[ceph.git] / ceph / src / boost / libs / unordered / test / unordered / compile_set.cpp


// Copyright 2006-2009 Daniel James.
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

// This test creates the containers with members that meet their minimum
// requirements. Makes sure everything compiles and is defined correctly.

#include "../helpers/prefix.hpp"
#include <boost/unordered_set.hpp>
#include "../helpers/postfix.hpp"

#include <iostream>
#include "../helpers/test.hpp"
#include "../objects/minimal.hpp"
#include "./compile_tests.hpp"

// Explicit instantiation to catch compile-time errors

template class boost::unordered_set<
    int,
    boost::hash<int>,
    std::equal_to<int>,
    test::minimal::allocator<int> >;
template class boost::unordered_multiset<
    int const,
    boost::hash<int>,
    std::equal_to<int>,
    test::minimal::allocator<int> >;

template class boost::unordered_set<
    test::minimal::assignable const,
    test::minimal::hash<test::minimal::assignable>,
    test::minimal::equal_to<test::minimal::assignable>,
    test::minimal::allocator<test::minimal::assignable> >;
template class boost::unordered_multiset<
    test::minimal::assignable,
    test::minimal::hash<test::minimal::assignable>,
    test::minimal::equal_to<test::minimal::assignable>,
    test::minimal::allocator<test::minimal::assignable> >;

UNORDERED_AUTO_TEST(test0)
{
    test::minimal::constructor_param x;

    test::minimal::assignable assignable(x);

    std::cout<<"Test unordered_set.\n";

    boost::unordered_set<int> int_set;

    boost::unordered_set<int,
        boost::hash<int>, std::equal_to<int>,
        test::minimal::cxx11_allocator<int>
        > int_set2;

    boost::unordered_set<
        test::minimal::assignable,
        test::minimal::hash<test::minimal::assignable>,
        test::minimal::equal_to<test::minimal::assignable>,
        test::minimal::allocator<test::minimal::assignable> > set;

    container_test(int_set, 0);
    container_test(int_set2, 0);
    container_test(set, assignable);

    std::cout<<"Test unordered_multiset.\n";

    boost::unordered_multiset<int> int_multiset;

    boost::unordered_multiset<int,
        boost::hash<int>, std::equal_to<int>,
        test::minimal::cxx11_allocator<int>
        > int_multiset2;

    boost::unordered_multiset<
        test::minimal::assignable,
        test::minimal::hash<test::minimal::assignable>,
        test::minimal::equal_to<test::minimal::assignable>,
        test::minimal::allocator<test::minimal::assignable> > multiset;

    container_test(int_multiset, 0);
    container_test(int_multiset2, 0);
    container_test(multiset, assignable);
}

UNORDERED_AUTO_TEST(equality_tests) {
    typedef test::minimal::copy_constructible_equality_comparable value_type;

    boost::unordered_set<int> int_set;

    boost::unordered_set<int,
        boost::hash<int>, std::equal_to<int>,
        test::minimal::cxx11_allocator<int>
        > int_set2;

    boost::unordered_set<
        test::minimal::copy_constructible_equality_comparable,
        test::minimal::hash<test::minimal::copy_constructible_equality_comparable>,
        test::minimal::equal_to<test::minimal::copy_constructible_equality_comparable>,
        test::minimal::allocator<value_type> > set;

    equality_test(int_set);
    equality_test(int_set2);
    equality_test(set);

    boost::unordered_multiset<int> int_multiset;

    boost::unordered_multiset<int,
        boost::hash<int>, std::equal_to<int>,
        test::minimal::cxx11_allocator<int>
        > int_multiset2;

    boost::unordered_multiset<
        test::minimal::copy_constructible_equality_comparable,
        test::minimal::hash<test::minimal::copy_constructible_equality_comparable>,
        test::minimal::equal_to<test::minimal::copy_constructible_equality_comparable>,
        test::minimal::allocator<value_type> > multiset;

    equality_test(int_multiset);
    equality_test(int_multiset2);
    equality_test(multiset);
}

