tunit - Reference Guide  1.0.0
Modern c++17 unit testing framework on Windows, macOS, Linux, iOS and android.
valid.h
Go to the documentation of this file.
1 #pragma once
4 #include "assert.h"
5 
7 namespace tunit {
12  class valid final : private base_assert {
13  public:
15  valid() = delete;
17 
26  template<typename TExpected, typename TActual>
27  static void are_equal(const TExpected& expected, const TActual& actual) {are_equal(expected, actual, "", line_info());}
28 
38  template<typename TExpected, typename TActual>
39  static void are_equal(const TExpected& expected, const TActual& actual, const tunit::line_info& line_info) {are_equal(expected, actual, "", line_info);}
40 
50  template<typename TExpected, typename TActual>
51  static void are_equal(const TExpected& expected, const TActual& actual, const std::string& message) {are_equal(expected, actual, message, line_info());}
52 
63  template<typename TExpected, typename TActual>
64  static void are_equal(const TExpected& expected, const TActual& actual, const std::string& message, const tunit::line_info& line_info) {
65  try {
66  assert::are_equal(expected, actual, message, line_info);
67  } catch (...) {
68  base_assert::error();
69  }
70  }
71 
73  static void are_equal(const char* expected, const char* actual, const std::string& message, const tunit::line_info& line_info) {
74  try{
75  assert::are_equal(expected, actual, message, line_info);
76  } catch (...) {
77  base_assert::error();
78  }
79  }
80 
81  static void are_equal(const char16_t* expected, const char16_t* actual, const std::string& message, const tunit::line_info& line_info) {
82  try {
83  assert::are_equal(expected, actual, message, line_info);
84  } catch (...) {
85  base_assert::error();
86  }
87  }
88 
89  static void are_equal(const char32_t* expected, const char32_t* actual, const std::string& message, const tunit::line_info& line_info) {
90  try {
91  assert::are_equal(expected, actual, message, line_info);
92  } catch (...) {
93  base_assert::error();
94  }
95  }
96 
97  static void are_equal(const wchar_t* expected, const wchar_t* actual, const std::string& message, const tunit::line_info& line_info) {
98  try {
99  assert::are_equal(expected, actual, message, line_info);
100  } catch (...) {
101  base_assert::error();
102  }
103  }
104 
105  static void are_equal(float expected, float actual, const std::string& message, const tunit::line_info& line_info) {
106  try {
107  assert::are_equal(expected, actual, message, line_info);
108  } catch (...) {
109  base_assert::error();
110  }
111  }
112 
113  static void are_equal(double expected, double actual, const std::string& message, const tunit::line_info& line_info) {
114  try {
115  assert::are_equal(expected, actual, message, line_info);
116  } catch (...) {
117  base_assert::error();
118  }
119  }
120 
121  static void are_equal(long double expected, long double actual, const std::string& message, const tunit::line_info& line_info) {
122  try {
123  assert::are_equal(expected, actual, message, line_info);
124  } catch (...) {
125  base_assert::error();
126  }
127  }
129 
140  static void are_equal(float expected, float actual, float tolerance) {are_equal(expected, actual, tolerance, "", line_info_);}
141 
153  static void are_equal(float expected, float actual, float tolerance, const tunit::line_info& line_info) {are_equal(expected, actual, tolerance, "", line_info);}
154 
166  static void are_equal(float expected, float& actual, float tolerance, const std::string& message) {are_equal(expected, actual, tolerance, message, line_info());}
167 
180  static void are_equal(float expected, float actual, float tolerance, const std::string& message, const tunit::line_info& line_info) {
181  try {
182  assert::are_equal(expected, actual, tolerance, message, line_info);
183  } catch (...) {
184  base_assert::error();
185  }
186  }
187 
198  static void are_equal(double expected, double actual, double tolerance) {are_equal(expected, actual, tolerance, "", line_info_);}
199 
211  static void are_equal(double expected, double actual, double tolerance, const tunit::line_info& line_info) {are_equal(expected, actual, tolerance, "", line_info);}
212 
224  static void are_equal(double expected, double actual, double tolerance, const std::string& message) {are_equal(expected, actual, tolerance, message, line_info());}
225 
238  static void are_equal(double expected, double actual, double tolerance, const std::string& message, const tunit::line_info& line_info) {
239  try {
240  assert::are_equal(expected, actual, tolerance, message, line_info);
241  } catch (...) {
242  base_assert::error();
243  }
244  }
245 
256  static void are_equal(long double expected, long double actual, long double tolerance) {are_equal(expected, actual, tolerance, "", line_info_);}
257 
269  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);}
270 
282  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());}
283 
296  static void are_equal(long double expected, long double actual, long double tolerance, const std::string& message, const tunit::line_info& line_info) {
297  try {
298  assert::are_equal(expected, actual, tolerance, message, line_info);
299  } catch (...) {
300  base_assert::error();
301  }
302  }
303 
312  template<typename TExpected, typename TActual>
313  static void are_not_equal(const TExpected& expected, const TActual& actual) {are_not_equal(expected, actual, "", line_info());}
314 
324  template<typename TExpected, typename TActual>
325  static void are_not_equal(const TExpected& expected, const TActual& actual, const tunit::line_info& line_info) {are_not_equal(expected, actual, "", line_info);}
326 
336  template<typename TExpected, typename TActual>
337  static void are_not_equal(const TExpected& expected, const TActual& actual, const std::string& message) {are_not_equal(expected, actual, message, line_info());}
338 
349  template<typename TExpected, typename TActual>
350  static void are_not_equal(const TExpected& expected, const TActual& actual, const std::string& message, const tunit::line_info& line_info) {
351  try {
352  assert::are_not_equal(expected, actual, message, line_info);
353  } catch (...) {
354  base_assert::error();
355  }
356  }
357 
359  static void are_not_equal(const char* expected, const char* actual, const std::string& message, const tunit::line_info& line_info) {
360  try {
361  assert::are_not_equal(expected, actual, message, line_info);
362  } catch (...) {
363  base_assert::error();
364  }
365  }
366 
367  static void are_not_equal(const char16_t* expected, const char16_t* actual, const std::string& message, const tunit::line_info& line_info) {
368  try {
369  assert::are_not_equal(expected, actual, message, line_info);
370  } catch (...) {
371  base_assert::error();
372  }
373  }
374 
375  static void are_not_equal(const char32_t* expected, const char32_t* actual, const std::string& message, const tunit::line_info& line_info) {
376  try {
377  assert::are_not_equal(expected, actual, message, line_info);
378  } catch (...) {
379  base_assert::error();
380  }
381  }
382 
383  static void are_not_equal(const wchar_t* expected, const wchar_t* actual, const std::string& message, const tunit::line_info& line_info) {
384  try {
385  assert::are_not_equal(expected, actual, message, line_info);
386  } catch (...) {
387  base_assert::error();
388  }
389  }
391 
403  template<typename TExpected, typename TActual>
404  static void are_not_same(const TExpected& expected, const TActual& actual) {are_not_same(expected, actual, "", line_info());}
405 
418  template<typename TExpected, typename TActual>
419  static void are_not_same(const TExpected& expected, const TActual& actual, const tunit::line_info& line_info) {are_not_same(expected, actual, "", line_info);}
420 
433  template<typename TExpected, typename TActual>
434  static void are_not_same(const TExpected& expected, const TActual& actual, const std::string& message) {are_not_same(expected, actual, message, line_info());}
435 
449  template<typename TExpected, typename TActual>
450  static void are_not_same(const TExpected& expected, const TActual& actual, const std::string& message, const tunit::line_info& line_info) {
451  try {
452  assert::are_not_same(expected, actual, message, line_info);
453  } catch (...) {
454  base_assert::error();
455  }
456  }
457 
469  template<typename TExpected, typename TActual>
470  static void are_same(const TExpected& expected, const TActual& actual) {are_same(expected, actual, "", line_info());}
471 
484  template<typename TExpected, typename TActual>
485  static void are_same(const TExpected& expected, const TActual& actual, const tunit::line_info& line_info) {are_same(expected, actual, "", line_info);}
486 
499  template<typename TExpected, typename TActual>
500  static void are_same(const TExpected& expected, const TActual& actual, const std::string& message) {are_same(expected, actual, message, line_info());}
501 
515  template<typename TExpected, typename TActual>
516  static void are_same(const TExpected& expected, const TActual& actual, const std::string& message, const tunit::line_info& line_info) {
517  try {
518  assert::are_same(expected, actual, message, line_info);
519  } catch (...) {
520  base_assert::error();
521  }
522  }
523 
533  template<typename TItem, typename TCollection>
534  static void contains(const TItem& item, const TCollection& collection) {contains(item, collection, "", line_info());}
535 
546  template<typename TItem, typename TCollection>
547  static void contains(const TItem& item, const TCollection& collection, const tunit::line_info& line_info) {contains(item, collection, "", line_info);}
548 
559  template<typename TItem, typename TCollection>
560  static void contains(const TItem& item, const TCollection& collection, const std::string& message) {contains(item, collection, message, line_info());}
561 
573  template<typename TItem, typename TCollection>
574  static void contains(const TItem& item, const TCollection& collection, const std::string& message, const tunit::line_info& line_info) {
575  try {
576  assert::contains(item, collection, message, line_info);
577  } catch (...) {
578  base_assert::error();
579  }
580  }
581 
583  template<typename TItem, typename TValue>
584  static void contains(const TItem& item, const std::initializer_list<TValue>& values) {contains(item, values, "", line_info());}
585  template<typename TItem, typename TValue>
586  static void contains(const TItem& item, const std::initializer_list<TValue>& values, const tunit::line_info& line_info) {contains(item, values, "", line_info);}
587  template<typename TItem, typename TValue>
588  static void contains(const TItem& item, const std::initializer_list<TValue>& values, const std::string& message) {contains(item, values, message, line_info());}
589  template<typename TItem, typename TValue>
590  static void contains(const TItem& item, const std::initializer_list<TValue>& values, const std::string& message, const tunit::line_info& line_info) {
591  try {
592  assert::contains(item, values, message, line_info);
593  } catch (...) {
594  base_assert::error();
595  }
596  }
597 
598  static void contains(char item, const char* values, const std::string& message, const tunit::line_info& line_info) {
599  try {
600  assert::contains(item, values, message, line_info);
601  } catch (...) {
602  base_assert::error();
603  }
604  }
605 
606  static void contains(char16_t item, const char16_t* values, const std::string& message, const tunit::line_info& line_info) {
607  try {
608  assert::contains(item, values, message, line_info);
609  } catch (...) {
610  base_assert::error();
611  }
612  }
613 
614  static void contains(char32_t item, const char32_t* values, const std::string& message, const tunit::line_info& line_info) {
615  try {
616  assert::contains(item, values, message, line_info);
617  } catch (...) {
618  base_assert::error();
619  }
620  }
621 
622  static void contains(wchar_t item, const wchar_t* values, const std::string& message, const tunit::line_info& line_info) {
623  try {
624  assert::contains(item, values, message, line_info);
625  } catch (...) {
626  base_assert::error();
627  }
628  }
630 
639  static void does_not_throw(const std::function<void()>& statement) {does_not_throw(statement, "", line_info());}
640 
650  static void does_not_throw(const std::function<void()>& statement, const tunit::line_info& line_info) {does_not_throw(statement, "", line_info);}
651 
661  static void does_not_throw(const std::function<void()>& statement, const std::string& message) {does_not_throw(statement, message, line_info());}
662 
673  static void does_not_throw(const std::function<void()>& statement, const std::string& message, const tunit::line_info& line_info) {
674  try {
675  assert::does_not_throw(statement, message, line_info);
676  } catch (...) {
677  base_assert::error();
678  }
679  }
680 
690  template<typename TValue>
691  static void is_empty(const TValue& value) {is_empty(value, "", line_info());}
692 
703  template<typename TValue>
704  static void is_empty(const TValue& value, const tunit::line_info& line_info) {is_empty(value, "", line_info);}
705 
716  template<typename TValue>
717  static void is_empty(const TValue& value, const std::string& message) {is_empty(value, message, line_info());}
718 
730  template<typename TValue>
731  static void is_empty(const TValue& value, const std::string& message, const tunit::line_info& line_info) {
732  try {
733  assert::is_empty(value, message, line_info);
734  } catch (...) {
735  base_assert::error();
736  }
737  }
738 
740  template<typename TValue>
741  static void is_empty(const std::initializer_list<TValue>& value) {is_empty(value, "", line_info());}
742  template<typename TValue>
743  static void is_empty(const std::initializer_list<TValue>& value, const tunit::line_info& line_info) {is_empty(value, "", line_info);}
744  template<typename TValue>
745  static void is_empty(const std::initializer_list<TValue>& value, const std::string& message) {is_empty(value, message, line_info());}
746  template<typename TValue>
747  static void is_empty(const std::initializer_list<TValue>& values, const std::string& message, const tunit::line_info& line_info) {
748  try {
749  assert::is_empty(values, message, line_info);
750  } catch (...) {
751  base_assert::error();
752  }
753  }
754 
755  static void is_empty(const char* value, const std::string& message, const tunit::line_info& line_info) {
756  try {
757  assert::is_empty(value, message, line_info);
758  } catch (...) {
759  base_assert::error();
760  }
761  }
762 
763  static void is_empty(const char16_t* value, const std::string& message, const tunit::line_info& line_info) {
764  try {
765  assert::is_empty(value, message, line_info);
766  } catch (...) {
767  base_assert::error();
768  }
769  }
770 
771  static void is_empty(const char32_t* value, const std::string& message, const tunit::line_info& line_info) {
772  try {
773  assert::is_empty(value, message, line_info);
774  } catch (...) {
775  base_assert::error();
776  }
777  }
778 
779  static void is_empty(const wchar_t* value, const std::string& message, const tunit::line_info& line_info) {
780  try {
781  assert::is_empty(value, message, line_info);
782  } catch (...) {
783  base_assert::error();
784  }
785  }
787 
797  static void is_false(bool condition) {is_false(condition, "", line_info());}
798 
809  static void is_false(bool condition, const tunit::line_info& line_info) {is_false(condition, "", line_info);}
810 
821  static void is_false(bool condition, const std::string& message) {is_false(condition, message, line_info());}
822 
834  static void is_false(bool condition, const std::string& message, const tunit::line_info& line_info) {
835  try {
836  assert::is_false(condition, message, line_info);
837  } catch (...) {
838  base_assert::error();
839  }
840  }
841 
850  template<typename TValue1, typename TValue2>
851  static void is_greater(const TValue1& val1, const TValue2& val2) {is_greater(val1, val2, "", line_info());}
852 
862  template<typename TValue1, typename TValue2>
863  static void is_greater(const TValue1& val1, const TValue2& val2, const tunit::line_info& line_info) {is_greater(val1, val2, "", line_info);}
864 
874  template<typename TValue1, typename TValue2>
875  static void is_greater(const TValue1& val1, const TValue2& val2, const std::string& message) {is_greater(val1, val2, message, line_info());}
876 
887  template<typename TValue1, typename TValue2>
888  static void is_greater(const TValue1& val1, const TValue2& val2, const std::string& message, const tunit::line_info& line_info) {
889  try {
890  assert::is_greater(val1, val2, message, line_info);
891  } catch (...) {
892  base_assert::error();
893  }
894  }
895 
897  static void is_greater(const char* val1, const char* val2, const std::string& message, const tunit::line_info& line_info) {
898  try {
899  assert::is_greater(val1, val2, message, line_info);
900  } catch (...) {
901  base_assert::error();
902  }
903  }
904 
905  static void is_greater(const char16_t* val1, const char16_t* val2, const std::string& message, const tunit::line_info& line_info) {
906  try {
907  assert::is_greater(val1, val2, message, line_info);
908  } catch (...) {
909  base_assert::error();
910  }
911  }
912 
913  static void is_greater(const char32_t* val1, const char32_t* val2, const std::string& message, const tunit::line_info& line_info) {
914  try {
915  assert::is_greater(val1, val2, message, line_info);
916  } catch (...) {
917  base_assert::error();
918  }
919  }
920 
921  static void is_greater(const wchar_t* val1, const wchar_t* val2, const std::string& message, const tunit::line_info& line_info) {
922  try {
923  assert::is_greater(val1, val2, message, line_info);
924  } catch (...) {
925  base_assert::error();
926  }
927  }
929 
939  template<typename TValue1, typename TValue2>
940  static void is_greater_or_equal(const TValue1& val1, const TValue2& val2) {is_greater_or_equal(val1, val2, "", line_info());}
941 
952  template<typename TValue1, typename TValue2>
953  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);}
954 
965  template<typename TValue1, typename TValue2>
966  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());}
967 
979  template<typename TValue1, typename TValue2>
980  static void is_greater_or_equal(const TValue1& val1, const TValue2& val2, const std::string& message, const tunit::line_info& line_info) {
981  try {
982  assert::is_greater_or_equal(val1, val2, message, line_info);
983  } catch (...) {
984  base_assert::error();
985  }
986  }
987 
989  static void is_greater_or_equal(const char* val1, const char* val2, const std::string& message, const tunit::line_info& line_info) {
990  try {
991  assert::is_greater_or_equal(val1, val2, message, line_info);
992  } catch (...) {
993  base_assert::error();
994  }
995  }
996 
997  static void is_greater_or_equal(const char16_t* val1, const char16_t* val2, const std::string& message, const tunit::line_info& line_info) {
998  try {
999  assert::is_greater_or_equal(val1, val2, message, line_info);
1000  } catch (...) {
1001  base_assert::error();
1002  }
1003  }
1004 
1005  static void is_greater_or_equal(const char32_t* val1, const char32_t* val2, const std::string& message, const tunit::line_info& line_info) {
1006  try {
1007  assert::is_greater_or_equal(val1, val2, message, line_info);
1008  } catch (...) {
1009  base_assert::error();
1010  }
1011  }
1012 
1013  static void is_greater_or_equal(const wchar_t* val1, const wchar_t* val2, const std::string& message, const tunit::line_info& line_info) {
1014  try {
1015  assert::is_greater_or_equal(val1, val2, message, line_info);
1016  } catch (...) {
1017  base_assert::error();
1018  }
1019  }
1021 
1030  template<typename Type, typename TValue>
1031  static void is_instance_of(const TValue& value) {is_instance_of<Type>(value, "", line_info());}
1032 
1042  template<typename Type, typename TValue>
1043  static void is_instance_of(const TValue& value, const tunit::line_info& line_info) {is_instance_of<Type>(value, "", line_info);}
1044 
1054  template<typename Type, typename TValue>
1055  static void is_instance_of(const TValue& value, const std::string& message) {is_instance_of<Type>(value, message, line_info());}
1056 
1067  template<typename Type, typename TValue>
1068  static void is_instance_of(const TValue& value, const std::string& message, const tunit::line_info& line_info) {
1069  try {
1070  assert::is_instance_of<Type>(value, message, line_info);
1071  } catch (...) {
1072  base_assert::error();
1073  }
1074  }
1075 
1084  template<typename TValue1, typename TValue2>
1085  static void is_less(const TValue1& val1, const TValue2& val2) {is_less(val1, val2, "", line_info());}
1086 
1096  template<typename TValue1, typename TValue2>
1097  static void is_less(const TValue1& val1, const TValue2& val2, const tunit::line_info& line_info) {is_less(val1, val2, "", line_info);}
1098 
1108  template<typename TValue1, typename TValue2>
1109  static void is_less(const TValue1& val1, const TValue2& val2, const std::string& message) {is_less(val1, val2, message, line_info());}
1110 
1121  template<typename TValue1, typename TValue2>
1122  static void is_less(const TValue1& val1, const TValue2& val2, const std::string& message, const tunit::line_info& line_info) {
1123  try {
1124  assert::is_less(val1, val2, message, line_info);
1125  } catch (...) {
1126  base_assert::error();
1127  }
1128  }
1129 
1131  static void is_less(const char* val1, const char* val2, const std::string& message, const tunit::line_info& line_info) {
1132  try {
1133  assert::is_less(val1, val2, message, line_info);
1134  } catch (...) {
1135  base_assert::error();
1136  }
1137  }
1138 
1139  static void is_less(const char16_t* val1, const char16_t* val2, const std::string& message, const tunit::line_info& line_info) {
1140  try {
1141  assert::is_less(val1, val2, message, line_info);
1142  } catch (...) {
1143  base_assert::error();
1144  }
1145  }
1146 
1147  static void is_less(const char32_t* val1, const char32_t* val2, const std::string& message, const tunit::line_info& line_info) {
1148  try {
1149  assert::is_less(val1, val2, message, line_info);
1150  } catch (...) {
1151  base_assert::error();
1152  }
1153  }
1154 
1155  static void is_less(const wchar_t* val1, const wchar_t* val2, const std::string& message, const tunit::line_info& line_info) {
1156  try {
1157  assert::is_less(val1, val2, message, line_info);
1158  } catch (...) {
1159  base_assert::error();
1160  }
1161  }
1163 
1173  template<typename TValue1, typename TValue2>
1174  static void is_less_or_equal(const TValue1& val1, const TValue2& val2) {is_less_or_equal(val1, val2, "", line_info());}
1175 
1186  template<typename TValue1, typename TValue2>
1187  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);}
1188 
1199  template<typename TValue1, typename TValue2>
1200  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());}
1201 
1213  template<typename TValue1, typename TValue2>
1214  static void is_less_or_equal(const TValue1& val1, const TValue2& val2, const std::string& message, const tunit::line_info& line_info) {
1215  try {
1216  assert::is_less_or_equal(val1, val2, message, line_info);
1217  } catch (...) {
1218  base_assert::error();
1219  }
1220  }
1221 
1223  static void is_less_or_equal(const char* val1, const char* val2, const std::string& message, const tunit::line_info& line_info) {
1224  try {
1225  assert::is_less_or_equal(val1, val2, message, line_info);
1226  } catch (...) {
1227  base_assert::error();
1228  }
1229  }
1230 
1231  static void is_less_or_equal(const char16_t* val1, const char16_t* val2, const std::string& message, const tunit::line_info& line_info) {
1232  try {
1233  assert::is_less_or_equal(val1, val2, message, line_info);
1234  } catch (...) {
1235  base_assert::error();
1236  }
1237  }
1238 
1239  static void is_less_or_equal(const char32_t* val1, const char32_t* val2, const std::string& message, const tunit::line_info& line_info) {
1240  try {
1241  assert::is_less_or_equal(val1, val2, message, line_info);
1242  } catch (...) {
1243  base_assert::error();
1244  }
1245  }
1246 
1247  static void is_less_or_equal(const wchar_t* val1, const wchar_t* val2, const std::string& message, const tunit::line_info& line_info) {
1248  try {
1249  assert::is_less_or_equal(val1, val2, message, line_info);
1250  } catch (...) {
1251  base_assert::error();
1252  }
1253  }
1255 
1265  static void is_NaN(double value) {is_NaN(value, "", line_info());}
1266 
1277  static void is_NaN(double value, const tunit::line_info& line_info) {is_NaN(value, "", line_info);}
1278 
1289  static void is_NaN(double value, const std::string& message) {is_NaN(value, message, line_info());}
1290 
1302  static void is_NaN(double value, const std::string& message, const tunit::line_info& line_info) {
1303  try {
1304  assert::is_NaN(value, message, line_info);
1305  } catch (...) {
1306  base_assert::error();
1307  }
1308  }
1309 
1319  static void is_NaN(long double value) {is_NaN(value, "", line_info());}
1320 
1331  static void is_NaN(long double value, const tunit::line_info& line_info) {is_NaN(value, "", line_info);}
1332 
1343  static void is_NaN(long double value, const std::string& message) {is_NaN(value, message, line_info());}
1344 
1356  static void is_NaN(long double value, const std::string& message, const tunit::line_info& line_info) {
1357  try {
1358  assert::is_NaN(value, message, line_info);
1359  } catch (...) {
1360  base_assert::error();
1361  }
1362  }
1363 
1373  static void is_NaN(float value) {is_NaN(value, "", line_info());}
1374 
1385  static void is_NaN(float value, const tunit::line_info& line_info) {is_NaN(value, "", line_info);}
1386 
1397  static void is_NaN(float value, const std::string& message) {is_NaN(value, message, line_info());}
1398 
1410  static void is_NaN(float value, const std::string& message, const tunit::line_info& line_info) {
1411  try {
1412  assert::is_NaN(value, message, line_info);
1413  } catch (...) {
1414  base_assert::error();
1415  }
1416  }
1417 
1427  template<typename TValue>
1428  static void is_negative(const TValue& value) {is_negative(value, "", line_info());}
1429 
1440  template<typename TValue>
1441  static void is_negative(const TValue& value, const tunit::line_info& line_info) {is_negative(value, "", line_info);}
1442 
1453  template<typename TValue>
1454  static void is_negative(const TValue& value, const std::string& message) {is_negative(value, message, line_info());}
1455 
1467  template<typename TValue>
1468  static void is_negative(const TValue& value, const std::string& message, const tunit::line_info& line_info) {
1469  try {
1470  assert::is_negative(value, message, line_info);
1471  } catch (...) {
1472  base_assert::error();
1473  }
1474  }
1475 
1485  template<typename TValue>
1486  static void is_not_empty(const TValue& value) {is_not_empty(value, "", line_info());}
1487 
1498  template<typename TValue>
1499  static void is_not_empty(const TValue& value, const tunit::line_info& line_info) {is_not_empty(value, "", line_info);}
1500 
1511  template<typename TValue>
1512  static void is_not_empty(const TValue& value, const std::string& message) {is_not_empty(value, message, line_info());}
1513 
1525  template<typename TValue>
1526  static void is_not_empty(const TValue& value, const std::string& message, const tunit::line_info& line_info) {
1527  try {
1528  assert::is_not_empty(value, message, line_info);
1529  } catch (...) {
1530  base_assert::error();
1531  }
1532  }
1533 
1535  template<typename TValue>
1536  static void is_not_empty(const std::initializer_list<TValue>& value) {is_not_empty(value, "", line_info());}
1537  template<typename TValue>
1538  static void is_not_empty(const std::initializer_list<TValue>& value, const tunit::line_info& line_info) {is_not_empty(value, "", line_info);}
1539  template<typename TValue>
1540  static void is_not_empty(const std::initializer_list<TValue>& value, const std::string& message) {is_not_empty(value, message, line_info());}
1541  template<typename TValue>
1542  static void is_not_empty(const std::initializer_list<TValue>& value, const std::string& message, const tunit::line_info& line_info) {
1543  try {
1544  assert::is_not_empty(value, message, line_info);
1545  } catch (...) {
1546  base_assert::error();
1547  }
1548  }
1549 
1550  static void is_not_empty(const char* value, const std::string& message, const tunit::line_info& line_info) {
1551  try {
1552  assert::is_not_empty(value, message, line_info);
1553  } catch (...) {
1554  base_assert::error();
1555  }
1556  }
1557 
1558  static void is_not_empty(const char16_t* value, const std::string& message, const tunit::line_info& line_info) {
1559  try {
1560  assert::is_not_empty(value, message, line_info);
1561  } catch (...) {
1562  base_assert::error();
1563  }
1564  }
1565 
1566  static void is_not_empty(const char32_t* value, const std::string& message, const tunit::line_info& line_info) {
1567  try {
1568  assert::is_not_empty(value, message, line_info);
1569  } catch (...) {
1570  base_assert::error();
1571  }
1572  }
1573 
1574  static void is_not_empty(const wchar_t* value, const std::string& message, const tunit::line_info& line_info) {
1575  try {
1576  assert::is_not_empty(value, message, line_info);
1577  } catch (...) {
1578  base_assert::error();
1579  }
1580  }
1582 
1591  template<typename Type, typename TValue>
1592  static void is_not_instance_of(const TValue& value) {is_not_instance_of<Type>(value, "", line_info());}
1593 
1603  template<typename Type, typename TValue>
1604  static void is_not_instance_of(const TValue& value, const tunit::line_info& line_info) {is_not_instance_of<Type>(value, "", line_info);}
1605 
1615  template<typename Type, typename TValue>
1616  static void is_not_instance_of(const TValue& value, const std::string& message) {is_not_instance_of<Type>(value, message, line_info());}
1617 
1628  template<typename Type, typename TValue>
1629  static void is_not_instance_of(const TValue& value, const std::string& message, const tunit::line_info& line_info) {
1630  try {
1631  assert::is_not_instance_of<Type>(value, message, line_info);
1632  } catch (...) {
1633  base_assert::error();
1634  }
1635  }
1636 
1647  template<typename TPointer>
1648  static void is_not_null(const TPointer* pointer) {is_not_null(pointer, "", line_info());}
1649 
1661  template<typename TPointer>
1662  static void is_not_null(const TPointer* pointer, const tunit::line_info& line_info) {is_not_null(pointer, "", line_info);}
1663 
1675  template<typename TPointer>
1676  static void is_not_null(const TPointer* pointer, const std::string& message) {is_not_null(pointer, message, line_info());}
1677 
1690  template<typename TPointer>
1691  static void is_not_null(const TPointer* pointer, const std::string& message, const tunit::line_info& line_info) {
1692  try {
1693  assert::is_not_null(pointer, message, line_info);
1694  } catch (...) {
1695  base_assert::error();
1696  }
1697  }
1698 
1708  template<typename TPointer>
1709  static void is_not_null(const std::unique_ptr<TPointer>& pointer) {is_not_null(pointer, "", line_info());}
1710 
1721  template<typename TPointer>
1722  static void is_not_null(const std::unique_ptr<TPointer>& pointer, const tunit::line_info& line_info) {is_not_null(pointer, "", line_info);}
1723 
1734  template<typename TPointer>
1735  static void is_not_null(const std::unique_ptr<TPointer>& pointer, const std::string& message) {is_not_null(pointer, message, line_info());}
1736 
1748  template<typename TPointer>
1749  static void is_not_null(const std::unique_ptr<TPointer>& pointer, const std::string& message, const tunit::line_info& line_info) {
1750  try {
1751  assert::is_not_null(pointer, message, line_info);
1752  } catch (...) {
1753  base_assert::error();
1754  }
1755  }
1756 
1766  template<typename TPointer>
1767  static void is_not_null(const std::shared_ptr<TPointer>& pointer) {is_not_null(pointer, "", line_info());}
1768 
1779  template<typename TPointer>
1780  static void is_not_null(const std::shared_ptr<TPointer>& pointer, const tunit::line_info& line_info) {is_not_null(pointer, "", line_info);}
1781 
1792  template<typename TPointer>
1793  static void is_not_null(const std::shared_ptr<TPointer>& pointer, const std::string& message) {is_not_null(pointer, message, line_info());}
1794 
1806  template<typename TPointer>
1807  static void is_not_null(const std::shared_ptr<TPointer>& pointer, const std::string& message, const tunit::line_info& line_info) {
1808  try {
1809  assert::is_not_null(pointer, message, line_info);
1810  } catch (...) {
1811  base_assert::error();
1812  }
1813  }
1814 
1826  template<typename TPointer>
1827  static void is_not_null(const std::weak_ptr<TPointer>& pointer) {is_not_null(pointer, "", line_info());}
1828 
1841  template<typename TPointer>
1842  static void is_not_null(const std::weak_ptr<TPointer>& pointer, const tunit::line_info& line_info) {is_not_null(pointer, "", line_info);}
1843 
1856  template<typename TPointer>
1857  static void is_not_null(const std::weak_ptr<TPointer>& pointer, const std::string& message) {is_not_null(pointer, message, line_info());}
1858 
1872  template<typename TPointer>
1873  static void is_not_null(const std::weak_ptr<TPointer>& pointer, const std::string& message, const tunit::line_info& line_info) {assert::succeed(message, line_info);}
1874 
1882  static void is_not_null(std::nullptr_t pointer) {is_not_null(pointer, "", line_info());}
1883 
1892  static void is_not_null(std::nullptr_t pointer, const tunit::line_info& line_info) {is_not_null(pointer, "", line_info);}
1893 
1902  static void is_not_null(std::nullptr_t pointer, const std::string& message) {is_not_null(pointer, message, line_info());}
1903 
1913  static void is_not_null(std::nullptr_t pointer, const std::string& message, const tunit::line_info& line_info) {
1914  try {
1915  assert::is_not_null(pointer, message, line_info);
1916  } catch (...) {
1917  base_assert::error();
1918  }
1919  }
1920 
1930  template<typename TValue>
1931  static void is_not_zero(const TValue& value) {is_not_zero(value, "", line_info());}
1932 
1943  template<typename TValue>
1944  static void is_not_zero(const TValue& value, const tunit::line_info& line_info) {is_not_zero(value, "", line_info);}
1945 
1956  template<typename TValue>
1957  static void is_not_zero(const TValue& value, const std::string& message) {is_not_zero(value, message, line_info());}
1958 
1970  template<typename TValue>
1971  static void is_not_zero(const TValue& value, const std::string& message, const tunit::line_info& line_info) {
1972  try {
1973  assert::is_zero(value, message, line_info);
1974  } catch (...) {
1975  base_assert::error();
1976  }
1977  }
1978 
1989  template<typename TPointer>
1990  static void is_null(const TPointer* pointer) {is_null(pointer, "", line_info());}
1991 
2003  template<typename TPointer>
2004  static void is_null(const TPointer* pointer, const tunit::line_info& line_info) {is_null(pointer, "", line_info);}
2005 
2017  template<typename TPointer>
2018  static void is_null(const TPointer* pointer, const std::string& message) {is_null(pointer, message, line_info());}
2019 
2032  template<typename TPointer>
2033  static void is_null(const TPointer* pointer, const std::string& message, const tunit::line_info& line_info) {
2034  try {
2035  assert::is_null(pointer, message, line_info);
2036  } catch (...) {
2037  base_assert::error();
2038  }
2039  }
2040 
2050  template<typename TPointer>
2051  static void is_null(const std::unique_ptr<TPointer>& pointer) {is_null(pointer, "", line_info());}
2052 
2063  template<typename TPointer>
2064  static void is_null(const std::unique_ptr<TPointer>& pointer, const tunit::line_info& line_info) {is_null(pointer, "", line_info);}
2065 
2076  template<typename TPointer>
2077  static void is_null(const std::unique_ptr<TPointer>& pointer, const std::string& message) {is_null(pointer, message, line_info());}
2078 
2090  template<typename TPointer>
2091  static void is_null(const std::unique_ptr<TPointer>& pointer, const std::string& message, const tunit::line_info& line_info) {
2092  try {
2093  assert::is_null(pointer, message, line_info);
2094  } catch (...) {
2095  base_assert::error();
2096  }
2097  }
2098 
2108  template<typename TPointer>
2109  static void is_null(const std::shared_ptr<TPointer>& pointer) {is_null(pointer, "", line_info());}
2110 
2121  template<typename TPointer>
2122  static void is_null(const std::shared_ptr<TPointer>& pointer, const tunit::line_info& line_info) {is_null(pointer, "", line_info);}
2123 
2134  template<typename TPointer>
2135  static void is_null(const std::shared_ptr<TPointer>& pointer, const std::string& message) {is_null(pointer, message, line_info());}
2136 
2148  template<typename TPointer>
2149  static void is_null(const std::shared_ptr<TPointer>& pointer, const std::string& message, const tunit::line_info& line_info) {
2150  try {
2151  assert::is_null(pointer, message, line_info);
2152  } catch (...) {
2153  base_assert::error();
2154  }
2155  }
2156 
2168  template<typename TPointer>
2169  static void is_null(const std::weak_ptr<TPointer>& pointer) {is_null(pointer, "", line_info());}
2170 
2183  template<typename TPointer>
2184  static void is_null(const std::weak_ptr<TPointer>& pointer, const tunit::line_info& line_info) {is_null(pointer, "", line_info);}
2185 
2198  template<typename TPointer>
2199  static void is_null(const std::weak_ptr<TPointer>& pointer, const std::string& message) {is_null(pointer, message, line_info());}
2200 
2214  template<typename TPointer>
2215  static void is_null(const std::weak_ptr<TPointer>& pointer, const std::string& message, const tunit::line_info& line_info) {
2216  try {
2217  assert::is_null(pointer, message, line_info);
2218  } catch (...) {
2219  base_assert::error();
2220  }
2221  }
2222 
2230  static void is_null(std::nullptr_t pointer) {is_null(pointer, "", line_info());}
2231 
2240  static void is_null(std::nullptr_t pointer, const tunit::line_info& line_info) {is_null(pointer, "", line_info);}
2241 
2250  static void is_null(std::nullptr_t pointer, const std::string& message) {is_null(pointer, message, line_info());}
2251 
2261  static void is_null(std::nullptr_t pointer, const std::string& message, const tunit::line_info& line_info) {assert::succeed(message, line_info);}
2262 
2272  template<typename TValue>
2273  static void is_positive(const TValue& value) {is_positive(value, "", line_info());}
2274 
2285  template<typename TValue>
2286  static void is_positive(const TValue& value, const tunit::line_info& line_info) {is_positive(value, "", line_info);}
2287 
2298  template<typename TValue>
2299  static void is_positive(const TValue& value, const std::string& message) {is_positive(value, message, line_info());}
2300 
2312  template<typename TValue>
2313  static void is_positive(const TValue& value, const std::string& message, const tunit::line_info& line_info) {
2314  try {
2315  assert::is_positive(value, message, line_info);
2316  } catch (...) {
2317  base_assert::error();
2318  }
2319  }
2320 
2330  static void is_true(bool condition) {is_true(condition, "", line_info());}
2331 
2342  static void is_true(bool condition, const tunit::line_info& line_info) {is_true(condition, "", line_info);}
2343 
2354  static void is_true(bool condition, const std::string& message) {is_true(condition, message, line_info());}
2355 
2367  static void is_true(bool condition, const std::string& message, const tunit::line_info& line_info) {
2368  try {
2369  assert::is_true(condition, message, line_info);
2370  } catch (...) {
2371  base_assert::error();
2372  }
2373  }
2374 
2384  template<typename TValue>
2385  static void is_zero(const TValue& value) {is_zero(value, "", line_info());}
2386 
2397  template<typename TValue>
2398  static void is_zero(const TValue& value, const tunit::line_info& line_info) {is_zero(value, "", line_info);}
2399 
2410  template<typename TValue>
2411  static void is_zero(const TValue& value, const std::string& message) {is_zero(value, message, line_info());}
2412 
2424  template<typename TValue>
2425  static void is_zero(const TValue& value, const std::string& message, const tunit::line_info& line_info) {
2426  try {
2427  assert::is_zero(value, message, line_info);
2428  } catch (...) {
2429  base_assert::error();
2430  }
2431  }
2432 
2442  template<typename TException>
2443  static void throws(const std::function<void()>& statement) {throws<TException>(statement, "", line_info());}
2444 
2455  template<typename TException>
2456  static void throws(const std::function<void()>& statement, const tunit::line_info& line_info) {throws<TException>(statement, "", line_info);}
2457 
2468  template<typename TException>
2469  static void throws(const std::function<void()>& statement, const std::string& message) {throws<TException>(statement, message, line_info());}
2470 
2482  template<typename TException>
2483  static void throws(const std::function<void()>& statement, const std::string& message, const tunit::line_info& line_info) {
2484  try {
2485  assert::throws<TException>(statement, message, line_info);
2486  } catch (...) {
2487  base_assert::error();
2488  }
2489  }
2490 
2499  static void throws_any(const std::function<void()>& statement) {throws_any(statement, "", line_info());}
2500 
2510  static void throws_any(const std::function<void()>& statement, const tunit::line_info& line_info) {throws_any(statement, "", line_info);}
2511 
2521  static void throws_any(const std::function<void()>& statement, const std::string& message) {throws_any(statement, message, line_info());}
2522 
2533  static void throws_any(const std::function<void()>& statement, const std::string& message, const tunit::line_info& line_info) {
2534  try {
2535  assert::throws_any(statement, message, line_info);
2536  } catch (...) {
2537  base_assert::error();
2538  }
2539  }
2540  };
2541 }
tunit::valid::is_instance_of
static void is_instance_of(const TValue &value, const std::string &message, const tunit::line_info &line_info)
Valids that an object is of the type supplied or a derived type.
Definition: valid.h:1068
tunit::valid::is_NaN
static void is_NaN(float value, const tunit::line_info &line_info)
that a value is NaN.
Definition: valid.h:1385
tunit::valid::contains
static void contains(const TItem &item, const TCollection &collection, const std::string &message)
Valids that collection contains an item.
Definition: valid.h:560
tunit::valid::does_not_throw
static void does_not_throw(const std::function< void()> &statement)
Valids that the staement does not throw an exception.
Definition: valid.h:639
tunit::valid::are_equal
static void are_equal(const TExpected &expected, const TActual &actual)
Valids that two type are equal.
Definition: valid.h:27
tunit::valid::is_not_null
static void is_not_null(const std::weak_ptr< TPointer > &pointer)
Valids that the pointer is not null.
Definition: valid.h:1827
tunit::valid::is_positive
static void is_positive(const TValue &value, const std::string &message, const tunit::line_info &line_info)
Valids that ta condition is positive.
Definition: valid.h:2313
tunit::valid::is_null
static void is_null(const std::weak_ptr< TPointer > &pointer, const tunit::line_info &line_info)
Valids that the pointer is null.
Definition: valid.h:2184
tunit::valid::are_equal
static void are_equal(double expected, double actual, double tolerance, const tunit::line_info &line_info)
Valids that two type are equal.
Definition: valid.h:211
tunit::valid::is_negative
static void is_negative(const TValue &value)
Valids that ta condition is negative.
Definition: valid.h:1428
tunit::valid::is_not_null
static void is_not_null(std::nullptr_t pointer, const std::string &message)
Valids that the pointer is not null.
Definition: valid.h:1902
tunit::valid::are_equal
static void are_equal(const TExpected &expected, const TActual &actual, const std::string &message)
Valids that two type are equal.
Definition: valid.h:51
tunit::valid::is_negative
static void is_negative(const TValue &value, const tunit::line_info &line_info)
Valids that ta condition is negative.
Definition: valid.h:1441
tunit::valid::are_not_equal
static void are_not_equal(const TExpected &expected, const TActual &actual)
Valids that two type are not equal.
Definition: valid.h:313
tunit::valid::is_zero
static void is_zero(const TValue &value, const std::string &message, const tunit::line_info &line_info)
Valids that ta condition is zero.
Definition: valid.h:2425
tunit::valid::is_null
static void is_null(const TPointer *pointer)
Valids that the pointer is null.
Definition: valid.h:1990
tunit::valid::are_equal
static void are_equal(double expected, double actual, double tolerance)
Valids that two type are equal.
Definition: valid.h:198
tunit::valid::are_equal
static void are_equal(long double expected, long double actual, long double tolerance, const tunit::line_info &line_info)
Valids that two type are equal.
Definition: valid.h:269
tunit::valid::is_true
static void is_true(bool condition, const std::string &message, const tunit::line_info &line_info)
Valids that a condition is true.
Definition: valid.h:2367
tunit::valid::is_null
static void is_null(const TPointer *pointer, const tunit::line_info &line_info)
Valids that the pointer is null.
Definition: valid.h:2004
tunit::valid::is_NaN
static void is_NaN(long double value)
that a value is NaN.
Definition: valid.h:1319
tunit::valid::is_NaN
static void is_NaN(long double value, const std::string &message)
Valids that a value is NaN.
Definition: valid.h:1343
tunit::valid::is_null
static void is_null(const std::unique_ptr< TPointer > &pointer, const tunit::line_info &line_info)
Valids that the pointer is null.
Definition: valid.h:2064
tunit::valid::is_less
static void is_less(const TValue1 &val1, const TValue2 &val2, const tunit::line_info &line_info)
Valids that the first value is is_less than the second value.
Definition: valid.h:1097
tunit::valid::throws_any
static void throws_any(const std::function< void()> &statement)
Valids that the staement does not throw an exception.
Definition: valid.h:2499
tunit::valid::are_equal
static void are_equal(const TExpected &expected, const TActual &actual, const std::string &message, const tunit::line_info &line_info)
Valids that two type are equal.
Definition: valid.h:64
tunit::assert::is_false
static void is_false(bool condition)
Asserts that ta condition is false.
Definition: assert.h:845
tunit::valid::is_true
static void is_true(bool condition, const std::string &message)
Valids that a condition is true.
Definition: valid.h:2354
tunit::assert::is_true
static void is_true(bool condition)
Asserts that ta condition is true.
Definition: assert.h:2414
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::valid::is_empty
static void is_empty(const TValue &value, const std::string &message, const tunit::line_info &line_info)
Valids that collection contains an item.
Definition: valid.h:731
tunit::valid::is_greater_or_equal
static void is_greater_or_equal(const TValue1 &val1, const TValue2 &val2)
Valids that the first value is greater than or equal to the second value.
Definition: valid.h:940
tunit::valid::is_null
static void is_null(const std::unique_ptr< TPointer > &pointer, const std::string &message, const tunit::line_info &line_info)
Valids that the pointer is null.
Definition: valid.h:2091
tunit::valid::is_zero
static void is_zero(const TValue &value, const std::string &message)
Valids that ta condition is zero.
Definition: valid.h:2411
tunit::valid::is_positive
static void is_positive(const TValue &value, const std::string &message)
Valids that ta condition is positive.
Definition: valid.h:2299
tunit::valid::is_null
static void is_null(const TPointer *pointer, const std::string &message, const tunit::line_info &line_info)
Valids that the pointer is null.
Definition: valid.h:2033
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::valid::are_not_same
static void are_not_same(const TExpected &expected, const TActual &actual, const std::string &message)
Valids that two objects do refer to differents objects.
Definition: valid.h:434
tunit::valid::is_not_null
static void is_not_null(const std::weak_ptr< TPointer > &pointer, const tunit::line_info &line_info)
Valids that the pointer is not null.
Definition: valid.h:1842
tunit::valid::are_not_equal
static void are_not_equal(const TExpected &expected, const TActual &actual, const std::string &message)
Valids that two type are not equal.
Definition: valid.h:337
tunit::valid::throws_any
static void throws_any(const std::function< void()> &statement, const tunit::line_info &line_info)
Valids that the staement does not throw an exception.
Definition: valid.h:2510
tunit::valid::is_NaN
static void is_NaN(float value)
that a value is NaN.
Definition: valid.h:1373
tunit::valid::is_empty
static void is_empty(const TValue &value)
Valids that collection contains an item.
Definition: valid.h:691
tunit::valid::are_same
static void are_same(const TExpected &expected, const TActual &actual, const std::string &message)
Valids that two objects do refer to differents objects.
Definition: valid.h:500
tunit::valid::is_not_null
static void is_not_null(const std::shared_ptr< TPointer > &pointer, const std::string &message)
Valids that the pointer is not null.
Definition: valid.h:1793
tunit::valid::contains
static void contains(const TItem &item, const TCollection &collection, const std::string &message, const tunit::line_info &line_info)
Valids that collection contains an item.
Definition: valid.h:574
tunit::assert::is_zero
static void is_zero(const TValue &value)
Asserts that ta condition is zero.
Definition: assert.h:2472
tunit::valid::is_less_or_equal
static void is_less_or_equal(const TValue1 &val1, const TValue2 &val2)
Valids that the first value is is_less than or equal to the second value.
Definition: valid.h:1174
tunit::valid::is_empty
static void is_empty(const TValue &value, const std::string &message)
Valids that collection contains an item.
Definition: valid.h:717
tunit::valid::are_equal
static void are_equal(double expected, double actual, double tolerance, const std::string &message, const tunit::line_info &line_info)
Valids that two type are equal.
Definition: valid.h:238
tunit::valid::is_less_or_equal
static void is_less_or_equal(const TValue1 &val1, const TValue2 &val2, const std::string &message)
Valids that the first value is is_less than or equal to the second value.
Definition: valid.h:1200
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::valid::contains
static void contains(const TItem &item, const TCollection &collection, const tunit::line_info &line_info)
Valids that collection contains an item.
Definition: valid.h:547
tunit::valid::is_NaN
static void is_NaN(long double value, const tunit::line_info &line_info)
that a value is NaN.
Definition: valid.h:1331
tunit::valid::is_instance_of
static void is_instance_of(const TValue &value, const tunit::line_info &line_info)
Valids that an object is of the type supplied or a derived type.
Definition: valid.h:1043
tunit::valid::is_not_instance_of
static void is_not_instance_of(const TValue &value, const std::string &message)
Valids that an object is not of the type supplied or a derived type.
Definition: valid.h:1616
tunit::assert::contains
static void contains(const TItem &item, const TCollection &collection)
Asserts that collection contains an item.
Definition: assert.h:565
tunit::valid::is_negative
static void is_negative(const TValue &value, const std::string &message, const tunit::line_info &line_info)
Valids that ta condition is negative.
Definition: valid.h:1468
tunit::valid::is_null
static void is_null(const std::unique_ptr< TPointer > &pointer)
Valids that the pointer is null.
Definition: valid.h:2051
tunit::valid::is_not_zero
static void is_not_zero(const TValue &value)
Valids that ta condition is not zero.
Definition: valid.h:1931
tunit::valid::is_less
static void is_less(const TValue1 &val1, const TValue2 &val2)
Valids that the first value is is_less than the second value.
Definition: valid.h:1085
tunit::valid::is_not_null
static void is_not_null(std::nullptr_t pointer, const std::string &message, const tunit::line_info &line_info)
Valids that the pointer is not null.
Definition: valid.h:1913
line_info_
#define line_info_
Get tunit::line_info informations.
Definition: line_info.h:75
tunit::valid::contains
static void contains(const TItem &item, const TCollection &collection)
Valids that collection contains an item.
Definition: valid.h:534
tunit::valid::is_not_empty
static void is_not_empty(const TValue &value, const tunit::line_info &line_info)
Valids that collection does not contain any item.
Definition: valid.h:1499
tunit::valid::is_not_null
static void is_not_null(const std::weak_ptr< TPointer > &pointer, const std::string &message)
Valids that the pointer is not null.
Definition: valid.h:1857
tunit::valid::are_equal
static void are_equal(long double expected, long double actual, long double tolerance, const std::string &message)
Valids that two type are equal.
Definition: valid.h:282
tunit::valid::are_equal
static void are_equal(double expected, double actual, double tolerance, const std::string &message)
Valids that two type are equal.
Definition: valid.h:224
assert.h
Contains tunit::assert class.
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::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::valid::is_true
static void is_true(bool condition)
Valids that ta condition is true.
Definition: valid.h:2330
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::valid::does_not_throw
static void does_not_throw(const std::function< void()> &statement, const tunit::line_info &line_info)
Valids that the staement does not throw an exception.
Definition: valid.h:650
tunit::valid::is_not_empty
static void is_not_empty(const TValue &value)
Valids that collection oes not contain any item.
Definition: valid.h:1486
tunit::valid::is_null
static void is_null(const std::weak_ptr< TPointer > &pointer, const std::string &message, const tunit::line_info &line_info)
Valids that the pointer is null.
Definition: valid.h:2215
tunit::valid::is_NaN
static void is_NaN(double value, const std::string &message)
Valids that a value is NaN.
Definition: valid.h:1289
tunit::assert::is_positive
static void is_positive(const TValue &value)
Asserts that ta condition is positive.
Definition: assert.h:2354
tunit::valid::is_not_null
static void is_not_null(const std::unique_ptr< TPointer > &pointer, const tunit::line_info &line_info)
Valids that the pointer is not null.
Definition: valid.h:1722
tunit::valid::is_zero
static void is_zero(const TValue &value)
Valids that ta condition is zero.
Definition: valid.h:2385
tunit::valid::is_not_null
static void is_not_null(const std::shared_ptr< TPointer > &pointer, const std::string &message, const tunit::line_info &line_info)
Valids that the pointer is not null.
Definition: valid.h:1807
tunit::valid::is_greater_or_equal
static void is_greater_or_equal(const TValue1 &val1, const TValue2 &val2, const tunit::line_info &line_info)
Valids that the first value is greater than or equal to the second value.
Definition: valid.h:953
tunit::valid::are_equal
static void are_equal(float expected, float actual, float tolerance, const tunit::line_info &line_info)
Valids that two type are equal.
Definition: valid.h:153
tunit::valid::is_zero
static void is_zero(const TValue &value, const tunit::line_info &line_info)
Valids that ta condition is zero.
Definition: valid.h:2398
tunit::valid::is_not_null
static void is_not_null(const std::unique_ptr< TPointer > &pointer, const std::string &message, const tunit::line_info &line_info)
Valids that the pointer is not null.
Definition: valid.h:1749
tunit::valid::is_null
static void is_null(const std::shared_ptr< TPointer > &pointer)
Valids that the pointer is null.
Definition: valid.h:2109
tunit::valid::is_not_zero
static void is_not_zero(const TValue &value, const tunit::line_info &line_info)
Valids that ta condition is not zero.
Definition: valid.h:1944
tunit::valid::is_null
static void is_null(const std::shared_ptr< TPointer > &pointer, const std::string &message)
Valids that the pointer is null.
Definition: valid.h:2135
tunit::valid::are_not_same
static void are_not_same(const TExpected &expected, const TActual &actual, const std::string &message, const tunit::line_info &line_info)
Valids that two objects do refer to differents objects.
Definition: valid.h:450
tunit::valid::is_instance_of
static void is_instance_of(const TValue &value)
Valids that an object is of the type supplied or a derived type.
Definition: valid.h:1031
tunit::valid::is_not_null
static void is_not_null(std::nullptr_t pointer, const tunit::line_info &line_info)
Valids that the pointer is not null.
Definition: valid.h:1892
tunit::valid::is_NaN
static void is_NaN(double value, const tunit::line_info &line_info)
that a value is NaN.
Definition: valid.h:1277
tunit::assert::is_negative
static void is_negative(const TValue &value)
Asserts that ta condition is negative.
Definition: assert.h:1488
tunit::valid::is_null
static void is_null(const std::shared_ptr< TPointer > &pointer, const tunit::line_info &line_info)
Valids that the pointer is null.
Definition: valid.h:2122
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::valid::is_not_null
static void is_not_null(const TPointer *pointer, const tunit::line_info &line_info)
Valids that the pointer is not null.
Definition: valid.h:1662
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::valid::is_not_zero
static void is_not_zero(const TValue &value, const std::string &message, const tunit::line_info &line_info)
Valids that ta condition is not zero.
Definition: valid.h:1971
tunit::valid::is_not_null
static void is_not_null(const std::unique_ptr< TPointer > &pointer)
Valids that the pointer is not null.
Definition: valid.h:1709
tunit::valid::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)
Valids that two type are equal.
Definition: valid.h:296
tunit::valid::is_not_null
static void is_not_null(const std::unique_ptr< TPointer > &pointer, const std::string &message)
Valids that the pointer is not null.
Definition: valid.h:1735
tunit::valid::does_not_throw
static void does_not_throw(const std::function< void()> &statement, const std::string &message)
Valids that the staement does not throw an exception.
Definition: valid.h:661
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::valid::is_null
static void is_null(const TPointer *pointer, const std::string &message)
Valids that the pointer is null.
Definition: valid.h:2018
tunit::valid::is_null
static void is_null(const std::weak_ptr< TPointer > &pointer, const std::string &message)
Valids that the pointer is null.
Definition: valid.h:2199
tunit::valid::is_null
static void is_null(const std::shared_ptr< TPointer > &pointer, const std::string &message, const tunit::line_info &line_info)
Valids that the pointer is null.
Definition: valid.h:2149
tunit::valid::is_not_instance_of
static void is_not_instance_of(const TValue &value, const tunit::line_info &line_info)
Valids that an object is not of the type supplied or a derived type.
Definition: valid.h:1604
tunit::valid::is_not_empty
static void is_not_empty(const TValue &value, const std::string &message, const tunit::line_info &line_info)
Valids that collection does not contain any item.
Definition: valid.h:1526
tunit::valid::are_equal
static void are_equal(const TExpected &expected, const TActual &actual, const tunit::line_info &line_info)
Valids that two type are equal.
Definition: valid.h:39
tunit::valid::are_not_equal
static void are_not_equal(const TExpected &expected, const TActual &actual, const std::string &message, const tunit::line_info &line_info)
Valids that two type are not equal.
Definition: valid.h:350
tunit::valid::are_same
static void are_same(const TExpected &expected, const TActual &actual)
Valids that two objects do refer to differents objects.
Definition: valid.h:470
tunit::valid::is_null
static void is_null(std::nullptr_t pointer, const std::string &message, const tunit::line_info &line_info)
Valids that the pointer is null.
Definition: valid.h:2261
tunit::valid::is_null
static void is_null(std::nullptr_t pointer, const std::string &message)
Valids that the pointer is null.
Definition: valid.h:2250
tunit::assert::is_null
static void is_null(const TPointer *pointer)
Asserts that the pointer is null.
Definition: assert.h:2064
tunit::valid::is_not_instance_of
static void is_not_instance_of(const TValue &value, const std::string &message, const tunit::line_info &line_info)
Valids that an object is not of the type supplied or a derived type.
Definition: valid.h:1629
tunit::assert::is_empty
static void is_empty(const TValue &value)
Asserts that collection contains an item.
Definition: assert.h:737
tunit::valid::is_not_null
static void is_not_null(const TPointer *pointer, const std::string &message)
Valids that the pointer is not null.
Definition: valid.h:1676
tunit::valid::is_instance_of
static void is_instance_of(const TValue &value, const std::string &message)
Valids that an object is of the type supplied or a derived type.
Definition: valid.h:1055
tunit::valid::is_less
static void is_less(const TValue1 &val1, const TValue2 &val2, const std::string &message, const tunit::line_info &line_info)
Valids that the first value is is_less than the second value.
Definition: valid.h:1122
tunit::valid::are_equal
static void are_equal(float expected, float actual, float tolerance, const std::string &message, const tunit::line_info &line_info)
Valids that two type are equal.
Definition: valid.h:180
tunit::valid::is_not_instance_of
static void is_not_instance_of(const TValue &value)
Valids that an object is not of the type supplied or a derived type.
Definition: valid.h:1592
tunit::base_assert
Definition: base_assert.h:15
tunit::valid::is_less_or_equal
static void is_less_or_equal(const TValue1 &val1, const TValue2 &val2, const tunit::line_info &line_info)
Valids that the first value is is_less than or equal to the second value.
Definition: valid.h:1187
tunit::base_assert::succeed
static void succeed()
Generates a success with a generic message.
Definition: base_assert.h:130
tunit::assert::is_NaN
static void is_NaN(double value)
that a value is NaN.
Definition: assert.h:1316
tunit::valid::is_not_null
static void is_not_null(const TPointer *pointer)
Valids that the pointer is not null.
Definition: valid.h:1648
tunit::valid::are_same
static void are_same(const TExpected &expected, const TActual &actual, const tunit::line_info &line_info)
Valids that two objects do refer to differents objects.
Definition: valid.h:485
tunit::valid::is_empty
static void is_empty(const TValue &value, const tunit::line_info &line_info)
Valids that collection contains an item.
Definition: valid.h:704
tunit
The tunit namespace contains a unit test library.
Definition: abort_error.h:8
tunit::valid::is_greater_or_equal
static void is_greater_or_equal(const TValue1 &val1, const TValue2 &val2, const std::string &message)
Valids that the first value is greater than or equal to the second value.
Definition: valid.h:966
tunit::valid::is_negative
static void is_negative(const TValue &value, const std::string &message)
Valids that ta condition is negative.
Definition: valid.h:1454
tunit::valid::is_NaN
static void is_NaN(double value)
that a value is NaN.
Definition: valid.h:1265
tunit::valid::throws_any
static void throws_any(const std::function< void()> &statement, const std::string &message)
Valids that the staement does not throw an exception.
Definition: valid.h:2521
tunit::valid::are_equal
static void are_equal(float expected, float &actual, float tolerance, const std::string &message)
Valids that two type are equal.
Definition: valid.h:166
tunit::valid::is_null
static void is_null(const std::unique_ptr< TPointer > &pointer, const std::string &message)
Valids that the pointer is null.
Definition: valid.h:2077
tunit::valid::does_not_throw
static void does_not_throw(const std::function< void()> &statement, const std::string &message, const tunit::line_info &line_info)
Valids that the staement does not throw an exception.
Definition: valid.h:673
tunit::valid::is_true
static void is_true(bool condition, const tunit::line_info &line_info)
Valids that a condition is true.
Definition: valid.h:2342
tunit::valid::is_not_null
static void is_not_null(const TPointer *pointer, const std::string &message, const tunit::line_info &line_info)
Valids that the pointer is not null.
Definition: valid.h:1691
tunit::valid::is_not_null
static void is_not_null(const std::shared_ptr< TPointer > &pointer)
Valids that the pointer is not null.
Definition: valid.h:1767
tunit::valid::is_NaN
static void is_NaN(long double value, const std::string &message, const tunit::line_info &line_info)
Valids that a value is NaN.
Definition: valid.h:1356
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::valid::throws_any
static void throws_any(const std::function< void()> &statement, const std::string &message, const tunit::line_info &line_info)
Valids that the staement does not throw an exception.
Definition: valid.h:2533
tunit::valid::is_NaN
static void is_NaN(float value, const std::string &message)
Valids that a value is NaN.
Definition: valid.h:1397
tunit::valid::are_not_equal
static void are_not_equal(const TExpected &expected, const TActual &actual, const tunit::line_info &line_info)
Valids that two type are not equal.
Definition: valid.h:325
tunit::valid::is_not_null
static void is_not_null(const std::shared_ptr< TPointer > &pointer, const tunit::line_info &line_info)
Valids that the pointer is not null.
Definition: valid.h:1780
tunit::valid
The assert class contains a collection of static methods that implement the most common assertions us...
Definition: valid.h:12
tunit::valid::is_not_empty
static void is_not_empty(const TValue &value, const std::string &message)
Valids that collection does not contain any item.
Definition: valid.h:1512
tunit::valid::is_not_null
static void is_not_null(std::nullptr_t pointer)
Valids that the pointer is not null.
Definition: valid.h:1882
tunit::valid::is_positive
static void is_positive(const TValue &value)
Valids that ta condition is positive.
Definition: valid.h:2273
tunit::valid::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)
Valids that the first value is greater than or equal to the second value.
Definition: valid.h:980
tunit::valid::are_equal
static void are_equal(long double expected, long double actual, long double tolerance)
Valids that two type are equal.
Definition: valid.h:256
tunit::valid::are_same
static void are_same(const TExpected &expected, const TActual &actual, const std::string &message, const tunit::line_info &line_info)
Valids that two objects do refer to differents objects.
Definition: valid.h:516
tunit::valid::is_null
static void is_null(std::nullptr_t pointer, const tunit::line_info &line_info)
Valids that the pointer is null.
Definition: valid.h:2240
tunit::valid::is_NaN
static void is_NaN(float value, const std::string &message, const tunit::line_info &line_info)
Valids that a value is NaN.
Definition: valid.h:1410
tunit::valid::are_equal
static void are_equal(float expected, float actual, float tolerance)
Valids that two type are equal.
Definition: valid.h:140
tunit::valid::is_null
static void is_null(const std::weak_ptr< TPointer > &pointer)
Valids that the pointer is null.
Definition: valid.h:2169
tunit::valid::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)
Valids that the first value is is_less than or equal to the second value.
Definition: valid.h:1214
tunit::valid::is_not_zero
static void is_not_zero(const TValue &value, const std::string &message)
Valids that ta condition is not zero.
Definition: valid.h:1957
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::valid::is_NaN
static void is_NaN(double value, const std::string &message, const tunit::line_info &line_info)
Valids that a value is NaN.
Definition: valid.h:1302
tunit::valid::is_not_null
static void is_not_null(const std::weak_ptr< TPointer > &pointer, const std::string &message, const tunit::line_info &line_info)
Valids that the pointer is not null.
Definition: valid.h:1873
tunit::valid::are_not_same
static void are_not_same(const TExpected &expected, const TActual &actual, const tunit::line_info &line_info)
Valids that two objects do refer to differents objects.
Definition: valid.h:419
tunit::valid::are_not_same
static void are_not_same(const TExpected &expected, const TActual &actual)
Valids that two objects do refer to differents objects.
Definition: valid.h:404
tunit::valid::is_null
static void is_null(std::nullptr_t pointer)
Valids that the pointer is null.
Definition: valid.h:2230
tunit::valid::is_less
static void is_less(const TValue1 &val1, const TValue2 &val2, const std::string &message)
Valids that the first value is is_less than the second value.
Definition: valid.h:1109
tunit::valid::is_positive
static void is_positive(const TValue &value, const tunit::line_info &line_info)
Valids that ta condition is positive.
Definition: valid.h:2286
tunit::assert::is_not_null
static void is_not_null(const TPointer *pointer)
Asserts that the pointer is not null.
Definition: assert.h:1712