Index: src/test/org/apache/lucene/search/CheckHits.java
===================================================================
--- src/test/org/apache/lucene/search/CheckHits.java	(revision 803704)
+++ src/test/org/apache/lucene/search/CheckHits.java	(working copy)
@@ -89,24 +89,45 @@
     }
     
     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);
+    searcher.search(query, c);
+    Assert.assertEquals("Simple: " + query.toString(defaultFieldName), 
+                        correct, actual);
+
+    actual.clear();
+
+    if (searcher instanceof IndexSearcher)
+    QueryUtils.wrapUnderlyingReader((IndexSearcher)searcher).search(query, c);
+    Assert.assertEquals("Wrapped Reader: " + query.toString(defaultFieldName),
+                        correct, actual);
 
+    actual.clear();
+
+    QueryUtils.wrapSearcher(searcher).search(query, c);
+    Assert.assertEquals("Wrapped Searcher: "+query.toString(defaultFieldName),
+                        correct, actual);
+      
     QueryUtils.check(query,searcher);
   }
   
+  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/QueryUtils.java
===================================================================
--- src/test/org/apache/lucene/search/QueryUtils.java	(revision 803704)
+++ src/test/org/apache/lucene/search/QueryUtils.java	(working copy)
@@ -5,10 +5,18 @@
 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.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 +83,20 @@
   }
   
   /** 
-   * various query sanity checks on a searcher, including explanation checks.
-   * @see #checkExplanations
-   * @see #checkSkipTo
+   * 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 #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,6 +104,14 @@
           IndexSearcher is = (IndexSearcher)s;
           checkFirstSkipTo(q1,is);
           checkSkipTo(q1,is);
+          if (wrap) {
+            IndexSearcher wrappedR = wrapUnderlyingReader(is);
+            check(q1, wrappedR, false);
+          }
+        }
+        if (wrap) {
+          MultiSearcher wrappedS = wrapSearcher(s);
+          check(q1, wrappedS, false);
         }
         checkExplanations(q1,s);
         checkSerialization(q1,s);
@@ -101,6 +125,48 @@
     }
   }
 
+  /**
+   * 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.  This new IndexSearcher should 
+   * behave exactly the same as the original IndexSearcher.
+   */
+  public static IndexSearcher wrapUnderlyingReader(IndexSearcher s) 
+    throws IOException {
+    
+    IndexReader[] readers = new IndexReader[7];
+    for (int i = 0; i < readers.length; i++) {
+      readers[i] = IndexReader.open(makeEmptyIndex());
+    }
+    readers[3] = s.getIndexReader();
+    return new IndexSearcher(new MultiReader(readers));
+  }
+  /**
+   * Given a Searcher, returns a new MultiSearcher wrapping the  
+   * the original Searcher, 
+   * as well as several "empty" IndexSearchers.  This new MultiSearcher 
+   * should behave exactly the same as the original Searcher.
+   */
+  public static MultiSearcher wrapSearcher(Searcher s) 
+    throws IOException {
+
+    Searcher[] searchers = new Searcher[7];
+    for (int i = 0; i < searchers.length; i++) {
+      searchers[i] = new IndexSearcher(makeEmptyIndex());
+    }
+    searchers[3] = s;
+    return new MultiSearcher(searchers);
+  }
+
+  private static RAMDirectory makeEmptyIndex() throws IOException {
+      RAMDirectory d = new RAMDirectory();
+      IndexWriter w = new IndexWriter(d, new WhitespaceAnalyzer(), true,
+                                      MaxFieldLength.LIMITED);
+      w.close();
+      return d;
+  }
+  
+
   /** check that the query weight is serializable. 
    * @throws IOException if serialization check fail. 
    */
@@ -146,7 +212,9 @@
         {skip_op, skip_op, skip_op, next_op, next_op},
     };
     for (int k = 0; k < orders.length; k++) {
-      IndexReader[] readers = s.getIndexReader().getSequentialSubReaders();
+      List readerList = new ArrayList();
+      ReaderUtil.gatherSubReaders(readerList, s.getIndexReader());
+      IndexReader[] readers = (IndexReader[]) readerList.toArray(new IndexReader[0]);
 
       for (int x = 0; x < readers.length; x++) {
         IndexReader reader = readers[x];
@@ -271,7 +339,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);