UNORDERED_AUTO_TEST(test1)
{
    boost::hash<int> hash;
    std::equal_to<int> equal_to;
    int value = 0;

    std::cout<<"Test unordered_set." << std::endl;

    boost::unordered_set<int> set;
    
    boost::unordered_set<int,
        boost::hash<int>, std::equal_to<int>,
        test::minimal::cxx11_allocator<int>
        > set2;

    unordered_unique_test(set, value);
    unordered_set_test(set, value);
    unordered_copyable_test(set, value, value, hash, equal_to);

    unordered_unique_test(set2, value);
    unordered_set_test(set2, value);
    unordered_copyable_test(set2, value, value, hash, equal_to);

    std::cout<<"Test unordered_multiset." << std::endl;

    boost::unordered_multiset<int> multiset;
    
    boost::unordered_multiset<int,
        boost::hash<int>, std::equal_to<int>,
        test::minimal::cxx11_allocator<int>
        > multiset2;

    unordered_equivalent_test(multiset, value);
    unordered_set_test(multiset, value);
    unordered_copyable_test(multiset, value, value, hash, equal_to);

    unordered_equivalent_test(multiset2, value);
    unordered_set_test(multiset2, value);
    unordered_copyable_test(multiset2, value, value, hash, equal_to);
}

UNORDERED_AUTO_TEST(test2)
{
    test::minimal::constructor_param x;
 
    test::minimal::assignable assignable(x);
    test::minimal::copy_constructible copy_constructible(x);
    test::minimal::hash<test::minimal::assignable> hash(x);
    test::minimal::equal_to<test::minimal::assignable> equal_to(x);

    std::cout<<"Test unordered_set.\n";

    boost::unordered_set<
        test::minimal::assignable,
        test::minimal::hash<test::minimal::assignable>,
        test::minimal::equal_to<test::minimal::assignable>,
        test::minimal::allocator<test::minimal::assignable> > set;

    unordered_unique_test(set, assignable);
    unordered_set_test(set, assignable);
    unordered_copyable_test(set, assignable, assignable, hash, equal_to);
    unordered_set_member_test(set, assignable);

    std::cout<<"Test unordered_multiset.\n";

    boost::unordered_multiset<
        test::minimal::assignable,
        test::minimal::hash<test::minimal::assignable>,
        test::minimal::equal_to<test::minimal::assignable>,
        test::minimal::allocator<test::minimal::assignable> > multiset;

    unordered_equivalent_test(multiset, assignable);
    unordered_set_test(multiset, assignable);
    unordered_copyable_test(multiset, assignable, assignable, hash, equal_to);
    unordered_set_member_test(multiset, assignable);
}

UNORDERED_AUTO_TEST(movable1_tests)
{
    test::minimal::constructor_param x;

    test::minimal::movable1 movable1(x);
    test::minimal::hash<test::minimal::movable1> hash(x);
    test::minimal::equal_to<test::minimal::movable1> equal_to(x);

    std::cout<<"Test unordered_set.\n";

    boost::unordered_set<
        test::minimal::movable1,
        test::minimal::hash<test::minimal::movable1>,
        test::minimal::equal_to<test::minimal::movable1>,
        test::minimal::allocator<test::minimal::movable1> > set;

    //unordered_unique_test(set, movable1);
    unordered_set_test(set, movable1);
    unordered_movable_test(set, movable1, movable1, hash, equal_to);

    std::cout<<"Test unordered_multiset.\n";

    boost::unordered_multiset<
        test::minimal::movable1,
        test::minimal::hash<test::minimal::movable1>,
        test::minimal::equal_to<test::minimal::movable1>,
        test::minimal::allocator<test::minimal::movable1> > multiset;

    //unordered_equivalent_test(multiset, movable1);
    unordered_set_test(multiset, movable1);
    unordered_movable_test(multiset, movable1, movable1, hash, equal_to);
}

