/*
*****************************************************************************
-* Copyright (C) 2001-2003, International Business Machines orporation and others.
-* All Rights Reserved.
+* Copyright (C) 2001-2008, International Business Machines orporation
+* and others. All Rights Reserved.
****************************************************************************/
#include "unicode/utypes.h"
#include "unicode/ustring.h"
#include "unicode/schriter.h"
#include <string.h>
+#include <stdio.h>
// private definitions -----------------------------------------------------
if (exec) { \
logln(#test "---"); \
logln((UnicodeString)""); \
- test(); \
+ if(areBroken) { \
+ errln(__FILE__ " cannot test - failed to create collator."); \
+ } else { \
+ test(); \
+ } \
} \
break;
// public contructors and destructors --------------------------------------
-StringSearchTest::StringSearchTest() :
+StringSearchTest::StringSearchTest()
+#if !UCONFIG_NO_BREAK_ITERATION
+:
m_en_wordbreaker_(NULL), m_en_characterbreaker_(NULL)
+#endif
{
+#if !UCONFIG_NO_BREAK_ITERATION
UErrorCode status = U_ZERO_ERROR;
m_en_us_ = (RuleBasedCollator *)Collator::createInstance("en_US", status);
m_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_en_wordbreaker_;
delete m_en_characterbreaker_;
#endif
+#endif
}
// public methods ----------------------------------------------------------
void StringSearchTest::runIndexedTest(int32_t index, UBool exec,
const char* &name, char* )
{
+#if !UCONFIG_NO_BREAK_ITERATION
+ UBool areBroken = FALSE;
if (m_en_us_ == NULL && m_fr_fr_ == NULL && m_de_ == NULL &&
m_es_ == NULL && m_en_wordbreaker_ == NULL &&
m_en_characterbreaker_ == NULL && exec) {
- errln(__FILE__ " cannot test - failed to create collator.");
- name = "";
- return;
+ areBroken = TRUE;
}
switch (index) {
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)
char * StringSearchTest::toCharString(const UnicodeString &text)
{
- UChar unichars[512];
static char result[1024];
- int count = 0;
int index = 0;
+ int count = 0;
int length = text.length();
- text.extract(0, text.length(), unichars, 0);
-
for (; count < length; count ++) {
- UChar ch = unichars[count];
+ UChar ch = text[count];
if (ch >= 0x20 && ch <= 0x7e) {
result[index ++] = (char)ch;
}
else {
- char digit[5];
- int zerosize;
- result[index ++] = '\\';
- result[index ++] = 'u';
- sprintf(digit, "%x", ch);
- zerosize = 4 - strlen(digit);
- while (zerosize != 0) {
- result[index ++] = '0';
- zerosize --;
- }
- result[index] = 0;
- strcat(result, digit);
- index += strlen(digit);
+ sprintf(result+index, "\\u%04x", ch);
+ index += 6; /* \uxxxx */
}
}
result[index] = 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",
+ infoln("Pattern: %s", str);
+ infoln("Error following match found at %d %d",
strsrch->getMatchedStart(), strsrch->getMatchedLength());
return FALSE;
}
Collator *collator = getCollator(search->collator);
BreakIterator *breaker = getBreakIterator(search->breaker);
- StringSearch *strsrch;
+ StringSearch *strsrch, *strsrch2;
UChar temp[128];
#if UCONFIG_NO_BREAK_ITERATION
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;
BreakIterator *breaker = getBreakIterator(search->breaker);
StringSearch *strsrch;
UChar temp[128];
+ UBool result = TRUE;
#if UCONFIG_NO_BREAK_ITERATION
if(search->breaker) {
}
#endif
collator->setStrength(getECollationStrength(search->strength));
+ collator->setAttribute(UCOL_NORMALIZATION_MODE, UCOL_ON, status);
strsrch = new StringSearch(pattern, text, (RuleBasedCollator *)collator,
breaker, status);
strsrch->setAttribute(USEARCH_CANONICAL_MATCH, USEARCH_ON, status);
if (U_FAILURE(status)) {
errln("Error opening string search %s", u_errorName(status));
- return FALSE;
+ result = FALSE;
+ goto bail;
}
if (!assertEqualWithStringSearch(strsrch, search)) {
- collator->setStrength(getECollationStrength(UCOL_TERTIARY));
- delete strsrch;
- return FALSE;
+ result = FALSE;
+ goto bail;
}
+
+bail:
collator->setStrength(getECollationStrength(UCOL_TERTIARY));
+ collator->setAttribute(UCOL_NORMALIZATION_MODE, UCOL_OFF, status);
delete strsrch;
- return TRUE;
+
+ return result;
}
UBool StringSearchTest::assertEqualWithAttribute(const SearchData *search,
while (BASIC[count].text != NULL) {
//printf("count %d", count);
if (!assertEqual(&BASIC[count])) {
- errln("Error at test number %d", count);
+ infoln("Error at test number %d", count);
}
count ++;
}
}
while (BASIC[count].text != NULL) {
if (!assertEqual(&BASIC[count])) {
- errln("Error at test number %d", count);
+ infoln("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);
+ infoln("Error at test number %d", count);
}
count ++;
}
count = 0;
while (NONNORMEXACT[count].text != NULL) {
if (!assertEqual(&NONNORMEXACT[count])) {
- errln("Error at test number %d", count);
+ infoln("Error at test number %d", count);
}
count ++;
}
int count = 0;
while (STRENGTH[count].text != NULL) {
if (!assertEqual(&STRENGTH[count])) {
- errln("Error at test number %d", count);
+ infoln("Error at test number %d", count);
}
count ++;
}
}
strsrch->reset();
if (!assertEqualWithStringSearch(strsrch, search)) {
- errln("Error at test number %d", count);
+ infoln("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);
+ infoln("Error at test number %d", count);
}
count ++;
}
while (VARIABLE[count].text != NULL) {
logln("variable %d", count);
if (!assertEqual(&VARIABLE[count])) {
- errln("Error at test number %d", count);
+ infoln("Error at test number %d", count);
}
count ++;
}
delete strsrch;
delete collator;
}
+
+void StringSearchTest::TestDiacriticMatch()
+{
+ UChar temp[128];
+ UErrorCode status = U_ZERO_ERROR;
+ int count = 0;
+ RuleBasedCollator* coll = NULL;
+ StringSearch *strsrch = NULL;
+
+ UnicodeString pattern("pattern");
+ UnicodeString text("text");
+
+ const SearchData *search;
+
+ search = &(DIACRITICMATCH[count]);
+ while (search->text != NULL) {
+ coll = getCollator(search->collator);
+ coll->setStrength(getECollationStrength(search->strength));
+ strsrch = new StringSearch(pattern, text, coll, getBreakIterator(search->breaker), status);
+ if (U_FAILURE(status)) {
+ errln("Error opening string search %s", u_errorName(status));
+ return;
+ }
+ u_unescape(search->text, temp, 128);
+ text.setTo(temp, u_strlen(temp));
+ u_unescape(search->pattern, temp, 128);
+ pattern.setTo(temp, u_strlen(temp));
+ strsrch->setText(text, status);
+ strsrch->setPattern(pattern, status);
+ if (!assertEqualWithStringSearch(strsrch, search)) {
+ errln("Error at test number %d", count);
+ }
+ search = &(DIACRITICMATCH[++count]);
+ delete strsrch;
+ }
+
+}
void StringSearchTest::TestCanonical()
{
}
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) {
if (tailored != NULL) {
delete tailored;
}
+
+ return;
}
strsrch->setCollator(m_en_us_, status);
UnicodeString pattern("pattern");
StringSearch *strsrch = new StringSearch(pattern, text, m_en_us_, NULL,
status);
+ Collator *collator = strsrch->getCollator();
+
+ collator->setAttribute(UCOL_NORMALIZATION_MODE, UCOL_ON, status);
+
strsrch->setAttribute(USEARCH_CANONICAL_MATCH, USEARCH_ON, status);
/* testing out of bounds error */
strsrch->setOffset(-1, status);
errln("Error match found at %d %d",
strsrch->getMatchedStart(),
strsrch->getMatchedLength());
- return;
+ goto bail;
}
matchindex = search.offset[count + 1] == -1 ? -1 :
search.offset[count + 2];
strsrch->setOffset(search.offset[count + 1] + 1, status);
if (strsrch->getOffset() != search.offset[count + 1] + 1) {
errln("Error setting offset");
- return;
+ goto bail;
}
}
errln("Pattern: %s", str);
errln("Error match found at %d %d", strsrch->getMatchedStart(),
strsrch->getMatchedLength());
- return;
+ goto bail;
}
}
+
+bail:
+ collator->setAttribute(UCOL_NORMALIZATION_MODE, UCOL_OFF, status);
delete strsrch;
}
int i;
StringCharacterIterator chariter(text);
- search.setText(text, status);
+ search.setText(text, status);
if (search.getText() != search2.getText()) {
errln("Error setting text");
}
}
}
+class StubSearchIterator:public SearchIterator{
+public:
+ StubSearchIterator(){}
+ virtual void setOffset(int32_t , UErrorCode &) {};
+ virtual int32_t getOffset(void) const {return 0;};
+ virtual SearchIterator* safeClone(void) const {return NULL;};
+ virtual int32_t handleNext(int32_t , UErrorCode &){return 0;};
+ virtual int32_t handlePrev(int32_t , UErrorCode &) {return 0;};
+ virtual UClassID getDynamicClassID() const {
+ static char classID = 0;
+ return (UClassID)&classID;
+ }
+};
+
+void StringSearchTest::TestCoverage(){
+ StubSearchIterator stub1, stub2;
+ UErrorCode status = U_ZERO_ERROR;
+
+ if (stub1 != stub2){
+ errln("new StubSearchIterator should be equal");
+ }
+
+ stub2.setText(UnicodeString("ABC"), status);
+ if (U_FAILURE(status)) {
+ errln("Error: SearchIterator::SetText");
+ }
+
+ stub1 = stub2;
+ if (stub1 != stub2){
+ errln("SearchIterator::operator = assigned object should be equal");
+ }
+}
+
+#endif /* !UCONFIG_NO_BREAK_ITERATION */
+
#endif /* #if !UCONFIG_NO_COLLATION */
projects / apple / icu.git / blobdiff