xtd - Reference Guide  0.1.1
Modern c++17/20 framework to create console, GUI and unit test applications on Windows, macOS, Linux, iOS and android.
valid.h
Go to the documentation of this file.
1 #pragma once
5 #include "assert.h"
6 
8 namespace xtd {
10  namespace tunit {
20  class valid final : private base_assert {
21  public:
23  valid() = delete;
25 
34  template<typename expected_t, typename actual_t>
35  static void are_equal(const expected_t& expected, const actual_t& actual) {are_equal(expected, actual, "", xtd::diagnostics::stack_frame::empty());}
36 
46  template<typename expected_t, typename actual_t>
47  static void are_equal(const expected_t& expected, const actual_t& actual, const xtd::diagnostics::stack_frame& stack_frame) {are_equal(expected, actual, "", stack_frame);}
48 
58  template<typename expected_t, typename actual_t>
59  static void are_equal(const expected_t& expected, const actual_t& actual, const xtd::ustring& message) {are_equal(expected, actual, message, xtd::diagnostics::stack_frame::empty());}
60 
71  template<typename expected_t, typename actual_t>
72  static void are_equal(const expected_t& expected, const actual_t& actual, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
73  try {
74  assert::are_equal(expected, actual, message, stack_frame);
75  } catch (...) {
76  base_assert::error();
77  }
78  }
79 
81  static void are_equal(const char* expected, const char* actual, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
82  try{
83  assert::are_equal(expected, actual, message, stack_frame);
84  } catch (...) {
85  base_assert::error();
86  }
87  }
88 
89  static void are_equal(const char8_t* expected, const char8_t* actual, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
90  try {
91  assert::are_equal(expected, actual, message, stack_frame);
92  } catch (...) {
93  base_assert::error();
94  }
95  }
96 
97  static void are_equal(const char16_t* expected, const char16_t* actual, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
98  try {
99  assert::are_equal(expected, actual, message, stack_frame);
100  } catch (...) {
101  base_assert::error();
102  }
103  }
104 
105  static void are_equal(const char32_t* expected, const char32_t* actual, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
106  try {
107  assert::are_equal(expected, actual, message, stack_frame);
108  } catch (...) {
109  base_assert::error();
110  }
111  }
112 
113  static void are_equal(const wchar_t* expected, const wchar_t* actual, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
114  try {
115  assert::are_equal(expected, actual, message, stack_frame);
116  } catch (...) {
117  base_assert::error();
118  }
119  }
120 
121  static void are_equal(float expected, float actual, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
122  try {
123  assert::are_equal(expected, actual, message, stack_frame);
124  } catch (...) {
125  base_assert::error();
126  }
127  }
128 
129  static void are_equal(double expected, double actual, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
130  try {
131  assert::are_equal(expected, actual, message, stack_frame);
132  } catch (...) {
133  base_assert::error();
134  }
135  }
136 
137  static void are_equal(long double expected, long double actual, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
138  try {
139  assert::are_equal(expected, actual, message, stack_frame);
140  } catch (...) {
141  base_assert::error();
142  }
143  }
145 
156  static void are_equal(float expected, float actual, float tolerance) {are_equal(expected, actual, tolerance, "", csf_);}
157 
169  static void are_equal(float expected, float actual, float tolerance, const xtd::diagnostics::stack_frame& stack_frame) {are_equal(expected, actual, tolerance, "", stack_frame);}
170 
182  static void are_equal(float expected, float& actual, float tolerance, const xtd::ustring& message) {are_equal(expected, actual, tolerance, message, xtd::diagnostics::stack_frame::empty());}
183 
196  static void are_equal(float expected, float actual, float tolerance, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
197  try {
198  assert::are_equal(expected, actual, tolerance, message, stack_frame);
199  } catch (...) {
200  base_assert::error();
201  }
202  }
203 
214  static void are_equal(double expected, double actual, double tolerance) {are_equal(expected, actual, tolerance, "", csf_);}
215 
227  static void are_equal(double expected, double actual, double tolerance, const xtd::diagnostics::stack_frame& stack_frame) {are_equal(expected, actual, tolerance, "", stack_frame);}
228 
240  static void are_equal(double expected, double actual, double tolerance, const xtd::ustring& message) {are_equal(expected, actual, tolerance, message, xtd::diagnostics::stack_frame::empty());}
241 
254  static void are_equal(double expected, double actual, double tolerance, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
255  try {
256  assert::are_equal(expected, actual, tolerance, message, stack_frame);
257  } catch (...) {
258  base_assert::error();
259  }
260  }
261 
272  static void are_equal(long double expected, long double actual, long double tolerance) {are_equal(expected, actual, tolerance, "", csf_);}
273 
285  static void are_equal(long double expected, long double actual, long double tolerance, const xtd::diagnostics::stack_frame& stack_frame) {are_equal(expected, actual, tolerance, "", stack_frame);}
286 
298  static void are_equal(long double expected, long double actual, long double tolerance, const xtd::ustring& message) {are_equal(expected, actual, tolerance, message, xtd::diagnostics::stack_frame::empty());}
299 
312  static void are_equal(long double expected, long double actual, long double tolerance, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
313  try {
314  assert::are_equal(expected, actual, tolerance, message, stack_frame);
315  } catch (...) {
316  base_assert::error();
317  }
318  }
319 
328  template<typename expected_t, typename actual_t>
329  static void are_not_equal(const expected_t& expected, const actual_t& actual) {are_not_equal(expected, actual, "", xtd::diagnostics::stack_frame::empty());}
330 
340  template<typename expected_t, typename actual_t>
341  static void are_not_equal(const expected_t& expected, const actual_t& actual, const xtd::diagnostics::stack_frame& stack_frame) {are_not_equal(expected, actual, "", stack_frame);}
342 
352  template<typename expected_t, typename actual_t>
353  static void are_not_equal(const expected_t& expected, const actual_t& actual, const xtd::ustring& message) {are_not_equal(expected, actual, message, xtd::diagnostics::stack_frame::empty());}
354 
365  template<typename expected_t, typename actual_t>
366  static void are_not_equal(const expected_t& expected, const actual_t& actual, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
367  try {
368  assert::are_not_equal(expected, actual, message, stack_frame);
369  } catch (...) {
370  base_assert::error();
371  }
372  }
373 
375  static void are_not_equal(const char* expected, const char* actual, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
376  try {
377  assert::are_not_equal(expected, actual, message, stack_frame);
378  } catch (...) {
379  base_assert::error();
380  }
381  }
382 
383  static void are_not_equal(const char8_t* expected, const char8_t* actual, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
384  try {
385  assert::are_not_equal(expected, actual, message, stack_frame);
386  } catch (...) {
387  base_assert::error();
388  }
389  }
390 
391  static void are_not_equal(const char16_t* expected, const char16_t* actual, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
392  try {
393  assert::are_not_equal(expected, actual, message, stack_frame);
394  } catch (...) {
395  base_assert::error();
396  }
397  }
398 
399  static void are_not_equal(const char32_t* expected, const char32_t* actual, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
400  try {
401  assert::are_not_equal(expected, actual, message, stack_frame);
402  } catch (...) {
403  base_assert::error();
404  }
405  }
406 
407  static void are_not_equal(const wchar_t* expected, const wchar_t* actual, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
408  try {
409  assert::are_not_equal(expected, actual, message, stack_frame);
410  } catch (...) {
411  base_assert::error();
412  }
413  }
415 
427  template<typename expected_t, typename actual_t>
428  static void are_not_same(const expected_t& expected, const actual_t& actual) {are_not_same(expected, actual, "", xtd::diagnostics::stack_frame::empty());}
429 
442  template<typename expected_t, typename actual_t>
443  static void are_not_same(const expected_t& expected, const actual_t& actual, const xtd::diagnostics::stack_frame& stack_frame) {are_not_same(expected, actual, "", stack_frame);}
444 
457  template<typename expected_t, typename actual_t>
458  static void are_not_same(const expected_t& expected, const actual_t& actual, const xtd::ustring& message) {are_not_same(expected, actual, message, xtd::diagnostics::stack_frame::empty());}
459 
473  template<typename expected_t, typename actual_t>
474  static void are_not_same(const expected_t& expected, const actual_t& actual, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
475  try {
476  assert::are_not_same(expected, actual, message, stack_frame);
477  } catch (...) {
478  base_assert::error();
479  }
480  }
481 
493  template<typename expected_t, typename actual_t>
494  static void are_same(const expected_t& expected, const actual_t& actual) {are_same(expected, actual, "", xtd::diagnostics::stack_frame::empty());}
495 
508  template<typename expected_t, typename actual_t>
509  static void are_same(const expected_t& expected, const actual_t& actual, const xtd::diagnostics::stack_frame& stack_frame) {are_same(expected, actual, "", stack_frame);}
510 
523  template<typename expected_t, typename actual_t>
524  static void are_same(const expected_t& expected, const actual_t& actual, const xtd::ustring& message) {are_same(expected, actual, message, xtd::diagnostics::stack_frame::empty());}
525 
539  template<typename expected_t, typename actual_t>
540  static void are_same(const expected_t& expected, const actual_t& actual, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
541  try {
542  assert::are_same(expected, actual, message, stack_frame);
543  } catch (...) {
544  base_assert::error();
545  }
546  }
547 
557  template<typename item_t, typename collection_t>
558  static void contains(const item_t& item, const collection_t& collection) {contains(item, collection, "", xtd::diagnostics::stack_frame::empty());}
559 
570  template<typename item_t, typename collection_t>
571  static void contains(const item_t& item, const collection_t& collection, const xtd::diagnostics::stack_frame& stack_frame) {contains(item, collection, "", stack_frame);}
572 
583  template<typename item_t, typename collection_t>
584  static void contains(const item_t& item, const collection_t& collection, const xtd::ustring& message) {contains(item, collection, message, xtd::diagnostics::stack_frame::empty());}
585 
597  template<typename item_t, typename collection_t>
598  static void contains(const item_t& item, const collection_t& collection, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
599  try {
600  assert::contains(item, collection, message, stack_frame);
601  } catch (...) {
602  base_assert::error();
603  }
604  }
605 
607  template<typename item_t, typename value_t>
608  static void contains(const item_t& item, const std::initializer_list<value_t>& values) {contains(item, values, "", xtd::diagnostics::stack_frame::empty());}
609  template<typename item_t, typename value_t>
610  static void contains(const item_t& item, const std::initializer_list<value_t>& values, const xtd::diagnostics::stack_frame& stack_frame) {contains(item, values, "", stack_frame);}
611  template<typename item_t, typename value_t>
612  static void contains(const item_t& item, const std::initializer_list<value_t>& values, const xtd::ustring& message) {contains(item, values, message, xtd::diagnostics::stack_frame::empty());}
613  template<typename item_t, typename value_t>
614  static void contains(const item_t& item, const std::initializer_list<value_t>& values, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
615  try {
616  assert::contains(item, values, message, stack_frame);
617  } catch (...) {
618  base_assert::error();
619  }
620  }
621 
622  static void contains(char item, const char* values, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
623  try {
624  assert::contains(item, values, message, stack_frame);
625  } catch (...) {
626  base_assert::error();
627  }
628  }
629 
630  static void contains(char8_t item, const char8_t* values, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
631  try {
632  assert::contains(item, values, message, stack_frame);
633  } catch (...) {
634  base_assert::error();
635  }
636  }
637 
638  static void contains(char16_t item, const char16_t* values, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
639  try {
640  assert::contains(item, values, message, stack_frame);
641  } catch (...) {
642  base_assert::error();
643  }
644  }
645 
646  static void contains(char32_t item, const char32_t* values, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
647  try {
648  assert::contains(item, values, message, stack_frame);
649  } catch (...) {
650  base_assert::error();
651  }
652  }
653 
654  static void contains(wchar_t item, const wchar_t* values, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
655  try {
656  assert::contains(item, values, message, stack_frame);
657  } catch (...) {
658  base_assert::error();
659  }
660  }
662 
671  static void does_not_throw(const std::function<void()>& statement) {does_not_throw(statement, "", xtd::diagnostics::stack_frame::empty());}
672 
682  static void does_not_throw(const std::function<void()>& statement, const xtd::diagnostics::stack_frame& stack_frame) {does_not_throw(statement, "", stack_frame);}
683 
693  static void does_not_throw(const std::function<void()>& statement, const xtd::ustring& message) {does_not_throw(statement, message, xtd::diagnostics::stack_frame::empty());}
694 
705  static void does_not_throw(const std::function<void()>& statement, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
706  try {
707  assert::does_not_throw(statement, message, stack_frame);
708  } catch (...) {
709  base_assert::error();
710  }
711  }
712 
722  template<typename value_t>
723  static void is_empty(const value_t& value) {is_empty(value, "", xtd::diagnostics::stack_frame::empty());}
724 
735  template<typename value_t>
736  static void is_empty(const value_t& value, const xtd::diagnostics::stack_frame& stack_frame) {is_empty(value, "", stack_frame);}
737 
748  template<typename value_t>
749  static void is_empty(const value_t& value, const xtd::ustring& message) {is_empty(value, message, xtd::diagnostics::stack_frame::empty());}
750 
762  template<typename value_t>
763  static void is_empty(const value_t& value, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
764  try {
765  assert::is_empty(value, message, stack_frame);
766  } catch (...) {
767  base_assert::error();
768  }
769  }
770 
772  template<typename value_t>
773  static void is_empty(const std::initializer_list<value_t>& value) {is_empty(value, "", xtd::diagnostics::stack_frame::empty());}
774  template<typename value_t>
775  static void is_empty(const std::initializer_list<value_t>& value, const xtd::diagnostics::stack_frame& stack_frame) {is_empty(value, "", stack_frame);}
776  template<typename value_t>
777  static void is_empty(const std::initializer_list<value_t>& value, const xtd::ustring& message) {is_empty(value, message, xtd::diagnostics::stack_frame::empty());}
778  template<typename value_t>
779  static void is_empty(const std::initializer_list<value_t>& values, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
780  try {
781  assert::is_empty(values, message, stack_frame);
782  } catch (...) {
783  base_assert::error();
784  }
785  }
786 
787  static void is_empty(const char* value, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
788  try {
789  assert::is_empty(value, message, stack_frame);
790  } catch (...) {
791  base_assert::error();
792  }
793  }
794 
795  static void is_empty(const char8_t* value, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
796  try {
797  assert::is_empty(value, message, stack_frame);
798  } catch (...) {
799  base_assert::error();
800  }
801  }
802 
803  static void is_empty(const char16_t* value, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
804  try {
805  assert::is_empty(value, message, stack_frame);
806  } catch (...) {
807  base_assert::error();
808  }
809  }
810 
811  static void is_empty(const char32_t* value, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
812  try {
813  assert::is_empty(value, message, stack_frame);
814  } catch (...) {
815  base_assert::error();
816  }
817  }
818 
819  static void is_empty(const wchar_t* value, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
820  try {
821  assert::is_empty(value, message, stack_frame);
822  } catch (...) {
823  base_assert::error();
824  }
825  }
827 
837  static void is_false(bool condition) {is_false(condition, "", xtd::diagnostics::stack_frame::empty());}
838 
849  static void is_false(bool condition, const xtd::diagnostics::stack_frame& stack_frame) {is_false(condition, "", stack_frame);}
850 
861  static void is_false(bool condition, const xtd::ustring& message) {is_false(condition, message, xtd::diagnostics::stack_frame::empty());}
862 
874  static void is_false(bool condition, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
875  try {
876  assert::is_false(condition, message, stack_frame);
877  } catch (...) {
878  base_assert::error();
879  }
880  }
881 
890  template<typename value1_t, typename value2_t>
891  static void is_greater(const value1_t& val1, const value2_t& val2) {is_greater(val1, val2, "", xtd::diagnostics::stack_frame::empty());}
892 
902  template<typename value1_t, typename value2_t>
903  static void is_greater(const value1_t& val1, const value2_t& val2, const xtd::diagnostics::stack_frame& stack_frame) {is_greater(val1, val2, "", stack_frame);}
904 
914  template<typename value1_t, typename value2_t>
915  static void is_greater(const value1_t& val1, const value2_t& val2, const xtd::ustring& message) {is_greater(val1, val2, message, xtd::diagnostics::stack_frame::empty());}
916 
927  template<typename value1_t, typename value2_t>
928  static void is_greater(const value1_t& val1, const value2_t& val2, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
929  try {
930  assert::is_greater(val1, val2, message, stack_frame);
931  } catch (...) {
932  base_assert::error();
933  }
934  }
935 
937  static void is_greater(const char* val1, const char* val2, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
938  try {
939  assert::is_greater(val1, val2, message, stack_frame);
940  } catch (...) {
941  base_assert::error();
942  }
943  }
944 
945  static void is_greater(const char8_t* val1, const char8_t* val2, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
946  try {
947  assert::is_greater(val1, val2, message, stack_frame);
948  } catch (...) {
949  base_assert::error();
950  }
951  }
952 
953  static void is_greater(const char16_t* val1, const char16_t* val2, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
954  try {
955  assert::is_greater(val1, val2, message, stack_frame);
956  } catch (...) {
957  base_assert::error();
958  }
959  }
960 
961  static void is_greater(const char32_t* val1, const char32_t* val2, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
962  try {
963  assert::is_greater(val1, val2, message, stack_frame);
964  } catch (...) {
965  base_assert::error();
966  }
967  }
968 
969  static void is_greater(const wchar_t* val1, const wchar_t* val2, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
970  try {
971  assert::is_greater(val1, val2, message, stack_frame);
972  } catch (...) {
973  base_assert::error();
974  }
975  }
977 
987  template<typename value1_t, typename value2_t>
988  static void is_greater_or_equal(const value1_t& val1, const value2_t& val2) {is_greater_or_equal(val1, val2, "", xtd::diagnostics::stack_frame::empty());}
989 
1000  template<typename value1_t, typename value2_t>
1001  static void is_greater_or_equal(const value1_t& val1, const value2_t& val2, const xtd::diagnostics::stack_frame& stack_frame) {is_greater_or_equal(val1, val2, "", stack_frame);}
1002 
1013  template<typename value1_t, typename value2_t>
1014  static void is_greater_or_equal(const value1_t& val1, const value2_t& val2, const xtd::ustring& message) {is_greater_or_equal(val1, val2, message, xtd::diagnostics::stack_frame::empty());}
1015 
1027  template<typename value1_t, typename value2_t>
1028  static void is_greater_or_equal(const value1_t& val1, const value2_t& val2, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
1029  try {
1030  assert::is_greater_or_equal(val1, val2, message, stack_frame);
1031  } catch (...) {
1032  base_assert::error();
1033  }
1034  }
1035 
1037  static void is_greater_or_equal(const char* val1, const char* val2, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
1038  try {
1039  assert::is_greater_or_equal(val1, val2, message, stack_frame);
1040  } catch (...) {
1041  base_assert::error();
1042  }
1043  }
1044 
1045  static void is_greater_or_equal(const char8_t* val1, const char8_t* val2, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
1046  try {
1047  assert::is_greater_or_equal(val1, val2, message, stack_frame);
1048  } catch (...) {
1049  base_assert::error();
1050  }
1051  }
1052 
1053  static void is_greater_or_equal(const char16_t* val1, const char16_t* val2, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
1054  try {
1055  assert::is_greater_or_equal(val1, val2, message, stack_frame);
1056  } catch (...) {
1057  base_assert::error();
1058  }
1059  }
1060 
1061  static void is_greater_or_equal(const char32_t* val1, const char32_t* val2, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
1062  try {
1063  assert::is_greater_or_equal(val1, val2, message, stack_frame);
1064  } catch (...) {
1065  base_assert::error();
1066  }
1067  }
1068 
1069  static void is_greater_or_equal(const wchar_t* val1, const wchar_t* val2, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
1070  try {
1071  assert::is_greater_or_equal(val1, val2, message, stack_frame);
1072  } catch (...) {
1073  base_assert::error();
1074  }
1075  }
1077 
1086  template<typename type_t, typename value_t>
1087  static void is_instance_of(const value_t& value) {is_instance_of<type_t>(value, "", xtd::diagnostics::stack_frame::empty());}
1088 
1098  template<typename type_t, typename value_t>
1099  static void is_instance_of(const value_t& value, const xtd::diagnostics::stack_frame& stack_frame) {is_instance_of<type_t>(value, "", stack_frame);}
1100 
1110  template<typename type_t, typename value_t>
1111  static void is_instance_of(const value_t& value, const xtd::ustring& message) {is_instance_of<type_t>(value, message, xtd::diagnostics::stack_frame::empty());}
1112 
1123  template<typename type_t, typename value_t>
1124  static void is_instance_of(const value_t& value, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
1125  try {
1126  assert::is_instance_of<type_t>(value, message, stack_frame);
1127  } catch (...) {
1128  base_assert::error();
1129  }
1130  }
1131 
1140  template<typename value1_t, typename value2_t>
1141  static void is_less(const value1_t& val1, const value2_t& val2) {is_less(val1, val2, "", xtd::diagnostics::stack_frame::empty());}
1142 
1152  template<typename value1_t, typename value2_t>
1153  static void is_less(const value1_t& val1, const value2_t& val2, const xtd::diagnostics::stack_frame& stack_frame) {is_less(val1, val2, "", stack_frame);}
1154 
1164  template<typename value1_t, typename value2_t>
1165  static void is_less(const value1_t& val1, const value2_t& val2, const xtd::ustring& message) {is_less(val1, val2, message, xtd::diagnostics::stack_frame::empty());}
1166 
1177  template<typename value1_t, typename value2_t>
1178  static void is_less(const value1_t& val1, const value2_t& val2, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
1179  try {
1180  assert::is_less(val1, val2, message, stack_frame);
1181  } catch (...) {
1182  base_assert::error();
1183  }
1184  }
1185 
1187  static void is_less(const char* val1, const char* val2, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
1188  try {
1189  assert::is_less(val1, val2, message, stack_frame);
1190  } catch (...) {
1191  base_assert::error();
1192  }
1193  }
1194 
1195  static void is_less(const char8_t* val1, const char8_t* val2, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
1196  try {
1197  assert::is_less(val1, val2, message, stack_frame);
1198  } catch (...) {
1199  base_assert::error();
1200  }
1201  }
1202 
1203  static void is_less(const char16_t* val1, const char16_t* val2, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
1204  try {
1205  assert::is_less(val1, val2, message, stack_frame);
1206  } catch (...) {
1207  base_assert::error();
1208  }
1209  }
1210 
1211  static void is_less(const char32_t* val1, const char32_t* val2, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
1212  try {
1213  assert::is_less(val1, val2, message, stack_frame);
1214  } catch (...) {
1215  base_assert::error();
1216  }
1217  }
1218 
1219  static void is_less(const wchar_t* val1, const wchar_t* val2, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
1220  try {
1221  assert::is_less(val1, val2, message, stack_frame);
1222  } catch (...) {
1223  base_assert::error();
1224  }
1225  }
1227 
1237  template<typename value1_t, typename value2_t>
1238  static void is_less_or_equal(const value1_t& val1, const value2_t& val2) {is_less_or_equal(val1, val2, "", xtd::diagnostics::stack_frame::empty());}
1239 
1250  template<typename value1_t, typename value2_t>
1251  static void is_less_or_equal(const value1_t& val1, const value2_t& val2, const xtd::diagnostics::stack_frame& stack_frame) {is_less_or_equal(val1, val2, "", stack_frame);}
1252 
1263  template<typename value1_t, typename value2_t>
1264  static void is_less_or_equal(const value1_t& val1, const value2_t& val2, const xtd::ustring& message) {is_less_or_equal(val1, val2, message, xtd::diagnostics::stack_frame::empty());}
1265 
1277  template<typename value1_t, typename value2_t>
1278  static void is_less_or_equal(const value1_t& val1, const value2_t& val2, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
1279  try {
1280  assert::is_less_or_equal(val1, val2, message, stack_frame);
1281  } catch (...) {
1282  base_assert::error();
1283  }
1284  }
1285 
1287  static void is_less_or_equal(const char* val1, const char* val2, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
1288  try {
1289  assert::is_less_or_equal(val1, val2, message, stack_frame);
1290  } catch (...) {
1291  base_assert::error();
1292  }
1293  }
1294 
1295  static void is_less_or_equal(const char8_t* val1, const char8_t* val2, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
1296  try {
1297  assert::is_less_or_equal(val1, val2, message, stack_frame);
1298  } catch (...) {
1299  base_assert::error();
1300  }
1301  }
1302 
1303  static void is_less_or_equal(const char16_t* val1, const char16_t* val2, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
1304  try {
1305  assert::is_less_or_equal(val1, val2, message, stack_frame);
1306  } catch (...) {
1307  base_assert::error();
1308  }
1309  }
1310 
1311  static void is_less_or_equal(const char32_t* val1, const char32_t* val2, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
1312  try {
1313  assert::is_less_or_equal(val1, val2, message, stack_frame);
1314  } catch (...) {
1315  base_assert::error();
1316  }
1317  }
1318 
1319  static void is_less_or_equal(const wchar_t* val1, const wchar_t* val2, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
1320  try {
1321  assert::is_less_or_equal(val1, val2, message, stack_frame);
1322  } catch (...) {
1323  base_assert::error();
1324  }
1325  }
1327 
1337  static void is_NaN(double value) {is_NaN(value, "", xtd::diagnostics::stack_frame::empty());}
1338 
1349  static void is_NaN(double value, const xtd::diagnostics::stack_frame& stack_frame) {is_NaN(value, "", stack_frame);}
1350 
1361  static void is_NaN(double value, const xtd::ustring& message) {is_NaN(value, message, xtd::diagnostics::stack_frame::empty());}
1362 
1374  static void is_NaN(double value, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
1375  try {
1376  assert::is_NaN(value, message, stack_frame);
1377  } catch (...) {
1378  base_assert::error();
1379  }
1380  }
1381 
1391  static void is_NaN(long double value) {is_NaN(value, "", xtd::diagnostics::stack_frame::empty());}
1392 
1403  static void is_NaN(long double value, const xtd::diagnostics::stack_frame& stack_frame) {is_NaN(value, "", stack_frame);}
1404 
1415  static void is_NaN(long double value, const xtd::ustring& message) {is_NaN(value, message, xtd::diagnostics::stack_frame::empty());}
1416 
1428  static void is_NaN(long double value, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
1429  try {
1430  assert::is_NaN(value, message, stack_frame);
1431  } catch (...) {
1432  base_assert::error();
1433  }
1434  }
1435 
1445  static void is_NaN(float value) {is_NaN(value, "", xtd::diagnostics::stack_frame::empty());}
1446 
1457  static void is_NaN(float value, const xtd::diagnostics::stack_frame& stack_frame) {is_NaN(value, "", stack_frame);}
1458 
1469  static void is_NaN(float value, const xtd::ustring& message) {is_NaN(value, message, xtd::diagnostics::stack_frame::empty());}
1470 
1482  static void is_NaN(float value, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
1483  try {
1484  assert::is_NaN(value, message, stack_frame);
1485  } catch (...) {
1486  base_assert::error();
1487  }
1488  }
1489 
1499  template<typename value_t>
1500  static void is_negative(const value_t& value) {is_negative(value, "", xtd::diagnostics::stack_frame::empty());}
1501 
1512  template<typename value_t>
1513  static void is_negative(const value_t& value, const xtd::diagnostics::stack_frame& stack_frame) {is_negative(value, "", stack_frame);}
1514 
1525  template<typename value_t>
1526  static void is_negative(const value_t& value, const xtd::ustring& message) {is_negative(value, message, xtd::diagnostics::stack_frame::empty());}
1527 
1539  template<typename value_t>
1540  static void is_negative(const value_t& value, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
1541  try {
1542  assert::is_negative(value, message, stack_frame);
1543  } catch (...) {
1544  base_assert::error();
1545  }
1546  }
1547 
1557  template<typename value_t>
1558  static void is_not_empty(const value_t& value) {is_not_empty(value, "", xtd::diagnostics::stack_frame::empty());}
1559 
1570  template<typename value_t>
1571  static void is_not_empty(const value_t& value, const xtd::diagnostics::stack_frame& stack_frame) {is_not_empty(value, "", stack_frame);}
1572 
1583  template<typename value_t>
1584  static void is_not_empty(const value_t& value, const xtd::ustring& message) {is_not_empty(value, message, xtd::diagnostics::stack_frame::empty());}
1585 
1597  template<typename value_t>
1598  static void is_not_empty(const value_t& value, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
1599  try {
1600  assert::is_not_empty(value, message, stack_frame);
1601  } catch (...) {
1602  base_assert::error();
1603  }
1604  }
1605 
1607  template<typename value_t>
1608  static void is_not_empty(const std::initializer_list<value_t>& value) {is_not_empty(value, "", xtd::diagnostics::stack_frame::empty());}
1609  template<typename value_t>
1610  static void is_not_empty(const std::initializer_list<value_t>& value, const xtd::diagnostics::stack_frame& stack_frame) {is_not_empty(value, "", stack_frame);}
1611  template<typename value_t>
1612  static void is_not_empty(const std::initializer_list<value_t>& value, const xtd::ustring& message) {is_not_empty(value, message, xtd::diagnostics::stack_frame::empty());}
1613  template<typename value_t>
1614  static void is_not_empty(const std::initializer_list<value_t>& value, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
1615  try {
1616  assert::is_not_empty(value, message, stack_frame);
1617  } catch (...) {
1618  base_assert::error();
1619  }
1620  }
1621 
1622  static void is_not_empty(const char* value, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
1623  try {
1624  assert::is_not_empty(value, message, stack_frame);
1625  } catch (...) {
1626  base_assert::error();
1627  }
1628  }
1629 
1630  static void is_not_empty(const char8_t* value, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
1631  try {
1632  assert::is_not_empty(value, message, stack_frame);
1633  } catch (...) {
1634  base_assert::error();
1635  }
1636  }
1637 
1638  static void is_not_empty(const char16_t* value, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
1639  try {
1640  assert::is_not_empty(value, message, stack_frame);
1641  } catch (...) {
1642  base_assert::error();
1643  }
1644  }
1645 
1646  static void is_not_empty(const char32_t* value, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
1647  try {
1648  assert::is_not_empty(value, message, stack_frame);
1649  } catch (...) {
1650  base_assert::error();
1651  }
1652  }
1653 
1654  static void is_not_empty(const wchar_t* value, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
1655  try {
1656  assert::is_not_empty(value, message, stack_frame);
1657  } catch (...) {
1658  base_assert::error();
1659  }
1660  }
1662 
1671  template<typename type_t, typename value_t>
1672  static void is_not_instance_of(const value_t& value) {is_not_instance_of<type_t>(value, "", xtd::diagnostics::stack_frame::empty());}
1673 
1683  template<typename type_t, typename value_t>
1684  static void is_not_instance_of(const value_t& value, const xtd::diagnostics::stack_frame& stack_frame) {is_not_instance_of<type_t>(value, "", stack_frame);}
1685 
1695  template<typename type_t, typename value_t>
1696  static void is_not_instance_of(const value_t& value, const xtd::ustring& message) {is_not_instance_of<type_t>(value, message, xtd::diagnostics::stack_frame::empty());}
1697 
1708  template<typename type_t, typename value_t>
1709  static void is_not_instance_of(const value_t& value, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
1710  try {
1711  assert::is_not_instance_of<type_t>(value, message, stack_frame);
1712  } catch (...) {
1713  base_assert::error();
1714  }
1715  }
1716 
1727  template<typename pointer_t>
1728  static void is_not_null(const pointer_t* pointer) {is_not_null(pointer, "", xtd::diagnostics::stack_frame::empty());}
1729 
1741  template<typename pointer_t>
1742  static void is_not_null(const pointer_t* pointer, const xtd::diagnostics::stack_frame& stack_frame) {is_not_null(pointer, "", stack_frame);}
1743 
1755  template<typename pointer_t>
1756  static void is_not_null(const pointer_t* pointer, const xtd::ustring& message) {is_not_null(pointer, message, xtd::diagnostics::stack_frame::empty());}
1757 
1770  template<typename pointer_t>
1771  static void is_not_null(const pointer_t* pointer, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
1772  try {
1773  assert::is_not_null(pointer, message, stack_frame);
1774  } catch (...) {
1775  base_assert::error();
1776  }
1777  }
1778 
1788  template<typename pointer_t>
1789  static void is_not_null(const std::unique_ptr<pointer_t>& pointer) {is_not_null(pointer, "", xtd::diagnostics::stack_frame::empty());}
1790 
1801  template<typename pointer_t>
1802  static void is_not_null(const std::unique_ptr<pointer_t>& pointer, const xtd::diagnostics::stack_frame& stack_frame) {is_not_null(pointer, "", stack_frame);}
1803 
1814  template<typename pointer_t>
1815  static void is_not_null(const std::unique_ptr<pointer_t>& pointer, const xtd::ustring& message) {is_not_null(pointer, message, xtd::diagnostics::stack_frame::empty());}
1816 
1828  template<typename pointer_t>
1829  static void is_not_null(const std::unique_ptr<pointer_t>& pointer, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
1830  try {
1831  assert::is_not_null(pointer, message, stack_frame);
1832  } catch (...) {
1833  base_assert::error();
1834  }
1835  }
1836 
1846  template<typename pointer_t>
1847  static void is_not_null(const std::shared_ptr<pointer_t>& pointer) {is_not_null(pointer, "", xtd::diagnostics::stack_frame::empty());}
1848 
1859  template<typename pointer_t>
1860  static void is_not_null(const std::shared_ptr<pointer_t>& pointer, const xtd::diagnostics::stack_frame& stack_frame) {is_not_null(pointer, "", stack_frame);}
1861 
1872  template<typename pointer_t>
1873  static void is_not_null(const std::shared_ptr<pointer_t>& pointer, const xtd::ustring& message) {is_not_null(pointer, message, xtd::diagnostics::stack_frame::empty());}
1874 
1886  template<typename pointer_t>
1887  static void is_not_null(const std::shared_ptr<pointer_t>& pointer, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
1888  try {
1889  assert::is_not_null(pointer, message, stack_frame);
1890  } catch (...) {
1891  base_assert::error();
1892  }
1893  }
1894 
1906  template<typename pointer_t>
1907  static void is_not_null(const std::weak_ptr<pointer_t>& pointer) {is_not_null(pointer, "", xtd::diagnostics::stack_frame::empty());}
1908 
1921  template<typename pointer_t>
1922  static void is_not_null(const std::weak_ptr<pointer_t>& pointer, const xtd::diagnostics::stack_frame& stack_frame) {is_not_null(pointer, "", stack_frame);}
1923 
1936  template<typename pointer_t>
1937  static void is_not_null(const std::weak_ptr<pointer_t>& pointer, const xtd::ustring& message) {is_not_null(pointer, message, xtd::diagnostics::stack_frame::empty());}
1938 
1952  template<typename pointer_t>
1953  static void is_not_null(const std::weak_ptr<pointer_t>& pointer, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {assert::succeed(message, stack_frame);}
1954 
1962  static void is_not_null(std::nullptr_t pointer) {is_not_null(pointer, "", xtd::diagnostics::stack_frame::empty());}
1963 
1972  static void is_not_null(std::nullptr_t pointer, const xtd::diagnostics::stack_frame& stack_frame) {is_not_null(pointer, "", stack_frame);}
1973 
1982  static void is_not_null(std::nullptr_t pointer, const xtd::ustring& message) {is_not_null(pointer, message, xtd::diagnostics::stack_frame::empty());}
1983 
1993  static void is_not_null(std::nullptr_t pointer, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
1994  try {
1995  assert::is_not_null(pointer, message, stack_frame);
1996  } catch (...) {
1997  base_assert::error();
1998  }
1999  }
2000 
2010  template<typename value_t>
2011  static void is_not_zero(const value_t& value) {is_not_zero(value, "", xtd::diagnostics::stack_frame::empty());}
2012 
2023  template<typename value_t>
2024  static void is_not_zero(const value_t& value, const xtd::diagnostics::stack_frame& stack_frame) {is_not_zero(value, "", stack_frame);}
2025 
2036  template<typename value_t>
2037  static void is_not_zero(const value_t& value, const xtd::ustring& message) {is_not_zero(value, message, xtd::diagnostics::stack_frame::empty());}
2038 
2050  template<typename value_t>
2051  static void is_not_zero(const value_t& value, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
2052  try {
2053  assert::is_zero(value, message, stack_frame);
2054  } catch (...) {
2055  base_assert::error();
2056  }
2057  }
2058 
2069  template<typename pointer_t>
2070  static void is_null(const pointer_t* pointer) {is_null(pointer, "", xtd::diagnostics::stack_frame::empty());}
2071 
2083  template<typename pointer_t>
2084  static void is_null(const pointer_t* pointer, const xtd::diagnostics::stack_frame& stack_frame) {is_null(pointer, "", stack_frame);}
2085 
2097  template<typename pointer_t>
2098  static void is_null(const pointer_t* pointer, const xtd::ustring& message) {is_null(pointer, message, xtd::diagnostics::stack_frame::empty());}
2099 
2112  template<typename pointer_t>
2113  static void is_null(const pointer_t* pointer, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
2114  try {
2115  assert::is_null(pointer, message, stack_frame);
2116  } catch (...) {
2117  base_assert::error();
2118  }
2119  }
2120 
2130  template<typename pointer_t>
2131  static void is_null(const std::unique_ptr<pointer_t>& pointer) {is_null(pointer, "", xtd::diagnostics::stack_frame::empty());}
2132 
2143  template<typename pointer_t>
2144  static void is_null(const std::unique_ptr<pointer_t>& pointer, const xtd::diagnostics::stack_frame& stack_frame) {is_null(pointer, "", stack_frame);}
2145 
2156  template<typename pointer_t>
2157  static void is_null(const std::unique_ptr<pointer_t>& pointer, const xtd::ustring& message) {is_null(pointer, message, xtd::diagnostics::stack_frame::empty());}
2158 
2170  template<typename pointer_t>
2171  static void is_null(const std::unique_ptr<pointer_t>& pointer, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
2172  try {
2173  assert::is_null(pointer, message, stack_frame);
2174  } catch (...) {
2175  base_assert::error();
2176  }
2177  }
2178 
2188  template<typename pointer_t>
2189  static void is_null(const std::shared_ptr<pointer_t>& pointer) {is_null(pointer, "", xtd::diagnostics::stack_frame::empty());}
2190 
2201  template<typename pointer_t>
2202  static void is_null(const std::shared_ptr<pointer_t>& pointer, const xtd::diagnostics::stack_frame& stack_frame) {is_null(pointer, "", stack_frame);}
2203 
2214  template<typename pointer_t>
2215  static void is_null(const std::shared_ptr<pointer_t>& pointer, const xtd::ustring& message) {is_null(pointer, message, xtd::diagnostics::stack_frame::empty());}
2216 
2228  template<typename pointer_t>
2229  static void is_null(const std::shared_ptr<pointer_t>& pointer, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
2230  try {
2231  assert::is_null(pointer, message, stack_frame);
2232  } catch (...) {
2233  base_assert::error();
2234  }
2235  }
2236 
2248  template<typename pointer_t>
2249  static void is_null(const std::weak_ptr<pointer_t>& pointer) {is_null(pointer, "", xtd::diagnostics::stack_frame::empty());}
2250 
2263  template<typename pointer_t>
2264  static void is_null(const std::weak_ptr<pointer_t>& pointer, const xtd::diagnostics::stack_frame& stack_frame) {is_null(pointer, "", stack_frame);}
2265 
2278  template<typename pointer_t>
2279  static void is_null(const std::weak_ptr<pointer_t>& pointer, const xtd::ustring& message) {is_null(pointer, message, xtd::diagnostics::stack_frame::empty());}
2280 
2294  template<typename pointer_t>
2295  static void is_null(const std::weak_ptr<pointer_t>& pointer, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
2296  try {
2297  assert::is_null(pointer, message, stack_frame);
2298  } catch (...) {
2299  base_assert::error();
2300  }
2301  }
2302 
2310  static void is_null(std::nullptr_t pointer) {is_null(pointer, "", xtd::diagnostics::stack_frame::empty());}
2311 
2320  static void is_null(std::nullptr_t pointer, const xtd::diagnostics::stack_frame& stack_frame) {is_null(pointer, "", stack_frame);}
2321 
2330  static void is_null(std::nullptr_t pointer, const xtd::ustring& message) {is_null(pointer, message, xtd::diagnostics::stack_frame::empty());}
2331 
2341  static void is_null(std::nullptr_t pointer, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {assert::succeed(message, stack_frame);}
2342 
2352  template<typename value_t>
2353  static void is_positive(const value_t& value) {is_positive(value, "", xtd::diagnostics::stack_frame::empty());}
2354 
2365  template<typename value_t>
2366  static void is_positive(const value_t& value, const xtd::diagnostics::stack_frame& stack_frame) {is_positive(value, "", stack_frame);}
2367 
2378  template<typename value_t>
2379  static void is_positive(const value_t& value, const xtd::ustring& message) {is_positive(value, message, xtd::diagnostics::stack_frame::empty());}
2380 
2392  template<typename value_t>
2393  static void is_positive(const value_t& value, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
2394  try {
2395  assert::is_positive(value, message, stack_frame);
2396  } catch (...) {
2397  base_assert::error();
2398  }
2399  }
2400 
2410  static void is_true(bool condition) {is_true(condition, "", xtd::diagnostics::stack_frame::empty());}
2411 
2422  static void is_true(bool condition, const xtd::diagnostics::stack_frame& stack_frame) {is_true(condition, "", stack_frame);}
2423 
2434  static void is_true(bool condition, const xtd::ustring& message) {is_true(condition, message, xtd::diagnostics::stack_frame::empty());}
2435 
2447  static void is_true(bool condition, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
2448  try {
2449  assert::is_true(condition, message, stack_frame);
2450  } catch (...) {
2451  base_assert::error();
2452  }
2453  }
2454 
2464  template<typename value_t>
2465  static void is_zero(const value_t& value) {is_zero(value, "", xtd::diagnostics::stack_frame::empty());}
2466 
2477  template<typename value_t>
2478  static void is_zero(const value_t& value, const xtd::diagnostics::stack_frame& stack_frame) {is_zero(value, "", stack_frame);}
2479 
2490  template<typename value_t>
2491  static void is_zero(const value_t& value, const xtd::ustring& message) {is_zero(value, message, xtd::diagnostics::stack_frame::empty());}
2492 
2504  template<typename value_t>
2505  static void is_zero(const value_t& value, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
2506  try {
2507  assert::is_zero(value, message, stack_frame);
2508  } catch (...) {
2509  base_assert::error();
2510  }
2511  }
2512 
2522  template<typename exception_t>
2523  static void throws(const std::function<void()>& statement) {throws<exception_t>(statement, "", xtd::diagnostics::stack_frame::empty());}
2524 
2535  template<typename exception_t>
2536  static void throws(const std::function<void()>& statement, const xtd::diagnostics::stack_frame& stack_frame) {throws<exception_t>(statement, "", stack_frame);}
2537 
2548  template<typename exception_t>
2549  static void throws(const std::function<void()>& statement, const xtd::ustring& message) {throws<exception_t>(statement, message, xtd::diagnostics::stack_frame::empty());}
2550 
2562  template<typename exception_t>
2563  static void throws(const std::function<void()>& statement, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
2564  try {
2565  assert::throws<exception_t>(statement, message, stack_frame);
2566  } catch (...) {
2567  base_assert::error();
2568  }
2569  }
2570 
2579  static void throws_any(const std::function<void()>& statement) {throws_any(statement, "", xtd::diagnostics::stack_frame::empty());}
2580 
2590  static void throws_any(const std::function<void()>& statement, const xtd::diagnostics::stack_frame& stack_frame) {throws_any(statement, "", stack_frame);}
2591 
2601  static void throws_any(const std::function<void()>& statement, const xtd::ustring& message) {throws_any(statement, message, xtd::diagnostics::stack_frame::empty());}
2602 
2613  static void throws_any(const std::function<void()>& statement, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
2614  try {
2615  assert::throws_any(statement, message, stack_frame);
2616  } catch (...) {
2617  base_assert::error();
2618  }
2619  }
2620  };
2621  }
2622 }
assert.h
Contains xtd::tunit::assert class.
xtd::diagnostics::stack_frame
Provides information about a xtd::diagnostics::stack_frame, which represents a function call on the c...
Definition: stack_frame.h:29
xtd::diagnostics::stack_frame::empty
static stack_frame empty() noexcept
Return an empty stack frame.
xtd::tunit::assert::are_not_same
static void are_not_same(const expected_t &expected, const actual_t &actual)
Asserts that two objects do refer to differents objects.
Definition: assert.h:451
xtd::tunit::assert::are_same
static void are_same(const expected_t &expected, const actual_t &actual)
Asserts that two objects do refer to differents objects.
Definition: assert.h:520
xtd::tunit::assert::is_false
static void is_false(bool condition)
Asserts that ta condition is false.
Definition: assert.h:884
xtd::tunit::assert::is_less
static void is_less(const value1_t &val1, const value2_t &val2)
Asserts that the first value is is_less than the second value.
Definition: assert.h:1191
xtd::tunit::assert::is_greater_or_equal
static void is_greater_or_equal(const value1_t &val1, const value2_t &val2)
Asserts that the first value is greater than or equal to the second value.
Definition: assert.h:1036
xtd::tunit::assert::is_less_or_equal
static void is_less_or_equal(const value1_t &val1, const value2_t &val2)
Asserts that the first value is is_less than or equal to the second value.
Definition: assert.h:1287
xtd::tunit::assert::is_NaN
static void is_NaN(double value)
that a value is NaN.
Definition: assert.h:1384
xtd::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:2675
xtd::tunit::assert::is_negative
static void is_negative(const value_t &value)
Asserts that ta condition is negative.
Definition: assert.h:1556
xtd::tunit::assert::is_empty
static void is_empty(const value_t &value)
Asserts that collection contains an item.
Definition: assert.h:768
xtd::tunit::assert::is_true
static void is_true(bool condition)
Asserts that ta condition is true.
Definition: assert.h:2489
xtd::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:709
xtd::tunit::assert::is_not_empty
static void is_not_empty(const value_t &value)
Asserts that collection oes not contain any item.
Definition: assert.h:1617
xtd::tunit::assert::is_not_null
static void is_not_null(const pointer_t *pointer)
Asserts that the pointer is not null.
Definition: assert.h:1787
xtd::tunit::assert::is_positive
static void is_positive(const value_t &value)
Asserts that ta condition is positive.
Definition: assert.h:2429
xtd::tunit::assert::is_null
static void is_null(const pointer_t *pointer)
Asserts that the pointer is null.
Definition: assert.h:2139
xtd::tunit::assert::is_greater
static void is_greater(const value1_t &val1, const value2_t &val2)
Asserts that the first value is greater than the second value.
Definition: assert.h:941
xtd::tunit::assert::is_zero
static void is_zero(const value_t &value)
Asserts that ta condition is zero.
Definition: assert.h:2547
xtd::tunit::assert::are_equal
static void are_equal(const expected_t &expected, const actual_t &actual)
Asserts that two type are equal.
Definition: assert.h:50
xtd::tunit::assert::are_not_equal
static void are_not_equal(const expected_t &expected, const actual_t &actual)
Asserts that two type are not equal.
Definition: assert.h:354
xtd::tunit::assert::contains
static void contains(const item_t &item, const collection_t &collection)
Asserts that collection contains an item.
Definition: assert.h:587
xtd::tunit::base_assert
The base class for assert.
Definition: base_assert.h:25
xtd::tunit::base_assert::succeed
static void succeed()
Generates a success with a generic message. This is used by the other Assert functions.
Definition: base_assert.h:140
xtd::tunit::valid
The valid class contains a collection of static methods that implement the most common assertions use...
Definition: valid.h:20
xtd::tunit::valid::is_not_null
static void is_not_null(const std::weak_ptr< pointer_t > &pointer, const xtd::ustring &message, const xtd::diagnostics::stack_frame &stack_frame)
Validates that the pointer is not null.
Definition: valid.h:1953
xtd::tunit::valid::is_null
static void is_null(const std::shared_ptr< pointer_t > &pointer, const xtd::ustring &message, const xtd::diagnostics::stack_frame &stack_frame)
Validates that the pointer is null.
Definition: valid.h:2229
xtd::tunit::valid::is_not_null
static void is_not_null(const std::weak_ptr< pointer_t > &pointer, const xtd::diagnostics::stack_frame &stack_frame)
Validates that the pointer is not null.
Definition: valid.h:1922
xtd::tunit::valid::is_null
static void is_null(const std::unique_ptr< pointer_t > &pointer)
Validates that the pointer is null.
Definition: valid.h:2131
xtd::tunit::valid::is_not_null
static void is_not_null(const pointer_t *pointer, const xtd::ustring &message, const xtd::diagnostics::stack_frame &stack_frame)
Validates that the pointer is not null.
Definition: valid.h:1771
xtd::tunit::valid::are_equal
static void are_equal(float expected, float actual, float tolerance, const xtd::ustring &message, const xtd::diagnostics::stack_frame &stack_frame)
Validates that two type are equal.
Definition: valid.h:196
xtd::tunit::valid::are_equal
static void are_equal(long double expected, long double actual, long double tolerance, const xtd::diagnostics::stack_frame &stack_frame)
Validates that two type are equal.
Definition: valid.h:285
xtd::tunit::valid::is_NaN
static void is_NaN(double value, const xtd::diagnostics::stack_frame &stack_frame)
that a value is NaN.
Definition: valid.h:1349
xtd::tunit::valid::are_not_equal
static void are_not_equal(const expected_t &expected, const actual_t &actual, const xtd::ustring &message, const xtd::diagnostics::stack_frame &stack_frame)
Validates that two type are not equal.
Definition: valid.h:366
xtd::tunit::valid::are_equal
static void are_equal(float expected, float actual, float tolerance)
Validates that two type are equal.
Definition: valid.h:156
xtd::tunit::valid::is_null
static void is_null(const std::weak_ptr< pointer_t > &pointer, const xtd::diagnostics::stack_frame &stack_frame)
Validates that the pointer is null.
Definition: valid.h:2264
xtd::tunit::valid::is_not_null
static void is_not_null(const std::unique_ptr< pointer_t > &pointer, const xtd::diagnostics::stack_frame &stack_frame)
Validates that the pointer is not null.
Definition: valid.h:1802
xtd::tunit::valid::contains
static void contains(const item_t &item, const collection_t &collection, const xtd::ustring &message, const xtd::diagnostics::stack_frame &stack_frame)
Validates that collection contains an item.
Definition: valid.h:598
xtd::tunit::valid::is_null
static void is_null(const std::weak_ptr< pointer_t > &pointer, const xtd::ustring &message, const xtd::diagnostics::stack_frame &stack_frame)
Validates that the pointer is null.
Definition: valid.h:2295
xtd::tunit::valid::is_positive
static void is_positive(const value_t &value, const xtd::ustring &message)
Validates that ta condition is positive.
Definition: valid.h:2379
xtd::tunit::valid::throws_any
static void throws_any(const std::function< void()> &statement)
Validates that the statement does not throw an exception.
Definition: valid.h:2579
xtd::tunit::valid::is_NaN
static void is_NaN(float value, const xtd::diagnostics::stack_frame &stack_frame)
that a value is NaN.
Definition: valid.h:1457
xtd::tunit::valid::is_NaN
static void is_NaN(float value, const xtd::ustring &message, const xtd::diagnostics::stack_frame &stack_frame)
Validates that a value is NaN.
Definition: valid.h:1482
xtd::tunit::valid::is_not_null
static void is_not_null(const std::unique_ptr< pointer_t > &pointer, const xtd::ustring &message, const xtd::diagnostics::stack_frame &stack_frame)
Validates that the pointer is not null.
Definition: valid.h:1829
xtd::tunit::valid::is_not_zero
static void is_not_zero(const value_t &value, const xtd::ustring &message)
Validates that ta condition is not zero.
Definition: valid.h:2037
xtd::tunit::valid::is_null
static void is_null(std::nullptr_t pointer)
Validates that the pointer is null.
Definition: valid.h:2310
xtd::tunit::valid::is_null
static void is_null(const pointer_t *pointer)
Validates that the pointer is null.
Definition: valid.h:2070
xtd::tunit::valid::is_not_instance_of
static void is_not_instance_of(const value_t &value)
Validates that an object is not of the type supplied or a derived type.
Definition: valid.h:1672
xtd::tunit::valid::is_not_zero
static void is_not_zero(const value_t &value)
Validates that ta condition is not zero.
Definition: valid.h:2011
xtd::tunit::valid::are_equal
static void are_equal(float expected, float actual, float tolerance, const xtd::diagnostics::stack_frame &stack_frame)
Validates that two type are equal.
Definition: valid.h:169
xtd::tunit::valid::are_same
static void are_same(const expected_t &expected, const actual_t &actual, const xtd::ustring &message, const xtd::diagnostics::stack_frame &stack_frame)
Validates that two objects do refer to different objects.
Definition: valid.h:540
xtd::tunit::valid::is_null
static void is_null(const std::shared_ptr< pointer_t > &pointer, const xtd::ustring &message)
Validates that the pointer is null.
Definition: valid.h:2215
xtd::tunit::valid::is_less_or_equal
static void is_less_or_equal(const value1_t &val1, const value2_t &val2, const xtd::ustring &message)
Validates that the first value is is_less than or equal to the second value.
Definition: valid.h:1264
xtd::tunit::valid::are_same
static void are_same(const expected_t &expected, const actual_t &actual, const xtd::diagnostics::stack_frame &stack_frame)
Validates that two objects do refer to different objects.
Definition: valid.h:509
xtd::tunit::valid::is_not_zero
static void is_not_zero(const value_t &value, const xtd::ustring &message, const xtd::diagnostics::stack_frame &stack_frame)
Validates that ta condition is not zero.
Definition: valid.h:2051
xtd::tunit::valid::is_not_null
static void is_not_null(const std::shared_ptr< pointer_t > &pointer, const xtd::diagnostics::stack_frame &stack_frame)
Validates that the pointer is not null.
Definition: valid.h:1860
xtd::tunit::valid::is_empty
static void is_empty(const value_t &value, const xtd::ustring &message)
Validates that collection contains an item.
Definition: valid.h:749
xtd::tunit::valid::are_equal
static void are_equal(double expected, double actual, double tolerance, const xtd::ustring &message)
Validates that two type are equal.
Definition: valid.h:240
xtd::tunit::valid::is_positive
static void is_positive(const value_t &value, const xtd::diagnostics::stack_frame &stack_frame)
Validates that ta condition is positive.
Definition: valid.h:2366
xtd::tunit::valid::contains
static void contains(const item_t &item, const collection_t &collection)
Validates that collection contains an item.
Definition: valid.h:558
xtd::tunit::valid::is_not_empty
static void is_not_empty(const value_t &value, const xtd::ustring &message)
Validates that collection does not contain any item.
Definition: valid.h:1584
xtd::tunit::valid::is_zero
static void is_zero(const value_t &value, const xtd::diagnostics::stack_frame &stack_frame)
Validates that ta condition is zero.
Definition: valid.h:2478
xtd::tunit::valid::is_greater_or_equal
static void is_greater_or_equal(const value1_t &val1, const value2_t &val2, const xtd::ustring &message, const xtd::diagnostics::stack_frame &stack_frame)
Validates that the first value is greater than or equal to the second value.
Definition: valid.h:1028
xtd::tunit::valid::does_not_throw
static void does_not_throw(const std::function< void()> &statement, const xtd::ustring &message, const xtd::diagnostics::stack_frame &stack_frame)
Validates that the statement does not throw an exception.
Definition: valid.h:705
xtd::tunit::valid::is_not_null
static void is_not_null(const std::shared_ptr< pointer_t > &pointer, const xtd::ustring &message, const xtd::diagnostics::stack_frame &stack_frame)
Validates that the pointer is not null.
Definition: valid.h:1887
xtd::tunit::valid::is_null
static void is_null(const std::unique_ptr< pointer_t > &pointer, const xtd::ustring &message, const xtd::diagnostics::stack_frame &stack_frame)
Validates that the pointer is null.
Definition: valid.h:2171
xtd::tunit::valid::is_not_null
static void is_not_null(const std::shared_ptr< pointer_t > &pointer)
Validates that the pointer is not null.
Definition: valid.h:1847
xtd::tunit::valid::is_null
static void is_null(const pointer_t *pointer, const xtd::ustring &message, const xtd::diagnostics::stack_frame &stack_frame)
Validates that the pointer is null.
Definition: valid.h:2113
xtd::tunit::valid::is_less
static void is_less(const value1_t &val1, const value2_t &val2, const xtd::ustring &message, const xtd::diagnostics::stack_frame &stack_frame)
Validates that the first value is is_less than the second value.
Definition: valid.h:1178
xtd::tunit::valid::is_not_null
static void is_not_null(const std::weak_ptr< pointer_t > &pointer)
Validates that the pointer is not null.
Definition: valid.h:1907
xtd::tunit::valid::is_null
static void is_null(const std::unique_ptr< pointer_t > &pointer, const xtd::ustring &message)
Validates that the pointer is null.
Definition: valid.h:2157
xtd::tunit::valid::is_less_or_equal
static void is_less_or_equal(const value1_t &val1, const value2_t &val2)
Validates that the first value is is_less than or equal to the second value.
Definition: valid.h:1238
xtd::tunit::valid::is_true
static void is_true(bool condition, const xtd::ustring &message)
Validates that a condition is true.
Definition: valid.h:2434
xtd::tunit::valid::is_not_empty
static void is_not_empty(const value_t &value)
Validates that collection oes not contain any item.
Definition: valid.h:1558
xtd::tunit::valid::is_less_or_equal
static void is_less_or_equal(const value1_t &val1, const value2_t &val2, const xtd::ustring &message, const xtd::diagnostics::stack_frame &stack_frame)
Validates that the first value is is_less than or equal to the second value.
Definition: valid.h:1278
xtd::tunit::valid::are_equal
static void are_equal(const expected_t &expected, const actual_t &actual)
Validates that two type are equal.
Definition: valid.h:35
xtd::tunit::valid::does_not_throw
static void does_not_throw(const std::function< void()> &statement, const xtd::diagnostics::stack_frame &stack_frame)
Validates that the statement does not throw an exception.
Definition: valid.h:682
xtd::tunit::valid::are_equal
static void are_equal(double expected, double actual, double tolerance, const xtd::diagnostics::stack_frame &stack_frame)
Validates that two type are equal.
Definition: valid.h:227
xtd::tunit::valid::is_null
static void is_null(const std::weak_ptr< pointer_t > &pointer, const xtd::ustring &message)
Validates that the pointer is null.
Definition: valid.h:2279
xtd::tunit::valid::is_NaN
static void is_NaN(long double value, const xtd::ustring &message)
Validates that a value is NaN.
Definition: valid.h:1415
xtd::tunit::valid::is_not_null
static void is_not_null(std::nullptr_t pointer, const xtd::ustring &message)
Validates that the pointer is not null.
Definition: valid.h:1982
xtd::tunit::valid::is_not_null
static void is_not_null(const pointer_t *pointer, const xtd::diagnostics::stack_frame &stack_frame)
Validates that the pointer is not null.
Definition: valid.h:1742
xtd::tunit::valid::is_NaN
static void is_NaN(long double value, const xtd::ustring &message, const xtd::diagnostics::stack_frame &stack_frame)
Validates that a value is NaN.
Definition: valid.h:1428
xtd::tunit::valid::are_equal
static void are_equal(double expected, double actual, double tolerance, const xtd::ustring &message, const xtd::diagnostics::stack_frame &stack_frame)
Validates that two type are equal.
Definition: valid.h:254
xtd::tunit::valid::is_less
static void is_less(const value1_t &val1, const value2_t &val2, const xtd::diagnostics::stack_frame &stack_frame)
Validates that the first value is is_less than the second value.
Definition: valid.h:1153
xtd::tunit::valid::is_not_empty
static void is_not_empty(const value_t &value, const xtd::ustring &message, const xtd::diagnostics::stack_frame &stack_frame)
Validates that collection does not contain any item.
Definition: valid.h:1598
xtd::tunit::valid::is_null
static void is_null(const std::weak_ptr< pointer_t > &pointer)
Validates that the pointer is null.
Definition: valid.h:2249
xtd::tunit::valid::are_not_equal
static void are_not_equal(const expected_t &expected, const actual_t &actual)
Validates that two type are not equal.
Definition: valid.h:329
xtd::tunit::valid::is_greater_or_equal
static void is_greater_or_equal(const value1_t &val1, const value2_t &val2, const xtd::ustring &message)
Validates that the first value is greater than or equal to the second value.
Definition: valid.h:1014
xtd::tunit::valid::is_greater_or_equal
static void is_greater_or_equal(const value1_t &val1, const value2_t &val2)
Validates that the first value is greater than or equal to the second value.
Definition: valid.h:988
xtd::tunit::valid::are_equal
static void are_equal(long double expected, long double actual, long double tolerance, const xtd::ustring &message, const xtd::diagnostics::stack_frame &stack_frame)
Validates that two type are equal.
Definition: valid.h:312
xtd::tunit::valid::is_not_empty
static void is_not_empty(const value_t &value, const xtd::diagnostics::stack_frame &stack_frame)
Validates that collection does not contain any item.
Definition: valid.h:1571
xtd::tunit::valid::is_true
static void is_true(bool condition)
Validates that ta condition is true.
Definition: valid.h:2410
xtd::tunit::valid::contains
static void contains(const item_t &item, const collection_t &collection, const xtd::diagnostics::stack_frame &stack_frame)
Validates that collection contains an item.
Definition: valid.h:571
xtd::tunit::valid::are_not_same
static void are_not_same(const expected_t &expected, const actual_t &actual, const xtd::ustring &message)
Validates that two objects do refer to different objects.
Definition: valid.h:458
xtd::tunit::valid::is_NaN
static void is_NaN(float value)
that a value is NaN.
Definition: valid.h:1445
xtd::tunit::valid::contains
static void contains(const item_t &item, const collection_t &collection, const xtd::ustring &message)
Validates that collection contains an item.
Definition: valid.h:584
xtd::tunit::valid::are_not_same
static void are_not_same(const expected_t &expected, const actual_t &actual, const xtd::ustring &message, const xtd::diagnostics::stack_frame &stack_frame)
Validates that two objects do refer to different objects.
Definition: valid.h:474
xtd::tunit::valid::is_instance_of
static void is_instance_of(const value_t &value, const xtd::ustring &message)
Validates that an object is of the type supplied or a derived type.
Definition: valid.h:1111
xtd::tunit::valid::is_zero
static void is_zero(const value_t &value)
Validates that ta condition is zero.
Definition: valid.h:2465
xtd::tunit::valid::are_equal
static void are_equal(const expected_t &expected, const actual_t &actual, const xtd::ustring &message, const xtd::diagnostics::stack_frame &stack_frame)
Validates that two type are equal.
Definition: valid.h:72
xtd::tunit::valid::are_equal
static void are_equal(double expected, double actual, double tolerance)
Validates that two type are equal.
Definition: valid.h:214
xtd::tunit::valid::is_negative
static void is_negative(const value_t &value, const xtd::ustring &message)
Validates that ta condition is negative.
Definition: valid.h:1526
xtd::tunit::valid::is_greater_or_equal
static void is_greater_or_equal(const value1_t &val1, const value2_t &val2, const xtd::diagnostics::stack_frame &stack_frame)
Validates that the first value is greater than or equal to the second value.
Definition: valid.h:1001
xtd::tunit::valid::is_negative
static void is_negative(const value_t &value, const xtd::diagnostics::stack_frame &stack_frame)
Validates that ta condition is negative.
Definition: valid.h:1513
xtd::tunit::valid::is_NaN
static void is_NaN(double value, const xtd::ustring &message, const xtd::diagnostics::stack_frame &stack_frame)
Validates that a value is NaN.
Definition: valid.h:1374
xtd::tunit::valid::is_not_null
static void is_not_null(std::nullptr_t pointer, const xtd::diagnostics::stack_frame &stack_frame)
Validates that the pointer is not null.
Definition: valid.h:1972
xtd::tunit::valid::is_null
static void is_null(const std::shared_ptr< pointer_t > &pointer)
Validates that the pointer is null.
Definition: valid.h:2189
xtd::tunit::valid::is_not_null
static void is_not_null(const pointer_t *pointer, const xtd::ustring &message)
Validates that the pointer is not null.
Definition: valid.h:1756
xtd::tunit::valid::is_less
static void is_less(const value1_t &val1, const value2_t &val2)
Validates that the first value is is_less than the second value.
Definition: valid.h:1141
xtd::tunit::valid::is_not_instance_of
static void is_not_instance_of(const value_t &value, const xtd::ustring &message, const xtd::diagnostics::stack_frame &stack_frame)
Validates that an object is not of the type supplied or a derived type.
Definition: valid.h:1709
xtd::tunit::valid::are_same
static void are_same(const expected_t &expected, const actual_t &actual, const xtd::ustring &message)
Validates that two objects do refer to different objects.
Definition: valid.h:524
xtd::tunit::valid::is_zero
static void is_zero(const value_t &value, const xtd::ustring &message)
Validates that ta condition is zero.
Definition: valid.h:2491
xtd::tunit::valid::is_NaN
static void is_NaN(long double value)
that a value is NaN.
Definition: valid.h:1391
xtd::tunit::valid::throws_any
static void throws_any(const std::function< void()> &statement, const xtd::ustring &message)
Validates that the statement does not throw an exception.
Definition: valid.h:2601
xtd::tunit::valid::is_null
static void is_null(const pointer_t *pointer, const xtd::diagnostics::stack_frame &stack_frame)
Validates that the pointer is null.
Definition: valid.h:2084
xtd::tunit::valid::is_positive
static void is_positive(const value_t &value)
Validates that ta condition is positive.
Definition: valid.h:2353
xtd::tunit::valid::is_true
static void is_true(bool condition, const xtd::diagnostics::stack_frame &stack_frame)
Validates that a condition is true.
Definition: valid.h:2422
xtd::tunit::valid::throws_any
static void throws_any(const std::function< void()> &statement, const xtd::ustring &message, const xtd::diagnostics::stack_frame &stack_frame)
Validates that the statement does not throw an exception.
Definition: valid.h:2613
xtd::tunit::valid::is_empty
static void is_empty(const value_t &value, const xtd::diagnostics::stack_frame &stack_frame)
Validates that collection contains an item.
Definition: valid.h:736
xtd::tunit::valid::is_less_or_equal
static void is_less_or_equal(const value1_t &val1, const value2_t &val2, const xtd::diagnostics::stack_frame &stack_frame)
Validates that the first value is is_less than or equal to the second value.
Definition: valid.h:1251
xtd::tunit::valid::are_not_equal
static void are_not_equal(const expected_t &expected, const actual_t &actual, const xtd::ustring &message)
Validates that two type are not equal.
Definition: valid.h:353
xtd::tunit::valid::is_instance_of
static void is_instance_of(const value_t &value, const xtd::diagnostics::stack_frame &stack_frame)
Validates that an object is of the type supplied or a derived type.
Definition: valid.h:1099
xtd::tunit::valid::is_true
static void is_true(bool condition, const xtd::ustring &message, const xtd::diagnostics::stack_frame &stack_frame)
Validates that a condition is true.
Definition: valid.h:2447
xtd::tunit::valid::is_not_instance_of
static void is_not_instance_of(const value_t &value, const xtd::diagnostics::stack_frame &stack_frame)
Validates that an object is not of the type supplied or a derived type.
Definition: valid.h:1684
xtd::tunit::valid::is_not_null
static void is_not_null(const std::weak_ptr< pointer_t > &pointer, const xtd::ustring &message)
Validates that the pointer is not null.
Definition: valid.h:1937
xtd::tunit::valid::is_empty
static void is_empty(const value_t &value)
Validates that collection contains an item.
Definition: valid.h:723
xtd::tunit::valid::does_not_throw
static void does_not_throw(const std::function< void()> &statement, const xtd::ustring &message)
Validates that the statement does not throw an exception.
Definition: valid.h:693
xtd::tunit::valid::is_not_null
static void is_not_null(const std::unique_ptr< pointer_t > &pointer)
Validates that the pointer is not null.
Definition: valid.h:1789
xtd::tunit::valid::is_positive
static void is_positive(const value_t &value, const xtd::ustring &message, const xtd::diagnostics::stack_frame &stack_frame)
Validates that ta condition is positive.
Definition: valid.h:2393
xtd::tunit::valid::are_not_same
static void are_not_same(const expected_t &expected, const actual_t &actual, const xtd::diagnostics::stack_frame &stack_frame)
Validates that two objects do refer to different objects.
Definition: valid.h:443
xtd::tunit::valid::are_equal
static void are_equal(long double expected, long double actual, long double tolerance, const xtd::ustring &message)
Validates that two type are equal.
Definition: valid.h:298
xtd::tunit::valid::is_empty
static void is_empty(const value_t &value, const xtd::ustring &message, const xtd::diagnostics::stack_frame &stack_frame)
Validates that collection contains an item.
Definition: valid.h:763
xtd::tunit::valid::are_equal
static void are_equal(const expected_t &expected, const actual_t &actual, const xtd::ustring &message)
Validates that two type are equal.
Definition: valid.h:59
xtd::tunit::valid::are_not_equal
static void are_not_equal(const expected_t &expected, const actual_t &actual, const xtd::diagnostics::stack_frame &stack_frame)
Validates that two type are not equal.
Definition: valid.h:341
xtd::tunit::valid::is_instance_of
static void is_instance_of(const value_t &value, const xtd::ustring &message, const xtd::diagnostics::stack_frame &stack_frame)
Validates that an object is of the type supplied or a derived type.
Definition: valid.h:1124
xtd::tunit::valid::is_less
static void is_less(const value1_t &val1, const value2_t &val2, const xtd::ustring &message)
Validates that the first value is is_less than the second value.
Definition: valid.h:1165
xtd::tunit::valid::are_equal
static void are_equal(float expected, float &actual, float tolerance, const xtd::ustring &message)
Validates that two type are equal.
Definition: valid.h:182
xtd::tunit::valid::is_null
static void is_null(std::nullptr_t pointer, const xtd::ustring &message, const xtd::diagnostics::stack_frame &stack_frame)
Validates that the pointer is null.
Definition: valid.h:2341
xtd::tunit::valid::is_instance_of
static void is_instance_of(const value_t &value)
Validates that an object is of the type supplied or a derived type.
Definition: valid.h:1087
xtd::tunit::valid::is_null
static void is_null(const std::shared_ptr< pointer_t > &pointer, const xtd::diagnostics::stack_frame &stack_frame)
Validates that the pointer is null.
Definition: valid.h:2202
xtd::tunit::valid::is_not_instance_of
static void is_not_instance_of(const value_t &value, const xtd::ustring &message)
Validates that an object is not of the type supplied or a derived type.
Definition: valid.h:1696
xtd::tunit::valid::is_null
static void is_null(std::nullptr_t pointer, const xtd::diagnostics::stack_frame &stack_frame)
Validates that the pointer is null.
Definition: valid.h:2320
xtd::tunit::valid::is_NaN
static void is_NaN(double value, const xtd::ustring &message)
Validates that a value is NaN.
Definition: valid.h:1361
xtd::tunit::valid::is_not_null
static void is_not_null(std::nullptr_t pointer, const xtd::ustring &message, const xtd::diagnostics::stack_frame &stack_frame)
Validates that the pointer is not null.
Definition: valid.h:1993
xtd::tunit::valid::are_not_same
static void are_not_same(const expected_t &expected, const actual_t &actual)
Validates that two objects do refer to different objects.
Definition: valid.h:428
xtd::tunit::valid::does_not_throw
static void does_not_throw(const std::function< void()> &statement)
Validates that the statement does not throw an exception.
Definition: valid.h:671
xtd::tunit::valid::are_equal
static void are_equal(const expected_t &expected, const actual_t &actual, const xtd::diagnostics::stack_frame &stack_frame)
Validates that two type are equal.
Definition: valid.h:47
xtd::tunit::valid::are_equal
static void are_equal(long double expected, long double actual, long double tolerance)
Validates that two type are equal.
Definition: valid.h:272
xtd::tunit::valid::is_not_zero
static void is_not_zero(const value_t &value, const xtd::diagnostics::stack_frame &stack_frame)
Validates that ta condition is not zero.
Definition: valid.h:2024
xtd::tunit::valid::throws_any
static void throws_any(const std::function< void()> &statement, const xtd::diagnostics::stack_frame &stack_frame)
Validates that the statement does not throw an exception.
Definition: valid.h:2590
xtd::tunit::valid::are_same
static void are_same(const expected_t &expected, const actual_t &actual)
Validates that two objects do refer to different objects.
Definition: valid.h:494
xtd::tunit::valid::is_not_null
static void is_not_null(std::nullptr_t pointer)
Validates that the pointer is not null.
Definition: valid.h:1962
xtd::tunit::valid::is_negative
static void is_negative(const value_t &value)
Validates that ta condition is negative.
Definition: valid.h:1500
xtd::tunit::valid::is_not_null
static void is_not_null(const pointer_t *pointer)
Validates that the pointer is not null.
Definition: valid.h:1728
xtd::tunit::valid::is_not_null
static void is_not_null(const std::shared_ptr< pointer_t > &pointer, const xtd::ustring &message)
Validates that the pointer is not null.
Definition: valid.h:1873
xtd::tunit::valid::is_null
static void is_null(const std::unique_ptr< pointer_t > &pointer, const xtd::diagnostics::stack_frame &stack_frame)
Validates that the pointer is null.
Definition: valid.h:2144
xtd::tunit::valid::is_not_null
static void is_not_null(const std::unique_ptr< pointer_t > &pointer, const xtd::ustring &message)
Validates that the pointer is not null.
Definition: valid.h:1815
xtd::tunit::valid::is_zero
static void is_zero(const value_t &value, const xtd::ustring &message, const xtd::diagnostics::stack_frame &stack_frame)
Validates that ta condition is zero.
Definition: valid.h:2505
xtd::tunit::valid::is_negative
static void is_negative(const value_t &value, const xtd::ustring &message, const xtd::diagnostics::stack_frame &stack_frame)
Validates that ta condition is negative.
Definition: valid.h:1540
xtd::tunit::valid::is_null
static void is_null(const pointer_t *pointer, const xtd::ustring &message)
Validates that the pointer is null.
Definition: valid.h:2098
xtd::tunit::valid::is_null
static void is_null(std::nullptr_t pointer, const xtd::ustring &message)
Validates that the pointer is null.
Definition: valid.h:2330
xtd::tunit::valid::is_NaN
static void is_NaN(float value, const xtd::ustring &message)
Validates that a value is NaN.
Definition: valid.h:1469
xtd::tunit::valid::is_NaN
static void is_NaN(double value)
that a value is NaN.
Definition: valid.h:1337
xtd::tunit::valid::is_NaN
static void is_NaN(long double value, const xtd::diagnostics::stack_frame &stack_frame)
that a value is NaN.
Definition: valid.h:1403
xtd::ustring
Represents text as a sequence of UTF-8 code units.
Definition: ustring.h:48
csf_
#define csf_
Provides information about the current stack frame.
Definition: stack_frame.h:213
xtd
The xtd namespace contains all fundamental classes to access Hardware, Os, System,...
Definition: system_report.h:17
Generated on Mon Jul 17 2023 23:13:06 for xtd - Reference Guide by Gammasoft. All rights reserved.