coffee/etl
1
0
Fork 0
mirror of https://github.com/ETLCPP/etl.git synced 2026-05-01 03:19:10 +08:00
Code Issues Packages Projects Releases Wiki Activity

Refactor to support multiple RFCs

Browse Source
This commit is contained in:
John Wellbelove 2023-10-21 20:29:08 +01:00 committed by John Wellbelove
parent 8db9613320
commit f9233f99ab
2 changed files with 161 additions and 147 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

208
include/etl/base64.h
View File

@ -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<size_t>::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<size_t>::max;
break;
}
case Encoding::RFC_3501:
{
use_padding = false;
max_line_length = etl::integral_limits<size_t>::max;
break;
}
case Encoding::RFC_4648:
{
use_padding = use_padding_;
max_line_length = etl::integral_limits<size_t>::max;
break;
}
case Encoding::RFC_4648_URL:
{
use_padding = use_padding_;
max_line_length = etl::integral_limits<size_t>::max;
break;
}
default:
{
break;
}
}
}
//*************************************************************************
/// Get the encoding standard
//*************************************************************************
@ -259,7 +192,7 @@ namespace etl
const size_t output_length = static_cast<size_t>(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<size_t>(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 <typename T>
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<T>('+');
return static_cast<T>(lookup[62]);
}
else if (index == 63)
{
return static_cast<T>('/');
return static_cast<T>(lookup[63]);
}
else
{
@ -655,7 +594,8 @@ namespace etl
// Translates a sextet into an index
//*************************************************************************
template <typename T>
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<size_t>::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<size_t>::max)
{
}
};
}

100
test/test_base64_RFC4648_with_padding.cpp
View File

@ -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<char, 344U> 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<char, 344U> 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<char, 344U> 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<char, 344U> 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<char, 344U> 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<char, 344U> 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<char, 344U> 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<char, 344U> 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 <size_t Size>
constexpr auto GetConstexprBase64(const etl::array<int8_t, Size> 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<char, etl::base64::encoded_size(Size)> output{ 0 };
constexpr size_t encoded_size = etl::base64_rfc4648::encoded_size(Size);
etl::array<char, etl::base64_rfc4648::encoded_size(Size)> 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<char, 1> 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<unsigned char, 256> 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<unsigned char, 256> 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<unsigned char, 256> 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<unsigned char, 256> 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<int8_t, 256> 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<int8_t> 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<int8_t, 256> 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<int8_t, 256> 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<int8_t> 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<int8_t, 256> 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<unsigned char, 1> 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<unsigned char, 50U> 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()));
}
}
};