Index: lucene/src/test/org/apache/lucene/search/TestFuzzyQuery2.java
===================================================================
--- lucene/src/test/org/apache/lucene/search/TestFuzzyQuery2.java	(revision 1032566)
+++ lucene/src/test/org/apache/lucene/search/TestFuzzyQuery2.java	(working copy)
@@ -91,7 +91,7 @@
     }   
     
     IndexReader r = writer.getReader();
-    IndexSearcher searcher = new IndexSearcher(r);
+    Searcher searcher = newSearcher(r);
     writer.close();
     String line;
     while ((line = reader.readLine()) != null) {
Index: lucene/src/test/org/apache/lucene/search/TestNot.java
===================================================================
--- lucene/src/test/org/apache/lucene/search/TestNot.java	(revision 1032566)
+++ lucene/src/test/org/apache/lucene/search/TestNot.java	(working copy)
@@ -44,7 +44,7 @@
     writer.addDocument(d1);
     IndexReader reader = writer.getReader();
 
-    Searcher searcher = new IndexSearcher(reader);
+    Searcher searcher = newSearcher(reader);
       QueryParser parser = new QueryParser(TEST_VERSION_CURRENT, "field", new MockAnalyzer());
     Query query = parser.parse("a NOT b");
     //System.out.println(query);
Index: lucene/src/test/org/apache/lucene/search/TestTimeLimitingCollector.java
===================================================================
--- lucene/src/test/org/apache/lucene/search/TestTimeLimitingCollector.java	(revision 1032566)
+++ lucene/src/test/org/apache/lucene/search/TestTimeLimitingCollector.java	(working copy)
@@ -79,7 +79,7 @@
     }
     reader = iw.getReader();
     iw.close();
-    searcher = new IndexSearcher(reader);
+    searcher = newSearcher(reader);
 
     String qtxt = "one";
     // start from 1, so that the 0th doc never matches
Index: lucene/src/test/org/apache/lucene/search/TestCachingWrapperFilter.java
===================================================================
--- lucene/src/test/org/apache/lucene/search/TestCachingWrapperFilter.java	(revision 1032566)
+++ lucene/src/test/org/apache/lucene/search/TestCachingWrapperFilter.java	(working copy)
@@ -160,7 +160,7 @@
     // but we use .reopen on this reader below and expect to
     // (must) get an NRT reader:
     IndexReader reader = IndexReader.open(writer.w);
-    IndexSearcher searcher = new IndexSearcher(reader);
+    Searcher searcher = newSearcher(reader);
 
     // add a doc, refresh the reader, and check that its there
     Document doc = new Document();
@@ -168,7 +168,7 @@
     writer.addDocument(doc);
 
     reader = refreshReader(reader);
-    searcher = new IndexSearcher(reader);
+    searcher = newSearcher(reader);
 
     TopDocs docs = searcher.search(new MatchAllDocsQuery(), 1);
     assertEquals("Should find a hit...", 1, docs.totalHits);
@@ -188,7 +188,7 @@
     writer.deleteDocuments(new Term("id", "1"));
 
     reader = refreshReader(reader);
-    searcher = new IndexSearcher(reader);
+    searcher = newSearcher(reader);
 
     docs = searcher.search(new MatchAllDocsQuery(), filter, 1);
     assertEquals("[query + filter] Should *not* find a hit...", 0, docs.totalHits);
@@ -203,7 +203,7 @@
     writer.addDocument(doc);
 
     reader = refreshReader(reader);
-    searcher = new IndexSearcher(reader);
+    searcher = newSearcher(reader);
         
     docs = searcher.search(new MatchAllDocsQuery(), filter, 1);
 
@@ -222,7 +222,7 @@
     // that had no change to deletions
     reader = refreshReader(reader);
     assertTrue(reader != oldReader);
-    searcher = new IndexSearcher(reader);
+    searcher = newSearcher(reader);
     int missCount = filter.missCount;
     docs = searcher.search(constantScore, 1);
     assertEquals("[just filter] Should find a hit...", 1, docs.totalHits);
@@ -232,7 +232,7 @@
     writer.deleteDocuments(new Term("id", "1"));
 
     reader = refreshReader(reader);
-    searcher = new IndexSearcher(reader);
+    searcher = newSearcher(reader);
 
     missCount = filter.missCount;
     docs = searcher.search(new MatchAllDocsQuery(), filter, 1);
@@ -247,7 +247,7 @@
 
     writer.addDocument(doc);
     reader = refreshReader(reader);
-    searcher = new IndexSearcher(reader);
+    searcher = newSearcher(reader);
         
     docs = searcher.search(new MatchAllDocsQuery(), filter, 1);
     assertEquals("[query + filter] Should find a hit...", 1, docs.totalHits);
@@ -259,7 +259,7 @@
     writer.deleteDocuments(new Term("id", "1"));
 
     reader = refreshReader(reader);
-    searcher = new IndexSearcher(reader);
+    searcher = newSearcher(reader);
 
     docs = searcher.search(new MatchAllDocsQuery(), filter, 1);
     assertEquals("[query + filter] Should *not* find a hit...", 0, docs.totalHits);
Index: lucene/src/test/org/apache/lucene/search/TestPrefixFilter.java
===================================================================
--- lucene/src/test/org/apache/lucene/search/TestPrefixFilter.java	(revision 1032566)
+++ lucene/src/test/org/apache/lucene/search/TestPrefixFilter.java	(working copy)
@@ -48,7 +48,7 @@
     // PrefixFilter combined with ConstantScoreQuery
     PrefixFilter filter = new PrefixFilter(new Term("category", "/Computers"));
     Query query = new ConstantScoreQuery(filter);
-    IndexSearcher searcher = new IndexSearcher(reader);
+    Searcher searcher = newSearcher(reader);
     ScoreDoc[] hits = searcher.search(query, null, 1000).scoreDocs;
     assertEquals(4, hits.length);
 
Index: lucene/src/test/org/apache/lucene/search/TestAutomatonQueryUnicode.java
===================================================================
--- lucene/src/test/org/apache/lucene/search/TestAutomatonQueryUnicode.java	(revision 1032566)
+++ lucene/src/test/org/apache/lucene/search/TestAutomatonQueryUnicode.java	(working copy)
@@ -36,7 +36,7 @@
  */
 public class TestAutomatonQueryUnicode extends LuceneTestCase {
   private IndexReader reader;
-  private IndexSearcher searcher;
+  private Searcher searcher;
   private Directory directory;
 
   private final String FN = "field";
@@ -81,7 +81,7 @@
     field.setValue("\uFFFD\uFFFD");
     writer.addDocument(doc);
     reader = writer.getReader();
-    searcher = new IndexSearcher(reader);
+    searcher = newSearcher(reader);
     writer.close();
   }
 
Index: lucene/src/test/org/apache/lucene/search/TestBooleanQuery.java
===================================================================
--- lucene/src/test/org/apache/lucene/search/TestBooleanQuery.java	(revision 1032566)
+++ lucene/src/test/org/apache/lucene/search/TestBooleanQuery.java	(working copy)
@@ -65,7 +65,7 @@
     w.addDocument(doc);
 
     IndexReader r = w.getReader();
-    IndexSearcher s = new IndexSearcher(r);
+    Searcher s = newSearcher(r);
     BooleanQuery q = new BooleanQuery();
     q.add(new TermQuery(new Term("field", "a")), BooleanClause.Occur.SHOULD);
 
Index: lucene/src/test/org/apache/lucene/search/TestPhraseQuery.java
===================================================================
--- lucene/src/test/org/apache/lucene/search/TestPhraseQuery.java	(revision 1032566)
+++ lucene/src/test/org/apache/lucene/search/TestPhraseQuery.java	(working copy)
@@ -46,7 +46,7 @@
   /** threshold for comparing floats */
   public static final float SCORE_COMP_THRESH = 1e-6f;
   
-  private IndexSearcher searcher;
+  private Searcher searcher;
   private IndexReader reader;
   private PhraseQuery query;
   private Directory directory;
@@ -87,7 +87,7 @@
     reader = writer.getReader();
     writer.close();
 
-    searcher = new IndexSearcher(reader);
+    searcher = newSearcher(reader);
     query = new PhraseQuery();
   }
 
@@ -222,7 +222,7 @@
     IndexReader reader = writer.getReader();
     writer.close();
 
-    IndexSearcher searcher = new IndexSearcher(reader);
+    Searcher searcher = newSearcher(reader);
 
     // valid exact phrase query
     PhraseQuery query = new PhraseQuery();
@@ -263,7 +263,7 @@
     IndexReader reader = writer.getReader();
     writer.close();
     
-    IndexSearcher searcher = new IndexSearcher(reader);
+    Searcher searcher = newSearcher(reader);
     
     PhraseQuery phraseQuery = new PhraseQuery();
     phraseQuery.add(new Term("source", "marketing"));
@@ -302,7 +302,7 @@
     reader = writer.getReader();
     writer.close();
     
-    searcher = new IndexSearcher(reader);
+    searcher = newSearcher(reader);
     
     termQuery = new TermQuery(new Term("contents","woo"));
     phraseQuery = new PhraseQuery();
@@ -353,7 +353,7 @@
     IndexReader reader = writer.getReader();
     writer.close();
 
-    Searcher searcher = new IndexSearcher(reader);
+    Searcher searcher = newSearcher(reader);
     PhraseQuery query = new PhraseQuery();
     query.add(new Term("field", "firstname"));
     query.add(new Term("field", "lastname"));
@@ -591,7 +591,7 @@
   public void testRewrite() throws IOException {
     PhraseQuery pq = new PhraseQuery();
     pq.add(new Term("foo", "bar"));
-    Query rewritten = pq.rewrite(searcher.getIndexReader());
+    Query rewritten = pq.rewrite(reader);
     assertTrue(rewritten instanceof TermQuery);
   }
 
@@ -650,7 +650,7 @@
     }
 
     IndexReader reader = w.getReader();
-    IndexSearcher s = new IndexSearcher(reader);
+    Searcher s = newSearcher(reader);
     w.close();
 
     // now search
Index: lucene/src/test/org/apache/lucene/search/TestTermRangeQuery.java
===================================================================
--- lucene/src/test/org/apache/lucene/search/TestTermRangeQuery.java	(revision 1032566)
+++ lucene/src/test/org/apache/lucene/search/TestTermRangeQuery.java	(working copy)
@@ -19,6 +19,7 @@
 
 import org.apache.lucene.document.Document;
 import org.apache.lucene.document.Field;
+import org.apache.lucene.index.IndexReader;
 import org.apache.lucene.index.IndexWriter;
 import org.apache.lucene.index.IndexWriterConfig.OpenMode;
 import org.apache.lucene.store.Directory;
