root/examples/bitfield_map.cpp

/* [<][>][^][v][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. BOOST_AUTO_TEST_SUITE
  2. BOOST_AUTO_TEST_CASE
  3. BOOST_AUTO_TEST_CASE
  4. BOOST_AUTO_TEST_CASE
  5. BOOST_AUTO_TEST_CASE
  6. BOOST_AUTO_TEST_CASE
  7. BOOST_AUTO_TEST_CASE
  8. BOOST_AUTO_TEST_CASE
  9. BOOST_AUTO_TEST_CASE
  10. BOOST_AUTO_TEST_CASE
  11. BOOST_AUTO_TEST_CASE
  12. BOOST_AUTO_TEST_CASE
  13. BOOST_AUTO_TEST_CASE
  14. BOOST_AUTO_TEST_CASE
  15. BOOST_AUTO_TEST_CASE

   1 /******************************************************************************

   2 ** $Header: svn+ssh://jmmcg@svn.code.sf.net/p/libjmmcg/code/trunk/libjmmcg/examples/bitfield_map.cpp 2185 2017-10-13 10:14:17Z jmmcg $

   3 **

   4 ** Copyright (c) 2014 by J.M.McGuiness, coder@hussar.me.uk

   5 **

   6 ** This library is free software; you can redistribute it and/or

   7 ** modify it under the terms of the GNU Lesser General Public

   8 ** License as published by the Free Software Foundation; either

   9 ** version 2.1 of the License, or (at your option) any later version.

  10 **

  11 ** This library is distributed in the hope that it will be useful,

  12 ** but WITHOUT ANY WARRANTY; without even the implied warranty of

  13 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

  14 ** Lesser General Public License for more details.

  15 **

  16 ** You should have received a copy of the GNU Lesser General Public

  17 ** License along with this library; if not, write to the Free Software

  18 ** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

  19 */
  20 
  21 #include "stdafx.h"
  22 
  23 #define BOOST_TEST_MODULE libjmmcg_tests
  24 #include <boost/test/included/unit_test.hpp>
  25 #include <boost/graph/graph_concepts.hpp>
  26 
  27 #include "core/bitfield_map.hpp"
  28 
  29 #include <boost/mpl/map.hpp>
  30 
  31 using namespace jmmcg;
  32 
  33 enum bitfield_3_positions : uint8_t {
  34         pos1=(0x1UL<<0),
  35         pos2=(0x1UL<<1),
  36         pos3=(0x1UL<<2)
  37 };
  38 
  39 struct p1_t {
  40         uint8_t i=1;
  41 };
  42 struct p2_t {
  43         uint32_t i=2;
  44 };
  45 
  46 typedef boost::mpl::map<
  47         boost::mpl::pair<
  48                 std::integral_constant<bitfield_3_positions, bitfield_3_positions::pos1>::type,
  49                 int
  50         >,
  51         boost::mpl::pair<
  52                 std::integral_constant<bitfield_3_positions, bitfield_3_positions::pos2>::type,
  53                 p1_t
  54         >,
  55         boost::mpl::pair<
  56                 std::integral_constant<bitfield_3_positions, bitfield_3_positions::pos3>::type,
  57                 p2_t
  58         >
  59 > bitfield_3_to_type_map;
  60 
  61 BOOST_AUTO_TEST_SUITE(bitfield_map_tests)
  62 
  63 BOOST_AUTO_TEST_CASE(ctor)
  64 {
  65         using m_t=bitfield_map<bitfield_3_to_type_map>;
  66         BOOST_MPL_ASSERT_RELATION(sizeof(m_t), ==, sizeof(bitfield_3_positions)+sizeof(int)+sizeof(p1_t)+sizeof(p2_t));
  67         m_t m;
  68         BOOST_CHECK(m.empty());
  69         BOOST_CHECK_EQUAL(m.size(), sizeof(bitfield_3_positions));
  70         BOOST_CHECK_GT(m.max_size(), m.size());
  71         BOOST_CHECK_THROW(m.at<bitfield_3_positions::pos1>(), std::range_error);
  72         BOOST_CHECK_THROW(m.at<bitfield_3_positions::pos2>(), std::range_error);
  73         BOOST_CHECK_THROW(m.at<bitfield_3_positions::pos3>(), std::range_error);
  74         BOOST_CHECK_EQUAL(m.find<bitfield_3_positions::pos1>(), false);
  75         BOOST_CHECK_EQUAL(m.find<bitfield_3_positions::pos2>(), false);
  76         BOOST_CHECK_EQUAL(m.find<bitfield_3_positions::pos3>(), false);
  77 }
  78 
  79 BOOST_AUTO_TEST_CASE(ctor_move)
  80 {
  81         bitfield_map<bitfield_3_to_type_map> m1;
  82         bitfield_map<bitfield_3_to_type_map> m2(std::move(m1));
  83         BOOST_CHECK(m1.empty());
  84         BOOST_CHECK_EQUAL(m1.size(), sizeof(bitfield_3_positions));
  85         BOOST_CHECK_GT(m1.max_size(), m1.size());
  86         BOOST_CHECK_THROW(m1.at<bitfield_3_positions::pos1>(), std::range_error);
  87         BOOST_CHECK_THROW(m1.at<bitfield_3_positions::pos2>(), std::range_error);
  88         BOOST_CHECK_THROW(m1.at<bitfield_3_positions::pos3>(), std::range_error);
  89         BOOST_CHECK_EQUAL(m1.find<bitfield_3_positions::pos1>(), false);
  90         BOOST_CHECK_EQUAL(m1.find<bitfield_3_positions::pos2>(), false);
  91         BOOST_CHECK_EQUAL(m1.find<bitfield_3_positions::pos3>(), false);
  92         BOOST_CHECK(m2.empty());
  93         BOOST_CHECK_EQUAL(m2.size(), sizeof(bitfield_3_positions));
  94         BOOST_CHECK_GT(m2.max_size(), m2.size());
  95         BOOST_CHECK_THROW(m2.at<bitfield_3_positions::pos1>(), std::range_error);
  96         BOOST_CHECK_THROW(m2.at<bitfield_3_positions::pos2>(), std::range_error);
  97         BOOST_CHECK_THROW(m2.at<bitfield_3_positions::pos3>(), std::range_error);
  98         BOOST_CHECK_EQUAL(m2.find<bitfield_3_positions::pos1>(), false);
  99         BOOST_CHECK_EQUAL(m2.find<bitfield_3_positions::pos2>(), false);
 100         BOOST_CHECK_EQUAL(m2.find<bitfield_3_positions::pos3>(), false);
 101 }
 102 
 103 BOOST_AUTO_TEST_CASE(cctor)
 104 {
 105         bitfield_map<bitfield_3_to_type_map> m1;
 106         bitfield_map<bitfield_3_to_type_map> m2(m1);
 107         BOOST_CHECK(m1.empty());
 108         BOOST_CHECK_EQUAL(m1.size(), sizeof(bitfield_3_positions));
 109         BOOST_CHECK_GT(m1.max_size(), m1.size());
 110         BOOST_CHECK_THROW(m1.at<bitfield_3_positions::pos1>(), std::range_error);
 111         BOOST_CHECK_THROW(m1.at<bitfield_3_positions::pos2>(), std::range_error);
 112         BOOST_CHECK_THROW(m1.at<bitfield_3_positions::pos3>(), std::range_error);
 113         BOOST_CHECK_EQUAL(m1.find<bitfield_3_positions::pos1>(), false);
 114         BOOST_CHECK_EQUAL(m1.find<bitfield_3_positions::pos2>(), false);
 115         BOOST_CHECK_EQUAL(m1.find<bitfield_3_positions::pos3>(), false);
 116         BOOST_CHECK(m2.empty());
 117         BOOST_CHECK_EQUAL(m2.size(), sizeof(bitfield_3_positions));
 118         BOOST_CHECK_GT(m2.max_size(), m2.size());
 119         BOOST_CHECK_THROW(m2.at<bitfield_3_positions::pos1>(), std::range_error);
 120         BOOST_CHECK_THROW(m2.at<bitfield_3_positions::pos2>(), std::range_error);
 121         BOOST_CHECK_THROW(m2.at<bitfield_3_positions::pos3>(), std::range_error);
 122         BOOST_CHECK_EQUAL(m2.find<bitfield_3_positions::pos1>(), false);
 123         BOOST_CHECK_EQUAL(m2.find<bitfield_3_positions::pos2>(), false);
 124         BOOST_CHECK_EQUAL(m2.find<bitfield_3_positions::pos3>(), false);
 125 }
 126 
 127 BOOST_AUTO_TEST_CASE(insert_1_item_at_find)
 128 {
 129         bitfield_map<bitfield_3_to_type_map> m;
 130         BOOST_CHECK_NO_THROW(m.push_back<bitfield_3_positions::pos1>(42));
 131         BOOST_CHECK(!m.empty());
 132         BOOST_CHECK_EQUAL(m.size(), sizeof(bitfield_3_positions)+sizeof(int));
 133         BOOST_CHECK_GT(m.max_size(), m.size());
 134         BOOST_CHECK_EQUAL(m.at<bitfield_3_positions::pos1>(), 42);
 135         BOOST_CHECK_THROW(m.at<bitfield_3_positions::pos2>(), std::range_error);
 136         BOOST_CHECK_THROW(m.at<bitfield_3_positions::pos3>(), std::range_error);
 137         BOOST_CHECK_EQUAL(m.find<bitfield_3_positions::pos1>(), true);
 138         BOOST_CHECK_EQUAL(m.find<bitfield_3_positions::pos2>(), false);
 139         BOOST_CHECK_EQUAL(m.find<bitfield_3_positions::pos3>(), false);
 140 }
 141 
 142 BOOST_AUTO_TEST_CASE(insert_1_move)
 143 {
 144         bitfield_map<bitfield_3_to_type_map> m1;
 145         BOOST_CHECK_NO_THROW(m1.push_back<bitfield_3_positions::pos1>(42));
 146         bitfield_map<bitfield_3_to_type_map> m2(std::move(m1));
 147         BOOST_CHECK(m1.empty());
 148         BOOST_CHECK_EQUAL(m1.size(), sizeof(bitfield_3_positions));
 149         BOOST_CHECK_GT(m1.max_size(), m1.size());
 150         BOOST_CHECK_THROW(m1.at<bitfield_3_positions::pos1>(), std::range_error);
 151         BOOST_CHECK_THROW(m1.at<bitfield_3_positions::pos2>(), std::range_error);
 152         BOOST_CHECK_THROW(m1.at<bitfield_3_positions::pos3>(), std::range_error);
 153         BOOST_CHECK_EQUAL(m1.find<bitfield_3_positions::pos1>(), false);
 154         BOOST_CHECK_EQUAL(m1.find<bitfield_3_positions::pos2>(), false);
 155         BOOST_CHECK_EQUAL(m1.find<bitfield_3_positions::pos3>(), false);
 156         BOOST_CHECK(!m2.empty());
 157         BOOST_CHECK_EQUAL(m2.size(), sizeof(bitfield_3_positions)+sizeof(int));
 158         BOOST_CHECK_GT(m2.max_size(), m2.size());
 159         BOOST_CHECK_EQUAL(m2.at<bitfield_3_positions::pos1>(), 42);
 160         BOOST_CHECK_THROW(m2.at<bitfield_3_positions::pos2>(), std::range_error);
 161         BOOST_CHECK_THROW(m2.at<bitfield_3_positions::pos3>(), std::range_error);
 162         BOOST_CHECK_EQUAL(m2.find<bitfield_3_positions::pos1>(), true);
 163         BOOST_CHECK_EQUAL(m2.find<bitfield_3_positions::pos2>(), false);
 164         BOOST_CHECK_EQUAL(m2.find<bitfield_3_positions::pos3>(), false);
 165 }
 166 
 167 BOOST_AUTO_TEST_CASE(insert_1_cctor)
 168 {
 169         bitfield_map<bitfield_3_to_type_map> m1;
 170         BOOST_CHECK_NO_THROW(m1.push_back<bitfield_3_positions::pos1>(42));
 171         bitfield_map<bitfield_3_to_type_map> m2(m1);
 172         BOOST_CHECK(!m1.empty());
 173         BOOST_CHECK_EQUAL(m1.size(), sizeof(bitfield_3_positions)+sizeof(int));
 174         BOOST_CHECK_GT(m1.max_size(), m1.size());
 175         BOOST_CHECK_EQUAL(m1.at<bitfield_3_positions::pos1>(), 42);
 176         BOOST_CHECK_THROW(m1.at<bitfield_3_positions::pos2>(), std::range_error);
 177         BOOST_CHECK_THROW(m1.at<bitfield_3_positions::pos3>(), std::range_error);
 178         BOOST_CHECK_EQUAL(m1.find<bitfield_3_positions::pos1>(), true);
 179         BOOST_CHECK_EQUAL(m1.find<bitfield_3_positions::pos2>(), false);
 180         BOOST_CHECK_EQUAL(m1.find<bitfield_3_positions::pos3>(), false);
 181         BOOST_CHECK(!m2.empty());
 182         BOOST_CHECK_EQUAL(m2.size(), sizeof(bitfield_3_positions)+sizeof(int));
 183         BOOST_CHECK_GT(m2.max_size(), m2.size());
 184         BOOST_CHECK_EQUAL(m2.at<bitfield_3_positions::pos1>(), 42);
 185         BOOST_CHECK_THROW(m2.at<bitfield_3_positions::pos2>(), std::range_error);
 186         BOOST_CHECK_THROW(m2.at<bitfield_3_positions::pos3>(), std::range_error);
 187         BOOST_CHECK_EQUAL(m2.find<bitfield_3_positions::pos1>(), true);
 188         BOOST_CHECK_EQUAL(m2.find<bitfield_3_positions::pos2>(), false);
 189         BOOST_CHECK_EQUAL(m2.find<bitfield_3_positions::pos3>(), false);
 190 }
 191 
 192 BOOST_AUTO_TEST_CASE(insert_1_move_assign)
 193 {
 194         bitfield_map<bitfield_3_to_type_map> m1;
 195         BOOST_CHECK_NO_THROW(m1.push_back<bitfield_3_positions::pos1>(42));
 196         bitfield_map<bitfield_3_to_type_map> m2;
 197         BOOST_CHECK_NO_THROW(m2=std::move(m1));
 198         BOOST_CHECK(m1.empty());
 199         BOOST_CHECK_EQUAL(m1.size(), sizeof(bitfield_3_positions));
 200         BOOST_CHECK_GT(m1.max_size(), m1.size());
 201         BOOST_CHECK_THROW(m1.at<bitfield_3_positions::pos1>(), std::range_error);
 202         BOOST_CHECK_THROW(m1.at<bitfield_3_positions::pos2>(), std::range_error);
 203         BOOST_CHECK_THROW(m1.at<bitfield_3_positions::pos3>(), std::range_error);
 204         BOOST_CHECK_EQUAL(m1.find<bitfield_3_positions::pos1>(), false);
 205         BOOST_CHECK_EQUAL(m1.find<bitfield_3_positions::pos2>(), false);
 206         BOOST_CHECK_EQUAL(m1.find<bitfield_3_positions::pos3>(), false);
 207         BOOST_CHECK(!m2.empty());
 208         BOOST_CHECK_EQUAL(m2.size(), sizeof(bitfield_3_positions)+sizeof(int));
 209         BOOST_CHECK_GT(m2.max_size(), m2.size());
 210         BOOST_CHECK_EQUAL(m2.at<bitfield_3_positions::pos1>(), 42);
 211         BOOST_CHECK_THROW(m2.at<bitfield_3_positions::pos2>(), std::range_error);
 212         BOOST_CHECK_THROW(m2.at<bitfield_3_positions::pos3>(), std::range_error);
 213         BOOST_CHECK_EQUAL(m2.find<bitfield_3_positions::pos1>(), true);
 214         BOOST_CHECK_EQUAL(m2.find<bitfield_3_positions::pos2>(), false);
 215         BOOST_CHECK_EQUAL(m2.find<bitfield_3_positions::pos3>(), false);
 216 }
 217 
 218 BOOST_AUTO_TEST_CASE(insert_2_move_assign)
 219 {
 220         bitfield_map<bitfield_3_to_type_map> m1;
 221         BOOST_CHECK_NO_THROW(m1.push_back<bitfield_3_positions::pos1>(42));
 222         bitfield_map<bitfield_3_to_type_map> m2;
 223         BOOST_CHECK_NO_THROW(m2.push_back<bitfield_3_positions::pos2>(p1_t()));
 224         BOOST_CHECK_NO_THROW(m2=std::move(m1));
 225         BOOST_CHECK(!m1.empty());
 226         BOOST_CHECK_EQUAL(m1.size(), sizeof(bitfield_3_positions)+sizeof(p1_t));
 227         BOOST_CHECK_GT(m1.max_size(), m1.size());
 228         BOOST_CHECK_THROW(m1.at<bitfield_3_positions::pos1>(), std::range_error);
 229         BOOST_CHECK_EQUAL(m1.at<bitfield_3_positions::pos2>().i, p1_t().i);
 230         BOOST_CHECK_THROW(m1.at<bitfield_3_positions::pos3>(), std::range_error);
 231         BOOST_CHECK_EQUAL(m1.find<bitfield_3_positions::pos1>(), false);
 232         BOOST_CHECK_EQUAL(m1.find<bitfield_3_positions::pos2>(), true);
 233         BOOST_CHECK_EQUAL(m1.find<bitfield_3_positions::pos3>(), false);
 234         BOOST_CHECK(!m2.empty());
 235         BOOST_CHECK_EQUAL(m2.size(), sizeof(bitfield_3_positions)+sizeof(int));
 236         BOOST_CHECK_GT(m2.max_size(), m2.size());
 237         BOOST_CHECK_EQUAL(m2.at<bitfield_3_positions::pos1>(), 42);
 238         BOOST_CHECK_THROW(m2.at<bitfield_3_positions::pos2>(), std::range_error);
 239         BOOST_CHECK_THROW(m2.at<bitfield_3_positions::pos3>(), std::range_error);
 240         BOOST_CHECK_EQUAL(m2.find<bitfield_3_positions::pos1>(), true);
 241         BOOST_CHECK_EQUAL(m2.find<bitfield_3_positions::pos2>(), false);
 242         BOOST_CHECK_EQUAL(m2.find<bitfield_3_positions::pos3>(), false);
 243 }
 244 
 245 BOOST_AUTO_TEST_CASE(clear_1_element)
 246 {
 247         bitfield_map<bitfield_3_to_type_map> m;
 248         BOOST_CHECK_NO_THROW(m.push_back<bitfield_3_positions::pos1>(42));
 249         BOOST_CHECK_NO_THROW(m.clear());
 250         BOOST_CHECK_THROW(m.at<bitfield_3_positions::pos1>(), std::range_error);
 251         BOOST_CHECK_THROW(m.at<bitfield_3_positions::pos2>(), std::range_error);
 252         BOOST_CHECK_THROW(m.at<bitfield_3_positions::pos3>(), std::range_error);
 253         BOOST_CHECK_EQUAL(m.find<bitfield_3_positions::pos1>(), false);
 254         BOOST_CHECK_EQUAL(m.find<bitfield_3_positions::pos2>(), false);
 255         BOOST_CHECK_EQUAL(m.find<bitfield_3_positions::pos3>(), false);
 256         BOOST_CHECK_EQUAL(m.size(), sizeof(bitfield_3_positions));
 257         BOOST_CHECK(m.empty());
 258 }
 259 
 260 BOOST_AUTO_TEST_CASE(at_1_item)
 261 {
 262         bitfield_map<bitfield_3_to_type_map> m;
 263         BOOST_CHECK_NO_THROW(m.push_back<bitfield_3_positions::pos1>(42));
 264         BOOST_CHECK_NO_THROW(m.at<bitfield_3_positions::pos1>());
 265         BOOST_CHECK_NO_THROW(m.at<bitfield_3_positions::pos1>()=68);
 266         BOOST_CHECK_EQUAL(m.at<bitfield_3_positions::pos1>(), 68);
 267 }
 268 
 269 BOOST_AUTO_TEST_CASE(erase_1_item)
 270 {
 271         bitfield_map<bitfield_3_to_type_map> m;
 272         BOOST_CHECK_NO_THROW(m.push_back<bitfield_3_positions::pos1>(42));
 273         BOOST_CHECK_NO_THROW(m.erase<bitfield_3_positions::pos1>());
 274         BOOST_CHECK_THROW(m.at<bitfield_3_positions::pos1>(), std::range_error);
 275         BOOST_CHECK_EQUAL(m.find<bitfield_3_positions::pos1>(), false);
 276         BOOST_CHECK_EQUAL(m.size(), sizeof(bitfield_3_positions));
 277         BOOST_CHECK(m.empty());
 278 }
 279 
 280 BOOST_AUTO_TEST_CASE(insert_2_items_at_find)
 281 {
 282         bitfield_map<bitfield_3_to_type_map> m;
 283         BOOST_CHECK_NO_THROW(m.push_back<bitfield_3_positions::pos1>(42));
 284         BOOST_CHECK_NO_THROW(m.push_back<bitfield_3_positions::pos2>(p1_t()));
 285         BOOST_CHECK(!m.empty());
 286         BOOST_CHECK_EQUAL(m.size(), sizeof(bitfield_3_positions)+sizeof(int)+sizeof(p1_t));
 287         BOOST_CHECK_GE(m.max_size(), m.size());
 288         BOOST_CHECK_EQUAL(m.at<bitfield_3_positions::pos1>(), 42);
 289         BOOST_CHECK_EQUAL(m.at<bitfield_3_positions::pos2>().i, p1_t().i);
 290         BOOST_CHECK_EQUAL(m.find<bitfield_3_positions::pos1>(), true);
 291         BOOST_CHECK_EQUAL(m.find<bitfield_3_positions::pos2>(), true);
 292 }
 293 
 294 BOOST_AUTO_TEST_CASE(invalid_insert_2_erase_1_element)
 295 {
 296         bitfield_map<bitfield_3_to_type_map> m;
 297         BOOST_CHECK_NO_THROW(m.push_back<bitfield_3_positions::pos1>(42));
 298         BOOST_CHECK_NO_THROW(m.push_back<bitfield_3_positions::pos2>(p1_t()));
 299         BOOST_CHECK_NO_THROW(m.erase<bitfield_3_positions::pos1>());
 300         BOOST_CHECK_THROW(m.at<bitfield_3_positions::pos1>(), std::range_error);
 301         BOOST_CHECK_EQUAL(m.find<bitfield_3_positions::pos1>(), false);
 302         BOOST_CHECK_EQUAL(m.find<bitfield_3_positions::pos2>(), true);
 303         BOOST_CHECK_EQUAL(m.size(), sizeof(bitfield_3_positions)+sizeof(p1_t));
 304         BOOST_CHECK(!m.empty());
 305 }
 306 
 307 BOOST_AUTO_TEST_CASE(insert_2_erase_2_elements)
 308 {
 309         bitfield_map<bitfield_3_to_type_map> m;
 310         BOOST_CHECK_NO_THROW(m.push_back<bitfield_3_positions::pos1>(42));
 311         BOOST_CHECK_NO_THROW(m.push_back<bitfield_3_positions::pos2>(p1_t()));
 312         BOOST_CHECK_NO_THROW(m.erase<bitfield_3_positions::pos2>());
 313         BOOST_CHECK_THROW(m.at<bitfield_3_positions::pos2>(), std::range_error);
 314         BOOST_CHECK_NO_THROW(m.at<bitfield_3_positions::pos1>());
 315         BOOST_CHECK_EQUAL(m.find<bitfield_3_positions::pos1>(), true);
 316         BOOST_CHECK_EQUAL(m.find<bitfield_3_positions::pos2>(), false);
 317         BOOST_CHECK_EQUAL(m.size(), sizeof(bitfield_3_positions)+sizeof(int));
 318         BOOST_CHECK(!m.empty());
 319         BOOST_CHECK_NO_THROW(m.erase<bitfield_3_positions::pos1>());
 320         BOOST_CHECK_THROW(m.at<bitfield_3_positions::pos1>(), std::range_error);
 321         BOOST_CHECK_THROW(m.at<bitfield_3_positions::pos2>(), std::range_error);
 322         BOOST_CHECK_EQUAL(m.find<bitfield_3_positions::pos1>(), false);
 323         BOOST_CHECK_EQUAL(m.find<bitfield_3_positions::pos2>(), false);
 324         BOOST_CHECK_EQUAL(m.size(), sizeof(bitfield_3_positions));
 325         BOOST_CHECK(m.empty());
 326 }
 327 
 328 BOOST_AUTO_TEST_CASE(insert_3_items_at)
 329 {
 330         bitfield_map<bitfield_3_to_type_map> m;
 331         BOOST_CHECK_NO_THROW(m.push_back<bitfield_3_positions::pos1>(42));
 332         BOOST_CHECK_NO_THROW(m.push_back<bitfield_3_positions::pos2>(p1_t()));
 333         BOOST_CHECK_NO_THROW(m.push_back<bitfield_3_positions::pos3>(p2_t()));
 334         BOOST_CHECK(!m.empty());
 335         BOOST_CHECK_EQUAL(m.size(), sizeof(bitfield_3_positions)+sizeof(int)+sizeof(p1_t)+sizeof(p2_t));
 336         BOOST_CHECK_GE(m.max_size(), m.size());
 337         BOOST_CHECK_EQUAL(m.at<bitfield_3_positions::pos1>(), 42);
 338         BOOST_CHECK_EQUAL(m.at<bitfield_3_positions::pos2>().i, p1_t().i);
 339         BOOST_CHECK_EQUAL(m.at<bitfield_3_positions::pos3>().i, p2_t().i);
 340 }
 341 
 342 BOOST_AUTO_TEST_SUITE_END()

/* [<][>][^][v][top][bottom][index][help] */