test/utils/Test_utils_bitset.cpp

   1 #include <gtest/gtest.h>
   2 #include <marnav/utils/bitset.hpp>
   3
   4 namespace
   5 {
   6
   7 using namespace marnav::utils;
   8
   9 class Test_utils_bitset : public ::testing::Test
  10 {
  11 public:
  12         template <class T> std::string to_string(const bitset<T> & bits)
  13         {
  14                 std::string result;
  15                 result.reserve(bits.size());
  16                 for (auto const & b : bits)
  17                         result += '0' + b;
  18                 return result;
  19         }
  20 };
  21
  22 TEST_F(Test_utils_bitset, uint8__construction_bit_size)
  23 {
  24         bitset<uint8_t> b{16};
  25
  26         //            0       8       16      24      32      40      48      56
  27         //            +-------+-------+-------+-------+-------+-------+-------+-------
  28         EXPECT_STREQ("0000000000000000", to_string(b).c_str());
  29 }
  30
  31 TEST_F(Test_utils_bitset, uint8__construction_container_iterator)
  32 {
  33         using namespace std;
  34
  35         vector<uint8_t> v{0xaa, 0x55};
  36         bitset<uint8_t> b(begin(v), end(v));
  37
  38         //            0       8       16      24      32      40      48      56
  39         //            +-------+-------+-------+-------+-------+-------+-------+-------
  40         EXPECT_STREQ("1010101001010101", to_string(b).c_str());
  41 }
  42
  43 TEST_F(Test_utils_bitset, uint8__construction_container_move)
  44 {
  45         bitset<uint8_t> b(std::vector<uint8_t>{0xaa, 0x55});
  46
  47         //            0       8       16      24      32      40      48      56
  48         //            +-------+-------+-------+-------+-------+-------+-------+-------
  49         EXPECT_STREQ("1010101001010101", to_string(b).c_str());
  50 }
  51
  52 TEST_F(Test_utils_bitset, const_iterator_comparison_less)
  53 {
  54         bitset<uint8_t> b{16};
  55
  56         auto i = b.begin();
  57         auto j = b.begin();
  58         auto k = b.begin();
  59         ++k;
  60
  61         EXPECT_FALSE(i < j);
  62         EXPECT_TRUE(i < k);
  63 }
  64
  65 TEST_F(Test_utils_bitset, const_iterator_comparison_greater)
  66 {
  67         bitset<uint8_t> b{16};
  68
  69         auto i = b.begin();
  70         auto j = b.begin();
  71         auto k = b.begin();
  72         ++k;
  73
  74         EXPECT_FALSE(i > j);
  75         EXPECT_TRUE(k > i);
  76 }
  77
  78 TEST_F(Test_utils_bitset, uint8__append_single_bits)
  79 {
  80         {
  81                 bitset<uint8_t> bits;
  82                 bits.append(1, 1);
  83                 //            0       8       16      24      32      40      48      56
  84                 //            +-------+-------+-------+-------+-------+-------+-------+-------
  85                 EXPECT_STREQ("1", to_string(bits).c_str());
  86         }
  87         {
  88                 bitset<uint8_t> bits;
  89                 bits.append(1, 1);
  90                 bits.append(0, 1);
  91                 bits.append(0, 1);
  92                 bits.append(1, 1);
  93                 //            0       8       16      24      32      40      48      56
  94                 //            +-------+-------+-------+-------+-------+-------+-------+-------
  95                 EXPECT_STREQ("1001", to_string(bits).c_str());
  96         }
  97         {
  98                 bitset<uint8_t> bits{8};
  99                 bits.append(1, 1);
 100                 //            0       8       16      24      32      40      48      56
 101                 //            +-------+-------+-------+-------+-------+-------+-------+-------
 102                 EXPECT_STREQ("000000001", to_string(bits).c_str());
 103         }
 104 }
 105
 106 TEST_F(Test_utils_bitset, uint8__append_block_size_plus_one)
 107 {
 108         bitset<uint8_t> bits;
 109         bits.append(0x00000001, 9);
 110         //            0       8       16      24      32      40      48      56
 111         //            +-------+-------+-------+-------+-------+-------+-------+-------
 112         EXPECT_STREQ("000000001", to_string(bits).c_str());
 113 }
 114
 115 TEST_F(Test_utils_bitset, uint8__append_multiple_bits)
 116 {
 117         {
 118                 bitset<uint8_t> bits;
 119                 bits.append(0x00000001, 2);
 120                 //            0       8       16      24      32      40      48      56
 121                 //            +-------+-------+-------+-------+-------+-------+-------+-------
 122                 EXPECT_STREQ("01", to_string(bits).c_str());
 123         }
 124         {
 125                 bitset<uint8_t> bits;
 126                 bits.append(0x00000001, 1);
 127                 bits.append(0x00000001, 2);
 128                 bits.append(0x00000001, 3);
 129                 bits.append(0x00000001, 4);
 130                 bits.append(0x00000001, 5);
 131                 bits.append(0x00000001, 6);
 132                 bits.append(0x00000001, 7);
 133                 bits.append(0x00000001, 8);
 134                 bits.append(0x00000001, 9);
 135                 bits.append(0x00000001, 10);
 136                 //            0       8       16      24      32      40      48      56
 137                 //            +-------+-------+-------+-------+-------+-------+-------+-------
 138                 EXPECT_STREQ(
 139                         "1010010001000010000010000001000000010000000010000000001", to_string(bits).c_str());
 140         }
 141         {
 142                 bitset<uint8_t> bits;
 143
 144                 //            0       8       16      24      32      40      48      56
 145                 //            +-------+-------+-------+-------+-------+-------+-------+-------
 146                 //            111010011110101011001111111111
 147                 const uint32_t value = 981119999; // 30 bits of information
 148
 149                 bits.append(value, 32);
 150
 151                 //            0       8       16      24      32      40      48      56
 152                 //            +-------+-------+-------+-------+-------+-------+-------+-------
 153                 EXPECT_STREQ("00111010011110101011001111111111", to_string(bits).c_str());
 154         }
 155         {
 156                 bitset<uint8_t> bits;
 157
 158                 //            0       8       16      24      32      40      48      56
 159                 //            +-------+-------+-------+-------+-------+-------+-------+-------
 160                 //            111010011110101011001111111111
 161                 const uint32_t value = 981119999; // 30 bits of information
 162
 163                 bits.append(value, 30);
 164
 165                 //            0       8       16      24      32      40      48      56
 166                 //            +-------+-------+-------+-------+-------+-------+-------+-------
 167                 EXPECT_STREQ("111010011110101011001111111111", to_string(bits).c_str());
 168         }
 169 }
 170
 171 TEST_F(Test_utils_bitset, uint8__set_single_bits)
 172 {
 173         {
 174                 bitset<uint8_t> bits{64};
 175                 bits.set(1, 0, 1);
 176                 //            0       8       16      24      32      40      48      56
 177                 //            +-------+-------+-------+-------+-------+-------+-------+-------
 178                 EXPECT_STREQ("1000000000000000000000000000000000000000000000000000000000000000",
 179                         to_string(bits).c_str());
 180         }
 181         {
 182                 bitset<uint8_t> bits{64};
 183                 bits.set(1, 1, 1);
 184                 //            0       8       16      24      32      40      48      56
 185                 //            +-------+-------+-------+-------+-------+-------+-------+-------
 186                 EXPECT_STREQ("0100000000000000000000000000000000000000000000000000000000000000",
 187                         to_string(bits).c_str());
 188         }
 189         {
 190                 bitset<uint8_t> bits{64};
 191                 bits.set(1, 15, 1);
 192                 //            0       8       16      24      32      40      48      56
 193                 //            +-------+-------+-------+-------+-------+-------+-------+-------
 194                 EXPECT_STREQ("0000000000000001000000000000000000000000000000000000000000000000",
 195                         to_string(bits).c_str());
 196         }
 197         {
 198                 bitset<uint8_t> bits{64};
 199                 bits.set(1, 16, 1);
 200                 //            0       8       16      24      32      40      48      56
 201                 //            +-------+-------+-------+-------+-------+-------+-------+-------
 202                 EXPECT_STREQ("0000000000000000100000000000000000000000000000000000000000000000",
 203                         to_string(bits).c_str());
 204         }
 205 }
 206
 207 TEST_F(Test_utils_bitset, uint8__set_block_size_plus_one)
 208 {
 209         bitset<uint8_t> bits{32};
 210         bits.set(0x00000001, 0, 9);
 211         //            0       8       16      24      32      40      48      56
 212         //            +-------+-------+-------+-------+-------+-------+-------+-------
 213         EXPECT_STREQ("00000000100000000000000000000000", to_string(bits).c_str());
 214 }
 215
 216 TEST_F(Test_utils_bitset, uint8__set_multiple_bits)
 217 {
 218         {
 219                 bitset<uint8_t> bits{64};
 220                 bits.set(0x00000001, 0, 2);
 221                 //            0       8       16      24      32      40      48      56
 222                 //            +-------+-------+-------+-------+-------+-------+-------+-------
 223                 EXPECT_STREQ("0100000000000000000000000000000000000000000000000000000000000000",
 224                         to_string(bits).c_str());
 225         }
 226         {
 227                 bitset<uint8_t> bits{64};
 228                 bits.set(0x00000001, 1, 2);
 229                 //            0       8       16      24      32      40      48      56
 230                 //            +-------+-------+-------+-------+-------+-------+-------+-------
 231                 EXPECT_STREQ("0010000000000000000000000000000000000000000000000000000000000000",
 232                         to_string(bits).c_str());
 233         }
 234         {
 235                 bitset<uint8_t> bits{64};
 236                 bits.set(0x00000001, 15, 2);
 237                 //            0       8       16      24      32      40      48      56
 238                 //            +-------+-------+-------+-------+-------+-------+-------+-------
 239                 EXPECT_STREQ("0000000000000000100000000000000000000000000000000000000000000000",
 240                         to_string(bits).c_str());
 241         }
 242         {
 243                 bitset<uint8_t> bits{64};
 244                 bits.set(0x00000001, 16, 2);
 245                 //            0       8       16      24      32      40      48      56
 246                 //            +-------+-------+-------+-------+-------+-------+-------+-------
 247                 EXPECT_STREQ("0000000000000000010000000000000000000000000000000000000000000000",
 248                         to_string(bits).c_str());
 249         }
 250         {
 251                 bitset<uint8_t> bits{64};
 252
 253                 //            0       8       16      24      32      40      48      56
 254                 //            +-------+-------+-------+-------+-------+-------+-------+-------
 255                 //            111010011110101011001111111111
 256                 const uint32_t value = 981119999; // 30 bits of information
 257
 258                 bits.set(value, 8, 30);
 259                 //            0       8       16      24      32      40      48      56
 260                 //            +-------+-------+-------+-------+-------+-------+-------+-------
 261                 EXPECT_STREQ("0000000011101001111010101100111111111100000000000000000000000000",
 262                         to_string(bits).c_str());
 263         }
 264 }
 265
 266 TEST_F(Test_utils_bitset, uint8__get_multiple_bits_ending_on_block_boundary)
 267 {
 268         bitset<uint8_t> bits{64};
 269         bits.set(0x7, 5, 3);
 270         //            0       8       16      24      32      40      48      56
 271         //            +-------+-------+-------+-------+-------+-------+-------+-------
 272         ASSERT_STREQ("0000011100000000000000000000000000000000000000000000000000000000",
 273                 to_string(bits).c_str());
 274
 275         uint32_t value = 0xffffffff;
 276         bits.get(value, 0, 6);
 277         EXPECT_EQ(1u, value);
 278 }
 279
 280 TEST_F(Test_utils_bitset, uint8__get_multiple_bits_completely_within_block)
 281 {
 282         bitset<uint8_t> bits{64};
 283         bits.set(0xff, 4, 3);
 284         //            0       8       16      24      32      40      48      56
 285         //            +-------+-------+-------+-------+-------+-------+-------+-------
 286         ASSERT_STREQ("0000111000000000000000000000000000000000000000000000000000000000",
 287                 to_string(bits).c_str());
 288
 289         uint32_t value = 0xffffffff;
 290         bits.get(value, 0, 6);
 291         EXPECT_EQ(3u, value);
 292 }
 293
 294 TEST_F(Test_utils_bitset, uint8__get_multiple_bits_fractions_of_two_blocks)
 295 {
 296         bitset<uint8_t> bits{64};
 297         bits.set(0xff, 4, 6);
 298         //            0       8       16      24      32      40      48      56
 299         //            +-------+-------+-------+-------+-------+-------+-------+-------
 300         ASSERT_STREQ("0000111111000000000000000000000000000000000000000000000000000000",
 301                 to_string(bits).c_str());
 302
 303         uint32_t value = 0xffffffff;
 304         bits.get(value, 0, 6);
 305         EXPECT_EQ(3u, value);
 306 }
 307
 308 TEST_F(Test_utils_bitset, uint8__get_multiple_bits_using_three_blocks)
 309 {
 310         bitset<uint8_t> bits{64};
 311         bits.set(0xffff, 4, 14);
 312         //            0       8       16      24      32      40      48      56
 313         //            +-------+-------+-------+-------+-------+-------+-------+-------
 314         ASSERT_STREQ("0000111111111111110000000000000000000000000000000000000000000000",
 315                 to_string(bits).c_str());
 316
 317         uint32_t value = 0xffffffff;
 318         bits.get(value, 2, 6);
 319         EXPECT_EQ(15u, value);
 320 }
 321
 322 TEST_F(Test_utils_bitset, uint8__set_enum)
 323 {
 324         enum class ids : uint8_t { A = 1, B, C };
 325
 326         bitset<uint8_t> bits{64};
 327         bits.set(ids::A, 4, 6);
 328         //            0       8       16      24      32      40      48      56
 329         //            +-------+-------+-------+-------+-------+-------+-------+-------
 330         ASSERT_STREQ("0000000001000000000000000000000000000000000000000000000000000000",
 331                 to_string(bits).c_str());
 332 }
 333
 334 TEST_F(Test_utils_bitset, uint16__get_multiple_bits_ending_on_block_boundary)
 335 {
 336         bitset<uint16_t> bits{64};
 337         bits.set(0xff, 13, 3);
 338         //            0       8       16      24      32      40      48      56
 339         //            +-------+-------+-------+-------+-------+-------+-------+-------
 340         ASSERT_STREQ("0000000000000111000000000000000000000000000000000000000000000000",
 341                 to_string(bits).c_str());
 342
 343         uint32_t value = 0xffffffff;
 344         bits.get(value, 8, 6);
 345         EXPECT_EQ(1u, value);
 346 }
 347
 348 TEST_F(Test_utils_bitset, uint16__get_multiple_bits_completely_within_block)
 349 {
 350         bitset<uint16_t> bits{64};
 351         bits.set(0x7, 4, 3);
 352         //            0       8       16      24      32      40      48      56
 353         //            +-------+-------+-------+-------+-------+-------+-------+-------
 354         ASSERT_STREQ("0000111000000000000000000000000000000000000000000000000000000000",
 355                 to_string(bits).c_str());
 356
 357         uint32_t value = 0xffffffff;
 358         bits.get(value, 0, 6);
 359         EXPECT_EQ(3u, value);
 360 }
 361
 362 TEST_F(Test_utils_bitset, uint16__get_multiple_bits_fractions_of_two_blocks)
 363 {
 364         bitset<uint16_t> bits{64};
 365         bits.set(0xffff, 4, 6);
 366         //            0       8       16      24      32      40      48      56
 367         //            +-------+-------+-------+-------+-------+-------+-------+-------
 368         ASSERT_STREQ("0000111111000000000000000000000000000000000000000000000000000000",
 369                 to_string(bits).c_str());
 370
 371         uint32_t value = 0xffffffff;
 372         bits.get(value, 0, 6);
 373         EXPECT_EQ(3u, value);
 374 }
 375
 376 TEST_F(Test_utils_bitset, uint16__get_multiple_bits_using_three_blocks)
 377 {
 378         bitset<uint16_t> bits{64};
 379         uint64_t val = -1;
 380         bits.set(val, 4, 40);
 381         //            0       8       16      24      32      40      48      56
 382         //            +-------+-------+-------+-------+-------+-------+-------+-------
 383         ASSERT_STREQ("0000111111111111111111111111111111111111111100000000000000000000",
 384                 to_string(bits).c_str());
 385
 386         uint32_t value = 0xffffffff;
 387         bits.get(value, 2, 6);
 388         EXPECT_EQ(15u, value);
 389 }
 390
 391 TEST_F(Test_utils_bitset, uint8__copy_constructor)
 392 {
 393         bitset<uint8_t> bits{32};
 394         bits.set(1, 0, 6);
 395
 396         bitset<uint8_t> copy(bits);
 397
 398         //            0       8       16      24      32      40      48      56
 399         //            +-------+-------+-------+-------+
 400         ASSERT_STREQ("00000100000000000000000000000000", to_string(bits).c_str());
 401         EXPECT_STREQ("00000100000000000000000000000000", to_string(copy).c_str());
 402 }
 403
 404 TEST_F(Test_utils_bitset, uint8__assignment)
 405 {
 406         bitset<uint8_t> bits{32};
 407         bits.set(1, 0, 6);
 408
 409         bitset<uint8_t> copy{16};
 410         ASSERT_STREQ("0000000000000000", to_string(copy).c_str());
 411         copy = bits;
 412
 413         //            0       8       16      24      32      40      48      56
 414         //            +-------+-------+-------+-------+
 415         ASSERT_STREQ("00000100000000000000000000000000", to_string(bits).c_str());
 416         EXPECT_STREQ("00000100000000000000000000000000", to_string(copy).c_str());
 417 }
 418
 419 template <class T> bitset<uint8_t> get_test_data(unsigned int size)
 420 {
 421         bitset<T> result{size};
 422
 423         result.set(1, 0, 6);
 424
 425         return result;
 426 }
 427
 428 TEST_F(Test_utils_bitset, uint8__as_return_value_small)
 429 {
 430         auto bits = get_test_data<uint8_t>(32);
 431
 432         //            0       8       16      24      32      40      48      56
 433         //            +-------+-------+-------+-------+
 434         ASSERT_STREQ("00000100000000000000000000000000", to_string(bits).c_str());
 435 }
 436
 437 TEST_F(Test_utils_bitset, uint8__as_return_value_medium)
 438 {
 439         auto bits = get_test_data<uint8_t>(168);
 440
 441         //            0       8       16      24      32      40      48      56
 442         //            +-------+-------+-------+-------+
 443         ASSERT_STREQ("00000100000000000000000000000000000000000000000000000000000000000000000000000"
 444                                  "00000000000000000000000000000000000000000000000000000000000000000000000000000"
 445                                  "00000000000000",
 446                 to_string(bits).c_str());
 447 }
 448
 449 TEST_F(Test_utils_bitset, uint8__set_multiple_values)
 450 {
 451         bitset<uint8_t> bits{64};
 452
 453         //            0       8       16      24      32      40      48      56
 454         //            +-------+-------+-------+-------+-------+-------+-------+-------
 455         ASSERT_STREQ("0000000000000000000000000000000000000000000000000000000000000000",
 456                 to_string(bits).c_str());
 457
 458         bits.set(1, 0, 6);
 459
 460         //            0       8       16      24      32      40      48      56
 461         //            +-------+-------+-------+-------+-------+-------+-------+-------
 462         ASSERT_STREQ("0000010000000000000000000000000000000000000000000000000000000000",
 463                 to_string(bits).c_str());
 464
 465         bits.set(1, 6, 2);
 466
 467         //            0       8       16      24      32      40      48      56
 468         //            +-------+-------+-------+-------+-------+-------+-------+-------
 469         ASSERT_STREQ("0000010100000000000000000000000000000000000000000000000000000000",
 470                 to_string(bits).c_str());
 471 }
 472
 473 TEST_F(Test_utils_bitset, uint8__flip)
 474 {
 475         bitset<uint8_t> bits{64};
 476
 477         //            0       8       16      24      32      40      48      56
 478         //            +-------+-------+-------+-------+-------+-------+-------+-------
 479         EXPECT_STREQ("0000000000000000000000000000000000000000000000000000000000000000",
 480                 to_string(bits).c_str());
 481
 482         bits.flip(0);
 483         //            0       8       16      24      32      40      48      56
 484         //            +-------+-------+-------+-------+-------+-------+-------+-------
 485         EXPECT_STREQ("1000000000000000000000000000000000000000000000000000000000000000",
 486                 to_string(bits).c_str());
 487
 488         bits.flip(10);
 489         //            0       8       16      24      32      40      48      56
 490         //            +-------+-------+-------+-------+-------+-------+-------+-------
 491         EXPECT_STREQ("1000000000100000000000000000000000000000000000000000000000000000",
 492                 to_string(bits).c_str());
 493
 494         bits.flip(32);
 495         //            0       8       16      24      32      40      48      56
 496         //            +-------+-------+-------+-------+-------+-------+-------+-------
 497         EXPECT_STREQ("1000000000100000000000000000000010000000000000000000000000000000",
 498                 to_string(bits).c_str());
 499 }
 500
 501 TEST_F(Test_utils_bitset, uint8__append_bitset_to_empty_bitset)
 502 {
 503         bitset<uint8_t> b0;
 504         bitset<uint8_t> b1;
 505
 506         b0.append(0x55, 8);
 507         b1.append(b0);
 508
 509         //            0       8       16      24      32      40      48      56
 510         //            +-------+
 511         EXPECT_STREQ("01010101", to_string(b0).c_str());
 512         EXPECT_STREQ("01010101", to_string(b1).c_str());
 513 }
 514
 515 TEST_F(Test_utils_bitset, uint8__append_bitset_to_nonempty_bitset)
 516 {
 517         bitset<uint8_t> b0;
 518         bitset<uint8_t> b1;
 519
 520         b0.append(0x55, 8);
 521         b1.append(0xaa, 8);
 522         b1.append(b0);
 523
 524         //            0       8       16      24      32      40      48      56
 525         //            +-------+
 526         EXPECT_STREQ("01010101", to_string(b0).c_str());
 527         EXPECT_STREQ("1010101001010101", to_string(b1).c_str());
 528 }
 529
 530 TEST_F(Test_utils_bitset, uint8__set_bitset_to_empty_bitset)
 531 {
 532         bitset<uint8_t> b0;
 533         bitset<uint8_t> b1;
 534
 535         b0.append(0x55, 8);
 536         b1.set(b0, 0);
 537
 538         //            0       8       16      24      32      40      48      56
 539         //            +-------+
 540         EXPECT_STREQ("01010101", to_string(b0).c_str());
 541         EXPECT_STREQ("01010101", to_string(b1).c_str());
 542 }
 543
 544 TEST_F(Test_utils_bitset, uint8__set_bitset_to_empty_bitset_mixed_type_bitsets_8_to_16)
 545 {
 546         bitset<uint8_t> b0;
 547         bitset<uint16_t> b1;
 548
 549         b0.append(0x55, 8);
 550         b1.set(b0, 0);
 551
 552         //            0       8       16      24      32      40      48      56
 553         //            +-------+
 554         EXPECT_STREQ("01010101", to_string(b0).c_str());
 555         EXPECT_STREQ("01010101", to_string(b1).c_str());
 556 }
 557
 558 TEST_F(Test_utils_bitset, uint8__set_bitset_to_empty_bitset_mixed_type_bitsets_16_to_8)
 559 {
 560         bitset<uint16_t> b0;
 561         bitset<uint8_t> b1;
 562
 563         b0.append(0x55, 8);
 564         b1.set(b0, 0);
 565
 566         //            0       8       16      24      32      40      48      56
 567         //            +-------+
 568         EXPECT_STREQ("01010101", to_string(b0).c_str());
 569         EXPECT_STREQ("01010101", to_string(b1).c_str());
 570 }
 571
 572 TEST_F(Test_utils_bitset, uint8__set_bitset_to_nonempty_bitset)
 573 {
 574         bitset<uint8_t> b0;
 575         bitset<uint8_t> b1;
 576
 577         b0.append(0x55, 8);
 578         b1.append(0xaa, 8);
 579         b1.set(b0, 0);
 580
 581         //            0       8       16      24      32      40      48      56
 582         //            +-------+
 583         EXPECT_STREQ("01010101", to_string(b0).c_str());
 584         EXPECT_STREQ("01010101", to_string(b1).c_str());
 585 }
 586
 587 TEST_F(Test_utils_bitset, uint8__set_bit)
 588 {
 589         bitset<uint8_t> b{8};
 590
 591         EXPECT_STREQ("00000000", to_string(b).c_str());
 592         b.set_bit(0, true);
 593         EXPECT_STREQ("10000000", to_string(b).c_str());
 594         b.set_bit(7, true);
 595         EXPECT_STREQ("10000001", to_string(b).c_str());
 596         b.set_bit(0, false);
 597         EXPECT_STREQ("00000001", to_string(b).c_str());
 598         b.set_bit(7, false);
 599         EXPECT_STREQ("00000000", to_string(b).c_str());
 600 }
 601
 602 TEST_F(Test_utils_bitset, uint8__reset_all)
 603 {
 604         bitset<uint8_t> b{8};
 605         b.set(0xaa, 0, 8);
 606
 607         EXPECT_STREQ("10101010", to_string(b).c_str());
 608         b.reset();
 609         EXPECT_STREQ("00000000", to_string(b).c_str());
 610 }
 611
 612 TEST_F(Test_utils_bitset, uint8__all)
 613 {
 614         {
 615                 bitset<uint8_t> b{8};
 616                 EXPECT_FALSE(b.all());
 617         }
 618         {
 619                 bitset<uint8_t> b{8};
 620                 b.set(0xaa, 0, 8);
 621                 EXPECT_FALSE(b.all());
 622         }
 623         {
 624                 bitset<uint8_t> b{8};
 625                 b.set(1, 0, 8);
 626                 EXPECT_FALSE(b.all());
 627         }
 628         {
 629                 bitset<uint8_t> b{8};
 630                 b.set(0xff, 0, 8);
 631                 EXPECT_TRUE(b.all());
 632         }
 633 }
 634
 635 TEST_F(Test_utils_bitset, uint8__any)
 636 {
 637         {
 638                 bitset<uint8_t> b{8};
 639                 EXPECT_FALSE(b.any());
 640         }
 641         {
 642                 bitset<uint8_t> b{8};
 643                 b.set(0xaa, 0, 8);
 644                 EXPECT_TRUE(b.any());
 645         }
 646         {
 647                 bitset<uint8_t> b{8};
 648                 b.set(1, 0, 8);
 649                 EXPECT_TRUE(b.any());
 650         }
 651         {
 652                 bitset<uint8_t> b{8};
 653                 b.set(0xff, 0, 8);
 654                 EXPECT_TRUE(b.any());
 655         }
 656 }
 657
 658 TEST_F(Test_utils_bitset, uint8__none)
 659 {
 660         {
 661                 bitset<uint8_t> b{8};
 662                 EXPECT_TRUE(b.none());
 663         }
 664         {
 665                 bitset<uint8_t> b{8};
 666                 b.set(0xaa, 0, 8);
 667                 EXPECT_FALSE(b.none());
 668         }
 669         {
 670                 bitset<uint8_t> b{8};
 671                 b.set(1, 0, 8);
 672                 EXPECT_FALSE(b.none());
 673         }
 674         {
 675                 bitset<uint8_t> b{8};
 676                 b.set(0xff, 0, 8);
 677                 EXPECT_FALSE(b.none());
 678         }
 679 }
 680
 681 TEST_F(Test_utils_bitset, uint8__count)
 682 {
 683         {
 684                 bitset<uint8_t> b{8};
 685                 EXPECT_EQ(0u, b.count());
 686         }
 687         {
 688                 bitset<uint8_t> b{8};
 689                 b.set(0xaa, 0, 8);
 690                 EXPECT_EQ(4u, b.count());
 691         }
 692         {
 693                 bitset<uint8_t> b{8};
 694                 b.set(1, 0, 8);
 695                 EXPECT_EQ(1u, b.count());
 696         }
 697         {
 698                 bitset<uint8_t> b{8};
 699                 b.set(0xff, 0, 8);
 700                 EXPECT_EQ(8u, b.count());
 701         }
 702 }
 703
 704 TEST_F(Test_utils_bitset, uint8__comparison_equal)
 705 {
 706         bitset<uint8_t> a;
 707         bitset<uint8_t> b;
 708         bitset<uint8_t> c;
 709
 710         a.append(0xaa, 8);
 711         b.append(0xaa, 8);
 712         c.append(0x55, 8);
 713
 714         EXPECT_TRUE(a == a);
 715         EXPECT_TRUE(b == b);
 716         EXPECT_TRUE(c == c);
 717
 718         EXPECT_TRUE(a == b);
 719         EXPECT_TRUE(b == a);
 720
 721         EXPECT_FALSE(a == c);
 722         EXPECT_FALSE(c == a);
 723         EXPECT_FALSE(b == c);
 724         EXPECT_FALSE(c == b);
 725 }
 726
 727 TEST_F(Test_utils_bitset, uint8__comparison_not_equal)
 728 {
 729         bitset<uint8_t> a;
 730         bitset<uint8_t> b;
 731         bitset<uint8_t> c;
 732
 733         a.append(0xaa, 8);
 734         b.append(0xaa, 8);
 735         c.append(0x55, 8);
 736
 737         EXPECT_FALSE(a != a);
 738         EXPECT_FALSE(b != b);
 739         EXPECT_FALSE(c != c);
 740
 741         EXPECT_FALSE(a != b);
 742         EXPECT_FALSE(b != a);
 743
 744         EXPECT_TRUE(a != c);
 745         EXPECT_TRUE(c != a);
 746         EXPECT_TRUE(b != c);
 747         EXPECT_TRUE(c != b);
 748 }
 749
 750 TEST_F(Test_utils_bitset, uint8__append_bits_exceeds_type)
 751 {
 752         bitset<uint8_t> b{32};
 753         const uint8_t data = 0xff;
 754         EXPECT_ANY_THROW(b.append(data, 16));
 755 }
 756
 757 TEST_F(Test_utils_bitset, uint8__set_bits_exceeds_type)
 758 {
 759         bitset<uint8_t> b{32};
 760         const uint8_t data = 0xff;
 761         EXPECT_ANY_THROW(b.set(data, 0, 16));
 762 }
 763
 764 TEST_F(Test_utils_bitset, uint8__get_bits_out_of_range)
 765 {
 766         bitset<uint8_t> b{32};
 767         uint8_t data;
 768         EXPECT_ANY_THROW(b.get(data, 0, 16));
 769         EXPECT_ANY_THROW(b.get(data, 28, 8));
 770         EXPECT_NO_THROW(b.get(data, 0, 0));
 771 }
 772
 773 TEST_F(Test_utils_bitset, uint8__get_uint32)
 774 {
 775         bitset<uint8_t> b{64};
 776         b.set(0xaaaaaaaa, 0, 32);
 777         b.set(0xaaaaaaaa, 32, 32);
 778         const uint32_t expected = 0xaaaaaaaa;
 779         uint32_t data = 0;
 780         b.get(data, 4);
 781         EXPECT_EQ(expected, data);
 782 }
 783
 784 TEST_F(Test_utils_bitset, uint8__get_bit_out_of_range)
 785 {
 786         bitset<uint8_t> b{32};
 787
 788         EXPECT_ANY_THROW(b.get_bit(64));
 789 }
 790
 791 TEST_F(Test_utils_bitset, uint8__set_bit_out_of_range)
 792 {
 793         bitset<uint8_t> b{32};
 794
 795         EXPECT_ANY_THROW(b.set_bit(64, 1));
 796 }
 797 }