blob: df9cebed9fb0206b79c9d77db7e8cb9b0adf2991 [file] [log] [blame]
// © 2016 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
/********************************************************************
* COPYRIGHT:
* Copyright (c) 1997-2016, International Business Machines Corporation and
* others. All Rights Reserved.
********************************************************************/
/*****************************************************************************
*
* File CLOCTST.C
*
* Modification History:
* Name Description
* Madhu Katragadda Ported for C API
******************************************************************************
*/
#include "cloctst.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "cintltst.h"
#include "cmemory.h"
#include "cstring.h"
#include "uparse.h"
#include "uresimp.h"
#include "uassert.h"
#include "unicode/putil.h"
#include "unicode/ubrk.h"
#include "unicode/uchar.h"
#include "unicode/ucol.h"
#include "unicode/udat.h"
#include "unicode/uloc.h"
#include "unicode/umsg.h"
#include "unicode/ures.h"
#include "unicode/uset.h"
#include "unicode/ustring.h"
#include "unicode/utypes.h"
#include "unicode/ulocdata.h"
#include "unicode/uldnames.h"
#include "unicode/parseerr.h" /* may not be included with some uconfig switches */
#include "udbgutil.h"
static void TestNullDefault(void);
static void TestNonexistentLanguageExemplars(void);
static void TestLocDataErrorCodeChaining(void);
static void TestLocDataWithRgTag(void);
static void TestLanguageExemplarsFallbacks(void);
static void TestDisplayNameBrackets(void);
static void TestIllegalArgumentWhenNoDataWithNoSubstitute(void);
static void Test21157CorrectTerminating(void);
static void TestUnicodeDefines(void);
static void TestIsRightToLeft(void);
static void TestBadLocaleIDs(void);
static void TestBug20370(void);
static void TestBug20321UnicodeLocaleKey(void);
static void TestUsingDefaultWarning(void);
void PrintDataTable();
/*---------------------------------------------------
table of valid data
--------------------------------------------------- */
#define LOCALE_SIZE 9
#define LOCALE_INFO_SIZE 28
static const char* const rawData2[LOCALE_INFO_SIZE][LOCALE_SIZE] = {
/* language code */
{ "en", "fr", "ca", "el", "no", "zh", "de", "es", "ja" },
/* script code */
{ "", "", "", "", "", "", "", "", "" },
/* country code */
{ "US", "FR", "ES", "GR", "NO", "CN", "DE", "", "JP" },
/* variant code */
{ "", "", "", "", "NY", "", "", "", "" },
/* full name */
{ "en_US", "fr_FR", "ca_ES",
"el_GR", "no_NO_NY", "zh_Hans_CN",
"de_DE@collation=phonebook", "es@collation=traditional", "ja_JP@calendar=japanese" },
/* ISO-3 language */
{ "eng", "fra", "cat", "ell", "nor", "zho", "deu", "spa", "jpn" },
/* ISO-3 country */
{ "USA", "FRA", "ESP", "GRC", "NOR", "CHN", "DEU", "", "JPN" },
/* LCID */
{ "409", "40c", "403", "408", "814", "804", "10407", "40a", "411" },
/* display language (English) */
{ "English", "French", "Catalan", "Greek", "Norwegian", "Chinese", "German", "Spanish", "Japanese" },
/* display script code (English) */
{ "", "", "", "", "", "Simplified Han", "", "", "" },
/* display country (English) */
{ "United States", "France", "Spain", "Greece", "Norway", "China", "Germany", "", "Japan" },
/* display variant (English) */
{ "", "", "", "", "NY", "", "", "", "" },
/* display name (English) */
{ "English (United States)", "French (France)", "Catalan (Spain)",
"Greek (Greece)", "Norwegian (Norway, NY)", "Chinese (Simplified, China)",
"German (Germany, Sort Order=Phonebook Sort Order)", "Spanish (Sort Order=Traditional Sort Order)", "Japanese (Japan, Calendar=Japanese Calendar)" },
/* display language (French) */
{ "anglais", "fran\\u00E7ais", "catalan", "grec", "norv\\u00E9gien", "chinois", "allemand", "espagnol", "japonais" },
/* display script code (French) */
{ "", "", "", "", "", "sinogrammes simplifi\\u00e9s", "", "", "" },
/* display country (French) */
{ "\\u00C9tats-Unis", "France", "Espagne", "Gr\\u00E8ce", "Norv\\u00E8ge", "Chine", "Allemagne", "", "Japon" },
/* display variant (French) */
{ "", "", "", "", "NY", "", "", "", "" },
/* display name (French) */
{ "anglais (\\u00C9tats-Unis)", "fran\\u00E7ais (France)", "catalan (Espagne)",
"grec (Gr\\u00E8ce)", "norv\\u00E9gien (Norv\\u00E8ge, NY)", "chinois (simplifi\\u00e9, Chine)",
"allemand (Allemagne, ordre de tri=ordre de l\\u2019annuaire)", "espagnol (ordre de tri=ordre traditionnel)", "japonais (Japon, calendrier=calendrier japonais)" },
/* display language (Catalan) */
{ "angl\\u00E8s", "franc\\u00E8s", "catal\\u00E0", "grec", "noruec", "xin\\u00E8s", "alemany", "espanyol", "japon\\u00E8s" },
/* display script code (Catalan) */
{ "", "", "", "", "", "han simplificat", "", "", "" },
/* display country (Catalan) */
{ "Estats Units", "Fran\\u00E7a", "Espanya", "Gr\\u00E8cia", "Noruega", "Xina", "Alemanya", "", "Jap\\u00F3" },
/* display variant (Catalan) */
{ "", "", "", "", "NY", "", "", "", "" },
/* display name (Catalan) */
{ "angl\\u00E8s (Estats Units)", "franc\\u00E8s (Fran\\u00E7a)", "catal\\u00E0 (Espanya)",
"grec (Gr\\u00E8cia)", "noruec (Noruega, NY)", "xin\\u00E8s (simplificat, Xina)",
"alemany (Alemanya, ordenaci\\u00F3=ordre de la guia telef\\u00F2nica)", "espanyol (ordenaci\\u00F3=ordre tradicional)", "japon\\u00E8s (Jap\\u00F3, calendari=calendari japon\\u00e8s)" },
/* display language (Greek) */
{
"\\u0391\\u03b3\\u03b3\\u03bb\\u03b9\\u03ba\\u03ac",
"\\u0393\\u03b1\\u03bb\\u03bb\\u03b9\\u03ba\\u03ac",
"\\u039a\\u03b1\\u03c4\\u03b1\\u03bb\\u03b1\\u03bd\\u03b9\\u03ba\\u03ac",
"\\u0395\\u03bb\\u03bb\\u03b7\\u03bd\\u03b9\\u03ba\\u03ac",
"\\u039d\\u03bf\\u03c1\\u03b2\\u03b7\\u03b3\\u03b9\\u03ba\\u03ac",
"\\u039A\\u03B9\\u03BD\\u03B5\\u03B6\\u03B9\\u03BA\\u03AC",
"\\u0393\\u03B5\\u03C1\\u03BC\\u03B1\\u03BD\\u03B9\\u03BA\\u03AC",
"\\u0399\\u03C3\\u03C0\\u03B1\\u03BD\\u03B9\\u03BA\\u03AC",
"\\u0399\\u03B1\\u03C0\\u03C9\\u03BD\\u03B9\\u03BA\\u03AC"
},
/* display script code (Greek) */
{ "", "", "", "", "", "\\u0391\\u03c0\\u03bb\\u03bf\\u03c0\\u03bf\\u03b9\\u03b7\\u03bc\\u03ad\\u03bd\\u03bf \\u03a7\\u03b1\\u03bd", "", "", "" },
/* display country (Greek) */
{
"\\u0397\\u03BD\\u03C9\\u03BC\\u03AD\\u03BD\\u03B5\\u03C2 \\u03A0\\u03BF\\u03BB\\u03B9\\u03C4\\u03B5\\u03AF\\u03B5\\u03C2",
"\\u0393\\u03b1\\u03bb\\u03bb\\u03af\\u03b1",
"\\u0399\\u03c3\\u03c0\\u03b1\\u03bd\\u03af\\u03b1",
"\\u0395\\u03bb\\u03bb\\u03ac\\u03b4\\u03b1",
"\\u039d\\u03bf\\u03c1\\u03b2\\u03b7\\u03b3\\u03af\\u03b1",
"\\u039A\\u03AF\\u03BD\\u03B1",
"\\u0393\\u03B5\\u03C1\\u03BC\\u03B1\\u03BD\\u03AF\\u03B1",
"",
"\\u0399\\u03B1\\u03C0\\u03C9\\u03BD\\u03AF\\u03B1"
},
/* display variant (Greek) */
{ "", "", "", "", "NY", "", "", "", "" }, /* TODO: currently there is no translation for NY in Greek fix this test when we have it */
/* display name (Greek) */
{
"\\u0391\\u03b3\\u03b3\\u03bb\\u03b9\\u03ba\\u03ac (\\u0397\\u03BD\\u03C9\\u03BC\\u03AD\\u03BD\\u03B5\\u03C2 \\u03A0\\u03BF\\u03BB\\u03B9\\u03C4\\u03B5\\u03AF\\u03B5\\u03C2)",
"\\u0393\\u03b1\\u03bb\\u03bb\\u03b9\\u03ba\\u03ac (\\u0393\\u03b1\\u03bb\\u03bb\\u03af\\u03b1)",
"\\u039a\\u03b1\\u03c4\\u03b1\\u03bb\\u03b1\\u03bd\\u03b9\\u03ba\\u03ac (\\u0399\\u03c3\\u03c0\\u03b1\\u03bd\\u03af\\u03b1)",
"\\u0395\\u03bb\\u03bb\\u03b7\\u03bd\\u03b9\\u03ba\\u03ac (\\u0395\\u03bb\\u03bb\\u03ac\\u03b4\\u03b1)",
"\\u039d\\u03bf\\u03c1\\u03b2\\u03b7\\u03b3\\u03b9\\u03ba\\u03ac (\\u039d\\u03bf\\u03c1\\u03b2\\u03b7\\u03b3\\u03af\\u03b1, NY)",
"\\u039A\\u03B9\\u03BD\\u03B5\\u03B6\\u03B9\\u03BA\\u03AC (\\u0391\\u03c0\\u03bb\\u03bf\\u03c0\\u03bf\\u03b9\\u03b7\\u03bc\\u03ad\\u03bd\\u03bf, \\u039A\\u03AF\\u03BD\\u03B1)",
"\\u0393\\u03b5\\u03c1\\u03bc\\u03b1\\u03bd\\u03b9\\u03ba\\u03ac (\\u0393\\u03b5\\u03c1\\u03bc\\u03b1\\u03bd\\u03af\\u03b1, \\u03a3\\u03b5\\u03b9\\u03c1\\u03ac \\u03c4\\u03b1\\u03be\\u03b9\\u03bd\\u03cc\\u03bc\\u03b7\\u03c3\\u03b7\\u03c2=\\u03a3\\u03b5\\u03b9\\u03c1\\u03ac \\u03c4\\u03b1\\u03be\\u03b9\\u03bd\\u03cc\\u03bc\\u03b7\\u03c3\\u03b7\\u03c2 \\u03c4\\u03b7\\u03bb\\u03b5\\u03c6\\u03c9\\u03bd\\u03b9\\u03ba\\u03bf\\u03cd \\u03ba\\u03b1\\u03c4\\u03b1\\u03bb\\u03cc\\u03b3\\u03bf\\u03c5)",
"\\u0399\\u03c3\\u03c0\\u03b1\\u03bd\\u03b9\\u03ba\\u03ac (\\u03a3\\u03b5\\u03b9\\u03c1\\u03ac \\u03c4\\u03b1\\u03be\\u03b9\\u03bd\\u03cc\\u03bc\\u03b7\\u03c3\\u03b7\\u03c2=\\u03a0\\u03b1\\u03c1\\u03b1\\u03b4\\u03bf\\u03c3\\u03b9\\u03b1\\u03ba\\u03ae \\u03c3\\u03b5\\u03b9\\u03c1\\u03ac \\u03c4\\u03b1\\u03be\\u03b9\\u03bd\\u03cc\\u03bc\\u03b7\\u03c3\\u03b7\\u03c2)",
"\\u0399\\u03b1\\u03c0\\u03c9\\u03bd\\u03b9\\u03ba\\u03ac (\\u0399\\u03b1\\u03c0\\u03c9\\u03bd\\u03af\\u03b1, \\u0397\\u03bc\\u03b5\\u03c1\\u03bf\\u03bb\\u03cc\\u03b3\\u03b9\\u03bf=\\u0399\\u03b1\\u03c0\\u03c9\\u03bd\\u03b9\\u03ba\\u03cc \\u03b7\\u03bc\\u03b5\\u03c1\\u03bf\\u03bb\\u03cc\\u03b3\\u03b9\\u03bf)"
}
};
static UChar*** dataTable=0;
enum {
ENGLISH = 0,
FRENCH = 1,
CATALAN = 2,
GREEK = 3,
NORWEGIAN = 4
};
enum {
LANG = 0,
SCRIPT = 1,
CTRY = 2,
VAR = 3,
NAME = 4,
LANG3 = 5,
CTRY3 = 6,
LCID = 7,
DLANG_EN = 8,
DSCRIPT_EN = 9,
DCTRY_EN = 10,
DVAR_EN = 11,
DNAME_EN = 12,
DLANG_FR = 13,
DSCRIPT_FR = 14,
DCTRY_FR = 15,
DVAR_FR = 16,
DNAME_FR = 17,
DLANG_CA = 18,
DSCRIPT_CA = 19,
DCTRY_CA = 20,
DVAR_CA = 21,
DNAME_CA = 22,
DLANG_EL = 23,
DSCRIPT_EL = 24,
DCTRY_EL = 25,
DVAR_EL = 26,
DNAME_EL = 27
};
#define TESTCASE(name) addTest(root, &name, "tsutil/cloctst/" #name)
void addLocaleTest(TestNode** root);
void addLocaleTest(TestNode** root)
{
TESTCASE(TestObsoleteNames); /* srl- move */
TESTCASE(TestBasicGetters);
TESTCASE(TestNullDefault);
TESTCASE(TestPrefixes);
TESTCASE(TestSimpleResourceInfo);
TESTCASE(TestDisplayNames);
TESTCASE(TestGetDisplayScriptPreFlighting21160);
TESTCASE(TestGetAvailableLocales);
TESTCASE(TestGetAvailableLocalesByType);
TESTCASE(TestDataDirectory);
#if !UCONFIG_NO_FILE_IO && !UCONFIG_NO_LEGACY_CONVERSION
TESTCASE(TestISOFunctions);
#endif
TESTCASE(TestISO3Fallback);
TESTCASE(TestUninstalledISO3Names);
TESTCASE(TestSimpleDisplayNames);
TESTCASE(TestVariantParsing);
TESTCASE(TestKeywordVariants);
TESTCASE(TestKeywordVariantParsing);
TESTCASE(TestCanonicalization);
TESTCASE(TestCanonicalizationBuffer);
TESTCASE(TestKeywordSet);
TESTCASE(TestKeywordSetError);
TESTCASE(TestDisplayKeywords);
TESTCASE(TestDisplayKeywordValues);
TESTCASE(TestGetBaseName);
#if !UCONFIG_NO_FILE_IO
TESTCASE(TestGetLocale);
#endif
TESTCASE(TestDisplayNameWarning);
TESTCASE(Test21157CorrectTerminating);
TESTCASE(TestNonexistentLanguageExemplars);
TESTCASE(TestLocDataErrorCodeChaining);
TESTCASE(TestLocDataWithRgTag);
TESTCASE(TestLanguageExemplarsFallbacks);
TESTCASE(TestCalendar);
TESTCASE(TestDateFormat);
TESTCASE(TestCollation);
TESTCASE(TestULocale);
TESTCASE(TestUResourceBundle);
TESTCASE(TestDisplayName);
TESTCASE(TestAcceptLanguage);
TESTCASE(TestGetLocaleForLCID);
TESTCASE(TestOrientation);
TESTCASE(TestLikelySubtags);
TESTCASE(TestToLanguageTag);
TESTCASE(TestBug20132);
TESTCASE(TestBug20149);
TESTCASE(TestCDefaultLocale);
TESTCASE(TestForLanguageTag);
TESTCASE(TestLangAndRegionCanonicalize);
TESTCASE(TestTrailingNull);
TESTCASE(TestUnicodeDefines);
TESTCASE(TestEnglishExemplarCharacters);
TESTCASE(TestDisplayNameBrackets);
TESTCASE(TestIllegalArgumentWhenNoDataWithNoSubstitute);
TESTCASE(TestIsRightToLeft);
TESTCASE(TestToUnicodeLocaleKey);
TESTCASE(TestToLegacyKey);
TESTCASE(TestToUnicodeLocaleType);
TESTCASE(TestToLegacyType);
TESTCASE(TestBadLocaleIDs);
TESTCASE(TestBug20370);
TESTCASE(TestBug20321UnicodeLocaleKey);
TESTCASE(TestUsingDefaultWarning);
TESTCASE(TestBug21449InfiniteLoop);
}
/* testing uloc(), uloc_getName(), uloc_getLanguage(), uloc_getVariant(), uloc_getCountry() */
static void TestBasicGetters() {
int32_t i;
int32_t cap;
UErrorCode status = U_ZERO_ERROR;
char *testLocale = 0;
char *temp = 0, *name = 0;
log_verbose("Testing Basic Getters\n");
for (i = 0; i < LOCALE_SIZE; i++) {
testLocale=(char*)malloc(sizeof(char) * (strlen(rawData2[NAME][i])+1));
strcpy(testLocale,rawData2[NAME][i]);
log_verbose("Testing %s .....\n", testLocale);
cap=uloc_getLanguage(testLocale, NULL, 0, &status);
if(status==U_BUFFER_OVERFLOW_ERROR){
status=U_ZERO_ERROR;
temp=(char*)malloc(sizeof(char) * (cap+1));
uloc_getLanguage(testLocale, temp, cap+1, &status);
}
if(U_FAILURE(status)){
log_err("ERROR: in uloc_getLanguage %s\n", myErrorName(status));
}
if (0 !=strcmp(temp,rawData2[LANG][i])) {
log_err(" Language code mismatch: %s versus %s\n", temp, rawData2[LANG][i]);
}
cap=uloc_getCountry(testLocale, temp, cap, &status);
if(status==U_BUFFER_OVERFLOW_ERROR){
status=U_ZERO_ERROR;
temp=(char*)realloc(temp, sizeof(char) * (cap+1));
uloc_getCountry(testLocale, temp, cap+1, &status);
}
if(U_FAILURE(status)){
log_err("ERROR: in uloc_getCountry %s\n", myErrorName(status));
}
if (0 != strcmp(temp, rawData2[CTRY][i])) {
log_err(" Country code mismatch: %s versus %s\n", temp, rawData2[CTRY][i]);
}
cap=uloc_getVariant(testLocale, temp, cap, &status);
if(status==U_BUFFER_OVERFLOW_ERROR){
status=U_ZERO_ERROR;
temp=(char*)realloc(temp, sizeof(char) * (cap+1));
uloc_getVariant(testLocale, temp, cap+1, &status);
}
if(U_FAILURE(status)){
log_err("ERROR: in uloc_getVariant %s\n", myErrorName(status));
}
if (0 != strcmp(temp, rawData2[VAR][i])) {
log_err("Variant code mismatch: %s versus %s\n", temp, rawData2[VAR][i]);
}
cap=uloc_getName(testLocale, NULL, 0, &status);
if(status==U_BUFFER_OVERFLOW_ERROR){
status=U_ZERO_ERROR;
name=(char*)malloc(sizeof(char) * (cap+1));
uloc_getName(testLocale, name, cap+1, &status);
} else if(status==U_ZERO_ERROR) {
log_err("ERROR: in uloc_getName(%s,NULL,0,..), expected U_BUFFER_OVERFLOW_ERROR!\n", testLocale);
}
if(U_FAILURE(status)){
log_err("ERROR: in uloc_getName %s\n", myErrorName(status));
}
if (0 != strcmp(name, rawData2[NAME][i])){
log_err(" Mismatch in getName: %s versus %s\n", name, rawData2[NAME][i]);
}
free(temp);
free(name);
free(testLocale);
}
}
static void TestNullDefault() {
UErrorCode status = U_ZERO_ERROR;
char original[ULOC_FULLNAME_CAPACITY];
uprv_strcpy(original, uloc_getDefault());
uloc_setDefault("qq_BLA", &status);
if (uprv_strcmp(uloc_getDefault(), "qq_BLA") != 0) {
log_err(" Mismatch in uloc_setDefault: qq_BLA versus %s\n", uloc_getDefault());
}
uloc_setDefault(NULL, &status);
if (uprv_strcmp(uloc_getDefault(), original) != 0) {
log_err(" uloc_setDefault(NULL, &status) didn't get the default locale back!\n");
}
{
/* Test that set & get of default locale work, and that
* default locales are cached and reused, and not overwritten.
*/
const char *n_en_US;
const char *n_fr_FR;
const char *n2_en_US;
status = U_ZERO_ERROR;
uloc_setDefault("en_US", &status);
n_en_US = uloc_getDefault();
if (strcmp(n_en_US, "en_US") != 0) {
log_err("Wrong result from uloc_getDefault(). Expected \"en_US\", got \"%s\"\n", n_en_US);
}
uloc_setDefault("fr_FR", &status);
n_fr_FR = uloc_getDefault();
if (strcmp(n_en_US, "en_US") != 0) {
log_err("uloc_setDefault altered previously default string."
"Expected \"en_US\", got \"%s\"\n", n_en_US);
}
if (strcmp(n_fr_FR, "fr_FR") != 0) {
log_err("Wrong result from uloc_getDefault(). Expected \"fr_FR\", got %s\n", n_fr_FR);
}
uloc_setDefault("en_US", &status);
n2_en_US = uloc_getDefault();
if (strcmp(n2_en_US, "en_US") != 0) {
log_err("Wrong result from uloc_getDefault(). Expected \"en_US\", got \"%s\"\n", n_en_US);
}
if (n2_en_US != n_en_US) {
log_err("Default locale cache failed to reuse en_US locale.\n");
}
if (U_FAILURE(status)) {
log_err("Failure returned from uloc_setDefault - \"%s\"\n", u_errorName(status));
}
}
uloc_setDefault(original, &status);
if (U_FAILURE(status)) {
log_err("Failed to change the default locale back to %s\n", original);
}
}
/* Test the i- and x- and @ and . functionality
*/
#define PREFIXBUFSIZ 128
static void TestPrefixes() {
int row = 0;
int n;
const char *loc, *expected;
static const char * const testData[][7] =
{
/* NULL canonicalize() column means "expect same as getName()" */
{"sv", "", "FI", "AL", "sv-fi-al", "sv_FI_AL", NULL},
{"en", "", "GB", "", "en-gb", "en_GB", NULL},
{"i-hakka", "", "MT", "XEMXIJA", "i-hakka_MT_XEMXIJA", "i-hakka_MT_XEMXIJA", NULL},
{"i-hakka", "", "CN", "", "i-hakka_CN", "i-hakka_CN", NULL},
{"i-hakka", "", "MX", "", "I-hakka_MX", "i-hakka_MX", NULL},
{"x-klingon", "", "US", "SANJOSE", "X-KLINGON_us_SANJOSE", "x-klingon_US_SANJOSE", NULL},
{"hy", "", "", "AREVMDA", "hy_AREVMDA", "hy__AREVMDA", "hyw"},
{"de", "", "", "1901", "de-1901", "de__1901", NULL},
{"mr", "", "", "", "mr.utf8", "mr.utf8", "mr"},
{"de", "", "TV", "", "de-tv.koi8r", "de_TV.koi8r", "de_TV"},
{"x-piglatin", "", "ML", "", "x-piglatin_ML.MBE", "x-piglatin_ML.MBE", "x-piglatin_ML"}, /* Multibyte English */
{"i-cherokee", "","US", "", "i-Cherokee_US.utf7", "i-cherokee_US.utf7", "i-cherokee_US"},
{"x-filfli", "", "MT", "FILFLA", "x-filfli_MT_FILFLA.gb-18030", "x-filfli_MT_FILFLA.gb-18030", "x-filfli_MT_FILFLA"},
{"no", "", "NO", "NY", "no-no-ny.utf32@B", "no_NO_NY.utf32@B", "no_NO_NY_B"},
{"no", "", "NO", "", "no-no.utf32@B", "no_NO.utf32@B", "no_NO_B"},
{"no", "", "", "NY", "no__ny", "no__NY", NULL},
{"no", "", "", "", "no@ny", "no@ny", "no__NY"},
{"el", "Latn", "", "", "el-latn", "el_Latn", NULL},
{"en", "Cyrl", "RU", "", "en-cyrl-ru", "en_Cyrl_RU", NULL},
{"qq", "Qqqq", "QQ", "QQ", "qq_Qqqq_QQ_QQ", "qq_Qqqq_QQ_QQ", NULL},
{"qq", "Qqqq", "", "QQ", "qq_Qqqq__QQ", "qq_Qqqq__QQ", NULL},
{"ab", "Cdef", "GH", "IJ", "ab_cdef_gh_ij", "ab_Cdef_GH_IJ", NULL}, /* total garbage */
// Before ICU 64, ICU locale canonicalization had some additional mappings.
// They were removed for ICU-20187 "drop support for long-obsolete locale ID variants".
// The following now use standard canonicalization.
{"zh", "Hans", "", "PINYIN", "zh-Hans-pinyin", "zh_Hans__PINYIN", "zh_Hans__PINYIN"},
{"zh", "Hant", "TW", "STROKE", "zh-hant_TW_STROKE", "zh_Hant_TW_STROKE", "zh_Hant_TW_STROKE"},
{NULL,NULL,NULL,NULL,NULL,NULL,NULL}
};
static const char * const testTitles[] = {
"uloc_getLanguage()",
"uloc_getScript()",
"uloc_getCountry()",
"uloc_getVariant()",
"name",
"uloc_getName()",
"uloc_canonicalize()"
};
char buf[PREFIXBUFSIZ];
int32_t len;
UErrorCode err;
for(row=0;testData[row][0] != NULL;row++) {
loc = testData[row][NAME];
log_verbose("Test #%d: %s\n", row, loc);
err = U_ZERO_ERROR;
len=0;
buf[0]=0;
for(n=0;n<=(NAME+2);n++) {
if(n==NAME) continue;
for(len=0;len<PREFIXBUFSIZ;len++) {
buf[len] = '%'; /* Set a tripwire.. */
}
len = 0;
switch(n) {
case LANG:
len = uloc_getLanguage(loc, buf, PREFIXBUFSIZ, &err);
break;
case SCRIPT:
len = uloc_getScript(loc, buf, PREFIXBUFSIZ, &err);
break;
case CTRY:
len = uloc_getCountry(loc, buf, PREFIXBUFSIZ, &err);
break;
case VAR:
len = uloc_getVariant(loc, buf, PREFIXBUFSIZ, &err);
break;
case NAME+1:
len = uloc_getName(loc, buf, PREFIXBUFSIZ, &err);
break;
case NAME+2:
len = uloc_canonicalize(loc, buf, PREFIXBUFSIZ, &err);
break;
default:
strcpy(buf, "**??");
len=4;
}
if(U_FAILURE(err)) {
log_err("#%d: %s on %s: err %s\n",
row, testTitles[n], loc, u_errorName(err));
} else {
log_verbose("#%d: %s on %s: -> [%s] (length %d)\n",
row, testTitles[n], loc, buf, len);
if(len != (int32_t)strlen(buf)) {
log_err("#%d: %s on %s: -> [%s] (length returned %d, actual %d!)\n",
row, testTitles[n], loc, buf, len, strlen(buf)+1);
}
/* see if they smashed something */
if(buf[len+1] != '%') {
log_err("#%d: %s on %s: -> [%s] - wrote [%X] out ofbounds!\n",
row, testTitles[n], loc, buf, buf[len+1]);
}
expected = testData[row][n];
if (expected == NULL && n == (NAME+2)) {
/* NULL expected canonicalize() means "expect same as getName()" */
expected = testData[row][NAME+1];
}
if(strcmp(buf, expected)) {
log_err("#%d: %s on %s: -> [%s] (expected '%s'!)\n",
row, testTitles[n], loc, buf, expected);
}
}
}
}
}
/* testing uloc_getISO3Language(), uloc_getISO3Country(), */
static void TestSimpleResourceInfo() {
int32_t i;
char* testLocale = 0;
UChar* expected = 0;
const char* temp;
char temp2[20];
testLocale=(char*)malloc(sizeof(char) * 1);
expected=(UChar*)malloc(sizeof(UChar) * 1);
setUpDataTable();
log_verbose("Testing getISO3Language and getISO3Country\n");
for (i = 0; i < LOCALE_SIZE; i++) {
testLocale=(char*)realloc(testLocale, sizeof(char) * (u_strlen(dataTable[NAME][i])+1));
u_austrcpy(testLocale, dataTable[NAME][i]);
log_verbose("Testing %s ......\n", testLocale);
temp=uloc_getISO3Language(testLocale);
expected=(UChar*)realloc(expected, sizeof(UChar) * (strlen(temp) + 1));
u_uastrcpy(expected,temp);
if (0 != u_strcmp(expected, dataTable[LANG3][i])) {
log_err(" ISO-3 language code mismatch: %s versus %s\n", austrdup(expected),
austrdup(dataTable[LANG3][i]));
}
temp=uloc_getISO3Country(testLocale);
expected=(UChar*)realloc(expected, sizeof(UChar) * (strlen(temp) + 1));
u_uastrcpy(expected,temp);
if (0 != u_strcmp(expected, dataTable[CTRY3][i])) {
log_err(" ISO-3 Country code mismatch: %s versus %s\n", austrdup(expected),
austrdup(dataTable[CTRY3][i]));
}
sprintf(temp2, "%x", (int)uloc_getLCID(testLocale));
if (strcmp(temp2, rawData2[LCID][i]) != 0) {
log_err("LCID mismatch: %s versus %s\n", temp2 , rawData2[LCID][i]);
}
}
free(expected);
free(testLocale);
cleanUpDataTable();
}
/* if len < 0, we convert until we hit UChar 0x0000, which is not output. will add trailing null
* if there's room but won't be included in result. result < 0 indicates an error.
* Returns the number of chars written (not those that would be written if there's enough room.*/
static int32_t UCharsToEscapedAscii(const UChar* utext, int32_t len, char* resultChars, int32_t buflen) {
static const struct {
char escapedChar;
UChar sourceVal;
} ESCAPE_MAP[] = {
/*a*/ {'a', 0x07},
/*b*/ {'b', 0x08},
/*e*/ {'e', 0x1b},
/*f*/ {'f', 0x0c},
/*n*/ {'n', 0x0a},
/*r*/ {'r', 0x0d},
/*t*/ {'t', 0x09},
/*v*/ {'v', 0x0b}
};
static const int32_t ESCAPE_MAP_LENGTH = UPRV_LENGTHOF(ESCAPE_MAP);
static const char HEX_DIGITS[] = {
'0', '1', '2', '3', '4', '5', '6', '7',
'8', '9', 'a', 'b', 'c', 'd', 'e', 'f'
};
int32_t i, j;
int32_t resultLen = 0;
const int32_t limit = len<0 ? buflen : len; /* buflen is long enough to hit the buffer limit */
const int32_t escapeLimit1 = buflen-2;
const int32_t escapeLimit2 = buflen-6;
UChar uc;
if(utext==NULL || resultChars==NULL || buflen<0) {
return -1;
}
for(i=0;i<limit && resultLen<buflen;++i) {
uc=utext[i];
if(len<0 && uc==0) {
break;
}
if(uc<0x20) {
for(j=0;j<ESCAPE_MAP_LENGTH && uc!=ESCAPE_MAP[j].sourceVal;j++) {
}
if(j<ESCAPE_MAP_LENGTH) {
if(resultLen>escapeLimit1) {
break;
}
resultChars[resultLen++]='\\';
resultChars[resultLen++]=ESCAPE_MAP[j].escapedChar;
continue;
}
} else if(uc<0x7f) {
u_austrncpy(resultChars + resultLen, &uc, 1);
resultLen++;
continue;
}
if(resultLen>escapeLimit2) {
break;
}
/* have to escape the uchar */
resultChars[resultLen++]='\\';
resultChars[resultLen++]='u';
resultChars[resultLen++]=HEX_DIGITS[(uc>>12)&0xff];
resultChars[resultLen++]=HEX_DIGITS[(uc>>8)&0xff];
resultChars[resultLen++]=HEX_DIGITS[(uc>>4)&0xff];
resultChars[resultLen++]=HEX_DIGITS[uc&0xff];
}
if(resultLen<buflen) {
resultChars[resultLen] = 0;
}
return resultLen;
}
/*
* Jitterbug 2439 -- markus 20030425
*
* The lookup of display names must not fall back through the default
* locale because that yields useless results.
*/
static void TestDisplayNames()
{
UChar buffer[100];
UErrorCode errorCode=U_ZERO_ERROR;
int32_t length;
log_verbose("Testing getDisplayName for different locales\n");
log_verbose(" In locale = en_US...\n");
doTestDisplayNames("en_US", DLANG_EN);
log_verbose(" In locale = fr_FR....\n");
doTestDisplayNames("fr_FR", DLANG_FR);
log_verbose(" In locale = ca_ES...\n");
doTestDisplayNames("ca_ES", DLANG_CA);
log_verbose(" In locale = gr_EL..\n");
doTestDisplayNames("el_GR", DLANG_EL);
/* test that the default locale has a display name for its own language */
errorCode=U_ZERO_ERROR;
length=uloc_getDisplayLanguage(NULL, NULL, buffer, UPRV_LENGTHOF(buffer), &errorCode);
/* check <=3 to reject getting the language code as a display name */
if(U_FAILURE(errorCode) || (length<=3 && buffer[0]<=0x7f)) {
const char* defaultLocale = uloc_getDefault();
for (int32_t i = 0, count = uloc_countAvailable(); i < count; i++) {
/* Only report error if the default locale is in the available list */
if (uprv_strcmp(defaultLocale, uloc_getAvailable(i)) == 0) {
log_data_err(
"unable to get a display string for the language of the "
"default locale - %s (Are you missing data?)\n",
u_errorName(errorCode));
break;
}
}
}
/* test that we get the language code itself for an unknown language, and a default warning */
errorCode=U_ZERO_ERROR;
length=uloc_getDisplayLanguage("qq", "rr", buffer, UPRV_LENGTHOF(buffer), &errorCode);
if(errorCode!=U_USING_DEFAULT_WARNING || length!=2 || buffer[0]!=0x71 || buffer[1]!=0x71) {
log_err("error getting the display string for an unknown language - %s\n", u_errorName(errorCode));
}
/* test that we get a default warning for a display name where one component is unknown (4255) */
errorCode=U_ZERO_ERROR;
length=uloc_getDisplayName("qq_US_POSIX", "en_US", buffer, UPRV_LENGTHOF(buffer), &errorCode);
if(errorCode!=U_USING_DEFAULT_WARNING) {
log_err("error getting the display name for a locale with an unknown language - %s\n", u_errorName(errorCode));
}
{
int32_t i;
static const char *aLocale = "es@collation=traditional;calendar=japanese";
static const char *testL[] = { "en_US",
"fr_FR",
"ca_ES",
"el_GR" };
static const char *expect[] = { "Spanish (Calendar=Japanese Calendar, Sort Order=Traditional Sort Order)", /* note sorted order of keywords */
"espagnol (calendrier=calendrier japonais, ordre de tri=ordre traditionnel)",
"espanyol (calendari=calendari japon\\u00e8s, ordenaci\\u00f3=ordre tradicional)",
"\\u0399\\u03c3\\u03c0\\u03b1\\u03bd\\u03b9\\u03ba\\u03ac (\\u0397\\u03bc\\u03b5\\u03c1\\u03bf\\u03bb\\u03cc\\u03b3\\u03b9\\u03bf=\\u0399\\u03b1\\u03c0\\u03c9\\u03bd\\u03b9\\u03ba\\u03cc \\u03b7\\u03bc\\u03b5\\u03c1\\u03bf\\u03bb\\u03cc\\u03b3\\u03b9\\u03bf, \\u03a3\\u03b5\\u03b9\\u03c1\\u03ac \\u03c4\\u03b1\\u03be\\u03b9\\u03bd\\u03cc\\u03bc\\u03b7\\u03c3\\u03b7\\u03c2=\\u03a0\\u03b1\\u03c1\\u03b1\\u03b4\\u03bf\\u03c3\\u03b9\\u03b1\\u03ba\\u03ae \\u03c3\\u03b5\\u03b9\\u03c1\\u03ac \\u03c4\\u03b1\\u03be\\u03b9\\u03bd\\u03cc\\u03bc\\u03b7\\u03c3\\u03b7\\u03c2)" };
UChar *expectBuffer;
for(i=0;i<UPRV_LENGTHOF(testL);i++) {
errorCode = U_ZERO_ERROR;
uloc_getDisplayName(aLocale, testL[i], buffer, UPRV_LENGTHOF(buffer), &errorCode);
if(U_FAILURE(errorCode)) {
log_err("FAIL in uloc_getDisplayName(%s,%s,..) -> %s\n", aLocale, testL[i], u_errorName(errorCode));
} else {
expectBuffer = CharsToUChars(expect[i]);
if(u_strcmp(buffer,expectBuffer)) {
log_data_err("FAIL in uloc_getDisplayName(%s,%s,..) expected '%s' got '%s' (Are you missing data?)\n", aLocale, testL[i], expect[i], austrdup(buffer));
} else {
log_verbose("pass in uloc_getDisplayName(%s,%s,..) got '%s'\n", aLocale, testL[i], expect[i]);
}
free(expectBuffer);
}
}
}
/* test that we properly preflight and return data when there's a non-default pattern,
see ticket #8262. */
{
int32_t i;
static const char *locale="az_Cyrl";
static const char *displayLocale="ja";
static const char *expectedChars =
"\\u30a2\\u30bc\\u30eb\\u30d0\\u30a4\\u30b8\\u30e3\\u30f3\\u8a9e "
"(\\u30ad\\u30ea\\u30eb\\u6587\\u5b57)";
UErrorCode ec=U_ZERO_ERROR;
UChar result[256];
int32_t len;
int32_t preflightLen=uloc_getDisplayName(locale, displayLocale, NULL, 0, &ec);
/* inconvenient semantics when preflighting, this condition is expected... */
if(ec==U_BUFFER_OVERFLOW_ERROR) {
ec=U_ZERO_ERROR;
}
len=uloc_getDisplayName(locale, displayLocale, result, UPRV_LENGTHOF(result), &ec);
if(U_FAILURE(ec)) {
log_err("uloc_getDisplayName(%s, %s...) returned error: %s",
locale, displayLocale, u_errorName(ec));
} else {
UChar *expected=CharsToUChars(expectedChars);
int32_t expectedLen=u_strlen(expected);
if(len!=expectedLen) {
log_data_err("uloc_getDisplayName(%s, %s...) returned string of length %d, expected length %d",
locale, displayLocale, len, expectedLen);
} else if(preflightLen!=expectedLen) {
log_err("uloc_getDisplayName(%s, %s...) returned preflight length %d, expected length %d",
locale, displayLocale, preflightLen, expectedLen);
} else if(u_strncmp(result, expected, len)) {
int32_t cap=len*6+1; /* worst case + space for trailing null */
char* resultChars=(char*)malloc(cap);
int32_t resultCharsLen=UCharsToEscapedAscii(result, len, resultChars, cap);
if(resultCharsLen<0 || resultCharsLen<cap-1) {
log_err("uloc_getDisplayName(%s, %s...) mismatch", locale, displayLocale);
} else {
log_err("uloc_getDisplayName(%s, %s...) returned '%s' but expected '%s'",
locale, displayLocale, resultChars, expectedChars);
}
free(resultChars);
resultChars=NULL;
} else {
/* test all buffer sizes */
for(i=len+1;i>=0;--i) {
len=uloc_getDisplayName(locale, displayLocale, result, i, &ec);
if(ec==U_BUFFER_OVERFLOW_ERROR) {
ec=U_ZERO_ERROR;
}
if(U_FAILURE(ec)) {
log_err("using buffer of length %d returned error %s", i, u_errorName(ec));
break;
}
if(len!=expectedLen) {
log_err("with buffer of length %d, expected length %d but got %d", i, expectedLen, len);
break;
}
/* There's no guarantee about what's in the buffer if we've overflowed, in particular,
* we don't know that it's been filled, so no point in checking. */
}
}
free(expected);
}
}
}
/**
* ICU-21160 test the pre-flighting call to uloc_getDisplayScript returns the actual length needed
* for the result buffer.
*/
static void TestGetDisplayScriptPreFlighting21160()
{
const char* locale = "und-Latn";
const char* inlocale = "de";
UErrorCode ec = U_ZERO_ERROR;
UChar* result = NULL;
int32_t length = uloc_getDisplayScript(locale, inlocale, NULL, 0, &ec) + 1;
ec = U_ZERO_ERROR;
result=(UChar*)malloc(sizeof(UChar) * length);
length = uloc_getDisplayScript(locale, inlocale, result, length, &ec);
if (U_FAILURE(ec)) {
log_err("uloc_getDisplayScript length %d returned error %s", length, u_errorName(ec));
}
free(result);
}
/* test for uloc_getAvialable() and uloc_countAvilable()*/
static void TestGetAvailableLocales()
{
const char *locList;
int32_t locCount,i;
log_verbose("Testing the no of avialable locales\n");
locCount=uloc_countAvailable();
if (locCount == 0)
log_data_err("countAvailable() returned an empty list!\n");
/* use something sensible w/o hardcoding the count */
else if(locCount < 0){
log_data_err("countAvailable() returned a wrong value!= %d\n", locCount);
}
else{
log_info("Number of locales returned = %d\n", locCount);
}
for(i=0;i<locCount;i++){
locList=uloc_getAvailable(i);
log_verbose(" %s\n", locList);
}
}
static void TestGetAvailableLocalesByType() {
UErrorCode status = U_ZERO_ERROR;
UEnumeration* uenum = uloc_openAvailableByType(ULOC_AVAILABLE_DEFAULT, &status);
assertSuccess("Constructing the UEnumeration", &status);
assertIntEquals("countAvailable() should be same in old and new methods",
uloc_countAvailable(),
uenum_count(uenum, &status));
for (int32_t i = 0; i < uloc_countAvailable(); i++) {
const char* old = uloc_getAvailable(i);
int32_t len = 0;
const char* new = uenum_next(uenum, &len, &status);
assertEquals("Old and new strings should equal", old, new);
assertIntEquals("String length should be correct", uprv_strlen(old), len);
}
assertPtrEquals("Should get nullptr on the last string",
NULL, uenum_next(uenum, NULL, &status));
uenum_close(uenum);
uenum = uloc_openAvailableByType(ULOC_AVAILABLE_ONLY_LEGACY_ALIASES, &status);
UBool found_he = FALSE;
UBool found_iw = FALSE;
const char* loc;
while ((loc = uenum_next(uenum, NULL, &status))) {
if (uprv_strcmp("he", loc) == 0) {
found_he = TRUE;
}
if (uprv_strcmp("iw", loc) == 0) {
found_iw = TRUE;
}
}
assertTrue("Should NOT have found he amongst the legacy/alias locales", !found_he);
assertTrue("Should have found iw amongst the legacy/alias locales", found_iw);
uenum_close(uenum);
uenum = uloc_openAvailableByType(ULOC_AVAILABLE_WITH_LEGACY_ALIASES, &status);
found_he = FALSE;
found_iw = FALSE;
const UChar* uloc; // test the UChar conversion
int32_t count = 0;
while ((uloc = uenum_unext(uenum, NULL, &status))) {
if (u_strcmp(u"iw", uloc) == 0) {
found_iw = TRUE;
}
if (u_strcmp(u"he", uloc) == 0) {
found_he = TRUE;
}
count++;
}
assertTrue("Should have found he amongst all locales", found_he);
assertTrue("Should have found iw amongst all locales", found_iw);
assertIntEquals("Should return as many strings as claimed",
count, uenum_count(uenum, &status));
// Reset the enumeration and it should still work
uenum_reset(uenum, &status);
count = 0;
while ((loc = uenum_next(uenum, NULL, &status))) {
count++;
}
assertIntEquals("After reset, should return as many strings as claimed",
count, uenum_count(uenum, &status));
uenum_close(uenum);
assertSuccess("No errors should have occurred", &status);
}
/* test for u_getDataDirectory, u_setDataDirectory, uloc_getISO3Language */
static void TestDataDirectory()
{
char oldDirectory[512];
const char *temp,*testValue1,*testValue2,*testValue3;
const char path[40] ="d:\\icu\\source\\test\\intltest" U_FILE_SEP_STRING; /*give the required path */
log_verbose("Testing getDataDirectory()\n");
temp = u_getDataDirectory();
strcpy(oldDirectory, temp);
testValue1=uloc_getISO3Language("en_US");
log_verbose("first fetch of language retrieved %s\n", testValue1);
if (0 != strcmp(testValue1,"eng")){
log_err("Initial check of ISO3 language failed: expected \"eng\", got %s \n", testValue1);
}
/*defining the path for DataDirectory */
log_verbose("Testing setDataDirectory\n");
u_setDataDirectory( path );
if(strcmp(path, u_getDataDirectory())==0)
log_verbose("setDataDirectory working fine\n");
else
log_err("Error in setDataDirectory. Directory not set correctly - came back as [%s], expected [%s]\n", u_getDataDirectory(), path);
testValue2=uloc_getISO3Language("en_US");
log_verbose("second fetch of language retrieved %s \n", testValue2);
u_setDataDirectory(oldDirectory);
testValue3=uloc_getISO3Language("en_US");
log_verbose("third fetch of language retrieved %s \n", testValue3);
if (0 != strcmp(testValue3,"eng")) {
log_err("get/setDataDirectory() failed: expected \"eng\", got \" %s \" \n", testValue3);
}
}
/*=========================================================== */
static UChar _NUL=0;
static void doTestDisplayNames(const char* displayLocale, int32_t compareIndex)
{
UErrorCode status = U_ZERO_ERROR;
int32_t i;
int32_t maxresultsize;
const char *testLocale;
UChar *testLang = 0;
UChar *testScript = 0;
UChar *testCtry = 0;
UChar *testVar = 0;
UChar *testName = 0;
UChar* expectedLang = 0;
UChar* expectedScript = 0;
UChar* expectedCtry = 0;
UChar* expectedVar = 0;
UChar* expectedName = 0;
setUpDataTable();
for(i=0;i<LOCALE_SIZE; ++i)
{
testLocale=rawData2[NAME][i];
log_verbose("Testing..... %s\n", testLocale);
maxresultsize=0;
maxresultsize=uloc_getDisplayLanguage(testLocale, displayLocale, NULL, maxresultsize, &status);
if(status==U_BUFFER_OVERFLOW_ERROR)
{
status=U_ZERO_ERROR;
testLang=(UChar*)malloc(sizeof(UChar) * (maxresultsize+1));
uloc_getDisplayLanguage(testLocale, displayLocale, testLang, maxresultsize + 1, &status);
}
else
{
testLang=&_NUL;
}
if(U_FAILURE(status)){
log_err("Error in getDisplayLanguage() %s\n", myErrorName(status));
}
maxresultsize=0;
maxresultsize=uloc_getDisplayScript(testLocale, displayLocale, NULL, maxresultsize, &status);
if(status==U_BUFFER_OVERFLOW_ERROR)
{
status=U_ZERO_ERROR;
testScript=(UChar*)malloc(sizeof(UChar) * (maxresultsize+1));
uloc_getDisplayScript(testLocale, displayLocale, testScript, maxresultsize + 1, &status);
}
else
{
testScript=&_NUL;
}
if(U_FAILURE(status)){
log_err("Error in getDisplayScript() %s\n", myErrorName(status));
}
maxresultsize=0;
maxresultsize=uloc_getDisplayCountry(testLocale, displayLocale, NULL, maxresultsize, &status);
if(status==U_BUFFER_OVERFLOW_ERROR)
{
status=U_ZERO_ERROR;
testCtry=(UChar*)malloc(sizeof(UChar) * (maxresultsize+1));
uloc_getDisplayCountry(testLocale, displayLocale, testCtry, maxresultsize + 1, &status);
}
else
{
testCtry=&_NUL;
}
if(U_FAILURE(status)){
log_err("Error in getDisplayCountry() %s\n", myErrorName(status));
}
maxresultsize=0;
maxresultsize=uloc_getDisplayVariant(testLocale, displayLocale, NULL, maxresultsize, &status);
if(status==U_BUFFER_OVERFLOW_ERROR)
{
status=U_ZERO_ERROR;
testVar=(UChar*)malloc(sizeof(UChar) * (maxresultsize+1));
uloc_getDisplayVariant(testLocale, displayLocale, testVar, maxresultsize + 1, &status);
}
else
{
testVar=&_NUL;
}
if(U_FAILURE(status)){
log_err("Error in getDisplayVariant() %s\n", myErrorName(status));
}
maxresultsize=0;
maxresultsize=uloc_getDisplayName(testLocale, displayLocale, NULL, maxresultsize, &status);
if(status==U_BUFFER_OVERFLOW_ERROR)
{
status=U_ZERO_ERROR;
testName=(UChar*)malloc(sizeof(UChar) * (maxresultsize+1));
uloc_getDisplayName(testLocale, displayLocale, testName, maxresultsize + 1, &status);
}
else
{
testName=&_NUL;
}
if(U_FAILURE(status)){
log_err("Error in getDisplayName() %s\n", myErrorName(status));
}
expectedLang=dataTable[compareIndex][i];
if(u_strlen(expectedLang)== 0)
expectedLang=dataTable[DLANG_EN][i];
expectedScript=dataTable[compareIndex + 1][i];
if(u_strlen(expectedScript)== 0)
expectedScript=dataTable[DSCRIPT_EN][i];
expectedCtry=dataTable[compareIndex + 2][i];
if(u_strlen(expectedCtry)== 0)
expectedCtry=dataTable[DCTRY_EN][i];
expectedVar=dataTable[compareIndex + 3][i];
if(u_strlen(expectedVar)== 0)
expectedVar=dataTable[DVAR_EN][i];
expectedName=dataTable[compareIndex + 4][i];
if(u_strlen(expectedName) == 0)
expectedName=dataTable[DNAME_EN][i];
if (0 !=u_strcmp(testLang,expectedLang)) {
log_data_err(" Display Language mismatch: got %s expected %s displayLocale=%s (Are you missing data?)\n", austrdup(testLang), austrdup(expectedLang), displayLocale);
}
if (0 != u_strcmp(testScript,expectedScript)) {
log_data_err(" Display Script mismatch: got %s expected %s displayLocale=%s (Are you missing data?)\n", austrdup(testScript), austrdup(expectedScript), displayLocale);
}
if (0 != u_strcmp(testCtry,expectedCtry)) {
log_data_err(" Display Country mismatch: got %s expected %s displayLocale=%s (Are you missing data?)\n", austrdup(testCtry), austrdup(expectedCtry), displayLocale);
}
if (0 != u_strcmp(testVar,expectedVar)) {
log_data_err(" Display Variant mismatch: got %s expected %s displayLocale=%s (Are you missing data?)\n", austrdup(testVar), austrdup(expectedVar), displayLocale);
}
if(0 != u_strcmp(testName, expectedName)) {
log_data_err(" Display Name mismatch: got %s expected %s displayLocale=%s (Are you missing data?)\n", austrdup(testName), austrdup(expectedName), displayLocale);
}
if(testName!=&_NUL) {
free(testName);
}
if(testLang!=&_NUL) {
free(testLang);
}
if(testScript!=&_NUL) {
free(testScript);
}
if(testCtry!=&_NUL) {
free(testCtry);
}
if(testVar!=&_NUL) {
free(testVar);
}
}
cleanUpDataTable();
}
/*------------------------------
* TestDisplayNameBrackets
*/
typedef struct {
const char * displayLocale;
const char * namedRegion;
const char * namedLocale;
const char * regionName;
const char * localeName;
} DisplayNameBracketsItem;
static const DisplayNameBracketsItem displayNameBracketsItems[] = {
{ "en", "CC", "en_CC", "Cocos (Keeling) Islands", "English (Cocos [Keeling] Islands)" },
{ "en", "MM", "my_MM", "Myanmar (Burma)", "Burmese (Myanmar [Burma])" },
{ "en", "MM", "my_Mymr_MM", "Myanmar (Burma)", "Burmese (Myanmar, Myanmar [Burma])" },
{ "zh", "CC", "en_CC", "\\u79D1\\u79D1\\u65AF\\uFF08\\u57FA\\u6797\\uFF09\\u7FA4\\u5C9B", "\\u82F1\\u8BED\\uFF08\\u79D1\\u79D1\\u65AF\\uFF3B\\u57FA\\u6797\\uFF3D\\u7FA4\\u5C9B\\uFF09" },
{ "zh", "CG", "fr_CG", "\\u521A\\u679C\\uFF08\\u5E03\\uFF09", "\\u6CD5\\u8BED\\uFF08\\u521A\\u679C\\uFF3B\\u5E03\\uFF3D\\uFF09" },
{ NULL, NULL, NULL, NULL, NULL }
};
enum { kDisplayNameBracketsMax = 128 };
static void TestDisplayNameBrackets()
{
const DisplayNameBracketsItem * itemPtr = displayNameBracketsItems;
for (; itemPtr->displayLocale != NULL; itemPtr++) {
ULocaleDisplayNames * uldn;
UErrorCode status;
UChar expectRegionName[kDisplayNameBracketsMax];
UChar expectLocaleName[kDisplayNameBracketsMax];
UChar getName[kDisplayNameBracketsMax];
int32_t ulen;
(void) u_unescape(itemPtr->regionName, expectRegionName, kDisplayNameBracketsMax);
(void) u_unescape(itemPtr->localeName, expectLocaleName, kDisplayNameBracketsMax);
status = U_ZERO_ERROR;
ulen = uloc_getDisplayCountry(itemPtr->namedLocale, itemPtr->displayLocale, getName, kDisplayNameBracketsMax, &status);
if ( U_FAILURE(status) || u_strcmp(getName, expectRegionName) != 0 ) {
log_data_err("uloc_getDisplayCountry for displayLocale %s and namedLocale %s returns unexpected name or status %s\n", itemPtr->displayLocale, itemPtr->namedLocale, myErrorName(status));
}
status = U_ZERO_ERROR;
ulen = uloc_getDisplayName(itemPtr->namedLocale, itemPtr->displayLocale, getName, kDisplayNameBracketsMax, &status);
if ( U_FAILURE(status) || u_strcmp(getName, expectLocaleName) != 0 ) {
log_data_err("uloc_getDisplayName for displayLocale %s and namedLocale %s returns unexpected name or status %s\n", itemPtr->displayLocale, itemPtr->namedLocale, myErrorName(status));
}
#if !UCONFIG_NO_FORMATTING
status = U_ZERO_ERROR;
uldn = uldn_open(itemPtr->displayLocale, ULDN_STANDARD_NAMES, &status);
if (U_SUCCESS(status)) {
status = U_ZERO_ERROR;
ulen = uldn_regionDisplayName(uldn, itemPtr->namedRegion, getName, kDisplayNameBracketsMax, &status);
if ( U_FAILURE(status) || u_strcmp(getName, expectRegionName) != 0 ) {
log_data_err("uldn_regionDisplayName for displayLocale %s and namedRegion %s returns unexpected name or status %s\n", itemPtr->displayLocale, itemPtr->namedRegion, myErrorName(status));
}
status = U_ZERO_ERROR;
ulen = uldn_localeDisplayName(uldn, itemPtr->namedLocale, getName, kDisplayNameBracketsMax, &status);
if ( U_FAILURE(status) || u_strcmp(getName, expectLocaleName) != 0 ) {
log_data_err("uldn_localeDisplayName for displayLocale %s and namedLocale %s returns unexpected name or status %s\n", itemPtr->displayLocale, itemPtr->namedLocale, myErrorName(status));
}
uldn_close(uldn);
} else {
log_data_err("uldn_open fails for displayLocale %s, status=%s\n", itemPtr->displayLocale, u_errorName(status));
}
#endif
(void)ulen; /* Suppress variable not used warning */
}
}
/*------------------------------
* TestIllegalArgumentWhenNoDataWithNoSubstitute
*/
static void TestIllegalArgumentWhenNoDataWithNoSubstitute()
{
#if !UCONFIG_NO_FORMATTING
UErrorCode status = U_ZERO_ERROR;
UChar getName[kDisplayNameBracketsMax];
UDisplayContext contexts[] = {
UDISPCTX_NO_SUBSTITUTE,
};
ULocaleDisplayNames* ldn = uldn_openForContext("en", contexts, 1, &status);
uldn_localeDisplayName(ldn, "efg", getName, kDisplayNameBracketsMax, &status);
if (status != U_ILLEGAL_ARGUMENT_ERROR) {
log_err("FAIL uldn_localeDisplayName should return U_ILLEGAL_ARGUMENT_ERROR "
"while no resource under UDISPCTX_NO_SUBSTITUTE");
}
status = U_ZERO_ERROR;
uldn_languageDisplayName(ldn, "zz", getName, kDisplayNameBracketsMax, &status);
if (status != U_ILLEGAL_ARGUMENT_ERROR) {
log_err("FAIL uldn_languageDisplayName should return U_ILLEGAL_ARGUMENT_ERROR "
"while no resource under UDISPCTX_NO_SUBSTITUTE");
}
status = U_ZERO_ERROR;
uldn_scriptDisplayName(ldn, "Aaaa", getName, kDisplayNameBracketsMax, &status);
if (status != U_ILLEGAL_ARGUMENT_ERROR) {
log_err("FAIL uldn_scriptDisplayName should return U_ILLEGAL_ARGUMENT_ERROR "
"while no resource under UDISPCTX_NO_SUBSTITUTE");
}
status = U_ZERO_ERROR;
uldn_regionDisplayName(ldn, "KK", getName, kDisplayNameBracketsMax, &status);
if (status != U_ILLEGAL_ARGUMENT_ERROR) {
log_err("FAIL uldn_regionDisplayName should return U_ILLEGAL_ARGUMENT_ERROR "
"while no resource under UDISPCTX_NO_SUBSTITUTE");
}
status = U_ZERO_ERROR;
uldn_variantDisplayName(ldn, "ZZ", getName, kDisplayNameBracketsMax, &status);
if (status != U_ILLEGAL_ARGUMENT_ERROR) {
log_err("FAIL uldn_variantDisplayName should return U_ILLEGAL_ARGUMENT_ERROR "
"while no resource under UDISPCTX_NO_SUBSTITUTE");
}
status = U_ZERO_ERROR;
uldn_keyDisplayName(ldn, "zz", getName, kDisplayNameBracketsMax, &status);
if (status != U_ILLEGAL_ARGUMENT_ERROR) {
log_err("FAIL uldn_keyDisplayName should return U_ILLEGAL_ARGUMENT_ERROR "
"while no resource under UDISPCTX_NO_SUBSTITUTE");
}
status = U_ZERO_ERROR;
uldn_keyValueDisplayName(ldn, "ca", "zz", getName, kDisplayNameBracketsMax, &status);
if (status != U_ILLEGAL_ARGUMENT_ERROR) {
log_err("FAIL uldn_keyValueDisplayName should return U_ILLEGAL_ARGUMENT_ERROR "
"while no resource under UDISPCTX_NO_SUBSTITUTE");
}
uldn_close(ldn);
#endif
}
/*------------------------------
* TestISOFunctions
*/
#if !UCONFIG_NO_FILE_IO && !UCONFIG_NO_LEGACY_CONVERSION
/* test for uloc_getISOLanguages, uloc_getISOCountries */
static void TestISOFunctions()
{
const char* const* str=uloc_getISOLanguages();
const char* const* str1=uloc_getISOCountries();
const char* test;
const char *key = NULL;
int32_t count = 0, skipped = 0;
int32_t expect;
UResourceBundle *res;
UResourceBundle *subRes;
UErrorCode status = U_ZERO_ERROR;
/* test getISOLanguages*/
/*str=uloc_getISOLanguages(); */
log_verbose("Testing ISO Languages: \n");
/* use structLocale - this data is no longer in root */
res = ures_openDirect(loadTestData(&status), "structLocale", &status);
subRes = ures_getByKey(res, "Languages", NULL, &status);
if (U_FAILURE(status)) {
log_data_err("There is an error in structLocale's ures_getByKey(\"Languages\"), status=%s\n", u_errorName(status));
return;
}
expect = ures_getSize(subRes);
for(count = 0; *(str+count) != 0; count++)
{
key = NULL;
test = *(str+count);
status = U_ZERO_ERROR;
do {
/* Skip over language tags. This API only returns language codes. */
skipped += (key != NULL);
ures_getNextString(subRes, NULL, &key, &status);
}
while (key != NULL && strchr(key, '_'));
if(key == NULL)
break;
/* TODO: Consider removing sh, which is deprecated */
if(strcmp(key,"root") == 0 || strcmp(key,"Fallback") == 0 || strcmp(key,"sh") == 0) {
ures_getNextString(subRes, NULL, &key, &status);
skipped++;
}
#if U_CHARSET_FAMILY==U_ASCII_FAMILY
/* This code only works on ASCII machines where the keys are stored in ASCII order */
if(strcmp(test,key)) {
/* The first difference usually implies the place where things get out of sync */
log_err("FAIL Language diff at offset %d, \"%s\" != \"%s\"\n", count, test, key);
}
#endif
if(!strcmp(test,"in"))
log_err("FAIL getISOLanguages() has obsolete language code %s\n", test);
if(!strcmp(test,"iw"))
log_err("FAIL getISOLanguages() has obsolete language code %s\n", test);
if(!strcmp(test,"ji"))
log_err("FAIL getISOLanguages() has obsolete language code %s\n", test);
if(!strcmp(test,"jw"))
log_err("FAIL getISOLanguages() has obsolete language code %s\n", test);
if(!strcmp(test,"sh"))
log_err("FAIL getISOLanguages() has obsolete language code %s\n", test);
}
expect -= skipped; /* Ignore the skipped resources from structLocale */
if(count!=expect) {
log_err("There is an error in getISOLanguages, got %d, expected %d (as per structLocale)\n", count, expect);
}
subRes = ures_getByKey(res, "Countries", subRes, &status);
log_verbose("Testing ISO Countries");
skipped = 0;
expect = ures_getSize(subRes) - 1; /* Skip ZZ */
for(count = 0; *(str1+count) != 0; count++)
{
key = NULL;
test = *(str1+count);
do {
/* Skip over numeric UN tags. This API only returns ISO-3166 codes. */
skipped += (key != NULL);
ures_getNextString(subRes, NULL, &key, &status);
}
while (key != NULL && strlen(key) != 2);
if(key == NULL)
break;
/* TODO: Consider removing CS, which is deprecated */
while(strcmp(key,"QO") == 0 || strcmp(key,"QU") == 0 || strcmp(key,"CS") == 0) {
ures_getNextString(subRes, NULL, &key, &status);
skipped++;
}
#if U_CHARSET_FAMILY==U_ASCII_FAMILY
/* This code only works on ASCII machines where the keys are stored in ASCII order */
if(strcmp(test,key)) {
/* The first difference usually implies the place where things get out of sync */
log_err("FAIL Country diff at offset %d, \"%s\" != \"%s\"\n", count, test, key);
}
#endif
if(!strcmp(test,"FX"))
log_err("FAIL getISOCountries() has obsolete country code %s\n", test);
if(!strcmp(test,"YU"))
log_err("FAIL getISOCountries() has obsolete country code %s\n", test);
if(!strcmp(test,"ZR"))
log_err("FAIL getISOCountries() has obsolete country code %s\n", test);
}
ures_getNextString(subRes, NULL, &key, &status);
if (strcmp(key, "ZZ") != 0) {
log_err("ZZ was expected to be the last entry in structLocale, but got %s\n", key);
}
#if U_CHARSET_FAMILY==U_EBCDIC_FAMILY
/* On EBCDIC machines, the numbers are sorted last. Account for those in the skipped value too. */
key = NULL;
do {
/* Skip over numeric UN tags. uloc_getISOCountries only returns ISO-3166 codes. */
skipped += (key != NULL);
ures_getNextString(subRes, NULL, &key, &status);
}
while (U_SUCCESS(status) && key != NULL && strlen(key) != 2);
#endif
expect -= skipped; /* Ignore the skipped resources from structLocale */
if(count!=expect)
{
log_err("There is an error in getISOCountries, got %d, expected %d \n", count, expect);
}
ures_close(subRes);
ures_close(res);
}
#endif
static void setUpDataTable()
{
int32_t i,j;
dataTable = (UChar***)(calloc(sizeof(UChar**),LOCALE_INFO_SIZE));
for (i = 0; i < LOCALE_INFO_SIZE; i++) {
dataTable[i] = (UChar**)(calloc(sizeof(UChar*),LOCALE_SIZE));
for (j = 0; j < LOCALE_SIZE; j++){
dataTable[i][j] = CharsToUChars(rawData2[i][j]);
}
}
}
static void cleanUpDataTable()
{
int32_t i,j;
if(dataTable != NULL) {
for (i=0; i<LOCALE_INFO_SIZE; i++) {
for(j = 0; j < LOCALE_SIZE; j++) {
free(dataTable[i][j]);
}
free(dataTable[i]);
}
free(dataTable);
}
dataTable = NULL;
}
/**
* @bug 4011756 4011380
*/
static void TestISO3Fallback()
{
const char* test="xx_YY";
const char * result;
result = uloc_getISO3Language(test);
/* Conform to C API usage */
if (!result || (result[0] != 0))
log_err("getISO3Language() on xx_YY returned %s instead of \"\"");
result = uloc_getISO3Country(test);
if (!result || (result[0] != 0))
log_err("getISO3Country() on xx_YY returned %s instead of \"\"");
}
/**
* @bug 4118587
*/
static void TestSimpleDisplayNames()
{
/*
This test is different from TestDisplayNames because TestDisplayNames checks
fallback behavior, combination of language and country names to form locale
names, and other stuff like that. This test just checks specific language
and country codes to make sure we have the correct names for them.
*/
char languageCodes[] [4] = { "he", "id", "iu", "ug", "yi", "za", "419" };
const char* languageNames [] = { "Hebrew", "Indonesian", "Inuktitut", "Uyghur", "Yiddish",
"Zhuang", "419" };
const char* inLocale [] = { "en_US", "zh_Hant"};
UErrorCode status=U_ZERO_ERROR;
int32_t i;
int32_t localeIndex = 0;
for (i = 0; i < 7; i++) {
UChar *testLang=0;
UChar *expectedLang=0;
int size=0;
if (i == 6) {
localeIndex = 1; /* Use the second locale for the rest of the test. */
}
size=uloc_getDisplayLanguage(languageCodes[i], inLocale[localeIndex], NULL, size, &status);
if(status==U_BUFFER_OVERFLOW_ERROR) {
status=U_ZERO_ERROR;
testLang=(UChar*)malloc(sizeof(UChar) * (size + 1));
uloc_getDisplayLanguage(languageCodes[i], inLocale[localeIndex], testLang, size + 1, &status);
}
expectedLang=(UChar*)malloc(sizeof(UChar) * (strlen(languageNames[i])+1));
u_uastrcpy(expectedLang, languageNames[i]);
if (u_strcmp(testLang, expectedLang) != 0)
log_data_err("Got wrong display name for %s : Expected \"%s\", got \"%s\".\n",
languageCodes[i], languageNames[i], austrdup(testLang));
free(testLang);
free(expectedLang);
}
}
/**
* @bug 4118595
*/
static void TestUninstalledISO3Names()
{
/* This test checks to make sure getISO3Language and getISO3Country work right
even for locales that are not installed. */
static const char iso2Languages [][4] = { "am", "ba", "fy", "mr", "rn",
"ss", "tw", "zu" };
static const char iso3Languages [][5] = { "amh", "bak", "fry", "mar", "run",
"ssw", "twi", "zul" };
static const char iso2Countries [][6] = { "am_AF", "ba_BW", "fy_KZ", "mr_MO", "rn_MN",
"ss_SB", "tw_TC", "zu_ZW" };
static const char iso3Countries [][4] = { "AFG", "BWA", "KAZ", "MAC", "MNG",
"SLB", "TCA", "ZWE" };
int32_t i;
for (i = 0; i < 8; i++) {
UErrorCode err = U_ZERO_ERROR;
const char *test;
test = uloc_getISO3Language(iso2Languages[i]);
if(strcmp(test, iso3Languages[i]) !=0 || U_FAILURE(err))
log_err("Got wrong ISO3 code for %s : Expected \"%s\", got \"%s\". %s\n",
iso2Languages[i], iso3Languages[i], test, myErrorName(err));
}
for (i = 0; i < 8; i++) {
UErrorCode err = U_ZERO_ERROR;
const char *test;
test = uloc_getISO3Country(iso2Countries[i]);
if(strcmp(test, iso3Countries[i]) !=0 || U_FAILURE(err))
log_err("Got wrong ISO3 code for %s : Expected \"%s\", got \"%s\". %s\n",
iso2Countries[i], iso3Countries[i], test, myErrorName(err));
}
}
static void TestVariantParsing()
{
static const char* en_US_custom="en_US_De Anza_Cupertino_California_United States_Earth";
static const char* dispName="English (United States, DE ANZA_CUPERTINO_CALIFORNIA_UNITED STATES_EARTH)";
static const char* dispVar="DE ANZA_CUPERTINO_CALIFORNIA_UNITED STATES_EARTH";
static const char* shortVariant="fr_FR_foo";
static const char* bogusVariant="fr_FR__foo";
static const char* bogusVariant2="fr_FR_foo_";
static const char* bogusVariant3="fr_FR__foo_";
UChar displayVar[100];
UChar displayName[100];
UErrorCode status=U_ZERO_ERROR;
UChar* got=0;
int32_t size=0;
size=uloc_getDisplayVariant(en_US_custom, "en_US", NULL, size, &status);
if(status==U_BUFFER_OVERFLOW_ERROR) {
status=U_ZERO_ERROR;
got=(UChar*)realloc(got, sizeof(UChar) * (size+1));
uloc_getDisplayVariant(en_US_custom, "en_US", got, size + 1, &status);
}
else {
log_err("FAIL: Didn't get U_BUFFER_OVERFLOW_ERROR\n");
}
u_uastrcpy(displayVar, dispVar);
if(u_strcmp(got,displayVar)!=0) {
log_err("FAIL: getDisplayVariant() Wanted %s, got %s\n", dispVar, austrdup(got));
}
size=0;
size=uloc_getDisplayName(en_US_custom, "en_US", NULL, size, &status);
if(status==U_BUFFER_OVERFLOW_ERROR) {
status=U_ZERO_ERROR;
got=(UChar*)realloc(got, sizeof(UChar) * (size+1));
uloc_getDisplayName(en_US_custom, "en_US", got, size + 1, &status);
}
else {
log_err("FAIL: Didn't get U_BUFFER_OVERFLOW_ERROR\n");
}
u_uastrcpy(displayName, dispName);
if(u_strcmp(got,displayName)!=0) {
if (status == U_USING_DEFAULT_WARNING) {
log_data_err("FAIL: getDisplayName() got %s. Perhaps you are missing data?\n", u_errorName(status));
} else {
log_err("FAIL: getDisplayName() Wanted %s, got %s\n", dispName, austrdup(got));
}
}
size=0;
status=U_ZERO_ERROR;
size=uloc_getDisplayVariant(shortVariant, NULL, NULL, size, &status);
if(status==U_BUFFER_OVERFLOW_ERROR) {
status=U_ZERO_ERROR;
got=(UChar*)realloc(got, sizeof(UChar) * (size+1));
uloc_getDisplayVariant(shortVariant, NULL, got, size + 1, &status);
}
else {
log_err("FAIL: Didn't get U_BUFFER_OVERFLOW_ERROR\n");
}
if(strcmp(austrdup(got),"FOO")!=0) {
log_err("FAIL: getDisplayVariant() Wanted: foo Got: %s\n", austrdup(got));
}
size=0;
status=U_ZERO_ERROR;
size=uloc_getDisplayVariant(bogusVariant, NULL, NULL, size, &status);
if(status==U_BUFFER_OVERFLOW_ERROR) {
status=U_ZERO_ERROR;
got=(UChar*)realloc(got, sizeof(UChar) * (size+1));
uloc_getDisplayVariant(bogusVariant, NULL, got, size + 1, &status);
}
else {
log_err("FAIL: Didn't get U_BUFFER_OVERFLOW_ERROR\n");
}
if(strcmp(austrdup(got),"_FOO")!=0) {
log_err("FAIL: getDisplayVariant() Wanted: _FOO Got: %s\n", austrdup(got));
}
size=0;
status=U_ZERO_ERROR;
size=uloc_getDisplayVariant(bogusVariant2, NULL, NULL, size, &status);
if(status==U_BUFFER_OVERFLOW_ERROR) {
status=U_ZERO_ERROR;
got=(UChar*)realloc(got, sizeof(UChar) * (size+1));
uloc_getDisplayVariant(bogusVariant2, NULL, got, size + 1, &status);
}
else {
log_err("FAIL: Didn't get U_BUFFER_OVERFLOW_ERROR\n");
}
if(strcmp(austrdup(got),"FOO_")!=0) {
log_err("FAIL: getDisplayVariant() Wanted: FOO_ Got: %s\n", austrdup(got));
}
size=0;
status=U_ZERO_ERROR;
size=uloc_getDisplayVariant(bogusVariant3, NULL, NULL, size, &status);
if(status==U_BUFFER_OVERFLOW_ERROR) {
status=U_ZERO_ERROR;
got=(UChar*)realloc(got, sizeof(UChar) * (size+1));
uloc_getDisplayVariant(bogusVariant3, NULL, got, size + 1, &status);
}
else {
log_err("FAIL: Didn't get U_BUFFER_OVERFLOW_ERROR\n");
}
if(strcmp(austrdup(got),"_FOO_")!=0) {
log_err("FAIL: getDisplayVariant() Wanted: _FOO_ Got: %s\n", austrdup(got));
}
free(got);
}
static void TestObsoleteNames(void)
{
int32_t i;
UErrorCode status = U_ZERO_ERROR;
char buff[256];
static const struct
{
char locale[9];
char lang3[4];
char lang[4];
char ctry3[4];
char ctry[4];
} tests[] =
{
{ "eng_USA", "eng", "en", "USA", "US" },
{ "kok", "kok", "kok", "", "" },
{ "in", "ind", "in", "", "" },
{ "id", "ind", "id", "", "" }, /* NO aliasing */
{ "sh", "srp", "sh", "", "" },
{ "zz_CS", "", "zz", "SCG", "CS" },
{ "zz_FX", "", "zz", "FXX", "FX" },
{ "zz_RO", "", "zz", "ROU", "RO" },
{ "zz_TP", "", "zz", "TMP", "TP" },
{ "zz_TL", "", "zz", "TLS", "TL" },
{ "zz_ZR", "", "zz", "ZAR", "ZR" },
{ "zz_FXX", "", "zz", "FXX", "FX" }, /* no aliasing. Doesn't go to PS(PSE). */
{ "zz_ROM", "", "zz", "ROU", "RO" },
{ "zz_ROU", "", "zz", "ROU", "RO" },
{ "zz_ZAR", "", "zz", "ZAR", "ZR" },
{ "zz_TMP", "", "zz", "TMP", "TP" },
{ "zz_TLS", "", "zz", "TLS", "TL" },
{ "zz_YUG", "", "zz", "YUG", "YU" },
{ "mlt_PSE", "mlt", "mt", "PSE", "PS" },
{ "iw", "heb", "iw", "", "" },
{ "ji", "yid", "ji", "", "" },
{ "jw", "jaw", "jw", "", "" },
{ "sh", "srp", "sh", "", "" },
{ "", "", "", "", "" }
};
for(i=0;tests[i].locale[0];i++)
{
const char *locale;
locale = tests[i].locale;
log_verbose("** %s:\n", locale);
status = U_ZERO_ERROR;
if(strcmp(tests[i].lang3,uloc_getISO3Language(locale)))
{
log_err("FAIL: uloc_getISO3Language(%s)==\t\"%s\",\t expected \"%s\"\n",
locale, uloc_getISO3Language(locale), tests[i].lang3);
}
else
{
log_verbose(" uloc_getISO3Language()==\t\"%s\"\n",
uloc_getISO3Language(locale) );
}
status = U_ZERO_ERROR;
uloc_getLanguage(locale, buff, 256, &status);
if(U_FAILURE(status))
{
log_err("FAIL: error getting language from %s\n", locale);
}
else
{
if(strcmp(buff,tests[i].lang))
{
log_err("FAIL: uloc_getLanguage(%s)==\t\"%s\"\t expected \"%s\"\n",
locale, buff, tests[i].lang);
}
else
{
log_verbose(" uloc_getLanguage(%s)==\t%s\n", locale, buff);
}
}
if(strcmp(tests[i].lang3,uloc_getISO3Language(locale)))
{
log_err("FAIL: uloc_getISO3Language(%s)==\t\"%s\",\t expected \"%s\"\n",
locale, uloc_getISO3Language(locale), tests[i].lang3);
}
else
{
log_verbose(" uloc_getISO3Language()==\t\"%s\"\n",
uloc_getISO3Language(locale) );
}
if(strcmp(tests[i].ctry3,uloc_getISO3Country(locale)))
{
log_err("FAIL: uloc_getISO3Country(%s)==\t\"%s\",\t expected \"%s\"\n",
locale, uloc_getISO3Country(locale), tests[i].ctry3);
}
else
{
log_verbose(" uloc_getISO3Country()==\t\"%s\"\n",
uloc_getISO3Country(locale) );
}
status = U_ZERO_ERROR;
uloc_getCountry(locale, buff, 256, &status);
if(U_FAILURE(status))
{
log_err("FAIL: error getting country from %s\n", locale);
}
else
{
if(strcmp(buff,tests[i].ctry))
{
log_err("FAIL: uloc_getCountry(%s)==\t\"%s\"\t expected \"%s\"\n",
locale, buff, tests[i].ctry);
}
else
{
log_verbose(" uloc_getCountry(%s)==\t%s\n", locale, buff);
}
}
}
if (uloc_getLCID("iw_IL") != uloc_getLCID("he_IL")) {
log_err("he,iw LCID mismatch: %X versus %X\n", uloc_getLCID("iw_IL"), uloc_getLCID("he_IL"));
}
if (uloc_getLCID("iw") != uloc_getLCID("he")) {
log_err("he,iw LCID mismatch: %X versus %X\n", uloc_getLCID("iw"), uloc_getLCID("he"));
}
#if 0
i = uloc_getLanguage("kok",NULL,0,&icu_err);
if(U_FAILURE(icu_err))
{
log_err("FAIL: Got %s trying to do uloc_getLanguage(kok)\n", u_errorName(icu_err));
}
icu_err = U_ZERO_ERROR;
uloc_getLanguage("kok",r1_buff,12,&icu_err);
if(U_FAILURE(icu_err))
{
log_err("FAIL: Got %s trying to do uloc_getLanguage(kok, buff)\n", u_errorName(icu_err));
}
r1_addr = (char *)uloc_getISO3Language("kok");
icu_err = U_ZERO_ERROR;
if (strcmp(r1_buff,"kok") != 0)
{
log_err("FAIL: uloc_getLanguage(kok)==%s not kok\n",r1_buff);
line--;
}
r1_addr = (char *)uloc_getISO3Language("in");
i = uloc_getLanguage(r1_addr,r1_buff,12,&icu_err);
if (strcmp(r1_buff,"id") != 0)
{
printf("uloc_getLanguage error (%s)\n",r1_buff);
line--;
}
r1_addr = (char *)uloc_getISO3Language("sh");
i = uloc_getLanguage(r1_addr,r1_buff,12,&icu_err);
if (strcmp(r1_buff,"sr") != 0)
{
printf("uloc_getLanguage error (%s)\n",r1_buff);
line--;
}
r1_addr = (char *)uloc_getISO3Country("zz_ZR");
strcpy(p1_buff,"zz_");
strcat(p1_buff,r1_addr);
i = uloc_getCountry(p1_buff,r1_buff,12,&icu_err);
if (strcmp(r1_buff,"ZR") != 0)
{
printf("uloc_getCountry error (%s)\n",r1_buff);
line--;
}
r1_addr = (char *)uloc_getISO3Country("zz_FX");
strcpy(p1_buff,"zz_");
strcat(p1_buff,r1_addr);
i = uloc_getCountry(p1_buff,r1_buff,12,&icu_err);
if (strcmp(r1_buff,"FX") != 0)
{
printf("uloc_getCountry error (%s)\n",r1_buff);
line--;
}
#endif
}
static void TestKeywordVariants(void)
{
static const struct {
const char *localeID;
const char *expectedLocaleID; /* uloc_getName */
const char *expectedLocaleIDNoKeywords; /* uloc_getBaseName */
const char *expectedCanonicalID; /* uloc_canonicalize */
const char *expectedKeywords[10];
int32_t numKeywords;
UErrorCode expectedStatus; /* from uloc_openKeywords */
} testCases[] = {
{
"de_DE@ currency = euro; C o ll A t i o n = Phonebook ; C alen dar = buddhist ",
"de_DE@calendar=buddhist;collation=Phonebook;currency=euro",
"de_DE",
"de_DE@calendar=buddhist;collation=Phonebook;currency=euro",
{"calendar", "collation", "currency"},
3,
U_ZERO_ERROR
},
{
"de_DE@euro",
"de_DE@euro",
"de_DE@euro", /* we probably should strip off the POSIX style variant @euro see #11690 */
"de_DE_EURO",
{"","","","","","",""},
0,
U_INVALID_FORMAT_ERROR /* must have '=' after '@' */
},
{
"de_DE@euro;collation=phonebook", /* The POSIX style variant @euro cannot be combined with key=value? */
"de_DE", /* getName returns de_DE - should be INVALID_FORMAT_ERROR? */
"de_DE", /* getBaseName returns de_DE - should be INVALID_FORMAT_ERROR? see #11690 */
"de_DE", /* canonicalize returns de_DE - should be INVALID_FORMAT_ERROR? */
{"","","","","","",""},
0,
U_INVALID_FORMAT_ERROR
},
{
"de_DE@collation=",
0, /* expected getName to fail */
"de_DE", /* getBaseName returns de_DE - should be INVALID_FORMAT_ERROR? see #11690 */
0, /* expected canonicalize to fail */
{"","","","","","",""},
0,
U_INVALID_FORMAT_ERROR /* must have '=' after '@' */
}
};
UErrorCode status = U_ZERO_ERROR;
int32_t i = 0, j = 0;
int32_t resultLen = 0;
char buffer[256];
UEnumeration *keywords;
int32_t keyCount = 0;
const char *keyword = NULL;
int32_t keywordLen = 0;
for(i = 0; i < UPRV_LENGTHOF(testCases); i++) {
status = U_ZERO_ERROR;
*buffer = 0;
keywords = uloc_openKeywords(testCases[i].localeID, &status);
if(status != testCases[i].expectedStatus) {
log_err("Expected to uloc_openKeywords(\"%s\") => status %s. Got %s instead\n",
testCases[i].localeID,
u_errorName(testCases[i].expectedStatus), u_errorName(status));
}
status = U_ZERO_ERROR;
if(keywords) {
if((keyCount = uenum_count(keywords, &status)) != testCases[i].numKeywords) {
log_err("Expected to get %i keywords, got %i\n", testCases[i].numKeywords, keyCount);
}
if(keyCount) {
j = 0;
while((keyword = uenum_next(keywords, &keywordLen, &status))) {
if(strcmp(keyword, testCases[i].expectedKeywords[j]) != 0) {
log_err("Expected to get keyword value %s, got %s\n", testCases[i].expectedKeywords[j], keyword);
}
j++;
}
j = 0;
uenum_reset(keywords, &status);
while((keyword = uenum_next(keywords, &keywordLen, &status))) {
if(strcmp(keyword, testCases[i].expectedKeywords[j]) != 0) {
log_err("Expected to get keyword value %s, got %s\n", testCases[i].expectedKeywords[j], keyword);
}
j++;
}
}
uenum_close(keywords);
}
status = U_ZERO_ERROR;
resultLen = uloc_getName(testCases[i].localeID, buffer, 256, &status);
(void)resultLen;
U_ASSERT(resultLen < 256);
if (U_SUCCESS(status)) {
if (testCases[i].expectedLocaleID == 0) {
log_err("Expected uloc_getName(\"%s\") to fail; got \"%s\"\n",
testCases[i].localeID, buffer);
} else if (uprv_strcmp(testCases[i].expectedLocaleID, buffer) != 0) {
log_err("Expected uloc_getName(\"%s\") => \"%s\"; got \"%s\"\n",
testCases[i].localeID, testCases[i].expectedLocaleID, buffer);
}
} else {
if (testCases[i].expectedLocaleID != 0) {
log_err("Expected uloc_getName(\"%s\") => \"%s\"; but returned error: %s\n",
testCases[i].localeID, testCases[i].expectedLocaleID, buffer, u_errorName(status));
}
}
status = U_ZERO_ERROR;
resultLen = uloc_getBaseName(testCases[i].localeID, buffer, 256, &status);
U_ASSERT(resultLen < 256);
if (U_SUCCESS(status)) {
if (testCases[i].expectedLocaleIDNoKeywords == 0) {
log_err("Expected uloc_getBaseName(\"%s\") to fail; got \"%s\"\n",
testCases[i].localeID, buffer);
} else if (uprv_strcmp(testCases[i].expectedLocaleIDNoKeywords, buffer) != 0) {
log_err("Expected uloc_getBaseName(\"%s\") => \"%s\"; got \"%s\"\n",
testCases[i].localeID, testCases[i].expectedLocaleIDNoKeywords, buffer);
}
} else {
if (testCases[i].expectedLocaleIDNoKeywords != 0) {
log_err("Expected uloc_getBaseName(\"%s\") => \"%s\"; but returned error: %s\n",
testCases[i].localeID, testCases[i].expectedLocaleIDNoKeywords, buffer, u_errorName(status));
}
}
status = U_ZERO_ERROR;
resultLen = uloc_canonicalize(testCases[i].localeID, buffer, 256, &status);
U_ASSERT(resultLen < 256);
if (U_SUCCESS(status)) {
if (testCases[i].expectedCanonicalID == 0) {
log_err("Expected uloc_canonicalize(\"%s\") to fail; got \"%s\"\n",
testCases[i].localeID, buffer);
} else if (uprv_strcmp(testCases[i].expectedCanonicalID, buffer) != 0) {
log_err("Expected uloc_canonicalize(\"%s\") => \"%s\"; got \"%s\"\n",
testCases[i].localeID, testCases[i].expectedCanonicalID, buffer);
}
} else {
if (testCases[i].expectedCanonicalID != 0) {
log_err("Expected uloc_canonicalize(\"%s\") => \"%s\"; but returned error: %s\n",
testCases[i].localeID, testCases[i].expectedCanonicalID, buffer, u_errorName(status));
}
}
}
}
static void TestKeywordVariantParsing(void)
{
static const struct {
const char *localeID;
const char *keyword;
const char *expectedValue; /* NULL if failure is expected */
} testCases[] = {
{ "de_DE@ C o ll A t i o n = Phonebook ", "c o ll a t i o n", NULL }, /* malformed key name */
{ "de_DE", "collation", ""},
{ "de_DE@collation=PHONEBOOK", "collation", "PHONEBOOK" },
{ "de_DE@currency = euro; CoLLaTion = PHONEBOOk", "collatiON", "PHONEBOOk" },
};
UErrorCode status;
int32_t i = 0;
int32_t resultLen = 0;
char buffer[256];
for(i = 0; i < UPRV_LENGTHOF(testCases); i++) {
*buffer = 0;
status = U_ZERO_ERROR;
resultLen = uloc_getKeywordValue(testCases[i].localeID, testCases[i].keyword, buffer, 256, &status);
(void)resultLen; /* Suppress set but not used warning. */
if (testCases[i].expectedValue) {
/* expect success */
if (U_FAILURE(status)) {
log_err("Expected to extract \"%s\" from \"%s\" for keyword \"%s\". Instead got status %s\n",
testCases[i].expectedValue, testCases[i].localeID, testCases[i].keyword, u_errorName(status));
} else if (uprv_strcmp(testCases[i].expectedValue, buffer) != 0) {
log_err("Expected to extract \"%s\" from \"%s\" for keyword \"%s\". Instead got \"%s\"\n",
testCases[i].expectedValue, testCases[i].localeID, testCases[i].keyword, buffer);
}
} else if (U_SUCCESS(status)) {
/* expect failure */
log_err("Expected failure but got success from \"%s\" for keyword \"%s\". Got \"%s\"\n",
testCases[i].localeID, testCases[i].keyword, buffer);
}
}
}
static const struct {
const char *l; /* locale */
const char *k; /* kw */
const char *v; /* value */
const char *x; /* expected */
} kwSetTestCases[] = {
#if 1
{ "en_US", "calendar", "japanese", "en_US@calendar=japanese" },
{ "en_US@", "calendar", "japanese", "en_US@calendar=japanese" },
{ "en_US@calendar=islamic", "calendar", "japanese", "en_US@calendar=japanese" },
{ "en_US@calendar=slovakian", "calendar", "gregorian", "en_US@calendar=gregorian" }, /* don't know what this means, but it has the same # of chars as gregorian */
{ "en_US@calendar=gregorian", "calendar", "japanese", "en_US@calendar=japanese" },
{ "de", "Currency", "CHF", "de@currency=CHF" },
{ "de", "Currency", "CHF", "de@currency=CHF" },
{ "en_US@collation=phonebook", "calendar", "japanese", "en_US@calendar=japanese;collation=phonebook" },
{ "en_US@calendar=japanese", "collation", "phonebook", "en_US@calendar=japanese;collation=phonebook" },
{ "de@collation=phonebook", "Currency", "CHF", "de@collation=phonebook;currency=CHF" },
{ "en_US@calendar=gregorian;collation=phonebook", "calendar", "japanese", "en_US@calendar=japanese;collation=phonebook" },
{ "en_US@calendar=slovakian;collation=phonebook", "calendar", "gregorian", "en_US@calendar=gregorian;collation=phonebook" }, /* don't know what this means, but it has the same # of chars as gregorian */
{ "en_US@calendar=slovakian;collation=videobook", "collation", "phonebook", "en_US@calendar=slovakian;collation=phonebook" }, /* don't know what this means, but it has the same # of chars as gregorian */
{ "en_US@calendar=islamic;collation=phonebook", "calendar", "japanese", "en_US@calendar=japanese;collation=phonebook" },
{ "de@collation=phonebook", "Currency", "CHF", "de@collation=phonebook;currency=CHF" },
#endif
#if 1
{ "mt@a=0;b=1;c=2;d=3", "c","j", "mt@a=0;b=1;c=j;d=3" },
{ "mt@a=0;b=1;c=2;d=3", "x","j", "mt@a=0;b=1;c=2;d=3;x=j" },
{ "mt@a=0;b=1;c=2;d=3", "a","f", "mt@a=f;b=1;c=2;d=3" },
{ "mt@a=0;aa=1;aaa=3", "a","x", "mt@a=x;aa=1;aaa=3" },
{ "mt@a=0;aa=1;aaa=3", "aa","x", "mt@a=0;aa=x;aaa=3" },
{ "mt@a=0;aa=1;aaa=3", "aaa","x", "mt@a=0;aa=1;aaa=x" },
{ "mt@a=0;aa=1;aaa=3", "a","yy", "mt@a=yy;aa=1;aaa=3" },
{ "mt@a=0;aa=1;aaa=3", "aa","yy", "mt@a=0;aa=yy;aaa=3" },
{ "mt@a=0;aa=1;aaa=3", "aaa","yy", "mt@a=0;aa=1;aaa=yy" },
#endif
#if 1
/* removal tests */
/* 1. removal of item at end */
{ "de@collation=phonebook;currency=CHF", "currency", "", "de@collation=phonebook" },
{ "de@collation=phonebook;currency=CHF", "currency", NULL, "de@collation=phonebook" },
/* 2. removal of item at beginning */
{ "de@collation=phonebook;currency=CHF", "collation", "", "de@currency=CHF" },
{ "de@collation=phonebook;currency=CHF", "collation", NULL, "de@currency=CHF" },
/* 3. removal of an item not there */
{ "de@collation=phonebook;currency=CHF", "calendar", NULL, "de@collation=phonebook;currency=CHF" },
/* 4. removal of only item */
{ "de@collation=phonebook", "collation", NULL, "de" },
#endif
{ "de@collation=phonebook", "Currency", "CHF", "de@collation=phonebook;currency=CHF" },
/* cases with legal extra spacing */
/*31*/{ "en_US@ calendar = islamic", "calendar", "japanese", "en_US@calendar=japanese" },
/*32*/{ "en_US@ calendar = gregorian ; collation = phonebook", "calendar", "japanese", "en_US@calendar=japanese;collation=phonebook" },
/*33*/{ "en_US@ calendar = islamic", "currency", "CHF", "en_US@calendar=islamic;currency=CHF" },
/*34*/{ "en_US@ currency = CHF", "calendar", "japanese", "en_US@calendar=japanese;currency=CHF" },
/* cases in which setKeywordValue expected to fail (implied by NULL for expected); locale need not be canonical */
/*35*/{ "en_US@calendar=gregorian;", "calendar", "japanese", NULL },
/*36*/{ "en_US@calendar=gregorian;=", "calendar", "japanese", NULL },
/*37*/{ "en_US@calendar=gregorian;currency=", "calendar", "japanese", NULL },
/*38*/{ "en_US@=", "calendar", "japanese", NULL },
/*39*/{ "en_US@=;", "calendar", "japanese", NULL },
/*40*/{ "en_US@= ", "calendar", "japanese", NULL },
/*41*/{ "en_US@ =", "calendar", "japanese", NULL },
/*42*/{ "en_US@ = ", "calendar", "japanese", NULL },
/*43*/{ "en_US@=;calendar=gregorian", "calendar", "japanese", NULL },
/*44*/{ "en_US@= calen dar = gregorian", "calendar", "japanese", NULL },
/*45*/{ "en_US@= calendar = greg orian", "calendar", "japanese", NULL },
/*46*/{ "en_US@=;cal...endar=gregorian", "calendar", "japanese", NULL },
/*47*/{ "en_US@=;calendar=greg...orian", "calendar", "japanese", NULL },
/*48*/{ "en_US@calendar=gregorian", "cale ndar", "japanese", NULL },
/*49*/{ "en_US@calendar=gregorian", "calendar", "japa..nese", NULL },
/* cases in which getKeywordValue and setKeyword expected to fail (implied by NULL for value and expected) */
/*50*/{ "en_US@=", "calendar", NULL, NULL },
/*51*/{ "en_US@=;", "calendar", NULL, NULL },
/*52*/{ "en_US@= ", "calendar", NULL, NULL },
/*53*/{ "en_US@ =", "calendar", NULL, NULL },
/*54*/{ "en_US@ = ", "calendar", NULL, NULL },
/*55*/{ "en_US@=;calendar=gregorian", "calendar", NULL, NULL },
/*56*/{ "en_US@= calen dar = gregorian", "calendar", NULL, NULL },
/*57*/{ "en_US@= calendar = greg orian", "calendar", NULL, NULL },
/*58*/{ "en_US@=;cal...endar=gregorian", "calendar", NULL, NULL },
/*59*/{ "en_US@=;calendar=greg...orian", "calendar", NULL, NULL },
/*60*/{ "en_US@calendar=gregorian", "cale ndar", NULL, NULL },
};
static void TestKeywordSet(void)
{
int32_t i = 0;
int32_t resultLen = 0;
char buffer[1024];
char cbuffer[1024];
for(i = 0; i < UPRV_LENGTHOF(kwSetTestCases); i++) {
UErrorCode status = U_ZERO_ERROR;
memset(buffer,'%',1023);
strcpy(buffer, kwSetTestCases[i].l);
if (kwSetTestCases[i].x != NULL) {
uloc_canonicalize(kwSetTestCases[i].l, cbuffer, 1023, &status);
if(strcmp(buffer,cbuffer)) {
log_verbose("note: [%d] wasn't canonical, should be: '%s' not '%s'. Won't check for canonicity in output.\n", i, cbuffer, buffer);
}
/* sanity check test case results for canonicity */
uloc_canonicalize(kwSetTestCases[i].x, cbuffer, 1023, &status);
if(strcmp(kwSetTestCases[i].x,cbuffer)) {
log_err("%s:%d: ERROR: kwSetTestCases[%d].x = '%s', should be %s (must be canonical)\n", __FILE__, __LINE__, i, kwSetTestCases[i].x, cbuffer);
}
status = U_ZERO_ERROR;
resultLen = uloc_setKeywordValue(kwSetTestCases[i].k, kwSetTestCases[i].v, buffer, 1023, &status);
if(U_FAILURE(status)) {
log_err("Err on test case %d for setKeywordValue: got error %s\n", i, u_errorName(status));
} else if(strcmp(buffer,kwSetTestCases[i].x) || ((int32_t)strlen(buffer)!=resultLen)) {
log_err("FAIL: #%d setKeywordValue: %s + [%s=%s] -> %s (%d) expected %s (%d)\n", i, kwSetTestCases[i].l, kwSetTestCases[i].k,
kwSetTestCases[i].v, buffer, resultLen, kwSetTestCases[i].x, strlen(buffer));
} else {
log_verbose("pass: #%d: %s + [%s=%s] -> %s\n", i, kwSetTestCases[i].l, kwSetTestCases[i].k, kwSetTestCases[i].v,buffer);
}
if (kwSetTestCases[i].v != NULL && kwSetTestCases[i].v[0] != 0) {
status = U_ZERO_ERROR;
resultLen = uloc_getKeywordValue(kwSetTestCases[i].x, kwSetTestCases[i].k, buffer, 1023, &status);
if(U_FAILURE(status)) {
log_err("Err on test case %d for getKeywordValue: got error %s\n", i, u_errorName(status));
} else if (resultLen != (int32_t)uprv_strlen(kwSetTestCases[i].v) || uprv_strcmp(buffer, kwSetTestCases[i].v) != 0) {
log_err("FAIL: #%d getKeywordValue: got %s (%d) expected %s (%d)\n", i, buffer, resultLen,
kwSetTestCases[i].v, uprv_strlen(kwSetTestCases[i].v));
}
}
} else {
/* test cases expected to result in error */
status = U_ZERO_ERROR;
resultLen = uloc_setKeywordValue(kwSetTestCases[i].k, kwSetTestCases[i].v, buffer, 1023, &status);
if(U_SUCCESS(status)) {
log_err("Err on test case %d for setKeywordValue: expected to fail but succeeded, got %s (%d)\n", i, buffer, resultLen);
}
if (kwSetTestCases[i].v == NULL) {
status = U_ZERO_ERROR;
strcpy(cbuffer, kwSetTestCases[i].l);
resultLen = uloc_getKeywordValue(cbuffer, kwSetTestCases[i].k, buffer, 1023, &status);
if(U_SUCCESS(status)) {
log_err("Err on test case %d for getKeywordValue: expected to fail but succeeded\n", i);
}
}
}
}
}
static void TestKeywordSetError(void)
{
char buffer[1024];
UErrorCode status;
int32_t res;
int32_t i;
int32_t blen;
/* 0-test whether an error condition modifies the buffer at all */
blen=0;
i=0;
memset(buffer,'%',1023);
status = U_ZERO_ERROR;
res = uloc_setKeywordValue(kwSetTestCases[i].k, kwSetTestCases[i].v, buffer, blen, &status);
if(status != U_ILLEGAL_ARGUMENT_ERROR) {
log_err("expected illegal err got %s\n", u_errorName(status));
return;
}
/* if(res!=strlen(kwSetTestCases[i].x)) {
log_err("expected result %d got %d\n", strlen(kwSetTestCases[i].x), res);
return;
} */
if(buffer[blen]!='%') {
log_err("Buffer byte %d was modified: now %c\n", blen, buffer[blen]);
return;
}
log_verbose("0-buffer modify OK\n");
for(i=0;i<=2;i++) {
/* 1- test a short buffer with growing text */
blen=(int32_t)strlen(kwSetTestCases[i].l)+1;
memset(buffer,'%',1023);
strcpy(buffer,kwSetTestCases[i].l);
status = U_ZERO_ERROR;
res = uloc_setKeywordValue(kwSetTestCases[i].k, kwSetTestCases[i].v, buffer, blen, &status);
if(status != U_BUFFER_OVERFLOW_ERROR) {
log_err("expected buffer overflow on buffer %d got %s, len %d (%s + [%s=%s])\n", blen, u_errorName(status), res, kwSetTestCases[i].l, kwSetTestCases[i].k, kwSetTestCases[i].v);
return;
}
if(res!=(int32_t)strlen(kwSetTestCases[i].x)) {
log_err("expected result %d got %d\n", strlen(kwSetTestCases[i].x), res);
return;
}
if(buffer[blen]!='%') {
log_err("Buffer byte %d was modified: now %c\n", blen, buffer[blen]);
return;
}
log_verbose("1/%d-buffer modify OK\n",i);
}
for(i=3;i<=4;i++) {
/* 2- test a short buffer - text the same size or shrinking */
blen=(int32_t)strlen(kwSetTestCases[i].l)+1;
memset(buffer,'%',1023);
strcpy(buffer,kwSetTestCases[i].l);
status = U_ZERO_ERROR;
res = uloc_setKeywordValue(kwSetTestCases[i].k, kwSetTestCases[i].v, buffer, blen, &status);
if(status != U_ZERO_ERROR) {
log_err("expected zero error got %s\n", u_errorName(status));
return;
}
if(buffer[blen+1]!='%') {
log_err("Buffer byte %d was modified: now %c\n", blen+1, buffer[blen+1]);
return;
}
if(res!=(int32_t)strlen(kwSetTestCases[i].x)) {
log_err("expected result %d got %d\n", strlen(kwSetTestCases[i].x), res);
return;
}
if(strcmp(buffer,kwSetTestCases[i].x) || ((int32_t)strlen(buffer)!=res)) {
log_err("FAIL: #%d: %s + [%s=%s] -> %s (%d) expected %s (%d)\n", i, kwSetTestCases[i].l, kwSetTestCases[i].k,
kwSetTestCases[i].v, buffer, res, kwSetTestCases[i].x, strlen(buffer));
} else {
log_verbose("pass: #%d: %s + [%s=%s] -> %s\n", i, kwSetTestCases[i].l, kwSetTestCases[i].k, kwSetTestCases[i].v,
buffer);
}
log_verbose("2/%d-buffer modify OK\n",i);
}
}
static int32_t _canonicalize(int32_t selector, /* 0==getName, 1==canonicalize */
const char* localeID,
char* result,
int32_t resultCapacity,
UErrorCode* ec) {
/* YOU can change this to use function pointers if you like */
switch (selector) {
case 0:
return uloc_getName(localeID, result, resultCapacity, ec);
case 1:
return uloc_canonicalize(localeID, result, resultCapacity, ec);
default:
return -1;
}
}
static void TestCanonicalization(void)
{
static const struct {
const char *localeID; /* input */
const char *getNameID; /* expected getName() result */
const char *canonicalID; /* expected canonicalize() result */
} testCases[] = {
{ "ca_ES-with-extra-stuff-that really doesn't make any sense-unless-you're trying to increase code coverage",
"ca_ES_WITH_EXTRA_STUFF_THAT REALLY DOESN'T MAKE ANY SENSE_UNLESS_YOU'RE TRYING TO INCREASE CODE COVERAGE",
"ca_ES_WITH_EXTRA_STUFF_THAT REALLY DOESN'T MAKE ANY SENSE_UNLESS_YOU'RE TRYING TO INCREASE CODE COVERAGE"},
{ "zh@collation=pinyin", "zh@collation=pinyin", "zh@collation=pinyin" },
{ "zh_CN@collation=pinyin", "zh_CN@collation=pinyin", "zh_CN@collation=pinyin" },
{ "zh_CN_CA@collation=pinyin", "zh_CN_CA@collation=pinyin", "zh_CN_CA@collation=pinyin" },
{ "en_US_POSIX", "en_US_POSIX", "en_US_POSIX" },
{ "hy_AM_REVISED", "hy_AM_REVISED", "hy_AM_REVISED" },
{ "no_NO_NY", "no_NO_NY", "no_NO_NY" /* not: "nn_NO" [alan ICU3.0] */ },
{ "no@ny", "no@ny", "no__NY" /* not: "nn" [alan ICU3.0] */ }, /* POSIX ID */
{ "no-no.utf32@B", "no_NO.utf32@B", "no_NO_B" /* not: "nb_NO_B" [alan ICU3.0] */ }, /* POSIX ID */
{ "qz-qz@Euro", "qz_QZ@Euro", "qz_QZ_EURO" }, /* qz-qz uses private use iso codes */
{ "en-BOONT", "en__BOONT", "en__BOONT" }, /* registered name */
{ "de-1901", "de__1901", "de__1901" }, /* registered name */
{ "de-1906", "de__1906", "de__1906" }, /* registered name */
/* posix behavior that used to be performed by getName */
{ "mr.utf8", "mr.utf8", "mr" },
{ "de-tv.koi8r", "de_TV.koi8r", "de_TV" },
{ "x-piglatin_ML.MBE", "x-piglatin_ML.MBE", "x-piglatin_ML" },
{ "i-cherokee_US.utf7", "i-cherokee_US.utf7", "i-cherokee_US" },
{ "x-filfli_MT_FILFLA.gb-18030", "x-filfli_MT_FILFLA.gb-18030", "x-filfli_MT_FILFLA" },
{ "no-no-ny.utf8@B", "no_NO_NY.utf8@B", "no_NO_NY_B" /* not: "nn_NO" [alan ICU3.0] */ }, /* @ ignored unless variant is empty */
/* fleshing out canonicalization */
/* trim space and sort keywords, ';' is separator so not present at end in canonical form */
{ "en_Hant_IL_VALLEY_GIRL@ currency = EUR; calendar = Japanese ;", "en_Hant_IL_VALLEY_GIRL@calendar=Japanese;currency=EUR", "en_Hant_IL_VALLEY_GIRL@calendar=Japanese;currency=EUR" },
/* already-canonical ids are not changed */
{ "en_Hant_IL_VALLEY_GIRL@calendar=Japanese;currency=EUR", "en_Hant_IL_VALLEY_GIRL@calendar=Japanese;currency=EUR", "en_Hant_IL_VALLEY_GIRL@calendar=Japanese;currency=EUR" },
/* norwegian is just too weird, if we handle things in their full generality */