base_assert.hpp

Go to the documentation of this file.

#pragma once
#include "../tunit_export.hpp"
#define __XTD_TUNIT_INTERNAL__
#include "__default_insert_basic_ostream_operator.hpp"
#include "__tunit_join__items.hpp"
#define __XTD_TUNIT_INTERNAL__
#include "abort_error.hpp"
#include "assert_error.hpp"
#include "ignore_error.hpp"
#include "settings.hpp"
#include <xtd/environment>
#include <xtd/math>
#include <xtd/static>
#include <xtd/types>
#include <xtd/typeof>
#include <xtd/string>
#include <xtd/diagnostics/assert>
#include <xtd/diagnostics/stack_frame>

namespace xtd {
  namespace tunit {
    class tunit_export_ base_assert static_ {
    public:
      
      static auto abort(const xtd::diagnostics::stack_frame& stack_frame = xtd::diagnostics::stack_frame::current()) -> void;
      static auto abort(const xtd::string& message, const xtd::diagnostics::stack_frame& stack_frame = xtd::diagnostics::stack_frame::current()) -> void;
      
      static auto fail(const xtd::diagnostics::stack_frame& stack_frame = xtd::diagnostics::stack_frame::current()) -> void;
      static auto fail(const xtd::string& message, const xtd::diagnostics::stack_frame& stack_frame = xtd::diagnostics::stack_frame::current()) -> void;
      
      static auto ignore(const xtd::diagnostics::stack_frame& stack_frame = xtd::diagnostics::stack_frame::current()) -> void;
      static auto ignore(const xtd::string& message, const xtd::diagnostics::stack_frame& stack_frame = xtd::diagnostics::stack_frame::current()) -> void;
      
      static auto succeed(const xtd::diagnostics::stack_frame& stack_frame = xtd::diagnostics::stack_frame::current()) -> void;
      static auto succeed(const xtd::string& message, const xtd::diagnostics::stack_frame& stack_frame = xtd::diagnostics::stack_frame::current()) -> void;
      
    protected:
      
      static auto error() -> void;
      static auto error(const xtd::string& message) -> void;
      static auto error(const xtd::string& actual, const xtd::string& expected, const xtd::string& message, const xtd::diagnostics::stack_frame& stack_frame = xtd::diagnostics::stack_frame::current()) -> void;
      
      static auto fail(const xtd::string& actual, const xtd::string& expected, const xtd::string& message, const xtd::diagnostics::stack_frame& stack_frame = xtd::diagnostics::stack_frame::current()) -> void {
        if (!test_fail(actual, expected, message, stack_frame) && xtd::environment::compiler_version().build_type() == build_type::debug) {
          auto msg = message != xtd::string {""} ? message : xtd::string {"assertion failed!"}; // Force asyle do not remove {}
          assert_(false, msg);
        } else { /*if (xtd::environment::target_type().is_test_application())*/
          if (settings::default_settings().break_on_failure() && xtd::diagnostics::debugger::is_attached()) debug_break_();
          throw assert_error(message != xtd::string {""} ? message : xtd::string {"assertion failed!"});
        }
      }
      
      template<typename value_t>
      static auto to_string(const value_t& value) -> xtd::string {return __tunit_to_string(value);}
      template<typename value_t>
      static auto to_string(const value_t* value) -> xtd::string {return __tunit_to_string(value);}
      
      template<typename collection_t>
      static auto join_items(const collection_t& collection) -> xtd::string {return __tunit_join__items(collection);}
      static auto join_items(const xtd::string& str) -> xtd::string;
      
      
      template<typename value_a_t, typename value_b_t>
      [[nodiscard]] static auto equals(const value_a_t& value_a, const value_b_t& value_b) -> bool {
        return value_a == value_b;
      }

      template<typename char_t>
      [[nodiscard]] static auto equals(const char_t* value_a, const string& value_b) -> bool {
        return xtd::string {value_a} == value_b;
      }

      template<typename char_t>
      [[nodiscard]] static auto equals(const string&  value_a, const char_t* value_b) -> bool {
        return value_a == xtd::string {value_b};
      }

      [[nodiscard]] static auto equals(long double value_a, long double value_b) -> bool {
        return equals(value_a, value_b, 0.0001l);
      }

      [[nodiscard]] static auto equals(double value_a, double value_b) -> bool {
        return equals(value_a, value_b, 0.0001);
      }

      [[nodiscard]] static auto equals(float value_a, float value_b) -> bool {
        return equals(value_a, value_b, 0.0001f);
      }

      [[nodiscard]] static auto equals(double value_a, double value_b, double tolerance) -> bool {
        return value_a == value_b ? true : xtd::math::abs(value_a - value_b) <= (xtd::math::abs(tolerance) * xtd::math::max(xtd::math::abs(value_a), xtd::math::abs(value_b)));
      }

      [[nodiscard]] static auto equals(long double value_a, long double value_b, long double tolerance) -> bool {
        return value_a == value_b ? true : xtd::math::abs(value_a - value_b) <= (xtd::math::abs(tolerance) * xtd::math::max(xtd::math::abs(value_a), xtd::math::abs(value_b)));
      }

      [[nodiscard]] static auto equals(float value_a, float value_b, float tolerance) -> bool {
        return value_a == value_b ? true : xtd::math::abs(value_a - value_b) <= (xtd::math::abs(tolerance) * xtd::math::max(xtd::math::abs(value_a), xtd::math::abs(value_b)));
      }

      
    private:
      static auto test_fail(const xtd::string& expected, const xtd::string& actual, const xtd::string& message, const xtd::diagnostics::stack_frame& stack_frame) -> bool;
    };
  }
}