tst_stringprep.c

   1 /* tst_stringprep.c     libstringprep self tests for stringprep_stringprep()
   2  * Copyright (C) 2002  Simon Josefsson
   3  *
   4  * This file is part of libstringprep.
   5  *
   6  * Libstringprep 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 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * Libstringprep 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 libstringprep; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  *
  20  */
  21
  22 #include "internal.h"
  23
  24 static int debug = 0;
  25 static int error_count = 0;
  26 static int break_on_error = 0;
  27
  28 static void
  29 fail (const char *format, ...)
  30 {
  31   va_list arg_ptr;
  32
  33   va_start (arg_ptr, format);
  34   vfprintf (stderr, format, arg_ptr);
  35   va_end (arg_ptr);
  36   error_count++;
  37   if (break_on_error)
  38     exit (1);
  39 }
  40
  41 static void
  42 escapeprint (char *str, int len)
  43 {
  44   int i;
  45
  46   printf ("\t;; `");
  47   for (i = 0; i < len; i++)
  48     {
  49       if (((str[i] & 0xFF) >= 'A' && (str[i] & 0xFF) <= 'Z') ||
  50           ((str[i] & 0xFF) >= 'a' && (str[i] & 0xFF) <= 'z') ||
  51           ((str[i] & 0xFF) >= '0' && (str[i] & 0xFF) <= '9')
  52           || (str[i] & 0xFF) == '.')
  53         printf ("%c", (str[i] & 0xFF));
  54       else
  55         printf ("\\x%02x", (str[i] & 0xFF));
  56     }
  57   printf ("' (length %d bytes)\n", len);
  58 }
  59
  60 static void
  61 hexprint (char *str, int len)
  62 {
  63   int i;
  64
  65   printf ("\t;; ");
  66   for (i = 0; i < len; i++)
  67     {
  68       printf ("%02x ", (str[i] & 0xFF));
  69       if ((i + 1) % 8 == 0)
  70         printf (" ");
  71       if ((i + 1) % 16 == 0 && i + 1 < len)
  72         printf ("\n\t;; ");
  73     }
  74 }
  75
  76 static void
  77 binprint (char *str, int len)
  78 {
  79   int i;
  80
  81   printf ("\t;; ");
  82   for (i = 0; i < len; i++)
  83     {
  84       printf ("%d%d%d%d%d%d%d%d ",
  85               (str[i] & 0xFF) & 0x80 ? 1 : 0,
  86               (str[i] & 0xFF) & 0x40 ? 1 : 0,
  87               (str[i] & 0xFF) & 0x20 ? 1 : 0,
  88               (str[i] & 0xFF) & 0x10 ? 1 : 0,
  89               (str[i] & 0xFF) & 0x08 ? 1 : 0,
  90               (str[i] & 0xFF) & 0x04 ? 1 : 0,
  91               (str[i] & 0xFF) & 0x02 ? 1 : 0, (str[i] & 0xFF) & 0x01 ? 1 : 0);
  92       if ((i + 1) % 3 == 0)
  93         printf (" ");
  94       if ((i + 1) % 6 == 0 && i + 1 < len)
  95         printf ("\n\t;; ");
  96     }
  97 }
  98
  99 struct stringprep
 100 {
 101   char *in;
 102   int flags;
 103   char *out;
 104   Stringprep_profile *profile;
 105   int rc;
 106 }
 107 strprep[] =
 108 {
 109   /* map to nothing U+00AD */
 110   {
 111   "foo\xC2\xAD" "bar", 0, "foobar", stringprep_generic}
 112   ,
 113     /* map case_nfkc + normalization: */
 114   {
 115   "\xC2\xB5", 0, "\xCE\xBC", stringprep_generic}
 116   ,
 117     /* case_nonfkc: */
 118   {
 119   "\xC2\xB5", STRINGPREP_NO_NFKC, "\xCE\xBC", stringprep_generic}
 120   ,
 121   {
 122   "\xC2\xAA", 0, "\x61", stringprep_generic}
 123   ,
 124     /* nameprep, exposed a bug in libstringprep 0.0.5 */
 125   {
 126   "\xC2\xAA\x0A", 0, "\x61\x0A", stringprep_nameprep}
 127   ,
 128     /* unassigned code point U+0221: */
 129   {
 130   "\xC8\xA1", 0, "\xC8\xA1", stringprep_generic}
 131   ,
 132     /* unassigned code point U+0221: */
 133   {
 134   "\xC8\xA1", STRINGPREP_NO_UNASSIGNED, NULL, stringprep_generic,
 135       STRINGPREP_CONTAINS_UNASSIGNED}
 136   ,
 137     /* unassigned code point U+0236: */
 138   {
 139   "\xC8\xB6", 0, "\xC8\xB6", stringprep_generic}
 140   ,
 141     /* unassigned code point U+0236: */
 142   {
 143   "\xC8\xB6", STRINGPREP_NO_UNASSIGNED, NULL, stringprep_generic,
 144       STRINGPREP_CONTAINS_UNASSIGNED}
 145   ,
 146     /* prohibited ASCII character U+0020: */
 147   {
 148   "\x20", 0, NULL, stringprep_generic, STRINGPREP_CONTAINS_PROHIBITED}
 149   ,
 150     /* prohibited character U+00A0: */
 151   {
 152   "\xC2\xA0", 0, NULL, stringprep_generic, STRINGPREP_CONTAINS_PROHIBITED}
 153   ,
 154     /* prohibited non-character U+10FFFE: */
 155   {
 156   "\xF4\x8F\xBF\xBE", 0, NULL, stringprep_generic,
 157       STRINGPREP_CONTAINS_PROHIBITED}
 158   ,
 159     /* prohibited surrogate character U+D801: */
 160   {
 161   "\xED\xA0\x81", 0, NULL, stringprep_generic,
 162       STRINGPREP_CONTAINS_PROHIBITED}
 163   ,
 164     /* bidi RandALCat without trailing RandALCat <U+0627><U+0031>: */
 165   {
 166   "\xD8\xA7\x31", 0, NULL, stringprep_generic,
 167       STRINGPREP_BIDI_LEADTRAIL_NOT_RAL}
 168   ,
 169     /* bidi RandALCat correct  <U+0627><U+0031><U+0628>: */
 170   {
 171   "\xD8\xA7\x31\xD8\xA8", 0, "\xD8\xA7\x31\xD8\xA8", stringprep_generic}
 172   ,
 173     /* bidi both RandALCat and LCat  <U+0627><U+00AA><U+0628>: */
 174   {
 175   "\xD8\xA7\xC2\xAA\xD8\xA8", 0, NULL, stringprep_generic,
 176       STRINGPREP_BIDI_BOTH_L_AND_RAL}
 177   ,
 178     /* case mapping (this triggered a bug in 0.0.5) */
 179   {
 180   "CAFE", 0, "cafe", stringprep_generic}
 181 };
 182
 183 int
 184 main (int argc, char *argv[])
 185 {
 186   char *p;
 187   int rc, i;
 188
 189   if (!stringprep_check_version (STRINGPREP_VERSION))
 190     fail ("stringprep_check_version() failed\n");
 191
 192   do
 193     if (strcmp (argv[argc - 1], "-v") == 0 ||
 194         strcmp (argv[argc - 1], "--verbose") == 0)
 195       debug = 1;
 196     else if (strcmp (argv[argc - 1], "-b") == 0 ||
 197              strcmp (argv[argc - 1], "--break-on-error") == 0)
 198       break_on_error = 1;
 199     else if (strcmp (argv[argc - 1], "-h") == 0 ||
 200              strcmp (argv[argc - 1], "-?") == 0 ||
 201              strcmp (argv[argc - 1], "--help") == 0)
 202       {
 203         printf ("Usage: %s [-vbh?] [--verbose] [--break-on-error] [--help]\n",
 204                 argv[0]);
 205         return 1;
 206       }
 207   while (argc-- > 1);
 208
 209   p = malloc (BUFSIZ);
 210   if (p == NULL)
 211     fail ("malloc() returned NULL\n");
 212
 213   for (i = 0; i < sizeof (strprep) / sizeof (strprep[0]); i++)
 214     {
 215       if (debug)
 216         printf ("STRINGPREP entry %d\n", i);
 217
 218       strcpy (p, strprep[i].in);
 219
 220       if (debug)
 221         {
 222           printf ("flags: %d\n", strprep[i].flags);
 223
 224           printf ("in:\n");
 225           escapeprint (strprep[i].in, strlen (strprep[i].in));
 226           hexprint (strprep[i].in, strlen (strprep[i].in));
 227           puts ("");
 228           binprint (strprep[i].in, strlen (strprep[i].in));
 229           puts ("");
 230         }
 231
 232       rc = stringprep (p, BUFSIZ, strprep[i].flags, strprep[i].profile);
 233       if (rc != strprep[i].rc)
 234         {
 235           fail ("stringprep() entry %d failed: %d\n", i, rc);
 236           if (debug)
 237             printf ("FATAL\n");
 238           continue;
 239         }
 240
 241       if (debug && rc == STRINGPREP_OK)
 242         {
 243           printf ("out:\n");
 244           escapeprint (p, strlen (p));
 245           hexprint (p, strlen (p));
 246           puts ("");
 247           binprint (p, strlen (p));
 248           puts ("");
 249
 250           printf ("expected out:\n");
 251           escapeprint (strprep[i].out, strlen (strprep[i].out));
 252           hexprint (strprep[i].out, strlen (strprep[i].out));
 253           puts ("");
 254           binprint (strprep[i].out, strlen (strprep[i].out));
 255           puts ("");
 256         }
 257       else if (debug)
 258         printf ("returned %d expected %d\n", rc, strprep[i].rc);
 259
 260       if (rc == STRINGPREP_OK)
 261         {
 262           if (strlen (strprep[i].out) != strlen (p) ||
 263               memcmp (strprep[i].out, p, strlen (p)) != 0)
 264             {
 265               fail ("stringprep() entry %d failed\n", i);
 266               if (debug)
 267                 printf ("ERROR\n");
 268             }
 269           else if (debug)
 270             printf ("OK\n\n");
 271         }
 272       else if (debug)
 273         printf ("OK\n\n");
 274     }
 275
 276   free (p);
 277
 278 #if 0
 279   memset (p, 0, 10);
 280   stringprep_unichar_to_utf8 (0x0628, p);
 281   hexprint (p, strlen (p));
 282   puts ("");
 283 #endif
 284
 285   if (debug)
 286     printf ("Stringprep self tests done with %d errors\n", error_count);
 287
 288   return error_count ? 1 : 0;
 289 }