#include <glib.h>
#include <string.h>
#include <stdlib.h>
#define DATA_SIZE 1024
#define BLOCK_SIZE 32
#define NUM_BLOCKS 32
static guchar data[DATA_SIZE];
static void
test_incremental (gboolean line_break,
gint length)
{
char *p;
gsize len, decoded_len, max, input_len, block_size;
int state, save;
guint decoder_save;
char *text;
guchar *data2;
data2 = g_malloc (length);
text = g_malloc (length * 4);
len = 0;
state = 0;
save = 0;
input_len = 0;
while (input_len < length)
{
block_size = MIN (BLOCK_SIZE, length - input_len);
len += g_base64_encode_step (data + input_len, block_size,
line_break, text + len, &state, &save);
input_len += block_size;
}
len += g_base64_encode_close (line_break, text + len, &state, &save);
if (line_break)
max = length * 4 / 3 + length * 4 / (3 * 72) + 7;
else
max = length * 4 / 3 + 6;
/* Check encoded length */
g_assert_cmpint (len, <=, max);
decoded_len = 0;
state = 0;
decoder_save = 0;
p = text;
while (len > 0)
{
int chunk_len = MIN (BLOCK_SIZE, len);
decoded_len += g_base64_decode_step (p,
chunk_len,
data2 + decoded_len,
&state, &decoder_save);
p += chunk_len;
len -= chunk_len;
}
g_assert_cmpmem (data, length, data2, decoded_len);
g_free (text);
g_free (data2);
}
static void
test_incremental_break (gconstpointer d)
{
gint length = GPOINTER_TO_INT (d);
test_incremental (TRUE, length);
}
static void
test_incremental_nobreak (gconstpointer d)
{
gint length = GPOINTER_TO_INT (d);
test_incremental (FALSE, length);
}
static void
test_full (gconstpointer d)
{
gint length = GPOINTER_TO_INT (d);
char *text;
guchar *data2;
gsize len;
text = g_base64_encode (data, length);
data2 = g_base64_decode (text, &len);
g_free (text);
g_assert_cmpmem (data, length, data2, len);
g_free (data2);
}
struct MyRawData
{
gint length; /* of data */
guchar data[DATA_SIZE];
};
/* 100 pre-encoded string from data[] buffer. Data length from 1..100
*/
static const char *ok_100_encode_strs[] = {
"AA==",
"AAE=",
"AAEC",
"AAECAw==",
"AAECAwQ=",
"AAECAwQF",
"AAECAwQFBg==",
"AAECAwQFBgc=",
"AAECAwQFBgcI",
"AAECAwQFBgcICQ==",
"AAECAwQFBgcICQo=",
"AAECAwQFBgcICQoL",
"AAECAwQFBgcICQoLDA==",
"AAECAwQFBgcICQoLDA0=",
"AAECAwQFBgcICQoLDA0O",
"AAECAwQFBgcICQoLDA0ODw==",
"AAECAwQFBgcICQoLDA0ODxA=",
"AAECAwQFBgcICQoLDA0ODxAR",
"AAECAwQFBgcICQoLDA0ODxAREg==",
"AAECAwQFBgcICQoLDA0ODxAREhM=",
"AAECAwQFBgcICQoLDA0ODxAREhMU",
"AAECAwQFBgcICQoLDA0ODxAREhMUFQ==",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRY=",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYX",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGA==",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBk=",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBka",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGw==",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxw=",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwd",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHg==",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8=",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8g",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gIQ==",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISI=",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIj",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJA==",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCU=",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUm",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJw==",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJyg=",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygp",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKg==",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKis=",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKiss",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLQ==",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4=",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4v",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMA==",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDE=",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEy",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMw==",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ=",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Ng==",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc=",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OQ==",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo=",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PA==",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0=",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+Pw==",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0A=",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BB",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQg==",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkM=",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNE",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERQ==",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUY=",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZH",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSA==",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSEk=",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElK",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKSw==",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0w=",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xN",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTg==",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk8=",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9Q",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUQ==",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVI=",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJT",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVA==",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFU=",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVW",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWVw==",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1g=",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZ",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWg==",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWls=",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltc",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXQ==",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV4=",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5f",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYA==",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGE=",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFi",
"AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiYw==",
NULL
};
static void
generate_databuffer_for_base64 (struct MyRawData *p)
{
int i;
for (i = 0; i < DATA_SIZE; i++)
p->data[i] = i;
}
static void
test_base64_encode (void)
{
int i;
gint length = 1;
char *text;
struct MyRawData myraw;
generate_databuffer_for_base64 (&myraw);
for (i = 0; ok_100_encode_strs[i]; i++)
{
length = i + 1;
text = g_base64_encode (myraw.data, length);
g_assert_cmpstr (text, ==, ok_100_encode_strs[i]);
/* printf ("\"%s\",\n",text); */
g_free (text);
}
}
/* Test that incremental and all-in-one encoding of strings of a length which
* is not a multiple of 3 bytes behave the same, as the state carried over
* between g_base64_encode_step() calls varies depending on how the input is
* split up. This is like the test_base64_decode_smallblock() test, but for
* encoding. */
static void
test_base64_encode_incremental_small_block (gconstpointer block_size_p)
{
gsize i;
struct MyRawData myraw;
g_test_bug ("780066");
generate_databuffer_for_base64 (&myraw);
for (i = 0; ok_100_encode_strs[i] != NULL; i++)
{
const guint block_size = GPOINTER_TO_UINT (block_size_p);
gchar *encoded_complete = NULL;
gchar encoded_stepped[1024];
gint state = 0, save = 0;
gsize len_written, len_read, len_to_read, input_length;
input_length = i + 1;
/* Do it all at once. */
encoded_complete = g_base64_encode (myraw.data, input_length);
/* Split the data up so some number of bits remain after each step. */
for (len_written = 0, len_read = 0; len_read < input_length; len_read += len_to_read)
{
len_to_read = MIN (block_size, input_length - len_read);
len_written += g_base64_encode_step (myraw.data + len_read, len_to_read,
FALSE,
encoded_stepped + len_written,
&state, &save);
}
len_written += g_base64_encode_close (FALSE, encoded_stepped + len_written,
&state, &save);
g_assert_cmpuint (len_written, <, G_N_ELEMENTS (encoded_stepped));
/* Nul-terminate to make string comparison easier. */
encoded_stepped[len_written] = '\0';
/* Compare results. They should be the same. */
g_assert_cmpstr (encoded_complete, ==, ok_100_encode_strs[i]);
g_assert_cmpstr (encoded_stepped, ==, encoded_complete);
g_free (encoded_complete);
}
}
static void
decode_and_compare (const gchar *datap,
const struct MyRawData *p)
{
guchar *data2;
gsize len;
data2 = g_base64_decode (datap, &len);
g_assert_cmpmem (p->data, p->length, data2, len);
g_free (data2);
}
static void
decode_inplace_and_compare (const gchar *datap,
const struct MyRawData *p)
{
gchar *data;
guchar *data2;
gsize len;
data = g_strdup (datap);
data2 = g_base64_decode_inplace (data, &len);
g_assert_cmpmem (p->data, p->length, data2, len);
g_free (data2);
}
static void
test_base64_decode (void)
{
int i;
struct MyRawData myraw;
generate_databuffer_for_base64 (&myraw);
for (i = 0; ok_100_encode_strs[i]; i++)
{
myraw.length = i + 1;
decode_and_compare (ok_100_encode_strs[i], &myraw);
}
}
static void
test_base64_decode_inplace (void)
{
int i;
struct MyRawData myraw;
generate_databuffer_for_base64 (&myraw);
for (i = 0; ok_100_encode_strs[i]; i++)
{
myraw.length = i + 1;
decode_inplace_and_compare (ok_100_encode_strs[i], &myraw);
}
}
static void
test_base64_encode_decode (void)
{
int i;
char *text;
struct MyRawData myraw;
generate_databuffer_for_base64 (&myraw);
for (i = 0; i < DATA_SIZE; i++)
{
myraw.length = i + 1;
text = g_base64_encode (myraw.data, myraw.length);
decode_and_compare (text, &myraw);
g_free (text);
}
}
static void
test_base64_decode_smallblock (gconstpointer blocksize_p)
{
const guint blocksize = GPOINTER_TO_UINT (blocksize_p);
guint i;
for (i = 0; ok_100_encode_strs[i]; i++)
{
const char *str = ok_100_encode_strs[i];
const char *p;
gsize len = strlen (str);
gint state = 0;
guint save = 0;
guchar *decoded;
gsize decoded_size = 0;
guchar *decoded_atonce;
gsize decoded_atonce_size = 0;
decoded = g_malloc (len / 4 * 3 + 3);
p = str;
while (len > 0)
{
int chunk_len = MIN (blocksize, len);
gsize size = g_base64_decode_step (p, chunk_len,
decoded + decoded_size,
&state, &save);
decoded_size += size;
len -= chunk_len;
p += chunk_len;
}
decoded_atonce = g_base64_decode (str, &decoded_atonce_size);
g_assert_cmpmem (decoded, decoded_size, decoded_atonce, decoded_atonce_size);
g_free (decoded);
g_free (decoded_atonce);
}
}
int
main (int argc, char *argv[])
{
gint i;
g_test_init (&argc, &argv, NULL);
g_test_bug_base ("https://bugzilla.gnome.org/browse.cgi?product=");
for (i = 0; i < DATA_SIZE; i++)
data[i] = (guchar)i;
g_test_add_data_func ("/base64/full/1", GINT_TO_POINTER (DATA_SIZE), test_full);
g_test_add_data_func ("/base64/full/2", GINT_TO_POINTER (1), test_full);
g_test_add_data_func ("/base64/full/3", GINT_TO_POINTER (2), test_full);
g_test_add_data_func ("/base64/full/4", GINT_TO_POINTER (3), test_full);
g_test_add_data_func ("/base64/encode/incremental/small-block/1", GINT_TO_POINTER (1), test_base64_encode_incremental_small_block);
g_test_add_data_func ("/base64/encode/incremental/small-block/2", GINT_TO_POINTER (2), test_base64_encode_incremental_small_block);
g_test_add_data_func ("/base64/encode/incremental/small-block/3", GINT_TO_POINTER (3), test_base64_encode_incremental_small_block);
g_test_add_data_func ("/base64/encode/incremental/small-block/4", GINT_TO_POINTER (4), test_base64_encode_incremental_small_block);
g_test_add_data_func ("/base64/incremental/nobreak/1", GINT_TO_POINTER (DATA_SIZE), test_incremental_nobreak);
g_test_add_data_func ("/base64/incremental/break/1", GINT_TO_POINTER (DATA_SIZE), test_incremental_break);
g_test_add_data_func ("/base64/incremental/nobreak/2", GINT_TO_POINTER (DATA_SIZE - 1), test_incremental_nobreak);
g_test_add_data_func ("/base64/incremental/break/2", GINT_TO_POINTER (DATA_SIZE - 1), test_incremental_break);
g_test_add_data_func ("/base64/incremental/nobreak/3", GINT_TO_POINTER (DATA_SIZE - 2), test_incremental_nobreak);
g_test_add_data_func ("/base64/incremental/break/3", GINT_TO_POINTER (DATA_SIZE - 2), test_incremental_break);
g_test_add_data_func ("/base64/incremental/nobreak/4-a", GINT_TO_POINTER (1), test_incremental_nobreak);
g_test_add_data_func ("/base64/incremental/nobreak/4-b", GINT_TO_POINTER (2), test_incremental_nobreak);
g_test_add_data_func ("/base64/incremental/nobreak/4-c", GINT_TO_POINTER (3), test_incremental_nobreak);
g_test_add_func ("/base64/encode", test_base64_encode);
g_test_add_func ("/base64/decode", test_base64_decode);
g_test_add_func ("/base64/decode-inplace", test_base64_decode_inplace);
g_test_add_func ("/base64/encode-decode", test_base64_encode_decode);
g_test_add_data_func ("/base64/incremental/smallblock/1", GINT_TO_POINTER(1),
test_base64_decode_smallblock);
g_test_add_data_func ("/base64/incremental/smallblock/2", GINT_TO_POINTER(2),
test_base64_decode_smallblock);
g_test_add_data_func ("/base64/incremental/smallblock/3", GINT_TO_POINTER(3),
test_base64_decode_smallblock);
g_test_add_data_func ("/base64/incremental/smallblock/4", GINT_TO_POINTER(4),
test_base64_decode_smallblock);
return g_test_run ();
}