source/test/intltest/apicoll.cpp - Issue 845603002: Update ICU to 54.1 step 1

Unified Diff: source/test/intltest/apicoll.cpp

Issue 845603002: Update ICU to 54.1 step 1 (Closed) Base URL: https://chromium.googlesource.com/chromium/deps/icu.git@master

Patch Set: remove unusued directories Created 5 years, 11 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Download patch

Index: source/test/intltest/apicoll.cpp

diff --git a/source/test/intltest/apicoll.cpp b/source/test/intltest/apicoll.cpp

index a51400b767c14485606882e0e3b22987e7ac8f2c..9d87bf07ce515a46a214628cc3073e28be507cc0 100644

--- a/source/test/intltest/apicoll.cpp

+++ b/source/test/intltest/apicoll.cpp

@@ -1,11 +1,11 @@

/********************************************************************

* COPYRIGHT:

********************************************************************/

//===============================================================================

-// File apitest.cpp

+// File apicoll.cpp

@@ -46,8 +46,6 @@

#include "cmemory.h"

#include <stdlib.h>

-#define LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0]))

void

CollationAPITest::doAssert(UBool condition, const char *message)

{

@@ -56,38 +54,6 @@ CollationAPITest::doAssert(UBool condition, const char *message)

}

-#ifdef U_USE_COLLATION_OBSOLETE_2_6

-/*

- * Test Collator::createInstance(... version...) for some locale. Called by TestProperty().

- */

-static void

