You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
599 lines
29 KiB
599 lines
29 KiB
// © 2016 and later: Unicode, Inc. and others.
|
|
// License & terms of use: http://www.unicode.org/copyright.html
|
|
/*********************************************************************
|
|
* COPYRIGHT:
|
|
* Copyright (c) 2010-2016, International Business Machines Corporation and
|
|
* others. All Rights Reserved.
|
|
*********************************************************************/
|
|
|
|
#include "locnmtst.h"
|
|
#include "unicode/ustring.h"
|
|
#include "cstring.h"
|
|
|
|
/*
|
|
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_assert_equal(target,value) UPRV_BLOCK_MACRO_BEGIN { \
|
|
if (UnicodeString(target)!=(value)) { \
|
|
logln("unexpected value '" + (value) + "'"); \
|
|
dataerrln("FAIL: " #target " == " #value " was not true. In " __FILE__ " on line %d", __LINE__); \
|
|
} else { \
|
|
logln("PASS: asserted " #target " == " #value); \
|
|
} \
|
|
} UPRV_BLOCK_MACRO_END
|
|
|
|
#define test_dumpLocale(l) UPRV_BLOCK_MACRO_BEGIN { \
|
|
logln(#l " = " + UnicodeString(l.getName(), "")); \
|
|
} UPRV_BLOCK_MACRO_END
|
|
|
|
LocaleDisplayNamesTest::LocaleDisplayNamesTest() {
|
|
}
|
|
|
|
LocaleDisplayNamesTest::~LocaleDisplayNamesTest() {
|
|
}
|
|
|
|
void LocaleDisplayNamesTest::runIndexedTest(int32_t index, UBool exec, const char* &name,
|
|
char* /*par*/) {
|
|
switch (index) {
|
|
#if !UCONFIG_NO_FORMATTING
|
|
TESTCASE(0, TestCreate);
|
|
TESTCASE(1, TestCreateDialect);
|
|
TESTCASE(2, TestWithKeywordsAndEverything);
|
|
TESTCASE(3, TestUldnOpen);
|
|
TESTCASE(4, TestUldnOpenDialect);
|
|
TESTCASE(5, TestUldnWithKeywordsAndEverything);
|
|
TESTCASE(6, TestUldnComponents);
|
|
TESTCASE(7, TestRootEtc);
|
|
TESTCASE(8, TestCurrencyKeyword);
|
|
TESTCASE(9, TestUnknownCurrencyKeyword);
|
|
TESTCASE(10, TestUntranslatedKeywords);
|
|
TESTCASE(11, TestPrivateUse);
|
|
TESTCASE(12, TestUldnDisplayContext);
|
|
TESTCASE(13, TestUldnWithGarbage);
|
|
TESTCASE(14, TestSubstituteHandling);
|
|
TESTCASE(15, TestNumericRegionID);
|
|
#endif
|
|
default:
|
|
name = "";
|
|
break;
|
|
}
|
|
}
|
|
|
|
#if !UCONFIG_NO_FORMATTING
|
|
void LocaleDisplayNamesTest::TestCreate() {
|
|
UnicodeString temp;
|
|
LocaleDisplayNames *ldn = LocaleDisplayNames::createInstance(Locale::getGermany());
|
|
ldn->localeDisplayName("de_DE", temp);
|
|
delete ldn;
|
|
test_assert_equal("Deutsch (Deutschland)", temp);
|
|
}
|
|
|
|
void LocaleDisplayNamesTest::TestCreateDialect() {
|
|
UnicodeString temp;
|
|
LocaleDisplayNames *ldn = LocaleDisplayNames::createInstance(Locale::getUS(), ULDN_DIALECT_NAMES);
|
|
ldn->localeDisplayName("en_GB", temp);
|
|
delete ldn;
|
|
test_assert_equal("British English", temp);
|
|
}
|
|
|
|
void LocaleDisplayNamesTest::TestWithKeywordsAndEverything() {
|
|
UnicodeString temp;
|
|
LocaleDisplayNames *ldn = LocaleDisplayNames::createInstance(Locale::getUS());
|
|
const char *locname = "en_Hant_US_VALLEY@calendar=gregorian;collation=phonebook";
|
|
const char *target = "English (Traditional, United States, VALLEY, "
|
|
"Gregorian Calendar, Phonebook Sort Order)";
|
|
ldn->localeDisplayName(locname, temp);
|
|
delete ldn;
|
|
test_assert_equal(target, temp);
|
|
}
|
|
|
|
void LocaleDisplayNamesTest::TestCurrencyKeyword() {
|
|
UnicodeString temp;
|
|
LocaleDisplayNames *ldn = LocaleDisplayNames::createInstance(Locale::getUS());
|
|
const char *locname = "ja@currency=JPY";
|
|
const char *target = "Japanese (Japanese Yen)";
|
|
ldn->localeDisplayName(locname, temp);
|
|
delete ldn;
|
|
test_assert_equal(target, temp);
|
|
}
|
|
|
|
void LocaleDisplayNamesTest::TestUnknownCurrencyKeyword() {
|
|
UnicodeString temp;
|
|
LocaleDisplayNames *ldn = LocaleDisplayNames::createInstance(Locale::getUS());
|
|
const char *locname = "de@currency=XYZ";
|
|
const char *target = "German (Currency: XYZ)";
|
|
ldn->localeDisplayName(locname, temp);
|
|
delete ldn;
|
|
test_assert_equal(target, temp);
|
|
}
|
|
|
|
void LocaleDisplayNamesTest::TestUntranslatedKeywords() {
|
|
UnicodeString temp;
|
|
LocaleDisplayNames *ldn = LocaleDisplayNames::createInstance(Locale::getUS());
|
|
const char *locname = "de@foo=bar";
|
|
const char *target = "German (foo=bar)";
|
|
ldn->localeDisplayName(locname, temp);
|
|
delete ldn;
|
|
test_assert_equal(target, temp);
|
|
}
|
|
|
|
void LocaleDisplayNamesTest::TestPrivateUse() {
|
|
UnicodeString temp;
|
|
LocaleDisplayNames *ldn = LocaleDisplayNames::createInstance(Locale::getUS());
|
|
const char *locname = "de@x=foobar";
|
|
const char *target = "German (Private-Use: foobar)";
|
|
ldn->localeDisplayName(locname, temp);
|
|
delete ldn;
|
|
test_assert_equal(target, temp);
|
|
}
|
|
|
|
void LocaleDisplayNamesTest::TestUldnOpen() {
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
const int32_t kMaxResultSize = 150; // long enough
|
|
UChar result[150];
|
|
ULocaleDisplayNames *ldn = uldn_open(Locale::getGermany().getName(), ULDN_STANDARD_NAMES, &status);
|
|
int32_t len = uldn_localeDisplayName(ldn, "de_DE", result, kMaxResultSize, &status);
|
|
uldn_close(ldn);
|
|
test_assert(U_SUCCESS(status));
|
|
|
|
UnicodeString str(result, len, kMaxResultSize);
|
|
test_assert_equal("Deutsch (Deutschland)", str);
|
|
|
|
// make sure that NULL gives us the default locale as usual
|
|
ldn = uldn_open(NULL, ULDN_STANDARD_NAMES, &status);
|
|
const char *locale = uldn_getLocale(ldn);
|
|
if(0 != uprv_strcmp(uloc_getDefault(), locale)) {
|
|
errln("uldn_getLocale(uldn_open(NULL))=%s != default locale %s\n", locale, uloc_getDefault());
|
|
}
|
|
uldn_close(ldn);
|
|
test_assert(U_SUCCESS(status));
|
|
}
|
|
|
|
void LocaleDisplayNamesTest::TestUldnOpenDialect() {
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
const int32_t kMaxResultSize = 150; // long enough
|
|
UChar result[150];
|
|
ULocaleDisplayNames *ldn = uldn_open(Locale::getUS().getName(), ULDN_DIALECT_NAMES, &status);
|
|
int32_t len = uldn_localeDisplayName(ldn, "en_GB", result, kMaxResultSize, &status);
|
|
uldn_close(ldn);
|
|
test_assert(U_SUCCESS(status));
|
|
|
|
UnicodeString str(result, len, kMaxResultSize);
|
|
test_assert_equal("British English", str);
|
|
}
|
|
|
|
void LocaleDisplayNamesTest::TestUldnWithGarbage() {
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
const int32_t kMaxResultSize = 150; // long enough
|
|
UChar result[150];
|
|
ULocaleDisplayNames *ldn = uldn_open(Locale::getUS().getName(), ULDN_DIALECT_NAMES, &status);
|
|
int32_t len = uldn_localeDisplayName(ldn, "english (United States) [w", result, kMaxResultSize, &status);
|
|
uldn_close(ldn);
|
|
test_assert(U_FAILURE(status) && len == 0);
|
|
}
|
|
|
|
void LocaleDisplayNamesTest::TestUldnWithKeywordsAndEverything() {
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
const int32_t kMaxResultSize = 150; // long enough
|
|
UChar result[150];
|
|
const char *locname = "en_Hant_US_VALLEY@calendar=gregorian;collation=phonebook";
|
|
const char *target = "English (Traditional, United States, VALLEY, "
|
|
"Gregorian Calendar, Phonebook Sort Order)";
|
|
ULocaleDisplayNames *ldn = uldn_open(Locale::getUS().getName(), ULDN_STANDARD_NAMES, &status);
|
|
int32_t len = uldn_localeDisplayName(ldn, locname, result, kMaxResultSize, &status);
|
|
uldn_close(ldn);
|
|
test_assert(U_SUCCESS(status));
|
|
|
|
UnicodeString str(result, len, kMaxResultSize);
|
|
test_assert_equal(target, str);
|
|
}
|
|
|
|
void LocaleDisplayNamesTest::TestUldnComponents() {
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
const int32_t kMaxResultSize = 150; // long enough
|
|
UChar result[150];
|
|
|
|
ULocaleDisplayNames *ldn = uldn_open(Locale::getGermany().getName(), ULDN_STANDARD_NAMES, &status);
|
|
test_assert(U_SUCCESS(status));
|
|
if (U_FAILURE(status)) {
|
|
return;
|
|
}
|
|
|
|
// "en_Hant_US_PRE_EURO@calendar=gregorian";
|
|
|
|
{
|
|
int32_t len = uldn_languageDisplayName(ldn, "en", result, kMaxResultSize, &status);
|
|
UnicodeString str(result, len, kMaxResultSize);
|
|
test_assert_equal("Englisch", str);
|
|
}
|
|
|
|
|
|
{
|
|
int32_t len = uldn_scriptDisplayName(ldn, "Hant", result, kMaxResultSize, &status);
|
|
UnicodeString str(result, len, kMaxResultSize);
|
|
test_assert_equal("Traditionell", str);
|
|
}
|
|
|
|
{
|
|
int32_t len = uldn_scriptCodeDisplayName(ldn, USCRIPT_TRADITIONAL_HAN, result, kMaxResultSize,
|
|
&status);
|
|
UnicodeString str(result, len, kMaxResultSize);
|
|
test_assert_equal("Traditionell", str);
|
|
}
|
|
|
|
{
|
|
int32_t len = uldn_regionDisplayName(ldn, "US", result, kMaxResultSize, &status);
|
|
UnicodeString str(result, len, kMaxResultSize);
|
|
test_assert_equal("Vereinigte Staaten", str);
|
|
}
|
|
|
|
{
|
|
int32_t len = uldn_variantDisplayName(ldn, "PRE_EURO", result, kMaxResultSize, &status);
|
|
UnicodeString str(result, len, kMaxResultSize);
|
|
test_assert_equal("PRE_EURO", str);
|
|
}
|
|
|
|
{
|
|
int32_t len = uldn_keyDisplayName(ldn, "calendar", result, kMaxResultSize, &status);
|
|
UnicodeString str(result, len, kMaxResultSize);
|
|
test_assert_equal("Kalender", str);
|
|
}
|
|
|
|
{
|
|
int32_t len = uldn_keyValueDisplayName(ldn, "calendar", "gregorian", result,
|
|
kMaxResultSize, &status);
|
|
UnicodeString str(result, len, kMaxResultSize);
|
|
test_assert_equal("Gregorianischer Kalender", str);
|
|
}
|
|
|
|
uldn_close(ldn);
|
|
}
|
|
|
|
|
|
typedef struct {
|
|
const char * displayLocale;
|
|
UDisplayContext dialectHandling;
|
|
UDisplayContext capitalization;
|
|
UDisplayContext displayLength;
|
|
const char * localeToBeNamed;
|
|
const UChar * result;
|
|
} LocNameDispContextItem;
|
|
|
|
static char en[] = "en";
|
|
static char en_cabud[] = "en@calendar=buddhist";
|
|
static char en_GB[] = "en_GB";
|
|
static char uz_Latn[] = "uz_Latn";
|
|
|
|
static UChar daFor_en[] = {0x65,0x6E,0x67,0x65,0x6C,0x73,0x6B,0}; //"engelsk"
|
|
static UChar daFor_en_cabud[] = {0x65,0x6E,0x67,0x65,0x6C,0x73,0x6B,0x20,0x28,0x62,0x75,0x64,0x64,0x68,0x69,0x73,0x74,0x69,0x73,0x6B,0x20,
|
|
0x6B,0x61,0x6C,0x65,0x6E,0x64,0x65,0x72,0x29,0}; //"engelsk (buddhistisk kalender)"
|
|
static UChar daFor_en_GB[] = {0x65,0x6E,0x67,0x65,0x6C,0x73,0x6B,0x20,0x28,0x53,0x74,0x6F,0x72,0x62,0x72,0x69,0x74,0x61,0x6E,0x6E,0x69,0x65,0x6E,0x29,0}; //"engelsk (Storbritannien)"
|
|
static UChar daFor_en_GB_D[] = {0x62,0x72,0x69,0x74,0x69,0x73,0x6B,0x20,0x65,0x6E,0x67,0x65,0x6C,0x73,0x6B,0}; //"britisk engelsk"
|
|
static UChar esFor_en[] = {0x69,0x6E,0x67,0x6C,0xE9,0x73,0}; //"ingles" with acute on the e
|
|
static UChar esFor_en_GB[] = {0x69,0x6E,0x67,0x6C,0xE9,0x73,0x20,0x28,0x52,0x65,0x69,0x6E,0x6F,0x20,0x55,0x6E,0x69,0x64,0x6F,0x29,0}; //"ingles (Reino Unido)" ...
|
|
static UChar esFor_en_GB_S[] = {0x69,0x6E,0x67,0x6C,0xE9,0x73,0x20,0x28,0x52,0x55,0x29,0}; //"ingles (RU)" ...
|
|
static UChar esFor_en_GB_D[] = {0x69,0x6E,0x67,0x6C,0xE9,0x73,0x20,0x62,0x72,0x69,0x74,0xE1,0x6E,0x69,0x63,0x6F,0}; //"ingles britanico" with acute on the e, a
|
|
static UChar ruFor_uz_Latn[] = {0x0443,0x0437,0x0431,0x0435,0x043A,0x0441,0x043A,0x0438,0x0439,0x20,0x28,0x043B,0x0430,0x0442,0x0438,0x043D,0x0438,0x0446,0x0430,0x29,0}; // all lowercase
|
|
#if !UCONFIG_NO_BREAK_ITERATION
|
|
static UChar daFor_en_T[] = {0x45,0x6E,0x67,0x65,0x6C,0x73,0x6B,0}; //"Engelsk"
|
|
static UChar daFor_en_cabudT[]= {0x45,0x6E,0x67,0x65,0x6C,0x73,0x6B,0x20,0x28,0x62,0x75,0x64,0x64,0x68,0x69,0x73,0x74,0x69,0x73,0x6B,0x20,
|
|
0x6B,0x61,0x6C,0x65,0x6E,0x64,0x65,0x72,0x29,0}; //"Engelsk (buddhistisk kalender)"
|
|
static UChar daFor_en_GB_T[] = {0x45,0x6E,0x67,0x65,0x6C,0x73,0x6B,0x20,0x28,0x53,0x74,0x6F,0x72,0x62,0x72,0x69,0x74,0x61,0x6E,0x6E,0x69,0x65,0x6E,0x29,0}; //"Engelsk (Storbritannien)"
|
|
static UChar daFor_en_GB_DT[] = {0x42,0x72,0x69,0x74,0x69,0x73,0x6B,0x20,0x65,0x6E,0x67,0x65,0x6C,0x73,0x6B,0}; //"Britisk engelsk"
|
|
static UChar esFor_en_T[] = {0x49,0x6E,0x67,0x6C,0xE9,0x73,0}; //"Ingles" with acute on the e
|
|
static UChar esFor_en_GB_T[] = {0x49,0x6E,0x67,0x6C,0xE9,0x73,0x20,0x28,0x52,0x65,0x69,0x6E,0x6F,0x20,0x55,0x6E,0x69,0x64,0x6F,0x29,0}; //"Ingles (Reino Unido)" ...
|
|
static UChar esFor_en_GB_ST[] = {0x49,0x6E,0x67,0x6C,0xE9,0x73,0x20,0x28,0x52,0x55,0x29,0}; //"Ingles (RU)" ...
|
|
static UChar esFor_en_GB_DT[] = {0x49,0x6E,0x67,0x6C,0xE9,0x73,0x20,0x62,0x72,0x69,0x74,0xE1,0x6E,0x69,0x63,0x6F,0}; //"Ingles britanico" with acute on the e, a
|
|
static UChar ruFor_uz_Latn_T[]= {0x0423,0x0437,0x0431,0x0435,0x043A,0x0441,0x043A,0x0438,0x0439,0x20,0x28,0x043B,0x0430,0x0442,0x0438,0x043D,0x0438,0x0446,0x0430,0x29,0}; // first char upper
|
|
#endif /* #if !UCONFIG_NO_BREAK_ITERATION */
|
|
|
|
static const LocNameDispContextItem ctxtItems[] = {
|
|
{ "da", UDISPCTX_STANDARD_NAMES, UDISPCTX_CAPITALIZATION_FOR_MIDDLE_OF_SENTENCE, UDISPCTX_LENGTH_FULL, en, daFor_en },
|
|
{ "da", UDISPCTX_STANDARD_NAMES, UDISPCTX_CAPITALIZATION_FOR_MIDDLE_OF_SENTENCE, UDISPCTX_LENGTH_FULL, en_cabud, daFor_en_cabud },
|
|
{ "da", UDISPCTX_STANDARD_NAMES, UDISPCTX_CAPITALIZATION_FOR_MIDDLE_OF_SENTENCE, UDISPCTX_LENGTH_FULL, en_GB, daFor_en_GB },
|
|
{ "da", UDISPCTX_STANDARD_NAMES, UDISPCTX_CAPITALIZATION_FOR_MIDDLE_OF_SENTENCE, UDISPCTX_LENGTH_SHORT, en_GB, daFor_en_GB },
|
|
{ "da", UDISPCTX_DIALECT_NAMES, UDISPCTX_CAPITALIZATION_FOR_MIDDLE_OF_SENTENCE, UDISPCTX_LENGTH_FULL, en_GB, daFor_en_GB_D },
|
|
{ "es", UDISPCTX_STANDARD_NAMES, UDISPCTX_CAPITALIZATION_FOR_MIDDLE_OF_SENTENCE, UDISPCTX_LENGTH_FULL, en, esFor_en },
|
|
{ "es", UDISPCTX_STANDARD_NAMES, UDISPCTX_CAPITALIZATION_FOR_MIDDLE_OF_SENTENCE, UDISPCTX_LENGTH_FULL, en_GB, esFor_en_GB },
|
|
{ "es", UDISPCTX_STANDARD_NAMES, UDISPCTX_CAPITALIZATION_FOR_MIDDLE_OF_SENTENCE, UDISPCTX_LENGTH_SHORT, en_GB, esFor_en_GB_S },
|
|
{ "es", UDISPCTX_DIALECT_NAMES, UDISPCTX_CAPITALIZATION_FOR_MIDDLE_OF_SENTENCE, UDISPCTX_LENGTH_FULL, en_GB, esFor_en_GB_D },
|
|
{ "ru", UDISPCTX_STANDARD_NAMES, UDISPCTX_CAPITALIZATION_FOR_MIDDLE_OF_SENTENCE, UDISPCTX_LENGTH_FULL, uz_Latn, ruFor_uz_Latn },
|
|
#if !UCONFIG_NO_BREAK_ITERATION
|
|
{ "da", UDISPCTX_STANDARD_NAMES, UDISPCTX_CAPITALIZATION_FOR_BEGINNING_OF_SENTENCE, UDISPCTX_LENGTH_FULL, en, daFor_en_T },
|
|
{ "da", UDISPCTX_STANDARD_NAMES, UDISPCTX_CAPITALIZATION_FOR_BEGINNING_OF_SENTENCE, UDISPCTX_LENGTH_FULL, en_cabud, daFor_en_cabudT },
|
|
{ "da", UDISPCTX_STANDARD_NAMES, UDISPCTX_CAPITALIZATION_FOR_BEGINNING_OF_SENTENCE, UDISPCTX_LENGTH_FULL, en_GB, daFor_en_GB_T },
|
|
{ "da", UDISPCTX_STANDARD_NAMES, UDISPCTX_CAPITALIZATION_FOR_BEGINNING_OF_SENTENCE, UDISPCTX_LENGTH_SHORT, en_GB, daFor_en_GB_T },
|
|
{ "da", UDISPCTX_DIALECT_NAMES, UDISPCTX_CAPITALIZATION_FOR_BEGINNING_OF_SENTENCE, UDISPCTX_LENGTH_FULL, en_GB, daFor_en_GB_DT },
|
|
{ "es", UDISPCTX_STANDARD_NAMES, UDISPCTX_CAPITALIZATION_FOR_BEGINNING_OF_SENTENCE, UDISPCTX_LENGTH_FULL, en, esFor_en_T },
|
|
{ "es", UDISPCTX_STANDARD_NAMES, UDISPCTX_CAPITALIZATION_FOR_BEGINNING_OF_SENTENCE, UDISPCTX_LENGTH_FULL, en_GB, esFor_en_GB_T },
|
|
{ "es", UDISPCTX_STANDARD_NAMES, UDISPCTX_CAPITALIZATION_FOR_BEGINNING_OF_SENTENCE, UDISPCTX_LENGTH_SHORT, en_GB, esFor_en_GB_ST },
|
|
{ "es", UDISPCTX_DIALECT_NAMES, UDISPCTX_CAPITALIZATION_FOR_BEGINNING_OF_SENTENCE, UDISPCTX_LENGTH_FULL, en_GB, esFor_en_GB_DT },
|
|
{ "ru", UDISPCTX_STANDARD_NAMES, UDISPCTX_CAPITALIZATION_FOR_BEGINNING_OF_SENTENCE, UDISPCTX_LENGTH_FULL, uz_Latn, ruFor_uz_Latn_T },
|
|
|
|
{ "da", UDISPCTX_STANDARD_NAMES, UDISPCTX_CAPITALIZATION_FOR_UI_LIST_OR_MENU, UDISPCTX_LENGTH_FULL, en, daFor_en_T },
|
|
{ "da", UDISPCTX_STANDARD_NAMES, UDISPCTX_CAPITALIZATION_FOR_UI_LIST_OR_MENU, UDISPCTX_LENGTH_FULL, en_cabud, daFor_en_cabudT },
|
|
{ "da", UDISPCTX_STANDARD_NAMES, UDISPCTX_CAPITALIZATION_FOR_UI_LIST_OR_MENU, UDISPCTX_LENGTH_FULL, en_GB, daFor_en_GB_T },
|
|
{ "da", UDISPCTX_STANDARD_NAMES, UDISPCTX_CAPITALIZATION_FOR_UI_LIST_OR_MENU, UDISPCTX_LENGTH_SHORT, en_GB, daFor_en_GB_T },
|
|
{ "da", UDISPCTX_DIALECT_NAMES, UDISPCTX_CAPITALIZATION_FOR_UI_LIST_OR_MENU, UDISPCTX_LENGTH_FULL, en_GB, daFor_en_GB_DT },
|
|
{ "es", UDISPCTX_STANDARD_NAMES, UDISPCTX_CAPITALIZATION_FOR_UI_LIST_OR_MENU, UDISPCTX_LENGTH_FULL, en, esFor_en_T },
|
|
{ "es", UDISPCTX_STANDARD_NAMES, UDISPCTX_CAPITALIZATION_FOR_UI_LIST_OR_MENU, UDISPCTX_LENGTH_FULL, en_GB, esFor_en_GB_T },
|
|
{ "es", UDISPCTX_STANDARD_NAMES, UDISPCTX_CAPITALIZATION_FOR_UI_LIST_OR_MENU, UDISPCTX_LENGTH_SHORT, en_GB, esFor_en_GB_ST },
|
|
{ "es", UDISPCTX_DIALECT_NAMES, UDISPCTX_CAPITALIZATION_FOR_UI_LIST_OR_MENU, UDISPCTX_LENGTH_FULL, en_GB, esFor_en_GB_DT },
|
|
{ "ru", UDISPCTX_STANDARD_NAMES, UDISPCTX_CAPITALIZATION_FOR_UI_LIST_OR_MENU, UDISPCTX_LENGTH_FULL, uz_Latn, ruFor_uz_Latn_T },
|
|
|
|
{ "da", UDISPCTX_STANDARD_NAMES, UDISPCTX_CAPITALIZATION_FOR_STANDALONE, UDISPCTX_LENGTH_FULL, en, daFor_en },
|
|
{ "da", UDISPCTX_STANDARD_NAMES, UDISPCTX_CAPITALIZATION_FOR_STANDALONE, UDISPCTX_LENGTH_FULL, en_cabud, daFor_en_cabud },
|
|
{ "da", UDISPCTX_STANDARD_NAMES, UDISPCTX_CAPITALIZATION_FOR_STANDALONE, UDISPCTX_LENGTH_FULL, en_GB, daFor_en_GB },
|
|
{ "da", UDISPCTX_STANDARD_NAMES, UDISPCTX_CAPITALIZATION_FOR_STANDALONE, UDISPCTX_LENGTH_SHORT, en_GB, daFor_en_GB },
|
|
{ "da", UDISPCTX_DIALECT_NAMES, UDISPCTX_CAPITALIZATION_FOR_STANDALONE, UDISPCTX_LENGTH_FULL, en_GB, daFor_en_GB_D },
|
|
{ "es", UDISPCTX_STANDARD_NAMES, UDISPCTX_CAPITALIZATION_FOR_STANDALONE, UDISPCTX_LENGTH_FULL, en, esFor_en_T },
|
|
{ "es", UDISPCTX_STANDARD_NAMES, UDISPCTX_CAPITALIZATION_FOR_STANDALONE, UDISPCTX_LENGTH_FULL, en_GB, esFor_en_GB_T },
|
|
{ "es", UDISPCTX_STANDARD_NAMES, UDISPCTX_CAPITALIZATION_FOR_STANDALONE, UDISPCTX_LENGTH_SHORT, en_GB, esFor_en_GB_ST },
|
|
{ "es", UDISPCTX_DIALECT_NAMES, UDISPCTX_CAPITALIZATION_FOR_STANDALONE, UDISPCTX_LENGTH_FULL, en_GB, esFor_en_GB_DT },
|
|
{ "ru", UDISPCTX_STANDARD_NAMES, UDISPCTX_CAPITALIZATION_FOR_STANDALONE, UDISPCTX_LENGTH_FULL, uz_Latn, ruFor_uz_Latn_T },
|
|
#endif /* #if !UCONFIG_NO_BREAK_ITERATION */
|
|
{ NULL, (UDisplayContext)0, (UDisplayContext)0, (UDisplayContext)0, NULL, NULL }
|
|
};
|
|
|
|
void LocaleDisplayNamesTest::TestUldnDisplayContext() {
|
|
const LocNameDispContextItem * ctxtItemPtr;
|
|
for (ctxtItemPtr = ctxtItems; ctxtItemPtr->displayLocale != NULL; ctxtItemPtr++) {
|
|
UDisplayContext contexts[3] = {ctxtItemPtr->dialectHandling, ctxtItemPtr->capitalization, ctxtItemPtr->displayLength};
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
ULocaleDisplayNames * uldn = uldn_openForContext(ctxtItemPtr->displayLocale, contexts, 3, &status);
|
|
if (U_FAILURE(status)) {
|
|
errln(UnicodeString("FAIL: uldn_openForContext failed for locale ") + ctxtItemPtr->displayLocale +
|
|
", dialectHandling " + ctxtItemPtr->dialectHandling +
|
|
", capitalization " + ctxtItemPtr->capitalization +
|
|
", displayLength " + ctxtItemPtr->displayLength);
|
|
} else {
|
|
UDisplayContext dialectHandling = uldn_getContext(uldn, UDISPCTX_TYPE_DIALECT_HANDLING, &status);
|
|
UDisplayContext capitalization = uldn_getContext(uldn, UDISPCTX_TYPE_CAPITALIZATION, &status);
|
|
UDisplayContext displayLength = uldn_getContext(uldn, UDISPCTX_TYPE_DISPLAY_LENGTH, &status);
|
|
if (U_FAILURE(status)) {
|
|
errln(UnicodeString("FAIL: uldn_getContext status ") + (int)status);
|
|
} else if (dialectHandling != ctxtItemPtr->dialectHandling ||
|
|
capitalization != ctxtItemPtr->capitalization ||
|
|
displayLength != ctxtItemPtr->displayLength) {
|
|
errln("FAIL: uldn_getContext retrieved incorrect dialectHandling, capitalization, or displayLength");
|
|
} else {
|
|
UChar nameBuf[ULOC_FULLNAME_CAPACITY];
|
|
int32_t len = uldn_localeDisplayName(uldn, ctxtItemPtr->localeToBeNamed, nameBuf, ULOC_FULLNAME_CAPACITY, &status);
|
|
if (U_FAILURE(status)) {
|
|
dataerrln(UnicodeString("FAIL: uldn_localeDisplayName status: ") + u_errorName(status));
|
|
} else if (u_strcmp(ctxtItemPtr->result, nameBuf) != 0) {
|
|
UnicodeString exp(ctxtItemPtr->result, u_strlen(ctxtItemPtr->result));
|
|
UnicodeString got(nameBuf, len);
|
|
dataerrln(UnicodeString("FAIL: uldn_localeDisplayName, capitalization ") + ctxtItemPtr->capitalization +
|
|
", expected " + exp + ", got " + got );
|
|
}
|
|
}
|
|
uldn_close(uldn);
|
|
}
|
|
}
|
|
}
|
|
|
|
void LocaleDisplayNamesTest::TestRootEtc() {
|
|
UnicodeString temp;
|
|
LocaleDisplayNames *ldn = LocaleDisplayNames::createInstance(Locale::getUS());
|
|
const char *locname = "@collation=phonebook";
|
|
const char *target = "Root (Phonebook Sort Order)";
|
|
ldn->localeDisplayName(locname, temp);
|
|
test_assert_equal(target, temp);
|
|
|
|
ldn->languageDisplayName("root", temp);
|
|
test_assert_equal("root", temp);
|
|
|
|
ldn->languageDisplayName("en_GB", temp);
|
|
test_assert_equal("en_GB", temp);
|
|
|
|
delete ldn;
|
|
}
|
|
|
|
void LocaleDisplayNamesTest::TestNumericRegionID() {
|
|
UErrorCode err = U_ZERO_ERROR;
|
|
ULocaleDisplayNames* ldn = uldn_open("es_MX", ULDN_STANDARD_NAMES, &err);
|
|
UChar displayName[200];
|
|
int32_t displayNameLength = uldn_regionDisplayName(ldn, "019", displayName, 200, &err);
|
|
test_assert(U_SUCCESS(err));
|
|
test_assert_equal(UnicodeString(u"América"), UnicodeString(displayName));
|
|
uldn_close(ldn);
|
|
|
|
err = U_ZERO_ERROR; // reset in case the test above returned an error code
|
|
ldn = uldn_open("en_AU", ULDN_STANDARD_NAMES, &err);
|
|
displayNameLength = uldn_regionDisplayName(ldn, "002", displayName, 200, &err);
|
|
test_assert(U_SUCCESS(err));
|
|
test_assert_equal(UnicodeString(u"Africa"), UnicodeString(displayName));
|
|
uldn_close(ldn);
|
|
}
|
|
|
|
static const char unknown_region[] = "wx";
|
|
static const char unknown_lang[] = "xy";
|
|
static const char unknown_script[] = "wxyz";
|
|
static const char unknown_variant[] = "abc";
|
|
static const char unknown_key[] = "efg";
|
|
static const char unknown_ca_value[] = "ijk";
|
|
static const char known_lang_unknown_script[] = "en-wxyz";
|
|
static const char unknown_lang_unknown_script[] = "xy-wxyz";
|
|
static const char unknown_lang_known_script[] = "xy-Latn";
|
|
static const char unknown_lang_unknown_region[] = "xy-wx";
|
|
static const char known_lang_unknown_region[] = "en-wx";
|
|
static const char unknown_lang_known_region[] = "xy-US";
|
|
static const char unknown_lang_unknown_script_unknown_region[] = "xy-wxyz-wx";
|
|
static const char known_lang_unknown_script_unknown_region[] = "en-wxyz-wx";
|
|
static const char unknown_lang_known_script_unknown_region[] = "xy-Latn-wx";
|
|
static const char unknown_lang_known_script_known_region[] = "xy-wxyz-US";
|
|
static const char known_lang[] = "en";
|
|
static const char known_lang_known_script[] = "en-Latn";
|
|
static const char known_lang_known_region[] = "en-US";
|
|
static const char known_lang_known_script_known_region[] = "en-Latn-US";
|
|
|
|
void LocaleDisplayNamesTest::VerifySubstitute(LocaleDisplayNames* ldn) {
|
|
UnicodeString temp;
|
|
// Ensure the default is UDISPCTX_SUBSTITUTE
|
|
UDisplayContext context = ldn->getContext(UDISPCTX_TYPE_SUBSTITUTE_HANDLING);
|
|
test_assert(UDISPCTX_SUBSTITUTE == context);
|
|
|
|
ldn->regionDisplayName(unknown_region, temp);
|
|
test_assert_equal(unknown_region, temp);
|
|
ldn->languageDisplayName(unknown_lang, temp);
|
|
test_assert_equal(unknown_lang, temp);
|
|
ldn->scriptDisplayName(unknown_script, temp);
|
|
test_assert_equal(unknown_script, temp);
|
|
ldn->variantDisplayName(unknown_variant, temp);
|
|
test_assert_equal(unknown_variant, temp);
|
|
ldn->keyDisplayName(unknown_key, temp);
|
|
test_assert_equal(unknown_key, temp);
|
|
ldn->keyValueDisplayName("ca", unknown_ca_value, temp);
|
|
test_assert_equal(unknown_ca_value, temp);
|
|
|
|
ldn->localeDisplayName(unknown_lang, temp);
|
|
test_assert_equal(unknown_lang, temp);
|
|
ldn->localeDisplayName(known_lang_unknown_script, temp);
|
|
test_assert_equal("Englisch (Wxyz)", temp);
|
|
ldn->localeDisplayName(unknown_lang_unknown_script, temp);
|
|
test_assert_equal("xy (Wxyz)", temp);
|
|
ldn->localeDisplayName(unknown_lang_known_script, temp);
|
|
test_assert_equal("xy (Lateinisch)", temp);
|
|
ldn->localeDisplayName(unknown_lang_unknown_region, temp);
|
|
test_assert_equal("xy (WX)", temp);
|
|
ldn->localeDisplayName(known_lang_unknown_region, temp);
|
|
test_assert_equal("Englisch (WX)", temp);
|
|
ldn->localeDisplayName(unknown_lang_known_region, temp);
|
|
test_assert_equal("xy (Vereinigte Staaten)", temp);
|
|
ldn->localeDisplayName(unknown_lang_unknown_script_unknown_region, temp);
|
|
test_assert_equal("xy (Wxyz, WX)", temp);
|
|
ldn->localeDisplayName(known_lang_unknown_script_unknown_region, temp);
|
|
test_assert_equal("Englisch (Wxyz, WX)", temp);
|
|
ldn->localeDisplayName(unknown_lang_known_script_unknown_region, temp);
|
|
test_assert_equal("xy (Lateinisch, WX)", temp);
|
|
ldn->localeDisplayName(unknown_lang_known_script_known_region, temp);
|
|
test_assert_equal("xy (Wxyz, Vereinigte Staaten)", temp);
|
|
|
|
ldn->localeDisplayName(known_lang, temp);
|
|
test_assert_equal("Englisch", temp);
|
|
ldn->localeDisplayName(known_lang_known_script, temp);
|
|
test_assert_equal("Englisch (Lateinisch)", temp);
|
|
ldn->localeDisplayName(known_lang_known_region, temp);
|
|
test_assert_equal("Englisch (Vereinigte Staaten)", temp);
|
|
ldn->localeDisplayName(known_lang_known_script_known_region, temp);
|
|
test_assert_equal("Englisch (Lateinisch, Vereinigte Staaten)", temp);
|
|
}
|
|
|
|
void LocaleDisplayNamesTest::VerifyNoSubstitute(LocaleDisplayNames* ldn) {
|
|
UnicodeString temp("");
|
|
std::string utf8;
|
|
// Ensure the default is UDISPCTX_SUBSTITUTE
|
|
UDisplayContext context = ldn->getContext(UDISPCTX_TYPE_SUBSTITUTE_HANDLING);
|
|
test_assert(UDISPCTX_NO_SUBSTITUTE == context);
|
|
|
|
ldn->regionDisplayName(unknown_region, temp);
|
|
test_assert(TRUE == temp.isBogus());
|
|
ldn->languageDisplayName(unknown_lang, temp);
|
|
test_assert(TRUE == temp.isBogus());
|
|
ldn->scriptDisplayName(unknown_script, temp);
|
|
test_assert(TRUE == temp.isBogus());
|
|
ldn->variantDisplayName(unknown_variant, temp);
|
|
test_assert(TRUE == temp.isBogus());
|
|
ldn->keyDisplayName(unknown_key, temp);
|
|
test_assert(TRUE == temp.isBogus());
|
|
ldn->keyValueDisplayName("ca", unknown_ca_value, temp);
|
|
test_assert(TRUE == temp.isBogus());
|
|
|
|
ldn->localeDisplayName(unknown_lang, temp);
|
|
test_assert(TRUE == temp.isBogus());
|
|
ldn->localeDisplayName(known_lang_unknown_script, temp);
|
|
test_assert(TRUE == temp.isBogus());
|
|
ldn->localeDisplayName(unknown_lang_unknown_script, temp);
|
|
test_assert(TRUE == temp.isBogus());
|
|
ldn->localeDisplayName(unknown_lang_known_script, temp);
|
|
test_assert(TRUE == temp.isBogus());
|
|
ldn->localeDisplayName(unknown_lang_unknown_region, temp);
|
|
test_assert(TRUE == temp.isBogus());
|
|
ldn->localeDisplayName(known_lang_unknown_region, temp);
|
|
test_assert(TRUE == temp.isBogus());
|
|
ldn->localeDisplayName(unknown_lang_known_region, temp);
|
|
test_assert(TRUE == temp.isBogus());
|
|
ldn->localeDisplayName(unknown_lang_unknown_script_unknown_region, temp);
|
|
test_assert(TRUE == temp.isBogus());
|
|
ldn->localeDisplayName(known_lang_unknown_script_unknown_region, temp);
|
|
test_assert(TRUE == temp.isBogus());
|
|
ldn->localeDisplayName(unknown_lang_known_script_unknown_region, temp);
|
|
test_assert(TRUE == temp.isBogus());
|
|
ldn->localeDisplayName(unknown_lang_known_script_known_region, temp);
|
|
test_assert(TRUE == temp.isBogus());
|
|
|
|
ldn->localeDisplayName(known_lang, temp);
|
|
test_assert_equal("Englisch", temp);
|
|
ldn->localeDisplayName(known_lang_known_script, temp);
|
|
test_assert_equal("Englisch (Lateinisch)", temp);
|
|
ldn->localeDisplayName(known_lang_known_region, temp);
|
|
test_assert_equal("Englisch (Vereinigte Staaten)", temp);
|
|
ldn->localeDisplayName(known_lang_known_script_known_region, temp);
|
|
test_assert_equal("Englisch (Lateinisch, Vereinigte Staaten)", temp);
|
|
}
|
|
|
|
void LocaleDisplayNamesTest::TestSubstituteHandling() {
|
|
// With substitute as default
|
|
logln("Context: none\n");
|
|
std::unique_ptr<LocaleDisplayNames> ldn(LocaleDisplayNames::createInstance(Locale::getGermany()));
|
|
VerifySubstitute(ldn.get());
|
|
|
|
// With explicit set substitute, and standard names
|
|
logln("Context: UDISPCTX_SUBSTITUTE, UDISPCTX_STANDARD_NAMES\n");
|
|
UDisplayContext context_1[] = { UDISPCTX_SUBSTITUTE, UDISPCTX_STANDARD_NAMES };
|
|
ldn.reset(LocaleDisplayNames::createInstance(Locale::getGermany(), context_1, 2));
|
|
VerifySubstitute(ldn.get());
|
|
|
|
// With explicit set substitute and dialect names
|
|
logln("Context: UDISPCTX_SUBSTITUTE, UDISPCTX_DIALECT_NAMES\n");
|
|
UDisplayContext context_2[] = { UDISPCTX_SUBSTITUTE, UDISPCTX_DIALECT_NAMES };
|
|
ldn.reset(LocaleDisplayNames::createInstance(Locale::getGermany(), context_2, 2));
|
|
VerifySubstitute(ldn.get());
|
|
|
|
// With explicit set no_substitute, and standard names
|
|
logln("Context: UDISPCTX_NO_SUBSTITUTE, UDISPCTX_STANDARD_NAMES\n");
|
|
UDisplayContext context_3[] = { UDISPCTX_NO_SUBSTITUTE, UDISPCTX_STANDARD_NAMES };
|
|
ldn.reset(LocaleDisplayNames::createInstance(Locale::getGermany(), context_3, 2));
|
|
VerifyNoSubstitute(ldn.get());
|
|
|
|
// With explicit set no_substitute and dialect names
|
|
logln("Context: UDISPCTX_NO_SUBSTITUTE, UDISPCTX_DIALECT_NAMES\n");
|
|
UDisplayContext context_4[] = { UDISPCTX_NO_SUBSTITUTE, UDISPCTX_DIALECT_NAMES };
|
|
ldn.reset(LocaleDisplayNames::createInstance(Locale::getGermany(), context_4, 2));
|
|
VerifyNoSubstitute(ldn.get());
|
|
}
|
|
|
|
#endif /* UCONFIG_NO_FORMATTING */
|