summaryrefslogtreecommitdiff
path: root/Build/source/libs/icu/icu-4.6/test/cintltst/cloctst.c
diff options
context:
space:
mode:
Diffstat (limited to 'Build/source/libs/icu/icu-4.6/test/cintltst/cloctst.c')
-rw-r--r--Build/source/libs/icu/icu-4.6/test/cintltst/cloctst.c5578
1 files changed, 5578 insertions, 0 deletions
diff --git a/Build/source/libs/icu/icu-4.6/test/cintltst/cloctst.c b/Build/source/libs/icu/icu-4.6/test/cintltst/cloctst.c
new file mode 100644
index 00000000000..c30ac4ba885
--- /dev/null
+++ b/Build/source/libs/icu/icu-4.6/test/cintltst/cloctst.c
@@ -0,0 +1,5578 @@
+/********************************************************************
+ * COPYRIGHT:
+ * Copyright (c) 1997-2010, 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 "cstring.h"
+#include "uparse.h"
+#include "uresimp.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/parseerr.h" /* may not be included with some uconfig switches */
+#include "udbgutil.h"
+#define LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0]))
+
+static void TestNullDefault(void);
+static void TestNonexistentLanguageExemplars(void);
+static void TestLocDataErrorCodeChaining(void);
+static void TestLanguageExemplarsFallbacks(void);
+
+static void TestUnicodeDefines(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 Han, China)",
+ "German (Germany, Collation=Phonebook Sort Order)", "Spanish (Collation=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) */
+ { "", "", "", "", "", "id\\u00e9ogrammes han 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 (id\\u00e9ogrammes han simplifi\\u00e9s, Chine)",
+ "allemand (Allemagne, Ordonnancement=Ordre de l\\u2019annuaire)", "espagnol (Ordonnancement=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) */
+ { "", "", "", "", "", "xin\\u00e8s 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 (xin\\u00e8s simplificat, Xina)",
+ "alemany (Alemanya, ordre alfab\\u00e8tic=ordre de la guia telef\\u00F2nica)", "espanyol (ordre alfab\\u00e8tic=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 \\u039a\\u03b9\\u03bd\\u03b5\\u03b6\\u03b9\\u03ba\\u03cc", "", "", "" },
+ /* display country (Greek) */
+ {
+ "\\u0397\\u03BD\\u03C9\\u03BC\\u03AD\\u03BD\\u03B5\\u03C2 \\u03A0\\u03BF\\u03BB\\u03B9\\u03C4\\u03B5\\u03AF\\u03B5\\u03C2 \\u03C4\\u03B7\\u03C2 \\u0391\\u03BC\\u03B5\\u03C1\\u03B9\\u03BA\\u03AE\\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 \\u03C4\\u03B7\\u03C2 \\u0391\\u03BC\\u03B5\\u03C1\\u03B9\\u03BA\\u03AE\\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\\u03b9\\u03bd\\u03b5\\u03b6\\u03b9\\u03ba\\u03cc, \\u039A\\u03AF\\u03BD\\u03B1)",
+ "\\u0393\\u03B5\\u03C1\\u03BC\\u03B1\\u03BD\\u03B9\\u03BA\\u03AC (\\u0393\\u03B5\\u03C1\\u03BC\\u03B1\\u03BD\\u03AF\\u03B1, \\u03C4\\u03B1\\u03BA\\u03C4\\u03BF\\u03C0\\u03BF\\u03AF\\u03B7\\u03C3\\u03B7=\\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 (\\u03C4\\u03B1\\u03BA\\u03C4\\u03BF\\u03C0\\u03BF\\u03AF\\u03B7\\u03C3\\u03B7=\\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, \\u03B7\\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(TestGetAvailableLocales);
+ 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(TestKeywordSet);
+ TESTCASE(TestKeywordSetError);
+ TESTCASE(TestDisplayKeywords);
+ TESTCASE(TestDisplayKeywordValues);
+ TESTCASE(TestGetBaseName);
+#if !UCONFIG_NO_FILE_IO
+ TESTCASE(TestGetLocale);
+#endif
+ TESTCASE(TestDisplayNameWarning);
+ TESTCASE(TestNonexistentLanguageExemplars);
+ TESTCASE(TestLocDataErrorCodeChaining);
+ 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(TestForLanguageTag);
+ TESTCASE(TestTrailingNull);
+ TESTCASE(TestUnicodeDefines);
+}
+
+
+/* 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));
+ }
+
+ }
+
+}
+/* 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},
+
+ {"zh", "Hans", "", "PINYIN", "zh-Hans-pinyin", "zh_Hans_PINYIN", "zh_Hans@collation=pinyin"},
+ {"hy", "", "", "AREVMDA", "hy_AREVMDA", "hy_AREVMDA", 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},
+ {"zh", "Hant", "TW", "STROKE", "zh-hant_TW_STROKE", "zh_Hant_TW_STROKE", "zh_Hant_TW@collation=stroke"},
+ {"qq", "Qqqq", "QQ", "QQ", "qq_Qqqq_QQ_QQ", "qq_Qqqq_QQ_QQ", NULL},
+ {"qq", "Qqqq", "", "QQ", "qq_Qqqq__QQ", "qq_Qqqq__QQ", NULL},
+ {"12", "3456", "78", "90", "12_3456_78_90", "12_3456_78_90", NULL}, /* total garbage */
+
+ {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();
+}
+
+/*
+ * 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, LENGTHOF(buffer), &errorCode);
+ if(U_FAILURE(errorCode) || (length<=3 && buffer[0]<=0x7f)) {
+ /* check <=3 to reject getting the language code as a display name */
+ 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));
+ }
+
+ /* 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, 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, 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, Collation=Traditional Sort Order)", /* note sorted order of keywords */
+ "espagnol (Calendrier=Calendrier japonais, Ordonnancement=Ordre traditionnel)",
+ "espanyol (calendari=calendari japon\\u00e8s, ordre alfab\\u00e8tic=ordre tradicional)",
+ "\\u0399\\u03C3\\u03C0\\u03B1\\u03BD\\u03B9\\u03BA\\u03AC (\\u03B7\\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, \\u03C4\\u03B1\\u03BA\\u03C4\\u03BF\\u03C0\\u03BF\\u03AF\\u03B7\\u03C3\\u03B7=\\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<LENGTHOF(testL);i++) {
+ errorCode = U_ZERO_ERROR;
+ uloc_getDisplayName(aLocale, testL[i], buffer, 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 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);
+ }
+}
+
+/* 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();
+}
+
+/* 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);
+}
+
+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", "Uighur", "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;
+ const char *expectedLocaleIDNoKeywords;
+ const char *expectedCanonicalID;
+ 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",
+ "de_DE@currency=EUR",
+ {"","","","","","",""},
+ 0,
+ U_INVALID_FORMAT_ERROR /* must have '=' after '@' */
+ },
+ {
+ "de_DE@euro;collation=phonebook",
+ "de_DE", /* error result; bad format */
+ "de_DE", /* error result; bad format */
+ "de_DE", /* error result; bad format */
+ {"","","","","","",""},
+ 0,
+ U_INVALID_FORMAT_ERROR
+ }
+ };
+ 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 < sizeof(testCases)/sizeof(testCases[0]); 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);
+ }
+ resultLen = uloc_getName(testCases[i].localeID, buffer, 256, &status);
+ 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);
+ }
+ resultLen = uloc_canonicalize(testCases[i].localeID, buffer, 256, &status);
+ 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);
+ }
+ }
+
+}
+
+static void TestKeywordVariantParsing(void)
+{
+ static const struct {
+ const char *localeID;
+ const char *keyword;
+ const char *expectedValue;
+ } testCases[] = {
+ { "de_DE@ C o ll A t i o n = Phonebook ", "c o ll a t i o n", "Phonebook" },
+ { "de_DE", "collation", ""},
+ { "de_DE@collation=PHONEBOOK", "collation", "PHONEBOOK" },
+ { "de_DE@currency = euro; CoLLaTion = PHONEBOOk", "collatiON", "PHONEBOOk" },
+ };
+
+ UErrorCode status = U_ZERO_ERROR;
+
+ int32_t i = 0;
+ int32_t resultLen = 0;
+ char buffer[256];
+
+ for(i = 0; i < sizeof(testCases)/sizeof(testCases[0]); i++) {
+ *buffer = 0;
+ resultLen = uloc_getKeywordValue(testCases[i].localeID, testCases[i].keyword, buffer, 256, &status);
+ if(uprv_strcmp(testCases[i].expectedValue, buffer) != 0) {
+ log_err("Expected to extract \"%s\" from \"%s\" for keyword \"%s\". Got \"%s\" instead\n",
+ testCases[i].expectedValue, 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" }
+};
+
+
+static void TestKeywordSet(void)
+{
+ int32_t i = 0;
+ int32_t resultLen = 0;
+ char buffer[1024];
+
+ char cbuffer[1024];
+
+ for(i = 0; i < sizeof(kwSetTestCases)/sizeof(kwSetTestCases[0]); i++) {
+ UErrorCode status = U_ZERO_ERROR;
+ memset(buffer,'%',1023);
+ strcpy(buffer, kwSetTestCases[i].l);
+
+ 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);
+ }
+
+ resultLen = uloc_setKeywordValue(kwSetTestCases[i].k, kwSetTestCases[i].v, buffer, 1023, &status);
+ if(U_FAILURE(status)) {
+ log_err("Err on test case %d: got error %s\n", i, u_errorName(status));
+ continue;
+ }
+ if(strcmp(buffer,kwSetTestCases[i].x) || ((int32_t)strlen(buffer)!=resultLen)) {
+ log_err("FAIL: #%d: %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);
+ }
+ }
+}
+
+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_PREEURO-with-extra-stuff-that really doesn't make any sense-unless-you're trying to increase code coverage",
+ "ca_ES_PREEURO_WITH_EXTRA_STUFF_THAT REALLY DOESN'T MAKE ANY SENSE_UNLESS_YOU'RE TRYING TO INCREASE CODE COVERAGE",
+ "ca_ES_PREEURO_WITH_EXTRA_STUFF_THAT REALLY DOESN'T MAKE ANY SENSE_UNLESS_YOU'RE TRYING TO INCREASE CODE COVERAGE"},
+ { "ca_ES_PREEURO", "ca_ES_PREEURO", "ca_ES@currency=ESP" },
+ { "de_AT_PREEURO", "de_AT_PREEURO", "de_AT@currency=ATS" },
+ { "de_DE_PREEURO", "de_DE_PREEURO", "de_DE@currency=DEM" },
+ { "de_LU_PREEURO", "de_LU_PREEURO", "de_LU@currency=LUF" },
+ { "el_GR_PREEURO", "el_GR_PREEURO", "el_GR@currency=GRD" },
+ { "en_BE_PREEURO", "en_BE_PREEURO", "en_BE@currency=BEF" },
+ { "en_IE_PREEURO", "en_IE_PREEURO", "en_IE@currency=IEP" },
+ { "es_ES_PREEURO", "es_ES_PREEURO", "es_ES@currency=ESP" },
+ { "eu_ES_PREEURO", "eu_ES_PREEURO", "eu_ES@currency=ESP" },
+ { "fi_FI_PREEURO", "fi_FI_PREEURO", "fi_FI@currency=FIM" },
+ { "fr_BE_PREEURO", "fr_BE_PREEURO", "fr_BE@currency=BEF" },
+ { "fr_FR_PREEURO", "fr_FR_PREEURO", "fr_FR@currency=FRF" },
+ { "fr_LU_PREEURO", "fr_LU_PREEURO", "fr_LU@currency=LUF" },
+ { "ga_IE_PREEURO", "ga_IE_PREEURO", "ga_IE@currency=IEP" },
+ { "gl_ES_PREEURO", "gl_ES_PREEURO", "gl_ES@currency=ESP" },
+ { "it_IT_PREEURO", "it_IT_PREEURO", "it_IT@currency=ITL" },
+ { "nl_BE_PREEURO", "nl_BE_PREEURO", "nl_BE@currency=BEF" },
+ { "nl_NL_PREEURO", "nl_NL_PREEURO", "nl_NL@currency=NLG" },
+ { "pt_PT_PREEURO", "pt_PT_PREEURO", "pt_PT@currency=PTE" },
+ { "de__PHONEBOOK", "de__PHONEBOOK", "de@collation=phonebook" },
+ { "en_GB_EURO", "en_GB_EURO", "en_GB@currency=EUR" },
+ { "en_GB@EURO", "en_GB@EURO", "en_GB@currency=EUR" }, /* POSIX ID */
+ { "es__TRADITIONAL", "es__TRADITIONAL", "es@collation=traditional" },
+ { "hi__DIRECT", "hi__DIRECT", "hi@collation=direct" },
+ { "ja_JP_TRADITIONAL", "ja_JP_TRADITIONAL", "ja_JP@calendar=japanese" },
+ { "th_TH_TRADITIONAL", "th_TH_TRADITIONAL", "th_TH@calendar=buddhist" },
+ { "zh_TW_STROKE", "zh_TW_STROKE", "zh_TW@collation=stroke" },
+ { "zh__PINYIN", "zh__PINYIN", "zh@collation=pinyin" },
+ { "zh@collation=pinyin", "zh@collation=pinyin", "zh@collation=pinyin" },
+ { "zh_CN@collation=pinyin", "zh_CN@collation=pinyin", "zh_CN@collation=pinyin" },
+ { "zh_CN_STROKE", "zh_CN_STROKE", "zh_CN@collation=stroke" },
+ { "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@currency=EUR" }, /* 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 */
+ { "sr-SP-Cyrl", "sr_SP_CYRL", "sr_Cyrl_RS" }, /* .NET name */
+ { "sr-SP-Latn", "sr_SP_LATN", "sr_Latn_RS" }, /* .NET name */
+ { "sr_YU_CYRILLIC", "sr_YU_CYRILLIC", "sr_Cyrl_RS" }, /* Linux name */
+ { "uz-UZ-Cyrl", "uz_UZ_CYRL", "uz_Cyrl_UZ" }, /* .NET name */
+ { "uz-UZ-Latn", "uz_UZ_LATN", "uz_Latn_UZ" }, /* .NET name */
+ { "zh-CHS", "zh_CHS", "zh_Hans" }, /* .NET name */
+ { "zh-CHT", "zh_CHT", "zh_Hant" }, /* .NET name This may change back to zh_Hant */
+
+ /* 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" },
+ /* PRE_EURO and EURO conversions don't affect other keywords */
+ { "es_ES_PREEURO@CALendar=Japanese", "es_ES_PREEURO@calendar=Japanese", "es_ES@calendar=Japanese;currency=ESP" },
+ { "es_ES_EURO@SHOUT=zipeedeedoodah", "es_ES_EURO@shout=zipeedeedoodah", "es_ES@currency=EUR;shout=zipeedeedoodah" },
+ /* currency keyword overrides PRE_EURO and EURO currency */
+ { "es_ES_PREEURO@currency=EUR", "es_ES_PREEURO@currency=EUR", "es_ES@currency=EUR" },
+ { "es_ES_EURO@currency=ESP", "es_ES_EURO@currency=ESP", "es_ES@currency=ESP" },
+ /* norwegian is just too weird, if we handle things in their full generality */
+ { "no-Hant-GB_NY@currency=$$$", "no_Hant_GB_NY@currency=$$$", "no_Hant_GB_NY@currency=$$$" /* not: "nn_Hant_GB@currency=$$$" [alan ICU3.0] */ },
+
+ /* test cases reflecting internal resource bundle usage */
+ { "root@kw=foo", "root@kw=foo", "root@kw=foo" },
+ { "@calendar=gregorian", "@calendar=gregorian", "@calendar=gregorian" },
+ { "ja_JP@calendar=Japanese", "ja_JP@calendar=Japanese", "ja_JP@calendar=Japanese" },
+ { "ja_JP", "ja_JP", "ja_JP" },
+
+ /* test case for "i-default" */
+ { "i-default", NULL, NULL }
+ };
+
+ static const char* label[] = { "getName", "canonicalize" };
+
+ UErrorCode status = U_ZERO_ERROR;
+ int32_t i, j, resultLen = 0, origResultLen;
+ char buffer[256];
+
+ for (i=0; i < sizeof(testCases)/sizeof(testCases[0]); i++) {
+ for (j=0; j<2; ++j) {
+ const char* expected = (j==0) ? testCases[i].getNameID : testCases[i].canonicalID;
+ *buffer = 0;
+ status = U_ZERO_ERROR;
+
+ if (expected == NULL) {
+ expected = uloc_getDefault();
+ }
+
+ /* log_verbose("testing %s -> %s\n", testCases[i], testCases[i].canonicalID); */
+ origResultLen = _canonicalize(j, testCases[i].localeID, NULL, 0, &status);
+ if (status != U_BUFFER_OVERFLOW_ERROR) {
+ log_err("FAIL: uloc_%s(%s) => %s, expected U_BUFFER_OVERFLOW_ERROR\n",
+ label[j], testCases[i].localeID, u_errorName(status));
+ continue;
+ }
+ status = U_ZERO_ERROR;
+ resultLen = _canonicalize(j, testCases[i].localeID, buffer, sizeof(buffer), &status);
+ if (U_FAILURE(status)) {
+ log_err("FAIL: uloc_%s(%s) => %s, expected U_ZERO_ERROR\n",
+ label[j], testCases[i].localeID, u_errorName(status));
+ continue;
+ }
+ if(uprv_strcmp(expected, buffer) != 0) {
+ log_err("FAIL: uloc_%s(%s) => \"%s\", expected \"%s\"\n",
+ label[j], testCases[i].localeID, buffer, expected);
+ } else {
+ log_verbose("Ok: uloc_%s(%s) => \"%s\"\n",
+ label[j], testCases[i].localeID, buffer);
+ }
+ if (resultLen != (int32_t)strlen(buffer)) {
+ log_err("FAIL: uloc_%s(%s) => len %d, expected len %d\n",
+ label[j], testCases[i].localeID, resultLen, strlen(buffer));
+ }
+ if (origResultLen != resultLen) {
+ log_err("FAIL: uloc_%s(%s) => preflight len %d != actual len %d\n",
+ label[j], testCases[i].localeID, origResultLen, resultLen);
+ }
+ }
+ }
+}
+
+static void TestDisplayKeywords(void)
+{
+ int32_t i;
+
+ static const struct {
+ const char *localeID;
+ const char *displayLocale;
+ UChar displayKeyword[200];
+ } testCases[] = {
+ { "ca_ES@currency=ESP", "de_AT",
+ {0x0057, 0x00e4, 0x0068, 0x0072, 0x0075, 0x006e, 0x0067, 0x0000},
+ },
+ { "ja_JP@calendar=japanese", "de",
+ { 0x004b, 0x0061, 0x006c, 0x0065, 0x006e, 0x0064, 0x0065, 0x0072, 0x0000}
+ },
+ { "de_DE@collation=traditional", "de_DE",
+ {0x0053, 0x006f, 0x0072, 0x0074, 0x0069, 0x0065, 0x0072, 0x0075, 0x006e, 0x0067, 0x0000}
+ },
+ };
+ for(i = 0; i < sizeof(testCases)/sizeof(testCases[0]); i++) {
+ UErrorCode status = U_ZERO_ERROR;
+ const char* keyword =NULL;
+ int32_t keywordLen = 0;
+ int32_t keywordCount = 0;
+ UChar *displayKeyword=NULL;
+ int32_t displayKeywordLen = 0;
+ UEnumeration* keywordEnum = uloc_openKeywords(testCases[i].localeID, &status);
+ for(keywordCount = uenum_count(keywordEnum, &status); keywordCount > 0 ; keywordCount--){
+ if(U_FAILURE(status)){
+ log_err("uloc_getKeywords failed for locale id: %s with error : %s \n", testCases[i].localeID, u_errorName(status));
+ break;
+ }
+ /* the uenum_next returns NUL terminated string */
+ keyword = uenum_next(keywordEnum, &keywordLen, &status);
+ /* fetch the displayKeyword */
+ displayKeywordLen = uloc_getDisplayKeyword(keyword, testCases[i].displayLocale, displayKeyword, displayKeywordLen, &status);
+ if(status==U_BUFFER_OVERFLOW_ERROR){
+ status = U_ZERO_ERROR;
+ displayKeywordLen++; /* for null termination */
+ displayKeyword = (UChar*) malloc(displayKeywordLen * U_SIZEOF_UCHAR);
+ displayKeywordLen = uloc_getDisplayKeyword(keyword, testCases[i].displayLocale, displayKeyword, displayKeywordLen, &status);
+ if(U_FAILURE(status)){
+ log_err("uloc_getDisplayKeyword filed for keyword : %s in locale id: %s for display locale: %s \n", testCases[i].localeID, keyword, testCases[i].displayLocale, u_errorName(status));
+ break;
+ }
+ if(u_strncmp(displayKeyword, testCases[i].displayKeyword, displayKeywordLen)!=0){
+ if (status == U_USING_DEFAULT_WARNING) {
+ log_data_err("uloc_getDisplayKeyword did not get the expected value for keyword : %s in locale id: %s for display locale: %s . Got error: %s. Perhaps you are missing data?\n", testCases[i].localeID, keyword, testCases[i].displayLocale, u_errorName(status));
+ } else {
+ log_err("uloc_getDisplayKeyword did not get the expected value for keyword : %s in locale id: %s for display locale: %s \n", testCases[i].localeID, keyword, testCases[i].displayLocale);
+ }
+ break;
+ }
+ }else{
+ log_err("uloc_getDisplayKeyword did not return the expected error. Error: %s\n", u_errorName(status));
+ }
+
+ free(displayKeyword);
+
+ }
+ uenum_close(keywordEnum);
+ }
+}
+
+static void TestDisplayKeywordValues(void){
+ int32_t i;
+
+ static const struct {
+ const char *localeID;
+ const char *displayLocale;
+ UChar displayKeywordValue[500];
+ } testCases[] = {
+ { "ca_ES@currency=ESP", "de_AT",
+ {0x0053, 0x0070, 0x0061, 0x006e, 0x0069, 0x0073, 0x0063, 0x0068, 0x0065, 0x0020, 0x0050, 0x0065, 0x0073, 0x0065, 0x0074, 0x0061, 0x0000}
+ },
+ { "de_AT@currency=ATS", "fr_FR",
+ {0x0073, 0x0063, 0x0068, 0x0069, 0x006c, 0x006c, 0x0069, 0x006e, 0x0067, 0x0020, 0x0061, 0x0075, 0x0074, 0x0072, 0x0069, 0x0063, 0x0068, 0x0069, 0x0065, 0x006e, 0x0000}
+ },
+ { "de_DE@currency=DEM", "it",
+ {0x004d, 0x0061, 0x0072, 0x0063, 0x006f, 0x0020, 0x0054, 0x0065, 0x0064, 0x0065, 0x0073, 0x0063, 0x006f, 0x0000}
+ },
+ { "el_GR@currency=GRD", "en",
+ {0x0047, 0x0072, 0x0065, 0x0065, 0x006b, 0x0020, 0x0044, 0x0072, 0x0061, 0x0063, 0x0068, 0x006d, 0x0061, 0x0000}
+ },
+ { "eu_ES@currency=ESP", "it_IT",
+ {0x0050, 0x0065, 0x0073, 0x0065, 0x0074, 0x0061, 0x0020, 0x0053, 0x0070, 0x0061, 0x0067, 0x006e, 0x006f, 0x006c, 0x0061, 0x0000}
+ },
+ { "de@collation=phonebook", "es",
+ {0x006F, 0x0072, 0x0064, 0x0065, 0x006E, 0x0020, 0x0064, 0x0065, 0x0020, 0x006C, 0x0069, 0x0073, 0x0074, 0x00ED, 0x006E, 0x0020, 0x0074, 0x0065, 0x006C, 0x0065, 0x0066, 0x00F3, 0x006E, 0x0069, 0x0063, 0x006F, 0x0000}
+ },
+
+ { "de_DE@collation=phonebook", "es",
+ {0x006F, 0x0072, 0x0064, 0x0065, 0x006E, 0x0020, 0x0064, 0x0065, 0x0020, 0x006C, 0x0069, 0x0073, 0x0074, 0x00ED, 0x006E, 0x0020, 0x0074, 0x0065, 0x006C, 0x0065, 0x0066, 0x00F3, 0x006E, 0x0069, 0x0063, 0x006F, 0x0000}
+ },
+ { "es_ES@collation=traditional","de",
+ {0x0054, 0x0072, 0x0061, 0x0064, 0x0069, 0x0074, 0x0069, 0x006f, 0x006e, 0x0065, 0x006c, 0x006c, 0x0065, 0x0020, 0x0053, 0x006f, 0x0072, 0x0074, 0x0069, 0x0065, 0x0072, 0x0072, 0x0065, 0x0067, 0x0065, 0x006c, 0x006e, 0x0000}
+ },
+ { "ja_JP@calendar=japanese", "de",
+ {0x004a, 0x0061, 0x0070, 0x0061, 0x006e, 0x0069, 0x0073, 0x0063, 0x0068, 0x0065, 0x0072, 0x0020, 0x004b, 0x0061, 0x006c, 0x0065, 0x006e, 0x0064, 0x0065, 0x0072, 0x0000}
+ },
+ };
+ for(i = 0; i < sizeof(testCases)/sizeof(testCases[0]); i++) {
+ UErrorCode status = U_ZERO_ERROR;
+ const char* keyword =NULL;
+ int32_t keywordLen = 0;
+ int32_t keywordCount = 0;
+ UChar *displayKeywordValue = NULL;
+ int32_t displayKeywordValueLen = 0;
+ UEnumeration* keywordEnum = uloc_openKeywords(testCases[i].localeID, &status);
+ for(keywordCount = uenum_count(keywordEnum, &status); keywordCount > 0 ; keywordCount--){
+ if(U_FAILURE(status)){
+ log_err("uloc_getKeywords failed for locale id: %s in display locale: % with error : %s \n", testCases[i].localeID, testCases[i].displayLocale, u_errorName(status));
+ break;
+ }
+ /* the uenum_next returns NUL terminated string */
+ keyword = uenum_next(keywordEnum, &keywordLen, &status);
+
+ /* fetch the displayKeywordValue */
+ displayKeywordValueLen = uloc_getDisplayKeywordValue(testCases[i].localeID, keyword, testCases[i].displayLocale, displayKeywordValue, displayKeywordValueLen, &status);
+ if(status==U_BUFFER_OVERFLOW_ERROR){
+ status = U_ZERO_ERROR;
+ displayKeywordValueLen++; /* for null termination */
+ displayKeywordValue = (UChar*)malloc(displayKeywordValueLen * U_SIZEOF_UCHAR);
+ displayKeywordValueLen = uloc_getDisplayKeywordValue(testCases[i].localeID, keyword, testCases[i].displayLocale, displayKeywordValue, displayKeywordValueLen, &status);
+ if(U_FAILURE(status)){
+ log_err("uloc_getDisplayKeywordValue failed for keyword : %s in locale id: %s for display locale: %s with error : %s \n", testCases[i].localeID, keyword, testCases[i].displayLocale, u_errorName(status));
+ break;
+ }
+ if(u_strncmp(displayKeywordValue, testCases[i].displayKeywordValue, displayKeywordValueLen)!=0){
+ if (status == U_USING_DEFAULT_WARNING) {
+ log_data_err("uloc_getDisplayKeywordValue did not return the expected value keyword : %s in locale id: %s for display locale: %s with error : %s Perhaps you are missing data\n", testCases[i].localeID, keyword, testCases[i].displayLocale, u_errorName(status));
+ } else {
+ log_err("uloc_getDisplayKeywordValue did not return the expected value keyword : %s in locale id: %s for display locale: %s with error : %s \n", testCases[i].localeID, keyword, testCases[i].displayLocale, u_errorName(status));
+ }
+ break;
+ }
+ }else{
+ log_err("uloc_getDisplayKeywordValue did not return the expected error. Error: %s\n", u_errorName(status));
+ }
+ free(displayKeywordValue);
+ }
+ uenum_close(keywordEnum);
+ }
+ {
+ /* test a multiple keywords */
+ UErrorCode status = U_ZERO_ERROR;
+ const char* keyword =NULL;
+ int32_t keywordLen = 0;
+ int32_t keywordCount = 0;
+ const char* localeID = "es@collation=phonebook;calendar=buddhist;currency=DEM";
+ const char* displayLocale = "de";
+ static const UChar expected[][50] = {
+ {0x0042, 0x0075, 0x0064, 0x0064, 0x0068, 0x0069, 0x0073, 0x0074, 0x0069, 0x0073, 0x0063, 0x0068, 0x0065, 0x0072, 0x0020, 0x004b, 0x0061, 0x006c, 0x0065, 0x006e, 0x0064, 0x0065, 0x0072, 0x0000},
+
+ {0x0054, 0x0065, 0x006c, 0x0065, 0x0066, 0x006f, 0x006e, 0x0062, 0x0075, 0x0063, 0x0068, 0x002d, 0x0053, 0x006f, 0x0072, 0x0074, 0x0069, 0x0065, 0x0072, 0x0072, 0x0065, 0x0067, 0x0065, 0x006c, 0x006e, 0x0000},
+ {0x0044, 0x0065, 0x0075, 0x0074, 0x0073, 0x0063, 0x0068, 0x0065, 0x0020, 0x004d, 0x0061, 0x0072, 0x006b, 0x0000},
+ };
+
+ UEnumeration* keywordEnum = uloc_openKeywords(localeID, &status);
+
+ for(keywordCount = 0; keywordCount < uenum_count(keywordEnum, &status) ; keywordCount++){
+ UChar *displayKeywordValue = NULL;
+ int32_t displayKeywordValueLen = 0;
+ if(U_FAILURE(status)){
+ log_err("uloc_getKeywords failed for locale id: %s in display locale: % with error : %s \n", localeID, displayLocale, u_errorName(status));
+ break;
+ }
+ /* the uenum_next returns NUL terminated string */
+ keyword = uenum_next(keywordEnum, &keywordLen, &status);
+
+ /* fetch the displayKeywordValue */
+ displayKeywordValueLen = uloc_getDisplayKeywordValue(localeID, keyword, displayLocale, displayKeywordValue, displayKeywordValueLen, &status);
+ if(status==U_BUFFER_OVERFLOW_ERROR){
+ status = U_ZERO_ERROR;
+ displayKeywordValueLen++; /* for null termination */
+ displayKeywordValue = (UChar*)malloc(displayKeywordValueLen * U_SIZEOF_UCHAR);
+ displayKeywordValueLen = uloc_getDisplayKeywordValue(localeID, keyword, displayLocale, displayKeywordValue, displayKeywordValueLen, &status);
+ if(U_FAILURE(status)){
+ log_err("uloc_getDisplayKeywordValue failed for keyword : %s in locale id: %s for display locale: %s with error : %s \n", localeID, keyword, displayLocale, u_errorName(status));
+ break;
+ }
+ if(u_strncmp(displayKeywordValue, expected[keywordCount], displayKeywordValueLen)!=0){
+ if (status == U_USING_DEFAULT_WARNING) {
+ log_data_err("uloc_getDisplayKeywordValue did not return the expected value keyword : %s in locale id: %s for display locale: %s got error: %s. Perhaps you are missing data?\n", localeID, keyword, displayLocale, u_errorName(status));
+ } else {
+ log_err("uloc_getDisplayKeywordValue did not return the expected value keyword : %s in locale id: %s for display locale: %s \n", localeID, keyword, displayLocale);
+ }
+ break;
+ }
+ }else{
+ log_err("uloc_getDisplayKeywordValue did not return the expected error. Error: %s\n", u_errorName(status));
+ }
+ free(displayKeywordValue);
+ }
+ uenum_close(keywordEnum);
+
+ }
+ {
+ /* Test non existent keywords */
+ UErrorCode status = U_ZERO_ERROR;
+ const char* localeID = "es";
+ const char* displayLocale = "de";
+ UChar *displayKeywordValue = NULL;
+ int32_t displayKeywordValueLen = 0;
+
+ /* fetch the displayKeywordValue */
+ displayKeywordValueLen = uloc_getDisplayKeywordValue(localeID, "calendar", displayLocale, displayKeywordValue, displayKeywordValueLen, &status);
+ if(U_FAILURE(status)) {
+ log_err("uloc_getDisplaykeywordValue returned error status %s\n", u_errorName(status));
+ } else if(displayKeywordValueLen != 0) {
+ log_err("uloc_getDisplaykeywordValue returned %d should be 0 \n", displayKeywordValueLen);
+ }
+ }
+}
+
+
+static void TestGetBaseName(void) {
+ static const struct {
+ const char *localeID;
+ const char *baseName;
+ } testCases[] = {
+ { "de_DE@ C o ll A t i o n = Phonebook ", "de_DE" },
+ { "de@currency = euro; CoLLaTion = PHONEBOOk", "de" },
+ { "ja@calendar = buddhist", "ja" }
+ };
+
+ int32_t i = 0, baseNameLen = 0;
+ char baseName[256];
+ UErrorCode status = U_ZERO_ERROR;
+
+ for(i = 0; i < sizeof(testCases)/sizeof(testCases[0]); i++) {
+ baseNameLen = uloc_getBaseName(testCases[i].localeID, baseName, 256, &status);
+ if(strcmp(testCases[i].baseName, baseName)) {
+ log_err("For locale \"%s\" expected baseName \"%s\", but got \"%s\"\n",
+ testCases[i].localeID, testCases[i].baseName, baseName);
+ return;
+ }
+ }
+}
+
+static void TestTrailingNull(void) {
+ const char* localeId = "zh_Hans";
+ UChar buffer[128]; /* sufficient for this test */
+ int32_t len;
+ UErrorCode status = U_ZERO_ERROR;
+ int i;
+
+ len = uloc_getDisplayName(localeId, localeId, buffer, 128, &status);
+ if (len > 128) {
+ log_err("buffer too small");
+ return;
+ }
+
+ for (i = 0; i < len; ++i) {
+ if (buffer[i] == 0) {
+ log_err("name contained null");
+ return;
+ }
+ }
+}
+
+/* Jitterbug 4115 */
+static void TestDisplayNameWarning(void) {
+ UChar name[256];
+ int32_t size;
+ UErrorCode status = U_ZERO_ERROR;
+
+ size = uloc_getDisplayLanguage("qqq", "kl", name, sizeof(name)/sizeof(name[0]), &status);
+ if (status != U_USING_DEFAULT_WARNING) {
+ log_err("For language \"qqq\" in locale \"kl\", expecting U_USING_DEFAULT_WARNING, but got %s\n",
+ u_errorName(status));
+ }
+}
+
+
+/**
+ * Compare two locale IDs. If they are equal, return 0. If `string'
+ * starts with `prefix' plus an additional element, that is, string ==
+ * prefix + '_' + x, then return 1. Otherwise return a value < 0.
+ */
+static UBool _loccmp(const char* string, const char* prefix) {
+ int32_t slen = (int32_t)uprv_strlen(string),
+ plen = (int32_t)uprv_strlen(prefix);
+ int32_t c = uprv_strncmp(string, prefix, plen);
+ /* 'root' is less than everything */
+ if (uprv_strcmp(prefix, "root") == 0) {
+ return (uprv_strcmp(string, "root") == 0) ? 0 : 1;
+ }
+ if (c) return -1; /* mismatch */
+ if (slen == plen) return 0;
+ if (string[plen] == '_') return 1;
+ return -2; /* false match, e.g. "en_USX" cmp "en_US" */
+}
+
+static void _checklocs(const char* label,
+ const char* req,
+ const char* valid,
+ const char* actual) {
+ /* We want the valid to be strictly > the bogus requested locale,
+ and the valid to be >= the actual. */
+ if (_loccmp(req, valid) > 0 &&
+ _loccmp(valid, actual) >= 0) {
+ log_verbose("%s; req=%s, valid=%s, actual=%s\n",
+ label, req, valid, actual);
+ } else {
+ log_err("FAIL: %s; req=%s, valid=%s, actual=%s\n",
+ label, req, valid, actual);
+ }
+}
+
+static void TestGetLocale(void) {
+ UErrorCode ec = U_ZERO_ERROR;
+ UParseError pe;
+ UChar EMPTY[1] = {0};
+
+ /* === udat === */
+#if !UCONFIG_NO_FORMATTING
+ {
+ UDateFormat *obj;
+ const char *req = "en_US_REDWOODSHORES", *valid, *actual;
+ obj = udat_open(UDAT_DEFAULT, UDAT_DEFAULT,
+ req,
+ NULL, 0,
+ NULL, 0, &ec);
+ if (U_FAILURE(ec)) {
+ log_data_err("udat_open failed.Error %s\n", u_errorName(ec));
+ return;
+ }
+ valid = udat_getLocaleByType(obj, ULOC_VALID_LOCALE, &ec);
+ actual = udat_getLocaleByType(obj, ULOC_ACTUAL_LOCALE, &ec);
+ if (U_FAILURE(ec)) {
+ log_err("udat_getLocaleByType() failed\n");
+ return;
+ }
+ _checklocs("udat", req, valid, actual);
+ udat_close(obj);
+ }
+#endif
+
+ /* === ucal === */
+#if !UCONFIG_NO_FORMATTING
+ {
+ UCalendar *obj;
+ const char *req = "fr_FR_PROVENCAL", *valid, *actual;
+ obj = ucal_open(NULL, 0,
+ req,
+ UCAL_GREGORIAN,
+ &ec);
+ if (U_FAILURE(ec)) {
+ log_err("ucal_open failed with error: %s\n", u_errorName(ec));
+ return;
+ }
+ valid = ucal_getLocaleByType(obj, ULOC_VALID_LOCALE, &ec);
+ actual = ucal_getLocaleByType(obj, ULOC_ACTUAL_LOCALE, &ec);
+ if (U_FAILURE(ec)) {
+ log_err("ucal_getLocaleByType() failed\n");
+ return;
+ }
+ _checklocs("ucal", req, valid, actual);
+ ucal_close(obj);
+ }
+#endif
+
+ /* === unum === */
+#if !UCONFIG_NO_FORMATTING
+ {
+ UNumberFormat *obj;
+ const char *req = "zh_Hant_TW_TAINAN", *valid, *actual;
+ obj = unum_open(UNUM_DECIMAL,
+ NULL, 0,
+ req,
+ &pe, &ec);
+ if (U_FAILURE(ec)) {
+ log_err("unum_open failed\n");
+ return;
+ }
+ valid = unum_getLocaleByType(obj, ULOC_VALID_LOCALE, &ec);
+ actual = unum_getLocaleByType(obj, ULOC_ACTUAL_LOCALE, &ec);
+ if (U_FAILURE(ec)) {
+ log_err("unum_getLocaleByType() failed\n");
+ return;
+ }
+ _checklocs("unum", req, valid, actual);
+ unum_close(obj);
+ }
+#endif
+
+ /* === umsg === */
+#if 0
+ /* commented out by weiv 01/12/2005. umsg_getLocaleByType is to be removed */
+#if !UCONFIG_NO_FORMATTING
+ {
+ UMessageFormat *obj;
+ const char *req = "ja_JP_TAKAYAMA", *valid, *actual;
+ UBool test;
+ obj = umsg_open(EMPTY, 0,
+ req,
+ &pe, &ec);
+ if (U_FAILURE(ec)) {
+ log_err("umsg_open failed\n");
+ return;
+ }
+ valid = umsg_getLocaleByType(obj, ULOC_VALID_LOCALE, &ec);
+ actual = umsg_getLocaleByType(obj, ULOC_ACTUAL_LOCALE, &ec);
+ if (U_FAILURE(ec)) {
+ log_err("umsg_getLocaleByType() failed\n");
+ return;
+ }
+ /* We want the valid to be strictly > the bogus requested locale,
+ and the valid to be >= the actual. */
+ /* TODO MessageFormat is currently just storing the locale it is given.
+ As a result, it will return whatever it was given, even if the
+ locale is invalid. */
+ test = (_cmpversion("3.2") <= 0) ?
+ /* Here is the weakened test for 3.0: */
+ (_loccmp(req, valid) >= 0) :
+ /* Here is what the test line SHOULD be: */
+ (_loccmp(req, valid) > 0);
+
+ if (test &&
+ _loccmp(valid, actual) >= 0) {
+ log_verbose("umsg; req=%s, valid=%s, actual=%s\n", req, valid, actual);
+ } else {
+ log_err("FAIL: umsg; req=%s, valid=%s, actual=%s\n", req, valid, actual);
+ }
+ umsg_close(obj);
+ }
+#endif
+#endif
+
+ /* === ubrk === */
+#if !UCONFIG_NO_BREAK_ITERATION
+ {
+ UBreakIterator *obj;
+ const char *req = "ar_KW_ABDALI", *valid, *actual;
+ obj = ubrk_open(UBRK_WORD,
+ req,
+ EMPTY,
+ 0,
+ &ec);
+ if (U_FAILURE(ec)) {
+ log_err("ubrk_open failed. Error: %s \n", u_errorName(ec));
+ return;
+ }
+ valid = ubrk_getLocaleByType(obj, ULOC_VALID_LOCALE, &ec);
+ actual = ubrk_getLocaleByType(obj, ULOC_ACTUAL_LOCALE, &ec);
+ if (U_FAILURE(ec)) {
+ log_err("ubrk_getLocaleByType() failed\n");
+ return;
+ }
+ _checklocs("ubrk", req, valid, actual);
+ ubrk_close(obj);
+ }
+#endif
+
+ /* === ucol === */
+#if !UCONFIG_NO_COLLATION
+ {
+ UCollator *obj;
+ const char *req = "es_AR_BUENOSAIRES", *valid, *actual;
+ obj = ucol_open(req, &ec);
+ if (U_FAILURE(ec)) {
+ log_err("ucol_open failed - %s\n", u_errorName(ec));
+ return;
+ }
+ valid = ucol_getLocaleByType(obj, ULOC_VALID_LOCALE, &ec);
+ actual = ucol_getLocaleByType(obj, ULOC_ACTUAL_LOCALE, &ec);
+ if (U_FAILURE(ec)) {
+ log_err("ucol_getLocaleByType() failed\n");
+ return;
+ }
+ _checklocs("ucol", req, valid, actual);
+ ucol_close(obj);
+ }
+#endif
+}
+
+static void TestNonexistentLanguageExemplars(void) {
+ /* JB 4068 - Nonexistent language */
+ UErrorCode ec = U_ZERO_ERROR;
+ ULocaleData *uld = ulocdata_open("qqq",&ec);
+ if (ec != U_USING_DEFAULT_WARNING) {
+ log_err_status(ec, "Exemplar set for \"qqq\", expecting U_USING_DEFAULT_WARNING, but got %s\n",
+ u_errorName(ec));
+ }
+ uset_close(ulocdata_getExemplarSet(uld, NULL, 0, ULOCDATA_ES_STANDARD, &ec));
+ ulocdata_close(uld);
+}
+
+static void TestLocDataErrorCodeChaining(void) {
+ UErrorCode ec = U_USELESS_COLLATOR_ERROR;
+ ulocdata_open(NULL, &ec);
+ ulocdata_getExemplarSet(NULL, NULL, 0, ULOCDATA_ES_STANDARD, &ec);
+ ulocdata_getDelimiter(NULL, ULOCDATA_DELIMITER_COUNT, NULL, -1, &ec);
+ ulocdata_getMeasurementSystem(NULL, &ec);
+ ulocdata_getPaperSize(NULL, NULL, NULL, &ec);
+ if (ec != U_USELESS_COLLATOR_ERROR) {
+ log_err("ulocdata API changed the error code to %s\n", u_errorName(ec));
+ }
+}
+
+static void TestLanguageExemplarsFallbacks(void) {
+ /* Test that en_US fallsback, but en doesn't fallback. */
+ UErrorCode ec = U_ZERO_ERROR;
+ ULocaleData *uld = ulocdata_open("en_US",&ec);
+ uset_close(ulocdata_getExemplarSet(uld, NULL, 0, ULOCDATA_ES_STANDARD, &ec));
+ if (ec != U_USING_FALLBACK_WARNING) {
+ log_err_status(ec, "Exemplar set for \"en_US\", expecting U_USING_FALLBACK_WARNING, but got %s\n",
+ u_errorName(ec));
+ }
+ ulocdata_close(uld);
+ ec = U_ZERO_ERROR;
+ uld = ulocdata_open("en",&ec);
+ uset_close(ulocdata_getExemplarSet(uld, NULL, 0, ULOCDATA_ES_STANDARD, &ec));
+ if (ec != U_ZERO_ERROR) {
+ log_err_status(ec, "Exemplar set for \"en\", expecting U_ZERO_ERROR, but got %s\n",
+ u_errorName(ec));
+ }
+ ulocdata_close(uld);
+}
+
+static const char *acceptResult(UAcceptResult uar) {
+ return udbg_enumName(UDBG_UAcceptResult, uar);
+}
+
+static void TestAcceptLanguage(void) {
+ UErrorCode status = U_ZERO_ERROR;
+ UAcceptResult outResult;
+ UEnumeration *available;
+ char tmp[200];
+ int i;
+ int32_t rc = 0;
+
+ struct {
+ int32_t httpSet; /**< Which of http[] should be used? */
+ const char *icuSet; /**< ? */
+ const char *expect; /**< The expected locale result */
+ UAcceptResult res; /**< The expected error code */
+ } tests[] = {
+ /*0*/{ 0, NULL, "mt_MT", ULOC_ACCEPT_VALID },
+ /*1*/{ 1, NULL, "en", ULOC_ACCEPT_VALID },
+ /*2*/{ 2, NULL, "en", ULOC_ACCEPT_FALLBACK },
+ /*3*/{ 3, NULL, "", ULOC_ACCEPT_FAILED },
+ /*4*/{ 4, NULL, "es", ULOC_ACCEPT_VALID },
+
+ /*5*/{ 5, NULL, "en", ULOC_ACCEPT_VALID }, /* XF */
+ /*6*/{ 6, NULL, "ja", ULOC_ACCEPT_FALLBACK }, /* XF */
+ /*7*/{ 7, NULL, "zh", ULOC_ACCEPT_FALLBACK }, /* XF */
+ };
+ const int32_t numTests = sizeof(tests)/sizeof(tests[0]);
+ static const char *http[] = {
+ /*0*/ "mt-mt, ja;q=0.76, en-us;q=0.95, en;q=0.92, en-gb;q=0.89, fr;q=0.87, iu-ca;q=0.84, iu;q=0.82, ja-jp;q=0.79, mt;q=0.97, de-de;q=0.74, de;q=0.71, es;q=0.68, it-it;q=0.66, it;q=0.63, vi-vn;q=0.61, vi;q=0.58, nl-nl;q=0.55, nl;q=0.53, th-th-traditional;q=.01",
+ /*1*/ "ja;q=0.5, en;q=0.8, tlh",
+ /*2*/ "en-wf, de-lx;q=0.8",
+ /*3*/ "mga-ie;q=0.9, tlh",
+ /*4*/ "xxx-yyy;q=.01, xxx-yyy;q=.01, xxx-yyy;q=.01, xxx-yyy;q=.01, xxx-yyy;q=.01, "
+ "xxx-yyy;q=.01, xxx-yyy;q=.01, xxx-yyy;q=.01, xxx-yyy;q=.01, xxx-yyy;q=.01, "
+ "xxx-yyy;q=.01, xxx-yyy;q=.01, xxx-yyy;q=.01, xxx-yyy;q=.01, xxx-yyy;q=.01, "
+ "xxx-yyy;q=.01, xxx-yyy;q=.01, xxx-yyy;q=.01, xxx-yyy;q=.01, xxx-yyy;q=.01, "
+ "xxx-yyy;q=.01, xxx-yyy;q=.01, xxx-yyy;q=.01, xxx-yyy;q=.01, xxx-yyy;q=.01, "
+ "xxx-yyy;q=.01, xxx-yyy;q=.01, xxx-yyy;q=.01, xxx-yyy;q=.01, xxx-yyy;q=.01, "
+ "xxx-yyy;q=.01, xxx-yyy;q=.01, xxx-yyy;q=.01, xx-yy;q=.1, "
+ "es",
+
+ /*5*/ "zh-xx;q=0.9, en;q=0.6",
+ /*6*/ "ja-JA",
+ /*7*/ "zh-xx;q=0.9",
+ };
+
+ for(i=0;i<numTests;i++) {
+ outResult = -3;
+ status=U_ZERO_ERROR;
+ log_verbose("test #%d: http[%s], ICU[%s], expect %s, %s\n",
+ i, http[tests[i].httpSet], tests[i].icuSet, tests[i].expect, acceptResult(tests[i].res));
+
+ available = ures_openAvailableLocales(tests[i].icuSet, &status);
+ tmp[0]=0;
+ rc = uloc_acceptLanguageFromHTTP(tmp, 199, &outResult, http[tests[i].httpSet], available, &status);
+ uenum_close(available);
+ log_verbose(" got %s, %s [%s]\n", tmp[0]?tmp:"(EMPTY)", acceptResult(outResult), u_errorName(status));
+ if(outResult != tests[i].res) {
+ log_err_status(status, "FAIL: #%d: expected outResult of %s but got %s\n", i,
+ acceptResult( tests[i].res),
+ acceptResult( outResult));
+ log_info("test #%d: http[%s], ICU[%s], expect %s, %s\n",
+ i, http[tests[i].httpSet], tests[i].icuSet, tests[i].expect,acceptResult(tests[i].res));
+ }
+ if((outResult>0)&&uprv_strcmp(tmp, tests[i].expect)) {
+ log_err_status(status, "FAIL: #%d: expected %s but got %s\n", i, tests[i].expect, tmp);
+ log_info("test #%d: http[%s], ICU[%s], expect %s, %s\n",
+ i, http[tests[i].httpSet], tests[i].icuSet, tests[i].expect, acceptResult(tests[i].res));
+ }
+ }
+}
+
+static const char* LOCALE_ALIAS[][2] = {
+ {"in", "id"},
+ {"in_ID", "id_ID"},
+ {"iw", "he"},
+ {"iw_IL", "he_IL"},
+ {"ji", "yi"},
+ {"en_BU", "en_MM"},
+ {"en_DY", "en_BJ"},
+ {"en_HV", "en_BF"},
+ {"en_NH", "en_VU"},
+ {"en_RH", "en_ZW"},
+ {"en_TP", "en_TL"},
+ {"en_ZR", "en_CD"}
+};
+static UBool isLocaleAvailable(UResourceBundle* resIndex, const char* loc){
+ UErrorCode status = U_ZERO_ERROR;
+ int32_t len = 0;
+ ures_getStringByKey(resIndex, loc,&len, &status);
+ if(U_FAILURE(status)){
+ return FALSE;
+ }
+ return TRUE;
+}
+
+static void TestCalendar() {
+#if !UCONFIG_NO_FORMATTING
+ int i;
+ UErrorCode status = U_ZERO_ERROR;
+ UResourceBundle *resIndex = ures_open(NULL,"res_index", &status);
+ if(U_FAILURE(status)){
+ log_err_status(status, "Could not open res_index.res. Exiting. Error: %s\n", u_errorName(status));
+ return;
+ }
+ for (i=0; i<LENGTHOF(LOCALE_ALIAS); i++) {
+ const char* oldLoc = LOCALE_ALIAS[i][0];
+ const char* newLoc = LOCALE_ALIAS[i][1];
+ UCalendar* c1 = NULL;
+ UCalendar* c2 = NULL;
+
+ /*Test function "getLocale(ULocale.VALID_LOCALE)"*/
+ const char* l1 = ucal_getLocaleByType(c1, ULOC_VALID_LOCALE, &status);
+ const char* l2 = ucal_getLocaleByType(c2, ULOC_VALID_LOCALE, &status);
+
+ if(!isLocaleAvailable(resIndex, newLoc)){
+ continue;
+ }
+ c1 = ucal_open(NULL, -1, oldLoc, UCAL_GREGORIAN, &status);
+ c2 = ucal_open(NULL, -1, newLoc, UCAL_GREGORIAN, &status);
+
+ if (strcmp(newLoc,l1)!=0 || strcmp(l1,l2)!=0 || status!=U_ZERO_ERROR) {
+ log_err("The locales are not equal!.Old: %s, New: %s \n", oldLoc, newLoc);
+ }
+ log_verbose("ucal_getLocaleByType old:%s new:%s\n", l1, l2);
+ ucal_close(c1);
+ ucal_close(c2);
+ }
+ ures_close(resIndex);
+#endif
+}
+
+static void TestDateFormat() {
+#if !UCONFIG_NO_FORMATTING
+ int i;
+ UErrorCode status = U_ZERO_ERROR;
+ UResourceBundle *resIndex = ures_open(NULL,"res_index", &status);
+ if(U_FAILURE(status)){
+ log_err_status(status, "Could not open res_index.res. Exiting. Error: %s\n", u_errorName(status));
+ return;
+ }
+ for (i=0; i<LENGTHOF(LOCALE_ALIAS); i++) {
+ const char* oldLoc = LOCALE_ALIAS[i][0];
+ const char* newLoc = LOCALE_ALIAS[i][1];
+ UDateFormat* df1 = NULL;
+ UDateFormat* df2 = NULL;
+ const char* l1 = NULL;
+ const char* l2 = NULL;
+
+ if(!isLocaleAvailable(resIndex, newLoc)){
+ continue;
+ }
+ df1 = udat_open(UDAT_FULL, UDAT_FULL,oldLoc, NULL, 0, NULL, -1, &status);
+ df2 = udat_open(UDAT_FULL, UDAT_FULL,newLoc, NULL, 0, NULL, -1, &status);
+ if(U_FAILURE(status)){
+ log_err("Creation of date format failed %s\n", u_errorName(status));
+ return;
+ }
+ /*Test function "getLocale"*/
+ l1 = udat_getLocaleByType(df1, ULOC_VALID_LOCALE, &status);
+ l2 = udat_getLocaleByType(df2, ULOC_VALID_LOCALE, &status);
+ if(U_FAILURE(status)){
+ log_err("Fetching the locale by type failed. %s\n", u_errorName(status));
+ }
+ if (strcmp(newLoc,l1)!=0 || strcmp(l1,l2)!=0) {
+ log_err("The locales are not equal!.Old: %s, New: %s \n", oldLoc, newLoc);
+ }
+ log_verbose("udat_getLocaleByType old:%s new:%s\n", l1, l2);
+ udat_close(df1);
+ udat_close(df2);
+ }
+ ures_close(resIndex);
+#endif
+}
+
+static void TestCollation() {
+#if !UCONFIG_NO_COLLATION
+ int i;
+ UErrorCode status = U_ZERO_ERROR;
+ UResourceBundle *resIndex = ures_open(NULL,"res_index", &status);
+ if(U_FAILURE(status)){
+ log_err_status(status, "Could not open res_index.res. Exiting. Error: %s\n", u_errorName(status));
+ return;
+ }
+ for (i=0; i<LENGTHOF(LOCALE_ALIAS); i++) {
+ const char* oldLoc = LOCALE_ALIAS[i][0];
+ const char* newLoc = LOCALE_ALIAS[i][1];
+ UCollator* c1 = NULL;
+ UCollator* c2 = NULL;
+ const char* l1 = NULL;
+ const char* l2 = NULL;
+
+ status = U_ZERO_ERROR;
+ if(!isLocaleAvailable(resIndex, newLoc)){
+ continue;
+ }
+ if(U_FAILURE(status)){
+ log_err("Creation of collators failed %s\n", u_errorName(status));
+ return;
+ }
+ c1 = ucol_open(oldLoc, &status);
+ c2 = ucol_open(newLoc, &status);
+ l1 = ucol_getLocaleByType(c1, ULOC_VALID_LOCALE, &status);
+ l2 = ucol_getLocaleByType(c2, ULOC_VALID_LOCALE, &status);
+ if(U_FAILURE(status)){
+ log_err("Fetching the locale names failed failed %s\n", u_errorName(status));
+ }
+ if (strcmp(newLoc,l1)!=0 || strcmp(l1,l2)!=0) {
+ log_err("The locales are not equal!.Old: %s, New: %s \n", oldLoc, newLoc);
+ }
+ log_verbose("ucol_getLocaleByType old:%s new:%s\n", l1, l2);
+ ucol_close(c1);
+ ucol_close(c2);
+ }
+ ures_close(resIndex);
+#endif
+}
+
+typedef struct OrientationStructTag {
+ const char* localeId;
+ ULayoutType character;
+ ULayoutType line;
+} OrientationStruct;
+
+static const char* ULayoutTypeToString(ULayoutType type)
+{
+ switch(type)
+ {
+ case ULOC_LAYOUT_LTR:
+ return "ULOC_LAYOUT_LTR";
+ break;
+ case ULOC_LAYOUT_RTL:
+ return "ULOC_LAYOUT_RTL";
+ break;
+ case ULOC_LAYOUT_TTB:
+ return "ULOC_LAYOUT_TTB";
+ break;
+ case ULOC_LAYOUT_BTT:
+ return "ULOC_LAYOUT_BTT";
+ break;
+ case ULOC_LAYOUT_UNKNOWN:
+ break;
+ }
+
+ return "Unknown enum value for ULayoutType!";
+}
+
+static void TestOrientation()
+{
+ static const OrientationStruct toTest [] = {
+ { "ar", ULOC_LAYOUT_RTL, ULOC_LAYOUT_TTB },
+ { "aR", ULOC_LAYOUT_RTL, ULOC_LAYOUT_TTB },
+ { "ar_Arab", ULOC_LAYOUT_RTL, ULOC_LAYOUT_TTB },
+ { "fa", ULOC_LAYOUT_RTL, ULOC_LAYOUT_TTB },
+ { "Fa", ULOC_LAYOUT_RTL, ULOC_LAYOUT_TTB },
+ { "he", ULOC_LAYOUT_RTL, ULOC_LAYOUT_TTB },
+ { "ps", ULOC_LAYOUT_RTL, ULOC_LAYOUT_TTB },
+ { "ur", ULOC_LAYOUT_RTL, ULOC_LAYOUT_TTB },
+ { "UR", ULOC_LAYOUT_RTL, ULOC_LAYOUT_TTB },
+ { "en", ULOC_LAYOUT_LTR, ULOC_LAYOUT_TTB }
+ };
+
+ size_t i = 0;
+ for (; i < sizeof(toTest) / sizeof(toTest[0]); ++i) {
+ UErrorCode statusCO = U_ZERO_ERROR;
+ UErrorCode statusLO = U_ZERO_ERROR;
+ const char* const localeId = toTest[i].localeId;
+ const ULayoutType co = uloc_getCharacterOrientation(localeId, &statusCO);
+ const ULayoutType expectedCO = toTest[i].character;
+ const ULayoutType lo = uloc_getLineOrientation(localeId, &statusLO);
+ const ULayoutType expectedLO = toTest[i].line;
+ if (U_FAILURE(statusCO)) {
+ log_err_status(statusCO,
+ " unexpected failure for uloc_getCharacterOrientation(), with localId \"%s\" and status %s\n",
+ localeId,
+ u_errorName(statusCO));
+ }
+ else if (co != expectedCO) {
+ log_err(
+ " unexpected result for uloc_getCharacterOrientation(), with localeId \"%s\". Expected %s but got result %s\n",
+ localeId,
+ ULayoutTypeToString(expectedCO),
+ ULayoutTypeToString(co));
+ }
+ if (U_FAILURE(statusLO)) {
+ log_err_status(statusLO,
+ " unexpected failure for uloc_getLineOrientation(), with localId \"%s\" and status %s\n",
+ localeId,
+ u_errorName(statusLO));
+ }
+ else if (lo != expectedLO) {
+ log_err(
+ " unexpected result for uloc_getLineOrientation(), with localeId \"%s\". Expected %s but got result %s\n",
+ localeId,
+ ULayoutTypeToString(expectedLO),
+ ULayoutTypeToString(lo));
+ }
+ }
+}
+
+static void TestULocale() {
+ int i;
+ UErrorCode status = U_ZERO_ERROR;
+ UResourceBundle *resIndex = ures_open(NULL,"res_index", &status);
+ if(U_FAILURE(status)){
+ log_err_status(status, "Could not open res_index.res. Exiting. Error: %s\n", u_errorName(status));
+ return;
+ }
+ for (i=0; i<LENGTHOF(LOCALE_ALIAS); i++) {
+ const char* oldLoc = LOCALE_ALIAS[i][0];
+ const char* newLoc = LOCALE_ALIAS[i][1];
+ UChar name1[256], name2[256];
+ char names1[256], names2[256];
+ int32_t capacity = 256;
+
+ status = U_ZERO_ERROR;
+ if(!isLocaleAvailable(resIndex, newLoc)){
+ continue;
+ }
+ uloc_getDisplayName(oldLoc, ULOC_US, name1, capacity, &status);
+ if(U_FAILURE(status)){
+ log_err("uloc_getDisplayName(%s) failed %s\n", oldLoc, u_errorName(status));
+ }
+
+ uloc_getDisplayName(newLoc, ULOC_US, name2, capacity, &status);
+ if(U_FAILURE(status)){
+ log_err("uloc_getDisplayName(%s) failed %s\n", newLoc, u_errorName(status));
+ }
+
+ if (u_strcmp(name1, name2)!=0) {
+ log_err("The locales are not equal!.Old: %s, New: %s \n", oldLoc, newLoc);
+ }
+ u_austrcpy(names1, name1);
+ u_austrcpy(names2, name2);
+ log_verbose("uloc_getDisplayName old:%s new:%s\n", names1, names2);
+ }
+ ures_close(resIndex);
+
+}
+
+static void TestUResourceBundle() {
+ const char* us1;
+ const char* us2;
+
+ UResourceBundle* rb1 = NULL;
+ UResourceBundle* rb2 = NULL;
+ UErrorCode status = U_ZERO_ERROR;
+ int i;
+ UResourceBundle *resIndex = NULL;
+ if(U_FAILURE(status)){
+ log_err("Could not open res_index.res. Exiting. Error: %s\n", u_errorName(status));
+ return;
+ }
+ resIndex = ures_open(NULL,"res_index", &status);
+ for (i=0; i<LENGTHOF(LOCALE_ALIAS); i++) {
+
+ const char* oldLoc = LOCALE_ALIAS[i][0];
+ const char* newLoc = LOCALE_ALIAS[i][1];
+ if(!isLocaleAvailable(resIndex, newLoc)){
+ continue;
+ }
+ rb1 = ures_open(NULL, oldLoc, &status);
+ if (U_FAILURE(status)) {
+ log_err("ures_open(%s) failed %s\n", oldLoc, u_errorName(status));
+ }
+
+ us1 = ures_getLocaleByType(rb1, ULOC_ACTUAL_LOCALE, &status);
+
+ status = U_ZERO_ERROR;
+ rb2 = ures_open(NULL, newLoc, &status);
+ if (U_FAILURE(status)) {
+ log_err("ures_open(%s) failed %s\n", oldLoc, u_errorName(status));
+ }
+ us2 = ures_getLocaleByType(rb2, ULOC_ACTUAL_LOCALE, &status);
+
+ if (strcmp(us1,newLoc)!=0 || strcmp(us1,us2)!=0 ) {
+ log_err("The locales are not equal!.Old: %s, New: %s \n", oldLoc, newLoc);
+ }
+
+ log_verbose("ures_getStringByKey old:%s new:%s\n", us1, us2);
+ ures_close(rb1);
+ rb1 = NULL;
+ ures_close(rb2);
+ rb2 = NULL;
+ }
+ ures_close(resIndex);
+}
+
+static void TestDisplayName() {
+
+ UChar oldCountry[256] = {'\0'};
+ UChar newCountry[256] = {'\0'};
+ UChar oldLang[256] = {'\0'};
+ UChar newLang[256] = {'\0'};
+ char country[256] ={'\0'};
+ char language[256] ={'\0'};
+ int32_t capacity = 256;
+ int i =0;
+ int j=0;
+ for (i=0; i<LENGTHOF(LOCALE_ALIAS); i++) {
+ const char* oldLoc = LOCALE_ALIAS[i][0];
+ const char* newLoc = LOCALE_ALIAS[i][1];
+ UErrorCode status = U_ZERO_ERROR;
+ int32_t available = uloc_countAvailable();
+
+ for(j=0; j<available; j++){
+
+ const char* dispLoc = uloc_getAvailable(j);
+ int32_t oldCountryLen = uloc_getDisplayCountry(oldLoc,dispLoc, oldCountry, capacity, &status);
+ int32_t newCountryLen = uloc_getDisplayCountry(newLoc, dispLoc, newCountry, capacity, &status);
+ int32_t oldLangLen = uloc_getDisplayLanguage(oldLoc, dispLoc, oldLang, capacity, &status);
+ int32_t newLangLen = uloc_getDisplayLanguage(newLoc, dispLoc, newLang, capacity, &status );
+
+ int32_t countryLen = uloc_getCountry(newLoc, country, capacity, &status);
+ int32_t langLen = uloc_getLanguage(newLoc, language, capacity, &status);
+ /* there is a display name for the current country ID */
+ if(countryLen != newCountryLen ){
+ if(u_strncmp(oldCountry,newCountry,oldCountryLen)!=0){
+ log_err("uloc_getDisplayCountry() failed for %s in display locale %s \n", oldLoc, dispLoc);
+ }
+ }
+ /* there is a display name for the current lang ID */
+ if(langLen!=newLangLen){
+ if(u_strncmp(oldLang,newLang,oldLangLen)){
+ log_err("uloc_getDisplayLanguage() failed for %s in display locale %s \n", oldLoc, dispLoc); }
+ }
+ }
+ }
+}
+
+static void TestGetLocaleForLCID() {
+ int32_t i, length, lengthPre;
+ const char* testLocale = 0;
+ UErrorCode status = U_ZERO_ERROR;
+ char temp2[40], temp3[40];
+ uint32_t lcid;
+
+ lcid = uloc_getLCID("en_US");
+ if (lcid != 0x0409) {
+ log_err(" uloc_getLCID(\"en_US\") = %d, expected 0x0409\n", lcid);
+ }
+
+ lengthPre = uloc_getLocaleForLCID(lcid, temp2, 4, &status);
+ if (status != U_BUFFER_OVERFLOW_ERROR) {
+ log_err(" unexpected result from uloc_getLocaleForLCID with small buffer: %s\n", u_errorName(status));
+ }
+ else {
+ status = U_ZERO_ERROR;
+ }
+
+ length = uloc_getLocaleForLCID(lcid, temp2, sizeof(temp2)/sizeof(char), &status);
+ if (U_FAILURE(status)) {
+ log_err(" unexpected result from uloc_getLocaleForLCID(0x0409): %s\n", u_errorName(status));
+ status = U_ZERO_ERROR;
+ }
+
+ if (length != lengthPre) {
+ log_err(" uloc_getLocaleForLCID(0x0409): returned length %d does not match preflight length %d\n", length, lengthPre);
+ }
+
+ length = uloc_getLocaleForLCID(0x12345, temp2, sizeof(temp2)/sizeof(char), &status);
+ if (U_SUCCESS(status)) {
+ log_err(" unexpected result from uloc_getLocaleForLCID(0x12345): %s, status %s\n", temp2, u_errorName(status));
+ }
+ status = U_ZERO_ERROR;
+
+ log_verbose("Testing getLocaleForLCID vs. locale data\n");
+ for (i = 0; i < LOCALE_SIZE; i++) {
+
+ testLocale=rawData2[NAME][i];
+
+ log_verbose("Testing %s ......\n", testLocale);
+
+ sscanf(rawData2[LCID][i], "%x", &lcid);
+ length = uloc_getLocaleForLCID(lcid, temp2, sizeof(temp2)/sizeof(char), &status);
+ if (U_FAILURE(status)) {
+ log_err(" unexpected failure of uloc_getLocaleForLCID(%#04x), status %s\n", lcid, u_errorName(status));
+ status = U_ZERO_ERROR;
+ continue;
+ }
+
+ if (length != uprv_strlen(temp2)) {
+ log_err(" returned length %d not correct for uloc_getLocaleForLCID(%#04x), expected %d\n", length, lcid, uprv_strlen(temp2));
+ }
+
+ /* Compare language, country, script */
+ length = uloc_getLanguage(temp2, temp3, sizeof(temp3)/sizeof(char), &status);
+ if (U_FAILURE(status)) {
+ log_err(" couldn't get language in uloc_getLocaleForLCID(%#04x) = %s, status %s\n", lcid, temp2, u_errorName(status));
+ status = U_ZERO_ERROR;
+ }
+ else if (uprv_strcmp(temp3, rawData2[LANG][i]) && !(uprv_strcmp(temp3, "nn") == 0 && uprv_strcmp(rawData2[VAR][i], "NY") == 0)) {
+ log_err(" language doesn't match expected %s in in uloc_getLocaleForLCID(%#04x) = %s\n", rawData2[LANG][i], lcid, temp2);
+ }
+
+ length = uloc_getScript(temp2, temp3, sizeof(temp3)/sizeof(char), &status);
+ if (U_FAILURE(status)) {
+ log_err(" couldn't get script in uloc_getLocaleForLCID(%#04x) = %s, status %s\n", lcid, temp2, u_errorName(status));
+ status = U_ZERO_ERROR;
+ }
+ else if (uprv_strcmp(temp3, rawData2[SCRIPT][i])) {
+ log_err(" script doesn't match expected %s in in uloc_getLocaleForLCID(%#04x) = %s\n", rawData2[SCRIPT][i], lcid, temp2);
+ }
+
+ length = uloc_getCountry(temp2, temp3, sizeof(temp3)/sizeof(char), &status);
+ if (U_FAILURE(status)) {
+ log_err(" couldn't get country in uloc_getLocaleForLCID(%#04x) = %s, status %s\n", lcid, temp2, u_errorName(status));
+ status = U_ZERO_ERROR;
+ }
+ else if (uprv_strlen(rawData2[CTRY][i]) && uprv_strcmp(temp3, rawData2[CTRY][i])) {
+ log_err(" country doesn't match expected %s in in uloc_getLocaleForLCID(%#04x) = %s\n", rawData2[CTRY][i], lcid, temp2);
+ }
+ }
+
+}
+
+const char* const basic_maximize_data[][2] = {
+ {
+ "zu_Zzzz_Zz",
+ "zu_Latn_ZA",
+ }, {
+ "ZU_Zz",
+ "zu_Latn_ZA"
+ }, {
+ "zu_LATN",
+ "zu_Latn_ZA"
+ }, {
+ "en_Zz",
+ "en_Latn_US"
+ }, {
+ "en_us",
+ "en_Latn_US"
+ }, {
+ "en_Kore",
+ "en_Kore_US"
+ }, {
+ "en_Kore_Zz",
+ "en_Kore_US"
+ }, {
+ "en_Kore_ZA",
+ "en_Kore_ZA"
+ }, {
+ "en_Kore_ZA_POSIX",
+ "en_Kore_ZA_POSIX"
+ }, {
+ "en_Gujr",
+ "en_Gujr_US"
+ }, {
+ "en_ZA",
+ "en_Latn_ZA"
+ }, {
+ "en_Gujr_Zz",
+ "en_Gujr_US"
+ }, {
+ "en_Gujr_ZA",
+ "en_Gujr_ZA"
+ }, {
+ "en_Gujr_ZA_POSIX",
+ "en_Gujr_ZA_POSIX"
+ }, {
+ "en_US_POSIX_1901",
+ "en_Latn_US_POSIX_1901"
+ }, {
+ "en_Latn__POSIX_1901",
+ "en_Latn_US_POSIX_1901"
+ }, {
+ "en__POSIX_1901",
+ "en_Latn_US_POSIX_1901"
+ }, {
+ "de__POSIX_1901",
+ "de_Latn_DE_POSIX_1901"
+ }, {
+ "en_US_BOSTON",
+ "en_Latn_US_BOSTON"
+ }, {
+ "th@calendar=buddhist",
+ "th_Thai_TH@calendar=buddhist"
+ }, {
+ "ar_ZZ",
+ "ar_Arab_EG"
+ }, {
+ "zh",
+ "zh_Hans_CN"
+ }, {
+ "zh_TW",
+ "zh_Hant_TW"
+ }, {
+ "zh_HK",
+ "zh_Hant_HK"
+ }, {
+ "zh_Hant",
+ "zh_Hant_TW"
+ }, {
+ "zh_Zzzz_CN",
+ "zh_Hans_CN"
+ }, {
+ "und_US",
+ "en_Latn_US"
+ }, {
+ "und_HK",
+ "zh_Hant_HK"
+ }, {
+ "zzz",
+ ""
+ }
+};
+
+const char* const basic_minimize_data[][2] = {
+ {
+ "en_Latn_US",
+ "en"
+ }, {
+ "en_Latn_US_POSIX_1901",
+ "en__POSIX_1901"
+ }, {
+ "EN_Latn_US_POSIX_1901",
+ "en__POSIX_1901"
+ }, {
+ "en_Zzzz_US_POSIX_1901",
+ "en__POSIX_1901"
+ }, {
+ "de_Latn_DE_POSIX_1901",
+ "de__POSIX_1901"
+ }, {
+ "und",
+ ""
+ }
+};
+
+const char* const full_data[][3] = {
+ {
+ /* "FROM", */
+ /* "ADD-LIKELY", */
+ /* "REMOVE-LIKELY" */
+ /* }, { */
+ "aa",
+ "aa_Latn_ET",
+ "aa"
+ }, {
+ "af",
+ "af_Latn_ZA",
+ "af"
+ }, {
+ "ak",
+ "ak_Latn_GH",
+ "ak"
+ }, {
+ "am",
+ "am_Ethi_ET",
+ "am"
+ }, {
+ "ar",
+ "ar_Arab_EG",
+ "ar"
+ }, {
+ "as",
+ "as_Beng_IN",
+ "as"
+ }, {
+ "az",
+ "az_Latn_AZ",
+ "az"
+ }, {
+ "be",
+ "be_Cyrl_BY",
+ "be"
+ }, {
+ "bg",
+ "bg_Cyrl_BG",
+ "bg"
+ }, {
+ "bn",
+ "bn_Beng_BD",
+ "bn"
+ }, {
+ "bo",
+ "bo_Tibt_CN",
+ "bo"
+ }, {
+ "bs",
+ "bs_Latn_BA",
+ "bs"
+ }, {
+ "ca",
+ "ca_Latn_ES",
+ "ca"
+ }, {
+ "ch",
+ "ch_Latn_GU",
+ "ch"
+ }, {
+ "chk",
+ "chk_Latn_FM",
+ "chk"
+ }, {
+ "cs",
+ "cs_Latn_CZ",
+ "cs"
+ }, {
+ "cy",
+ "cy_Latn_GB",
+ "cy"
+ }, {
+ "da",
+ "da_Latn_DK",
+ "da"
+ }, {
+ "de",
+ "de_Latn_DE",
+ "de"
+ }, {
+ "dv",
+ "dv_Thaa_MV",
+ "dv"
+ }, {
+ "dz",
+ "dz_Tibt_BT",
+ "dz"
+ }, {
+ "ee",
+ "ee_Latn_GH",
+ "ee"
+ }, {
+ "el",
+ "el_Grek_GR",
+ "el"
+ }, {
+ "en",
+ "en_Latn_US",
+ "en"
+ }, {
+ "es",
+ "es_Latn_ES",
+ "es"
+ }, {
+ "et",
+ "et_Latn_EE",
+ "et"
+ }, {
+ "eu",
+ "eu_Latn_ES",
+ "eu"
+ }, {
+ "fa",
+ "fa_Arab_IR",
+ "fa"
+ }, {
+ "fi",
+ "fi_Latn_FI",
+ "fi"
+ }, {
+ "fil",
+ "fil_Latn_PH",
+ "fil"
+ }, {
+ "fo",
+ "fo_Latn_FO",
+ "fo"
+ }, {
+ "fr",
+ "fr_Latn_FR",
+ "fr"
+ }, {
+ "fur",
+ "fur_Latn_IT",
+ "fur"
+ }, {
+ "ga",
+ "ga_Latn_IE",
+ "ga"
+ }, {
+ "gaa",
+ "gaa_Latn_GH",
+ "gaa"
+ }, {
+ "gl",
+ "gl_Latn_ES",
+ "gl"
+ }, {
+ "gn",
+ "gn_Latn_PY",
+ "gn"
+ }, {
+ "gu",
+ "gu_Gujr_IN",
+ "gu"
+ }, {
+ "ha",
+ "ha_Latn_NG",
+ "ha"
+ }, {
+ "haw",
+ "haw_Latn_US",
+ "haw"
+ }, {
+ "he",
+ "he_Hebr_IL",
+ "he"
+ }, {
+ "hi",
+ "hi_Deva_IN",
+ "hi"
+ }, {
+ "hr",
+ "hr_Latn_HR",
+ "hr"
+ }, {
+ "ht",
+ "ht_Latn_HT",
+ "ht"
+ }, {
+ "hu",
+ "hu_Latn_HU",
+ "hu"
+ }, {
+ "hy",
+ "hy_Armn_AM",
+ "hy"
+ }, {
+ "id",
+ "id_Latn_ID",
+ "id"
+ }, {
+ "ig",
+ "ig_Latn_NG",
+ "ig"
+ }, {
+ "ii",
+ "ii_Yiii_CN",
+ "ii"
+ }, {
+ "is",
+ "is_Latn_IS",
+ "is"
+ }, {
+ "it",
+ "it_Latn_IT",
+ "it"
+ }, {
+ "ja",
+ "ja_Jpan_JP",
+ "ja"
+ }, {
+ "ka",
+ "ka_Geor_GE",
+ "ka"
+ }, {
+ "kaj",
+ "kaj_Latn_NG",
+ "kaj"
+ }, {
+ "kam",
+ "kam_Latn_KE",
+ "kam"
+ }, {
+ "kk",
+ "kk_Cyrl_KZ",
+ "kk"
+ }, {
+ "kl",
+ "kl_Latn_GL",
+ "kl"
+ }, {
+ "km",
+ "km_Khmr_KH",
+ "km"
+ }, {
+ "kn",
+ "kn_Knda_IN",
+ "kn"
+ }, {
+ "ko",
+ "ko_Kore_KR",
+ "ko"
+ }, {
+ "kok",
+ "kok_Deva_IN",
+ "kok"
+ }, {
+ "kpe",
+ "kpe_Latn_LR",
+ "kpe"
+ }, {
+ "ku",
+ "ku_Arab_IQ",
+ "ku"
+ }, {
+ "ky",
+ "ky_Cyrl_KG",
+ "ky"
+ }, {
+ "la",
+ "la_Latn_VA",
+ "la"
+ }, {
+ "ln",
+ "ln_Latn_CD",
+ "ln"
+ }, {
+ "lo",
+ "lo_Laoo_LA",
+ "lo"
+ }, {
+ "lt",
+ "lt_Latn_LT",
+ "lt"
+ }, {
+ "lv",
+ "lv_Latn_LV",
+ "lv"
+ }, {
+ "mg",
+ "mg_Latn_MG",
+ "mg"
+ }, {
+ "mh",
+ "mh_Latn_MH",
+ "mh"
+ }, {
+ "mk",
+ "mk_Cyrl_MK",
+ "mk"
+ }, {
+ "ml",
+ "ml_Mlym_IN",
+ "ml"
+ }, {
+ "mn",
+ "mn_Cyrl_MN",
+ "mn"
+ }, {
+ "mr",
+ "mr_Deva_IN",
+ "mr"
+ }, {
+ "ms",
+ "ms_Latn_MY",
+ "ms"
+ }, {
+ "mt",
+ "mt_Latn_MT",
+ "mt"
+ }, {
+ "my",
+ "my_Mymr_MM",
+ "my"
+ }, {
+ "na",
+ "na_Latn_NR",
+ "na"
+ }, {
+ "ne",
+ "ne_Deva_NP",
+ "ne"
+ }, {
+ "niu",
+ "niu_Latn_NU",
+ "niu"
+ }, {
+ "nl",
+ "nl_Latn_NL",
+ "nl"
+ }, {
+ "nn",
+ "nn_Latn_NO",
+ "nn"
+ }, {
+ "nr",
+ "nr_Latn_ZA",
+ "nr"
+ }, {
+ "nso",
+ "nso_Latn_ZA",
+ "nso"
+ }, {
+ "ny",
+ "ny_Latn_MW",
+ "ny"
+ }, {
+ "om",
+ "om_Latn_ET",
+ "om"
+ }, {
+ "or",
+ "or_Orya_IN",
+ "or"
+ }, {
+ "pa",
+ "pa_Guru_IN",
+ "pa"
+ }, {
+ "pa_Arab",
+ "pa_Arab_PK",
+ "pa_PK"
+ }, {
+ "pa_PK",
+ "pa_Arab_PK",
+ "pa_PK"
+ }, {
+ "pap",
+ "pap_Latn_AN",
+ "pap"
+ }, {
+ "pau",
+ "pau_Latn_PW",
+ "pau"
+ }, {
+ "pl",
+ "pl_Latn_PL",
+ "pl"
+ }, {
+ "ps",
+ "ps_Arab_AF",
+ "ps"
+ }, {
+ "pt",
+ "pt_Latn_BR",
+ "pt"
+ }, {
+ "rn",
+ "rn_Latn_BI",
+ "rn"
+ }, {
+ "ro",
+ "ro_Latn_RO",
+ "ro"
+ }, {
+ "ru",
+ "ru_Cyrl_RU",
+ "ru"
+ }, {
+ "rw",
+ "rw_Latn_RW",
+ "rw"
+ }, {
+ "sa",
+ "sa_Deva_IN",
+ "sa"
+ }, {
+ "se",
+ "se_Latn_NO",
+ "se"
+ }, {
+ "sg",
+ "sg_Latn_CF",
+ "sg"
+ }, {
+ "si",
+ "si_Sinh_LK",
+ "si"
+ }, {
+ "sid",
+ "sid_Latn_ET",
+ "sid"
+ }, {
+ "sk",
+ "sk_Latn_SK",
+ "sk"
+ }, {
+ "sl",
+ "sl_Latn_SI",
+ "sl"
+ }, {
+ "sm",
+ "sm_Latn_WS",
+ "sm"
+ }, {
+ "so",
+ "so_Latn_SO",
+ "so"
+ }, {
+ "sq",
+ "sq_Latn_AL",
+ "sq"
+ }, {
+ "sr",
+ "sr_Cyrl_RS",
+ "sr"
+ }, {
+ "ss",
+ "ss_Latn_ZA",
+ "ss"
+ }, {
+ "st",
+ "st_Latn_ZA",
+ "st"
+ }, {
+ "sv",
+ "sv_Latn_SE",
+ "sv"
+ }, {
+ "sw",
+ "sw_Latn_TZ",
+ "sw"
+ }, {
+ "ta",
+ "ta_Taml_IN",
+ "ta"
+ }, {
+ "te",
+ "te_Telu_IN",
+ "te"
+ }, {
+ "tet",
+ "tet_Latn_TL",
+ "tet"
+ }, {
+ "tg",
+ "tg_Cyrl_TJ",
+ "tg"
+ }, {
+ "th",
+ "th_Thai_TH",
+ "th"
+ }, {
+ "ti",
+ "ti_Ethi_ET",
+ "ti"
+ }, {
+ "tig",
+ "tig_Ethi_ER",
+ "tig"
+ }, {
+ "tk",
+ "tk_Latn_TM",
+ "tk"
+ }, {
+ "tkl",
+ "tkl_Latn_TK",
+ "tkl"
+ }, {
+ "tn",
+ "tn_Latn_ZA",
+ "tn"
+ }, {
+ "to",
+ "to_Latn_TO",
+ "to"
+ }, {
+ "tpi",
+ "tpi_Latn_PG",
+ "tpi"
+ }, {
+ "tr",
+ "tr_Latn_TR",
+ "tr"
+ }, {
+ "ts",
+ "ts_Latn_ZA",
+ "ts"
+ }, {
+ "tt",
+ "tt_Cyrl_RU",
+ "tt"
+ }, {
+ "tvl",
+ "tvl_Latn_TV",
+ "tvl"
+ }, {
+ "ty",
+ "ty_Latn_PF",
+ "ty"
+ }, {
+ "uk",
+ "uk_Cyrl_UA",
+ "uk"
+ }, {
+ "und",
+ "en_Latn_US",
+ "en"
+ }, {
+ "und_AD",
+ "ca_Latn_AD",
+ "ca_AD"
+ }, {
+ "und_AE",
+ "ar_Arab_AE",
+ "ar_AE"
+ }, {
+ "und_AF",
+ "fa_Arab_AF",
+ "fa_AF"
+ }, {
+ "und_AL",
+ "sq_Latn_AL",
+ "sq"
+ }, {
+ "und_AM",
+ "hy_Armn_AM",
+ "hy"
+ }, {
+ "und_AN",
+ "pap_Latn_AN",
+ "pap"
+ }, {
+ "und_AO",
+ "pt_Latn_AO",
+ "pt_AO"
+ }, {
+ "und_AR",
+ "es_Latn_AR",
+ "es_AR"
+ }, {
+ "und_AS",
+ "sm_Latn_AS",
+ "sm_AS"
+ }, {
+ "und_AT",
+ "de_Latn_AT",
+ "de_AT"
+ }, {
+ "und_AW",
+ "nl_Latn_AW",
+ "nl_AW"
+ }, {
+ "und_AX",
+ "sv_Latn_AX",
+ "sv_AX"
+ }, {
+ "und_AZ",
+ "az_Latn_AZ",
+ "az"
+ }, {
+ "und_Arab",
+ "ar_Arab_EG",
+ "ar"
+ }, {
+ "und_Arab_IN",
+ "ur_Arab_IN",
+ "ur_IN"
+ }, {
+ "und_Arab_PK",
+ "ur_Arab_PK",
+ "ur"
+ }, {
+ "und_Arab_SN",
+ "ar_Arab_SN",
+ "ar_SN"
+ }, {
+ "und_Armn",
+ "hy_Armn_AM",
+ "hy"
+ }, {
+ "und_BA",
+ "bs_Latn_BA",
+ "bs"
+ }, {
+ "und_BD",
+ "bn_Beng_BD",
+ "bn"
+ }, {
+ "und_BE",
+ "nl_Latn_BE",
+ "nl_BE"
+ }, {
+ "und_BF",
+ "fr_Latn_BF",
+ "fr_BF"
+ }, {
+ "und_BG",
+ "bg_Cyrl_BG",
+ "bg"
+ }, {
+ "und_BH",
+ "ar_Arab_BH",
+ "ar_BH"
+ }, {
+ "und_BI",
+ "rn_Latn_BI",
+ "rn"
+ }, {
+ "und_BJ",
+ "fr_Latn_BJ",
+ "fr_BJ"
+ }, {
+ "und_BN",
+ "ms_Latn_BN",
+ "ms_BN"
+ }, {
+ "und_BO",
+ "es_Latn_BO",
+ "es_BO"
+ }, {
+ "und_BR",
+ "pt_Latn_BR",
+ "pt"
+ }, {
+ "und_BT",
+ "dz_Tibt_BT",
+ "dz"
+ }, {
+ "und_BY",
+ "be_Cyrl_BY",
+ "be"
+ }, {
+ "und_Beng",
+ "bn_Beng_BD",
+ "bn"
+ }, {
+ "und_Beng_IN",
+ "bn_Beng_IN",
+ "bn_IN"
+ }, {
+ "und_CD",
+ "sw_Latn_CD",
+ "sw_CD"
+ }, {
+ "und_CF",
+ "fr_Latn_CF",
+ "fr_CF"
+ }, {
+ "und_CG",
+ "fr_Latn_CG",
+ "fr_CG"
+ }, {
+ "und_CH",
+ "de_Latn_CH",
+ "de_CH"
+ }, {
+ "und_CI",
+ "fr_Latn_CI",
+ "fr_CI"
+ }, {
+ "und_CL",
+ "es_Latn_CL",
+ "es_CL"
+ }, {
+ "und_CM",
+ "fr_Latn_CM",
+ "fr_CM"
+ }, {
+ "und_CN",
+ "zh_Hans_CN",
+ "zh"
+ }, {
+ "und_CO",
+ "es_Latn_CO",
+ "es_CO"
+ }, {
+ "und_CR",
+ "es_Latn_CR",
+ "es_CR"
+ }, {
+ "und_CU",
+ "es_Latn_CU",
+ "es_CU"
+ }, {
+ "und_CV",
+ "pt_Latn_CV",
+ "pt_CV"
+ }, {
+ "und_CY",
+ "el_Grek_CY",
+ "el_CY"
+ }, {
+ "und_CZ",
+ "cs_Latn_CZ",
+ "cs"
+ }, {
+ "und_Cher",
+ "chr_Cher_US",
+ "chr"
+ }, {
+ "und_Cyrl",
+ "ru_Cyrl_RU",
+ "ru"
+ }, {
+ "und_Cyrl_KZ",
+ "ru_Cyrl_KZ",
+ "ru_KZ"
+ }, {
+ "und_DE",
+ "de_Latn_DE",
+ "de"
+ }, {
+ "und_DJ",
+ "aa_Latn_DJ",
+ "aa_DJ"
+ }, {
+ "und_DK",
+ "da_Latn_DK",
+ "da"
+ }, {
+ "und_DO",
+ "es_Latn_DO",
+ "es_DO"
+ }, {
+ "und_DZ",
+ "ar_Arab_DZ",
+ "ar_DZ"
+ }, {
+ "und_Deva",
+ "hi_Deva_IN",
+ "hi"
+ }, {
+ "und_EC",
+ "es_Latn_EC",
+ "es_EC"
+ }, {
+ "und_EE",
+ "et_Latn_EE",
+ "et"
+ }, {
+ "und_EG",
+ "ar_Arab_EG",
+ "ar"
+ }, {
+ "und_EH",
+ "ar_Arab_EH",
+ "ar_EH"
+ }, {
+ "und_ER",
+ "ti_Ethi_ER",
+ "ti_ER"
+ }, {
+ "und_ES",
+ "es_Latn_ES",
+ "es"
+ }, {
+ "und_ET",
+ "en_Latn_ET",
+ "en_ET"
+ }, {
+ "und_Ethi",
+ "am_Ethi_ET",
+ "am"
+ }, {
+ "und_Ethi_ER",
+ "am_Ethi_ER",
+ "am_ER"
+ }, {
+ "und_FI",
+ "fi_Latn_FI",
+ "fi"
+ }, {
+ "und_FM",
+ "chk_Latn_FM",
+ "chk"
+ }, {
+ "und_FO",
+ "fo_Latn_FO",
+ "fo"
+ }, {
+ "und_FR",
+ "fr_Latn_FR",
+ "fr"
+ }, {
+ "und_GA",
+ "fr_Latn_GA",
+ "fr_GA"
+ }, {
+ "und_GE",
+ "ka_Geor_GE",
+ "ka"
+ }, {
+ "und_GF",
+ "fr_Latn_GF",
+ "fr_GF"
+ }, {
+ "und_GL",
+ "kl_Latn_GL",
+ "kl"
+ }, {
+ "und_GN",
+ "fr_Latn_GN",
+ "fr_GN"
+ }, {
+ "und_GP",
+ "fr_Latn_GP",
+ "fr_GP"
+ }, {
+ "und_GQ",
+ "es_Latn_GQ",
+ "es_GQ"
+ }, {
+ "und_GR",
+ "el_Grek_GR",
+ "el"
+ }, {
+ "und_GT",
+ "es_Latn_GT",
+ "es_GT"
+ }, {
+ "und_GU",
+ "en_Latn_GU",
+ "en_GU"
+ }, {
+ "und_GW",
+ "pt_Latn_GW",
+ "pt_GW"
+ }, {
+ "und_Geor",
+ "ka_Geor_GE",
+ "ka"
+ }, {
+ "und_Grek",
+ "el_Grek_GR",
+ "el"
+ }, {
+ "und_Gujr",
+ "gu_Gujr_IN",
+ "gu"
+ }, {
+ "und_Guru",
+ "pa_Guru_IN",
+ "pa"
+ }, {
+ "und_HK",
+ "zh_Hant_HK",
+ "zh_HK"
+ }, {
+ "und_HN",
+ "es_Latn_HN",
+ "es_HN"
+ }, {
+ "und_HR",
+ "hr_Latn_HR",
+ "hr"
+ }, {
+ "und_HT",
+ "ht_Latn_HT",
+ "ht"
+ }, {
+ "und_HU",
+ "hu_Latn_HU",
+ "hu"
+ }, {
+ "und_Hani",
+ "zh_Hans_CN",
+ "zh"
+ }, {
+ "und_Hans",
+ "zh_Hans_CN",
+ "zh"
+ }, {
+ "und_Hant",
+ "zh_Hant_TW",
+ "zh_TW"
+ }, {
+ "und_Hebr",
+ "he_Hebr_IL",
+ "he"
+ }, {
+ "und_IL",
+ "he_Hebr_IL",
+ "he"
+ }, {
+ "und_IN",
+ "hi_Deva_IN",
+ "hi"
+ }, {
+ "und_IQ",
+ "ar_Arab_IQ",
+ "ar_IQ"
+ }, {
+ "und_IR",
+ "fa_Arab_IR",
+ "fa"
+ }, {
+ "und_IS",
+ "is_Latn_IS",
+ "is"
+ }, {
+ "und_IT",
+ "it_Latn_IT",
+ "it"
+ }, {
+ "und_JO",
+ "ar_Arab_JO",
+ "ar_JO"
+ }, {
+ "und_JP",
+ "ja_Jpan_JP",
+ "ja"
+ }, {
+ "und_Jpan",
+ "ja_Jpan_JP",
+ "ja"
+ }, {
+ "und_KG",
+ "ky_Cyrl_KG",
+ "ky"
+ }, {
+ "und_KH",
+ "km_Khmr_KH",
+ "km"
+ }, {
+ "und_KM",
+ "ar_Arab_KM",
+ "ar_KM"
+ }, {
+ "und_KP",
+ "ko_Kore_KP",
+ "ko_KP"
+ }, {
+ "und_KR",
+ "ko_Kore_KR",
+ "ko"
+ }, {
+ "und_KW",
+ "ar_Arab_KW",
+ "ar_KW"
+ }, {
+ "und_KZ",
+ "ru_Cyrl_KZ",
+ "ru_KZ"
+ }, {
+ "und_Khmr",
+ "km_Khmr_KH",
+ "km"
+ }, {
+ "und_Knda",
+ "kn_Knda_IN",
+ "kn"
+ }, {
+ "und_Kore",
+ "ko_Kore_KR",
+ "ko"
+ }, {
+ "und_LA",
+ "lo_Laoo_LA",
+ "lo"
+ }, {
+ "und_LB",
+ "ar_Arab_LB",
+ "ar_LB"
+ }, {
+ "und_LI",
+ "de_Latn_LI",
+ "de_LI"
+ }, {
+ "und_LK",
+ "si_Sinh_LK",
+ "si"
+ }, {
+ "und_LS",
+ "st_Latn_LS",
+ "st_LS"
+ }, {
+ "und_LT",
+ "lt_Latn_LT",
+ "lt"
+ }, {
+ "und_LU",
+ "fr_Latn_LU",
+ "fr_LU"
+ }, {
+ "und_LV",
+ "lv_Latn_LV",
+ "lv"
+ }, {
+ "und_LY",
+ "ar_Arab_LY",
+ "ar_LY"
+ }, {
+ "und_Laoo",
+ "lo_Laoo_LA",
+ "lo"
+ }, {
+ "und_Latn_ES",
+ "es_Latn_ES",
+ "es"
+ }, {
+ "und_Latn_ET",
+ "en_Latn_ET",
+ "en_ET"
+ }, {
+ "und_Latn_GB",
+ "en_Latn_GB",
+ "en_GB"
+ }, {
+ "und_Latn_GH",
+ "ak_Latn_GH",
+ "ak"
+ }, {
+ "und_Latn_ID",
+ "id_Latn_ID",
+ "id"
+ }, {
+ "und_Latn_IT",
+ "it_Latn_IT",
+ "it"
+ }, {
+ "und_Latn_NG",
+ "en_Latn_NG",
+ "en_NG"
+ }, {
+ "und_Latn_TR",
+ "tr_Latn_TR",
+ "tr"
+ }, {
+ "und_Latn_ZA",
+ "en_Latn_ZA",
+ "en_ZA"
+ }, {
+ "und_MA",
+ "ar_Arab_MA",
+ "ar_MA"
+ }, {
+ "und_MC",
+ "fr_Latn_MC",
+ "fr_MC"
+ }, {
+ "und_MD",
+ "ro_Latn_MD",
+ "ro_MD"
+ }, {
+ "und_ME",
+ "sr_Latn_ME",
+ "sr_ME"
+ }, {
+ "und_MG",
+ "mg_Latn_MG",
+ "mg"
+ }, {
+ "und_MH",
+ "en_Latn_MH",
+ "en_MH"
+ }, {
+ "und_MK",
+ "mk_Cyrl_MK",
+ "mk"
+ }, {
+ "und_ML",
+ "bm_Latn_ML",
+ "bm"
+ }, {
+ "und_MM",
+ "my_Mymr_MM",
+ "my"
+ }, {
+ "und_MN",
+ "mn_Cyrl_MN",
+ "mn"
+ }, {
+ "und_MO",
+ "zh_Hant_MO",
+ "zh_MO"
+ }, {
+ "und_MQ",
+ "fr_Latn_MQ",
+ "fr_MQ"
+ }, {
+ "und_MR",
+ "ar_Arab_MR",
+ "ar_MR"
+ }, {
+ "und_MT",
+ "mt_Latn_MT",
+ "mt"
+ }, {
+ "und_MV",
+ "dv_Thaa_MV",
+ "dv"
+ }, {
+ "und_MW",
+ "en_Latn_MW",
+ "en_MW"
+ }, {
+ "und_MX",
+ "es_Latn_MX",
+ "es_MX"
+ }, {
+ "und_MY",
+ "ms_Latn_MY",
+ "ms"
+ }, {
+ "und_MZ",
+ "pt_Latn_MZ",
+ "pt_MZ"
+ }, {
+ "und_Mlym",
+ "ml_Mlym_IN",
+ "ml"
+ }, {
+ "und_Mymr",
+ "my_Mymr_MM",
+ "my"
+ }, {
+ "und_NC",
+ "fr_Latn_NC",
+ "fr_NC"
+ }, {
+ "und_NE",
+ "ha_Latn_NE",
+ "ha_NE"
+ }, {
+ "und_NG",
+ "en_Latn_NG",
+ "en_NG"
+ }, {
+ "und_NI",
+ "es_Latn_NI",
+ "es_NI"
+ }, {
+ "und_NL",
+ "nl_Latn_NL",
+ "nl"
+ }, {
+ "und_NO",
+ "nb_Latn_NO",
+ "nb"
+ }, {
+ "und_NP",
+ "ne_Deva_NP",
+ "ne"
+ }, {
+ "und_NR",
+ "en_Latn_NR",
+ "en_NR"
+ }, {
+ "und_NU",
+ "en_Latn_NU",
+ "en_NU"
+ }, {
+ "und_OM",
+ "ar_Arab_OM",
+ "ar_OM"
+ }, {
+ "und_Orya",
+ "or_Orya_IN",
+ "or"
+ }, {
+ "und_PA",
+ "es_Latn_PA",
+ "es_PA"
+ }, {
+ "und_PE",
+ "es_Latn_PE",
+ "es_PE"
+ }, {
+ "und_PF",
+ "fr_Latn_PF",
+ "fr_PF"
+ }, {
+ "und_PG",
+ "tpi_Latn_PG",
+ "tpi"
+ }, {
+ "und_PH",
+ "fil_Latn_PH",
+ "fil"
+ }, {
+ "und_PL",
+ "pl_Latn_PL",
+ "pl"
+ }, {
+ "und_PM",
+ "fr_Latn_PM",
+ "fr_PM"
+ }, {
+ "und_PR",
+ "es_Latn_PR",
+ "es_PR"
+ }, {
+ "und_PS",
+ "ar_Arab_PS",
+ "ar_PS"
+ }, {
+ "und_PT",
+ "pt_Latn_PT",
+ "pt_PT"
+ }, {
+ "und_PW",
+ "pau_Latn_PW",
+ "pau"
+ }, {
+ "und_PY",
+ "gn_Latn_PY",
+ "gn"
+ }, {
+ "und_QA",
+ "ar_Arab_QA",
+ "ar_QA"
+ }, {
+ "und_RE",
+ "fr_Latn_RE",
+ "fr_RE"
+ }, {
+ "und_RO",
+ "ro_Latn_RO",
+ "ro"
+ }, {
+ "und_RS",
+ "sr_Cyrl_RS",
+ "sr"
+ }, {
+ "und_RU",
+ "ru_Cyrl_RU",
+ "ru"
+ }, {
+ "und_RW",
+ "rw_Latn_RW",
+ "rw"
+ }, {
+ "und_SA",
+ "ar_Arab_SA",
+ "ar_SA"
+ }, {
+ "und_SD",
+ "ar_Arab_SD",
+ "ar_SD"
+ }, {
+ "und_SE",
+ "sv_Latn_SE",
+ "sv"
+ }, {
+ "und_SG",
+ "en_Latn_SG",
+ "en_SG"
+ }, {
+ "und_SI",
+ "sl_Latn_SI",
+ "sl"
+ }, {
+ "und_SJ",
+ "nb_Latn_SJ",
+ "nb_SJ"
+ }, {
+ "und_SK",
+ "sk_Latn_SK",
+ "sk"
+ }, {
+ "und_SM",
+ "it_Latn_SM",
+ "it_SM"
+ }, {
+ "und_SN",
+ "fr_Latn_SN",
+ "fr_SN"
+ }, {
+ "und_SO",
+ "so_Latn_SO",
+ "so"
+ }, {
+ "und_SR",
+ "nl_Latn_SR",
+ "nl_SR"
+ }, {
+ "und_ST",
+ "pt_Latn_ST",
+ "pt_ST"
+ }, {
+ "und_SV",
+ "es_Latn_SV",
+ "es_SV"
+ }, {
+ "und_SY",
+ "ar_Arab_SY",
+ "ar_SY"
+ }, {
+ "und_Sinh",
+ "si_Sinh_LK",
+ "si"
+ }, {
+ "und_TD",
+ "fr_Latn_TD",
+ "fr_TD"
+ }, {
+ "und_TG",
+ "fr_Latn_TG",
+ "fr_TG"
+ }, {
+ "und_TH",
+ "th_Thai_TH",
+ "th"
+ }, {
+ "und_TJ",
+ "tg_Cyrl_TJ",
+ "tg"
+ }, {
+ "und_TK",
+ "tkl_Latn_TK",
+ "tkl"
+ }, {
+ "und_TL",
+ "pt_Latn_TL",
+ "pt_TL"
+ }, {
+ "und_TM",
+ "tk_Latn_TM",
+ "tk"
+ }, {
+ "und_TN",
+ "ar_Arab_TN",
+ "ar_TN"
+ }, {
+ "und_TO",
+ "to_Latn_TO",
+ "to"
+ }, {
+ "und_TR",
+ "tr_Latn_TR",
+ "tr"
+ }, {
+ "und_TV",
+ "tvl_Latn_TV",
+ "tvl"
+ }, {
+ "und_TW",
+ "zh_Hant_TW",
+ "zh_TW"
+ }, {
+ "und_Taml",
+ "ta_Taml_IN",
+ "ta"
+ }, {
+ "und_Telu",
+ "te_Telu_IN",
+ "te"
+ }, {
+ "und_Thaa",
+ "dv_Thaa_MV",
+ "dv"
+ }, {
+ "und_Thai",
+ "th_Thai_TH",
+ "th"
+ }, {
+ "und_Tibt",
+ "bo_Tibt_CN",
+ "bo"
+ }, {
+ "und_UA",
+ "uk_Cyrl_UA",
+ "uk"
+ }, {
+ "und_UY",
+ "es_Latn_UY",
+ "es_UY"
+ }, {
+ "und_UZ",
+ "uz_Cyrl_UZ",
+ "uz"
+ }, {
+ "und_VA",
+ "la_Latn_VA",
+ "la"
+ }, {
+ "und_VE",
+ "es_Latn_VE",
+ "es_VE"
+ }, {
+ "und_VN",
+ "vi_Latn_VN",
+ "vi"
+ }, {
+ "und_VU",
+ "fr_Latn_VU",
+ "fr_VU"
+ }, {
+ "und_WF",
+ "fr_Latn_WF",
+ "fr_WF"
+ }, {
+ "und_WS",
+ "sm_Latn_WS",
+ "sm"
+ }, {
+ "und_YE",
+ "ar_Arab_YE",
+ "ar_YE"
+ }, {
+ "und_YT",
+ "fr_Latn_YT",
+ "fr_YT"
+ }, {
+ "und_Yiii",
+ "ii_Yiii_CN",
+ "ii"
+ }, {
+ "ur",
+ "ur_Arab_PK",
+ "ur"
+ }, {
+ "uz",
+ "uz_Cyrl_UZ",
+ "uz"
+ }, {
+ "uz_AF",
+ "uz_Arab_AF",
+ "uz_AF"
+ }, {
+ "uz_Arab",
+ "uz_Arab_AF",
+ "uz_AF"
+ }, {
+ "ve",
+ "ve_Latn_ZA",
+ "ve"
+ }, {
+ "vi",
+ "vi_Latn_VN",
+ "vi"
+ }, {
+ "wal",
+ "wal_Ethi_ET",
+ "wal"
+ }, {
+ "wo",
+ "wo_Latn_SN",
+ "wo"
+ }, {
+ "xh",
+ "xh_Latn_ZA",
+ "xh"
+ }, {
+ "yo",
+ "yo_Latn_NG",
+ "yo"
+ }, {
+ "zh",
+ "zh_Hans_CN",
+ "zh"
+ }, {
+ "zh_HK",
+ "zh_Hant_HK",
+ "zh_HK"
+ }, {
+ "zh_Hani",
+ "zh_Hans_CN",
+ "zh"
+ }, {
+ "zh_Hant",
+ "zh_Hant_TW",
+ "zh_TW"
+ }, {
+ "zh_MO",
+ "zh_Hant_MO",
+ "zh_MO"
+ }, {
+ "zh_TW",
+ "zh_Hant_TW",
+ "zh_TW"
+ }, {
+ "zu",
+ "zu_Latn_ZA",
+ "zu"
+ }, {
+ "und",
+ "en_Latn_US",
+ "en"
+ }, {
+ "und_ZZ",
+ "en_Latn_US",
+ "en"
+ }, {
+ "und_CN",
+ "zh_Hans_CN",
+ "zh"
+ }, {
+ "und_TW",
+ "zh_Hant_TW",
+ "zh_TW"
+ }, {
+ "und_HK",
+ "zh_Hant_HK",
+ "zh_HK"
+ }, {
+ "und_AQ",
+ "en_Latn_AQ",
+ "en_AQ"
+ }, {
+ "und_Zzzz",
+ "en_Latn_US",
+ "en"
+ }, {
+ "und_Zzzz_ZZ",
+ "en_Latn_US",
+ "en"
+ }, {
+ "und_Zzzz_CN",
+ "zh_Hans_CN",
+ "zh"
+ }, {
+ "und_Zzzz_TW",
+ "zh_Hant_TW",
+ "zh_TW"
+ }, {
+ "und_Zzzz_HK",
+ "zh_Hant_HK",
+ "zh_HK"
+ }, {
+ "und_Zzzz_AQ",
+ "en_Latn_AQ",
+ "en_AQ"
+ }, {
+ "und_Latn",
+ "en_Latn_US",
+ "en"
+ }, {
+ "und_Latn_ZZ",
+ "en_Latn_US",
+ "en"
+ }, {
+ "und_Latn_CN",
+ "za_Latn_CN",
+ "za"
+ }, {
+ "und_Latn_TW",
+ "zh_Latn_TW",
+ "zh_Latn_TW"
+ }, {
+ "und_Latn_HK",
+ "zh_Latn_HK",
+ "zh_Latn_HK"
+ }, {
+ "und_Latn_AQ",
+ "en_Latn_AQ",
+ "en_AQ"
+ }, {
+ "und_Hans",
+ "zh_Hans_CN",
+ "zh"
+ }, {
+ "und_Hans_ZZ",
+ "zh_Hans_CN",
+ "zh"
+ }, {
+ "und_Hans_CN",
+ "zh_Hans_CN",
+ "zh"
+ }, {
+ "und_Hans_TW",
+ "zh_Hans_TW",
+ "zh_Hans_TW"
+ }, {
+ "und_Hans_HK",
+ "zh_Hans_HK",
+ "zh_Hans_HK"
+ }, {
+ "und_Hans_AQ",
+ "zh_Hans_AQ",
+ "zh_AQ"
+ }, {
+ "und_Hant",
+ "zh_Hant_TW",
+ "zh_TW"
+ }, {
+ "und_Hant_ZZ",
+ "zh_Hant_TW",
+ "zh_TW"
+ }, {
+ "und_Hant_CN",
+ "zh_Hant_CN",
+ "zh_Hant_CN"
+ }, {
+ "und_Hant_TW",
+ "zh_Hant_TW",
+ "zh_TW"
+ }, {
+ "und_Hant_HK",
+ "zh_Hant_HK",
+ "zh_HK"
+ }, {
+ "und_Hant_AQ",
+ "zh_Hant_AQ",
+ "zh_Hant_AQ"
+ }, {
+ "und_Moon",
+ "en_Moon_US",
+ "en_Moon"
+ }, {
+ "und_Moon_ZZ",
+ "en_Moon_US",
+ "en_Moon"
+ }, {
+ "und_Moon_CN",
+ "zh_Moon_CN",
+ "zh_Moon"
+ }, {
+ "und_Moon_TW",
+ "zh_Moon_TW",
+ "zh_Moon_TW"
+ }, {
+ "und_Moon_HK",
+ "zh_Moon_HK",
+ "zh_Moon_HK"
+ }, {
+ "und_Moon_AQ",
+ "en_Moon_AQ",
+ "en_Moon_AQ"
+ }, {
+ "es",
+ "es_Latn_ES",
+ "es"
+ }, {
+ "es_ZZ",
+ "es_Latn_ES",
+ "es"
+ }, {
+ "es_CN",
+ "es_Latn_CN",
+ "es_CN"
+ }, {
+ "es_TW",
+ "es_Latn_TW",
+ "es_TW"
+ }, {
+ "es_HK",
+ "es_Latn_HK",
+ "es_HK"
+ }, {
+ "es_AQ",
+ "es_Latn_AQ",
+ "es_AQ"
+ }, {
+ "es_Zzzz",
+ "es_Latn_ES",
+ "es"
+ }, {
+ "es_Zzzz_ZZ",
+ "es_Latn_ES",
+ "es"
+ }, {
+ "es_Zzzz_CN",
+ "es_Latn_CN",
+ "es_CN"
+ }, {
+ "es_Zzzz_TW",
+ "es_Latn_TW",
+ "es_TW"
+ }, {
+ "es_Zzzz_HK",
+ "es_Latn_HK",
+ "es_HK"
+ }, {
+ "es_Zzzz_AQ",
+ "es_Latn_AQ",
+ "es_AQ"
+ }, {
+ "es_Latn",
+ "es_Latn_ES",
+ "es"
+ }, {
+ "es_Latn_ZZ",
+ "es_Latn_ES",
+ "es"
+ }, {
+ "es_Latn_CN",
+ "es_Latn_CN",
+ "es_CN"
+ }, {
+ "es_Latn_TW",
+ "es_Latn_TW",
+ "es_TW"
+ }, {
+ "es_Latn_HK",
+ "es_Latn_HK",
+ "es_HK"
+ }, {
+ "es_Latn_AQ",
+ "es_Latn_AQ",
+ "es_AQ"
+ }, {
+ "es_Hans",
+ "es_Hans_ES",
+ "es_Hans"
+ }, {
+ "es_Hans_ZZ",
+ "es_Hans_ES",
+ "es_Hans"
+ }, {
+ "es_Hans_CN",
+ "es_Hans_CN",
+ "es_Hans_CN"
+ }, {
+ "es_Hans_TW",
+ "es_Hans_TW",
+ "es_Hans_TW"
+ }, {
+ "es_Hans_HK",
+ "es_Hans_HK",
+ "es_Hans_HK"
+ }, {
+ "es_Hans_AQ",
+ "es_Hans_AQ",
+ "es_Hans_AQ"
+ }, {
+ "es_Hant",
+ "es_Hant_ES",
+ "es_Hant"
+ }, {
+ "es_Hant_ZZ",
+ "es_Hant_ES",
+ "es_Hant"
+ }, {
+ "es_Hant_CN",
+ "es_Hant_CN",
+ "es_Hant_CN"
+ }, {
+ "es_Hant_TW",
+ "es_Hant_TW",
+ "es_Hant_TW"
+ }, {
+ "es_Hant_HK",
+ "es_Hant_HK",
+ "es_Hant_HK"
+ }, {
+ "es_Hant_AQ",
+ "es_Hant_AQ",
+ "es_Hant_AQ"
+ }, {
+ "es_Moon",
+ "es_Moon_ES",
+ "es_Moon"
+ }, {
+ "es_Moon_ZZ",
+ "es_Moon_ES",
+ "es_Moon"
+ }, {
+ "es_Moon_CN",
+ "es_Moon_CN",
+ "es_Moon_CN"
+ }, {
+ "es_Moon_TW",
+ "es_Moon_TW",
+ "es_Moon_TW"
+ }, {
+ "es_Moon_HK",
+ "es_Moon_HK",
+ "es_Moon_HK"
+ }, {
+ "es_Moon_AQ",
+ "es_Moon_AQ",
+ "es_Moon_AQ"
+ }, {
+ "zh",
+ "zh_Hans_CN",
+ "zh"
+ }, {
+ "zh_ZZ",
+ "zh_Hans_CN",
+ "zh"
+ }, {
+ "zh_CN",
+ "zh_Hans_CN",
+ "zh"
+ }, {
+ "zh_TW",
+ "zh_Hant_TW",
+ "zh_TW"
+ }, {
+ "zh_HK",
+ "zh_Hant_HK",
+ "zh_HK"
+ }, {
+ "zh_AQ",
+ "zh_Hans_AQ",
+ "zh_AQ"
+ }, {
+ "zh_Zzzz",
+ "zh_Hans_CN",
+ "zh"
+ }, {
+ "zh_Zzzz_ZZ",
+ "zh_Hans_CN",
+ "zh"
+ }, {
+ "zh_Zzzz_CN",
+ "zh_Hans_CN",
+ "zh"
+ }, {
+ "zh_Zzzz_TW",
+ "zh_Hant_TW",
+ "zh_TW"
+ }, {
+ "zh_Zzzz_HK",
+ "zh_Hant_HK",
+ "zh_HK"
+ }, {
+ "zh_Zzzz_AQ",
+ "zh_Hans_AQ",
+ "zh_AQ"
+ }, {
+ "zh_Latn",
+ "zh_Latn_CN",
+ "zh_Latn"
+ }, {
+ "zh_Latn_ZZ",
+ "zh_Latn_CN",
+ "zh_Latn"
+ }, {
+ "zh_Latn_CN",
+ "zh_Latn_CN",
+ "zh_Latn"
+ }, {
+ "zh_Latn_TW",
+ "zh_Latn_TW",
+ "zh_Latn_TW"
+ }, {
+ "zh_Latn_HK",
+ "zh_Latn_HK",
+ "zh_Latn_HK"
+ }, {
+ "zh_Latn_AQ",
+ "zh_Latn_AQ",
+ "zh_Latn_AQ"
+ }, {
+ "zh_Hans",
+ "zh_Hans_CN",
+ "zh"
+ }, {
+ "zh_Hans_ZZ",
+ "zh_Hans_CN",
+ "zh"
+ }, {
+ "zh_Hans_TW",
+ "zh_Hans_TW",
+ "zh_Hans_TW"
+ }, {
+ "zh_Hans_HK",
+ "zh_Hans_HK",
+ "zh_Hans_HK"
+ }, {
+ "zh_Hans_AQ",
+ "zh_Hans_AQ",
+ "zh_AQ"
+ }, {
+ "zh_Hant",
+ "zh_Hant_TW",
+ "zh_TW"
+ }, {
+ "zh_Hant_ZZ",
+ "zh_Hant_TW",
+ "zh_TW"
+ }, {
+ "zh_Hant_CN",
+ "zh_Hant_CN",
+ "zh_Hant_CN"
+ }, {
+ "zh_Hant_AQ",
+ "zh_Hant_AQ",
+ "zh_Hant_AQ"
+ }, {
+ "zh_Moon",
+ "zh_Moon_CN",
+ "zh_Moon"
+ }, {
+ "zh_Moon_ZZ",
+ "zh_Moon_CN",
+ "zh_Moon"
+ }, {
+ "zh_Moon_CN",
+ "zh_Moon_CN",
+ "zh_Moon"
+ }, {
+ "zh_Moon_TW",
+ "zh_Moon_TW",
+ "zh_Moon_TW"
+ }, {
+ "zh_Moon_HK",
+ "zh_Moon_HK",
+ "zh_Moon_HK"
+ }, {
+ "zh_Moon_AQ",
+ "zh_Moon_AQ",
+ "zh_Moon_AQ"
+ }, {
+ "art",
+ "",
+ ""
+ }, {
+ "art_ZZ",
+ "",
+ ""
+ }, {
+ "art_CN",
+ "",
+ ""
+ }, {
+ "art_TW",
+ "",
+ ""
+ }, {
+ "art_HK",
+ "",
+ ""
+ }, {
+ "art_AQ",
+ "",
+ ""
+ }, {
+ "art_Zzzz",
+ "",
+ ""
+ }, {
+ "art_Zzzz_ZZ",
+ "",
+ ""
+ }, {
+ "art_Zzzz_CN",
+ "",
+ ""
+ }, {
+ "art_Zzzz_TW",
+ "",
+ ""
+ }, {
+ "art_Zzzz_HK",
+ "",
+ ""
+ }, {
+ "art_Zzzz_AQ",
+ "",
+ ""
+ }, {
+ "art_Latn",
+ "",
+ ""
+ }, {
+ "art_Latn_ZZ",
+ "",
+ ""
+ }, {
+ "art_Latn_CN",
+ "",
+ ""
+ }, {
+ "art_Latn_TW",
+ "",
+ ""
+ }, {
+ "art_Latn_HK",
+ "",
+ ""
+ }, {
+ "art_Latn_AQ",
+ "",
+ ""
+ }, {
+ "art_Hans",
+ "",
+ ""
+ }, {
+ "art_Hans_ZZ",
+ "",
+ ""
+ }, {
+ "art_Hans_CN",
+ "",
+ ""
+ }, {
+ "art_Hans_TW",
+ "",
+ ""
+ }, {
+ "art_Hans_HK",
+ "",
+ ""
+ }, {
+ "art_Hans_AQ",
+ "",
+ ""
+ }, {
+ "art_Hant",
+ "",
+ ""
+ }, {
+ "art_Hant_ZZ",
+ "",
+ ""
+ }, {
+ "art_Hant_CN",
+ "",
+ ""
+ }, {
+ "art_Hant_TW",
+ "",
+ ""
+ }, {
+ "art_Hant_HK",
+ "",
+ ""
+ }, {
+ "art_Hant_AQ",
+ "",
+ ""
+ }, {
+ "art_Moon",
+ "",
+ ""
+ }, {
+ "art_Moon_ZZ",
+ "",
+ ""
+ }, {
+ "art_Moon_CN",
+ "",
+ ""
+ }, {
+ "art_Moon_TW",
+ "",
+ ""
+ }, {
+ "art_Moon_HK",
+ "",
+ ""
+ }, {
+ "art_Moon_AQ",
+ "",
+ ""
+ }
+};
+
+typedef struct errorDataTag {
+ const char* tag;
+ const char* expected;
+ UErrorCode uerror;
+ int32_t bufferSize;
+} errorData;
+
+const errorData maximizeErrors[] = {
+ {
+ "enfueiujhytdf",
+ NULL,
+ U_ILLEGAL_ARGUMENT_ERROR,
+ -1
+ },
+ {
+ "en_THUJIOGIURJHGJFURYHFJGURYYYHHGJURHG",
+ NULL,
+ U_ILLEGAL_ARGUMENT_ERROR,
+ -1
+ },
+ {
+ "en_THUJIOGIURJHGJFURYHFJGURYYYHHGJURHG",
+ NULL,
+ U_ILLEGAL_ARGUMENT_ERROR,
+ -1
+ },
+ {
+ "en_Latn_US_POSIX@currency=EURO",
+ "en_Latn_US_POSIX@currency=EURO",
+ U_BUFFER_OVERFLOW_ERROR,
+ 29
+ },
+ {
+ "en_Latn_US_POSIX@currency=EURO",
+ "en_Latn_US_POSIX@currency=EURO",
+ U_STRING_NOT_TERMINATED_WARNING,
+ 30
+ }
+};
+
+const errorData minimizeErrors[] = {
+ {
+ "enfueiujhytdf",
+ NULL,
+ U_ILLEGAL_ARGUMENT_ERROR,
+ -1
+ },
+ {
+ "en_THUJIOGIURJHGJFURYHFJGURYYYHHGJURHG",
+ NULL,
+ U_ILLEGAL_ARGUMENT_ERROR,
+ -1
+ },
+ {
+ "en_Latn_US_POSIX@currency=EURO",
+ "en__POSIX@currency=EURO",
+ U_BUFFER_OVERFLOW_ERROR,
+ 22
+ },
+ {
+ "en_Latn_US_POSIX@currency=EURO",
+ "en__POSIX@currency=EURO",
+ U_STRING_NOT_TERMINATED_WARNING,
+ 23
+ }
+};
+
+static int32_t getExpectedReturnValue(const errorData* data)
+{
+ if (data->uerror == U_BUFFER_OVERFLOW_ERROR ||
+ data->uerror == U_STRING_NOT_TERMINATED_WARNING)
+ {
+ return strlen(data->expected);
+ }
+ else
+ {
+ return -1;
+ }
+}
+
+static int32_t getBufferSize(const errorData* data, int32_t actualSize)
+{
+ if (data->expected == NULL)
+ {
+ return actualSize;
+ }
+ else if (data->bufferSize < 0)
+ {
+ return strlen(data->expected) + 1;
+ }
+ else
+ {
+ return data->bufferSize;
+ }
+}
+
+static void TestLikelySubtags()
+{
+ char buffer[ULOC_FULLNAME_CAPACITY + ULOC_KEYWORD_AND_VALUES_CAPACITY + 1];
+ int32_t i = 0;
+
+ for (; i < sizeof(basic_maximize_data) / sizeof(basic_maximize_data[0]); ++i)
+ {
+ UErrorCode status = U_ZERO_ERROR;
+ const char* const minimal = basic_maximize_data[i][0];
+ const char* const maximal = basic_maximize_data[i][1];
+
+ /* const int32_t length = */
+ uloc_addLikelySubtags(
+ minimal,
+ buffer,
+ sizeof(buffer),
+ &status);
+ if (U_FAILURE(status)) {
+ log_err_status(status, " unexpected failure of uloc_addLikelySubtags(), minimal \"%s\" status %s\n", minimal, u_errorName(status));
+ status = U_ZERO_ERROR;
+ }
+ else if (uprv_strlen(maximal) == 0) {
+ if (uprv_stricmp(minimal, buffer) != 0) {
+ log_err(" unexpected maximal value \"%s\" in uloc_addLikelySubtags(), minimal \"%s\" = \"%s\"\n", maximal, minimal, buffer);
+ }
+ }
+ else if (uprv_stricmp(maximal, buffer) != 0) {
+ log_err(" maximal doesn't match expected %s in uloc_addLikelySubtags(), minimal \"%s\" = %s\n", maximal, minimal, buffer);
+ }
+ }
+
+ for (i = 0; i < sizeof(basic_minimize_data) / sizeof(basic_minimize_data[0]); ++i) {
+
+ UErrorCode status = U_ZERO_ERROR;
+ const char* const maximal = basic_minimize_data[i][0];
+ const char* const minimal = basic_minimize_data[i][1];
+
+ /* const int32_t length = */
+ uloc_minimizeSubtags(
+ maximal,
+ buffer,
+ sizeof(buffer),
+ &status);
+
+ if (U_FAILURE(status)) {
+ log_err_status(status, " unexpected failure of uloc_MinimizeSubtags(), maximal \"%s\" status %s\n", maximal, u_errorName(status));
+ status = U_ZERO_ERROR;
+ }
+ else if (uprv_strlen(minimal) == 0) {
+ if (uprv_stricmp(maximal, buffer) != 0) {
+ log_err(" unexpected minimal value \"%s\" in uloc_minimizeSubtags(), maximal \"%s\" = \"%s\"\n", minimal, maximal, buffer);
+ }
+ }
+ else if (uprv_stricmp(minimal, buffer) != 0) {
+ log_err(" minimal doesn't match expected %s in uloc_MinimizeSubtags(), maximal \"%s\" = %s\n", minimal, maximal, buffer);
+ }
+ }
+
+ for (i = 0; i < sizeof(full_data) / sizeof(full_data[0]); ++i) {
+
+ UErrorCode status = U_ZERO_ERROR;
+ const char* const minimal = full_data[i][0];
+ const char* const maximal = full_data[i][1];
+
+ /* const int32_t length = */
+ uloc_addLikelySubtags(
+ minimal,
+ buffer,
+ sizeof(buffer),
+ &status);
+ if (U_FAILURE(status)) {
+ log_err_status(status, " unexpected failure of uloc_addLikelySubtags(), minimal \"%s\" status \"%s\"\n", minimal, u_errorName(status));
+ status = U_ZERO_ERROR;
+ }
+ else if (uprv_strlen(maximal) == 0) {
+ if (uprv_stricmp(minimal, buffer) != 0) {
+ log_err(" unexpected maximal value \"%s\" in uloc_addLikelySubtags(), minimal \"%s\" = \"%s\"\n", maximal, minimal, buffer);
+ }
+ }
+ else if (uprv_stricmp(maximal, buffer) != 0) {
+ log_err(" maximal doesn't match expected \"%s\" in uloc_addLikelySubtags(), minimal \"%s\" = \"%s\"\n", maximal, minimal, buffer);
+ }
+ }
+
+ for (i = 0; i < sizeof(full_data) / sizeof(full_data[0]); ++i) {
+
+ UErrorCode status = U_ZERO_ERROR;
+ const char* const maximal = full_data[i][1];
+ const char* const minimal = full_data[i][2];
+
+ if (strlen(maximal) > 0) {
+
+ /* const int32_t length = */
+ uloc_minimizeSubtags(
+ maximal,
+ buffer,
+ sizeof(buffer),
+ &status);
+
+ if (U_FAILURE(status)) {
+ log_err_status(status, " unexpected failure of uloc_minimizeSubtags(), maximal \"%s\" status %s\n", maximal, u_errorName(status));
+ status = U_ZERO_ERROR;
+ }
+ else if (uprv_strlen(minimal) == 0) {
+ if (uprv_stricmp(maximal, buffer) != 0) {
+ log_err(" unexpected minimal value \"%s\" in uloc_minimizeSubtags(), maximal \"%s\" = \"%s\"\n", minimal, maximal, buffer);
+ }
+ }
+ else if (uprv_stricmp(minimal, buffer) != 0) {
+ log_err(" minimal doesn't match expected %s in uloc_MinimizeSubtags(), maximal \"%s\" = %s\n", minimal, maximal, buffer);
+ }
+ }
+ }
+
+ for (i = 0; i < sizeof(maximizeErrors) / sizeof(maximizeErrors[0]); ++i) {
+
+ UErrorCode status = U_ZERO_ERROR;
+ const char* const minimal = maximizeErrors[i].tag;
+ const char* const maximal = maximizeErrors[i].expected;
+ const UErrorCode expectedStatus = maximizeErrors[i].uerror;
+ const int32_t expectedLength = getExpectedReturnValue(&maximizeErrors[i]);
+ const int32_t bufferSize = getBufferSize(&maximizeErrors[i], sizeof(buffer));
+
+ const int32_t length =
+ uloc_addLikelySubtags(
+ minimal,
+ buffer,
+ bufferSize,
+ &status);
+
+ if (status == U_ZERO_ERROR) {
+ log_err(" unexpected U_ZERO_ERROR for uloc_addLikelySubtags(), minimal \"%s\" expected status %s\n", minimal, u_errorName(expectedStatus));
+ status = U_ZERO_ERROR;
+ }
+ else if (status != expectedStatus) {
+ log_err_status(status, " unexpected status for uloc_addLikelySubtags(), minimal \"%s\" expected status %s, but got %s\n", minimal, u_errorName(expectedStatus), u_errorName(status));
+ }
+ else if (length != expectedLength) {
+ log_err(" unexpected length for uloc_addLikelySubtags(), minimal \"%s\" expected length %d, but got %d\n", minimal, expectedLength, length);
+ }
+ else if (status == U_BUFFER_OVERFLOW_ERROR || status == U_STRING_NOT_TERMINATED_WARNING) {
+ if (uprv_strnicmp(maximal, buffer, bufferSize) != 0) {
+ log_err(" maximal doesn't match expected %s in uloc_addLikelySubtags(), minimal \"%s\" = %*s\n",
+ maximal, minimal, (int)sizeof(buffer), buffer);
+ }
+ }
+ }
+
+ for (i = 0; i < sizeof(minimizeErrors) / sizeof(minimizeErrors[0]); ++i) {
+
+ UErrorCode status = U_ZERO_ERROR;
+ const char* const maximal = minimizeErrors[i].tag;
+ const char* const minimal = minimizeErrors[i].expected;
+ const UErrorCode expectedStatus = minimizeErrors[i].uerror;
+ const int32_t expectedLength = getExpectedReturnValue(&minimizeErrors[i]);
+ const int32_t bufferSize = getBufferSize(&minimizeErrors[i], sizeof(buffer));
+
+ const int32_t length =
+ uloc_minimizeSubtags(
+ maximal,
+ buffer,
+ bufferSize,
+ &status);
+
+ if (status == U_ZERO_ERROR) {
+ log_err(" unexpected U_ZERO_ERROR for uloc_minimizeSubtags(), maximal \"%s\" expected status %s\n", maximal, u_errorName(expectedStatus));
+ status = U_ZERO_ERROR;
+ }
+ else if (status != expectedStatus) {
+ log_err_status(status, " unexpected status for uloc_minimizeSubtags(), maximal \"%s\" expected status %s, but got %s\n", maximal, u_errorName(expectedStatus), u_errorName(status));
+ }
+ else if (length != expectedLength) {
+ log_err(" unexpected length for uloc_minimizeSubtags(), maximal \"%s\" expected length %d, but got %d\n", maximal, expectedLength, length);
+ }
+ else if (status == U_BUFFER_OVERFLOW_ERROR || status == U_STRING_NOT_TERMINATED_WARNING) {
+ if (uprv_strnicmp(minimal, buffer, bufferSize) != 0) {
+ log_err(" minimal doesn't match expected \"%s\" in uloc_minimizeSubtags(), minimal \"%s\" = \"%*s\"\n",
+ minimal, maximal, (int)sizeof(buffer), buffer);
+ }
+ }
+ }
+}
+
+const char* const locale_to_langtag[][3] = {
+ {"", "und", "und"},
+ {"en", "en", "en"},
+ {"en_US", "en-US", "en-US"},
+ {"iw_IL", "he-IL", "he-IL"},
+ {"sr_Latn_SR", "sr-Latn-SR", "sr-Latn-SR"},
+ {"en__POSIX", "en-u-va-posix", "en-u-va-posix"},
+ {"en_POSIX", "en-u-va-posix", "en-u-va-posix"},
+ {"en_US_POSIX@ca=japanese", "en-US-u-ca-japanese-va-posix", "en-US-u-ca-japanese-va-posix"},
+ {"und_555", "und-555", "und-555"},
+ {"123", "und", NULL},
+ {"%$#&", "und", NULL},
+ {"_Latn", "und-Latn", "und-Latn"},
+ {"_DE", "und-DE", "und-DE"},
+ {"und_FR", "und-FR", "und-FR"},
+ {"th_TH_TH", "th-TH", NULL},
+ {"bogus", "bogus", "bogus"},
+ {"foooobarrr", "und", NULL},
+ {"az_AZ_CYRL", "az-Cyrl-AZ", "az-Cyrl-AZ"},
+ {"aa_BB_CYRL", "aa-BB", NULL},
+ {"en_US_1234", "en-US-1234", "en-US-1234"},
+ {"en_US_VARIANTA_VARIANTB", "en-US-varianta-variantb", "en-US-varianta-variantb"},
+ {"en_US_VARIANTB_VARIANTA", "en-US-varianta-variantb", "en-US-varianta-variantb"},
+ {"ja__9876_5432", "ja-5432-9876", "ja-5432-9876"},
+ {"zh_Hant__VAR", "zh-Hant", NULL},
+ {"es__BADVARIANT_GOODVAR", "es-goodvar", NULL},
+ {"en@calendar=gregorian", "en-u-ca-gregory", "en-u-ca-gregory"},
+ {"de@collation=phonebook;calendar=gregorian", "de-u-ca-gregory-co-phonebk", "de-u-ca-gregory-co-phonebk"},
+ {"th@numbers=thai;z=extz;x=priv-use;a=exta", "th-a-exta-u-nu-thai-z-extz-x-priv-use", "th-a-exta-u-nu-thai-z-extz-x-priv-use"},
+ {"en@timezone=America/New_York;calendar=japanese", "en-u-ca-japanese-tz-usnyc", "en-u-ca-japanese-tz-usnyc"},
+ {"en@timezone=US/Eastern", "en-u-tz-usnyc", "en-u-tz-usnyc"},
+ {"en@x=x-y-z;a=a-b-c", "en-x-x-y-z", NULL},
+ {"it@collation=badcollationtype;colStrength=identical;cu=usd-eur", "it-u-ks-identic", NULL},
+ {"en_US_POSIX", "en-US-u-va-posix", "en-US-u-va-posix"},
+ {"en_US_POSIX@calendar=japanese;currency=EUR","en-US-u-ca-japanese-cu-EUR-va-posix", "en-US-u-ca-japanese-cu-EUR-va-posix"},
+
+ {NULL, NULL, NULL}
+};
+
+static void TestToLanguageTag(void) {
+ char langtag[256];
+ int32_t i;
+ UErrorCode status;
+ int32_t len;
+ const char *inloc;
+ const char *expected;
+
+ for (i = 0; locale_to_langtag[i][0] != NULL; i++) {
+ inloc = locale_to_langtag[i][0];
+
+ /* testing non-strict mode */
+ status = U_ZERO_ERROR;
+ langtag[0] = 0;
+ expected = locale_to_langtag[i][1];
+
+ len = uloc_toLanguageTag(inloc, langtag, sizeof(langtag), FALSE, &status);
+ if (U_FAILURE(status)) {
+ if (expected != NULL) {
+ log_err("Error returned by uloc_toLanguageTag for locale id [%s] - error: %s\n",
+ inloc, u_errorName(status));
+ }
+ } else {
+ if (expected == NULL) {
+ log_err("Error should be returned by uloc_toLanguageTag for locale id [%s], but [%s] is returned without errors\n",
+ inloc, langtag);
+ } else if (uprv_strcmp(langtag, expected) != 0) {
+ log_data_err("uloc_toLanguageTag returned language tag [%s] for input locale [%s] - expected: [%s]. Are you missing data?\n",
+ langtag, inloc, expected);
+ }
+ }
+
+ /* testing strict mode */
+ status = U_ZERO_ERROR;
+ langtag[0] = 0;
+ expected = locale_to_langtag[i][2];
+
+ len = uloc_toLanguageTag(inloc, langtag, sizeof(langtag), TRUE, &status);
+ if (U_FAILURE(status)) {
+ if (expected != NULL) {
+ log_data_err("Error returned by uloc_toLanguageTag {strict} for locale id [%s] - error: %s Are you missing data?\n",
+ inloc, u_errorName(status));
+ }
+ } else {
+ if (expected == NULL) {
+ log_err("Error should be returned by uloc_toLanguageTag {strict} for locale id [%s], but [%s] is returned without errors\n",
+ inloc, langtag);
+ } else if (uprv_strcmp(langtag, expected) != 0) {
+ log_err("uloc_toLanguageTag {strict} returned language tag [%s] for input locale [%s] - expected: [%s]\n",
+ langtag, inloc, expected);
+ }
+ }
+ }
+}
+
+static const struct {
+ const char *bcpID;
+ const char *locID;
+ int32_t len;
+} langtag_to_locale[] = {
+ {"en", "en", 2},
+ {"en-us", "en_US", 5},
+ {"und-US", "_US", 6},
+ {"und-latn", "_Latn", 8},
+ {"en-US-posix", "en_US_POSIX", 11},
+ {"de-de_euro", "de", 2},
+ {"kok-IN", "kok_IN", 6},
+ {"123", "", 0},
+ {"en_us", "", 0},
+ {"en-latn-x", "en_Latn", 7},
+ {"art-lojban", "jbo", 10},
+ {"zh-hakka", "hak", 8},
+ {"zh-cmn-CH", "cmn_CH", 9},
+ {"xxx-yy", "xxx_YY", 6},
+ {"fr-234", "fr_234", 6},
+ {"i-default", "", 9},
+ {"i-test", "", 0},
+ {"ja-jp-jp", "ja_JP", 5},
+ {"bogus", "bogus", 5},
+ {"boguslang", "", 0},
+ {"EN-lATN-us", "en_Latn_US", 10},
+ {"und-variant-1234", "__1234_VARIANT", 16},
+ {"und-varzero-var1-vartwo", "__VARZERO", 11},
+ {"en-u-ca-gregory", "en@calendar=gregorian", 15},
+ {"en-U-cu-USD", "en@currency=usd", 11},
+ {"en-US-u-va-posix", "en_US_POSIX", 16},
+ {"ar-x-1-2-3", "ar@x=1-2-3", 10},
+ {"fr-u-nu-latn-cu-eur", "fr@currency=eur;numbers=latn", 19},
+ {"de-k-kext-u-co-phonebk-nu-latn", "de@collation=phonebook;k=kext;numbers=latn", 30},
+ {"ja-u-cu-jpy-ca-jp", "ja@currency=jpy", 11},
+ {"en-us-u-tz-usnyc", "en_US@timezone=America/New_York", 16},
+ {"und-a-abc-def", "und@a=abc-def", 13},
+ {"zh-u-ca-chinese-x-u-ca-chinese", "zh@calendar=chinese;x=u-ca-chinese", 30},
+ {NULL, NULL, 0}
+};
+
+static void TestForLanguageTag(void) {
+ char locale[256];
+ int32_t i;
+ UErrorCode status;
+ int32_t parsedLen;
+
+ for (i = 0; langtag_to_locale[i].bcpID != NULL; i++) {
+ status = U_ZERO_ERROR;
+ locale[0] = 0;
+ uloc_forLanguageTag(langtag_to_locale[i].bcpID, locale, sizeof(locale), &parsedLen, &status);
+ if (U_FAILURE(status)) {
+ log_err_status(status, "Error returned by uloc_forLanguageTag for language tag [%s] - error: %s\n",
+ langtag_to_locale[i].bcpID, u_errorName(status));
+ } else {
+ if (uprv_strcmp(langtag_to_locale[i].locID, locale) != 0) {
+ log_err("uloc_forLanguageTag returned locale [%s] for input language tag [%s] - expected: [%s]\n",
+ locale, langtag_to_locale[i].bcpID, langtag_to_locale[i].locID);
+ }
+ if (parsedLen != langtag_to_locale[i].len) {
+ log_err("uloc_forLanguageTag parsed length of %d for input language tag [%s] - expected parsed length: %d\n",
+ parsedLen, langtag_to_locale[i].bcpID, langtag_to_locale[i].len);
+ }
+ }
+ }
+}
+
+static void test_unicode_define(const char *namech, char ch, const char *nameu, UChar uch)
+{
+ UChar asUch[1];
+ asUch[0]=0;
+ log_verbose("Testing whether %s[\\x%02x,'%c'] == %s[U+%04X]\n", namech, ch,(int)ch, nameu, (int) uch);
+ u_charsToUChars(&ch, asUch, 1);
+ if(asUch[0] != uch) {
+ log_err("FAIL: %s[\\x%02x,'%c'] maps to U+%04X, but %s = U+%04X\n", namech, ch, (int)ch, (int)asUch[0], nameu, (int)uch);
+ } else {
+ log_verbose(" .. OK, == U+%04X\n", (int)asUch[0]);
+ }
+}
+
+#define TEST_UNICODE_DEFINE(x,y) test_unicode_define(#x, (char)(x), #y, (UChar)(y))
+
+static void TestUnicodeDefines(void) {
+ TEST_UNICODE_DEFINE(ULOC_KEYWORD_SEPARATOR, ULOC_KEYWORD_SEPARATOR_UNICODE);
+ TEST_UNICODE_DEFINE(ULOC_KEYWORD_ASSIGN, ULOC_KEYWORD_ASSIGN_UNICODE);
+ TEST_UNICODE_DEFINE(ULOC_KEYWORD_ITEM_SEPARATOR, ULOC_KEYWORD_ITEM_SEPARATOR_UNICODE);
+}