From f9233f99aba50787c19103e4bb24cc61811efad1 Mon Sep 17 00:00:00 2001 From: John Wellbelove Date: Sat, 21 Oct 2023 20:29:08 +0100 Subject: [PATCH] Refactor to support multiple RFCs --- include/etl/base64.h | 208 ++++++++++++---------- test/test_base64_RFC4648_with_padding.cpp | 100 +++++------ 2 files changed, 161 insertions(+), 147 deletions(-) diff --git a/include/etl/base64.h b/include/etl/base64.h index 76a8396a..c34847c1 100644 --- a/include/etl/base64.h +++ b/include/etl/base64.h @@ -101,7 +101,7 @@ namespace etl //************************************************************************* /// Codec for Base64 (RFC 4648) //************************************************************************* - class base64 + class ibase64 { public: @@ -118,8 +118,12 @@ namespace etl }; ETL_DECLARE_ENUM_TYPE(Encoding, int) - ETL_ENUM_TYPE(RFC_1421, "RFC 1421") - ETL_ENUM_TYPE(RFC_2045, "RFC 2045") + ETL_ENUM_TYPE(RFC_1421, "RFC_1421") + ETL_ENUM_TYPE(RFC_2045, "RFC_2045") + ETL_ENUM_TYPE(RFC_2152, "RFC_2152") + ETL_ENUM_TYPE(RFC_3501, "RFC_3501") + ETL_ENUM_TYPE(RFC_4648, "RFC_4648") + ETL_ENUM_TYPE(RFC_4648_URL, "RFC_4648_URL") ETL_END_ENUM_TYPE }; @@ -132,82 +136,11 @@ namespace etl }; ETL_DECLARE_ENUM_TYPE(Padding, bool) - ETL_ENUM_TYPE(Use_Padding, "Use padding") - ETL_ENUM_TYPE(No_Padding, "No padding") + ETL_ENUM_TYPE(Use_Padding, "Use_Padding") + ETL_ENUM_TYPE(No_Padding, "No_Padding") ETL_END_ENUM_TYPE }; - //************************************************************************* - /// Default constructor - //************************************************************************* - ETL_CONSTEXPR14 - base64() - : encoding(Encoding::RFC_4648) - , use_padding(true) - , max_line_length(etl::integral_limits::max) - { - } - - //************************************************************************* - /// Constructor - //************************************************************************* - ETL_CONSTEXPR14 - base64(Encoding encoding_, bool use_padding_ = etl::base64::Padding::Use_Padding) - : encoding(Encoding::RFC_4648) - , use_padding(false) - , max_line_length(0) - { - switch (encoding) - { - case Encoding::RFC_1421: - { - use_padding = true; - max_line_length = 64; - break; - } - - case Encoding::RFC_2045: - { - use_padding = true; - max_line_length = 76; - break; - } - - case Encoding::RFC_2152: - { - use_padding = false; - max_line_length = etl::integral_limits::max; - break; - } - - case Encoding::RFC_3501: - { - use_padding = false; - max_line_length = etl::integral_limits::max; - break; - } - - case Encoding::RFC_4648: - { - use_padding = use_padding_; - max_line_length = etl::integral_limits::max; - break; - } - - case Encoding::RFC_4648_URL: - { - use_padding = use_padding_; - max_line_length = etl::integral_limits::max; - break; - } - - default: - { - break; - } - } - } - //************************************************************************* /// Get the encoding standard //************************************************************************* @@ -259,7 +192,7 @@ namespace etl const size_t output_length = static_cast(etl::distance(output_begin, output_end)); // Figure out if the output buffer is large enough. - size_t required_output_length = etl::base64::encoded_size(input_length); + size_t required_output_length = encoded_size(input_length); ETL_ASSERT_OR_RETURN_VALUE(output_length >= required_output_length, ETL_ERROR(base64_overflow), 0U); return process_encode(input_begin, input_length, output_begin, required_output_length); @@ -316,7 +249,7 @@ namespace etl ETL_STATIC_ASSERT(ETL_IS_ITERATOR_TYPE_8_BIT_INTEGRAL(TOutputIterator), "Output type must be an 8 bit integral"); // Figure out if the output buffer is large enough. - size_t required_output_length = etl::base64::encoded_size(input_length); + size_t required_output_length = encoded_size(input_length); ETL_ASSERT_OR_RETURN_VALUE(output_length >= required_output_length, ETL_ERROR(base64_overflow), 0U); return process_encode(input_begin, input_length, output_begin, required_output_length); @@ -391,7 +324,7 @@ namespace etl const size_t output_length = static_cast(etl::distance(output_begin, output_end)); // Figure out if the output buffer is large enough. - size_t required_output_length = etl::base64::decoded_size_from_valid_input_length(input_length); + size_t required_output_length = decoded_size_from_valid_input_length(input_length); ETL_ASSERT_OR_RETURN_VALUE(output_length >= required_output_length, ETL_ERROR(base64_overflow), 0U); return process_decode(input_begin, input_length, output_begin, required_output_length); @@ -457,7 +390,7 @@ namespace etl input_length = valid_input_length(input_begin, input_length); // Figure out if the output buffer is large enough. - size_t required_output_length = etl::base64::decoded_size_from_valid_input_length(input_length); + size_t required_output_length = decoded_size_from_valid_input_length(input_length); ETL_ASSERT_OR_RETURN_VALUE(output_length >= required_output_length, ETL_ERROR(base64_overflow), 0U); return process_decode(input_begin, input_length, output_begin, required_output_length); @@ -604,23 +537,29 @@ namespace etl return input_length - (input_length / 4U); } - private: + protected: - // Sextets - // 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', - // 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', - // 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', - // 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', - // 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', - // 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', - // 'w', 'x', 'y', 'z', '0', '1', '2', '3', - // '4', '5', '6', '7', '8', '9', '+', '/' + //************************************************************************* + /// Constructor + //************************************************************************* + ETL_CONSTEXPR14 + ibase64(Encoding encoding_, const char* lookup_, bool use_padding_, bool discard_illegal_characters_, size_t max_line_length_) + : encoding(encoding_) + , lookup(lookup_) + , use_padding(use_padding_) + , discard_illegal_characters(discard_illegal_characters_) + , max_line_length(max_line_length_) + { + } + + private: //************************************************************************* // Translates an index into a sextet //************************************************************************* template - ETL_CONSTEXPR14 static T get_sextet_from_index(char index) + ETL_CONSTEXPR14 + T get_sextet_from_index(char index) { if ((index >= 0) && (index < 26)) { @@ -638,11 +577,11 @@ namespace etl } else if (index == 62) { - return static_cast('+'); + return static_cast(lookup[62]); } else if (index == 63) { - return static_cast('/'); + return static_cast(lookup[63]); } else { @@ -655,7 +594,8 @@ namespace etl // Translates a sextet into an index //************************************************************************* template - ETL_CONSTEXPR14 static uint32_t get_index_from_sextet(T sextet) + ETL_CONSTEXPR14 + uint32_t get_index_from_sextet(T sextet) { if ((sextet >= 'A') && (sextet <= 'Z')) { @@ -848,9 +788,83 @@ namespace etl return output_length; } - Encoding encoding; - bool use_padding; - size_t max_line_length; + Encoding encoding; + const char* lookup; + bool use_padding; + bool discard_illegal_characters; + size_t max_line_length; + }; + + //************************************************************************* + /// Base64 RFC-1421 + //************************************************************************* + class base64_rfc1421 : public ibase64 + { + public: + + ETL_CONSTEXPR14 + base64_rfc1421() + : ibase64(etl::ibase64::Encoding::RFC_1421, + "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", + etl::ibase64::Padding::Use_Padding, + false, + 64U) + { + } + }; + + //************************************************************************* + /// Base64 RFC-2045 + //************************************************************************* + class base64_rfc2045 : public ibase64 + { + public: + + ETL_CONSTEXPR14 + base64_rfc2045(size_t max_line_length) + : ibase64(etl::ibase64::Encoding::RFC_2045, + "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", + etl::ibase64::Padding::Use_Padding, + true, + max_line_length) + { + } + }; + + //************************************************************************* + /// Base64 RFC-4648 + //************************************************************************* + class base64_rfc4648 : public ibase64 + { + public: + + ETL_CONSTEXPR14 + base64_rfc4648(etl::ibase64::Padding use_padding) + : ibase64(etl::ibase64::Encoding::RFC_4648, + "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", + use_padding, + false, + etl::integral_limits::max) + { + } + }; + + //************************************************************************* + /// Base64 RFC-4648 URL + //************************************************************************* + class base64_rfc4648_url : public ibase64 + { + public: + + ETL_CONSTEXPR14 + base64_rfc4648_url(etl::ibase64::Padding use_padding) + : ibase64(etl::ibase64::Encoding::RFC_4648_URL, + "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_", + use_padding, + false, + etl::integral_limits::max) + { + } }; } diff --git a/test/test_base64_RFC4648_with_padding.cpp b/test/test_base64_RFC4648_with_padding.cpp index 81a37460..a6a323da 100644 --- a/test/test_base64_RFC4648_with_padding.cpp +++ b/test/test_base64_RFC4648_with_padding.cpp @@ -352,7 +352,7 @@ namespace //************************************************************************* TEST(test_encode_unsigned_char_pointer_size) { - etl::base64 b64(etl::base64::Encoding::RFC_4648, etl::base64::Padding::Use_Padding); + etl::base64_rfc4648 b64(etl::ibase64::Padding::Use_Padding); std::array encoded_output; for (size_t i = 0; i < 256; ++i) @@ -366,14 +366,14 @@ namespace std::string actual(encoded_output.data(), size); CHECK_EQUAL(expected, actual); - CHECK_EQUAL(etl::base64::encoded_size(i), size); + CHECK_EQUAL(etl::base64_rfc4648::encoded_size(i), size); } } //************************************************************************* TEST(test_encode_unsigned_char_pointer_size_no_output_length) { - etl::base64 b64(etl::base64::Encoding::RFC_4648, etl::base64::Padding::Use_Padding); + etl::base64_rfc4648 b64(etl::ibase64::Padding::Use_Padding); std::array encoded_output; for (size_t i = 0; i < 256; ++i) @@ -387,14 +387,14 @@ namespace std::string actual(encoded_output.data(), size); CHECK_EQUAL(expected, actual); - CHECK_EQUAL(etl::base64::encoded_size(i), size); + CHECK_EQUAL(etl::base64_rfc4648::encoded_size(i), size); } } //************************************************************************* TEST(test_encode_unsigned_char_pointer_size_to_back_inserter) { - etl::base64 b64(etl::base64::Encoding::RFC_4648, etl::base64::Padding::Use_Padding); + etl::base64_rfc4648 b64(etl::ibase64::Padding::Use_Padding); for (size_t i = 0; i < 256; ++i) { @@ -406,14 +406,14 @@ namespace std::string expected(encoded[i]); CHECK_EQUAL(expected, actual); - CHECK_EQUAL(etl::base64::encoded_size(i), size); + CHECK_EQUAL(etl::base64_rfc4648::encoded_size(i), size); } } //************************************************************************* TEST(test_encode_unsigned_char_pointer_pointer) { - etl::base64 b64(etl::base64::Encoding::RFC_4648, etl::base64::Padding::Use_Padding); + etl::base64_rfc4648 b64(etl::ibase64::Padding::Use_Padding); std::array encoded_output; for (size_t i = 0; i < 256; ++i) @@ -427,14 +427,14 @@ namespace std::string actual(encoded_output.data(), size); CHECK_EQUAL(expected, actual); - CHECK_EQUAL(etl::base64::encoded_size(i), size); + CHECK_EQUAL(etl::base64_rfc4648::encoded_size(i), size); } } //************************************************************************* TEST(test_encode_unsigned_char_pointer_pointer_no_output_end_pointer) { - etl::base64 b64(etl::base64::Encoding::RFC_4648, etl::base64::Padding::Use_Padding); + etl::base64_rfc4648 b64(etl::ibase64::Padding::Use_Padding); std::array encoded_output; for (size_t i = 6; i < 256; ++i) @@ -448,14 +448,14 @@ namespace std::string actual(encoded_output.data(), size); CHECK_EQUAL(expected, actual); - CHECK_EQUAL(etl::base64::encoded_size(i), size); + CHECK_EQUAL(etl::base64_rfc4648::encoded_size(i), size); } } //************************************************************************* TEST(test_encode_int8_t_pointer_size) { - etl::base64 b64(etl::base64::Encoding::RFC_4648, etl::base64::Padding::Use_Padding); + etl::base64_rfc4648 b64(etl::ibase64::Padding::Use_Padding); std::array encoded_output; for (size_t i = 11; i < 256; ++i) @@ -469,14 +469,14 @@ namespace std::string actual(encoded_output.data(), size); CHECK_EQUAL(expected, actual); - CHECK_EQUAL(etl::base64::encoded_size(i), size); + CHECK_EQUAL(etl::base64_rfc4648::encoded_size(i), size); } } //************************************************************************* TEST(test_encode_int8_t_pointer_size_no_output_length) { - etl::base64 b64(etl::base64::Encoding::RFC_4648, etl::base64::Padding::Use_Padding); + etl::base64_rfc4648 b64(etl::ibase64::Padding::Use_Padding); std::array encoded_output; for (size_t i = 6; i < 256; ++i) @@ -490,14 +490,14 @@ namespace std::string actual(encoded_output.data(), size); CHECK_EQUAL(expected, actual); - CHECK_EQUAL(etl::base64::encoded_size(i), size); + CHECK_EQUAL(etl::base64_rfc4648::encoded_size(i), size); } } //************************************************************************* TEST(test_encode_int8_t_pointer_size_to_back_inserter) { - etl::base64 b64(etl::base64::Encoding::RFC_4648, etl::base64::Padding::Use_Padding); + etl::base64_rfc4648 b64(etl::ibase64::Padding::Use_Padding); for (size_t i = 0; i < 256; ++i) { @@ -509,14 +509,14 @@ namespace std::string expected(encoded[i]); CHECK_EQUAL(expected, actual); - CHECK_EQUAL(etl::base64::encoded_size(i), size); + CHECK_EQUAL(etl::base64_rfc4648::encoded_size(i), size); } } //************************************************************************* TEST(test_encode_int8_t_pointer_pointer) { - etl::base64 b64(etl::base64::Encoding::RFC_4648, etl::base64::Padding::Use_Padding); + etl::base64_rfc4648 b64(etl::ibase64::Padding::Use_Padding); std::array encoded_output; for (size_t i = 0; i < 256; ++i) @@ -530,14 +530,14 @@ namespace std::string actual(encoded_output.data(), size); CHECK_EQUAL(expected, actual); - CHECK_EQUAL(etl::base64::encoded_size(i), size); + CHECK_EQUAL(etl::base64_rfc4648::encoded_size(i), size); } } //************************************************************************* TEST(test_encode_int8_t_pointer_pointer_no_end_pointer) { - etl::base64 b64(etl::base64::Encoding::RFC_4648, etl::base64::Padding::Use_Padding); + etl::base64_rfc4648 b64(etl::ibase64::Padding::Use_Padding); std::array encoded_output; @@ -552,7 +552,7 @@ namespace std::string actual(encoded_output.data(), size); CHECK_EQUAL(expected, actual); - CHECK_EQUAL(etl::base64::encoded_size(i), size); + CHECK_EQUAL(etl::base64_rfc4648::encoded_size(i), size); } } @@ -561,10 +561,10 @@ namespace template constexpr auto GetConstexprBase64(const etl::array input) noexcept { - etl::base64 b64(etl::base64::Encoding::RFC_4648, etl::base64::Padding::Use_Padding); + etl::base64_rfc4648 b64(etl::ibase64::Padding::Use_Padding); - constexpr size_t encoded_size = etl::base64::encoded_size(Size); - etl::array output{ 0 }; + constexpr size_t encoded_size = etl::base64_rfc4648::encoded_size(Size); + etl::array output{ 0 }; b64.encode(input.begin(), Size, output._buffer, encoded_size); @@ -582,14 +582,14 @@ namespace std::string actual(output.data(), output.size()); CHECK_EQUAL(expected, actual); - CHECK_EQUAL(etl::base64::encoded_size(10), output.size()); + CHECK_EQUAL(etl::base64_rfc4648::encoded_size(10), output.size()); } #endif //************************************************************************* TEST(test_encode_overflow) { - etl::base64 b64(etl::base64::Encoding::RFC_4648, etl::base64::Padding::Use_Padding); + etl::base64_rfc4648 b64(etl::ibase64::Padding::Use_Padding); std::array encoded_output{ 0 }; CHECK_THROW((b64.encode(input_data_unsigned_char.data(), 10, @@ -600,7 +600,7 @@ namespace //************************************************************************* TEST(test_decode_unsigned_char_pointer_size) { - etl::base64 b64(etl::base64::Encoding::RFC_4648, etl::base64::Padding::Use_Padding); + etl::base64_rfc4648 b64(etl::ibase64::Padding::Use_Padding); std::array decoded_output; for (size_t i = 0; i < 256; ++i) @@ -611,7 +611,7 @@ namespace decoded_output.data(), decoded_output.size()); CHECK_ARRAY_EQUAL(input_data_unsigned_char.data(), decoded_output.data(), i); - CHECK_EQUAL(i, etl::base64::decoded_size(encoded[i].data(), encoded[i].size())); + CHECK_EQUAL(i, etl::base64_rfc4648::decoded_size(encoded[i].data(), encoded[i].size())); CHECK_EQUAL(i, decoded_size); } } @@ -619,7 +619,7 @@ namespace //************************************************************************* TEST(test_decode_unsigned_char_pointer_size_no_end_pointer) { - etl::base64 b64(etl::base64::Encoding::RFC_4648, etl::base64::Padding::Use_Padding); + etl::base64_rfc4648 b64(etl::ibase64::Padding::Use_Padding); std::array decoded_output; for (size_t i = 0; i < 256; ++i) @@ -630,7 +630,7 @@ namespace decoded_output.data()); CHECK_ARRAY_EQUAL(input_data_unsigned_char.data(), decoded_output.data(), i); - CHECK_EQUAL(i, etl::base64::decoded_size(encoded[i].data(), encoded[i].size())); + CHECK_EQUAL(i, etl::base64_rfc4648::decoded_size(encoded[i].data(), encoded[i].size())); CHECK_EQUAL(i, decoded_size); } } @@ -638,7 +638,7 @@ namespace //************************************************************************* TEST(test_decode_unsigned_char_pointer_pointer) { - etl::base64 b64(etl::base64::Encoding::RFC_4648, etl::base64::Padding::Use_Padding); + etl::base64_rfc4648 b64(etl::ibase64::Padding::Use_Padding); std::array decoded_output; for (size_t i = 0; i < 256; ++i) @@ -649,7 +649,7 @@ namespace decoded_output.data(), decoded_output.data() + decoded_output.size()); CHECK_ARRAY_EQUAL(input_data_unsigned_char.data(), decoded_output.data(), i); - CHECK_EQUAL(i, etl::base64::decoded_size(encoded[i].data(), encoded[i].size())); + CHECK_EQUAL(i, etl::base64_rfc4648::decoded_size(encoded[i].data(), encoded[i].size())); CHECK_EQUAL(i, decoded_size); } } @@ -657,7 +657,7 @@ namespace //************************************************************************* TEST(test_decode_unsigned_char_pointer_pointer_no_end_pointer) { - etl::base64 b64(etl::base64::Encoding::RFC_4648, etl::base64::Padding::Use_Padding); + etl::base64_rfc4648 b64(etl::ibase64::Padding::Use_Padding); std::array decoded_output; for (size_t i = 0; i < 256; ++i) @@ -668,7 +668,7 @@ namespace decoded_output.data()); CHECK_ARRAY_EQUAL(input_data_unsigned_char.data(), decoded_output.data(), i); - CHECK_EQUAL(i, etl::base64::decoded_size(encoded[i].data(), encoded[i].size())); + CHECK_EQUAL(i, etl::base64_rfc4648::decoded_size(encoded[i].data(), encoded[i].size())); CHECK_EQUAL(i, decoded_size); } } @@ -676,7 +676,7 @@ namespace //************************************************************************* TEST(test_decode_int8_t_pointer_size) { - etl::base64 b64(etl::base64::Encoding::RFC_4648, etl::base64::Padding::Use_Padding); + etl::base64_rfc4648 b64(etl::ibase64::Padding::Use_Padding); std::array decoded_output; for (size_t i = 0; i < 256; ++i) @@ -687,7 +687,7 @@ namespace decoded_output.data(), decoded_output.size()); CHECK_ARRAY_EQUAL(input_data_int8_t.data(), decoded_output.data(), i); - CHECK_EQUAL(i, etl::base64::decoded_size(encoded[i].data(), encoded[i].size())); + CHECK_EQUAL(i, etl::base64_rfc4648::decoded_size(encoded[i].data(), encoded[i].size())); CHECK_EQUAL(i, decoded_size); } } @@ -695,7 +695,7 @@ namespace //************************************************************************* TEST(test_decode_int8_t_pointer_size_back_inserter) { - etl::base64 b64(etl::base64::Encoding::RFC_4648, etl::base64::Padding::Use_Padding); + etl::base64_rfc4648 b64(etl::ibase64::Padding::Use_Padding); std::vector decoded_output; for (size_t i = 0; i < 256; ++i) @@ -706,7 +706,7 @@ namespace etl::back_inserter(decoded_output)); CHECK_ARRAY_EQUAL(input_data_int8_t.data(), decoded_output.data(), i); - CHECK_EQUAL(i, etl::base64::decoded_size(encoded[i].data(), encoded[i].size())); + CHECK_EQUAL(i, etl::base64_rfc4648::decoded_size(encoded[i].data(), encoded[i].size())); CHECK_EQUAL(i, decoded_size); } } @@ -714,7 +714,7 @@ namespace //************************************************************************* TEST(test_decode_int8_t_pointer_size_no_output_size) { - etl::base64 b64(etl::base64::Encoding::RFC_4648, etl::base64::Padding::Use_Padding); + etl::base64_rfc4648 b64(etl::ibase64::Padding::Use_Padding); std::array decoded_output; for (size_t i = 0; i < 256; ++i) @@ -725,7 +725,7 @@ namespace decoded_output.data()); CHECK_ARRAY_EQUAL(input_data_int8_t.data(), decoded_output.data(), i); - CHECK_EQUAL(i, etl::base64::decoded_size(encoded[i].data(), encoded[i].size())); + CHECK_EQUAL(i, etl::base64_rfc4648::decoded_size(encoded[i].data(), encoded[i].size())); CHECK_EQUAL(i, decoded_size); } } @@ -733,7 +733,7 @@ namespace //************************************************************************* TEST(test_decode_int8_t_pointer_pointer) { - etl::base64 b64(etl::base64::Encoding::RFC_4648, etl::base64::Padding::Use_Padding); + etl::base64_rfc4648 b64(etl::ibase64::Padding::Use_Padding); std::array decoded_output; for (size_t i = 0; i < 256; ++i) @@ -744,7 +744,7 @@ namespace decoded_output.data(), decoded_output.data() + decoded_output.size()); CHECK_ARRAY_EQUAL(input_data_int8_t.data(), decoded_output.data(), i); - CHECK_EQUAL(i, etl::base64::decoded_size(encoded[i].data(), encoded[i].size())); + CHECK_EQUAL(i, etl::base64_rfc4648::decoded_size(encoded[i].data(), encoded[i].size())); CHECK_EQUAL(i, decoded_size); } } @@ -752,7 +752,7 @@ namespace //************************************************************************* TEST(test_decode_int8_t_pointer_pointer_back_inserter) { - etl::base64 b64(etl::base64::Encoding::RFC_4648, etl::base64::Padding::Use_Padding); + etl::base64_rfc4648 b64(etl::ibase64::Padding::Use_Padding); std::vector decoded_output; for (size_t i = 0; i < 256; ++i) @@ -763,7 +763,7 @@ namespace etl::back_inserter(decoded_output)); CHECK_ARRAY_EQUAL(input_data_int8_t.data(), decoded_output.data(), i); - CHECK_EQUAL(i, etl::base64::decoded_size(encoded[i].data(), encoded[i].size())); + CHECK_EQUAL(i, etl::base64_rfc4648::decoded_size(encoded[i].data(), encoded[i].size())); CHECK_EQUAL(i, decoded_size); } } @@ -771,7 +771,7 @@ namespace //************************************************************************* TEST(test_decode_int8_t_pointer_pointer_no_end_pointer) { - etl::base64 b64(etl::base64::Encoding::RFC_4648, etl::base64::Padding::Use_Padding); + etl::base64_rfc4648 b64(etl::ibase64::Padding::Use_Padding); std::array decoded_output; for (size_t i = 0; i < 256; ++i) @@ -782,7 +782,7 @@ namespace decoded_output.data()); CHECK_ARRAY_EQUAL(input_data_int8_t.data(), decoded_output.data(), i); - CHECK_EQUAL(i, etl::base64::decoded_size(encoded[i].data(), encoded[i].size())); + CHECK_EQUAL(i, etl::base64_rfc4648::decoded_size(encoded[i].data(), encoded[i].size())); CHECK_EQUAL(i, decoded_size); } } @@ -790,7 +790,7 @@ namespace //************************************************************************* TEST(test_decode_overflow) { - etl::base64 b64(etl::base64::Encoding::RFC_4648, etl::base64::Padding::Use_Padding); + etl::base64_rfc4648 b64(etl::ibase64::Padding::Use_Padding); std::array decoded_output{ 0 }; CHECK_THROW((b64.decode(encoded[10].data(), encoded[10].size(), @@ -800,7 +800,7 @@ namespace //************************************************************************* TEST(test_decode_invalid_character) { - etl::base64 b64(etl::base64::Encoding::RFC_4648, etl::base64::Padding::Use_Padding); + etl::base64_rfc4648 b64(etl::ibase64::Padding::Use_Padding); std::array decoded_output{ 0 }; std::string invalid_chararacter("OycD£Qy37KA=="); @@ -813,13 +813,13 @@ namespace //************************************************************************* TEST(test_decoded_size) { - etl::base64 b64(etl::base64::Encoding::RFC_4648, etl::base64::Padding::Use_Padding); + etl::base64_rfc4648 b64(etl::ibase64::Padding::Use_Padding); for (size_t i = 0; i < 256; ++i) { - size_t length = etl::base64::decoded_size(encoded[i].data(), encoded[i].size()); + size_t length = etl::base64_rfc4648::decoded_size(encoded[i].data(), encoded[i].size()); - CHECK_EQUAL(length, etl::base64::decoded_size(encoded[i].data(), encoded[i].data() + encoded[i].size())); + CHECK_EQUAL(length, etl::base64_rfc4648::decoded_size(encoded[i].data(), encoded[i].data() + encoded[i].size())); } } };