1/* Test of case and normalization insensitive comparison of UTF-8 strings.
2   Copyright (C) 2009, 2010 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 "unicase.h"
22
23#include "uninorm.h"
24#include "macros.h"
25
26#define UNIT uint8_t
27#include "test-casecmp.h"
28#undef UNIT
29
30static void
31test_nonascii (int (*my_casecmp) (const uint8_t *, size_t, const uint8_t *, size_t, const char *, uninorm_t, int *))
32{
33  /* Normalization effects.  */
34  {
35    static const uint8_t input1[] = { 'H', 0xC3, 0xB6, 'h', 'l', 'e' };
36    static const uint8_t input2[] = { 'H', 'O', 0xCC, 0x88, 'h', 'L', 'e' };
37    static const uint8_t input3[] = { 'H', 0xC3, 0xB6, 'h', 'l', 'e', 'n' };
38    static const uint8_t input4[] = { 'H', 'O', 0xCC, 0x88, 'h', 'L', 'e', 'n' };
39    static const uint8_t input5[] = { 'H', 'u', 'r', 'z' };
40    int cmp;
41
42    ASSERT (my_casecmp (input1, SIZEOF (input1), input2, SIZEOF (input2), NULL, UNINORM_NFD, &cmp) == 0);
43    ASSERT (cmp == 0);
44
45    ASSERT (my_casecmp (input2, SIZEOF (input2), input1, SIZEOF (input1), NULL, UNINORM_NFD, &cmp) == 0);
46    ASSERT (cmp == 0);
47
48    ASSERT (my_casecmp (input3, SIZEOF (input3), input4, SIZEOF (input4), NULL, UNINORM_NFD, &cmp) == 0);
49    ASSERT (cmp == 0);
50
51    ASSERT (my_casecmp (input4, SIZEOF (input4), input3, SIZEOF (input3), NULL, UNINORM_NFD, &cmp) == 0);
52    ASSERT (cmp == 0);
53
54    ASSERT (my_casecmp (input2, SIZEOF (input2), input3, SIZEOF (input3), NULL, UNINORM_NFD, &cmp) == 0);
55    ASSERT (cmp == -1);
56
57    ASSERT (my_casecmp (input1, SIZEOF (input1), input4, SIZEOF (input4), NULL, UNINORM_NFD, &cmp) == 0);
58    ASSERT (cmp == -1);
59
60    ASSERT (my_casecmp (input1, SIZEOF (input1), input5, SIZEOF (input5), NULL, UNINORM_NFD, &cmp) == 0);
61    ASSERT (cmp == -1);
62
63    ASSERT (my_casecmp (input2, SIZEOF (input2), input5, SIZEOF (input5), NULL, UNINORM_NFD, &cmp) == 0);
64    ASSERT (cmp == -1);
65  }
66  { /* LATIN CAPITAL LETTER A WITH DIAERESIS */
67    static const uint8_t input1[] = { 0xC3, 0x84 };
68    static const uint8_t input2[] = { 0x41, 0xCC, 0x88 };
69    int cmp;
70
71    ASSERT (my_casecmp (input1, SIZEOF (input1), input2, SIZEOF (input2), NULL, UNINORM_NFD, &cmp) == 0);
72    ASSERT (cmp == 0);
73  }
74  { /* LATIN CAPITAL LETTER A WITH DIAERESIS AND MACRON */
75    static const uint8_t input1[] = { 0xC7, 0x9E };
76    static const uint8_t input2[] = { 0x41, 0xCC, 0x88, 0xCC, 0x84 };
77    int cmp;
78
79    ASSERT (my_casecmp (input1, SIZEOF (input1), input2, SIZEOF (input2), NULL, UNINORM_NFD, &cmp) == 0);
80    ASSERT (cmp == 0);
81  }
82  { /* GREEK DIALYTIKA AND PERISPOMENI */
83    static const uint8_t input1[] = { 0xE1, 0xBF, 0x81 };
84    static const uint8_t input2[] = { 0xC2, 0xA8, 0xCD, 0x82 };
85    int cmp;
86
87    ASSERT (my_casecmp (input1, SIZEOF (input1), input2, SIZEOF (input2), NULL, UNINORM_NFD, &cmp) == 0);
88    ASSERT (cmp == 0);
89  }
90  { /* HANGUL SYLLABLE GEUL */
91    static const uint8_t input1[] = { 0xEA, 0xB8, 0x80 };
92    static const uint8_t input2[] = { 0xEA, 0xB7, 0xB8, 0xE1, 0x86, 0xAF };
93    static const uint8_t input3[] = { 0xE1, 0x84, 0x80, 0xE1, 0x85, 0xB3, 0xE1, 0x86, 0xAF };
94    int cmp;
95
96    ASSERT (my_casecmp (input1, SIZEOF (input1), input2, SIZEOF (input2), NULL, UNINORM_NFD, &cmp) == 0);
97    ASSERT (cmp == 0);
98
99    ASSERT (my_casecmp (input1, SIZEOF (input1), input3, SIZEOF (input3), NULL, UNINORM_NFD, &cmp) == 0);
100    ASSERT (cmp == 0);
101  }
102  { /* HANGUL SYLLABLE GEU */
103    static const uint8_t input1[] = { 0xEA, 0xB7, 0xB8 };
104    static const uint8_t input2[] = { 0xE1, 0x84, 0x80, 0xE1, 0x85, 0xB3 };
105    int cmp;
106
107    ASSERT (my_casecmp (input1, SIZEOF (input1), input2, SIZEOF (input2), NULL, UNINORM_NFD, &cmp) == 0);
108    ASSERT (cmp == 0);
109  }
110
111  /* Simple string.  */
112  { /* "Gr���� Gott. ������������������������! x=(-b��sqrt(b��-4ac))/(2a)  ���������,������,������" */
113    static const uint8_t input1[] =
114      { 'G', 'r', 0xC3, 0xBC, 0xC3, 0x9F, ' ', 'G', 'o', 't', 't', '.', ' ',
115        0xD0, 0x97, 0xD0, 0xB4, 0xD1, 0x80, 0xD0, 0xB0, 0xD0, 0xB2, 0xD1, 0x81,
116        0xD1, 0x82, 0xD0, 0xB2, 0xD1, 0x83, 0xD0, 0xB9, 0xD1, 0x82, 0xD0, 0xB5,
117        '!', ' ', 'x', '=', '(', '-', 'b', 0xC2, 0xB1, 's', 'q', 'r', 't', '(',
118        'b', 0xC2, 0xB2, '-', '4', 'a', 'c', ')', ')', '/', '(', '2', 'a', ')',
119        ' ', ' ', 0xE6, 0x97, 0xA5, 0xE6, 0x9C, 0xAC, 0xE8, 0xAA, 0x9E, ',',
120        0xE4, 0xB8, 0xAD, 0xE6, 0x96, 0x87, ',',
121        0xED, 0x95, 0x9C, 0xEA, 0xB8, 0x80, '\n'
122      };
123    static const uint8_t input2[] =
124      { 'g', 'r', 0xC3, 0xBC, 0x73, 0x73, ' ', 'g', 'o', 't', 't', '.', ' ',
125        0xD0, 0xB7, 0xD0, 0xB4, 0xD1, 0x80, 0xD0, 0xB0, 0xD0, 0xB2, 0xD1, 0x81,
126        0xD1, 0x82, 0xD0, 0xB2, 0xD1, 0x83, 0xD0, 0xB9, 0xD1, 0x82, 0xD0, 0xB5,
127        '!', ' ', 'x', '=', '(', '-', 'b', 0xC2, 0xB1, 's', 'q', 'r', 't', '(',
128        'b', 0xC2, 0xB2, '-', '4', 'a', 'c', ')', ')', '/', '(', '2', 'a', ')',
129        ' ', ' ', 0xE6, 0x97, 0xA5, 0xE6, 0x9C, 0xAC, 0xE8, 0xAA, 0x9E, ',',
130        0xE4, 0xB8, 0xAD, 0xE6, 0x96, 0x87, ',',
131        0xED, 0x95, 0x9C, 0xEA, 0xB8, 0x80, '\n'
132      };
133    static const uint8_t input3[] =
134      { 'G', 'R', 0xC3, 0x9C, 0x53, 0x53, ' ', 'G', 'O', 'T', 'T', '.', ' ',
135        0xD0, 0x97, 0xD0, 0x94, 0xD0, 0xA0, 0xD0, 0x90, 0xD0, 0x92, 0xD0, 0xA1,
136        0xD0, 0xA2, 0xD0, 0x92, 0xD0, 0xA3, 0xD0, 0x99, 0xD0, 0xA2, 0xD0, 0x95,
137        '!', ' ', 'X', '=', '(', '-', 'B', 0xC2, 0xB1, 'S', 'Q', 'R', 'T', '(',
138        'B', 0xC2, 0xB2, '-', '4', 'A', 'C', ')', ')', '/', '(', '2', 'A', ')',
139        ' ', ' ', 0xE6, 0x97, 0xA5, 0xE6, 0x9C, 0xAC, 0xE8, 0xAA, 0x9E, ',',
140        0xE4, 0xB8, 0xAD, 0xE6, 0x96, 0x87, ',',
141        0xED, 0x95, 0x9C, 0xEA, 0xB8, 0x80, '\n'
142      };
143    int cmp;
144
145    ASSERT (my_casecmp (input1, SIZEOF (input1), input2, SIZEOF (input2), NULL, NULL, &cmp) == 0);
146    ASSERT (cmp == 0);
147
148    ASSERT (my_casecmp (input1, SIZEOF (input1), input2, SIZEOF (input2), NULL, UNINORM_NFD, &cmp) == 0);
149    ASSERT (cmp == 0);
150
151    ASSERT (my_casecmp (input1, SIZEOF (input1), input3, SIZEOF (input3), NULL, NULL, &cmp) == 0);
152    ASSERT (cmp == 0);
153
154    ASSERT (my_casecmp (input1, SIZEOF (input1), input3, SIZEOF (input3), NULL, UNINORM_NFD, &cmp) == 0);
155    ASSERT (cmp == 0);
156
157    ASSERT (my_casecmp (input2, SIZEOF (input2), input3, SIZEOF (input3), NULL, NULL, &cmp) == 0);
158    ASSERT (cmp == 0);
159
160    ASSERT (my_casecmp (input2, SIZEOF (input2), input3, SIZEOF (input3), NULL, UNINORM_NFD, &cmp) == 0);
161    ASSERT (cmp == 0);
162  }
163
164  /* Case mapping can increase the number of Unicode characters.  */
165  { /* LATIN SMALL LETTER N PRECEDED BY APOSTROPHE */
166    static const uint8_t input1[] = { 0xC5, 0x89 };
167    static const uint8_t input2[] = { 0xCA, 0xBC, 0x6E };
168    static const uint8_t input3[] = { 0xCA, 0xBC, 0x4E };
169    int cmp;
170
171    ASSERT (my_casecmp (input1, SIZEOF (input1), input2, SIZEOF (input2), NULL, NULL, &cmp) == 0);
172    ASSERT (cmp == 0);
173
174    ASSERT (my_casecmp (input1, SIZEOF (input1), input2, SIZEOF (input2), NULL, UNINORM_NFD, &cmp) == 0);
175    ASSERT (cmp == 0);
176
177    ASSERT (my_casecmp (input1, SIZEOF (input1), input3, SIZEOF (input3), NULL, NULL, &cmp) == 0);
178    ASSERT (cmp == 0);
179
180    ASSERT (my_casecmp (input1, SIZEOF (input1), input3, SIZEOF (input3), NULL, UNINORM_NFD, &cmp) == 0);
181    ASSERT (cmp == 0);
182  }
183  { /* GREEK SMALL LETTER IOTA WITH DIALYTIKA AND TONOS */
184    static const uint8_t input1[] = { 0xCE, 0x90 };
185    static const uint8_t input2[] = { 0xCE, 0xB9, 0xCC, 0x88, 0xCC, 0x81 };
186    int cmp;
187
188    ASSERT (my_casecmp (input1, SIZEOF (input1), input2, SIZEOF (input2), NULL, NULL, &cmp) == 0);
189    ASSERT (cmp == 0);
190
191    ASSERT (my_casecmp (input1, SIZEOF (input1), input2, SIZEOF (input2), NULL, UNINORM_NFD, &cmp) == 0);
192    ASSERT (cmp == 0);
193  }
194
195  /* Turkish letters i �� �� I */
196  { /* LATIN CAPITAL LETTER I */
197    static const uint8_t input[]         = { 0x49 };
198    static const uint8_t casefolded[]    = { 0x69 };
199    static const uint8_t casefolded_tr[] = { 0xC4, 0xB1 };
200    int cmp;
201
202    ASSERT (my_casecmp (input, SIZEOF (input), casefolded, SIZEOF (casefolded), NULL, NULL, &cmp) == 0);
203    ASSERT (cmp == 0);
204
205    ASSERT (my_casecmp (input, SIZEOF (input), casefolded_tr, SIZEOF (casefolded_tr), "tr", NULL, &cmp) == 0);
206    ASSERT (cmp == 0);
207  }
208  { /* LATIN SMALL LETTER I */
209    static const uint8_t input[]         = { 0x69 };
210    static const uint8_t casefolded[]    = { 0x49 };
211    static const uint8_t casefolded_tr[] = { 0xC4, 0xB0 };
212    int cmp;
213
214    ASSERT (my_casecmp (input, SIZEOF (input), casefolded, SIZEOF (casefolded), NULL, NULL, &cmp) == 0);
215    ASSERT (cmp == 0);
216
217    ASSERT (my_casecmp (input, SIZEOF (input), casefolded_tr, SIZEOF (casefolded_tr), "tr", NULL, &cmp) == 0);
218    ASSERT (cmp == 0);
219  }
220  { /* LATIN CAPITAL LETTER I WITH DOT ABOVE */
221    static const uint8_t input[]         = { 0xC4, 0xB0 };
222    static const uint8_t casefolded[]    = { 0x69, 0xCC, 0x87 };
223    static const uint8_t casefolded_tr[] = { 0x69 };
224    int cmp;
225
226    ASSERT (my_casecmp (input, SIZEOF (input), casefolded, SIZEOF (casefolded), NULL, NULL, &cmp) == 0);
227    ASSERT (cmp == 0);
228
229    ASSERT (my_casecmp (input, SIZEOF (input), casefolded_tr, SIZEOF (casefolded_tr), "tr", NULL, &cmp) == 0);
230    ASSERT (cmp == 0);
231  }
232  { /* LATIN SMALL LETTER DOTLESS I */
233    static const uint8_t input[]      = { 0xC4, 0xB1 };
234    static const uint8_t casefolded[] = { 0x49 };
235    int cmp;
236
237    ASSERT (my_casecmp (input, SIZEOF (input), casefolded, SIZEOF (casefolded), NULL, NULL, &cmp) == 0);
238    ASSERT (cmp == 1);
239
240    ASSERT (my_casecmp (input, SIZEOF (input), casefolded, SIZEOF (casefolded), "tr", NULL, &cmp) == 0);
241    ASSERT (cmp == 0);
242  }
243  { /* "topkap��" */
244    static const uint8_t input[] =
245      { 0x54, 0x4F, 0x50, 0x4B, 0x41, 0x50, 0x49 };
246    static const uint8_t casefolded[] =
247      { 0x74, 0x6F, 0x70, 0x6B, 0x61, 0x70, 0xC4, 0xB1 };
248    int cmp;
249
250    ASSERT (my_casecmp (input, SIZEOF (input), casefolded, SIZEOF (casefolded), NULL, NULL, &cmp) == 0);
251    ASSERT (cmp == -1);
252
253    ASSERT (my_casecmp (input, SIZEOF (input), casefolded, SIZEOF (casefolded), "tr", NULL, &cmp) == 0);
254    ASSERT (cmp == 0);
255  }
256
257  /* Uppercasing can increase the number of Unicode characters.  */
258  { /* "hei��" */
259    static const uint8_t input1[] = { 0x68, 0x65, 0x69, 0xC3, 0x9F };
260    static const uint8_t input2[] = { 0x68, 0x65, 0x69, 0x73, 0x73 };
261    int cmp;
262
263    ASSERT (my_casecmp (input1, SIZEOF (input1), input2, SIZEOF (input2), NULL, NULL, &cmp) == 0);
264    ASSERT (cmp == 0);
265  }
266
267  /* Case mappings for some characters can depend on the surrounding characters.  */
268  { /* "������������������������ ����������������������" */
269    static const uint8_t input1[] =
270      {
271        0xCF, 0x80, 0xCE, 0xB5, 0xCF, 0x81, 0xCE, 0xB9, 0xCF, 0x83, 0xCF, 0x83,
272        0xCF, 0x8C, 0xCF, 0x84, 0xCE, 0xB5, 0xCF, 0x81, 0xCE, 0xB5, 0xCF, 0x82,
273        ' ', 0xCF, 0x80, 0xCE, 0xBB, 0xCE, 0xB7, 0xCF, 0x81, 0xCE, 0xBF,
274        0xCF, 0x86, 0xCE, 0xBF, 0xCF, 0x81, 0xCE, 0xAF, 0xCE, 0xB5, 0xCF, 0x82
275      };
276    static const uint8_t input2[] =
277      {
278        0xCF, 0x80, 0xCE, 0xB5, 0xCF, 0x81, 0xCE, 0xB9, 0xCF, 0x83, 0xCF, 0x83,
279        0xCF, 0x8C, 0xCF, 0x84, 0xCE, 0xB5, 0xCF, 0x81, 0xCE, 0xB5, 0xCF, 0x83,
280        ' ', 0xCF, 0x80, 0xCE, 0xBB, 0xCE, 0xB7, 0xCF, 0x81, 0xCE, 0xBF,
281        0xCF, 0x86, 0xCE, 0xBF, 0xCF, 0x81, 0xCE, 0xAF, 0xCE, 0xB5, 0xCF, 0x83
282      };
283    static const uint8_t input3[] =
284      {
285        0xCE, 0xA0, 0xCE, 0x95, 0xCE, 0xA1, 0xCE, 0x99, 0xCE, 0xA3, 0xCE, 0xA3,
286        0xCE, 0x8C, 0xCE, 0xA4, 0xCE, 0x95, 0xCE, 0xA1, 0xCE, 0x95, 0xCE, 0xA3,
287        ' ', 0xCE, 0xA0, 0xCE, 0x9B, 0xCE, 0x97, 0xCE, 0xA1, 0xCE, 0x9F,
288        0xCE, 0xA6, 0xCE, 0x9F, 0xCE, 0xA1, 0xCE, 0x8A, 0xCE, 0x95, 0xCE, 0xA3
289      };
290    int cmp;
291
292    ASSERT (my_casecmp (input1, SIZEOF (input1), input2, SIZEOF (input2), NULL, NULL, &cmp) == 0);
293    ASSERT (cmp == 0);
294
295    ASSERT (my_casecmp (input1, SIZEOF (input1), input3, SIZEOF (input3), NULL, NULL, &cmp) == 0);
296    ASSERT (cmp == 0);
297
298    ASSERT (my_casecmp (input2, SIZEOF (input2), input3, SIZEOF (input3), NULL, NULL, &cmp) == 0);
299    ASSERT (cmp == 0);
300  }
301
302  /* Case mapping can require subsequent normalization.  */
303  { /* LATIN SMALL LETTER J WITH CARON, COMBINING DOT BELOW */
304    static const uint8_t input[]                 = { 0xC7, 0xB0, 0xCC, 0xA3 };
305    static const uint8_t casefolded[]            = { 0x6A, 0xCC, 0x8C, 0xCC, 0xA3 };
306    static const uint8_t casefolded_decomposed[] = { 0x6A, 0xCC, 0xA3, 0xCC, 0x8C };
307    int cmp;
308
309    ASSERT (my_casecmp (input, SIZEOF (input), casefolded, SIZEOF (casefolded), NULL, NULL, &cmp) == 0);
310    ASSERT (cmp == 0);
311
312    ASSERT (my_casecmp (input, SIZEOF (input), casefolded_decomposed, SIZEOF (casefolded_decomposed), NULL, NULL, &cmp) == 0);
313    ASSERT (cmp != 0);
314
315    ASSERT (my_casecmp (input, SIZEOF (input), casefolded, SIZEOF (casefolded), NULL, UNINORM_NFD, &cmp) == 0);
316    ASSERT (cmp == 0);
317
318    ASSERT (my_casecmp (input, SIZEOF (input), casefolded_decomposed, SIZEOF (casefolded_decomposed), NULL, UNINORM_NFD, &cmp) == 0);
319    ASSERT (cmp == 0);
320  }
321}
322
323int
324main ()
325{
326  test_ascii (u8_casecmp, UNINORM_NFD);
327  test_nonascii (u8_casecmp);
328
329  return 0;
330}
331