tests/test-base32.c

   1 /* Self tests for base32.
   2    Copyright (C) 2004, 2008-2024 Free Software Foundation, Inc.
   3    Based on the tests for base64 written by Simon Josefsson.
   4    Adapted for base32 by Gijs van Tulder.
   5
   6    This program is free software: you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation, either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
  18
  19 #include <config.h>
  20
  21 #include "base32.h"
  22
  23 #include <stddef.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26 #include <stdint.h>
  27
  28 #include "macros.h"
  29
  30 int
  31 main (void)
  32 {
  33   const char *in = "abcdefghijklmnop";
  34   const char *b32in = "MFRGGZDFMZTWQ2LKNNWG23TPOA======";
  35   char out[255];
  36   idx_t len;
  37   bool ok;
  38   char *p;
  39
  40   memset (out, 0x42, sizeof (out));
  41   base32_encode (in, 0, out, 0);
  42   ASSERT (out[0] == '\x42');
  43
  44   memset (out, 0x42, sizeof (out));
  45   base32_encode (in, 1, out, 10);
  46   ASSERT (memcmp (out, "ME======", 1) == 0);
  47
  48   memset (out, 0x42, sizeof (out));
  49   base32_encode (in, 1, out, 2);
  50   ASSERT (memcmp (out, "ME======", 2) == 0);
  51
  52   memset (out, 0x42, sizeof (out));
  53   base32_encode (in, 1, out, 3);
  54   ASSERT (memcmp (out, "ME======", 3) == 0);
  55
  56   memset (out, 0x42, sizeof (out));
  57   base32_encode (in, 1, out, 4);
  58   ASSERT (memcmp (out, "ME======", 4) == 0);
  59
  60   memset (out, 0x42, sizeof (out));
  61   base32_encode (in, 1, out, 8);
  62   ASSERT (memcmp (out, "ME======", 8) == 0);
  63
  64   memset (out, 0x42, sizeof (out));
  65   base32_encode (in, 2, out, 8);
  66   ASSERT (memcmp (out, "MFRA====", 8) == 0);
  67
  68   memset (out, 0x42, sizeof (out));
  69   base32_encode (in, 3, out, 8);
  70   ASSERT (memcmp (out, "MFRGG===", 8) == 0);
  71
  72   memset (out, 0x42, sizeof (out));
  73   base32_encode (in, 4, out, 8);
  74   ASSERT (memcmp (out, "MFRGGZA=", 8) == 0);
  75
  76   memset (out, 0x42, sizeof (out));
  77   base32_encode (in, 5, out, 8);
  78   ASSERT (memcmp (out, "MFRGGZDF", 8) == 0);
  79
  80   memset (out, 0x42, sizeof (out));
  81   base32_encode (in, 6, out, 16);
  82   ASSERT (memcmp (out, "MFRGGZDFMY======", 16) == 0);
  83
  84   memset (out, 0x42, sizeof (out));
  85   base32_encode (in, 6, out, 100);
  86   ASSERT (memcmp (out, "MFRGGZDFMY======", 16) == 0);
  87
  88   /* Decode. */
  89
  90   memset (out, 0x42, sizeof (out));
  91   len = 0;
  92   ok = base32_decode (b32in, 8, out, &len);
  93   ASSERT (ok);
  94   ASSERT (len == 0);
  95
  96   memset (out, 0x42, sizeof (out));
  97   len = 1;
  98   ok = base32_decode (b32in, 8, out, &len);
  99   ASSERT (ok);
 100   ASSERT (len == 1);
 101   ASSERT (memcmp (out, "abcdefghijklmnop", 1) == 0);
 102
 103   memset (out, 0x42, sizeof (out));
 104   len = 2;
 105   ok = base32_decode (b32in, 8, out, &len);
 106   ASSERT (ok);
 107   ASSERT (len == 2);
 108   ASSERT (memcmp (out, "abcdefghijklmnop", 2) == 0);
 109
 110   memset (out, 0x42, sizeof (out));
 111   len = 3;
 112   ok = base32_decode (b32in, 8, out, &len);
 113   ASSERT (ok);
 114   ASSERT (len == 3);
 115   ASSERT (memcmp (out, "abcdefghijklmnop", 3) == 0);
 116
 117   memset (out, 0x42, sizeof (out));
 118   len = 4;
 119   ok = base32_decode (b32in, 8, out, &len);
 120   ASSERT (ok);
 121   ASSERT (len == 4);
 122   ASSERT (memcmp (out, "abcdefghijklmnop", 4) == 0);
 123
 124   memset (out, 0x42, sizeof (out));
 125   len = 5;
 126   ok = base32_decode (b32in, 8, out, &len);
 127   ASSERT (ok);
 128   ASSERT (len == 5);
 129   ASSERT (memcmp (out, "abcdefghijklmnop", 5) == 0);
 130
 131   memset (out, 0x42, sizeof (out));
 132   len = 6;
 133   ok = base32_decode (b32in, 8, out, &len);
 134   ASSERT (ok);
 135   ASSERT (len == 5);
 136   ASSERT (memcmp (out, "abcdefghijklmnop", 5) == 0);
 137
 138   memset (out, 0x42, sizeof (out));
 139   len = 100;
 140   ok = base32_decode (b32in, strlen (b32in), out, &len);
 141   ASSERT (ok);
 142   ASSERT (len == 16);
 143   ASSERT (memcmp (out, "abcdefghijklmnop", 16) == 0);
 144
 145   /* Allocating encode */
 146
 147   len = base32_encode_alloc (in, strlen (in), &p);
 148   ASSERT (len == 32);
 149   ASSERT (strcmp (p, "MFRGGZDFMZTWQ2LKNNWG23TPOA======") == 0);
 150   free (p);
 151
 152   len = base32_encode_alloc (in, IDX_MAX - 5, &p);
 153   ASSERT (len == 0);
 154
 155   /* Decode context function */
 156   {
 157     struct base32_decode_context ctx;
 158
 159     base32_decode_ctx_init (&ctx);
 160
 161     len = sizeof (out);
 162     ok = base32_decode_ctx (&ctx, b32in, strlen (b32in), out, &len);
 163     ASSERT (ok);
 164     ASSERT (len == 16);
 165     ASSERT (memcmp (out, "abcdefghijklmnop", len) == 0);
 166   }
 167
 168   /* Allocating decode context function */
 169
 170   ok = base32_decode_alloc_ctx (NULL, b32in, strlen (b32in), &p, &len);
 171   ASSERT (ok);
 172   ASSERT (len == 16);
 173   ASSERT (memcmp (out, "abcdefghijklmnop", len) == 0);
 174   free (p);
 175
 176   {
 177     struct base32_decode_context ctx;
 178     const char *newlineb32 = "MFRG\nGZDFMZTWQ2LKNNW\nG23TPOA======";
 179
 180     base32_decode_ctx_init (&ctx);
 181
 182     ok = base32_decode_alloc_ctx (&ctx, newlineb32, strlen (newlineb32), &p, &len);
 183     ASSERT (ok);
 184     ASSERT (len == strlen (in));
 185     ASSERT (memcmp (p, in, len) == 0);
 186     free (p);
 187   }
 188
 189   {
 190     struct base32_decode_context ctx;
 191     base32_decode_ctx_init (&ctx);
 192
 193     ok = base32_decode_alloc_ctx (&ctx, "MFRGGZDFM\nZTWQ2LK", 17, &p, &len);
 194     ASSERT (ok);
 195     ASSERT (len == 10);
 196     ASSERT (memcmp (p, "abcdefghij", len) == 0);
 197     free (p);
 198
 199     base32_decode_ctx_init (&ctx);
 200
 201     ok = base32_decode_alloc_ctx (&ctx, "MF\n", 3, &p, &len);
 202     ASSERT (ok);
 203     ASSERT (len == 0);
 204     free (p);
 205
 206     ok = base32_decode_alloc_ctx (&ctx, "RGGZDFMZ", 8, &p, &len);
 207     ASSERT (ok);
 208     ASSERT (len == 5);
 209     ASSERT (memcmp (p, "abcde", len) == 0);
 210     free (p);
 211
 212     ok = base32_decode_alloc_ctx (&ctx, "TWQ2LK", 6, &p, &len);
 213     ASSERT (ok);
 214     ASSERT (len == 5);
 215     ASSERT (memcmp (p, "fghij", len) == 0);
 216     free (p);
 217
 218     ok = base32_decode_alloc_ctx (&ctx, "", 0, &p, &len);
 219     ASSERT (ok);
 220     free (p);
 221   }
 222
 223   {
 224     struct base32_decode_context ctx;
 225     const char *newlineb32 = "\n\n\n\n\n";
 226
 227     base32_decode_ctx_init (&ctx);
 228
 229     ok = base32_decode_alloc_ctx (&ctx, newlineb32, strlen (newlineb32), &p, &len);
 230     ASSERT (ok);
 231     ASSERT (len == 0);
 232     free (p);
 233   }
 234
 235   ok = base32_decode_alloc_ctx (NULL, " ! ", 3, &p, &len);
 236   ASSERT (!ok);
 237
 238   ok = base32_decode_alloc_ctx (NULL, "ABC\nDEF", 7, &p, &len);
 239   ASSERT (!ok);
 240
 241   ok = base32_decode_alloc_ctx (NULL, "AA", 2, &p, &len);
 242   ASSERT (!ok);
 243
 244   ok = base32_decode_alloc_ctx (NULL, "AA=", 3, &p, &len);
 245   ASSERT (!ok);
 246
 247   ok = base32_decode_alloc_ctx (NULL, "AABBAAxx", 8, &p, &len);
 248   ASSERT (!ok);
 249
 250   ok = base32_decode_alloc_ctx (NULL, "AABBAA=X", 8, &p, &len);
 251   ASSERT (!ok);
 252
 253   ok = base32_decode_alloc_ctx (NULL, "AABBAA=X", 8, &p, &len);
 254   ASSERT (!ok);
 255
 256   ok = base32_decode_alloc_ctx (NULL, "AABBAA=A", 8, &p, &len);
 257   ASSERT (!ok);
 258
 259   ok = base32_decode_alloc_ctx (NULL, "FZ======", 8, &p, &len);
 260   ASSERT (!ok);
 261
 262   ok = base32_decode_alloc_ctx (NULL, "FYXB====", 8, &p, &len);
 263   ASSERT (!ok);
 264
 265   ok = base32_decode_alloc_ctx (NULL, "FYXC5===", 8, &p, &len);
 266   ASSERT (!ok);
 267
 268   ok = base32_decode_alloc_ctx (NULL, "FYXC4LR=", 8, &p, &len);
 269   ASSERT (!ok);
 270
 271   ok = base32_decode_alloc_ctx (NULL, "FZ======FY======", 16, &p, &len);
 272   ASSERT (!ok);
 273
 274   return test_exit_status;
 275 }