@@ -59,63 +60,77 @@
   public void testExclusive() throws Exception {
     Query query = new TermRangeQuery("content", "A", "C", false, false);
     initializeIndex(new String[] {"A", "B", "C", "D"});
-    IndexSearcher searcher = new IndexSearcher(dir, true);
+    IndexReader reader = IndexReader.open(dir);
+    Searcher searcher = newSearcher(reader);
     ScoreDoc[] hits = searcher.search(query, null, 1000).scoreDocs;
     assertEquals("A,B,C,D, only B in range", 1, hits.length);
     searcher.close();
+    reader.close();
 
     initializeIndex(new String[] {"A", "B", "D"});
-    searcher = new IndexSearcher(dir, true);
+    reader = IndexReader.open(dir);
+    searcher = newSearcher(reader);
     hits = searcher.search(query, null, 1000).scoreDocs;
     assertEquals("A,B,D, only B in range", 1, hits.length);
     searcher.close();
+    reader.close();
 
     addDoc("C");
-    searcher = new IndexSearcher(dir, true);
+    reader = IndexReader.open(dir);
+    searcher = newSearcher(reader);
     hits = searcher.search(query, null, 1000).scoreDocs;
     assertEquals("C added, still only B in range", 1, hits.length);
     searcher.close();
+    reader.close();
   }
   
   public void testInclusive() throws Exception {
     Query query = new TermRangeQuery("content", "A", "C", true, true);
 
     initializeIndex(new String[]{"A", "B", "C", "D"});
-    IndexSearcher searcher = new IndexSearcher(dir, true);
+    IndexReader reader = IndexReader.open(dir);
+    Searcher searcher = newSearcher(reader);
     ScoreDoc[] hits = searcher.search(query, null, 1000).scoreDocs;
     assertEquals("A,B,C,D - A,B,C in range", 3, hits.length);
     searcher.close();
+    reader.close();
 
     initializeIndex(new String[]{"A", "B", "D"});
-    searcher = new IndexSearcher(dir, true);
+    reader = IndexReader.open(dir);
+    searcher = newSearcher(reader);
     hits = searcher.search(query, null, 1000).scoreDocs;
     assertEquals("A,B,D - A and B in range", 2, hits.length);
     searcher.close();
+    reader.close();
 
     addDoc("C");
-    searcher = new IndexSearcher(dir, true);
+    reader = IndexReader.open(dir);
+    searcher = newSearcher(reader);
     hits = searcher.search(query, null, 1000).scoreDocs;
     assertEquals("C added - A, B, C in range", 3, hits.length);
     searcher.close();
+    reader.close();
   }
   
   public void testAllDocs() throws Exception {
     initializeIndex(new String[]{"A", "B", "C", "D"});
-    IndexSearcher searcher = new IndexSearcher(dir, true);
+    IndexReader reader = IndexReader.open(dir);
+    Searcher searcher = newSearcher(reader);
     TermRangeQuery query = new TermRangeQuery("content", null, null, true, true);
-    assertFalse(query.getTermsEnum(searcher.getIndexReader()) instanceof TermRangeTermsEnum);
+    assertFalse(query.getTermsEnum(reader) instanceof TermRangeTermsEnum);
     assertEquals(4, searcher.search(query, null, 1000).scoreDocs.length);
     query = new TermRangeQuery("content", null, null, false, false);
-    assertFalse(query.getTermsEnum(searcher.getIndexReader()) instanceof TermRangeTermsEnum);
+    assertFalse(query.getTermsEnum(reader) instanceof TermRangeTermsEnum);
     assertEquals(4, searcher.search(query, null, 1000).scoreDocs.length);
     query = new TermRangeQuery("content", "", null, true, false);
-    assertFalse(query.getTermsEnum(searcher.getIndexReader()) instanceof TermRangeTermsEnum);
+    assertFalse(query.getTermsEnum(reader) instanceof TermRangeTermsEnum);
     assertEquals(4, searcher.search(query, null, 1000).scoreDocs.length);
     // and now anothe one
     query = new TermRangeQuery("content", "B", null, true, false);
-    assertTrue(query.getTermsEnum(searcher.getIndexReader()) instanceof TermRangeTermsEnum);
+    assertTrue(query.getTermsEnum(reader) instanceof TermRangeTermsEnum);
     assertEquals(3, searcher.search(query, null, 1000).scoreDocs.length);
     searcher.close();
+    reader.close();
   }
 
   /** This test should not be here, but it tests the fuzzy query rewrite mode (TOP_TERMS_SCORING_BOOLEAN_REWRITE)
@@ -123,7 +138,8 @@
   public void testTopTermsRewrite() throws Exception {
     initializeIndex(new String[]{"A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K"});
 
-    IndexSearcher searcher = new IndexSearcher(dir, true);
+    IndexReader reader = IndexReader.open(dir);
+    Searcher searcher = newSearcher(reader);
     TermRangeQuery query = new TermRangeQuery("content", "B", "J", true, true);
     checkBooleanTerms(searcher, query, "B", "C", "D", "E", "F", "G", "H", "I", "J");
     
@@ -135,6 +151,7 @@
       BooleanQuery.setMaxClauseCount(savedClauseCount);
     }
     searcher.close();
+    reader.close();
   }
   
   private void checkBooleanTerms(Searcher searcher, TermRangeQuery query, String... terms) throws IOException {
@@ -201,44 +218,56 @@
   public void testExclusiveCollating() throws Exception {
     Query query = new TermRangeQuery("content", "A", "C", false, false, Collator.getInstance(Locale.ENGLISH));
     initializeIndex(new String[] {"A", "B", "C", "D"});
-    IndexSearcher searcher = new IndexSearcher(dir, true);
+    IndexReader reader = IndexReader.open(dir);
+    Searcher searcher = newSearcher(reader);
     ScoreDoc[] hits = searcher.search(query, null, 1000).scoreDocs;
     assertEquals("A,B,C,D, only B in range", 1, hits.length);
     searcher.close();
+    reader.close();
 
     initializeIndex(new String[] {"A", "B", "D"});
-    searcher = new IndexSearcher(dir, true);
+    reader = IndexReader.open(dir);
+    searcher = newSearcher(reader);
     hits = searcher.search(query, null, 1000).scoreDocs;
     assertEquals("A,B,D, only B in range", 1, hits.length);
     searcher.close();
+    reader.close();
 
     addDoc("C");
-    searcher = new IndexSearcher(dir, true);
+    reader = IndexReader.open(dir);
+    searcher = newSearcher(reader);
     hits = searcher.search(query, null, 1000).scoreDocs;
     assertEquals("C added, still only B in range", 1, hits.length);
     searcher.close();
+    reader.close();
   }
 
   public void testInclusiveCollating() throws Exception {
     Query query = new TermRangeQuery("content", "A", "C",true, true, Collator.getInstance(Locale.ENGLISH));
 
     initializeIndex(new String[]{"A", "B", "C", "D"});
-    IndexSearcher searcher = new IndexSearcher(dir, true);
+    IndexReader reader = IndexReader.open(dir);
+    Searcher searcher = newSearcher(reader);
     ScoreDoc[] hits = searcher.search(query, null, 1000).scoreDocs;
     assertEquals("A,B,C,D - A,B,C in range", 3, hits.length);
     searcher.close();
+    reader.close();
 
     initializeIndex(new String[]{"A", "B", "D"});
-    searcher = new IndexSearcher(dir, true);
+    reader = IndexReader.open(dir);
+    searcher = newSearcher(reader);
     hits = searcher.search(query, null, 1000).scoreDocs;
     assertEquals("A,B,D - A and B in range", 2, hits.length);
     searcher.close();
+    reader.close();
 
     addDoc("C");
-    searcher = new IndexSearcher(dir, true);
+    reader = IndexReader.open(dir);
+    searcher = newSearcher(reader);
     hits = searcher.search(query, null, 1000).scoreDocs;
     assertEquals("C added - A, B, C in range", 3, hits.length);
     searcher.close();
+    reader.close();
   }
 
   public void testFarsi() throws Exception {
@@ -252,7 +281,8 @@
     // index Term below should NOT be returned by a TermRangeQuery with a Farsi
     // Collator (or an Arabic one for the case when Farsi is not supported).
     initializeIndex(new String[]{ "\u0633\u0627\u0628"});
-    IndexSearcher searcher = new IndexSearcher(dir, true);
+    IndexReader reader = IndexReader.open(dir);
+    Searcher searcher = newSearcher(reader);
     ScoreDoc[] hits = searcher.search(query, null, 1000).scoreDocs;
     assertEquals("The index Term should not be included.", 0, hits.length);
 
@@ -260,6 +290,7 @@
     hits = searcher.search(query, null, 1000).scoreDocs;
     assertEquals("The index Term should be included.", 1, hits.length);
     searcher.close();
+    reader.close();
   }
   
   public void testDanish() throws Exception {
@@ -272,7 +303,8 @@
     // Unicode order would not include "H\u00C5T" in [ "H\u00D8T", "MAND" ],
     // but Danish collation does.
     initializeIndex(words);
-    IndexSearcher searcher = new IndexSearcher(dir, true);
+    IndexReader reader = IndexReader.open(dir);
+    Searcher searcher = newSearcher(reader);
     ScoreDoc[] hits = searcher.search(query, null, 1000).scoreDocs;
     assertEquals("The index Term should be included.", 1, hits.length);
 
@@ -280,6 +312,7 @@
     hits = searcher.search(query, null, 1000).scoreDocs;
     assertEquals("The index Term should not be included.", 0, hits.length);
     searcher.close();
+    reader.close();
   }
 
   private static class SingleCharAnalyzer extends Analyzer {
@@ -369,7 +402,8 @@
     Query query = new TermRangeQuery("content", null, "C",
                                  false, false);
     initializeIndex(new String[] {"A", "B", "", "C", "D"}, analyzer);
-    IndexSearcher searcher = new IndexSearcher(dir, true);
+    IndexReader reader = IndexReader.open(dir);
+    Searcher 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);
@@ -377,22 +411,29 @@
     //assertEquals("A,B,<empty string>,C,D => A, B & <empty string> are in range", 2, hits.length());
 
     searcher.close();
+    reader.close();
+    
     initializeIndex(new String[] {"A", "B", "", "D"}, analyzer);
-    searcher = new IndexSearcher(dir, true);
+    reader = IndexReader.open(dir);
+    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);
     // until Lucene-38 is fixed, use this assert:
     //assertEquals("A,B,<empty string>,D => A, B & <empty string> are in range", 2, hits.length());
     searcher.close();
+    reader.close();
+    
     addDoc("C");
-    searcher = new IndexSearcher(dir, true);
+    reader = IndexReader.open(dir);
+    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);
     // until Lucene-38 is fixed, use this assert
     //assertEquals("C added, still A, B & <empty string> are in range", 2, hits.length());
     searcher.close();
+    reader.close();
   }
 
   // LUCENE-38
@@ -401,28 +442,36 @@
     Analyzer analyzer = new SingleCharAnalyzer();
     Query query = new TermRangeQuery("content", null, "C", true, true);
     initializeIndex(new String[]{"A", "B", "","C", "D"}, analyzer);
-    IndexSearcher searcher = new IndexSearcher(dir, true);
+    IndexReader reader = IndexReader.open(dir);
+    Searcher 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);
     // until Lucene-38 is fixed, use this assert
     //assertEquals("A,B,<empty string>,C,D => A,B,<empty string>,C in range", 3, hits.length());
     searcher.close();
+    reader.close();
+    
     initializeIndex(new String[]{"A", "B", "", "D"}, analyzer);
-    searcher = new IndexSearcher(dir, true);
+    reader = IndexReader.open(dir);
+    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);
     // until Lucene-38 is fixed, use this assert
     //assertEquals("A,B,<empty string>,D => A, B and <empty string> in range", 2, hits.length());
     searcher.close();
+    reader.close();
+    
     addDoc("C");
-    searcher = new IndexSearcher(dir, true);
+    reader = IndexReader.open(dir);
+    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);
     // until Lucene-38 is fixed, use this assert
     //assertEquals("C added => A,B,<empty string>,C in range", 3, hits.length());
-     searcher.close();
+    searcher.close();
+    reader.close();
   }
 }
Index: lucene/src/test/org/apache/lucene/search/TestBooleanMinShouldMatch.java
===================================================================
--- lucene/src/test/org/apache/lucene/search/TestBooleanMinShouldMatch.java	(revision 1032566)
+++ lucene/src/test/org/apache/lucene/search/TestBooleanMinShouldMatch.java	(working copy)
@@ -34,7 +34,7 @@
 
     private Directory index;
     private IndexReader r;
-    private IndexSearcher s;
+    private Searcher s;
 
     @Override
     public void setUp() throws Exception {
@@ -65,7 +65,7 @@
         }
 
         r = w.getReader();
-        s = new IndexSearcher(r);
+        s = newSearcher(r);
         w.close();
 //System.out.println("Set up " + getName());
     }
Index: lucene/src/test/org/apache/lucene/search/TestBooleanOr.java
===================================================================
--- lucene/src/test/org/apache/lucene/search/TestBooleanOr.java	(revision 1032566)
+++ lucene/src/test/org/apache/lucene/search/TestBooleanOr.java	(working copy)
@@ -26,7 +26,6 @@
 import org.apache.lucene.index.Term;
 import org.apache.lucene.search.BooleanClause;
 import org.apache.lucene.search.BooleanQuery;
-import org.apache.lucene.search.IndexSearcher;
 import org.apache.lucene.search.Query;
 import org.apache.lucene.search.TermQuery;
 import org.apache.lucene.store.Directory;
@@ -41,7 +40,7 @@
   private TermQuery c1 = new TermQuery(new Term(FIELD_C, "production"));
   private TermQuery c2 = new TermQuery(new Term(FIELD_C, "optimize"));
 
-  private IndexSearcher searcher = null;
+  private Searcher searcher = null;
   private Directory dir;
   private IndexReader reader;
   
@@ -159,7 +158,7 @@
 
     reader = writer.getReader();
     //
-    searcher = new IndexSearcher(reader);
+    searcher = newSearcher(reader);
     writer.close();
   }
 
Index: lucene/src/test/org/apache/lucene/search/TestDateSort.java
===================================================================
--- lucene/src/test/org/apache/lucene/search/TestDateSort.java	(revision 1032566)
+++ lucene/src/test/org/apache/lucene/search/TestDateSort.java	(working copy)
@@ -28,7 +28,6 @@
 import org.apache.lucene.index.IndexReader;
 import org.apache.lucene.index.RandomIndexWriter;
 import org.apache.lucene.queryParser.QueryParser;
-import org.apache.lucene.search.IndexSearcher;
 import org.apache.lucene.search.Query;
 import org.apache.lucene.search.Sort;
 import org.apache.lucene.search.SortField;
@@ -78,7 +77,7 @@
   }
 
   public void testReverseDateSort() throws Exception {
-    IndexSearcher searcher = new IndexSearcher(reader);
+    Searcher searcher = newSearcher(reader);
 
     Sort sort = new Sort(new SortField(DATE_TIME_FIELD, SortField.STRING, true));
 
Index: lucene/src/test/org/apache/lucene/search/TestMultiTermConstantScore.java
===================================================================
--- lucene/src/test/org/apache/lucene/search/TestMultiTermConstantScore.java	(revision 1032566)
+++ lucene/src/test/org/apache/lucene/search/TestMultiTermConstantScore.java	(working copy)
@@ -152,7 +152,7 @@
   public void testEqualScores() throws IOException {
     // NOTE: uses index build in *this* setUp
 
-    IndexSearcher search = new IndexSearcher(reader);
+    Searcher search = newSearcher(reader);
 
     ScoreDoc[] result;
 
@@ -181,7 +181,7 @@
   public void testBoost() throws IOException {
     // NOTE: uses index build in *this* setUp
 
-    IndexSearcher search = new IndexSearcher(reader);
+    Searcher search = newSearcher(reader);
 
     // test for correct application of query normalization
     // must use a non score normalizing method for this.
@@ -253,7 +253,7 @@
   public void testBooleanOrderUnAffected() throws IOException {
     // NOTE: uses index build in *this* setUp
 
-    IndexSearcher search = new IndexSearcher(reader);
+    Searcher search = newSearcher(reader);
 
     // first do a regular TermRangeQuery which uses term expansion so
     // docs with more terms in range get higher scores
@@ -285,7 +285,7 @@
     // NOTE: uses index build in *super* setUp
 
     IndexReader reader = signedIndexReader;
-    IndexSearcher search = new IndexSearcher(reader);
+    Searcher search = newSearcher(reader);
 
     int medId = ((maxId - minId) / 2);
 
@@ -413,7 +413,7 @@
     // NOTE: uses index build in *super* setUp
 
     IndexReader reader = signedIndexReader;
-    IndexSearcher search = new IndexSearcher(reader);
+    Searcher search = newSearcher(reader);
 
     int medId = ((maxId - minId) / 2);
 
@@ -497,7 +497,7 @@
     // NOTE: uses index build in *super* setUp
 
     IndexReader reader = signedIndexReader;
-    IndexSearcher search = new IndexSearcher(reader);
+    Searcher search = newSearcher(reader);
 
     String minRP = pad(signedIndexDir.minR);
     String maxRP = pad(signedIndexDir.maxR);
@@ -561,7 +561,7 @@
 
     // using the unsigned index because collation seems to ignore hyphens
     IndexReader reader = unsignedIndexReader;
-    IndexSearcher search = new IndexSearcher(reader);
+    Searcher search = newSearcher(reader);
 
     String minRP = pad(unsignedIndexDir.minR);
     String maxRP = pad(unsignedIndexDir.maxR);
@@ -637,7 +637,7 @@
     IndexReader reader = writer.getReader();
     writer.close();
 
-    IndexSearcher search = new IndexSearcher(reader);
+    Searcher search = newSearcher(reader);
 
     // Neither Java 1.4.2 nor 1.5.0 has Farsi Locale collation available in
     // RuleBasedCollator. However, the Arabic Locale seems to order the Farsi
@@ -682,7 +682,7 @@
     IndexReader reader = writer.getReader();
     writer.close();
 
-    IndexSearcher search = new IndexSearcher(reader);
+    Searcher search = newSearcher(reader);
 
     Collator c = Collator.getInstance(new Locale("da", "dk"));
 
Index: lucene/src/test/org/apache/lucene/search/TestWildcardRandom.java
===================================================================
--- lucene/src/test/org/apache/lucene/search/TestWildcardRandom.java	(revision 1032566)
+++ lucene/src/test/org/apache/lucene/search/TestWildcardRandom.java	(working copy)
@@ -61,7 +61,7 @@
     }
     
     reader = writer.getReader();
-    searcher = new IndexSearcher(reader);
+    searcher = newSearcher(reader);
     writer.close();
   }
   
Index: lucene/src/test/org/apache/lucene/search/TestMultiTermQueryRewrites.java
===================================================================
--- lucene/src/test/org/apache/lucene/search/TestMultiTermQueryRewrites.java	(revision 1032566)
+++ lucene/src/test/org/apache/lucene/search/TestMultiTermQueryRewrites.java	(working copy)
@@ -60,10 +60,12 @@
     writer.close(); swriter1.close(); swriter2.close();
     
     reader = IndexReader.open(dir, true);
+    // TODO: newSearcher(reader)
     searcher = new IndexSearcher(reader);
     multiReader = new MultiReader(new IndexReader[] {
       IndexReader.open(sdir1, true), IndexReader.open(sdir2, true) 
     }, true);
+    // TODO: newSearcher(reader)
     multiSearcher = new IndexSearcher(multiReader);
   }
 
Index: lucene/src/test/org/apache/lucene/search/TestBooleanScorer.java
===================================================================
--- lucene/src/test/org/apache/lucene/search/TestBooleanScorer.java	(revision 1032566)
+++ lucene/src/test/org/apache/lucene/search/TestBooleanScorer.java	(working copy)
@@ -55,7 +55,7 @@
     query.add(booleanQuery1, BooleanClause.Occur.MUST);
     query.add(new TermQuery(new Term(FIELD, "9")), BooleanClause.Occur.MUST_NOT);
 
-    IndexSearcher indexSearcher = new IndexSearcher(ir);
+    Searcher indexSearcher = newSearcher(ir);
     ScoreDoc[] hits = indexSearcher.search(query, null, 1000).scoreDocs;
     assertEquals("Number of matched documents", 2, hits.length);
     ir.close();
Index: lucene/src/test/org/apache/lucene/search/TestDocIdSet.java
===================================================================
--- lucene/src/test/org/apache/lucene/search/TestDocIdSet.java	(revision 1032566)
+++ lucene/src/test/org/apache/lucene/search/TestDocIdSet.java	(working copy)
@@ -109,7 +109,7 @@
     writer.close();
     
     // First verify the document is searchable.
-    IndexSearcher searcher = new IndexSearcher(reader);
+    Searcher searcher = newSearcher(reader);
     Assert.assertEquals(1, searcher.search(new MatchAllDocsQuery(), 10).totalHits);
     
     // Now search w/ a Filter which returns a null DocIdSet
Index: lucene/src/test/org/apache/lucene/search/TestTermVectors.java
===================================================================
--- lucene/src/test/org/apache/lucene/search/TestTermVectors.java	(revision 1032566)
+++ lucene/src/test/org/apache/lucene/search/TestTermVectors.java	(working copy)
@@ -34,7 +34,7 @@
 import java.util.SortedSet;
 
 public class TestTermVectors extends LuceneTestCase {
-  private IndexSearcher searcher;
+  private Searcher searcher;
   private IndexReader reader;
   private Directory directory;
 
@@ -71,7 +71,7 @@
     }
     reader = writer.getReader();
     writer.close();
-    searcher = new IndexSearcher(reader);
+    searcher = newSearcher(reader);
   }
   
   @Override
@@ -93,16 +93,16 @@
       
     for (int i = 0; i < hits.length; i++)
     {
-      TermFreqVector [] vector = searcher.reader.getTermFreqVectors(hits[i].doc);
+      TermFreqVector [] vector = reader.getTermFreqVectors(hits[i].doc);
       assertTrue(vector != null);
       assertTrue(vector.length == 1);
     }
     TermFreqVector vector;
-    vector = searcher.reader.getTermFreqVector(hits[0].doc, "noTV");
+    vector = reader.getTermFreqVector(hits[0].doc, "noTV");
     assertNull(vector);
 
     TestTermVectorMapper mapper = new TestTermVectorMapper();
-    searcher.reader.getTermFreqVector(hits[0].doc, "noTV", mapper);
+    reader.getTermFreqVector(hits[0].doc, "noTV", mapper);
     assertNull(mapper.field);
   }
   
@@ -145,7 +145,7 @@
     assertEquals(1, hits.length);
     
     for (int i = 0; i < hits.length; i++) {
-      TermFreqVector[] vector = searcher.reader.getTermFreqVectors(hits[i].doc);
+      TermFreqVector[] vector = reader.getTermFreqVectors(hits[i].doc);
       assertTrue(vector != null);
       assertTrue(vector.length == 1);
       
@@ -197,7 +197,7 @@
       
       for (int i = 0; i < hits.length; i++)
       {
-        TermFreqVector [] vector = searcher.reader.getTermFreqVectors(hits[i].doc);
+        TermFreqVector [] vector = reader.getTermFreqVectors(hits[i].doc);
         assertTrue(vector != null);
         assertTrue(vector.length == 1);
         
@@ -246,21 +246,21 @@
     writer.addDocument(testDoc4);
     IndexReader reader = writer.getReader();
     writer.close();
-    IndexSearcher knownSearcher = new IndexSearcher(reader);
-    FieldsEnum fields = MultiFields.getFields(knownSearcher.reader).iterator();
+    Searcher knownSearcher = newSearcher(reader);
+    FieldsEnum fields = MultiFields.getFields(reader).iterator();
     
     DocsEnum docs = null;
     while(fields.next() != null) {
       TermsEnum terms = fields.terms();
       while(terms.next() != null) {
         String text = terms.term().utf8ToString();
-        docs = terms.docs(MultiFields.getDeletedDocs(knownSearcher.reader), docs);
+        docs = terms.docs(MultiFields.getDeletedDocs(reader), docs);
         
         while (docs.nextDoc() != DocsEnum.NO_MORE_DOCS) {
           int docId = docs.docID();
           int freq = docs.freq();
           //System.out.println("Doc Id: " + docId + " freq " + freq);
-          TermFreqVector vector = knownSearcher.reader.getTermFreqVector(docId, "field");
+          TermFreqVector vector = reader.getTermFreqVector(docId, "field");
           //float tf = sim.tf(freq);
           //float idf = sim.idf(knownSearcher.docFreq(term), knownSearcher.maxDoc());
           //float qNorm = sim.queryNorm()
@@ -295,7 +295,7 @@
     assertTrue(hits[0].doc == 2);
     assertTrue(hits[1].doc == 3);
     assertTrue(hits[2].doc == 0);
-    TermFreqVector vector = knownSearcher.reader.getTermFreqVector(hits[1].doc, "field");
+    TermFreqVector vector = reader.getTermFreqVector(hits[1].doc, "field");
     assertTrue(vector != null);
     //System.out.println("Vector: " + vector);
     BytesRef[] terms = vector.getTerms();
@@ -311,7 +311,7 @@
       assertTrue(freqInt.intValue() == freq);        
     }
     SortedTermVectorMapper mapper = new SortedTermVectorMapper(new TermVectorEntryFreqSortedComparator());
-    knownSearcher.reader.getTermFreqVector(hits[1].doc, mapper);
+    reader.getTermFreqVector(hits[1].doc, mapper);
     SortedSet<TermVectorEntry> vectorEntrySet = mapper.getTermVectorEntrySet();
     assertTrue("mapper.getTermVectorEntrySet() Size: " + vectorEntrySet.size() + " is not: " + 10, vectorEntrySet.size() == 10);
     TermVectorEntry last = null;
@@ -328,7 +328,7 @@
     }
     
     FieldSortedTermVectorMapper fieldMapper = new FieldSortedTermVectorMapper(new TermVectorEntryFreqSortedComparator());
-    knownSearcher.reader.getTermFreqVector(hits[1].doc, fieldMapper);
+    reader.getTermFreqVector(hits[1].doc, fieldMapper);
     Map<String,SortedSet<TermVectorEntry>> map = fieldMapper.getFieldToTerms();
     assertTrue("map Size: " + map.size() + " is not: " + 2, map.size() == 2);
     vectorEntrySet = map.get("field");
@@ -368,13 +368,13 @@
 
     IndexReader reader = writer.getReader();
     writer.close();
-    searcher = new IndexSearcher(reader);
+    searcher = newSearcher(reader);
 
     Query query = new TermQuery(new Term("field", "hundred"));
     ScoreDoc[] hits = searcher.search(query, null, 1000).scoreDocs;
     assertEquals(10, hits.length);
     for (int i = 0; i < hits.length; i++) {
-      TermFreqVector [] vector = searcher.reader.getTermFreqVectors(hits[i].doc);
+      TermFreqVector [] vector = reader.getTermFreqVectors(hits[i].doc);
       assertTrue(vector != null);
       assertTrue(vector.length == 1);
     }
@@ -403,13 +403,13 @@
     IndexReader reader = writer.getReader();
     writer.close();
 
-    searcher = new IndexSearcher(reader);
+    searcher = newSearcher(reader);
 
     Query query = new TermQuery(new Term("field", "one"));
     ScoreDoc[] hits = searcher.search(query, null, 1000).scoreDocs;
     assertEquals(1, hits.length);
 
-    TermFreqVector [] vector = searcher.reader.getTermFreqVectors(hits[0].doc);
+    TermFreqVector [] vector = reader.getTermFreqVectors(hits[0].doc);
     assertTrue(vector != null);
     assertTrue(vector.length == 1);
     TermPositionVector tfv = (TermPositionVector) vector[0];
Index: lucene/src/test/org/apache/lucene/search/TestMultiValuedNumericRangeQuery.java
===================================================================
--- lucene/src/test/org/apache/lucene/search/TestMultiValuedNumericRangeQuery.java	(revision 1032566)
+++ lucene/src/test/org/apache/lucene/search/TestMultiValuedNumericRangeQuery.java	(working copy)
@@ -59,7 +59,7 @@
     IndexReader reader = writer.getReader();
     writer.close();
     
-    Searcher searcher=new IndexSearcher(reader);
+    Searcher searcher=newSearcher(reader);
     num = 50 * RANDOM_MULTIPLIER;
     for (int i = 0; i < num; i++) {
       int lower=random.nextInt(Integer.MAX_VALUE);
Index: lucene/src/test/org/apache/lucene/search/TestTopDocsCollector.java
===================================================================
--- lucene/src/test/org/apache/lucene/search/TestTopDocsCollector.java	(revision 1032566)
+++ lucene/src/test/org/apache/lucene/search/TestTopDocsCollector.java	(working copy)
@@ -94,7 +94,7 @@
 
   private TopDocsCollector<ScoreDoc> doSearch(int numResults) throws IOException {
     Query q = new MatchAllDocsQuery();
-    IndexSearcher searcher = new IndexSearcher(reader);
+    Searcher searcher = newSearcher(reader);
     TopDocsCollector<ScoreDoc> tdc = new MyTopsDocCollector(numResults);
     searcher.search(q, tdc);
     searcher.close();
Index: lucene/src/test/org/apache/lucene/search/TestPhrasePrefixQuery.java
===================================================================
--- lucene/src/test/org/apache/lucene/search/TestPhrasePrefixQuery.java	(revision 1032566)
+++ lucene/src/test/org/apache/lucene/search/TestPhrasePrefixQuery.java	(working copy)
@@ -65,7 +65,7 @@
     IndexReader reader = writer.getReader();
     writer.close();
     
-    IndexSearcher searcher = new IndexSearcher(reader);
+    Searcher searcher = newSearcher(reader);
     
     // PhrasePrefixQuery query1 = new PhrasePrefixQuery();
     MultiPhraseQuery query1 = new MultiPhraseQuery();
Index: lucene/src/test/org/apache/lucene/search/TestWildcard.java
===================================================================
--- lucene/src/test/org/apache/lucene/search/TestWildcard.java	(revision 1032566)
+++ lucene/src/test/org/apache/lucene/search/TestWildcard.java	(working copy)
@@ -24,6 +24,7 @@
 import org.apache.lucene.document.Field;
 import org.apache.lucene.document.Field.Store;
 import org.apache.lucene.document.Field.Index;
+import org.apache.lucene.index.IndexReader;
 import org.apache.lucene.index.RandomIndexWriter;
 import org.apache.lucene.index.Term;
 import org.apache.lucene.queryParser.QueryParser;
@@ -68,7 +69,8 @@
    */
   public void testTermWithoutWildcard() throws IOException {
       Directory indexStore = getIndexStore("field", new String[]{"nowildcard", "nowildcardx"});
-      IndexSearcher searcher = new IndexSearcher(indexStore, true);
+      IndexReader reader = IndexReader.open(indexStore);
+      Searcher searcher = newSearcher(reader);
 
       MultiTermQuery wq = new WildcardQuery(new Term("field", "nowildcard"));
       assertMatches(searcher, wq, 1);
@@ -97,6 +99,7 @@
       assertTrue(q instanceof ConstantScoreQuery);
       assertEquals(q.getBoost(), wq.getBoost());
       searcher.close();
+      reader.close();
       indexStore.close();
   }
   
