glib/tests/base64.c - third_party/glib - Git at Google

 #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 ();
 }
	#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 ();
	}