util-spm.c

Go to the documentation of this file.

/* Copyright (C) 2007-2022 Open Information Security Foundation
 *
 * You can copy, redistribute or modify this Program under the terms of
 * the GNU General Public License version 2 as published by the Free
 * Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * version 2 along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 * 02110-1301, USA.
 */
 
/**
 * \file
 *
 * \author Pablo Rincon Crespo <pablo.rincon.crespo@gmail.com>
 *
 * PR (17/01/2010): Single pattern search algorithms:
 * Currently there are 3 algorithms to choose: BasicSearch, Bs2Bm and
 * BoyerMoore (Boyer Moores algorithm). The first one doesn't need a context.
 * But for Bs2Bm and BoyerMoore, you'll need to build some arrays.
 *
 * !! If you are going to use the same pattern multiple times,
 * please, try to store the context some where. For Bs2Bm, the
 * context is an array of "badchars". For BoyerMoore you need to store
 * two arrays of shifts. Have a look at the wrappers and unittests
 * for examples of this. If you cant store the context, use the
 * wrappers: Bs2bmSearch, BoyerMooreSearch, and the ones caseless, or BasicSearch
 * That is the most basic.
 *
 * Use the stats and util-clock.h to determine which one fit better for you
 * Boyer Moore should be used for patterns greater than 1 of length
 * In the range of 2 - 6, if the text length is greater than 1000 you could
 * use boyer moore, otherwise, basic search. If the pattern is greater
 * than 6 and the textlen is greater than 500, use boyer moore.
 * This is an aproximation, but use the stats and util-clock to determine which one
 * fit better for your case.
 *
 */
 
#include "suricata-common.h"
#include "util-unittest.h"
 
#include "conf.h"
 
#include "util-spm.h"
#include "util-spm-bs.h"
#include "util-spm-bs2bm.h"
#include "util-spm-bm.h"
#include "util-spm-hs.h"
#include "util-spm-mm.h"
#include "util-clock.h"
#ifdef BUILD_HYPERSCAN
#include "hs.h"
#endif
#include "util-debug.h"
 
SpmTableElmt spm_table[SPM_TABLE_SIZE];
 
/**
 * \brief Returns the single pattern matcher algorithm to be used, based on the
 * spm-algo setting in yaml.
 */
uint8_t SinglePatternMatchDefaultMatcher(void)
{
    const char *spm_algo;
    if ((SCConfGet("spm-algo", &spm_algo)) == 1) {
        if (spm_algo != NULL) {
            if (strcmp("auto", spm_algo) == 0) {
                goto default_matcher;
            }
            for (uint8_t i = 0; i < SPM_TABLE_SIZE; i++) {
                if (spm_table[i].name == NULL) {
                    continue;
                }
                if (strcmp(spm_table[i].name, spm_algo) == 0) {
                    return i;
                }
            }
        }
 
#ifndef BUILD_HYPERSCAN
        if ((spm_algo != NULL) && (strcmp(spm_algo, "hs") == 0)) {
            FatalError("Hyperscan (hs) support for spm-algo is "
                       "not compiled into Suricata.");
        }
#endif
#ifndef HAVE_MEMMEM
        if ((spm_algo != NULL) && (strcmp(spm_algo, "mm") == 0)) {
            FatalError("Memmem (mm) support for spm-algo is "
                       "not compiled into Suricata.");
        }
#endif
        SCLogError("Invalid spm algo supplied "
                   "in the yaml conf file: \"%s\"",
                spm_algo);
        exit(EXIT_FAILURE);
    }
 
default_matcher:
    /* When Suricata is built with Hyperscan support, default to using it for
     * SPM. */
#if defined(BUILD_HYPERSCAN)
#ifdef HAVE_HS_VALID_PLATFORM
    /* Enable runtime check for SSSE3. Do not use Hyperscan SPM matcher if
     * check is not successful. */
        if (hs_valid_platform() != HS_SUCCESS) {
            SCLogInfo("SSSE3 support not detected, disabling Hyperscan for "
                      "SPM");
            /* Use Boyer-Moore as fallback. */
            return SPM_BM;
        } else {
            return SPM_HS;
        }
#else
    return SPM_HS;
#endif
#elif defined(HAVE_MEMMEM)
    return SPM_MM;
#else
    /* Otherwise, default to Boyer-Moore */
    return SPM_BM;
#endif
}
 
void SpmTableSetup(void)
{
    memset(spm_table, 0, sizeof(spm_table));
 
    SpmBMRegister();
    SpmMMRegister();
#ifdef BUILD_HYPERSCAN
    #ifdef HAVE_HS_VALID_PLATFORM
        if (hs_valid_platform() == HS_SUCCESS) {
            SpmHSRegister();
        }
    #else
        SpmHSRegister();
    #endif
#endif
}
 
SpmGlobalThreadCtx *SpmInitGlobalThreadCtx(uint8_t matcher)
{
    BUG_ON(spm_table[matcher].InitGlobalThreadCtx == NULL);
    return spm_table[matcher].InitGlobalThreadCtx();
}
 
void SpmDestroyGlobalThreadCtx(SpmGlobalThreadCtx *global_thread_ctx)
{
    if (global_thread_ctx == NULL) {
        return;
    }
    uint8_t matcher = global_thread_ctx->matcher;
    spm_table[matcher].DestroyGlobalThreadCtx(global_thread_ctx);
}
 
SpmThreadCtx *SpmMakeThreadCtx(const SpmGlobalThreadCtx *global_thread_ctx)
{
    if (global_thread_ctx == NULL) {
        return NULL;
    }
    uint8_t matcher = global_thread_ctx->matcher;
    BUG_ON(spm_table[matcher].MakeThreadCtx == NULL);
    return spm_table[matcher].MakeThreadCtx(global_thread_ctx);
}
 
void SpmDestroyThreadCtx(SpmThreadCtx *thread_ctx)
{
    if (thread_ctx == NULL) {
        return;
    }
    uint8_t matcher = thread_ctx->matcher;
    BUG_ON(spm_table[matcher].DestroyThreadCtx == NULL);
    spm_table[matcher].DestroyThreadCtx(thread_ctx);
}
 
SpmCtx *SpmInitCtx(const uint8_t *needle, uint16_t needle_len, int nocase,
                   SpmGlobalThreadCtx *global_thread_ctx)
{
    BUG_ON(global_thread_ctx == NULL);
    uint8_t matcher = global_thread_ctx->matcher;
    BUG_ON(spm_table[matcher].InitCtx == NULL);
    return spm_table[matcher].InitCtx(needle, needle_len, nocase,
                                      global_thread_ctx);
}
 
void SpmDestroyCtx(SpmCtx *ctx)
{
    if (ctx == NULL) {
        return;
    }
    uint8_t matcher = ctx->matcher;
    BUG_ON(spm_table[matcher].DestroyCtx == NULL);
    spm_table[matcher].DestroyCtx(ctx);
}
 
uint8_t *SpmScan(const SpmCtx *ctx, SpmThreadCtx *thread_ctx,
                 const uint8_t *haystack, uint32_t haystack_len)
{
    uint8_t matcher = ctx->matcher;
    return spm_table[matcher].Scan(ctx, thread_ctx, haystack, haystack_len);
}
 
/**
 * Wrappers for building context and searching (Bs2Bm and boyermoore)
 * Use them if you cant store the context
 *
 */
 
/**
 * \brief Search a pattern in the text using the Bs2Bm algorithm (build a bad characters array)
 *
 * \param text Text to search in
 * \param textlen length of the text
 * \param needle pattern to search for
 * \param needlelen length of the pattern
 */
uint8_t *Bs2bmSearch(const uint8_t *text, uint32_t textlen,
        const uint8_t *needle, uint16_t needlelen)
{
    uint8_t badchars[ALPHABET_SIZE];
    Bs2BmBadchars(needle, needlelen, badchars);
 
    return Bs2Bm(text, textlen, needle, needlelen, badchars);
}
 
/**
 * \brief Search a pattern in the text using Boyer Moore algorithm
 *        (build a bad character shifts array and good prefixes shift array)
 *
 * \param text Text to search in
 * \param textlen length of the text
 * \param needle pattern to search for
 * \param needlelen length of the pattern
 */
uint8_t *BoyerMooreSearch(const uint8_t *text, uint32_t textlen,
        const uint8_t *needle, uint16_t needlelen)
{
    BmCtx *bm_ctx = BoyerMooreCtxInit(needle, needlelen);
 
    uint8_t *ret = BoyerMoore(needle, needlelen, text, textlen, bm_ctx);
    BoyerMooreCtxDeInit(bm_ctx);
 
    return ret;
}
 
/**
 * \brief Search a pattern in the text using Boyer Moore nocase algorithm
 *        (build a bad character shifts array and good prefixes shift array)
 *
 * \param text Text to search in
 * \param textlen length of the text
 * \param needle pattern to search for
 * \param needlelen length of the pattern
 */
uint8_t *BoyerMooreNocaseSearch(const uint8_t *text, uint32_t textlen,
        uint8_t *needle, uint16_t needlelen)
{
    BmCtx *bm_ctx = BoyerMooreNocaseCtxInit(needle, needlelen);
 
    uint8_t *ret = BoyerMooreNocase(needle, needlelen, text, textlen, bm_ctx);
    BoyerMooreCtxDeInit(bm_ctx);
 
    return ret;
}
 
 
#ifdef UNITTESTS
 
/** Comment out this if you want stats
 *  #define ENABLE_SEARCH_STATS 1
 */
 
/**
 * \brief Unittest helper function wrappers for the search algorithms
 * \param text pointer to the buffer to search in
 * \param needle pointer to the pattern to search for
 * \param times If you are testing performance, se the numebr of times
 *              that you want to repeat the search
 */
static uint8_t *BasicSearchWrapper(uint8_t *text, uint8_t *needle, int times)
{
    uint32_t textlen = strlen((char *)text);
    uint16_t needlelen = (uint16_t)strlen((char *)needle);
 
    uint8_t *ret = NULL;
    int i = 0;
 
    CLOCK_INIT;
    if (times > 1)
        CLOCK_START;
 
    for (i = 0; i < times; i++) {
        ret = BasicSearch(text, textlen, needle, needlelen);
    }
 
    if (times > 1) { CLOCK_END; CLOCK_PRINT_SEC; };
    return ret;
}
 
static uint8_t *BasicSearchNocaseWrapper(uint8_t *text, uint8_t *needle, int times)
{
    uint32_t textlen = strlen((char *)text);
    uint16_t needlelen = (uint16_t)strlen((char *)needle);
 
    uint8_t *ret = NULL;
    int i = 0;
 
    CLOCK_INIT;
    if (times > 1) CLOCK_START;
    for (i = 0; i < times; i++) {
        ret = BasicSearchNocase(text, textlen, needle, needlelen);
    }
    if (times > 1) { CLOCK_END; CLOCK_PRINT_SEC; };
    return ret;
}
 
static uint8_t *Bs2bmWrapper(uint8_t *text, uint8_t *needle, int times)
{
    uint32_t textlen = strlen((char *)text);
    uint16_t needlelen = (uint16_t)strlen((char *)needle);
 
    uint8_t badchars[ALPHABET_SIZE];
    Bs2BmBadchars(needle, needlelen, badchars);
 
    uint8_t *ret = NULL;
    int i = 0;
 
    CLOCK_INIT;
    if (times > 1) CLOCK_START;
    for (i = 0; i < times; i++) {
        ret = Bs2Bm(text, textlen, needle, needlelen, badchars);
    }
    if (times > 1) { CLOCK_END; CLOCK_PRINT_SEC; };
    return ret;
}
 
static uint8_t *Bs2bmNocaseWrapper(uint8_t *text, uint8_t *needle, int times)
{
    uint32_t textlen = strlen((char *)text);
    uint16_t needlelen = (uint16_t)strlen((char *)needle);
 
    uint8_t badchars[ALPHABET_SIZE];
    Bs2BmBadchars(needle, needlelen, badchars);
 
    uint8_t *ret = NULL;
    int i = 0;
 
    CLOCK_INIT;
    if (times > 1) CLOCK_START;
    for (i = 0; i < times; i++) {
        ret = Bs2BmNocase(text, textlen, needle, needlelen, badchars);
    }
    if (times > 1) { CLOCK_END; CLOCK_PRINT_SEC; };
    return ret;
}
 
static uint8_t *BoyerMooreWrapper(uint8_t *text, uint8_t *needle, int times)
{
    uint32_t textlen = strlen((char *)text);
    uint16_t needlelen = (uint16_t)strlen((char *)needle);
 
    BmCtx *bm_ctx = BoyerMooreCtxInit(needle, needlelen);
 
    uint8_t *ret = NULL;
    int i = 0;
 
    CLOCK_INIT;
    if (times > 1) CLOCK_START;
    for (i = 0; i < times; i++) {
        ret = BoyerMoore(needle, needlelen, text, textlen, bm_ctx);
    }
    if (times > 1) { CLOCK_END; CLOCK_PRINT_SEC; };
    BoyerMooreCtxDeInit(bm_ctx);
    return ret;
}
 
static uint8_t *BoyerMooreNocaseWrapper(uint8_t *text, uint8_t *in_needle, int times)
{
    uint32_t textlen = strlen((char *)text);
    uint16_t needlelen = (uint16_t)strlen((char *)in_needle);
 
    /* Make a copy of in_needle to be able to convert it to lowercase. */
    uint8_t *needle = SCMalloc(needlelen);
    if (needle == NULL)
        return NULL;
    memcpy(needle, in_needle, needlelen);
 
    BmCtx *bm_ctx = BoyerMooreNocaseCtxInit(needle, needlelen);
 
    uint8_t *ret = NULL;
    int i = 0;
 
    CLOCK_INIT;
    if (times > 1) CLOCK_START;
    for (i = 0; i < times; i++) {
        ret = BoyerMooreNocase(needle, needlelen, text, textlen, bm_ctx);
    }
    if (times > 1) { CLOCK_END; CLOCK_PRINT_SEC; };
    BoyerMooreCtxDeInit(bm_ctx);
    free(needle);
    return ret;
 
}
 
#ifdef ENABLE_SEARCH_STATS
/* Number of times to repeat the search (for stats) */
#define STATS_TIMES 1000000
 
/**
 * \brief Unittest helper function wrappers for the search algorithms
 * \param text pointer to the buffer to search in
 * \param needle pointer to the pattern to search for
 * \param times If you are testing performance, se the numebr of times
 *              that you want to repeat the search
 */
static uint8_t *BasicSearchCtxWrapper(uint8_t *text, uint8_t *needle, int times)
{
    uint32_t textlen = strlen((char *)text);
    uint16_t needlelen = strlen((char *)needle);
 
    uint8_t *ret = NULL;
    int i = 0;
 
    CLOCK_INIT;
    if (times > 1) CLOCK_START;
    for (i = 0; i < times; i++) {
        /* This wrapper is a fake, no context needed! */
        ret = BasicSearch(text, textlen, needle, needlelen);
    }
    if (times > 1) { CLOCK_END; CLOCK_PRINT_SEC; };
    return ret;
}
 
static uint8_t *BasicSearchNocaseCtxWrapper(uint8_t *text, uint8_t *needle, int times)
{
    uint32_t textlen = strlen((char *)text);
    uint16_t needlelen = strlen((char *)needle);
 
    uint8_t *ret = NULL;
    int i = 0;
 
    CLOCK_INIT;
    if (times > 1) CLOCK_START;
    for (i = 0; i < times; i++) {
        /* This wrapper is a fake, no context needed! */
        ret = BasicSearchNocase(text, textlen, needle, needlelen);
    }
    if (times > 1) { CLOCK_END; CLOCK_PRINT_SEC; };
    return ret;
}
 
static uint8_t *Bs2bmCtxWrapper(uint8_t *text, uint8_t *needle, int times)
{
    uint32_t textlen = strlen((char *)text);
    uint16_t needlelen = strlen((char *)needle);
 
    uint8_t badchars[ALPHABET_SIZE];
 
    uint8_t *ret = NULL;
    int i = 0;
 
    CLOCK_INIT;
    if (times > 1) CLOCK_START;
    for (i = 0; i < times; i++) {
        /* Stats including context building */
        Bs2BmBadchars(needle, needlelen, badchars);
        ret = Bs2Bm(text, textlen, needle, needlelen, badchars);
    }
    if (times > 1) { CLOCK_END; CLOCK_PRINT_SEC; };
    return ret;
}
 
static uint8_t *Bs2bmNocaseCtxWrapper(uint8_t *text, uint8_t *needle, int times)
{
    uint32_t textlen = strlen((char *)text);
    uint16_t needlelen = strlen((char *)needle);
 
    uint8_t badchars[ALPHABET_SIZE];
 
    uint8_t *ret = NULL;
    int i = 0;
 
    CLOCK_INIT;
    if (times > 1) CLOCK_START;
    for (i = 0; i < times; i++) {
        /* Stats including context building */
        Bs2BmBadchars(needle, needlelen, badchars);
        ret = Bs2BmNocase(text, textlen, needle, needlelen, badchars);
    }
    if (times > 1) { CLOCK_END; CLOCK_PRINT_SEC; };
    return ret;
}
 
static uint8_t *BoyerMooreCtxWrapper(uint8_t *text, uint8_t *needle, int times)
{
    uint32_t textlen = strlen((char *)text);
    uint16_t needlelen = strlen((char *)needle);
 
    BmCtx *bm_ctx = BoyerMooreCtxInit(needle, needlelen);
 
    uint8_t *ret = NULL;
    int i = 0;
 
    CLOCK_INIT;
    if (times > 1) CLOCK_START;
    for (i = 0; i < times; i++) {
        /* Stats including context building */
        ret = BoyerMoore(needle, needlelen, text, textlen, bm_ctx);
    }
    if (times > 1) { CLOCK_END; CLOCK_PRINT_SEC; };
    BoyerMooreCtxDeInit(bm_ctx);
 
    return ret;
}
 
static uint8_t *RawCtxWrapper(uint8_t *text, uint8_t *needle, int times)
{
    uint32_t textlen = strlen((char *)text);
    uint16_t needlelen = strlen((char *)needle);
 
    uint8_t *ret = NULL;
    int i = 0;
 
    CLOCK_INIT;
    if (times > 1) CLOCK_START;
    for (i = 0; i < times; i++) {
        ret = SpmSearch(text, textlen, needle, needlelen);
    }
    if (times > 1) { CLOCK_END; CLOCK_PRINT_SEC; };
    return ret;
}
 
static uint8_t *BoyerMooreNocaseCtxWrapper(uint8_t *text, uint8_t *in_needle, int times)
{
    uint32_t textlen = strlen((char *)text);
    uint16_t needlelen = strlen((char *)in_needle);
 
    /* Make a copy of in_needle to be able to convert it to lowercase. */
    uint8_t *needle = SCMalloc(needlelen);
    if (needle == NULL)
        return NULL;
    memcpy(needle, in_needle, needlelen);
 
    BmCtx *bm_ctx = BoyerMooreNocaseCtxInit(needle, needlelen);
 
    uint8_t *ret = NULL;
    int i = 0;
 
    CLOCK_INIT;
    if (times > 1) CLOCK_START;
    for (i = 0; i < times; i++) {
        ret = BoyerMooreNocase(needle, needlelen, text, textlen, bm_ctx);
    }
    if (times > 1) { CLOCK_END; CLOCK_PRINT_SEC; };
    BoyerMooreCtxDeInit(bm_ctx);
    free(needle);
    return ret;
 
}
#endif
 
/**
 * \test Generic test for BasicSearch matching
 */
static int UtilSpmBasicSearchTest01(void)
{
    uint8_t *needle = (uint8_t *)"oPqRsT";
    uint8_t *text = (uint8_t *)"aBcDeFgHiJkLmNoPqRsTuVwXyZ";
    uint8_t *found = BasicSearchWrapper(text, needle, 1);
    //printf("found: %s\n", found);
    if (found != NULL)
        return 1;
    else
        return 0;
}
 
