xtd - Reference Guide  0.1.1
Modern c++17/20 framework to create console, GUI and unit test applications on Windows, macOS, Linux, iOS and android.
collection_assert.h
Go to the documentation of this file.
1 #pragma once
5 #include "assert.h"
6 
8 namespace xtd {
10  namespace tunit {
20  class collection_assert final : private base_assert {
21  public:
23  collection_assert() = delete;
25 
37  template<typename expected_t, typename collection_t>
38  static void all_items_are_instances_of(const collection_t& collection) {all_items_are_instances_of<expected_t>(collection, "", xtd::diagnostics::stack_frame::empty());}
39 
51  template<typename expected_t, typename collection_t>
52  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());}
53 
65  template<typename expected_t, typename collection_t>
66  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);}
67 
79  template<typename expected_t, typename collection_t>
80  static void all_items_are_instances_of(const collection_t& collection, const std::string& message, const xtd::diagnostics::stack_frame& stack_frame) {
81  for (auto item : collection)
82  if (dynamic_cast<expected_t>(item) == nullptr) {
83  base_assert::fail("all items instance of <" + __tunit_demangle(typeid(expected_t).name()) + ">", base_assert::join_items(collection), message, stack_frame);
84  return;
85  }
86  assert::succeed(message, stack_frame);
87  }
88 
90  template<typename expected_t, typename item_t>
91  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());}
92  template<typename expected_t, typename item_t>
93  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());}
94  template<typename expected_t, typename item_t>
95  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);}
96  template<typename expected_t, typename item_t>
97  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) {
98  for (auto item : collection)
99  if (dynamic_cast<expected_t>(item) == nullptr) {
100  base_assert::fail("all items instance of <" + __tunit_demangle(typeid(expected_t).name()) + ">", base_assert::join_items(collection), message, stack_frame);
101  return;
102  }
103  assert::succeed(message, stack_frame);
104  }
106 
120  template<typename collection_t>
121  static void all_items_are_not_null(const collection_t& collection) {all_items_are_not_null(collection, "", xtd::diagnostics::stack_frame::empty());}
122 
136  template<typename collection_t>
137  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());}
138 
152  template<typename collection_t>
153  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);}
154 
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  base_assert::fail("all items are not null", base_assert::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  base_assert::fail("all items are not null", base_assert::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());}
210 
223  template<typename collection_t>
224  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());}
225 
238  template<typename collection_t>
239  static void all_items_are_unique(const collection_t& collection, const xtd::diagnostics::stack_frame& stack_frame) {all_items_are_unique(collection, "", stack_frame);}
240 
253  template<typename collection_t>
254  static void all_items_are_unique(const collection_t& collection, const std::string& message, const xtd::diagnostics::stack_frame& stack_frame) {
255  auto value = *collection.cbegin();
256  std::map<decltype(value), int> counts;
257  for (auto item : collection) {
258  auto result = counts.insert(std::pair<decltype(item), int>(item, 1));
259  if (result.second == false)
260  base_assert::fail("all items are unique", base_assert::join_items(collection), message, stack_frame);
261  }
262  assert::succeed(message, stack_frame);
263  }
264 
266  template<typename item_t>
267  static void all_items_are_unique(const std::initializer_list<item_t>& collection) {all_items_are_unique(collection, "", xtd::diagnostics::stack_frame::empty());}
268  template<typename item_t>
269  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);}
270  template<typename item_t>
271  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());}
272  template<typename item_t>
273  static void all_items_are_unique(const std::initializer_list<item_t>& collection, const std::string& message, const xtd::diagnostics::stack_frame& stack_frame) {
274  std::map<item_t, int> counts;
275  for (auto item : collection) {
276  auto result = counts.insert(std::pair<item_t, int>(item, 1));
277  if (result.second == false)
278  base_assert::fail("all items are unique", base_assert::join_items(collection), message, stack_frame);
279  }
280  assert::succeed(message, stack_frame);
281  }
283 
295  template<typename expected_t, typename actual_t>
296  static void are_equal(const expected_t& expected, const actual_t& actual) {are_equal(expected, actual, "", xtd::diagnostics::stack_frame::empty());}
297 
309  template<typename expected_t, typename actual_t>
310  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());}
311 
323  template<typename expected_t, typename actual_t>
324  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);}
325 
337  template<typename expected_t, typename actual_t>
338  static void are_equal(const expected_t& expected, const actual_t& actual, const std::string& message, const xtd::diagnostics::stack_frame& stack_frame) {
339  if (std::equal(actual.begin(), actual.end(), expected.begin(), expected.end()) == false)
340  base_assert::fail(base_assert::join_items(expected), base_assert::join_items(actual), message, stack_frame);
341  else
342  assert::succeed(message, stack_frame);
343  }
344 
346  template<typename item_t>
347  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());}
348  template<typename item_t>
349  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);}
350  template<typename item_t>
351  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());}
352  template<typename item_t>
353  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) {
354  if (std::equal(actual.begin(), actual.end(), expected.begin(), expected.end()) == false)
355  base_assert::fail(base_assert::join_items(expected), base_assert::join_items(actual), message, stack_frame);
356  else
357  assert::succeed(message, stack_frame);
358  }
359 
361  template<typename collection_t, typename item_t>
362  static void are_equal(const collection_t& expected, const std::initializer_list<item_t>& actual) {are_equal(expected, actual, "", xtd::diagnostics::stack_frame::empty());}
363  template<typename collection_t, typename item_t>
364  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);}
365  template<typename collection_t, typename item_t>
366  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());}
367  template<typename collection_t, typename item_t>
368  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) {
369  if (std::equal(actual.begin(), actual.end(), expected.begin(), expected.end()) == false)
370  base_assert::fail(base_assert::join_items(expected), base_assert::join_items(actual), message, stack_frame);
371  else
372  assert::succeed(message, stack_frame);
373  }
374 
376  template<typename item_t, typename collection_t>
377  static void are_equal(const std::initializer_list<item_t>& expected, const collection_t& actual) {are_equal(expected, actual, "", xtd::diagnostics::stack_frame::empty());}
378  template<typename item_t, typename collection_t>
379  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);}
380  template<typename item_t, typename collection_t>
381  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());}
382  template<typename item_t, typename collection_t>
383  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) {
384  if (std::equal(actual.begin(), actual.end(), expected.begin(), expected.end()) == false)
385  base_assert::fail(base_assert::join_items(expected), base_assert::join_items(actual), message, stack_frame);
386  else
387  assert::succeed(message, stack_frame);
388  }
390 
402  template<typename expected_t, typename actual_t>
403  static void are_equivalent(const expected_t& expected, const actual_t& actual) {are_equivalent(expected, actual, "", xtd::diagnostics::stack_frame::empty());}
404 
416  template<typename expected_t, typename actual_t>
417  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 
430  template<typename expected_t, typename actual_t>
431  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);}
432 
444  template<typename expected_t, typename actual_t>
445  static void are_equivalent(const expected_t& expected, const actual_t& actual, const std::string& message, const xtd::diagnostics::stack_frame& stack_frame) {
446  expected_t expect_sorted = expected;
447  std::sort(expect_sorted.begin(), expect_sorted.end());
448  expected_t actual_sorted = actual;
449  std::sort(actual_sorted.begin(), actual_sorted.end());
450  if (std::equal(actual_sorted.begin(), actual_sorted.end(), expect_sorted.begin(), expect_sorted.end()) == false)
451  base_assert::fail("equivalent " + base_assert::join_items(expected), base_assert::join_items(actual), message, stack_frame);
452  else
453  assert::succeed(message, stack_frame);
454  }
455 
457  template<typename expected_t, typename actual_t>
458  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());}
459  template<typename expected_t, typename actual_t>
460  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);}
461  template<typename expected_t, typename actual_t>
462  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());}
463  template<typename expected_t, typename actual_t>
464  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) {
465  std::vector<expected_t> expect_sorted = expected;
466  std::sort(expect_sorted.begin(), expect_sorted.end());
467  std::vector<actual_t> actual_sorted = actual;
468  std::sort(actual_sorted.begin(), actual_sorted.end());
469  if (std::equal(actual_sorted.begin(), actual_sorted.end(), expect_sorted.begin(), expect_sorted.end()) == false)
470  base_assert::fail("equivalent " + base_assert::join_items(expected), base_assert::join_items(actual), message, stack_frame);
471  else
472  assert::succeed(message, stack_frame);
473  }
474 
476  template<typename collection_t, typename item_t>
477  static void are_equivalent(const collection_t& expected, const std::initializer_list<item_t>& actual) {are_equivalent(expected, actual, "", xtd::diagnostics::stack_frame::empty());}
478  template<typename collection_t, typename item_t>
479  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);}
480  template<typename collection_t, typename item_t>
481  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());}
482  template<typename collection_t, typename item_t>
483  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) {
484  collection_t expect_sorted = expected;
485  std::sort(expect_sorted.begin(), expect_sorted.end());
486  std::vector<item_t> actual_sorted = actual;
487  std::sort(actual_sorted.begin(), actual_sorted.end());
488  if (std::equal(actual_sorted.begin(), actual_sorted.end(), expect_sorted.begin(), expect_sorted.end()) == false)
489  base_assert::fail("equivalent " + base_assert::join_items(expected), base_assert::join_items(actual), message, stack_frame);
490  else
491  assert::succeed(message, stack_frame);
492  }
493 
495  template<typename item_t, typename collection_t>
496  static void are_equivalent(const std::initializer_list<item_t>& expected, const collection_t& actual) {are_equivalent(expected, actual, "", xtd::diagnostics::stack_frame::empty());}
497  template<typename item_t, typename collection_t>
498  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);}
499  template<typename item_t, typename collection_t>
500  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());}
501  template<typename item_t, typename collection_t>
502  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) {
503  std::vector<item_t> expect_sorted = expected;
504  std::sort(expect_sorted.begin(), expect_sorted.end());
505  collection_t actual_sorted = actual;
506  std::sort(actual_sorted.begin(), actual_sorted.end());
507  if (std::equal(actual_sorted.begin(), actual_sorted.end(), expect_sorted.begin(), expect_sorted.end()) == false)
508  base_assert::fail("equivalent " + base_assert::join_items(expected), base_assert::join_items(actual), message, stack_frame);
509  else
510  assert::succeed(message, stack_frame);
511  }
513 
525  template<typename expected_t, typename actual_t>
526  static void are_not_equal(const expected_t& expected, const actual_t& actual) {are_not_equal(expected, actual, "", xtd::diagnostics::stack_frame::empty());}
527 
539  template<typename expected_t, typename actual_t>
540  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());}
541 
553  template<typename expected_t, typename actual_t>
554  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);}
555 
567  template<typename expected_t, typename actual_t>
568  static void are_not_equal(const expected_t& expected, const actual_t& actual, const std::string& message, const xtd::diagnostics::stack_frame& stack_frame) {
569  if (std::equal(actual.begin(), actual.end(), expected.begin(), expected.end()) == true)
570  base_assert::fail("not " + base_assert::join_items(expected), base_assert::join_items(actual), message, stack_frame);
571  else
572  assert::succeed(message, stack_frame);
573  }
574 
576  template<typename item_t>
577  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());}
578  template<typename item_t>
579  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);}
580  template<typename item_t>
581  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());}
582  template<typename item_t>
583  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) {
584  if (std::equal(actual.begin(), actual.end(), expected.begin(), expected.end()) == true)
585  base_assert::fail("not " + base_assert::join_items(expected), base_assert::join_items(actual), message, stack_frame);
586  else
587  assert::succeed(message, stack_frame);
588  }
589 
591  template<typename collection_t, typename item_t>
592  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());}
593  template<typename collection_t, typename item_t>
594  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);}
595  template<typename collection_t, typename item_t>
596  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());}
597  template<typename collection_t, typename item_t>
598  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) {
599  if (std::equal(actual.begin(), actual.end(), expected.begin(), expected.end()) == true)
600  base_assert::fail("not " + base_assert::join_items(expected), base_assert::join_items(actual), message, stack_frame);
601  else
602  assert::succeed(message, stack_frame);
603  }
604 
606  template<typename item_t, typename collection_t>
607  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());}
608  template<typename item_t, typename collection_t>
609  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);}
610  template<typename item_t, typename collection_t>
611  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());}
612  template<typename item_t, typename collection_t>
613  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) {
614  if (std::equal(actual.begin(), actual.end(), expected.begin(), expected.end()) == true)
615  base_assert::fail("not " + base_assert::join_items(expected), base_assert::join_items(actual), message, stack_frame);
616  else
617  assert::succeed(message, stack_frame);
618  }
620 
632  template<typename expected_t, typename actual_t>
633  static void are_not_equivalent(const expected_t& expected, const actual_t& actual) {are_not_equivalent(expected, actual, "", xtd::diagnostics::stack_frame::empty());}
634 
646  template<typename expected_t, typename actual_t>
647  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());}
648 
660  template<typename expected_t, typename actual_t>
661  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);}
662 
674  template<typename expected_t, typename actual_t>
675  static void are_not_equivalent(const expected_t& expected, const actual_t& actual, const std::string& message, const xtd::diagnostics::stack_frame& stack_frame) {
676  expected_t expect_sorted = expected;
677  std::sort(expect_sorted.begin(), expect_sorted.end());
678  expected_t actual_sorted = actual;
679  std::sort(actual_sorted.begin(), actual_sorted.end());
680  if (std::equal(actual_sorted.begin(), actual_sorted.end(), expect_sorted.begin(), expect_sorted.end()) == true)
681  base_assert::fail("not equivalent " + base_assert::join_items(expected), base_assert::join_items(actual), message, stack_frame);
682  else
683  assert::succeed(message, stack_frame);
684  }
685 
687  template<typename expected_t, typename actual_t>
688  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());}
689  template<typename expected_t, typename actual_t>
690  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);}
691  template<typename expected_t, typename actual_t>
692  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());}
693  template<typename expected_t, typename actual_t>
694  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) {
695  std::vector<expected_t> expect_sorted = expected;
696  std::sort(expect_sorted.begin(), expect_sorted.end());
697  std::vector<actual_t> actual_sorted = actual;
698  std::sort(actual_sorted.begin(), actual_sorted.end());
699  if (std::equal(actual_sorted.begin(), actual_sorted.end(), expect_sorted.begin(), expect_sorted.end()) == true)
700  base_assert::fail("not equivalent " + base_assert::join_items(expected), base_assert::join_items(actual), message, stack_frame);
701  else
702  assert::succeed(message, stack_frame);
703  }
704 
706  template<typename collection_t, typename item_t>
707  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());}
708  template<typename collection_t, typename item_t>
709  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);}
710  template<typename collection_t, typename item_t>
711  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());}
712  template<typename collection_t, typename item_t>
713  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) {
714  collection_t expect_sorted = expected;
715  std::sort(expect_sorted.begin(), expect_sorted.end());
716  std::vector<item_t> actual_sorted = actual;
717  std::sort(actual_sorted.begin(), actual_sorted.end());
718  if (std::equal(actual_sorted.begin(), actual_sorted.end(), expect_sorted.begin(), expect_sorted.end()) == true)
719  base_assert::fail("not equivalent " + base_assert::join_items(expected), base_assert::join_items(actual), message, stack_frame);
720  else
721  assert::succeed(message, stack_frame);
722  }
723 
725  template<typename item_t, typename collection_t>
726  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());}
727  template<typename item_t, typename collection_t>
728  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);}
729  template<typename item_t, typename collection_t>
730  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());}
731  template<typename item_t, typename collection_t>
732  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) {
733  std::vector<item_t> expect_sorted = expected;
734  std::sort(expect_sorted.begin(), expect_sorted.end());
735  collection_t actual_sorted = actual;
736  std::sort(actual_sorted.begin(), actual_sorted.end());
737  if (std::equal(actual_sorted.begin(), actual_sorted.end(), expect_sorted.begin(), expect_sorted.end()) == true)
738  base_assert::fail("not equivalent " + base_assert::join_items(expected), base_assert::join_items(actual), message, stack_frame);
739  else
740  assert::succeed(message, stack_frame);
741  }
743 
755  template<typename expected_t, typename actual_t>
756  static void contains(const expected_t& expected, const actual_t& actual) {contains(expected, actual, "", xtd::diagnostics::stack_frame::empty());}
757 
769  template<typename expected_t, typename actual_t>
770  static void contains(const expected_t& expected, const actual_t& actual, const std::string& message) {contains(expected, actual, message, xtd::diagnostics::stack_frame::empty());}
771 
783  template<typename expected_t, typename actual_t>
784  static void contains(const expected_t& expected, const actual_t& actual, const xtd::diagnostics::stack_frame& stack_frame) {contains(expected, actual, "", stack_frame);}
785 
797  template<typename expected_t, typename actual_t>
798  static void contains(const expected_t& expected, const actual_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  base_assert::fail("contains " + base_assert::join_items(expected), base_assert::join_items(actual), message, stack_frame);
802  return;
803  }
804  }
805  assert::succeed(message, stack_frame);
806  }
807 
809  template<typename item_t>
810  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());}
811  template<typename item_t>
812  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);}
813  template<typename item_t>
814  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());}
815  template<typename item_t>
816  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) {
817  for (auto item : expected) {
818  if (std::find(actual.begin(), actual.end(), item) == actual.end()) {
819  base_assert::fail("contains " + base_assert::join_items(expected), base_assert::join_items(actual), message, stack_frame);
820  return;
821  }
822  }
823  assert::succeed(message, stack_frame);
824  }
825 
827  template<typename collection_t, typename item_t>
828  static void contains(const collection_t& expected, const std::initializer_list<item_t>& actual) {contains(expected, actual, "", xtd::diagnostics::stack_frame::empty());}
829  template<typename collection_t, typename item_t>
830  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);}
831  template<typename collection_t, typename item_t>
832  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());}
833  template<typename collection_t, typename item_t>
834  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) {
835  for (auto item : expected) {
836  if (std::find(actual.begin(), actual.end(), item) == actual.end()) {
837  base_assert::fail("contains " + base_assert::join_items(expected), base_assert::join_items(actual), message, stack_frame);
838  return;
839  }
840  }
841  assert::succeed(message, stack_frame);
842  }
843 
845  template<typename item_t, typename collection_t>
846  static void contains(const std::initializer_list<item_t>& expected, const collection_t& actual) {contains(expected, actual, "", xtd::diagnostics::stack_frame::empty());}
847  template<typename item_t, typename collection_t>
848  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);}
849  template<typename item_t, typename collection_t>
850  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());}
851  template<typename item_t, typename collection_t>
852  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) {
853  for (auto item : expected) {
854  if (std::find(actual.begin(), actual.end(), item) == actual.end()) {
855  base_assert::fail("contains " + base_assert::join_items(expected), base_assert::join_items(actual), message, stack_frame);
856  return;
857  }
858  }
859  assert::succeed(message, stack_frame);
860  }
862 
874  template<typename expected_t, typename actual_t>
875  static void does_not_contain(const expected_t& expected, const actual_t& actual) {does_not_contain(expected, actual, "", xtd::diagnostics::stack_frame::empty());}
876 
888  template<typename expected_t, typename actual_t>
889  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());}
890 
902  template<typename expected_t, typename actual_t>
903  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);}
904 
916  template<typename expected_t, typename actual_t>
917  static void does_not_contain(const expected_t& expected, const actual_t& actual, const std::string& message, const xtd::diagnostics::stack_frame& stack_frame) {
918  for (auto item : expected) {
919  if (std::find(actual.begin(), actual.end(), item) == actual.end()) {
920  assert::succeed(message, stack_frame);
921  return;
922  }
923  }
924  base_assert::fail("not contains " + base_assert::join_items(expected), base_assert::join_items(actual), message, stack_frame);
925  }
926 
928  template<typename item_t>
929  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());}
930  template<typename item_t>
931  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);}
932  template<typename item_t>
933  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());}
934  template<typename item_t>
935  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) {
936  for (auto item : expected) {
937  if (std::find(actual.begin(), actual.end(), item) == actual.end()) {
938  assert::succeed(message, stack_frame);
939  return;
940  }
941  }
942  base_assert::fail("not contains " + base_assert::join_items(expected), base_assert::join_items(actual), message, stack_frame);
943  }
944 
946  template<typename collection_t, typename item_t>
947  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());}
948  template<typename collection_t, typename item_t>
949  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);}
950  template<typename collection_t, typename item_t>
951  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());}
952  template<typename collection_t, typename item_t>
953  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) {
954  for (auto item : expected) {
955  if (std::find(actual.begin(), actual.end(), item) == actual.end()) {
956  assert::succeed(message, stack_frame);
957  return;
958  }
959  }
960  base_assert::fail("not contains " + base_assert::join_items(expected), base_assert::join_items(actual), message, stack_frame);
961  }
962 
964  template<typename item_t, typename collection_t>
965  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());}
966  template<typename item_t, typename collection_t>
967  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);}
968  template<typename item_t, typename collection_t>
969  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());}
970  template<typename item_t, typename collection_t>
971  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) {
972  for (auto item : expected) {
973  if (std::find(actual.begin(), actual.end(), item) == actual.end()) {
974  assert::succeed(message, stack_frame);
975  return;
976  }
977  }
978  base_assert::fail("not contains " + base_assert::join_items(expected), base_assert::join_items(actual), message, stack_frame);
979  }
981 
992  template<typename value_t>
993  static void is_empty(const value_t& value) {is_empty(value, "", xtd::diagnostics::stack_frame::empty());}
994 
1006  template<typename value_t>
1007  static void is_empty(const value_t& value, const xtd::diagnostics::stack_frame& stack_frame) {is_empty(value, "", stack_frame);}
1008 
1020  template<typename value_t>
1021  static void is_empty(const value_t& value, const std::string& message) {is_empty(value, message, xtd::diagnostics::stack_frame::empty());}
1022 
1035  template<typename value_t>
1036  static void is_empty(const value_t& value, const std::string& message, const xtd::diagnostics::stack_frame& stack_frame) {
1037  if (std::empty(value))
1038  assert::succeed(message, stack_frame);
1039  else
1040  base_assert::fail("<empty>", base_assert::join_items(value), message, stack_frame);
1041  }
1042 
1044  template<typename value_t>
1045  static void is_empty(const std::initializer_list<value_t>& value) {is_empty(value, "", xtd::diagnostics::stack_frame::empty());}
1046  template<typename value_t>
1047  static void is_empty(const std::initializer_list<value_t>& value, const xtd::diagnostics::stack_frame& stack_frame) {is_empty(value, "", stack_frame);}
1048  template<typename value_t>
1049  static void is_empty(const std::initializer_list<value_t>& value, const std::string& message) {is_empty(value, message, xtd::diagnostics::stack_frame::empty());}
1050  template<typename value_t>
1051  static void is_empty(const std::initializer_list<value_t>& value, const std::string& message, const xtd::diagnostics::stack_frame& stack_frame) {
1052  if (std::empty(value))
1053  assert::succeed(message, stack_frame);
1054  else
1055  base_assert::fail("<empty>", base_assert::join_items(value), message, stack_frame);
1056  }
1058 
1069  template<typename value_t>
1070  static void is_not_empty(const value_t& value) {is_not_empty(value, "", xtd::diagnostics::stack_frame::empty());}
1071 
1083  template<typename value_t>
1084  static void is_not_empty(const value_t& value, const xtd::diagnostics::stack_frame& stack_frame) {is_not_empty(value, "", stack_frame);}
1085 
1097  template<typename value_t>
1098  static void is_not_empty(const value_t& value, const std::string& message) {is_not_empty(value, message, xtd::diagnostics::stack_frame::empty());}
1099 
1112  template<typename value_t>
1113  static void is_not_empty(const value_t& value, const std::string& message, const xtd::diagnostics::stack_frame& stack_frame) {
1114  if (!std::empty(value))
1115  assert::succeed(message, stack_frame);
1116  else
1117  base_assert::fail("not <empty>", "<empty>", message, stack_frame);
1118  }
1119 
1121  template<typename value_t>
1122  static void is_not_empty(const std::initializer_list<value_t>& value) {is_not_empty(value, "", xtd::diagnostics::stack_frame::empty());}
1123  template<typename value_t>
1124  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);}
1125  template<typename value_t>
1126  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());}
1127  template<typename value_t>
1128  static void is_not_empty(const std::initializer_list<value_t>& value, const std::string& message, const xtd::diagnostics::stack_frame& stack_frame) {
1129  if (!std::empty(value))
1130  assert::succeed(message, stack_frame);
1131  else
1132  base_assert::fail("not <empty>", "<empty>", message, stack_frame);
1133  }
1135 
1146  template<typename value_t>
1147  static void is_ordered(const value_t& value) {is_ordered(value, "", xtd::diagnostics::stack_frame::empty());}
1148 
1160  template<typename value_t>
1161  static void is_ordered(const value_t& value, const xtd::diagnostics::stack_frame& stack_frame) {is_ordered(value, "", stack_frame);}
1162 
1174  template<typename value_t>
1175  static void is_ordered(const value_t& value, const std::string& message) {is_ordered(value, message, xtd::diagnostics::stack_frame::empty());}
1176 
1189  template<typename value_t>
1190  static void is_ordered(const value_t& value, const std::string& message, const xtd::diagnostics::stack_frame& stack_frame) {
1191  if (std::is_sorted(value.begin(), value.end()))
1192  assert::succeed(message, stack_frame);
1193  else
1194  base_assert::fail("<ordered>", base_assert::join_items(value), message, stack_frame);
1195  }
1196 
1198  template<typename value_t>
1199  static void is_ordered(const std::initializer_list<value_t>& value) {is_ordered(value, "", xtd::diagnostics::stack_frame::empty());}
1200  template<typename value_t>
1201  static void is_ordered(const std::initializer_list<value_t>& value, const xtd::diagnostics::stack_frame& stack_frame) {is_ordered(value, "", stack_frame);}
1202  template<typename value_t>
1203  static void is_ordered(const std::initializer_list<value_t>& value, const std::string& message) {is_ordered(value, message, xtd::diagnostics::stack_frame::empty());}
1204  template<typename value_t>
1205  static void is_ordered(const std::initializer_list<value_t>& value, const std::string& message, const xtd::diagnostics::stack_frame& stack_frame) {
1206  if (std::is_sorted(value.begin(), value.end()))
1207  assert::succeed(message, stack_frame);
1208  else
1209  base_assert::fail("<ordered>", base_assert::join_items(value), message, stack_frame);
1210  }
1212  };
1213  }
1214 }
1215 
1216 #define all_items_are_instances_of_(...) __CMD_ASSERT_ARGS(all_items_are_instances_of, __VA_ARGS__)
1217 
1218 #define all_items_are_not_null_(...) __CMD_ASSERT_ARGS(all_items_are_not_null, __VA_ARGS__)
1219 
1220 #define all_items_are_unique_(...) __CMD_ASSERT_ARGS(all_items_are_unique, __VA_ARGS__)
1221 
1222 #define are_equivalent_(...) __CMD_ASSERT_ARGS(are_equivalent, __VA_ARGS__)
1223 
1224 #define are_not_equivalent_(...) __CMD_ASSERT_ARGS(are_not_equivalent, __VA_ARGS__)
1225 
1226 #define is_ordered_(...) __CMD_ASSERT_ARGS(is_ordered, __VA_ARGS__)
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::base_assert
The base class for assert.
Definition: base_assert.h:25
xtd::tunit::base_assert::fail
static void fail()
Throws an xtd::tunit::assertion_error exception. This is used by the other Assert functions.
Definition: base_assert.h:70
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::collection_assert
The collection_assert class contains a collection of static methods that implement the most collectio...
Definition: collection_assert.h:20
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:1007
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:153
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:675
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:254
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:875
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:647
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:296
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:661
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:52
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:1190
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:224
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:431
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:554
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:1084
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:770
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:1161
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:310
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:1113
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:1098
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:403
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:445
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:903
xtd::tunit::collection_assert::is_ordered
static void is_ordered(const value_t &value)
Asserts that collection is ordered.
Definition: collection_assert.h:1147
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:338
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:239
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:417
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:633
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:784
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:526
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:1036
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:137
xtd::tunit::collection_assert::is_empty
static void is_empty(const value_t &value)
Asserts that collection contains an item.
Definition: collection_assert.h:993
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:80
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:66
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:540
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:756
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:798
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:324
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:1175
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:38
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:1070
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:917
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:121
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:889
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:568
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:1021
xtd
The xtd namespace contains all fundamental classes to access Hardware, Os, System,...
Definition: system_report.h:17
Generated on Mon Jul 17 2023 23:13:06 for xtd - Reference Guide by Gammasoft. All rights reserved.