tunit - Reference Guide  1.0.0
Modern c++17 unit testing framework on Windows, macOS, Linux, iOS and android.
assume.h
Go to the documentation of this file.
1 #pragma once
4 #include "assert.h"
5 
7 namespace tunit {
12  class assume final : private base_assert {
13  public:
15  assume() = delete;
17 
27  template<typename TExpected, typename TActual>
28  static void are_equal(const TExpected& expected, const TActual& actual) {are_equal(expected, actual, "", line_info());}
29 
40  template<typename TExpected, typename TActual>
41  static void are_equal(const TExpected& expected, const TActual& actual, const tunit::line_info& line_info) {are_equal(expected, actual, "", line_info);}
42 
53  template<typename TExpected, typename TActual>
54  static void are_equal(const TExpected& expected, const TActual& actual, const std::string& message) {are_equal(expected, actual, message, line_info());}
55 
67  template<typename TExpected, typename TActual>
68  static void are_equal(const TExpected& expected, const TActual& actual, const std::string& message, const tunit::line_info& line_info) {
69  try {
70  assert::are_equal(expected, actual, message, line_info);
71  } catch (...) {
72  assert::abort();
73  }
74  }
75 
77  static void are_equal(const char* expected, const char* actual, const std::string& message, const tunit::line_info& line_info) {
78  try{
79  assert::are_equal(expected, actual, message, line_info);
80  } catch (...) {
81  assert::abort();
82  }
83  }
84 
85  static void are_equal(const char16_t* expected, const char16_t* actual, const std::string& message, const tunit::line_info& line_info) {
86  try {
87  assert::are_equal(expected, actual, message, line_info);
88  } catch (...) {
89  assert::abort();
90  }
91  }
92 
93  static void are_equal(const char32_t* expected, const char32_t* actual, const std::string& message, const tunit::line_info& line_info) {
94  try {
95  assert::are_equal(expected, actual, message, line_info);
96  } catch (...) {
97  assert::abort();
98  }
99  }
100 
101  static void are_equal(const wchar_t* expected, const wchar_t* actual, const std::string& message, const tunit::line_info& line_info) {
102  try {
103  assert::are_equal(expected, actual, message, line_info);
104  } catch (...) {
105  assert::abort();
106  }
107  }
108 
109  static void are_equal(float expected, float actual, const std::string& message, const tunit::line_info& line_info) {
110  try {
111  assert::are_equal(expected, actual, message, line_info);
112  } catch (...) {
113  assert::abort();
114  }
115  }
116 
117  static void are_equal(double expected, double actual, const std::string& message, const tunit::line_info& line_info) {
118  try {
119  assert::are_equal(expected, actual, message, line_info);
120  } catch (...) {
121  assert::abort();
122  }
123  }
124 
125  static void are_equal(long double expected, long double actual, const std::string& message, const tunit::line_info& line_info) {
126  try {
127  assert::are_equal(expected, actual, message, line_info);
128  } catch (...) {
129  assert::abort();
130  }
131  }
133 
145  static void are_equal(float expected, float actual, float tolerance) {are_equal(expected, actual, tolerance, "", line_info_);}
146 
159  static void are_equal(float expected, float actual, float tolerance, const tunit::line_info& line_info) {are_equal(expected, actual, tolerance, "", line_info);}
160 
173  static void are_equal(float expected, float& actual, float tolerance, const std::string& message) {are_equal(expected, actual, tolerance, message, line_info());}
174 
188  static void are_equal(float expected, float actual, float tolerance, const std::string& message, const tunit::line_info& line_info) {
189  try {
190  assert::are_equal(expected, actual, tolerance, message, line_info);
191  } catch (...) {
192  assert::abort();
193  }
194  }
195 
207  static void are_equal(double expected, double actual, double tolerance) {are_equal(expected, actual, tolerance, "", line_info_);}
208 
221  static void are_equal(double expected, double actual, double tolerance, const tunit::line_info& line_info) {are_equal(expected, actual, tolerance, "", line_info);}
222 
235  static void are_equal(double expected, double actual, double tolerance, const std::string& message) {are_equal(expected, actual, tolerance, message, line_info());}
236 
250  static void are_equal(double expected, double actual, double tolerance, const std::string& message, const tunit::line_info& line_info) {
251  try {
252  assert::are_equal(expected, actual, tolerance, message, line_info);
253  } catch (...) {
254  assert::abort();
255  }
256  }
257 
269  static void are_equal(long double expected, long double actual, long double tolerance) {are_equal(expected, actual, tolerance, "", line_info_);}
270 
283  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);}
284 
297  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());}
298 
312  static void are_equal(long double expected, long double actual, long double tolerance, const std::string& message, const tunit::line_info& line_info) {
313  try {
314  assert::are_equal(expected, actual, tolerance, message, line_info);
315  } catch (...) {
316  assert::abort();
317  }
318  }
319 
329  template<typename TExpected, typename TActual>
330  static void are_not_equal(const TExpected& expected, const TActual& actual) {are_not_equal(expected, actual, "", line_info());}
331 
342  template<typename TExpected, typename TActual>
343  static void are_not_equal(const TExpected& expected, const TActual& actual, const tunit::line_info& line_info) {are_not_equal(expected, actual, "", line_info);}
344 
355  template<typename TExpected, typename TActual>
356  static void are_not_equal(const TExpected& expected, const TActual& actual, const std::string& message) {are_not_equal(expected, actual, message, line_info());}
357 
369  template<typename TExpected, typename TActual>
370  static void are_not_equal(const TExpected& expected, const TActual& actual, const std::string& message, const tunit::line_info& line_info) {
371  try {
372  assert::are_not_equal(expected, actual, message, line_info);
373  } catch (...) {
374  assert::abort();
375  }
376  }
377 
379  static void are_not_equal(const char* expected, const char* actual, const std::string& message, const tunit::line_info& line_info) {
380  try {
381  assert::are_not_equal(expected, actual, message, line_info);
382  } catch (...) {
383  assert::abort();
384  }
385  }
386 
387  static void are_not_equal(const char16_t* expected, const char16_t* actual, const std::string& message, const tunit::line_info& line_info) {
388  try {
389  assert::are_not_equal(expected, actual, message, line_info);
390  } catch (...) {
391  assert::abort();
392  }
393  }
394 
395  static void are_not_equal(const char32_t* expected, const char32_t* actual, const std::string& message, const tunit::line_info& line_info) {
396  try {
397  assert::are_not_equal(expected, actual, message, line_info);
398  } catch (...) {
399  assert::abort();
400  }
401  }
402 
403  static void are_not_equal(const wchar_t* expected, const wchar_t* actual, const std::string& message, const tunit::line_info& line_info) {
404  try {
405  assert::are_not_equal(expected, actual, message, line_info);
406  } catch (...) {
407  assert::abort();
408  }
409  }
411 
424  template<typename TExpected, typename TActual>
425  static void are_not_same(const TExpected& expected, const TActual& actual) {are_not_same(expected, actual, "", line_info());}
426 
440  template<typename TExpected, typename TActual>
441  static void are_not_same(const TExpected& expected, const TActual& actual, const tunit::line_info& line_info) {are_not_same(expected, actual, "", line_info);}
442 
456  template<typename TExpected, typename TActual>
457  static void are_not_same(const TExpected& expected, const TActual& actual, const std::string& message) {are_not_same(expected, actual, message, line_info());}
458 
473  template<typename TExpected, typename TActual>
474  static void are_not_same(const TExpected& expected, const TActual& actual, const std::string& message, const tunit::line_info& line_info) {
475  try {
476  assert::are_not_same(expected, actual, message, line_info);
477  } catch (...) {
478  assert::abort();
479  }
480  }
481 
494  template<typename TExpected, typename TActual>
495  static void are_same(const TExpected& expected, const TActual& actual) {are_same(expected, actual, "", line_info());}
496 
510  template<typename TExpected, typename TActual>
511  static void are_same(const TExpected& expected, const TActual& actual, const tunit::line_info& line_info) {are_same(expected, actual, "", line_info);}
512 
526  template<typename TExpected, typename TActual>
527  static void are_same(const TExpected& expected, const TActual& actual, const std::string& message) {are_same(expected, actual, message, line_info());}
528 
543  template<typename TExpected, typename TActual>
544  static void are_same(const TExpected& expected, const TActual& actual, const std::string& message, const tunit::line_info& line_info) {
545  try {
546  assert::are_same(expected, actual, message, line_info);
547  } catch (...) {
548  assert::abort();
549  }
550  }
551 
562  template<typename TItem, typename TCollection>
563  static void contains(const TItem& item, const TCollection& collection) {contains(item, collection, "", line_info());}
564 
576  template<typename TItem, typename TCollection>
577  static void contains(const TItem& item, const TCollection& collection, const tunit::line_info& line_info) {contains(item, collection, "", line_info);}
578 
590  template<typename TItem, typename TCollection>
591  static void contains(const TItem& item, const TCollection& collection, const std::string& message) {contains(item, collection, message, line_info());}
592 
605  template<typename TItem, typename TCollection>
606  static void contains(const TItem& item, const TCollection& collection, const std::string& message, const tunit::line_info& line_info) {
607  try {
608  assert::contains(item, collection, message, line_info);
609  } catch (...) {
610  assert::abort();
611  }
612  }
613 
615  template<typename TItem, typename TValue>
616  static void contains(const TItem& item, const std::initializer_list<TValue>& values) {contains(item, values, "", line_info());}
617  template<typename TItem, typename TValue>
618  static void contains(const TItem& item, const std::initializer_list<TValue>& values, const tunit::line_info& line_info) {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 std::string& message) {contains(item, values, message, 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, const tunit::line_info& line_info) {
623  try {
624  assert::contains(item, values, message, line_info);
625  } catch (...) {
626  assert::abort();
627  }
628  }
629 
630  static void contains(char item, const char* values, const std::string& message, const tunit::line_info& line_info) {
631  try {
632  assert::contains(item, values, message, line_info);
633  } catch (...) {
634  assert::abort();
635  }
636  }
637 
638  static void contains(char16_t item, const char16_t* values, const std::string& message, const tunit::line_info& line_info) {
639  try {
640  assert::contains(item, values, message, line_info);
641  } catch (...) {
642  assert::abort();
643  }
644  }
645 
646  static void contains(char32_t item, const char32_t* values, const std::string& message, const tunit::line_info& line_info) {
647  try {
648  assert::contains(item, values, message, line_info);
649  } catch (...) {
650  assert::abort();
651  }
652  }
653 
654  static void contains(wchar_t item, const wchar_t* values, const std::string& message, const tunit::line_info& line_info) {
655  try {
656  assert::contains(item, values, message, line_info);
657  } catch (...) {
658  assert::abort();
659  }
660  }
662 
672  static void does_not_throw(const std::function<void()>& statement) {does_not_throw(statement, "", line_info());}
673 
684  static void does_not_throw(const std::function<void()>& statement, const tunit::line_info& line_info) {does_not_throw(statement, "", line_info);}
685 
696  static void does_not_throw(const std::function<void()>& statement, const std::string& message) {does_not_throw(statement, message, line_info());}
697 
709  static void does_not_throw(const std::function<void()>& statement, const std::string& message, const tunit::line_info& line_info) {
710  try {
711  assert::does_not_throw(statement, message, line_info);
712  } catch (...) {
713  assert::abort();
714  }
715  }
716 
727  template<typename TValue>
728  static void is_empty(const TValue& value) {is_empty(value, "", line_info());}
729 
741  template<typename TValue>
742  static void is_empty(const TValue& value, const tunit::line_info& line_info) {is_empty(value, "", line_info);}
743 
755  template<typename TValue>
756  static void is_empty(const TValue& value, const std::string& message) {is_empty(value, message, line_info());}
757 
770  template<typename TValue>
771  static void is_empty(const TValue& value, const std::string& message, const tunit::line_info& line_info) {
772  try {
773  assert::is_empty(value, message, line_info);
774  } catch (...) {
775  assert::abort();
776  }
777  }
778 
780  template<typename TValue>
781  static void is_empty(const std::initializer_list<TValue>& value) {is_empty(value, "", line_info());}
782  template<typename TValue>
783  static void is_empty(const std::initializer_list<TValue>& value, const tunit::line_info& line_info) {is_empty(value, "", line_info);}
784  template<typename TValue>
785  static void is_empty(const std::initializer_list<TValue>& value, const std::string& message) {is_empty(value, message, line_info());}
786  template<typename TValue>
787  static void is_empty(const std::initializer_list<TValue>& values, const std::string& message, const tunit::line_info& line_info) {
788  try {
789  assert::is_empty(values, message, line_info);
790  } catch (...) {
791  assert::abort();
792  }
793  }
794 
795  static void is_empty(const char* value, const std::string& message, const tunit::line_info& line_info) {
796  try {
797  assert::is_empty(value, message, line_info);
798  } catch (...) {
799  assert::abort();
800  }
801  }
802 
803  static void is_empty(const char16_t* value, const std::string& message, const tunit::line_info& line_info) {
804  try {
805  assert::is_empty(value, message, line_info);
806  } catch (...) {
807  assert::abort();
808  }
809  }
810 
811  static void is_empty(const char32_t* value, const std::string& message, const tunit::line_info& line_info) {
812  try {
813  assert::is_empty(value, message, line_info);
814  } catch (...) {
815  assert::abort();
816  }
817  }
818 
819  static void is_empty(const wchar_t* value, const std::string& message, const tunit::line_info& line_info) {
820  try {
821  assert::is_empty(value, message, line_info);
822  } catch (...) {
823  assert::abort();
824  }
825  }
827 
838  static void is_false(bool condition) {is_false(condition, "", line_info());}
839 
851  static void is_false(bool condition, const tunit::line_info& line_info) {is_false(condition, "", line_info);}
852 
864  static void is_false(bool condition, const std::string& message) {is_false(condition, message, line_info());}
865 
878  static void is_false(bool condition, const std::string& message, const tunit::line_info& line_info) {
879  try {
880  assert::is_false(condition, message, line_info);
881  } catch (...) {
882  assert::abort();
883  }
884  }
885 
895  template<typename TValue1, typename TValue2>
896  static void is_greater(const TValue1& val1, const TValue2& val2) {is_greater(val1, val2, "", line_info());}
897 
908  template<typename TValue1, typename TValue2>
909  static void is_greater(const TValue1& val1, const TValue2& val2, const tunit::line_info& line_info) {is_greater(val1, val2, "", line_info);}
910 
921  template<typename TValue1, typename TValue2>
922  static void is_greater(const TValue1& val1, const TValue2& val2, const std::string& message) {is_greater(val1, val2, message, line_info());}
923 
935  template<typename TValue1, typename TValue2>
936  static void is_greater(const TValue1& val1, const TValue2& val2, const std::string& message, const tunit::line_info& line_info) {
937  try {
938  assert::is_greater(val1, val2, message, line_info);
939  } catch (...) {
940  assert::abort();
941  }
942  }
943 
945  static void is_greater(const char* val1, const char* val2, const std::string& message, const tunit::line_info& line_info) {
946  try {
947  assert::is_greater(val1, val2, message, line_info);
948  } catch (...) {
949  assert::abort();
950  }
951  }
952 
953  static void is_greater(const char16_t* val1, const char16_t* val2, const std::string& message, const tunit::line_info& line_info) {
954  try {
955  assert::is_greater(val1, val2, message, line_info);
956  } catch (...) {
957  assert::abort();
958  }
959  }
960 
961  static void is_greater(const char32_t* val1, const char32_t* val2, const std::string& message, const tunit::line_info& line_info) {
962  try {
963  assert::is_greater(val1, val2, message, line_info);
964  } catch (...) {
965  assert::abort();
966  }
967  }
968 
969  static void is_greater(const wchar_t* val1, const wchar_t* val2, const std::string& message, const tunit::line_info& line_info) {
970  try {
971  assert::is_greater(val1, val2, message, line_info);
972  } catch (...) {
973  assert::abort();
974  }
975  }
977 
988  template<typename TValue1, typename TValue2>
989  static void is_greater_or_equal(const TValue1& val1, const TValue2& val2) {is_greater_or_equal(val1, val2, "", line_info());}
990 
1002  template<typename TValue1, typename TValue2>
1003  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);}
1004 
1016  template<typename TValue1, typename TValue2>
1017  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());}
1018 
1031  template<typename TValue1, typename TValue2>
1032  static void is_greater_or_equal(const TValue1& val1, const TValue2& val2, const std::string& message, const tunit::line_info& line_info) {
1033  try {
1034  assert::is_greater_or_equal(val1, val2, message, line_info);
1035  } catch (...) {
1036  assert::abort();
1037  }
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  try {
1043  assert::is_greater_or_equal(val1, val2, message, line_info);
1044  } catch (...) {
1045  assert::abort();
1046  }
1047  }
1048 
1049  static void is_greater_or_equal(const char16_t* val1, const char16_t* val2, const std::string& message, const tunit::line_info& line_info) {
1050  try {
1051  assert::is_greater_or_equal(val1, val2, message, line_info);
1052  } catch (...) {
1053  assert::abort();
1054  }
1055  }
1056 
1057  static void is_greater_or_equal(const char32_t* val1, const char32_t* val2, const std::string& message, const tunit::line_info& line_info) {
1058  try {
1059  assert::is_greater_or_equal(val1, val2, message, line_info);
1060  } catch (...) {
1061  assert::abort();
1062  }
1063  }
1064 
1065  static void is_greater_or_equal(const wchar_t* val1, const wchar_t* val2, const std::string& message, const tunit::line_info& line_info) {
1066  try {
1067  assert::is_greater_or_equal(val1, val2, message, line_info);
1068  } catch (...) {
1069  assert::abort();
1070  }
1071  }
1073 
1083  template<typename Type, typename TValue>
1084  static void is_instance_of(const TValue& value) {is_instance_of<Type>(value, "", line_info());}
1085 
1096  template<typename Type, typename TValue>
1097  static void is_instance_of(const TValue& value, const tunit::line_info& line_info) {is_instance_of<Type>(value, "", line_info);}
1098 
1109  template<typename Type, typename TValue>
1110  static void is_instance_of(const TValue& value, const std::string& message) {is_instance_of<Type>(value, message, line_info());}
1111 
1123  template<typename Type, typename TValue>
1124  static void is_instance_of(const TValue& value, const std::string& message, const tunit::line_info& line_info) {
1125  try {
1126  assert::is_instance_of<Type>(value, message, line_info);
1127  } catch (...) {
1128  assert::abort();
1129  }
1130  }
1131 
1141  template<typename TValue1, typename TValue2>
1142  static void is_less(const TValue1& val1, const TValue2& val2) {is_less(val1, val2, "", line_info());}
1143 
1154  template<typename TValue1, typename TValue2>
1155  static void is_less(const TValue1& val1, const TValue2& val2, const tunit::line_info& line_info) {is_less(val1, val2, "", line_info);}
1156 
1167  template<typename TValue1, typename TValue2>
1168  static void is_less(const TValue1& val1, const TValue2& val2, const std::string& message) {is_less(val1, val2, message, line_info());}
1169 
1181  template<typename TValue1, typename TValue2>
1182  static void is_less(const TValue1& val1, const TValue2& val2, const std::string& message, const tunit::line_info& line_info) {
1183  try {
1184  assert::is_less(val1, val2, message, line_info);
1185  } catch (...) {
1186  assert::abort();
1187  }
1188  }
1189 
1191  static void is_less(const char* val1, const char* val2, const std::string& message, const tunit::line_info& line_info) {
1192  try {
1193  assert::is_less(val1, val2, message, line_info);
1194  } catch (...) {
1195  assert::abort();
1196  }
1197  }
1198 
1199  static void is_less(const char16_t* val1, const char16_t* val2, const std::string& message, const tunit::line_info& line_info) {
1200  try {
1201  assert::is_less(val1, val2, message, line_info);
1202  } catch (...) {
1203  assert::abort();
1204  }
1205  }
1206 
1207  static void is_less(const char32_t* val1, const char32_t* val2, const std::string& message, const tunit::line_info& line_info) {
1208  try {
1209  assert::is_less(val1, val2, message, line_info);
1210  } catch (...) {
1211  assert::abort();
1212  }
1213  }
1214 
1215  static void is_less(const wchar_t* val1, const wchar_t* val2, const std::string& message, const tunit::line_info& line_info) {
1216  try {
1217  assert::is_less(val1, val2, message, line_info);
1218  } catch (...) {
1219  assert::abort();
1220  }
1221  }
1223 
1234  template<typename TValue1, typename TValue2>
1235  static void is_less_or_equal(const TValue1& val1, const TValue2& val2) {is_less_or_equal(val1, val2, "", line_info());}
1236 
1248  template<typename TValue1, typename TValue2>
1249  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);}
1250 
1262  template<typename TValue1, typename TValue2>
1263  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());}
1264 
1277  template<typename TValue1, typename TValue2>
1278  static void is_less_or_equal(const TValue1& val1, const TValue2& val2, const std::string& message, const tunit::line_info& line_info) {
1279  try {
1280  assert::is_less_or_equal(val1, val2, message, line_info);
1281  } catch (...) {
1282  assert::abort();
1283  }
1284  }
1285 
1287  static void is_less_or_equal(const char* val1, const char* val2, const std::string& message, const tunit::line_info& line_info) {
1288  try {
1289  assert::is_less_or_equal(val1, val2, message, line_info);
1290  } catch (...) {
1291  assert::abort();
1292  }
1293  }
1294 
1295  static void is_less_or_equal(const char16_t* val1, const char16_t* val2, const std::string& message, const tunit::line_info& line_info) {
1296  try {
1297  assert::is_less_or_equal(val1, val2, message, line_info);
1298  } catch (...) {
1299  assert::abort();
1300  }
1301  }
1302 
1303  static void is_less_or_equal(const char32_t* val1, const char32_t* val2, const std::string& message, const tunit::line_info& line_info) {
1304  try {
1305  assert::is_less_or_equal(val1, val2, message, line_info);
1306  } catch (...) {
1307  assert::abort();
1308  }
1309  }
1310 
1311  static void is_less_or_equal(const wchar_t* val1, const wchar_t* val2, const std::string& message, const tunit::line_info& line_info) {
1312  try {
1313  assert::is_less_or_equal(val1, val2, message, line_info);
1314  } catch (...) {
1315  assert::abort();
1316  }
1317  }
1319 
1330  static void is_NaN(double value) {is_NaN(value, "", line_info());}
1331 
1343  static void is_NaN(double value, const tunit::line_info& line_info) {is_NaN(value, "", line_info);}
1344 
1356  static void is_NaN(double value, const std::string& message) {is_NaN(value, message, line_info());}
1357 
1370  static void is_NaN(double value, const std::string& message, const tunit::line_info& line_info) {
1371  try {
1372  assert::is_NaN(value, message, line_info);
1373  } catch (...) {
1374  assert::abort();
1375  }
1376  }
1377 
1388  static void is_NaN(long double value) {is_NaN(value, "", line_info());}
1389 
1401  static void is_NaN(long double value, const tunit::line_info& line_info) {is_NaN(value, "", line_info);}
1402 
1414  static void is_NaN(long double value, const std::string& message) {is_NaN(value, message, line_info());}
1415 
1428  static void is_NaN(long double value, const std::string& message, const tunit::line_info& line_info) {
1429  try {
1430  assert::is_NaN(value, message, line_info);
1431  } catch (...) {
1432  assert::abort();
1433  }
1434  }
1435 
1446  static void is_NaN(float value) {is_NaN(value, "", line_info());}
1447 
1459  static void is_NaN(float value, const tunit::line_info& line_info) {is_NaN(value, "", line_info);}
1460 
1472  static void is_NaN(float value, const std::string& message) {is_NaN(value, message, line_info());}
1473 
1486  static void is_NaN(float value, const std::string& message, const tunit::line_info& line_info) {
1487  try {
1488  assert::is_NaN(value, message, line_info);
1489  } catch (...) {
1490  assert::abort();
1491  }
1492  }
1493 
1504  template<typename TValue>
1505  static void is_negative(const TValue& value) {is_negative(value, "", line_info());}
1506 
1518  template<typename TValue>
1519  static void is_negative(const TValue& value, const tunit::line_info& line_info) {is_negative(value, "", line_info);}
1520 
1532  template<typename TValue>
1533  static void is_negative(const TValue& value, const std::string& message) {is_negative(value, message, line_info());}
1534 
1547  template<typename TValue>
1548  static void is_negative(const TValue& value, const std::string& message, const tunit::line_info& line_info) {
1549  try {
1550  assert::is_negative(value, message, line_info);
1551  } catch (...) {
1552  assert::abort();
1553  }
1554  }
1555 
1566  template<typename TValue>
1567  static void is_not_empty(const TValue& value) {is_not_empty(value, "", line_info());}
1568 
1580  template<typename TValue>
1581  static void is_not_empty(const TValue& value, const tunit::line_info& line_info) {is_not_empty(value, "", line_info);}
1582 
1594  template<typename TValue>
1595  static void is_not_empty(const TValue& value, const std::string& message) {is_not_empty(value, message, line_info());}
1596 
1609  template<typename TValue>
1610  static void is_not_empty(const TValue& value, const std::string& message, const tunit::line_info& line_info) {
1611  try {
1612  assert::is_not_empty(value, message, line_info);
1613  } catch (...) {
1614  assert::abort();
1615  }
1616  }
1617 
1619  template<typename TValue>
1620  static void is_not_empty(const std::initializer_list<TValue>& value) {is_not_empty(value, "", line_info());}
1621  template<typename TValue>
1622  static void is_not_empty(const std::initializer_list<TValue>& value, const tunit::line_info& line_info) {is_not_empty(value, "", line_info);}
1623  template<typename TValue>
1624  static void is_not_empty(const std::initializer_list<TValue>& value, const std::string& message) {is_not_empty(value, message, line_info());}
1625  template<typename TValue>
1626  static void is_not_empty(const std::initializer_list<TValue>& value, const std::string& message, const tunit::line_info& line_info) {
1627  try {
1628  assert::is_not_empty(value, message, line_info);
1629  } catch (...) {
1630  assert::abort();
1631  }
1632  }
1633 
1634  static void is_not_empty(const char* value, const std::string& message, const tunit::line_info& line_info) {
1635  try {
1636  assert::is_not_empty(value, message, line_info);
1637  } catch (...) {
1638  assert::abort();
1639  }
1640  }
1641 
1642  static void is_not_empty(const char16_t* value, const std::string& message, const tunit::line_info& line_info) {
1643  try {
1644  assert::is_not_empty(value, message, line_info);
1645  } catch (...) {
1646  assert::abort();
1647  }
1648  }
1649 
1650  static void is_not_empty(const char32_t* value, const std::string& message, const tunit::line_info& line_info) {
1651  try {
1652  assert::is_not_empty(value, message, line_info);
1653  } catch (...) {
1654  assert::abort();
1655  }
1656  }
1657 
1658  static void is_not_empty(const wchar_t* value, const std::string& message, const tunit::line_info& line_info) {
1659  try {
1660  assert::is_not_empty(value, message, line_info);
1661  } catch (...) {
1662  assert::abort();
1663  }
1664  }
1666 
1676  template<typename Type, typename TValue>
1677  static void is_not_instance_of(const TValue& value) {is_not_instance_of<Type>(value, "", line_info());}
1678 
1689  template<typename Type, typename TValue>
1690  static void is_not_instance_of(const TValue& value, const tunit::line_info& line_info) {is_not_instance_of<Type>(value, "", line_info);}
1691 
1702  template<typename Type, typename TValue>
1703  static void is_not_instance_of(const TValue& value, const std::string& message) {is_not_instance_of<Type>(value, message, line_info());}
1704 
1716  template<typename Type, typename TValue>
1717  static void is_not_instance_of(const TValue& value, const std::string& message, const tunit::line_info& line_info) {
1718  try {
1719  assert::is_not_instance_of<Type>(value, message, line_info);
1720  } catch (...) {
1721  assert::abort();
1722  }
1723  }
1724 
1736  template<typename TPointer>
1737  static void is_not_null(const TPointer* pointer) {is_not_null(pointer, "", line_info());}
1738 
1751  template<typename TPointer>
1752  static void is_not_null(const TPointer* pointer, const tunit::line_info& line_info) {is_not_null(pointer, "", line_info);}
1753 
1766  template<typename TPointer>
1767  static void is_not_null(const TPointer* pointer, const std::string& message) {is_not_null(pointer, message, line_info());}
1768 
1782  template<typename TPointer>
1783  static void is_not_null(const TPointer* pointer, const std::string& message, const tunit::line_info& line_info) {
1784  try {
1785  assert::is_not_null(pointer, message, line_info);
1786  } catch (...) {
1787  assert::abort();
1788  }
1789  }
1790 
1801  template<typename TPointer>
1802  static void is_not_null(const std::unique_ptr<TPointer>& pointer) {is_not_null(pointer, "", line_info());}
1803 
1815  template<typename TPointer>
1816  static void is_not_null(const std::unique_ptr<TPointer>& pointer, const tunit::line_info& line_info) {is_not_null(pointer, "", line_info);}
1817 
1829  template<typename TPointer>
1830  static void is_not_null(const std::unique_ptr<TPointer>& pointer, const std::string& message) {is_not_null(pointer, message, line_info());}
1831 
1844  template<typename TPointer>
1845  static void is_not_null(const std::unique_ptr<TPointer>& pointer, const std::string& message, const tunit::line_info& line_info) {
1846  try {
1847  assert::is_not_null(pointer, message, line_info);
1848  } catch (...) {
1849  assert::abort();
1850  }
1851  }
1852 
1863  template<typename TPointer>
1864  static void is_not_null(const std::shared_ptr<TPointer>& pointer) {is_not_null(pointer, "", line_info());}
1865 
1877  template<typename TPointer>
1878  static void is_not_null(const std::shared_ptr<TPointer>& pointer, const tunit::line_info& line_info) {is_not_null(pointer, "", line_info);}
1879 
1891  template<typename TPointer>
1892  static void is_not_null(const std::shared_ptr<TPointer>& pointer, const std::string& message) {is_not_null(pointer, message, line_info());}
1893 
1906  template<typename TPointer>
1907  static void is_not_null(const std::shared_ptr<TPointer>& pointer, const std::string& message, const tunit::line_info& line_info) {
1908  try {
1909  assert::is_not_null(pointer, message, line_info);
1910  } catch (...) {
1911  assert::abort();
1912  }
1913  }
1914 
1927  template<typename TPointer>
1928  static void is_not_null(const std::weak_ptr<TPointer>& pointer) {is_not_null(pointer, "", line_info());}
1929 
1943  template<typename TPointer>
1944  static void is_not_null(const std::weak_ptr<TPointer>& pointer, const tunit::line_info& line_info) {is_not_null(pointer, "", line_info);}
1945 
1959  template<typename TPointer>
1960  static void is_not_null(const std::weak_ptr<TPointer>& pointer, const std::string& message) {is_not_null(pointer, message, line_info());}
1961 
1976  template<typename TPointer>
1977  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);}
1978 
1987  static void is_not_null(std::nullptr_t pointer) {is_not_null(pointer, "", line_info());}
1988 
1998  static void is_not_null(std::nullptr_t pointer, const tunit::line_info& line_info) {is_not_null(pointer, "", line_info);}
1999 
2009  static void is_not_null(std::nullptr_t pointer, const std::string& message) {is_not_null(pointer, message, line_info());}
2010 
2021  static void is_not_null(std::nullptr_t pointer, const std::string& message, const tunit::line_info& line_info) {
2022  try {
2023  assert::is_not_null(pointer, message, line_info);
2024  } catch (...) {
2025  assert::abort();
2026  }
2027  }
2028 
2039  template<typename TValue>
2040  static void is_not_zero(const TValue& value) {is_not_zero(value, "", line_info());}
2041 
2053  template<typename TValue>
2054  static void is_not_zero(const TValue& value, const tunit::line_info& line_info) {is_not_zero(value, "", line_info);}
2055 
2067  template<typename TValue>
2068  static void is_not_zero(const TValue& value, const std::string& message) {is_not_zero(value, message, line_info());}
2069 
2082  template<typename TValue>
2083  static void is_not_zero(const TValue& value, const std::string& message, const tunit::line_info& line_info) {
2084  try {
2085  assert::is_zero(value, message, line_info);
2086  } catch (...) {
2087  assert::abort();
2088  }
2089  }
2090 
2102  template<typename TPointer>
2103  static void is_null(const TPointer* pointer) {is_null(pointer, "", line_info());}
2104 
2117  template<typename TPointer>
2118  static void is_null(const TPointer* pointer, const tunit::line_info& line_info) {is_null(pointer, "", line_info);}
2119 
2132  template<typename TPointer>
2133  static void is_null(const TPointer* pointer, const std::string& message) {is_null(pointer, message, line_info());}
2134 
2148  template<typename TPointer>
2149  static void is_null(const 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  assert::abort();
2154  }
2155  }
2156 
2167  template<typename TPointer>
2168  static void is_null(const std::unique_ptr<TPointer>& pointer) {is_null(pointer, "", line_info());}
2169 
2181  template<typename TPointer>
2182  static void is_null(const std::unique_ptr<TPointer>& pointer, const tunit::line_info& line_info) {is_null(pointer, "", line_info);}
2183 
2195  template<typename TPointer>
2196  static void is_null(const std::unique_ptr<TPointer>& pointer, const std::string& message) {is_null(pointer, message, line_info());}
2197 
2210  template<typename TPointer>
2211  static void is_null(const std::unique_ptr<TPointer>& pointer, const std::string& message, const tunit::line_info& line_info) {
2212  try {
2213  assert::is_null(pointer, message, line_info);
2214  } catch (...) {
2215  assert::abort();
2216  }
2217  }
2218 
2229  template<typename TPointer>
2230  static void is_null(const std::shared_ptr<TPointer>& pointer) {is_null(pointer, "", line_info());}
2231 
2243  template<typename TPointer>
2244  static void is_null(const std::shared_ptr<TPointer>& pointer, const tunit::line_info& line_info) {is_null(pointer, "", line_info);}
2245 
2257  template<typename TPointer>
2258  static void is_null(const std::shared_ptr<TPointer>& pointer, const std::string& message) {is_null(pointer, message, line_info());}
2259 
2272  template<typename TPointer>
2273  static void is_null(const std::shared_ptr<TPointer>& pointer, const std::string& message, const tunit::line_info& line_info) {
2274  try {
2275  assert::is_null(pointer, message, line_info);
2276  } catch (...) {
2277  assert::abort();
2278  }
2279  }
2280 
2293  template<typename TPointer>
2294  static void is_null(const std::weak_ptr<TPointer>& pointer) {is_null(pointer, "", line_info());}
2295 
2309  template<typename TPointer>
2310  static void is_null(const std::weak_ptr<TPointer>& pointer, const tunit::line_info& line_info) {is_null(pointer, "", line_info);}
2311 
2325  template<typename TPointer>
2326  static void is_null(const std::weak_ptr<TPointer>& pointer, const std::string& message) {is_null(pointer, message, line_info());}
2327 
2342  template<typename TPointer>
2343  static void is_null(const std::weak_ptr<TPointer>& pointer, const std::string& message, const tunit::line_info& line_info) {
2344  try {
2345  assert::is_null(pointer, message, line_info);
2346  } catch (...) {
2347  assert::abort();
2348  }
2349  }
2350 
2359  static void is_null(std::nullptr_t pointer) {is_null(pointer, "", line_info());}
2360 
2370  static void is_null(std::nullptr_t pointer, const tunit::line_info& line_info) {is_null(pointer, "", line_info);}
2371 
2381  static void is_null(std::nullptr_t pointer, const std::string& message) {is_null(pointer, message, line_info());}
2382 
2393  static void is_null(std::nullptr_t pointer, const std::string& message, const tunit::line_info& line_info) {assert::succeed(message, line_info);}
2394 
2405  template<typename TValue>
2406  static void is_positive(const TValue& value) {is_positive(value, "", line_info());}
2407 
2419  template<typename TValue>
2420  static void is_positive(const TValue& value, const tunit::line_info& line_info) {is_positive(value, "", line_info);}
2421 
2433  template<typename TValue>
2434  static void is_positive(const TValue& value, const std::string& message) {is_positive(value, message, line_info());}
2435 
2448  template<typename TValue>
2449  static void is_positive(const TValue& value, const std::string& message, const tunit::line_info& line_info) {
2450  try {
2451  assert::is_positive(value, message, line_info);
2452  } catch (...) {
2453  assert::abort();
2454  }
2455  }
2456 
2467  static void is_true(bool condition) {is_true(condition, "", line_info());}
2468 
2480  static void is_true(bool condition, const tunit::line_info& line_info) {is_true(condition, "", line_info);}
2481 
2493  static void is_true(bool condition, const std::string& message) {is_true(condition, message, line_info());}
2494 
2507  static void is_true(bool condition, const std::string& message, const tunit::line_info& line_info) {
2508  try {
2509  assert::is_true(condition, message, line_info);
2510  } catch (...) {
2511  assert::abort();
2512  }
2513  }
2514 
2525  template<typename TValue>
2526  static void is_zero(const TValue& value) {is_zero(value, "", line_info());}
2527 
2539  template<typename TValue>
2540  static void is_zero(const TValue& value, const tunit::line_info& line_info) {is_zero(value, "", line_info);}
2541 
2553  template<typename TValue>
2554  static void is_zero(const TValue& value, const std::string& message) {is_zero(value, message, line_info());}
2555 
2568  template<typename TValue>
2569  static void is_zero(const TValue& value, const std::string& message, const tunit::line_info& line_info) {
2570  try {
2571  assert::is_zero(value, message, line_info);
2572  } catch (...) {
2573  assert::abort();
2574  }
2575  }
2576 
2587  template<typename TException>
2588  static void throws(const std::function<void()>& statement) {throws<TException>(statement, "", line_info());}
2589 
2601  template<typename TException>
2602  static void throws(const std::function<void()>& statement, const tunit::line_info& line_info) {throws<TException>(statement, "", line_info);}
2603 
2615  template<typename TException>
2616  static void throws(const std::function<void()>& statement, const std::string& message) {throws<TException>(statement, message, line_info());}
2617 
2630  template<typename TException>
2631  static void throws(const std::function<void()>& statement, const std::string& message, const tunit::line_info& line_info) {
2632  try {
2633  assert::throws<TException>(statement, message, line_info);
2634  } catch (...) {
2635  assert::abort();
2636  }
2637  }
2638 
2648  static void throws_any(const std::function<void()>& statement) {throws_any(statement, "", line_info());}
2649 
2660  static void throws_any(const std::function<void()>& statement, const tunit::line_info& line_info) {throws_any(statement, "", line_info);}
2661 
2672  static void throws_any(const std::function<void()>& statement, const std::string& message) {throws_any(statement, message, line_info());}
2673 
2685  static void throws_any(const std::function<void()>& statement, const std::string& message, const tunit::line_info& line_info) {
2686  try {
2687  assert::throws_any(statement, message, line_info);
2688  } catch (...) {
2689  assert::abort();
2690  }
2691  }
2692  };
2693 }
tunit::assume::is_not_null
static void is_not_null(const std::unique_ptr< TPointer > &pointer, const std::string &message, const tunit::line_info &line_info)
Assumes that the pointer is not null.
Definition: assume.h:1845
tunit::assume::does_not_throw
static void does_not_throw(const std::function< void()> &statement, const std::string &message, const tunit::line_info &line_info)
Assumes that the staement does not throw an exception.
Definition: assume.h:709
tunit::assume::are_equal
static void are_equal(const TExpected &expected, const TActual &actual, const tunit::line_info &line_info)
Assumes that two type are equal.
Definition: assume.h:41
tunit::assume::does_not_throw
static void does_not_throw(const std::function< void()> &statement)
Assumes that the staement does not throw an exception.
Definition: assume.h:672
tunit::assume::is_empty
static void is_empty(const TValue &value, const std::string &message)
Assumes that collection contains an item.
Definition: assume.h:756
tunit::assume::is_instance_of
static void is_instance_of(const TValue &value)
Assumes that an object is of the type supplied or a derived type.
Definition: assume.h:1084
tunit::assume::is_zero
static void is_zero(const TValue &value, const tunit::line_info &line_info)
Assumes that ta condition is zero.
Definition: assume.h:2540
tunit::assume::is_negative
static void is_negative(const TValue &value, const tunit::line_info &line_info)
Assumes that ta condition is negative.
Definition: assume.h:1519
tunit::assume::are_same
static void are_same(const TExpected &expected, const TActual &actual, const std::string &message, const tunit::line_info &line_info)
Assumes that two objects do refer to differents objects.
Definition: assume.h:544
tunit::assume::is_instance_of
static void is_instance_of(const TValue &value, const tunit::line_info &line_info)
Assumes that an object is of the type supplied or a derived type.
Definition: assume.h:1097
tunit::assume::is_NaN
static void is_NaN(double value, const std::string &message, const tunit::line_info &line_info)
Assumes that a value is NaN.
Definition: assume.h:1370
tunit::assume::is_not_null
static void is_not_null(const std::unique_ptr< TPointer > &pointer)
Assumes that the pointer is not null.
Definition: assume.h:1802
tunit::assume::are_not_same
static void are_not_same(const TExpected &expected, const TActual &actual, const tunit::line_info &line_info)
Assumes that two objects do refer to differents objects.
Definition: assume.h:441
tunit::assume::is_not_empty
static void is_not_empty(const TValue &value, const std::string &message, const tunit::line_info &line_info)
Assumes that collection does not contain any item.
Definition: assume.h:1610
tunit::assume::are_not_same
static void are_not_same(const TExpected &expected, const TActual &actual, const std::string &message, const tunit::line_info &line_info)
Assumes that two objects do refer to differents objects.
Definition: assume.h:474
tunit::assume::is_null
static void is_null(const std::shared_ptr< TPointer > &pointer, const std::string &message, const tunit::line_info &line_info)
Assumes that the pointer is null.
Definition: assume.h:2273
tunit::assume::is_not_zero
static void is_not_zero(const TValue &value, const std::string &message, const tunit::line_info &line_info)
Assumes that ta condition is not zero.
Definition: assume.h:2083
tunit::assume::is_NaN
static void is_NaN(long double value, const tunit::line_info &line_info)
that a value is NaN.
Definition: assume.h:1401
tunit::assume::contains
static void contains(const TItem &item, const TCollection &collection, const std::string &message)
Assumes that collection contains an item.
Definition: assume.h:591
tunit::assert::is_false
static void is_false(bool condition)
Asserts that ta condition is false.
Definition: assert.h:845
tunit::assume::does_not_throw
static void does_not_throw(const std::function< void()> &statement, const tunit::line_info &line_info)
Assumes that the staement does not throw an exception.
Definition: assume.h:684
tunit::assume::is_not_null
static void is_not_null(const std::shared_ptr< TPointer > &pointer, const tunit::line_info &line_info)
Assumes that the pointer is not null.
Definition: assume.h:1878
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::assume::contains
static void contains(const TItem &item, const TCollection &collection, const tunit::line_info &line_info)
Assumes that collection contains an item.
Definition: assume.h:577
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::assume::is_not_null
static void is_not_null(const std::weak_ptr< TPointer > &pointer, const std::string &message)
Assumes that the pointer is not null.
Definition: assume.h:1960
tunit::assume::is_less_or_equal
static void is_less_or_equal(const TValue1 &val1, const TValue2 &val2, const tunit::line_info &line_info)
Assumes that the first value is is_less than or equal to the second value.
Definition: assume.h:1249
tunit::assume::is_negative
static void is_negative(const TValue &value, const std::string &message, const tunit::line_info &line_info)
Assumes that ta condition is negative.
Definition: assume.h:1548
tunit::assume::is_not_empty
static void is_not_empty(const TValue &value, const tunit::line_info &line_info)
Assumes that collection does not contain any item.
Definition: assume.h:1581
tunit::assume::is_not_null
static void is_not_null(std::nullptr_t pointer, const std::string &message, const tunit::line_info &line_info)
Assumes that the pointer is not null.
Definition: assume.h:2021
tunit::assume::is_true
static void is_true(bool condition, const std::string &message)
Assumes that a condition is true.
Definition: assume.h:2493
tunit::assume::are_equal
static void are_equal(double expected, double actual, double tolerance, const std::string &message)
Assumes that two type are equal.
Definition: assume.h:235
tunit::assume::are_equal
static void are_equal(double expected, double actual, double tolerance, const tunit::line_info &line_info)
Assumes that two type are equal.
Definition: assume.h:221
tunit::assume::is_null
static void is_null(const std::unique_ptr< TPointer > &pointer, const tunit::line_info &line_info)
Assumes that the pointer is null.
Definition: assume.h:2182
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::assume::is_NaN
static void is_NaN(long double value)
that a value is NaN.
Definition: assume.h:1388
tunit::assume::are_equal
static void are_equal(const TExpected &expected, const TActual &actual, const std::string &message, const tunit::line_info &line_info)
Assumes that two type are equal.
Definition: assume.h:68
tunit::assume::does_not_throw
static void does_not_throw(const std::function< void()> &statement, const std::string &message)
Assumes that the staement does not throw an exception.
Definition: assume.h:696
tunit::assume::is_null
static void is_null(const std::unique_ptr< TPointer > &pointer)
Assumes that the pointer is null.
Definition: assume.h:2168
tunit::assume::is_not_zero
static void is_not_zero(const TValue &value)
Assumes that ta condition is not zero.
Definition: assume.h:2040
tunit::assume::is_null
static void is_null(const std::shared_ptr< TPointer > &pointer, const tunit::line_info &line_info)
Assumes that the pointer is null.
Definition: assume.h:2244
tunit::assume::is_not_instance_of
static void is_not_instance_of(const TValue &value)
Assumes that an object is not of the type supplied or a derived type.
Definition: assume.h:1677
tunit::assume::is_less
static void is_less(const TValue1 &val1, const TValue2 &val2, const std::string &message, const tunit::line_info &line_info)
Assumes that the first value is is_less than the second value.
Definition: assume.h:1182
tunit::assume::is_null
static void is_null(std::nullptr_t pointer, const std::string &message, const tunit::line_info &line_info)
Assumes that the pointer is null.
Definition: assume.h:2393
tunit::assume::is_null
static void is_null(const TPointer *pointer, const std::string &message)
Assumes that the pointer is null.
Definition: assume.h:2133
tunit::assume::is_not_null
static void is_not_null(const TPointer *pointer, const tunit::line_info &line_info)
Assumes that the pointer is not null.
Definition: assume.h:1752
tunit::assume::are_equal
static void are_equal(const TExpected &expected, const TActual &actual, const std::string &message)
Assumes that two type are equal.
Definition: assume.h:54
tunit::assume::is_not_instance_of
static void is_not_instance_of(const TValue &value, const tunit::line_info &line_info)
Assumes that an object is not of the type supplied or a derived type.
Definition: assume.h:1690
tunit::assume::is_null
static void is_null(const TPointer *pointer)
Assumes that the pointer is null.
Definition: assume.h:2103
tunit::assume::is_not_instance_of
static void is_not_instance_of(const TValue &value, const std::string &message)
Assumes that an object is not of the type supplied or a derived type.
Definition: assume.h:1703
tunit::assume::is_NaN
static void is_NaN(float value, const tunit::line_info &line_info)
that a value is NaN.
Definition: assume.h:1459
tunit::assume::contains
static void contains(const TItem &item, const TCollection &collection, const std::string &message, const tunit::line_info &line_info)
Assumes that collection contains an item.
Definition: assume.h:606
tunit::assert::is_zero
static void is_zero(const TValue &value)
Asserts that ta condition is zero.
Definition: assert.h:2472
tunit::assume::is_less
static void is_less(const TValue1 &val1, const TValue2 &val2, const tunit::line_info &line_info)
Assumes that the first value is is_less than the second value.
Definition: assume.h:1155
tunit::assume::is_true
static void is_true(bool condition, const tunit::line_info &line_info)
Assumes that a condition is true.
Definition: assume.h:2480
tunit::assume::is_null
static void is_null(const std::unique_ptr< TPointer > &pointer, const std::string &message)
Assumes that the pointer is null.
Definition: assume.h:2196
tunit::assume::is_negative
static void is_negative(const TValue &value, const std::string &message)
Assumes that ta condition is negative.
Definition: assume.h:1533
tunit::assume::are_equal
static void are_equal(float expected, float actual, float tolerance, const std::string &message, const tunit::line_info &line_info)
Assumes that two type are equal.
Definition: assume.h:188
tunit::assume::are_not_equal
static void are_not_equal(const TExpected &expected, const TActual &actual, const std::string &message, const tunit::line_info &line_info)
Assumes that two type are not equal.
Definition: assume.h:370
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::assume::are_same
static void are_same(const TExpected &expected, const TActual &actual, const std::string &message)
Assumes that two objects do refer to differents objects.
Definition: assume.h:527
tunit::assert::contains
static void contains(const TItem &item, const TCollection &collection)
Asserts that collection contains an item.
Definition: assert.h:565
tunit::assume::is_not_null
static void is_not_null(const std::shared_ptr< TPointer > &pointer, const std::string &message, const tunit::line_info &line_info)
Assumes that the pointer is not null.
Definition: assume.h:1907
tunit::assume::is_less
static void is_less(const TValue1 &val1, const TValue2 &val2, const std::string &message)
Assumes that the first value is is_less than the second value.
Definition: assume.h:1168
tunit::assume::are_equal
static void are_equal(float expected, float actual, float tolerance)
Assumes that two type are equal.
Definition: assume.h:145
line_info_
#define line_info_
Get tunit::line_info informations.
Definition: line_info.h:75
tunit::assume::is_not_null
static void is_not_null(std::nullptr_t pointer, const std::string &message)
Assumes that the pointer is not null.
Definition: assume.h:2009
tunit::assume::is_null
static void is_null(const std::weak_ptr< TPointer > &pointer)
Assumes that the pointer is null.
Definition: assume.h:2294
tunit::assume::throws_any
static void throws_any(const std::function< void()> &statement)
Assumes that the staement does not throw an exception.
Definition: assume.h:2648
tunit::assume::is_empty
static void is_empty(const TValue &value, const tunit::line_info &line_info)
Assumes that collection contains an item.
Definition: assume.h:742
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::assume::is_not_null
static void is_not_null(const std::unique_ptr< TPointer > &pointer, const std::string &message)
Assumes that the pointer is not null.
Definition: assume.h:1830
tunit::assume::are_equal
static void are_equal(float expected, float &actual, float tolerance, const std::string &message)
Assumes that two type are equal.
Definition: assume.h:173
tunit::assume::are_same
static void are_same(const TExpected &expected, const TActual &actual)
Assumes that two objects do refer to differents objects.
Definition: assume.h:495
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::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::is_positive
static void is_positive(const TValue &value)
Asserts that ta condition is positive.
Definition: assert.h:2354
tunit::assume::is_not_instance_of
static void is_not_instance_of(const TValue &value, const std::string &message, const tunit::line_info &line_info)
Assumes that an object is not of the type supplied or a derived type.
Definition: assume.h:1717
tunit::assume::is_NaN
static void is_NaN(double value, const std::string &message)
Assumes that a value is NaN.
Definition: assume.h:1356
tunit::assume::is_not_null
static void is_not_null(const std::weak_ptr< TPointer > &pointer, const std::string &message, const tunit::line_info &line_info)
Assumes that the pointer is not null.
Definition: assume.h:1977
tunit::base_assert::abort
static void abort()
Abort current test.
Definition: base_assert.h:26
tunit::assume::is_zero
static void is_zero(const TValue &value)
Assumes that ta condition is zero.
Definition: assume.h:2526
tunit::assume::is_NaN
static void is_NaN(float value)
that a value is NaN.
Definition: assume.h:1446
tunit::assume::is_null
static void is_null(std::nullptr_t pointer, const tunit::line_info &line_info)
Assumes that the pointer is null.
Definition: assume.h:2370
tunit::assume::is_not_null
static void is_not_null(const std::weak_ptr< TPointer > &pointer)
Assumes that the pointer is not null.
Definition: assume.h:1928
tunit::assert::is_negative
static void is_negative(const TValue &value)
Asserts that ta condition is negative.
Definition: assert.h:1488
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::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::assume::are_equal
static void are_equal(const TExpected &expected, const TActual &actual)
Assumes that two type are equal.
Definition: assume.h:28
tunit::assume::is_null
static void is_null(const std::weak_ptr< TPointer > &pointer, const std::string &message, const tunit::line_info &line_info)
Assumes that the pointer is null.
Definition: assume.h:2343
tunit::assume::is_zero
static void is_zero(const TValue &value, const std::string &message)
Assumes that ta condition is zero.
Definition: assume.h:2554
tunit::assume::is_not_zero
static void is_not_zero(const TValue &value, const tunit::line_info &line_info)
Assumes that ta condition is not zero.
Definition: assume.h:2054
tunit::assume::is_less_or_equal
static void is_less_or_equal(const TValue1 &val1, const TValue2 &val2, const std::string &message)
Assumes that the first value is is_less than or equal to the second value.
Definition: assume.h:1263
tunit::assume::is_positive
static void is_positive(const TValue &value)
Assumes that ta condition is positive.
Definition: assume.h:2406
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::assume::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)
Assumes that the first value is is_less than or equal to the second value.
Definition: assume.h:1278
tunit::assume::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)
Assumes that two type are equal.
Definition: assume.h:312
tunit::assume::is_null
static void is_null(const std::unique_ptr< TPointer > &pointer, const std::string &message, const tunit::line_info &line_info)
Assumes that the pointer is null.
Definition: assume.h:2211
tunit::assume::is_negative
static void is_negative(const TValue &value)
Assumes that ta condition is negative.
Definition: assume.h:1505
tunit::assume::are_not_same
static void are_not_same(const TExpected &expected, const TActual &actual)
Assumes that two objects do refer to differents objects.
Definition: assume.h:425
tunit::assume::is_instance_of
static void is_instance_of(const TValue &value, const std::string &message, const tunit::line_info &line_info)
Assumes that an object is of the type supplied or a derived type.
Definition: assume.h:1124
tunit::assume::is_empty
static void is_empty(const TValue &value)
Assumes that collection contains an item.
Definition: assume.h:728
tunit::assume::is_greater_or_equal
static void is_greater_or_equal(const TValue1 &val1, const TValue2 &val2, const std::string &message)
Assumes that the first value is greater than or equal to the second value.
Definition: assume.h:1017
tunit::assume::is_true
static void is_true(bool condition)
Assumes that ta condition is true.
Definition: assume.h:2467
tunit::assert::is_null
static void is_null(const TPointer *pointer)
Asserts that the pointer is null.
Definition: assert.h:2064
tunit::assume::are_same
static void are_same(const TExpected &expected, const TActual &actual, const tunit::line_info &line_info)
Assumes that two objects do refer to differents objects.
Definition: assume.h:511
tunit::assert::is_empty
static void is_empty(const TValue &value)
Asserts that collection contains an item.
Definition: assert.h:737
tunit::assume::are_equal
static void are_equal(double expected, double actual, double tolerance, const std::string &message, const tunit::line_info &line_info)
Assumes that two type are equal.
Definition: assume.h:250
tunit::assume::are_not_equal
static void are_not_equal(const TExpected &expected, const TActual &actual)
Assumes that two type are not equal.
Definition: assume.h:330
tunit::assume
The assert class contains a collection of static methods that implement the most common assertions us...
Definition: assume.h:12
tunit::base_assert
Definition: base_assert.h:15
tunit::assume::are_equal
static void are_equal(long double expected, long double actual, long double tolerance, const std::string &message)
Assumes that two type are equal.
Definition: assume.h:297
tunit::base_assert::succeed
static void succeed()
Generates a success with a generic message.
Definition: base_assert.h:130
tunit::assume::is_not_null
static void is_not_null(const std::shared_ptr< TPointer > &pointer, const std::string &message)
Assumes that the pointer is not null.
Definition: assume.h:1892
tunit::assume::is_not_null
static void is_not_null(const TPointer *pointer, const std::string &message, const tunit::line_info &line_info)
Assumes that the pointer is not null.
Definition: assume.h:1783
tunit::assert::is_NaN
static void is_NaN(double value)
that a value is NaN.
Definition: assert.h:1316
tunit::assume::is_greater_or_equal
static void is_greater_or_equal(const TValue1 &val1, const TValue2 &val2, const tunit::line_info &line_info)
Assumes that the first value is greater than or equal to the second value.
Definition: assume.h:1003
tunit::assume::is_null
static void is_null(const std::weak_ptr< TPointer > &pointer, const std::string &message)
Assumes that the pointer is null.
Definition: assume.h:2326
tunit::assume::is_positive
static void is_positive(const TValue &value, const std::string &message)
Assumes that ta condition is positive.
Definition: assume.h:2434
tunit
The tunit namespace contains a unit test library.
Definition: abort_error.h:8
tunit::assume::is_null
static void is_null(std::nullptr_t pointer, const std::string &message)
Assumes that the pointer is null.
Definition: assume.h:2381
tunit::assume::is_greater_or_equal
static void is_greater_or_equal(const TValue1 &val1, const TValue2 &val2)
Assumes that the first value is greater than or equal to the second value.
Definition: assume.h:989
tunit::assume::is_null
static void is_null(std::nullptr_t pointer)
Assumes that the pointer is null.
Definition: assume.h:2359
tunit::assume::is_null
static void is_null(const std::weak_ptr< TPointer > &pointer, const tunit::line_info &line_info)
Assumes that the pointer is null.
Definition: assume.h:2310
tunit::assume::is_null
static void is_null(const std::shared_ptr< TPointer > &pointer)
Assumes that the pointer is null.
Definition: assume.h:2230
tunit::assume::is_zero
static void is_zero(const TValue &value, const std::string &message, const tunit::line_info &line_info)
Assumes that ta condition is zero.
Definition: assume.h:2569
tunit::assume::is_NaN
static void is_NaN(double value, const tunit::line_info &line_info)
that a value is NaN.
Definition: assume.h:1343
tunit::assume::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)
Assumes that the first value is greater than or equal to the second value.
Definition: assume.h:1032
tunit::assume::is_instance_of
static void is_instance_of(const TValue &value, const std::string &message)
Assumes that an object is of the type supplied or a derived type.
Definition: assume.h:1110
tunit::assume::is_not_zero
static void is_not_zero(const TValue &value, const std::string &message)
Assumes that ta condition is not zero.
Definition: assume.h:2068
tunit::assume::is_null
static void is_null(const TPointer *pointer, const tunit::line_info &line_info)
Assumes that the pointer is null.
Definition: assume.h:2118
tunit::assume::is_null
static void is_null(const TPointer *pointer, const std::string &message, const tunit::line_info &line_info)
Assumes that the pointer is null.
Definition: assume.h:2149
tunit::assume::is_NaN
static void is_NaN(float value, const std::string &message)
Assumes that a value is NaN.
Definition: assume.h:1472
tunit::assume::is_not_null
static void is_not_null(const std::shared_ptr< TPointer > &pointer)
Assumes that the pointer is not null.
Definition: assume.h:1864
tunit::assume::is_NaN
static void is_NaN(float value, const std::string &message, const tunit::line_info &line_info)
Assumes that a value is NaN.
Definition: assume.h:1486
tunit::assume::are_not_equal
static void are_not_equal(const TExpected &expected, const TActual &actual, const std::string &message)
Assumes that two type are not equal.
Definition: assume.h:356
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::assume::is_NaN
static void is_NaN(long double value, const std::string &message, const tunit::line_info &line_info)
Assumes that a value is NaN.
Definition: assume.h:1428
tunit::assume::is_NaN
static void is_NaN(long double value, const std::string &message)
Assumes that a value is NaN.
Definition: assume.h:1414
tunit::assume::is_NaN
static void is_NaN(double value)
that a value is NaN.
Definition: assume.h:1330
tunit::assume::is_not_null
static void is_not_null(const std::unique_ptr< TPointer > &pointer, const tunit::line_info &line_info)
Assumes that the pointer is not null.
Definition: assume.h:1816
tunit::assume::is_not_null
static void is_not_null(std::nullptr_t pointer)
Assumes that the pointer is not null.
Definition: assume.h:1987
tunit::assume::is_not_empty
static void is_not_empty(const TValue &value, const std::string &message)
Assumes that collection does not contain any item.
Definition: assume.h:1595
tunit::assume::is_null
static void is_null(const std::shared_ptr< TPointer > &pointer, const std::string &message)
Assumes that the pointer is null.
Definition: assume.h:2258
tunit::assume::contains
static void contains(const TItem &item, const TCollection &collection)
Assumes that collection contains an item.
Definition: assume.h:563
tunit::assume::throws_any
static void throws_any(const std::function< void()> &statement, const tunit::line_info &line_info)
Assumes that the staement does not throw an exception.
Definition: assume.h:2660
tunit::assume::is_positive
static void is_positive(const TValue &value, const tunit::line_info &line_info)
Assumes that ta condition is positive.
Definition: assume.h:2420
tunit::assume::are_equal
static void are_equal(long double expected, long double actual, long double tolerance, const tunit::line_info &line_info)
Assumes that two type are equal.
Definition: assume.h:283
tunit::assume::is_positive
static void is_positive(const TValue &value, const std::string &message, const tunit::line_info &line_info)
Assumes that ta condition is positive.
Definition: assume.h:2449
tunit::assume::is_not_null
static void is_not_null(const TPointer *pointer, const std::string &message)
Assumes that the pointer is not null.
Definition: assume.h:1767
tunit::assume::is_not_empty
static void is_not_empty(const TValue &value)
Assumes that collection oes not contain any item.
Definition: assume.h:1567
tunit::assume::are_not_equal
static void are_not_equal(const TExpected &expected, const TActual &actual, const tunit::line_info &line_info)
Assumes that two type are not equal.
Definition: assume.h:343
tunit::assume::are_equal
static void are_equal(double expected, double actual, double tolerance)
Assumes that two type are equal.
Definition: assume.h:207
tunit::assume::throws_any
static void throws_any(const std::function< void()> &statement, const std::string &message, const tunit::line_info &line_info)
Assumes that the staement does not throw an exception.
Definition: assume.h:2685
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::assume::is_less
static void is_less(const TValue1 &val1, const TValue2 &val2)
Assumes that the first value is is_less than the second value.
Definition: assume.h:1142
tunit::assume::throws_any
static void throws_any(const std::function< void()> &statement, const std::string &message)
Assumes that the staement does not throw an exception.
Definition: assume.h:2672
tunit::assume::is_not_null
static void is_not_null(std::nullptr_t pointer, const tunit::line_info &line_info)
Assumes that the pointer is not null.
Definition: assume.h:1998
tunit::assume::is_less_or_equal
static void is_less_or_equal(const TValue1 &val1, const TValue2 &val2)
Assumes that the first value is is_less than or equal to the second value.
Definition: assume.h:1235
tunit::assume::is_true
static void is_true(bool condition, const std::string &message, const tunit::line_info &line_info)
Assumes that a condition is true.
Definition: assume.h:2507
tunit::assume::are_not_same
static void are_not_same(const TExpected &expected, const TActual &actual, const std::string &message)
Assumes that two objects do refer to differents objects.
Definition: assume.h:457
tunit::assume::is_empty
static void is_empty(const TValue &value, const std::string &message, const tunit::line_info &line_info)
Assumes that collection contains an item.
Definition: assume.h:771
tunit::assume::is_not_null
static void is_not_null(const std::weak_ptr< TPointer > &pointer, const tunit::line_info &line_info)
Assumes that the pointer is not null.
Definition: assume.h:1944
tunit::assume::is_not_null
static void is_not_null(const TPointer *pointer)
Assumes that the pointer is not null.
Definition: assume.h:1737
tunit::assume::are_equal
static void are_equal(float expected, float actual, float tolerance, const tunit::line_info &line_info)
Assumes that two type are equal.
Definition: assume.h:159
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::assume::are_equal
static void are_equal(long double expected, long double actual, long double tolerance)
Assumes that two type are equal.
Definition: assume.h:269