[apple/icu.git] / icuSources / test / intltest / locnmtst.cpp

/*********************************************************************
 * COPYRIGHT:
 * Copyright (c) 2010-2014, International Business Machines Corporation and
 * others. All Rights Reserved.
 *********************************************************************/

#include "locnmtst.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) \
    { \
        if(!(test)) \
            errln("FAIL: " #test " was not true. In " __FILE__ " on line %d", __LINE__ ); \
        else \
            logln("PASS: asserted " #test); \
    }

/*
 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) \
    { \
        if(!(test)) \
            errln("FAIL: " #test " was not true. " + UnicodeString(print) ); \
        else \
            logln("PASS: asserted " #test "-> " + UnicodeString(print)); \
    }

#define test_assert_equal(target,value) \
  { \
    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); \
    } \
  }

#define test_dumpLocale(l) { logln(#l " = " + UnicodeString(l.getName(), "")); }

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);
#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, US, 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::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, US, 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_GB[] = "en_GB";

static UChar daFor_en[]       = {0x65,0x6E,0x67,0x65,0x6C,0x73,0x6B,0}; //"engelsk"
static UChar daFor_en_GB[]    = {0x65,0x6E,0x67,0x65,0x6C,0x73,0x6B,0x20,0x28,0x55,0x4B,0x29,0}; //"engelsk (UK)" // Apple change
static UChar daFor_en_GB_S[]  = {0x65,0x6E,0x67,0x65,0x6C,0x73,0x6B,0x20,0x28,0x55,0x4B,0x29,0}; //"engelsk (UK)"
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,0x55,0x29,0}; //"ingles (RU)" ... // Apple change
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
#if !UCONFIG_NO_BREAK_ITERATION
static UChar daFor_en_T[]     = {0x45,0x6E,0x67,0x65,0x6C,0x73,0x6B,0}; //"Engelsk"
static UChar daFor_en_GB_T[]  = {0x45,0x6E,0x67,0x65,0x6C,0x73,0x6B,0x20,0x28,0x55,0x4B,0x29,0}; //"Engelsk (UK)" // Apple change
static UChar daFor_en_GB_ST[] = {0x45,0x6E,0x67,0x65,0x6C,0x73,0x6B,0x20,0x28,0x55,0x4B,0x29,0}; //"Engelsk (UK)"
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,0x55,0x29,0}; //"Ingles (RU)" ... // Apple change
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
#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_GB, daFor_en_GB },
    { "da", UDISPCTX_STANDARD_NAMES, UDISPCTX_CAPITALIZATION_FOR_MIDDLE_OF_SENTENCE,    UDISPCTX_LENGTH_SHORT,  en_GB, daFor_en_GB_S },
    { "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 },
#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_GB, daFor_en_GB_T },
    { "da", UDISPCTX_STANDARD_NAMES, UDISPCTX_CAPITALIZATION_FOR_BEGINNING_OF_SENTENCE, UDISPCTX_LENGTH_SHORT,  en_GB, daFor_en_GB_ST },
    { "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 },

    { "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_GB, daFor_en_GB_T },
    { "da", UDISPCTX_STANDARD_NAMES, UDISPCTX_CAPITALIZATION_FOR_UI_LIST_OR_MENU,       UDISPCTX_LENGTH_SHORT,  en_GB, daFor_en_GB_ST },
    { "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 },

    { "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_GB, daFor_en_GB },
    { "da", UDISPCTX_STANDARD_NAMES, UDISPCTX_CAPITALIZATION_FOR_STANDALONE,            UDISPCTX_LENGTH_SHORT,  en_GB, daFor_en_GB_S },
    { "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 },
 #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;
}

#endif   /*  UCONFIG_NO_FORMATTING */
Commit	Line	Data
729e4ab9 A	1	/*********************************************************************
729e4ab9 A	2	* COPYRIGHT:
57a6839d	3	* Copyright (c) 2010-2014, International Business Machines Corporation and
729e4ab9 A	4	* others. All Rights Reserved.
	5	*********************************************************************/
	6
	7	#include "locnmtst.h"
	8	#include "cstring.h"
	9
	10	/*
	11	Usage:
	12	test_assert( Test (should be TRUE) )
	13
	14	Example:
	15	test_assert(i==3);
	16
	17	the macro is ugly but makes the tests pretty.
	18	*/
	19
	20	#define test_assert(test) \
	21	{ \
	22	if(!(test)) \
	23	errln("FAIL: " #test " was not true. In " __FILE__ " on line %d", __LINE__ ); \
	24	else \
	25	logln("PASS: asserted " #test); \
	26	}
	27
	28	/*
	29	Usage:
	30	test_assert_print( Test (should be TRUE), printable )
	31
	32	Example:
	33	test_assert(i==3, toString(i));
	34
	35	the macro is ugly but makes the tests pretty.
	36	*/
	37
	38	#define test_assert_print(test,print) \
	39	{ \
	40	if(!(test)) \
	41	errln("FAIL: " #test " was not true. " + UnicodeString(print) ); \
	42	else \
	43	logln("PASS: asserted " #test "-> " + UnicodeString(print)); \
	44	}
	45
	46	#define test_assert_equal(target,value) \
	47	{ \
	48	if (UnicodeString(target)!=(value)) { \
	49	logln("unexpected value '" + (value) + "'"); \
	50	dataerrln("FAIL: " #target " == " #value " was not true. In " __FILE__ " on line %d", __LINE__); \
	51	} else { \
51004dcb	52	logln("PASS: asserted " #target " == " #value); \
729e4ab9 A	53	} \
	54	}
	55
	56	#define test_dumpLocale(l) { logln(#l " = " + UnicodeString(l.getName(), "")); }
	57
	58	LocaleDisplayNamesTest::LocaleDisplayNamesTest() {
	59	}
	60
	61	LocaleDisplayNamesTest::~LocaleDisplayNamesTest() {
	62	}
	63
	64	void LocaleDisplayNamesTest::runIndexedTest(int32_t index, UBool exec, const char* &name,
51004dcb	65	char* /par/) {
729e4ab9 A	66	switch (index) {
	67	#if !UCONFIG_NO_FORMATTING
	68	TESTCASE(0, TestCreate);
	69	TESTCASE(1, TestCreateDialect);
51004dcb A	70	TESTCASE(2, TestWithKeywordsAndEverything);
	71	TESTCASE(3, TestUldnOpen);
	72	TESTCASE(4, TestUldnOpenDialect);
	73	TESTCASE(5, TestUldnWithKeywordsAndEverything);
	74	TESTCASE(6, TestUldnComponents);
	75	TESTCASE(7, TestRootEtc);
b331163b A	76	TESTCASE(8, TestCurrencyKeyword);
	77	TESTCASE(9, TestUnknownCurrencyKeyword);
	78	TESTCASE(10, TestUntranslatedKeywords);
	79	TESTCASE(11, TestPrivateUse);
	80	TESTCASE(12, TestUldnDisplayContext);
729e4ab9 A	81	#endif
729e4ab9 A	82	default:
51004dcb A	83	name = "";
51004dcb A	84	break;
729e4ab9 A	85	}
	86	}
	87
	88	#if !UCONFIG_NO_FORMATTING
	89	void LocaleDisplayNamesTest::TestCreate() {
	90	UnicodeString temp;
	91	LocaleDisplayNames *ldn = LocaleDisplayNames::createInstance(Locale::getGermany());
	92	ldn->localeDisplayName("de_DE", temp);
	93	delete ldn;
	94	test_assert_equal("Deutsch (Deutschland)", temp);
	95	}
	96
	97	void LocaleDisplayNamesTest::TestCreateDialect() {
	98	UnicodeString temp;
	99	LocaleDisplayNames *ldn = LocaleDisplayNames::createInstance(Locale::getUS(), ULDN_DIALECT_NAMES);
	100	ldn->localeDisplayName("en_GB", temp);
	101	delete ldn;
	102	test_assert_equal("British English", temp);
	103	}
	104
	105	void LocaleDisplayNamesTest::TestWithKeywordsAndEverything() {
	106	UnicodeString temp;
	107	LocaleDisplayNames *ldn = LocaleDisplayNames::createInstance(Locale::getUS());
	108	const char *locname = "en_Hant_US_VALLEY@calendar=gregorian;collation=phonebook";
b331163b	109	const char *target = "English (Traditional, US, VALLEY, "
4388f060 A	110	"Gregorian Calendar, Phonebook Sort Order)";
	111	ldn->localeDisplayName(locname, temp);
	112	delete ldn;
	113	test_assert_equal(target, temp);
	114	}
	115
b331163b A	116	void LocaleDisplayNamesTest::TestCurrencyKeyword() {
	117	UnicodeString temp;
	118	LocaleDisplayNames *ldn = LocaleDisplayNames::createInstance(Locale::getUS());
	119	const char *locname = "ja@currency=JPY";
	120	const char *target = "Japanese (Japanese Yen)";
	121	ldn->localeDisplayName(locname, temp);
	122	delete ldn;
	123	test_assert_equal(target, temp);
	124	}
	125
	126	void LocaleDisplayNamesTest::TestUnknownCurrencyKeyword() {
4388f060 A	127	UnicodeString temp;
	128	LocaleDisplayNames *ldn = LocaleDisplayNames::createInstance(Locale::getUS());
	129	const char *locname = "de@currency=XYZ";
	130	const char *target = "German (Currency: XYZ)";
	131	ldn->localeDisplayName(locname, temp);
	132	delete ldn;
	133	test_assert_equal(target, temp);
	134	}
	135
	136	void LocaleDisplayNamesTest::TestUntranslatedKeywords() {
	137	UnicodeString temp;
	138	LocaleDisplayNames *ldn = LocaleDisplayNames::createInstance(Locale::getUS());
	139	const char *locname = "de@foo=bar";
	140	const char *target = "German (foo=bar)";
	141	ldn->localeDisplayName(locname, temp);
	142	delete ldn;
	143	test_assert_equal(target, temp);
	144	}
	145
	146	void LocaleDisplayNamesTest::TestPrivateUse() {
	147	UnicodeString temp;
	148	LocaleDisplayNames *ldn = LocaleDisplayNames::createInstance(Locale::getUS());
	149	const char *locname = "de@x=foobar";
	150	const char *target = "German (Private-Use: foobar)";
729e4ab9 A	151	ldn->localeDisplayName(locname, temp);
	152	delete ldn;
	153	test_assert_equal(target, temp);
	154	}
	155
	156	void LocaleDisplayNamesTest::TestUldnOpen() {
	157	UErrorCode status = U_ZERO_ERROR;
	158	const int32_t kMaxResultSize = 150; // long enough
	159	UChar result[150];
	160	ULocaleDisplayNames *ldn = uldn_open(Locale::getGermany().getName(), ULDN_STANDARD_NAMES, &status);
	161	int32_t len = uldn_localeDisplayName(ldn, "de_DE", result, kMaxResultSize, &status);
	162	uldn_close(ldn);
	163	test_assert(U_SUCCESS(status));
	164
	165	UnicodeString str(result, len, kMaxResultSize);
	166	test_assert_equal("Deutsch (Deutschland)", str);
	167
	168	// make sure that NULL gives us the default locale as usual
	169	ldn = uldn_open(NULL, ULDN_STANDARD_NAMES, &status);
	170	const char *locale = uldn_getLocale(ldn);
	171	if(0 != uprv_strcmp(uloc_getDefault(), locale)) {
	172	errln("uldn_getLocale(uldn_open(NULL))=%s != default locale %s\n", locale, uloc_getDefault());
	173	}
	174	uldn_close(ldn);
	175	test_assert(U_SUCCESS(status));
	176	}
	177
	178	void LocaleDisplayNamesTest::TestUldnOpenDialect() {
	179	UErrorCode status = U_ZERO_ERROR;
	180	const int32_t kMaxResultSize = 150; // long enough
	181	UChar result[150];
	182	ULocaleDisplayNames *ldn = uldn_open(Locale::getUS().getName(), ULDN_DIALECT_NAMES, &status);
	183	int32_t len = uldn_localeDisplayName(ldn, "en_GB", result, kMaxResultSize, &status);
	184	uldn_close(ldn);
	185	test_assert(U_SUCCESS(status));
	186
	187	UnicodeString str(result, len, kMaxResultSize);
	188	test_assert_equal("British English", str);
	189	}
	190
	191	void LocaleDisplayNamesTest::TestUldnWithKeywordsAndEverything() {
	192	UErrorCode status = U_ZERO_ERROR;
	193	const int32_t kMaxResultSize = 150; // long enough
	194	UChar result[150];
	195	const char *locname = "en_Hant_US_VALLEY@calendar=gregorian;collation=phonebook";
b331163b	196	const char *target = "English (Traditional, US, VALLEY, "
4388f060	197	"Gregorian Calendar, Phonebook Sort Order)";
729e4ab9 A	198	ULocaleDisplayNames *ldn = uldn_open(Locale::getUS().getName(), ULDN_STANDARD_NAMES, &status);
	199	int32_t len = uldn_localeDisplayName(ldn, locname, result, kMaxResultSize, &status);
	200	uldn_close(ldn);
	201	test_assert(U_SUCCESS(status));
	202
	203	UnicodeString str(result, len, kMaxResultSize);
	204	test_assert_equal(target, str);
	205	}
	206
	207	void LocaleDisplayNamesTest::TestUldnComponents() {
	208	UErrorCode status = U_ZERO_ERROR;
	209	const int32_t kMaxResultSize = 150; // long enough
	210	UChar result[150];
	211
	212	ULocaleDisplayNames *ldn = uldn_open(Locale::getGermany().getName(), ULDN_STANDARD_NAMES, &status);
	213	test_assert(U_SUCCESS(status));
	214	if (U_FAILURE(status)) {
	215	return;
	216	}
	217
	218	// "en_Hant_US_PRE_EURO@calendar=gregorian";
	219
	220	{
	221	int32_t len = uldn_languageDisplayName(ldn, "en", result, kMaxResultSize, &status);
	222	UnicodeString str(result, len, kMaxResultSize);
	223	test_assert_equal("Englisch", str);
	224	}
	225
	226
	227	{
	228	int32_t len = uldn_scriptDisplayName(ldn, "Hant", result, kMaxResultSize, &status);
	229	UnicodeString str(result, len, kMaxResultSize);
4388f060	230	test_assert_equal("Traditionell", str);
729e4ab9 A	231	}
	232
	233	{
	234	int32_t len = uldn_scriptCodeDisplayName(ldn, USCRIPT_TRADITIONAL_HAN, result, kMaxResultSize,
51004dcb	235	&status);
729e4ab9	236	UnicodeString str(result, len, kMaxResultSize);
4388f060	237	test_assert_equal("Traditionell", str);
729e4ab9 A	238	}
	239
	240	{
	241	int32_t len = uldn_regionDisplayName(ldn, "US", result, kMaxResultSize, &status);
	242	UnicodeString str(result, len, kMaxResultSize);
	243	test_assert_equal("Vereinigte Staaten", str);
	244	}
	245
	246	{
	247	int32_t len = uldn_variantDisplayName(ldn, "PRE_EURO", result, kMaxResultSize, &status);
	248	UnicodeString str(result, len, kMaxResultSize);
	249	test_assert_equal("PRE_EURO", str);
	250	}
	251
	252	{
	253	int32_t len = uldn_keyDisplayName(ldn, "calendar", result, kMaxResultSize, &status);
	254	UnicodeString str(result, len, kMaxResultSize);
	255	test_assert_equal("Kalender", str);
	256	}
	257
	258	{
	259	int32_t len = uldn_keyValueDisplayName(ldn, "calendar", "gregorian", result,
51004dcb	260	kMaxResultSize, &status);
729e4ab9 A	261	UnicodeString str(result, len, kMaxResultSize);
	262	test_assert_equal("Gregorianischer Kalender", str);
	263	}
	264
	265	uldn_close(ldn);
	266	}
	267
51004dcb A	268
	269	typedef struct {
	270	const char * displayLocale;
	271	UDisplayContext dialectHandling;
	272	UDisplayContext capitalization;
b331163b	273	UDisplayContext displayLength;
51004dcb A	274	const char * localeToBeNamed;
	275	const UChar * result;
	276	} LocNameDispContextItem;
	277
	278	static char en[] = "en";
b331163b	279	static char en_GB[] = "en_GB";
51004dcb A	280
51004dcb A	281	static UChar daFor_en[] = {0x65,0x6E,0x67,0x65,0x6C,0x73,0x6B,0}; //"engelsk"
b331163b A	282	static UChar daFor_en_GB[] = {0x65,0x6E,0x67,0x65,0x6C,0x73,0x6B,0x20,0x28,0x55,0x4B,0x29,0}; //"engelsk (UK)" // Apple change
	283	static UChar daFor_en_GB_S[] = {0x65,0x6E,0x67,0x65,0x6C,0x73,0x6B,0x20,0x28,0x55,0x4B,0x29,0}; //"engelsk (UK)"
	284	static UChar daFor_en_GB_D[] = {0x62,0x72,0x69,0x74,0x69,0x73,0x6B,0x20,0x65,0x6E,0x67,0x65,0x6C,0x73,0x6B,0}; //"britisk engelsk"
	285	static UChar esFor_en[] = {0x69,0x6E,0x67,0x6C,0xE9,0x73,0}; //"ingles" with acute on the e
	286	static UChar esFor_en_GB[] = {0x69,0x6E,0x67,0x6C,0xE9,0x73,0x20,0x28,0x52,0x55,0x29,0}; //"ingles (RU)" ... // Apple change
	287	static UChar esFor_en_GB_S[] = {0x69,0x6E,0x67,0x6C,0xE9,0x73,0x20,0x28,0x52,0x55,0x29,0}; //"ingles (RU)" ...
	288	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
51004dcb A	289	#if !UCONFIG_NO_BREAK_ITERATION
51004dcb A	290	static UChar daFor_en_T[] = {0x45,0x6E,0x67,0x65,0x6C,0x73,0x6B,0}; //"Engelsk"
b331163b A	291	static UChar daFor_en_GB_T[] = {0x45,0x6E,0x67,0x65,0x6C,0x73,0x6B,0x20,0x28,0x55,0x4B,0x29,0}; //"Engelsk (UK)" // Apple change
	292	static UChar daFor_en_GB_ST[] = {0x45,0x6E,0x67,0x65,0x6C,0x73,0x6B,0x20,0x28,0x55,0x4B,0x29,0}; //"Engelsk (UK)"
	293	static UChar daFor_en_GB_DT[] = {0x42,0x72,0x69,0x74,0x69,0x73,0x6B,0x20,0x65,0x6E,0x67,0x65,0x6C,0x73,0x6B,0}; //"Britisk engelsk"
	294	static UChar esFor_en_T[] = {0x49,0x6E,0x67,0x6C,0xE9,0x73,0}; //"Ingles" with acute on the e
	295	static UChar esFor_en_GB_T[] = {0x49,0x6E,0x67,0x6C,0xE9,0x73,0x20,0x28,0x52,0x55,0x29,0}; //"Ingles (RU)" ... // Apple change
	296	static UChar esFor_en_GB_ST[] = {0x49,0x6E,0x67,0x6C,0xE9,0x73,0x20,0x28,0x52,0x55,0x29,0}; //"Ingles (RU)" ...
	297	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
51004dcb A	298	#endif /* #if !UCONFIG_NO_BREAK_ITERATION */
	299
	300	static const LocNameDispContextItem ctxtItems[] = {
b331163b A	301	{ "da", UDISPCTX_STANDARD_NAMES, UDISPCTX_CAPITALIZATION_FOR_MIDDLE_OF_SENTENCE, UDISPCTX_LENGTH_FULL, en, daFor_en },
	302	{ "da", UDISPCTX_STANDARD_NAMES, UDISPCTX_CAPITALIZATION_FOR_MIDDLE_OF_SENTENCE, UDISPCTX_LENGTH_FULL, en_GB, daFor_en_GB },
	303	{ "da", UDISPCTX_STANDARD_NAMES, UDISPCTX_CAPITALIZATION_FOR_MIDDLE_OF_SENTENCE, UDISPCTX_LENGTH_SHORT, en_GB, daFor_en_GB_S },
	304	{ "da", UDISPCTX_DIALECT_NAMES, UDISPCTX_CAPITALIZATION_FOR_MIDDLE_OF_SENTENCE, UDISPCTX_LENGTH_FULL, en_GB, daFor_en_GB_D },
	305	{ "es", UDISPCTX_STANDARD_NAMES, UDISPCTX_CAPITALIZATION_FOR_MIDDLE_OF_SENTENCE, UDISPCTX_LENGTH_FULL, en, esFor_en },
	306	{ "es", UDISPCTX_STANDARD_NAMES, UDISPCTX_CAPITALIZATION_FOR_MIDDLE_OF_SENTENCE, UDISPCTX_LENGTH_FULL, en_GB, esFor_en_GB },
	307	{ "es", UDISPCTX_STANDARD_NAMES, UDISPCTX_CAPITALIZATION_FOR_MIDDLE_OF_SENTENCE, UDISPCTX_LENGTH_SHORT, en_GB, esFor_en_GB_S },
	308	{ "es", UDISPCTX_DIALECT_NAMES, UDISPCTX_CAPITALIZATION_FOR_MIDDLE_OF_SENTENCE, UDISPCTX_LENGTH_FULL, en_GB, esFor_en_GB_D },
51004dcb	309	#if !UCONFIG_NO_BREAK_ITERATION
b331163b A	310	{ "da", UDISPCTX_STANDARD_NAMES, UDISPCTX_CAPITALIZATION_FOR_BEGINNING_OF_SENTENCE, UDISPCTX_LENGTH_FULL, en, daFor_en_T },
	311	{ "da", UDISPCTX_STANDARD_NAMES, UDISPCTX_CAPITALIZATION_FOR_BEGINNING_OF_SENTENCE, UDISPCTX_LENGTH_FULL, en_GB, daFor_en_GB_T },
	312	{ "da", UDISPCTX_STANDARD_NAMES, UDISPCTX_CAPITALIZATION_FOR_BEGINNING_OF_SENTENCE, UDISPCTX_LENGTH_SHORT, en_GB, daFor_en_GB_ST },
	313	{ "da", UDISPCTX_DIALECT_NAMES, UDISPCTX_CAPITALIZATION_FOR_BEGINNING_OF_SENTENCE, UDISPCTX_LENGTH_FULL, en_GB, daFor_en_GB_DT },
	314	{ "es", UDISPCTX_STANDARD_NAMES, UDISPCTX_CAPITALIZATION_FOR_BEGINNING_OF_SENTENCE, UDISPCTX_LENGTH_FULL, en, esFor_en_T },
	315	{ "es", UDISPCTX_STANDARD_NAMES, UDISPCTX_CAPITALIZATION_FOR_BEGINNING_OF_SENTENCE, UDISPCTX_LENGTH_FULL, en_GB, esFor_en_GB_T },
	316	{ "es", UDISPCTX_STANDARD_NAMES, UDISPCTX_CAPITALIZATION_FOR_BEGINNING_OF_SENTENCE, UDISPCTX_LENGTH_SHORT, en_GB, esFor_en_GB_ST },
	317	{ "es", UDISPCTX_DIALECT_NAMES, UDISPCTX_CAPITALIZATION_FOR_BEGINNING_OF_SENTENCE, UDISPCTX_LENGTH_FULL, en_GB, esFor_en_GB_DT },
	318
	319	{ "da", UDISPCTX_STANDARD_NAMES, UDISPCTX_CAPITALIZATION_FOR_UI_LIST_OR_MENU, UDISPCTX_LENGTH_FULL, en, daFor_en_T },
	320	{ "da", UDISPCTX_STANDARD_NAMES, UDISPCTX_CAPITALIZATION_FOR_UI_LIST_OR_MENU, UDISPCTX_LENGTH_FULL, en_GB, daFor_en_GB_T },
	321	{ "da", UDISPCTX_STANDARD_NAMES, UDISPCTX_CAPITALIZATION_FOR_UI_LIST_OR_MENU, UDISPCTX_LENGTH_SHORT, en_GB, daFor_en_GB_ST },
	322	{ "da", UDISPCTX_DIALECT_NAMES, UDISPCTX_CAPITALIZATION_FOR_UI_LIST_OR_MENU, UDISPCTX_LENGTH_FULL, en_GB, daFor_en_GB_DT },
	323	{ "es", UDISPCTX_STANDARD_NAMES, UDISPCTX_CAPITALIZATION_FOR_UI_LIST_OR_MENU, UDISPCTX_LENGTH_FULL, en, esFor_en_T },
	324	{ "es", UDISPCTX_STANDARD_NAMES, UDISPCTX_CAPITALIZATION_FOR_UI_LIST_OR_MENU, UDISPCTX_LENGTH_FULL, en_GB, esFor_en_GB_T },
	325	{ "es", UDISPCTX_STANDARD_NAMES, UDISPCTX_CAPITALIZATION_FOR_UI_LIST_OR_MENU, UDISPCTX_LENGTH_SHORT, en_GB, esFor_en_GB_ST },
	326	{ "es", UDISPCTX_DIALECT_NAMES, UDISPCTX_CAPITALIZATION_FOR_UI_LIST_OR_MENU, UDISPCTX_LENGTH_FULL, en_GB, esFor_en_GB_DT },
	327
	328	{ "da", UDISPCTX_STANDARD_NAMES, UDISPCTX_CAPITALIZATION_FOR_STANDALONE, UDISPCTX_LENGTH_FULL, en, daFor_en },
	329	{ "da", UDISPCTX_STANDARD_NAMES, UDISPCTX_CAPITALIZATION_FOR_STANDALONE, UDISPCTX_LENGTH_FULL, en_GB, daFor_en_GB },
	330	{ "da", UDISPCTX_STANDARD_NAMES, UDISPCTX_CAPITALIZATION_FOR_STANDALONE, UDISPCTX_LENGTH_SHORT, en_GB, daFor_en_GB_S },
	331	{ "da", UDISPCTX_DIALECT_NAMES, UDISPCTX_CAPITALIZATION_FOR_STANDALONE, UDISPCTX_LENGTH_FULL, en_GB, daFor_en_GB_D },
	332	{ "es", UDISPCTX_STANDARD_NAMES, UDISPCTX_CAPITALIZATION_FOR_STANDALONE, UDISPCTX_LENGTH_FULL, en, esFor_en_T },
	333	{ "es", UDISPCTX_STANDARD_NAMES, UDISPCTX_CAPITALIZATION_FOR_STANDALONE, UDISPCTX_LENGTH_FULL, en_GB, esFor_en_GB_T },
	334	{ "es", UDISPCTX_STANDARD_NAMES, UDISPCTX_CAPITALIZATION_FOR_STANDALONE, UDISPCTX_LENGTH_SHORT, en_GB, esFor_en_GB_ST },
	335	{ "es", UDISPCTX_DIALECT_NAMES, UDISPCTX_CAPITALIZATION_FOR_STANDALONE, UDISPCTX_LENGTH_FULL, en_GB, esFor_en_GB_DT },
51004dcb	336	#endif /* #if !UCONFIG_NO_BREAK_ITERATION */
b331163b	337	{ NULL, (UDisplayContext)0, (UDisplayContext)0, (UDisplayContext)0, NULL, NULL }
51004dcb A	338	};
	339
	340	void LocaleDisplayNamesTest::TestUldnDisplayContext() {
	341	const LocNameDispContextItem * ctxtItemPtr;
	342	for (ctxtItemPtr = ctxtItems; ctxtItemPtr->displayLocale != NULL; ctxtItemPtr++) {
b331163b	343	UDisplayContext contexts[3] = {ctxtItemPtr->dialectHandling, ctxtItemPtr->capitalization, ctxtItemPtr->displayLength};
51004dcb	344	UErrorCode status = U_ZERO_ERROR;
b331163b	345	ULocaleDisplayNames * uldn = uldn_openForContext(ctxtItemPtr->displayLocale, contexts, 3, &status);
51004dcb A	346	if (U_FAILURE(status)) {
51004dcb A	347	errln(UnicodeString("FAIL: uldn_openForContext failed for locale ") + ctxtItemPtr->displayLocale +
b331163b A	348	", dialectHandling " + ctxtItemPtr->dialectHandling +
	349	", capitalization " + ctxtItemPtr->capitalization +
	350	", displayLength " + ctxtItemPtr->displayLength);
51004dcb A	351	} else {
	352	UDisplayContext dialectHandling = uldn_getContext(uldn, UDISPCTX_TYPE_DIALECT_HANDLING, &status);
	353	UDisplayContext capitalization = uldn_getContext(uldn, UDISPCTX_TYPE_CAPITALIZATION, &status);
b331163b	354	UDisplayContext displayLength = uldn_getContext(uldn, UDISPCTX_TYPE_DISPLAY_LENGTH, &status);
51004dcb A	355	if (U_FAILURE(status)) {
51004dcb A	356	errln(UnicodeString("FAIL: uldn_getContext status ") + (int)status);
b331163b A	357	} else if (dialectHandling != ctxtItemPtr->dialectHandling \|\|
	358	capitalization != ctxtItemPtr->capitalization \|\|
	359	displayLength != ctxtItemPtr->displayLength) {
	360	errln("FAIL: uldn_getContext retrieved incorrect dialectHandling, capitalization, or displayLength");
51004dcb A	361	} else {
	362	UChar nameBuf[ULOC_FULLNAME_CAPACITY];
	363	int32_t len = uldn_localeDisplayName(uldn, ctxtItemPtr->localeToBeNamed, nameBuf, ULOC_FULLNAME_CAPACITY, &status);
	364	if (U_FAILURE(status)) {
	365	dataerrln(UnicodeString("FAIL: uldn_localeDisplayName status: ") + u_errorName(status));
	366	} else if (u_strcmp(ctxtItemPtr->result, nameBuf) != 0) {
	367	UnicodeString exp(ctxtItemPtr->result, u_strlen(ctxtItemPtr->result));
	368	UnicodeString got(nameBuf, len);
	369	dataerrln(UnicodeString("FAIL: uldn_localeDisplayName, capitalization ") + ctxtItemPtr->capitalization +
	370	", expected " + exp + ", got " + got );
	371	}
	372	}
	373	uldn_close(uldn);
	374	}
	375	}
	376	}
	377
729e4ab9 A	378	void LocaleDisplayNamesTest::TestRootEtc() {
	379	UnicodeString temp;
	380	LocaleDisplayNames *ldn = LocaleDisplayNames::createInstance(Locale::getUS());
	381	const char *locname = "@collation=phonebook";
4388f060	382	const char *target = "Root (Phonebook Sort Order)";
729e4ab9 A	383	ldn->localeDisplayName(locname, temp);
	384	test_assert_equal(target, temp);
	385
	386	ldn->languageDisplayName("root", temp);
	387	test_assert_equal("root", temp);
	388
	389	ldn->languageDisplayName("en_GB", temp);
	390	test_assert_equal("en_GB", temp);
	391
	392	delete ldn;
	393	}
	394
	395	#endif /* UCONFIG_NO_FORMATTING */