ceph/src/boost/libs/unordered/test/exception/assign_exception_tests.cpp

   1
   2 // Copyright 2006-2009 Daniel James.
   3 // Distributed under the Boost Software License, Version 1.0. (See accompanying
   4 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   5
   6 #include "./containers.hpp"
   7 #include "../helpers/random_values.hpp"
   8 #include "../helpers/invariants.hpp"
   9
  10 #if defined(BOOST_MSVC)
  11 #pragma warning(disable:4512) // assignment operator could not be generated
  12 #endif
  13
  14 test::seed_t initialize_seed(12847);
  15
  16 template <class T>
  17 struct self_assign_base : public test::exception_base
  18 {
  19     test::random_values<T> values;
  20     self_assign_base(std::size_t count = 0) : values(count) {}
  21
  22     typedef T data_type;
  23     T init() const { return T(values.begin(), values.end()); }
  24     void run(T& x) const { x = x; }
  25     void check BOOST_PREVENT_MACRO_SUBSTITUTION(T const& x) const
  26         { test::check_equivalent_keys(x); }
  27 };
  28
  29 template <class T>
  30 struct self_assign_test1 : self_assign_base<T> {};
  31
  32 template <class T>
  33 struct self_assign_test2 : self_assign_base<T>
  34 {
  35     self_assign_test2() : self_assign_base<T>(100) {}
  36 };
  37
  38 template <class T>
  39 struct assign_base : public test::exception_base
  40 {
  41     test::random_values<T> x_values, y_values;
  42     T x,y;
  43
  44     typedef BOOST_DEDUCED_TYPENAME T::hasher hasher;
  45     typedef BOOST_DEDUCED_TYPENAME T::key_equal key_equal;
  46     typedef BOOST_DEDUCED_TYPENAME T::allocator_type allocator_type;
  47
  48     assign_base(int tag1, int tag2, float mlf1 = 1.0, float mlf2 = 1.0) :
  49         x_values(),
  50         y_values(),
  51         x(0, hasher(tag1), key_equal(tag1), allocator_type(tag1)),
  52         y(0, hasher(tag2), key_equal(tag2), allocator_type(tag2))
  53     {
  54         x.max_load_factor(mlf1);
  55         y.max_load_factor(mlf2);
  56     }
  57
  58     typedef T data_type;
  59     T init() const { return T(x); }
  60     void run(T& x1) const { x1 = y; }
  61     void check BOOST_PREVENT_MACRO_SUBSTITUTION(T const& x1) const
  62     {
  63         test::check_equivalent_keys(x1);
  64
  65         // If the container is empty at the point of the exception, the
  66         // internal structure is hidden, this exposes it, at the cost of
  67         // messing up the data.
  68         if (x_values.size()) {
  69             T& x2 = const_cast<T&>(x1);
  70             x2.emplace(*x_values.begin());
  71             test::check_equivalent_keys(x2);
  72         }
  73     }
  74 };
  75
  76 template <class T>
  77 struct assign_values : assign_base<T>
  78 {
  79     assign_values(unsigned int count1, unsigned int count2,
  80             int tag1, int tag2, float mlf1 = 1.0, float mlf2 = 1.0) :
  81         assign_base<T>(tag1, tag2, mlf1, mlf2)
  82     {
  83         this->x_values.fill(count1);
  84         this->y_values.fill(count2);
  85         this->x.insert(this->x_values.begin(), this->x_values.end());
  86         this->y.insert(this->y_values.begin(), this->y_values.end());
  87     }
  88 };
  89
  90 template <class T>
  91 struct assign_test1 : assign_values<T>
  92 {
  93     assign_test1() : assign_values<T>(0, 0, 0, 0) {}
  94 };
  95
  96 template <class T>
  97 struct assign_test2 : assign_values<T>
  98 {
  99     assign_test2() : assign_values<T>(60, 0, 0, 0) {}
 100 };
 101
 102 template <class T>
 103 struct assign_test3 : assign_values<T>
 104 {
 105     assign_test3() : assign_values<T>(0, 60, 0, 0) {}
 106 };
 107
 108 template <class T>
 109 struct assign_test4 : assign_values<T>
 110 {
 111     assign_test4() : assign_values<T>(10, 10, 1, 2) {}
 112 };
 113
 114 template <class T>
 115 struct assign_test4a : assign_values<T>
 116 {
 117     assign_test4a() : assign_values<T>(10, 100, 1, 2) {}
 118 };
 119
 120 template <class T>
 121 struct assign_test5 : assign_values<T>
 122 {
 123     assign_test5() : assign_values<T>(5, 60, 0, 0, 1.0f, 0.1f) {}
 124 };
 125
 126 template <class T>
 127 struct equivalent_test1 : assign_base<T>
 128 {
 129     equivalent_test1() :
 130         assign_base<T>(0, 0)
 131     {
 132         test::random_values<T> x_values2(10);
 133         this->x_values.insert(x_values2.begin(), x_values2.end());
 134         this->x_values.insert(x_values2.begin(), x_values2.end());
 135         test::random_values<T> y_values2(10);
 136         this->y_values.insert(y_values2.begin(), y_values2.end());
 137         this->y_values.insert(y_values2.begin(), y_values2.end());
 138         this->x.insert(this->x_values.begin(), this->x_values.end());
 139         this->y.insert(this->y_values.begin(), this->y_values.end());
 140     }
 141 };
 142
 143 EXCEPTION_TESTS(
 144     (self_assign_test1)(self_assign_test2)
 145     (assign_test1)(assign_test2)(assign_test3)(assign_test4)(assign_test4a)(assign_test5)
 146     (equivalent_test1),
 147     CONTAINER_SEQ)
 148 RUN_TESTS()