Avoid test failures on AIX and OSF/1.
[gnulib.git] / tests / uninorm / test-u32-nfkc.c
1 /* Test of compatibility normalization 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 #if GNULIB_UNINORM_U32_NORMALIZE
22
23 #include "uninorm.h"
24
25 #include <signal.h>
26 #include <stdio.h>
27 #include <stdlib.h>
28 #include <unistd.h>
29
30 #include "unistr.h"
31
32 #define SIZEOF(array) (sizeof (array) / sizeof (array[0]))
33 #define ASSERT(expr) \
34   do                                                                         \
35     {                                                                        \
36       if (!(expr))                                                           \
37         {                                                                    \
38           fprintf (stderr, "%s:%d: assertion failed\n", __FILE__, __LINE__); \
39           fflush (stderr);                                                   \
40           abort ();                                                          \
41         }                                                                    \
42     }                                                                        \
43   while (0)
44
45 static int
46 check (const uint32_t *input, size_t input_length,
47        const uint32_t *expected, size_t expected_length)
48 {
49   size_t length;
50   uint32_t *result;
51
52   /* Test return conventions with resultbuf == NULL.  */
53   result = u32_normalize (UNINORM_NFKC, input, input_length, NULL, &length);
54   if (!(result != NULL))
55     return 1;
56   if (!(length == expected_length))
57     return 2;
58   if (!(u32_cmp (result, expected, expected_length) == 0))
59     return 3;
60   free (result);
61
62   /* Test return conventions with resultbuf too small.  */
63   if (expected_length > 0)
64     {
65       uint32_t *preallocated;
66
67       length = expected_length - 1;
68       preallocated = (uint32_t *) malloc (length * sizeof (uint32_t));
69       result = u32_normalize (UNINORM_NFKC, input, input_length, preallocated, &length);
70       if (!(result != NULL))
71         return 4;
72       if (!(result != preallocated))
73         return 5;
74       if (!(length == expected_length))
75         return 6;
76       if (!(u32_cmp (result, expected, expected_length) == 0))
77         return 7;
78       free (result);
79       free (preallocated);
80     }
81
82   /* Test return conventions with resultbuf large enough.  */
83   {
84     uint32_t *preallocated;
85
86     length = expected_length;
87     preallocated = (uint32_t *) malloc (length * sizeof (uint32_t));
88     result = u32_normalize (UNINORM_NFKC, input, input_length, preallocated, &length);
89     if (!(result != NULL))
90       return 8;
91     if (!(preallocated == NULL || result == preallocated))
92       return 9;
93     if (!(length == expected_length))
94       return 10;
95     if (!(u32_cmp (result, expected, expected_length) == 0))
96       return 11;
97     free (preallocated);
98   }
99
100   return 0;
101 }
102
103 void
104 test_u32_nfkc (void)
105 {
106   { /* Empty string.  */
107     ASSERT (check (NULL, 0, NULL, 0) == 0);
108   }
109   { /* SPACE */
110     static const uint32_t input[]    = { 0x0020 };
111     ASSERT (check (input, SIZEOF (input), input, SIZEOF (input)) == 0);
112   }
113
114   { /* LATIN CAPITAL LETTER A WITH DIAERESIS */
115     static const uint32_t input[]      = { 0x00C4 };
116     static const uint32_t decomposed[] = { 0x0041, 0x0308 };
117     ASSERT (check (input, SIZEOF (input),           input, SIZEOF (input)) == 0);
118     ASSERT (check (decomposed, SIZEOF (decomposed), input, SIZEOF (input)) == 0);
119   }
120
121   { /* LATIN CAPITAL LETTER A WITH DIAERESIS AND MACRON */
122     static const uint32_t input[]      = { 0x01DE };
123     static const uint32_t decomposed[] = { 0x0041, 0x0308, 0x0304 };
124     ASSERT (check (input, SIZEOF (input),           input, SIZEOF (input)) == 0);
125     ASSERT (check (decomposed, SIZEOF (decomposed), input, SIZEOF (input)) == 0);
126   }
127
128   { /* ANGSTROM SIGN */
129     static const uint32_t input[]      = { 0x212B };
130     static const uint32_t decomposed[] = { 0x0041, 0x030A };
131     static const uint32_t expected[]   = { 0x00C5 };
132     ASSERT (check (input, SIZEOF (input),           expected, SIZEOF (expected)) == 0);
133     ASSERT (check (decomposed, SIZEOF (decomposed), expected, SIZEOF (expected)) == 0);
134     ASSERT (check (expected, SIZEOF (expected),     expected, SIZEOF (expected)) == 0);
135   }
136
137   { /* GREEK DIALYTIKA AND PERISPOMENI */
138     static const uint32_t input[]      = { 0x1FC1 };
139     static const uint32_t decomposed[] = { 0x0020, 0x0308, 0x0342 };
140     ASSERT (check (input, SIZEOF (input),           decomposed, SIZEOF (decomposed)) == 0);
141     ASSERT (check (decomposed, SIZEOF (decomposed), decomposed, SIZEOF (decomposed)) == 0);
142   }
143
144   { /* SCRIPT SMALL L */
145     static const uint32_t input[]      = { 0x2113 };
146     static const uint32_t decomposed[] = { 0x006C };
147     ASSERT (check (input, SIZEOF (input),           decomposed, SIZEOF (decomposed)) == 0);
148     ASSERT (check (decomposed, SIZEOF (decomposed), decomposed, SIZEOF (decomposed)) == 0);
149   }
150
151   { /* NO-BREAK SPACE */
152     static const uint32_t input[]      = { 0x00A0 };
153     static const uint32_t decomposed[] = { 0x0020 };
154     ASSERT (check (input, SIZEOF (input),           decomposed, SIZEOF (decomposed)) == 0);
155     ASSERT (check (decomposed, SIZEOF (decomposed), decomposed, SIZEOF (decomposed)) == 0);
156   }
157
158   { /* ARABIC LETTER VEH INITIAL FORM */
159     static const uint32_t input[]      = { 0xFB6C };
160     static const uint32_t decomposed[] = { 0x06A4 };
161     ASSERT (check (input, SIZEOF (input),           decomposed, SIZEOF (decomposed)) == 0);
162     ASSERT (check (decomposed, SIZEOF (decomposed), decomposed, SIZEOF (decomposed)) == 0);
163   }
164
165   { /* ARABIC LETTER VEH MEDIAL FORM */
166     static const uint32_t input[]      = { 0xFB6D };
167     static const uint32_t decomposed[] = { 0x06A4 };
168     ASSERT (check (input, SIZEOF (input),           decomposed, SIZEOF (decomposed)) == 0);
169     ASSERT (check (decomposed, SIZEOF (decomposed), decomposed, SIZEOF (decomposed)) == 0);
170   }
171
172   { /* ARABIC LETTER VEH FINAL FORM */
173     static const uint32_t input[]      = { 0xFB6B };
174     static const uint32_t decomposed[] = { 0x06A4 };
175     ASSERT (check (input, SIZEOF (input),           decomposed, SIZEOF (decomposed)) == 0);
176     ASSERT (check (decomposed, SIZEOF (decomposed), decomposed, SIZEOF (decomposed)) == 0);
177   }
178
179   { /* ARABIC LETTER VEH ISOLATED FORM */
180     static const uint32_t input[]      = { 0xFB6A };
181     static const uint32_t decomposed[] = { 0x06A4 };
182     ASSERT (check (input, SIZEOF (input),           decomposed, SIZEOF (decomposed)) == 0);
183     ASSERT (check (decomposed, SIZEOF (decomposed), decomposed, SIZEOF (decomposed)) == 0);
184   }
185
186   { /* CIRCLED NUMBER FIFTEEN */
187     static const uint32_t input[]      = { 0x246E };
188     static const uint32_t decomposed[] = { 0x0031, 0x0035 };
189     ASSERT (check (input, SIZEOF (input),           decomposed, SIZEOF (decomposed)) == 0);
190     ASSERT (check (decomposed, SIZEOF (decomposed), decomposed, SIZEOF (decomposed)) == 0);
191   }
192
193   { /* TRADE MARK SIGN */
194     static const uint32_t input[]      = { 0x2122 };
195     static const uint32_t decomposed[] = { 0x0054, 0x004D };
196     ASSERT (check (input, SIZEOF (input),           decomposed, SIZEOF (decomposed)) == 0);
197     ASSERT (check (decomposed, SIZEOF (decomposed), decomposed, SIZEOF (decomposed)) == 0);
198   }
199
200   { /* LATIN SUBSCRIPT SMALL LETTER I */
201     static const uint32_t input[]      = { 0x1D62 };
202     static const uint32_t decomposed[] = { 0x0069 };
203     ASSERT (check (input, SIZEOF (input),           decomposed, SIZEOF (decomposed)) == 0);
204     ASSERT (check (decomposed, SIZEOF (decomposed), decomposed, SIZEOF (decomposed)) == 0);
205   }
206
207   { /* PRESENTATION FORM FOR VERTICAL LEFT PARENTHESIS */
208     static const uint32_t input[]      = { 0xFE35 };
209     static const uint32_t decomposed[] = { 0x0028 };
210     ASSERT (check (input, SIZEOF (input),           decomposed, SIZEOF (decomposed)) == 0);
211     ASSERT (check (decomposed, SIZEOF (decomposed), decomposed, SIZEOF (decomposed)) == 0);
212   }
213
214   { /* FULLWIDTH LATIN CAPITAL LETTER A */
215     static const uint32_t input[]      = { 0xFF21 };
216     static const uint32_t decomposed[] = { 0x0041 };
217     ASSERT (check (input, SIZEOF (input),           decomposed, SIZEOF (decomposed)) == 0);
218     ASSERT (check (decomposed, SIZEOF (decomposed), decomposed, SIZEOF (decomposed)) == 0);
219   }
220
221   { /* HALFWIDTH IDEOGRAPHIC COMMA */
222     static const uint32_t input[]      = { 0xFF64 };
223     static const uint32_t decomposed[] = { 0x3001 };
224     ASSERT (check (input, SIZEOF (input),           decomposed, SIZEOF (decomposed)) == 0);
225     ASSERT (check (decomposed, SIZEOF (decomposed), decomposed, SIZEOF (decomposed)) == 0);
226   }
227
228   { /* SMALL IDEOGRAPHIC COMMA */
229     static const uint32_t input[]      = { 0xFE51 };
230     static const uint32_t decomposed[] = { 0x3001 };
231     ASSERT (check (input, SIZEOF (input),           decomposed, SIZEOF (decomposed)) == 0);
232     ASSERT (check (decomposed, SIZEOF (decomposed), decomposed, SIZEOF (decomposed)) == 0);
233   }
234
235   { /* SQUARE MHZ */
236     static const uint32_t input[]      = { 0x3392 };
237     static const uint32_t decomposed[] = { 0x004D, 0x0048, 0x007A };
238     ASSERT (check (input, SIZEOF (input),           decomposed, SIZEOF (decomposed)) == 0);
239     ASSERT (check (decomposed, SIZEOF (decomposed), decomposed, SIZEOF (decomposed)) == 0);
240   }
241
242   { /* VULGAR FRACTION THREE EIGHTHS */
243     static const uint32_t input[]      = { 0x215C };
244     static const uint32_t decomposed[] = { 0x0033, 0x2044, 0x0038 };
245     ASSERT (check (input, SIZEOF (input),           decomposed, SIZEOF (decomposed)) == 0);
246     ASSERT (check (decomposed, SIZEOF (decomposed), decomposed, SIZEOF (decomposed)) == 0);
247   }
248
249   { /* MICRO SIGN */
250     static const uint32_t input[]      = { 0x00B5 };
251     static const uint32_t decomposed[] = { 0x03BC };
252     ASSERT (check (input, SIZEOF (input),           decomposed, SIZEOF (decomposed)) == 0);
253     ASSERT (check (decomposed, SIZEOF (decomposed), decomposed, SIZEOF (decomposed)) == 0);
254   }
255
256   { /* ARABIC LIGATURE SALLALLAHOU ALAYHE WASALLAM */
257     static const uint32_t input[]      = { 0xFDFA };
258     static const uint32_t decomposed[] =
259       { 0x0635, 0x0644, 0x0649, 0x0020, 0x0627, 0x0644, 0x0644, 0x0647, 0x0020,
260         0x0639, 0x0644, 0x064A, 0x0647, 0x0020, 0x0648, 0x0633, 0x0644, 0x0645
261       };
262     ASSERT (check (input, SIZEOF (input),           decomposed, SIZEOF (decomposed)) == 0);
263     ASSERT (check (decomposed, SIZEOF (decomposed), decomposed, SIZEOF (decomposed)) == 0);
264   }
265
266   { /* HANGUL SYLLABLE GEUL */
267     static const uint32_t input[]      = { 0xAE00 };
268     static const uint32_t decomposed[] = { 0x1100, 0x1173, 0x11AF };
269     ASSERT (check (input, SIZEOF (input),           input, SIZEOF (input)) == 0);
270     ASSERT (check (decomposed, SIZEOF (decomposed), input, SIZEOF (input)) == 0);
271   }
272
273   { /* HANGUL SYLLABLE GEU */
274     static const uint32_t input[]      = { 0xADF8 };
275     static const uint32_t decomposed[] = { 0x1100, 0x1173 };
276     ASSERT (check (input, SIZEOF (input),           input, SIZEOF (input)) == 0);
277     ASSERT (check (decomposed, SIZEOF (decomposed), input, SIZEOF (input)) == 0);
278   }
279
280   { /* "Grüß Gott. Здравствуйте! x=(-b±sqrt(b²-4ac))/(2a)  日本語,中文,한글" */
281     static const uint32_t input[] =
282       { 'G', 'r', 0x00FC, 0x00DF, ' ', 'G', 'o', 't', 't', '.', ' ',
283         0x0417, 0x0434, 0x0440, 0x0430, 0x0432, 0x0441, 0x0442, 0x0432, 0x0443,
284         0x0439, 0x0442, 0x0435, '!', ' ',
285         'x', '=', '(', '-', 'b', 0x00B1, 's', 'q', 'r', 't', '(', 'b', 0x00B2,
286         '-', '4', 'a', 'c', ')', ')', '/', '(', '2', 'a', ')', ' ', ' ',
287         0x65E5, 0x672C, 0x8A9E, ',', 0x4E2D, 0x6587, ',', 0xD55C, 0xAE00, '\n'
288       };
289     static const uint32_t decomposed[] =
290       { 'G', 'r', 0x0075, 0x0308, 0x00DF, ' ', 'G', 'o', 't', 't', '.', ' ',
291         0x0417, 0x0434, 0x0440, 0x0430, 0x0432, 0x0441, 0x0442, 0x0432, 0x0443,
292         0x0438, 0x0306, 0x0442, 0x0435, '!', ' ',
293         'x', '=', '(', '-', 'b', 0x00B1, 's', 'q', 'r', 't', '(', 'b', 0x0032,
294         '-', '4', 'a', 'c', ')', ')', '/', '(', '2', 'a', ')', ' ', ' ',
295         0x65E5, 0x672C, 0x8A9E, ',', 0x4E2D, 0x6587, ',',
296         0x1112, 0x1161, 0x11AB, 0x1100, 0x1173, 0x11AF, '\n'
297       };
298     static const uint32_t expected[] =
299       { 'G', 'r', 0x00FC, 0x00DF, ' ', 'G', 'o', 't', 't', '.', ' ',
300         0x0417, 0x0434, 0x0440, 0x0430, 0x0432, 0x0441, 0x0442, 0x0432, 0x0443,
301         0x0439, 0x0442, 0x0435, '!', ' ',
302         'x', '=', '(', '-', 'b', 0x00B1, 's', 'q', 'r', 't', '(', 'b', 0x0032,
303         '-', '4', 'a', 'c', ')', ')', '/', '(', '2', 'a', ')', ' ', ' ',
304         0x65E5, 0x672C, 0x8A9E, ',', 0x4E2D, 0x6587, ',', 0xD55C, 0xAE00, '\n'
305       };
306     ASSERT (check (input, SIZEOF (input),           expected, SIZEOF (expected)) == 0);
307     ASSERT (check (decomposed, SIZEOF (decomposed), expected, SIZEOF (expected)) == 0);
308     ASSERT (check (expected, SIZEOF (expected),     expected, SIZEOF (expected)) == 0);
309   }
310
311 #if HAVE_DECL_ALARM
312   /* Declare failure if test takes too long, by using default abort
313      caused by SIGALRM.  */
314   signal (SIGALRM, SIG_DFL);
315   alarm (50);
316 #endif
317
318   /* Check that the sorting is not O(n²) but O(n log n).  */
319   {
320     int pass;
321     for (pass = 0; pass < 3; pass++)
322       {
323         size_t repeat = 1;
324         size_t m = 100000;
325         uint32_t *input = (uint32_t *) malloc (2 * m * sizeof (uint32_t));
326         if (input != NULL)
327           {
328             uint32_t *expected = input + m;
329             size_t m1 = m / 2;
330             size_t m2 = (m - 1) / 2;
331             /* NB: m1 + m2 == m - 1.  */
332             uint32_t *p;
333             size_t i;
334
335             input[0] = 0x0041;
336             p = input + 1;
337             switch (pass)
338               {
339               case 0:
340                 for (i = 0; i < m1; i++)
341                   *p++ = 0x0319;
342                 for (i = 0; i < m2; i++)
343                   *p++ = 0x0300;
344                 break;
345
346               case 1:
347                 for (i = 0; i < m2; i++)
348                   *p++ = 0x0300;
349                 for (i = 0; i < m1; i++)
350                   *p++ = 0x0319;
351                 break;
352
353               case 2:
354                 for (i = 0; i < m2; i++)
355                   {
356                     *p++ = 0x0319;
357                     *p++ = 0x0300;
358                   }
359                 for (; i < m1; i++)
360                   *p++ = 0x0319;
361                 break;
362
363               default:
364                 abort ();
365               }
366
367             expected[0] = 0x00C0;
368             p = expected + 1;
369             for (i = 0; i < m1; i++)
370               *p++ = 0x0319;
371             for (i = 0; i < m2 - 1; i++)
372               *p++ = 0x0300;
373
374             for (; repeat > 0; repeat--)
375               {
376                 ASSERT (check (input, m,        expected, m - 1) == 0);
377                 ASSERT (check (expected, m - 1, expected, m - 1) == 0);
378               }
379
380             free (input);
381           }
382       }
383   }
384 }
385
386 #else
387
388 void
389 test_u32_nfkc (void)
390 {
391 }
392
393 #endif