mirror of https://github.com/OISF/suricata
You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2749 lines
126 KiB
C
2749 lines
126 KiB
C
/* Copyright (C) 2007-2014 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 "suricata.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-clock.h"
|
|
#ifdef BUILD_HYPERSCAN
|
|
#include "hs.h"
|
|
#endif
|
|
|
|
SpmTableElmt spm_table[SPM_TABLE_SIZE];
|
|
|
|
/**
|
|
* \brief Returns the single pattern matcher algorithm to be used, based on the
|
|
* spm-algo setting in yaml.
|
|
*/
|
|
uint16_t SinglePatternMatchDefaultMatcher(void)
|
|
{
|
|
const char *spm_algo;
|
|
if ((ConfGet("spm-algo", &spm_algo)) == 1) {
|
|
if (spm_algo != NULL) {
|
|
if (strcmp("auto", spm_algo) == 0) {
|
|
goto default_matcher;
|
|
}
|
|
for (uint16_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(SC_ERR_INVALID_VALUE, "Hyperscan (hs) support for spm-algo is "
|
|
"not compiled into Suricata.");
|
|
}
|
|
#endif
|
|
SCLogError(SC_ERR_INVALID_YAML_CONF_ENTRY,
|
|
"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. */
|
|
#ifdef 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
|
|
#else
|
|
/* Otherwise, default to Boyer-Moore */
|
|
return SPM_BM;
|
|
#endif
|
|
}
|
|
|
|
void SpmTableSetup(void)
|
|
{
|
|
memset(spm_table, 0, sizeof(spm_table));
|
|
|
|
SpmBMRegister();
|
|
#ifdef BUILD_HYPERSCAN
|
|
#ifdef HAVE_HS_VALID_PLATFORM
|
|
if (hs_valid_platform() == HS_SUCCESS) {
|
|
SpmHSRegister();
|
|
}
|
|
#else
|
|
SpmHSRegister();
|
|
#endif
|
|
#endif
|
|
}
|
|
|
|
SpmGlobalThreadCtx *SpmInitGlobalThreadCtx(uint16_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;
|
|
}
|
|
uint16_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;
|
|
}
|
|
uint16_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;
|
|
}
|
|
uint16_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);
|
|
uint16_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;
|
|
}
|
|
uint16_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)
|
|
{
|
|
uint16_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 the Bs2Bm nocase 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 *Bs2bmNocaseSearch(const uint8_t *text, uint32_t textlen,
|
|
const uint8_t *needle, uint16_t needlelen)
|
|
{
|
|
uint8_t badchars[ALPHABET_SIZE];
|
|
Bs2BmBadchars(needle, needlelen, badchars);
|
|
|
|
return Bs2BmNocase(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
|
|
*/
|
|
|
|
/* 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 *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
|
|
/**
|
|
* \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, uint16_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},
|
|
};
|
|
|
|
int ret = 1;
|
|
|
|
uint16_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);
|
|
|
|
uint32_t i;
|
|
for (i = 0; i < sizeof(data)/sizeof(data[0]); i++) {
|
|
const SpmTestData *d = &data[i];
|
|
if (SpmTestSearch(d, matcher) == 0) {
|
|
printf(" test %" PRIu32 ": fail\n", i);
|
|
ret = 0;
|
|
}
|
|
}
|
|
printf(" %" PRIu32 " tests passed\n", i);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
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;
|
|
|
|
uint16_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;
|
|
}
|
|
|
|
#endif
|
|
|
|
/* Register unittests */
|
|
void UtilSpmSearchRegistertests(void)
|
|
{
|
|
#ifdef UNITTESTS
|
|
/* 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
|
|
}
|