/**
 * \test Generic test for BasicSearch nocase matching
 */
static int UtilSpmBasicSearchNocaseTest01(void)
{
    uint8_t *needle = (uint8_t *)"OpQrSt";
    uint8_t *text = (uint8_t *)"aBcDeFgHiJkLmNoPqRsTuVwXyZ";
    uint8_t *found = BasicSearchNocaseWrapper(text, needle, 1);
    //printf("found: %s\n", found);
    if (found != NULL)
        return 1;
    else
        return 0;
}
 
/**
 * \test Generic test for Bs2Bm matching
 */
static int UtilSpmBs2bmSearchTest01(void)
{
    uint8_t *needle = (uint8_t *)"oPqRsT";
    uint8_t *text = (uint8_t *)"aBcDeFgHiJkLmNoPqRsTuVwXyZ";
    uint8_t *found = Bs2bmWrapper(text, needle, 1);
    //printf("found: %s\n", found);
    if (found != NULL)
        return 1;
    else
        return 0;
}
 
/**
 * \test Generic test for Bs2Bm no case matching
 */
static int UtilSpmBs2bmSearchNocaseTest01(void)
{
    uint8_t *needle = (uint8_t *)"OpQrSt";
    uint8_t *text = (uint8_t *)"aBcDeFgHiJkLmNoPqRsTuVwXyZ";
    uint8_t *found = Bs2bmNocaseWrapper(text, needle, 1);
    //printf("found: %s\n", found);
    if (found != NULL)
        return 1;
    else
        return 0;
}
 
/**
 * \test Generic test for boyer moore matching
 */
static int UtilSpmBoyerMooreSearchTest01(void)
{
    uint8_t *needle = (uint8_t *)"oPqRsT";
    uint8_t *text = (uint8_t *)"aBcDeFgHiJkLmNoPqRsTuVwXyZ";
    uint8_t *found = BoyerMooreWrapper(text, needle, 1);
    //printf("found: %s\n", found);
    if (found != NULL)
        return 1;
    else
        return 0;
}
 
/**
 * \test Generic test for boyer moore nocase matching
 */
static int UtilSpmBoyerMooreSearchNocaseTest01(void)
{
    uint8_t *needle = (uint8_t *)"OpQrSt";
    uint8_t *text = (uint8_t *)"aBcDeFgHiJkLmNoPqRsTuVwXyZ";
    uint8_t *found = BoyerMooreNocaseWrapper(text, needle, 1);
    //printf("found: %s\n", found);
    if (found != NULL)
        return 1;
    else
        return 0;
}
 
/**
 * \test issue 130 (@redmine) check to ensure that the
 *       problem is not the algorithm implementation
 */
static int UtilSpmBoyerMooreSearchNocaseTestIssue130(void)
{
    uint8_t *needle = (uint8_t *)"WWW-Authenticate: ";
    uint8_t *text = (uint8_t *)"Date: Mon, 23 Feb 2009 13:31:49 GMT"
                "Server: Apache\r\n"
                "Www-authenticate: Basic realm=\"Authentification user password\"\r\n"
                "Vary: accept-language,accept-charset\r\n"
                "Accept-ranges: bytes\r\n"
                "Connection: close\r\n"
                "Content-type: text/html; charset=iso-8859-1\r\n"
                "Content-language: fr\r\n"
                "Expires: Mon, 23 Feb 2009 13:31:49 GMT\r\n\r\n";
    uint8_t *found = BoyerMooreNocaseWrapper(text, needle, 1);
    //printf("found: %s\n", found);
    if (found != NULL)
        return 1;
    else
        return 0;
}
 
/* Generic tests that should not match */
static int UtilSpmBasicSearchTest02(void)
{
    uint8_t *needle = (uint8_t *)"oPQRsT";
    uint8_t *text = (uint8_t *)"aBcDeFgHiJkLmNoPqRsTuVwXyZ";
    uint8_t *found = BasicSearchWrapper(text, needle, 1);
    //printf("found: %s\n", found);
    if (found != NULL)
        return 0;
    else
        return 1;
}
 
static int UtilSpmBasicSearchNocaseTest02(void)
{
    uint8_t *needle = (uint8_t *)"OpZrSt";
    uint8_t *text = (uint8_t *)"aBcDeFgHiJkLmNoPqRsTuVwXyZ";
    uint8_t *found = BasicSearchNocaseWrapper(text, needle, 1);
    //printf("found: %s\n", found);
    if (found != NULL)
        return 0;
    else
        return 1;
}
 
static int UtilSpmBs2bmSearchTest02(void)
{
    uint8_t *needle = (uint8_t *)"oPQRsT";
    uint8_t *text = (uint8_t *)"aBcDeFgHiJkLmNoPqRsTuVwXyZ";
    uint8_t *found = Bs2bmWrapper(text, needle, 1);
    //printf("found: %s\n", found);
    if (found != NULL)
        return 0;
    else
        return 1;
}
 
static int UtilSpmBs2bmSearchNocaseTest02(void)
{
    uint8_t *needle = (uint8_t *)"OpZrSt";
    uint8_t *text = (uint8_t *)"aBcDeFgHiJkLmNoPqRsTuVwXyZ";
    uint8_t *found = Bs2bmNocaseWrapper(text, needle, 1);
    //printf("found: %s\n", found);
    if (found != NULL)
        return 0;
    else
        return 1;
}
 
static int UtilSpmBoyerMooreSearchTest02(void)
{
    uint8_t *needle = (uint8_t *)"oPQRsT";
    uint8_t *text = (uint8_t *)"aBcDeFgHiJkLmNoPqRsTuVwXyZ";
    uint8_t *found = BoyerMooreWrapper(text, needle, 1);
    //printf("found: %s\n", found);
    if (found != NULL)
        return 0;
    else
        return 1;
}
 
static int UtilSpmBoyerMooreSearchNocaseTest02(void)
{
    uint8_t *needle = (uint8_t *)"OpZrSt";
    uint8_t *text = (uint8_t *)"aBcDeFgHiJkLmNoPqRsTuVwXyZ";
    uint8_t *found = BoyerMooreNocaseWrapper(text, needle, 1);
    //printf("found: %s\n", found);
    if (found != NULL)
        return 0;
    else
        return 1;
}
 
/**
 * \test Check that all the algorithms work at any offset and any pattern length
 */
