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