TEST_F(DateSortTest, testReverseDateSort) {
IndexSearcherPtr searcher = newLucene<IndexSearcher>(directory, true);
SortPtr sort = newLucene<Sort>(newLucene<SortField>(DATE_TIME_FIELD, SortField::STRING, true));
QueryParserPtr queryParser = newLucene<QueryParser>(LuceneVersion::LUCENE_CURRENT, TEXT_FIELD, newLucene<WhitespaceAnalyzer>());
QueryPtr query = queryParser->parse(L"Document");
// Execute the search and process the search results.
Collection<String> actualOrder = Collection<String>::newInstance(5);
Collection<ScoreDocPtr>hits = searcher->search(query, FilterPtr(), 1000, sort)->scoreDocs;
for (int32_t i = 0; i < hits.size(); ++i) {
DocumentPtr document = searcher->doc(hits[i]->doc);
String text = document->get(TEXT_FIELD);
actualOrder[i] = text;
}
searcher->close();
// Set up the expected order (ie. Document 5, 4, 3, 2, 1).
Collection<String> expectedOrder = Collection<String>::newInstance(5);
expectedOrder[0] = L"Document 5";
expectedOrder[1] = L"Document 4";
expectedOrder[2] = L"Document 3";
expectedOrder[3] = L"Document 2";
expectedOrder[4] = L"Document 1";
EXPECT_TRUE(expectedOrder.equals(actualOrder));
}
void checkAllQueries(const MemoryIndexPtr& memory, const RAMDirectoryPtr& ramdir, const AnalyzerPtr& analyzer) {
IndexSearcherPtr ram = newLucene<IndexSearcher>(ramdir);
IndexSearcherPtr mem = memory->createSearcher();
QueryParserPtr qp = newLucene<QueryParser>(LuceneVersion::LUCENE_CURRENT, L"foo", analyzer);
for (HashSet<String>::iterator query = queries.begin(); query != queries.end(); ++query) {
TopDocsPtr ramDocs = ram->search(qp->parse(*query), 1);
TopDocsPtr memDocs = mem->search(qp->parse(*query), 1);
EXPECT_EQ(ramDocs->totalHits, memDocs->totalHits);
}
}
/// checks if a query yields the same result when executed on a single IndexSearcher containing all
/// documents and on MultiSearcher aggregating sub-searchers
/// @param queryStr the query to check.
void checkQuery(const String& queryStr)
{
QueryParserPtr queryParser = newLucene<QueryParser>(LuceneVersion::LUCENE_CURRENT, FIELD_NAME, newLucene<StandardAnalyzer>(LuceneVersion::LUCENE_CURRENT));
QueryPtr query = queryParser->parse(queryStr);
Collection<ScoreDocPtr> multiSearcherHits = multiSearcher->search(query, FilterPtr(), 1000)->scoreDocs;
Collection<ScoreDocPtr> singleSearcherHits = singleSearcher->search(query, FilterPtr(), 1000)->scoreDocs;
BOOST_CHECK_EQUAL(multiSearcherHits.size(), singleSearcherHits.size());
for (int32_t i = 0; i < multiSearcherHits.size(); ++i)
{
DocumentPtr docMulti = multiSearcher->doc(multiSearcherHits[i]->doc);
DocumentPtr docSingle = singleSearcher->doc(singleSearcherHits[i]->doc);
BOOST_CHECK_CLOSE_FRACTION(multiSearcherHits[i]->score, singleSearcherHits[i]->score, 0.001);
BOOST_CHECK_EQUAL(docMulti->get(FIELD_NAME), docSingle->get(FIELD_NAME));
}
}
TEST_F(SimpleExplanationsOfNonMatchesTest, testTermQueryMultiSearcherExplain) {
// creating two directories for indices
DirectoryPtr indexStoreA = newLucene<MockRAMDirectory>();
DirectoryPtr indexStoreB = newLucene<MockRAMDirectory>();
DocumentPtr lDoc = newLucene<Document>();
lDoc->add(newLucene<Field>(L"handle", L"1 2", Field::STORE_YES, Field::INDEX_ANALYZED));
DocumentPtr lDoc2 = newLucene<Document>();
lDoc2->add(newLucene<Field>(L"handle", L"1 2", Field::STORE_YES, Field::INDEX_ANALYZED));
DocumentPtr lDoc3 = newLucene<Document>();
lDoc3->add(newLucene<Field>(L"handle", L"1 2", Field::STORE_YES, Field::INDEX_ANALYZED));
IndexWriterPtr writerA = newLucene<IndexWriter>(indexStoreA, newLucene<StandardAnalyzer>(LuceneVersion::LUCENE_CURRENT), true, IndexWriter::MaxFieldLengthLIMITED);
IndexWriterPtr writerB = newLucene<IndexWriter>(indexStoreB, newLucene<StandardAnalyzer>(LuceneVersion::LUCENE_CURRENT), true, IndexWriter::MaxFieldLengthLIMITED);
writerA->addDocument(lDoc);
writerA->addDocument(lDoc2);
writerA->optimize();
writerA->close();
writerB->addDocument(lDoc3);
writerB->close();
QueryParserPtr parser = newLucene<QueryParser>(LuceneVersion::LUCENE_CURRENT, L"fulltext", newLucene<StandardAnalyzer>(LuceneVersion::LUCENE_CURRENT));
QueryPtr query = parser->parse(L"handle:1");
Collection<SearchablePtr> searchers = newCollection<SearchablePtr>(
newLucene<IndexSearcher>(indexStoreB, true),
newLucene<IndexSearcher>(indexStoreA, true)
);
SearcherPtr mSearcher = newLucene<MultiSearcher>(searchers);
Collection<ScoreDocPtr> hits = mSearcher->search(query, FilterPtr(), 1000)->scoreDocs;
EXPECT_EQ(3, hits.size());
ExplanationPtr explain = mSearcher->explain(query, hits[0]->doc);
String exp = explain->toString();
EXPECT_TRUE(exp.find(L"maxDocs=3") != String::npos);
EXPECT_TRUE(exp.find(L"docFreq=3") != String::npos);
query = parser->parse(L"handle:\"1 2\"");
hits = mSearcher->search(query, FilterPtr(), 1000)->scoreDocs;
EXPECT_EQ(3, hits.size());
explain = mSearcher->explain(query, hits[0]->doc);
exp = explain->toString();
EXPECT_TRUE(exp.find(L"1=3") != String::npos);
EXPECT_TRUE(exp.find(L"2=3") != String::npos);
query = newLucene<SpanNearQuery>(newCollection<SpanQueryPtr>(newLucene<SpanTermQuery>(newLucene<Term>(L"handle", L"1")), newLucene<SpanTermQuery>(newLucene<Term>(L"handle", L"2"))), 0, true);
hits = mSearcher->search(query, FilterPtr(), 1000)->scoreDocs;
EXPECT_EQ(3, hits.size());
explain = mSearcher->explain(query, hits[0]->doc);
exp = explain->toString();
EXPECT_TRUE(exp.find(L"1=3") != String::npos);
EXPECT_TRUE(exp.find(L"2=3") != String::npos);
mSearcher->close();
}
