github_mirrors/vectorscan
3
0
Fork 1
mirror of https://github.com/VectorCamp/vectorscan.git synced 2025-09-29 11:16:29 +03:00
Code Issues Packages Projects Releases Wiki Activity

literal matchers: change context passed to callback to scratch

Browse Source
This commit is contained in:
Wang, Xiang W
2017-07-04 12:24:11 -04:00
committed by Matthew Barr
parent bc232d272f
commit 67a8f43355
17 changed files with 203 additions and 188 deletions
Download Patch File Download Diff File Expand all files Collapse all files

98
unit/internal/fdr.cpp
View File

@@ -39,6 +39,7 @@
#include "util/alloc.h"
#include "database.h"
#include "scratch.h"
#include "gtest/gtest.h"
#include <algorithm>
@@ -85,28 +86,23 @@ struct match {
}
};
vector<match> matches;
extern "C" {
static
hwlmcb_rv_t decentCallback(size_t end, u32 id, void *ctxt) {
hwlmcb_rv_t decentCallback(size_t end, u32 id,
UNUSED struct hs_scratch *scratch) {
DEBUG_PRINTF("match @%zu : %u\n", end, id);
if (!ctxt) {
return HWLM_CONTINUE_MATCHING;
}
vector<match> *out = (vector<match> *)ctxt;
out->push_back(match(end, id));
matches.push_back(match(end, id));
return HWLM_CONTINUE_MATCHING;
}
static
hwlmcb_rv_t decentCallbackT(size_t end, u32 id, void *ctxt) {
if (!ctxt) {
return HWLM_TERMINATE_MATCHING;
}
vector<match> *out = (vector<match> *)ctxt;
out->push_back(match(end, id));
hwlmcb_rv_t decentCallbackT(size_t end, u32 id,
UNUSED struct hs_scratch *scratch) {
matches.push_back(match(end, id));
return HWLM_TERMINATE_MATCHING;
}
@@ -154,14 +150,15 @@ TEST_P(FDRp, Simple) {
auto fdr = fdrBuildTableHinted(lits, false, hint, get_current_target(), Grey());
CHECK_WITH_TEDDY_OK_TO_FAIL(fdr, hint);
vector<match> matches;
struct hs_scratch scratch;
fdrExec(fdr.get(), (const u8 *)data, sizeof(data), 0, decentCallback,
&matches, HWLM_ALL_GROUPS);
&scratch, HWLM_ALL_GROUPS);
ASSERT_EQ(3U, matches.size());
EXPECT_EQ(match(5, 0), matches[0]);
EXPECT_EQ(match(23, 0), matches[1]);
EXPECT_EQ(match(83, 0), matches[2]);
matches.clear();
}
TEST_P(FDRp, SimpleSingle) {
@@ -176,15 +173,16 @@ TEST_P(FDRp, SimpleSingle) {
auto fdr = fdrBuildTableHinted(lits, false, hint, get_current_target(), Grey());
CHECK_WITH_TEDDY_OK_TO_FAIL(fdr, hint);
vector<match> matches;
struct hs_scratch scratch;
fdrExec(fdr.get(), (const u8 *)data, sizeof(data) - 1 /* skip nul */, 0,
decentCallback, &matches, HWLM_ALL_GROUPS);
decentCallback, &scratch, HWLM_ALL_GROUPS);
ASSERT_EQ(4U, matches.size());
EXPECT_EQ(match(0, 0), matches[0]);
EXPECT_EQ(match(18, 0), matches[1]);
EXPECT_EQ(match(78, 0), matches[2]);
EXPECT_EQ(match(80, 0), matches[3]);
matches.clear();
}
TEST_P(FDRp, MultiLocation) {
@@ -201,14 +199,15 @@ TEST_P(FDRp, MultiLocation) {
vector<u8> data(testSize, 0);
struct hs_scratch scratch;
for (u32 i = 0; i < testSize - 3; i++) {
memcpy(data.data() + i, "abc", 3);
vector<match> matches;
fdrExec(fdr.get(), data.data(), testSize, 0, decentCallback, &matches,
fdrExec(fdr.get(), data.data(), testSize, 0, decentCallback, &scratch,
HWLM_ALL_GROUPS);
ASSERT_EQ(1U, matches.size());
EXPECT_EQ(match(i + 2, 1), matches[0]);
memset(data.data() + i, 0, 3);
matches.clear();
}
}
@@ -224,12 +223,13 @@ TEST_P(FDRp, NoRepeat1) {
auto fdr = fdrBuildTableHinted(lits, false, hint, get_current_target(), Grey());
CHECK_WITH_TEDDY_OK_TO_FAIL(fdr, hint);
vector<match> matches;
struct hs_scratch scratch;
fdrExec(fdr.get(), (const u8 *)data, sizeof(data) - 1 /* skip nul */, 0,
decentCallback, &matches, HWLM_ALL_GROUPS);
decentCallback, &scratch, HWLM_ALL_GROUPS);
ASSERT_EQ(1U, matches.size());
EXPECT_EQ(match(0, 0), matches[0]);
matches.clear();
}
TEST_P(FDRp, NoRepeat2) {
@@ -245,13 +245,14 @@ TEST_P(FDRp, NoRepeat2) {
auto fdr = fdrBuildTableHinted(lits, false, hint, get_current_target(), Grey());
CHECK_WITH_TEDDY_OK_TO_FAIL(fdr, hint);
vector<match> matches;
struct hs_scratch scratch;
fdrExec(fdr.get(), (const u8 *)data, sizeof(data) - 1 /* skip nul */, 0,
decentCallback, &matches, HWLM_ALL_GROUPS);
decentCallback, &scratch, HWLM_ALL_GROUPS);
ASSERT_EQ(3U, matches.size());
EXPECT_EQ(match(0, 0), matches[0]);
EXPECT_EQ(match(78, 0), matches[2]);
matches.clear();
}
TEST_P(FDRp, NoRepeat3) {
@@ -267,12 +268,13 @@ TEST_P(FDRp, NoRepeat3) {
auto fdr = fdrBuildTableHinted(lits, false, hint, get_current_target(), Grey());
CHECK_WITH_TEDDY_OK_TO_FAIL(fdr, hint);
vector<match> matches;
struct hs_scratch scratch;
fdrExec(fdr.get(), (const u8 *)data, sizeof(data) - 1 /* skip nul */, 0,
decentCallback, &matches, HWLM_ALL_GROUPS);
decentCallback, &scratch, HWLM_ALL_GROUPS);
ASSERT_EQ(1U, matches.size());
EXPECT_EQ(match(32, 0), matches[0]);
matches.clear();
}
/**
@@ -282,8 +284,7 @@ TEST_P(FDRp, NoRepeat3) {
static
hwlm_error_t safeExecStreaming(const FDR *fdr, const u8 *hbuf, size_t hlen,
const u8 *buf, size_t len, size_t start,
HWLMCallback cb, void *ctxt,
hwlm_group_t groups) {
HWLMCallback cb, hwlm_group_t groups) {
array<u8, 16> wrapped_history = {{'0', '1', '2', '3', '4', '5', '6', '7',
'8', '9', 'a', 'b', 'c', 'd', 'e', 'f'}};
if (hlen < 16) {
@@ -291,7 +292,9 @@ hwlm_error_t safeExecStreaming(const FDR *fdr, const u8 *hbuf, size_t hlen,
memcpy(new_hbuf, hbuf, hlen);
hbuf = new_hbuf;
}
return fdrExecStreaming(fdr, hbuf, hlen, buf, len, start, cb, ctxt, groups);
struct hs_scratch scratch;
return fdrExecStreaming(fdr, hbuf, hlen, buf, len, start, cb, &scratch,
groups);
}
TEST_P(FDRp, SmallStreaming) {
@@ -304,13 +307,13 @@ TEST_P(FDRp, SmallStreaming) {
auto fdr = fdrBuildTableHinted(lits, false, hint, get_current_target(), Grey());
CHECK_WITH_TEDDY_OK_TO_FAIL(fdr, hint);
vector<match> expected, matches;
vector<match> expected;
expected.push_back(match(0, 1));
expected.push_back(match(1, 1));
expected.push_back(match(2, 1));
safeExecStreaming(fdr.get(), (const u8 *)"", 0, (const u8 *)"aaar", 4, 0,
decentCallback, &matches, HWLM_ALL_GROUPS);
decentCallback, HWLM_ALL_GROUPS);
for (u32 i = 0; i < MIN(expected.size(), matches.size()); i++) {
EXPECT_EQ(expected[i], matches[i]);
}
@@ -322,12 +325,13 @@ TEST_P(FDRp, SmallStreaming) {
expected.push_back(match(8, 10));
safeExecStreaming(fdr.get(), (const u8 *)"aaar", 4, (const u8 *)"dvark", 5,
0, decentCallback, &matches, HWLM_ALL_GROUPS);
0, decentCallback, HWLM_ALL_GROUPS);
for (u32 i = 0; i < MIN(expected.size(), matches.size()); i++) {
EXPECT_EQ(expected[i], matches[i] + 4);
}
ASSERT_EQ(expected.size(), matches.size());
matches.clear();
}
TEST_P(FDRp, SmallStreaming2) {
@@ -341,7 +345,7 @@ TEST_P(FDRp, SmallStreaming2) {
auto fdr = fdrBuildTableHinted(lits, false, hint, get_current_target(), Grey());
CHECK_WITH_TEDDY_OK_TO_FAIL(fdr, hint);
vector<match> expected, matches;
vector<match> expected;
expected.push_back(match(6,1));
expected.push_back(match(7,1));
expected.push_back(match(11,1));
@@ -350,13 +354,14 @@ TEST_P(FDRp, SmallStreaming2) {
expected.push_back(match(15,2));
safeExecStreaming(fdr.get(), (const u8 *)"foobar", 6,
(const u8 *)"aardvarkkk", 10, 0, decentCallback, &matches,
(const u8 *)"aardvarkkk", 10, 0, decentCallback,
HWLM_ALL_GROUPS);
for (u32 i = 0; i < MIN(expected.size(), matches.size()); i++) {
EXPECT_EQ(expected[i], matches[i] + 6);
}
ASSERT_EQ(expected.size(), matches.size());
matches.clear();
}
TEST_P(FDRp, moveByteStream) {
@@ -384,15 +389,16 @@ TEST_P(FDRp, moveByteStream) {
}
// check matches
vector<match> matches;
struct hs_scratch scratch;
hwlm_error_t fdrStatus = fdrExec(fdrTable.get(), (const u8 *)data,
data_len, 0, decentCallback, &matches,
data_len, 0, decentCallback, &scratch,
HWLM_ALL_GROUPS);
ASSERT_EQ(0, fdrStatus);
ASSERT_EQ(1U, matches.size());
EXPECT_EQ(match(17, 0), matches[0]);
matches.clear();
}
TEST_P(FDRp, Stream1) {
@@ -412,17 +418,17 @@ TEST_P(FDRp, Stream1) {
CHECK_WITH_TEDDY_OK_TO_FAIL(fdr, hint);
// check matches
vector<match> matches;
fdrStatus = safeExecStreaming(fdr.get(), (const u8 *)data1, data_len1,
(const u8 *)data2, data_len2, 0,
decentCallback, &matches, HWLM_ALL_GROUPS);
decentCallback, HWLM_ALL_GROUPS);
ASSERT_EQ(0, fdrStatus);
ASSERT_EQ(4U, matches.size());
for (size_t i = 0; i < matches.size(); i++) {
EXPECT_EQ(match(i, 0), matches[i]);
}
matches.clear();
}
INSTANTIATE_TEST_CASE_P(FDR, FDRp, ValuesIn(getValidFdrEngines()));
@@ -463,6 +469,7 @@ TEST_P(FDRpp, AlignAndTooEarly) {
aligned_free_internal);
vector<hwlmLiteral> lits;
struct hs_scratch scratch;
for (size_t litLen = 1; litLen <= patLen; litLen++) {
// building literal from pattern substring of variable length 1-patLen
@@ -482,11 +489,10 @@ TEST_P(FDRpp, AlignAndTooEarly) {
pattern.data(), litLen);
for (size_t j = 0; j <= litLen; j++) {
vector<match> matches;
hwlm_error_t fdrStatus = fdrExec(fdr.get(),
(const u8 *)dataBufAligned.get() + i + j,
4 * buf_alignment - j * 2, 0, decentCallback,
&matches, HWLM_ALL_GROUPS);
&scratch, HWLM_ALL_GROUPS);
ASSERT_EQ(0, fdrStatus);
// j == 0 means that start and end matches are entirely within
// searched buffer. Otherwise they are out of buffer boundaries
@@ -585,6 +591,7 @@ TEST_P(FDRpa, ShortWritings) {
}
// run the literal matching through all generated literals
struct hs_scratch scratch;
for (size_t patIdx = 0; patIdx < pats.size();) {
// group them in the sets of 32
vector<hwlmLiteral> testSigs;
@@ -603,9 +610,8 @@ TEST_P(FDRpa, ShortWritings) {
const string &buf = bufs[bufIdx];
size_t bufLen = buf.size();
vector<match> matches;
hwlm_error_t fdrStatus = fdrExec(fdr.get(), (const u8 *)buf.data(),
bufLen, 0, decentCallback, &matches, HWLM_ALL_GROUPS);
bufLen, 0, decentCallback, &scratch, HWLM_ALL_GROUPS);
ASSERT_EQ(0, fdrStatus);
// build the set of expected matches using standard
@@ -627,6 +633,7 @@ TEST_P(FDRpa, ShortWritings) {
sort(expMatches.begin(), expMatches.end());
sort(matches.begin(), matches.end());
ASSERT_EQ(expMatches, matches);
matches.clear();
}
}
}
@@ -656,14 +663,14 @@ TEST(FDR, FDRTermS) {
ASSERT_TRUE(fdr != nullptr);
// check matches
vector<match> matches;
fdrStatus = safeExecStreaming(fdr.get(), (const u8 *)data1, data_len1,
(const u8 *)data2, data_len2, 0,
decentCallbackT, &matches, HWLM_ALL_GROUPS);
decentCallbackT, HWLM_ALL_GROUPS);
ASSERT_EQ(HWLM_TERMINATED, fdrStatus);
ASSERT_EQ(1U, matches.size());
matches.clear();
}
TEST(FDR, FDRTermB) {
@@ -679,11 +686,12 @@ TEST(FDR, FDRTermB) {
ASSERT_TRUE(fdr != nullptr);
// check matches
vector<match> matches;
struct hs_scratch scratch;
fdrStatus = fdrExec(fdr.get(), (const u8 *)data1, data_len1,
0, decentCallbackT, &matches, HWLM_ALL_GROUPS);
0, decentCallbackT, &scratch, HWLM_ALL_GROUPS);
ASSERT_EQ(HWLM_TERMINATED, fdrStatus);
ASSERT_EQ(1U, matches.size());
matches.clear();
}

38
unit/internal/fdr_flood.cpp
View File

@@ -36,6 +36,7 @@
#include "fdr/fdr_engine_description.h"
#include "fdr/teddy_compile.h"
#include "fdr/teddy_engine_description.h"
#include "scratch.h"
#include "util/alloc.h"
#include "util/bitutils.h"
@@ -94,13 +95,13 @@ T &operator<<(T &a, const vector<match> &b) {
return a;
}
map<u32, int> matchesCounts;
extern "C" {
static hwlmcb_rv_t countCallback(UNUSED size_t end, u32 id, void *cntxt) {
if (cntxt) {
map<u32, int> *matchesCounts = (map<u32, int> *)cntxt;
(*matchesCounts)[id]++;
}
static hwlmcb_rv_t countCallback(UNUSED size_t end, u32 id,
UNUSED struct hs_scratch *scratch) {
matchesCounts[id]++;
return HWLM_CONTINUE_MATCHING;
}
@@ -140,6 +141,7 @@ TEST_P(FDRFloodp, NoMask) {
vector<u8> data(dataSize);
u8 c = 0;
struct hs_scratch scratch;
while (1) {
SCOPED_TRACE((unsigned int)c);
u8 bit = 1 << (c & 0x7);
@@ -171,10 +173,8 @@ TEST_P(FDRFloodp, NoMask) {
Grey());
CHECK_WITH_TEDDY_OK_TO_FAIL(fdr, hint);
map<u32, int> matchesCounts;
hwlm_error_t fdrStatus = fdrExec(fdr.get(), &data[0], dataSize,
0, countCallback, (void *)&matchesCounts, HWLM_ALL_GROUPS);
0, countCallback, &scratch, HWLM_ALL_GROUPS);
ASSERT_EQ(0, fdrStatus);
for (u8 i = 0; i < 4; i++) {
@@ -199,7 +199,7 @@ TEST_P(FDRFloodp, NoMask) {
matchesCounts.clear();
memset(&data[0], cAlt, dataSize);
fdrStatus = fdrExec(fdr.get(), &data[0], dataSize,
0, countCallback, (void *)&matchesCounts, HWLM_ALL_GROUPS);
0, countCallback, &scratch, HWLM_ALL_GROUPS);
ASSERT_EQ(0, fdrStatus);
for (u8 i = 0; i < 4; i++) {
@@ -219,6 +219,7 @@ TEST_P(FDRFloodp, NoMask) {
ASSERT_EQ(0, matchesCounts[i * 8 + 6]);
}
}
matchesCounts.clear();
if (++c == 0) {
break;
@@ -233,6 +234,7 @@ TEST_P(FDRFloodp, WithMask) {
vector<u8> data(dataSize);
u8 c = '\0';
struct hs_scratch scratch;
while (1) {
u8 bit = 1 << (c & 0x7);
u8 cAlt = c ^ bit;
@@ -307,10 +309,8 @@ TEST_P(FDRFloodp, WithMask) {
Grey());
CHECK_WITH_TEDDY_OK_TO_FAIL(fdr, hint);
map <u32, int> matchesCounts;
hwlm_error_t fdrStatus = fdrExec(fdr.get(), &data[0], dataSize,
0, countCallback, &matchesCounts, HWLM_ALL_GROUPS);
0, countCallback, &scratch, HWLM_ALL_GROUPS);
ASSERT_EQ(0, fdrStatus);
const u32 cnt4 = dataSize - 4 + 1;
@@ -348,7 +348,7 @@ TEST_P(FDRFloodp, WithMask) {
memset(&data[0], cAlt, dataSize);
matchesCounts.clear();
fdrStatus = fdrExec(fdr.get(), &data[0], dataSize,
0, countCallback, &matchesCounts, HWLM_ALL_GROUPS);
0, countCallback, &scratch, HWLM_ALL_GROUPS);
ASSERT_EQ(0, fdrStatus);
for (u8 i = 0; i < 4; i++) {
@@ -381,6 +381,7 @@ TEST_P(FDRFloodp, WithMask) {
ASSERT_EQ(0, matchesCounts[i * 12 + 11]);
}
}
matchesCounts.clear();
if (++c == '\0') {
break;
@@ -398,6 +399,7 @@ TEST_P(FDRFloodp, StreamingMask) {
vector<u8> tempdata(dataSize + fake_history_size); // headroom
u8 c = '\0';
struct hs_scratch scratch;
while (1) {
u8 bit = 1 << (c & 0x7);
u8 cAlt = c ^ bit;
@@ -472,7 +474,6 @@ TEST_P(FDRFloodp, StreamingMask) {
Grey());
CHECK_WITH_TEDDY_OK_TO_FAIL(fdr, hint);
map <u32, int> matchesCounts;
hwlm_error_t fdrStatus;
const u32 cnt4 = dataSize - 4 + 1;
@@ -482,7 +483,7 @@ TEST_P(FDRFloodp, StreamingMask) {
// reference past the end of fake history to allow headroom
const u8 *fhist = fake_history.data() + fake_history_size;
fdrStatus = fdrExecStreaming(fdr.get(), fhist, 0, d, streamChunk, 0,
countCallback, &matchesCounts,
countCallback, &scratch,
HWLM_ALL_GROUPS);
ASSERT_EQ(0, fdrStatus);
for (u32 j = streamChunk; j < dataSize; j += streamChunk) {
@@ -493,13 +494,11 @@ TEST_P(FDRFloodp, StreamingMask) {
const u8 *tmp_d = tempdata.data() + fake_history_size;
fdrStatus = fdrExecStreaming(fdr.get(), tmp_d, j, tmp_d + j,
streamChunk, 0, countCallback,
&matchesCounts,
HWLM_ALL_GROUPS);
&scratch, HWLM_ALL_GROUPS);
} else {
fdrStatus = fdrExecStreaming(fdr.get(), d + j - 8, 8, d + j,
streamChunk, 0, countCallback,
&matchesCounts,
HWLM_ALL_GROUPS);
&scratch, HWLM_ALL_GROUPS);
}
ASSERT_EQ(0, fdrStatus);
}
@@ -540,6 +539,7 @@ TEST_P(FDRFloodp, StreamingMask) {
break;
}
}
matchesCounts.clear();
}
INSTANTIATE_TEST_CASE_P(FDRFlood, FDRFloodp, ValuesIn(getValidFdrEngines()));

72
unit/internal/noodle.cpp
View File

@@ -33,6 +33,7 @@
#include "hwlm/noodle_engine.h"
#include "hwlm/hwlm.h"
#include "hwlm/hwlm_literal.h"
#include "scratch.h"
#include "util/alloc.h"
#include "util/ue2string.h"
@@ -51,52 +52,51 @@ struct hlmMatchEntry {
to(end), id(identifier) {}
};
typedef vector<hlmMatchEntry> hlmMatchRecord;
vector<hlmMatchEntry> ctxt;
static
hwlmcb_rv_t hlmSimpleCallback(size_t to, u32 id, void *context) {
hlmMatchRecord *mr = (hlmMatchRecord *)context;
hwlmcb_rv_t hlmSimpleCallback(size_t to, u32 id,
UNUSED struct hs_scratch *scratch) {
DEBUG_PRINTF("match @%zu = %u\n", to, id);
DEBUG_PRINTF("match @%zu = %u,%p\n", to, id, context);
mr->push_back(hlmMatchEntry(to, id));
ctxt.push_back(hlmMatchEntry(to, id));
return HWLM_CONTINUE_MATCHING;
}
static
void noodleMatch(const u8 *data, size_t data_len, const char *lit_str,
size_t lit_len, char nocase, HWLMCallback cb, void *ctxt) {
size_t lit_len, char nocase, HWLMCallback cb) {
u32 id = 1000;
hwlmLiteral lit(std::string(lit_str, lit_len), nocase, id);
auto n = noodBuildTable(lit);
ASSERT_TRUE(n != nullptr);
hwlm_error_t rv;
rv = noodExec(n.get(), data, data_len, 0, cb, ctxt);
struct hs_scratch scratch;
rv = noodExec(n.get(), data, data_len, 0, cb, &scratch);
ASSERT_EQ(HWLM_SUCCESS, rv);
}
TEST(Noodle, nood1) {
const size_t data_len = 1024;
unsigned int i, j;
hlmMatchRecord ctxt;
u8 data[data_len];
memset(data, 'a', data_len);
noodleMatch(data, data_len, "a", 1, 0, hlmSimpleCallback, &ctxt);
noodleMatch(data, data_len, "a", 1, 0, hlmSimpleCallback);
ASSERT_EQ(1024U, ctxt.size());
for (i = 0; i < 1024; i++) {
ASSERT_EQ(i, ctxt[i].to);
}
ctxt.clear();
noodleMatch(data, data_len, "A", 1, 0, hlmSimpleCallback, &ctxt);
noodleMatch(data, data_len, "A", 1, 0, hlmSimpleCallback);
ASSERT_EQ(0U, ctxt.size());
ctxt.clear();
noodleMatch(data, data_len, "A", 1, 1, hlmSimpleCallback, &ctxt);
noodleMatch(data, data_len, "A", 1, 1, hlmSimpleCallback);
ASSERT_EQ(1024U, ctxt.size());
for (i = 0; i < 1024; i++) {
ASSERT_EQ(i, ctxt[i].to);
@@ -104,60 +104,59 @@ TEST(Noodle, nood1) {
for (j = 0; j < 16; j++) {
ctxt.clear();
noodleMatch(data + j, data_len - j, "A", 1, 1, hlmSimpleCallback,
&ctxt);
noodleMatch(data + j, data_len - j, "A", 1, 1, hlmSimpleCallback);
ASSERT_EQ(1024 - j, ctxt.size());
for (i = 0; i < 1024 - j; i++) {
ASSERT_EQ(i, ctxt[i].to);
}
ctxt.clear();
noodleMatch(data, data_len - j, "A", 1, 1, hlmSimpleCallback, &ctxt);
noodleMatch(data, data_len - j, "A", 1, 1, hlmSimpleCallback);
ASSERT_EQ(1024 - j, ctxt.size());
for (i = 0; i < 1024 - j; i++) {
ASSERT_EQ(i, ctxt[i].to);
}
}
ctxt.clear();
}
TEST(Noodle, nood2) {
const size_t data_len = 1024;
unsigned int i, j;
hlmMatchRecord ctxt;
u8 data[data_len];
memset(data, 'a', data_len);
noodleMatch(data, data_len, "aa", 2, 0, hlmSimpleCallback, &ctxt);
noodleMatch(data, data_len, "aa", 2, 0, hlmSimpleCallback);
ASSERT_EQ(1023U, ctxt.size());
for (i = 0; i < 1023; i++) {
ASSERT_EQ(i + 1, ctxt[i].to);
}
ctxt.clear();
noodleMatch(data, data_len, "aA", 2, 0, hlmSimpleCallback, &ctxt);
noodleMatch(data, data_len, "aA", 2, 0, hlmSimpleCallback);
ASSERT_EQ(0U, ctxt.size());
ctxt.clear();
noodleMatch(data, data_len, "AA", 2, 0, hlmSimpleCallback, &ctxt);
noodleMatch(data, data_len, "AA", 2, 0, hlmSimpleCallback);
ASSERT_EQ(0U, ctxt.size());
ctxt.clear();
noodleMatch(data, data_len, "aa", 2, 1, hlmSimpleCallback, &ctxt);
noodleMatch(data, data_len, "aa", 2, 1, hlmSimpleCallback);
ASSERT_EQ(1023U, ctxt.size());
for (i = 0; i < 1023; i++) {
ASSERT_EQ(i + 1, ctxt[i].to);
}
ctxt.clear();
noodleMatch(data, data_len, "Aa", 2, 1, hlmSimpleCallback, &ctxt);
noodleMatch(data, data_len, "Aa", 2, 1, hlmSimpleCallback);
ASSERT_EQ(1023U, ctxt.size());
for (i = 0; i < 1023; i++) {
ASSERT_EQ(i + 1, ctxt[i].to);
}
ctxt.clear();
noodleMatch(data, data_len, "AA", 2, 1, hlmSimpleCallback, &ctxt);
noodleMatch(data, data_len, "AA", 2, 1, hlmSimpleCallback);
ASSERT_EQ(1023U, ctxt.size());
for (i = 0; i < 1023; i++) {
ASSERT_EQ(i + 1, ctxt[i].to);
@@ -165,42 +164,41 @@ TEST(Noodle, nood2) {
for (j = 0; j < 16; j++) {
ctxt.clear();
noodleMatch(data + j, data_len - j, "Aa", 2, 1, hlmSimpleCallback,
&ctxt);
noodleMatch(data + j, data_len - j, "Aa", 2, 1, hlmSimpleCallback);
ASSERT_EQ(1023 - j, ctxt.size());
for (i = 0; i < 1023 - j; i++) {
ASSERT_EQ(i + 1, ctxt[i].to);
}
ctxt.clear();
noodleMatch(data, data_len - j, "aA", 2, 1, hlmSimpleCallback, &ctxt);
noodleMatch(data, data_len - j, "aA", 2, 1, hlmSimpleCallback);
ASSERT_EQ(1023 - j, ctxt.size());
for (i = 0; i < 1023 - j; i++) {
ASSERT_EQ(i + 1, ctxt[i].to);
}
}
ctxt.clear();
}
TEST(Noodle, noodLong) {
const size_t data_len = 1024;
unsigned int i, j;
hlmMatchRecord ctxt;
u8 data[data_len];
memset(data, 'a', data_len);
noodleMatch(data, data_len, "aaaa", 4, 0, hlmSimpleCallback, &ctxt);
noodleMatch(data, data_len, "aaaa", 4, 0, hlmSimpleCallback);
ASSERT_EQ(1021U, ctxt.size());
for (i = 0; i < 1021; i++) {
ASSERT_EQ(i + 3, ctxt[i].to);
}
ctxt.clear();
noodleMatch(data, data_len, "aaAA", 4, 0, hlmSimpleCallback, &ctxt);
noodleMatch(data, data_len, "aaAA", 4, 0, hlmSimpleCallback);
ASSERT_EQ(0U, ctxt.size());
ctxt.clear();
noodleMatch(data, data_len, "aaAA", 4, 1, hlmSimpleCallback, &ctxt);
noodleMatch(data, data_len, "aaAA", 4, 1, hlmSimpleCallback);
ASSERT_EQ(1021U, ctxt.size());
for (i = 0; i < 1021; i++) {
ASSERT_EQ(i + 3, ctxt[i].to);
@@ -208,26 +206,24 @@ TEST(Noodle, noodLong) {
for (j = 0; j < 16; j++) {
ctxt.clear();
noodleMatch(data + j, data_len - j, "AAaa", 4, 1, hlmSimpleCallback,
&ctxt);
noodleMatch(data + j, data_len - j, "AAaa", 4, 1, hlmSimpleCallback);
ASSERT_EQ(1021 - j, ctxt.size());
for (i = 0; i < 1021 - j; i++) {
ASSERT_EQ(i + 3, ctxt[i].to);
}
ctxt.clear();
noodleMatch(data + j, data_len - j, "aaaA", 4, 1, hlmSimpleCallback,
&ctxt);
noodleMatch(data + j, data_len - j, "aaaA", 4, 1, hlmSimpleCallback);
ASSERT_EQ(1021 - j, ctxt.size());
for (i = 0; i < 1021 - j; i++) {
ASSERT_EQ(i + 3, ctxt[i].to);
}
}
ctxt.clear();
}
TEST(Noodle, noodCutoverSingle) {
const size_t max_data_len = 128;
hlmMatchRecord ctxt;
u8 data[max_data_len + 15];
memset(data, 'a', max_data_len + 15);
@@ -235,18 +231,18 @@ TEST(Noodle, noodCutoverSingle) {
for (u32 align = 0; align < 16; align++) {
for (u32 len = 0; len < max_data_len; len++) {
ctxt.clear();
noodleMatch(data + align, len, "a", 1, 0, hlmSimpleCallback, &ctxt);
noodleMatch(data + align, len, "a", 1, 0, hlmSimpleCallback);
EXPECT_EQ(len, ctxt.size());
for (u32 i = 0; i < ctxt.size(); i++) {
ASSERT_EQ(i, ctxt[i].to);
}
}
}
ctxt.clear();
}
TEST(Noodle, noodCutoverDouble) {
const size_t max_data_len = 128;
hlmMatchRecord ctxt;
u8 data[max_data_len + 15];
memset(data, 'a', max_data_len + 15);
@@ -254,13 +250,13 @@ TEST(Noodle, noodCutoverDouble) {
for (u32 align = 0; align < 16; align++) {
for (u32 len = 0; len < max_data_len; len++) {
ctxt.clear();
noodleMatch(data + align, len, "aa", 2, 0, hlmSimpleCallback,
&ctxt);
noodleMatch(data + align, len, "aa", 2, 0, hlmSimpleCallback);
EXPECT_EQ(len ? len - 1 : 0U, ctxt.size());
for (u32 i = 0; i < ctxt.size(); i++) {
ASSERT_EQ(i + 1, ctxt[i].to);
}
}
}
ctxt.clear();
}