-TestOpenVersion(IntlTest &test, const Locale &locale) {

- UVersionInfo version1, version2;

- Collator *collator1, *collator2;

- UErrorCode errorCode;

- errorCode=U_ZERO_ERROR;

- collator1=Collator::createInstance(locale, errorCode);

- if(U_SUCCESS(errorCode)) {

- /* get the current version */

- collator1->getVersion(version1);

- delete collator1;

- /* try to get that same version again */

- collator2=Collator::createInstance(locale, version1, errorCode);

- if(U_SUCCESS(errorCode)) {

- collator2->getVersion(version2);

- if(0!=uprv_memcmp(version1, version2, sizeof(UVersionInfo))) {

- test.errln("error: Collator::createInstance(\"%s\", (%s collator)->getVersion()) returns a different collator\n", locale.getName(), locale.getName());

- }

- delete collator2;

- } else {

- test.errln("error: Collator::createInstance(\"%s\", (%s collator)->getVersion()) fails: %s\n", locale.getName(), locale.getName(), u_errorName(errorCode));

- }

-#endif

// Collator Class Properties

// ctor, dtor, createInstance, compare, getStrength/setStrength

// getDecomposition/setDecomposition, getDisplayName

@@ -196,7 +162,16 @@ CollationAPITest::TestProperty(/* char* par */)

delete col; col = 0;

RuleBasedCollator *rcol = (RuleBasedCollator *)Collator::createInstance("da_DK",

success);

- doAssert(rcol->getRules().length() != 0, "da_DK rules does not have length 0");

+ if (U_FAILURE(success)) {

+ errcheckln(success, "Collator::createInstance(\"da_DK\") failed - %s", u_errorName(success));

+ return;

+ }

+ const UnicodeString &daRules = rcol->getRules();

+ if(daRules.isEmpty()) {

+ dataerrln("missing da_DK tailoring rule string");

+ } else {

+ doAssert(daRules.indexOf("aa") >= 0, "da_DK rules do not contain 'aa'");

+ }

delete rcol;

col = Collator::createInstance(Locale::getFrench(), success);

@@ -263,25 +238,6 @@ CollationAPITest::TestProperty(/* char* par */)

delete frCol;

delete aFrCol;

delete junk;

-#ifdef U_USE_COLLATION_OBSOLETE_2_6

- /* test Collator::createInstance(...version...) */

- TestOpenVersion(*this, "");

- TestOpenVersion(*this, "da");

- TestOpenVersion(*this, "fr");

- TestOpenVersion(*this, "ja");

- /* try some bogus version */

- versionArray[0]=0;

- versionArray[1]=0x99;

- versionArray[2]=0xc7;

- versionArray[3]=0xfe;

- col=Collator::createInstance(Locale(), versionArray, success);

- if(U_SUCCESS(success)) {

- errln("error: ucol_openVersion(bogus version) succeeded");

- delete col;

- }

-#endif

}

void

@@ -550,12 +506,35 @@ CollationAPITest::TestCollationKey(/* char* par */)

UErrorCode key1Status = U_ZERO_ERROR, key2Status = U_ZERO_ERROR;

logln("Testing weird arguments");

- col->getCollationKey(NULL, 0, sortk1, key1Status);

- // key gets reset here

+ // No string vs. empty string vs. completely-ignorable string:

+ // See ICU ticket #10495.

+ CollationKey sortkNone;

int32_t length;

- sortk1.getByteArray(length);

- doAssert(sortk1.isBogus() == FALSE && length == 0,

- "Empty string should return an empty collation key");

+ sortkNone.getByteArray(length);

+ doAssert(!sortkNone.isBogus() && length == 0,

+ "Default-constructed collation key should be empty");

+ CollationKey sortkEmpty;

+ col->getCollationKey(NULL, 0, sortkEmpty, key1Status);

+ // key gets reset here

+ const uint8_t* byteArrayEmpty = sortkEmpty.getByteArray(length);

+ doAssert(sortkEmpty.isBogus() == FALSE && length == 3 &&

+ byteArrayEmpty[0] == 1 && byteArrayEmpty[1] == 1 && byteArrayEmpty[2] == 0,

+ "Empty string should return a collation key with empty levels");

+ doAssert(sortkNone.compareTo(sortkEmpty) == Collator::LESS,

+ "Expected no collation key < collation key for empty string");

+ doAssert(sortkEmpty.compareTo(sortkNone) == Collator::GREATER,

+ "Expected collation key for empty string > no collation key");

+ CollationKey sortkIgnorable;

+ // Most control codes and CGJ are completely ignorable.

+ // A string with only completely ignorables must compare equal to an empty string.

+ col->getCollationKey(UnicodeString((UChar)1).append((UChar)0x34f), sortkIgnorable, key1Status);

+ sortkIgnorable.getByteArray(length);

+ doAssert(!sortkIgnorable.isBogus() && length == 3,

+ "Completely ignorable string should return a collation key with empty levels");

+ doAssert(sortkIgnorable.compareTo(sortkEmpty) == Collator::EQUAL,

+ "Completely ignorable string should compare equal to empty string");

// bogus key returned here

key1Status = U_ILLEGAL_ARGUMENT_ERROR;

col->getCollationKey(NULL, 0, sortk1, key1Status);

@@ -566,12 +545,15 @@ CollationAPITest::TestCollationKey(/* char* par */)

logln("Use tertiary comparison level testing ....");

col->getCollationKey(test1, sortk1, key1Status);

+ if (U_FAILURE(key1Status)) {

+ errln("getCollationKey(Abcda) failed - %s", u_errorName(key1Status));

+ return;

+ }

doAssert((sortk1.compareTo(col->getCollationKey(test2, sortk2, key2Status)))

== Collator::GREATER,

"Result should be \"Abcda\" >>> \"abcda\"");

- CollationKey sortk3(sortk2), sortkNew, sortkEmpty;

+ CollationKey sortk3(sortk2), sortkNew;

sortkNew = sortk1;

doAssert((sortk1 != sortk2), "The sort keys should be different");

@@ -838,8 +820,8 @@ void

CollationAPITest::TestOperators(/* char* par */)

{

UErrorCode success = U_ZERO_ERROR;

- UnicodeString ruleset1("< a, A < b, B < c, C; ch, cH, Ch, CH < d, D, e, E");

- UnicodeString ruleset2("< a, A < b, B < c, C < d, D, e, E");

+ UnicodeString ruleset1("&9 < a, A < b, B < c, C; ch, cH, Ch, CH < d, D, e, E");

+ UnicodeString ruleset2("&9 < a, A < b, B < c, C < d, D, e, E");

RuleBasedCollator *col1 = new RuleBasedCollator(ruleset1, success);

if (U_FAILURE(success)) {

errcheckln(success, "RuleBasedCollator creation failed. - %s", u_errorName(success));

@@ -925,16 +907,15 @@ CollationAPITest::TestDuplicate(/* char* par */)

}

Collator *col2 = col1->clone();

doAssert((*col1 == *col2), "Cloned object is not equal to the orginal");

- UnicodeString *ruleset = new UnicodeString("< a, A < b, B < c, C < d, D, e, E");

- RuleBasedCollator *col3 = new RuleBasedCollator(*ruleset, status);

- doAssert((*col1 != *col3), "Cloned object is equal to some dummy");

- *col3 = *((RuleBasedCollator*)col1);

- doAssert((*col1 == *col3), "Copied object is not equal to the orginal");

+ UnicodeString ruleset("&9 < a, A < b, B < c, C < d, D, e, E");

+ RuleBasedCollator *col3 = new RuleBasedCollator(ruleset, status);

if (U_FAILURE(status)) {

logln("Collation tailoring failed.");

return;

}

+ doAssert((*col1 != *col3), "Cloned object is equal to some dummy");

+ *col3 = *((RuleBasedCollator*)col1);

+ doAssert((*col1 == *col3), "Copied object is not equal to the orginal");

UCollationResult res;

UnicodeString first((UChar)0x0061);

@@ -942,7 +923,6 @@ CollationAPITest::TestDuplicate(/* char* par */)

UnicodeString copiedEnglishRules(((RuleBasedCollator*)col1)->getRules());

delete col1;

- delete ruleset;

// Try using the cloned collators after deleting the original data

res = col2->compare(first, second, status);

@@ -1028,6 +1008,9 @@ CollationAPITest::TestCompare(/* char* par */)

void

CollationAPITest::TestGetAll(/* char* par */)

{

+ if (logKnownIssue("10774","Side effects from utility/LocaleTest/TestGetLocale")) {

+ return;

+ }

int32_t count1, count2;

UErrorCode status = U_ZERO_ERROR;

@@ -1259,10 +1242,10 @@ void CollationAPITest::TestSortKeyOverflow() {

// 2 bytes for the Cyrillic i, 1 byte for the primary-compression terminator,

// 2 bytes for the Greek phi, and 1 byte for the NUL terminator.

uint8_t sortKey[12];

- int32_t length = col->getSortKey(i_and_phi, 2, sortKey, LENGTHOF(sortKey));

+ int32_t length = col->getSortKey(i_and_phi, 2, sortKey, UPRV_LENGTHOF(sortKey));

uint8_t sortKey2[12];

for (int32_t capacity = 0; capacity < length; ++capacity) {

- uprv_memset(sortKey2, 2, LENGTHOF(sortKey2));

+ uprv_memset(sortKey2, 2, UPRV_LENGTHOF(sortKey2));

int32_t length2 = col->getSortKey(i_and_phi, 2, sortKey2, capacity);

if (length2 != length || 0 != uprv_memcmp(sortKey, sortKey2, capacity)) {

errln("getSortKey(i_and_phi, capacity=%d) failed to write proper prefix", capacity);

@@ -1329,7 +1312,7 @@ void CollationAPITest::TestMaxExpansion()

if (order == 0)

order = iter->previous(status);

- while (U_SUCCESS(status) && iter->previous(status) != UCOL_NULLORDER) {

+ while (U_SUCCESS(status) && iter->previous(status) != CollationElementIterator::NULLORDER) {

count ++;

}

@@ -1545,7 +1528,9 @@ void CollationAPITest::TestVariableTopSetting() {

UChar vt[256] = { 0 };

- Collator *coll = Collator::createInstance(status);

+ // Use the root collator, not the default collator.

+ // This test fails with en_US_POSIX which tailors the dollar sign after 'A'.

+ Collator *coll = Collator::createInstance(Locale::getRoot(), status);

if(U_FAILURE(status)) {

delete coll;

errcheckln(status, "Collator creation failed with error %s", u_errorName(status));

@@ -1554,19 +1539,41 @@ void CollationAPITest::TestVariableTopSetting() {

uint32_t oldVarTop = coll->getVariableTop(status);

+ // ICU 53+: The character must be in a supported reordering group,

+ // and the variable top is pinned to the end of that group.

vt[0] = 0x0041;

+ (void)coll->setVariableTop(vt, 1, status);

+ if(status != U_ILLEGAL_ARGUMENT_ERROR) {

+ errln("setVariableTop(letter) did not detect illegal argument - %s", u_errorName(status));

+ }

+ status = U_ZERO_ERROR;

+ vt[0] = 0x24; // dollar sign (currency symbol)

uint32_t newVarTop = coll->setVariableTop(vt, 1, status);

- if((newVarTop & 0xFFFF0000) != (coll->getVariableTop(status) & 0xFFFF0000)) {

- errln("Didn't set vartop properly\n");

+ if(newVarTop != coll->getVariableTop(status)) {

+ errln("setVariableTop(dollar sign) != following getVariableTop()");

}

+ UnicodeString dollar((UChar)0x24);

+ UnicodeString euro((UChar)0x20AC);

+ uint32_t newVarTop2 = coll->setVariableTop(euro, status);

+ assertEquals("setVariableTop(Euro sign) == following getVariableTop()",

+ (int64_t)newVarTop2, (int64_t)coll->getVariableTop(status));

+ assertEquals("setVariableTop(Euro sign) == setVariableTop(dollar sign) (should pin to top of currency group)",

+ (int64_t)newVarTop2, (int64_t)newVarTop);

+ coll->setAttribute(UCOL_ALTERNATE_HANDLING, UCOL_SHIFTED, status);

+ assertEquals("empty==dollar", UCOL_EQUAL, coll->compare(UnicodeString(), dollar));

+ assertEquals("empty==euro", UCOL_EQUAL, coll->compare(UnicodeString(), euro));

+ assertEquals("dollar<zero", UCOL_LESS, coll->compare(dollar, UnicodeString((UChar)0x30)));

coll->setVariableTop(oldVarTop, status);

uint32_t newerVarTop = coll->setVariableTop(UnicodeString(vt, 1), status);

- if((newVarTop & 0xFFFF0000) != (newerVarTop & 0xFFFF0000)) {

+ if(newVarTop != newerVarTop) {

errln("Didn't set vartop properly from UnicodeString!\n");

}

@@ -1574,13 +1581,62 @@ void CollationAPITest::TestVariableTopSetting() {

}

+void CollationAPITest::TestMaxVariable() {

+ UErrorCode errorCode = U_ZERO_ERROR;

+ LocalPointer<Collator> coll(Collator::createInstance(Locale::getRoot(), errorCode));

+ if(U_FAILURE(errorCode)) {

+ errcheckln(errorCode, "Collator creation failed with error %s", u_errorName(errorCode));

+ return;

+ }

+ (void)coll->setMaxVariable(UCOL_REORDER_CODE_OTHERS, errorCode);

+ if(errorCode != U_ILLEGAL_ARGUMENT_ERROR) {

+ errln("setMaxVariable(others) did not detect illegal argument - %s", u_errorName(errorCode));

+ }

+ errorCode = U_ZERO_ERROR;

+ (void)coll->setMaxVariable(UCOL_REORDER_CODE_CURRENCY, errorCode);

+ if(UCOL_REORDER_CODE_CURRENCY != coll->getMaxVariable()) {

+ errln("setMaxVariable(currency) != following getMaxVariable()");

+ }

+ coll->setAttribute(UCOL_ALTERNATE_HANDLING, UCOL_SHIFTED, errorCode);

+ assertEquals("empty==dollar", UCOL_EQUAL, coll->compare(UnicodeString(), UnicodeString((UChar)0x24)));

+ assertEquals("empty==euro", UCOL_EQUAL, coll->compare(UnicodeString(), UnicodeString((UChar)0x20AC)));

+ assertEquals("dollar<zero", UCOL_LESS, coll->compare(UnicodeString((UChar)0x24), UnicodeString((UChar)0x30)));

void CollationAPITest::TestGetLocale() {

UErrorCode status = U_ZERO_ERROR;

const char *rules = "&a<x<y<z";

UChar rlz[256] = {0};

- Collator *coll = NULL;

- Locale locale;

+ Collator *coll = Collator::createInstance("root", status);

+ if(U_FAILURE(status)) {

+ dataerrln("Failed to open collator for \"root\" with %s", u_errorName(status));

+ return;

+ }

+ Locale locale = coll->getLocale(ULOC_ACTUAL_LOCALE, status);

+ if(locale != Locale::getRoot()) {

+ errln("Collator::createInstance(\"root\").getLocale(actual) != Locale::getRoot(); "

+ "getLocale().getName() = \"%s\"",

+ locale.getName());

+ }

+ delete coll;

+ coll = Collator::createInstance("", status);

+ if(U_FAILURE(status)) {

+ dataerrln("Failed to open collator for \"\" with %s", u_errorName(status));

+ return;

+ }

+ locale = coll->getLocale(ULOC_ACTUAL_LOCALE, status);

+ if(locale != Locale::getRoot()) {

+ errln("Collator::createInstance(\"\").getLocale(actual) != Locale::getRoot(); "

+ "getLocale().getName() = \"%s\"",

+ locale.getName());

+ }

+ delete coll;

int32_t i = 0;

@@ -1589,34 +1645,64 @@ void CollationAPITest::TestGetLocale() {

const char* validLocale;

const char* actualLocale;

} testStruct[] = {

- { "sr_YU", "sr_YU", "root" },

- { "sh_YU", "sh_YU", "sh" },

- { "en_US_CALIFORNIA", "en_US", "root" },

- { "fr_FR_NONEXISTANT", "fr_FR", "fr" }

+ // Note: Locale::getRoot().getName() == "" not "root".

+ { "de_DE", "de", "" },

+ { "sr_RS", "sr_Cyrl_RS", "sr" },

+ { "en_US_CALIFORNIA", "en_US", "" },

+ { "fr_FR_NONEXISTANT", "fr", "" },

+ // pinyin is the default, therefore suppressed.

+ { "zh_CN", "zh_Hans_CN", "zh" },

+ // zh_Hant has default=stroke but the data is in zh.

+ { "zh_TW", "zh_Hant_TW", "zh@collation=stroke" },

+ { "zh_TW@collation=pinyin", "zh_Hant_TW@collation=pinyin", "zh" },

+ { "zh_CN@collation=stroke", "zh_Hans_CN@collation=stroke", "zh@collation=stroke" }

};

u_unescape(rules, rlz, 256);

/* test opening collators for different locales */

- for(i = 0; i<(int32_t)(sizeof(testStruct)/sizeof(testStruct[0])); i++) {

+ for(i = 0; i<(int32_t)UPRV_LENGTHOF(testStruct); i++) {

status = U_ZERO_ERROR;

coll = Collator::createInstance(testStruct[i].requestedLocale, status);

if(U_FAILURE(status)) {

- log("Failed to open collator for %s with %s\n", testStruct[i].requestedLocale, u_errorName(status));

+ errln("Failed to open collator for %s with %s", testStruct[i].requestedLocale, u_errorName(status));

delete coll;

continue;

}

+ // The requested locale may be the same as the valid locale,

+ // or may not be supported at all. See ticket #10477.

locale = coll->getLocale(ULOC_REQUESTED_LOCALE, status);

- if(locale != testStruct[i].requestedLocale) {

- log("[Coll %s]: Error in requested locale, expected %s, got %s\n", testStruct[i].requestedLocale, testStruct[i].requestedLocale, locale.getName());

+ if(U_SUCCESS(status) &&

+ locale != testStruct[i].requestedLocale && locale != testStruct[i].validLocale) {

+ errln("[Coll %s]: Error in requested locale, expected %s or %s, got %s",

+ testStruct[i].requestedLocale,

+ testStruct[i].requestedLocale, testStruct[i].validLocale, locale.getName());

}

+ status = U_ZERO_ERROR;

locale = coll->getLocale(ULOC_VALID_LOCALE, status);

if(locale != testStruct[i].validLocale) {

- log("[Coll %s]: Error in valid locale, expected %s, got %s\n", testStruct[i].requestedLocale, testStruct[i].validLocale, locale.getName());

+ errln("[Coll %s]: Error in valid locale, expected %s, got %s",

+ testStruct[i].requestedLocale, testStruct[i].validLocale, locale.getName());

}

locale = coll->getLocale(ULOC_ACTUAL_LOCALE, status);

if(locale != testStruct[i].actualLocale) {

- log("[Coll %s]: Error in actual locale, expected %s, got %s\n", testStruct[i].requestedLocale, testStruct[i].actualLocale, locale.getName());

+ errln("[Coll %s]: Error in actual locale, expected %s, got %s",

+ testStruct[i].requestedLocale, testStruct[i].actualLocale, locale.getName());

+ }

+ // If we open a collator for the actual locale, we should get an equivalent one again.

+ LocalPointer<Collator> coll2(Collator::createInstance(locale, status));

+ if(U_FAILURE(status)) {

+ errln("Failed to open collator for actual locale \"%s\" with %s",

+ locale.getName(), u_errorName(status));

+ } else {

+ Locale actual2 = coll2->getLocale(ULOC_ACTUAL_LOCALE, status);

+ if(actual2 != locale) {

+ errln("[Coll actual \"%s\"]: Error in actual locale, got different one: \"%s\"",

+ locale.getName(), actual2.getName());

+ }

+ if(*coll2 != *coll) {

+ errln("[Coll actual \"%s\"]: Got different collator than before", locale.getName());

+ }

}

delete coll;

}

@@ -1626,23 +1712,20 @@ void CollationAPITest::TestGetLocale() {

Collator *defaultColl = Collator::createInstance((const Locale)NULL, status);

coll = Collator::createInstance("blahaha", status);

if(U_FAILURE(status)) {

- log("Failed to open collator with %s\n", u_errorName(status));

+ errln("Failed to open collator with %s", u_errorName(status));

delete coll;

delete defaultColl;

return;

}

- if(coll->getLocale(ULOC_REQUESTED_LOCALE, status) != "blahaha") {

- log("Nonexisting locale didn't preserve the requested locale\n");

- }

if(coll->getLocale(ULOC_VALID_LOCALE, status) !=

defaultColl->getLocale(ULOC_VALID_LOCALE, status)) {

- log("Valid locale for nonexisting locale locale collator differs "

- "from valid locale for default collator\n");

+ errln("Valid locale for nonexisting locale locale collator differs "

+ "from valid locale for default collator");

}

if(coll->getLocale(ULOC_ACTUAL_LOCALE, status) !=

defaultColl->getLocale(ULOC_ACTUAL_LOCALE, status)) {

- log("Actual locale for nonexisting locale locale collator differs "

- "from actual locale for default collator\n");

+ errln("Actual locale for nonexisting locale locale collator differs "

+ "from actual locale for default collator");

}

delete coll;

delete defaultColl;

@@ -1653,16 +1736,17 @@ void CollationAPITest::TestGetLocale() {

/* collator instantiated from rules should have all three locales NULL */

coll = new RuleBasedCollator(rlz, status);

locale = coll->getLocale(ULOC_REQUESTED_LOCALE, status);

- if(!locale.isBogus()) {

- log("For collator instantiated from rules, requested locale %s is not bogus\n", locale.getName());

+ if(U_SUCCESS(status) && !locale.isBogus()) {

+ errln("For collator instantiated from rules, requested locale %s is not bogus", locale.getName());

}

+ status = U_ZERO_ERROR;

locale = coll->getLocale(ULOC_VALID_LOCALE, status);

if(!locale.isBogus()) {

- log("For collator instantiated from rules, valid locale %s is not bogus\n", locale.getName());

+ errln("For collator instantiated from rules, valid locale %s is not bogus", locale.getName());

}

locale = coll->getLocale(ULOC_ACTUAL_LOCALE, status);

if(!locale.isBogus()) {

- log("For collator instantiated from rules, actual locale %s is not bogus\n", locale.getName());

+ errln("For collator instantiated from rules, actual locale %s is not bogus", locale.getName());

}

delete coll;

}

@@ -1829,23 +1913,22 @@ void CollationAPITest::TestGetTailoredSet()

{ "& S < \\u0161 <<< \\u0160", { "\\u0161", "s\\u030C", "\\u0160", "S\\u030C" }, 4}

};

- uint32_t i = 0, j = 0;

+ int32_t i = 0, j = 0;

UErrorCode status = U_ZERO_ERROR;

- RuleBasedCollator *coll = NULL;

UnicodeString buff;

UnicodeSet *set = NULL;

- for(i = 0; i < sizeof(setTest)/sizeof(setTest[0]); i++) {

- buff = UnicodeString(setTest[i].rules, "").unescape();

- coll = new RuleBasedCollator(buff, status);

+ for(i = 0; i < UPRV_LENGTHOF(setTest); i++) {

+ buff = UnicodeString(setTest[i].rules, -1, US_INV).unescape();

+ RuleBasedCollator coll(buff, status);

if(U_SUCCESS(status)) {

- set = coll->getTailoredSet(status);

- if(set->size() != setTest[i].testsize) {

- errln("Tailored set size different (%d) than expected (%d)", set->size(), setTest[i].testsize);

+ set = coll.getTailoredSet(status);

+ if(set->size() < setTest[i].testsize) {

+ errln("Tailored set size smaller (%d) than expected (%d)", set->size(), setTest[i].testsize);

}

- for(j = 0; j < (uint32_t)setTest[i].testsize; j++) {

- buff = UnicodeString(setTest[i].tests[j], "").unescape();

+ for(j = 0; j < setTest[i].testsize; j++) {

+ buff = UnicodeString(setTest[i].tests[j], -1, US_INV).unescape();

if(!set->contains(buff)) {

errln("Tailored set doesn't contain %s... It should", setTest[i].tests[j]);

}

@@ -1854,7 +1937,6 @@ void CollationAPITest::TestGetTailoredSet()

} else {

errcheckln(status, "Couldn't open collator with rules %s - %s", setTest[i].rules, u_errorName(status));

}

- delete coll;

}

@@ -2270,6 +2352,51 @@ void CollationAPITest::TestClone() {

delete c2;

}

+void CollationAPITest::TestCloneBinary() {

+ IcuTestErrorCode errorCode(*this, "TestCloneBinary");

+ LocalPointer<Collator> root(Collator::createInstance(Locale::getRoot(), errorCode));

+ LocalPointer<Collator> coll(Collator::createInstance("de@collation=phonebook", errorCode));

+ if(errorCode.logDataIfFailureAndReset("Collator::createInstance(de@collation=phonebook)")) {

+ return;

+ }

+ RuleBasedCollator *rbRoot = dynamic_cast<RuleBasedCollator *>(root.getAlias());

+ RuleBasedCollator *rbc = dynamic_cast<RuleBasedCollator *>(coll.getAlias());

+ if(rbRoot == NULL || rbc == NULL) {

+ infoln("root or de@collation=phonebook is not a RuleBasedCollator");

+ return;

+ }

+ rbc->setAttribute(UCOL_STRENGTH, UCOL_PRIMARY, errorCode);

+ UnicodeString uUmlaut((UChar)0xfc);

+ UnicodeString ue = UNICODE_STRING_SIMPLE("ue");

+ assertEquals("rbc/primary: u-umlaut==ue", UCOL_EQUAL, rbc->compare(uUmlaut, ue, errorCode));

+ uint8_t bin[25000];

+ int32_t binLength = rbc->cloneBinary(bin, UPRV_LENGTHOF(bin), errorCode);

+ if(errorCode.logDataIfFailureAndReset("rbc->cloneBinary()")) {

+ return;

+ }

+ logln("rbc->cloneBinary() -> %d bytes", (int)binLength);

+ RuleBasedCollator rbc2(bin, binLength, rbRoot, errorCode);

+ if(errorCode.logDataIfFailureAndReset("RuleBasedCollator(rbc binary)")) {

+ return;

+ }

+ assertEquals("rbc2.strength==primary", UCOL_PRIMARY, rbc2.getAttribute(UCOL_STRENGTH, errorCode));

+ assertEquals("rbc2: u-umlaut==ue", UCOL_EQUAL, rbc2.compare(uUmlaut, ue, errorCode));

+ assertTrue("rbc==rbc2", *rbc == rbc2);

+ uint8_t bin2[25000];

+ int32_t bin2Length = rbc2.cloneBinary(bin2, UPRV_LENGTHOF(bin2), errorCode);

+ assertEquals("len(rbc binary)==len(rbc2 binary)", binLength, bin2Length);

+ assertTrue("rbc binary==rbc2 binary", binLength == bin2Length && memcmp(bin, bin2, binLength) == 0);

+ RuleBasedCollator rbc3(bin, -1, rbRoot, errorCode);

+ if(errorCode.logDataIfFailureAndReset("RuleBasedCollator(rbc binary, length<0)")) {

+ return;

+ }

+ assertEquals("rbc3.strength==primary", UCOL_PRIMARY, rbc3.getAttribute(UCOL_STRENGTH, errorCode));

+ assertEquals("rbc3: u-umlaut==ue", UCOL_EQUAL, rbc3.compare(uUmlaut, ue, errorCode));

+ assertTrue("rbc==rbc3", *rbc == rbc3);

void CollationAPITest::TestIterNumeric() {

// Regression test for ticket #9915.

// The collation code sometimes masked the continuation marker away

@@ -2293,6 +2420,53 @@ void CollationAPITest::TestIterNumeric() {

assertEquals("40<72", (int32_t)UCOL_LESS, (int32_t)result);

}

+void CollationAPITest::TestBadKeywords() {

+ // Test locale IDs with errors.

+ // Valid locale IDs are tested via data-driven tests.

+ UErrorCode errorCode = U_ZERO_ERROR;

+ Locale bogusLocale(Locale::getRoot());

+ bogusLocale.setToBogus();

+ LocalPointer<Collator> coll(Collator::createInstance(bogusLocale, errorCode));

+ if(errorCode != U_ILLEGAL_ARGUMENT_ERROR) {

+ errln("Collator::createInstance(bogus locale) did not fail as expected - %s",

+ u_errorName(errorCode));

+ }

+ // Unknown value.

+ const char *localeID = "it-u-ks-xyz";

+ errorCode = U_ZERO_ERROR;

+ coll.adoptInstead(Collator::createInstance(localeID, errorCode));

+ if(errorCode != U_ILLEGAL_ARGUMENT_ERROR) {

+ dataerrln("Collator::createInstance(%s) did not fail as expected - %s",

+ localeID, u_errorName(errorCode));

+ }

+ // Unsupported attributes.

+ localeID = "it@colHiraganaQuaternary=true";

+ errorCode = U_ZERO_ERROR;

+ coll.adoptInstead(Collator::createInstance(localeID, errorCode));

+ if(errorCode != U_UNSUPPORTED_ERROR) {

+ if (errorCode == U_FILE_ACCESS_ERROR) {

+ dataerrln("Collator::createInstance(it@colHiraganaQuaternary=true) : %s", u_errorName(errorCode));

+ } else {

+ errln("Collator::createInstance(%s) did not fail as expected - %s",

+ localeID, u_errorName(errorCode));

+ }

+ localeID = "it-u-vt-u24";

+ errorCode = U_ZERO_ERROR;

+ coll.adoptInstead(Collator::createInstance(localeID, errorCode));

+ if(errorCode != U_UNSUPPORTED_ERROR) {

+ if (errorCode == U_ILLEGAL_ARGUMENT_ERROR || errorCode == U_FILE_ACCESS_ERROR) {

+ dataerrln("Collator::createInstance(it-u-vt-u24) : %s", u_errorName(errorCode));

+ } else {

+ errln("Collator::createInstance(%s) did not fail as expected - %s",

+ localeID, u_errorName(errorCode));

+ }

void CollationAPITest::dump(UnicodeString msg, RuleBasedCollator* c, UErrorCode& status) {

const char* bigone = "One";

const char* littleone = "one";

@@ -2322,6 +2496,7 @@ void CollationAPITest::runIndexedTest( int32_t index, UBool exec, const char* &n

TESTCASE_AUTO(TestDisplayName);

TESTCASE_AUTO(TestAttribute);

TESTCASE_AUTO(TestVariableTopSetting);

+ TESTCASE_AUTO(TestMaxVariable);

TESTCASE_AUTO(TestRules);

TESTCASE_AUTO(TestGetLocale);

TESTCASE_AUTO(TestBounds);

@@ -2330,7 +2505,9 @@ void CollationAPITest::runIndexedTest( int32_t index, UBool exec, const char* &n

TESTCASE_AUTO(TestSubclass);

TESTCASE_AUTO(TestNULLCharTailoring);

TESTCASE_AUTO(TestClone);

+ TESTCASE_AUTO(TestCloneBinary);

TESTCASE_AUTO(TestIterNumeric);

+ TESTCASE_AUTO(TestBadKeywords);

TESTCASE_AUTO_END;

}

« no previous file with comments | « source/test/intltest/apicoll.h ('k') | source/test/intltest/astrotst.cpp » ('j') | no next file with comments »