tests/uninorm/test-u8-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 int
  40 main ()
  41 {
  42   /* Empty string.  */
  43   {
  44     int cmp;
  45
  46     ASSERT (u8_normcmp (NULL, 0, NULL, 0, UNINORM_NFD, &cmp) == 0);
  47     ASSERT (cmp == 0);
  48   }
  49   {
  50     static const uint8_t input[] = { 'x', 'y' };
  51     int cmp;
  52
  53     ASSERT (u8_normcmp (input, SIZEOF (input), NULL, 0, UNINORM_NFD, &cmp) == 0);
  54     ASSERT (cmp == 1);
  55
  56     ASSERT (u8_normcmp (NULL, 0, input, SIZEOF (input), UNINORM_NFD, &cmp) == 0);
  57     ASSERT (cmp == -1);
  58
  59     ASSERT (u8_normcmp (input, SIZEOF (input), input, SIZEOF (input), UNINORM_NFD, &cmp) == 0);
  60     ASSERT (cmp == 0);
  61   }
  62
  63   /* Shorter and longer strings.  */
  64   {
  65     static const uint8_t input1[] = { 'R', 'e', 'a', 'g', 'a', 'n' };
  66     static const uint8_t input2[] = { 'R', 'e', 'a', 'g', 'a', 'n', 'o', 'm', 'i', 'c', 's' };
  67     int cmp;
  68
  69     ASSERT (u8_normcmp (input1, SIZEOF (input1), input2, SIZEOF (input2), UNINORM_NFD, &cmp) == 0);
  70     ASSERT (cmp == -1);
  71
  72     ASSERT (u8_normcmp (input2, SIZEOF (input2), input1, SIZEOF (input1), UNINORM_NFD, &cmp) == 0);
  73     ASSERT (cmp == 1);
  74   }
  75
  76   /* Normalization effects.  */
  77   {
  78     static const uint8_t input1[] = { 'H', 0xC3, 0xB6, 'h', 'l', 'e' };
  79     static const uint8_t input2[] = { 'H', 'o', 0xCC, 0x88, 'h', 'l', 'e' };
  80     static const uint8_t input3[] = { 'H', 0xC3, 0xB6, 'h', 'l', 'e', 'n' };
  81     static const uint8_t input4[] = { 'H', 'o', 0xCC, 0x88, 'h', 'l', 'e', 'n' };
  82     static const uint8_t input5[] = { 'H', 'u', 'r', 'z' };
  83     int cmp;
  84
  85     ASSERT (u8_normcmp (input1, SIZEOF (input1), input2, SIZEOF (input2), UNINORM_NFD, &cmp) == 0);
  86     ASSERT (cmp == 0);
  87
  88     ASSERT (u8_normcmp (input2, SIZEOF (input2), input1, SIZEOF (input1), UNINORM_NFD, &cmp) == 0);
  89     ASSERT (cmp == 0);
  90
  91     ASSERT (u8_normcmp (input3, SIZEOF (input3), input4, SIZEOF (input4), UNINORM_NFD, &cmp) == 0);
  92     ASSERT (cmp == 0);
  93
  94     ASSERT (u8_normcmp (input4, SIZEOF (input4), input3, SIZEOF (input3), UNINORM_NFD, &cmp) == 0);
  95     ASSERT (cmp == 0);
  96
  97     ASSERT (u8_normcmp (input2, SIZEOF (input2), input3, SIZEOF (input3), UNINORM_NFD, &cmp) == 0);
  98     ASSERT (cmp == -1);
  99
 100     ASSERT (u8_normcmp (input1, SIZEOF (input1), input4, SIZEOF (input4), UNINORM_NFD, &cmp) == 0);
 101     ASSERT (cmp == -1);
 102
 103     ASSERT (u8_normcmp (input1, SIZEOF (input1), input5, SIZEOF (input5), UNINORM_NFD, &cmp) == 0);
 104     ASSERT (cmp == -1);
 105
 106     ASSERT (u8_normcmp (input2, SIZEOF (input2), input5, SIZEOF (input5), UNINORM_NFD, &cmp) == 0);
 107     ASSERT (cmp == -1);
 108   }
 109
 110   return 0;
 111 }