static Folder*
S_create_index()
{
Schema *schema = (Schema*)TestSchema_new();
RAMFolder *folder = RAMFolder_new(NULL);
VArray *doc_set = TestUtils_doc_set();
Indexer *indexer = Indexer_new(schema, (Obj*)folder, NULL, NULL, 0);
u32_t i, max;
for (i = 0, max = VA_Get_Size(doc_set); i < max; i++) {
static CharBuf field = ZCB_LITERAL("content");
Doc *doc = Doc_new(NULL, 0);
Doc_Store(doc, &field, VA_Fetch(doc_set, i));
Indexer_Add_Doc(indexer, doc, 1.0f);
DECREF(doc);
}
Indexer_Commit(indexer);
DECREF(doc_set);
DECREF(indexer);
DECREF(schema);
return (Folder*)folder;
}
#include "Search/Kino03/KinoSearch/Util/ToolSet.h"
#include "Search/Kino03/KinoSearch/Test.h"
#include "Search/Kino03/KinoSearch/Test/Analysis/TestPolyAnalyzer.h"
#include "Search/Kino03/KinoSearch/Analysis/PolyAnalyzer.h"
static ZombieCharBuf EN = ZCB_LITERAL("en");
static ZombieCharBuf ES = ZCB_LITERAL("es");
static void
test_Dump_Load_and_Equals(TestBatch *batch)
{
PolyAnalyzer *analyzer = PolyAnalyzer_new((CharBuf*)&EN, NULL);
PolyAnalyzer *other = PolyAnalyzer_new((CharBuf*)&ES, NULL);
Obj *dump = (Obj*)PolyAnalyzer_Dump(analyzer);
Obj *other_dump = (Obj*)PolyAnalyzer_Dump(other);
PolyAnalyzer *clone = (PolyAnalyzer*)PolyAnalyzer_Load(other, dump);
PolyAnalyzer *other_clone
= (PolyAnalyzer*)PolyAnalyzer_Load(other, other_dump);
ASSERT_FALSE(batch, PolyAnalyzer_Equals(analyzer,
(Obj*)other), "Equals() false with different language");
ASSERT_TRUE(batch, PolyAnalyzer_Dump_Equals(other,
(Obj*)other_dump), "Dump_Equals()");
ASSERT_TRUE(batch, PolyAnalyzer_Dump_Equals(analyzer,
(Obj*)dump), "Dump_Equals()");
ASSERT_FALSE(batch, PolyAnalyzer_Dump_Equals(analyzer,
(Obj*)other_dump), "Dump_Equals() false with different language");
ASSERT_FALSE(batch, PolyAnalyzer_Dump_Equals(other,
(Obj*)dump), "Dump_Equals() false with different language");
ASSERT_TRUE(batch, PolyAnalyzer_Equals(analyzer,
#include "Search/Kino03/KinoSearch/Test.h"
#include "Search/Kino03/KinoSearch/Test/TestArchitecture.h"
#include "Search/Kino03/KinoSearch/Test/TestSchema.h"
#include "Search/Kino03/KinoSearch/Analysis/CaseFolder.h"
#include "Search/Kino03/KinoSearch/Analysis/Tokenizer.h"
#include "Search/Kino03/KinoSearch/Architecture.h"
#include "Search/Kino03/KinoSearch/FieldType/FullTextType.h"
TestSchema*
TestSchema_new()
{
TestSchema *self = (TestSchema*)VTable_Make_Obj(&TESTSCHEMA);
return TestSchema_init(self);
}
static CharBuf content = ZCB_LITERAL("content");
TestSchema*
TestSchema_init(TestSchema *self)
{
Tokenizer *tokenizer = Tokenizer_new(NULL);
FullTextType *type = FullTextType_new((Analyzer*)tokenizer);
Schema_init((Schema*)self);
FullTextType_Set_Highlightable(type, true);
Schema_Spec_Field(self, &content, (FieldType*)type);
DECREF(type);
DECREF(tokenizer);
return self;
}
#define C_KINO_RAMFOLDER
#define C_KINO_CHARBUF
#include "KinoSearch/Util/ToolSet.h"
#include "KinoSearch/Test.h"
#include "KinoSearch/Test/Store/TestFolder.h"
#include "KinoSearch/Store/DirHandle.h"
#include "KinoSearch/Store/FileHandle.h"
#include "KinoSearch/Store/InStream.h"
#include "KinoSearch/Store/OutStream.h"
#include "KinoSearch/Store/RAMFolder.h"
static CharBuf foo = ZCB_LITERAL("foo");
static CharBuf bar = ZCB_LITERAL("bar");
static CharBuf baz = ZCB_LITERAL("baz");
static CharBuf boffo = ZCB_LITERAL("boffo");
static CharBuf banana = ZCB_LITERAL("banana");
static CharBuf foo_bar = ZCB_LITERAL("foo/bar");
static CharBuf foo_boffo = ZCB_LITERAL("foo/boffo");
static CharBuf foo_foo = ZCB_LITERAL("foo/foo");
static CharBuf foo_bar_baz = ZCB_LITERAL("foo/bar/baz");
static CharBuf foo_bar_baz_boffo = ZCB_LITERAL("foo/bar/baz/boffo");
static CharBuf nope = ZCB_LITERAL("nope");
static void
test_Exists(TestBatch *batch)
{
Folder *folder = (Folder*)RAMFolder_new(NULL);
FileHandle *fh;
Folder_MkDir(folder, &foo);
void
TestQPLogic_run_tests()
{
u32_t i;
TestBatch *batch = Test_new_batch("TestQueryParserLogic", 178, NULL);
Folder *folder = S_create_index();
Searcher *searcher = Searcher_new((Obj*)folder);
QueryParser *or_parser = QParser_new(Searcher_Get_Schema(searcher),
NULL, NULL, NULL);
static ZombieCharBuf AND = ZCB_LITERAL("AND");
QueryParser *and_parser = QParser_new(Searcher_Get_Schema(searcher),
NULL, (CharBuf*)&AND, NULL);
QParser_Set_Heed_Colons(or_parser, true);
QParser_Set_Heed_Colons(and_parser, true);
PLAN(batch);
/* Run logical tests with default boolop of OR. */
for (i = 0; logical_test_funcs[i] != NULL; i++) {
kino_TestQPLogic_logical_test_t test_func = logical_test_funcs[i];
TestQueryParser *test_case = test_func(BOOLOP_OR);
Query *tree = QParser_Tree(or_parser, test_case->query_string);
Query *parsed = QParser_Parse(or_parser, test_case->query_string);
Hits *hits = Searcher_Hits(searcher, (Obj*)parsed, 0, 10, NULL);
ASSERT_TRUE(batch, Query_Equals(tree, (Obj*)test_case->tree),
"tree() OR %s", test_case->query_string->ptr);
ASSERT_INT_EQ(batch, Hits_Total_Hits(hits), test_case->num_hits,
"hits: OR %s", test_case->query_string->ptr);
DECREF(hits);
DECREF(parsed);
DECREF(tree);
DECREF(test_case);
}
/* Run logical tests with default boolop of AND. */
for (i = 0; logical_test_funcs[i] != NULL; i++) {
kino_TestQPLogic_logical_test_t test_func = logical_test_funcs[i];
TestQueryParser *test_case = test_func(BOOLOP_AND);
Query *tree = QParser_Tree(and_parser, test_case->query_string);
Query *parsed = QParser_Parse(and_parser, test_case->query_string);
Hits *hits = Searcher_Hits(searcher, (Obj*)parsed, 0, 10, NULL);
ASSERT_TRUE(batch, Query_Equals(tree, (Obj*)test_case->tree),
"tree() AND %s", test_case->query_string->ptr);
ASSERT_INT_EQ(batch, Hits_Total_Hits(hits), test_case->num_hits,
"hits: AND %s", test_case->query_string->ptr);
DECREF(hits);
DECREF(parsed);
DECREF(tree);
DECREF(test_case);
}
/* Run tests for QParser_Prune(). */
for (i = 0; prune_test_funcs[i] != NULL; i++) {
kino_TestQPLogic_prune_test_t test_func = prune_test_funcs[i];
TestQueryParser *test_case = test_func();
CharBuf *qstring = test_case->tree
? Obj_To_String(test_case->tree)
: CB_new_from_trusted_utf8("(NULL)", 6);
Query *tree = test_case->tree;
Query *wanted = test_case->expanded;
Query *pruned = QParser_Prune(or_parser, tree);
Query *expanded;
Hits *hits;
ASSERT_TRUE(batch, Query_Equals(pruned, (Obj*)wanted),
"prune() %s", qstring->ptr);
expanded = QParser_Expand(or_parser, pruned);
hits = Searcher_Hits(searcher, (Obj*)expanded, 0, 10, NULL);
ASSERT_INT_EQ(batch, Hits_Total_Hits(hits), test_case->num_hits,
"hits: %s", qstring->ptr);
DECREF(hits);
DECREF(expanded);
DECREF(pruned);
DECREF(qstring);
DECREF(test_case);
}
DECREF(and_parser);
DECREF(or_parser);
DECREF(searcher);
DECREF(folder);
batch->destroy(batch);
}
#include "Search/Kino03/KinoSearch/Util/ToolSet.h"
#include "Search/Kino03/KinoSearch/Test.h"
#include "Search/Kino03/KinoSearch/Test/Analysis/TestTokenizer.h"
#include "Search/Kino03/KinoSearch/Analysis/Tokenizer.h"
static ZombieCharBuf word_char_pattern = ZCB_LITERAL("\\w+");
static ZombieCharBuf whitespace_pattern = ZCB_LITERAL("\\S+");
static void
test_Dump_Load_and_Equals(TestBatch *batch)
{
Tokenizer *word_char_tokenizer =
Tokenizer_new((CharBuf*)&word_char_pattern);
Tokenizer *whitespace_tokenizer =
Tokenizer_new((CharBuf*)&whitespace_pattern);
Obj *word_char_dump = Tokenizer_Dump(word_char_tokenizer);
Obj *whitespace_dump = Tokenizer_Dump(whitespace_tokenizer);
Tokenizer *word_char_clone
= Tokenizer_Load(whitespace_tokenizer, word_char_dump);
Tokenizer *whitespace_clone
= Tokenizer_Load(whitespace_tokenizer, whitespace_dump);
ASSERT_FALSE(batch, Tokenizer_Equals(word_char_tokenizer,
(Obj*)whitespace_tokenizer), "Equals() false with different pattern");
ASSERT_TRUE(batch, Tokenizer_Dump_Equals(whitespace_tokenizer,
(Obj*)whitespace_dump), "Dump_Equals()");
ASSERT_TRUE(batch, Tokenizer_Dump_Equals(word_char_tokenizer,
(Obj*)word_char_dump), "Dump_Equals()");
ASSERT_FALSE(batch, Tokenizer_Dump_Equals(word_char_tokenizer,
(Obj*)whitespace_dump), "Dump_Equals() false with different pattern");
