glib/tests/base64.c

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