tunit - Reference Guide  1.0.0
Modern c++17 unit testing framework on Windows, macOS, Linux, iOS and android.
assert.h
Go to the documentation of this file.
1 #pragma once
4 #include "base_assert.h"
5 #include <algorithm>
6 #include <cmath>
7 #include <cstring>
8 #include <exception>
9 #include <functional>
10 #include <iterator>
11 #include <memory>
12 #include <string>
13 
15 #ifdef assert
16 #undef assert
17 #endif
18 
21 namespace tunit {
26  class assert final : public base_assert {
27  public:
29  assert() = delete;
31 
41  template<typename TExpected, typename TActual>
42  static void are_equal(const TExpected& expected, const TActual& actual) {are_equal(expected, actual, "", line_info());}
43 
54  template<typename TExpected, typename TActual>
55  static void are_equal(const TExpected& expected, const TActual& actual, const tunit::line_info& line_info) {are_equal(expected, actual, "", line_info);}
56 
67  template<typename TExpected, typename TActual>
68  static void are_equal(const TExpected& expected, const TActual& actual, const std::string& message) {are_equal(expected, actual, message, line_info());}
69 
81  template<typename TExpected, typename TActual>
82  static void are_equal(const TExpected& expected, const TActual& actual, const std::string& message, const tunit::line_info& line_info) {
83  if (actual == expected)
84  succeed(message, line_info);
85  else
86  base_assert::fail(base_assert::to_string(expected), base_assert::to_string(actual), message, line_info);
87  }
88 
90  static void are_equal(const char* expected, const char* actual, const std::string& message, const tunit::line_info& line_info) {
91  if (strcmp(actual, expected) == 0)
92  succeed(message, line_info);
93  else
94  base_assert::fail(base_assert::to_string(expected), base_assert::to_string(actual), message, line_info);
95  }
96 
97  static void are_equal(const char16_t* expected, const char16_t* actual, const std::string& message, const tunit::line_info& line_info) {
98  if (std::u16string(actual) == std::u16string(expected))
99  succeed(message, line_info);
100  else
101  base_assert::base_assert::fail(base_assert::to_string(expected), base_assert::to_string(actual), message, line_info);
102  }
103 
104  static void are_equal(const char32_t* expected, const char32_t* actual, const std::string& message, const tunit::line_info& line_info) {
105  if (std::u32string(actual) == std::u32string(expected))
106  succeed(message, line_info);
107  else
108  base_assert::fail(base_assert::to_string(expected), base_assert::to_string(actual), message, line_info);
109  }
110 
111  static void are_equal(const wchar_t* expected, const wchar_t* actual, const std::string& message, const tunit::line_info& line_info) {
112  if (wcscmp(actual, expected) == 0)
113  succeed(message, line_info);
114  else
115  base_assert::fail(base_assert::to_string(expected), base_assert::to_string(actual), message, line_info);
116  }
117 
118  static void are_equal(float expected, float actual, const std::string& message, const tunit::line_info& line_info) {
119  if (std::isnan(actual) && std::isnan(expected))
120  succeed(message, line_info);
121  else if (actual == expected)
122  succeed(message, line_info);
123  else
124  base_assert::fail(base_assert::to_string(expected), base_assert::to_string(actual), message, line_info);
125  }
126 
127  static void are_equal(double expected, double actual, const std::string& message, const tunit::line_info& line_info) {
128  if (std::isnan(actual) && std::isnan(expected))
129  succeed(message, line_info);
130  else if (actual == expected)
131  succeed(message, line_info);
132  else
133  base_assert::fail(base_assert::to_string(expected), base_assert::to_string(actual), message, line_info);
134  }
135 
136  static void are_equal(long double expected, long double actual, const std::string& message, const tunit::line_info& line_info) {
137  if (std::isnan(actual) && std::isnan(expected))
138  succeed(message, line_info);
139  else if (actual == expected)
140  succeed(message, line_info);
141  else
142  base_assert::fail(base_assert::to_string(expected), base_assert::to_string(actual), message, line_info);
143  }
145 
157  static void are_equal(float expected, float actual, float tolerance) {are_equal(expected, actual, tolerance, "", line_info_);}
158 
171  static void are_equal(float expected, float actual, float tolerance, const tunit::line_info& line_info) {are_equal(expected, actual, tolerance, "", line_info);}
172 
185  static void are_equal(float expected, float& actual, float tolerance, const std::string& message) {are_equal(expected, actual, tolerance, message, line_info());}
186 
200  static void are_equal(float expected, float actual, float tolerance, const std::string& message, const tunit::line_info& line_info) {
201  if (fabsf(expected - actual) <= fabsf(tolerance))
202  succeed(message, line_info);
203  else
204  base_assert::fail(base_assert::to_string(expected), base_assert::to_string(actual), message, line_info);
205  }
206 
218  static void are_equal(double expected, double actual, double tolerance) {are_equal(expected, actual, tolerance, "", line_info_);}
219 
232  static void are_equal(double expected, double actual, double tolerance, const tunit::line_info& line_info) {are_equal(expected, actual, tolerance, "", line_info);}
233 
246  static void are_equal(double expected, double actual, double tolerance, const std::string& message) {are_equal(expected, actual, tolerance, message, line_info());}
247 
261  static void are_equal(double expected, double actual, double tolerance, const std::string& message, const tunit::line_info& line_info) {
262  if (fabs(expected - actual) <= fabs(tolerance))
263  succeed(message, line_info);
264  else
265  base_assert::fail(base_assert::to_string(expected), base_assert::to_string(actual), message, line_info);
266  }
267 
279  static void are_equal(long double expected, long double actual, long double tolerance) {are_equal(expected, actual, tolerance, "", line_info_);}
280 
293  static void are_equal(long double expected, long double actual, long double tolerance, const tunit::line_info& line_info) {are_equal(expected, actual, tolerance, "", line_info);}
294 
307  static void are_equal(long double expected, long double actual, long double tolerance, const std::string& message) {are_equal(expected, actual, tolerance, message, line_info());}
308 
322  static void are_equal(long double expected, long double actual, long double tolerance, const std::string& message, const tunit::line_info& line_info) {
323  if (fabsl(expected - actual) <= fabsl(tolerance))
324  succeed(message, line_info);
325  else
326  base_assert::fail(base_assert::to_string(expected), base_assert::to_string(actual), message, line_info);
327  }
328 
338  template<typename TExpected, typename TActual>
339  static void are_not_equal(const TExpected& expected, const TActual& actual) {are_not_equal(expected, actual, "", line_info());}
340 
351  template<typename TExpected, typename TActual>
352  static void are_not_equal(const TExpected& expected, const TActual& actual, const tunit::line_info& line_info) {are_not_equal(expected, actual, "", line_info);}
353 
364  template<typename TExpected, typename TActual>
365  static void are_not_equal(const TExpected& expected, const TActual& actual, const std::string& message) {are_not_equal(expected, actual, message, line_info());}
366 
378  template<typename TExpected, typename TActual>
379  static void are_not_equal(const TExpected& expected, const TActual& actual, const std::string& message, const tunit::line_info& line_info) {
380  if (actual != expected)
381  succeed(message, line_info);
382  else
383  base_assert::fail("not " + base_assert::to_string(expected), base_assert::to_string(actual), message, line_info);
384  }
385 
387  static void are_not_equal(const char* expected, const char* actual, const std::string& message, const tunit::line_info& line_info) {
388  if (strcmp(actual, expected) != 0)
389  succeed(message, line_info);
390  else
391  base_assert::fail("not " + base_assert::to_string(expected), base_assert::to_string(actual), message, line_info);
392  }
393 
394  static void are_not_equal(const char16_t* expected, const char16_t* actual, const std::string& message, const tunit::line_info& line_info) {
395  if (std::u16string(actual) != std::u16string(expected))
396  succeed(message, line_info);
397  else
398  base_assert::fail("not " + base_assert::to_string(expected), base_assert::to_string(actual), message, line_info);
399  }
400 
401  static void are_not_equal(const char32_t* expected, const char32_t* actual, const std::string& message, const tunit::line_info& line_info) {
402  if (std::u32string(actual) != std::u32string(expected))
403  succeed(message, line_info);
404  else
405  base_assert::fail("not " + base_assert::to_string(expected), base_assert::to_string(actual), message, line_info);
406  }
407 
408  static void are_not_equal(const wchar_t* expected, const wchar_t* actual, const std::string& message, const tunit::line_info& line_info) {
409  if (wcscmp(actual, expected) != 0)
410  succeed(message, line_info);
411  else
412  base_assert::fail("not " + base_assert::to_string(expected), base_assert::to_string(actual), message, line_info);
413  }
415 
428  template<typename TExpected, typename TActual>
429  static void are_not_same(const TExpected& expected, const TActual& actual) {are_not_same(expected, actual, "", line_info());}
430 
444  template<typename TExpected, typename TActual>
445  static void are_not_same(const TExpected& expected, const TActual& actual, const tunit::line_info& line_info) {are_not_same(expected, actual, "", line_info);}
446 
460  template<typename TExpected, typename TActual>
461  static void are_not_same(const TExpected& expected, const TActual& actual, const std::string& message) {are_not_same(expected, actual, message, line_info());}
462 
477  template<typename TExpected, typename TActual>
478  static void are_not_same(const TExpected& expected, const TActual& actual, const std::string& message, const tunit::line_info& line_info) {
479  if (&actual != &expected)
480  succeed(message, line_info);
481  else
482  base_assert::fail("not same as " + base_assert::to_string(expected), base_assert::to_string(actual), message, line_info);
483  }
484 
497  template<typename TExpected, typename TActual>
498  static void are_same(const TExpected& expected, const TActual& actual) {are_same(expected, actual, "", line_info());}
499 
513  template<typename TExpected, typename TActual>
514  static void are_same(const TExpected& expected, const TActual& actual, const tunit::line_info& line_info) {are_same(expected, actual, "", line_info);}
515 
529  template<typename TExpected, typename TActual>
530  static void are_same(const TExpected& expected, const TActual& actual, const std::string& message) {are_same(expected, actual, message, line_info());}
531 
546  template<typename TExpected, typename TActual>
547  static void are_same(const TExpected& expected, const TActual& actual, const std::string& message, const tunit::line_info& line_info) {
548  if (&actual == &expected)
549  succeed(message, line_info);
550  else
551  base_assert::fail("same as " + base_assert::to_string(expected), base_assert::to_string(actual), message, line_info);
552  }
553 
564  template<typename TItem, typename TCollection>
565  static void contains(const TItem& item, const TCollection& collection) {contains(item, collection, "", line_info());}
566 
578  template<typename TItem, typename TCollection>
579  static void contains(const TItem& item, const TCollection& collection, const tunit::line_info& line_info) {contains(item, collection, "", line_info);}
580 
592  template<typename TItem, typename TCollection>
593  static void contains(const TItem& item, const TCollection& collection, const std::string& message) {contains(item, collection, message, line_info());}
594 
607  template<typename TItem, typename TCollection>
608  static void contains(const TItem& item, const TCollection& collection, const std::string& message, const tunit::line_info& line_info) {
609  auto result = std::find(collection.begin(), collection.end(), item);
610  if (result != collection.end())
611  succeed(message, line_info);
612  else
613  base_assert::fail("collection containing " + base_assert::to_string(item), base_assert::join_items(collection), message, line_info);
614  }
615 
617  template<typename TItem, typename TValue>
618  static void contains(const TItem& item, const std::initializer_list<TValue>& values) {contains(item, values, "", line_info());}
619  template<typename TItem, typename TValue>
620  static void contains(const TItem& item, const std::initializer_list<TValue>& values, const tunit::line_info& line_info) {contains(item, values, "", line_info);}
621  template<typename TItem, typename TValue>
622  static void contains(const TItem& item, const std::initializer_list<TValue>& values, const std::string& message) {contains(item, values, message, line_info());}
623  template<typename TItem, typename TValue>
624  static void contains(const TItem& item, const std::initializer_list<TValue>& values, const std::string& message, const tunit::line_info& line_info) {
625  auto result = std::find(values.begin(), values.end(), item);
626  if (result != values.end())
627  succeed(message, line_info);
628  else
629  base_assert::fail("collection containing " + base_assert::to_string(item), base_assert::join_items(values), message, line_info);
630  }
631 
632  static void contains(char item, const char* values, const std::string& message, const tunit::line_info& line_info) {
633  std::string s(values);
634  auto result = std::find(s.begin(), s.end(), item);
635  if (result != s.end())
636  succeed(message, line_info);
637  else
638  base_assert::fail("collection containing " + base_assert::to_string(item), base_assert::join_items(s), message, line_info);
639  }
640 
641  static void contains(char16_t item, const char16_t* values, const std::string& message, const tunit::line_info& line_info) {
642  std::u16string s(values);
643  auto result = std::find(s.begin(), s.end(), item);
644  if (result != s.end())
645  succeed(message, line_info);
646  else
647  base_assert::fail("collection containing " + base_assert::to_string(item), base_assert::join_items(s), message, line_info);
648  }
649 
650  static void contains(char32_t item, const char32_t* values, const std::string& message, const tunit::line_info& line_info) {
651  std::u32string s(values);
652  auto result = std::find(s.begin(), s.end(), item);
653  if (result != s.end())
654  succeed(message, line_info);
655  else
656  base_assert::fail("collection containing " + base_assert::to_string(item), base_assert::join_items(s), message, line_info);
657  }
658 
659  static void contains(wchar_t item, const wchar_t* values, const std::string& message, const tunit::line_info& line_info) {
660  std::wstring s(values);
661  auto result = std::find(s.begin(), s.end(), item);
662  if (result != s.end())
663  succeed(message, line_info);
664  else
665  base_assert::fail("collection containing " + base_assert::to_string(item), base_assert::join_items(s), message, line_info);
666  }
668 
678  static void does_not_throw(const std::function<void()>& statement) {does_not_throw(statement, "", line_info());}
679 
690  static void does_not_throw(const std::function<void()>& statement, const tunit::line_info& line_info) {does_not_throw(statement, "", line_info);}
691 
702  static void does_not_throw(const std::function<void()>& statement, const std::string& message) {does_not_throw(statement, message, line_info());}
703 
715  static void does_not_throw(const std::function<void()>& statement, const std::string& message, const tunit::line_info& line_info) {
716  try {
717  statement();
718  succeed(message, line_info);
719  } catch (const std::exception& e) {
720  base_assert::fail("No Exception to be thrown", "<" + __tunit_demangle(typeid(e).name()) + ">", message, line_info);
721  } catch (...) {
722  base_assert::fail("No Exception to be thrown", "<exception>", message, line_info);
723  }
724  }
725 
736  template<typename TValue>
737  static void is_empty(const TValue& value) {is_empty(value, "", line_info());}
738 
750  template<typename TValue>
751  static void is_empty(const TValue& value, const tunit::line_info& line_info) {is_empty(value, "", line_info);}
752 
764  template<typename TValue>
765  static void is_empty(const TValue& value, const std::string& message) {is_empty(value, message, line_info());}
766 
779  template<typename TValue>
780  static void is_empty(const TValue& value, const std::string& message, const tunit::line_info& line_info) {
781  if (std::empty(value))
782  succeed(message, line_info);
783  else
784  base_assert::fail("collection <empty>", base_assert::join_items(value), message, line_info);
785  }
786 
788  template<typename TValue>
789  static void is_empty(const std::initializer_list<TValue>& value) {is_empty(value, "", line_info());}
790  template<typename TValue>
791  static void is_empty(const std::initializer_list<TValue>& value, const tunit::line_info& line_info) {is_empty(value, "", line_info);}
792  template<typename TValue>
793  static void is_empty(const std::initializer_list<TValue>& value, const std::string& message) {is_empty(value, message, line_info());}
794  template<typename TValue>
795  static void is_empty(const std::initializer_list<TValue>& values, const std::string& message, const tunit::line_info& line_info) {
796  if (std::empty(values))
797  succeed(message, line_info);
798  else
799  base_assert::fail("collection <empty>", base_assert::join_items(values), message, line_info);
800  }
801 
802  static void is_empty(const char* value, const std::string& message, const tunit::line_info& line_info) {
803  std::string s(value);
804  if (std::empty(s))
805  succeed(message, line_info);
806  else
807  base_assert::fail("collection <empty>", base_assert::join_items(s), message, line_info);
808  }
809 
810  static void is_empty(const char16_t* value, const std::string& message, const tunit::line_info& line_info) {
811  std::u16string s(value);
812  if (std::empty(s))
813  succeed(message, line_info);
814  else
815  base_assert::fail("collection <empty>", base_assert::join_items(s), message, line_info);
816  }
817 
818  static void is_empty(const char32_t* value, const std::string& message, const tunit::line_info& line_info) {
819  std::u32string s(value);
820  if (std::empty(s))
821  succeed(message, line_info);
822  else
823  base_assert::fail("collection <empty>", base_assert::join_items(s), message, line_info);
824  }
825 
826  static void is_empty(const wchar_t* value, const std::string& message, const tunit::line_info& line_info) {
827  std::wstring s(value);
828  if (std::empty(s))
829  succeed(message, line_info);
830  else
831  base_assert::fail("collection <empty>", base_assert::join_items(s), message, line_info);
832  }
834 
845  static void is_false(bool condition) {is_false(condition, "", line_info());}
846 
858  static void is_false(bool condition, const tunit::line_info& line_info) {is_false(condition, "", line_info);}
859 
871  static void is_false(bool condition, const std::string& message) {is_false(condition, message, line_info());}
872 
885  static void is_false(bool condition, const std::string& message, const tunit::line_info& line_info) {
886  if (condition == false)
887  succeed(message, line_info);
888  else
889  base_assert::fail("false", "true", message, line_info);
890  }
891 
901  template<typename TValue1, typename TValue2>
902  static void is_greater(const TValue1& val1, const TValue2& val2) {is_greater(val1, val2, "", line_info());}
903 
914  template<typename TValue1, typename TValue2>
915  static void is_greater(const TValue1& val1, const TValue2& val2, const tunit::line_info& line_info) {is_greater(val1, val2, "", line_info);}
916 
927  template<typename TValue1, typename TValue2>
928  static void is_greater(const TValue1& val1, const TValue2& val2, const std::string& message) {is_greater(val1, val2, message, line_info());}
929 
941  template<typename TValue1, typename TValue2>
942  static void is_greater(const TValue1& val1, const TValue2& val2, const std::string& message, const tunit::line_info& line_info) {
943  if (val1 > val2)
944  succeed(message, line_info);
945  else
946  base_assert::fail("greater than " + base_assert::to_string(val2), base_assert::to_string(val1), message, line_info);
947  }
948 
950  static void is_greater(const char* val1, const char* val2, const std::string& message, const tunit::line_info& line_info) {
951  if (strcmp(val1, val2) > 0)
952  succeed(message, line_info);
953  else
954  base_assert::fail("greather than " + base_assert::to_string(val2), base_assert::to_string(val1), message, line_info);
955  }
956 
957  static void is_greater(const char16_t* val1, const char16_t* val2, const std::string& message, const tunit::line_info& line_info) {
958  if (std::u16string(val1) > std::u16string(val2))
959  succeed(message, line_info);
960  else
961  base_assert::fail("greather than " + base_assert::to_string(val2), base_assert::to_string(val1), message, line_info);
962  }
963 
964  static void is_greater(const char32_t* val1, const char32_t* val2, const std::string& message, const tunit::line_info& line_info) {
965  if (std::u32string(val1) > std::u32string(val2))
966  succeed(message, line_info);
967  else
968  base_assert::fail("greather than " + base_assert::to_string(val2), base_assert::to_string(val1), message, line_info);
969  }
970 
971  static void is_greater(const wchar_t* val1, const wchar_t* val2, const std::string& message, const tunit::line_info& line_info) {
972  if (wcscmp(val1, val2) > 0)
973  succeed(message, line_info);
974  else
975  base_assert::fail("greather than " + base_assert::to_string(val2), base_assert::to_string(val1), message, line_info);
976  }
978 
989  template<typename TValue1, typename TValue2>
990  static void is_greater_or_equal(const TValue1& val1, const TValue2& val2) {is_greater_or_equal(val1, val2, "", line_info());}
991 
1003  template<typename TValue1, typename TValue2>
1004  static void is_greater_or_equal(const TValue1& val1, const TValue2& val2, const tunit::line_info& line_info) {is_greater_or_equal(val1, val2, "", line_info);}
1005 
1017  template<typename TValue1, typename TValue2>
1018  static void is_greater_or_equal(const TValue1& val1, const TValue2& val2, const std::string& message) {is_greater_or_equal(val1, val2, message, line_info());}
1019 
1032  template<typename TValue1, typename TValue2>
1033  static void is_greater_or_equal(const TValue1& val1, const TValue2& val2, const std::string& message, const tunit::line_info& line_info) {
1034  if (val1 >= val2)
1035  succeed(message, line_info);
1036  else
1037  base_assert::fail("greater than or equal to " + base_assert::to_string(val2), base_assert::to_string(val1), message, line_info);
1038  }
1039 
1041  static void is_greater_or_equal(const char* val1, const char* val2, const std::string& message, const tunit::line_info& line_info) {
1042  if (strcmp(val1, val2) >= 0)
1043  succeed(message, line_info);
1044  else
1045  base_assert::fail("greather than or equal to " + base_assert::to_string(val2), base_assert::to_string(val1), message, line_info);
1046  }
1047 
1048  static void is_greater_or_equal(const char16_t* val1, const char16_t* val2, const std::string& message, const tunit::line_info& line_info) {
1049  if (std::u16string(val1) >= std::u16string(val2))
1050  succeed(message, line_info);
1051  else
1052  base_assert::fail("greather than " + base_assert::to_string(val2), base_assert::to_string(val1), message, line_info);
1053  }
1054 
1055  static void is_greater_or_equal(const char32_t* val1, const char32_t* val2, const std::string& message, const tunit::line_info& line_info) {
1056  if (std::u32string(val1) >= std::u32string(val2))
1057  succeed(message, line_info);
1058  else
1059  base_assert::fail("greather than " + base_assert::to_string(val2), base_assert::to_string(val1), message, line_info);
1060  }
1061 
1062  static void is_greater_or_equal(const wchar_t* val1, const wchar_t* val2, const std::string& message, const tunit::line_info& line_info) {
1063  if (wcscmp(val1, val2) >= 0)
1064  succeed(message, line_info);
1065  else
1066  base_assert::fail("greather than or equal to " + base_assert::to_string(val2), base_assert::to_string(val1), message, line_info);
1067  }
1069 
1079  template<typename Type, typename TValue>
1080  static void is_instance_of(const TValue& value) {is_instance_of<Type>(value, "", line_info());}
1081 
1092  template<typename Type, typename TValue>
1093  static void is_instance_of(const TValue& value, const tunit::line_info& line_info) {is_instance_of<Type>(value, "", line_info);}
1094 
1105  template<typename Type, typename TValue>
1106  static void is_instance_of(const TValue& value, const std::string& message) {is_instance_of<Type>(value, message, line_info());}
1107 
1119  template<typename Type, typename TValue>
1120  static void is_instance_of(const TValue& value, const std::string& message, const tunit::line_info& line_info) {
1121  if (dynamic_cast<const Type*>(&value) != nullptr)
1122  succeed(message, line_info);
1123  else
1124  base_assert::fail("instance of <" + __tunit_demangle(typeid(Type).name()) + ">", "<" + __tunit_demangle(typeid(value).name()) + ">", message, line_info);
1125  }
1126 
1136  template<typename TValue1, typename TValue2>
1137  static void is_less(const TValue1& val1, const TValue2& val2) {is_less(val1, val2, "", line_info());}
1138 
1149  template<typename TValue1, typename TValue2>
1150  static void is_less(const TValue1& val1, const TValue2& val2, const tunit::line_info& line_info) {is_less(val1, val2, "", line_info);}
1151 
1162  template<typename TValue1, typename TValue2>
1163  static void is_less(const TValue1& val1, const TValue2& val2, const std::string& message) {is_less(val1, val2, message, line_info());}
1164 
1176  template<typename TValue1, typename TValue2>
1177  static void is_less(const TValue1& val1, const TValue2& val2, const std::string& message, const tunit::line_info& line_info) {
1178  if (val1 < val2)
1179  succeed(message, line_info);
1180  else {
1181  base_assert::fail("less than " + base_assert::to_string(val2), base_assert::to_string(val1), message, line_info);
1182  }
1183  }
1184 
1186  static void is_less(const char* val1, const char* val2, const std::string& message, const tunit::line_info& line_info) {
1187  if (strcmp(val1, val2) < 0)
1188  succeed(message, line_info);
1189  else
1190  base_assert::fail("less than " + base_assert::to_string(val2), base_assert::to_string(val1), message, line_info);
1191  }
1192 
1193  static void is_less(const char16_t* val1, const char16_t* val2, const std::string& message, const tunit::line_info& line_info) {
1194  if (std::u16string(val1) < std::u16string(val2))
1195  succeed(message, line_info);
1196  else
1197  base_assert::fail("greather than " + base_assert::to_string(val2), base_assert::to_string(val1), message, line_info);
1198  }
1199 
1200  static void is_less(const char32_t* val1, const char32_t* val2, const std::string& message, const tunit::line_info& line_info) {
1201  if (std::u32string(val1) < std::u32string(val2))
1202  succeed(message, line_info);
1203  else
1204  base_assert::fail("greather than " + base_assert::to_string(val2), base_assert::to_string(val1), message, line_info);
1205  }
1206 
1207  static void is_less(const wchar_t* val1, const wchar_t* val2, const std::string& message, const tunit::line_info& line_info) {
1208  if (wcscmp(val1, val2) < 0)
1209  succeed(message, line_info);
1210  else
1211  base_assert::fail("less than " + base_assert::to_string(val2), base_assert::to_string(val1), message, line_info);
1212  }
1214 
1225  template<typename TValue1, typename TValue2>
1226  static void is_less_or_equal(const TValue1& val1, const TValue2& val2) {is_less_or_equal(val1, val2, "", line_info());}
1227 
1239  template<typename TValue1, typename TValue2>
1240  static void is_less_or_equal(const TValue1& val1, const TValue2& val2, const tunit::line_info& line_info) {is_less_or_equal(val1, val2, "", line_info);}
1241 
1253  template<typename TValue1, typename TValue2>
1254  static void is_less_or_equal(const TValue1& val1, const TValue2& val2, const std::string& message) {is_less_or_equal(val1, val2, message, line_info());}
1255 
1268  template<typename TValue1, typename TValue2>
1269  static void is_less_or_equal(const TValue1& val1, const TValue2& val2, const std::string& message, const tunit::line_info& line_info) {
1270  if (val1 <= val2)
1271  succeed(message, line_info);
1272  else
1273  base_assert::fail("less than or equal to " + base_assert::to_string(val2), base_assert::to_string(val1), message, line_info);
1274  }
1275 
1277  static void is_less_or_equal(const char* val1, const char* val2, const std::string& message, const tunit::line_info& line_info) {
1278  if (strcmp(val1, val1) <= 0)
1279  succeed(message, line_info);
1280  else
1281  base_assert::fail("less than or equal to " + base_assert::to_string(val2), base_assert::to_string(val1), message, line_info);
1282  }
1283 
1284  static void is_less_or_equal(const char16_t* val1, const char16_t* val2, const std::string& message, const tunit::line_info& line_info) {
1285  if (std::u16string(val1) < std::u16string(val2))
1286  succeed(message, line_info);
1287  else
1288  base_assert::fail("greather than " + base_assert::to_string(val2), base_assert::to_string(val1), message, line_info);
1289  }
1290 
1291  static void is_less_or_equal(const char32_t* val1, const char32_t* val2, const std::string& message, const tunit::line_info& line_info) {
1292  if (std::u32string(val1) < std::u32string(val2))
1293  succeed(message, line_info);
1294  else
1295  base_assert::fail("greather than " + base_assert::to_string(val2), base_assert::to_string(val1), message, line_info);
1296  }
1297 
1298  static void is_less_or_equal(const wchar_t* val1, const wchar_t* val2, const std::string& message, const tunit::line_info& line_info) {
1299  if (wcscmp(val1, val1) <= 0)
1300  succeed(message, line_info);
1301  else
1302  base_assert::fail("less than or equal to " + base_assert::to_string(val2), base_assert::to_string(val1), message, line_info);
1303  }
1305 
1316  static void is_NaN(double value) {is_NaN(value, "", line_info());}
1317 
1329  static void is_NaN(double value, const tunit::line_info& line_info) {is_NaN(value, "", line_info);}
1330 
1342  static void is_NaN(double value, const std::string& message) {is_NaN(value, message, line_info());}
1343 
1356  static void is_NaN(double value, const std::string& message, const tunit::line_info& line_info) {
1357  if (std::isnan(value))
1358  succeed(message, line_info);
1359  else
1360  base_assert::fail("NaN", base_assert::to_string(value), message, line_info);
1361  }
1362 
1373  static void is_NaN(long double value) {is_NaN(value, "", line_info());}
1374 
1386  static void is_NaN(long double value, const tunit::line_info& line_info) {is_NaN(value, "", line_info);}
1387 
1399  static void is_NaN(long double value, const std::string& message) {is_NaN(value, message, line_info());}
1400 
1413  static void is_NaN(long double value, const std::string& message, const tunit::line_info& line_info) {
1414  if (std::isnan(value))
1415  succeed(message, line_info);
1416  else
1417  base_assert::fail("NaN", base_assert::to_string(value), message, line_info);
1418  }
1419 
1430  static void is_NaN(float value) {is_NaN(value, "", line_info());}
1431 
1443  static void is_NaN(float value, const tunit::line_info& line_info) {is_NaN(value, "", line_info);}
1444 
1456  static void is_NaN(float value, const std::string& message) {is_NaN(value, message, line_info());}
1457 
1470  static void is_NaN(float value, const std::string& message, const tunit::line_info& line_info) {
1471  if (std::isnan(value))
1472  succeed(message, line_info);
1473  else
1474  base_assert::fail("NaN", base_assert::to_string(value), message, line_info);
1475  }
1476 
1487  template<typename TValue>
1488  static void is_negative(const TValue& value) {is_negative(value, "", line_info());}
1489 
1501  template<typename TValue>
1502  static void is_negative(const TValue& value, const tunit::line_info& line_info) {is_negative(value, "", line_info);}
1503 
1515  template<typename TValue>
1516  static void is_negative(const TValue& value, const std::string& message) {is_negative(value, message, line_info());}
1517 
1530  template<typename TValue>
1531  static void is_negative(const TValue& value, const std::string& message, const tunit::line_info& line_info) {
1532  if (value < 0)
1533  succeed(message, line_info);
1534  else
1535  base_assert::fail("negative", base_assert::to_string(value), message, line_info);
1536  }
1537 
1548  template<typename TValue>
1549  static void is_not_empty(const TValue& value) {is_not_empty(value, "", line_info());}
1550 
1562  template<typename TValue>
1563  static void is_not_empty(const TValue& value, const tunit::line_info& line_info) {is_not_empty(value, "", line_info);}
1564 
1576  template<typename TValue>
1577  static void is_not_empty(const TValue& value, const std::string& message) {is_not_empty(value, message, line_info());}
1578 
1591  template<typename TValue>
1592  static void is_not_empty(const TValue& value, const std::string& message, const tunit::line_info& line_info) {
1593  if (!std::empty(value))
1594  succeed(message, line_info);
1595  else
1596  base_assert::fail("collection not <empty>", "<empty>", message, line_info);
1597  }
1598 
1600  template<typename TValue>
1601  static void is_not_empty(const std::initializer_list<TValue>& value) {is_not_empty(value, "", line_info());}
1602  template<typename TValue>
1603  static void is_not_empty(const std::initializer_list<TValue>& value, const tunit::line_info& line_info) {is_not_empty(value, "", line_info);}
1604  template<typename TValue>
1605  static void is_not_empty(const std::initializer_list<TValue>& value, const std::string& message) {is_not_empty(value, message, line_info());}
1606  template<typename TValue>
1607  static void is_not_empty(const std::initializer_list<TValue>& value, const std::string& message, const tunit::line_info& line_info) {
1608  if (!std::empty(value))
1609  succeed(message, line_info);
1610  else
1611  base_assert::fail("collection not <empty>", "<empty>", message, line_info);
1612  }
1613 
1614  static void is_not_empty(const char* value, const std::string& message, const tunit::line_info& line_info) {
1615  if (!std::empty(std::string(value)))
1616  succeed(message, line_info);
1617  else
1618  base_assert::fail("collection not <empty>", "<empty>", message, line_info);
1619  }
1620 
1621  static void is_not_empty(const char16_t* value, const std::string& message, const tunit::line_info& line_info) {
1622  if (!std::empty(std::u16string(value)))
1623  succeed(message, line_info);
1624  else
1625  base_assert::fail("collection not <empty>", "<empty>", message, line_info);
1626  }
1627 
1628  static void is_not_empty(const char32_t* value, const std::string& message, const tunit::line_info& line_info) {
1629  if (!std::empty(std::u32string(value)))
1630  succeed(message, line_info);
1631  else
1632  base_assert::fail("collection not <empty>", "<empty>", message, line_info);
1633  }
1634 
1635  static void is_not_empty(const wchar_t* value, const std::string& message, const tunit::line_info& line_info) {
1636  if (!std::empty(std::wstring(value)))
1637  succeed(message, line_info);
1638  else
1639  base_assert::fail("collection not <empty>", "<empty>", message, line_info);
1640  }
1642 
1652  template<typename Type, typename TValue>
1653  static void is_not_instance_of(const TValue& value) {is_not_instance_of<Type>(value, "", line_info());}
1654 
1665  template<typename Type, typename TValue>
1666  static void is_not_instance_of(const TValue& value, const tunit::line_info& line_info) {is_not_instance_of<Type>(value, "", line_info);}
1667 
1678  template<typename Type, typename TValue>
1679  static void is_not_instance_of(const TValue& value, const std::string& message) {is_not_instance_of<Type>(value, message, line_info());}
1680 
1692  template<typename Type, typename TValue>
1693  static void is_not_instance_of(const TValue& value, const std::string& message, const tunit::line_info& line_info) {
1694  if (dynamic_cast<const Type*>(&value) == nullptr)
1695  succeed(message, line_info);
1696  else
1697  base_assert::fail("not instance of <" + __tunit_demangle(typeid(Type).name()) + ">", "<" + __tunit_demangle(typeid(value).name()) + ">", message, line_info);
1698  }
1699 
1711  template<typename TPointer>
1712  static void is_not_null(const TPointer* pointer) {is_not_null(pointer, "", line_info());}
1713 
1726  template<typename TPointer>
1727  static void is_not_null(const TPointer* pointer, const tunit::line_info& line_info) {is_not_null(pointer, "", line_info);}
1728 
1741  template<typename TPointer>
1742  static void is_not_null(const TPointer* pointer, const std::string& message) {is_not_null(pointer, message, line_info());}
1743 
1757  template<typename TPointer>
1758  static void is_not_null(const TPointer* pointer, const std::string& message, const tunit::line_info& line_info) {
1759  if (pointer != nullptr)
1760  succeed(message, line_info);
1761  else
1762  base_assert::fail("not null", "null", message, line_info);
1763  }
1764 
1775  template<typename TPointer>
1776  static void is_not_null(const std::unique_ptr<TPointer>& pointer) {is_not_null(pointer, "", line_info());}
1777 
1789  template<typename TPointer>
1790  static void is_not_null(const std::unique_ptr<TPointer>& pointer, const tunit::line_info& line_info) {is_not_null(pointer, "", line_info);}
1791 
1803  template<typename TPointer>
1804  static void is_not_null(const std::unique_ptr<TPointer>& pointer, const std::string& message) {is_not_null(pointer, message, line_info());}
1805 
1818  template<typename TPointer>
1819  static void is_not_null(const std::unique_ptr<TPointer>& pointer, const std::string& message, const tunit::line_info& line_info) {
1820  if (pointer != nullptr)
1821  succeed(message, line_info);
1822  else
1823  base_assert::fail("not null", "null", message, line_info);
1824  }
1825 
1836  template<typename TPointer>
1837  static void is_not_null(const std::shared_ptr<TPointer>& pointer) {is_not_null(pointer, "", line_info());}
1838 
1850  template<typename TPointer>
1851  static void is_not_null(const std::shared_ptr<TPointer>& pointer, const tunit::line_info& line_info) {is_not_null(pointer, "", line_info);}
1852 
1864  template<typename TPointer>
1865  static void is_not_null(const std::shared_ptr<TPointer>& pointer, const std::string& message) {is_not_null(pointer, message, line_info());}
1866 
1879  template<typename TPointer>
1880  static void is_not_null(const std::shared_ptr<TPointer>& pointer, const std::string& message, const tunit::line_info& line_info) {
1881  if (pointer != nullptr)
1882  succeed(message, line_info);
1883  else
1884  base_assert::fail("not null", "null", message, line_info);
1885  }
1886 
1898  template<typename TPointer>
1899  static void is_not_null(const std::weak_ptr<TPointer>& pointer) {is_not_null(pointer, "", line_info());}
1900 
1913  template<typename TPointer>
1914  static void is_not_null(const std::weak_ptr<TPointer>& pointer, const tunit::line_info& line_info) {is_not_null(pointer, "", line_info);}
1915 
1928  template<typename TPointer>
1929  static void is_not_null(const std::weak_ptr<TPointer>& pointer, const std::string& message) {is_not_null(pointer, message, line_info());}
1930 
1944  template<typename TPointer>
1945  static void is_not_null(const std::weak_ptr<TPointer>& pointer, const std::string& message, const tunit::line_info& line_info) {succeed(message, line_info);}
1946 
1955  static void is_not_null(std::nullptr_t pointer) {is_not_null(pointer, "", line_info());}
1956 
1966  static void is_not_null(std::nullptr_t pointer, const tunit::line_info& line_info) {is_not_null(pointer, "", line_info);}
1967 
1977  static void is_not_null(std::nullptr_t pointer, const std::string& message) {is_not_null(pointer, message, line_info());}
1978 
1989  static void is_not_null(std::nullptr_t pointer, const std::string& message, const tunit::line_info& line_info) {base_assert::fail("not null", "null", message, line_info);}
1990 
2001  template<typename TValue>
2002  static void is_not_zero(const TValue& value) {is_not_zero(value, "", line_info());}
2003 
2015  template<typename TValue>
2016  static void is_not_zero(const TValue& value, const tunit::line_info& line_info) {is_not_zero(value, "", line_info);}
2017 
2029  template<typename TValue>
2030  static void is_not_zero(const TValue& value, const std::string& message) {is_not_zero(value, message, line_info());}
2031 
2044  template<typename TValue>
2045  static void is_not_zero(const TValue& value, const std::string& message, const tunit::line_info& line_info) {
2046  if (value != 0)
2047  succeed(message, line_info);
2048  else
2049  base_assert::fail("not zero", "0", message, line_info);
2050  }
2051 
2063  template<typename TPointer>
2064  static void is_null(const TPointer* pointer) {is_null(pointer, "", line_info());}
2065 
2078  template<typename TPointer>
2079  static void is_null(const TPointer* pointer, const tunit::line_info& line_info) {is_null(pointer, "", line_info);}
2080 
2093  template<typename TPointer>
2094  static void is_null(const TPointer* pointer, const std::string& message) {is_null(pointer, message, line_info());}
2095 
2109  template<typename TPointer>
2110  static void is_null(const TPointer* pointer, const std::string& message, const tunit::line_info& line_info) {
2111  if (pointer == nullptr)
2112  succeed(message, line_info);
2113  else
2114  base_assert::fail("null", "not null", message, line_info);
2115  }
2116 
2127  template<typename TPointer>
2128  static void is_null(const std::unique_ptr<TPointer>& pointer) {is_null(pointer, "", line_info());}
2129 
2141  template<typename TPointer>
2142  static void is_null(const std::unique_ptr<TPointer>& pointer, const tunit::line_info& line_info) {is_null(pointer, "", line_info);}
2143 
2155  template<typename TPointer>
2156  static void is_null(const std::unique_ptr<TPointer>& pointer, const std::string& message) {is_null(pointer, message, line_info());}
2157 
2170  template<typename TPointer>
2171  static void is_null(const std::unique_ptr<TPointer>& pointer, const std::string& message, const tunit::line_info& line_info) {
2172  if (pointer == nullptr)
2173  succeed(message, line_info);
2174  else
2175  base_assert::fail("null", "not null", message, line_info);
2176  }
2177 
2188  template<typename TPointer>
2189  static void is_null(const std::shared_ptr<TPointer>& pointer) {is_null(pointer, "", line_info());}
2190 
2202  template<typename TPointer>
2203  static void is_null(const std::shared_ptr<TPointer>& pointer, const tunit::line_info& line_info) {is_null(pointer, "", line_info);}
2204 
2216  template<typename TPointer>
2217  static void is_null(const std::shared_ptr<TPointer>& pointer, const std::string& message) {is_null(pointer, message, line_info());}
2218 
2231  template<typename TPointer>
2232  static void is_null(const std::shared_ptr<TPointer>& pointer, const std::string& message, const tunit::line_info& line_info) {
2233  if (pointer == nullptr)
2234  succeed(message, line_info);
2235  else
2236  base_assert::fail("null", "not null", message, line_info);
2237  }
2238 
2250  template<typename TPointer>
2251  static void is_null(const std::weak_ptr<TPointer>& pointer) {is_null(pointer, "", line_info());}
2252 
2265  template<typename TPointer>
2266  static void is_null(const std::weak_ptr<TPointer>& pointer, const tunit::line_info& line_info) {is_null(pointer, "", line_info);}
2267 
2280  template<typename TPointer>
2281  static void is_null(const std::weak_ptr<TPointer>& pointer, const std::string& message) {is_null(pointer, message, line_info());}
2282 
2296  template<typename TPointer>
2297  static void is_null(const std::weak_ptr<TPointer>& pointer, const std::string& message, const tunit::line_info& line_info) {base_assert::fail("null", "not null", message, line_info);}
2298 
2307  static void is_null(std::nullptr_t pointer) {is_null(pointer, "", line_info());}
2308 
2318  static void is_null(std::nullptr_t pointer, const tunit::line_info& line_info) {is_null(pointer, "", line_info);}
2319 
2329  static void is_null(std::nullptr_t pointer, const std::string& message) {is_null(pointer, message, line_info());}
2330 
2341  static void is_null(std::nullptr_t pointer, const std::string& message, const tunit::line_info& line_info) {succeed(message, line_info);}
2342 
2353  template<typename TValue>
2354  static void is_positive(const TValue& value) {is_positive(value, "", line_info());}
2355 
2367  template<typename TValue>
2368  static void is_positive(const TValue& value, const tunit::line_info& line_info) {is_positive(value, "", line_info);}
2369 
2381  template<typename TValue>
2382  static void is_positive(const TValue& value, const std::string& message) {is_positive(value, message, line_info());}
2383 
2396  template<typename TValue>
2397  static void is_positive(const TValue& value, const std::string& message, const tunit::line_info& line_info) {
2398  if (value > 0)
2399  succeed(message, line_info);
2400  else
2401  base_assert::fail("positive", base_assert::to_string(value), message, line_info);
2402  }
2403 
2414  static void is_true(bool condition) {is_true(condition, "", line_info());}
2415 
2427  static void is_true(bool condition, const tunit::line_info& line_info) {is_true(condition, "", line_info);}
2428 
2440  static void is_true(bool condition, const std::string& message) {is_true(condition, message, line_info());}
2441 
2454  static void is_true(bool condition, const std::string& message, const tunit::line_info& line_info) {
2455  if (condition == true)
2456  succeed(message, line_info);
2457  else
2458  base_assert::fail("true", "false", message, line_info);
2459  }
2460 
2471  template<typename TValue>
2472  static void is_zero(const TValue& value) {is_zero(value, "", line_info());}
2473 
2485  template<typename TValue>
2486  static void is_zero(const TValue& value, const tunit::line_info& line_info) {is_zero(value, "", line_info);}
2487 
2499  template<typename TValue>
2500  static void is_zero(const TValue& value, const std::string& message) {is_zero(value, message, line_info());}
2501 
2514  template<typename TValue>
2515  static void is_zero(const TValue& value, const std::string& message, const tunit::line_info& line_info) {
2516  if (value == 0)
2517  succeed(message, line_info);
2518  else
2519  base_assert::fail("zero", base_assert::to_string(value), message, line_info);
2520  }
2521 
2532  template<typename TException>
2533  static void throws(const std::function<void()>& statement) {throws<TException>(statement, "", line_info());}
2534 
2546  template<typename TException>
2547  static void throws(const std::function<void()>& statement, const tunit::line_info& line_info) {throws<TException>(statement, "", line_info);}
2548 
2560  template<typename TException>
2561  static void throws(const std::function<void()>& statement, const std::string& message) {throws<TException>(statement, message, line_info());}
2562 
2575  template<typename TException>
2576  static void throws(const std::function<void()>& statement, const std::string& message, const tunit::line_info& line_info) {
2577  try {
2578  statement();
2579  base_assert::fail("<" + __tunit_demangle(typeid(TException).name()) + ">", "<nothing>", message, line_info);
2580  } catch (const TException&) {
2581  succeed(message, line_info);
2582  } catch (const tunit::assert_error&) {
2583  throw;
2584  } catch (const std::exception& e) {
2585  base_assert::fail("<" + __tunit_demangle(typeid(TException).name()) + ">", "<" + __tunit_demangle(typeid(e).name()) + ">", message, line_info);
2586  } catch (...) {
2587  base_assert::fail("<" + __tunit_demangle(typeid(TException).name()) + ">", "<exception>", message, line_info);
2588  }
2589  }
2590 
2600  static void throws_any(const std::function<void()>& statement) {throws_any(statement, "", line_info());}
2601 
2612  static void throws_any(const std::function<void()>& statement, const tunit::line_info& line_info) {throws_any(statement, "", line_info);}
2613 
2624  static void throws_any(const std::function<void()>& statement, const std::string& message) {throws_any(statement, message, line_info());}
2625 
2637  static void throws_any(const std::function<void()>& statement, const std::string& message, const tunit::line_info& line_info) {
2638  try {
2639  statement();
2640  base_assert::fail("<exception>", "<nothing>", message, line_info);
2641  } catch (const tunit::assert_error&) {
2642  throw;
2643  } catch (...) {
2644  succeed(message, line_info);
2645  }
2646  }
2647 
2648  private:
2649  };
2650 }
2651 
2653 #define __CMD_ASSERT_0_ARGS__(cmd) cmd(line_info_)
2654 #define __CMD_ASSERT_1_ARGS__(cmd, arg1) cmd(arg1, line_info_)
2655 #define __CMD_ASSERT_2_ARGS__(cmd, arg1, arg2) cmd(arg1, arg2, line_info_)
2656 #define __CMD_ASSERT_3_ARGS__(cmd, arg1, arg2, arg3) cmd(arg1, arg2, arg3, line_info_)
2657 #define __CMD_ASSERT_4_ARGS__(cmd, arg1, arg2, arg3, arg4) cmd(arg1, arg2, arg3, arg4)
2658 #define __GET_LAST_ARG(arg1, arg2, arg3, arg4, arg5, ...) arg5
2659 #define __CMD_ASSERT_MACRO_CHOOSER(cmd, ...) __GET_LAST_ARG(__VA_ARGS__, __CMD_ASSERT_4_ARGS__, __CMD_ASSERT_3_ARGS__, __CMD_ASSERT_2_ARGS__, __CMD_ASSERT_1_ARGS__, __CMD_ASSERT_0_ARGS__, )
2660 #define __CMD_ASSERT_ARGS(cmd, ...) __CMD_ASSERT_MACRO_CHOOSER(cmd, __VA_ARGS__)(cmd, __VA_ARGS__)
2661 
2663 #define abort_() abort(line_info_)
2664 
2665 #define are_equal_(...) __CMD_ASSERT_ARGS(are_equal, __VA_ARGS__)
2666 
2667 #define are_not_equal_(...) __CMD_ASSERT_ARGS(are_not_equal, __VA_ARGS__)
2668 
2669 #define are_not_same_(...) __CMD_ASSERT_ARGS(are_not_same, __VA_ARGS__)
2670 
2671 #define are_same_(...) __CMD_ASSERT_ARGS(are_same, __VA_ARGS__)
2672 
2673 #define contains_(...) __CMD_ASSERT_ARGS(contains, __VA_ARGS__)
2674 
2675 #define does_not_throw_(...) __CMD_ASSERT_ARGS(does_not_throw, __VA_ARGS__)
2676 
2677 #define fail_() base_assert::fail(line_info_)
2678 
2679 #define ignore_() ignore(line_info_)
2680 
2681 #define is_empty_(...) __CMD_ASSERT_ARGS(is_empty, __VA_ARGS__)
2682 
2683 #define is_false_(...) __CMD_ASSERT_ARGS(is_false, __VA_ARGS__)
2684 
2685 #define is_greater_(...) __CMD_ASSERT_ARGS(is_greater, __VA_ARGS__)
2686 
2687 #define is_greater_or_equal_(...) __CMD_ASSERT_ARGS(is_greater_or_equal, __VA_ARGS__)
2688 
2689 #define is_instance_of_(Type, ...) __CMD_ASSERT_ARGS(is_instance_of<Type>, __VA_ARGS__)
2690 
2691 #define is_less_(...) __CMD_ASSERT_ARGS(is_less, __VA_ARGS__)
2692 
2693 #define is_less_or_equal_(...) __CMD_ASSERT_ARGS(is_less_or_equal, __VA_ARGS__)
2694 
2695 #define is_NaN_(...) __CMD_ASSERT_ARGS(is_NaN, __VA_ARGS__)
2696 
2697 #define is_negative_(...) __CMD_ASSERT_ARGS(is_negative, __VA_ARGS__)
2698 
2699 #define is_not_empty_(...) __CMD_ASSERT_ARGS(is_not_empty, __VA_ARGS__)
2700 
2701 #define is_not_instance_of_(Type, ...) __CMD_ASSERT_ARGS(is_not_instance_of<Type>, __VA_ARGS__)
2702 
2703 #define is_not_null_(...) __CMD_ASSERT_ARGS(is_not_null, __VA_ARGS__)
2704 
2705 #define is_not_zero_(...) __CMD_ASSERT_ARGS(is_not_zero, __VA_ARGS__)
2706 
2707 #define is_null_(...) __CMD_ASSERT_ARGS(is_null, __VA_ARGS__)
2708 
2709 #define is_positive_(...) __CMD_ASSERT_ARGS(is_positive, __VA_ARGS__)
2710 
2711 #define is_true_(...) __CMD_ASSERT_ARGS(is_true, __VA_ARGS__)
2712 
2713 #define is_zero_(...) __CMD_ASSERT_ARGS(is_zero, __VA_ARGS__)
2714 
2715 #define succeed_() succeed(line_info_)
2716 
2717 #define throws_(TException, ...) __CMD_ASSERT_ARGS(throws<TException>, __VA_ARGS__)
2718 
2719 #define throws_any_(...) __CMD_ASSERT_ARGS(throws_any, __VA_ARGS__)
tunit::assert::is_not_empty
static void is_not_empty(const TValue &value, const tunit::line_info &line_info)
Asserts that collection does not contain any item.
Definition: assert.h:1563
tunit::assert::is_NaN
static void is_NaN(double value, const tunit::line_info &line_info)
that a value is NaN.
Definition: assert.h:1329
tunit::assert::are_equal
static void are_equal(long double expected, long double actual, long double tolerance, const tunit::line_info &line_info)
Asserts that two type are equal.
Definition: assert.h:293
tunit::assert::is_negative
static void is_negative(const TValue &value, const std::string &message)
Asserts that ta condition is negative.
Definition: assert.h:1516
tunit::assert::is_positive
static void is_positive(const TValue &value, const std::string &message, const tunit::line_info &line_info)
Asserts that ta condition is positive.
Definition: assert.h:2397
tunit::assert::is_positive
static void is_positive(const TValue &value, const tunit::line_info &line_info)
Asserts that ta condition is positive.
Definition: assert.h:2368
tunit::assert::is_zero
static void is_zero(const TValue &value, const std::string &message, const tunit::line_info &line_info)
Asserts that ta condition is zero.
Definition: assert.h:2515
tunit::assert::are_equal
static void are_equal(const TExpected &expected, const TActual &actual, const tunit::line_info &line_info)
Asserts that two type are equal.
Definition: assert.h:55
tunit::assert::is_null
static void is_null(std::nullptr_t pointer, const tunit::line_info &line_info)
Asserts that the pointer is null.
Definition: assert.h:2318
tunit::assert::is_NaN
static void is_NaN(float value)
that a value is NaN.
Definition: assert.h:1430
tunit::assert::is_greater
static void is_greater(const TValue1 &val1, const TValue2 &val2, const tunit::line_info &line_info)
Asserts that the first value is greater than the second value.
Definition: assert.h:915
tunit::assert::is_instance_of
static void is_instance_of(const TValue &value, const std::string &message)
Asserts that an object is of the type supplied or a derived type.
Definition: assert.h:1106
tunit::assert::is_NaN
static void is_NaN(long double value, const std::string &message)
Asserts that a value is NaN.
Definition: assert.h:1399
tunit::assert::are_equal
static void are_equal(float expected, float actual, float tolerance, const tunit::line_info &line_info)
Asserts that two type are equal.
Definition: assert.h:171
tunit::assert::is_negative
static void is_negative(const TValue &value, const std::string &message, const tunit::line_info &line_info)
Asserts that ta condition is negative.
Definition: assert.h:1531
tunit::assert::is_NaN
static void is_NaN(float value, const std::string &message)
Asserts that a value is NaN.
Definition: assert.h:1456
tunit::assert::is_not_null
static void is_not_null(const std::unique_ptr< TPointer > &pointer, const tunit::line_info &line_info)
Asserts that the pointer is not null.
Definition: assert.h:1790
tunit::assert::are_not_equal
static void are_not_equal(const TExpected &expected, const TActual &actual, const std::string &message, const tunit::line_info &line_info)
Asserts that two type are not equal.
Definition: assert.h:379
tunit::assert::is_not_null
static void is_not_null(const std::shared_ptr< TPointer > &pointer, const std::string &message, const tunit::line_info &line_info)
Asserts that the pointer is not null.
Definition: assert.h:1880
tunit::assert::is_empty
static void is_empty(const TValue &value, const std::string &message)
Asserts that collection contains an item.
Definition: assert.h:765
tunit::assert::is_false
static void is_false(bool condition, const tunit::line_info &line_info)
Asserts that a condition is false.
Definition: assert.h:858
tunit::assert::throws_any
static void throws_any(const std::function< void()> &statement, const tunit::line_info &line_info)
Asserts that the staement does not throw an exception.
Definition: assert.h:2612
tunit::assert::are_equal
static void are_equal(double expected, double actual, double tolerance, const std::string &message)
Asserts that two type are equal.
Definition: assert.h:246
tunit::assert::is_null
static void is_null(const std::unique_ptr< TPointer > &pointer, const tunit::line_info &line_info)
Asserts that the pointer is null.
Definition: assert.h:2142
tunit::assert::is_false
static void is_false(bool condition)
Asserts that ta condition is false.
Definition: assert.h:845
tunit::assert::is_less_or_equal
static void is_less_or_equal(const TValue1 &val1, const TValue2 &val2, const std::string &message)
Asserts that the first value is is_less than or equal to the second value.
Definition: assert.h:1254
tunit::assert::is_NaN
static void is_NaN(long double value)
that a value is NaN.
Definition: assert.h:1373
tunit::assert::is_true
static void is_true(bool condition)
Asserts that ta condition is true.
Definition: assert.h:2414
tunit::assert::is_null
static void is_null(const std::shared_ptr< TPointer > &pointer)
Asserts that the pointer is null.
Definition: assert.h:2189
tunit::assert::throws_any
static void throws_any(const std::function< void()> &statement)
Asserts that the staement does not throw an exception.
Definition: assert.h:2600
tunit::assert::is_less
static void is_less(const TValue1 &val1, const TValue2 &val2)
Asserts that the first value is is_less than the second value.
Definition: assert.h:1137
tunit::assert::is_less
static void is_less(const TValue1 &val1, const TValue2 &val2, const std::string &message, const tunit::line_info &line_info)
Asserts that the first value is is_less than the second value.
Definition: assert.h:1177
tunit::assert::are_equal
static void are_equal(long double expected, long double actual, long double tolerance, const std::string &message)
Asserts that two type are equal.
Definition: assert.h:307
tunit::assert::throws_any
static void throws_any(const std::function< void()> &statement, const std::string &message)
Asserts that the staement does not throw an exception.
Definition: assert.h:2624
tunit::assert::is_not_null
static void is_not_null(std::nullptr_t pointer, const std::string &message, const tunit::line_info &line_info)
Asserts that the pointer is not null.
Definition: assert.h:1989
tunit::assert::is_not_null
static void is_not_null(const std::weak_ptr< TPointer > &pointer)
Asserts that the pointer is not null.
Definition: assert.h:1899
tunit::assert::is_not_empty
static void is_not_empty(const TValue &value)
Asserts that collection oes not contain any item.
Definition: assert.h:1549
tunit::assert::is_NaN
static void is_NaN(long double value, const tunit::line_info &line_info)
that a value is NaN.
Definition: assert.h:1386
tunit::assert::is_not_null
static void is_not_null(const std::shared_ptr< TPointer > &pointer, const tunit::line_info &line_info)
Asserts that the pointer is not null.
Definition: assert.h:1851
tunit::assert::contains
static void contains(const TItem &item, const TCollection &collection, const std::string &message)
Asserts that collection contains an item.
Definition: assert.h:593
tunit::assert
The assert class contains a collection of static methods that implement the most common assertions us...
Definition: assert.h:26
tunit::assert::is_null
static void is_null(const TPointer *pointer, const std::string &message, const tunit::line_info &line_info)
Asserts that the pointer is null.
Definition: assert.h:2110
tunit::assert::is_null
static void is_null(const std::shared_ptr< TPointer > &pointer, const std::string &message)
Asserts that the pointer is null.
Definition: assert.h:2217
tunit::assert::is_not_null
static void is_not_null(const std::unique_ptr< TPointer > &pointer)
Asserts that the pointer is not null.
Definition: assert.h:1776
tunit::assert::is_null
static void is_null(const std::weak_ptr< TPointer > &pointer, const tunit::line_info &line_info)
Asserts that the pointer is null.
Definition: assert.h:2266
tunit::assert::is_not_zero
static void is_not_zero(const TValue &value, const std::string &message, const tunit::line_info &line_info)
Asserts that ta condition is not zero.
Definition: assert.h:2045
tunit::assert::are_equal
static void are_equal(long double expected, long double actual, long double tolerance, const std::string &message, const tunit::line_info &line_info)
Asserts that two type are equal.
Definition: assert.h:322
tunit::assert::is_instance_of
static void is_instance_of(const TValue &value, const std::string &message, const tunit::line_info &line_info)
Asserts that an object is of the type supplied or a derived type.
Definition: assert.h:1120
tunit::assert::is_greater
static void is_greater(const TValue1 &val1, const TValue2 &val2, const std::string &message)
Asserts that the first value is greater than the second value.
Definition: assert.h:928
tunit::assert::is_positive
static void is_positive(const TValue &value, const std::string &message)
Asserts that ta condition is positive.
Definition: assert.h:2382
tunit::assert::is_not_null
static void is_not_null(const std::weak_ptr< TPointer > &pointer, const std::string &message, const tunit::line_info &line_info)
Asserts that the pointer is not null.
Definition: assert.h:1945
tunit::assert::is_zero
static void is_zero(const TValue &value)
Asserts that ta condition is zero.
Definition: assert.h:2472
tunit::assert::are_not_equal
static void are_not_equal(const TExpected &expected, const TActual &actual)
Asserts that two type are not equal.
Definition: assert.h:339
tunit::assert::is_NaN
static void is_NaN(float value, const std::string &message, const tunit::line_info &line_info)
Asserts that a value is NaN.
Definition: assert.h:1470
tunit::assert::are_equal
static void are_equal(double expected, double actual, double tolerance, const std::string &message, const tunit::line_info &line_info)
Asserts that two type are equal.
Definition: assert.h:261
tunit::assert::contains
static void contains(const TItem &item, const TCollection &collection)
Asserts that collection contains an item.
Definition: assert.h:565
tunit::assert::is_not_null
static void is_not_null(const TPointer *pointer, const tunit::line_info &line_info)
Asserts that the pointer is not null.
Definition: assert.h:1727
tunit::assert::is_null
static void is_null(const std::unique_ptr< TPointer > &pointer, const std::string &message, const tunit::line_info &line_info)
Asserts that the pointer is null.
Definition: assert.h:2171
tunit::assert::is_null
static void is_null(const std::unique_ptr< TPointer > &pointer, const std::string &message)
Asserts that the pointer is null.
Definition: assert.h:2156
line_info_
#define line_info_
Get tunit::line_info informations.
Definition: line_info.h:75
tunit::assert::is_null
static void is_null(const std::weak_ptr< TPointer > &pointer, const std::string &message, const tunit::line_info &line_info)
Asserts that the pointer is null.
Definition: assert.h:2297
tunit::assert::is_not_null
static void is_not_null(const std::weak_ptr< TPointer > &pointer, const std::string &message)
Asserts that the pointer is not null.
Definition: assert.h:1929
tunit::assert::is_greater_or_equal
static void is_greater_or_equal(const TValue1 &val1, const TValue2 &val2, const std::string &message, const tunit::line_info &line_info)
Asserts that the first value is greater than or equal to the second value.
Definition: assert.h:1033
tunit::assert::is_false
static void is_false(bool condition, const std::string &message, const tunit::line_info &line_info)
Asserts that a condition is false.
Definition: assert.h:885
tunit::assert::is_null
static void is_null(std::nullptr_t pointer)
Asserts that the pointer is null.
Definition: assert.h:2307
tunit::assert::are_not_same
static void are_not_same(const TExpected &expected, const TActual &actual)
Asserts that two objects do refer to differents objects.
Definition: assert.h:429
tunit::assert::is_less
static void is_less(const TValue1 &val1, const TValue2 &val2, const tunit::line_info &line_info)
Asserts that the first value is is_less than the second value.
Definition: assert.h:1150
tunit::assert::does_not_throw
static void does_not_throw(const std::function< void()> &statement)
Asserts that the staement does not throw an exception.
Definition: assert.h:678
tunit::assert::are_equal
static void are_equal(double expected, double actual, double tolerance, const tunit::line_info &line_info)
Asserts that two type are equal.
Definition: assert.h:232
tunit::assert::is_greater_or_equal
static void is_greater_or_equal(const TValue1 &val1, const TValue2 &val2)
Asserts that the first value is greater than or equal to the second value.
Definition: assert.h:990
tunit::assert::contains
static void contains(const TItem &item, const TCollection &collection, const std::string &message, const tunit::line_info &line_info)
Asserts that collection contains an item.
Definition: assert.h:608
tunit::assert::is_positive
static void is_positive(const TValue &value)
Asserts that ta condition is positive.
Definition: assert.h:2354
tunit::assert::are_not_same
static void are_not_same(const TExpected &expected, const TActual &actual, const std::string &message)
Asserts that two objects do refer to differents objects.
Definition: assert.h:461
tunit::assert::is_null
static void is_null(std::nullptr_t pointer, const std::string &message)
Asserts that the pointer is null.
Definition: assert.h:2329
tunit::assert::is_not_empty
static void is_not_empty(const TValue &value, const std::string &message, const tunit::line_info &line_info)
Asserts that collection does not contain any item.
Definition: assert.h:1592
tunit::assert::is_greater_or_equal
static void is_greater_or_equal(const TValue1 &val1, const TValue2 &val2, const std::string &message)
Asserts that the first value is greater than or equal to the second value.
Definition: assert.h:1018
tunit::assert::is_not_zero
static void is_not_zero(const TValue &value)
Asserts that ta condition is not zero.
Definition: assert.h:2002
tunit::assert::is_not_null
static void is_not_null(const TPointer *pointer, const std::string &message)
Asserts that the pointer is not null.
Definition: assert.h:1742
tunit::assert::is_false
static void is_false(bool condition, const std::string &message)
Asserts that a condition is false.
Definition: assert.h:871
tunit::assert::is_empty
static void is_empty(const TValue &value, const std::string &message, const tunit::line_info &line_info)
Asserts that collection contains an item.
Definition: assert.h:780
tunit::assert::is_zero
static void is_zero(const TValue &value, const tunit::line_info &line_info)
Asserts that ta condition is zero.
Definition: assert.h:2486
tunit::assert::are_same
static void are_same(const TExpected &expected, const TActual &actual, const std::string &message)
Asserts that two objects do refer to differents objects.
Definition: assert.h:530
tunit::assert::is_null
static void is_null(const std::unique_ptr< TPointer > &pointer)
Asserts that the pointer is null.
Definition: assert.h:2128
tunit::assert::is_NaN
static void is_NaN(double value, const std::string &message, const tunit::line_info &line_info)
Asserts that a value is NaN.
Definition: assert.h:1356
tunit::assert::are_not_equal
static void are_not_equal(const TExpected &expected, const TActual &actual, const tunit::line_info &line_info)
Asserts that two type are not equal.
Definition: assert.h:352
tunit::assert::is_negative
static void is_negative(const TValue &value)
Asserts that ta condition is negative.
Definition: assert.h:1488
tunit::assert::is_not_empty
static void is_not_empty(const TValue &value, const std::string &message)
Asserts that collection does not contain any item.
Definition: assert.h:1577
tunit::assert::is_not_zero
static void is_not_zero(const TValue &value, const std::string &message)
Asserts that ta condition is not zero.
Definition: assert.h:2030
tunit::assert::is_not_instance_of
static void is_not_instance_of(const TValue &value, const std::string &message, const tunit::line_info &line_info)
Asserts that an object is not of the type supplied or a derived type.
Definition: assert.h:1693
tunit::assert::are_not_same
static void are_not_same(const TExpected &expected, const TActual &actual, const tunit::line_info &line_info)
Asserts that two objects do refer to differents objects.
Definition: assert.h:445
tunit::line_info
line_info information class is used to store current file, current line and current function informat...
Definition: line_info.h:13
tunit::assert_error
Exception thow when an assertion failed.
Definition: assert_error.h:10
tunit::assert::is_less_or_equal
static void is_less_or_equal(const TValue1 &val1, const TValue2 &val2)
Asserts that the first value is is_less than or equal to the second value.
Definition: assert.h:1226
tunit::assert::is_zero
static void is_zero(const TValue &value, const std::string &message)
Asserts that ta condition is zero.
Definition: assert.h:2500
tunit::base_assert::fail
static void fail()
Throws an tunit::assertion_error exception.
Definition: base_assert.h:60
tunit::assert::is_true
static void is_true(bool condition, const std::string &message)
Asserts that a condition is true.
Definition: assert.h:2440
tunit::assert::is_instance_of
static void is_instance_of(const TValue &value)
Asserts that an object is of the type supplied or a derived type.
Definition: assert.h:1080
tunit::assert::is_less
static void is_less(const TValue1 &val1, const TValue2 &val2, const std::string &message)
Asserts that the first value is is_less than the second value.
Definition: assert.h:1163
tunit::assert::is_null
static void is_null(const std::weak_ptr< TPointer > &pointer)
Asserts that the pointer is null.
Definition: assert.h:2251
tunit::assert::is_null
static void is_null(const std::shared_ptr< TPointer > &pointer, const std::string &message, const tunit::line_info &line_info)
Asserts that the pointer is null.
Definition: assert.h:2232
tunit::assert::are_equal
static void are_equal(const TExpected &expected, const TActual &actual)
Asserts that two type are equal.
Definition: assert.h:42
tunit::assert::are_same
static void are_same(const TExpected &expected, const TActual &actual, const tunit::line_info &line_info)
Asserts that two objects do refer to differents objects.
Definition: assert.h:514
tunit::assert::contains
static void contains(const TItem &item, const TCollection &collection, const tunit::line_info &line_info)
Asserts that collection contains an item.
Definition: assert.h:579
tunit::assert::is_negative
static void is_negative(const TValue &value, const tunit::line_info &line_info)
Asserts that ta condition is negative.
Definition: assert.h:1502
tunit::assert::is_null
static void is_null(const TPointer *pointer)
Asserts that the pointer is null.
Definition: assert.h:2064
tunit::assert::is_not_null
static void is_not_null(std::nullptr_t pointer)
Asserts that the pointer is not null.
Definition: assert.h:1955
tunit::assert::does_not_throw
static void does_not_throw(const std::function< void()> &statement, const std::string &message)
Asserts that the staement does not throw an exception.
Definition: assert.h:702
tunit::assert::is_instance_of
static void is_instance_of(const TValue &value, const tunit::line_info &line_info)
Asserts that an object is of the type supplied or a derived type.
Definition: assert.h:1093
tunit::assert::is_empty
static void is_empty(const TValue &value)
Asserts that collection contains an item.
Definition: assert.h:737
tunit::assert::is_less_or_equal
static void is_less_or_equal(const TValue1 &val1, const TValue2 &val2, const std::string &message, const tunit::line_info &line_info)
Asserts that the first value is is_less than or equal to the second value.
Definition: assert.h:1269
tunit::assert::is_not_instance_of
static void is_not_instance_of(const TValue &value, const tunit::line_info &line_info)
Asserts that an object is not of the type supplied or a derived type.
Definition: assert.h:1666
tunit::base_assert
Definition: base_assert.h:15
tunit::base_assert::succeed
static void succeed()
Generates a success with a generic message.
Definition: base_assert.h:130
tunit::assert::is_greater_or_equal
static void is_greater_or_equal(const TValue1 &val1, const TValue2 &val2, const tunit::line_info &line_info)
Asserts that the first value is greater than or equal to the second value.
Definition: assert.h:1004
tunit::assert::is_NaN
static void is_NaN(double value)
that a value is NaN.
Definition: assert.h:1316
tunit::assert::is_greater
static void is_greater(const TValue1 &val1, const TValue2 &val2, const std::string &message, const tunit::line_info &line_info)
Asserts that the first value is greater than the second value.
Definition: assert.h:942
tunit::assert::does_not_throw
static void does_not_throw(const std::function< void()> &statement, const tunit::line_info &line_info)
Asserts that the staement does not throw an exception.
Definition: assert.h:690
tunit
The tunit namespace contains a unit test library.
Definition: abort_error.h:8
tunit::assert::is_null
static void is_null(std::nullptr_t pointer, const std::string &message, const tunit::line_info &line_info)
Asserts that the pointer is null.
Definition: assert.h:2341
tunit::assert::is_not_instance_of
static void is_not_instance_of(const TValue &value)
Asserts that an object is not of the type supplied or a derived type.
Definition: assert.h:1653
tunit::assert::are_not_equal
static void are_not_equal(const TExpected &expected, const TActual &actual, const std::string &message)
Asserts that two type are not equal.
Definition: assert.h:365
tunit::assert::are_same
static void are_same(const TExpected &expected, const TActual &actual, const std::string &message, const tunit::line_info &line_info)
Asserts that two objects do refer to differents objects.
Definition: assert.h:547
tunit::assert::is_not_null
static void is_not_null(const std::shared_ptr< TPointer > &pointer, const std::string &message)
Asserts that the pointer is not null.
Definition: assert.h:1865
tunit::assert::are_equal
static void are_equal(float expected, float actual, float tolerance, const std::string &message, const tunit::line_info &line_info)
Asserts that two type are equal.
Definition: assert.h:200
tunit::assert::are_equal
static void are_equal(float expected, float actual, float tolerance)
Asserts that two type are equal.
Definition: assert.h:157
tunit::assert::throws_any
static void throws_any(const std::function< void()> &statement, const std::string &message, const tunit::line_info &line_info)
Asserts that the staement does not throw an exception.
Definition: assert.h:2637
tunit::assert::is_not_null
static void is_not_null(const TPointer *pointer, const std::string &message, const tunit::line_info &line_info)
Asserts that the pointer is not null.
Definition: assert.h:1758
tunit::assert::is_null
static void is_null(const TPointer *pointer, const tunit::line_info &line_info)
Asserts that the pointer is null.
Definition: assert.h:2079
tunit::assert::is_NaN
static void is_NaN(double value, const std::string &message)
Asserts that a value is NaN.
Definition: assert.h:1342
tunit::assert::is_NaN
static void is_NaN(long double value, const std::string &message, const tunit::line_info &line_info)
Asserts that a value is NaN.
Definition: assert.h:1413
tunit::assert::are_equal
static void are_equal(float expected, float &actual, float tolerance, const std::string &message)
Asserts that two type are equal.
Definition: assert.h:185
tunit::assert::is_not_null
static void is_not_null(const std::shared_ptr< TPointer > &pointer)
Asserts that the pointer is not null.
Definition: assert.h:1837
tunit::assert::are_equal
static void are_equal(double expected, double actual, double tolerance)
Asserts that two type are equal.
Definition: assert.h:218
tunit::assert::is_greater
static void is_greater(const TValue1 &val1, const TValue2 &val2)
Asserts that the first value is greater than the second value.
Definition: assert.h:902
tunit::assert::are_equal
static void are_equal(const TExpected &expected, const TActual &actual, const std::string &message)
Asserts that two type are equal.
Definition: assert.h:68
tunit::assert::is_not_zero
static void is_not_zero(const TValue &value, const tunit::line_info &line_info)
Asserts that ta condition is not zero.
Definition: assert.h:2016
tunit::assert::is_not_null
static void is_not_null(const std::unique_ptr< TPointer > &pointer, const std::string &message)
Asserts that the pointer is not null.
Definition: assert.h:1804
tunit::assert::are_not_same
static void are_not_same(const TExpected &expected, const TActual &actual, const std::string &message, const tunit::line_info &line_info)
Asserts that two objects do refer to differents objects.
Definition: assert.h:478
tunit::assert::is_empty
static void is_empty(const TValue &value, const tunit::line_info &line_info)
Asserts that collection contains an item.
Definition: assert.h:751
tunit::assert::is_null
static void is_null(const std::shared_ptr< TPointer > &pointer, const tunit::line_info &line_info)
Asserts that the pointer is null.
Definition: assert.h:2203
tunit::assert::are_equal
static void are_equal(const TExpected &expected, const TActual &actual, const std::string &message, const tunit::line_info &line_info)
Asserts that two type are equal.
Definition: assert.h:82
tunit::assert::is_not_null
static void is_not_null(std::nullptr_t pointer, const tunit::line_info &line_info)
Asserts that the pointer is not null.
Definition: assert.h:1966
tunit::assert::is_true
static void is_true(bool condition, const std::string &message, const tunit::line_info &line_info)
Asserts that a condition is true.
Definition: assert.h:2454
tunit::assert::is_NaN
static void is_NaN(float value, const tunit::line_info &line_info)
that a value is NaN.
Definition: assert.h:1443
tunit::assert::is_null
static void is_null(const TPointer *pointer, const std::string &message)
Asserts that the pointer is null.
Definition: assert.h:2094
tunit::assert::are_equal
static void are_equal(long double expected, long double actual, long double tolerance)
Asserts that two type are equal.
Definition: assert.h:279
tunit::assert::is_null
static void is_null(const std::weak_ptr< TPointer > &pointer, const std::string &message)
Asserts that the pointer is null.
Definition: assert.h:2281
tunit::assert::is_not_null
static void is_not_null(const std::weak_ptr< TPointer > &pointer, const tunit::line_info &line_info)
Asserts that the pointer is not null.
Definition: assert.h:1914
tunit::assert::is_less_or_equal
static void is_less_or_equal(const TValue1 &val1, const TValue2 &val2, const tunit::line_info &line_info)
Asserts that the first value is is_less than or equal to the second value.
Definition: assert.h:1240
base_assert.h
Contains tunit::assert class.
tunit::assert::are_same
static void are_same(const TExpected &expected, const TActual &actual)
Asserts that two objects do refer to differents objects.
Definition: assert.h:498
tunit::assert::is_not_null
static void is_not_null(const std::unique_ptr< TPointer > &pointer, const std::string &message, const tunit::line_info &line_info)
Asserts that the pointer is not null.
Definition: assert.h:1819
tunit::assert::does_not_throw
static void does_not_throw(const std::function< void()> &statement, const std::string &message, const tunit::line_info &line_info)
Asserts that the staement does not throw an exception.
Definition: assert.h:715
tunit::assert::is_not_null
static void is_not_null(std::nullptr_t pointer, const std::string &message)
Asserts that the pointer is not null.
Definition: assert.h:1977
tunit::assert::is_not_instance_of
static void is_not_instance_of(const TValue &value, const std::string &message)
Asserts that an object is not of the type supplied or a derived type.
Definition: assert.h:1679
tunit::assert::is_not_null
static void is_not_null(const TPointer *pointer)
Asserts that the pointer is not null.
Definition: assert.h:1712
tunit::assert::is_true
static void is_true(bool condition, const tunit::line_info &line_info)
Asserts that a condition is true.
Definition: assert.h:2427