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
8#include "../helpers/input_iterator.hpp"
9#include "../helpers/invariants.hpp"
10#include "../helpers/random_values.hpp"
11#include "../helpers/tracker.hpp"
12
13template <typename T> inline void avoid_unused_warning(T const&) {}
14
15test::seed_t initialize_seed(91274);
16
17struct objects
18{
19 test::exception::object obj;
20 test::exception::hash hash;
21 test::exception::equal_to equal_to;
22 test::exception::allocator<test::exception::object> allocator;
23};
24
25template <class T> struct construct_test1 : public objects, test::exception_base
26{
27 void run() const
28 {
29 T x;
30
31 DISABLE_EXCEPTIONS;
32 BOOST_TEST(x.empty());
33 test::check_equivalent_keys(x);
34 }
35};
36
37template <class T> struct construct_test2 : public objects, test::exception_base
38{
39 void run() const
40 {
41 T x(300);
42
43 DISABLE_EXCEPTIONS;
44 BOOST_TEST(x.empty());
45 test::check_equivalent_keys(x);
46 }
47};
48
49template <class T> struct construct_test3 : public objects, test::exception_base
50{
51 void run() const
52 {
53 T x(0, hash);
54
55 DISABLE_EXCEPTIONS;
56 BOOST_TEST(x.empty());
57 test::check_equivalent_keys(x);
58 }
59};
60
61template <class T> struct construct_test4 : public objects, test::exception_base
62{
63 void run() const
64 {
65 T x(0, hash, equal_to);
66
67 DISABLE_EXCEPTIONS;
68 BOOST_TEST(x.empty());
69 test::check_equivalent_keys(x);
70 }
71};
72
73template <class T> struct construct_test5 : public objects, test::exception_base
74{
75 void run() const
76 {
77 T x(50, hash, equal_to, allocator);
78
79 DISABLE_EXCEPTIONS;
80 BOOST_TEST(x.empty());
81 test::check_equivalent_keys(x);
82 }
83};
84
85template <class T> struct construct_test6 : public objects, test::exception_base
86{
87 void run() const
88 {
89 T x(allocator);
90
91 DISABLE_EXCEPTIONS;
92 BOOST_TEST(x.empty());
93 test::check_equivalent_keys(x);
94 }
95};
96
97template <class T> struct range : public test::exception_base
98{
99 test::random_values<T> values;
100
101 range() : values(5, test::limited_range) {}
102 range(unsigned int count) : values(count, test::limited_range) {}
103};
104
105template <class T> struct range_construct_test1 : public range<T>, objects
106{
107 void run() const
108 {
109 T x(this->values.begin(), this->values.end());
110
111 DISABLE_EXCEPTIONS;
112 test::check_container(x, this->values);
113 test::check_equivalent_keys(x);
114 }
115};
116
117template <class T> struct range_construct_test2 : public range<T>, objects
118{
119 void run() const
120 {
121 T x(this->values.begin(), this->values.end(), 0);
122
123 DISABLE_EXCEPTIONS;
124 test::check_container(x, this->values);
125 test::check_equivalent_keys(x);
126 }
127};
128
129template <class T> struct range_construct_test3 : public range<T>, objects
130{
131 void run() const
132 {
133 T x(this->values.begin(), this->values.end(), 0, hash);
134
135 DISABLE_EXCEPTIONS;
136 test::check_container(x, this->values);
137 test::check_equivalent_keys(x);
138 }
139};
140
141template <class T> struct range_construct_test4 : public range<T>, objects
142{
143 void run() const
144 {
145 T x(this->values.begin(), this->values.end(), 100, hash, equal_to);
146
147 DISABLE_EXCEPTIONS;
148 test::check_container(x, this->values);
149 test::check_equivalent_keys(x);
150 }
151};
152
153// Need to run at least one test with a fairly large number
154// of objects in case it triggers a rehash.
155template <class T> struct range_construct_test5 : public range<T>, objects
156{
157 range_construct_test5() : range<T>(60) {}
158
159 void run() const
160 {
161 T x(this->values.begin(), this->values.end(), 0, hash, equal_to, allocator);
162
163 DISABLE_EXCEPTIONS;
164 test::check_container(x, this->values);
165 test::check_equivalent_keys(x);
166 }
167};
168
169template <class T> struct input_range_construct_test : public range<T>, objects
170{
171 input_range_construct_test() : range<T>(60) {}
172
173 void run() const
174 {
175 typename test::random_values<T>::const_iterator begin =
176 this->values.begin(),
177 end = this->values.end();
178 T x(test::input_iterator(begin), test::input_iterator(end), 0, hash,
179 equal_to, allocator);
180
181 DISABLE_EXCEPTIONS;
182 test::check_container(x, this->values);
183 test::check_equivalent_keys(x);
184 }
185};
186
187template <class T> struct copy_range_construct_test : public range<T>, objects
188{
189 copy_range_construct_test() : range<T>(60) {}
190
191 void run() const
192 {
193 T x(test::copy_iterator(this->values.begin()),
194 test::copy_iterator(this->values.end()), 0, hash, equal_to, allocator);
195
196 DISABLE_EXCEPTIONS;
197 test::check_container(x, this->values);
198 test::check_equivalent_keys(x);
199 }
200};
201
202// clang-format off
203EXCEPTION_TESTS(
204 (construct_test1)(construct_test2)(construct_test3)(construct_test4)
205 (construct_test5)(construct_test6)(range_construct_test1)
206 (range_construct_test2)(range_construct_test3)(range_construct_test4)
207 (range_construct_test5)(input_range_construct_test)
208 (copy_range_construct_test),
209 CONTAINER_SEQ)
210// clang-format on
211
212RUN_TESTS()
213

source code of boost/libs/unordered/test/exception/constructor_exception_tests.cpp