static int UtilSpmSearchOffsetsTest01(void)
{
    const char *text[26][27];
    text[0][0]="azzzzzzzzzzzzzzzzzzzzzzzzzz";
    text[0][1]="zazzzzzzzzzzzzzzzzzzzzzzzzz";
    text[0][2]="zzazzzzzzzzzzzzzzzzzzzzzzzz";
    text[0][3]="zzzazzzzzzzzzzzzzzzzzzzzzzz";
    text[0][4]="zzzzazzzzzzzzzzzzzzzzzzzzzz";
    text[0][5]="zzzzzazzzzzzzzzzzzzzzzzzzzz";
    text[0][6]="zzzzzzazzzzzzzzzzzzzzzzzzzz";
    text[0][7]="zzzzzzzazzzzzzzzzzzzzzzzzzz";
    text[0][8]="zzzzzzzzazzzzzzzzzzzzzzzzzz";
    text[0][9]="zzzzzzzzzazzzzzzzzzzzzzzzzz";
    text[0][10]="zzzzzzzzzzazzzzzzzzzzzzzzzz";
    text[0][11]="zzzzzzzzzzzazzzzzzzzzzzzzzz";
    text[0][12]="zzzzzzzzzzzzazzzzzzzzzzzzzz";
    text[0][13]="zzzzzzzzzzzzzazzzzzzzzzzzzz";
    text[0][14]="zzzzzzzzzzzzzzazzzzzzzzzzzz";
    text[0][15]="zzzzzzzzzzzzzzzazzzzzzzzzzz";
    text[0][16]="zzzzzzzzzzzzzzzzazzzzzzzzzz";
    text[0][17]="zzzzzzzzzzzzzzzzzazzzzzzzzz";
    text[0][18]="zzzzzzzzzzzzzzzzzzazzzzzzzz";
    text[0][19]="zzzzzzzzzzzzzzzzzzzazzzzzzz";
    text[0][20]="zzzzzzzzzzzzzzzzzzzzazzzzzz";
    text[0][21]="zzzzzzzzzzzzzzzzzzzzzazzzzz";
    text[0][22]="zzzzzzzzzzzzzzzzzzzzzzazzzz";
    text[0][23]="zzzzzzzzzzzzzzzzzzzzzzzazzz";
    text[0][24]="zzzzzzzzzzzzzzzzzzzzzzzzazz";
    text[0][25]="zzzzzzzzzzzzzzzzzzzzzzzzzaz";
    text[0][26]="zzzzzzzzzzzzzzzzzzzzzzzzzza";
    text[1][0]="aBzzzzzzzzzzzzzzzzzzzzzzzzz";
    text[1][1]="zaBzzzzzzzzzzzzzzzzzzzzzzzz";
    text[1][2]="zzaBzzzzzzzzzzzzzzzzzzzzzzz";
    text[1][3]="zzzaBzzzzzzzzzzzzzzzzzzzzzz";
    text[1][4]="zzzzaBzzzzzzzzzzzzzzzzzzzzz";
    text[1][5]="zzzzzaBzzzzzzzzzzzzzzzzzzzz";
    text[1][6]="zzzzzzaBzzzzzzzzzzzzzzzzzzz";
    text[1][7]="zzzzzzzaBzzzzzzzzzzzzzzzzzz";
    text[1][8]="zzzzzzzzaBzzzzzzzzzzzzzzzzz";
    text[1][9]="zzzzzzzzzaBzzzzzzzzzzzzzzzz";
    text[1][10]="zzzzzzzzzzaBzzzzzzzzzzzzzzz";
    text[1][11]="zzzzzzzzzzzaBzzzzzzzzzzzzzz";
    text[1][12]="zzzzzzzzzzzzaBzzzzzzzzzzzzz";
    text[1][13]="zzzzzzzzzzzzzaBzzzzzzzzzzzz";
    text[1][14]="zzzzzzzzzzzzzzaBzzzzzzzzzzz";
    text[1][15]="zzzzzzzzzzzzzzzaBzzzzzzzzzz";
    text[1][16]="zzzzzzzzzzzzzzzzaBzzzzzzzzz";
    text[1][17]="zzzzzzzzzzzzzzzzzaBzzzzzzzz";
    text[1][18]="zzzzzzzzzzzzzzzzzzaBzzzzzzz";
    text[1][19]="zzzzzzzzzzzzzzzzzzzaBzzzzzz";
    text[1][20]="zzzzzzzzzzzzzzzzzzzzaBzzzzz";
    text[1][21]="zzzzzzzzzzzzzzzzzzzzzaBzzzz";
    text[1][22]="zzzzzzzzzzzzzzzzzzzzzzaBzzz";
    text[1][23]="zzzzzzzzzzzzzzzzzzzzzzzaBzz";
    text[1][24]="zzzzzzzzzzzzzzzzzzzzzzzzaBz";
    text[1][25]="zzzzzzzzzzzzzzzzzzzzzzzzzaB";
    text[2][0]="aBczzzzzzzzzzzzzzzzzzzzzzzz";
    text[2][1]="zaBczzzzzzzzzzzzzzzzzzzzzzz";
    text[2][2]="zzaBczzzzzzzzzzzzzzzzzzzzzz";
    text[2][3]="zzzaBczzzzzzzzzzzzzzzzzzzzz";
    text[2][4]="zzzzaBczzzzzzzzzzzzzzzzzzzz";
    text[2][5]="zzzzzaBczzzzzzzzzzzzzzzzzzz";
    text[2][6]="zzzzzzaBczzzzzzzzzzzzzzzzzz";
    text[2][7]="zzzzzzzaBczzzzzzzzzzzzzzzzz";
    text[2][8]="zzzzzzzzaBczzzzzzzzzzzzzzzz";
    text[2][9]="zzzzzzzzzaBczzzzzzzzzzzzzzz";
    text[2][10]="zzzzzzzzzzaBczzzzzzzzzzzzzz";
    text[2][11]="zzzzzzzzzzzaBczzzzzzzzzzzzz";
    text[2][12]="zzzzzzzzzzzzaBczzzzzzzzzzzz";
    text[2][13]="zzzzzzzzzzzzzaBczzzzzzzzzzz";
    text[2][14]="zzzzzzzzzzzzzzaBczzzzzzzzzz";
    text[2][15]="zzzzzzzzzzzzzzzaBczzzzzzzzz";
    text[2][16]="zzzzzzzzzzzzzzzzaBczzzzzzzz";
    text[2][17]="zzzzzzzzzzzzzzzzzaBczzzzzzz";
    text[2][18]="zzzzzzzzzzzzzzzzzzaBczzzzzz";
    text[2][19]="zzzzzzzzzzzzzzzzzzzaBczzzzz";
    text[2][20]="zzzzzzzzzzzzzzzzzzzzaBczzzz";
    text[2][21]="zzzzzzzzzzzzzzzzzzzzzaBczzz";
    text[2][22]="zzzzzzzzzzzzzzzzzzzzzzaBczz";
    text[2][23]="zzzzzzzzzzzzzzzzzzzzzzzaBcz";
    text[2][24]="zzzzzzzzzzzzzzzzzzzzzzzzaBc";
    text[3][0]="aBcDzzzzzzzzzzzzzzzzzzzzzzz";
    text[3][1]="zaBcDzzzzzzzzzzzzzzzzzzzzzz";
    text[3][2]="zzaBcDzzzzzzzzzzzzzzzzzzzzz";
    text[3][3]="zzzaBcDzzzzzzzzzzzzzzzzzzzz";
    text[3][4]="zzzzaBcDzzzzzzzzzzzzzzzzzzz";
    text[3][5]="zzzzzaBcDzzzzzzzzzzzzzzzzzz";
    text[3][6]="zzzzzzaBcDzzzzzzzzzzzzzzzzz";
    text[3][7]="zzzzzzzaBcDzzzzzzzzzzzzzzzz";
    text[3][8]="zzzzzzzzaBcDzzzzzzzzzzzzzzz";
    text[3][9]="zzzzzzzzzaBcDzzzzzzzzzzzzzz";
    text[3][10]="zzzzzzzzzzaBcDzzzzzzzzzzzzz";
    text[3][11]="zzzzzzzzzzzaBcDzzzzzzzzzzzz";
    text[3][12]="zzzzzzzzzzzzaBcDzzzzzzzzzzz";
    text[3][13]="zzzzzzzzzzzzzaBcDzzzzzzzzzz";
    text[3][14]="zzzzzzzzzzzzzzaBcDzzzzzzzzz";
    text[3][15]="zzzzzzzzzzzzzzzaBcDzzzzzzzz";
    text[3][16]="zzzzzzzzzzzzzzzzaBcDzzzzzzz";
    text[3][17]="zzzzzzzzzzzzzzzzzaBcDzzzzzz";
    text[3][18]="zzzzzzzzzzzzzzzzzzaBcDzzzzz";
    text[3][19]="zzzzzzzzzzzzzzzzzzzaBcDzzzz";
    text[3][20]="zzzzzzzzzzzzzzzzzzzzaBcDzzz";
    text[3][21]="zzzzzzzzzzzzzzzzzzzzzaBcDzz";
    text[3][22]="zzzzzzzzzzzzzzzzzzzzzzaBcDz";
    text[3][23]="zzzzzzzzzzzzzzzzzzzzzzzaBcD";
    text[4][0]="aBcDezzzzzzzzzzzzzzzzzzzzzz";
    text[4][1]="zaBcDezzzzzzzzzzzzzzzzzzzzz";
    text[4][2]="zzaBcDezzzzzzzzzzzzzzzzzzzz";
    text[4][3]="zzzaBcDezzzzzzzzzzzzzzzzzzz";
    text[4][4]="zzzzaBcDezzzzzzzzzzzzzzzzzz";
    text[4][5]="zzzzzaBcDezzzzzzzzzzzzzzzzz";
    text[4][6]="zzzzzzaBcDezzzzzzzzzzzzzzzz";
    text[4][7]="zzzzzzzaBcDezzzzzzzzzzzzzzz";
    text[4][8]="zzzzzzzzaBcDezzzzzzzzzzzzzz";
    text[4][9]="zzzzzzzzzaBcDezzzzzzzzzzzzz";
    text[4][10]="zzzzzzzzzzaBcDezzzzzzzzzzzz";
    text[4][11]="zzzzzzzzzzzaBcDezzzzzzzzzzz";
    text[4][12]="zzzzzzzzzzzzaBcDezzzzzzzzzz";
    text[4][13]="zzzzzzzzzzzzzaBcDezzzzzzzzz";
    text[4][14]="zzzzzzzzzzzzzzaBcDezzzzzzzz";
    text[4][15]="zzzzzzzzzzzzzzzaBcDezzzzzzz";
    text[4][16]="zzzzzzzzzzzzzzzzaBcDezzzzzz";
    text[4][17]="zzzzzzzzzzzzzzzzzaBcDezzzzz";
    text[4][18]="zzzzzzzzzzzzzzzzzzaBcDezzzz";
    text[4][19]="zzzzzzzzzzzzzzzzzzzaBcDezzz";
    text[4][20]="zzzzzzzzzzzzzzzzzzzzaBcDezz";
    text[4][21]="zzzzzzzzzzzzzzzzzzzzzaBcDez";
    text[4][22]="zzzzzzzzzzzzzzzzzzzzzzaBcDe";
    text[5][0]="aBcDeFzzzzzzzzzzzzzzzzzzzzz";
    text[5][1]="zaBcDeFzzzzzzzzzzzzzzzzzzzz";
    text[5][2]="zzaBcDeFzzzzzzzzzzzzzzzzzzz";
    text[5][3]="zzzaBcDeFzzzzzzzzzzzzzzzzzz";
    text[5][4]="zzzzaBcDeFzzzzzzzzzzzzzzzzz";
    text[5][5]="zzzzzaBcDeFzzzzzzzzzzzzzzzz";
    text[5][6]="zzzzzzaBcDeFzzzzzzzzzzzzzzz";
    text[5][7]="zzzzzzzaBcDeFzzzzzzzzzzzzzz";
    text[5][8]="zzzzzzzzaBcDeFzzzzzzzzzzzzz";
    text[5][9]="zzzzzzzzzaBcDeFzzzzzzzzzzzz";
    text[5][10]="zzzzzzzzzzaBcDeFzzzzzzzzzzz";
    text[5][11]="zzzzzzzzzzzaBcDeFzzzzzzzzzz";
    text[5][12]="zzzzzzzzzzzzaBcDeFzzzzzzzzz";
    text[5][13]="zzzzzzzzzzzzzaBcDeFzzzzzzzz";
    text[5][14]="zzzzzzzzzzzzzzaBcDeFzzzzzzz";
    text[5][15]="zzzzzzzzzzzzzzzaBcDeFzzzzzz";
    text[5][16]="zzzzzzzzzzzzzzzzaBcDeFzzzzz";
    text[5][17]="zzzzzzzzzzzzzzzzzaBcDeFzzzz";
    text[5][18]="zzzzzzzzzzzzzzzzzzaBcDeFzzz";
    text[5][19]="zzzzzzzzzzzzzzzzzzzaBcDeFzz";
    text[5][20]="zzzzzzzzzzzzzzzzzzzzaBcDeFz";
    text[5][21]="zzzzzzzzzzzzzzzzzzzzzaBcDeF";
    text[6][0]="aBcDeFgzzzzzzzzzzzzzzzzzzzz";
    text[6][1]="zaBcDeFgzzzzzzzzzzzzzzzzzzz";
    text[6][2]="zzaBcDeFgzzzzzzzzzzzzzzzzzz";
    text[6][3]="zzzaBcDeFgzzzzzzzzzzzzzzzzz";
    text[6][4]="zzzzaBcDeFgzzzzzzzzzzzzzzzz";
    text[6][5]="zzzzzaBcDeFgzzzzzzzzzzzzzzz";
    text[6][6]="zzzzzzaBcDeFgzzzzzzzzzzzzzz";
    text[6][7]="zzzzzzzaBcDeFgzzzzzzzzzzzzz";
    text[6][8]="zzzzzzzzaBcDeFgzzzzzzzzzzzz";
    text[6][9]="zzzzzzzzzaBcDeFgzzzzzzzzzzz";
    text[6][10]="zzzzzzzzzzaBcDeFgzzzzzzzzzz";
    text[6][11]="zzzzzzzzzzzaBcDeFgzzzzzzzzz";
    text[6][12]="zzzzzzzzzzzzaBcDeFgzzzzzzzz";
    text[6][13]="zzzzzzzzzzzzzaBcDeFgzzzzzzz";
    text[6][14]="zzzzzzzzzzzzzzaBcDeFgzzzzzz";
    text[6][15]="zzzzzzzzzzzzzzzaBcDeFgzzzzz";
    text[6][16]="zzzzzzzzzzzzzzzzaBcDeFgzzzz";
    text[6][17]="zzzzzzzzzzzzzzzzzaBcDeFgzzz";
    text[6][18]="zzzzzzzzzzzzzzzzzzaBcDeFgzz";
    text[6][19]="zzzzzzzzzzzzzzzzzzzaBcDeFgz";
    text[6][20]="zzzzzzzzzzzzzzzzzzzzaBcDeFg";
    text[7][0]="aBcDeFgHzzzzzzzzzzzzzzzzzzz";
    text[7][1]="zaBcDeFgHzzzzzzzzzzzzzzzzzz";
    text[7][2]="zzaBcDeFgHzzzzzzzzzzzzzzzzz";
    text[7][3]="zzzaBcDeFgHzzzzzzzzzzzzzzzz";
    text[7][4]="zzzzaBcDeFgHzzzzzzzzzzzzzzz";
    text[7][5]="zzzzzaBcDeFgHzzzzzzzzzzzzzz";
    text[7][6]="zzzzzzaBcDeFgHzzzzzzzzzzzzz";
    text[7][7]="zzzzzzzaBcDeFgHzzzzzzzzzzzz";
    text[7][8]="zzzzzzzzaBcDeFgHzzzzzzzzzzz";
    text[7][9]="zzzzzzzzzaBcDeFgHzzzzzzzzzz";
    text[7][10]="zzzzzzzzzzaBcDeFgHzzzzzzzzz";
    text[7][11]="zzzzzzzzzzzaBcDeFgHzzzzzzzz";
    text[7][12]="zzzzzzzzzzzzaBcDeFgHzzzzzzz";
    text[7][13]="zzzzzzzzzzzzzaBcDeFgHzzzzzz";
    text[7][14]="zzzzzzzzzzzzzzaBcDeFgHzzzzz";
    text[7][15]="zzzzzzzzzzzzzzzaBcDeFgHzzzz";
    text[7][16]="zzzzzzzzzzzzzzzzaBcDeFgHzzz";
    text[7][17]="zzzzzzzzzzzzzzzzzaBcDeFgHzz";
    text[7][18]="zzzzzzzzzzzzzzzzzzaBcDeFgHz";
    text[7][19]="zzzzzzzzzzzzzzzzzzzaBcDeFgH";
    text[8][0]="aBcDeFgHizzzzzzzzzzzzzzzzzz";
    text[8][1]="zaBcDeFgHizzzzzzzzzzzzzzzzz";
    text[8][2]="zzaBcDeFgHizzzzzzzzzzzzzzzz";
    text[8][3]="zzzaBcDeFgHizzzzzzzzzzzzzzz";
    text[8][4]="zzzzaBcDeFgHizzzzzzzzzzzzzz";
    text[8][5]="zzzzzaBcDeFgHizzzzzzzzzzzzz";
    text[8][6]="zzzzzzaBcDeFgHizzzzzzzzzzzz";
    text[8][7]="zzzzzzzaBcDeFgHizzzzzzzzzzz";
    text[8][8]="zzzzzzzzaBcDeFgHizzzzzzzzzz";
    text[8][9]="zzzzzzzzzaBcDeFgHizzzzzzzzz";
    text[8][10]="zzzzzzzzzzaBcDeFgHizzzzzzzz";
    text[8][11]="zzzzzzzzzzzaBcDeFgHizzzzzzz";
    text[8][12]="zzzzzzzzzzzzaBcDeFgHizzzzzz";
    text[8][13]="zzzzzzzzzzzzzaBcDeFgHizzzzz";
    text[8][14]="zzzzzzzzzzzzzzaBcDeFgHizzzz";
    text[8][15]="zzzzzzzzzzzzzzzaBcDeFgHizzz";
    text[8][16]="zzzzzzzzzzzzzzzzaBcDeFgHizz";
    text[8][17]="zzzzzzzzzzzzzzzzzaBcDeFgHiz";
    text[8][18]="zzzzzzzzzzzzzzzzzzaBcDeFgHi";
    text[9][0]="aBcDeFgHiJzzzzzzzzzzzzzzzzz";
    text[9][1]="zaBcDeFgHiJzzzzzzzzzzzzzzzz";
    text[9][2]="zzaBcDeFgHiJzzzzzzzzzzzzzzz";
    text[9][3]="zzzaBcDeFgHiJzzzzzzzzzzzzzz";
    text[9][4]="zzzzaBcDeFgHiJzzzzzzzzzzzzz";
    text[9][5]="zzzzzaBcDeFgHiJzzzzzzzzzzzz";
    text[9][6]="zzzzzzaBcDeFgHiJzzzzzzzzzzz";
    text[9][7]="zzzzzzzaBcDeFgHiJzzzzzzzzzz";
    text[9][8]="zzzzzzzzaBcDeFgHiJzzzzzzzzz";
    text[9][9]="zzzzzzzzzaBcDeFgHiJzzzzzzzz";
    text[9][10]="zzzzzzzzzzaBcDeFgHiJzzzzzzz";
    text[9][11]="zzzzzzzzzzzaBcDeFgHiJzzzzzz";
    text[9][12]="zzzzzzzzzzzzaBcDeFgHiJzzzzz";
    text[9][13]="zzzzzzzzzzzzzaBcDeFgHiJzzzz";
    text[9][14]="zzzzzzzzzzzzzzaBcDeFgHiJzzz";
    text[9][15]="zzzzzzzzzzzzzzzaBcDeFgHiJzz";
    text[9][16]="zzzzzzzzzzzzzzzzaBcDeFgHiJz";
    text[9][17]="zzzzzzzzzzzzzzzzzaBcDeFgHiJ";
    text[10][0]="aBcDeFgHiJkzzzzzzzzzzzzzzzz";
    text[10][1]="zaBcDeFgHiJkzzzzzzzzzzzzzzz";
    text[10][2]="zzaBcDeFgHiJkzzzzzzzzzzzzzz";
    text[10][3]="zzzaBcDeFgHiJkzzzzzzzzzzzzz";
    text[10][4]="zzzzaBcDeFgHiJkzzzzzzzzzzzz";
    text[10][5]="zzzzzaBcDeFgHiJkzzzzzzzzzzz";
    text[10][6]="zzzzzzaBcDeFgHiJkzzzzzzzzzz";
    text[10][7]="zzzzzzzaBcDeFgHiJkzzzzzzzzz";
    text[10][8]="zzzzzzzzaBcDeFgHiJkzzzzzzzz";
    text[10][9]="zzzzzzzzzaBcDeFgHiJkzzzzzzz";
    text[10][10]="zzzzzzzzzzaBcDeFgHiJkzzzzzz";
    text[10][11]="zzzzzzzzzzzaBcDeFgHiJkzzzzz";
    text[10][12]="zzzzzzzzzzzzaBcDeFgHiJkzzzz";
    text[10][13]="zzzzzzzzzzzzzaBcDeFgHiJkzzz";
    text[10][14]="zzzzzzzzzzzzzzaBcDeFgHiJkzz";
    text[10][15]="zzzzzzzzzzzzzzzaBcDeFgHiJkz";
    text[10][16]="zzzzzzzzzzzzzzzzaBcDeFgHiJk";
    text[11][0]="aBcDeFgHiJkLzzzzzzzzzzzzzzz";
    text[11][1]="zaBcDeFgHiJkLzzzzzzzzzzzzzz";
    text[11][2]="zzaBcDeFgHiJkLzzzzzzzzzzzzz";
    text[11][3]="zzzaBcDeFgHiJkLzzzzzzzzzzzz";
    text[11][4]="zzzzaBcDeFgHiJkLzzzzzzzzzzz";
    text[11][5]="zzzzzaBcDeFgHiJkLzzzzzzzzzz";
    text[11][6]="zzzzzzaBcDeFgHiJkLzzzzzzzzz";
    text[11][7]="zzzzzzzaBcDeFgHiJkLzzzzzzzz";
    text[11][8]="zzzzzzzzaBcDeFgHiJkLzzzzzzz";
    text[11][9]="zzzzzzzzzaBcDeFgHiJkLzzzzzz";
    text[11][10]="zzzzzzzzzzaBcDeFgHiJkLzzzzz";
    text[11][11]="zzzzzzzzzzzaBcDeFgHiJkLzzzz";
    text[11][12]="zzzzzzzzzzzzaBcDeFgHiJkLzzz";
    text[11][13]="zzzzzzzzzzzzzaBcDeFgHiJkLzz";
    text[11][14]="zzzzzzzzzzzzzzaBcDeFgHiJkLz";
    text[11][15]="zzzzzzzzzzzzzzzaBcDeFgHiJkL";
    text[12][0]="aBcDeFgHiJkLmzzzzzzzzzzzzzz";
    text[12][1]="zaBcDeFgHiJkLmzzzzzzzzzzzzz";
    text[12][2]="zzaBcDeFgHiJkLmzzzzzzzzzzzz";
    text[12][3]="zzzaBcDeFgHiJkLmzzzzzzzzzzz";
    text[12][4]="zzzzaBcDeFgHiJkLmzzzzzzzzzz";
    text[12][5]="zzzzzaBcDeFgHiJkLmzzzzzzzzz";
    text[12][6]="zzzzzzaBcDeFgHiJkLmzzzzzzzz";
    text[12][7]="zzzzzzzaBcDeFgHiJkLmzzzzzzz";
    text[12][8]="zzzzzzzzaBcDeFgHiJkLmzzzzzz";
    text[12][9]="zzzzzzzzzaBcDeFgHiJkLmzzzzz";
    text[12][10]="zzzzzzzzzzaBcDeFgHiJkLmzzzz";
    text[12][11]="zzzzzzzzzzzaBcDeFgHiJkLmzzz";
    text[12][12]="zzzzzzzzzzzzaBcDeFgHiJkLmzz";
    text[12][13]="zzzzzzzzzzzzzaBcDeFgHiJkLmz";
    text[12][14]="zzzzzzzzzzzzzzaBcDeFgHiJkLm";
    text[13][0]="aBcDeFgHiJkLmNzzzzzzzzzzzzz";
    text[13][1]="zaBcDeFgHiJkLmNzzzzzzzzzzzz";
    text[13][2]="zzaBcDeFgHiJkLmNzzzzzzzzzzz";
    text[13][3]="zzzaBcDeFgHiJkLmNzzzzzzzzzz";
    text[13][4]="zzzzaBcDeFgHiJkLmNzzzzzzzzz";
    text[13][5]="zzzzzaBcDeFgHiJkLmNzzzzzzzz";
    text[13][6]="zzzzzzaBcDeFgHiJkLmNzzzzzzz";
    text[13][7]="zzzzzzzaBcDeFgHiJkLmNzzzzzz";
    text[13][8]="zzzzzzzzaBcDeFgHiJkLmNzzzzz";
    text[13][9]="zzzzzzzzzaBcDeFgHiJkLmNzzzz";
    text[13][10]="zzzzzzzzzzaBcDeFgHiJkLmNzzz";
    text[13][11]="zzzzzzzzzzzaBcDeFgHiJkLmNzz";
    text[13][12]="zzzzzzzzzzzzaBcDeFgHiJkLmNz";
    text[13][13]="zzzzzzzzzzzzzaBcDeFgHiJkLmN";
    text[14][0]="aBcDeFgHiJkLmNozzzzzzzzzzzz";
    text[14][1]="zaBcDeFgHiJkLmNozzzzzzzzzzz";
    text[14][2]="zzaBcDeFgHiJkLmNozzzzzzzzzz";
    text[14][3]="zzzaBcDeFgHiJkLmNozzzzzzzzz";
    text[14][4]="zzzzaBcDeFgHiJkLmNozzzzzzzz";
    text[14][5]="zzzzzaBcDeFgHiJkLmNozzzzzzz";
    text[14][6]="zzzzzzaBcDeFgHiJkLmNozzzzzz";
    text[14][7]="zzzzzzzaBcDeFgHiJkLmNozzzzz";
    text[14][8]="zzzzzzzzaBcDeFgHiJkLmNozzzz";
    text[14][9]="zzzzzzzzzaBcDeFgHiJkLmNozzz";
    text[14][10]="zzzzzzzzzzaBcDeFgHiJkLmNozz";
    text[14][11]="zzzzzzzzzzzaBcDeFgHiJkLmNoz";
    text[14][12]="zzzzzzzzzzzzaBcDeFgHiJkLmNo";
    text[15][0]="aBcDeFgHiJkLmNoPzzzzzzzzzzz";
    text[15][1]="zaBcDeFgHiJkLmNoPzzzzzzzzzz";
    text[15][2]="zzaBcDeFgHiJkLmNoPzzzzzzzzz";
    text[15][3]="zzzaBcDeFgHiJkLmNoPzzzzzzzz";
    text[15][4]="zzzzaBcDeFgHiJkLmNoPzzzzzzz";
    text[15][5]="zzzzzaBcDeFgHiJkLmNoPzzzzzz";
    text[15][6]="zzzzzzaBcDeFgHiJkLmNoPzzzzz";
    text[15][7]="zzzzzzzaBcDeFgHiJkLmNoPzzzz";
    text[15][8]="zzzzzzzzaBcDeFgHiJkLmNoPzzz";
    text[15][9]="zzzzzzzzzaBcDeFgHiJkLmNoPzz";
    text[15][10]="zzzzzzzzzzaBcDeFgHiJkLmNoPz";
    text[15][11]="zzzzzzzzzzzaBcDeFgHiJkLmNoP";
    text[16][0]="aBcDeFgHiJkLmNoPqzzzzzzzzzz";
    text[16][1]="zaBcDeFgHiJkLmNoPqzzzzzzzzz";
    text[16][2]="zzaBcDeFgHiJkLmNoPqzzzzzzzz";
    text[16][3]="zzzaBcDeFgHiJkLmNoPqzzzzzzz";
    text[16][4]="zzzzaBcDeFgHiJkLmNoPqzzzzzz";
    text[16][5]="zzzzzaBcDeFgHiJkLmNoPqzzzzz";
    text[16][6]="zzzzzzaBcDeFgHiJkLmNoPqzzzz";
    text[16][7]="zzzzzzzaBcDeFgHiJkLmNoPqzzz";
    text[16][8]="zzzzzzzzaBcDeFgHiJkLmNoPqzz";
    text[16][9]="zzzzzzzzzaBcDeFgHiJkLmNoPqz";
    text[16][10]="zzzzzzzzzzaBcDeFgHiJkLmNoPq";
    text[17][0]="aBcDeFgHiJkLmNoPqRzzzzzzzzz";
    text[17][1]="zaBcDeFgHiJkLmNoPqRzzzzzzzz";
    text[17][2]="zzaBcDeFgHiJkLmNoPqRzzzzzzz";
    text[17][3]="zzzaBcDeFgHiJkLmNoPqRzzzzzz";
    text[17][4]="zzzzaBcDeFgHiJkLmNoPqRzzzzz";
    text[17][5]="zzzzzaBcDeFgHiJkLmNoPqRzzzz";
    text[17][6]="zzzzzzaBcDeFgHiJkLmNoPqRzzz";
    text[17][7]="zzzzzzzaBcDeFgHiJkLmNoPqRzz";
    text[17][8]="zzzzzzzzaBcDeFgHiJkLmNoPqRz";
    text[17][9]="zzzzzzzzzaBcDeFgHiJkLmNoPqR";
    text[18][0]="aBcDeFgHiJkLmNoPqRszzzzzzzz";
    text[18][1]="zaBcDeFgHiJkLmNoPqRszzzzzzz";
    text[18][2]="zzaBcDeFgHiJkLmNoPqRszzzzzz";
    text[18][3]="zzzaBcDeFgHiJkLmNoPqRszzzzz";
    text[18][4]="zzzzaBcDeFgHiJkLmNoPqRszzzz";
    text[18][5]="zzzzzaBcDeFgHiJkLmNoPqRszzz";
    text[18][6]="zzzzzzaBcDeFgHiJkLmNoPqRszz";
    text[18][7]="zzzzzzzaBcDeFgHiJkLmNoPqRsz";
    text[18][8]="zzzzzzzzaBcDeFgHiJkLmNoPqRs";
    text[19][0]="aBcDeFgHiJkLmNoPqRsTzzzzzzz";
    text[19][1]="zaBcDeFgHiJkLmNoPqRsTzzzzzz";
    text[19][2]="zzaBcDeFgHiJkLmNoPqRsTzzzzz";
    text[19][3]="zzzaBcDeFgHiJkLmNoPqRsTzzzz";
    text[19][4]="zzzzaBcDeFgHiJkLmNoPqRsTzzz";
    text[19][5]="zzzzzaBcDeFgHiJkLmNoPqRsTzz";
    text[19][6]="zzzzzzaBcDeFgHiJkLmNoPqRsTz";
    text[19][7]="zzzzzzzaBcDeFgHiJkLmNoPqRsT";
    text[20][0]="aBcDeFgHiJkLmNoPqRsTuzzzzzz";
    text[20][1]="zaBcDeFgHiJkLmNoPqRsTuzzzzz";
    text[20][2]="zzaBcDeFgHiJkLmNoPqRsTuzzzz";
    text[20][3]="zzzaBcDeFgHiJkLmNoPqRsTuzzz";
    text[20][4]="zzzzaBcDeFgHiJkLmNoPqRsTuzz";
    text[20][5]="zzzzzaBcDeFgHiJkLmNoPqRsTuz";
    text[20][6]="zzzzzzaBcDeFgHiJkLmNoPqRsTu";
    text[21][0]="aBcDeFgHiJkLmNoPqRsTuVzzzzz";
    text[21][1]="zaBcDeFgHiJkLmNoPqRsTuVzzzz";
    text[21][2]="zzaBcDeFgHiJkLmNoPqRsTuVzzz";
    text[21][3]="zzzaBcDeFgHiJkLmNoPqRsTuVzz";
    text[21][4]="zzzzaBcDeFgHiJkLmNoPqRsTuVz";
    text[21][5]="zzzzzaBcDeFgHiJkLmNoPqRsTuV";
    text[22][0]="aBcDeFgHiJkLmNoPqRsTuVwzzzz";
    text[22][1]="zaBcDeFgHiJkLmNoPqRsTuVwzzz";
    text[22][2]="zzaBcDeFgHiJkLmNoPqRsTuVwzz";
    text[22][3]="zzzaBcDeFgHiJkLmNoPqRsTuVwz";
    text[22][4]="zzzzaBcDeFgHiJkLmNoPqRsTuVw";
    text[23][0]="aBcDeFgHiJkLmNoPqRsTuVwXzzz";
    text[23][1]="zaBcDeFgHiJkLmNoPqRsTuVwXzz";
    text[23][2]="zzaBcDeFgHiJkLmNoPqRsTuVwXz";
    text[23][3]="zzzaBcDeFgHiJkLmNoPqRsTuVwX";
    text[24][0]="aBcDeFgHiJkLmNoPqRsTuVwXyzz";
    text[24][1]="zaBcDeFgHiJkLmNoPqRsTuVwXyz";
    text[24][2]="zzaBcDeFgHiJkLmNoPqRsTuVwXy";
    text[25][0]="aBcDeFgHiJkLmNoPqRsTuVwXyZz";
    text[25][1]="zaBcDeFgHiJkLmNoPqRsTuVwXyZ";
 
    const char *needle[26];
    needle[0]="a";
    needle[1]="aB";
    needle[2]="aBc";
    needle[3]="aBcD";
    needle[4]="aBcDe";
    needle[5]="aBcDeF";
    needle[6]="aBcDeFg";
    needle[7]="aBcDeFgH";
    needle[8]="aBcDeFgHi";
    needle[9]="aBcDeFgHiJ";
    needle[10]="aBcDeFgHiJk";
    needle[11]="aBcDeFgHiJkL";
    needle[12]="aBcDeFgHiJkLm";
    needle[13]="aBcDeFgHiJkLmN";
    needle[14]="aBcDeFgHiJkLmNo";
    needle[15]="aBcDeFgHiJkLmNoP";
    needle[16]="aBcDeFgHiJkLmNoPq";
    needle[17]="aBcDeFgHiJkLmNoPqR";
    needle[18]="aBcDeFgHiJkLmNoPqRs";
    needle[19]="aBcDeFgHiJkLmNoPqRsT";
    needle[20]="aBcDeFgHiJkLmNoPqRsTu";
    needle[21]="aBcDeFgHiJkLmNoPqRsTuV";
    needle[22]="aBcDeFgHiJkLmNoPqRsTuVw";
    needle[23]="aBcDeFgHiJkLmNoPqRsTuVwX";
    needle[24]="aBcDeFgHiJkLmNoPqRsTuVwXy";
    needle[25]="aBcDeFgHiJkLmNoPqRsTuVwXyZ";
 
    int i, j;
    uint8_t *found = NULL;
    for (i = 0; i < 26; i++) {
        for (j = 0; j <= (26 - i); j++) {
            found = BasicSearchWrapper((uint8_t *)text[i][j], (uint8_t *)needle[i], 1);
            if (found == 0) {
                printf("Error1 searching for %s in text %s\n", needle[i], text[i][j]);
                return 0;
            }
            found = Bs2bmWrapper((uint8_t *)text[i][j], (uint8_t *)needle[i], 1);
            if (found == 0) {
                printf("Error2 searching for %s in text %s\n", needle[i], text[i][j]);
                return 0;
            }
            found = BoyerMooreWrapper((uint8_t *)text[i][j], (uint8_t *)needle[i], 1);
            if (found == 0) {
                printf("Error3 searching for %s in text %s\n", needle[i], text[i][j]);
                return 0;
            }
        }
    }
    return 1;
}
 
