xtd - Reference Guide  0.1.0
Modern c++17/20 framework to create console, GUI and unit test applications on Windows, macOS, Linux, iOS and android.
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Modules Pages
valid.h
Go to the documentation of this file.
1
4#pragma once
5#include "assert.h"
6
8namespace 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 Sat Jan 28 2023 18:12:26 for xtd - Reference Guide by Gammasoft. All rights reserved.