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
 336 int
 337 main (int argc, char *argv[])
 338 {
 339   gint i;
 340
 341   g_test_init (&argc, &argv, NULL);
 342
 343   for (i = 0; i < DATA_SIZE; i++)
 344     data[i] = (guchar)i;
 345
 346   g_test_add_data_func ("/base64/full/1", GINT_TO_POINTER (DATA_SIZE), test_full);
 347   g_test_add_data_func ("/base64/full/2", GINT_TO_POINTER (1), test_full);
 348   g_test_add_data_func ("/base64/full/3", GINT_TO_POINTER (2), test_full);
 349   g_test_add_data_func ("/base64/full/4", GINT_TO_POINTER (3), test_full);
 350
 351   g_test_add_data_func ("/base64/incremental/nobreak/1", GINT_TO_POINTER (DATA_SIZE), test_incremental_nobreak);
 352   g_test_add_data_func ("/base64/incremental/break/1", GINT_TO_POINTER (DATA_SIZE), test_incremental_break);
 353
 354   g_test_add_data_func ("/base64/incremental/nobreak/2", GINT_TO_POINTER (DATA_SIZE - 1), test_incremental_nobreak);
 355   g_test_add_data_func ("/base64/incremental/break/2", GINT_TO_POINTER (DATA_SIZE - 1), test_incremental_break);
 356
 357   g_test_add_data_func ("/base64/incremental/nobreak/3", GINT_TO_POINTER (DATA_SIZE - 2), test_incremental_nobreak);
 358   g_test_add_data_func ("/base64/incremental/break/3", GINT_TO_POINTER (DATA_SIZE - 2), test_incremental_break);
 359
 360   g_test_add_data_func ("/base64/incremental/nobreak/4", GINT_TO_POINTER (1), test_incremental_nobreak);
 361   g_test_add_data_func ("/base64/incremental/nobreak/4", GINT_TO_POINTER (2), test_incremental_nobreak);
 362   g_test_add_data_func ("/base64/incremental/nobreak/4", GINT_TO_POINTER (3), test_incremental_nobreak);
 363
 364   g_test_add_func ("/base64/encode", test_base64_encode);
 365   g_test_add_func ("/base64/decode", test_base64_decode);
 366   g_test_add_func ("/base64/decode-inplace", test_base64_decode_inplace);
 367   g_test_add_func ("/base64/encode-decode", test_base64_encode_decode);
 368
 369   return g_test_run ();
 370 }