UNORDERED_AUTO_TEST(movable2_tests)
{
    test::minimal::constructor_param x;

    test::minimal::movable2 movable2(x);
    test::minimal::hash<test::minimal::movable2> hash(x);
    test::minimal::equal_to<test::minimal::movable2> equal_to(x);

    std::cout<<"Test unordered_set.\n";

    boost::unordered_set<
        test::minimal::movable2,
        test::minimal::hash<test::minimal::movable2>,
        test::minimal::equal_to<test::minimal::movable2>,
        test::minimal::allocator<test::minimal::movable2> > set;

    //unordered_unique_test(set, movable2);
    unordered_set_test(set, movable2);
    unordered_movable_test(set, movable2, movable2, hash, equal_to);

    std::cout<<"Test unordered_multiset.\n";

    boost::unordered_multiset<
        test::minimal::movable2,
        test::minimal::hash<test::minimal::movable2>,
        test::minimal::equal_to<test::minimal::movable2>,
        test::minimal::allocator<test::minimal::movable2> > multiset;

    //unordered_equivalent_test(multiset, movable2);
    unordered_set_test(multiset, movable2);
    unordered_movable_test(multiset, movable2, movable2, hash, equal_to);
}

UNORDERED_AUTO_TEST(destructible_tests)
{
    test::minimal::constructor_param x;

    test::minimal::destructible destructible(x);
    test::minimal::hash<test::minimal::destructible> hash(x);
    test::minimal::equal_to<test::minimal::destructible> equal_to(x);

    std::cout<<"Test unordered_set.\n";

    boost::unordered_set<
        test::minimal::destructible,
        test::minimal::hash<test::minimal::destructible>,
        test::minimal::equal_to<test::minimal::destructible> > set;

    unordered_destructible_test(set);

    std::cout<<"Test unordered_multiset.\n";

    boost::unordered_multiset<
        test::minimal::destructible,
        test::minimal::hash<test::minimal::destructible>,
        test::minimal::equal_to<test::minimal::destructible> > multiset;

    unordered_destructible_test(multiset);
}

