tests/uninorm/test-u32-normcmp.c

   1 /* Test of normalization insensitive comparison of UTF-32 strings.
   2    Copyright (C) 2009 Free Software Foundation, Inc.
   3
   4    This program is free software: you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation; either version 3 of the License, or
   7    (at your option) any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  16
  17 /* Written by Bruno Haible <bruno@clisp.org>, 2009.  */
  18
  19 #include <config.h>
  20
  21 #include "uninorm.h"
  22
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25
  26 #define SIZEOF(array) (sizeof (array) / sizeof (array[0]))
  27 #define ASSERT(expr) \
  28   do                                                                         \
  29     {                                                                        \
  30       if (!(expr))                                                           \
  31         {                                                                    \
  32           fprintf (stderr, "%s:%d: assertion failed\n", __FILE__, __LINE__); \
  33           fflush (stderr);                                                   \
  34           abort ();                                                          \
  35         }                                                                    \
  36     }                                                                        \
  37   while (0)
  38
  39 #include "test-u32-normcmp.h"
  40
  41 static void
  42 test_nonascii (int (*my_normcmp) (const uint32_t *, size_t, const uint32_t *, size_t, uninorm_t, int *))
  43 {
  44   /* Normalization effects.  */
  45   {
  46     static const uint32_t input1[] = { 'H', 0x00F6, 'h', 'l', 'e' };
  47     static const uint32_t input2[] = { 'H', 'o', 0x0308, 'h', 'l', 'e' };
  48     static const uint32_t input3[] = { 'H', 0x00F6, 'h', 'l', 'e', 'n' };
  49     static const uint32_t input4[] = { 'H', 'o', 0x0308, 'h', 'l', 'e', 'n' };
  50     static const uint32_t input5[] = { 'H', 'u', 'r', 'z' };
  51     int cmp;
  52
  53     ASSERT (my_normcmp (input1, SIZEOF (input1), input2, SIZEOF (input2), UNINORM_NFD, &cmp) == 0);
  54     ASSERT (cmp == 0);
  55
  56     ASSERT (my_normcmp (input2, SIZEOF (input2), input1, SIZEOF (input1), UNINORM_NFD, &cmp) == 0);
  57     ASSERT (cmp == 0);
  58
  59     ASSERT (my_normcmp (input3, SIZEOF (input3), input4, SIZEOF (input4), UNINORM_NFD, &cmp) == 0);
  60     ASSERT (cmp == 0);
  61
  62     ASSERT (my_normcmp (input4, SIZEOF (input4), input3, SIZEOF (input3), UNINORM_NFD, &cmp) == 0);
  63     ASSERT (cmp == 0);
  64
  65     ASSERT (my_normcmp (input2, SIZEOF (input2), input3, SIZEOF (input3), UNINORM_NFD, &cmp) == 0);
  66     ASSERT (cmp == -1);
  67
  68     ASSERT (my_normcmp (input1, SIZEOF (input1), input4, SIZEOF (input4), UNINORM_NFD, &cmp) == 0);
  69     ASSERT (cmp == -1);
  70
  71     ASSERT (my_normcmp (input1, SIZEOF (input1), input5, SIZEOF (input5), UNINORM_NFD, &cmp) == 0);
  72     ASSERT (cmp == -1);
  73
  74     ASSERT (my_normcmp (input2, SIZEOF (input2), input5, SIZEOF (input5), UNINORM_NFD, &cmp) == 0);
  75     ASSERT (cmp == -1);
  76   }
  77   { /* LATIN CAPITAL LETTER A WITH DIAERESIS */
  78     static const uint32_t input1[] = { 0x00C4 };
  79     static const uint32_t input2[] = { 0x0041, 0x0308 };
  80     int cmp;
  81
  82     ASSERT (my_normcmp (input1, SIZEOF (input1), input2, SIZEOF (input2), UNINORM_NFD, &cmp) == 0);
  83     ASSERT (cmp == 0);
  84   }
  85   { /* LATIN CAPITAL LETTER A WITH DIAERESIS AND MACRON */
  86     static const uint32_t input1[] = { 0x01DE };
  87     static const uint32_t input2[] = { 0x0041, 0x0308, 0x0304 };
  88     int cmp;
  89
  90     ASSERT (my_normcmp (input1, SIZEOF (input1), input2, SIZEOF (input2), UNINORM_NFD, &cmp) == 0);
  91     ASSERT (cmp == 0);
  92   }
  93   { /* GREEK DIALYTIKA AND PERISPOMENI */
  94     static const uint32_t input1[] = { 0x1FC1 };
  95     static const uint32_t input2[] = { 0x00A8, 0x0342 };
  96     int cmp;
  97
  98     ASSERT (my_normcmp (input1, SIZEOF (input1), input2, SIZEOF (input2), UNINORM_NFD, &cmp) == 0);
  99     ASSERT (cmp == 0);
 100   }
 101   { /* HANGUL SYLLABLE GEUL */
 102     static const uint32_t input1[] = { 0xAE00 };
 103     static const uint32_t input2[] = { 0xADF8, 0x11AF };
 104     static const uint32_t input3[] = { 0x1100, 0x1173, 0x11AF };
 105     int cmp;
 106
 107     ASSERT (my_normcmp (input1, SIZEOF (input1), input2, SIZEOF (input2), UNINORM_NFD, &cmp) == 0);
 108     ASSERT (cmp == 0);
 109
 110     ASSERT (my_normcmp (input1, SIZEOF (input1), input3, SIZEOF (input3), UNINORM_NFD, &cmp) == 0);
 111     ASSERT (cmp == 0);
 112   }
 113   { /* HANGUL SYLLABLE GEU */
 114     static const uint32_t input1[] = { 0xADF8 };
 115     static const uint32_t input2[] = { 0x1100, 0x1173 };
 116     int cmp;
 117
 118     ASSERT (my_normcmp (input1, SIZEOF (input1), input2, SIZEOF (input2), UNINORM_NFD, &cmp) == 0);
 119     ASSERT (cmp == 0);
 120   }
 121 }
 122
 123 int
 124 main ()
 125 {
 126   test_ascii (u32_normcmp, UNINORM_NFD);
 127   test_nonascii (u32_normcmp);
 128
 129   return 0;
 130 }