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