RUN_TESTS()
Commit	Line	Data
7c673cae FG	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	// This test creates the containers with members that meet their minimum
	7	// requirements. Makes sure everything compiles and is defined correctly.
	8
	9	#include "../helpers/prefix.hpp"
	10	#include <boost/unordered_set.hpp>
	11	#include "../helpers/postfix.hpp"
	12
	13	#include <iostream>
	14	#include "../helpers/test.hpp"
	15	#include "../objects/minimal.hpp"
	16	#include "./compile_tests.hpp"
	17
	18	// Explicit instantiation to catch compile-time errors
	19
	20	template class boost::unordered_set<
	21	int,
	22	boost::hash<int>,
	23	std::equal_to<int>,
	24	test::minimal::allocator<int> >;
	25	template class boost::unordered_multiset<
	26	int const,
	27	boost::hash<int>,
	28	std::equal_to<int>,
	29	test::minimal::allocator<int> >;
	30
	31	template class boost::unordered_set<
	32	test::minimal::assignable const,
	33	test::minimal::hash<test::minimal::assignable>,
	34	test::minimal::equal_to<test::minimal::assignable>,
	35	test::minimal::allocator<test::minimal::assignable> >;
	36	template class boost::unordered_multiset<
	37	test::minimal::assignable,
	38	test::minimal::hash<test::minimal::assignable>,
	39	test::minimal::equal_to<test::minimal::assignable>,
	40	test::minimal::allocator<test::minimal::assignable> >;
	41
	42	UNORDERED_AUTO_TEST(test0)
	43	{
	44	test::minimal::constructor_param x;
	45
	46	test::minimal::assignable assignable(x);
	47
	48	std::cout<<"Test unordered_set.\n";
	49
	50	boost::unordered_set<int> int_set;
	51
	52	boost::unordered_set<int,
	53	boost::hash<int>, std::equal_to<int>,
	54	test::minimal::cxx11_allocator<int>
	55	> int_set2;
	56
	57	boost::unordered_set<
	58	test::minimal::assignable,
	59	test::minimal::hash<test::minimal::assignable>,
	60	test::minimal::equal_to<test::minimal::assignable>,
	61	test::minimal::allocator<test::minimal::assignable> > set;
	62
	63	container_test(int_set, 0);
	64	container_test(int_set2, 0);
65	container_test(set, assignable);
66
67	std::cout<<"Test unordered_multiset.\n";
68
69	boost::unordered_multiset<int> int_multiset;
70
71	boost::unordered_multiset<int,
72	boost::hash<int>, std::equal_to<int>,
73	test::minimal::cxx11_allocator<int>
74	> int_multiset2;
75
76	boost::unordered_multiset<
77	test::minimal::assignable,
78	test::minimal::hash<test::minimal::assignable>,
79	test::minimal::equal_to<test::minimal::assignable>,
80	test::minimal::allocator<test::minimal::assignable> > multiset;
81
82	container_test(int_multiset, 0);
83	container_test(int_multiset2, 0);
84	container_test(multiset, assignable);
85	}
86
87	UNORDERED_AUTO_TEST(equality_tests) {
88	typedef test::minimal::copy_constructible_equality_comparable value_type;
89
90	boost::unordered_set<int> int_set;
91
92	boost::unordered_set<int,
93	boost::hash<int>, std::equal_to<int>,
94	test::minimal::cxx11_allocator<int>
95	> int_set2;
96
97	boost::unordered_set<
98	test::minimal::copy_constructible_equality_comparable,
99	test::minimal::hash<test::minimal::copy_constructible_equality_comparable>,
100	test::minimal::equal_to<test::minimal::copy_constructible_equality_comparable>,
101	test::minimal::allocator<value_type> > set;
102
103	equality_test(int_set);
104	equality_test(int_set2);
105	equality_test(set);
106
107	boost::unordered_multiset<int> int_multiset;
108
109	boost::unordered_multiset<int,
110	boost::hash<int>, std::equal_to<int>,
111	test::minimal::cxx11_allocator<int>
112	> int_multiset2;
113
114	boost::unordered_multiset<
115	test::minimal::copy_constructible_equality_comparable,
116	test::minimal::hash<test::minimal::copy_constructible_equality_comparable>,
117	test::minimal::equal_to<test::minimal::copy_constructible_equality_comparable>,
118	test::minimal::allocator<value_type> > multiset;
119
120	equality_test(int_multiset);
121	equality_test(int_multiset2);
122	equality_test(multiset);
123	}
124
125	UNORDERED_AUTO_TEST(test1)
126	{
127	boost::hash<int> hash;
128	std::equal_to<int> equal_to;
129	int value = 0;
130
131	std::cout<<"Test unordered_set." << std::endl;
132
133	boost::unordered_set<int> set;
134
135	boost::unordered_set<int,
136	boost::hash<int>, std::equal_to<int>,
137	test::minimal::cxx11_allocator<int>
138	> set2;
139
140	unordered_unique_test(set, value);
141	unordered_set_test(set, value);
142	unordered_copyable_test(set, value, value, hash, equal_to);
143
144	unordered_unique_test(set2, value);
145	unordered_set_test(set2, value);
146	unordered_copyable_test(set2, value, value, hash, equal_to);
147
148	std::cout<<"Test unordered_multiset." << std::endl;
149
150	boost::unordered_multiset<int> multiset;
151
152	boost::unordered_multiset<int,
153	boost::hash<int>, std::equal_to<int>,
154	test::minimal::cxx11_allocator<int>
155	> multiset2;
156
157	unordered_equivalent_test(multiset, value);
158	unordered_set_test(multiset, value);
159	unordered_copyable_test(multiset, value, value, hash, equal_to);
160
161	unordered_equivalent_test(multiset2, value);
162	unordered_set_test(multiset2, value);
163	unordered_copyable_test(multiset2, value, value, hash, equal_to);
164	}
165
166	UNORDERED_AUTO_TEST(test2)
167	{
168	test::minimal::constructor_param x;
169
170	test::minimal::assignable assignable(x);
171	test::minimal::copy_constructible copy_constructible(x);
172	test::minimal::hash<test::minimal::assignable> hash(x);
173	test::minimal::equal_to<test::minimal::assignable> equal_to(x);
174
175	std::cout<<"Test unordered_set.\n";
176
177	boost::unordered_set<
178	test::minimal::assignable,
179	test::minimal::hash<test::minimal::assignable>,
180	test::minimal::equal_to<test::minimal::assignable>,
181	test::minimal::allocator<test::minimal::assignable> > set;
182
183	unordered_unique_test(set, assignable);
184	unordered_set_test(set, assignable);
185	unordered_copyable_test(set, assignable, assignable, hash, equal_to);
186	unordered_set_member_test(set, assignable);
187
188	std::cout<<"Test unordered_multiset.\n";
189
190	boost::unordered_multiset<
191	test::minimal::assignable,
192	test::minimal::hash<test::minimal::assignable>,
193	test::minimal::equal_to<test::minimal::assignable>,
194	test::minimal::allocator<test::minimal::assignable> > multiset;
195
196	unordered_equivalent_test(multiset, assignable);
197	unordered_set_test(multiset, assignable);
198	unordered_copyable_test(multiset, assignable, assignable, hash, equal_to);
199	unordered_set_member_test(multiset, assignable);
200	}
201
202	UNORDERED_AUTO_TEST(movable1_tests)
203	{
204	test::minimal::constructor_param x;
205
206	test::minimal::movable1 movable1(x);
207	test::minimal::hash<test::minimal::movable1> hash(x);
208	test::minimal::equal_to<test::minimal::movable1> equal_to(x);
209
210	std::cout<<"Test unordered_set.\n";
211
212	boost::unordered_set<
213	test::minimal::movable1,
214	test::minimal::hash<test::minimal::movable1>,
215	test::minimal::equal_to<test::minimal::movable1>,
216	test::minimal::allocator<test::minimal::movable1> > set;
217
218	//unordered_unique_test(set, movable1);
219	unordered_set_test(set, movable1);
220	unordered_movable_test(set, movable1, movable1, hash, equal_to);
221
222	std::cout<<"Test unordered_multiset.\n";
223
224	boost::unordered_multiset<
225	test::minimal::movable1,
226	test::minimal::hash<test::minimal::movable1>,
227	test::minimal::equal_to<test::minimal::movable1>,
228	test::minimal::allocator<test::minimal::movable1> > multiset;
229
230	//unordered_equivalent_test(multiset, movable1);
231	unordered_set_test(multiset, movable1);
232	unordered_movable_test(multiset, movable1, movable1, hash, equal_to);
233	}
234
235	UNORDERED_AUTO_TEST(movable2_tests)
236	{
237	test::minimal::constructor_param x;
238
239	test::minimal::movable2 movable2(x);
240	test::minimal::hash<test::minimal::movable2> hash(x);
241	test::minimal::equal_to<test::minimal::movable2> equal_to(x);
242
243	std::cout<<"Test unordered_set.\n";
244
245	boost::unordered_set<
246	test::minimal::movable2,
247	test::minimal::hash<test::minimal::movable2>,
248	test::minimal::equal_to<test::minimal::movable2>,
249	test::minimal::allocator<test::minimal::movable2> > set;
250
251	//unordered_unique_test(set, movable2);
252	unordered_set_test(set, movable2);
253	unordered_movable_test(set, movable2, movable2, hash, equal_to);
254
255	std::cout<<"Test unordered_multiset.\n";
256
257	boost::unordered_multiset<
258	test::minimal::movable2,
259	test::minimal::hash<test::minimal::movable2>,
260	test::minimal::equal_to<test::minimal::movable2>,
261	test::minimal::allocator<test::minimal::movable2> > multiset;
262
263	//unordered_equivalent_test(multiset, movable2);
264	unordered_set_test(multiset, movable2);
265	unordered_movable_test(multiset, movable2, movable2, hash, equal_to);
266	}
267
268	UNORDERED_AUTO_TEST(destructible_tests)
269	{
270	test::minimal::constructor_param x;
271
272	test::minimal::destructible destructible(x);
273	test::minimal::hash<test::minimal::destructible> hash(x);
274	test::minimal::equal_to<test::minimal::destructible> equal_to(x);
275
276	std::cout<<"Test unordered_set.\n";
277
278	boost::unordered_set<
279	test::minimal::destructible,
280	test::minimal::hash<test::minimal::destructible>,
281	test::minimal::equal_to<test::minimal::destructible> > set;
282
283	unordered_destructible_test(set);
284
285	std::cout<<"Test unordered_multiset.\n";
286
287	boost::unordered_multiset<
288	test::minimal::destructible,
289	test::minimal::hash<test::minimal::destructible>,
290	test::minimal::equal_to<test::minimal::destructible> > multiset;
291
292	unordered_destructible_test(multiset);
293	}
294
295	RUN_TESTS()