tunit - Reference Guide  1.0.0
Modern c++17 unit testing framework on Windows, macOS, Linux, iOS and android.
collection_assert.h
Go to the documentation of this file.
1 #pragma once
4 #include "assert.h"
5 
7 namespace tunit {
12  class collection_assert final : private base_assert {
13  public:
15  collection_assert() = delete;
17 
29  template<typename TExpected, typename TCollection>
30  static void all_items_are_instances_of(const TCollection& collection) {all_items_are_instances_of<TExpected>(collection, "", line_info());}
31 
43  template<typename TExpected, typename TCollection>
44  static void all_items_are_instances_of(const TCollection& collection, const std::string& message) {all_items_are_instances_of<TExpected>(collection, message, line_info());}
45 
57  template<typename TExpected, typename TCollection>
58  static void all_items_are_instances_of(const TCollection& collection, const tunit::line_info& line_info) {all_items_are_instances_of<TExpected>(collection, "", line_info);}
59 
71  template<typename TExpected, typename TCollection>
72  static void all_items_are_instances_of(const TCollection& collection, const std::string& message, const tunit::line_info& line_info) {
73  for (auto item : collection)
74  if (dynamic_cast<TExpected>(item) == nullptr) {
75  base_assert::fail("all items instance of <" + __tunit_demangle(typeid(TExpected).name()) + ">", base_assert::join_items(collection), message, line_info);
76  return;
77  }
78  assert::succeed(message, line_info);
79  }
80 
82  template<typename TExpected, typename TItem>
83  static void all_items_are_instances_of(const std::initializer_list<TItem>& collection) {all_items_are_instances_of<TExpected>(collection, "", line_info());}
84  template<typename TExpected, typename TItem>
85  static void all_items_are_instances_of(const std::initializer_list<TItem>& collection, const std::string& message) {all_items_are_instances_of<TExpected>(collection, message, line_info());}
86  template<typename TExpected, typename TItem>
87  static void all_items_are_instances_of(const std::initializer_list<TItem>& collection, const tunit::line_info& line_info) {all_items_are_instances_of<TExpected>(collection, "", line_info);}
88  template<typename TExpected, typename TItem>
89  static void all_items_are_instances_of(const std::initializer_list<TItem>& collection, const std::string& message, const tunit::line_info& line_info) {
90  for (auto item : collection)
91  if (dynamic_cast<TExpected>(item) == nullptr) {
92  base_assert::fail("all items instance of <" + __tunit_demangle(typeid(TExpected).name()) + ">", base_assert::join_items(collection), message, line_info);
93  return;
94  }
95  assert::succeed(message, line_info);
96  }
98 
112  template<typename TCollection>
113  static void all_items_are_not_null(const TCollection& collection) {all_items_are_not_null(collection, "", line_info());}
114 
128  template<typename TCollection>
129  static void all_items_are_not_null(const TCollection& collection, const std::string& message) {all_items_are_not_null(collection, message, line_info());}
130 
144  template<typename TCollection>
145  static void all_items_are_not_null(const TCollection& collection, const tunit::line_info& line_info) {all_items_are_instances_of(collection, "", line_info);}
146 
160  template<typename TCollection>
161  static void all_items_are_not_null(const TCollection& collection, const std::string& message, const tunit::line_info& line_info) {
162  for (auto item : collection)
163  if (item == nullptr) {
164  base_assert::fail("all items are not null", base_assert::join_items(collection), message, line_info);
165  return;
166  }
167  assert::succeed(message, line_info);
168  }
169 
171  template<typename TItem>
172  static void all_items_are_not_null(const std::initializer_list<TItem>& collection) {all_items_are_not_null(collection, "", line_info());}
173  template<typename TItem>
174  static void all_items_are_not_null(const std::initializer_list<TItem>& collection, const std::string& message) {all_items_are_not_null(collection, message, line_info());}
175  template<typename TItem>
176  static void all_items_are_not_null(const std::initializer_list<TItem>& collection, const tunit::line_info& line_info) {all_items_are_instances_of(collection, "", line_info);}
177  template<typename TItem>
178  static void all_items_are_not_null(const std::initializer_list<TItem>& collection, const std::string& message, const tunit::line_info& line_info) {
179  for (auto item : collection)
180  if (item == nullptr) {
181  base_assert::fail("all items are not null", base_assert::join_items(collection), message, line_info);
182  return;
183  }
184  assert::succeed(message, line_info);
185  }
187 
200  template<typename TCollection>
201  static void all_items_are_unique(const TCollection& collection) {all_items_are_unique(collection, "", line_info());}
202 
215  template<typename TCollection>
216  static void all_items_are_unique(const TCollection& collection, const std::string& message) {all_items_are_unique(collection, message, line_info());}
217 
230  template<typename TCollection>
231  static void all_items_are_unique(const TCollection& collection, const tunit::line_info& line_info) {all_items_are_unique(collection, "", line_info);}
232 
245  template<typename TCollection>
246  static void all_items_are_unique(const TCollection& collection, const std::string& message, const tunit::line_info& line_info) {
247  auto value = *collection.cbegin();
248  std::map<decltype(value), int> counts;
249  for (auto item : collection) {
250  auto result = counts.insert(std::pair<decltype(item), int>(item, 1));
251  if (result.second == false)
252  base_assert::fail("all items are unqiue", base_assert::join_items(collection), message, line_info);
253  }
254  assert::succeed(message, line_info);
255  }
256 
258  template<typename TItem>
259  static void all_items_are_unique(const std::initializer_list<TItem>& collection) {all_items_are_unique(collection, "", line_info());}
260  template<typename TItem>
261  static void all_items_are_unique(const std::initializer_list<TItem>& collection, const tunit::line_info& line_info) {all_items_are_unique(collection, "", line_info);}
262  template<typename TItem>
263  static void all_items_are_unique(const std::initializer_list<TItem>& collection, const std::string& message) {all_items_are_unique(collection, message, line_info());}
264  template<typename TItem>
265  static void all_items_are_unique(const std::initializer_list<TItem>& collection, const std::string& message, const tunit::line_info& line_info) {
266  std::map<TItem, int> counts;
267  for (auto item : collection) {
268  auto result = counts.insert(std::pair<TItem, int>(item, 1));
269  if (result.second == false)
270  base_assert::fail("all items are unqiue", base_assert::join_items(collection), message, line_info);
271  }
272  assert::succeed(message, line_info);
273  }
275 
287  template<typename TExpected, typename TAcutal>
288  static void are_equal(const TExpected& expected, const TAcutal& actual) {are_equal(expected, actual, "", line_info());}
289 
301  template<typename TExpected, typename TAcutal>
302  static void are_equal(const TExpected& expected, const TAcutal& actual, const std::string& message) {are_equal(expected, actual, message, line_info());}
303 
315  template<typename TExpected, typename TAcutal>
316  static void are_equal(const TExpected& expected, const TAcutal& actual, const tunit::line_info& line_info) {are_equal(expected, actual, "", line_info);}
317 
329  template<typename TExpected, typename TAcutal>
330  static void are_equal(const TExpected& expected, const TAcutal& actual, const std::string& message, const tunit::line_info& line_info) {
331  if (std::equal(expected.begin(), expected.end(), actual.begin(), actual.end()) == false)
332  base_assert::fail(base_assert::join_items(expected), base_assert::join_items(actual), message, line_info);
333  else
334  assert::succeed(message, line_info);
335  }
336 
338  template<typename TItem>
339  static void are_equal(const std::initializer_list<TItem>& expected, const std::initializer_list<TItem>& actual) {are_equal(expected, actual, "", line_info());}
340  template<typename TItem>
341  static void are_equal(const std::initializer_list<TItem>& expected, const std::initializer_list<TItem>& actual, const tunit::line_info& line_info) {are_equal(expected, actual, "", line_info);}
342  template<typename TItem>
343  static void are_equal(const std::initializer_list<TItem>& expected, const std::initializer_list<TItem>& actual, const std::string& message) {are_equal(expected, actual, message, line_info());}
344  template<typename TItem>
345  static void are_equal(const std::initializer_list<TItem>& expected, const std::initializer_list<TItem>& actual, const std::string& message, const tunit::line_info& line_info) {
346  if (std::equal(expected.begin(), expected.end(), actual.begin(), actual.end()) == false)
347  base_assert::fail(base_assert::join_items(expected), base_assert::join_items(actual), message, line_info);
348  else
349  assert::succeed(message, line_info);
350  }
351 
353  template<typename TCollection, typename TItem>
354  static void are_equal(const TCollection& expected, const std::initializer_list<TItem>& actual) {are_equal(expected, actual, "", line_info());}
355  template<typename TCollection, typename TItem>
356  static void are_equal(const TCollection& expected, const std::initializer_list<TItem>& actual, const tunit::line_info& line_info) {are_equal(expected, actual, "", line_info);}
357  template<typename TCollection, typename TItem>
358  static void are_equal(const TCollection& expected, const std::initializer_list<TItem>& actual, const std::string& message) {are_equal(expected, actual, message, line_info());}
359  template<typename TCollection, typename TItem>
360  static void are_equal(const TCollection& expected, const std::initializer_list<TItem>& actual, const std::string& message, const tunit::line_info& line_info) {
361  if (std::equal(expected.begin(), expected.end(), actual.begin(), actual.end()) == false)
362  base_assert::fail(base_assert::join_items(expected), base_assert::join_items(actual), message, line_info);
363  else
364  assert::succeed(message, line_info);
365  }
366 
368  template<typename TItem, typename TCollection>
369  static void are_equal(const std::initializer_list<TItem>& expected, const TCollection& actual) {are_equal(expected, actual, "", line_info());}
370  template<typename TItem, typename TCollection>
371  static void are_equal(const std::initializer_list<TItem>& expected, const TCollection& actual, const tunit::line_info& line_info) {are_equal(expected, actual, "", line_info);}
372  template<typename TItem, typename TCollection>
373  static void are_equal(const std::initializer_list<TItem>& expected, const TCollection& actual, const std::string& message) {are_equal(expected, actual, message, line_info());}
374  template<typename TItem, typename TCollection>
375  static void are_equal(const std::initializer_list<TItem>& expected, const TCollection& actual, const std::string& message, const tunit::line_info& line_info) {
376  if (std::equal(expected.begin(), expected.end(), actual.begin(), actual.end()) == false)
377  base_assert::fail(base_assert::join_items(expected), base_assert::join_items(actual), message, line_info);
378  else
379  assert::succeed(message, line_info);
380  }
382 
394  template<typename TExpected, typename TAcutal>
395  static void are_equivalent(const TExpected& expected, const TAcutal& actual) {are_equivalent(expected, actual, "", line_info());}
396 
408  template<typename TExpected, typename TAcutal>
409  static void are_equivalent(const TExpected& expected, const TAcutal& actual, const std::string& message) {are_equivalent(expected, actual, message, line_info());}
410 
422  template<typename TExpected, typename TAcutal>
423  static void are_equivalent(const TExpected& expected, const TAcutal& actual, const tunit::line_info& line_info) {are_equivalent(expected, actual, "", line_info);}
424 
436  template<typename TExpected, typename TAcutal>
437  static void are_equivalent(const TExpected& expected, const TAcutal& actual, const std::string& message, const tunit::line_info& line_info) {
438  TExpected expect_sorted = expected;
439  std::sort(expect_sorted.begin(), expect_sorted.end());
440  TExpected actual_sorted = actual;
441  std::sort(actual_sorted.begin(), actual_sorted.end());
442  if (std::equal(expect_sorted.begin(), expect_sorted.end(), actual_sorted.begin(), actual_sorted.end()) == false)
443  base_assert::fail("equivalent " + base_assert::join_items(expected), base_assert::join_items(actual), message, line_info);
444  else
445  assert::succeed(message, line_info);
446  }
447 
449  template<typename TExpected, typename TActual>
450  static void are_equivalent(const std::initializer_list<TExpected>& expected, const std::initializer_list<TActual>& actual) {are_equivalent(expected, actual, "", line_info());}
451  template<typename TExpected, typename TActual>
452  static void are_equivalent(const std::initializer_list<TExpected>& expected, const std::initializer_list<TActual>& actual, const tunit::line_info& line_info) {are_equivalent(expected, actual, "", line_info);}
453  template<typename TExpected, typename TActual>
454  static void are_equivalent(const std::initializer_list<TExpected>& expected, const std::initializer_list<TActual>& actual, const std::string& message) {are_equal(are_equivalent, actual, message, line_info());}
455  template<typename TExpected, typename TActual>
456  static void are_equivalent(const std::initializer_list<TExpected>& expected, const std::initializer_list<TActual>& actual, const std::string& message, const tunit::line_info& line_info) {
457  std::vector<TExpected> expect_sorted = expected;
458  std::sort(expect_sorted.begin(), expect_sorted.end());
459  std::vector<TActual> actual_sorted = actual;
460  std::sort(actual_sorted.begin(), actual_sorted.end());
461  if (std::equal(expect_sorted.begin(), expect_sorted.end(), actual_sorted.begin(), actual_sorted.end()) == false)
462  base_assert::fail("equivalent " + base_assert::join_items(expected), base_assert::join_items(actual), message, line_info);
463  else
464  assert::succeed(message, line_info);
465  }
466 
468  template<typename TCollection, typename TItem>
469  static void are_equivalent(const TCollection& expected, const std::initializer_list<TItem>& actual) {are_equivalent(expected, actual, "", line_info());}
470  template<typename TCollection, typename TItem>
471  static void are_equivalent(const TCollection& expected, const std::initializer_list<TItem>& actual, const tunit::line_info& line_info) {are_equivalent(expected, actual, "", line_info);}
472  template<typename TCollection, typename TItem>
473  static void are_equivalent(const TCollection& expected, const std::initializer_list<TItem>& actual, const std::string& message) {are_equivalent(expected, actual, message, line_info());}
474  template<typename TCollection, typename TItem>
475  static void are_equivalent(const TCollection& expected, const std::initializer_list<TItem>& actual, const std::string& message, const tunit::line_info& line_info) {
476  TCollection expect_sorted = expected;
477  std::sort(expect_sorted.begin(), expect_sorted.end());
478  std::vector<TItem> actual_sorted = actual;
479  std::sort(actual_sorted.begin(), actual_sorted.end());
480  if (std::equal(expect_sorted.begin(), expect_sorted.end(), actual_sorted.begin(), actual_sorted.end()) == false)
481  base_assert::fail("equivalent " + base_assert::join_items(expected), base_assert::join_items(actual), message, line_info);
482  else
483  assert::succeed(message, line_info);
484  }
485 
487  template<typename TItem, typename TCollection>
488  static void are_equivalent(const std::initializer_list<TItem>& expected, const TCollection& actual) {are_equivalent(expected, actual, "", line_info());}
489  template<typename TItem, typename TCollection>
490  static void are_equivalent(const std::initializer_list<TItem>& expected, const TCollection& actual, const tunit::line_info& line_info) {are_equivalent(expected, actual, "", line_info);}
491  template<typename TItem, typename TCollection>
492  static void are_equivalent(const std::initializer_list<TItem>& expected, const TCollection& actual, const std::string& message) {are_equivalent(expected, actual, message, line_info());}
493  template<typename TItem, typename TCollection>
494  static void are_equivalent(const std::initializer_list<TItem>& expected, const TCollection& actual, const std::string& message, const tunit::line_info& line_info) {
495  std::vector<TItem> expect_sorted = expected;
496  std::sort(expect_sorted.begin(), expect_sorted.end());
497  TCollection actual_sorted = actual;
498  std::sort(actual_sorted.begin(), actual_sorted.end());
499  if (std::equal(expect_sorted.begin(), expect_sorted.end(), actual_sorted.begin(), actual_sorted.end()) == false)
500  base_assert::fail("equivalent " + base_assert::join_items(expected), base_assert::join_items(actual), message, line_info);
501  else
502  assert::succeed(message, line_info);
503  }
505 
517  template<typename TExpected, typename TAcutal>
518  static void are_not_equal(const TExpected& expected, const TAcutal& actual) {are_not_equal(expected, actual, "", line_info());}
519 
531  template<typename TExpected, typename TAcutal>
532  static void are_not_equal(const TExpected& expected, const TAcutal& actual, const std::string& message) {are_not_equal(expected, actual, message, line_info());}
533 
545  template<typename TExpected, typename TAcutal>
546  static void are_not_equal(const TExpected& expected, const TAcutal& actual, const tunit::line_info& line_info) {are_not_equal(expected, actual, "", line_info);}
547 
559  template<typename TExpected, typename TAcutal>
560  static void are_not_equal(const TExpected& expected, const TAcutal& actual, const std::string& message, const tunit::line_info& line_info) {
561  if (std::equal(expected.begin(), expected.end(), actual.begin(), actual.end()) == true)
562  base_assert::fail("not " + base_assert::join_items(expected), base_assert::join_items(actual), message, line_info);
563  else
564  assert::succeed(message, line_info);
565  }
566 
568  template<typename TItem>
569  static void are_not_equal(const std::initializer_list<TItem>& expected, const std::initializer_list<TItem>& actual) {are_not_equal(expected, actual, "", line_info());}
570  template<typename TItem>
571  static void are_not_equal(const std::initializer_list<TItem>& expected, const std::initializer_list<TItem>& actual, const tunit::line_info& line_info) {are_not_equal(expected, actual, "", line_info);}
572  template<typename TItem>
573  static void are_not_equal(const std::initializer_list<TItem>& expected, const std::initializer_list<TItem>& actual, const std::string& message) {are_not_equal(expected, actual, message, line_info());}
574  template<typename TItem>
575  static void are_not_equal(const std::initializer_list<TItem>& expected, const std::initializer_list<TItem>& actual, const std::string& message, const tunit::line_info& line_info) {
576  if (std::equal(expected.begin(), expected.end(), actual.begin(), actual.end()) == true)
577  base_assert::fail("not " + base_assert::join_items(expected), base_assert::join_items(actual), message, line_info);
578  else
579  assert::succeed(message, line_info);
580  }
581 
583  template<typename TCollection, typename TItem>
584  static void are_not_equal(const TCollection& expected, const std::initializer_list<TItem>& actual) {are_not_equal(expected, actual, "", line_info());}
585  template<typename TCollection, typename TItem>
586  static void are_not_equal(const TCollection& expected, const std::initializer_list<TItem>& actual, const tunit::line_info& line_info) {are_not_equal(expected, actual, "", line_info);}
587  template<typename TCollection, typename TItem>
588  static void are_not_equal(const TCollection& expected, const std::initializer_list<TItem>& actual, const std::string& message) {are_not_equal(expected, actual, message, line_info());}
589  template<typename TCollection, typename TItem>
590  static void are_not_equal(const TCollection& expected, const std::initializer_list<TItem>& actual, const std::string& message, const tunit::line_info& line_info) {
591  if (std::equal(expected.begin(), expected.end(), actual.begin(), actual.end()) == true)
592  base_assert::fail("not " + base_assert::join_items(expected), base_assert::join_items(actual), message, line_info);
593  else
594  assert::succeed(message, line_info);
595  }
596 
598  template<typename TItem, typename TCollection>
599  static void are_not_equal(const std::initializer_list<TItem>& expected, const TCollection& actual) {are_not_equal(expected, actual, "", line_info());}
600  template<typename TItem, typename TCollection>
601  static void are_not_equal(const std::initializer_list<TItem>& expected, const TCollection& actual, const tunit::line_info& line_info) {are_not_equal(expected, actual, "", line_info);}
602  template<typename TItem, typename TCollection>
603  static void are_not_equal(const std::initializer_list<TItem>& expected, const TCollection& actual, const std::string& message) {are_not_equal(expected, actual, message, line_info());}
604  template<typename TItem, typename TCollection>
605  static void are_not_equal(const std::initializer_list<TItem>& expected, const TCollection& actual, const std::string& message, const tunit::line_info& line_info) {
606  if (std::equal(expected.begin(), expected.end(), actual.begin(), actual.end()) == true)
607  base_assert::fail("not " + base_assert::join_items(expected), base_assert::join_items(actual), message, line_info);
608  else
609  assert::succeed(message, line_info);
610  }
612 
624  template<typename TExpected, typename TAcutal>
625  static void are_not_equivalent(const TExpected& expected, const TAcutal& actual) {are_not_equivalent(expected, actual, "", line_info());}
626 
638  template<typename TExpected, typename TAcutal>
639  static void are_not_equivalent(const TExpected& expected, const TAcutal& actual, const std::string& message) {are_not_equivalent(expected, actual, message, line_info());}
640 
652  template<typename TExpected, typename TAcutal>
653  static void are_not_equivalent(const TExpected& expected, const TAcutal& actual, const tunit::line_info& line_info) {are_not_equivalent(expected, actual, "", line_info);}
654 
666  template<typename TExpected, typename TAcutal>
667  static void are_not_equivalent(const TExpected& expected, const TAcutal& actual, const std::string& message, const tunit::line_info& line_info) {
668  TExpected expect_sorted = expected;
669  std::sort(expect_sorted.begin(), expect_sorted.end());
670  TExpected actual_sorted = actual;
671  std::sort(actual_sorted.begin(), actual_sorted.end());
672  if (std::equal(expect_sorted.begin(), expect_sorted.end(), actual_sorted.begin(), actual_sorted.end()) == true)
673  base_assert::fail("not equivalent " + base_assert::join_items(expected), base_assert::join_items(actual), message, line_info);
674  else
675  assert::succeed(message, line_info);
676  }
677 
679  template<typename TExpected, typename TActual>
680  static void are_not_equivalent(const std::initializer_list<TExpected>& expected, const std::initializer_list<TActual>& actual) {are_not_equivalent(expected, actual, "", line_info());}
681  template<typename TExpected, typename TActual>
682  static void are_not_equivalent(const std::initializer_list<TExpected>& expected, const std::initializer_list<TActual>& actual, const tunit::line_info& line_info) {are_not_equivalent(expected, actual, "", line_info);}
683  template<typename TExpected, typename TActual>
684  static void are_not_equivalent(const std::initializer_list<TExpected>& expected, const std::initializer_list<TActual>& actual, const std::string& message) {are_not_equivalent(are_equivalent, actual, message, line_info());}
685  template<typename TExpected, typename TActual>
686  static void are_not_equivalent(const std::initializer_list<TExpected>& expected, const std::initializer_list<TActual>& actual, const std::string& message, const tunit::line_info& line_info) {
687  std::vector<TExpected> expect_sorted = expected;
688  std::sort(expect_sorted.begin(), expect_sorted.end());
689  std::vector<TActual> actual_sorted = actual;
690  std::sort(actual_sorted.begin(), actual_sorted.end());
691  if (std::equal(expect_sorted.begin(), expect_sorted.end(), actual_sorted.begin(), actual_sorted.end()) == true)
692  base_assert::fail("not equivalent " + base_assert::join_items(expected), base_assert::join_items(actual), message, line_info);
693  else
694  assert::succeed(message, line_info);
695  }
696 
698  template<typename TCollection, typename TItem>
699  static void are_not_equivalent(const TCollection& expected, const std::initializer_list<TItem>& actual) {are_not_equivalent(expected, actual, "", line_info());}
700  template<typename TCollection, typename TItem>
701  static void are_not_equivalent(const TCollection& expected, const std::initializer_list<TItem>& actual, const tunit::line_info& line_info) {are_not_equivalent(expected, actual, "", line_info);}
702  template<typename TCollection, typename TItem>
703  static void are_not_equivalent(const TCollection& expected, const std::initializer_list<TItem>& actual, const std::string& message) {are_not_equivalent(expected, actual, message, line_info());}
704  template<typename TCollection, typename TItem>
705  static void are_not_equivalent(const TCollection& expected, const std::initializer_list<TItem>& actual, const std::string& message, const tunit::line_info& line_info) {
706  TCollection expect_sorted = expected;
707  std::sort(expect_sorted.begin(), expect_sorted.end());
708  std::vector<TItem> actual_sorted = actual;
709  std::sort(actual_sorted.begin(), actual_sorted.end());
710  if (std::equal(expect_sorted.begin(), expect_sorted.end(), actual_sorted.begin(), actual_sorted.end()) == true)
711  base_assert::fail("not equivalent " + base_assert::join_items(expected), base_assert::join_items(actual), message, line_info);
712  else
713  assert::succeed(message, line_info);
714  }
715 
717  template<typename TItem, typename TCollection>
718  static void are_not_equivalent(const std::initializer_list<TItem>& expected, const TCollection& actual) {are_not_equivalent(expected, actual, "", line_info());}
719  template<typename TItem, typename TCollection>
720  static void are_not_equivalent(const std::initializer_list<TItem>& expected, const TCollection& actual, const tunit::line_info& line_info) {are_not_equivalent(expected, actual, "", line_info);}
721  template<typename TItem, typename TCollection>
722  static void are_not_equivalent(const std::initializer_list<TItem>& expected, const TCollection& actual, const std::string& message) {are_not_equivalent(expected, actual, message, line_info());}
723  template<typename TItem, typename TCollection>
724  static void are_not_equivalent(const std::initializer_list<TItem>& expected, const TCollection& actual, const std::string& message, const tunit::line_info& line_info) {
725  std::vector<TItem> expect_sorted = expected;
726  std::sort(expect_sorted.begin(), expect_sorted.end());
727  TCollection actual_sorted = actual;
728  std::sort(actual_sorted.begin(), actual_sorted.end());
729  if (std::equal(expect_sorted.begin(), expect_sorted.end(), actual_sorted.begin(), actual_sorted.end()) == true)
730  base_assert::fail("not equivalent " + base_assert::join_items(expected), base_assert::join_items(actual), message, line_info);
731  else
732  assert::succeed(message, line_info);
733  }
735 
747  template<typename TExpected, typename TAcutal>
748  static void contains(const TExpected& expected, const TAcutal& actual) {contains(expected, actual, "", line_info());}
749 
761  template<typename TExpected, typename TAcutal>
762  static void contains(const TExpected& expected, const TAcutal& actual, const std::string& message) {contains(expected, actual, message, line_info());}
763 
775  template<typename TExpected, typename TAcutal>
776  static void contains(const TExpected& expected, const TAcutal& actual, const tunit::line_info& line_info) {contains(expected, actual, "", line_info);}
777 
789  template<typename TExpected, typename TAcutal>
790  static void contains(const TExpected& expected, const TAcutal& actual, const std::string& message, const tunit::line_info& line_info) {
791  for (auto item : expected) {
792  if (std::find(actual.begin(), actual.end(), item) == actual.end()) {
793  base_assert::fail("contains " + base_assert::join_items(expected), base_assert::join_items(actual), message, line_info);
794  return;
795  }
796  }
797  assert::succeed(message, line_info);
798  }
799 
801  template<typename TItem>
802  static void contains(const std::initializer_list<TItem>& expected, const std::initializer_list<TItem>& actual) {contains(expected, actual, "", line_info());}
803  template<typename TItem>
804  static void contains(const std::initializer_list<TItem>& expected, const std::initializer_list<TItem>& actual, const tunit::line_info& line_info) {contains(expected, actual, "", line_info);}
805  template<typename TItem>
806  static void contains(const std::initializer_list<TItem>& expected, const std::initializer_list<TItem>& actual, const std::string& message) {contains(expected, actual, message, line_info());}
807  template<typename TItem>
808  static void contains(const std::initializer_list<TItem>& expected, const std::initializer_list<TItem>& actual, const std::string& message, const tunit::line_info& line_info) {
809  for (auto item : expected) {
810  if (std::find(actual.begin(), actual.end(), item) == actual.end()) {
811  base_assert::fail("contains " + base_assert::join_items(expected), base_assert::join_items(actual), message, line_info);
812  return;
813  }
814  }
815  assert::succeed(message, line_info);
816  }
817 
819  template<typename TCollection, typename TItem>
820  static void contains(const TCollection& expected, const std::initializer_list<TItem>& actual) {contains(expected, actual, "", line_info());}
821  template<typename TCollection, typename TItem>
822  static void contains(const TCollection& expected, const std::initializer_list<TItem>& actual, const tunit::line_info& line_info) {contains(expected, actual, "", line_info);}
823  template<typename TCollection, typename TItem>
824  static void contains(const TCollection& expected, const std::initializer_list<TItem>& actual, const std::string& message) {contains(expected, actual, message, line_info());}
825  template<typename TCollection, typename TItem>
826  static void contains(const TCollection& expected, const std::initializer_list<TItem>& actual, const std::string& message, const tunit::line_info& line_info) {
827  for (auto item : expected) {
828  if (std::find(actual.begin(), actual.end(), item) == actual.end()) {
829  base_assert::fail("contains " + base_assert::join_items(expected), base_assert::join_items(actual), message, line_info);
830  return;
831  }
832  }
833  assert::succeed(message, line_info);
834  }
835 
837  template<typename TItem, typename TCollection>
838  static void contains(const std::initializer_list<TItem>& expected, const TCollection& actual) {contains(expected, actual, "", line_info());}
839  template<typename TItem, typename TCollection>
840  static void contains(const std::initializer_list<TItem>& expected, const TCollection& actual, const tunit::line_info& line_info) {contains(expected, actual, "", line_info);}
841  template<typename TItem, typename TCollection>
842  static void contains(const std::initializer_list<TItem>& expected, const TCollection& actual, const std::string& message) {contains(expected, actual, message, line_info());}
843  template<typename TItem, typename TCollection>
844  static void contains(const std::initializer_list<TItem>& expected, const TCollection& actual, const std::string& message, const tunit::line_info& line_info) {
845  for (auto item : expected) {
846  if (std::find(actual.begin(), actual.end(), item) == actual.end()) {
847  base_assert::fail("contains " + base_assert::join_items(expected), base_assert::join_items(actual), message, line_info);
848  return;
849  }
850  }
851  assert::succeed(message, line_info);
852  }
854 
866  template<typename TExpected, typename TAcutal>
867  static void does_not_contain(const TExpected& expected, const TAcutal& actual) {does_not_contain(expected, actual, "", line_info());}
868 
880  template<typename TExpected, typename TAcutal>
881  static void does_not_contain(const TExpected& expected, const TAcutal& actual, const std::string& message) {does_not_contain(expected, actual, message, line_info());}
882 
894  template<typename TExpected, typename TAcutal>
895  static void does_not_contain(const TExpected& expected, const TAcutal& actual, const tunit::line_info& line_info) {does_not_contain(expected, actual, "", line_info);}
896 
908  template<typename TExpected, typename TAcutal>
909  static void does_not_contain(const TExpected& expected, const TAcutal& actual, const std::string& message, const tunit::line_info& line_info) {
910  for (auto item : expected) {
911  if (std::find(actual.begin(), actual.end(), item) == actual.end()) {
912  assert::succeed(message, line_info);
913  return;
914  }
915  }
916  base_assert::fail("not contains " + base_assert::join_items(expected), base_assert::join_items(actual), message, line_info);
917  }
918 
920  template<typename TItem>
921  static void does_not_contain(const std::initializer_list<TItem>& expected, const std::initializer_list<TItem>& actual) {does_not_contain(expected, actual, "", line_info());}
922  template<typename TItem>
923  static void does_not_contain(const std::initializer_list<TItem>& expected, const std::initializer_list<TItem>& actual, const tunit::line_info& line_info) {does_not_contain(expected, actual, "", line_info);}
924  template<typename TItem>
925  static void does_not_contain(const std::initializer_list<TItem>& expected, const std::initializer_list<TItem>& actual, const std::string& message) {does_not_contain(expected, actual, message, line_info());}
926  template<typename TItem>
927  static void does_not_contain(const std::initializer_list<TItem>& expected, const std::initializer_list<TItem>& actual, const std::string& message, const tunit::line_info& line_info) {
928  for (auto item : expected) {
929  if (std::find(actual.begin(), actual.end(), item) == actual.end()) {
930  assert::succeed(message, line_info);
931  return;
932  }
933  }
934  base_assert::fail("not contains " + base_assert::join_items(expected), base_assert::join_items(actual), message, line_info);
935  }
936 
938  template<typename TCollection, typename TItem>
939  static void does_not_contain(const TCollection& expected, const std::initializer_list<TItem>& actual) {does_not_contain(expected, actual, "", line_info());}
940  template<typename TCollection, typename TItem>
941  static void does_not_contain(const TCollection& expected, const std::initializer_list<TItem>& actual, const tunit::line_info& line_info) {does_not_contain(expected, actual, "", line_info);}
942  template<typename TCollection, typename TItem>
943  static void does_not_contain(const TCollection& expected, const std::initializer_list<TItem>& actual, const std::string& message) {does_not_contain(expected, actual, message, line_info());}
944  template<typename TCollection, typename TItem>
945  static void does_not_contain(const TCollection& expected, const std::initializer_list<TItem>& actual, const std::string& message, const tunit::line_info& line_info) {
946  for (auto item : expected) {
947  if (std::find(actual.begin(), actual.end(), item) == actual.end()) {
948  assert::succeed(message, line_info);
949  return;
950  }
951  }
952  base_assert::fail("not contains " + base_assert::join_items(expected), base_assert::join_items(actual), message, line_info);
953  }
954 
956  template<typename TItem, typename TCollection>
957  static void does_not_contain(const std::initializer_list<TItem>& expected, const TCollection& actual) {does_not_contain(expected, actual, "", line_info());}
958  template<typename TItem, typename TCollection>
959  static void does_not_contain(const std::initializer_list<TItem>& expected, const TCollection& actual, const tunit::line_info& line_info) {does_not_contain(expected, actual, "", line_info);}
960  template<typename TItem, typename TCollection>
961  static void does_not_contain(const std::initializer_list<TItem>& expected, const TCollection& actual, const std::string& message) {does_not_contain(expected, actual, message, line_info());}
962  template<typename TItem, typename TCollection>
963  static void does_not_contain(const std::initializer_list<TItem>& expected, const TCollection& actual, const std::string& message, const tunit::line_info& line_info) {
964  for (auto item : expected) {
965  if (std::find(actual.begin(), actual.end(), item) == actual.end()) {
966  assert::succeed(message, line_info);
967  return;
968  }
969  }
970  base_assert::fail("not contains " + base_assert::join_items(expected), base_assert::join_items(actual), message, line_info);
971  }
973 
984  template<typename TValue>
985  static void is_empty(const TValue& value) {is_empty(value, "", line_info());}
986 
998  template<typename TValue>
999  static void is_empty(const TValue& value, const tunit::line_info& line_info) {is_empty(value, "", line_info);}
1000 
1012  template<typename TValue>
1013  static void is_empty(const TValue& value, const std::string& message) {is_empty(value, message, line_info());}
1014 
1027  template<typename TValue>
1028  static void is_empty(const TValue& value, const std::string& message, const tunit::line_info& line_info) {
1029  if (std::empty(value))
1030  assert::succeed(message, line_info);
1031  else
1032  base_assert::fail("<empty>", base_assert::join_items(value), message, line_info);
1033  }
1034 
1036  template<typename TValue>
1037  static void is_empty(const std::initializer_list<TValue>& value) {is_empty(value, "", line_info());}
1038  template<typename TValue>
1039  static void is_empty(const std::initializer_list<TValue>& value, const tunit::line_info& line_info) {is_empty(value, "", line_info);}
1040  template<typename TValue>
1041  static void is_empty(const std::initializer_list<TValue>& value, const std::string& message) {is_empty(value, message, line_info());}
1042  template<typename TValue>
1043  static void is_empty(const std::initializer_list<TValue>& value, const std::string& message, const tunit::line_info& line_info) {
1044  if (std::empty(value))
1045  assert::succeed(message, line_info);
1046  else
1047  base_assert::fail("<empty>", base_assert::join_items(value), message, line_info);
1048  }
1050 
1061  template<typename TValue>
1062  static void is_not_empty(const TValue& value) {is_not_empty(value, "", line_info());}
1063 
1075  template<typename TValue>
1076  static void is_not_empty(const TValue& value, const tunit::line_info& line_info) {is_not_empty(value, "", line_info);}
1077 
1089  template<typename TValue>
1090  static void is_not_empty(const TValue& value, const std::string& message) {is_not_empty(value, message, line_info());}
1091 
1104  template<typename TValue>
1105  static void is_not_empty(const TValue& value, const std::string& message, const tunit::line_info& line_info) {
1106  if (!std::empty(value))
1107  assert::succeed(message, line_info);
1108  else
1109  base_assert::fail("not <empty>", "<empty>", message, line_info);
1110  }
1111 
1113  template<typename TValue>
1114  static void is_not_empty(const std::initializer_list<TValue>& value) {is_not_empty(value, "", line_info());}
1115  template<typename TValue>
1116  static void is_not_empty(const std::initializer_list<TValue>& value, const tunit::line_info& line_info) {is_not_empty(value, "", line_info);}
1117  template<typename TValue>
1118  static void is_not_empty(const std::initializer_list<TValue>& value, const std::string& message) {is_not_empty(value, message, line_info());}
1119  template<typename TValue>
1120  static void is_not_empty(const std::initializer_list<TValue>& value, const std::string& message, const tunit::line_info& line_info) {
1121  if (!std::empty(value))
1122  assert::succeed(message, line_info);
1123  else
1124  base_assert::fail("not <empty>", "<empty>", message, line_info);
1125  }
1127 
1138  template<typename TValue>
1139  static void is_ordered(const TValue& value) {is_ordered(value, "", line_info());}
1140 
1152  template<typename TValue>
1153  static void is_ordered(const TValue& value, const tunit::line_info& line_info) {is_ordered(value, "", line_info);}
1154 
1166  template<typename TValue>
1167  static void is_ordered(const TValue& value, const std::string& message) {is_ordered(value, message, line_info());}
1168 
1181  template<typename TValue>
1182  static void is_ordered(const TValue& value, const std::string& message, const tunit::line_info& line_info) {
1183  if (std::is_sorted(value.begin(), value.end()))
1184  assert::succeed(message, line_info);
1185  else
1186  base_assert::fail("<ordered>", base_assert::join_items(value), message, line_info);
1187  }
1188 
1190  template<typename TValue>
1191  static void is_ordered(const std::initializer_list<TValue>& value) {is_ordered(value, "", line_info());}
1192  template<typename TValue>
1193  static void is_ordered(const std::initializer_list<TValue>& value, const tunit::line_info& line_info) {is_ordered(value, "", line_info);}
1194  template<typename TValue>
1195  static void is_ordered(const std::initializer_list<TValue>& value, const std::string& message) {is_ordered(value, message, line_info());}
1196  template<typename TValue>
1197  static void is_ordered(const std::initializer_list<TValue>& value, const std::string& message, const tunit::line_info& line_info) {
1198  if (std::is_sorted(value.begin(), value.end()))
1199  assert::succeed(message, line_info);
1200  else
1201  base_assert::fail("<ordered>", base_assert::join_items(value), message, line_info);
1202  }
1204  };
1205 }
1206 
1207 #define all_items_are_instances_of_(...) __CMD_ASSERT_ARGS(all_items_are_instances_of, __VA_ARGS__)
1208 
1209 #define all_items_are_not_null_(...) __CMD_ASSERT_ARGS(all_items_are_not_null, __VA_ARGS__)
1210 
1211 #define all_items_are_unqiue_(...) __CMD_ASSERT_ARGS(all_items_are_unqiue, __VA_ARGS__)
1212 
1213 #define are_equivalent_(...) __CMD_ASSERT_ARGS(are_equivalent, __VA_ARGS__)
1214 
1215 #define are_not_equivalent_(...) __CMD_ASSERT_ARGS(are_not_equivalent, __VA_ARGS__)
1216 
1217 #define is_ordered_(...) __CMD_ASSERT_ARGS(is_ordered, __VA_ARGS__)
tunit::collection_assert
The collection_assert class contains a collection of static methods that implement the most collectio...
Definition: collection_assert.h:12
tunit::collection_assert::is_not_empty
static void is_not_empty(const TValue &value, const std::string &message)
Asserts that collection or traits does not contain any item.
Definition: collection_assert.h:1090
tunit::collection_assert::are_equivalent
static void are_equivalent(const TExpected &expected, const TAcutal &actual, const tunit::line_info &line_info)
Asserts that all collection items are equivalent.
Definition: collection_assert.h:423
tunit::collection_assert::is_not_empty
static void is_not_empty(const TValue &value)
Asserts that collection does not contain any item.
Definition: collection_assert.h:1062
tunit::collection_assert::all_items_are_instances_of
static void all_items_are_instances_of(const TCollection &collection, const std::string &message)
Asserts that all collection items are of the type supplied or a derived type.
Definition: collection_assert.h:44
tunit::collection_assert::are_not_equal
static void are_not_equal(const TExpected &expected, const TAcutal &actual, const tunit::line_info &line_info)
Asserts that all collection items are not equal.
Definition: collection_assert.h:546
tunit::collection_assert::all_items_are_not_null
static void all_items_are_not_null(const TCollection &collection)
Asserts that all collection items are not null.
Definition: collection_assert.h:113
tunit::collection_assert::are_equivalent
static void are_equivalent(const TExpected &expected, const TAcutal &actual, const std::string &message, const tunit::line_info &line_info)
Asserts that all collection items are equivalent.
Definition: collection_assert.h:437
tunit::collection_assert::are_equivalent
static void are_equivalent(const TExpected &expected, const TAcutal &actual)
Asserts that all collection items are equivalent.
Definition: collection_assert.h:395
tunit::collection_assert::is_empty
static void is_empty(const TValue &value, const std::string &message)
Asserts that collection contains an item.
Definition: collection_assert.h:1013
tunit::collection_assert::is_ordered
static void is_ordered(const TValue &value, const std::string &message)
Asserts that collection is ordered.
Definition: collection_assert.h:1167
tunit::collection_assert::contains
static void contains(const TExpected &expected, const TAcutal &actual)
Asserts that ollection contains all items.
Definition: collection_assert.h:748
tunit::collection_assert::all_items_are_instances_of
static void all_items_are_instances_of(const TCollection &collection, const std::string &message, const tunit::line_info &line_info)
Asserts that all collection items are of the type supplied or a derived type.
Definition: collection_assert.h:72
assert.h
Contains tunit::assert class.
tunit::collection_assert::is_ordered
static void is_ordered(const TValue &value, const tunit::line_info &line_info)
Asserts that collection is ordered.
Definition: collection_assert.h:1153
tunit::collection_assert::all_items_are_not_null
static void all_items_are_not_null(const TCollection &collection, const std::string &message, const tunit::line_info &line_info)
Asserts that all collection items are not null.
Definition: collection_assert.h:161
tunit::collection_assert::are_not_equal
static void are_not_equal(const TExpected &expected, const TAcutal &actual, const std::string &message)
Asserts that all collection items are not equal.
Definition: collection_assert.h:532
tunit::collection_assert::contains
static void contains(const TExpected &expected, const TAcutal &actual, const tunit::line_info &line_info)
Asserts that collection contains all items.
Definition: collection_assert.h:776
tunit::collection_assert::are_equal
static void are_equal(const TExpected &expected, const TAcutal &actual, const std::string &message, const tunit::line_info &line_info)
Asserts that all collection items are equal.
Definition: collection_assert.h:330
tunit::collection_assert::all_items_are_not_null
static void all_items_are_not_null(const TCollection &collection, const std::string &message)
Asserts that all collection items are not null.
Definition: collection_assert.h:129
tunit::collection_assert::does_not_contain
static void does_not_contain(const TExpected &expected, const TAcutal &actual, const tunit::line_info &line_info)
Asserts that collection contains all items.
Definition: collection_assert.h:895
tunit::collection_assert::is_ordered
static void is_ordered(const TValue &value, const std::string &message, const tunit::line_info &line_info)
Asserts that collection is ordered.
Definition: collection_assert.h:1182
tunit::collection_assert::is_not_empty
static void is_not_empty(const TValue &value, const tunit::line_info &line_info)
Asserts that collection or traits does not contain any item.
Definition: collection_assert.h:1076
tunit::collection_assert::all_items_are_not_null
static void all_items_are_not_null(const TCollection &collection, const tunit::line_info &line_info)
Asserts that all collection items are not null.
Definition: collection_assert.h:145
tunit::collection_assert::all_items_are_instances_of
static void all_items_are_instances_of(const TCollection &collection, const tunit::line_info &line_info)
Asserts that all collection items are of the type supplied or a derived type.
Definition: collection_assert.h:58
tunit::line_info
line_info information class is used to store current file, current line and current function informat...
Definition: line_info.h:13
tunit::base_assert::fail
static void fail()
Throws an tunit::assertion_error exception.
Definition: base_assert.h:60
tunit::collection_assert::all_items_are_unique
static void all_items_are_unique(const TCollection &collection, const std::string &message)
Asserts that all collection items are unique.
Definition: collection_assert.h:216
tunit::collection_assert::does_not_contain
static void does_not_contain(const TExpected &expected, const TAcutal &actual, const std::string &message)
Asserts that collection contains all items.
Definition: collection_assert.h:881
tunit::collection_assert::are_not_equivalent
static void are_not_equivalent(const TExpected &expected, const TAcutal &actual, const std::string &message, const tunit::line_info &line_info)
Asserts that all collection items are not equivalent.
Definition: collection_assert.h:667
tunit::collection_assert::are_not_equivalent
static void are_not_equivalent(const TExpected &expected, const TAcutal &actual)
Asserts that all collection items are not equivalent.
Definition: collection_assert.h:625
tunit::collection_assert::are_not_equivalent
static void are_not_equivalent(const TExpected &expected, const TAcutal &actual, const std::string &message)
Asserts that all collection items are not equivalent.
Definition: collection_assert.h:639
tunit::collection_assert::does_not_contain
static void does_not_contain(const TExpected &expected, const TAcutal &actual, const std::string &message, const tunit::line_info &line_info)
Asserts that collection contains all items.
Definition: collection_assert.h:909
tunit::collection_assert::is_empty
static void is_empty(const TValue &value, const tunit::line_info &line_info)
Asserts that collection contains an item.
Definition: collection_assert.h:999
tunit::base_assert
Definition: base_assert.h:15
tunit::collection_assert::is_empty
static void is_empty(const TValue &value, const std::string &message, const tunit::line_info &line_info)
Asserts that collection contains an item.
Definition: collection_assert.h:1028
tunit::base_assert::succeed
static void succeed()
Generates a success with a generic message.
Definition: base_assert.h:130
tunit::collection_assert::is_empty
static void is_empty(const TValue &value)
Asserts that collection contains an item.
Definition: collection_assert.h:985
tunit::collection_assert::all_items_are_unique
static void all_items_are_unique(const TCollection &collection, const std::string &message, const tunit::line_info &line_info)
Asserts that all collection items are unique.
Definition: collection_assert.h:246
tunit
The tunit namespace contains a unit test library.
Definition: abort_error.h:8
tunit::collection_assert::all_items_are_unique
static void all_items_are_unique(const TCollection &collection)
Asserts that all collection items are unique.
Definition: collection_assert.h:201
tunit::collection_assert::is_not_empty
static void is_not_empty(const TValue &value, const std::string &message, const tunit::line_info &line_info)
Asserts that collection or traits does not contain any item.
Definition: collection_assert.h:1105
tunit::collection_assert::all_items_are_unique
static void all_items_are_unique(const TCollection &collection, const tunit::line_info &line_info)
Asserts that all collection items are unique.
Definition: collection_assert.h:231
tunit::collection_assert::contains
static void contains(const TExpected &expected, const TAcutal &actual, const std::string &message)
Asserts that collection contains all items.
Definition: collection_assert.h:762
tunit::collection_assert::are_not_equivalent
static void are_not_equivalent(const TExpected &expected, const TAcutal &actual, const tunit::line_info &line_info)
Asserts that all collection items are not equivalent.
Definition: collection_assert.h:653
tunit::collection_assert::is_ordered
static void is_ordered(const TValue &value)
Asserts that collection is ordered.
Definition: collection_assert.h:1139
tunit::collection_assert::does_not_contain
static void does_not_contain(const TExpected &expected, const TAcutal &actual)
Asserts that ollection contains all items.
Definition: collection_assert.h:867
tunit::collection_assert::are_not_equal
static void are_not_equal(const TExpected &expected, const TAcutal &actual, const std::string &message, const tunit::line_info &line_info)
Asserts that all collection items arenot equal.
Definition: collection_assert.h:560
tunit::collection_assert::are_not_equal
static void are_not_equal(const TExpected &expected, const TAcutal &actual)
Asserts that all collection items are not equal.
Definition: collection_assert.h:518
tunit::collection_assert::are_equal
static void are_equal(const TExpected &expected, const TAcutal &actual, const std::string &message)
Asserts that all collection items are equal.
Definition: collection_assert.h:302
tunit::collection_assert::are_equivalent
static void are_equivalent(const TExpected &expected, const TAcutal &actual, const std::string &message)
Asserts that all collection items are equivalent.
Definition: collection_assert.h:409
tunit::collection_assert::contains
static void contains(const TExpected &expected, const TAcutal &actual, const std::string &message, const tunit::line_info &line_info)
Asserts that collection contains all items.
Definition: collection_assert.h:790
tunit::collection_assert::are_equal
static void are_equal(const TExpected &expected, const TAcutal &actual, const tunit::line_info &line_info)
Asserts that all collection items are equal.
Definition: collection_assert.h:316
tunit::collection_assert::all_items_are_instances_of
static void all_items_are_instances_of(const TCollection &collection)
Asserts that all collection items are of the type supplied or a derived type.
Definition: collection_assert.h:30
tunit::collection_assert::are_equal
static void are_equal(const TExpected &expected, const TAcutal &actual)
Asserts that all collection items are equal.
Definition: collection_assert.h:288