TEST(IndexInfoTest, WriteIntoDir)
{
    RAMDirectory dir;

    IndexInfo infos;
    infos.addSegment(SegmentInfo(0, 42, 100, 123));
    infos.incLastSegmentId();
    infos.addSegment(SegmentInfo(1, 66, 200, 456));
    infos.incLastSegmentId();
    infos.setAttribute("foo", "bar");
    infos.save(&dir);

    ScopedPtr<InputStream> input(dir.openFile("info_0"));
    ASSERT_EQ(2, input->readVInt32());
    ASSERT_EQ(2, input->readVInt32());
    ASSERT_EQ(0, input->readVInt32());
    ASSERT_EQ(42, input->readVInt32());
    ASSERT_EQ(100, input->readVInt32());
    ASSERT_EQ(123, input->readVInt32());
    ASSERT_EQ(1, input->readVInt32());
    ASSERT_EQ(66, input->readVInt32());
    ASSERT_EQ(200, input->readVInt32());
    ASSERT_EQ(456, input->readVInt32());
    ASSERT_EQ(1, input->readVInt32());
    ASSERT_EQ("foo", input->readString());
    ASSERT_EQ("bar", input->readString());
    ASSERT_EQ(3656423981u, input->readInt32());
}
TEST(SegmentInfoListTest, Read)
{
	RAMDirectory dir;

	ScopedPtr<OutputStream> output(dir.createFile("segments_0"));
	output->writeVInt32(3);
	output->writeVInt32(2);
	output->writeString("segment_0");
	output->writeVInt32(42);
	output->writeString("segment_2");
	output->writeVInt32(66);
	output.reset();

	SegmentInfoList infos;
	ScopedPtr<InputStream> input(dir.openFile("segments_0"));
	infos.read(input.get());
	input.reset();

	ASSERT_EQ(3, infos.lastSegmetNum());
	ASSERT_EQ(2, infos.segmentCount());
	ASSERT_EQ("segment_0", infos.info(0).name());
	ASSERT_EQ(42, infos.info(0).numDocs());
	ASSERT_EQ("segment_2", infos.info(1).name());
	ASSERT_EQ(66, infos.info(1).numDocs());
}
TEST(IndexWriterTest, OpenEmpty)
{
	RAMDirectory dir;

	ASSERT_FALSE(dir.fileExists("segments_0"));
	ASSERT_THROW(IndexWriter writer(&dir), IOException);
	ASSERT_FALSE(dir.fileExists("segments_0"));
}
TEST(IndexWriterTest, OpenEmptyCreate)
{
	RAMDirectory dir;

	ASSERT_FALSE(dir.fileExists("segments_0"));
	IndexWriter writer(&dir, true);
	ASSERT_TRUE(dir.fileExists("segments_0"));
	ASSERT_EQ(0, writer.revision());
}
示例#5
0
void testEndThreadException(CuTest *tc) {

    const int MAX_DOCS=1500;
	RAMDirectory ram;
	WhitespaceAnalyzer an;
	IndexWriter* writer = _CLNEW IndexWriter(&ram, &an, true);

    // add some documents
    Document doc;
    for (int i = 0; i < MAX_DOCS; i++) {
        TCHAR * tmp = English::IntToEnglish(i);
        doc.add(* new Field(_T("content"), tmp, Field::STORE_YES | Field::INDEX_UNTOKENIZED));
        writer->addDocument(&doc);
        doc.clear();
        _CLDELETE_ARRAY( tmp );
    }

    CuAssertEquals(tc, MAX_DOCS, writer->docCount());
    
    writer->close();
	_CLLDELETE(writer);
    
    // this sequence is OK: delete searcher after search thread finish
    {
        IndexSearcher * searcher = _CLNEW IndexSearcher(&ram);
        _LUCENE_THREADID_TYPE thread = _LUCENE_THREAD_CREATE(&searchDocs, searcher);
        SCOPED_LOCK_MUTEX(searchMutex);

        CONDITION_WAIT(searchMutex, searchCondition);
//        _LUCENE_SLEEP(9999); //make sure that deleteMutex is being waited on...
        CONDITION_NOTIFYALL(deleteCondition);

        _LUCENE_THREAD_JOIN(thread);

        searcher->close();
        _CLLDELETE(searcher);
    }

    // this produces memory exception: delete searcher after search finish but before thread finish
    {
        IndexSearcher * searcher = _CLNEW IndexSearcher(&ram);
        _LUCENE_THREADID_TYPE thread = _LUCENE_THREAD_CREATE(&searchDocs, searcher);
        SCOPED_LOCK_MUTEX(searchMutex);

        CONDITION_WAIT(searchMutex, searchCondition);
        searcher->close();
        _CLLDELETE(searcher);
        CONDITION_NOTIFYALL(deleteCondition);

        _LUCENE_THREAD_JOIN(thread);
    }


    ram.close();
}
void testIncludeLowerTrue(CuTest* tc)
{
    WhitespaceAnalyzer a;
    RAMDirectory* index = _CLNEW RAMDirectory();
    IndexWriter* writer = _CLNEW IndexWriter(index,
        &a, true);

    Document doc;
    doc.add(*_CLNEW Field(_T("Category"), _T("a 1"), Field::STORE_YES | Field::INDEX_TOKENIZED));
    writer->addDocument(&doc); doc.clear();

    doc.add(*_CLNEW Field(_T("Category"), _T("a 2"), Field::STORE_YES | Field::INDEX_TOKENIZED));
    writer->addDocument(&doc); doc.clear();

    doc.add(*_CLNEW Field(_T("Category"), _T("a 3"), Field::STORE_YES | Field::INDEX_TOKENIZED));
    writer->addDocument(&doc); doc.clear();

    writer->close();
    _CLLDELETE(writer);

    IndexSearcher* s = _CLNEW IndexSearcher(index);
    Filter* f = _CLNEW RangeFilter(_T("Category"), _T("3"), _T("3"), true, true);

    Term* t = _CLNEW Term(_T("Category"), _T("a"));
    Query* q1 = _CLNEW TermQuery(t);
    _CLLDECDELETE(t);

    t = _CLNEW Term(_T("Category"), _T("3"));
    Query* q2 = _CLNEW TermQuery(t);
    _CLLDECDELETE(t);

    Hits* h = s->search(q1);
    assertTrue(h->length() == 3);
    _CLLDELETE(h);

    h = s->search(q2);
    assertTrue(h->length() == 1);
    _CLLDELETE(h);

    h = s->search(q1, f);
    assertTrue(h->length() == 1);
    _CLLDELETE(h);

    s->close();
    _CLLDELETE(s);
    _CLLDELETE(q1);
    _CLLDELETE(q2);
    _CLLDELETE(f);

    index->close();
    _CLLDECDELETE(index);
}
TEST(IndexInfoTest, ReadFromDirCorruptRecover2)
{
    RAMDirectory dir;

    {
        ScopedPtr<OutputStream> output(dir.createFile("info_0"));
        output->writeVInt32(2);
        output->writeVInt32(2);
        output->writeVInt32(0);
        output->writeVInt32(42);
        output->writeVInt32(100);
        output->writeVInt32(123);
        output->writeVInt32(1);
        output->writeVInt32(66);
        output->writeVInt32(200);
        output->writeVInt32(456);
        output->writeVInt32(1);
        output->writeString("foo");
        output->writeString("bar");
        output->writeInt32(3656423981u);
    }

    {
        ScopedPtr<OutputStream> output(dir.createFile("info_1"));
        output->writeVInt32(3);
    }

    {
        ScopedPtr<OutputStream> output(dir.createFile("info_2"));
        output->writeVInt32(4);
    }

    IndexInfo infos;
    infos.load(&dir);

    ASSERT_EQ(0, infos.revision());
    ASSERT_EQ(2, infos.lastSegmentId());
    ASSERT_EQ(2, infos.segmentCount());
    ASSERT_EQ("segment_0", infos.segment(0).name());
    ASSERT_EQ(42, infos.segment(0).blockCount());
    ASSERT_EQ(100, infos.segment(0).lastKey());
    ASSERT_EQ(123, infos.segment(0).checksum());
    ASSERT_EQ("segment_1", infos.segment(1).name());
    ASSERT_EQ(66, infos.segment(1).blockCount());
    ASSERT_EQ(200, infos.segment(1).lastKey());
    ASSERT_EQ(456, infos.segment(1).checksum());
    ASSERT_EQ(1, infos.attributes().size());
    ASSERT_EQ("bar", infos.attribute("foo"));
}
TEST(IndexInfoTest, ReadFromDirCorruptFail)
{
    RAMDirectory dir;

    {
        ScopedPtr<OutputStream> output(dir.createFile("info_0"));
        output->writeVInt32(2);
    }

    {
        ScopedPtr<OutputStream> output(dir.createFile("info_1"));
        output->writeVInt32(3);
    }

    IndexInfo infos;
    ASSERT_THROW(infos.load(&dir), CorruptIndexException);
}
TEST(IndexInfoTest, FindCurrentRevision)
{
    RAMDirectory dir;

    int rev = IndexInfo::findCurrentRevision(&dir);
    ASSERT_EQ(-1, rev);

    delete dir.createFile("info_0");
    rev = IndexInfo::findCurrentRevision(&dir);
    ASSERT_EQ(0, rev);

    delete dir.createFile("info_1");
    rev = IndexInfo::findCurrentRevision(&dir);
    ASSERT_EQ(1, rev);

    delete dir.createFile("info_8");
    rev = IndexInfo::findCurrentRevision(&dir);
    ASSERT_EQ(8, rev);
}
TEST(SegmentInfoListTest, FindCurrentRevision)
{
	RAMDirectory dir;

	int rev = SegmentInfoList::findCurrentRevision(&dir);
	ASSERT_EQ(-1, rev);

	delete dir.createFile("segments_0");
	rev = SegmentInfoList::findCurrentRevision(&dir);
	ASSERT_EQ(0, rev);

	delete dir.createFile("segments_1");
	rev = SegmentInfoList::findCurrentRevision(&dir);
	ASSERT_EQ(1, rev);

	delete dir.createFile("segments_8");
	rev = SegmentInfoList::findCurrentRevision(&dir);
	ASSERT_EQ(8, rev);
}
TEST(SegmentInfoListTest, Write)
{
	RAMDirectory dir;

	SegmentInfoList infos;
	infos.add(SegmentInfo("segment_0", 42));
	infos.incNextSegmentNum();
	infos.add(SegmentInfo("segment_1", 66));
	infos.incNextSegmentNum();
	ScopedPtr<OutputStream> output(dir.createFile("segments_0"));
	infos.write(output.get());
	output.reset();

	ScopedPtr<InputStream> input(dir.openFile("segments_0"));
	ASSERT_EQ(2, input->readVInt32());
	ASSERT_EQ(2, input->readVInt32());
	ASSERT_EQ("segment_0", input->readString());
	ASSERT_EQ(42, input->readVInt32());
	ASSERT_EQ("segment_1", input->readString());
	ASSERT_EQ(66, input->readVInt32());
}
TEST(IndexWriterTest, AddDocument)
{
	RAMDirectory dir;
	IndexWriter writer(&dir, true);
	ASSERT_TRUE(dir.fileExists("segments_0"));
	ASSERT_EQ(0, writer.revision());
	ASSERT_EQ(0, writer.segmentInfoList().segmentCount());

	uint32_t fp[] = { 7, 9, 12 };
	writer.addDocument(1, fp, 3);
	writer.commit();
	ASSERT_TRUE(dir.fileExists("segments_1"));
	ASSERT_TRUE(dir.fileExists("segment_0.fii"));
	ASSERT_TRUE(dir.fileExists("segment_0.fid"));
	ASSERT_EQ(1, writer.revision());
	ASSERT_EQ(1, writer.segmentInfoList().segmentCount());
	ASSERT_EQ("segment_0", writer.segmentInfoList().info(0).name());
	ASSERT_EQ(1, writer.segmentInfoList().info(0).numDocs());

	{
		ScopedPtr<InputStream> input(dir.openFile("segment_0.fii"));
		ASSERT_EQ(512, input->readInt32());
		ASSERT_EQ(1, input->readInt32());
		ASSERT_EQ(7, input->readVInt32());
	}

	{
		ScopedPtr<InputStream> input(dir.openFile("segment_0.fid"));
		ASSERT_EQ(3, input->readVInt32());
		ASSERT_EQ(1, input->readVInt32());
		ASSERT_EQ(2, input->readVInt32());
		ASSERT_EQ(1, input->readVInt32());
		ASSERT_EQ(3, input->readVInt32());
		ASSERT_EQ(1, input->readVInt32());
	}
}
示例#13
0
/*
  Run above stress test against RAMDirectory and then
  FSDirectory.
 */
void testRAMThreading(CuTest *tc){
  // First in a RAM directory:
  RAMDirectory directory; //todo: use MockRAMDirectory?
  runThreadingTests(tc,directory);
  directory.close();
}