@@ -105,7 +108,8 @@
    */
   public void testEmptyTerm() throws IOException {
     Directory indexStore = getIndexStore("field", new String[]{"nowildcard", "nowildcardx"});
-    IndexSearcher searcher = new IndexSearcher(indexStore, true);
+    IndexReader reader = IndexReader.open(indexStore);
+    Searcher searcher = newSearcher(reader);
 
     MultiTermQuery wq = new WildcardQuery(new Term("field", ""));
     wq.setRewriteMethod(MultiTermQuery.SCORING_BOOLEAN_QUERY_REWRITE);
@@ -114,6 +118,7 @@
     assertTrue(q instanceof BooleanQuery);
     assertEquals(0, ((BooleanQuery) q).clauses().size());
     searcher.close();
+    reader.close();
     indexStore.close();
   }
   
@@ -146,7 +151,8 @@
       throws IOException {
     Directory indexStore = getIndexStore("body", new String[]
     {"metal", "metals"});
-    IndexSearcher searcher = new IndexSearcher(indexStore, true);
+    IndexReader reader = IndexReader.open(indexStore);
+    Searcher 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"));
@@ -175,6 +181,7 @@
     assertMatches(searcher, new WildcardQuery(new Term("body", "*tal")), 1);
     assertMatches(searcher, new WildcardQuery(new Term("body", "*tal*")), 2);
     searcher.close();
+    reader.close();
     indexStore.close();
   }
 
