tests/unicode-normalize.c

   1 #include <glib.h>
   2 #include <stdio.h>
   3 #include <stdlib.h>
   4
   5 gboolean success = TRUE;
   6
   7 static char *
   8 decode (const gchar *input)
   9 {
  10   unsigned ch;
  11   int offset = 0;
  12   GString *result = g_string_new (NULL);
  13   int len;
  14   char buf[6];
  15
  16   do
  17     {
  18       if (sscanf (input + offset, "%x", &ch) != 1)
  19         {
  20           fprintf (stderr, "Error parsing character string %s\n", input);
  21           exit (1);
  22         }
  23
  24       /* FIXME: We don't handle the > BMP or Hangul syllables */
  25       if (ch > 0xffff ||                 /* > BMP */
  26           (ch >= 0xac00 && ch <= 0xd7ff))  /* Hangul syllables */
  27         {
  28           g_string_free (result, TRUE);
  29           return NULL;
  30         }
  31
  32       len = g_unichar_to_utf8 (ch, buf);
  33       g_string_append_len (result, buf, len);
  34
  35       while (input[offset] && input[offset] != ' ')
  36         offset++;
  37       while (input[offset] && input[offset] == ' ')
  38         offset++;
  39     }
  40   while (input[offset]);
  41
  42   return g_string_free (result, FALSE);
  43 }
  44
  45 const char *names[4] = {
  46   "NFD",
  47   "NFC",
  48   "NFKD",
  49   "NFKC"
  50 };
  51
  52 static void
  53 test_form (int            line,
  54            GNormalizeMode mode,
  55            gboolean       do_compat,
  56            int            expected,
  57            char         **c,
  58            char         **raw)
  59 {
  60   int i;
  61
  62   gboolean mode_is_compat = (mode == G_NORMALIZE_NFKC ||
  63                              mode == G_NORMALIZE_NFKD);
  64
  65   if (mode_is_compat || !do_compat)
  66     {
  67       for (i = 0; i < 3; i++)
  68         {
  69           char *result = g_utf8_normalize (c[i], mode);
  70           if (strcmp (result, c[expected]) != 0)
  71             {
  72               fprintf (stderr, "\nFailure: %d/%d: %s\n", line, i + 1, raw[5]);
  73               fprintf (stderr, "  g_utf8_normalize (%s, %s) != %s\n",
  74                    raw[i], names[mode], raw[expected]);
  75               success = FALSE;
  76             }
  77
  78           g_free (result);
  79         }
  80     }
  81   if (mode_is_compat || do_compat)
  82     {
  83       for (i = 3; i < 5; i++)
  84         {
  85           char *result = g_utf8_normalize (c[i], mode);
  86           if (strcmp (result, c[expected]) != 0)
  87             {
  88               fprintf (stderr, "\nFailure: %d/%d: %s\n", line, i, raw[5]);
  89               fprintf (stderr, "  g_utf8_normalize (%s, %s) != %s\n",
  90                    raw[i], names[mode], raw[expected]);
  91               success = FALSE;
  92             }
  93
  94           g_free (result);
  95         }
  96     }
  97 }
  98
  99 static gboolean
 100 process_one (int line, gchar **columns)
 101 {
 102   char *c[5];
 103   int i;
 104   gboolean skip = FALSE;
 105
 106   for (i=0; i < 5; i++)
 107     {
 108       c[i] = decode(columns[i]);
 109       if (!c[i])
 110         skip = TRUE;
 111     }
 112
 113   if (!skip)
 114     {
 115       test_form (line, G_NORMALIZE_NFD, FALSE, 2, c, columns);
 116       test_form (line, G_NORMALIZE_NFD, TRUE, 4, c, columns);
 117       test_form (line, G_NORMALIZE_NFC, FALSE, 1, c, columns);
 118       test_form (line, G_NORMALIZE_NFC, TRUE, 3, c, columns);
 119       test_form (line, G_NORMALIZE_NFKD, TRUE, 4, c, columns);
 120       test_form (line, G_NORMALIZE_NFKC, TRUE, 3, c, columns);
 121     }
 122
 123   for (i=0; i < 5; i++)
 124     g_free (c[i]);
 125
 126   return TRUE;
 127 }
 128
 129 int main (int argc, char **argv)
 130 {
 131   GIOChannel *in;
 132   GError *error = NULL;
 133   GString *buffer = g_string_new (NULL);
 134   int line_to_do = 0;
 135   int line = 1;
 136
 137   if (argc != 2 && argc != 3)
 138     {
 139       fprintf (stderr, "Usage: unicode-normalize NormalizationTest.txt LINE\n");
 140       return 1;
 141     }
 142
 143   if (argc == 3)
 144     line_to_do = atoi(argv[2]);
 145
 146   in = g_io_channel_new_file (argv[1], G_IO_FILE_MODE_READ, &error);
 147   if (!in)
 148     {
 149       fprintf (stderr, "Cannot open %s: %s\n", argv[1], error->message);
 150       return 1;
 151     }
 152
 153   while (TRUE)
 154     {
 155       gsize term_pos;
 156       gchar **columns;
 157
 158       if (g_io_channel_read_line_string (in, buffer, &term_pos, &error) != G_IO_STATUS_NORMAL)
 159         break;
 160
 161       if (line_to_do && line != line_to_do)
 162         goto next;
 163
 164       buffer->str[term_pos] = '\0';
 165
 166       if (buffer->str[0] == '#') /* Comment */
 167         goto next;
 168       if (buffer->str[0] == '@') /* Part */
 169         {
 170           fprintf (stderr, "\nProcessing %s\n", buffer->str + 1);
 171           goto next;
 172         }
 173
 174       columns = g_strsplit (buffer->str, ";", -1);
 175       if (!process_one (line, columns))
 176         return 1;
 177       g_strfreev (columns);
 178
 179     next:
 180       g_string_truncate (buffer, 0);
 181       line++;
 182     }
 183
 184   if (error)
 185     {
 186       fprintf (stderr, "Error reading test file, %s\n", error->message);
 187       return 1;
 188     }
 189
 190   g_io_channel_close (in);
 191   g_string_free (buffer, TRUE);
 192
 193   return !success;
 194 }