xtd 0.2.0
Loading...
Searching...
No Matches
collection_assert.h
Go to the documentation of this file.
1
4#pragma once
5#include "assert.h"
6
8namespace xtd {
10 namespace tunit {
23 class tunit_export_ collection_assert final : private base_assert {
24 public:
26 collection_assert() = delete;
28
30
43 template<typename expected_t, typename collection_t>
44 static void all_items_are_instances_of(const collection_t& collection) {all_items_are_instances_of<expected_t>(collection, "", xtd::diagnostics::stack_frame::empty());}
56 template<typename expected_t, typename collection_t>
57 static void all_items_are_instances_of(const collection_t& collection, const std::string& message) {all_items_are_instances_of<expected_t>(collection, message, xtd::diagnostics::stack_frame::empty());}
69 template<typename expected_t, typename collection_t>
70 static void all_items_are_instances_of(const collection_t& collection, const xtd::diagnostics::stack_frame& stack_frame) {all_items_are_instances_of<expected_t>(collection, "", stack_frame);}
82 template<typename expected_t, typename collection_t>
83 static void all_items_are_instances_of(const collection_t& collection, const std::string& message, const xtd::diagnostics::stack_frame& stack_frame) {
84 for (auto item : collection)
85 if (dynamic_cast<expected_t>(item) == nullptr) {
86 fail("all items instance of <" + typeof_<expected_t>().full_name() + ">", join_items(collection), message, stack_frame);
87 return;
88 }
89 assert::succeed(message, stack_frame);
90 }
91
93 template<typename expected_t, typename item_t>
94 static void all_items_are_instances_of(const std::initializer_list<item_t>& collection) {all_items_are_instances_of<expected_t>(collection, "", xtd::diagnostics::stack_frame::empty());}
95 template<typename expected_t, typename item_t>
96 static void all_items_are_instances_of(const std::initializer_list<item_t>& collection, const std::string& message) {all_items_are_instances_of<expected_t>(collection, message, xtd::diagnostics::stack_frame::empty());}
97 template<typename expected_t, typename item_t>
98 static void all_items_are_instances_of(const std::initializer_list<item_t>& collection, const xtd::diagnostics::stack_frame& stack_frame) {all_items_are_instances_of<expected_t>(collection, "", stack_frame);}
99 template<typename expected_t, typename item_t>
100 static void all_items_are_instances_of(const std::initializer_list<item_t>& collection, const std::string& message, const xtd::diagnostics::stack_frame& stack_frame) {
101 for (auto item : collection)
102 if (dynamic_cast<expected_t>(item) == nullptr) {
103 fail("all items instance of <" + typeof_<expected_t>().full_name() + ">", join_items(collection), message, stack_frame);
104 return;
105 }
106 assert::succeed(message, stack_frame);
107 }
109
123 template<typename collection_t>
124 static void all_items_are_not_null(const collection_t& collection) {all_items_are_not_null(collection, "", xtd::diagnostics::stack_frame::empty());}
138 template<typename collection_t>
139 static void all_items_are_not_null(const collection_t& collection, const std::string& message) {all_items_are_not_null(collection, message, xtd::diagnostics::stack_frame::empty());}
153 template<typename collection_t>
154 static void all_items_are_not_null(const collection_t& collection, const xtd::diagnostics::stack_frame& stack_frame) {all_items_are_instances_of(collection, "", stack_frame);}
168 template<typename collection_t>
169 static void all_items_are_not_null(const collection_t& collection, const std::string& message, const xtd::diagnostics::stack_frame& stack_frame) {
170 for (auto item : collection)
171 if (item == nullptr) {
172 fail("all items are not null", join_items(collection), message, stack_frame);
173 return;
174 }
175 assert::succeed(message, stack_frame);
176 }
177
179 template<typename item_t>
180 static void all_items_are_not_null(const std::initializer_list<item_t>& collection) {all_items_are_not_null(collection, "", xtd::diagnostics::stack_frame::empty());}
181 template<typename item_t>
182 static void all_items_are_not_null(const std::initializer_list<item_t>& collection, const std::string& message) {all_items_are_not_null(collection, message, xtd::diagnostics::stack_frame::empty());}
183 template<typename item_t>
184 static void all_items_are_not_null(const std::initializer_list<item_t>& collection, const xtd::diagnostics::stack_frame& stack_frame) {all_items_are_instances_of(collection, "", stack_frame);}
185 template<typename item_t>
186 static void all_items_are_not_null(const std::initializer_list<item_t>& collection, const std::string& message, const xtd::diagnostics::stack_frame& stack_frame) {
187 for (auto item : collection)
188 if (item == nullptr) {
189 fail("all items are not null", join_items(collection), message, stack_frame);
190 return;
191 }
192 assert::succeed(message, stack_frame);
193 }
195
208 template<typename collection_t>
209 static void all_items_are_unique(const collection_t& collection) {all_items_are_unique(collection, "", xtd::diagnostics::stack_frame::empty());}
222 template<typename collection_t>
223 static void all_items_are_unique(const collection_t& collection, const std::string& message) {all_items_are_unique(collection, message, xtd::diagnostics::stack_frame::empty());}
236 template<typename collection_t>
237 static void all_items_are_unique(const collection_t& collection, const xtd::diagnostics::stack_frame& stack_frame) {all_items_are_unique(collection, "", stack_frame);}
250 template<typename collection_t>
251 static void all_items_are_unique(const collection_t& collection, const std::string& message, const xtd::diagnostics::stack_frame& stack_frame) {
252 auto value = *collection.cbegin();
253 std::map<decltype(value), int32> counts;
254 for (auto item : collection) {
255 auto result = counts.emplace(item, 1);
256 if (result.second == false)
257 fail("all items are unique", join_items(collection), message, stack_frame);
258 }
259 assert::succeed(message, stack_frame);
260 }
261
263 template<typename item_t>
264 static void all_items_are_unique(const std::initializer_list<item_t>& collection) {all_items_are_unique(collection, "", xtd::diagnostics::stack_frame::empty());}
265 template<typename item_t>
266 static void all_items_are_unique(const std::initializer_list<item_t>& collection, const xtd::diagnostics::stack_frame& stack_frame) {all_items_are_unique(collection, "", stack_frame);}
267 template<typename item_t>
268 static void all_items_are_unique(const std::initializer_list<item_t>& collection, const std::string& message) {all_items_are_unique(collection, message, xtd::diagnostics::stack_frame::empty());}
269 template<typename item_t>
270 static void all_items_are_unique(const std::initializer_list<item_t>& collection, const std::string& message, const xtd::diagnostics::stack_frame& stack_frame) {
271 std::map<item_t, int32> counts;
272 for (auto item : collection) {
273 auto result = counts.emplace(item, 1);
274 if (result.second == false)
275 fail("all items are unique", join_items(collection), message, stack_frame);
276 }
277 assert::succeed(message, stack_frame);
278 }
280
292 template<typename expected_t, typename actual_t>
293 static void are_equal(const expected_t& expected, const actual_t& actual) {are_equal(expected, actual, "", xtd::diagnostics::stack_frame::empty());}
305 template<typename expected_t, typename actual_t>
306 static void are_equal(const expected_t& expected, const actual_t& actual, const std::string& message) {are_equal(expected, actual, message, xtd::diagnostics::stack_frame::empty());}
318 template<typename expected_t, typename actual_t>
319 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);}
331 template<typename expected_t, typename actual_t>
332 static void are_equal(const expected_t& expected, const actual_t& actual, const std::string& message, const xtd::diagnostics::stack_frame& stack_frame) {
333 if (std::equal(actual.begin(), actual.end(), expected.begin(), expected.end()) == false)
334 fail(join_items(expected), join_items(actual), message, stack_frame);
335 else
336 assert::succeed(message, stack_frame);
337 }
338
340 template<typename item_t>
341 static void are_equal(const std::initializer_list<item_t>& expected, const std::initializer_list<item_t>& actual) {are_equal(expected, actual, "", xtd::diagnostics::stack_frame::empty());}
342 template<typename item_t>
343 static void are_equal(const std::initializer_list<item_t>& expected, const std::initializer_list<item_t>& actual, const xtd::diagnostics::stack_frame& stack_frame) {are_equal(expected, actual, "", stack_frame);}
344 template<typename item_t>
345 static void are_equal(const std::initializer_list<item_t>& expected, const std::initializer_list<item_t>& actual, const std::string& message) {are_equal(expected, actual, message, xtd::diagnostics::stack_frame::empty());}
346 template<typename item_t>
347 static void are_equal(const std::initializer_list<item_t>& expected, const std::initializer_list<item_t>& actual, const std::string& message, const xtd::diagnostics::stack_frame& stack_frame) {
348 if (std::equal(actual.begin(), actual.end(), expected.begin(), expected.end()) == false)
349 fail(join_items(expected), join_items(actual), message, stack_frame);
350 else
351 assert::succeed(message, stack_frame);
352 }
353 template<typename collection_t, typename item_t>
354 static void are_equal(const collection_t& expected, const std::initializer_list<item_t>& actual) {are_equal(expected, actual, "", xtd::diagnostics::stack_frame::empty());}
355 template<typename collection_t, typename item_t>
356 static void are_equal(const collection_t& expected, const std::initializer_list<item_t>& actual, const xtd::diagnostics::stack_frame& stack_frame) {are_equal(expected, actual, "", stack_frame);}
357 template<typename collection_t, typename item_t>
358 static void are_equal(const collection_t& expected, const std::initializer_list<item_t>& actual, const std::string& message) {are_equal(expected, actual, message, xtd::diagnostics::stack_frame::empty());}
359 template<typename collection_t, typename item_t>
360 static void are_equal(const collection_t& expected, const std::initializer_list<item_t>& actual, const std::string& message, const xtd::diagnostics::stack_frame& stack_frame) {
361 if (std::equal(actual.begin(), actual.end(), expected.begin(), expected.end()) == false)
362 fail(join_items(expected), join_items(actual), message, stack_frame);
363 else
364 assert::succeed(message, stack_frame);
365 }
366 template<typename item_t, typename collection_t>
367 static void are_equal(const std::initializer_list<item_t>& expected, const collection_t& actual) {are_equal(expected, actual, "", xtd::diagnostics::stack_frame::empty());}
368 template<typename item_t, typename collection_t>
369 static void are_equal(const std::initializer_list<item_t>& expected, const collection_t& actual, const xtd::diagnostics::stack_frame& stack_frame) {are_equal(expected, actual, "", stack_frame);}
370 template<typename item_t, typename collection_t>
371 static void are_equal(const std::initializer_list<item_t>& expected, const collection_t& actual, const std::string& message) {are_equal(expected, actual, message, xtd::diagnostics::stack_frame::empty());}
372 template<typename item_t, typename collection_t>
373 static void are_equal(const std::initializer_list<item_t>& expected, const collection_t& actual, const std::string& message, const xtd::diagnostics::stack_frame& stack_frame) {
374 if (std::equal(actual.begin(), actual.end(), expected.begin(), expected.end()) == false)
375 fail(join_items(expected), join_items(actual), message, stack_frame);
376 else
377 assert::succeed(message, stack_frame);
378 }
380
392 template<typename expected_t, typename actual_t>
393 static void are_equivalent(const expected_t& expected, const actual_t& actual) {are_equivalent(expected, actual, "", xtd::diagnostics::stack_frame::empty());}
405 template<typename expected_t, typename actual_t>
406 static void are_equivalent(const expected_t& expected, const actual_t& actual, const std::string& message) {are_equivalent(expected, actual, message, xtd::diagnostics::stack_frame::empty());}
418 template<typename expected_t, typename actual_t>
419 static void are_equivalent(const expected_t& expected, const actual_t& actual, const xtd::diagnostics::stack_frame& stack_frame) {are_equivalent(expected, actual, "", stack_frame);}
431 template<typename expected_t, typename actual_t>
432 static void are_equivalent(const expected_t& expected, const actual_t& actual, const std::string& message, const xtd::diagnostics::stack_frame& stack_frame) {
433 expected_t expect_sorted = expected;
434 std::sort(expect_sorted.begin(), expect_sorted.end());
435 expected_t actual_sorted = actual;
436 std::sort(actual_sorted.begin(), actual_sorted.end());
437 if (std::equal(actual_sorted.begin(), actual_sorted.end(), expect_sorted.begin(), expect_sorted.end()) == false)
438 fail("equivalent " + join_items(expected), join_items(actual), message, stack_frame);
439 else
440 assert::succeed(message, stack_frame);
441 }
442
444 template<typename expected_t, typename actual_t>
445 static void are_equivalent(const std::initializer_list<expected_t>& expected, const std::initializer_list<actual_t>& actual) {are_equivalent(expected, actual, "", xtd::diagnostics::stack_frame::empty());}
446 template<typename expected_t, typename actual_t>
447 static void are_equivalent(const std::initializer_list<expected_t>& expected, const std::initializer_list<actual_t>& actual, const xtd::diagnostics::stack_frame& stack_frame) {are_equivalent(expected, actual, "", stack_frame);}
448 template<typename expected_t, typename actual_t>
449 static void are_equivalent(const std::initializer_list<expected_t>& expected, const std::initializer_list<actual_t>& actual, const std::string& message) {are_equal(are_equivalent, actual, message, xtd::diagnostics::stack_frame::empty());}
450 template<typename expected_t, typename actual_t>
451 static void are_equivalent(const std::initializer_list<expected_t>& expected, const std::initializer_list<actual_t>& actual, const std::string& message, const xtd::diagnostics::stack_frame& stack_frame) {
452 std::vector<expected_t> expect_sorted = expected;
453 std::sort(expect_sorted.begin(), expect_sorted.end());
454 std::vector<actual_t> actual_sorted = actual;
455 std::sort(actual_sorted.begin(), actual_sorted.end());
456 if (std::equal(actual_sorted.begin(), actual_sorted.end(), expect_sorted.begin(), expect_sorted.end()) == false)
457 fail("equivalent " + join_items(expected), join_items(actual), message, stack_frame);
458 else
459 assert::succeed(message, stack_frame);
460 }
461 template<typename collection_t, typename item_t>
462 static void are_equivalent(const collection_t& expected, const std::initializer_list<item_t>& actual) {are_equivalent(expected, actual, "", xtd::diagnostics::stack_frame::empty());}
463 template<typename collection_t, typename item_t>
464 static void are_equivalent(const collection_t& expected, const std::initializer_list<item_t>& actual, const xtd::diagnostics::stack_frame& stack_frame) {are_equivalent(expected, actual, "", stack_frame);}
465 template<typename collection_t, typename item_t>
466 static void are_equivalent(const collection_t& expected, const std::initializer_list<item_t>& actual, const std::string& message) {are_equivalent(expected, actual, message, xtd::diagnostics::stack_frame::empty());}
467 template<typename collection_t, typename item_t>
468 static void are_equivalent(const collection_t& expected, const std::initializer_list<item_t>& actual, const std::string& message, const xtd::diagnostics::stack_frame& stack_frame) {
469 collection_t expect_sorted = expected;
470 std::sort(expect_sorted.begin(), expect_sorted.end());
471 std::vector<item_t> actual_sorted = actual;
472 std::sort(actual_sorted.begin(), actual_sorted.end());
473 if (std::equal(actual_sorted.begin(), actual_sorted.end(), expect_sorted.begin(), expect_sorted.end()) == false)
474 fail("equivalent " + join_items(expected), join_items(actual), message, stack_frame);
475 else
476 assert::succeed(message, stack_frame);
477 }
478 template<typename item_t, typename collection_t>
479 static void are_equivalent(const std::initializer_list<item_t>& expected, const collection_t& actual) {are_equivalent(expected, actual, "", xtd::diagnostics::stack_frame::empty());}
480 template<typename item_t, typename collection_t>
481 static void are_equivalent(const std::initializer_list<item_t>& expected, const collection_t& actual, const xtd::diagnostics::stack_frame& stack_frame) {are_equivalent(expected, actual, "", stack_frame);}
482 template<typename item_t, typename collection_t>
483 static void are_equivalent(const std::initializer_list<item_t>& expected, const collection_t& actual, const std::string& message) {are_equivalent(expected, actual, message, xtd::diagnostics::stack_frame::empty());}
484 template<typename item_t, typename collection_t>
485 static void are_equivalent(const std::initializer_list<item_t>& expected, const collection_t& actual, const std::string& message, const xtd::diagnostics::stack_frame& stack_frame) {
486 std::vector<item_t> expect_sorted = expected;
487 std::sort(expect_sorted.begin(), expect_sorted.end());
488 collection_t actual_sorted = actual;
489 std::sort(actual_sorted.begin(), actual_sorted.end());
490 if (std::equal(actual_sorted.begin(), actual_sorted.end(), expect_sorted.begin(), expect_sorted.end()) == false)
491 fail("equivalent " + join_items(expected), join_items(actual), message, stack_frame);
492 else
493 assert::succeed(message, stack_frame);
494 }
496
508 template<typename expected_t, typename actual_t>
509 static void are_not_equal(const expected_t& expected, const actual_t& actual) {are_not_equal(expected, actual, "", xtd::diagnostics::stack_frame::empty());}
521 template<typename expected_t, typename actual_t>
522 static void are_not_equal(const expected_t& expected, const actual_t& actual, const std::string& message) {are_not_equal(expected, actual, message, xtd::diagnostics::stack_frame::empty());}
534 template<typename expected_t, typename actual_t>
535 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);}
547 template<typename expected_t, typename actual_t>
548 static void are_not_equal(const expected_t& expected, const actual_t& actual, const std::string& message, const xtd::diagnostics::stack_frame& stack_frame) {
549 if (std::equal(actual.begin(), actual.end(), expected.begin(), expected.end()) == true)
550 fail("not " + join_items(expected), join_items(actual), message, stack_frame);
551 else
552 assert::succeed(message, stack_frame);
553 }
554
556 template<typename item_t>
557 static void are_not_equal(const std::initializer_list<item_t>& expected, const std::initializer_list<item_t>& actual) {are_not_equal(expected, actual, "", xtd::diagnostics::stack_frame::empty());}
558 template<typename item_t>
559 static void are_not_equal(const std::initializer_list<item_t>& expected, const std::initializer_list<item_t>& actual, const xtd::diagnostics::stack_frame& stack_frame) {are_not_equal(expected, actual, "", stack_frame);}
560 template<typename item_t>
561 static void are_not_equal(const std::initializer_list<item_t>& expected, const std::initializer_list<item_t>& actual, const std::string& message) {are_not_equal(expected, actual, message, xtd::diagnostics::stack_frame::empty());}
562 template<typename item_t>
563 static void are_not_equal(const std::initializer_list<item_t>& expected, const std::initializer_list<item_t>& actual, const std::string& message, const xtd::diagnostics::stack_frame& stack_frame) {
564 if (std::equal(actual.begin(), actual.end(), expected.begin(), expected.end()) == true)
565 fail("not " + join_items(expected), join_items(actual), message, stack_frame);
566 else
567 assert::succeed(message, stack_frame);
568 }
569 template<typename collection_t, typename item_t>
570 static void are_not_equal(const collection_t& expected, const std::initializer_list<item_t>& actual) {are_not_equal(expected, actual, "", xtd::diagnostics::stack_frame::empty());}
571 template<typename collection_t, typename item_t>
572 static void are_not_equal(const collection_t& expected, const std::initializer_list<item_t>& actual, const xtd::diagnostics::stack_frame& stack_frame) {are_not_equal(expected, actual, "", stack_frame);}
573 template<typename collection_t, typename item_t>
574 static void are_not_equal(const collection_t& expected, const std::initializer_list<item_t>& actual, const std::string& message) {are_not_equal(expected, actual, message, xtd::diagnostics::stack_frame::empty());}
575 template<typename collection_t, typename item_t>
576 static void are_not_equal(const collection_t& expected, const std::initializer_list<item_t>& actual, const std::string& message, const xtd::diagnostics::stack_frame& stack_frame) {
577 if (std::equal(actual.begin(), actual.end(), expected.begin(), expected.end()) == true)
578 fail("not " + join_items(expected), join_items(actual), message, stack_frame);
579 else
580 assert::succeed(message, stack_frame);
581 }
582 template<typename item_t, typename collection_t>
583 static void are_not_equal(const std::initializer_list<item_t>& expected, const collection_t& actual) {are_not_equal(expected, actual, "", xtd::diagnostics::stack_frame::empty());}
584 template<typename item_t, typename collection_t>
585 static void are_not_equal(const std::initializer_list<item_t>& expected, const collection_t& actual, const xtd::diagnostics::stack_frame& stack_frame) {are_not_equal(expected, actual, "", stack_frame);}
586 template<typename item_t, typename collection_t>
587 static void are_not_equal(const std::initializer_list<item_t>& expected, const collection_t& actual, const std::string& message) {are_not_equal(expected, actual, message, xtd::diagnostics::stack_frame::empty());}
588 template<typename item_t, typename collection_t>
589 static void are_not_equal(const std::initializer_list<item_t>& expected, const collection_t& actual, const std::string& message, const xtd::diagnostics::stack_frame& stack_frame) {
590 if (std::equal(actual.begin(), actual.end(), expected.begin(), expected.end()) == true)
591 fail("not " + join_items(expected), join_items(actual), message, stack_frame);
592 else
593 assert::succeed(message, stack_frame);
594 }
596
608 template<typename expected_t, typename actual_t>
609 static void are_not_equivalent(const expected_t& expected, const actual_t& actual) {are_not_equivalent(expected, actual, "", xtd::diagnostics::stack_frame::empty());}
621 template<typename expected_t, typename actual_t>
622 static void are_not_equivalent(const expected_t& expected, const actual_t& actual, const std::string& message) {are_not_equivalent(expected, actual, message, xtd::diagnostics::stack_frame::empty());}
634 template<typename expected_t, typename actual_t>
635 static void are_not_equivalent(const expected_t& expected, const actual_t& actual, const xtd::diagnostics::stack_frame& stack_frame) {are_not_equivalent(expected, actual, "", stack_frame);}
647 template<typename expected_t, typename actual_t>
648 static void are_not_equivalent(const expected_t& expected, const actual_t& actual, const std::string& message, const xtd::diagnostics::stack_frame& stack_frame) {
649 expected_t expect_sorted = expected;
650 std::sort(expect_sorted.begin(), expect_sorted.end());
651 expected_t actual_sorted = actual;
652 std::sort(actual_sorted.begin(), actual_sorted.end());
653 if (std::equal(actual_sorted.begin(), actual_sorted.end(), expect_sorted.begin(), expect_sorted.end()) == true)
654 fail("not equivalent " + join_items(expected), join_items(actual), message, stack_frame);
655 else
656 assert::succeed(message, stack_frame);
657 }
658
660 template<typename expected_t, typename actual_t>
661 static void are_not_equivalent(const std::initializer_list<expected_t>& expected, const std::initializer_list<actual_t>& actual) {are_not_equivalent(expected, actual, "", xtd::diagnostics::stack_frame::empty());}
662 template<typename expected_t, typename actual_t>
663 static void are_not_equivalent(const std::initializer_list<expected_t>& expected, const std::initializer_list<actual_t>& actual, const xtd::diagnostics::stack_frame& stack_frame) {are_not_equivalent(expected, actual, "", stack_frame);}
664 template<typename expected_t, typename actual_t>
665 static void are_not_equivalent(const std::initializer_list<expected_t>& expected, const std::initializer_list<actual_t>& actual, const std::string& message) {are_not_equivalent(are_equivalent, actual, message, xtd::diagnostics::stack_frame::empty());}
666 template<typename expected_t, typename actual_t>
667 static void are_not_equivalent(const std::initializer_list<expected_t>& expected, const std::initializer_list<actual_t>& actual, const std::string& message, const xtd::diagnostics::stack_frame& stack_frame) {
668 std::vector<expected_t> expect_sorted = expected;
669 std::sort(expect_sorted.begin(), expect_sorted.end());
670 std::vector<actual_t> actual_sorted = actual;
671 std::sort(actual_sorted.begin(), actual_sorted.end());
672 if (std::equal(actual_sorted.begin(), actual_sorted.end(), expect_sorted.begin(), expect_sorted.end()) == true)
673 fail("not equivalent " + join_items(expected), join_items(actual), message, stack_frame);
674 else
675 assert::succeed(message, stack_frame);
676 }
677 template<typename collection_t, typename item_t>
678 static void are_not_equivalent(const collection_t& expected, const std::initializer_list<item_t>& actual) {are_not_equivalent(expected, actual, "", xtd::diagnostics::stack_frame::empty());}
679 template<typename collection_t, typename item_t>
680 static void are_not_equivalent(const collection_t& expected, const std::initializer_list<item_t>& actual, const xtd::diagnostics::stack_frame& stack_frame) {are_not_equivalent(expected, actual, "", stack_frame);}
681 template<typename collection_t, typename item_t>
682 static void are_not_equivalent(const collection_t& expected, const std::initializer_list<item_t>& actual, const std::string& message) {are_not_equivalent(expected, actual, message, xtd::diagnostics::stack_frame::empty());}
683 template<typename collection_t, typename item_t>
684 static void are_not_equivalent(const collection_t& expected, const std::initializer_list<item_t>& actual, const std::string& message, const xtd::diagnostics::stack_frame& stack_frame) {
685 collection_t expect_sorted = expected;
686 std::sort(expect_sorted.begin(), expect_sorted.end());
687 std::vector<item_t> actual_sorted = actual;
688 std::sort(actual_sorted.begin(), actual_sorted.end());
689 if (std::equal(actual_sorted.begin(), actual_sorted.end(), expect_sorted.begin(), expect_sorted.end()) == true)
690 fail("not equivalent " + join_items(expected), join_items(actual), message, stack_frame);
691 else
692 assert::succeed(message, stack_frame);
693 }
694 template<typename item_t, typename collection_t>
695 static void are_not_equivalent(const std::initializer_list<item_t>& expected, const collection_t& actual) {are_not_equivalent(expected, actual, "", xtd::diagnostics::stack_frame::empty());}
696 template<typename item_t, typename collection_t>
697 static void are_not_equivalent(const std::initializer_list<item_t>& expected, const collection_t& actual, const xtd::diagnostics::stack_frame& stack_frame) {are_not_equivalent(expected, actual, "", stack_frame);}
698 template<typename item_t, typename collection_t>
699 static void are_not_equivalent(const std::initializer_list<item_t>& expected, const collection_t& actual, const std::string& message) {are_not_equivalent(expected, actual, message, xtd::diagnostics::stack_frame::empty());}
700 template<typename item_t, typename collection_t>
701 static void are_not_equivalent(const std::initializer_list<item_t>& expected, const collection_t& actual, const std::string& message, const xtd::diagnostics::stack_frame& stack_frame) {
702 std::vector<item_t> expect_sorted = expected;
703 std::sort(expect_sorted.begin(), expect_sorted.end());
704 collection_t actual_sorted = actual;
705 std::sort(actual_sorted.begin(), actual_sorted.end());
706 if (std::equal(actual_sorted.begin(), actual_sorted.end(), expect_sorted.begin(), expect_sorted.end()) == true)
707 fail("not equivalent " + join_items(expected), join_items(actual), message, stack_frame);
708 else
709 assert::succeed(message, stack_frame);
710 }
712
724 template<typename expected_t, typename actual_t>
725 static void contains(const expected_t& expected, const actual_t& actual) {contains(expected, actual, "", xtd::diagnostics::stack_frame::empty());}
737 template<typename expected_t, typename actual_t>
738 static void contains(const expected_t& expected, const actual_t& actual, const std::string& message) {contains(expected, actual, message, xtd::diagnostics::stack_frame::empty());}
750 template<typename expected_t, typename actual_t>
751 static void contains(const expected_t& expected, const actual_t& actual, const xtd::diagnostics::stack_frame& stack_frame) {contains(expected, actual, "", stack_frame);}
763 template<typename expected_t, typename actual_t>
764 static void contains(const expected_t& expected, const actual_t& actual, const std::string& message, const xtd::diagnostics::stack_frame& stack_frame) {
765 for (auto item : expected) {
766 if (std::find(actual.begin(), actual.end(), item) == actual.end()) {
767 fail("contains " + join_items(expected), join_items(actual), message, stack_frame);
768 return;
769 }
770 }
771 assert::succeed(message, stack_frame);
772 }
773
775 template<typename item_t>
776 static void contains(const std::initializer_list<item_t>& expected, const std::initializer_list<item_t>& actual) {contains(expected, actual, "", xtd::diagnostics::stack_frame::empty());}
777 template<typename item_t>
778 static void contains(const std::initializer_list<item_t>& expected, const std::initializer_list<item_t>& actual, const xtd::diagnostics::stack_frame& stack_frame) {contains(expected, actual, "", stack_frame);}
779 template<typename item_t>
780 static void contains(const std::initializer_list<item_t>& expected, const std::initializer_list<item_t>& actual, const std::string& message) {contains(expected, actual, message, xtd::diagnostics::stack_frame::empty());}
781 template<typename item_t>
782 static void contains(const std::initializer_list<item_t>& expected, const std::initializer_list<item_t>& actual, const std::string& message, const xtd::diagnostics::stack_frame& stack_frame) {
783 for (auto item : expected) {
784 if (std::find(actual.begin(), actual.end(), item) == actual.end()) {
785 fail("contains " + join_items(expected), join_items(actual), message, stack_frame);
786 return;
787 }
788 }
789 assert::succeed(message, stack_frame);
790 }
791 template<typename collection_t, typename item_t>
792 static void contains(const collection_t& expected, const std::initializer_list<item_t>& actual) {contains(expected, actual, "", xtd::diagnostics::stack_frame::empty());}
793 template<typename collection_t, typename item_t>
794 static void contains(const collection_t& expected, const std::initializer_list<item_t>& actual, const xtd::diagnostics::stack_frame& stack_frame) {contains(expected, actual, "", stack_frame);}
795 template<typename collection_t, typename item_t>
796 static void contains(const collection_t& expected, const std::initializer_list<item_t>& actual, const std::string& message) {contains(expected, actual, message, xtd::diagnostics::stack_frame::empty());}
797 template<typename collection_t, typename item_t>
798 static void contains(const collection_t& expected, const std::initializer_list<item_t>& actual, const std::string& message, const xtd::diagnostics::stack_frame& stack_frame) {
799 for (auto item : expected) {
800 if (std::find(actual.begin(), actual.end(), item) == actual.end()) {
801 fail("contains " + join_items(expected), join_items(actual), message, stack_frame);
802 return;
803 }
804 }
805 assert::succeed(message, stack_frame);
806 }
807 template<typename item_t, typename collection_t>
808 static void contains(const std::initializer_list<item_t>& expected, const collection_t& actual) {contains(expected, actual, "", xtd::diagnostics::stack_frame::empty());}
809 template<typename item_t, typename collection_t>
810 static void contains(const std::initializer_list<item_t>& expected, const collection_t& actual, const xtd::diagnostics::stack_frame& stack_frame) {contains(expected, actual, "", stack_frame);}
811 template<typename item_t, typename collection_t>
812 static void contains(const std::initializer_list<item_t>& expected, const collection_t& actual, const std::string& message) {contains(expected, actual, message, xtd::diagnostics::stack_frame::empty());}
813 template<typename item_t, typename collection_t>
814 static void contains(const std::initializer_list<item_t>& expected, const collection_t& actual, const std::string& message, const xtd::diagnostics::stack_frame& stack_frame) {
815 for (auto item : expected) {
816 if (std::find(actual.begin(), actual.end(), item) == actual.end()) {
817 fail("contains " + join_items(expected), join_items(actual), message, stack_frame);
818 return;
819 }
820 }
821 assert::succeed(message, stack_frame);
822 }
824
836 template<typename expected_t, typename actual_t>
837 static void does_not_contain(const expected_t& expected, const actual_t& actual) {does_not_contain(expected, actual, "", xtd::diagnostics::stack_frame::empty());}
849 template<typename expected_t, typename actual_t>
850 static void does_not_contain(const expected_t& expected, const actual_t& actual, const std::string& message) {does_not_contain(expected, actual, message, xtd::diagnostics::stack_frame::empty());}
862 template<typename expected_t, typename actual_t>
863 static void does_not_contain(const expected_t& expected, const actual_t& actual, const xtd::diagnostics::stack_frame& stack_frame) {does_not_contain(expected, actual, "", stack_frame);}
875 template<typename expected_t, typename actual_t>
876 static void does_not_contain(const expected_t& expected, const actual_t& actual, const std::string& message, const xtd::diagnostics::stack_frame& stack_frame) {
877 for (auto item : expected) {
878 if (std::find(actual.begin(), actual.end(), item) == actual.end()) {
879 assert::succeed(message, stack_frame);
880 return;
881 }
882 }
883 fail("not contains " + join_items(expected), join_items(actual), message, stack_frame);
884 }
885
887 template<typename item_t>
888 static void does_not_contain(const std::initializer_list<item_t>& expected, const std::initializer_list<item_t>& actual) {does_not_contain(expected, actual, "", xtd::diagnostics::stack_frame::empty());}
889 template<typename item_t>
890 static void does_not_contain(const std::initializer_list<item_t>& expected, const std::initializer_list<item_t>& actual, const xtd::diagnostics::stack_frame& stack_frame) {does_not_contain(expected, actual, "", stack_frame);}
891 template<typename item_t>
892 static void does_not_contain(const std::initializer_list<item_t>& expected, const std::initializer_list<item_t>& actual, const std::string& message) {does_not_contain(expected, actual, message, xtd::diagnostics::stack_frame::empty());}
893 template<typename item_t>
894 static void does_not_contain(const std::initializer_list<item_t>& expected, const std::initializer_list<item_t>& actual, const std::string& message, const xtd::diagnostics::stack_frame& stack_frame) {
895 for (auto item : expected) {
896 if (std::find(actual.begin(), actual.end(), item) == actual.end()) {
897 assert::succeed(message, stack_frame);
898 return;
899 }
900 }
901 fail("not contains " + join_items(expected), join_items(actual), message, stack_frame);
902 }
903 template<typename collection_t, typename item_t>
904 static void does_not_contain(const collection_t& expected, const std::initializer_list<item_t>& actual) {does_not_contain(expected, actual, "", xtd::diagnostics::stack_frame::empty());}
905 template<typename collection_t, typename item_t>
906 static void does_not_contain(const collection_t& expected, const std::initializer_list<item_t>& actual, const xtd::diagnostics::stack_frame& stack_frame) {does_not_contain(expected, actual, "", stack_frame);}
907 template<typename collection_t, typename item_t>
908 static void does_not_contain(const collection_t& expected, const std::initializer_list<item_t>& actual, const std::string& message) {does_not_contain(expected, actual, message, xtd::diagnostics::stack_frame::empty());}
909 template<typename collection_t, typename item_t>
910 static void does_not_contain(const collection_t& expected, const std::initializer_list<item_t>& actual, const std::string& message, const xtd::diagnostics::stack_frame& stack_frame) {
911 for (auto item : expected) {
912 if (std::find(actual.begin(), actual.end(), item) == actual.end()) {
913 assert::succeed(message, stack_frame);
914 return;
915 }
916 }
917 fail("not contains " + join_items(expected), join_items(actual), message, stack_frame);
918 }
919 template<typename item_t, typename collection_t>
920 static void does_not_contain(const std::initializer_list<item_t>& expected, const collection_t& actual) {does_not_contain(expected, actual, "", xtd::diagnostics::stack_frame::empty());}
921 template<typename item_t, typename collection_t>
922 static void does_not_contain(const std::initializer_list<item_t>& expected, const collection_t& actual, const xtd::diagnostics::stack_frame& stack_frame) {does_not_contain(expected, actual, "", stack_frame);}
923 template<typename item_t, typename collection_t>
924 static void does_not_contain(const std::initializer_list<item_t>& expected, const collection_t& actual, const std::string& message) {does_not_contain(expected, actual, message, xtd::diagnostics::stack_frame::empty());}
925 template<typename item_t, typename collection_t>
926 static void does_not_contain(const std::initializer_list<item_t>& expected, const collection_t& actual, const std::string& message, const xtd::diagnostics::stack_frame& stack_frame) {
927 for (auto item : expected) {
928 if (std::find(actual.begin(), actual.end(), item) == actual.end()) {
929 assert::succeed(message, stack_frame);
930 return;
931 }
932 }
933 fail("not contains " + join_items(expected), join_items(actual), message, stack_frame);
934 }
936
947 template<typename value_t>
948 static void is_empty(const value_t& value) {is_empty(value, "", xtd::diagnostics::stack_frame::empty());}
960 template<typename value_t>
961 static void is_empty(const value_t& value, const xtd::diagnostics::stack_frame& stack_frame) {is_empty(value, "", stack_frame);}
973 template<typename value_t>
974 static void is_empty(const value_t& value, const std::string& message) {is_empty(value, message, xtd::diagnostics::stack_frame::empty());}
987 template<typename value_t>
988 static void is_empty(const value_t& value, const std::string& message, const xtd::diagnostics::stack_frame& stack_frame) {
989 if (std::empty(value))
990 assert::succeed(message, stack_frame);
991 else
992 fail("<empty>", join_items(value), message, stack_frame);
993 }
994
996 template<typename value_t>
997 static void is_empty(const std::initializer_list<value_t>& value) {is_empty(value, "", xtd::diagnostics::stack_frame::empty());}
998 template<typename value_t>
999 static void is_empty(const std::initializer_list<value_t>& value, const xtd::diagnostics::stack_frame& stack_frame) {is_empty(value, "", stack_frame);}
1000 template<typename value_t>
1001 static void is_empty(const std::initializer_list<value_t>& value, const std::string& message) {is_empty(value, message, xtd::diagnostics::stack_frame::empty());}
1002 template<typename value_t>
1003 static void is_empty(const std::initializer_list<value_t>& value, const std::string& message, const xtd::diagnostics::stack_frame& stack_frame) {
1004 if (std::empty(value))
1005 assert::succeed(message, stack_frame);
1006 else
1007 fail("<empty>", join_items(value), message, stack_frame);
1008 }
1010
1021 template<typename value_t>
1022 static void is_not_empty(const value_t& value) {is_not_empty(value, "", xtd::diagnostics::stack_frame::empty());}
1034 template<typename value_t>
1035 static void is_not_empty(const value_t& value, const xtd::diagnostics::stack_frame& stack_frame) {is_not_empty(value, "", stack_frame);}
1047 template<typename value_t>
1048 static void is_not_empty(const value_t& value, const std::string& message) {is_not_empty(value, message, xtd::diagnostics::stack_frame::empty());}
1061 template<typename value_t>
1062 static void is_not_empty(const value_t& value, const std::string& message, const xtd::diagnostics::stack_frame& stack_frame) {
1063 if (!std::empty(value))
1064 assert::succeed(message, stack_frame);
1065 else
1066 fail("not <empty>", "<empty>", message, stack_frame);
1067 }
1068
1070 template<typename value_t>
1071 static void is_not_empty(const std::initializer_list<value_t>& value) {is_not_empty(value, "", xtd::diagnostics::stack_frame::empty());}
1072 template<typename value_t>
1073 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);}
1074 template<typename value_t>
1075 static void is_not_empty(const std::initializer_list<value_t>& value, const std::string& message) {is_not_empty(value, message, xtd::diagnostics::stack_frame::empty());}
1076 template<typename value_t>
1077 static void is_not_empty(const std::initializer_list<value_t>& value, const std::string& message, const xtd::diagnostics::stack_frame& stack_frame) {
1078 if (!std::empty(value))
1079 assert::succeed(message, stack_frame);
1080 else
1081 fail("not <empty>", "<empty>", message, stack_frame);
1082 }
1084
1095 template<typename value_t>
1096 static void is_ordered(const value_t& value) {is_ordered(value, "", xtd::diagnostics::stack_frame::empty());}
1108 template<typename value_t>
1109 static void is_ordered(const value_t& value, const xtd::diagnostics::stack_frame& stack_frame) {is_ordered(value, "", stack_frame);}
1121 template<typename value_t>
1122 static void is_ordered(const value_t& value, const std::string& message) {is_ordered(value, message, xtd::diagnostics::stack_frame::empty());}
1135 template<typename value_t>
1136 static void is_ordered(const value_t& value, const std::string& message, const xtd::diagnostics::stack_frame& stack_frame) {
1137 if (std::is_sorted(value.begin(), value.end()))
1138 assert::succeed(message, stack_frame);
1139 else
1140 fail("<ordered>", join_items(value), message, stack_frame);
1141 }
1142
1144 template<typename value_t>
1145 static void is_ordered(const std::initializer_list<value_t>& value) {is_ordered(value, "", xtd::diagnostics::stack_frame::empty());}
1146 template<typename value_t>
1147 static void is_ordered(const std::initializer_list<value_t>& value, const xtd::diagnostics::stack_frame& stack_frame) {is_ordered(value, "", stack_frame);}
1148 template<typename value_t>
1149 static void is_ordered(const std::initializer_list<value_t>& value, const std::string& message) {is_ordered(value, message, xtd::diagnostics::stack_frame::empty());}
1150 template<typename value_t>
1151 static void is_ordered(const std::initializer_list<value_t>& value, const std::string& message, const xtd::diagnostics::stack_frame& stack_frame) {
1152 if (std::is_sorted(value.begin(), value.end()))
1153 assert::succeed(message, stack_frame);
1154 else
1155 fail("<ordered>", join_items(value), message, stack_frame);
1156 }
1159 };
1160 }
1161}
1162
1179#define all_items_are_instances_of_(type_t, ...) __CMD_ASSERT_ARGS(all_items_are_instances_of<type_t>, __VA_ARGS__)
1180
1199#define all_items_are_not_null_(...) __CMD_ASSERT_ARGS(all_items_are_not_null, __VA_ARGS__)
1200
1218#define all_items_are_unique_(...) __CMD_ASSERT_ARGS(all_items_are_unique, __VA_ARGS__)
1219
1236#define are_equivalent_(...) __CMD_ASSERT_ARGS(are_equivalent, __VA_ARGS__)
1237
1254#define are_not_equivalent_(...) __CMD_ASSERT_ARGS(are_not_equivalent, __VA_ARGS__)
1255
1273#define is_ordered_(...) __CMD_ASSERT_ARGS(is_ordered, __VA_ARGS__)
xtd::diagnostics::stack_frame
Provides information about a xtd::diagnostics::stack_frame, which represents a function call on the c...
Definition stack_frame.h:37
xtd::diagnostics::stack_frame::empty
static stack_frame empty() noexcept
Return an empty stack frame.
xtd::tunit::base_assert
The base class for assert.
Definition base_assert.h:29
xtd::tunit::collection_assert
The collection_assert class contains a collection of static methods that implement the most collectio...
Definition collection_assert.h:23
xtd::tunit::collection_assert::is_empty
static void is_empty(const value_t &value, const xtd::diagnostics::stack_frame &stack_frame)
Asserts that collection contains an item.
Definition collection_assert.h:961
xtd::tunit::collection_assert::all_items_are_not_null
static void all_items_are_not_null(const collection_t &collection, const xtd::diagnostics::stack_frame &stack_frame)
Asserts that all collection items are not null.
Definition collection_assert.h:154
xtd::tunit::collection_assert::are_not_equivalent
static void are_not_equivalent(const expected_t &expected, const actual_t &actual, const std::string &message, const xtd::diagnostics::stack_frame &stack_frame)
Asserts that all collection items are not equivalent.
Definition collection_assert.h:648
xtd::tunit::collection_assert::all_items_are_unique
static void all_items_are_unique(const collection_t &collection, const std::string &message, const xtd::diagnostics::stack_frame &stack_frame)
Asserts that all collection items are unique.
Definition collection_assert.h:251
xtd::tunit::collection_assert::does_not_contain
static void does_not_contain(const expected_t &expected, const actual_t &actual)
Asserts that collection contains all items.
Definition collection_assert.h:837
xtd::tunit::collection_assert::are_not_equivalent
static void are_not_equivalent(const expected_t &expected, const actual_t &actual, const std::string &message)
Asserts that all collection items are not equivalent.
Definition collection_assert.h:622
xtd::tunit::collection_assert::are_equal
static void are_equal(const expected_t &expected, const actual_t &actual)
Asserts that all collection items are equal.
Definition collection_assert.h:293
xtd::tunit::collection_assert::are_not_equivalent
static void are_not_equivalent(const expected_t &expected, const actual_t &actual, const xtd::diagnostics::stack_frame &stack_frame)
Asserts that all collection items are not equivalent.
Definition collection_assert.h:635
xtd::tunit::collection_assert::all_items_are_instances_of
static void all_items_are_instances_of(const collection_t &collection, const std::string &message)
Asserts that all collection items are of the type supplied or a derived type.
Definition collection_assert.h:57
xtd::tunit::collection_assert::is_ordered
static void is_ordered(const value_t &value, const std::string &message, const xtd::diagnostics::stack_frame &stack_frame)
Asserts that collection is ordered.
Definition collection_assert.h:1136
xtd::tunit::collection_assert::all_items_are_unique
static void all_items_are_unique(const collection_t &collection, const std::string &message)
Asserts that all collection items are unique.
Definition collection_assert.h:223
xtd::tunit::collection_assert::are_equivalent
static void are_equivalent(const expected_t &expected, const actual_t &actual, const xtd::diagnostics::stack_frame &stack_frame)
Asserts that all collection items are equivalent.
Definition collection_assert.h:419
xtd::tunit::collection_assert::are_not_equal
static void are_not_equal(const expected_t &expected, const actual_t &actual, const xtd::diagnostics::stack_frame &stack_frame)
Asserts that all collection items are not equal.
Definition collection_assert.h:535
xtd::tunit::collection_assert::is_not_empty
static void is_not_empty(const value_t &value, const xtd::diagnostics::stack_frame &stack_frame)
Asserts that collection or traits does not contain any item.
Definition collection_assert.h:1035
xtd::tunit::collection_assert::contains
static void contains(const expected_t &expected, const actual_t &actual, const std::string &message)
Asserts that collection contains all items.
Definition collection_assert.h:738
xtd::tunit::collection_assert::is_ordered
static void is_ordered(const value_t &value, const xtd::diagnostics::stack_frame &stack_frame)
Asserts that collection is ordered.
Definition collection_assert.h:1109
xtd::tunit::collection_assert::are_equal
static void are_equal(const expected_t &expected, const actual_t &actual, const std::string &message)
Asserts that all collection items are equal.
Definition collection_assert.h:306
xtd::tunit::collection_assert::is_not_empty
static void is_not_empty(const value_t &value, const std::string &message, const xtd::diagnostics::stack_frame &stack_frame)
Asserts that collection or traits does not contain any item.
Definition collection_assert.h:1062
xtd::tunit::collection_assert::is_not_empty
static void is_not_empty(const value_t &value, const std::string &message)
Asserts that collection or traits does not contain any item.
Definition collection_assert.h:1048
xtd::tunit::collection_assert::are_equivalent
static void are_equivalent(const expected_t &expected, const actual_t &actual)
Asserts that all collection items are equivalent.
Definition collection_assert.h:393
xtd::tunit::collection_assert::are_equivalent
static void are_equivalent(const expected_t &expected, const actual_t &actual, const std::string &message, const xtd::diagnostics::stack_frame &stack_frame)
Asserts that all collection items are equivalent.
Definition collection_assert.h:432
xtd::tunit::collection_assert::does_not_contain
static void does_not_contain(const expected_t &expected, const actual_t &actual, const xtd::diagnostics::stack_frame &stack_frame)
Asserts that collection contains all items.
Definition collection_assert.h:863
xtd::tunit::collection_assert::is_ordered
static void is_ordered(const value_t &value)
Asserts that collection is ordered.
Definition collection_assert.h:1096
xtd::tunit::collection_assert::are_equal
static void are_equal(const expected_t &expected, const actual_t &actual, const std::string &message, const xtd::diagnostics::stack_frame &stack_frame)
Asserts that all collection items are equal.
Definition collection_assert.h:332
xtd::tunit::collection_assert::all_items_are_unique
static void all_items_are_unique(const collection_t &collection, const xtd::diagnostics::stack_frame &stack_frame)
Asserts that all collection items are unique.
Definition collection_assert.h:237
xtd::tunit::collection_assert::are_equivalent
static void are_equivalent(const expected_t &expected, const actual_t &actual, const std::string &message)
Asserts that all collection items are equivalent.
Definition collection_assert.h:406
xtd::tunit::collection_assert::are_not_equivalent
static void are_not_equivalent(const expected_t &expected, const actual_t &actual)
Asserts that all collection items are not equivalent.
Definition collection_assert.h:609
xtd::tunit::collection_assert::all_items_are_unique
static void all_items_are_unique(const collection_t &collection)
Asserts that all collection items are unique.
Definition collection_assert.h:209
xtd::tunit::collection_assert::contains
static void contains(const expected_t &expected, const actual_t &actual, const xtd::diagnostics::stack_frame &stack_frame)
Asserts that collection contains all items.
Definition collection_assert.h:751
xtd::tunit::collection_assert::are_not_equal
static void are_not_equal(const expected_t &expected, const actual_t &actual)
Asserts that all collection items are not equal.
Definition collection_assert.h:509
xtd::tunit::collection_assert::is_empty
static void is_empty(const value_t &value, const std::string &message, const xtd::diagnostics::stack_frame &stack_frame)
Asserts that collection contains an item.
Definition collection_assert.h:988
xtd::tunit::collection_assert::all_items_are_not_null
static void all_items_are_not_null(const collection_t &collection, const std::string &message)
Asserts that all collection items are not null.
Definition collection_assert.h:139
xtd::tunit::collection_assert::is_empty
static void is_empty(const value_t &value)
Asserts that collection contains an item.
Definition collection_assert.h:948
xtd::tunit::collection_assert::all_items_are_instances_of
static void all_items_are_instances_of(const collection_t &collection, const std::string &message, const xtd::diagnostics::stack_frame &stack_frame)
Asserts that all collection items are of the type supplied or a derived type.
Definition collection_assert.h:83
xtd::tunit::collection_assert::all_items_are_instances_of
static void all_items_are_instances_of(const collection_t &collection, const xtd::diagnostics::stack_frame &stack_frame)
Asserts that all collection items are of the type supplied or a derived type.
Definition collection_assert.h:70
xtd::tunit::collection_assert::are_not_equal
static void are_not_equal(const expected_t &expected, const actual_t &actual, const std::string &message)
Asserts that all collection items are not equal.
Definition collection_assert.h:522
xtd::tunit::collection_assert::contains
static void contains(const expected_t &expected, const actual_t &actual)
Asserts that collection contains all items.
Definition collection_assert.h:725
xtd::tunit::collection_assert::contains
static void contains(const expected_t &expected, const actual_t &actual, const std::string &message, const xtd::diagnostics::stack_frame &stack_frame)
Asserts that collection contains all items.
Definition collection_assert.h:764
xtd::tunit::collection_assert::are_equal
static void are_equal(const expected_t &expected, const actual_t &actual, const xtd::diagnostics::stack_frame &stack_frame)
Asserts that all collection items are equal.
Definition collection_assert.h:319
xtd::tunit::collection_assert::is_ordered
static void is_ordered(const value_t &value, const std::string &message)
Asserts that collection is ordered.
Definition collection_assert.h:1122
xtd::tunit::collection_assert::all_items_are_instances_of
static void all_items_are_instances_of(const collection_t &collection)
Asserts that all collection items are of the type supplied or a derived type.
Definition collection_assert.h:44
xtd::tunit::collection_assert::all_items_are_not_null
static void all_items_are_not_null(const collection_t &collection, const std::string &message, const xtd::diagnostics::stack_frame &stack_frame)
Asserts that all collection items are not null.
Definition collection_assert.h:169
xtd::tunit::collection_assert::is_not_empty
static void is_not_empty(const value_t &value)
Asserts that collection does not contain any item.
Definition collection_assert.h:1022
xtd::tunit::collection_assert::does_not_contain
static void does_not_contain(const expected_t &expected, const actual_t &actual, const std::string &message, const xtd::diagnostics::stack_frame &stack_frame)
Asserts that collection contains all items.
Definition collection_assert.h:876
xtd::tunit::collection_assert::all_items_are_not_null
static void all_items_are_not_null(const collection_t &collection)
Asserts that all collection items are not null.
Definition collection_assert.h:124
xtd::tunit::collection_assert::does_not_contain
static void does_not_contain(const expected_t &expected, const actual_t &actual, const std::string &message)
Asserts that collection contains all items.
Definition collection_assert.h:850
xtd::tunit::collection_assert::are_not_equal
static void are_not_equal(const expected_t &expected, const actual_t &actual, const std::string &message, const xtd::diagnostics::stack_frame &stack_frame)
Asserts that all collection items are not equal.
Definition collection_assert.h:548
xtd::tunit::collection_assert::is_empty
static void is_empty(const value_t &value, const std::string &message)
Asserts that collection contains an item.
Definition collection_assert.h:974
tunit_export_
#define tunit_export_
Define shared library export.
Definition tunit_export.h:13
xtd::int32
int_least32_t int32
Represents a 32-bit signed integer.
Definition types.h:131
xtd
The xtd namespace contains all fundamental classes to access Hardware, Os, System,...
Definition xtd_about_box.h:10
assert.h
Contains xtd::tunit::assert class.
Generated on Wed Apr 10 2024 00:07:12 for xtd by Gammasoft. All rights reserved.