void testEqualScores()
{
// NOTE: uses index build in *this* setUp
IndexReader * pReader = IndexReader::open( m_pSmall );
IndexSearcher * pSearch = _CLNEW IndexSearcher( pReader );
Hits * pResult;
// some hits match more terms then others, score should be the same
Query * q = csrq( _T( "data" ), _T( "1" ), _T( "6" ), true, true );
pResult = pSearch->search( q );
size_t numHits = pResult->length();
assertEqualsMsg( _T( "wrong number of results" ), 6, numHits );
float_t score = pResult->score( 0 );
for( size_t i = 1; i < numHits; i++ )
{
assertTrueMsg( _T( "score was not the same" ), score == pResult->score( i ));
}
_CLDELETE( pResult );
_CLDELETE( q );
pSearch->close();
_CLDELETE( pSearch );
pReader->close();
_CLDELETE( pReader );
}
/**
* Verifies that the index has the correct number of documents.
*/
void TestSpansAdvanced2::testVerifyIndex()
{
IndexReader * reader = IndexReader::open( directory );
assertEquals( 8, reader->numDocs() );
reader->close();
_CLDELETE( reader );
}
void createIndex(CuTest* tc, Directory* dir, bool multiSegment) {
WhitespaceAnalyzer whitespaceAnalyzer;
IndexWriter w(dir, &whitespaceAnalyzer, true);
w.setMergePolicy(_CLNEW LogDocMergePolicy());
Document doc;
for (int i = 0; i < 100; i++) {
createDocument(doc, i, 4);
w.addDocument(&doc);
if (multiSegment && (i % 10) == 0) {
w.flush();
}
}
if (!multiSegment) {
w.optimize();
}
w.close();
IndexReader* r = IndexReader::open(dir);
if (multiSegment) {
CuAssert(tc,_T("check is multi"), strcmp(r->getObjectName(),"MultiSegmentReader")==0);
} else {
CuAssert(tc,_T("check is segment"), strcmp(r->getObjectName(),"SegmentReader")==0);
}
r->close();
_CLDELETE(r);
}
// BK> all test functions are the same except RAMDirectory constructor, so shared code moved here
void checkDir(CuTest *tc, MockRAMDirectory * ramDir) {
// Check size
CuAssertTrue(tc, ramDir->sizeInBytes == ramDir->getRecomputedSizeInBytes(), _T("RAMDir size"));
// open reader to test document count
IndexReader * reader = IndexReader::open(ramDir);
CuAssertEquals(tc, docsToAdd, reader->numDocs(), _T("document count"));
// open search to check if all doc's are there
IndexSearcher * searcher = _CLNEW IndexSearcher(reader);
// search for all documents
Document doc;
for (int i = 0; i < docsToAdd; i++) {
searcher->doc(i, doc);
CuAssertTrue(tc, doc.getField(_T("content")) != NULL, _T("content is NULL"));
}
// cleanup
reader->close();
searcher->close();
_CLLDELETE(reader);
_CLLDELETE(searcher);
}
_LUCENE_THREAD_FUNC(atomicSearchTest, _directory){
Directory* directory = (Directory*)_directory;
uint64_t stopTime = Misc::currentTimeMillis() + 1000*ATOMIC_SEARCH_RUN_TIME_SEC;
int count = 0;
try {
while(Misc::currentTimeMillis() < stopTime && !atomicSearchFailed) {
IndexReader* r = IndexReader::open(directory);
try {
if ( 100 != r->numDocs() ){
fprintf(stderr, "err 2: 100 != %d \n", r->numDocs());
atomicSearchFailed = true;
}
} catch (CLuceneError& e) {
fprintf(stderr, "err 3: %d:%s\n", e.number(), e.what());
atomicSearchFailed = true;
break;
}
r->close();
_CLDELETE(r);
count++;
}
} catch (CLuceneError& e) {
fprintf(stderr, "err 4: #%d: %s\n", e.number(), e.what());
atomicSearchFailed = true;
}
_LUCENE_THREAD_FUNC_RETURN(0);
}
void testExtractFromWildcardQuery( CuTest * tc )
{
Directory * pIndex = setUpIndex();
IndexReader * pReader = IndexReader::open( pIndex );
TermSet termSet;
WildcardQuery * wildcard;
Term * t1;
Query * rewrite;
t1 = _CLNEW Term( _T("data"), _T("aaaa?") );
wildcard = _CLNEW WildcardQuery( t1 );
rewrite = wildcard->rewrite( pReader );
rewrite->extractTerms( &termSet );
_CLLDECDELETE( t1 );
assertEqualsMsg( _T( "wrong number of terms" ), 3, termSet.size() );
for( TermSet::iterator itTerms = termSet.begin(); itTerms != termSet.end(); itTerms++ )
{
Term * pTerm = *itTerms;
if( 0 != _tcscmp( _T( "aaaaa" ), pTerm->text())
&& 0 != _tcscmp( _T( "aaaab" ), pTerm->text())
&& 0 != _tcscmp( _T( "aaaac" ), pTerm->text()))
{
assertTrueMsg( _T( "wrong term" ), false );
}
}
clearTermSet( termSet );
if( rewrite != wildcard )
_CLDELETE( rewrite );
_CLDELETE( wildcard );
t1 = _CLNEW Term( _T("data"), _T("aaa*") );
wildcard = _CLNEW WildcardQuery( t1 );
rewrite = wildcard->rewrite( pReader );
rewrite->extractTerms( &termSet );
_CLLDECDELETE( t1 );
assertEqualsMsg( _T( "wrong number of terms" ), 5, termSet.size() );
for( TermSet::iterator itTerms = termSet.begin(); itTerms != termSet.end(); itTerms++ )
{
Term * pTerm = *itTerms;
assertTrueMsg( _T( "wrong term" ), ( 0 == _tcsncmp( _T( "aaa" ), pTerm->text(), 3 )));
}
clearTermSet( termSet );
if( rewrite != wildcard )
_CLDELETE( rewrite );
_CLDELETE( wildcard );
pReader->close();
_CLDELETE( pReader );
closeIndex( pIndex );
pIndex = NULL;
}
void testBoost()
{
// NOTE: uses index build in *this* setUp
IndexReader * pReader = IndexReader::open( m_pSmall );
IndexSearcher * pSearch = _CLNEW IndexSearcher( pReader );
Hits * pResult;
// test for correct application of query normalization
// must use a non score normalizing method for this.
Query * q = csrq( _T( "data" ), _T( "1" ), _T( "6" ), true, true );
q->setBoost( 100 );
pResult = pSearch->search( q );
for( size_t i = 1; i < pResult->length(); i++ )
{
assertTrueMsg( _T( "score was not was not correct" ), 1.0f == pResult->score( i ));
}
_CLDELETE( pResult );
_CLDELETE( q );
//
// Ensure that boosting works to score one clause of a query higher
// than another.
//
Query * q1 = csrq( _T( "data" ), _T( "A" ), _T( "A" ), true, true ); // matches document #0
q1->setBoost( .1f );
Query * q2 = csrq( _T( "data" ), _T( "Z" ), _T( "Z" ), true, true ); // matches document #1
BooleanQuery * bq = _CLNEW BooleanQuery( true );
bq->add( q1, true, BooleanClause::SHOULD );
bq->add( q2, true, BooleanClause::SHOULD );
pResult = pSearch->search( bq );
assertEquals( 1, pResult->id( 0 ));
assertEquals( 0, pResult->id( 1 ));
assertTrue( pResult->score( 0 ) > pResult->score( 1 ));
_CLDELETE( pResult );
_CLDELETE( bq );
q1 = csrq( _T( "data" ), _T( "A" ), _T( "A" ), true, true ); // matches document #0
q1->setBoost( 10.0f );
q2 = csrq( _T( "data" ), _T( "Z" ), _T( "Z" ), true, true ); // matches document #1
bq = _CLNEW BooleanQuery( true );
bq->add( q1, true, BooleanClause::SHOULD );
bq->add( q2, true, BooleanClause::SHOULD );
pResult = pSearch->search( bq );
assertEquals( 0, pResult->id( 0 ));
assertEquals( 1, pResult->id( 1 ));
assertTrue( pResult->score( 0 ) > pResult->score( 1 ));
_CLDELETE( pResult );
_CLDELETE( bq );
pSearch->close();
_CLDELETE( pSearch );
pReader->close();
_CLDELETE( pReader );
}
static void verifyNumDocs(CuTest *tc, Directory * dir, int numDocs) {
IndexReader * reader = IndexReader::open(dir);
assertEquals(numDocs, reader->maxDoc());
assertEquals(numDocs, reader->numDocs());
reader->close();
_CLLDELETE(reader);
}
void SegmentMerger::closeReaders()
{
for (uint32_t i = 0; i < readers.size(); i++) {
// close readers
IndexReader* reader = readers[i];
reader->close();
}
}
void SearchFilesC(const char* index, const char* fobizzle){
standard::StandardAnalyzer analyzer;
char line[80];
TCHAR tline[80];
TCHAR* buf;
IndexReader* reader = IndexReader::open(index);
//printf("Enter query string: ");
strncpy(line,fobizzle,80);
//line[strlen(line)-1]=0;
IndexReader* newreader = reader->reopen();
if ( newreader != reader ){
_CLLDELETE(reader);
reader = newreader;
}
IndexSearcher s(reader);
STRCPY_AtoT(tline,line,80);
Query* q = QueryParser::parse(tline,_T("contents"),&analyzer);
buf = q->toString(_T("contents"));
_tprintf(_T("Searching for: %S\n\n"), buf);
_CLDELETE_LCARRAY(buf);
uint64_t str = Misc::currentTimeMillis();
Hits* h = s.search(q);
uint32_t srch = (int32_t)(Misc::currentTimeMillis() - str);
str = Misc::currentTimeMillis();
//SearchData search[h->length()];
for ( size_t i=0; i < h->length(); i++ ){
Document* doc = &h->doc(i);
//const TCHAR* buf = doc.get(_T("contents"));
_tprintf(_T("%d. %S - %f\n"), i, doc->get(_T("path")), h->score(i));
//search[i].set_path(doc->get(_T("path")));
}
printf("\n\nSearch took: %d ms.\n", srch);
printf("Screen dump took: %d ms.\n\n", (int32_t)(Misc::currentTimeMillis() - str));
_CLLDELETE(h);
_CLLDELETE(q);
s.close();
reader->close();
_CLLDELETE(reader);
};
void SearchFiles(const char* index){
standard::StandardAnalyzer analyzer;
char line[80];
TCHAR tline[80];
TCHAR* buf;
IndexReader* reader = IndexReader::open(index);
while (true) {
printf("Enter query string: ");
char* tmp = fgets(line,80,stdin);
if ( tmp == NULL ) continue;
line[strlen(line)-1]=0;
IndexReader* newreader = reader->reopen();
if ( newreader != reader ){
_CLLDELETE(reader);
reader = newreader;
}
IndexSearcher s(reader);
if ( strlen(line) == 0 )
break;
STRCPY_AtoT(tline,line,80);
Query* q = QueryParser::parse(tline,_T("contents"),&analyzer);
buf = q->toString(_T("contents"));
_tprintf(_T("Searching for: %s\n\n"), buf);
_CLDELETE_LCARRAY(buf);
uint64_t str = Misc::currentTimeMillis();
Hits* h = s.search(q);
uint32_t srch = (int32_t)(Misc::currentTimeMillis() - str);
str = Misc::currentTimeMillis();
for ( size_t i=0;i<h->length();i++ ){
Document* doc = &h->doc(i);
//const TCHAR* buf = doc.get(_T("contents"));
_tprintf(_T("%d. %s - %f\n"), i, doc->get(_T("path")), h->score(i));
//print result to web interface:
LINH_PRINT_WEB(i,doc->get(_T("path")),h->score(i));
}
printf("\n\nSearch took: %d ms.\n", srch);
printf("Screen dump took: %d ms.\n\n", (int32_t)(Misc::currentTimeMillis() - str));
_CLLDELETE(h);
_CLLDELETE(q);
s.close();
}
reader->close();
_CLLDELETE(reader);
}
static void verifyTermDocs(CuTest *tc, Directory * dir, Term * term, int numDocs) {
IndexReader * reader = IndexReader::open(dir);
TermDocs * termDocs = reader->termDocs(term);
int count = 0;
while (termDocs->next())
count++;
assertEquals(numDocs, count);
termDocs->close();
_CLLDELETE(termDocs);
reader->close();
_CLLDELETE(reader);
}
// case 4: tail segments, invariants hold, copy, invariants not hold
void testMergeAfterCopy(CuTest * tc) {
// main directory
Directory * dir = _CLNEW RAMDirectory();
// auxiliary directory
Directory * aux = _CLNEW RAMDirectory();
WhitespaceAnalyzer an;
setUpDirs(tc, dir, aux);
IndexReader * reader = IndexReader::open(aux);
for (int i = 0; i < 20; i++) {
reader->deleteDocument(i);
}
assertEquals(10, reader->numDocs());
reader->close();
_CLLDELETE(reader);
IndexWriter4Test * writer = newWriter(dir, &an, false);
writer->setMaxBufferedDocs(4);
writer->setMergeFactor(4);
ValueArray<Directory*> dirs(2);
dirs[0] = aux;
dirs[1] = aux;
writer->addIndexesNoOptimize(dirs);
assertEquals(1020, writer->docCount());
assertEquals(1000, writer->getDocCount(0));
writer->close();
_CLLDELETE(writer);
// make sure the index is correct
verifyNumDocs(tc, dir, 1020);
dir->close();
_CLLDELETE(dir);
aux->close();
_CLLDELETE(aux);
}
void testBooleanOrderUnAffected()
{
// NOTE: uses index build in *this* setUp
IndexReader * pReader = IndexReader::open( m_pSmall );
IndexSearcher * pSearch = _CLNEW IndexSearcher( pReader );
// first do a regular RangeQuery which uses term expansion so
// docs with more terms in range get higher scores
Term * pLower = _CLNEW Term( _T( "data" ), _T( "1" ));
Term * pUpper = _CLNEW Term( _T( "data" ), _T( "4" ));
Query * rq = _CLNEW RangeQuery( pLower, pUpper, true );
_CLLDECDELETE( pUpper );
_CLLDECDELETE( pLower );
Hits * pExpected = pSearch->search( rq );
size_t numHits = pExpected->length();
// now do a boolean where which also contains a
// ConstantScoreRangeQuery and make sure the order is the same
BooleanQuery * q = _CLNEW BooleanQuery();
q->add( rq, true, BooleanClause::MUST );
q->add( csrq( _T( "data" ), _T( "1" ), _T( "6" ), true, true ), true, BooleanClause::MUST );
Hits * pActual = pSearch->search( q );
assertEqualsMsg( _T( "wrong number of hits" ), numHits, pActual->length() );
for( size_t i = 0; i < numHits; i++ )
{
assertEqualsMsg( _T( "mismatch in docid for a hit" ), pExpected->id( i ), pActual->id( i ));
}
_CLDELETE( pActual );
_CLDELETE( pExpected );
_CLDELETE( q );
pSearch->close();
_CLDELETE( pSearch );
pReader->close();
_CLDELETE( pReader );
}
void testExtractFromFuzzyQuery( CuTest * tc )
{
Directory * pIndex = setUpIndex();
IndexReader * pReader = IndexReader::open( pIndex );
TermSet termSet;
FuzzyQuery * fuzzy;
Term * t1;
Query * rewrite;
t1 = _CLNEW Term( _T("data"), _T("aaaab") );
fuzzy = _CLNEW FuzzyQuery( t1, 0.7f );
rewrite = fuzzy->rewrite( pReader );
rewrite->extractTerms( &termSet );
_CLLDECDELETE( t1 );
assertEqualsMsg( _T( "wrong number of terms" ), 4, termSet.size() );
for( TermSet::iterator itTerms = termSet.begin(); itTerms != termSet.end(); itTerms++ )
{
Term * pTerm = *itTerms;
if( 0 != _tcscmp( _T( "aaaaa" ), pTerm->text())
&& 0 != _tcscmp( _T( "aaaab" ), pTerm->text())
&& 0 != _tcscmp( _T( "aaabb" ), pTerm->text())
&& 0 != _tcscmp( _T( "aaaac" ), pTerm->text()))
{
assertTrueMsg( _T( "wrong term" ), false );
}
}
clearTermSet( termSet );
if( rewrite != fuzzy )
_CLDELETE( rewrite );
_CLDELETE( fuzzy );
pReader->close();
_CLDELETE( pReader );
closeIndex( pIndex );
pIndex = NULL;
}
void testExtractFromTermQuery( CuTest * tc )
{
Directory * pIndex = setUpIndex();
IndexReader * pReader = IndexReader::open( pIndex );
TermSet termSet;
Term * t1 = _CLNEW Term( _T("data"), _T("aaaaa") );
Term * t2 = _CLNEW Term( _T("data"), _T("bbbbb") );
Query * q1 = _CLNEW TermQuery( t1 );
Query * q2 = _CLNEW TermQuery( t2 );
Query * rewrite1 = q1->rewrite( pReader );
Query * rewrite2 = q2->rewrite( pReader );
rewrite1->extractTerms( &termSet );
assertEqualsMsg( _T( "wrong number of terms" ), 1, termSet.size() );
assertEqualsMsg( _T( "wrong term" ), 0, t1->compareTo( *(termSet.begin())) );
clearTermSet( termSet );
rewrite2->extractTerms( &termSet );
assertEqualsMsg( _T( "wrong number of terms" ), 1, termSet.size() );
assertEqualsMsg( _T( "wrong term" ), 0, t2->compareTo( *(termSet.begin())) );
clearTermSet( termSet );
_CLLDECDELETE( t1 );
_CLLDECDELETE( t2 );
if( q1 != rewrite1 )
_CLDELETE( rewrite1 );
_CLDELETE( q1 );
if( q2 != rewrite2 )
_CLDELETE( rewrite2 );
_CLDELETE( q2 );
pReader->close();
_CLDELETE( pReader );
closeIndex( pIndex );
pIndex = NULL;
}
void testExtractFromBooleanQuery( CuTest * tc )
{
Directory * pIndex = setUpIndex();
IndexReader * pReader = IndexReader::open( pIndex );
TermSet termSet;
Term * t1 = _CLNEW Term( _T("data"), _T("aaaab") );
Term * t2 = _CLNEW Term( _T("data"), _T("aaabb") );
Term * t3 = _CLNEW Term( _T("data"), _T("aaabb") );
BooleanQuery * bq = _CLNEW BooleanQuery();
bq->add( _CLNEW TermQuery( t1 ), true, BooleanClause::SHOULD );
bq->add( _CLNEW TermQuery( t2 ), true, BooleanClause::SHOULD );
bq->add( _CLNEW TermQuery( t3 ), true, BooleanClause::SHOULD );
Query * rewrite = bq->rewrite( pReader );
rewrite->extractTerms( &termSet );
assertEqualsMsg( _T( "wrong number of terms" ), 2, termSet.size() );
for( TermSet::iterator itTerms = termSet.begin(); itTerms != termSet.end(); itTerms++ )
{
Term * pTerm = *itTerms;
assertTrueMsg( _T( "wrong term" ), ( 0 == t1->compareTo( pTerm ) || 0 == t2->compareTo( pTerm )));
}
clearTermSet( termSet );
_CLLDECDELETE( t1 );
_CLLDECDELETE( t2 );
_CLLDECDELETE( t3 );
if( rewrite != bq )
_CLDELETE( rewrite );
_CLDELETE( bq );
pReader->close();
_CLDELETE( pReader );
closeIndex( pIndex );
pIndex = NULL;
}
/////////////////////////////////////////////////////////////////////////////
// CLucene specific
// Visual Studio 2005 shows memory leaks for this test, but some other
// tools do not detect any memory leaks. So what is right?
// IN VC80 shows memory leaks ONLY if both sub-queries are added as
// MUST BooleanClauses.
void testBooleanMemLeaks()
{
IndexReader * pReader = IndexReader::open( m_pSmall );
IndexSearcher * pSearch = _CLNEW IndexSearcher( pReader );
Query * q1 = csrq( _T( "data" ), _T( "A" ), _T( "A" ), true, true ); // matches document #0
Query * q2 = csrq( _T( "data" ), _T( "Z" ), _T( "Z" ), true, true ); // matches document #1
BooleanQuery * bq = _CLNEW BooleanQuery( true );
bq->add( q1, true, BooleanClause::MUST );
bq->add( q2, true, BooleanClause::MUST );
Hits * pResult = pSearch->search( bq );
_CLDELETE( pResult );
_CLDELETE( bq );
pSearch->close();
_CLDELETE( pSearch );
pReader->close();
_CLDELETE( pReader );
}
void testRangeFilterId() {
IndexReader* reader = IndexReader::open(index);
IndexSearcher* search = new IndexSearcher(reader);
int medId = ((maxId - minId) / 2);
std::tstring minIPstr = pad(minId);
const TCHAR* minIP = minIPstr.c_str();
std::tstring maxIPstr = pad(maxId);
const TCHAR* maxIP = maxIPstr.c_str();
std::tstring medIPstr = pad(medId);
const TCHAR* medIP = medIPstr.c_str();
size_t numDocs = static_cast<size_t>(reader->numDocs());
assertEqualsMsg(_T("num of docs"), numDocs, static_cast<size_t>(1+ maxId - minId));
Hits* result;
Term* term = _CLNEW Term(_T("body"),_T("body"));
Query* q = _CLNEW TermQuery(term);
_CLDECDELETE(term);
// test id, bounded on both ends
Filter* f = _CLNEW RangeFilter(_T("id"),minIP,maxIP,T,T);
result = search->search(q, f);
assertEqualsMsg(_T("find all"), numDocs, result->length());
_CLLDELETE(result);
_CLLDELETE(f);
f=_CLNEW RangeFilter(_T("id"),minIP,maxIP,T,F);
result = search->search(q,f);
assertEqualsMsg(_T("all but last"), numDocs-1, result->length());
_CLLDELETE(result);
_CLLDELETE(f);
f =_CLNEW RangeFilter(_T("id"),minIP,maxIP,F,T);
result = search->search(q,f);
assertEqualsMsg(_T("all but first"), numDocs-1, result->length());
_CLLDELETE(result);
_CLLDELETE(f);
f=_CLNEW RangeFilter(_T("id"),minIP,maxIP,F,F);
result = search->search(q,f);
assertEqualsMsg(_T("all but ends"), numDocs-2, result->length());
_CLLDELETE(result);
_CLLDELETE(f);
f=_CLNEW RangeFilter(_T("id"),medIP,maxIP,T,T);
result = search->search(q,f);
assertEqualsMsg(_T("med and up"), 1+ maxId-medId, result->length());
_CLLDELETE(result);
_CLLDELETE(f);
f=_CLNEW RangeFilter(_T("id"),minIP,medIP,T,T);
result = search->search(q,f);
assertEqualsMsg(_T("up to med"), 1+ medId-minId, result->length());
_CLLDELETE(result);
_CLLDELETE(f);
// unbounded id
f=_CLNEW RangeFilter(_T("id"),minIP,NULL,T,F);
result = search->search(q,f);
assertEqualsMsg(_T("min and up"), numDocs, result->length());
_CLLDELETE(result);
_CLLDELETE(f);
f=_CLNEW RangeFilter(_T("id"),NULL,maxIP,F,T);
result = search->search(q,f);
assertEqualsMsg(_T("max and down"), numDocs, result->length());
_CLLDELETE(result);
_CLLDELETE(f);
f=_CLNEW RangeFilter(_T("id"),minIP,NULL,F,F);
result = search->search(q,f);
assertEqualsMsg(_T("not min, but up"), numDocs-1, result->length());
_CLLDELETE(result);
_CLLDELETE(f);
f=_CLNEW RangeFilter(_T("id"),NULL,maxIP,F,F);
result = search->search(q,f);
assertEqualsMsg(_T("not max, but down"), numDocs-1, result->length());
_CLLDELETE(result);
_CLLDELETE(f);
f=_CLNEW RangeFilter(_T("id"),medIP,maxIP,T,F);
result = search->search(q,f);
assertEqualsMsg(_T("med and up, not max"), maxId-medId, result->length());
_CLLDELETE(result);
_CLLDELETE(f);
f=_CLNEW RangeFilter(_T("id"),minIP,medIP,F,T);
result = search->search(q,f);
assertEqualsMsg(_T("not min, up to med"), medId-minId, result->length());
_CLLDELETE(result);
_CLLDELETE(f);
// very small sets
f=_CLNEW RangeFilter(_T("id"),minIP,minIP,F,F);
result = search->search(q,f);
assertEqualsMsg(_T("min,min,F,F"), 0, result->length());
_CLLDELETE(result); _CLLDELETE(f);
f=_CLNEW RangeFilter(_T("id"),medIP,medIP,F,F);
result = search->search(q,f);
assertEqualsMsg(_T("med,med,F,F"), 0, result->length());
_CLLDELETE(result); _CLLDELETE(f);
f=_CLNEW RangeFilter(_T("id"),maxIP,maxIP,F,F);
result = search->search(q,f);
assertEqualsMsg(_T("max,max,F,F"), 0, result->length());
_CLLDELETE(result); _CLLDELETE(f);
f=_CLNEW RangeFilter(_T("id"),minIP,minIP,T,T);
result = search->search(q,f);
assertEqualsMsg(_T("min,min,T,T"), 1, result->length());
_CLLDELETE(result); _CLLDELETE(f);
f=_CLNEW RangeFilter(_T("id"),NULL,minIP,F,T);
result = search->search(q,f);
assertEqualsMsg(_T("nul,min,F,T"), 1, result->length());
_CLLDELETE(result); _CLLDELETE(f);
f=_CLNEW RangeFilter(_T("id"),maxIP,maxIP,T,T);
result = search->search(q,f);
assertEqualsMsg(_T("max,max,T,T"), 1, result->length());
_CLLDELETE(result); _CLLDELETE(f);
f=_CLNEW RangeFilter(_T("id"),maxIP,NULL,T,F);
result = search->search(q,f);
assertEqualsMsg(_T("max,nul,T,T"), 1, result->length());
_CLLDELETE(result); _CLLDELETE(f);
f=_CLNEW RangeFilter(_T("id"),medIP,medIP,T,T);
result = search->search(q,f);
assertEqualsMsg(_T("med,med,T,T"), 1, result->length());
_CLLDELETE(result); _CLLDELETE(f);
search->close();
_CLLDELETE(search);
reader->close();
_CLLDELETE(reader);
_CLLDELETE(q);
}
void testRangeFilterRand()
{
IndexReader* reader = IndexReader::open(index);
IndexSearcher* search = _CLNEW IndexSearcher(reader);
std::tstring minRPstr = pad(minR);
const TCHAR* minRP = minRPstr.c_str();
std::tstring maxRPstr = pad(maxR);
const TCHAR* maxRP = maxRPstr.c_str();
size_t numDocs = static_cast<size_t>(reader->numDocs());
assertEqualsMsg(_T("num of docs"), numDocs, 1+ maxId - minId);
Hits* result;
Term* term = _CLNEW Term(_T("body"),_T("body"));
Query* q = _CLNEW TermQuery(term);
_CLDECDELETE(term);
// test extremes, bounded on both ends
Filter* f = _CLNEW RangeFilter(_T("rand"),minRP,maxRP,T,T);
result = search->search(q,f);
assertEqualsMsg(_T("find all"), numDocs, result->length());
_CLLDELETE(result); _CLLDELETE(f);
f=_CLNEW RangeFilter(_T("rand"),minRP,maxRP,T,F);
result = search->search(q,f);
assertEqualsMsg(_T("all but biggest"), numDocs-1, result->length());
_CLLDELETE(result); _CLLDELETE(f);
f=_CLNEW RangeFilter(_T("rand"),minRP,maxRP,F,T);
result = search->search(q,f);
assertEqualsMsg(_T("all but smallest"), numDocs-1, result->length());
_CLLDELETE(result); _CLLDELETE(f);
f=_CLNEW RangeFilter(_T("rand"),minRP,maxRP,F,F);
result = search->search(q,f);
assertEqualsMsg(_T("all but extremes"), numDocs-2, result->length());
_CLLDELETE(result); _CLLDELETE(f);
// unbounded
f=_CLNEW RangeFilter(_T("rand"),minRP,NULL,T,F);
result = search->search(q,f);
assertEqualsMsg(_T("smallest and up"), numDocs, result->length());
_CLLDELETE(result); _CLLDELETE(f);
f=_CLNEW RangeFilter(_T("rand"),NULL,maxRP,F,T);
result = search->search(q,f);
assertEqualsMsg(_T("biggest and down"), numDocs, result->length());
_CLLDELETE(result); _CLLDELETE(f);
f=_CLNEW RangeFilter(_T("rand"),minRP,NULL,F,F);
result = search->search(q,f);
assertEqualsMsg(_T("not smallest, but up"), numDocs-1, result->length());
_CLLDELETE(result); _CLLDELETE(f);
f=_CLNEW RangeFilter(_T("rand"),NULL,maxRP,F,F);
result = search->search(q,f);
assertEqualsMsg(_T("not biggest, but down"), numDocs-1, result->length());
_CLLDELETE(result); _CLLDELETE(f);
// very small sets
f=_CLNEW RangeFilter(_T("rand"),minRP,minRP,F,F);
result = search->search(q,f);
assertEqualsMsg(_T("min,min,F,F"), 0, result->length());
_CLLDELETE(result); _CLLDELETE(f);
f=_CLNEW RangeFilter(_T("rand"),maxRP,maxRP,F,F);
result = search->search(q,f);
assertEqualsMsg(_T("max,max,F,F"), 0, result->length());
_CLLDELETE(result); _CLLDELETE(f);
f=_CLNEW RangeFilter(_T("rand"),minRP,minRP,T,T);
result = search->search(q,f);
assertEqualsMsg(_T("min,min,T,T"), 1, result->length());
_CLLDELETE(result); _CLLDELETE(f);
f=_CLNEW RangeFilter(_T("rand"),NULL,minRP,F,T);
result = search->search(q,f);
assertEqualsMsg(_T("nul,min,F,T"), 1, result->length());
_CLLDELETE(result); _CLLDELETE(f);
f=_CLNEW RangeFilter(_T("rand"),maxRP,maxRP,T,T);
result = search->search(q,f);
assertEqualsMsg(_T("max,max,T,T"), 1, result->length());
_CLLDELETE(result); _CLLDELETE(f);
f=_CLNEW RangeFilter(_T("rand"),maxRP,NULL,T,F);
result = search->search(q,f);
assertEqualsMsg(_T("max,nul,T,T"), 1, result->length());
_CLLDELETE(result); _CLLDELETE(f);
search->close();
_CLLDELETE(search);
reader->close();
_CLLDELETE(reader);
_CLLDELETE(q);
}
void testRangeQueryRand()
{
// NOTE: uses index build in *super* setUp
IndexReader * pReader = IndexReader::open( index );
IndexSearcher * pSearch = _CLNEW IndexSearcher( pReader );
std::tstring sMinRP = pad(minR);
std::tstring sMaxRP = pad(maxR);
const TCHAR* minRP = sMinRP.c_str();
const TCHAR* maxRP = sMaxRP.c_str();
size_t numDocs = static_cast<size_t>( pReader->numDocs() );
assertEqualsMsg( _T("num of docs"), numDocs, static_cast<size_t>(1+ maxId - minId));
Hits * pResult;
Query * q;
// test extremes, bounded on both ends
q = csrq( _T( "rand" ), minRP, maxRP, true, true );
pResult = pSearch->search( q );
assertEqualsMsg( _T( "find all" ), numDocs, pResult->length());
_CLDELETE( pResult ); _CLDELETE( q );
q = csrq( _T( "rand" ), minRP, maxRP, true, false );
pResult = pSearch->search( q );
assertEqualsMsg( _T( "all but biggest" ), numDocs-1, pResult->length());
_CLDELETE( pResult ); _CLDELETE( q );
q = csrq( _T( "rand" ), minRP, maxRP, false, true );
pResult = pSearch->search( q );
assertEqualsMsg( _T( "all but smallest" ), numDocs-1, pResult->length());
_CLDELETE( pResult ); _CLDELETE( q );
q = csrq( _T( "rand" ), minRP, maxRP, false, false );
pResult = pSearch->search( q );
assertEqualsMsg( _T( "all but extremes" ), numDocs-2, pResult->length());
_CLDELETE( pResult ); _CLDELETE( q );
// unbounded
q = csrq( _T( "rand" ), minRP, NULL, true, false );
pResult = pSearch->search( q );
assertEqualsMsg( _T( "smallest and up" ), numDocs, pResult->length());
_CLDELETE( pResult ); _CLDELETE( q );
q = csrq( _T( "rand" ), NULL, maxRP, false, true );
pResult = pSearch->search( q );
assertEqualsMsg( _T( "biggest and down" ), numDocs, pResult->length());
_CLDELETE( pResult ); _CLDELETE( q );
q = csrq( _T( "rand" ), minRP, NULL, false, false );
pResult = pSearch->search( q );
assertEqualsMsg( _T( "not smallest, but up" ), numDocs-1, pResult->length());
_CLDELETE( pResult ); _CLDELETE( q );
q = csrq( _T( "rand" ), NULL, maxRP, false, false );
pResult = pSearch->search( q );
assertEqualsMsg( _T( "not biggest, but down" ), numDocs-1, pResult->length());
_CLDELETE( pResult ); _CLDELETE( q );
// very small sets
q = csrq( _T( "rand" ), minRP, minRP, false, false );
pResult = pSearch->search( q );
assertEqualsMsg( _T( "min,min,F,F" ), 0, pResult->length());
_CLDELETE( pResult ); _CLDELETE( q );
q = csrq( _T( "rand" ), maxRP, maxRP, false, false );
pResult = pSearch->search( q );
assertEqualsMsg( _T( "max,max,F,F" ), 0, pResult->length());
_CLDELETE( pResult ); _CLDELETE( q );
q = csrq( _T( "rand" ), minRP, minRP, true, true );
pResult = pSearch->search( q );
assertEqualsMsg( _T( "min,min,T,T" ), 1, pResult->length());
_CLDELETE( pResult ); _CLDELETE( q );
q = csrq( _T( "rand" ), NULL, minRP, false, true );
pResult = pSearch->search( q );
assertEqualsMsg( _T( "nul,min,F,T" ), 1, pResult->length());
_CLDELETE( pResult ); _CLDELETE( q );
q = csrq( _T( "rand" ), maxRP, maxRP, true, true );
pResult = pSearch->search( q );
assertEqualsMsg( _T( "max,max,T,T" ), 1, pResult->length());
_CLDELETE( pResult ); _CLDELETE( q );
q = csrq( _T( "rand" ), maxRP, NULL, true, false );
pResult = pSearch->search( q );
assertEqualsMsg( _T( "max,nul,T,T" ), 1, pResult->length());
_CLDELETE( pResult ); _CLDELETE( q );
pSearch->close();
_CLDELETE( pSearch );
pReader->close();
_CLDELETE( pReader );
}
void testRangeQueryId()
{
// NOTE: uses index build in *super* setUp
IndexReader * pReader = IndexReader::open( index );
IndexSearcher * pSearch = _CLNEW IndexSearcher( pReader );
int32_t medId = ((maxId - minId) / 2);
std::tstring sMinIP = pad(minId);
std::tstring sMaxIP = pad(maxId);
std::tstring sMedIP = pad(medId);
const TCHAR* minIP = sMinIP.c_str();
const TCHAR* maxIP = sMaxIP.c_str();
const TCHAR* medIP = sMedIP.c_str();
size_t numDocs = static_cast<size_t>( pReader->numDocs() );
assertEqualsMsg( _T("num of docs"), numDocs, static_cast<size_t>(1+ maxId - minId));
Hits * pResult;
Query * q;
// test id, bounded on both ends
q = csrq( _T( "id" ), minIP, maxIP, true, true );
pResult = pSearch->search( q );
assertEqualsMsg( _T( "find all" ), numDocs, pResult->length() );
_CLDELETE( pResult ); _CLDELETE( q );
q = csrq( _T( "id" ), minIP, maxIP, true, false );
pResult = pSearch->search( q );
assertEqualsMsg( _T( "all but last" ), numDocs-1, pResult->length());
_CLDELETE( pResult ); _CLDELETE( q );
q = csrq( _T( "id" ), minIP, maxIP, false, true );
pResult = pSearch->search( q );
assertEqualsMsg( _T( "all but first" ), numDocs-1, pResult->length());
_CLDELETE( pResult ); _CLDELETE( q );
q = csrq( _T( "id" ), minIP, maxIP, false,false );
pResult = pSearch->search( q );
assertEqualsMsg( _T( "all but ends" ), numDocs-2, pResult->length());
_CLDELETE( pResult ); _CLDELETE( q );
q = csrq( _T( "id" ), medIP, maxIP, true, true );
pResult = pSearch->search( q );
assertEqualsMsg( _T( "med and up" ), 1+maxId-medId, pResult->length());
_CLDELETE( pResult ); _CLDELETE( q );
q = csrq( _T( "id" ), minIP, medIP, true, true );
pResult = pSearch->search( q );
assertEqualsMsg( _T( "up to med" ), 1+medId-minId, pResult->length());
_CLDELETE( pResult ); _CLDELETE( q );
// unbounded id
q = csrq( _T( "id" ), minIP, NULL, true, false );
pResult = pSearch->search( q );
assertEqualsMsg( _T( "min and up" ), numDocs, pResult->length());
_CLDELETE( pResult ); _CLDELETE( q );
q = csrq( _T( "id" ), NULL, maxIP, false, true );
pResult = pSearch->search( q );
assertEqualsMsg( _T( "max and down" ), numDocs, pResult->length());
_CLDELETE( pResult ); _CLDELETE( q );
q = csrq( _T( "id" ), minIP, NULL, false, false );
pResult = pSearch->search( q );
assertEqualsMsg( _T( "not min, but up" ), numDocs-1, pResult->length());
_CLDELETE( pResult ); _CLDELETE( q );
q = csrq( _T( "id" ), NULL, maxIP, false, false );
pResult = pSearch->search( q );
assertEqualsMsg( _T( "not max, but down" ), numDocs-1, pResult->length());
_CLDELETE( pResult ); _CLDELETE( q );
q = csrq( _T( "id" ), medIP, maxIP, true, false );
pResult = pSearch->search( q );
assertEqualsMsg( _T( "med and up, not max" ), maxId-medId, pResult->length());
_CLDELETE( pResult ); _CLDELETE( q );
q = csrq( _T( "id" ), minIP, medIP, false,true );
pResult = pSearch->search( q );
assertEqualsMsg( _T( "not min, up to med" ), medId-minId, pResult->length());
_CLDELETE( pResult ); _CLDELETE( q );
// very small sets
q = csrq( _T( "id" ), minIP, minIP, false, false );
pResult = pSearch->search( q );
assertEqualsMsg( _T( "min,min,F,F" ), 0, pResult->length());
_CLDELETE( pResult ); _CLDELETE( q );
q = csrq( _T( "id" ), medIP, medIP, false, false );
pResult = pSearch->search( q );
assertEqualsMsg( _T( "med,med,F,F" ), 0, pResult->length());
_CLDELETE( pResult ); _CLDELETE( q );
q = csrq( _T( "id") , maxIP, maxIP, false, false );
pResult = pSearch->search( q );
assertEqualsMsg( _T( "max,max,F,F" ), 0, pResult->length());
_CLDELETE( pResult ); _CLDELETE( q );
q = csrq( _T( "id" ), minIP, minIP, true, true );
pResult = pSearch->search( q );
assertEqualsMsg( _T( "min,min,T,T" ), 1, pResult->length());
_CLDELETE( pResult ); _CLDELETE( q );
q = csrq( _T( "id" ), NULL, minIP, false, true );
pResult = pSearch->search( q );
assertEqualsMsg( _T( "nul,min,F,T" ), 1, pResult->length());
_CLDELETE( pResult ); _CLDELETE( q );
q = csrq( _T( "id" ), maxIP, maxIP, true, true );
pResult = pSearch->search( q );
assertEqualsMsg( _T( "max,max,T,T" ), 1, pResult->length());
_CLDELETE( pResult ); _CLDELETE( q );
q = csrq( _T( "id" ), maxIP, NULL, true, false );
pResult = pSearch->search( q );
assertEqualsMsg( _T( "max,nul,T,T" ), 1, pResult->length());
_CLDELETE( pResult ); _CLDELETE( q );
q = csrq( _T( "id" ), medIP, medIP, true, true );
pResult = pSearch->search( q );
assertEqualsMsg( _T( "med,med,T,T" ), 1, pResult->length());
_CLDELETE( pResult ); _CLDELETE( q );
pSearch->close();
_CLDELETE( pSearch );
pReader->close();
_CLDELETE( pReader );
}
/// TestBooleanPrefixQuery.java, ported 5/9/2009
void testBooleanPrefixQuery(CuTest* tc) {
RAMDirectory directory;
WhitespaceAnalyzer a;
TCHAR* categories[] = {_T("food"), _T("foodanddrink"),
_T("foodanddrinkandgoodtimes"), _T("food and drink"), NULL};
Query* rw1 = NULL;
Query* rw2 = NULL;
try {
IndexWriter* writer = _CLNEW IndexWriter(&directory, &a, true);
for (size_t i = 0; categories[i]!=NULL; i++) {
Document* doc = new Document();
doc->add(*_CLNEW Field(_T("category"), categories[i], Field::STORE_YES | Field::INDEX_UNTOKENIZED));
writer->addDocument(doc);
_CLLDELETE(doc);
}
writer->close();
_CLLDELETE(writer);
IndexReader* reader = IndexReader::open(&directory);
Term* t = _CLNEW Term(_T("category"), _T("foo"));
PrefixQuery* query = _CLNEW PrefixQuery(t);
_CLDECDELETE(t);
rw1 = query->rewrite(reader);
BooleanQuery* bq = _CLNEW BooleanQuery();
bq->add(query, true, BooleanClause::MUST);
rw2 = bq->rewrite(reader);
reader->close(); // TODO: check necessity (_CLLDELETE(reader) alone will not do the same cleanup)
_CLLDELETE(reader);
_CLLDELETE(bq);
} catch (CLuceneError& e) {
CuFail(tc, e.twhat());
}
BooleanQuery* bq1 = NULL;
if (rw1->instanceOf(BooleanQuery::getClassName())) {
bq1 = (BooleanQuery*) rw1;
}
BooleanQuery* bq2 = NULL;
if (rw2->instanceOf(BooleanQuery::getClassName())) {
bq2 = (BooleanQuery*) rw2;
} else {
CuFail(tc, _T("Rewrite"));
}
bool bClausesMatch = bq1->getClauseCount() == bq2->getClauseCount();
_CLLDELETE(rw1);
_CLLDELETE(rw2);
if (!bClausesMatch) {
CuFail(tc, _T("Number of Clauses Mismatch"));
}
}