You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@lucene.apache.org by us...@apache.org on 2012/01/31 00:34:14 UTC
svn commit: r1238085 [5/10] - in /lucene/dev/trunk: ./
dev-tools/idea/lucene/contrib/ lucene/ lucene/contrib/
lucene/contrib/highlighter/src/java/org/apache/lucene/search/highlight/
lucene/contrib/highlighter/src/test/org/apache/lucene/search/highlight...
Modified: lucene/dev/trunk/lucene/src/test-framework/java/org/apache/lucene/store/MockDirectoryWrapper.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/src/test-framework/java/org/apache/lucene/store/MockDirectoryWrapper.java?rev=1238085&r1=1238084&r2=1238085&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/src/test-framework/java/org/apache/lucene/store/MockDirectoryWrapper.java (original)
+++ lucene/dev/trunk/lucene/src/test-framework/java/org/apache/lucene/store/MockDirectoryWrapper.java Mon Jan 30 23:34:03 2012
@@ -33,7 +33,7 @@ import java.util.Random;
import java.util.Set;
import java.util.concurrent.atomic.AtomicInteger;
-import org.apache.lucene.index.IndexReader;
+import org.apache.lucene.index.DirectoryReader;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.index.IndexWriterConfig;
import org.apache.lucene.util.LuceneTestCase;
@@ -559,7 +559,7 @@ public class MockDirectoryWrapper extend
}
open = false;
if (checkIndexOnClose) {
- if (IndexReader.indexExists(this)) {
+ if (DirectoryReader.indexExists(this)) {
if (LuceneTestCase.VERBOSE) {
System.out.println("\nNOTE: MockDirectoryWrapper: now crash");
}
@@ -582,11 +582,11 @@ public class MockDirectoryWrapper extend
assert false : "unreferenced files: before delete:\n " + Arrays.toString(startFiles) + "\n after delete:\n " + Arrays.toString(endFiles);
}
- IndexReader ir1 = IndexReader.open(this);
+ DirectoryReader ir1 = DirectoryReader.open(this);
int numDocs1 = ir1.numDocs();
ir1.close();
new IndexWriter(this, new IndexWriterConfig(LuceneTestCase.TEST_VERSION_CURRENT, null)).close();
- IndexReader ir2 = IndexReader.open(this);
+ DirectoryReader ir2 = DirectoryReader.open(this);
int numDocs2 = ir2.numDocs();
ir2.close();
assert numDocs1 == numDocs2 : "numDocs changed after opening/closing IW: before=" + numDocs1 + " after=" + numDocs2;
Modified: lucene/dev/trunk/lucene/src/test-framework/java/org/apache/lucene/util/LuceneTestCase.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/src/test-framework/java/org/apache/lucene/util/LuceneTestCase.java?rev=1238085&r1=1238084&r2=1238085&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/src/test-framework/java/org/apache/lucene/util/LuceneTestCase.java (original)
+++ lucene/dev/trunk/lucene/src/test-framework/java/org/apache/lucene/util/LuceneTestCase.java Mon Jan 30 23:34:03 2012
@@ -189,14 +189,11 @@ public abstract class LuceneTestCase ext
* Some tests expect the directory to contain a single segment, and want to do tests on that segment's reader.
* This is an utility method to help them.
*/
- public static SegmentReader getOnlySegmentReader(IndexReader reader) {
- if (reader instanceof SegmentReader)
- return (SegmentReader) reader;
-
+ public static SegmentReader getOnlySegmentReader(DirectoryReader reader) {
IndexReader[] subReaders = reader.getSequentialSubReaders();
if (subReaders.length != 1)
throw new IllegalArgumentException(reader + " has " + subReaders.length + " segments instead of exactly one");
-
+ assertTrue(subReaders[0] instanceof SegmentReader);
return (SegmentReader) subReaders[0];
}
@@ -1239,7 +1236,7 @@ public abstract class LuceneTestCase ext
public static IndexSearcher newSearcher(IndexReader r, boolean maybeWrap) throws IOException {
if (usually()) {
if (maybeWrap && rarely()) {
- r = new SlowMultiReaderWrapper(r);
+ r = SlowCompositeReaderWrapper.wrap(r);
}
IndexSearcher ret = random.nextBoolean() ? new AssertingIndexSearcher(random, r) : new AssertingIndexSearcher(random, r.getTopReaderContext());
ret.setSimilarityProvider(similarityProvider);
Modified: lucene/dev/trunk/lucene/src/test/org/apache/lucene/TestExternalCodecs.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/src/test/org/apache/lucene/TestExternalCodecs.java?rev=1238085&r1=1238084&r2=1238085&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/src/test/org/apache/lucene/TestExternalCodecs.java (original)
+++ lucene/dev/trunk/lucene/src/test/org/apache/lucene/TestExternalCodecs.java Mon Jan 30 23:34:03 2012
@@ -93,7 +93,6 @@ public class TestExternalCodecs extends
w.deleteDocuments(new Term("id", "77"));
IndexReader r = IndexReader.open(w, true);
- IndexReader[] subs = r.getSequentialSubReaders();
assertEquals(NUM_DOCS-1, r.numDocs());
IndexSearcher s = newSearcher(r);
Modified: lucene/dev/trunk/lucene/src/test/org/apache/lucene/codecs/lucene3x/TestTermInfosReaderIndex.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/src/test/org/apache/lucene/codecs/lucene3x/TestTermInfosReaderIndex.java?rev=1238085&r1=1238084&r2=1238085&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/src/test/org/apache/lucene/codecs/lucene3x/TestTermInfosReaderIndex.java (original)
+++ lucene/dev/trunk/lucene/src/test/org/apache/lucene/codecs/lucene3x/TestTermInfosReaderIndex.java Mon Jan 30 23:34:03 2012
@@ -34,6 +34,7 @@ import org.apache.lucene.codecs.preflexr
import org.apache.lucene.document.Document;
import org.apache.lucene.document.StringField;
import org.apache.lucene.index.CorruptIndexException;
+import org.apache.lucene.index.DirectoryReader;
import org.apache.lucene.index.FieldInfos;
import org.apache.lucene.index.FieldsEnum;
import org.apache.lucene.index.IndexFileNames;
@@ -93,8 +94,8 @@ public class TestTermInfosReaderIndex ex
populate(directory, config);
- IndexReader r0 = IndexReader.open(directory);
- SegmentReader r = (SegmentReader) r0.getSequentialSubReaders()[0];
+ DirectoryReader r0 = IndexReader.open(directory);
+ SegmentReader r = LuceneTestCase.getOnlySegmentReader(r0);
String segment = r.getSegmentName();
r.close();
Modified: lucene/dev/trunk/lucene/src/test/org/apache/lucene/codecs/lucene40/TestReuseDocsEnum.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/src/test/org/apache/lucene/codecs/lucene40/TestReuseDocsEnum.java?rev=1238085&r1=1238084&r2=1238085&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/src/test/org/apache/lucene/codecs/lucene40/TestReuseDocsEnum.java (original)
+++ lucene/dev/trunk/lucene/src/test/org/apache/lucene/codecs/lucene40/TestReuseDocsEnum.java Mon Jan 30 23:34:03 2012
@@ -22,6 +22,8 @@ import java.util.Random;
import org.apache.lucene.analysis.MockAnalyzer;
import org.apache.lucene.codecs.Codec;
import org.apache.lucene.codecs.lucene40.Lucene40PostingsFormat;
+import org.apache.lucene.index.AtomicReader;
+import org.apache.lucene.index.DirectoryReader;
import org.apache.lucene.index.DocsEnum;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.RandomIndexWriter;
@@ -34,6 +36,7 @@ import org.apache.lucene.util.BytesRef;
import org.apache.lucene.util.IOUtils;
import org.apache.lucene.util.LineFileDocs;
import org.apache.lucene.util.LuceneTestCase;
+import org.apache.lucene.util.ReaderUtil;
import org.apache.lucene.util._TestUtil;
public class TestReuseDocsEnum extends LuceneTestCase {
@@ -47,20 +50,22 @@ public class TestReuseDocsEnum extends L
createRandomIndex(numdocs, writer, random);
writer.commit();
- IndexReader open = IndexReader.open(dir);
- IndexReader[] sequentialSubReaders = open.getSequentialSubReaders();
- for (IndexReader indexReader : sequentialSubReaders) {
- Terms terms = indexReader.terms("body");
- TermsEnum iterator = terms.iterator(null);
- IdentityHashMap<DocsEnum, Boolean> enums = new IdentityHashMap<DocsEnum, Boolean>();
- MatchNoBits bits = new Bits.MatchNoBits(open.maxDoc());
- while ((iterator.next()) != null) {
- DocsEnum docs = iterator.docs(random.nextBoolean() ? bits : new Bits.MatchNoBits(open.maxDoc()), null, random.nextBoolean());
- enums.put(docs, true);
+ DirectoryReader open = DirectoryReader.open(dir);
+ new ReaderUtil.Gather(open) {
+ @Override
+ protected void add(int base, AtomicReader r) throws IOException {
+ Terms terms = r.terms("body");
+ TermsEnum iterator = terms.iterator(null);
+ IdentityHashMap<DocsEnum, Boolean> enums = new IdentityHashMap<DocsEnum, Boolean>();
+ MatchNoBits bits = new Bits.MatchNoBits(r.maxDoc());
+ while ((iterator.next()) != null) {
+ DocsEnum docs = iterator.docs(random.nextBoolean() ? bits : new Bits.MatchNoBits(r.maxDoc()), null, random.nextBoolean());
+ enums.put(docs, true);
+ }
+
+ assertEquals(terms.getUniqueTermCount(), enums.size());
}
-
- assertEquals(terms.getUniqueTermCount(), enums.size());
- }
+ }.run();
IOUtils.close(writer, open, dir);
}
@@ -74,10 +79,10 @@ public class TestReuseDocsEnum extends L
createRandomIndex(numdocs, writer, random);
writer.commit();
- IndexReader open = IndexReader.open(dir);
+ DirectoryReader open = DirectoryReader.open(dir);
IndexReader[] sequentialSubReaders = open.getSequentialSubReaders();
for (IndexReader indexReader : sequentialSubReaders) {
- Terms terms = indexReader.terms("body");
+ Terms terms = ((AtomicReader) indexReader).terms("body");
TermsEnum iterator = terms.iterator(null);
IdentityHashMap<DocsEnum, Boolean> enums = new IdentityHashMap<DocsEnum, Boolean>();
MatchNoBits bits = new Bits.MatchNoBits(open.maxDoc());
@@ -119,13 +124,13 @@ public class TestReuseDocsEnum extends L
createRandomIndex(numdocs, writer, random);
writer.commit();
- IndexReader firstReader = IndexReader.open(dir);
- IndexReader secondReader = IndexReader.open(dir);
+ DirectoryReader firstReader = DirectoryReader.open(dir);
+ DirectoryReader secondReader = DirectoryReader.open(dir);
IndexReader[] sequentialSubReaders = firstReader.getSequentialSubReaders();
IndexReader[] sequentialSubReaders2 = secondReader.getSequentialSubReaders();
for (IndexReader indexReader : sequentialSubReaders) {
- Terms terms = indexReader.terms("body");
+ Terms terms = ((AtomicReader) indexReader).terms("body");
TermsEnum iterator = terms.iterator(null);
IdentityHashMap<DocsEnum, Boolean> enums = new IdentityHashMap<DocsEnum, Boolean>();
MatchNoBits bits = new Bits.MatchNoBits(firstReader.maxDoc());
@@ -154,7 +159,7 @@ public class TestReuseDocsEnum extends L
if (random.nextInt(10) == 0) {
return null;
}
- IndexReader indexReader = readers[random.nextInt(readers.length)];
+ AtomicReader indexReader = (AtomicReader) readers[random.nextInt(readers.length)];
return indexReader.termDocsEnum(bits, field, term, random.nextBoolean());
}
Modified: lucene/dev/trunk/lucene/src/test/org/apache/lucene/codecs/pulsing/TestPulsingReuse.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/src/test/org/apache/lucene/codecs/pulsing/TestPulsingReuse.java?rev=1238085&r1=1238084&r2=1238085&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/src/test/org/apache/lucene/codecs/pulsing/TestPulsingReuse.java (original)
+++ lucene/dev/trunk/lucene/src/test/org/apache/lucene/codecs/pulsing/TestPulsingReuse.java Mon Jan 30 23:34:03 2012
@@ -26,7 +26,9 @@ import org.apache.lucene.codecs.nestedpu
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.document.TextField;
+import org.apache.lucene.index.AtomicReader;
import org.apache.lucene.index.CheckIndex;
+import org.apache.lucene.index.DirectoryReader;
import org.apache.lucene.index.DocsAndPositionsEnum;
import org.apache.lucene.index.DocsEnum;
import org.apache.lucene.index.IndexReader;
@@ -51,10 +53,10 @@ public class TestPulsingReuse extends Lu
Document doc = new Document();
doc.add(new Field("foo", "a b b c c c d e f g g h i i j j k", TextField.TYPE_UNSTORED));
iw.addDocument(doc);
- IndexReader ir = iw.getReader();
+ DirectoryReader ir = iw.getReader();
iw.close();
- IndexReader segment = ir.getSequentialSubReaders()[0];
+ AtomicReader segment = getOnlySegmentReader(ir);
DocsEnum reuse = null;
Map<DocsEnum,Boolean> allEnums = new IdentityHashMap<DocsEnum,Boolean>();
TermsEnum te = segment.terms("foo").iterator(null);
@@ -93,10 +95,10 @@ public class TestPulsingReuse extends Lu
// this is because we only track the 'last' enum we reused (not all).
// but this seems 'good enough' for now.
iw.addDocument(doc);
- IndexReader ir = iw.getReader();
+ DirectoryReader ir = iw.getReader();
iw.close();
- IndexReader segment = ir.getSequentialSubReaders()[0];
+ AtomicReader segment = getOnlySegmentReader(ir);
DocsEnum reuse = null;
Map<DocsEnum,Boolean> allEnums = new IdentityHashMap<DocsEnum,Boolean>();
TermsEnum te = segment.terms("foo").iterator(null);
Modified: lucene/dev/trunk/lucene/src/test/org/apache/lucene/index/TestAddIndexes.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/src/test/org/apache/lucene/index/TestAddIndexes.java?rev=1238085&r1=1238084&r2=1238085&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/src/test/org/apache/lucene/index/TestAddIndexes.java (original)
+++ lucene/dev/trunk/lucene/src/test/org/apache/lucene/index/TestAddIndexes.java Mon Jan 30 23:34:03 2012
@@ -1279,16 +1279,16 @@ public class TestAddIndexes extends Luce
Directory d3 = newDirectory();
w = new RandomIndexWriter(random, d3);
- w.addIndexes(new SlowMultiReaderWrapper(r1), new SlowMultiReaderWrapper(r2));
+ w.addIndexes(SlowCompositeReaderWrapper.wrap(r1), SlowCompositeReaderWrapper.wrap(r2));
r1.close();
d1.close();
r2.close();
d2.close();
w.forceMerge(1);
- IndexReader r3 = w.getReader();
+ DirectoryReader r3 = w.getReader();
w.close();
- IndexReader sr = getOnlySegmentReader(r3);
+ AtomicReader sr = getOnlySegmentReader(r3);
assertEquals(2, sr.numDocs());
DocValues docValues = sr.docValues("dv");
assertNotNull(docValues);
Modified: lucene/dev/trunk/lucene/src/test/org/apache/lucene/index/TestBackwardsCompatibility.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/src/test/org/apache/lucene/index/TestBackwardsCompatibility.java?rev=1238085&r1=1238084&r2=1238085&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/src/test/org/apache/lucene/index/TestBackwardsCompatibility.java (original)
+++ lucene/dev/trunk/lucene/src/test/org/apache/lucene/index/TestBackwardsCompatibility.java Mon Jan 30 23:34:03 2012
@@ -644,12 +644,12 @@ public class TestBackwardsCompatibility
assertEquals("wrong number of hits", 34, hits.length);
// check decoding into field cache
- int[] fci = FieldCache.DEFAULT.getInts(new SlowMultiReaderWrapper(searcher.getIndexReader()), "trieInt", false);
+ int[] fci = FieldCache.DEFAULT.getInts(SlowCompositeReaderWrapper.wrap(searcher.getIndexReader()), "trieInt", false);
for (int val : fci) {
assertTrue("value in id bounds", val >= 0 && val < 35);
}
- long[] fcl = FieldCache.DEFAULT.getLongs(new SlowMultiReaderWrapper(searcher.getIndexReader()), "trieLong", false);
+ long[] fcl = FieldCache.DEFAULT.getLongs(SlowCompositeReaderWrapper.wrap(searcher.getIndexReader()), "trieLong", false);
for (long val : fcl) {
assertTrue("value in id bounds", val >= 0L && val < 35L);
}
Modified: lucene/dev/trunk/lucene/src/test/org/apache/lucene/index/TestCodecs.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/src/test/org/apache/lucene/index/TestCodecs.java?rev=1238085&r1=1238084&r2=1238085&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/src/test/org/apache/lucene/index/TestCodecs.java (original)
+++ lucene/dev/trunk/lucene/src/test/org/apache/lucene/index/TestCodecs.java Mon Jan 30 23:34:03 2012
@@ -260,7 +260,7 @@ public class TestCodecs extends LuceneTe
Codec codec = Codec.getDefault();
final SegmentInfo si = new SegmentInfo(SEGMENT, 10000, dir, false, codec, clonedFieldInfos);
- final FieldsProducer reader = codec.postingsFormat().fieldsProducer(new SegmentReadState(dir, si, fieldInfos, newIOContext(random), IndexReader.DEFAULT_TERMS_INDEX_DIVISOR));
+ final FieldsProducer reader = codec.postingsFormat().fieldsProducer(new SegmentReadState(dir, si, fieldInfos, newIOContext(random), DirectoryReader.DEFAULT_TERMS_INDEX_DIVISOR));
final FieldsEnum fieldsEnum = reader.iterator();
assertNotNull(fieldsEnum.next());
@@ -319,7 +319,7 @@ public class TestCodecs extends LuceneTe
if (VERBOSE) {
System.out.println("TEST: now read postings");
}
- final FieldsProducer terms = codec.postingsFormat().fieldsProducer(new SegmentReadState(dir, si, fieldInfos, newIOContext(random), IndexReader.DEFAULT_TERMS_INDEX_DIVISOR));
+ final FieldsProducer terms = codec.postingsFormat().fieldsProducer(new SegmentReadState(dir, si, fieldInfos, newIOContext(random), DirectoryReader.DEFAULT_TERMS_INDEX_DIVISOR));
final Verify[] threads = new Verify[NUM_TEST_THREADS-1];
for(int i=0;i<NUM_TEST_THREADS-1;i++) {
Modified: lucene/dev/trunk/lucene/src/test/org/apache/lucene/index/TestCustomNorms.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/src/test/org/apache/lucene/index/TestCustomNorms.java?rev=1238085&r1=1238084&r2=1238085&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/src/test/org/apache/lucene/index/TestCustomNorms.java (original)
+++ lucene/dev/trunk/lucene/src/test/org/apache/lucene/index/TestCustomNorms.java Mon Jan 30 23:34:03 2012
@@ -79,7 +79,7 @@ public class TestCustomNorms extends Luc
}
writer.commit();
writer.close();
- IndexReader open = new SlowMultiReaderWrapper(IndexReader.open(dir));
+ AtomicReader open = SlowCompositeReaderWrapper.wrap(DirectoryReader.open(dir));
DocValues normValues = open.normValues(floatTestField);
assertNotNull(normValues);
Source source = normValues.getSource();
Modified: lucene/dev/trunk/lucene/src/test/org/apache/lucene/index/TestDeletionPolicy.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/src/test/org/apache/lucene/index/TestDeletionPolicy.java?rev=1238085&r1=1238084&r2=1238085&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/src/test/org/apache/lucene/index/TestDeletionPolicy.java (original)
+++ lucene/dev/trunk/lucene/src/test/org/apache/lucene/index/TestDeletionPolicy.java Mon Jan 30 23:34:03 2012
@@ -67,7 +67,7 @@ public class TestDeletionPolicy extends
}
public void onCommit(List<? extends IndexCommit> commits) throws IOException {
IndexCommit lastCommit = commits.get(commits.size()-1);
- IndexReader r = IndexReader.open(dir);
+ DirectoryReader r = DirectoryReader.open(dir);
assertEquals("lastCommit.segmentCount()=" + lastCommit.getSegmentCount() + " vs IndexReader.segmentCount=" + r.getSequentialSubReaders().length, r.getSequentialSubReaders().length, lastCommit.getSegmentCount());
r.close();
verifyCommitOrder(commits);
@@ -325,7 +325,7 @@ public class TestDeletionPolicy extends
final boolean needsMerging;
{
- IndexReader r = IndexReader.open(dir);
+ DirectoryReader r = DirectoryReader.open(dir);
needsMerging = r.getSequentialSubReaders().length != 1;
r.close();
}
@@ -351,7 +351,7 @@ public class TestDeletionPolicy extends
assertEquals(1 + (needsMerging ? 1:0), policy.numOnCommit);
// Test listCommits
- Collection<IndexCommit> commits = IndexReader.listCommits(dir);
+ Collection<IndexCommit> commits = DirectoryReader.listCommits(dir);
// 2 from closing writer
assertEquals(1 + (needsMerging ? 1:0), commits.size());
@@ -415,7 +415,7 @@ public class TestDeletionPolicy extends
}
writer.close();
- Collection<IndexCommit> commits = IndexReader.listCommits(dir);
+ Collection<IndexCommit> commits = DirectoryReader.listCommits(dir);
assertEquals(5, commits.size());
IndexCommit lastCommit = null;
for (final IndexCommit commit : commits) {
@@ -431,7 +431,7 @@ public class TestDeletionPolicy extends
writer.forceMerge(1);
writer.close();
- assertEquals(6, IndexReader.listCommits(dir).size());
+ assertEquals(6, DirectoryReader.listCommits(dir).size());
// Now open writer on the commit just before merge:
writer = new IndexWriter(dir, newIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(random))
@@ -441,7 +441,7 @@ public class TestDeletionPolicy extends
// Should undo our rollback:
writer.rollback();
- IndexReader r = IndexReader.open(dir);
+ DirectoryReader r = DirectoryReader.open(dir);
// Still merged, still 11 docs
assertEquals(1, r.getSequentialSubReaders().length);
assertEquals(11, r.numDocs());
@@ -454,9 +454,9 @@ public class TestDeletionPolicy extends
writer.close();
// Now 8 because we made another commit
- assertEquals(7, IndexReader.listCommits(dir).size());
+ assertEquals(7, DirectoryReader.listCommits(dir).size());
- r = IndexReader.open(dir);
+ r = DirectoryReader.open(dir);
// Not fully merged because we rolled it back, and now only
// 10 docs
assertTrue(r.getSequentialSubReaders().length > 1);
Modified: lucene/dev/trunk/lucene/src/test/org/apache/lucene/index/TestDirectoryReader.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/src/test/org/apache/lucene/index/TestDirectoryReader.java?rev=1238085&r1=1238084&r2=1238085&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/src/test/org/apache/lucene/index/TestDirectoryReader.java (original)
+++ lucene/dev/trunk/lucene/src/test/org/apache/lucene/index/TestDirectoryReader.java Mon Jan 30 23:34:03 2012
@@ -86,31 +86,19 @@ public class TestDirectoryReader extends
assertTrue(DocHelper.numFields(newDoc2) == DocHelper.numFields(doc2) - DocHelper.unstored.size());
Terms vector = reader.getTermVectors(0).terms(DocHelper.TEXT_FIELD_2_KEY);
assertNotNull(vector);
- TestSegmentReader.checkNorms(reader);
+ // TODO: pretty sure this check makes zero sense TestSegmentReader.checkNorms(reader);
reader.close();
}
public void testIsCurrent() throws IOException {
- Directory ramDir1=newDirectory();
- addDoc(random, ramDir1, "test foo", true);
- Directory ramDir2=newDirectory();
- addDoc(random, ramDir2, "test blah", true);
- IndexReader[] readers = new IndexReader[]{IndexReader.open(ramDir1), IndexReader.open(ramDir2)};
- MultiReader mr = new MultiReader(readers);
- assertTrue(mr.isCurrent()); // just opened, must be current
- addDoc(random, ramDir1, "more text", false);
- assertFalse(mr.isCurrent()); // has been modified, not current anymore
- addDoc(random, ramDir2, "even more text", false);
- assertFalse(mr.isCurrent()); // has been modified even more, not current anymore
- try {
- mr.getVersion();
- fail();
- } catch (UnsupportedOperationException e) {
- // expected exception
- }
- mr.close();
- ramDir1.close();
- ramDir2.close();
+ Directory ramDir=newDirectory();
+ addDoc(random, ramDir, "test foo", true);
+ DirectoryReader reader = DirectoryReader.open(ramDir);
+ assertTrue(reader.isCurrent()); // just opened, must be current
+ addDoc(random, ramDir, "more text", false);
+ assertFalse(reader.isCurrent()); // has been modified, not current anymore
+ reader.close();
+ ramDir.close();
}
public void testMultiTermDocs() throws IOException {
Modified: lucene/dev/trunk/lucene/src/test/org/apache/lucene/index/TestDoc.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/src/test/org/apache/lucene/index/TestDoc.java?rev=1238085&r1=1238084&r2=1238085&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/src/test/org/apache/lucene/index/TestDoc.java (original)
+++ lucene/dev/trunk/lucene/src/test/org/apache/lucene/index/TestDoc.java Mon Jan 30 23:34:03 2012
@@ -190,8 +190,8 @@ public class TestDoc extends LuceneTestC
private SegmentInfo merge(Directory dir, SegmentInfo si1, SegmentInfo si2, String merged, boolean useCompoundFile)
throws Exception {
IOContext context = newIOContext(random);
- SegmentReader r1 = new SegmentReader(si1, IndexReader.DEFAULT_TERMS_INDEX_DIVISOR, context);
- SegmentReader r2 = new SegmentReader(si2, IndexReader.DEFAULT_TERMS_INDEX_DIVISOR, context);
+ SegmentReader r1 = new SegmentReader(si1, DirectoryReader.DEFAULT_TERMS_INDEX_DIVISOR, context);
+ SegmentReader r2 = new SegmentReader(si2, DirectoryReader.DEFAULT_TERMS_INDEX_DIVISOR, context);
final Codec codec = Codec.getDefault();
SegmentMerger merger = new SegmentMerger(InfoStream.getDefault(), si1.dir, IndexWriterConfig.DEFAULT_TERM_INDEX_INTERVAL, merged, MergeState.CheckAbort.NONE, null, new FieldInfos(new FieldInfos.FieldNumberBiMap()), codec, context);
@@ -218,7 +218,7 @@ public class TestDoc extends LuceneTestC
private void printSegment(PrintWriter out, SegmentInfo si)
throws Exception {
- SegmentReader reader = new SegmentReader(si, IndexReader.DEFAULT_TERMS_INDEX_DIVISOR, newIOContext(random));
+ SegmentReader reader = new SegmentReader(si, DirectoryReader.DEFAULT_TERMS_INDEX_DIVISOR, newIOContext(random));
for (int i = 0; i < reader.numDocs(); i++)
out.println(reader.document(i));
Modified: lucene/dev/trunk/lucene/src/test/org/apache/lucene/index/TestDocTermOrds.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/src/test/org/apache/lucene/index/TestDocTermOrds.java?rev=1238085&r1=1238084&r2=1238085&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/src/test/org/apache/lucene/index/TestDocTermOrds.java (original)
+++ lucene/dev/trunk/lucene/src/test/org/apache/lucene/index/TestDocTermOrds.java Mon Jan 30 23:34:03 2012
@@ -66,7 +66,7 @@ public class TestDocTermOrds extends Luc
final IndexReader r = w.getReader();
w.close();
- final DocTermOrds dto = new DocTermOrds(new SlowMultiReaderWrapper(r), "field");
+ final DocTermOrds dto = new DocTermOrds(SlowCompositeReaderWrapper.wrap(r), "field");
TermOrdsIterator iter = dto.lookup(0, null);
final int[] buffer = new int[5];
@@ -149,7 +149,7 @@ public class TestDocTermOrds extends Luc
w.addDocument(doc);
}
- final IndexReader r = w.getReader();
+ final DirectoryReader r = w.getReader();
w.close();
if (VERBOSE) {
@@ -160,7 +160,7 @@ public class TestDocTermOrds extends Luc
if (VERBOSE) {
System.out.println("\nTEST: sub=" + subR);
}
- verify(subR, idToOrds, termsArray, null);
+ verify((AtomicReader) subR, idToOrds, termsArray, null);
}
// Also test top-level reader: its enum does not support
@@ -168,9 +168,10 @@ public class TestDocTermOrds extends Luc
if (VERBOSE) {
System.out.println("TEST: top reader");
}
- verify(new SlowMultiReaderWrapper(r), idToOrds, termsArray, null);
+ AtomicReader slowR = SlowCompositeReaderWrapper.wrap(r);
+ verify(slowR, idToOrds, termsArray, null);
- FieldCache.DEFAULT.purge(r);
+ FieldCache.DEFAULT.purge(slowR);
r.close();
dir.close();
@@ -245,13 +246,14 @@ public class TestDocTermOrds extends Luc
w.addDocument(doc);
}
- final IndexReader r = w.getReader();
+ final DirectoryReader r = w.getReader();
w.close();
if (VERBOSE) {
System.out.println("TEST: reader=" + r);
}
+ AtomicReader slowR = SlowCompositeReaderWrapper.wrap(r);
for(String prefix : prefixesArray) {
final BytesRef prefixRef = prefix == null ? null : new BytesRef(prefix);
@@ -277,7 +279,7 @@ public class TestDocTermOrds extends Luc
if (VERBOSE) {
System.out.println("\nTEST: sub=" + subR);
}
- verify(subR, idToOrdsPrefix, termsArray, prefixRef);
+ verify((AtomicReader) subR, idToOrdsPrefix, termsArray, prefixRef);
}
// Also test top-level reader: its enum does not support
@@ -285,16 +287,16 @@ public class TestDocTermOrds extends Luc
if (VERBOSE) {
System.out.println("TEST: top reader");
}
- verify(new SlowMultiReaderWrapper(r), idToOrdsPrefix, termsArray, prefixRef);
+ verify(slowR, idToOrdsPrefix, termsArray, prefixRef);
}
- FieldCache.DEFAULT.purge(r);
+ FieldCache.DEFAULT.purge(slowR);
r.close();
dir.close();
}
- private void verify(IndexReader r, int[][] idToOrds, BytesRef[] termsArray, BytesRef prefixRef) throws Exception {
+ private void verify(AtomicReader r, int[][] idToOrds, BytesRef[] termsArray, BytesRef prefixRef) throws Exception {
final DocTermOrds dto = new DocTermOrds(r,
"field",
Modified: lucene/dev/trunk/lucene/src/test/org/apache/lucene/index/TestDocValuesIndexing.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/src/test/org/apache/lucene/index/TestDocValuesIndexing.java?rev=1238085&r1=1238084&r2=1238085&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/src/test/org/apache/lucene/index/TestDocValuesIndexing.java (original)
+++ lucene/dev/trunk/lucene/src/test/org/apache/lucene/index/TestDocValuesIndexing.java Mon Jan 30 23:34:03 2012
@@ -82,7 +82,7 @@ public class TestDocValuesIndexing exten
writer.close(true);
- IndexReader reader = IndexReader.open(dir, 1);
+ DirectoryReader reader = DirectoryReader.open(dir, 1);
assertEquals(1, reader.getSequentialSubReaders().length);
IndexSearcher searcher = new IndexSearcher(reader);
@@ -694,9 +694,9 @@ public class TestDocValuesIndexing exten
doc.add(f);
w.addDocument(doc);
w.forceMerge(1);
- IndexReader r = w.getReader();
+ DirectoryReader r = w.getReader();
w.close();
- assertEquals(17, r.getSequentialSubReaders()[0].docValues("field").load().getInt(0));
+ assertEquals(17, ((AtomicReader) r.getSequentialSubReaders()[0]).docValues("field").load().getInt(0));
r.close();
d.close();
}
@@ -721,9 +721,9 @@ public class TestDocValuesIndexing exten
doc.add(f);
w.addDocument(doc);
w.forceMerge(1);
- IndexReader r = w.getReader();
+ DirectoryReader r = w.getReader();
w.close();
- assertEquals(17, r.getSequentialSubReaders()[0].docValues("field").load().getInt(0));
+ assertEquals(17, getOnlySegmentReader(r).docValues("field").load().getInt(0));
r.close();
d.close();
}
@@ -795,11 +795,11 @@ public class TestDocValuesIndexing exten
int ord = asSortedSource.getByValue(expected, actual);
assertEquals(i, ord);
}
- reader = new SlowMultiReaderWrapper(reader);
+ AtomicReader slowR = SlowCompositeReaderWrapper.wrap(reader);
Set<Entry<String, String>> entrySet = docToString.entrySet();
for (Entry<String, String> entry : entrySet) {
- int docId = docId(reader, new Term("id", entry.getKey()));
+ int docId = docId(slowR, new Term("id", entry.getKey()));
expected.copyChars(entry.getValue());
assertEquals(expected, asSortedSource.getBytes(docId, actual));
}
@@ -810,7 +810,7 @@ public class TestDocValuesIndexing exten
}
}
- public int docId(IndexReader reader, Term term) throws IOException {
+ public int docId(AtomicReader reader, Term term) throws IOException {
int docFreq = reader.docFreq(term);
assertEquals(1, docFreq);
DocsEnum termDocsEnum = reader.termDocsEnum(null, term.field, term.bytes, false);
Modified: lucene/dev/trunk/lucene/src/test/org/apache/lucene/index/TestDocsAndPositions.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/src/test/org/apache/lucene/index/TestDocsAndPositions.java?rev=1238085&r1=1238084&r2=1238085&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/src/test/org/apache/lucene/index/TestDocsAndPositions.java (original)
+++ lucene/dev/trunk/lucene/src/test/org/apache/lucene/index/TestDocsAndPositions.java Mon Jan 30 23:34:03 2012
@@ -25,8 +25,6 @@ import org.apache.lucene.document.Docume
import org.apache.lucene.document.FieldType;
import org.apache.lucene.document.StringField;
import org.apache.lucene.document.TextField;
-import org.apache.lucene.index.IndexReader.AtomicReaderContext;
-import org.apache.lucene.index.IndexReader.ReaderContext;
import org.apache.lucene.search.DocIdSetIterator;
import org.apache.lucene.store.Directory;
import org.apache.lucene.util.Bits;
@@ -66,16 +64,16 @@ public class TestDocsAndPositions extend
int num = atLeast(13);
for (int i = 0; i < num; i++) {
BytesRef bytes = new BytesRef("1");
- ReaderContext topReaderContext = reader.getTopReaderContext();
+ IndexReaderContext topReaderContext = reader.getTopReaderContext();
AtomicReaderContext[] leaves = ReaderUtil.leaves(topReaderContext);
for (AtomicReaderContext atomicReaderContext : leaves) {
DocsAndPositionsEnum docsAndPosEnum = getDocsAndPositions(
- atomicReaderContext.reader, bytes, null);
+ atomicReaderContext.reader(), bytes, null);
assertNotNull(docsAndPosEnum);
- if (atomicReaderContext.reader.maxDoc() == 0) {
+ if (atomicReaderContext.reader().maxDoc() == 0) {
continue;
}
- final int advance = docsAndPosEnum.advance(random.nextInt(atomicReaderContext.reader.maxDoc()));
+ final int advance = docsAndPosEnum.advance(random.nextInt(atomicReaderContext.reader().maxDoc()));
do {
String msg = "Advanced to: " + advance + " current doc: "
+ docsAndPosEnum.docID(); // TODO: + " usePayloads: " + usePayload;
@@ -94,7 +92,7 @@ public class TestDocsAndPositions extend
directory.close();
}
- public DocsAndPositionsEnum getDocsAndPositions(IndexReader reader,
+ public DocsAndPositionsEnum getDocsAndPositions(AtomicReader reader,
BytesRef bytes, Bits liveDocs) throws IOException {
return reader.termPositionsEnum(null, fieldName, bytes, false);
}
@@ -142,14 +140,14 @@ public class TestDocsAndPositions extend
int num = atLeast(13);
for (int i = 0; i < num; i++) {
BytesRef bytes = new BytesRef("" + term);
- ReaderContext topReaderContext = reader.getTopReaderContext();
+ IndexReaderContext topReaderContext = reader.getTopReaderContext();
AtomicReaderContext[] leaves = ReaderUtil.leaves(topReaderContext);
for (AtomicReaderContext atomicReaderContext : leaves) {
DocsAndPositionsEnum docsAndPosEnum = getDocsAndPositions(
- atomicReaderContext.reader, bytes, null);
+ atomicReaderContext.reader(), bytes, null);
assertNotNull(docsAndPosEnum);
int initDoc = 0;
- int maxDoc = atomicReaderContext.reader.maxDoc();
+ int maxDoc = atomicReaderContext.reader().maxDoc();
// initially advance or do next doc
if (random.nextBoolean()) {
initDoc = docsAndPosEnum.nextDoc();
@@ -218,11 +216,11 @@ public class TestDocsAndPositions extend
int num = atLeast(13);
for (int i = 0; i < num; i++) {
BytesRef bytes = new BytesRef("" + term);
- ReaderContext topReaderContext = reader.getTopReaderContext();
+ IndexReaderContext topReaderContext = reader.getTopReaderContext();
AtomicReaderContext[] leaves = ReaderUtil.leaves(topReaderContext);
for (AtomicReaderContext context : leaves) {
- int maxDoc = context.reader.maxDoc();
- DocsEnum docsEnum = _TestUtil.docs(random, context.reader, fieldName, bytes, null, null, true);
+ int maxDoc = context.reader().maxDoc();
+ DocsEnum docsEnum = _TestUtil.docs(random, context.reader(), fieldName, bytes, null, null, true);
if (findNext(freqInDoc, context.docBase, context.docBase + maxDoc) == Integer.MAX_VALUE) {
assertNull(docsEnum);
continue;
@@ -297,15 +295,15 @@ public class TestDocsAndPositions extend
for (int i = 0; i < num; i++) {
BytesRef bytes = new BytesRef("even");
- ReaderContext topReaderContext = reader.getTopReaderContext();
+ IndexReaderContext topReaderContext = reader.getTopReaderContext();
AtomicReaderContext[] leaves = ReaderUtil.leaves(topReaderContext);
for (AtomicReaderContext atomicReaderContext : leaves) {
DocsAndPositionsEnum docsAndPosEnum = getDocsAndPositions(
- atomicReaderContext.reader, bytes, null);
+ atomicReaderContext.reader(), bytes, null);
assertNotNull(docsAndPosEnum);
int initDoc = 0;
- int maxDoc = atomicReaderContext.reader.maxDoc();
+ int maxDoc = atomicReaderContext.reader().maxDoc();
// initially advance or do next doc
if (random.nextBoolean()) {
initDoc = docsAndPosEnum.nextDoc();
@@ -331,8 +329,8 @@ public class TestDocsAndPositions extend
Document doc = new Document();
doc.add(newField("foo", "bar", StringField.TYPE_UNSTORED));
writer.addDocument(doc);
- IndexReader reader = writer.getReader();
- IndexReader r = getOnlySegmentReader(reader);
+ DirectoryReader reader = writer.getReader();
+ AtomicReader r = getOnlySegmentReader(reader);
DocsEnum disi = _TestUtil.docs(random, r, "foo", new BytesRef("bar"), null, null, false);
int docid = disi.docID();
assertTrue(docid == -1 || docid == DocIdSetIterator.NO_MORE_DOCS);
@@ -356,8 +354,8 @@ public class TestDocsAndPositions extend
Document doc = new Document();
doc.add(newField("foo", "bar", TextField.TYPE_UNSTORED));
writer.addDocument(doc);
- IndexReader reader = writer.getReader();
- IndexReader r = getOnlySegmentReader(reader);
+ DirectoryReader reader = writer.getReader();
+ AtomicReader r = getOnlySegmentReader(reader);
DocsAndPositionsEnum disi = r.termPositionsEnum(null, "foo", new BytesRef("bar"), false);
int docid = disi.docID();
assertTrue(docid == -1 || docid == DocIdSetIterator.NO_MORE_DOCS);
Modified: lucene/dev/trunk/lucene/src/test/org/apache/lucene/index/TestDocumentWriter.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/src/test/org/apache/lucene/index/TestDocumentWriter.java?rev=1238085&r1=1238084&r2=1238085&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/src/test/org/apache/lucene/index/TestDocumentWriter.java (original)
+++ lucene/dev/trunk/lucene/src/test/org/apache/lucene/index/TestDocumentWriter.java Mon Jan 30 23:34:03 2012
@@ -64,7 +64,7 @@ public class TestDocumentWriter extends
SegmentInfo info = writer.newestSegment();
writer.close();
//After adding the document, we should be able to read it back in
- SegmentReader reader = new SegmentReader(info, IndexReader.DEFAULT_TERMS_INDEX_DIVISOR, newIOContext(random));
+ SegmentReader reader = new SegmentReader(info, DirectoryReader.DEFAULT_TERMS_INDEX_DIVISOR, newIOContext(random));
assertTrue(reader != null);
Document doc = reader.document(0);
assertTrue(doc != null);
@@ -125,7 +125,7 @@ public class TestDocumentWriter extends
writer.commit();
SegmentInfo info = writer.newestSegment();
writer.close();
- SegmentReader reader = new SegmentReader(info, IndexReader.DEFAULT_TERMS_INDEX_DIVISOR, newIOContext(random));
+ SegmentReader reader = new SegmentReader(info, DirectoryReader.DEFAULT_TERMS_INDEX_DIVISOR, newIOContext(random));
DocsAndPositionsEnum termPositions = MultiFields.getTermPositionsEnum(reader, MultiFields.getLiveDocs(reader),
"repeated", new BytesRef("repeated"), false);
@@ -197,7 +197,7 @@ public class TestDocumentWriter extends
writer.commit();
SegmentInfo info = writer.newestSegment();
writer.close();
- SegmentReader reader = new SegmentReader(info, IndexReader.DEFAULT_TERMS_INDEX_DIVISOR, newIOContext(random));
+ SegmentReader reader = new SegmentReader(info, DirectoryReader.DEFAULT_TERMS_INDEX_DIVISOR, newIOContext(random));
DocsAndPositionsEnum termPositions = MultiFields.getTermPositionsEnum(reader, reader.getLiveDocs(), "f1", new BytesRef("a"), false);
assertTrue(termPositions.nextDoc() != termPositions.NO_MORE_DOCS);
@@ -241,7 +241,7 @@ public class TestDocumentWriter extends
writer.commit();
SegmentInfo info = writer.newestSegment();
writer.close();
- SegmentReader reader = new SegmentReader(info, IndexReader.DEFAULT_TERMS_INDEX_DIVISOR, newIOContext(random));
+ SegmentReader reader = new SegmentReader(info, DirectoryReader.DEFAULT_TERMS_INDEX_DIVISOR, newIOContext(random));
DocsAndPositionsEnum termPositions = reader.termPositionsEnum(reader.getLiveDocs(), "preanalyzed", new BytesRef("term1"), false);
assertTrue(termPositions.nextDoc() != termPositions.NO_MORE_DOCS);
Modified: lucene/dev/trunk/lucene/src/test/org/apache/lucene/index/TestDuelingCodecs.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/src/test/org/apache/lucene/index/TestDuelingCodecs.java?rev=1238085&r1=1238084&r2=1238085&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/src/test/org/apache/lucene/index/TestDuelingCodecs.java (original)
+++ lucene/dev/trunk/lucene/src/test/org/apache/lucene/index/TestDuelingCodecs.java Mon Jan 30 23:34:03 2012
@@ -151,10 +151,6 @@ public class TestDuelingCodecs extends L
assertEquals(info, leftReader.numDocs(), rightReader.numDocs());
assertEquals(info, leftReader.numDeletedDocs(), rightReader.numDeletedDocs());
assertEquals(info, leftReader.hasDeletions(), rightReader.hasDeletions());
-
- if (leftReader.getUniqueTermCount() != -1 && rightReader.getUniqueTermCount() != -1) {
- assertEquals(info, leftReader.getUniqueTermCount(), rightReader.getUniqueTermCount());
- }
}
/**
@@ -462,11 +458,13 @@ public class TestDuelingCodecs extends L
FieldsEnum fieldsEnum = leftFields.iterator();
String field;
while ((field = fieldsEnum.next()) != null) {
- assertEquals(info, leftReader.hasNorms(field), rightReader.hasNorms(field));
- if (leftReader.hasNorms(field)) {
- DocValues leftNorms = MultiDocValues.getNormDocValues(leftReader, field);
- DocValues rightNorms = MultiDocValues.getNormDocValues(rightReader, field);
+ DocValues leftNorms = MultiDocValues.getNormDocValues(leftReader, field);
+ DocValues rightNorms = MultiDocValues.getNormDocValues(rightReader, field);
+ if (leftNorms != null && rightNorms != null) {
assertDocValues(leftNorms, rightNorms);
+ } else {
+ assertNull(leftNorms);
+ assertNull(rightNorms);
}
}
}
@@ -519,7 +517,7 @@ public class TestDuelingCodecs extends L
private static Set<String> getDVFields(IndexReader reader) {
Set<String> fields = new HashSet<String>();
- for(FieldInfo fi : ReaderUtil.getMergedFieldInfos(reader)) {
+ for(FieldInfo fi : MultiFields.getMergedFieldInfos(reader)) {
if (fi.hasDocValues()) {
fields.add(fi.name);
}
@@ -539,7 +537,12 @@ public class TestDuelingCodecs extends L
for (String field : leftValues) {
DocValues leftDocValues = MultiDocValues.getDocValues(leftReader, field);
DocValues rightDocValues = MultiDocValues.getDocValues(rightReader, field);
- assertDocValues(leftDocValues, rightDocValues);
+ if (leftDocValues != null && rightDocValues != null) {
+ assertDocValues(leftDocValues, rightDocValues);
+ } else {
+ assertNull(leftDocValues);
+ assertNull(rightDocValues);
+ }
}
}
Modified: lucene/dev/trunk/lucene/src/test/org/apache/lucene/index/TestFieldsReader.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/src/test/org/apache/lucene/index/TestFieldsReader.java?rev=1238085&r1=1238084&r2=1238085&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/src/test/org/apache/lucene/index/TestFieldsReader.java (original)
+++ lucene/dev/trunk/lucene/src/test/org/apache/lucene/index/TestFieldsReader.java Mon Jan 30 23:34:03 2012
@@ -272,13 +272,13 @@ public class TestFieldsReader extends Lu
doc.add(new NumericField("id", id, ft));
w.addDocument(doc);
}
- final IndexReader r = w.getReader();
+ final DirectoryReader r = w.getReader();
w.close();
assertEquals(numDocs, r.numDocs());
for(IndexReader sub : r.getSequentialSubReaders()) {
- final int[] ids = FieldCache.DEFAULT.getInts(sub, "id", false);
+ final int[] ids = FieldCache.DEFAULT.getInts((AtomicReader) sub, "id", false);
for(int docID=0;docID<sub.numDocs();docID++) {
final Document doc = sub.document(docID);
final Field f = (Field) doc.getField("nf");
Modified: lucene/dev/trunk/lucene/src/test/org/apache/lucene/index/TestFilterIndexReader.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/src/test/org/apache/lucene/index/TestFilterIndexReader.java?rev=1238085&r1=1238084&r2=1238085&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/src/test/org/apache/lucene/index/TestFilterIndexReader.java (original)
+++ lucene/dev/trunk/lucene/src/test/org/apache/lucene/index/TestFilterIndexReader.java Mon Jan 30 23:34:03 2012
@@ -114,19 +114,14 @@ public class TestFilterIndexReader exten
}
}
- public TestReader(IndexReader reader) {
- super(new SlowMultiReaderWrapper(reader));
+ public TestReader(IndexReader reader) throws IOException {
+ super(SlowCompositeReaderWrapper.wrap(reader));
}
@Override
public Fields fields() throws IOException {
return new TestFields(super.fields());
}
-
- @Override
- public FieldInfos getFieldInfos() {
- return ReaderUtil.getMergedFieldInfos(in);
- }
}
/**
@@ -183,23 +178,17 @@ public class TestFilterIndexReader exten
}
public void testOverrideMethods() throws Exception {
- HashSet<String> methodsThatShouldNotBeOverridden = new HashSet<String>();
- methodsThatShouldNotBeOverridden.add("doOpenIfChanged");
- methodsThatShouldNotBeOverridden.add("clone");
boolean fail = false;
for (Method m : FilterIndexReader.class.getMethods()) {
int mods = m.getModifiers();
- if (Modifier.isStatic(mods) || Modifier.isFinal(mods)) {
+ if (Modifier.isStatic(mods) || Modifier.isFinal(mods) || m.isSynthetic()) {
continue;
}
- Class< ? > declaringClass = m.getDeclaringClass();
+ Class<?> declaringClass = m.getDeclaringClass();
String name = m.getName();
- if (declaringClass != FilterIndexReader.class && declaringClass != Object.class && !methodsThatShouldNotBeOverridden.contains(name)) {
+ if (declaringClass != FilterIndexReader.class && declaringClass != Object.class) {
System.err.println("method is not overridden by FilterIndexReader: " + name);
fail = true;
- } else if (declaringClass == FilterIndexReader.class && methodsThatShouldNotBeOverridden.contains(name)) {
- System.err.println("method should not be overridden by FilterIndexReader: " + name);
- fail = true;
}
}
assertFalse("FilterIndexReader overrides (or not) some problematic methods; see log above", fail);
Modified: lucene/dev/trunk/lucene/src/test/org/apache/lucene/index/TestFlex.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/src/test/org/apache/lucene/index/TestFlex.java?rev=1238085&r1=1238084&r2=1238085&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/src/test/org/apache/lucene/index/TestFlex.java (original)
+++ lucene/dev/trunk/lucene/src/test/org/apache/lucene/index/TestFlex.java Mon Jan 30 23:34:03 2012
@@ -69,8 +69,9 @@ public class TestFlex extends LuceneTest
Document doc = new Document();
doc.add(newField("f", "a b c", TextField.TYPE_UNSTORED));
w.addDocument(doc);
- IndexReader r = w.getReader();
- TermsEnum terms = r.getSequentialSubReaders()[0].fields().terms("f").iterator(null);
+ w.forceMerge(1);
+ DirectoryReader r = w.getReader();
+ TermsEnum terms = getOnlySegmentReader(r).fields().terms("f").iterator(null);
assertTrue(terms.next() != null);
try {
assertEquals(0, terms.ord());
Modified: lucene/dev/trunk/lucene/src/test/org/apache/lucene/index/TestIndexReader.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/src/test/org/apache/lucene/index/TestIndexReader.java?rev=1238085&r1=1238084&r2=1238085&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/src/test/org/apache/lucene/index/TestIndexReader.java (original)
+++ lucene/dev/trunk/lucene/src/test/org/apache/lucene/index/TestIndexReader.java Mon Jan 30 23:34:03 2012
@@ -58,7 +58,7 @@ public class TestIndexReader extends Luc
addDocumentWithFields(writer);
writer.close();
// set up reader:
- IndexReader reader = IndexReader.open(d);
+ DirectoryReader reader = DirectoryReader.open(d);
assertTrue(reader.isCurrent());
// modify index by adding another document:
writer = new IndexWriter(d, newIndexWriterConfig(TEST_VERSION_CURRENT,
@@ -101,8 +101,8 @@ public class TestIndexReader extends Luc
writer.close();
// set up reader
- IndexReader reader = IndexReader.open(d);
- FieldInfos fieldInfos = ReaderUtil.getMergedFieldInfos(reader);
+ DirectoryReader reader = DirectoryReader.open(d);
+ FieldInfos fieldInfos = MultiFields.getMergedFieldInfos(reader);
assertNotNull(fieldInfos.fieldInfo("keyword"));
assertNotNull(fieldInfos.fieldInfo("text"));
assertNotNull(fieldInfos.fieldInfo("unindexed"));
@@ -162,8 +162,8 @@ public class TestIndexReader extends Luc
writer.close();
// verify fields again
- reader = IndexReader.open(d);
- fieldInfos = ReaderUtil.getMergedFieldInfos(reader);
+ reader = DirectoryReader.open(d);
+ fieldInfos = MultiFields.getMergedFieldInfos(reader);
Collection<String> allFieldNames = new HashSet<String>();
Collection<String> indexedFieldNames = new HashSet<String>();
@@ -301,7 +301,7 @@ public class TestIndexReader extends Luc
doc.add(new TextField("junk", "junk text"));
writer.addDocument(doc);
writer.close();
- IndexReader reader = IndexReader.open(dir);
+ DirectoryReader reader = DirectoryReader.open(dir);
Document doc2 = reader.document(reader.maxDoc() - 1);
IndexableField[] fields = doc2.getFields("bin1");
assertNotNull(fields);
@@ -320,7 +320,7 @@ public class TestIndexReader extends Luc
writer = new IndexWriter(dir, newIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(random)).setOpenMode(OpenMode.APPEND).setMergePolicy(newLogMergePolicy()));
writer.forceMerge(1);
writer.close();
- reader = IndexReader.open(dir);
+ reader = DirectoryReader.open(dir);
doc2 = reader.document(reader.maxDoc() - 1);
fields = doc2.getFields("bin1");
assertNotNull(fields);
@@ -343,8 +343,8 @@ public class TestIndexReader extends Luc
fileDirName.mkdir();
}
try {
- IndexReader.open(fileDirName);
- fail("opening IndexReader on empty directory failed to produce FileNotFoundException");
+ DirectoryReader.open(fileDirName);
+ fail("opening DirectoryReader on empty directory failed to produce FileNotFoundException");
} catch (FileNotFoundException e) {
// GOOD
}
@@ -372,7 +372,7 @@ public class TestIndexReader extends Luc
// Now open existing directory and test that reader closes all files
dir = newFSDirectory(dirFile);
- IndexReader reader1 = IndexReader.open(dir);
+ DirectoryReader reader1 = DirectoryReader.open(dir);
reader1.close();
dir.close();
@@ -385,7 +385,7 @@ public class TestIndexReader extends Luc
File dirFile = _TestUtil.getTempDir("deletetest");
Directory dir = newFSDirectory(dirFile);
try {
- IndexReader.open(dir);
+ DirectoryReader.open(dir);
fail("expected FileNotFoundException");
} catch (FileNotFoundException e) {
// expected
@@ -395,7 +395,7 @@ public class TestIndexReader extends Luc
// Make sure we still get a CorruptIndexException (not NPE):
try {
- IndexReader.open(dir);
+ DirectoryReader.open(dir);
fail("expected FileNotFoundException");
} catch (FileNotFoundException e) {
// expected
@@ -461,17 +461,15 @@ public class TestIndexReader extends Luc
}
// TODO: maybe this can reuse the logic of test dueling codecs?
- public static void assertIndexEquals(IndexReader index1, IndexReader index2) throws IOException {
+ public static void assertIndexEquals(DirectoryReader index1, DirectoryReader index2) throws IOException {
assertEquals("IndexReaders have different values for numDocs.", index1.numDocs(), index2.numDocs());
assertEquals("IndexReaders have different values for maxDoc.", index1.maxDoc(), index2.maxDoc());
assertEquals("Only one IndexReader has deletions.", index1.hasDeletions(), index2.hasDeletions());
- if (!(index1 instanceof ParallelReader)) {
- assertEquals("Single segment test differs.", index1.getSequentialSubReaders().length == 1, index2.getSequentialSubReaders().length == 1);
- }
+ assertEquals("Single segment test differs.", index1.getSequentialSubReaders().length == 1, index2.getSequentialSubReaders().length == 1);
// check field names
- FieldInfos fieldInfos1 = ReaderUtil.getMergedFieldInfos(index1);
- FieldInfos fieldInfos2 = ReaderUtil.getMergedFieldInfos(index2);
+ FieldInfos fieldInfos1 = MultiFields.getMergedFieldInfos(index1);
+ FieldInfos fieldInfos2 = MultiFields.getMergedFieldInfos(index2);
assertEquals("IndexReaders have different numbers of fields.", fieldInfos1.size(), fieldInfos2.size());
final int numFields = fieldInfos1.size();
for(int fieldID=0;fieldID<numFields;fieldID++) {
@@ -581,7 +579,7 @@ public class TestIndexReader extends Luc
SegmentInfos sis = new SegmentInfos();
sis.read(d);
- IndexReader r = IndexReader.open(d);
+ DirectoryReader r = DirectoryReader.open(d);
IndexCommit c = r.getIndexCommit();
assertEquals(sis.getCurrentSegmentFileName(), c.getSegmentsFileName());
@@ -600,7 +598,7 @@ public class TestIndexReader extends Luc
addDocumentWithFields(writer);
writer.close();
- IndexReader r2 = IndexReader.openIfChanged(r);
+ DirectoryReader r2 = DirectoryReader.openIfChanged(r);
assertNotNull(r2);
assertFalse(c.equals(r2.getIndexCommit()));
assertFalse(r2.getIndexCommit().getSegmentCount() == 1);
@@ -612,9 +610,9 @@ public class TestIndexReader extends Luc
writer.forceMerge(1);
writer.close();
- r2 = IndexReader.openIfChanged(r);
+ r2 = DirectoryReader.openIfChanged(r);
assertNotNull(r2);
- assertNull(IndexReader.openIfChanged(r2));
+ assertNull(DirectoryReader.openIfChanged(r2));
assertEquals(1, r2.getIndexCommit().getSegmentCount());
r.close();
@@ -633,12 +631,12 @@ public class TestIndexReader extends Luc
}
// LUCENE-1468 -- make sure on attempting to open an
- // IndexReader on a non-existent directory, you get a
+ // DirectoryReader on a non-existent directory, you get a
// good exception
public void testNoDir() throws Throwable {
Directory dir = newFSDirectory(_TestUtil.getTempDir("doesnotexist"));
try {
- IndexReader.open(dir);
+ DirectoryReader.open(dir);
fail("did not hit expected exception");
} catch (NoSuchDirectoryException nsde) {
// expected
@@ -659,7 +657,7 @@ public class TestIndexReader extends Luc
writer.addDocument(createDocument("a"));
writer.close();
- Collection<IndexCommit> commits = IndexReader.listCommits(dir);
+ Collection<IndexCommit> commits = DirectoryReader.listCommits(dir);
for (final IndexCommit commit : commits) {
Collection<String> files = commit.getFileNames();
HashSet<String> seen = new HashSet<String>();
@@ -688,8 +686,8 @@ public class TestIndexReader extends Luc
writer.commit();
// Open reader1
- IndexReader r = IndexReader.open(dir);
- IndexReader r1 = getOnlySegmentReader(r);
+ DirectoryReader r = DirectoryReader.open(dir);
+ AtomicReader r1 = getOnlySegmentReader(r);
final int[] ints = FieldCache.DEFAULT.getInts(r1, "number", false);
assertEquals(1, ints.length);
assertEquals(17, ints[0]);
@@ -699,10 +697,10 @@ public class TestIndexReader extends Luc
writer.commit();
// Reopen reader1 --> reader2
- IndexReader r2 = IndexReader.openIfChanged(r);
+ DirectoryReader r2 = DirectoryReader.openIfChanged(r);
assertNotNull(r2);
r.close();
- IndexReader sub0 = r2.getSequentialSubReaders()[0];
+ AtomicReader sub0 = (AtomicReader) r2.getSequentialSubReaders()[0];
final int[] ints2 = FieldCache.DEFAULT.getInts(sub0, "number", false);
r2.close();
assertTrue(ints == ints2);
@@ -722,19 +720,18 @@ public class TestIndexReader extends Luc
writer.addDocument(doc);
writer.commit();
- IndexReader r = IndexReader.open(dir);
- IndexReader r1 = getOnlySegmentReader(r);
+ DirectoryReader r = DirectoryReader.open(dir);
+ AtomicReader r1 = getOnlySegmentReader(r);
assertEquals(36, r1.getUniqueTermCount());
writer.addDocument(doc);
writer.commit();
- IndexReader r2 = IndexReader.openIfChanged(r);
+ DirectoryReader r2 = DirectoryReader.openIfChanged(r);
assertNotNull(r2);
r.close();
- assertEquals(-1, r2.getUniqueTermCount());
IndexReader[] subs = r2.getSequentialSubReaders();
for(int i=0;i<subs.length;i++) {
- assertEquals(36, subs[i].getUniqueTermCount());
+ assertEquals(36, ((AtomicReader) subs[i]).getUniqueTermCount());
}
r2.close();
writer.close();
@@ -752,7 +749,7 @@ public class TestIndexReader extends Luc
writer.addDocument(doc);
writer.close();
- IndexReader r = IndexReader.open(dir, -1);
+ DirectoryReader r = DirectoryReader.open(dir, -1);
try {
r.docFreq(new Term("field", "f"));
fail("did not hit expected exception");
@@ -771,9 +768,9 @@ public class TestIndexReader extends Luc
writer.close();
// LUCENE-1718: ensure re-open carries over no terms index:
- IndexReader r2 = IndexReader.openIfChanged(r);
+ DirectoryReader r2 = DirectoryReader.openIfChanged(r);
assertNotNull(r2);
- assertNull(IndexReader.openIfChanged(r2));
+ assertNull(DirectoryReader.openIfChanged(r2));
r.close();
IndexReader[] subReaders = r2.getSequentialSubReaders();
assertEquals(2, subReaders.length);
@@ -797,12 +794,12 @@ public class TestIndexReader extends Luc
writer.commit();
Document doc = new Document();
writer.addDocument(doc);
- IndexReader r = IndexReader.open(dir);
+ DirectoryReader r = DirectoryReader.open(dir);
assertTrue(r.isCurrent());
writer.addDocument(doc);
writer.prepareCommit();
assertTrue(r.isCurrent());
- IndexReader r2 = IndexReader.openIfChanged(r);
+ DirectoryReader r2 = DirectoryReader.openIfChanged(r);
assertNull(r2);
writer.commit();
assertFalse(r.isCurrent());
@@ -828,7 +825,7 @@ public class TestIndexReader extends Luc
sdp.snapshot("c3");
writer.close();
long currentGen = 0;
- for (IndexCommit ic : IndexReader.listCommits(dir)) {
+ for (IndexCommit ic : DirectoryReader.listCommits(dir)) {
assertTrue("currentGen=" + currentGen + " commitGen=" + ic.getGeneration(), currentGen < ic.getGeneration());
currentGen = ic.getGeneration();
}
@@ -841,9 +838,9 @@ public class TestIndexReader extends Luc
IndexWriter writer = new IndexWriter(dir, newIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(random)));
writer.addDocument(new Document());
writer.prepareCommit();
- assertFalse(IndexReader.indexExists(dir));
+ assertFalse(DirectoryReader.indexExists(dir));
writer.close();
- assertTrue(IndexReader.indexExists(dir));
+ assertTrue(DirectoryReader.indexExists(dir));
dir.close();
}
@@ -855,7 +852,7 @@ public class TestIndexReader extends Luc
Document d = new Document();
d.add(newField("f", "a a b", TextField.TYPE_UNSTORED));
writer.addDocument(d);
- IndexReader r = writer.getReader();
+ DirectoryReader r = writer.getReader();
writer.close();
try {
// Make sure codec impls totalTermFreq (eg PreFlex doesn't)
@@ -878,7 +875,7 @@ public class TestIndexReader extends Luc
writer.commit();
writer.addDocument(new Document());
writer.commit();
- final IndexReader reader = writer.getReader();
+ final DirectoryReader reader = writer.getReader();
final int[] closeCount = new int[1];
final IndexReader.ReaderClosedListener listener = new IndexReader.ReaderClosedListener() {
public void onClose(IndexReader reader) {
@@ -894,7 +891,7 @@ public class TestIndexReader extends Luc
assertEquals(1, closeCount[0]);
writer.close();
- IndexReader reader2 = IndexReader.open(dir);
+ DirectoryReader reader2 = DirectoryReader.open(dir);
reader2.addReaderClosedListener(listener);
closeCount[0] = 0;
@@ -907,7 +904,7 @@ public class TestIndexReader extends Luc
Directory dir = newDirectory();
IndexWriter writer = new IndexWriter(dir, newIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(random)));
writer.addDocument(new Document());
- IndexReader r = writer.getReader();
+ DirectoryReader r = writer.getReader();
writer.close();
r.document(0);
try {
@@ -925,7 +922,7 @@ public class TestIndexReader extends Luc
IndexWriter writer = new IndexWriter(dir, newIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(random)));
writer.addDocument(new Document());
writer.commit();
- IndexReader r = IndexReader.open(dir);
+ DirectoryReader r = DirectoryReader.open(dir);
assertTrue(r.tryIncRef());
r.decRef();
r.close();
@@ -939,7 +936,7 @@ public class TestIndexReader extends Luc
IndexWriter writer = new IndexWriter(dir, newIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(random)));
writer.addDocument(new Document());
writer.commit();
- IndexReader r = IndexReader.open(dir);
+ DirectoryReader r = DirectoryReader.open(dir);
int numThreads = atLeast(2);
IncThread[] threads = new IncThread[numThreads];
@@ -993,7 +990,7 @@ public class TestIndexReader extends Luc
doc.add(newField("field1", "foobar", StringField.TYPE_STORED));
doc.add(newField("field2", "foobaz", StringField.TYPE_STORED));
writer.addDocument(doc);
- IndexReader r = writer.getReader();
+ DirectoryReader r = writer.getReader();
writer.close();
Set<String> fieldsToLoad = new HashSet<String>();
assertEquals(0, r.document(0, fieldsToLoad).getFields().size());
Modified: lucene/dev/trunk/lucene/src/test/org/apache/lucene/index/TestIndexReaderReopen.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/src/test/org/apache/lucene/index/TestIndexReaderReopen.java?rev=1238085&r1=1238084&r2=1238085&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/src/test/org/apache/lucene/index/TestIndexReaderReopen.java (original)
+++ lucene/dev/trunk/lucene/src/test/org/apache/lucene/index/TestIndexReaderReopen.java Mon Jan 30 23:34:03 2012
@@ -60,8 +60,8 @@ public class TestIndexReaderReopen exten
}
@Override
- protected IndexReader openReader() throws IOException {
- return IndexReader.open(dir1);
+ protected DirectoryReader openReader() throws IOException {
+ return DirectoryReader.open(dir1);
}
});
@@ -78,69 +78,14 @@ public class TestIndexReaderReopen exten
}
@Override
- protected IndexReader openReader() throws IOException {
- return IndexReader.open(dir2);
+ protected DirectoryReader openReader() throws IOException {
+ return DirectoryReader.open(dir2);
}
});
dir2.close();
}
- public void testParallelReaderReopen() throws Exception {
- final Directory dir1 = newDirectory();
- createIndex(random, dir1, true);
- final Directory dir2 = newDirectory();
- createIndex(random, dir2, true);
-
- performDefaultTests(new TestReopen() {
-
- @Override
- protected void modifyIndex(int i) throws IOException {
- TestIndexReaderReopen.modifyIndex(i, dir1);
- TestIndexReaderReopen.modifyIndex(i, dir2);
- }
-
- @Override
- protected IndexReader openReader() throws IOException {
- ParallelReader pr = new ParallelReader();
- pr.add(IndexReader.open(dir1));
- pr.add(IndexReader.open(dir2));
- return pr;
- }
-
- });
- dir1.close();
- dir2.close();
-
- final Directory dir3 = newDirectory();
- createIndex(random, dir3, true);
- final Directory dir4 = newDirectory();
- createIndex(random, dir4, true);
-
- performTestsWithExceptionInReopen(new TestReopen() {
-
- @Override
- protected void modifyIndex(int i) throws IOException {
- TestIndexReaderReopen.modifyIndex(i, dir3);
- TestIndexReaderReopen.modifyIndex(i, dir4);
- }
-
- @Override
- protected IndexReader openReader() throws IOException {
- ParallelReader pr = new ParallelReader();
- pr.add(IndexReader.open(dir3));
- pr.add(IndexReader.open(dir4));
- // Does not implement reopen, so
- // hits exception:
- pr.add(new FilterIndexReader(IndexReader.open(dir3)));
- return pr;
- }
-
- });
- dir3.close();
- dir4.close();
- }
-
// LUCENE-1228: IndexWriter.commit() does not update the index version
// populate an index in iterations.
// at the end of every iteration, commit the index and reopen/recreate the reader.
@@ -162,7 +107,7 @@ public class TestIndexReaderReopen exten
TEST_VERSION_CURRENT, new MockAnalyzer(random)).setOpenMode(
OpenMode.CREATE).setMergeScheduler(new SerialMergeScheduler()).setMergePolicy(newLogMergePolicy()));
iwriter.commit();
- IndexReader reader = IndexReader.open(dir);
+ DirectoryReader reader = DirectoryReader.open(dir);
try {
int M = 3;
FieldType customType = new FieldType(TextField.TYPE_STORED);
@@ -191,7 +136,7 @@ public class TestIndexReaderReopen exten
iwriter.commit();
if (withReopen) {
// reopen
- IndexReader r2 = IndexReader.openIfChanged(reader);
+ DirectoryReader r2 = DirectoryReader.openIfChanged(reader);
if (r2 != null) {
reader.close();
reader = r2;
@@ -199,7 +144,7 @@ public class TestIndexReaderReopen exten
} else {
// recreate
reader.close();
- reader = IndexReader.open(dir);
+ reader = DirectoryReader.open(dir);
}
}
} finally {
@@ -207,99 +152,11 @@ public class TestIndexReaderReopen exten
reader.close();
}
}
-
- public void testMultiReaderReopen() throws Exception {
- final Directory dir1 = newDirectory();
- createIndex(random, dir1, true);
-
- final Directory dir2 = newDirectory();
- createIndex(random, dir2, true);
-
- performDefaultTests(new TestReopen() {
-
- @Override
- protected void modifyIndex(int i) throws IOException {
- TestIndexReaderReopen.modifyIndex(i, dir1);
- TestIndexReaderReopen.modifyIndex(i, dir2);
- }
-
- @Override
- protected IndexReader openReader() throws IOException {
- return new MultiReader(IndexReader.open(dir1),
- IndexReader.open(dir2));
- }
-
- });
-
- dir1.close();
- dir2.close();
- final Directory dir3 = newDirectory();
- createIndex(random, dir3, true);
-
- final Directory dir4 = newDirectory();
- createIndex(random, dir4, true);
-
- performTestsWithExceptionInReopen(new TestReopen() {
-
- @Override
- protected void modifyIndex(int i) throws IOException {
- TestIndexReaderReopen.modifyIndex(i, dir3);
- TestIndexReaderReopen.modifyIndex(i, dir4);
- }
-
- @Override
- protected IndexReader openReader() throws IOException {
- return new MultiReader(IndexReader.open(dir3),
- IndexReader.open(dir4),
- // Does not implement reopen, so
- // hits exception:
- new FilterIndexReader(IndexReader.open(dir3)));
- }
-
- });
- dir3.close();
- dir4.close();
- }
-
- public void testMixedReaders() throws Exception {
- final Directory dir1 = newDirectory();
- createIndex(random, dir1, true);
- final Directory dir2 = newDirectory();
- createIndex(random, dir2, true);
- final Directory dir3 = newDirectory();
- createIndex(random, dir3, false);
- final Directory dir4 = newDirectory();
- createIndex(random, dir4, true);
- final Directory dir5 = newDirectory();
- createIndex(random, dir5, false);
-
- performDefaultTests(new TestReopen() {
-
- @Override
- protected void modifyIndex(int i) throws IOException {
- TestIndexReaderReopen.modifyIndex(i, dir4);
- TestIndexReaderReopen.modifyIndex(i, dir5);
- }
-
- @Override
- protected IndexReader openReader() throws IOException {
- MultiReader mr1 = new MultiReader(IndexReader.open(dir1), IndexReader.open(dir2));
- MultiReader mr2 = new MultiReader(IndexReader.open(dir3), IndexReader.open(dir4));
- return new MultiReader(mr1, mr2, IndexReader.open(dir5));
- }
- });
- dir1.close();
- dir2.close();
- dir3.close();
- dir4.close();
- dir5.close();
- }
-
private void performDefaultTests(TestReopen test) throws Exception {
- IndexReader index1 = test.openReader();
- IndexReader index2 = test.openReader();
+ DirectoryReader index1 = test.openReader();
+ DirectoryReader index2 = test.openReader();
TestIndexReader.assertIndexEquals(index1, index2);
@@ -312,7 +169,7 @@ public class TestIndexReaderReopen exten
index1.close();
index1 = couple.newReader;
- IndexReader index2_refreshed = couple.refreshedReader;
+ DirectoryReader index2_refreshed = couple.refreshedReader;
index2.close();
// test if refreshed reader and newly opened reader return equal results
@@ -328,7 +185,7 @@ public class TestIndexReaderReopen exten
index1.close();
couple = refreshReader(index2, test, i, true);
- // refresh IndexReader
+ // refresh DirectoryReader
index2.close();
index2 = couple.refreshedReader;
@@ -341,85 +198,10 @@ public class TestIndexReaderReopen exten
assertReaderClosed(index1, true, true);
assertReaderClosed(index2, true, true);
}
-
- public void testReferenceCountingMultiReader() throws IOException {
- for (int mode = 0; mode <=1; mode++) {
- Directory dir1 = newDirectory();
- createIndex(random, dir1, false);
- Directory dir2 = newDirectory();
- createIndex(random, dir2, true);
-
- IndexReader reader1 = IndexReader.open(dir1);
- assertRefCountEquals(1, reader1);
-
- IndexReader initReader2 = IndexReader.open(dir2);
- IndexReader multiReader1 = new MultiReader(new IndexReader[] {reader1, initReader2}, (mode == 0));
- modifyIndex(0, dir2);
- assertRefCountEquals(1 + mode, reader1);
-
- IndexReader multiReader2 = IndexReader.openIfChanged(multiReader1);
- assertNotNull(multiReader2);
- // index1 hasn't changed, so multiReader2 should share reader1 now with multiReader1
- assertRefCountEquals(2 + mode, reader1);
-
- modifyIndex(0, dir1);
- IndexReader reader2 = IndexReader.openIfChanged(reader1);
- assertNotNull(reader2);
- assertNull(IndexReader.openIfChanged(reader2));
- assertRefCountEquals(2 + mode, reader1);
-
- if (mode == 1) {
- initReader2.close();
- }
-
- modifyIndex(1, dir1);
- IndexReader reader3 = IndexReader.openIfChanged(reader2);
- assertNotNull(reader3);
- assertRefCountEquals(2 + mode, reader1);
- assertRefCountEquals(1, reader2);
-
- multiReader1.close();
- assertRefCountEquals(1 + mode, reader1);
-
- multiReader1.close();
- assertRefCountEquals(1 + mode, reader1);
-
- if (mode == 1) {
- initReader2.close();
- }
-
- reader1.close();
- assertRefCountEquals(1, reader1);
-
- multiReader2.close();
- assertRefCountEquals(0, reader1);
-
- multiReader2.close();
- assertRefCountEquals(0, reader1);
-
- reader3.close();
- assertRefCountEquals(0, reader1);
- assertReaderClosed(reader1, true, false);
-
- reader2.close();
- assertRefCountEquals(0, reader1);
- assertReaderClosed(reader1, true, false);
-
- reader2.close();
- assertRefCountEquals(0, reader1);
-
- reader3.close();
- assertRefCountEquals(0, reader1);
- assertReaderClosed(reader1, true, true);
- dir1.close();
- dir2.close();
- }
-
- }
private void performTestsWithExceptionInReopen(TestReopen test) throws Exception {
- IndexReader index1 = test.openReader();
- IndexReader index2 = test.openReader();
+ DirectoryReader index1 = test.openReader();
+ DirectoryReader index2 = test.openReader();
TestIndexReader.assertIndexEquals(index1, index2);
@@ -459,28 +241,28 @@ public class TestIndexReaderReopen exten
}
@Override
- protected IndexReader openReader() throws IOException {
- return IndexReader.open(dir);
+ protected DirectoryReader openReader() throws IOException {
+ return DirectoryReader.open(dir);
}
};
final List<ReaderCouple> readers = Collections.synchronizedList(new ArrayList<ReaderCouple>());
- IndexReader firstReader = IndexReader.open(dir);
- IndexReader reader = firstReader;
+ DirectoryReader firstReader = DirectoryReader.open(dir);
+ DirectoryReader reader = firstReader;
final Random rnd = random;
ReaderThread[] threads = new ReaderThread[n];
- final Set<IndexReader> readersToClose = Collections.synchronizedSet(new HashSet<IndexReader>());
+ final Set<DirectoryReader> readersToClose = Collections.synchronizedSet(new HashSet<DirectoryReader>());
for (int i = 0; i < n; i++) {
if (i % 2 == 0) {
- IndexReader refreshed = IndexReader.openIfChanged(reader);
+ DirectoryReader refreshed = DirectoryReader.openIfChanged(reader);
if (refreshed != null) {
readersToClose.add(reader);
reader = refreshed;
}
}
- final IndexReader r = reader;
+ final DirectoryReader r = reader;
final int index = i;
@@ -502,7 +284,7 @@ public class TestIndexReaderReopen exten
break;
} else {
// not synchronized
- IndexReader refreshed = IndexReader.openIfChanged(r);
+ DirectoryReader refreshed = DirectoryReader.openIfChanged(r);
if (refreshed == null) {
refreshed = r;
}
@@ -569,14 +351,14 @@ public class TestIndexReaderReopen exten
}
- for (final IndexReader readerToClose : readersToClose) {
+ for (final DirectoryReader readerToClose : readersToClose) {
readerToClose.close();
}
firstReader.close();
reader.close();
- for (final IndexReader readerToClose : readersToClose) {
+ for (final DirectoryReader readerToClose : readersToClose) {
assertReaderClosed(readerToClose, true, true);
}
@@ -587,13 +369,13 @@ public class TestIndexReaderReopen exten
}
private static class ReaderCouple {
- ReaderCouple(IndexReader r1, IndexReader r2) {
+ ReaderCouple(DirectoryReader r1, DirectoryReader r2) {
newReader = r1;
refreshedReader = r2;
}
- IndexReader newReader;
- IndexReader refreshedReader;
+ DirectoryReader newReader;
+ DirectoryReader refreshedReader;
}
private abstract static class ReaderThreadTask {
@@ -631,21 +413,21 @@ public class TestIndexReaderReopen exten
private Object createReaderMutex = new Object();
- private ReaderCouple refreshReader(IndexReader reader, boolean hasChanges) throws IOException {
+ private ReaderCouple refreshReader(DirectoryReader reader, boolean hasChanges) throws IOException {
return refreshReader(reader, null, -1, hasChanges);
}
- ReaderCouple refreshReader(IndexReader reader, TestReopen test, int modify, boolean hasChanges) throws IOException {
+ ReaderCouple refreshReader(DirectoryReader reader, TestReopen test, int modify, boolean hasChanges) throws IOException {
synchronized (createReaderMutex) {
- IndexReader r = null;
+ DirectoryReader r = null;
if (test != null) {
test.modifyIndex(modify);
r = test.openReader();
}
- IndexReader refreshed = null;
+ DirectoryReader refreshed = null;
try {
- refreshed = IndexReader.openIfChanged(reader);
+ refreshed = DirectoryReader.openIfChanged(reader);
if (refreshed == null) {
refreshed = reader;
}
@@ -658,11 +440,11 @@ public class TestIndexReaderReopen exten
if (hasChanges) {
if (refreshed == reader) {
- fail("No new IndexReader instance created during refresh.");
+ fail("No new DirectoryReader instance created during refresh.");
}
} else {
if (refreshed != reader) {
- fail("New IndexReader instance created during refresh even though index had no changes.");
+ fail("New DirectoryReader instance created during refresh even though index had no changes.");
}
}
@@ -689,7 +471,7 @@ public class TestIndexReaderReopen exten
w.close();
- IndexReader r = IndexReader.open(dir);
+ DirectoryReader r = DirectoryReader.open(dir);
if (multiSegment) {
assertTrue(r.getSequentialSubReaders().length > 1);
} else {
@@ -758,41 +540,25 @@ public class TestIndexReaderReopen exten
static void assertReaderClosed(IndexReader reader, boolean checkSubReaders, boolean checkNormsClosed) {
assertEquals(0, reader.getRefCount());
- if (checkNormsClosed && reader instanceof SegmentReader) {
+ if (checkNormsClosed && reader instanceof AtomicReader) {
// TODO: should we really assert something here? we check for open files and this is obselete...
// assertTrue(((SegmentReader) reader).normsClosed());
}
- if (checkSubReaders) {
- if (reader instanceof DirectoryReader) {
- IndexReader[] subReaders = reader.getSequentialSubReaders();
- for (int i = 0; i < subReaders.length; i++) {
- assertReaderClosed(subReaders[i], checkSubReaders, checkNormsClosed);
- }
- }
-
- if (reader instanceof MultiReader) {
- IndexReader[] subReaders = reader.getSequentialSubReaders();
- for (int i = 0; i < subReaders.length; i++) {
- assertReaderClosed(subReaders[i], checkSubReaders, checkNormsClosed);
- }
- }
-
- if (reader instanceof ParallelReader) {
- IndexReader[] subReaders = ((ParallelReader) reader).getSubReaders();
- for (int i = 0; i < subReaders.length; i++) {
- assertReaderClosed(subReaders[i], checkSubReaders, checkNormsClosed);
- }
+ if (checkSubReaders && reader instanceof CompositeReader) {
+ IndexReader[] subReaders = ((CompositeReader) reader).getSequentialSubReaders();
+ for (int i = 0; i < subReaders.length; i++) {
+ assertReaderClosed(subReaders[i], checkSubReaders, checkNormsClosed);
}
}
}
/*
- private void assertReaderOpen(IndexReader reader) {
+ private void assertReaderOpen(DirectoryReader reader) {
reader.ensureOpen();
if (reader instanceof DirectoryReader) {
- IndexReader[] subReaders = reader.getSequentialSubReaders();
+ DirectoryReader[] subReaders = reader.getSequentialSubReaders();
for (int i = 0; i < subReaders.length; i++) {
assertReaderOpen(subReaders[i]);
}
@@ -800,13 +566,13 @@ public class TestIndexReaderReopen exten
}
*/
- private void assertRefCountEquals(int refCount, IndexReader reader) {
+ private void assertRefCountEquals(int refCount, DirectoryReader reader) {
assertEquals("Reader has wrong refCount value.", refCount, reader.getRefCount());
}
private abstract static class TestReopen {
- protected abstract IndexReader openReader() throws IOException;
+ protected abstract DirectoryReader openReader() throws IOException;
protected abstract void modifyIndex(int i) throws IOException;
}
@@ -842,12 +608,12 @@ public class TestIndexReaderReopen exten
}
writer.close();
- IndexReader r = IndexReader.open(dir);
+ DirectoryReader r = DirectoryReader.open(dir);
assertEquals(0, r.numDocs());
- Collection<IndexCommit> commits = IndexReader.listCommits(dir);
+ Collection<IndexCommit> commits = DirectoryReader.listCommits(dir);
for (final IndexCommit commit : commits) {
- IndexReader r2 = IndexReader.openIfChanged(r, commit);
+ DirectoryReader r2 = DirectoryReader.openIfChanged(r, commit);
assertNotNull(r2);
assertTrue(r2 != r);
Modified: lucene/dev/trunk/lucene/src/test/org/apache/lucene/index/TestIndexWriter.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/src/test/org/apache/lucene/index/TestIndexWriter.java?rev=1238085&r1=1238084&r2=1238085&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/src/test/org/apache/lucene/index/TestIndexWriter.java (original)
+++ lucene/dev/trunk/lucene/src/test/org/apache/lucene/index/TestIndexWriter.java Mon Jan 30 23:34:03 2012
@@ -775,8 +775,8 @@ public class TestIndexWriter extends Luc
doc.add(newField("", "a b c", TextField.TYPE_UNSTORED));
writer.addDocument(doc);
writer.close();
- IndexReader reader = IndexReader.open(dir);
- IndexReader subreader = getOnlySegmentReader(reader);
+ DirectoryReader reader = IndexReader.open(dir);
+ AtomicReader subreader = getOnlySegmentReader(reader);
TermsEnum te = subreader.fields().terms("").iterator(null);
assertEquals(new BytesRef("a"), te.next());
assertEquals(new BytesRef("b"), te.next());
@@ -796,8 +796,8 @@ public class TestIndexWriter extends Luc
doc.add(newField("", "c", StringField.TYPE_UNSTORED));
writer.addDocument(doc);
writer.close();
- IndexReader reader = IndexReader.open(dir);
- IndexReader subreader = getOnlySegmentReader(reader);
+ DirectoryReader reader = IndexReader.open(dir);
+ AtomicReader subreader = getOnlySegmentReader(reader);
TermsEnum te = subreader.fields().terms("").iterator(null);
assertEquals(new BytesRef(""), te.next());
assertEquals(new BytesRef("a"), te.next());
@@ -1301,7 +1301,7 @@ public class TestIndexWriter extends Luc
d.add(f);
w.addDocument(d);
- IndexReader r = w.getReader().getSequentialSubReaders()[0];
+ AtomicReader r = getOnlySegmentReader(w.getReader());
TermsEnum t = r.fields().terms("field").iterator(null);
int count = 0;
while(t.next() != null) {
@@ -1331,7 +1331,7 @@ public class TestIndexWriter extends Luc
Document doc = new Document();
doc.add(newField("field", "go", TextField.TYPE_UNSTORED));
w.addDocument(doc);
- IndexReader r;
+ DirectoryReader r;
if (iter == 0) {
// use NRT
r = w.getReader();
@@ -1348,7 +1348,7 @@ public class TestIndexWriter extends Luc
if (iter == 1) {
w.commit();
}
- IndexReader r2 = IndexReader.openIfChanged(r);
+ IndexReader r2 = DirectoryReader.openIfChanged(r);
assertNotNull(r2);
assertTrue(r != r2);
files = Arrays.asList(dir.listAll());
@@ -1407,7 +1407,7 @@ public class TestIndexWriter extends Luc
doc.add(newField("c", "val", customType));
writer.addDocument(doc);
writer.commit();
- assertEquals(1, IndexReader.listCommits(dir).size());
+ assertEquals(1, DirectoryReader.listCommits(dir).size());
// Keep that commit
sdp.snapshot("id");
@@ -1417,12 +1417,12 @@ public class TestIndexWriter extends Luc
doc.add(newField("c", "val", customType));
writer.addDocument(doc);
writer.commit();
- assertEquals(2, IndexReader.listCommits(dir).size());
+ assertEquals(2, DirectoryReader.listCommits(dir).size());
// Should delete the unreferenced commit
sdp.release("id");
writer.deleteUnusedFiles();
- assertEquals(1, IndexReader.listCommits(dir).size());
+ assertEquals(1, DirectoryReader.listCommits(dir).size());
writer.close();
dir.close();
@@ -1543,7 +1543,7 @@ public class TestIndexWriter extends Luc
_TestUtil.checkIndex(dir);
assertNoUnreferencedFiles(dir, "no tv files");
- IndexReader r0 = IndexReader.open(dir);
+ DirectoryReader r0 = IndexReader.open(dir);
for (IndexReader r : r0.getSequentialSubReaders()) {
SegmentInfo s = ((SegmentReader) r).getSegmentInfo();
assertFalse(s.getHasVectors());
@@ -1675,7 +1675,7 @@ public class TestIndexWriter extends Luc
w.close();
assertEquals(1, reader.docFreq(new Term("content", bigTerm)));
- FieldCache.DocTermsIndex dti = FieldCache.DEFAULT.getTermsIndex(new SlowMultiReaderWrapper(reader), "content", random.nextBoolean());
+ FieldCache.DocTermsIndex dti = FieldCache.DEFAULT.getTermsIndex(SlowCompositeReaderWrapper.wrap(reader), "content", random.nextBoolean());
assertEquals(5, dti.numOrd()); // +1 for null ord
assertEquals(4, dti.size());
assertEquals(bigTermBytesRef, dti.lookup(3, new BytesRef()));
@@ -1727,7 +1727,7 @@ public class TestIndexWriter extends Luc
Document doc = new Document();
doc.add(newField("id", "0", StringField.TYPE_STORED));
w.addDocument(doc);
- IndexReader r = w.getReader();
+ DirectoryReader r = w.getReader();
long version = r.getVersion();
r.close();