coffee/etl
1
0
Fork 0
mirror of https://github.com/ETLCPP/etl.git synced 2026-04-30 19:09:10 +08:00
Code Issues Packages Projects Releases Wiki Activity
etl/test/test_bit.cpp
John Wellbelove b8579f0151 Initial bit tests
2022-01-03 18:21:45 +00:00

897 lines
30 KiB
C++
Raw Blame History

/******************************************************************************
The MIT License(MIT)
Embedded Template Library.
https://github.com/ETLCPP/etl
https://www.etlcpp.com
Copyright(c) 2021 jwellbelove
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files(the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions :
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
******************************************************************************/
#include "unit_test_framework.h"
#include <limits>
#include "etl/bit.h"
#include "etl/fnv_1.h"
namespace
{
// Count bits the long way.
template <typename T>
size_t test_count(T value)
{
size_t count = 0UL;
for (int i = 0; i < etl::integral_limits<T>::bits; ++i)
{
if ((value & (T(1) << i)) != 0)
{
++count;
}
}
return count;
}
// Count trailing zero the long way.
template <typename T>
size_t test_trailing_zeros(T value)
{
size_t count = 0UL;
for (int i = 0; i < etl::integral_limits<T>::bits; ++i)
{
if ((value & 1) == 0)
{
++count;
}
else
{
return count;
}
value >>= 1;
}
return count;
}
// Count trailing ones the long way.
template <typename T>
size_t test_trailing_ones(T value)
{
size_t count = 0UL;
for (int i = 0; i < etl::integral_limits<T>::bits; ++i)
{
if ((value & 1) == 1)
{
++count;
}
value >>= 1;
}
return count;
}
// Check parity the long way.
template <typename T>
size_t test_parity(T value)
{
size_t count = test_count(value);
return count & 1;
}
// Power of 2.
uint64_t test_power_of_2(int power)
{
uint64_t result = 1ULL;
for (int i = 0; i < power; ++i)
{
result *= 2;
}
return result;
}
SUITE(test_bit)
{
//*************************************************************************
TEST(test_rotl8)
{
uint8_t value;
value = 0x00U;
value = etl::rotl(value, 1);
CHECK_EQUAL(0, int(value));
value = 0x21U;
value = etl::rotl(value, 1);
CHECK_EQUAL(0x42U, int(value));
value = 0x42U;
value = etl::rotl(value, 1);
CHECK_EQUAL(0x84U, int(value));
value = 0x84U;
value = etl::rotl(value, 1);
CHECK_EQUAL(0x09U, int(value));
value = 0xB7U;
value = etl::rotl(value, 2);
CHECK_EQUAL(0xDEU, int(value));
value = 0xB7U;
value = etl::rotl(value, 3);
CHECK_EQUAL(0xBDU, int(value));
value = 0xB7U;
value = etl::rotl(value, 4);
CHECK_EQUAL(0x7BU, int(value));
value = 0xB7U;
value = etl::rotl(value, 5);
CHECK_EQUAL(0xF6U, int(value));
value = 0xB7U;
value = etl::rotl(value, 6);
CHECK_EQUAL(0xEDU, int(value));
value = 0xB7U;
value = etl::rotl(value, 7);
CHECK_EQUAL(0xDBU, int(value));
value = 0xB7U;
value = etl::rotl(value, 8);
CHECK_EQUAL(0xB7U, int(value));
value = 0xB7U;
value = etl::rotl(value, 9);
CHECK_EQUAL(0x6FU, int(value));
value = 0xB7U;
value = etl::rotl(value, -1);
CHECK_EQUAL(0xDBU, int(value));
}
#if !defined(ETL_FORCE_NO_ADVANCED_CPP)
//*************************************************************************
TEST(test_rotl8_constexpr)
{
char temp[etl::rotl(uint8_t(0xAAU), 1)];
CHECK_EQUAL(etl::rotl(uint8_t(0xAAU), 1), sizeof(temp));
}
#endif
//*************************************************************************
TEST(test_rotl16)
{
uint16_t value;
value = 0x0000U;
value = etl::rotl(value, 1);
CHECK_EQUAL(0, value);
value = 0x8421U;
value = etl::rotl(value, 1);
CHECK_EQUAL(0x0843U, value);
value = 0x0843U;
value = etl::rotl(value, 1);
CHECK_EQUAL(0x1086U, value);
value = 0x1086U;
value = etl::rotl(value, 1);
CHECK_EQUAL(0x210CU, value);
value = 0xB73CU;
value = etl::rotl(value, 2);
CHECK_EQUAL(0xDCF2U, int(value));
value = 0xB73CU;
value = etl::rotl(value, 3);
CHECK_EQUAL(0xB9E5U, int(value));
value = 0xB73CU;
value = etl::rotl(value, 4);
CHECK_EQUAL(0x73CBU, int(value));
value = 0xB73CU;
value = etl::rotl(value, 5);
CHECK_EQUAL(0xE796U, int(value));
value = 0xB73CU;
value = etl::rotl(value, 6);
CHECK_EQUAL(0xCF2DU, int(value));
value = 0xB73CU;
value = etl::rotl(value, 7);
CHECK_EQUAL(0x9E5BU, int(value));
value = 0xB73CU;
value = etl::rotl(value, 8);
CHECK_EQUAL(0x3CB7U, int(value));
value = 0xB73CU;
value = etl::rotl(value, 9);
CHECK_EQUAL(0x796EU, int(value));
value = 0xB73CU;
value = etl::rotl(value, 9);
CHECK_EQUAL(0x796EU, int(value));
value = 0xB73CU;
value = etl::rotl(value, 10);
CHECK_EQUAL(0xF2DCU, int(value));
value = 0xB73CU;
value = etl::rotl(value, 11);
CHECK_EQUAL(0xE5B9U, int(value));
value = 0xB73CU;
value = etl::rotl(value, 12);
CHECK_EQUAL(0xCB73U, int(value));
value = 0xB73CU;
value = etl::rotl(value, 13);
CHECK_EQUAL(0x96E7U, int(value));
value = 0xB73CU;
value = etl::rotl(value, 14);
CHECK_EQUAL(0x2DCFU, int(value));
value = 0xB73CU;
value = etl::rotl(value, 15);
CHECK_EQUAL(0x5B9EU, int(value));
value = 0xB73CU;
value = etl::rotl(value, 16);
CHECK_EQUAL(0xB73CU, int(value));
value = 0xB73CU;
value = etl::rotl(value, 17);
CHECK_EQUAL(0x6E79U, int(value));
value = 0xB73CU;
value = etl::rotl(value, -1);
CHECK_EQUAL(0x5B9EU, int(value));
}
#if !defined(ETL_FORCE_NO_ADVANCED_CPP)
//*************************************************************************
TEST(test_rotl16_constexpr)
{
char temp[etl::rotl(uint16_t(0xAAU), 1)];
CHECK_EQUAL(etl::rotl(uint16_t(0xAAU), 1), sizeof(temp));
}
#endif
//*************************************************************************
TEST(test_rotate_right8)
{
uint8_t value;
value = 0x00U;
value = etl::rotate_right(value);
CHECK_EQUAL(0, int(value));
value = 0x21U;
value = etl::rotate_right(value);
CHECK_EQUAL(0x90U, int(value));
value = 0x42U;
value = etl::rotate_right(value);
CHECK_EQUAL(0x21U, int(value));
value = 0x84U;
value = etl::rotate_right(value);
CHECK_EQUAL(0x42U, int(value));
value = 0xB7U;
value = etl::rotate_right(value, 2);
CHECK_EQUAL(0xEDU, int(value));
value = 0xB7U;
value = etl::rotate_right(value, 3);
CHECK_EQUAL(0xF6U, int(value));
value = 0xB7U;
value = etl::rotate_right(value, 4);
CHECK_EQUAL(0x7BU, int(value));
value = 0xB7U;
value = etl::rotate_right(value, 5);
CHECK_EQUAL(0xBDU, int(value));
value = 0xB7U;
value = etl::rotate_right(value, 6);
CHECK_EQUAL(0xDEU, int(value));
value = 0xB7U;
value = etl::rotate_right(value, 7);
CHECK_EQUAL(0x6FU, int(value));
value = 0xB7U;
value = etl::rotate_right(value, 8);
CHECK_EQUAL(0xB7U, int(value));
value = 0xB7U;
value = etl::rotate_right(value, 9);
CHECK_EQUAL(0xDBU, int(value));
value = 0xB7U;
value = etl::rotate_right(value, -1);
CHECK_EQUAL(0x6FU, int(value));
}
#if !defined(ETL_FORCE_NO_ADVANCED_CPP)
//*************************************************************************
TEST(test_rotate_right8_constexpr)
{
char temp[etl::rotate_right(uint8_t(0xAAU))];
CHECK_EQUAL(etl::rotate_right(uint8_t(0xAAU)), sizeof(temp));
}
#endif
//*************************************************************************
TEST(test_rotate_right16)
{
uint16_t value;
value = 0x0000U;
value = etl::rotate_right(value);
CHECK_EQUAL(0, value);
value = 0x8421U;
value = etl::rotate_right(value);
CHECK_EQUAL(0xC210U, value);
value = 0xC210U;
value = etl::rotate_right(value);
CHECK_EQUAL(0x6108U, value);
value = 0x6108U;
value = etl::rotate_right(value);
CHECK_EQUAL(0x3084U, value);
value = 0xB73CU;
value = etl::rotate_right(value, 2);
CHECK_EQUAL(0x2DCFU, int(value));
value = 0xB73CU;
value = etl::rotate_right(value, 3);
CHECK_EQUAL(0x96E7U, int(value));
value = 0xB73CU;
value = etl::rotate_right(value, 4);
CHECK_EQUAL(0xCB73U, int(value));
value = 0xB73CU;
value = etl::rotate_right(value, 5);
CHECK_EQUAL(0xE5B9U, int(value));
value = 0xB73CU;
value = etl::rotate_right(value, 6);
CHECK_EQUAL(0xF2DCU, int(value));
value = 0xB73CU;
value = etl::rotate_right(value, 7);
CHECK_EQUAL(0x796EU, int(value));
value = 0xB73CU;
value = etl::rotate_right(value, 8);
CHECK_EQUAL(0x3CB7U, int(value));
value = 0xB73CU;
value = etl::rotate_right(value, 9);
CHECK_EQUAL(0x9E5BU, int(value));
value = 0xB73CU;
value = etl::rotate_right(value, 9);
CHECK_EQUAL(0x9E5BU, int(value));
value = 0xB73CU;
value = etl::rotate_right(value, 10);
CHECK_EQUAL(0xCF2DU, int(value));
value = 0xB73CU;
value = etl::rotate_right(value, 11);
CHECK_EQUAL(0xE796U, int(value));
value = 0xB73CU;
value = etl::rotate_right(value, 12);
CHECK_EQUAL(0x73CBU, int(value));
value = 0xB73CU;
value = etl::rotate_right(value, 13);
CHECK_EQUAL(0xB9E5U, int(value));
value = 0xB73CU;
value = etl::rotate_right(value, 14);
CHECK_EQUAL(0xDCF2U, int(value));
value = 0xB73CU;
value = etl::rotate_right(value, 15);
CHECK_EQUAL(0x6E79U, int(value));
value = 0xB73CU;
value = etl::rotate_right(value, 16);
CHECK_EQUAL(0xB73CU, int(value));
value = 0xB73CU;
value = etl::rotate_right(value, 17);
CHECK_EQUAL(0x5B9EU, int(value));
value = 0xB73CU;
value = etl::rotate_right(value, -1);
CHECK_EQUAL(0x6E79U, int(value));
}
#if !defined(ETL_FORCE_NO_ADVANCED_CPP)
//*************************************************************************
TEST(test_rotate_right16_constexpr)
{
char temp[etl::rotate_right(uint16_t(0xAAU))];
CHECK_EQUAL(etl::rotate_right(uint16_t(0xAAU)), sizeof(temp));
}
#endif
//*************************************************************************
TEST(test_rotate16)
{
uint16_t value;
int offset;
offset = 4;
value = 0xB73CU;
value = etl::rotate(value, offset);
CHECK_EQUAL(0x73CBU, int(value));
offset = -4;
value = 0xB73CU;
value = etl::rotate(value, offset);
CHECK_EQUAL(0xCB73U, int(value));
}
#if !defined(ETL_FORCE_NO_ADVANCED_CPP)
//*************************************************************************
TEST(test_rotate16_constexpr)
{
char temp[etl::rotate(uint16_t(0xAAU), 1)];
CHECK_EQUAL(etl::rotate(uint16_t(0xAAU), 1), sizeof(temp));
}
#endif
//*************************************************************************
TEST(test_reverse_bytes16)
{
uint16_t value;
value = 0xFC5AU;
value = etl::byteswap(value);
CHECK_EQUAL(0x5AFCU, value);
value = 0x5AA5U;
value = etl::byteswap(value);
CHECK_EQUAL(0xA55AU, value);
value = 0xA55AU;
value = etl::byteswap(value);
CHECK_EQUAL(0x5AA5U, value);
}
#if !defined(ETL_FORCE_NO_ADVANCED_CPP)
//*************************************************************************
TEST(test_reverse_bytes16_constexpr)
{
char temp[etl::byteswap(uint16_t(0xA500U))];
CHECK_EQUAL(etl::byteswap(uint16_t(0xA500U)), sizeof(temp));
}
#endif
//*************************************************************************
TEST(test_reverse_bytes32)
{
uint32_t value;
value = 0xF0C3A55AUL;
value = etl::byteswap(value);
CHECK_EQUAL(0x5AA5C3F0UL, value);
value = 0xA5A55A5AUL;
value = etl::byteswap(value);
CHECK_EQUAL(0x5A5AA5A5UL, value);
value = 0x5A5AA5A5UL;
value = etl::byteswap(value);
CHECK_EQUAL(0xA5A55A5AUL, value);
}
#if !defined(ETL_FORCE_NO_ADVANCED_CPP)
//*************************************************************************
TEST(test_reverse_bytes32_constexpr)
{
char temp[etl::byteswap(uint32_t(0xA5000000UL))];
CHECK_EQUAL(etl::byteswap(uint32_t(0xA5000000UL)), sizeof(temp));
}
#endif
//*************************************************************************
TEST(test_reverse_bytes64)
{
uint64_t value;
value = 0x0123456789ABCDEFULL;
value = etl::byteswap(value);
CHECK_EQUAL(0xEFCDAB8967452301ULL, value);
value = 0xA5A55A5AA5A55A5AULL;
value = etl::byteswap(value);
CHECK_EQUAL(0x5A5AA5A55A5AA5A5ULL, value);
value = 0x5A5AA5A55A5AA5A5ULL;
value = etl::byteswap(value);
CHECK_EQUAL(0xA5A55A5AA5A55A5AULL, value);
}
#if !defined(ETL_FORCE_NO_ADVANCED_CPP)
//*************************************************************************
TEST(test_reverse_bytes64_constexpr)
{
char temp[etl::byteswap(uint64_t(0xA500000000000000ULL))];
CHECK_EQUAL(etl::byteswap(uint64_t(0xA500000000000000ULL)), sizeof(temp));
}
#endif
//*************************************************************************
TEST(test_count_bits_8)
{
for (size_t i = 1UL; i <= std::numeric_limits<uint8_t>::max(); ++i)
{
CHECK_EQUAL(test_count(i), etl::popcount(uint8_t(i)));
}
}
#if !defined(ETL_FORCE_NO_ADVANCED_CPP)
//*************************************************************************
TEST(test_count_bits_8_constexpr)
{
char temp[etl::popcount(uint8_t(0xFFU))];
CHECK_EQUAL(etl::popcount(uint8_t(0xFFU)), sizeof(temp));
}
#endif
//*************************************************************************
TEST(test_count_bits_16)
{
for (size_t i = 1UL; i <= std::numeric_limits<uint16_t>::max(); ++i)
{
CHECK_EQUAL(test_count(i), etl::popcount(uint16_t(i)));
}
}
#if !defined(ETL_FORCE_NO_ADVANCED_CPP)
//*************************************************************************
TEST(test_count_bits_16_constexpr)
{
char temp[etl::popcount(uint16_t(0xFFU))];
CHECK_EQUAL(etl::popcount(uint16_t(0xFFU)), sizeof(temp));
}
#endif
//*************************************************************************
TEST(test_count_bits_32)
{
etl::fnv_1a_32 hash;
for (size_t i = 0UL; i < 1000000UL; ++i)
{
hash.add(1);
uint32_t value = hash.value();
CHECK_EQUAL(test_count(value), etl::popcount(value));
}
}
#if !defined(ETL_FORCE_NO_ADVANCED_CPP)
//*************************************************************************
TEST(test_count_bits_32_constexpr)
{
char temp[etl::popcount(uint32_t(0xFFU))];
CHECK_EQUAL(etl::popcount(uint32_t(0xFFU)), sizeof(temp));
}
#endif
//*************************************************************************
TEST(test_count_bits_64)
{
etl::fnv_1a_64 hash;
for (size_t i = 0UL; i < 1000000UL; ++i)
{
hash.add(1);
uint64_t value = hash.value();
CHECK_EQUAL(test_count(value), etl::popcount(value));
}
}
#if !defined(ETL_FORCE_NO_ADVANCED_CPP)
//*************************************************************************
TEST(test_count_bits_64_constexpr)
{
char temp[etl::popcount(uint64_t(0xFFU))];
CHECK_EQUAL(etl::popcount(uint64_t(0xFFU)), sizeof(temp));
}
#endif
//*************************************************************************
TEST(test_count_trailing_zeros_8)
{
etl::fnv_1a_32 hash;
for (size_t i = 0; i < 256; ++i)
{
uint8_t value = uint8_t(i);
CHECK_EQUAL(test_trailing_zeros(value), etl::countr_zero(value));
}
}
#if !defined(ETL_FORCE_NO_ADVANCED_CPP)
//*************************************************************************
TEST(test_count_trailing_zeros_8_constexpr)
{
char temp[etl::countr_zero(uint8_t(0x08))];
CHECK_EQUAL(etl::countr_zero(uint8_t(0x08)), sizeof(temp));
}
#endif
//*************************************************************************
TEST(test_count_trailing_zeros_16)
{
for (size_t i = 0; i < 65536; ++i)
{
uint16_t value = uint16_t(i);
CHECK_EQUAL(test_trailing_zeros(value), etl::countr_zero(value));
}
}
#if !defined(ETL_FORCE_NO_ADVANCED_CPP)
//*************************************************************************
TEST(test_count_trailing_zeros_16_constexpr)
{
char temp[etl::countr_zero(uint16_t(0x08))];
CHECK_EQUAL(etl::countr_zero(uint16_t(0x08)), sizeof(temp));
}
#endif
//*************************************************************************
TEST(test_count_trailing_zeros_32)
{
etl::fnv_1a_32 hash;
for (size_t i = 0UL; i < 100000UL; ++i)
{
hash.add(1);
uint32_t value = hash.value();
CHECK_EQUAL(test_trailing_zeros(value), etl::countr_zero(value));
}
}
#if !defined(ETL_FORCE_NO_ADVANCED_CPP)
//*************************************************************************
TEST(test_count_trailing_zeros_32_constexpr)
{
char temp[etl::countr_zero(uint32_t(0x08))];
CHECK_EQUAL(etl::countr_zero(uint32_t(0x08)), sizeof(temp));
}
#endif
//*************************************************************************
TEST(test_count_trailing_zeros_64)
{
etl::fnv_1a_64 hash;
for (size_t i = 0UL; i < 100000UL; ++i)
{
hash.add(1);
uint64_t value = hash.value();
CHECK_EQUAL(test_trailing_zeros(value), etl::countr_zero(value));
}
}
#if !defined(ETL_FORCE_NO_ADVANCED_CPP)
//*************************************************************************
TEST(test_count_trailing_zeros_64_constexpr)
{
char temp[etl::countr_zero(uint64_t(0x08))];
CHECK_EQUAL(etl::countr_zero(uint64_t(0x08)), sizeof(temp));
}
#endif
// //*************************************************************************
// TEST(test_max_value_for_bits)
// {
// // Check that the values are correct.
// //CHECK_EQUAL(0U, etl::max_value_for_nbits<0>::value);
// CHECK_EQUAL(1U, etl::max_value_for_nbits<1>::value);
// CHECK_EQUAL(3U, etl::max_value_for_nbits<2>::value);
// CHECK_EQUAL(7U, etl::max_value_for_nbits<3>::value);
// CHECK_EQUAL(15U, etl::max_value_for_nbits<4>::value);
// CHECK_EQUAL(31U, etl::max_value_for_nbits<5>::value);
// CHECK_EQUAL(63U, etl::max_value_for_nbits<6>::value);
// CHECK_EQUAL(127U, etl::max_value_for_nbits<7>::value);
// CHECK_EQUAL(255U, etl::max_value_for_nbits<8>::value);
// CHECK_EQUAL(511U, etl::max_value_for_nbits<9>::value);
// CHECK_EQUAL(1023U, etl::max_value_for_nbits<10>::value);
// CHECK_EQUAL(2047U, etl::max_value_for_nbits<11>::value);
// CHECK_EQUAL(4095U, etl::max_value_for_nbits<12>::value);
// CHECK_EQUAL(8191U, etl::max_value_for_nbits<13>::value);
// CHECK_EQUAL(16383U, etl::max_value_for_nbits<14>::value);
// CHECK_EQUAL(32767U, etl::max_value_for_nbits<15>::value);
// CHECK_EQUAL(65535U, etl::max_value_for_nbits<16>::value);
// CHECK_EQUAL(131071UL, etl::max_value_for_nbits<17>::value);
// CHECK_EQUAL(262143UL, etl::max_value_for_nbits<18>::value);
// CHECK_EQUAL(524287UL, etl::max_value_for_nbits<19>::value);
// CHECK_EQUAL(1048575UL, etl::max_value_for_nbits<20>::value);
// CHECK_EQUAL(2097151UL, etl::max_value_for_nbits<21>::value);
// CHECK_EQUAL(4194303UL, etl::max_value_for_nbits<22>::value);
// CHECK_EQUAL(8388607UL, etl::max_value_for_nbits<23>::value);
// CHECK_EQUAL(16777215UL, etl::max_value_for_nbits<24>::value);
// CHECK_EQUAL(33554431UL, etl::max_value_for_nbits<25>::value);
// CHECK_EQUAL(67108863UL, etl::max_value_for_nbits<26>::value);
// CHECK_EQUAL(134217727UL, etl::max_value_for_nbits<27>::value);
// CHECK_EQUAL(268435455UL, etl::max_value_for_nbits<28>::value);
// CHECK_EQUAL(536870911UL, etl::max_value_for_nbits<29>::value);
// CHECK_EQUAL(1073741823UL, etl::max_value_for_nbits<30>::value);
// CHECK_EQUAL(2147483647UL, etl::max_value_for_nbits<31>::value);
// CHECK_EQUAL(4294967295UL, etl::max_value_for_nbits<32>::value);
// CHECK_EQUAL(8589934591ULL, etl::max_value_for_nbits<33>::value);
// CHECK_EQUAL(17179869183ULL, etl::max_value_for_nbits<34>::value);
// CHECK_EQUAL(34359738367ULL, etl::max_value_for_nbits<35>::value);
// CHECK_EQUAL(68719476735ULL, etl::max_value_for_nbits<36>::value);
// CHECK_EQUAL(137438953471ULL, etl::max_value_for_nbits<37>::value);
// CHECK_EQUAL(274877906943ULL, etl::max_value_for_nbits<38>::value);
// CHECK_EQUAL(549755813887ULL, etl::max_value_for_nbits<39>::value);
// CHECK_EQUAL(1099511627775ULL, etl::max_value_for_nbits<40>::value);
// CHECK_EQUAL(2199023255551ULL, etl::max_value_for_nbits<41>::value);
// CHECK_EQUAL(4398046511103ULL, etl::max_value_for_nbits<42>::value);
// CHECK_EQUAL(8796093022207ULL, etl::max_value_for_nbits<43>::value);
// CHECK_EQUAL(17592186044415ULL, etl::max_value_for_nbits<44>::value);
// CHECK_EQUAL(35184372088831ULL, etl::max_value_for_nbits<45>::value);
// CHECK_EQUAL(70368744177663ULL, etl::max_value_for_nbits<46>::value);
// CHECK_EQUAL(140737488355327ULL, etl::max_value_for_nbits<47>::value);
// CHECK_EQUAL(281474976710655ULL, etl::max_value_for_nbits<48>::value);
// CHECK_EQUAL(562949953421311ULL, etl::max_value_for_nbits<49>::value);
// CHECK_EQUAL(1125899906842623ULL, etl::max_value_for_nbits<50>::value);
// CHECK_EQUAL(2251799813685247ULL, etl::max_value_for_nbits<51>::value);
// CHECK_EQUAL(4503599627370495ULL, etl::max_value_for_nbits<52>::value);
// CHECK_EQUAL(9007199254740991ULL, etl::max_value_for_nbits<53>::value);
// CHECK_EQUAL(18014398509481983ULL, etl::max_value_for_nbits<54>::value);
// CHECK_EQUAL(36028797018963967ULL, etl::max_value_for_nbits<55>::value);
// CHECK_EQUAL(72057594037927935ULL, etl::max_value_for_nbits<56>::value);
// CHECK_EQUAL(144115188075855871ULL, etl::max_value_for_nbits<57>::value);
// CHECK_EQUAL(288230376151711743ULL, etl::max_value_for_nbits<58>::value);
// CHECK_EQUAL(576460752303423487ULL, etl::max_value_for_nbits<59>::value);
// CHECK_EQUAL(1152921504606846975ULL, etl::max_value_for_nbits<60>::value);
// CHECK_EQUAL(2305843009213693951ULL, etl::max_value_for_nbits<61>::value);
// CHECK_EQUAL(4611686018427387903ULL, etl::max_value_for_nbits<62>::value);
// CHECK_EQUAL(9223372036854775807ULL, etl::max_value_for_nbits<63>::value);
// CHECK_EQUAL(18446744073709551615ULL, etl::max_value_for_nbits<64>::value);
//
// // Check that the value types are correct.
// CHECK((etl::is_same<uint8_t, etl::max_value_for_nbits<0>::value_type>::value));
// CHECK((etl::is_same<uint8_t, etl::max_value_for_nbits<1>::value_type>::value));
// CHECK((etl::is_same<uint8_t, etl::max_value_for_nbits<2>::value_type>::value));
// CHECK((etl::is_same<uint8_t, etl::max_value_for_nbits<3>::value_type>::value));
// CHECK((etl::is_same<uint8_t, etl::max_value_for_nbits<4>::value_type>::value));
// CHECK((etl::is_same<uint8_t, etl::max_value_for_nbits<5>::value_type>::value));
// CHECK((etl::is_same<uint8_t, etl::max_value_for_nbits<6>::value_type>::value));
// CHECK((etl::is_same<uint8_t, etl::max_value_for_nbits<7>::value_type>::value));
// CHECK((etl::is_same<uint8_t, etl::max_value_for_nbits<8>::value_type>::value));
// CHECK((etl::is_same<uint16_t, etl::max_value_for_nbits<9>::value_type>::value));
// CHECK((etl::is_same<uint16_t, etl::max_value_for_nbits<10>::value_type>::value));
// CHECK((etl::is_same<uint16_t, etl::max_value_for_nbits<11>::value_type>::value));
// CHECK((etl::is_same<uint16_t, etl::max_value_for_nbits<12>::value_type>::value));
// CHECK((etl::is_same<uint16_t, etl::max_value_for_nbits<13>::value_type>::value));
// CHECK((etl::is_same<uint16_t, etl::max_value_for_nbits<14>::value_type>::value));
// CHECK((etl::is_same<uint16_t, etl::max_value_for_nbits<15>::value_type>::value));
// CHECK((etl::is_same<uint16_t, etl::max_value_for_nbits<16>::value_type>::value));
// CHECK((etl::is_same<uint32_t, etl::max_value_for_nbits<17>::value_type>::value));
// CHECK((etl::is_same<uint32_t, etl::max_value_for_nbits<18>::value_type>::value));
// CHECK((etl::is_same<uint32_t, etl::max_value_for_nbits<19>::value_type>::value));
// CHECK((etl::is_same<uint32_t, etl::max_value_for_nbits<20>::value_type>::value));
// CHECK((etl::is_same<uint32_t, etl::max_value_for_nbits<21>::value_type>::value));
// CHECK((etl::is_same<uint32_t, etl::max_value_for_nbits<22>::value_type>::value));
// CHECK((etl::is_same<uint32_t, etl::max_value_for_nbits<23>::value_type>::value));
// CHECK((etl::is_same<uint32_t, etl::max_value_for_nbits<24>::value_type>::value));
// CHECK((etl::is_same<uint32_t, etl::max_value_for_nbits<25>::value_type>::value));
// CHECK((etl::is_same<uint32_t, etl::max_value_for_nbits<26>::value_type>::value));
// CHECK((etl::is_same<uint32_t, etl::max_value_for_nbits<27>::value_type>::value));
// CHECK((etl::is_same<uint32_t, etl::max_value_for_nbits<28>::value_type>::value));
// CHECK((etl::is_same<uint32_t, etl::max_value_for_nbits<29>::value_type>::value));
// CHECK((etl::is_same<uint32_t, etl::max_value_for_nbits<30>::value_type>::value));
// CHECK((etl::is_same<uint32_t, etl::max_value_for_nbits<31>::value_type>::value));
// CHECK((etl::is_same<uint32_t, etl::max_value_for_nbits<32>::value_type>::value));
// CHECK((etl::is_same<uint64_t, etl::max_value_for_nbits<33>::value_type>::value));
// CHECK((etl::is_same<uint64_t, etl::max_value_for_nbits<34>::value_type>::value));
// CHECK((etl::is_same<uint64_t, etl::max_value_for_nbits<35>::value_type>::value));
// CHECK((etl::is_same<uint64_t, etl::max_value_for_nbits<36>::value_type>::value));
// CHECK((etl::is_same<uint64_t, etl::max_value_for_nbits<37>::value_type>::value));
// CHECK((etl::is_same<uint64_t, etl::max_value_for_nbits<38>::value_type>::value));
// CHECK((etl::is_same<uint64_t, etl::max_value_for_nbits<39>::value_type>::value));
// CHECK((etl::is_same<uint64_t, etl::max_value_for_nbits<40>::value_type>::value));
// CHECK((etl::is_same<uint64_t, etl::max_value_for_nbits<41>::value_type>::value));
// CHECK((etl::is_same<uint64_t, etl::max_value_for_nbits<42>::value_type>::value));
// CHECK((etl::is_same<uint64_t, etl::max_value_for_nbits<43>::value_type>::value));
// CHECK((etl::is_same<uint64_t, etl::max_value_for_nbits<44>::value_type>::value));
// CHECK((etl::is_same<uint64_t, etl::max_value_for_nbits<45>::value_type>::value));
// CHECK((etl::is_same<uint64_t, etl::max_value_for_nbits<46>::value_type>::value));
// CHECK((etl::is_same<uint64_t, etl::max_value_for_nbits<47>::value_type>::value));
// CHECK((etl::is_same<uint64_t, etl::max_value_for_nbits<48>::value_type>::value));
// CHECK((etl::is_same<uint64_t, etl::max_value_for_nbits<49>::value_type>::value));
// CHECK((etl::is_same<uint64_t, etl::max_value_for_nbits<50>::value_type>::value));
// CHECK((etl::is_same<uint64_t, etl::max_value_for_nbits<51>::value_type>::value));
// CHECK((etl::is_same<uint64_t, etl::max_value_for_nbits<52>::value_type>::value));
// CHECK((etl::is_same<uint64_t, etl::max_value_for_nbits<53>::value_type>::value));
// CHECK((etl::is_same<uint64_t, etl::max_value_for_nbits<54>::value_type>::value));
// CHECK((etl::is_same<uint64_t, etl::max_value_for_nbits<55>::value_type>::value));
// CHECK((etl::is_same<uint64_t, etl::max_value_for_nbits<56>::value_type>::value));
// CHECK((etl::is_same<uint64_t, etl::max_value_for_nbits<57>::value_type>::value));
// CHECK((etl::is_same<uint64_t, etl::max_value_for_nbits<58>::value_type>::value));
// CHECK((etl::is_same<uint64_t, etl::max_value_for_nbits<59>::value_type>::value));
// CHECK((etl::is_same<uint64_t, etl::max_value_for_nbits<60>::value_type>::value));
// CHECK((etl::is_same<uint64_t, etl::max_value_for_nbits<61>::value_type>::value));
// CHECK((etl::is_same<uint64_t, etl::max_value_for_nbits<62>::value_type>::value));
// CHECK((etl::is_same<uint64_t, etl::max_value_for_nbits<63>::value_type>::value));
// CHECK((etl::is_same<uint64_t, etl::max_value_for_nbits<64>::value_type>::value));
// }
};
}
Reference in New Issue View Git Blame Copy Permalink