703 lines
21 KiB
C++
703 lines
21 KiB
C++
// © 2016 and later: Unicode, Inc. and others.
|
|
// License & terms of use: http://www.unicode.org/copyright.html
|
|
/********************************************************************
|
|
* COPYRIGHT:
|
|
* Copyright (c) 1997-2016, International Business Machines Corporation and
|
|
* others. All Rights Reserved.
|
|
********************************************************************/
|
|
|
|
#include "unicode/utypes.h"
|
|
|
|
#if !UCONFIG_NO_COLLATION
|
|
|
|
#include "unicode/coll.h"
|
|
#include "unicode/tblcoll.h"
|
|
#include "unicode/unistr.h"
|
|
#include "unicode/sortkey.h"
|
|
#include "itercoll.h"
|
|
#include "unicode/schriter.h"
|
|
#include "unicode/chariter.h"
|
|
#include "unicode/uchar.h"
|
|
#include "cmemory.h"
|
|
|
|
static UErrorCode status = U_ZERO_ERROR;
|
|
|
|
CollationIteratorTest::CollationIteratorTest()
|
|
: test1("What subset of all possible test cases?", ""),
|
|
test2("has the highest probability of detecting", "")
|
|
{
|
|
en_us = (RuleBasedCollator *)Collator::createInstance(Locale::getUS(), status);
|
|
if(U_FAILURE(status)) {
|
|
delete en_us;
|
|
en_us = 0;
|
|
errcheckln(status, "Collator creation failed with %s", u_errorName(status));
|
|
return;
|
|
}
|
|
|
|
}
|
|
|
|
CollationIteratorTest::~CollationIteratorTest()
|
|
{
|
|
delete en_us;
|
|
}
|
|
|
|
/**
|
|
* Test for CollationElementIterator previous and next for the whole set of
|
|
* unicode characters.
|
|
*/
|
|
void CollationIteratorTest::TestUnicodeChar()
|
|
{
|
|
CollationElementIterator *iter;
|
|
UChar codepoint;
|
|
UnicodeString source;
|
|
|
|
for (codepoint = 1; codepoint < 0xFFFE;)
|
|
{
|
|
source.remove();
|
|
|
|
while (codepoint % 0xFF != 0)
|
|
{
|
|
if (u_isdefined(codepoint))
|
|
source += codepoint;
|
|
codepoint ++;
|
|
}
|
|
|
|
if (u_isdefined(codepoint))
|
|
source += codepoint;
|
|
|
|
if (codepoint != 0xFFFF)
|
|
codepoint ++;
|
|
|
|
iter = en_us->createCollationElementIterator(source);
|
|
/* A basic test to see if it's working at all */
|
|
backAndForth(*iter);
|
|
delete iter;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Test for CollationElementIterator.previous()
|
|
*
|
|
* @bug 4108758 - Make sure it works with contracting characters
|
|
*
|
|
*/
|
|
void CollationIteratorTest::TestPrevious(/* char* par */)
|
|
{
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
CollationElementIterator *iter = en_us->createCollationElementIterator(test1);
|
|
|
|
// A basic test to see if it's working at all
|
|
backAndForth(*iter);
|
|
delete iter;
|
|
|
|
// Test with a contracting character sequence
|
|
UnicodeString source;
|
|
RuleBasedCollator *c1 = NULL;
|
|
c1 = new RuleBasedCollator(
|
|
(UnicodeString)"&a,A < b,B < c,C, d,D < z,Z < ch,cH,Ch,CH", status);
|
|
|
|
if (c1 == NULL || U_FAILURE(status))
|
|
{
|
|
errln("Couldn't create a RuleBasedCollator with a contracting sequence.");
|
|
delete c1;
|
|
return;
|
|
}
|
|
|
|
source = "abchdcba";
|
|
iter = c1->createCollationElementIterator(source);
|
|
backAndForth(*iter);
|
|
delete iter;
|
|
delete c1;
|
|
|
|
// Test with an expanding character sequence
|
|
RuleBasedCollator *c2 = NULL;
|
|
c2 = new RuleBasedCollator((UnicodeString)"&a < b < c/abd < d", status);
|
|
|
|
if (c2 == NULL || U_FAILURE(status))
|
|
{
|
|
errln("Couldn't create a RuleBasedCollator with an expanding sequence.");
|
|
delete c2;
|
|
return;
|
|
}
|
|
|
|
source = "abcd";
|
|
iter = c2->createCollationElementIterator(source);
|
|
backAndForth(*iter);
|
|
delete iter;
|
|
delete c2;
|
|
|
|
// Now try both
|
|
RuleBasedCollator *c3 = NULL;
|
|
c3 = new RuleBasedCollator((UnicodeString)"&a < b < c/aba < d < z < ch", status);
|
|
|
|
if (c3 == NULL || U_FAILURE(status))
|
|
{
|
|
errln("Couldn't create a RuleBasedCollator with both an expanding and a contracting sequence.");
|
|
delete c3;
|
|
return;
|
|
}
|
|
|
|
source = "abcdbchdc";
|
|
iter = c3->createCollationElementIterator(source);
|
|
backAndForth(*iter);
|
|
delete iter;
|
|
delete c3;
|
|
|
|
status=U_ZERO_ERROR;
|
|
source= CharsToUnicodeString("\\u0e41\\u0e02\\u0e41\\u0e02\\u0e27abc");
|
|
|
|
Collator *c4 = Collator::createInstance(Locale("th", "TH", ""), status);
|
|
if(U_FAILURE(status)){
|
|
errln("Couldn't create a collator");
|
|
}
|
|
iter = ((RuleBasedCollator*)c4)->createCollationElementIterator(source);
|
|
backAndForth(*iter);
|
|
delete iter;
|
|
delete c4;
|
|
|
|
source= CharsToUnicodeString("\\u0061\\u30CF\\u3099\\u30FC");
|
|
Collator *c5 = Collator::createInstance(Locale("ja", "JP", ""), status);
|
|
|
|
iter = ((RuleBasedCollator*)c5)->createCollationElementIterator(source);
|
|
if(U_FAILURE(status)){
|
|
errln("Couldn't create Japanese collator\n");
|
|
}
|
|
backAndForth(*iter);
|
|
delete iter;
|
|
delete c5;
|
|
}
|
|
|
|
/**
|
|
* Test for getOffset() and setOffset()
|
|
*/
|
|
void CollationIteratorTest::TestOffset(/* char* par */)
|
|
{
|
|
CollationElementIterator *iter = en_us->createCollationElementIterator(test1);
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
// testing boundaries
|
|
iter->setOffset(0, status);
|
|
if (U_FAILURE(status) || iter->previous(status) != CollationElementIterator::NULLORDER) {
|
|
errln("Error: After setting offset to 0, we should be at the end "
|
|
"of the backwards iteration");
|
|
}
|
|
iter->setOffset(test1.length(), status);
|
|
if (U_FAILURE(status) || iter->next(status) != CollationElementIterator::NULLORDER) {
|
|
errln("Error: After setting offset to end of the string, we should "
|
|
"be at the end of the backwards iteration");
|
|
}
|
|
|
|
// Run all the way through the iterator, then get the offset
|
|
int32_t orderLength = 0;
|
|
Order *orders = getOrders(*iter, orderLength);
|
|
|
|
int32_t offset = iter->getOffset();
|
|
|
|
if (offset != test1.length())
|
|
{
|
|
UnicodeString msg1("offset at end != length: ");
|
|
UnicodeString msg2(" vs ");
|
|
|
|
errln(msg1 + offset + msg2 + test1.length());
|
|
}
|
|
|
|
// Now set the offset back to the beginning and see if it works
|
|
CollationElementIterator *pristine = en_us->createCollationElementIterator(test1);
|
|
|
|
iter->setOffset(0, status);
|
|
|
|
if (U_FAILURE(status))
|
|
{
|
|
errln("setOffset failed.");
|
|
}
|
|
else
|
|
{
|
|
assertEqual(*iter, *pristine);
|
|
}
|
|
|
|
delete pristine;
|
|
delete[] orders;
|
|
delete iter;
|
|
|
|
// setting offset in the middle of a contraction
|
|
UnicodeString contraction = "change";
|
|
status = U_ZERO_ERROR;
|
|
RuleBasedCollator tailored("& a < ch", status);
|
|
if (U_FAILURE(status)) {
|
|
errln("Error: in creation of Spanish collator - %s", u_errorName(status));
|
|
return;
|
|
}
|
|
iter = tailored.createCollationElementIterator(contraction);
|
|
Order *order = getOrders(*iter, orderLength);
|
|
iter->setOffset(1, status); // sets offset in the middle of ch
|
|
int32_t order2Length = 0;
|
|
Order *order2 = getOrders(*iter, order2Length);
|
|
if (orderLength != order2Length || uprv_memcmp(order, order2, orderLength * sizeof(Order)) != 0) {
|
|
errln("Error: setting offset in the middle of a contraction should be the same as setting it to the start of the contraction");
|
|
}
|
|
delete[] order;
|
|
delete[] order2;
|
|
delete iter;
|
|
contraction = "peache";
|
|
iter = tailored.createCollationElementIterator(contraction);
|
|
iter->setOffset(3, status);
|
|
order = getOrders(*iter, orderLength);
|
|
iter->setOffset(4, status); // sets offset in the middle of ch
|
|
order2 = getOrders(*iter, order2Length);
|
|
if (orderLength != order2Length || uprv_memcmp(order, order2, orderLength * sizeof(Order)) != 0) {
|
|
errln("Error: setting offset in the middle of a contraction should be the same as setting it to the start of the contraction");
|
|
}
|
|
delete[] order;
|
|
delete[] order2;
|
|
delete iter;
|
|
// setting offset in the middle of a surrogate pair
|
|
UnicodeString surrogate = UNICODE_STRING_SIMPLE("\\ud800\\udc00str").unescape();
|
|
iter = tailored.createCollationElementIterator(surrogate);
|
|
order = getOrders(*iter, orderLength);
|
|
iter->setOffset(1, status); // sets offset in the middle of surrogate
|
|
order2 = getOrders(*iter, order2Length);
|
|
if (orderLength != order2Length || uprv_memcmp(order, order2, orderLength * sizeof(Order)) != 0) {
|
|
errln("Error: setting offset in the middle of a surrogate pair should be the same as setting it to the start of the surrogate pair");
|
|
}
|
|
delete[] order;
|
|
delete[] order2;
|
|
delete iter;
|
|
surrogate = UNICODE_STRING_SIMPLE("simple\\ud800\\udc00str").unescape();
|
|
iter = tailored.createCollationElementIterator(surrogate);
|
|
iter->setOffset(6, status);
|
|
order = getOrders(*iter, orderLength);
|
|
iter->setOffset(7, status); // sets offset in the middle of surrogate
|
|
order2 = getOrders(*iter, order2Length);
|
|
if (orderLength != order2Length || uprv_memcmp(order, order2, orderLength * sizeof(Order)) != 0) {
|
|
errln("Error: setting offset in the middle of a surrogate pair should be the same as setting it to the start of the surrogate pair");
|
|
}
|
|
delete[] order;
|
|
delete[] order2;
|
|
delete iter;
|
|
// TODO: try iterating halfway through a messy string.
|
|
}
|
|
|
|
/**
|
|
* Test for setText()
|
|
*/
|
|
void CollationIteratorTest::TestSetText(/* char* par */)
|
|
{
|
|
CollationElementIterator *iter1 = en_us->createCollationElementIterator(test1);
|
|
CollationElementIterator *iter2 = en_us->createCollationElementIterator(test2);
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
|
|
// Run through the second iterator just to exercise it
|
|
int32_t c = iter2->next(status);
|
|
int32_t i = 0;
|
|
|
|
while ( ++i < 10 && c != CollationElementIterator::NULLORDER)
|
|
{
|
|
if (U_FAILURE(status))
|
|
{
|
|
errln("iter2->next() returned an error.");
|
|
delete iter2;
|
|
delete iter1;
|
|
}
|
|
|
|
c = iter2->next(status);
|
|
}
|
|
|
|
// Now set it to point to the same string as the first iterator
|
|
iter2->setText(test1, status);
|
|
|
|
if (U_FAILURE(status))
|
|
{
|
|
errln("call to iter2->setText(test1) failed.");
|
|
}
|
|
else
|
|
{
|
|
assertEqual(*iter1, *iter2);
|
|
}
|
|
iter1->reset();
|
|
//now use the overloaded setText(ChracterIterator&, UErrorCode) function to set the text
|
|
CharacterIterator* chariter = new StringCharacterIterator(test1);
|
|
iter2->setText(*chariter, status);
|
|
if (U_FAILURE(status))
|
|
{
|
|
errln("call to iter2->setText(chariter(test1)) failed.");
|
|
}
|
|
else
|
|
{
|
|
assertEqual(*iter1, *iter2);
|
|
}
|
|
|
|
// test for an empty string
|
|
UnicodeString empty("");
|
|
iter1->setText(empty, status);
|
|
if (U_FAILURE(status)
|
|
|| iter1->next(status) != (int32_t)CollationElementIterator::NULLORDER) {
|
|
errln("Empty string should have no CEs.");
|
|
}
|
|
((StringCharacterIterator *)chariter)->setText(empty);
|
|
iter1->setText(*chariter, status);
|
|
if (U_FAILURE(status)
|
|
|| iter1->next(status) != (int32_t)CollationElementIterator::NULLORDER) {
|
|
errln("Empty string should have no CEs.");
|
|
}
|
|
delete chariter;
|
|
delete iter2;
|
|
delete iter1;
|
|
}
|
|
|
|
/** @bug 4108762
|
|
* Test for getMaxExpansion()
|
|
*/
|
|
void CollationIteratorTest::TestMaxExpansion(/* char* par */)
|
|
{
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
UnicodeString rule("&a < ab < c/aba < d < z < ch");
|
|
RuleBasedCollator *coll = new RuleBasedCollator(rule, status);
|
|
UChar ch = 0;
|
|
UnicodeString str(ch);
|
|
|
|
CollationElementIterator *iter = coll->createCollationElementIterator(str);
|
|
|
|
while (ch < 0xFFFF && U_SUCCESS(status)) {
|
|
int count = 1;
|
|
uint32_t order;
|
|
ch ++;
|
|
UnicodeString str(ch);
|
|
iter->setText(str, status);
|
|
order = iter->previous(status);
|
|
|
|
/* thai management */
|
|
if (CollationElementIterator::isIgnorable(order))
|
|
order = iter->previous(status);
|
|
|
|
while (U_SUCCESS(status)
|
|
&& iter->previous(status) != (int32_t)CollationElementIterator::NULLORDER)
|
|
{
|
|
count ++;
|
|
}
|
|
|
|
if (U_FAILURE(status) && iter->getMaxExpansion(order) < count) {
|
|
errln("Failure at codepoint %d, maximum expansion count < %d\n",
|
|
ch, count);
|
|
}
|
|
}
|
|
|
|
delete iter;
|
|
delete coll;
|
|
}
|
|
|
|
/*
|
|
* @bug 4157299
|
|
*/
|
|
void CollationIteratorTest::TestClearBuffers(/* char* par */)
|
|
{
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
RuleBasedCollator *c = new RuleBasedCollator((UnicodeString)"&a < b < c & ab = d", status);
|
|
|
|
if (c == NULL || U_FAILURE(status))
|
|
{
|
|
errln("Couldn't create a RuleBasedCollator.");
|
|
delete c;
|
|
return;
|
|
}
|
|
|
|
UnicodeString source("abcd");
|
|
CollationElementIterator *i = c->createCollationElementIterator(source);
|
|
int32_t e0 = i->next(status); // save the first collation element
|
|
|
|
if (U_FAILURE(status))
|
|
{
|
|
errln("call to i->next() failed. err=%s", u_errorName(status));
|
|
}
|
|
else
|
|
{
|
|
i->setOffset(3, status); // go to the expanding character
|
|
|
|
if (U_FAILURE(status))
|
|
{
|
|
errln("call to i->setOffset(3) failed. err=%s", u_errorName(status));
|
|
}
|
|
else
|
|
{
|
|
i->next(status); // but only use up half of it
|
|
|
|
if (U_FAILURE(status))
|
|
{
|
|
errln("call to i->next() failed. err=%s", u_errorName(status));
|
|
}
|
|
else
|
|
{
|
|
i->setOffset(0, status); // go back to the beginning
|
|
|
|
if (U_FAILURE(status))
|
|
{
|
|
errln("call to i->setOffset(0) failed. err=%s", u_errorName(status));
|
|
}
|
|
else
|
|
{
|
|
int32_t e = i->next(status); // and get this one again
|
|
|
|
if (U_FAILURE(status))
|
|
{
|
|
errln("call to i->next() failed. err=%s", u_errorName(status));
|
|
}
|
|
else if (e != e0)
|
|
{
|
|
errln("got 0x%X, expected 0x%X", e, e0);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
delete i;
|
|
delete c;
|
|
}
|
|
|
|
/**
|
|
* Testing the assignment operator
|
|
*/
|
|
void CollationIteratorTest::TestAssignment()
|
|
{
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
RuleBasedCollator *coll =
|
|
(RuleBasedCollator *)Collator::createInstance(status);
|
|
|
|
if (coll == NULL || U_FAILURE(status))
|
|
{
|
|
errln("Couldn't create a default collator.");
|
|
return;
|
|
}
|
|
|
|
UnicodeString source("abcd");
|
|
CollationElementIterator *iter1 =
|
|
coll->createCollationElementIterator(source);
|
|
|
|
CollationElementIterator iter2 = *iter1;
|
|
|
|
if (*iter1 != iter2) {
|
|
errln("Fail collation iterator assignment does not produce the same elements");
|
|
}
|
|
|
|
CollationElementIterator iter3(*iter1);
|
|
|
|
if (*iter1 != iter3) {
|
|
errln("Fail collation iterator copy constructor does not produce the same elements");
|
|
}
|
|
|
|
source = CharsToUnicodeString("a\\u0300\\u0325");
|
|
coll->setAttribute(UCOL_NORMALIZATION_MODE, UCOL_ON, status);
|
|
CollationElementIterator *iter4
|
|
= coll->createCollationElementIterator(source);
|
|
CollationElementIterator iter5(*iter4);
|
|
if (*iter4 != iter5) {
|
|
errln("collation iterator assignment does not produce the same elements");
|
|
}
|
|
iter4->next(status);
|
|
if (U_FAILURE(status) || *iter4 == iter5) {
|
|
errln("collation iterator not equal");
|
|
}
|
|
iter5.next(status);
|
|
if (U_FAILURE(status) || *iter4 != iter5) {
|
|
errln("collation iterator equal");
|
|
}
|
|
iter4->next(status);
|
|
if (U_FAILURE(status) || *iter4 == iter5) {
|
|
errln("collation iterator not equal");
|
|
}
|
|
iter5.next(status);
|
|
if (U_FAILURE(status) || *iter4 != iter5) {
|
|
errln("collation iterator equal");
|
|
}
|
|
CollationElementIterator iter6(*iter4);
|
|
if (*iter4 != iter6) {
|
|
errln("collation iterator equal");
|
|
}
|
|
iter4->next(status);
|
|
if (U_FAILURE(status) || *iter4 == iter5) {
|
|
errln("collation iterator not equal");
|
|
}
|
|
iter5.next(status);
|
|
if (U_FAILURE(status) || *iter4 != iter5) {
|
|
errln("collation iterator equal");
|
|
}
|
|
iter4->next(status);
|
|
if (U_FAILURE(status) || *iter4 == iter5) {
|
|
errln("collation iterator not equal");
|
|
}
|
|
iter5.next(status);
|
|
if (U_FAILURE(status) || *iter4 != iter5) {
|
|
errln("collation iterator equal");
|
|
}
|
|
delete iter1;
|
|
delete iter4;
|
|
delete coll;
|
|
}
|
|
|
|
/**
|
|
* Testing the constructors
|
|
*/
|
|
void CollationIteratorTest::TestConstructors()
|
|
{
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
RuleBasedCollator *coll =
|
|
(RuleBasedCollator *)Collator::createInstance(status);
|
|
if (coll == NULL || U_FAILURE(status))
|
|
{
|
|
errln("Couldn't create a default collator.");
|
|
return;
|
|
}
|
|
|
|
// testing protected constructor with character iterator as argument
|
|
StringCharacterIterator chariter(test1);
|
|
CollationElementIterator *iter1 =
|
|
coll->createCollationElementIterator(chariter);
|
|
if (U_FAILURE(status)) {
|
|
errln("Couldn't create collation element iterator with character iterator.");
|
|
return;
|
|
}
|
|
CollationElementIterator *iter2 =
|
|
coll->createCollationElementIterator(test1);
|
|
|
|
// initially the 2 collation element iterators should be the same
|
|
if (*iter1 != *iter1 || *iter2 != *iter2 || *iter1 != *iter2
|
|
|| *iter2 != *iter1) {
|
|
errln("CollationElementIterators constructed with the same string data should be the same at the start");
|
|
}
|
|
assertEqual(*iter1, *iter2);
|
|
|
|
delete iter1;
|
|
delete iter2;
|
|
|
|
// tests empty strings
|
|
UnicodeString empty("");
|
|
iter1 = coll->createCollationElementIterator(empty);
|
|
chariter.setText(empty);
|
|
iter2 = coll->createCollationElementIterator(chariter);
|
|
if (*iter1 != *iter1 || *iter2 != *iter2 || *iter1 != *iter2
|
|
|| *iter2 != *iter1) {
|
|
errln("CollationElementIterators constructed with the same string data should be the same at the start");
|
|
}
|
|
if (iter1->next(status) != (int32_t)CollationElementIterator::NULLORDER) {
|
|
errln("Empty string should have no CEs.");
|
|
}
|
|
if (iter2->next(status) != (int32_t)CollationElementIterator::NULLORDER) {
|
|
errln("Empty string should have no CEs.");
|
|
}
|
|
delete iter1;
|
|
delete iter2;
|
|
delete coll;
|
|
}
|
|
|
|
/**
|
|
* Testing the strength order
|
|
*/
|
|
void CollationIteratorTest::TestStrengthOrder()
|
|
{
|
|
int order = 0x0123ABCD;
|
|
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
RuleBasedCollator *coll =
|
|
(RuleBasedCollator *)Collator::createInstance(status);
|
|
if (coll == NULL || U_FAILURE(status))
|
|
{
|
|
errln("Couldn't create a default collator.");
|
|
return;
|
|
}
|
|
|
|
coll->setStrength(Collator::PRIMARY);
|
|
CollationElementIterator *iter =
|
|
coll->createCollationElementIterator(test1);
|
|
|
|
if (iter == NULL) {
|
|
errln("Couldn't create a collation element iterator from default collator");
|
|
return;
|
|
}
|
|
|
|
if (iter->strengthOrder(order) != 0x01230000) {
|
|
errln("Strength order for a primary strength collator should be the first 2 bytes");
|
|
return;
|
|
}
|
|
|
|
coll->setStrength(Collator::SECONDARY);
|
|
if (iter->strengthOrder(order) != 0x0123AB00) {
|
|
errln("Strength order for a secondary strength collator should be the third byte");
|
|
return;
|
|
}
|
|
|
|
coll->setStrength(Collator::TERTIARY);
|
|
if (iter->strengthOrder(order) != order) {
|
|
errln("Strength order for a tertiary strength collator should be the third byte");
|
|
return;
|
|
}
|
|
delete iter;
|
|
delete coll;
|
|
}
|
|
|
|
/**
|
|
* Return a string containing all of the collation orders
|
|
* returned by calls to next on the specified iterator
|
|
*/
|
|
UnicodeString &CollationIteratorTest::orderString(CollationElementIterator &iter, UnicodeString &target)
|
|
{
|
|
int32_t order;
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
|
|
while ((order = iter.next(status)) != CollationElementIterator::NULLORDER)
|
|
{
|
|
target += "0x";
|
|
appendHex(order, 8, target);
|
|
target += " ";
|
|
}
|
|
|
|
return target;
|
|
}
|
|
|
|
void CollationIteratorTest::assertEqual(CollationElementIterator &i1, CollationElementIterator &i2)
|
|
{
|
|
int32_t c1, c2, count = 0;
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
|
|
do
|
|
{
|
|
c1 = i1.next(status);
|
|
c2 = i2.next(status);
|
|
|
|
if (c1 != c2)
|
|
{
|
|
errln(" %d: strength(0x%X) != strength(0x%X)", count, c1, c2);
|
|
break;
|
|
}
|
|
|
|
count += 1;
|
|
}
|
|
while (c1 != CollationElementIterator::NULLORDER);
|
|
}
|
|
|
|
void CollationIteratorTest::runIndexedTest(int32_t index, UBool exec, const char* &name, char* /*par*/)
|
|
{
|
|
if (exec)
|
|
{
|
|
logln("Collation Iteration Tests: ");
|
|
}
|
|
|
|
if(en_us) {
|
|
switch (index)
|
|
{
|
|
case 0: name = "TestPrevious"; if (exec) TestPrevious(/* par */); break;
|
|
case 1: name = "TestOffset"; if (exec) TestOffset(/* par */); break;
|
|
case 2: name = "TestSetText"; if (exec) TestSetText(/* par */); break;
|
|
case 3: name = "TestMaxExpansion"; if (exec) TestMaxExpansion(/* par */); break;
|
|
case 4: name = "TestClearBuffers"; if (exec) TestClearBuffers(/* par */); break;
|
|
case 5: name = "TestUnicodeChar"; if (exec) TestUnicodeChar(/* par */); break;
|
|
case 6: name = "TestAssignment"; if (exec) TestAssignment(/* par */); break;
|
|
case 7: name = "TestConstructors"; if (exec) TestConstructors(/* par */); break;
|
|
case 8: name = "TestStrengthOrder"; if (exec) TestStrengthOrder(/* par */); break;
|
|
default: name = ""; break;
|
|
}
|
|
} else {
|
|
dataerrln("Class iterator not instantiated");
|
|
name = "";
|
|
}
|
|
}
|
|
|
|
#endif /* #if !UCONFIG_NO_COLLATION */
|