Index: lucene/contrib/memory/src/test/org/apache/lucene/index/memory/MemoryIndexTest.java
===================================================================
--- lucene/contrib/memory/src/test/org/apache/lucene/index/memory/MemoryIndexTest.java	(revision 979588)
+++ lucene/contrib/memory/src/test/org/apache/lucene/index/memory/MemoryIndexTest.java	(working copy)
@@ -48,7 +48,7 @@
   private Set<String> queries = new HashSet<String>();
   private Random random;
   
-  public static final int ITERATIONS = 100*_TestUtil.getRandomMultiplier();
+  public static final int ITERATIONS = 100 * RANDOM_MULTIPLIER;
 
   @Override
   public void setUp() throws Exception {
@@ -93,14 +93,14 @@
     StringBuilder termField = new StringBuilder();
  
     // add up to 250 terms to field "foo"
-    final int numFooTerms = random.nextInt(250*_TestUtil.getRandomMultiplier());
+    final int numFooTerms = random.nextInt(250 * RANDOM_MULTIPLIER);
     for (int i = 0; i < numFooTerms; i++) {
       fooField.append(" ");
       fooField.append(randomTerm());
     }
 
     // add up to 250 terms to field "term"
-    final int numTermTerms = random.nextInt(250*_TestUtil.getRandomMultiplier());
+    final int numTermTerms = random.nextInt(250 * RANDOM_MULTIPLIER);
     for (int i = 0; i < numTermTerms; i++) {
       termField.append(" ");
       termField.append(randomTerm());
Index: lucene/src/test/org/apache/lucene/analysis/TestCharTokenizers.java
===================================================================
--- lucene/src/test/org/apache/lucene/analysis/TestCharTokenizers.java	(revision 979588)
+++ lucene/src/test/org/apache/lucene/analysis/TestCharTokenizers.java	(working copy)
@@ -39,7 +39,8 @@
     Random newRandom = newRandom();
     // create random input
     int num = 1024 + newRandom.nextInt(1024);
-    for (int i = 1; i < num*_TestUtil.getRandomMultiplier(); i++) {
+    num *= RANDOM_MULTIPLIER;
+    for (int i = 1; i < num; i++) {
       builder.append("\ud801\udc1cabc");
       if((i % 10) == 0)
         builder.append(" ");
Index: lucene/src/test/org/apache/lucene/index/TestAtomicUpdate.java
===================================================================
--- lucene/src/test/org/apache/lucene/index/TestAtomicUpdate.java	(revision 979588)
+++ lucene/src/test/org/apache/lucene/index/TestAtomicUpdate.java	(working copy)
@@ -47,7 +47,7 @@
   private static abstract class TimedThread extends Thread {
     volatile boolean failed;
     int count;
-    private static float RUN_TIME_SEC = 0.5f * (float)_TestUtil.getRandomMultiplier();
+    private static float RUN_TIME_SEC = 0.5f * RANDOM_MULTIPLIER;
     private TimedThread[] allThreads;
 
     abstract public void doWork() throws Throwable;
Index: lucene/src/test/org/apache/lucene/index/TestByteSlices.java
===================================================================
--- lucene/src/test/org/apache/lucene/index/TestByteSlices.java	(revision 979588)
+++ lucene/src/test/org/apache/lucene/index/TestByteSlices.java	(working copy)
@@ -18,7 +18,6 @@
 import java.util.ArrayList;
 import java.util.List;
 import org.apache.lucene.util.LuceneTestCase;
-import org.apache.lucene.util._TestUtil;
 
 public class TestByteSlices extends LuceneTestCase {
 
@@ -55,7 +54,7 @@
   public void testBasic() throws Throwable {
     ByteBlockPool pool = new ByteBlockPool(new ByteBlockAllocator());
 
-    final int NUM_STREAM = 100*_TestUtil.getRandomMultiplier();
+    final int NUM_STREAM = 100 * RANDOM_MULTIPLIER;
 
     ByteSliceWriter writer = new ByteSliceWriter(pool);
 
@@ -74,7 +73,8 @@
         counters[stream] = 0;
       }
       
-      for(int iter=0;iter<10000*_TestUtil.getRandomMultiplier();iter++) {
+      int num = 10000 * RANDOM_MULTIPLIER;
+      for (int iter = 0; iter < num; iter++) {
         int stream = r.nextInt(NUM_STREAM);
         if (VERBOSE)
           System.out.println("write stream=" + stream);
Index: lucene/src/test/org/apache/lucene/index/TestCodecs.java
===================================================================
--- lucene/src/test/org/apache/lucene/index/TestCodecs.java	(revision 979588)
+++ lucene/src/test/org/apache/lucene/index/TestCodecs.java	(working copy)
@@ -44,7 +44,6 @@
 import org.apache.lucene.util.BytesRef;
 import org.apache.lucene.util.MultiCodecTestCase;
 import org.apache.lucene.util.Version;
-import org.apache.lucene.util._TestUtil;
 
 // TODO: test multiple codecs here?
 
@@ -69,7 +68,7 @@
   private Random RANDOM;
   private static String[] fieldNames = new String[] {"one", "two", "three", "four"};
 
-  private final static int NUM_TEST_ITER = 20*_TestUtil.getRandomMultiplier();
+  private final static int NUM_TEST_ITER = 20 * RANDOM_MULTIPLIER;
   private final static int NUM_TEST_THREADS = 3;
   private final static int NUM_FIELDS = 4;
   private final static int NUM_TERMS_RAND = 50; // must be > 16 to test skipping
Index: lucene/src/test/org/apache/lucene/index/TestIndexReaderReopen.java
===================================================================
--- lucene/src/test/org/apache/lucene/index/TestIndexReaderReopen.java	(revision 979588)
+++ lucene/src/test/org/apache/lucene/index/TestIndexReaderReopen.java	(working copy)
@@ -45,7 +45,6 @@
 import org.apache.lucene.store.AlreadyClosedException;
 import org.apache.lucene.util.LuceneTestCase;
 import org.apache.lucene.util.BitVector;
-import org.apache.lucene.util._TestUtil;
 
 public class TestIndexReaderReopen extends LuceneTestCase {
     
@@ -701,7 +700,7 @@
   
   public void testThreadSafety() throws Exception {
     final Directory dir = new MockRAMDirectory();
-    final int n = 30*_TestUtil.getRandomMultiplier();
+    final int n = 30 * RANDOM_MULTIPLIER;
 
     IndexWriter writer = new IndexWriter(dir, new IndexWriterConfig(
         TEST_VERSION_CURRENT, new MockAnalyzer()));
Index: lucene/src/test/org/apache/lucene/index/TestIndexWriter.java
===================================================================
--- lucene/src/test/org/apache/lucene/index/TestIndexWriter.java	(revision 979588)
+++ lucene/src/test/org/apache/lucene/index/TestIndexWriter.java	(working copy)
@@ -52,6 +52,7 @@
 import org.apache.lucene.document.Field.Store;
 import org.apache.lucene.document.Field.TermVector;
 import org.apache.lucene.index.IndexWriterConfig.OpenMode;
+import org.apache.lucene.search.DocIdSetIterator;
 import org.apache.lucene.search.IndexSearcher;
 import org.apache.lucene.search.PhraseQuery;
 import org.apache.lucene.search.Query;
@@ -1711,7 +1712,7 @@
                                               new BytesRef(t.text()));
 
     int count = 0;
-    while(tdocs.nextDoc() != DocsEnum.NO_MORE_DOCS) {
+    while(tdocs.nextDoc() != DocIdSetIterator.NO_MORE_DOCS) {
       count++;
     }
     assertEquals(2, count);
@@ -3354,7 +3355,8 @@
     BytesRef utf8 = new BytesRef(20);
     UnicodeUtil.UTF16Result utf16 = new UnicodeUtil.UTF16Result();
 
-    for(int iter=0;iter<100000*_TestUtil.getRandomMultiplier();iter++) {
+    int num = 100000 * RANDOM_MULTIPLIER;
+    for (int iter = 0; iter < num; iter++) {
       boolean hasIllegal = fillUnicode(buffer, expected, 0, 20);
 
       UnicodeUtil.UTF16toUTF8(buffer, 0, 20, utf8);
@@ -3385,7 +3387,8 @@
     boolean hasIllegal = false;
     byte[] last = new byte[60];
 
-    for(int iter=0;iter<100000*_TestUtil.getRandomMultiplier();iter++) {
+    int num = 100000 * RANDOM_MULTIPLIER;
+    for (int iter = 0; iter < num; iter++) {
 
       final int prefix;
 
@@ -4682,7 +4685,8 @@
     char[] chars = new char[2];
     final Set<String> allTerms = new HashSet<String>();
 
-    for(int i=0;i<200*_TestUtil.getRandomMultiplier();i++) {
+    int num = 200 * RANDOM_MULTIPLIER;
+    for (int i = 0; i < num; i++) {
 
       final String s;
       if (rnd.nextBoolean()) {
@@ -4872,7 +4876,8 @@
     //w.setInfoStream(System.out);
     Document doc = new Document();
     doc.add(new Field("field", "go 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20", Field.Store.NO, Field.Index.ANALYZED));
-    for(int iter=0;iter<6*_TestUtil.getRandomMultiplier();iter++) {
+    int num = 6 * RANDOM_MULTIPLIER;
+    for (int iter = 0; iter < num; iter++) {
       int count = 0;
 
       final boolean doIndexing = r.nextBoolean();
Index: lucene/src/test/org/apache/lucene/index/TestIndexWriterReader.java
===================================================================
--- lucene/src/test/org/apache/lucene/index/TestIndexWriterReader.java	(revision 979588)
+++ lucene/src/test/org/apache/lucene/index/TestIndexWriterReader.java	(working copy)
@@ -547,7 +547,8 @@
     
     ((LogMergePolicy) writer.getConfig().getMergePolicy()).setMergeFactor(2);
 
-    for (int i = 0; i < 100*_TestUtil.getRandomMultiplier(); i++) {
+    int num = 100 * RANDOM_MULTIPLIER;
+    for (int i = 0; i < num; i++) {
       writer.addDocument(createDocument(i, "test", 4));
     }
     ((ConcurrentMergeScheduler) writer.getConfig().getMergeScheduler()).sync();
Index: lucene/src/test/org/apache/lucene/index/TestMultiFields.java
===================================================================
--- lucene/src/test/org/apache/lucene/index/TestMultiFields.java	(revision 979588)
+++ lucene/src/test/org/apache/lucene/index/TestMultiFields.java	(working copy)
@@ -29,7 +29,8 @@
 
     Random r = newRandom();
 
-    for(int iter=0;iter<2*_TestUtil.getRandomMultiplier();iter++) {
+    int num = 2 * RANDOM_MULTIPLIER;
+    for (int iter = 0; iter < num; iter++) {
       Directory dir = new MockRAMDirectory();
 
       IndexWriter w = new IndexWriter(dir, new IndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer()).setMergePolicy(NoMergePolicy.COMPOUND_FILES));
@@ -38,7 +39,7 @@
       Set<Integer> deleted = new HashSet<Integer>();
       List<BytesRef> terms = new ArrayList<BytesRef>();
 
-      int numDocs = _TestUtil.nextInt(r, 1, 100*_TestUtil.getRandomMultiplier());
+      int numDocs = _TestUtil.nextInt(r, 1, 100 * RANDOM_MULTIPLIER);
       Document doc = new Document();
       Field f = new Field("field", "", Field.Store.NO, Field.Index.NOT_ANALYZED);
       doc.add(f);
Index: lucene/src/test/org/apache/lucene/index/TestPayloads.java
===================================================================
--- lucene/src/test/org/apache/lucene/index/TestPayloads.java	(revision 979588)
+++ lucene/src/test/org/apache/lucene/index/TestPayloads.java	(working copy)
@@ -486,7 +486,7 @@
     public void testThreadSafety() throws Exception {
         rnd = newRandom();
         final int numThreads = 5;
-        final int numDocs = 50* _TestUtil.getRandomMultiplier();
+        final int numDocs = 50 * RANDOM_MULTIPLIER;
         final ByteArrayPool pool = new ByteArrayPool(numThreads, 5);
         
         Directory dir = new MockRAMDirectory();
Index: lucene/src/test/org/apache/lucene/index/TestStressIndexing.java
===================================================================
--- lucene/src/test/org/apache/lucene/index/TestStressIndexing.java	(revision 979588)
+++ lucene/src/test/org/apache/lucene/index/TestStressIndexing.java	(working copy)
@@ -32,7 +32,7 @@
   private static abstract class TimedThread extends Thread {
     volatile boolean failed;
     int count;
-    private static int RUN_TIME_SEC = 1*_TestUtil.getRandomMultiplier();
+    private static int RUN_TIME_SEC = 1 * RANDOM_MULTIPLIER;
     private TimedThread[] allThreads;
 
     abstract public void doWork() throws Throwable;
Index: lucene/src/test/org/apache/lucene/index/TestStressIndexing2.java
===================================================================
--- lucene/src/test/org/apache/lucene/index/TestStressIndexing2.java	(revision 979588)
+++ lucene/src/test/org/apache/lucene/index/TestStressIndexing2.java	(working copy)
@@ -99,7 +99,8 @@
 
     r = newRandom();
 
-    for (int i=0; i<3*_TestUtil.getRandomMultiplier(); i++) {  // increase iterations for better testing
+    int num = 3 * RANDOM_MULTIPLIER;
+    for (int i = 0; i < num; i++) { // increase iterations for better testing
       sameFieldOrder=r.nextBoolean();
       mergeFactor=r.nextInt(3)+2;
       maxBufferedDocs=r.nextInt(3)+2;
Index: lucene/src/test/org/apache/lucene/index/TestTransactions.java
===================================================================
--- lucene/src/test/org/apache/lucene/index/TestTransactions.java	(revision 979588)
+++ lucene/src/test/org/apache/lucene/index/TestTransactions.java	(working copy)
@@ -44,7 +44,7 @@
 
   private static abstract class TimedThread extends Thread {
     volatile boolean failed;
-    private static float RUN_TIME_SEC = 0.5f*_TestUtil.getRandomMultiplier();
+    private static float RUN_TIME_SEC = 0.5f * RANDOM_MULTIPLIER;
     private TimedThread[] allThreads;
 
     abstract public void doWork() throws Throwable;
Index: lucene/src/test/org/apache/lucene/index/codecs/preflex/TestSurrogates.java
===================================================================
--- lucene/src/test/org/apache/lucene/index/codecs/preflex/TestSurrogates.java	(revision 979588)
+++ lucene/src/test/org/apache/lucene/index/codecs/preflex/TestSurrogates.java	(working copy)
@@ -135,7 +135,8 @@
       System.out.println("\nTEST: top now seek");
     }
 
-    for(int iter=0;iter<100*_TestUtil.getRandomMultiplier();iter++) {
+    int num = 100 * RANDOM_MULTIPLIER;
+    for (int iter = 0; iter < num; iter++) {
 
       // pick random field+term
       int spot = r.nextInt(fieldTerms.size());
@@ -197,7 +198,8 @@
     }
 
     {
-      for(int iter=0;iter<100*_TestUtil.getRandomMultiplier();iter++) {
+      int num = 100 * RANDOM_MULTIPLIER;
+      for (int iter = 0; iter < num; iter++) {
       
         // seek to random spot
         String field = ("f" + r.nextInt(numField)).intern();
@@ -288,7 +290,7 @@
 
     for(int f=0;f<numField;f++) {
       String field = "f" + f;
-      final int numTerms = 10000*_TestUtil.getRandomMultiplier();
+      final int numTerms = 10000 * RANDOM_MULTIPLIER;
 
       final Set<String> uniqueTerms = new HashSet<String>();
 
Index: lucene/src/test/org/apache/lucene/search/TestBoolean2.java
===================================================================
--- lucene/src/test/org/apache/lucene/search/TestBoolean2.java	(revision 979588)
+++ lucene/src/test/org/apache/lucene/search/TestBoolean2.java	(working copy)
@@ -208,7 +208,8 @@
     try {
 
       // increase number of iterations for more complete testing
-      for (int i=0; i<50*_TestUtil.getRandomMultiplier(); i++) {
+      int num = 50 * RANDOM_MULTIPLIER;
+      for (int i=0; i<num; i++) {
         int level = rnd.nextInt(3);
         q1 = randBoolQuery(new Random(rnd.nextLong()), rnd.nextBoolean(), level, field, vals, null);
         
Index: lucene/src/test/org/apache/lucene/search/TestBooleanMinShouldMatch.java
===================================================================
--- lucene/src/test/org/apache/lucene/search/TestBooleanMinShouldMatch.java	(revision 979588)
+++ lucene/src/test/org/apache/lucene/search/TestBooleanMinShouldMatch.java	(working copy)
@@ -17,9 +17,7 @@
  * limitations under the License.
  */
 
-
 import org.apache.lucene.util.LuceneTestCase;
-import org.apache.lucene.util._TestUtil;
 import org.apache.lucene.document.Document;
 import org.apache.lucene.document.Field;
 import org.apache.lucene.index.IndexReader;
@@ -318,7 +316,8 @@
 
 
       // increase number of iterations for more complete testing      
-      for (int i=0; i<50*_TestUtil.getRandomMultiplier(); i++) {
+      int num = 50 * RANDOM_MULTIPLIER;
+      for (int i=0; i<num; i++) {
         int lev = rnd.nextInt(maxLev);
         final long seed = rnd.nextLong();
         BooleanQuery q1 = TestBoolean2.randBoolQuery(new Random(seed), true, lev, field, vals, null);
Index: lucene/src/test/org/apache/lucene/search/TestCustomSearcherSort.java
===================================================================
--- lucene/src/test/org/apache/lucene/search/TestCustomSearcherSort.java	(revision 979588)
+++ lucene/src/test/org/apache/lucene/search/TestCustomSearcherSort.java	(working copy)
@@ -33,21 +33,15 @@
 import org.apache.lucene.store.Directory;
 import org.apache.lucene.store.RAMDirectory;
 import org.apache.lucene.util.LuceneTestCase;
-import org.apache.lucene.util._TestUtil;
 
-/**
- * Unit test for sorting code.
- * 
- */
-
-public class TestCustomSearcherSort extends LuceneTestCase implements
-    Serializable {
+/** Unit test for sorting code. */
+public class TestCustomSearcherSort extends LuceneTestCase implements Serializable {
   
   private Directory index = null;
   private IndexReader reader;
   private Query query = null;
   // reduced from 20000 to 2000 to speed up test...
-  private final static int INDEX_SIZE = 2000 * _TestUtil.getRandomMultiplier();
+  private final static int INDEX_SIZE = 2000 * RANDOM_MULTIPLIER;
   
   /**
    * Create index and query for test cases.
Index: lucene/src/test/org/apache/lucene/search/TestFieldCache.java
===================================================================
--- lucene/src/test/org/apache/lucene/search/TestFieldCache.java	(revision 979588)
+++ lucene/src/test/org/apache/lucene/search/TestFieldCache.java	(working copy)
@@ -37,7 +37,7 @@
 
 public class TestFieldCache extends LuceneTestCase {
   protected IndexReader reader;
-  private int NUM_DOCS;
+  private static final int NUM_DOCS = 1000 * RANDOM_MULTIPLIER;
   private String[] unicodeStrings;
 
   public TestFieldCache(String s) {
@@ -48,7 +48,6 @@
   protected void setUp() throws Exception {
     super.setUp();
     Random r = newRandom();
-    NUM_DOCS = 1000 * _TestUtil.getRandomMultiplier();
     RAMDirectory directory = new RAMDirectory();
     RandomIndexWriter writer= new RandomIndexWriter(r, directory);
     long theLong = Long.MAX_VALUE;
Index: lucene/src/test/org/apache/lucene/search/TestMultiValuedNumericRangeQuery.java
===================================================================
--- lucene/src/test/org/apache/lucene/search/TestMultiValuedNumericRangeQuery.java	(revision 979588)
+++ lucene/src/test/org/apache/lucene/search/TestMultiValuedNumericRangeQuery.java	(working copy)
@@ -29,7 +29,6 @@
 import org.apache.lucene.index.RandomIndexWriter;
 import org.apache.lucene.store.RAMDirectory;
 import org.apache.lucene.util.LuceneTestCase;
-import org.apache.lucene.util._TestUtil;
 
 public class TestMultiValuedNumericRangeQuery extends LuceneTestCase {
 
@@ -38,7 +37,6 @@
    * NumericRangeQuery (see SOLR-1322 for discussion) and the multiple precision terms per numeric value
    * do not interfere with multiple numeric values.
    */
-
   public void testMultiValuedNRQ() throws Exception {
     final Random rnd = newRandom();
 
@@ -47,7 +45,8 @@
     
     DecimalFormat format = new DecimalFormat("00000000000", new DecimalFormatSymbols(Locale.US));
     
-    for (int l=0; l<5000*_TestUtil.getRandomMultiplier(); l++) {
+    int num = 5000 * RANDOM_MULTIPLIER;
+    for (int l = 0; l < num; l++) {
       Document doc = new Document();
       for (int m=0, c=rnd.nextInt(10); m<=c; m++) {
         int value = rnd.nextInt(Integer.MAX_VALUE);
@@ -60,7 +59,8 @@
     writer.close();
     
     Searcher searcher=new IndexSearcher(reader);
-    for (int i=0; i<50*_TestUtil.getRandomMultiplier(); i++) {
+    num = 50 * RANDOM_MULTIPLIER;
+    for (int i = 0; i < num; i++) {
       int lower=rnd.nextInt(Integer.MAX_VALUE);
       int upper=rnd.nextInt(Integer.MAX_VALUE);
       if (lower>upper) {
Index: lucene/src/test/org/apache/lucene/search/TestNumericRangeQuery32.java
===================================================================
--- lucene/src/test/org/apache/lucene/search/TestNumericRangeQuery32.java	(revision 979588)
+++ lucene/src/test/org/apache/lucene/search/TestNumericRangeQuery32.java	(working copy)
@@ -32,7 +32,6 @@
 import org.apache.lucene.util.BytesRef;
 import org.apache.lucene.util.LuceneTestCaseJ4;
 import org.apache.lucene.util.NumericUtils;
-import org.apache.lucene.util._TestUtil;
 
 import org.junit.Test;
 import org.junit.AfterClass;
@@ -45,7 +44,7 @@
   // shift the starting of the values to the left, to also have negative values:
   private static final int startOffset = - 1 << 15;
   // number of docs to generate for testing
-  private static final int noDocs = 10000*_TestUtil.getRandomMultiplier();
+  private static final int noDocs = 10000 * RANDOM_MULTIPLIER;
   
   private static RAMDirectory directory = null;
   private static IndexReader reader = null;
@@ -333,7 +332,8 @@
     final Random rnd=newRandom();
     String field="field"+precisionStep;
     int termCountT=0,termCountC=0;
-    for (int i=0; i<10*_TestUtil.getRandomMultiplier(); i++) {
+    int num = 10 * RANDOM_MULTIPLIER;
+    for (int i = 0; i < num; i++) {
       int lower=(int)(rnd.nextDouble()*noDocs*distance)+startOffset;
       int upper=(int)(rnd.nextDouble()*noDocs*distance)+startOffset;
       if (lower>upper) {
@@ -411,7 +411,8 @@
     final Random rnd=newRandom();
     String field="ascfield"+precisionStep;
     // 10 random tests
-    for (int i=0; i<10*_TestUtil.getRandomMultiplier(); i++) {
+    int  num = 10 * RANDOM_MULTIPLIER;
+    for (int  i =0;  i< num; i++) {
       int lower=(int)(rnd.nextDouble()*noDocs - noDocs/2);
       int upper=(int)(rnd.nextDouble()*noDocs - noDocs/2);
       if (lower>upper) {
@@ -487,7 +488,8 @@
     String field="field"+precisionStep;
     // 10 random tests, the index order is ascending,
     // so using a reverse sort field should retun descending documents
-    for (int i=0; i<10*_TestUtil.getRandomMultiplier(); i++) {
+    int num = 10 * RANDOM_MULTIPLIER;
+    for (int i = 0; i < num; i++) {
       int lower=(int)(rnd.nextDouble()*noDocs*distance)+startOffset;
       int upper=(int)(rnd.nextDouble()*noDocs*distance)+startOffset;
       if (lower>upper) {
Index: lucene/src/test/org/apache/lucene/search/TestNumericRangeQuery64.java
===================================================================
--- lucene/src/test/org/apache/lucene/search/TestNumericRangeQuery64.java	(revision 979588)
+++ lucene/src/test/org/apache/lucene/search/TestNumericRangeQuery64.java	(working copy)
@@ -31,7 +31,6 @@
 import org.apache.lucene.util.BytesRef;
 import org.apache.lucene.util.LuceneTestCaseJ4;
 import org.apache.lucene.util.NumericUtils;
-import org.apache.lucene.util._TestUtil;
 
 import org.junit.Test;
 import org.junit.AfterClass;
@@ -44,7 +43,7 @@
   // shift the starting of the values to the left, to also have negative values:
   private static final long startOffset = - 1L << 31;
   // number of docs to generate for testing
-  private static final int noDocs = 10000*_TestUtil.getRandomMultiplier();
+  private static final int noDocs = 10000 * RANDOM_MULTIPLIER;
   
   private static RAMDirectory directory = null;
   private static IndexReader reader = null;
@@ -352,7 +351,8 @@
     final Random rnd=newRandom();
     String field="field"+precisionStep;
     int termCountT=0,termCountC=0;
-    for (int i=0; i<10*_TestUtil.getRandomMultiplier(); i++) {
+    int num = 10 * RANDOM_MULTIPLIER;
+    for (int i = 0; i < num; i++) {
       long lower=(long)(rnd.nextDouble()*noDocs*distance)+startOffset;
       long upper=(long)(rnd.nextDouble()*noDocs*distance)+startOffset;
       if (lower>upper) {
@@ -435,7 +435,8 @@
     final Random rnd=newRandom();
     String field="ascfield"+precisionStep;
     // 10 random tests
-    for (int i=0; i<10*_TestUtil.getRandomMultiplier(); i++) {
+    int num = 10 * RANDOM_MULTIPLIER;
+    for (int i = 0; i < num; i++) {
       long lower=(long)(rnd.nextDouble()*noDocs - noDocs/2);
       long upper=(long)(rnd.nextDouble()*noDocs - noDocs/2);
       if (lower>upper) {
@@ -521,7 +522,8 @@
     String field="field"+precisionStep;
     // 10 random tests, the index order is ascending,
     // so using a reverse sort field should retun descending documents
-    for (int i=0; i<10*_TestUtil.getRandomMultiplier(); i++) {
+    int num = 10 * RANDOM_MULTIPLIER;
+    for (int i = 0; i < num; i++) {
       long lower=(long)(rnd.nextDouble()*noDocs*distance)+startOffset;
       long upper=(long)(rnd.nextDouble()*noDocs*distance)+startOffset;
       if (lower>upper) {
Index: lucene/src/test/org/apache/lucene/search/TestPhraseQuery.java
===================================================================
--- lucene/src/test/org/apache/lucene/search/TestPhraseQuery.java	(revision 979588)
+++ lucene/src/test/org/apache/lucene/search/TestPhraseQuery.java	(working copy)
@@ -608,8 +608,8 @@
 
     Random r = random;
 
-    int NUM_DOCS = 10*_TestUtil.getRandomMultiplier();
-    for(int i=0;i<NUM_DOCS;i++) {
+    int NUM_DOCS = 10 * RANDOM_MULTIPLIER;
+    for (int i = 0; i < NUM_DOCS; i++) {
       // must be > 4096 so it spans multiple chunks
       int termCount = _TestUtil.nextInt(r, 10000, 30000);
 
@@ -655,7 +655,8 @@
     w.close();
 
     // now search
-    for(int i=0;i<100*_TestUtil.getRandomMultiplier();i++) {
+    int num = 100 * RANDOM_MULTIPLIER;
+    for(int i=0;i<num;i++) {
       int docID = r.nextInt(docs.size());
       List<String> doc = docs.get(docID);
       
Index: lucene/src/test/org/apache/lucene/search/TestPrefixRandom.java
===================================================================
--- lucene/src/test/org/apache/lucene/search/TestPrefixRandom.java	(revision 979588)
+++ lucene/src/test/org/apache/lucene/search/TestPrefixRandom.java	(working copy)
@@ -56,7 +56,8 @@
     Field field = new Field("field", "", Field.Store.NO, Field.Index.ANALYZED);
     doc.add(field);
 
-    for (int i = 0; i < 2000*_TestUtil.getRandomMultiplier(); i++) {
+    int num = 2000 * RANDOM_MULTIPLIER;
+    for (int i = 0; i < num; i++) {
       field.setValue(_TestUtil.randomUnicodeString(random, 10));
       writer.addDocument(doc);
     }
@@ -111,7 +112,8 @@
   
   /** test a bunch of random prefixes */
   public void testPrefixes() throws Exception {
-      for (int i = 0; i < 1000*_TestUtil.getRandomMultiplier(); i++)
+      int num = 1000 * RANDOM_MULTIPLIER;
+      for (int i = 0; i < num; i++)
         assertSame(_TestUtil.randomUnicodeString(random, 5));
   }
   
Index: lucene/src/test/org/apache/lucene/search/TestRegexpRandom.java
===================================================================
--- lucene/src/test/org/apache/lucene/search/TestRegexpRandom.java	(revision 979588)
+++ lucene/src/test/org/apache/lucene/search/TestRegexpRandom.java	(working copy)
@@ -23,17 +23,14 @@
 import java.util.Locale;
 import java.util.Random;
 
-import org.apache.lucene.analysis.MockAnalyzer;
 import org.apache.lucene.document.Document;
 import org.apache.lucene.document.Field;
 import org.apache.lucene.index.IndexReader;
-import org.apache.lucene.index.IndexWriterConfig;
 import org.apache.lucene.index.RandomIndexWriter;
 import org.apache.lucene.index.Term;
 import org.apache.lucene.store.Directory;
 import org.apache.lucene.store.RAMDirectory;
 import org.apache.lucene.util.LuceneTestCase;
-import org.apache.lucene.util._TestUtil;
 
 /**
  * Create an index with terms from 0000-9999.
@@ -101,7 +98,8 @@
   }
   
   public void testRegexps() throws Exception {
-    for (int i = 0; i < 100*_TestUtil.getRandomMultiplier(); i++) {
+    int num = 100 * RANDOM_MULTIPLIER;
+    for (int i = 0; i < num; i++) {
       assertPatternHits("NNNN", 1);
       assertPatternHits(".NNN", 10);
       assertPatternHits("N.NN", 10);
@@ -109,7 +107,8 @@
       assertPatternHits("NNN.", 10);
     }
     
-    for (int i = 0; i < 10*_TestUtil.getRandomMultiplier(); i++) {
+    num = 10 * RANDOM_MULTIPLIER;
+    for (int i = 0; i < num; i++) {
       assertPatternHits(".{1,2}NN", 100);
       assertPatternHits("N.{1,2}N", 100);
       assertPatternHits("NN.{1,2}", 100);
Index: lucene/src/test/org/apache/lucene/search/TestRegexpRandom2.java
===================================================================
--- lucene/src/test/org/apache/lucene/search/TestRegexpRandom2.java	(revision 979588)
+++ lucene/src/test/org/apache/lucene/search/TestRegexpRandom2.java	(working copy)
@@ -66,7 +66,8 @@
     Field field = new Field("field", "", Field.Store.NO, Field.Index.ANALYZED);
     doc.add(field);
     List<String> terms = new ArrayList<String>();
-    for (int i = 0; i < 2000*_TestUtil.getRandomMultiplier(); i++) {
+    int num = 2000 * RANDOM_MULTIPLIER;
+    for (int i = 0; i < num; i++) {
       String s = _TestUtil.randomUnicodeString(random);
       field.setValue(s);
       terms.add(s);
@@ -136,7 +137,8 @@
   /** test a bunch of random regular expressions */
   public void testRegexps() throws Exception {
 
-    for (int i = 0; i < 1000*_TestUtil.getRandomMultiplier(); i++) {
+    int num = 1000 * RANDOM_MULTIPLIER;
+    for (int i = 0; i < num; i++) {
       String reg = AutomatonTestUtil.randomRegexp(random).toString();
       assertSame(reg);
     }
Index: lucene/src/test/org/apache/lucene/search/TestScorerPerf.java
===================================================================
--- lucene/src/test/org/apache/lucene/search/TestScorerPerf.java	(revision 979588)
+++ lucene/src/test/org/apache/lucene/search/TestScorerPerf.java	(working copy)
@@ -2,7 +2,6 @@
 
 import org.apache.lucene.util.DocIdBitSet;
 import org.apache.lucene.util.LuceneTestCase;
-import org.apache.lucene.util._TestUtil;
 
 import java.util.Random;
 import java.util.BitSet;
@@ -319,9 +318,9 @@
     r = newRandom();
     createDummySearcher();
     validate=true;
-    sets=randBitSets(1000*_TestUtil.getRandomMultiplier(),10*_TestUtil.getRandomMultiplier());
-    doConjunctions(10000*_TestUtil.getRandomMultiplier(),5*_TestUtil.getRandomMultiplier());
-    doNestedConjunctions(10000*_TestUtil.getRandomMultiplier(),3*_TestUtil.getRandomMultiplier(),3*_TestUtil.getRandomMultiplier());
+    sets=randBitSets(1000 * RANDOM_MULTIPLIER, 10 * RANDOM_MULTIPLIER);
+    doConjunctions(10000 * RANDOM_MULTIPLIER, 5 * RANDOM_MULTIPLIER);
+    doNestedConjunctions(10000 * RANDOM_MULTIPLIER, 3 * RANDOM_MULTIPLIER, 3 * RANDOM_MULTIPLIER);
     s.close();
   }
 
Index: lucene/src/test/org/apache/lucene/search/TestSort.java
===================================================================
--- lucene/src/test/org/apache/lucene/search/TestSort.java	(revision 979588)
+++ lucene/src/test/org/apache/lucene/search/TestSort.java	(working copy)
@@ -48,7 +48,6 @@
 import org.apache.lucene.store.MockRAMDirectory;
 import org.apache.lucene.util.DocIdBitSet;
 import org.apache.lucene.util.LuceneTestCase;
-import org.apache.lucene.util._TestUtil;
 
 /**
  * Unit tests for sorting code.
@@ -60,7 +59,7 @@
 
 public class TestSort extends LuceneTestCase implements Serializable {
 
-  private static final int NUM_STRINGS = 6000*_TestUtil.getRandomMultiplier();
+  private static final int NUM_STRINGS = 6000 * RANDOM_MULTIPLIER;
   private Searcher full;
   private Searcher searchX;
   private Searcher searchY;
Index: lucene/src/test/org/apache/lucene/search/TestThreadSafe.java
===================================================================
--- lucene/src/test/org/apache/lucene/search/TestThreadSafe.java	(revision 979588)
+++ lucene/src/test/org/apache/lucene/search/TestThreadSafe.java	(working copy)
@@ -17,7 +17,6 @@
  */
 
 import org.apache.lucene.util.LuceneTestCase;
-import org.apache.lucene.util._TestUtil;
 import org.apache.lucene.store.Directory;
 import org.apache.lucene.store.RAMDirectory;
 import org.apache.lucene.index.IndexReader;
@@ -148,7 +147,8 @@
     buildDir(dir1, 15, 5, 2000);
 
     // do many small tests so the thread locals go away inbetween
-    for (int i=0; i<100*_TestUtil.getRandomMultiplier(); i++) {
+    int num = 100 * RANDOM_MULTIPLIER;
+    for (int i = 0; i < num; i++) {
       ir1 = IndexReader.open(dir1, false);
       doTest(10,100);
     }
Index: lucene/src/test/org/apache/lucene/search/TestWildcardRandom.java
===================================================================
--- lucene/src/test/org/apache/lucene/search/TestWildcardRandom.java	(revision 979588)
+++ lucene/src/test/org/apache/lucene/search/TestWildcardRandom.java	(working copy)
@@ -31,7 +31,6 @@
 import org.apache.lucene.store.Directory;
 import org.apache.lucene.store.RAMDirectory;
 import org.apache.lucene.util.LuceneTestCase;
-import org.apache.lucene.util._TestUtil;
 
 /**
  * Create an index with terms from 0000-9999.
@@ -98,7 +97,8 @@
   }
   
   public void testWildcards() throws Exception {;
-    for (int i = 0; i < 100*_TestUtil.getRandomMultiplier(); i++) {
+    int num = 100 * RANDOM_MULTIPLIER;
+    for (int i = 0; i < num; i++) {
       assertPatternHits("NNNN", 1);
       assertPatternHits("?NNN", 10);
       assertPatternHits("N?NN", 10);
@@ -106,7 +106,8 @@
       assertPatternHits("NNN?", 10);
     }
     
-    for (int i = 0; i < 10*_TestUtil.getRandomMultiplier(); i++) {
+    num = 10 * RANDOM_MULTIPLIER;
+    for (int i = 0; i < num; i++) {
       assertPatternHits("??NN", 100);
       assertPatternHits("N??N", 100);
       assertPatternHits("NN??", 100);
Index: lucene/src/test/org/apache/lucene/store/TestWindowsMMap.java
===================================================================
--- lucene/src/test/org/apache/lucene/store/TestWindowsMMap.java	(revision 979588)
+++ lucene/src/test/org/apache/lucene/store/TestWindowsMMap.java	(working copy)
@@ -17,12 +17,10 @@
  * limitations under the License.
  */
 
-import java.util.Collections;
 import java.util.Random;
 import java.io.File;
 
 import org.apache.lucene.util.LuceneTestCase;
-import org.apache.lucene.util._TestUtil;
 
 import org.apache.lucene.analysis.MockAnalyzer;
 import org.apache.lucene.document.Document;
@@ -84,7 +82,8 @@
     writer.commit();
     IndexSearcher searcher = new IndexSearcher(dir, true);
     
-    for(int dx = 0; dx < 1000*_TestUtil.getRandomMultiplier(); dx ++) {
+    int num = 1000 * RANDOM_MULTIPLIER;
+    for(int dx = 0; dx < num; dx ++) {
       String f = randomField();
       Document doc = new Document();
       doc.add(new Field("data", f, Field.Store.YES, Field.Index.ANALYZED));	
Index: lucene/src/test/org/apache/lucene/util/LuceneTestCase.java
===================================================================
--- lucene/src/test/org/apache/lucene/util/LuceneTestCase.java	(revision 979588)
+++ lucene/src/test/org/apache/lucene/util/LuceneTestCase.java	(working copy)
@@ -72,6 +72,15 @@
   /** Create indexes in this directory, optimally use a subdir, named after the test */
   public static final File TEMP_DIR = LuceneTestCaseJ4.TEMP_DIR;
 
+  /** Gets the codec to run tests with. */
+  public static final String TEST_CODEC = LuceneTestCaseJ4.TEST_CODEC;
+
+  /**
+   * A random multiplier which you should use when writing random tests:
+   * multiply it by the number of iterations
+   */
+  public static final int RANDOM_MULTIPLIER = LuceneTestCaseJ4.RANDOM_MULTIPLIER;
+  
   private int savedBoolMaxClauseCount;
   
   private volatile Thread.UncaughtExceptionHandler savedUncaughtExceptionHandler = null;
@@ -120,7 +129,7 @@
     savedBoolMaxClauseCount = BooleanQuery.getMaxClauseCount();
     savedDefaultCodec = CodecProvider.getDefaultCodec();
 
-    codec = _TestUtil.getTestCodec();
+    codec = TEST_CODEC;
     if (codec.equals("random"))
       codec = CodecProvider.CORE_CODECS[seedRnd.nextInt(CodecProvider.CORE_CODECS.length)];
 
@@ -318,7 +327,7 @@
       seed = null;
       super.runBare();
     } catch (Throwable e) {
-      if (_TestUtil.getTestCodec().equals("random")) {
+      if (TEST_CODEC.equals("random")) {
         System.out.println("NOTE: random codec of testcase '" + getName() + "' was: " + codec);
       }
       if (seed != null) {
Index: lucene/src/test/org/apache/lucene/util/LuceneTestCaseJ4.java
===================================================================
--- lucene/src/test/org/apache/lucene/util/LuceneTestCaseJ4.java	(revision 979588)
+++ lucene/src/test/org/apache/lucene/util/LuceneTestCaseJ4.java	(working copy)
@@ -114,6 +114,18 @@
     TEMP_DIR = new File(s);
   }
 
+  // by default we randomly pick a different codec for
+  // each test case (non-J4 tests) and each test class (J4
+  // tests)
+  /** Gets the codec to run tests with. */
+  public static final String TEST_CODEC = System.getProperty("tests.codec", "random");
+
+  /**
+   * A random multiplier which you should use when writing random tests:
+   * multiply it by the number of iterations
+   */
+  public static final int RANDOM_MULTIPLIER = Integer.parseInt(System.getProperty("random.multiplier", "1"));
+  
   private int savedBoolMaxClauseCount;
 
   private volatile Thread.UncaughtExceptionHandler savedUncaughtExceptionHandler = null;
@@ -164,7 +176,7 @@
   @BeforeClass
   public static void beforeClassLuceneTestCaseJ4() {
     savedDefaultCodec = CodecProvider.getDefaultCodec();
-    codec = _TestUtil.getTestCodec();
+    codec = TEST_CODEC;
     if (codec.equals("random"))
       codec = CodecProvider.CORE_CODECS[seedRnd.nextInt(CodecProvider.CORE_CODECS.length)];
 
@@ -483,7 +495,7 @@
       System.out.println("NOTE: random static seed of testclass '" + getName() + "' was: " + staticSeed);
     }
     
-    if (_TestUtil.getTestCodec().equals("random")) {
+    if (TEST_CODEC.equals("random")) {
       System.out.println("NOTE: random codec of testcase '" + getName() + "' was: " + codec);
     }
 
Index: lucene/src/test/org/apache/lucene/util/TestArrayUtil.java
===================================================================
--- lucene/src/test/org/apache/lucene/util/TestArrayUtil.java	(revision 979588)
+++ lucene/src/test/org/apache/lucene/util/TestArrayUtil.java	(working copy)
@@ -49,7 +49,8 @@
 
   public void testInvalidElementSizes() {
     final Random r = newRandom();
-    for(int iter=0;iter<10000*_TestUtil.getRandomMultiplier();iter++) {
+    int num = 10000 * RANDOM_MULTIPLIER;
+    for (int iter = 0; iter < num; iter++) {
       final int minTargetSize = r.nextInt(Integer.MAX_VALUE);
       final int elemSize = r.nextInt(11);
       final int v = ArrayUtil.oversize(minTargetSize, elemSize);
Index: lucene/src/test/org/apache/lucene/util/TestIndexableBinaryStringTools.java
===================================================================
--- lucene/src/test/org/apache/lucene/util/TestIndexableBinaryStringTools.java	(revision 979588)
+++ lucene/src/test/org/apache/lucene/util/TestIndexableBinaryStringTools.java	(working copy)
@@ -22,8 +22,8 @@
 import java.nio.ByteBuffer;
 
 public class TestIndexableBinaryStringTools extends LuceneTestCase {
-  private static final int NUM_RANDOM_TESTS = 2000*_TestUtil.getRandomMultiplier();
-  private static final int MAX_RANDOM_BINARY_LENGTH = 300*_TestUtil.getRandomMultiplier();
+  private static final int NUM_RANDOM_TESTS = 2000 * RANDOM_MULTIPLIER;
+  private static final int MAX_RANDOM_BINARY_LENGTH = 300 * RANDOM_MULTIPLIER;
   
   /** @deprecated remove this test for Lucene 4.0 */
   @Deprecated
Index: lucene/src/test/org/apache/lucene/util/TestNumericUtils.java
===================================================================
--- lucene/src/test/org/apache/lucene/util/TestNumericUtils.java	(revision 979588)
+++ lucene/src/test/org/apache/lucene/util/TestNumericUtils.java	(working copy)
@@ -309,7 +309,7 @@
   
   public void testRandomSplit() throws Exception {
     final Random random = newRandom();
-    long num = 100L * _TestUtil.getRandomMultiplier();
+    long num = 100L * RANDOM_MULTIPLIER;
     for (long i=0; i < num; i++) {
       executeOneRandomSplit(random);
     }
@@ -317,7 +317,7 @@
   
   private void executeOneRandomSplit(final Random random) throws Exception {
     long lower = randomLong(random);
-    long len = (long) random.nextInt(16384*1024); // not too large bitsets, else OOME!
+    long len = random.nextInt(16384*1024); // not too large bitsets, else OOME!
     while (lower + len < lower) { // overflow
       lower >>= 1;
     }
Index: lucene/src/test/org/apache/lucene/util/TestOpenBitSet.java
===================================================================
--- lucene/src/test/org/apache/lucene/util/TestOpenBitSet.java	(revision 979588)
+++ lucene/src/test/org/apache/lucene/util/TestOpenBitSet.java	(working copy)
@@ -175,8 +175,8 @@
   // larger testsuite.
   public void testSmall() {
     rand = newRandom();
-    doRandomSets(1200*_TestUtil.getRandomMultiplier(),1000*_TestUtil.getRandomMultiplier(), 1);
-    doRandomSets(1200*_TestUtil.getRandomMultiplier(),1000*_TestUtil.getRandomMultiplier(), 2);
+    doRandomSets(1200 * RANDOM_MULTIPLIER, 1000 * RANDOM_MULTIPLIER, 1);
+    doRandomSets(1200 * RANDOM_MULTIPLIER, 1000 * RANDOM_MULTIPLIER, 2);
   }
 
   public void testBig() {
Index: lucene/src/test/org/apache/lucene/util/TestPriorityQueue.java
===================================================================
--- lucene/src/test/org/apache/lucene/util/TestPriorityQueue.java	(revision 979588)
+++ lucene/src/test/org/apache/lucene/util/TestPriorityQueue.java	(working copy)
@@ -37,7 +37,7 @@
     }
 
     public void testPQ() throws Exception {
-        testPQ(10000*_TestUtil.getRandomMultiplier(), newRandom());
+        testPQ(10000 * RANDOM_MULTIPLIER, newRandom());
     }
 
     public static void testPQ(int count, Random gen) {
Index: lucene/src/test/org/apache/lucene/util/TestSmallFloat.java
===================================================================
--- lucene/src/test/org/apache/lucene/util/TestSmallFloat.java	(revision 979588)
+++ lucene/src/test/org/apache/lucene/util/TestSmallFloat.java	(working copy)
@@ -72,9 +72,10 @@
   public void testFloatToByte() {
     Random rand = newRandom();
     // up iterations for more exhaustive test after changing something
-    for (int i=0; i<100000*_TestUtil.getRandomMultiplier(); i++) {
+    int num = 100000 * RANDOM_MULTIPLIER;
+    for (int i = 0; i < num; i++) {
       float f = Float.intBitsToFloat(rand.nextInt());
-      if (f!=f) continue;    // skip NaN
+      if (Float.isNaN(f)) continue;    // skip NaN
       byte b1 = orig_floatToByte(f);
       byte b2 = SmallFloat.floatToByte(f,3,15);
       byte b3 = SmallFloat.floatToByte315(f);
Index: lucene/src/test/org/apache/lucene/util/TestStringIntern.java
===================================================================
--- lucene/src/test/org/apache/lucene/util/TestStringIntern.java	(revision 979588)
+++ lucene/src/test/org/apache/lucene/util/TestStringIntern.java	(working copy)
@@ -44,7 +44,7 @@
     // makeStrings(100);  // realistic for perf testing
     int nThreads = 20;
     // final int iter=100000;
-    final int iter=1000000*_TestUtil.getRandomMultiplier();
+    final int iter = 1000000 * RANDOM_MULTIPLIER;
     
     // try native intern
     // StringHelper.interner = new StringInterner();
Index: lucene/src/test/org/apache/lucene/util/TestUnicodeUtil.java
===================================================================
--- lucene/src/test/org/apache/lucene/util/TestUnicodeUtil.java	(revision 979588)
+++ lucene/src/test/org/apache/lucene/util/TestUnicodeUtil.java	(working copy)
@@ -122,7 +122,8 @@
   public void testCodePointCount() {
     final Random r = newRandom();
     BytesRef utf8 = new BytesRef(20);
-    for(int i=0;i<50000*_TestUtil.getRandomMultiplier();i++) {
+    int num = 50000 * RANDOM_MULTIPLIER;
+    for (int i = 0; i < num; i++) {
       final String s = _TestUtil.randomUnicodeString(r);
       UnicodeUtil.UTF16toUTF8(s, 0, s.length(), utf8);
       assertEquals(s.codePointCount(0, s.length()),
@@ -135,7 +136,8 @@
     BytesRef utf8 = new BytesRef(20);
     IntsRef utf32 = new IntsRef(20);
     int[] codePoints = new int[20];
-    for(int i=0;i<50000*_TestUtil.getRandomMultiplier();i++) {
+    int num = 50000 * RANDOM_MULTIPLIER;
+    for (int i = 0; i < num; i++) {
       final String s = _TestUtil.randomUnicodeString(r);
       UnicodeUtil.UTF16toUTF8(s, 0, s.length(), utf8);
       UnicodeUtil.UTF8toUTF32(utf8, utf32);
Index: lucene/src/test/org/apache/lucene/util/_TestUtil.java
===================================================================
--- lucene/src/test/org/apache/lucene/util/_TestUtil.java	(revision 979588)
+++ lucene/src/test/org/apache/lucene/util/_TestUtil.java	(working copy)
@@ -41,20 +41,21 @@
 
   public static void rmDir(File dir) throws IOException {
     if (dir.exists()) {
-      File[] files = dir.listFiles();
-      for (int i = 0; i < files.length; i++) {
-        if (!files[i].delete()) {
-          throw new IOException("could not delete " + files[i]);
+      for (File f : dir.listFiles()) {
+        if (f.isDirectory()) {
+          rmDir(f);
+        } else {
+          if (!f.delete()) {
+            throw new IOException("could not delete " + f);
+          }
         }
       }
-      dir.delete();
+      if (!dir.delete()) {
+        throw new IOException("could not delete " + dir);
+      }
     }
   }
 
-  public static void rmDir(String dir) throws IOException {
-    rmDir(new File(dir));
-  }
-
   public static void syncConcurrentMerges(IndexWriter writer) {
     syncConcurrentMerges(writer.getConfig().getMergeScheduler());
   }
@@ -81,39 +82,6 @@
       return true;
   }
 
-  /** Use only for testing.
-   *  @deprecated -- in 3.0 we can use Arrays.toString
-   *  instead */
-  @Deprecated
-  public static String arrayToString(int[] array) {
-    StringBuilder buf = new StringBuilder();
-    buf.append("[");
-    for(int i=0;i<array.length;i++) {
-      if (i > 0) {
-        buf.append(" ");
-      }
-      buf.append(array[i]);
-    }
-    buf.append("]");
-    return buf.toString();
-  }
-
-  /** Use only for testing.
-   *  @deprecated -- in 3.0 we can use Arrays.toString
-   *  instead */
-  @Deprecated
-  public static String arrayToString(Object[] array) {
-    StringBuilder buf = new StringBuilder();
-    buf.append("[");
-    for(int i=0;i<array.length;i++) {
-      if (i > 0) {
-        buf.append(" ");
-      }
-      buf.append(array[i]);
-    }
-    buf.append("]");
-    return buf.toString();
-  }
   /** start and end are BOTH inclusive */
   public static int nextInt(Random r, int start, int end) {
     return start + r.nextInt(end-start+1);
@@ -216,20 +184,6 @@
     return sb.toString();
   }
 
-  /** gets a random multiplier, which you should use when writing
-   *  random tests: multiply it by the number of iterations */
-  public static int getRandomMultiplier() {
-    return Integer.parseInt(System.getProperty("random.multiplier", "1"));
-  }
-
-  /** gets the codec to run tests with */
-  public static String getTestCodec() {
-    // by default we randomly pick a different codec for
-    // each test case (non-J4 tests) and each test class (J4
-    // tests)
-    return System.getProperty("tests.codec", "random");
-  }
-
   public static CodecProvider alwaysCodec(final Codec c) {
     return new CodecProvider() {
       @Override
Index: lucene/src/test/org/apache/lucene/util/automaton/TestBasicOperations.java
===================================================================
--- lucene/src/test/org/apache/lucene/util/automaton/TestBasicOperations.java	(revision 979588)
+++ lucene/src/test/org/apache/lucene/util/automaton/TestBasicOperations.java	(working copy)
@@ -19,7 +19,6 @@
 
 import org.apache.lucene.util.LuceneTestCase;
 import org.apache.lucene.util.UnicodeUtil;
-import org.apache.lucene.util._TestUtil;
 
 import java.util.Random;
 
@@ -87,8 +86,8 @@
 
   public void testGetRandomAcceptedString() throws Throwable {
     final Random r = newRandom();
-    final int ITER1 = 100*_TestUtil.getRandomMultiplier();
-    final int ITER2 = 100*_TestUtil.getRandomMultiplier();
+    final int ITER1 = 100 * RANDOM_MULTIPLIER;
+    final int ITER2 = 100 * RANDOM_MULTIPLIER;
     for(int i=0;i<ITER1;i++) {
 
       final RegExp re = AutomatonTestUtil.randomRegexp(r);
Index: lucene/src/test/org/apache/lucene/util/automaton/TestDeterminism.java
===================================================================
--- lucene/src/test/org/apache/lucene/util/automaton/TestDeterminism.java	(revision 979588)
+++ lucene/src/test/org/apache/lucene/util/automaton/TestDeterminism.java	(working copy)
@@ -20,7 +20,6 @@
 import java.util.Random;
 
 import org.apache.lucene.util.LuceneTestCase;
-import org.apache.lucene.util._TestUtil;
 
 /**
  * Not thorough, but tries to test determinism correctness
@@ -37,7 +36,8 @@
   
   /** test a bunch of random regular expressions */
   public void testRegexps() throws Exception {
-      for (int i = 0; i < 500*_TestUtil.getRandomMultiplier(); i++)
+      int num = 500 * RANDOM_MULTIPLIER;
+      for (int i = 0; i < num; i++)
         assertAutomaton(AutomatonTestUtil.randomRegexp(random).toAutomaton());
   }
   
Index: lucene/src/test/org/apache/lucene/util/automaton/TestDeterminizeLexicon.java
===================================================================
--- lucene/src/test/org/apache/lucene/util/automaton/TestDeterminizeLexicon.java	(revision 979588)
+++ lucene/src/test/org/apache/lucene/util/automaton/TestDeterminizeLexicon.java	(working copy)
@@ -22,7 +22,6 @@
 import java.util.List;
 import java.util.Random;
 
-import org.apache.lucene.util.BytesRef;
 import org.apache.lucene.util.LuceneTestCase;
 import org.apache.lucene.util._TestUtil;
 
@@ -37,7 +36,8 @@
   
   public void testLexicon() throws Exception {
     random = newRandom();
-    for (int i = 0; i < 3*_TestUtil.getRandomMultiplier(); i++) {
+    int num = 3 * RANDOM_MULTIPLIER;
+    for (int i = 0; i < num; i++) {
       automata.clear();
       terms.clear();
       for (int j = 0; j < 5000; j++) {
Index: lucene/src/test/org/apache/lucene/util/automaton/TestUTF32ToUTF8.java
===================================================================
--- lucene/src/test/org/apache/lucene/util/automaton/TestUTF32ToUTF8.java	(revision 979588)
+++ lucene/src/test/org/apache/lucene/util/automaton/TestUTF32ToUTF8.java	(working copy)
@@ -132,8 +132,8 @@
 
   public void testRandomRanges() throws Exception {
     final Random r = random;
-    int ITERS = 10*_TestUtil.getRandomMultiplier();
-    int ITERS_PER_DFA = 100*_TestUtil.getRandomMultiplier();
+    int ITERS = 10 * RANDOM_MULTIPLIER;
+    int ITERS_PER_DFA = 100 * RANDOM_MULTIPLIER;
     for(int iter=0;iter<ITERS;iter++) {
       int x1 = getCodeStart(r);
       int x2 = getCodeStart(r);
@@ -204,7 +204,8 @@
   }
   
   public void testRandomRegexes() throws Exception {
-    for (int i = 0; i < 250*_TestUtil.getRandomMultiplier(); i++) {
+    int num = 250 * RANDOM_MULTIPLIER;
+    for (int i = 0; i < num; i++) {
       assertAutomaton(AutomatonTestUtil.randomRegexp(random).toAutomaton());
     }
   }
@@ -214,7 +215,8 @@
     ByteRunAutomaton bra = new ByteRunAutomaton(automaton);
     final AutomatonTestUtil.RandomAcceptedStrings ras = new AutomatonTestUtil.RandomAcceptedStrings(automaton);
     
-    for (int i = 0; i < 1000*_TestUtil.getRandomMultiplier(); i++) {
+    int num = 1000 * RANDOM_MULTIPLIER;
+    for (int i = 0; i < num; i++) {
       final String string;
       if (random.nextBoolean()) {
         // likely not accepted
Index: lucene/src/test/org/apache/lucene/util/packed/TestPackedInts.java
===================================================================
--- lucene/src/test/org/apache/lucene/util/packed/TestPackedInts.java	(revision 979588)
+++ lucene/src/test/org/apache/lucene/util/packed/TestPackedInts.java	(working copy)
@@ -19,7 +19,6 @@
 
 import org.apache.lucene.store.*;
 import org.apache.lucene.util.LuceneTestCase;
-import org.apache.lucene.util._TestUtil;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -52,7 +51,8 @@
 
   public void testPackedInts() throws IOException {
     rnd = newRandom();
-    for(int iter=0;iter<5*_TestUtil.getRandomMultiplier();iter++) {
+    int num = 5 * RANDOM_MULTIPLIER;
+    for (int iter = 0; iter < num; iter++) {
       long ceil = 2;
       for(int nbits=1;nbits<63;nbits++) {
         final int valueCount = 100+rnd.nextInt(500);
Index: modules/analysis/common/src/test/org/apache/lucene/analysis/util/TestCharArrayMap.java
===================================================================
--- modules/analysis/common/src/test/org/apache/lucene/analysis/util/TestCharArrayMap.java	(revision 979588)
+++ modules/analysis/common/src/test/org/apache/lucene/analysis/util/TestCharArrayMap.java	(working copy)
@@ -22,7 +22,6 @@
 import org.apache.lucene.analysis.util.CharArrayMap;
 import org.apache.lucene.analysis.util.CharArraySet;
 import org.apache.lucene.util.LuceneTestCase;
-import org.apache.lucene.util._TestUtil;
 
 public class TestCharArrayMap extends LuceneTestCase {
   Random r = newRandom();
@@ -59,7 +58,8 @@
   }
 
   public void testCharArrayMap() {
-    for (int i=0; i<5*_TestUtil.getRandomMultiplier(); i++) {  // pump this up for more random testing
+    int num = 5 * RANDOM_MULTIPLIER;
+    for (int i = 0; i < num; i++) { // pump this up for more random testing
       doRandom(1000,false);
       doRandom(1000,true);      
     }