enlightenment/efl
enlightenment
/
efl
8
7
Fork 14
Code Issues 13 Pull Requests 3 Projects Releases Wiki Activity

emile: move all eina_str_base64 to emile_base64.

This commit is contained in:
Cedric BAIL 2016-01-07 15:53:12 -08:00
parent c451d5885b
commit bb921aff04
8 changed files with 390 additions and 324 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/Makefile_Emile.am
View File

@ -7,13 +7,15 @@ dist_installed_emilemainheaders_DATA = \
lib/emile/Emile.h \
lib/emile/emile_cipher.h \
lib/emile/emile_compress.h \
lib/emile/emile_image.h
lib/emile/emile_image.h \
lib/emile/emile_base64.h
lib_emile_libemile_la_SOURCES = \
lib/emile/emile_private.h \
lib/emile/emile_main.c \
lib/emile/emile_compress.c \
lib/emile/emile_image.c \
lib/emile/emile_base64.c \
static_libs/rg_etc/rg_etc1.c \
static_libs/rg_etc/rg_etc2.c \
static_libs/rg_etc/rg_etc1.h \

173
src/lib/eina/eina_str.c
View File

@ -45,10 +45,6 @@
* @cond LOCAL
*/
static const char *base64_table_normal = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/" ;
static const char *base64_table_url = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_" ;
/*
* Internal helper function used by eina_str_has_suffix() and
* eina_str_has_extension()
@ -301,151 +297,6 @@ eina_str_split_full_helper(const char *str,
return str_array;
}
static inline Eina_Bool is_base64_char(unsigned char c, Eina_Bool is_base64url)
{
if (is_base64url)
return (isalnum(c) || (c == '-') || (c == '_'));
else
return (isalnum(c) || (c == '+') || (c == '/'));
}
static char *
eina_str_base64_encode_common(const unsigned char *src, unsigned int len, Eina_Bool is_base64url_encode)
{
unsigned char inarr[3], outarr[4];
char *dest;
int i = 0, j = 0, k = 0;
const char *base64_table;
if (!src) return NULL;
// Max length of encoded string.
dest = malloc(sizeof (char) * (((len + 2) / 3) * 4 + 1));
if (!dest) return NULL;
if (is_base64url_encode)
base64_table = base64_table_url;
else
base64_table = base64_table_normal;
while (len--)
{
inarr[i++] = *(src++);
if (i == 3)
{
outarr[0] = (inarr[0] & 0xfc) >> 2;
outarr[1] = ((inarr[0] & 0x03) << 4) + ((inarr[1] & 0xf0) >> 4);
outarr[2] = ((inarr[1] & 0x0f) << 2) + ((inarr[2] & 0xc0) >> 6);
outarr[3] = inarr[2] & 0x3f;
for(i = 0; (i <4) ; i++)
dest[k++] = base64_table[outarr[i]];
i = 0;
}
}
if (i)
{
for(j = i; j < 3; j++)
inarr[j] = '\0';
outarr[0] = (inarr[0] & 0xfc) >> 2;
outarr[1] = ((inarr[0] & 0x03) << 4) + ((inarr[1] & 0xf0) >> 4);
outarr[2] = ((inarr[1] & 0x0f) << 2) + ((inarr[2] & 0xc0) >> 6);
outarr[3] = inarr[2] & 0x3f;
for (j = 0; (j < i + 1); j++)
dest[k++] = base64_table[outarr[j]];
/* No padding for URL encoding */
while((i++ < 3) && (!is_base64url_encode)) {
dest[k++] = '=';
}
}
dest[k] = '\0';
return dest;
}
static
unsigned char *eina_str_base64_decode_common(const char * src, int *decoded_str_len, Eina_Bool is_base64url_decode)
{
unsigned char inarr[4], outarr[3];
int i = 0, j = 0, k = 0, l = 0;
int len;
unsigned char *dest;
const char *base64_table;
if (!src)
goto error;
len = strlen(src);
/* The encoded string length should be a multiple of 4. Else it is not a
* valid encoded string.
*/
if (!is_base64url_decode && (len % 4))
goto error;
/* This is the max size the destination string can have.
*/
dest = (unsigned char *)malloc(sizeof(unsigned char) * ((len * 3 / 4) + 1));
if (!dest)
goto error;
if (is_base64url_decode)
base64_table = base64_table_url;
else
base64_table = base64_table_normal;
while (len-- && (src[k] != '=') && is_base64_char(src[k], is_base64url_decode))
{
inarr[i++] = src[k++];
if (i == 4)
{
for (i = 0; i <4; i++)
inarr[i] = strchr(base64_table,(int) inarr[i]) - base64_table;
outarr[0] = (inarr[0] << 2) + ((inarr[1] & 0x30) >> 4);
outarr[1] = ((inarr[1] & 0xf) << 4) + ((inarr[2] & 0x3c) >> 2);
outarr[2] = ((inarr[2] & 0x3) << 6) + inarr[3];
for (i = 0; (i < 3); i++)
dest[l++] = outarr[i];
i = 0;
}
}
if (i)
{
for (j = i; j <4; j++)
inarr[j] = 0;
for (j = 0; j <4; j++)
inarr[j] = strchr(base64_table, (int) inarr[j]) - base64_table;
outarr[0] = (inarr[0] << 2) + ((inarr[1] & 0x30) >> 4);
outarr[1] = ((inarr[1] & 0xf) << 4) + ((inarr[2] & 0x3c) >> 2);
outarr[2] = ((inarr[2] & 0x3) << 6) + inarr[3];
for (j = 0; (j < i - 1); j++)
dest[l++] = outarr[j];
}
/* This is to prevent the applications from crashing. */
dest[l] = '\0';
if (decoded_str_len)
*decoded_str_len = l;
return dest;
error:
if (decoded_str_len)
*decoded_str_len = 0;
return NULL;
}
/**
* @endcond
*/
@ -874,27 +725,3 @@ eina_memdup(unsigned char *mem, size_t size, Eina_Bool terminate)
ret[size] = 0;
return ret;
}
EAPI char *
eina_str_base64_encode(const unsigned char *src, unsigned int len)
{
return eina_str_base64_encode_common(src, len, EINA_FALSE);
}
EAPI char *
eina_str_base64url_encode(const unsigned char *src, unsigned int len)
{
return eina_str_base64_encode_common(src, len, EINA_TRUE);
}
EAPI
unsigned char *eina_str_base64_decode(const char * src, int *decoded_str_len)
{
return eina_str_base64_decode_common(src, decoded_str_len, EINA_FALSE);
}
EAPI
unsigned char *eina_str_base64url_decode(const char * src, int *decoded_str_len)
{
return eina_str_base64_decode_common(src, decoded_str_len, EINA_TRUE);
}

