tunit - Reference Guide  1.0.0
Modern c++17 unit testing framework on Windows, macOS, Linux, iOS and android.
collection_valid.h
Go to the documentation of this file.
1 #pragma once
4 #include "valid.h"
5 #include "collection_valid.h"
6 
8 namespace tunit {
13  class collection_valid final : private base_assert {
14  public:
16  collection_valid() = delete;
18 
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 
42  template<typename TExpected, typename TCollection>
43  static void all_items_are_instances_of(const TCollection& collection, const std::string& message) {all_items_are_instances_of<TExpected>(collection, message, line_info());}
44 
55  template<typename TExpected, typename TCollection>
56  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);}
57 
68  template<typename TExpected, typename TCollection>
69  static void all_items_are_instances_of(const TCollection& collection, const std::string& message, const tunit::line_info& line_info) {
70  try {
71  collection_assert::all_items_are_instances_of<TExpected>(collection, message, line_info);
72  } catch(...) {
73  base_assert::error();
74  }
75  }
76 
78  template<typename TExpected, typename TItem>
79  static void all_items_are_instances_of(const std::initializer_list<TItem>& collection) {all_items_are_instances_of<TExpected>(collection, "", line_info());}
80  template<typename TExpected, typename TItem>
81  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());}
82  template<typename TExpected, typename TItem>
83  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);}
84  template<typename TExpected, typename TItem>
85  static void all_items_are_instances_of(const std::initializer_list<TItem>& collection, const std::string& message, const tunit::line_info& line_info) {
86  try {
87  collection_assert::all_items_are_instances_of<TExpected>(collection, message, line_info);
88  } catch(...) {
89  base_assert::error();
90  }
91  }
93 
106  template<typename TCollection>
107  static void all_items_are_not_null(const TCollection& collection) {all_items_are_not_null(collection, "", line_info());}
108 
121  template<typename TCollection>
122  static void all_items_are_not_null(const TCollection& collection, const std::string& message) {all_items_are_not_null(collection, message, line_info());}
123 
136  template<typename TCollection>
137  static void all_items_are_not_null(const TCollection& collection, const tunit::line_info& line_info) {all_items_are_instances_of(collection, "", line_info);}
138 
151  template<typename TCollection>
152  static void all_items_are_not_null(const TCollection& collection, const std::string& message, const tunit::line_info& line_info) {
153  try {
154  collection_assert::all_items_are_not_null(collection, message, line_info);
155  } catch(...) {
156  base_assert::error();
157  }
158  }
159 
161  template<typename TItem>
162  static void all_items_are_not_null(const std::initializer_list<TItem>& collection) {all_items_are_not_null(collection, "", line_info());}
163  template<typename TItem>
164  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());}
165  template<typename TItem>
166  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);}
167  template<typename TItem>
168  static void all_items_are_not_null(const std::initializer_list<TItem>& collection, const std::string& message, const tunit::line_info& line_info) {
169  try {
170  collection_assert::all_items_are_not_null(collection, message, line_info);
171  } catch(...) {
172  base_assert::error();
173  }
174  }
176 
188  template<typename TCollection>
189  static void all_items_are_unique(const TCollection& collection) {all_items_are_unique(collection, "", line_info());}
190 
202  template<typename TCollection>
203  static void all_items_are_unique(const TCollection& collection, const std::string& message) {all_items_are_unique(collection, message, line_info());}
204 
216  template<typename TCollection>
217  static void all_items_are_unique(const TCollection& collection, const tunit::line_info& line_info) {all_items_are_unique(collection, "", line_info);}
218 
230  template<typename TCollection>
231  static void all_items_are_unique(const TCollection& collection, const std::string& message, const tunit::line_info& line_info) {
232  try {
233  collection_assert::all_items_are_unique(collection, message, line_info);
234  } catch(...) {
235  base_assert::error();
236  }
237  }
238 
240  template<typename TItem>
241  static void all_items_are_unique(const std::initializer_list<TItem>& collection) {all_items_are_unique(collection, "", line_info());}
242  template<typename TItem>
243  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);}
244  template<typename TItem>
245  static void all_items_are_unique(const std::initializer_list<TItem>& collection, const std::string& message) {all_items_are_unique(collection, message, line_info());}
246  template<typename TItem>
247  static void all_items_are_unique(const std::initializer_list<TItem>& collection, const std::string& message, const tunit::line_info& line_info) {
248  try {
249  collection_assert::all_items_are_unique(collection, message, line_info);
250  } catch(...) {
251  base_assert::error();
252  }
253  }
255 
266  template<typename TExpected, typename TAcutal>
267  static void are_equal(const TExpected& expected, const TAcutal& actual) {are_equal(expected, actual, "", line_info());}
268 
279  template<typename TExpected, typename TAcutal>
280  static void are_equal(const TExpected& expected, const TAcutal& actual, const std::string& message) {are_equal(expected, actual, message, line_info());}
281 
292  template<typename TExpected, typename TAcutal>
293  static void are_equal(const TExpected& expected, const TAcutal& actual, const tunit::line_info& line_info) {are_equal(expected, actual, "", line_info);}
294 
305  template<typename TExpected, typename TAcutal>
306  static void are_equal(const TExpected& expected, const TAcutal& actual, const std::string& message, const tunit::line_info& line_info) {
307  try {
308  collection_assert::are_equal(expected, actual, message, line_info);
309  } catch(...) {
310  base_assert::error();
311  }
312  }
313 
315  template<typename TItem>
316  static void are_equal(const std::initializer_list<TItem>& expected, const std::initializer_list<TItem>& actual) {are_equal(expected, actual, "", line_info());}
317  template<typename TItem>
318  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);}
319  template<typename TItem>
320  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());}
321  template<typename TItem>
322  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) {
323  try {
324  collection_assert::are_equal(expected, actual, message, line_info);
325  } catch(...) {
326  base_assert::error();
327  }
328  }
329 
331  template<typename TCollection, typename TItem>
332  static void are_equal(const TCollection& expected, const std::initializer_list<TItem>& actual) {are_equal(expected, actual, "", line_info());}
333  template<typename TCollection, typename TItem>
334  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);}
335  template<typename TCollection, typename TItem>
336  static void are_equal(const TCollection& expected, const std::initializer_list<TItem>& actual, const std::string& message) {are_equal(expected, actual, message, line_info());}
337  template<typename TCollection, typename TItem>
338  static void are_equal(const TCollection& 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  base_assert::error();
343  }
344  }
345 
347  template<typename TItem, typename TCollection>
348  static void are_equal(const std::initializer_list<TItem>& expected, const TCollection& actual) {are_equal(expected, actual, "", line_info());}
349  template<typename TItem, typename TCollection>
350  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);}
351  template<typename TItem, typename TCollection>
352  static void are_equal(const std::initializer_list<TItem>& expected, const TCollection& actual, const std::string& message) {are_equal(expected, actual, message, line_info());}
353  template<typename TItem, typename TCollection>
354  static void are_equal(const std::initializer_list<TItem>& expected, const TCollection& 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  base_assert::error();
359  }
360  }
362 
373  template<typename TExpected, typename TAcutal>
374  static void are_equivalent(const TExpected& expected, const TAcutal& actual) {are_equivalent(expected, actual, "", line_info());}
375 
386  template<typename TExpected, typename TAcutal>
387  static void are_equivalent(const TExpected& expected, const TAcutal& actual, const std::string& message) {are_equivalent(expected, actual, message, line_info());}
388 
399  template<typename TExpected, typename TAcutal>
400  static void are_equivalent(const TExpected& expected, const TAcutal& actual, const tunit::line_info& line_info) {are_equivalent(expected, actual, "", line_info);}
401 
412  template<typename TExpected, typename TAcutal>
413  static void are_equivalent(const TExpected& expected, const TAcutal& actual, const std::string& message, const tunit::line_info& line_info) {
414  try {
415  collection_assert::are_equivalent(expected, actual, message, line_info);
416  } catch(...) {
417  base_assert::error();
418  }
419  }
420 
422  template<typename TExpected, typename TActual>
423  static void are_equivalent(const std::initializer_list<TExpected>& expected, const std::initializer_list<TActual>& actual) {are_equivalent(expected, actual, "", line_info());}
424  template<typename TExpected, typename TActual>
425  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);}
426  template<typename TExpected, typename TActual>
427  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());}
428  template<typename TExpected, typename TActual>
429  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) {
430  try {
431  collection_assert::are_equivalent(expected, actual, message, line_info);
432  } catch(...) {
433  base_assert::error();
434  }
435  }
436 
438  template<typename TCollection, typename TItem>
439  static void are_equivalent(const TCollection& expected, const std::initializer_list<TItem>& actual) {are_equivalent(expected, actual, "", line_info());}
440  template<typename TCollection, typename TItem>
441  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);}
442  template<typename TCollection, typename TItem>
443  static void are_equivalent(const TCollection& expected, const std::initializer_list<TItem>& actual, const std::string& message) {are_equivalent(expected, actual, message, line_info());}
444  template<typename TCollection, typename TItem>
445  static void are_equivalent(const TCollection& expected, const std::initializer_list<TItem>& actual, const std::string& message, const tunit::line_info& line_info) {
446  try {
447  collection_assert::are_equivalent(expected, actual, message, line_info);
448  } catch(...) {
449  base_assert::error();
450  }
451  }
452 
454  template<typename TItem, typename TCollection>
455  static void are_equivalent(const std::initializer_list<TItem>& expected, const TCollection& actual) {are_equivalent(expected, actual, "", line_info());}
456  template<typename TItem, typename TCollection>
457  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);}
458  template<typename TItem, typename TCollection>
459  static void are_equivalent(const std::initializer_list<TItem>& expected, const TCollection& actual, const std::string& message) {are_equivalent(expected, actual, message, line_info());}
460  template<typename TItem, typename TCollection>
461  static void are_equivalent(const std::initializer_list<TItem>& expected, const TCollection& actual, const std::string& message, const tunit::line_info& line_info) {
462  try {
463  collection_assert::are_equivalent(expected, actual, message, line_info);
464  } catch(...) {
465  base_assert::error();
466  }
467  }
469 
480  template<typename TExpected, typename TAcutal>
481  static void are_not_equal(const TExpected& expected, const TAcutal& actual) {are_not_equal(expected, actual, "", line_info());}
482 
493  template<typename TExpected, typename TAcutal>
494  static void are_not_equal(const TExpected& expected, const TAcutal& actual, const std::string& message) {are_not_equal(expected, actual, message, line_info());}
495 
506  template<typename TExpected, typename TAcutal>
507  static void are_not_equal(const TExpected& expected, const TAcutal& actual, const tunit::line_info& line_info) {are_not_equal(expected, actual, "", line_info);}
508 
519  template<typename TExpected, typename TAcutal>
520  static void are_not_equal(const TExpected& expected, const TAcutal& actual, const std::string& message, const tunit::line_info& line_info) {
521  try {
522  collection_assert::are_not_equal(expected, actual, message, line_info);
523  } catch(...) {
524  base_assert::error();
525  }
526  }
527 
529  template<typename TItem>
530  static void are_not_equal(const std::initializer_list<TItem>& expected, const std::initializer_list<TItem>& actual) {are_not_equal(expected, actual, "", line_info());}
531  template<typename TItem>
532  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);}
533  template<typename TItem>
534  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());}
535  template<typename TItem>
536  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) {
537  try {
538  collection_assert::are_not_equal(expected, actual, message, line_info);
539  } catch(...) {
540  base_assert::error();
541  }
542  }
543 
545  template<typename TCollection, typename TItem>
546  static void are_not_equal(const TCollection& expected, const std::initializer_list<TItem>& actual) {are_not_equal(expected, actual, "", line_info());}
547  template<typename TCollection, typename TItem>
548  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);}
549  template<typename TCollection, typename TItem>
550  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());}
551  template<typename TCollection, typename TItem>
552  static void are_not_equal(const TCollection& expected, const std::initializer_list<TItem>& actual, const std::string& message, const tunit::line_info& line_info) {
553  try {
554  collection_assert::are_not_equal(expected, actual, message, line_info);
555  } catch(...) {
556  base_assert::error();
557  }
558  }
559 
561  template<typename TItem, typename TCollection>
562  static void are_not_equal(const std::initializer_list<TItem>& expected, const TCollection& actual) {are_not_equal(expected, actual, "", line_info());}
563  template<typename TItem, typename TCollection>
564  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);}
565  template<typename TItem, typename TCollection>
566  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());}
567  template<typename TItem, typename TCollection>
568  static void are_not_equal(const std::initializer_list<TItem>& expected, const TCollection& actual, const std::string& message, const tunit::line_info& line_info) {
569  try {
570  collection_assert::are_not_equal(expected, actual, message, line_info);
571  } catch(...) {
572  base_assert::error();
573  }
574  }
576 
587  template<typename TExpected, typename TAcutal>
588  static void are_not_equivalent(const TExpected& expected, const TAcutal& actual) {are_not_equivalent(expected, actual, "", line_info());}
589 
600  template<typename TExpected, typename TAcutal>
601  static void are_not_equivalent(const TExpected& expected, const TAcutal& actual, const std::string& message) {are_not_equivalent(expected, actual, message, line_info());}
602 
613  template<typename TExpected, typename TAcutal>
614  static void are_not_equivalent(const TExpected& expected, const TAcutal& actual, const tunit::line_info& line_info) {are_not_equivalent(expected, actual, "", line_info);}
615 
626  template<typename TExpected, typename TAcutal>
627  static void are_not_equivalent(const TExpected& expected, const TAcutal& actual, const std::string& message, const tunit::line_info& line_info) {
628  try {
629  collection_assert::are_not_equivalent(expected, actual, message, line_info);
630  } catch(...) {
631  base_assert::error();
632  }
633  }
634 
636  template<typename TExpected, typename TActual>
637  static void are_not_equivalent(const std::initializer_list<TExpected>& expected, const std::initializer_list<TActual>& actual) {are_not_equivalent(expected, actual, "", line_info());}
638  template<typename TExpected, typename TActual>
639  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);}
640  template<typename TExpected, typename TActual>
641  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());}
642  template<typename TExpected, typename TActual>
643  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) {
644  try {
645  collection_assert::are_not_equivalent(expected, actual, message, line_info);
646  } catch(...) {
647  base_assert::error();
648  }
649  }
650 
652  template<typename TCollection, typename TItem>
653  static void are_not_equivalent(const TCollection& expected, const std::initializer_list<TItem>& actual) {are_not_equivalent(expected, actual, "", line_info());}
654  template<typename TCollection, typename TItem>
655  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);}
656  template<typename TCollection, typename TItem>
657  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());}
658  template<typename TCollection, typename TItem>
659  static void are_not_equivalent(const TCollection& expected, const std::initializer_list<TItem>& actual, const std::string& message, const tunit::line_info& line_info) {
660  try {
661  collection_assert::are_not_equivalent(expected, actual, message, line_info);
662  } catch(...) {
663  base_assert::error();
664  }
665  }
666 
668  template<typename TItem, typename TCollection>
669  static void are_not_equivalent(const std::initializer_list<TItem>& expected, const TCollection& actual) {are_not_equivalent(expected, actual, "", line_info());}
670  template<typename TItem, typename TCollection>
671  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);}
672  template<typename TItem, typename TCollection>
673  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());}
674  template<typename TItem, typename TCollection>
675  static void are_not_equivalent(const std::initializer_list<TItem>& expected, const TCollection& actual, const std::string& message, const tunit::line_info& line_info) {
676  try {
677  collection_assert::are_not_equivalent(expected, actual, message, line_info);
678  } catch(...) {
679  base_assert::error();
680  }
681  }
683 
694  template<typename TExpected, typename TAcutal>
695  static void contains(const TExpected& expected, const TAcutal& actual) {contains(expected, actual, "", line_info());}
696 
707  template<typename TExpected, typename TAcutal>
708  static void contains(const TExpected& expected, const TAcutal& actual, const std::string& message) {contains(expected, actual, message, line_info());}
709 
720  template<typename TExpected, typename TAcutal>
721  static void contains(const TExpected& expected, const TAcutal& actual, const tunit::line_info& line_info) {contains(expected, actual, "", line_info);}
722 
733  template<typename TExpected, typename TAcutal>
734  static void contains(const TExpected& expected, const TAcutal& actual, const std::string& message, const tunit::line_info& line_info) {
735  try {
736  collection_assert::contains(expected, actual, message, line_info);
737  } catch(...) {
738  base_assert::error();
739  }
740  }
741 
743  template<typename TItem>
744  static void contains(const std::initializer_list<TItem>& expected, const std::initializer_list<TItem>& actual) {contains(expected, actual, "", line_info());}
745  template<typename TItem>
746  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);}
747  template<typename TItem>
748  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());}
749  template<typename TItem>
750  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) {
751  try {
752  collection_assert::contains(expected, actual, message, line_info);
753  } catch(...) {
754  base_assert::error();
755  }
756  }
757 
759  template<typename TCollection, typename TItem>
760  static void contains(const TCollection& expected, const std::initializer_list<TItem>& actual) {contains(expected, actual, "", line_info());}
761  template<typename TCollection, typename TItem>
762  static void contains(const TCollection& expected, const std::initializer_list<TItem>& actual, const tunit::line_info& line_info) {contains(expected, actual, "", line_info);}
763  template<typename TCollection, typename TItem>
764  static void contains(const TCollection& expected, const std::initializer_list<TItem>& actual, const std::string& message) {contains(expected, actual, message, line_info());}
765  template<typename TCollection, typename TItem>
766  static void contains(const TCollection& expected, const std::initializer_list<TItem>& 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  base_assert::error();
771  }
772  }
773 
775  template<typename TItem, typename TCollection>
776  static void contains(const std::initializer_list<TItem>& expected, const TCollection& actual) {contains(expected, actual, "", line_info());}
777  template<typename TItem, typename TCollection>
778  static void contains(const std::initializer_list<TItem>& expected, const TCollection& actual, const tunit::line_info& line_info) {contains(expected, actual, "", line_info);}
779  template<typename TItem, typename TCollection>
780  static void contains(const std::initializer_list<TItem>& expected, const TCollection& actual, const std::string& message) {contains(expected, actual, message, line_info());}
781  template<typename TItem, typename TCollection>
782  static void contains(const std::initializer_list<TItem>& expected, const TCollection& 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  base_assert::error();
787  }
788  }
790 
801  template<typename TExpected, typename TAcutal>
802  static void does_not_contain(const TExpected& expected, const TAcutal& actual) {does_not_contain(expected, actual, "", line_info());}
803 
814  template<typename TExpected, typename TAcutal>
815  static void does_not_contain(const TExpected& expected, const TAcutal& actual, const std::string& message) {does_not_contain(expected, actual, message, line_info());}
816 
827  template<typename TExpected, typename TAcutal>
828  static void does_not_contain(const TExpected& expected, const TAcutal& actual, const tunit::line_info& line_info) {does_not_contain(expected, actual, "", line_info);}
829 
840  template<typename TExpected, typename TAcutal>
841  static void does_not_contain(const TExpected& expected, const TAcutal& actual, const std::string& message, const tunit::line_info& line_info) {
842  try {
843  collection_assert::does_not_contain(expected, actual, message, line_info);
844  } catch(...) {
845  base_assert::error();
846  }
847  }
848 
850  template<typename TItem>
851  static void does_not_contain(const std::initializer_list<TItem>& expected, const std::initializer_list<TItem>& actual) {does_not_contain(expected, actual, "", line_info());}
852  template<typename TItem>
853  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);}
854  template<typename TItem>
855  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());}
856  template<typename TItem>
857  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) {
858  try {
859  collection_assert::does_not_contain(expected, actual, message, line_info);
860  } catch(...) {
861  base_assert::error();
862  }
863  }
864 
866  template<typename TCollection, typename TItem>
867  static void does_not_contain(const TCollection& expected, const std::initializer_list<TItem>& actual) {does_not_contain(expected, actual, "", line_info());}
868  template<typename TCollection, typename TItem>
869  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);}
870  template<typename TCollection, typename TItem>
871  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());}
872  template<typename TCollection, typename TItem>
873  static void does_not_contain(const TCollection& expected, const std::initializer_list<TItem>& actual, const std::string& message, const tunit::line_info& line_info) {
874  try {
875  collection_assert::does_not_contain(expected, actual, message, line_info);
876  } catch(...) {
877  base_assert::error();
878  }
879  }
880 
882  template<typename TItem, typename TCollection>
883  static void does_not_contain(const std::initializer_list<TItem>& expected, const TCollection& actual) {does_not_contain(expected, actual, "", line_info());}
884  template<typename TItem, typename TCollection>
885  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);}
886  template<typename TItem, typename TCollection>
887  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());}
888  template<typename TItem, typename TCollection>
889  static void does_not_contain(const std::initializer_list<TItem>& expected, const TCollection& actual, const std::string& message, const tunit::line_info& line_info) {
890  try {
891  collection_assert::does_not_contain(expected, actual, message, line_info);
892  } catch(...) {
893  base_assert::error();
894  }
895  }
897 
907  template<typename TValue>
908  static void is_empty(const TValue& value) {is_empty(value, "", line_info());}
909 
920  template<typename TValue>
921  static void is_empty(const TValue& value, const tunit::line_info& line_info) {is_empty(value, "", line_info);}
922 
933  template<typename TValue>
934  static void is_empty(const TValue& value, const std::string& message) {is_empty(value, message, line_info());}
935 
947  template<typename TValue>
948  static void is_empty(const TValue& value, const std::string& message, const tunit::line_info& line_info) {
949  try {
950  collection_assert::is_empty(value, message, line_info);
951  } catch(...) {
952  base_assert::error();
953  }
954  }
955 
957  template<typename TValue>
958  static void is_empty(const std::initializer_list<TValue>& value) {is_empty(value, "", line_info());}
959  template<typename TValue>
960  static void is_empty(const std::initializer_list<TValue>& value, const tunit::line_info& line_info) {is_empty(value, "", line_info);}
961  template<typename TValue>
962  static void is_empty(const std::initializer_list<TValue>& value, const std::string& message) {is_empty(value, message, line_info());}
963  template<typename TValue>
964  static void is_empty(const std::initializer_list<TValue>& value, const std::string& message, const tunit::line_info& line_info) {
965  try {
966  collection_assert::is_empty(value, message, line_info);
967  } catch(...) {
968  base_assert::error();
969  }
970  }
972 
982  template<typename TValue>
983  static void is_not_empty(const TValue& value) {is_not_empty(value, "", line_info());}
984 
995  template<typename TValue>
996  static void is_not_empty(const TValue& value, const tunit::line_info& line_info) {is_not_empty(value, "", line_info);}
997 
1008  template<typename TValue>
1009  static void is_not_empty(const TValue& value, const std::string& message) {is_not_empty(value, message, line_info());}
1010 
1022  template<typename TValue>
1023  static void is_not_empty(const TValue& value, const std::string& message, const tunit::line_info& line_info) {
1024  try {
1025  collection_assert::is_not_empty(value, message, line_info);
1026  } catch(...) {
1027  base_assert::error();
1028  }
1029  }
1030 
1032  template<typename TValue>
1033  static void is_not_empty(const std::initializer_list<TValue>& value) {is_not_empty(value, "", line_info());}
1034  template<typename TValue>
1035  static void is_not_empty(const std::initializer_list<TValue>& value, const tunit::line_info& line_info) {is_not_empty(value, "", line_info);}
1036  template<typename TValue>
1037  static void is_not_empty(const std::initializer_list<TValue>& value, const std::string& message) {is_not_empty(value, message, line_info());}
1038  template<typename TValue>
1039  static void is_not_empty(const std::initializer_list<TValue>& value, const std::string& message, const tunit::line_info& line_info) {
1040  try {
1041  collection_assert::is_not_empty(value, message, line_info);
1042  } catch(...) {
1043  base_assert::error();
1044  }
1045  }
1047 
1057  template<typename TValue>
1058  static void is_ordered(const TValue& value) {is_ordered(value, "", line_info());}
1059 
1070  template<typename TValue>
1071  static void is_ordered(const TValue& value, const tunit::line_info& line_info) {is_ordered(value, "", line_info);}
1072 
1083  template<typename TValue>
1084  static void is_ordered(const TValue& value, const std::string& message) {is_ordered(value, message, line_info());}
1085 
1097  template<typename TValue>
1098  static void is_ordered(const TValue& value, const std::string& message, const tunit::line_info& line_info) {
1099  try {
1100  collection_assert::is_ordered(value, message, line_info);
1101  } catch(...) {
1102  base_assert::error();
1103  }
1104  }
1105 
1107  template<typename TValue>
1108  static void is_ordered(const std::initializer_list<TValue>& value) {is_ordered(value, "", line_info());}
1109  template<typename TValue>
1110  static void is_ordered(const std::initializer_list<TValue>& value, const tunit::line_info& line_info) {is_ordered(value, "", line_info);}
1111  template<typename TValue>
1112  static void is_ordered(const std::initializer_list<TValue>& value, const std::string& message) {is_ordered(value, message, line_info());}
1113  template<typename TValue>
1114  static void is_ordered(const std::initializer_list<TValue>& value, const std::string& message, const tunit::line_info& line_info) {
1115  try {
1116  collection_assert::is_ordered(value, message, line_info);
1117  } catch(...) {
1118  base_assert::error();
1119  }
1120  }
1122  };
1123 }
tunit::collection_valid::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)
Valids that all collection items are not null.
Definition: collection_valid.h:152
tunit::collection_valid::are_equal
static void are_equal(const TExpected &expected, const TAcutal &actual, const std::string &message)
Valids that all collection items are equal.
Definition: collection_valid.h:280
tunit::collection_valid::contains
static void contains(const TExpected &expected, const TAcutal &actual, const tunit::line_info &line_info)
Valids that collection contains all items.
Definition: collection_valid.h:721
tunit::collection_valid::are_equivalent
static void are_equivalent(const TExpected &expected, const TAcutal &actual, const tunit::line_info &line_info)
Valids that all collection items are equivalent.
Definition: collection_valid.h:400
tunit::collection_valid::is_not_empty
static void is_not_empty(const TValue &value, const tunit::line_info &line_info)
Valids that collection or traits does not contain any item.
Definition: collection_valid.h:996
tunit::collection_valid::are_not_equal
static void are_not_equal(const TExpected &expected, const TAcutal &actual, const std::string &message, const tunit::line_info &line_info)
Valids that all collection items arenot equal.
Definition: collection_valid.h:520
tunit::collection_valid::are_not_equal
static void are_not_equal(const TExpected &expected, const TAcutal &actual)
Valids that all collection items are not equal.
Definition: collection_valid.h:481
tunit::collection_valid::are_equivalent
static void are_equivalent(const TExpected &expected, const TAcutal &actual, const std::string &message)
Valids that all collection items are equivalent.
Definition: collection_valid.h:387
tunit::collection_valid::does_not_contain
static void does_not_contain(const TExpected &expected, const TAcutal &actual, const std::string &message, const tunit::line_info &line_info)
Valids that collection contains all items.
Definition: collection_valid.h:841
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_valid::are_equal
static void are_equal(const TExpected &expected, const TAcutal &actual, const std::string &message, const tunit::line_info &line_info)
Valids that all collection items are equal.
Definition: collection_valid.h:306
tunit::collection_valid::contains
static void contains(const TExpected &expected, const TAcutal &actual, const std::string &message)
Valids that collection contains all items.
Definition: collection_valid.h:708
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_valid::contains
static void contains(const TExpected &expected, const TAcutal &actual)
Valids that ollection contains all items.
Definition: collection_valid.h:695
tunit::collection_valid::does_not_contain
static void does_not_contain(const TExpected &expected, const TAcutal &actual, const tunit::line_info &line_info)
Valids that collection contains all items.
Definition: collection_valid.h:828
tunit::collection_valid::is_ordered
static void is_ordered(const TValue &value, const std::string &message, const tunit::line_info &line_info)
Valids that collection is ordered.
Definition: collection_valid.h:1098
tunit::collection_valid::does_not_contain
static void does_not_contain(const TExpected &expected, const TAcutal &actual)
Valids that ollection contains all items.
Definition: collection_valid.h:802
tunit::collection_valid::is_not_empty
static void is_not_empty(const TValue &value)
Valids that collection does not contain any item.
Definition: collection_valid.h:983
tunit::collection_valid::all_items_are_instances_of
static void all_items_are_instances_of(const TCollection &collection, const std::string &message)
Valids that all collection items are of the type supplied or a derived type.
Definition: collection_valid.h:43
tunit::collection_valid::are_equivalent
static void are_equivalent(const TExpected &expected, const TAcutal &actual)
Valids that all collection items are equivalent.
Definition: collection_valid.h:374
tunit::collection_valid::are_equivalent
static void are_equivalent(const TExpected &expected, const TAcutal &actual, const std::string &message, const tunit::line_info &line_info)
Valids that all collection items are equivalent.
Definition: collection_valid.h:413
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_valid
The collection_valid class contains a collection of static methods that implement the most collection...
Definition: collection_valid.h:13
tunit::collection_valid::is_empty
static void is_empty(const TValue &value, const std::string &message, const tunit::line_info &line_info)
Valids that collection contains an item.
Definition: collection_valid.h:948
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_valid::all_items_are_not_null
static void all_items_are_not_null(const TCollection &collection, const std::string &message)
Valids that all collection items are not null.
Definition: collection_valid.h:122
tunit::collection_valid::is_empty
static void is_empty(const TValue &value, const std::string &message)
Valids that collection contains an item.
Definition: collection_valid.h:934
tunit::collection_valid::are_not_equivalent
static void are_not_equivalent(const TExpected &expected, const TAcutal &actual)
Valids that all collection items are not equivalent.
Definition: collection_valid.h:588
tunit::collection_valid::all_items_are_unique
static void all_items_are_unique(const TCollection &collection, const tunit::line_info &line_info)
Valids that all collection items are unique.
Definition: collection_valid.h:217
collection_valid.h
Contains tunit::collection_valid class.
tunit::collection_valid::all_items_are_unique
static void all_items_are_unique(const TCollection &collection, const std::string &message)
Valids that all collection items are unique.
Definition: collection_valid.h:203
tunit::collection_valid::all_items_are_unique
static void all_items_are_unique(const TCollection &collection, const std::string &message, const tunit::line_info &line_info)
Valids that all collection items are unique.
Definition: collection_valid.h:231
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::collection_valid::is_not_empty
static void is_not_empty(const TValue &value, const std::string &message, const tunit::line_info &line_info)
Valids that collection or traits does not contain any item.
Definition: collection_valid.h:1023
tunit::collection_valid::all_items_are_instances_of
static void all_items_are_instances_of(const TCollection &collection)
Valids that all collection items are of the type supplied or a derived type.
Definition: collection_valid.h:30
tunit::collection_valid::are_not_equivalent
static void are_not_equivalent(const TExpected &expected, const TAcutal &actual, const std::string &message, const tunit::line_info &line_info)
Valids that all collection items are not equivalent.
Definition: collection_valid.h:627
tunit::collection_valid::are_not_equal
static void are_not_equal(const TExpected &expected, const TAcutal &actual, const std::string &message)
Valids that all collection items are not equal.
Definition: collection_valid.h:494
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_valid::are_not_equivalent
static void are_not_equivalent(const TExpected &expected, const TAcutal &actual, const tunit::line_info &line_info)
Valids that all collection items are not equivalent.
Definition: collection_valid.h:614
tunit::collection_valid::is_empty
static void is_empty(const TValue &value)
Valids that collection contains an item.
Definition: collection_valid.h:908
tunit::collection_valid::all_items_are_not_null
static void all_items_are_not_null(const TCollection &collection)
Valids that all collection items are not null.
Definition: collection_valid.h:107
valid.h
Contains tunit::valid class.
tunit::base_assert
Definition: base_assert.h:15
tunit::collection_valid::is_empty
static void is_empty(const TValue &value, const tunit::line_info &line_info)
Valids that collection contains an item.
Definition: collection_valid.h:921
tunit::collection_assert::is_empty
static void is_empty(const TValue &value)
Asserts that collection contains an item.
Definition: collection_assert.h:985
tunit
The tunit namespace contains a unit test library.
Definition: abort_error.h:8
tunit::collection_valid::is_ordered
static void is_ordered(const TValue &value)
Valids that collection is ordered.
Definition: collection_valid.h:1058
tunit::collection_valid::contains
static void contains(const TExpected &expected, const TAcutal &actual, const std::string &message, const tunit::line_info &line_info)
Valids that collection contains all items.
Definition: collection_valid.h:734
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_valid::all_items_are_unique
static void all_items_are_unique(const TCollection &collection)
Valids that all collection items are unique.
Definition: collection_valid.h:189
tunit::collection_valid::all_items_are_not_null
static void all_items_are_not_null(const TCollection &collection, const tunit::line_info &line_info)
Valids that all collection items are not null.
Definition: collection_valid.h:137
tunit::collection_valid::is_ordered
static void is_ordered(const TValue &value, const tunit::line_info &line_info)
Valids that collection is ordered.
Definition: collection_valid.h:1071
tunit::collection_valid::are_not_equivalent
static void are_not_equivalent(const TExpected &expected, const TAcutal &actual, const std::string &message)
Valids that all collection items are not equivalent.
Definition: collection_valid.h:601
tunit::collection_assert::is_ordered
static void is_ordered(const TValue &value)
Asserts that collection is ordered.
Definition: collection_assert.h:1139
tunit::collection_valid::are_not_equal
static void are_not_equal(const TExpected &expected, const TAcutal &actual, const tunit::line_info &line_info)
Valids that all collection items are not equal.
Definition: collection_valid.h:507
tunit::collection_valid::is_not_empty
static void is_not_empty(const TValue &value, const std::string &message)
Valids that collection or traits does not contain any item.
Definition: collection_valid.h:1009
tunit::collection_valid::is_ordered
static void is_ordered(const TValue &value, const std::string &message)
Valids that collection is ordered.
Definition: collection_valid.h:1084
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_valid::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)
Valids that all collection items are of the type supplied or a derived type.
Definition: collection_valid.h:69
tunit::collection_valid::are_equal
static void are_equal(const TExpected &expected, const TAcutal &actual)
Valids that all collection items are equal.
Definition: collection_valid.h:267
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_valid::are_equal
static void are_equal(const TExpected &expected, const TAcutal &actual, const tunit::line_info &line_info)
Valids that all collection items are equal.
Definition: collection_valid.h:293
tunit::collection_valid::all_items_are_instances_of
static void all_items_are_instances_of(const TCollection &collection, const tunit::line_info &line_info)
Valids that all collection items are of the type supplied or a derived type.
Definition: collection_valid.h:56
tunit::collection_valid::does_not_contain
static void does_not_contain(const TExpected &expected, const TAcutal &actual, const std::string &message)
Valids that collection contains all items.
Definition: collection_valid.h:815
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