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