tunit - Reference Guide  1.0.0
Modern c++17 unit testing framework on Windows, macOS, Linux, iOS and android.
collection_assume.h
Go to the documentation of this file.
1 #pragma once
4 #include "assume.h"
5 #include "collection_assert.h"
6 
8 namespace tunit {
13  class collection_assume final : private base_assert {
14  public:
16  collection_assume() = delete;
18 
30  template<typename TExpected, typename TCollection>
31  static void all_items_are_instances_of(const TCollection& collection) {all_items_are_instances_of<TExpected>(collection, "", line_info());}
32 
44  template<typename TExpected, typename TCollection>
45  static void all_items_are_instances_of(const TCollection& collection, const std::string& message) {all_items_are_instances_of<TExpected>(collection, message, line_info());}
46 
58  template<typename TExpected, typename TCollection>
59  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);}
60 
72  template<typename TExpected, typename TCollection>
73  static void all_items_are_instances_of(const TCollection& collection, const std::string& message, const tunit::line_info& line_info) {
74  try {
75  collection_assert::all_items_are_instances_of<TExpected>(collection, message, line_info);
76  } catch(...) {
77  assert::abort();
78  }
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  try {
91  collection_assert::all_items_are_instances_of<TExpected>(collection, message, line_info);
92  } catch(...) {
93  assert::abort();
94  }
95  }
97 
111  template<typename TCollection>
112  static void all_items_are_not_null(const TCollection& collection) {all_items_are_not_null(collection, "", line_info());}
113 
127  template<typename TCollection>
128  static void all_items_are_not_null(const TCollection& collection, const std::string& message) {all_items_are_not_null(collection, message, line_info());}
129 
143  template<typename TCollection>
144  static void all_items_are_not_null(const TCollection& collection, const tunit::line_info& line_info) {all_items_are_instances_of(collection, "", line_info);}
145 
159  template<typename TCollection>
160  static void all_items_are_not_null(const TCollection& collection, const std::string& message, const tunit::line_info& line_info) {
161  try {
162  collection_assert::all_items_are_not_null(collection, message, line_info);
163  } catch(...) {
164  assert::abort();
165  }
166  }
167 
169  template<typename TItem>
170  static void all_items_are_not_null(const std::initializer_list<TItem>& collection) {all_items_are_not_null(collection, "", line_info());}
171  template<typename TItem>
172  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());}
173  template<typename TItem>
174  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);}
175  template<typename TItem>
176  static void all_items_are_not_null(const std::initializer_list<TItem>& collection, const std::string& message, const tunit::line_info& line_info) {
177  try {
178  collection_assert::all_items_are_not_null(collection, message, line_info);
179  } catch(...) {
180  assert::abort();
181  }
182  }
184 
197  template<typename TCollection>
198  static void all_items_are_unique(const TCollection& collection) {all_items_are_unique(collection, "", line_info());}
199 
212  template<typename TCollection>
213  static void all_items_are_unique(const TCollection& collection, const std::string& message) {all_items_are_unique(collection, message, line_info());}
214 
227  template<typename TCollection>
228  static void all_items_are_unique(const TCollection& collection, const tunit::line_info& line_info) {all_items_are_unique(collection, "", line_info);}
229 
242  template<typename TCollection>
243  static void all_items_are_unique(const TCollection& collection, const std::string& message, const tunit::line_info& line_info) {
244  try {
245  collection_assert::all_items_are_unique(collection, message, line_info);
246  } catch(...) {
247  assert::abort();
248  }
249  }
250 
252  template<typename TItem>
253  static void all_items_are_unique(const std::initializer_list<TItem>& collection) {all_items_are_unique(collection, "", line_info());}
254  template<typename TItem>
255  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);}
256  template<typename TItem>
257  static void all_items_are_unique(const std::initializer_list<TItem>& collection, const std::string& message) {all_items_are_unique(collection, message, line_info());}
258  template<typename TItem>
259  static void all_items_are_unique(const std::initializer_list<TItem>& collection, const std::string& message, const tunit::line_info& line_info) {
260  try {
261  collection_assert::all_items_are_unique(collection, message, line_info);
262  } catch(...) {
263  assert::abort();
264  }
265  }
267 
279  template<typename TExpected, typename TAcutal>
280  static void are_equal(const TExpected& expected, const TAcutal& actual) {are_equal(expected, actual, "", line_info());}
281 
293  template<typename TExpected, typename TAcutal>
294  static void are_equal(const TExpected& expected, const TAcutal& actual, const std::string& message) {are_equal(expected, actual, message, line_info());}
295 
307  template<typename TExpected, typename TAcutal>
308  static void are_equal(const TExpected& expected, const TAcutal& actual, const tunit::line_info& line_info) {are_equal(expected, actual, "", line_info);}
309 
321  template<typename TExpected, typename TAcutal>
322  static void are_equal(const TExpected& expected, const TAcutal& actual, const std::string& message, const tunit::line_info& line_info) {
323  try {
324  collection_assert::are_equal(expected, actual, message, line_info);
325  } catch(...) {
326  assert::abort();
327  }
328  }
329 
331  template<typename TItem>
332  static void are_equal(const std::initializer_list<TItem>& expected, const std::initializer_list<TItem>& actual) {are_equal(expected, actual, "", line_info());}
333  template<typename TItem>
334  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);}
335  template<typename TItem>
336  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());}
337  template<typename TItem>
338  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) {
339  try {
340  collection_assert::are_equal(expected, actual, message, line_info);
341  } catch(...) {
342  assert::abort();
343  }
344  }
345 
347  template<typename TCollection, typename TItem>
348  static void are_equal(const TCollection& expected, const std::initializer_list<TItem>& actual) {are_equal(expected, actual, "", line_info());}
349  template<typename TCollection, typename TItem>
350  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);}
351  template<typename TCollection, typename TItem>
352  static void are_equal(const TCollection& expected, const std::initializer_list<TItem>& actual, const std::string& message) {are_equal(expected, actual, message, line_info());}
353  template<typename TCollection, typename TItem>
354  static void are_equal(const TCollection& expected, const std::initializer_list<TItem>& actual, const std::string& message, const tunit::line_info& line_info) {
355  try {
356  collection_assert::are_equal(expected, actual, message, line_info);
357  } catch(...) {
358  assert::abort();
359  }
360  }
361 
363  template<typename TItem, typename TCollection>
364  static void are_equal(const std::initializer_list<TItem>& expected, const TCollection& actual) {are_equal(expected, actual, "", line_info());}
365  template<typename TItem, typename TCollection>
366  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);}
367  template<typename TItem, typename TCollection>
368  static void are_equal(const std::initializer_list<TItem>& expected, const TCollection& actual, const std::string& message) {are_equal(expected, actual, message, line_info());}
369  template<typename TItem, typename TCollection>
370  static void are_equal(const std::initializer_list<TItem>& expected, const TCollection& actual, const std::string& message, const tunit::line_info& line_info) {
371  try {
372  collection_assert::are_equal(expected, actual, message, line_info);
373  } catch(...) {
374  assert::abort();
375  }
376  }
378 
390  template<typename TExpected, typename TAcutal>
391  static void are_equivalent(const TExpected& expected, const TAcutal& actual) {are_equivalent(expected, actual, "", line_info());}
392 
404  template<typename TExpected, typename TAcutal>
405  static void are_equivalent(const TExpected& expected, const TAcutal& actual, const std::string& message) {are_equivalent(expected, actual, message, line_info());}
406 
418  template<typename TExpected, typename TAcutal>
419  static void are_equivalent(const TExpected& expected, const TAcutal& actual, const tunit::line_info& line_info) {are_equivalent(expected, actual, "", line_info);}
420 
432  template<typename TExpected, typename TAcutal>
433  static void are_equivalent(const TExpected& expected, const TAcutal& actual, const std::string& message, const tunit::line_info& line_info) {
434  try {
435  collection_assert::are_equivalent(expected, actual, message, line_info);
436  } catch(...) {
437  assert::abort();
438  }
439  }
440 
442  template<typename TExpected, typename TActual>
443  static void are_equivalent(const std::initializer_list<TExpected>& expected, const std::initializer_list<TActual>& actual) {are_equivalent(expected, actual, "", line_info());}
444  template<typename TExpected, typename TActual>
445  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);}
446  template<typename TExpected, typename TActual>
447  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());}
448  template<typename TExpected, typename TActual>
449  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) {
450  try {
451  collection_assert::are_equivalent(expected, actual, message, line_info);
452  } catch(...) {
453  assert::abort();
454  }
455  }
456 
458  template<typename TCollection, typename TItem>
459  static void are_equivalent(const TCollection& expected, const std::initializer_list<TItem>& actual) {are_equivalent(expected, actual, "", line_info());}
460  template<typename TCollection, typename TItem>
461  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);}
462  template<typename TCollection, typename TItem>
463  static void are_equivalent(const TCollection& expected, const std::initializer_list<TItem>& actual, const std::string& message) {are_equivalent(expected, actual, message, line_info());}
464  template<typename TCollection, typename TItem>
465  static void are_equivalent(const TCollection& expected, const std::initializer_list<TItem>& actual, const std::string& message, const tunit::line_info& line_info) {
466  try {
467  collection_assert::are_equivalent(expected, actual, message, line_info);
468  } catch(...) {
469  assert::abort();
470  }
471  }
472 
474  template<typename TItem, typename TCollection>
475  static void are_equivalent(const std::initializer_list<TItem>& expected, const TCollection& actual) {are_equivalent(expected, actual, "", line_info());}
476  template<typename TItem, typename TCollection>
477  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);}
478  template<typename TItem, typename TCollection>
479  static void are_equivalent(const std::initializer_list<TItem>& expected, const TCollection& actual, const std::string& message) {are_equivalent(expected, actual, message, line_info());}
480  template<typename TItem, typename TCollection>
481  static void are_equivalent(const std::initializer_list<TItem>& expected, const TCollection& actual, const std::string& message, const tunit::line_info& line_info) {
482  try {
483  collection_assert::are_equivalent(expected, actual, message, line_info);
484  } catch(...) {
485  assert::abort();
486  }
487  }
489 
501  template<typename TExpected, typename TAcutal>
502  static void are_not_equal(const TExpected& expected, const TAcutal& actual) {are_not_equal(expected, actual, "", line_info());}
503 
515  template<typename TExpected, typename TAcutal>
516  static void are_not_equal(const TExpected& expected, const TAcutal& actual, const std::string& message) {are_not_equal(expected, actual, message, line_info());}
517 
529  template<typename TExpected, typename TAcutal>
530  static void are_not_equal(const TExpected& expected, const TAcutal& actual, const tunit::line_info& line_info) {are_not_equal(expected, actual, "", line_info);}
531 
543  template<typename TExpected, typename TAcutal>
544  static void are_not_equal(const TExpected& expected, const TAcutal& actual, const std::string& message, const tunit::line_info& line_info) {
545  try {
546  collection_assert::are_not_equal(expected, actual, message, line_info);
547  } catch(...) {
548  assert::abort();
549  }
550  }
551 
553  template<typename TItem>
554  static void are_not_equal(const std::initializer_list<TItem>& expected, const std::initializer_list<TItem>& actual) {are_not_equal(expected, actual, "", line_info());}
555  template<typename TItem>
556  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);}
557  template<typename TItem>
558  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());}
559  template<typename TItem>
560  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) {
561  try {
562  collection_assert::are_not_equal(expected, actual, message, line_info);
563  } catch(...) {
564  assert::abort();
565  }
566  }
567 
569  template<typename TCollection, typename TItem>
570  static void are_not_equal(const TCollection& expected, const std::initializer_list<TItem>& actual) {are_not_equal(expected, actual, "", line_info());}
571  template<typename TCollection, typename TItem>
572  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);}
573  template<typename TCollection, typename TItem>
574  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());}
575  template<typename TCollection, typename TItem>
576  static void are_not_equal(const TCollection& expected, const std::initializer_list<TItem>& actual, const std::string& message, const tunit::line_info& line_info) {
577  try {
578  collection_assert::are_not_equal(expected, actual, message, line_info);
579  } catch(...) {
580  assert::abort();
581  }
582  }
583 
585  template<typename TItem, typename TCollection>
586  static void are_not_equal(const std::initializer_list<TItem>& expected, const TCollection& actual) {are_not_equal(expected, actual, "", line_info());}
587  template<typename TItem, typename TCollection>
588  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);}
589  template<typename TItem, typename TCollection>
590  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());}
591  template<typename TItem, typename TCollection>
592  static void are_not_equal(const std::initializer_list<TItem>& expected, const TCollection& actual, const std::string& message, const tunit::line_info& line_info) {
593  try {
594  collection_assert::are_not_equal(expected, actual, message, line_info);
595  } catch(...) {
596  assert::abort();
597  }
598  }
600 
612  template<typename TExpected, typename TAcutal>
613  static void are_not_equivalent(const TExpected& expected, const TAcutal& actual) {are_not_equivalent(expected, actual, "", line_info());}
614 
626  template<typename TExpected, typename TAcutal>
627  static void are_not_equivalent(const TExpected& expected, const TAcutal& actual, const std::string& message) {are_not_equivalent(expected, actual, message, line_info());}
628 
640  template<typename TExpected, typename TAcutal>
641  static void are_not_equivalent(const TExpected& expected, const TAcutal& actual, const tunit::line_info& line_info) {are_not_equivalent(expected, actual, "", line_info);}
642 
654  template<typename TExpected, typename TAcutal>
655  static void are_not_equivalent(const TExpected& expected, const TAcutal& actual, const std::string& message, const tunit::line_info& line_info) {
656  try {
657  collection_assert::are_not_equivalent(expected, actual, message, line_info);
658  } catch(...) {
659  assert::abort();
660  }
661  }
662 
664  template<typename TExpected, typename TActual>
665  static void are_not_equivalent(const std::initializer_list<TExpected>& expected, const std::initializer_list<TActual>& actual) {are_not_equivalent(expected, actual, "", line_info());}
666  template<typename TExpected, typename TActual>
667  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);}
668  template<typename TExpected, typename TActual>
669  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());}
670  template<typename TExpected, typename TActual>
671  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) {
672  try {
673  collection_assert::are_not_equivalent(expected, actual, message, line_info);
674  } catch(...) {
675  assert::abort();
676  }
677  }
678 
680  template<typename TCollection, typename TItem>
681  static void are_not_equivalent(const TCollection& expected, const std::initializer_list<TItem>& actual) {are_not_equivalent(expected, actual, "", line_info());}
682  template<typename TCollection, typename TItem>
683  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);}
684  template<typename TCollection, typename TItem>
685  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());}
686  template<typename TCollection, typename TItem>
687  static void are_not_equivalent(const TCollection& expected, const std::initializer_list<TItem>& actual, const std::string& message, const tunit::line_info& line_info) {
688  try {
689  collection_assert::are_not_equivalent(expected, actual, message, line_info);
690  } catch(...) {
691  assert::abort();
692  }
693  }
694 
696  template<typename TItem, typename TCollection>
697  static void are_not_equivalent(const std::initializer_list<TItem>& expected, const TCollection& actual) {are_not_equivalent(expected, actual, "", line_info());}
698  template<typename TItem, typename TCollection>
699  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);}
700  template<typename TItem, typename TCollection>
701  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());}
702  template<typename TItem, typename TCollection>
703  static void are_not_equivalent(const std::initializer_list<TItem>& expected, const TCollection& actual, const std::string& message, const tunit::line_info& line_info) {
704  try {
705  collection_assert::are_not_equivalent(expected, actual, message, line_info);
706  } catch(...) {
707  assert::abort();
708  }
709  }
711 
723  template<typename TExpected, typename TAcutal>
724  static void contains(const TExpected& expected, const TAcutal& actual) {contains(expected, actual, "", line_info());}
725 
737  template<typename TExpected, typename TAcutal>
738  static void contains(const TExpected& expected, const TAcutal& actual, const std::string& message) {contains(expected, actual, message, line_info());}
739 
751  template<typename TExpected, typename TAcutal>
752  static void contains(const TExpected& expected, const TAcutal& actual, const tunit::line_info& line_info) {contains(expected, actual, "", line_info);}
753 
765  template<typename TExpected, typename TAcutal>
766  static void contains(const TExpected& expected, const TAcutal& actual, const std::string& message, const tunit::line_info& line_info) {
767  try {
768  collection_assert::contains(expected, actual, message, line_info);
769  } catch(...) {
770  assert::abort();
771  }
772  }
773 
775  template<typename TItem>
776  static void contains(const std::initializer_list<TItem>& expected, const std::initializer_list<TItem>& actual) {contains(expected, actual, "", line_info());}
777  template<typename TItem>
778  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);}
779  template<typename TItem>
780  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());}
781  template<typename TItem>
782  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) {
783  try {
784  collection_assert::contains(expected, actual, message, line_info);
785  } catch(...) {
786  assert::abort();
787  }
788  }
789 
791  template<typename TCollection, typename TItem>
792  static void contains(const TCollection& expected, const std::initializer_list<TItem>& actual) {contains(expected, actual, "", line_info());}
793  template<typename TCollection, typename TItem>
794  static void contains(const TCollection& expected, const std::initializer_list<TItem>& actual, const tunit::line_info& line_info) {contains(expected, actual, "", line_info);}
795  template<typename TCollection, typename TItem>
796  static void contains(const TCollection& expected, const std::initializer_list<TItem>& actual, const std::string& message) {contains(expected, actual, message, line_info());}
797  template<typename TCollection, typename TItem>
798  static void contains(const TCollection& expected, const std::initializer_list<TItem>& actual, const std::string& message, const tunit::line_info& line_info) {
799  try {
800  collection_assert::contains(expected, actual, message, line_info);
801  } catch(...) {
802  assert::abort();
803  }
804  }
805 
807  template<typename TItem, typename TCollection>
808  static void contains(const std::initializer_list<TItem>& expected, const TCollection& actual) {contains(expected, actual, "", line_info());}
809  template<typename TItem, typename TCollection>
810  static void contains(const std::initializer_list<TItem>& expected, const TCollection& actual, const tunit::line_info& line_info) {contains(expected, actual, "", line_info);}
811  template<typename TItem, typename TCollection>
812  static void contains(const std::initializer_list<TItem>& expected, const TCollection& actual, const std::string& message) {contains(expected, actual, message, line_info());}
813  template<typename TItem, typename TCollection>
814  static void contains(const std::initializer_list<TItem>& expected, const TCollection& actual, const std::string& message, const tunit::line_info& line_info) {
815  try {
816  collection_assert::contains(expected, actual, message, line_info);
817  } catch(...) {
818  assert::abort();
819  }
820  }
822 
834  template<typename TExpected, typename TAcutal>
835  static void does_not_contain(const TExpected& expected, const TAcutal& actual) {does_not_contain(expected, actual, "", line_info());}
836 
848  template<typename TExpected, typename TAcutal>
849  static void does_not_contain(const TExpected& expected, const TAcutal& actual, const std::string& message) {does_not_contain(expected, actual, message, line_info());}
850 
862  template<typename TExpected, typename TAcutal>
863  static void does_not_contain(const TExpected& expected, const TAcutal& actual, const tunit::line_info& line_info) {does_not_contain(expected, actual, "", line_info);}
864 
876  template<typename TExpected, typename TAcutal>
877  static void does_not_contain(const TExpected& expected, const TAcutal& actual, const std::string& message, const tunit::line_info& line_info) {
878  try {
879  collection_assert::does_not_contain(expected, actual, message, line_info);
880  } catch(...) {
881  assert::abort();
882  }
883  }
884 
886  template<typename TItem>
887  static void does_not_contain(const std::initializer_list<TItem>& expected, const std::initializer_list<TItem>& actual) {does_not_contain(expected, actual, "", line_info());}
888  template<typename TItem>
889  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);}
890  template<typename TItem>
891  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());}
892  template<typename TItem>
893  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) {
894  try {
895  collection_assert::does_not_contain(expected, actual, message, line_info);
896  } catch(...) {
897  assert::abort();
898  }
899  }
900 
902  template<typename TCollection, typename TItem>
903  static void does_not_contain(const TCollection& expected, const std::initializer_list<TItem>& actual) {does_not_contain(expected, actual, "", line_info());}
904  template<typename TCollection, typename TItem>
905  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);}
906  template<typename TCollection, typename TItem>
907  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());}
908  template<typename TCollection, typename TItem>
909  static void does_not_contain(const TCollection& expected, const std::initializer_list<TItem>& actual, const std::string& message, const tunit::line_info& line_info) {
910  try {
911  collection_assert::does_not_contain(expected, actual, message, line_info);
912  } catch(...) {
913  assert::abort();
914  }
915  }
916 
918  template<typename TItem, typename TCollection>
919  static void does_not_contain(const std::initializer_list<TItem>& expected, const TCollection& actual) {does_not_contain(expected, actual, "", line_info());}
920  template<typename TItem, typename TCollection>
921  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);}
922  template<typename TItem, typename TCollection>
923  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());}
924  template<typename TItem, typename TCollection>
925  static void does_not_contain(const std::initializer_list<TItem>& expected, const TCollection& actual, const std::string& message, const tunit::line_info& line_info) {
926  try {
927  collection_assert::does_not_contain(expected, actual, message, line_info);
928  } catch(...) {
929  assert::abort();
930  }
931  }
933 
944  template<typename TValue>
945  static void is_empty(const TValue& value) {is_empty(value, "", line_info());}
946 
958  template<typename TValue>
959  static void is_empty(const TValue& value, const tunit::line_info& line_info) {is_empty(value, "", line_info);}
960 
972  template<typename TValue>
973  static void is_empty(const TValue& value, const std::string& message) {is_empty(value, message, line_info());}
974 
987  template<typename TValue>
988  static void is_empty(const TValue& value, const std::string& message, const tunit::line_info& line_info) {
989  try {
990  collection_assert::is_empty(value, message, line_info);
991  } catch(...) {
992  assert::abort();
993  }
994  }
995 
997  template<typename TValue>
998  static void is_empty(const std::initializer_list<TValue>& value) {is_empty(value, "", line_info());}
999  template<typename TValue>
1000  static void is_empty(const std::initializer_list<TValue>& value, const tunit::line_info& line_info) {is_empty(value, "", line_info);}
1001  template<typename TValue>
1002  static void is_empty(const std::initializer_list<TValue>& value, const std::string& message) {is_empty(value, message, line_info());}
1003  template<typename TValue>
1004  static void is_empty(const std::initializer_list<TValue>& value, const std::string& message, const tunit::line_info& line_info) {
1005  try {
1006  collection_assert::is_empty(value, message, line_info);
1007  } catch(...) {
1008  assert::abort();
1009  }
1010  }
1012 
1023  template<typename TValue>
1024  static void is_not_empty(const TValue& value) {is_not_empty(value, "", line_info());}
1025 
1037  template<typename TValue>
1038  static void is_not_empty(const TValue& value, const tunit::line_info& line_info) {is_not_empty(value, "", line_info);}
1039 
1051  template<typename TValue>
1052  static void is_not_empty(const TValue& value, const std::string& message) {is_not_empty(value, message, line_info());}
1053 
1066  template<typename TValue>
1067  static void is_not_empty(const TValue& value, const std::string& message, const tunit::line_info& line_info) {
1068  try {
1069  collection_assert::is_not_empty(value, message, line_info);
1070  } catch(...) {
1071  assert::abort();
1072  }
1073  }
1074 
1076  template<typename TValue>
1077  static void is_not_empty(const std::initializer_list<TValue>& value) {is_not_empty(value, "", line_info());}
1078  template<typename TValue>
1079  static void is_not_empty(const std::initializer_list<TValue>& value, const tunit::line_info& line_info) {is_not_empty(value, "", line_info);}
1080  template<typename TValue>
1081  static void is_not_empty(const std::initializer_list<TValue>& value, const std::string& message) {is_not_empty(value, message, line_info());}
1082  template<typename TValue>
1083  static void is_not_empty(const std::initializer_list<TValue>& value, const std::string& message, const tunit::line_info& line_info) {
1084  try {
1085  collection_assert::is_not_empty(value, message, line_info);
1086  } catch(...) {
1087  assert::abort();
1088  }
1089  }
1091 
1102  template<typename TValue>
1103  static void is_ordered(const TValue& value) {is_ordered(value, "", line_info());}
1104 
1116  template<typename TValue>
1117  static void is_ordered(const TValue& value, const tunit::line_info& line_info) {is_ordered(value, "", line_info);}
1118 
1130  template<typename TValue>
1131  static void is_ordered(const TValue& value, const std::string& message) {is_ordered(value, message, line_info());}
1132 
1145  template<typename TValue>
1146  static void is_ordered(const TValue& value, const std::string& message, const tunit::line_info& line_info) {
1147  try {
1148  collection_assert::is_ordered(value, message, line_info);
1149  } catch(...) {
1150  assert::abort();
1151  }
1152  }
1153 
1155  template<typename TValue>
1156  static void is_ordered(const std::initializer_list<TValue>& value) {is_ordered(value, "", line_info());}
1157  template<typename TValue>
1158  static void is_ordered(const std::initializer_list<TValue>& value, const tunit::line_info& line_info) {is_ordered(value, "", line_info);}
1159  template<typename TValue>
1160  static void is_ordered(const std::initializer_list<TValue>& value, const std::string& message) {is_ordered(value, message, line_info());}
1161  template<typename TValue>
1162  static void is_ordered(const std::initializer_list<TValue>& value, const std::string& message, const tunit::line_info& line_info) {
1163  try {
1164  collection_assert::is_ordered(value, message, line_info);
1165  } catch(...) {
1166  assert::abort();
1167  }
1168  }
1170  };
1171 }
tunit::collection_assume::is_not_empty
static void is_not_empty(const TValue &value, const std::string &message)
Assumes that collection or traits does not contain any item.
Definition: collection_assume.h:1052
tunit::collection_assume::all_items_are_unique
static void all_items_are_unique(const TCollection &collection, const std::string &message)
Assumes that all collection items are unique.
Definition: collection_assume.h:213
tunit::collection_assume
The collection_assume class contains a collection of static methods that implement the most collectio...
Definition: collection_assume.h:13
tunit::collection_assume::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)
Assumes that all collection items are of the type supplied or a derived type.
Definition: collection_assume.h:73
tunit::collection_assume::contains
static void contains(const TExpected &expected, const TAcutal &actual, const tunit::line_info &line_info)
Assumes that collection contains all items.
Definition: collection_assume.h:752
tunit::collection_assume::are_not_equal
static void are_not_equal(const TExpected &expected, const TAcutal &actual, const tunit::line_info &line_info)
Assumes that all collection items are not equal.
Definition: collection_assume.h:530
tunit::collection_assume::is_empty
static void is_empty(const TValue &value, const std::string &message, const tunit::line_info &line_info)
Assumes that collection contains an item.
Definition: collection_assume.h:988
tunit::collection_assume::are_equal
static void are_equal(const TExpected &expected, const TAcutal &actual)
Assumes that all collection items are equal.
Definition: collection_assume.h:280
collection_assert.h
Contains tunit::collection_assert class.
tunit::collection_assume::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)
Assumes that all collection items are not null.
Definition: collection_assume.h:160
tunit::collection_assume::all_items_are_instances_of
static void all_items_are_instances_of(const TCollection &collection, const std::string &message)
Assumes that all collection items are of the type supplied or a derived type.
Definition: collection_assume.h:45
tunit::collection_assume::are_not_equivalent
static void are_not_equivalent(const TExpected &expected, const TAcutal &actual)
Assumes that all collection items are not equivalent.
Definition: collection_assume.h:613
tunit::collection_assume::contains
static void contains(const TExpected &expected, const TAcutal &actual)
Assumes that ollection contains all items.
Definition: collection_assume.h:724
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_assume::is_ordered
static void is_ordered(const TValue &value)
Assumes that collection is ordered.
Definition: collection_assume.h:1103
tunit::collection_assume::does_not_contain
static void does_not_contain(const TExpected &expected, const TAcutal &actual, const std::string &message)
Assumes that collection contains all items.
Definition: collection_assume.h:849
tunit::collection_assume::all_items_are_unique
static void all_items_are_unique(const TCollection &collection)
Assumes that all collection items are unique.
Definition: collection_assume.h:198
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_assume::contains
static void contains(const TExpected &expected, const TAcutal &actual, const std::string &message)
Assumes that collection contains all items.
Definition: collection_assume.h:738
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_assume::are_equivalent
static void are_equivalent(const TExpected &expected, const TAcutal &actual, const tunit::line_info &line_info)
Assumes that all collection items are equivalent.
Definition: collection_assume.h:419
tunit::collection_assume::is_empty
static void is_empty(const TValue &value, const tunit::line_info &line_info)
Assumes that collection contains an item.
Definition: collection_assume.h:959
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_assume::is_empty
static void is_empty(const TValue &value, const std::string &message)
Assumes that collection contains an item.
Definition: collection_assume.h:973
tunit::collection_assume::are_equivalent
static void are_equivalent(const TExpected &expected, const TAcutal &actual, const std::string &message, const tunit::line_info &line_info)
Assumes that all collection items are equivalent.
Definition: collection_assume.h:433
tunit::collection_assume::all_items_are_instances_of
static void all_items_are_instances_of(const TCollection &collection)
Assumes that all collection items are of the type supplied or a derived type.
Definition: collection_assume.h:31
tunit::collection_assume::is_ordered
static void is_ordered(const TValue &value, const std::string &message)
Assumes that collection is ordered.
Definition: collection_assume.h:1131
tunit::collection_assume::all_items_are_unique
static void all_items_are_unique(const TCollection &collection, const tunit::line_info &line_info)
Assumes that all collection items are unique.
Definition: collection_assume.h:228
tunit::collection_assume::are_equal
static void are_equal(const TExpected &expected, const TAcutal &actual, const tunit::line_info &line_info)
Assumes that all collection items are equal.
Definition: collection_assume.h:308
tunit::collection_assume::all_items_are_unique
static void all_items_are_unique(const TCollection &collection, const std::string &message, const tunit::line_info &line_info)
Assumes that all collection items are unique.
Definition: collection_assume.h:243
tunit::base_assert::abort
static void abort()
Abort current test.
Definition: base_assert.h:26
tunit::collection_assume::are_equal
static void are_equal(const TExpected &expected, const TAcutal &actual, const std::string &message, const tunit::line_info &line_info)
Assumes that all collection items are equal.
Definition: collection_assume.h:322
tunit::collection_assume::are_equivalent
static void are_equivalent(const TExpected &expected, const TAcutal &actual, const std::string &message)
Assumes that all collection items are equivalent.
Definition: collection_assume.h:405
tunit::collection_assume::are_equal
static void are_equal(const TExpected &expected, const TAcutal &actual, const std::string &message)
Assumes that all collection items are equal.
Definition: collection_assume.h:294
tunit::collection_assume::all_items_are_instances_of
static void all_items_are_instances_of(const TCollection &collection, const tunit::line_info &line_info)
Assumes that all collection items are of the type supplied or a derived type.
Definition: collection_assume.h:59
tunit::collection_assume::is_empty
static void is_empty(const TValue &value)
Assumes that collection contains an item.
Definition: collection_assume.h:945
tunit::line_info
line_info information class is used to store current file, current line and current function informat...
Definition: line_info.h:13
assume.h
Contains tunit::assume class.
tunit::collection_assume::all_items_are_not_null
static void all_items_are_not_null(const TCollection &collection)
Assumes that all collection items are not null.
Definition: collection_assume.h:112
tunit::collection_assume::are_equivalent
static void are_equivalent(const TExpected &expected, const TAcutal &actual)
Assumes that all collection items are equivalent.
Definition: collection_assume.h:391
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_assume::does_not_contain
static void does_not_contain(const TExpected &expected, const TAcutal &actual)
Assumes that ollection contains all items.
Definition: collection_assume.h:835
tunit::collection_assume::is_not_empty
static void is_not_empty(const TValue &value)
Assumes that collection does not contain any item.
Definition: collection_assume.h:1024
tunit::base_assert
Definition: base_assert.h:15
tunit::collection_assume::all_items_are_not_null
static void all_items_are_not_null(const TCollection &collection, const tunit::line_info &line_info)
Assumes that all collection items are not null.
Definition: collection_assume.h:144
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_assume::does_not_contain
static void does_not_contain(const TExpected &expected, const TAcutal &actual, const std::string &message, const tunit::line_info &line_info)
Assumes that collection contains all items.
Definition: collection_assume.h:877
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_assume::does_not_contain
static void does_not_contain(const TExpected &expected, const TAcutal &actual, const tunit::line_info &line_info)
Assumes that collection contains all items.
Definition: collection_assume.h:863
tunit::collection_assume::are_not_equal
static void are_not_equal(const TExpected &expected, const TAcutal &actual)
Assumes that all collection items are not equal.
Definition: collection_assume.h:502
tunit::collection_assume::contains
static void contains(const TExpected &expected, const TAcutal &actual, const std::string &message, const tunit::line_info &line_info)
Assumes that collection contains all items.
Definition: collection_assume.h:766
tunit::collection_assume::all_items_are_not_null
static void all_items_are_not_null(const TCollection &collection, const std::string &message)
Assumes that all collection items are not null.
Definition: collection_assume.h:128
tunit::collection_assume::are_not_equal
static void are_not_equal(const TExpected &expected, const TAcutal &actual, const std::string &message, const tunit::line_info &line_info)
Assumes that all collection items arenot equal.
Definition: collection_assume.h:544
tunit::collection_assume::are_not_equivalent
static void are_not_equivalent(const TExpected &expected, const TAcutal &actual, const tunit::line_info &line_info)
Assumes that all collection items are not equivalent.
Definition: collection_assume.h:641
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_assume::are_not_equivalent
static void are_not_equivalent(const TExpected &expected, const TAcutal &actual, const std::string &message)
Assumes that all collection items are not equivalent.
Definition: collection_assume.h:627
tunit::collection_assume::is_ordered
static void is_ordered(const TValue &value, const tunit::line_info &line_info)
Assumes that collection is ordered.
Definition: collection_assume.h:1117
tunit::collection_assume::is_ordered
static void is_ordered(const TValue &value, const std::string &message, const tunit::line_info &line_info)
Assumes that collection is ordered.
Definition: collection_assume.h:1146
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_assume::is_not_empty
static void is_not_empty(const TValue &value, const std::string &message, const tunit::line_info &line_info)
Assumes that collection or traits does not contain any item.
Definition: collection_assume.h:1067
tunit::collection_assume::are_not_equal
static void are_not_equal(const TExpected &expected, const TAcutal &actual, const std::string &message)
Assumes that all collection items are not equal.
Definition: collection_assume.h:516
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
tunit::collection_assume::are_not_equivalent
static void are_not_equivalent(const TExpected &expected, const TAcutal &actual, const std::string &message, const tunit::line_info &line_info)
Assumes that all collection items are not equivalent.
Definition: collection_assume.h:655
tunit::collection_assume::is_not_empty
static void is_not_empty(const TValue &value, const tunit::line_info &line_info)
Assumes that collection or traits does not contain any item.
Definition: collection_assume.h:1038