/**
 * \test Check that all the algorithms (no case) work at any offset and any pattern length
 */
static int UtilSpmSearchOffsetsNocaseTest01(void)
{
    const char *text[26][27];
    text[0][0]="azzzzzzzzzzzzzzzzzzzzzzzzzz";
    text[0][1]="zazzzzzzzzzzzzzzzzzzzzzzzzz";
    text[0][2]="zzazzzzzzzzzzzzzzzzzzzzzzzz";
    text[0][3]="zzzazzzzzzzzzzzzzzzzzzzzzzz";
    text[0][4]="zzzzazzzzzzzzzzzzzzzzzzzzzz";
    text[0][5]="zzzzzazzzzzzzzzzzzzzzzzzzzz";
    text[0][6]="zzzzzzazzzzzzzzzzzzzzzzzzzz";
    text[0][7]="zzzzzzzazzzzzzzzzzzzzzzzzzz";
    text[0][8]="zzzzzzzzazzzzzzzzzzzzzzzzzz";
    text[0][9]="zzzzzzzzzazzzzzzzzzzzzzzzzz";
    text[0][10]="zzzzzzzzzzazzzzzzzzzzzzzzzz";
    text[0][11]="zzzzzzzzzzzazzzzzzzzzzzzzzz";
    text[0][12]="zzzzzzzzzzzzazzzzzzzzzzzzzz";
    text[0][13]="zzzzzzzzzzzzzazzzzzzzzzzzzz";
    text[0][14]="zzzzzzzzzzzzzzazzzzzzzzzzzz";
    text[0][15]="zzzzzzzzzzzzzzzazzzzzzzzzzz";
    text[0][16]="zzzzzzzzzzzzzzzzazzzzzzzzzz";
    text[0][17]="zzzzzzzzzzzzzzzzzazzzzzzzzz";
    text[0][18]="zzzzzzzzzzzzzzzzzzazzzzzzzz";
    text[0][19]="zzzzzzzzzzzzzzzzzzzazzzzzzz";
    text[0][20]="zzzzzzzzzzzzzzzzzzzzazzzzzz";
    text[0][21]="zzzzzzzzzzzzzzzzzzzzzazzzzz";
    text[0][22]="zzzzzzzzzzzzzzzzzzzzzzazzzz";
    text[0][23]="zzzzzzzzzzzzzzzzzzzzzzzazzz";
    text[0][24]="zzzzzzzzzzzzzzzzzzzzzzzzazz";
    text[0][25]="zzzzzzzzzzzzzzzzzzzzzzzzzaz";
    text[0][26]="zzzzzzzzzzzzzzzzzzzzzzzzzza";
    text[1][0]="aBzzzzzzzzzzzzzzzzzzzzzzzzz";
    text[1][1]="zaBzzzzzzzzzzzzzzzzzzzzzzzz";
    text[1][2]="zzaBzzzzzzzzzzzzzzzzzzzzzzz";
    text[1][3]="zzzaBzzzzzzzzzzzzzzzzzzzzzz";
    text[1][4]="zzzzaBzzzzzzzzzzzzzzzzzzzzz";
    text[1][5]="zzzzzaBzzzzzzzzzzzzzzzzzzzz";
    text[1][6]="zzzzzzaBzzzzzzzzzzzzzzzzzzz";
    text[1][7]="zzzzzzzaBzzzzzzzzzzzzzzzzzz";
    text[1][8]="zzzzzzzzaBzzzzzzzzzzzzzzzzz";
    text[1][9]="zzzzzzzzzaBzzzzzzzzzzzzzzzz";
    text[1][10]="zzzzzzzzzzaBzzzzzzzzzzzzzzz";
    text[1][11]="zzzzzzzzzzzaBzzzzzzzzzzzzzz";
    text[1][12]="zzzzzzzzzzzzaBzzzzzzzzzzzzz";
    text[1][13]="zzzzzzzzzzzzzaBzzzzzzzzzzzz";
    text[1][14]="zzzzzzzzzzzzzzaBzzzzzzzzzzz";
    text[1][15]="zzzzzzzzzzzzzzzaBzzzzzzzzzz";
    text[1][16]="zzzzzzzzzzzzzzzzaBzzzzzzzzz";
    text[1][17]="zzzzzzzzzzzzzzzzzaBzzzzzzzz";
    text[1][18]="zzzzzzzzzzzzzzzzzzaBzzzzzzz";
    text[1][19]="zzzzzzzzzzzzzzzzzzzaBzzzzzz";
    text[1][20]="zzzzzzzzzzzzzzzzzzzzaBzzzzz";
    text[1][21]="zzzzzzzzzzzzzzzzzzzzzaBzzzz";
    text[1][22]="zzzzzzzzzzzzzzzzzzzzzzaBzzz";
    text[1][23]="zzzzzzzzzzzzzzzzzzzzzzzaBzz";
    text[1][24]="zzzzzzzzzzzzzzzzzzzzzzzzaBz";
    text[1][25]="zzzzzzzzzzzzzzzzzzzzzzzzzaB";
    text[2][0]="aBczzzzzzzzzzzzzzzzzzzzzzzz";
    text[2][1]="zaBczzzzzzzzzzzzzzzzzzzzzzz";
    text[2][2]="zzaBczzzzzzzzzzzzzzzzzzzzzz";
    text[2][3]="zzzaBczzzzzzzzzzzzzzzzzzzzz";
    text[2][4]="zzzzaBczzzzzzzzzzzzzzzzzzzz";
    text[2][5]="zzzzzaBczzzzzzzzzzzzzzzzzzz";
    text[2][6]="zzzzzzaBczzzzzzzzzzzzzzzzzz";
    text[2][7]="zzzzzzzaBczzzzzzzzzzzzzzzzz";
    text[2][8]="zzzzzzzzaBczzzzzzzzzzzzzzzz";
    text[2][9]="zzzzzzzzzaBczzzzzzzzzzzzzzz";
    text[2][10]="zzzzzzzzzzaBczzzzzzzzzzzzzz";
    text[2][11]="zzzzzzzzzzzaBczzzzzzzzzzzzz";
    text[2][12]="zzzzzzzzzzzzaBczzzzzzzzzzzz";
    text[2][13]="zzzzzzzzzzzzzaBczzzzzzzzzzz";
    text[2][14]="zzzzzzzzzzzzzzaBczzzzzzzzzz";
    text[2][15]="zzzzzzzzzzzzzzzaBczzzzzzzzz";
    text[2][16]="zzzzzzzzzzzzzzzzaBczzzzzzzz";
    text[2][17]="zzzzzzzzzzzzzzzzzaBczzzzzzz";
    text[2][18]="zzzzzzzzzzzzzzzzzzaBczzzzzz";
    text[2][19]="zzzzzzzzzzzzzzzzzzzaBczzzzz";
    text[2][20]="zzzzzzzzzzzzzzzzzzzzaBczzzz";
    text[2][21]="zzzzzzzzzzzzzzzzzzzzzaBczzz";
    text[2][22]="zzzzzzzzzzzzzzzzzzzzzzaBczz";
    text[2][23]="zzzzzzzzzzzzzzzzzzzzzzzaBcz";
    text[2][24]="zzzzzzzzzzzzzzzzzzzzzzzzaBc";
    text[3][0]="aBcDzzzzzzzzzzzzzzzzzzzzzzz";
    text[3][1]="zaBcDzzzzzzzzzzzzzzzzzzzzzz";
    text[3][2]="zzaBcDzzzzzzzzzzzzzzzzzzzzz";
    text[3][3]="zzzaBcDzzzzzzzzzzzzzzzzzzzz";
    text[3][4]="zzzzaBcDzzzzzzzzzzzzzzzzzzz";
    text[3][5]="zzzzzaBcDzzzzzzzzzzzzzzzzzz";
    text[3][6]="zzzzzzaBcDzzzzzzzzzzzzzzzzz";
    text[3][7]="zzzzzzzaBcDzzzzzzzzzzzzzzzz";
    text[3][8]="zzzzzzzzaBcDzzzzzzzzzzzzzzz";
    text[3][9]="zzzzzzzzzaBcDzzzzzzzzzzzzzz";
    text[3][10]="zzzzzzzzzzaBcDzzzzzzzzzzzzz";
    text[3][11]="zzzzzzzzzzzaBcDzzzzzzzzzzzz";
    text[3][12]="zzzzzzzzzzzzaBcDzzzzzzzzzzz";
    text[3][13]="zzzzzzzzzzzzzaBcDzzzzzzzzzz";
    text[3][14]="zzzzzzzzzzzzzzaBcDzzzzzzzzz";
    text[3][15]="zzzzzzzzzzzzzzzaBcDzzzzzzzz";
    text[3][16]="zzzzzzzzzzzzzzzzaBcDzzzzzzz";
    text[3][17]="zzzzzzzzzzzzzzzzzaBcDzzzzzz";
    text[3][18]="zzzzzzzzzzzzzzzzzzaBcDzzzzz";
    text[3][19]="zzzzzzzzzzzzzzzzzzzaBcDzzzz";
    text[3][20]="zzzzzzzzzzzzzzzzzzzzaBcDzzz";
    text[3][21]="zzzzzzzzzzzzzzzzzzzzzaBcDzz";
    text[3][22]="zzzzzzzzzzzzzzzzzzzzzzaBcDz";
    text[3][23]="zzzzzzzzzzzzzzzzzzzzzzzaBcD";
    text[4][0]="aBcDezzzzzzzzzzzzzzzzzzzzzz";
    text[4][1]="zaBcDezzzzzzzzzzzzzzzzzzzzz";
    text[4][2]="zzaBcDezzzzzzzzzzzzzzzzzzzz";
    text[4][3]="zzzaBcDezzzzzzzzzzzzzzzzzzz";
    text[4][4]="zzzzaBcDezzzzzzzzzzzzzzzzzz";
    text[4][5]="zzzzzaBcDezzzzzzzzzzzzzzzzz";
    text[4][6]="zzzzzzaBcDezzzzzzzzzzzzzzzz";
    text[4][7]="zzzzzzzaBcDezzzzzzzzzzzzzzz";
    text[4][8]="zzzzzzzzaBcDezzzzzzzzzzzzzz";
    text[4][9]="zzzzzzzzzaBcDezzzzzzzzzzzzz";
    text[4][10]="zzzzzzzzzzaBcDezzzzzzzzzzzz";
    text[4][11]="zzzzzzzzzzzaBcDezzzzzzzzzzz";
    text[4][12]="zzzzzzzzzzzzaBcDezzzzzzzzzz";
    text[4][13]="zzzzzzzzzzzzzaBcDezzzzzzzzz";
    text[4][14]="zzzzzzzzzzzzzzaBcDezzzzzzzz";
    text[4][15]="zzzzzzzzzzzzzzzaBcDezzzzzzz";
    text[4][16]="zzzzzzzzzzzzzzzzaBcDezzzzzz";
    text[4][17]="zzzzzzzzzzzzzzzzzaBcDezzzzz";
    text[4][18]="zzzzzzzzzzzzzzzzzzaBcDezzzz";
    text[4][19]="zzzzzzzzzzzzzzzzzzzaBcDezzz";
    text[4][20]="zzzzzzzzzzzzzzzzzzzzaBcDezz";
    text[4][21]="zzzzzzzzzzzzzzzzzzzzzaBcDez";
    text[4][22]="zzzzzzzzzzzzzzzzzzzzzzaBcDe";
    text[5][0]="aBcDeFzzzzzzzzzzzzzzzzzzzzz";
    text[5][1]="zaBcDeFzzzzzzzzzzzzzzzzzzzz";
    text[5][2]="zzaBcDeFzzzzzzzzzzzzzzzzzzz";
    text[5][3]="zzzaBcDeFzzzzzzzzzzzzzzzzzz";
    text[5][4]="zzzzaBcDeFzzzzzzzzzzzzzzzzz";
    text[5][5]="zzzzzaBcDeFzzzzzzzzzzzzzzzz";
    text[5][6]="zzzzzzaBcDeFzzzzzzzzzzzzzzz";
    text[5][7]="zzzzzzzaBcDeFzzzzzzzzzzzzzz";
    text[5][8]="zzzzzzzzaBcDeFzzzzzzzzzzzzz";
    text[5][9]="zzzzzzzzzaBcDeFzzzzzzzzzzzz";
    text[5][10]="zzzzzzzzzzaBcDeFzzzzzzzzzzz";
    text[5][11]="zzzzzzzzzzzaBcDeFzzzzzzzzzz";
    text[5][12]="zzzzzzzzzzzzaBcDeFzzzzzzzzz";
    text[5][13]="zzzzzzzzzzzzzaBcDeFzzzzzzzz";
    text[5][14]="zzzzzzzzzzzzzzaBcDeFzzzzzzz";
    text[5][15]="zzzzzzzzzzzzzzzaBcDeFzzzzzz";
    text[5][16]="zzzzzzzzzzzzzzzzaBcDeFzzzzz";
    text[5][17]="zzzzzzzzzzzzzzzzzaBcDeFzzzz";
    text[5][18]="zzzzzzzzzzzzzzzzzzaBcDeFzzz";
    text[5][19]="zzzzzzzzzzzzzzzzzzzaBcDeFzz";
    text[5][20]="zzzzzzzzzzzzzzzzzzzzaBcDeFz";
    text[5][21]="zzzzzzzzzzzzzzzzzzzzzaBcDeF";
    text[6][0]="aBcDeFgzzzzzzzzzzzzzzzzzzzz";
    text[6][1]="zaBcDeFgzzzzzzzzzzzzzzzzzzz";
    text[6][2]="zzaBcDeFgzzzzzzzzzzzzzzzzzz";
    text[6][3]="zzzaBcDeFgzzzzzzzzzzzzzzzzz";
    text[6][4]="zzzzaBcDeFgzzzzzzzzzzzzzzzz";
    text[6][5]="zzzzzaBcDeFgzzzzzzzzzzzzzzz";
    text[6][6]="zzzzzzaBcDeFgzzzzzzzzzzzzzz";
    text[6][7]="zzzzzzzaBcDeFgzzzzzzzzzzzzz";
    text[6][8]="zzzzzzzzaBcDeFgzzzzzzzzzzzz";
    text[6][9]="zzzzzzzzzaBcDeFgzzzzzzzzzzz";
    text[6][10]="zzzzzzzzzzaBcDeFgzzzzzzzzzz";
    text[6][11]="zzzzzzzzzzzaBcDeFgzzzzzzzzz";
    text[6][12]="zzzzzzzzzzzzaBcDeFgzzzzzzzz";
    text[6][13]="zzzzzzzzzzzzzaBcDeFgzzzzzzz";
    text[6][14]="zzzzzzzzzzzzzzaBcDeFgzzzzzz";
    text[6][15]="zzzzzzzzzzzzzzzaBcDeFgzzzzz";
    text[6][16]="zzzzzzzzzzzzzzzzaBcDeFgzzzz";
    text[6][17]="zzzzzzzzzzzzzzzzzaBcDeFgzzz";
    text[6][18]="zzzzzzzzzzzzzzzzzzaBcDeFgzz";
    text[6][19]="zzzzzzzzzzzzzzzzzzzaBcDeFgz";
    text[6][20]="zzzzzzzzzzzzzzzzzzzzaBcDeFg";
    text[7][0]="aBcDeFgHzzzzzzzzzzzzzzzzzzz";
    text[7][1]="zaBcDeFgHzzzzzzzzzzzzzzzzzz";
    text[7][2]="zzaBcDeFgHzzzzzzzzzzzzzzzzz";
    text[7][3]="zzzaBcDeFgHzzzzzzzzzzzzzzzz";
    text[7][4]="zzzzaBcDeFgHzzzzzzzzzzzzzzz";
    text[7][5]="zzzzzaBcDeFgHzzzzzzzzzzzzzz";
    text[7][6]="zzzzzzaBcDeFgHzzzzzzzzzzzzz";
    text[7][7]="zzzzzzzaBcDeFgHzzzzzzzzzzzz";
    text[7][8]="zzzzzzzzaBcDeFgHzzzzzzzzzzz";
    text[7][9]="zzzzzzzzzaBcDeFgHzzzzzzzzzz";
    text[7][10]="zzzzzzzzzzaBcDeFgHzzzzzzzzz";
    text[7][11]="zzzzzzzzzzzaBcDeFgHzzzzzzzz";
    text[7][12]="zzzzzzzzzzzzaBcDeFgHzzzzzzz";
    text[7][13]="zzzzzzzzzzzzzaBcDeFgHzzzzzz";
    text[7][14]="zzzzzzzzzzzzzzaBcDeFgHzzzzz";
    text[7][15]="zzzzzzzzzzzzzzzaBcDeFgHzzzz";
    text[7][16]="zzzzzzzzzzzzzzzzaBcDeFgHzzz";
    text[7][17]="zzzzzzzzzzzzzzzzzaBcDeFgHzz";
    text[7][18]="zzzzzzzzzzzzzzzzzzaBcDeFgHz";
    text[7][19]="zzzzzzzzzzzzzzzzzzzaBcDeFgH";
    text[8][0]="aBcDeFgHizzzzzzzzzzzzzzzzzz";
    text[8][1]="zaBcDeFgHizzzzzzzzzzzzzzzzz";
    text[8][2]="zzaBcDeFgHizzzzzzzzzzzzzzzz";
    text[8][3]="zzzaBcDeFgHizzzzzzzzzzzzzzz";
    text[8][4]="zzzzaBcDeFgHizzzzzzzzzzzzzz";
    text[8][5]="zzzzzaBcDeFgHizzzzzzzzzzzzz";
    text[8][6]="zzzzzzaBcDeFgHizzzzzzzzzzzz";
    text[8][7]="zzzzzzzaBcDeFgHizzzzzzzzzzz";
    text[8][8]="zzzzzzzzaBcDeFgHizzzzzzzzzz";
    text[8][9]="zzzzzzzzzaBcDeFgHizzzzzzzzz";
    text[8][10]="zzzzzzzzzzaBcDeFgHizzzzzzzz";
    text[8][11]="zzzzzzzzzzzaBcDeFgHizzzzzzz";
    text[8][12]="zzzzzzzzzzzzaBcDeFgHizzzzzz";
    text[8][13]="zzzzzzzzzzzzzaBcDeFgHizzzzz";
    text[8][14]="zzzzzzzzzzzzzzaBcDeFgHizzzz";
    text[8][15]="zzzzzzzzzzzzzzzaBcDeFgHizzz";
    text[8][16]="zzzzzzzzzzzzzzzzaBcDeFgHizz";
    text[8][17]="zzzzzzzzzzzzzzzzzaBcDeFgHiz";
    text[8][18]="zzzzzzzzzzzzzzzzzzaBcDeFgHi";
    text[9][0]="aBcDeFgHiJzzzzzzzzzzzzzzzzz";
    text[9][1]="zaBcDeFgHiJzzzzzzzzzzzzzzzz";
    text[9][2]="zzaBcDeFgHiJzzzzzzzzzzzzzzz";
    text[9][3]="zzzaBcDeFgHiJzzzzzzzzzzzzzz";
    text[9][4]="zzzzaBcDeFgHiJzzzzzzzzzzzzz";
    text[9][5]="zzzzzaBcDeFgHiJzzzzzzzzzzzz";
    text[9][6]="zzzzzzaBcDeFgHiJzzzzzzzzzzz";
    text[9][7]="zzzzzzzaBcDeFgHiJzzzzzzzzzz";
    text[9][8]="zzzzzzzzaBcDeFgHiJzzzzzzzzz";
    text[9][9]="zzzzzzzzzaBcDeFgHiJzzzzzzzz";
    text[9][10]="zzzzzzzzzzaBcDeFgHiJzzzzzzz";
    text[9][11]="zzzzzzzzzzzaBcDeFgHiJzzzzzz";
    text[9][12]="zzzzzzzzzzzzaBcDeFgHiJzzzzz";
    text[9][13]="zzzzzzzzzzzzzaBcDeFgHiJzzzz";
    text[9][14]="zzzzzzzzzzzzzzaBcDeFgHiJzzz";
    text[9][15]="zzzzzzzzzzzzzzzaBcDeFgHiJzz";
    text[9][16]="zzzzzzzzzzzzzzzzaBcDeFgHiJz";
    text[9][17]="zzzzzzzzzzzzzzzzzaBcDeFgHiJ";
    text[10][0]="aBcDeFgHiJkzzzzzzzzzzzzzzzz";
    text[10][1]="zaBcDeFgHiJkzzzzzzzzzzzzzzz";
    text[10][2]="zzaBcDeFgHiJkzzzzzzzzzzzzzz";
    text[10][3]="zzzaBcDeFgHiJkzzzzzzzzzzzzz";
    text[10][4]="zzzzaBcDeFgHiJkzzzzzzzzzzzz";
    text[10][5]="zzzzzaBcDeFgHiJkzzzzzzzzzzz";
    text[10][6]="zzzzzzaBcDeFgHiJkzzzzzzzzzz";
    text[10][7]="zzzzzzzaBcDeFgHiJkzzzzzzzzz";
    text[10][8]="zzzzzzzzaBcDeFgHiJkzzzzzzzz";
    text[10][9]="zzzzzzzzzaBcDeFgHiJkzzzzzzz";
    text[10][10]="zzzzzzzzzzaBcDeFgHiJkzzzzzz";
    text[10][11]="zzzzzzzzzzzaBcDeFgHiJkzzzzz";
    text[10][12]="zzzzzzzzzzzzaBcDeFgHiJkzzzz";
    text[10][13]="zzzzzzzzzzzzzaBcDeFgHiJkzzz";
    text[10][14]="zzzzzzzzzzzzzzaBcDeFgHiJkzz";
    text[10][15]="zzzzzzzzzzzzzzzaBcDeFgHiJkz";
    text[10][16]="zzzzzzzzzzzzzzzzaBcDeFgHiJk";
    text[11][0]="aBcDeFgHiJkLzzzzzzzzzzzzzzz";
    text[11][1]="zaBcDeFgHiJkLzzzzzzzzzzzzzz";
    text[11][2]="zzaBcDeFgHiJkLzzzzzzzzzzzzz";
    text[11][3]="zzzaBcDeFgHiJkLzzzzzzzzzzzz";
    text[11][4]="zzzzaBcDeFgHiJkLzzzzzzzzzzz";
    text[11][5]="zzzzzaBcDeFgHiJkLzzzzzzzzzz";
    text[11][6]="zzzzzzaBcDeFgHiJkLzzzzzzzzz";
    text[11][7]="zzzzzzzaBcDeFgHiJkLzzzzzzzz";
    text[11][8]="zzzzzzzzaBcDeFgHiJkLzzzzzzz";
    text[11][9]="zzzzzzzzzaBcDeFgHiJkLzzzzzz";
    text[11][10]="zzzzzzzzzzaBcDeFgHiJkLzzzzz";
    text[11][11]="zzzzzzzzzzzaBcDeFgHiJkLzzzz";
    text[11][12]="zzzzzzzzzzzzaBcDeFgHiJkLzzz";
    text[11][13]="zzzzzzzzzzzzzaBcDeFgHiJkLzz";
    text[11][14]="zzzzzzzzzzzzzzaBcDeFgHiJkLz";
    text[11][15]="zzzzzzzzzzzzzzzaBcDeFgHiJkL";
    text[12][0]="aBcDeFgHiJkLmzzzzzzzzzzzzzz";
    text[12][1]="zaBcDeFgHiJkLmzzzzzzzzzzzzz";
    text[12][2]="zzaBcDeFgHiJkLmzzzzzzzzzzzz";
    text[12][3]="zzzaBcDeFgHiJkLmzzzzzzzzzzz";
    text[12][4]="zzzzaBcDeFgHiJkLmzzzzzzzzzz";
    text[12][5]="zzzzzaBcDeFgHiJkLmzzzzzzzzz";
    text[12][6]="zzzzzzaBcDeFgHiJkLmzzzzzzzz";
    text[12][7]="zzzzzzzaBcDeFgHiJkLmzzzzzzz";
    text[12][8]="zzzzzzzzaBcDeFgHiJkLmzzzzzz";
    text[12][9]="zzzzzzzzzaBcDeFgHiJkLmzzzzz";
    text[12][10]="zzzzzzzzzzaBcDeFgHiJkLmzzzz";
    text[12][11]="zzzzzzzzzzzaBcDeFgHiJkLmzzz";
    text[12][12]="zzzzzzzzzzzzaBcDeFgHiJkLmzz";
    text[12][13]="zzzzzzzzzzzzzaBcDeFgHiJkLmz";
    text[12][14]="zzzzzzzzzzzzzzaBcDeFgHiJkLm";
    text[13][0]="aBcDeFgHiJkLmNzzzzzzzzzzzzz";
    text[13][1]="zaBcDeFgHiJkLmNzzzzzzzzzzzz";
    text[13][2]="zzaBcDeFgHiJkLmNzzzzzzzzzzz";
    text[13][3]="zzzaBcDeFgHiJkLmNzzzzzzzzzz";
    text[13][4]="zzzzaBcDeFgHiJkLmNzzzzzzzzz";
    text[13][5]="zzzzzaBcDeFgHiJkLmNzzzzzzzz";
    text[13][6]="zzzzzzaBcDeFgHiJkLmNzzzzzzz";
    text[13][7]="zzzzzzzaBcDeFgHiJkLmNzzzzzz";
    text[13][8]="zzzzzzzzaBcDeFgHiJkLmNzzzzz";
    text[13][9]="zzzzzzzzzaBcDeFgHiJkLmNzzzz";
    text[13][10]="zzzzzzzzzzaBcDeFgHiJkLmNzzz";
    text[13][11]="zzzzzzzzzzzaBcDeFgHiJkLmNzz";
    text[13][12]="zzzzzzzzzzzzaBcDeFgHiJkLmNz";
    text[13][13]="zzzzzzzzzzzzzaBcDeFgHiJkLmN";
    text[14][0]="aBcDeFgHiJkLmNozzzzzzzzzzzz";
    text[14][1]="zaBcDeFgHiJkLmNozzzzzzzzzzz";
    text[14][2]="zzaBcDeFgHiJkLmNozzzzzzzzzz";
    text[14][3]="zzzaBcDeFgHiJkLmNozzzzzzzzz";
    text[14][4]="zzzzaBcDeFgHiJkLmNozzzzzzzz";
    text[14][5]="zzzzzaBcDeFgHiJkLmNozzzzzzz";
    text[14][6]="zzzzzzaBcDeFgHiJkLmNozzzzzz";
    text[14][7]="zzzzzzzaBcDeFgHiJkLmNozzzzz";
    text[14][8]="zzzzzzzzaBcDeFgHiJkLmNozzzz";
    text[14][9]="zzzzzzzzzaBcDeFgHiJkLmNozzz";
    text[14][10]="zzzzzzzzzzaBcDeFgHiJkLmNozz";
    text[14][11]="zzzzzzzzzzzaBcDeFgHiJkLmNoz";
    text[14][12]="zzzzzzzzzzzzaBcDeFgHiJkLmNo";
    text[15][0]="aBcDeFgHiJkLmNoPzzzzzzzzzzz";
    text[15][1]="zaBcDeFgHiJkLmNoPzzzzzzzzzz";
    text[15][2]="zzaBcDeFgHiJkLmNoPzzzzzzzzz";
    text[15][3]="zzzaBcDeFgHiJkLmNoPzzzzzzzz";
    text[15][4]="zzzzaBcDeFgHiJkLmNoPzzzzzzz";
    text[15][5]="zzzzzaBcDeFgHiJkLmNoPzzzzzz";
    text[15][6]="zzzzzzaBcDeFgHiJkLmNoPzzzzz";
    text[15][7]="zzzzzzzaBcDeFgHiJkLmNoPzzzz";
    text[15][8]="zzzzzzzzaBcDeFgHiJkLmNoPzzz";
    text[15][9]="zzzzzzzzzaBcDeFgHiJkLmNoPzz";
    text[15][10]="zzzzzzzzzzaBcDeFgHiJkLmNoPz";
    text[15][11]="zzzzzzzzzzzaBcDeFgHiJkLmNoP";
    text[16][0]="aBcDeFgHiJkLmNoPqzzzzzzzzzz";
    text[16][1]="zaBcDeFgHiJkLmNoPqzzzzzzzzz";
    text[16][2]="zzaBcDeFgHiJkLmNoPqzzzzzzzz";
    text[16][3]="zzzaBcDeFgHiJkLmNoPqzzzzzzz";
    text[16][4]="zzzzaBcDeFgHiJkLmNoPqzzzzzz";
    text[16][5]="zzzzzaBcDeFgHiJkLmNoPqzzzzz";
    text[16][6]="zzzzzzaBcDeFgHiJkLmNoPqzzzz";
    text[16][7]="zzzzzzzaBcDeFgHiJkLmNoPqzzz";
    text[16][8]="zzzzzzzzaBcDeFgHiJkLmNoPqzz";
    text[16][9]="zzzzzzzzzaBcDeFgHiJkLmNoPqz";
    text[16][10]="zzzzzzzzzzaBcDeFgHiJkLmNoPq";
    text[17][0]="aBcDeFgHiJkLmNoPqRzzzzzzzzz";
    text[17][1]="zaBcDeFgHiJkLmNoPqRzzzzzzzz";
    text[17][2]="zzaBcDeFgHiJkLmNoPqRzzzzzzz";
    text[17][3]="zzzaBcDeFgHiJkLmNoPqRzzzzzz";
    text[17][4]="zzzzaBcDeFgHiJkLmNoPqRzzzzz";
    text[17][5]="zzzzzaBcDeFgHiJkLmNoPqRzzzz";
    text[17][6]="zzzzzzaBcDeFgHiJkLmNoPqRzzz";
    text[17][7]="zzzzzzzaBcDeFgHiJkLmNoPqRzz";
    text[17][8]="zzzzzzzzaBcDeFgHiJkLmNoPqRz";
    text[17][9]="zzzzzzzzzaBcDeFgHiJkLmNoPqR";
    text[18][0]="aBcDeFgHiJkLmNoPqRszzzzzzzz";
    text[18][1]="zaBcDeFgHiJkLmNoPqRszzzzzzz";
    text[18][2]="zzaBcDeFgHiJkLmNoPqRszzzzzz";
    text[18][3]="zzzaBcDeFgHiJkLmNoPqRszzzzz";
    text[18][4]="zzzzaBcDeFgHiJkLmNoPqRszzzz";
    text[18][5]="zzzzzaBcDeFgHiJkLmNoPqRszzz";
    text[18][6]="zzzzzzaBcDeFgHiJkLmNoPqRszz";
    text[18][7]="zzzzzzzaBcDeFgHiJkLmNoPqRsz";
    text[18][8]="zzzzzzzzaBcDeFgHiJkLmNoPqRs";
    text[19][0]="aBcDeFgHiJkLmNoPqRsTzzzzzzz";
    text[19][1]="zaBcDeFgHiJkLmNoPqRsTzzzzzz";
    text[19][2]="zzaBcDeFgHiJkLmNoPqRsTzzzzz";
    text[19][3]="zzzaBcDeFgHiJkLmNoPqRsTzzzz";
    text[19][4]="zzzzaBcDeFgHiJkLmNoPqRsTzzz";
    text[19][5]="zzzzzaBcDeFgHiJkLmNoPqRsTzz";
    text[19][6]="zzzzzzaBcDeFgHiJkLmNoPqRsTz";
    text[19][7]="zzzzzzzaBcDeFgHiJkLmNoPqRsT";
    text[20][0]="aBcDeFgHiJkLmNoPqRsTuzzzzzz";
    text[20][1]="zaBcDeFgHiJkLmNoPqRsTuzzzzz";
    text[20][2]="zzaBcDeFgHiJkLmNoPqRsTuzzzz";
    text[20][3]="zzzaBcDeFgHiJkLmNoPqRsTuzzz";
    text[20][4]="zzzzaBcDeFgHiJkLmNoPqRsTuzz";
    text[20][5]="zzzzzaBcDeFgHiJkLmNoPqRsTuz";
    text[20][6]="zzzzzzaBcDeFgHiJkLmNoPqRsTu";
    text[21][0]="aBcDeFgHiJkLmNoPqRsTuVzzzzz";
    text[21][1]="zaBcDeFgHiJkLmNoPqRsTuVzzzz";
    text[21][2]="zzaBcDeFgHiJkLmNoPqRsTuVzzz";
    text[21][3]="zzzaBcDeFgHiJkLmNoPqRsTuVzz";
    text[21][4]="zzzzaBcDeFgHiJkLmNoPqRsTuVz";
    text[21][5]="zzzzzaBcDeFgHiJkLmNoPqRsTuV";
    text[22][0]="aBcDeFgHiJkLmNoPqRsTuVwzzzz";
    text[22][1]="zaBcDeFgHiJkLmNoPqRsTuVwzzz";
    text[22][2]="zzaBcDeFgHiJkLmNoPqRsTuVwzz";
    text[22][3]="zzzaBcDeFgHiJkLmNoPqRsTuVwz";
    text[22][4]="zzzzaBcDeFgHiJkLmNoPqRsTuVw";
    text[23][0]="aBcDeFgHiJkLmNoPqRsTuVwXzzz";
    text[23][1]="zaBcDeFgHiJkLmNoPqRsTuVwXzz";
    text[23][2]="zzaBcDeFgHiJkLmNoPqRsTuVwXz";
    text[23][3]="zzzaBcDeFgHiJkLmNoPqRsTuVwX";
    text[24][0]="aBcDeFgHiJkLmNoPqRsTuVwXyzz";
    text[24][1]="zaBcDeFgHiJkLmNoPqRsTuVwXyz";
    text[24][2]="zzaBcDeFgHiJkLmNoPqRsTuVwXy";
    text[25][0]="aBcDeFgHiJkLmNoPqRsTuVwXyZz";
    text[25][1]="zaBcDeFgHiJkLmNoPqRsTuVwXyZ";
 
    const char *needle[26];
    needle[0]="A";
    needle[1]="Ab";
    needle[2]="AbC";
    needle[3]="AbCd";
    needle[4]="AbCdE";
    needle[5]="AbCdEf";
    needle[6]="AbCdEfG";
    needle[7]="AbCdEfGh";
    needle[8]="AbCdEfGhI";
    needle[9]="AbCdEfGhIJ";
    needle[10]="AbCdEfGhIjK";
    needle[11]="AbCdEfGhIjKl";
    needle[12]="AbCdEfGhIjKlM";
    needle[13]="AbCdEfGhIjKlMn";
    needle[14]="AbCdEfGhIjKlMnO";
    needle[15]="AbCdEfGhIjKlMnOp";
    needle[16]="AbCdEfGhIjKlMnOpQ";
    needle[17]="AbCdEfGhIjKlMnOpQr";
    needle[18]="AbCdEfGhIjKlMnOpQrS";
    needle[19]="AbCdEfGhIjKlMnOpQrSt";
    needle[20]="AbCdEfGhIjKlMnOpQrStU";
    needle[21]="AbCdEfGhIjKlMnOpQrStUv";
    needle[22]="AbCdEfGhIjKlMnOpQrStUvW";
    needle[23]="AbCdEfGhIjKlMnOpQrStUvWx";
    needle[24]="AbCdEfGhIjKlMnOpQrStUvWxY";
    needle[25]="AbCdEfGhIjKlMnOpQrStUvWxYZ";
 
    int i, j;
    uint8_t *found = NULL;
    for (i = 0; i < 26; i++) {
        for (j = 0; j <= (26-i); j++) {
            found = BasicSearchNocaseWrapper((uint8_t *)text[i][j], (uint8_t *)needle[i], 1);
            if (found == 0) {
                printf("Error1 searching for %s in text %s\n", needle[i], text[i][j]);
                return 0;
            }
            found = Bs2bmNocaseWrapper((uint8_t *)text[i][j], (uint8_t *)needle[i], 1);
            if (found == 0) {
                printf("Error2 searching for %s in text %s\n", needle[i], text[i][j]);
                return 0;
            }
            found = BoyerMooreNocaseWrapper((uint8_t *)text[i][j], (uint8_t *)needle[i], 1);
            if (found == 0) {
                printf("Error3 searching for %s in text %s\n", needle[i], text[i][j]);
                return 0;
            }
        }
    }
    return 1;
}
 
