blob: a748ac707465a30a1b540022caa56b0a569c4005 [file] [log] [blame]
/*
*****************************************************************************
* Copyright (C) 2001-2011, International Business Machines orporation
* and others. All Rights Reserved.
****************************************************************************/
#include "unicode/utypes.h"
#if !UCONFIG_NO_COLLATION
#include "srchtest.h"
#if !UCONFIG_NO_BREAK_ITERATION
#include "../cintltst/usrchdat.c"
#endif
#include "unicode/stsearch.h"
#include "unicode/ustring.h"
#include "unicode/schriter.h"
#include <string.h>
#include <stdio.h>
// private definitions -----------------------------------------------------
#define CASE(id,test) \
case id: \
name = #test; \
if (exec) { \
logln(#test "---"); \
logln((UnicodeString)""); \
if(areBroken) { \
dataerrln(__FILE__ " cannot test - failed to create collator."); \
} else { \
test(); \
} \
} \
break;
// public contructors and destructors --------------------------------------
StringSearchTest::StringSearchTest()
#if !UCONFIG_NO_BREAK_ITERATION
:
m_en_wordbreaker_(NULL), m_en_characterbreaker_(NULL)
#endif
{
#if !UCONFIG_NO_BREAK_ITERATION
UErrorCode status = U_ZERO_ERROR;
m_en_us_ = (RuleBasedCollator *)Collator::createInstance("en_US", status);
m_fr_fr_ = (RuleBasedCollator *)Collator::createInstance("fr_FR", status);
m_de_ = (RuleBasedCollator *)Collator::createInstance("de_DE", status);
m_es_ = (RuleBasedCollator *)Collator::createInstance("es_ES", status);
if(U_FAILURE(status)) {
delete m_en_us_;
delete m_fr_fr_;
delete m_de_;
delete m_es_;
m_en_us_ = 0;
m_fr_fr_ = 0;
m_de_ = 0;
m_es_ = 0;
errln("Collator creation failed with %s", u_errorName(status));
return;
}
UnicodeString rules;
rules.setTo(((RuleBasedCollator *)m_de_)->getRules());
UChar extrarules[128];
u_unescape(EXTRACOLLATIONRULE, extrarules, 128);
rules.append(extrarules, u_strlen(extrarules));
delete m_de_;
m_de_ = new RuleBasedCollator(rules, status);
rules.setTo(((RuleBasedCollator *)m_es_)->getRules());
rules.append(extrarules, u_strlen(extrarules));
delete m_es_;
m_es_ = new RuleBasedCollator(rules, status);
#if !UCONFIG_NO_BREAK_ITERATION
m_en_wordbreaker_ = BreakIterator::createWordInstance(
Locale::getEnglish(), status);
m_en_characterbreaker_ = BreakIterator::createCharacterInstance(
Locale::getEnglish(), status);
#endif
#endif
}
StringSearchTest::~StringSearchTest()
{
#if !UCONFIG_NO_BREAK_ITERATION
delete m_en_us_;
delete m_fr_fr_;
delete m_de_;
delete m_es_;
#if !UCONFIG_NO_BREAK_ITERATION
delete m_en_wordbreaker_;
delete m_en_characterbreaker_;
#endif
#endif
}
// public methods ----------------------------------------------------------
void StringSearchTest::runIndexedTest(int32_t index, UBool exec,
const char* &name, char* )
{
#if !UCONFIG_NO_BREAK_ITERATION
UBool areBroken = FALSE;
if (m_en_us_ == NULL && m_fr_fr_ == NULL && m_de_ == NULL &&
m_es_ == NULL && m_en_wordbreaker_ == NULL &&
m_en_characterbreaker_ == NULL && exec) {
areBroken = TRUE;
}
switch (index) {
#if !UCONFIG_NO_FILE_IO
CASE(0, TestOpenClose)
#endif
CASE(1, TestInitialization)
CASE(2, TestBasic)
CASE(3, TestNormExact)
CASE(4, TestStrength)
#if UCONFIG_NO_BREAK_ITERATION
case 5:
name = "TestBreakIterator";
break;
#else
CASE(5, TestBreakIterator)
#endif
CASE(6, TestVariable)
CASE(7, TestOverlap)
CASE(8, TestCollator)
CASE(9, TestPattern)
CASE(10, TestText)
CASE(11, TestCompositeBoundaries)
CASE(12, TestGetSetOffset)
CASE(13, TestGetSetAttribute)
CASE(14, TestGetMatch)
CASE(15, TestSetMatch)
CASE(16, TestReset)
CASE(17, TestSupplementary)
CASE(18, TestContraction)
CASE(19, TestIgnorable)
CASE(20, TestCanonical)
CASE(21, TestNormCanonical)
CASE(22, TestStrengthCanonical)
#if UCONFIG_NO_BREAK_ITERATION
case 23:
name = "TestBreakIteratorCanonical";
break;
#else
CASE(23, TestBreakIteratorCanonical)
#endif
CASE(24, TestVariableCanonical)
CASE(25, TestOverlapCanonical)
CASE(26, TestCollatorCanonical)
CASE(27, TestPatternCanonical)
CASE(28, TestTextCanonical)
CASE(29, TestCompositeBoundariesCanonical)
CASE(30, TestGetSetOffsetCanonical)
CASE(31, TestSupplementaryCanonical)
CASE(32, TestContractionCanonical)
CASE(33, TestUClassID)
CASE(34, TestSubclass)
CASE(35, TestCoverage)
CASE(36, TestDiacriticMatch)
default: name = ""; break;
}
#else
name="";
#endif
}
#if !UCONFIG_NO_BREAK_ITERATION
// private methods ------------------------------------------------------
RuleBasedCollator * StringSearchTest::getCollator(const char *collator)
{
if (collator == NULL) {
return m_en_us_;
}
if (strcmp(collator, "fr") == 0) {
return m_fr_fr_;
}
else if (strcmp(collator, "de") == 0) {
return m_de_;
}
else if (strcmp(collator, "es") == 0) {
return m_es_;
}
else {
return m_en_us_;
}
}
BreakIterator * StringSearchTest::getBreakIterator(const char *breaker)
{
#if UCONFIG_NO_BREAK_ITERATION
return NULL;
#else
if (breaker == NULL) {
return NULL;
}
if (strcmp(breaker, "wordbreaker") == 0) {
return m_en_wordbreaker_;
}
else {
return m_en_characterbreaker_;
}
#endif
}
char * StringSearchTest::toCharString(const UnicodeString &text)
{
static char result[1024];
int index = 0;
int count = 0;
int length = text.length();
for (; count < length; count ++) {
UChar ch = text[count];
if (ch >= 0x20 && ch <= 0x7e) {
result[index ++] = (char)ch;
}
else {
sprintf(result+index, "\\u%04x", ch);
index += 6; /* \uxxxx */
}
}
result[index] = 0;
return result;
}
Collator::ECollationStrength StringSearchTest::getECollationStrength(
const UCollationStrength &strength) const
{
switch (strength)
{
case UCOL_PRIMARY :
return Collator::PRIMARY;
case UCOL_SECONDARY :
return Collator::SECONDARY;
case UCOL_TERTIARY :
return Collator::TERTIARY;
default :
return Collator::IDENTICAL;
}
}
UBool StringSearchTest::assertEqualWithStringSearch(StringSearch *strsrch,
const SearchData *search)
{
int32_t count = 0;
UErrorCode status = U_ZERO_ERROR;
int32_t matchindex = search->offset[count];
UnicodeString matchtext;
int32_t matchlength;
strsrch->setAttribute(USEARCH_ELEMENT_COMPARISON, search->elemCompare, status);
if (U_FAILURE(status)) {
errln("Error setting USEARCH_ELEMENT_COMPARISON attribute %s", u_errorName(status));
return FALSE;
}
if (strsrch->getMatchedStart() != USEARCH_DONE ||
strsrch->getMatchedLength() != 0) {
errln("Error with the initialization of match start and length");
}
// start of next matches
while (U_SUCCESS(status) && matchindex >= 0) {
matchlength = search->size[count];
strsrch->next(status);
if (matchindex != strsrch->getMatchedStart() ||
matchlength != strsrch->getMatchedLength()) {
char *str = toCharString(strsrch->getText());
errln("Text: %s", str);
str = toCharString(strsrch->getPattern());
errln("Pattern: %s", str);
errln("Error next match found at %d (len:%d); expected %d (len:%d)",
strsrch->getMatchedStart(), strsrch->getMatchedLength(),
matchindex, matchlength);
return FALSE;
}
count ++;
strsrch->getMatchedText(matchtext);
if (U_FAILURE(status) ||
strsrch->getText().compareBetween(matchindex,
matchindex + matchlength,
matchtext, 0,
matchtext.length())) {
errln("Error getting next matched text");
}
matchindex = search->offset[count];
}
strsrch->next(status);
if (strsrch->getMatchedStart() != USEARCH_DONE ||
strsrch->getMatchedLength() != 0) {
char *str = toCharString(strsrch->getText());
errln("Text: %s", str);
str = toCharString(strsrch->getPattern());
errln("Pattern: %s", str);
errln("Error next match found at %d (len:%d); expected <NO MATCH>",
strsrch->getMatchedStart(), strsrch->getMatchedLength());
return FALSE;
}
// start of previous matches
count = count == 0 ? 0 : count - 1;
matchindex = search->offset[count];
while (U_SUCCESS(status) && matchindex >= 0) {
matchlength = search->size[count];
strsrch->previous(status);
if (matchindex != strsrch->getMatchedStart() ||
matchlength != strsrch->getMatchedLength()) {
char *str = toCharString(strsrch->getText());
errln("Text: %s", str);
str = toCharString(strsrch->getPattern());
errln("Pattern: %s", str);
errln("Error previous match found at %d (len:%d); expected %d (len:%d)",
strsrch->getMatchedStart(), strsrch->getMatchedLength(),
matchindex, matchlength);
return FALSE;
}
strsrch->getMatchedText(matchtext);
if (U_FAILURE(status) ||
strsrch->getText().compareBetween(matchindex,
matchindex + matchlength,
matchtext, 0,
matchtext.length())) {
errln("Error getting previous matched text");
}
matchindex = count > 0 ? search->offset[count - 1] : -1;
count --;
}
strsrch->previous(status);
if (strsrch->getMatchedStart() != USEARCH_DONE ||
strsrch->getMatchedLength() != 0) {
char *str = toCharString(strsrch->getText());
errln("Text: %s", str);
str = toCharString(strsrch->getPattern());
errln("Pattern: %s", str);
errln("Error previous match found at %d (len:%d); expected <NO MATCH>",
strsrch->getMatchedStart(), strsrch->getMatchedLength());
return FALSE;
}
int32_t nextStart;
UBool isOverlap = (strsrch->getAttribute(USEARCH_OVERLAP) == USEARCH_ON);
// start of following matches
count = 0;
matchindex = search->offset[count];
nextStart = 0;
while (TRUE) {
strsrch->following(nextStart, status);
if (matchindex < 0) {
if (strsrch->getMatchedStart() != USEARCH_DONE ||
strsrch->getMatchedLength() != 0) {
char *str = toCharString(strsrch->getText());
errln("Text: %s", str);
str = toCharString(strsrch->getPattern());
errln("Pattern: %s", str);
errln("Error following match starting at %d (overlap:%d) found at %d (len:%d); expected <NO MATCH>",
nextStart, isOverlap,
strsrch->getMatchedStart(), strsrch->getMatchedLength());
return FALSE;
}
// no more matches
break;
}
matchlength = search->size[count];
if (strsrch->getMatchedStart() != matchindex
|| strsrch->getMatchedLength() != matchlength
|| U_FAILURE(status)) {
char *str = toCharString(strsrch->getText());
errln("Text: %s\n", str);
str = toCharString(strsrch->getPattern());
errln("Pattern: %s\n", str);
errln("Error following match starting at %d (overlap: %d) found at %d (len:%d); expected %d (len:%d)\n",
nextStart, isOverlap,
strsrch->getMatchedStart(), strsrch->getMatchedLength(),
matchindex, matchlength);
return FALSE;
}
if (isOverlap || strsrch->getMatchedLength() == 0) {
nextStart = strsrch->getMatchedStart() + 1;
} else {
nextStart = strsrch->getMatchedStart() + strsrch->getMatchedLength();
}
count++;
matchindex = search->offset[count];
}
// start preceding matches
count = -1; // last non-negative offset index, could be -1 if no match
while (search->offset[count + 1] >= 0) {
count++;
}
nextStart = strsrch->getText().length();
while (TRUE) {
strsrch->preceding(nextStart, status);
if (count < 0) {
if (strsrch->getMatchedStart() != USEARCH_DONE || strsrch->getMatchedLength() != 0) {
char *str = toCharString(strsrch->getText());
errln("Text: %s\n", str);
str = toCharString(strsrch->getPattern());
errln("Pattern: %s\n", str);
errln("Error preceding match starting at %d (overlap: %d) found at %d (len:%d); expected <NO MATCH>\n",
nextStart, isOverlap,
strsrch->getMatchedStart(),
strsrch->getMatchedLength());
return FALSE;
}
// no more matches
break;
}
matchindex = search->offset[count];
matchlength = search->size[count];
if (strsrch->getMatchedStart() != matchindex
|| strsrch->getMatchedLength() != matchlength
|| U_FAILURE(status)) {
char *str = toCharString(strsrch->getText());
errln("Text: %s\n", str);
str = toCharString(strsrch->getPattern());
errln("Pattern: %s\n", str);
errln("Error preceding match starting at %d (overlap: %d) found at %d (len:%d); expected %d (len:%d)\n",
nextStart, isOverlap,
strsrch->getMatchedStart(), strsrch->getMatchedLength(),
matchindex, matchlength);
return FALSE;
}
nextStart = matchindex;
count--;
}
strsrch->setAttribute(USEARCH_ELEMENT_COMPARISON, USEARCH_STANDARD_ELEMENT_COMPARISON, status);
return TRUE;
}
UBool StringSearchTest::assertEqual(const SearchData *search)
{
UErrorCode status = U_ZERO_ERROR;
Collator *collator = getCollator(search->collator);
BreakIterator *breaker = getBreakIterator(search->breaker);
StringSearch *strsrch, *strsrch2;
UChar temp[128];
#if UCONFIG_NO_BREAK_ITERATION
if(search->breaker) {
return TRUE; /* skip test */
}
#endif
u_unescape(search->text, temp, 128);
UnicodeString text;
text.setTo(temp);
u_unescape(search->pattern, temp, 128);
UnicodeString pattern;
pattern.setTo(temp);
#if !UCONFIG_NO_BREAK_ITERATION
if (breaker != NULL) {
breaker->setText(text);
}
#endif
collator->setStrength(getECollationStrength(search->strength));
strsrch = new StringSearch(pattern, text, (RuleBasedCollator *)collator,
breaker, status);
if (U_FAILURE(status)) {
errln("Error opening string search %s", u_errorName(status));
return FALSE;
}
if (!assertEqualWithStringSearch(strsrch, search)) {
collator->setStrength(getECollationStrength(UCOL_TERTIARY));
delete strsrch;
return FALSE;
}
strsrch2 = strsrch->clone();
if( strsrch2 == strsrch || *strsrch2 != *strsrch ||
!assertEqualWithStringSearch(strsrch2, search)
) {
infoln("failure with StringSearch.clone()");
collator->setStrength(getECollationStrength(UCOL_TERTIARY));
delete strsrch;
delete strsrch2;
return FALSE;
}
delete strsrch2;
collator->setStrength(getECollationStrength(UCOL_TERTIARY));
delete strsrch;
return TRUE;
}
UBool StringSearchTest::assertCanonicalEqual(const SearchData *search)
{
UErrorCode status = U_ZERO_ERROR;
Collator *collator = getCollator(search->collator);
BreakIterator *breaker = getBreakIterator(search->breaker);
StringSearch *strsrch;
UChar temp[128];
UBool result = TRUE;
#if UCONFIG_NO_BREAK_ITERATION
if(search->breaker) {
return TRUE; /* skip test */
}
#endif
u_unescape(search->text, temp, 128);
UnicodeString text;
text.setTo(temp);
u_unescape(search->pattern, temp, 128);
UnicodeString pattern;
pattern.setTo(temp);
#if !UCONFIG_NO_BREAK_ITERATION
if (breaker != NULL) {
breaker->setText(text);
}
#endif
collator->setStrength(getECollationStrength(search->strength));
collator->setAttribute(UCOL_NORMALIZATION_MODE, UCOL_ON, status);
strsrch = new StringSearch(pattern, text, (RuleBasedCollator *)collator,
breaker, status);
strsrch->setAttribute(USEARCH_CANONICAL_MATCH, USEARCH_ON, status);
if (U_FAILURE(status)) {
errln("Error opening string search %s", u_errorName(status));
result = FALSE;
goto bail;
}
if (!assertEqualWithStringSearch(strsrch, search)) {
result = FALSE;
goto bail;
}
bail:
collator->setStrength(getECollationStrength(UCOL_TERTIARY));
collator->setAttribute(UCOL_NORMALIZATION_MODE, UCOL_OFF, status);
delete strsrch;
return result;
}
UBool StringSearchTest::assertEqualWithAttribute(const SearchData *search,
USearchAttributeValue canonical,
USearchAttributeValue overlap)
{
UErrorCode status = U_ZERO_ERROR;
Collator *collator = getCollator(search->collator);
BreakIterator *breaker = getBreakIterator(search->breaker);
StringSearch *strsrch;
UChar temp[128];
#if UCONFIG_NO_BREAK_ITERATION
if(search->breaker) {
return TRUE; /* skip test */
}
#endif
u_unescape(search->text, temp, 128);
UnicodeString text;
text.setTo(temp);
u_unescape(search->pattern, temp, 128);
UnicodeString pattern;
pattern.setTo(temp);
#if !UCONFIG_NO_BREAK_ITERATION
if (breaker != NULL) {
breaker->setText(text);
}
#endif
collator->setStrength(getECollationStrength(search->strength));
strsrch = new StringSearch(pattern, text, (RuleBasedCollator *)collator,
breaker, status);
strsrch->setAttribute(USEARCH_CANONICAL_MATCH, canonical, status);
strsrch->setAttribute(USEARCH_OVERLAP, overlap, status);
if (U_FAILURE(status)) {
errln("Error opening string search %s", u_errorName(status));
return FALSE;
}
if (!assertEqualWithStringSearch(strsrch, search)) {
collator->setStrength(getECollationStrength(UCOL_TERTIARY));
delete strsrch;
return FALSE;
}
collator->setStrength(getECollationStrength(UCOL_TERTIARY));
delete strsrch;
return TRUE;
}
void StringSearchTest::TestOpenClose()
{
UErrorCode status = U_ZERO_ERROR;
StringSearch *result;
BreakIterator *breakiter = m_en_wordbreaker_;
UnicodeString pattern;
UnicodeString text;
UnicodeString temp("a");
StringCharacterIterator chariter(text);
/* testing null arguments */
result = new StringSearch(pattern, text, NULL, NULL, status);
if (U_SUCCESS(status)) {
errln("Error: NULL arguments should produce an error");
}
delete result;
chariter.setText(text);
status = U_ZERO_ERROR;
result = new StringSearch(pattern, chariter, NULL, NULL, status);
if (U_SUCCESS(status)) {
errln("Error: NULL arguments should produce an error");
}
delete result;
text.append(0, 0x1);
status = U_ZERO_ERROR;
result = new StringSearch(pattern, text, NULL, NULL, status);
if (U_SUCCESS(status)) {
errln("Error: Empty pattern should produce an error");
}
delete result;
chariter.setText(text);
status = U_ZERO_ERROR;
result = new StringSearch(pattern, chariter, NULL, NULL, status);
if (U_SUCCESS(status)) {
errln("Error: Empty pattern should produce an error");
}
delete result;
text.remove();
pattern.append(temp);
status = U_ZERO_ERROR;
result = new StringSearch(pattern, text, NULL, NULL, status);
if (U_SUCCESS(status)) {
errln("Error: Empty text should produce an error");
}
delete result;
chariter.setText(text);
status = U_ZERO_ERROR;
result = new StringSearch(pattern, chariter, NULL, NULL, status);
if (U_SUCCESS(status)) {
errln("Error: Empty text should produce an error");
}
delete result;
text.append(temp);
status = U_ZERO_ERROR;
result = new StringSearch(pattern, text, NULL, NULL, status);
if (U_SUCCESS(status)) {
errln("Error: NULL arguments should produce an error");
}
delete result;
chariter.setText(text);
status = U_ZERO_ERROR;
result = new StringSearch(pattern, chariter, NULL, NULL, status);
if (U_SUCCESS(status)) {
errln("Error: NULL arguments should produce an error");
}
delete result;
status = U_ZERO_ERROR;
result = new StringSearch(pattern, text, m_en_us_, NULL, status);
if (U_FAILURE(status)) {
errln("Error: NULL break iterator is valid for opening search");
}
delete result;
status = U_ZERO_ERROR;
result = new StringSearch(pattern, chariter, m_en_us_, NULL, status);
if (U_FAILURE(status)) {
errln("Error: NULL break iterator is valid for opening search");
}
delete result;
status = U_ZERO_ERROR;
result = new StringSearch(pattern, text, Locale::getEnglish(), NULL, status);
if (U_FAILURE(status) || result == NULL) {
errln("Error: NULL break iterator is valid for opening search");
}
delete result;
status = U_ZERO_ERROR;
result = new StringSearch(pattern, chariter, Locale::getEnglish(), NULL, status);
if (U_FAILURE(status)) {
errln("Error: NULL break iterator is valid for opening search");
}
delete result;
status = U_ZERO_ERROR;
result = new StringSearch(pattern, text, m_en_us_, breakiter, status);
if (U_FAILURE(status)) {
errln("Error: Break iterator is valid for opening search");
}
delete result;
status = U_ZERO_ERROR;
result = new StringSearch(pattern, chariter, m_en_us_, NULL, status);
if (U_FAILURE(status)) {
errln("Error: Break iterator is valid for opening search");
}
delete result;
}
void StringSearchTest::TestInitialization()
{
UErrorCode status = U_ZERO_ERROR;
UnicodeString pattern;
UnicodeString text;
UnicodeString temp("a");
StringSearch *result;
int count;
/* simple test on the pattern ce construction */
pattern.append(temp);
pattern.append(temp);
text.append(temp);
text.append(temp);
text.append(temp);
result = new StringSearch(pattern, text, m_en_us_, NULL, status);
if (U_FAILURE(status)) {
errln("Error opening search %s", u_errorName(status));
}
StringSearch *copy = new StringSearch(*result);
if (*(copy->getCollator()) != *(result->getCollator()) ||
copy->getBreakIterator() != result->getBreakIterator() ||
copy->getMatchedLength() != result->getMatchedLength() ||
copy->getMatchedStart() != result->getMatchedStart() ||
copy->getOffset() != result->getOffset() ||
copy->getPattern() != result->getPattern() ||
copy->getText() != result->getText() ||
*(copy) != *(result))
{
errln("Error copying StringSearch");
}
delete copy;
copy = (StringSearch *)result->safeClone();
if (*(copy->getCollator()) != *(result->getCollator()) ||
copy->getBreakIterator() != result->getBreakIterator() ||
copy->getMatchedLength() != result->getMatchedLength() ||
copy->getMatchedStart() != result->getMatchedStart() ||
copy->getOffset() != result->getOffset() ||
copy->getPattern() != result->getPattern() ||
copy->getText() != result->getText() ||
*(copy) != *(result)) {
errln("Error copying StringSearch");
}
delete result;
/* testing if an extremely large pattern will fail the initialization */
for (count = 0; count < 512; count ++) {
pattern.append(temp);
}
result = new StringSearch(pattern, text, m_en_us_, NULL, status);
if (*result != *result) {
errln("Error: string search object expected to match itself");
}
if (*result == *copy) {
errln("Error: string search objects are not expected to match");
}
*copy = *result;
if (*(copy->getCollator()) != *(result->getCollator()) ||
copy->getBreakIterator() != result->getBreakIterator() ||
copy->getMatchedLength() != result->getMatchedLength() ||
copy->getMatchedStart() != result->getMatchedStart() ||
copy->getOffset() != result->getOffset() ||
copy->getPattern() != result->getPattern() ||
copy->getText() != result->getText() ||
*(copy) != *(result)) {
errln("Error copying StringSearch");
}
if (U_FAILURE(status)) {
errln("Error opening search %s", u_errorName(status));
}
delete result;
delete copy;
}
void StringSearchTest::TestBasic()
{
int count = 0;
while (BASIC[count].text != NULL) {
//printf("count %d", count);
if (!assertEqual(&BASIC[count])) {
infoln("Error at test number %d", count);
}
count ++;
}
}
void StringSearchTest::TestNormExact()
{
int count = 0;
UErrorCode status = U_ZERO_ERROR;
m_en_us_->setAttribute(UCOL_NORMALIZATION_MODE, UCOL_ON, status);
if (U_FAILURE(status)) {
errln("Error setting collation normalization %s",
u_errorName(status));
}
while (BASIC[count].text != NULL) {
if (!assertEqual(&BASIC[count])) {
infoln("Error at test number %d", count);
}
count ++;
}
count = 0;
while (NORMEXACT[count].text != NULL) {
if (!assertEqual(&NORMEXACT[count])) {
infoln("Error at test number %d", count);
}
count ++;
}
m_en_us_->setAttribute(UCOL_NORMALIZATION_MODE, UCOL_OFF, status);
count = 0;
while (NONNORMEXACT[count].text != NULL) {
if (!assertEqual(&NONNORMEXACT[count])) {
infoln("Error at test number %d", count);
}
count ++;
}
}
void StringSearchTest::TestStrength()
{
int count = 0;
while (STRENGTH[count].text != NULL) {
if (!assertEqual(&STRENGTH[count])) {
infoln("Error at test number %d", count);
}
count ++;
}
}
#if !UCONFIG_NO_BREAK_ITERATION
void StringSearchTest::TestBreakIterator()
{
UChar temp[128];
u_unescape(BREAKITERATOREXACT[0].text, temp, 128);
UnicodeString text;
text.setTo(temp, u_strlen(temp));
u_unescape(BREAKITERATOREXACT[0].pattern, temp, 128);
UnicodeString pattern;
pattern.setTo(temp, u_strlen(temp));
UErrorCode status = U_ZERO_ERROR;
StringSearch *strsrch = new StringSearch(pattern, text, m_en_us_, NULL,
status);
if (U_FAILURE(status)) {
errln("Error opening string search %s", u_errorName(status));
}
strsrch->setBreakIterator(NULL, status);
if (U_FAILURE(status) || strsrch->getBreakIterator() != NULL) {
errln("Error usearch_getBreakIterator returned wrong object");
}
strsrch->setBreakIterator(m_en_characterbreaker_, status);
if (U_FAILURE(status) ||
strsrch->getBreakIterator() != m_en_characterbreaker_) {
errln("Error usearch_getBreakIterator returned wrong object");
}
strsrch->setBreakIterator(m_en_wordbreaker_, status);
if (U_FAILURE(status) ||
strsrch->getBreakIterator() != m_en_wordbreaker_) {
errln("Error usearch_getBreakIterator returned wrong object");
}
delete strsrch;
int count = 0;
while (count < 4) {
// special purposes for tests numbers 0-3
const SearchData *search = &(BREAKITERATOREXACT[count]);
RuleBasedCollator *collator = getCollator(search->collator);
BreakIterator *breaker = getBreakIterator(search->breaker);
StringSearch *strsrch;
u_unescape(search->text, temp, 128);
text.setTo(temp, u_strlen(temp));
u_unescape(search->pattern, temp, 128);
pattern.setTo(temp, u_strlen(temp));
if (breaker != NULL) {
breaker->setText(text);
}
collator->setStrength(getECollationStrength(search->strength));
strsrch = new StringSearch(pattern, text, collator, breaker, status);
if (U_FAILURE(status) ||
strsrch->getBreakIterator() != breaker) {
errln("Error setting break iterator");
if (strsrch != NULL) {
delete strsrch;
}
}
if (!assertEqualWithStringSearch(strsrch, search)) {
collator->setStrength(getECollationStrength(UCOL_TERTIARY));
delete strsrch;
}
search = &(BREAKITERATOREXACT[count + 1]);
breaker = getBreakIterator(search->breaker);
if (breaker != NULL) {
breaker->setText(text);
}
strsrch->setBreakIterator(breaker, status);
if (U_FAILURE(status) ||
strsrch->getBreakIterator() != breaker) {
errln("Error setting break iterator");
delete strsrch;
}
strsrch->reset();
if (!assertEqualWithStringSearch(strsrch, search)) {
infoln("Error at test number %d", count);
}
delete strsrch;
count += 2;
}
count = 0;
while (BREAKITERATOREXACT[count].text != NULL) {
if (!assertEqual(&BREAKITERATOREXACT[count])) {
infoln("Error at test number %d", count);
}
count ++;
}
}
#endif
void StringSearchTest::TestVariable()
{
int count = 0;
UErrorCode status = U_ZERO_ERROR;
m_en_us_->setAttribute(UCOL_ALTERNATE_HANDLING, UCOL_SHIFTED, status);
if (U_FAILURE(status)) {
errln("Error setting collation alternate attribute %s",
u_errorName(status));
}
while (VARIABLE[count].text != NULL) {
logln("variable %d", count);
if (!assertEqual(&VARIABLE[count])) {
infoln("Error at test number %d", count);
}
count ++;
}
m_en_us_->setAttribute(UCOL_ALTERNATE_HANDLING, UCOL_NON_IGNORABLE,
status);
}
void StringSearchTest::TestOverlap()
{
int count = 0;
while (OVERLAP[count].text != NULL) {
if (!assertEqualWithAttribute(&OVERLAP[count], USEARCH_OFF,
USEARCH_ON)) {
errln("Error at overlap test number %d", count);
}
count ++;
}
count = 0;
while (NONOVERLAP[count].text != NULL) {
if (!assertEqual(&NONOVERLAP[count])) {
errln("Error at non overlap test number %d", count);
}
count ++;
}
count = 0;
while (count < 1) {
const SearchData *search = &(OVERLAP[count]);
UChar temp[128];
u_unescape(search->text, temp, 128);
UnicodeString text;
text.setTo(temp, u_strlen(temp));
u_unescape(search->pattern, temp, 128);
UnicodeString pattern;
pattern.setTo(temp, u_strlen(temp));
RuleBasedCollator *collator = getCollator(search->collator);
UErrorCode status = U_ZERO_ERROR;
StringSearch *strsrch = new StringSearch(pattern, text,
collator, NULL,
status);
strsrch->setAttribute(USEARCH_OVERLAP, USEARCH_ON, status);
if (U_FAILURE(status) ||
strsrch->getAttribute(USEARCH_OVERLAP) != USEARCH_ON) {
errln("Error setting overlap option");
}
if (!assertEqualWithStringSearch(strsrch, search)) {
delete strsrch;
return;
}
search = &(NONOVERLAP[count]);
strsrch->setAttribute(USEARCH_OVERLAP, USEARCH_OFF, status);
if (U_FAILURE(status) ||
strsrch->getAttribute(USEARCH_OVERLAP) != USEARCH_OFF) {
errln("Error setting overlap option");
}
strsrch->reset();
if (!assertEqualWithStringSearch(strsrch, search)) {
delete strsrch;
errln("Error at test number %d", count);
}
count ++;
delete strsrch;
}
}
void StringSearchTest::TestCollator()
{
// test collator that thinks "o" and "p" are the same thing
UChar temp[128];
u_unescape(COLLATOR[0].text, temp, 128);
UnicodeString text;
text.setTo(temp, u_strlen(temp));
u_unescape(COLLATOR[0].pattern, temp, 128);
UnicodeString pattern;
pattern.setTo(temp, u_strlen(temp));
UErrorCode status = U_ZERO_ERROR;
StringSearch *strsrch = new StringSearch(pattern, text, m_en_us_, NULL,
status);
if (U_FAILURE(status)) {
errln("Error opening string search %s", u_errorName(status));
delete strsrch;
return;
}
if (!assertEqualWithStringSearch(strsrch, &COLLATOR[0])) {
delete strsrch;
return;
}
u_unescape(TESTCOLLATORRULE, temp, 128);
UnicodeString rules;
rules.setTo(temp, u_strlen(temp));
RuleBasedCollator *tailored = new RuleBasedCollator(rules, status);
tailored->setStrength(getECollationStrength(COLLATOR[1].strength));
if (U_FAILURE(status)) {
errln("Error opening rule based collator %s", u_errorName(status));
delete strsrch;
delete tailored;
return;
}
strsrch->setCollator(tailored, status);
if (U_FAILURE(status) || (*strsrch->getCollator()) != (*tailored)) {
errln("Error setting rule based collator");
delete strsrch;
delete tailored;
}
strsrch->reset();
if (!assertEqualWithStringSearch(strsrch, &COLLATOR[1])) {
delete strsrch;
delete tailored;
return;
}
strsrch->setCollator(m_en_us_, status);
strsrch->reset();
if (U_FAILURE(status) || (*strsrch->getCollator()) != (*m_en_us_)) {
errln("Error setting rule based collator");
delete strsrch;
delete tailored;
}
if (!assertEqualWithStringSearch(strsrch, &COLLATOR[0])) {
errln("Error searching collator test");
}
delete strsrch;
delete tailored;
}
void StringSearchTest::TestPattern()
{
UChar temp[512];
int templength;
u_unescape(PATTERN[0].text, temp, 512);
UnicodeString text;
text.setTo(temp, u_strlen(temp));
u_unescape(PATTERN[0].pattern, temp, 512);
UnicodeString pattern;
pattern.setTo(temp, u_strlen(temp));
m_en_us_->setStrength(getECollationStrength(PATTERN[0].strength));
UErrorCode status = U_ZERO_ERROR;
StringSearch *strsrch = new StringSearch(pattern, text, m_en_us_, NULL,
status);
if (U_FAILURE(status)) {
errln("Error opening string search %s", u_errorName(status));
m_en_us_->setStrength(getECollationStrength(UCOL_TERTIARY));
if (strsrch != NULL) {
delete strsrch;
}
return;
}
if (strsrch->getPattern() != pattern) {
errln("Error setting pattern");
}
if (!assertEqualWithStringSearch(strsrch, &PATTERN[0])) {
m_en_us_->setStrength(getECollationStrength(UCOL_TERTIARY));
if (strsrch != NULL) {
delete strsrch;
}
return;
}
u_unescape(PATTERN[1].pattern, temp, 512);
pattern.setTo(temp, u_strlen(temp));
strsrch->setPattern(pattern, status);
if (pattern != strsrch->getPattern()) {
errln("Error setting pattern");
m_en_us_->setStrength(getECollationStrength(UCOL_TERTIARY));
if (strsrch != NULL) {
delete strsrch;
}
return;
}
strsrch->reset();
if (U_FAILURE(status)) {
errln("Error setting pattern %s", u_errorName(status));
}
if (!assertEqualWithStringSearch(strsrch, &PATTERN[1])) {
m_en_us_->setStrength(getECollationStrength(UCOL_TERTIARY));
if (strsrch != NULL) {
delete strsrch;
}
return;
}
u_unescape(PATTERN[0].pattern, temp, 512);
pattern.setTo(temp, u_strlen(temp));
strsrch->setPattern(pattern, status);
if (pattern != strsrch->getPattern()) {
errln("Error setting pattern");
m_en_us_->setStrength(getECollationStrength(UCOL_TERTIARY));
if (strsrch != NULL) {
delete strsrch;
}
return;
}
strsrch->reset();
if (U_FAILURE(status)) {
errln("Error setting pattern %s", u_errorName(status));
}
if (!assertEqualWithStringSearch(strsrch, &PATTERN[0])) {
m_en_us_->setStrength(getECollationStrength(UCOL_TERTIARY));
if (strsrch != NULL) {
delete strsrch;
}
return;
}
/* enormous pattern size to see if this crashes */
for (templength = 0; templength != 512; templength ++) {
temp[templength] = 0x61;
}
temp[511] = 0;
pattern.setTo(temp, 511);
strsrch->setPattern(pattern, status);
if (U_FAILURE(status)) {
errln("Error setting pattern with size 512, %s", u_errorName(status));
}
m_en_us_->setStrength(getECollationStrength(UCOL_TERTIARY));
if (strsrch != NULL) {
delete strsrch;
}
}
void StringSearchTest::TestText()
{
UChar temp[128];
u_unescape(TEXT[0].text, temp, 128);
UnicodeString text;
text.setTo(temp, u_strlen(temp));
u_unescape(TEXT[0].pattern, temp, 128);
UnicodeString pattern;
pattern.setTo(temp, u_strlen(temp));
UErrorCode status = U_ZERO_ERROR;
StringSearch *strsrch = new StringSearch(pattern, text, m_en_us_, NULL,
status);
if (U_FAILURE(status)) {
errln("Error opening string search %s", u_errorName(status));
return;
}
if (text != strsrch->getText()) {
errln("Error setting text");
}
if (!assertEqualWithStringSearch(strsrch, &TEXT[0])) {
delete strsrch;
return;
}
u_unescape(TEXT[1].text, temp, 128);
text.setTo(temp, u_strlen(temp));
strsrch->setText(text, status);
if (text != strsrch->getText()) {
errln("Error setting text");
delete strsrch;
return;
}
if (U_FAILURE(status)) {
errln("Error setting text %s", u_errorName(status));
}
if (!assertEqualWithStringSearch(strsrch, &TEXT[1])) {
delete strsrch;
return;
}
u_unescape(TEXT[0].text, temp, 128);
text.setTo(temp, u_strlen(temp));
StringCharacterIterator chariter(text);
strsrch->setText(chariter, status);
if (text != strsrch->getText()) {
errln("Error setting text");
delete strsrch;
return;
}
if (U_FAILURE(status)) {
errln("Error setting pattern %s", u_errorName(status));
}
if (!assertEqualWithStringSearch(strsrch, &TEXT[0])) {
errln("Error searching within set text");
}
delete strsrch;
}
void StringSearchTest::TestCompositeBoundaries()
{
int count = 0;
while (COMPOSITEBOUNDARIES[count].text != NULL) {
logln("composite %d", count);
if (!assertEqual(&COMPOSITEBOUNDARIES[count])) {
errln("Error at test number %d", count);
}
count ++;
}
}
void StringSearchTest::TestGetSetOffset()
{
UErrorCode status = U_ZERO_ERROR;
UnicodeString pattern("1234567890123456");
UnicodeString text("12345678901234567890123456789012");
StringSearch *strsrch = new StringSearch(pattern, text, m_en_us_,
NULL, status);
/* testing out of bounds error */
strsrch->setOffset(-1, status);
if (U_SUCCESS(status)) {
errln("Error expecting set offset error");
}
strsrch->setOffset(128, status);
if (U_SUCCESS(status)) {
errln("Error expecting set offset error");
}
int index = 0;
while (BASIC[index].text != NULL) {
UErrorCode status = U_ZERO_ERROR;
SearchData search = BASIC[index ++];
UChar temp[128];
u_unescape(search.text, temp, 128);
text.setTo(temp, u_strlen(temp));
u_unescape(search.pattern, temp, 128);
pattern.setTo(temp, u_strlen(temp));
strsrch->setText(text, status);
strsrch->setPattern(pattern, status);
strsrch->getCollator()->setStrength(getECollationStrength(
search.strength));
strsrch->reset();
int count = 0;
int32_t matchindex = search.offset[count];
while (U_SUCCESS(status) && matchindex >= 0) {
int32_t matchlength = search.size[count];
strsrch->next(status);
if (matchindex != strsrch->getMatchedStart() ||
matchlength != strsrch->getMatchedLength()) {
char *str = toCharString(strsrch->getText());
errln("Text: %s", str);
str = toCharString(strsrch->getPattern());
errln("Pattern: %s", str);
errln("Error match found at %d %d",
strsrch->getMatchedStart(),
strsrch->getMatchedLength());
return;
}
matchindex = search.offset[count + 1] == -1 ? -1 :
search.offset[count + 2];
if (search.offset[count + 1] != -1) {
strsrch->setOffset(search.offset[count + 1] + 1, status);
if (strsrch->getOffset() != search.offset[count + 1] + 1) {
errln("Error setting offset\n");
return;
}
}
count += 2;
}
strsrch->next(status);
if (strsrch->getMatchedStart() != USEARCH_DONE) {
char *str = toCharString(strsrch->getText());
errln("Text: %s", str);
str = toCharString(strsrch->getPattern());
errln("Pattern: %s", str);
errln("Error match found at %d %d",
strsrch->getMatchedStart(),
strsrch->getMatchedLength());
return;
}
}
strsrch->getCollator()->setStrength(getECollationStrength(
UCOL_TERTIARY));
delete strsrch;
}
void StringSearchTest::TestGetSetAttribute()
{
UErrorCode status = U_ZERO_ERROR;
UnicodeString pattern("pattern");
UnicodeString text("text");
StringSearch *strsrch = new StringSearch(pattern, text, m_en_us_, NULL,
status);
if (U_FAILURE(status)) {
errln("Error opening search %s", u_errorName(status));
return;
}
strsrch->setAttribute(USEARCH_OVERLAP, USEARCH_DEFAULT, status);
if (U_FAILURE(status) ||
strsrch->getAttribute(USEARCH_OVERLAP) != USEARCH_OFF) {
errln("Error setting overlap to the default");
}
strsrch->setAttribute(USEARCH_OVERLAP, USEARCH_ON, status);
if (U_FAILURE(status) ||
strsrch->getAttribute(USEARCH_OVERLAP) != USEARCH_ON) {
errln("Error setting overlap true");
}
strsrch->setAttribute(USEARCH_OVERLAP, USEARCH_OFF, status);
if (U_FAILURE(status) ||
strsrch->getAttribute(USEARCH_OVERLAP) != USEARCH_OFF) {
errln("Error setting overlap false");
}
strsrch->setAttribute(USEARCH_OVERLAP, USEARCH_ATTRIBUTE_VALUE_COUNT,
status);
if (U_SUCCESS(status)) {
errln("Error setting overlap to illegal value");
}
status = U_ZERO_ERROR;
strsrch->setAttribute(USEARCH_CANONICAL_MATCH, USEARCH_DEFAULT, status);
if (U_FAILURE(status) ||
strsrch->getAttribute(USEARCH_CANONICAL_MATCH) != USEARCH_OFF) {
errln("Error setting canonical match to the default");
}
strsrch->setAttribute(USEARCH_CANONICAL_MATCH, USEARCH_ON, status);
if (U_FAILURE(status) ||
strsrch->getAttribute(USEARCH_CANONICAL_MATCH) != USEARCH_ON) {
errln("Error setting canonical match true");
}
strsrch->setAttribute(USEARCH_CANONICAL_MATCH, USEARCH_OFF, status);
if (U_FAILURE(status) ||
strsrch->getAttribute(USEARCH_CANONICAL_MATCH) != USEARCH_OFF) {
errln("Error setting canonical match false");
}
strsrch->setAttribute(USEARCH_CANONICAL_MATCH,
USEARCH_ATTRIBUTE_VALUE_COUNT, status);
if (U_SUCCESS(status)) {
errln("Error setting canonical match to illegal value");
}
status = U_ZERO_ERROR;
strsrch->setAttribute(USEARCH_ATTRIBUTE_COUNT, USEARCH_DEFAULT, status);
if (U_SUCCESS(status)) {
errln("Error setting illegal attribute success");
}
delete strsrch;
}
void StringSearchTest::TestGetMatch()
{
UChar temp[128];
SearchData search = MATCH[0];
u_unescape(search.text, temp, 128);
UnicodeString text;
text.setTo(temp, u_strlen(temp));
u_unescape(search.pattern, temp, 128);
UnicodeString pattern;
pattern.setTo(temp, u_strlen(temp));
UErrorCode status = U_ZERO_ERROR;
StringSearch *strsrch = new StringSearch(pattern, text, m_en_us_, NULL,
status);
if (U_FAILURE(status)) {
errln("Error opening string search %s", u_errorName(status));
if (strsrch != NULL) {
delete strsrch;
}
return;
}
int count = 0;
int32_t matchindex = search.offset[count];
UnicodeString matchtext;
while (U_SUCCESS(status) && matchindex >= 0) {
int32_t matchlength = search.size[count];
strsrch->next(status);
if (matchindex != strsrch->getMatchedStart() ||
matchlength != strsrch->getMatchedLength()) {
char *str = toCharString(strsrch->getText());
errln("Text: %s", str);
str = toCharString(strsrch->getPattern());
errln("Pattern: %s", str);
errln("Error match found at %d %d", strsrch->getMatchedStart(),
strsrch->getMatchedLength());
return;
}
count ++;
status = U_ZERO_ERROR;
strsrch->getMatchedText(matchtext);
if (matchtext.length() != matchlength || U_FAILURE(status)){
errln("Error getting match text");
}
matchindex = search.offset[count];
}
status = U_ZERO_ERROR;
strsrch->next(status);
if (strsrch->getMatchedStart() != USEARCH_DONE ||
strsrch->getMatchedLength() != 0) {
errln("Error end of match not found");
}
status = U_ZERO_ERROR;
strsrch->getMatchedText(matchtext);
if (matchtext.length() != 0) {
errln("Error getting null matches");
}
delete strsrch;
}
void StringSearchTest::TestSetMatch()
{
int count = 0;
while (MATCH[count].text != NULL) {
SearchData search = MATCH[count];
UChar temp[128];
UErrorCode status = U_ZERO_ERROR;
u_unescape(search.text, temp, 128);
UnicodeString text;
text.setTo(temp, u_strlen(temp));
u_unescape(search.pattern, temp, 128);
UnicodeString pattern;
pattern.setTo(temp, u_strlen(temp));
StringSearch *strsrch = new StringSearch(pattern, text, m_en_us_,
NULL, status);
if (U_FAILURE(status)) {
errln("Error opening string search %s", u_errorName(status));
if (strsrch != NULL) {
delete strsrch;
}
return;
}
int size = 0;
while (search.offset[size] != -1) {
size ++;
}
if (strsrch->first(status) != search.offset[0] || U_FAILURE(status)) {
errln("Error getting first match");
}
if (strsrch->last(status) != search.offset[size -1] ||
U_FAILURE(status)) {
errln("Error getting last match");
}
int index = 0;
while (index < size) {
if (index + 2 < size) {
if (strsrch->following(search.offset[index + 2] - 1, status)
!= search.offset[index + 2] || U_FAILURE(status)) {
errln("Error getting following match at index %d",
search.offset[index + 2] - 1);
}
}
if (index + 1 < size) {
if (strsrch->preceding(search.offset[index + 1] +
search.size[index + 1] + 1,
status) != search.offset[index + 1] ||
U_FAILURE(status)) {
errln("Error getting preceeding match at index %d",
search.offset[index + 1] + 1);
}
}
index += 2;
}
status = U_ZERO_ERROR;
if (strsrch->following(text.length(), status) != USEARCH_DONE) {
errln("Error expecting out of bounds match");
}
if (strsrch->preceding(0, status) != USEARCH_DONE) {
errln("Error expecting out of bounds match");
}
count ++;
delete strsrch;
}
}
void StringSearchTest::TestReset()
{
UErrorCode status = U_ZERO_ERROR;
UnicodeString text("fish fish");
UnicodeString pattern("s");
StringSearch *strsrch = new StringSearch(pattern, text, m_en_us_, NULL,
status);
if (U_FAILURE(status)) {
errln("Error opening string search %s", u_errorName(status));
if (strsrch != NULL) {
delete strsrch;
}
return;
}
strsrch->setAttribute(USEARCH_OVERLAP, USEARCH_ON, status);
strsrch->setAttribute(USEARCH_CANONICAL_MATCH, USEARCH_ON, status);
strsrch->setOffset(9, status);
if (U_FAILURE(status)) {
errln("Error setting attributes and offsets");
}
else {
strsrch->reset();
if (strsrch->getAttribute(USEARCH_OVERLAP) != USEARCH_OFF ||
strsrch->getAttribute(USEARCH_CANONICAL_MATCH) != USEARCH_OFF ||
strsrch->getOffset() != 0 || strsrch->getMatchedLength() != 0 ||
strsrch->getMatchedStart() != USEARCH_DONE) {
errln("Error resetting string search");
}
strsrch->previous(status);
if (strsrch->getMatchedStart() != 7 ||
strsrch->getMatchedLength() != 1) {
errln("Error resetting string search\n");
}
}
delete strsrch;
}
void StringSearchTest::TestSupplementary()
{
int count = 0;
while (SUPPLEMENTARY[count].text != NULL) {
if (!assertEqual(&SUPPLEMENTARY[count])) {
errln("Error at test number %d", count);
}
count ++;
}
}
void StringSearchTest::TestContraction()
{
UChar temp[128];
UErrorCode status = U_ZERO_ERROR;
u_unescape(CONTRACTIONRULE, temp, 128);
UnicodeString rules;
rules.setTo(temp, u_strlen(temp));
RuleBasedCollator *collator = new RuleBasedCollator(rules,
getECollationStrength(UCOL_TERTIARY), UCOL_ON, status);
if (U_FAILURE(status)) {
errln("Error opening collator %s", u_errorName(status));
}
UnicodeString text("text");
UnicodeString pattern("pattern");
StringSearch *strsrch = new StringSearch(pattern, text, collator, NULL,
status);
if (U_FAILURE(status)) {
errln("Error opening string search %s", u_errorName(status));
}
int count = 0;
while (CONTRACTION[count].text != NULL) {
u_unescape(CONTRACTION[count].text, temp, 128);
text.setTo(temp, u_strlen(temp));
u_unescape(CONTRACTION[count].pattern, temp, 128);
pattern.setTo(temp, u_strlen(temp));
strsrch->setText(text, status);
strsrch->setPattern(pattern, status);
if (!assertEqualWithStringSearch(strsrch, &CONTRACTION[count])) {
errln("Error at test number %d", count);
}
count ++;
}
delete strsrch;
delete collator;
}
void StringSearchTest::TestIgnorable()
{
UChar temp[128];
u_unescape(IGNORABLERULE, temp, 128);
UnicodeString rules;
rules.setTo(temp, u_strlen(temp));
UErrorCode status = U_ZERO_ERROR;
int count = 0;
RuleBasedCollator *collator = new RuleBasedCollator(rules,
getECollationStrength(IGNORABLE[count].strength),
UCOL_ON, status);
if (U_FAILURE(status)) {
errln("Error opening collator %s", u_errorName(status));
return;
}
UnicodeString pattern("pattern");
UnicodeString text("text");
StringSearch *strsrch = new StringSearch(pattern, text, collator, NULL,
status);
if (U_FAILURE(status)) {
errln("Error opening string search %s", u_errorName(status));
delete collator;
return;
}
while (IGNORABLE[count].text != NULL) {
u_unescape(IGNORABLE[count].text, temp, 128);
text.setTo(temp, u_strlen(temp));
u_unescape(IGNORABLE[count].pattern, temp, 128);
pattern.setTo(temp, u_strlen(temp));
strsrch->setText(text, status);
strsrch->setPattern(pattern, status);
if (!assertEqualWithStringSearch(strsrch, &IGNORABLE[count])) {
errln("Error at test number %d", count);
}
count ++;
}
delete strsrch;
delete collator;
}
void StringSearchTest::TestDiacriticMatch()
{
UChar temp[128];
UErrorCode status = U_ZERO_ERROR;
int count = 0;
RuleBasedCollator* coll = NULL;
StringSearch *strsrch = NULL;
UnicodeString pattern("pattern");
UnicodeString text("text");
const SearchData *search;
search = &(DIACRITICMATCH[count]);
while (search->text != NULL) {
coll = getCollator(search->collator);
coll->setStrength(getECollationStrength(search->strength));
strsrch = new StringSearch(pattern, text, coll, getBreakIterator(search->breaker), status);
if (U_FAILURE(status)) {
errln("Error opening string search %s", u_errorName(status));
return;
}
u_unescape(search->text, temp, 128);
text.setTo(temp, u_strlen(temp));
u_unescape(search->pattern, temp, 128);
pattern.setTo(temp, u_strlen(temp));
strsrch->setText(text, status);
strsrch->setPattern(pattern, status);
if (!assertEqualWithStringSearch(strsrch, search)) {
errln("Error at test number %d", count);
}
search = &(DIACRITICMATCH[++count]);
delete strsrch;
}
}
void StringSearchTest::TestCanonical()
{
int count = 0;
while (BASICCANONICAL[count].text != NULL) {
if (!assertCanonicalEqual(&BASICCANONICAL[count])) {
errln("Error at test number %d", count);
}
count ++;
}
}
void StringSearchTest::TestNormCanonical()
{
UErrorCode status = U_ZERO_ERROR;
m_en_us_->setAttribute(UCOL_NORMALIZATION_MODE, UCOL_ON, status);
int count = 0;
while (NORMCANONICAL[count].text != NULL) {
if (!assertCanonicalEqual(&NORMCANONICAL[count])) {
errln("Error at test number %d", count);
}
count ++;
}
m_en_us_->setAttribute(UCOL_NORMALIZATION_MODE, UCOL_OFF, status);
}
void StringSearchTest::TestStrengthCanonical()
{
int count = 0;
while (STRENGTHCANONICAL[count].text != NULL) {
if (!assertCanonicalEqual(&STRENGTHCANONICAL[count])) {
errln("Error at test number %d", count);
}
count ++;
}
}
#if !UCONFIG_NO_BREAK_ITERATION
void StringSearchTest::TestBreakIteratorCanonical()
{
UErrorCode status = U_ZERO_ERROR;
int count = 0;
while (count < 4) {
// special purposes for tests numbers 0-3
UChar temp[128];
const SearchData *search = &(BREAKITERATORCANONICAL[count]);
u_unescape(search->text, temp, 128);
UnicodeString text;
text.setTo(temp, u_strlen(temp));
u_unescape(search->pattern, temp, 128);
UnicodeString pattern;
pattern.setTo(temp, u_strlen(temp));
RuleBasedCollator *collator = getCollator(search->collator);
collator->setStrength(getECollationStrength(search->strength));
BreakIterator *breaker = getBreakIterator(search->breaker);
StringSearch *strsrch = new StringSearch(pattern, text, collator,
breaker, status);
if (U_FAILURE(status)) {
errln("Error creating string search data");
return;
}
strsrch->setAttribute(USEARCH_CANONICAL_MATCH, USEARCH_ON, status);
if (U_FAILURE(status) ||
strsrch->getBreakIterator() != breaker) {
errln("Error setting break iterator");
delete strsrch;
return;
}
if (!assertEqualWithStringSearch(strsrch, search)) {
collator->setStrength(getECollationStrength(UCOL_TERTIARY));
delete strsrch;
return;
}
search = &(BREAKITERATOREXACT[count + 1]);
breaker = getBreakIterator(search->breaker);
if (breaker == NULL) {
errln("Error creating BreakIterator");
return;
}
breaker->setText(strsrch->getText());
strsrch->setBreakIterator(breaker, status);
if (U_FAILURE(status) || strsrch->getBreakIterator() != breaker) {
errln("Error setting break iterator");
delete strsrch;
return;
}
strsrch->reset();
strsrch->setAttribute(USEARCH_CANONICAL_MATCH, USEARCH_ON, status);
if (!assertEqualWithStringSearch(strsrch, search)) {
errln("Error at test number %d", count);
return;
}
delete strsrch;
count += 2;
}
count = 0;
while (BREAKITERATORCANONICAL[count].text != NULL) {
if (!assertEqual(&BREAKITERATORCANONICAL[count])) {
errln("Error at test number %d", count);
return;
}
count ++;
}
}
#endif
void StringSearchTest::TestVariableCanonical()
{
int count = 0;
UErrorCode status = U_ZERO_ERROR;
m_en_us_->setAttribute(UCOL_ALTERNATE_HANDLING, UCOL_SHIFTED, status);
if (U_FAILURE(status)) {
errln("Error setting collation alternate attribute %s",
u_errorName(status));
}
while (VARIABLE[count].text != NULL) {
logln("variable %d", count);
if (!assertCanonicalEqual(&VARIABLE[count])) {
errln("Error at test number %d", count);
}
count ++;
}
m_en_us_->setAttribute(UCOL_ALTERNATE_HANDLING, UCOL_NON_IGNORABLE,
status);
}
void StringSearchTest::TestOverlapCanonical()
{
int count = 0;
while (OVERLAPCANONICAL[count].text != NULL) {
if (!assertEqualWithAttribute(&OVERLAPCANONICAL[count], USEARCH_ON,
USEARCH_ON)) {
errln("Error at overlap test number %d", count);
}
count ++;
}
count = 0;
while (NONOVERLAP[count].text != NULL) {
if (!assertCanonicalEqual(&NONOVERLAPCANONICAL[count])) {
errln("Error at non overlap test number %d", count);
}
count ++;
}
count = 0;
while (count < 1) {
UChar temp[128];
const SearchData *search = &(OVERLAPCANONICAL[count]);
UErrorCode status = U_ZERO_ERROR;
u_unescape(search->text, temp, 128);
UnicodeString text;
text.setTo(temp, u_strlen(temp));
u_unescape(search->pattern, temp, 128);
UnicodeString pattern;
pattern.setTo(temp, u_strlen(temp));
RuleBasedCollator *collator = getCollator(search->collator);
StringSearch *strsrch = new StringSearch(pattern, text, collator,
NULL, status);
strsrch->setAttribute(USEARCH_CANONICAL_MATCH, USEARCH_ON, status);
strsrch->setAttribute(USEARCH_OVERLAP, USEARCH_ON, status);
if (U_FAILURE(status) ||
strsrch->getAttribute(USEARCH_OVERLAP) != USEARCH_ON) {
errln("Error setting overlap option");
}
if (!assertEqualWithStringSearch(strsrch, search)) {
delete strsrch;
return;
}
search = &(NONOVERLAPCANONICAL[count]);
strsrch->setAttribute(USEARCH_OVERLAP, USEARCH_OFF, status);
if (U_FAILURE(status) ||
strsrch->getAttribute(USEARCH_OVERLAP) != USEARCH_OFF) {
errln("Error setting overlap option");
}
strsrch->reset();
if (!assertEqualWithStringSearch(strsrch, search)) {
delete strsrch;
errln("Error at test number %d", count);
}
count ++;
delete strsrch;
}
}
void StringSearchTest::TestCollatorCanonical()
{
/* test collator that thinks "o" and "p" are the same thing */
UChar temp[128];
u_unescape(COLLATORCANONICAL[0].text, temp, 128);
UnicodeString text;
text.setTo(temp, u_strlen(temp));
u_unescape(COLLATORCANONICAL[0].pattern, temp, 128);
UnicodeString pattern;
pattern.setTo(temp, u_strlen(temp));
UErrorCode status = U_ZERO_ERROR;
StringSearch *strsrch = new StringSearch(pattern, text, m_en_us_,
NULL, status);
strsrch->setAttribute(USEARCH_CANONICAL_MATCH, USEARCH_ON, status);
if (U_FAILURE(status)) {
errln("Error opening string search %s", u_errorName(status));
}
if (!assertEqualWithStringSearch(strsrch, &COLLATORCANONICAL[0])) {
delete strsrch;
return;
}
u_unescape(TESTCOLLATORRULE, temp, 128);
UnicodeString rules;
rules.setTo(temp, u_strlen(temp));
RuleBasedCollator *tailored = new RuleBasedCollator(rules,
getECollationStrength(COLLATORCANONICAL[1].strength),
UCOL_ON, status);
if (U_FAILURE(status)) {
errln("Error opening rule based collator %s", u_errorName(status));
}
strsrch->setCollator(tailored, status);
if (U_FAILURE(status) || *(strsrch->getCollator()) != *tailored) {
errln("Error setting rule based collator");
}
strsrch->reset();
strsrch->setAttribute(USEARCH_CANONICAL_MATCH, USEARCH_ON, status);
if (!assertEqualWithStringSearch(strsrch, &COLLATORCANONICAL[1])) {
delete strsrch;
if (tailored != NULL) {
delete tailored;
}
return;
}
strsrch->setCollator(m_en_us_, status);
strsrch->reset();
if (U_FAILURE(status) || *(strsrch->getCollator()) != *m_en_us_) {
errln("Error setting rule based collator");
}
if (!assertEqualWithStringSearch(strsrch, &COLLATORCANONICAL[0])) {
}
delete strsrch;
if (tailored != NULL) {
delete tailored;
}
}
void StringSearchTest::TestPatternCanonical()
{
UChar temp[128];
u_unescape(PATTERNCANONICAL[0].text, temp, 128);
UnicodeString text;
text.setTo(temp, u_strlen(temp));
u_unescape(PATTERNCANONICAL[0].pattern, temp, 128);
UnicodeString pattern;
pattern.setTo(temp, u_strlen(temp));
m_en_us_->setStrength(
getECollationStrength(PATTERNCANONICAL[0].strength));
UErrorCode status = U_ZERO_ERROR;
StringSearch *strsrch = new StringSearch(pattern, text, m_en_us_, NULL,
status);
strsrch->setAttribute(USEARCH_CANONICAL_MATCH, USEARCH_ON, status);
if (U_FAILURE(status)) {
errln("Error opening string search %s", u_errorName(status));
goto ENDTESTPATTERN;
}
if (pattern != strsrch->getPattern()) {
errln("Error setting pattern");
}
if (!assertEqualWithStringSearch(strsrch, &PATTERNCANONICAL[0])) {
goto ENDTESTPATTERN;
}
u_unescape(PATTERNCANONICAL[1].pattern, temp, 128);
pattern.setTo(temp, u_strlen(temp));
strsrch->setPattern(pattern, status);
if (pattern != strsrch->getPattern()) {
errln("Error setting pattern");
goto ENDTESTPATTERN;
}
strsrch->reset();
strsrch->setAttribute(USEARCH_CANONICAL_MATCH, USEARCH_ON, status);
if (U_FAILURE(status)) {
errln("Error setting pattern %s", u_errorName(status));
}
if (!assertEqualWithStringSearch(strsrch, &PATTERNCANONICAL[1])) {
goto ENDTESTPATTERN;
}
u_unescape(PATTERNCANONICAL[0].pattern, temp, 128);
pattern.setTo(temp, u_strlen(temp));
strsrch->setPattern(pattern, status);
if (pattern != strsrch->getPattern()) {
errln("Error setting pattern");
goto ENDTESTPATTERN;
}
strsrch->reset();
strsrch->setAttribute(USEARCH_CANONICAL_MATCH, USEARCH_ON, status);
if (U_FAILURE(status)) {
errln("Error setting pattern %s", u_errorName(status));
}
if (!assertEqualWithStringSearch(strsrch, &PATTERNCANONICAL[0])) {
goto ENDTESTPATTERN;
}
ENDTESTPATTERN:
m_en_us_->setStrength(getECollationStrength(UCOL_TERTIARY));
if (strsrch != NULL) {
delete strsrch;
}
}
void StringSearchTest::TestTextCanonical()
{
UChar temp[128];
u_unescape(TEXTCANONICAL[0].text, temp, 128);
UnicodeString text;
text.setTo(temp, u_strlen(temp));
u_unescape(TEXTCANONICAL[0].pattern, temp, 128);
UnicodeString pattern;
pattern.setTo(temp, u_strlen(temp));
UErrorCode status = U_ZERO_ERROR;
StringSearch *strsrch = new StringSearch(pattern, text, m_en_us_, NULL,
status);
strsrch->setAttribute(USEARCH_CANONICAL_MATCH, USEARCH_ON, status);
if (U_FAILURE(status)) {
errln("Error opening string search %s", u_errorName(status));
goto ENDTESTPATTERN;
}
if (text != strsrch->getText()) {
errln("Error setting text");
}
if (!assertEqualWithStringSearch(strsrch, &TEXTCANONICAL[0])) {
goto ENDTESTPATTERN;
}
u_unescape(TEXTCANONICAL[1].text, temp, 128);
text.setTo(temp, u_strlen(temp));
strsrch->setText(text, status);
if (text != strsrch->getText()) {
errln("Error setting text");
goto ENDTESTPATTERN;
}
if (U_FAILURE(status)) {
errln("Error setting text %s", u_errorName(status));
}
if (!assertEqualWithStringSearch(strsrch, &TEXTCANONICAL[1])) {
goto ENDTESTPATTERN;
}
u_unescape(TEXTCANONICAL[0].text, temp, 128);
text.setTo(temp, u_strlen(temp));
strsrch->setText(text, status);
if (text != strsrch->getText()) {
errln("Error setting text");
goto ENDTESTPATTERN;
}
if (U_FAILURE(status)) {
errln("Error setting pattern %s", u_errorName(status));
}
if (!assertEqualWithStringSearch(strsrch, &TEXTCANONICAL[0])) {
goto ENDTESTPATTERN;
}
ENDTESTPATTERN:
if (strsrch != NULL) {
delete strsrch;
}
}
void StringSearchTest::TestCompositeBoundariesCanonical()
{
int count = 0;
while (COMPOSITEBOUNDARIESCANONICAL[count].text != NULL) {
logln("composite %d", count);
if (!assertCanonicalEqual(&COMPOSITEBOUNDARIESCANONICAL[count])) {
errln("Error at test number %d", count);
}
count ++;
}
}
void StringSearchTest::TestGetSetOffsetCanonical()
{
UErrorCode status = U_ZERO_ERROR;
UnicodeString text("text");
UnicodeString pattern("pattern");
StringSearch *strsrch = new StringSearch(pattern, text, m_en_us_, NULL,
status);
Collator *collator = strsrch->getCollator();
collator->setAttribute(UCOL_NORMALIZATION_MODE, UCOL_ON, status);
strsrch->setAttribute(USEARCH_CANONICAL_MATCH, USEARCH_ON, status);
/* testing out of bounds error */
strsrch->setOffset(-1, status);
if (U_SUCCESS(status)) {
errln("Error expecting set offset error");
}
strsrch->setOffset(128, status);
if (U_SUCCESS(status)) {
errln("Error expecting set offset error");
}
int index = 0;
UChar temp[128];
while (BASICCANONICAL[index].text != NULL) {
SearchData search = BASICCANONICAL[index ++];
if (BASICCANONICAL[index].text == NULL) {
/* skip the last one */
break;
}
u_unescape(search.text, temp, 128);
text.setTo(temp, u_strlen(temp));
u_unescape(search.pattern, temp, 128);
pattern.setTo(temp, u_strlen(temp));
UErrorCode status = U_ZERO_ERROR;
strsrch->setText(text, status);
strsrch->setPattern(pattern, status);
int count = 0;
int32_t matchindex = search.offset[count];
while (U_SUCCESS(status) && matchindex >= 0) {
int32_t matchlength = search.size[count];
strsrch->next(status);
if (matchindex != strsrch->getMatchedStart() ||
matchlength != strsrch->getMatchedLength()) {
char *str = toCharString(strsrch->getText());
errln("Text: %s", str);
str = toCharString(strsrch->getPattern());
errln("Pattern: %s", str);
errln("Error match found at %d %d",
strsrch->getMatchedStart(),
strsrch->getMatchedLength());
goto bail;
}
matchindex = search.offset[count + 1] == -1 ? -1 :
search.offset[count + 2];
if (search.offset[count + 1] != -1) {
strsrch->setOffset(search.offset[count + 1] + 1, status);
if (strsrch->getOffset() != search.offset[count + 1] + 1) {
errln("Error setting offset");
goto bail;
}
}
count += 2;
}
strsrch->next(status);
if (strsrch->getMatchedStart() != USEARCH_DONE) {
char *str = toCharString(strsrch->getText());
errln("Text: %s", str);
str = toCharString(strsrch->getPattern());
errln("Pattern: %s", str);
errln("Error match found at %d %d", strsrch->getMatchedStart(),
strsrch->getMatchedLength());
goto bail;
}
}
bail:
collator->setAttribute(UCOL_NORMALIZATION_MODE, UCOL_OFF, status);
delete strsrch;
}
void StringSearchTest::TestSupplementaryCanonical()
{
int count = 0;
while (SUPPLEMENTARYCANONICAL[count].text != NULL) {
if (!assertCanonicalEqual(&SUPPLEMENTARYCANONICAL[count])) {
errln("Error at test number %d", count);
}
count ++;
}
}
void StringSearchTest::TestContractionCanonical()
{
UChar temp[128];
u_unescape(CONTRACTIONRULE, temp, 128);
UnicodeString rules;
rules.setTo(temp, u_strlen(temp));
UErrorCode status = U_ZERO_ERROR;
RuleBasedCollator *collator = new RuleBasedCollator(rules,
getECollationStrength(UCOL_TERTIARY), UCOL_ON, status);
if (U_FAILURE(status)) {
errln("Error opening collator %s", u_errorName(status));
}
UnicodeString text("text");
UnicodeString pattern("pattern");
StringSearch *strsrch = new StringSearch(pattern, text, collator, NULL,
status);
strsrch->setAttribute(USEARCH_CANONICAL_MATCH, USEARCH_ON, status);
if (U_FAILURE(status)) {
errln("Error opening string search %s", u_errorName(status));
}
int count = 0;
while (CONTRACTIONCANONICAL[count].text != NULL) {
u_unescape(CONTRACTIONCANONICAL[count].text, temp, 128);
text.setTo(temp, u_strlen(temp));
u_unescape(CONTRACTIONCANONICAL[count].pattern, temp, 128);
pattern.setTo(temp, u_strlen(temp));
strsrch->setText(text, status);
strsrch->setPattern(pattern, status);
if (!assertEqualWithStringSearch(strsrch,
&CONTRACTIONCANONICAL[count])) {
errln("Error at test number %d", count);
}
count ++;
}
delete strsrch;
delete collator;
}
void StringSearchTest::TestUClassID()
{
char id = *((char *)StringSearch::getStaticClassID());
if (id != 0) {
errln("Static class id for StringSearch should be 0");
}
UErrorCode status = U_ZERO_ERROR;
UnicodeString text("text");
UnicodeString pattern("pattern");
StringSearch *strsrch = new StringSearch(pattern, text, m_en_us_, NULL,
status);
id = *((char *)strsrch->getDynamicClassID());
if (id != 0) {
errln("Dynamic class id for StringSearch should be 0");
}
delete strsrch;
}
class TestSearch : public SearchIterator
{
public:
TestSearch(const TestSearch &obj);
TestSearch(const UnicodeString &text,
BreakIterator *breakiter,
const UnicodeString &pattern);
~TestSearch();
void setOffset(int32_t position, UErrorCode &status);
int32_t getOffset() const;
SearchIterator* safeClone() const;
/**
* ICU "poor man's RTTI", returns a UClassID for the actual class.
*
* @draft ICU 2.2
*/
virtual inline UClassID getDynamicClassID() const { return getStaticClassID(); }
/**
* ICU "poor man's RTTI", returns a UClassID for this class.
*
* @draft ICU 2.2
*/
static inline UClassID getStaticClassID() { return (UClassID)&fgClassID; }
UBool operator!=(const TestSearch &that) const;
UnicodeString m_pattern_;
protected:
int32_t handleNext(int32_t position, UErrorCode &status);
int32_t handlePrev(int32_t position, UErrorCode &status);
TestSearch & operator=(const TestSearch &that);
private:
/**
* The address of this static class variable serves as this class's ID
* for ICU "poor man's RTTI".
*/
static const char fgClassID;
uint32_t m_offset_;
};
const char TestSearch::fgClassID=0;
TestSearch::TestSearch(const TestSearch &obj) : SearchIterator(obj)
{
m_offset_ = obj.m_offset_;
m_pattern_ = obj.m_pattern_;
}
TestSearch::TestSearch(const UnicodeString &text,
BreakIterator *breakiter,
const UnicodeString &pattern) : SearchIterator()
{
m_breakiterator_ = breakiter;
m_pattern_ = pattern;
m_text_ = text;
m_offset_ = 0;
m_pattern_ = pattern;
}
TestSearch::~TestSearch()
{
}
void TestSearch::setOffset(int32_t position, UErrorCode &status)
{
if (position >= 0 && position <= m_text_.length()) {
m_offset_ = position;
}
else {
status = U_INDEX_OUTOFBOUNDS_ERROR;
}
}
int32_t TestSearch::getOffset() const
{
return m_offset_;
}
SearchIterator * TestSearch::safeClone() const
{
return new TestSearch(m_text_, m_breakiterator_, m_pattern_);
}
UBool TestSearch::operator!=(const TestSearch &that) const
{
if (SearchIterator::operator !=(that)) {
return FALSE;
}
return m_offset_ != that.m_offset_ || m_pattern_ != that.m_pattern_;
}
int32_t TestSearch::handleNext(int32_t start, UErrorCode &status)
{
if(U_SUCCESS(status)) {
int match = m_text_.indexOf(m_pattern_, start);
if (match < 0) {
m_offset_ = m_text_.length();
setMatchStart(m_offset_);
setMatchLength(0);
return USEARCH_DONE;
}
setMatchStart(match);
m_offset_ = match;
setMatchLength(m_pattern_.length());
return match;
} else {
return USEARCH_DONE;
}
}
int32_t TestSearch::handlePrev(int32_t start, UErrorCode &status)
{
if(U_SUCCESS(status)) {
int match = m_text_.lastIndexOf(m_pattern_, 0, start);
if (match < 0) {
m_offset_ = 0;
setMatchStart(m_offset_);
setMatchLength(0);
return USEARCH_DONE;
}
setMatchStart(match);
m_offset_ = match;
setMatchLength(m_pattern_.length());
return match;
} else {
return USEARCH_DONE;
}
}
TestSearch & TestSearch::operator=(const TestSearch &that)
{
SearchIterator::operator=(that);
m_offset_ = that.m_offset_;
m_pattern_ = that.m_pattern_;
return *this;
}
void StringSearchTest::TestSubclass()
{
UnicodeString text("abc abcd abc");
UnicodeString pattern("abc");
TestSearch search(text, NULL, pattern);
TestSearch search2(search);
int expected[] = {0, 4, 9};
UErrorCode status = U_ZERO_ERROR;
int i;
StringCharacterIterator chariter(text);
search.setText(text, status);
if (search.getText() != search2.getText()) {
errln("Error setting text");
}
search.setText(chariter, status);
if (search.getText() != search2.getText()) {
errln("Error setting text");
}
search.reset();
// comparing constructors
for (i = 0; i < (int)(sizeof(expected) / sizeof(expected[0])); i ++) {
if (search.next(status) != expected[i]) {
errln("Error getting next match");
}
if (search.getMatchedLength() != search.m_pattern_.length()) {
errln("Error getting next match length");
}
}
if (search.next(status) != USEARCH_DONE) {
errln("Error should have reached the end of the iteration");
}
for (i = sizeof(expected) / sizeof(expected[0]) - 1; i >= 0; i --) {
if (search.previous(status) != expected[i]) {
errln("Error getting previous match");
}
if (search.getMatchedLength() != search.m_pattern_.length()) {
errln("Error getting previous match length");
}
}
if (search.previous(status) != USEARCH_DONE) {
errln("Error should have reached the start of the iteration");
}
}
class StubSearchIterator:public SearchIterator{
public:
StubSearchIterator(){}
virtual void setOffset(int32_t , UErrorCode &) {};
virtual int32_t getOffset(void) const {return 0;};
virtual SearchIterator* safeClone(void) const {return NULL;};
virtual int32_t handleNext(int32_t , UErrorCode &){return 0;};
virtual int32_t handlePrev(int32_t , UErrorCode &) {return 0;};
virtual UClassID getDynamicClassID() const {
static char classID = 0;
return (UClassID)&classID;
}
};
void StringSearchTest::TestCoverage(){
StubSearchIterator stub1, stub2;
UErrorCode status = U_ZERO_ERROR;
if (stub1 != stub2){
errln("new StubSearchIterator should be equal");
}
stub2.setText(UnicodeString("ABC"), status);
if (U_FAILURE(status)) {
errln("Error: SearchIterator::SetText");
}
stub1 = stub2;
if (stub1 != stub2){
errln("SearchIterator::operator = assigned object should be equal");
}
}
#endif /* !UCONFIG_NO_BREAK_ITERATION */
#endif /* #if !UCONFIG_NO_COLLATION */