1 /* Copyright (C) 2007-2014 Open Information Security Foundation
2 *
3 * You can copy, redistribute or modify this Program under the terms of
4 * the GNU General Public License version 2 as published by the Free
5 * Software Foundation.
6 *
7 * This program is distributed in the hope that it will be useful,
8 * but WITHOUT ANY WARRANTY; without even the implied warranty of
9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 * GNU General Public License for more details.
11 *
12 * You should have received a copy of the GNU General Public License
13 * version 2 along with this program; if not, write to the Free Software
14 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
15 * 02110-1301, USA.
16 */
17
18 /**
19 * \file
20 *
21 * \author Pablo Rincon Crespo <pablo.rincon.crespo@gmail.com>
22 *
23 * PR (17/01/2010): Single pattern search algorithms:
24 * Currently there are 3 algorithms to choose: BasicSearch, Bs2Bm and
25 * BoyerMoore (Boyer Moores algorithm). The first one doesn't need a context.
26 * But for Bs2Bm and BoyerMoore, you'll need to build some arrays.
27 *
28 * !! If you are going to use the same pattern multiple times,
29 * please, try to store the context some where. For Bs2Bm, the
30 * context is an array of "badchars". For BoyerMoore you need to store
31 * two arrays of shifts. Have a look at the wrappers and unittests
32 * for examples of this. If you cant store the context, use the
33 * wrappers: Bs2bmSearch, BoyerMooreSearch, and the ones caseless, or BasicSearch
34 * That is the most basic.
35 *
36 * Use the stats and util-clock.h to determine which one fit better for you
37 * Boyer Moore should be used for patterns greater than 1 of length
38 * In the range of 2 - 6, if the text length is greater than 1000 you could
39 * use boyer moore, otherwise, basic search. If the pattern is greater
40 * than 6 and the textlen is greater than 500, use boyer moore.
41 * This is an aproximation, but use the stats and util-clock to determine which one
42 * fit better for your case.
43 *
44 */
45
46 #include "suricata-common.h"
47 #include "suricata.h"
48 #include "util-unittest.h"
49
50 #include "conf.h"
51
52 #include "util-spm.h"
53 #include "util-spm-bs.h"
54 #include "util-spm-bs2bm.h"
55 #include "util-spm-bm.h"
56 #include "util-spm-hs.h"
57 #include "util-clock.h"
58 #ifdef BUILD_HYPERSCAN
59 #include "hs.h"
60 #endif
61
62 SpmTableElmt spm_table[SPM_TABLE_SIZE];
63
64 /**
65 * \brief Returns the single pattern matcher algorithm to be used, based on the
66 * spm-algo setting in yaml.
67 */
SinglePatternMatchDefaultMatcher(void)68 uint16_t SinglePatternMatchDefaultMatcher(void)
69 {
70 const char *spm_algo;
71 if ((ConfGet("spm-algo", &spm_algo)) == 1) {
72 if (spm_algo != NULL) {
73 if (strcmp("auto", spm_algo) == 0) {
74 goto default_matcher;
75 }
76 for (uint16_t i = 0; i < SPM_TABLE_SIZE; i++) {
77 if (spm_table[i].name == NULL) {
78 continue;
79 }
80 if (strcmp(spm_table[i].name, spm_algo) == 0) {
81 return i;
82 }
83 }
84 }
85
86 #ifndef BUILD_HYPERSCAN
87 if ((spm_algo != NULL) && (strcmp(spm_algo, "hs") == 0)) {
88 FatalError(SC_ERR_INVALID_VALUE, "Hyperscan (hs) support for spm-algo is "
89 "not compiled into Suricata.");
90 }
91 #endif
92 SCLogError(SC_ERR_INVALID_YAML_CONF_ENTRY,
93 "Invalid spm algo supplied "
94 "in the yaml conf file: \"%s\"",
95 spm_algo);
96 exit(EXIT_FAILURE);
97 }
98
99 default_matcher:
100 /* When Suricata is built with Hyperscan support, default to using it for
101 * SPM. */
102 #ifdef BUILD_HYPERSCAN
103 #ifdef HAVE_HS_VALID_PLATFORM
104 /* Enable runtime check for SSSE3. Do not use Hyperscan SPM matcher if
105 * check is not successful. */
106 if (hs_valid_platform() != HS_SUCCESS) {
107 SCLogInfo("SSSE3 support not detected, disabling Hyperscan for "
108 "SPM");
109 /* Use Boyer-Moore as fallback. */
110 return SPM_BM;
111 } else {
112 return SPM_HS;
113 }
114 #else
115 return SPM_HS;
116 #endif
117 #else
118 /* Otherwise, default to Boyer-Moore */
119 return SPM_BM;
120 #endif
121 }
122
SpmTableSetup(void)123 void SpmTableSetup(void)
124 {
125 memset(spm_table, 0, sizeof(spm_table));
126
127 SpmBMRegister();
128 #ifdef BUILD_HYPERSCAN
129 #ifdef HAVE_HS_VALID_PLATFORM
130 if (hs_valid_platform() == HS_SUCCESS) {
131 SpmHSRegister();
132 }
133 #else
134 SpmHSRegister();
135 #endif
136 #endif
137 }
138
SpmInitGlobalThreadCtx(uint16_t matcher)139 SpmGlobalThreadCtx *SpmInitGlobalThreadCtx(uint16_t matcher)
140 {
141 BUG_ON(spm_table[matcher].InitGlobalThreadCtx == NULL);
142 return spm_table[matcher].InitGlobalThreadCtx();
143 }
144
SpmDestroyGlobalThreadCtx(SpmGlobalThreadCtx * global_thread_ctx)145 void SpmDestroyGlobalThreadCtx(SpmGlobalThreadCtx *global_thread_ctx)
146 {
147 if (global_thread_ctx == NULL) {
148 return;
149 }
150 uint16_t matcher = global_thread_ctx->matcher;
151 spm_table[matcher].DestroyGlobalThreadCtx(global_thread_ctx);
152 }
153
SpmMakeThreadCtx(const SpmGlobalThreadCtx * global_thread_ctx)154 SpmThreadCtx *SpmMakeThreadCtx(const SpmGlobalThreadCtx *global_thread_ctx)
155 {
156 if (global_thread_ctx == NULL) {
157 return NULL;
158 }
159 uint16_t matcher = global_thread_ctx->matcher;
160 BUG_ON(spm_table[matcher].MakeThreadCtx == NULL);
161 return spm_table[matcher].MakeThreadCtx(global_thread_ctx);
162 }
163
SpmDestroyThreadCtx(SpmThreadCtx * thread_ctx)164 void SpmDestroyThreadCtx(SpmThreadCtx *thread_ctx)
165 {
166 if (thread_ctx == NULL) {
167 return;
168 }
169 uint16_t matcher = thread_ctx->matcher;
170 BUG_ON(spm_table[matcher].DestroyThreadCtx == NULL);
171 spm_table[matcher].DestroyThreadCtx(thread_ctx);
172 }
173
SpmInitCtx(const uint8_t * needle,uint16_t needle_len,int nocase,SpmGlobalThreadCtx * global_thread_ctx)174 SpmCtx *SpmInitCtx(const uint8_t *needle, uint16_t needle_len, int nocase,
175 SpmGlobalThreadCtx *global_thread_ctx)
176 {
177 BUG_ON(global_thread_ctx == NULL);
178 uint16_t matcher = global_thread_ctx->matcher;
179 BUG_ON(spm_table[matcher].InitCtx == NULL);
180 return spm_table[matcher].InitCtx(needle, needle_len, nocase,
181 global_thread_ctx);
182 }
183
SpmDestroyCtx(SpmCtx * ctx)184 void SpmDestroyCtx(SpmCtx *ctx)
185 {
186 if (ctx == NULL) {
187 return;
188 }
189 uint16_t matcher = ctx->matcher;
190 BUG_ON(spm_table[matcher].DestroyCtx == NULL);
191 spm_table[matcher].DestroyCtx(ctx);
192 }
193
SpmScan(const SpmCtx * ctx,SpmThreadCtx * thread_ctx,const uint8_t * haystack,uint32_t haystack_len)194 uint8_t *SpmScan(const SpmCtx *ctx, SpmThreadCtx *thread_ctx,
195 const uint8_t *haystack, uint32_t haystack_len)
196 {
197 uint16_t matcher = ctx->matcher;
198 return spm_table[matcher].Scan(ctx, thread_ctx, haystack, haystack_len);
199 }
200
201 /**
202 * Wrappers for building context and searching (Bs2Bm and boyermoore)
203 * Use them if you cant store the context
204 *
205 */
206
207 /**
208 * \brief Search a pattern in the text using the Bs2Bm algorithm (build a bad characters array)
209 *
210 * \param text Text to search in
211 * \param textlen length of the text
212 * \param needle pattern to search for
213 * \param needlelen length of the pattern
214 */
Bs2bmSearch(const uint8_t * text,uint32_t textlen,const uint8_t * needle,uint16_t needlelen)215 uint8_t *Bs2bmSearch(const uint8_t *text, uint32_t textlen,
216 const uint8_t *needle, uint16_t needlelen)
217 {
218 uint8_t badchars[ALPHABET_SIZE];
219 Bs2BmBadchars(needle, needlelen, badchars);
220
221 return Bs2Bm(text, textlen, needle, needlelen, badchars);
222 }
223
224 /**
225 * \brief Search a pattern in the text using the Bs2Bm nocase algorithm (build a bad characters array)
226 *
227 * \param text Text to search in
228 * \param textlen length of the text
229 * \param needle pattern to search for
230 * \param needlelen length of the pattern
231 */
Bs2bmNocaseSearch(const uint8_t * text,uint32_t textlen,const uint8_t * needle,uint16_t needlelen)232 uint8_t *Bs2bmNocaseSearch(const uint8_t *text, uint32_t textlen,
233 const uint8_t *needle, uint16_t needlelen)
234 {
235 uint8_t badchars[ALPHABET_SIZE];
236 Bs2BmBadchars(needle, needlelen, badchars);
237
238 return Bs2BmNocase(text, textlen, needle, needlelen, badchars);
239 }
240
241 /**
242 * \brief Search a pattern in the text using Boyer Moore algorithm
243 * (build a bad character shifts array and good prefixes shift array)
244 *
245 * \param text Text to search in
246 * \param textlen length of the text
247 * \param needle pattern to search for
248 * \param needlelen length of the pattern
249 */
BoyerMooreSearch(const uint8_t * text,uint32_t textlen,const uint8_t * needle,uint16_t needlelen)250 uint8_t *BoyerMooreSearch(const uint8_t *text, uint32_t textlen,
251 const uint8_t *needle, uint16_t needlelen)
252 {
253 BmCtx *bm_ctx = BoyerMooreCtxInit(needle, needlelen);
254
255 uint8_t *ret = BoyerMoore(needle, needlelen, text, textlen, bm_ctx);
256 BoyerMooreCtxDeInit(bm_ctx);
257
258 return ret;
259 }
260
261 /**
262 * \brief Search a pattern in the text using Boyer Moore nocase algorithm
263 * (build a bad character shifts array and good prefixes shift array)
264 *
265 * \param text Text to search in
266 * \param textlen length of the text
267 * \param needle pattern to search for
268 * \param needlelen length of the pattern
269 */
BoyerMooreNocaseSearch(const uint8_t * text,uint32_t textlen,uint8_t * needle,uint16_t needlelen)270 uint8_t *BoyerMooreNocaseSearch(const uint8_t *text, uint32_t textlen,
271 uint8_t *needle, uint16_t needlelen)
272 {
273 BmCtx *bm_ctx = BoyerMooreNocaseCtxInit(needle, needlelen);
274
275 uint8_t *ret = BoyerMooreNocase(needle, needlelen, text, textlen, bm_ctx);
276 BoyerMooreCtxDeInit(bm_ctx);
277
278 return ret;
279 }
280
281
282 #ifdef UNITTESTS
283
284 /** Comment out this if you want stats
285 * #define ENABLE_SEARCH_STATS 1
286 */
287
288 /* Number of times to repeat the search (for stats) */
289 #define STATS_TIMES 1000000
290
291 /**
292 * \brief Unittest helper function wrappers for the search algorithms
293 * \param text pointer to the buffer to search in
294 * \param needle pointer to the pattern to search for
295 * \param times If you are testing performance, se the numebr of times
296 * that you want to repeat the search
297 */
BasicSearchWrapper(uint8_t * text,uint8_t * needle,int times)298 static uint8_t *BasicSearchWrapper(uint8_t *text, uint8_t *needle, int times)
299 {
300 uint32_t textlen = strlen((char *)text);
301 uint16_t needlelen = strlen((char *)needle);
302
303 uint8_t *ret = NULL;
304 int i = 0;
305
306 CLOCK_INIT;
307 if (times > 1)
308 CLOCK_START;
309
310 for (i = 0; i < times; i++) {
311 ret = BasicSearch(text, textlen, needle, needlelen);
312 }
313
314 if (times > 1) { CLOCK_END; CLOCK_PRINT_SEC; };
315 return ret;
316 }
317
BasicSearchNocaseWrapper(uint8_t * text,uint8_t * needle,int times)318 static uint8_t *BasicSearchNocaseWrapper(uint8_t *text, uint8_t *needle, int times)
319 {
320 uint32_t textlen = strlen((char *)text);
321 uint16_t needlelen = strlen((char *)needle);
322
323 uint8_t *ret = NULL;
324 int i = 0;
325
326 CLOCK_INIT;
327 if (times > 1) CLOCK_START;
328 for (i = 0; i < times; i++) {
329 ret = BasicSearchNocase(text, textlen, needle, needlelen);
330 }
331 if (times > 1) { CLOCK_END; CLOCK_PRINT_SEC; };
332 return ret;
333 }
334
Bs2bmWrapper(uint8_t * text,uint8_t * needle,int times)335 static uint8_t *Bs2bmWrapper(uint8_t *text, uint8_t *needle, int times)
336 {
337 uint32_t textlen = strlen((char *)text);
338 uint16_t needlelen = strlen((char *)needle);
339
340 uint8_t badchars[ALPHABET_SIZE];
341 Bs2BmBadchars(needle, needlelen, badchars);
342
343 uint8_t *ret = NULL;
344 int i = 0;
345
346 CLOCK_INIT;
347 if (times > 1) CLOCK_START;
348 for (i = 0; i < times; i++) {
349 ret = Bs2Bm(text, textlen, needle, needlelen, badchars);
350 }
351 if (times > 1) { CLOCK_END; CLOCK_PRINT_SEC; };
352 return ret;
353 }
354
Bs2bmNocaseWrapper(uint8_t * text,uint8_t * needle,int times)355 static uint8_t *Bs2bmNocaseWrapper(uint8_t *text, uint8_t *needle, int times)
356 {
357 uint32_t textlen = strlen((char *)text);
358 uint16_t needlelen = strlen((char *)needle);
359
360 uint8_t badchars[ALPHABET_SIZE];
361 Bs2BmBadchars(needle, needlelen, badchars);
362
363 uint8_t *ret = NULL;
364 int i = 0;
365
366 CLOCK_INIT;
367 if (times > 1) CLOCK_START;
368 for (i = 0; i < times; i++) {
369 ret = Bs2BmNocase(text, textlen, needle, needlelen, badchars);
370 }
371 if (times > 1) { CLOCK_END; CLOCK_PRINT_SEC; };
372 return ret;
373 }
374
BoyerMooreWrapper(uint8_t * text,uint8_t * needle,int times)375 static uint8_t *BoyerMooreWrapper(uint8_t *text, uint8_t *needle, int times)
376 {
377 uint32_t textlen = strlen((char *)text);
378 uint16_t needlelen = strlen((char *)needle);
379
380 BmCtx *bm_ctx = BoyerMooreCtxInit(needle, needlelen);
381
382 uint8_t *ret = NULL;
383 int i = 0;
384
385 CLOCK_INIT;
386 if (times > 1) CLOCK_START;
387 for (i = 0; i < times; i++) {
388 ret = BoyerMoore(needle, needlelen, text, textlen, bm_ctx);
389 }
390 if (times > 1) { CLOCK_END; CLOCK_PRINT_SEC; };
391 BoyerMooreCtxDeInit(bm_ctx);
392 return ret;
393 }
394
BoyerMooreNocaseWrapper(uint8_t * text,uint8_t * in_needle,int times)395 static uint8_t *BoyerMooreNocaseWrapper(uint8_t *text, uint8_t *in_needle, int times)
396 {
397 uint32_t textlen = strlen((char *)text);
398 uint16_t needlelen = strlen((char *)in_needle);
399
400 /* Make a copy of in_needle to be able to convert it to lowercase. */
401 uint8_t *needle = SCMalloc(needlelen);
402 if (needle == NULL)
403 return NULL;
404 memcpy(needle, in_needle, needlelen);
405
406 BmCtx *bm_ctx = BoyerMooreNocaseCtxInit(needle, needlelen);
407
408 uint8_t *ret = NULL;
409 int i = 0;
410
411 CLOCK_INIT;
412 if (times > 1) CLOCK_START;
413 for (i = 0; i < times; i++) {
414 ret = BoyerMooreNocase(needle, needlelen, text, textlen, bm_ctx);
415 }
416 if (times > 1) { CLOCK_END; CLOCK_PRINT_SEC; };
417 BoyerMooreCtxDeInit(bm_ctx);
418 free(needle);
419 return ret;
420
421 }
422
423 #ifdef ENABLE_SEARCH_STATS
424 /**
425 * \brief Unittest helper function wrappers for the search algorithms
426 * \param text pointer to the buffer to search in
427 * \param needle pointer to the pattern to search for
428 * \param times If you are testing performance, se the numebr of times
429 * that you want to repeat the search
430 */
BasicSearchCtxWrapper(uint8_t * text,uint8_t * needle,int times)431 static uint8_t *BasicSearchCtxWrapper(uint8_t *text, uint8_t *needle, int times)
432 {
433 uint32_t textlen = strlen((char *)text);
434 uint16_t needlelen = strlen((char *)needle);
435
436 uint8_t *ret = NULL;
437 int i = 0;
438
439 CLOCK_INIT;
440 if (times > 1) CLOCK_START;
441 for (i = 0; i < times; i++) {
442 /* This wrapper is a fake, no context needed! */
443 ret = BasicSearch(text, textlen, needle, needlelen);
444 }
445 if (times > 1) { CLOCK_END; CLOCK_PRINT_SEC; };
446 return ret;
447 }
448
BasicSearchNocaseCtxWrapper(uint8_t * text,uint8_t * needle,int times)449 static uint8_t *BasicSearchNocaseCtxWrapper(uint8_t *text, uint8_t *needle, int times)
450 {
451 uint32_t textlen = strlen((char *)text);
452 uint16_t needlelen = strlen((char *)needle);
453
454 uint8_t *ret = NULL;
455 int i = 0;
456
457 CLOCK_INIT;
458 if (times > 1) CLOCK_START;
459 for (i = 0; i < times; i++) {
460 /* This wrapper is a fake, no context needed! */
461 ret = BasicSearchNocase(text, textlen, needle, needlelen);
462 }
463 if (times > 1) { CLOCK_END; CLOCK_PRINT_SEC; };
464 return ret;
465 }
466
Bs2bmCtxWrapper(uint8_t * text,uint8_t * needle,int times)467 static uint8_t *Bs2bmCtxWrapper(uint8_t *text, uint8_t *needle, int times)
468 {
469 uint32_t textlen = strlen((char *)text);
470 uint16_t needlelen = strlen((char *)needle);
471
472 uint8_t badchars[ALPHABET_SIZE];
473
474 uint8_t *ret = NULL;
475 int i = 0;
476
477 CLOCK_INIT;
478 if (times > 1) CLOCK_START;
479 for (i = 0; i < times; i++) {
480 /* Stats including context building */
481 Bs2BmBadchars(needle, needlelen, badchars);
482 ret = Bs2Bm(text, textlen, needle, needlelen, badchars);
483 }
484 if (times > 1) { CLOCK_END; CLOCK_PRINT_SEC; };
485 return ret;
486 }
487
Bs2bmNocaseCtxWrapper(uint8_t * text,uint8_t * needle,int times)488 static uint8_t *Bs2bmNocaseCtxWrapper(uint8_t *text, uint8_t *needle, int times)
489 {
490 uint32_t textlen = strlen((char *)text);
491 uint16_t needlelen = strlen((char *)needle);
492
493 uint8_t badchars[ALPHABET_SIZE];
494
495 uint8_t *ret = NULL;
496 int i = 0;
497
498 CLOCK_INIT;
499 if (times > 1) CLOCK_START;
500 for (i = 0; i < times; i++) {
501 /* Stats including context building */
502 Bs2BmBadchars(needle, needlelen, badchars);
503 ret = Bs2BmNocase(text, textlen, needle, needlelen, badchars);
504 }
505 if (times > 1) { CLOCK_END; CLOCK_PRINT_SEC; };
506 return ret;
507 }
508
BoyerMooreCtxWrapper(uint8_t * text,uint8_t * needle,int times)509 static uint8_t *BoyerMooreCtxWrapper(uint8_t *text, uint8_t *needle, int times)
510 {
511 uint32_t textlen = strlen((char *)text);
512 uint16_t needlelen = strlen((char *)needle);
513
514 BmCtx *bm_ctx = BoyerMooreCtxInit(needle, needlelen);
515
516 uint8_t *ret = NULL;
517 int i = 0;
518
519 CLOCK_INIT;
520 if (times > 1) CLOCK_START;
521 for (i = 0; i < times; i++) {
522 /* Stats including context building */
523 ret = BoyerMoore(needle, needlelen, text, textlen, bm_ctx);
524 }
525 if (times > 1) { CLOCK_END; CLOCK_PRINT_SEC; };
526 BoyerMooreCtxDeInit(bm_ctx);
527
528 return ret;
529 }
530
RawCtxWrapper(uint8_t * text,uint8_t * needle,int times)531 static uint8_t *RawCtxWrapper(uint8_t *text, uint8_t *needle, int times)
532 {
533 uint32_t textlen = strlen((char *)text);
534 uint16_t needlelen = strlen((char *)needle);
535
536 uint8_t *ret = NULL;
537 int i = 0;
538
539 CLOCK_INIT;
540 if (times > 1) CLOCK_START;
541 for (i = 0; i < times; i++) {
542 ret = SpmSearch(text, textlen, needle, needlelen);
543 }
544 if (times > 1) { CLOCK_END; CLOCK_PRINT_SEC; };
545 return ret;
546 }
547
BoyerMooreNocaseCtxWrapper(uint8_t * text,uint8_t * in_needle,int times)548 static uint8_t *BoyerMooreNocaseCtxWrapper(uint8_t *text, uint8_t *in_needle, int times)
549 {
550 uint32_t textlen = strlen((char *)text);
551 uint16_t needlelen = strlen((char *)in_needle);
552
553 /* Make a copy of in_needle to be able to convert it to lowercase. */
554 uint8_t *needle = SCMalloc(needlelen);
555 if (needle == NULL)
556 return NULL;
557 memcpy(needle, in_needle, needlelen);
558
559 BmCtx *bm_ctx = BoyerMooreNocaseCtxInit(needle, needlelen);
560
561 uint8_t *ret = NULL;
562 int i = 0;
563
564 CLOCK_INIT;
565 if (times > 1) CLOCK_START;
566 for (i = 0; i < times; i++) {
567 ret = BoyerMooreNocase(needle, needlelen, text, textlen, bm_ctx);
568 }
569 if (times > 1) { CLOCK_END; CLOCK_PRINT_SEC; };
570 BoyerMooreCtxDeInit(bm_ctx);
571 free(needle);
572 return ret;
573
574 }
575 #endif
576
577 /**
578 * \test Generic test for BasicSearch matching
579 */
UtilSpmBasicSearchTest01(void)580 static int UtilSpmBasicSearchTest01(void)
581 {
582 uint8_t *needle = (uint8_t *)"oPqRsT";
583 uint8_t *text = (uint8_t *)"aBcDeFgHiJkLmNoPqRsTuVwXyZ";
584 uint8_t *found = BasicSearchWrapper(text, needle, 1);
585 //printf("found: %s\n", found);
586 if (found != NULL)
587 return 1;
588 else
589 return 0;
590 }
591
592 /**
593 * \test Generic test for BasicSearch nocase matching
594 */
UtilSpmBasicSearchNocaseTest01(void)595 static int UtilSpmBasicSearchNocaseTest01(void)
596 {
597 uint8_t *needle = (uint8_t *)"OpQrSt";
598 uint8_t *text = (uint8_t *)"aBcDeFgHiJkLmNoPqRsTuVwXyZ";
599 uint8_t *found = BasicSearchNocaseWrapper(text, needle, 1);
600 //printf("found: %s\n", found);
601 if (found != NULL)
602 return 1;
603 else
604 return 0;
605 }
606
607 /**
608 * \test Generic test for Bs2Bm matching
609 */
UtilSpmBs2bmSearchTest01(void)610 static int UtilSpmBs2bmSearchTest01(void)
611 {
612 uint8_t *needle = (uint8_t *)"oPqRsT";
613 uint8_t *text = (uint8_t *)"aBcDeFgHiJkLmNoPqRsTuVwXyZ";
614 uint8_t *found = Bs2bmWrapper(text, needle, 1);
615 //printf("found: %s\n", found);
616 if (found != NULL)
617 return 1;
618 else
619 return 0;
620 }
621
622 /**
623 * \test Generic test for Bs2Bm no case matching
624 */
UtilSpmBs2bmSearchNocaseTest01(void)625 static int UtilSpmBs2bmSearchNocaseTest01(void)
626 {
627 uint8_t *needle = (uint8_t *)"OpQrSt";
628 uint8_t *text = (uint8_t *)"aBcDeFgHiJkLmNoPqRsTuVwXyZ";
629 uint8_t *found = Bs2bmNocaseWrapper(text, needle, 1);
630 //printf("found: %s\n", found);
631 if (found != NULL)
632 return 1;
633 else
634 return 0;
635 }
636
637 /**
638 * \test Generic test for boyer moore matching
639 */
UtilSpmBoyerMooreSearchTest01(void)640 static int UtilSpmBoyerMooreSearchTest01(void)
641 {
642 uint8_t *needle = (uint8_t *)"oPqRsT";
643 uint8_t *text = (uint8_t *)"aBcDeFgHiJkLmNoPqRsTuVwXyZ";
644 uint8_t *found = BoyerMooreWrapper(text, needle, 1);
645 //printf("found: %s\n", found);
646 if (found != NULL)
647 return 1;
648 else
649 return 0;
650 }
651
652 /**
653 * \test Generic test for boyer moore nocase matching
654 */
UtilSpmBoyerMooreSearchNocaseTest01(void)655 static int UtilSpmBoyerMooreSearchNocaseTest01(void)
656 {
657 uint8_t *needle = (uint8_t *)"OpQrSt";
658 uint8_t *text = (uint8_t *)"aBcDeFgHiJkLmNoPqRsTuVwXyZ";
659 uint8_t *found = BoyerMooreNocaseWrapper(text, needle, 1);
660 //printf("found: %s\n", found);
661 if (found != NULL)
662 return 1;
663 else
664 return 0;
665 }
666
667 /**
668 * \test issue 130 (@redmine) check to ensure that the
669 * problem is not the algorithm implementation
670 */
UtilSpmBoyerMooreSearchNocaseTestIssue130(void)671 static int UtilSpmBoyerMooreSearchNocaseTestIssue130(void)
672 {
673 uint8_t *needle = (uint8_t *)"WWW-Authenticate: ";
674 uint8_t *text = (uint8_t *)"Date: Mon, 23 Feb 2009 13:31:49 GMT"
675 "Server: Apache\r\n"
676 "Www-authenticate: Basic realm=\"Authentification user password\"\r\n"
677 "Vary: accept-language,accept-charset\r\n"
678 "Accept-ranges: bytes\r\n"
679 "Connection: close\r\n"
680 "Content-type: text/html; charset=iso-8859-1\r\n"
681 "Content-language: fr\r\n"
682 "Expires: Mon, 23 Feb 2009 13:31:49 GMT\r\n\r\n";
683 uint8_t *found = BoyerMooreNocaseWrapper(text, needle, 1);
684 //printf("found: %s\n", found);
685 if (found != NULL)
686 return 1;
687 else
688 return 0;
689 }
690
691 /* Generic tests that should not match */
UtilSpmBasicSearchTest02(void)692 static int UtilSpmBasicSearchTest02(void)
693 {
694 uint8_t *needle = (uint8_t *)"oPQRsT";
695 uint8_t *text = (uint8_t *)"aBcDeFgHiJkLmNoPqRsTuVwXyZ";
696 uint8_t *found = BasicSearchWrapper(text, needle, 1);
697 //printf("found: %s\n", found);
698 if (found != NULL)
699 return 0;
700 else
701 return 1;
702 }
703
UtilSpmBasicSearchNocaseTest02(void)704 static int UtilSpmBasicSearchNocaseTest02(void)
705 {
706 uint8_t *needle = (uint8_t *)"OpZrSt";
707 uint8_t *text = (uint8_t *)"aBcDeFgHiJkLmNoPqRsTuVwXyZ";
708 uint8_t *found = BasicSearchNocaseWrapper(text, needle, 1);
709 //printf("found: %s\n", found);
710 if (found != NULL)
711 return 0;
712 else
713 return 1;
714 }
715
UtilSpmBs2bmSearchTest02(void)716 static int UtilSpmBs2bmSearchTest02(void)
717 {
718 uint8_t *needle = (uint8_t *)"oPQRsT";
719 uint8_t *text = (uint8_t *)"aBcDeFgHiJkLmNoPqRsTuVwXyZ";
720 uint8_t *found = Bs2bmWrapper(text, needle, 1);
721 //printf("found: %s\n", found);
722 if (found != NULL)
723 return 0;
724 else
725 return 1;
726 }
727
UtilSpmBs2bmSearchNocaseTest02(void)728 static int UtilSpmBs2bmSearchNocaseTest02(void)
729 {
730 uint8_t *needle = (uint8_t *)"OpZrSt";
731 uint8_t *text = (uint8_t *)"aBcDeFgHiJkLmNoPqRsTuVwXyZ";
732 uint8_t *found = Bs2bmNocaseWrapper(text, needle, 1);
733 //printf("found: %s\n", found);
734 if (found != NULL)
735 return 0;
736 else
737 return 1;
738 }
739
UtilSpmBoyerMooreSearchTest02(void)740 static int UtilSpmBoyerMooreSearchTest02(void)
741 {
742 uint8_t *needle = (uint8_t *)"oPQRsT";
743 uint8_t *text = (uint8_t *)"aBcDeFgHiJkLmNoPqRsTuVwXyZ";
744 uint8_t *found = BoyerMooreWrapper(text, needle, 1);
745 //printf("found: %s\n", found);
746 if (found != NULL)
747 return 0;
748 else
749 return 1;
750 }
751
UtilSpmBoyerMooreSearchNocaseTest02(void)752 static int UtilSpmBoyerMooreSearchNocaseTest02(void)
753 {
754 uint8_t *needle = (uint8_t *)"OpZrSt";
755 uint8_t *text = (uint8_t *)"aBcDeFgHiJkLmNoPqRsTuVwXyZ";
756 uint8_t *found = BoyerMooreNocaseWrapper(text, needle, 1);
757 //printf("found: %s\n", found);
758 if (found != NULL)
759 return 0;
760 else
761 return 1;
762 }
763
764 /**
765 * \test Check that all the algorithms work at any offset and any pattern length
766 */
UtilSpmSearchOffsetsTest01(void)767 static int UtilSpmSearchOffsetsTest01(void)
768 {
769 const char *text[26][27];
770 text[0][0]="azzzzzzzzzzzzzzzzzzzzzzzzzz";
771 text[0][1]="zazzzzzzzzzzzzzzzzzzzzzzzzz";
772 text[0][2]="zzazzzzzzzzzzzzzzzzzzzzzzzz";
773 text[0][3]="zzzazzzzzzzzzzzzzzzzzzzzzzz";
774 text[0][4]="zzzzazzzzzzzzzzzzzzzzzzzzzz";
775 text[0][5]="zzzzzazzzzzzzzzzzzzzzzzzzzz";
776 text[0][6]="zzzzzzazzzzzzzzzzzzzzzzzzzz";
777 text[0][7]="zzzzzzzazzzzzzzzzzzzzzzzzzz";
778 text[0][8]="zzzzzzzzazzzzzzzzzzzzzzzzzz";
779 text[0][9]="zzzzzzzzzazzzzzzzzzzzzzzzzz";
780 text[0][10]="zzzzzzzzzzazzzzzzzzzzzzzzzz";
781 text[0][11]="zzzzzzzzzzzazzzzzzzzzzzzzzz";
782 text[0][12]="zzzzzzzzzzzzazzzzzzzzzzzzzz";
783 text[0][13]="zzzzzzzzzzzzzazzzzzzzzzzzzz";
784 text[0][14]="zzzzzzzzzzzzzzazzzzzzzzzzzz";
785 text[0][15]="zzzzzzzzzzzzzzzazzzzzzzzzzz";
786 text[0][16]="zzzzzzzzzzzzzzzzazzzzzzzzzz";
787 text[0][17]="zzzzzzzzzzzzzzzzzazzzzzzzzz";
788 text[0][18]="zzzzzzzzzzzzzzzzzzazzzzzzzz";
789 text[0][19]="zzzzzzzzzzzzzzzzzzzazzzzzzz";
790 text[0][20]="zzzzzzzzzzzzzzzzzzzzazzzzzz";
791 text[0][21]="zzzzzzzzzzzzzzzzzzzzzazzzzz";
792 text[0][22]="zzzzzzzzzzzzzzzzzzzzzzazzzz";
793 text[0][23]="zzzzzzzzzzzzzzzzzzzzzzzazzz";
794 text[0][24]="zzzzzzzzzzzzzzzzzzzzzzzzazz";
795 text[0][25]="zzzzzzzzzzzzzzzzzzzzzzzzzaz";
796 text[0][26]="zzzzzzzzzzzzzzzzzzzzzzzzzza";
797 text[1][0]="aBzzzzzzzzzzzzzzzzzzzzzzzzz";
798 text[1][1]="zaBzzzzzzzzzzzzzzzzzzzzzzzz";
799 text[1][2]="zzaBzzzzzzzzzzzzzzzzzzzzzzz";
800 text[1][3]="zzzaBzzzzzzzzzzzzzzzzzzzzzz";
801 text[1][4]="zzzzaBzzzzzzzzzzzzzzzzzzzzz";
802 text[1][5]="zzzzzaBzzzzzzzzzzzzzzzzzzzz";
803 text[1][6]="zzzzzzaBzzzzzzzzzzzzzzzzzzz";
804 text[1][7]="zzzzzzzaBzzzzzzzzzzzzzzzzzz";
805 text[1][8]="zzzzzzzzaBzzzzzzzzzzzzzzzzz";
806 text[1][9]="zzzzzzzzzaBzzzzzzzzzzzzzzzz";
807 text[1][10]="zzzzzzzzzzaBzzzzzzzzzzzzzzz";
808 text[1][11]="zzzzzzzzzzzaBzzzzzzzzzzzzzz";
809 text[1][12]="zzzzzzzzzzzzaBzzzzzzzzzzzzz";
810 text[1][13]="zzzzzzzzzzzzzaBzzzzzzzzzzzz";
811 text[1][14]="zzzzzzzzzzzzzzaBzzzzzzzzzzz";
812 text[1][15]="zzzzzzzzzzzzzzzaBzzzzzzzzzz";
813 text[1][16]="zzzzzzzzzzzzzzzzaBzzzzzzzzz";
814 text[1][17]="zzzzzzzzzzzzzzzzzaBzzzzzzzz";
815 text[1][18]="zzzzzzzzzzzzzzzzzzaBzzzzzzz";
816 text[1][19]="zzzzzzzzzzzzzzzzzzzaBzzzzzz";
817 text[1][20]="zzzzzzzzzzzzzzzzzzzzaBzzzzz";
818 text[1][21]="zzzzzzzzzzzzzzzzzzzzzaBzzzz";
819 text[1][22]="zzzzzzzzzzzzzzzzzzzzzzaBzzz";
820 text[1][23]="zzzzzzzzzzzzzzzzzzzzzzzaBzz";
821 text[1][24]="zzzzzzzzzzzzzzzzzzzzzzzzaBz";
822 text[1][25]="zzzzzzzzzzzzzzzzzzzzzzzzzaB";
823 text[2][0]="aBczzzzzzzzzzzzzzzzzzzzzzzz";
824 text[2][1]="zaBczzzzzzzzzzzzzzzzzzzzzzz";
825 text[2][2]="zzaBczzzzzzzzzzzzzzzzzzzzzz";
826 text[2][3]="zzzaBczzzzzzzzzzzzzzzzzzzzz";
827 text[2][4]="zzzzaBczzzzzzzzzzzzzzzzzzzz";
828 text[2][5]="zzzzzaBczzzzzzzzzzzzzzzzzzz";
829 text[2][6]="zzzzzzaBczzzzzzzzzzzzzzzzzz";
830 text[2][7]="zzzzzzzaBczzzzzzzzzzzzzzzzz";
831 text[2][8]="zzzzzzzzaBczzzzzzzzzzzzzzzz";
832 text[2][9]="zzzzzzzzzaBczzzzzzzzzzzzzzz";
833 text[2][10]="zzzzzzzzzzaBczzzzzzzzzzzzzz";
834 text[2][11]="zzzzzzzzzzzaBczzzzzzzzzzzzz";
835 text[2][12]="zzzzzzzzzzzzaBczzzzzzzzzzzz";
836 text[2][13]="zzzzzzzzzzzzzaBczzzzzzzzzzz";
837 text[2][14]="zzzzzzzzzzzzzzaBczzzzzzzzzz";
838 text[2][15]="zzzzzzzzzzzzzzzaBczzzzzzzzz";
839 text[2][16]="zzzzzzzzzzzzzzzzaBczzzzzzzz";
840 text[2][17]="zzzzzzzzzzzzzzzzzaBczzzzzzz";
841 text[2][18]="zzzzzzzzzzzzzzzzzzaBczzzzzz";
842 text[2][19]="zzzzzzzzzzzzzzzzzzzaBczzzzz";
843 text[2][20]="zzzzzzzzzzzzzzzzzzzzaBczzzz";
844 text[2][21]="zzzzzzzzzzzzzzzzzzzzzaBczzz";
845 text[2][22]="zzzzzzzzzzzzzzzzzzzzzzaBczz";
846 text[2][23]="zzzzzzzzzzzzzzzzzzzzzzzaBcz";
847 text[2][24]="zzzzzzzzzzzzzzzzzzzzzzzzaBc";
848 text[3][0]="aBcDzzzzzzzzzzzzzzzzzzzzzzz";
849 text[3][1]="zaBcDzzzzzzzzzzzzzzzzzzzzzz";
850 text[3][2]="zzaBcDzzzzzzzzzzzzzzzzzzzzz";
851 text[3][3]="zzzaBcDzzzzzzzzzzzzzzzzzzzz";
852 text[3][4]="zzzzaBcDzzzzzzzzzzzzzzzzzzz";
853 text[3][5]="zzzzzaBcDzzzzzzzzzzzzzzzzzz";
854 text[3][6]="zzzzzzaBcDzzzzzzzzzzzzzzzzz";
855 text[3][7]="zzzzzzzaBcDzzzzzzzzzzzzzzzz";
856 text[3][8]="zzzzzzzzaBcDzzzzzzzzzzzzzzz";
857 text[3][9]="zzzzzzzzzaBcDzzzzzzzzzzzzzz";
858 text[3][10]="zzzzzzzzzzaBcDzzzzzzzzzzzzz";
859 text[3][11]="zzzzzzzzzzzaBcDzzzzzzzzzzzz";
860 text[3][12]="zzzzzzzzzzzzaBcDzzzzzzzzzzz";
861 text[3][13]="zzzzzzzzzzzzzaBcDzzzzzzzzzz";
862 text[3][14]="zzzzzzzzzzzzzzaBcDzzzzzzzzz";
863 text[3][15]="zzzzzzzzzzzzzzzaBcDzzzzzzzz";
864 text[3][16]="zzzzzzzzzzzzzzzzaBcDzzzzzzz";
865 text[3][17]="zzzzzzzzzzzzzzzzzaBcDzzzzzz";
866 text[3][18]="zzzzzzzzzzzzzzzzzzaBcDzzzzz";
867 text[3][19]="zzzzzzzzzzzzzzzzzzzaBcDzzzz";
868 text[3][20]="zzzzzzzzzzzzzzzzzzzzaBcDzzz";
869 text[3][21]="zzzzzzzzzzzzzzzzzzzzzaBcDzz";
870 text[3][22]="zzzzzzzzzzzzzzzzzzzzzzaBcDz";
871 text[3][23]="zzzzzzzzzzzzzzzzzzzzzzzaBcD";
872 text[4][0]="aBcDezzzzzzzzzzzzzzzzzzzzzz";
873 text[4][1]="zaBcDezzzzzzzzzzzzzzzzzzzzz";
874 text[4][2]="zzaBcDezzzzzzzzzzzzzzzzzzzz";
875 text[4][3]="zzzaBcDezzzzzzzzzzzzzzzzzzz";
876 text[4][4]="zzzzaBcDezzzzzzzzzzzzzzzzzz";
877 text[4][5]="zzzzzaBcDezzzzzzzzzzzzzzzzz";
878 text[4][6]="zzzzzzaBcDezzzzzzzzzzzzzzzz";
879 text[4][7]="zzzzzzzaBcDezzzzzzzzzzzzzzz";
880 text[4][8]="zzzzzzzzaBcDezzzzzzzzzzzzzz";
881 text[4][9]="zzzzzzzzzaBcDezzzzzzzzzzzzz";
882 text[4][10]="zzzzzzzzzzaBcDezzzzzzzzzzzz";
883 text[4][11]="zzzzzzzzzzzaBcDezzzzzzzzzzz";
884 text[4][12]="zzzzzzzzzzzzaBcDezzzzzzzzzz";
885 text[4][13]="zzzzzzzzzzzzzaBcDezzzzzzzzz";
886 text[4][14]="zzzzzzzzzzzzzzaBcDezzzzzzzz";
887 text[4][15]="zzzzzzzzzzzzzzzaBcDezzzzzzz";
888 text[4][16]="zzzzzzzzzzzzzzzzaBcDezzzzzz";
889 text[4][17]="zzzzzzzzzzzzzzzzzaBcDezzzzz";
890 text[4][18]="zzzzzzzzzzzzzzzzzzaBcDezzzz";
891 text[4][19]="zzzzzzzzzzzzzzzzzzzaBcDezzz";
892 text[4][20]="zzzzzzzzzzzzzzzzzzzzaBcDezz";
893 text[4][21]="zzzzzzzzzzzzzzzzzzzzzaBcDez";
894 text[4][22]="zzzzzzzzzzzzzzzzzzzzzzaBcDe";
895 text[5][0]="aBcDeFzzzzzzzzzzzzzzzzzzzzz";
896 text[5][1]="zaBcDeFzzzzzzzzzzzzzzzzzzzz";
897 text[5][2]="zzaBcDeFzzzzzzzzzzzzzzzzzzz";
898 text[5][3]="zzzaBcDeFzzzzzzzzzzzzzzzzzz";
899 text[5][4]="zzzzaBcDeFzzzzzzzzzzzzzzzzz";
900 text[5][5]="zzzzzaBcDeFzzzzzzzzzzzzzzzz";
901 text[5][6]="zzzzzzaBcDeFzzzzzzzzzzzzzzz";
902 text[5][7]="zzzzzzzaBcDeFzzzzzzzzzzzzzz";
903 text[5][8]="zzzzzzzzaBcDeFzzzzzzzzzzzzz";
904 text[5][9]="zzzzzzzzzaBcDeFzzzzzzzzzzzz";
905 text[5][10]="zzzzzzzzzzaBcDeFzzzzzzzzzzz";
906 text[5][11]="zzzzzzzzzzzaBcDeFzzzzzzzzzz";
907 text[5][12]="zzzzzzzzzzzzaBcDeFzzzzzzzzz";
908 text[5][13]="zzzzzzzzzzzzzaBcDeFzzzzzzzz";
909 text[5][14]="zzzzzzzzzzzzzzaBcDeFzzzzzzz";
910 text[5][15]="zzzzzzzzzzzzzzzaBcDeFzzzzzz";
911 text[5][16]="zzzzzzzzzzzzzzzzaBcDeFzzzzz";
912 text[5][17]="zzzzzzzzzzzzzzzzzaBcDeFzzzz";
913 text[5][18]="zzzzzzzzzzzzzzzzzzaBcDeFzzz";
914 text[5][19]="zzzzzzzzzzzzzzzzzzzaBcDeFzz";
915 text[5][20]="zzzzzzzzzzzzzzzzzzzzaBcDeFz";
916 text[5][21]="zzzzzzzzzzzzzzzzzzzzzaBcDeF";
917 text[6][0]="aBcDeFgzzzzzzzzzzzzzzzzzzzz";
918 text[6][1]="zaBcDeFgzzzzzzzzzzzzzzzzzzz";
919 text[6][2]="zzaBcDeFgzzzzzzzzzzzzzzzzzz";
920 text[6][3]="zzzaBcDeFgzzzzzzzzzzzzzzzzz";
921 text[6][4]="zzzzaBcDeFgzzzzzzzzzzzzzzzz";
922 text[6][5]="zzzzzaBcDeFgzzzzzzzzzzzzzzz";
923 text[6][6]="zzzzzzaBcDeFgzzzzzzzzzzzzzz";
924 text[6][7]="zzzzzzzaBcDeFgzzzzzzzzzzzzz";
925 text[6][8]="zzzzzzzzaBcDeFgzzzzzzzzzzzz";
926 text[6][9]="zzzzzzzzzaBcDeFgzzzzzzzzzzz";
927 text[6][10]="zzzzzzzzzzaBcDeFgzzzzzzzzzz";
928 text[6][11]="zzzzzzzzzzzaBcDeFgzzzzzzzzz";
929 text[6][12]="zzzzzzzzzzzzaBcDeFgzzzzzzzz";
930 text[6][13]="zzzzzzzzzzzzzaBcDeFgzzzzzzz";
931 text[6][14]="zzzzzzzzzzzzzzaBcDeFgzzzzzz";
932 text[6][15]="zzzzzzzzzzzzzzzaBcDeFgzzzzz";
933 text[6][16]="zzzzzzzzzzzzzzzzaBcDeFgzzzz";
934 text[6][17]="zzzzzzzzzzzzzzzzzaBcDeFgzzz";
935 text[6][18]="zzzzzzzzzzzzzzzzzzaBcDeFgzz";
936 text[6][19]="zzzzzzzzzzzzzzzzzzzaBcDeFgz";
937 text[6][20]="zzzzzzzzzzzzzzzzzzzzaBcDeFg";
938 text[7][0]="aBcDeFgHzzzzzzzzzzzzzzzzzzz";
939 text[7][1]="zaBcDeFgHzzzzzzzzzzzzzzzzzz";
940 text[7][2]="zzaBcDeFgHzzzzzzzzzzzzzzzzz";
941 text[7][3]="zzzaBcDeFgHzzzzzzzzzzzzzzzz";
942 text[7][4]="zzzzaBcDeFgHzzzzzzzzzzzzzzz";
943 text[7][5]="zzzzzaBcDeFgHzzzzzzzzzzzzzz";
944 text[7][6]="zzzzzzaBcDeFgHzzzzzzzzzzzzz";
945 text[7][7]="zzzzzzzaBcDeFgHzzzzzzzzzzzz";
946 text[7][8]="zzzzzzzzaBcDeFgHzzzzzzzzzzz";
947 text[7][9]="zzzzzzzzzaBcDeFgHzzzzzzzzzz";
948 text[7][10]="zzzzzzzzzzaBcDeFgHzzzzzzzzz";
949 text[7][11]="zzzzzzzzzzzaBcDeFgHzzzzzzzz";
950 text[7][12]="zzzzzzzzzzzzaBcDeFgHzzzzzzz";
951 text[7][13]="zzzzzzzzzzzzzaBcDeFgHzzzzzz";
952 text[7][14]="zzzzzzzzzzzzzzaBcDeFgHzzzzz";
953 text[7][15]="zzzzzzzzzzzzzzzaBcDeFgHzzzz";
954 text[7][16]="zzzzzzzzzzzzzzzzaBcDeFgHzzz";
955 text[7][17]="zzzzzzzzzzzzzzzzzaBcDeFgHzz";
956 text[7][18]="zzzzzzzzzzzzzzzzzzaBcDeFgHz";
957 text[7][19]="zzzzzzzzzzzzzzzzzzzaBcDeFgH";
958 text[8][0]="aBcDeFgHizzzzzzzzzzzzzzzzzz";
959 text[8][1]="zaBcDeFgHizzzzzzzzzzzzzzzzz";
960 text[8][2]="zzaBcDeFgHizzzzzzzzzzzzzzzz";
961 text[8][3]="zzzaBcDeFgHizzzzzzzzzzzzzzz";
962 text[8][4]="zzzzaBcDeFgHizzzzzzzzzzzzzz";
963 text[8][5]="zzzzzaBcDeFgHizzzzzzzzzzzzz";
964 text[8][6]="zzzzzzaBcDeFgHizzzzzzzzzzzz";
965 text[8][7]="zzzzzzzaBcDeFgHizzzzzzzzzzz";
966 text[8][8]="zzzzzzzzaBcDeFgHizzzzzzzzzz";
967 text[8][9]="zzzzzzzzzaBcDeFgHizzzzzzzzz";
968 text[8][10]="zzzzzzzzzzaBcDeFgHizzzzzzzz";
969 text[8][11]="zzzzzzzzzzzaBcDeFgHizzzzzzz";
970 text[8][12]="zzzzzzzzzzzzaBcDeFgHizzzzzz";
971 text[8][13]="zzzzzzzzzzzzzaBcDeFgHizzzzz";
972 text[8][14]="zzzzzzzzzzzzzzaBcDeFgHizzzz";
973 text[8][15]="zzzzzzzzzzzzzzzaBcDeFgHizzz";
974 text[8][16]="zzzzzzzzzzzzzzzzaBcDeFgHizz";
975 text[8][17]="zzzzzzzzzzzzzzzzzaBcDeFgHiz";
976 text[8][18]="zzzzzzzzzzzzzzzzzzaBcDeFgHi";
977 text[9][0]="aBcDeFgHiJzzzzzzzzzzzzzzzzz";
978 text[9][1]="zaBcDeFgHiJzzzzzzzzzzzzzzzz";
979 text[9][2]="zzaBcDeFgHiJzzzzzzzzzzzzzzz";
980 text[9][3]="zzzaBcDeFgHiJzzzzzzzzzzzzzz";
981 text[9][4]="zzzzaBcDeFgHiJzzzzzzzzzzzzz";
982 text[9][5]="zzzzzaBcDeFgHiJzzzzzzzzzzzz";
983 text[9][6]="zzzzzzaBcDeFgHiJzzzzzzzzzzz";
984 text[9][7]="zzzzzzzaBcDeFgHiJzzzzzzzzzz";
985 text[9][8]="zzzzzzzzaBcDeFgHiJzzzzzzzzz";
986 text[9][9]="zzzzzzzzzaBcDeFgHiJzzzzzzzz";
987 text[9][10]="zzzzzzzzzzaBcDeFgHiJzzzzzzz";
988 text[9][11]="zzzzzzzzzzzaBcDeFgHiJzzzzzz";
989 text[9][12]="zzzzzzzzzzzzaBcDeFgHiJzzzzz";
990 text[9][13]="zzzzzzzzzzzzzaBcDeFgHiJzzzz";
991 text[9][14]="zzzzzzzzzzzzzzaBcDeFgHiJzzz";
992 text[9][15]="zzzzzzzzzzzzzzzaBcDeFgHiJzz";
993 text[9][16]="zzzzzzzzzzzzzzzzaBcDeFgHiJz";
994 text[9][17]="zzzzzzzzzzzzzzzzzaBcDeFgHiJ";
995 text[10][0]="aBcDeFgHiJkzzzzzzzzzzzzzzzz";
996 text[10][1]="zaBcDeFgHiJkzzzzzzzzzzzzzzz";
997 text[10][2]="zzaBcDeFgHiJkzzzzzzzzzzzzzz";
998 text[10][3]="zzzaBcDeFgHiJkzzzzzzzzzzzzz";
999 text[10][4]="zzzzaBcDeFgHiJkzzzzzzzzzzzz";
1000 text[10][5]="zzzzzaBcDeFgHiJkzzzzzzzzzzz";
1001 text[10][6]="zzzzzzaBcDeFgHiJkzzzzzzzzzz";
1002 text[10][7]="zzzzzzzaBcDeFgHiJkzzzzzzzzz";
1003 text[10][8]="zzzzzzzzaBcDeFgHiJkzzzzzzzz";
1004 text[10][9]="zzzzzzzzzaBcDeFgHiJkzzzzzzz";
1005 text[10][10]="zzzzzzzzzzaBcDeFgHiJkzzzzzz";
1006 text[10][11]="zzzzzzzzzzzaBcDeFgHiJkzzzzz";
1007 text[10][12]="zzzzzzzzzzzzaBcDeFgHiJkzzzz";
1008 text[10][13]="zzzzzzzzzzzzzaBcDeFgHiJkzzz";
1009 text[10][14]="zzzzzzzzzzzzzzaBcDeFgHiJkzz";
1010 text[10][15]="zzzzzzzzzzzzzzzaBcDeFgHiJkz";
1011 text[10][16]="zzzzzzzzzzzzzzzzaBcDeFgHiJk";
1012 text[11][0]="aBcDeFgHiJkLzzzzzzzzzzzzzzz";
1013 text[11][1]="zaBcDeFgHiJkLzzzzzzzzzzzzzz";
1014 text[11][2]="zzaBcDeFgHiJkLzzzzzzzzzzzzz";
1015 text[11][3]="zzzaBcDeFgHiJkLzzzzzzzzzzzz";
1016 text[11][4]="zzzzaBcDeFgHiJkLzzzzzzzzzzz";
1017 text[11][5]="zzzzzaBcDeFgHiJkLzzzzzzzzzz";
1018 text[11][6]="zzzzzzaBcDeFgHiJkLzzzzzzzzz";
1019 text[11][7]="zzzzzzzaBcDeFgHiJkLzzzzzzzz";
1020 text[11][8]="zzzzzzzzaBcDeFgHiJkLzzzzzzz";
1021 text[11][9]="zzzzzzzzzaBcDeFgHiJkLzzzzzz";
1022 text[11][10]="zzzzzzzzzzaBcDeFgHiJkLzzzzz";
1023 text[11][11]="zzzzzzzzzzzaBcDeFgHiJkLzzzz";
1024 text[11][12]="zzzzzzzzzzzzaBcDeFgHiJkLzzz";
1025 text[11][13]="zzzzzzzzzzzzzaBcDeFgHiJkLzz";
1026 text[11][14]="zzzzzzzzzzzzzzaBcDeFgHiJkLz";
1027 text[11][15]="zzzzzzzzzzzzzzzaBcDeFgHiJkL";
1028 text[12][0]="aBcDeFgHiJkLmzzzzzzzzzzzzzz";
1029 text[12][1]="zaBcDeFgHiJkLmzzzzzzzzzzzzz";
1030 text[12][2]="zzaBcDeFgHiJkLmzzzzzzzzzzzz";
1031 text[12][3]="zzzaBcDeFgHiJkLmzzzzzzzzzzz";
1032 text[12][4]="zzzzaBcDeFgHiJkLmzzzzzzzzzz";
1033 text[12][5]="zzzzzaBcDeFgHiJkLmzzzzzzzzz";
1034 text[12][6]="zzzzzzaBcDeFgHiJkLmzzzzzzzz";
1035 text[12][7]="zzzzzzzaBcDeFgHiJkLmzzzzzzz";
1036 text[12][8]="zzzzzzzzaBcDeFgHiJkLmzzzzzz";
1037 text[12][9]="zzzzzzzzzaBcDeFgHiJkLmzzzzz";
1038 text[12][10]="zzzzzzzzzzaBcDeFgHiJkLmzzzz";
1039 text[12][11]="zzzzzzzzzzzaBcDeFgHiJkLmzzz";
1040 text[12][12]="zzzzzzzzzzzzaBcDeFgHiJkLmzz";
1041 text[12][13]="zzzzzzzzzzzzzaBcDeFgHiJkLmz";
1042 text[12][14]="zzzzzzzzzzzzzzaBcDeFgHiJkLm";
1043 text[13][0]="aBcDeFgHiJkLmNzzzzzzzzzzzzz";
1044 text[13][1]="zaBcDeFgHiJkLmNzzzzzzzzzzzz";
1045 text[13][2]="zzaBcDeFgHiJkLmNzzzzzzzzzzz";
1046 text[13][3]="zzzaBcDeFgHiJkLmNzzzzzzzzzz";
1047 text[13][4]="zzzzaBcDeFgHiJkLmNzzzzzzzzz";
1048 text[13][5]="zzzzzaBcDeFgHiJkLmNzzzzzzzz";
1049 text[13][6]="zzzzzzaBcDeFgHiJkLmNzzzzzzz";
1050 text[13][7]="zzzzzzzaBcDeFgHiJkLmNzzzzzz";
1051 text[13][8]="zzzzzzzzaBcDeFgHiJkLmNzzzzz";
1052 text[13][9]="zzzzzzzzzaBcDeFgHiJkLmNzzzz";
1053 text[13][10]="zzzzzzzzzzaBcDeFgHiJkLmNzzz";
1054 text[13][11]="zzzzzzzzzzzaBcDeFgHiJkLmNzz";
1055 text[13][12]="zzzzzzzzzzzzaBcDeFgHiJkLmNz";
1056 text[13][13]="zzzzzzzzzzzzzaBcDeFgHiJkLmN";
1057 text[14][0]="aBcDeFgHiJkLmNozzzzzzzzzzzz";
1058 text[14][1]="zaBcDeFgHiJkLmNozzzzzzzzzzz";
1059 text[14][2]="zzaBcDeFgHiJkLmNozzzzzzzzzz";
1060 text[14][3]="zzzaBcDeFgHiJkLmNozzzzzzzzz";
1061 text[14][4]="zzzzaBcDeFgHiJkLmNozzzzzzzz";
1062 text[14][5]="zzzzzaBcDeFgHiJkLmNozzzzzzz";
1063 text[14][6]="zzzzzzaBcDeFgHiJkLmNozzzzzz";
1064 text[14][7]="zzzzzzzaBcDeFgHiJkLmNozzzzz";
1065 text[14][8]="zzzzzzzzaBcDeFgHiJkLmNozzzz";
1066 text[14][9]="zzzzzzzzzaBcDeFgHiJkLmNozzz";
1067 text[14][10]="zzzzzzzzzzaBcDeFgHiJkLmNozz";
1068 text[14][11]="zzzzzzzzzzzaBcDeFgHiJkLmNoz";
1069 text[14][12]="zzzzzzzzzzzzaBcDeFgHiJkLmNo";
1070 text[15][0]="aBcDeFgHiJkLmNoPzzzzzzzzzzz";
1071 text[15][1]="zaBcDeFgHiJkLmNoPzzzzzzzzzz";
1072 text[15][2]="zzaBcDeFgHiJkLmNoPzzzzzzzzz";
1073 text[15][3]="zzzaBcDeFgHiJkLmNoPzzzzzzzz";
1074 text[15][4]="zzzzaBcDeFgHiJkLmNoPzzzzzzz";
1075 text[15][5]="zzzzzaBcDeFgHiJkLmNoPzzzzzz";
1076 text[15][6]="zzzzzzaBcDeFgHiJkLmNoPzzzzz";
1077 text[15][7]="zzzzzzzaBcDeFgHiJkLmNoPzzzz";
1078 text[15][8]="zzzzzzzzaBcDeFgHiJkLmNoPzzz";
1079 text[15][9]="zzzzzzzzzaBcDeFgHiJkLmNoPzz";
1080 text[15][10]="zzzzzzzzzzaBcDeFgHiJkLmNoPz";
1081 text[15][11]="zzzzzzzzzzzaBcDeFgHiJkLmNoP";
1082 text[16][0]="aBcDeFgHiJkLmNoPqzzzzzzzzzz";
1083 text[16][1]="zaBcDeFgHiJkLmNoPqzzzzzzzzz";
1084 text[16][2]="zzaBcDeFgHiJkLmNoPqzzzzzzzz";
1085 text[16][3]="zzzaBcDeFgHiJkLmNoPqzzzzzzz";
1086 text[16][4]="zzzzaBcDeFgHiJkLmNoPqzzzzzz";
1087 text[16][5]="zzzzzaBcDeFgHiJkLmNoPqzzzzz";
1088 text[16][6]="zzzzzzaBcDeFgHiJkLmNoPqzzzz";
1089 text[16][7]="zzzzzzzaBcDeFgHiJkLmNoPqzzz";
1090 text[16][8]="zzzzzzzzaBcDeFgHiJkLmNoPqzz";
1091 text[16][9]="zzzzzzzzzaBcDeFgHiJkLmNoPqz";
1092 text[16][10]="zzzzzzzzzzaBcDeFgHiJkLmNoPq";
1093 text[17][0]="aBcDeFgHiJkLmNoPqRzzzzzzzzz";
1094 text[17][1]="zaBcDeFgHiJkLmNoPqRzzzzzzzz";
1095 text[17][2]="zzaBcDeFgHiJkLmNoPqRzzzzzzz";
1096 text[17][3]="zzzaBcDeFgHiJkLmNoPqRzzzzzz";
1097 text[17][4]="zzzzaBcDeFgHiJkLmNoPqRzzzzz";
1098 text[17][5]="zzzzzaBcDeFgHiJkLmNoPqRzzzz";
1099 text[17][6]="zzzzzzaBcDeFgHiJkLmNoPqRzzz";
1100 text[17][7]="zzzzzzzaBcDeFgHiJkLmNoPqRzz";
1101 text[17][8]="zzzzzzzzaBcDeFgHiJkLmNoPqRz";
1102 text[17][9]="zzzzzzzzzaBcDeFgHiJkLmNoPqR";
1103 text[18][0]="aBcDeFgHiJkLmNoPqRszzzzzzzz";
1104 text[18][1]="zaBcDeFgHiJkLmNoPqRszzzzzzz";
1105 text[18][2]="zzaBcDeFgHiJkLmNoPqRszzzzzz";
1106 text[18][3]="zzzaBcDeFgHiJkLmNoPqRszzzzz";
1107 text[18][4]="zzzzaBcDeFgHiJkLmNoPqRszzzz";
1108 text[18][5]="zzzzzaBcDeFgHiJkLmNoPqRszzz";
1109 text[18][6]="zzzzzzaBcDeFgHiJkLmNoPqRszz";
1110 text[18][7]="zzzzzzzaBcDeFgHiJkLmNoPqRsz";
1111 text[18][8]="zzzzzzzzaBcDeFgHiJkLmNoPqRs";
1112 text[19][0]="aBcDeFgHiJkLmNoPqRsTzzzzzzz";
1113 text[19][1]="zaBcDeFgHiJkLmNoPqRsTzzzzzz";
1114 text[19][2]="zzaBcDeFgHiJkLmNoPqRsTzzzzz";
1115 text[19][3]="zzzaBcDeFgHiJkLmNoPqRsTzzzz";
1116 text[19][4]="zzzzaBcDeFgHiJkLmNoPqRsTzzz";
1117 text[19][5]="zzzzzaBcDeFgHiJkLmNoPqRsTzz";
1118 text[19][6]="zzzzzzaBcDeFgHiJkLmNoPqRsTz";
1119 text[19][7]="zzzzzzzaBcDeFgHiJkLmNoPqRsT";
1120 text[20][0]="aBcDeFgHiJkLmNoPqRsTuzzzzzz";
1121 text[20][1]="zaBcDeFgHiJkLmNoPqRsTuzzzzz";
1122 text[20][2]="zzaBcDeFgHiJkLmNoPqRsTuzzzz";
1123 text[20][3]="zzzaBcDeFgHiJkLmNoPqRsTuzzz";
1124 text[20][4]="zzzzaBcDeFgHiJkLmNoPqRsTuzz";
1125 text[20][5]="zzzzzaBcDeFgHiJkLmNoPqRsTuz";
1126 text[20][6]="zzzzzzaBcDeFgHiJkLmNoPqRsTu";
1127 text[21][0]="aBcDeFgHiJkLmNoPqRsTuVzzzzz";
1128 text[21][1]="zaBcDeFgHiJkLmNoPqRsTuVzzzz";
1129 text[21][2]="zzaBcDeFgHiJkLmNoPqRsTuVzzz";
1130 text[21][3]="zzzaBcDeFgHiJkLmNoPqRsTuVzz";
1131 text[21][4]="zzzzaBcDeFgHiJkLmNoPqRsTuVz";
1132 text[21][5]="zzzzzaBcDeFgHiJkLmNoPqRsTuV";
1133 text[22][0]="aBcDeFgHiJkLmNoPqRsTuVwzzzz";
1134 text[22][1]="zaBcDeFgHiJkLmNoPqRsTuVwzzz";
1135 text[22][2]="zzaBcDeFgHiJkLmNoPqRsTuVwzz";
1136 text[22][3]="zzzaBcDeFgHiJkLmNoPqRsTuVwz";
1137 text[22][4]="zzzzaBcDeFgHiJkLmNoPqRsTuVw";
1138 text[23][0]="aBcDeFgHiJkLmNoPqRsTuVwXzzz";
1139 text[23][1]="zaBcDeFgHiJkLmNoPqRsTuVwXzz";
1140 text[23][2]="zzaBcDeFgHiJkLmNoPqRsTuVwXz";
1141 text[23][3]="zzzaBcDeFgHiJkLmNoPqRsTuVwX";
1142 text[24][0]="aBcDeFgHiJkLmNoPqRsTuVwXyzz";
1143 text[24][1]="zaBcDeFgHiJkLmNoPqRsTuVwXyz";
1144 text[24][2]="zzaBcDeFgHiJkLmNoPqRsTuVwXy";
1145 text[25][0]="aBcDeFgHiJkLmNoPqRsTuVwXyZz";
1146 text[25][1]="zaBcDeFgHiJkLmNoPqRsTuVwXyZ";
1147
1148 const char *needle[26];
1149 needle[0]="a";
1150 needle[1]="aB";
1151 needle[2]="aBc";
1152 needle[3]="aBcD";
1153 needle[4]="aBcDe";
1154 needle[5]="aBcDeF";
1155 needle[6]="aBcDeFg";
1156 needle[7]="aBcDeFgH";
1157 needle[8]="aBcDeFgHi";
1158 needle[9]="aBcDeFgHiJ";
1159 needle[10]="aBcDeFgHiJk";
1160 needle[11]="aBcDeFgHiJkL";
1161 needle[12]="aBcDeFgHiJkLm";
1162 needle[13]="aBcDeFgHiJkLmN";
1163 needle[14]="aBcDeFgHiJkLmNo";
1164 needle[15]="aBcDeFgHiJkLmNoP";
1165 needle[16]="aBcDeFgHiJkLmNoPq";
1166 needle[17]="aBcDeFgHiJkLmNoPqR";
1167 needle[18]="aBcDeFgHiJkLmNoPqRs";
1168 needle[19]="aBcDeFgHiJkLmNoPqRsT";
1169 needle[20]="aBcDeFgHiJkLmNoPqRsTu";
1170 needle[21]="aBcDeFgHiJkLmNoPqRsTuV";
1171 needle[22]="aBcDeFgHiJkLmNoPqRsTuVw";
1172 needle[23]="aBcDeFgHiJkLmNoPqRsTuVwX";
1173 needle[24]="aBcDeFgHiJkLmNoPqRsTuVwXy";
1174 needle[25]="aBcDeFgHiJkLmNoPqRsTuVwXyZ";
1175
1176 int i, j;
1177 uint8_t *found = NULL;
1178 for (i = 0; i < 26; i++) {
1179 for (j = 0; j <= (26 - i); j++) {
1180 found = BasicSearchWrapper((uint8_t *)text[i][j], (uint8_t *)needle[i], 1);
1181 if (found == 0) {
1182 printf("Error1 searching for %s in text %s\n", needle[i], text[i][j]);
1183 return 0;
1184 }
1185 found = Bs2bmWrapper((uint8_t *)text[i][j], (uint8_t *)needle[i], 1);
1186 if (found == 0) {
1187 printf("Error2 searching for %s in text %s\n", needle[i], text[i][j]);
1188 return 0;
1189 }
1190 found = BoyerMooreWrapper((uint8_t *)text[i][j], (uint8_t *)needle[i], 1);
1191 if (found == 0) {
1192 printf("Error3 searching for %s in text %s\n", needle[i], text[i][j]);
1193 return 0;
1194 }
1195 }
1196 }
1197 return 1;
1198 }
1199
1200 /**
1201 * \test Check that all the algorithms (no case) work at any offset and any pattern length
1202 */
UtilSpmSearchOffsetsNocaseTest01(void)1203 static int UtilSpmSearchOffsetsNocaseTest01(void)
1204 {
1205 const char *text[26][27];
1206 text[0][0]="azzzzzzzzzzzzzzzzzzzzzzzzzz";
1207 text[0][1]="zazzzzzzzzzzzzzzzzzzzzzzzzz";
1208 text[0][2]="zzazzzzzzzzzzzzzzzzzzzzzzzz";
1209 text[0][3]="zzzazzzzzzzzzzzzzzzzzzzzzzz";
1210 text[0][4]="zzzzazzzzzzzzzzzzzzzzzzzzzz";
1211 text[0][5]="zzzzzazzzzzzzzzzzzzzzzzzzzz";
1212 text[0][6]="zzzzzzazzzzzzzzzzzzzzzzzzzz";
1213 text[0][7]="zzzzzzzazzzzzzzzzzzzzzzzzzz";
1214 text[0][8]="zzzzzzzzazzzzzzzzzzzzzzzzzz";
1215 text[0][9]="zzzzzzzzzazzzzzzzzzzzzzzzzz";
1216 text[0][10]="zzzzzzzzzzazzzzzzzzzzzzzzzz";
1217 text[0][11]="zzzzzzzzzzzazzzzzzzzzzzzzzz";
1218 text[0][12]="zzzzzzzzzzzzazzzzzzzzzzzzzz";
1219 text[0][13]="zzzzzzzzzzzzzazzzzzzzzzzzzz";
1220 text[0][14]="zzzzzzzzzzzzzzazzzzzzzzzzzz";
1221 text[0][15]="zzzzzzzzzzzzzzzazzzzzzzzzzz";
1222 text[0][16]="zzzzzzzzzzzzzzzzazzzzzzzzzz";
1223 text[0][17]="zzzzzzzzzzzzzzzzzazzzzzzzzz";
1224 text[0][18]="zzzzzzzzzzzzzzzzzzazzzzzzzz";
1225 text[0][19]="zzzzzzzzzzzzzzzzzzzazzzzzzz";
1226 text[0][20]="zzzzzzzzzzzzzzzzzzzzazzzzzz";
1227 text[0][21]="zzzzzzzzzzzzzzzzzzzzzazzzzz";
1228 text[0][22]="zzzzzzzzzzzzzzzzzzzzzzazzzz";
1229 text[0][23]="zzzzzzzzzzzzzzzzzzzzzzzazzz";
1230 text[0][24]="zzzzzzzzzzzzzzzzzzzzzzzzazz";
1231 text[0][25]="zzzzzzzzzzzzzzzzzzzzzzzzzaz";
1232 text[0][26]="zzzzzzzzzzzzzzzzzzzzzzzzzza";
1233 text[1][0]="aBzzzzzzzzzzzzzzzzzzzzzzzzz";
1234 text[1][1]="zaBzzzzzzzzzzzzzzzzzzzzzzzz";
1235 text[1][2]="zzaBzzzzzzzzzzzzzzzzzzzzzzz";
1236 text[1][3]="zzzaBzzzzzzzzzzzzzzzzzzzzzz";
1237 text[1][4]="zzzzaBzzzzzzzzzzzzzzzzzzzzz";
1238 text[1][5]="zzzzzaBzzzzzzzzzzzzzzzzzzzz";
1239 text[1][6]="zzzzzzaBzzzzzzzzzzzzzzzzzzz";
1240 text[1][7]="zzzzzzzaBzzzzzzzzzzzzzzzzzz";
1241 text[1][8]="zzzzzzzzaBzzzzzzzzzzzzzzzzz";
1242 text[1][9]="zzzzzzzzzaBzzzzzzzzzzzzzzzz";
1243 text[1][10]="zzzzzzzzzzaBzzzzzzzzzzzzzzz";
1244 text[1][11]="zzzzzzzzzzzaBzzzzzzzzzzzzzz";
1245 text[1][12]="zzzzzzzzzzzzaBzzzzzzzzzzzzz";
1246 text[1][13]="zzzzzzzzzzzzzaBzzzzzzzzzzzz";
1247 text[1][14]="zzzzzzzzzzzzzzaBzzzzzzzzzzz";
1248 text[1][15]="zzzzzzzzzzzzzzzaBzzzzzzzzzz";
1249 text[1][16]="zzzzzzzzzzzzzzzzaBzzzzzzzzz";
1250 text[1][17]="zzzzzzzzzzzzzzzzzaBzzzzzzzz";
1251 text[1][18]="zzzzzzzzzzzzzzzzzzaBzzzzzzz";
1252 text[1][19]="zzzzzzzzzzzzzzzzzzzaBzzzzzz";
1253 text[1][20]="zzzzzzzzzzzzzzzzzzzzaBzzzzz";
1254 text[1][21]="zzzzzzzzzzzzzzzzzzzzzaBzzzz";
1255 text[1][22]="zzzzzzzzzzzzzzzzzzzzzzaBzzz";
1256 text[1][23]="zzzzzzzzzzzzzzzzzzzzzzzaBzz";
1257 text[1][24]="zzzzzzzzzzzzzzzzzzzzzzzzaBz";
1258 text[1][25]="zzzzzzzzzzzzzzzzzzzzzzzzzaB";
1259 text[2][0]="aBczzzzzzzzzzzzzzzzzzzzzzzz";
1260 text[2][1]="zaBczzzzzzzzzzzzzzzzzzzzzzz";
1261 text[2][2]="zzaBczzzzzzzzzzzzzzzzzzzzzz";
1262 text[2][3]="zzzaBczzzzzzzzzzzzzzzzzzzzz";
1263 text[2][4]="zzzzaBczzzzzzzzzzzzzzzzzzzz";
1264 text[2][5]="zzzzzaBczzzzzzzzzzzzzzzzzzz";
1265 text[2][6]="zzzzzzaBczzzzzzzzzzzzzzzzzz";
1266 text[2][7]="zzzzzzzaBczzzzzzzzzzzzzzzzz";
1267 text[2][8]="zzzzzzzzaBczzzzzzzzzzzzzzzz";
1268 text[2][9]="zzzzzzzzzaBczzzzzzzzzzzzzzz";
1269 text[2][10]="zzzzzzzzzzaBczzzzzzzzzzzzzz";
1270 text[2][11]="zzzzzzzzzzzaBczzzzzzzzzzzzz";
1271 text[2][12]="zzzzzzzzzzzzaBczzzzzzzzzzzz";
1272 text[2][13]="zzzzzzzzzzzzzaBczzzzzzzzzzz";
1273 text[2][14]="zzzzzzzzzzzzzzaBczzzzzzzzzz";
1274 text[2][15]="zzzzzzzzzzzzzzzaBczzzzzzzzz";
1275 text[2][16]="zzzzzzzzzzzzzzzzaBczzzzzzzz";
1276 text[2][17]="zzzzzzzzzzzzzzzzzaBczzzzzzz";
1277 text[2][18]="zzzzzzzzzzzzzzzzzzaBczzzzzz";
1278 text[2][19]="zzzzzzzzzzzzzzzzzzzaBczzzzz";
1279 text[2][20]="zzzzzzzzzzzzzzzzzzzzaBczzzz";
1280 text[2][21]="zzzzzzzzzzzzzzzzzzzzzaBczzz";
1281 text[2][22]="zzzzzzzzzzzzzzzzzzzzzzaBczz";
1282 text[2][23]="zzzzzzzzzzzzzzzzzzzzzzzaBcz";
1283 text[2][24]="zzzzzzzzzzzzzzzzzzzzzzzzaBc";
1284 text[3][0]="aBcDzzzzzzzzzzzzzzzzzzzzzzz";
1285 text[3][1]="zaBcDzzzzzzzzzzzzzzzzzzzzzz";
1286 text[3][2]="zzaBcDzzzzzzzzzzzzzzzzzzzzz";
1287 text[3][3]="zzzaBcDzzzzzzzzzzzzzzzzzzzz";
1288 text[3][4]="zzzzaBcDzzzzzzzzzzzzzzzzzzz";
1289 text[3][5]="zzzzzaBcDzzzzzzzzzzzzzzzzzz";
1290 text[3][6]="zzzzzzaBcDzzzzzzzzzzzzzzzzz";
1291 text[3][7]="zzzzzzzaBcDzzzzzzzzzzzzzzzz";
1292 text[3][8]="zzzzzzzzaBcDzzzzzzzzzzzzzzz";
1293 text[3][9]="zzzzzzzzzaBcDzzzzzzzzzzzzzz";
1294 text[3][10]="zzzzzzzzzzaBcDzzzzzzzzzzzzz";
1295 text[3][11]="zzzzzzzzzzzaBcDzzzzzzzzzzzz";
1296 text[3][12]="zzzzzzzzzzzzaBcDzzzzzzzzzzz";
1297 text[3][13]="zzzzzzzzzzzzzaBcDzzzzzzzzzz";
1298 text[3][14]="zzzzzzzzzzzzzzaBcDzzzzzzzzz";
1299 text[3][15]="zzzzzzzzzzzzzzzaBcDzzzzzzzz";
1300 text[3][16]="zzzzzzzzzzzzzzzzaBcDzzzzzzz";
1301 text[3][17]="zzzzzzzzzzzzzzzzzaBcDzzzzzz";
1302 text[3][18]="zzzzzzzzzzzzzzzzzzaBcDzzzzz";
1303 text[3][19]="zzzzzzzzzzzzzzzzzzzaBcDzzzz";
1304 text[3][20]="zzzzzzzzzzzzzzzzzzzzaBcDzzz";
1305 text[3][21]="zzzzzzzzzzzzzzzzzzzzzaBcDzz";
1306 text[3][22]="zzzzzzzzzzzzzzzzzzzzzzaBcDz";
1307 text[3][23]="zzzzzzzzzzzzzzzzzzzzzzzaBcD";
1308 text[4][0]="aBcDezzzzzzzzzzzzzzzzzzzzzz";
1309 text[4][1]="zaBcDezzzzzzzzzzzzzzzzzzzzz";
1310 text[4][2]="zzaBcDezzzzzzzzzzzzzzzzzzzz";
1311 text[4][3]="zzzaBcDezzzzzzzzzzzzzzzzzzz";
1312 text[4][4]="zzzzaBcDezzzzzzzzzzzzzzzzzz";
1313 text[4][5]="zzzzzaBcDezzzzzzzzzzzzzzzzz";
1314 text[4][6]="zzzzzzaBcDezzzzzzzzzzzzzzzz";
1315 text[4][7]="zzzzzzzaBcDezzzzzzzzzzzzzzz";
1316 text[4][8]="zzzzzzzzaBcDezzzzzzzzzzzzzz";
1317 text[4][9]="zzzzzzzzzaBcDezzzzzzzzzzzzz";
1318 text[4][10]="zzzzzzzzzzaBcDezzzzzzzzzzzz";
1319 text[4][11]="zzzzzzzzzzzaBcDezzzzzzzzzzz";
1320 text[4][12]="zzzzzzzzzzzzaBcDezzzzzzzzzz";
1321 text[4][13]="zzzzzzzzzzzzzaBcDezzzzzzzzz";
1322 text[4][14]="zzzzzzzzzzzzzzaBcDezzzzzzzz";
1323 text[4][15]="zzzzzzzzzzzzzzzaBcDezzzzzzz";
1324 text[4][16]="zzzzzzzzzzzzzzzzaBcDezzzzzz";
1325 text[4][17]="zzzzzzzzzzzzzzzzzaBcDezzzzz";
1326 text[4][18]="zzzzzzzzzzzzzzzzzzaBcDezzzz";
1327 text[4][19]="zzzzzzzzzzzzzzzzzzzaBcDezzz";
1328 text[4][20]="zzzzzzzzzzzzzzzzzzzzaBcDezz";
1329 text[4][21]="zzzzzzzzzzzzzzzzzzzzzaBcDez";
1330 text[4][22]="zzzzzzzzzzzzzzzzzzzzzzaBcDe";
1331 text[5][0]="aBcDeFzzzzzzzzzzzzzzzzzzzzz";
1332 text[5][1]="zaBcDeFzzzzzzzzzzzzzzzzzzzz";
1333 text[5][2]="zzaBcDeFzzzzzzzzzzzzzzzzzzz";
1334 text[5][3]="zzzaBcDeFzzzzzzzzzzzzzzzzzz";
1335 text[5][4]="zzzzaBcDeFzzzzzzzzzzzzzzzzz";
1336 text[5][5]="zzzzzaBcDeFzzzzzzzzzzzzzzzz";
1337 text[5][6]="zzzzzzaBcDeFzzzzzzzzzzzzzzz";
1338 text[5][7]="zzzzzzzaBcDeFzzzzzzzzzzzzzz";
1339 text[5][8]="zzzzzzzzaBcDeFzzzzzzzzzzzzz";
1340 text[5][9]="zzzzzzzzzaBcDeFzzzzzzzzzzzz";
1341 text[5][10]="zzzzzzzzzzaBcDeFzzzzzzzzzzz";
1342 text[5][11]="zzzzzzzzzzzaBcDeFzzzzzzzzzz";
1343 text[5][12]="zzzzzzzzzzzzaBcDeFzzzzzzzzz";
1344 text[5][13]="zzzzzzzzzzzzzaBcDeFzzzzzzzz";
1345 text[5][14]="zzzzzzzzzzzzzzaBcDeFzzzzzzz";
1346 text[5][15]="zzzzzzzzzzzzzzzaBcDeFzzzzzz";
1347 text[5][16]="zzzzzzzzzzzzzzzzaBcDeFzzzzz";
1348 text[5][17]="zzzzzzzzzzzzzzzzzaBcDeFzzzz";
1349 text[5][18]="zzzzzzzzzzzzzzzzzzaBcDeFzzz";
1350 text[5][19]="zzzzzzzzzzzzzzzzzzzaBcDeFzz";
1351 text[5][20]="zzzzzzzzzzzzzzzzzzzzaBcDeFz";
1352 text[5][21]="zzzzzzzzzzzzzzzzzzzzzaBcDeF";
1353 text[6][0]="aBcDeFgzzzzzzzzzzzzzzzzzzzz";
1354 text[6][1]="zaBcDeFgzzzzzzzzzzzzzzzzzzz";
1355 text[6][2]="zzaBcDeFgzzzzzzzzzzzzzzzzzz";
1356 text[6][3]="zzzaBcDeFgzzzzzzzzzzzzzzzzz";
1357 text[6][4]="zzzzaBcDeFgzzzzzzzzzzzzzzzz";
1358 text[6][5]="zzzzzaBcDeFgzzzzzzzzzzzzzzz";
1359 text[6][6]="zzzzzzaBcDeFgzzzzzzzzzzzzzz";
1360 text[6][7]="zzzzzzzaBcDeFgzzzzzzzzzzzzz";
1361 text[6][8]="zzzzzzzzaBcDeFgzzzzzzzzzzzz";
1362 text[6][9]="zzzzzzzzzaBcDeFgzzzzzzzzzzz";
1363 text[6][10]="zzzzzzzzzzaBcDeFgzzzzzzzzzz";
1364 text[6][11]="zzzzzzzzzzzaBcDeFgzzzzzzzzz";
1365 text[6][12]="zzzzzzzzzzzzaBcDeFgzzzzzzzz";
1366 text[6][13]="zzzzzzzzzzzzzaBcDeFgzzzzzzz";
1367 text[6][14]="zzzzzzzzzzzzzzaBcDeFgzzzzzz";
1368 text[6][15]="zzzzzzzzzzzzzzzaBcDeFgzzzzz";
1369 text[6][16]="zzzzzzzzzzzzzzzzaBcDeFgzzzz";
1370 text[6][17]="zzzzzzzzzzzzzzzzzaBcDeFgzzz";
1371 text[6][18]="zzzzzzzzzzzzzzzzzzaBcDeFgzz";
1372 text[6][19]="zzzzzzzzzzzzzzzzzzzaBcDeFgz";
1373 text[6][20]="zzzzzzzzzzzzzzzzzzzzaBcDeFg";
1374 text[7][0]="aBcDeFgHzzzzzzzzzzzzzzzzzzz";
1375 text[7][1]="zaBcDeFgHzzzzzzzzzzzzzzzzzz";
1376 text[7][2]="zzaBcDeFgHzzzzzzzzzzzzzzzzz";
1377 text[7][3]="zzzaBcDeFgHzzzzzzzzzzzzzzzz";
1378 text[7][4]="zzzzaBcDeFgHzzzzzzzzzzzzzzz";
1379 text[7][5]="zzzzzaBcDeFgHzzzzzzzzzzzzzz";
1380 text[7][6]="zzzzzzaBcDeFgHzzzzzzzzzzzzz";
1381 text[7][7]="zzzzzzzaBcDeFgHzzzzzzzzzzzz";
1382 text[7][8]="zzzzzzzzaBcDeFgHzzzzzzzzzzz";
1383 text[7][9]="zzzzzzzzzaBcDeFgHzzzzzzzzzz";
1384 text[7][10]="zzzzzzzzzzaBcDeFgHzzzzzzzzz";
1385 text[7][11]="zzzzzzzzzzzaBcDeFgHzzzzzzzz";
1386 text[7][12]="zzzzzzzzzzzzaBcDeFgHzzzzzzz";
1387 text[7][13]="zzzzzzzzzzzzzaBcDeFgHzzzzzz";
1388 text[7][14]="zzzzzzzzzzzzzzaBcDeFgHzzzzz";
1389 text[7][15]="zzzzzzzzzzzzzzzaBcDeFgHzzzz";
1390 text[7][16]="zzzzzzzzzzzzzzzzaBcDeFgHzzz";
1391 text[7][17]="zzzzzzzzzzzzzzzzzaBcDeFgHzz";
1392 text[7][18]="zzzzzzzzzzzzzzzzzzaBcDeFgHz";
1393 text[7][19]="zzzzzzzzzzzzzzzzzzzaBcDeFgH";
1394 text[8][0]="aBcDeFgHizzzzzzzzzzzzzzzzzz";
1395 text[8][1]="zaBcDeFgHizzzzzzzzzzzzzzzzz";
1396 text[8][2]="zzaBcDeFgHizzzzzzzzzzzzzzzz";
1397 text[8][3]="zzzaBcDeFgHizzzzzzzzzzzzzzz";
1398 text[8][4]="zzzzaBcDeFgHizzzzzzzzzzzzzz";
1399 text[8][5]="zzzzzaBcDeFgHizzzzzzzzzzzzz";
1400 text[8][6]="zzzzzzaBcDeFgHizzzzzzzzzzzz";
1401 text[8][7]="zzzzzzzaBcDeFgHizzzzzzzzzzz";
1402 text[8][8]="zzzzzzzzaBcDeFgHizzzzzzzzzz";
1403 text[8][9]="zzzzzzzzzaBcDeFgHizzzzzzzzz";
1404 text[8][10]="zzzzzzzzzzaBcDeFgHizzzzzzzz";
1405 text[8][11]="zzzzzzzzzzzaBcDeFgHizzzzzzz";
1406 text[8][12]="zzzzzzzzzzzzaBcDeFgHizzzzzz";
1407 text[8][13]="zzzzzzzzzzzzzaBcDeFgHizzzzz";
1408 text[8][14]="zzzzzzzzzzzzzzaBcDeFgHizzzz";
1409 text[8][15]="zzzzzzzzzzzzzzzaBcDeFgHizzz";
1410 text[8][16]="zzzzzzzzzzzzzzzzaBcDeFgHizz";
1411 text[8][17]="zzzzzzzzzzzzzzzzzaBcDeFgHiz";
1412 text[8][18]="zzzzzzzzzzzzzzzzzzaBcDeFgHi";
1413 text[9][0]="aBcDeFgHiJzzzzzzzzzzzzzzzzz";
1414 text[9][1]="zaBcDeFgHiJzzzzzzzzzzzzzzzz";
1415 text[9][2]="zzaBcDeFgHiJzzzzzzzzzzzzzzz";
1416 text[9][3]="zzzaBcDeFgHiJzzzzzzzzzzzzzz";
1417 text[9][4]="zzzzaBcDeFgHiJzzzzzzzzzzzzz";
1418 text[9][5]="zzzzzaBcDeFgHiJzzzzzzzzzzzz";
1419 text[9][6]="zzzzzzaBcDeFgHiJzzzzzzzzzzz";
1420 text[9][7]="zzzzzzzaBcDeFgHiJzzzzzzzzzz";
1421 text[9][8]="zzzzzzzzaBcDeFgHiJzzzzzzzzz";
1422 text[9][9]="zzzzzzzzzaBcDeFgHiJzzzzzzzz";
1423 text[9][10]="zzzzzzzzzzaBcDeFgHiJzzzzzzz";
1424 text[9][11]="zzzzzzzzzzzaBcDeFgHiJzzzzzz";
1425 text[9][12]="zzzzzzzzzzzzaBcDeFgHiJzzzzz";
1426 text[9][13]="zzzzzzzzzzzzzaBcDeFgHiJzzzz";
1427 text[9][14]="zzzzzzzzzzzzzzaBcDeFgHiJzzz";
1428 text[9][15]="zzzzzzzzzzzzzzzaBcDeFgHiJzz";
1429 text[9][16]="zzzzzzzzzzzzzzzzaBcDeFgHiJz";
1430 text[9][17]="zzzzzzzzzzzzzzzzzaBcDeFgHiJ";
1431 text[10][0]="aBcDeFgHiJkzzzzzzzzzzzzzzzz";
1432 text[10][1]="zaBcDeFgHiJkzzzzzzzzzzzzzzz";
1433 text[10][2]="zzaBcDeFgHiJkzzzzzzzzzzzzzz";
1434 text[10][3]="zzzaBcDeFgHiJkzzzzzzzzzzzzz";
1435 text[10][4]="zzzzaBcDeFgHiJkzzzzzzzzzzzz";
1436 text[10][5]="zzzzzaBcDeFgHiJkzzzzzzzzzzz";
1437 text[10][6]="zzzzzzaBcDeFgHiJkzzzzzzzzzz";
1438 text[10][7]="zzzzzzzaBcDeFgHiJkzzzzzzzzz";
1439 text[10][8]="zzzzzzzzaBcDeFgHiJkzzzzzzzz";
1440 text[10][9]="zzzzzzzzzaBcDeFgHiJkzzzzzzz";
1441 text[10][10]="zzzzzzzzzzaBcDeFgHiJkzzzzzz";
1442 text[10][11]="zzzzzzzzzzzaBcDeFgHiJkzzzzz";
1443 text[10][12]="zzzzzzzzzzzzaBcDeFgHiJkzzzz";
1444 text[10][13]="zzzzzzzzzzzzzaBcDeFgHiJkzzz";
1445 text[10][14]="zzzzzzzzzzzzzzaBcDeFgHiJkzz";
1446 text[10][15]="zzzzzzzzzzzzzzzaBcDeFgHiJkz";
1447 text[10][16]="zzzzzzzzzzzzzzzzaBcDeFgHiJk";
1448 text[11][0]="aBcDeFgHiJkLzzzzzzzzzzzzzzz";
1449 text[11][1]="zaBcDeFgHiJkLzzzzzzzzzzzzzz";
1450 text[11][2]="zzaBcDeFgHiJkLzzzzzzzzzzzzz";
1451 text[11][3]="zzzaBcDeFgHiJkLzzzzzzzzzzzz";
1452 text[11][4]="zzzzaBcDeFgHiJkLzzzzzzzzzzz";
1453 text[11][5]="zzzzzaBcDeFgHiJkLzzzzzzzzzz";
1454 text[11][6]="zzzzzzaBcDeFgHiJkLzzzzzzzzz";
1455 text[11][7]="zzzzzzzaBcDeFgHiJkLzzzzzzzz";
1456 text[11][8]="zzzzzzzzaBcDeFgHiJkLzzzzzzz";
1457 text[11][9]="zzzzzzzzzaBcDeFgHiJkLzzzzzz";
1458 text[11][10]="zzzzzzzzzzaBcDeFgHiJkLzzzzz";
1459 text[11][11]="zzzzzzzzzzzaBcDeFgHiJkLzzzz";
1460 text[11][12]="zzzzzzzzzzzzaBcDeFgHiJkLzzz";
1461 text[11][13]="zzzzzzzzzzzzzaBcDeFgHiJkLzz";
1462 text[11][14]="zzzzzzzzzzzzzzaBcDeFgHiJkLz";
1463 text[11][15]="zzzzzzzzzzzzzzzaBcDeFgHiJkL";
1464 text[12][0]="aBcDeFgHiJkLmzzzzzzzzzzzzzz";
1465 text[12][1]="zaBcDeFgHiJkLmzzzzzzzzzzzzz";
1466 text[12][2]="zzaBcDeFgHiJkLmzzzzzzzzzzzz";
1467 text[12][3]="zzzaBcDeFgHiJkLmzzzzzzzzzzz";
1468 text[12][4]="zzzzaBcDeFgHiJkLmzzzzzzzzzz";
1469 text[12][5]="zzzzzaBcDeFgHiJkLmzzzzzzzzz";
1470 text[12][6]="zzzzzzaBcDeFgHiJkLmzzzzzzzz";
1471 text[12][7]="zzzzzzzaBcDeFgHiJkLmzzzzzzz";
1472 text[12][8]="zzzzzzzzaBcDeFgHiJkLmzzzzzz";
1473 text[12][9]="zzzzzzzzzaBcDeFgHiJkLmzzzzz";
1474 text[12][10]="zzzzzzzzzzaBcDeFgHiJkLmzzzz";
1475 text[12][11]="zzzzzzzzzzzaBcDeFgHiJkLmzzz";
1476 text[12][12]="zzzzzzzzzzzzaBcDeFgHiJkLmzz";
1477 text[12][13]="zzzzzzzzzzzzzaBcDeFgHiJkLmz";
1478 text[12][14]="zzzzzzzzzzzzzzaBcDeFgHiJkLm";
1479 text[13][0]="aBcDeFgHiJkLmNzzzzzzzzzzzzz";
1480 text[13][1]="zaBcDeFgHiJkLmNzzzzzzzzzzzz";
1481 text[13][2]="zzaBcDeFgHiJkLmNzzzzzzzzzzz";
1482 text[13][3]="zzzaBcDeFgHiJkLmNzzzzzzzzzz";
1483 text[13][4]="zzzzaBcDeFgHiJkLmNzzzzzzzzz";
1484 text[13][5]="zzzzzaBcDeFgHiJkLmNzzzzzzzz";
1485 text[13][6]="zzzzzzaBcDeFgHiJkLmNzzzzzzz";
1486 text[13][7]="zzzzzzzaBcDeFgHiJkLmNzzzzzz";
1487 text[13][8]="zzzzzzzzaBcDeFgHiJkLmNzzzzz";
1488 text[13][9]="zzzzzzzzzaBcDeFgHiJkLmNzzzz";
1489 text[13][10]="zzzzzzzzzzaBcDeFgHiJkLmNzzz";
1490 text[13][11]="zzzzzzzzzzzaBcDeFgHiJkLmNzz";
1491 text[13][12]="zzzzzzzzzzzzaBcDeFgHiJkLmNz";
1492 text[13][13]="zzzzzzzzzzzzzaBcDeFgHiJkLmN";
1493 text[14][0]="aBcDeFgHiJkLmNozzzzzzzzzzzz";
1494 text[14][1]="zaBcDeFgHiJkLmNozzzzzzzzzzz";
1495 text[14][2]="zzaBcDeFgHiJkLmNozzzzzzzzzz";
1496 text[14][3]="zzzaBcDeFgHiJkLmNozzzzzzzzz";
1497 text[14][4]="zzzzaBcDeFgHiJkLmNozzzzzzzz";
1498 text[14][5]="zzzzzaBcDeFgHiJkLmNozzzzzzz";
1499 text[14][6]="zzzzzzaBcDeFgHiJkLmNozzzzzz";
1500 text[14][7]="zzzzzzzaBcDeFgHiJkLmNozzzzz";
1501 text[14][8]="zzzzzzzzaBcDeFgHiJkLmNozzzz";
1502 text[14][9]="zzzzzzzzzaBcDeFgHiJkLmNozzz";
1503 text[14][10]="zzzzzzzzzzaBcDeFgHiJkLmNozz";
1504 text[14][11]="zzzzzzzzzzzaBcDeFgHiJkLmNoz";
1505 text[14][12]="zzzzzzzzzzzzaBcDeFgHiJkLmNo";
1506 text[15][0]="aBcDeFgHiJkLmNoPzzzzzzzzzzz";
1507 text[15][1]="zaBcDeFgHiJkLmNoPzzzzzzzzzz";
1508 text[15][2]="zzaBcDeFgHiJkLmNoPzzzzzzzzz";
1509 text[15][3]="zzzaBcDeFgHiJkLmNoPzzzzzzzz";
1510 text[15][4]="zzzzaBcDeFgHiJkLmNoPzzzzzzz";
1511 text[15][5]="zzzzzaBcDeFgHiJkLmNoPzzzzzz";
1512 text[15][6]="zzzzzzaBcDeFgHiJkLmNoPzzzzz";
1513 text[15][7]="zzzzzzzaBcDeFgHiJkLmNoPzzzz";
1514 text[15][8]="zzzzzzzzaBcDeFgHiJkLmNoPzzz";
1515 text[15][9]="zzzzzzzzzaBcDeFgHiJkLmNoPzz";
1516 text[15][10]="zzzzzzzzzzaBcDeFgHiJkLmNoPz";
1517 text[15][11]="zzzzzzzzzzzaBcDeFgHiJkLmNoP";
1518 text[16][0]="aBcDeFgHiJkLmNoPqzzzzzzzzzz";
1519 text[16][1]="zaBcDeFgHiJkLmNoPqzzzzzzzzz";
1520 text[16][2]="zzaBcDeFgHiJkLmNoPqzzzzzzzz";
1521 text[16][3]="zzzaBcDeFgHiJkLmNoPqzzzzzzz";
1522 text[16][4]="zzzzaBcDeFgHiJkLmNoPqzzzzzz";
1523 text[16][5]="zzzzzaBcDeFgHiJkLmNoPqzzzzz";
1524 text[16][6]="zzzzzzaBcDeFgHiJkLmNoPqzzzz";
1525 text[16][7]="zzzzzzzaBcDeFgHiJkLmNoPqzzz";
1526 text[16][8]="zzzzzzzzaBcDeFgHiJkLmNoPqzz";
1527 text[16][9]="zzzzzzzzzaBcDeFgHiJkLmNoPqz";
1528 text[16][10]="zzzzzzzzzzaBcDeFgHiJkLmNoPq";
1529 text[17][0]="aBcDeFgHiJkLmNoPqRzzzzzzzzz";
1530 text[17][1]="zaBcDeFgHiJkLmNoPqRzzzzzzzz";
1531 text[17][2]="zzaBcDeFgHiJkLmNoPqRzzzzzzz";
1532 text[17][3]="zzzaBcDeFgHiJkLmNoPqRzzzzzz";
1533 text[17][4]="zzzzaBcDeFgHiJkLmNoPqRzzzzz";
1534 text[17][5]="zzzzzaBcDeFgHiJkLmNoPqRzzzz";
1535 text[17][6]="zzzzzzaBcDeFgHiJkLmNoPqRzzz";
1536 text[17][7]="zzzzzzzaBcDeFgHiJkLmNoPqRzz";
1537 text[17][8]="zzzzzzzzaBcDeFgHiJkLmNoPqRz";
1538 text[17][9]="zzzzzzzzzaBcDeFgHiJkLmNoPqR";
1539 text[18][0]="aBcDeFgHiJkLmNoPqRszzzzzzzz";
1540 text[18][1]="zaBcDeFgHiJkLmNoPqRszzzzzzz";
1541 text[18][2]="zzaBcDeFgHiJkLmNoPqRszzzzzz";
1542 text[18][3]="zzzaBcDeFgHiJkLmNoPqRszzzzz";
1543 text[18][4]="zzzzaBcDeFgHiJkLmNoPqRszzzz";
1544 text[18][5]="zzzzzaBcDeFgHiJkLmNoPqRszzz";
1545 text[18][6]="zzzzzzaBcDeFgHiJkLmNoPqRszz";
1546 text[18][7]="zzzzzzzaBcDeFgHiJkLmNoPqRsz";
1547 text[18][8]="zzzzzzzzaBcDeFgHiJkLmNoPqRs";
1548 text[19][0]="aBcDeFgHiJkLmNoPqRsTzzzzzzz";
1549 text[19][1]="zaBcDeFgHiJkLmNoPqRsTzzzzzz";
1550 text[19][2]="zzaBcDeFgHiJkLmNoPqRsTzzzzz";
1551 text[19][3]="zzzaBcDeFgHiJkLmNoPqRsTzzzz";
1552 text[19][4]="zzzzaBcDeFgHiJkLmNoPqRsTzzz";
1553 text[19][5]="zzzzzaBcDeFgHiJkLmNoPqRsTzz";
1554 text[19][6]="zzzzzzaBcDeFgHiJkLmNoPqRsTz";
1555 text[19][7]="zzzzzzzaBcDeFgHiJkLmNoPqRsT";
1556 text[20][0]="aBcDeFgHiJkLmNoPqRsTuzzzzzz";
1557 text[20][1]="zaBcDeFgHiJkLmNoPqRsTuzzzzz";
1558 text[20][2]="zzaBcDeFgHiJkLmNoPqRsTuzzzz";
1559 text[20][3]="zzzaBcDeFgHiJkLmNoPqRsTuzzz";
1560 text[20][4]="zzzzaBcDeFgHiJkLmNoPqRsTuzz";
1561 text[20][5]="zzzzzaBcDeFgHiJkLmNoPqRsTuz";
1562 text[20][6]="zzzzzzaBcDeFgHiJkLmNoPqRsTu";
1563 text[21][0]="aBcDeFgHiJkLmNoPqRsTuVzzzzz";
1564 text[21][1]="zaBcDeFgHiJkLmNoPqRsTuVzzzz";
1565 text[21][2]="zzaBcDeFgHiJkLmNoPqRsTuVzzz";
1566 text[21][3]="zzzaBcDeFgHiJkLmNoPqRsTuVzz";
1567 text[21][4]="zzzzaBcDeFgHiJkLmNoPqRsTuVz";
1568 text[21][5]="zzzzzaBcDeFgHiJkLmNoPqRsTuV";
1569 text[22][0]="aBcDeFgHiJkLmNoPqRsTuVwzzzz";
1570 text[22][1]="zaBcDeFgHiJkLmNoPqRsTuVwzzz";
1571 text[22][2]="zzaBcDeFgHiJkLmNoPqRsTuVwzz";
1572 text[22][3]="zzzaBcDeFgHiJkLmNoPqRsTuVwz";
1573 text[22][4]="zzzzaBcDeFgHiJkLmNoPqRsTuVw";
1574 text[23][0]="aBcDeFgHiJkLmNoPqRsTuVwXzzz";
1575 text[23][1]="zaBcDeFgHiJkLmNoPqRsTuVwXzz";
1576 text[23][2]="zzaBcDeFgHiJkLmNoPqRsTuVwXz";
1577 text[23][3]="zzzaBcDeFgHiJkLmNoPqRsTuVwX";
1578 text[24][0]="aBcDeFgHiJkLmNoPqRsTuVwXyzz";
1579 text[24][1]="zaBcDeFgHiJkLmNoPqRsTuVwXyz";
1580 text[24][2]="zzaBcDeFgHiJkLmNoPqRsTuVwXy";
1581 text[25][0]="aBcDeFgHiJkLmNoPqRsTuVwXyZz";
1582 text[25][1]="zaBcDeFgHiJkLmNoPqRsTuVwXyZ";
1583
1584 const char *needle[26];
1585 needle[0]="A";
1586 needle[1]="Ab";
1587 needle[2]="AbC";
1588 needle[3]="AbCd";
1589 needle[4]="AbCdE";
1590 needle[5]="AbCdEf";
1591 needle[6]="AbCdEfG";
1592 needle[7]="AbCdEfGh";
1593 needle[8]="AbCdEfGhI";
1594 needle[9]="AbCdEfGhIJ";
1595 needle[10]="AbCdEfGhIjK";
1596 needle[11]="AbCdEfGhIjKl";
1597 needle[12]="AbCdEfGhIjKlM";
1598 needle[13]="AbCdEfGhIjKlMn";
1599 needle[14]="AbCdEfGhIjKlMnO";
1600 needle[15]="AbCdEfGhIjKlMnOp";
1601 needle[16]="AbCdEfGhIjKlMnOpQ";
1602 needle[17]="AbCdEfGhIjKlMnOpQr";
1603 needle[18]="AbCdEfGhIjKlMnOpQrS";
1604 needle[19]="AbCdEfGhIjKlMnOpQrSt";
1605 needle[20]="AbCdEfGhIjKlMnOpQrStU";
1606 needle[21]="AbCdEfGhIjKlMnOpQrStUv";
1607 needle[22]="AbCdEfGhIjKlMnOpQrStUvW";
1608 needle[23]="AbCdEfGhIjKlMnOpQrStUvWx";
1609 needle[24]="AbCdEfGhIjKlMnOpQrStUvWxY";
1610 needle[25]="AbCdEfGhIjKlMnOpQrStUvWxYZ";
1611
1612 int i, j;
1613 uint8_t *found = NULL;
1614 for (i = 0; i < 26; i++) {
1615 for (j = 0; j <= (26-i); j++) {
1616 found = BasicSearchNocaseWrapper((uint8_t *)text[i][j], (uint8_t *)needle[i], 1);
1617 if (found == 0) {
1618 printf("Error1 searching for %s in text %s\n", needle[i], text[i][j]);
1619 return 0;
1620 }
1621 found = Bs2bmNocaseWrapper((uint8_t *)text[i][j], (uint8_t *)needle[i], 1);
1622 if (found == 0) {
1623 printf("Error2 searching for %s in text %s\n", needle[i], text[i][j]);
1624 return 0;
1625 }
1626 found = BoyerMooreNocaseWrapper((uint8_t *)text[i][j], (uint8_t *)needle[i], 1);
1627 if (found == 0) {
1628 printf("Error3 searching for %s in text %s\n", needle[i], text[i][j]);
1629 return 0;
1630 }
1631 }
1632 }
1633 return 1;
1634 }
1635
1636 #ifdef ENABLE_SEARCH_STATS
1637 /**
1638 * \test Give some stats
1639 */
UtilSpmSearchStatsTest01(void)1640 static int UtilSpmSearchStatsTest01(void)
1641 {
1642 char *text[16];
1643 text[0]="zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzza";
1644 text[1]="aaaaaaaaazaaaaaaaaaaaaaaaaaaaaazaaaaaaaaaaaaaazaaaaaaaaaaaaaaaaaaaaazaaaaaaaaaaaaaaaaaaazaaaaaaaaaaaaaaaaaaazaaaaaaaaazaaaaaaaaaazaaaaaaaaaaaaazaaaaaaaaazaaaaaaaaaaaaaaaaazaaaaaaaaaaaaaaaaazaaaaaaaaazaaaaaaaaaazaaaaaraaaaazaaaaaaazaaaaaaaaaaaaaazaaaaaaaazaaaaaaaaazaaaaaaaaaaaaB";
1645 text[2]="aBaBaBaBaBaBaBaBazaBaBaBaBaBaBazaBaBaBaBaBaBaBaBaBzBaBaBaBaBaBaBaBazaBaBaBaBaBaBaBzBaBaBaBaBaBaBzBaBaBaBaBzBaBaBaBaBaBzBaBaBaBaBaBzBaBaBaBaBaBaBaBazaBaBaBaBaBaBaBaBaBaBaBaBazaBaBaBaBaBaBaBaBaBzBaBaBaBaBaBaBaBzBaBaBaBaBaBaBaBaBaBzBaBaBaBaBaBaBaBaBaBaBazaBaBaBaBaBaBaBazaBaBaBaBaBc";
1646 text[3]="aBcaBcaBcaBcaBczBcaBcaBzaBcaBcaBcaBcaBcaBcaBcaBcazcaBcaBcaBcaBcaBcaBcaBzaBcaBcaBcaBcaBcaBczBcaBcaBcaBcaBcaBzaBcaBcaBcaBcaBcaBcaBcazcaBcaBcaBcaBcaBcaBcaBcaBczBcaBcaBcaBcaBcaBcaBczBcaBcaBcaBcaBzaBcaBcaBcaBcaBcaBcaBcazcaBcaBcaBcaBcaBcazcaBcaBcaBcaBcaBcaBzaBcaBcaBcazcaBcaBcaBcaBcaBcD";
1647 text[4]="aBcDaBcDaBcDaBczaBcDaBcDaBcDaBcDaBczaBcDaBcDaBcDaBcDzBcDaBcDaBcDaBcDzBcDaBcDaBczaBcDaBcDaBczaBcDaBcDaBcDaBcDaBzDaBcDaBcDaBcDaBcDaBcDaBcDaBcDaBczaBcDaBcDaBcDaBcDaBcDaBzDaBcDaBcDaBcDaBzDaBcDaBcDaBzDaBcDaBcDaBcDaBcDaBcDaBczaBcDaBcDaBcDaBcDazcDaBcDaBcDaBcDaBcDzBcDaBcDaBcDaBcDaBcDaBcDe";
1648 text[5]="aBcDeaBcDeaBcDeazcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDezBcDeaBcDeaBcDzaBcDeaBcDeaBcDeazcDzaBcDeaBcDezBcDeaBzDeaBcDeaBcDeazcDeaBcDeaBcDeaBcDzaBcDeaBcDeaBczeaBcDeaBcDeaBzDeaBcDeaBcDezBcDeaBcDzaBcDeaBcDezBcDeaBcDezBcDeaBczeaBcDeaBcDeaBzDeaBcDezBcDeaBcDeaBcDeaBcDeaBcDeaBcDeaBcDeaBcDezzzaBcDeF";
1649 text[6]="aBcDeaBcDeaBcDeazcDeaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDeaBcDzaBzDeaBcDeaBcDeaBcDzaBcDzaBcDeaBcDeaBcDeaBcDzaBzDeaBcDeaBcDeaBczzaBcDeaBcDeaBcDzazcDeaBcDeaBcDeaBcDzaBzDeaBcDeaBcDeaBcDeazcDeaBcDeaBcDeaBcDeaBczeaBcDeaBcDeaBcDeaBczeaBcDezzzaBcDeFg";
1650 text[7]="aBcDeaBczeaBcDzaBcDezBcDeaBcDeaBcDeaBcDzaBzDeaBcDeaBcDeaBzDzaBcDeaBcDeazcDeaBcDzaBcDeaBczeaBcDeaBcDeaBzDzaBcDeaBcDeaBcDezBcDzaBcDeaBzDeaBcDeaBcDezBcDzaBcDeaBcDeaBzDeaBcDeaBcDeaBzDeaBcDeaBcDezBcDeaBcDeaBcDeazcDeaBcDeaBcDeaBcDzaBcDeaBcDeaBcDeaBcDzaBcDeaBcDeaBcDeaBrDeaBcDeaBcDezzzaBcDeFgH";
1651 text[8]="aBcDeaBcDeaBczzaBcDeazcDeaBcDezBcDeaBcDzaBcDeaBcDeaBcDeaBczzaBcDeaBcDeaBczeaBcDeaBcDzzBcDeaBcDeaBcDzaBczeaBcDeaBcDzaBcDeaBczeaBcDeaBcDeaBzDeaBcDeaBcDeaBzDeaBcDeaBcDzaBcDeaBcDeazcDeaBcDeaBcDzaBcDeaBcDeaBcDeazcDeaBcDeaBcDeaBcDeazcDeaBcDeaBcDeaBczeaBcDeaBzDeaBcDeaBcDeaBcDeaBcDezzzaBcDeFgHi";
1652 text[9]="aBcDeaBcDzaBcDzaBcDeaBcDeaBcDzaBcDeaBcDzaBcDeazcDeaBcDeaBcDzzBcDeaBcDeaBczeaBcDzaBcDezBcDeaBczeaBcDzaBcDezBcDeaBcDzaBczeaBcDeaBcDzaBcDeazcDeaBcDeaBcDzaBczeaBcDeaBcDzaBzDeaBcDeaBczeaBcDeaBcDzaBcDeaBcDeaBzDeaBcDeaBcDeaBczeaBcDeaBcDeaBcDeaBzDeaBcDeaBcDeazcDeaBcDeaBcDeaBcDeaBcDezzzaBcDeFgHiJ";
1653 text[10]="aBcDeaBcDeaBczeaBcDzaBczeaBcDeaBczeaBcDeaBcDzaBcDeaBcDeazcDeaBcDeaBcDeaBzDzaBcDeazcDeaBcDeazcDeaBcDzaBcDeazcDeaBcDeaBczzaBcDeaBcDeaBzDeaBcDeaBcDzaBczeaBcDeaBcDeaBcDeaBczeaBcDeaBcDeaBcDzaBcDeaBcDeaBcDezBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDezBcDeaBcDeaBcDeaBzDeaBcDeaBcDezzzaBcDeFgHiJk";
1654 text[11]="aBcDeaBcDeaBcDeaBcDeaBzDeaBcDeaBcDzaBcDzaBcDeaBcDeaBcDeaBcDeazcDeaBcDzaBcDeaBcDeaBcDeaBcDzaBcDeaBcDzaBcDzaBcDeaBcDeaBcDeaBcDzzBcDeaBcDeaBcDeaBcDzaBcDzaBcDeaBzDeaBcDeaBcDezBcDeaBcDeazcDeaBcDeaBcDezBcDeaBcDeaBcDeazcDeaBcDeaBzDeaBcDeaBczeaBcDeazcDeaBcDezBcDeaBcDeaBcDeaBcDeaBcDezzzaBcDeFgHiJkL";
1655 text[12]="aBcDeaBcDeaBcDeaBcDeaBzDeaBcDeaBzDeaBcDeaBcDezBcDeaBcDeazcDeaBcDeaBcDeazcDeaBcDeaBczeaBcDeaBcDeaBcDezBcDeaBcDzaBcDeaBcDzaBcDeaBcDeaBcDeaBcDeaBcDeaBcDeaBcDeaBcDeaBcDeaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDzaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDeaBcDeaBcDeaBcDezzzaBcDeFgHiJkLm";
1656 text[13]="aBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDeaBcDeaBcDeaBcDeaBcDeaBcDeaBcDeaBcDeaBcDeaBcDeaBcDeaBcDeaBcDeaBcDeaBcDezzzaBcDeFgHiJkLmN";
1657 text[14]="aBcDeaBcDeaBcDzaBcDeaBcDeaBcDeaBcDzaBcDeaBcDeaBcDeaBcDzaBcDeaBcDeaBcDeaBcDzaBcDeaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDzaBcDezzzaBcDeFgHiJkLmNo";
1658 text[15]="aBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDzaBcDeaBcDzaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDzaBcDeaBcDzaBcDeaBcDzaBcDeaBcDzaBcDeaBcDzaBcDeaBcDzaBcDeaBcDeaBcDeaBcDezzzaBcDeFgHiJkLmNoP";
1659
1660 char *needle[16];
1661 needle[0]="a";
1662 needle[1]="aB";
1663 needle[2]="aBc";
1664 needle[3]="aBcD";
1665 needle[4]="aBcDe";
1666 needle[5]="aBcDeF";
1667 needle[6]="aBcDeFg";
1668 needle[7]="aBcDeFgH";
1669 needle[8]="aBcDeFgHi";
1670 needle[9]="aBcDeFgHiJ";
1671 needle[10]="aBcDeFgHiJk";
1672 needle[11]="aBcDeFgHiJkL";
1673 needle[12]="aBcDeFgHiJkLm";
1674 needle[13]="aBcDeFgHiJkLmN";
1675 needle[14]="aBcDeFgHiJkLmNo";
1676 needle[15]="aBcDeFgHiJkLmNoP";
1677
1678 int i;
1679 uint8_t *found = NULL;
1680 printf("\nStats for text of greater length (text with a lot of partial matches, worst case for a basic search):\n");
1681 for (i = 0; i < 16; i++) {
1682 printf("Pattern length %d with BasicSearch:", i+1);
1683 found = BasicSearchWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
1684 if (found == 0) {
1685 printf("Error1 searching for %s in text %s\n", needle[i], text[i]);
1686 return 0;
1687 }
1688 printf("Pattern length %d with Bs2BmSearch:", i+1);
1689 found = Bs2bmWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
1690 if (found == 0) {
1691 printf("Error2 searching for %s in text %s\n", needle[i], text[i]);
1692 return 0;
1693 }
1694 printf("Pattern length %d with BoyerMooreSearch:", i+1);
1695 found = BoyerMooreWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
1696 if (found == 0) {
1697 printf("Error3 searching for %s in text %s\n", needle[i], text[i]);
1698 return 0;
1699 }
1700 printf("\n");
1701 }
1702 return 1;
1703 }
1704
1705 /**
1706 * \test Give some stats for
1707 */
UtilSpmSearchStatsTest02(void)1708 static int UtilSpmSearchStatsTest02(void)
1709 {
1710 char *text[16];
1711 text[0]="zzzzzzzzzzzzzzzzzza";
1712 text[1]="zzzzzzzzzzzzzzzzzzaB";
1713 text[2]="zzzzzzzzzzzzzzzzzzaBc";
1714 text[3]="zzzzzzzzzzzzzzzzzzaBcD";
1715 text[4]="zzzzzzzzzzzzzzzzzzaBcDe";
1716 text[5]="zzzzzzzzzzzzzzzzzzzzaBcDeF";
1717 text[6]="zzzzzzzzzzzzzzzzzzzzaBcDeFg";
1718 text[7]="zzzzzzzzzzzzzzzzzzzzaBcDeFgH";
1719 text[8]="zzzzzzzzzzzzzzzzzzzzaBcDeFgHi";
1720 text[9]="zzzzzzzzzzzzzzzzzzzzaBcDeFgHiJ";
1721 text[10]="zzzzzzzzzzzzzzzzzzzzaBcDeFgHiJk";
1722 text[11]="zzzzzzzzzzzzzzzzzzzzaBcDeFgHiJkL";
1723 text[12]="zzzzzzzzzzzzzzzzzzzzaBcDeFgHiJkLm";
1724 text[13]="zzzzzzzzzzzzzzzzzzzzaBcDeFgHiJkLmN";
1725 text[14]="zzzzzzzzzzzzzzzzzzzzaBcDeFgHiJkLmNo";
1726 text[15]="zzzzzzzzzzzzzzzzzzzzaBcDeFgHiJkLmNoP";
1727
1728 char *needle[16];
1729 needle[0]="a";
1730 needle[1]="aB";
1731 needle[2]="aBc";
1732 needle[3]="aBcD";
1733 needle[4]="aBcDe";
1734 needle[5]="aBcDeF";
1735 needle[6]="aBcDeFg";
1736 needle[7]="aBcDeFgH";
1737 needle[8]="aBcDeFgHi";
1738 needle[9]="aBcDeFgHiJ";
1739 needle[10]="aBcDeFgHiJk";
1740 needle[11]="aBcDeFgHiJkL";
1741 needle[12]="aBcDeFgHiJkLm";
1742 needle[13]="aBcDeFgHiJkLmN";
1743 needle[14]="aBcDeFgHiJkLmNo";
1744 needle[15]="aBcDeFgHiJkLmNoP";
1745
1746 int i;
1747 uint8_t *found = NULL;
1748 printf("\nStats for text of lower length:\n");
1749 for (i = 0; i < 16; i++) {
1750 printf("Pattern length %d with BasicSearch:", i+1);
1751 found = BasicSearchWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
1752 if (found == 0) {
1753 printf("Error1 searching for %s in text %s\n", needle[i], text[i]);
1754 return 0;
1755 }
1756 printf("Pattern length %d with Bs2BmSearch:", i+1);
1757 found = Bs2bmWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
1758 if (found == 0) {
1759 printf("Error2 searching for %s in text %s\n", needle[i], text[i]);
1760 return 0;
1761 }
1762 printf("Pattern length %d with BoyerMooreSearch:", i+1);
1763 found = BoyerMooreWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
1764 if (found == 0) {
1765 printf("Error3 searching for %s in text %s\n", needle[i], text[i]);
1766 return 0;
1767 }
1768 printf("\n");
1769 }
1770 return 1;
1771 }
1772
1773
UtilSpmSearchStatsTest03(void)1774 static int UtilSpmSearchStatsTest03(void)
1775 {
1776 char *text[16];
1777 text[0]="zzzzzza";
1778 text[1]="zzzzzzaB";
1779 text[2]="zzzzzzaBc";
1780 text[3]="zzzzzzaBcD";
1781 text[4]="zzzzzzaBcDe";
1782 text[5]="zzzzzzzzaBcDeF";
1783 text[6]="zzzzzzzzaBcDeFg";
1784 text[7]="zzzzzzzzaBcDeFgH";
1785 text[8]="zzzzzzzzaBcDeFgHi";
1786 text[9]="zzzzzzzzaBcDeFgHiJ";
1787 text[10]="zzzzzzzzaBcDeFgHiJk";
1788 text[11]="zzzzzzzzaBcDeFgHiJkL";
1789 text[12]="zzzzzzzzaBcDeFgHiJkLm";
1790 text[13]="zzzzzzzzaBcDeFgHiJkLmN";
1791 text[14]="zzzzzzzzaBcDeFgHiJkLmNo";
1792 text[15]="zzzzzzzzaBcDeFgHiJkLmNoP";
1793
1794 char *needle[16];
1795 needle[0]="a";
1796 needle[1]="aB";
1797 needle[2]="aBc";
1798 needle[3]="aBcD";
1799 needle[4]="aBcDe";
1800 needle[5]="aBcDeF";
1801 needle[6]="aBcDeFg";
1802 needle[7]="aBcDeFgH";
1803 needle[8]="aBcDeFgHi";
1804 needle[9]="aBcDeFgHiJ";
1805 needle[10]="aBcDeFgHiJk";
1806 needle[11]="aBcDeFgHiJkL";
1807 needle[12]="aBcDeFgHiJkLm";
1808 needle[13]="aBcDeFgHiJkLmN";
1809 needle[14]="aBcDeFgHiJkLmNo";
1810 needle[15]="aBcDeFgHiJkLmNoP";
1811
1812 int i;
1813 uint8_t *found = NULL;
1814 printf("\nStats for text of lower length (badcase for):\n");
1815 for (i = 0; i < 16; i++) {
1816 printf("Pattern length %d with BasicSearch:", i+1);
1817 found = BasicSearchWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
1818 if (found == 0) {
1819 printf("Error1 searching for %s in text %s\n", needle[i], text[i]);
1820 return 0;
1821 }
1822 printf("Pattern length %d with Bs2BmSearch:", i+1);
1823 found = Bs2bmWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
1824 if (found == 0) {
1825 printf("Error2 searching for %s in text %s\n", needle[i], text[i]);
1826 return 0;
1827 }
1828 printf("Pattern length %d with BoyerMooreSearch:", i+1);
1829 found = BoyerMooreWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
1830 if (found == 0) {
1831 printf("Error3 searching for %s in text %s\n", needle[i], text[i]);
1832 return 0;
1833 }
1834 printf("\n");
1835 }
1836 return 1;
1837 }
1838
1839 /**
1840 * \test Give some stats
1841 */
UtilSpmSearchStatsTest04(void)1842 static int UtilSpmSearchStatsTest04(void)
1843 {
1844 char *text[16];
1845 text[0]="zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzza";
1846 text[1]="aaaaaaaaazaaaaaaaaaaaaaaaaaaaaazaaaaaaaaaaaaaazaaaaaaaaaaaaaaaaaaaaazaaaaaaaaaaaaaaaaaaazaaaaaaaaaaaaaaaaaaazaaaaaaaaazaaaaaaaaaazaaaaaaaaaaaaazaaaaaaaaazaaaaaaaaaaaaaaaaazaaaaaaaaaaaaaaaaazaaaaaaaaazaaaaaaaaaazaaaaaraaaaazaaaaaaazaaaaaaaaaaaaaazaaaaaaaazaaaaaaaaazaaaaaaaaaaaaB";
1847 text[2]="aBaBaBaBaBaBaBaBazaBaBaBaBaBaBazaBaBaBaBaBaBaBaBaBzBaBaBaBaBaBaBaBazaBaBaBaBaBaBaBzBaBaBaBaBaBaBzBaBaBaBaBzBaBaBaBaBaBzBaBaBaBaBaBzBaBaBaBaBaBaBaBazaBaBaBaBaBaBaBaBaBaBaBaBazaBaBaBaBaBaBaBaBaBzBaBaBaBaBaBaBaBzBaBaBaBaBaBaBaBaBaBzBaBaBaBaBaBaBaBaBaBaBazaBaBaBaBaBaBaBazaBaBaBaBaBc";
1848 text[3]="aBcaBcaBcaBcaBczBcaBcaBzaBcaBcaBcaBcaBcaBcaBcaBcazcaBcaBcaBcaBcaBcaBcaBzaBcaBcaBcaBcaBcaBczBcaBcaBcaBcaBcaBzaBcaBcaBcaBcaBcaBcaBcazcaBcaBcaBcaBcaBcaBcaBcaBczBcaBcaBcaBcaBcaBcaBczBcaBcaBcaBcaBzaBcaBcaBcaBcaBcaBcaBcazcaBcaBcaBcaBcaBcazcaBcaBcaBcaBcaBcaBzaBcaBcaBcazcaBcaBcaBcaBcaBcD";
1849 text[4]="aBcDaBcDaBcDaBczaBcDaBcDaBcDaBcDaBczaBcDaBcDaBcDaBcDzBcDaBcDaBcDaBcDzBcDaBcDaBczaBcDaBcDaBczaBcDaBcDaBcDaBcDaBzDaBcDaBcDaBcDaBcDaBcDaBcDaBcDaBczaBcDaBcDaBcDaBcDaBcDaBzDaBcDaBcDaBcDaBzDaBcDaBcDaBzDaBcDaBcDaBcDaBcDaBcDaBczaBcDaBcDaBcDaBcDazcDaBcDaBcDaBcDaBcDzBcDaBcDaBcDaBcDaBcDaBcDe";
1850 text[5]="aBcDeaBcDeaBcDeazcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDezBcDeaBcDeaBcDzaBcDeaBcDeaBcDeazcDzaBcDeaBcDezBcDeaBzDeaBcDeaBcDeazcDeaBcDeaBcDeaBcDzaBcDeaBcDeaBczeaBcDeaBcDeaBzDeaBcDeaBcDezBcDeaBcDzaBcDeaBcDezBcDeaBcDezBcDeaBczeaBcDeaBcDeaBzDeaBcDezBcDeaBcDeaBcDeaBcDeaBcDeaBcDeaBcDeaBcDezzzaBcDeF";
1851 text[6]="aBcDeaBcDeaBcDeazcDeaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDeaBcDzaBzDeaBcDeaBcDeaBcDzaBcDzaBcDeaBcDeaBcDeaBcDzaBzDeaBcDeaBcDeaBczzaBcDeaBcDeaBcDzazcDeaBcDeaBcDeaBcDzaBzDeaBcDeaBcDeaBcDeazcDeaBcDeaBcDeaBcDeaBczeaBcDeaBcDeaBcDeaBczeaBcDezzzaBcDeFg";
1852 text[7]="aBcDeaBczeaBcDzaBcDezBcDeaBcDeaBcDeaBcDzaBzDeaBcDeaBcDeaBzDzaBcDeaBcDeazcDeaBcDzaBcDeaBczeaBcDeaBcDeaBzDzaBcDeaBcDeaBcDezBcDzaBcDeaBzDeaBcDeaBcDezBcDzaBcDeaBcDeaBzDeaBcDeaBcDeaBzDeaBcDeaBcDezBcDeaBcDeaBcDeazcDeaBcDeaBcDeaBcDzaBcDeaBcDeaBcDeaBcDzaBcDeaBcDeaBcDeaBrDeaBcDeaBcDezzzaBcDeFgH";
1853 text[8]="aBcDeaBcDeaBczzaBcDeazcDeaBcDezBcDeaBcDzaBcDeaBcDeaBcDeaBczzaBcDeaBcDeaBczeaBcDeaBcDzzBcDeaBcDeaBcDzaBczeaBcDeaBcDzaBcDeaBczeaBcDeaBcDeaBzDeaBcDeaBcDeaBzDeaBcDeaBcDzaBcDeaBcDeazcDeaBcDeaBcDzaBcDeaBcDeaBcDeazcDeaBcDeaBcDeaBcDeazcDeaBcDeaBcDeaBczeaBcDeaBzDeaBcDeaBcDeaBcDeaBcDezzzaBcDeFgHi";
1854 text[9]="aBcDeaBcDzaBcDzaBcDeaBcDeaBcDzaBcDeaBcDzaBcDeazcDeaBcDeaBcDzzBcDeaBcDeaBczeaBcDzaBcDezBcDeaBczeaBcDzaBcDezBcDeaBcDzaBczeaBcDeaBcDzaBcDeazcDeaBcDeaBcDzaBczeaBcDeaBcDzaBzDeaBcDeaBczeaBcDeaBcDzaBcDeaBcDeaBzDeaBcDeaBcDeaBczeaBcDeaBcDeaBcDeaBzDeaBcDeaBcDeazcDeaBcDeaBcDeaBcDeaBcDezzzaBcDeFgHiJ";
1855 text[10]="aBcDeaBcDeaBczeaBcDzaBczeaBcDeaBczeaBcDeaBcDzaBcDeaBcDeazcDeaBcDeaBcDeaBzDzaBcDeazcDeaBcDeazcDeaBcDzaBcDeazcDeaBcDeaBczzaBcDeaBcDeaBzDeaBcDeaBcDzaBczeaBcDeaBcDeaBcDeaBczeaBcDeaBcDeaBcDzaBcDeaBcDeaBcDezBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDezBcDeaBcDeaBcDeaBzDeaBcDeaBcDezzzaBcDeFgHiJk";
1856 text[11]="aBcDeaBcDeaBcDeaBcDeaBzDeaBcDeaBcDzaBcDzaBcDeaBcDeaBcDeaBcDeazcDeaBcDzaBcDeaBcDeaBcDeaBcDzaBcDeaBcDzaBcDzaBcDeaBcDeaBcDeaBcDzzBcDeaBcDeaBcDeaBcDzaBcDzaBcDeaBzDeaBcDeaBcDezBcDeaBcDeazcDeaBcDeaBcDezBcDeaBcDeaBcDeazcDeaBcDeaBzDeaBcDeaBczeaBcDeazcDeaBcDezBcDeaBcDeaBcDeaBcDeaBcDezzzaBcDeFgHiJkL";
1857 text[12]="aBcDeaBcDeaBcDeaBcDeaBzDeaBcDeaBzDeaBcDeaBcDezBcDeaBcDeazcDeaBcDeaBcDeazcDeaBcDeaBczeaBcDeaBcDeaBcDezBcDeaBcDzaBcDeaBcDzaBcDeaBcDeaBcDeaBcDeaBcDeaBcDeaBcDeaBcDeaBcDeaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDzaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDeaBcDeaBcDeaBcDezzzaBcDeFgHiJkLm";
1858 text[13]="aBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDeaBcDeaBcDeaBcDeaBcDeaBcDeaBcDeaBcDeaBcDeaBcDeaBcDeaBcDeaBcDeaBcDeaBcDezzzaBcDeFgHiJkLmN";
1859 text[14]="aBcDeaBcDeaBcDzaBcDeaBcDeaBcDeaBcDzaBcDeaBcDeaBcDeaBcDzaBcDeaBcDeaBcDeaBcDzaBcDeaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDzaBcDezzzaBcDeFgHiJkLmNo";
1860 text[15]="aBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDzaBcDeaBcDzaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDzaBcDeaBcDzaBcDeaBcDzaBcDeaBcDzaBcDeaBcDzaBcDeaBcDzaBcDeaBcDeaBcDeaBcDezzzaBcDeFgHiJkLmNoP";
1861
1862
1863 char *needle[16];
1864 needle[0]="a";
1865 needle[1]="aB";
1866 needle[2]="aBc";
1867 needle[3]="aBcD";
1868 needle[4]="aBcDe";
1869 needle[5]="aBcDeF";
1870 needle[6]="aBcDeFg";
1871 needle[7]="aBcDeFgH";
1872 needle[8]="aBcDeFgHi";
1873 needle[9]="aBcDeFgHiJ";
1874 needle[10]="aBcDeFgHiJk";
1875 needle[11]="aBcDeFgHiJkL";
1876 needle[12]="aBcDeFgHiJkLm";
1877 needle[13]="aBcDeFgHiJkLmN";
1878 needle[14]="aBcDeFgHiJkLmNo";
1879 needle[15]="aBcDeFgHiJkLmNoP";
1880
1881 int i;
1882 uint8_t *found = NULL;
1883 printf("\nStats for text of greater length:\n");
1884 for (i = 0; i < 16; i++) {
1885 printf("Pattern length %d with BasicSearch (Building Context):", i + 1);
1886 found = BasicSearchCtxWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
1887 if (found == 0) {
1888 printf("Error1 searching for %s in text %s\n", needle[i], text[i]);
1889 return 0;
1890 }
1891 printf("Pattern length %d with Bs2BmSearch (Building Context):", i + 1);
1892 found = Bs2bmCtxWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
1893 if (found == 0) {
1894 printf("Error2 searching for %s in text %s\n", needle[i], text[i]);
1895 return 0;
1896 }
1897 printf("Pattern length %d with BoyerMooreSearch (Building Context):", i + 1);
1898 found = BoyerMooreCtxWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
1899 if (found == 0) {
1900 printf("Error3 searching for %s in text %s\n", needle[i], text[i]);
1901 return 0;
1902 }
1903 printf("Pattern length %d with SpmSearch (Building Context):", i + 1);
1904 found = RawCtxWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
1905 if (found == 0) {
1906 printf("Error3 searching for %s in text %s\n", needle[i], text[i]);
1907 return 0;
1908 }
1909 printf("\n");
1910 }
1911 return 1;
1912 }
1913
1914 /**
1915 * \test Give some stats for
1916 */
UtilSpmSearchStatsTest05(void)1917 static int UtilSpmSearchStatsTest05(void)
1918 {
1919 char *text[16];
1920 text[0]="zzzzzzzzzzzzzzzzzza";
1921 text[1]="zzzzzzzzzzzzzzzzzzaB";
1922 text[2]="zzzzzzzzzzzzzzzzzzaBc";
1923 text[3]="zzzzzzzzzzzzzzzzzzaBcD";
1924 text[4]="zzzzzzzzzzzzzzzzzzaBcDe";
1925 text[5]="zzzzzzzzzzzzzzzzzzzzaBcDeF";
1926 text[6]="zzzzzzzzzzzzzzzzzzzzaBcDeFg";
1927 text[7]="zzzzzzzzzzzzzzzzzzzzaBcDeFgH";
1928 text[8]="zzzzzzzzzzzzzzzzzzzzaBcDeFgHi";
1929 text[9]="zzzzzzzzzzzzzzzzzzzzaBcDeFgHiJ";
1930 text[10]="zzzzzzzzzzzzzzzzzzzzaBcDeFgHiJk";
1931 text[11]="zzzzzzzzzzzzzzzzzzzzaBcDeFgHiJkL";
1932 text[12]="zzzzzzzzzzzzzzzzzzzzaBcDeFgHiJkLm";
1933 text[13]="zzzzzzzzzzzzzzzzzzzzaBcDeFgHiJkLmN";
1934 text[14]="zzzzzzzzzzzzzzzzzzzzaBcDeFgHiJkLmNo";
1935 text[15]="zzzzzzzzzzzzzzzzzzzzaBcDeFgHiJkLmNoP";
1936
1937 char *needle[16];
1938 needle[0]="a";
1939 needle[1]="aB";
1940 needle[2]="aBc";
1941 needle[3]="aBcD";
1942 needle[4]="aBcDe";
1943 needle[5]="aBcDeF";
1944 needle[6]="aBcDeFg";
1945 needle[7]="aBcDeFgH";
1946 needle[8]="aBcDeFgHi";
1947 needle[9]="aBcDeFgHiJ";
1948 needle[10]="aBcDeFgHiJk";
1949 needle[11]="aBcDeFgHiJkL";
1950 needle[12]="aBcDeFgHiJkLm";
1951 needle[13]="aBcDeFgHiJkLmN";
1952 needle[14]="aBcDeFgHiJkLmNo";
1953 needle[15]="aBcDeFgHiJkLmNoP";
1954
1955 int i;
1956 uint8_t *found = NULL;
1957 printf("\nStats for text of lower length:\n");
1958 for (i = 0; i < 16; i++) {
1959 printf("Pattern length %d with BasicSearch (Building Context):", i+1);
1960 found = BasicSearchCtxWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
1961 if (found == 0) {
1962 printf("Error1 searching for %s in text %s\n", needle[i], text[i]);
1963 return 0;
1964 }
1965 printf("Pattern length %d with Bs2BmSearch (Building Context):", i+1);
1966 found = Bs2bmCtxWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
1967 if (found == 0) {
1968 printf("Error2 searching for %s in text %s\n", needle[i], text[i]);
1969 return 0;
1970 }
1971 printf("Pattern length %d with BoyerMooreSearch (Building Context):", i+1);
1972 found = BoyerMooreCtxWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
1973 if (found == 0) {
1974 printf("Error3 searching for %s in text %s\n", needle[i], text[i]);
1975 return 0;
1976 }
1977 printf("\n");
1978 }
1979 return 1;
1980 }
1981
1982
UtilSpmSearchStatsTest06(void)1983 static int UtilSpmSearchStatsTest06(void)
1984 {
1985 char *text[16];
1986 text[0]="zzzzkzzzzzzzkzzzzzza";
1987 text[1]="BBBBkBBBBBBBkBBBBBaB";
1988 text[2]="BcBckcBcBcBckcBcBcaBc";
1989 text[3]="BcDBkDBcDBcDkcDBcDaBcD";
1990 text[4]="BcDekcDeBcDekcDezzaBcDe";
1991
1992 char *needle[16];
1993 needle[0]="a";
1994 needle[1]="aB";
1995 needle[2]="aBc";
1996 needle[3]="aBcD";
1997 needle[4]="aBcDe";
1998
1999 int i;
2000 uint8_t *found = NULL;
2001 printf("\nStats for text of lower length (badcase for):\n");
2002 for (i = 0; i < 5; i++) {
2003 printf("Pattern length %d with BasicSearch (Building Context):", i+1);
2004 found = BasicSearchCtxWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
2005 if (found == 0) {
2006 printf("Error1 searching for %s in text %s\n", needle[i], text[i]);
2007 return 0;
2008 }
2009 printf("Pattern length %d with Bs2BmSearch (Building Context):", i+1);
2010 found = Bs2bmCtxWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
2011 if (found == 0) {
2012 printf("Error2 searching for %s in text %s\n", needle[i], text[i]);
2013 return 0;
2014 }
2015 printf("Pattern length %d with BoyerMooreSearch (Building Context):", i+1);
2016 found = BoyerMooreCtxWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
2017 if (found == 0) {
2018 printf("Error3 searching for %s in text %s\n", needle[i], text[i]);
2019 return 0;
2020 }
2021 printf("\n");
2022 }
2023 return 1;
2024 }
2025
UtilSpmSearchStatsTest07(void)2026 static int UtilSpmSearchStatsTest07(void)
2027 {
2028 char *text[16];
2029 text[0]="zzzza";
2030 text[1]="BBBaB";
2031 text[2]="bbaBc";
2032 text[3]="aaBcD";
2033 text[4]="aBcDe";
2034
2035 char *needle[16];
2036 needle[0]="a";
2037 needle[1]="aB";
2038 needle[2]="aBc";
2039 needle[3]="aBcD";
2040 needle[4]="aBcDe";
2041
2042 int i;
2043 uint8_t *found = NULL;
2044 printf("\nStats for text of real lower length (badcase for):\n");
2045 for (i = 0; i < 5; i++) {
2046 printf("Pattern length %d with BasicSearch (Building Context):", i+1);
2047 found = BasicSearchCtxWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
2048 if (found == 0) {
2049 printf("Error1 searching for %s in text %s\n", needle[i], text[i]);
2050 return 0;
2051 }
2052 printf("Pattern length %d with Bs2BmSearch (Building Context):", i+1);
2053 found = Bs2bmCtxWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
2054 if (found == 0) {
2055 printf("Error2 searching for %s in text %s\n", needle[i], text[i]);
2056 return 0;
2057 }
2058 printf("Pattern length %d with BoyerMooreSearch (Building Context):", i+1);
2059 found = BoyerMooreCtxWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
2060 if (found == 0) {
2061 printf("Error3 searching for %s in text %s\n", needle[i], text[i]);
2062 return 0;
2063 }
2064 printf("\n");
2065 }
2066 return 1;
2067 }
2068
2069 /**
2070 * \test Give some stats for no case algorithms
2071 */
UtilSpmNocaseSearchStatsTest01(void)2072 static int UtilSpmNocaseSearchStatsTest01(void)
2073 {
2074 char *text[16];
2075 text[0]="zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzza";
2076 text[1]="zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzaB";
2077 text[2]="zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzaBc";
2078 text[3]="zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzaBcD";
2079 text[4]="zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzaBcDe";
2080 text[5]="zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzaBcDeF";
2081 text[6]="zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzaBcDeFg";
2082 text[7]="zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzaBcDeFgH";
2083 text[8]="zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzaBcDeFgHi";
2084 text[9]="zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzaBcDeFgHiJ";
2085 text[10]="zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzaBcDeFgHiJk";
2086 text[11]="zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzaBcDeFgHiJkL";
2087 text[12]="zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzaBcDeFgHiJkLm";
2088 text[13]="zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzaBcDeFgHiJkLmN";
2089 text[14]="zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzaBcDeFgHiJkLmNo";
2090 text[15]="zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzaBcDeFgHiJkLmNoP";
2091
2092 char *needle[16];
2093 needle[0]="a";
2094 needle[1]="aB";
2095 needle[2]="aBc";
2096 needle[3]="aBcD";
2097 needle[4]="aBcDe";
2098 needle[5]="aBcDeF";
2099 needle[6]="aBcDeFg";
2100 needle[7]="aBcDeFgH";
2101 needle[8]="aBcDeFgHi";
2102 needle[9]="aBcDeFgHiJ";
2103 needle[10]="aBcDeFgHiJk";
2104 needle[11]="aBcDeFgHiJkL";
2105 needle[12]="aBcDeFgHiJkLm";
2106 needle[13]="aBcDeFgHiJkLmN";
2107 needle[14]="aBcDeFgHiJkLmNo";
2108 needle[15]="aBcDeFgHiJkLmNoP";
2109
2110 int i;
2111 uint8_t *found = NULL;
2112 printf("\nStats for text of greater length:\n");
2113 for (i = 0; i < 16; i++) {
2114 printf("Pattern length %d with BasicSearch:", i+1);
2115 found = BasicSearchNocaseWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
2116 if (found == 0) {
2117 printf("Error1 searching for %s in text %s\n", needle[i], text[i]);
2118 return 0;
2119 }
2120 printf("Pattern length %d with Bs2BmSearch:", i+1);
2121 found = Bs2bmNocaseWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
2122 if (found == 0) {
2123 printf("Error2 searching for %s in text %s\n", needle[i], text[i]);
2124 return 0;
2125 }
2126 printf("Pattern length %d with BoyerMooreSearch:", i+1);
2127 found = BoyerMooreNocaseWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
2128 if (found == 0) {
2129 printf("Error3 searching for %s in text %s\n", needle[i], text[i]);
2130 return 0;
2131 }
2132 printf("\n");
2133 }
2134 return 1;
2135 }
2136
UtilSpmNocaseSearchStatsTest02(void)2137 static int UtilSpmNocaseSearchStatsTest02(void)
2138 {
2139 char *text[16];
2140 text[0]="zzzzzzzzzzzzzzzzzza";
2141 text[1]="zzzzzzzzzzzzzzzzzzaB";
2142 text[2]="zzzzzzzzzzzzzzzzzzaBc";
2143 text[3]="zzzzzzzzzzzzzzzzzzaBcD";
2144 text[4]="zzzzzzzzzzzzzzzzzzaBcDe";
2145 text[5]="zzzzzzzzzzzzzzzzzzzzaBcDeF";
2146 text[6]="zzzzzzzzzzzzzzzzzzzzaBcDeFg";
2147 text[7]="zzzzzzzzzzzzzzzzzzzzaBcDeFgH";
2148 text[8]="zzzzzzzzzzzzzzzzzzzzaBcDeFgHi";
2149 text[9]="zzzzzzzzzzzzzzzzzzzzaBcDeFgHiJ";
2150 text[10]="zzzzzzzzzzzzzzzzzzzzaBcDeFgHiJk";
2151 text[11]="zzzzzzzzzzzzzzzzzzzzaBcDeFgHiJkL";
2152 text[12]="zzzzzzzzzzzzzzzzzzzzaBcDeFgHiJkLm";
2153 text[13]="zzzzzzzzzzzzzzzzzzzzaBcDeFgHiJkLmN";
2154 text[14]="zzzzzzzzzzzzzzzzzzzzaBcDeFgHiJkLmNo";
2155 text[15]="zzzzzzzzzzzzzzzzzzzzaBcDeFgHiJkLmNoP";
2156
2157 char *needle[16];
2158 needle[0]="a";
2159 needle[1]="aB";
2160 needle[2]="aBc";
2161 needle[3]="aBcD";
2162 needle[4]="aBcDe";
2163 needle[5]="aBcDeF";
2164 needle[6]="aBcDeFg";
2165 needle[7]="aBcDeFgH";
2166 needle[8]="aBcDeFgHi";
2167 needle[9]="aBcDeFgHiJ";
2168 needle[10]="aBcDeFgHiJk";
2169 needle[11]="aBcDeFgHiJkL";
2170 needle[12]="aBcDeFgHiJkLm";
2171 needle[13]="aBcDeFgHiJkLmN";
2172 needle[14]="aBcDeFgHiJkLmNo";
2173 needle[15]="aBcDeFgHiJkLmNoP";
2174
2175 int i;
2176 uint8_t *found = NULL;
2177 printf("\nStats for text of lower length:\n");
2178 for (i = 0; i < 16; i++) {
2179 printf("Pattern length %d with BasicSearch:", i+1);
2180 found = BasicSearchNocaseWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
2181 if (found == 0) {
2182 printf("Error1 searching for %s in text %s\n", needle[i], text[i]);
2183 return 0;
2184 }
2185 printf("Pattern length %d with Bs2BmSearch:", i+1);
2186 found = Bs2bmNocaseWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
2187 if (found == 0) {
2188 printf("Error2 searching for %s in text %s\n", needle[i], text[i]);
2189 return 0;
2190 }
2191 printf("Pattern length %d with BoyerMooreSearch:", i+1);
2192 found = BoyerMooreNocaseWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
2193 if (found == 0) {
2194 printf("Error3 searching for %s in text %s\n", needle[i], text[i]);
2195 return 0;
2196 }
2197 printf("\n");
2198 }
2199 return 1;
2200 }
2201
2202
UtilSpmNocaseSearchStatsTest03(void)2203 static int UtilSpmNocaseSearchStatsTest03(void)
2204 {
2205 char *text[16];
2206 text[0]="zzzzkzzzzzzzkzzzzzza";
2207 text[1]="BBBBkBBBBBBBkBBBBBaB";
2208 text[2]="BcBckcBcBcBckcBcBcaBc";
2209 text[3]="BcDBkDBcDBcDkcDBcDaBcD";
2210 text[4]="BcDekcDeBcDekcDezzaBcDe";
2211
2212 char *needle[16];
2213 needle[0]="a";
2214 needle[1]="aB";
2215 needle[2]="aBc";
2216 needle[3]="aBcD";
2217 needle[4]="aBcDe";
2218
2219 int i;
2220 uint8_t *found = NULL;
2221 printf("\nStats for text of lower length (badcase for):\n");
2222 for (i = 0; i < 5; i++) {
2223 printf("Pattern length %d with BasicSearch:", i+1);
2224 found = BasicSearchNocaseWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
2225 if (found == 0) {
2226 printf("Error1 searching for %s in text %s\n", needle[i], text[i]);
2227 return 0;
2228 }
2229 printf("Pattern length %d with Bs2BmSearch:", i+1);
2230 found = Bs2bmNocaseWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
2231 if (found == 0) {
2232 printf("Error2 searching for %s in text %s\n", needle[i], text[i]);
2233 return 0;
2234 }
2235 printf("Pattern length %d with BoyerMooreSearch:", i+1);
2236 found = BoyerMooreNocaseWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
2237 if (found == 0) {
2238 printf("Error3 searching for %s in text %s\n", needle[i], text[i]);
2239 return 0;
2240 }
2241 printf("\n");
2242 }
2243 return 1;
2244 }
2245
2246 /**
2247 * \test Give some stats for no case algorithms
2248 */
UtilSpmNocaseSearchStatsTest04(void)2249 static int UtilSpmNocaseSearchStatsTest04(void)
2250 {
2251 char *text[16];
2252 text[0]="zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzza";
2253 text[1]="zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzaB";
2254 text[2]="zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzaBc";
2255 text[3]="zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzaBcD";
2256 text[4]="zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzaBcDe";
2257 text[5]="zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzaBcDeF";
2258 text[6]="zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzaBcDeFg";
2259 text[7]="zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzaBcDeFgH";
2260 text[8]="zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzaBcDeFgHi";
2261 text[9]="zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzaBcDeFgHiJ";
2262 text[10]="zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzaBcDeFgHiJk";
2263 text[11]="zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzaBcDeFgHiJkL";
2264 text[12]="zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzaBcDeFgHiJkLm";
2265 text[13]="zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzaBcDeFgHiJkLmN";
2266 text[14]="zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzaBcDeFgHiJkLmNo";
2267 text[15]="zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzaBcDeFgHiJkLmNoP";
2268
2269 char *needle[16];
2270 needle[0]="a";
2271 needle[1]="aB";
2272 needle[2]="aBc";
2273 needle[3]="aBcD";
2274 needle[4]="aBcDe";
2275 needle[5]="aBcDeF";
2276 needle[6]="aBcDeFg";
2277 needle[7]="aBcDeFgH";
2278 needle[8]="aBcDeFgHi";
2279 needle[9]="aBcDeFgHiJ";
2280 needle[10]="aBcDeFgHiJk";
2281 needle[11]="aBcDeFgHiJkL";
2282 needle[12]="aBcDeFgHiJkLm";
2283 needle[13]="aBcDeFgHiJkLmN";
2284 needle[14]="aBcDeFgHiJkLmNo";
2285 needle[15]="aBcDeFgHiJkLmNoP";
2286
2287 int i;
2288 uint8_t *found = NULL;
2289 printf("\nStats for text of greater length:\n");
2290 for (i = 0; i < 16; i++) {
2291 printf("Pattern length %d with BasicSearch (Building Context):", i+1);
2292 found = BasicSearchNocaseCtxWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
2293 if (found == 0) {
2294 printf("Error1 searching for %s in text %s\n", needle[i], text[i]);
2295 return 0;
2296 }
2297 printf("Pattern length %d with Bs2BmSearch (Building Context):", i+1);
2298 found = Bs2bmNocaseCtxWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
2299 if (found == 0) {
2300 printf("Error2 searching for %s in text %s\n", needle[i], text[i]);
2301 return 0;
2302 }
2303 printf("Pattern length %d with BoyerMooreSearch (Building Context):", i+1);
2304 found = BoyerMooreNocaseCtxWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
2305 if (found == 0) {
2306 printf("Error3 searching for %s in text %s\n", needle[i], text[i]);
2307 return 0;
2308 }
2309 printf("\n");
2310 }
2311 return 1;
2312 }
2313
UtilSpmNocaseSearchStatsTest05(void)2314 static int UtilSpmNocaseSearchStatsTest05(void)
2315 {
2316 char *text[16];
2317 text[0]="zzzzzzzzzzzzzzzzzza";
2318 text[1]="zzzzzzzzzzzzzzzzzzaB";
2319 text[2]="zzzzzzzzzzzzzzzzzzaBc";
2320 text[3]="zzzzzzzzzzzzzzzzzzaBcD";
2321 text[4]="zzzzzzzzzzzzzzzzzzaBcDe";
2322 text[5]="zzzzzzzzzzzzzzzzzzzzaBcDeF";
2323 text[6]="zzzzzzzzzzzzzzzzzzzzaBcDeFg";
2324 text[7]="zzzzzzzzzzzzzzzzzzzzaBcDeFgH";
2325 text[8]="zzzzzzzzzzzzzzzzzzzzaBcDeFgHi";
2326 text[9]="zzzzzzzzzzzzzzzzzzzzaBcDeFgHiJ";
2327 text[10]="zzzzzzzzzzzzzzzzzzzzaBcDeFgHiJk";
2328 text[11]="zzzzzzzzzzzzzzzzzzzzaBcDeFgHiJkL";
2329 text[12]="zzzzzzzzzzzzzzzzzzzzaBcDeFgHiJkLm";
2330 text[13]="zzzzzzzzzzzzzzzzzzzzaBcDeFgHiJkLmN";
2331 text[14]="zzzzzzzzzzzzzzzzzzzzaBcDeFgHiJkLmNo";
2332 text[15]="zzzzzzzzzzzzzzzzzzzzaBcDeFgHiJkLmNoP";
2333
2334 char *needle[16];
2335 needle[0]="a";
2336 needle[1]="aB";
2337 needle[2]="aBc";
2338 needle[3]="aBcD";
2339 needle[4]="aBcDe";
2340 needle[5]="aBcDeF";
2341 needle[6]="aBcDeFg";
2342 needle[7]="aBcDeFgH";
2343 needle[8]="aBcDeFgHi";
2344 needle[9]="aBcDeFgHiJ";
2345 needle[10]="aBcDeFgHiJk";
2346 needle[11]="aBcDeFgHiJkL";
2347 needle[12]="aBcDeFgHiJkLm";
2348 needle[13]="aBcDeFgHiJkLmN";
2349 needle[14]="aBcDeFgHiJkLmNo";
2350 needle[15]="aBcDeFgHiJkLmNoP";
2351
2352 int i;
2353 uint8_t *found = NULL;
2354 printf("\nStats for text of lower length:\n");
2355 for (i = 0; i < 16; i++) {
2356 printf("Pattern length %d with BasicSearch (Building Context):", i+1);
2357 found = BasicSearchNocaseCtxWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
2358 if (found == 0) {
2359 printf("Error1 searching for %s in text %s\n", needle[i], text[i]);
2360 return 0;
2361 }
2362 printf("Pattern length %d with Bs2BmSearch (Building Context):", i+1);
2363 found = Bs2bmNocaseCtxWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
2364 if (found == 0) {
2365 printf("Error2 searching for %s in text %s\n", needle[i], text[i]);
2366 return 0;
2367 }
2368 printf("Pattern length %d with BoyerMooreSearch (Building Context):", i+1);
2369 found = BoyerMooreNocaseCtxWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
2370 if (found == 0) {
2371 printf("Error3 searching for %s in text %s\n", needle[i], text[i]);
2372 return 0;
2373 }
2374 printf("\n");
2375 }
2376 return 1;
2377 }
2378
2379
UtilSpmNocaseSearchStatsTest06(void)2380 static int UtilSpmNocaseSearchStatsTest06(void)
2381 {
2382 char *text[16];
2383 text[0]="zzzzkzzzzzzzkzzzzzza";
2384 text[1]="BBBBkBBBBBBBkBBBBBaB";
2385 text[2]="BcBckcBcBcBckcBcBcaBc";
2386 text[3]="BcDBkDBcDBcDkcDBcDaBcD";
2387 text[4]="BcDekcDeBcDekcDezzaBcDe";
2388
2389 char *needle[16];
2390 needle[0]="a";
2391 needle[1]="aB";
2392 needle[2]="aBc";
2393 needle[3]="aBcD";
2394 needle[4]="aBcDe";
2395
2396 int i;
2397 uint8_t *found = NULL;
2398 printf("\nStats for text of lower length (badcase for):\n");
2399 for (i = 0; i < 5; i++) {
2400 printf("Pattern length %d with BasicSearch (Building Context):", i+1);
2401 found = BasicSearchNocaseCtxWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
2402 if (found == 0) {
2403 printf("Error1 searching for %s in text %s\n", needle[i], text[i]);
2404 return 0;
2405 }
2406 printf("Pattern length %d with Bs2BmSearch (Building Context):", i+1);
2407 found = Bs2bmNocaseCtxWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
2408 if (found == 0) {
2409 printf("Error2 searching for %s in text %s\n", needle[i], text[i]);
2410 return 0;
2411 }
2412 printf("Pattern length %d with BoyerMooreSearch (Building Context):", i+1);
2413 found = BoyerMooreNocaseCtxWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
2414 if (found == 0) {
2415 printf("Error3 searching for %s in text %s\n", needle[i], text[i]);
2416 return 0;
2417 }
2418 printf("\n");
2419 }
2420 return 1;
2421 }
2422
UtilSpmNocaseSearchStatsTest07(void)2423 static int UtilSpmNocaseSearchStatsTest07(void)
2424 {
2425 char *text[16];
2426 text[0]="zzzza";
2427 text[1]="bbbAb";
2428 text[2]="bbAbC";
2429 text[3]="bAbCd";
2430 text[4]="AbCdE";
2431
2432 char *needle[16];
2433 needle[0]="a";
2434 needle[1]="aB";
2435 needle[2]="aBc";
2436 needle[3]="aBcD";
2437 needle[4]="aBcDe";
2438
2439 int i;
2440 uint8_t *found = NULL;
2441 printf("\nStats for text of real lower length (badcase for):\n");
2442 for (i = 0; i < 5; i++) {
2443 printf("Pattern length %d with BasicSearch (Building Context):", i+1);
2444 found = BasicSearchNocaseCtxWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
2445 if (found == 0) {
2446 printf("Error1 searching for %s in text %s\n", needle[i], text[i]);
2447 return 0;
2448 }
2449 printf("Pattern length %d with Bs2BmSearch (Building Context):", i+1);
2450 found = Bs2bmNocaseCtxWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
2451 if (found == 0) {
2452 printf("Error2 searching for %s in text %s\n", needle[i], text[i]);
2453 return 0;
2454 }
2455 printf("Pattern length %d with BoyerMooreSearch (Building Context):", i+1);
2456 found = BoyerMooreNocaseCtxWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
2457 if (found == 0) {
2458 printf("Error3 searching for %s in text %s\n", needle[i], text[i]);
2459 return 0;
2460 }
2461 printf("\n");
2462 }
2463 return 1;
2464 }
2465 #endif
2466
2467 /* Unit tests for new SPM API. */
2468
2469 #define SPM_NO_MATCH UINT32_MAX
2470
2471 /* Helper structure describing a particular search. */
2472 typedef struct SpmTestData_ {
2473 const char *needle;
2474 uint16_t needle_len;
2475 const char *haystack;
2476 uint16_t haystack_len;
2477 int nocase;
2478 uint32_t match_offset; /* offset in haystack, or SPM_NO_MATCH. */
2479 } SpmTestData;
2480
2481 /* Helper function to conduct a search with a particular SPM matcher. */
SpmTestSearch(const SpmTestData * d,uint16_t matcher)2482 static int SpmTestSearch(const SpmTestData *d, uint16_t matcher)
2483 {
2484 int ret = 1;
2485 SpmGlobalThreadCtx *global_thread_ctx = NULL;
2486 SpmThreadCtx *thread_ctx = NULL;
2487 SpmCtx *ctx = NULL;
2488 uint8_t *found = NULL;
2489
2490 global_thread_ctx = SpmInitGlobalThreadCtx(matcher);
2491 if (global_thread_ctx == NULL) {
2492 ret = 0;
2493 goto exit;
2494 }
2495
2496 ctx = SpmInitCtx((const uint8_t *)d->needle, d->needle_len, d->nocase,
2497 global_thread_ctx);
2498 if (ctx == NULL) {
2499 ret = 0;
2500 goto exit;
2501 }
2502
2503 thread_ctx = SpmMakeThreadCtx(global_thread_ctx);
2504 if (thread_ctx == NULL) {
2505 ret = 0;
2506 goto exit;
2507 }
2508
2509 found = SpmScan(ctx, thread_ctx, (const uint8_t *)d->haystack,
2510 d->haystack_len);
2511 if (found == NULL) {
2512 if (d->match_offset != SPM_NO_MATCH) {
2513 printf(" should have matched at %" PRIu32 " but didn't\n",
2514 d->match_offset);
2515 ret = 0;
2516 }
2517 } else {
2518 uint32_t offset = (uint32_t)(found - (const uint8_t *)d->haystack);
2519 if (offset != d->match_offset) {
2520 printf(" should have matched at %" PRIu32
2521 " but matched at %" PRIu32 "\n",
2522 d->match_offset, offset);
2523 ret = 0;
2524 }
2525 }
2526
2527 exit:
2528 SpmDestroyCtx(ctx);
2529 SpmDestroyThreadCtx(thread_ctx);
2530 SpmDestroyGlobalThreadCtx(global_thread_ctx);
2531 return ret;
2532 }
2533
SpmSearchTest01(void)2534 static int SpmSearchTest01(void) {
2535 SpmTableSetup();
2536 printf("\n");
2537
2538 /* Each of the following tests will be run against every registered SPM
2539 * algorithm. */
2540
2541 static const SpmTestData data[] = {
2542 /* Some trivial single-character case/nocase tests */
2543 {"a", 1, "a", 1, 0, 0},
2544 {"a", 1, "A", 1, 1, 0},
2545 {"A", 1, "A", 1, 0, 0},
2546 {"A", 1, "a", 1, 1, 0},
2547 {"a", 1, "A", 1, 0, SPM_NO_MATCH},
2548 {"A", 1, "a", 1, 0, SPM_NO_MATCH},
2549 /* Nulls and odd characters */
2550 {"\x00", 1, "test\x00test", 9, 0, 4},
2551 {"\x00", 1, "testtest", 8, 0, SPM_NO_MATCH},
2552 {"\n", 1, "new line\n", 9, 0, 8},
2553 {"\n", 1, "new line\x00\n", 10, 0, 9},
2554 {"\xff", 1, "abcdef\xff", 7, 0, 6},
2555 {"\xff", 1, "abcdef\xff", 7, 1, 6},
2556 {"$", 1, "dollar$", 7, 0, 6},
2557 {"^", 1, "caret^", 6, 0, 5},
2558 /* Longer literals */
2559 {"Suricata", 8, "This is a Suricata test", 23, 0, 10},
2560 {"Suricata", 8, "This is a suricata test", 23, 1, 10},
2561 {"Suricata", 8, "This is a suriCATA test", 23, 1, 10},
2562 {"suricata", 8, "This is a Suricata test", 23, 0, SPM_NO_MATCH},
2563 {"Suricata", 8, "This is a Suricat_ test", 23, 0, SPM_NO_MATCH},
2564 {"Suricata", 8, "This is a _uricata test", 23, 0, SPM_NO_MATCH},
2565 /* First occurrence with the correct case should match */
2566 {"foo", 3, "foofoofoo", 9, 0, 0},
2567 {"foo", 3, "_foofoofoo", 9, 0, 1},
2568 {"FOO", 3, "foofoofoo", 9, 1, 0},
2569 {"FOO", 3, "_foofoofoo", 9, 1, 1},
2570 {"FOO", 3, "foo Foo FOo fOo foO FOO", 23, 0, 20},
2571 {"foo", 3, "Foo FOo fOo foO FOO foo", 23, 0, 20},
2572 };
2573
2574 int ret = 1;
2575
2576 uint16_t matcher;
2577 for (matcher = 0; matcher < SPM_TABLE_SIZE; matcher++) {
2578 const SpmTableElmt *m = &spm_table[matcher];
2579 if (m->name == NULL) {
2580 continue;
2581 }
2582 printf("matcher: %s\n", m->name);
2583
2584 uint32_t i;
2585 for (i = 0; i < sizeof(data)/sizeof(data[0]); i++) {
2586 const SpmTestData *d = &data[i];
2587 if (SpmTestSearch(d, matcher) == 0) {
2588 printf(" test %" PRIu32 ": fail\n", i);
2589 ret = 0;
2590 }
2591 }
2592 printf(" %" PRIu32 " tests passed\n", i);
2593 }
2594
2595 return ret;
2596 }
2597
SpmSearchTest02(void)2598 static int SpmSearchTest02(void) {
2599 SpmTableSetup();
2600 printf("\n");
2601
2602 /* Test that we can find needles of various lengths at various alignments
2603 * in the haystack. Note that these are passed to strlen. */
2604
2605 static const char* needles[] = {
2606 /* Single bytes */
2607 "a", "b", "c", ":", "/", "\x7f", "\xff",
2608 /* Repeats */
2609 "aa", "aaa", "aaaaaaaaaaaaaaaaaaaaaaa",
2610 /* Longer literals */
2611 "suricata", "meerkat", "aardvark", "raptor", "marmot", "lemming",
2612 /* Mixed case */
2613 "Suricata", "CAPS LOCK", "mIxEd cAsE",
2614 };
2615
2616 int ret = 1;
2617
2618 uint16_t matcher;
2619 for (matcher = 0; matcher < SPM_TABLE_SIZE; matcher++) {
2620 const SpmTableElmt *m = &spm_table[matcher];
2621 if (m->name == NULL) {
2622 continue;
2623 }
2624 printf("matcher: %s\n", m->name);
2625
2626 SpmTestData d;
2627
2628 uint32_t i;
2629 for (i = 0; i < sizeof(needles) / sizeof(needles[0]); i++) {
2630 const char *needle = needles[i];
2631 uint16_t prefix;
2632 for (prefix = 0; prefix < 32; prefix++) {
2633 d.needle = needle;
2634 d.needle_len = strlen(needle);
2635 uint16_t haystack_len = prefix + d.needle_len;
2636 char *haystack = SCMalloc(haystack_len);
2637 if (haystack == NULL) {
2638 printf("alloc failure\n");
2639 return 0;
2640 }
2641 memset(haystack, ' ', haystack_len);
2642 memcpy(haystack + prefix, d.needle, d.needle_len);
2643 d.haystack = haystack;
2644 d.haystack_len = haystack_len;
2645 d.nocase = 0;
2646 d.match_offset = prefix;
2647
2648 /* Case-sensitive scan */
2649 if (SpmTestSearch(&d, matcher) == 0) {
2650 printf(" test %" PRIu32 ": fail (case-sensitive)\n", i);
2651 ret = 0;
2652 }
2653
2654 /* Case-insensitive scan */
2655 d.nocase = 1;
2656 uint16_t j;
2657 for (j = 0; j < haystack_len; j++) {
2658 haystack[j] = toupper(haystack[j]);
2659 }
2660 if (SpmTestSearch(&d, matcher) == 0) {
2661 printf(" test %" PRIu32 ": fail (case-insensitive)\n", i);
2662 ret = 0;
2663 }
2664
2665 SCFree(haystack);
2666 }
2667 }
2668 printf(" %" PRIu32 " tests passed\n", i);
2669 }
2670
2671 return ret;
2672 }
2673
2674 #endif
2675
2676 /* Register unittests */
UtilSpmSearchRegistertests(void)2677 void UtilSpmSearchRegistertests(void)
2678 {
2679 #ifdef UNITTESTS
2680 /* Generic tests */
2681 UtRegisterTest("UtilSpmBasicSearchTest01", UtilSpmBasicSearchTest01);
2682 UtRegisterTest("UtilSpmBasicSearchNocaseTest01",
2683 UtilSpmBasicSearchNocaseTest01);
2684
2685 UtRegisterTest("UtilSpmBs2bmSearchTest01", UtilSpmBs2bmSearchTest01);
2686 UtRegisterTest("UtilSpmBs2bmSearchNocaseTest01",
2687 UtilSpmBs2bmSearchNocaseTest01);
2688
2689 UtRegisterTest("UtilSpmBoyerMooreSearchTest01",
2690 UtilSpmBoyerMooreSearchTest01);
2691 UtRegisterTest("UtilSpmBoyerMooreSearchNocaseTest01",
2692 UtilSpmBoyerMooreSearchNocaseTest01);
2693 UtRegisterTest("UtilSpmBoyerMooreSearchNocaseTestIssue130",
2694 UtilSpmBoyerMooreSearchNocaseTestIssue130);
2695
2696 UtRegisterTest("UtilSpmBs2bmSearchTest02", UtilSpmBs2bmSearchTest02);
2697 UtRegisterTest("UtilSpmBs2bmSearchNocaseTest02",
2698 UtilSpmBs2bmSearchNocaseTest02);
2699
2700 UtRegisterTest("UtilSpmBasicSearchTest02", UtilSpmBasicSearchTest02);
2701 UtRegisterTest("UtilSpmBasicSearchNocaseTest02",
2702 UtilSpmBasicSearchNocaseTest02);
2703
2704 UtRegisterTest("UtilSpmBoyerMooreSearchTest02",
2705 UtilSpmBoyerMooreSearchTest02);
2706 UtRegisterTest("UtilSpmBoyerMooreSearchNocaseTest02",
2707 UtilSpmBoyerMooreSearchNocaseTest02);
2708
2709 /* test matches at any offset */
2710 UtRegisterTest("UtilSpmSearchOffsetsTest01", UtilSpmSearchOffsetsTest01);
2711 UtRegisterTest("UtilSpmSearchOffsetsNocaseTest01",
2712 UtilSpmSearchOffsetsNocaseTest01);
2713
2714 /* new SPM API */
2715 UtRegisterTest("SpmSearchTest01", SpmSearchTest01);
2716 UtRegisterTest("SpmSearchTest02", SpmSearchTest02);
2717
2718 #ifdef ENABLE_SEARCH_STATS
2719 /* Give some stats searching given a prepared context (look at the wrappers) */
2720 UtRegisterTest("UtilSpmSearchStatsTest01", UtilSpmSearchStatsTest01);
2721 UtRegisterTest("UtilSpmSearchStatsTest02", UtilSpmSearchStatsTest02);
2722 UtRegisterTest("UtilSpmSearchStatsTest03", UtilSpmSearchStatsTest03);
2723
2724 UtRegisterTest("UtilSpmNocaseSearchStatsTest01",
2725 UtilSpmNocaseSearchStatsTest01);
2726 UtRegisterTest("UtilSpmNocaseSearchStatsTest02",
2727 UtilSpmNocaseSearchStatsTest02);
2728 UtRegisterTest("UtilSpmNocaseSearchStatsTest03",
2729 UtilSpmNocaseSearchStatsTest03);
2730
2731 /* Stats building context and searching */
2732 UtRegisterTest("UtilSpmSearchStatsTest04", UtilSpmSearchStatsTest04);
2733 UtRegisterTest("UtilSpmSearchStatsTest05", UtilSpmSearchStatsTest05);
2734 UtRegisterTest("UtilSpmSearchStatsTest06", UtilSpmSearchStatsTest06);
2735 UtRegisterTest("UtilSpmSearchStatsTest07", UtilSpmSearchStatsTest07);
2736
2737 UtRegisterTest("UtilSpmNocaseSearchStatsTest04",
2738 UtilSpmNocaseSearchStatsTest04);
2739 UtRegisterTest("UtilSpmNocaseSearchStatsTest05",
2740 UtilSpmNocaseSearchStatsTest05);
2741 UtRegisterTest("UtilSpmNocaseSearchStatsTest06",
2742 UtilSpmNocaseSearchStatsTest06);
2743 UtRegisterTest("UtilSpmNocaseSearchStatsTest07",
2744 UtilSpmNocaseSearchStatsTest07);
2745
2746 #endif
2747 #endif
2748 }
2749