Change copyright notice from GPLv2+ to GPLv3+.
[gnulib.git] / tests / uniconv / test-u16-conv-to-enc.c
1 /* Test of conversion from UTF-16 to legacy encodings.
2    Copyright (C) 2007 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>, 2007.  */
18
19 #include <config.h>
20
21 #include "uniconv.h"
22
23 #include <errno.h>
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <string.h>
27
28 #define SIZEOF(array) (sizeof (array) / sizeof (array[0]))
29 #define ASSERT(expr) \
30   do                                                                         \
31     {                                                                        \
32       if (!(expr))                                                           \
33         {                                                                    \
34           fprintf (stderr, "%s:%d: assertion failed\n", __FILE__, __LINE__); \
35           abort ();                                                          \
36         }                                                                    \
37     }                                                                        \
38   while (0)
39
40 /* Magic number for detecting bounds violations.  */
41 #define MAGIC 0x1983EFF1
42
43 static size_t *
44 new_offsets (size_t n)
45 {
46   size_t *offsets = (size_t *) malloc ((n + 1) * sizeof (size_t));
47   offsets[n] = MAGIC;
48   return offsets;
49 }
50
51 int
52 main ()
53 {
54   static enum iconv_ilseq_handler handlers[] =
55     { iconveh_error, iconveh_question_mark, iconveh_escape_sequence };
56   size_t h;
57   size_t o;
58   size_t i;
59
60 #if HAVE_ICONV
61   /* Assume that iconv() supports at least the encodings ASCII, ISO-8859-1,
62      ISO-8859-2, and UTF-8.  */
63
64   /* Test conversion from UTF-16 to ISO-8859-1 with no errors.  */
65   for (h = 0; h < SIZEOF (handlers); h++)
66     {
67       enum iconv_ilseq_handler handler = handlers[h];
68       static const uint16_t input[] = /* Ärger mit bösen Bübchen ohne Augenmaß */
69         {
70           0xC4, 'r', 'g', 'e', 'r', ' ', 'm', 'i', 't', ' ', 'b', 0xF6, 's',
71           'e', 'n', ' ', 'B', 0xFC, 'b', 'c', 'h', 'e', 'n', ' ', 'o', 'h',
72           'n', 'e', ' ', 'A', 'u', 'g', 'e', 'n', 'm', 'a', 0xDF
73         };
74       static const char expected[] = "\304rger mit b\366sen B\374bchen ohne Augenma\337";
75       for (o = 0; o < 2; o++)
76         {
77           size_t *offsets = (o ? new_offsets (SIZEOF (input)) : NULL);
78           char *result = NULL;
79           size_t length = 0;
80           int retval = u16_conv_to_encoding ("ISO-8859-1", handler,
81                                              input, SIZEOF (input),
82                                              offsets,
83                                              &result, &length);
84           ASSERT (retval == 0);
85           ASSERT (length == strlen (expected));
86           ASSERT (result != NULL);
87           ASSERT (memcmp (result, expected, length) == 0);
88           if (o)
89             {
90               for (i = 0; i < 37; i++)
91                 ASSERT (offsets[i] == i);
92               ASSERT (offsets[37] == MAGIC);
93               free (offsets);
94             }
95           free (result);
96         }
97     }
98
99   /* Test conversion from UTF-16 to ISO-8859-1 with EILSEQ.  */
100   for (h = 0; h < SIZEOF (handlers); h++)
101     {
102       enum iconv_ilseq_handler handler = handlers[h];
103       static const uint16_t input[] = /* Rafał Maszkowski */
104         {
105           'R', 'a', 'f', 'a', 0x0142, ' ', 'M', 'a', 's', 'z', 'k', 'o', 'w',
106           's', 'k', 'i'
107         };
108       for (o = 0; o < 2; o++)
109         {
110           size_t *offsets = (o ? new_offsets (SIZEOF (input)) : NULL);
111           char *result = NULL;
112           size_t length = 0;
113           int retval = u16_conv_to_encoding ("ISO-8859-1", handler,
114                                              input, SIZEOF (input),
115                                              offsets,
116                                              &result, &length);
117           switch (handler)
118             {
119             case iconveh_error:
120               ASSERT (retval == -1 && errno == EILSEQ);
121               ASSERT (result == NULL);
122               ASSERT (length == 0);
123               break;
124             case iconveh_question_mark:
125               {
126                 static const char expected[] = "Rafa? Maszkowski";
127                 static const char expected_translit[] = "Rafal Maszkowski";
128                 ASSERT (retval == 0);
129                 ASSERT (length == strlen (expected));
130                 ASSERT (result != NULL);
131                 ASSERT (memcmp (result, expected, length) == 0
132                         || memcmp (result, expected_translit, length) == 0);
133                 if (o)
134                   {
135                     for (i = 0; i < 16; i++)
136                       ASSERT (offsets[i] == i);
137                     ASSERT (offsets[16] == MAGIC);
138                     free (offsets);
139                   }
140                 free (result);
141               }
142               break;
143             case iconveh_escape_sequence:
144               {
145                 static const char expected[] = "Rafa\\u0142 Maszkowski";
146                 ASSERT (retval == 0);
147                 ASSERT (length == strlen (expected));
148                 ASSERT (result != NULL);
149                 ASSERT (memcmp (result, expected, length) == 0);
150                 if (o)
151                   {
152                     for (i = 0; i < 16; i++)
153                       ASSERT (offsets[i] == (i < 5 ? i : i + 5));
154                     ASSERT (offsets[16] == MAGIC);
155                     free (offsets);
156                   }
157                 free (result);
158               }
159               break;
160             }
161         }
162     }
163
164   /* Test conversion from UTF-16 to ISO-8859-1 with EINVAL.  */
165   for (h = 0; h < SIZEOF (handlers); h++)
166     {
167       enum iconv_ilseq_handler handler = handlers[h];
168       static const uint16_t input[] = { 0xD845 };
169       for (o = 0; o < 2; o++)
170         {
171           size_t *offsets = (o ? new_offsets (SIZEOF (input)) : NULL);
172           char *result = NULL;
173           size_t length = 0;
174           int retval = u16_conv_to_encoding ("ISO-8859-1", handler,
175                                              input, SIZEOF (input),
176                                              offsets,
177                                              &result, &length);
178           ASSERT (retval == 0);
179           ASSERT (length == strlen (""));
180           ASSERT (result != NULL);
181           if (o)
182             {
183               ASSERT (offsets[0] == 0);
184               ASSERT (offsets[1] == MAGIC);
185               free (offsets);
186             }
187           free (result);
188         }
189     }
190
191 #endif
192
193   return 0;
194 }