55
src/lib/eina/eina_str.h
View File

@ -382,61 +382,6 @@ EAPI unsigned char *eina_memdup(unsigned char *mem, size_t size, Eina_Bool termi
*/
EAPI char *eina_strftime(const char *format, const struct tm *tm);
/**
* @brief base64 encoding function.
* @param src The string to be encoded.
* @param len The length of the string that should be encoded.
* @return the base64 encoded string.
*
* This will create a string which is base64 encode of the src. The caller has
* to free the returned string using free().
*
* @since 1.17.0
*/
EAPI char *eina_str_base64_encode(const unsigned char *src, unsigned int len);
/**
* @brief base64 url and filename safe encoding function.
* @param src The string to be encoded.
* @param len The length of the string that should be encoded.
* @return the base64 url encoded string.
*
* This will create a string which is base64 encoded with url and
* filename safe alphabet of the src. The caller has to free the
* returned string using free(). There will be no padding in the
* encoded string.
*
* @since 1.17.0
*/
EAPI char *eina_str_base64url_encode(const unsigned char *src, unsigned int len);
/**
* @brief base64 decoding function.
* @param src The string to be decoded.
* @param decoded_str_len The length of the decoded string.
* @return the base64 decoded string.
*
* This will create a NULL terminated string which is base64 decode of the src.
* The caller has to free the returned string using free().
*
* @since 1.17.0
*/
EAPI unsigned char * eina_str_base64_decode(const char * src, int *decoded_str_len);
/**
* @brief decoding function for base64 url and filename safe encoding.
* @param src The string to be decoded.
* @param decoded_str_len The length of the decoded string.
* @return the base64url decoded string.
*
* This will create a NULL terminated string which is base64url
* decode of the src.
* The caller has to free the returned string using free().
*
* @since 1.17.0
*/
EAPI unsigned char * eina_str_base64url_decode(const char * src, int *decoded_str_len);
#include "eina_inline_str.x"
/**

1
src/lib/emile/Emile.h
View File

@ -109,6 +109,7 @@ EAPI int emile_shutdown(void);
#include "emile_cipher.h"
#include "emile_compress.h"
#include "emile_image.h"
#include "emile_base64.h"
#ifdef __cplusplus
}

203
src/lib/emile/emile_base64.c Normal file
View File

@ -0,0 +1,203 @@
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <Eina.h>
#include "Emile.h"
#include <ctype.h>
/*============================================================================*
* Local *
*============================================================================*/
/**
* @cond LOCAL
*/
static const char *base64_table_normal = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/" ;
static const char *base64_table_url = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_" ;
static inline Eina_Bool is_base64_char(unsigned char c, Eina_Bool is_base64url)
{
if (is_base64url)
return (isalnum(c) || (c == '-') || (c == '_'));
else
return (isalnum(c) || (c == '+') || (c == '/'));
}
static Eina_Strbuf *
emile_base64_encode_common(const Eina_Binbuf *in, Eina_Bool is_base64url_encode)
{
unsigned char inarr[3], outarr[4];
const unsigned char *src;
size_t len;
char *dest;
int i = 0, j = 0, k = 0;
const char *base64_table;
if (!in) return NULL;
src = eina_binbuf_string_get(in);
len = eina_binbuf_length_get(in);
if (!src) return NULL;
// Max length of encoded string.
dest = malloc(sizeof (char) * (((len + 2) / 3) * 4 + 1));
if (!dest) return NULL;
if (is_base64url_encode)
base64_table = base64_table_url;
else
base64_table = base64_table_normal;
while (len--)
{
inarr[i++] = *(src++);
if (i == 3)
{
outarr[0] = (inarr[0] & 0xfc) >> 2;
outarr[1] = ((inarr[0] & 0x03) << 4) + ((inarr[1] & 0xf0) >> 4);
outarr[2] = ((inarr[1] & 0x0f) << 2) + ((inarr[2] & 0xc0) >> 6);
outarr[3] = inarr[2] & 0x3f;
for(i = 0; (i <4) ; i++)
dest[k++] = base64_table[outarr[i]];
i = 0;
}
}
if (i)
{
for(j = i; j < 3; j++)
inarr[j] = '\0';
outarr[0] = (inarr[0] & 0xfc) >> 2;
outarr[1] = ((inarr[0] & 0x03) << 4) + ((inarr[1] & 0xf0) >> 4);
outarr[2] = ((inarr[1] & 0x0f) << 2) + ((inarr[2] & 0xc0) >> 6);
outarr[3] = inarr[2] & 0x3f;
for (j = 0; (j < i + 1); j++)
dest[k++] = base64_table[outarr[j]];
/* No padding for URL encoding */
while((i++ < 3) && (!is_base64url_encode)) {
dest[k++] = '=';
}
}
dest[k] = '\0';
return eina_strbuf_manage_new(dest);
}
static Eina_Binbuf *
emile_base64_decode_common(const Eina_Strbuf *in, Eina_Bool is_base64url_decode)
{
unsigned char inarr[4], outarr[3];
int i = 0, j = 0, k = 0, l = 0;
int len;
unsigned char *dest;
const char *src;
const char *base64_table;
if (!in) return NULL;
src = eina_strbuf_string_get(in);
len = eina_strbuf_length_get(in);
if (!src) return NULL;
/* The encoded string length should be a multiple of 4. Else it is not a
* valid encoded string.
*/
if (!is_base64url_decode && (len % 4))
return NULL;
/* This is the max size the destination string can have.
*/
dest = (unsigned char *)malloc(sizeof(unsigned char) * ((len * 3 / 4) + 1));
if (!dest)
return NULL;
if (is_base64url_decode)
base64_table = base64_table_url;
else
base64_table = base64_table_normal;
while (len-- && (src[k] != '=') && is_base64_char(src[k], is_base64url_decode))
{
inarr[i++] = src[k++];
if (i == 4)
{
for (i = 0; i <4; i++)
inarr[i] = strchr(base64_table,(int) inarr[i]) - base64_table;
outarr[0] = (inarr[0] << 2) + ((inarr[1] & 0x30) >> 4);
outarr[1] = ((inarr[1] & 0xf) << 4) + ((inarr[2] & 0x3c) >> 2);
outarr[2] = ((inarr[2] & 0x3) << 6) + inarr[3];
for (i = 0; (i < 3); i++)
dest[l++] = outarr[i];
i = 0;
}
}
if (i)
{
for (j = i; j <4; j++)
inarr[j] = 0;
for (j = 0; j <4; j++)
inarr[j] = strchr(base64_table, (int) inarr[j]) - base64_table;
outarr[0] = (inarr[0] << 2) + ((inarr[1] & 0x30) >> 4);
outarr[1] = ((inarr[1] & 0xf) << 4) + ((inarr[2] & 0x3c) >> 2);
outarr[2] = ((inarr[2] & 0x3) << 6) + inarr[3];
for (j = 0; (j < i - 1); j++)
dest[l++] = outarr[j];
}
/* This is to prevent the applications from crashing. */
dest[l] = '\0';
return eina_binbuf_manage_new(dest, l, EINA_FALSE);
}
/*============================================================================*
* Global *
*============================================================================*/
/*============================================================================*
* API *
*============================================================================*/
EAPI Eina_Strbuf *
emile_base64_encode(const Eina_Binbuf *in)
{
return emile_base64_encode_common(in, EINA_FALSE);
}
EAPI Eina_Strbuf *
emile_base64url_encode(const Eina_Binbuf *in)
{
return emile_base64_encode_common(in, EINA_TRUE);
}
EAPI Eina_Binbuf *
emile_base64_decode(const Eina_Strbuf *in)
{
return emile_base64_decode_common(in, EINA_FALSE);
}
EAPI Eina_Binbuf *
emile_base64url_decode(const Eina_Strbuf *in)
{
return emile_base64_decode_common(in, EINA_TRUE);
}

65
src/lib/emile/emile_base64.h Normal file
View File

@ -0,0 +1,65 @@
#ifndef EMILE_BASE64_H_
#define EMILE_BASE64_H_
/**
* @defgroup Emile_Group_Base64 Non destructive base64 manipulation functions.
* @ingroup Emile
* Function that allow the encoding and decoding of base64 Eina_Binbuf.
*
* @{
*/
/**
* @brief base64 encoding function.
* @param in The buffer to be encoded.
* @return the base64 encoded string.
*
* This will create a string which is base64 encode of the buffer. The caller has
* to free the returned string using eina_strbuf_free().
*
* @since 1.17.0
*/
EAPI Eina_Strbuf *emile_base64_encode(const Eina_Binbuf *in);
/**
* @brief base64 url and filename safe encoding function.
* @param src The buffer to be encoded.
* @return the base64 url encoded string.
*
* This will create a string which is base64 encoded with url and
* filename safe alphabet of the src. The caller has to free the
* returned string using eina_strbuf_free(). There will be no padding in the
* encoded string.
*
* @since 1.17.0
*/
EAPI Eina_Strbuf *emile_base64url_encode(const Eina_Binbuf *in);
/**
* @brief base64 decoding function.
* @param src The string to be decoded.
* @return the base64 decoded buffer.
*
* This will create a buffer which is base64 decode of the src.
* The caller has to free the returned string using eina_binbuf_free().
*
* @since 1.17.0
*/
EAPI Eina_Binbuf* emile_base64_decode(const Eina_Strbuf *in);
/**
* @brief decoding function for base64 url and filename safe encoding.
* @param src The string to be decoded.
* @return the base64 url decoded buffer.
*
* This will create a buffer which is base64 url decode of the src.
* The caller has to free the returned string using eina_binbuf_free().
*
* @since 1.17.0
*/
EAPI Eina_Binbuf* emile_base64url_decode(const Eina_Strbuf *in);
/**
* @}
*/
#endif

92
src/tests/eina/eina_test_str.c
View File

@ -365,96 +365,6 @@ START_TEST(str_strftime)
}
END_TEST
/* All cases are taken from https://en.wikipedia.org/wiki/Base64 */
static const struct {
char *decoded_str;
char *encoded_normal;
char *encoded_url;
unsigned int len;
Eina_Bool not;
} tests[] = {
{ "any carnal pleasure.", "YW55IGNhcm5hbCBwbGVhc3VyZS4=", "YW55IGNhcm5hbCBwbGVhc3VyZS4", 20 },
{ "any carnal pleasure.", "YW55IGNhcm5hbCBwbGVhc3VyZQ==", "YW55IGNhcm5hbCBwbGVhc3VyZQ", 19 },
{ "any carnal pleasure.", "YW55IGNhcm5hbCBwbGVhc3Vy", "YW55IGNhcm5hbCBwbGVhc3Vy", 18 },
{ "any carnal pleasure.", "YW55IGNhcm5hbCBwbGVhc3U=", "YW55IGNhcm5hbCBwbGVhc3U", 17 },
{ "any carnal pleasure.", "YW55IGNhcm5hbCBwbGVhcw==", "YW55IGNhcm5hbCBwbGVhcw", 16 },
{ "pleasure.", "cGxlYXN1cmUu", "cGxlYXN1cmUu", 9 },
{ "leasure.", "bGVhc3VyZS4=", "bGVhc3VyZS4", 8 },
{ "easure.", "ZWFzdXJlLg==", "ZWFzdXJlLg", 7 },
{ "asure.", "YXN1cmUu", "YXN1cmUu", 6 },
{ "sure.", "c3VyZS4=", "c3VyZS4", 5 },
/* The following 2 cases are manually generated for -/ testing*/
{ "aabc123!?", "YWFiYzEyMyE/", "YWFiYzEyMyE_", 9 },
{ "abc123!?$*&()'-=@~", "YWJjMTIzIT8kKiYoKSctPUB+", "YWJjMTIzIT8kKiYoKSctPUB-", 18 }
};
START_TEST(str_base64_encode_decode)
{
unsigned int i;
int len;
unsigned char *decoded;
for (i = 0; i < sizeof (tests) / sizeof (tests[0]); i++)
{
char *encoded;
encoded = eina_str_base64_encode((unsigned char*) tests[i].decoded_str, tests[i].len);
fail_if(strcmp(encoded, tests[i].encoded_normal));
decoded = eina_str_base64_decode(tests[i].encoded_normal, &len);
fail_if(memcmp(decoded, tests[i].decoded_str, tests[i].len));
fprintf(stderr, "len = %d, tests[%d].len = %d\n", len, i, tests[i].len);
fail_if(len != (int)tests[i].len);
free(encoded);
free(decoded);
}
//Failure scenarios.
decoded = eina_str_base64_decode(NULL, &len);
fail_if(decoded);
decoded = eina_str_base64_decode("TWFu", NULL);
fail_if(memcmp(decoded, "Man", 3));
decoded = eina_str_base64_decode("abc", &len);
fail_if(decoded);
}
END_TEST
START_TEST(str_base64url_encode_decode)
{
unsigned int i;
int len;
unsigned char *decoded;
for (i = 0; i < sizeof (tests) / sizeof (tests[0]); i++)
{
char *encoded;
encoded = eina_str_base64url_encode((unsigned char*) tests[i].decoded_str, tests[i].len);
fail_if(strcmp(encoded, tests[i].encoded_url));
decoded = eina_str_base64url_decode(tests[i].encoded_url, &len);
fail_if(memcmp(decoded, tests[i].decoded_str, tests[i].len));
fprintf(stderr, "len = %d, tests[%d].len = %d\n", len, i, tests[i].len);
fail_if(len != (int)tests[i].len);
free(encoded);
free(decoded);
}
//Failure scenarios.
decoded = eina_str_base64url_decode(NULL, &len);
fail_if(decoded);
decoded = eina_str_base64url_decode("TWFu", NULL);
fail_if(memcmp(decoded, "Man", 3));
}
END_TEST
#ifdef HAVE_ICONV
START_TEST(str_convert)
{
@ -494,8 +404,6 @@ eina_test_str(TCase *tc)
tcase_add_test(tc, str_join_len);
tcase_add_test(tc, str_memdup);
tcase_add_test(tc, str_strftime);
tcase_add_test(tc, str_base64_encode_decode);
tcase_add_test(tc, str_base64url_encode_decode);
#ifdef HAVE_ICONV
tcase_add_test(tc, str_convert);
#endif

121
src/tests/emile/emile_suite.c
View File

@ -17,20 +17,135 @@ START_TEST(emile_test_init)
}
END_TEST
/* All cases are taken from https://en.wikipedia.org/wiki/Base64 */
static const struct {
char *decoded_str;
char *encoded_normal;
char *encoded_url;
unsigned int len;
Eina_Bool not;
} base64_tests[] = {
{ "any carnal pleasure.", "YW55IGNhcm5hbCBwbGVhc3VyZS4=", "YW55IGNhcm5hbCBwbGVhc3VyZS4", 20 },
{ "any carnal pleasure.", "YW55IGNhcm5hbCBwbGVhc3VyZQ==", "YW55IGNhcm5hbCBwbGVhc3VyZQ", 19 },
{ "any carnal pleasure.", "YW55IGNhcm5hbCBwbGVhc3Vy", "YW55IGNhcm5hbCBwbGVhc3Vy", 18 },
{ "any carnal pleasure.", "YW55IGNhcm5hbCBwbGVhc3U=", "YW55IGNhcm5hbCBwbGVhc3U", 17 },
{ "any carnal pleasure.", "YW55IGNhcm5hbCBwbGVhcw==", "YW55IGNhcm5hbCBwbGVhcw", 16 },
{ "pleasure.", "cGxlYXN1cmUu", "cGxlYXN1cmUu", 9 },
{ "leasure.", "bGVhc3VyZS4=", "bGVhc3VyZS4", 8 },
{ "easure.", "ZWFzdXJlLg==", "ZWFzdXJlLg", 7 },
{ "asure.", "YXN1cmUu", "YXN1cmUu", 6 },
{ "sure.", "c3VyZS4=", "c3VyZS4", 5 },
/* The following 2 cases are manually generated for -/ testing*/
{ "aabc123!?", "YWFiYzEyMyE/", "YWFiYzEyMyE_", 9 },
{ "abc123!?$*&()'-=@~", "YWJjMTIzIT8kKiYoKSctPUB+", "YWJjMTIzIT8kKiYoKSctPUB-", 18 }
};
START_TEST(emile_test_base64)
{
Eina_Binbuf *buffer, *decoded;
Eina_Strbuf *str, *encoded;
unsigned int i;
buffer = eina_binbuf_new();
str = eina_strbuf_new();
for (i = 0; i < sizeof (base64_tests) / sizeof (base64_tests[0]); i++)
{
eina_binbuf_append_length(buffer, (const unsigned char *) base64_tests[i].decoded_str, base64_tests[i].len);
eina_strbuf_append(str, base64_tests[i].encoded_normal);
encoded = emile_base64_encode(buffer);
fail_if(strcmp(eina_strbuf_string_get(encoded), base64_tests[i].encoded_normal));
decoded = emile_base64_decode(str);
fail_if(memcmp(eina_binbuf_string_get(decoded), base64_tests[i].decoded_str, base64_tests[i].len));
fail_if(eina_binbuf_length_get(decoded) != base64_tests[i].len);
eina_strbuf_free(encoded);
eina_binbuf_free(decoded);
eina_binbuf_reset(buffer);
eina_strbuf_reset(str);
}
//Failure scenarios.
decoded = emile_base64_decode(NULL);
fail_if(decoded);
eina_strbuf_append(str, "TWFu");
decoded = emile_base64_decode(str);
eina_strbuf_reset(str);
fail_if(memcmp(eina_binbuf_string_get(decoded), "Man", 3));
eina_binbuf_free(decoded);
eina_strbuf_append(str, "abc");
decoded = emile_base64_decode(str);
eina_strbuf_reset(str);
fail_if(decoded);
}
END_TEST
START_TEST(emile_test_base64url)
{
Eina_Binbuf *buffer, *decoded;
Eina_Strbuf *str, *encoded;
unsigned int i;
buffer = eina_binbuf_new();
str = eina_strbuf_new();
for (i = 0; i < sizeof (base64_tests) / sizeof (base64_tests[0]); i++)
{
eina_binbuf_append_length(buffer, (const unsigned char *) base64_tests[i].decoded_str, base64_tests[i].len);
eina_strbuf_append(str, base64_tests[i].encoded_url);
encoded = emile_base64url_encode(buffer);
fail_if(strcmp(eina_strbuf_string_get(encoded), base64_tests[i].encoded_url));
decoded = emile_base64url_decode(str);
fail_if(memcmp(eina_binbuf_string_get(decoded), base64_tests[i].decoded_str, base64_tests[i].len));
fail_if(eina_binbuf_length_get(decoded) != base64_tests[i].len);
eina_strbuf_free(encoded);
eina_binbuf_free(decoded);
eina_binbuf_reset(buffer);
eina_strbuf_reset(str);
}
//Failure scenarios.
decoded = emile_base64url_decode(NULL);
fail_if(decoded);
eina_strbuf_append(str, "TWFu");
decoded = emile_base64url_decode(str);
fail_if(memcmp(eina_binbuf_string_get(decoded), "Man", 3));
}
END_TEST
static void
emile_base_test(TCase *tc)
{
tcase_add_test(tc, emile_test_init);
}
static void
emile_base64_test(TCase *tc)
{
tcase_add_test(tc, emile_test_base64);
tcase_add_test(tc, emile_test_base64url);
}
static const struct
{
const char *name;
void (*build)(TCase *tc);
} tests[] = {
{
"Emile_Base", emile_base_test
}
{ "Emile_Base", emile_base_test },
{ "Emile_Base64", emile_base64_test }
};
static void