@@ -187,7 +194,8 @@
       throws IOException {
     Directory indexStore = getIndexStore("body", new String[]
     {"metal", "metals", "mXtals", "mXtXls"});
-    IndexSearcher searcher = new IndexSearcher(indexStore, true);
+    IndexReader reader = IndexReader.open(indexStore);
+    Searcher 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?"));
@@ -202,6 +210,7 @@
     assertMatches(searcher, query5, 0);
     assertMatches(searcher, query6, 1); // Query: 'meta??' matches 'metals' not 'metal'
     searcher.close();
+    reader.close();
     indexStore.close();
   }
 
@@ -211,7 +220,8 @@
   public void testEscapes() throws Exception {
     Directory indexStore = getIndexStore("field", 
         new String[]{"foo*bar", "foo??bar", "fooCDbar", "fooSOMETHINGbar", "foo\\"});
-    IndexSearcher searcher = new IndexSearcher(indexStore, true);
+    IndexReader reader = IndexReader.open(indexStore);
+    Searcher searcher = newSearcher(reader);
 
     // without escape: matches foo??bar, fooCDbar, foo*bar, and fooSOMETHINGbar
     WildcardQuery unescaped = new WildcardQuery(new Term("field", "foo*bar"));
@@ -234,6 +244,7 @@
     assertMatches(searcher, atEnd, 1);
     
     searcher.close();
+    reader.close();
     indexStore.close();
   }
   
