Index: lucene/test-framework/src/java/org/apache/lucene/util/LuceneTestCase.java
===================================================================
--- lucene/test-framework/src/java/org/apache/lucene/util/LuceneTestCase.java	(révision 1466277)
+++ lucene/test-framework/src/java/org/apache/lucene/util/LuceneTestCase.java	(copie de travail)
@@ -1237,7 +1237,7 @@
    * Create a new searcher over the reader. This searcher might randomly use
    * threads.
    */
-  public static IndexSearcher newSearcher(IndexReader r) throws IOException {
+  public static IndexSearcher newSearcher(IndexReader r) {
     return newSearcher(r, true);
   }
   
@@ -1246,18 +1246,26 @@
    * threads. if <code>maybeWrap</code> is true, this searcher might wrap the
    * reader with one that returns null for getSequentialSubReaders.
    */
-  public static IndexSearcher newSearcher(IndexReader r, boolean maybeWrap) throws IOException {
+  public static IndexSearcher newSearcher(IndexReader r, boolean maybeWrap) {
     Random random = random();
     if (usually()) {
       if (maybeWrap) {
-        r = maybeWrapReader(r);
+        try {
+          r = maybeWrapReader(r);
+        } catch (IOException e) {
+          throw new AssertionError(e);
+        }
       }
       // TODO: this whole check is a coverage hack, we should move it to tests for various filterreaders.
       // ultimately whatever you do will be checkIndex'd at the end anyway. 
       if (random.nextInt(500) == 0 && r instanceof AtomicReader) {
         // TODO: not useful to check DirectoryReader (redundant with checkindex)
         // but maybe sometimes run this on the other crazy readers maybeWrapReader creates?
-        _TestUtil.checkReader(r);
+        try {
+          _TestUtil.checkReader(r);
+        } catch (IOException e) {
+          throw new AssertionError(e);
+        }
       }
       IndexSearcher ret = random.nextBoolean() ? new AssertingIndexSearcher(random, r) : new AssertingIndexSearcher(random, r.getContext());
       ret.setSimilarity(classEnvRule.similarity);
Index: lucene/test-framework/src/java/org/apache/lucene/search/AssertingIndexSearcher.java
===================================================================
--- lucene/test-framework/src/java/org/apache/lucene/search/AssertingIndexSearcher.java	(révision 1466277)
+++ lucene/test-framework/src/java/org/apache/lucene/search/AssertingIndexSearcher.java	(copie de travail)
@@ -17,20 +17,28 @@
  * limitations under the License.
  */
 
+import java.io.IOException;
+import java.lang.ref.WeakReference;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
 import java.util.Random;
+import java.util.WeakHashMap;
 import java.util.concurrent.ExecutorService;
-import java.io.IOException;
 
+import org.apache.lucene.index.AssertingAtomicReader;
 import org.apache.lucene.index.AtomicReaderContext;
+import org.apache.lucene.index.DocsEnum;
 import org.apache.lucene.index.IndexReader;
 import org.apache.lucene.index.IndexReaderContext;
 import org.apache.lucene.util.Bits;
+import org.apache.lucene.util.VirtualMethod;
 import org.apache.lucene.util._TestUtil;
 
-/** 
+/**
  * Helper class that adds some extra checks to ensure correct
  * usage of {@code IndexSearcher} and {@code Weight}.
- * TODO: Extend this by more checks, that's just a start.
  */
 public class AssertingIndexSearcher extends IndexSearcher {
   final Random random;
@@ -58,58 +66,280 @@
   @Override
   public Weight createNormalizedWeight(Query query) throws IOException {
     final Weight w = super.createNormalizedWeight(query);
-    return new Weight() {
-      @Override
-      public Explanation explain(AtomicReaderContext context, int doc) throws IOException {
-        return w.explain(context, doc);
-      }
+    return new AssertingWeight(random, w) {
 
       @Override
-      public Query getQuery() {
-        return w.getQuery();
-      }
-
-      @Override
       public void normalize(float norm, float topLevelBoost) {
         throw new IllegalStateException("Weight already normalized.");
       }
 
       @Override
-      public Scorer scorer(AtomicReaderContext context, boolean scoreDocsInOrder,
-          boolean topScorer, Bits acceptDocs) throws IOException {
-        Scorer scorer = w.scorer(context, scoreDocsInOrder, topScorer, acceptDocs);
-        if (scorer != null) {
-          // check that scorer obeys disi contract for docID() before next()/advance
-          try {
-            int docid = scorer.docID();
-            assert docid == -1 || docid == DocIdSetIterator.NO_MORE_DOCS;
-          } catch (UnsupportedOperationException ignored) {
-            // from a top-level BS1
-            assert topScorer;
-          }
-        }
-        return scorer;
-      }
-
-      @Override
       public float getValueForNormalization() {
         throw new IllegalStateException("Weight already normalized.");
       }
 
-      @Override
-      public boolean scoresDocsOutOfOrder() {
-        // TODO: if this returns false, we should wrap
-        // Scorer with AssertingScorer that confirms docIDs
-        // are in order?
-        return w.scoresDocsOutOfOrder();
-      }
     };
   }
-  
+
   @Override
   protected Query wrapFilter(Query query, Filter filter) {
     if (random.nextBoolean())
       return super.wrapFilter(query, filter);
     return (filter == null) ? query : new FilteredQuery(query, filter, _TestUtil.randomFilterStrategy(random));
   }
+
+  @Override
+  protected void search(List<AtomicReaderContext> leaves, Weight weight, Collector collector) throws IOException {
+    super.search(leaves, AssertingWeight.wrap(random, weight), collector);
+  }
+
+  static class AssertingWeight extends Weight {
+
+    static Weight wrap(Random random, Weight other) {
+      return other instanceof AssertingWeight ? other : new AssertingWeight(random, other);
+    }
+
+    final Random random;
+    final Weight in;
+
+    AssertingWeight(Random random, Weight in) {
+      this.random = random;
+      this.in = in;
+    }
+
+    @Override
+    public Explanation explain(AtomicReaderContext context, int doc) throws IOException {
+      return in.explain(context, doc);
+    }
+
+    @Override
+    public Query getQuery() {
+      return in.getQuery();
+    }
+
+    @Override
+    public float getValueForNormalization() throws IOException {
+      return in.getValueForNormalization();
+    }
+
+    @Override
+    public void normalize(float norm, float topLevelBoost) {
+      in.normalize(norm, topLevelBoost);
+    }
+
+    @Override
+    public Scorer scorer(AtomicReaderContext context, boolean scoreDocsInOrder,
+        boolean topScorer, Bits acceptDocs) throws IOException {
+      // if the caller asks for in-order scoring or if the weight does not support
+      // out-of order scoring then collection will have to happen in-order.
+      final boolean inOrder = scoreDocsInOrder || !scoresDocsOutOfOrder();
+      final Scorer inScorer = in.scorer(context, scoreDocsInOrder, topScorer, acceptDocs);
+      return AssertingScorer.wrap(random, inScorer, topScorer, inOrder);
+    }
+
+    @Override
+    public boolean scoresDocsOutOfOrder() {
+      return in.scoresDocsOutOfOrder();
+    }
+
+  }
+
+  enum TopScorer {
+    YES, NO, UNKNOWN;
+  }
+
+  public static class AssertingScorer extends Scorer {
+
+    private static final VirtualMethod<Scorer> SCORE_COLLECTOR = new VirtualMethod<Scorer>(Scorer.class, "score", Collector.class);
+    private static final VirtualMethod<Scorer> SCORE_COLLECTOR_RANGE = new VirtualMethod<Scorer>(Scorer.class, "score", Collector.class, int.class, int.class);
+
+    // we need to track scorers using a weak hash map because otherwise we
+    // could loose references because of eg.
+    // AssertingScorer.score(Collector) which needs to delegate to work correctly
+    private static Map<Scorer, WeakReference<AssertingScorer>> ASSERTING_INSTANCES = Collections.synchronizedMap(new WeakHashMap<Scorer, WeakReference<AssertingScorer>>());
+
+    private static Scorer wrap(Random random, Scorer other, TopScorer topScorer, boolean inOrder) {
+      if (other == null || other instanceof AssertingScorer) {
+        return other;
+      }
+      final AssertingScorer assertScorer = new AssertingScorer(random, other, topScorer, inOrder);
+      ASSERTING_INSTANCES.put(other, new WeakReference<AssertingScorer>(assertScorer));
+      return assertScorer;
+    }
+
+    static Scorer wrap(Random random, Scorer other, boolean topScorer, boolean inOrder) {
+      return wrap(random, other, topScorer ? TopScorer.YES : TopScorer.NO, inOrder);
+    }
+
+    static Scorer getAssertingScorer(Random random, Scorer other) {
+      if (other == null || other instanceof AssertingScorer) {
+        return other;
+      }
+      final WeakReference<AssertingScorer> assertingScorerRef = ASSERTING_INSTANCES.get(other);
+      final AssertingScorer assertingScorer = assertingScorerRef == null ? null : assertingScorerRef.get();
+      if (assertingScorer == null) {
+        // can happen in case of memory pressure or if
+        // scorer1.score(collector) calls
+        // collector.setScorer(scorer2) with scorer1 != scorer2, such as
+        // BooleanScorer. In that case we can't enable all assertions
+        return new AssertingScorer(random, other, TopScorer.UNKNOWN, false);
+      } else {
+        return assertingScorer;
+      }
+    }
+
+    final Random random;
+    final Scorer in;
+    final AssertingAtomicReader.AssertingDocsEnum docsEnumIn;
+    final TopScorer topScorer;
+    final boolean inOrder;
+    final boolean canCallNextDoc;
+
+    private AssertingScorer(Random random, Scorer in, TopScorer topScorer, boolean inOrder) {
+      super(in.weight);
+      this.random = random;
+      this.in = in;
+      this.topScorer = topScorer;
+      this.inOrder = inOrder;
+      this.docsEnumIn = new AssertingAtomicReader.AssertingDocsEnum(in, topScorer == TopScorer.NO);
+      this.canCallNextDoc = topScorer != TopScorer.YES // not a top scorer
+          || !SCORE_COLLECTOR_RANGE.isOverriddenAsOf(in.getClass()) // the default impl relies upon nextDoc()
+          || !SCORE_COLLECTOR.isOverriddenAsOf(in.getClass()); // the default impl relies upon nextDoc()
+    }
+
+    public Scorer getIn() {
+      return in;
+    }
+
+    boolean iterating() {
+      switch (docID()) {
+        case -1:
+        case NO_MORE_DOCS:
+          return false;
+        default:
+          return true;
+      }
+    }
+
+    @Override
+    public float score() throws IOException {
+      assert iterating();
+      final float score = in.score();
+      assert score != Float.NaN;
+      assert score != Float.NEGATIVE_INFINITY;
+      assert score != Float.POSITIVE_INFINITY;
+      return score;
+    }
+
+    @Override
+    public void score(Collector collector) throws IOException {
+      assert topScorer != TopScorer.NO;
+      if (SCORE_COLLECTOR.isOverriddenAsOf(this.in.getClass())) {
+        if (random.nextBoolean()) {
+          try {
+            final boolean remaining = in.score(collector, DocsEnum.NO_MORE_DOCS, in.nextDoc());
+            assert !remaining;
+          } catch (UnsupportedOperationException e) {
+            in.score(collector);
+          }
+        } else {
+          in.score(collector);
+        }
+      } else {
+        // score(Collector) has not been overridden, use the super method in
+        // order to benefit from all assertions
+        super.score(collector);
+      }
+    }
+
+    @Override
+    public boolean score(Collector collector, int max, int firstDocID) throws IOException {
+      assert topScorer != TopScorer.NO;
+      if (SCORE_COLLECTOR_RANGE.isOverriddenAsOf(this.in.getClass())) {
+        return in.score(collector, max, firstDocID);
+      } else {
+        // score(Collector,int,int) has not been overridden, use the super
+        // method in order to benefit from all assertions
+        return super.score(collector, max, firstDocID);
+      }
+    }
+
+    @Override
+    public Collection<ChildScorer> getChildren() {
+      return in.getChildren();
+    }
+
+    @Override
+    public int freq() throws IOException {
+      assert iterating();
+      return in.freq();
+    }
+
+    @Override
+    public int docID() {
+      return in.docID();
+    }
+
+    @Override
+    public int nextDoc() throws IOException {
+      assert canCallNextDoc : "top scorers should not call nextDoc()";
+      return docsEnumIn.nextDoc();
+    }
+
+    @Override
+    public int advance(int target) throws IOException {
+      assert canCallNextDoc : "top scorers should not call advance(target)";
+      return docsEnumIn.advance(target);
+    }
+
+    @Override
+    public long cost() {
+      return in.cost();
+    }
+  }
+
+  static class AssertingCollector extends Collector {
+
+    static Collector wrap(Random random, Collector other, boolean inOrder) {
+      return other instanceof AssertingCollector ? other : new AssertingCollector(random, other, inOrder);
+    }
+
+    final Random random;
+    final Collector in;
+    final boolean inOrder;
+    int lastCollected;
+
+    AssertingCollector(Random random, Collector in, boolean inOrder) {
+      this.random = random;
+      this.in = in;
+      this.inOrder = inOrder;
+      lastCollected = -1;
+    }
+
+    @Override
+    public void setScorer(Scorer scorer) throws IOException {
+      in.setScorer(AssertingScorer.getAssertingScorer(random, scorer));
+    }
+
+    @Override
+    public void collect(int doc) throws IOException {
+      if (inOrder || !acceptsDocsOutOfOrder()) {
+        assert doc > lastCollected : "Out of order : " + lastCollected + " " + doc;
+      }
+      in.collect(doc);
+      lastCollected = doc;
+    }
+
+    @Override
+    public void setNextReader(AtomicReaderContext context) throws IOException {
+      lastCollected = -1;
+    }
+
+    @Override
+    public boolean acceptsDocsOutOfOrder() {
+      return in.acceptsDocsOutOfOrder();
+    }
+
+  }
+
 }
Index: lucene/test-framework/src/java/org/apache/lucene/index/AssertingAtomicReader.java
===================================================================
--- lucene/test-framework/src/java/org/apache/lucene/index/AssertingAtomicReader.java	(révision 1466277)
+++ lucene/test-framework/src/java/org/apache/lucene/index/AssertingAtomicReader.java	(copie de travail)
@@ -223,14 +223,25 @@
   }
   
   static enum DocsEnumState { START, ITERATING, FINISHED };
-  static class AssertingDocsEnum extends FilterDocsEnum {
+
+  public static class AssertingDocsEnum extends FilterDocsEnum {
     private DocsEnumState state = DocsEnumState.START;
     private int doc;
     
     public AssertingDocsEnum(DocsEnum in) {
+      this(in, true);
+    }
+
+    public AssertingDocsEnum(DocsEnum in, boolean failOnUnsupportedDocID) {
       super(in);
-      int docid = in.docID();
-      assert docid == -1 || docid == DocIdSetIterator.NO_MORE_DOCS : "invalid initial doc id: " + docid;
+      try {
+        int docid = in.docID();
+        assert docid == -1 || docid == DocIdSetIterator.NO_MORE_DOCS : in.getClass() + ": invalid initial doc id: " + docid;
+      } catch (UnsupportedOperationException e) {
+        if (failOnUnsupportedDocID) {
+          throw e;
+        }
+      }
       doc = -1;
     }
 
@@ -238,7 +249,7 @@
     public int nextDoc() throws IOException {
       assert state != DocsEnumState.FINISHED : "nextDoc() called after NO_MORE_DOCS";
       int nextDoc = super.nextDoc();
-      assert nextDoc > doc : "backwards nextDoc from " + doc + " to " + nextDoc;
+      assert nextDoc > doc : "backwards nextDoc from " + doc + " to " + nextDoc + " " + in;
       if (nextDoc == DocIdSetIterator.NO_MORE_DOCS) {
         state = DocsEnumState.FINISHED;
       } else {
Index: lucene/core/src/test/org/apache/lucene/index/Test2BTerms.java
===================================================================
--- lucene/core/src/test/org/apache/lucene/index/Test2BTerms.java	(révision 1466277)
+++ lucene/core/src/test/org/apache/lucene/index/Test2BTerms.java	(copie de travail)
@@ -238,7 +238,7 @@
 
   private void testSavedTerms(IndexReader r, List<BytesRef> terms) throws IOException {
     System.out.println("TEST: run " + terms.size() + " terms on reader=" + r);
-    IndexSearcher s = new IndexSearcher(r);
+    IndexSearcher s = newSearcher(r);
     Collections.shuffle(terms);
     TermsEnum termsEnum = MultiFields.getTerms(r, "field").iterator(null);
     boolean failed = false;
Index: lucene/core/src/test/org/apache/lucene/index/TestBackwardsCompatibility.java
===================================================================
--- lucene/core/src/test/org/apache/lucene/index/TestBackwardsCompatibility.java	(révision 1466277)
+++ lucene/core/src/test/org/apache/lucene/index/TestBackwardsCompatibility.java	(copie de travail)
@@ -362,7 +362,7 @@
     //Query query = parser.parse("handle:1");
 
     IndexReader reader = DirectoryReader.open(dir);
-    IndexSearcher searcher = new IndexSearcher(reader);
+    IndexSearcher searcher = newSearcher(reader);
 
     _TestUtil.checkIndex(dir);
     
@@ -522,7 +522,7 @@
 
     // make sure searching sees right # hits
     IndexReader reader = DirectoryReader.open(dir);
-    IndexSearcher searcher = new IndexSearcher(reader);
+    IndexSearcher searcher = newSearcher(reader);
     ScoreDoc[] hits = searcher.search(new TermQuery(new Term("content", "aaa")), null, 1000).scoreDocs;
     StoredDocument d = searcher.getIndexReader().document(hits[0].doc);
     assertEquals("wrong first document", "0", d.get("id"));
@@ -535,7 +535,7 @@
     writer.close();
 
     reader = DirectoryReader.open(dir);
-    searcher = new IndexSearcher(reader);
+    searcher = newSearcher(reader);
     hits = searcher.search(new TermQuery(new Term("content", "aaa")), null, 1000).scoreDocs;
     assertEquals("wrong number of hits", 44, hits.length);
     d = searcher.doc(hits[0].doc);
@@ -547,7 +547,7 @@
   public void changeIndexNoAdds(Random random, Directory dir) throws IOException {
     // make sure searching sees right # hits
     DirectoryReader reader = DirectoryReader.open(dir);
-    IndexSearcher searcher = new IndexSearcher(reader);
+    IndexSearcher searcher = newSearcher(reader);
     ScoreDoc[] hits = searcher.search(new TermQuery(new Term("content", "aaa")), null, 1000).scoreDocs;
     assertEquals("wrong number of hits", 34, hits.length);
     StoredDocument d = searcher.doc(hits[0].doc);
@@ -560,7 +560,7 @@
     writer.close();
 
     reader = DirectoryReader.open(dir);
-    searcher = new IndexSearcher(reader);
+    searcher = newSearcher(reader);
     hits = searcher.search(new TermQuery(new Term("content", "aaa")), null, 1000).scoreDocs;
     assertEquals("wrong number of hits", 34, hits.length);
     doTestHits(hits, 34, searcher.getIndexReader());
@@ -852,7 +852,7 @@
       
       Directory dir = oldIndexDirs.get(name);
       IndexReader reader = DirectoryReader.open(dir);
-      IndexSearcher searcher = new IndexSearcher(reader);
+      IndexSearcher searcher = newSearcher(reader);
       
       for (int id=10; id<15; id++) {
         ScoreDoc[] hits = searcher.search(NumericRangeQuery.newIntRange("trieInt", 4, Integer.valueOf(id), Integer.valueOf(id), true, true), 100).scoreDocs;
Index: lucene/core/src/test/org/apache/lucene/index/TestIndexWriterCommit.java
===================================================================
--- lucene/core/src/test/org/apache/lucene/index/TestIndexWriterCommit.java	(révision 1466277)
+++ lucene/core/src/test/org/apache/lucene/index/TestIndexWriterCommit.java	(copie de travail)
@@ -51,7 +51,7 @@
 
       Term searchTerm = new Term("content", "aaa");
       DirectoryReader reader = DirectoryReader.open(dir);
-      IndexSearcher searcher = new IndexSearcher(reader);
+      IndexSearcher searcher = newSearcher(reader);
       ScoreDoc[] hits = searcher.search(new TermQuery(searchTerm), null, 1000).scoreDocs;
       assertEquals("first number of hits", 14, hits.length);
       reader.close();
@@ -64,7 +64,7 @@
           TestIndexWriter.addDoc(writer);
         }
         IndexReader r = DirectoryReader.open(dir);
-        searcher = new IndexSearcher(r);
+        searcher = newSearcher(r);
         hits = searcher.search(new TermQuery(searchTerm), null, 1000).scoreDocs;
         assertEquals("reader incorrectly sees changes from writer", 14, hits.length);
         r.close();
@@ -76,7 +76,7 @@
       assertFalse("reader should not be current now", reader.isCurrent());
 
       IndexReader r = DirectoryReader.open(dir);
-      searcher = new IndexSearcher(r);
+      searcher = newSearcher(r);
       hits = searcher.search(new TermQuery(searchTerm), null, 1000).scoreDocs;
       assertEquals("reader did not see changes after writer was closed", 47, hits.length);
       r.close();
@@ -102,7 +102,7 @@
 
     Term searchTerm = new Term("content", "aaa");
     IndexReader reader = DirectoryReader.open(dir);
-    IndexSearcher searcher = new IndexSearcher(reader);
+    IndexSearcher searcher = newSearcher(reader);
     ScoreDoc[] hits = searcher.search(new TermQuery(searchTerm), null, 1000).scoreDocs;
     assertEquals("first number of hits", 14, hits.length);
     reader.close();
@@ -116,7 +116,7 @@
     writer.deleteDocuments(searchTerm);
 
     reader = DirectoryReader.open(dir);
-    searcher = new IndexSearcher(reader);
+    searcher = newSearcher(reader);
     hits = searcher.search(new TermQuery(searchTerm), null, 1000).scoreDocs;
     assertEquals("reader incorrectly sees changes from writer", 14, hits.length);
     reader.close();
@@ -127,7 +127,7 @@
     TestIndexWriter.assertNoUnreferencedFiles(dir, "unreferenced files remain after rollback()");
 
     reader = DirectoryReader.open(dir);
-    searcher = new IndexSearcher(reader);
+    searcher = newSearcher(reader);
     hits = searcher.search(new TermQuery(searchTerm), null, 1000).scoreDocs;
     assertEquals("saw changes after writer.abort", 14, hits.length);
     reader.close();
@@ -148,7 +148,7 @@
         TestIndexWriter.addDoc(writer);
       }
       IndexReader r = DirectoryReader.open(dir);
-      searcher = new IndexSearcher(r);
+      searcher = newSearcher(r);
       hits = searcher.search(new TermQuery(searchTerm), null, 1000).scoreDocs;
       assertEquals("reader incorrectly sees changes from writer", 14, hits.length);
       r.close();
@@ -156,7 +156,7 @@
 
     writer.close();
     IndexReader r = DirectoryReader.open(dir);
-    searcher = new IndexSearcher(r);
+    searcher = newSearcher(r);
     hits = searcher.search(new TermQuery(searchTerm), null, 1000).scoreDocs;
     assertEquals("didn't see changes after close", 218, hits.length);
     r.close();
Index: lucene/core/src/test/org/apache/lucene/index/TestIndexWriterExceptions.java
===================================================================
--- lucene/core/src/test/org/apache/lucene/index/TestIndexWriterExceptions.java	(révision 1466277)
+++ lucene/core/src/test/org/apache/lucene/index/TestIndexWriterExceptions.java	(copie de travail)
@@ -1394,7 +1394,7 @@
     final IndexReader r = w.getReader();
     w.close();
 
-    final IndexSearcher s = new IndexSearcher(r);
+    final IndexSearcher s = newSearcher(r);
     PhraseQuery pq = new PhraseQuery();
     pq.add(new Term("content", "silly"));
     pq.add(new Term("content", "content"));
@@ -1474,7 +1474,7 @@
     final IndexReader r = w.getReader();
     w.close();
 
-    final IndexSearcher s = new IndexSearcher(r);
+    final IndexSearcher s = newSearcher(r);
     PhraseQuery pq = new PhraseQuery();
     pq.add(new Term("content", "silly"));
     pq.add(new Term("content", "content"));
Index: lucene/core/src/test/org/apache/lucene/index/TestStressNRT.java
===================================================================
--- lucene/core/src/test/org/apache/lucene/index/TestStressNRT.java	(révision 1466277)
+++ lucene/core/src/test/org/apache/lucene/index/TestStressNRT.java	(copie de travail)
@@ -318,7 +318,7 @@
               }
 
               //  sreq = req("wt","json", "q","id:"+Integer.toString(id), "omitHeader","true");
-              IndexSearcher searcher = new IndexSearcher(r);
+              IndexSearcher searcher = newSearcher(r);
               Query q = new TermQuery(new Term("id",Integer.toString(id)));
               TopDocs results = searcher.search(q, 10);
 
Index: lucene/core/src/test/org/apache/lucene/index/TestStressIndexing.java
===================================================================
--- lucene/core/src/test/org/apache/lucene/index/TestStressIndexing.java	(révision 1466277)
+++ lucene/core/src/test/org/apache/lucene/index/TestStressIndexing.java	(copie de travail)
@@ -104,7 +104,7 @@
     public void doWork() throws Throwable {
       for (int i=0; i<100; i++) {
         IndexReader ir = DirectoryReader.open(directory);
-        IndexSearcher is = new IndexSearcher(ir);
+        IndexSearcher is = newSearcher(ir);
         ir.close();
       }
       count += 100;
Index: lucene/core/src/test/org/apache/lucene/index/TestDeletionPolicy.java
===================================================================
--- lucene/core/src/test/org/apache/lucene/index/TestDeletionPolicy.java	(révision 1466277)
+++ lucene/core/src/test/org/apache/lucene/index/TestDeletionPolicy.java	(copie de travail)
@@ -689,7 +689,7 @@
       assertEquals(3*(N+1)+1, policy.numOnCommit);
 
       IndexReader rwReader = DirectoryReader.open(dir);
-      IndexSearcher searcher = new IndexSearcher(rwReader);
+      IndexSearcher searcher = newSearcher(rwReader);
       ScoreDoc[] hits = searcher.search(query, null, 1000).scoreDocs;
       assertEquals(0, hits.length);
 
Index: lucene/core/src/test/org/apache/lucene/index/TestForTooMuchCloning.java
===================================================================
--- lucene/core/src/test/org/apache/lucene/index/TestForTooMuchCloning.java	(révision 1466277)
+++ lucene/core/src/test/org/apache/lucene/index/TestForTooMuchCloning.java	(copie de travail)
@@ -60,7 +60,7 @@
     //System.out.println("merge clone count=" + cloneCount);
     assertTrue("too many calls to IndexInput.clone during merging: " + dir.getInputCloneCount(), cloneCount < 500);
 
-    final IndexSearcher s = new IndexSearcher(r);
+    final IndexSearcher s = newSearcher(r);
 
     // MTQ that matches all terms so the AUTO_REWRITE should
     // cutover to filter rewrite and reuse a single DocsEnum
Index: lucene/core/src/test/org/apache/lucene/index/TestIndexWriter.java
===================================================================
--- lucene/core/src/test/org/apache/lucene/index/TestIndexWriter.java	(révision 1466277)
+++ lucene/core/src/test/org/apache/lucene/index/TestIndexWriter.java	(copie de travail)
@@ -456,7 +456,7 @@
       writer.close();
 
       IndexReader reader = DirectoryReader.open(dir);
-      IndexSearcher searcher = new IndexSearcher(reader);
+      IndexSearcher searcher = newSearcher(reader);
       int totalHits = searcher.search(new TermQuery(new Term("field", "aaa")), null, 1).totalHits;
       assertEquals(n*100, totalHits);
       reader.close();
@@ -487,7 +487,7 @@
       Term searchTerm = new Term("field", "aaa");
 
       IndexReader reader = DirectoryReader.open(dir);
-      IndexSearcher searcher = new IndexSearcher(reader);
+      IndexSearcher searcher = newSearcher(reader);
       ScoreDoc[] hits = searcher.search(new TermQuery(searchTerm), null, 1000).scoreDocs;
       assertEquals(10, hits.length);
       reader.close();
@@ -509,7 +509,7 @@
       }
       writer.close();
       reader = DirectoryReader.open(dir);
-      searcher = new IndexSearcher(reader);
+      searcher = newSearcher(reader);
       hits = searcher.search(new TermQuery(searchTerm), null, 1000).scoreDocs;
       assertEquals(27, hits.length);
       reader.close();
@@ -587,7 +587,7 @@
       writer.close();
       Term searchTerm = new Term("content", "aaa");
       IndexReader reader = DirectoryReader.open(dir);
-      IndexSearcher searcher = new IndexSearcher(reader);
+      IndexSearcher searcher = newSearcher(reader);
       ScoreDoc[] hits = searcher.search(new TermQuery(searchTerm), null, 1000).scoreDocs;
       assertEquals("did not get right number of hits", 100, hits.length);
       reader.close();
Index: lucene/core/src/test/org/apache/lucene/index/TestOmitTf.java
===================================================================
--- lucene/core/src/test/org/apache/lucene/index/TestOmitTf.java	(révision 1466277)
+++ lucene/core/src/test/org/apache/lucene/index/TestOmitTf.java	(copie de travail)
@@ -18,6 +18,7 @@
  */
 
 import java.io.IOException;
+import java.util.concurrent.ExecutionException;
 
 import org.apache.lucene.util.BytesRef;
 import org.apache.lucene.util.LuceneTestCase;
@@ -281,7 +282,7 @@
      * Verify the index
      */         
     IndexReader reader = DirectoryReader.open(dir);
-    IndexSearcher searcher = new IndexSearcher(reader);
+    IndexSearcher searcher = newSearcher(reader);
     searcher.setSimilarity(new SimpleSimilarity());
         
     Term a = new Term("noTf", term);
@@ -299,8 +300,15 @@
     try {
       searcher.search(pq, 10);
       fail("did not hit expected exception");
-    } catch (IllegalStateException ise) {
-      // expected
+    } catch (Exception e) {
+      Throwable cause = e;
+      // If the searcher uses an executor service, the IAE is wrapped into other exceptions
+      while (cause.getCause() != null) {
+        cause = cause.getCause();
+      }
+      if (!(cause instanceof IllegalStateException)) {
+        throw new AssertionError("Expected an IAE", e);
+      } // else OK because positions are not indexed
     }
         
     searcher.search(q1,
Index: lucene/core/src/test/org/apache/lucene/index/TestIndexWriterDelete.java
===================================================================
--- lucene/core/src/test/org/apache/lucene/index/TestIndexWriterDelete.java	(révision 1466277)
+++ lucene/core/src/test/org/apache/lucene/index/TestIndexWriterDelete.java	(copie de travail)
@@ -407,7 +407,7 @@
 
   private int getHitCount(Directory dir, Term term) throws IOException {
     IndexReader reader = DirectoryReader.open(dir);
-    IndexSearcher searcher = new IndexSearcher(reader);
+    IndexSearcher searcher = newSearcher(reader);
     int hitCount = searcher.search(new TermQuery(term), null, 1000).totalHits;
     reader.close();
     return hitCount;
Index: lucene/core/src/test/org/apache/lucene/index/TestRollingUpdates.java
===================================================================
--- lucene/core/src/test/org/apache/lucene/index/TestRollingUpdates.java	(révision 1466277)
+++ lucene/core/src/test/org/apache/lucene/index/TestRollingUpdates.java	(copie de travail)
@@ -112,7 +112,7 @@
 
         r = w.getReader(applyDeletions);
         if (applyDeletions) {
-          s = new IndexSearcher(r);
+          s = newSearcher(r);
         } else {
           s = null;
         }
Index: lucene/core/src/test/org/apache/lucene/index/TestIndexableField.java
===================================================================
--- lucene/core/src/test/org/apache/lucene/index/TestIndexableField.java	(révision 1466277)
+++ lucene/core/src/test/org/apache/lucene/index/TestIndexableField.java	(copie de travail)
@@ -282,7 +282,7 @@
     final IndexReader r = w.getReader();
     w.close();
 
-    final IndexSearcher s = new IndexSearcher(r);
+    final IndexSearcher s = newSearcher(r);
     int counter = 0;
     for(int id=0;id<NUM_DOCS;id++) {
       if (VERBOSE) {
Index: lucene/core/src/test/org/apache/lucene/TestSearchForDuplicates.java
===================================================================
--- lucene/core/src/test/org/apache/lucene/TestSearchForDuplicates.java	(révision 1466277)
+++ lucene/core/src/test/org/apache/lucene/TestSearchForDuplicates.java	(copie de travail)
@@ -90,7 +90,7 @@
 
       // try a search without OR
       IndexReader reader = DirectoryReader.open(directory);
-      IndexSearcher searcher = new IndexSearcher(reader);
+      IndexSearcher searcher = newSearcher(reader);
 
       Query query = new TermQuery(new Term(PRIORITY_FIELD, HIGH_PRIORITY));
       out.println("Query: " + query.toString(PRIORITY_FIELD));
@@ -106,7 +106,7 @@
       checkHits(hits, MAX_DOCS, searcher);
 
       // try a new search with OR
-      searcher = new IndexSearcher(reader);
+      searcher = newSearcher(reader);
       hits = null;
 
       BooleanQuery booleanQuery = new BooleanQuery();
Index: lucene/core/src/test/org/apache/lucene/util/fst/TestFSTs.java
===================================================================
--- lucene/core/src/test/org/apache/lucene/util/fst/TestFSTs.java	(révision 1466277)
+++ lucene/core/src/test/org/apache/lucene/util/fst/TestFSTs.java	(copie de travail)
@@ -868,7 +868,7 @@
 
       // turn writer into reader:
       final IndexReader r = w.getReader();
-      final IndexSearcher s = new IndexSearcher(r);
+      final IndexSearcher s = newSearcher(r);
       w.close();
 
       final List<String> allIDsList = new ArrayList<String>(allIDs);
@@ -997,7 +997,7 @@
     if (VERBOSE) {
       System.out.println("TEST: got reader=" + r);
     }
-    IndexSearcher s = new IndexSearcher(r);
+    IndexSearcher s = newSearcher(r);
     w.close();
 
     final List<String> allTermsList = new ArrayList<String>(allTerms);
Index: lucene/core/src/test/org/apache/lucene/TestSearch.java
===================================================================
--- lucene/core/src/test/org/apache/lucene/TestSearch.java	(révision 1466277)
+++ lucene/core/src/test/org/apache/lucene/TestSearch.java	(copie de travail)
@@ -55,7 +55,7 @@
       
       IndexReader reader = DirectoryReader.open(directory);
       try {
-        IndexSearcher searcher = new IndexSearcher(reader);
+        IndexSearcher searcher = newSearcher(reader);
         
         ScoreDoc[] hits = searcher.search(q, null, 1000).scoreDocs;
         assertEquals(1, hits.length);
@@ -136,7 +136,7 @@
       writer.close();
 
       IndexReader reader = DirectoryReader.open(directory);
-      IndexSearcher searcher = new IndexSearcher(reader);
+      IndexSearcher searcher = newSearcher(reader);
 
       ScoreDoc[] hits = null;
 
Index: lucene/core/src/test/org/apache/lucene/store/TestLockFactory.java
===================================================================
--- lucene/core/src/test/org/apache/lucene/store/TestLockFactory.java	(révision 1466277)
+++ lucene/core/src/test/org/apache/lucene/store/TestLockFactory.java	(copie de travail)
@@ -349,7 +349,7 @@
             for(int i=0;i<this.numIteration;i++) {
                 try{
                     reader = DirectoryReader.open(dir);
-                    searcher = new IndexSearcher(reader);
+                    searcher = newSearcher(reader);
                 } catch (Exception e) {
                     hitException = true;
                     System.out.println("Stress Test Index Searcher: create hit unexpected exception: " + e.toString());
Index: lucene/core/src/test/org/apache/lucene/store/TestNRTCachingDirectory.java
===================================================================
--- lucene/core/src/test/org/apache/lucene/store/TestNRTCachingDirectory.java	(révision 1466277)
+++ lucene/core/src/test/org/apache/lucene/store/TestNRTCachingDirectory.java	(copie de travail)
@@ -72,7 +72,7 @@
           }
         }
         assertEquals(1+docCount, r.numDocs());
-        final IndexSearcher s = new IndexSearcher(r);
+        final IndexSearcher s = newSearcher(r);
         // Just make sure search can run; we can't assert
         // totHits since it could be 0
         TopDocs hits = s.search(new TermQuery(new Term("body", "the")), 10);
Index: lucene/core/src/test/org/apache/lucene/store/TestWindowsMMap.java
===================================================================
--- lucene/core/src/test/org/apache/lucene/store/TestWindowsMMap.java	(révision 1466277)
+++ lucene/core/src/test/org/apache/lucene/store/TestWindowsMMap.java	(copie de travail)
@@ -78,7 +78,7 @@
         .setOpenMode(OpenMode.CREATE));
     writer.commit();
     IndexReader reader = DirectoryReader.open(dir);
-    IndexSearcher searcher = new IndexSearcher(reader);
+    IndexSearcher searcher = newSearcher(reader);
     
     int num = atLeast(1000);
     for(int dx = 0; dx < num; dx ++) {
Index: lucene/core/src/test/org/apache/lucene/codecs/perfield/TestPerFieldDocValuesFormat.java
===================================================================
--- lucene/core/src/test/org/apache/lucene/codecs/perfield/TestPerFieldDocValuesFormat.java	(révision 1466277)
+++ lucene/core/src/test/org/apache/lucene/codecs/perfield/TestPerFieldDocValuesFormat.java	(copie de travail)
@@ -97,7 +97,7 @@
     
     // Now search the index:
     IndexReader ireader = DirectoryReader.open(directory); // read-only=true
-    IndexSearcher isearcher = new IndexSearcher(ireader);
+    IndexSearcher isearcher = newSearcher(ireader);
 
     assertEquals(1, isearcher.search(new TermQuery(new Term("fieldname", longTerm)), 1).totalHits);
     Query query = new TermQuery(new Term("fieldname", "text"));
Index: lucene/core/src/test/org/apache/lucene/TestDemo.java
===================================================================
--- lucene/core/src/test/org/apache/lucene/TestDemo.java	(révision 1466277)
+++ lucene/core/src/test/org/apache/lucene/TestDemo.java	(copie de travail)
@@ -57,7 +57,7 @@
     
     // Now search the index:
     IndexReader ireader = DirectoryReader.open(directory); // read-only=true
-    IndexSearcher isearcher = new IndexSearcher(ireader);
+    IndexSearcher isearcher = newSearcher(ireader);
 
     assertEquals(1, isearcher.search(new TermQuery(new Term("fieldname", longTerm)), 1).totalHits);
     Query query = new TermQuery(new Term("fieldname", "text"));
Index: lucene/core/src/test/org/apache/lucene/search/TestBooleanQuery.java
===================================================================
--- lucene/core/src/test/org/apache/lucene/search/TestBooleanQuery.java	(révision 1466277)
+++ lucene/core/src/test/org/apache/lucene/search/TestBooleanQuery.java	(copie de travail)
@@ -164,7 +164,7 @@
     query.add(wildcardQuery, BooleanClause.Occur.MUST_NOT);
     
     MultiReader multireader = new MultiReader(reader1, reader2);
-    IndexSearcher searcher = new IndexSearcher(multireader);
+    IndexSearcher searcher = newSearcher(multireader);
     assertEquals(0, searcher.search(query, 10).totalHits);
     
     final ExecutorService es = Executors.newCachedThreadPool(new NamedThreadFactory("NRT search threads"));
@@ -307,7 +307,7 @@
     writer.close();
 
     IndexReader indexReader = DirectoryReader.open(directory);
-    IndexSearcher searcher = new IndexSearcher(indexReader);
+    IndexSearcher searcher = newSearcher(indexReader);
 
     BooleanQuery query = new BooleanQuery();
     SpanQuery sq1 = new SpanTermQuery(new Term(FIELD, "clockwork"));
Index: lucene/core/src/test/org/apache/lucene/search/TestTermRangeQuery.java
===================================================================
--- lucene/core/src/test/org/apache/lucene/search/TestTermRangeQuery.java	(révision 1466277)
+++ lucene/core/src/test/org/apache/lucene/search/TestTermRangeQuery.java	(copie de travail)
@@ -56,21 +56,21 @@
     Query query = TermRangeQuery.newStringRange("content", "A", "C", false, false);
     initializeIndex(new String[] {"A", "B", "C", "D"});
     IndexReader reader = DirectoryReader.open(dir);
-    IndexSearcher searcher = new IndexSearcher(reader);
+    IndexSearcher searcher = newSearcher(reader);
     ScoreDoc[] hits = searcher.search(query, null, 1000).scoreDocs;
     assertEquals("A,B,C,D, only B in range", 1, hits.length);
     reader.close();
 
     initializeIndex(new String[] {"A", "B", "D"});
     reader = DirectoryReader.open(dir);
-    searcher = new IndexSearcher(reader);
+    searcher = newSearcher(reader);
     hits = searcher.search(query, null, 1000).scoreDocs;
     assertEquals("A,B,D, only B in range", 1, hits.length);
     reader.close();
 
     addDoc("C");
     reader = DirectoryReader.open(dir);
-    searcher = new IndexSearcher(reader);
+    searcher = newSearcher(reader);
     hits = searcher.search(query, null, 1000).scoreDocs;
     assertEquals("C added, still only B in range", 1, hits.length);
     reader.close();
@@ -81,21 +81,21 @@
 
     initializeIndex(new String[]{"A", "B", "C", "D"});
     IndexReader reader = DirectoryReader.open(dir);
-    IndexSearcher searcher = new IndexSearcher(reader);
+    IndexSearcher searcher = newSearcher(reader);
     ScoreDoc[] hits = searcher.search(query, null, 1000).scoreDocs;
     assertEquals("A,B,C,D - A,B,C in range", 3, hits.length);
     reader.close();
 
     initializeIndex(new String[]{"A", "B", "D"});
     reader = DirectoryReader.open(dir);
-    searcher = new IndexSearcher(reader);
+    searcher = newSearcher(reader);
     hits = searcher.search(query, null, 1000).scoreDocs;
     assertEquals("A,B,D - A and B in range", 2, hits.length);
     reader.close();
 
     addDoc("C");
     reader = DirectoryReader.open(dir);
-    searcher = new IndexSearcher(reader);
+    searcher = newSearcher(reader);
     hits = searcher.search(query, null, 1000).scoreDocs;
     assertEquals("C added - A, B, C in range", 3, hits.length);
     reader.close();
@@ -104,7 +104,7 @@
   public void testAllDocs() throws Exception {
     initializeIndex(new String[]{"A", "B", "C", "D"});
     IndexReader reader = DirectoryReader.open(dir);
-    IndexSearcher searcher = new IndexSearcher(reader);
+    IndexSearcher searcher = newSearcher(reader);
     TermRangeQuery query = new TermRangeQuery("content", null, null, true, true);
     Terms terms = MultiFields.getTerms(searcher.getIndexReader(), "content");
     assertFalse(query.getTermsEnum(terms) instanceof TermRangeTermsEnum);
@@ -128,7 +128,7 @@
     initializeIndex(new String[]{"A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K"});
 
     IndexReader reader = DirectoryReader.open(dir);
-    IndexSearcher searcher = new IndexSearcher(reader);
+    IndexSearcher searcher = newSearcher(reader);
     TermRangeQuery query = TermRangeQuery.newStringRange("content", "B", "J", true, true);
     checkBooleanTerms(searcher, query, "B", "C", "D", "E", "F", "G", "H", "I", "J");
     
@@ -276,7 +276,7 @@
                                  false, false);
     initializeIndex(new String[] {"A", "B", "", "C", "D"}, analyzer);
     IndexReader reader = DirectoryReader.open(dir);
-    IndexSearcher searcher = new IndexSearcher(reader);
+    IndexSearcher searcher = newSearcher(reader);
     int numHits = searcher.search(query, null, 1000).totalHits;
     // When Lucene-38 is fixed, use the assert on the next line:
     assertEquals("A,B,<empty string>,C,D => A, B & <empty string> are in range", 3, numHits);
@@ -286,7 +286,7 @@
     reader.close();
     initializeIndex(new String[] {"A", "B", "", "D"}, analyzer);
     reader = DirectoryReader.open(dir);
-    searcher = new IndexSearcher(reader);
+    searcher = newSearcher(reader);
     numHits = searcher.search(query, null, 1000).totalHits;
     // When Lucene-38 is fixed, use the assert on the next line:
     assertEquals("A,B,<empty string>,D => A, B & <empty string> are in range", 3, numHits);
@@ -295,7 +295,7 @@
     reader.close();
     addDoc("C");
     reader = DirectoryReader.open(dir);
-    searcher = new IndexSearcher(reader);
+    searcher = newSearcher(reader);
     numHits = searcher.search(query, null, 1000).totalHits;
     // When Lucene-38 is fixed, use the assert on the next line:
     assertEquals("C added, still A, B & <empty string> are in range", 3, numHits);
@@ -311,7 +311,7 @@
     Query query = TermRangeQuery.newStringRange("content", null, "C", true, true);
     initializeIndex(new String[]{"A", "B", "","C", "D"}, analyzer);
     IndexReader reader = DirectoryReader.open(dir);
-    IndexSearcher searcher = new IndexSearcher(reader);
+    IndexSearcher searcher = newSearcher(reader);
     int numHits = searcher.search(query, null, 1000).totalHits;
     // When Lucene-38 is fixed, use the assert on the next line:
     assertEquals("A,B,<empty string>,C,D => A,B,<empty string>,C in range", 4, numHits);
@@ -320,7 +320,7 @@
     reader.close();
     initializeIndex(new String[]{"A", "B", "", "D"}, analyzer);
     reader = DirectoryReader.open(dir);
-    searcher = new IndexSearcher(reader);
+    searcher = newSearcher(reader);
     numHits = searcher.search(query, null, 1000).totalHits;
     // When Lucene-38 is fixed, use the assert on the next line:
     assertEquals("A,B,<empty string>,D - A, B and <empty string> in range", 3, numHits);
@@ -329,7 +329,7 @@
     reader.close();
     addDoc("C");
     reader = DirectoryReader.open(dir);
-    searcher = new IndexSearcher(reader);
+    searcher = newSearcher(reader);
     numHits = searcher.search(query, null, 1000).totalHits;
     // When Lucene-38 is fixed, use the assert on the next line:
     assertEquals("C added => A,B,<empty string>,C in range", 4, numHits);
Index: lucene/core/src/test/org/apache/lucene/search/TestSort.java
===================================================================
--- lucene/core/src/test/org/apache/lucene/search/TestSort.java	(révision 1466277)
+++ lucene/core/src/test/org/apache/lucene/search/TestSort.java	(copie de travail)
@@ -69,7 +69,7 @@
     IndexReader ir = writer.getReader();
     writer.close();
     
-    IndexSearcher searcher = new IndexSearcher(ir);
+    IndexSearcher searcher = newSearcher(ir);
     Sort sort = new Sort(new SortField("value", SortField.Type.STRING));
 
     TopDocs td = searcher.search(new MatchAllDocsQuery(), 10, sort);
@@ -97,7 +97,7 @@
     IndexReader ir = writer.getReader();
     writer.close();
     
-    IndexSearcher searcher = new IndexSearcher(ir);
+    IndexSearcher searcher = newSearcher(ir);
     Sort sort = new Sort(new SortField("value", SortField.Type.STRING));
 
     TopDocs td = searcher.search(new MatchAllDocsQuery(), 10, sort);
@@ -124,7 +124,7 @@
     IndexReader ir = writer.getReader();
     writer.close();
     
-    IndexSearcher searcher = new IndexSearcher(ir);
+    IndexSearcher searcher = newSearcher(ir);
     Sort sort = new Sort(new SortField("value", SortField.Type.STRING, true));
 
     TopDocs td = searcher.search(new MatchAllDocsQuery(), 10, sort);
@@ -150,7 +150,7 @@
     IndexReader ir = writer.getReader();
     writer.close();
     
-    IndexSearcher searcher = new IndexSearcher(ir);
+    IndexSearcher searcher = newSearcher(ir);
     Sort sort = new Sort(new SortField("value", SortField.Type.STRING_VAL));
 
     TopDocs td = searcher.search(new MatchAllDocsQuery(), 10, sort);
@@ -178,7 +178,7 @@
     IndexReader ir = writer.getReader();
     writer.close();
     
-    IndexSearcher searcher = new IndexSearcher(ir);
+    IndexSearcher searcher = newSearcher(ir);
     Sort sort = new Sort(new SortField("value", SortField.Type.STRING_VAL));
 
     TopDocs td = searcher.search(new MatchAllDocsQuery(), 10, sort);
@@ -205,7 +205,7 @@
     IndexReader ir = writer.getReader();
     writer.close();
     
-    IndexSearcher searcher = new IndexSearcher(ir);
+    IndexSearcher searcher = newSearcher(ir);
     Sort sort = new Sort(new SortField("value", SortField.Type.STRING_VAL, true));
 
     TopDocs td = searcher.search(new MatchAllDocsQuery(), 10, sort);
@@ -231,7 +231,7 @@
     IndexReader ir = writer.getReader();
     writer.close();
     
-    IndexSearcher searcher = new IndexSearcher(ir);
+    IndexSearcher searcher = newSearcher(ir);
     Sort sort = new Sort(SortField.FIELD_DOC);
 
     TopDocs td = searcher.search(new MatchAllDocsQuery(), 10, sort);
@@ -257,7 +257,7 @@
     IndexReader ir = writer.getReader();
     writer.close();
     
-    IndexSearcher searcher = new IndexSearcher(ir);
+    IndexSearcher searcher = newSearcher(ir);
     Sort sort = new Sort(new SortField(null, SortField.Type.DOC, true));
 
     TopDocs td = searcher.search(new MatchAllDocsQuery(), 10, sort);
@@ -283,7 +283,7 @@
     IndexReader ir = writer.getReader();
     writer.close();
     
-    IndexSearcher searcher = new IndexSearcher(ir);
+    IndexSearcher searcher = newSearcher(ir);
     Sort sort = new Sort();
 
     TopDocs actual = searcher.search(new TermQuery(new Term("value", "foo")), 10, sort);
@@ -313,7 +313,7 @@
     IndexReader ir = writer.getReader();
     writer.close();
     
-    IndexSearcher searcher = new IndexSearcher(ir);
+    IndexSearcher searcher = newSearcher(ir);
     Sort sort = new Sort(new SortField(null, SortField.Type.SCORE, true));
 
     TopDocs actual = searcher.search(new TermQuery(new Term("value", "foo")), 10, sort);
@@ -345,7 +345,7 @@
     IndexReader ir = writer.getReader();
     writer.close();
     
-    IndexSearcher searcher = new IndexSearcher(ir);
+    IndexSearcher searcher = newSearcher(ir);
     Sort sort = new Sort(new SortField("value", SortField.Type.BYTE));
 
     TopDocs td = searcher.search(new MatchAllDocsQuery(), 10, sort);
@@ -374,7 +374,7 @@
     IndexReader ir = writer.getReader();
     writer.close();
     
-    IndexSearcher searcher = new IndexSearcher(ir);
+    IndexSearcher searcher = newSearcher(ir);
     Sort sort = new Sort(new SortField("value", SortField.Type.BYTE));
 
     TopDocs td = searcher.search(new MatchAllDocsQuery(), 10, sort);
@@ -403,7 +403,7 @@
     IndexReader ir = writer.getReader();
     writer.close();
     
-    IndexSearcher searcher = new IndexSearcher(ir);
+    IndexSearcher searcher = newSearcher(ir);
     SortField sortField = new SortField("value", SortField.Type.BYTE);
     sortField.setMissingValue(Byte.MAX_VALUE);
     Sort sort = new Sort(sortField);
@@ -435,7 +435,7 @@
     IndexReader ir = writer.getReader();
     writer.close();
     
-    IndexSearcher searcher = new IndexSearcher(ir);
+    IndexSearcher searcher = newSearcher(ir);
     Sort sort = new Sort(new SortField("value", SortField.Type.BYTE, true));
 
     TopDocs td = searcher.search(new MatchAllDocsQuery(), 10, sort);
@@ -465,7 +465,7 @@
     IndexReader ir = writer.getReader();
     writer.close();
     
-    IndexSearcher searcher = new IndexSearcher(ir);
+    IndexSearcher searcher = newSearcher(ir);
     Sort sort = new Sort(new SortField("value", SortField.Type.SHORT));
 
     TopDocs td = searcher.search(new MatchAllDocsQuery(), 10, sort);
@@ -494,7 +494,7 @@
     IndexReader ir = writer.getReader();
     writer.close();
     
-    IndexSearcher searcher = new IndexSearcher(ir);
+    IndexSearcher searcher = newSearcher(ir);
     Sort sort = new Sort(new SortField("value", SortField.Type.SHORT));
 
     TopDocs td = searcher.search(new MatchAllDocsQuery(), 10, sort);
@@ -523,7 +523,7 @@
     IndexReader ir = writer.getReader();
     writer.close();
     
-    IndexSearcher searcher = new IndexSearcher(ir);
+    IndexSearcher searcher = newSearcher(ir);
     SortField sortField = new SortField("value", SortField.Type.SHORT);
     sortField.setMissingValue(Short.MAX_VALUE);
     Sort sort = new Sort(sortField);
@@ -555,7 +555,7 @@
     IndexReader ir = writer.getReader();
     writer.close();
     
-    IndexSearcher searcher = new IndexSearcher(ir);
+    IndexSearcher searcher = newSearcher(ir);
     Sort sort = new Sort(new SortField("value", SortField.Type.SHORT, true));
 
     TopDocs td = searcher.search(new MatchAllDocsQuery(), 10, sort);
@@ -585,7 +585,7 @@
     IndexReader ir = writer.getReader();
     writer.close();
     
-    IndexSearcher searcher = new IndexSearcher(ir);
+    IndexSearcher searcher = newSearcher(ir);
     Sort sort = new Sort(new SortField("value", SortField.Type.INT));
 
     TopDocs td = searcher.search(new MatchAllDocsQuery(), 10, sort);
@@ -614,7 +614,7 @@
     IndexReader ir = writer.getReader();
     writer.close();
     
-    IndexSearcher searcher = new IndexSearcher(ir);
+    IndexSearcher searcher = newSearcher(ir);
     Sort sort = new Sort(new SortField("value", SortField.Type.INT));
 
     TopDocs td = searcher.search(new MatchAllDocsQuery(), 10, sort);
@@ -643,7 +643,7 @@
     IndexReader ir = writer.getReader();
     writer.close();
     
-    IndexSearcher searcher = new IndexSearcher(ir);
+    IndexSearcher searcher = newSearcher(ir);
     SortField sortField = new SortField("value", SortField.Type.INT);
     sortField.setMissingValue(Integer.MAX_VALUE);
     Sort sort = new Sort(sortField);
@@ -675,7 +675,7 @@
     IndexReader ir = writer.getReader();
     writer.close();
     
-    IndexSearcher searcher = new IndexSearcher(ir);
+    IndexSearcher searcher = newSearcher(ir);
     Sort sort = new Sort(new SortField("value", SortField.Type.INT, true));
 
     TopDocs td = searcher.search(new MatchAllDocsQuery(), 10, sort);
@@ -705,7 +705,7 @@
     IndexReader ir = writer.getReader();
     writer.close();
     
-    IndexSearcher searcher = new IndexSearcher(ir);
+    IndexSearcher searcher = newSearcher(ir);
     Sort sort = new Sort(new SortField("value", SortField.Type.LONG));
 
     TopDocs td = searcher.search(new MatchAllDocsQuery(), 10, sort);
@@ -734,7 +734,7 @@
     IndexReader ir = writer.getReader();
     writer.close();
     
-    IndexSearcher searcher = new IndexSearcher(ir);
+    IndexSearcher searcher = newSearcher(ir);
     Sort sort = new Sort(new SortField("value", SortField.Type.LONG));
 
     TopDocs td = searcher.search(new MatchAllDocsQuery(), 10, sort);
@@ -763,7 +763,7 @@
     IndexReader ir = writer.getReader();
     writer.close();
     
-    IndexSearcher searcher = new IndexSearcher(ir);
+    IndexSearcher searcher = newSearcher(ir);
     SortField sortField = new SortField("value", SortField.Type.LONG);
     sortField.setMissingValue(Long.MAX_VALUE);
     Sort sort = new Sort(sortField);
@@ -795,7 +795,7 @@
     IndexReader ir = writer.getReader();
     writer.close();
     
-    IndexSearcher searcher = new IndexSearcher(ir);
+    IndexSearcher searcher = newSearcher(ir);
     Sort sort = new Sort(new SortField("value", SortField.Type.LONG, true));
 
     TopDocs td = searcher.search(new MatchAllDocsQuery(), 10, sort);
@@ -825,7 +825,7 @@
     IndexReader ir = writer.getReader();
     writer.close();
     
-    IndexSearcher searcher = new IndexSearcher(ir);
+    IndexSearcher searcher = newSearcher(ir);
     Sort sort = new Sort(new SortField("value", SortField.Type.FLOAT));
 
     TopDocs td = searcher.search(new MatchAllDocsQuery(), 10, sort);
@@ -854,7 +854,7 @@
     IndexReader ir = writer.getReader();
     writer.close();
     
-    IndexSearcher searcher = new IndexSearcher(ir);
+    IndexSearcher searcher = newSearcher(ir);
     Sort sort = new Sort(new SortField("value", SortField.Type.FLOAT));
 
     TopDocs td = searcher.search(new MatchAllDocsQuery(), 10, sort);
@@ -883,7 +883,7 @@
     IndexReader ir = writer.getReader();
     writer.close();
     
-    IndexSearcher searcher = new IndexSearcher(ir);
+    IndexSearcher searcher = newSearcher(ir);
     SortField sortField = new SortField("value", SortField.Type.FLOAT);
     sortField.setMissingValue(Float.MAX_VALUE);
     Sort sort = new Sort(sortField);
@@ -915,7 +915,7 @@
     IndexReader ir = writer.getReader();
     writer.close();
     
-    IndexSearcher searcher = new IndexSearcher(ir);
+    IndexSearcher searcher = newSearcher(ir);
     Sort sort = new Sort(new SortField("value", SortField.Type.FLOAT, true));
 
     TopDocs td = searcher.search(new MatchAllDocsQuery(), 10, sort);
@@ -948,7 +948,7 @@
     IndexReader ir = writer.getReader();
     writer.close();
     
-    IndexSearcher searcher = new IndexSearcher(ir);
+    IndexSearcher searcher = newSearcher(ir);
     Sort sort = new Sort(new SortField("value", SortField.Type.DOUBLE));
 
     TopDocs td = searcher.search(new MatchAllDocsQuery(), 10, sort);
@@ -981,7 +981,7 @@
     IndexReader ir = writer.getReader();
     writer.close();
     
-    IndexSearcher searcher = new IndexSearcher(ir);
+    IndexSearcher searcher = newSearcher(ir);
     Sort sort = new Sort(new SortField("value", SortField.Type.DOUBLE));
 
     TopDocs td = searcher.search(new MatchAllDocsQuery(), 10, sort);
@@ -1014,7 +1014,7 @@
     IndexReader ir = writer.getReader();
     writer.close();
     
-    IndexSearcher searcher = new IndexSearcher(ir);
+    IndexSearcher searcher = newSearcher(ir);
     SortField sortField = new SortField("value", SortField.Type.DOUBLE);
     sortField.setMissingValue(Double.MAX_VALUE);
     Sort sort = new Sort(sortField);
@@ -1050,7 +1050,7 @@
     IndexReader ir = writer.getReader();
     writer.close();
     
-    IndexSearcher searcher = new IndexSearcher(ir);
+    IndexSearcher searcher = newSearcher(ir);
     Sort sort = new Sort(new SortField("value", SortField.Type.DOUBLE, true));
 
     TopDocs td = searcher.search(new MatchAllDocsQuery(), 10, sort);
@@ -1108,7 +1108,7 @@
         SortField.FIELD_DOC);
     // this should not throw AIOOBE or RuntimeEx
     IndexReader reader = DirectoryReader.open(indexStore);
-    IndexSearcher searcher = new IndexSearcher(reader);
+    IndexSearcher searcher = newSearcher(reader);
     searcher.search(new MatchAllDocsQuery(), null, 500, sort);
     reader.close();
     indexStore.close();
@@ -1150,7 +1150,7 @@
   
   /** test sorts when there's nothing in the index */
   public void testEmptyIndex() throws Exception {
-    IndexSearcher empty = new IndexSearcher(new MultiReader());
+    IndexSearcher empty = newSearcher(new MultiReader());
     Query query = new TermQuery(new Term("contents", "foo"));
   
     Sort sort = new Sort();
@@ -1452,7 +1452,7 @@
     IndexReader ir = writer.getReader();
     writer.close();
     
-    IndexSearcher searcher = new IndexSearcher(ir);
+    IndexSearcher searcher = newSearcher(ir);
     Sort sort = new Sort(new SortField("value", SortField.Type.STRING));
 
     TopDocs td = searcher.search(new MatchAllDocsQuery(), 10, sort);
@@ -1473,7 +1473,7 @@
     IndexReader ir = writer.getReader();
     writer.close();
     
-    IndexSearcher searcher = new IndexSearcher(ir);
+    IndexSearcher searcher = newSearcher(ir);
     Sort sort = new Sort(new SortField("value", SortField.Type.STRING));
 
     TopDocs expected = searcher.search(new TermQuery(new Term("value", "foo")), 10);
@@ -1502,7 +1502,7 @@
     IndexReader ir = writer.getReader();
     writer.close();
     
-    IndexSearcher searcher = new IndexSearcher(ir);
+    IndexSearcher searcher = newSearcher(ir);
     // tievalue, then value
     Sort sort = new Sort(new SortField("tievalue", SortField.Type.STRING),
                          new SortField("value", SortField.Type.STRING));
Index: lucene/core/src/test/org/apache/lucene/search/TestNumericRangeQuery32.java
===================================================================
--- lucene/core/src/test/org/apache/lucene/search/TestNumericRangeQuery32.java	(révision 1466277)
+++ lucene/core/src/test/org/apache/lucene/search/TestNumericRangeQuery32.java	(copie de travail)
@@ -327,7 +327,7 @@
     writer.close();
     
     IndexReader r = DirectoryReader.open(dir);
-    IndexSearcher s = new IndexSearcher(r);
+    IndexSearcher s = newSearcher(r);
     
     Query q=NumericRangeQuery.newIntRange("int", null, null, true, true);
     TopDocs topDocs = s.search(q, 10);
Index: lucene/core/src/test/org/apache/lucene/search/TestSearcherManager.java
===================================================================
--- lucene/core/src/test/org/apache/lucene/search/TestSearcherManager.java	(révision 1466277)
+++ lucene/core/src/test/org/apache/lucene/search/TestSearcherManager.java	(copie de travail)
@@ -39,6 +39,7 @@
 import org.apache.lucene.index.ThreadedIndexingAndSearchingTestCase;
 import org.apache.lucene.store.AlreadyClosedException;
 import org.apache.lucene.store.Directory;
+import org.apache.lucene.util.LuceneTestCase;
 import org.apache.lucene.util.LuceneTestCase.SuppressCodecs;
 import org.apache.lucene.util.NamedThreadFactory;
 import org.apache.lucene.util._TestUtil;
@@ -361,7 +362,7 @@
     final SearcherFactory theEvilOne = new SearcherFactory() {
       @Override
       public IndexSearcher newSearcher(IndexReader ignored) {
-        return new IndexSearcher(other);
+        return LuceneTestCase.newSearcher(other);
       }
       };
 
Index: lucene/core/src/test/org/apache/lucene/search/TestNRTManager.java
===================================================================
--- lucene/core/src/test/org/apache/lucene/search/TestNRTManager.java	(révision 1466277)
+++ lucene/core/src/test/org/apache/lucene/search/TestNRTManager.java	(copie de travail)
@@ -39,6 +39,7 @@
 import org.apache.lucene.store.Directory;
 import org.apache.lucene.store.NRTCachingDirectory;
 import org.apache.lucene.util.IOUtils;
+import org.apache.lucene.util.LuceneTestCase;
 import org.apache.lucene.util.LuceneTestCase.SuppressCodecs;
 import org.apache.lucene.util.ThreadInterruptedException;
 
@@ -402,7 +403,7 @@
     final SearcherFactory theEvilOne = new SearcherFactory() {
       @Override
       public IndexSearcher newSearcher(IndexReader ignored) {
-        return new IndexSearcher(other);
+        return LuceneTestCase.newSearcher(other);
       }
       };
 
Index: lucene/core/src/test/org/apache/lucene/search/TestScorerPerf.java
===================================================================
--- lucene/core/src/test/org/apache/lucene/search/TestScorerPerf.java	(révision 1466277)
+++ lucene/core/src/test/org/apache/lucene/search/TestScorerPerf.java	(copie de travail)
@@ -53,7 +53,7 @@
     iw.addDocument(new Document());
     iw.close();
     r = DirectoryReader.open(d);
-    s = new IndexSearcher(r);
+    s = newSearcher(r);
   }
 
   public void createRandomTerms(int nDocs, int nTerms, double power, Directory dir) throws Exception {
@@ -366,7 +366,7 @@
     RAMDirectory dir = new RAMDirectory();
     if (VERBOSE) System.out.println("Creating index");
     createRandomTerms(100000,25,.5, dir);
-    s = new IndexSearcher(dir, true);
+    s = newSearcher(dir, true);
     if (VERBOSE) System.out.println("Starting performance test");
     for (int i=0; i<bigIter; i++) {
       long start = System.currentTimeMillis();
@@ -383,7 +383,7 @@
     RAMDirectory dir = new RAMDirectory();
     if (VERBOSE) System.out.println("Creating index");
     createRandomTerms(100000,25,.2, dir);
-    s = new IndexSearcher(dir, true);
+    s = newSearcher(dir, true);
     if (VERBOSE) System.out.println("Starting performance test");
     for (int i=0; i<bigIter; i++) {
       long start = System.currentTimeMillis();
@@ -401,7 +401,7 @@
     RAMDirectory dir = new RAMDirectory();
     if (VERBOSE) System.out.println("Creating index");
     createRandomTerms(100000,25,2,dir);
-    s = new IndexSearcher(dir, true);
+    s = newSearcher(dir, true);
     if (VERBOSE) System.out.println("Starting performance test");
     for (int i=0; i<bigIter; i++) {
       long start = System.currentTimeMillis();
Index: lucene/core/src/test/org/apache/lucene/search/TestSameScoresWithThreads.java
===================================================================
--- lucene/core/src/test/org/apache/lucene/search/TestSameScoresWithThreads.java	(révision 1466277)
+++ lucene/core/src/test/org/apache/lucene/search/TestSameScoresWithThreads.java	(copie de travail)
@@ -57,7 +57,7 @@
     //System.out.println("numDocs=" + r.numDocs());
     w.close();
 
-    final IndexSearcher s = new IndexSearcher(r);
+    final IndexSearcher s = newSearcher(r);
     Terms terms = MultiFields.getFields(r).terms("body");
     int termCount = 0;
     TermsEnum termsEnum = terms.iterator(null);
Index: lucene/core/src/test/org/apache/lucene/search/TestMultiPhraseQuery.java
===================================================================
--- lucene/core/src/test/org/apache/lucene/search/TestMultiPhraseQuery.java	(révision 1466277)
+++ lucene/core/src/test/org/apache/lucene/search/TestMultiPhraseQuery.java	(copie de travail)
@@ -376,7 +376,7 @@
     writer.addDocument(doc);
     IndexReader r = writer.getReader();
     writer.close();
-    IndexSearcher s = new IndexSearcher(r);
+    IndexSearcher s = newSearcher(r);
     MultiPhraseQuery mpq = new MultiPhraseQuery();
     //mpq.setSlop(1);
 
@@ -474,7 +474,7 @@
     writer.addDocument(doc);
     IndexReader r = DirectoryReader.open(writer,false);
     writer.close();
-    IndexSearcher s = new IndexSearcher(r);
+    IndexSearcher s = newSearcher(r);
     
     if (VERBOSE) {
       System.out.println("QUERY=" + q);
Index: lucene/core/src/test/org/apache/lucene/search/TestBooleanQueryVisitSubscorers.java
===================================================================
--- lucene/core/src/test/org/apache/lucene/search/TestBooleanQueryVisitSubscorers.java	(révision 1466277)
+++ lucene/core/src/test/org/apache/lucene/search/TestBooleanQueryVisitSubscorers.java	(copie de travail)
@@ -61,7 +61,7 @@
     writer.addDocument(doc("nutch", "nutch is an internet search engine with web crawler and is using lucene and hadoop"));
     reader = writer.getReader();
     writer.close();
-    searcher = new IndexSearcher(reader);
+    searcher = newSearcher(reader);
   }
   
   @Override
Index: lucene/core/src/test/org/apache/lucene/search/TestSortDocValues.java
===================================================================
--- lucene/core/src/test/org/apache/lucene/search/TestSortDocValues.java	(révision 1466277)
+++ lucene/core/src/test/org/apache/lucene/search/TestSortDocValues.java	(copie de travail)
@@ -64,7 +64,7 @@
     IndexReader ir = writer.getReader();
     writer.close();
     
-    IndexSearcher searcher = new IndexSearcher(ir);
+    IndexSearcher searcher = newSearcher(ir);
     Sort sort = new Sort(new SortField("value", SortField.Type.STRING));
 
     TopDocs td = searcher.search(new MatchAllDocsQuery(), 10, sort);
@@ -93,7 +93,7 @@
     IndexReader ir = writer.getReader();
     writer.close();
     
-    IndexSearcher searcher = new IndexSearcher(ir);
+    IndexSearcher searcher = newSearcher(ir);
     Sort sort = new Sort(new SortField("value", SortField.Type.STRING, true));
 
     TopDocs td = searcher.search(new MatchAllDocsQuery(), 10, sort);
@@ -122,7 +122,7 @@
     IndexReader ir = writer.getReader();
     writer.close();
     
-    IndexSearcher searcher = new IndexSearcher(ir);
+    IndexSearcher searcher = newSearcher(ir);
     Sort sort = new Sort(new SortField("value", SortField.Type.STRING_VAL));
 
     TopDocs td = searcher.search(new MatchAllDocsQuery(), 10, sort);
@@ -151,7 +151,7 @@
     IndexReader ir = writer.getReader();
     writer.close();
     
-    IndexSearcher searcher = new IndexSearcher(ir);
+    IndexSearcher searcher = newSearcher(ir);
     Sort sort = new Sort(new SortField("value", SortField.Type.STRING_VAL, true));
 
     TopDocs td = searcher.search(new MatchAllDocsQuery(), 10, sort);
@@ -180,7 +180,7 @@
     IndexReader ir = writer.getReader();
     writer.close();
     
-    IndexSearcher searcher = new IndexSearcher(ir);
+    IndexSearcher searcher = newSearcher(ir);
     Sort sort = new Sort(new SortField("value", SortField.Type.STRING_VAL));
 
     TopDocs td = searcher.search(new MatchAllDocsQuery(), 10, sort);
@@ -209,7 +209,7 @@
     IndexReader ir = writer.getReader();
     writer.close();
     
-    IndexSearcher searcher = new IndexSearcher(ir);
+    IndexSearcher searcher = newSearcher(ir);
     Sort sort = new Sort(new SortField("value", SortField.Type.STRING_VAL, true));
 
     TopDocs td = searcher.search(new MatchAllDocsQuery(), 10, sort);
@@ -242,7 +242,7 @@
     IndexReader ir = writer.getReader();
     writer.close();
     
-    IndexSearcher searcher = new IndexSearcher(ir);
+    IndexSearcher searcher = newSearcher(ir);
     Sort sort = new Sort(new SortField("value", SortField.Type.BYTE));
 
     TopDocs td = searcher.search(new MatchAllDocsQuery(), 10, sort);
@@ -276,7 +276,7 @@
     IndexReader ir = writer.getReader();
     writer.close();
     
-    IndexSearcher searcher = new IndexSearcher(ir);
+    IndexSearcher searcher = newSearcher(ir);
     Sort sort = new Sort(new SortField("value", SortField.Type.BYTE, true));
 
     TopDocs td = searcher.search(new MatchAllDocsQuery(), 10, sort);
@@ -310,7 +310,7 @@
     IndexReader ir = writer.getReader();
     writer.close();
     
-    IndexSearcher searcher = new IndexSearcher(ir);
+    IndexSearcher searcher = newSearcher(ir);
     Sort sort = new Sort(new SortField("value", SortField.Type.SHORT));
 
     TopDocs td = searcher.search(new MatchAllDocsQuery(), 10, sort);
@@ -344,7 +344,7 @@
     IndexReader ir = writer.getReader();
     writer.close();
     
-    IndexSearcher searcher = new IndexSearcher(ir);
+    IndexSearcher searcher = newSearcher(ir);
     Sort sort = new Sort(new SortField("value", SortField.Type.SHORT, true));
 
     TopDocs td = searcher.search(new MatchAllDocsQuery(), 10, sort);
@@ -378,7 +378,7 @@
     IndexReader ir = writer.getReader();
     writer.close();
     
-    IndexSearcher searcher = new IndexSearcher(ir);
+    IndexSearcher searcher = newSearcher(ir);
     Sort sort = new Sort(new SortField("value", SortField.Type.INT));
 
     TopDocs td = searcher.search(new MatchAllDocsQuery(), 10, sort);
@@ -412,7 +412,7 @@
     IndexReader ir = writer.getReader();
     writer.close();
     
-    IndexSearcher searcher = new IndexSearcher(ir);
+    IndexSearcher searcher = newSearcher(ir);
     Sort sort = new Sort(new SortField("value", SortField.Type.INT, true));
 
     TopDocs td = searcher.search(new MatchAllDocsQuery(), 10, sort);
@@ -446,7 +446,7 @@
     IndexReader ir = writer.getReader();
     writer.close();
     
-    IndexSearcher searcher = new IndexSearcher(ir);
+    IndexSearcher searcher = newSearcher(ir);
     Sort sort = new Sort(new SortField("value", SortField.Type.LONG));
 
     TopDocs td = searcher.search(new MatchAllDocsQuery(), 10, sort);
@@ -480,7 +480,7 @@
     IndexReader ir = writer.getReader();
     writer.close();
     
-    IndexSearcher searcher = new IndexSearcher(ir);
+    IndexSearcher searcher = newSearcher(ir);
     Sort sort = new Sort(new SortField("value", SortField.Type.LONG, true));
 
     TopDocs td = searcher.search(new MatchAllDocsQuery(), 10, sort);
@@ -514,7 +514,7 @@
     IndexReader ir = writer.getReader();
     writer.close();
     
-    IndexSearcher searcher = new IndexSearcher(ir);
+    IndexSearcher searcher = newSearcher(ir);
     Sort sort = new Sort(new SortField("value", SortField.Type.FLOAT));
 
     TopDocs td = searcher.search(new MatchAllDocsQuery(), 10, sort);
@@ -548,7 +548,7 @@
     IndexReader ir = writer.getReader();
     writer.close();
     
-    IndexSearcher searcher = new IndexSearcher(ir);
+    IndexSearcher searcher = newSearcher(ir);
     Sort sort = new Sort(new SortField("value", SortField.Type.FLOAT, true));
 
     TopDocs td = searcher.search(new MatchAllDocsQuery(), 10, sort);
@@ -586,7 +586,7 @@
     IndexReader ir = writer.getReader();
     writer.close();
     
-    IndexSearcher searcher = new IndexSearcher(ir);
+    IndexSearcher searcher = newSearcher(ir);
     Sort sort = new Sort(new SortField("value", SortField.Type.DOUBLE));
 
     TopDocs td = searcher.search(new MatchAllDocsQuery(), 10, sort);
@@ -625,7 +625,7 @@
     IndexReader ir = writer.getReader();
     writer.close();
     
-    IndexSearcher searcher = new IndexSearcher(ir);
+    IndexSearcher searcher = newSearcher(ir);
     Sort sort = new Sort(new SortField("value", SortField.Type.DOUBLE, true));
 
     TopDocs td = searcher.search(new MatchAllDocsQuery(), 10, sort);
Index: lucene/core/src/test/org/apache/lucene/search/TestConjunctions.java
===================================================================
--- lucene/core/src/test/org/apache/lucene/search/TestConjunctions.java	(révision 1466277)
+++ lucene/core/src/test/org/apache/lucene/search/TestConjunctions.java	(copie de travail)
@@ -58,7 +58,7 @@
     writer.addDocument(doc("nutch", "nutch is an internet search engine with web crawler and is using lucene and hadoop"));
     reader = writer.getReader();
     writer.close();
-    searcher = new IndexSearcher(reader);
+    searcher = newSearcher(reader);
     searcher.setSimilarity(new TFSimilarity());
   }
   
Index: lucene/core/src/test/org/apache/lucene/search/TestQueryWrapperFilter.java
===================================================================
--- lucene/core/src/test/org/apache/lucene/search/TestQueryWrapperFilter.java	(révision 1466277)
+++ lucene/core/src/test/org/apache/lucene/search/TestQueryWrapperFilter.java	(copie de travail)
@@ -113,7 +113,7 @@
 
     final IndexReader r = w.getReader();
     w.close();
-    final TopDocs hits = new IndexSearcher(r).search(new MatchAllDocsQuery(),
+    final TopDocs hits = newSearcher(r).search(new MatchAllDocsQuery(),
                                                      new QueryWrapperFilter(new TermQuery(new Term("field", "a"))),
                                                      numDocs);
     assertEquals(aDocs.size(), hits.totalHits);
Index: lucene/core/src/test/org/apache/lucene/search/TestNumericRangeQuery64.java
===================================================================
--- lucene/core/src/test/org/apache/lucene/search/TestNumericRangeQuery64.java	(révision 1466277)
+++ lucene/core/src/test/org/apache/lucene/search/TestNumericRangeQuery64.java	(copie de travail)
@@ -352,7 +352,7 @@
     writer.close();
     
     IndexReader r = DirectoryReader.open(dir);
-    IndexSearcher s = new IndexSearcher(r);
+    IndexSearcher s = newSearcher(r);
     
     Query q=NumericRangeQuery.newLongRange("long", null, null, true, true);
     TopDocs topDocs = s.search(q, 10);
Index: lucene/core/src/test/org/apache/lucene/search/TestTermScorer.java
===================================================================
--- lucene/core/src/test/org/apache/lucene/search/TestTermScorer.java	(révision 1466277)
+++ lucene/core/src/test/org/apache/lucene/search/TestTermScorer.java	(copie de travail)
@@ -140,7 +140,7 @@
     Weight weight = indexSearcher.createNormalizedWeight(termQuery);
     assertTrue(indexSearcher.getTopReaderContext() instanceof AtomicReaderContext);
     AtomicReaderContext context = (AtomicReaderContext) indexSearcher.getTopReaderContext();
-    Scorer ts = weight.scorer(context, true, true, context.reader().getLiveDocs());
+    Scorer ts = weight.scorer(context, true, false, context.reader().getLiveDocs());
     assertTrue("next did not return a doc",
         ts.nextDoc() != DocIdSetIterator.NO_MORE_DOCS);
     assertTrue("score is not correct", ts.score() == 1.6931472f);
@@ -159,7 +159,7 @@
     Weight weight = indexSearcher.createNormalizedWeight(termQuery);
     assertTrue(indexSearcher.getTopReaderContext() instanceof AtomicReaderContext);
     AtomicReaderContext context = (AtomicReaderContext) indexSearcher.getTopReaderContext();
-    Scorer ts = weight.scorer(context, true, true, context.reader().getLiveDocs());
+    Scorer ts = weight.scorer(context, true, false, context.reader().getLiveDocs());
     assertTrue("Didn't skip", ts.advance(3) != DocIdSetIterator.NO_MORE_DOCS);
     // The next doc should be doc 5
     assertTrue("doc should be number 5", ts.docID() == 5);
Index: lucene/core/src/test/org/apache/lucene/search/TestFieldValueFilter.java
===================================================================
--- lucene/core/src/test/org/apache/lucene/search/TestFieldValueFilter.java	(révision 1466277)
+++ lucene/core/src/test/org/apache/lucene/search/TestFieldValueFilter.java	(copie de travail)
@@ -47,7 +47,7 @@
     }
 
     IndexReader reader = DirectoryReader.open(directory);
-    IndexSearcher searcher = new IndexSearcher(reader);
+    IndexSearcher searcher = newSearcher(reader);
     TopDocs search = searcher.search(new TermQuery(new Term("all", "test")),
         new FieldValueFilter("some", true), docs);
     assertEquals(search.totalHits, numDocsNoValue);
@@ -74,7 +74,7 @@
       }
     }
     IndexReader reader = DirectoryReader.open(directory);
-    IndexSearcher searcher = new IndexSearcher(reader);
+    IndexSearcher searcher = newSearcher(reader);
     TopDocs search = searcher.search(new TermQuery(new Term("all", "test")),
         new FieldValueFilter("some"), docs);
     assertEquals(search.totalHits, numDocsWithValue);
Index: lucene/core/src/test/org/apache/lucene/search/TestWildcard.java
===================================================================
--- lucene/core/src/test/org/apache/lucene/search/TestWildcard.java	(révision 1466277)
+++ lucene/core/src/test/org/apache/lucene/search/TestWildcard.java	(copie de travail)
@@ -70,7 +70,7 @@
   public void testTermWithoutWildcard() throws IOException {
       Directory indexStore = getIndexStore("field", new String[]{"nowildcard", "nowildcardx"});
       IndexReader reader = DirectoryReader.open(indexStore);
-      IndexSearcher searcher = new IndexSearcher(reader);
+      IndexSearcher searcher = newSearcher(reader);
 
       MultiTermQuery wq = new WildcardQuery(new Term("field", "nowildcard"));
       assertMatches(searcher, wq, 1);
@@ -108,7 +108,7 @@
   public void testEmptyTerm() throws IOException {
     Directory indexStore = getIndexStore("field", new String[]{"nowildcard", "nowildcardx"});
     IndexReader reader = DirectoryReader.open(indexStore);
-    IndexSearcher searcher = new IndexSearcher(reader);
+    IndexSearcher searcher = newSearcher(reader);
 
     MultiTermQuery wq = new WildcardQuery(new Term("field", ""));
     wq.setRewriteMethod(MultiTermQuery.SCORING_BOOLEAN_QUERY_REWRITE);
@@ -128,7 +128,7 @@
   public void testPrefixTerm() throws IOException {
     Directory indexStore = getIndexStore("field", new String[]{"prefix", "prefixx"});
     IndexReader reader = DirectoryReader.open(indexStore);
-    IndexSearcher searcher = new IndexSearcher(reader);
+    IndexSearcher searcher = newSearcher(reader);
 
     MultiTermQuery wq = new WildcardQuery(new Term("field", "prefix*"));
     assertMatches(searcher, wq, 2);
@@ -151,7 +151,7 @@
     Directory indexStore = getIndexStore("body", new String[]
     {"metal", "metals"});
     IndexReader reader = DirectoryReader.open(indexStore);
-    IndexSearcher searcher = new IndexSearcher(reader);
+    IndexSearcher searcher = newSearcher(reader);
     Query query1 = new TermQuery(new Term("body", "metal"));
     Query query2 = new WildcardQuery(new Term("body", "metal*"));
     Query query3 = new WildcardQuery(new Term("body", "m*tal"));
@@ -193,7 +193,7 @@
     Directory indexStore = getIndexStore("body", new String[]
     {"metal", "metals", "mXtals", "mXtXls"});
     IndexReader reader = DirectoryReader.open(indexStore);
-    IndexSearcher searcher = new IndexSearcher(reader);
+    IndexSearcher searcher = newSearcher(reader);
     Query query1 = new WildcardQuery(new Term("body", "m?tal"));
     Query query2 = new WildcardQuery(new Term("body", "metal?"));
     Query query3 = new WildcardQuery(new Term("body", "metals?"));
@@ -218,7 +218,7 @@
     Directory indexStore = getIndexStore("field", 
         new String[]{"foo*bar", "foo??bar", "fooCDbar", "fooSOMETHINGbar", "foo\\"});
     IndexReader reader = DirectoryReader.open(indexStore);
-    IndexSearcher searcher = new IndexSearcher(reader);
+    IndexSearcher searcher = newSearcher(reader);
 
     // without escape: matches foo??bar, fooCDbar, foo*bar, and fooSOMETHINGbar
     WildcardQuery unescaped = new WildcardQuery(new Term("field", "foo*bar"));
@@ -355,7 +355,7 @@
     iw.close();
     
     IndexReader reader = DirectoryReader.open(dir);
-    IndexSearcher searcher = new IndexSearcher(reader);
+    IndexSearcher searcher = newSearcher(reader);
     
     // test queries that must find all
     for (Query q : matchAll) {
Index: lucene/core/src/test/org/apache/lucene/search/TestConstantScoreQuery.java
===================================================================
--- lucene/core/src/test/org/apache/lucene/search/TestConstantScoreQuery.java	(révision 1466277)
+++ lucene/core/src/test/org/apache/lucene/search/TestConstantScoreQuery.java	(copie de travail)
@@ -95,7 +95,7 @@
 
       reader = writer.getReader();
       writer.close();
-      searcher = newSearcher(reader);
+      searcher = new IndexSearcher(reader);
       
       // set a similarity that does not normalize our boost away
       searcher.setSimilarity(new DefaultSimilarity() {
@@ -145,7 +145,7 @@
     Filter filterB = new CachingWrapperFilter(new QueryWrapperFilter(new TermQuery(new Term("field", "b"))));
     Query query = new ConstantScoreQuery(filterB);
 
-    IndexSearcher s = new IndexSearcher(r);
+    IndexSearcher s = newSearcher(r);
     assertEquals(1, s.search(query, filterB, 1).totalHits); // Query for field:b, Filter field:b
 
     Filter filterA = new CachingWrapperFilter(new QueryWrapperFilter(new TermQuery(new Term("field", "a"))));
Index: lucene/core/src/test/org/apache/lucene/search/TestFilteredSearch.java
===================================================================
--- lucene/core/src/test/org/apache/lucene/search/TestFilteredSearch.java	(révision 1466277)
+++ lucene/core/src/test/org/apache/lucene/search/TestFilteredSearch.java	(copie de travail)
@@ -78,7 +78,7 @@
      
      
       IndexReader reader = DirectoryReader.open(directory);
-      IndexSearcher indexSearcher = new IndexSearcher(reader);
+      IndexSearcher indexSearcher = newSearcher(reader);
       ScoreDoc[] hits = indexSearcher.search(booleanQuery, filter, 1000).scoreDocs;
       assertEquals("Number of matched documents", 1, hits.length);
       reader.close();
Index: lucene/core/src/test/org/apache/lucene/search/payloads/TestPayloadTermQuery.java
===================================================================
--- lucene/core/src/test/org/apache/lucene/search/payloads/TestPayloadTermQuery.java	(révision 1466277)
+++ lucene/core/src/test/org/apache/lucene/search/payloads/TestPayloadTermQuery.java	(copie de travail)
@@ -229,7 +229,7 @@
             new MaxPayloadFunction(), false);
 
     IndexReader reader = DirectoryReader.open(directory);
-    IndexSearcher theSearcher = new IndexSearcher(reader);
+    IndexSearcher theSearcher = newSearcher(reader);
     theSearcher.setSimilarity(new FullSimilarity());
     TopDocs hits = searcher.search(query, null, 100);
     assertTrue("hits is null and it shouldn't be", hits != null);
Index: lucene/core/src/test/org/apache/lucene/search/TestBooleanScorer.java
===================================================================
--- lucene/core/src/test/org/apache/lucene/search/TestBooleanScorer.java	(révision 1466277)
+++ lucene/core/src/test/org/apache/lucene/search/TestBooleanScorer.java	(copie de travail)
@@ -28,6 +28,7 @@
 import org.apache.lucene.index.IndexReader;
 import org.apache.lucene.index.RandomIndexWriter;
 import org.apache.lucene.index.Term;
+import org.apache.lucene.search.AssertingIndexSearcher.AssertingScorer;
 import org.apache.lucene.search.BooleanQuery.BooleanWeight;
 import org.apache.lucene.store.Directory;
 import org.apache.lucene.util.LuceneTestCase;
@@ -152,13 +153,12 @@
                             
     final int[] count = new int[1];
     s.search(q, new Collector() {
-      private Scorer scorer;
     
       @Override
       public void setScorer(Scorer scorer) {
         // Make sure we got BooleanScorer:
-        this.scorer = scorer;
-        assertEquals("Scorer is implemented by wrong class", BooleanScorer.class.getName() + "$BucketScorer", scorer.getClass().getName());
+        final Class<?> clazz = scorer instanceof AssertingScorer ? ((AssertingScorer) scorer).getIn().getClass() : scorer.getClass();
+        assertEquals("Scorer is implemented by wrong class", BooleanScorer.class.getName() + "$BucketScorer", clazz.getName());
       }
       
       @Override
Index: lucene/core/src/java/org/apache/lucene/search/Scorer.java
===================================================================
--- lucene/core/src/java/org/apache/lucene/search/Scorer.java	(révision 1466277)
+++ lucene/core/src/java/org/apache/lucene/search/Scorer.java	(copie de travail)
@@ -58,6 +58,7 @@
    * @param collector The collector to which all matching documents are passed.
    */
   public void score(Collector collector) throws IOException {
+    assert docID() == -1 || docID() == NO_MORE_DOCS; // not started
     collector.setScorer(this);
     int doc;
     while ((doc = nextDoc()) != NO_MORE_DOCS) {
@@ -80,11 +81,11 @@
    * @return true if more matching documents may remain.
    */
   public boolean score(Collector collector, int max, int firstDocID) throws IOException {
+    assert docID() == firstDocID;
     collector.setScorer(this);
-    int doc = firstDocID;
-    while (doc < max) {
+    int doc;
+    for (doc = firstDocID; doc < max; doc = nextDoc()) {
       collector.collect(doc);
-      doc = nextDoc();
     }
     return doc != NO_MORE_DOCS;
   }
Index: lucene/core/src/java/org/apache/lucene/search/FilteredQuery.java
===================================================================
--- lucene/core/src/java/org/apache/lucene/search/FilteredQuery.java	(révision 1466277)
+++ lucene/core/src/java/org/apache/lucene/search/FilteredQuery.java	(copie de travail)
@@ -240,11 +240,11 @@
     // optimization: we are topScorer and collect directly using short-circuited algo
     @Override
     public final void score(Collector collector) throws IOException {
-      int primDoc = primaryNext();
-      int secDoc = secondary.advance(primDoc);
       // the normalization trick already applies the boost of this query,
       // so we can use the wrapped scorer directly:
       collector.setScorer(scorer);
+      int primDoc = primaryNext();
+      int secDoc = secondary.advance(primDoc);
       for (;;) {
         if (primDoc == secDoc) {
           // Check if scorer has exhausted, only before collecting.
Index: lucene/join/src/test/org/apache/lucene/search/join/TestBlockJoin.java
===================================================================
--- lucene/join/src/test/org/apache/lucene/search/join/TestBlockJoin.java	(révision 1466277)
+++ lucene/join/src/test/org/apache/lucene/search/join/TestBlockJoin.java	(copie de travail)
@@ -500,7 +500,7 @@
 
     final IndexSearcher s = newSearcher(r);
 
-    final IndexSearcher joinS = newSearcher(joinR);
+    final IndexSearcher joinS = new IndexSearcher(joinR);
 
     final Filter parentsFilter = new CachingWrapperFilter(new QueryWrapperFilter(new TermQuery(new Term("isParent", "x"))));
 
@@ -1074,7 +1074,7 @@
 
     IndexReader r = w.getReader();
     w.close();
-    IndexSearcher s = newSearcher(r);
+    IndexSearcher s = new IndexSearcher(r);
 
     // Create a filter that defines "parent" documents in the index - in this case resumes
     Filter parentsFilter = new CachingWrapperFilter(new QueryWrapperFilter(new TermQuery(new Term("docType", "resume"))));
Index: lucene/join/src/java/org/apache/lucene/search/join/TermsIncludingScoreQuery.java
===================================================================
--- lucene/join/src/java/org/apache/lucene/search/join/TermsIncludingScoreQuery.java	(révision 1466277)
+++ lucene/join/src/java/org/apache/lucene/search/join/TermsIncludingScoreQuery.java	(copie de travail)
@@ -23,6 +23,7 @@
 import org.apache.lucene.index.Term;
 import org.apache.lucene.index.Terms;
 import org.apache.lucene.index.TermsEnum;
+import org.apache.lucene.search.Collector;
 import org.apache.lucene.search.ComplexExplanation;
 import org.apache.lucene.search.DocIdSetIterator;
 import org.apache.lucene.search.Explanation;
@@ -201,6 +202,23 @@
     }
 
     @Override
+    public void score(Collector collector) throws IOException {
+      score(collector, NO_MORE_DOCS, nextDocOutOfOrder());
+    }
+
+    @Override
+    public boolean score(Collector collector, int max, int firstDocID)
+        throws IOException {
+      assert collector.acceptsDocsOutOfOrder();
+      collector.setScorer(this);
+      int doc;
+      for (doc = firstDocID; doc < max; doc = nextDocOutOfOrder()) {
+        collector.collect(doc);
+      }
+      return doc != NO_MORE_DOCS;
+    }
+
+    @Override
     public float score() throws IOException {
       return scores[ords[scoreUpto]];
     }
@@ -214,8 +232,7 @@
       return docsEnum != null ? docsEnum.docID() : DocIdSetIterator.NO_MORE_DOCS;
     }
 
-    @Override
-    public int nextDoc() throws IOException {
+    int nextDocOutOfOrder() throws IOException {
       if (docsEnum != null) {
         int docId = docsEnum.nextDoc();
         if (docId == DocIdSetIterator.NO_MORE_DOCS) {
@@ -240,6 +257,11 @@
     }
 
     @Override
+    public int nextDoc() throws IOException {
+      throw new UnsupportedOperationException("nextDoc() isn't supported because doc ids are emitted out of order");
+    }
+
+    @Override
     public int advance(int target) throws IOException {
       throw new UnsupportedOperationException("advance() isn't supported because doc ids are emitted out of order");
     }
@@ -247,7 +269,7 @@
     private int advanceForExplainOnly(int target) throws IOException {
       int docId;
       do {
-        docId = nextDoc();
+        docId = nextDocOutOfOrder();
         if (docId < target) {
           int tempDocId = docsEnum.advance(target);
           if (tempDocId == target) {
@@ -286,7 +308,7 @@
     }
 
     @Override
-    public int nextDoc() throws IOException {
+    int nextDocOutOfOrder() throws IOException {
       if (docsEnum != null) {
         int docId;
         do {