/*-
* Copyright (c) 2011-2012 Michihiro NAKAJIMA
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "test.h"
__FBSDID("$FreeBSD$");
#include <locale.h>
#define __LIBARCHIVE_TEST
#include "archive_string.h"
/*
Execute the following to rebuild the data for this program:
tail -n +36 test_archive_string_conversion.c | /bin/sh
#
# This requires http://unicode.org/Public/6.0.0/ucd/NormalizationTest.txt
#
if="NormalizationTest.txt"
if [ ! -f ${if} ]; then
echo "Not found: \"${if}\""
exit 0
fi
of=test_archive_string_conversion.txt.Z
echo "\$FreeBSD\$" > ${of}.uu
awk -F ';' '$0 ~/^[0-9A-F]+/ {printf "%s;%s\n", $2, $3}' ${if} | compress | uuencode ${of} >> ${of}.uu
exit 1
*/
static int
unicode_to_utf8(char *p, uint32_t uc)
{
char *_p = p;
/* Translate code point to UTF8 */
if (uc <= 0x7f) {
*p++ = (char)uc;
} else if (uc <= 0x7ff) {
*p++ = 0xc0 | ((uc >> 6) & 0x1f);
*p++ = 0x80 | (uc & 0x3f);
} else if (uc <= 0xffff) {
*p++ = 0xe0 | ((uc >> 12) & 0x0f);
*p++ = 0x80 | ((uc >> 6) & 0x3f);
*p++ = 0x80 | (uc & 0x3f);
} else {
*p++ = 0xf0 | ((uc >> 18) & 0x07);
*p++ = 0x80 | ((uc >> 12) & 0x3f);
*p++ = 0x80 | ((uc >> 6) & 0x3f);
*p++ = 0x80 | (uc & 0x3f);
}
return ((int)(p - _p));
}
static void
archive_be16enc(void *pp, uint16_t u)
{
unsigned char *p = (unsigned char *)pp;
p[0] = (u >> 8) & 0xff;
p[1] = u & 0xff;
}
static int
unicode_to_utf16be(char *p, uint32_t uc)
{
char *utf16 = p;
if (uc > 0xffff) {
/* We have a code point that won't fit into a
* wchar_t; convert it to a surrogate pair. */
uc -= 0x10000;
archive_be16enc(utf16, ((uc >> 10) & 0x3ff) + 0xD800);
archive_be16enc(utf16+2, (uc & 0x3ff) + 0xDC00);
return (4);
} else {
archive_be16enc(utf16, uc);
return (2);
}
}
static void
archive_le16enc(void *pp, uint16_t u)
{
unsigned char *p = (unsigned char *)pp;
p[0] = u & 0xff;
p[1] = (u >> 8) & 0xff;
}
static size_t
unicode_to_utf16le(char *p, uint32_t uc)
{
char *utf16 = p;
if (uc > 0xffff) {
/* We have a code point that won't fit into a
* wchar_t; convert it to a surrogate pair. */
uc -= 0x10000;
archive_le16enc(utf16, ((uc >> 10) & 0x3ff) + 0xD800);
archive_le16enc(utf16+2, (uc & 0x3ff) + 0xDC00);
return (4);
} else {
archive_le16enc(utf16, uc);
return (2);
}
}
static int
wc_size(void)
{
return (sizeof(wchar_t));
}
static int
unicode_to_wc(wchar_t *wp, uint32_t uc)
{
if (wc_size() == 4) {
*wp = (wchar_t)uc;
return (1);
}
if (uc > 0xffff) {
/* We have a code point that won't fit into a
* wchar_t; convert it to a surrogate pair. */
uc -= 0x10000;
*wp++ = (wchar_t)(((uc >> 10) & 0x3ff) + 0xD800);
*wp = (wchar_t)((uc & 0x3ff) + 0xDC00);
return (2);
} else {
*wp = (wchar_t)uc;
return (1);
}
}
/*
* Note: U+2000 - U+2FFF, U+F900 - U+FAFF and U+2F800 - U+2FAFF are not
* converted to NFD on Mac OS.
* see also http://developer.apple.com/library/mac/#qa/qa2001/qa1173.html
*/
static int
scan_unicode_pattern(char *out, wchar_t *wout, char *u16be, char *u16le,
const char *pattern, int mac_nfd)
{
unsigned uc = 0;
const char *p = pattern;
char *op = out;
wchar_t *owp = wout;
char *op16be = u16be;
char *op16le = u16le;
int ret = 0;
for (;;) {
if (*p >= '0' && *p <= '9')
uc = (uc << 4) + (*p - '0');
else if (*p >= 'A' && *p <= 'F')
uc = (uc << 4) + (*p - 'A' + 0x0a);
else {
if (mac_nfd && op == out) {
/*
* These are not converted to NFD on Mac OS.
* U+2000 - U+2FFF
* U+F900 - U+FAFF
* U+2F800 - U+2FAFF
*/
switch (uc) {
case 0x2194: case 0x219A: case 0x219B:
case 0x21AE: case 0x21CD: case 0x21CE:
case 0x21CF: case 0x2204: case 0x2209:
case 0x220C: case 0x2224: case 0x2226:
case 0x2241: case 0x2244: case 0x2247:
case 0x2249: case 0x2260: case 0x2262:
case 0x226D: case 0x226E: case 0x226F:
case 0x2270: case 0x2271: case 0x2274:
case 0x2275: case 0x2276: case 0x2278:
case 0x2279: case 0x227A: case 0x227B:
case 0x2280: case 0x2281: case 0x2284:
case 0x2285: case 0x2288: case 0x2289:
case 0x22AC: case 0x22AD: case 0x22AE:
case 0x22AF: case 0x22E0: case 0x22E1:
case 0x22E2: case 0x22E3: case 0x22EA:
case 0x22EB: case 0x22EC: case 0x22ED:
/*
* Those code points are not converted to
* NFD on Mac OS. I do not know the reason
* because it is undocumented.
* NFC NFD
* 1109A ==> 11099 110BA
* 1109C ==> 1109B 110BA
* 110AB ==> 110A5 110BA
*/
case 0x1109A: case 0x1109C: case 0x110AB:
ret = 1;
break;
}
}
op16be += unicode_to_utf16be(op16be, uc);
op16le += unicode_to_utf16le(op16le, uc);
owp += unicode_to_wc(owp, uc);
op += unicode_to_utf8(op, uc);
if (!*p) {
*op16be++ = 0;
*op16be = 0;
*op16le++ = 0;
*op16le = 0;
*owp = L'\0';
*op = '\0';
break;
}
uc = 0;
}
p++;
}
return (ret);
}
static int
is_wc_unicode(void)
{
#if defined(_WIN32) && !defined(__CYGWIN__)
return (1);
#else
return (0);
#endif
}
/*
* A conversion test that we correctly normalize UTF-8 and UTF-16BE characters.
* On Mac OS, the characters to be Form D.
* On other platforms, the characters to be Form C.
*/
static void
test_archive_string_normalization_nfc(const char *testdata)
{
struct archive *a, *a2;
struct archive_string utf8;
struct archive_mstring mstr;
struct archive_string_conv *f_sconv8, *t_sconv8;
struct archive_string_conv *f_sconv16be, *f_sconv16le;
FILE *fp;
char buff[512];
int line = 0;
int locale_is_utf8, wc_is_unicode;
int sconv_opt = SCONV_SET_OPT_NORMALIZATION_C;
locale_is_utf8 = (NULL != setlocale(LC_ALL, "en_US.UTF-8"));
wc_is_unicode = is_wc_unicode();
/* If it doesn't exist, just warn and return. */
if (!locale_is_utf8 && !wc_is_unicode) {
skipping("A test of string normalization for NFC requires "
"a suitable locale; en_US.UTF-8 not available on this "
"system");
return;
}
archive_string_init(&utf8);
memset(&mstr, 0, sizeof(mstr));
/*
* Create string conversion objects.
*/
assert((a = archive_read_new()) != NULL);
assertA(NULL != (f_sconv8 =
archive_string_conversion_from_charset(a, "UTF-8", 0)));
assertA(NULL != (f_sconv16be =
archive_string_conversion_from_charset(a, "UTF-16BE", 0)));
assertA(NULL != (f_sconv16le =
archive_string_conversion_from_charset(a, "UTF-16LE", 0)));
assert((a2 = archive_write_new()) != NULL);
assertA(NULL != (t_sconv8 =
archive_string_conversion_to_charset(a2, "UTF-8", 0)));
if (f_sconv8 == NULL || f_sconv16be == NULL || f_sconv16le == NULL ||
t_sconv8 == NULL) {
/* We cannot continue this test. */
assertEqualInt(ARCHIVE_OK, archive_read_free(a));
return;
}
archive_string_conversion_set_opt(f_sconv8, sconv_opt);
archive_string_conversion_set_opt(f_sconv16be, sconv_opt);
archive_string_conversion_set_opt(f_sconv16le, sconv_opt);
archive_string_conversion_set_opt(t_sconv8, sconv_opt);
/* Open a test pattern file. */
assert((fp = fopen(testdata, "r")) != NULL);
/*
* Read test data.
* Test data format:
* <NFC Unicode pattern> ';' <NFD Unicode pattern> '\n'
* Unicode pattern format:
* [0-9A-F]{4,5}([ ][0-9A-F]{4,5}){0,}
*/
while (fgets(buff, sizeof(buff), fp) != NULL) {
char nfc[80], nfd[80];
char utf8_nfc[80], utf8_nfd[80];
char utf16be_nfc[80], utf16be_nfd[80];
char utf16le_nfc[80], utf16le_nfd[80];
wchar_t wc_nfc[40], wc_nfd[40];
char *e, *p;
const wchar_t *wp;
const char *mp;
size_t mplen;
line++;
if (buff[0] == '#')
continue;
p = strchr(buff, ';');
if (p == NULL)
continue;
*p++ = '\0';
/* Copy an NFC pattern */
strncpy(nfc, buff, sizeof(nfc)-1);
nfc[sizeof(nfc)-1] = '\0';
e = p;
p = strchr(p, '\n');
if (p == NULL)
continue;
*p = '\0';
/* Copy an NFD pattern */
strncpy(nfd, e, sizeof(nfd)-1);
nfd[sizeof(nfd)-1] = '\0';
/*
* Get an NFC patterns.
*/
scan_unicode_pattern(utf8_nfc, wc_nfc, utf16be_nfc, utf16le_nfc,
nfc, 0);
/*
* Get an NFD patterns.
*/
scan_unicode_pattern(utf8_nfd, wc_nfd, utf16be_nfd, utf16le_nfd,
nfd, 0);
if (locale_is_utf8) {
/*
* Normalize an NFD string for import.
*/
assertEqualInt(0, archive_strcpy_l(
&utf8, utf8_nfd, f_sconv8));
failure("NFD(%s) should be converted to NFC(%s):%d",
nfd, nfc, line);
assertEqualUTF8String(utf8_nfc, utf8.s);
/*
* Normalize an NFC string for import.
*/
assertEqualInt(0, archive_strcpy_l(
&utf8, utf8_nfc, f_sconv8));
failure("NFC(%s) should not be any changed:%d",
nfc, line);
assertEqualUTF8String(utf8_nfc, utf8.s);
/*
* Copy an NFC string for export.
*/
assertEqualInt(0, archive_strcpy_l(
&utf8, utf8_nfc, t_sconv8));
failure("NFC(%s) should not be any changed:%d",
nfc, line);
assertEqualUTF8String(utf8_nfc, utf8.s);
/*
* Normalize an NFD string in UTF-16BE for import.
*/
assertEqualInt(0, archive_strncpy_l(
&utf8, utf16be_nfd, 100000, f_sconv16be));
failure("NFD(%s) should be converted to NFC(%s):%d",
nfd, nfc, line);
assertEqualUTF8String(utf8_nfc, utf8.s);
/*
* Normalize an NFD string in UTF-16LE for import.
*/
assertEqualInt(0, archive_strncpy_l(
&utf8, utf16le_nfd, 100000, f_sconv16le));
failure("NFD(%s) should be converted to NFC(%s):%d",
nfd, nfc, line);
assertEqualUTF8String(utf8_nfc, utf8.s);
}
/*
* Test for archive_mstring interface.
* In specific, Windows platform UTF-16BE is directly
* converted to/from wide-character to avoid the effect of
* current locale since windows platform cannot make
* locale UTF-8.
*/
if (locale_is_utf8 || wc_is_unicode) {
/*
* Normalize an NFD string in UTF-8 for import.
*/
assertEqualInt(0, archive_mstring_copy_mbs_len_l(
&mstr, utf8_nfd, 100000, f_sconv8));
assertEqualInt(0,
archive_mstring_get_wcs(a, &mstr, &wp));
failure("UTF-8 NFD(%s) should be converted "
"to WCS NFC(%s):%d", nfd, nfc, line);
assertEqualWString(wc_nfc, wp);
/*
* Normalize an NFD string in UTF-16BE for import.
*/
assertEqualInt(0, archive_mstring_copy_mbs_len_l(
&mstr, utf16be_nfd, 100000, f_sconv16be));
assertEqualInt(0,
archive_mstring_get_wcs(a, &mstr, &wp));
failure("UTF-8 NFD(%s) should be converted "
"to WCS NFC(%s):%d", nfd, nfc, line);
assertEqualWString(wc_nfc, wp);
/*
* Normalize an NFD string in UTF-16LE for import.
*/
assertEqualInt(0, archive_mstring_copy_mbs_len_l(
&mstr, utf16le_nfd, 100000, f_sconv16le));
assertEqualInt(0,
archive_mstring_get_wcs(a, &mstr, &wp));
failure("UTF-8 NFD(%s) should be converted "
"to WCS NFC(%s):%d", nfd, nfc, line);
assertEqualWString(wc_nfc, wp);
/*
* Copy an NFC wide-string for export.
*/
assertEqualInt(0,
archive_mstring_copy_wcs(&mstr, wc_nfc));
assertEqualInt(0, archive_mstring_get_mbs_l(
&mstr, &mp, &mplen, t_sconv8));
failure("WCS NFC(%s) should be UTF-8 NFC:%d"
,nfc, line);
assertEqualUTF8String(utf8_nfc, mp);
}
}
archive_string_free(&utf8);
archive_mstring_clean(&mstr);
fclose(fp);
assertEqualInt(ARCHIVE_OK, archive_read_free(a));
assertEqualInt(ARCHIVE_OK, archive_write_free(a2));
}
static void
test_archive_string_normalization_mac_nfd(const char *testdata)
{
struct archive *a, *a2;
struct archive_string utf8;
struct archive_mstring mstr;
struct archive_string_conv *f_sconv8, *t_sconv8;
struct archive_string_conv *f_sconv16be, *f_sconv16le;
FILE *fp;
char buff[512];
int line = 0;
int locale_is_utf8, wc_is_unicode;
int sconv_opt = SCONV_SET_OPT_NORMALIZATION_D;
locale_is_utf8 = (NULL != setlocale(LC_ALL, "en_US.UTF-8"));
wc_is_unicode = is_wc_unicode();
/* If it doesn't exist, just warn and return. */
if (!locale_is_utf8 && !wc_is_unicode) {
skipping("A test of string normalization for NFD requires "
"a suitable locale; en_US.UTF-8 not available on this "
"system");
return;
}
archive_string_init(&utf8);
memset(&mstr, 0, sizeof(mstr));
/*
* Create string conversion objects.
*/
assert((a = archive_read_new()) != NULL);
assertA(NULL != (f_sconv8 =
archive_string_conversion_from_charset(a, "UTF-8", 0)));
assertA(NULL != (f_sconv16be =
archive_string_conversion_from_charset(a, "UTF-16BE", 0)));
assertA(NULL != (f_sconv16le =
archive_string_conversion_from_charset(a, "UTF-16LE", 0)));
assert((a2 = archive_write_new()) != NULL);
assertA(NULL != (t_sconv8 =
archive_string_conversion_to_charset(a2, "UTF-8", 0)));
if (f_sconv8 == NULL || f_sconv16be == NULL || f_sconv16le == NULL ||
t_sconv8 == NULL) {
/* We cannot continue this test. */
assertEqualInt(ARCHIVE_OK, archive_read_free(a));
return;
}
archive_string_conversion_set_opt(f_sconv8, sconv_opt);
archive_string_conversion_set_opt(f_sconv16be, sconv_opt);
archive_string_conversion_set_opt(f_sconv16le, sconv_opt);
archive_string_conversion_set_opt(t_sconv8, sconv_opt);
/* Open a test pattern file. */
assert((fp = fopen(testdata, "r")) != NULL);
/*
* Read test data.
* Test data format:
* <NFC Unicode pattern> ';' <NFD Unicode pattern> '\n'
* Unicode pattern format:
* [0-9A-F]{4,5}([ ][0-9A-F]{4,5}){0,}
*/
while (fgets(buff, sizeof(buff), fp) != NULL) {
char nfc[80], nfd[80];
char utf8_nfc[80], utf8_nfd[80];
char utf16be_nfc[80], utf16be_nfd[80];
char utf16le_nfc[80], utf16le_nfd[80];
wchar_t wc_nfc[40], wc_nfd[40];
char *e, *p;
const wchar_t *wp;
const char *mp;
size_t mplen;
int should_be_nfc;
line++;
if (buff[0] == '#')
continue;
p = strchr(buff, ';');
if (p == NULL)
continue;
*p++ = '\0';
/* Copy an NFC pattern */
strncpy(nfc, buff, sizeof(nfc)-1);
nfc[sizeof(nfc)-1] = '\0';
e = p;
p = strchr(p, '\n');
if (p == NULL)
continue;
*p = '\0';
/* Copy an NFD pattern */
strncpy(nfd, e, sizeof(nfd)-1);
nfd[sizeof(nfd)-1] = '\0';
/*
* Get an NFC patterns.
*/
should_be_nfc = scan_unicode_pattern(utf8_nfc, wc_nfc,
utf16be_nfc, utf16le_nfc, nfc, 1);
/*
* Get an NFD patterns.
*/
scan_unicode_pattern(utf8_nfd, wc_nfd, utf16be_nfd, utf16le_nfd,
nfd, 0);
if (locale_is_utf8) {
/*
* Normalize an NFC string for import.
*/
assertEqualInt(0, archive_strcpy_l(
&utf8, utf8_nfc, f_sconv8));
if (should_be_nfc) {
failure("NFC(%s) should not be converted to"
" NFD(%s):%d", nfc, nfd, line);
assertEqualUTF8String(utf8_nfc, utf8.s);
} else {
failure("NFC(%s) should be converted to"
" NFD(%s):%d", nfc, nfd, line);
assertEqualUTF8String(utf8_nfd, utf8.s);
}
/*
* Normalize an NFD string for import.
*/
assertEqualInt(0, archive_strcpy_l(
&utf8, utf8_nfd, f_sconv8));
failure("NFD(%s) should not be any changed:%d",
nfd, line);
assertEqualUTF8String(utf8_nfd, utf8.s);
/*
* Copy an NFD string for export.
*/
assertEqualInt(0, archive_strcpy_l(
&utf8, utf8_nfd, t_sconv8));
failure("NFD(%s) should not be any changed:%d",
nfd, line);
assertEqualUTF8String(utf8_nfd, utf8.s);
/*
* Normalize an NFC string in UTF-16BE for import.
*/
assertEqualInt(0, archive_strncpy_l(
&utf8, utf16be_nfc, 100000, f_sconv16be));
if (should_be_nfc) {
failure("NFC(%s) should not be converted to"
" NFD(%s):%d", nfc, nfd, line);
assertEqualUTF8String(utf8_nfc, utf8.s);
} else {
failure("NFC(%s) should be converted to"
" NFD(%s):%d", nfc, nfd, line);
assertEqualUTF8String(utf8_nfd, utf8.s);
}
/*
* Normalize an NFC string in UTF-16LE for import.
*/
assertEqualInt(0, archive_strncpy_l(
&utf8, utf16le_nfc, 100000, f_sconv16le));
if (should_be_nfc) {
failure("NFC(%s) should not be converted to"
" NFD(%s):%d", nfc, nfd, line);
assertEqualUTF8String(utf8_nfc, utf8.s);
} else {
failure("NFC(%s) should be converted to"
" NFD(%s):%d", nfc, nfd, line);
assertEqualUTF8String(utf8_nfd, utf8.s);
}
}
/*
* Test for archive_mstring interface.
* In specific, Windows platform UTF-16BE is directly
* converted to/from wide-character to avoid the effect of
* current locale since windows platform cannot make
* locale UTF-8.
*/
if (locale_is_utf8 || wc_is_unicode) {
/*
* Normalize an NFD string in UTF-8 for import.
*/
assertEqualInt(0, archive_mstring_copy_mbs_len_l(
&mstr, utf8_nfc, 100000, f_sconv8));
assertEqualInt(0,
archive_mstring_get_wcs(a, &mstr, &wp));
if (should_be_nfc) {
failure("UTF-8 NFC(%s) should not be converted "
"to WCS NFD(%s):%d", nfc, nfd, line);
assertEqualWString(wc_nfc, wp);
} else {
failure("UTF-8 NFC(%s) should be converted "
"to WCS NFD(%s):%d", nfc, nfd, line);
assertEqualWString(wc_nfd, wp);
}
/*
* Normalize an NFD string in UTF-16BE for import.
*/
assertEqualInt(0, archive_mstring_copy_mbs_len_l(
&mstr, utf16be_nfc, 100000, f_sconv16be));
assertEqualInt(0,
archive_mstring_get_wcs(a, &mstr, &wp));
if (should_be_nfc) {
failure("UTF-16BE NFC(%s) should not be "
"converted to WCS NFD(%s):%d",
nfc, nfd, line);
assertEqualWString(wc_nfc, wp);
} else {
failure("UTF-16BE NFC(%s) should be converted "
"to WCS NFD(%s):%d", nfc, nfd, line);
assertEqualWString(wc_nfd, wp);
}
/*
* Normalize an NFD string in UTF-16LE for import.
*/
assertEqualInt(0, archive_mstring_copy_mbs_len_l(
&mstr, utf16le_nfc, 100000, f_sconv16le));
assertEqualInt(0,
archive_mstring_get_wcs(a, &mstr, &wp));
if (should_be_nfc) {
failure("UTF-16LE NFC(%s) should not be "
"converted to WCS NFD(%s):%d",
nfc, nfd, line);
assertEqualWString(wc_nfc, wp);
} else {
failure("UTF-16LE NFC(%s) should be converted "
"to WCS NFD(%s):%d", nfc, nfd, line);
assertEqualWString(wc_nfd, wp);
}
/*
* Copy an NFD wide-string for export.
*/
assertEqualInt(0, archive_mstring_copy_wcs(
&mstr, wc_nfd));
assertEqualInt(0, archive_mstring_get_mbs_l(
&mstr, &mp, &mplen, t_sconv8));
failure("WCS NFD(%s) should be UTF-8 NFD:%d"
,nfd, line);
assertEqualUTF8String(utf8_nfd, mp);
}
}
archive_string_free(&utf8);
archive_mstring_clean(&mstr);
fclose(fp);
assertEqualInt(ARCHIVE_OK, archive_read_free(a));
assertEqualInt(ARCHIVE_OK, archive_write_free(a2));
}
static void
test_archive_string_canonicalization(void)
{
struct archive *a;
struct archive_string_conv *sconv;
setlocale(LC_ALL, "en_US.UTF-8");
assert((a = archive_read_new()) != NULL);
assertA(NULL != (sconv =
archive_string_conversion_to_charset(a, "UTF-8", 1)));
failure("Charset name should be UTF-8");
assertEqualString("UTF-8",
archive_string_conversion_charset_name(sconv));
assertA(NULL != (sconv =
archive_string_conversion_to_charset(a, "UTF8", 1)));
failure("Charset name should be UTF-8");
assertEqualString("UTF-8",
archive_string_conversion_charset_name(sconv));
assertA(NULL != (sconv =
archive_string_conversion_to_charset(a, "utf8", 1)));
failure("Charset name should be UTF-8");
assertEqualString("UTF-8",
archive_string_conversion_charset_name(sconv));
assertA(NULL != (sconv =
archive_string_conversion_to_charset(a, "UTF-16BE", 1)));
failure("Charset name should be UTF-16BE");
assertEqualString("UTF-16BE",
archive_string_conversion_charset_name(sconv));
assertA(NULL != (sconv =
archive_string_conversion_to_charset(a, "UTF16BE", 1)));
failure("Charset name should be UTF-16BE");
assertEqualString("UTF-16BE",
archive_string_conversion_charset_name(sconv));
assertA(NULL != (sconv =
archive_string_conversion_to_charset(a, "utf16be", 1)));
failure("Charset name should be UTF-16BE");
assertEqualString("UTF-16BE",
archive_string_conversion_charset_name(sconv));
assertA(NULL != (sconv =
archive_string_conversion_to_charset(a, "UTF-16LE", 1)));
failure("Charset name should be UTF-16LE");
assertEqualString("UTF-16LE",
archive_string_conversion_charset_name(sconv));
assertA(NULL != (sconv =
archive_string_conversion_to_charset(a, "UTF16LE", 1)));
failure("Charset name should be UTF-16LE");
assertEqualString("UTF-16LE",
archive_string_conversion_charset_name(sconv));
assertA(NULL != (sconv =
archive_string_conversion_to_charset(a, "utf16le", 1)));
failure("Charset name should be UTF-16LE");
assertEqualString("UTF-16LE",
archive_string_conversion_charset_name(sconv));
assertEqualInt(ARCHIVE_OK, archive_read_free(a));
}
DEFINE_TEST(test_archive_string_conversion)
{
static const char reffile[] = "test_archive_string_conversion.txt.Z";
static const char testdata[] = "testdata.txt";
struct archive *a;
struct archive_entry *ae;
char buff[512];
ssize_t size;
FILE *fp;
/*
* Extract a test pattern file.
*/
extract_reference_file(reffile);
assert((a = archive_read_new()) != NULL);
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_filter_all(a));
assertEqualIntA(a, ARCHIVE_OK, archive_read_support_format_raw(a));
assertEqualIntA(a, ARCHIVE_OK,
archive_read_open_filename(a, reffile, 512));
assertEqualIntA(a, ARCHIVE_OK, archive_read_next_header(a, &ae));
assert((fp = fopen(testdata, "w")) != NULL);
while ((size = archive_read_data(a, buff, 512)) > 0)
assertEqualInt(size, fwrite(buff, 1, size, fp));
assertEqualInt(0, fclose(fp));
assertEqualInt(ARCHIVE_OK, archive_read_free(a));
test_archive_string_normalization_nfc(testdata);
test_archive_string_normalization_mac_nfd(testdata);
test_archive_string_canonicalization();
}