@@ -251,7 +262,7 @@
     return indexStore;
   }
 
-  private void assertMatches(IndexSearcher searcher, Query q, int expectedMatches)
+  private void assertMatches(Searcher searcher, Query q, int expectedMatches)
       throws IOException {
     ScoreDoc[] result = searcher.search(q, null, 1000).scoreDocs;
     assertEquals(expectedMatches, result.length);
@@ -302,9 +313,10 @@
       doc.add(newField(field,docs[i],Store.NO,Index.ANALYZED));
       iw.addDocument(doc);
     }
+    IndexReader ir = iw.getReader();
     iw.close();
     
-    IndexSearcher searcher = new IndexSearcher(dir, true);
+    Searcher searcher = newSearcher(ir);
     
     // test queries that must find all
     for (int i = 0; i < matchAll.length; i++) {
@@ -351,6 +363,7 @@
     }
 
     searcher.close();
+    ir.close();
     dir.close();
   }
 }
Index: lucene/src/test/org/apache/lucene/search/TestAutomatonQuery.java
===================================================================
--- lucene/src/test/org/apache/lucene/search/TestAutomatonQuery.java	(revision 1032566)
+++ lucene/src/test/org/apache/lucene/search/TestAutomatonQuery.java	(working copy)
@@ -34,7 +34,7 @@
 public class TestAutomatonQuery extends LuceneTestCase {
   private Directory directory;
   private IndexReader reader;
-  private IndexSearcher searcher;
+  private Searcher searcher;
 
   private final String FN = "field";
   
@@ -59,7 +59,7 @@
         + " with numbers 1234 5678.9 and letter b");
     writer.addDocument(doc);
     reader = writer.getReader();
-    searcher = new IndexSearcher(reader);
+    searcher = newSearcher(reader);
     writer.close();
   }
   
@@ -170,7 +170,7 @@
   public void testRewriteSingleTerm() throws IOException {
     AutomatonQuery aq = new AutomatonQuery(newTerm("bogus"), BasicAutomata
         .makeString("piece"));
-    assertTrue(aq.getTermsEnum(searcher.getIndexReader()) instanceof SingleTermsEnum);
+    assertTrue(aq.getTermsEnum(reader) instanceof SingleTermsEnum);
     assertEquals(1, automatonQueryNrHits(aq));
   }
   
@@ -184,7 +184,7 @@
     Automaton prefixAutomaton = BasicOperations.concatenate(pfx, BasicAutomata
         .makeAnyString());
     AutomatonQuery aq = new AutomatonQuery(newTerm("bogus"), prefixAutomaton);
-    assertTrue(aq.getTermsEnum(searcher.getIndexReader()) instanceof PrefixTermsEnum);
+    assertTrue(aq.getTermsEnum(reader) instanceof PrefixTermsEnum);
     assertEquals(3, automatonQueryNrHits(aq));
   }
   
@@ -196,7 +196,7 @@
         .makeEmpty());
     // not yet available: assertTrue(aq.getEnum(searcher.getIndexReader())
     // instanceof EmptyTermEnum);
-    assertSame(TermsEnum.EMPTY, aq.getTermsEnum(searcher.getIndexReader()));
+    assertSame(TermsEnum.EMPTY, aq.getTermsEnum(reader));
     assertEquals(0, automatonQueryNrHits(aq));
   }
 }
Index: lucene/src/test/org/apache/lucene/search/TestBoolean2.java
===================================================================
--- lucene/src/test/org/apache/lucene/search/TestBoolean2.java	(revision 1032566)
+++ lucene/src/test/org/apache/lucene/search/TestBoolean2.java	(working copy)
@@ -43,9 +43,10 @@
  * This also tests the scoring order of BooleanQuery.
  */
 public class TestBoolean2 extends LuceneTestCase {
-  private static IndexSearcher searcher;
-  private static IndexSearcher bigSearcher;
+  private static Searcher searcher;
   private static IndexReader reader;
+  private static Searcher bigSearcher;
+  private static IndexReader bigReader;
   private static int NUM_EXTRA_DOCS = 6000;
 
   public static final String field = "field";
@@ -62,8 +63,9 @@
       doc.add(newField(field, docFields[i], Field.Store.NO, Field.Index.ANALYZED));
       writer.addDocument(doc);
     }
+    reader = writer.getReader();
     writer.close();
-    searcher = new IndexSearcher(directory, true);
+    searcher = newSearcher(reader);
 
     // Make big index
     dir2 = new MockDirectoryWrapper(new RAMDirectory(directory));
@@ -93,19 +95,21 @@
     for(int i=0;i<NUM_EXTRA_DOCS/2;i++) {
       w.addDocument(doc);
     }
-    reader = w.getReader();
-    bigSearcher = new IndexSearcher(reader);
+    bigReader = w.getReader();
+    bigSearcher = newSearcher(bigReader);
     w.close();
   }
 
   @AfterClass
   public static void afterClass() throws Exception {
     searcher.close();
+    bigReader.close();
     reader.close();
     dir2.close();
     directory.close();
     bigSearcher.close();
     searcher = null;
+    bigReader = null;
     reader = null;
     dir2 = null;
     directory = null;
Index: lucene/src/test/org/apache/lucene/search/TestExplanations.java
===================================================================
--- lucene/src/test/org/apache/lucene/search/TestExplanations.java	(revision 1032566)
+++ lucene/src/test/org/apache/lucene/search/TestExplanations.java	(working copy)
@@ -47,7 +47,7 @@
  * @see "Subclasses for actual tests"
  */
 public class TestExplanations extends LuceneTestCase {
-  protected IndexSearcher searcher;
+  protected Searcher searcher;
   protected IndexReader reader;
   protected Directory directory;
   
@@ -77,7 +77,7 @@
     }
     reader = writer.getReader();
     writer.close();
-    searcher = new IndexSearcher(reader);
+    searcher = newSearcher(reader);
   }
 
   protected String[] docFields = {
Index: lucene/src/test/org/apache/lucene/search/TestFuzzyQuery.java
===================================================================
--- lucene/src/test/org/apache/lucene/search/TestFuzzyQuery.java	(revision 1032566)
+++ lucene/src/test/org/apache/lucene/search/TestFuzzyQuery.java	(working copy)
@@ -50,7 +50,7 @@
     addDoc("ddddd", writer);
 
     IndexReader reader = writer.getReader();
-    IndexSearcher searcher = new IndexSearcher(reader);
+    Searcher searcher = newSearcher(reader);
     writer.close();
 
     FuzzyQuery query = new FuzzyQuery(new Term("field", "aaaaa"), FuzzyQuery.defaultMinSimilarity, 0);   
@@ -198,7 +198,7 @@
     addDoc("segment", writer);
 
     IndexReader reader = writer.getReader();
-    IndexSearcher searcher = new IndexSearcher(reader);
+    Searcher searcher = newSearcher(reader);
     writer.close();
 
     FuzzyQuery query;
@@ -309,7 +309,7 @@
     IndexReader ir2 = writer2.getReader();
     
     MultiReader mr = new MultiReader(ir1, ir2);
-    IndexSearcher searcher = new IndexSearcher(mr);
+    Searcher searcher = newSearcher(mr);
     FuzzyQuery fq = new FuzzyQuery(new Term("field", "z123456"), 1f, 0, 2);
     TopDocs docs = searcher.search(fq, 2);
     assertEquals(5, docs.totalHits); // 5 docs, from the a and b's
@@ -330,7 +330,7 @@
     addDoc("segment", writer);
 
     IndexReader reader = writer.getReader();
-    IndexSearcher searcher = new IndexSearcher(reader);
+    Searcher searcher = newSearcher(reader);
     writer.close();
 
     Query query;
@@ -368,7 +368,7 @@
     addDoc("Lucenne", writer);
 
     IndexReader reader = writer.getReader();
-    IndexSearcher searcher = new IndexSearcher(reader);
+    Searcher searcher = newSearcher(reader);
     writer.close();
     
     FuzzyQuery query = new FuzzyQuery(new Term("field", "lucene"));
@@ -413,7 +413,7 @@
     Query q = new QueryParser(TEST_VERSION_CURRENT, "field", analyzer).parse( "giga~0.9" );
 
     // 3. search
-    IndexSearcher searcher = new IndexSearcher(r);
+    Searcher searcher = newSearcher(r);
     ScoreDoc[] hits = searcher.search(q, 10).scoreDocs;
     assertEquals(1, hits.length);
     assertEquals("Giga byte", searcher.doc(hits[0].doc).get("field"));
@@ -435,7 +435,7 @@
     addDoc("test", w);
     addDoc("working", w);
     IndexReader reader = w.getReader();
-    IndexSearcher searcher = new IndexSearcher(reader);
+    Searcher searcher = newSearcher(reader);
     w.close();
     QueryParser qp = new QueryParser(TEST_VERSION_CURRENT, "field", new MockAnalyzer());
     
Index: lucene/src/test/org/apache/lucene/search/TestRegexpRandom2.java
===================================================================
--- lucene/src/test/org/apache/lucene/search/TestRegexpRandom2.java	(revision 1032566)
+++ lucene/src/test/org/apache/lucene/search/TestRegexpRandom2.java	(working copy)
@@ -47,7 +47,7 @@
  * Generates random regexps, and validates against a simple impl.
  */
 public class TestRegexpRandom2 extends LuceneTestCase {
-  private IndexSearcher searcher;
+  private Searcher searcher;
   private IndexReader reader;
   private Directory dir;
   
@@ -81,7 +81,7 @@
     }
     
     reader = writer.getReader();
-    searcher = new IndexSearcher(reader);
+    searcher = newSearcher(reader);
     writer.close();
   }
 
