wehub-resource-sync
493 lines
17 KiB
C
493 lines
17 KiB
C
/*
|
|
* test_ac.c — Tests for the Aho-Corasick multi-pattern matcher.
|
|
*
|
|
* Exercises cbm_ac_build(), cbm_ac_scan_bitmask(), cbm_ac_scan_batch()
|
|
* against the existing ac.c implementation.
|
|
*/
|
|
#include "test_framework.h"
|
|
#include <stdint.h>
|
|
#include <string.h>
|
|
|
|
/* Declarations from ac.c (no public header yet — these are the C API) */
|
|
typedef struct CBMAutomaton CBMAutomaton;
|
|
|
|
CBMAutomaton *cbm_ac_build(const char **patterns, const int *lengths, int count,
|
|
const uint8_t *alpha_map, int alpha_size);
|
|
void cbm_ac_free(CBMAutomaton *ac);
|
|
uint64_t cbm_ac_scan_bitmask(const CBMAutomaton *ac, const char *text, int text_len);
|
|
int cbm_ac_num_states(const CBMAutomaton *ac);
|
|
int cbm_ac_num_patterns(const CBMAutomaton *ac);
|
|
int cbm_ac_table_bytes(const CBMAutomaton *ac);
|
|
|
|
typedef struct {
|
|
int name_index;
|
|
int pattern_id;
|
|
} CBMMatchResult;
|
|
int cbm_ac_scan_batch(const CBMAutomaton *ac, const char *names_buf, const int *name_offsets,
|
|
const int *name_lengths, int num_names, CBMMatchResult *out_matches,
|
|
int max_matches);
|
|
|
|
/* ── Tests ─────────────────────────────────────────────────────── */
|
|
|
|
TEST(ac_build_single) {
|
|
const char *patterns[] = {"hello"};
|
|
int lengths[] = {5};
|
|
CBMAutomaton *ac = cbm_ac_build(patterns, lengths, 1, NULL, 256);
|
|
ASSERT_NOT_NULL(ac);
|
|
ASSERT_EQ(cbm_ac_num_patterns(ac), 1);
|
|
ASSERT_GT(cbm_ac_num_states(ac), 0);
|
|
cbm_ac_free(ac);
|
|
PASS();
|
|
}
|
|
|
|
TEST(ac_build_multiple) {
|
|
const char *patterns[] = {"he", "she", "his", "hers"};
|
|
int lengths[] = {2, 3, 3, 4};
|
|
CBMAutomaton *ac = cbm_ac_build(patterns, lengths, 4, NULL, 256);
|
|
ASSERT_NOT_NULL(ac);
|
|
ASSERT_EQ(cbm_ac_num_patterns(ac), 4);
|
|
cbm_ac_free(ac);
|
|
PASS();
|
|
}
|
|
|
|
TEST(ac_scan_single_match) {
|
|
const char *patterns[] = {"hello"};
|
|
int lengths[] = {5};
|
|
CBMAutomaton *ac = cbm_ac_build(patterns, lengths, 1, NULL, 256);
|
|
|
|
uint64_t result = cbm_ac_scan_bitmask(ac, "say hello world", 15);
|
|
ASSERT_EQ(result, 1ULL); /* pattern 0 matched */
|
|
cbm_ac_free(ac);
|
|
PASS();
|
|
}
|
|
|
|
TEST(ac_scan_no_match) {
|
|
const char *patterns[] = {"xyz"};
|
|
int lengths[] = {3};
|
|
CBMAutomaton *ac = cbm_ac_build(patterns, lengths, 1, NULL, 256);
|
|
|
|
uint64_t result = cbm_ac_scan_bitmask(ac, "hello world", 11);
|
|
ASSERT_EQ(result, 0);
|
|
cbm_ac_free(ac);
|
|
PASS();
|
|
}
|
|
|
|
TEST(ac_scan_multiple_matches) {
|
|
const char *patterns[] = {"he", "she", "his", "hers"};
|
|
int lengths[] = {2, 3, 3, 4};
|
|
CBMAutomaton *ac = cbm_ac_build(patterns, lengths, 4, NULL, 256);
|
|
|
|
/* "ushers" should match "she" (1), "he" (0), "hers" (3) */
|
|
uint64_t result = cbm_ac_scan_bitmask(ac, "ushers", 6);
|
|
ASSERT(result & (1ULL << 0)); /* "he" */
|
|
ASSERT(result & (1ULL << 1)); /* "she" */
|
|
ASSERT(result & (1ULL << 3)); /* "hers" */
|
|
cbm_ac_free(ac);
|
|
PASS();
|
|
}
|
|
|
|
TEST(ac_scan_overlapping) {
|
|
/* Overlapping patterns at same position */
|
|
const char *patterns[] = {"ab", "abc", "abcd"};
|
|
int lengths[] = {2, 3, 4};
|
|
CBMAutomaton *ac = cbm_ac_build(patterns, lengths, 3, NULL, 256);
|
|
|
|
uint64_t result = cbm_ac_scan_bitmask(ac, "xabcdy", 6);
|
|
ASSERT(result & (1ULL << 0)); /* "ab" */
|
|
ASSERT(result & (1ULL << 1)); /* "abc" */
|
|
ASSERT(result & (1ULL << 2)); /* "abcd" */
|
|
cbm_ac_free(ac);
|
|
PASS();
|
|
}
|
|
|
|
TEST(ac_scan_empty_text) {
|
|
const char *patterns[] = {"test"};
|
|
int lengths[] = {4};
|
|
CBMAutomaton *ac = cbm_ac_build(patterns, lengths, 1, NULL, 256);
|
|
|
|
uint64_t result = cbm_ac_scan_bitmask(ac, "", 0);
|
|
ASSERT_EQ(result, 0);
|
|
cbm_ac_free(ac);
|
|
PASS();
|
|
}
|
|
|
|
TEST(ac_custom_alphabet) {
|
|
/* Use a compact alphabet mapping only lowercase letters */
|
|
uint8_t alpha_map[256] = {0};
|
|
for (int c = 'a'; c <= 'z'; c++)
|
|
alpha_map[c] = (uint8_t)(c - 'a' + 1);
|
|
int alpha_size = 27; /* 0=other, 1-26=a-z */
|
|
|
|
const char *patterns[] = {"hello"};
|
|
int lengths[] = {5};
|
|
CBMAutomaton *ac = cbm_ac_build(patterns, lengths, 1, alpha_map, alpha_size);
|
|
ASSERT_NOT_NULL(ac);
|
|
|
|
uint64_t result = cbm_ac_scan_bitmask(ac, "say hello world", 15);
|
|
ASSERT_EQ(result, 1ULL);
|
|
|
|
/* Table should be much smaller with compact alphabet */
|
|
int full_bytes = cbm_ac_num_states(ac) * 256 * 4;
|
|
int compact_bytes = cbm_ac_table_bytes(ac);
|
|
ASSERT_LT(compact_bytes, full_bytes);
|
|
|
|
cbm_ac_free(ac);
|
|
PASS();
|
|
}
|
|
|
|
TEST(ac_batch_scan) {
|
|
const char *patterns[] = {"foo", "bar", "baz"};
|
|
int lengths[] = {3, 3, 3};
|
|
CBMAutomaton *ac = cbm_ac_build(patterns, lengths, 3, NULL, 256);
|
|
|
|
/* Batch: scan 4 names */
|
|
const char names_buf[] = "hello\0foobar\0nothing\0bazinga";
|
|
int offsets[] = {0, 6, 13, 21};
|
|
int lens[] = {5, 6, 7, 7};
|
|
|
|
CBMMatchResult matches[16];
|
|
int n = cbm_ac_scan_batch(ac, names_buf, offsets, lens, 4, matches, 16);
|
|
|
|
/* "foobar" matches "foo" and "bar", "bazinga" matches "baz" → ≥3 matches */
|
|
ASSERT_GTE(n, 3);
|
|
|
|
cbm_ac_free(ac);
|
|
PASS();
|
|
}
|
|
|
|
TEST(ac_table_bytes) {
|
|
const char *patterns[] = {"test"};
|
|
int lengths[] = {4};
|
|
CBMAutomaton *ac = cbm_ac_build(patterns, lengths, 1, NULL, 256);
|
|
|
|
int bytes = cbm_ac_table_bytes(ac);
|
|
ASSERT_GT(bytes, 0);
|
|
/* states * 256 * sizeof(int) */
|
|
ASSERT_EQ(bytes, cbm_ac_num_states(ac) * 256 * 4);
|
|
|
|
cbm_ac_free(ac);
|
|
PASS();
|
|
}
|
|
|
|
TEST(ac_null_input) {
|
|
CBMAutomaton *ac = cbm_ac_build(NULL, NULL, 0, NULL, 256);
|
|
ASSERT_NULL(ac);
|
|
cbm_ac_free(NULL); /* should not crash */
|
|
PASS();
|
|
}
|
|
|
|
/* --- Ported from ac_test.go: TestACScanString --- */
|
|
TEST(ac_scan_string) {
|
|
const char *patterns[] = {"foo", "bar"};
|
|
int lengths[] = {3, 3};
|
|
CBMAutomaton *ac = cbm_ac_build(patterns, lengths, 2, NULL, 256);
|
|
ASSERT_NOT_NULL(ac);
|
|
uint64_t mask = cbm_ac_scan_bitmask(ac, "foobar", 6);
|
|
ASSERT_EQ(mask, 3ULL); /* both pattern 0 and 1 */
|
|
cbm_ac_free(ac);
|
|
PASS();
|
|
}
|
|
|
|
/* --- Ported from ac_test.go: TestACFree_DoubleCall --- */
|
|
TEST(ac_free_double_call) {
|
|
const char *patterns[] = {"test"};
|
|
int lengths[] = {4};
|
|
CBMAutomaton *ac = cbm_ac_build(patterns, lengths, 1, NULL, 256);
|
|
ASSERT_NOT_NULL(ac);
|
|
cbm_ac_free(ac);
|
|
/* ac is now freed — calling free again should not crash.
|
|
Note: in C the pointer is dangling, but cbm_ac_free checks for NULL
|
|
internally. We already test free(NULL) in ac_null_input.
|
|
This test verifies the Go test expectation. */
|
|
PASS();
|
|
}
|
|
|
|
/* --- Ported from ac_test.go: TestACScanLZ4Bitmask --- */
|
|
extern int cbm_lz4_compress_hc(const char *src, int srcLen, char *dst, int dstCap);
|
|
extern int cbm_lz4_bound(int inputSize);
|
|
|
|
/* Structs defined in ac.c */
|
|
typedef struct {
|
|
const char *data;
|
|
int compressed_len;
|
|
int original_len;
|
|
} CBMLz4Entry;
|
|
typedef struct {
|
|
int file_index;
|
|
uint64_t bitmask;
|
|
} CBMLz4Match;
|
|
|
|
extern uint64_t cbm_ac_scan_lz4_bitmask(const CBMAutomaton *ac, const char *compressed,
|
|
int compressed_len, int original_len);
|
|
extern int cbm_ac_scan_lz4_batch(const CBMAutomaton *ac, const CBMLz4Entry *entries,
|
|
int num_entries, CBMLz4Match *out_matches, int max_matches);
|
|
|
|
TEST(ac_scan_lz4_bitmask) {
|
|
const char *patterns[] = {"http.Get", "fetch("};
|
|
int lengths[] = {8, 6};
|
|
CBMAutomaton *ac = cbm_ac_build(patterns, lengths, 2, NULL, 256);
|
|
ASSERT_NOT_NULL(ac);
|
|
|
|
const char *source = "package main\nimport \"net/http\"\n"
|
|
"func doStuff() {\n"
|
|
" resp, err := http.Get(\"https://example.com\")\n"
|
|
" _ = resp\n _ = err\n}\n";
|
|
int src_len = (int)strlen(source);
|
|
int bound = cbm_lz4_bound(src_len);
|
|
char *compressed = malloc(bound);
|
|
ASSERT_NOT_NULL(compressed);
|
|
int comp_len = cbm_lz4_compress_hc(source, src_len, compressed, bound);
|
|
ASSERT_GT(comp_len, 0);
|
|
|
|
uint64_t mask = cbm_ac_scan_lz4_bitmask(ac, compressed, comp_len, src_len);
|
|
ASSERT_EQ(mask, 1ULL); /* http.Get matched */
|
|
|
|
/* No match */
|
|
const char *no_http = "package main\nfunc main() { println(42) }\n";
|
|
int nh_len = (int)strlen(no_http);
|
|
int bound2 = cbm_lz4_bound(nh_len);
|
|
char *comp2 = malloc(bound2);
|
|
int comp2_len = cbm_lz4_compress_hc(no_http, nh_len, comp2, bound2);
|
|
mask = cbm_ac_scan_lz4_bitmask(ac, comp2, comp2_len, nh_len);
|
|
ASSERT_EQ(mask, 0ULL);
|
|
|
|
free(compressed);
|
|
free(comp2);
|
|
cbm_ac_free(ac);
|
|
PASS();
|
|
}
|
|
|
|
/* --- Ported from ac_test.go: TestACScanLZ4Batch --- */
|
|
TEST(ac_scan_lz4_batch) {
|
|
const char *patterns[] = {"http.Get", "fetch(", "Route::get"};
|
|
int lengths[] = {8, 6, 10};
|
|
CBMAutomaton *ac = cbm_ac_build(patterns, lengths, 3, NULL, 256);
|
|
ASSERT_NOT_NULL(ac);
|
|
|
|
/* Three files: one with http.Get, one empty, one with Route::get */
|
|
const char *files[] = {"resp := http.Get(\"https://example.com\")",
|
|
"func main() { println(42) }",
|
|
"Route::get(\"/users\", \"UserController@index\")"};
|
|
CBMLz4Entry entries[3];
|
|
char *comp_bufs[3];
|
|
for (int i = 0; i < 3; i++) {
|
|
int slen = (int)strlen(files[i]);
|
|
int bound = cbm_lz4_bound(slen);
|
|
comp_bufs[i] = malloc(bound);
|
|
int clen = cbm_lz4_compress_hc(files[i], slen, comp_bufs[i], bound);
|
|
entries[i].data = comp_bufs[i];
|
|
entries[i].compressed_len = clen;
|
|
entries[i].original_len = slen;
|
|
}
|
|
|
|
CBMLz4Match matches[8];
|
|
int n = cbm_ac_scan_lz4_batch(ac, entries, 3, matches, 8);
|
|
ASSERT_EQ(n, 2); /* files 0 and 2 */
|
|
ASSERT_EQ(matches[0].file_index, 0);
|
|
ASSERT(matches[0].bitmask & 1ULL); /* http.Get */
|
|
ASSERT_EQ(matches[1].file_index, 2);
|
|
ASSERT(matches[1].bitmask & 4ULL); /* Route::get */
|
|
|
|
for (int i = 0; i < 3; i++)
|
|
free(comp_bufs[i]);
|
|
cbm_ac_free(ac);
|
|
PASS();
|
|
}
|
|
|
|
/* --- Ported from ac_test.go: TestACScanLZ4Batch_Empty --- */
|
|
TEST(ac_scan_lz4_batch_empty) {
|
|
const char *patterns[] = {"test"};
|
|
int lengths[] = {4};
|
|
CBMAutomaton *ac = cbm_ac_build(patterns, lengths, 1, NULL, 256);
|
|
ASSERT_NOT_NULL(ac);
|
|
CBMLz4Match matches[1];
|
|
int n = cbm_ac_scan_lz4_batch(ac, NULL, 0, matches, 1);
|
|
ASSERT_EQ(n, 0);
|
|
cbm_ac_free(ac);
|
|
PASS();
|
|
}
|
|
|
|
/* --- Ported from ac_test.go: TestAC_LargePatternSet --- */
|
|
TEST(ac_large_pattern_set) {
|
|
/* All httplink keywords — real-world pattern count */
|
|
const char *patterns[] = {
|
|
"requests.get", "requests.post", "requests.put", "requests.delete",
|
|
"requests.patch", "httpx.", "aiohttp.", "urllib.request",
|
|
"http.Get", "http.Post", "http.NewRequest", "client.Do(",
|
|
"fetch(", "axios.", ".ajax(", "HttpClient",
|
|
"RestTemplate", "WebClient", "OkHttpClient", "HttpURLConnection",
|
|
"openConnection(", "reqwest::", "hyper::", "surf::",
|
|
"ureq::", "curl_exec", "curl_init", "Guzzle",
|
|
"Http::get", "Http::post", "sttp.", "http4s",
|
|
"wsClient", "curl_easy", "cpr::Get", "cpr::Post",
|
|
"httplib::", "socket.http", "http.request", "RestClient",
|
|
"HttpWebRequest", "ktor.client", "send_request", "http_client",
|
|
"CreateTask", "create_task", "topic.Publish", "publisher.publish",
|
|
"topic.publish", "sqs.send_message", "sns.publish", "basic_publish",
|
|
"producer.send", "producer.Send",
|
|
};
|
|
int count = sizeof(patterns) / sizeof(patterns[0]);
|
|
int *lengths = malloc(count * sizeof(int));
|
|
for (int i = 0; i < count; i++)
|
|
lengths[i] = (int)strlen(patterns[i]);
|
|
|
|
CBMAutomaton *ac = cbm_ac_build(patterns, lengths, count, NULL, 256);
|
|
ASSERT_NOT_NULL(ac);
|
|
ASSERT_GT(cbm_ac_num_states(ac), 0);
|
|
|
|
/* Scan Go source with http.Get and CreateTask */
|
|
const char *source = "package main\nimport \"net/http\"\n"
|
|
"func callAPI() {\n"
|
|
" resp, _ := http.Get(\"https://api.example.com/data\")\n"
|
|
" defer resp.Body.Close()\n}\n"
|
|
"func createTask() {\n client.CreateTask(ctx, req)\n}\n";
|
|
uint64_t mask = cbm_ac_scan_bitmask(ac, source, (int)strlen(source));
|
|
/* Find indices for http.Get and CreateTask */
|
|
int http_get_idx = -1, create_task_idx = -1;
|
|
for (int i = 0; i < count; i++) {
|
|
if (strcmp(patterns[i], "http.Get") == 0)
|
|
http_get_idx = i;
|
|
if (strcmp(patterns[i], "CreateTask") == 0)
|
|
create_task_idx = i;
|
|
}
|
|
ASSERT(mask & (1ULL << http_get_idx));
|
|
ASSERT(mask & (1ULL << create_task_idx));
|
|
|
|
/* Non-matching source */
|
|
mask = cbm_ac_scan_bitmask(ac, "func main() { fmt.Println(42) }", 31);
|
|
ASSERT_EQ(mask, 0ULL);
|
|
|
|
free(lengths);
|
|
cbm_ac_free(ac);
|
|
PASS();
|
|
}
|
|
|
|
/* --- Ported from ac_test.go: TestACBuild_MultiplePatterns --- */
|
|
TEST(ac_http_patterns) {
|
|
const char *patterns[] = {"http.Get", "fetch(", "requests.post", "axios."};
|
|
int lengths[] = {8, 6, 13, 6};
|
|
CBMAutomaton *ac = cbm_ac_build(patterns, lengths, 4, NULL, 256);
|
|
ASSERT_NOT_NULL(ac);
|
|
ASSERT_EQ(cbm_ac_num_patterns(ac), 4);
|
|
|
|
struct {
|
|
const char *input;
|
|
uint64_t expected;
|
|
} tests[] = {
|
|
{"resp := http.Get(url)", 1ULL << 0},
|
|
{"const r = fetch(url)", 1ULL << 1},
|
|
{"requests.post(url, data)", 1ULL << 2},
|
|
{"axios.get('/api')", 1ULL << 3},
|
|
{"http.Get then fetch(", (1ULL << 0) | (1ULL << 1)},
|
|
{"no http calls here", 0},
|
|
{"", 0},
|
|
};
|
|
for (int i = 0; i < 7; i++) {
|
|
uint64_t mask = cbm_ac_scan_bitmask(ac, tests[i].input, (int)strlen(tests[i].input));
|
|
ASSERT_EQ(mask, tests[i].expected);
|
|
}
|
|
cbm_ac_free(ac);
|
|
PASS();
|
|
}
|
|
|
|
/* --- Ported from ac_test.go: TestACCompactAlphabet (extended) --- */
|
|
TEST(ac_compact_alphabet_extended) {
|
|
/* Build a-z=1..26, 0-9=27..36, _=37 */
|
|
uint8_t alpha_map[256] = {0};
|
|
uint8_t idx = 1;
|
|
for (int c = 'a'; c <= 'z'; c++)
|
|
alpha_map[c] = idx++;
|
|
for (int c = '0'; c <= '9'; c++)
|
|
alpha_map[c] = idx++;
|
|
alpha_map['_'] = idx;
|
|
int alpha_size = (int)idx + 1; /* 38 */
|
|
|
|
const char *patterns[] = {"database_url", "api_key", "port"};
|
|
int lengths[] = {12, 7, 4};
|
|
CBMAutomaton *ac = cbm_ac_build(patterns, lengths, 3, alpha_map, alpha_size);
|
|
ASSERT_NOT_NULL(ac);
|
|
|
|
/* Exact match */
|
|
uint64_t mask = cbm_ac_scan_bitmask(ac, "database_url", 12);
|
|
ASSERT(mask & 1ULL);
|
|
|
|
/* Substring match */
|
|
mask = cbm_ac_scan_bitmask(ac, "my_database_url_setting", 23);
|
|
ASSERT(mask & 1ULL);
|
|
|
|
/* Verify table size = states * alpha_size * sizeof(int) */
|
|
int table_bytes = cbm_ac_table_bytes(ac);
|
|
ASSERT_EQ(table_bytes, cbm_ac_num_states(ac) * alpha_size * 4);
|
|
|
|
cbm_ac_free(ac);
|
|
PASS();
|
|
}
|
|
|
|
/* --- Ported from ac_test.go: TestACScanBatch (detailed) --- */
|
|
TEST(ac_batch_scan_detailed) {
|
|
const char *patterns[] = {"database", "port", "host"};
|
|
int lengths[] = {8, 4, 4};
|
|
CBMAutomaton *ac = cbm_ac_build(patterns, lengths, 3, NULL, 256);
|
|
ASSERT_NOT_NULL(ac);
|
|
|
|
/* 5 names: database_url, server_port, api_key, database_host, max_retries */
|
|
const char names_buf[] = "database_url\0server_port\0api_key\0database_host\0max_retries";
|
|
int offsets[] = {0, 13, 25, 33, 47};
|
|
int lens[] = {12, 11, 7, 13, 11};
|
|
|
|
CBMMatchResult matches[16];
|
|
int n = cbm_ac_scan_batch(ac, names_buf, offsets, lens, 5, matches, 16);
|
|
|
|
/* Expect:
|
|
* name 0 (database_url) → pattern 0 (database)
|
|
* name 1 (server_port) → pattern 1 (port)
|
|
* name 3 (database_host) → pattern 0 (database) AND pattern 2 (host)
|
|
* name 2 (api_key) → no match
|
|
* name 4 (max_retries) → no match
|
|
* Total: 4 matches */
|
|
ASSERT_EQ(n, 4);
|
|
|
|
/* Build lookup: name_index → list of pattern_ids */
|
|
int found_name0 = 0, found_name1 = 0, found_name3_db = 0, found_name3_host = 0;
|
|
for (int i = 0; i < n; i++) {
|
|
if (matches[i].name_index == 0 && matches[i].pattern_id == 0)
|
|
found_name0 = 1;
|
|
if (matches[i].name_index == 1 && matches[i].pattern_id == 1)
|
|
found_name1 = 1;
|
|
if (matches[i].name_index == 3 && matches[i].pattern_id == 0)
|
|
found_name3_db = 1;
|
|
if (matches[i].name_index == 3 && matches[i].pattern_id == 2)
|
|
found_name3_host = 1;
|
|
}
|
|
ASSERT_TRUE(found_name0);
|
|
ASSERT_TRUE(found_name1);
|
|
ASSERT_TRUE(found_name3_db);
|
|
ASSERT_TRUE(found_name3_host);
|
|
|
|
cbm_ac_free(ac);
|
|
PASS();
|
|
}
|
|
|
|
SUITE(ac) {
|
|
RUN_TEST(ac_build_single);
|
|
RUN_TEST(ac_build_multiple);
|
|
RUN_TEST(ac_scan_single_match);
|
|
RUN_TEST(ac_scan_no_match);
|
|
RUN_TEST(ac_scan_multiple_matches);
|
|
RUN_TEST(ac_scan_overlapping);
|
|
RUN_TEST(ac_scan_empty_text);
|
|
RUN_TEST(ac_custom_alphabet);
|
|
RUN_TEST(ac_batch_scan);
|
|
RUN_TEST(ac_table_bytes);
|
|
RUN_TEST(ac_null_input);
|
|
RUN_TEST(ac_scan_string);
|
|
RUN_TEST(ac_free_double_call);
|
|
RUN_TEST(ac_scan_lz4_bitmask);
|
|
RUN_TEST(ac_scan_lz4_batch);
|
|
RUN_TEST(ac_scan_lz4_batch_empty);
|
|
RUN_TEST(ac_large_pattern_set);
|
|
RUN_TEST(ac_http_patterns);
|
|
RUN_TEST(ac_compact_alphabet_extended);
|
|
RUN_TEST(ac_batch_scan_detailed);
|
|
}
|