Index: src/test/org/apache/lucene/search/CheckHits.java =================================================================== --- src/test/org/apache/lucene/search/CheckHits.java (revision 804438) +++ src/test/org/apache/lucene/search/CheckHits.java (working copy) @@ -82,31 +82,58 @@ public static void checkHitCollector(Query query, String defaultFieldName, Searcher searcher, int[] results) throws IOException { + + QueryUtils.check(query,searcher); Set correct = new TreeSet(); for (int i = 0; i < results.length; i++) { correct.add(new Integer(results[i])); } - final Set actual = new TreeSet(); - searcher.search(query, new Collector() { - private int base = 0; - public void setScorer(Scorer scorer) throws IOException {} - public void collect(int doc) { - actual.add(new Integer(doc + base)); - } - public void setNextReader(IndexReader reader, int docBase) { - base = docBase; - } - public boolean acceptsDocsOutOfOrder() { - return true; - } - }); - Assert.assertEquals(query.toString(defaultFieldName), correct, actual); + final Collector c = new SetCollector(actual); - QueryUtils.check(query,searcher); + searcher.search(query, c); + Assert.assertEquals("Simple: " + query.toString(defaultFieldName), + correct, actual); + + for (int i = -1; i < 2; i++) { + actual.clear(); + QueryUtils.wrapSearcher(searcher, i).search(query, c); + Assert.assertEquals("Wrap Searcher " + i + ": " + + query.toString(defaultFieldName), + correct, actual); + } + + if ( ! ( searcher instanceof IndexSearcher ) ) return; + + for (int i = -1; i < 2; i++) { + actual.clear(); + QueryUtils.wrapUnderlyingReader + ((IndexSearcher)searcher, i).search(query, c); + Assert.assertEquals("Wrap Reader " + i + ": " + + query.toString(defaultFieldName), + correct, actual); + } } - + + public static class SetCollector extends Collector { + final Set bag; + public SetCollector(Set bag) { + this.bag = bag; + } + private int base = 0; + public void setScorer(Scorer scorer) throws IOException {} + public void collect(int doc) { + bag.add(new Integer(doc + base)); + } + public void setNextReader(IndexReader reader, int docBase) { + base = docBase; + } + public boolean acceptsDocsOutOfOrder() { + return true; + } + } + /** * Tests that a query matches the an expected set of documents using Hits. * Index: src/test/org/apache/lucene/search/TestExplanations.java =================================================================== --- src/test/org/apache/lucene/search/TestExplanations.java (revision 804438) +++ src/test/org/apache/lucene/search/TestExplanations.java (working copy) @@ -17,27 +17,29 @@ * limitations under the License. */ -import org.apache.lucene.search.spans.*; -import org.apache.lucene.store.RAMDirectory; +import java.util.ArrayList; +import java.util.BitSet; +import java.util.List; -import org.apache.lucene.index.IndexWriter; -import org.apache.lucene.index.IndexReader; -import org.apache.lucene.index.Term; - +import org.apache.lucene.queryParser.QueryParser; +import org.apache.lucene.queryParser.ParseException; import org.apache.lucene.analysis.WhitespaceAnalyzer; - import org.apache.lucene.document.Document; import org.apache.lucene.document.Field; - -import org.apache.lucene.queryParser.QueryParser; -import org.apache.lucene.queryParser.ParseException; - +import org.apache.lucene.index.IndexReader; +import org.apache.lucene.index.IndexWriter; +import org.apache.lucene.index.Term; +import org.apache.lucene.search.spans.SpanFirstQuery; +import org.apache.lucene.search.spans.SpanNearQuery; +import org.apache.lucene.search.spans.SpanNotQuery; +import org.apache.lucene.search.spans.SpanOrQuery; +import org.apache.lucene.search.spans.SpanQuery; +import org.apache.lucene.search.spans.SpanTermQuery; +import org.apache.lucene.store.RAMDirectory; +import org.apache.lucene.util.DocIdBitSet; import org.apache.lucene.util.LuceneTestCase; -import org.apache.lucene.util.DocIdBitSet; +import org.apache.lucene.util.ReaderUtil; -import java.util.Random; -import java.util.BitSet; - /** * Tests primative queries (ie: that rewrite to themselves) to * insure they match the expected set of docs, and that the score of each @@ -53,6 +55,7 @@ public class TestExplanations extends LuceneTestCase { protected IndexSearcher searcher; + public static final String KEY = "KEY"; public static final String FIELD = "field"; public static final QueryParser qp = new QueryParser(FIELD, new WhitespaceAnalyzer()); @@ -69,6 +72,7 @@ IndexWriter.MaxFieldLength.LIMITED); for (int i = 0; i < docFields.length; i++) { Document doc = new Document(); + doc.add(new Field(KEY, ""+i, Field.Store.NO, Field.Index.NOT_ANALYZED)); doc.add(new Field(FIELD, docFields[i], Field.Store.NO, Field.Index.ANALYZED)); writer.addDocument(doc); } @@ -117,19 +121,23 @@ bqtest(makeQuery(queryText), expDocNrs); } - /** A filter that only lets the specified document numbers pass */ - public static class ItemizedFilter extends Filter { - int[] docs; - public ItemizedFilter(int[] docs) { - this.docs = docs; - } - public DocIdSet getDocIdSet(IndexReader r) { - BitSet b = new BitSet(r.maxDoc()); - for (int i = 0; i < docs.length; i++) { - b.set(docs[i]); + /** + * Convincience subclass of FieldCacheTermsFilter + */ + public static class ItemizedFilter extends FieldCacheTermsFilter { + private static String[] int2str(int [] terms) { + String [] out = new String[terms.length]; + for (int i = 0; i < terms.length; i++) { + out[i] = ""+terms[i]; } - return new DocIdBitSet(b); + return out; } + public ItemizedFilter(String keyField, int [] keys) { + super(keyField, int2str(keys)); + } + public ItemizedFilter(int [] keys) { + super(KEY, int2str(keys)); + } } /** helper for generating MultiPhraseQueries */ Index: src/test/org/apache/lucene/search/QueryUtils.java =================================================================== --- src/test/org/apache/lucene/search/QueryUtils.java (revision 804438) +++ src/test/org/apache/lucene/search/QueryUtils.java (working copy) @@ -5,10 +5,19 @@ import java.io.IOException; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; +import java.util.ArrayList; +import java.util.List; import junit.framework.Assert; +import org.apache.lucene.analysis.WhitespaceAnalyzer; +import org.apache.lucene.document.Document; import org.apache.lucene.index.IndexReader; +import org.apache.lucene.index.IndexWriter; +import org.apache.lucene.index.MultiReader; +import org.apache.lucene.index.IndexWriter.MaxFieldLength; +import org.apache.lucene.store.RAMDirectory; +import org.apache.lucene.util.ReaderUtil; /** * Copyright 2005 Apache Software Foundation @@ -75,12 +84,20 @@ } /** - * various query sanity checks on a searcher, including explanation checks. + * Various query sanity checks on a searcher, some checks are only done for + * instanceof IndexSearcher. + * + * @see #check(Query) + * @see #checkFirstSkipTo + * @see #checkSkipTo * @see #checkExplanations - * @see #checkSkipTo - * @see #check(Query) + * @see #checkSerialization + * @see #checkEqual */ public static void check(Query q1, Searcher s) { + check(q1, s, true); + } + private static void check(Query q1, Searcher s, boolean wrap) { try { check(q1); if (s!=null) { @@ -88,7 +105,17 @@ IndexSearcher is = (IndexSearcher)s; checkFirstSkipTo(q1,is); checkSkipTo(q1,is); + if (wrap) { + check(q1, wrapUnderlyingReader(is, -1), false); + check(q1, wrapUnderlyingReader(is, 0), false); + check(q1, wrapUnderlyingReader(is, +1), false); + } } + if (wrap) { + check(q1, wrapSearcher(s, -1), false); + check(q1, wrapSearcher(s, 0), false); + check(q1, wrapSearcher(s, +1), false); + } checkExplanations(q1,s); checkSerialization(q1,s); @@ -101,6 +128,104 @@ } } + /** + * Given an IndexSearcher, returns a new IndexSearcher whose IndexReader + * is a MultiReader containing the Reader of the original IndexSearcher, + * as well as several "empty" IndexReaders -- some of which will have + * deleted documents in them. This new IndexSearcher should + * behave exactly the same as the original IndexSearcher. + * @param s the seracher to wrap + * @param edge if negative, s will be the first sub; if 0, s will be in hte middle, if positive s will be the last sub + */ + public static IndexSearcher wrapUnderlyingReader(final IndexSearcher s, final int edge) + throws IOException { + + IndexReader r = s.getIndexReader(); + + // we can't put deleted docs before the nested reader, because + // it will through off the docIds + IndexReader[] readers = new IndexReader[] { + edge < 0 ? r : IndexReader.open(makeEmptyIndex(0)), + IndexReader.open(makeEmptyIndex(0)), + new MultiReader(new IndexReader[] { + IndexReader.open(makeEmptyIndex(edge < 0 ? 4 : 0)), + IndexReader.open(makeEmptyIndex(0)), + 0 == edge ? r : IndexReader.open(makeEmptyIndex(0)) + }), + IndexReader.open(makeEmptyIndex(0 < edge ? 0 : 7)), + IndexReader.open(makeEmptyIndex(0)), + new MultiReader(new IndexReader[] { + IndexReader.open(makeEmptyIndex(0 < edge ? 0 : 5)), + IndexReader.open(makeEmptyIndex(0)), + 0 < edge ? r : IndexReader.open(makeEmptyIndex(0)) + }) + }; + IndexSearcher out = new IndexSearcher(new MultiReader(readers)); + out.setSimilarity(s.getSimilarity()); + return out; + } + /** + * Given a Searcher, returns a new MultiSearcher wrapping the + * the original Searcher, + * as well as several "empty" IndexSearchers -- some of which will have + * deleted documents in them. This new MultiSearcher + * should behave exactly the same as the original Searcher. + * @param s the seracher to wrap + * @param edge if negative, s will be the first sub; if 0, s will be in hte middle, if positive s will be the last sub + */ + public static MultiSearcher wrapSearcher(final Searcher s, final int edge) + throws IOException { + + // we can't put deleted docs before the nested reader, because + // it will through off the docIds + Searcher[] searchers = new Searcher[] { + edge < 0 ? s : new IndexSearcher(makeEmptyIndex(0)), + new MultiSearcher(new Searcher[] { + new IndexSearcher(makeEmptyIndex(edge < 0 ? 65 : 0)), + new IndexSearcher(makeEmptyIndex(0)), + 0 == edge ? s : new IndexSearcher(makeEmptyIndex(0)) + }), + new IndexSearcher(makeEmptyIndex(0 < edge ? 0 : 3)), + new IndexSearcher(makeEmptyIndex(0)), + new MultiSearcher(new Searcher[] { + new IndexSearcher(makeEmptyIndex(0 < edge ? 0 : 5)), + new IndexSearcher(makeEmptyIndex(0)), + 0 < edge ? s : new IndexSearcher(makeEmptyIndex(0)) + }) + }; + MultiSearcher out = new MultiSearcher(searchers); + out.setSimilarity(s.getSimilarity()); + return out; + } + + private static RAMDirectory makeEmptyIndex(final int numDeletedDocs) + throws IOException { + RAMDirectory d = new RAMDirectory(); + IndexWriter w = new IndexWriter(d, new WhitespaceAnalyzer(), true, + MaxFieldLength.LIMITED); + for (int i = 0; i < numDeletedDocs; i++) { + w.addDocument(new Document()); + } + w.commit(); + w.deleteDocuments( new MatchAllDocsQuery() ); + w.commit(); + + if (0 < numDeletedDocs) + Assert.assertTrue("writer has no deletions", w.hasDeletions()); + + Assert.assertEquals("writer is missing some deleted docs", + numDeletedDocs, w.maxDoc()); + Assert.assertEquals("writer has non-deleted docs", + 0, w.numDocs()); + w.close(); + IndexReader r = IndexReader.open(d); + Assert.assertEquals("reader has wrong number of deleted docs", + numDeletedDocs, r.numDeletedDocs()); + r.close(); + return d; + } + + /** check that the query weight is serializable. * @throws IOException if serialization check fail. */ @@ -146,11 +271,7 @@ {skip_op, skip_op, skip_op, next_op, next_op}, }; for (int k = 0; k < orders.length; k++) { - IndexReader[] readers = s.getIndexReader().getSequentialSubReaders(); - for (int x = 0; x < readers.length; x++) { - IndexReader reader = readers[x]; - final int order[] = orders[k]; // System.out.print("Order:");for (int i = 0; i < order.length; i++) // System.out.print(order[i]==skip_op ? " skip()":" next()"); @@ -158,7 +279,7 @@ final int opidx[] = { 0 }; final Weight w = q.weight(s); - final Scorer scorer = w.scorer(reader, true, false); + final Scorer scorer = w.scorer(s.getIndexReader(), true, false); if (scorer == null) { continue; } @@ -229,7 +350,6 @@ .nextDoc()) != DocIdSetIterator.NO_MORE_DOCS; Assert.assertFalse(more); } - } } // check that first skip on just created scorers always goes to the right doc @@ -271,7 +391,9 @@ } }); - IndexReader[] readers = s.getIndexReader().getSequentialSubReaders(); + List readerList = new ArrayList(); + ReaderUtil.gatherSubReaders(readerList, s.getIndexReader()); + IndexReader[] readers = (IndexReader[]) readerList.toArray(new IndexReader[0]); for(int i = 0; i < readers.length; i++) { IndexReader reader = readers[i]; Weight w = q.weight(s);