317 lines
9.5 KiB
C++
317 lines
9.5 KiB
C++
/********************************************************************
|
|
* COPYRIGHT:
|
|
* Copyright (c) 1997-2001, International Business Machines Corporation and
|
|
* others. All Rights Reserved.
|
|
********************************************************************/
|
|
|
|
/**
|
|
* IntlTestCollator is the medium level test class for everything in the directory "collate".
|
|
*/
|
|
|
|
/***********************************************************************
|
|
* Modification history
|
|
* Date Name Description
|
|
* 02/14/2001 synwee Compare with cintltst and commented away tests
|
|
* that are not run.
|
|
***********************************************************************/
|
|
|
|
#include "unicode/utypes.h"
|
|
#include "unicode/uchar.h"
|
|
|
|
#include "cstring.h"
|
|
#include "ucol_tok.h"
|
|
|
|
#include "tscoll.h"
|
|
|
|
#include "dadrcoll.h"
|
|
|
|
DataDrivenCollatorTest::DataDrivenCollatorTest()
|
|
: seq(StringCharacterIterator(""))
|
|
{
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
TestLog testLog;
|
|
|
|
driver = TestDataModule::getTestDataModule("DataDrivenCollationTest", testLog, status);
|
|
}
|
|
|
|
DataDrivenCollatorTest::~DataDrivenCollatorTest()
|
|
{
|
|
delete driver;
|
|
}
|
|
|
|
void DataDrivenCollatorTest::runIndexedTest( int32_t index, UBool exec, const char* &name, char* /*par */)
|
|
{
|
|
if(driver != NULL) {
|
|
if (exec)
|
|
{
|
|
logln("TestSuite Collator: ");
|
|
}
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
const DataMap *info = NULL;
|
|
TestData *testData = driver->createTestData(index, status);
|
|
if(U_SUCCESS(status)) {
|
|
name = testData->getName();
|
|
if(testData->getInfo(info, status)) {
|
|
log(info->getString("Description", status));
|
|
}
|
|
if(exec) {
|
|
log(name);
|
|
logln("---");
|
|
logln("");
|
|
processTest(testData, status);
|
|
}
|
|
delete testData;
|
|
} else {
|
|
name = "";
|
|
}
|
|
} else {
|
|
errln("collate/DataDrivenTest data not initialized!");
|
|
name = "";
|
|
}
|
|
|
|
|
|
}
|
|
|
|
UBool
|
|
DataDrivenCollatorTest::setTestSequence(const UnicodeString &setSequence, UnicodeString &source, Collator::EComparisonResult &relation, UErrorCode &status) {
|
|
seq.setText(setSequence);
|
|
return getNextInSequence(source, relation, status);
|
|
}
|
|
|
|
// Parses the sequence to be tested
|
|
UBool
|
|
DataDrivenCollatorTest::getNextInSequence(UnicodeString &source, Collator::EComparisonResult &relation, UErrorCode &status) {
|
|
source.truncate(0);
|
|
// TODO: add quoting support - will need it pretty soon!
|
|
UBool quoted = FALSE;
|
|
UBool quotedsingle = FALSE;
|
|
UChar32 currChar = 0;
|
|
|
|
while(currChar != CharacterIterator::DONE) {
|
|
currChar= seq.next32PostInc();
|
|
if(!quoted) {
|
|
if(u_isWhitespace(currChar)) {
|
|
continue;
|
|
}
|
|
switch(currChar) {
|
|
case CharacterIterator::DONE:
|
|
break;
|
|
case 0x003C /* < */:
|
|
relation = Collator::LESS;
|
|
currChar = CharacterIterator::DONE;
|
|
break;
|
|
case 0x003D /* = */:
|
|
relation = Collator::EQUAL;
|
|
currChar = CharacterIterator::DONE;
|
|
break;
|
|
case 0x003E /* > */:
|
|
relation = Collator::GREATER;
|
|
currChar = CharacterIterator::DONE;
|
|
break;
|
|
case 0x0027 /* ' */: /* very basic quoting */
|
|
quoted = TRUE;
|
|
quotedsingle = FALSE;
|
|
break;
|
|
case 0x005c /* \ */: /* single quote */
|
|
quoted = TRUE;
|
|
quotedsingle = TRUE;
|
|
break;
|
|
default:
|
|
source.append(currChar);
|
|
}
|
|
} else {
|
|
if(currChar == CharacterIterator::DONE) {
|
|
status = U_ILLEGAL_ARGUMENT_ERROR;
|
|
errln("Quote in sequence not closed!");
|
|
return FALSE;
|
|
} else if(currChar == 0x0027) {
|
|
quoted = FALSE;
|
|
} else {
|
|
source.append(currChar);
|
|
}
|
|
if(quotedsingle) {
|
|
quoted = FALSE;
|
|
}
|
|
}
|
|
}
|
|
return seq.hasNext();
|
|
}
|
|
|
|
// Reads the options string and sets appropriate attributes in collator
|
|
void
|
|
DataDrivenCollatorTest::processArguments(Collator *col, const UChar *start, int32_t optLen, UErrorCode &status) {
|
|
const UChar *end = start+optLen;
|
|
UColAttribute attrib;
|
|
UColAttributeValue value;
|
|
|
|
if(optLen == 0) {
|
|
return;
|
|
}
|
|
|
|
start = ucol_tok_getNextArgument(start, end, &attrib, &value, &status);
|
|
while(start != NULL) {
|
|
if(U_SUCCESS(status)) {
|
|
col->setAttribute(attrib, value, status);
|
|
}
|
|
start = ucol_tok_getNextArgument(start, end, &attrib, &value, &status);
|
|
}
|
|
}
|
|
|
|
void
|
|
DataDrivenCollatorTest::processTest(TestData *testData, UErrorCode &status) {
|
|
Collator *col = NULL;
|
|
/*
|
|
UnicodeString testInit[256];
|
|
const char **testNames = new const char*[256];
|
|
int32_t settingsSetSize = 0;
|
|
const UChar *arguments = NULL;
|
|
int32_t argLen = 0;
|
|
int32_t i = 0;
|
|
while(settingsSetSize = driver->getNextSettingsSet(testNames, testInit, 256, status)) {
|
|
argLen = 0;
|
|
for(i = 0; i < settingsSetSize; i++) {
|
|
if(strcmp(testNames[i], "Locale") == 0) { // Make the locale dependent collator
|
|
if(col == NULL) {
|
|
char localeName[256];
|
|
testInit[i].extract(0, testInit[i].length(), localeName, "");
|
|
col = Collator::createInstance(localeName, status);
|
|
if(U_SUCCESS(status)) {
|
|
logln("Testing collator for locale "+testInit[i]);
|
|
} else {
|
|
errln("Unable to instantiate collator for locale "+testInit[i]);
|
|
return;
|
|
}
|
|
} else {
|
|
errln("Collator defined more than once!");
|
|
return;
|
|
}
|
|
} else if(strcmp(testNames[i], "Rules") == 0) {
|
|
if(col == NULL) {
|
|
col = new RuleBasedCollator(testInit[i], status);
|
|
if(U_SUCCESS(status)) {
|
|
logln("Testing collator for rules "+UnicodeString(testInit[i]));
|
|
} else {
|
|
errln("Unable to instantiate collator for rules "+UnicodeString(testInit[i]));
|
|
return;
|
|
}
|
|
} else {
|
|
errln("Collator defined more than once!");
|
|
return;
|
|
}
|
|
} else if(strcmp(testNames[i], "Attributes") == 0) {
|
|
logln("Arguments: "+testInit[i]);
|
|
argLen = testInit[i].length();
|
|
arguments = testInit[i].getBuffer();
|
|
} else {
|
|
errln("I don't understand the setting "+UnicodeString(testNames[i]));
|
|
}
|
|
}
|
|
if(col != NULL) {
|
|
if(argLen > 0) {
|
|
processArguments(col, arguments, argLen, status);
|
|
if(U_SUCCESS(status)) {
|
|
UnicodeString sequence[1];
|
|
while(driver->getNextTestCase(sequence, 1, status)) {
|
|
processSequence(col, *sequence, status);
|
|
}
|
|
} else {
|
|
errln("Couldn't process arguments");
|
|
}
|
|
}
|
|
} else {
|
|
errln("Couldn't instantiate a collator!");
|
|
}
|
|
delete col;
|
|
}
|
|
delete testNames;
|
|
*/
|
|
const UChar *arguments = NULL;
|
|
int32_t argLen = 0;
|
|
const DataMap *settings = NULL;
|
|
const DataMap *currentCase = NULL;
|
|
UErrorCode intStatus = U_ZERO_ERROR;
|
|
UnicodeString testSetting;
|
|
while(testData->nextSettings(settings, status)) {
|
|
intStatus = U_ZERO_ERROR;
|
|
// try to get a locale
|
|
testSetting = settings->getString("TestLocale", intStatus);
|
|
if(U_SUCCESS(intStatus)) {
|
|
char localeName[256];
|
|
testSetting.extract(0, testSetting.length(), localeName, "");
|
|
col = Collator::createInstance(localeName, status);
|
|
if(U_SUCCESS(status)) {
|
|
logln("Testing collator for locale "+testSetting);
|
|
} else {
|
|
errln("Unable to instantiate collator for locale "+testSetting);
|
|
return;
|
|
}
|
|
} else {
|
|
// if no locale, try from rules
|
|
intStatus = U_ZERO_ERROR;
|
|
testSetting = settings->getString("Rules", intStatus);
|
|
if(U_SUCCESS(intStatus)) {
|
|
col = new RuleBasedCollator(testSetting, status);
|
|
UCollator *ucol = ucol_openRules(testSetting.getBuffer(), testSetting.length(), UCOL_DEFAULT, UCOL_DEFAULT, NULL, &status);
|
|
if(U_SUCCESS(status)) {
|
|
logln("Testing collator for rules "+testSetting);
|
|
} else {
|
|
errln("Unable to instantiate collator for rules "+testSetting);
|
|
return;
|
|
}
|
|
} else {
|
|
errln("No collator definition!");
|
|
}
|
|
}
|
|
if(col != NULL) {
|
|
// get attributes
|
|
testSetting = settings->getString("Arguments", intStatus);
|
|
if(U_SUCCESS(intStatus)) {
|
|
logln("Arguments: "+testSetting);
|
|
argLen = testSetting.length();
|
|
arguments = testSetting.getBuffer();
|
|
processArguments(col, arguments, argLen, intStatus);
|
|
if(U_FAILURE(intStatus)) {
|
|
errln("Couldn't process arguments");
|
|
break;
|
|
}
|
|
} else {
|
|
intStatus = U_ZERO_ERROR;
|
|
}
|
|
// Start the processing
|
|
while(testData->nextCase(currentCase, status)) {
|
|
UnicodeString sequence = currentCase->getString("sequence", status);
|
|
if(U_SUCCESS(status)) {
|
|
processSequence(col, sequence, status);
|
|
}
|
|
}
|
|
} else {
|
|
errln("Couldn't instantiate a collator!");
|
|
}
|
|
delete col;
|
|
col = NULL;
|
|
}
|
|
}
|
|
|
|
void
|
|
DataDrivenCollatorTest::processSequence(Collator* col, const UnicodeString &sequence, UErrorCode &status) {
|
|
UnicodeString source;
|
|
UnicodeString target;
|
|
UnicodeString temp;
|
|
Collator::EComparisonResult relation = Collator::EQUAL;
|
|
Collator::EComparisonResult nextRelation = Collator::EQUAL;
|
|
UBool hasNext;
|
|
|
|
setTestSequence(sequence, source, relation, status);
|
|
|
|
// TODO: have a smarter tester that remembers the sequence and ensures that
|
|
// the complete sequence is in order. That is why I have made a constraint
|
|
// in the sequence format.
|
|
do {
|
|
hasNext = getNextInSequence(target, nextRelation, status);
|
|
doTest(col, source, target, relation);
|
|
source = target;
|
|
relation = nextRelation;
|
|
} while(hasNext);
|
|
}
|
|
|