#ifdef ENABLE_SEARCH_STATS
/**
 * \test Give some stats
 */
static int UtilSpmSearchStatsTest01(void)
{
    char *text[16];
    text[0]="zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzza";
    text[1]="aaaaaaaaazaaaaaaaaaaaaaaaaaaaaazaaaaaaaaaaaaaazaaaaaaaaaaaaaaaaaaaaazaaaaaaaaaaaaaaaaaaazaaaaaaaaaaaaaaaaaaazaaaaaaaaazaaaaaaaaaazaaaaaaaaaaaaazaaaaaaaaazaaaaaaaaaaaaaaaaazaaaaaaaaaaaaaaaaazaaaaaaaaazaaaaaaaaaazaaaaaraaaaazaaaaaaazaaaaaaaaaaaaaazaaaaaaaazaaaaaaaaazaaaaaaaaaaaaB";
    text[2]="aBaBaBaBaBaBaBaBazaBaBaBaBaBaBazaBaBaBaBaBaBaBaBaBzBaBaBaBaBaBaBaBazaBaBaBaBaBaBaBzBaBaBaBaBaBaBzBaBaBaBaBzBaBaBaBaBaBzBaBaBaBaBaBzBaBaBaBaBaBaBaBazaBaBaBaBaBaBaBaBaBaBaBaBazaBaBaBaBaBaBaBaBaBzBaBaBaBaBaBaBaBzBaBaBaBaBaBaBaBaBaBzBaBaBaBaBaBaBaBaBaBaBazaBaBaBaBaBaBaBazaBaBaBaBaBc";
    text[3]="aBcaBcaBcaBcaBczBcaBcaBzaBcaBcaBcaBcaBcaBcaBcaBcazcaBcaBcaBcaBcaBcaBcaBzaBcaBcaBcaBcaBcaBczBcaBcaBcaBcaBcaBzaBcaBcaBcaBcaBcaBcaBcazcaBcaBcaBcaBcaBcaBcaBcaBczBcaBcaBcaBcaBcaBcaBczBcaBcaBcaBcaBzaBcaBcaBcaBcaBcaBcaBcazcaBcaBcaBcaBcaBcazcaBcaBcaBcaBcaBcaBzaBcaBcaBcazcaBcaBcaBcaBcaBcD";
    text[4]="aBcDaBcDaBcDaBczaBcDaBcDaBcDaBcDaBczaBcDaBcDaBcDaBcDzBcDaBcDaBcDaBcDzBcDaBcDaBczaBcDaBcDaBczaBcDaBcDaBcDaBcDaBzDaBcDaBcDaBcDaBcDaBcDaBcDaBcDaBczaBcDaBcDaBcDaBcDaBcDaBzDaBcDaBcDaBcDaBzDaBcDaBcDaBzDaBcDaBcDaBcDaBcDaBcDaBczaBcDaBcDaBcDaBcDazcDaBcDaBcDaBcDaBcDzBcDaBcDaBcDaBcDaBcDaBcDe";
    text[5]="aBcDeaBcDeaBcDeazcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDezBcDeaBcDeaBcDzaBcDeaBcDeaBcDeazcDzaBcDeaBcDezBcDeaBzDeaBcDeaBcDeazcDeaBcDeaBcDeaBcDzaBcDeaBcDeaBczeaBcDeaBcDeaBzDeaBcDeaBcDezBcDeaBcDzaBcDeaBcDezBcDeaBcDezBcDeaBczeaBcDeaBcDeaBzDeaBcDezBcDeaBcDeaBcDeaBcDeaBcDeaBcDeaBcDeaBcDezzzaBcDeF";
    text[6]="aBcDeaBcDeaBcDeazcDeaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDeaBcDzaBzDeaBcDeaBcDeaBcDzaBcDzaBcDeaBcDeaBcDeaBcDzaBzDeaBcDeaBcDeaBczzaBcDeaBcDeaBcDzazcDeaBcDeaBcDeaBcDzaBzDeaBcDeaBcDeaBcDeazcDeaBcDeaBcDeaBcDeaBczeaBcDeaBcDeaBcDeaBczeaBcDezzzaBcDeFg";
    text[7]="aBcDeaBczeaBcDzaBcDezBcDeaBcDeaBcDeaBcDzaBzDeaBcDeaBcDeaBzDzaBcDeaBcDeazcDeaBcDzaBcDeaBczeaBcDeaBcDeaBzDzaBcDeaBcDeaBcDezBcDzaBcDeaBzDeaBcDeaBcDezBcDzaBcDeaBcDeaBzDeaBcDeaBcDeaBzDeaBcDeaBcDezBcDeaBcDeaBcDeazcDeaBcDeaBcDeaBcDzaBcDeaBcDeaBcDeaBcDzaBcDeaBcDeaBcDeaBrDeaBcDeaBcDezzzaBcDeFgH";
    text[8]="aBcDeaBcDeaBczzaBcDeazcDeaBcDezBcDeaBcDzaBcDeaBcDeaBcDeaBczzaBcDeaBcDeaBczeaBcDeaBcDzzBcDeaBcDeaBcDzaBczeaBcDeaBcDzaBcDeaBczeaBcDeaBcDeaBzDeaBcDeaBcDeaBzDeaBcDeaBcDzaBcDeaBcDeazcDeaBcDeaBcDzaBcDeaBcDeaBcDeazcDeaBcDeaBcDeaBcDeazcDeaBcDeaBcDeaBczeaBcDeaBzDeaBcDeaBcDeaBcDeaBcDezzzaBcDeFgHi";
    text[9]="aBcDeaBcDzaBcDzaBcDeaBcDeaBcDzaBcDeaBcDzaBcDeazcDeaBcDeaBcDzzBcDeaBcDeaBczeaBcDzaBcDezBcDeaBczeaBcDzaBcDezBcDeaBcDzaBczeaBcDeaBcDzaBcDeazcDeaBcDeaBcDzaBczeaBcDeaBcDzaBzDeaBcDeaBczeaBcDeaBcDzaBcDeaBcDeaBzDeaBcDeaBcDeaBczeaBcDeaBcDeaBcDeaBzDeaBcDeaBcDeazcDeaBcDeaBcDeaBcDeaBcDezzzaBcDeFgHiJ";
    text[10]="aBcDeaBcDeaBczeaBcDzaBczeaBcDeaBczeaBcDeaBcDzaBcDeaBcDeazcDeaBcDeaBcDeaBzDzaBcDeazcDeaBcDeazcDeaBcDzaBcDeazcDeaBcDeaBczzaBcDeaBcDeaBzDeaBcDeaBcDzaBczeaBcDeaBcDeaBcDeaBczeaBcDeaBcDeaBcDzaBcDeaBcDeaBcDezBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDezBcDeaBcDeaBcDeaBzDeaBcDeaBcDezzzaBcDeFgHiJk";
    text[11]="aBcDeaBcDeaBcDeaBcDeaBzDeaBcDeaBcDzaBcDzaBcDeaBcDeaBcDeaBcDeazcDeaBcDzaBcDeaBcDeaBcDeaBcDzaBcDeaBcDzaBcDzaBcDeaBcDeaBcDeaBcDzzBcDeaBcDeaBcDeaBcDzaBcDzaBcDeaBzDeaBcDeaBcDezBcDeaBcDeazcDeaBcDeaBcDezBcDeaBcDeaBcDeazcDeaBcDeaBzDeaBcDeaBczeaBcDeazcDeaBcDezBcDeaBcDeaBcDeaBcDeaBcDezzzaBcDeFgHiJkL";
    text[12]="aBcDeaBcDeaBcDeaBcDeaBzDeaBcDeaBzDeaBcDeaBcDezBcDeaBcDeazcDeaBcDeaBcDeazcDeaBcDeaBczeaBcDeaBcDeaBcDezBcDeaBcDzaBcDeaBcDzaBcDeaBcDeaBcDeaBcDeaBcDeaBcDeaBcDeaBcDeaBcDeaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDzaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDeaBcDeaBcDeaBcDezzzaBcDeFgHiJkLm";
    text[13]="aBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDeaBcDeaBcDeaBcDeaBcDeaBcDeaBcDeaBcDeaBcDeaBcDeaBcDeaBcDeaBcDeaBcDeaBcDezzzaBcDeFgHiJkLmN";
    text[14]="aBcDeaBcDeaBcDzaBcDeaBcDeaBcDeaBcDzaBcDeaBcDeaBcDeaBcDzaBcDeaBcDeaBcDeaBcDzaBcDeaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDzaBcDezzzaBcDeFgHiJkLmNo";
    text[15]="aBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDzaBcDeaBcDzaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDzaBcDeaBcDzaBcDeaBcDzaBcDeaBcDzaBcDeaBcDzaBcDeaBcDzaBcDeaBcDeaBcDeaBcDezzzaBcDeFgHiJkLmNoP";
 
    char *needle[16];
    needle[0]="a";
    needle[1]="aB";
    needle[2]="aBc";
    needle[3]="aBcD";
    needle[4]="aBcDe";
    needle[5]="aBcDeF";
    needle[6]="aBcDeFg";
    needle[7]="aBcDeFgH";
    needle[8]="aBcDeFgHi";
    needle[9]="aBcDeFgHiJ";
    needle[10]="aBcDeFgHiJk";
    needle[11]="aBcDeFgHiJkL";
    needle[12]="aBcDeFgHiJkLm";
    needle[13]="aBcDeFgHiJkLmN";
    needle[14]="aBcDeFgHiJkLmNo";
    needle[15]="aBcDeFgHiJkLmNoP";
 
    int i;
    uint8_t *found = NULL;
        printf("\nStats for text of greater length (text with a lot of partial matches, worst case for a basic search):\n");
    for (i = 0; i < 16; i++) {
        printf("Pattern length %d with BasicSearch:", i+1);
        found = BasicSearchWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
        if (found == 0) {
            printf("Error1 searching for %s in text %s\n", needle[i], text[i]);
            return 0;
        }
        printf("Pattern length %d with Bs2BmSearch:", i+1);
        found = Bs2bmWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
        if (found == 0) {
            printf("Error2 searching for %s in text %s\n", needle[i], text[i]);
            return 0;
        }
        printf("Pattern length %d with BoyerMooreSearch:", i+1);
        found = BoyerMooreWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
        if (found == 0) {
            printf("Error3 searching for %s in text %s\n", needle[i], text[i]);
            return 0;
        }
        printf("\n");
    }
    return 1;
}
 
