organicmaps/icu
13
Fork 0
mirror of https://github.com/unicode-org/icu.git synced 2025-04-05 05:25:34 +00:00
Code Issues 1 Projects Releases Wiki Activity Actions 11
icu/icu4c/source/test/intltest/loctest.cpp

7125 lines
229 KiB
C++
Raw Permalink Blame History

// © 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 <cctype>
#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(nullptr)
{
setUpDataTable();
}
LocaleTest::~LocaleTest()
{
if (dataTable != nullptr) {
for (int32_t i = 0; i < 33; i++) {
delete []dataTable[i];
}
delete []dataTable;
dataTable = nullptr;
}
}
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(TestVariantLengthLimit);
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(TestPseudoLocales);
TESTCASE_AUTO(TestAddLikelySubtags);
TESTCASE_AUTO(TestMinimizeSubtags);
TESTCASE_AUTO(TestAddLikelyAndMinimizeSubtags);
TESTCASE_AUTO(TestDataDrivenLikelySubtags);
TESTCASE_AUTO(TestKeywordVariants);
TESTCASE_AUTO(TestCreateUnicodeKeywords);
TESTCASE_AUTO(TestKeywordVariantParsing);
TESTCASE_AUTO(TestCreateKeywordSet);
TESTCASE_AUTO(TestCreateKeywordSetEmpty);
TESTCASE_AUTO(TestCreateKeywordSetWithPrivateUse);
TESTCASE_AUTO(TestCreateUnicodeKeywordSet);
TESTCASE_AUTO(TestCreateUnicodeKeywordSetEmpty);
TESTCASE_AUTO(TestCreateUnicodeKeywordSetWithPrivateUse);
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(TestForLanguageTagLegacyTagBug21676);
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(TestNullDereferenceWrite21597);
TESTCASE_AUTO(TestLongLocaleSetKeywordAssign);
TESTCASE_AUTO(TestLongLocaleSetKeywordMoveAssign);
#if !UCONFIG_NO_FORMATTING
TESTCASE_AUTO(TestSierraLeoneCurrency21997);
#endif
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(nullptr))
errln("Locale::getDefault() == Locale::createFromName(nullptr)");
/*----------*/
// 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::TestVariantLengthLimit() {
static constexpr char valid[] =
"_"
"_12345678"
"_12345678"
"_12345678"
"_12345678"
"_12345678"
"_12345678"
"_12345678"
"_12345678"
"_12345678"
"_12345678"
"_12345678"
"_12345678"
"_12345678"
"_12345678"
"_12345678"
"_12345678"
"_12345678"
"_12345678"
"_12345678"
"_12345678";
static constexpr char invalid[] =
"_"
"_12345678"
"_12345678"
"_12345678"
"_12345678"
"_12345678"
"_12345678"
"_12345678"
"_12345678"
"_12345678"
"_12345678"
"_12345678"
"_12345678"
"_12345678"
"_12345678"
"_12345678"
"_12345678"
"_12345678"
"_12345678"
"_12345678"
"_12345678X"; // One character too long.
constexpr const char* variantsExpected = valid + 2; // Skip initial "__".
Locale validLocale(valid);
if (validLocale.isBogus()) {
errln("Valid locale is unexpectedly bogus.");
} else if (uprv_strcmp(variantsExpected, validLocale.getVariant()) != 0) {
errln("Expected variants \"%s\" but got variants \"%s\"\n",
variantsExpected, validLocale.getVariant());
}
Locale invalidLocale(invalid);
if (!invalidLocale.isBogus()) {
errln("Invalid locale is unexpectedly NOT bogus.");
}
}
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]);
snprintf(temp2, sizeof(temp2), "%x", static_cast<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 == nullptr) {
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 != 601)
errln("Expected getISOLanguages() to return 601 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 != 254){
errln("Expected getISOCountries to return 254 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 = dynamic_cast<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()
{
char16_t 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",
nullptr
};
const char** locales = localeArr;
UErrorCode status = U_ZERO_ERROR;
UnicodeString temp;
for (;*locales!=nullptr;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(static_cast<char16_t>(0x00a4)), resultStr;
char16_t 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 nullptr");
}
// 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.
char16_t ocf = 0x00f4;
char16_t oda = 0x0151;
if (str.indexOf(oda) < 0 || str.indexOf(ocf) >= 0) {
/* If the default calendar of the default locale is not "gregorian" this test will fail. */
LocalPointer<Calendar> defaultCalendar(Calendar::createInstance(status));
if (strcmp(defaultCalendar->getType(), "gregorian") == 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 non Gregorian 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 == nullptr)
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==nullptr)||(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==nullptr)||(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 (const 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(static_cast<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::TestPseudoLocales() {
// input locale tag, expected locale tag
static const struct {
const char* const input;
const char* const expected;
} test_cases[] = {
// language + region, en
{ "en-XA", "en-Latn-XA" },
{ "en-XB", "en-Latn-XB" },
{ "en-XC", "en-Latn-XC" },
// language + region, ar
{ "ar-XA", "ar-Arab-XA" },
{ "ar-XB", "ar-Arab-XB" },
{ "ar-XC", "ar-Arab-XC" },
// language + region, something other than en, ar
{ "ru-XA", "ru-Cyrl-XA" },
{ "el-XB", "el-Grek-XB" },
// undefined language - region
{ "und-XA", "en-Latn-XA" },
{ "und-XB", "en-Latn-XB" },
{ "und-XC", "en-Latn-XC" },
// language + script + region
{ "und-Latn-XA", "en-Latn-XA" },
{ "und-Latn-XB", "en-Latn-XB" },
{ "und-Latn-XC", "en-Latn-XC" },
{ "und-Arab-XA", "ar-Arab-XA" },
{ "und-Arab-XB", "ar-Arab-XB" },
{ "und-Arab-XC", "ar-Arab-XC" },
{ "und-Cyrl-XA", "ru-Cyrl-XA" },
{ "und-Grek-XB", "el-Grek-XB" },
// Make sure the script is not damaged, when correct
{ "ru-Cyrl-XA", "ru-Cyrl-XA" },
{ "el-Grek-XB", "el-Grek-XB" },
// Make sure the script is not damaged, even if it is wrong
{ "ru-Grek-XA", "ru-Grek-XA" },
{ "el-Cyrl-XB", "el-Cyrl-XB" },
// PS Variants
{ "en-XA-PSACCENT", "en-Latn-XA-psaccent" },
{ "en-XA-PSBIDI", "en-Latn-XA-psbidi" },
{ "en-XA-PSCRACK", "en-Latn-XA-pscrack" },
{ "ar-XB-PSACCENT", "ar-Arab-XB-psaccent" },
{ "ar-XB-PSBIDI", "ar-Arab-XB-psbidi" },
{ "ar-XB-PSCRACK", "ar-Arab-XB-pscrack" },
{ "en-XC-PSACCENT", "en-Latn-XC-psaccent" },
{ "en-XC-PSBIDI", "en-Latn-XC-psbidi" },
{ "en-XC-PSCRACK", "en-Latn-XC-pscrack" },
{ "en-US-PSACCENT", "en-Latn-US-psaccent" },
{ "en-US-PSBIDI", "en-Latn-US-psbidi" },
{ "en-US-PSCRACK", "en-Latn-US-pscrack" },
{ "ar-EG-PSACCENT", "ar-Arab-EG-psaccent" },
{ "ar-EG-PSBIDI", "ar-Arab-EG-psbidi" },
{ "ar-EG-PSCRACK", "ar-Arab-EG-pscrack" },
{ "en-PSACCENT", "en-Latn-US-psaccent" },
{ "en-PSBIDI", "en-Latn-US-psbidi" },
{ "en-PSCRACK", "en-Latn-US-pscrack" },
{ "ar-PSACCENT", "ar-Arab-EG-psaccent" },
{ "ar-PSBIDI", "ar-Arab-EG-psbidi" },
{ "ar-PSCRACK", "ar-Arab-EG-pscrack" },
{ "und-US-PSACCENT", "en-Latn-US-psaccent" },
{ "und-US-PSBIDI", "en-Latn-US-psbidi" },
{ "und-US-PSCRACK", "en-Latn-US-pscrack" },
{ "und-EG-PSACCENT", "ar-Arab-EG-psaccent" },
{ "und-EG-PSBIDI", "ar-Arab-EG-psbidi" },
{ "und-EG-PSCRACK", "ar-Arab-EG-pscrack" },
{ "und-PSACCENT", "en-Latn-US-psaccent" },
{ "und-PSBIDI", "en-Latn-US-psbidi" },
{ "und-PSCRACK", "en-Latn-US-pscrack" },
{ "und-PSACCENT", "en-Latn-US-psaccent" },
{ "und-PSBIDI", "en-Latn-US-psbidi" },
{ "und-PSCRACK", "en-Latn-US-pscrack" },
};
std::string extensions("-u-nu-Deva-hc-h23-fw-mon-mu-celsius-x-somethin-more");
IcuTestErrorCode status(*this, "TestPseudoLocales()");
for (const auto& item : test_cases) {
const char* const inputTag = item.input;
const char* const expectedTag = item.expected;
Locale result = Locale::forLanguageTag(inputTag, status);
result.addLikelySubtags(status);
status.errIfFailureAndReset("\"%s\"", inputTag);
Locale expected = Locale::forLanguageTag(expectedTag, status);
status.errIfFailureAndReset("\"%s\"", expectedTag);
assertEquals(inputTag, expected.getName(), result.getName());
// Test extension
std::string extendedTag(inputTag);
extendedTag.append(extensions);
result = Locale::forLanguageTag(extendedTag, status);
result.addLikelySubtags(status);
status.errIfFailureAndReset(extendedTag.c_str());
std::string expectedExtendedTag(expectedTag);
expectedExtendedTag.append(extensions);
expected = Locale::forLanguageTag(expectedExtendedTag, status);
status.errIfFailureAndReset(expectedExtendedTag.c_str());
assertEquals(extendedTag.c_str(), expected.getName(), result.getName());
}
}
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",
"en_Latn_US",
"en"
},
{
"und_AQ",
"en_Latn_AQ",
"en_AQ"
}, {
"und_Zzzz_AQ",
"en_Latn_AQ",
"en_AQ"
}, {
"und_Latn_AQ",
"en_Latn_AQ",
"en_AQ"
}, {
"und_Moon_AQ",
"en_Moon_AQ",
"en_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_CW",
"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",
"fr_Latn_CD",
"fr_CD"
}, {
"und_CF",
"sg_Latn_CF",
"sg"
}, {
"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",
"fr_Latn_DJ",
"fr_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",
"ti_Ethi_ER",
"ti_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",
"wo_Latn_SN",
"wo"
}, {
"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",
"ar_Arab_TD",
"ar_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_Latn_UZ",
"uz"
}, {
"und_VA",
"it_Latn_VA",
"it_VA"
}, {
"und_VE",
"es_Latn_VE",
"es_VE"
}, {
"und_VN",
"vi_Latn_VN",
"vi"
}, {
"und_VU",
"bi_Latn_VU",
"bi"
}, {
"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_Latn_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"
}, {
"wo_SN",
"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_Hani_CN",
"zh_Hani"
}, {
"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",
"trv_Latn_TW",
"trv"
}, {
"und_Latn_HK",
"en_Latn_HK",
"en_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",
"yue_Hant_CN",
"yue_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",
"",
""
}, {
"aae_Latn_IT",
"aae_Latn_IT",
"aae"
}, {
"aae_Thai_CO",
"aae_Thai_CO",
"aae_Thai_CO"
}, {
"und_CW",
"pap_Latn_CW",
"pap"
}, {
"zh_Hant",
"zh_Hant_TW",
"zh_TW"
}, {
"zh_Hani",
"zh_Hani_CN",
"zh_Hani"
}, {
"und",
"en_Latn_US",
"en"
}, {
"und_Thai",
"th_Thai_TH",
"th"
}, {
"und_419",
"es_Latn_419",
"es_419"
}, {
"und_150",
"en_Latn_150",
"en_150"
}, {
"und_AT",
"de_Latn_AT",
"de_AT"
}, {
"und_US",
"en_Latn_US",
"en"
}, {
// ICU-22547
// unicode_language_id = "root" |
// (unicode_language_subtag (sep unicode_script_subtag)? | unicode_script_subtag)
// (sep unicode_region_subtag)? (sep unicode_variant_subtag)* ;
// so "aaaa" is a well-formed unicode_language_id
"aaaa",
"aaaa",
"aaaa",
}, {
// ICU-22727
// unicode_language_subtag = alpha{2,3} | alpha{5,8};
// so "bbbbb", "cccccc", "ddddddd", "eeeeeeee" are
// well-formed unicode_language_subtag and therefore
// well-formed unicode_language_id
// but "fffffffff" is not.
"bbbbb",
"bbbbb",
"bbbbb",
}, {
// ICU-22727
"cccccc",
"cccccc",
"cccccc",
}, {
// ICU-22727
"ddddddd",
"ddddddd",
"ddddddd",
}, {
// ICU-22727
"eeeeeeee",
"eeeeeeee",
"eeeeeeee",
}, {
// ICU-22546
"und-Zzzz",
"en_Latn_US", // If change, please also update common/unicode/locid.h
"en"
}, {
// ICU-22546
"en",
"en_Latn_US", // If change, please also update common/unicode/locid.h
"en"
}, {
// ICU-22546
"de",
"de_Latn_DE", // If change, please also update common/unicode/locid.h
"de"
}, {
// ICU-22546
"sr",
"sr_Cyrl_RS", // If change, please also update common/unicode/locid.h
"sr"
}, {
// ICU-22546
"sh",
"sh",// If change, please also update common/unicode/locid.h
"sh"
}, {
// ICU-22546
"zh_Hani",
"zh_Hani_CN", // If change, please also update common/unicode/locid.h
"zh_Hani"
}, {
// ICU-22545 & ICU-22742
"en_XA",
"en_Latn_XA",
"en_XA",
}, {
// ICU-22545 & ICU-22742
"ar_XB",
"ar_Arab_XB",
"ar_XB",
}, {
// ICU-22545 & ICU-22742
"ru_XC",
"ru_Cyrl_XC",
"ru_XC",
}, {
// ICU-22742
"en_PSACCENT",
"en_Latn_US_PSACCENT",
"en__PSACCENT"
}, {
"ar_PSBIDI",
"ar_Arab_EG_PSBIDI",
"ar__PSBIDI"
}, {
"ru_PSCRACK",
"ru_Cyrl_RU_PSCRACK",
"ru__PSCRACK"
}, {
"ar_PSACCENT",
"ar_Arab_EG_PSACCENT",
"ar__PSACCENT"
}, {
"ru_PSBIDI",
"ru_Cyrl_RU_PSBIDI",
"ru__PSBIDI"
}, {
"en_PSCRACK",
"en_Latn_US_PSCRACK",
"en__PSCRACK"
}, {
// ICU-22765
"th@x=private",
"th_Thai_TH@x=private",
"th@x=private",
}, {
"und@x=private",
"en_Latn_US@x=private",
"en@x=private",
}
};
for (const auto& item : full_data) {
const char* const org = item.from;
const char* const exp = item.add;
Locale res(org);
res.addLikelySubtags(status);
status.errIfFailureAndReset("\"%s\"", org);
if (exp[0]) {
assertEquals("addLikelySubtags", exp, res.getName());
} else {
assertEquals("addLikelySubtags", org, res.getName());
}
}
for (const auto& item : full_data) {
const char* const org = item.from;
const char* const exp = item.remove;
Locale res(org);
res.minimizeSubtags(status);
status.errIfFailureAndReset("\"%s\"", org);
if (exp[0]) {
assertEquals("minimizeSubtags", exp, res.getName());
} else {
assertEquals("minimizeSubtags", org, res.getName());
}
}
}
void
LocaleTest::TestKeywordVariants() {
static const struct {
const char *localeID;
const char *expectedLocaleID;
//const char *expectedLocaleIDNoKeywords;
//const char *expectedCanonicalID;
const char *expectedKeywords[10];
int32_t numKeywords;
UErrorCode expectedStatus;
} 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 '@' */
}
};
UErrorCode status = U_ZERO_ERROR;
int32_t i = 0, j = 0;
const char *result = nullptr;
StringEnumeration *keywords;
int32_t keyCount = 0;
const char *keyword = nullptr;
const UnicodeString *keywordString;
int32_t keywordLen = 0;
for(i = 0; i < UPRV_LENGTHOF(testCases); i++) {
status = U_ZERO_ERROR;
Locale l(testCases[i].localeID);
keywords = l.createKeywords(status);
if(status != testCases[i].expectedStatus) {
err("Expected to get status %s. Got %s instead\n",
u_errorName(testCases[i].expectedStatus), u_errorName(status));
}
status = U_ZERO_ERROR;
if(keywords) {
if((keyCount = keywords->count(status)) != testCases[i].numKeywords) {
err("Expected to get %i keywords, got %i\n", testCases[i].numKeywords, keyCount);
}
if(keyCount) {
for(j = 0;;) {
if((j&1)==0) {
if((keyword = keywords->next(&keywordLen, status)) == nullptr) {
break;
}
if(strcmp(keyword, testCases[i].expectedKeywords[j]) != 0) {
err("Expected to get keyword value %s, got %s\n", testCases[i].expectedKeywords[j], keyword);
}
} else {
if((keywordString = keywords->snext(status)) == nullptr) {
break;
}
if(*keywordString != UnicodeString(testCases[i].expectedKeywords[j], "")) {
err("Expected to get keyword UnicodeString %s, got %s\n", testCases[i].expectedKeywords[j], keyword);
}
}
j++;
if(j == keyCount / 2) {
// replace keywords with a clone of itself
StringEnumeration *k2 = keywords->clone();
if(k2 == nullptr || keyCount != k2->count(status)) {
errln("KeywordEnumeration.clone() failed");
} else {
delete keywords;
keywords = k2;
}
}
}
keywords->reset(status); // Make sure that reset works.
for(j = 0;;) {
if((keyword = keywords->next(&keywordLen, status)) == nullptr) {
break;
}
if(strcmp(keyword, testCases[i].expectedKeywords[j]) != 0) {
err("Expected to get keyword value %s, got %s\n", testCases[i].expectedKeywords[j], keyword);
}
j++;
}
}
delete keywords;
}
result = l.getName();
if(uprv_strcmp(testCases[i].expectedLocaleID, result) != 0) {
err("Expected to get \"%s\" from \"%s\". Got \"%s\" instead\n",
testCases[i].expectedLocaleID, testCases[i].localeID, result);
}
}
}
void
LocaleTest::TestCreateUnicodeKeywords() {
IcuTestErrorCode status(*this, "TestCreateUnicodeKeywords()");
static const Locale l("de@calendar=buddhist;collation=phonebook");
LocalPointer<StringEnumeration> keys(l.createUnicodeKeywords(status));
status.errIfFailureAndReset("\"%s\"", l.getName());
assertEquals("count", 2, keys->count(status));
const char* key;
int32_t resultLength;
key = keys->next(&resultLength, status);
status.errIfFailureAndReset("key #1");
assertEquals("resultLength", 2, resultLength);
assertTrue("key != nullptr", key != nullptr);
if (key != nullptr) {
assertEquals("calendar", "ca", key);
}
key = keys->next(&resultLength, status);
status.errIfFailureAndReset("key #2");
assertEquals("resultLength", 2, resultLength);
assertTrue("key != nullptr", key != nullptr);
if (key != nullptr) {
assertEquals("collation", "co", key);
}
key = keys->next(&resultLength, status);
status.errIfFailureAndReset("end of keys");
assertEquals("resultLength", 0, resultLength);
assertTrue("key == nullptr", key == nullptr);
const UnicodeString* skey;
keys->reset(status); // KeywordEnumeration::reset() never touches status.
skey = keys->snext(status);
status.errIfFailureAndReset("skey #1");
assertTrue("skey != nullptr", skey != nullptr);
if (skey != nullptr) {
assertEquals("calendar", "ca", *skey);
}
skey = keys->snext(status);
status.errIfFailureAndReset("skey #2");
assertTrue("skey != nullptr", skey != nullptr);
if (skey != nullptr) {
assertEquals("collation", "co", *skey);
}
skey = keys->snext(status);
status.errIfFailureAndReset("end of keys");
assertTrue("skey == nullptr", skey == nullptr);
}
void
LocaleTest::TestKeywordVariantParsing() {
static const struct {
const char *localeID;
const char *keyword;
const char *expectedValue;
} testCases[] = {
{ "de_DE@ C o ll A t i o n = Phonebook ", "collation", "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 < UPRV_LENGTHOF(testCases); i++) {
*buffer = 0;
Locale l(testCases[i].localeID);
resultLen = l.getKeywordValue(testCases[i].keyword, buffer, 256, status);
(void)resultLen; // Suppress unused variable warning.
if(uprv_strcmp(testCases[i].expectedValue, buffer) != 0) {
err("Expected to extract \"%s\" from \"%s\" for keyword \"%s\". Got \"%s\" instead\n",
testCases[i].expectedValue, testCases[i].localeID, testCases[i].keyword, buffer);
}
}
}
void
LocaleTest::TestCreateKeywordSet() {
IcuTestErrorCode status(*this, "TestCreateKeywordSet()");
static const Locale l("de@calendar=buddhist;collation=phonebook");
std::set<std::string> result;
l.getKeywords<std::string>(
std::insert_iterator<decltype(result)>(result, result.begin()),
status);
status.errIfFailureAndReset("\"%s\"", l.getName());
assertEquals("set::size()", 2, static_cast<int32_t>(result.size()));
assertTrue("set::find(\"calendar\")",
result.find("calendar") != result.end());
assertTrue("set::find(\"collation\")",
result.find("collation") != result.end());
}
void
LocaleTest::TestCreateKeywordSetEmpty() {
IcuTestErrorCode status(*this, "TestCreateKeywordSetEmpty()");
static const Locale l("de");
std::set<std::string> result;
l.getKeywords<std::string>(
std::insert_iterator<decltype(result)>(result, result.begin()),
status);
status.errIfFailureAndReset("\"%s\"", l.getName());
assertEquals("set::size()", 0, static_cast<int32_t>(result.size()));
}
void
LocaleTest::TestCreateKeywordSetWithPrivateUse() {
IcuTestErrorCode status(*this, "TestCreateKeywordSetWithPrivateUse()");
static const char tag[] = "en-US-u-ca-gregory-x-foo";
static const Locale l = Locale::forLanguageTag(tag, status);
std::set<std::string> result;
l.getKeywords<std::string>(
std::insert_iterator<decltype(result)>(result, result.begin()),
status);
status.errIfFailureAndReset("getKeywords \"%s\"", l.getName());
assertTrue("getKeywords set::find(\"calendar\")",
result.find("calendar") != result.end());
assertTrue("getKeywords set::find(\"ca\")",
result.find("ca") == result.end());
assertTrue("getKeywords set::find(\"x\")",
result.find("x") != result.end());
assertTrue("getKeywords set::find(\"foo\")",
result.find("foo") == result.end());
}
void
LocaleTest::TestCreateUnicodeKeywordSet() {
IcuTestErrorCode status(*this, "TestCreateUnicodeKeywordSet()");
static const Locale l("de@calendar=buddhist;collation=phonebook");
std::set<std::string> result;
l.getUnicodeKeywords<std::string>(
std::insert_iterator<decltype(result)>(result, result.begin()),
status);
status.errIfFailureAndReset("\"%s\"", l.getName());
assertEquals("set::size()", 2, static_cast<int32_t>(result.size()));
assertTrue("set::find(\"ca\")",
result.find("ca") != result.end());
assertTrue("set::find(\"co\")",
result.find("co") != result.end());
LocalPointer<StringEnumeration> se(l.createUnicodeKeywords(status), status);
status.errIfFailureAndReset("\"%s\" createUnicodeKeywords()", l.getName());
assertEquals("count()", 2, se->count(status));
status.errIfFailureAndReset("\"%s\" count()", l.getName());
}
void
LocaleTest::TestCreateUnicodeKeywordSetEmpty() {
IcuTestErrorCode status(*this, "TestCreateUnicodeKeywordSetEmpty()");
static const Locale l("de");
std::set<std::string> result;
l.getUnicodeKeywords<std::string>(
std::insert_iterator<decltype(result)>(result, result.begin()),
status);
status.errIfFailureAndReset("\"%s\"", l.getName());
assertEquals("set::size()", 0, static_cast<int32_t>(result.size()));
LocalPointer<StringEnumeration> se(l.createUnicodeKeywords(status), status);
assertTrue("createUnicodeKeywords", se.isNull());
status.expectErrorAndReset(U_MEMORY_ALLOCATION_ERROR);
}
void
LocaleTest::TestCreateUnicodeKeywordSetWithPrivateUse() {
IcuTestErrorCode status(*this, "TestCreateUnicodeKeywordSetWithPrivateUse()");
static const char tag[] = "en-US-u-ca-gregory-x-foo";
static const Locale l = Locale::forLanguageTag(tag, status);
std::set<std::string> result;
l.getUnicodeKeywords<std::string>(
std::insert_iterator<decltype(result)>(result, result.begin()),
status);
status.errIfFailureAndReset("getUnicodeKeywords \"%s\"", l.getName());
assertTrue("getUnicodeKeywords set::find(\"ca\")",
result.find("ca") != result.end());
assertTrue("getUnicodeKeywords set::find(\"x\")",
result.find("x") == result.end());
assertTrue("getUnicodeKeywords set::find(\"foo\")",
result.find("foo") == result.end());
assertEquals("set::size()", 1, static_cast<int32_t>(result.size()));
LocalPointer<StringEnumeration> se(l.createUnicodeKeywords(status), status);
status.errIfFailureAndReset("\"%s\" createUnicodeKeywords()", l.getName());
assertEquals("count()", 1, se->count(status));
status.errIfFailureAndReset("\"%s\" count()", l.getName());
}
void
LocaleTest::TestGetKeywordValueStdString() {
IcuTestErrorCode status(*this, "TestGetKeywordValueStdString()");
static const char tag[] = "fa-u-nu-latn";
static const char keyword[] = "numbers";
static const char expected[] = "latn";
Locale l = Locale::forLanguageTag(tag, status);
status.errIfFailureAndReset("\"%s\"", tag);
std::string result = l.getKeywordValue<std::string>(keyword, status);
status.errIfFailureAndReset("\"%s\"", keyword);
assertEquals(keyword, expected, result.c_str());
}
void
LocaleTest::TestGetUnicodeKeywordValueStdString() {
IcuTestErrorCode status(*this, "TestGetUnicodeKeywordValueStdString()");
static const char keyword[] = "co";
static const char expected[] = "phonebk";
static const Locale l("de@calendar=buddhist;collation=phonebook");
std::string result = l.getUnicodeKeywordValue<std::string>(keyword, status);
status.errIfFailureAndReset("\"%s\"", keyword);
assertEquals(keyword, expected, result.c_str());
}
void
LocaleTest::TestSetKeywordValue() {
static const struct {
const char *keyword;
const char *value;
} testCases[] = {
{ "collation", "phonebook" },
{ "currency", "euro" },
{ "calendar", "buddhist" }
};
IcuTestErrorCode status(*this, "TestSetKeywordValue()");
int32_t i = 0;
int32_t resultLen = 0;
char buffer[256];
Locale l(Locale::getGerman());
for(i = 0; i < UPRV_LENGTHOF(testCases); i++) {
l.setKeywordValue(testCases[i].keyword, testCases[i].value, status);
if(U_FAILURE(status)) {
err("FAIL: Locale::setKeywordValue failed - %s\n", u_errorName(status));
}
*buffer = 0;
resultLen = l.getKeywordValue(testCases[i].keyword, buffer, 256, status);
(void)resultLen; // Suppress unused variable warning.
if(uprv_strcmp(testCases[i].value, buffer) != 0) {
err("Expected to extract \"%s\" for keyword \"%s\". Got \"%s\" instead\n",
testCases[i].value, testCases[i].keyword, buffer);
}
}
// Test long locale
{
status.errIfFailureAndReset();
const char* input =
"de__POSIX@colnormalization=no;colstrength=primary;currency=eur;"
"em=default;kv=space;lb=strict;lw=normal;measure=metric;"
"numbers=latn;rg=atzzzz;sd=atat1";
const char* expected =
"de__POSIX@colnormalization=no;colstrength=primary;currency=eur;"
"em=default;kv=space;lb=strict;lw=normal;measure=metric;"
"numbers=latn;rg=atzzzz;sd=atat1;ss=none";
// Bug ICU-21385
Locale l2(input);
l2.setKeywordValue("ss", "none", status);
assertEquals("", expected, l2.getName());
status.errIfFailureAndReset();
}
}
void
LocaleTest::TestSetKeywordValueStringPiece() {
IcuTestErrorCode status(*this, "TestSetKeywordValueStringPiece()");
Locale l(Locale::getGerman());
l.setKeywordValue(StringPiece("collation"), StringPiece("phonebook"), status);
l.setKeywordValue(StringPiece("calendarxxx", 8), StringPiece("buddhistxxx", 8), status);
static const char expected[] = "de@calendar=buddhist;collation=phonebook";
assertEquals("", expected, l.getName());
}
void
LocaleTest::TestSetUnicodeKeywordValueStringPiece() {
IcuTestErrorCode status(*this, "TestSetUnicodeKeywordValueStringPiece()");
Locale l(Locale::getGerman());
l.setUnicodeKeywordValue(StringPiece("co"), StringPiece("phonebk"), status);
status.errIfFailureAndReset();
l.setUnicodeKeywordValue(StringPiece("caxxx", 2), StringPiece("buddhistxxx", 8), status);
status.errIfFailureAndReset();
static const char expected[] = "de@calendar=buddhist;collation=phonebook";
assertEquals("", expected, l.getName());
l.setUnicodeKeywordValue("cu", nullptr, status);
status.errIfFailureAndReset();
assertEquals("", expected, l.getName());
l.setUnicodeKeywordValue("!!", nullptr, status);
assertEquals("status", U_ILLEGAL_ARGUMENT_ERROR, status.reset());
assertEquals("", expected, l.getName());
l.setUnicodeKeywordValue("co", "!!", status);
assertEquals("status", U_ILLEGAL_ARGUMENT_ERROR, status.reset());
assertEquals("", expected, l.getName());
l.setUnicodeKeywordValue("co", nullptr, status);
status.errIfFailureAndReset();
l.setUnicodeKeywordValue("ca", "", status);
status.errIfFailureAndReset();
assertEquals("", Locale::getGerman().getName(), l.getName());
}
void
LocaleTest::TestGetBaseName() {
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" },
{ "de-u-co-phonebk", "de"}
};
int32_t i = 0;
for(i = 0; i < UPRV_LENGTHOF(testCases); i++) {
Locale loc(testCases[i].localeID);
if(strcmp(testCases[i].baseName, loc.getBaseName())) {
errln("For locale \"%s\" expected baseName \"%s\", but got \"%s\"",
testCases[i].localeID, testCases[i].baseName, loc.getBaseName());
return;
}
}
// Verify that adding a keyword to an existing Locale doesn't change the base name.
UErrorCode status = U_ZERO_ERROR;
Locale loc2("en-US");
if (strcmp("en_US", loc2.getBaseName())) {
errln("%s:%d Expected \"en_US\", got \"%s\"", __FILE__, __LINE__, loc2.getBaseName());
}
loc2.setKeywordValue("key", "value", status);
if (strcmp("en_US@key=value", loc2.getName())) {
errln("%s:%d Expected \"en_US@key=value\", got \"%s\"", __FILE__, __LINE__, loc2.getName());
}
if (strcmp("en_US", loc2.getBaseName())) {
errln("%s:%d Expected \"en_US\", got \"%s\"", __FILE__, __LINE__, loc2.getBaseName());
}
}
/**
* 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 = static_cast<int32_t>(strlen(string)),
plen = static_cast<int32_t>(strlen(prefix));
int32_t c = uprv_strncmp(string, prefix, plen);
/* 'root' is "less than" everything */
if (prefix[0] == '\0') {
return string[0] != '\0';
}
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" */
}
/**
* Check the relationship between requested locales, and report problems.
* The caller specifies the expected relationships between requested
* and valid (expReqValid) and between valid and actual (expValidActual).
* Possible values are:
* "gt" strictly greater than, e.g., en_US > en
* "ge" greater or equal, e.g., en >= en
* "eq" equal, e.g., en == en
*/
void LocaleTest::_checklocs(const char* label,
const char* req,
const Locale& validLoc,
const Locale& actualLoc,
const char* expReqValid,
const char* expValidActual) {
const char* valid = validLoc.getName();
const char* actual = actualLoc.getName();
int32_t reqValid = _loccmp(req, valid);
int32_t validActual = _loccmp(valid, actual);
if (((0 == uprv_strcmp(expReqValid, "gt") && reqValid > 0) ||
(0 == uprv_strcmp(expReqValid, "ge") && reqValid >= 0) ||
(0 == uprv_strcmp(expReqValid, "eq") && reqValid == 0)) &&
((0 == uprv_strcmp(expValidActual, "gt") && validActual > 0) ||
(0 == uprv_strcmp(expValidActual, "ge") && validActual >= 0) ||
(0 == uprv_strcmp(expValidActual, "eq") && validActual == 0))) {
logln("%s; req=%s, valid=%s, actual=%s",
label, req, valid, actual);
} else {
dataerrln("FAIL: %s; req=%s, valid=%s, actual=%s. Require (R %s V) and (V %s A)",
label, req, valid, actual,
expReqValid, expValidActual);
}
}
void LocaleTest::TestGetLocale() {
#if !UCONFIG_NO_SERVICE
const char *req;
Locale valid, actual, reqLoc;
// Calendar
#if !UCONFIG_NO_FORMATTING
{
UErrorCode ec = U_ZERO_ERROR; // give each resource type its own error code
req = "en_US_BROOKLYN";
Calendar* cal = Calendar::createInstance(Locale::createFromName(req), ec);
if (U_FAILURE(ec)) {
dataerrln("FAIL: Calendar::createInstance failed - %s", u_errorName(ec));
} else {
valid = cal->getLocale(ULOC_VALID_LOCALE, ec);
actual = cal->getLocale(ULOC_ACTUAL_LOCALE, ec);
if (U_FAILURE(ec)) {
errln("FAIL: Calendar::getLocale() failed");
} else {
_checklocs("Calendar", req, valid, actual);
}
/* Make sure that it fails correctly */
ec = U_FILE_ACCESS_ERROR;
if (cal->getLocale(ULOC_VALID_LOCALE, ec).getName()[0] != 0) {
errln("FAIL: Calendar::getLocale() failed to fail correctly. It should have returned \"\"");
}
ec = U_ZERO_ERROR;
}
delete cal;
}
#endif
// DecimalFormat, DecimalFormatSymbols
#if !UCONFIG_NO_FORMATTING
{
UErrorCode ec = U_ZERO_ERROR; // give each resource type its own error code
req = "fr_FR_NICE";
NumberFormat* nf = NumberFormat::createInstance(Locale::createFromName(req), ec);
if (U_FAILURE(ec)) {
dataerrln("FAIL: NumberFormat::createInstance failed - %s", u_errorName(ec));
} else {
DecimalFormat* dec = dynamic_cast<DecimalFormat*>(nf);
if (dec == nullptr) {
errln("FAIL: NumberFormat::createInstance does not return a DecimalFormat");
return;
}
valid = dec->getLocale(ULOC_VALID_LOCALE, ec);
actual = dec->getLocale(ULOC_ACTUAL_LOCALE, ec);
if (U_FAILURE(ec)) {
errln("FAIL: DecimalFormat::getLocale() failed");
} else {
_checklocs("DecimalFormat", req, valid, actual);
}
const DecimalFormatSymbols* sym = dec->getDecimalFormatSymbols();
if (sym == nullptr) {
errln("FAIL: getDecimalFormatSymbols returned nullptr");
return;
}
valid = sym->getLocale(ULOC_VALID_LOCALE, ec);
actual = sym->getLocale(ULOC_ACTUAL_LOCALE, ec);
if (U_FAILURE(ec)) {
errln("FAIL: DecimalFormatSymbols::getLocale() failed");
} else {
_checklocs("DecimalFormatSymbols", req, valid, actual);
}
}
delete nf;
}
#endif
// DateFormat, DateFormatSymbols
#if !UCONFIG_NO_FORMATTING
{
UErrorCode ec = U_ZERO_ERROR; // give each resource type its own error code
req = "de_CH_LUCERNE";
DateFormat* df =
DateFormat::createDateInstance(DateFormat::kDefault,
Locale::createFromName(req));
if (df == nullptr) {
dataerrln("Error calling DateFormat::createDateInstance()");
} else {
SimpleDateFormat* dat = dynamic_cast<SimpleDateFormat*>(df);
if (dat == nullptr) {
errln("FAIL: DateFormat::createInstance does not return a SimpleDateFormat");
return;
}
valid = dat->getLocale(ULOC_VALID_LOCALE, ec);
actual = dat->getLocale(ULOC_ACTUAL_LOCALE, ec);
if (U_FAILURE(ec)) {
errln("FAIL: SimpleDateFormat::getLocale() failed");
} else {
_checklocs("SimpleDateFormat", req, valid, actual);
}
const DateFormatSymbols* sym = dat->getDateFormatSymbols();
if (sym == nullptr) {
errln("FAIL: getDateFormatSymbols returned nullptr");
return;
}
valid = sym->getLocale(ULOC_VALID_LOCALE, ec);
actual = sym->getLocale(ULOC_ACTUAL_LOCALE, ec);
if (U_FAILURE(ec)) {
errln("FAIL: DateFormatSymbols::getLocale() failed");
} else {
_checklocs("DateFormatSymbols", req, valid, actual);
}
}
delete df;
}
#endif
// BreakIterator
#if !UCONFIG_NO_BREAK_ITERATION
{
UErrorCode ec = U_ZERO_ERROR; // give each resource type its own error code
req = "es_ES_BARCELONA";
reqLoc = Locale::createFromName(req);
BreakIterator* brk = BreakIterator::createWordInstance(reqLoc, ec);
if (U_FAILURE(ec)) {
dataerrln("FAIL: BreakIterator::createWordInstance failed - %s", u_errorName(ec));
} else {
valid = brk->getLocale(ULOC_VALID_LOCALE, ec);
actual = brk->getLocale(ULOC_ACTUAL_LOCALE, ec);
if (U_FAILURE(ec)) {
errln("FAIL: BreakIterator::getLocale() failed");
} else {
_checklocs("BreakIterator", req, valid, actual);
}
// After registering something, the behavior should be different
URegistryKey key = BreakIterator::registerInstance(brk, reqLoc, UBRK_WORD, ec);
brk = nullptr; // registerInstance adopts
if (U_FAILURE(ec)) {
errln("FAIL: BreakIterator::registerInstance() failed");
} else {
brk = BreakIterator::createWordInstance(reqLoc, ec);
if (U_FAILURE(ec)) {
errln("FAIL: BreakIterator::createWordInstance failed");
} else {
valid = brk->getLocale(ULOC_VALID_LOCALE, ec);
actual = brk->getLocale(ULOC_ACTUAL_LOCALE, ec);
if (U_FAILURE(ec)) {
errln("FAIL: BreakIterator::getLocale() failed");
} else {
// N.B.: now expect valid==actual==req
_checklocs("BreakIterator(registered)",
req, valid, actual, "eq", "eq");
}
}
// No matter what, unregister
BreakIterator::unregister(key, ec);
if (U_FAILURE(ec)) {
errln("FAIL: BreakIterator::unregister() failed");
}
delete brk;
brk = nullptr;
}
// After unregistering, should behave normally again
brk = BreakIterator::createWordInstance(reqLoc, ec);
if (U_FAILURE(ec)) {
errln("FAIL: BreakIterator::createWordInstance failed");
} else {
valid = brk->getLocale(ULOC_VALID_LOCALE, ec);
actual = brk->getLocale(ULOC_ACTUAL_LOCALE, ec);
if (U_FAILURE(ec)) {
errln("FAIL: BreakIterator::getLocale() failed");
} else {
_checklocs("BreakIterator(unregistered)", req, valid, actual);
}
}
}
delete brk;
}
#endif
// Collator
#if !UCONFIG_NO_COLLATION
{
UErrorCode ec = U_ZERO_ERROR; // give each resource type its own error code
checkRegisteredCollators(nullptr); // Don't expect any extras
req = "hi_IN_BHOPAL";
reqLoc = Locale::createFromName(req);
Collator* coll = Collator::createInstance(reqLoc, ec);
if (U_FAILURE(ec)) {
dataerrln("FAIL: Collator::createInstance failed - %s", u_errorName(ec));
} else {
valid = coll->getLocale(ULOC_VALID_LOCALE, ec);
actual = coll->getLocale(ULOC_ACTUAL_LOCALE, ec);
if (U_FAILURE(ec)) {
errln("FAIL: Collator::getLocale() failed");
} else {
_checklocs("Collator", req, valid, actual);
}
// After registering something, the behavior should be different
URegistryKey key = Collator::registerInstance(coll, reqLoc, ec);
coll = nullptr; // registerInstance adopts
if (U_FAILURE(ec)) {
errln("FAIL: Collator::registerInstance() failed");
} else {
coll = Collator::createInstance(reqLoc, ec);
if (U_FAILURE(ec)) {
errln("FAIL: Collator::createWordInstance failed");
} else {
valid = coll->getLocale(ULOC_VALID_LOCALE, ec);
actual = coll->getLocale(ULOC_ACTUAL_LOCALE, ec);
if (U_FAILURE(ec)) {
errln("FAIL: Collator::getLocale() failed");
} else {
// N.B.: now expect valid==actual==req
_checklocs("Collator(registered)",
req, valid, actual, "eq", "eq");
}
}
checkRegisteredCollators(req); // include hi_IN_BHOPAL
// No matter what, unregister
Collator::unregister(key, ec);
if (U_FAILURE(ec)) {
errln("FAIL: Collator::unregister() failed");
}
delete coll;
coll = nullptr;
}
// After unregistering, should behave normally again
coll = Collator::createInstance(reqLoc, ec);
if (U_FAILURE(ec)) {
errln("FAIL: Collator::createInstance failed");
} else {
valid = coll->getLocale(ULOC_VALID_LOCALE, ec);
actual = coll->getLocale(ULOC_ACTUAL_LOCALE, ec);
if (U_FAILURE(ec)) {
errln("FAIL: Collator::getLocale() failed");
} else {
_checklocs("Collator(unregistered)", req, valid, actual);
}
}
}
delete coll;
checkRegisteredCollators(nullptr); // extra should be gone again
}
#endif
#endif
}
#if !UCONFIG_NO_COLLATION
/**
* Compare Collator::getAvailableLocales(int) [ "old", returning an array ]
* with Collator::getAvailableLocales() [ "new", returning a StringEnumeration ]
* These should be identical (check their API docs) EXCEPT that
* if expectExtra is non-nullptr, it will be in the "new" array but not "old".
* Does not return any status but calls errln on error.
* @param expectExtra an extra locale, will be in "new" but not "old". Or nullptr.
*/
void LocaleTest::checkRegisteredCollators(const char *expectExtra) {
UErrorCode status = U_ZERO_ERROR;
int32_t count1=0,count2=0;
Hashtable oldHash(status);
Hashtable newHash(status);
assertSuccess(WHERE, status);
UnicodeString expectStr(expectExtra?expectExtra:"n/a", "");
// the 'old' list (non enumeration)
const Locale* oldList = Collator::getAvailableLocales(count1);
if(oldList == nullptr) {
dataerrln("Error: Collator::getAvailableLocales(count) returned nullptr");
return;
}
// the 'new' list (enumeration)
LocalPointer<StringEnumeration> newEnum(Collator::getAvailableLocales());
if(newEnum.isNull()) {
errln("Error: collator::getAvailableLocales() returned nullptr");
return;
}
// OK. Let's add all of the OLD
// then check for any in the NEW not in OLD
// then check for any in OLD not in NEW.
// 1. add all of OLD
for(int32_t i=0;i<count1;i++) {
const UnicodeString key(oldList[i].getName(), "");
int32_t oldI = oldHash.puti(key, 1, status);
if( oldI == 1 ){
errln("Error: duplicate key %s in Collator::getAvailableLocales(count) list.\n",
oldList[i].getName());
return;
}
if(expectExtra != nullptr && !strcmp(expectExtra, oldList[i].getName())) {
errln("Inexplicably, Collator::getAvailableCollators(count) had registered collator %s. This shouldn't happen, so I am going to consider it an error.\n", expectExtra);
}
}
// 2. add all of NEW
const UnicodeString *locStr;
UBool foundExpected = false;
while((locStr = newEnum->snext(status)) && U_SUCCESS(status)) {
count2++;
if(expectExtra != nullptr && expectStr == *locStr) {
foundExpected = true;
logln(UnicodeString("Found expected registered collator: ","") + expectStr);
}
(void)foundExpected; // Hush unused variable compiler warning.
if( oldHash.geti(*locStr) == 0 ) {
if(expectExtra != nullptr && expectStr==*locStr) {
logln(UnicodeString("As expected, Collator::getAvailableLocales(count) is missing registered collator ") + expectStr);
} else {
errln(UnicodeString("Error: Collator::getAvailableLocales(count) is missing: ","")
+ *locStr);
}
}
newHash.puti(*locStr, 1, status);
}
// 3. check all of OLD again
for(int32_t i=0;i<count1;i++) {
const UnicodeString key(oldList[i].getName(), "");
int32_t newI = newHash.geti(key);
if(newI == 0) {
errln(UnicodeString("Error: Collator::getAvailableLocales() is missing: ","")
+ key);
}
}
int32_t expectCount2 = count1;
if(expectExtra != nullptr) {
expectCount2 ++; // if an extra item registered, bump the expect count
}
assertEquals("Collator::getAvail() count", expectCount2, count2);
}
#endif
void LocaleTest::TestVariantWithOutCountry() {
Locale loc("en","","POSIX");
if (0 != strcmp(loc.getVariant(), "POSIX")) {
errln("FAIL: en__POSIX didn't get parsed correctly - name is %s - expected %s got %s", loc.getName(), "POSIX", loc.getVariant());
}
Locale loc2("en","","FOUR");
if (0 != strcmp(loc2.getVariant(), "FOUR")) {
errln("FAIL: en__FOUR didn't get parsed correctly - name is %s - expected %s got %s", loc2.getName(), "FOUR", loc2.getVariant());
}
Locale loc3("en","Latn","","FOUR");
if (0 != strcmp(loc3.getVariant(), "FOUR")) {
errln("FAIL: en_Latn__FOUR didn't get parsed correctly - name is %s - expected %s got %s", loc3.getName(), "FOUR", loc3.getVariant());
}
Locale loc4("","Latn","","FOUR");
if (0 != strcmp(loc4.getVariant(), "FOUR")) {
errln("FAIL: _Latn__FOUR didn't get parsed correctly - name is %s - expected %s got %s", loc4.getName(), "FOUR", loc4.getVariant());
}
Locale loc5("","Latn","US","FOUR");
if (0 != strcmp(loc5.getVariant(), "FOUR")) {
errln("FAIL: _Latn_US_FOUR didn't get parsed correctly - name is %s - expected %s got %s", loc5.getName(), "FOUR", loc5.getVariant());
}
Locale loc6("de-1901");
if (0 != strcmp(loc6.getVariant(), "1901")) {
errln("FAIL: de-1901 didn't get parsed correctly - name is %s - expected %s got %s", loc6.getName(), "1901", loc6.getVariant());
}
}
static Locale _canonicalize(int32_t selector, /* 0==createFromName, 1==createCanonical, 2==Locale ct */
const char* localeID) {
switch (selector) {
case 0:
return Locale::createFromName(localeID);
case 1:
return Locale::createCanonical(localeID);
case 2:
return {localeID};
default:
return {""};
}
}
void LocaleTest::TestCanonicalization()
{
static const struct {
const char *localeID; /* input */
const char *getNameID; /* expected getName() result */
const char *canonicalID; /* expected canonicalize() result */
} testCases[] = {
{ "ca_ES-with-extra-stuff-that really doesn't make any sense-unless-you're trying to increase code coverage",
"ca_ES_WITH_EXTRA_STUFF_THAT REALLY DOESN'T MAKE ANY SENSE_UNLESS_YOU'RE TRYING TO INCREASE CODE COVERAGE",
"ca_ES_EXTRA_STUFF_THAT REALLY DOESN'T MAKE ANY SENSE_UNLESS_WITH_YOU'RE TRYING TO INCREASE CODE COVERAGE"},
{ "zh@collation=pinyin", "zh@collation=pinyin", "zh@collation=pinyin" },
{ "zh_CN@collation=pinyin", "zh_CN@collation=pinyin", "zh_CN@collation=pinyin" },
{ "zh_CN_CA@collation=pinyin", "zh_CN_CA@collation=pinyin", "zh_CN_CA@collation=pinyin" },
{ "en_US_POSIX", "en_US_POSIX", "en_US_POSIX" },
{ "hy_AM_REVISED", "hy_AM_REVISED", "hy_AM_REVISED" },
{ "no_NO_NY", "no_NO_NY", "no_NO_NY" /* not: "nn_NO" [alan ICU3.0] */ },
{ "no@ny", "no@ny", "no__NY" /* not: "nn" [alan ICU3.0] */ }, /* POSIX ID */
{ "no-no.utf32@B", "no_NO.utf32@B", "no_NO_B" }, /* POSIX ID */
{ "qz-qz@Euro", "qz_QZ@Euro", "qz_QZ_EURO" }, /* qz-qz uses private use iso codes */
// A very long charset name in IANA charset
{ "ja_JP.Extended_UNIX_Code_Packed_Format_for_Japanese@B",
"ja_JP.Extended_UNIX_Code_Packed_Format_for_Japanese@B", "ja_JP_B" }, /* POSIX ID */
// A fake long charset name below the limitation
{ "ja_JP.1234567890123456789012345678901234567890123456789012345678901234@B",
"ja_JP.1234567890123456789012345678901234567890123456789012345678901234@B",
"ja_JP_B" }, /* POSIX ID */
// A fake long charset name one char above the limitation
{ "ja_JP.12345678901234567890123456789012345678901234567890123456789012345@B",
"BOGUS",
"ja_JP_B" }, /* POSIX ID */
// NOTE: uloc_getName() works on en-BOONT, but Locale() parser considers it BOGUS
// TODO: unify this behavior
{ "en-BOONT", "en__BOONT", "en__BOONT" }, /* registered name */
{ "de-1901", "de__1901", "de__1901" }, /* registered name */
{ "de-1906", "de__1906", "de__1906" }, /* registered name */
// New in CLDR 39 / ICU 69
{ "nb", "nb", "nb" },
/* 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@b=ny" /* 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_GIRL_VALLEY@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_GIRL_VALLEY@calendar=Japanese;currency=EUR" },
/* 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" },
// Before ICU 64, ICU locale canonicalization had some additional mappings.
// They were removed for ICU-20187 "drop support for long-obsolete locale ID variants".
// The following now use standard canonicalization.
{ "", "", "" },
{ "C", "c", "c" },
{ "POSIX", "posix", "posix" },
{ "ca_ES_PREEURO", "ca_ES_PREEURO", "ca_ES_PREEURO" },
{ "de_AT_PREEURO", "de_AT_PREEURO", "de_AT_PREEURO" },
{ "de_DE_PREEURO", "de_DE_PREEURO", "de_DE_PREEURO" },
{ "de_LU_PREEURO", "de_LU_PREEURO", "de_LU_PREEURO" },
{ "el_GR_PREEURO", "el_GR_PREEURO", "el_GR_PREEURO" },
{ "en_BE_PREEURO", "en_BE_PREEURO", "en_BE_PREEURO" },
{ "en_IE_PREEURO", "en_IE_PREEURO", "en_IE_PREEURO" },
{ "es_ES_PREEURO", "es_ES_PREEURO", "es_ES_PREEURO" },
{ "eu_ES_PREEURO", "eu_ES_PREEURO", "eu_ES_PREEURO" },
{ "fi_FI_PREEURO", "fi_FI_PREEURO", "fi_FI_PREEURO" },
{ "fr_BE_PREEURO", "fr_BE_PREEURO", "fr_BE_PREEURO" },
{ "fr_FR_PREEURO", "fr_FR_PREEURO", "fr_FR_PREEURO" },
{ "fr_LU_PREEURO", "fr_LU_PREEURO", "fr_LU_PREEURO" },
{ "ga_IE_PREEURO", "ga_IE_PREEURO", "ga_IE_PREEURO" },
{ "gl_ES_PREEURO", "gl_ES_PREEURO", "gl_ES_PREEURO" },
{ "it_IT_PREEURO", "it_IT_PREEURO", "it_IT_PREEURO" },
{ "nl_BE_PREEURO", "nl_BE_PREEURO", "nl_BE_PREEURO" },
{ "nl_NL_PREEURO", "nl_NL_PREEURO", "nl_NL_PREEURO" },
{ "pt_PT_PREEURO", "pt_PT_PREEURO", "pt_PT_PREEURO" },
{ "de__PHONEBOOK", "de__PHONEBOOK", "de__PHONEBOOK" },
{ "en_GB_EURO", "en_GB_EURO", "en_GB_EURO" },
{ "en_GB@EURO", "en_GB@EURO", "en_GB_EURO" }, /* POSIX ID */
{ "es__TRADITIONAL", "es__TRADITIONAL", "es__TRADITIONAL" },
{ "hi__DIRECT", "hi__DIRECT", "hi__DIRECT" },
{ "ja_JP_TRADITIONAL", "ja_JP_TRADITIONAL", "ja_JP_TRADITIONAL" },
{ "th_TH_TRADITIONAL", "th_TH_TRADITIONAL", "th_TH_TRADITIONAL" },
{ "zh_TW_STROKE", "zh_TW_STROKE", "zh_TW_STROKE" },
{ "zh__PINYIN", "zh__PINYIN", "zh__PINYIN" },
{ "sr-SP-Cyrl", "sr_SP_CYRL", "sr_SP_CYRL" }, /* .NET name */
{ "sr-SP-Latn", "sr_SP_LATN", "sr_SP_LATN" }, /* .NET name */
{ "sr_YU_CYRILLIC", "sr_YU_CYRILLIC", "sr_RS_CYRILLIC" }, /* Linux name */
{ "uz-UZ-Cyrl", "uz_UZ_CYRL", "uz_UZ_CYRL" }, /* .NET name */
{ "uz-UZ-Latn", "uz_UZ_LATN", "uz_UZ_LATN" }, /* .NET name */
{ "zh-CHS", "zh_CHS", "zh_CHS" }, /* .NET name */
{ "zh-CHT", "zh_CHT", "zh_CHT" }, /* .NET name This may change back to zh_Hant */
/* PRE_EURO and EURO conversions don't affect other keywords */
{ "es_ES_PREEURO@CALendar=Japanese", "es_ES_PREEURO@calendar=Japanese", "es_ES_PREEURO@calendar=Japanese" },
{ "es_ES_EURO@SHOUT=zipeedeedoodah", "es_ES_EURO@shout=zipeedeedoodah", "es_ES_EURO@shout=zipeedeedoodah" },
/* currency keyword overrides PRE_EURO and EURO currency */
{ "es_ES_PREEURO@currency=EUR", "es_ES_PREEURO@currency=EUR", "es_ES_PREEURO@currency=EUR" },
{ "es_ES_EURO@currency=ESP", "es_ES_EURO@currency=ESP", "es_ES_EURO@currency=ESP" },
};
static const char* label[] = { "createFromName", "createCanonical", "Locale" };
int32_t i, j;
for (i=0; i < UPRV_LENGTHOF(testCases); i++) {
for (j=0; j<3; ++j) {
const char* expected = (j==1) ? testCases[i].canonicalID : testCases[i].getNameID;
Locale loc = _canonicalize(j, testCases[i].localeID);
const char* getName = loc.isBogus() ? "BOGUS" : loc.getName();
if(uprv_strcmp(expected, getName) != 0) {
errln("FAIL: %s(%s).getName() => \"%s\", expected \"%s\"",
label[j], testCases[i].localeID, getName, expected);
} else {
logln("Ok: %s(%s) => \"%s\"",
label[j], testCases[i].localeID, getName);
}
}
}
}
void LocaleTest::TestCanonicalize()
{
static const struct {
const char *localeID; /* input */
const char *canonicalID; /* expected canonicalize() result */
} testCases[] = {
// language _ variant -> language
{ "no-BOKMAL", "nb" },
// also test with script, country and extensions
{ "no-Cyrl-ID-BOKMAL-u-ca-japanese", "nb-Cyrl-ID-u-ca-japanese" },
{ "no-Cyrl-ID-1901-BOKMAL-xsistemo-u-ca-japanese", "nb-Cyrl-ID-1901-xsistemo-u-ca-japanese" },
{ "no-Cyrl-ID-1901-BOKMAL-u-ca-japanese", "nb-Cyrl-ID-1901-u-ca-japanese" },
{ "no-Cyrl-ID-BOKMAL-xsistemo-u-ca-japanese", "nb-Cyrl-ID-xsistemo-u-ca-japanese" },
{ "no-NYNORSK", "nn" },
{ "no-Cyrl-ID-NYNORSK-u-ca-japanese", "nn-Cyrl-ID-u-ca-japanese" },
{ "aa-SAAHO", "ssy" },
// also test with script, country and extensions
{ "aa-Deva-IN-SAAHO-u-ca-japanese", "ssy-Deva-IN-u-ca-japanese" },
// language -> language
{ "aam", "aas" },
// also test with script, country, variants and extensions
{ "aam-Cyrl-ID-3456-u-ca-japanese", "aas-Cyrl-ID-3456-u-ca-japanese" },
// language -> language _ Script
{ "sh", "sr-Latn" },
// also test with script
{ "sh-Cyrl", "sr-Cyrl" },
// also test with country, variants and extensions
{ "sh-ID-3456-u-ca-roc", "sr-Latn-ID-3456-u-ca-roc" },
// language -> language _ country
{ "prs", "fa-AF" },
// also test with country
{ "prs-RU", "fa-RU" },
// also test with script, variants and extensions
{ "prs-Cyrl-1009-u-ca-roc", "fa-Cyrl-AF-1009-u-ca-roc" },
{ "pa-IN", "pa-IN" },
// also test with script
{ "pa-Latn-IN", "pa-Latn-IN" },
// also test with variants and extensions
{ "pa-IN-5678-u-ca-hindi", "pa-IN-5678-u-ca-hindi" },
{ "ky-Cyrl-KG", "ky-Cyrl-KG" },
// also test with variants and extensions
{ "ky-Cyrl-KG-3456-u-ca-roc", "ky-Cyrl-KG-3456-u-ca-roc" },
// Test replacement of scriptAlias
{ "en-Qaai", "en-Zinh" },
// Test replacement of territoryAlias
// 554 has one replacement
{ "en-554", "en-NZ" },
{ "en-554-u-nu-arab", "en-NZ-u-nu-arab" },
// 172 has multiple replacements
// also test with variants
{ "ru-172-1234", "ru-RU-1234" },
// also test with extensions
{ "ru-172-1234-u-nu-latn", "ru-RU-1234-u-nu-latn" },
// also test with scripts
{ "uz-172", "uz-UZ" },
{ "uz-Cyrl-172", "uz-Cyrl-UZ" },
{ "uz-Bopo-172", "uz-Bopo-UZ" },
// also test with variants and scripts
{ "uz-Cyrl-172-5678-u-nu-latn", "uz-Cyrl-UZ-5678-u-nu-latn" },
// a language not used in this region
{ "fr-172", "fr-RU" },
// variant
{ "ja-Latn-hepburn-heploc", "ja-Latn-alalc97"},
{ "aaa-Fooo-SU", "aaa-Fooo-RU"},
// ICU-21344
{ "ku-Arab-NT", "ku-Arab-IQ"},
// ICU-21402
{ "und-u-rg-no23", "und-u-rg-no50"},
{ "und-u-rg-cn11", "und-u-rg-cnbj"},
{ "und-u-rg-cz10a", "und-u-rg-cz110"},
{ "und-u-rg-fra", "und-u-rg-frges"},
{ "und-u-rg-frg", "und-u-rg-frges"},
{ "und-u-rg-lud", "und-u-rg-lucl"},
{ "und-NO-u-sd-no23", "und-NO-u-sd-no50"},
{ "und-CN-u-sd-cn11", "und-CN-u-sd-cnbj"},
{ "und-CZ-u-sd-cz10a", "und-CZ-u-sd-cz110"},
{ "und-FR-u-sd-fra", "und-FR-u-sd-frges"},
{ "und-FR-u-sd-frg", "und-FR-u-sd-frges"},
{ "und-LU-u-sd-lud", "und-LU-u-sd-lucl"},
// ICU-21550
{ "und-u-rg-fi01", "und-u-rg-axzzzz"},
{ "und-u-rg-frcp", "und-u-rg-cpzzzz"},
{ "und-u-rg-frpm", "und-u-rg-pmzzzz"},
{ "und-u-rg-usvi", "und-u-rg-vizzzz"},
{ "und-u-rg-cn91", "und-u-rg-hkzzzz"},
{ "und-u-rg-nlaw", "und-u-rg-awzzzz"},
{ "und-NO-u-sd-frre", "und-NO-u-sd-rezzzz"},
{ "und-CN-u-sd-nlcw", "und-CN-u-sd-cwzzzz"},
{ "und-CZ-u-sd-usgu", "und-CZ-u-sd-guzzzz"},
{ "und-FR-u-sd-shta", "und-FR-u-sd-tazzzz"},
{ "und-FR-u-sd-cn71", "und-FR-u-sd-twzzzz"},
// ICU-21401
{ "cel-gaulish", "xtg"},
// ICU-21406
// Inside T extension
// Case of Script and Region
{ "ja-kana-jp-t-it-latn-it", "ja-Kana-JP-t-it-latn-it"},
{ "und-t-zh-hani-tw", "und-t-zh-hani-tw"},
{ "und-cyrl-t-und-Latn", "und-Cyrl-t-und-latn"},
// Order of singleton
{ "und-u-ca-roc-t-zh", "und-t-zh-u-ca-roc"},
// Variant subtags are alphabetically ordered.
{ "sl-t-sl-rozaj-biske-1994", "sl-t-sl-1994-biske-rozaj"},
// tfield subtags are alphabetically ordered.
// (Also tests subtag case normalisation.)
{ "DE-T-lv-M0-DIN", "de-t-lv-m0-din"},
{ "DE-T-M0-DIN-K0-QWERTZ", "de-t-k0-qwertz-m0-din"},
{ "DE-T-lv-M0-DIN-K0-QWERTZ", "de-t-lv-k0-qwertz-m0-din"},
// "true" tvalue subtags aren't removed.
// (UTS 35 version 36, §3.2.1 claims otherwise, but tkey must be followed by
// tvalue, so that's likely a spec bug in UTS 35.)
{ "en-t-m0-true", "en-t-m0-true"},
// tlang subtags are canonicalised.
{ "en-t-iw", "en-t-he"},
{ "en-t-hy-latn-SU", "en-t-hy-latn-am"},
{ "ru-t-ru-cyrl-SU", "ru-t-ru-cyrl-ru"},
{ "fr-t-fr-172", "fr-t-fr-ru"},
{ "und-t-no-latn-BOKMAL", "und-t-nb-latn" },
{ "und-t-sgn-qAAi-NL", "und-t-dse-zinh" },
// alias of tvalue should be replaced
{ "en-t-m0-NaMeS", "en-t-m0-prprname" },
{ "en-t-s0-ascii-d0-NaMe", "en-t-d0-charname-s0-ascii" },
};
int32_t i;
for (i=0; i < UPRV_LENGTHOF(testCases); i++) {
UErrorCode status = U_ZERO_ERROR;
std::string otag = testCases[i].localeID;
Locale loc = Locale::forLanguageTag(otag.c_str(), status);
loc.canonicalize(status);
std::string tag = loc.toLanguageTag<std::string>(status);
if (tag != testCases[i].canonicalID) {
errcheckln(status, "FAIL: %s should be canonicalized to %s but got %s - %s",
otag.c_str(),
testCases[i].canonicalID,
tag.c_str(),
u_errorName(status));
}
}
}
void LocaleTest::TestCurrencyByDate()
{
#if !UCONFIG_NO_FORMATTING
UErrorCode status = U_ZERO_ERROR;
UDate date = uprv_getUTCtime();
char16_t TMP[4] = {0, 0, 0, 0};
int32_t index = 0;
int32_t resLen = 0;
UnicodeString tempStr, resultStr;
// Cycle through historical currencies
date = static_cast<UDate>(-630720000000.0); // pre 1961 - no currency defined
index = ucurr_countCurrencies("eo_AM", date, &status);
if (index != 0)
{
errcheckln(status, "FAIL: didn't return 0 for eo_AM - %s", u_errorName(status));
}
resLen = ucurr_forLocaleAndDate("eo_AM", date, index, TMP, 4, &status);
if (resLen != 0) {
errcheckln(status, "FAIL: eo_AM didn't return nullptr - %s", u_errorName(status));
}
status = U_ZERO_ERROR;
date = static_cast<UDate>(0.0); // 1970 - one currency defined
index = ucurr_countCurrencies("eo_AM", date, &status);
if (index != 1)
{
errcheckln(status, "FAIL: didn't return 1 for eo_AM - %s", u_errorName(status));
}
resLen = ucurr_forLocaleAndDate("eo_AM", date, index, TMP, 4, &status);
tempStr.setTo(TMP);
resultStr.setTo("SUR");
if (resultStr != tempStr) {
errcheckln(status, "FAIL: didn't return SUR for eo_AM - %s", u_errorName(status));
}
date = static_cast<UDate>(693792000000.0); // 1992 - one currency defined
index = ucurr_countCurrencies("eo_AM", date, &status);
if (index != 1)
{
errcheckln(status, "FAIL: didn't return 1 for eo_AM - %s", u_errorName(status));
}
resLen = ucurr_forLocaleAndDate("eo_AM", date, index, TMP, 4, &status);
tempStr.setTo(TMP);
resultStr.setTo("RUR");
if (resultStr != tempStr) {
errcheckln(status, "FAIL: didn't return RUR for eo_AM - %s", u_errorName(status));
}
date = static_cast<UDate>(977616000000.0); // post 1993 - one currency defined
index = ucurr_countCurrencies("eo_AM", date, &status);
if (index != 1)
{
errcheckln(status, "FAIL: didn't return 1 for eo_AM - %s", u_errorName(status));
}
resLen = ucurr_forLocaleAndDate("eo_AM", date, index, TMP, 4, &status);
tempStr.setTo(TMP);
resultStr.setTo("AMD");
if (resultStr != tempStr) {
errcheckln(status, "FAIL: didn't return AMD for eo_AM - %s", u_errorName(status));
}
// Locale AD has multiple currencies at once
date = static_cast<UDate>(977616000000.0); // year 2001
index = ucurr_countCurrencies("eo_AD", date, &status);
if (index != 4)
{
errcheckln(status, "FAIL: didn't return 4 for eo_AD - %s", u_errorName(status));
}
resLen = ucurr_forLocaleAndDate("eo_AD", date, 1, TMP, 4, &status);
tempStr.setTo(TMP);
resultStr.setTo("EUR");
if (resultStr != tempStr) {
errcheckln(status, "FAIL: didn't return EUR for eo_AD - %s", u_errorName(status));
}
resLen = ucurr_forLocaleAndDate("eo_AD", date, 2, TMP, 4, &status);
tempStr.setTo(TMP);
resultStr.setTo("ESP");
if (resultStr != tempStr) {
errcheckln(status, "FAIL: didn't return ESP for eo_AD - %s", u_errorName(status));
}
resLen = ucurr_forLocaleAndDate("eo_AD", date, 3, TMP, 4, &status);
tempStr.setTo(TMP);
resultStr.setTo("FRF");
if (resultStr != tempStr) {
errcheckln(status, "FAIL: didn't return FRF for eo_AD - %s", u_errorName(status));
}
resLen = ucurr_forLocaleAndDate("eo_AD", date, 4, TMP, 4, &status);
tempStr.setTo(TMP);
resultStr.setTo("ADP");
if (resultStr != tempStr) {
errcheckln(status, "FAIL: didn't return ADP for eo_AD - %s", u_errorName(status));
}
date = static_cast<UDate>(0.0); // year 1970
index = ucurr_countCurrencies("eo_AD", date, &status);
if (index != 3)
{
errcheckln(status, "FAIL: didn't return 3 for eo_AD - %s", u_errorName(status));
}
resLen = ucurr_forLocaleAndDate("eo_AD", date, 1, TMP, 4, &status);
tempStr.setTo(TMP);
resultStr.setTo("ESP");
if (resultStr != tempStr) {
errcheckln(status, "FAIL: didn't return ESP for eo_AD - %s", u_errorName(status));
}
resLen = ucurr_forLocaleAndDate("eo_AD", date, 2, TMP, 4, &status);
tempStr.setTo(TMP);
resultStr.setTo("FRF");
if (resultStr != tempStr) {
errcheckln(status, "FAIL: didn't return FRF for eo_AD - %s", u_errorName(status));
}
resLen = ucurr_forLocaleAndDate("eo_AD", date, 3, TMP, 4, &status);
tempStr.setTo(TMP);
resultStr.setTo("ADP");
if (resultStr != tempStr) {
errcheckln(status, "FAIL: didn't return ADP for eo_AD - %s", u_errorName(status));
}
date = static_cast<UDate>(-630720000000.0); // year 1950
index = ucurr_countCurrencies("eo_AD", date, &status);
if (index != 2)
{
errcheckln(status, "FAIL: didn't return 2 for eo_AD - %s", u_errorName(status));
}
resLen = ucurr_forLocaleAndDate("eo_AD", date, 1, TMP, 4, &status);
tempStr.setTo(TMP);
resultStr.setTo("ESP");
if (resultStr != tempStr) {
errcheckln(status, "FAIL: didn't return ESP for eo_AD - %s", u_errorName(status));
}
resLen = ucurr_forLocaleAndDate("eo_AD", date, 2, TMP, 4, &status);
tempStr.setTo(TMP);
resultStr.setTo("ADP");
if (resultStr != tempStr) {
errcheckln(status, "FAIL: didn't return ADP for eo_AD - %s", u_errorName(status));
}
date = static_cast<UDate>(-2207520000000.0); // year 1900
index = ucurr_countCurrencies("eo_AD", date, &status);
if (index != 1)
{
errcheckln(status, "FAIL: didn't return 1 for eo_AD - %s", u_errorName(status));
}
resLen = ucurr_forLocaleAndDate("eo_AD", date, 1, TMP, 4, &status);
tempStr.setTo(TMP);
resultStr.setTo("ESP");
if (resultStr != tempStr) {
errcheckln(status, "FAIL: didn't return ESP for eo_AD - %s", u_errorName(status));
}
// Locale UA has gap between years 1994 - 1996
date = static_cast<UDate>(788400000000.0);
index = ucurr_countCurrencies("eo_UA", date, &status);
if (index != 0)
{
errcheckln(status, "FAIL: didn't return 0 for eo_UA - %s", u_errorName(status));
}
resLen = ucurr_forLocaleAndDate("eo_UA", date, index, TMP, 4, &status);
if (resLen != 0) {
errcheckln(status, "FAIL: eo_UA didn't return nullptr - %s", u_errorName(status));
}
status = U_ZERO_ERROR;
// Test index bounds
resLen = ucurr_forLocaleAndDate("eo_UA", date, 100, TMP, 4, &status);
if (resLen != 0) {
errcheckln(status, "FAIL: eo_UA didn't return nullptr - %s", u_errorName(status));
}
status = U_ZERO_ERROR;
resLen = ucurr_forLocaleAndDate("eo_UA", date, 0, TMP, 4, &status);
if (resLen != 0) {
errcheckln(status, "FAIL: eo_UA didn't return nullptr - %s", u_errorName(status));
}
status = U_ZERO_ERROR;
// Test for bogus locale
index = ucurr_countCurrencies("eo_QQ", date, &status);
if (index != 0)
{
errcheckln(status, "FAIL: didn't return 0 for eo_QQ - %s", u_errorName(status));
}
status = U_ZERO_ERROR;
resLen = ucurr_forLocaleAndDate("eo_QQ", date, 1, TMP, 4, &status);
if (resLen != 0) {
errcheckln(status, "FAIL: eo_QQ didn't return nullptr - %s", u_errorName(status));
}
status = U_ZERO_ERROR;
resLen = ucurr_forLocaleAndDate("eo_QQ", date, 0, TMP, 4, &status);
if (resLen != 0) {
errcheckln(status, "FAIL: eo_QQ didn't return nullptr - %s", u_errorName(status));
}
status = U_ZERO_ERROR;
// Cycle through histrocial currencies
date = static_cast<UDate>(977616000000.0); // 2001 - one currency
index = ucurr_countCurrencies("eo_AO", date, &status);
if (index != 1)
{
errcheckln(status, "FAIL: didn't return 1 for eo_AO - %s", u_errorName(status));
}
resLen = ucurr_forLocaleAndDate("eo_AO", date, 1, TMP, 4, &status);
tempStr.setTo(TMP);
resultStr.setTo("AOA");
if (resultStr != tempStr) {
errcheckln(status, "FAIL: didn't return AOA for eo_AO - %s", u_errorName(status));
}
date = static_cast<UDate>(819936000000.0); // 1996 - 2 currencies
index = ucurr_countCurrencies("eo_AO", date, &status);
if (index != 2)
{
errcheckln(status, "FAIL: didn't return 1 for eo_AO - %s", u_errorName(status));
}
resLen = ucurr_forLocaleAndDate("eo_AO", date, 1, TMP, 4, &status);
tempStr.setTo(TMP);
resultStr.setTo("AOR");
if (resultStr != tempStr) {
errcheckln(status, "FAIL: didn't return AOR for eo_AO - %s", u_errorName(status));
}
resLen = ucurr_forLocaleAndDate("eo_AO", date, 2, TMP, 4, &status);
tempStr.setTo(TMP);
resultStr.setTo("AON");
if (resultStr != tempStr) {
errcheckln(status, "FAIL: didn't return AON for eo_AO - %s", u_errorName(status));
}
date = static_cast<UDate>(662256000000.0); // 1991 - 2 currencies
index = ucurr_countCurrencies("eo_AO", date, &status);
if (index != 2)
{
errcheckln(status, "FAIL: didn't return 1 for eo_AO - %s", u_errorName(status));
}
resLen = ucurr_forLocaleAndDate("eo_AO", date, 1, TMP, 4, &status);
tempStr.setTo(TMP);
resultStr.setTo("AON");
if (resultStr != tempStr) {
errcheckln(status, "FAIL: didn't return AON for eo_AO - %s", u_errorName(status));
}
resLen = ucurr_forLocaleAndDate("eo_AO", date, 2, TMP, 4, &status);
tempStr.setTo(TMP);
resultStr.setTo("AOK");
if (resultStr != tempStr) {
errcheckln(status, "FAIL: didn't return AOK for eo_AO - %s", u_errorName(status));
}
date = static_cast<UDate>(315360000000.0); // 1980 - one currency
index = ucurr_countCurrencies("eo_AO", date, &status);
if (index != 1)
{
errcheckln(status, "FAIL: didn't return 1 for eo_AO - %s", u_errorName(status));
}
resLen = ucurr_forLocaleAndDate("eo_AO", date, 1, TMP, 4, &status);
tempStr.setTo(TMP);
resultStr.setTo("AOK");
if (resultStr != tempStr) {
errcheckln(status, "FAIL: didn't return AOK for eo_AO - %s", u_errorName(status));
}
date = static_cast<UDate>(0.0); // 1970 - no currencies
index = ucurr_countCurrencies("eo_AO", date, &status);
if (index != 0)
{
errcheckln(status, "FAIL: didn't return 1 for eo_AO - %s", u_errorName(status));
}
resLen = ucurr_forLocaleAndDate("eo_AO", date, 1, TMP, 4, &status);
if (resLen != 0) {
errcheckln(status, "FAIL: eo_AO didn't return nullptr - %s", u_errorName(status));
}
status = U_ZERO_ERROR;
// Test with currency keyword override
date = static_cast<UDate>(977616000000.0); // 2001 - two currencies
index = ucurr_countCurrencies("eo_DE@currency=DEM", date, &status);
if (index != 2)
{
errcheckln(status, "FAIL: didn't return 2 for eo_DE@currency=DEM - %s", u_errorName(status));
}
resLen = ucurr_forLocaleAndDate("eo_DE@currency=DEM", date, 1, TMP, 4, &status);
tempStr.setTo(TMP);
resultStr.setTo("EUR");
if (resultStr != tempStr) {
errcheckln(status, "FAIL: didn't return EUR for eo_DE@currency=DEM - %s", u_errorName(status));
}
resLen = ucurr_forLocaleAndDate("eo_DE@currency=DEM", date, 2, TMP, 4, &status);
tempStr.setTo(TMP);
resultStr.setTo("DEM");
if (resultStr != tempStr) {
errcheckln(status, "FAIL: didn't return DEM for eo_DE@currency=DEM - %s", u_errorName(status));
}
// Test Euro Support
status = U_ZERO_ERROR; // reset
date = uprv_getUTCtime();
char16_t USD[4];
ucurr_forLocaleAndDate("en_US", date, 1, USD, 4, &status);
char16_t YEN[4];
ucurr_forLocaleAndDate("ja_JP", date, 1, YEN, 4, &status);
ucurr_forLocaleAndDate("en_US", date, 1, TMP, 4, &status);
if (u_strcmp(USD, TMP) != 0) {
errcheckln(status, "Fail: en_US didn't return USD - %s", u_errorName(status));
}
ucurr_forLocaleAndDate("en_US_Q", date, 1, TMP, 4, &status);
if (u_strcmp(USD, TMP) != 0) {
errcheckln(status, "Fail: en_US_Q didn't fallback to en_US - %s", u_errorName(status));
}
status = U_ZERO_ERROR; // reset
#endif
}
void LocaleTest::TestGetVariantWithKeywords()
{
Locale l("en_US_VALLEY@foo=value");
const char *variant = l.getVariant();
logln(variant);
test_assert(strcmp("VALLEY", variant) == 0);
UErrorCode status = U_ZERO_ERROR;
char buffer[50];
int32_t len = l.getKeywordValue("foo", buffer, 50, status);
buffer[len] = '\0';
test_assert(strcmp("value", buffer) == 0);
}
void LocaleTest::TestIsRightToLeft() {
assertFalse("root LTR", Locale::getRoot().isRightToLeft());
assertFalse("zh LTR", Locale::getChinese().isRightToLeft());
assertTrue("ar RTL", Locale("ar").isRightToLeft());
assertTrue("und-EG RTL", Locale("und-EG").isRightToLeft(), false, true);
assertFalse("fa-Cyrl LTR", Locale("fa-Cyrl").isRightToLeft());
assertTrue("en-Hebr RTL", Locale("en-Hebr").isRightToLeft());
assertTrue("ckb RTL", Locale("ckb").isRightToLeft(), false, true); // Sorani Kurdish
assertFalse("fil LTR", Locale("fil").isRightToLeft());
assertFalse("he-Zyxw LTR", Locale("he-Zyxw").isRightToLeft());
}
void LocaleTest::TestBug11421() {
Locale::getDefault().getBaseName();
int32_t numLocales;
const Locale *localeList = Locale::getAvailableLocales(numLocales);
for (int localeIndex = 0; localeIndex < numLocales; localeIndex++) {
const Locale &loc = localeList[localeIndex];
if (strncmp(loc.getName(), loc.getBaseName(), strlen(loc.getBaseName()))) {
errln("%s:%d loc.getName=\"%s\"; loc.getBaseName=\"%s\"",
__FILE__, __LINE__, loc.getName(), loc.getBaseName());
break;
}
}
}
// TestBug13277. The failure manifests as valgrind errors.
// See the trac ticket for details.
//
void LocaleTest::TestBug13277() {
UErrorCode status = U_ZERO_ERROR;
CharString name("en-us-x-foo", -1, status);
while (name.length() < 152) {
name.append("-x-foo", -1, status);
}
while (name.length() < 160) {
name.append('z', status);
Locale loc(name.data(), nullptr, nullptr, nullptr);
}
}
// TestBug13554 Check for read past end of array in getPosixID().
// The bug shows as an Address Sanitizer failure.
void LocaleTest::TestBug13554() {
UErrorCode status = U_ZERO_ERROR;
const int BUFFER_SIZE = 100;
char posixID[BUFFER_SIZE];
for (uint32_t hostid = 0; hostid < 0x500; ++hostid) {
status = U_ZERO_ERROR;
uprv_convertToPosix(hostid, posixID, BUFFER_SIZE, &status);
}
}
void LocaleTest::TestBug20410() {
IcuTestErrorCode status(*this, "TestBug20410()");
static const char tag1[] = "art-lojban-x-0";
static const Locale expected1("jbo@x=0");
Locale result1 = Locale::forLanguageTag(tag1, status);
status.errIfFailureAndReset("\"%s\"", tag1);
assertEquals(tag1, expected1.getName(), result1.getName());
static const char tag2[] = "zh-xiang-u-nu-thai-x-0";
static const Locale expected2("hsn@numbers=thai;x=0");
Locale result2 = Locale::forLanguageTag(tag2, status);
status.errIfFailureAndReset("\"%s\"", tag2);
assertEquals(tag2, expected2.getName(), result2.getName());
static const char locid3[] = "art__lojban@x=0";
Locale result3 = Locale::createCanonical(locid3);
static const Locale expected3("jbo@x=0");
assertEquals(locid3, expected3.getName(), result3.getName());
static const char locid4[] = "art-lojban-x-0";
Locale result4 = Locale::createCanonical(locid4);
static const Locale expected4("jbo@x=0");
assertEquals(locid4, expected4.getName(), result4.getName());
}
void LocaleTest::TestBug20900() {
static const struct {
const char *localeID; /* input */
const char *canonicalID; /* expected canonicalize() result */
} testCases[] = {
{ "art-lojban", "jbo" },
{ "zh-guoyu", "zh" },
{ "zh-hakka", "hak" },
{ "zh-xiang", "hsn" },
{ "zh-min-nan", "nan" },
{ "zh-gan", "gan" },
{ "zh-wuu", "wuu" },
{ "zh-yue", "yue" },
};
IcuTestErrorCode status(*this, "TestBug20900");
for (int32_t i=0; i < UPRV_LENGTHOF(testCases); i++) {
Locale loc = Locale::createCanonical(testCases[i].localeID);
std::string result = loc.toLanguageTag<std::string>(status);
const char* tag = loc.isBogus() ? "BOGUS" : result.c_str();
status.errIfFailureAndReset("FAIL: createCanonical(%s).toLanguageTag() expected \"%s\"",
testCases[i].localeID, tag);
assertEquals("createCanonical", testCases[i].canonicalID, tag);
}
}
U_DEFINE_LOCAL_OPEN_POINTER(LocalStdioFilePointer, FILE, fclose);
void LocaleTest::TestLocaleCanonicalizationFromFile()
{
IcuTestErrorCode status(*this, "TestLocaleCanonicalizationFromFile");
const char *sourceTestDataPath=getSourceTestData(status);
if(status.errIfFailureAndReset("unable to find the source/test/testdata "
"folder (getSourceTestData())")) {
return;
}
char testPath[400];
char line[256];
strcpy(testPath, sourceTestDataPath);
strcat(testPath, "cldr/localeIdentifiers/localeCanonicalization.txt");
LocalStdioFilePointer testFile(fopen(testPath, "r"));
if(testFile.isNull()) {
errln("unable to open %s", testPath);
return;
}
// Format:
// <source locale identifier> ; <expected canonicalized locale identifier>
while (fgets(line, static_cast<int>(sizeof(line)), testFile.getAlias()) != nullptr) {
if (line[0] == '#') {
// ignore any lines start with #
continue;
}
char *semi = strchr(line, ';');
if (semi == nullptr) {
// ignore any lines without ;
continue;
}
*semi = '\0'; // null terminiate on the spot of semi
const char* from = u_skipWhitespace((const char*)line);
u_rtrim(const_cast<char*>(from));
const char* to = u_skipWhitespace((const char*)semi + 1);
u_rtrim(const_cast<char*>(to));
std::string expect(to);
// Change the _ to -
std::transform(expect.begin(), expect.end(), expect.begin(),
[](unsigned char c){ return c == '_' ? '-' : c; });
Locale loc = Locale::createCanonical(from);
std::string result = loc.toLanguageTag<std::string>(status);
const char* tag = loc.isBogus() ? "BOGUS" : result.c_str();
status.errIfFailureAndReset(
"FAIL: createCanonical(%s).toLanguageTag() expected \"%s\" locale is %s",
from, tag, loc.getName());
std::string msg("createCanonical(");
msg += from;
msg += ") locale = ";
msg += loc.getName();
assertEquals(msg.c_str(), expect.c_str(), tag);
}
}
std::string trim(const std::string &s) {
auto start = s.begin();
while (start != s.end() && std::isspace(*start)) {
start++;
}
auto end = s.end();
do {
end--;
} while (std::distance(start, end) > 0 && std::isspace(*end));
return std::string(start, end + 1);
}
// A testing helper class which favorScript when minimizeSubtags.
class FavorScriptLocale : public Locale {
public:
FavorScriptLocale(const Locale& l) :Locale(l) { }
void minimizeSubtags(UErrorCode& status) {
Locale::minimizeSubtags(true, status);
}
};
void U_CALLCONV
testLikelySubtagsLineFn(void *context,
char *fields[][2], int32_t fieldCount,
UErrorCode *pErrorCode) {
if (U_FAILURE(*pErrorCode)) {
return;
}
(void)fieldCount;
LocaleTest* THIS = static_cast<LocaleTest*>(context);
std::string source(trim(std::string(fields[0][0], fields[0][1]-fields[0][0])));
std::string addLikely(trim(std::string(fields[1][0], fields[1][1]-fields[1][0])));
std::string removeFavorScript(trim(std::string(fields[2][0], fields[2][1]-fields[2][0])));
if (removeFavorScript.length() == 0) {
removeFavorScript = addLikely;
}
std::string removeFavorRegion(trim(std::string(fields[3][0], fields[3][1]-fields[3][0])));
if (removeFavorRegion.length() == 0) {
removeFavorRegion = removeFavorScript;
}
Locale l = Locale::forLanguageTag(source, *pErrorCode);
if (U_FAILURE(*pErrorCode)) {
THIS->errln("forLanguageTag(%s) return error %x %s", source.c_str(),
*pErrorCode, u_errorName(*pErrorCode));
*pErrorCode = U_ZERO_ERROR;
return;
}
Locale actualMax(l);
actualMax.addLikelySubtags(*pErrorCode);
if (addLikely == "FAIL") {
if (uprv_strcmp(l.getName(), actualMax.getName()) != 0) {
THIS->errln("addLikelySubtags('%s') return should return the same but return '%s'",
l.getName(), actualMax.getName());
}
} else {
std::string max = actualMax.toLanguageTag<std::string>(*pErrorCode);
if (U_FAILURE(*pErrorCode)) {
THIS->errln("toLanguageTag(%s) return error %x %s", actualMax.getName(),
*pErrorCode, u_errorName(*pErrorCode));
*pErrorCode = U_ZERO_ERROR;
} else {
if (max != addLikely) {
THIS->errln("addLikelySubtags('%s') should return '%s' but got '%s'",
source.c_str(), addLikely.c_str(), max.c_str());
}
}
}
Locale actualMin(l);
actualMin.minimizeSubtags(*pErrorCode);
if (removeFavorRegion == "FAIL") {
if (uprv_strcmp(l.getName(), actualMin.getName()) != 0) {
THIS->errln("minimizeSubtags('%s') return should return the same but return '%s'",
l.getName(), actualMin.getName());
}
} else {
std::string min = actualMin.toLanguageTag<std::string>(*pErrorCode);
if (U_FAILURE(*pErrorCode)) {
THIS->errln("toLanguageTag(%s) return error %x %s", actualMin.getName(),
*pErrorCode, u_errorName(*pErrorCode));
*pErrorCode = U_ZERO_ERROR;
} else {
if (min != removeFavorRegion) {
THIS->errln("minimizeSubtags('%s') should return '%s' but got '%s'",
source.c_str(), removeFavorRegion.c_str(), min.c_str());
}
}
}
FavorScriptLocale actualMinFavorScript(l);
actualMinFavorScript.minimizeSubtags(*pErrorCode);
if (removeFavorScript == "FAIL") {
if (uprv_strcmp(l.getName(), actualMinFavorScript.getName()) != 0) {
THIS->errln("minimizeSubtags('%s') return should return the same but return '%s'",
l.getName(), actualMinFavorScript.getName());
}
} else {
std::string min = actualMinFavorScript.toLanguageTag<std::string>(*pErrorCode);
if (U_FAILURE(*pErrorCode)) {
THIS->errln("toLanguageTag(%s) favor script return error %x %s", actualMinFavorScript.getName(),
*pErrorCode, u_errorName(*pErrorCode));
*pErrorCode = U_ZERO_ERROR;
} else {
if (min != removeFavorScript) {
THIS->errln("minimizeSubtags('%s') favor script should return '%s' but got '%s'",
source.c_str(), removeFavorScript.c_str(), min.c_str());
}
}
}
}
void
LocaleTest::TestDataDrivenLikelySubtags() {
if (quick) {
// This test is too slow to run. Only run in -e mode.
return;
}
IcuTestErrorCode errorCode(*this, "TestDataDrivenLikelySubtags()");
const char* name = "cldr/localeIdentifiers/likelySubtags.txt";
const char *sourceTestDataPath = getSourceTestData(errorCode);
if (errorCode.errIfFailureAndReset("unable to find the source/test/testdata "
"folder (getSourceTestData())")) {
return;
}
CharString path(sourceTestDataPath, errorCode);
path.appendPathPart(name, errorCode);
LocalStdioFilePointer testFile(fopen(path.data(), "r"));
if (testFile.isNull()) {
errln("unable to open %s", path.data());
return;
}
// Columns (c1, c2,...) are separated by semicolons.
// Leading and trailing spaces and tabs in each column are ignored.
// Comments are indicated with hash marks.
const int32_t kNumFields = 4;
char *fields[kNumFields][2];
u_parseDelimitedFile(path.data(), ';', fields, kNumFields, testLikelySubtagsLineFn,
this, errorCode);
if (errorCode.errIfFailureAndReset("error parsing %s", name)) {
return;
}
}
void LocaleTest::TestKnownCanonicalizedListCorrect()
{
IcuTestErrorCode status(*this, "TestKnownCanonicalizedListCorrect");
int32_t numOfKnownCanonicalized;
const char* const* knownCanonicalized =
ulocimp_getKnownCanonicalizedLocaleForTest(numOfKnownCanonicalized);
for (int32_t i = 0; i < numOfKnownCanonicalized; i++) {
std::string msg("Known Canonicalized Locale is not canonicalized: ");
assertTrue((msg + knownCanonicalized[i]).c_str(),
ulocimp_isCanonicalizedLocaleForTest(knownCanonicalized[i]));
}
}
void LocaleTest::TestConstructorAcceptsBCP47() {
IcuTestErrorCode status(*this, "TestConstructorAcceptsBCP47");
Locale loc1("ar-EG-u-nu-latn");
Locale loc2("ar-EG@numbers=latn");
Locale loc3("ar-EG");
std::string val;
// Check getKeywordValue "numbers"
val = loc1.getKeywordValue<std::string>("numbers", status);
assertEquals("BCP47 syntax has ICU keyword value", "latn", val.c_str());
val = loc2.getKeywordValue<std::string>("numbers", status);
assertEquals("ICU syntax has ICU keyword value", "latn", val.c_str());
val = loc3.getKeywordValue<std::string>("numbers", status);
assertEquals("Default, ICU keyword", "", val.c_str());
// Check getUnicodeKeywordValue "nu"
val = loc1.getUnicodeKeywordValue<std::string>("nu", status);
assertEquals("BCP47 syntax has short unicode keyword value", "latn", val.c_str());
val = loc2.getUnicodeKeywordValue<std::string>("nu", status);
assertEquals("ICU syntax has short unicode keyword value", "latn", val.c_str());
val = loc3.getUnicodeKeywordValue<std::string>("nu", status);
status.expectErrorAndReset(U_ILLEGAL_ARGUMENT_ERROR, "Default, short unicode keyword");
// Check getUnicodeKeywordValue "numbers"
val = loc1.getUnicodeKeywordValue<std::string>("numbers", status);
assertEquals("BCP47 syntax has long unicode keyword value", "latn", val.c_str());
val = loc2.getUnicodeKeywordValue<std::string>("numbers", status);
assertEquals("ICU syntax has long unicode keyword value", "latn", val.c_str());
val = loc3.getUnicodeKeywordValue<std::string>("numbers", status);
status.expectErrorAndReset(U_ILLEGAL_ARGUMENT_ERROR, "Default, long unicode keyword");
}
void LocaleTest::TestForLanguageTag() {
IcuTestErrorCode status(*this, "TestForLanguageTag()");
static const char tag_en[] = "en-US";
static const char tag_oed[] = "en-GB-oed";
static const char tag_af[] = "af-t-ar-i0-handwrit-u-ca-coptic-x-foo";
static const char tag_ill[] = "!";
static const char tag_no_nul[] = { 'e', 'n', '-', 'G', 'B' };
static const char tag_ext[] = "en-GB-1-abc-efg-a-xyz";
static const char tag_var[] = "sl-rozaj-biske-1994";
static const Locale loc_en("en_US");
static const Locale loc_oed("en_GB_OXENDICT");
static const Locale loc_af("af@calendar=coptic;t=ar-i0-handwrit;x=foo");
static const Locale loc_null("");
static const Locale loc_gb("en_GB");
static const Locale loc_ext("en_GB@1=abc-efg;a=xyz");
static const Locale loc_var("sl__1994_BISKE_ROZAJ");
Locale result_en = Locale::forLanguageTag(tag_en, status);
status.errIfFailureAndReset("\"%s\"", tag_en);
assertEquals(tag_en, loc_en.getName(), result_en.getName());
Locale result_oed = Locale::forLanguageTag(tag_oed, status);
status.errIfFailureAndReset("\"%s\"", tag_oed);
assertEquals(tag_oed, loc_oed.getName(), result_oed.getName());
Locale result_af = Locale::forLanguageTag(tag_af, status);
status.errIfFailureAndReset("\"%s\"", tag_af);
assertEquals(tag_af, loc_af.getName(), result_af.getName());
Locale result_var = Locale::forLanguageTag(tag_var, status);
status.errIfFailureAndReset("\"%s\"", tag_var);
assertEquals(tag_var, loc_var.getName(), result_var.getName());
Locale result_ill = Locale::forLanguageTag(tag_ill, status);
assertEquals(tag_ill, U_ILLEGAL_ARGUMENT_ERROR, status.reset());
assertTrue(result_ill.getName(), result_ill.isBogus());
Locale result_null = Locale::forLanguageTag(nullptr, status);
status.errIfFailureAndReset("nullptr");
assertEquals("nullptr", loc_null.getName(), result_null.getName());
StringPiece sp_substr(tag_oed, 5); // "en-GB", no NUL.
Locale result_substr = Locale::forLanguageTag(sp_substr, status);
status.errIfFailureAndReset("\"%.*s\"", sp_substr.size(), sp_substr.data());
assertEquals(CharString(sp_substr, status).data(),
loc_gb.getName(), result_substr.getName());
StringPiece sp_no_nul(tag_no_nul, sizeof tag_no_nul); // "en-GB", no NUL.
Locale result_no_nul = Locale::forLanguageTag(sp_no_nul, status);
status.errIfFailureAndReset("\"%.*s\"", sp_no_nul.size(), sp_no_nul.data());
assertEquals(CharString(sp_no_nul, status).data(),
loc_gb.getName(), result_no_nul.getName());
Locale result_ext = Locale::forLanguageTag(tag_ext, status);
status.errIfFailureAndReset("\"%s\"", tag_ext);
assertEquals(tag_ext, loc_ext.getName(), result_ext.getName());
static const struct {
const char *inputTag; /* input */
const char *expectedID; /* expected forLanguageTag().getName() result */
} testCases[] = {
// ICU-21433
{"und-1994-biske-rozaj", "__1994_BISKE_ROZAJ"},
{"de-1994-biske-rozaj", "de__1994_BISKE_ROZAJ"},
{"und-x-private", "@x=private"},
{"de-1994-biske-rozaj-x-private", "de__1994_BISKE_ROZAJ@x=private"},
{"und-1994-biske-rozaj-x-private", "__1994_BISKE_ROZAJ@x=private"},
};
int32_t i;
for (i=0; i < UPRV_LENGTHOF(testCases); i++) {
UErrorCode status = U_ZERO_ERROR;
std::string otag = testCases[i].inputTag;
std::string tag = Locale::forLanguageTag(otag.c_str(), status).getName();
if (tag != testCases[i].expectedID) {
errcheckln(status, "FAIL: %s should be toLanguageTag to %s but got %s - %s",
otag.c_str(),
testCases[i].expectedID,
tag.c_str(),
u_errorName(status));
}
}
}
void LocaleTest::TestForLanguageTagLegacyTagBug21676() {
IcuTestErrorCode status(*this, "TestForLanguageTagLegacyTagBug21676()");
std::string tag(
"i-enochian-1nochian-129-515VNTR-64863775-X3il6-110Y101-29-515VNTR-"
"64863775-153zu-u-Y4-H0-t6-X3-u6-110Y101-X");
std::string input(tag);
input += "EXTRA MEMORY AFTER NON-nullptr TERMINATED STRING";
StringPiece stringp(input.c_str(), tag.length());
std::string name = Locale::forLanguageTag(stringp, status).getName();
std::string expected(
"@x=i-enochian-1nochian-129-515vntr-64863775-x3il6-110y101-29-515vntr-"
"64863775-153zu-u-y4-h0-t6-x3-u6-110y101-x");
if (name != expected) {
errcheckln(
status,
"FAIL: forLanguageTag('%s', \n%d).getName() should be \n'%s' but got %s",
tag.c_str(), tag.length(), expected.c_str(), name.c_str());
}
}
void LocaleTest::TestToLanguageTag() {
IcuTestErrorCode status(*this, "TestToLanguageTag()");
static const Locale loc_c("en_US_POSIX");
static const Locale loc_en("en_US");
static const Locale loc_af("af@calendar=coptic;t=ar-i0-handwrit;x=foo");
static const Locale loc_ext("en@0=abc;a=xyz");
static const Locale loc_empty("");
static const Locale loc_ill("!");
static const Locale loc_variant("sl__ROZAJ_BISKE_1994");
static const char tag_c[] = "en-US-u-va-posix";
static const char tag_en[] = "en-US";
static const char tag_af[] = "af-t-ar-i0-handwrit-u-ca-coptic-x-foo";
static const char tag_ext[] = "en-0-abc-a-xyz";
static const char tag_und[] = "und";
static const char tag_variant[] = "sl-1994-biske-rozaj";
std::string result;
StringByteSink<std::string> sink(&result);
loc_c.toLanguageTag(sink, status);
status.errIfFailureAndReset("\"%s\"", loc_c.getName());
assertEquals(loc_c.getName(), tag_c, result.c_str());
std::string result_c = loc_c.toLanguageTag<std::string>(status);
status.errIfFailureAndReset("\"%s\"", loc_c.getName());
assertEquals(loc_c.getName(), tag_c, result_c.c_str());
std::string result_en = loc_en.toLanguageTag<std::string>(status);
status.errIfFailureAndReset("\"%s\"", loc_en.getName());
assertEquals(loc_en.getName(), tag_en, result_en.c_str());
std::string result_af = loc_af.toLanguageTag<std::string>(status);
status.errIfFailureAndReset("\"%s\"", loc_af.getName());
assertEquals(loc_af.getName(), tag_af, result_af.c_str());
std::string result_ext = loc_ext.toLanguageTag<std::string>(status);
status.errIfFailureAndReset("\"%s\"", loc_ext.getName());
assertEquals(loc_ext.getName(), tag_ext, result_ext.c_str());
std::string result_empty = loc_empty.toLanguageTag<std::string>(status);
status.errIfFailureAndReset("\"%s\"", loc_empty.getName());
assertEquals(loc_empty.getName(), tag_und, result_empty.c_str());
std::string result_ill = loc_ill.toLanguageTag<std::string>(status);
status.errIfFailureAndReset("\"%s\"", loc_ill.getName());
assertEquals(loc_ill.getName(), tag_und, result_ill.c_str());
std::string result_variant = loc_variant.toLanguageTag<std::string>(status);
status.errIfFailureAndReset("\"%s\"", loc_variant.getName());
assertEquals(loc_variant.getName(), tag_variant, result_variant.c_str());
Locale loc_bogus;
loc_bogus.setToBogus();
std::string result_bogus = loc_bogus.toLanguageTag<std::string>(status);
assertEquals("bogus", U_ILLEGAL_ARGUMENT_ERROR, status.reset());
assertTrue(result_bogus.c_str(), result_bogus.empty());
static const struct {
const char *localeID; /* input */
const char *expectedID; /* expected toLanguageTag() result */
} testCases[] = {
/* ICU-21414 */
{"und-x-abc-private", "und-x-abc-private"},
{"und-x-private", "und-x-private"},
{"und-u-ca-roc-x-private", "und-u-ca-roc-x-private"},
{"und-US-x-private", "und-US-x-private"},
{"und-Latn-x-private", "und-Latn-x-private"},
{"und-1994-biske-rozaj", "und-1994-biske-rozaj"},
{"und-1994-biske-rozaj-x-private", "und-1994-biske-rozaj-x-private"},
// ICU-22497
{"-ins0-ins17Rz-yqyq-UWLF-uRyq-UWLF-uRRyq-UWLF-uR-UWLF-uRns0-ins17Rz-yq-UWLF-uRyq-UWLF-uRRyq-LF-uRyq-UWLF-uRRyq-UWLF-uRq-UWLF-uRyq-UWLF-uRRyq-UWLF-uR", ""},
// ICU-22504
{"@attribute=zzo9zzzzzzzs0zzzzzzzzzz55555555555555555555500000000000000000000fffffffffffffffffffffffffzzzzz2mfPAK", ""},
};
int32_t i;
for (i=0; i < UPRV_LENGTHOF(testCases); i++) {
UErrorCode status = U_ZERO_ERROR;
std::string otag = testCases[i].localeID;
std::string tag = Locale::forLanguageTag(otag.c_str(), status).toLanguageTag<std::string>(status);
if (tag != testCases[i].expectedID) {
errcheckln(status, "FAIL: %s should be toLanguageTag to %s but got %s - %s",
otag.c_str(),
testCases[i].expectedID,
tag.c_str(),
u_errorName(status));
}
// Test ICU-22497
status = U_ZERO_ERROR;
icu::Locale locale(otag.c_str());
char buf[245];
icu::CheckedArrayByteSink sink(buf, sizeof(buf));
locale.toLanguageTag(sink, status);
}
}
/* ICU-20310 */
void LocaleTest::TestToLanguageTagOmitTrue() {
IcuTestErrorCode status(*this, "TestToLanguageTagOmitTrue()");
assertEquals("en-u-kn should drop true",
"en-u-kn", Locale("en-u-kn-true").toLanguageTag<std::string>(status).c_str());
status.errIfFailureAndReset();
assertEquals("en-u-kn should drop true",
"en-u-kn", Locale("en-u-kn").toLanguageTag<std::string>(status).c_str());
status.errIfFailureAndReset();
assertEquals("de-u-co should drop true",
"de-u-co", Locale("de-u-co").toLanguageTag<std::string>(status).c_str());
status.errIfFailureAndReset();
assertEquals("de-u-co should drop true",
"de-u-co", Locale("de-u-co-yes").toLanguageTag<std::string>(status).c_str());
status.errIfFailureAndReset();
assertEquals("de@collation=yes should drop true",
"de-u-co", Locale("de@collation=yes").toLanguageTag<std::string>(status).c_str());
status.errIfFailureAndReset();
assertEquals("cmn-Hans-CN-t-ca-u-ca-x-t-u should drop true",
"cmn-Hans-CN-t-ca-u-ca-x-t-u",
Locale("cmn-hans-cn-u-ca-t-ca-x-t-u").toLanguageTag<std::string>(status).c_str());
status.errIfFailureAndReset();
}
void LocaleTest::TestMoveAssign() {
// ULOC_FULLNAME_CAPACITY == 157 (uloc.h)
Locale l1("de@collation=phonebook;x="
"aaaaabbbbbcccccdddddeeeeefffffggggghhhhh"
"aaaaabbbbbcccccdddddeeeeefffffggggghhhhh"
"aaaaabbbbbcccccdddddeeeeefffffggggghhhhh"
"aaaaabbbbbzz");
Locale l2;
{
Locale l3(l1);
assertTrue("l1 == l3", l1 == l3);
l2 = std::move(l3);
assertTrue("l1 == l2", l1 == l2);
assertTrue("l2 != l3", l2.getName() != l3.getName());
}
// This should remain true also after l3 has been destructed.
assertTrue("l1 == l2, again", l1 == l2);
Locale l4("de@collation=phonebook");
Locale l5;
{
Locale l6(l4);
assertTrue("l4 == l6", l4 == l6);
l5 = std::move(l6);
assertTrue("l4 == l5", l4 == l5);
assertTrue("l5 != l6", l5.getName() != l6.getName());
}
// This should remain true also after l6 has been destructed.
assertTrue("l4 == l5, again", l4 == l5);
Locale l7("vo_Cyrl_AQ_EURO");
Locale l8;
{
Locale l9(l7);
assertTrue("l7 == l9", l7 == l9);
l8 = std::move(l9);
assertTrue("l7 == l8", l7 == l8);
assertTrue("l8 != l9", l8.getName() != l9.getName());
}
// This should remain true also after l9 has been destructed.
assertTrue("l7 == l8, again", l7 == l8);
assertEquals("language", l7.getLanguage(), l8.getLanguage());
assertEquals("script", l7.getScript(), l8.getScript());
assertEquals("country", l7.getCountry(), l8.getCountry());
assertEquals("variant", l7.getVariant(), l8.getVariant());
assertEquals("bogus", l7.isBogus(), l8.isBogus());
}
void LocaleTest::TestMoveCtor() {
// ULOC_FULLNAME_CAPACITY == 157 (uloc.h)
Locale l1("de@collation=phonebook;x="
"aaaaabbbbbcccccdddddeeeeefffffggggghhhhh"
"aaaaabbbbbcccccdddddeeeeefffffggggghhhhh"
"aaaaabbbbbcccccdddddeeeeefffffggggghhhhh"
"aaaaabbbbbzz");
Locale l3(l1);
assertTrue("l1 == l3", l1 == l3);
Locale l2(std::move(l3));
assertTrue("l1 == l2", l1 == l2);
assertTrue("l2 != l3", l2.getName() != l3.getName());
Locale l4("de@collation=phonebook");
Locale l6(l4);
assertTrue("l4 == l6", l4 == l6);
Locale l5(std::move(l6));
assertTrue("l4 == l5", l4 == l5);
assertTrue("l5 != l6", l5.getName() != l6.getName());
Locale l7("vo_Cyrl_AQ_EURO");
Locale l9(l7);
assertTrue("l7 == l9", l7 == l9);
Locale l8(std::move(l9));
assertTrue("l7 == l8", l7 == l8);
assertTrue("l8 != l9", l8.getName() != l9.getName());
assertEquals("language", l7.getLanguage(), l8.getLanguage());
assertEquals("script", l7.getScript(), l8.getScript());
assertEquals("country", l7.getCountry(), l8.getCountry());
assertEquals("variant", l7.getVariant(), l8.getVariant());
assertEquals("bogus", l7.isBogus(), l8.isBogus());
}
void LocaleTest::TestBug20407iVariantPreferredValue() {
IcuTestErrorCode status(*this, "TestBug20407iVariantPreferredValue()");
Locale l = Locale::forLanguageTag("hy-arevela", status);
status.errIfFailureAndReset("hy-arevela fail");
assertTrue("!l.isBogus()", !l.isBogus());
std::string result = l.toLanguageTag<std::string>(status);
assertEquals(l.getName(), "hy", result.c_str());
l = Locale::forLanguageTag("hy-arevmda", status);
status.errIfFailureAndReset("hy-arevmda");
assertTrue("!l.isBogus()", !l.isBogus());
result = l.toLanguageTag<std::string>(status);
assertEquals(l.getName(), "hyw", result.c_str());
}
void LocaleTest::TestBug13417VeryLongLanguageTag() {
IcuTestErrorCode status(*this, "TestBug13417VeryLongLanguageTag()");
static const char tag[] =
"zh-x"
"-foo-bar-baz-foo-bar-baz-foo-bar-baz-foo-bar-baz"
"-foo-bar-baz-foo-bar-baz-foo-bar-baz-foo-bar-baz"
"-foo-bar-baz-foo-bar-baz-foo-bar-baz-foo-bar-baz"
"-foo-bar-baz-fxx"
;
Locale l = Locale::forLanguageTag(tag, status);
status.errIfFailureAndReset("\"%s\"", tag);
assertTrue("!l.isBogus()", !l.isBogus());
std::string result = l.toLanguageTag<std::string>(status);
status.errIfFailureAndReset("\"%s\"", l.getName());
assertEquals("equals", tag, result.c_str());
}
void LocaleTest::TestBug11053UnderlineTimeZone() {
static const char* const tz_in_ext[] = {
"etadd",
"tzdar",
"eheai",
"sttms",
"arirj",
"arrgl",
"aruaq",
"arluq",
"mxpvr",
"brbvb",
"arbue",
"caycb",
"brcgr",
"cayzs",
"crsjo",
"caydq",
"svsal",
"cafne",
"caglb",
"cagoo",
"tcgdt",
"ustel",
"bolpb",
"uslax",
"sxphi",
"mxmex",
"usnyc",
"usxul",
"usndcnt",
"usndnsl",
"ttpos",
"brpvh",
"prsju",
"clpuq",
"caffs",
"cayek",
"brrbr",
"mxstis",
"dosdq",
"brsao",
"gpsbh",
"casjf",
"knbas",
"lccas",
"vistt",
"vcsvd",
"cayyn",
"cathu",
"hkhkg",
"mykul",
"khpnh",
"cvrai",
"gsgrv",
"shshn",
"aubhq",
"auldh",
"imdgs",
"smsai",
"asppg",
"pgpom",
};
static const char* const tzname_with_underline[] = {
"America/Buenos_Aires",
"America/Coral_Harbour",
"America/Los_Angeles",
"America/Mexico_City",
"America/New_York",
"America/Rio_Branco",
"America/Sao_Paulo",
"America/St_Johns",
"America/St_Thomas",
"Australia/Broken_Hill",
"Australia/Lord_Howe",
"Pacific/Pago_Pago",
};
std::string locale_str;
for (int32_t i = 0; i < UPRV_LENGTHOF(tz_in_ext); i++) {
locale_str = "en-u-tz-";
locale_str += tz_in_ext[i];
Locale l(locale_str.c_str());
assertTrue((locale_str + " !l.isBogus()").c_str(), !l.isBogus());
}
for (int32_t i = 0; i < UPRV_LENGTHOF(tzname_with_underline); i++) {
locale_str = "en@timezone=";
locale_str += tzname_with_underline[i];
Locale l(locale_str.c_str());
assertTrue((locale_str + " !l.isBogus()").c_str(), !l.isBogus());
}
locale_str = "en_US@timezone=America/Coral_Harbour";
Locale l2(locale_str.c_str());
assertTrue((locale_str + " !l2.isBogus()").c_str(), !l2.isBogus());
locale_str = "en_Latn@timezone=America/New_York";
Locale l3(locale_str.c_str());
assertTrue((locale_str + " !l3.isBogus()").c_str(), !l3.isBogus());
locale_str = "en_Latn_US@timezone=Australia/Broken_Hill";
Locale l4(locale_str.c_str());
assertTrue((locale_str + " !l4.isBogus()").c_str(), !l4.isBogus());
locale_str = "en-u-tz-ciabj";
Locale l5(locale_str.c_str());
assertTrue((locale_str + " !l5.isBogus()").c_str(), !l5.isBogus());
locale_str = "en-US-u-tz-asppg";
Locale l6(locale_str.c_str());
assertTrue((locale_str + " !l6.isBogus()").c_str(), !l6.isBogus());
locale_str = "fil-Latn-u-tz-cvrai";
Locale l7(locale_str.c_str());
assertTrue((locale_str + " !l7.isBogus()").c_str(), !l7.isBogus());
locale_str = "fil-Latn-PH-u-tz-gsgrv";
Locale l8(locale_str.c_str());
assertTrue((locale_str + " !l8.isBogus()").c_str(), !l8.isBogus());
}
void LocaleTest::TestUnd() {
IcuTestErrorCode status(*this, "TestUnd()");
static const char empty[] = "";
static const char root[] = "root";
static const char und[] = "und";
Locale empty_ctor(empty);
Locale empty_tag = Locale::forLanguageTag(empty, status);
status.errIfFailureAndReset("\"%s\"", empty);
Locale root_ctor(root);
Locale root_tag = Locale::forLanguageTag(root, status);
Locale root_build = LocaleBuilder().setLanguageTag(root).build(status);
status.errIfFailureAndReset("\"%s\"", root);
Locale und_ctor(und);
Locale und_tag = Locale::forLanguageTag(und, status);
Locale und_build = LocaleBuilder().setLanguageTag(und).build(status);
status.errIfFailureAndReset("\"%s\"", und);
assertEquals("getName()", empty, empty_ctor.getName());
assertEquals("getName()", empty, root_ctor.getName());
assertEquals("getName()", empty, und_ctor.getName());
assertEquals("getName()", empty, empty_tag.getName());
assertEquals("getName()", empty, root_tag.getName());
assertEquals("getName()", empty, und_tag.getName());
assertEquals("getName()", empty, root_build.getName());
assertEquals("getName()", empty, und_build.getName());
assertEquals("toLanguageTag()", und, empty_ctor.toLanguageTag<std::string>(status).c_str());
assertEquals("toLanguageTag()", und, root_ctor.toLanguageTag<std::string>(status).c_str());
assertEquals("toLanguageTag()", und, und_ctor.toLanguageTag<std::string>(status).c_str());
status.errIfFailureAndReset();
assertEquals("toLanguageTag()", und, empty_tag.toLanguageTag<std::string>(status).c_str());
assertEquals("toLanguageTag()", und, root_tag.toLanguageTag<std::string>(status).c_str());
assertEquals("toLanguageTag()", und, und_tag.toLanguageTag<std::string>(status).c_str());
status.errIfFailureAndReset();
assertEquals("toLanguageTag()", und, root_build.toLanguageTag<std::string>(status).c_str());
assertEquals("toLanguageTag()", und, und_build.toLanguageTag<std::string>(status).c_str());
status.errIfFailureAndReset();
assertTrue("empty_ctor == empty_tag", empty_ctor == empty_tag);
assertTrue("root_ctor == root_tag", root_ctor == root_tag);
assertTrue("root_ctor == root_build", root_ctor == root_build);
assertTrue("root_tag == root_build", root_tag == root_build);
assertTrue("und_ctor == und_tag", und_ctor == und_tag);
assertTrue("und_ctor == und_build", und_ctor == und_build);
assertTrue("und_tag == und_build", und_tag == und_build);
assertTrue("empty_ctor == root_ctor", empty_ctor == root_ctor);
assertTrue("empty_ctor == und_ctor", empty_ctor == und_ctor);
assertTrue("root_ctor == und_ctor", root_ctor == und_ctor);
assertTrue("empty_tag == root_tag", empty_tag == root_tag);
assertTrue("empty_tag == und_tag", empty_tag == und_tag);
assertTrue("root_tag == und_tag", root_tag == und_tag);
assertTrue("root_build == und_build", root_build == und_build);
static const Locale& displayLocale = Locale::getEnglish();
static const UnicodeString displayName("Unknown language");
UnicodeString tmp;
assertEquals("getDisplayName()", displayName, empty_ctor.getDisplayName(displayLocale, tmp));
assertEquals("getDisplayName()", displayName, root_ctor.getDisplayName(displayLocale, tmp));
assertEquals("getDisplayName()", displayName, und_ctor.getDisplayName(displayLocale, tmp));
assertEquals("getDisplayName()", displayName, empty_tag.getDisplayName(displayLocale, tmp));
assertEquals("getDisplayName()", displayName, root_tag.getDisplayName(displayLocale, tmp));
assertEquals("getDisplayName()", displayName, und_tag.getDisplayName(displayLocale, tmp));
assertEquals("getDisplayName()", displayName, root_build.getDisplayName(displayLocale, tmp));
assertEquals("getDisplayName()", displayName, und_build.getDisplayName(displayLocale, tmp));
}
void LocaleTest::TestUndScript() {
IcuTestErrorCode status(*this, "TestUndScript()");
static const char id[] = "_Cyrl";
static const char tag[] = "und-Cyrl";
static const char script[] = "Cyrl";
Locale locale_ctor(id);
Locale locale_legacy(tag);
Locale locale_tag = Locale::forLanguageTag(tag, status);
Locale locale_build = LocaleBuilder().setScript(script).build(status);
status.errIfFailureAndReset("\"%s\"", tag);
assertEquals("getName()", id, locale_ctor.getName());
assertEquals("getName()", id, locale_legacy.getName());
assertEquals("getName()", id, locale_tag.getName());
assertEquals("getName()", id, locale_build.getName());
assertEquals("toLanguageTag()", tag, locale_ctor.toLanguageTag<std::string>(status).c_str());
assertEquals("toLanguageTag()", tag, locale_legacy.toLanguageTag<std::string>(status).c_str());
assertEquals("toLanguageTag()", tag, locale_tag.toLanguageTag<std::string>(status).c_str());
assertEquals("toLanguageTag()", tag, locale_build.toLanguageTag<std::string>(status).c_str());
status.errIfFailureAndReset();
static const Locale& displayLocale = Locale::getEnglish();
static const UnicodeString displayName("Unknown language (Cyrillic)");
UnicodeString tmp;
assertEquals("getDisplayName()", displayName, locale_ctor.getDisplayName(displayLocale, tmp));
assertEquals("getDisplayName()", displayName, locale_legacy.getDisplayName(displayLocale, tmp));
assertEquals("getDisplayName()", displayName, locale_tag.getDisplayName(displayLocale, tmp));
assertEquals("getDisplayName()", displayName, locale_build.getDisplayName(displayLocale, tmp));
}
void LocaleTest::TestUndRegion() {
IcuTestErrorCode status(*this, "TestUndRegion()");
static const char id[] = "_AQ";
static const char tag[] = "und-AQ";
static const char region[] = "AQ";
Locale locale_ctor(id);
Locale locale_legacy(tag);
Locale locale_tag = Locale::forLanguageTag(tag, status);
Locale locale_build = LocaleBuilder().setRegion(region).build(status);
status.errIfFailureAndReset("\"%s\"", tag);
assertEquals("getName()", id, locale_ctor.getName());
assertEquals("getName()", id, locale_legacy.getName());
assertEquals("getName()", id, locale_tag.getName());
assertEquals("getName()", id, locale_build.getName());
assertEquals("toLanguageTag()", tag, locale_ctor.toLanguageTag<std::string>(status).c_str());
assertEquals("toLanguageTag()", tag, locale_legacy.toLanguageTag<std::string>(status).c_str());
assertEquals("toLanguageTag()", tag, locale_tag.toLanguageTag<std::string>(status).c_str());
assertEquals("toLanguageTag()", tag, locale_build.toLanguageTag<std::string>(status).c_str());
status.errIfFailureAndReset();
static const Locale& displayLocale = Locale::getEnglish();
static const UnicodeString displayName("Unknown language (Antarctica)");
UnicodeString tmp;
assertEquals("getDisplayName()", displayName, locale_ctor.getDisplayName(displayLocale, tmp));
assertEquals("getDisplayName()", displayName, locale_legacy.getDisplayName(displayLocale, tmp));
assertEquals("getDisplayName()", displayName, locale_tag.getDisplayName(displayLocale, tmp));
assertEquals("getDisplayName()", displayName, locale_build.getDisplayName(displayLocale, tmp));
}
void LocaleTest::TestUndCAPI() {
IcuTestErrorCode status(*this, "TestUndCAPI()");
static const char empty[] = "";
static const char root[] = "root";
static const char und[] = "und";
static const char empty_script[] = "_Cyrl";
static const char empty_region[] = "_AQ";
static const char und_script[] = "und_Cyrl";
static const char und_region[] = "und_AQ";
char tmp[ULOC_FULLNAME_CAPACITY];
int32_t reslen;
// uloc_getName()
uprv_memset(tmp, '!', sizeof tmp);
reslen = uloc_getName(empty, tmp, sizeof tmp, status);
status.errIfFailureAndReset("\"%s\"", empty);
assertTrue("reslen >= 0", reslen >= 0);
assertEquals("uloc_getName()", empty, tmp);
uprv_memset(tmp, '!', sizeof tmp);
reslen = uloc_getName(root, tmp, sizeof tmp, status);
status.errIfFailureAndReset("\"%s\"", root);
assertTrue("reslen >= 0", reslen >= 0);
assertEquals("uloc_getName()", empty, tmp);
uprv_memset(tmp, '!', sizeof tmp);
reslen = uloc_getName(und, tmp, sizeof tmp, status);
status.errIfFailureAndReset("\"%s\"", und);
assertTrue("reslen >= 0", reslen >= 0);
assertEquals("uloc_getName()", empty, tmp);
uprv_memset(tmp, '!', sizeof tmp);
reslen = uloc_getName(empty_script, tmp, sizeof tmp, status);
status.errIfFailureAndReset("\"%s\"", empty_script);
assertTrue("reslen >= 0", reslen >= 0);
assertEquals("uloc_getName()", empty_script, tmp);
uprv_memset(tmp, '!', sizeof tmp);
reslen = uloc_getName(empty_region, tmp, sizeof tmp, status);
status.errIfFailureAndReset("\"%s\"", empty_region);
assertTrue("reslen >= 0", reslen >= 0);
assertEquals("uloc_getName()", empty_region, tmp);
uprv_memset(tmp, '!', sizeof tmp);
reslen = uloc_getName(und_script, tmp, sizeof tmp, status);
status.errIfFailureAndReset("\"%s\"", und_script);
assertTrue("reslen >= 0", reslen >= 0);
assertEquals("uloc_getName()", empty_script, tmp);
uprv_memset(tmp, '!', sizeof tmp);
reslen = uloc_getName(und_region, tmp, sizeof tmp, status);
status.errIfFailureAndReset("\"%s\"", und_region);
assertTrue("reslen >= 0", reslen >= 0);
assertEquals("uloc_getName()", empty_region, tmp);
// uloc_getBaseName()
uprv_memset(tmp, '!', sizeof tmp);
reslen = uloc_getBaseName(empty, tmp, sizeof tmp, status);
status.errIfFailureAndReset("\"%s\"", empty);
assertTrue("reslen >= 0", reslen >= 0);
assertEquals("uloc_getBaseName()", empty, tmp);
uprv_memset(tmp, '!', sizeof tmp);
reslen = uloc_getBaseName(root, tmp, sizeof tmp, status);
status.errIfFailureAndReset("\"%s\"", root);
assertTrue("reslen >= 0", reslen >= 0);
assertEquals("uloc_getBaseName()", empty, tmp);
uprv_memset(tmp, '!', sizeof tmp);
reslen = uloc_getBaseName(und, tmp, sizeof tmp, status);
status.errIfFailureAndReset("\"%s\"", und);
assertTrue("reslen >= 0", reslen >= 0);
assertEquals("uloc_getBaseName()", empty, tmp);
uprv_memset(tmp, '!', sizeof tmp);
reslen = uloc_getBaseName(empty_script, tmp, sizeof tmp, status);
status.errIfFailureAndReset("\"%s\"", empty_script);
assertTrue("reslen >= 0", reslen >= 0);
assertEquals("uloc_getBaseName()", empty_script, tmp);
uprv_memset(tmp, '!', sizeof tmp);
reslen = uloc_getBaseName(empty_region, tmp, sizeof tmp, status);
status.errIfFailureAndReset("\"%s\"", empty_region);
assertTrue("reslen >= 0", reslen >= 0);
assertEquals("uloc_getBaseName()", empty_region, tmp);
uprv_memset(tmp, '!', sizeof tmp);
reslen = uloc_getBaseName(und_script, tmp, sizeof tmp, status);
status.errIfFailureAndReset("\"%s\"", und_script);
assertTrue("reslen >= 0", reslen >= 0);
assertEquals("uloc_getBaseName()", empty_script, tmp);
uprv_memset(tmp, '!', sizeof tmp);
reslen = uloc_getBaseName(und_region, tmp, sizeof tmp, status);
status.errIfFailureAndReset("\"%s\"", und_region);
assertTrue("reslen >= 0", reslen >= 0);
assertEquals("uloc_getBaseName()", empty_region, tmp);
// uloc_getParent()
uprv_memset(tmp, '!', sizeof tmp);
reslen = uloc_getParent(empty, tmp, sizeof tmp, status);
status.errIfFailureAndReset("\"%s\"", empty);
assertTrue("reslen >= 0", reslen >= 0);
assertEquals("uloc_getParent()", empty, tmp);
uprv_memset(tmp, '!', sizeof tmp);
reslen = uloc_getParent(root, tmp, sizeof tmp, status);
status.errIfFailureAndReset("\"%s\"", root);
assertTrue("reslen >= 0", reslen >= 0);
assertEquals("uloc_getParent()", empty, tmp);
uprv_memset(tmp, '!', sizeof tmp);
reslen = uloc_getParent(und, tmp, sizeof tmp, status);
status.errIfFailureAndReset("\"%s\"", und);
assertTrue("reslen >= 0", reslen >= 0);
assertEquals("uloc_getParent()", empty, tmp);
uprv_memset(tmp, '!', sizeof tmp);
reslen = uloc_getParent(empty_script, tmp, sizeof tmp, status);
status.errIfFailureAndReset("\"%s\"", empty_script);
assertTrue("reslen >= 0", reslen >= 0);
assertEquals("uloc_getParent()", empty, tmp);
uprv_memset(tmp, '!', sizeof tmp);
reslen = uloc_getParent(empty_region, tmp, sizeof tmp, status);
status.errIfFailureAndReset("\"%s\"", empty_region);
assertTrue("reslen >= 0", reslen >= 0);
assertEquals("uloc_getParent()", empty, tmp);
uprv_memset(tmp, '!', sizeof tmp);
reslen = uloc_getParent(und_script, tmp, sizeof tmp, status);
status.errIfFailureAndReset("\"%s\"", und_script);
assertTrue("reslen >= 0", reslen >= 0);
assertEquals("uloc_getParent()", empty, tmp);
uprv_memset(tmp, '!', sizeof tmp);
reslen = uloc_getParent(und_region, tmp, sizeof tmp, status);
status.errIfFailureAndReset("\"%s\"", und_region);
assertTrue("reslen >= 0", reslen >= 0);
assertEquals("uloc_getParent()", empty, tmp);
// uloc_getLanguage()
uprv_memset(tmp, '!', sizeof tmp);
reslen = uloc_getLanguage(empty, tmp, sizeof tmp, status);
status.errIfFailureAndReset("\"%s\"", empty);
assertTrue("reslen >= 0", reslen >= 0);
assertEquals("uloc_getLanguage()", empty, tmp);
uprv_memset(tmp, '!', sizeof tmp);
reslen = uloc_getLanguage(root, tmp, sizeof tmp, status);
status.errIfFailureAndReset("\"%s\"", root);
assertTrue("reslen >= 0", reslen >= 0);
assertEquals("uloc_getLanguage()", empty, tmp);
uprv_memset(tmp, '!', sizeof tmp);
reslen = uloc_getLanguage(und, tmp, sizeof tmp, status);
status.errIfFailureAndReset("\"%s\"", und);
assertTrue("reslen >= 0", reslen >= 0);
assertEquals("uloc_getLanguage()", empty, tmp);
uprv_memset(tmp, '!', sizeof tmp);
reslen = uloc_getLanguage(empty_script, tmp, sizeof tmp, status);
status.errIfFailureAndReset("\"%s\"", empty_script);
assertTrue("reslen >= 0", reslen >= 0);
assertEquals("uloc_getLanguage()", empty, tmp);
uprv_memset(tmp, '!', sizeof tmp);
reslen = uloc_getLanguage(empty_region, tmp, sizeof tmp, status);
status.errIfFailureAndReset("\"%s\"", empty_region);
assertTrue("reslen >= 0", reslen >= 0);
assertEquals("uloc_getLanguage()", empty, tmp);
uprv_memset(tmp, '!', sizeof tmp);
reslen = uloc_getLanguage(und_script, tmp, sizeof tmp, status);
status.errIfFailureAndReset("\"%s\"", und_script);
assertTrue("reslen >= 0", reslen >= 0);
assertEquals("uloc_getLanguage()", empty, tmp);
uprv_memset(tmp, '!', sizeof tmp);
reslen = uloc_getLanguage(und_region, tmp, sizeof tmp, status);
status.errIfFailureAndReset("\"%s\"", und_region);
assertTrue("reslen >= 0", reslen >= 0);
assertEquals("uloc_getLanguage()", empty, tmp);
}
#define ARRAY_RANGE(array) (array), ((array) + UPRV_LENGTHOF(array))
void LocaleTest::TestRangeIterator() {
IcuTestErrorCode status(*this, "TestRangeIterator");
Locale locales[] = { "fr", "en_GB", "en" };
Locale::RangeIterator<Locale *> iter(ARRAY_RANGE(locales));
assertTrue("0.hasNext()", iter.hasNext());
const Locale &l0 = iter.next();
assertEquals("0.next()", "fr", l0.getName());
assertTrue("&0.next()", &l0 == &locales[0]);
assertTrue("1.hasNext()", iter.hasNext());
const Locale &l1 = iter.next();
assertEquals("1.next()", "en_GB", l1.getName());
assertTrue("&1.next()", &l1 == &locales[1]);
assertTrue("2.hasNext()", iter.hasNext());
const Locale &l2 = iter.next();
assertEquals("2.next()", "en", l2.getName());
assertTrue("&2.next()", &l2 == &locales[2]);
assertFalse("3.hasNext()", iter.hasNext());
}
void LocaleTest::TestPointerConvertingIterator() {
IcuTestErrorCode status(*this, "TestPointerConvertingIterator");
Locale locales[] = { "fr", "en_GB", "en" };
Locale *pointers[] = { locales, locales + 1, locales + 2 };
// Lambda with explicit reference return type to prevent copy-constructing a temporary
// which would be destructed right away.
Locale::ConvertingIterator<Locale **, std::function<const Locale &(const Locale *)>> iter(
ARRAY_RANGE(pointers), [](const Locale *p) -> const Locale & { return *p; });
assertTrue("0.hasNext()", iter.hasNext());
const Locale &l0 = iter.next();
assertEquals("0.next()", "fr", l0.getName());
assertTrue("&0.next()", &l0 == pointers[0]);
assertTrue("1.hasNext()", iter.hasNext());
const Locale &l1 = iter.next();
assertEquals("1.next()", "en_GB", l1.getName());
assertTrue("&1.next()", &l1 == pointers[1]);
assertTrue("2.hasNext()", iter.hasNext());
const Locale &l2 = iter.next();
assertEquals("2.next()", "en", l2.getName());
assertTrue("&2.next()", &l2 == pointers[2]);
assertFalse("3.hasNext()", iter.hasNext());
}
namespace {
class LocaleFromTag {
public:
LocaleFromTag() : locale(Locale::getRoot()) {}
const Locale &operator()(const char *tag) { return locale = Locale(tag); }
private:
// Store the locale in the converter, rather than return a reference to a temporary,
// or a value which could go out of scope with the caller's reference to it.
Locale locale;
};
} // namespace
void LocaleTest::TestTagConvertingIterator() {
IcuTestErrorCode status(*this, "TestTagConvertingIterator");
const char *tags[] = { "fr", "en_GB", "en" };
LocaleFromTag converter;
Locale::ConvertingIterator<const char **, LocaleFromTag> iter(ARRAY_RANGE(tags), converter);
assertTrue("0.hasNext()", iter.hasNext());
const Locale &l0 = iter.next();
assertEquals("0.next()", "fr", l0.getName());
assertTrue("1.hasNext()", iter.hasNext());
const Locale &l1 = iter.next();
assertEquals("1.next()", "en_GB", l1.getName());
assertTrue("2.hasNext()", iter.hasNext());
const Locale &l2 = iter.next();
assertEquals("2.next()", "en", l2.getName());
assertFalse("3.hasNext()", iter.hasNext());
}
void LocaleTest::TestCapturingTagConvertingIterator() {
IcuTestErrorCode status(*this, "TestCapturingTagConvertingIterator");
const char *tags[] = { "fr", "en_GB", "en" };
// Store the converted locale in a locale variable,
// rather than return a reference to a temporary,
// or a value which could go out of scope with the caller's reference to it.
Locale locale;
// Lambda with explicit reference return type to prevent copy-constructing a temporary
// which would be destructed right away.
Locale::ConvertingIterator<const char **, std::function<const Locale &(const char *)>> iter(
ARRAY_RANGE(tags), [&](const char *tag) -> const Locale & { return locale = Locale(tag); });
assertTrue("0.hasNext()", iter.hasNext());
const Locale &l0 = iter.next();
assertEquals("0.next()", "fr", l0.getName());
assertTrue("1.hasNext()", iter.hasNext());
const Locale &l1 = iter.next();
assertEquals("1.next()", "en_GB", l1.getName());
assertTrue("2.hasNext()", iter.hasNext());
const Locale &l2 = iter.next();
assertEquals("2.next()", "en", l2.getName());
assertFalse("3.hasNext()", iter.hasNext());
}
void LocaleTest::TestSetUnicodeKeywordValueInLongLocale() {
IcuTestErrorCode status(*this, "TestSetUnicodeKeywordValueInLongLocale");
const char* value = "efghijkl";
icu::Locale l("de");
char keyword[3];
CharString expected("de-u", status);
keyword[2] = '\0';
for (char i = 'a'; i < 's'; i++) {
keyword[0] = keyword[1] = i;
expected.append("-", status);
expected.append(keyword, status);
expected.append("-", status);
expected.append(value, status);
l.setUnicodeKeywordValue(keyword, value, status);
if (status.errIfFailureAndReset(
"setUnicodeKeywordValue(\"%s\", \"%s\") fail while locale is \"%s\"",
keyword, value, l.getName())) {
return;
}
std::string tag = l.toLanguageTag<std::string>(status);
if (status.errIfFailureAndReset(
"toLanguageTag fail on \"%s\"", l.getName())) {
return;
}
if (tag != expected.data()) {
errln("Expected to get \"%s\" bug got \"%s\"", tag.c_str(),
expected.data());
return;
}
}
}
void LocaleTest::TestLongLocaleSetKeywordAssign() {
IcuTestErrorCode status(*this, "TestLongLocaleSetKeywordAssign");
// A long base name, with an illegal keyword and copy constructor
icu::Locale l("de_AAAAAAA1_AAAAAAA2_AAAAAAA3_AAAAAAA4_AAAAAAA5_AAAAAAA6_"
"AAAAAAA7_AAAAAAA8_AAAAAAA9_AAAAAA10_AAAAAA11_AAAAAA12_"
"AAAAAA13_AAAAAA14_AAAAAA15_AAAAAA16_AAAAAA17_AAAAAA18");
Locale l2;
l.setUnicodeKeywordValue("co", "12", status); // Cause an error
status.reset();
l2 = l; // copy operator on such bogus locale.
}
void LocaleTest::TestLongLocaleSetKeywordMoveAssign() {
IcuTestErrorCode status(*this, "TestLongLocaleSetKeywordMoveAssign");
// A long base name, with an illegal keyword and copy constructor
icu::Locale l("de_AAAAAAA1_AAAAAAA2_AAAAAAA3_AAAAAAA4_AAAAAAA5_AAAAAAA6_"
"AAAAAAA7_AAAAAAA8_AAAAAAA9_AAAAAA10_AAAAAA11_AAAAAA12_"
"AAAAAA13_AAAAAA14_AAAAAA15_AAAAAA16_AAAAAA17");
Locale l2;
l.setUnicodeKeywordValue("co", "12", status); // Cause an error
status.reset();
Locale l3 = std::move(l); // move assign
}
void LocaleTest::TestSetUnicodeKeywordValueNullInLongLocale() {
IcuTestErrorCode status(*this, "TestSetUnicodeKeywordValueNullInLongLocale");
const char *exts[] = {"cf", "cu", "em", "kk", "kr", "ks", "kv", "lb", "lw",
"ms", "nu", "rg", "sd", "ss", "tz"};
for (int32_t i = 0; i < UPRV_LENGTHOF(exts); i++) {
CharString tag("de-u", status);
for (int32_t j = 0; j <= i; j++) {
tag.append("-", status).append(exts[j], status);
}
if (status.errIfFailureAndReset(
"Cannot create tag \"%s\"", tag.data())) {
continue;
}
Locale l = Locale::forLanguageTag(tag.data(), status);
if (status.errIfFailureAndReset(
"Locale::forLanguageTag(\"%s\") failed", tag.data())) {
continue;
}
for (int32_t j = 0; j <= i; j++) {
l.setUnicodeKeywordValue(exts[j], nullptr, status);
if (status.errIfFailureAndReset(
"Locale(\"%s\").setUnicodeKeywordValue(\"%s\", nullptr) failed",
tag.data(), exts[j])) {
continue;
}
}
if (strcmp("de", l.getName()) != 0) {
errln("setUnicodeKeywordValue should remove all extensions from "
"\"%s\" and only have \"de\", but is \"%s\" instead.",
tag.data(), l.getName());
}
}
}
void LocaleTest::TestLeak21419() {
IcuTestErrorCode status(*this, "TestLeak21419");
Locale l = Locale("s-yU");
l.canonicalize(status);
status.expectErrorAndReset(U_ILLEGAL_ARGUMENT_ERROR);
}
void LocaleTest::TestNullDereferenceWrite21597() {
IcuTestErrorCode status(*this, "TestNullDereferenceWrite21597");
Locale l = Locale("zu-t-q5-X1-vKf-KK-Ks-cO--Kc");
l.canonicalize(status);
status.expectErrorAndReset(U_ILLEGAL_ARGUMENT_ERROR);
}
#if !UCONFIG_NO_FORMATTING
void LocaleTest::TestSierraLeoneCurrency21997() {
// CLDR 41: Check that currency of Sierra Leone is SLL (which is legal tender)
// and not the newer currency SLE (which is not legal tender), as of CLDR 41.
// Test will fail once SLE is declared legal.
// CLDR 42: Now check that currency of Sierra Leone is SLE (which is legal tender)
UnicodeString sllStr("SLE", ""), resultStr;
char16_t tmp[4];
UErrorCode status = U_ZERO_ERROR;
ucurr_forLocale("en_SL", tmp, 4, &status);
resultStr.setTo(tmp);
if (sllStr != resultStr) {
errcheckln(status, "Fail: en_SL didn't return SLE - %s", u_errorName(status));
}
}
#endif
Reference in a new issue View git blame Copy permalink