@@ -150,14 +150,6 @@
     RegexpQuery smart = new RegexpQuery(new Term("field", regexp), RegExp.NONE);
     DumbRegexpQuery dumb = new DumbRegexpQuery(new Term("field", regexp), RegExp.NONE);
     
-    // we can't compare the two if automaton rewrites to a simpler enum.
-    // for example: "a\uda07\udcc7?.*?" gets rewritten to a simpler query:
-    // a\uda07* prefixquery. Prefixquery then does the "wrong" thing, which
-    // isn't really wrong as the query was undefined to begin with... but not
-    // automatically comparable.
-    if (!(smart.getTermsEnum(searcher.getIndexReader()) instanceof AutomatonTermsEnum))
-      return;
-    
     TopDocs smartDocs = searcher.search(smart, 25);
     TopDocs dumbDocs = searcher.search(dumb, 25);
 
Index: lucene/src/test/org/apache/lucene/search/TestRegexpQuery.java
===================================================================
--- lucene/src/test/org/apache/lucene/search/TestRegexpQuery.java	(revision 1032566)
+++ lucene/src/test/org/apache/lucene/search/TestRegexpQuery.java	(working copy)
@@ -37,7 +37,7 @@
  * Some simple regex tests, mostly converted from contrib's TestRegexQuery.
  */
 public class TestRegexpQuery extends LuceneTestCase {
-  private IndexSearcher searcher;
+  private Searcher searcher;
   private IndexReader reader;
   private Directory directory;
   private final String FN = "field";
@@ -53,7 +53,7 @@
     writer.addDocument(doc);
     reader = writer.getReader();
     writer.close();
-    searcher = new IndexSearcher(reader);
+    searcher = newSearcher(reader);
   }
   
   public void tearDown() throws Exception {
Index: lucene/src/test/org/apache/lucene/search/TestDateFilter.java
===================================================================
--- lucene/src/test/org/apache/lucene/search/TestDateFilter.java	(revision 1032566)
+++ lucene/src/test/org/apache/lucene/search/TestDateFilter.java	(working copy)
@@ -57,7 +57,7 @@
     
     IndexReader reader = writer.getReader();
     writer.close();
-    IndexSearcher searcher = new IndexSearcher(reader);
+    Searcher searcher = newSearcher(reader);
     
     // filter that should preserve matches
     // DateFilter df1 = DateFilter.Before("datefield", now);
@@ -123,7 +123,7 @@
     
     IndexReader reader = writer.getReader();
     writer.close();
-    IndexSearcher searcher = new IndexSearcher(reader);
+    Searcher searcher = newSearcher(reader);
     
     // filter that should preserve matches
     // DateFilter df1 = DateFilter.After("datefield", now);
Index: lucene/src/test/org/apache/lucene/search/TestCachingSpanFilter.java
===================================================================
--- lucene/src/test/org/apache/lucene/search/TestCachingSpanFilter.java	(revision 1032566)
+++ lucene/src/test/org/apache/lucene/search/TestCachingSpanFilter.java	(working copy)
@@ -42,7 +42,7 @@
     // but we use .reopen on this reader below and expect to
     // (must) get an NRT reader:
     IndexReader reader = IndexReader.open(writer.w);
-    IndexSearcher searcher = new IndexSearcher(reader);
+    Searcher searcher = newSearcher(reader);
 
     // add a doc, refresh the reader, and check that its there
     Document doc = new Document();
@@ -50,7 +50,7 @@
     writer.addDocument(doc);
 
     reader = refreshReader(reader);
-    searcher = new IndexSearcher(reader);
+    searcher = newSearcher(reader);
 
     TopDocs docs = searcher.search(new MatchAllDocsQuery(), 1);
     assertEquals("Should find a hit...", 1, docs.totalHits);
@@ -70,7 +70,7 @@
     writer.deleteDocuments(new Term("id", "1"));
 
     reader = refreshReader(reader);
-    searcher = new IndexSearcher(reader);
+    searcher = newSearcher(reader);
 
     docs = searcher.search(new MatchAllDocsQuery(), filter, 1);
     assertEquals("[query + filter] Should *not* find a hit...", 0, docs.totalHits);
@@ -84,7 +84,7 @@
 
     writer.addDocument(doc);
     reader = refreshReader(reader);
-    searcher = new IndexSearcher(reader);
+    searcher = newSearcher(reader);
         
     docs = searcher.search(new MatchAllDocsQuery(), filter, 1);
     assertEquals("[query + filter] Should find a hit...", 1, docs.totalHits);
@@ -102,7 +102,7 @@
     // that had no new deletions
     reader = refreshReader(reader);
     assertTrue(reader != oldReader);
-    searcher = new IndexSearcher(reader);
+    searcher = newSearcher(reader);
     int missCount = filter.missCount;
     docs = searcher.search(constantScore, 1);
     assertEquals("[just filter] Should find a hit...", 1, docs.totalHits);
@@ -112,7 +112,7 @@
     writer.deleteDocuments(new Term("id", "1"));
 
     reader = refreshReader(reader);
-    searcher = new IndexSearcher(reader);
+    searcher = newSearcher(reader);
 
     docs = searcher.search(new MatchAllDocsQuery(), filter, 1);
     assertEquals("[query + filter] Should *not* find a hit...", 0, docs.totalHits);
Index: lucene/src/test/org/apache/lucene/search/TestFilteredSearch.java
===================================================================
--- lucene/src/test/org/apache/lucene/search/TestFilteredSearch.java	(revision 1032566)
+++ lucene/src/test/org/apache/lucene/search/TestFilteredSearch.java	(working copy)
@@ -73,12 +73,13 @@
       BooleanQuery booleanQuery = new BooleanQuery();
       booleanQuery.add(new TermQuery(new Term(FIELD, "36")), BooleanClause.Occur.SHOULD);
      
-     
-      IndexSearcher indexSearcher = new IndexSearcher(directory, true);
-      filter.setTopReader(indexSearcher.getIndexReader());
+      IndexReader reader = IndexReader.open(directory);
+      Searcher indexSearcher = newSearcher(reader);
+      filter.setTopReader(reader);
       ScoreDoc[] hits = indexSearcher.search(booleanQuery, filter, 1000).scoreDocs;
       assertEquals("Number of matched documents", 1, hits.length);
       indexSearcher.close();
+      reader.close();
     }
     catch (IOException e) {
       fail(e.getMessage());
Index: lucene/src/test/org/apache/lucene/search/TestMatchAllDocsQuery.java
===================================================================
--- lucene/src/test/org/apache/lucene/search/TestMatchAllDocsQuery.java	(revision 1032566)
+++ lucene/src/test/org/apache/lucene/search/TestMatchAllDocsQuery.java	(working copy)
@@ -47,7 +47,7 @@
     iw.close();
 
     IndexReader ir = IndexReader.open(dir, false);
-    IndexSearcher is = new IndexSearcher(ir);
+    Searcher is = newSearcher(ir);
     ScoreDoc[] hits;
 
     // assert with norms scoring turned off
@@ -93,7 +93,7 @@
     assertEquals(1, hits.length);
 
     // delete a document:
-    is.getIndexReader().deleteDocument(0);
+    ir.deleteDocument(0);
     hits = is.search(new MatchAllDocsQuery(), null, 1000).scoreDocs;
     assertEquals(2, hits.length);
     
Index: lucene/src/test/org/apache/lucene/search/TestFieldCacheRangeFilter.java
===================================================================
--- lucene/src/test/org/apache/lucene/search/TestFieldCacheRangeFilter.java	(revision 1032566)
+++ lucene/src/test/org/apache/lucene/search/TestFieldCacheRangeFilter.java	(working copy)
@@ -46,7 +46,7 @@
   public void testRangeFilterId() throws IOException {
 
     IndexReader reader = signedIndexReader;
-    IndexSearcher search = new IndexSearcher(reader);
+    Searcher search = newSearcher(reader);
 
     int medId = ((maxId - minId) / 2);
         
@@ -131,7 +131,7 @@
   public void testFieldCacheRangeFilterRand() throws IOException {
 
     IndexReader reader = signedIndexReader;
-    IndexSearcher search = new IndexSearcher(reader);
+    Searcher search = newSearcher(reader);
 
     String minRP = pad(signedIndexDir.minR);
     String maxRP = pad(signedIndexDir.maxR);
@@ -195,7 +195,7 @@
   public void testFieldCacheRangeFilterShorts() throws IOException {
 
     IndexReader reader = signedIndexReader;
-    IndexSearcher search = new IndexSearcher(reader);
+    Searcher search = newSearcher(reader);
 
     int numDocs = reader.numDocs();
     int medId = ((maxId - minId) / 2);
@@ -285,7 +285,7 @@
   public void testFieldCacheRangeFilterInts() throws IOException {
 
     IndexReader reader = signedIndexReader;
-    IndexSearcher search = new IndexSearcher(reader);
+    Searcher search = newSearcher(reader);
 
     int numDocs = reader.numDocs();
     int medId = ((maxId - minId) / 2);
@@ -376,7 +376,7 @@
   public void testFieldCacheRangeFilterLongs() throws IOException {
 
     IndexReader reader = signedIndexReader;
-    IndexSearcher search = new IndexSearcher(reader);
+    Searcher search = newSearcher(reader);
 
     int numDocs = reader.numDocs();
     int medId = ((maxId - minId) / 2);
@@ -469,7 +469,7 @@
   public void testFieldCacheRangeFilterFloats() throws IOException {
 
     IndexReader reader = signedIndexReader;
-    IndexSearcher search = new IndexSearcher(reader);
+    Searcher search = newSearcher(reader);
 
     int numDocs = reader.numDocs();
     Float minIdO = Float.valueOf(minId + .5f);
@@ -498,7 +498,7 @@
   public void testFieldCacheRangeFilterDoubles() throws IOException {
 
     IndexReader reader = signedIndexReader;
-    IndexSearcher search = new IndexSearcher(reader);
+    Searcher search = newSearcher(reader);
 
     int numDocs = reader.numDocs();
     Double minIdO = Double.valueOf(minId + .5);
@@ -541,7 +541,7 @@
     writer.close();
 
     IndexReader reader = IndexReader.open(dir, true);
-    IndexSearcher search = new IndexSearcher(reader);
+    Searcher search = newSearcher(reader);
     assertTrue(reader.hasDeletions());
 
     ScoreDoc[] result;
Index: lucene/src/test/org/apache/lucene/search/TestRegexpRandom.java
===================================================================
--- lucene/src/test/org/apache/lucene/search/TestRegexpRandom.java	(revision 1032566)
+++ lucene/src/test/org/apache/lucene/search/TestRegexpRandom.java	(working copy)
@@ -62,7 +62,7 @@
     
     reader = writer.getReader();
     writer.close();
-    searcher = new IndexSearcher(reader);
+    searcher = newSearcher(reader);
   }
   
   private char N() {
Index: lucene/src/test/org/apache/lucene/search/TestTopScoreDocCollector.java
===================================================================
--- lucene/src/test/org/apache/lucene/search/TestTopScoreDocCollector.java	(revision 1032566)
+++ lucene/src/test/org/apache/lucene/search/TestTopScoreDocCollector.java	(working copy)
@@ -47,7 +47,7 @@
     // the clause instead of BQ.
     bq.setMinimumNumberShouldMatch(1);
     IndexReader reader = writer.getReader();
-    IndexSearcher searcher = new IndexSearcher(reader);
+    Searcher searcher = newSearcher(reader);
     for (int i = 0; i < inOrder.length; i++) {
       TopDocsCollector<ScoreDoc> tdc = TopScoreDocCollector.create(3, inOrder[i]);
       assertEquals("org.apache.lucene.search.TopScoreDocCollector$" + actualTSDCClass[i], tdc.getClass().getName());
Index: lucene/src/test/org/apache/lucene/search/TestPrefixRandom.java
===================================================================
--- lucene/src/test/org/apache/lucene/search/TestPrefixRandom.java	(revision 1032566)
+++ lucene/src/test/org/apache/lucene/search/TestPrefixRandom.java	(working copy)
@@ -39,7 +39,7 @@
  * Generates random prefix queries, and validates against a simple impl.
  */
 public class TestPrefixRandom extends LuceneTestCase {
-  private IndexSearcher searcher;
+  private Searcher searcher;
   private IndexReader reader;
   private Directory dir;
   
@@ -64,7 +64,7 @@
       writer.addDocument(doc);
     }
     reader = writer.getReader();
-    searcher = new IndexSearcher(reader);
+    searcher = newSearcher(reader);
     writer.close();
   }
 
Index: lucene/src/test/org/apache/lucene/search/TestPrefixInBooleanQuery.java
===================================================================
--- lucene/src/test/org/apache/lucene/search/TestPrefixInBooleanQuery.java	(revision 1032566)
+++ lucene/src/test/org/apache/lucene/search/TestPrefixInBooleanQuery.java	(working copy)
@@ -40,7 +40,7 @@
   private static final String FIELD = "name";
   private Directory directory;
   private IndexReader reader;
-  private IndexSearcher searcher;
+  private Searcher searcher;
 
   @Override
   public void setUp() throws Exception {
@@ -75,7 +75,7 @@
     }
     
     reader = writer.getReader();
-    searcher = new IndexSearcher(reader);
+    searcher = newSearcher(reader);
     writer.close();
   }
   
Index: lucene/src/test/org/apache/lucene/search/TestNumericRangeQuery32.java
===================================================================
--- lucene/src/test/org/apache/lucene/search/TestNumericRangeQuery32.java	(revision 1032566)
+++ lucene/src/test/org/apache/lucene/search/TestNumericRangeQuery32.java	(working copy)
@@ -46,7 +46,7 @@
   
   private static Directory directory = null;
   private static IndexReader reader = null;
-  private static IndexSearcher searcher = null;
+  private static Searcher searcher = null;
   
   @BeforeClass
   public static void beforeClass() throws Exception {
@@ -86,7 +86,7 @@
     }
   
     reader = writer.getReader();
-    searcher=new IndexSearcher(reader);
+    searcher=newSearcher(reader);
     writer.close();
   }
   
@@ -151,7 +151,7 @@
       assertEquals("First doc"+type, 2*distance+startOffset, Integer.parseInt(doc.get(field)) );
       doc=searcher.doc(sd[sd.length-1].doc);
       assertEquals("Last doc"+type, (1+count)*distance+startOffset, Integer.parseInt(doc.get(field)) );
-      if (i>0 && searcher.getIndexReader().getSequentialSubReaders().length == 1) {
+      if (i>0 && reader.getSequentialSubReaders().length == 1) {
         assertEquals("Distinct term number is equal for all query types", lastTerms, terms);
       }
       lastTerms = terms;
@@ -176,13 +176,13 @@
   @Test
   public void testInverseRange() throws Exception {
     NumericRangeFilter<Integer> f = NumericRangeFilter.newIntRange("field8", 8, 1000, -1000, true, true);
-    assertSame("A inverse range should return the EMPTY_DOCIDSET instance", DocIdSet.EMPTY_DOCIDSET, f.getDocIdSet(searcher.getIndexReader()));
+    assertSame("A inverse range should return the EMPTY_DOCIDSET instance", DocIdSet.EMPTY_DOCIDSET, f.getDocIdSet(reader));
     f = NumericRangeFilter.newIntRange("field8", 8, Integer.MAX_VALUE, null, false, false);
     assertSame("A exclusive range starting with Integer.MAX_VALUE should return the EMPTY_DOCIDSET instance",
-      DocIdSet.EMPTY_DOCIDSET, f.getDocIdSet(searcher.getIndexReader()));
+      DocIdSet.EMPTY_DOCIDSET, f.getDocIdSet(reader));
     f = NumericRangeFilter.newIntRange("field8", 8, null, Integer.MIN_VALUE, false, false);
     assertSame("A exclusive range ending with Integer.MIN_VALUE should return the EMPTY_DOCIDSET instance",
-      DocIdSet.EMPTY_DOCIDSET, f.getDocIdSet(searcher.getIndexReader()));
+      DocIdSet.EMPTY_DOCIDSET, f.getDocIdSet(reader));
   }
   
   @Test
@@ -297,7 +297,8 @@
     writer.addDocument(doc);
     writer.close();
     
-    IndexSearcher s = new IndexSearcher(dir);
+    IndexReader r = IndexReader.open(dir);
+    Searcher s = newSearcher(r);
     
     Query q=NumericRangeQuery.newIntRange("int", null, null, true, true);
     TopDocs topDocs = s.search(q, 10);
@@ -324,6 +325,7 @@
     assertEquals("Score doc count", 3,  topDocs.scoreDocs.length );
 
     s.close();
+    r.close();
     dir.close();
   }
   
@@ -376,7 +378,7 @@
       termCountT += tq.getTotalNumberOfTerms();
       termCountC += cq.getTotalNumberOfTerms();
     }
-    if (precisionStep == Integer.MAX_VALUE && searcher.getIndexReader().getSequentialSubReaders().length == 1) {
+    if (precisionStep == Integer.MAX_VALUE && reader.getSequentialSubReaders().length == 1) {
       assertEquals("Total number of terms should be equal for unlimited precStep", termCountT, termCountC);
     } else if (VERBOSE) {
       System.out.println("Average number of terms during random search on '" + field + "':");
@@ -563,7 +565,7 @@
   private void testEnum(int lower, int upper) throws Exception {
     NumericRangeQuery<Integer> q = NumericRangeQuery.newIntRange("field4", 4,
         lower, upper, true, true);
-    TermsEnum termEnum = q.getTermsEnum(searcher.getIndexReader());
+    TermsEnum termEnum = q.getTermsEnum(reader);
     int count = 0;
     while (termEnum.next() != null) {
       final BytesRef t = termEnum.term();
Index: lucene/src/test/org/apache/lucene/search/TestDocBoost.java
===================================================================
--- lucene/src/test/org/apache/lucene/search/TestDocBoost.java	(revision 1032566)
+++ lucene/src/test/org/apache/lucene/search/TestDocBoost.java	(working copy)
@@ -63,7 +63,7 @@
 
     final float[] scores = new float[4];
 
-    new IndexSearcher(reader).search
+    newSearcher(reader).search
       (new TermQuery(new Term("field", "word")),
        new Collector() {
          private int base = 0;
Index: lucene/src/test/org/apache/lucene/search/TestElevationComparator.java
===================================================================
--- lucene/src/test/org/apache/lucene/search/TestElevationComparator.java	(revision 1032566)
+++ lucene/src/test/org/apache/lucene/search/TestElevationComparator.java	(working copy)
@@ -48,7 +48,7 @@
     IndexReader r = IndexReader.open(writer);
     writer.close();
 
-    IndexSearcher searcher = new IndexSearcher(r);
+    Searcher searcher = newSearcher(r);
 
     runTest(searcher, true);
     runTest(searcher, false);
@@ -58,7 +58,7 @@
     directory.close();
   }
 
-  private void runTest(IndexSearcher searcher, boolean reversed) throws Throwable {
+  private void runTest(Searcher searcher, boolean reversed) throws Throwable {
 
     BooleanQuery newq = new BooleanQuery(false);
     TermQuery query = new TermQuery(new Term("title", "ipod"));
Index: lucene/src/test/org/apache/lucene/search/TestNumericRangeQuery64.java
===================================================================
--- lucene/src/test/org/apache/lucene/search/TestNumericRangeQuery64.java	(revision 1032566)
+++ lucene/src/test/org/apache/lucene/search/TestNumericRangeQuery64.java	(working copy)
@@ -45,7 +45,7 @@
   
   private static Directory directory = null;
   private static IndexReader reader = null;
-  private static IndexSearcher searcher = null;
+  private static Searcher searcher = null;
   
   @BeforeClass
   public static void beforeClass() throws Exception {
@@ -88,7 +88,7 @@
       writer.addDocument(doc);
     }
     reader = writer.getReader();
-    searcher=new IndexSearcher(reader);
+    searcher=newSearcher(reader);
     writer.close();
   }
   
@@ -153,7 +153,7 @@
       assertEquals("First doc"+type, 2*distance+startOffset, Long.parseLong(doc.get(field)) );
       doc=searcher.doc(sd[sd.length-1].doc);
       assertEquals("Last doc"+type, (1+count)*distance+startOffset, Long.parseLong(doc.get(field)) );
-      if (i>0 && searcher.getIndexReader().getSequentialSubReaders().length == 1) {
+      if (i>0 && reader.getSequentialSubReaders().length == 1) {
         assertEquals("Distinct term number is equal for all query types", lastTerms, terms);
       }
       lastTerms = terms;
@@ -183,13 +183,13 @@
   @Test
   public void testInverseRange() throws Exception {
     NumericRangeFilter<Long> f = NumericRangeFilter.newLongRange("field8", 8, 1000L, -1000L, true, true);
-    assertSame("A inverse range should return the EMPTY_DOCIDSET instance", DocIdSet.EMPTY_DOCIDSET, f.getDocIdSet(searcher.getIndexReader()));
+    assertSame("A inverse range should return the EMPTY_DOCIDSET instance", DocIdSet.EMPTY_DOCIDSET, f.getDocIdSet(reader));
     f = NumericRangeFilter.newLongRange("field8", 8, Long.MAX_VALUE, null, false, false);
     assertSame("A exclusive range starting with Long.MAX_VALUE should return the EMPTY_DOCIDSET instance",
-      DocIdSet.EMPTY_DOCIDSET, f.getDocIdSet(searcher.getIndexReader()));
+      DocIdSet.EMPTY_DOCIDSET, f.getDocIdSet(reader));
     f = NumericRangeFilter.newLongRange("field8", 8, null, Long.MIN_VALUE, false, false);
     assertSame("A exclusive range ending with Long.MIN_VALUE should return the EMPTY_DOCIDSET instance",
-      DocIdSet.EMPTY_DOCIDSET, f.getDocIdSet(searcher.getIndexReader()));
+      DocIdSet.EMPTY_DOCIDSET, f.getDocIdSet(reader));
   }
   
   @Test
@@ -315,7 +315,8 @@
     writer.addDocument(doc);
     writer.close();
     
-    IndexSearcher s = new IndexSearcher(dir);
+    IndexReader r = IndexReader.open(dir);
+    Searcher s = newSearcher(r);
     
     Query q=NumericRangeQuery.newLongRange("long", null, null, true, true);
     TopDocs topDocs = s.search(q, 10);
@@ -342,6 +343,7 @@
     assertEquals("Score doc count", 3,  topDocs.scoreDocs.length );
 
     s.close();
+    r.close();
     dir.close();
   }
   
@@ -394,7 +396,7 @@
       termCountT += tq.getTotalNumberOfTerms();
       termCountC += cq.getTotalNumberOfTerms();
     }
-    if (precisionStep == Integer.MAX_VALUE && searcher.getIndexReader().getSequentialSubReaders().length == 1) {
+    if (precisionStep == Integer.MAX_VALUE && reader.getSequentialSubReaders().length == 1) {
       assertEquals("Total number of terms should be equal for unlimited precStep", termCountT, termCountC);
     } else if (VERBOSE) {
       System.out.println("Average number of terms during random search on '" + field + "':");
Index: lucene/src/test/org/apache/lucene/search/TestPrefixQuery.java
===================================================================
--- lucene/src/test/org/apache/lucene/search/TestPrefixQuery.java	(revision 1032566)
+++ lucene/src/test/org/apache/lucene/search/TestPrefixQuery.java	(working copy)
@@ -45,7 +45,7 @@
     IndexReader reader = writer.getReader();
 
     PrefixQuery query = new PrefixQuery(new Term("category", "/Computers"));
-    IndexSearcher searcher = new IndexSearcher(reader);
+    Searcher searcher = newSearcher(reader);
     ScoreDoc[] hits = searcher.search(query, null, 1000).scoreDocs;
     assertEquals("All documents in /Computers category and below", 3, hits.length);
 
@@ -54,7 +54,7 @@
     assertEquals("One in /Computers/Mac", 1, hits.length);
 
     query = new PrefixQuery(new Term("category", ""));
-    assertFalse(query.getTermsEnum(searcher.getIndexReader()) instanceof PrefixTermsEnum);
+    assertFalse(query.getTermsEnum(reader) instanceof PrefixTermsEnum);
     hits = searcher.search(query, null, 1000).scoreDocs;
     assertEquals("everything", 3, hits.length);
     writer.close();
Index: lucene/src/test/org/apache/lucene/search/TestMultiPhraseQuery.java
===================================================================
--- lucene/src/test/org/apache/lucene/search/TestMultiPhraseQuery.java	(revision 1032566)
+++ lucene/src/test/org/apache/lucene/search/TestMultiPhraseQuery.java	(working copy)
@@ -51,7 +51,7 @@
     add("piccadilly circus", writer);
     
     IndexReader reader = writer.getReader();
-    IndexSearcher searcher = new IndexSearcher(reader);
+    Searcher searcher = newSearcher(reader);
     
     // search for "blueberry pi*":
     MultiPhraseQuery query1 = new MultiPhraseQuery();
@@ -140,7 +140,7 @@
     IndexReader r = writer.getReader();
     writer.close();
 
-    IndexSearcher searcher = new IndexSearcher(r);
+    Searcher searcher = newSearcher(r);
     MultiPhraseQuery q = new MultiPhraseQuery();
     q.add(new Term("body", "blueberry"));
     q.add(new Term("body", "chocolate"));
@@ -169,7 +169,7 @@
     add("blue raspberry pie", writer);
     
     IndexReader reader = writer.getReader();
-    IndexSearcher searcher = new IndexSearcher(reader);
+    Searcher searcher = newSearcher(reader);
     // This query will be equivalent to +body:pie +body:"blue*"
     BooleanQuery q = new BooleanQuery();
     q.add(new TermQuery(new Term("body", "pie")), BooleanClause.Occur.MUST);
@@ -200,7 +200,7 @@
     add("a note", "note", writer);
     
     IndexReader reader = writer.getReader();
-    IndexSearcher searcher = new IndexSearcher(reader);
+    Searcher searcher = newSearcher(reader);
     
     // This query will be equivalent to +type:note +body:"a t*"
     BooleanQuery q = new BooleanQuery();
@@ -227,7 +227,7 @@
     add("a note", "note", writer);
     
     IndexReader reader = writer.getReader();
-    IndexSearcher searcher = new IndexSearcher(reader);
+    Searcher searcher = newSearcher(reader);
     
     MultiPhraseQuery q = new MultiPhraseQuery();
     q.add(new Term("body", "a"));
Index: lucene/src/test/org/apache/lucene/search/TestFilteredQuery.java
===================================================================
--- lucene/src/test/org/apache/lucene/search/TestFilteredQuery.java	(revision 1032566)
+++ lucene/src/test/org/apache/lucene/search/TestFilteredQuery.java	(working copy)
@@ -38,7 +38,7 @@
  */
 public class TestFilteredQuery extends LuceneTestCase {
 
-  private IndexSearcher searcher;
+  private Searcher searcher;
   private IndexReader reader;
   private Directory directory;
   private Query query;
@@ -78,7 +78,7 @@
     reader = writer.getReader();
     writer.close ();
 
-    searcher = new IndexSearcher (reader);
+    searcher = newSearcher(reader);
     query = new TermQuery (new Term ("field", "three"));
     filter = newStaticFilterB();
   }
Index: lucene/src/test/org/apache/lucene/search/TestFieldCacheTermsFilter.java
===================================================================
--- lucene/src/test/org/apache/lucene/search/TestFieldCacheTermsFilter.java	(revision 1032566)
+++ lucene/src/test/org/apache/lucene/search/TestFieldCacheTermsFilter.java	(working copy)
@@ -47,7 +47,7 @@
     IndexReader reader = w.getReader();
     w.close();
 
-    IndexSearcher searcher = new IndexSearcher(reader);
+    Searcher searcher = newSearcher(reader);
     int numDocs = reader.numDocs();
     ScoreDoc[] results;
     MatchAllDocsQuery q = new MatchAllDocsQuery();
Index: lucene/src/test/org/apache/lucene/util/LuceneTestCase.java
===================================================================
--- lucene/src/test/org/apache/lucene/util/LuceneTestCase.java	(revision 1032566)
+++ lucene/src/test/org/apache/lucene/util/LuceneTestCase.java	(working copy)
@@ -23,6 +23,7 @@
 import org.apache.lucene.document.Field.Store;
 import org.apache.lucene.document.Field.TermVector;
 import org.apache.lucene.index.ConcurrentMergeScheduler;
+import org.apache.lucene.index.IndexReader;
 import org.apache.lucene.index.IndexWriterConfig;
 import org.apache.lucene.index.LogDocMergePolicy;
 import org.apache.lucene.index.LogMergePolicy;
@@ -38,6 +39,10 @@
 import org.apache.lucene.search.BooleanQuery;
 import org.apache.lucene.search.FieldCache;
 import org.apache.lucene.search.FieldCache.CacheEntry;
+import org.apache.lucene.search.IndexSearcher;
+import org.apache.lucene.search.MultiSearcher;
+import org.apache.lucene.search.ParallelMultiSearcher;
+import org.apache.lucene.search.Searcher;
 import org.apache.lucene.store.Directory;
 import org.apache.lucene.store.MockDirectoryWrapper;
 import org.apache.lucene.util.FieldCacheSanityChecker.Insanity;
@@ -603,6 +608,27 @@
     dumpIterator(label, iter, stream);
   }
 
+  /** create a new searcher over the reader */
+  public static Searcher newSearcher(IndexReader r) throws IOException {
+    if (random.nextBoolean()) {
+      return new IndexSearcher(r);
+    } else { // build a multisearcher over the subreaders
+      List<IndexReader> readers = new ArrayList<IndexReader>();
+      ReaderUtil.gatherSubReaders(readers, r);
+      IndexSearcher searchers[] = new IndexSearcher[readers.size()];
+      
+      for (int i = 0; i < searchers.length; i++) {
+        searchers[i] = new IndexSearcher(readers.get(i));
+      }
+      
+      if (random.nextBoolean()) {
+        return new MultiSearcher(searchers);
+      } else {
+        return new ParallelMultiSearcher(searchers);
+      }
+    }
+  }
+  
   /** create a new index writer config with random defaults */
   public static IndexWriterConfig newIndexWriterConfig(Version v, Analyzer a) {
     return newIndexWriterConfig(random, v, a);