coffee/etl
1
0
Fork 0
mirror of https://github.com/ETLCPP/etl.git synced 2026-06-26 20:38:45 +08:00
Code Issues Packages Projects Releases Wiki Activity

Static version of Base64 - RFC-6848 - No optional padding

Browse Source
This commit is contained in:
John Wellbelove 2023-10-21 10:27:42 +01:00 committed by John Wellbelove
parent 91a150e37b
commit 25338fb0d1
7 changed files with 684 additions and 743 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
arduino/library-arduino.json
View File

@ -1,6 +1,6 @@
{
"name": "Embedded Template Library - Arduino",
"version": "20.38.4",
"version": "20.39.0",
"authors": {
"name": "John Wellbelove",
"email": "john.wellbelove@etlcpp.com"

2
arduino/library-arduino.properties
View File

@ -1,5 +1,5 @@
name=Embedded Template Library - Arduino
version=20.38.4
version=20.39.0
author= John Wellbelove <john.wellbelove@etlcpp.com>
maintainer=John Wellbelove <john.wellbelove@etlcpp.com>
license=MIT

682
include/etl/base64.h
View File

@ -42,11 +42,8 @@ SOFTWARE.
#include <stdint.h>
#if ETL_USING_STL
#include <string>
#endif
#define ETL_IS_8_BIT_INTEGRAL(Type) (etl::is_integral<Type>::value && (etl::integral_limits<Type>::bits == 8U))
#define ETL_IS_ITERATOR_TYPE_8_BIT_INTEGRAL(Type) (etl::is_integral<typename etl::iterator_traits<typename etl::remove_cv<Type>::type>::value_type>::value && \
(etl::integral_limits<typename etl::iterator_traits<typename etl::remove_cv<Type>::type>::value_type>::bits == 8U))
namespace etl
{
@ -77,200 +74,135 @@ namespace etl
};
//*************************************************************************
/// Codec for Base64
/// Codec for Base64 (RFC 4648)
//*************************************************************************
class base64
{
public:
//*************************************************************************
/// Encode to Base64 from and to pointer/length
/// Encode to Base64
/// Four parameter
//*************************************************************************
template <typename T>
template <typename TInputIterator, typename TOutputIterator>
ETL_CONSTEXPR14
static
typename etl::enable_if<ETL_IS_8_BIT_INTEGRAL(T), size_t>::type
encode(const T* input, size_t input_length, char* output, size_t output_length)
static size_t encode(TInputIterator input_begin, TInputIterator input_end, TOutputIterator output_begin, TOutputIterator output_end)
{
if (input_length == 0U)
{
return 0;
}
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");
const size_t input_length = static_cast<size_t>(etl::distance(input_begin, input_end));
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 = encoded_size(input_length);
size_t required_output_length = etl::base64::encoded_size(input_length);
ETL_ASSERT_OR_RETURN_VALUE(output_length >= required_output_length, ETL_ERROR(base64_overflow), 0U);
const T* p_in = input;
const T* p_in_end = input + input_length;
char* p_out = output;
char* p_out_end = output + required_output_length;
int next_sextet = First_Sextet;
// Step through the input buffer, creating the output sextets.
while (p_in != p_in_end)
{
T c = *p_in;
char index = 0;
switch (next_sextet)
{
//**************************
case First_Sextet:
{
index = static_cast<char>((*p_in & b11111100) >> 2);
next_sextet = Second_Sextet;
break;
}
//**************************
case Second_Sextet:
{
index = static_cast<char>((c & b00000011) << 4);
++p_in;
// Next byte valid?
if (p_in != p_in_end)
{
index = index | ((*p_in & b11110000) >> 4);
}
next_sextet = Third_Sextet;
break;
}
//**************************
case Third_Sextet:
{
index = (c & b00001111) << 2;
++p_in;
// Next byte valid?
if (p_in != p_in_end)
{
index = index | static_cast<char>((*p_in & b11000000) >> 6);
}
next_sextet = Fourth_Sextet;
break;
}
//**************************
case Fourth_Sextet:
{
index = static_cast<char>(c & b00111111);
++p_in;
next_sextet = First_Sextet;
break;
}
//**************************
default:
{
// Should never get here.
assert(false);
break;
}
}
*p_out = get_sextet_from_index(index);
++p_out;
}
// Pad out the end of the output buffer.
while (p_out != p_out_end)
{
*p_out++ = padding();
}
return static_cast<size_t>(etl::distance(output, p_out));
return process_encode(input_begin, input_length, output_begin, required_output_length);
}
//*************************************************************************
/// Encode to Base64 from and to pointer/pointer
/// Encode to Base64
/// For TOutputIterator not derived from etl::iterator<ETL_OR_STD::output_iterator_tag, void, void, void, void>
/// Three parameter
/// Assumes the output container is large enough.
//*************************************************************************
template <typename T>
template <typename TInputIterator, typename TOutputIterator>
ETL_CONSTEXPR14
static
typename etl::enable_if<ETL_IS_8_BIT_INTEGRAL(T), size_t>::type
encode(const T* input_begin, const T* input_end, char* output_begin, char* output_end)
static typename etl::enable_if<!etl::is_void<typename etl::iterator_traits<TOutputIterator>::value_type>::value, size_t>::type
encode(TInputIterator input_begin, TInputIterator input_end, TOutputIterator output_begin)
{
return encode(input_begin, static_cast<size_t>(etl::distance(input_begin, input_end)),
output_begin, static_cast<size_t>(etl::distance(output_begin, 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");
const size_t input_length = static_cast<size_t>(etl::distance(input_begin, input_end));
const size_t output_length = encoded_size(input_length);
return process_encode(input_begin, input_length, output_begin, output_length);
}
//*************************************************************************
/// Encode to Base64 from and to span/span
/// Encode to Base64
/// For TOutputIterator derived from etl::iterator<ETL_OR_STD::output_iterator_tag, void, void, void, void>
/// Three parameter
/// Assumes the output container is large enough.
//*************************************************************************
template <typename T, size_t Length1, size_t Length2>
template <typename TInputIterator, typename TOutputIterator>
ETL_CONSTEXPR14
static
typename etl::enable_if<ETL_IS_8_BIT_INTEGRAL(T), size_t>::type
encode(const etl::span<const T, Length1>& input_span,
const etl::span<char, Length2>& output_span)
static typename etl::enable_if<etl::is_void<typename etl::iterator_traits<TOutputIterator>::value_type>::value, size_t>::type
encode(TInputIterator input_begin, TInputIterator input_end, TOutputIterator output_begin)
{
return encode(input_span.begin(), input_span.size(),
output_span.begin(), output_span.size());
ETL_STATIC_ASSERT(ETL_IS_ITERATOR_TYPE_8_BIT_INTEGRAL(TInputIterator), "Input type must be an 8 bit integral");
const size_t input_length = static_cast<size_t>(etl::distance(input_begin, input_end));
const size_t output_length = encoded_size(input_length);
return process_encode(input_begin, input_length, output_begin, output_length);
}
//*************************************************************************
/// Encode to Base64 from pointer/length to etl::istring
/// Encode to Base64
/// Four parameter
//*************************************************************************
template <typename T>
template <typename TInputIterator, typename TOutputIterator>
ETL_CONSTEXPR14
static
typename etl::enable_if<ETL_IS_8_BIT_INTEGRAL(T), size_t>::type
encode(const T* input_begin, size_t input_length,
etl::istring& output)
static size_t encode(TInputIterator input_begin, size_t input_length, TOutputIterator output_begin, size_t output_length)
{
output.resize(etl::base64::encoded_size(input_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");
return encode(input_begin, input_length,
output.data(), output.size());
// Figure out if the output buffer is large enough.
size_t required_output_length = etl::base64::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);
}
//*************************************************************************
/// Encode to Base64 from pointer/pointer to etl::istring
/// Encode to Base64
/// For TOutputIterator not derived from etl::iterator<ETL_OR_STD::output_iterator_tag, void, void, void, void>
/// Three parameter
/// Assumes the output container is large enough.
//*************************************************************************
template <typename T>
template <typename TInputIterator, typename TOutputIterator>
ETL_CONSTEXPR14
static
typename etl::enable_if<ETL_IS_8_BIT_INTEGRAL(T), size_t>::type
encode(const T* input_begin, const T* input_end,
etl::istring& output)
static typename etl::enable_if<!etl::is_void<typename etl::iterator_traits<TOutputIterator>::value_type>::value, size_t>::type
encode(TInputIterator input_begin, size_t input_length, TOutputIterator output_begin)
{
output.resize(etl::base64::encoded_size(etl::distance(input_begin, input_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");
return encode(input_begin, static_cast<size_t>(etl::distance(input_begin, input_end)),
output.data(), output.size());
const size_t output_length = encoded_size(input_length);
return process_encode(input_begin, input_length, output_begin, output_length);
}
//*************************************************************************
/// Encode to Base64 from span to etl::istring
/// Encode to Base64
/// For TOutputIterator derived from etl::iterator<ETL_OR_STD::output_iterator_tag, void, void, void, void>
/// Three parameter
/// Assumes the output container is large enough.
//*************************************************************************
template <typename T, size_t Length1>
template <typename TInputIterator, typename TOutputIterator>
ETL_CONSTEXPR14
static
typename etl::enable_if<ETL_IS_8_BIT_INTEGRAL(T), size_t>::type
encode(const etl::span<const T, Length1>& input_span,
etl::istring& output)
static typename etl::enable_if<etl::is_void<typename etl::iterator_traits<TOutputIterator>::value_type>::value, size_t>::type
encode(TInputIterator input_begin, size_t input_length, TOutputIterator output_begin)
{
output.resize(etl::base64::encoded_size(Length1));
ETL_STATIC_ASSERT(ETL_IS_ITERATOR_TYPE_8_BIT_INTEGRAL(TInputIterator), "Input type must be an 8 bit integral");
return encode(input_span.begin(), input_span.size(),
output.data(), output.size());
const size_t output_length = encoded_size(input_length);
return process_encode(input_begin, input_length, output_begin, output_length);
}
//*************************************************************************
/// Calculates the buffer size required to encode to Base64
/// Calculates the minimum buffer size required to encode to Base64
//*************************************************************************
ETL_NODISCARD
ETL_CONSTEXPR14
static
size_t encoded_size(size_t input_length)
static size_t encoded_size(size_t input_length)
{
size_t required_output_length = (input_length * 8U) / 6U;
size_t required_output_length = (input_length * 4U) / 3U;
while ((required_output_length % 4U) != 0)
{
@ -281,175 +213,238 @@ namespace etl
}
//*************************************************************************
/// Decode from Base64 from and to pointer/length
/// Decode from Base64
/// Four parameter
//*************************************************************************
template <typename T>
template <typename TInputIterator, typename TOutputIterator>
ETL_CONSTEXPR14
static
typename etl::enable_if<ETL_IS_8_BIT_INTEGRAL(T), size_t>::type
decode(const char* input, size_t input_length, T* output, size_t output_length)
static size_t decode(TInputIterator input_begin, TInputIterator input_end, TOutputIterator output_begin, TOutputIterator output_end)
{
if (input_length == 0)
{
return 0;
}
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");
const size_t input_length = valid_input_length(input_begin, input_end);
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(input, input_length);
size_t required_output_length = etl::base64::decoded_size_from_valid_input_length(input_length);
ETL_ASSERT_OR_RETURN_VALUE(output_length >= required_output_length, ETL_ERROR(base64_overflow), 0U);
const char* p_in = input;
const char* p_in_end = input + input_length;
T* p_out = output;
T c = 0;
int next_sextet = First_Sextet;
// Step through the input buffer, creating the output binary.
while (p_in != p_in_end)
{
char sextet = *p_in++; // Get the sextet as a T.
if (sextet == padding())
{
break;
}
char index = get_index_from_sextet(sextet);
switch (next_sextet)
{
//**************************
case First_Sextet:
{
c = (index & b00111111) << 2;
next_sextet = Second_Sextet;
break;
}
//**************************
case Second_Sextet:
{
c |= (index & b00110000) >> 4;
*p_out++ = static_cast<T>(c);
c = (index & b00001111) << 4;
next_sextet = Third_Sextet;
break;
}
//**************************
case Third_Sextet:
{
c |= (index & b00111100) >> 2;
*p_out++ = static_cast<T>(c);
c = (index & b00000011) << 6;
next_sextet = Fourth_Sextet;
break;
}
//**************************
case Fourth_Sextet:
{
c |= (index & b00111111);
*p_out++ = static_cast<T>(c);
next_sextet = First_Sextet;
break;
}
//**************************
default:
{
// Should never get here.
assert(false);
break;
}
}
}
return static_cast<size_t>(etl::distance(output, p_out));
return process_decode(input_begin, input_length, output_begin, required_output_length);
}
//*************************************************************************
/// Decode from Base64 from and to pointer/pointer
/// Decode from Base64
/// For TOutputIterator not derived from etl::iterator<ETL_OR_STD::output_iterator_tag, void, void, void, void>
/// Three parameter
/// Assumes the output container is large enough.
//*************************************************************************
template <typename T>
template <typename TInputIterator, typename TOutputIterator>
ETL_CONSTEXPR14
static
typename etl::enable_if<ETL_IS_8_BIT_INTEGRAL(T), size_t>::type
decode(const char* input_begin, const char* input_end, T* output_begin, T* output_end)
static typename etl::enable_if<!etl::is_void<typename etl::iterator_traits<TOutputIterator>::value_type>::value, size_t>::type
decode(TInputIterator input_begin, TInputIterator input_end, TOutputIterator output_begin)
{
return decode(input_begin, static_cast<size_t>(etl::distance(input_begin, input_end)),
output_begin, static_cast<size_t>(etl::distance(output_begin, 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");
// Find the length of decodable characters.
const size_t input_length = valid_input_length(input_begin, input_end);
// Find the length of the decoded output.
const size_t required_output_length = decoded_size(input_begin, input_length);
return process_decode(input_begin, input_length, output_begin, required_output_length);
}
//*************************************************************************
/// Decode from Base64 from and to span/span
/// Decode from Base64
/// For TOutputIterator derived from etl::iterator<ETL_OR_STD::output_iterator_tag, void, void, void, void>
/// Three parameter
/// Assumes the output container is large enough.
//*************************************************************************
template <typename T, size_t Length1, size_t Length2>
template <typename TInputIterator, typename TOutputIterator>
ETL_CONSTEXPR14
static
typename etl::enable_if<ETL_IS_8_BIT_INTEGRAL(T), size_t>::type
decode(const etl::span<const char, Length1>& input_span,
const etl::span<T, Length2>& output_span)
static typename etl::enable_if<etl::is_void<typename etl::iterator_traits<TOutputIterator>::value_type>::value, size_t>::type
decode(TInputIterator input_begin, TInputIterator input_end, TOutputIterator output_begin)
{
return decode(input_span.begin(), input_span.size(),
output_span.begin(), output_span.size());
ETL_STATIC_ASSERT(ETL_IS_ITERATOR_TYPE_8_BIT_INTEGRAL(TInputIterator), "Input type must be an 8 bit integral");
// Find the length of decodable characters.
const size_t input_length = valid_input_length(input_begin, input_end);
// Find the length of the decoded output.
const size_t required_output_length = decoded_size(input_begin, input_length);
return process_decode(input_begin, input_length, output_begin, required_output_length);
}
//*************************************************************************
/// Calculates the buffer size required to decode from Base64
/// Decode from Base64
/// Four parameter
//*************************************************************************
template <typename TInputIterator, typename TOutputIterator>
ETL_CONSTEXPR14
static 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");
// Find the length of decodable characters.
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);
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);
}
//*************************************************************************
/// Decode from Base64
/// For TOutputIterator not derived from etl::iterator<ETL_OR_STD::output_iterator_tag, void, void, void, void>
/// Three parameter
/// Assumes the output container is large enough.
//*************************************************************************
template <typename TInputIterator, typename TOutputIterator>
ETL_CONSTEXPR14
static typename etl::enable_if<!etl::is_void<typename etl::iterator_traits<TOutputIterator>::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");
ETL_STATIC_ASSERT(ETL_IS_ITERATOR_TYPE_8_BIT_INTEGRAL(TOutputIterator), "Output type must be an 8 bit integral");
// Find the length of decodable characters.
input_length = valid_input_length(input_begin, input_length);
// Find the length of the decoded output.
const size_t required_output_length = decoded_size(input_begin, input_length);
return process_decode(input_begin, input_length, output_begin, required_output_length);
}
//*************************************************************************
/// Decode from Base64
/// For TOutputIterator derived from etl::iterator<ETL_OR_STD::output_iterator_tag, void, void, void, void>
/// Three parameter
/// Assumes the output container is large enough.
//*************************************************************************
template <typename TInputIterator, typename TOutputIterator>
ETL_CONSTEXPR14
static typename etl::enable_if<etl::is_void<typename etl::iterator_traits<TOutputIterator>::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");
// Find the length of decodable characters.
input_length = valid_input_length(input_begin, input_length);
// Find the length of the decoded output.
const size_t output_length = decoded_size(input_begin, input_length);
return process_decode(input_begin, input_length, output_begin, output_length);
}
//*************************************************************************
/// Discovers the number of valid decodable characters
//*************************************************************************
template <typename TInputIterator>
ETL_NODISCARD
ETL_CONSTEXPR14
static size_t decoded_size(const char* input, size_t input_length)
static size_t valid_input_length(TInputIterator input_begin, size_t input_length)
{
if (input_length == 0U)
{
return 0U;
}
// Figure out the minimum output buffer size.
size_t length = static_cast<size_t>(etl::distance(input, etl::find(input, input + input_length, padding())) - 1);
size_t required_output_length = length - (length / 4U);
TInputIterator input_end = input_begin;
return required_output_length;
if (input_length >= 2U)
{
// Jump forward to where padding characters possibly start.
// There are never more than two padding characters.
input_length -= 2U;
etl::advance(input_end, input_length);
}
typedef etl::iterator_traits<TInputIterator>::value_type input_type;
if (*input_end != padding<input_type>())
{
++input_end;
++input_length;
if (*input_end != padding<input_type>())
{
++input_end;
++input_length;
}
}
return input_length;
}
//*************************************************************************
/// Calculates the buffer size required to decode from Base64
/// Discovers the number of valid decodable characters
//*************************************************************************
template <typename TInputIterator>
ETL_NODISCARD
ETL_CONSTEXPR14
static size_t decoded_size(const char* input_begin, const char* input_end)
static size_t valid_input_length(TInputIterator input_begin, TInputIterator input_end)
{
return valid_input_length(input_begin, static_cast<size_t>(etl::distance(input_begin, input_end)));
}
//*************************************************************************
/// Calculates the minimum buffer size required to decode from Base64
//*************************************************************************
template <typename TInputIterator>
ETL_NODISCARD
ETL_CONSTEXPR14
static
size_t decoded_size(TInputIterator input_begin, size_t input_length)
{
if (input_length == 0U)
{
return 0U;
}
input_length = valid_input_length(input_begin, input_length);
--input_length;
return input_length - (input_length / 4U);
}
//*************************************************************************
/// Calculates the minimum buffer size required to decode from Base64
//*************************************************************************
template <typename TInputIterator>
ETL_NODISCARD
ETL_CONSTEXPR14
static
size_t decoded_size(TInputIterator input_begin, TInputIterator input_end)
{
return decoded_size(input_begin, static_cast<size_t>(etl::distance(input_begin, input_end)));
}
//*************************************************************************
/// Calculates the buffer size required to decode from Base64
/// Calculates the minimum buffer size required to decode from Base64
//*************************************************************************
template <size_t Length>
ETL_NODISCARD
ETL_CONSTEXPR14
static size_t decoded_size(etl::span<const char, Length> sp)
static
size_t decoded_size_from_valid_input_length(size_t input_length)
{
return decoded_size(sp.begin(), sp.size());
if (input_length == 0U)
{
return 0U;
}
--input_length;
return input_length - (input_length / 4U);
}
private:
//*************************************************************************
/// Sextet index id.
enum
{
First_Sextet,
Second_Sextet,
Third_Sextet,
Fourth_Sextet
};
// Sextets
// 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
// 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
@ -463,42 +458,44 @@ namespace etl
//*************************************************************************
// Translates an index into a sextet
//*************************************************************************
ETL_CONSTEXPR14 static char get_sextet_from_index(char index)
template <typename T>
ETL_CONSTEXPR14 static T get_sextet_from_index(char index)
{
if ((index >= 0) && (index < 26))
{
return 'A' + index;
return static_cast<T>('A' + index);
}
else if ((index >= 26) && (index < 52))
{
index -= 26;
return 'a' + index;
return static_cast<T>('a' + index);
}
else if ((index >= 52) && (index < 62))
{
index -= 52;
return '0' + index;
return static_cast<T>('0' + index);
}
else if (index == 62)
{
return '+';
return static_cast<T>('+');
}
else if (index == 63)
{
return '/';
return static_cast<T>('/');
}
else
{
// Should never get here.
assert(false);
return padding();
return padding<T>();
}
}
//*************************************************************************
// Translates a sextet into an index
//*************************************************************************
ETL_CONSTEXPR14 static char get_index_from_sextet(char sextet)
template <typename T>
ETL_CONSTEXPR14 static uint32_t get_index_from_sextet(T sextet)
{
if ((sextet >= 'A') && (sextet <= 'Z'))
{
@ -512,11 +509,11 @@ namespace etl
{
return sextet - '0' + 52;
}
else if (sextet == '+')
else if ((sextet == '+'))
{
return 62;
}
else if (sextet == '/')
else if ((sextet == '/'))
{
return 63;
}
@ -531,15 +528,142 @@ namespace etl
//*************************************************************************
/// Gets the padding character
//*************************************************************************
template <typename T>
ETL_NODISCARD
ETL_CONSTEXPR14
static char padding()
static T padding()
{
return '=';
return static_cast<T>('=');
}
//*************************************************************************
/// Encode to Base64 implementation
//*************************************************************************
template <typename TInputIterator, typename TOutputIterator>
ETL_CONSTEXPR14
static
size_t process_encode(TInputIterator input, size_t input_length,
TOutputIterator output, size_t output_length)
{
if (input_length == 0U)
{
return 0;
}
// Count the actual number of sextets written.
size_t output_count = 0;
uint32_t octets = 0;
// Read octet triplets and write sextet quartets
while (input_length >= 3U)
{
// Read in three octets
octets = (static_cast<uint32_t>(static_cast<unsigned char>(*input++)) << 16);
octets = octets | (static_cast<uint32_t>(static_cast<unsigned char>(*input++)) << 8);
octets = octets | static_cast<uint32_t>(static_cast<unsigned char>(*input++));
// Write out four sextets
*output++ = get_sextet_from_index<char>((octets >> 18) & b00111111);
*output++ = get_sextet_from_index<char>((octets >> 12) & b00111111);
*output++ = get_sextet_from_index<char>((octets >> 6) & b00111111);
*output++ = get_sextet_from_index<char>((octets >> 0) & b00111111);
input_length -= 3U;
output_count += 4U;
}
// Any input left?
if (input_length > 0)
{
// Write out any remaining sextets
if (input_length == 1U)
{
// There is one octet remaining
octets = static_cast<uint32_t>(static_cast<unsigned char>(*input++));
octets <<= 4; // Adjust one octet (8 bits) for two sextets worth of data (12 bits)
output_count += 2U;
}
else if (input_length == 2U)
{
// There are two octets remaining
octets = static_cast<uint32_t>(static_cast<unsigned char>(*input++));
octets <<= 8;
octets = octets | static_cast<uint32_t>(static_cast<unsigned char>(*input++));
octets <<= 2; // Adjust two octets (16 bits) for three sextets worth of data (18 bits)
output_count += 3U;
}
int shift = static_cast<int>(input_length * 6U);
while (shift >= 0)
{
*output++ = get_sextet_from_index<char>((octets >> shift) & b00111111);
shift -= 6;
}
}
// Pad out the end of the output buffer.
while (output_count != output_length)
{
*output++ = padding<char>();
++output_count;
}
return output_length;
}
//*************************************************************************
/// Decode from Base64 implementation
//*************************************************************************
template <typename TInputIterator, typename TOutputIterator>
ETL_CONSTEXPR14
static
size_t process_decode(TInputIterator input, size_t input_length, TOutputIterator output, size_t output_length)
{
if (input_length == 0)
{
return 0;
}
// Read sextet quartets and write octet triplets
while (input_length >= 4U)
{
// Read in four sextets
uint32_t sextets = (get_index_from_sextet(*input++) << 18) |
(get_index_from_sextet(*input++) << 12) |
(get_index_from_sextet(*input++) << 6) |
(get_index_from_sextet(*input++));
// Write out three octets
*output++ = (sextets >> 16) & b11111111;
*output++ = (sextets >> 8) & b11111111;
*output++ = (sextets >> 0) & b11111111;
input_length -= 4U;
}
// Write out any remaining octets
if (input_length == 2U)
{
uint32_t sextets = (get_index_from_sextet(*input++) << 6) |
(get_index_from_sextet(*input++));
*output++ = (sextets >> 4) & b11111111;
input_length -= 2U;
}
else if (input_length == 3U)
{
uint32_t sextets = (get_index_from_sextet(*input++) << 12) |
(get_index_from_sextet(*input++) << 6) |
(get_index_from_sextet(*input++));
*output++ = (sextets >> 10) & b11111111;
*output++ = (sextets >> 2) & b11111111;
input_length -= 3U;
}
return output_length;
}
};
}
#undef ETL_IS_8_BIT_INTEGRAL
#endif

10
include/etl/iterator.h
View File

@ -605,14 +605,14 @@ namespace etl
}
//***************************************************************************
/// This kind of %iterator doesn't really have a @a position in the
/// This kind of iterator doesn't really have a a position in the
/// container (you can think of the position as being permanently at
/// the end, if you like). Assigning a value to the %iterator will
/// the end, if you like). Assigning a value to the iterator will
/// always append the value to the end of the container.
///
/// @param value An instance of whatever type container_type::const_reference is;
/// presumably a reference-to-const T for container<T>.
/// @return This %iterator, for chained operations.
/// @return This iterator, for chained operations.
//***************************************************************************
ETL_CONSTEXPR14 back_insert_iterator& operator =(const typename TContainer::value_type& value)
{
@ -644,7 +644,7 @@ namespace etl
//***************************************************************************
/// Pre-increment operator.
/// Simply returns *this. (This %iterator does not @a move.)
/// Simply returns *this. (This iterator does not move.)
//***************************************************************************
ETL_CONSTEXPR14 back_insert_iterator& operator ++()
{
@ -653,7 +653,7 @@ namespace etl
//***************************************************************************
/// Post-increment operator.
/// Simply returns *this. (This %iterator does not @a move.)
/// Simply returns *this. (This iterator does not move.)
//***************************************************************************
ETL_CONSTEXPR14 back_insert_iterator operator ++(int)
{

4
include/etl/private/pvoidvector.h
View File

@ -593,7 +593,7 @@ namespace etl
iterator last_ = to_iterator(last);
etl::copy(last_, end(), first_);
size_t n_delete = etl::distance(first, last);
size_t n_delete = static_cast<size_t>(etl::distance(first, last));
// Just adjust the count.
p_end -= n_delete;
@ -695,7 +695,7 @@ namespace etl
//*************************************************************************
void repair_buffer(void** p_buffer_)
{
uintptr_t length = p_end - p_buffer;
uintptr_t length = static_cast<uintptr_t>(p_end - p_buffer);
p_buffer = p_buffer_;
p_end = p_buffer_ + length;

267
test/CMakeLists.txt
View File

@ -12,273 +12,7 @@ project(etl_unit_tests LANGUAGES CXX)
add_executable(etl_tests
main.cpp
murmurhash3.cpp
test_algorithm.cpp
test_alignment.cpp
test_array.cpp
test_array_view.cpp
test_array_wrapper.cpp
test_atomic.cpp
test_base64.cpp
test_binary.cpp
test_bip_buffer_spsc_atomic.cpp
test_bit.cpp
test_bitset_legacy.cpp
test_bitset_new_default_element_type.cpp
test_bitset_new_explicit_single_element_type.cpp
test_bitset_new_ext_default_element_type.cpp
test_bitset_new_ext_explicit_single_element_type.cpp
test_bit_stream.cpp
test_bit_stream_reader_big_endian.cpp
test_bit_stream_reader_little_endian.cpp
test_bit_stream_writer_big_endian.cpp
test_bit_stream_writer_little_endian.cpp
test_byte.cpp
test_byte_stream.cpp
test_bloom_filter.cpp
test_bresenham_line.cpp
test_bsd_checksum.cpp
test_buffer_descriptors.cpp
test_callback_service.cpp
test_callback_timer.cpp
test_callback_timer_atomic.cpp
test_callback_timer_interrupt.cpp
test_callback_timer_locked.cpp
test_char_traits.cpp
test_checksum.cpp
test_circular_buffer.cpp
test_circular_buffer_external_buffer.cpp
test_circular_iterator.cpp
test_compare.cpp
test_constant.cpp
test_container.cpp
test_correlation.cpp
test_covariance.cpp
test_crc.cpp
test_crc16.cpp
test_crc16_a.cpp
test_crc16_arc.cpp
test_crc16_aug_ccitt.cpp
test_crc16_buypass.cpp
test_crc16_ccitt.cpp
test_crc16_cdma2000.cpp
test_crc16_dds110.cpp
test_crc16_dectr.cpp
test_crc16_dectx.cpp
test_crc16_dnp.cpp
test_crc16_en13757.cpp
test_crc16_genibus.cpp
test_crc16_kermit.cpp
test_crc16_m17.cpp
test_crc16_maxim.cpp
test_crc16_mcrf4xx.cpp
test_crc16_modbus.cpp
test_crc16_profibus.cpp
test_crc16_riello.cpp
test_crc16_t10dif.cpp
test_crc16_teledisk.cpp
test_crc16_tms37157.cpp
test_crc16_usb.cpp
test_crc16_x25.cpp
test_crc16_xmodem.cpp
test_crc32.cpp
test_crc32_bzip2.cpp
test_crc32_c.cpp
test_crc32_d.cpp
test_crc32_jamcrc.cpp
test_crc32_mpeg2.cpp
test_crc32_posix.cpp
test_crc32_q.cpp
test_crc32_xfer.cpp
test_crc64_ecma.cpp
test_crc8_ccitt.cpp
test_crc8_cdma2000.cpp
test_crc8_darc.cpp
test_crc8_dvbs2.cpp
test_crc8_ebu.cpp
test_crc8_icode.cpp
test_crc8_itu.cpp
test_crc8_maxim.cpp
test_crc8_rohc.cpp
test_crc8_wcdma.cpp
test_cyclic_value.cpp
test_debounce.cpp
test_delegate.cpp
test_delegate_cpp03.cpp
test_delegate_service.cpp
test_delegate_service_compile_time.cpp
test_deque.cpp
test_endian.cpp
test_enum_type.cpp
test_error_handler.cpp
test_etl_traits.cpp
test_exception.cpp
test_expected.cpp
test_fixed_iterator.cpp
test_fixed_sized_memory_block_allocator.cpp
test_flags.cpp
test_flat_map.cpp
test_flat_multimap.cpp
test_flat_multiset.cpp
test_flat_set.cpp
test_fnv_1.cpp
test_format_spec.cpp
test_forward_list.cpp
test_forward_list_shared_pool.cpp
test_fsm.cpp
test_function.cpp
test_functional.cpp
test_gamma.cpp
test_hash.cpp
test_hfsm.cpp
test_histogram.cpp
test_indirect_vector.cpp
test_indirect_vector_external_buffer.cpp
test_instance_count.cpp
test_integral_limits.cpp
test_intrusive_forward_list.cpp
test_intrusive_links.cpp
test_intrusive_list.cpp
test_intrusive_queue.cpp
test_intrusive_stack.cpp
test_invert.cpp
test_io_port.cpp
test_iterator.cpp
test_jenkins.cpp
test_largest.cpp
test_limiter.cpp
test_limits.cpp
test_list.cpp
test_list_shared_pool.cpp
test_make_string.cpp
test_map.cpp
test_maths.cpp
test_mean.cpp
test_mem_cast.cpp
test_mem_cast_ptr.cpp
test_memory.cpp
test_message_broker.cpp
test_message_bus.cpp
test_message_packet.cpp
test_message_router.cpp
test_message_router_registry.cpp
test_message_timer.cpp
test_message_timer_atomic.cpp
test_message_timer_interrupt.cpp
test_message_timer_locked.cpp
test_multimap.cpp
test_multiset.cpp
test_multi_array.cpp
test_multi_range.cpp
test_multi_vector.cpp
test_murmur3.cpp
test_nth_type.cpp
test_numeric.cpp
test_observer.cpp
test_optional.cpp
test_packet.cpp
test_parameter_pack.cpp
test_parameter_type.cpp
test_parity_checksum.cpp
test_pearson.cpp
test_poly_span_dynamic_extent.cpp
test_poly_span_fixed_extent.cpp
test_pool.cpp
test_pool_external_buffer.cpp
test_priority_queue.cpp
test_pseudo_moving_average.cpp
test_quantize.cpp
test_queue.cpp
test_queue_lockable.cpp
test_queue_lockable_small.cpp
test_queue_memory_model_small.cpp
test_queue_mpmc_mutex.cpp
test_queue_mpmc_mutex_small.cpp
test_queue_spsc_atomic.cpp
test_queue_spsc_atomic_small.cpp
test_queue_spsc_isr.cpp
test_queue_spsc_isr_small.cpp
test_queue_spsc_locked.cpp
test_queue_spsc_locked_small.cpp
test_random.cpp
test_reference_flat_map.cpp
test_reference_flat_multimap.cpp
test_reference_flat_multiset.cpp
test_reference_flat_set.cpp
test_rescale.cpp
test_result.cpp
test_rms.cpp
test_scaled_rounding.cpp
test_set.cpp
test_shared_message.cpp
test_singleton.cpp
test_smallest.cpp
test_span_dynamic_extent.cpp
test_span_fixed_extent.cpp
test_stack.cpp
test_standard_deviation.cpp
test_state_chart.cpp
test_state_chart_with_data_parameter.cpp
test_state_chart_with_rvalue_data_parameter.cpp
test_state_chart_compile_time.cpp
test_state_chart_compile_time_with_data_parameter.cpp
test_string_char.cpp
test_string_char_external_buffer.cpp
test_string_stream.cpp
test_string_stream_u16.cpp
test_string_stream_u32.cpp
test_string_stream_wchar_t.cpp
test_string_u16.cpp
test_string_u16_external_buffer.cpp
test_string_u32.cpp
test_string_u32_external_buffer.cpp
test_string_utilities.cpp
test_string_utilities_std.cpp
test_string_utilities_std_u16.cpp
test_string_utilities_std_u32.cpp
test_string_utilities_std_wchar_t.cpp
test_string_utilities_u16.cpp
test_string_utilities_u32.cpp
test_string_utilities_wchar_t.cpp
test_string_view.cpp
test_string_wchar_t.cpp
test_string_wchar_t_external_buffer.cpp
test_successor.cpp
test_task_scheduler.cpp
test_threshold.cpp
test_to_arithmetic.cpp
test_to_arithmetic_u16.cpp
test_to_arithmetic_u32.cpp
test_to_arithmetic_wchar_t.cpp
test_to_string.cpp
test_to_u16string.cpp
test_to_u32string.cpp
test_to_wstring.cpp
test_type_def.cpp
test_type_lookup.cpp
test_type_select.cpp
test_type_traits.cpp
test_unaligned_type.cpp
test_unaligned_type_constexpr.cpp
test_unordered_map.cpp
test_unordered_multimap.cpp
test_unordered_multiset.cpp
test_unordered_set.cpp
test_user_type.cpp
test_utility.cpp
test_variance.cpp
test_variant_legacy.cpp
test_variant_variadic.cpp
test_variant_pool.cpp
test_variant_pool_external_buffer.cpp
test_vector.cpp
test_vector_external_buffer.cpp
test_vector_non_trivial.cpp
test_vector_pointer.cpp
test_vector_pointer_external_buffer.cpp
test_visitor.cpp
test_xor_checksum.cpp
test_xor_rotate_checksum.cpp
)
target_compile_definitions(etl_tests PRIVATE -DETL_DEBUG)
@ -371,6 +105,7 @@ if ((CMAKE_CXX_COMPILER_ID MATCHES "GNU") OR (CMAKE_CXX_COMPILER_ID MATCHES "Cla
-Wall
-Wextra
-Werror
-Wsign-conversion
)
if (ETL_ENABLE_SANITIZER)

460
test/test_base64.cpp
View File

@ -38,6 +38,8 @@ SOFTWARE.
#include <vector>
#include <algorithm>
#include "etl/integral_limits.h"
namespace
{
std::array<unsigned char, 256> input_data_unsigned_char =
@ -343,198 +345,109 @@ namespace
SUITE(test_base64)
{
//*************************************************************************
TEST(test_encode_unsigned_char_pointer_size)
{
std::array<char, 344U> encoded_output;
////*************************************************************************
//TEST(test_encode_unsigned_char_pointer_size)
//{
// std::array<char, 344U> 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 = etl::base64::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_pointer)
{
std::array<char, 344U> encoded_output;
////*************************************************************************
//TEST(test_encode_unsigned_char_pointer_size_no_output_length)
//{
// std::array<char, 344U> 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(), input_data_unsigned_char.data() + i,
encoded_output.data(), encoded_output.data() + encoded_output.size());
// auto size = etl::base64::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_span)
{
std::array<char, 344U> encoded_output;
////*************************************************************************
//TEST(test_encode_unsigned_char_pointer_size_to_back_inserter)
//{
// for (size_t i = 0; i < 256; ++i)
// {
// std::string actual;
for (size_t i = 0; i < 256; ++i)
{
encoded_output.fill(0);
// auto size = etl::base64::encode(input_data_unsigned_char.data(), i,
// etl::back_inserter(actual));
etl::span<const unsigned char> input_span(input_data_unsigned_char.data(), i);
etl::span<char> output_span(encoded_output.data(), encoded_output.size());
// std::string expected(encoded[i]);
//
// CHECK_EQUAL(expected, actual);
// CHECK_EQUAL(etl::base64::encoded_size(i), size);
// }
//}
auto size = etl::base64::encode(input_span, output_span);
////*************************************************************************
//TEST(test_encode_unsigned_char_pointer_pointer)
//{
// std::array<char, 344U> encoded_output;
std::string expected(encoded[i]);
std::string actual(encoded_output.data(), size);
// for (size_t i = 0; i < 256; ++i)
// {
// encoded_output.fill(0);
CHECK_EQUAL(expected, actual);
CHECK_EQUAL(etl::base64::encoded_size(i), size);
}
}
// 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());
//*************************************************************************
TEST(test_encode_unsigned_char_pointer_size_to_etl_string)
{
etl::string<344U> encoded_output;
// std::string expected(encoded[i]);
// std::string actual(encoded_output.data(), size);
for (size_t i = 0; i < 256; ++i)
{
encoded_output.clear();
// CHECK_EQUAL(expected, actual);
// CHECK_EQUAL(etl::base64::encoded_size(i), size);
// }
//}
auto size = etl::base64::encode(input_data_unsigned_char.data(), i,
encoded_output);
////*************************************************************************
//TEST(test_encode_unsigned_char_pointer_pointer_no_output_end_pointer)
//{
// std::array<char, 344U> encoded_output;
std::string expected(encoded[i]);
std::string actual(encoded_output.data(), size);
// for (size_t i = 6; i < 256; ++i)
// {
// encoded_output.fill(0);
CHECK_EQUAL(expected, actual);
CHECK_EQUAL(etl::base64::encoded_size(i), size);
}
}
// auto size = etl::base64::encode(input_data_unsigned_char.data(), input_data_unsigned_char.data() + i,
// encoded_output.data());
//*************************************************************************
TEST(test_encode_unsigned_char_pointer_pointer_to_etl_string)
{
etl::string<344U> encoded_output;
// std::string expected(encoded[i]);
// std::string actual(encoded_output.data(), size);
for (size_t i = 0; i < 256; ++i)
{
encoded_output.clear();
auto size = etl::base64::encode(input_data_unsigned_char.data(), input_data_unsigned_char.data() + i,
encoded_output);
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_unsigned_char_span_to_etl_string)
{
etl::string<344U> encoded_output;
for (size_t i = 0; i < 256; ++i)
{
encoded_output.clear();
etl::span<const unsigned char> input_span(input_data_unsigned_char.data(), i);
auto size = etl::base64::encode(input_span,
encoded_output);
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_to_etl_string)
{
etl::string<344U> encoded_output;
for (size_t i = 0; i < 256; ++i)
{
encoded_output.clear();
auto size = etl::base64::encode(input_data_int8_t.data(), i,
encoded_output);
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_pointer_to_etl_string)
{
etl::string<344U> encoded_output;
for (size_t i = 0; i < 256; ++i)
{
encoded_output.clear();
auto size = etl::base64::encode(input_data_int8_t.data(), input_data_int8_t.data() + i,
encoded_output);
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_span_to_etl_string)
{
etl::string<344U> encoded_output;
for (size_t i = 0; i < 256; ++i)
{
encoded_output.clear();
etl::span<const int8_t> input_span(input_data_int8_t.data(), i);
auto size = etl::base64::encode(input_span,
encoded_output);
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_int8_t_pointer_size)
{
std::array<char, 344U> encoded_output;
for (size_t i = 0; i < 256; ++i)
for (size_t i = 11; i < 256; ++i)
{
encoded_output.fill(0);
@ -550,16 +463,16 @@ namespace
}
//*************************************************************************
TEST(test_encode_int8_t_pointer_pointer)
TEST(test_encode_int8_t_pointer_size_no_output_length)
{
std::array<char, 344U> encoded_output;
for (size_t i = 0; i < 256; ++i)
for (size_t i = 6; i < 256; ++i)
{
encoded_output.fill(0);
auto size = etl::base64::encode(input_data_int8_t.data(), input_data_int8_t.data() + i,
encoded_output.data(), encoded_output.data() + encoded_output.size());
auto size = etl::base64::encode(input_data_int8_t.data(), i,
encoded_output.data());
std::string expected(encoded[i]);
std::string actual(encoded_output.data(), size);
@ -570,7 +483,24 @@ namespace
}
//*************************************************************************
TEST(test_encode_int8_t_span)
TEST(test_encode_int8_t_pointer_size_to_back_inserter)
{
for (size_t i = 0; i < 256; ++i)
{
std::string actual;
auto size = etl::base64::encode(input_data_int8_t.data(), i,
etl::back_inserter(actual));
std::string expected(encoded[i]);
CHECK_EQUAL(expected, actual);
CHECK_EQUAL(etl::base64::encoded_size(i), size);
}
}
//*************************************************************************
TEST(test_encode_int8_t_pointer_pointer)
{
std::array<char, 344U> encoded_output;
@ -578,10 +508,28 @@ namespace
{
encoded_output.fill(0);
etl::span<const int8_t> input_span(input_data_int8_t.data(), i);
etl::span<char> output_span(encoded_output.data(), encoded_output.size());
auto size = etl::base64::encode(input_data_int8_t.data(), input_data_int8_t.data() + i,
encoded_output.data(), encoded_output.data() + encoded_output.size());
auto size = etl::base64::encode(input_span, output_span);
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_pointer_no_end_pointer)
{
std::array<char, 344U> 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,
encoded_output.data());
std::string expected(encoded[i]);
std::string actual(encoded_output.data(), size);
@ -600,7 +548,7 @@ namespace
etl::array<char, etl::base64::encoded_size(Size)> output{ 0 };
etl::base64::encode(input.begin(), Size,
output._buffer, encoded_size);
output._buffer, encoded_size);
return output;
}
@ -625,19 +573,12 @@ namespace
std::array<char, 1> encoded_output{ 0 };
CHECK_THROW((etl::base64::encode(input_data_unsigned_char.data(), 10,
encoded_output.data(), encoded_output.size())), etl::base64_overflow);
encoded_output.data(), encoded_output.size())),
etl::base64_overflow);
}
//*************************************************************************
TEST(test_encode_overflow_for_etl_string)
{
etl::string<10> output;
CHECK_THROW((etl::base64::encode(input_data_unsigned_char.data(), 10, output)), etl::base64_overflow);
}
//*************************************************************************
TEST(test_decode_unsigned_char)
TEST(test_decode_unsigned_char_pointer_size)
{
std::array<unsigned char, 256> decoded_output;
@ -645,8 +586,8 @@ namespace
{
decoded_output.fill(0);
auto decoded_size = etl::base64::decode(encoded[i].data(), encoded[i].size(),
decoded_output.data(), decoded_output.size());
auto decoded_size = etl::base64::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);
CHECK_EQUAL(i, etl::base64::decoded_size(encoded[i].data(), encoded[i].size()));
@ -655,7 +596,61 @@ namespace
}
//*************************************************************************
TEST(test_decode_int8_t)
TEST(test_decode_unsigned_char_pointer_size_no_end_pointer)
{
std::array<unsigned char, 256> 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(),
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, decoded_size);
}
}
//*************************************************************************
TEST(test_decode_unsigned_char_pointer_pointer)
{
std::array<unsigned char, 256> 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(),
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, decoded_size);
}
}
//*************************************************************************
TEST(test_decode_unsigned_char_pointer_pointer_no_end_pointer)
{
std::array<unsigned char, 256> 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(),
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, decoded_size);
}
}
//*************************************************************************
TEST(test_decode_int8_t_pointer_size)
{
std::array<int8_t, 256> decoded_output;
@ -672,6 +667,96 @@ namespace
}
}
//*************************************************************************
TEST(test_decode_int8_t_pointer_size_back_inserter)
{
std::vector<int8_t> 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(),
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, decoded_size);
}
}
//*************************************************************************
TEST(test_decode_int8_t_pointer_size_no_output_size)
{
std::array<int8_t, 256> 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(),
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, decoded_size);
}
}
//*************************************************************************
TEST(test_decode_int8_t_pointer_pointer)
{
std::array<int8_t, 256> 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(),
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, decoded_size);
}
}
//*************************************************************************
TEST(test_decode_int8_t_pointer_pointer_back_inserter)
{
std::vector<int8_t> 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(),
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, decoded_size);
}
}
//*************************************************************************
TEST(test_decode_int8_t_pointer_pointer_no_end_pointer)
{
std::array<int8_t, 256> 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(),
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, decoded_size);
}
}
//*************************************************************************
TEST(test_decode_overflow)
{
@ -689,9 +774,6 @@ namespace
size_t length = etl::base64::decoded_size(encoded[i].data(), encoded[i].size());
CHECK_EQUAL(length, etl::base64::decoded_size(encoded[i].data(), encoded[i].data() + encoded[i].size()));
etl::span<const char> sp(encoded[i].data(), encoded[i].size());
CHECK_EQUAL(length, etl::base64::decoded_size(sp));
}
}
};