/**
 * \test Give some stats for
 */
static int UtilSpmSearchStatsTest02(void)
{
    char *text[16];
    text[0]="zzzzzzzzzzzzzzzzzza";
    text[1]="zzzzzzzzzzzzzzzzzzaB";
    text[2]="zzzzzzzzzzzzzzzzzzaBc";
    text[3]="zzzzzzzzzzzzzzzzzzaBcD";
    text[4]="zzzzzzzzzzzzzzzzzzaBcDe";
    text[5]="zzzzzzzzzzzzzzzzzzzzaBcDeF";
    text[6]="zzzzzzzzzzzzzzzzzzzzaBcDeFg";
    text[7]="zzzzzzzzzzzzzzzzzzzzaBcDeFgH";
    text[8]="zzzzzzzzzzzzzzzzzzzzaBcDeFgHi";
    text[9]="zzzzzzzzzzzzzzzzzzzzaBcDeFgHiJ";
    text[10]="zzzzzzzzzzzzzzzzzzzzaBcDeFgHiJk";
    text[11]="zzzzzzzzzzzzzzzzzzzzaBcDeFgHiJkL";
    text[12]="zzzzzzzzzzzzzzzzzzzzaBcDeFgHiJkLm";
    text[13]="zzzzzzzzzzzzzzzzzzzzaBcDeFgHiJkLmN";
    text[14]="zzzzzzzzzzzzzzzzzzzzaBcDeFgHiJkLmNo";
    text[15]="zzzzzzzzzzzzzzzzzzzzaBcDeFgHiJkLmNoP";
 
    char *needle[16];
    needle[0]="a";
    needle[1]="aB";
    needle[2]="aBc";
    needle[3]="aBcD";
    needle[4]="aBcDe";
    needle[5]="aBcDeF";
    needle[6]="aBcDeFg";
    needle[7]="aBcDeFgH";
    needle[8]="aBcDeFgHi";
    needle[9]="aBcDeFgHiJ";
    needle[10]="aBcDeFgHiJk";
    needle[11]="aBcDeFgHiJkL";
    needle[12]="aBcDeFgHiJkLm";
    needle[13]="aBcDeFgHiJkLmN";
    needle[14]="aBcDeFgHiJkLmNo";
    needle[15]="aBcDeFgHiJkLmNoP";
 
    int i;
    uint8_t *found = NULL;
        printf("\nStats for text of lower length:\n");
    for (i = 0; i < 16; i++) {
        printf("Pattern length %d with BasicSearch:", i+1);
        found = BasicSearchWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
        if (found == 0) {
            printf("Error1 searching for %s in text %s\n", needle[i], text[i]);
            return 0;
        }
        printf("Pattern length %d with Bs2BmSearch:", i+1);
        found = Bs2bmWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
        if (found == 0) {
            printf("Error2 searching for %s in text %s\n", needle[i], text[i]);
            return 0;
        }
        printf("Pattern length %d with BoyerMooreSearch:", i+1);
        found = BoyerMooreWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
        if (found == 0) {
            printf("Error3 searching for %s in text %s\n", needle[i], text[i]);
            return 0;
        }
        printf("\n");
    }
    return 1;
}
 
 
static int UtilSpmSearchStatsTest03(void)
{
    char *text[16];
    text[0]="zzzzzza";
    text[1]="zzzzzzaB";
    text[2]="zzzzzzaBc";
    text[3]="zzzzzzaBcD";
    text[4]="zzzzzzaBcDe";
    text[5]="zzzzzzzzaBcDeF";
    text[6]="zzzzzzzzaBcDeFg";
    text[7]="zzzzzzzzaBcDeFgH";
    text[8]="zzzzzzzzaBcDeFgHi";
    text[9]="zzzzzzzzaBcDeFgHiJ";
    text[10]="zzzzzzzzaBcDeFgHiJk";
    text[11]="zzzzzzzzaBcDeFgHiJkL";
    text[12]="zzzzzzzzaBcDeFgHiJkLm";
    text[13]="zzzzzzzzaBcDeFgHiJkLmN";
    text[14]="zzzzzzzzaBcDeFgHiJkLmNo";
    text[15]="zzzzzzzzaBcDeFgHiJkLmNoP";
 
    char *needle[16];
    needle[0]="a";
    needle[1]="aB";
    needle[2]="aBc";
    needle[3]="aBcD";
    needle[4]="aBcDe";
    needle[5]="aBcDeF";
    needle[6]="aBcDeFg";
    needle[7]="aBcDeFgH";
    needle[8]="aBcDeFgHi";
    needle[9]="aBcDeFgHiJ";
    needle[10]="aBcDeFgHiJk";
    needle[11]="aBcDeFgHiJkL";
    needle[12]="aBcDeFgHiJkLm";
    needle[13]="aBcDeFgHiJkLmN";
    needle[14]="aBcDeFgHiJkLmNo";
    needle[15]="aBcDeFgHiJkLmNoP";
 
    int i;
    uint8_t *found = NULL;
        printf("\nStats for text of lower length (badcase for):\n");
    for (i = 0; i < 16; i++) {
        printf("Pattern length %d with BasicSearch:", i+1);
        found = BasicSearchWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
        if (found == 0) {
            printf("Error1 searching for %s in text %s\n", needle[i], text[i]);
            return 0;
        }
        printf("Pattern length %d with Bs2BmSearch:", i+1);
        found = Bs2bmWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
        if (found == 0) {
            printf("Error2 searching for %s in text %s\n", needle[i], text[i]);
            return 0;
        }
        printf("Pattern length %d with BoyerMooreSearch:", i+1);
        found = BoyerMooreWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
        if (found == 0) {
            printf("Error3 searching for %s in text %s\n", needle[i], text[i]);
            return 0;
        }
        printf("\n");
    }
    return 1;
}
 
/**
 * \test Give some stats
 */
