xtd 0.2.0
collection_assert.h
Go to the documentation of this file.
1 #pragma once
5 #include "assert.h"
6 
8 namespace 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::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::base_assert
The base class for assert.
Definition: base_assert.h:29
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::is_ordered
static void is_ordered(const value_t &value)
Asserts that collection is ordered.
Definition: collection_assert.h:1096
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::base_assert::succeed
static void succeed()
Generates a success with a generic message. This is used by the other assert functions.
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::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::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::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::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
The xtd namespace contains all fundamental classes to access Hardware, Os, System, and more.
Definition: system_report.h:17
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::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::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::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::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::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::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::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::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, const xtd::diagnostics::stack_frame &stack_frame)
Asserts that all collection items are not equivalent.
Definition: collection_assert.h:635
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::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_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::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::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::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::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::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_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::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::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
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::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::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::diagnostics::stack_frame::empty
static stack_frame empty() noexcept
Return an empty stack frame.
assert.h
Contains xtd::tunit::assert class.
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
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_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::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::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::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::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_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::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::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::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::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::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::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::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::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
Generated on Mon Oct 9 2023 14:41:59 for xtd by Gammasoft. All rights reserved.