tests/unittests: Extend & clean up base64 tests
- Added unit test for `base64_estimate_{de,en}code_size()`
- Mark constant stuff as `const`
- Use `memcmp()` for comparing memory
- Do not use variable size arrays
- Various code style issue
This commit is contained in:
Marian Buschsieweke
parent
e3ea4943af
commit
4e6ec3493f
@ -20,16 +20,17 @@
|
||||
|
||||
static void test_base64_01_encode_string(void)
|
||||
{
|
||||
unsigned char data_in[] = "Hello RIOT this is a base64 test!\n"
|
||||
"This should work as intended.";
|
||||
static const char data_in[] = "Hello RIOT this is a base64 test!\n"
|
||||
"This should work as intended.";
|
||||
|
||||
unsigned char expected_encoding[] = "SGVsbG8gUklPVCB0aGlzIGlzIGEgYmFzZTY0IHR"
|
||||
"lc3QhClRoaXMgc2hvdWxkIHdvcmsgYXMgaW50ZW5kZWQu";
|
||||
static const char expected_encoding[] =
|
||||
"SGVsbG8gUklPVCB0aGlzIGlzIGEgYmFzZTY0IHR"
|
||||
"lc3QhClRoaXMgc2hvdWxkIHdvcmsgYXMgaW50ZW5kZWQu";
|
||||
|
||||
size_t data_in_size = strlen((char *)data_in);
|
||||
size_t data_in_size = strlen(data_in);
|
||||
|
||||
size_t base64_out_size = 0;
|
||||
unsigned char base64_out[ strlen((char *)expected_encoding) ];
|
||||
char base64_out[sizeof(expected_encoding)];
|
||||
|
||||
/*
|
||||
* @Note:
|
||||
@ -46,34 +47,34 @@ static void test_base64_01_encode_string(void)
|
||||
|
||||
TEST_ASSERT_EQUAL_INT(BASE64_SUCCESS, ret);
|
||||
|
||||
for (int i = 0; i < (int)base64_out_size; ++i) {
|
||||
TEST_ASSERT_MESSAGE(base64_out[i] == expected_encoding[i], \
|
||||
"encoding failed!(produced unexpected output)");
|
||||
}
|
||||
TEST_ASSERT_MESSAGE((0 == memcmp(expected_encoding, base64_out,
|
||||
base64_out_size)),
|
||||
"encoding failed!(produced unexpected output)");
|
||||
|
||||
#if (TEST_BASE64_SHOW_OUTPUT == 1)
|
||||
puts("Test 01 Encoded:");
|
||||
|
||||
for (int i = 0; i < (int)base64_out_size; ++i) {
|
||||
for (size_t i = 0; i < base64_out_size; ++i) {
|
||||
printf("%c", base64_out[i]);
|
||||
}
|
||||
|
||||
printf("\nFrom:\n%s\n", (char *)data_in);
|
||||
printf("\nFrom:\n%s\n", data_in);
|
||||
#endif
|
||||
}
|
||||
|
||||
static void test_base64_02_decode_base64(void)
|
||||
{
|
||||
unsigned char encoded_base64[] = "SGVsbG8gUklPVCB0aGlzIGlzIGEgYmFzZTY0IHRlc3Q"
|
||||
"hClRoaXMgc2hvdWxkIHdvcmsgYXMgaW50ZW5kZWQu";
|
||||
static const char encoded_base64[] =
|
||||
"SGVsbG8gUklPVCB0aGlzIGlzIGEgYmFzZTY0IHRlc3Q"
|
||||
"hClRoaXMgc2hvdWxkIHdvcmsgYXMgaW50ZW5kZWQu";
|
||||
|
||||
unsigned char expected_string[] = "Hello RIOT this is a base64 test!\n"
|
||||
"This should work as intended.";
|
||||
static const char expected_string[] = "Hello RIOT this is a base64 test!\n"
|
||||
"This should work as intended.";
|
||||
|
||||
size_t base64_size = strlen((char *)encoded_base64);
|
||||
size_t base64_size = strlen(encoded_base64);
|
||||
|
||||
size_t data_out_size = 0;
|
||||
unsigned char data_out[ strlen((char *)expected_string) ];
|
||||
unsigned char data_out[sizeof(expected_string)];
|
||||
|
||||
int ret = base64_decode(encoded_base64, base64_size, NULL, &data_out_size);
|
||||
TEST_ASSERT_EQUAL_INT(BASE64_ERROR_BUFFER_OUT_SIZE, ret);
|
||||
@ -84,51 +85,49 @@ static void test_base64_02_decode_base64(void)
|
||||
ret = base64_decode(encoded_base64, base64_size, data_out, &data_out_size);
|
||||
TEST_ASSERT_EQUAL_INT(BASE64_SUCCESS, ret);
|
||||
|
||||
for (int i = 0; i < (int)data_out_size; ++i) {
|
||||
TEST_ASSERT_MESSAGE(data_out[i] == expected_string[i], \
|
||||
"decoding failed!(produced unexpected output)");
|
||||
}
|
||||
TEST_ASSERT_MESSAGE((0 == memcmp(expected_string, data_out,
|
||||
data_out_size)),
|
||||
"decoding failed!(produced unexpected output)");
|
||||
|
||||
#if (TEST_BASE64_SHOW_OUTPUT == 1)
|
||||
puts("Test 02 Decoded:");
|
||||
|
||||
for (int i = 0; i < (int)data_out_size; ++i) {
|
||||
for (size_t i = 0; i < data_out_size; ++i) {
|
||||
printf("%c", data_out[i]);
|
||||
}
|
||||
|
||||
printf("\nFrom:\n%s\n", (char *)encoded_base64);
|
||||
printf("\nFrom:\n%s\n", encoded_base64);
|
||||
#endif
|
||||
}
|
||||
|
||||
static void test_base64_03_single_character(void)
|
||||
{
|
||||
size_t element_size = 1;
|
||||
unsigned char element[] = "1";
|
||||
static const char element[] = "1";
|
||||
|
||||
size_t elementDecodeSize = 3;
|
||||
unsigned char elementDecode[3];
|
||||
unsigned char element_decode[3];
|
||||
size_t element_decode_size = sizeof(element_decode);
|
||||
|
||||
size_t element_base64_out_size = 10;
|
||||
unsigned char element_base64_out[10];
|
||||
size_t element_base64_out_size = sizeof(element_base64_out);
|
||||
|
||||
int ret = base64_encode(element, element_size, \
|
||||
int ret = base64_encode(element, element_size,
|
||||
element_base64_out, &element_base64_out_size);
|
||||
TEST_ASSERT_EQUAL_INT(BASE64_SUCCESS, ret);
|
||||
|
||||
ret = base64_decode(element_base64_out, element_base64_out_size, \
|
||||
elementDecode, &elementDecodeSize);
|
||||
ret = base64_decode(element_base64_out, element_base64_out_size,
|
||||
element_decode, &element_decode_size);
|
||||
TEST_ASSERT_EQUAL_INT(BASE64_SUCCESS, ret);
|
||||
|
||||
for (int i = 0; i < (int)elementDecodeSize; ++i) {
|
||||
TEST_ASSERT_MESSAGE(element[i] == elementDecode[i], \
|
||||
"decoding failed!(produced unexpected output)");
|
||||
}
|
||||
TEST_ASSERT_MESSAGE((0 == memcmp(element, element_decode,
|
||||
element_decode_size)),
|
||||
"encoding failed!(produced unexpected output)");
|
||||
}
|
||||
|
||||
static void test_base64_04_free_conversion(void)
|
||||
{
|
||||
size_t elements = 255;
|
||||
unsigned char elm[elements];
|
||||
char elm[elements];
|
||||
|
||||
size_t elem_base64_out_size = 0;
|
||||
unsigned char elm_base64_out[((elements / 3) * 4) + (elements / 10)];
|
||||
@ -137,7 +136,7 @@ static void test_base64_04_free_conversion(void)
|
||||
unsigned char elem_base64_out_decoded[ elements + 10 ];
|
||||
|
||||
/* fill some values */
|
||||
for (int i = 0; i < (int)elements; ++i) {
|
||||
for (size_t i = 0; i < elements; ++i) {
|
||||
elm[i] = i;
|
||||
}
|
||||
|
||||
@ -147,33 +146,33 @@ static void test_base64_04_free_conversion(void)
|
||||
ret = base64_encode(elm, elements, elm_base64_out, &elem_base64_out_size);
|
||||
TEST_ASSERT_EQUAL_INT(BASE64_SUCCESS, ret);
|
||||
|
||||
ret = base64_decode(elm_base64_out, elem_base64_out_size, \
|
||||
ret = base64_decode(elm_base64_out, elem_base64_out_size,
|
||||
NULL, &elem_base64_out_decoded_size);
|
||||
TEST_ASSERT_EQUAL_INT(BASE64_ERROR_BUFFER_OUT_SIZE, ret);
|
||||
|
||||
ret = base64_decode(elm_base64_out, elem_base64_out_size, \
|
||||
ret = base64_decode(elm_base64_out, elem_base64_out_size,
|
||||
elem_base64_out_decoded, &elem_base64_out_decoded_size);
|
||||
TEST_ASSERT_EQUAL_INT(BASE64_SUCCESS, ret);
|
||||
|
||||
for (int i = 0; i < (int)elements; ++i) {
|
||||
TEST_ASSERT_MESSAGE(elem_base64_out_decoded[i] == elm[i], \
|
||||
"decoding failed!(produced unexpected output)");
|
||||
}
|
||||
TEST_ASSERT_MESSAGE((0 == memcmp(elem_base64_out_decoded, elm,
|
||||
elements)),
|
||||
"decoding failed!(produced unexpected output)");
|
||||
}
|
||||
|
||||
static void test_base64_05_decode_larger(void)
|
||||
{
|
||||
unsigned char decodeit[] = "SG93IG11Y2ggd29vZCB3b3VsZCBhIHdvb2RjaHVjayBjaHVj"
|
||||
"awppZiBhIHdvb2RjaHVjayBjb3VsZCBjaHVjayB3b29kPwpI"
|
||||
"ZSB3b3VsZCBjaHVjaywgaGUgd291bGQsIGFzIG11Y2ggYXMg"
|
||||
"aGUgY291bGQsCmFuZCBjaHVjayBhcyBtdWNoIHdvb2QgYXMg"
|
||||
"YSB3b29kY2h1Y2sgd291bGQKaWYgYSB3b29kY2h1Y2sgY291"
|
||||
"bGQgY2h1Y2sgd29vZC4==";
|
||||
static const char decodeit[] =
|
||||
"SG93IG11Y2ggd29vZCB3b3VsZCBhIHdvb2RjaHVjayBjaHVj"
|
||||
"awppZiBhIHdvb2RjaHVjayBjb3VsZCBjaHVjayB3b29kPwpI"
|
||||
"ZSB3b3VsZCBjaHVjaywgaGUgd291bGQsIGFzIG11Y2ggYXMg"
|
||||
"aGUgY291bGQsCmFuZCBjaHVjayBhcyBtdWNoIHdvb2QgYXMg"
|
||||
"YSB3b29kY2h1Y2sgd291bGQKaWYgYSB3b29kY2h1Y2sgY291"
|
||||
"bGQgY2h1Y2sgd29vZC4==";
|
||||
|
||||
size_t data_size = 199;
|
||||
unsigned char data[data_size];
|
||||
char data[data_size];
|
||||
|
||||
size_t decodeit_size = strlen((char *)decodeit);
|
||||
size_t decodeit_size = strlen(decodeit);
|
||||
|
||||
int ret = base64_decode(decodeit, decodeit_size, data, &data_size);
|
||||
TEST_ASSERT_EQUAL_INT(BASE64_SUCCESS, ret);
|
||||
@ -181,11 +180,11 @@ static void test_base64_05_decode_larger(void)
|
||||
#if (TEST_BASE64_SHOW_OUTPUT == 1)
|
||||
puts("Test 05 Decoded:");
|
||||
|
||||
for (int i = 0; i < (int)data_size; ++i) {
|
||||
for (size_t i = 0; i < data_size; ++i) {
|
||||
printf("%c", data[i]);
|
||||
}
|
||||
|
||||
printf("\nFrom:\n%s\n", (char *)decodeit);
|
||||
printf("\nFrom:\n%s\n", decodeit);
|
||||
#endif
|
||||
}
|
||||
|
||||
@ -202,25 +201,26 @@ static void test_base64_06_stream_encode(void)
|
||||
*
|
||||
*/
|
||||
|
||||
unsigned char stream_encode[] = "Peter Piper picked a peck of pickled peppers."
|
||||
"\nA peck of pickled peppers Peter Piper picked."
|
||||
"\nIf Peter Piper picked a peck of pickled peppers,"
|
||||
"\nWhere's the peck of pickled peppers Peter Piper picked?";
|
||||
static const char stream_encode[] =
|
||||
"Peter Piper picked a peck of pickled peppers.\n"
|
||||
"A peck of pickled peppers Peter Piper picked.\n"
|
||||
"If Peter Piper picked a peck of pickled peppers,\n"
|
||||
"Where's the peck of pickled peppers Peter Piper picked?";
|
||||
|
||||
/* required output size +2 extra bytes */
|
||||
size_t encoded_size = 264 + 2;
|
||||
/* cppcheck-suppress unassignedVariable
|
||||
* (reason: the above array is used/assigned in base64_encode() using its pointer) */
|
||||
unsigned char encode_result[encoded_size];
|
||||
char encode_result[encoded_size];
|
||||
|
||||
int remain = strlen((char *)stream_encode);
|
||||
int remain = strlen(stream_encode);
|
||||
int out_iter = 0;
|
||||
|
||||
int ret = BASE64_SUCCESS;
|
||||
|
||||
for (int i = 3; i < remain; (i += 3)) {
|
||||
size_t size_used = encoded_size - out_iter;
|
||||
ret = base64_encode(stream_encode + (strlen((char *)stream_encode) - remain), \
|
||||
ret = base64_encode(stream_encode + (strlen(stream_encode) - remain),
|
||||
i, encode_result + out_iter, &size_used);
|
||||
TEST_ASSERT_EQUAL_INT(BASE64_SUCCESS, ret);
|
||||
|
||||
@ -230,7 +230,7 @@ static void test_base64_06_stream_encode(void)
|
||||
|
||||
/* this final chunk we want to encode and append is prime to 3 */
|
||||
size_t finish = encoded_size - out_iter;
|
||||
ret = base64_encode(stream_encode + (strlen((char *)stream_encode) - remain), \
|
||||
ret = base64_encode(stream_encode + (strlen(stream_encode) - remain),
|
||||
remain, encode_result + out_iter, &finish);
|
||||
TEST_ASSERT_EQUAL_INT(BASE64_SUCCESS, ret);
|
||||
|
||||
@ -238,11 +238,11 @@ static void test_base64_06_stream_encode(void)
|
||||
out_iter += finish;
|
||||
puts("Test 06 Encoded:");
|
||||
|
||||
for (int i = 0; i < (int)out_iter; ++i) {
|
||||
for (size_t i = 0; i < out_iter; ++i) {
|
||||
printf("%c", encode_result[i]);
|
||||
}
|
||||
|
||||
printf("\nFrom:\n%s\n", (char *)stream_encode);
|
||||
printf("\nFrom:\n%s\n", stream_encode);
|
||||
#endif
|
||||
}
|
||||
|
||||
@ -255,21 +255,22 @@ static void test_base64_07_stream_decode(void)
|
||||
* The chunks passed to decode MUST be dividable by 4.
|
||||
*/
|
||||
|
||||
unsigned char encoded[] = "UGV0ZXIgUGlwZXIgcGlja2VkIGEgcGVjayBvZiBwaWNrbGVkIH"
|
||||
"BlcHBlcnMuCkEgcGVjayBvZiBwaWNrbGVkIHBlcHBlcnMgUGV0"
|
||||
"ZXIgUGlwZXIgcGlja2VkLgpJZiBQZXRlciBQaXBlciBwaWNrZW"
|
||||
"QgYSBwZWNrIG9mIHBpY2tsZWQgcGVwcGVycywKV2hlcmUncyB0"
|
||||
"aGUgcGVjayBvZiBwaWNrbGVkIHBlcHBlcnMgUGV0ZXIgUGlwZX"
|
||||
"IgcGlja2VkPw==";
|
||||
static const char encoded[] =
|
||||
"UGV0ZXIgUGlwZXIgcGlja2VkIGEgcGVjayBvZiBwaWNrbGVkIH"
|
||||
"BlcHBlcnMuCkEgcGVjayBvZiBwaWNrbGVkIHBlcHBlcnMgUGV0"
|
||||
"ZXIgUGlwZXIgcGlja2VkLgpJZiBQZXRlciBQaXBlciBwaWNrZW"
|
||||
"QgYSBwZWNrIG9mIHBpY2tsZWQgcGVwcGVycywKV2hlcmUncyB0"
|
||||
"aGUgcGVjayBvZiBwaWNrbGVkIHBlcHBlcnMgUGV0ZXIgUGlwZX"
|
||||
"IgcGlja2VkPw==";
|
||||
|
||||
/* required output size +2 extra bytes */
|
||||
size_t decoded_size = 196 + 2;
|
||||
|
||||
/* cppcheck-suppress unassignedVariable
|
||||
* (reason: the above array is used/assigned in base64_decode() using its pointer) */
|
||||
unsigned char stream_decoded[decoded_size];
|
||||
char stream_decoded[decoded_size];
|
||||
|
||||
size_t encoded_size = strlen((char *)encoded);
|
||||
size_t encoded_size = strlen(encoded);
|
||||
int remain = encoded_size;
|
||||
int out_iter = 0;
|
||||
|
||||
@ -277,7 +278,7 @@ static void test_base64_07_stream_decode(void)
|
||||
|
||||
for (int i = 4; i < remain; (i += 4)) {
|
||||
size_t size_used = decoded_size - out_iter;
|
||||
ret = base64_decode(encoded + (encoded_size - remain), \
|
||||
ret = base64_decode(encoded + (encoded_size - remain),
|
||||
i, stream_decoded + out_iter, &size_used);
|
||||
TEST_ASSERT_EQUAL_INT(BASE64_SUCCESS, ret);
|
||||
|
||||
@ -286,7 +287,7 @@ static void test_base64_07_stream_decode(void)
|
||||
}
|
||||
|
||||
size_t finish = decoded_size - out_iter;
|
||||
ret = base64_decode(encoded + (encoded_size - remain), \
|
||||
ret = base64_decode(encoded + (encoded_size - remain),
|
||||
remain, stream_decoded + out_iter, &finish);
|
||||
TEST_ASSERT_EQUAL_INT(BASE64_SUCCESS, ret);
|
||||
|
||||
@ -294,38 +295,35 @@ static void test_base64_07_stream_decode(void)
|
||||
out_iter += finish;
|
||||
puts("Test 07 Decoded:");
|
||||
|
||||
for (int i = 0; i < (int)out_iter; ++i) {
|
||||
for (size_t i = 0; i < out_iter; ++i) {
|
||||
printf("%c", stream_decoded[i]);
|
||||
}
|
||||
|
||||
printf("\nFrom:\n%s\n", (char *)encoded);
|
||||
printf("\nFrom:\n%s\n", encoded);
|
||||
#endif
|
||||
}
|
||||
|
||||
static void test_base64_08_encode_16_bytes(void)
|
||||
{
|
||||
/* FIXME: init as enum here and below required,
|
||||
* to fix folding-constant compiler error on OS X
|
||||
*/
|
||||
enum { buffer_size = 16 };
|
||||
unsigned char buffer[buffer_size];
|
||||
for (int i = 0; i < buffer_size; ++i) {
|
||||
unsigned char buffer[16];
|
||||
size_t buffer_size = sizeof(buffer);
|
||||
for (size_t i = 0; i < buffer_size; ++i) {
|
||||
buffer[i] = 'a';
|
||||
}
|
||||
|
||||
enum { expected_out_size = 24 };
|
||||
char element_base64_out[24];
|
||||
size_t expected_out_size = sizeof(element_base64_out);
|
||||
size_t element_base64_out_size = expected_out_size;
|
||||
unsigned char element_base64_out[expected_out_size];
|
||||
|
||||
size_t required_out_size = 0;
|
||||
int ret = base64_encode(buffer, buffer_size, \
|
||||
int ret = base64_encode(buffer, buffer_size,
|
||||
element_base64_out, &required_out_size);
|
||||
|
||||
TEST_ASSERT_EQUAL_INT(BASE64_ERROR_BUFFER_OUT_SIZE, ret);
|
||||
TEST_ASSERT_EQUAL_INT(required_out_size, expected_out_size);
|
||||
|
||||
ret = base64_encode(buffer, buffer_size, \
|
||||
element_base64_out, &element_base64_out_size);
|
||||
ret = base64_encode(buffer, buffer_size,
|
||||
element_base64_out, &element_base64_out_size);
|
||||
|
||||
TEST_ASSERT_EQUAL_INT(BASE64_SUCCESS, ret);
|
||||
TEST_ASSERT_EQUAL_INT(expected_out_size, element_base64_out_size);
|
||||
@ -345,22 +343,22 @@ static void test_base64_09_encode_size_determination(void)
|
||||
|
||||
// test 20 bytes input, expected 28 bytes output
|
||||
size_t required_out_size = 0;
|
||||
int ret = base64_encode(buffer, buffer_size, \
|
||||
int ret = base64_encode(buffer, buffer_size,
|
||||
element_base64_out, &required_out_size);
|
||||
|
||||
TEST_ASSERT_EQUAL_INT(BASE64_ERROR_BUFFER_OUT_SIZE, ret);
|
||||
TEST_ASSERT_EQUAL_INT(required_out_size, expected_out_size);
|
||||
|
||||
ret = base64_encode(buffer, buffer_size, \
|
||||
element_base64_out, &element_base64_out_size);
|
||||
ret = base64_encode(buffer, buffer_size,
|
||||
element_base64_out, &element_base64_out_size);
|
||||
|
||||
TEST_ASSERT_EQUAL_INT(BASE64_SUCCESS, ret);
|
||||
TEST_ASSERT_EQUAL_INT(expected_out_size, element_base64_out_size);
|
||||
|
||||
// test 19 bytes input, expected 28 bytes output
|
||||
required_out_size = 0;
|
||||
ret = base64_encode(buffer, 19, \
|
||||
element_base64_out, &required_out_size);
|
||||
ret = base64_encode(buffer, 19,
|
||||
element_base64_out, &required_out_size);
|
||||
|
||||
TEST_ASSERT_EQUAL_INT(BASE64_ERROR_BUFFER_OUT_SIZE, ret);
|
||||
TEST_ASSERT_EQUAL_INT(required_out_size, expected_out_size);
|
||||
@ -368,8 +366,8 @@ static void test_base64_09_encode_size_determination(void)
|
||||
// test 18 bytes input, expected 24 bytes output
|
||||
expected_out_size = 24;
|
||||
required_out_size = 0;
|
||||
ret = base64_encode(buffer, 18, \
|
||||
element_base64_out, &required_out_size);
|
||||
ret = base64_encode(buffer, 18,
|
||||
element_base64_out, &required_out_size);
|
||||
|
||||
TEST_ASSERT_EQUAL_INT(BASE64_ERROR_BUFFER_OUT_SIZE, ret);
|
||||
TEST_ASSERT_EQUAL_INT(required_out_size, expected_out_size);
|
||||
@ -377,8 +375,8 @@ static void test_base64_09_encode_size_determination(void)
|
||||
// test 17 bytes input, expected 24 bytes output
|
||||
expected_out_size = 24;
|
||||
required_out_size = 0;
|
||||
ret = base64_encode(buffer, 17, \
|
||||
element_base64_out, &required_out_size);
|
||||
ret = base64_encode(buffer, 17,
|
||||
element_base64_out, &required_out_size);
|
||||
|
||||
TEST_ASSERT_EQUAL_INT(BASE64_ERROR_BUFFER_OUT_SIZE, ret);
|
||||
TEST_ASSERT_EQUAL_INT(required_out_size, expected_out_size);
|
||||
@ -416,7 +414,7 @@ static void test_base64_11_urlsafe_encode_int(void)
|
||||
unsigned char expected_encoding[] = "-RAAAA==";
|
||||
|
||||
size_t base64_out_size = 0;
|
||||
unsigned char base64_out[ strlen((char *)expected_encoding) ];
|
||||
char base64_out[sizeof(expected_encoding)];
|
||||
|
||||
/*
|
||||
* @Note:
|
||||
@ -425,23 +423,22 @@ static void test_base64_11_urlsafe_encode_int(void)
|
||||
* This size is a lower bound estimation,
|
||||
* thus it can require few more bytes then the actual used size for the output.
|
||||
*/
|
||||
int ret = base64url_encode((void *)&data_in, sizeof(data_in), NULL, &base64_out_size);
|
||||
int ret = base64url_encode(&data_in, sizeof(data_in), NULL, &base64_out_size);
|
||||
|
||||
TEST_ASSERT_EQUAL_INT(BASE64_ERROR_BUFFER_OUT_SIZE, ret);
|
||||
|
||||
ret = base64url_encode((void *)&data_in, sizeof(data_in), base64_out, &base64_out_size);
|
||||
ret = base64url_encode(&data_in, sizeof(data_in), base64_out, &base64_out_size);
|
||||
|
||||
TEST_ASSERT_EQUAL_INT(BASE64_SUCCESS, ret);
|
||||
|
||||
for (int i = 0; i < (int)base64_out_size; ++i) {
|
||||
TEST_ASSERT_MESSAGE(base64_out[i] == expected_encoding[i], \
|
||||
"encoding failed!(produced unexpected output)");
|
||||
}
|
||||
TEST_ASSERT_MESSAGE((0 == memcmp(expected_encoding, base64_out,
|
||||
base64_out_size)),
|
||||
"encoding failed!(produced unexpected output)");
|
||||
|
||||
#if (TEST_BASE64_SHOW_OUTPUT == 1)
|
||||
puts("Test 11 Encoded:");
|
||||
|
||||
for (int i = 0; i < (int)base64_out_size; ++i) {
|
||||
for (size_t i = 0; i < base64_out_size; ++i) {
|
||||
printf("%c", base64_out[i]);
|
||||
}
|
||||
|
||||
@ -451,13 +448,13 @@ static void test_base64_11_urlsafe_encode_int(void)
|
||||
|
||||
static void test_base64_12_urlsafe_decode_int(void)
|
||||
{
|
||||
unsigned char encoded_base64[] = "_____wAA==";
|
||||
unsigned char expected[] = {0xFF, 0xFF, 0xFF, 0xFF, 0x0, 0x0};
|
||||
static const char encoded_base64[] = "_____wAA==";
|
||||
static const uint8_t expected[] = {0xFF, 0xFF, 0xFF, 0xFF, 0x0, 0x0};
|
||||
|
||||
size_t base64_size = strlen((char *)encoded_base64);
|
||||
size_t base64_size = strlen(encoded_base64);
|
||||
|
||||
size_t data_out_size = 0;
|
||||
unsigned char data_out[ sizeof(expected) ];
|
||||
unsigned char data_out[sizeof(expected)];
|
||||
|
||||
int ret = base64_decode(encoded_base64, base64_size, NULL, &data_out_size);
|
||||
TEST_ASSERT_EQUAL_INT(BASE64_ERROR_BUFFER_OUT_SIZE, ret);
|
||||
@ -468,22 +465,39 @@ static void test_base64_12_urlsafe_decode_int(void)
|
||||
ret = base64_decode(encoded_base64, base64_size, data_out, &data_out_size);
|
||||
TEST_ASSERT_EQUAL_INT(BASE64_SUCCESS, ret);
|
||||
|
||||
for (int i = 0; i < (int)data_out_size; ++i) {
|
||||
TEST_ASSERT_MESSAGE(data_out[i] == expected[i], \
|
||||
"decoding failed!(produced unexpected output)");
|
||||
}
|
||||
TEST_ASSERT_MESSAGE((0 == memcmp(expected, data_out, data_out_size)),
|
||||
"decoding failed!(produced unexpected output)");
|
||||
|
||||
#if (TEST_BASE64_SHOW_OUTPUT == 1)
|
||||
puts("Test 11 Decoded:");
|
||||
|
||||
for (int i = 0; i < (int)data_out_size; ++i) {
|
||||
for (size_t i = 0; i < data_out_size; ++i) {
|
||||
printf("%x", data_out[i]);
|
||||
}
|
||||
|
||||
printf("\nFrom:\n%x\n", (char *)encoded_base64);
|
||||
printf("\nFrom:\n%s\n", encoded_base64);
|
||||
#endif
|
||||
}
|
||||
|
||||
static void test_base64_13_size_estimation(void) {
|
||||
size_t expected = 0;
|
||||
for (size_t i = 0; i < 33; i += 3) {
|
||||
TEST_ASSERT_EQUAL_INT(expected, base64_estimate_encode_size(i + 0));
|
||||
expected += 4;
|
||||
TEST_ASSERT_EQUAL_INT(expected, base64_estimate_encode_size(i + 1));
|
||||
TEST_ASSERT_EQUAL_INT(expected, base64_estimate_encode_size(i + 2));
|
||||
}
|
||||
|
||||
expected = 0;
|
||||
for (size_t i = 0; i < 44; i += 4) {
|
||||
TEST_ASSERT_EQUAL_INT(expected, base64_estimate_decode_size(i + 0));
|
||||
expected += 3;
|
||||
TEST_ASSERT_EQUAL_INT(expected, base64_estimate_decode_size(i + 1));
|
||||
TEST_ASSERT_EQUAL_INT(expected, base64_estimate_decode_size(i + 2));
|
||||
TEST_ASSERT_EQUAL_INT(expected, base64_estimate_decode_size(i + 3));
|
||||
}
|
||||
}
|
||||
|
||||
Test *tests_base64_tests(void)
|
||||
{
|
||||
EMB_UNIT_TESTFIXTURES(fixtures) {
|
||||
@ -500,6 +514,7 @@ Test *tests_base64_tests(void)
|
||||
new_TestFixture(test_base64_10_decode_empty),
|
||||
new_TestFixture(test_base64_11_urlsafe_encode_int),
|
||||
new_TestFixture(test_base64_12_urlsafe_decode_int),
|
||||
new_TestFixture(test_base64_13_size_estimation),
|
||||
};
|
||||
|
||||
EMB_UNIT_TESTCALLER(base64_tests, NULL, NULL, fixtures);
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user