static int UtilSpmSearchStatsTest04(void)
{
    char *text[16];
    text[0]="zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzza";
    text[1]="aaaaaaaaazaaaaaaaaaaaaaaaaaaaaazaaaaaaaaaaaaaazaaaaaaaaaaaaaaaaaaaaazaaaaaaaaaaaaaaaaaaazaaaaaaaaaaaaaaaaaaazaaaaaaaaazaaaaaaaaaazaaaaaaaaaaaaazaaaaaaaaazaaaaaaaaaaaaaaaaazaaaaaaaaaaaaaaaaazaaaaaaaaazaaaaaaaaaazaaaaaraaaaazaaaaaaazaaaaaaaaaaaaaazaaaaaaaazaaaaaaaaazaaaaaaaaaaaaB";
    text[2]="aBaBaBaBaBaBaBaBazaBaBaBaBaBaBazaBaBaBaBaBaBaBaBaBzBaBaBaBaBaBaBaBazaBaBaBaBaBaBaBzBaBaBaBaBaBaBzBaBaBaBaBzBaBaBaBaBaBzBaBaBaBaBaBzBaBaBaBaBaBaBaBazaBaBaBaBaBaBaBaBaBaBaBaBazaBaBaBaBaBaBaBaBaBzBaBaBaBaBaBaBaBzBaBaBaBaBaBaBaBaBaBzBaBaBaBaBaBaBaBaBaBaBazaBaBaBaBaBaBaBazaBaBaBaBaBc";
    text[3]="aBcaBcaBcaBcaBczBcaBcaBzaBcaBcaBcaBcaBcaBcaBcaBcazcaBcaBcaBcaBcaBcaBcaBzaBcaBcaBcaBcaBcaBczBcaBcaBcaBcaBcaBzaBcaBcaBcaBcaBcaBcaBcazcaBcaBcaBcaBcaBcaBcaBcaBczBcaBcaBcaBcaBcaBcaBczBcaBcaBcaBcaBzaBcaBcaBcaBcaBcaBcaBcazcaBcaBcaBcaBcaBcazcaBcaBcaBcaBcaBcaBzaBcaBcaBcazcaBcaBcaBcaBcaBcD";
    text[4]="aBcDaBcDaBcDaBczaBcDaBcDaBcDaBcDaBczaBcDaBcDaBcDaBcDzBcDaBcDaBcDaBcDzBcDaBcDaBczaBcDaBcDaBczaBcDaBcDaBcDaBcDaBzDaBcDaBcDaBcDaBcDaBcDaBcDaBcDaBczaBcDaBcDaBcDaBcDaBcDaBzDaBcDaBcDaBcDaBzDaBcDaBcDaBzDaBcDaBcDaBcDaBcDaBcDaBczaBcDaBcDaBcDaBcDazcDaBcDaBcDaBcDaBcDzBcDaBcDaBcDaBcDaBcDaBcDe";
    text[5]="aBcDeaBcDeaBcDeazcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDezBcDeaBcDeaBcDzaBcDeaBcDeaBcDeazcDzaBcDeaBcDezBcDeaBzDeaBcDeaBcDeazcDeaBcDeaBcDeaBcDzaBcDeaBcDeaBczeaBcDeaBcDeaBzDeaBcDeaBcDezBcDeaBcDzaBcDeaBcDezBcDeaBcDezBcDeaBczeaBcDeaBcDeaBzDeaBcDezBcDeaBcDeaBcDeaBcDeaBcDeaBcDeaBcDeaBcDezzzaBcDeF";
    text[6]="aBcDeaBcDeaBcDeazcDeaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDeaBcDzaBzDeaBcDeaBcDeaBcDzaBcDzaBcDeaBcDeaBcDeaBcDzaBzDeaBcDeaBcDeaBczzaBcDeaBcDeaBcDzazcDeaBcDeaBcDeaBcDzaBzDeaBcDeaBcDeaBcDeazcDeaBcDeaBcDeaBcDeaBczeaBcDeaBcDeaBcDeaBczeaBcDezzzaBcDeFg";
    text[7]="aBcDeaBczeaBcDzaBcDezBcDeaBcDeaBcDeaBcDzaBzDeaBcDeaBcDeaBzDzaBcDeaBcDeazcDeaBcDzaBcDeaBczeaBcDeaBcDeaBzDzaBcDeaBcDeaBcDezBcDzaBcDeaBzDeaBcDeaBcDezBcDzaBcDeaBcDeaBzDeaBcDeaBcDeaBzDeaBcDeaBcDezBcDeaBcDeaBcDeazcDeaBcDeaBcDeaBcDzaBcDeaBcDeaBcDeaBcDzaBcDeaBcDeaBcDeaBrDeaBcDeaBcDezzzaBcDeFgH";
    text[8]="aBcDeaBcDeaBczzaBcDeazcDeaBcDezBcDeaBcDzaBcDeaBcDeaBcDeaBczzaBcDeaBcDeaBczeaBcDeaBcDzzBcDeaBcDeaBcDzaBczeaBcDeaBcDzaBcDeaBczeaBcDeaBcDeaBzDeaBcDeaBcDeaBzDeaBcDeaBcDzaBcDeaBcDeazcDeaBcDeaBcDzaBcDeaBcDeaBcDeazcDeaBcDeaBcDeaBcDeazcDeaBcDeaBcDeaBczeaBcDeaBzDeaBcDeaBcDeaBcDeaBcDezzzaBcDeFgHi";
    text[9]="aBcDeaBcDzaBcDzaBcDeaBcDeaBcDzaBcDeaBcDzaBcDeazcDeaBcDeaBcDzzBcDeaBcDeaBczeaBcDzaBcDezBcDeaBczeaBcDzaBcDezBcDeaBcDzaBczeaBcDeaBcDzaBcDeazcDeaBcDeaBcDzaBczeaBcDeaBcDzaBzDeaBcDeaBczeaBcDeaBcDzaBcDeaBcDeaBzDeaBcDeaBcDeaBczeaBcDeaBcDeaBcDeaBzDeaBcDeaBcDeazcDeaBcDeaBcDeaBcDeaBcDezzzaBcDeFgHiJ";
    text[10]="aBcDeaBcDeaBczeaBcDzaBczeaBcDeaBczeaBcDeaBcDzaBcDeaBcDeazcDeaBcDeaBcDeaBzDzaBcDeazcDeaBcDeazcDeaBcDzaBcDeazcDeaBcDeaBczzaBcDeaBcDeaBzDeaBcDeaBcDzaBczeaBcDeaBcDeaBcDeaBczeaBcDeaBcDeaBcDzaBcDeaBcDeaBcDezBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDezBcDeaBcDeaBcDeaBzDeaBcDeaBcDezzzaBcDeFgHiJk";
    text[11]="aBcDeaBcDeaBcDeaBcDeaBzDeaBcDeaBcDzaBcDzaBcDeaBcDeaBcDeaBcDeazcDeaBcDzaBcDeaBcDeaBcDeaBcDzaBcDeaBcDzaBcDzaBcDeaBcDeaBcDeaBcDzzBcDeaBcDeaBcDeaBcDzaBcDzaBcDeaBzDeaBcDeaBcDezBcDeaBcDeazcDeaBcDeaBcDezBcDeaBcDeaBcDeazcDeaBcDeaBzDeaBcDeaBczeaBcDeazcDeaBcDezBcDeaBcDeaBcDeaBcDeaBcDezzzaBcDeFgHiJkL";
    text[12]="aBcDeaBcDeaBcDeaBcDeaBzDeaBcDeaBzDeaBcDeaBcDezBcDeaBcDeazcDeaBcDeaBcDeazcDeaBcDeaBczeaBcDeaBcDeaBcDezBcDeaBcDzaBcDeaBcDzaBcDeaBcDeaBcDeaBcDeaBcDeaBcDeaBcDeaBcDeaBcDeaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDzaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDeaBcDeaBcDeaBcDezzzaBcDeFgHiJkLm";
    text[13]="aBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDeaBcDeaBcDeaBcDeaBcDeaBcDeaBcDeaBcDeaBcDeaBcDeaBcDeaBcDeaBcDeaBcDeaBcDezzzaBcDeFgHiJkLmN";
    text[14]="aBcDeaBcDeaBcDzaBcDeaBcDeaBcDeaBcDzaBcDeaBcDeaBcDeaBcDzaBcDeaBcDeaBcDeaBcDzaBcDeaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDzaBcDezzzaBcDeFgHiJkLmNo";
    text[15]="aBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDzaBcDeaBcDzaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDzaBcDeaBcDeaBcDzaBcDeaBcDzaBcDeaBcDzaBcDeaBcDzaBcDeaBcDzaBcDeaBcDzaBcDeaBcDzaBcDeaBcDeaBcDeaBcDezzzaBcDeFgHiJkLmNoP";
 
 
    char *needle[16];
    needle[0]="a";
    needle[1]="aB";
    needle[2]="aBc";
    needle[3]="aBcD";
    needle[4]="aBcDe";
    needle[5]="aBcDeF";
    needle[6]="aBcDeFg";
    needle[7]="aBcDeFgH";
    needle[8]="aBcDeFgHi";
    needle[9]="aBcDeFgHiJ";
    needle[10]="aBcDeFgHiJk";
    needle[11]="aBcDeFgHiJkL";
    needle[12]="aBcDeFgHiJkLm";
    needle[13]="aBcDeFgHiJkLmN";
    needle[14]="aBcDeFgHiJkLmNo";
    needle[15]="aBcDeFgHiJkLmNoP";
 
    int i;
    uint8_t *found = NULL;
        printf("\nStats for text of greater length:\n");
    for (i = 0; i < 16; i++) {
        printf("Pattern length %d with BasicSearch (Building Context):", i + 1);
        found = BasicSearchCtxWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
        if (found == 0) {
            printf("Error1 searching for %s in text %s\n", needle[i], text[i]);
            return 0;
        }
        printf("Pattern length %d with Bs2BmSearch (Building Context):", i + 1);
        found = Bs2bmCtxWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
        if (found == 0) {
            printf("Error2 searching for %s in text %s\n", needle[i], text[i]);
            return 0;
        }
        printf("Pattern length %d with BoyerMooreSearch (Building Context):", i + 1);
        found = BoyerMooreCtxWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
        if (found == 0) {
            printf("Error3 searching for %s in text %s\n", needle[i], text[i]);
            return 0;
        }
        printf("Pattern length %d with SpmSearch (Building Context):", i + 1);
        found = RawCtxWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
        if (found == 0) {
            printf("Error3 searching for %s in text %s\n", needle[i], text[i]);
            return 0;
        }
        printf("\n");
    }
    return 1;
}
 
/**
 * \test Give some stats for
 */
static int UtilSpmSearchStatsTest05(void)
{
    char *text[16];
    text[0]="zzzzzzzzzzzzzzzzzza";
    text[1]="zzzzzzzzzzzzzzzzzzaB";
    text[2]="zzzzzzzzzzzzzzzzzzaBc";
    text[3]="zzzzzzzzzzzzzzzzzzaBcD";
    text[4]="zzzzzzzzzzzzzzzzzzaBcDe";
    text[5]="zzzzzzzzzzzzzzzzzzzzaBcDeF";
    text[6]="zzzzzzzzzzzzzzzzzzzzaBcDeFg";
    text[7]="zzzzzzzzzzzzzzzzzzzzaBcDeFgH";
    text[8]="zzzzzzzzzzzzzzzzzzzzaBcDeFgHi";
    text[9]="zzzzzzzzzzzzzzzzzzzzaBcDeFgHiJ";
    text[10]="zzzzzzzzzzzzzzzzzzzzaBcDeFgHiJk";
    text[11]="zzzzzzzzzzzzzzzzzzzzaBcDeFgHiJkL";
    text[12]="zzzzzzzzzzzzzzzzzzzzaBcDeFgHiJkLm";
    text[13]="zzzzzzzzzzzzzzzzzzzzaBcDeFgHiJkLmN";
    text[14]="zzzzzzzzzzzzzzzzzzzzaBcDeFgHiJkLmNo";
    text[15]="zzzzzzzzzzzzzzzzzzzzaBcDeFgHiJkLmNoP";
 
    char *needle[16];
    needle[0]="a";
    needle[1]="aB";
    needle[2]="aBc";
    needle[3]="aBcD";
    needle[4]="aBcDe";
    needle[5]="aBcDeF";
    needle[6]="aBcDeFg";
    needle[7]="aBcDeFgH";
    needle[8]="aBcDeFgHi";
    needle[9]="aBcDeFgHiJ";
    needle[10]="aBcDeFgHiJk";
    needle[11]="aBcDeFgHiJkL";
    needle[12]="aBcDeFgHiJkLm";
    needle[13]="aBcDeFgHiJkLmN";
    needle[14]="aBcDeFgHiJkLmNo";
    needle[15]="aBcDeFgHiJkLmNoP";
 
    int i;
    uint8_t *found = NULL;
        printf("\nStats for text of lower length:\n");
    for (i = 0; i < 16; i++) {
        printf("Pattern length %d with BasicSearch (Building Context):", i+1);
        found = BasicSearchCtxWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
        if (found == 0) {
            printf("Error1 searching for %s in text %s\n", needle[i], text[i]);
            return 0;
        }
        printf("Pattern length %d with Bs2BmSearch (Building Context):", i+1);
        found = Bs2bmCtxWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
        if (found == 0) {
            printf("Error2 searching for %s in text %s\n", needle[i], text[i]);
            return 0;
        }
        printf("Pattern length %d with BoyerMooreSearch (Building Context):", i+1);
        found = BoyerMooreCtxWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
        if (found == 0) {
            printf("Error3 searching for %s in text %s\n", needle[i], text[i]);
            return 0;
        }
        printf("\n");
    }
    return 1;
}
 
 
static int UtilSpmSearchStatsTest06(void)
{
    char *text[16];
    text[0]="zzzzkzzzzzzzkzzzzzza";
    text[1]="BBBBkBBBBBBBkBBBBBaB";
    text[2]="BcBckcBcBcBckcBcBcaBc";
    text[3]="BcDBkDBcDBcDkcDBcDaBcD";
    text[4]="BcDekcDeBcDekcDezzaBcDe";
 
    char *needle[16];
    needle[0]="a";
    needle[1]="aB";
    needle[2]="aBc";
    needle[3]="aBcD";
    needle[4]="aBcDe";
 
    int i;
    uint8_t *found = NULL;
        printf("\nStats for text of lower length (badcase for):\n");
    for (i = 0; i < 5; i++) {
        printf("Pattern length %d with BasicSearch (Building Context):", i+1);
        found = BasicSearchCtxWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
        if (found == 0) {
            printf("Error1 searching for %s in text %s\n", needle[i], text[i]);
            return 0;
        }
        printf("Pattern length %d with Bs2BmSearch (Building Context):", i+1);
        found = Bs2bmCtxWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
        if (found == 0) {
            printf("Error2 searching for %s in text %s\n", needle[i], text[i]);
            return 0;
        }
        printf("Pattern length %d with BoyerMooreSearch (Building Context):", i+1);
        found = BoyerMooreCtxWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
        if (found == 0) {
            printf("Error3 searching for %s in text %s\n", needle[i], text[i]);
            return 0;
        }
        printf("\n");
    }
    return 1;
}
 
static int UtilSpmSearchStatsTest07(void)
{
    char *text[16];
    text[0]="zzzza";
    text[1]="BBBaB";
    text[2]="bbaBc";
    text[3]="aaBcD";
    text[4]="aBcDe";
 
    char *needle[16];
    needle[0]="a";
    needle[1]="aB";
    needle[2]="aBc";
    needle[3]="aBcD";
    needle[4]="aBcDe";
 
    int i;
    uint8_t *found = NULL;
        printf("\nStats for text of real lower length (badcase for):\n");
    for (i = 0; i < 5; i++) {
        printf("Pattern length %d with BasicSearch (Building Context):", i+1);
        found = BasicSearchCtxWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
        if (found == 0) {
            printf("Error1 searching for %s in text %s\n", needle[i], text[i]);
            return 0;
        }
        printf("Pattern length %d with Bs2BmSearch (Building Context):", i+1);
        found = Bs2bmCtxWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
        if (found == 0) {
            printf("Error2 searching for %s in text %s\n", needle[i], text[i]);
            return 0;
        }
        printf("Pattern length %d with BoyerMooreSearch (Building Context):", i+1);
        found = BoyerMooreCtxWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
        if (found == 0) {
            printf("Error3 searching for %s in text %s\n", needle[i], text[i]);
            return 0;
        }
        printf("\n");
    }
    return 1;
}
 
/**
 * \test Give some stats for no case algorithms
 */
static int UtilSpmNocaseSearchStatsTest01(void)
{
    char *text[16];
    text[0]="zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzza";
    text[1]="zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzaB";
    text[2]="zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzaBc";
    text[3]="zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzaBcD";
    text[4]="zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzaBcDe";
    text[5]="zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzaBcDeF";
    text[6]="zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzaBcDeFg";
    text[7]="zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzaBcDeFgH";
    text[8]="zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzaBcDeFgHi";
    text[9]="zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzaBcDeFgHiJ";
    text[10]="zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzaBcDeFgHiJk";
    text[11]="zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzaBcDeFgHiJkL";
    text[12]="zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzaBcDeFgHiJkLm";
    text[13]="zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzaBcDeFgHiJkLmN";
    text[14]="zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzaBcDeFgHiJkLmNo";
    text[15]="zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzaBcDeFgHiJkLmNoP";
 
    char *needle[16];
    needle[0]="a";
    needle[1]="aB";
    needle[2]="aBc";
    needle[3]="aBcD";
    needle[4]="aBcDe";
    needle[5]="aBcDeF";
    needle[6]="aBcDeFg";
    needle[7]="aBcDeFgH";
    needle[8]="aBcDeFgHi";
    needle[9]="aBcDeFgHiJ";
    needle[10]="aBcDeFgHiJk";
    needle[11]="aBcDeFgHiJkL";
    needle[12]="aBcDeFgHiJkLm";
    needle[13]="aBcDeFgHiJkLmN";
    needle[14]="aBcDeFgHiJkLmNo";
    needle[15]="aBcDeFgHiJkLmNoP";
 
    int i;
    uint8_t *found = NULL;
        printf("\nStats for text of greater length:\n");
    for (i = 0; i < 16; i++) {
        printf("Pattern length %d with BasicSearch:", i+1);
        found = BasicSearchNocaseWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
        if (found == 0) {
            printf("Error1 searching for %s in text %s\n", needle[i], text[i]);
            return 0;
        }
        printf("Pattern length %d with Bs2BmSearch:", i+1);
        found = Bs2bmNocaseWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
        if (found == 0) {
            printf("Error2 searching for %s in text %s\n", needle[i], text[i]);
            return 0;
        }
        printf("Pattern length %d with BoyerMooreSearch:", i+1);
        found = BoyerMooreNocaseWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
        if (found == 0) {
            printf("Error3 searching for %s in text %s\n", needle[i], text[i]);
            return 0;
        }
        printf("\n");
    }
    return 1;
}
 
static int UtilSpmNocaseSearchStatsTest02(void)
{
    char *text[16];
    text[0]="zzzzzzzzzzzzzzzzzza";
    text[1]="zzzzzzzzzzzzzzzzzzaB";
    text[2]="zzzzzzzzzzzzzzzzzzaBc";
    text[3]="zzzzzzzzzzzzzzzzzzaBcD";
    text[4]="zzzzzzzzzzzzzzzzzzaBcDe";
    text[5]="zzzzzzzzzzzzzzzzzzzzaBcDeF";
    text[6]="zzzzzzzzzzzzzzzzzzzzaBcDeFg";
    text[7]="zzzzzzzzzzzzzzzzzzzzaBcDeFgH";
    text[8]="zzzzzzzzzzzzzzzzzzzzaBcDeFgHi";
    text[9]="zzzzzzzzzzzzzzzzzzzzaBcDeFgHiJ";
    text[10]="zzzzzzzzzzzzzzzzzzzzaBcDeFgHiJk";
    text[11]="zzzzzzzzzzzzzzzzzzzzaBcDeFgHiJkL";
    text[12]="zzzzzzzzzzzzzzzzzzzzaBcDeFgHiJkLm";
    text[13]="zzzzzzzzzzzzzzzzzzzzaBcDeFgHiJkLmN";
    text[14]="zzzzzzzzzzzzzzzzzzzzaBcDeFgHiJkLmNo";
    text[15]="zzzzzzzzzzzzzzzzzzzzaBcDeFgHiJkLmNoP";
 
    char *needle[16];
    needle[0]="a";
    needle[1]="aB";
    needle[2]="aBc";
    needle[3]="aBcD";
    needle[4]="aBcDe";
    needle[5]="aBcDeF";
    needle[6]="aBcDeFg";
    needle[7]="aBcDeFgH";
    needle[8]="aBcDeFgHi";
    needle[9]="aBcDeFgHiJ";
    needle[10]="aBcDeFgHiJk";
    needle[11]="aBcDeFgHiJkL";
    needle[12]="aBcDeFgHiJkLm";
    needle[13]="aBcDeFgHiJkLmN";
    needle[14]="aBcDeFgHiJkLmNo";
    needle[15]="aBcDeFgHiJkLmNoP";
 
    int i;
    uint8_t *found = NULL;
        printf("\nStats for text of lower length:\n");
    for (i = 0; i < 16; i++) {
        printf("Pattern length %d with BasicSearch:", i+1);
        found = BasicSearchNocaseWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
        if (found == 0) {
            printf("Error1 searching for %s in text %s\n", needle[i], text[i]);
            return 0;
        }
        printf("Pattern length %d with Bs2BmSearch:", i+1);
        found = Bs2bmNocaseWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
        if (found == 0) {
            printf("Error2 searching for %s in text %s\n", needle[i], text[i]);
            return 0;
        }
        printf("Pattern length %d with BoyerMooreSearch:", i+1);
        found = BoyerMooreNocaseWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
        if (found == 0) {
            printf("Error3 searching for %s in text %s\n", needle[i], text[i]);
            return 0;
        }
        printf("\n");
    }
    return 1;
}
 
 
static int UtilSpmNocaseSearchStatsTest03(void)
{
    char *text[16];
    text[0]="zzzzkzzzzzzzkzzzzzza";
    text[1]="BBBBkBBBBBBBkBBBBBaB";
    text[2]="BcBckcBcBcBckcBcBcaBc";
    text[3]="BcDBkDBcDBcDkcDBcDaBcD";
    text[4]="BcDekcDeBcDekcDezzaBcDe";
 
    char *needle[16];
    needle[0]="a";
    needle[1]="aB";
    needle[2]="aBc";
    needle[3]="aBcD";
    needle[4]="aBcDe";
 
    int i;
    uint8_t *found = NULL;
        printf("\nStats for text of lower length (badcase for):\n");
    for (i = 0; i < 5; i++) {
        printf("Pattern length %d with BasicSearch:", i+1);
        found = BasicSearchNocaseWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
        if (found == 0) {
            printf("Error1 searching for %s in text %s\n", needle[i], text[i]);
            return 0;
        }
        printf("Pattern length %d with Bs2BmSearch:", i+1);
        found = Bs2bmNocaseWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
        if (found == 0) {
            printf("Error2 searching for %s in text %s\n", needle[i], text[i]);
            return 0;
        }
        printf("Pattern length %d with BoyerMooreSearch:", i+1);
        found = BoyerMooreNocaseWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
        if (found == 0) {
            printf("Error3 searching for %s in text %s\n", needle[i], text[i]);
            return 0;
        }
        printf("\n");
    }
    return 1;
}
 
/**
 * \test Give some stats for no case algorithms
 */
