glib/tests/base64.c

   1 #include <glib.h>
   2 #include <string.h>
   3 #include <stdlib.h>
   4
   5 #define DATA_SIZE 1024
   6 #define BLOCK_SIZE 32
   7 #define NUM_BLOCKS 32
   8 static guchar data[DATA_SIZE];
   9
  10 static void
  11 test_incremental (gboolean line_break,
  12                   gint     length)
  13 {
  14   char *p;
  15   gsize len, decoded_len, max, input_len, block_size;
  16   int state, save;
  17   guint decoder_save;
  18   char *text;
  19   guchar *data2;
  20
  21   data2 = g_malloc (length);
  22   text = g_malloc (length * 4);
  23
  24   len = 0;
  25   state = 0;
  26   save = 0;
  27   input_len = 0;
  28   while (input_len < length)
  29     {
  30       block_size = MIN (BLOCK_SIZE, length - input_len);
  31       len += g_base64_encode_step (data + input_len, block_size,
  32                                    line_break, text + len, &state, &save);
  33       input_len += block_size;
  34     }
  35   len += g_base64_encode_close (line_break, text + len, &state, &save);
  36
  37   if (line_break)
  38     max = length * 4 / 3 + length * 4 / (3 * 72) + 7;
  39   else
  40     max = length * 4 / 3 + 6;
  41
  42   /* Check encoded length */
  43   g_assert_cmpint (len, <=, max);
  44
  45   decoded_len = 0;
  46   state = 0;
  47   decoder_save = 0;
  48   p = text;
  49   while (len > 0)
  50     {
  51       int chunk_len = MIN (BLOCK_SIZE, len);
  52       decoded_len += g_base64_decode_step (p,
  53                                            chunk_len,
  54                                            data2 + decoded_len,
  55                                            &state, &decoder_save);
  56       p += chunk_len;
  57       len -= chunk_len;
  58     }
  59
  60   /* Check decoded length */
  61   g_assert_cmpint (decoded_len, ==, length);
  62   /* Check decoded data */
  63   g_assert (memcmp (data, data2, length) == 0);
  64
  65   g_free (text);
  66   g_free (data2);
  67 }
  68
  69 static void
  70 test_incremental_break (gconstpointer d)
  71 {
  72   gint length = GPOINTER_TO_INT (d);
  73
  74   test_incremental (TRUE, length);
  75 }
  76
  77 static void
  78 test_incremental_nobreak (gconstpointer d)
  79 {
  80   gint length = GPOINTER_TO_INT (d);
  81
  82   test_incremental (FALSE, length);
  83 }
  84
  85 static void
  86 test_full (gconstpointer d)
  87 {
  88   gint length = GPOINTER_TO_INT (d);
  89   char *text;
  90   guchar *data2;
  91   gsize len;
  92
  93   text = g_base64_encode (data, length);
  94   data2 = g_base64_decode (text, &len);
  95   g_free (text);
  96
  97   /* Check decoded length */
  98   g_assert_cmpint (len, ==, length);
  99   /* Check decoded base64 data */
 100   g_assert (memcmp (data, data2, length) == 0);
 101
 102   g_free (data2);
 103 }
 104
 105 struct MyRawData
 106 {
 107   gint length;   /* of data */
 108   guchar data[DATA_SIZE];
 109 };
 110
 111 /* 100 pre-encoded string from data[] buffer. Data length from 1..100
 112  */
 113 static const char *ok_100_encode_strs[] = {
 114   "AA==",
 115   "AAE=",
 116   "AAEC",
 117   "AAECAw==",
 118   "AAECAwQ=",
 119   "AAECAwQF",
 120   "AAECAwQFBg==",
 121   "AAECAwQFBgc=",
 122   "AAECAwQFBgcI",
 123   "AAECAwQFBgcICQ==",
 124   "AAECAwQFBgcICQo=",
 125   "AAECAwQFBgcICQoL",
 126   "AAECAwQFBgcICQoLDA==",
 127   "AAECAwQFBgcICQoLDA0=",
 128   "AAECAwQFBgcICQoLDA0O",
 129   "AAECAwQFBgcICQoLDA0ODw==",
 130   "AAECAwQFBgcICQoLDA0ODxA=",
 131   "AAECAwQFBgcICQoLDA0ODxAR",
 132   "AAECAwQFBgcICQoLDA0ODxAREg==",
 133   "AAECAwQFBgcICQoLDA0ODxAREhM=",
 134   "AAECAwQFBgcICQoLDA0ODxAREhMU",
 135   "AAECAwQFBgcICQoLDA0ODxAREhMUFQ==",
 136   "AAECAwQFBgcICQoLDA0ODxAREhMUFRY=",
 137   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYX",
 138   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGA==",
 139   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBk=",
 140   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBka",
 141   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGw==",
 142   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxw=",
 143   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwd",
 144   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHg==",
 145   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8=",
 146   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8g",
 147   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gIQ==",
 148   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISI=",
 149   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIj",
 150   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJA==",
 151   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCU=",
 152   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUm",
 153   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJw==",
 154   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJyg=",
 155   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygp",
 156   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKg==",
 157   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKis=",
 158   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKiss",
 159   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLQ==",
 160   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4=",
 161   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4v",
 162   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMA==",
 163   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDE=",
 164   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEy",
 165   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMw==",
 166   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ=",
 167   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1",
 168   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Ng==",
 169   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc=",
 170   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4",
 171   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OQ==",
 172   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo=",
 173   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7",
 174   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PA==",
 175   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0=",
 176   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+",
 177   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+Pw==",
 178   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0A=",
 179   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BB",
 180   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQg==",
 181   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkM=",
 182   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNE",
 183   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERQ==",
 184   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUY=",
 185   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZH",
 186   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSA==",
 187   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSEk=",
 188   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElK",
 189   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKSw==",
 190   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0w=",
 191   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xN",
 192   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTg==",
 193   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk8=",
 194   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9Q",
 195   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUQ==",
 196   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVI=",
 197   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJT",
 198   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVA==",
 199   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFU=",
 200   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVW",
 201   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWVw==",
 202   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1g=",
 203   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZ",
 204   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWg==",
 205   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWls=",
 206   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltc",
 207   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXQ==",
 208   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV4=",
 209   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5f",
 210   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYA==",
 211   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGE=",
 212   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFi",
 213   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiYw==",
 214   NULL
 215 };
 216
 217 static void
 218 generate_databuffer_for_base64 (struct MyRawData *p)
 219 {
 220   int i;
 221   for (i = 0; i < DATA_SIZE; i++)
 222     p->data[i] = i;
 223 }
 224
 225 static void
 226 test_base64_encode (void)
 227 {
 228   int i;
 229   gint length = 1;
 230   char *text;
 231   struct MyRawData myraw;
 232
 233   generate_databuffer_for_base64 (&myraw);
 234
 235   for (i = 0; ok_100_encode_strs[i]; i++)
 236     {
 237       length = i + 1;
 238       text = g_base64_encode (myraw.data, length);
 239       g_assert_cmpstr (text, ==, ok_100_encode_strs[i]);
 240       /* printf ("\"%s\",\n",text); */
 241       g_free (text);
 242     }
 243 }
 244
 245
 246 static void
 247 decode_and_compare (const gchar            *datap,
 248                     const struct MyRawData *p)
 249 {
 250   guchar *data2;
 251   gsize len;
 252   int memcmp_decode;
 253
 254   data2 = g_base64_decode (datap, &len);
 255   g_assert_cmpint (len, ==, p->length);
 256   /* g_print ("length: got %d, expected %d\n",len, length); */
 257   memcmp_decode = memcmp (p->data, data2, p->length);
 258   g_assert_cmpint (memcmp_decode, ==, 0);
 259   g_free (data2);
 260 }
 261
 262 static void
 263 decode_inplace_and_compare (const gchar            *datap,
 264                             const struct MyRawData *p)
 265 {
 266   gchar *data;
 267   guchar *data2;
 268   gsize len;
 269   int memcmp_decode;
 270
 271   data = g_strdup (datap);
 272   data2 = g_base64_decode_inplace (data, &len);
 273   g_assert_cmpint (len, ==, p->length);
 274   /* g_print ("length: got %d, expected %d\n",len, length); */
 275   memcmp_decode = memcmp (p->data, data2, p->length);
 276   g_assert_cmpint (memcmp_decode, ==, 0);
 277   g_free (data2);
 278 }
 279
 280 static void
 281 test_base64_decode (void)
 282 {
 283   int i;
 284   struct MyRawData myraw;
 285
 286   generate_databuffer_for_base64 (&myraw);
 287
 288   for (i = 0; ok_100_encode_strs[i]; i++)
 289     {
 290       myraw.length = i + 1;
 291       decode_and_compare (ok_100_encode_strs[i], &myraw);
 292     }
 293 }
 294
 295 static void
 296 test_base64_decode_inplace (void)
 297 {
 298   int i;
 299   struct MyRawData myraw;
 300
 301   generate_databuffer_for_base64 (&myraw);
 302
 303   for (i = 0; ok_100_encode_strs[i]; i++)
 304     {
 305       myraw.length = i + 1;
 306       decode_inplace_and_compare (ok_100_encode_strs[i], &myraw);
 307     }
 308 }
 309
 310 static void
 311 test_base64_encode_decode (void)
 312 {
 313   int i;
 314   char *text;
 315   struct MyRawData myraw;
 316
 317   generate_databuffer_for_base64 (&myraw);
 318
 319   for (i = 0; i < DATA_SIZE; i++)
 320     {
 321       myraw.length = i + 1;
 322       text = g_base64_encode (myraw.data, myraw.length);
 323
 324       decode_and_compare (text, &myraw);
 325
 326       g_free (text);
 327     }
 328 }
 329
 330 static void
 331 test_base64_decode_smallblock (gconstpointer blocksize_p)
 332 {
 333   const guint blocksize = GPOINTER_TO_UINT (blocksize_p);
 334   guint i;
 335
 336   for (i = 0; ok_100_encode_strs[i]; i++)
 337     {
 338       const char *str = ok_100_encode_strs[i];
 339       const char *p;
 340       gsize len = strlen (str);
 341       gint state = 0;
 342       guint save = 0;
 343       guchar *decoded;
 344       gsize decoded_size = 0;
 345       guchar *decoded_atonce;
 346       gsize decoded_atonce_size = 0;
 347
 348       decoded = g_malloc (len / 4 * 3 + 3);
 349
 350       p = str;
 351       while (len > 0)
 352         {
 353           int chunk_len = MIN (blocksize, len);
 354           gsize size = g_base64_decode_step (p, chunk_len,
 355                                              decoded + decoded_size,
 356                                              &state, &save);
 357           decoded_size += size;
 358           len -= chunk_len;
 359           p += chunk_len;
 360         }
 361
 362       decoded_atonce = g_base64_decode (str, &decoded_atonce_size);
 363
 364       g_assert_cmpint (decoded_size, ==, decoded_atonce_size);
 365       g_assert (memcmp (decoded, decoded_atonce, decoded_size) == 0);
 366
 367       g_free (decoded);
 368       g_free (decoded_atonce);
 369     }
 370 }
 371
 372
 373 int
 374 main (int argc, char *argv[])
 375 {
 376   gint i;
 377
 378   g_test_init (&argc, &argv, NULL);
 379
 380   for (i = 0; i < DATA_SIZE; i++)
 381     data[i] = (guchar)i;
 382
 383   g_test_add_data_func ("/base64/full/1", GINT_TO_POINTER (DATA_SIZE), test_full);
 384   g_test_add_data_func ("/base64/full/2", GINT_TO_POINTER (1), test_full);
 385   g_test_add_data_func ("/base64/full/3", GINT_TO_POINTER (2), test_full);
 386   g_test_add_data_func ("/base64/full/4", GINT_TO_POINTER (3), test_full);
 387
 388   g_test_add_data_func ("/base64/incremental/nobreak/1", GINT_TO_POINTER (DATA_SIZE), test_incremental_nobreak);
 389   g_test_add_data_func ("/base64/incremental/break/1", GINT_TO_POINTER (DATA_SIZE), test_incremental_break);
 390
 391   g_test_add_data_func ("/base64/incremental/nobreak/2", GINT_TO_POINTER (DATA_SIZE - 1), test_incremental_nobreak);
 392   g_test_add_data_func ("/base64/incremental/break/2", GINT_TO_POINTER (DATA_SIZE - 1), test_incremental_break);
 393
 394   g_test_add_data_func ("/base64/incremental/nobreak/3", GINT_TO_POINTER (DATA_SIZE - 2), test_incremental_nobreak);
 395   g_test_add_data_func ("/base64/incremental/break/3", GINT_TO_POINTER (DATA_SIZE - 2), test_incremental_break);
 396
 397   g_test_add_data_func ("/base64/incremental/nobreak/4", GINT_TO_POINTER (1), test_incremental_nobreak);
 398   g_test_add_data_func ("/base64/incremental/nobreak/4", GINT_TO_POINTER (2), test_incremental_nobreak);
 399   g_test_add_data_func ("/base64/incremental/nobreak/4", GINT_TO_POINTER (3), test_incremental_nobreak);
 400
 401   g_test_add_func ("/base64/encode", test_base64_encode);
 402   g_test_add_func ("/base64/decode", test_base64_decode);
 403   g_test_add_func ("/base64/decode-inplace", test_base64_decode_inplace);
 404   g_test_add_func ("/base64/encode-decode", test_base64_encode_decode);
 405
 406   g_test_add_data_func ("/base64/incremental/smallblock/1", GINT_TO_POINTER(1),
 407                         test_base64_decode_smallblock);
 408   g_test_add_data_func ("/base64/incremental/smallblock/2", GINT_TO_POINTER(2),
 409                         test_base64_decode_smallblock);
 410   g_test_add_data_func ("/base64/incremental/smallblock/3", GINT_TO_POINTER(3),
 411                         test_base64_decode_smallblock);
 412   g_test_add_data_func ("/base64/incremental/smallblock/4", GINT_TO_POINTER(4),
 413                         test_base64_decode_smallblock);
 414
 415   return g_test_run ();
 416 }