void test_block_codec()
{
std::vector<size_t> sizes = {1, 16, BlockCodec::block_size - 1, BlockCodec::block_size};
for(size_t mag=1;mag<25;mag++) {
for (auto size: sizes) {
std::vector<uint32_t> values(size);
std::mt19937 gen(12345);
std::uniform_int_distribution<uint32_t> dis(0, (1<<mag));
std::generate(values.begin(), values.end(), [&]() { return dis(gen); });
for (size_t tcase = 0; tcase < 2; ++tcase) {
// test both undefined and given sum_of_values
uint32_t sum_of_values(-1);
if (tcase == 1) {
sum_of_values = std::accumulate(values.begin(), values.end(), 0);
}
std::vector<uint8_t> encoded;
BlockCodec::encode(values.data(), sum_of_values, values.size(), encoded);
std::vector<uint32_t> decoded(values.size() + BlockCodec::overflow);
uint8_t const* out = BlockCodec::decode(encoded.data(), decoded.data(),
sum_of_values, values.size());
BOOST_REQUIRE_EQUAL(encoded.size(), out - encoded.data());
BOOST_REQUIRE_EQUAL_COLLECTIONS(values.begin(), values.end(),
decoded.begin(), decoded.begin()+ values.size());
}
}
}
}
BOOST_FIXTURE_TEST_CASE( utf8to16, utf16conv_fixture )
{
std::u16string str;
lib::utf8to16( enc_u8_beg, enc_u8_end, std::back_inserter( str ) );
BOOST_REQUIRE_EQUAL_COLLECTIONS( str.cbegin( ), str.cend( ), enc_u16_beg, enc_u16_end );
it_u16 = lib::utf8to16( enc_u8_beg, enc_u8_end, str.begin( ) );
BOOST_CHECK( it_u16 == str.end( ) );
}
BOOST_FIXTURE_TEST_CASE( utf8to32, utf32conv_fixture )
{
std::u32string str;
lib::utf8to32( enc_u8_beg, enc_u8_end, std::back_inserter( str ) );
BOOST_REQUIRE_EQUAL_COLLECTIONS( str.cbegin( ), str.cend( ), dec_beg, dec_end );
// check returned iterator validity
it_u32 = lib::utf8to32( enc_u8_beg, enc_u8_end, str.begin( ) );
BOOST_CHECK( it_u32 == str.end( ) );
}
bluetoe::details::attribute_access_result read_characteristic_impl(
const std::initializer_list< std::uint8_t >& input,
const bluetoe::details::attribute& value_attribute,
std::size_t offset = 0,
std::size_t buffer_size = 100 )
{
const std::vector< std::uint8_t > values( input );
std::uint8_t buffer[ 1000 ];
auto read = bluetoe::details::attribute_access_arguments::read( &buffer[ 0 ], &buffer[ buffer_size ], offset, this->client_configurations(), nullptr );
auto result = value_attribute.access( read, 1 );
BOOST_REQUIRE_EQUAL_COLLECTIONS( values.begin(), values.end(), &read.buffer[ 0 ], &read.buffer[ read.buffer_size ] );
return result;
}
BOOST_FIXTURE_TEST_CASE( append, append_fixture )
{
it_u8 = enc_u8_beg;
for (char32_t cp : dec)
{
std::string res;
std::string::const_iterator it2_u8 = it_u8;
BOOST_TEST_CHECKPOINT( "cp=U+" << std::hex << (uint32_t)cp );
utf8::unchecked::advance( it_u8, 1 );
lib::append( cp, std::back_inserter( res ) );
BOOST_REQUIRE_EQUAL_COLLECTIONS( res.cbegin( ), res.cend( ), it2_u8, it_u8 );
it2_u8 = lib::append( cp, res.begin( ) );
BOOST_REQUIRE( it2_u8 == res.cend( ) );
}
}
static void AssertValueHasPrimeFactors(int value, int const *expected, int numExpected)
{
std::list<int> result = PrimeFactors::Generate(value);
BOOST_REQUIRE_EQUAL_COLLECTIONS(&expected[0], &expected[numExpected], result.begin(), result.end());
}
static void AssertValueHasPrimeFactors(int value, const std::initializer_list<int> &expected)
{
std::list<int> result = PrimeFactors::Generate(value);
BOOST_REQUIRE_EQUAL_COLLECTIONS(expected.begin(), expected.end(),
result.cbegin(), result.cend());
}
