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