| /* bug 19727: Testing UTF conversions with UTF16 surrogates as input. |
| Copyright (C) 2016-2018 Free Software Foundation, Inc. |
| This file is part of the GNU C Library. |
| |
| The GNU C Library is free software; you can redistribute it and/or |
| modify it under the terms of the GNU Lesser General Public |
| License as published by the Free Software Foundation; either |
| version 2.1 of the License, or (at your option) any later version. |
| |
| The GNU C Library is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| Lesser General Public License for more details. |
| |
| You should have received a copy of the GNU Lesser General Public |
| License along with the GNU C Library; if not, see |
| <http://www.gnu.org/licenses/>. */ |
| |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <errno.h> |
| #include <string.h> |
| #include <inttypes.h> |
| #include <iconv.h> |
| #include <byteswap.h> |
| |
| static int |
| run_conversion (const char *from, const char *to, char *inbuf, size_t inbuflen, |
| int exp_errno, int line) |
| { |
| char outbuf[16]; |
| iconv_t cd; |
| char *inptr; |
| size_t inlen; |
| char *outptr; |
| size_t outlen; |
| size_t n; |
| int e; |
| int fails = 0; |
| |
| cd = iconv_open (to, from); |
| if (cd == (iconv_t) -1) |
| { |
| printf ("line %d: cannot convert from %s to %s: %m\n", line, from, to); |
| return 1; |
| } |
| |
| inptr = (char *) inbuf; |
| inlen = inbuflen; |
| outptr = outbuf; |
| outlen = sizeof (outbuf); |
| |
| errno = 0; |
| n = iconv (cd, &inptr, &inlen, &outptr, &outlen); |
| e = errno; |
| |
| if (exp_errno == 0) |
| { |
| if (n == (size_t) -1) |
| { |
| puts ("n should be >= 0, but n == -1"); |
| fails ++; |
| } |
| |
| if (e != 0) |
| { |
| printf ("errno should be 0: 'Success', but errno == %d: '%s'\n" |
| , e, strerror(e)); |
| fails ++; |
| } |
| } |
| else |
| { |
| if (n != (size_t) -1) |
| { |
| printf ("n should be -1, but n == %zd\n", n); |
| fails ++; |
| } |
| |
| if (e != exp_errno) |
| { |
| printf ("errno should be %d: '%s', but errno == %d: '%s'\n" |
| , exp_errno, strerror (exp_errno), e, strerror (e)); |
| fails ++; |
| } |
| } |
| |
| iconv_close (cd); |
| |
| if (fails > 0) |
| { |
| printf ("Errors in line %d while converting %s to %s.\n\n" |
| , line, from, to); |
| } |
| |
| return fails; |
| } |
| |
| static int |
| do_test (void) |
| { |
| int fails = 0; |
| char buf[4]; |
| |
| /* This test runs iconv() with UTF character in range of an UTF16 surrogate. |
| UTF-16 high surrogate is in range 0xD800..0xDBFF and |
| UTF-16 low surrogate is in range 0xDC00..0xDFFF. |
| Converting from or to UTF-xx has to report errors in those cases. |
| In UTF-16, surrogate pairs with a high surrogate in front of a low |
| surrogate is valid. */ |
| |
| /* Use RUN_UCS4_UTF32_INPUT to test conversion ... |
| |
| ... from INTERNAL to UTF-xx[LE|BE]: |
| Converting from UCS4 to UTF-xx[LE|BE] first converts UCS4 to INTERNAL |
| without checking for UTF-16 surrogate values |
| and then converts from INTERNAL to UTF-xx[LE|BE]. |
| The latter conversion has to report an error in those cases. |
| |
| ... from UTF-32[LE|BE] to INTERNAL: |
| Converting directly from UTF-32LE to UTF-8|16 is needed, |
| because e.g. s390x has iconv-modules which converts directly. */ |
| #define RUN_UCS4_UTF32_INPUT(b0, b1, b2, b3, err, line) \ |
| buf[0] = b0; \ |
| buf[1] = b1; \ |
| buf[2] = b2; \ |
| buf[3] = b3; \ |
| fails += run_conversion ("UCS4", "UTF-8", buf, 4, err, line); \ |
| fails += run_conversion ("UCS4", "UTF-16LE", buf, 4, err, line); \ |
| fails += run_conversion ("UCS4", "UTF-16BE", buf, 4, err, line); \ |
| fails += run_conversion ("UCS4", "UTF-32LE", buf, 4, err, line); \ |
| fails += run_conversion ("UCS4", "UTF-32BE", buf, 4, err, line); \ |
| fails += run_conversion ("UTF-32BE", "WCHAR_T", buf, 4, err, line); \ |
| fails += run_conversion ("UTF-32BE", "UTF-8", buf, 4, err, line); \ |
| fails += run_conversion ("UTF-32BE", "UTF-16LE", buf, 4, err, line); \ |
| fails += run_conversion ("UTF-32BE", "UTF-16BE", buf, 4, err, line); \ |
| buf[0] = b3; \ |
| buf[1] = b2; \ |
| buf[2] = b1; \ |
| buf[3] = b0; \ |
| fails += run_conversion ("UTF-32LE", "WCHAR_T", buf, 4, err, line); \ |
| fails += run_conversion ("UTF-32LE", "UTF-8", buf, 4, err, line); \ |
| fails += run_conversion ("UTF-32LE", "UTF-16LE", buf, 4, err, line); \ |
| fails += run_conversion ("UTF-32LE", "UTF-16BE", buf, 4, err, line); |
| |
| /* Use UCS4/UTF32 input of 0xD7FF. */ |
| RUN_UCS4_UTF32_INPUT (0x0, 0x0, 0xD7, 0xFF, 0, __LINE__); |
| |
| /* Use UCS4/UTF32 input of 0xD800. */ |
| RUN_UCS4_UTF32_INPUT (0x0, 0x0, 0xD8, 0x00, EILSEQ, __LINE__); |
| |
| /* Use UCS4/UTF32 input of 0xDBFF. */ |
| RUN_UCS4_UTF32_INPUT (0x0, 0x0, 0xDB, 0xFF, EILSEQ, __LINE__); |
| |
| /* Use UCS4/UTF32 input of 0xDC00. */ |
| RUN_UCS4_UTF32_INPUT (0x0, 0x0, 0xDC, 0x00, EILSEQ, __LINE__); |
| |
| /* Use UCS4/UTF32 input of 0xDFFF. */ |
| RUN_UCS4_UTF32_INPUT (0x0, 0x0, 0xDF, 0xFF, EILSEQ, __LINE__); |
| |
| /* Use UCS4/UTF32 input of 0xE000. */ |
| RUN_UCS4_UTF32_INPUT (0x0, 0x0, 0xE0, 0x00, 0, __LINE__); |
| |
| |
| /* Use RUN_UTF16_INPUT to test conversion from UTF16[LE|BE] to INTERNAL. |
| Converting directly from UTF-16 to UTF-8|32 is needed, |
| because e.g. s390x has iconv-modules which converts directly. |
| Use len == 2 or 4 to specify one or two UTF-16 characters. */ |
| #define RUN_UTF16_INPUT(b0, b1, b2, b3, len, err, line) \ |
| buf[0] = b0; \ |
| buf[1] = b1; \ |
| buf[2] = b2; \ |
| buf[3] = b3; \ |
| fails += run_conversion ("UTF-16BE", "WCHAR_T", buf, len, err, line); \ |
| fails += run_conversion ("UTF-16BE", "UTF-8", buf, len, err, line); \ |
| fails += run_conversion ("UTF-16BE", "UTF-32LE", buf, len, err, line); \ |
| fails += run_conversion ("UTF-16BE", "UTF-32BE", buf, len, err, line); \ |
| buf[0] = b1; \ |
| buf[1] = b0; \ |
| buf[2] = b3; \ |
| buf[3] = b2; \ |
| fails += run_conversion ("UTF-16LE", "WCHAR_T", buf, len, err, line); \ |
| fails += run_conversion ("UTF-16LE", "UTF-8", buf, len, err, line); \ |
| fails += run_conversion ("UTF-16LE", "UTF-32LE", buf, len, err, line); \ |
| fails += run_conversion ("UTF-16LE", "UTF-32BE", buf, len, err, line); |
| |
| /* Use UTF16 input of 0xD7FF. */ |
| RUN_UTF16_INPUT (0xD7, 0xFF, 0xD7, 0xFF, 4, 0, __LINE__); |
| |
| /* Use [single] UTF16 high surrogate 0xD800 [with a valid character behind]. |
| And check an UTF16 surrogate pair [without valid low surrogate]. */ |
| RUN_UTF16_INPUT (0xD8, 0x0, 0x0, 0x0, 2, EINVAL, __LINE__); |
| RUN_UTF16_INPUT (0xD8, 0x0, 0xD7, 0xFF, 4, EILSEQ, __LINE__); |
| RUN_UTF16_INPUT (0xD8, 0x0, 0xD8, 0x0, 4, EILSEQ, __LINE__); |
| RUN_UTF16_INPUT (0xD8, 0x0, 0xE0, 0x0, 4, EILSEQ, __LINE__); |
| RUN_UTF16_INPUT (0xD8, 0x0, 0xDC, 0x0, 4, 0, __LINE__); |
| |
| /* Use [single] UTF16 high surrogate 0xDBFF [with a valid character behind]. |
| And check an UTF16 surrogate pair [without valid low surrogate]. */ |
| RUN_UTF16_INPUT (0xDB, 0xFF, 0x0, 0x0, 2, EINVAL, __LINE__); |
| RUN_UTF16_INPUT (0xDB, 0xFF, 0xD7, 0xFF, 4, EILSEQ, __LINE__); |
| RUN_UTF16_INPUT (0xDB, 0xFF, 0xDB, 0xFF, 4, EILSEQ, __LINE__); |
| RUN_UTF16_INPUT (0xDB, 0xFF, 0xE0, 0x0, 4, EILSEQ, __LINE__); |
| RUN_UTF16_INPUT (0xDB, 0xFF, 0xDF, 0xFF, 4, 0, __LINE__); |
| |
| /* Use single UTF16 low surrogate 0xDC00 [with a valid character behind]. |
| And check an UTF16 surrogate pair [without valid high surrogate]. */ |
| RUN_UTF16_INPUT (0xDC, 0x0, 0x0, 0x0, 2, EILSEQ, __LINE__); |
| RUN_UTF16_INPUT (0xDC, 0x0, 0xD7, 0xFF, 4, EILSEQ, __LINE__); |
| RUN_UTF16_INPUT (0xD8, 0x0, 0xDC, 0x0, 4, 0, __LINE__); |
| RUN_UTF16_INPUT (0xD7, 0xFF, 0xDC, 0x0, 4, EILSEQ, __LINE__); |
| RUN_UTF16_INPUT (0xDC, 0x0, 0xDC, 0x0, 4, EILSEQ, __LINE__); |
| RUN_UTF16_INPUT (0xE0, 0x0, 0xDC, 0x0, 4, EILSEQ, __LINE__); |
| |
| /* Use single UTF16 low surrogate 0xDFFF [with a valid character behind]. |
| And check an UTF16 surrogate pair [without valid high surrogate]. */ |
| RUN_UTF16_INPUT (0xDF, 0xFF, 0x0, 0x0, 2, EILSEQ, __LINE__); |
| RUN_UTF16_INPUT (0xDF, 0xFF, 0xD7, 0xFF, 4, EILSEQ, __LINE__); |
| RUN_UTF16_INPUT (0xDB, 0xFF, 0xDF, 0xFF, 4, 0, __LINE__); |
| RUN_UTF16_INPUT (0xD7, 0xFF, 0xDF, 0xFF, 4, EILSEQ, __LINE__); |
| RUN_UTF16_INPUT (0xDF, 0xFF, 0xDF, 0xFF, 4, EILSEQ, __LINE__); |
| RUN_UTF16_INPUT (0xE0, 0x0, 0xDF, 0xFF, 4, EILSEQ, __LINE__); |
| |
| /* Use UCS4/UTF32 input of 0xE000. */ |
| RUN_UTF16_INPUT (0xE0, 0x0, 0xE0, 0x0, 4, 0, __LINE__); |
| |
| |
| /* Use RUN_UTF8_3BYTE_INPUT to test conversion from UTF-8 to INTERNAL. |
| Converting directly from UTF-8 to UTF-16|32 is needed, |
| because e.g. s390x has iconv-modules which converts directly. */ |
| #define RUN_UTF8_3BYTE_INPUT(b0, b1, b2, err, line) \ |
| buf[0] = b0; \ |
| buf[1] = b1; \ |
| buf[2] = b2; \ |
| fails += run_conversion ("UTF-8", "WCHAR_T", buf, 3, err, line); \ |
| fails += run_conversion ("UTF-8", "UTF-16LE", buf, 3, err, line); \ |
| fails += run_conversion ("UTF-8", "UTF-16BE", buf, 3, err, line); \ |
| fails += run_conversion ("UTF-8", "UTF-32LE", buf, 3, err, line); \ |
| fails += run_conversion ("UTF-8", "UTF-32BE", buf, 3, err, line); |
| |
| /* Use UTF-8 input of 0xD7FF. */ |
| RUN_UTF8_3BYTE_INPUT (0xED, 0x9F, 0xBF, 0, __LINE__); |
| |
| /* Use UTF-8 input of 0xD800. */ |
| RUN_UTF8_3BYTE_INPUT (0xED, 0xA0, 0x80, EILSEQ, __LINE__); |
| |
| /* Use UTF-8 input of 0xDBFF. */ |
| RUN_UTF8_3BYTE_INPUT (0xED, 0xAF, 0xBF, EILSEQ, __LINE__); |
| |
| /* Use UTF-8 input of 0xDC00. */ |
| RUN_UTF8_3BYTE_INPUT (0xED, 0xB0, 0x80, EILSEQ, __LINE__); |
| |
| /* Use UTF-8 input of 0xDFFF. */ |
| RUN_UTF8_3BYTE_INPUT (0xED, 0xBF, 0xBF, EILSEQ, __LINE__); |
| |
| /* Use UTF-8 input of 0xF000. */ |
| RUN_UTF8_3BYTE_INPUT (0xEF, 0x80, 0x80, 0, __LINE__); |
| |
| return fails > 0 ? EXIT_FAILURE : EXIT_SUCCESS; |
| } |
| |
| #define TEST_FUNCTION do_test () |
| #include "../test-skeleton.c" |
