organicmaps/icu
13
Fork 0
mirror of https://github.com/unicode-org/icu.git synced 2025-04-05 05:25:34 +00:00
Code Issues 1 Projects Releases Wiki Activity Actions 11
icu/icu4c/source/test/intltest/srchtest.cpp

2457 lines
79 KiB
C++
Raw Permalink Blame History

// © 2016 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
/*
*****************************************************************************
* Copyright (C) 2001-2016, 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.inc"
#endif
#include "unicode/stsearch.h"
#include "unicode/ustring.h"
#include "unicode/schriter.h"
#include "cmemory.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 constructors and destructors --------------------------------------
StringSearchTest::StringSearchTest()
#if !UCONFIG_NO_BREAK_ITERATION
:
m_en_wordbreaker_(nullptr), m_en_characterbreaker_(nullptr)
#endif
{
#if !UCONFIG_NO_BREAK_ITERATION
UErrorCode status = U_ZERO_ERROR;
m_en_us_ = dynamic_cast<RuleBasedCollator*>(Collator::createInstance("en_US", status));
m_fr_fr_ = dynamic_cast<RuleBasedCollator*>(Collator::createInstance("fr_FR", status));
m_de_ = dynamic_cast<RuleBasedCollator*>(Collator::createInstance("de_DE", status));
m_es_ = dynamic_cast<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_ = nullptr;
m_fr_fr_ = nullptr;
m_de_ = nullptr;
m_es_ = nullptr;
errln("Collator creation failed with %s", u_errorName(status));
return;
}
UnicodeString rules;
rules.setTo(m_de_->getRules());
char16_t extrarules[128];
u_unescape(EXTRACOLLATIONRULE, extrarules, 128);
rules.append(extrarules, u_strlen(extrarules));
delete m_de_;
m_de_ = new RuleBasedCollator(rules, status);
rules.setTo(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_ == nullptr && m_fr_fr_ == nullptr && m_de_ == nullptr &&
m_es_ == nullptr && m_en_wordbreaker_ == nullptr &&
m_en_characterbreaker_ == nullptr && 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 == nullptr) {
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 nullptr;
#else
if (breaker == nullptr) {
return nullptr;
}
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 ++) {
char16_t ch = text[count];
if (ch >= 0x20 && ch <= 0x7e) {
result[index++] = static_cast<char>(ch);
}
else {
snprintf(result+index, sizeof(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;
char16_t 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 != nullptr) {
breaker->setText(text);
}
#endif
collator->setStrength(getECollationStrength(search->strength));
strsrch = new StringSearch(pattern, text, dynamic_cast<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;
char16_t 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 != nullptr) {
breaker->setText(text);
}
#endif
collator->setStrength(getECollationStrength(search->strength));
collator->setAttribute(UCOL_NORMALIZATION_MODE, UCOL_ON, status);
strsrch = new StringSearch(pattern, text, dynamic_cast<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;
char16_t 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 != nullptr) {
breaker->setText(text);
}
#endif
collator->setStrength(getECollationStrength(search->strength));
strsrch = new StringSearch(pattern, text, dynamic_cast<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, nullptr, nullptr, status);
if (U_SUCCESS(status)) {
errln("Error: nullptr arguments should produce an error");
}
delete result;
chariter.setText(text);
status = U_ZERO_ERROR;
result = new StringSearch(pattern, chariter, nullptr, nullptr, status);
if (U_SUCCESS(status)) {
errln("Error: nullptr arguments should produce an error");
}
delete result;
// No-op: text.append(0, 0x1); -- what was intended here?
status = U_ZERO_ERROR;
result = new StringSearch(pattern, text, nullptr, nullptr, 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, nullptr, nullptr, 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, nullptr, nullptr, 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, nullptr, nullptr, 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, nullptr, nullptr, status);
if (U_SUCCESS(status)) {
errln("Error: nullptr arguments should produce an error");
}
delete result;
chariter.setText(text);
status = U_ZERO_ERROR;
result = new StringSearch(pattern, chariter, nullptr, nullptr, status);
if (U_SUCCESS(status)) {
errln("Error: nullptr arguments should produce an error");
}
delete result;
status = U_ZERO_ERROR;
result = new StringSearch(pattern, text, m_en_us_, nullptr, status);
if (U_FAILURE(status)) {
errln("Error: nullptr break iterator is valid for opening search");
}
delete result;
status = U_ZERO_ERROR;
result = new StringSearch(pattern, chariter, m_en_us_, nullptr, status);
if (U_FAILURE(status)) {
errln("Error: nullptr break iterator is valid for opening search");
}
delete result;
status = U_ZERO_ERROR;
result = new StringSearch(pattern, text, Locale::getEnglish(), nullptr, status);
if (U_FAILURE(status) || result == nullptr) {
errln("Error: nullptr break iterator is valid for opening search");
}
delete result;
status = U_ZERO_ERROR;
result = new StringSearch(pattern, chariter, Locale::getEnglish(), nullptr, status);
if (U_FAILURE(status)) {
errln("Error: nullptr 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_, nullptr, 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_, nullptr, 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 = 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_, nullptr, 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 != nullptr) {
//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 != nullptr) {
if (!assertEqual(&BASIC[count])) {
infoln("Error at test number %d", count);
}
count ++;
}
count = 0;
while (NORMEXACT[count].text != nullptr) {
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 != nullptr) {
if (!assertEqual(&NONNORMEXACT[count])) {
infoln("Error at test number %d", count);
}
count ++;
}
}
void StringSearchTest::TestStrength()
{
int count = 0;
while (STRENGTH[count].text != nullptr) {
if (!assertEqual(&STRENGTH[count])) {
infoln("Error at test number %d", count);
}
count ++;
}
}
#if !UCONFIG_NO_BREAK_ITERATION
void StringSearchTest::TestBreakIterator()
{
char16_t 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_, nullptr,
status);
if (U_FAILURE(status)) {
errln("Error opening string search %s", u_errorName(status));
}
strsrch->setBreakIterator(nullptr, status);
if (U_FAILURE(status) || strsrch->getBreakIterator() != nullptr) {
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 != nullptr) {
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");
delete strsrch;
}
if (!assertEqualWithStringSearch(strsrch, search)) {
collator->setStrength(getECollationStrength(UCOL_TERTIARY));
delete strsrch;
}
search = &(BREAKITERATOREXACT[count + 1]);
breaker = getBreakIterator(search->breaker);
if (breaker != nullptr) {
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 != nullptr) {
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 != nullptr) {
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 != nullptr) {
if (!assertEqualWithAttribute(&OVERLAP[count], USEARCH_OFF,
USEARCH_ON)) {
errln("Error at overlap test number %d", count);
}
count ++;
}
count = 0;
while (NONOVERLAP[count].text != nullptr) {
if (!assertEqual(&NONOVERLAP[count])) {
errln("Error at non overlap test number %d", count);
}
count ++;
}
count = 0;
while (count < 1) {
const SearchData *search = &(OVERLAP[count]);
char16_t 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, nullptr,
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
char16_t 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_, nullptr,
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()
{
char16_t 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_, nullptr,
status);
if (U_FAILURE(status)) {
errln("Error opening string search %s", u_errorName(status));
m_en_us_->setStrength(getECollationStrength(UCOL_TERTIARY));
delete strsrch;
return;
}
if (strsrch->getPattern() != pattern) {
errln("Error setting pattern");
}
if (!assertEqualWithStringSearch(strsrch, &PATTERN[0])) {
m_en_us_->setStrength(getECollationStrength(UCOL_TERTIARY));
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));
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));
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));
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));
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));
delete strsrch;
}
void StringSearchTest::TestText()
{
char16_t 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_, nullptr,
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 != nullptr) {
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_,
nullptr, 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 != nullptr) {
UErrorCode status = U_ZERO_ERROR;
SearchData search = BASIC[index ++];
char16_t 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_, nullptr,
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()
{
char16_t 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_, nullptr,
status);
if (U_FAILURE(status)) {
errln("Error opening string search %s", u_errorName(status));
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 != nullptr) {
SearchData search = MATCH[count];
char16_t 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_,
nullptr, status);
if (U_FAILURE(status)) {
errln("Error opening string search %s", u_errorName(status));
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 preceding 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_, nullptr,
status);
if (U_FAILURE(status)) {
errln("Error opening string search %s", u_errorName(status));
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 != nullptr) {
if (!assertEqual(&SUPPLEMENTARY[count])) {
errln("Error at test number %d", count);
}
count ++;
}
}
void StringSearchTest::TestContraction()
{
char16_t 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, nullptr,
status);
if (U_FAILURE(status)) {
errln("Error opening string search %s", u_errorName(status));
}
int count = 0;
while (CONTRACTION[count].text != nullptr) {
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()
{
char16_t 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, nullptr,
status);
if (U_FAILURE(status)) {
errln("Error opening string search %s", u_errorName(status));
delete collator;
return;
}
while (IGNORABLE[count].text != nullptr) {
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()
{
char16_t temp[128];
UErrorCode status = U_ZERO_ERROR;
int count = 0;
RuleBasedCollator* coll = nullptr;
StringSearch *strsrch = nullptr;
UnicodeString pattern("pattern");
UnicodeString text("text");
const SearchData *search;
search = &(DIACRITICMATCH[count]);
while (search->text != nullptr) {
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 != nullptr) {
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 != nullptr) {
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 != nullptr) {
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
char16_t 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 == nullptr) {
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 != nullptr) {
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 != nullptr) {
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 != nullptr) {
if (!assertEqualWithAttribute(&OVERLAPCANONICAL[count], USEARCH_ON,
USEARCH_ON)) {
errln("Error at overlap test number %d", count);
}
count ++;
}
count = 0;
while (NONOVERLAP[count].text != nullptr) {
if (!assertCanonicalEqual(&NONOVERLAPCANONICAL[count])) {
errln("Error at non overlap test number %d", count);
}
count ++;
}
count = 0;
while (count < 1) {
char16_t 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,
nullptr, 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 */
char16_t 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_,
nullptr, 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;
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;
delete tailored;
}
void StringSearchTest::TestPatternCanonical()
{
char16_t 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_, nullptr,
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));
delete strsrch;
}
void StringSearchTest::TestTextCanonical()
{
char16_t 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_, nullptr,
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:
delete strsrch;
}
void StringSearchTest::TestCompositeBoundariesCanonical()
{
int count = 0;
while (COMPOSITEBOUNDARIESCANONICAL[count].text != nullptr) {
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_, nullptr,
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;
char16_t temp[128];
while (BASICCANONICAL[index].text != nullptr) {
SearchData search = BASICCANONICAL[index ++];
if (BASICCANONICAL[index].text == nullptr) {
/* 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 != nullptr) {
if (!assertCanonicalEqual(&SUPPLEMENTARYCANONICAL[count])) {
errln("Error at test number %d", count);
}
count ++;
}
}
void StringSearchTest::TestContractionCanonical()
{
char16_t 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, nullptr,
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 != nullptr) {
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 = *static_cast<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_, nullptr,
status);
id = *static_cast<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) override;
int32_t getOffset() const override;
SearchIterator* safeClone() const override;
/**
* ICU "poor man's RTTI", returns a UClassID for the actual class.
*
* @draft ICU 2.2
*/
virtual inline UClassID getDynamicClassID() const override { return getStaticClassID(); }
/**
* ICU "poor man's RTTI", returns a UClassID for this class.
*
* @draft ICU 2.2
*/
static inline UClassID getStaticClassID() { return (UClassID)&fgClassID; }
bool operator!=(const TestSearch &that) const;
UnicodeString m_pattern_;
protected:
int32_t handleNext(int32_t position, UErrorCode &status) override;
int32_t handlePrev(int32_t position, UErrorCode &status) override;
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_);
}
bool 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, nullptr, 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 < UPRV_LENGTHOF(expected); 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 = UPRV_LENGTHOF(expected) - 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 &) override {}
virtual int32_t getOffset() const override {return 0;}
virtual SearchIterator* safeClone() const override {return nullptr;}
virtual int32_t handleNext(int32_t , UErrorCode &) override {return 0;}
virtual int32_t handlePrev(int32_t , UErrorCode &) override {return 0;}
virtual UClassID getDynamicClassID() const override {
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 */
Reference in a new issue View git blame Copy permalink