| /* |
| ***************************************************************************** |
| * Copyright (C) 2001-2006, International Business Machines orporation |
| * and others. All Rights Reserved. |
| ****************************************************************************/ |
| |
| #include "unicode/utypes.h" |
| |
| #if !UCONFIG_NO_COLLATION |
| |
| #include "srchtest.h" |
| #include "../cintltst/usrchdat.c" |
| #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) { \ |
| errln(__FILE__ " cannot test - failed to create collator."); \ |
| } else { \ |
| test(); \ |
| } \ |
| } \ |
| break; |
| |
| // public contructors and destructors -------------------------------------- |
| |
| StringSearchTest::StringSearchTest() : |
| m_en_wordbreaker_(NULL), m_en_characterbreaker_(NULL) |
| { |
| 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 |
| } |
| |
| StringSearchTest::~StringSearchTest() |
| { |
| 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 |
| } |
| |
| // public methods ---------------------------------------------------------- |
| |
| void StringSearchTest::runIndexedTest(int32_t index, UBool exec, |
| const char* &name, char* ) |
| { |
| 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) { |
| CASE(0, TestOpenClose) |
| 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) |
| default: name = ""; break; |
| } |
| } |
| |
| // 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) |
| { |
| int count = 0; |
| UErrorCode status = U_ZERO_ERROR; |
| int32_t matchindex = search->offset[count]; |
| UnicodeString matchtext; |
| |
| if (strsrch->getMatchedStart() != USEARCH_DONE || |
| strsrch->getMatchedLength() != 0) { |
| errln("Error with the initialization of match start and length"); |
| } |
| // start of following matches |
| 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 following match found at %d %d", |
| strsrch->getMatchedStart(), strsrch->getMatchedLength()); |
| return FALSE; |
| } |
| count ++; |
| |
| strsrch->getMatchedText(matchtext); |
| |
| if (U_FAILURE(status) || |
| strsrch->getText().compareBetween(matchindex, |
| matchindex + matchlength, |
| matchtext, 0, |
| matchtext.length())) { |
| errln("Error getting following 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 following match found at %d %d", |
| strsrch->getMatchedStart(), strsrch->getMatchedLength()); |
| return FALSE; |
| } |
| // start of preceding matches |
| count = count == 0 ? 0 : count - 1; |
| matchindex = search->offset[count]; |
| while (U_SUCCESS(status) && matchindex >= 0) { |
| int32_t 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 following match found at %d %d", |
| strsrch->getMatchedStart(), strsrch->getMatchedLength()); |
| return FALSE; |
| } |
| |
| strsrch->getMatchedText(matchtext); |
| |
| if (U_FAILURE(status) || |
| strsrch->getText().compareBetween(matchindex, |
| matchindex + matchlength, |
| matchtext, 0, |
| matchtext.length())) { |
| errln("Error getting following 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 following match found at %d %d", |
| strsrch->getMatchedStart(), strsrch->getMatchedLength()); |
| return FALSE; |
| } |
| 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) |
| ) { |
| errln("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]; |
| |
| #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, USEARCH_ON, 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; |
| } |
| |
| 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])) { |
| errln("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])) { |
| errln("Error at test number %d", count); |
| } |
| count ++; |
| } |
| count = 0; |
| while (NORMEXACT[count].text != NULL) { |
| if (!assertEqual(&NORMEXACT[count])) { |
| errln("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])) { |
| errln("Error at test number %d", count); |
| } |
| count ++; |
| } |
| } |
| |
| void StringSearchTest::TestStrength() |
| { |
| int count = 0; |
| while (STRENGTH[count].text != NULL) { |
| if (!assertEqual(&STRENGTH[count])) { |
| errln("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)) { |
| errln("Error at test number %d", count); |
| } |
| delete strsrch; |
| count += 2; |
| } |
| count = 0; |
| while (BREAKITERATOREXACT[count].text != NULL) { |
| if (!assertEqual(&BREAKITERATOREXACT[count])) { |
| errln("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])) { |
| errln("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; |
| if (tailored != NULL) { |
| delete tailored; |
| } |
| return; |
| } |
| |
| strsrch->setCollator(tailored, status); |
| if (U_FAILURE(status) || (*strsrch->getCollator()) != (*tailored)) { |
| errln("Error setting rule based collator"); |
| delete strsrch; |
| if (tailored != NULL) { |
| delete tailored; |
| } |
| } |
| strsrch->reset(); |
| if (!assertEqualWithStringSearch(strsrch, &COLLATOR[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"); |
| delete strsrch; |
| if (tailored != NULL) { |
| delete tailored; |
| } |
| } |
| if (!assertEqualWithStringSearch(strsrch, &COLLATOR[0])) { |
| errln("Error searching collator test"); |
| } |
| delete strsrch; |
| if (tailored != NULL) { |
| 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::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; |
| } |
| } |
| |
| 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); |
| 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()); |
| 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"); |
| 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; |
| } |
| } |
| 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 /* #if !UCONFIG_NO_COLLATION */ |
