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