static int UtilSpmNocaseSearchStatsTest04(void)
{
    char *text[16];
    text[0]="zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzza";
    text[1]="zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzaB";
    text[2]="zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzaBc";
    text[3]="zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzaBcD";
    text[4]="zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzaBcDe";
    text[5]="zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzaBcDeF";
    text[6]="zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzaBcDeFg";
    text[7]="zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzaBcDeFgH";
    text[8]="zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzaBcDeFgHi";
    text[9]="zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzaBcDeFgHiJ";
    text[10]="zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzaBcDeFgHiJk";
    text[11]="zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzaBcDeFgHiJkL";
    text[12]="zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzaBcDeFgHiJkLm";
    text[13]="zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzaBcDeFgHiJkLmN";
    text[14]="zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzaBcDeFgHiJkLmNo";
    text[15]="zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzaBcDeFgHiJkLmNoP";
 
    char *needle[16];
    needle[0]="a";
    needle[1]="aB";
    needle[2]="aBc";
    needle[3]="aBcD";
    needle[4]="aBcDe";
    needle[5]="aBcDeF";
    needle[6]="aBcDeFg";
    needle[7]="aBcDeFgH";
    needle[8]="aBcDeFgHi";
    needle[9]="aBcDeFgHiJ";
    needle[10]="aBcDeFgHiJk";
    needle[11]="aBcDeFgHiJkL";
    needle[12]="aBcDeFgHiJkLm";
    needle[13]="aBcDeFgHiJkLmN";
    needle[14]="aBcDeFgHiJkLmNo";
    needle[15]="aBcDeFgHiJkLmNoP";
 
    int i;
    uint8_t *found = NULL;
        printf("\nStats for text of greater length:\n");
    for (i = 0; i < 16; i++) {
        printf("Pattern length %d with BasicSearch (Building Context):", i+1);
        found = BasicSearchNocaseCtxWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
        if (found == 0) {
            printf("Error1 searching for %s in text %s\n", needle[i], text[i]);
            return 0;
        }
        printf("Pattern length %d with Bs2BmSearch (Building Context):", i+1);
        found = Bs2bmNocaseCtxWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
        if (found == 0) {
            printf("Error2 searching for %s in text %s\n", needle[i], text[i]);
            return 0;
        }
        printf("Pattern length %d with BoyerMooreSearch (Building Context):", i+1);
        found = BoyerMooreNocaseCtxWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
        if (found == 0) {
            printf("Error3 searching for %s in text %s\n", needle[i], text[i]);
            return 0;
        }
        printf("\n");
    }
    return 1;
}
 
static int UtilSpmNocaseSearchStatsTest05(void)
{
    char *text[16];
    text[0]="zzzzzzzzzzzzzzzzzza";
    text[1]="zzzzzzzzzzzzzzzzzzaB";
    text[2]="zzzzzzzzzzzzzzzzzzaBc";
    text[3]="zzzzzzzzzzzzzzzzzzaBcD";
    text[4]="zzzzzzzzzzzzzzzzzzaBcDe";
    text[5]="zzzzzzzzzzzzzzzzzzzzaBcDeF";
    text[6]="zzzzzzzzzzzzzzzzzzzzaBcDeFg";
    text[7]="zzzzzzzzzzzzzzzzzzzzaBcDeFgH";
    text[8]="zzzzzzzzzzzzzzzzzzzzaBcDeFgHi";
    text[9]="zzzzzzzzzzzzzzzzzzzzaBcDeFgHiJ";
    text[10]="zzzzzzzzzzzzzzzzzzzzaBcDeFgHiJk";
    text[11]="zzzzzzzzzzzzzzzzzzzzaBcDeFgHiJkL";
    text[12]="zzzzzzzzzzzzzzzzzzzzaBcDeFgHiJkLm";
    text[13]="zzzzzzzzzzzzzzzzzzzzaBcDeFgHiJkLmN";
    text[14]="zzzzzzzzzzzzzzzzzzzzaBcDeFgHiJkLmNo";
    text[15]="zzzzzzzzzzzzzzzzzzzzaBcDeFgHiJkLmNoP";
 
    char *needle[16];
    needle[0]="a";
    needle[1]="aB";
    needle[2]="aBc";
    needle[3]="aBcD";
    needle[4]="aBcDe";
    needle[5]="aBcDeF";
    needle[6]="aBcDeFg";
    needle[7]="aBcDeFgH";
    needle[8]="aBcDeFgHi";
    needle[9]="aBcDeFgHiJ";
    needle[10]="aBcDeFgHiJk";
    needle[11]="aBcDeFgHiJkL";
    needle[12]="aBcDeFgHiJkLm";
    needle[13]="aBcDeFgHiJkLmN";
    needle[14]="aBcDeFgHiJkLmNo";
    needle[15]="aBcDeFgHiJkLmNoP";
 
    int i;
    uint8_t *found = NULL;
        printf("\nStats for text of lower length:\n");
    for (i = 0; i < 16; i++) {
        printf("Pattern length %d with BasicSearch (Building Context):", i+1);
        found = BasicSearchNocaseCtxWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
        if (found == 0) {
            printf("Error1 searching for %s in text %s\n", needle[i], text[i]);
            return 0;
        }
        printf("Pattern length %d with Bs2BmSearch (Building Context):", i+1);
        found = Bs2bmNocaseCtxWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
        if (found == 0) {
            printf("Error2 searching for %s in text %s\n", needle[i], text[i]);
            return 0;
        }
        printf("Pattern length %d with BoyerMooreSearch (Building Context):", i+1);
        found = BoyerMooreNocaseCtxWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
        if (found == 0) {
            printf("Error3 searching for %s in text %s\n", needle[i], text[i]);
            return 0;
        }
        printf("\n");
    }
    return 1;
}
 
 
static int UtilSpmNocaseSearchStatsTest06(void)
{
    char *text[16];
    text[0]="zzzzkzzzzzzzkzzzzzza";
    text[1]="BBBBkBBBBBBBkBBBBBaB";
    text[2]="BcBckcBcBcBckcBcBcaBc";
    text[3]="BcDBkDBcDBcDkcDBcDaBcD";
    text[4]="BcDekcDeBcDekcDezzaBcDe";
 
    char *needle[16];
    needle[0]="a";
    needle[1]="aB";
    needle[2]="aBc";
    needle[3]="aBcD";
    needle[4]="aBcDe";
 
    int i;
    uint8_t *found = NULL;
        printf("\nStats for text of lower length (badcase for):\n");
    for (i = 0; i < 5; i++) {
        printf("Pattern length %d with BasicSearch (Building Context):", i+1);
        found = BasicSearchNocaseCtxWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
        if (found == 0) {
            printf("Error1 searching for %s in text %s\n", needle[i], text[i]);
            return 0;
        }
        printf("Pattern length %d with Bs2BmSearch (Building Context):", i+1);
        found = Bs2bmNocaseCtxWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
        if (found == 0) {
            printf("Error2 searching for %s in text %s\n", needle[i], text[i]);
            return 0;
        }
        printf("Pattern length %d with BoyerMooreSearch (Building Context):", i+1);
        found = BoyerMooreNocaseCtxWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
        if (found == 0) {
            printf("Error3 searching for %s in text %s\n", needle[i], text[i]);
            return 0;
        }
        printf("\n");
    }
    return 1;
}
 
static int UtilSpmNocaseSearchStatsTest07(void)
{
    char *text[16];
    text[0]="zzzza";
    text[1]="bbbAb";
    text[2]="bbAbC";
    text[3]="bAbCd";
    text[4]="AbCdE";
 
    char *needle[16];
    needle[0]="a";
    needle[1]="aB";
    needle[2]="aBc";
    needle[3]="aBcD";
    needle[4]="aBcDe";
 
    int i;
    uint8_t *found = NULL;
        printf("\nStats for text of real lower length (badcase for):\n");
    for (i = 0; i < 5; i++) {
        printf("Pattern length %d with BasicSearch (Building Context):", i+1);
        found = BasicSearchNocaseCtxWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
        if (found == 0) {
            printf("Error1 searching for %s in text %s\n", needle[i], text[i]);
            return 0;
        }
        printf("Pattern length %d with Bs2BmSearch (Building Context):", i+1);
        found = Bs2bmNocaseCtxWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
        if (found == 0) {
            printf("Error2 searching for %s in text %s\n", needle[i], text[i]);
            return 0;
        }
        printf("Pattern length %d with BoyerMooreSearch (Building Context):", i+1);
        found = BoyerMooreNocaseCtxWrapper((uint8_t *)text[i], (uint8_t *)needle[i], STATS_TIMES);
        if (found == 0) {
            printf("Error3 searching for %s in text %s\n", needle[i], text[i]);
            return 0;
        }
        printf("\n");
    }
    return 1;
}
#endif
 
/* Unit tests for new SPM API. */
 
#define SPM_NO_MATCH UINT32_MAX
 
/* Helper structure describing a particular search. */
typedef struct SpmTestData_ {
    const char *needle;
    uint16_t needle_len;
    const char *haystack;
    uint16_t haystack_len;
    int nocase;
    uint32_t match_offset; /* offset in haystack, or SPM_NO_MATCH. */
} SpmTestData;
 
/* Helper function to conduct a search with a particular SPM matcher. */
static int SpmTestSearch(const SpmTestData *d, uint8_t matcher)
{
    int ret = 1;
    SpmGlobalThreadCtx *global_thread_ctx = NULL;
    SpmThreadCtx *thread_ctx = NULL;
    SpmCtx *ctx = NULL;
    uint8_t *found = NULL;
 
    global_thread_ctx = SpmInitGlobalThreadCtx(matcher);
    if (global_thread_ctx == NULL) {
        ret = 0;
        goto exit;
    }
 
    ctx = SpmInitCtx((const uint8_t *)d->needle, d->needle_len, d->nocase,
                     global_thread_ctx);
    if (ctx == NULL) {
        ret = 0;
        goto exit;
    }
 
    thread_ctx = SpmMakeThreadCtx(global_thread_ctx);
    if (thread_ctx == NULL) {
        ret = 0;
        goto exit;
    }
 
    found = SpmScan(ctx, thread_ctx, (const uint8_t *)d->haystack,
                    d->haystack_len);
    if (found == NULL) {
        if (d->match_offset != SPM_NO_MATCH) {
            printf("  should have matched at %" PRIu32 " but didn't\n",
                   d->match_offset);
            ret = 0;
        }
    } else {
        uint32_t offset = (uint32_t)(found - (const uint8_t *)d->haystack);
        if (offset != d->match_offset) {
            printf("  should have matched at %" PRIu32
                   " but matched at %" PRIu32 "\n",
                   d->match_offset, offset);
            ret = 0;
        }
    }
 
exit:
    SpmDestroyCtx(ctx);
    SpmDestroyThreadCtx(thread_ctx);
    SpmDestroyGlobalThreadCtx(global_thread_ctx);
    return ret;
}
 
static int SpmSearchTest01(void) {
    SpmTableSetup();
    printf("\n");
 
    /* Each of the following tests will be run against every registered SPM
     * algorithm. */
 
    static const SpmTestData data[] = {
        /* Some trivial single-character case/nocase tests */
        {"a", 1, "a", 1, 0, 0},
        {"a", 1, "A", 1, 1, 0},
        {"A", 1, "A", 1, 0, 0},
        {"A", 1, "a", 1, 1, 0},
        {"a", 1, "A", 1, 0, SPM_NO_MATCH},
        {"A", 1, "a", 1, 0, SPM_NO_MATCH},
        /* Nulls and odd characters */
        {"\x00", 1, "test\x00test", 9, 0, 4},
        {"\x00", 1, "testtest", 8, 0, SPM_NO_MATCH},
        {"\n", 1, "new line\n", 9, 0, 8},
        {"\n", 1, "new line\x00\n", 10, 0, 9},
        {"\xff", 1, "abcdef\xff", 7, 0, 6},
        {"\xff", 1, "abcdef\xff", 7, 1, 6},
        {"$", 1, "dollar$", 7, 0, 6},
        {"^", 1, "caret^", 6, 0, 5},
        /* Longer literals */
        {"Suricata", 8, "This is a Suricata test", 23, 0, 10},
        {"Suricata", 8, "This is a suricata test", 23, 1, 10},
        {"Suricata", 8, "This is a suriCATA test", 23, 1, 10},
        {"suricata", 8, "This is a Suricata test", 23, 0, SPM_NO_MATCH},
        {"Suricata", 8, "This is a Suricat_ test", 23, 0, SPM_NO_MATCH},
        {"Suricata", 8, "This is a _uricata test", 23, 0, SPM_NO_MATCH},
        /* First occurrence with the correct case should match */
        {"foo", 3, "foofoofoo", 9, 0, 0},
        {"foo", 3, "_foofoofoo", 9, 0, 1},
        {"FOO", 3, "foofoofoo", 9, 1, 0},
        {"FOO", 3, "_foofoofoo", 9, 1, 1},
        {"FOO", 3, "foo Foo FOo fOo foO FOO", 23, 0, 20},
        {"foo", 3, "Foo FOo fOo foO FOO foo", 23, 0, 20},
    };
 
    for (uint8_t matcher = 0; matcher < SPM_TABLE_SIZE; matcher++) {
        const SpmTableElmt *m = &spm_table[matcher];
        if (m->name == NULL) {
            continue;
        }
        for (uint32_t i = 0; i < sizeof(data) / sizeof(data[0]); i++) {
            const SpmTestData *d = &data[i];
            FAIL_IF(SpmTestSearch(d, matcher) == 0);
        }
    }
 
    PASS;
}
 
static int SpmSearchTest02(void) {
    SpmTableSetup();
    printf("\n");
 
    /* Test that we can find needles of various lengths at various alignments
     * in the haystack. Note that these are passed to strlen. */
 
    static const char* needles[] = {
        /* Single bytes */
        "a", "b", "c", ":", "/", "\x7f", "\xff",
        /* Repeats */
        "aa", "aaa", "aaaaaaaaaaaaaaaaaaaaaaa",
        /* Longer literals */
        "suricata", "meerkat", "aardvark", "raptor", "marmot", "lemming",
        /* Mixed case */
        "Suricata", "CAPS LOCK", "mIxEd cAsE",
    };
 
    int ret = 1;
 
    uint8_t matcher;
    for (matcher = 0; matcher < SPM_TABLE_SIZE; matcher++) {
        const SpmTableElmt *m = &spm_table[matcher];
        if (m->name == NULL) {
            continue;
        }
        printf("matcher: %s\n", m->name);
 
        SpmTestData d;
 
        uint32_t i;
        for (i = 0; i < sizeof(needles) / sizeof(needles[0]); i++) {
            const char *needle = needles[i];
            uint16_t prefix;
            for (prefix = 0; prefix < 32; prefix++) {
                d.needle = needle;
                d.needle_len = (uint16_t)strlen(needle);
                uint16_t haystack_len = prefix + d.needle_len;
                char *haystack = SCMalloc(haystack_len);
                if (haystack == NULL) {
                    printf("alloc failure\n");
                    return 0;
                }
                memset(haystack, ' ', haystack_len);
                memcpy(haystack + prefix, d.needle, d.needle_len);
                d.haystack = haystack;
                d.haystack_len = haystack_len;
                d.nocase = 0;
                d.match_offset = prefix;
 
                /* Case-sensitive scan */
                if (SpmTestSearch(&d, matcher) == 0) {
                    printf("  test %" PRIu32 ": fail (case-sensitive)\n", i);
                    ret = 0;
                }
 
                /* Case-insensitive scan */
                d.nocase = 1;
                uint16_t j;
                for (j = 0; j < haystack_len; j++) {
                    haystack[j] = u8_toupper(haystack[j]);
                }
                if (SpmTestSearch(&d, matcher) == 0) {
                    printf("  test %" PRIu32 ": fail (case-insensitive)\n", i);
                    ret = 0;
                }
 
                SCFree(haystack);
            }
        }
        printf("  %" PRIu32 " tests passed\n", i);
    }
 
    return ret;
}
 
/* Register unittests */
void UtilSpmSearchRegistertests(void)
{
    /* Generic tests */
    UtRegisterTest("UtilSpmBasicSearchTest01", UtilSpmBasicSearchTest01);
    UtRegisterTest("UtilSpmBasicSearchNocaseTest01",
                   UtilSpmBasicSearchNocaseTest01);
 
    UtRegisterTest("UtilSpmBs2bmSearchTest01", UtilSpmBs2bmSearchTest01);
    UtRegisterTest("UtilSpmBs2bmSearchNocaseTest01",
                   UtilSpmBs2bmSearchNocaseTest01);
 
    UtRegisterTest("UtilSpmBoyerMooreSearchTest01",
                   UtilSpmBoyerMooreSearchTest01);
    UtRegisterTest("UtilSpmBoyerMooreSearchNocaseTest01",
                   UtilSpmBoyerMooreSearchNocaseTest01);
    UtRegisterTest("UtilSpmBoyerMooreSearchNocaseTestIssue130",
                   UtilSpmBoyerMooreSearchNocaseTestIssue130);
 
    UtRegisterTest("UtilSpmBs2bmSearchTest02", UtilSpmBs2bmSearchTest02);
    UtRegisterTest("UtilSpmBs2bmSearchNocaseTest02",
                   UtilSpmBs2bmSearchNocaseTest02);
 
    UtRegisterTest("UtilSpmBasicSearchTest02", UtilSpmBasicSearchTest02);
    UtRegisterTest("UtilSpmBasicSearchNocaseTest02",
                   UtilSpmBasicSearchNocaseTest02);
 
    UtRegisterTest("UtilSpmBoyerMooreSearchTest02",
                   UtilSpmBoyerMooreSearchTest02);
    UtRegisterTest("UtilSpmBoyerMooreSearchNocaseTest02",
                   UtilSpmBoyerMooreSearchNocaseTest02);
 
    /* test matches at any offset */
    UtRegisterTest("UtilSpmSearchOffsetsTest01", UtilSpmSearchOffsetsTest01);
    UtRegisterTest("UtilSpmSearchOffsetsNocaseTest01",
                   UtilSpmSearchOffsetsNocaseTest01);
 
    /* new SPM API */
    UtRegisterTest("SpmSearchTest01", SpmSearchTest01);
    UtRegisterTest("SpmSearchTest02", SpmSearchTest02);
 
#ifdef ENABLE_SEARCH_STATS
    /* Give some stats searching given a prepared context (look at the wrappers) */
    UtRegisterTest("UtilSpmSearchStatsTest01", UtilSpmSearchStatsTest01);
    UtRegisterTest("UtilSpmSearchStatsTest02", UtilSpmSearchStatsTest02);
    UtRegisterTest("UtilSpmSearchStatsTest03", UtilSpmSearchStatsTest03);
 
    UtRegisterTest("UtilSpmNocaseSearchStatsTest01",
                   UtilSpmNocaseSearchStatsTest01);
    UtRegisterTest("UtilSpmNocaseSearchStatsTest02",
                   UtilSpmNocaseSearchStatsTest02);
    UtRegisterTest("UtilSpmNocaseSearchStatsTest03",
                   UtilSpmNocaseSearchStatsTest03);
 
    /* Stats building context and searching */
    UtRegisterTest("UtilSpmSearchStatsTest04", UtilSpmSearchStatsTest04);
    UtRegisterTest("UtilSpmSearchStatsTest05", UtilSpmSearchStatsTest05);
    UtRegisterTest("UtilSpmSearchStatsTest06", UtilSpmSearchStatsTest06);
    UtRegisterTest("UtilSpmSearchStatsTest07", UtilSpmSearchStatsTest07);
 
    UtRegisterTest("UtilSpmNocaseSearchStatsTest04",
                   UtilSpmNocaseSearchStatsTest04);
    UtRegisterTest("UtilSpmNocaseSearchStatsTest05",
                   UtilSpmNocaseSearchStatsTest05);
    UtRegisterTest("UtilSpmNocaseSearchStatsTest06",
                   UtilSpmNocaseSearchStatsTest06);
    UtRegisterTest("UtilSpmNocaseSearchStatsTest07",
                   UtilSpmNocaseSearchStatsTest07);
 
#endif
}
#endif