You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@lucene.apache.org by jp...@apache.org on 2015/06/25 15:59:21 UTC
svn commit: r1687524 [6/7] - in /lucene/dev/trunk: lucene/
lucene/analysis/common/src/test/org/apache/lucene/analysis/core/
lucene/analysis/common/src/test/org/apache/lucene/analysis/sinks/
lucene/analysis/common/src/test/org/apache/lucene/analysis/sta...
Modified: lucene/dev/trunk/lucene/spatial/src/java/org/apache/lucene/spatial/prefix/PrefixTreeFacetCounter.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/spatial/src/java/org/apache/lucene/spatial/prefix/PrefixTreeFacetCounter.java?rev=1687524&r1=1687523&r2=1687524&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/spatial/src/java/org/apache/lucene/spatial/prefix/PrefixTreeFacetCounter.java (original)
+++ lucene/dev/trunk/lucene/spatial/src/java/org/apache/lucene/spatial/prefix/PrefixTreeFacetCounter.java Thu Jun 25 13:59:19 2015
@@ -183,8 +183,11 @@ public class PrefixTreeFacetCounter {
return termsEnum.docFreq();
}
int count = 0;
- postingsEnum = termsEnum.postings(acceptDocs, postingsEnum, PostingsEnum.NONE);
+ postingsEnum = termsEnum.postings(postingsEnum, PostingsEnum.NONE);
while (postingsEnum.nextDoc() != DocIdSetIterator.NO_MORE_DOCS) {
+ if (acceptDocs != null && acceptDocs.get(postingsEnum.docID()) == false) {
+ continue;
+ }
count++;
}
return count;
@@ -194,8 +197,12 @@ public class PrefixTreeFacetCounter {
if (acceptDocs == null) {
return true;
}
- postingsEnum = termsEnum.postings(acceptDocs, postingsEnum, PostingsEnum.NONE);
- return (postingsEnum.nextDoc() != DocIdSetIterator.NO_MORE_DOCS);
+ postingsEnum = termsEnum.postings(postingsEnum, PostingsEnum.NONE);
+ int nextDoc = postingsEnum.nextDoc();
+ while (nextDoc != DocIdSetIterator.NO_MORE_DOCS && acceptDocs.get(nextDoc) == false) {
+ nextDoc = postingsEnum.nextDoc();
+ }
+ return nextDoc != DocIdSetIterator.NO_MORE_DOCS;
}
}.getDocIdSet();
Modified: lucene/dev/trunk/lucene/spatial/src/java/org/apache/lucene/spatial/util/ShapeFieldCacheProvider.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/spatial/src/java/org/apache/lucene/spatial/util/ShapeFieldCacheProvider.java?rev=1687524&r1=1687523&r2=1687524&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/spatial/src/java/org/apache/lucene/spatial/util/ShapeFieldCacheProvider.java (original)
+++ lucene/dev/trunk/lucene/spatial/src/java/org/apache/lucene/spatial/util/ShapeFieldCacheProvider.java Thu Jun 25 13:59:19 2015
@@ -69,7 +69,7 @@ public abstract class ShapeFieldCachePro
while (term != null) {
T shape = readShape(term);
if( shape != null ) {
- docs = te.postings(null, docs, PostingsEnum.NONE);
+ docs = te.postings(docs, PostingsEnum.NONE);
Integer docid = docs.nextDoc();
while (docid != DocIdSetIterator.NO_MORE_DOCS) {
idx.add( docid, shape );
Modified: lucene/dev/trunk/lucene/suggest/src/java/org/apache/lucene/search/suggest/analyzing/BlendedInfixSuggester.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/suggest/src/java/org/apache/lucene/search/suggest/analyzing/BlendedInfixSuggester.java?rev=1687524&r1=1687523&r2=1687524&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/suggest/src/java/org/apache/lucene/search/suggest/analyzing/BlendedInfixSuggester.java (original)
+++ lucene/dev/trunk/lucene/suggest/src/java/org/apache/lucene/search/suggest/analyzing/BlendedInfixSuggester.java Thu Jun 25 13:59:19 2015
@@ -270,7 +270,7 @@ public class BlendedInfixSuggester exten
if (matchedTokens.contains(docTerm) || (prefixToken != null && docTerm.startsWith(prefixToken))) {
- PostingsEnum docPosEnum = it.postings(null, null, PostingsEnum.OFFSETS);
+ PostingsEnum docPosEnum = it.postings(null, PostingsEnum.OFFSETS);
docPosEnum.nextDoc();
// use the first occurrence of the term
Modified: lucene/dev/trunk/lucene/suggest/src/java/org/apache/lucene/search/suggest/document/CompletionFieldsConsumer.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/suggest/src/java/org/apache/lucene/search/suggest/document/CompletionFieldsConsumer.java?rev=1687524&r1=1687523&r2=1687524&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/suggest/src/java/org/apache/lucene/search/suggest/document/CompletionFieldsConsumer.java (original)
+++ lucene/dev/trunk/lucene/suggest/src/java/org/apache/lucene/search/suggest/document/CompletionFieldsConsumer.java Thu Jun 25 13:59:19 2015
@@ -196,7 +196,7 @@ final class CompletionFieldsConsumer ext
* Writes all postings (surface form, weight, document id) for <code>term</code>
*/
public void write(BytesRef term, TermsEnum termsEnum) throws IOException {
- postingsEnum = termsEnum.postings(null, postingsEnum, PostingsEnum.PAYLOADS);
+ postingsEnum = termsEnum.postings(postingsEnum, PostingsEnum.PAYLOADS);
builder.startTerm(term);
int docFreq = 0;
while (postingsEnum.nextDoc() != DocIdSetIterator.NO_MORE_DOCS) {
Modified: lucene/dev/trunk/lucene/suggest/src/java/org/apache/lucene/search/suggest/document/CompletionScorer.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/suggest/src/java/org/apache/lucene/search/suggest/document/CompletionScorer.java?rev=1687524&r1=1687523&r2=1687524&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/suggest/src/java/org/apache/lucene/search/suggest/document/CompletionScorer.java (original)
+++ lucene/dev/trunk/lucene/suggest/src/java/org/apache/lucene/search/suggest/document/CompletionScorer.java Thu Jun 25 13:59:19 2015
@@ -30,17 +30,17 @@ import org.apache.lucene.util.automaton.
* appropriate suggester and collecting the results
* via a collector.
*
- * {@link #score(LeafCollector, int, int)} is called
+ * {@link #score(LeafCollector, Bits, int, int)} is called
* for each leaf reader.
*
- * {@link #accept(int)} and {@link #score(float, float)}
+ * {@link #accept(int,Bits)} and {@link #score(float, float)}
* is called for every matched completion (i.e. document)
*
* @lucene.experimental
*/
public class CompletionScorer extends BulkScorer {
private final NRTSuggester suggester;
- private final Bits acceptDocs;
+ private final Bits filterDocs;
// values accessed by suggester
/** weight that created this scorer */
@@ -53,22 +53,22 @@ public class CompletionScorer extends Bu
* Creates a scorer for a field-specific <code>suggester</code> scoped by <code>acceptDocs</code>
*/
protected CompletionScorer(final CompletionWeight weight, final NRTSuggester suggester,
- final LeafReader reader, final Bits acceptDocs,
+ final LeafReader reader, final Bits filterDocs,
final boolean filtered, final Automaton automaton) throws IOException {
this.weight = weight;
this.suggester = suggester;
this.reader = reader;
this.automaton = automaton;
this.filtered = filtered;
- this.acceptDocs = acceptDocs;
+ this.filterDocs = filterDocs;
}
@Override
- public int score(LeafCollector collector, int min, int max) throws IOException {
+ public int score(LeafCollector collector, Bits acceptDocs, int min, int max) throws IOException {
if (!(collector instanceof TopSuggestDocsCollector)) {
throw new IllegalArgumentException("collector is not of type TopSuggestDocsCollector");
}
- suggester.lookup(this, ((TopSuggestDocsCollector) collector));
+ suggester.lookup(this, acceptDocs, ((TopSuggestDocsCollector) collector));
return max;
}
@@ -81,9 +81,12 @@ public class CompletionScorer extends Bu
* Returns true if a document with <code>docID</code> is accepted,
* false if the docID maps to a deleted
* document or has been filtered out
+ * @param liveDocs the {@link Bits} representing live docs, or possibly
+ * {@code null} if all docs are live
*/
- public final boolean accept(int docID) {
- return acceptDocs == null || acceptDocs.get(docID);
+ public final boolean accept(int docID, Bits liveDocs) {
+ return (filterDocs == null || filterDocs.get(docID))
+ && (liveDocs == null || liveDocs.get(docID));
}
/**
Modified: lucene/dev/trunk/lucene/suggest/src/java/org/apache/lucene/search/suggest/document/CompletionWeight.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/suggest/src/java/org/apache/lucene/search/suggest/document/CompletionWeight.java?rev=1687524&r1=1687523&r2=1687524&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/suggest/src/java/org/apache/lucene/search/suggest/document/CompletionWeight.java (original)
+++ lucene/dev/trunk/lucene/suggest/src/java/org/apache/lucene/search/suggest/document/CompletionWeight.java Thu Jun 25 13:59:19 2015
@@ -70,7 +70,7 @@ public class CompletionWeight extends We
}
@Override
- public BulkScorer bulkScorer(final LeafReaderContext context, Bits acceptDocs) throws IOException {
+ public BulkScorer bulkScorer(final LeafReaderContext context) throws IOException {
final LeafReader reader = context.reader();
final Terms terms;
final NRTSuggester suggester;
@@ -91,7 +91,7 @@ public class CompletionWeight extends We
DocIdSet docIdSet = null;
Filter filter = completionQuery.getFilter();
if (filter != null) {
- docIdSet = filter.getDocIdSet(context, acceptDocs);
+ docIdSet = filter.getDocIdSet(context, null);
if (docIdSet == null || docIdSet.iterator() == null) {
// filter matches no docs in current leave
return null;
@@ -99,7 +99,7 @@ public class CompletionWeight extends We
throw new IllegalArgumentException("DocIDSet does not provide random access interface");
}
}
- Bits acceptDocBits = (docIdSet != null) ? docIdSet.bits() : acceptDocs;
+ Bits acceptDocBits = (docIdSet != null) ? docIdSet.bits() : null;
return new CompletionScorer(this, suggester, reader, acceptDocBits, filter != null, automaton);
}
@@ -134,7 +134,7 @@ public class CompletionWeight extends We
}
@Override
- public Scorer scorer(LeafReaderContext context, Bits acceptDocs) throws IOException {
+ public Scorer scorer(LeafReaderContext context) throws IOException {
throw new UnsupportedOperationException();
}
Modified: lucene/dev/trunk/lucene/suggest/src/java/org/apache/lucene/search/suggest/document/NRTSuggester.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/suggest/src/java/org/apache/lucene/search/suggest/document/NRTSuggester.java?rev=1687524&r1=1687523&r2=1687524&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/suggest/src/java/org/apache/lucene/search/suggest/document/NRTSuggester.java (original)
+++ lucene/dev/trunk/lucene/suggest/src/java/org/apache/lucene/search/suggest/document/NRTSuggester.java Thu Jun 25 13:59:19 2015
@@ -28,6 +28,7 @@ import org.apache.lucene.store.ByteArray
import org.apache.lucene.store.ByteArrayDataOutput;
import org.apache.lucene.store.IndexInput;
import org.apache.lucene.util.Accountable;
+import org.apache.lucene.util.Bits;
import org.apache.lucene.util.BytesRef;
import org.apache.lucene.util.CharsRefBuilder;
import org.apache.lucene.util.fst.ByteSequenceOutputs;
@@ -44,7 +45,7 @@ import static org.apache.lucene.search.s
* <p>
* NRTSuggester executes Top N search on a weighted FST specified by a {@link CompletionScorer}
* <p>
- * See {@link #lookup(CompletionScorer, TopSuggestDocsCollector)} for more implementation
+ * See {@link #lookup(CompletionScorer, Bits, TopSuggestDocsCollector)} for more implementation
* details.
* <p>
* FST Format:
@@ -56,7 +57,7 @@ import static org.apache.lucene.search.s
* NOTE:
* <ul>
* <li>having too many deletions or using a very restrictive filter can make the search inadmissible due to
- * over-pruning of potential paths. See {@link CompletionScorer#accept(int)}</li>
+ * over-pruning of potential paths. See {@link CompletionScorer#accept(int, Bits)}</li>
* <li>when matched documents are arbitrarily filtered ({@link CompletionScorer#filtered} set to <code>true</code>,
* it is assumed that the filter will roughly filter out half the number of documents that match
* the provided automaton</li>
@@ -120,12 +121,12 @@ public final class NRTSuggester implemen
* The {@link CompletionScorer#automaton} is intersected with the {@link #fst}.
* {@link CompletionScorer#weight} is used to compute boosts and/or extract context
* for each matched partial paths. A top N search is executed on {@link #fst} seeded with
- * the matched partial paths. Upon reaching a completed path, {@link CompletionScorer#accept(int)}
+ * the matched partial paths. Upon reaching a completed path, {@link CompletionScorer#accept(int, Bits)}
* and {@link CompletionScorer#score(float, float)} is used on the document id, index weight
* and query boost to filter and score the entry, before being collected via
* {@link TopSuggestDocsCollector#collect(int, CharSequence, CharSequence, float)}
*/
- public void lookup(final CompletionScorer scorer, final TopSuggestDocsCollector collector) throws IOException {
+ public void lookup(final CompletionScorer scorer, Bits acceptDocs, final TopSuggestDocsCollector collector) throws IOException {
final double liveDocsRatio = calculateLiveDocRatio(scorer.reader.numDocs(), scorer.reader.maxDoc());
if (liveDocsRatio == -1) {
return;
@@ -143,7 +144,7 @@ public final class NRTSuggester implemen
protected boolean acceptResult(Util.FSTPath<Pair<Long, BytesRef>> path) {
int payloadSepIndex = parseSurfaceForm(path.cost.output2, payloadSep, spare);
int docID = parseDocID(path.cost.output2, payloadSepIndex);
- if (!scorer.accept(docID)) {
+ if (!scorer.accept(docID, acceptDocs)) {
return false;
}
try {
Modified: lucene/dev/trunk/lucene/suggest/src/java/org/apache/lucene/search/suggest/document/SuggestIndexSearcher.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/suggest/src/java/org/apache/lucene/search/suggest/document/SuggestIndexSearcher.java?rev=1687524&r1=1687523&r2=1687524&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/suggest/src/java/org/apache/lucene/search/suggest/document/SuggestIndexSearcher.java (original)
+++ lucene/dev/trunk/lucene/suggest/src/java/org/apache/lucene/search/suggest/document/SuggestIndexSearcher.java Thu Jun 25 13:59:19 2015
@@ -70,10 +70,10 @@ public class SuggestIndexSearcher extend
query = (CompletionQuery) query.rewrite(getIndexReader());
Weight weight = query.createWeight(this, collector.needsScores());
for (LeafReaderContext context : getIndexReader().leaves()) {
- BulkScorer scorer = weight.bulkScorer(context, context.reader().getLiveDocs());
+ BulkScorer scorer = weight.bulkScorer(context);
if (scorer != null) {
try {
- scorer.score(collector.getLeafCollector(context));
+ scorer.score(collector.getLeafCollector(context), context.reader().getLiveDocs());
} catch (CollectionTerminatedException e) {
// collection was terminated prematurely
// continue with the following leaf
Modified: lucene/dev/trunk/lucene/test-framework/src/java/org/apache/lucene/codecs/asserting/AssertingPostingsFormat.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/test-framework/src/java/org/apache/lucene/codecs/asserting/AssertingPostingsFormat.java?rev=1687524&r1=1687523&r2=1687524&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/test-framework/src/java/org/apache/lucene/codecs/asserting/AssertingPostingsFormat.java (original)
+++ lucene/dev/trunk/lucene/test-framework/src/java/org/apache/lucene/codecs/asserting/AssertingPostingsFormat.java Thu Jun 25 13:59:19 2015
@@ -187,7 +187,7 @@ public final class AssertingPostingsForm
if (hasFreqs) {
flags = flags | PostingsEnum.FREQS;
}
- postingsEnum = termsEnum.postings(null, postingsEnum, flags);
+ postingsEnum = termsEnum.postings(postingsEnum, flags);
} else {
flags = PostingsEnum.POSITIONS;
if (hasPayloads) {
@@ -196,7 +196,7 @@ public final class AssertingPostingsForm
if (hasOffsets) {
flags = flags | PostingsEnum.OFFSETS;
}
- postingsEnum = termsEnum.postings(null, postingsEnum, flags);
+ postingsEnum = termsEnum.postings(postingsEnum, flags);
}
assert postingsEnum != null : "termsEnum=" + termsEnum + " hasPositions=" + hasPositions;
Modified: lucene/dev/trunk/lucene/test-framework/src/java/org/apache/lucene/codecs/ramonly/RAMOnlyPostingsFormat.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/test-framework/src/java/org/apache/lucene/codecs/ramonly/RAMOnlyPostingsFormat.java?rev=1687524&r1=1687523&r2=1687524&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/test-framework/src/java/org/apache/lucene/codecs/ramonly/RAMOnlyPostingsFormat.java (original)
+++ lucene/dev/trunk/lucene/test-framework/src/java/org/apache/lucene/codecs/ramonly/RAMOnlyPostingsFormat.java Thu Jun 25 13:59:19 2015
@@ -47,7 +47,6 @@ import org.apache.lucene.store.IndexInpu
import org.apache.lucene.store.IndexOutput;
import org.apache.lucene.util.Accountable;
import org.apache.lucene.util.Accountables;
-import org.apache.lucene.util.Bits;
import org.apache.lucene.util.BytesRef;
import org.apache.lucene.util.FixedBitSet;
import org.apache.lucene.util.IOUtils;
@@ -284,7 +283,7 @@ public final class RAMOnlyPostingsFormat
break;
}
RAMPostingsWriterImpl postingsWriter = termsConsumer.startTerm(term);
- postingsEnum = termsEnum.postings(null, postingsEnum, enumFlags);
+ postingsEnum = termsEnum.postings(postingsEnum, enumFlags);
int docFreq = 0;
long totalTermFreq = 0;
@@ -470,22 +469,20 @@ public final class RAMOnlyPostingsFormat
}
@Override
- public PostingsEnum postings(Bits liveDocs, PostingsEnum reuse, int flags) {
- return new RAMDocsEnum(ramField.termToDocs.get(current), liveDocs);
+ public PostingsEnum postings(PostingsEnum reuse, int flags) {
+ return new RAMDocsEnum(ramField.termToDocs.get(current));
}
}
private static class RAMDocsEnum extends PostingsEnum {
private final RAMTerm ramTerm;
- private final Bits liveDocs;
private RAMDoc current;
int upto = -1;
int posUpto = 0;
- public RAMDocsEnum(RAMTerm ramTerm, Bits liveDocs) {
+ public RAMDocsEnum(RAMTerm ramTerm) {
this.ramTerm = ramTerm;
- this.liveDocs = liveDocs;
}
@Override
@@ -496,17 +493,13 @@ public final class RAMOnlyPostingsFormat
// TODO: override bulk read, for better perf
@Override
public int nextDoc() {
- while(true) {
- upto++;
- if (upto < ramTerm.docs.size()) {
- current = ramTerm.docs.get(upto);
- if (liveDocs == null || liveDocs.get(current.docID)) {
- posUpto = 0;
- return current.docID;
- }
- } else {
- return NO_MORE_DOCS;
- }
+ upto++;
+ if (upto < ramTerm.docs.size()) {
+ current = ramTerm.docs.get(upto);
+ posUpto = 0;
+ return current.docID;
+ } else {
+ return NO_MORE_DOCS;
}
}
Modified: lucene/dev/trunk/lucene/test-framework/src/java/org/apache/lucene/index/AssertingLeafReader.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/test-framework/src/java/org/apache/lucene/index/AssertingLeafReader.java?rev=1687524&r1=1687523&r2=1687524&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/test-framework/src/java/org/apache/lucene/index/AssertingLeafReader.java (original)
+++ lucene/dev/trunk/lucene/test-framework/src/java/org/apache/lucene/index/AssertingLeafReader.java Thu Jun 25 13:59:19 2015
@@ -143,7 +143,7 @@ public class AssertingLeafReader extends
}
@Override
- public PostingsEnum postings(Bits liveDocs, PostingsEnum reuse, int flags) throws IOException {
+ public PostingsEnum postings(PostingsEnum reuse, int flags) throws IOException {
assertThread("Terms enums", creationThread);
assert state == State.POSITIONED: "docs(...) called on unpositioned TermsEnum";
@@ -154,7 +154,7 @@ public class AssertingLeafReader extends
} else {
actualReuse = null;
}
- PostingsEnum docs = super.postings(liveDocs, actualReuse, flags);
+ PostingsEnum docs = super.postings(actualReuse, flags);
assert docs != null;
if (docs == actualReuse) {
// codec reused, reset asserting state
Modified: lucene/dev/trunk/lucene/test-framework/src/java/org/apache/lucene/index/BasePostingsFormatTestCase.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/test-framework/src/java/org/apache/lucene/index/BasePostingsFormatTestCase.java?rev=1687524&r1=1687523&r2=1687524&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/test-framework/src/java/org/apache/lucene/index/BasePostingsFormatTestCase.java (original)
+++ lucene/dev/trunk/lucene/test-framework/src/java/org/apache/lucene/index/BasePostingsFormatTestCase.java Thu Jun 25 13:59:19 2015
@@ -176,8 +176,8 @@ public abstract class BasePostingsFormat
}
protected static void checkReuse(TermsEnum termsEnum, int firstFlags, int secondFlags, boolean shouldReuse) throws IOException {
- PostingsEnum postings1 = termsEnum.postings(null, null, firstFlags);
- PostingsEnum postings2 = termsEnum.postings(null, postings1, secondFlags);
+ PostingsEnum postings1 = termsEnum.postings(null, firstFlags);
+ PostingsEnum postings2 = termsEnum.postings(postings1, secondFlags);
if (shouldReuse)
assertSame("Expected PostingsEnum " + postings1.getClass().getName() + " to be reused", postings1, postings2);
else
@@ -247,7 +247,7 @@ public abstract class BasePostingsFormat
LeafReader ar = getOnlySegmentReader(ir);
TermsEnum termsEnum = ar.terms("field").iterator();
assertTrue(termsEnum.seekExact(new BytesRef("value")));
- PostingsEnum docsEnum = termsEnum.postings(null, null, PostingsEnum.NONE);
+ PostingsEnum docsEnum = termsEnum.postings(null, PostingsEnum.NONE);
assertEquals(0, docsEnum.nextDoc());
assertEquals(1, docsEnum.freq());
assertEquals(1, docsEnum.nextDoc());
@@ -270,7 +270,7 @@ public abstract class BasePostingsFormat
LeafReader ar = getOnlySegmentReader(ir);
TermsEnum termsEnum = ar.terms("field").iterator();
assertTrue(termsEnum.seekExact(new BytesRef("value")));
- PostingsEnum docsEnum = termsEnum.postings(null, null, PostingsEnum.POSITIONS);
+ PostingsEnum docsEnum = termsEnum.postings(null, PostingsEnum.POSITIONS);
assertEquals(0, docsEnum.nextDoc());
assertEquals(1, docsEnum.freq());
assertEquals(1, docsEnum.nextDoc());
@@ -306,7 +306,7 @@ public abstract class BasePostingsFormat
TermsEnum termsEnum = terms.iterator();
BytesRef term = termsEnum.next();
if (term != null) {
- PostingsEnum postingsEnum = termsEnum.postings(null, null);
+ PostingsEnum postingsEnum = termsEnum.postings(null);
assertTrue(postingsEnum.nextDoc() == PostingsEnum.NO_MORE_DOCS);
}
}
@@ -398,9 +398,9 @@ public abstract class BasePostingsFormat
// TODO: also sometimes ask for payloads/offsets?
boolean noPositions = random().nextBoolean();
if (noPositions) {
- docs = termsEnum.postings(null, docs, PostingsEnum.FREQS);
+ docs = termsEnum.postings(docs, PostingsEnum.FREQS);
} else {
- docs = termsEnum.postings(null, null, PostingsEnum.POSITIONS);
+ docs = termsEnum.postings(null, PostingsEnum.POSITIONS);
}
int docFreq = 0;
long totalTermFreq = 0;
@@ -447,9 +447,9 @@ public abstract class BasePostingsFormat
// TODO: also sometimes ask for payloads/offsets?
boolean noPositions = random().nextBoolean();
if (noPositions) {
- docs = termsEnum.postings(null, docs, PostingsEnum.FREQS);
+ docs = termsEnum.postings(docs, PostingsEnum.FREQS);
} else {
- docs = termsEnum.postings(null, null, PostingsEnum.POSITIONS);
+ docs = termsEnum.postings(null, PostingsEnum.POSITIONS);
}
int docFreq = 0;
@@ -579,7 +579,7 @@ public abstract class BasePostingsFormat
// termsenum reuse (FREQS)
TermsEnum termsEnum = getOnlySegmentReader(reader).terms("foo").iterator();
termsEnum.seekExact(new BytesRef("bar"));
- PostingsEnum postings2 = termsEnum.postings(null, postings);
+ PostingsEnum postings2 = termsEnum.postings(postings);
assertNotNull(postings2);
assertReused("foo", postings, postings2);
// and it had better work
@@ -590,13 +590,13 @@ public abstract class BasePostingsFormat
// asking for any flags: ok
for (int flag : new int[] { NONE, FREQS, POSITIONS, PAYLOADS, OFFSETS, ALL }) {
- postings = termsEnum.postings(null, null, flag);
+ postings = termsEnum.postings(null, flag);
assertEquals(-1, postings.docID());
assertEquals(0, postings.nextDoc());
assertEquals(1, postings.freq());
assertEquals(DocIdSetIterator.NO_MORE_DOCS, postings.nextDoc());
// reuse that too
- postings2 = termsEnum.postings(null, postings, flag);
+ postings2 = termsEnum.postings(postings, flag);
assertNotNull(postings2);
assertReused("foo", postings, postings2);
// and it had better work
@@ -637,7 +637,7 @@ public abstract class BasePostingsFormat
// termsenum reuse (FREQS)
TermsEnum termsEnum = getOnlySegmentReader(reader).terms("foo").iterator();
termsEnum.seekExact(new BytesRef("bar"));
- PostingsEnum postings2 = termsEnum.postings(null, postings);
+ PostingsEnum postings2 = termsEnum.postings(postings);
assertNotNull(postings2);
assertReused("foo", postings, postings2);
// and it had better work
@@ -647,14 +647,14 @@ public abstract class BasePostingsFormat
assertEquals(DocIdSetIterator.NO_MORE_DOCS, postings2.nextDoc());
// asking for docs only: ok
- PostingsEnum docsOnly = termsEnum.postings(null, null, PostingsEnum.NONE);
+ PostingsEnum docsOnly = termsEnum.postings(null, PostingsEnum.NONE);
assertEquals(-1, docsOnly.docID());
assertEquals(0, docsOnly.nextDoc());
// we don't define what it is, but if its something else, we should look into it?
assertTrue(docsOnly.freq() == 1 || docsOnly.freq() == 2);
assertEquals(DocIdSetIterator.NO_MORE_DOCS, docsOnly.nextDoc());
// reuse that too
- PostingsEnum docsOnly2 = termsEnum.postings(null, docsOnly, PostingsEnum.NONE);
+ PostingsEnum docsOnly2 = termsEnum.postings(docsOnly, PostingsEnum.NONE);
assertNotNull(docsOnly2);
assertReused("foo", docsOnly, docsOnly2);
// and it had better work
@@ -666,7 +666,7 @@ public abstract class BasePostingsFormat
// asking for any flags: ok
for (int flag : new int[] { NONE, FREQS, POSITIONS, PAYLOADS, OFFSETS, ALL }) {
- postings = termsEnum.postings(null, null, flag);
+ postings = termsEnum.postings(null, flag);
assertEquals(-1, postings.docID());
assertEquals(0, postings.nextDoc());
if (flag != NONE) {
@@ -674,7 +674,7 @@ public abstract class BasePostingsFormat
}
assertEquals(DocIdSetIterator.NO_MORE_DOCS, postings.nextDoc());
// reuse that too
- postings2 = termsEnum.postings(null, postings, flag);
+ postings2 = termsEnum.postings(postings, flag);
assertNotNull(postings2);
assertReused("foo", postings, postings2);
// and it had better work
@@ -715,7 +715,7 @@ public abstract class BasePostingsFormat
// termsenum reuse (FREQS)
TermsEnum termsEnum = getOnlySegmentReader(reader).terms("foo").iterator();
termsEnum.seekExact(new BytesRef("bar"));
- PostingsEnum postings2 = termsEnum.postings(null, postings);
+ PostingsEnum postings2 = termsEnum.postings(postings);
assertNotNull(postings2);
assertReused("foo", postings, postings2);
// and it had better work
@@ -725,14 +725,14 @@ public abstract class BasePostingsFormat
assertEquals(DocIdSetIterator.NO_MORE_DOCS, postings2.nextDoc());
// asking for docs only: ok
- PostingsEnum docsOnly = termsEnum.postings(null, null, PostingsEnum.NONE);
+ PostingsEnum docsOnly = termsEnum.postings(null, PostingsEnum.NONE);
assertEquals(-1, docsOnly.docID());
assertEquals(0, docsOnly.nextDoc());
// we don't define what it is, but if its something else, we should look into it?
assertTrue(docsOnly.freq() == 1 || docsOnly.freq() == 2);
assertEquals(DocIdSetIterator.NO_MORE_DOCS, docsOnly.nextDoc());
// reuse that too
- PostingsEnum docsOnly2 = termsEnum.postings(null, docsOnly, PostingsEnum.NONE);
+ PostingsEnum docsOnly2 = termsEnum.postings(docsOnly, PostingsEnum.NONE);
assertNotNull(docsOnly2);
assertReused("foo", docsOnly, docsOnly2);
// and it had better work
@@ -758,7 +758,7 @@ public abstract class BasePostingsFormat
assertEquals(DocIdSetIterator.NO_MORE_DOCS, docsAndPositionsEnum.nextDoc());
// now reuse the positions
- PostingsEnum docsAndPositionsEnum2 = termsEnum.postings(null, docsAndPositionsEnum, PostingsEnum.POSITIONS);
+ PostingsEnum docsAndPositionsEnum2 = termsEnum.postings(docsAndPositionsEnum, PostingsEnum.POSITIONS);
assertReused("foo", docsAndPositionsEnum, docsAndPositionsEnum2);
assertEquals(-1, docsAndPositionsEnum2.docID());
assertEquals(0, docsAndPositionsEnum2.nextDoc());
@@ -790,7 +790,7 @@ public abstract class BasePostingsFormat
assertNull(docsAndPositionsEnum.getPayload());
assertEquals(DocIdSetIterator.NO_MORE_DOCS, docsAndPositionsEnum.nextDoc());
// reuse
- docsAndPositionsEnum2 = termsEnum.postings(null, docsAndPositionsEnum, PostingsEnum.PAYLOADS);
+ docsAndPositionsEnum2 = termsEnum.postings(docsAndPositionsEnum, PostingsEnum.PAYLOADS);
assertReused("foo", docsAndPositionsEnum, docsAndPositionsEnum2);
assertEquals(-1, docsAndPositionsEnum2.docID());
assertEquals(0, docsAndPositionsEnum2.nextDoc());
@@ -820,7 +820,7 @@ public abstract class BasePostingsFormat
assertNull(docsAndPositionsEnum.getPayload());
assertEquals(DocIdSetIterator.NO_MORE_DOCS, docsAndPositionsEnum.nextDoc());
// reuse
- docsAndPositionsEnum2 = termsEnum.postings(null, docsAndPositionsEnum, PostingsEnum.OFFSETS);
+ docsAndPositionsEnum2 = termsEnum.postings(docsAndPositionsEnum, PostingsEnum.OFFSETS);
assertReused("foo", docsAndPositionsEnum, docsAndPositionsEnum2);
assertEquals(-1, docsAndPositionsEnum2.docID());
assertEquals(0, docsAndPositionsEnum2.nextDoc());
@@ -849,7 +849,7 @@ public abstract class BasePostingsFormat
assertEquals(-1, docsAndPositionsEnum.endOffset());
assertNull(docsAndPositionsEnum.getPayload());
assertEquals(DocIdSetIterator.NO_MORE_DOCS, docsAndPositionsEnum.nextDoc());
- docsAndPositionsEnum2 = termsEnum.postings(null, docsAndPositionsEnum, PostingsEnum.ALL);
+ docsAndPositionsEnum2 = termsEnum.postings(docsAndPositionsEnum, PostingsEnum.ALL);
assertReused("foo", docsAndPositionsEnum, docsAndPositionsEnum2);
assertEquals(-1, docsAndPositionsEnum2.docID());
assertEquals(0, docsAndPositionsEnum2.nextDoc());
@@ -895,7 +895,7 @@ public abstract class BasePostingsFormat
// termsenum reuse (FREQS)
TermsEnum termsEnum = getOnlySegmentReader(reader).terms("foo").iterator();
termsEnum.seekExact(new BytesRef("bar"));
- PostingsEnum postings2 = termsEnum.postings(null, postings);
+ PostingsEnum postings2 = termsEnum.postings(postings);
assertNotNull(postings2);
assertReused("foo", postings, postings2);
// and it had better work
@@ -905,14 +905,14 @@ public abstract class BasePostingsFormat
assertEquals(DocIdSetIterator.NO_MORE_DOCS, postings2.nextDoc());
// asking for docs only: ok
- PostingsEnum docsOnly = termsEnum.postings(null, null, PostingsEnum.NONE);
+ PostingsEnum docsOnly = termsEnum.postings(null, PostingsEnum.NONE);
assertEquals(-1, docsOnly.docID());
assertEquals(0, docsOnly.nextDoc());
// we don't define what it is, but if its something else, we should look into it?
assertTrue(docsOnly.freq() == 1 || docsOnly.freq() == 2);
assertEquals(DocIdSetIterator.NO_MORE_DOCS, docsOnly.nextDoc());
// reuse that too
- PostingsEnum docsOnly2 = termsEnum.postings(null, docsOnly, PostingsEnum.NONE);
+ PostingsEnum docsOnly2 = termsEnum.postings(docsOnly, PostingsEnum.NONE);
assertNotNull(docsOnly2);
assertReused("foo", docsOnly, docsOnly2);
// and it had better work
@@ -940,7 +940,7 @@ public abstract class BasePostingsFormat
assertEquals(DocIdSetIterator.NO_MORE_DOCS, docsAndPositionsEnum.nextDoc());
// now reuse the positions
- PostingsEnum docsAndPositionsEnum2 = termsEnum.postings(null, docsAndPositionsEnum, PostingsEnum.POSITIONS);
+ PostingsEnum docsAndPositionsEnum2 = termsEnum.postings(docsAndPositionsEnum, PostingsEnum.POSITIONS);
assertReused("foo", docsAndPositionsEnum, docsAndPositionsEnum2);
assertEquals(-1, docsAndPositionsEnum2.docID());
assertEquals(0, docsAndPositionsEnum2.nextDoc());
@@ -976,7 +976,7 @@ public abstract class BasePostingsFormat
assertNull(docsAndPositionsEnum.getPayload());
assertEquals(DocIdSetIterator.NO_MORE_DOCS, docsAndPositionsEnum.nextDoc());
// reuse
- docsAndPositionsEnum2 = termsEnum.postings(null, docsAndPositionsEnum, PostingsEnum.PAYLOADS);
+ docsAndPositionsEnum2 = termsEnum.postings(docsAndPositionsEnum, PostingsEnum.PAYLOADS);
assertReused("foo", docsAndPositionsEnum, docsAndPositionsEnum2);
assertEquals(-1, docsAndPositionsEnum2.docID());
assertEquals(0, docsAndPositionsEnum2.nextDoc());
@@ -1008,7 +1008,7 @@ public abstract class BasePostingsFormat
assertNull(docsAndPositionsEnum.getPayload());
assertEquals(DocIdSetIterator.NO_MORE_DOCS, docsAndPositionsEnum.nextDoc());
// reuse
- docsAndPositionsEnum2 = termsEnum.postings(null, docsAndPositionsEnum, PostingsEnum.OFFSETS);
+ docsAndPositionsEnum2 = termsEnum.postings(docsAndPositionsEnum, PostingsEnum.OFFSETS);
assertReused("foo", docsAndPositionsEnum, docsAndPositionsEnum2);
assertEquals(-1, docsAndPositionsEnum2.docID());
assertEquals(0, docsAndPositionsEnum2.nextDoc());
@@ -1037,7 +1037,7 @@ public abstract class BasePostingsFormat
assertEquals(7, docsAndPositionsEnum.endOffset());
assertNull(docsAndPositionsEnum.getPayload());
assertEquals(DocIdSetIterator.NO_MORE_DOCS, docsAndPositionsEnum.nextDoc());
- docsAndPositionsEnum2 = termsEnum.postings(null, docsAndPositionsEnum, PostingsEnum.ALL);
+ docsAndPositionsEnum2 = termsEnum.postings(docsAndPositionsEnum, PostingsEnum.ALL);
assertReused("foo", docsAndPositionsEnum, docsAndPositionsEnum2);
assertEquals(-1, docsAndPositionsEnum2.docID());
assertEquals(0, docsAndPositionsEnum2.nextDoc());
@@ -1080,7 +1080,7 @@ public abstract class BasePostingsFormat
// termsenum reuse (FREQS)
TermsEnum termsEnum = getOnlySegmentReader(reader).terms("foo").iterator();
termsEnum.seekExact(new BytesRef("bar"));
- PostingsEnum postings2 = termsEnum.postings(null, postings);
+ PostingsEnum postings2 = termsEnum.postings(postings);
assertNotNull(postings2);
assertReused("foo", postings, postings2);
// and it had better work
@@ -1090,14 +1090,14 @@ public abstract class BasePostingsFormat
assertEquals(DocIdSetIterator.NO_MORE_DOCS, postings2.nextDoc());
// asking for docs only: ok
- PostingsEnum docsOnly = termsEnum.postings(null, null, PostingsEnum.NONE);
+ PostingsEnum docsOnly = termsEnum.postings(null, PostingsEnum.NONE);
assertEquals(-1, docsOnly.docID());
assertEquals(0, docsOnly.nextDoc());
// we don't define what it is, but if its something else, we should look into it?
assertTrue(docsOnly.freq() == 1 || docsOnly.freq() == 2);
assertEquals(DocIdSetIterator.NO_MORE_DOCS, docsOnly.nextDoc());
// reuse that too
- PostingsEnum docsOnly2 = termsEnum.postings(null, docsOnly, PostingsEnum.NONE);
+ PostingsEnum docsOnly2 = termsEnum.postings(docsOnly, PostingsEnum.NONE);
assertNotNull(docsOnly2);
assertReused("foo", docsOnly, docsOnly2);
// and it had better work
@@ -1125,7 +1125,7 @@ public abstract class BasePostingsFormat
assertEquals(DocIdSetIterator.NO_MORE_DOCS, docsAndPositionsEnum.nextDoc());
// now reuse the positions
- PostingsEnum docsAndPositionsEnum2 = termsEnum.postings(null, docsAndPositionsEnum, PostingsEnum.POSITIONS);
+ PostingsEnum docsAndPositionsEnum2 = termsEnum.postings(docsAndPositionsEnum, PostingsEnum.POSITIONS);
assertReused("foo", docsAndPositionsEnum, docsAndPositionsEnum2);
assertEquals(-1, docsAndPositionsEnum2.docID());
assertEquals(0, docsAndPositionsEnum2.nextDoc());
@@ -1158,7 +1158,7 @@ public abstract class BasePostingsFormat
assertEquals(new BytesRef("pay2"), docsAndPositionsEnum.getPayload());
assertEquals(DocIdSetIterator.NO_MORE_DOCS, docsAndPositionsEnum.nextDoc());
// reuse
- docsAndPositionsEnum2 = termsEnum.postings(null, docsAndPositionsEnum, PostingsEnum.PAYLOADS);
+ docsAndPositionsEnum2 = termsEnum.postings(docsAndPositionsEnum, PostingsEnum.PAYLOADS);
assertReused("foo", docsAndPositionsEnum, docsAndPositionsEnum2);
assertEquals(-1, docsAndPositionsEnum2.docID());
assertEquals(0, docsAndPositionsEnum2.nextDoc());
@@ -1190,7 +1190,7 @@ public abstract class BasePostingsFormat
assertTrue(docsAndPositionsEnum.getPayload() == null || new BytesRef("pay2").equals(docsAndPositionsEnum.getPayload()));
assertEquals(DocIdSetIterator.NO_MORE_DOCS, docsAndPositionsEnum.nextDoc());
// reuse
- docsAndPositionsEnum2 = termsEnum.postings(null, docsAndPositionsEnum, PostingsEnum.OFFSETS);
+ docsAndPositionsEnum2 = termsEnum.postings(docsAndPositionsEnum, PostingsEnum.OFFSETS);
assertReused("foo", docsAndPositionsEnum, docsAndPositionsEnum2);
assertEquals(-1, docsAndPositionsEnum2.docID());
assertEquals(0, docsAndPositionsEnum2.nextDoc());
@@ -1221,7 +1221,7 @@ public abstract class BasePostingsFormat
assertEquals(-1, docsAndPositionsEnum.endOffset());
assertEquals(new BytesRef("pay2"), docsAndPositionsEnum.getPayload());
assertEquals(DocIdSetIterator.NO_MORE_DOCS, docsAndPositionsEnum.nextDoc());
- docsAndPositionsEnum2 = termsEnum.postings(null, docsAndPositionsEnum, PostingsEnum.ALL);
+ docsAndPositionsEnum2 = termsEnum.postings(docsAndPositionsEnum, PostingsEnum.ALL);
assertReused("foo", docsAndPositionsEnum, docsAndPositionsEnum2);
assertEquals(-1, docsAndPositionsEnum2.docID());
assertEquals(0, docsAndPositionsEnum2.nextDoc());
@@ -1266,7 +1266,7 @@ public abstract class BasePostingsFormat
// termsenum reuse (FREQS)
TermsEnum termsEnum = getOnlySegmentReader(reader).terms("foo").iterator();
termsEnum.seekExact(new BytesRef("bar"));
- PostingsEnum postings2 = termsEnum.postings(null, postings);
+ PostingsEnum postings2 = termsEnum.postings(postings);
assertNotNull(postings2);
assertReused("foo", postings, postings2);
// and it had better work
@@ -1276,14 +1276,14 @@ public abstract class BasePostingsFormat
assertEquals(DocIdSetIterator.NO_MORE_DOCS, postings2.nextDoc());
// asking for docs only: ok
- PostingsEnum docsOnly = termsEnum.postings(null, null, PostingsEnum.NONE);
+ PostingsEnum docsOnly = termsEnum.postings(null, PostingsEnum.NONE);
assertEquals(-1, docsOnly.docID());
assertEquals(0, docsOnly.nextDoc());
// we don't define what it is, but if its something else, we should look into it?
assertTrue(docsOnly.freq() == 1 || docsOnly.freq() == 2);
assertEquals(DocIdSetIterator.NO_MORE_DOCS, docsOnly.nextDoc());
// reuse that too
- PostingsEnum docsOnly2 = termsEnum.postings(null, docsOnly, PostingsEnum.NONE);
+ PostingsEnum docsOnly2 = termsEnum.postings(docsOnly, PostingsEnum.NONE);
assertNotNull(docsOnly2);
assertReused("foo", docsOnly, docsOnly2);
// and it had better work
@@ -1313,7 +1313,7 @@ public abstract class BasePostingsFormat
assertEquals(DocIdSetIterator.NO_MORE_DOCS, docsAndPositionsEnum.nextDoc());
// now reuse the positions
- PostingsEnum docsAndPositionsEnum2 = termsEnum.postings(null, docsAndPositionsEnum, PostingsEnum.POSITIONS);
+ PostingsEnum docsAndPositionsEnum2 = termsEnum.postings(docsAndPositionsEnum, PostingsEnum.POSITIONS);
assertReused("foo", docsAndPositionsEnum, docsAndPositionsEnum2);
assertEquals(-1, docsAndPositionsEnum2.docID());
assertEquals(0, docsAndPositionsEnum2.nextDoc());
@@ -1350,7 +1350,7 @@ public abstract class BasePostingsFormat
assertEquals(new BytesRef("pay2"), docsAndPositionsEnum.getPayload());
assertEquals(DocIdSetIterator.NO_MORE_DOCS, docsAndPositionsEnum.nextDoc());
// reuse
- docsAndPositionsEnum2 = termsEnum.postings(null, docsAndPositionsEnum, PostingsEnum.PAYLOADS);
+ docsAndPositionsEnum2 = termsEnum.postings(docsAndPositionsEnum, PostingsEnum.PAYLOADS);
assertReused("foo", docsAndPositionsEnum, docsAndPositionsEnum2);
assertEquals(-1, docsAndPositionsEnum2.docID());
assertEquals(0, docsAndPositionsEnum2.nextDoc());
@@ -1384,7 +1384,7 @@ public abstract class BasePostingsFormat
assertTrue(docsAndPositionsEnum.getPayload() == null || new BytesRef("pay2").equals(docsAndPositionsEnum.getPayload()));
assertEquals(DocIdSetIterator.NO_MORE_DOCS, docsAndPositionsEnum.nextDoc());
// reuse
- docsAndPositionsEnum2 = termsEnum.postings(null, docsAndPositionsEnum, PostingsEnum.OFFSETS);
+ docsAndPositionsEnum2 = termsEnum.postings(docsAndPositionsEnum, PostingsEnum.OFFSETS);
assertReused("foo", docsAndPositionsEnum, docsAndPositionsEnum2);
assertEquals(-1, docsAndPositionsEnum2.docID());
assertEquals(0, docsAndPositionsEnum2.nextDoc());
@@ -1415,7 +1415,7 @@ public abstract class BasePostingsFormat
assertEquals(7, docsAndPositionsEnum.endOffset());
assertEquals(new BytesRef("pay2"), docsAndPositionsEnum.getPayload());
assertEquals(DocIdSetIterator.NO_MORE_DOCS, docsAndPositionsEnum.nextDoc());
- docsAndPositionsEnum2 = termsEnum.postings(null, docsAndPositionsEnum, PostingsEnum.ALL);
+ docsAndPositionsEnum2 = termsEnum.postings(docsAndPositionsEnum, PostingsEnum.ALL);
assertReused("foo", docsAndPositionsEnum, docsAndPositionsEnum2);
assertEquals(-1, docsAndPositionsEnum2.docID());
assertEquals(0, docsAndPositionsEnum2.nextDoc());
Modified: lucene/dev/trunk/lucene/test-framework/src/java/org/apache/lucene/index/BaseTermVectorsFormatTestCase.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/test-framework/src/java/org/apache/lucene/index/BaseTermVectorsFormatTestCase.java?rev=1687524&r1=1687523&r2=1687524&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/test-framework/src/java/org/apache/lucene/index/BaseTermVectorsFormatTestCase.java (original)
+++ lucene/dev/trunk/lucene/test-framework/src/java/org/apache/lucene/index/BaseTermVectorsFormatTestCase.java Thu Jun 25 13:59:19 2015
@@ -450,12 +450,8 @@ public abstract class BaseTermVectorsFor
assertEquals(sortedTerms[i], termsEnum.term());
assertEquals(1, termsEnum.docFreq());
- final FixedBitSet bits = new FixedBitSet(1);
- PostingsEnum postingsEnum = termsEnum.postings(bits, random().nextBoolean() ? null : this.docsEnum.get());
- assertEquals(PostingsEnum.NO_MORE_DOCS, postingsEnum.nextDoc());
- bits.set(0);
-
- postingsEnum = termsEnum.postings(random().nextBoolean() ? bits : null, random().nextBoolean() ? null : postingsEnum);
+ PostingsEnum postingsEnum = termsEnum.postings(null);
+ postingsEnum = termsEnum.postings(random().nextBoolean() ? null : postingsEnum);
assertNotNull(postingsEnum);
assertEquals(0, postingsEnum.nextDoc());
assertEquals(0, postingsEnum.docID());
@@ -463,14 +459,8 @@ public abstract class BaseTermVectorsFor
assertEquals(PostingsEnum.NO_MORE_DOCS, postingsEnum.nextDoc());
this.docsEnum.set(postingsEnum);
- bits.clear(0);
- PostingsEnum docsAndPositionsEnum = termsEnum.postings(bits, random().nextBoolean() ? null : this.docsEnum.get(), PostingsEnum.POSITIONS);
- if (terms.hasPositions()) {
- assertEquals(PostingsEnum.NO_MORE_DOCS, docsAndPositionsEnum.nextDoc());
- }
- bits.set(0);
-
- docsAndPositionsEnum = termsEnum.postings(random().nextBoolean() ? bits : null, random().nextBoolean() ? null : docsAndPositionsEnum, PostingsEnum.POSITIONS);
+ PostingsEnum docsAndPositionsEnum = termsEnum.postings(null);
+ docsAndPositionsEnum = termsEnum.postings(random().nextBoolean() ? null : docsAndPositionsEnum, PostingsEnum.POSITIONS);
if (terms.hasPositions() || terms.hasOffsets()) {
assertEquals(0, docsAndPositionsEnum.nextDoc());
final int freq = docsAndPositionsEnum.freq();
@@ -778,14 +768,14 @@ public abstract class BaseTermVectorsFor
assertEquals(new BytesRef("bar"), termsEnum.next());
// simple use (FREQS)
- PostingsEnum postings = termsEnum.postings(null, null);
+ PostingsEnum postings = termsEnum.postings(null);
assertEquals(-1, postings.docID());
assertEquals(0, postings.nextDoc());
assertEquals(2, postings.freq());
assertEquals(DocIdSetIterator.NO_MORE_DOCS, postings.nextDoc());
// termsenum reuse (FREQS)
- PostingsEnum postings2 = termsEnum.postings(null, postings);
+ PostingsEnum postings2 = termsEnum.postings(postings);
assertNotNull(postings2);
// and it had better work
assertEquals(-1, postings2.docID());
@@ -794,14 +784,14 @@ public abstract class BaseTermVectorsFor
assertEquals(DocIdSetIterator.NO_MORE_DOCS, postings2.nextDoc());
// asking for docs only: ok
- PostingsEnum docsOnly = termsEnum.postings(null, null, PostingsEnum.NONE);
+ PostingsEnum docsOnly = termsEnum.postings(null, PostingsEnum.NONE);
assertEquals(-1, docsOnly.docID());
assertEquals(0, docsOnly.nextDoc());
// we don't define what it is, but if its something else, we should look into it?
assertTrue(docsOnly.freq() == 1 || docsOnly.freq() == 2);
assertEquals(DocIdSetIterator.NO_MORE_DOCS, docsOnly.nextDoc());
// reuse that too
- PostingsEnum docsOnly2 = termsEnum.postings(null, docsOnly, PostingsEnum.NONE);
+ PostingsEnum docsOnly2 = termsEnum.postings(docsOnly, PostingsEnum.NONE);
assertNotNull(docsOnly2);
// and it had better work
assertEquals(-1, docsOnly2.docID());
@@ -812,7 +802,7 @@ public abstract class BaseTermVectorsFor
// asking for any flags: ok
for (int flag : new int[] { NONE, FREQS, POSITIONS, PAYLOADS, OFFSETS, ALL }) {
- postings = termsEnum.postings(null, null, flag);
+ postings = termsEnum.postings(null, flag);
assertEquals(-1, postings.docID());
assertEquals(0, postings.nextDoc());
if (flag != NONE) {
@@ -820,7 +810,7 @@ public abstract class BaseTermVectorsFor
}
assertEquals(DocIdSetIterator.NO_MORE_DOCS, postings.nextDoc());
// reuse that too
- postings2 = termsEnum.postings(null, postings, flag);
+ postings2 = termsEnum.postings(postings, flag);
assertNotNull(postings2);
// and it had better work
assertEquals(-1, postings2.docID());
@@ -859,14 +849,14 @@ public abstract class BaseTermVectorsFor
assertEquals(new BytesRef("bar"), termsEnum.next());
// simple use (FREQS)
- PostingsEnum postings = termsEnum.postings(null, null);
+ PostingsEnum postings = termsEnum.postings(null);
assertEquals(-1, postings.docID());
assertEquals(0, postings.nextDoc());
assertEquals(2, postings.freq());
assertEquals(DocIdSetIterator.NO_MORE_DOCS, postings.nextDoc());
// termsenum reuse (FREQS)
- PostingsEnum postings2 = termsEnum.postings(null, postings);
+ PostingsEnum postings2 = termsEnum.postings(postings);
assertNotNull(postings2);
// and it had better work
assertEquals(-1, postings2.docID());
@@ -875,14 +865,14 @@ public abstract class BaseTermVectorsFor
assertEquals(DocIdSetIterator.NO_MORE_DOCS, postings2.nextDoc());
// asking for docs only: ok
- PostingsEnum docsOnly = termsEnum.postings(null, null, PostingsEnum.NONE);
+ PostingsEnum docsOnly = termsEnum.postings(null, PostingsEnum.NONE);
assertEquals(-1, docsOnly.docID());
assertEquals(0, docsOnly.nextDoc());
// we don't define what it is, but if its something else, we should look into it?
assertTrue(docsOnly.freq() == 1 || docsOnly.freq() == 2);
assertEquals(DocIdSetIterator.NO_MORE_DOCS, docsOnly.nextDoc());
// reuse that too
- PostingsEnum docsOnly2 = termsEnum.postings(null, docsOnly, PostingsEnum.NONE);
+ PostingsEnum docsOnly2 = termsEnum.postings(docsOnly, PostingsEnum.NONE);
assertNotNull(docsOnly2);
// and it had better work
assertEquals(-1, docsOnly2.docID());
@@ -892,7 +882,7 @@ public abstract class BaseTermVectorsFor
assertEquals(DocIdSetIterator.NO_MORE_DOCS, docsOnly2.nextDoc());
// asking for positions, ok
- PostingsEnum docsAndPositionsEnum = termsEnum.postings(null, null, PostingsEnum.POSITIONS);
+ PostingsEnum docsAndPositionsEnum = termsEnum.postings(null, PostingsEnum.POSITIONS);
assertEquals(-1, docsAndPositionsEnum.docID());
assertEquals(0, docsAndPositionsEnum.nextDoc());
assertEquals(2, docsAndPositionsEnum.freq());
@@ -907,7 +897,7 @@ public abstract class BaseTermVectorsFor
assertEquals(DocIdSetIterator.NO_MORE_DOCS, docsAndPositionsEnum.nextDoc());
// now reuse the positions
- PostingsEnum docsAndPositionsEnum2 = termsEnum.postings(null, docsAndPositionsEnum, PostingsEnum.POSITIONS);
+ PostingsEnum docsAndPositionsEnum2 = termsEnum.postings(docsAndPositionsEnum, PostingsEnum.POSITIONS);
assertEquals(-1, docsAndPositionsEnum2.docID());
assertEquals(0, docsAndPositionsEnum2.nextDoc());
assertEquals(2, docsAndPositionsEnum2.freq());
@@ -922,7 +912,7 @@ public abstract class BaseTermVectorsFor
assertEquals(DocIdSetIterator.NO_MORE_DOCS, docsAndPositionsEnum2.nextDoc());
// payloads, offsets, etc don't cause an error if they aren't there
- docsAndPositionsEnum = termsEnum.postings(null, null, PostingsEnum.PAYLOADS);
+ docsAndPositionsEnum = termsEnum.postings(null, PostingsEnum.PAYLOADS);
assertNotNull(docsAndPositionsEnum);
// but make sure they work
assertEquals(-1, docsAndPositionsEnum.docID());
@@ -938,7 +928,7 @@ public abstract class BaseTermVectorsFor
assertNull(docsAndPositionsEnum.getPayload());
assertEquals(DocIdSetIterator.NO_MORE_DOCS, docsAndPositionsEnum.nextDoc());
// reuse
- docsAndPositionsEnum2 = termsEnum.postings(null, docsAndPositionsEnum, PostingsEnum.PAYLOADS);
+ docsAndPositionsEnum2 = termsEnum.postings(docsAndPositionsEnum, PostingsEnum.PAYLOADS);
assertEquals(-1, docsAndPositionsEnum2.docID());
assertEquals(0, docsAndPositionsEnum2.nextDoc());
assertEquals(2, docsAndPositionsEnum2.freq());
@@ -952,7 +942,7 @@ public abstract class BaseTermVectorsFor
assertNull(docsAndPositionsEnum2.getPayload());
assertEquals(DocIdSetIterator.NO_MORE_DOCS, docsAndPositionsEnum2.nextDoc());
- docsAndPositionsEnum = termsEnum.postings(null, null, PostingsEnum.OFFSETS);
+ docsAndPositionsEnum = termsEnum.postings(null, PostingsEnum.OFFSETS);
assertNotNull(docsAndPositionsEnum);
assertEquals(-1, docsAndPositionsEnum.docID());
assertEquals(0, docsAndPositionsEnum.nextDoc());
@@ -967,7 +957,7 @@ public abstract class BaseTermVectorsFor
assertNull(docsAndPositionsEnum.getPayload());
assertEquals(DocIdSetIterator.NO_MORE_DOCS, docsAndPositionsEnum.nextDoc());
// reuse
- docsAndPositionsEnum2 = termsEnum.postings(null, docsAndPositionsEnum, PostingsEnum.OFFSETS);
+ docsAndPositionsEnum2 = termsEnum.postings(docsAndPositionsEnum, PostingsEnum.OFFSETS);
assertEquals(-1, docsAndPositionsEnum2.docID());
assertEquals(0, docsAndPositionsEnum2.nextDoc());
assertEquals(2, docsAndPositionsEnum2.freq());
@@ -981,7 +971,7 @@ public abstract class BaseTermVectorsFor
assertNull(docsAndPositionsEnum2.getPayload());
assertEquals(DocIdSetIterator.NO_MORE_DOCS, docsAndPositionsEnum2.nextDoc());
- docsAndPositionsEnum = termsEnum.postings(null, null, PostingsEnum.ALL);
+ docsAndPositionsEnum = termsEnum.postings(null, PostingsEnum.ALL);
assertNotNull(docsAndPositionsEnum);
assertEquals(-1, docsAndPositionsEnum.docID());
assertEquals(0, docsAndPositionsEnum.nextDoc());
@@ -995,7 +985,7 @@ public abstract class BaseTermVectorsFor
assertEquals(-1, docsAndPositionsEnum.endOffset());
assertNull(docsAndPositionsEnum.getPayload());
assertEquals(DocIdSetIterator.NO_MORE_DOCS, docsAndPositionsEnum.nextDoc());
- docsAndPositionsEnum2 = termsEnum.postings(null, docsAndPositionsEnum, PostingsEnum.ALL);
+ docsAndPositionsEnum2 = termsEnum.postings(docsAndPositionsEnum, PostingsEnum.ALL);
assertEquals(-1, docsAndPositionsEnum2.docID());
assertEquals(0, docsAndPositionsEnum2.nextDoc());
assertEquals(2, docsAndPositionsEnum2.freq());
@@ -1038,14 +1028,14 @@ public abstract class BaseTermVectorsFor
assertEquals(new BytesRef("bar"), termsEnum.next());
// simple usage (FREQS)
- PostingsEnum postings = termsEnum.postings(null, null);
+ PostingsEnum postings = termsEnum.postings(null);
assertEquals(-1, postings.docID());
assertEquals(0, postings.nextDoc());
assertEquals(2, postings.freq());
assertEquals(DocIdSetIterator.NO_MORE_DOCS, postings.nextDoc());
// termsenum reuse (FREQS)
- PostingsEnum postings2 = termsEnum.postings(null, postings);
+ PostingsEnum postings2 = termsEnum.postings(postings);
assertNotNull(postings2);
// and it had better work
assertEquals(-1, postings2.docID());
@@ -1054,14 +1044,14 @@ public abstract class BaseTermVectorsFor
assertEquals(DocIdSetIterator.NO_MORE_DOCS, postings2.nextDoc());
// asking for docs only: ok
- PostingsEnum docsOnly = termsEnum.postings(null, null, PostingsEnum.NONE);
+ PostingsEnum docsOnly = termsEnum.postings(null, PostingsEnum.NONE);
assertEquals(-1, docsOnly.docID());
assertEquals(0, docsOnly.nextDoc());
// we don't define what it is, but if its something else, we should look into it?
assertTrue(docsOnly.freq() == 1 || docsOnly.freq() == 2);
assertEquals(DocIdSetIterator.NO_MORE_DOCS, docsOnly.nextDoc());
// reuse that too
- PostingsEnum docsOnly2 = termsEnum.postings(null, docsOnly, PostingsEnum.NONE);
+ PostingsEnum docsOnly2 = termsEnum.postings(docsOnly, PostingsEnum.NONE);
assertNotNull(docsOnly2);
// and it had better work
assertEquals(-1, docsOnly2.docID());
@@ -1071,7 +1061,7 @@ public abstract class BaseTermVectorsFor
assertEquals(DocIdSetIterator.NO_MORE_DOCS, docsOnly2.nextDoc());
// asking for positions, ok
- PostingsEnum docsAndPositionsEnum = termsEnum.postings(null, null, PostingsEnum.POSITIONS);
+ PostingsEnum docsAndPositionsEnum = termsEnum.postings(null, PostingsEnum.POSITIONS);
assertEquals(-1, docsAndPositionsEnum.docID());
assertEquals(0, docsAndPositionsEnum.nextDoc());
assertEquals(2, docsAndPositionsEnum.freq());
@@ -1088,7 +1078,7 @@ public abstract class BaseTermVectorsFor
assertEquals(DocIdSetIterator.NO_MORE_DOCS, docsAndPositionsEnum.nextDoc());
// now reuse the positions
- PostingsEnum docsAndPositionsEnum2 = termsEnum.postings(null, docsAndPositionsEnum, PostingsEnum.POSITIONS);
+ PostingsEnum docsAndPositionsEnum2 = termsEnum.postings(docsAndPositionsEnum, PostingsEnum.POSITIONS);
assertEquals(-1, docsAndPositionsEnum2.docID());
assertEquals(0, docsAndPositionsEnum2.nextDoc());
assertEquals(2, docsAndPositionsEnum2.freq());
@@ -1105,7 +1095,7 @@ public abstract class BaseTermVectorsFor
assertEquals(DocIdSetIterator.NO_MORE_DOCS, docsAndPositionsEnum2.nextDoc());
// payloads don't cause an error if they aren't there
- docsAndPositionsEnum = termsEnum.postings(null, null, PostingsEnum.PAYLOADS);
+ docsAndPositionsEnum = termsEnum.postings(null, PostingsEnum.PAYLOADS);
assertNotNull(docsAndPositionsEnum);
// but make sure they work
assertEquals(-1, docsAndPositionsEnum.docID());
@@ -1123,7 +1113,7 @@ public abstract class BaseTermVectorsFor
assertNull(docsAndPositionsEnum.getPayload());
assertEquals(DocIdSetIterator.NO_MORE_DOCS, docsAndPositionsEnum.nextDoc());
// reuse
- docsAndPositionsEnum2 = termsEnum.postings(null, docsAndPositionsEnum, PostingsEnum.PAYLOADS);
+ docsAndPositionsEnum2 = termsEnum.postings(docsAndPositionsEnum, PostingsEnum.PAYLOADS);
assertEquals(-1, docsAndPositionsEnum2.docID());
assertEquals(0, docsAndPositionsEnum2.nextDoc());
assertEquals(2, docsAndPositionsEnum2.freq());
@@ -1139,7 +1129,7 @@ public abstract class BaseTermVectorsFor
assertNull(docsAndPositionsEnum2.getPayload());
assertEquals(DocIdSetIterator.NO_MORE_DOCS, docsAndPositionsEnum2.nextDoc());
- docsAndPositionsEnum = termsEnum.postings(null, null, PostingsEnum.OFFSETS);
+ docsAndPositionsEnum = termsEnum.postings(null, PostingsEnum.OFFSETS);
assertNotNull(docsAndPositionsEnum);
assertEquals(-1, docsAndPositionsEnum.docID());
assertEquals(0, docsAndPositionsEnum.nextDoc());
@@ -1154,7 +1144,7 @@ public abstract class BaseTermVectorsFor
assertNull(docsAndPositionsEnum.getPayload());
assertEquals(DocIdSetIterator.NO_MORE_DOCS, docsAndPositionsEnum.nextDoc());
// reuse
- docsAndPositionsEnum2 = termsEnum.postings(null, docsAndPositionsEnum, PostingsEnum.OFFSETS);
+ docsAndPositionsEnum2 = termsEnum.postings(docsAndPositionsEnum, PostingsEnum.OFFSETS);
assertEquals(-1, docsAndPositionsEnum2.docID());
assertEquals(0, docsAndPositionsEnum2.nextDoc());
assertEquals(2, docsAndPositionsEnum2.freq());
@@ -1168,7 +1158,7 @@ public abstract class BaseTermVectorsFor
assertNull(docsAndPositionsEnum2.getPayload());
assertEquals(DocIdSetIterator.NO_MORE_DOCS, docsAndPositionsEnum2.nextDoc());
- docsAndPositionsEnum = termsEnum.postings(null, null, PostingsEnum.ALL);
+ docsAndPositionsEnum = termsEnum.postings(null, PostingsEnum.ALL);
assertNotNull(docsAndPositionsEnum);
assertEquals(-1, docsAndPositionsEnum.docID());
assertEquals(0, docsAndPositionsEnum.nextDoc());
@@ -1182,7 +1172,7 @@ public abstract class BaseTermVectorsFor
assertEquals(7, docsAndPositionsEnum.endOffset());
assertNull(docsAndPositionsEnum.getPayload());
assertEquals(DocIdSetIterator.NO_MORE_DOCS, docsAndPositionsEnum.nextDoc());
- docsAndPositionsEnum2 = termsEnum.postings(null, docsAndPositionsEnum, PostingsEnum.ALL);
+ docsAndPositionsEnum2 = termsEnum.postings(docsAndPositionsEnum, PostingsEnum.ALL);
assertEquals(-1, docsAndPositionsEnum2.docID());
assertEquals(0, docsAndPositionsEnum2.nextDoc());
assertEquals(2, docsAndPositionsEnum2.freq());
@@ -1224,14 +1214,14 @@ public abstract class BaseTermVectorsFor
assertEquals(new BytesRef("bar"), termsEnum.next());
// simple usage (FREQS)
- PostingsEnum postings = termsEnum.postings(null, null);
+ PostingsEnum postings = termsEnum.postings(null);
assertEquals(-1, postings.docID());
assertEquals(0, postings.nextDoc());
assertEquals(2, postings.freq());
assertEquals(DocIdSetIterator.NO_MORE_DOCS, postings.nextDoc());
// termsenum reuse (FREQS)
- PostingsEnum postings2 = termsEnum.postings(null, postings);
+ PostingsEnum postings2 = termsEnum.postings(postings);
assertNotNull(postings2);
// and it had better work
assertEquals(-1, postings2.docID());
@@ -1240,14 +1230,14 @@ public abstract class BaseTermVectorsFor
assertEquals(DocIdSetIterator.NO_MORE_DOCS, postings2.nextDoc());
// asking for docs only: ok
- PostingsEnum docsOnly = termsEnum.postings(null, null, PostingsEnum.NONE);
+ PostingsEnum docsOnly = termsEnum.postings(null, PostingsEnum.NONE);
assertEquals(-1, docsOnly.docID());
assertEquals(0, docsOnly.nextDoc());
// we don't define what it is, but if its something else, we should look into it?
assertTrue(docsOnly.freq() == 1 || docsOnly.freq() == 2);
assertEquals(DocIdSetIterator.NO_MORE_DOCS, docsOnly.nextDoc());
// reuse that too
- PostingsEnum docsOnly2 = termsEnum.postings(null, docsOnly, PostingsEnum.NONE);
+ PostingsEnum docsOnly2 = termsEnum.postings(docsOnly, PostingsEnum.NONE);
assertNotNull(docsOnly2);
// and it had better work
assertEquals(-1, docsOnly2.docID());
@@ -1257,7 +1247,7 @@ public abstract class BaseTermVectorsFor
assertEquals(DocIdSetIterator.NO_MORE_DOCS, docsOnly2.nextDoc());
// asking for positions, ok
- PostingsEnum docsAndPositionsEnum = termsEnum.postings(null, null, PostingsEnum.POSITIONS);
+ PostingsEnum docsAndPositionsEnum = termsEnum.postings(null, PostingsEnum.POSITIONS);
assertEquals(-1, docsAndPositionsEnum.docID());
assertEquals(0, docsAndPositionsEnum.nextDoc());
assertEquals(2, docsAndPositionsEnum.freq());
@@ -1274,7 +1264,7 @@ public abstract class BaseTermVectorsFor
assertEquals(DocIdSetIterator.NO_MORE_DOCS, docsAndPositionsEnum.nextDoc());
// now reuse the positions
- PostingsEnum docsAndPositionsEnum2 = termsEnum.postings(null, docsAndPositionsEnum, PostingsEnum.POSITIONS);
+ PostingsEnum docsAndPositionsEnum2 = termsEnum.postings(docsAndPositionsEnum, PostingsEnum.POSITIONS);
assertEquals(-1, docsAndPositionsEnum2.docID());
assertEquals(0, docsAndPositionsEnum2.nextDoc());
assertEquals(2, docsAndPositionsEnum2.freq());
@@ -1291,7 +1281,7 @@ public abstract class BaseTermVectorsFor
assertEquals(DocIdSetIterator.NO_MORE_DOCS, docsAndPositionsEnum2.nextDoc());
// payloads don't cause an error if they aren't there
- docsAndPositionsEnum = termsEnum.postings(null, null, PostingsEnum.PAYLOADS);
+ docsAndPositionsEnum = termsEnum.postings(null, PostingsEnum.PAYLOADS);
assertNotNull(docsAndPositionsEnum);
// but make sure they work
assertEquals(-1, docsAndPositionsEnum.docID());
@@ -1309,7 +1299,7 @@ public abstract class BaseTermVectorsFor
assertNull(docsAndPositionsEnum.getPayload());
assertEquals(DocIdSetIterator.NO_MORE_DOCS, docsAndPositionsEnum.nextDoc());
// reuse
- docsAndPositionsEnum2 = termsEnum.postings(null, docsAndPositionsEnum, PostingsEnum.PAYLOADS);
+ docsAndPositionsEnum2 = termsEnum.postings(docsAndPositionsEnum, PostingsEnum.PAYLOADS);
assertEquals(-1, docsAndPositionsEnum2.docID());
assertEquals(0, docsAndPositionsEnum2.nextDoc());
assertEquals(2, docsAndPositionsEnum2.freq());
@@ -1325,7 +1315,7 @@ public abstract class BaseTermVectorsFor
assertNull(docsAndPositionsEnum2.getPayload());
assertEquals(DocIdSetIterator.NO_MORE_DOCS, docsAndPositionsEnum2.nextDoc());
- docsAndPositionsEnum = termsEnum.postings(null, null, PostingsEnum.OFFSETS);
+ docsAndPositionsEnum = termsEnum.postings(null, PostingsEnum.OFFSETS);
assertNotNull(docsAndPositionsEnum);
assertEquals(-1, docsAndPositionsEnum.docID());
assertEquals(0, docsAndPositionsEnum.nextDoc());
@@ -1340,7 +1330,7 @@ public abstract class BaseTermVectorsFor
assertNull(docsAndPositionsEnum.getPayload());
assertEquals(DocIdSetIterator.NO_MORE_DOCS, docsAndPositionsEnum.nextDoc());
// reuse
- docsAndPositionsEnum2 = termsEnum.postings(null, docsAndPositionsEnum, PostingsEnum.OFFSETS);
+ docsAndPositionsEnum2 = termsEnum.postings(docsAndPositionsEnum, PostingsEnum.OFFSETS);
assertEquals(-1, docsAndPositionsEnum2.docID());
assertEquals(0, docsAndPositionsEnum2.nextDoc());
assertEquals(2, docsAndPositionsEnum2.freq());
@@ -1354,7 +1344,7 @@ public abstract class BaseTermVectorsFor
assertNull(docsAndPositionsEnum2.getPayload());
assertEquals(DocIdSetIterator.NO_MORE_DOCS, docsAndPositionsEnum2.nextDoc());
- docsAndPositionsEnum = termsEnum.postings(null, null, PostingsEnum.ALL);
+ docsAndPositionsEnum = termsEnum.postings(null, PostingsEnum.ALL);
assertNotNull(docsAndPositionsEnum);
assertEquals(-1, docsAndPositionsEnum.docID());
assertEquals(0, docsAndPositionsEnum.nextDoc());
@@ -1368,7 +1358,7 @@ public abstract class BaseTermVectorsFor
assertEquals(7, docsAndPositionsEnum.endOffset());
assertNull(docsAndPositionsEnum.getPayload());
assertEquals(DocIdSetIterator.NO_MORE_DOCS, docsAndPositionsEnum.nextDoc());
- docsAndPositionsEnum2 = termsEnum.postings(null, docsAndPositionsEnum, PostingsEnum.ALL);
+ docsAndPositionsEnum2 = termsEnum.postings(docsAndPositionsEnum, PostingsEnum.ALL);
assertEquals(-1, docsAndPositionsEnum2.docID());
assertEquals(0, docsAndPositionsEnum2.nextDoc());
assertEquals(2, docsAndPositionsEnum2.freq());
@@ -1410,14 +1400,14 @@ public abstract class BaseTermVectorsFor
assertEquals(new BytesRef("bar"), termsEnum.next());
// sugar method (FREQS)
- PostingsEnum postings = termsEnum.postings(null, null);
+ PostingsEnum postings = termsEnum.postings(null);
assertEquals(-1, postings.docID());
assertEquals(0, postings.nextDoc());
assertEquals(2, postings.freq());
assertEquals(DocIdSetIterator.NO_MORE_DOCS, postings.nextDoc());
// termsenum reuse (FREQS)
- PostingsEnum postings2 = termsEnum.postings(null, postings);
+ PostingsEnum postings2 = termsEnum.postings(postings);
assertNotNull(postings2);
// and it had better work
assertEquals(-1, postings2.docID());
@@ -1426,14 +1416,14 @@ public abstract class BaseTermVectorsFor
assertEquals(DocIdSetIterator.NO_MORE_DOCS, postings2.nextDoc());
// asking for docs only: ok
- PostingsEnum docsOnly = termsEnum.postings(null, null, PostingsEnum.NONE);
+ PostingsEnum docsOnly = termsEnum.postings(null, PostingsEnum.NONE);
assertEquals(-1, docsOnly.docID());
assertEquals(0, docsOnly.nextDoc());
// we don't define what it is, but if its something else, we should look into it?
assertTrue(docsOnly.freq() == 1 || docsOnly.freq() == 2);
assertEquals(DocIdSetIterator.NO_MORE_DOCS, docsOnly.nextDoc());
// reuse that too
- PostingsEnum docsOnly2 = termsEnum.postings(null, docsOnly, PostingsEnum.NONE);
+ PostingsEnum docsOnly2 = termsEnum.postings(docsOnly, PostingsEnum.NONE);
assertNotNull(docsOnly2);
// and it had better work
assertEquals(-1, docsOnly2.docID());
@@ -1443,7 +1433,7 @@ public abstract class BaseTermVectorsFor
assertEquals(DocIdSetIterator.NO_MORE_DOCS, docsOnly2.nextDoc());
// asking for positions, ok
- PostingsEnum docsAndPositionsEnum = termsEnum.postings(null, null, PostingsEnum.POSITIONS);
+ PostingsEnum docsAndPositionsEnum = termsEnum.postings(null, PostingsEnum.POSITIONS);
assertEquals(-1, docsAndPositionsEnum.docID());
assertEquals(0, docsAndPositionsEnum.nextDoc());
assertEquals(2, docsAndPositionsEnum.freq());
@@ -1460,7 +1450,7 @@ public abstract class BaseTermVectorsFor
assertEquals(DocIdSetIterator.NO_MORE_DOCS, docsAndPositionsEnum.nextDoc());
// now reuse the positions
- PostingsEnum docsAndPositionsEnum2 = termsEnum.postings(null, docsAndPositionsEnum, PostingsEnum.POSITIONS);
+ PostingsEnum docsAndPositionsEnum2 = termsEnum.postings(docsAndPositionsEnum, PostingsEnum.POSITIONS);
assertEquals(-1, docsAndPositionsEnum2.docID());
assertEquals(0, docsAndPositionsEnum2.nextDoc());
assertEquals(2, docsAndPositionsEnum2.freq());
@@ -1477,7 +1467,7 @@ public abstract class BaseTermVectorsFor
assertEquals(DocIdSetIterator.NO_MORE_DOCS, docsAndPositionsEnum2.nextDoc());
// payloads
- docsAndPositionsEnum = termsEnum.postings(null, null, PostingsEnum.PAYLOADS);
+ docsAndPositionsEnum = termsEnum.postings(null, PostingsEnum.PAYLOADS);
assertNotNull(docsAndPositionsEnum);
assertEquals(-1, docsAndPositionsEnum.docID());
assertEquals(0, docsAndPositionsEnum.nextDoc());
@@ -1492,7 +1482,7 @@ public abstract class BaseTermVectorsFor
assertEquals(new BytesRef("pay2"), docsAndPositionsEnum.getPayload());
assertEquals(DocIdSetIterator.NO_MORE_DOCS, docsAndPositionsEnum.nextDoc());
// reuse
- docsAndPositionsEnum2 = termsEnum.postings(null, docsAndPositionsEnum, PostingsEnum.PAYLOADS);
+ docsAndPositionsEnum2 = termsEnum.postings(docsAndPositionsEnum, PostingsEnum.PAYLOADS);
assertEquals(-1, docsAndPositionsEnum2.docID());
assertEquals(0, docsAndPositionsEnum2.nextDoc());
assertEquals(2, docsAndPositionsEnum2.freq());
@@ -1506,7 +1496,7 @@ public abstract class BaseTermVectorsFor
assertEquals(new BytesRef("pay2"), docsAndPositionsEnum2.getPayload());
assertEquals(DocIdSetIterator.NO_MORE_DOCS, docsAndPositionsEnum2.nextDoc());
- docsAndPositionsEnum = termsEnum.postings(null, null, PostingsEnum.OFFSETS);
+ docsAndPositionsEnum = termsEnum.postings(null, PostingsEnum.OFFSETS);
assertNotNull(docsAndPositionsEnum);
assertEquals(-1, docsAndPositionsEnum.docID());
assertEquals(0, docsAndPositionsEnum.nextDoc());
@@ -1523,7 +1513,7 @@ public abstract class BaseTermVectorsFor
assertTrue(docsAndPositionsEnum.getPayload() == null || new BytesRef("pay2").equals(docsAndPositionsEnum.getPayload()));
assertEquals(DocIdSetIterator.NO_MORE_DOCS, docsAndPositionsEnum.nextDoc());
// reuse
- docsAndPositionsEnum2 = termsEnum.postings(null, docsAndPositionsEnum, PostingsEnum.OFFSETS);
+ docsAndPositionsEnum2 = termsEnum.postings(docsAndPositionsEnum, PostingsEnum.OFFSETS);
assertEquals(-1, docsAndPositionsEnum2.docID());
assertEquals(0, docsAndPositionsEnum2.nextDoc());
assertEquals(2, docsAndPositionsEnum2.freq());
@@ -1539,7 +1529,7 @@ public abstract class BaseTermVectorsFor
assertTrue(docsAndPositionsEnum2.getPayload() == null || new BytesRef("pay2").equals(docsAndPositionsEnum2.getPayload()));
assertEquals(DocIdSetIterator.NO_MORE_DOCS, docsAndPositionsEnum2.nextDoc());
- docsAndPositionsEnum = termsEnum.postings(null, null, PostingsEnum.ALL);
+ docsAndPositionsEnum = termsEnum.postings(null, PostingsEnum.ALL);
assertNotNull(docsAndPositionsEnum);
assertEquals(-1, docsAndPositionsEnum.docID());
assertEquals(0, docsAndPositionsEnum.nextDoc());
@@ -1553,7 +1543,7 @@ public abstract class BaseTermVectorsFor
assertEquals(-1, docsAndPositionsEnum.endOffset());
assertEquals(new BytesRef("pay2"), docsAndPositionsEnum.getPayload());
assertEquals(DocIdSetIterator.NO_MORE_DOCS, docsAndPositionsEnum.nextDoc());
- docsAndPositionsEnum2 = termsEnum.postings(null, docsAndPositionsEnum, PostingsEnum.ALL);
+ docsAndPositionsEnum2 = termsEnum.postings(docsAndPositionsEnum, PostingsEnum.ALL);
assertEquals(-1, docsAndPositionsEnum2.docID());
assertEquals(0, docsAndPositionsEnum2.nextDoc());
assertEquals(2, docsAndPositionsEnum2.freq());
@@ -1596,14 +1586,14 @@ public abstract class BaseTermVectorsFor
assertEquals(new BytesRef("bar"), termsEnum.next());
// sugar method (FREQS)
- PostingsEnum postings = termsEnum.postings(null, null);
+ PostingsEnum postings = termsEnum.postings(null);
assertEquals(-1, postings.docID());
assertEquals(0, postings.nextDoc());
assertEquals(2, postings.freq());
assertEquals(DocIdSetIterator.NO_MORE_DOCS, postings.nextDoc());
// termsenum reuse (FREQS)
- PostingsEnum postings2 = termsEnum.postings(null, postings);
+ PostingsEnum postings2 = termsEnum.postings(postings);
assertNotNull(postings2);
// and it had better work
assertEquals(-1, postings2.docID());
@@ -1612,14 +1602,14 @@ public abstract class BaseTermVectorsFor
assertEquals(DocIdSetIterator.NO_MORE_DOCS, postings2.nextDoc());
// asking for docs only: ok
- PostingsEnum docsOnly = termsEnum.postings(null, null, PostingsEnum.NONE);
+ PostingsEnum docsOnly = termsEnum.postings(null, PostingsEnum.NONE);
assertEquals(-1, docsOnly.docID());
assertEquals(0, docsOnly.nextDoc());
// we don't define what it is, but if its something else, we should look into it?
assertTrue(docsOnly.freq() == 1 || docsOnly.freq() == 2);
assertEquals(DocIdSetIterator.NO_MORE_DOCS, docsOnly.nextDoc());
// reuse that too
- PostingsEnum docsOnly2 = termsEnum.postings(null, docsOnly, PostingsEnum.NONE);
+ PostingsEnum docsOnly2 = termsEnum.postings(docsOnly, PostingsEnum.NONE);
assertNotNull(docsOnly2);
// and it had better work
assertEquals(-1, docsOnly2.docID());
@@ -1629,7 +1619,7 @@ public abstract class BaseTermVectorsFor
assertEquals(DocIdSetIterator.NO_MORE_DOCS, docsOnly2.nextDoc());
// asking for positions, ok
- PostingsEnum docsAndPositionsEnum = termsEnum.postings(null, null, PostingsEnum.POSITIONS);
+ PostingsEnum docsAndPositionsEnum = termsEnum.postings(null, PostingsEnum.POSITIONS);
assertEquals(-1, docsAndPositionsEnum.docID());
assertEquals(0, docsAndPositionsEnum.nextDoc());
assertEquals(2, docsAndPositionsEnum.freq());
@@ -1648,7 +1638,7 @@ public abstract class BaseTermVectorsFor
assertEquals(DocIdSetIterator.NO_MORE_DOCS, docsAndPositionsEnum.nextDoc());
// now reuse the positions
- PostingsEnum docsAndPositionsEnum2 = termsEnum.postings(null, docsAndPositionsEnum, PostingsEnum.POSITIONS);
+ PostingsEnum docsAndPositionsEnum2 = termsEnum.postings(docsAndPositionsEnum, PostingsEnum.POSITIONS);
assertEquals(-1, docsAndPositionsEnum2.docID());
assertEquals(0, docsAndPositionsEnum2.nextDoc());
assertEquals(2, docsAndPositionsEnum2.freq());
@@ -1667,7 +1657,7 @@ public abstract class BaseTermVectorsFor
assertEquals(DocIdSetIterator.NO_MORE_DOCS, docsAndPositionsEnum2.nextDoc());
// payloads
- docsAndPositionsEnum = termsEnum.postings(null, null, PostingsEnum.PAYLOADS);
+ docsAndPositionsEnum = termsEnum.postings(null, PostingsEnum.PAYLOADS);
assertNotNull(docsAndPositionsEnum);
assertEquals(-1, docsAndPositionsEnum.docID());
assertEquals(0, docsAndPositionsEnum.nextDoc());
@@ -1684,7 +1674,7 @@ public abstract class BaseTermVectorsFor
assertEquals(new BytesRef("pay2"), docsAndPositionsEnum.getPayload());
assertEquals(DocIdSetIterator.NO_MORE_DOCS, docsAndPositionsEnum.nextDoc());
// reuse
- docsAndPositionsEnum2 = termsEnum.postings(null, docsAndPositionsEnum, PostingsEnum.PAYLOADS);
+ docsAndPositionsEnum2 = termsEnum.postings(docsAndPositionsEnum, PostingsEnum.PAYLOADS);
assertEquals(-1, docsAndPositionsEnum2.docID());
assertEquals(0, docsAndPositionsEnum2.nextDoc());
assertEquals(2, docsAndPositionsEnum2.freq());
@@ -1700,7 +1690,7 @@ public abstract class BaseTermVectorsFor
assertEquals(new BytesRef("pay2"), docsAndPositionsEnum2.getPayload());
assertEquals(DocIdSetIterator.NO_MORE_DOCS, docsAndPositionsEnum2.nextDoc());
- docsAndPositionsEnum = termsEnum.postings(null, null, PostingsEnum.OFFSETS);
+ docsAndPositionsEnum = termsEnum.postings(null, PostingsEnum.OFFSETS);
assertNotNull(docsAndPositionsEnum);
assertEquals(-1, docsAndPositionsEnum.docID());
assertEquals(0, docsAndPositionsEnum.nextDoc());
@@ -1717,7 +1707,7 @@ public abstract class BaseTermVectorsFor
assertTrue(docsAndPositionsEnum.getPayload() == null || new BytesRef("pay2").equals(docsAndPositionsEnum.getPayload()));
assertEquals(DocIdSetIterator.NO_MORE_DOCS, docsAndPositionsEnum.nextDoc());
// reuse
- docsAndPositionsEnum2 = termsEnum.postings(null, docsAndPositionsEnum, PostingsEnum.OFFSETS);
+ docsAndPositionsEnum2 = termsEnum.postings(docsAndPositionsEnum, PostingsEnum.OFFSETS);
assertEquals(-1, docsAndPositionsEnum2.docID());
assertEquals(0, docsAndPositionsEnum2.nextDoc());
assertEquals(2, docsAndPositionsEnum2.freq());
@@ -1733,7 +1723,7 @@ public abstract class BaseTermVectorsFor
assertTrue(docsAndPositionsEnum2.getPayload() == null || new BytesRef("pay2").equals(docsAndPositionsEnum2.getPayload()));
assertEquals(DocIdSetIterator.NO_MORE_DOCS, docsAndPositionsEnum2.nextDoc());
- docsAndPositionsEnum = termsEnum.postings(null, null, PostingsEnum.ALL);
+ docsAndPositionsEnum = termsEnum.postings(null, PostingsEnum.ALL);
assertNotNull(docsAndPositionsEnum);
assertEquals(-1, docsAndPositionsEnum.docID());
assertEquals(0, docsAndPositionsEnum.nextDoc());
@@ -1747,7 +1737,7 @@ public abstract class BaseTermVectorsFor
assertEquals(7, docsAndPositionsEnum.endOffset());
assertEquals(new BytesRef("pay2"), docsAndPositionsEnum.getPayload());
assertEquals(DocIdSetIterator.NO_MORE_DOCS, docsAndPositionsEnum.nextDoc());
- docsAndPositionsEnum2 = termsEnum.postings(null, docsAndPositionsEnum, PostingsEnum.ALL);
+ docsAndPositionsEnum2 = termsEnum.postings(docsAndPositionsEnum, PostingsEnum.ALL);
assertEquals(-1, docsAndPositionsEnum2.docID());
assertEquals(0, docsAndPositionsEnum2.nextDoc());
assertEquals(2, docsAndPositionsEnum2.freq());
Modified: lucene/dev/trunk/lucene/test-framework/src/java/org/apache/lucene/index/PerThreadPKLookup.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/test-framework/src/java/org/apache/lucene/index/PerThreadPKLookup.java?rev=1687524&r1=1687523&r2=1687524&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/test-framework/src/java/org/apache/lucene/index/PerThreadPKLookup.java (original)
+++ lucene/dev/trunk/lucene/test-framework/src/java/org/apache/lucene/index/PerThreadPKLookup.java Thu Jun 25 13:59:19 2015
@@ -78,9 +78,10 @@ public class PerThreadPKLookup {
public int lookup(BytesRef id) throws IOException {
for(int seg=0;seg<numSegs;seg++) {
if (termsEnums[seg].seekExact(id)) {
- postingsEnums[seg] = termsEnums[seg].postings(liveDocs[seg], postingsEnums[seg], 0);
+ postingsEnums[seg] = termsEnums[seg].postings(postingsEnums[seg], 0);
int docID = postingsEnums[seg].nextDoc();
- if (docID != PostingsEnum.NO_MORE_DOCS) {
+ if (docID != PostingsEnum.NO_MORE_DOCS
+ && (liveDocs[seg] == null || liveDocs[seg].get(docID))) {
return docBases[seg] + docID;
}
assert hasDeletions;
Modified: lucene/dev/trunk/lucene/test-framework/src/java/org/apache/lucene/index/RandomPostingsTester.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/test-framework/src/java/org/apache/lucene/index/RandomPostingsTester.java?rev=1687524&r1=1687523&r2=1687524&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/test-framework/src/java/org/apache/lucene/index/RandomPostingsTester.java (original)
+++ lucene/dev/trunk/lucene/test-framework/src/java/org/apache/lucene/index/RandomPostingsTester.java Thu Jun 25 13:59:19 2015
@@ -40,9 +40,7 @@ import org.apache.lucene.codecs.FieldsPr
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FlushInfo;
import org.apache.lucene.store.IOContext;
-import org.apache.lucene.util.Bits;
import org.apache.lucene.util.BytesRef;
-import org.apache.lucene.util.FixedBitSet;
import org.apache.lucene.util.IOUtils;
import org.apache.lucene.util.LuceneTestCase;
import org.apache.lucene.util.StringHelper;
@@ -99,8 +97,6 @@ public class RandomPostingsTester {
private FieldInfos fieldInfos;
- private FixedBitSet globalLiveDocs;
-
List<FieldAndTerm> allTerms;
private int maxDoc;
@@ -169,7 +165,7 @@ public class RandomPostingsTester {
// NOTE: sort of silly: we enum all the docs just to
// get the maxDoc
- PostingsEnum postingsEnum = getSeedPostings(term, termSeed, false, globalLiveDocs, IndexOptions.DOCS, true);
+ PostingsEnum postingsEnum = getSeedPostings(term, termSeed, IndexOptions.DOCS, true);
int doc;
int lastDoc = 0;
while((doc = postingsEnum.nextDoc()) != PostingsEnum.NO_MORE_DOCS) {
@@ -190,14 +186,6 @@ public class RandomPostingsTester {
// It's the count, not the last docID:
maxDoc++;
- globalLiveDocs = new FixedBitSet(maxDoc);
- double liveRatio = random.nextDouble();
- for(int i=0;i<maxDoc;i++) {
- if (random.nextDouble() <= liveRatio) {
- globalLiveDocs.set(i);
- }
- }
-
allTerms = new ArrayList<>();
for(Map.Entry<String,SortedMap<BytesRef,SeedAndOrd>> fieldEnt : fields.entrySet()) {
String field = fieldEnt.getKey();
@@ -212,7 +200,7 @@ public class RandomPostingsTester {
}
}
- public static SeedPostings getSeedPostings(String term, long seed, boolean withLiveDocs, Bits globalLiveDocs, IndexOptions options, boolean allowPayloads) {
+ public static SeedPostings getSeedPostings(String term, long seed, IndexOptions options, boolean allowPayloads) {
int minDocFreq, maxDocFreq;
if (term.startsWith("big_")) {
minDocFreq = LuceneTestCase.RANDOM_MULTIPLIER * 50000;
@@ -228,7 +216,7 @@ public class RandomPostingsTester {
maxDocFreq = 3;
}
- return new SeedPostings(seed, minDocFreq, maxDocFreq, withLiveDocs ? globalLiveDocs : null, options, allowPayloads);
+ return new SeedPostings(seed, minDocFreq, maxDocFreq, options, allowPayloads);
}
/** Given the same random seed this always enumerates the
@@ -242,9 +230,7 @@ public class RandomPostingsTester {
private final int maxDocSpacing;
private final int payloadSize;
private final boolean fixedPayloads;
- private final Bits liveDocs;
private final BytesRef payload;
- private final IndexOptions options;
private final boolean doPositions;
private final boolean allowPayloads;
@@ -259,11 +245,10 @@ public class RandomPostingsTester {
private int posSpacing;
private int posUpto;
- public SeedPostings(long seed, int minDocFreq, int maxDocFreq, Bits liveDocs, IndexOptions options, boolean allowPayloads) {
+ public SeedPostings(long seed, int minDocFreq, int maxDocFreq, IndexOptions options, boolean allowPayloads) {
random = new Random(seed);
docRandom = new Random(random.nextLong());
docFreq = TestUtil.nextInt(random, minDocFreq, maxDocFreq);
- this.liveDocs = liveDocs;
this.allowPayloads = allowPayloads;
// TODO: more realistic to inversely tie this to numDocs:
@@ -279,7 +264,6 @@ public class RandomPostingsTester {
fixedPayloads = random.nextBoolean();
byte[] payloadBytes = new byte[payloadSize];
payload = new BytesRef(payloadBytes);
- this.options = options;
doPositions = IndexOptions.DOCS_AND_FREQS_AND_POSITIONS.compareTo(options) <= 0;
}
@@ -287,9 +271,7 @@ public class RandomPostingsTester {
public int nextDoc() {
while(true) {
_nextDoc();
- if (liveDocs == null || docID == NO_MORE_DOCS || liveDocs.get(docID)) {
- return docID;
- }
+ return docID;
}
}
@@ -601,10 +583,7 @@ public class RandomPostingsTester {
}
@Override
- public final PostingsEnum postings(Bits liveDocs, PostingsEnum reuse, int flags) throws IOException {
- if (liveDocs != null) {
- throw new IllegalArgumentException("liveDocs must be null");
- }
+ public final PostingsEnum postings(PostingsEnum reuse, int flags) throws IOException {
if (PostingsEnum.featureRequested(flags, PostingsEnum.POSITIONS)) {
if (maxAllowed.compareTo(IndexOptions.DOCS_AND_FREQS_AND_POSITIONS) < 0) {
return null;
@@ -619,7 +598,7 @@ public class RandomPostingsTester {
if (PostingsEnum.featureRequested(flags, PostingsEnum.FREQS) && maxAllowed.compareTo(IndexOptions.DOCS_AND_FREQS) < 0) {
return null;
}
- return getSeedPostings(current.getKey().utf8ToString(), current.getValue().seed, false, null, maxAllowed, allowPayloads);
+ return getSeedPostings(current.getKey().utf8ToString(), current.getValue().seed, maxAllowed, allowPayloads);
}
}
@@ -723,28 +702,11 @@ public class RandomPostingsTester {
// expected term:
assertEquals(term, termsEnum.term());
- // 50% of the time time pass liveDocs:
- boolean useLiveDocs = options.contains(Option.LIVE_DOCS) && random.nextBoolean();
- Bits liveDocs;
- if (useLiveDocs) {
- liveDocs = globalLiveDocs;
- if (LuceneTestCase.VERBOSE) {
- System.out.println(" use liveDocs: " + globalLiveDocs.length());
- }
- } else {
- liveDocs = null;
- if (LuceneTestCase.VERBOSE) {
- System.out.println(" no liveDocs");
- }
- }
-
FieldInfo fieldInfo = currentFieldInfos.fieldInfo(field);
// NOTE: can be empty list if we are using liveDocs:
SeedPostings expected = getSeedPostings(term.utf8ToString(),
fields.get(field).get(term).seed,
- useLiveDocs,
- globalLiveDocs,
maxIndexOptions,
true);
assertEquals(expected.docFreq, termsEnum.docFreq());
@@ -787,7 +749,7 @@ public class RandomPostingsTester {
System.out.println(" get DocsEnum (but we won't check positions) flags=" + flags);
}
- threadState.reusePostingsEnum = termsEnum.postings(liveDocs, prevPostingsEnum, flags);
+ threadState.reusePostingsEnum = termsEnum.postings(prevPostingsEnum, flags);
postingsEnum = threadState.reusePostingsEnum;
} else {
if (LuceneTestCase.VERBOSE) {
@@ -796,7 +758,7 @@ public class RandomPostingsTester {
if (options.contains(Option.REUSE_ENUMS) && random.nextInt(10) < 9) {
prevPostingsEnum = threadState.reusePostingsEnum;
}
- threadState.reusePostingsEnum = termsEnum.postings(liveDocs, prevPostingsEnum, doCheckFreqs ? PostingsEnum.FREQS : PostingsEnum.NONE);
+ threadState.reusePostingsEnum = termsEnum.postings(prevPostingsEnum, doCheckFreqs ? PostingsEnum.FREQS : PostingsEnum.NONE);
postingsEnum = threadState.reusePostingsEnum;
}
} else {
@@ -816,7 +778,7 @@ public class RandomPostingsTester {
System.out.println(" get DocsEnum flags=" + flags);
}
- threadState.reusePostingsEnum = termsEnum.postings(liveDocs, prevPostingsEnum, flags);
+ threadState.reusePostingsEnum = termsEnum.postings(prevPostingsEnum, flags);
postingsEnum = threadState.reusePostingsEnum;
}