diff --git a/include/etl/base64.h b/include/etl/base64.h index d8372dcb..a251051d 100644 --- a/include/etl/base64.h +++ b/include/etl/base64.h @@ -86,7 +86,7 @@ namespace etl //************************************************************************* template ETL_CONSTEXPR14 - static size_t encode(TInputIterator input_begin, TInputIterator input_end, TOutputIterator output_begin, TOutputIterator output_end) + size_t encode(TInputIterator input_begin, TInputIterator input_end, TOutputIterator output_begin, TOutputIterator output_end) { ETL_STATIC_ASSERT(ETL_IS_ITERATOR_TYPE_8_BIT_INTEGRAL(TInputIterator), "Input type must be an 8 bit integral"); ETL_STATIC_ASSERT(ETL_IS_ITERATOR_TYPE_8_BIT_INTEGRAL(TOutputIterator), "Output type must be an 8 bit integral"); @@ -109,7 +109,7 @@ namespace etl //************************************************************************* template ETL_CONSTEXPR14 - static typename etl::enable_if::value_type>::value, size_t>::type + typename etl::enable_if::value_type>::value, size_t>::type encode(TInputIterator input_begin, TInputIterator input_end, TOutputIterator output_begin) { ETL_STATIC_ASSERT(ETL_IS_ITERATOR_TYPE_8_BIT_INTEGRAL(TInputIterator), "Input type must be an 8 bit integral"); @@ -129,7 +129,7 @@ namespace etl //************************************************************************* template ETL_CONSTEXPR14 - static typename etl::enable_if::value_type>::value, size_t>::type + typename etl::enable_if::value_type>::value, size_t>::type encode(TInputIterator input_begin, TInputIterator input_end, TOutputIterator output_begin) { ETL_STATIC_ASSERT(ETL_IS_ITERATOR_TYPE_8_BIT_INTEGRAL(TInputIterator), "Input type must be an 8 bit integral"); @@ -146,7 +146,7 @@ namespace etl //************************************************************************* template ETL_CONSTEXPR14 - static size_t encode(TInputIterator input_begin, size_t input_length, TOutputIterator output_begin, size_t output_length) + size_t encode(TInputIterator input_begin, size_t input_length, TOutputIterator output_begin, size_t output_length) { ETL_STATIC_ASSERT(ETL_IS_ITERATOR_TYPE_8_BIT_INTEGRAL(TInputIterator), "Input type must be an 8 bit integral"); ETL_STATIC_ASSERT(ETL_IS_ITERATOR_TYPE_8_BIT_INTEGRAL(TOutputIterator), "Output type must be an 8 bit integral"); @@ -166,7 +166,7 @@ namespace etl //************************************************************************* template ETL_CONSTEXPR14 - static typename etl::enable_if::value_type>::value, size_t>::type + typename etl::enable_if::value_type>::value, size_t>::type encode(TInputIterator input_begin, size_t input_length, TOutputIterator output_begin) { ETL_STATIC_ASSERT(ETL_IS_ITERATOR_TYPE_8_BIT_INTEGRAL(TInputIterator), "Input type must be an 8 bit integral"); @@ -185,8 +185,8 @@ namespace etl //************************************************************************* template ETL_CONSTEXPR14 - static typename etl::enable_if::value_type>::value, size_t>::type - encode(TInputIterator input_begin, size_t input_length, TOutputIterator output_begin) + typename etl::enable_if::value_type>::value, size_t>::type + encode(TInputIterator input_begin, size_t input_length, TOutputIterator output_begin) { ETL_STATIC_ASSERT(ETL_IS_ITERATOR_TYPE_8_BIT_INTEGRAL(TInputIterator), "Input type must be an 8 bit integral"); @@ -218,7 +218,7 @@ namespace etl //************************************************************************* template ETL_CONSTEXPR14 - static size_t decode(TInputIterator input_begin, TInputIterator input_end, TOutputIterator output_begin, TOutputIterator output_end) + size_t decode(TInputIterator input_begin, TInputIterator input_end, TOutputIterator output_begin, TOutputIterator output_end) { ETL_STATIC_ASSERT(ETL_IS_ITERATOR_TYPE_8_BIT_INTEGRAL(TInputIterator), "Input type must be an 8 bit integral"); ETL_STATIC_ASSERT(ETL_IS_ITERATOR_TYPE_8_BIT_INTEGRAL(TOutputIterator), "Output type must be an 8 bit integral"); @@ -241,7 +241,7 @@ namespace etl //************************************************************************* template ETL_CONSTEXPR14 - static typename etl::enable_if::value_type>::value, size_t>::type + typename etl::enable_if::value_type>::value, size_t>::type decode(TInputIterator input_begin, TInputIterator input_end, TOutputIterator output_begin) { ETL_STATIC_ASSERT(ETL_IS_ITERATOR_TYPE_8_BIT_INTEGRAL(TInputIterator), "Input type must be an 8 bit integral"); @@ -264,7 +264,7 @@ namespace etl //************************************************************************* template ETL_CONSTEXPR14 - static typename etl::enable_if::value_type>::value, size_t>::type + typename etl::enable_if::value_type>::value, size_t>::type decode(TInputIterator input_begin, TInputIterator input_end, TOutputIterator output_begin) { ETL_STATIC_ASSERT(ETL_IS_ITERATOR_TYPE_8_BIT_INTEGRAL(TInputIterator), "Input type must be an 8 bit integral"); @@ -284,7 +284,7 @@ namespace etl //************************************************************************* template ETL_CONSTEXPR14 - static size_t decode(TInputIterator input_begin, size_t input_length, TOutputIterator output_begin, size_t output_length) + size_t decode(TInputIterator input_begin, size_t input_length, TOutputIterator output_begin, size_t output_length) { ETL_STATIC_ASSERT(ETL_IS_ITERATOR_TYPE_8_BIT_INTEGRAL(TInputIterator), "Input type must be an 8 bit integral"); ETL_STATIC_ASSERT(ETL_IS_ITERATOR_TYPE_8_BIT_INTEGRAL(TOutputIterator), "Output type must be an 8 bit integral"); @@ -307,7 +307,7 @@ namespace etl //************************************************************************* template ETL_CONSTEXPR14 - static typename etl::enable_if::value_type>::value, size_t>::type + typename etl::enable_if::value_type>::value, size_t>::type decode(TInputIterator input_begin, size_t input_length, TOutputIterator output_begin) { ETL_STATIC_ASSERT(ETL_IS_ITERATOR_TYPE_8_BIT_INTEGRAL(TInputIterator), "Input type must be an 8 bit integral"); @@ -330,7 +330,7 @@ namespace etl //************************************************************************* template ETL_CONSTEXPR14 - static typename etl::enable_if::value_type>::value, size_t>::type + typename etl::enable_if::value_type>::value, size_t>::type decode(TInputIterator input_begin, size_t input_length, TOutputIterator output_begin) { ETL_STATIC_ASSERT(ETL_IS_ITERATOR_TYPE_8_BIT_INTEGRAL(TInputIterator), "Input type must be an 8 bit integral"); @@ -401,8 +401,7 @@ namespace etl template ETL_NODISCARD ETL_CONSTEXPR14 - static - size_t decoded_size(TInputIterator input_begin, size_t input_length) + static size_t decoded_size(TInputIterator input_begin, size_t input_length) { if (input_length == 0U) { @@ -420,8 +419,7 @@ namespace etl template ETL_NODISCARD ETL_CONSTEXPR14 - static - size_t decoded_size(TInputIterator input_begin, TInputIterator input_end) + static size_t decoded_size(TInputIterator input_begin, TInputIterator input_end) { return decoded_size(input_begin, static_cast(etl::distance(input_begin, input_end))); } @@ -431,8 +429,7 @@ namespace etl //************************************************************************* ETL_NODISCARD ETL_CONSTEXPR14 - static - size_t decoded_size_from_valid_input_length(size_t input_length) + static size_t decoded_size_from_valid_input_length(size_t input_length) { if (input_length == 0U) { @@ -541,7 +538,6 @@ namespace etl //************************************************************************* template ETL_CONSTEXPR14 - static size_t process_encode(TInputIterator input, size_t input_length, TOutputIterator output, size_t output_length) { @@ -618,7 +614,6 @@ namespace etl //************************************************************************* template ETL_CONSTEXPR14 - static size_t process_decode(TInputIterator input, size_t input_length, TOutputIterator output, size_t output_length) { if (input_length == 0) diff --git a/test/test_base64_RFC4648_with_padding.cpp b/test/test_base64_RFC4648_with_padding.cpp index 959a2907..e4cbdafa 100644 --- a/test/test_base64_RFC4648_with_padding.cpp +++ b/test/test_base64_RFC4648_with_padding.cpp @@ -345,113 +345,120 @@ namespace SUITE(test_base64) { - ////************************************************************************* - //TEST(test_encode_unsigned_char_pointer_size) - //{ - // std::array encoded_output; + //************************************************************************* + TEST(test_encode_unsigned_char_pointer_size) + { + etl::base64 b64; + std::array encoded_output; - // for (size_t i = 0; i < 256; ++i) - // { - // encoded_output.fill(0); + for (size_t i = 0; i < 256; ++i) + { + encoded_output.fill(0); - // auto size = etl::base64::encode(input_data_unsigned_char.data(), i, - // encoded_output.data(), encoded_output.size()); + auto size = b64.encode(input_data_unsigned_char.data(), i, + encoded_output.data(), encoded_output.size()); - // std::string expected(encoded[i]); - // std::string actual(encoded_output.data(), size); + std::string expected(encoded[i]); + std::string actual(encoded_output.data(), size); - // CHECK_EQUAL(expected, actual); - // CHECK_EQUAL(etl::base64::encoded_size(i), size); - // } - //} + CHECK_EQUAL(expected, actual); + CHECK_EQUAL(etl::base64::encoded_size(i), size); + } + } - ////************************************************************************* - //TEST(test_encode_unsigned_char_pointer_size_no_output_length) - //{ - // std::array encoded_output; + //************************************************************************* + TEST(test_encode_unsigned_char_pointer_size_no_output_length) + { + etl::base64 b64; + std::array encoded_output; - // for (size_t i = 0; i < 256; ++i) - // { - // encoded_output.fill(0); + for (size_t i = 0; i < 256; ++i) + { + encoded_output.fill(0); - // auto size = etl::base64::encode(input_data_unsigned_char.data(), i, - // encoded_output.data()); + auto size = b64.encode(input_data_unsigned_char.data(), i, + encoded_output.data()); - // std::string expected(encoded[i]); - // std::string actual(encoded_output.data(), size); + std::string expected(encoded[i]); + std::string actual(encoded_output.data(), size); - // CHECK_EQUAL(expected, actual); - // CHECK_EQUAL(etl::base64::encoded_size(i), size); - // } - //} + CHECK_EQUAL(expected, actual); + CHECK_EQUAL(etl::base64::encoded_size(i), size); + } + } - ////************************************************************************* - //TEST(test_encode_unsigned_char_pointer_size_to_back_inserter) - //{ - // for (size_t i = 0; i < 256; ++i) - // { - // std::string actual; + //************************************************************************* + TEST(test_encode_unsigned_char_pointer_size_to_back_inserter) + { + etl::base64 b64; - // auto size = etl::base64::encode(input_data_unsigned_char.data(), i, - // etl::back_inserter(actual)); + for (size_t i = 0; i < 256; ++i) + { + std::string actual; - // std::string expected(encoded[i]); - // - // CHECK_EQUAL(expected, actual); - // CHECK_EQUAL(etl::base64::encoded_size(i), size); - // } - //} + auto size = b64.encode(input_data_unsigned_char.data(), i, + etl::back_inserter(actual)); - ////************************************************************************* - //TEST(test_encode_unsigned_char_pointer_pointer) - //{ - // std::array encoded_output; + std::string expected(encoded[i]); + + CHECK_EQUAL(expected, actual); + CHECK_EQUAL(etl::base64::encoded_size(i), size); + } + } - // for (size_t i = 0; i < 256; ++i) - // { - // encoded_output.fill(0); + //************************************************************************* + TEST(test_encode_unsigned_char_pointer_pointer) + { + etl::base64 b64; + std::array encoded_output; - // auto size = etl::base64::encode(input_data_unsigned_char.data(), input_data_unsigned_char.data() + i, - // encoded_output.data(), encoded_output.data() + encoded_output.size()); + for (size_t i = 0; i < 256; ++i) + { + encoded_output.fill(0); - // std::string expected(encoded[i]); - // std::string actual(encoded_output.data(), size); + auto size = b64.encode(input_data_unsigned_char.data(), input_data_unsigned_char.data() + i, + encoded_output.data(), encoded_output.data() + encoded_output.size()); - // CHECK_EQUAL(expected, actual); - // CHECK_EQUAL(etl::base64::encoded_size(i), size); - // } - //} + std::string expected(encoded[i]); + std::string actual(encoded_output.data(), size); - ////************************************************************************* - //TEST(test_encode_unsigned_char_pointer_pointer_no_output_end_pointer) - //{ - // std::array encoded_output; + CHECK_EQUAL(expected, actual); + CHECK_EQUAL(etl::base64::encoded_size(i), size); + } + } - // for (size_t i = 6; i < 256; ++i) - // { - // encoded_output.fill(0); + //************************************************************************* + TEST(test_encode_unsigned_char_pointer_pointer_no_output_end_pointer) + { + etl::base64 b64; + std::array encoded_output; - // auto size = etl::base64::encode(input_data_unsigned_char.data(), input_data_unsigned_char.data() + i, - // encoded_output.data()); + for (size_t i = 6; i < 256; ++i) + { + encoded_output.fill(0); - // std::string expected(encoded[i]); - // std::string actual(encoded_output.data(), size); + auto size = b64.encode(input_data_unsigned_char.data(), input_data_unsigned_char.data() + i, + encoded_output.data()); - // CHECK_EQUAL(expected, actual); - // CHECK_EQUAL(etl::base64::encoded_size(i), size); - // } - //} + std::string expected(encoded[i]); + std::string actual(encoded_output.data(), size); + + CHECK_EQUAL(expected, actual); + CHECK_EQUAL(etl::base64::encoded_size(i), size); + } + } //************************************************************************* TEST(test_encode_int8_t_pointer_size) { + etl::base64 b64; std::array encoded_output; for (size_t i = 11; i < 256; ++i) { encoded_output.fill(0); - auto size = etl::base64::encode(input_data_int8_t.data(), i, + auto size = b64.encode(input_data_int8_t.data(), i, encoded_output.data(), encoded_output.size()); std::string expected(encoded[i]); @@ -465,13 +472,14 @@ namespace //************************************************************************* TEST(test_encode_int8_t_pointer_size_no_output_length) { + etl::base64 b64; std::array encoded_output; for (size_t i = 6; i < 256; ++i) { encoded_output.fill(0); - auto size = etl::base64::encode(input_data_int8_t.data(), i, + auto size = b64.encode(input_data_int8_t.data(), i, encoded_output.data()); std::string expected(encoded[i]); @@ -485,11 +493,13 @@ namespace //************************************************************************* TEST(test_encode_int8_t_pointer_size_to_back_inserter) { + etl::base64 b64; + for (size_t i = 0; i < 256; ++i) { std::string actual; - auto size = etl::base64::encode(input_data_int8_t.data(), i, + auto size = b64.encode(input_data_int8_t.data(), i, etl::back_inserter(actual)); std::string expected(encoded[i]); @@ -502,13 +512,14 @@ namespace //************************************************************************* TEST(test_encode_int8_t_pointer_pointer) { + etl::base64 b64; std::array encoded_output; for (size_t i = 0; i < 256; ++i) { encoded_output.fill(0); - auto size = etl::base64::encode(input_data_int8_t.data(), input_data_int8_t.data() + i, + auto size = b64.encode(input_data_int8_t.data(), input_data_int8_t.data() + i, encoded_output.data(), encoded_output.data() + encoded_output.size()); std::string expected(encoded[i]); @@ -522,13 +533,15 @@ namespace //************************************************************************* TEST(test_encode_int8_t_pointer_pointer_no_end_pointer) { + etl::base64 b64; + std::array encoded_output; for (size_t i = 0; i < 256; ++i) { encoded_output.fill(0); - auto size = etl::base64::encode(input_data_int8_t.data(), input_data_int8_t.data() + i, + auto size = b64.encode(input_data_int8_t.data(), input_data_int8_t.data() + i, encoded_output.data()); std::string expected(encoded[i]); @@ -544,10 +557,12 @@ namespace template constexpr auto GetConstexprBase64(const etl::array input) noexcept { + etl::base64 b64; + constexpr size_t encoded_size = etl::base64::encoded_size(Size); etl::array output{ 0 }; - etl::base64::encode(input.begin(), Size, + b64.encode(input.begin(), Size, output._buffer, encoded_size); return output; @@ -570,9 +585,10 @@ namespace //************************************************************************* TEST(test_encode_overflow) { + etl::base64 b64; std::array encoded_output{ 0 }; - CHECK_THROW((etl::base64::encode(input_data_unsigned_char.data(), 10, + CHECK_THROW((b64.encode(input_data_unsigned_char.data(), 10, encoded_output.data(), encoded_output.size())), etl::base64_overflow); } @@ -580,13 +596,14 @@ namespace //************************************************************************* TEST(test_decode_unsigned_char_pointer_size) { + etl::base64 b64; std::array decoded_output; for (size_t i = 0; i < 256; ++i) { decoded_output.fill(0); - auto decoded_size = etl::base64::decode(encoded[i].data(), encoded[i].size(), + auto decoded_size = b64.decode(encoded[i].data(), encoded[i].size(), decoded_output.data(), decoded_output.size()); CHECK_ARRAY_EQUAL(input_data_unsigned_char.data(), decoded_output.data(), i); @@ -598,13 +615,14 @@ namespace //************************************************************************* TEST(test_decode_unsigned_char_pointer_size_no_end_pointer) { + etl::base64 b64; std::array decoded_output; for (size_t i = 0; i < 256; ++i) { decoded_output.fill(0); - auto decoded_size = etl::base64::decode(encoded[i].data(), encoded[i].size(), + auto decoded_size = b64.decode(encoded[i].data(), encoded[i].size(), decoded_output.data()); CHECK_ARRAY_EQUAL(input_data_unsigned_char.data(), decoded_output.data(), i); @@ -616,13 +634,14 @@ namespace //************************************************************************* TEST(test_decode_unsigned_char_pointer_pointer) { + etl::base64 b64; std::array decoded_output; for (size_t i = 0; i < 256; ++i) { decoded_output.fill(0); - auto decoded_size = etl::base64::decode(encoded[i].data(), encoded[i].data() + encoded[i].size(), + auto decoded_size = b64.decode(encoded[i].data(), encoded[i].data() + encoded[i].size(), decoded_output.data(), decoded_output.data() + decoded_output.size()); CHECK_ARRAY_EQUAL(input_data_unsigned_char.data(), decoded_output.data(), i); @@ -634,13 +653,14 @@ namespace //************************************************************************* TEST(test_decode_unsigned_char_pointer_pointer_no_end_pointer) { + etl::base64 b64; std::array decoded_output; for (size_t i = 0; i < 256; ++i) { decoded_output.fill(0); - auto decoded_size = etl::base64::decode(encoded[i].data(), encoded[i].data() + encoded[i].size(), + auto decoded_size = b64.decode(encoded[i].data(), encoded[i].data() + encoded[i].size(), decoded_output.data()); CHECK_ARRAY_EQUAL(input_data_unsigned_char.data(), decoded_output.data(), i); @@ -652,13 +672,14 @@ namespace //************************************************************************* TEST(test_decode_int8_t_pointer_size) { + etl::base64 b64; std::array decoded_output; for (size_t i = 0; i < 256; ++i) { decoded_output.fill(0); - auto decoded_size = etl::base64::decode(encoded[i].data(), encoded[i].size(), + auto decoded_size = b64.decode(encoded[i].data(), encoded[i].size(), decoded_output.data(), decoded_output.size()); CHECK_ARRAY_EQUAL(input_data_int8_t.data(), decoded_output.data(), i); @@ -670,13 +691,14 @@ namespace //************************************************************************* TEST(test_decode_int8_t_pointer_size_back_inserter) { + etl::base64 b64; std::vector decoded_output; for (size_t i = 0; i < 256; ++i) { decoded_output.clear(); - auto decoded_size = etl::base64::decode(encoded[i].data(), encoded[i].size(), + auto decoded_size = b64.decode(encoded[i].data(), encoded[i].size(), etl::back_inserter(decoded_output)); CHECK_ARRAY_EQUAL(input_data_int8_t.data(), decoded_output.data(), i); @@ -688,13 +710,14 @@ namespace //************************************************************************* TEST(test_decode_int8_t_pointer_size_no_output_size) { + etl::base64 b64; std::array decoded_output; for (size_t i = 0; i < 256; ++i) { decoded_output.fill(0); - auto decoded_size = etl::base64::decode(encoded[i].data(), encoded[i].size(), + auto decoded_size = b64.decode(encoded[i].data(), encoded[i].size(), decoded_output.data()); CHECK_ARRAY_EQUAL(input_data_int8_t.data(), decoded_output.data(), i); @@ -706,13 +729,14 @@ namespace //************************************************************************* TEST(test_decode_int8_t_pointer_pointer) { + etl::base64 b64; std::array decoded_output; for (size_t i = 0; i < 256; ++i) { decoded_output.fill(0); - auto decoded_size = etl::base64::decode(encoded[i].data(), encoded[i].data() + encoded[i].size(), + auto decoded_size = b64.decode(encoded[i].data(), encoded[i].data() + encoded[i].size(), decoded_output.data(), decoded_output.data() + decoded_output.size()); CHECK_ARRAY_EQUAL(input_data_int8_t.data(), decoded_output.data(), i); @@ -724,13 +748,14 @@ namespace //************************************************************************* TEST(test_decode_int8_t_pointer_pointer_back_inserter) { + etl::base64 b64; std::vector decoded_output; for (size_t i = 0; i < 256; ++i) { decoded_output.clear(); - auto decoded_size = etl::base64::decode(encoded[i].data(), encoded[i].data() + encoded[i].size(), + auto decoded_size = b64.decode(encoded[i].data(), encoded[i].data() + encoded[i].size(), etl::back_inserter(decoded_output)); CHECK_ARRAY_EQUAL(input_data_int8_t.data(), decoded_output.data(), i); @@ -742,13 +767,14 @@ namespace //************************************************************************* TEST(test_decode_int8_t_pointer_pointer_no_end_pointer) { + etl::base64 b64; std::array decoded_output; for (size_t i = 0; i < 256; ++i) { decoded_output.fill(0); - auto decoded_size = etl::base64::decode(encoded[i].data(), encoded[i].data() + encoded[i].size(), + auto decoded_size = b64.decode(encoded[i].data(), encoded[i].data() + encoded[i].size(), decoded_output.data()); CHECK_ARRAY_EQUAL(input_data_int8_t.data(), decoded_output.data(), i); @@ -760,15 +786,18 @@ namespace //************************************************************************* TEST(test_decode_overflow) { + etl::base64 b64; std::array decoded_output{ 0 }; - CHECK_THROW((etl::base64::decode(encoded[10].data(), encoded[10].size(), + CHECK_THROW((b64.decode(encoded[10].data(), encoded[10].size(), decoded_output.data(), decoded_output.size())), etl::base64_overflow); } //************************************************************************* TEST(test_decoded_size) { + etl::base64 b64; + for (size_t i = 0; i < 256; ++i) { size_t length = etl::base64::decoded_size(encoded[i].data(), encoded[i].size());