]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | // Boost.Bimap |
2 | // | |
3 | // Copyright (c) 2006-2007 Matias Capeletto | |
4 | // | |
5 | // Distributed under the Boost Software License, Version 1.0. | |
6 | // (See accompanying file LICENSE_1_0.txt or copy at | |
7 | // http://www.boost.org/LICENSE_1_0.txt) | |
8 | ||
9 | // VC++ 8.0 warns on usage of certain Standard Library and API functions that | |
10 | // can be cause buffer overruns or other possible security issues if misused. | |
92f5a8d4 | 11 | // See https://web.archive.org/web/20071014014301/http://msdn.microsoft.com/msdnmag/issues/05/05/SafeCandC/default.aspx |
7c673cae FG |
12 | // But the wording of the warning is misleading and unsettling, there are no |
13 | // portable alternative functions, and VC++ 8.0's own libraries use the | |
14 | // functions in question. So turn off the warnings. | |
15 | #define _CRT_SECURE_NO_DEPRECATE | |
16 | #define _SCL_SECURE_NO_DEPRECATE | |
17 | ||
18 | #include <boost/config.hpp> | |
19 | ||
20 | // std | |
21 | #include <string> | |
22 | ||
20effc67 | 23 | #include <boost/core/lightweight_test.hpp> |
7c673cae FG |
24 | |
25 | // Boost.MPL | |
26 | #include <boost/mpl/assert.hpp> | |
27 | #include <boost/type_traits/is_same.hpp> | |
28 | ||
29 | // Boost.Bimap | |
30 | #include <boost/bimap/detail/test/check_metadata.hpp> | |
31 | #include <boost/bimap/tags/tagged.hpp> | |
32 | ||
33 | // Boost.Bimap.Relation | |
34 | #include <boost/bimap/relation/mutant_relation.hpp> | |
35 | #include <boost/bimap/relation/member_at.hpp> | |
36 | #include <boost/bimap/relation/support/get.hpp> | |
37 | #include <boost/bimap/relation/support/pair_by.hpp> | |
38 | #include <boost/bimap/relation/support/pair_type_by.hpp> | |
39 | #include <boost/bimap/relation/support/value_type_of.hpp> | |
40 | #include <boost/bimap/relation/support/member_with_tag.hpp> | |
41 | #include <boost/bimap/relation/support/is_tag_of_member_at.hpp> | |
42 | ||
43 | // Bimap Test Utilities | |
44 | #include "test_relation.hpp" | |
45 | ||
46 | BOOST_BIMAP_TEST_STATIC_FUNCTION( untagged_static_test ) | |
47 | { | |
48 | using namespace boost::bimaps::relation::member_at; | |
49 | using namespace boost::bimaps::relation; | |
50 | using namespace boost::bimaps::tags; | |
51 | ||
52 | struct left_data {}; | |
53 | struct right_data {}; | |
54 | ||
55 | typedef mutant_relation< left_data, right_data > rel; | |
56 | ||
57 | BOOST_BIMAP_CHECK_METADATA(rel,left_value_type ,left_data); | |
58 | BOOST_BIMAP_CHECK_METADATA(rel,right_value_type,right_data); | |
59 | ||
60 | BOOST_BIMAP_CHECK_METADATA(rel,left_tag ,left ); | |
61 | BOOST_BIMAP_CHECK_METADATA(rel,right_tag,right); | |
62 | ||
63 | typedef tagged<left_data ,left > desired_tagged_left_type; | |
64 | BOOST_BIMAP_CHECK_METADATA(rel,tagged_left_type,desired_tagged_left_type); | |
65 | ||
66 | typedef tagged<right_data,right> desired_tagged_right_type; | |
67 | BOOST_BIMAP_CHECK_METADATA(rel,tagged_right_type,desired_tagged_right_type); | |
68 | ||
69 | } | |
70 | ||
71 | BOOST_BIMAP_TEST_STATIC_FUNCTION( tagged_static_test) | |
72 | { | |
73 | using namespace boost::bimaps::relation::member_at; | |
74 | using namespace boost::bimaps::relation; | |
75 | using namespace boost::bimaps::tags; | |
76 | ||
77 | struct left_data {}; | |
78 | struct right_data {}; | |
79 | ||
80 | struct left_tag {}; | |
81 | struct right_tag {}; | |
82 | ||
83 | typedef mutant_relation< | |
84 | tagged<left_data,left_tag>, tagged<right_data,right_tag> > rel; | |
85 | ||
86 | BOOST_BIMAP_CHECK_METADATA(rel,left_value_type ,left_data); | |
87 | BOOST_BIMAP_CHECK_METADATA(rel,right_value_type,right_data); | |
88 | ||
89 | BOOST_BIMAP_CHECK_METADATA(rel,left_tag ,left_tag ); | |
90 | BOOST_BIMAP_CHECK_METADATA(rel,right_tag,right_tag ); | |
91 | ||
92 | typedef tagged<left_data ,left_tag > desired_tagged_left_type; | |
93 | BOOST_BIMAP_CHECK_METADATA(rel,tagged_left_type,desired_tagged_left_type); | |
94 | ||
95 | typedef tagged<right_data,right_tag> desired_tagged_right_type; | |
96 | BOOST_BIMAP_CHECK_METADATA(rel,tagged_right_type,desired_tagged_right_type); | |
97 | } | |
98 | ||
99 | struct mutant_relation_builder | |
100 | { | |
101 | template< class LeftType, class RightType > | |
102 | struct build | |
103 | { | |
104 | typedef boost::bimaps::relation:: | |
105 | mutant_relation<LeftType,RightType,::boost::mpl::na,true> type; | |
106 | }; | |
107 | }; | |
108 | ||
109 | // Complex classes | |
110 | ||
111 | class cc1 | |
112 | { | |
113 | public: | |
114 | cc1(int s = 0) : a(s+100), b(s+101) {} | |
115 | static int sd; | |
116 | int a; | |
117 | const int b; | |
118 | }; | |
119 | ||
120 | bool operator==(const cc1 & da, const cc1 & db) | |
121 | { | |
122 | return da.a == db.a && da.b == db.b; | |
123 | } | |
124 | ||
125 | int cc1::sd = 102; | |
126 | ||
127 | class cc2_base | |
128 | { | |
129 | public: | |
130 | cc2_base(int s) : a(s+200) {} | |
131 | int a; | |
132 | }; | |
133 | ||
134 | class cc2 : public cc2_base | |
135 | { | |
136 | public: | |
137 | cc2(int s = 0) : cc2_base(s), b(s+201) {} | |
138 | int b; | |
139 | }; | |
140 | ||
141 | bool operator==(const cc2 & da, const cc2 & db) | |
142 | { | |
143 | return da.a == db.a && da.b == db.b; | |
144 | } | |
145 | ||
146 | class cc3_base | |
147 | { | |
148 | public: | |
149 | cc3_base(int s = 0) : a(s+300) {} | |
150 | const int a; | |
151 | }; | |
152 | ||
153 | class cc3 : virtual public cc3_base | |
154 | { | |
155 | public: | |
156 | cc3(int s = 0) : cc3_base(s), b(s+301) {} | |
157 | int b; | |
158 | }; | |
159 | ||
160 | bool operator==(const cc3 & da, const cc3 & db) | |
161 | { | |
162 | return da.a == db.a && da.b == db.b; | |
163 | } | |
164 | ||
165 | class cc4_base | |
166 | { | |
167 | public: | |
168 | cc4_base(int s) : a(s+400) {} | |
169 | virtual ~cc4_base() {} | |
170 | const int a; | |
171 | }; | |
172 | ||
173 | class cc4 : public cc4_base | |
174 | { | |
175 | public: | |
176 | cc4(int s = 0) : cc4_base(s), b(s+401) {} | |
177 | int b; | |
178 | }; | |
179 | ||
180 | bool operator==(const cc4 & da, const cc4 & db) | |
181 | { | |
182 | return da.a == db.a && da.b == db.b; | |
183 | } | |
184 | ||
185 | class cc5 : public cc1, public cc3, public cc4 | |
186 | { | |
187 | public: | |
188 | cc5(int s = 0) : cc1(s), cc3(s), cc4(s) {} | |
189 | }; | |
190 | ||
191 | bool operator==(const cc5 & da, const cc5 & db) | |
192 | { | |
193 | return da.cc1::a == db.cc1::a && da.cc1::b == db.cc1::b && | |
194 | da.cc3::a == db.cc3::a && da.cc3::b == db.cc3::b && | |
195 | da.cc4::a == db.cc4::a && da.cc4::b == db.cc4::b; | |
196 | } | |
197 | ||
198 | class cc6 | |
199 | { | |
200 | public: | |
201 | cc6(int s = 0) : a(s+600), b(a) {} | |
202 | int a; | |
203 | int & b; | |
204 | }; | |
205 | ||
206 | bool operator==(const cc6 & da, const cc6 & db) | |
207 | { | |
208 | return da.a == db.a && da.b == db.b; | |
209 | } | |
210 | ||
211 | void test_mutant_relation() | |
212 | { | |
213 | test_relation< mutant_relation_builder, char , double >( 'l', 2.5 ); | |
214 | test_relation< mutant_relation_builder, double, char >( 2.5, 'r' ); | |
215 | ||
216 | test_relation<mutant_relation_builder, int , int >( 1 , 2 ); | |
217 | ||
218 | test_relation<mutant_relation_builder, std::string, int* >("left value",0); | |
219 | ||
220 | test_relation<mutant_relation_builder, cc1, cc2>(0,0); | |
221 | test_relation<mutant_relation_builder, cc2, cc3>(0,0); | |
222 | test_relation<mutant_relation_builder, cc3, cc4>(0,0); | |
223 | test_relation<mutant_relation_builder, cc4, cc5>(0,0); | |
224 | } | |
225 | ||
20effc67 | 226 | int main() |
7c673cae FG |
227 | { |
228 | ||
229 | // Test metadata correctness with untagged relation version | |
230 | BOOST_BIMAP_CALL_TEST_STATIC_FUNCTION( tagged_static_test ); | |
231 | ||
232 | // Test metadata correctness with tagged relation version | |
233 | BOOST_BIMAP_CALL_TEST_STATIC_FUNCTION( untagged_static_test ); | |
234 | ||
235 | // Test basic | |
236 | test_mutant_relation(); | |
237 | ||
20effc67 | 238 | return boost::report_errors(); |
7c673cae FG |
239 | } |
240 |