1 // © 2016 and later: Unicode, Inc. and others.
2 // License & terms of use: http://www.unicode.org/copyright.html
4 **********************************************************************
5 * Copyright (C) 2005-2016, International Business Machines
6 * Corporation and others. All Rights Reserved.
7 **********************************************************************
10 #include "unicode/utypes.h"
12 #if !UCONFIG_NO_COLLATION
18 #include "unicode/coll.h"
19 #include "unicode/tblcoll.h"
20 #include "unicode/usearch.h"
21 #include "unicode/uset.h"
22 #include "unicode/ustring.h"
24 #include "unicode/coleitr.h"
25 #include "unicode/regex.h" // TODO: make conditional on regexp being built.
29 #include "xmlparser.h"
31 #include <stdio.h> // for sprintf
35 #define TEST_ASSERT(x) UPRV_BLOCK_MACRO_BEGIN { \
37 errln("Failure in file %s, line %d, test ID = \"%s\"", __FILE__, __LINE__, testId); \
39 } UPRV_BLOCK_MACRO_END
41 #define TEST_ASSERT_M(x, m) UPRV_BLOCK_MACRO_BEGIN { \
43 dataerrln("Failure in file %s, line %d. \"%s\"", __FILE__, __LINE__, m); \
46 } UPRV_BLOCK_MACRO_END
48 #define TEST_ASSERT_SUCCESS(errcode) UPRV_BLOCK_MACRO_BEGIN { \
49 if (U_FAILURE(errcode)) { \
50 dataerrln("Failure in file %s, line %d, test ID \"%s\", status = \"%s\"", \
51 __FILE__, __LINE__, testId, u_errorName(errcode)); \
53 } UPRV_BLOCK_MACRO_END
55 #define NEW_ARRAY(type, count) (type *) uprv_malloc((count) * sizeof(type))
56 #define DELETE_ARRAY(array) uprv_free((void *) (array))
58 //---------------------------------------------------------------------------
60 // Test class boilerplate
62 //---------------------------------------------------------------------------
63 SSearchTest::SSearchTest()
67 SSearchTest::~SSearchTest()
71 void SSearchTest::runIndexedTest( int32_t index
, UBool exec
, const char* &name
, char *params
)
73 if (exec
) logln("TestSuite SSearchTest: ");
75 #if !UCONFIG_NO_BREAK_ITERATION
76 case 0: name
= "searchTest";
77 if (exec
) searchTest();
80 case 1: name
= "offsetTest";
81 if (exec
) offsetTest();
84 case 2: name
= "monkeyTest";
85 if (exec
) monkeyTest(params
);
88 case 3: name
= "sharpSTest";
89 if (exec
) sharpSTest();
92 case 4: name
= "goodSuffixTest";
93 if (exec
) goodSuffixTest();
96 case 5: name
= "searchTime";
97 if (exec
) searchTime();
101 break; //needed to end loop
106 #if !UCONFIG_NO_BREAK_ITERATION
108 #define PATH_BUFFER_SIZE 2048
109 const char *SSearchTest::getPath(char buffer
[2048], const char *filename
) {
110 UErrorCode status
= U_ZERO_ERROR
;
111 const char *testDataDirectory
= IntlTest::getSourceTestData(status
);
113 if (U_FAILURE(status
) || strlen(testDataDirectory
) + strlen(filename
) + 1 >= PATH_BUFFER_SIZE
) {
114 errln("ERROR: getPath() failed - %s", u_errorName(status
));
118 strcpy(buffer
, testDataDirectory
);
119 strcat(buffer
, filename
);
124 void SSearchTest::searchTest()
126 #if !UCONFIG_NO_REGULAR_EXPRESSIONS && !UCONFIG_NO_FILE_IO
127 UErrorCode status
= U_ZERO_ERROR
;
128 char path
[PATH_BUFFER_SIZE
];
129 const char *testFilePath
= getPath(path
, "ssearch.xml");
131 if (testFilePath
== NULL
) {
132 return; /* Couldn't get path: error message already output. */
135 LocalPointer
<UXMLParser
> parser(UXMLParser::createParser(status
));
136 TEST_ASSERT_SUCCESS(status
);
137 LocalPointer
<UXMLElement
> root(parser
->parseFile(testFilePath
, status
));
138 TEST_ASSERT_SUCCESS(status
);
139 if (U_FAILURE(status
)) {
143 const UnicodeString
*debugTestCase
= root
->getAttribute("debug");
144 if (debugTestCase
!= NULL
) {
145 // setenv("USEARCH_DEBUG", "1", 1);
149 const UXMLElement
*testCase
;
152 while((testCase
= root
->nextChildElement(tc
)) != NULL
) {
154 if (testCase
->getTagName().compare("test-case") != 0) {
155 errln("ssearch, unrecognized XML Element in test file");
158 const UnicodeString
*id
= testCase
->getAttribute("id");
161 id
->extract(0, id
->length(), testId
, sizeof(testId
), US_INV
);
164 // If debugging test case has been specified and this is not it, skip to next.
165 if (id
!=NULL
&& debugTestCase
!=NULL
&& *id
!= *debugTestCase
) {
169 // Get the requested collation strength.
170 // Default is tertiary if the XML attribute is missing from the test case.
172 const UnicodeString
*strength
= testCase
->getAttribute("strength");
173 UColAttributeValue collatorStrength
= UCOL_PRIMARY
;
174 if (strength
==NULL
) { collatorStrength
= UCOL_TERTIARY
;}
175 else if (*strength
=="PRIMARY") { collatorStrength
= UCOL_PRIMARY
;}
176 else if (*strength
=="SECONDARY") { collatorStrength
= UCOL_SECONDARY
;}
177 else if (*strength
=="TERTIARY") { collatorStrength
= UCOL_TERTIARY
;}
178 else if (*strength
=="QUATERNARY") { collatorStrength
= UCOL_QUATERNARY
;}
179 else if (*strength
=="IDENTICAL") { collatorStrength
= UCOL_IDENTICAL
;}
181 // Bogus value supplied for strength. Shouldn't happen, even from
182 // typos, if the XML source has been validated.
183 // This assert is a little deceiving in that strength can be
184 // any of the allowed values, not just TERTIARY, but it will
185 // do the job of getting the error output.
186 TEST_ASSERT(*strength
=="TERTIARY");
190 // Get the collator normalization flag. Default is UCOL_OFF.
192 UColAttributeValue normalize
= UCOL_OFF
;
193 const UnicodeString
*norm
= testCase
->getAttribute("norm");
194 TEST_ASSERT (norm
==NULL
|| *norm
=="ON" || *norm
=="OFF");
195 if (norm
!=NULL
&& *norm
=="ON") {
200 // Get the alternate_handling flag. Default is UCOL_NON_IGNORABLE.
202 UColAttributeValue alternateHandling
= UCOL_NON_IGNORABLE
;
203 const UnicodeString
*alt
= testCase
->getAttribute("alternate_handling");
204 TEST_ASSERT (alt
== NULL
|| *alt
== "SHIFTED" || *alt
== "NON_IGNORABLE");
205 if (alt
!= NULL
&& *alt
== "SHIFTED") {
206 alternateHandling
= UCOL_SHIFTED
;
209 const UnicodeString
defLocale("en");
211 const UnicodeString
*locale
= testCase
->getAttribute("locale");
212 if (locale
== NULL
|| locale
->length()==0) {
215 locale
->extract(0, locale
->length(), clocale
, sizeof(clocale
), NULL
);
219 UnicodeString target
;
220 UnicodeString pattern
;
221 int32_t expectedMatchStart
= -1;
222 int32_t expectedMatchLimit
= -1;
223 const UXMLElement
*n
;
224 int32_t nodeCount
= 0;
226 n
= testCase
->getChildElement("pattern");
227 TEST_ASSERT(n
!= NULL
);
231 text
= n
->getText(FALSE
);
232 text
= text
.unescape();
233 pattern
.append(text
);
236 n
= testCase
->getChildElement("pre");
238 text
= n
->getText(FALSE
);
239 text
= text
.unescape();
244 n
= testCase
->getChildElement("m");
246 expectedMatchStart
= target
.length();
247 text
= n
->getText(FALSE
);
248 text
= text
.unescape();
250 expectedMatchLimit
= target
.length();
254 n
= testCase
->getChildElement("post");
256 text
= n
->getText(FALSE
);
257 text
= text
.unescape();
262 // Check that there weren't extra things in the XML
263 TEST_ASSERT(nodeCount
== testCase
->countChildren());
265 // Open a collator and StringSearch based on the parameters
266 // obtained from the XML.
268 status
= U_ZERO_ERROR
;
269 LocalUCollatorPointer
collator(ucol_open(clocale
, &status
));
270 ucol_setStrength(collator
.getAlias(), collatorStrength
);
271 ucol_setAttribute(collator
.getAlias(), UCOL_NORMALIZATION_MODE
, normalize
, &status
);
272 ucol_setAttribute(collator
.getAlias(), UCOL_ALTERNATE_HANDLING
, alternateHandling
, &status
);
273 LocalUStringSearchPointer
uss(usearch_openFromCollator(pattern
.getBuffer(), pattern
.length(),
274 target
.getBuffer(), target
.length(),
276 NULL
, // the break iterator
279 TEST_ASSERT_SUCCESS(status
);
280 if (U_FAILURE(status
)) {
284 int32_t foundStart
= 0;
285 int32_t foundLimit
= 0;
289 // Do the search, check the match result against the expected results.
291 foundMatch
= usearch_search(uss
.getAlias(), 0, &foundStart
, &foundLimit
, &status
);
292 TEST_ASSERT_SUCCESS(status
);
293 if ((foundMatch
&& expectedMatchStart
<0) ||
294 (foundStart
!= expectedMatchStart
) ||
295 (foundLimit
!= expectedMatchLimit
)) {
296 TEST_ASSERT(FALSE
); // ouput generic error position
297 infoln("Found, expected match start = %d, %d \n"
298 "Found, expected match limit = %d, %d",
299 foundStart
, expectedMatchStart
, foundLimit
, expectedMatchLimit
);
302 // In case there are other matches...
303 // (should we only do this if the test case passed?)
305 expectedMatchStart
= foundStart
;
306 expectedMatchLimit
= foundLimit
;
308 foundMatch
= usearch_search(uss
.getAlias(), foundLimit
, &foundStart
, &foundLimit
, &status
);
311 uss
.adoptInstead(usearch_openFromCollator(pattern
.getBuffer(), pattern
.length(),
312 target
.getBuffer(), target
.length(),
318 // Do the backwards search, check the match result against the expected results.
320 foundMatch
= usearch_searchBackwards(uss
.getAlias(), target
.length(), &foundStart
, &foundLimit
, &status
);
321 TEST_ASSERT_SUCCESS(status
);
322 if ((foundMatch
&& expectedMatchStart
<0) ||
323 (foundStart
!= expectedMatchStart
) ||
324 (foundLimit
!= expectedMatchLimit
)) {
325 TEST_ASSERT(FALSE
); // ouput generic error position
326 infoln("Found, expected backwards match start = %d, %d \n"
327 "Found, expected backwards match limit = %d, %d",
328 foundStart
, expectedMatchStart
, foundLimit
, expectedMatchLimit
);
345 OrderList(UCollator
*coll
, const UnicodeString
&string
, int32_t stringOffset
= 0);
348 int32_t size(void) const;
349 void add(int32_t order
, int32_t low
, int32_t high
);
350 const Order
*get(int32_t index
) const;
351 int32_t getLowOffset(int32_t index
) const;
352 int32_t getHighOffset(int32_t index
) const;
353 int32_t getOrder(int32_t index
) const;
355 UBool
compare(const OrderList
&other
) const;
356 UBool
matchesAt(int32_t offset
, const OrderList
&other
) const;
364 OrderList::OrderList()
365 : list(NULL
), listMax(16), listSize(0)
367 list
= new Order
[listMax
];
370 OrderList::OrderList(UCollator
*coll
, const UnicodeString
&string
, int32_t stringOffset
)
371 : list(NULL
), listMax(16), listSize(0)
373 UErrorCode status
= U_ZERO_ERROR
;
374 UCollationElements
*elems
= ucol_openElements(coll
, string
.getBuffer(), string
.length(), &status
);
375 uint32_t strengthMask
= 0;
376 int32_t order
, low
, high
;
378 switch (ucol_getStrength(coll
))
381 strengthMask
|= UCOL_TERTIARYORDERMASK
;
384 strengthMask
|= UCOL_SECONDARYORDERMASK
;
387 strengthMask
|= UCOL_PRIMARYORDERMASK
;
390 list
= new Order
[listMax
];
392 ucol_setOffset(elems
, stringOffset
, &status
);
395 low
= ucol_getOffset(elems
);
396 order
= ucol_next(elems
, &status
);
397 high
= ucol_getOffset(elems
);
399 if (order
!= UCOL_NULLORDER
) {
400 order
&= strengthMask
;
403 if (order
!= UCOL_IGNORABLE
) {
404 add(order
, low
, high
);
406 } while (order
!= UCOL_NULLORDER
);
408 ucol_closeElements(elems
);
411 OrderList::~OrderList()
416 void OrderList::add(int32_t order
, int32_t low
, int32_t high
)
418 if (listSize
>= listMax
) {
421 Order
*newList
= new Order
[listMax
];
423 uprv_memcpy(newList
, list
, listSize
* sizeof(Order
));
428 list
[listSize
].order
= order
;
429 list
[listSize
].lowOffset
= low
;
430 list
[listSize
].highOffset
= high
;
435 const Order
*OrderList::get(int32_t index
) const
437 if (index
>= listSize
) {
444 int32_t OrderList::getLowOffset(int32_t index
) const
446 const Order
*order
= get(index
);
449 return order
->lowOffset
;
455 int32_t OrderList::getHighOffset(int32_t index
) const
457 const Order
*order
= get(index
);
460 return order
->highOffset
;
466 int32_t OrderList::getOrder(int32_t index
) const
468 const Order
*order
= get(index
);
474 return UCOL_NULLORDER
;
477 int32_t OrderList::size() const
482 void OrderList::reverse()
484 for(int32_t f
= 0, b
= listSize
- 1; f
< b
; f
+= 1, b
-= 1) {
485 Order swap
= list
[b
];
492 UBool
OrderList::compare(const OrderList
&other
) const
494 if (listSize
!= other
.listSize
) {
498 for(int32_t i
= 0; i
< listSize
; i
+= 1) {
499 if (list
[i
].order
!= other
.list
[i
].order
||
500 list
[i
].lowOffset
!= other
.list
[i
].lowOffset
||
501 list
[i
].highOffset
!= other
.list
[i
].highOffset
) {
509 UBool
OrderList::matchesAt(int32_t offset
, const OrderList
&other
) const
511 // NOTE: sizes include the NULLORDER, which we don't want to compare.
512 int32_t otherSize
= other
.size() - 1;
514 if (listSize
- 1 - offset
< otherSize
) {
518 for (int32_t i
= offset
, j
= 0; j
< otherSize
; i
+= 1, j
+= 1) {
519 if (getOrder(i
) != other
.getOrder(j
)) {
527 static char *printOffsets(char *buffer
, OrderList
&list
)
529 int32_t size
= list
.size();
532 for(int32_t i
= 0; i
< size
; i
+= 1) {
533 const Order
*order
= list
.get(i
);
536 s
+= sprintf(s
, ", ");
539 s
+= sprintf(s
, "(%d, %d)", order
->lowOffset
, order
->highOffset
);
545 static char *printOrders(char *buffer
, OrderList
&list
)
547 int32_t size
= list
.size();
550 for(int32_t i
= 0; i
< size
; i
+= 1) {
551 const Order
*order
= list
.get(i
);
554 s
+= sprintf(s
, ", ");
557 s
+= sprintf(s
, "%8.8X", order
->order
);
563 void SSearchTest::offsetTest()
565 const char *test
[] = {
566 // The sequence \u0FB3\u0F71\u0F71\u0F80 contains a discontiguous
567 // contraction (\u0FB3\u0F71\u0F80) logically followed by \u0F71.
568 "\\u1E33\\u0FB3\\u0F71\\u0F71\\u0F80\\uD835\\uDF6C\\u01B0",
570 "\\ua191\\u16ef\\u2036\\u017a",
573 // This results in a complex interaction between contraction,
574 // expansion and normalization that confuses the backwards offset fixups.
575 "\\u0F7F\\u0F80\\u0F81\\u0F82\\u0F83\\u0F84\\u0F85",
578 "\\u0F80\\u0F81\\u0F82\\u0F83\\u0F84\\u0F85",
579 "\\u07E9\\u07EA\\u07F1\\u07F2\\u07F3",
582 "\\u0300\\u0301\\u0302\\u0303\\u0304\\u0305\\u0306\\u0307\\u0308\\u0309\\u030A\\u030B\\u030C\\u030D\\u030E\\u030F"
583 "\\u0310\\u0311\\u0312\\u0313\\u0314\\u0315\\u0316\\u0317\\u0318\\u0319\\u031A\\u031B\\u031C\\u031D\\u031E\\u031F"
584 "\\u0320\\u0321\\u0322\\u0323\\u0324\\u0325\\u0326\\u0327\\u0328\\u0329\\u032A\\u032B\\u032C\\u032D\\u032E\\u032F"
585 "\\u0330\\u0331\\u0332\\u0333\\u0334\\u0335\\u0336\\u0337\\u0338\\u0339\\u033A\\u033B\\u033C\\u033D\\u033E\\u033F"
586 "\\u0340\\u0341\\u0342\\u0343\\u0344\\u0345\\u0346\\u0347\\u0348\\u0349\\u034A\\u034B\\u034C\\u034D\\u034E", // currently not working, see #8081
588 "\\u02FE\\u02FF\\u0300\\u0301\\u0302\\u0303\\u0316\\u0317\\u0318", // currently not working, see #8081
589 "a\\u02FF\\u0301\\u0316", // currently not working, see #8081
590 "a\\u02FF\\u0316\\u0301",
591 "a\\u0430\\u0301\\u0316",
592 "a\\u0430\\u0316\\u0301",
593 "abc\\u0E41\\u0301\\u0316",
594 "abc\\u0E41\\u0316\\u0301",
595 "\\u0E41\\u0301\\u0316",
596 "\\u0E41\\u0316\\u0301",
610 "A\\u0302\\u0301\\u0323B",
614 " \\uD800\\uDC00\\uDC00",
615 "a\\uD800\\uDC00\\uDC00",
621 "\\u0301A\\u0301\\u0301",
627 int32_t testCount
= UPRV_LENGTHOF(test
);
628 UErrorCode status
= U_ZERO_ERROR
;
629 RuleBasedCollator
*col
= (RuleBasedCollator
*) Collator::createInstance(Locale::getEnglish(), status
);
630 if (U_FAILURE(status
)) {
631 errcheckln(status
, "Failed to create collator in offsetTest! - %s", u_errorName(status
));
634 char buffer
[4096]; // A bit of a hack... just happens to be long enough for all the test cases...
635 // We could allocate one that's the right size by (CE_count * 10) + 2
636 // 10 chars is enough room for 8 hex digits plus ", ". 2 extra chars for "[" and "]"
638 col
->setAttribute(UCOL_NORMALIZATION_MODE
, UCOL_ON
, status
);
640 for(int32_t i
= 0; i
< testCount
; i
+= 1) {
641 UnicodeString ts
= CharsToUnicodeString(test
[i
]);
642 CollationElementIterator
*iter
= col
->createCollationElementIterator(ts
);
643 OrderList forwardList
;
644 OrderList backwardList
;
645 int32_t order
, low
, high
;
648 low
= iter
->getOffset();
649 order
= iter
->next(status
);
650 high
= iter
->getOffset();
652 forwardList
.add(order
, low
, high
);
653 } while (order
!= CollationElementIterator::NULLORDER
);
656 iter
->setOffset(ts
.length(), status
);
658 backwardList
.add(CollationElementIterator::NULLORDER
, iter
->getOffset(), iter
->getOffset());
661 high
= iter
->getOffset();
662 order
= iter
->previous(status
);
663 low
= iter
->getOffset();
665 if (order
== CollationElementIterator::NULLORDER
) {
669 backwardList
.add(order
, low
, high
);
672 backwardList
.reverse();
674 if (forwardList
.compare(backwardList
)) {
675 logln("Works with \"%s\"", test
[i
]);
676 logln("Forward offsets: [%s]", printOffsets(buffer
, forwardList
));
677 // logln("Backward offsets: [%s]", printOffsets(buffer, backwardList));
679 logln("Forward CEs: [%s]", printOrders(buffer
, forwardList
));
680 // logln("Backward CEs: [%s]", printOrders(buffer, backwardList));
684 errln("Fails with \"%s\"", test
[i
]);
685 infoln("Forward offsets: [%s]", printOffsets(buffer
, forwardList
));
686 infoln("Backward offsets: [%s]", printOffsets(buffer
, backwardList
));
688 infoln("Forward CEs: [%s]", printOrders(buffer
, forwardList
));
689 infoln("Backward CEs: [%s]", printOrders(buffer
, backwardList
));
699 static UnicodeString
&escape(const UnicodeString
&string
, UnicodeString
&buffer
)
701 for(int32_t i
= 0; i
< string
.length(); i
+= 1) {
702 UChar32 ch
= string
.char32At(i
);
704 if (ch
>= 0x0020 && ch
<= 0x007F) {
706 buffer
.append("\\\\");
714 sprintf(cbuffer
, "\\u%4.4X", ch
);
716 sprintf(cbuffer
, "\\U%8.8X", ch
);
719 buffer
.append(cbuffer
);
722 if (ch
>= 0x10000L
) {
731 void SSearchTest::sharpSTest()
733 UErrorCode status
= U_ZERO_ERROR
;
734 UCollator
*coll
= NULL
;
735 UnicodeString lp
= "fuss";
736 UnicodeString sp
= "fu\\u00DF";
737 UnicodeString targets
[] = {"fu\\u00DF", "fu\\u00DFball", "1fu\\u00DFball", "12fu\\u00DFball", "123fu\\u00DFball", "1234fu\\u00DFball",
738 "ffu\\u00DF", "fufu\\u00DF", "fusfu\\u00DF",
739 "fuss", "ffuss", "fufuss", "fusfuss", "1fuss", "12fuss", "123fuss", "1234fuss", "fu\\u00DF", "1fu\\u00DF", "12fu\\u00DF", "123fu\\u00DF", "1234fu\\u00DF"};
740 int32_t start
= -1, end
= -1;
742 coll
= ucol_openFromShortString("LEN_S1", FALSE
, NULL
, &status
);
743 TEST_ASSERT_SUCCESS(status
);
745 UnicodeString lpUnescaped
= lp
.unescape();
746 UnicodeString spUnescaped
= sp
.unescape();
748 LocalUStringSearchPointer
ussLong(usearch_openFromCollator(lpUnescaped
.getBuffer(), lpUnescaped
.length(),
749 lpUnescaped
.getBuffer(), lpUnescaped
.length(), // actual test data will be set later
751 NULL
, // the break iterator
754 LocalUStringSearchPointer
ussShort(usearch_openFromCollator(spUnescaped
.getBuffer(), spUnescaped
.length(),
755 spUnescaped
.getBuffer(), spUnescaped
.length(), // actual test data will be set later
757 NULL
, // the break iterator
759 TEST_ASSERT_SUCCESS(status
);
761 for (uint32_t t
= 0; t
< UPRV_LENGTHOF(targets
); t
+= 1) {
763 UnicodeString target
= targets
[t
].unescape();
766 usearch_setText(ussLong
.getAlias(), target
.getBuffer(), target
.length(), &status
);
767 bFound
= usearch_search(ussLong
.getAlias(), 0, &start
, &end
, &status
);
768 TEST_ASSERT_SUCCESS(status
);
770 logln("Test %d: found long pattern at [%d, %d].", t
, start
, end
);
772 dataerrln("Test %d: did not find long pattern.", t
);
775 usearch_setText(ussShort
.getAlias(), target
.getBuffer(), target
.length(), &status
);
776 bFound
= usearch_search(ussShort
.getAlias(), 0, &start
, &end
, &status
);
777 TEST_ASSERT_SUCCESS(status
);
779 logln("Test %d: found long pattern at [%d, %d].", t
, start
, end
);
781 dataerrln("Test %d: did not find long pattern.", t
);
788 void SSearchTest::goodSuffixTest()
790 UErrorCode status
= U_ZERO_ERROR
;
791 UCollator
*coll
= NULL
;
792 UnicodeString pat
= /*"gcagagag"*/ "fxeld";
793 UnicodeString target
= /*"gcatcgcagagagtatacagtacg"*/ "cloveldfxeld";
794 int32_t start
= -1, end
= -1;
797 coll
= ucol_open(NULL
, &status
);
798 TEST_ASSERT_SUCCESS(status
);
800 LocalUStringSearchPointer
ss(usearch_openFromCollator(pat
.getBuffer(), pat
.length(),
801 target
.getBuffer(), target
.length(),
803 NULL
, // the break iterator
805 TEST_ASSERT_SUCCESS(status
);
807 bFound
= usearch_search(ss
.getAlias(), 0, &start
, &end
, &status
);
808 TEST_ASSERT_SUCCESS(status
);
810 logln("Found pattern at [%d, %d].", start
, end
);
812 dataerrln("Did not find pattern.");
819 // searchTime() A quick and dirty performance test for string search.
820 // Probably doesn't really belong as part of intltest, but it
821 // does check that the search succeeds, and gets the right result,
822 // so it serves as a functionality test also.
824 // To run as a perf test, up the loop count, select by commenting
825 // and uncommenting in the code the operation to be measured,
826 // rebuild, and measure the running time of this test alone.
828 // time LD_LIBRARY_PATH=whatever ./intltest collate/SSearchTest/searchTime
830 void SSearchTest::searchTime() {
831 static const char *longishText
=
832 "Whylom, as olde stories tellen us,\n"
833 "Ther was a duk that highte Theseus:\n"
834 "Of Athenes he was lord and governour,\n"
835 "And in his tyme swich a conquerour,\n"
836 "That gretter was ther noon under the sonne.\n"
837 "Ful many a riche contree hadde he wonne;\n"
838 "What with his wisdom and his chivalrye,\n"
839 "He conquered al the regne of Femenye,\n"
840 "That whylom was y-cleped Scithia;\n"
841 "And weddede the quene Ipolita,\n"
842 "And broghte hir hoom with him in his contree\n"
843 "With muchel glorie and greet solempnitee,\n"
844 "And eek hir yonge suster Emelye.\n"
845 "And thus with victorie and with melodye\n"
846 "Lete I this noble duk to Athenes ryde,\n"
847 "And al his hoost, in armes, him bisyde.\n"
848 "And certes, if it nere to long to here,\n"
849 "I wolde han told yow fully the manere,\n"
850 "How wonnen was the regne of Femenye\n"
851 "By Theseus, and by his chivalrye;\n"
852 "And of the grete bataille for the nones\n"
853 "Bitwixen Athen's and Amazones;\n"
854 "And how asseged was Ipolita,\n"
855 "The faire hardy quene of Scithia;\n"
856 "And of the feste that was at hir weddinge,\n"
857 "And of the tempest at hir hoom-cominge;\n"
858 "But al that thing I moot as now forbere.\n"
859 "I have, God woot, a large feeld to ere,\n"
860 "And wayke been the oxen in my plough.\n"
861 "The remenant of the tale is long y-nough.\n"
862 "I wol nat letten eek noon of this route;\n"
863 "Lat every felawe telle his tale aboute,\n"
864 "And lat see now who shal the soper winne;\n"
865 "And ther I lefte, I wol ageyn biginne.\n"
866 "This duk, of whom I make mencioun,\n"
867 "When he was come almost unto the toun,\n"
868 "In al his wele and in his moste pryde,\n"
869 "He was war, as he caste his eye asyde,\n"
870 "Wher that ther kneled in the hye weye\n"
871 "A companye of ladies, tweye and tweye,\n"
872 "Ech after other, clad in clothes blake; \n"
873 "But swich a cry and swich a wo they make,\n"
874 "That in this world nis creature livinge,\n"
875 "That herde swich another weymentinge;\n"
876 "And of this cry they nolde never stenten,\n"
877 "Til they the reynes of his brydel henten.\n"
878 "'What folk ben ye, that at myn hoomcominge\n"
879 "Perturben so my feste with cryinge'?\n"
880 "Quod Theseus, 'have ye so greet envye\n"
881 "Of myn honour, that thus compleyne and crye? \n"
882 "Or who hath yow misboden, or offended?\n"
883 "And telleth me if it may been amended;\n"
884 "And why that ye ben clothed thus in blak'?\n"
885 "The eldest lady of hem alle spak,\n"
886 "When she hadde swowned with a deedly chere,\n"
887 "That it was routhe for to seen and here,\n"
888 "And seyde: 'Lord, to whom Fortune hath yiven\n"
889 "Victorie, and as a conquerour to liven,\n"
890 "Noght greveth us your glorie and your honour;\n"
891 "But we biseken mercy and socour.\n"
892 "Have mercy on our wo and our distresse.\n"
893 "Som drope of pitee, thurgh thy gentilesse,\n"
894 "Up-on us wrecched wommen lat thou falle.\n"
895 "For certes, lord, ther nis noon of us alle,\n"
896 "That she nath been a duchesse or a quene;\n"
897 "Now be we caitifs, as it is wel sene:\n"
898 "Thanked be Fortune, and hir false wheel,\n"
899 "That noon estat assureth to be weel.\n"
900 "And certes, lord, t'abyden your presence,\n"
901 "Here in the temple of the goddesse Clemence\n"
902 "We han ben waytinge al this fourtenight;\n"
903 "Now help us, lord, sith it is in thy might.\n"
904 "I wrecche, which that wepe and waille thus,\n"
905 "Was whylom wyf to king Capaneus,\n"
906 "That starf at Thebes, cursed be that day!\n"
907 "And alle we, that been in this array,\n"
908 "And maken al this lamentacioun,\n"
909 "We losten alle our housbondes at that toun,\n"
910 "Whyl that the sege ther-aboute lay.\n"
911 "And yet now th'olde Creon, weylaway!\n"
912 "The lord is now of Thebes the citee, \n"
913 "Fulfild of ire and of iniquitee,\n"
914 "He, for despyt, and for his tirannye,\n"
915 "To do the dede bodyes vileinye,\n"
916 "Of alle our lordes, whiche that ben slawe,\n"
917 "Hath alle the bodyes on an heep y-drawe,\n"
918 "And wol nat suffren hem, by noon assent,\n"
919 "Neither to been y-buried nor y-brent,\n"
920 "But maketh houndes ete hem in despyt. zet'\n";
922 const char *cPattern
= "maketh houndes ete hem";
923 //const char *cPattern = "Whylom";
924 //const char *cPattern = "zet";
925 const char *testId
= "searchTime()"; // for error macros.
926 UnicodeString target
= longishText
;
927 UErrorCode status
= U_ZERO_ERROR
;
930 LocalUCollatorPointer
collator(ucol_open("en", &status
));
931 //ucol_setStrength(collator.getAlias(), collatorStrength);
932 //ucol_setAttribute(collator.getAlias(), UCOL_NORMALIZATION_MODE, normalize, &status);
933 UnicodeString uPattern
= cPattern
;
934 LocalUStringSearchPointer
uss(usearch_openFromCollator(uPattern
.getBuffer(), uPattern
.length(),
935 target
.getBuffer(), target
.length(),
937 NULL
, // the break iterator
939 TEST_ASSERT_SUCCESS(status
);
941 // int32_t foundStart;
945 // Find the match position usgin strstr
946 const char *pm
= strstr(longishText
, cPattern
);
947 TEST_ASSERT_M(pm
!=NULL
, "No pattern match with strstr");
948 int32_t refMatchPos
= (int32_t)(pm
- longishText
);
951 usearch_search(uss
.getAlias(), 0, &icuMatchPos
, &icuMatchEnd
, &status
);
952 TEST_ASSERT_SUCCESS(status
);
953 TEST_ASSERT_M(refMatchPos
== icuMatchPos
, "strstr and icu give different match positions.");
958 // Try loopcounts around 100000 to some millions, depending on the operation,
959 // to get runtimes of at least several seconds.
960 for (i
=0; i
<10000; i
++) {
961 found
= usearch_search(uss
.getAlias(), 0, &icuMatchPos
, &icuMatchEnd
, &status
);
962 (void)found
; // Suppress set but not used warning.
963 //TEST_ASSERT_SUCCESS(status);
964 //TEST_ASSERT(found);
966 // usearch_setOffset(uss.getAlias(), 0, &status);
967 // icuMatchPos = usearch_next(uss.getAlias(), &status);
969 // The i+j stuff is to confuse the optimizer and get it to actually leave the
970 // call to strstr in place.
971 //pm = strstr(longishText+j, cPattern);
975 //printf("%ld, %d\n", pm-longishText, j);
978 //----------------------------------------------------------------------------------------
980 // Random Numbers. Similar to standard lib rand() and srand()
981 // Not using library to
982 // 1. Get same results on all platforms.
983 // 2. Get access to current seed, to more easily reproduce failures.
985 //---------------------------------------------------------------------------------------
986 static uint32_t m_seed
= 1;
988 static uint32_t m_rand()
990 m_seed
= m_seed
* 1103515245 + 12345;
991 return (uint32_t)(m_seed
/65536) % 32768;
997 virtual void append(UnicodeString
&test
, UnicodeString
&alternate
) = 0;
1014 class SetMonkey
: public Monkey
1017 SetMonkey(const USet
*theSet
);
1020 virtual void append(UnicodeString
&test
, UnicodeString
&alternate
);
1026 SetMonkey::SetMonkey(const USet
*theSet
)
1027 : Monkey(), set(theSet
)
1032 SetMonkey::~SetMonkey()
1037 void SetMonkey::append(UnicodeString
&test
, UnicodeString
&alternate
)
1039 int32_t size
= uset_size(set
);
1040 int32_t index
= m_rand() % size
;
1041 UChar32 ch
= uset_charAt(set
, index
);
1042 UnicodeString
str(ch
);
1045 alternate
.append(str
); // flip case, or some junk?
1048 class StringSetMonkey
: public Monkey
1051 StringSetMonkey(const USet
*theSet
, UCollator
*theCollator
, CollData
*theCollData
);
1054 void append(UnicodeString
&testCase
, UnicodeString
&alternate
);
1057 UnicodeString
&generateAlternative(const UnicodeString
&testCase
, UnicodeString
&alternate
);
1064 StringSetMonkey::StringSetMonkey(const USet
*theSet
, UCollator
*theCollator
, CollData
*theCollData
)
1065 : Monkey(), set(theSet
), coll(theCollator
), collData(theCollData
)
1070 StringSetMonkey::~StringSetMonkey()
1075 void StringSetMonkey::append(UnicodeString
&testCase
, UnicodeString
&alternate
)
1077 int32_t itemCount
= uset_getItemCount(set
), len
= 0;
1078 int32_t index
= m_rand() % itemCount
;
1079 UChar32 rangeStart
= 0, rangeEnd
= 0;
1081 UErrorCode err
= U_ZERO_ERROR
;
1083 len
= uset_getItem(set
, index
, &rangeStart
, &rangeEnd
, buffer
, 16, &err
);
1086 int32_t offset
= m_rand() % (rangeEnd
- rangeStart
+ 1);
1087 UChar32 ch
= rangeStart
+ offset
;
1088 UnicodeString
str(ch
);
1090 testCase
.append(str
);
1091 generateAlternative(str
, alternate
);
1092 } else if (len
> 0) {
1093 // should check that len < 16...
1094 UnicodeString
str(buffer
, len
);
1096 testCase
.append(str
);
1097 generateAlternative(str
, alternate
);
1099 // shouldn't happen...
1103 UnicodeString
&StringSetMonkey::generateAlternative(const UnicodeString
&testCase
, UnicodeString
&alternate
)
1105 // find out shortest string for the longest sequence of ces.
1106 // needs to be refined to use dynamic programming, but will be roughly right
1107 UErrorCode status
= U_ZERO_ERROR
;
1108 CEList
ceList(coll
, testCase
, status
);
1112 if (ceList
.size() == 0) {
1113 return alternate
.append(testCase
);
1116 while (offset
< ceList
.size()) {
1117 int32_t ce
= ceList
.get(offset
);
1118 const StringList
*strings
= collData
->getStringList(ce
);
1120 if (strings
== NULL
) {
1121 return alternate
.append(testCase
);
1124 int32_t stringCount
= strings
->size();
1127 // find random string that generates the same CEList
1128 const CEList
*ceList2
= NULL
;
1129 const UnicodeString
*string
= NULL
;
1130 UBool matches
= FALSE
;
1133 int32_t s
= m_rand() % stringCount
;
1135 if (tries
++ > stringCount
) {
1136 alternate
.append(testCase
);
1140 string
= strings
->get(s
);
1141 ceList2
= collData
->getCEList(string
);
1142 matches
= ceList
.matchesAt(offset
, ceList2
);
1145 collData
->freeCEList((CEList
*) ceList2
);
1147 } while (! matches
);
1149 alt
.append(*string
);
1150 offset
+= ceList2
->size();
1151 collData
->freeCEList(ceList2
);
1154 const CEList
altCEs(coll
, alt
, status
);
1156 if (ceList
.matchesAt(0, &altCEs
)) {
1157 return alternate
.append(alt
);
1160 return alternate
.append(testCase
);
1163 static void generateTestCase(UCollator
*coll
, Monkey
*monkeys
[], int32_t monkeyCount
, UnicodeString
&testCase
, UnicodeString
&alternate
)
1165 int32_t pieces
= (m_rand() % 4) + 1;
1166 UErrorCode status
= U_ZERO_ERROR
;
1172 monkeys
[0]->append(testCase
, alternate
);
1174 for(int32_t piece
= 0; piece
< pieces
; piece
+= 1) {
1175 int32_t monkey
= m_rand() % monkeyCount
;
1177 monkeys
[monkey
]->append(testCase
, alternate
);
1180 const CEList
ceTest(coll
, testCase
, status
);
1181 const CEList
ceAlt(coll
, alternate
, status
);
1183 matches
= ceTest
.matchesAt(0, &ceAlt
);
1184 } while (! matches
);
1187 static UBool
simpleSearch(UCollator
*coll
, const UnicodeString
&target
, int32_t offset
, const UnicodeString
&pattern
, int32_t &matchStart
, int32_t &matchEnd
)
1189 UErrorCode status
= U_ZERO_ERROR
;
1190 OrderList
targetOrders(coll
, target
, offset
);
1191 OrderList
patternOrders(coll
, pattern
);
1192 int32_t targetSize
= targetOrders
.size() - 1;
1193 int32_t patternSize
= patternOrders
.size() - 1;
1194 UBreakIterator
*charBreakIterator
= ubrk_open(UBRK_CHARACTER
, ucol_getLocaleByType(coll
, ULOC_VALID_LOCALE
, &status
),
1195 target
.getBuffer(), target
.length(), &status
);
1197 if (patternSize
== 0) {
1198 // Searching for an empty pattern always fails
1199 matchStart
= matchEnd
= -1;
1200 ubrk_close(charBreakIterator
);
1204 matchStart
= matchEnd
= -1;
1206 for(int32_t i
= 0; i
< targetSize
; i
+= 1) {
1207 if (targetOrders
.matchesAt(i
, patternOrders
)) {
1208 int32_t start
= targetOrders
.getLowOffset(i
);
1209 int32_t maxLimit
= targetOrders
.getLowOffset(i
+ patternSize
);
1210 int32_t minLimit
= targetOrders
.getLowOffset(i
+ patternSize
- 1);
1212 // if the low and high offsets of the first CE in
1213 // the match are the same, it means that the match
1214 // starts in the middle of an expansion - all but
1215 // the first CE of the expansion will have the offset
1216 // of the following character.
1217 if (start
== targetOrders
.getHighOffset(i
)) {
1221 // Make sure match starts on a grapheme boundary
1222 if (! ubrk_isBoundary(charBreakIterator
, start
)) {
1226 // If the low and high offsets of the CE after the match
1227 // are the same, it means that the match ends in the middle
1228 // of an expansion sequence.
1229 if (maxLimit
== targetOrders
.getHighOffset(i
+ patternSize
) &&
1230 targetOrders
.getOrder(i
+ patternSize
) != UCOL_NULLORDER
) {
1234 int32_t mend
= maxLimit
;
1236 // Find the first grapheme break after the character index
1237 // of the last CE in the match. If it's after character index
1238 // that's after the last CE in the match, use that index
1239 // as the end of the match.
1240 if (minLimit
< maxLimit
) {
1241 // When the last CE's low index is same with its high index, the CE is likely
1242 // a part of expansion. In this case, the index is located just after the
1243 // character corresponding to the CEs compared above. If the index is right
1244 // at the break boundary, move the position to the next boundary will result
1245 // incorrect match length when there are ignorable characters exist between
1246 // the position and the next character produces CE(s). See ticket#8482.
1247 if (minLimit
== targetOrders
.getHighOffset(i
+ patternSize
- 1) && ubrk_isBoundary(charBreakIterator
, minLimit
)) {
1250 int32_t nba
= ubrk_following(charBreakIterator
, minLimit
);
1252 if (nba
>= targetOrders
.getHighOffset(i
+ patternSize
- 1)) {
1258 if (mend
> maxLimit
) {
1262 if (! ubrk_isBoundary(charBreakIterator
, mend
)) {
1269 ubrk_close(charBreakIterator
);
1274 ubrk_close(charBreakIterator
);
1278 #if !UCONFIG_NO_REGULAR_EXPRESSIONS
1279 static int32_t getIntParam(UnicodeString name
, UnicodeString
¶ms
, int32_t defaultVal
) {
1280 int32_t val
= defaultVal
;
1282 name
.append(" *= *(-?\\d+)");
1284 UErrorCode status
= U_ZERO_ERROR
;
1285 RegexMatcher
m(name
, params
, 0, status
);
1288 // The param exists. Convert the string to an int.
1289 char valString
[100];
1290 int32_t paramLength
= m
.end(1, status
) - m
.start(1, status
);
1292 if (paramLength
>= (int32_t)(sizeof(valString
)-1)) {
1293 paramLength
= (int32_t)(sizeof(valString
)-2);
1296 params
.extract(m
.start(1, status
), paramLength
, valString
, sizeof(valString
));
1297 val
= uprv_strtol(valString
, NULL
, 10);
1299 // Delete this parameter from the params string.
1301 params
= m
.replaceFirst("", status
);
1304 //U_ASSERT(U_SUCCESS(status));
1305 if (! U_SUCCESS(status
)) {
1313 #if !UCONFIG_NO_COLLATION
1314 int32_t SSearchTest::monkeyTestCase(UCollator
*coll
, const UnicodeString
&testCase
, const UnicodeString
&pattern
, const UnicodeString
&altPattern
,
1315 const char *name
, const char *strength
, uint32_t seed
)
1317 UErrorCode status
= U_ZERO_ERROR
;
1318 int32_t actualStart
= -1, actualEnd
= -1;
1319 //int32_t expectedStart = prefix.length(), expectedEnd = prefix.length() + altPattern.length();
1320 int32_t expectedStart
= -1, expectedEnd
= -1;
1321 int32_t notFoundCount
= 0;
1322 LocalUStringSearchPointer
uss(usearch_openFromCollator(pattern
.getBuffer(), pattern
.length(),
1323 testCase
.getBuffer(), testCase
.length(),
1325 NULL
, // the break iterator
1328 // **** TODO: find *all* matches, not just first one ****
1329 simpleSearch(coll
, testCase
, 0, pattern
, expectedStart
, expectedEnd
);
1331 usearch_search(uss
.getAlias(), 0, &actualStart
, &actualEnd
, &status
);
1333 if (expectedStart
>= 0 && (actualStart
!= expectedStart
|| actualEnd
!= expectedEnd
)) {
1334 errln("Search for <pattern> in <%s> failed: expected [%d, %d], got [%d, %d]\n"
1335 " strength=%s seed=%d",
1336 name
, expectedStart
, expectedEnd
, actualStart
, actualEnd
, strength
, seed
);
1339 if (expectedStart
== -1 && actualStart
== -1) {
1343 // **** TODO: find *all* matches, not just first one ****
1344 simpleSearch(coll
, testCase
, 0, altPattern
, expectedStart
, expectedEnd
);
1346 usearch_setPattern(uss
.getAlias(), altPattern
.getBuffer(), altPattern
.length(), &status
);
1348 usearch_search(uss
.getAlias(), 0, &actualStart
, &actualEnd
, &status
);
1350 if (expectedStart
>= 0 && (actualStart
!= expectedStart
|| actualEnd
!= expectedEnd
)) {
1351 errln("Search for <alt_pattern> in <%s> failed: expected [%d, %d], got [%d, %d]\n"
1352 " strength=%s seed=%d",
1353 name
, expectedStart
, expectedEnd
, actualStart
, actualEnd
, strength
, seed
);
1356 if (expectedStart
== -1 && actualStart
== -1) {
1360 return notFoundCount
;
1364 void SSearchTest::monkeyTest(char *params
)
1367 UErrorCode status
= U_ZERO_ERROR
;
1368 //UCollator *coll = ucol_open(NULL, &status);
1369 UCollator
*coll
= ucol_openFromShortString("S1", FALSE
, NULL
, &status
);
1371 if (U_FAILURE(status
)) {
1372 errcheckln(status
, "Failed to create collator in MonkeyTest! - %s", u_errorName(status
));
1376 CollData
*monkeyData
= new CollData(coll
, status
);
1378 USet
*expansions
= uset_openEmpty();
1379 USet
*contractions
= uset_openEmpty();
1381 ucol_getContractionsAndExpansions(coll
, contractions
, expansions
, FALSE
, &status
);
1383 U_STRING_DECL(letter_pattern
, "[[:letter:]-[:ideographic:]-[:hangul:]]", 39);
1384 U_STRING_INIT(letter_pattern
, "[[:letter:]-[:ideographic:]-[:hangul:]]", 39);
1385 USet
*letters
= uset_openPattern(letter_pattern
, 39, &status
);
1386 SetMonkey
letterMonkey(letters
);
1387 StringSetMonkey
contractionMonkey(contractions
, coll
, monkeyData
);
1388 StringSetMonkey
expansionMonkey(expansions
, coll
, monkeyData
);
1389 UnicodeString testCase
;
1390 UnicodeString alternate
;
1391 UnicodeString pattern
, altPattern
;
1392 UnicodeString prefix
, altPrefix
;
1393 UnicodeString suffix
, altSuffix
;
1395 Monkey
*monkeys
[] = {
1405 int32_t monkeyCount
= UPRV_LENGTHOF(monkeys
);
1406 // int32_t nonMatchCount = 0;
1408 UCollationStrength strengths
[] = {UCOL_PRIMARY
, UCOL_SECONDARY
, UCOL_TERTIARY
};
1409 const char *strengthNames
[] = {"primary", "secondary", "tertiary"};
1410 int32_t strengthCount
= UPRV_LENGTHOF(strengths
);
1411 int32_t loopCount
= quick
? 1000 : 10000;
1412 int32_t firstStrength
= 0;
1413 int32_t lastStrength
= strengthCount
- 1; //*/ 0;
1415 if (params
!= NULL
) {
1416 #if !UCONFIG_NO_REGULAR_EXPRESSIONS
1417 UnicodeString
p(params
);
1419 loopCount
= getIntParam("loop", p
, loopCount
);
1420 m_seed
= getIntParam("seed", p
, m_seed
);
1422 RegexMatcher
m(" *strength *= *(primary|secondary|tertiary) *", p
, 0, status
);
1424 UnicodeString breakType
= m
.group(1, status
);
1426 for (int32_t s
= 0; s
< strengthCount
; s
+= 1) {
1427 if (breakType
== strengthNames
[s
]) {
1428 firstStrength
= lastStrength
= s
;
1434 p
= m
.replaceFirst("", status
);
1437 if (RegexMatcher("\\S", p
, 0, status
).find()) {
1438 // Each option is stripped out of the option string as it is processed.
1439 // All options have been checked. The option string should have been completely emptied..
1441 p
.extract(buf
, sizeof(buf
), NULL
, status
);
1442 buf
[sizeof(buf
)-1] = 0;
1443 errln("Unrecognized or extra parameter: %s\n", buf
);
1447 infoln("SSearchTest built with UCONFIG_NO_REGULAR_EXPRESSIONS: ignoring parameters.");
1451 for(int32_t s
= firstStrength
; s
<= lastStrength
; s
+= 1) {
1452 int32_t notFoundCount
= 0;
1454 logln("Setting strength to %s.", strengthNames
[s
]);
1455 ucol_setStrength(coll
, strengths
[s
]);
1457 // TODO: try alternate prefix and suffix too?
1458 // TODO: alternates are only equal at primary strength. Is this OK?
1459 for(int32_t t
= 0; t
< loopCount
; t
+= 1) {
1460 uint32_t seed
= m_seed
;
1463 generateTestCase(coll
, monkeys
, monkeyCount
, pattern
, altPattern
);
1464 generateTestCase(coll
, monkeys
, monkeyCount
, prefix
, altPrefix
);
1465 generateTestCase(coll
, monkeys
, monkeyCount
, suffix
, altSuffix
);
1468 notFoundCount
+= monkeyTestCase(coll
, pattern
, pattern
, altPattern
, "pattern", strengthNames
[s
], seed
);
1471 testCase
.append(prefix
);
1472 testCase
.append(/*alt*/pattern
);
1475 notFoundCount
+= monkeyTestCase(coll
, testCase
, pattern
, altPattern
, "prefix + pattern", strengthNames
[s
], seed
);
1477 testCase
.append(suffix
);
1479 // prefix + pattern + suffix
1480 notFoundCount
+= monkeyTestCase(coll
, testCase
, pattern
, altPattern
, "prefix + pattern + suffix", strengthNames
[s
], seed
);
1483 testCase
.append(pattern
);
1484 testCase
.append(suffix
);
1487 notFoundCount
+= monkeyTestCase(coll
, testCase
, pattern
, altPattern
, "pattern + suffix", strengthNames
[s
], seed
);
1490 logln("For strength %s the not found count is %d.", strengthNames
[s
], notFoundCount
);
1493 uset_close(contractions
);
1494 uset_close(expansions
);
1495 uset_close(letters
);