libjmmcg  release_579_6_g8cffd
A C++ library containing an eclectic mix of useful, advanced components.
bitfield_map.cpp
Go to the documentation of this file.
1 /******************************************************************************
2 ** Copyright © 2014 by J.M.McGuiness, coder@hussar.me.uk
3 **
4 ** This library is free software; you can redistribute it and/or
5 ** modify it under the terms of the GNU Lesser General Public
6 ** License as published by the Free Software Foundation; either
7 ** version 2.1 of the License, or (at your option) any later version.
8 **
9 ** This library is distributed in the hope that it will be useful,
10 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
11 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 ** Lesser General Public License for more details.
13 **
14 ** You should have received a copy of the GNU Lesser General Public
15 ** License along with this library; if not, write to the Free Software
16 ** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 */
18 
19 #include "stdafx.h"
20 
21 #define BOOST_TEST_MODULE libjmmcg_tests
22 #include <boost/test/included/unit_test.hpp>
23 #include <boost/graph/graph_concepts.hpp>
24 
25 #include "core/bitfield_map.hpp"
26 
27 #include <boost/mpl/map.hpp>
28 
29 using namespace libjmmcg;
30 
31 enum bitfield_3_positions : uint8_t {
32  pos1=(0x1UL<<0),
33  pos2=(0x1UL<<1),
34  pos3=(0x1UL<<2)
35 };
36 
37 struct p1_t {
38  uint8_t i=1;
39 };
40 struct p2_t {
41  uint32_t i=2;
42 };
43 
44 typedef boost::mpl::map<
45  boost::mpl::pair<
46  std::integral_constant<bitfield_3_positions, bitfield_3_positions::pos1>::type,
47  int
48  >,
49  boost::mpl::pair<
50  std::integral_constant<bitfield_3_positions, bitfield_3_positions::pos2>::type,
51  p1_t
52  >,
53  boost::mpl::pair<
54  std::integral_constant<bitfield_3_positions, bitfield_3_positions::pos3>::type,
55  p2_t
56  >
57 > bitfield_3_to_type_map;
58 
59 BOOST_AUTO_TEST_SUITE(bitfield_map_tests)
60 
61 BOOST_AUTO_TEST_CASE(ctor)
62 {
63  using m_t=bitfield_map<bitfield_3_to_type_map>;
64  BOOST_MPL_ASSERT_RELATION(sizeof(m_t), ==, sizeof(bitfield_3_positions)+sizeof(int)+sizeof(p1_t)+sizeof(p2_t));
65  m_t m;
66  BOOST_CHECK(m.empty());
67  BOOST_CHECK_EQUAL(m.size(), sizeof(bitfield_3_positions));
68  BOOST_CHECK_GT(m.max_size(), m.size());
69  BOOST_CHECK_THROW(m.at<bitfield_3_positions::pos1>(), std::range_error);
70  BOOST_CHECK_THROW(m.at<bitfield_3_positions::pos2>(), std::range_error);
71  BOOST_CHECK_THROW(m.at<bitfield_3_positions::pos3>(), std::range_error);
72  BOOST_CHECK_EQUAL(m.find<bitfield_3_positions::pos1>(), false);
73  BOOST_CHECK_EQUAL(m.find<bitfield_3_positions::pos2>(), false);
74  BOOST_CHECK_EQUAL(m.find<bitfield_3_positions::pos3>(), false);
75 }
76 
77 BOOST_AUTO_TEST_CASE(ctor_move)
78 {
79  bitfield_map<bitfield_3_to_type_map> m1;
80  bitfield_map<bitfield_3_to_type_map> m2(std::move(m1));
81  BOOST_CHECK(m1.empty());
82  BOOST_CHECK_EQUAL(m1.size(), sizeof(bitfield_3_positions));
83  BOOST_CHECK_GT(m1.max_size(), m1.size());
84  BOOST_CHECK_THROW(m1.at<bitfield_3_positions::pos1>(), std::range_error);
85  BOOST_CHECK_THROW(m1.at<bitfield_3_positions::pos2>(), std::range_error);
86  BOOST_CHECK_THROW(m1.at<bitfield_3_positions::pos3>(), std::range_error);
87  BOOST_CHECK_EQUAL(m1.find<bitfield_3_positions::pos1>(), false);
88  BOOST_CHECK_EQUAL(m1.find<bitfield_3_positions::pos2>(), false);
89  BOOST_CHECK_EQUAL(m1.find<bitfield_3_positions::pos3>(), false);
90  BOOST_CHECK(m2.empty());
91  BOOST_CHECK_EQUAL(m2.size(), sizeof(bitfield_3_positions));
92  BOOST_CHECK_GT(m2.max_size(), m2.size());
93  BOOST_CHECK_THROW(m2.at<bitfield_3_positions::pos1>(), std::range_error);
94  BOOST_CHECK_THROW(m2.at<bitfield_3_positions::pos2>(), std::range_error);
95  BOOST_CHECK_THROW(m2.at<bitfield_3_positions::pos3>(), std::range_error);
96  BOOST_CHECK_EQUAL(m2.find<bitfield_3_positions::pos1>(), false);
97  BOOST_CHECK_EQUAL(m2.find<bitfield_3_positions::pos2>(), false);
98  BOOST_CHECK_EQUAL(m2.find<bitfield_3_positions::pos3>(), false);
99 }
100 
101 BOOST_AUTO_TEST_CASE(cctor)
102 {
103  bitfield_map<bitfield_3_to_type_map> m1;
104  bitfield_map<bitfield_3_to_type_map> m2(m1);
105  BOOST_CHECK(m1.empty());
106  BOOST_CHECK_EQUAL(m1.size(), sizeof(bitfield_3_positions));
107  BOOST_CHECK_GT(m1.max_size(), m1.size());
108  BOOST_CHECK_THROW(m1.at<bitfield_3_positions::pos1>(), std::range_error);
109  BOOST_CHECK_THROW(m1.at<bitfield_3_positions::pos2>(), std::range_error);
110  BOOST_CHECK_THROW(m1.at<bitfield_3_positions::pos3>(), std::range_error);
111  BOOST_CHECK_EQUAL(m1.find<bitfield_3_positions::pos1>(), false);
112  BOOST_CHECK_EQUAL(m1.find<bitfield_3_positions::pos2>(), false);
113  BOOST_CHECK_EQUAL(m1.find<bitfield_3_positions::pos3>(), false);
114  BOOST_CHECK(m2.empty());
115  BOOST_CHECK_EQUAL(m2.size(), sizeof(bitfield_3_positions));
116  BOOST_CHECK_GT(m2.max_size(), m2.size());
117  BOOST_CHECK_THROW(m2.at<bitfield_3_positions::pos1>(), std::range_error);
118  BOOST_CHECK_THROW(m2.at<bitfield_3_positions::pos2>(), std::range_error);
119  BOOST_CHECK_THROW(m2.at<bitfield_3_positions::pos3>(), std::range_error);
120  BOOST_CHECK_EQUAL(m2.find<bitfield_3_positions::pos1>(), false);
121  BOOST_CHECK_EQUAL(m2.find<bitfield_3_positions::pos2>(), false);
122  BOOST_CHECK_EQUAL(m2.find<bitfield_3_positions::pos3>(), false);
123 }
124 
125 BOOST_AUTO_TEST_CASE(insert_1_item_at_find)
126 {
127  bitfield_map<bitfield_3_to_type_map> m;
128  BOOST_CHECK_NO_THROW(m.push_back<bitfield_3_positions::pos1>(42));
129  BOOST_CHECK(!m.empty());
130  BOOST_CHECK_EQUAL(m.size(), sizeof(bitfield_3_positions)+sizeof(int));
131  BOOST_CHECK_GT(m.max_size(), m.size());
132  BOOST_CHECK_EQUAL(m.at<bitfield_3_positions::pos1>(), 42);
133  BOOST_CHECK_THROW(m.at<bitfield_3_positions::pos2>(), std::range_error);
134  BOOST_CHECK_THROW(m.at<bitfield_3_positions::pos3>(), std::range_error);
135  BOOST_CHECK_EQUAL(m.find<bitfield_3_positions::pos1>(), true);
136  BOOST_CHECK_EQUAL(m.find<bitfield_3_positions::pos2>(), false);
137  BOOST_CHECK_EQUAL(m.find<bitfield_3_positions::pos3>(), false);
138 }
139 
140 BOOST_AUTO_TEST_CASE(insert_1_move)
141 {
142  bitfield_map<bitfield_3_to_type_map> m1;
143  BOOST_CHECK_NO_THROW(m1.push_back<bitfield_3_positions::pos1>(42));
144  bitfield_map<bitfield_3_to_type_map> m2(std::move(m1));
145  BOOST_CHECK(m1.empty());
146  BOOST_CHECK_EQUAL(m1.size(), sizeof(bitfield_3_positions));
147  BOOST_CHECK_GT(m1.max_size(), m1.size());
148  BOOST_CHECK_THROW(m1.at<bitfield_3_positions::pos1>(), std::range_error);
149  BOOST_CHECK_THROW(m1.at<bitfield_3_positions::pos2>(), std::range_error);
150  BOOST_CHECK_THROW(m1.at<bitfield_3_positions::pos3>(), std::range_error);
151  BOOST_CHECK_EQUAL(m1.find<bitfield_3_positions::pos1>(), false);
152  BOOST_CHECK_EQUAL(m1.find<bitfield_3_positions::pos2>(), false);
153  BOOST_CHECK_EQUAL(m1.find<bitfield_3_positions::pos3>(), false);
154  BOOST_CHECK(!m2.empty());
155  BOOST_CHECK_EQUAL(m2.size(), sizeof(bitfield_3_positions)+sizeof(int));
156  BOOST_CHECK_GT(m2.max_size(), m2.size());
157  BOOST_CHECK_EQUAL(m2.at<bitfield_3_positions::pos1>(), 42);
158  BOOST_CHECK_THROW(m2.at<bitfield_3_positions::pos2>(), std::range_error);
159  BOOST_CHECK_THROW(m2.at<bitfield_3_positions::pos3>(), std::range_error);
160  BOOST_CHECK_EQUAL(m2.find<bitfield_3_positions::pos1>(), true);
161  BOOST_CHECK_EQUAL(m2.find<bitfield_3_positions::pos2>(), false);
162  BOOST_CHECK_EQUAL(m2.find<bitfield_3_positions::pos3>(), false);
163 }
164 
165 BOOST_AUTO_TEST_CASE(insert_1_cctor)
166 {
167  bitfield_map<bitfield_3_to_type_map> m1;
168  BOOST_CHECK_NO_THROW(m1.push_back<bitfield_3_positions::pos1>(42));
169  bitfield_map<bitfield_3_to_type_map> m2(m1);
170  BOOST_CHECK(!m1.empty());
171  BOOST_CHECK_EQUAL(m1.size(), sizeof(bitfield_3_positions)+sizeof(int));
172  BOOST_CHECK_GT(m1.max_size(), m1.size());
173  BOOST_CHECK_EQUAL(m1.at<bitfield_3_positions::pos1>(), 42);
174  BOOST_CHECK_THROW(m1.at<bitfield_3_positions::pos2>(), std::range_error);
175  BOOST_CHECK_THROW(m1.at<bitfield_3_positions::pos3>(), std::range_error);
176  BOOST_CHECK_EQUAL(m1.find<bitfield_3_positions::pos1>(), true);
177  BOOST_CHECK_EQUAL(m1.find<bitfield_3_positions::pos2>(), false);
178  BOOST_CHECK_EQUAL(m1.find<bitfield_3_positions::pos3>(), false);
179  BOOST_CHECK(!m2.empty());
180  BOOST_CHECK_EQUAL(m2.size(), sizeof(bitfield_3_positions)+sizeof(int));
181  BOOST_CHECK_GT(m2.max_size(), m2.size());
182  BOOST_CHECK_EQUAL(m2.at<bitfield_3_positions::pos1>(), 42);
183  BOOST_CHECK_THROW(m2.at<bitfield_3_positions::pos2>(), std::range_error);
184  BOOST_CHECK_THROW(m2.at<bitfield_3_positions::pos3>(), std::range_error);
185  BOOST_CHECK_EQUAL(m2.find<bitfield_3_positions::pos1>(), true);
186  BOOST_CHECK_EQUAL(m2.find<bitfield_3_positions::pos2>(), false);
187  BOOST_CHECK_EQUAL(m2.find<bitfield_3_positions::pos3>(), false);
188 }
189 
190 BOOST_AUTO_TEST_CASE(insert_1_move_assign)
191 {
192  bitfield_map<bitfield_3_to_type_map> m1;
193  BOOST_CHECK_NO_THROW(m1.push_back<bitfield_3_positions::pos1>(42));
194  bitfield_map<bitfield_3_to_type_map> m2;
195  BOOST_CHECK_NO_THROW(m2=std::move(m1));
196  BOOST_CHECK(m1.empty());
197  BOOST_CHECK_EQUAL(m1.size(), sizeof(bitfield_3_positions));
198  BOOST_CHECK_GT(m1.max_size(), m1.size());
199  BOOST_CHECK_THROW(m1.at<bitfield_3_positions::pos1>(), std::range_error);
200  BOOST_CHECK_THROW(m1.at<bitfield_3_positions::pos2>(), std::range_error);
201  BOOST_CHECK_THROW(m1.at<bitfield_3_positions::pos3>(), std::range_error);
202  BOOST_CHECK_EQUAL(m1.find<bitfield_3_positions::pos1>(), false);
203  BOOST_CHECK_EQUAL(m1.find<bitfield_3_positions::pos2>(), false);
204  BOOST_CHECK_EQUAL(m1.find<bitfield_3_positions::pos3>(), false);
205  BOOST_CHECK(!m2.empty());
206  BOOST_CHECK_EQUAL(m2.size(), sizeof(bitfield_3_positions)+sizeof(int));
207  BOOST_CHECK_GT(m2.max_size(), m2.size());
208  BOOST_CHECK_EQUAL(m2.at<bitfield_3_positions::pos1>(), 42);
209  BOOST_CHECK_THROW(m2.at<bitfield_3_positions::pos2>(), std::range_error);
210  BOOST_CHECK_THROW(m2.at<bitfield_3_positions::pos3>(), std::range_error);
211  BOOST_CHECK_EQUAL(m2.find<bitfield_3_positions::pos1>(), true);
212  BOOST_CHECK_EQUAL(m2.find<bitfield_3_positions::pos2>(), false);
213  BOOST_CHECK_EQUAL(m2.find<bitfield_3_positions::pos3>(), false);
214 }
215 
216 BOOST_AUTO_TEST_CASE(insert_2_move_assign)
217 {
218  bitfield_map<bitfield_3_to_type_map> m1;
219  BOOST_CHECK_NO_THROW(m1.push_back<bitfield_3_positions::pos1>(42));
220  bitfield_map<bitfield_3_to_type_map> m2;
221  BOOST_CHECK_NO_THROW(m2.push_back<bitfield_3_positions::pos2>(p1_t()));
222  BOOST_CHECK_NO_THROW(m2=std::move(m1));
223  BOOST_CHECK(!m1.empty());
224  BOOST_CHECK_EQUAL(m1.size(), sizeof(bitfield_3_positions)+sizeof(p1_t));
225  BOOST_CHECK_GT(m1.max_size(), m1.size());
226  BOOST_CHECK_THROW(m1.at<bitfield_3_positions::pos1>(), std::range_error);
227  BOOST_CHECK_EQUAL(m1.at<bitfield_3_positions::pos2>().i, p1_t().i);
228  BOOST_CHECK_THROW(m1.at<bitfield_3_positions::pos3>(), std::range_error);
229  BOOST_CHECK_EQUAL(m1.find<bitfield_3_positions::pos1>(), false);
230  BOOST_CHECK_EQUAL(m1.find<bitfield_3_positions::pos2>(), true);
231  BOOST_CHECK_EQUAL(m1.find<bitfield_3_positions::pos3>(), false);
232  BOOST_CHECK(!m2.empty());
233  BOOST_CHECK_EQUAL(m2.size(), sizeof(bitfield_3_positions)+sizeof(int));
234  BOOST_CHECK_GT(m2.max_size(), m2.size());
235  BOOST_CHECK_EQUAL(m2.at<bitfield_3_positions::pos1>(), 42);
236  BOOST_CHECK_THROW(m2.at<bitfield_3_positions::pos2>(), std::range_error);
237  BOOST_CHECK_THROW(m2.at<bitfield_3_positions::pos3>(), std::range_error);
238  BOOST_CHECK_EQUAL(m2.find<bitfield_3_positions::pos1>(), true);
239  BOOST_CHECK_EQUAL(m2.find<bitfield_3_positions::pos2>(), false);
240  BOOST_CHECK_EQUAL(m2.find<bitfield_3_positions::pos3>(), false);
241 }
242 
243 BOOST_AUTO_TEST_CASE(clear_1_element)
244 {
245  bitfield_map<bitfield_3_to_type_map> m;
246  BOOST_CHECK_NO_THROW(m.push_back<bitfield_3_positions::pos1>(42));
247  BOOST_CHECK_NO_THROW(m.clear());
248  BOOST_CHECK_THROW(m.at<bitfield_3_positions::pos1>(), std::range_error);
249  BOOST_CHECK_THROW(m.at<bitfield_3_positions::pos2>(), std::range_error);
250  BOOST_CHECK_THROW(m.at<bitfield_3_positions::pos3>(), std::range_error);
251  BOOST_CHECK_EQUAL(m.find<bitfield_3_positions::pos1>(), false);
252  BOOST_CHECK_EQUAL(m.find<bitfield_3_positions::pos2>(), false);
253  BOOST_CHECK_EQUAL(m.find<bitfield_3_positions::pos3>(), false);
254  BOOST_CHECK_EQUAL(m.size(), sizeof(bitfield_3_positions));
255  BOOST_CHECK(m.empty());
256 }
257 
258 BOOST_AUTO_TEST_CASE(at_1_item)
259 {
260  bitfield_map<bitfield_3_to_type_map> m;
261  BOOST_CHECK_NO_THROW(m.push_back<bitfield_3_positions::pos1>(42));
262  BOOST_CHECK_NO_THROW(m.at<bitfield_3_positions::pos1>());
263  BOOST_CHECK_NO_THROW(m.at<bitfield_3_positions::pos1>()=68);
264  BOOST_CHECK_EQUAL(m.at<bitfield_3_positions::pos1>(), 68);
265 }
266 
267 BOOST_AUTO_TEST_CASE(erase_1_item)
268 {
269  bitfield_map<bitfield_3_to_type_map> m;
270  BOOST_CHECK_NO_THROW(m.push_back<bitfield_3_positions::pos1>(42));
271  BOOST_CHECK_NO_THROW(m.erase<bitfield_3_positions::pos1>());
272  BOOST_CHECK_THROW(m.at<bitfield_3_positions::pos1>(), std::range_error);
273  BOOST_CHECK_EQUAL(m.find<bitfield_3_positions::pos1>(), false);
274  BOOST_CHECK_EQUAL(m.size(), sizeof(bitfield_3_positions));
275  BOOST_CHECK(m.empty());
276 }
277 
278 BOOST_AUTO_TEST_CASE(insert_2_items_at_find)
279 {
280  bitfield_map<bitfield_3_to_type_map> m;
281  BOOST_CHECK_NO_THROW(m.push_back<bitfield_3_positions::pos1>(42));
282  BOOST_CHECK_NO_THROW(m.push_back<bitfield_3_positions::pos2>(p1_t()));
283  BOOST_CHECK(!m.empty());
284  BOOST_CHECK_EQUAL(m.size(), sizeof(bitfield_3_positions)+sizeof(int)+sizeof(p1_t));
285  BOOST_CHECK_GE(m.max_size(), m.size());
286  BOOST_CHECK_EQUAL(m.at<bitfield_3_positions::pos1>(), 42);
287  BOOST_CHECK_EQUAL(m.at<bitfield_3_positions::pos2>().i, p1_t().i);
288  BOOST_CHECK_EQUAL(m.find<bitfield_3_positions::pos1>(), true);
289  BOOST_CHECK_EQUAL(m.find<bitfield_3_positions::pos2>(), true);
290 }
291 
292 BOOST_AUTO_TEST_CASE(invalid_insert_2_erase_1_element)
293 {
294  bitfield_map<bitfield_3_to_type_map> m;
295  BOOST_CHECK_NO_THROW(m.push_back<bitfield_3_positions::pos1>(42));
296  BOOST_CHECK_NO_THROW(m.push_back<bitfield_3_positions::pos2>(p1_t()));
297  BOOST_CHECK_NO_THROW(m.erase<bitfield_3_positions::pos1>());
298  BOOST_CHECK_THROW(m.at<bitfield_3_positions::pos1>(), std::range_error);
299  BOOST_CHECK_EQUAL(m.find<bitfield_3_positions::pos1>(), false);
300  BOOST_CHECK_EQUAL(m.find<bitfield_3_positions::pos2>(), true);
301  BOOST_CHECK_EQUAL(m.size(), sizeof(bitfield_3_positions)+sizeof(p1_t));
302  BOOST_CHECK(!m.empty());
303 }
304 
305 BOOST_AUTO_TEST_CASE(insert_2_erase_2_elements)
306 {
307  bitfield_map<bitfield_3_to_type_map> m;
308  BOOST_CHECK_NO_THROW(m.push_back<bitfield_3_positions::pos1>(42));
309  BOOST_CHECK_NO_THROW(m.push_back<bitfield_3_positions::pos2>(p1_t()));
310  BOOST_CHECK_NO_THROW(m.erase<bitfield_3_positions::pos2>());
311  BOOST_CHECK_THROW(m.at<bitfield_3_positions::pos2>(), std::range_error);
312  BOOST_CHECK_NO_THROW(m.at<bitfield_3_positions::pos1>());
313  BOOST_CHECK_EQUAL(m.find<bitfield_3_positions::pos1>(), true);
314  BOOST_CHECK_EQUAL(m.find<bitfield_3_positions::pos2>(), false);
315  BOOST_CHECK_EQUAL(m.size(), sizeof(bitfield_3_positions)+sizeof(int));
316  BOOST_CHECK(!m.empty());
317  BOOST_CHECK_NO_THROW(m.erase<bitfield_3_positions::pos1>());
318  BOOST_CHECK_THROW(m.at<bitfield_3_positions::pos1>(), std::range_error);
319  BOOST_CHECK_THROW(m.at<bitfield_3_positions::pos2>(), std::range_error);
320  BOOST_CHECK_EQUAL(m.find<bitfield_3_positions::pos1>(), false);
321  BOOST_CHECK_EQUAL(m.find<bitfield_3_positions::pos2>(), false);
322  BOOST_CHECK_EQUAL(m.size(), sizeof(bitfield_3_positions));
323  BOOST_CHECK(m.empty());
324 }
325 
326 BOOST_AUTO_TEST_CASE(insert_3_items_at)
327 {
328  bitfield_map<bitfield_3_to_type_map> m;
329  BOOST_CHECK_NO_THROW(m.push_back<bitfield_3_positions::pos1>(42));
330  BOOST_CHECK_NO_THROW(m.push_back<bitfield_3_positions::pos2>(p1_t()));
331  BOOST_CHECK_NO_THROW(m.push_back<bitfield_3_positions::pos3>(p2_t()));
332  BOOST_CHECK(!m.empty());
333  BOOST_CHECK_EQUAL(m.size(), sizeof(bitfield_3_positions)+sizeof(int)+sizeof(p1_t)+sizeof(p2_t));
334  BOOST_CHECK_GE(m.max_size(), m.size());
335  BOOST_CHECK_EQUAL(m.at<bitfield_3_positions::pos1>(), 42);
336  BOOST_CHECK_EQUAL(m.at<bitfield_3_positions::pos2>().i, p1_t().i);
337  BOOST_CHECK_EQUAL(m.at<bitfield_3_positions::pos3>().i, p2_t().i);
338 }
339 
340 BOOST_AUTO_TEST_SUITE_END()