1 /* Test of case and normalization insensitive comparison of UTF-8 strings.
2 Copyright (C) 2009-2020 Free Software Foundation, Inc.
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.
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.
14 You should have received a copy of the GNU General Public License
15 along with this program. If not, see <https://www.gnu.org/licenses/>. */
17 /* Written by Bruno Haible <bruno@clisp.org>, 2009. */
27 #include "test-casecmp.h"
31 test_nonascii (int (*my_casecmp
) (const uint8_t *, size_t, const uint8_t *, size_t, const char *, uninorm_t
, int *))
33 /* Normalization effects. */
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' };
42 ASSERT (my_casecmp (input1
, SIZEOF (input1
), input2
, SIZEOF (input2
), NULL
, UNINORM_NFD
, &cmp
) == 0);
45 ASSERT (my_casecmp (input2
, SIZEOF (input2
), input1
, SIZEOF (input1
), NULL
, UNINORM_NFD
, &cmp
) == 0);
48 ASSERT (my_casecmp (input3
, SIZEOF (input3
), input4
, SIZEOF (input4
), NULL
, UNINORM_NFD
, &cmp
) == 0);
51 ASSERT (my_casecmp (input4
, SIZEOF (input4
), input3
, SIZEOF (input3
), NULL
, UNINORM_NFD
, &cmp
) == 0);
54 ASSERT (my_casecmp (input2
, SIZEOF (input2
), input3
, SIZEOF (input3
), NULL
, UNINORM_NFD
, &cmp
) == 0);
57 ASSERT (my_casecmp (input1
, SIZEOF (input1
), input4
, SIZEOF (input4
), NULL
, UNINORM_NFD
, &cmp
) == 0);
60 ASSERT (my_casecmp (input1
, SIZEOF (input1
), input5
, SIZEOF (input5
), NULL
, UNINORM_NFD
, &cmp
) == 0);
63 ASSERT (my_casecmp (input2
, SIZEOF (input2
), input5
, SIZEOF (input5
), NULL
, UNINORM_NFD
, &cmp
) == 0);
66 { /* LATIN CAPITAL LETTER A WITH DIAERESIS */
67 static const uint8_t input1
[] = { 0xC3, 0x84 };
68 static const uint8_t input2
[] = { 0x41, 0xCC, 0x88 };
71 ASSERT (my_casecmp (input1
, SIZEOF (input1
), input2
, SIZEOF (input2
), NULL
, UNINORM_NFD
, &cmp
) == 0);
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 };
79 ASSERT (my_casecmp (input1
, SIZEOF (input1
), input2
, SIZEOF (input2
), NULL
, UNINORM_NFD
, &cmp
) == 0);
82 { /* GREEK DIALYTIKA AND PERISPOMENI */
83 static const uint8_t input1
[] = { 0xE1, 0xBF, 0x81 };
84 static const uint8_t input2
[] = { 0xC2, 0xA8, 0xCD, 0x82 };
87 ASSERT (my_casecmp (input1
, SIZEOF (input1
), input2
, SIZEOF (input2
), NULL
, UNINORM_NFD
, &cmp
) == 0);
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 };
96 ASSERT (my_casecmp (input1
, SIZEOF (input1
), input2
, SIZEOF (input2
), NULL
, UNINORM_NFD
, &cmp
) == 0);
99 ASSERT (my_casecmp (input1
, SIZEOF (input1
), input3
, SIZEOF (input3
), NULL
, UNINORM_NFD
, &cmp
) == 0);
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 };
107 ASSERT (my_casecmp (input1
, SIZEOF (input1
), input2
, SIZEOF (input2
), NULL
, UNINORM_NFD
, &cmp
) == 0);
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'
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'
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'
145 ASSERT (my_casecmp (input1
, SIZEOF (input1
), input2
, SIZEOF (input2
), NULL
, NULL
, &cmp
) == 0);
148 ASSERT (my_casecmp (input1
, SIZEOF (input1
), input2
, SIZEOF (input2
), NULL
, UNINORM_NFD
, &cmp
) == 0);
151 ASSERT (my_casecmp (input1
, SIZEOF (input1
), input3
, SIZEOF (input3
), NULL
, NULL
, &cmp
) == 0);
154 ASSERT (my_casecmp (input1
, SIZEOF (input1
), input3
, SIZEOF (input3
), NULL
, UNINORM_NFD
, &cmp
) == 0);
157 ASSERT (my_casecmp (input2
, SIZEOF (input2
), input3
, SIZEOF (input3
), NULL
, NULL
, &cmp
) == 0);
160 ASSERT (my_casecmp (input2
, SIZEOF (input2
), input3
, SIZEOF (input3
), NULL
, UNINORM_NFD
, &cmp
) == 0);
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 };
171 ASSERT (my_casecmp (input1
, SIZEOF (input1
), input2
, SIZEOF (input2
), NULL
, NULL
, &cmp
) == 0);
174 ASSERT (my_casecmp (input1
, SIZEOF (input1
), input2
, SIZEOF (input2
), NULL
, UNINORM_NFD
, &cmp
) == 0);
177 ASSERT (my_casecmp (input1
, SIZEOF (input1
), input3
, SIZEOF (input3
), NULL
, NULL
, &cmp
) == 0);
180 ASSERT (my_casecmp (input1
, SIZEOF (input1
), input3
, SIZEOF (input3
), NULL
, UNINORM_NFD
, &cmp
) == 0);
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 };
188 ASSERT (my_casecmp (input1
, SIZEOF (input1
), input2
, SIZEOF (input2
), NULL
, NULL
, &cmp
) == 0);
191 ASSERT (my_casecmp (input1
, SIZEOF (input1
), input2
, SIZEOF (input2
), NULL
, UNINORM_NFD
, &cmp
) == 0);
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 };
202 ASSERT (my_casecmp (input
, SIZEOF (input
), casefolded
, SIZEOF (casefolded
), NULL
, NULL
, &cmp
) == 0);
205 ASSERT (my_casecmp (input
, SIZEOF (input
), casefolded_tr
, SIZEOF (casefolded_tr
), "tr", NULL
, &cmp
) == 0);
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 };
214 ASSERT (my_casecmp (input
, SIZEOF (input
), casefolded
, SIZEOF (casefolded
), NULL
, NULL
, &cmp
) == 0);
217 ASSERT (my_casecmp (input
, SIZEOF (input
), casefolded_tr
, SIZEOF (casefolded_tr
), "tr", NULL
, &cmp
) == 0);
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 };
226 ASSERT (my_casecmp (input
, SIZEOF (input
), casefolded
, SIZEOF (casefolded
), NULL
, NULL
, &cmp
) == 0);
229 ASSERT (my_casecmp (input
, SIZEOF (input
), casefolded_tr
, SIZEOF (casefolded_tr
), "tr", NULL
, &cmp
) == 0);
232 { /* LATIN SMALL LETTER DOTLESS I */
233 static const uint8_t input
[] = { 0xC4, 0xB1 };
234 static const uint8_t casefolded
[] = { 0x49 };
237 ASSERT (my_casecmp (input
, SIZEOF (input
), casefolded
, SIZEOF (casefolded
), NULL
, NULL
, &cmp
) == 0);
240 ASSERT (my_casecmp (input
, SIZEOF (input
), casefolded
, SIZEOF (casefolded
), "tr", NULL
, &cmp
) == 0);
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 };
250 ASSERT (my_casecmp (input
, SIZEOF (input
), casefolded
, SIZEOF (casefolded
), NULL
, NULL
, &cmp
) == 0);
253 ASSERT (my_casecmp (input
, SIZEOF (input
), casefolded
, SIZEOF (casefolded
), "tr", NULL
, &cmp
) == 0);
257 /* Uppercasing can increase the number of Unicode characters. */
259 static const uint8_t input1
[] = { 0x68, 0x65, 0x69, 0xC3, 0x9F };
260 static const uint8_t input2
[] = { 0x68, 0x65, 0x69, 0x73, 0x73 };
263 ASSERT (my_casecmp (input1
, SIZEOF (input1
), input2
, SIZEOF (input2
), NULL
, NULL
, &cmp
) == 0);
267 /* Case mappings for some characters can depend on the surrounding characters. */
268 { /* "περισσότερες πληροφορίες" */
269 static const uint8_t input1
[] =
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
276 static const uint8_t input2
[] =
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
283 static const uint8_t input3
[] =
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
292 ASSERT (my_casecmp (input1
, SIZEOF (input1
), input2
, SIZEOF (input2
), NULL
, NULL
, &cmp
) == 0);
295 ASSERT (my_casecmp (input1
, SIZEOF (input1
), input3
, SIZEOF (input3
), NULL
, NULL
, &cmp
) == 0);
298 ASSERT (my_casecmp (input2
, SIZEOF (input2
), input3
, SIZEOF (input3
), NULL
, NULL
, &cmp
) == 0);
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 };
309 ASSERT (my_casecmp (input
, SIZEOF (input
), casefolded
, SIZEOF (casefolded
), NULL
, NULL
, &cmp
) == 0);
312 ASSERT (my_casecmp (input
, SIZEOF (input
), casefolded_decomposed
, SIZEOF (casefolded_decomposed
), NULL
, NULL
, &cmp
) == 0);
315 ASSERT (my_casecmp (input
, SIZEOF (input
), casefolded
, SIZEOF (casefolded
), NULL
, UNINORM_NFD
, &cmp
) == 0);
318 ASSERT (my_casecmp (input
, SIZEOF (input
), casefolded_decomposed
, SIZEOF (casefolded_decomposed
), NULL
, UNINORM_NFD
, &cmp
) == 0);
326 test_ascii (u8_casecmp
, UNINORM_NFD
);
327 test_nonascii (u8_casecmp
);