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 void abort(const xtd::diagnostics::stack_frame& stack_frame = xtd::diagnostics::stack_frame::current());
      static void abort(const xtd::string& message, const xtd::diagnostics::stack_frame& stack_frame = xtd::diagnostics::stack_frame::current());
      
      static void fail(const xtd::diagnostics::stack_frame& stack_frame = xtd::diagnostics::stack_frame::current());
      static void fail(const xtd::string& message, const xtd::diagnostics::stack_frame& stack_frame = xtd::diagnostics::stack_frame::current());
      
      static void ignore(const xtd::diagnostics::stack_frame& stack_frame = xtd::diagnostics::stack_frame::current());
      static void ignore(const xtd::string& message, const xtd::diagnostics::stack_frame& stack_frame = xtd::diagnostics::stack_frame::current());
      
      static void succeed(const xtd::diagnostics::stack_frame& stack_frame = xtd::diagnostics::stack_frame::current());
      static void succeed(const xtd::string& message, const xtd::diagnostics::stack_frame& stack_frame = xtd::diagnostics::stack_frame::current());
      
    protected:
      
      static void error();
      static void error(const xtd::string& message);
      static void 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());
      
      static void 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()) {
        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<class value_t>
      static xtd::string to_string(const value_t& value) {return __tunit_to_string(value);}
      template<class value_t>
      static xtd::string to_string(const value_t* value) {return __tunit_to_string(value);}
      
      template<class collection_t>
      static xtd::string join_items(const collection_t& collection) {return __tunit_join__items(collection);}
      static xtd::string join_items(const xtd::string& str);
      
      
      template<class value_a_t, class value_b_t>
      static bool equals(const value_a_t& value_a, const value_b_t& value_b) {
        return value_a == value_b;
      }

      template<class char_t>
      static bool equals(const char_t* value_a, const string& value_b) {
        return xtd::string {value_a} == value_b;
      }

      template<class char_t>
      static bool equals(const string&  value_a, const char_t* value_b) {
        return value_a == xtd::string {value_b};
      }

      static bool equals(long double value_a, long double value_b) {
        return equals(value_a, value_b, 0.0001l);
      }

      static bool equals(double value_a, double value_b) {
        return equals(value_a, value_b, 0.0001);
      }

      static bool equals(float value_a, float value_b) {
        return equals(value_a, value_b, 0.0001f);
      }

      static bool equals(double value_a, double value_b, double tolerance) {
        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)));
      }

      static bool equals(long double value_a, long double value_b, long double tolerance) {
        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)));
      }

      static bool equals(float value_a, float value_b, float tolerance) {
        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 bool test_fail(const xtd::string& expected, const xtd::string& actual, const xtd::string& message, const xtd::diagnostics::stack_frame& stack_frame);
    };
  }
}