git.saurik.com Git - apple/icu.git/blame_incremental - icuSources/test/intltest/srchtest.cpp

... / ...

Commit	Line	Data
	1	/*
	2	*****************************************************************************
	3	* Copyright (C) 2001-2008, International Business Machines orporation
	4	* and others. All Rights Reserved.
	5	****************************************************************************/
	6
	7	#include "unicode/utypes.h"
	8
	9	#if !UCONFIG_NO_COLLATION
	10
	11	#include "srchtest.h"
	12	#include "../cintltst/usrchdat.c"
	13	#include "unicode/stsearch.h"
	14	#include "unicode/ustring.h"
	15	#include "unicode/schriter.h"
	16	#include <string.h>
	17	#include <stdio.h>
	18
	19	// private definitions -----------------------------------------------------
	20
	21	#define CASE(id,test) \
	22	case id: \
	23	name = #test; \
	24	if (exec) { \
	25	logln(#test "---"); \
	26	logln((UnicodeString)""); \
	27	if(areBroken) { \
	28	errln(__FILE__ " cannot test - failed to create collator."); \
	29	} else { \
	30	test(); \
	31	} \
	32	} \
	33	break;
	34
	35	// public contructors and destructors --------------------------------------
	36
	37	StringSearchTest::StringSearchTest()
	38	#if !UCONFIG_NO_BREAK_ITERATION
	39	:
	40	m_en_wordbreaker_(NULL), m_en_characterbreaker_(NULL)
	41	#endif
	42	{
	43	#if !UCONFIG_NO_BREAK_ITERATION
	44	UErrorCode status = U_ZERO_ERROR;
	45
	46	m_en_us_ = (RuleBasedCollator *)Collator::createInstance("en_US", status);
	47	m_fr_fr_ = (RuleBasedCollator *)Collator::createInstance("fr_FR", status);
	48	m_de_ = (RuleBasedCollator *)Collator::createInstance("de_DE", status);
	49	m_es_ = (RuleBasedCollator *)Collator::createInstance("es_ES", status);
	50	if(U_FAILURE(status)) {
	51	delete m_en_us_;
	52	delete m_fr_fr_;
	53	delete m_de_;
	54	delete m_es_;
	55	m_en_us_ = 0;
	56	m_fr_fr_ = 0;
	57	m_de_ = 0;
	58	m_es_ = 0;
	59	errln("Collator creation failed with %s", u_errorName(status));
	60	return;
	61	}
	62
	63
	64	UnicodeString rules;
	65	rules.setTo(((RuleBasedCollator *)m_de_)->getRules());
	66	UChar extrarules[128];
	67	u_unescape(EXTRACOLLATIONRULE, extrarules, 128);
	68	rules.append(extrarules, u_strlen(extrarules));
	69	delete m_de_;
	70
	71	m_de_ = new RuleBasedCollator(rules, status);
	72
	73	rules.setTo(((RuleBasedCollator *)m_es_)->getRules());
	74	rules.append(extrarules, u_strlen(extrarules));
	75
	76	delete m_es_;
	77
	78	m_es_ = new RuleBasedCollator(rules, status);
	79
	80	#if !UCONFIG_NO_BREAK_ITERATION
	81	m_en_wordbreaker_ = BreakIterator::createWordInstance(
	82	Locale::getEnglish(), status);
	83	m_en_characterbreaker_ = BreakIterator::createCharacterInstance(
	84	Locale::getEnglish(), status);
	85	#endif
	86	#endif
	87	}
	88
	89	StringSearchTest::~StringSearchTest()
	90	{
	91	#if !UCONFIG_NO_BREAK_ITERATION
	92	delete m_en_us_;
	93	delete m_fr_fr_;
	94	delete m_de_;
	95	delete m_es_;
	96	#if !UCONFIG_NO_BREAK_ITERATION
	97	delete m_en_wordbreaker_;
	98	delete m_en_characterbreaker_;
	99	#endif
	100	#endif
	101	}
	102
	103	// public methods ----------------------------------------------------------
	104
	105	void StringSearchTest::runIndexedTest(int32_t index, UBool exec,
	106	const char* &name, char* )
	107	{
	108	#if !UCONFIG_NO_BREAK_ITERATION
	109	UBool areBroken = FALSE;
	110	if (m_en_us_ == NULL && m_fr_fr_ == NULL && m_de_ == NULL &&
	111	m_es_ == NULL && m_en_wordbreaker_ == NULL &&
	112	m_en_characterbreaker_ == NULL && exec) {
	113	areBroken = TRUE;
	114	}
	115
	116	switch (index) {
	117	CASE(0, TestOpenClose)
	118	CASE(1, TestInitialization)
	119	CASE(2, TestBasic)
	120	CASE(3, TestNormExact)
	121	CASE(4, TestStrength)
	122	#if UCONFIG_NO_BREAK_ITERATION
	123	case 5:
	124	name = "TestBreakIterator";
	125	break;
	126	#else
	127	CASE(5, TestBreakIterator)
	128	#endif
	129	CASE(6, TestVariable)
	130	CASE(7, TestOverlap)
	131	CASE(8, TestCollator)
	132	CASE(9, TestPattern)
	133	CASE(10, TestText)
	134	CASE(11, TestCompositeBoundaries)
	135	CASE(12, TestGetSetOffset)
	136	CASE(13, TestGetSetAttribute)
	137	CASE(14, TestGetMatch)
	138	CASE(15, TestSetMatch)
	139	CASE(16, TestReset)
	140	CASE(17, TestSupplementary)
	141	CASE(18, TestContraction)
	142	CASE(19, TestIgnorable)
	143	CASE(20, TestCanonical)
	144	CASE(21, TestNormCanonical)
	145	CASE(22, TestStrengthCanonical)
	146	#if UCONFIG_NO_BREAK_ITERATION
	147	case 23:
	148	name = "TestBreakIteratorCanonical";
	149	break;
	150	#else
	151	CASE(23, TestBreakIteratorCanonical)
	152	#endif
	153	CASE(24, TestVariableCanonical)
	154	CASE(25, TestOverlapCanonical)
	155	CASE(26, TestCollatorCanonical)
	156	CASE(27, TestPatternCanonical)
	157	CASE(28, TestTextCanonical)
	158	CASE(29, TestCompositeBoundariesCanonical)
	159	CASE(30, TestGetSetOffsetCanonical)
	160	CASE(31, TestSupplementaryCanonical)
	161	CASE(32, TestContractionCanonical)
	162	CASE(33, TestUClassID)
	163	CASE(34, TestSubclass)
	164	CASE(35, TestCoverage)
	165	CASE(36, TestDiacriticMatch)
	166	default: name = ""; break;
	167	}
	168	#else
	169	name="";
	170	#endif
	171	}
	172
	173	#if !UCONFIG_NO_BREAK_ITERATION
	174	// private methods ------------------------------------------------------
	175
	176	RuleBasedCollator * StringSearchTest::getCollator(const char *collator)
	177	{
	178	if (collator == NULL) {
	179	return m_en_us_;
	180	}
	181	if (strcmp(collator, "fr") == 0) {
	182	return m_fr_fr_;
	183	}
	184	else if (strcmp(collator, "de") == 0) {
	185	return m_de_;
	186	}
	187	else if (strcmp(collator, "es") == 0) {
	188	return m_es_;
	189	}
	190	else {
	191	return m_en_us_;
	192	}
	193	}
	194
	195	BreakIterator * StringSearchTest::getBreakIterator(const char *breaker)
	196	{
	197	#if UCONFIG_NO_BREAK_ITERATION
	198	return NULL;
	199	#else
	200	if (breaker == NULL) {
	201	return NULL;
	202	}
	203	if (strcmp(breaker, "wordbreaker") == 0) {
	204	return m_en_wordbreaker_;
	205	}
	206	else {
	207	return m_en_characterbreaker_;
	208	}
	209	#endif
	210	}
	211
	212	char * StringSearchTest::toCharString(const UnicodeString &text)
	213	{
	214	static char result[1024];
	215	int index = 0;
	216	int count = 0;
	217	int length = text.length();
	218
	219	for (; count < length; count ++) {
	220	UChar ch = text[count];
	221	if (ch >= 0x20 && ch <= 0x7e) {
	222	result[index ++] = (char)ch;
	223	}
	224	else {
	225	sprintf(result+index, "\\u%04x", ch);
	226	index += 6; /* \uxxxx */
	227	}
	228	}
	229	result[index] = 0;
	230
	231	return result;
	232	}
	233
	234	Collator::ECollationStrength StringSearchTest::getECollationStrength(
	235	const UCollationStrength &strength) const
	236	{
	237	switch (strength)
	238	{
	239	case UCOL_PRIMARY :
	240	return Collator::PRIMARY;
	241	case UCOL_SECONDARY :
	242	return Collator::SECONDARY;
	243	case UCOL_TERTIARY :
	244	return Collator::TERTIARY;
	245	default :
	246	return Collator::IDENTICAL;
	247	}
	248	}
	249
	250	UBool StringSearchTest::assertEqualWithStringSearch(StringSearch *strsrch,
	251	const SearchData *search)
	252	{
	253	int count = 0;
	254	UErrorCode status = U_ZERO_ERROR;
	255	int32_t matchindex = search->offset[count];
	256	UnicodeString matchtext;
	257
	258	if (strsrch->getMatchedStart() != USEARCH_DONE \|\|
	259	strsrch->getMatchedLength() != 0) {
	260	errln("Error with the initialization of match start and length");
	261	}
	262	// start of following matches
	263	while (U_SUCCESS(status) && matchindex >= 0) {
	264	int32_t matchlength = search->size[count];
	265	strsrch->next(status);
	266	if (matchindex != strsrch->getMatchedStart() \|\|
	267	matchlength != strsrch->getMatchedLength()) {
	268	char *str = toCharString(strsrch->getText());
	269	errln("Text: %s", str);
	270	str = toCharString(strsrch->getPattern());
	271	infoln("Pattern: %s", str);
	272	infoln("Error following match found at %d %d",
	273	strsrch->getMatchedStart(), strsrch->getMatchedLength());
	274	return FALSE;
	275	}
	276	count ++;
	277
	278	strsrch->getMatchedText(matchtext);
	279
	280	if (U_FAILURE(status) \|\|
	281	strsrch->getText().compareBetween(matchindex,
	282	matchindex + matchlength,
	283	matchtext, 0,
	284	matchtext.length())) {
	285	errln("Error getting following matched text");
	286	}
	287
	288	matchindex = search->offset[count];
	289	}
	290	strsrch->next(status);
	291	if (strsrch->getMatchedStart() != USEARCH_DONE \|\|
	292	strsrch->getMatchedLength() != 0) {
	293	char *str = toCharString(strsrch->getText());
	294	errln("Text: %s", str);
	295	str = toCharString(strsrch->getPattern());
	296	errln("Pattern: %s", str);
	297	errln("Error following match found at %d %d",
	298	strsrch->getMatchedStart(), strsrch->getMatchedLength());
	299	return FALSE;
	300	}
	301	// start of preceding matches
	302	count = count == 0 ? 0 : count - 1;
	303	matchindex = search->offset[count];
	304	while (U_SUCCESS(status) && matchindex >= 0) {
	305	int32_t matchlength = search->size[count];
	306	strsrch->previous(status);
	307	if (matchindex != strsrch->getMatchedStart() \|\|
	308	matchlength != strsrch->getMatchedLength()) {
	309	char *str = toCharString(strsrch->getText());
	310	errln("Text: %s", str);
	311	str = toCharString(strsrch->getPattern());
	312	errln("Pattern: %s", str);
	313	errln("Error following match found at %d %d",
	314	strsrch->getMatchedStart(), strsrch->getMatchedLength());
	315	return FALSE;
	316	}
	317
	318	strsrch->getMatchedText(matchtext);
	319
	320	if (U_FAILURE(status) \|\|
	321	strsrch->getText().compareBetween(matchindex,
	322	matchindex + matchlength,
	323	matchtext, 0,
	324	matchtext.length())) {
	325	errln("Error getting following matched text");
	326	}
	327
	328	matchindex = count > 0 ? search->offset[count - 1] : -1;
	329	count --;
	330	}
	331	strsrch->previous(status);
	332	if (strsrch->getMatchedStart() != USEARCH_DONE \|\|
	333	strsrch->getMatchedLength() != 0) {
	334	char *str = toCharString(strsrch->getText());
	335	errln("Text: %s", str);
	336	str = toCharString(strsrch->getPattern());
	337	errln("Pattern: %s", str);
	338	errln("Error following match found at %d %d",
	339	strsrch->getMatchedStart(), strsrch->getMatchedLength());
	340	return FALSE;
	341	}
	342	return TRUE;
	343	}
	344
	345	UBool StringSearchTest::assertEqual(const SearchData *search)
	346	{
	347	UErrorCode status = U_ZERO_ERROR;
	348
	349	Collator *collator = getCollator(search->collator);
	350	BreakIterator *breaker = getBreakIterator(search->breaker);
	351	StringSearch strsrch, strsrch2;
	352	UChar temp[128];
	353
	354	#if UCONFIG_NO_BREAK_ITERATION
	355	if(search->breaker) {
	356	return TRUE; /* skip test */
	357	}
	358	#endif
	359	u_unescape(search->text, temp, 128);
	360	UnicodeString text;
	361	text.setTo(temp);
	362	u_unescape(search->pattern, temp, 128);
	363	UnicodeString pattern;
	364	pattern.setTo(temp);
	365
	366	#if !UCONFIG_NO_BREAK_ITERATION
	367	if (breaker != NULL) {
	368	breaker->setText(text);
	369	}
	370	#endif
	371	collator->setStrength(getECollationStrength(search->strength));
	372	strsrch = new StringSearch(pattern, text, (RuleBasedCollator *)collator,
	373	breaker, status);
	374	if (U_FAILURE(status)) {
	375	errln("Error opening string search %s", u_errorName(status));
	376	return FALSE;
	377	}
	378
	379	if (!assertEqualWithStringSearch(strsrch, search)) {
	380	collator->setStrength(getECollationStrength(UCOL_TERTIARY));
	381	delete strsrch;
	382	return FALSE;
	383	}
	384
	385
	386	strsrch2 = strsrch->clone();
	387	if( strsrch2 == strsrch \|\| strsrch2 != strsrch \|\|
	388	!assertEqualWithStringSearch(strsrch2, search)
	389	) {
	390	infoln("failure with StringSearch.clone()");
	391	collator->setStrength(getECollationStrength(UCOL_TERTIARY));
	392	delete strsrch;
	393	delete strsrch2;
	394	return FALSE;
	395	}
	396	delete strsrch2;
	397
	398	collator->setStrength(getECollationStrength(UCOL_TERTIARY));
	399	delete strsrch;
	400	return TRUE;
	401	}
	402
	403	UBool StringSearchTest::assertCanonicalEqual(const SearchData *search)
	404	{
	405	UErrorCode status = U_ZERO_ERROR;
	406	Collator *collator = getCollator(search->collator);
	407	BreakIterator *breaker = getBreakIterator(search->breaker);
	408	StringSearch *strsrch;
	409	UChar temp[128];
	410	UBool result = TRUE;
	411
	412	#if UCONFIG_NO_BREAK_ITERATION
	413	if(search->breaker) {
	414	return TRUE; /* skip test */
	415	}
	416	#endif
	417
	418	u_unescape(search->text, temp, 128);
	419	UnicodeString text;
	420	text.setTo(temp);
	421	u_unescape(search->pattern, temp, 128);
	422	UnicodeString pattern;
	423	pattern.setTo(temp);
	424
	425	#if !UCONFIG_NO_BREAK_ITERATION
	426	if (breaker != NULL) {
	427	breaker->setText(text);
	428	}
	429	#endif
	430	collator->setStrength(getECollationStrength(search->strength));
	431	collator->setAttribute(UCOL_NORMALIZATION_MODE, UCOL_ON, status);
	432	strsrch = new StringSearch(pattern, text, (RuleBasedCollator *)collator,
	433	breaker, status);
	434	strsrch->setAttribute(USEARCH_CANONICAL_MATCH, USEARCH_ON, status);
	435	if (U_FAILURE(status)) {
	436	errln("Error opening string search %s", u_errorName(status));
	437	result = FALSE;
	438	goto bail;
	439	}
	440
	441	if (!assertEqualWithStringSearch(strsrch, search)) {
	442	result = FALSE;
	443	goto bail;
	444	}
	445
	446	bail:
	447	collator->setStrength(getECollationStrength(UCOL_TERTIARY));
	448	collator->setAttribute(UCOL_NORMALIZATION_MODE, UCOL_OFF, status);
	449	delete strsrch;
	450
	451	return result;
	452	}
	453
	454	UBool StringSearchTest::assertEqualWithAttribute(const SearchData *search,
	455	USearchAttributeValue canonical,
	456	USearchAttributeValue overlap)
	457	{
	458	UErrorCode status = U_ZERO_ERROR;
	459	Collator *collator = getCollator(search->collator);
	460	BreakIterator *breaker = getBreakIterator(search->breaker);
	461	StringSearch *strsrch;
	462	UChar temp[128];
	463
	464
	465	#if UCONFIG_NO_BREAK_ITERATION
	466	if(search->breaker) {
	467	return TRUE; /* skip test */
	468	}
	469	#endif
	470
	471	u_unescape(search->text, temp, 128);
	472	UnicodeString text;
	473	text.setTo(temp);
	474	u_unescape(search->pattern, temp, 128);
	475	UnicodeString pattern;
	476	pattern.setTo(temp);
	477
	478	#if !UCONFIG_NO_BREAK_ITERATION
	479	if (breaker != NULL) {
	480	breaker->setText(text);
	481	}
	482	#endif
	483	collator->setStrength(getECollationStrength(search->strength));
	484	strsrch = new StringSearch(pattern, text, (RuleBasedCollator *)collator,
	485	breaker, status);
	486	strsrch->setAttribute(USEARCH_CANONICAL_MATCH, canonical, status);
	487	strsrch->setAttribute(USEARCH_OVERLAP, overlap, status);
	488
	489	if (U_FAILURE(status)) {
	490	errln("Error opening string search %s", u_errorName(status));
	491	return FALSE;
	492	}
	493
	494	if (!assertEqualWithStringSearch(strsrch, search)) {
	495	collator->setStrength(getECollationStrength(UCOL_TERTIARY));
	496	delete strsrch;
	497	return FALSE;
	498	}
	499	collator->setStrength(getECollationStrength(UCOL_TERTIARY));
	500	delete strsrch;
	501	return TRUE;
	502	}
	503
	504	void StringSearchTest::TestOpenClose()
	505	{
	506	UErrorCode status = U_ZERO_ERROR;
	507	StringSearch *result;
	508	BreakIterator *breakiter = m_en_wordbreaker_;
	509	UnicodeString pattern;
	510	UnicodeString text;
	511	UnicodeString temp("a");
	512	StringCharacterIterator chariter(text);
	513
	514	/* testing null arguments */
	515	result = new StringSearch(pattern, text, NULL, NULL, status);
	516	if (U_SUCCESS(status)) {
	517	errln("Error: NULL arguments should produce an error");
	518	}
	519	delete result;
	520
	521	chariter.setText(text);
	522	status = U_ZERO_ERROR;
	523	result = new StringSearch(pattern, chariter, NULL, NULL, status);
	524	if (U_SUCCESS(status)) {
	525	errln("Error: NULL arguments should produce an error");
	526	}
	527	delete result;
	528
	529	text.append(0, 0x1);
	530	status = U_ZERO_ERROR;
	531	result = new StringSearch(pattern, text, NULL, NULL, status);
	532	if (U_SUCCESS(status)) {
	533	errln("Error: Empty pattern should produce an error");
	534	}
	535	delete result;
	536
	537	chariter.setText(text);
	538	status = U_ZERO_ERROR;
	539	result = new StringSearch(pattern, chariter, NULL, NULL, status);
	540	if (U_SUCCESS(status)) {
	541	errln("Error: Empty pattern should produce an error");
	542	}
	543	delete result;
	544
	545	text.remove();
	546	pattern.append(temp);
	547	status = U_ZERO_ERROR;
	548	result = new StringSearch(pattern, text, NULL, NULL, status);
	549	if (U_SUCCESS(status)) {
	550	errln("Error: Empty text should produce an error");
	551	}
	552	delete result;
	553
	554	chariter.setText(text);
	555	status = U_ZERO_ERROR;
	556	result = new StringSearch(pattern, chariter, NULL, NULL, status);
	557	if (U_SUCCESS(status)) {
	558	errln("Error: Empty text should produce an error");
	559	}
	560	delete result;
	561
	562	text.append(temp);
	563	status = U_ZERO_ERROR;
	564	result = new StringSearch(pattern, text, NULL, NULL, status);
	565	if (U_SUCCESS(status)) {
	566	errln("Error: NULL arguments should produce an error");
	567	}
	568	delete result;
	569
	570	chariter.setText(text);
	571	status = U_ZERO_ERROR;
	572	result = new StringSearch(pattern, chariter, NULL, NULL, status);
	573	if (U_SUCCESS(status)) {
	574	errln("Error: NULL arguments should produce an error");
	575	}
	576	delete result;
	577
	578	status = U_ZERO_ERROR;
	579	result = new StringSearch(pattern, text, m_en_us_, NULL, status);
	580	if (U_FAILURE(status)) {
	581	errln("Error: NULL break iterator is valid for opening search");
	582	}
	583	delete result;
	584
	585	status = U_ZERO_ERROR;
	586	result = new StringSearch(pattern, chariter, m_en_us_, NULL, status);
	587	if (U_FAILURE(status)) {
	588	errln("Error: NULL break iterator is valid for opening search");
	589	}
	590	delete result;
	591
	592	status = U_ZERO_ERROR;
	593	result = new StringSearch(pattern, text, Locale::getEnglish(), NULL, status);
	594	if (U_FAILURE(status) \|\| result == NULL) {
	595	errln("Error: NULL break iterator is valid for opening search");
	596	}
	597	delete result;
	598
	599	status = U_ZERO_ERROR;
	600	result = new StringSearch(pattern, chariter, Locale::getEnglish(), NULL, status);
	601	if (U_FAILURE(status)) {
	602	errln("Error: NULL break iterator is valid for opening search");
	603	}
	604	delete result;
	605
	606	status = U_ZERO_ERROR;
	607	result = new StringSearch(pattern, text, m_en_us_, breakiter, status);
	608	if (U_FAILURE(status)) {
	609	errln("Error: Break iterator is valid for opening search");
	610	}
	611	delete result;
	612
	613	status = U_ZERO_ERROR;
	614	result = new StringSearch(pattern, chariter, m_en_us_, NULL, status);
	615	if (U_FAILURE(status)) {
	616	errln("Error: Break iterator is valid for opening search");
	617	}
	618	delete result;
	619	}
	620
	621	void StringSearchTest::TestInitialization()
	622	{
	623	UErrorCode status = U_ZERO_ERROR;
	624	UnicodeString pattern;
	625	UnicodeString text;
	626	UnicodeString temp("a");
	627	StringSearch *result;
	628	int count;
	629
	630	/* simple test on the pattern ce construction */
	631	pattern.append(temp);
	632	pattern.append(temp);
	633	text.append(temp);
	634	text.append(temp);
	635	text.append(temp);
	636	result = new StringSearch(pattern, text, m_en_us_, NULL, status);
	637	if (U_FAILURE(status)) {
	638	errln("Error opening search %s", u_errorName(status));
	639	}
	640	StringSearch copy = new StringSearch(result);
	641	if ((copy->getCollator()) != (result->getCollator()) \|\|
	642	copy->getBreakIterator() != result->getBreakIterator() \|\|
	643	copy->getMatchedLength() != result->getMatchedLength() \|\|
	644	copy->getMatchedStart() != result->getMatchedStart() \|\|
	645	copy->getOffset() != result->getOffset() \|\|
	646	copy->getPattern() != result->getPattern() \|\|
	647	copy->getText() != result->getText() \|\|
	648	(copy) != (result))
	649	{
	650	errln("Error copying StringSearch");
	651	}
	652	delete copy;
	653
	654	copy = (StringSearch *)result->safeClone();
	655	if ((copy->getCollator()) != (result->getCollator()) \|\|
	656	copy->getBreakIterator() != result->getBreakIterator() \|\|
	657	copy->getMatchedLength() != result->getMatchedLength() \|\|
	658	copy->getMatchedStart() != result->getMatchedStart() \|\|
	659	copy->getOffset() != result->getOffset() \|\|
	660	copy->getPattern() != result->getPattern() \|\|
	661	copy->getText() != result->getText() \|\|
	662	(copy) != (result)) {
	663	errln("Error copying StringSearch");
	664	}
	665	delete result;
	666
	667	/* testing if an extremely large pattern will fail the initialization */
	668	for (count = 0; count < 512; count ++) {
	669	pattern.append(temp);
	670	}
	671	result = new StringSearch(pattern, text, m_en_us_, NULL, status);
	672	if (result != result) {
	673	errln("Error: string search object expected to match itself");
	674	}
	675	if (result == copy) {
	676	errln("Error: string search objects are not expected to match");
	677	}
	678	copy = result;
	679	if ((copy->getCollator()) != (result->getCollator()) \|\|
	680	copy->getBreakIterator() != result->getBreakIterator() \|\|
	681	copy->getMatchedLength() != result->getMatchedLength() \|\|
	682	copy->getMatchedStart() != result->getMatchedStart() \|\|
	683	copy->getOffset() != result->getOffset() \|\|
	684	copy->getPattern() != result->getPattern() \|\|
	685	copy->getText() != result->getText() \|\|
	686	(copy) != (result)) {
	687	errln("Error copying StringSearch");
	688	}
	689	if (U_FAILURE(status)) {
	690	errln("Error opening search %s", u_errorName(status));
	691	}
	692	delete result;
	693	delete copy;
	694	}
	695
	696	void StringSearchTest::TestBasic()
	697	{
	698	int count = 0;
	699	while (BASIC[count].text != NULL) {
	700	//printf("count %d", count);
	701	if (!assertEqual(&BASIC[count])) {
	702	infoln("Error at test number %d", count);
	703	}
	704	count ++;
	705	}
	706	}
	707
	708	void StringSearchTest::TestNormExact()
	709	{
	710	int count = 0;
	711	UErrorCode status = U_ZERO_ERROR;
	712	m_en_us_->setAttribute(UCOL_NORMALIZATION_MODE, UCOL_ON, status);
	713	if (U_FAILURE(status)) {
	714	errln("Error setting collation normalization %s",
	715	u_errorName(status));
	716	}
	717	while (BASIC[count].text != NULL) {
	718	if (!assertEqual(&BASIC[count])) {
	719	infoln("Error at test number %d", count);
	720	}
	721	count ++;
	722	}
	723	count = 0;
	724	while (NORMEXACT[count].text != NULL) {
	725	if (!assertEqual(&NORMEXACT[count])) {
	726	infoln("Error at test number %d", count);
	727	}
	728	count ++;
	729	}
	730	m_en_us_->setAttribute(UCOL_NORMALIZATION_MODE, UCOL_OFF, status);
	731	count = 0;
	732	while (NONNORMEXACT[count].text != NULL) {
	733	if (!assertEqual(&NONNORMEXACT[count])) {
	734	infoln("Error at test number %d", count);
	735	}
	736	count ++;
	737	}
	738	}
	739
	740	void StringSearchTest::TestStrength()
	741	{
	742	int count = 0;
	743	while (STRENGTH[count].text != NULL) {
	744	if (!assertEqual(&STRENGTH[count])) {
	745	infoln("Error at test number %d", count);
	746	}
	747	count ++;
	748	}
	749	}
	750
	751	#if !UCONFIG_NO_BREAK_ITERATION
	752
	753	void StringSearchTest::TestBreakIterator()
	754	{
	755	UChar temp[128];
	756	u_unescape(BREAKITERATOREXACT[0].text, temp, 128);
	757	UnicodeString text;
	758	text.setTo(temp, u_strlen(temp));
	759	u_unescape(BREAKITERATOREXACT[0].pattern, temp, 128);
	760	UnicodeString pattern;
	761	pattern.setTo(temp, u_strlen(temp));
	762
	763	UErrorCode status = U_ZERO_ERROR;
	764	StringSearch *strsrch = new StringSearch(pattern, text, m_en_us_, NULL,
	765	status);
	766	if (U_FAILURE(status)) {
	767	errln("Error opening string search %s", u_errorName(status));
	768	}
	769
	770	strsrch->setBreakIterator(NULL, status);
	771	if (U_FAILURE(status) \|\| strsrch->getBreakIterator() != NULL) {
	772	errln("Error usearch_getBreakIterator returned wrong object");
	773	}
	774
	775	strsrch->setBreakIterator(m_en_characterbreaker_, status);
	776	if (U_FAILURE(status) \|\|
	777	strsrch->getBreakIterator() != m_en_characterbreaker_) {
	778	errln("Error usearch_getBreakIterator returned wrong object");
	779	}
	780
	781	strsrch->setBreakIterator(m_en_wordbreaker_, status);
	782	if (U_FAILURE(status) \|\|
	783	strsrch->getBreakIterator() != m_en_wordbreaker_) {
	784	errln("Error usearch_getBreakIterator returned wrong object");
	785	}
	786
	787	delete strsrch;
	788
	789	int count = 0;
	790	while (count < 4) {
	791	// special purposes for tests numbers 0-3
	792	const SearchData *search = &(BREAKITERATOREXACT[count]);
	793	RuleBasedCollator *collator = getCollator(search->collator);
	794	BreakIterator *breaker = getBreakIterator(search->breaker);
	795	StringSearch *strsrch;
	796
	797	u_unescape(search->text, temp, 128);
	798	text.setTo(temp, u_strlen(temp));
	799	u_unescape(search->pattern, temp, 128);
	800	pattern.setTo(temp, u_strlen(temp));
	801	if (breaker != NULL) {
	802	breaker->setText(text);
	803	}
	804	collator->setStrength(getECollationStrength(search->strength));
	805
	806	strsrch = new StringSearch(pattern, text, collator, breaker, status);
	807	if (U_FAILURE(status) \|\|
	808	strsrch->getBreakIterator() != breaker) {
	809	errln("Error setting break iterator");
	810	if (strsrch != NULL) {
	811	delete strsrch;
	812	}
	813	}
	814	if (!assertEqualWithStringSearch(strsrch, search)) {
	815	collator->setStrength(getECollationStrength(UCOL_TERTIARY));
	816	delete strsrch;
	817	}
	818	search = &(BREAKITERATOREXACT[count + 1]);
	819	breaker = getBreakIterator(search->breaker);
	820	if (breaker != NULL) {
	821	breaker->setText(text);
	822	}
	823	strsrch->setBreakIterator(breaker, status);
	824	if (U_FAILURE(status) \|\|
	825	strsrch->getBreakIterator() != breaker) {
	826	errln("Error setting break iterator");
	827	delete strsrch;
	828	}
	829	strsrch->reset();
	830	if (!assertEqualWithStringSearch(strsrch, search)) {
	831	infoln("Error at test number %d", count);
	832	}
	833	delete strsrch;
	834	count += 2;
	835	}
	836	count = 0;
	837	while (BREAKITERATOREXACT[count].text != NULL) {
	838	if (!assertEqual(&BREAKITERATOREXACT[count])) {
	839	infoln("Error at test number %d", count);
	840	}
	841	count ++;
	842	}
	843	}
	844
	845	#endif
	846
	847	void StringSearchTest::TestVariable()
	848	{
	849	int count = 0;
	850	UErrorCode status = U_ZERO_ERROR;
	851	m_en_us_->setAttribute(UCOL_ALTERNATE_HANDLING, UCOL_SHIFTED, status);
	852	if (U_FAILURE(status)) {
	853	errln("Error setting collation alternate attribute %s",
	854	u_errorName(status));
	855	}
	856	while (VARIABLE[count].text != NULL) {
	857	logln("variable %d", count);
	858	if (!assertEqual(&VARIABLE[count])) {
	859	infoln("Error at test number %d", count);
	860	}
	861	count ++;
	862	}
	863	m_en_us_->setAttribute(UCOL_ALTERNATE_HANDLING, UCOL_NON_IGNORABLE,
	864	status);
	865	}
	866
	867	void StringSearchTest::TestOverlap()
	868	{
	869	int count = 0;
	870	while (OVERLAP[count].text != NULL) {
	871	if (!assertEqualWithAttribute(&OVERLAP[count], USEARCH_OFF,
	872	USEARCH_ON)) {
	873	errln("Error at overlap test number %d", count);
	874	}
	875	count ++;
	876	}
	877	count = 0;
	878	while (NONOVERLAP[count].text != NULL) {
	879	if (!assertEqual(&NONOVERLAP[count])) {
	880	errln("Error at non overlap test number %d", count);
	881	}
	882	count ++;
	883	}
	884
	885	count = 0;
	886	while (count < 1) {
	887	const SearchData *search = &(OVERLAP[count]);
	888	UChar temp[128];
	889	u_unescape(search->text, temp, 128);
	890	UnicodeString text;
	891	text.setTo(temp, u_strlen(temp));
	892	u_unescape(search->pattern, temp, 128);
	893	UnicodeString pattern;
	894	pattern.setTo(temp, u_strlen(temp));
	895
	896	RuleBasedCollator *collator = getCollator(search->collator);
	897	UErrorCode status = U_ZERO_ERROR;
	898	StringSearch *strsrch = new StringSearch(pattern, text,
	899	collator, NULL,
	900	status);
	901
	902	strsrch->setAttribute(USEARCH_OVERLAP, USEARCH_ON, status);
	903	if (U_FAILURE(status) \|\|
	904	strsrch->getAttribute(USEARCH_OVERLAP) != USEARCH_ON) {
	905	errln("Error setting overlap option");
	906	}
	907	if (!assertEqualWithStringSearch(strsrch, search)) {
	908	delete strsrch;
	909	return;
	910	}
	911
	912	search = &(NONOVERLAP[count]);
	913	strsrch->setAttribute(USEARCH_OVERLAP, USEARCH_OFF, status);
	914	if (U_FAILURE(status) \|\|
	915	strsrch->getAttribute(USEARCH_OVERLAP) != USEARCH_OFF) {
	916	errln("Error setting overlap option");
	917	}
	918	strsrch->reset();
	919	if (!assertEqualWithStringSearch(strsrch, search)) {
	920	delete strsrch;
	921	errln("Error at test number %d", count);
	922	}
	923
	924	count ++;
	925	delete strsrch;
	926	}
	927	}
	928
	929	void StringSearchTest::TestCollator()
	930	{
	931	// test collator that thinks "o" and "p" are the same thing
	932	UChar temp[128];
	933	u_unescape(COLLATOR[0].text, temp, 128);
	934	UnicodeString text;
	935	text.setTo(temp, u_strlen(temp));
	936	u_unescape(COLLATOR[0].pattern, temp, 128);
	937	UnicodeString pattern;
	938	pattern.setTo(temp, u_strlen(temp));
	939
	940	UErrorCode status = U_ZERO_ERROR;
	941	StringSearch *strsrch = new StringSearch(pattern, text, m_en_us_, NULL,
	942	status);
	943	if (U_FAILURE(status)) {
	944	errln("Error opening string search %s", u_errorName(status));
	945	delete strsrch;
	946	return;
	947	}
	948	if (!assertEqualWithStringSearch(strsrch, &COLLATOR[0])) {
	949	delete strsrch;
	950	return;
	951	}
	952
	953	u_unescape(TESTCOLLATORRULE, temp, 128);
	954	UnicodeString rules;
	955	rules.setTo(temp, u_strlen(temp));
	956	RuleBasedCollator *tailored = new RuleBasedCollator(rules, status);
	957	tailored->setStrength(getECollationStrength(COLLATOR[1].strength));
	958
	959	if (U_FAILURE(status)) {
	960	errln("Error opening rule based collator %s", u_errorName(status));
	961	delete strsrch;
	962	if (tailored != NULL) {
	963	delete tailored;
	964	}
	965	return;
	966	}
	967
	968	strsrch->setCollator(tailored, status);
	969	if (U_FAILURE(status) \|\| (strsrch->getCollator()) != (tailored)) {
	970	errln("Error setting rule based collator");
	971	delete strsrch;
	972	if (tailored != NULL) {
	973	delete tailored;
	974	}
	975	}
	976	strsrch->reset();
	977	if (!assertEqualWithStringSearch(strsrch, &COLLATOR[1])) {
	978	delete strsrch;
	979	if (tailored != NULL) {
	980	delete tailored;
	981	}
	982	return;
	983	}
	984
	985	strsrch->setCollator(m_en_us_, status);
	986	strsrch->reset();
	987	if (U_FAILURE(status) \|\| (strsrch->getCollator()) != (m_en_us_)) {
	988	errln("Error setting rule based collator");
	989	delete strsrch;
	990	if (tailored != NULL) {
	991	delete tailored;
	992	}
	993	}
	994	if (!assertEqualWithStringSearch(strsrch, &COLLATOR[0])) {
	995	errln("Error searching collator test");
	996	}
	997	delete strsrch;
	998	if (tailored != NULL) {
	999	delete tailored;
	1000	}
	1001	}
	1002
	1003	void StringSearchTest::TestPattern()
	1004	{
	1005
	1006	UChar temp[512];
	1007	int templength;
	1008	u_unescape(PATTERN[0].text, temp, 512);
	1009	UnicodeString text;
	1010	text.setTo(temp, u_strlen(temp));
	1011	u_unescape(PATTERN[0].pattern, temp, 512);
	1012	UnicodeString pattern;
	1013	pattern.setTo(temp, u_strlen(temp));
	1014
	1015	m_en_us_->setStrength(getECollationStrength(PATTERN[0].strength));
	1016	UErrorCode status = U_ZERO_ERROR;
	1017	StringSearch *strsrch = new StringSearch(pattern, text, m_en_us_, NULL,
	1018	status);
	1019
	1020	if (U_FAILURE(status)) {
	1021	errln("Error opening string search %s", u_errorName(status));
	1022	m_en_us_->setStrength(getECollationStrength(UCOL_TERTIARY));
	1023	if (strsrch != NULL) {
	1024	delete strsrch;
	1025	}
	1026	return;
	1027	}
	1028	if (strsrch->getPattern() != pattern) {
	1029	errln("Error setting pattern");
	1030	}
	1031	if (!assertEqualWithStringSearch(strsrch, &PATTERN[0])) {
	1032	m_en_us_->setStrength(getECollationStrength(UCOL_TERTIARY));
	1033	if (strsrch != NULL) {
	1034	delete strsrch;
	1035	}
	1036	return;
	1037	}
	1038
	1039	u_unescape(PATTERN[1].pattern, temp, 512);
	1040	pattern.setTo(temp, u_strlen(temp));
	1041	strsrch->setPattern(pattern, status);
	1042	if (pattern != strsrch->getPattern()) {
	1043	errln("Error setting pattern");
	1044	m_en_us_->setStrength(getECollationStrength(UCOL_TERTIARY));
	1045	if (strsrch != NULL) {
	1046	delete strsrch;
	1047	}
	1048	return;
	1049	}
	1050	strsrch->reset();
	1051	if (U_FAILURE(status)) {
	1052	errln("Error setting pattern %s", u_errorName(status));
	1053	}
	1054	if (!assertEqualWithStringSearch(strsrch, &PATTERN[1])) {
	1055	m_en_us_->setStrength(getECollationStrength(UCOL_TERTIARY));
	1056	if (strsrch != NULL) {
	1057	delete strsrch;
	1058	}
	1059	return;
	1060	}
	1061
	1062	u_unescape(PATTERN[0].pattern, temp, 512);
	1063	pattern.setTo(temp, u_strlen(temp));
	1064	strsrch->setPattern(pattern, status);
	1065	if (pattern != strsrch->getPattern()) {
	1066	errln("Error setting pattern");
	1067	m_en_us_->setStrength(getECollationStrength(UCOL_TERTIARY));
	1068	if (strsrch != NULL) {
	1069	delete strsrch;
	1070	}
	1071	return;
	1072	}
	1073	strsrch->reset();
	1074	if (U_FAILURE(status)) {
	1075	errln("Error setting pattern %s", u_errorName(status));
	1076	}
	1077	if (!assertEqualWithStringSearch(strsrch, &PATTERN[0])) {
	1078	m_en_us_->setStrength(getECollationStrength(UCOL_TERTIARY));
	1079	if (strsrch != NULL) {
	1080	delete strsrch;
	1081	}
	1082	return;
	1083	}
	1084	/* enormous pattern size to see if this crashes */
	1085	for (templength = 0; templength != 512; templength ++) {
	1086	temp[templength] = 0x61;
	1087	}
	1088	temp[511] = 0;
	1089	pattern.setTo(temp, 511);
	1090	strsrch->setPattern(pattern, status);
	1091	if (U_FAILURE(status)) {
	1092	errln("Error setting pattern with size 512, %s", u_errorName(status));
	1093	}
	1094	m_en_us_->setStrength(getECollationStrength(UCOL_TERTIARY));
	1095	if (strsrch != NULL) {
	1096	delete strsrch;
	1097	}
	1098	}
	1099
	1100	void StringSearchTest::TestText()
	1101	{
	1102	UChar temp[128];
	1103	u_unescape(TEXT[0].text, temp, 128);
	1104	UnicodeString text;
	1105	text.setTo(temp, u_strlen(temp));
	1106	u_unescape(TEXT[0].pattern, temp, 128);
	1107	UnicodeString pattern;
	1108	pattern.setTo(temp, u_strlen(temp));
	1109
	1110	UErrorCode status = U_ZERO_ERROR;
	1111	StringSearch *strsrch = new StringSearch(pattern, text, m_en_us_, NULL,
	1112	status);
	1113	if (U_FAILURE(status)) {
	1114	errln("Error opening string search %s", u_errorName(status));
	1115	return;
	1116	}
	1117	if (text != strsrch->getText()) {
	1118	errln("Error setting text");
	1119	}
	1120	if (!assertEqualWithStringSearch(strsrch, &TEXT[0])) {
	1121	delete strsrch;
	1122	return;
	1123	}
	1124
	1125	u_unescape(TEXT[1].text, temp, 128);
	1126	text.setTo(temp, u_strlen(temp));
	1127	strsrch->setText(text, status);
	1128	if (text != strsrch->getText()) {
	1129	errln("Error setting text");
	1130	delete strsrch;
	1131	return;
	1132	}
	1133	if (U_FAILURE(status)) {
	1134	errln("Error setting text %s", u_errorName(status));
	1135	}
	1136	if (!assertEqualWithStringSearch(strsrch, &TEXT[1])) {
	1137	delete strsrch;
	1138	return;
	1139	}
	1140
	1141	u_unescape(TEXT[0].text, temp, 128);
	1142	text.setTo(temp, u_strlen(temp));
	1143	StringCharacterIterator chariter(text);
	1144	strsrch->setText(chariter, status);
	1145	if (text != strsrch->getText()) {
	1146	errln("Error setting text");
	1147	delete strsrch;
	1148	return;
	1149	}
	1150	if (U_FAILURE(status)) {
	1151	errln("Error setting pattern %s", u_errorName(status));
	1152	}
	1153	if (!assertEqualWithStringSearch(strsrch, &TEXT[0])) {
	1154	errln("Error searching within set text");
	1155	}
	1156	delete strsrch;
	1157	}
	1158
	1159	void StringSearchTest::TestCompositeBoundaries()
	1160	{
	1161	int count = 0;
	1162	while (COMPOSITEBOUNDARIES[count].text != NULL) {
	1163	logln("composite %d", count);
	1164	if (!assertEqual(&COMPOSITEBOUNDARIES[count])) {
	1165	errln("Error at test number %d", count);
	1166	}
	1167	count ++;
	1168	}
	1169	}
	1170
	1171	void StringSearchTest::TestGetSetOffset()
	1172	{
	1173	UErrorCode status = U_ZERO_ERROR;
	1174	UnicodeString pattern("1234567890123456");
	1175	UnicodeString text("12345678901234567890123456789012");
	1176	StringSearch *strsrch = new StringSearch(pattern, text, m_en_us_,
	1177	NULL, status);
	1178	/* testing out of bounds error */
	1179	strsrch->setOffset(-1, status);
	1180	if (U_SUCCESS(status)) {
	1181	errln("Error expecting set offset error");
	1182	}
	1183	strsrch->setOffset(128, status);
	1184	if (U_SUCCESS(status)) {
	1185	errln("Error expecting set offset error");
	1186	}
	1187	int index = 0;
	1188	while (BASIC[index].text != NULL) {
	1189	UErrorCode status = U_ZERO_ERROR;
	1190	SearchData search = BASIC[index ++];
	1191	UChar temp[128];
	1192
	1193	u_unescape(search.text, temp, 128);
	1194	text.setTo(temp, u_strlen(temp));
	1195	u_unescape(search.pattern, temp, 128);
	1196	pattern.setTo(temp, u_strlen(temp));
	1197	strsrch->setText(text, status);
	1198	strsrch->setPattern(pattern, status);
	1199	strsrch->getCollator()->setStrength(getECollationStrength(
	1200	search.strength));
	1201	strsrch->reset();
	1202
	1203	int count = 0;
	1204	int32_t matchindex = search.offset[count];
	1205	while (U_SUCCESS(status) && matchindex >= 0) {
	1206	int32_t matchlength = search.size[count];
	1207	strsrch->next(status);
	1208	if (matchindex != strsrch->getMatchedStart() \|\|
	1209	matchlength != strsrch->getMatchedLength()) {
	1210	char *str = toCharString(strsrch->getText());
	1211	errln("Text: %s", str);
	1212	str = toCharString(strsrch->getPattern());
	1213	errln("Pattern: %s", str);
	1214	errln("Error match found at %d %d",
	1215	strsrch->getMatchedStart(),
	1216	strsrch->getMatchedLength());
	1217	return;
	1218	}
	1219	matchindex = search.offset[count + 1] == -1 ? -1 :
	1220	search.offset[count + 2];
	1221	if (search.offset[count + 1] != -1) {
	1222	strsrch->setOffset(search.offset[count + 1] + 1, status);
	1223	if (strsrch->getOffset() != search.offset[count + 1] + 1) {
	1224	errln("Error setting offset\n");
	1225	return;
	1226	}
	1227	}
	1228
	1229	count += 2;
	1230	}
	1231	strsrch->next(status);
	1232	if (strsrch->getMatchedStart() != USEARCH_DONE) {
	1233	char *str = toCharString(strsrch->getText());
	1234	errln("Text: %s", str);
	1235	str = toCharString(strsrch->getPattern());
	1236	errln("Pattern: %s", str);
	1237	errln("Error match found at %d %d",
	1238	strsrch->getMatchedStart(),
	1239	strsrch->getMatchedLength());
	1240	return;
	1241	}
	1242	}
	1243	strsrch->getCollator()->setStrength(getECollationStrength(
	1244	UCOL_TERTIARY));
	1245	delete strsrch;
	1246	}
	1247
	1248	void StringSearchTest::TestGetSetAttribute()
	1249	{
	1250	UErrorCode status = U_ZERO_ERROR;
	1251	UnicodeString pattern("pattern");
	1252	UnicodeString text("text");
	1253	StringSearch *strsrch = new StringSearch(pattern, text, m_en_us_, NULL,
	1254	status);
	1255	if (U_FAILURE(status)) {
	1256	errln("Error opening search %s", u_errorName(status));
	1257	return;
	1258	}
	1259
	1260	strsrch->setAttribute(USEARCH_OVERLAP, USEARCH_DEFAULT, status);
	1261	if (U_FAILURE(status) \|\|
	1262	strsrch->getAttribute(USEARCH_OVERLAP) != USEARCH_OFF) {
	1263	errln("Error setting overlap to the default");
	1264	}
	1265	strsrch->setAttribute(USEARCH_OVERLAP, USEARCH_ON, status);
	1266	if (U_FAILURE(status) \|\|
	1267	strsrch->getAttribute(USEARCH_OVERLAP) != USEARCH_ON) {
	1268	errln("Error setting overlap true");
	1269	}
	1270	strsrch->setAttribute(USEARCH_OVERLAP, USEARCH_OFF, status);
	1271	if (U_FAILURE(status) \|\|
	1272	strsrch->getAttribute(USEARCH_OVERLAP) != USEARCH_OFF) {
	1273	errln("Error setting overlap false");
	1274	}
	1275	strsrch->setAttribute(USEARCH_OVERLAP, USEARCH_ATTRIBUTE_VALUE_COUNT,
	1276	status);
	1277	if (U_SUCCESS(status)) {
	1278	errln("Error setting overlap to illegal value");
	1279	}
	1280	status = U_ZERO_ERROR;
	1281	strsrch->setAttribute(USEARCH_CANONICAL_MATCH, USEARCH_DEFAULT, status);
	1282	if (U_FAILURE(status) \|\|
	1283	strsrch->getAttribute(USEARCH_CANONICAL_MATCH) != USEARCH_OFF) {
	1284	errln("Error setting canonical match to the default");
	1285	}
	1286	strsrch->setAttribute(USEARCH_CANONICAL_MATCH, USEARCH_ON, status);
	1287	if (U_FAILURE(status) \|\|
	1288	strsrch->getAttribute(USEARCH_CANONICAL_MATCH) != USEARCH_ON) {
	1289	errln("Error setting canonical match true");
	1290	}
	1291	strsrch->setAttribute(USEARCH_CANONICAL_MATCH, USEARCH_OFF, status);
	1292	if (U_FAILURE(status) \|\|
	1293	strsrch->getAttribute(USEARCH_CANONICAL_MATCH) != USEARCH_OFF) {
	1294	errln("Error setting canonical match false");
	1295	}
	1296	strsrch->setAttribute(USEARCH_CANONICAL_MATCH,
	1297	USEARCH_ATTRIBUTE_VALUE_COUNT, status);
	1298	if (U_SUCCESS(status)) {
	1299	errln("Error setting canonical match to illegal value");
	1300	}
	1301	status = U_ZERO_ERROR;
	1302	strsrch->setAttribute(USEARCH_ATTRIBUTE_COUNT, USEARCH_DEFAULT, status);
	1303	if (U_SUCCESS(status)) {
	1304	errln("Error setting illegal attribute success");
	1305	}
	1306
	1307	delete strsrch;
	1308	}
	1309
	1310	void StringSearchTest::TestGetMatch()
	1311	{
	1312	UChar temp[128];
	1313	SearchData search = MATCH[0];
	1314	u_unescape(search.text, temp, 128);
	1315	UnicodeString text;
	1316	text.setTo(temp, u_strlen(temp));
	1317	u_unescape(search.pattern, temp, 128);
	1318	UnicodeString pattern;
	1319	pattern.setTo(temp, u_strlen(temp));
	1320
	1321	UErrorCode status = U_ZERO_ERROR;
	1322	StringSearch *strsrch = new StringSearch(pattern, text, m_en_us_, NULL,
	1323	status);
	1324	if (U_FAILURE(status)) {
	1325	errln("Error opening string search %s", u_errorName(status));
	1326	if (strsrch != NULL) {
	1327	delete strsrch;
	1328	}
	1329	return;
	1330	}
	1331
	1332	int count = 0;
	1333	int32_t matchindex = search.offset[count];
	1334	UnicodeString matchtext;
	1335	while (U_SUCCESS(status) && matchindex >= 0) {
	1336	int32_t matchlength = search.size[count];
	1337	strsrch->next(status);
	1338	if (matchindex != strsrch->getMatchedStart() \|\|
	1339	matchlength != strsrch->getMatchedLength()) {
	1340	char *str = toCharString(strsrch->getText());
	1341	errln("Text: %s", str);
	1342	str = toCharString(strsrch->getPattern());
	1343	errln("Pattern: %s", str);
	1344	errln("Error match found at %d %d", strsrch->getMatchedStart(),
	1345	strsrch->getMatchedLength());
	1346	return;
	1347	}
	1348	count ++;
	1349
	1350	status = U_ZERO_ERROR;
	1351	strsrch->getMatchedText(matchtext);
	1352	if (matchtext.length() != matchlength \|\| U_FAILURE(status)){
	1353	errln("Error getting match text");
	1354	}
	1355	matchindex = search.offset[count];
	1356	}
	1357	status = U_ZERO_ERROR;
	1358	strsrch->next(status);
	1359	if (strsrch->getMatchedStart() != USEARCH_DONE \|\|
	1360	strsrch->getMatchedLength() != 0) {
	1361	errln("Error end of match not found");
	1362	}
	1363	status = U_ZERO_ERROR;
	1364	strsrch->getMatchedText(matchtext);
	1365	if (matchtext.length() != 0) {
	1366	errln("Error getting null matches");
	1367	}
	1368	delete strsrch;
	1369	}
	1370
	1371	void StringSearchTest::TestSetMatch()
	1372	{
	1373	int count = 0;
	1374	while (MATCH[count].text != NULL) {
	1375	SearchData search = MATCH[count];
	1376	UChar temp[128];
	1377	UErrorCode status = U_ZERO_ERROR;
	1378	u_unescape(search.text, temp, 128);
	1379	UnicodeString text;
	1380	text.setTo(temp, u_strlen(temp));
	1381	u_unescape(search.pattern, temp, 128);
	1382	UnicodeString pattern;
	1383	pattern.setTo(temp, u_strlen(temp));
	1384
	1385	StringSearch *strsrch = new StringSearch(pattern, text, m_en_us_,
	1386	NULL, status);
	1387	if (U_FAILURE(status)) {
	1388	errln("Error opening string search %s", u_errorName(status));
	1389	if (strsrch != NULL) {
	1390	delete strsrch;
	1391	}
	1392	return;
	1393	}
	1394
	1395	int size = 0;
	1396	while (search.offset[size] != -1) {
	1397	size ++;
	1398	}
	1399
	1400	if (strsrch->first(status) != search.offset[0] \|\| U_FAILURE(status)) {
	1401	errln("Error getting first match");
	1402	}
	1403	if (strsrch->last(status) != search.offset[size -1] \|\|
	1404	U_FAILURE(status)) {
	1405	errln("Error getting last match");
	1406	}
	1407
	1408	int index = 0;
	1409	while (index < size) {
	1410	if (index + 2 < size) {
	1411	if (strsrch->following(search.offset[index + 2] - 1, status)
	1412	!= search.offset[index + 2] \|\| U_FAILURE(status)) {
	1413	errln("Error getting following match at index %d",
	1414	search.offset[index + 2] - 1);
	1415	}
	1416	}
	1417	if (index + 1 < size) {
	1418	if (strsrch->preceding(search.offset[index + 1] +
	1419	search.size[index + 1] + 1,
	1420	status) != search.offset[index + 1] \|\|
	1421	U_FAILURE(status)) {
	1422	errln("Error getting preceeding match at index %d",
	1423	search.offset[index + 1] + 1);
	1424	}
	1425	}
	1426	index += 2;
	1427	}
	1428	status = U_ZERO_ERROR;
	1429	if (strsrch->following(text.length(), status) != USEARCH_DONE) {
	1430	errln("Error expecting out of bounds match");
	1431	}
	1432	if (strsrch->preceding(0, status) != USEARCH_DONE) {
	1433	errln("Error expecting out of bounds match");
	1434	}
	1435	count ++;
	1436	delete strsrch;
	1437	}
	1438	}
	1439
	1440	void StringSearchTest::TestReset()
	1441	{
	1442	UErrorCode status = U_ZERO_ERROR;
	1443	UnicodeString text("fish fish");
	1444	UnicodeString pattern("s");
	1445	StringSearch *strsrch = new StringSearch(pattern, text, m_en_us_, NULL,
	1446	status);
	1447	if (U_FAILURE(status)) {
	1448	errln("Error opening string search %s", u_errorName(status));
	1449	if (strsrch != NULL) {
	1450	delete strsrch;
	1451	}
	1452	return;
	1453	}
	1454	strsrch->setAttribute(USEARCH_OVERLAP, USEARCH_ON, status);
	1455	strsrch->setAttribute(USEARCH_CANONICAL_MATCH, USEARCH_ON, status);
	1456	strsrch->setOffset(9, status);
	1457	if (U_FAILURE(status)) {
	1458	errln("Error setting attributes and offsets");
	1459	}
	1460	else {
	1461	strsrch->reset();
	1462	if (strsrch->getAttribute(USEARCH_OVERLAP) != USEARCH_OFF \|\|
	1463	strsrch->getAttribute(USEARCH_CANONICAL_MATCH) != USEARCH_OFF \|\|
	1464	strsrch->getOffset() != 0 \|\| strsrch->getMatchedLength() != 0 \|\|
	1465	strsrch->getMatchedStart() != USEARCH_DONE) {
	1466	errln("Error resetting string search");
	1467	}
	1468	strsrch->previous(status);
	1469	if (strsrch->getMatchedStart() != 7 \|\|
	1470	strsrch->getMatchedLength() != 1) {
	1471	errln("Error resetting string search\n");
	1472	}
	1473	}
	1474	delete strsrch;
	1475	}
	1476
	1477	void StringSearchTest::TestSupplementary()
	1478	{
	1479	int count = 0;
	1480	while (SUPPLEMENTARY[count].text != NULL) {
	1481	if (!assertEqual(&SUPPLEMENTARY[count])) {
	1482	errln("Error at test number %d", count);
	1483	}
	1484	count ++;
	1485	}
	1486	}
	1487
	1488	void StringSearchTest::TestContraction()
	1489	{
	1490	UChar temp[128];
	1491	UErrorCode status = U_ZERO_ERROR;
	1492
	1493	u_unescape(CONTRACTIONRULE, temp, 128);
	1494	UnicodeString rules;
	1495	rules.setTo(temp, u_strlen(temp));
	1496	RuleBasedCollator *collator = new RuleBasedCollator(rules,
	1497	getECollationStrength(UCOL_TERTIARY), UCOL_ON, status);
	1498	if (U_FAILURE(status)) {
	1499	errln("Error opening collator %s", u_errorName(status));
	1500	}
	1501	UnicodeString text("text");
	1502	UnicodeString pattern("pattern");
	1503	StringSearch *strsrch = new StringSearch(pattern, text, collator, NULL,
	1504	status);
	1505	if (U_FAILURE(status)) {
	1506	errln("Error opening string search %s", u_errorName(status));
	1507	}
	1508
	1509	int count = 0;
	1510	while (CONTRACTION[count].text != NULL) {
	1511	u_unescape(CONTRACTION[count].text, temp, 128);
	1512	text.setTo(temp, u_strlen(temp));
	1513	u_unescape(CONTRACTION[count].pattern, temp, 128);
	1514	pattern.setTo(temp, u_strlen(temp));
	1515	strsrch->setText(text, status);
	1516	strsrch->setPattern(pattern, status);
	1517	if (!assertEqualWithStringSearch(strsrch, &CONTRACTION[count])) {
	1518	errln("Error at test number %d", count);
	1519	}
	1520	count ++;
	1521	}
	1522	delete strsrch;
	1523	delete collator;
	1524	}
	1525
	1526	void StringSearchTest::TestIgnorable()
	1527	{
	1528	UChar temp[128];
	1529	u_unescape(IGNORABLERULE, temp, 128);
	1530	UnicodeString rules;
	1531	rules.setTo(temp, u_strlen(temp));
	1532	UErrorCode status = U_ZERO_ERROR;
	1533	int count = 0;
	1534	RuleBasedCollator *collator = new RuleBasedCollator(rules,
	1535	getECollationStrength(IGNORABLE[count].strength),
	1536	UCOL_ON, status);
	1537	if (U_FAILURE(status)) {
	1538	errln("Error opening collator %s", u_errorName(status));
	1539	return;
	1540	}
	1541	UnicodeString pattern("pattern");
	1542	UnicodeString text("text");
	1543	StringSearch *strsrch = new StringSearch(pattern, text, collator, NULL,
	1544	status);
	1545	if (U_FAILURE(status)) {
	1546	errln("Error opening string search %s", u_errorName(status));
	1547	delete collator;
	1548	return;
	1549	}
	1550
	1551	while (IGNORABLE[count].text != NULL) {
	1552	u_unescape(IGNORABLE[count].text, temp, 128);
	1553	text.setTo(temp, u_strlen(temp));
	1554	u_unescape(IGNORABLE[count].pattern, temp, 128);
	1555	pattern.setTo(temp, u_strlen(temp));
	1556	strsrch->setText(text, status);
	1557	strsrch->setPattern(pattern, status);
	1558	if (!assertEqualWithStringSearch(strsrch, &IGNORABLE[count])) {
	1559	errln("Error at test number %d", count);
	1560	}
	1561	count ++;
	1562	}
	1563	delete strsrch;
	1564	delete collator;
	1565	}
	1566
	1567	void StringSearchTest::TestDiacriticMatch()
	1568	{
	1569	UChar temp[128];
	1570	UErrorCode status = U_ZERO_ERROR;
	1571	int count = 0;
	1572	RuleBasedCollator* coll = NULL;
	1573	StringSearch *strsrch = NULL;
	1574
	1575	UnicodeString pattern("pattern");
	1576	UnicodeString text("text");
	1577
	1578	const SearchData *search;
	1579
	1580	search = &(DIACRITICMATCH[count]);
	1581	while (search->text != NULL) {
	1582	coll = getCollator(search->collator);
	1583	coll->setStrength(getECollationStrength(search->strength));
	1584	strsrch = new StringSearch(pattern, text, coll, getBreakIterator(search->breaker), status);
	1585	if (U_FAILURE(status)) {
	1586	errln("Error opening string search %s", u_errorName(status));
	1587	return;
	1588	}
	1589	u_unescape(search->text, temp, 128);
	1590	text.setTo(temp, u_strlen(temp));
	1591	u_unescape(search->pattern, temp, 128);
	1592	pattern.setTo(temp, u_strlen(temp));
	1593	strsrch->setText(text, status);
	1594	strsrch->setPattern(pattern, status);
	1595	if (!assertEqualWithStringSearch(strsrch, search)) {
	1596	errln("Error at test number %d", count);
	1597	}
	1598	search = &(DIACRITICMATCH[++count]);
	1599	delete strsrch;
	1600	}
	1601
	1602	}
	1603
	1604	void StringSearchTest::TestCanonical()
	1605	{
	1606	int count = 0;
	1607	while (BASICCANONICAL[count].text != NULL) {
	1608	if (!assertCanonicalEqual(&BASICCANONICAL[count])) {
	1609	errln("Error at test number %d", count);
	1610	}
	1611	count ++;
	1612	}
	1613	}
	1614
	1615	void StringSearchTest::TestNormCanonical()
	1616	{
	1617	UErrorCode status = U_ZERO_ERROR;
	1618	m_en_us_->setAttribute(UCOL_NORMALIZATION_MODE, UCOL_ON, status);
	1619	int count = 0;
	1620	while (NORMCANONICAL[count].text != NULL) {
	1621	if (!assertCanonicalEqual(&NORMCANONICAL[count])) {
	1622	errln("Error at test number %d", count);
	1623	}
	1624	count ++;
	1625	}
	1626	m_en_us_->setAttribute(UCOL_NORMALIZATION_MODE, UCOL_OFF, status);
	1627	}
	1628
	1629	void StringSearchTest::TestStrengthCanonical()
	1630	{
	1631	int count = 0;
	1632	while (STRENGTHCANONICAL[count].text != NULL) {
	1633	if (!assertCanonicalEqual(&STRENGTHCANONICAL[count])) {
	1634	errln("Error at test number %d", count);
	1635	}
	1636	count ++;
	1637	}
	1638	}
	1639
	1640	#if !UCONFIG_NO_BREAK_ITERATION
	1641
	1642	void StringSearchTest::TestBreakIteratorCanonical()
	1643	{
	1644	UErrorCode status = U_ZERO_ERROR;
	1645	int count = 0;
	1646
	1647	while (count < 4) {
	1648	// special purposes for tests numbers 0-3
	1649	UChar temp[128];
	1650	const SearchData *search = &(BREAKITERATORCANONICAL[count]);
	1651
	1652	u_unescape(search->text, temp, 128);
	1653	UnicodeString text;
	1654	text.setTo(temp, u_strlen(temp));
	1655	u_unescape(search->pattern, temp, 128);
	1656	UnicodeString pattern;
	1657	pattern.setTo(temp, u_strlen(temp));
	1658	RuleBasedCollator *collator = getCollator(search->collator);
	1659	collator->setStrength(getECollationStrength(search->strength));
	1660
	1661	BreakIterator *breaker = getBreakIterator(search->breaker);
	1662	StringSearch *strsrch = new StringSearch(pattern, text, collator,
	1663	breaker, status);
	1664	if (U_FAILURE(status)) {
	1665	errln("Error creating string search data");
	1666	return;
	1667	}
	1668	strsrch->setAttribute(USEARCH_CANONICAL_MATCH, USEARCH_ON, status);
	1669	if (U_FAILURE(status) \|\|
	1670	strsrch->getBreakIterator() != breaker) {
	1671	errln("Error setting break iterator");
	1672	delete strsrch;
	1673	return;
	1674	}
	1675	if (!assertEqualWithStringSearch(strsrch, search)) {
	1676	collator->setStrength(getECollationStrength(UCOL_TERTIARY));
	1677	delete strsrch;
	1678	return;
	1679	}
	1680	search = &(BREAKITERATOREXACT[count + 1]);
	1681	breaker = getBreakIterator(search->breaker);
	1682	if (breaker == NULL) {
	1683	errln("Error creating BreakIterator");
	1684	return;
	1685	}
	1686	breaker->setText(strsrch->getText());
	1687	strsrch->setBreakIterator(breaker, status);
	1688	if (U_FAILURE(status) \|\| strsrch->getBreakIterator() != breaker) {
	1689	errln("Error setting break iterator");
	1690	delete strsrch;
	1691	return;
	1692	}
	1693	strsrch->reset();
	1694	strsrch->setAttribute(USEARCH_CANONICAL_MATCH, USEARCH_ON, status);
	1695	if (!assertEqualWithStringSearch(strsrch, search)) {
	1696	errln("Error at test number %d", count);
	1697	return;
	1698	}
	1699	delete strsrch;
	1700	count += 2;
	1701	}
	1702	count = 0;
	1703	while (BREAKITERATORCANONICAL[count].text != NULL) {
	1704	if (!assertEqual(&BREAKITERATORCANONICAL[count])) {
	1705	errln("Error at test number %d", count);
	1706	return;
	1707	}
	1708	count ++;
	1709	}
	1710	}
	1711
	1712	#endif
	1713
	1714	void StringSearchTest::TestVariableCanonical()
	1715	{
	1716	int count = 0;
	1717	UErrorCode status = U_ZERO_ERROR;
	1718	m_en_us_->setAttribute(UCOL_ALTERNATE_HANDLING, UCOL_SHIFTED, status);
	1719	if (U_FAILURE(status)) {
	1720	errln("Error setting collation alternate attribute %s",
	1721	u_errorName(status));
	1722	}
	1723	while (VARIABLE[count].text != NULL) {
	1724	logln("variable %d", count);
	1725	if (!assertCanonicalEqual(&VARIABLE[count])) {
	1726	errln("Error at test number %d", count);
	1727	}
	1728	count ++;
	1729	}
	1730	m_en_us_->setAttribute(UCOL_ALTERNATE_HANDLING, UCOL_NON_IGNORABLE,
	1731	status);
	1732	}
	1733
	1734	void StringSearchTest::TestOverlapCanonical()
	1735	{
	1736	int count = 0;
	1737	while (OVERLAPCANONICAL[count].text != NULL) {
	1738	if (!assertEqualWithAttribute(&OVERLAPCANONICAL[count], USEARCH_ON,
	1739	USEARCH_ON)) {
	1740	errln("Error at overlap test number %d", count);
	1741	}
	1742	count ++;
	1743	}
	1744	count = 0;
	1745	while (NONOVERLAP[count].text != NULL) {
	1746	if (!assertCanonicalEqual(&NONOVERLAPCANONICAL[count])) {
	1747	errln("Error at non overlap test number %d", count);
	1748	}
	1749	count ++;
	1750	}
	1751
	1752	count = 0;
	1753	while (count < 1) {
	1754	UChar temp[128];
	1755	const SearchData *search = &(OVERLAPCANONICAL[count]);
	1756	UErrorCode status = U_ZERO_ERROR;
	1757
	1758	u_unescape(search->text, temp, 128);
	1759	UnicodeString text;
	1760	text.setTo(temp, u_strlen(temp));
	1761	u_unescape(search->pattern, temp, 128);
	1762	UnicodeString pattern;
	1763	pattern.setTo(temp, u_strlen(temp));
	1764	RuleBasedCollator *collator = getCollator(search->collator);
	1765	StringSearch *strsrch = new StringSearch(pattern, text, collator,
	1766	NULL, status);
	1767	strsrch->setAttribute(USEARCH_CANONICAL_MATCH, USEARCH_ON, status);
	1768	strsrch->setAttribute(USEARCH_OVERLAP, USEARCH_ON, status);
	1769	if (U_FAILURE(status) \|\|
	1770	strsrch->getAttribute(USEARCH_OVERLAP) != USEARCH_ON) {
	1771	errln("Error setting overlap option");
	1772	}
	1773	if (!assertEqualWithStringSearch(strsrch, search)) {
	1774	delete strsrch;
	1775	return;
	1776	}
	1777	search = &(NONOVERLAPCANONICAL[count]);
	1778	strsrch->setAttribute(USEARCH_OVERLAP, USEARCH_OFF, status);
	1779	if (U_FAILURE(status) \|\|
	1780	strsrch->getAttribute(USEARCH_OVERLAP) != USEARCH_OFF) {
	1781	errln("Error setting overlap option");
	1782	}
	1783	strsrch->reset();
	1784	if (!assertEqualWithStringSearch(strsrch, search)) {
	1785	delete strsrch;
	1786	errln("Error at test number %d", count);
	1787	}
	1788
	1789	count ++;
	1790	delete strsrch;
	1791	}
	1792	}
	1793
	1794	void StringSearchTest::TestCollatorCanonical()
	1795	{
	1796	/* test collator that thinks "o" and "p" are the same thing */
	1797	UChar temp[128];
	1798	u_unescape(COLLATORCANONICAL[0].text, temp, 128);
	1799	UnicodeString text;
	1800	text.setTo(temp, u_strlen(temp));
	1801	u_unescape(COLLATORCANONICAL[0].pattern, temp, 128);
	1802	UnicodeString pattern;
	1803	pattern.setTo(temp, u_strlen(temp));
	1804
	1805	UErrorCode status = U_ZERO_ERROR;
	1806	StringSearch *strsrch = new StringSearch(pattern, text, m_en_us_,
	1807	NULL, status);
	1808	strsrch->setAttribute(USEARCH_CANONICAL_MATCH, USEARCH_ON, status);
	1809	if (U_FAILURE(status)) {
	1810	errln("Error opening string search %s", u_errorName(status));
	1811	}
	1812	if (!assertEqualWithStringSearch(strsrch, &COLLATORCANONICAL[0])) {
	1813	delete strsrch;
	1814	return;
	1815	}
	1816
	1817	u_unescape(TESTCOLLATORRULE, temp, 128);
	1818	UnicodeString rules;
	1819	rules.setTo(temp, u_strlen(temp));
	1820	RuleBasedCollator *tailored = new RuleBasedCollator(rules,
	1821	getECollationStrength(COLLATORCANONICAL[1].strength),
	1822	UCOL_ON, status);
	1823
	1824	if (U_FAILURE(status)) {
	1825	errln("Error opening rule based collator %s", u_errorName(status));
	1826	}
	1827
	1828	strsrch->setCollator(tailored, status);
	1829	if (U_FAILURE(status) \|\| (strsrch->getCollator()) != tailored) {
	1830	errln("Error setting rule based collator");
	1831	}
	1832	strsrch->reset();
	1833	strsrch->setAttribute(USEARCH_CANONICAL_MATCH, USEARCH_ON, status);
	1834	if (!assertEqualWithStringSearch(strsrch, &COLLATORCANONICAL[1])) {
	1835	delete strsrch;
	1836	if (tailored != NULL) {
	1837	delete tailored;
	1838	}
	1839
	1840	return;
	1841	}
	1842
	1843	strsrch->setCollator(m_en_us_, status);
	1844	strsrch->reset();
	1845	if (U_FAILURE(status) \|\| (strsrch->getCollator()) != m_en_us_) {
	1846	errln("Error setting rule based collator");
	1847	}
	1848	if (!assertEqualWithStringSearch(strsrch, &COLLATORCANONICAL[0])) {
	1849	}
	1850	delete strsrch;
	1851	if (tailored != NULL) {
	1852	delete tailored;
	1853	}
	1854	}
	1855
	1856	void StringSearchTest::TestPatternCanonical()
	1857	{
	1858
	1859	UChar temp[128];
	1860
	1861	u_unescape(PATTERNCANONICAL[0].text, temp, 128);
	1862	UnicodeString text;
	1863	text.setTo(temp, u_strlen(temp));
	1864	u_unescape(PATTERNCANONICAL[0].pattern, temp, 128);
	1865	UnicodeString pattern;
	1866	pattern.setTo(temp, u_strlen(temp));
	1867
	1868	m_en_us_->setStrength(
	1869	getECollationStrength(PATTERNCANONICAL[0].strength));
	1870
	1871	UErrorCode status = U_ZERO_ERROR;
	1872	StringSearch *strsrch = new StringSearch(pattern, text, m_en_us_, NULL,
	1873	status);
	1874	strsrch->setAttribute(USEARCH_CANONICAL_MATCH, USEARCH_ON, status);
	1875	if (U_FAILURE(status)) {
	1876	errln("Error opening string search %s", u_errorName(status));
	1877	goto ENDTESTPATTERN;
	1878	}
	1879	if (pattern != strsrch->getPattern()) {
	1880	errln("Error setting pattern");
	1881	}
	1882	if (!assertEqualWithStringSearch(strsrch, &PATTERNCANONICAL[0])) {
	1883	goto ENDTESTPATTERN;
	1884	}
	1885
	1886	u_unescape(PATTERNCANONICAL[1].pattern, temp, 128);
	1887	pattern.setTo(temp, u_strlen(temp));
	1888	strsrch->setPattern(pattern, status);
	1889	if (pattern != strsrch->getPattern()) {
	1890	errln("Error setting pattern");
	1891	goto ENDTESTPATTERN;
	1892	}
	1893	strsrch->reset();
	1894	strsrch->setAttribute(USEARCH_CANONICAL_MATCH, USEARCH_ON, status);
	1895	if (U_FAILURE(status)) {
	1896	errln("Error setting pattern %s", u_errorName(status));
	1897	}
	1898	if (!assertEqualWithStringSearch(strsrch, &PATTERNCANONICAL[1])) {
	1899	goto ENDTESTPATTERN;
	1900	}
	1901
	1902	u_unescape(PATTERNCANONICAL[0].pattern, temp, 128);
	1903	pattern.setTo(temp, u_strlen(temp));
	1904	strsrch->setPattern(pattern, status);
	1905	if (pattern != strsrch->getPattern()) {
	1906	errln("Error setting pattern");
	1907	goto ENDTESTPATTERN;
	1908	}
	1909	strsrch->reset();
	1910	strsrch->setAttribute(USEARCH_CANONICAL_MATCH, USEARCH_ON, status);
	1911	if (U_FAILURE(status)) {
	1912	errln("Error setting pattern %s", u_errorName(status));
	1913	}
	1914	if (!assertEqualWithStringSearch(strsrch, &PATTERNCANONICAL[0])) {
	1915	goto ENDTESTPATTERN;
	1916	}
	1917	ENDTESTPATTERN:
	1918	m_en_us_->setStrength(getECollationStrength(UCOL_TERTIARY));
	1919	if (strsrch != NULL) {
	1920	delete strsrch;
	1921	}
	1922	}
	1923
	1924	void StringSearchTest::TestTextCanonical()
	1925	{
	1926	UChar temp[128];
	1927	u_unescape(TEXTCANONICAL[0].text, temp, 128);
	1928	UnicodeString text;
	1929	text.setTo(temp, u_strlen(temp));
	1930	u_unescape(TEXTCANONICAL[0].pattern, temp, 128);
	1931	UnicodeString pattern;
	1932	pattern.setTo(temp, u_strlen(temp));
	1933
	1934	UErrorCode status = U_ZERO_ERROR;
	1935	StringSearch *strsrch = new StringSearch(pattern, text, m_en_us_, NULL,
	1936	status);
	1937	strsrch->setAttribute(USEARCH_CANONICAL_MATCH, USEARCH_ON, status);
	1938
	1939	if (U_FAILURE(status)) {
	1940	errln("Error opening string search %s", u_errorName(status));
	1941	goto ENDTESTPATTERN;
	1942	}
	1943	if (text != strsrch->getText()) {
	1944	errln("Error setting text");
	1945	}
	1946	if (!assertEqualWithStringSearch(strsrch, &TEXTCANONICAL[0])) {
	1947	goto ENDTESTPATTERN;
	1948	}
	1949
	1950	u_unescape(TEXTCANONICAL[1].text, temp, 128);
	1951	text.setTo(temp, u_strlen(temp));
	1952	strsrch->setText(text, status);
	1953	if (text != strsrch->getText()) {
	1954	errln("Error setting text");
	1955	goto ENDTESTPATTERN;
	1956	}
	1957	if (U_FAILURE(status)) {
	1958	errln("Error setting text %s", u_errorName(status));
	1959	}
	1960	if (!assertEqualWithStringSearch(strsrch, &TEXTCANONICAL[1])) {
	1961	goto ENDTESTPATTERN;
	1962	}
	1963
	1964	u_unescape(TEXTCANONICAL[0].text, temp, 128);
	1965	text.setTo(temp, u_strlen(temp));
	1966	strsrch->setText(text, status);
	1967	if (text != strsrch->getText()) {
	1968	errln("Error setting text");
	1969	goto ENDTESTPATTERN;
	1970	}
	1971	if (U_FAILURE(status)) {
	1972	errln("Error setting pattern %s", u_errorName(status));
	1973	}
	1974	if (!assertEqualWithStringSearch(strsrch, &TEXTCANONICAL[0])) {
	1975	goto ENDTESTPATTERN;
	1976	}
	1977	ENDTESTPATTERN:
	1978	if (strsrch != NULL) {
	1979	delete strsrch;
	1980	}
	1981	}
	1982
	1983	void StringSearchTest::TestCompositeBoundariesCanonical()
	1984	{
	1985	int count = 0;
	1986	while (COMPOSITEBOUNDARIESCANONICAL[count].text != NULL) {
	1987	logln("composite %d", count);
	1988	if (!assertCanonicalEqual(&COMPOSITEBOUNDARIESCANONICAL[count])) {
	1989	errln("Error at test number %d", count);
	1990	}
	1991	count ++;
	1992	}
	1993	}
	1994
	1995	void StringSearchTest::TestGetSetOffsetCanonical()
	1996	{
	1997
	1998	UErrorCode status = U_ZERO_ERROR;
	1999	UnicodeString text("text");
	2000	UnicodeString pattern("pattern");
	2001	StringSearch *strsrch = new StringSearch(pattern, text, m_en_us_, NULL,
	2002	status);
	2003	Collator *collator = strsrch->getCollator();
	2004
	2005	collator->setAttribute(UCOL_NORMALIZATION_MODE, UCOL_ON, status);
	2006
	2007	strsrch->setAttribute(USEARCH_CANONICAL_MATCH, USEARCH_ON, status);
	2008	/* testing out of bounds error */
	2009	strsrch->setOffset(-1, status);
	2010	if (U_SUCCESS(status)) {
	2011	errln("Error expecting set offset error");
	2012	}
	2013	strsrch->setOffset(128, status);
	2014	if (U_SUCCESS(status)) {
	2015	errln("Error expecting set offset error");
	2016	}
	2017	int index = 0;
	2018	UChar temp[128];
	2019	while (BASICCANONICAL[index].text != NULL) {
	2020	SearchData search = BASICCANONICAL[index ++];
	2021	if (BASICCANONICAL[index].text == NULL) {
	2022	/* skip the last one */
	2023	break;
	2024	}
	2025
	2026	u_unescape(search.text, temp, 128);
	2027	text.setTo(temp, u_strlen(temp));
	2028	u_unescape(search.pattern, temp, 128);
	2029	pattern.setTo(temp, u_strlen(temp));
	2030
	2031	UErrorCode status = U_ZERO_ERROR;
	2032	strsrch->setText(text, status);
	2033
	2034	strsrch->setPattern(pattern, status);
	2035
	2036	int count = 0;
	2037	int32_t matchindex = search.offset[count];
	2038	while (U_SUCCESS(status) && matchindex >= 0) {
	2039	int32_t matchlength = search.size[count];
	2040	strsrch->next(status);
	2041	if (matchindex != strsrch->getMatchedStart() \|\|
	2042	matchlength != strsrch->getMatchedLength()) {
	2043	char *str = toCharString(strsrch->getText());
	2044	errln("Text: %s", str);
	2045	str = toCharString(strsrch->getPattern());
	2046	errln("Pattern: %s", str);
	2047	errln("Error match found at %d %d",
	2048	strsrch->getMatchedStart(),
	2049	strsrch->getMatchedLength());
	2050	goto bail;
	2051	}
	2052	matchindex = search.offset[count + 1] == -1 ? -1 :
	2053	search.offset[count + 2];
	2054	if (search.offset[count + 1] != -1) {
	2055	strsrch->setOffset(search.offset[count + 1] + 1, status);
	2056	if (strsrch->getOffset() != search.offset[count + 1] + 1) {
	2057	errln("Error setting offset");
	2058	goto bail;
	2059	}
	2060	}
	2061
	2062	count += 2;
	2063	}
	2064	strsrch->next(status);
	2065	if (strsrch->getMatchedStart() != USEARCH_DONE) {
	2066	char *str = toCharString(strsrch->getText());
	2067	errln("Text: %s", str);
	2068	str = toCharString(strsrch->getPattern());
	2069	errln("Pattern: %s", str);
	2070	errln("Error match found at %d %d", strsrch->getMatchedStart(),
	2071	strsrch->getMatchedLength());
	2072	goto bail;
	2073	}
	2074	}
	2075
	2076	bail:
	2077	collator->setAttribute(UCOL_NORMALIZATION_MODE, UCOL_OFF, status);
	2078	delete strsrch;
	2079	}
	2080
	2081	void StringSearchTest::TestSupplementaryCanonical()
	2082	{
	2083	int count = 0;
	2084	while (SUPPLEMENTARYCANONICAL[count].text != NULL) {
	2085	if (!assertCanonicalEqual(&SUPPLEMENTARYCANONICAL[count])) {
	2086	errln("Error at test number %d", count);
	2087	}
	2088	count ++;
	2089	}
	2090	}
	2091
	2092	void StringSearchTest::TestContractionCanonical()
	2093	{
	2094	UChar temp[128];
	2095
	2096	u_unescape(CONTRACTIONRULE, temp, 128);
	2097	UnicodeString rules;
	2098	rules.setTo(temp, u_strlen(temp));
	2099
	2100	UErrorCode status = U_ZERO_ERROR;
	2101	RuleBasedCollator *collator = new RuleBasedCollator(rules,
	2102	getECollationStrength(UCOL_TERTIARY), UCOL_ON, status);
	2103	if (U_FAILURE(status)) {
	2104	errln("Error opening collator %s", u_errorName(status));
	2105	}
	2106	UnicodeString text("text");
	2107	UnicodeString pattern("pattern");
	2108	StringSearch *strsrch = new StringSearch(pattern, text, collator, NULL,
	2109	status);
	2110	strsrch->setAttribute(USEARCH_CANONICAL_MATCH, USEARCH_ON, status);
	2111	if (U_FAILURE(status)) {
	2112	errln("Error opening string search %s", u_errorName(status));
	2113	}
	2114
	2115	int count = 0;
	2116	while (CONTRACTIONCANONICAL[count].text != NULL) {
	2117	u_unescape(CONTRACTIONCANONICAL[count].text, temp, 128);
	2118	text.setTo(temp, u_strlen(temp));
	2119	u_unescape(CONTRACTIONCANONICAL[count].pattern, temp, 128);
	2120	pattern.setTo(temp, u_strlen(temp));
	2121	strsrch->setText(text, status);
	2122	strsrch->setPattern(pattern, status);
	2123	if (!assertEqualWithStringSearch(strsrch,
	2124	&CONTRACTIONCANONICAL[count])) {
	2125	errln("Error at test number %d", count);
	2126	}
	2127	count ++;
	2128	}
	2129	delete strsrch;
	2130	delete collator;
	2131	}
	2132
	2133	void StringSearchTest::TestUClassID()
	2134	{
	2135	char id = ((char )StringSearch::getStaticClassID());
	2136	if (id != 0) {
	2137	errln("Static class id for StringSearch should be 0");
	2138	}
	2139	UErrorCode status = U_ZERO_ERROR;
	2140	UnicodeString text("text");
	2141	UnicodeString pattern("pattern");
	2142	StringSearch *strsrch = new StringSearch(pattern, text, m_en_us_, NULL,
	2143	status);
	2144	id = ((char )strsrch->getDynamicClassID());
	2145	if (id != 0) {
	2146	errln("Dynamic class id for StringSearch should be 0");
	2147	}
	2148	delete strsrch;
	2149	}
	2150
	2151	class TestSearch : public SearchIterator
	2152	{
	2153	public:
	2154	TestSearch(const TestSearch &obj);
	2155	TestSearch(const UnicodeString &text,
	2156	BreakIterator *breakiter,
	2157	const UnicodeString &pattern);
	2158	~TestSearch();
	2159
	2160	void setOffset(int32_t position, UErrorCode &status);
	2161	int32_t getOffset() const;
	2162	SearchIterator* safeClone() const;
	2163
	2164
	2165	/**
	2166	* ICU "poor man's RTTI", returns a UClassID for the actual class.
	2167	*
	2168	* @draft ICU 2.2
	2169	*/
	2170	virtual inline UClassID getDynamicClassID() const { return getStaticClassID(); }
	2171
	2172	/**
	2173	* ICU "poor man's RTTI", returns a UClassID for this class.
	2174	*
	2175	* @draft ICU 2.2
	2176	*/
	2177	static inline UClassID getStaticClassID() { return (UClassID)&fgClassID; }
	2178
	2179	UBool operator!=(const TestSearch &that) const;
	2180
	2181	UnicodeString m_pattern_;
	2182
	2183	protected:
	2184	int32_t handleNext(int32_t position, UErrorCode &status);
	2185	int32_t handlePrev(int32_t position, UErrorCode &status);
	2186	TestSearch & operator=(const TestSearch &that);
	2187
	2188	private:
	2189
	2190	/**
	2191	* The address of this static class variable serves as this class's ID
	2192	* for ICU "poor man's RTTI".
	2193	*/
	2194	static const char fgClassID;
	2195	uint32_t m_offset_;
	2196	};
	2197
	2198	const char TestSearch::fgClassID=0;
	2199
	2200	TestSearch::TestSearch(const TestSearch &obj) : SearchIterator(obj)
	2201	{
	2202	m_offset_ = obj.m_offset_;
	2203	m_pattern_ = obj.m_pattern_;
	2204	}
	2205
	2206	TestSearch::TestSearch(const UnicodeString &text,
	2207	BreakIterator *breakiter,
	2208	const UnicodeString &pattern) : SearchIterator()
	2209	{
	2210	m_breakiterator_ = breakiter;
	2211	m_pattern_ = pattern;
	2212	m_text_ = text;
	2213	m_offset_ = 0;
	2214	m_pattern_ = pattern;
	2215	}
	2216
	2217	TestSearch::~TestSearch()
	2218	{
	2219	}
	2220
	2221
	2222	void TestSearch::setOffset(int32_t position, UErrorCode &status)
	2223	{
	2224	if (position >= 0 && position <= m_text_.length()) {
	2225	m_offset_ = position;
	2226	}
	2227	else {
	2228	status = U_INDEX_OUTOFBOUNDS_ERROR;
	2229	}
	2230	}
	2231
	2232	int32_t TestSearch::getOffset() const
	2233	{
	2234	return m_offset_;
	2235	}
	2236
	2237	SearchIterator * TestSearch::safeClone() const
	2238	{
	2239	return new TestSearch(m_text_, m_breakiterator_, m_pattern_);
	2240	}
	2241
	2242	UBool TestSearch::operator!=(const TestSearch &that) const
	2243	{
	2244	if (SearchIterator::operator !=(that)) {
	2245	return FALSE;
	2246	}
	2247	return m_offset_ != that.m_offset_ \|\| m_pattern_ != that.m_pattern_;
	2248	}
	2249
	2250	int32_t TestSearch::handleNext(int32_t start, UErrorCode &status)
	2251	{
	2252	if(U_SUCCESS(status)) {
	2253	int match = m_text_.indexOf(m_pattern_, start);
	2254	if (match < 0) {
	2255	m_offset_ = m_text_.length();
	2256	setMatchStart(m_offset_);
	2257	setMatchLength(0);
	2258	return USEARCH_DONE;
	2259	}
	2260	setMatchStart(match);
	2261	m_offset_ = match;
	2262	setMatchLength(m_pattern_.length());
	2263	return match;
	2264	} else {
	2265	return USEARCH_DONE;
	2266	}
	2267	}
	2268
	2269	int32_t TestSearch::handlePrev(int32_t start, UErrorCode &status)
	2270	{
	2271	if(U_SUCCESS(status)) {
	2272	int match = m_text_.lastIndexOf(m_pattern_, 0, start);
	2273	if (match < 0) {
	2274	m_offset_ = 0;
	2275	setMatchStart(m_offset_);
	2276	setMatchLength(0);
	2277	return USEARCH_DONE;
	2278	}
	2279	setMatchStart(match);
	2280	m_offset_ = match;
	2281	setMatchLength(m_pattern_.length());
	2282	return match;
	2283	} else {
	2284	return USEARCH_DONE;
	2285	}
	2286	}
	2287
	2288	TestSearch & TestSearch::operator=(const TestSearch &that)
	2289	{
	2290	SearchIterator::operator=(that);
	2291	m_offset_ = that.m_offset_;
	2292	m_pattern_ = that.m_pattern_;
	2293	return *this;
	2294	}
	2295
	2296	void StringSearchTest::TestSubclass()
	2297	{
	2298	UnicodeString text("abc abcd abc");
	2299	UnicodeString pattern("abc");
	2300	TestSearch search(text, NULL, pattern);
	2301	TestSearch search2(search);
	2302	int expected[] = {0, 4, 9};
	2303	UErrorCode status = U_ZERO_ERROR;
	2304	int i;
	2305	StringCharacterIterator chariter(text);
	2306
	2307	search.setText(text, status);
	2308	if (search.getText() != search2.getText()) {
	2309	errln("Error setting text");
	2310	}
	2311
	2312	search.setText(chariter, status);
	2313	if (search.getText() != search2.getText()) {
	2314	errln("Error setting text");
	2315	}
	2316
	2317	search.reset();
	2318	// comparing constructors
	2319
	2320	for (i = 0; i < (int)(sizeof(expected) / sizeof(expected[0])); i ++) {
	2321	if (search.next(status) != expected[i]) {
	2322	errln("Error getting next match");
	2323	}
	2324	if (search.getMatchedLength() != search.m_pattern_.length()) {
	2325	errln("Error getting next match length");
	2326	}
	2327	}
	2328	if (search.next(status) != USEARCH_DONE) {
	2329	errln("Error should have reached the end of the iteration");
	2330	}
	2331	for (i = sizeof(expected) / sizeof(expected[0]) - 1; i >= 0; i --) {
	2332	if (search.previous(status) != expected[i]) {
	2333	errln("Error getting previous match");
	2334	}
	2335	if (search.getMatchedLength() != search.m_pattern_.length()) {
	2336	errln("Error getting previous match length");
	2337	}
	2338	}
	2339	if (search.previous(status) != USEARCH_DONE) {
	2340	errln("Error should have reached the start of the iteration");
	2341	}
	2342	}
	2343
	2344	class StubSearchIterator:public SearchIterator{
	2345	public:
	2346	StubSearchIterator(){}
	2347	virtual void setOffset(int32_t , UErrorCode &) {};
	2348	virtual int32_t getOffset(void) const {return 0;};
	2349	virtual SearchIterator* safeClone(void) const {return NULL;};
	2350	virtual int32_t handleNext(int32_t , UErrorCode &){return 0;};
	2351	virtual int32_t handlePrev(int32_t , UErrorCode &) {return 0;};
	2352	virtual UClassID getDynamicClassID() const {
	2353	static char classID = 0;
	2354	return (UClassID)&classID;
	2355	}
	2356	};
	2357
	2358	void StringSearchTest::TestCoverage(){
	2359	StubSearchIterator stub1, stub2;
	2360	UErrorCode status = U_ZERO_ERROR;
	2361
	2362	if (stub1 != stub2){
	2363	errln("new StubSearchIterator should be equal");
	2364	}
	2365
	2366	stub2.setText(UnicodeString("ABC"), status);
	2367	if (U_FAILURE(status)) {
	2368	errln("Error: SearchIterator::SetText");
	2369	}
	2370
	2371	stub1 = stub2;
	2372	if (stub1 != stub2){
	2373	errln("SearchIterator::operator = assigned object should be equal");
	2374	}
	2375	}
	2376
	2377	#endif /* !UCONFIG_NO_BREAK_ITERATION */
	2378
	2379	#endif /* #if !UCONFIG_NO_COLLATION */