Index: source/test/intltest/regcoll.cpp |
diff --git a/source/test/intltest/regcoll.cpp b/source/test/intltest/regcoll.cpp |
index 4028f43602dad29cd22676907278ea3926d7dbe6..0cc127e704a81ee38a0d16906e2f912e0f7a6777 100644 |
--- a/source/test/intltest/regcoll.cpp |
+++ b/source/test/intltest/regcoll.cpp |
@@ -1,6 +1,6 @@ |
/******************************************************************** |
* COPYRIGHT: |
- * Copyright (c) 1997-2011, International Business Machines Corporation and |
+ * Copyright (c) 1997-2014, International Business Machines Corporation and |
* others. All Rights Reserved. |
********************************************************************/ |
@@ -9,6 +9,7 @@ |
#if !UCONFIG_NO_COLLATION |
#include "unicode/coll.h" |
+#include "unicode/localpointer.h" |
#include "unicode/tblcoll.h" |
#include "unicode/unistr.h" |
#include "unicode/sortkey.h" |
@@ -84,19 +85,10 @@ void CollationRegressionTest::Test4048446(/* char* par */) |
// |
void CollationRegressionTest::Test4051866(/* char* par */) |
{ |
-/* |
- RuleBasedCollator c1 = new RuleBasedCollator("< o " |
- +"& oe ,o\u3080" |
- +"& oe ,\u1530 ,O" |
- +"& OE ,O\u3080" |
- +"& OE ,\u1520" |
- +"< p ,P"); |
-*/ |
- |
UnicodeString rules; |
UErrorCode status = U_ZERO_ERROR; |
- rules += "< o "; |
+ rules += "&n < o "; |
rules += "& oe ,o"; |
rules += (UChar)0x3080; |
rules += "& oe ,"; |
@@ -109,19 +101,20 @@ void CollationRegressionTest::Test4051866(/* char* par */) |
rules += "< p ,P"; |
// Build a collator containing expanding characters |
- RuleBasedCollator *c1 = new RuleBasedCollator(rules, status); |
+ LocalPointer<RuleBasedCollator> c1(new RuleBasedCollator(rules, status)); |
// Build another using the rules from the first |
- RuleBasedCollator *c2 = new RuleBasedCollator(c1->getRules(), status); |
+ LocalPointer<RuleBasedCollator> c2(new RuleBasedCollator(c1->getRules(), status)); |
+ if (U_FAILURE(status)) { |
+ errln("RuleBasedCollator(rule string) failed - %s", u_errorName(status)); |
+ return; |
+ } |
// Make sure they're the same |
if (!(c1->getRules() == c2->getRules())) |
{ |
errln("Rules are not equal"); |
} |
- |
- delete c2; |
- delete c1; |
} |
// @bug 4053636 |
@@ -273,7 +266,7 @@ void CollationRegressionTest::Test4059820(/* char* par */) |
UErrorCode status = U_ZERO_ERROR; |
RuleBasedCollator *c = NULL; |
- UnicodeString rules = "< a < b , c/a < d < z"; |
+ UnicodeString rules = "&9 < a < b , c/a < d < z"; |
c = new RuleBasedCollator(rules, status); |
@@ -301,7 +294,7 @@ void CollationRegressionTest::Test4060154(/* char* par */) |
UErrorCode status = U_ZERO_ERROR; |
UnicodeString rules; |
- rules += "< g, G < h, H < i, I < j, J"; |
+ rules += "&f < g, G < h, H < i, I < j, J"; |
rules += " & H < "; |
rules += (UChar)0x0131; |
rules += ", "; |
@@ -544,7 +537,7 @@ void CollationRegressionTest::Test4079231(/* char* par */) |
void CollationRegressionTest::Test4078588(/* char *par */) |
{ |
UErrorCode status = U_ZERO_ERROR; |
- RuleBasedCollator *rbc = new RuleBasedCollator((UnicodeString)"< a < bb", status); |
+ RuleBasedCollator *rbc = new RuleBasedCollator("&9 < a < bb", status); |
if (rbc == NULL || U_FAILURE(status)) |
{ |
@@ -616,7 +609,7 @@ void CollationRegressionTest::Test4087241(/* char* par */) |
static const UChar tests[][CollationRegressionTest::MAX_TOKEN_LEN] = |
{ |
{0x7a, 0}, {0x3c, 0}, {0x00E6, 0}, // z < ae |
- {0x61, 0x0308, 0}, {0x3c, 0}, {0x61, 0x030A, 0}, // a-unlaut < a-ring |
+ {0x61, 0x0308, 0}, {0x3c, 0}, {0x61, 0x030A, 0}, // a-umlaut < a-ring |
{0x59, 0}, {0x3c, 0}, {0x75, 0x0308, 0}, // Y < u-umlaut |
}; |
@@ -711,7 +704,7 @@ void CollationRegressionTest::Test4101940(/* char* par */) |
{ |
UErrorCode status = U_ZERO_ERROR; |
RuleBasedCollator *c = NULL; |
- UnicodeString rules = "< a < b"; |
+ UnicodeString rules = "&9 < a < b"; |
UnicodeString nothing = ""; |
c = new RuleBasedCollator(rules, status); |
@@ -1078,6 +1071,104 @@ void CollationRegressionTest::Test4146160(/* char* par */) |
#endif |
} |
+void CollationRegressionTest::Test4179216() { |
+ // you can position a CollationElementIterator in the middle of |
+ // a contracting character sequence, yielding a bogus collation |
+ // element |
+ IcuTestErrorCode errorCode(*this, "Test4179216"); |
+ RuleBasedCollator coll(en_us->getRules() + " & C < ch , cH , Ch , CH < cat < crunchy", errorCode); |
+ UnicodeString testText = "church church catcatcher runcrunchynchy"; |
+ CollationElementIterator *iter = coll.createCollationElementIterator(testText); |
+ |
+ // test that the "ch" combination works properly |
+ iter->setOffset(4, errorCode); |
+ int32_t elt4 = CollationElementIterator::primaryOrder(iter->next(errorCode)); |
+ |
+ iter->reset(); |
+ int32_t elt0 = CollationElementIterator::primaryOrder(iter->next(errorCode)); |
+ |
+ iter->setOffset(5, errorCode); |
+ int32_t elt5 = CollationElementIterator::primaryOrder(iter->next(errorCode)); |
+ |
+ // Compares and prints only 16-bit primary weights. |
+ if (elt4 != elt0 || elt5 != elt0) { |
+ errln("The collation elements at positions 0 (0x%04x), " |
+ "4 (0x%04x), and 5 (0x%04x) don't match.", |
+ elt0, elt4, elt5); |
+ } |
+ |
+ // test that the "cat" combination works properly |
+ iter->setOffset(14, errorCode); |
+ int32_t elt14 = CollationElementIterator::primaryOrder(iter->next(errorCode)); |
+ |
+ iter->setOffset(15, errorCode); |
+ int32_t elt15 = CollationElementIterator::primaryOrder(iter->next(errorCode)); |
+ |
+ iter->setOffset(16, errorCode); |
+ int32_t elt16 = CollationElementIterator::primaryOrder(iter->next(errorCode)); |
+ |
+ iter->setOffset(17, errorCode); |
+ int32_t elt17 = CollationElementIterator::primaryOrder(iter->next(errorCode)); |
+ |
+ iter->setOffset(18, errorCode); |
+ int32_t elt18 = CollationElementIterator::primaryOrder(iter->next(errorCode)); |
+ |
+ iter->setOffset(19, errorCode); |
+ int32_t elt19 = CollationElementIterator::primaryOrder(iter->next(errorCode)); |
+ |
+ // Compares and prints only 16-bit primary weights. |
+ if (elt14 != elt15 || elt14 != elt16 || elt14 != elt17 |
+ || elt14 != elt18 || elt14 != elt19) { |
+ errln("\"cat\" elements don't match: elt14 = 0x%04x, " |
+ "elt15 = 0x%04x, elt16 = 0x%04x, elt17 = 0x%04x, " |
+ "elt18 = 0x%04x, elt19 = 0x%04x", |
+ elt14, elt15, elt16, elt17, elt18, elt19); |
+ } |
+ |
+ // now generate a complete list of the collation elements, |
+ // first using next() and then using setOffset(), and |
+ // make sure both interfaces return the same set of elements |
+ iter->reset(); |
+ |
+ int32_t elt = iter->next(errorCode); |
+ int32_t count = 0; |
+ while (elt != CollationElementIterator::NULLORDER) { |
+ ++count; |
+ elt = iter->next(errorCode); |
+ } |
+ |
+ LocalArray<UnicodeString> nextElements(new UnicodeString[count]); |
+ LocalArray<UnicodeString> setOffsetElements(new UnicodeString[count]); |
+ int32_t lastPos = 0; |
+ |
+ iter->reset(); |
+ elt = iter->next(errorCode); |
+ count = 0; |
+ while (elt != CollationElementIterator::NULLORDER) { |
+ nextElements[count++] = testText.tempSubStringBetween(lastPos, iter->getOffset()); |
+ lastPos = iter->getOffset(); |
+ elt = iter->next(errorCode); |
+ } |
+ int32_t nextElementsLength = count; |
+ count = 0; |
+ for (int32_t i = 0; i < testText.length(); ) { |
+ iter->setOffset(i, errorCode); |
+ lastPos = iter->getOffset(); |
+ elt = iter->next(errorCode); |
+ setOffsetElements[count++] = testText.tempSubStringBetween(lastPos, iter->getOffset()); |
+ i = iter->getOffset(); |
+ } |
+ for (int32_t i = 0; i < nextElementsLength; i++) { |
+ if (nextElements[i] == setOffsetElements[i]) { |
+ logln(nextElements[i]); |
+ } else { |
+ errln(UnicodeString("Error: next() yielded ") + nextElements[i] + |
+ ", but setOffset() yielded " + setOffsetElements[i]); |
+ } |
+ } |
+ delete iter; |
+} |
+ |
// Ticket 7189 |
// |
// nextSortKeyPart incorrect for EO_S1 collation |
@@ -1216,7 +1307,33 @@ void CollationRegressionTest::caseFirstCompressionSub(Collator *col, UnicodeStri |
} |
} |
+void CollationRegressionTest::TestTrailingComment() { |
+ // ICU ticket #8070: |
+ // Check that the rule parser handles a comment without terminating end-of-line. |
+ IcuTestErrorCode errorCode(*this, "TestTrailingComment"); |
+ RuleBasedCollator coll(UNICODE_STRING_SIMPLE("&c<b#comment1\n<a#comment2"), errorCode); |
+ UnicodeString a((UChar)0x61), b((UChar)0x62), c((UChar)0x63); |
+ assertTrue("c<b", coll.compare(c, b) < 0); |
+ assertTrue("b<a", coll.compare(b, a) < 0); |
+} |
+void CollationRegressionTest::TestBeforeWithTooStrongAfter() { |
+ // ICU ticket #9959: |
+ // Forbid rules with a before-reset followed by a stronger relation. |
+ IcuTestErrorCode errorCode(*this, "TestBeforeWithTooStrongAfter"); |
+ RuleBasedCollator before2(UNICODE_STRING_SIMPLE("&[before 2]x<<q<p"), errorCode); |
+ if(errorCode.isSuccess()) { |
+ errln("should forbid before-2-reset followed by primary relation"); |
+ } else { |
+ errorCode.reset(); |
+ } |
+ RuleBasedCollator before3(UNICODE_STRING_SIMPLE("&[before 3]x<<<q<<s<p"), errorCode); |
+ if(errorCode.isSuccess()) { |
+ errln("should forbid before-3-reset followed by primary or secondary relation"); |
+ } else { |
+ errorCode.reset(); |
+ } |
+} |
void CollationRegressionTest::compareArray(Collator &c, |
const UChar tests[][CollationRegressionTest::MAX_TOKEN_LEN], |
@@ -1315,48 +1432,49 @@ void CollationRegressionTest::runIndexedTest(int32_t index, UBool exec, const ch |
logln("Collation Regression Tests: "); |
} |
- if(en_us) { |
- switch (index) |
- { |
- case 0: name = "Test4048446"; if (exec) Test4048446(/* par */); break; |
- case 1: name = "Test4051866"; if (exec) Test4051866(/* par */); break; |
- case 2: name = "Test4053636"; if (exec) Test4053636(/* par */); break; |
- case 3: name = "Test4054238"; if (exec) Test4054238(/* par */); break; |
- case 4: name = "Test4054734"; if (exec) Test4054734(/* par */); break; |
- case 5: name = "Test4054736"; if (exec) Test4054736(/* par */); break; |
- case 6: name = "Test4058613"; if (exec) Test4058613(/* par */); break; |
- case 7: name = "Test4059820"; if (exec) Test4059820(/* par */); break; |
- case 8: name = "Test4060154"; if (exec) Test4060154(/* par */); break; |
- case 9: name = "Test4062418"; if (exec) Test4062418(/* par */); break; |
- case 10: name = "Test4065540"; if (exec) Test4065540(/* par */); break; |
- case 11: name = "Test4066189"; if (exec) Test4066189(/* par */); break; |
- case 12: name = "Test4066696"; if (exec) Test4066696(/* par */); break; |
- case 13: name = "Test4076676"; if (exec) Test4076676(/* par */); break; |
- case 14: name = "Test4078588"; if (exec) Test4078588(/* par */); break; |
- case 15: name = "Test4079231"; if (exec) Test4079231(/* par */); break; |
- case 16: name = "Test4081866"; if (exec) Test4081866(/* par */); break; |
- case 17: name = "Test4087241"; if (exec) Test4087241(/* par */); break; |
- case 18: name = "Test4087243"; if (exec) Test4087243(/* par */); break; |
- case 19: name = "Test4092260"; if (exec) Test4092260(/* par */); break; |
- case 20: name = "Test4095316"; if (exec) Test4095316(/* par */); break; |
- case 21: name = "Test4101940"; if (exec) Test4101940(/* par */); break; |
- case 22: name = "Test4103436"; if (exec) Test4103436(/* par */); break; |
- case 23: name = "Test4114076"; if (exec) Test4114076(/* par */); break; |
- case 24: name = "Test4114077"; if (exec) Test4114077(/* par */); break; |
- case 25: name = "Test4124632"; if (exec) Test4124632(/* par */); break; |
- case 26: name = "Test4132736"; if (exec) Test4132736(/* par */); break; |
- case 27: name = "Test4133509"; if (exec) Test4133509(/* par */); break; |
- case 28: name = "Test4139572"; if (exec) Test4139572(/* par */); break; |
- case 29: name = "Test4141640"; if (exec) Test4141640(/* par */); break; |
- case 30: name = "Test4146160"; if (exec) Test4146160(/* par */); break; |
- case 31: name = "TestT7189"; if (exec) TestT7189(); break; |
- case 32: name = "TestCaseFirstCompression"; if (exec) TestCaseFirstCompression(); break; |
- default: name = ""; break; |
- } |
- } else { |
- dataerrln("Class collator not instantiated"); |
- name = ""; |
+ if(en_us == NULL) { |
+ dataerrln("Class collator not instantiated"); |
+ name = ""; |
+ return; |
} |
+ TESTCASE_AUTO_BEGIN; |
+ TESTCASE_AUTO(Test4048446); |
+ TESTCASE_AUTO(Test4051866); |
+ TESTCASE_AUTO(Test4053636); |
+ TESTCASE_AUTO(Test4054238); |
+ TESTCASE_AUTO(Test4054734); |
+ TESTCASE_AUTO(Test4054736); |
+ TESTCASE_AUTO(Test4058613); |
+ TESTCASE_AUTO(Test4059820); |
+ TESTCASE_AUTO(Test4060154); |
+ TESTCASE_AUTO(Test4062418); |
+ TESTCASE_AUTO(Test4065540); |
+ TESTCASE_AUTO(Test4066189); |
+ TESTCASE_AUTO(Test4066696); |
+ TESTCASE_AUTO(Test4076676); |
+ TESTCASE_AUTO(Test4078588); |
+ TESTCASE_AUTO(Test4079231); |
+ TESTCASE_AUTO(Test4081866); |
+ TESTCASE_AUTO(Test4087241); |
+ TESTCASE_AUTO(Test4087243); |
+ TESTCASE_AUTO(Test4092260); |
+ TESTCASE_AUTO(Test4095316); |
+ TESTCASE_AUTO(Test4101940); |
+ TESTCASE_AUTO(Test4103436); |
+ TESTCASE_AUTO(Test4114076); |
+ TESTCASE_AUTO(Test4114077); |
+ TESTCASE_AUTO(Test4124632); |
+ TESTCASE_AUTO(Test4132736); |
+ TESTCASE_AUTO(Test4133509); |
+ TESTCASE_AUTO(Test4139572); |
+ TESTCASE_AUTO(Test4141640); |
+ TESTCASE_AUTO(Test4146160); |
+ TESTCASE_AUTO(Test4179216); |
+ TESTCASE_AUTO(TestT7189); |
+ TESTCASE_AUTO(TestCaseFirstCompression); |
+ TESTCASE_AUTO(TestTrailingComment); |
+ TESTCASE_AUTO(TestBeforeWithTooStrongAfter); |
+ TESTCASE_AUTO_END; |
} |
#endif /* #if !UCONFIG_NO_COLLATION */ |