use gnulib to detect iconv.
[gnutls:gnutls.git] / gl / tests / test-iconv.c
1 /* Test of character set conversion.
2    Copyright (C) 2007-2012 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 #if HAVE_ICONV
22 # include <iconv.h>
23
24 # ifndef ICONV_CONST
25 #  define ICONV_CONST /* empty */
26 # endif
27
28 #include "signature.h"
29 SIGNATURE_CHECK (iconv, size_t, (iconv_t, ICONV_CONST char **, size_t *,
30                                  char **, size_t *));
31 SIGNATURE_CHECK (iconv_close, int, (iconv_t x));
32 SIGNATURE_CHECK (iconv_open, iconv_t, (char const *, char const *));
33
34 #endif
35
36 #include <errno.h>
37 #include <string.h>
38
39 #include "macros.h"
40
41 int
42 main ()
43 {
44 #if HAVE_ICONV
45   /* Assume that iconv() supports at least the encodings ASCII, ISO-8859-1,
46      and UTF-8.  */
47   iconv_t cd_88591_to_utf8 = iconv_open ("UTF-8", "ISO-8859-1");
48   iconv_t cd_utf8_to_88591 = iconv_open ("ISO-8859-1", "UTF-8");
49
50   ASSERT (cd_88591_to_utf8 != (iconv_t)(-1));
51   ASSERT (cd_utf8_to_88591 != (iconv_t)(-1));
52
53   /* Test conversion from ISO-8859-1 to UTF-8 with no errors.  */
54   {
55     static const char input[] = "\304rger mit b\366sen B\374bchen ohne Augenma\337";
56     static const char expected[] = "\303\204rger mit b\303\266sen B\303\274bchen ohne Augenma\303\237";
57     char buf[50];
58     const char *inptr = input;
59     size_t inbytesleft = strlen (input);
60     char *outptr = buf;
61     size_t outbytesleft = sizeof (buf);
62     size_t res = iconv (cd_88591_to_utf8,
63                         (ICONV_CONST char **) &inptr, &inbytesleft,
64                         &outptr, &outbytesleft);
65     ASSERT (res == 0 && inbytesleft == 0);
66     ASSERT (outptr == buf + strlen (expected));
67     ASSERT (memcmp (buf, expected, strlen (expected)) == 0);
68   }
69
70   /* Test conversion from ISO-8859-1 to UTF-8 with E2BIG.  */
71   {
72     static const char input[] = "\304";
73     static char buf[2] = { (char)0xDE, (char)0xAD };
74     const char *inptr = input;
75     size_t inbytesleft = 1;
76     char *outptr = buf;
77     size_t outbytesleft = 1;
78     size_t res = iconv (cd_88591_to_utf8,
79                         (ICONV_CONST char **) &inptr, &inbytesleft,
80                         &outptr, &outbytesleft);
81     ASSERT (res == (size_t)(-1) && errno == E2BIG);
82     ASSERT (inbytesleft == 1);
83     ASSERT (outbytesleft == 1);
84     ASSERT ((unsigned char) buf[1] == 0xAD);
85     ASSERT ((unsigned char) buf[0] == 0xDE);
86   }
87
88   /* Test conversion from UTF-8 to ISO-8859-1 with no errors.  */
89   {
90     static const char input[] = "\303\204rger mit b\303\266sen B\303\274bchen ohne Augenma\303\237";
91     static const char expected[] = "\304rger mit b\366sen B\374bchen ohne Augenma\337";
92     char buf[50];
93     const char *inptr = input;
94     size_t inbytesleft = strlen (input);
95     char *outptr = buf;
96     size_t outbytesleft = sizeof (buf);
97     size_t res = iconv (cd_utf8_to_88591,
98                         (ICONV_CONST char **) &inptr, &inbytesleft,
99                         &outptr, &outbytesleft);
100     ASSERT (res == 0 && inbytesleft == 0);
101     ASSERT (outptr == buf + strlen (expected));
102     ASSERT (memcmp (buf, expected, strlen (expected)) == 0);
103   }
104
105   /* Test conversion from UTF-8 to ISO-8859-1 with EILSEQ.  */
106   {
107     static const char input[] = "\342\202\254"; /* EURO SIGN */
108     char buf[10];
109     const char *inptr = input;
110     size_t inbytesleft = strlen (input);
111     char *outptr = buf;
112     size_t outbytesleft = sizeof (buf);
113     size_t res = iconv (cd_utf8_to_88591,
114                         (ICONV_CONST char **) &inptr, &inbytesleft,
115                         &outptr, &outbytesleft);
116     if (res == (size_t)(-1))
117       {
118         ASSERT (errno == EILSEQ);
119         ASSERT (inbytesleft == strlen (input) && outptr == buf);
120       }
121     else
122       {
123         ASSERT (res == 1);
124         ASSERT (inbytesleft == 0);
125       }
126   }
127
128   /* Test conversion from UTF-8 to ISO-8859-1 with EINVAL.  */
129   {
130     static const char input[] = "\342";
131     char buf[10];
132     const char *inptr = input;
133     size_t inbytesleft = 1;
134     char *outptr = buf;
135     size_t outbytesleft = sizeof (buf);
136     size_t res = iconv (cd_utf8_to_88591,
137                         (ICONV_CONST char **) &inptr, &inbytesleft,
138                         &outptr, &outbytesleft);
139     ASSERT (res == (size_t)(-1) && errno == EINVAL);
140     ASSERT (inbytesleft == 1 && outptr == buf);
141   }
142
143   iconv_close (cd_88591_to_utf8);
144   iconv_close (cd_utf8_to_88591);
145 #endif
146
147   return 0;
148 }