From ce5cf84baafe5c75db31c1bc24a785c54818319f Mon Sep 17 00:00:00 2001 From: Henning Baldersheim Date: Fri, 16 Dec 2016 11:27:04 +0100 Subject: Rewrite test to modern framework. --- vsm/src/tests/searcher/searcher.cpp | 450 +++++++++++++++--------------------- 1 file changed, 189 insertions(+), 261 deletions(-) (limited to 'vsm/src/tests/searcher') diff --git a/vsm/src/tests/searcher/searcher.cpp b/vsm/src/tests/searcher/searcher.cpp index dfcad223701..0d84c889363 100644 --- a/vsm/src/tests/searcher/searcher.cpp +++ b/vsm/src/tests/searcher/searcher.cpp @@ -1,7 +1,5 @@ // Copyright 2016 Yahoo Inc. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. -#include -#include -LOG_SETUP("searcher_test"); + #include #include @@ -24,8 +22,7 @@ using namespace document; using search::EmptyQueryNodeResult; using search::QueryTerm; using search::QueryTermList; - -namespace vsm { +using namespace vsm; template class Vector : public std::vector @@ -113,144 +110,132 @@ struct SnippetModifierSetup } }; -class SearcherTest : public vespalib::TestApp -{ -private: - // helper functions - ArrayFieldValue getFieldValue(const StringList & fv); - ArrayFieldValue getFieldValue(const LongList & fv); - ArrayFieldValue getFieldValue(const FloatList & fv); - bool assertMatchTermSuffix(const std::string & term, const std::string & word); +// helper functions +ArrayFieldValue getFieldValue(const StringList &fv); +ArrayFieldValue getFieldValue(const LongList &fv); +ArrayFieldValue getFieldValue(const FloatList &fv); - /** string field searcher **/ - void assertString(StrChrFieldSearcher & fs, const std::string & term, const std::string & field, const Hits & exp) { - assertString(fs, StringList().add(term), field, HitsList().add(exp)); - } - void assertString(StrChrFieldSearcher & fs, const StringList & query, const std::string & field, const HitsList & exp) { - assertSearch(fs, query, StringFieldValue(field), exp); - } - void assertString(StrChrFieldSearcher & fs, const std::string & term, const StringList & field, const Hits & exp) { - assertString(fs, StringList().add(term), field, HitsList().add(exp)); - } - void assertString(StrChrFieldSearcher & fs, const StringList & query, const StringList & field, const HitsList & exp) { - assertSearch(fs, query, getFieldValue(field), exp); - } +bool assertMatchTermSuffix(const std::string &term, const std::string &word); +void assertSnippetModifier(const StringList &query, const std::string &fv, const std::string &exp); +void assertSnippetModifier(SnippetModifierSetup &setup, const FieldValue &fv, const std::string &exp); +void assertQueryTerms(const SnippetModifierManager &man, FieldIdT fId, const StringList &terms); +void assertNumeric(FieldSearcher &fs, const StringList &query, const FieldValue &fv, const BoolList &exp); +std::vector performSearch(FieldSearcher &fs, const StringList &query, const FieldValue &fv); +void assertSearch(FieldSearcher &fs, const StringList &query, const FieldValue &fv, const HitsList &exp); +bool assertCountWords(size_t numWords, const std::string &field); +bool assertFieldInfo(FieldSearcher &fs, const StringList &query, const FieldValue &fv, const FieldInfoList &exp); - /** int field searcher **/ - void assertInt(IntFieldSearcher fs, const std::string & term, int64_t field, bool exp) { - assertInt(fs, StringList().add(term), field, BoolList().add(exp)); - } - void assertInt(IntFieldSearcher fs, const StringList & query, int64_t field, const BoolList & exp) { - assertNumeric(fs, query, LongFieldValue(field), exp); - } - void assertInt(IntFieldSearcher fs, const std::string & term, const LongList & field, const Hits & exp) { - assertInt(fs, StringList().add(term), field, HitsList().add(exp)); - } - void assertInt(IntFieldSearcher fs, const StringList & query, const LongList & field, const HitsList & exp) { - assertSearch(fs, query, getFieldValue(field), exp); - } +void assertString(StrChrFieldSearcher &fs, const StringList &query, const std::string &field, const HitsList &exp) { + assertSearch(fs, query, StringFieldValue(field), exp); +} - /** float field searcher **/ - void assertFloat(FloatFieldSearcher fs, const std::string & term, float field, bool exp) { - assertFloat(fs, StringList().add(term), field, BoolList().add(exp)); - } - void assertFloat(FloatFieldSearcher fs, const StringList & query, float field, const BoolList & exp) { - assertNumeric(fs, query, FloatFieldValue(field), exp); - } - void assertFloat(FloatFieldSearcher fs, const std::string & term, const FloatList & field, const Hits & exp) { - assertFloat(fs, StringList().add(term), field, HitsList().add(exp)); - } - void assertFloat(FloatFieldSearcher fs, const StringList & query, const FloatList & field, const HitsList & exp) { - assertSearch(fs, query, getFieldValue(field), exp); - } +void assertString(StrChrFieldSearcher &fs, const StringList &query, const StringList &field, const HitsList &exp) { + assertSearch(fs, query, getFieldValue(field), exp); +} - void assertNumeric(FieldSearcher & fs, const StringList & query, const FieldValue & fv, const BoolList & exp); - std::vector performSearch(FieldSearcher & fs, const StringList & query, const FieldValue & fv); - void assertSearch(FieldSearcher & fs, const StringList & query, const FieldValue & fv, const HitsList & exp); +void assertString(StrChrFieldSearcher &fs, const std::string &term, const std::string &field, const Hits &exp) { + assertString(fs, StringList().add(term), field, HitsList().add(exp)); +} +void assertString(StrChrFieldSearcher &fs, const std::string &term, const StringList &field, const Hits &exp) { + assertString(fs, StringList().add(term), field, HitsList().add(exp)); +} - /** string field searcher **/ - bool assertFieldInfo(StrChrFieldSearcher & fs, const std::string & term, const std::string & fv, const QTFieldInfo & exp) { - return assertFieldInfo(fs, StringList().add(term), fv, FieldInfoList().add(exp)); - } - bool assertFieldInfo(StrChrFieldSearcher & fs, const std::string & term, const StringList & fv, const QTFieldInfo & exp) { - return assertFieldInfo(fs, StringList().add(term), fv, FieldInfoList().add(exp)); - } - bool assertFieldInfo(StrChrFieldSearcher & fs, const StringList & query, const std::string & fv, const FieldInfoList & exp) { - return assertFieldInfo(fs, query, StringFieldValue(fv), exp); - } - bool assertFieldInfo(StrChrFieldSearcher & fs, const StringList & query, const StringList & fv, const FieldInfoList & exp) { - return assertFieldInfo(fs, query, getFieldValue(fv), exp); - } +void assertInt(IntFieldSearcher fs, const StringList &query, int64_t field, const BoolList &exp) { + assertNumeric(fs, query, LongFieldValue(field), exp); +} - /** int field searcher **/ - void assertFieldInfo(IntFieldSearcher fs, const std::string & term, int64_t fv, const QTFieldInfo & exp) { - assertFieldInfo(fs, StringList().add(term), fv, FieldInfoList().add(exp)); - } - void assertFieldInfo(IntFieldSearcher fs, const std::string & term, const LongList & fv, const QTFieldInfo & exp) { - assertFieldInfo(fs, StringList().add(term), fv, FieldInfoList().add(exp)); - } - void assertFieldInfo(IntFieldSearcher fs, const StringList & query, int64_t fv, const FieldInfoList & exp) { - assertFieldInfo(fs, query, LongFieldValue(fv), exp); - } - void assertFieldInfo(IntFieldSearcher fs, const StringList & query, const LongList & fv, const FieldInfoList & exp) { - assertFieldInfo(fs, query, getFieldValue(fv), exp); - } +void assertInt(IntFieldSearcher fs, const std::string &term, int64_t field, bool exp) { + assertInt(fs, StringList().add(term), field, BoolList().add(exp)); +} - /** float field searcher **/ - void assertFieldInfo(FloatFieldSearcher fs, const std::string & term, float fv, const QTFieldInfo & exp) { - assertFieldInfo(fs, StringList().add(term), fv, FieldInfoList().add(exp)); - } - void assertFieldInfo(FloatFieldSearcher fs, const std::string & term, const FloatList & fv, const QTFieldInfo & exp) { - assertFieldInfo(fs, StringList().add(term), fv, FieldInfoList().add(exp)); - } - void assertFieldInfo(FloatFieldSearcher fs, const StringList & query, float fv, const FieldInfoList & exp) { - assertFieldInfo(fs, query, FloatFieldValue(fv), exp); - } - void assertFieldInfo(FloatFieldSearcher fs, const StringList & query, const FloatList & fv, const FieldInfoList & exp) { - assertFieldInfo(fs, query, getFieldValue(fv), exp); - } +void assertInt(IntFieldSearcher fs, const StringList &query, const LongList &field, const HitsList &exp) { + assertSearch(fs, query, getFieldValue(field), exp); +} - bool assertFieldInfo(FieldSearcher & fs, const StringList & query, const FieldValue & fv, const FieldInfoList & exp); +void assertInt(IntFieldSearcher fs, const std::string &term, const LongList &field, const Hits &exp) { + assertInt(fs, StringList().add(term), field, HitsList().add(exp)); +} - /** snippet modifer searcher **/ - void assertSnippetModifier(const std::string & term, const std::string & fv, const std::string & exp) { - assertSnippetModifier(StringList().add(term), fv, exp); - } - void assertSnippetModifier(const StringList & query, const std::string & fv, const std::string & exp); - /** snippet modifier **/ - void assertSnippetModifier(SnippetModifierSetup & setup, const FieldValue & fv, const std::string & exp); - void assertQueryTerms(const SnippetModifierManager & man, FieldIdT fId, const StringList & terms); - /** count words **/ - bool assertCountWords(size_t numWords, const std::string & field); +void assertFloat(FloatFieldSearcher fs, const StringList &query, float field, const BoolList &exp) { + assertNumeric(fs, query, FloatFieldValue(field), exp); +} - // test functions - void testParseTerm(); - void testMatchTermSuffix(); - bool testStrChrFieldSearcher(StrChrFieldSearcher & fs); - void testStrChrFieldSearcher(); - bool testUTF8SubStringFieldSearcher(StrChrFieldSearcher & fs); - void testUTF8SubStringFieldSearcher(); - void testUTF8SuffixStringFieldSearcher(); - void testUTF8FlexibleStringFieldSearcher(); - void testUTF8ExactStringFieldSearcher(); - void testIntFieldSearcher(); - void testFloatFieldSearcher(); - bool testStringFieldInfo(StrChrFieldSearcher & fs); - void testSnippetModifierSearcher(); - void testSnippetModifier(); - void testFieldSearchSpec(); - void testSnippetModifierManager(); - void testStripIndexes(); - void requireThatCountWordsIsWorking(); +void assertFloat(FloatFieldSearcher fs, const std::string &term, float field, bool exp) { + assertFloat(fs, StringList().add(term), field, BoolList().add(exp)); +} + +void assertFloat(FloatFieldSearcher fs, const StringList &query, const FloatList &field, const HitsList &exp) { + assertSearch(fs, query, getFieldValue(field), exp); +} + +void assertFloat(FloatFieldSearcher fs, const std::string &term, const FloatList &field, const Hits &exp) { + assertFloat(fs, StringList().add(term), field, HitsList().add(exp)); +} + +bool +assertFieldInfo(StrChrFieldSearcher &fs, const StringList &query, const std::string &fv, const FieldInfoList &exp) { + return assertFieldInfo(fs, query, StringFieldValue(fv), exp); +} + +bool +assertFieldInfo(StrChrFieldSearcher &fs, const StringList &query, const StringList &fv, const FieldInfoList &exp) { + return assertFieldInfo(fs, query, getFieldValue(fv), exp); +} +bool +assertFieldInfo(StrChrFieldSearcher &fs, const std::string &term, const StringList &fv, const QTFieldInfo &exp) { + return assertFieldInfo(fs, StringList().add(term), fv, FieldInfoList().add(exp)); +} + +bool +assertFieldInfo(StrChrFieldSearcher &fs, const std::string &term, const std::string &fv, const QTFieldInfo &exp) { + return assertFieldInfo(fs, StringList().add(term), fv, FieldInfoList().add(exp)); +} + +void assertFieldInfo(IntFieldSearcher fs, const StringList &query, int64_t fv, const FieldInfoList &exp) { + assertFieldInfo(fs, query, LongFieldValue(fv), exp); +} + +void assertFieldInfo(IntFieldSearcher fs, const StringList &query, const LongList &fv, const FieldInfoList &exp) { + assertFieldInfo(fs, query, getFieldValue(fv), exp); +} + +void assertFieldInfo(IntFieldSearcher fs, const std::string &term, int64_t fv, const QTFieldInfo &exp) { + assertFieldInfo(fs, StringList().add(term), fv, FieldInfoList().add(exp)); +} + +void assertFieldInfo(IntFieldSearcher fs, const std::string &term, const LongList &fv, const QTFieldInfo &exp) { + assertFieldInfo(fs, StringList().add(term), fv, FieldInfoList().add(exp)); +} + +void assertFieldInfo(FloatFieldSearcher fs, const StringList &query, float fv, const FieldInfoList &exp) { + assertFieldInfo(fs, query, FloatFieldValue(fv), exp); +} + +void +assertFieldInfo(FloatFieldSearcher fs, const StringList &query, const FloatList &fv, const FieldInfoList &exp) { + assertFieldInfo(fs, query, getFieldValue(fv), exp); +} + +/** float field searcher **/ +void assertFieldInfo(FloatFieldSearcher fs, const std::string &term, float fv, const QTFieldInfo &exp) { + assertFieldInfo(fs, StringList().add(term), fv, FieldInfoList().add(exp)); +} + +void assertFieldInfo(FloatFieldSearcher fs, const std::string &term, const FloatList &fv, const QTFieldInfo &exp) { + assertFieldInfo(fs, StringList().add(term), fv, FieldInfoList().add(exp)); +} + + +/** snippet modifer searcher **/ +void assertSnippetModifier(const std::string &term, const std::string &fv, const std::string &exp) { + assertSnippetModifier(StringList().add(term), fv, exp); +} -public: - int Main(); -}; ArrayFieldValue -SearcherTest::getFieldValue(const StringList & fv) +getFieldValue(const StringList & fv) { static ArrayDataType type(*DataType::STRING); @@ -262,7 +247,7 @@ SearcherTest::getFieldValue(const StringList & fv) } ArrayFieldValue -SearcherTest::getFieldValue(const LongList & fv) +getFieldValue(const LongList & fv) { static ArrayDataType type(*DataType::LONG); ArrayFieldValue afv(type); @@ -273,7 +258,7 @@ SearcherTest::getFieldValue(const LongList & fv) } ArrayFieldValue -SearcherTest::getFieldValue(const FloatList & fv) +getFieldValue(const FloatList & fv) { static ArrayDataType type(*DataType::FLOAT); ArrayFieldValue afv(type); @@ -284,7 +269,7 @@ SearcherTest::getFieldValue(const FloatList & fv) } bool -SearcherTest::assertMatchTermSuffix(const std::string & term, const std::string & word) +assertMatchTermSuffix(const std::string & term, const std::string & word) { EmptyQueryNodeResult eqnr; QueryTerm qa(eqnr, term, "index", QueryTerm::WORD); @@ -297,7 +282,7 @@ SearcherTest::assertMatchTermSuffix(const std::string & term, const std::string } void -SearcherTest::assertNumeric(FieldSearcher & fs, const StringList & query, const FieldValue & fv, const BoolList & exp) +assertNumeric(FieldSearcher & fs, const StringList & query, const FieldValue & fv, const BoolList & exp) { HitsList hl; for (size_t i = 0; i < exp.size(); ++i) { @@ -307,7 +292,7 @@ SearcherTest::assertNumeric(FieldSearcher & fs, const StringList & query, const } std::vector -SearcherTest::performSearch(FieldSearcher & fs, const StringList & query, const FieldValue & fv) +performSearch(FieldSearcher & fs, const StringList & query, const FieldValue & fv) { Query q(query); @@ -328,7 +313,7 @@ SearcherTest::performSearch(FieldSearcher & fs, const StringList & query, const } void -SearcherTest::assertSearch(FieldSearcher & fs, const StringList & query, const FieldValue & fv, const HitsList & exp) +assertSearch(FieldSearcher & fs, const StringList & query, const FieldValue & fv, const HitsList & exp) { std::vector qtv = performSearch(fs, query, fv); EXPECT_EQUAL(qtv.size(), exp.size()); @@ -344,7 +329,7 @@ SearcherTest::assertSearch(FieldSearcher & fs, const StringList & query, const F } bool -SearcherTest::assertFieldInfo(FieldSearcher & fs, const StringList & query, +assertFieldInfo(FieldSearcher & fs, const StringList & query, const FieldValue & fv, const FieldInfoList & exp) { std::vector qtv = performSearch(fs, query, fv); @@ -359,7 +344,7 @@ SearcherTest::assertFieldInfo(FieldSearcher & fs, const StringList & query, } void -SearcherTest::assertSnippetModifier(const StringList & query, const std::string & fv, const std::string & exp) +assertSnippetModifier(const StringList & query, const std::string & fv, const std::string & exp) { UTF8SubstringSnippetModifier mod; performSearch(mod, query, StringFieldValue(fv)); @@ -369,8 +354,7 @@ SearcherTest::assertSnippetModifier(const StringList & query, const std::string EXPECT_EQUAL(actual, exp); } -void -SearcherTest::assertSnippetModifier(SnippetModifierSetup & setup, const FieldValue & fv, const std::string & exp) +void assertSnippetModifier(SnippetModifierSetup & setup, const FieldValue & fv, const std::string & exp) { FieldValue::UP mfv = setup.modifier.modify(fv); const document::LiteralFieldValueB & lfv = static_cast(*mfv.get()); @@ -379,8 +363,7 @@ SearcherTest::assertSnippetModifier(SnippetModifierSetup & setup, const FieldVal EXPECT_EQUAL(actual, exp); } -void -SearcherTest::assertQueryTerms(const SnippetModifierManager & man, FieldIdT fId, const StringList & terms) +void assertQueryTerms(const SnippetModifierManager & man, FieldIdT fId, const StringList & terms) { if (terms.size() == 0) { ASSERT_TRUE(man.getModifiers().getModifier(fId) == NULL); @@ -396,43 +379,42 @@ SearcherTest::assertQueryTerms(const SnippetModifierManager & man, FieldIdT fId, } } -bool -SearcherTest::assertCountWords(size_t numWords, const std::string & field) +bool assertCountWords(size_t numWords, const std::string & field) { FieldRef ref(field.c_str(), field.size()); return EXPECT_EQUAL(numWords, FieldSearcher::countWords(ref)); } -void -SearcherTest::testParseTerm() +bool +testStringFieldInfo(StrChrFieldSearcher & fs) { - ASSERT_TRUE(Query::parseQueryTerm("index:term").first == "index"); - ASSERT_TRUE(Query::parseQueryTerm("index:term").second == "term"); - ASSERT_TRUE(Query::parseQueryTerm("term").first == ""); - ASSERT_TRUE(Query::parseQueryTerm("term").second == "term"); - ASSERT_TRUE(Query::parseTerm("*substr*").first == "substr"); - ASSERT_TRUE(Query::parseTerm("*substr*").second == QueryTerm::SUBSTRINGTERM); - ASSERT_TRUE(Query::parseTerm("*suffix").first == "suffix"); - ASSERT_TRUE(Query::parseTerm("*suffix").second == QueryTerm::SUFFIXTERM); - ASSERT_TRUE(Query::parseTerm("prefix*").first == "prefix"); - ASSERT_TRUE(Query::parseTerm("prefix*").second == QueryTerm::PREFIXTERM); - ASSERT_TRUE(Query::parseTerm("term").first == "term"); - ASSERT_TRUE(Query::parseTerm("term").second == QueryTerm::WORD); -} + assertString(fs, "foo", StringList().add("foo bar baz").add("foo bar").add("baz foo"), Hits().add(0).add(3).add(6)); + assertString(fs, StringList().add("foo").add("bar"), StringList().add("foo bar baz").add("foo bar").add("baz foo"), + HitsList().add(Hits().add(0).add(3).add(6)).add(Hits().add(1).add(4))); -void -SearcherTest::testMatchTermSuffix() -{ - EXPECT_EQUAL(assertMatchTermSuffix("a", "vespa"), true); - EXPECT_EQUAL(assertMatchTermSuffix("spa", "vespa"), true); - EXPECT_EQUAL(assertMatchTermSuffix("vespa", "vespa"), true); - EXPECT_EQUAL(assertMatchTermSuffix("vvespa", "vespa"), false); - EXPECT_EQUAL(assertMatchTermSuffix("fspa", "vespa"), false); - EXPECT_EQUAL(assertMatchTermSuffix("v", "vespa"), false); + bool retval = true; + if (!EXPECT_TRUE(assertFieldInfo(fs, "foo", "foo", QTFieldInfo(0, 1, 1)))) retval = false; + if (!EXPECT_TRUE(assertFieldInfo(fs, "bar", "foo", QTFieldInfo(0, 0, 1)))) retval = false; + if (!EXPECT_TRUE(assertFieldInfo(fs, "foo", "foo bar baz", QTFieldInfo(0, 1, 3)))) retval = false; + if (!EXPECT_TRUE(assertFieldInfo(fs, "bar", "foo bar baz", QTFieldInfo(0, 1, 3)))) retval = false; + if (!EXPECT_TRUE(assertFieldInfo(fs, "baz", "foo bar baz", QTFieldInfo(0, 1, 3)))) retval = false; + if (!EXPECT_TRUE(assertFieldInfo(fs, "qux", "foo bar baz", QTFieldInfo(0, 0, 3)))) retval = false; + if (!EXPECT_TRUE(assertFieldInfo(fs, "foo", "foo foo foo", QTFieldInfo(0, 3, 3)))) retval = false; + // query term size > last term size + if (!EXPECT_TRUE(assertFieldInfo(fs, "runner", "Road Runner Disco", QTFieldInfo(0, 1, 3)))) retval = false; + if (!EXPECT_TRUE(assertFieldInfo(fs, StringList().add("roadrun").add("runner"), "Road Runner Disco", + FieldInfoList().add(QTFieldInfo(0, 0, 3)).add(QTFieldInfo(0, 1, 3))))) retval = false; + // multiple terms + if (!EXPECT_TRUE(assertFieldInfo(fs, "foo", StringList().add("foo bar baz").add("foo bar"), + QTFieldInfo(0, 2, 5)))) retval = false; + if (!EXPECT_TRUE(assertFieldInfo(fs, StringList().add("foo").add("baz"), "foo bar baz", + FieldInfoList().add(QTFieldInfo(0, 1, 3)).add(QTFieldInfo(0, 1, 3))))) retval = false; + if (!EXPECT_TRUE(assertFieldInfo(fs, StringList().add("foo").add("baz"), StringList().add("foo bar baz").add("foo bar"), + FieldInfoList().add(QTFieldInfo(0, 2, 5)).add(QTFieldInfo(0, 1, 5))))) retval = false; + return retval; } - bool -SearcherTest::testStrChrFieldSearcher(StrChrFieldSearcher & fs) +testStrChrFieldSearcher(StrChrFieldSearcher & fs) { std::string field = "operators and operator overloading with utf8 char oe = \xc3\x98"; assertString(fs, "oper", field, Hits()); @@ -469,9 +451,31 @@ SearcherTest::testStrChrFieldSearcher(StrChrFieldSearcher & fs) return true; } -void -SearcherTest::testStrChrFieldSearcher() -{ + TEST("verify correct term parsing") { + ASSERT_TRUE(Query::parseQueryTerm("index:term").first == "index"); + ASSERT_TRUE(Query::parseQueryTerm("index:term").second == "term"); + ASSERT_TRUE(Query::parseQueryTerm("term").first == ""); + ASSERT_TRUE(Query::parseQueryTerm("term").second == "term"); + ASSERT_TRUE(Query::parseTerm("*substr*").first == "substr"); + ASSERT_TRUE(Query::parseTerm("*substr*").second == QueryTerm::SUBSTRINGTERM); + ASSERT_TRUE(Query::parseTerm("*suffix").first == "suffix"); + ASSERT_TRUE(Query::parseTerm("*suffix").second == QueryTerm::SUFFIXTERM); + ASSERT_TRUE(Query::parseTerm("prefix*").first == "prefix"); + ASSERT_TRUE(Query::parseTerm("prefix*").second == QueryTerm::PREFIXTERM); + ASSERT_TRUE(Query::parseTerm("term").first == "term"); + ASSERT_TRUE(Query::parseTerm("term").second == QueryTerm::WORD); + } + + TEST("suffix matching") { + EXPECT_EQUAL(assertMatchTermSuffix("a", "vespa"), true); + EXPECT_EQUAL(assertMatchTermSuffix("spa", "vespa"), true); + EXPECT_EQUAL(assertMatchTermSuffix("vespa", "vespa"), true); + EXPECT_EQUAL(assertMatchTermSuffix("vvespa", "vespa"), false); + EXPECT_EQUAL(assertMatchTermSuffix("fspa", "vespa"), false); + EXPECT_EQUAL(assertMatchTermSuffix("v", "vespa"), false); + } + +TEST("Test basic strchrfield searchers") { { UTF8StrChrFieldSearcher fs(0); EXPECT_TRUE(testStrChrFieldSearcher(fs)); @@ -483,7 +487,7 @@ SearcherTest::testStrChrFieldSearcher() } bool -SearcherTest::testUTF8SubStringFieldSearcher(StrChrFieldSearcher & fs) +testUTF8SubStringFieldSearcher(StrChrFieldSearcher & fs) { std::string field = "operators and operator overloading"; assertString(fs, "rsand", field, Hits()); @@ -502,9 +506,7 @@ SearcherTest::testUTF8SubStringFieldSearcher(StrChrFieldSearcher & fs) return true; } -void -SearcherTest::testUTF8SubStringFieldSearcher() -{ +TEST("utf8 substring search") { { UTF8SubStringFieldSearcher fs(0); EXPECT_TRUE(testUTF8SubStringFieldSearcher(fs)); @@ -525,9 +527,7 @@ SearcherTest::testUTF8SubStringFieldSearcher() } } -void -SearcherTest::testUTF8SuffixStringFieldSearcher() -{ +TEST("utf8 suffix search") { UTF8SuffixStringFieldSearcher fs(0); std::string field = "operators and operator overloading"; assertString(fs, "rsand", field, Hits()); @@ -540,9 +540,7 @@ SearcherTest::testUTF8SuffixStringFieldSearcher() EXPECT_TRUE(testStringFieldInfo(fs)); } -void -SearcherTest::testUTF8ExactStringFieldSearcher() -{ +TEST("utf8 exact match") { UTF8ExactStringFieldSearcher fs(0); // regular TEST_DO(assertString(fs, "vespa", "vespa", Hits().add(0))); @@ -559,9 +557,7 @@ SearcherTest::testUTF8ExactStringFieldSearcher() TEST_DO(assertString(fs, "hütte", "hütter", Hits())); } -void -SearcherTest::testUTF8FlexibleStringFieldSearcher() -{ +TEST("utf8 flexible searcher"){ UTF8FlexibleStringFieldSearcher fs(0); // regular assertString(fs, "vespa", "vespa", Hits().add(0)); @@ -590,8 +586,7 @@ SearcherTest::testUTF8FlexibleStringFieldSearcher() EXPECT_TRUE(testStringFieldInfo(fs)); } -void -SearcherTest::testIntFieldSearcher() +TEST("integre search") { IntFieldSearcher fs; assertInt(fs, "10", 10, true); @@ -625,8 +620,7 @@ SearcherTest::testIntFieldSearcher() FieldInfoList().add(QTFieldInfo(0, 2, 4)).add(QTFieldInfo(0, 1, 4))); } -void -SearcherTest::testFloatFieldSearcher() +TEST("floating point search") { FloatFieldSearcher fs; assertFloat(fs, "10", 10, true); @@ -661,38 +655,7 @@ SearcherTest::testFloatFieldSearcher() FieldInfoList().add(QTFieldInfo(0, 2, 4)).add(QTFieldInfo(0, 1, 4))); } -bool -SearcherTest::testStringFieldInfo(StrChrFieldSearcher & fs) -{ - assertString(fs, "foo", StringList().add("foo bar baz").add("foo bar").add("baz foo"), Hits().add(0).add(3).add(6)); - assertString(fs, StringList().add("foo").add("bar"), StringList().add("foo bar baz").add("foo bar").add("baz foo"), - HitsList().add(Hits().add(0).add(3).add(6)).add(Hits().add(1).add(4))); - - bool retval = true; - if (!EXPECT_TRUE(assertFieldInfo(fs, "foo", "foo", QTFieldInfo(0, 1, 1)))) retval = false; - if (!EXPECT_TRUE(assertFieldInfo(fs, "bar", "foo", QTFieldInfo(0, 0, 1)))) retval = false; - if (!EXPECT_TRUE(assertFieldInfo(fs, "foo", "foo bar baz", QTFieldInfo(0, 1, 3)))) retval = false; - if (!EXPECT_TRUE(assertFieldInfo(fs, "bar", "foo bar baz", QTFieldInfo(0, 1, 3)))) retval = false; - if (!EXPECT_TRUE(assertFieldInfo(fs, "baz", "foo bar baz", QTFieldInfo(0, 1, 3)))) retval = false; - if (!EXPECT_TRUE(assertFieldInfo(fs, "qux", "foo bar baz", QTFieldInfo(0, 0, 3)))) retval = false; - if (!EXPECT_TRUE(assertFieldInfo(fs, "foo", "foo foo foo", QTFieldInfo(0, 3, 3)))) retval = false; - // query term size > last term size - if (!EXPECT_TRUE(assertFieldInfo(fs, "runner", "Road Runner Disco", QTFieldInfo(0, 1, 3)))) retval = false; - if (!EXPECT_TRUE(assertFieldInfo(fs, StringList().add("roadrun").add("runner"), "Road Runner Disco", - FieldInfoList().add(QTFieldInfo(0, 0, 3)).add(QTFieldInfo(0, 1, 3))))) retval = false; - // multiple terms - if (!EXPECT_TRUE(assertFieldInfo(fs, "foo", StringList().add("foo bar baz").add("foo bar"), - QTFieldInfo(0, 2, 5)))) retval = false; - if (!EXPECT_TRUE(assertFieldInfo(fs, StringList().add("foo").add("baz"), "foo bar baz", - FieldInfoList().add(QTFieldInfo(0, 1, 3)).add(QTFieldInfo(0, 1, 3))))) retval = false; - if (!EXPECT_TRUE(assertFieldInfo(fs, StringList().add("foo").add("baz"), StringList().add("foo bar baz").add("foo bar"), - FieldInfoList().add(QTFieldInfo(0, 2, 5)).add(QTFieldInfo(0, 1, 5))))) retval = false; - return retval; -} - -void -SearcherTest::testSnippetModifierSearcher() -{ +TEST("Snippet modifier search") { // ascii assertSnippetModifier("f", "foo", "\x1F""f\x1Foo"); assertSnippetModifier("o", "foo", "f\x1Fo\x1F\x1Fo\x1F"); @@ -735,9 +698,7 @@ SearcherTest::testSnippetModifierSearcher() } } -void -SearcherTest::testSnippetModifier() -{ +TEST("snippet modifier") { { // string field value SnippetModifierSetup sms(StringList().add("ab")); // multiple invokations @@ -765,9 +726,7 @@ SearcherTest::testSnippetModifier() } } -void -SearcherTest::testFieldSearchSpec() -{ +TEST("FieldSearchSpec constrution") { { FieldSearchSpec f; EXPECT_FALSE(f.valid()); @@ -785,9 +744,7 @@ SearcherTest::testFieldSearchSpec() } } -void -SearcherTest::testSnippetModifierManager() -{ +TEST("snippet modifier manager") { FieldSearchSpecMapT specMap; specMap[0] = FieldSearchSpec(0, "f0", VsmfieldsConfig::Fieldspec::AUTOUTF8, "substring", 1000); specMap[1] = FieldSearchSpec(1, "f1", VsmfieldsConfig::Fieldspec::AUTOUTF8, "", 1000); @@ -844,8 +801,7 @@ SearcherTest::testSnippetModifierManager() } } -void -SearcherTest::testStripIndexes() +TEST("Stripping of indexes") { EXPECT_EQUAL("f", FieldSearchSpecMap::stripNonFields("f")); EXPECT_EQUAL("f", FieldSearchSpecMap::stripNonFields("f[0]")); @@ -857,9 +813,7 @@ SearcherTest::testStripIndexes() EXPECT_EQUAL("f.value", FieldSearchSpecMap::stripNonFields("f{\"a 0\"}")); } -void -SearcherTest::requireThatCountWordsIsWorking() -{ +TEST("counting of words") { EXPECT_TRUE(assertCountWords(0, "")); EXPECT_TRUE(assertCountWords(0, "?")); EXPECT_TRUE(assertCountWords(1, "foo")); @@ -874,32 +828,6 @@ SearcherTest::requireThatCountWordsIsWorking() assertString(fs, StringList().add("bb").add("not"), field, HitsList().add(Hits().add(2)).add(Hits())); } -int -SearcherTest::Main() -{ - TEST_INIT("searcher_test"); - - testFieldSearchSpec(); - testParseTerm(); - testMatchTermSuffix(); - testStrChrFieldSearcher(); - testUTF8SubStringFieldSearcher(); - testUTF8SuffixStringFieldSearcher(); - testUTF8FlexibleStringFieldSearcher(); - testUTF8ExactStringFieldSearcher(); - testIntFieldSearcher(); - testFloatFieldSearcher(); - - testSnippetModifierSearcher(); - testSnippetModifier(); - testSnippetModifierManager(); - testStripIndexes(); - requireThatCountWordsIsWorking(); - - TEST_DONE(); -} - -} -TEST_APPHOOK(vsm::SearcherTest); +TEST_MAIN() { TEST_RUN_ALL(); } -- cgit v1.2.3