| // © 2016 and later: Unicode, Inc. and others. |
| // License & terms of use: http://www.unicode.org/copyright.html |
| /******************************************************************** |
| * COPYRIGHT: |
| * Copyright (c) 1997-2016, International Business Machines Corporation and |
| * others. All Rights Reserved. |
| ********************************************************************/ |
| |
| #include <algorithm> |
| #include <functional> |
| #include <iterator> |
| #include <set> |
| #include <utility> |
| |
| #include "loctest.h" |
| #include "unicode/localebuilder.h" |
| #include "unicode/localpointer.h" |
| #include "unicode/decimfmt.h" |
| #include "unicode/ucurr.h" |
| #include "unicode/smpdtfmt.h" |
| #include "unicode/strenum.h" |
| #include "unicode/dtfmtsym.h" |
| #include "unicode/brkiter.h" |
| #include "unicode/coll.h" |
| #include "unicode/ustring.h" |
| #include "unicode/std_string.h" |
| #include "charstr.h" |
| #include "cmemory.h" |
| #include "cstring.h" |
| #include <stdio.h> |
| #include <string.h> |
| #include "putilimp.h" |
| #include "hash.h" |
| #include "locmap.h" |
| #include "uparse.h" |
| #include "ulocimp.h" |
| |
| static const char* const rawData[33][8] = { |
| |
| // language code |
| { "en", "fr", "ca", "el", "no", "it", "xx", "zh" }, |
| // script code |
| { "", "", "", "", "", "", "", "Hans" }, |
| // country code |
| { "US", "FR", "ES", "GR", "NO", "", "YY", "CN" }, |
| // variant code |
| { "", "", "", "", "NY", "", "", "" }, |
| // full name |
| { "en_US", "fr_FR", "ca_ES", "el_GR", "no_NO_NY", "it", "xx_YY", "zh_Hans_CN" }, |
| // ISO-3 language |
| { "eng", "fra", "cat", "ell", "nor", "ita", "", "zho" }, |
| // ISO-3 country |
| { "USA", "FRA", "ESP", "GRC", "NOR", "", "", "CHN" }, |
| // LCID |
| { "409", "40c", "403", "408", "814", "10", "0", "804" }, |
| |
| // display language (English) |
| { "English", "French", "Catalan", "Greek", "Norwegian", "Italian", "xx", "Chinese" }, |
| // display script (English) |
| { "", "", "", "", "", "", "", "Simplified Han" }, |
| // display country (English) |
| { "United States", "France", "Spain", "Greece", "Norway", "", "YY", "China" }, |
| // display variant (English) |
| { "", "", "", "", "NY", "", "", ""}, |
| // display name (English) |
| // Updated no_NO_NY English display name for new pattern-based algorithm |
| // (part of Euro support). |
| { "English (United States)", "French (France)", "Catalan (Spain)", "Greek (Greece)", "Norwegian (Norway, NY)", "Italian", "xx (YY)", "Chinese (Simplified, China)" }, |
| |
| // display language (French) |
| { "anglais", "fran\\u00E7ais", "catalan", "grec", "norv\\u00E9gien", "italien", "xx", "chinois" }, |
| // display script (French) |
| { "", "", "", "", "", "", "", "sinogrammes simplifi\\u00E9s" }, |
| // display country (French) |
| { "\\u00C9tats-Unis", "France", "Espagne", "Gr\\u00E8ce", "Norv\\u00E8ge", "", "YY", "Chine" }, |
| // display variant (French) |
| { "", "", "", "", "NY", "", "", "" }, |
| // display name (French) |
| //{ "anglais (Etats-Unis)", "francais (France)", "catalan (Espagne)", "grec (Grece)", "norvegien (Norvege,Nynorsk)", "italien", "xx (YY)" }, |
| { "anglais (\\u00C9tats-Unis)", "fran\\u00E7ais (France)", "catalan (Espagne)", "grec (Gr\\u00E8ce)", "norv\\u00E9gien (Norv\\u00E8ge, NY)", "italien", "xx (YY)", "chinois (simplifi\\u00E9, Chine)" }, |
| |
| |
| /* display language (Catalan) */ |
| { "angl\\u00E8s", "franc\\u00E8s", "catal\\u00E0", "grec", "noruec", "itali\\u00E0", "", "xin\\u00E8s" }, |
| /* display script (Catalan) */ |
| { "", "", "", "", "", "", "", "han simplificat" }, |
| /* display country (Catalan) */ |
| { "Estats Units", "Fran\\u00E7a", "Espanya", "Gr\\u00E8cia", "Noruega", "", "", "Xina" }, |
| /* display variant (Catalan) */ |
| { "", "", "", "", "NY", "", "" }, |
| /* display name (Catalan) */ |
| { "angl\\u00E8s (Estats Units)", "franc\\u00E8s (Fran\\u00E7a)", "catal\\u00E0 (Espanya)", "grec (Gr\\u00E8cia)", "noruec (Noruega, NY)", "itali\\u00E0", "", "xin\\u00E8s (simplificat, Xina)" }, |
| |
| // display language (Greek)[actual values listed below] |
| { "\\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", |
| "\\u0399\\u03c4\\u03b1\\u03bb\\u03b9\\u03ba\\u03ac", |
| "", |
| "\\u039A\\u03B9\\u03BD\\u03B5\\u03B6\\u03B9\\u03BA\\u03AC" |
| }, |
| // display script (Greek) |
| { "", "", "", "", "", "", "", "\\u0391\\u03c0\\u03bb\\u03bf\\u03c0\\u03bf\\u03b9\\u03b7\\u03bc\\u03ad\\u03bd\\u03bf \\u03a7\\u03b1\\u03bd" }, |
| // display country (Greek)[actual values listed below] |
| { "\\u0397\\u03BD\\u03C9\\u03BC\\u03AD\\u03BD\\u03B5\\u03C2 \\u03A0\\u03BF\\u03BB\\u03B9\\u03C4\\u03B5\\u03AF\\u03B5\\u03C2", |
| "\\u0393\\u03b1\\u03bb\\u03bb\\u03af\\u03b1", |
| "\\u0399\\u03c3\\u03c0\\u03b1\\u03bd\\u03af\\u03b1", |
| "\\u0395\\u03bb\\u03bb\\u03ac\\u03b4\\u03b1", |
| "\\u039d\\u03bf\\u03c1\\u03b2\\u03b7\\u03b3\\u03af\\u03b1", |
| "", |
| "", |
| "\\u039A\\u03AF\\u03BD\\u03B1" |
| }, |
| // display variant (Greek) |
| { "", "", "", "", "NY", "", "" }, |
| // display name (Greek)[actual values listed below] |
| { "\\u0391\\u03b3\\u03b3\\u03bb\\u03b9\\u03ba\\u03ac (\\u0397\\u03BD\\u03C9\\u03BC\\u03AD\\u03BD\\u03B5\\u03C2 \\u03A0\\u03BF\\u03BB\\u03B9\\u03C4\\u03B5\\u03AF\\u03B5\\u03C2)", |
| "\\u0393\\u03b1\\u03bb\\u03bb\\u03b9\\u03ba\\u03ac (\\u0393\\u03b1\\u03bb\\u03bb\\u03af\\u03b1)", |
| "\\u039a\\u03b1\\u03c4\\u03b1\\u03bb\\u03b1\\u03bd\\u03b9\\u03ba\\u03ac (\\u0399\\u03c3\\u03c0\\u03b1\\u03bd\\u03af\\u03b1)", |
| "\\u0395\\u03bb\\u03bb\\u03b7\\u03bd\\u03b9\\u03ba\\u03ac (\\u0395\\u03bb\\u03bb\\u03ac\\u03b4\\u03b1)", |
| "\\u039d\\u03bf\\u03c1\\u03b2\\u03b7\\u03b3\\u03b9\\u03ba\\u03ac (\\u039d\\u03bf\\u03c1\\u03b2\\u03b7\\u03b3\\u03af\\u03b1, NY)", |
| "\\u0399\\u03c4\\u03b1\\u03bb\\u03b9\\u03ba\\u03ac", |
| "", |
| "\\u039A\\u03B9\\u03BD\\u03B5\\u03B6\\u03B9\\u03BA\\u03AC (\\u0391\\u03c0\\u03bb\\u03bf\\u03c0\\u03bf\\u03b9\\u03b7\\u03bc\\u03ad\\u03bd\\u03bf, \\u039A\\u03AF\\u03BD\\u03B1)" |
| }, |
| |
| // display language (<root>) |
| { "English", "French", "Catalan", "Greek", "Norwegian", "Italian", "xx", "" }, |
| // display script (<root>) |
| { "", "", "", "", "", "", "", ""}, |
| // display country (<root>) |
| { "United States", "France", "Spain", "Greece", "Norway", "", "YY", "" }, |
| // display variant (<root>) |
| { "", "", "", "", "Nynorsk", "", "", ""}, |
| // display name (<root>) |
| //{ "English (United States)", "French (France)", "Catalan (Spain)", "Greek (Greece)", "Norwegian (Norway,Nynorsk)", "Italian", "xx (YY)" }, |
| { "English (United States)", "French (France)", "Catalan (Spain)", "Greek (Greece)", "Norwegian (Norway,NY)", "Italian", "xx (YY)", "" } |
| }; |
| |
| |
| /* |
| Usage: |
| test_assert( Test (should be TRUE) ) |
| |
| Example: |
| test_assert(i==3); |
| |
| the macro is ugly but makes the tests pretty. |
| */ |
| |
| #define test_assert(test) UPRV_BLOCK_MACRO_BEGIN { \ |
| if(!(test)) \ |
| errln("FAIL: " #test " was not true. In " __FILE__ " on line %d", __LINE__ ); \ |
| else \ |
| logln("PASS: asserted " #test); \ |
| } UPRV_BLOCK_MACRO_END |
| |
| /* |
| Usage: |
| test_assert_print( Test (should be TRUE), printable ) |
| |
| Example: |
| test_assert(i==3, toString(i)); |
| |
| the macro is ugly but makes the tests pretty. |
| */ |
| |
| #define test_assert_print(test,print) UPRV_BLOCK_MACRO_BEGIN { \ |
| if(!(test)) \ |
| errln("FAIL: " #test " was not true. " + UnicodeString(print) ); \ |
| else \ |
| logln("PASS: asserted " #test "-> " + UnicodeString(print)); \ |
| } UPRV_BLOCK_MACRO_END |
| |
| |
| #define test_dumpLocale(l) UPRV_BLOCK_MACRO_BEGIN { \ |
| logln(#l " = " + UnicodeString(l.getName(), "")); \ |
| } UPRV_BLOCK_MACRO_END |
| |
| LocaleTest::LocaleTest() |
| : dataTable(NULL) |
| { |
| setUpDataTable(); |
| } |
| |
| LocaleTest::~LocaleTest() |
| { |
| if (dataTable != 0) { |
| for (int32_t i = 0; i < 33; i++) { |
| delete []dataTable[i]; |
| } |
| delete []dataTable; |
| dataTable = 0; |
| } |
| } |
| |
| void LocaleTest::runIndexedTest( int32_t index, UBool exec, const char* &name, char* /*par*/ ) |
| { |
| TESTCASE_AUTO_BEGIN; |
| TESTCASE_AUTO(TestBug11421); // Must run early in list to trigger failure. |
| TESTCASE_AUTO(TestBasicGetters); |
| TESTCASE_AUTO(TestSimpleResourceInfo); |
| TESTCASE_AUTO(TestDisplayNames); |
| TESTCASE_AUTO(TestSimpleObjectStuff); |
| TESTCASE_AUTO(TestPOSIXParsing); |
| TESTCASE_AUTO(TestGetAvailableLocales); |
| TESTCASE_AUTO(TestDataDirectory); |
| TESTCASE_AUTO(TestISO3Fallback); |
| TESTCASE_AUTO(TestGetLangsAndCountries); |
| TESTCASE_AUTO(TestSimpleDisplayNames); |
| TESTCASE_AUTO(TestUninstalledISO3Names); |
| TESTCASE_AUTO(TestAtypicalLocales); |
| #if !UCONFIG_NO_FORMATTING |
| TESTCASE_AUTO(TestThaiCurrencyFormat); |
| TESTCASE_AUTO(TestEuroSupport); |
| #endif |
| TESTCASE_AUTO(TestToString); |
| #if !UCONFIG_NO_FORMATTING |
| TESTCASE_AUTO(Test4139940); |
| TESTCASE_AUTO(Test4143951); |
| #endif |
| TESTCASE_AUTO(Test4147315); |
| TESTCASE_AUTO(Test4147317); |
| TESTCASE_AUTO(Test4147552); |
| TESTCASE_AUTO(TestVariantParsing); |
| TESTCASE_AUTO(Test20639_DeprecatesISO3Language); |
| #if !UCONFIG_NO_FORMATTING |
| TESTCASE_AUTO(Test4105828); |
| #endif |
| TESTCASE_AUTO(TestSetIsBogus); |
| TESTCASE_AUTO(TestParallelAPIValues); |
| TESTCASE_AUTO(TestAddLikelySubtags); |
| TESTCASE_AUTO(TestMinimizeSubtags); |
| TESTCASE_AUTO(TestAddLikelyAndMinimizeSubtags); |
| TESTCASE_AUTO(TestKeywordVariants); |
| TESTCASE_AUTO(TestCreateUnicodeKeywords); |
| TESTCASE_AUTO(TestKeywordVariantParsing); |
| TESTCASE_AUTO(TestCreateKeywordSet); |
| TESTCASE_AUTO(TestCreateKeywordSetEmpty); |
| TESTCASE_AUTO(TestCreateUnicodeKeywordSet); |
| TESTCASE_AUTO(TestCreateUnicodeKeywordSetEmpty); |
| TESTCASE_AUTO(TestGetKeywordValueStdString); |
| TESTCASE_AUTO(TestGetUnicodeKeywordValueStdString); |
| TESTCASE_AUTO(TestSetKeywordValue); |
| TESTCASE_AUTO(TestSetKeywordValueStringPiece); |
| TESTCASE_AUTO(TestSetUnicodeKeywordValueStringPiece); |
| TESTCASE_AUTO(TestGetBaseName); |
| #if !UCONFIG_NO_FILE_IO |
| TESTCASE_AUTO(TestGetLocale); |
| #endif |
| TESTCASE_AUTO(TestVariantWithOutCountry); |
| TESTCASE_AUTO(TestCanonicalization); |
| TESTCASE_AUTO(TestCurrencyByDate); |
| TESTCASE_AUTO(TestGetVariantWithKeywords); |
| TESTCASE_AUTO(TestIsRightToLeft); |
| TESTCASE_AUTO(TestBug13277); |
| TESTCASE_AUTO(TestBug13554); |
| TESTCASE_AUTO(TestBug20410); |
| TESTCASE_AUTO(TestBug20900); |
| TESTCASE_AUTO(TestLocaleCanonicalizationFromFile); |
| TESTCASE_AUTO(TestKnownCanonicalizedListCorrect); |
| TESTCASE_AUTO(TestConstructorAcceptsBCP47); |
| TESTCASE_AUTO(TestForLanguageTag); |
| TESTCASE_AUTO(TestToLanguageTag); |
| TESTCASE_AUTO(TestToLanguageTagOmitTrue); |
| TESTCASE_AUTO(TestMoveAssign); |
| TESTCASE_AUTO(TestMoveCtor); |
| TESTCASE_AUTO(TestBug20407iVariantPreferredValue); |
| TESTCASE_AUTO(TestBug13417VeryLongLanguageTag); |
| TESTCASE_AUTO(TestBug11053UnderlineTimeZone); |
| TESTCASE_AUTO(TestUnd); |
| TESTCASE_AUTO(TestUndScript); |
| TESTCASE_AUTO(TestUndRegion); |
| TESTCASE_AUTO(TestUndCAPI); |
| TESTCASE_AUTO(TestRangeIterator); |
| TESTCASE_AUTO(TestPointerConvertingIterator); |
| TESTCASE_AUTO(TestTagConvertingIterator); |
| TESTCASE_AUTO(TestCapturingTagConvertingIterator); |
| TESTCASE_AUTO(TestSetUnicodeKeywordValueInLongLocale); |
| TESTCASE_AUTO(TestSetUnicodeKeywordValueNullInLongLocale); |
| TESTCASE_AUTO(TestCanonicalize); |
| TESTCASE_AUTO(TestLeak21419); |
| TESTCASE_AUTO_END; |
| } |
| |
| void LocaleTest::TestBasicGetters() { |
| UnicodeString temp; |
| |
| int32_t i; |
| for (i = 0; i <= MAX_LOCALES; i++) { |
| Locale testLocale(""); |
| if (rawData[SCRIPT][i] && rawData[SCRIPT][i][0] != 0) { |
| testLocale = Locale(rawData[LANG][i], rawData[SCRIPT][i], rawData[CTRY][i], rawData[VAR][i]); |
| } |
| else { |
| testLocale = Locale(rawData[LANG][i], rawData[CTRY][i], rawData[VAR][i]); |
| } |
| logln("Testing " + (UnicodeString)testLocale.getName() + "..."); |
| |
| if ( (temp=testLocale.getLanguage()) != (dataTable[LANG][i])) |
| errln(" Language code mismatch: " + temp + " versus " |
| + dataTable[LANG][i]); |
| if ( (temp=testLocale.getScript()) != (dataTable[SCRIPT][i])) |
| errln(" Script code mismatch: " + temp + " versus " |
| + dataTable[SCRIPT][i]); |
| if ( (temp=testLocale.getCountry()) != (dataTable[CTRY][i])) |
| errln(" Country code mismatch: " + temp + " versus " |
| + dataTable[CTRY][i]); |
| if ( (temp=testLocale.getVariant()) != (dataTable[VAR][i])) |
| errln(" Variant code mismatch: " + temp + " versus " |
| + dataTable[VAR][i]); |
| if ( (temp=testLocale.getName()) != (dataTable[NAME][i])) |
| errln(" Locale name mismatch: " + temp + " versus " |
| + dataTable[NAME][i]); |
| } |
| |
| logln("Same thing without variant codes..."); |
| for (i = 0; i <= MAX_LOCALES; i++) { |
| Locale testLocale(""); |
| if (rawData[SCRIPT][i] && rawData[SCRIPT][i][0] != 0) { |
| testLocale = Locale(rawData[LANG][i], rawData[SCRIPT][i], rawData[CTRY][i]); |
| } |
| else { |
| testLocale = Locale(rawData[LANG][i], rawData[CTRY][i]); |
| } |
| logln("Testing " + (temp=testLocale.getName()) + "..."); |
| |
| if ( (temp=testLocale.getLanguage()) != (dataTable[LANG][i])) |
| errln("Language code mismatch: " + temp + " versus " |
| + dataTable[LANG][i]); |
| if ( (temp=testLocale.getScript()) != (dataTable[SCRIPT][i])) |
| errln("Script code mismatch: " + temp + " versus " |
| + dataTable[SCRIPT][i]); |
| if ( (temp=testLocale.getCountry()) != (dataTable[CTRY][i])) |
| errln("Country code mismatch: " + temp + " versus " |
| + dataTable[CTRY][i]); |
| if (testLocale.getVariant()[0] != 0) |
| errln("Variant code mismatch: something versus \"\""); |
| } |
| |
| logln("Testing long language names and getters"); |
| Locale test8 = Locale::createFromName("x-klingon-latn-zx.utf32be@special"); |
| |
| temp = test8.getLanguage(); |
| if (temp != UnicodeString("x-klingon") ) |
| errln("Language code mismatch: " + temp + " versus \"x-klingon\""); |
| |
| temp = test8.getScript(); |
| if (temp != UnicodeString("Latn") ) |
| errln("Script code mismatch: " + temp + " versus \"Latn\""); |
| |
| temp = test8.getCountry(); |
| if (temp != UnicodeString("ZX") ) |
| errln("Country code mismatch: " + temp + " versus \"ZX\""); |
| |
| temp = test8.getVariant(); |
| //if (temp != UnicodeString("SPECIAL") ) |
| // errln("Variant code mismatch: " + temp + " versus \"SPECIAL\""); |
| // As of 3.0, the "@special" will *not* be parsed by uloc_getName() |
| if (temp != UnicodeString("") ) |
| errln("Variant code mismatch: " + temp + " versus \"\""); |
| |
| if (Locale::getDefault() != Locale::createFromName(NULL)) |
| errln("Locale::getDefault() == Locale::createFromName(NULL)"); |
| |
| /*----------*/ |
| // NOTE: There used to be a special test for locale names that had language or |
| // country codes that were longer than two letters. The new version of Locale |
| // doesn't support anything that isn't an officially recognized language or |
| // country code, so we no longer support this feature. |
| |
| Locale bogusLang("THISISABOGUSLANGUAGE"); // Jitterbug 2864: language code too long |
| if(!bogusLang.isBogus()) { |
| errln("Locale(\"THISISABOGUSLANGUAGE\").isBogus()==FALSE"); |
| } |
| |
| bogusLang=Locale("eo"); |
| if( bogusLang.isBogus() || |
| strcmp(bogusLang.getLanguage(), "eo")!=0 || |
| *bogusLang.getCountry()!=0 || |
| *bogusLang.getVariant()!=0 || |
| strcmp(bogusLang.getName(), "eo")!=0 |
| ) { |
| errln("assignment to bogus Locale does not unbogus it or sets bad data"); |
| } |
| |
| Locale a("eo_DE@currency=DEM"); |
| Locale *pb=a.clone(); |
| if(pb==&a || *pb!=a) { |
| errln("Locale.clone() failed"); |
| } |
| delete pb; |
| } |
| |
| void LocaleTest::TestParallelAPIValues() { |
| logln("Test synchronization between C and C++ API"); |
| if (strcmp(Locale::getChinese().getName(), ULOC_CHINESE) != 0) { |
| errln("Differences for ULOC_CHINESE Locale"); |
| } |
| if (strcmp(Locale::getEnglish().getName(), ULOC_ENGLISH) != 0) { |
| errln("Differences for ULOC_ENGLISH Locale"); |
| } |
| if (strcmp(Locale::getFrench().getName(), ULOC_FRENCH) != 0) { |
| errln("Differences for ULOC_FRENCH Locale"); |
| } |
| if (strcmp(Locale::getGerman().getName(), ULOC_GERMAN) != 0) { |
| errln("Differences for ULOC_GERMAN Locale"); |
| } |
| if (strcmp(Locale::getItalian().getName(), ULOC_ITALIAN) != 0) { |
| errln("Differences for ULOC_ITALIAN Locale"); |
| } |
| if (strcmp(Locale::getJapanese().getName(), ULOC_JAPANESE) != 0) { |
| errln("Differences for ULOC_JAPANESE Locale"); |
| } |
| if (strcmp(Locale::getKorean().getName(), ULOC_KOREAN) != 0) { |
| errln("Differences for ULOC_KOREAN Locale"); |
| } |
| if (strcmp(Locale::getSimplifiedChinese().getName(), ULOC_SIMPLIFIED_CHINESE) != 0) { |
| errln("Differences for ULOC_SIMPLIFIED_CHINESE Locale"); |
| } |
| if (strcmp(Locale::getTraditionalChinese().getName(), ULOC_TRADITIONAL_CHINESE) != 0) { |
| errln("Differences for ULOC_TRADITIONAL_CHINESE Locale"); |
| } |
| |
| |
| if (strcmp(Locale::getCanada().getName(), ULOC_CANADA) != 0) { |
| errln("Differences for ULOC_CANADA Locale"); |
| } |
| if (strcmp(Locale::getCanadaFrench().getName(), ULOC_CANADA_FRENCH) != 0) { |
| errln("Differences for ULOC_CANADA_FRENCH Locale"); |
| } |
| if (strcmp(Locale::getChina().getName(), ULOC_CHINA) != 0) { |
| errln("Differences for ULOC_CHINA Locale"); |
| } |
| if (strcmp(Locale::getPRC().getName(), ULOC_PRC) != 0) { |
| errln("Differences for ULOC_PRC Locale"); |
| } |
| if (strcmp(Locale::getFrance().getName(), ULOC_FRANCE) != 0) { |
| errln("Differences for ULOC_FRANCE Locale"); |
| } |
| if (strcmp(Locale::getGermany().getName(), ULOC_GERMANY) != 0) { |
| errln("Differences for ULOC_GERMANY Locale"); |
| } |
| if (strcmp(Locale::getItaly().getName(), ULOC_ITALY) != 0) { |
| errln("Differences for ULOC_ITALY Locale"); |
| } |
| if (strcmp(Locale::getJapan().getName(), ULOC_JAPAN) != 0) { |
| errln("Differences for ULOC_JAPAN Locale"); |
| } |
| if (strcmp(Locale::getKorea().getName(), ULOC_KOREA) != 0) { |
| errln("Differences for ULOC_KOREA Locale"); |
| } |
| if (strcmp(Locale::getTaiwan().getName(), ULOC_TAIWAN) != 0) { |
| errln("Differences for ULOC_TAIWAN Locale"); |
| } |
| if (strcmp(Locale::getUK().getName(), ULOC_UK) != 0) { |
| errln("Differences for ULOC_UK Locale"); |
| } |
| if (strcmp(Locale::getUS().getName(), ULOC_US) != 0) { |
| errln("Differences for ULOC_US Locale"); |
| } |
| } |
| |
| |
| void LocaleTest::TestSimpleResourceInfo() { |
| UnicodeString temp; |
| char temp2[20]; |
| UErrorCode err = U_ZERO_ERROR; |
| int32_t i = 0; |
| |
| for (i = 0; i <= MAX_LOCALES; i++) { |
| Locale testLocale(rawData[LANG][i], rawData[CTRY][i], rawData[VAR][i]); |
| logln("Testing " + (temp=testLocale.getName()) + "..."); |
| |
| if ( (temp=testLocale.getISO3Language()) != (dataTable[LANG3][i])) |
| errln(" ISO-3 language code mismatch: " + temp |
| + " versus " + dataTable[LANG3][i]); |
| if ( (temp=testLocale.getISO3Country()) != (dataTable[CTRY3][i])) |
| errln(" ISO-3 country code mismatch: " + temp |
| + " versus " + dataTable[CTRY3][i]); |
| |
| sprintf(temp2, "%x", (int)testLocale.getLCID()); |
| if (UnicodeString(temp2) != dataTable[LCID][i]) |
| errln((UnicodeString)" LCID mismatch: " + temp2 + " versus " |
| + dataTable[LCID][i]); |
| |
| if(U_FAILURE(err)) |
| { |
| errln((UnicodeString)"Some error on number " + i + u_errorName(err)); |
| } |
| err = U_ZERO_ERROR; |
| } |
| |
| Locale locale("en"); |
| if(strcmp(locale.getName(), "en") != 0|| |
| strcmp(locale.getLanguage(), "en") != 0) { |
| errln("construction of Locale(en) failed\n"); |
| } |
| /*-----*/ |
| |
| } |
| |
| /* |
| * Jitterbug 2439 -- markus 20030425 |
| * |
| * The lookup of display names must not fall back through the default |
| * locale because that yields useless results. |
| */ |
| void |
| LocaleTest::TestDisplayNames() |
| { |
| Locale english("en", "US"); |
| Locale french("fr", "FR"); |
| Locale croatian("ca", "ES"); |
| Locale greek("el", "GR"); |
| |
| logln(" In locale = en_US..."); |
| doTestDisplayNames(english, DLANG_EN); |
| logln(" In locale = fr_FR..."); |
| doTestDisplayNames(french, DLANG_FR); |
| logln(" In locale = ca_ES..."); |
| doTestDisplayNames(croatian, DLANG_CA); |
| logln(" In locale = el_GR..."); |
| doTestDisplayNames(greek, DLANG_EL); |
| |
| UnicodeString s; |
| UErrorCode status = U_ZERO_ERROR; |
| |
| #if !UCONFIG_NO_FORMATTING |
| DecimalFormatSymbols symb(status); |
| /* Check to see if ICU supports this locale */ |
| if (symb.getLocale(ULOC_VALID_LOCALE, status) != Locale("root")) { |
| /* test that the default locale has a display name for its own language */ |
| /* Currently, there is no language information in the "tl" data file so this test will fail if default locale is "tl" */ |
| if (uprv_strcmp(Locale().getLanguage(), "tl") != 0) { |
| Locale().getDisplayLanguage(Locale(), s); |
| if(s.length()<=3 && s.charAt(0)<=0x7f) { |
| /* check <=3 to reject getting the language code as a display name */ |
| dataerrln("unable to get a display string for the language of the default locale: " + s); |
| } |
| |
| /* |
| * API coverage improvements: call |
| * Locale::getDisplayLanguage(UnicodeString &) and |
| * Locale::getDisplayCountry(UnicodeString &) |
| */ |
| s.remove(); |
| Locale().getDisplayLanguage(s); |
| if(s.length()<=3 && s.charAt(0)<=0x7f) { |
| dataerrln("unable to get a display string for the language of the default locale [2]: " + s); |
| } |
| } |
| } |
| else { |
| logln("Default locale %s is unsupported by ICU\n", Locale().getName()); |
| } |
| s.remove(); |
| #endif |
| |
| french.getDisplayCountry(s); |
| if(s.isEmpty()) { |
| errln("unable to get any default-locale display string for the country of fr_FR\n"); |
| } |
| s.remove(); |
| Locale("zh", "Hant").getDisplayScript(s); |
| if(s.isEmpty()) { |
| errln("unable to get any default-locale display string for the country of zh_Hant\n"); |
| } |
| } |
| |
| void LocaleTest::TestSimpleObjectStuff() { |
| Locale test1("aa", "AA"); |
| Locale test2("aa", "AA"); |
| Locale test3(test1); |
| Locale test4("zz", "ZZ"); |
| Locale test5("aa", "AA", ""); |
| Locale test6("aa", "AA", "ANTARES"); |
| Locale test7("aa", "AA", "JUPITER"); |
| Locale test8 = Locale::createFromName("aa-aa-jupiTER"); // was "aa-aa.utf8@jupiter" but in 3.0 getName won't normalize that |
| |
| // now list them all for debugging usage. |
| test_dumpLocale(test1); |
| test_dumpLocale(test2); |
| test_dumpLocale(test3); |
| test_dumpLocale(test4); |
| test_dumpLocale(test5); |
| test_dumpLocale(test6); |
| test_dumpLocale(test7); |
| test_dumpLocale(test8); |
| |
| // Make sure things compare to themselves! |
| test_assert(test1 == test1); |
| test_assert(test2 == test2); |
| test_assert(test3 == test3); |
| test_assert(test4 == test4); |
| test_assert(test5 == test5); |
| test_assert(test6 == test6); |
| test_assert(test7 == test7); |
| test_assert(test8 == test8); |
| |
| // make sure things are not equal to themselves. |
| test_assert(!(test1 != test1)); |
| test_assert(!(test2 != test2)); |
| test_assert(!(test3 != test3)); |
| test_assert(!(test4 != test4)); |
| test_assert(!(test5 != test5)); |
| test_assert(!(test6 != test6)); |
| test_assert(!(test7 != test7)); |
| test_assert(!(test8 != test8)); |
| |
| // make sure things that are equal to each other don't show up as unequal. |
| test_assert(!(test1 != test2)); |
| test_assert(!(test2 != test1)); |
| test_assert(!(test1 != test3)); |
| test_assert(!(test2 != test3)); |
| test_assert(test5 == test1); |
| test_assert(test6 != test2); |
| test_assert(test6 != test5); |
| |
| test_assert(test6 != test7); |
| |
| // test for things that shouldn't compare equal. |
| test_assert(!(test1 == test4)); |
| test_assert(!(test2 == test4)); |
| test_assert(!(test3 == test4)); |
| |
| test_assert(test7 == test8); |
| |
| // test for hash codes to be the same. |
| int32_t hash1 = test1.hashCode(); |
| int32_t hash2 = test2.hashCode(); |
| int32_t hash3 = test3.hashCode(); |
| |
| test_assert(hash1 == hash2); |
| test_assert(hash1 == hash3); |
| test_assert(hash2 == hash3); |
| |
| // test that the assignment operator works. |
| test4 = test1; |
| logln("test4=test1;"); |
| test_dumpLocale(test4); |
| test_assert(test4 == test4); |
| |
| test_assert(!(test1 != test4)); |
| test_assert(!(test2 != test4)); |
| test_assert(!(test3 != test4)); |
| test_assert(test1 == test4); |
| test_assert(test4 == test1); |
| |
| // test assignments with a variant |
| logln("test7 = test6"); |
| test7 = test6; |
| test_dumpLocale(test7); |
| test_assert(test7 == test7); |
| test_assert(test7 == test6); |
| test_assert(test7 != test5); |
| |
| logln("test6 = test1"); |
| test6=test1; |
| test_dumpLocale(test6); |
| test_assert(test6 != test7); |
| test_assert(test6 == test1); |
| test_assert(test6 == test6); |
| } |
| |
| // A class which exposes constructors that are implemented in terms of the POSIX parsing code. |
| class POSIXLocale : public Locale |
| { |
| public: |
| POSIXLocale(const UnicodeString& l) |
| :Locale() |
| { |
| char *ch; |
| ch = new char[l.length() + 1]; |
| ch[l.extract(0, 0x7fffffff, ch, "")] = 0; |
| setFromPOSIXID(ch); |
| delete [] ch; |
| } |
| POSIXLocale(const char *l) |
| :Locale() |
| { |
| setFromPOSIXID(l); |
| } |
| }; |
| |
| void LocaleTest::TestPOSIXParsing() |
| { |
| POSIXLocale test1("ab_AB"); |
| POSIXLocale test2(UnicodeString("ab_AB")); |
| Locale test3("ab","AB"); |
| |
| POSIXLocale test4("ab_AB_Antares"); |
| POSIXLocale test5(UnicodeString("ab_AB_Antares")); |
| Locale test6("ab", "AB", "Antares"); |
| |
| test_dumpLocale(test1); |
| test_dumpLocale(test2); |
| test_dumpLocale(test3); |
| test_dumpLocale(test4); |
| test_dumpLocale(test5); |
| test_dumpLocale(test6); |
| |
| test_assert(test1 == test1); |
| |
| test_assert(test1 == test2); |
| test_assert(test2 == test3); |
| test_assert(test3 == test1); |
| |
| test_assert(test4 == test5); |
| test_assert(test5 == test6); |
| test_assert(test6 == test4); |
| |
| test_assert(test1 != test4); |
| test_assert(test5 != test3); |
| test_assert(test5 != test2); |
| |
| int32_t hash1 = test1.hashCode(); |
| int32_t hash2 = test2.hashCode(); |
| int32_t hash3 = test3.hashCode(); |
| |
| test_assert(hash1 == hash2); |
| test_assert(hash2 == hash3); |
| test_assert(hash3 == hash1); |
| } |
| |
| void LocaleTest::TestGetAvailableLocales() |
| { |
| int32_t locCount = 0; |
| const Locale* locList = Locale::getAvailableLocales(locCount); |
| |
| if (locCount == 0) |
| dataerrln("getAvailableLocales() returned an empty list!"); |
| else { |
| logln(UnicodeString("Number of locales returned = ") + locCount); |
| UnicodeString temp; |
| for(int32_t i = 0; i < locCount; ++i) |
| logln(locList[i].getName()); |
| } |
| // I have no idea how to test this function... |
| } |
| |
| // This test isn't applicable anymore - getISO3Language is |
| // independent of the data directory |
| void LocaleTest::TestDataDirectory() |
| { |
| /* |
| char oldDirectory[80]; |
| const char* temp; |
| UErrorCode err = U_ZERO_ERROR; |
| UnicodeString testValue; |
| |
| temp = Locale::getDataDirectory(); |
| strcpy(oldDirectory, temp); |
| logln(UnicodeString("oldDirectory = ") + oldDirectory); |
| |
| Locale test(Locale::US); |
| test.getISO3Language(testValue); |
| logln("first fetch of language retrieved " + testValue); |
| if (testValue != "eng") |
| errln("Initial check of ISO3 language failed: expected \"eng\", got \"" + testValue + "\""); |
| |
| { |
| char *path; |
| path=IntlTest::getTestDirectory(); |
| Locale::setDataDirectory( path ); |
| } |
| |
| test.getISO3Language(testValue); |
| logln("second fetch of language retrieved " + testValue); |
| if (testValue != "xxx") |
| errln("setDataDirectory() failed: expected \"xxx\", got \"" + testValue + "\""); |
| |
| Locale::setDataDirectory(oldDirectory); |
| test.getISO3Language(testValue); |
| logln("third fetch of language retrieved " + testValue); |
| if (testValue != "eng") |
| errln("get/setDataDirectory() failed: expected \"eng\", got \"" + testValue + "\""); |
| */ |
| } |
| |
| //=========================================================== |
| |
| void LocaleTest::doTestDisplayNames(Locale& displayLocale, int32_t compareIndex) { |
| UnicodeString temp; |
| |
| for (int32_t i = 0; i <= MAX_LOCALES; i++) { |
| Locale testLocale(""); |
| if (rawData[SCRIPT][i] && rawData[SCRIPT][i][0] != 0) { |
| testLocale = Locale(rawData[LANG][i], rawData[SCRIPT][i], rawData[CTRY][i], rawData[VAR][i]); |
| } |
| else { |
| testLocale = Locale(rawData[LANG][i], rawData[CTRY][i], rawData[VAR][i]); |
| } |
| logln(" Testing " + (temp=testLocale.getName()) + "..."); |
| |
| UnicodeString testLang; |
| UnicodeString testScript; |
| UnicodeString testCtry; |
| UnicodeString testVar; |
| UnicodeString testName; |
| |
| testLocale.getDisplayLanguage(displayLocale, testLang); |
| testLocale.getDisplayScript(displayLocale, testScript); |
| testLocale.getDisplayCountry(displayLocale, testCtry); |
| testLocale.getDisplayVariant(displayLocale, testVar); |
| testLocale.getDisplayName(displayLocale, testName); |
| |
| UnicodeString expectedLang; |
| UnicodeString expectedScript; |
| UnicodeString expectedCtry; |
| UnicodeString expectedVar; |
| UnicodeString expectedName; |
| |
| expectedLang = dataTable[compareIndex][i]; |
| if (expectedLang.length() == 0) |
| expectedLang = dataTable[DLANG_EN][i]; |
| |
| expectedScript = dataTable[compareIndex + 1][i]; |
| if (expectedScript.length() == 0) |
| expectedScript = dataTable[DSCRIPT_EN][i]; |
| |
| expectedCtry = dataTable[compareIndex + 2][i]; |
| if (expectedCtry.length() == 0) |
| expectedCtry = dataTable[DCTRY_EN][i]; |
| |
| expectedVar = dataTable[compareIndex + 3][i]; |
| if (expectedVar.length() == 0) |
| expectedVar = dataTable[DVAR_EN][i]; |
| |
| expectedName = dataTable[compareIndex + 4][i]; |
| if (expectedName.length() == 0) |
| expectedName = dataTable[DNAME_EN][i]; |
| |
| if (testLang != expectedLang) |
| dataerrln("Display language (" + UnicodeString(displayLocale.getName()) + ") of (" + UnicodeString(testLocale.getName()) + ") got " + testLang + " expected " + expectedLang); |
| if (testScript != expectedScript) |
| dataerrln("Display script (" + UnicodeString(displayLocale.getName()) + ") of (" + UnicodeString(testLocale.getName()) + ") got " + testScript + " expected " + expectedScript); |
| if (testCtry != expectedCtry) |
| dataerrln("Display country (" + UnicodeString(displayLocale.getName()) + ") of (" + UnicodeString(testLocale.getName()) + ") got " + testCtry + " expected " + expectedCtry); |
| if (testVar != expectedVar) |
| dataerrln("Display variant (" + UnicodeString(displayLocale.getName()) + ") of (" + UnicodeString(testLocale.getName()) + ") got " + testVar + " expected " + expectedVar); |
| if (testName != expectedName) |
| dataerrln("Display name (" + UnicodeString(displayLocale.getName()) + ") of (" + UnicodeString(testLocale.getName()) + ") got " + testName + " expected " + expectedName); |
| } |
| } |
| |
| //--------------------------------------------------- |
| // table of valid data |
| //--------------------------------------------------- |
| |
| |
| |
| void LocaleTest::setUpDataTable() |
| { |
| if (dataTable == 0) { |
| dataTable = new UnicodeString*[33]; |
| |
| for (int32_t i = 0; i < 33; i++) { |
| dataTable[i] = new UnicodeString[8]; |
| for (int32_t j = 0; j < 8; j++) { |
| dataTable[i][j] = CharsToUnicodeString(rawData[i][j]); |
| } |
| } |
| } |
| } |
| |
| // ==================== |
| |
| |
| /** |
| * @bug 4011756 4011380 |
| */ |
| void |
| LocaleTest::TestISO3Fallback() |
| { |
| Locale test("xx", "YY"); |
| |
| const char * result; |
| |
| result = test.getISO3Language(); |
| |
| // Conform to C API usage |
| |
| if (!result || (result[0] != 0)) |
| errln("getISO3Language() on xx_YY returned " + UnicodeString(result) + " instead of \"\""); |
| |
| result = test.getISO3Country(); |
| |
| if (!result || (result[0] != 0)) |
| errln("getISO3Country() on xx_YY returned " + UnicodeString(result) + " instead of \"\""); |
| } |
| |
| /** |
| * @bug 4106155 4118587 |
| */ |
| void |
| LocaleTest::TestGetLangsAndCountries() |
| { |
| // It didn't seem right to just do an exhaustive test of everything here, so I check |
| // for the following things: |
| // 1) Does each list have the right total number of entries? |
| // 2) Does each list contain certain language and country codes we think are important |
| // (the G7 countries, plus a couple others)? |
| // 3) Does each list have every entry formatted correctly? (i.e., two characters, |
| // all lower case for the language codes, all upper case for the country codes) |
| // 4) Is each list in sorted order? |
| int32_t testCount = 0; |
| const char * const * test = Locale::getISOLanguages(); |
| const char spotCheck1[ ][4] = { "en", "es", "fr", "de", "it", |
| "ja", "ko", "zh", "th", "he", |
| "id", "iu", "ug", "yi", "za" }; |
| |
| int32_t i; |
| |
| for(testCount = 0;test[testCount];testCount++) |
| ; |
| |
| /* TODO: Change this test to be more like the cloctst version? */ |
| if (testCount != 597) |
| errln("Expected getISOLanguages() to return 597 languages; it returned %d", testCount); |
| else { |
| for (i = 0; i < 15; i++) { |
| int32_t j; |
| for (j = 0; j < testCount; j++) |
| if (uprv_strcmp(test[j],spotCheck1[i])== 0) |
| break; |
| if (j == testCount || (uprv_strcmp(test[j],spotCheck1[i])!=0)) |
| errln("Couldn't find " + (UnicodeString)spotCheck1[i] + " in language list."); |
| } |
| } |
| for (i = 0; i < testCount; i++) { |
| UnicodeString testee(test[i],""); |
| UnicodeString lc(test[i],""); |
| if (testee != lc.toLower()) |
| errln(lc + " is not all lower case."); |
| if ( (testee.length() != 2) && (testee.length() != 3)) |
| errln(testee + " is not two or three characters long."); |
| if (i > 0 && testee.compare(test[i - 1]) <= 0) |
| errln(testee + " appears in an out-of-order position in the list."); |
| } |
| |
| test = Locale::getISOCountries(); |
| UnicodeString spotCheck2 [] = { "US", "CA", "GB", "FR", "DE", |
| "IT", "JP", "KR", "CN", "TW", |
| "TH" }; |
| int32_t spot2Len = 11; |
| for(testCount=0;test[testCount];testCount++) |
| ; |
| |
| if (testCount != 249){ |
| errln("Expected getISOCountries to return 249 countries; it returned %d", testCount); |
| }else { |
| for (i = 0; i < spot2Len; i++) { |
| int32_t j; |
| for (j = 0; j < testCount; j++) |
| { |
| UnicodeString testee(test[j],""); |
| |
| if (testee == spotCheck2[i]) |
| break; |
| } |
| UnicodeString testee(test[j],""); |
| if (j == testCount || testee != spotCheck2[i]) |
| errln("Couldn't find " + spotCheck2[i] + " in country list."); |
| } |
| } |
| for (i = 0; i < testCount; i++) { |
| UnicodeString testee(test[i],""); |
| UnicodeString uc(test[i],""); |
| if (testee != uc.toUpper()) |
| errln(testee + " is not all upper case."); |
| if (testee.length() != 2) |
| errln(testee + " is not two characters long."); |
| if (i > 0 && testee.compare(test[i - 1]) <= 0) |
| errln(testee + " appears in an out-of-order position in the list."); |
| } |
| |
| // This getAvailableLocales and getISO3Language |
| { |
| int32_t numOfLocales; |
| Locale enLoc ("en"); |
| const Locale *pLocales = Locale::getAvailableLocales(numOfLocales); |
| |
| for (int i = 0; i < numOfLocales; i++) { |
| const Locale &loc(pLocales[i]); |
| UnicodeString name; |
| char szName[200]; |
| |
| loc.getDisplayName (enLoc, name); |
| name.extract (0, 200, szName, sizeof(szName)); |
| |
| if (strlen(loc.getISO3Language()) == 0) { |
| errln("getISO3Language() returned an empty string for: " + name); |
| } |
| } |
| } |
| } |
| |
| /** |
| * @bug 4118587 |
| */ |
| void |
| LocaleTest::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" }; |
| UnicodeString languageNames [] = { "Hebrew", "Indonesian", "Inuktitut", "Uyghur", "Yiddish", |
| "Zhuang" }; |
| |
| for (int32_t i = 0; i < 6; i++) { |
| UnicodeString test; |
| Locale l(languageCodes[i], "", ""); |
| l.getDisplayLanguage(Locale::getUS(), test); |
| if (test != languageNames[i]) |
| dataerrln("Got wrong display name for " + UnicodeString(languageCodes[i]) + ": Expected \"" + |
| languageNames[i] + "\", got \"" + test + "\"."); |
| } |
| } |
| |
| /** |
| * @bug 4118595 |
| */ |
| void |
| LocaleTest::TestUninstalledISO3Names() |
| { |
| // This test checks to make sure getISO3Language and getISO3Country work right |
| // even for locales that are not installed. |
| const char iso2Languages [][4] = { "am", "ba", "fy", "mr", "rn", |
| "ss", "tw", "zu" }; |
| const char iso3Languages [][5] = { "amh", "bak", "fry", "mar", "run", |
| "ssw", "twi", "zul" }; |
| |
| int32_t i; |
| |
| for (i = 0; i < 8; i++) { |
| UErrorCode err = U_ZERO_ERROR; |
| |
| UnicodeString test; |
| Locale l(iso2Languages[i], "", ""); |
| test = l.getISO3Language(); |
| if((test != iso3Languages[i]) || U_FAILURE(err)) |
| errln("Got wrong ISO3 code for " + UnicodeString(iso2Languages[i]) + ": Expected \"" + |
| iso3Languages[i] + "\", got \"" + test + "\"." + UnicodeString(u_errorName(err))); |
| } |
| |
| char iso2Countries [][4] = { "AF", "BW", "KZ", "MO", "MN", |
| "SB", "TC", "ZW" }; |
| char iso3Countries [][4] = { "AFG", "BWA", "KAZ", "MAC", "MNG", |
| "SLB", "TCA", "ZWE" }; |
| |
| for (i = 0; i < 8; i++) { |
| UErrorCode err = U_ZERO_ERROR; |
| Locale l("", iso2Countries[i], ""); |
| UnicodeString test(l.getISO3Country(), ""); |
| if (test != iso3Countries[i]) |
| errln("Got wrong ISO3 code for " + UnicodeString(iso2Countries[i]) + ": Expected \"" + |
| UnicodeString(iso3Countries[i]) + "\", got \"" + test + "\"." + u_errorName(err)); |
| } |
| } |
| |
| /** |
| * @bug 4092475 |
| * I could not reproduce this bug. I'm pretty convinced it was fixed with the |
| * big locale-data reorg of 10/28/97. The lookup logic for language and country |
| * display names was also changed at that time in that check-in. --rtg 3/20/98 |
| */ |
| void |
| LocaleTest::TestAtypicalLocales() |
| { |
| Locale localesToTest [] = { Locale("de", "CA"), |
| Locale("ja", "ZA"), |
| Locale("ru", "MX"), |
| Locale("en", "FR"), |
| Locale("es", "DE"), |
| Locale("", "HR"), |
| Locale("", "SE"), |
| Locale("", "DO"), |
| Locale("", "BE") }; |
| |
| UnicodeString englishDisplayNames [] = { "German (Canada)", |
| "Japanese (South Africa)", |
| "Russian (Mexico)", |
| "English (France)", |
| "Spanish (Germany)", |
| "Unknown language (Croatia)", |
| "Unknown language (Sweden)", |
| "Unknown language (Dominican Republic)", |
| "Unknown language (Belgium)" }; |
| UnicodeString frenchDisplayNames []= { "allemand (Canada)", |
| "japonais (Afrique du Sud)", |
| "russe (Mexique)", |
| "anglais (France)", |
| "espagnol (Allemagne)", |
| u"langue indéterminée (Croatie)", |
| u"langue indéterminée (Suède)", |
| u"langue indéterminée (République dominicaine)", |
| u"langue indéterminée (Belgique)" }; |
| UnicodeString spanishDisplayNames [] = { |
| u"alemán (Canadá)", |
| u"japonés (Sudáfrica)", |
| u"ruso (México)", |
| u"inglés (Francia)", |
| u"español (Alemania)", |
| "lengua desconocida (Croacia)", |
| "lengua desconocida (Suecia)", |
| u"lengua desconocida (República Dominicana)", |
| u"lengua desconocida (Bélgica)" }; |
| // De-Anglicizing root required the change from |
| // English display names to ISO Codes - ram 2003/09/26 |
| UnicodeString invDisplayNames [] = { "German (Canada)", |
| "Japanese (South Africa)", |
| "Russian (Mexico)", |
| "English (France)", |
| "Spanish (Germany)", |
| "Unknown language (Croatia)", |
| "Unknown language (Sweden)", |
| "Unknown language (Dominican Republic)", |
| "Unknown language (Belgium)" }; |
| |
| int32_t i; |
| UErrorCode status = U_ZERO_ERROR; |
| Locale saveLocale; |
| Locale::setDefault(Locale::getUS(), status); |
| for (i = 0; i < 9; ++i) { |
| UnicodeString name; |
| localesToTest[i].getDisplayName(Locale::getUS(), name); |
| logln(name); |
| if (name != englishDisplayNames[i]) |
| { |
| dataerrln("Lookup in English failed: expected \"" + englishDisplayNames[i] |
| + "\", got \"" + name + "\""); |
| logln("Locale name was-> " + (name=localesToTest[i].getName())); |
| } |
| } |
| |
| for (i = 0; i < 9; i++) { |
| UnicodeString name; |
| localesToTest[i].getDisplayName(Locale("es", "ES"), name); |
| logln(name); |
| if (name != spanishDisplayNames[i]) |
| dataerrln("Lookup in Spanish failed: expected \"" + spanishDisplayNames[i] |
| + "\", got \"" + name + "\""); |
| } |
| |
| for (i = 0; i < 9; i++) { |
| UnicodeString name; |
| localesToTest[i].getDisplayName(Locale::getFrance(), name); |
| logln(name); |
| if (name != frenchDisplayNames[i]) |
| dataerrln("Lookup in French failed: expected \"" + frenchDisplayNames[i] |
| + "\", got \"" + name + "\""); |
| } |
| |
| for (i = 0; i < 9; i++) { |
| UnicodeString name; |
| localesToTest[i].getDisplayName(Locale("inv", "IN"), name); |
| logln(name + " Locale fallback to be, and data fallback to root"); |
| if (name != invDisplayNames[i]) |
| dataerrln("Lookup in INV failed: expected \"" + prettify(invDisplayNames[i]) |
| + "\", got \"" + prettify(name) + "\""); |
| localesToTest[i].getDisplayName(Locale("inv", "BD"), name); |
| logln(name + " Data fallback to root"); |
| if (name != invDisplayNames[i]) |
| dataerrln("Lookup in INV failed: expected \"" + prettify(invDisplayNames[i]) |
| + "\", got \"" + prettify(name )+ "\""); |
| } |
| Locale::setDefault(saveLocale, status); |
| } |
| |
| #if !UCONFIG_NO_FORMATTING |
| |
| /** |
| * @bug 4135752 |
| * This would be better tested by the LocaleDataTest. Will move it when I |
| * get the LocaleDataTest working again. |
| */ |
| void |
| LocaleTest::TestThaiCurrencyFormat() |
| { |
| UErrorCode status = U_ZERO_ERROR; |
| DecimalFormat *thaiCurrency = (DecimalFormat*)NumberFormat::createCurrencyInstance( |
| Locale("th", "TH"), status); |
| UnicodeString posPrefix(u"\u0E3F"); |
| UnicodeString temp; |
| |
| if(U_FAILURE(status) || !thaiCurrency) |
| { |
| dataerrln("Couldn't get th_TH currency -> " + UnicodeString(u_errorName(status))); |
| return; |
| } |
| if (thaiCurrency->getPositivePrefix(temp) != posPrefix) |
| errln("Thai currency prefix wrong: expected Baht sign, got \"" + |
| thaiCurrency->getPositivePrefix(temp) + "\""); |
| if (thaiCurrency->getPositiveSuffix(temp) != "") |
| errln("Thai currency suffix wrong: expected \"\", got \"" + |
| thaiCurrency->getPositiveSuffix(temp) + "\""); |
| |
| delete thaiCurrency; |
| } |
| |
| /** |
| * @bug 4122371 |
| * Confirm that Euro support works. This test is pretty rudimentary; all it does |
| * is check that any locales with the EURO variant format a number using the |
| * Euro currency symbol. |
| * |
| * ASSUME: All locales encode the Euro character "\u20AC". |
| * If this is changed to use the single-character Euro symbol, this |
| * test must be updated. |
| * |
| */ |
| void |
| LocaleTest::TestEuroSupport() |
| { |
| UChar euro = 0x20ac; |
| const UnicodeString EURO_CURRENCY(&euro, 1, 1); // Look for this UnicodeString in formatted Euro currency |
| const char* localeArr[] = { |
| "ca_ES", |
| "de_AT", |
| "de_DE", |
| "de_LU", |
| "el_GR", |
| "en_BE", |
| "en_IE", |
| "en_GB@currency=EUR", |
| "en_US@currency=EUR", |
| "es_ES", |
| "eu_ES", |
| "fi_FI", |
| "fr_BE", |
| "fr_FR", |
| "fr_LU", |
| "ga_IE", |
| "gl_ES", |
| "it_IT", |
| "nl_BE", |
| "nl_NL", |
| "pt_PT", |
| NULL |
| }; |
| const char** locales = localeArr; |
| |
| UErrorCode status = U_ZERO_ERROR; |
| |
| UnicodeString temp; |
| |
| for (;*locales!=NULL;locales++) { |
| Locale loc (*locales); |
| UnicodeString temp; |
| NumberFormat *nf = NumberFormat::createCurrencyInstance(loc, status); |
| UnicodeString pos; |
| |
| if (U_FAILURE(status)) { |
| dataerrln("Error calling NumberFormat::createCurrencyInstance(%s)", *locales); |
| continue; |
| } |
| |
| nf->format(271828.182845, pos); |
| UnicodeString neg; |
| nf->format(-271828.182845, neg); |
| if (pos.indexOf(EURO_CURRENCY) >= 0 && |
| neg.indexOf(EURO_CURRENCY) >= 0) { |
| logln("Ok: " + (temp=loc.getName()) + |
| ": " + pos + " / " + neg); |
| } |
| else { |
| errln("Fail: " + (temp=loc.getName()) + |
| " formats without " + EURO_CURRENCY + |
| ": " + pos + " / " + neg + |
| "\n*** THIS FAILURE MAY ONLY MEAN THAT LOCALE DATA HAS CHANGED ***"); |
| } |
| |
| delete nf; |
| } |
| |
| UnicodeString dollarStr("USD", ""), euroStr("EUR", ""), genericStr((UChar)0x00a4), resultStr; |
| UChar tmp[4]; |
| status = U_ZERO_ERROR; |
| |
| ucurr_forLocale("en_US", tmp, 4, &status); |
| resultStr.setTo(tmp); |
| if (dollarStr != resultStr) { |
| errcheckln(status, "Fail: en_US didn't return USD - %s", u_errorName(status)); |
| } |
| ucurr_forLocale("en_US@currency=EUR", tmp, 4, &status); |
| resultStr.setTo(tmp); |
| if (euroStr != resultStr) { |
| errcheckln(status, "Fail: en_US@currency=EUR didn't return EUR - %s", u_errorName(status)); |
| } |
| ucurr_forLocale("en_GB@currency=EUR", tmp, 4, &status); |
| resultStr.setTo(tmp); |
| if (euroStr != resultStr) { |
| errcheckln(status, "Fail: en_GB@currency=EUR didn't return EUR - %s", u_errorName(status)); |
| } |
| ucurr_forLocale("en_US_Q", tmp, 4, &status); |
| resultStr.setTo(tmp); |
| if (dollarStr != resultStr) { |
| errcheckln(status, "Fail: en_US_Q didn't fallback to en_US - %s", u_errorName(status)); |
| } |
| int32_t invalidLen = ucurr_forLocale("en_QQ", tmp, 4, &status); |
| if (invalidLen || U_SUCCESS(status)) { |
| errln("Fail: en_QQ didn't return NULL"); |
| } |
| |
| // The currency keyword value is as long as the destination buffer. |
| // It should detect the overflow internally, and default to the locale's currency. |
| tmp[0] = u'¤'; |
| status = U_ZERO_ERROR; |
| int32_t length = ucurr_forLocale("en_US@currency=euro", tmp, 4, &status); |
| if (U_FAILURE(status) || dollarStr != UnicodeString(tmp, length)) { |
| if (U_SUCCESS(status) && tmp[0] == u'¤') { |
| errln("Fail: ucurr_forLocale(en_US@currency=euro) succeeded without writing output"); |
| } else { |
| errln("Fail: ucurr_forLocale(en_US@currency=euro) != USD - %s", u_errorName(status)); |
| } |
| } |
| } |
| |
| #endif |
| |
| /** |
| * @bug 4139504 |
| * toString() doesn't work with language_VARIANT. |
| */ |
| void |
| LocaleTest::TestToString() { |
| Locale DATA [] = { |
| Locale("xx", "", ""), |
| Locale("", "YY", ""), |
| Locale("", "", "ZZ"), |
| Locale("xx", "YY", ""), |
| Locale("xx", "", "ZZ"), |
| Locale("", "YY", "ZZ"), |
| Locale("xx", "YY", "ZZ"), |
| }; |
| |
| const char DATA_S [][20] = { |
| "xx", |
| "_YY", |
| "__ZZ", |
| "xx_YY", |
| "xx__ZZ", |
| "_YY_ZZ", |
| "xx_YY_ZZ", |
| }; |
| |
| for (int32_t i=0; i < 7; ++i) { |
| const char *name; |
| name = DATA[i].getName(); |
| |
| if (strcmp(name, DATA_S[i]) != 0) |
| { |
| errln("Fail: Locale.getName(), got:" + UnicodeString(name) + ", expected: " + DATA_S[i]); |
| } |
| else |
| logln("Pass: Locale.getName(), got:" + UnicodeString(name) ); |
| } |
| } |
| |
| #if !UCONFIG_NO_FORMATTING |
| |
| /** |
| * @bug 4139940 |
| * Couldn't reproduce this bug -- probably was fixed earlier. |
| * |
| * ORIGINAL BUG REPORT: |
| * -- basically, hungarian for monday shouldn't have an \u00f4 |
| * (o circumflex)in it instead it should be an o with 2 inclined |
| * (right) lines over it.. |
| * |
| * You may wonder -- why do all this -- why not just add a line to |
| * LocaleData? Well, I could see by inspection that the locale file had the |
| * right character in it, so I wanted to check the rest of the pipeline -- a |
| * very remote possibility, but I wanted to be sure. The other possibility |
| * is that something is wrong with the font mapping subsystem, but we can't |
| * test that here. |
| */ |
| void |
| LocaleTest::Test4139940() |
| { |
| Locale mylocale("hu", "", ""); |
| UDate mydate = date(98,3,13); // A Monday |
| UErrorCode status = U_ZERO_ERROR; |
| SimpleDateFormat df_full("EEEE", mylocale, status); |
| if(U_FAILURE(status)){ |
| dataerrln(UnicodeString("Could not create SimpleDateFormat object for locale hu. Error: ") + UnicodeString(u_errorName(status))); |
| return; |
| } |
| UnicodeString str; |
| FieldPosition pos(FieldPosition::DONT_CARE); |
| df_full.format(mydate, str, pos); |
| // Make sure that o circumflex (\u00F4) is NOT there, and |
| // o double acute (\u0151) IS. |
| UChar ocf = 0x00f4; |
| UChar oda = 0x0151; |
| if (str.indexOf(oda) < 0 || str.indexOf(ocf) >= 0) { |
| /* If the default locale is "th" this test will fail because of the buddhist calendar. */ |
| if (strcmp(Locale::getDefault().getLanguage(), "th") != 0) { |
| errln("Fail: Monday in Hungarian is wrong - oda's index is %d and ocf's is %d", |
| str.indexOf(oda), str.indexOf(ocf)); |
| } else { |
| logln(UnicodeString("An error is produce in buddhist calendar.")); |
| } |
| logln(UnicodeString("String is: ") + str ); |
| } |
| } |
| |
| UDate |
| LocaleTest::date(int32_t y, int32_t m, int32_t d, int32_t hr, int32_t min, int32_t sec) |
| { |
| UErrorCode status = U_ZERO_ERROR; |
| Calendar *cal = Calendar::createInstance(status); |
| if (cal == 0) |
| return 0.0; |
| cal->clear(); |
| cal->set(1900 + y, m, d, hr, min, sec); // Add 1900 to follow java.util.Date protocol |
| UDate dt = cal->getTime(status); |
| if (U_FAILURE(status)) |
| return 0.0; |
| |
| delete cal; |
| return dt; |
| } |
| |
| /** |
| * @bug 4143951 |
| * Russian first day of week should be Monday. Confirmed. |
| */ |
| void |
| LocaleTest::Test4143951() |
| { |
| UErrorCode status = U_ZERO_ERROR; |
| Calendar *cal = Calendar::createInstance(Locale("ru", "", ""), status); |
| if(U_SUCCESS(status)) { |
| if (cal->getFirstDayOfWeek(status) != UCAL_MONDAY) { |
| dataerrln("Fail: First day of week in Russia should be Monday"); |
| } |
| } |
| delete cal; |
| } |
| |
| #endif |
| |
| /** |
| * @bug 4147315 |
| * java.util.Locale.getISO3Country() works wrong for non ISO-3166 codes. |
| * Should throw an exception for unknown locales |
| */ |
| void |
| LocaleTest::Test4147315() |
| { |
| UnicodeString temp; |
| // Try with codes that are the wrong length but happen to match text |
| // at a valid offset in the mapping table |
| Locale locale("xxx", "CCC"); |
| |
| const char *result = locale.getISO3Country(); |
| |
| // Change to conform to C api usage |
| if((result==NULL)||(result[0] != 0)) |
| errln("ERROR: getISO3Country() returns: " + UnicodeString(result,"") + |
| " for locale '" + (temp=locale.getName()) + "' rather than exception" ); |
| } |
| |
| /** |
| * @bug 4147317 |
| * java.util.Locale.getISO3Language() works wrong for non ISO-3166 codes. |
| * Should throw an exception for unknown locales |
| */ |
| void |
| LocaleTest::Test4147317() |
| { |
| UnicodeString temp; |
| // Try with codes that are the wrong length but happen to match text |
| // at a valid offset in the mapping table |
| Locale locale("xxx", "CCC"); |
| |
| const char *result = locale.getISO3Language(); |
| |
| // Change to conform to C api usage |
| if((result==NULL)||(result[0] != 0)) |
| errln("ERROR: getISO3Language() returns: " + UnicodeString(result,"") + |
| " for locale '" + (temp=locale.getName()) + "' rather than exception" ); |
| } |
| |
| /* |
| * @bug 4147552 |
| */ |
| void |
| LocaleTest::Test4147552() |
| { |
| Locale locales [] = { Locale("no", "NO"), |
| Locale("no", "NO", "B"), |
| Locale("no", "NO", "NY") |
| }; |
| |
| UnicodeString edn("Norwegian (Norway, B)"); |
| UnicodeString englishDisplayNames [] = { |
| "Norwegian (Norway)", |
| edn, |
| // "Norwegian (Norway,B)", |
| //"Norwegian (Norway,NY)" |
| "Norwegian (Norway, NY)" |
| }; |
| UnicodeString ndn("norsk (Norge, B"); |
| UnicodeString norwegianDisplayNames [] = { |
| "norsk (Norge)", |
| "norsk (Norge, B)", |
| //ndn, |
| "norsk (Noreg, NY)" |
| //"Norsk (Noreg, Nynorsk)" |
| }; |
| UErrorCode status = U_ZERO_ERROR; |
| |
| Locale saveLocale; |
| Locale::setDefault(Locale::getEnglish(), status); |
| for (int32_t i = 0; i < 3; ++i) { |
| Locale loc = locales[i]; |
| UnicodeString temp; |
| if (loc.getDisplayName(temp) != englishDisplayNames[i]) |
| dataerrln("English display-name mismatch: expected " + |
| englishDisplayNames[i] + ", got " + loc.getDisplayName(temp)); |
| if (loc.getDisplayName(loc, temp) != norwegianDisplayNames[i]) |
| dataerrln("Norwegian display-name mismatch: expected " + |
| norwegianDisplayNames[i] + ", got " + |
| loc.getDisplayName(loc, temp)); |
| } |
| Locale::setDefault(saveLocale, status); |
| } |
| |
| void |
| LocaleTest::TestVariantParsing() |
| { |
| Locale en_US_custom("en", "US", "De Anza_Cupertino_California_United States_Earth"); |
| |
| UnicodeString dispName("English (United States, DE ANZA_CUPERTINO_CALIFORNIA_UNITED STATES_EARTH)"); |
| UnicodeString dispVar("DE ANZA_CUPERTINO_CALIFORNIA_UNITED STATES_EARTH"); |
| |
| UnicodeString got; |
| |
| en_US_custom.getDisplayVariant(Locale::getUS(), got); |
| if(got != dispVar) { |
| errln("FAIL: getDisplayVariant()"); |
| errln("Wanted: " + dispVar); |
| errln("Got : " + got); |
| } |
| |
| en_US_custom.getDisplayName(Locale::getUS(), got); |
| if(got != dispName) { |
| dataerrln("FAIL: getDisplayName()"); |
| dataerrln("Wanted: " + dispName); |
| dataerrln("Got : " + got); |
| } |
| |
| Locale shortVariant("fr", "FR", "foo"); |
| shortVariant.getDisplayVariant(got); |
| |
| if(got != "FOO") { |
| errln("FAIL: getDisplayVariant()"); |
| errln("Wanted: foo"); |
| errln("Got : " + got); |
| } |
| |
| Locale bogusVariant("fr", "FR", "_foo"); |
| bogusVariant.getDisplayVariant(got); |
| |
| if(got != "FOO") { |
| errln("FAIL: getDisplayVariant()"); |
| errln("Wanted: foo"); |
| errln("Got : " + got); |
| } |
| |
| Locale bogusVariant2("fr", "FR", "foo_"); |
| bogusVariant2.getDisplayVariant(got); |
| |
| if(got != "FOO") { |
| errln("FAIL: getDisplayVariant()"); |
| errln("Wanted: foo"); |
| errln("Got : " + got); |
| } |
| |
| Locale bogusVariant3("fr", "FR", "_foo_"); |
| bogusVariant3.getDisplayVariant(got); |
| |
| if(got != "FOO") { |
| errln("FAIL: getDisplayVariant()"); |
| errln("Wanted: foo"); |
| errln("Got : " + got); |
| } |
| } |
| |
| void LocaleTest::Test20639_DeprecatesISO3Language() { |
| IcuTestErrorCode status(*this, "Test20639_DeprecatesISO3Language"); |
| |
| const struct TestCase { |
| const char* localeName; |
| const char* expectedISO3Language; |
| } cases[] = { |
| {"nb", "nob"}, |
| {"no", "nor"}, // why not nob? |
| {"he", "heb"}, |
| {"iw", "heb"}, |
| {"ro", "ron"}, |
| {"mo", "mol"}, |
| }; |
| for (auto& cas : cases) { |
| Locale loc(cas.localeName); |
| const char* actual = loc.getISO3Language(); |
| assertEquals(cas.localeName, cas.expectedISO3Language, actual); |
| } |
| } |
| |
| #if !UCONFIG_NO_FORMATTING |
| |
| /** |
| * @bug 4105828 |
| * Currency symbol in zh is wrong. We will test this at the NumberFormat |
| * end to test the whole pipe. |
| */ |
| void |
| LocaleTest::Test4105828() |
| { |
| Locale LOC [] = { Locale::getChinese(), Locale("zh", "CN", ""), |
| Locale("zh", "TW", ""), Locale("zh", "HK", "") }; |
| UErrorCode status = U_ZERO_ERROR; |
| for (int32_t i = 0; i < 4; ++i) { |
| NumberFormat *fmt = NumberFormat::createPercentInstance(LOC[i], status); |
| if(U_FAILURE(status)) { |
| dataerrln("Couldn't create NumberFormat - %s", u_errorName(status)); |
| return; |
| } |
| UnicodeString result; |
| FieldPosition pos(FieldPosition::DONT_CARE); |
| fmt->format((int32_t)1, result, pos); |
| UnicodeString temp; |
| if(result != "100%") { |
| errln(UnicodeString("Percent for ") + LOC[i].getDisplayName(temp) + " should be 100%, got " + result); |
| } |
| delete fmt; |
| } |
| } |
| |
| #endif |
| |
| // Tests setBogus and isBogus APIs for Locale |
| // Jitterbug 1735 |
| void |
| LocaleTest::TestSetIsBogus() { |
| Locale l("en_US"); |
| l.setToBogus(); |
| if(l.isBogus() != TRUE) { |
| errln("After setting bogus, didn't return TRUE"); |
| } |
| l = "en_US"; // This should reset bogus |
| if(l.isBogus() != FALSE) { |
| errln("After resetting bogus, didn't return FALSE"); |
| } |
| } |
| |
| |
| void |
| LocaleTest::TestAddLikelySubtags() { |
| IcuTestErrorCode status(*this, "TestAddLikelySubtags()"); |
| |
| static const Locale min("sv"); |
| static const Locale max("sv_Latn_SE"); |
| |
| Locale result(min); |
| result.addLikelySubtags(status); |
| status.errIfFailureAndReset("\"%s\"", min.getName()); |
| assertEquals("addLikelySubtags", max.getName(), result.getName()); |
| } |
| |
| |
| void |
| LocaleTest::TestMinimizeSubtags() { |
| IcuTestErrorCode status(*this, "TestMinimizeSubtags()"); |
| |
| static const Locale max("zh_Hant_TW"); |
| static const Locale min("zh_TW"); |
| |
| Locale result(max); |
| result.minimizeSubtags(status); |
| status.errIfFailureAndReset("\"%s\"", max.getName()); |
| assertEquals("minimizeSubtags", min.getName(), result.getName()); |
| } |
| |
| |
| void |
| LocaleTest::TestAddLikelyAndMinimizeSubtags() { |
| IcuTestErrorCode status(*this, "TestAddLikelyAndMinimizeSubtags()"); |
| |
| static const struct { |
| const char* const from; |
| const char* const add; |
| const char* const remove; |
| } full_data[] = { |
| { |
| "und_AQ", |
| "_Latn_AQ", |
| "_AQ" |
| }, { |
| "und_Zzzz_AQ", |
| "_Latn_AQ", |
| "_AQ" |
| }, { |
| "und_Latn_AQ", |
| "_Latn_AQ", |
| "_AQ" |
| }, { |
| "und_Moon_AQ", |
| "_Moon_AQ", |
| "_Moon_AQ" |
| }, { |
| "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" |
| }, { |
| "fj", |
| "fj_Latn_FJ", |
| "fj" |
| }, { |
| "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_Latn_TR", |
| "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" |
| }, { |
| "no", |
| "no_Latn_NO", |
| "no" |
| }, { |
| "nr", |
| "nr_Latn_ZA", |
| "nr" |
| }, { |
| "nso", |
| "nso_Latn_ZA", |
| "nso" |
| }, { |
| "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_AW", |
| "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_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_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", |
| "am_Ethi_ET", |
| "am" |
| }, { |
| "und_Ethi", |
| "am_Ethi_ET", |
| "am" |
| }, { |
| "und_Ethi_ER", |
| "am_Ethi_ER", |
| "am_ER" |
| }, { |
| "und_FI", |
| "fi_Latn_FI", |
| "fi" |
| }, { |
| "und_FM", |
| "en_Latn_FM", |
| "en_FM" |
| }, { |
| "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_Hani_CN", |
| "zh_Hani" |
| }, { |
| "und_Hans", |
| "zh_Hans_CN", |
| "zh" |
| }, { |
| "und_Hant", |
| "zh_Hant_TW", |
| "zh_TW" |
| }, { |
| "und_Hebr", |
| "he_Hebr_IL", |
| "he" |
| }, { |
| "und_ID", |
| "id_Latn_ID", |
| "id" |
| }, { |
| "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_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_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_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_Syrc", |
| "syr_Syrc_IQ", |
| "syr" |
| }, { |
| "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" |
| }, { |
|
