Index: contrib/queries/src/test/org/apache/lucene/search/trie/TestTrieRangeQuery.java
===================================================================
--- contrib/queries/src/test/org/apache/lucene/search/trie/TestTrieRangeQuery.java	(revision 740444)
+++ contrib/queries/src/test/org/apache/lucene/search/trie/TestTrieRangeQuery.java	(working copy)
@@ -36,11 +36,11 @@
 {
   private static final long distance=66666;
   
-  private static Random rnd=new Random();
-  private static RAMDirectory directory;
-  private static IndexSearcher searcher;
+  private static final Random seedRnd=new Random();
+  private static final RAMDirectory directory;
+  private static final IndexSearcher searcher;
   static {
-    try {
+    try {    
       directory = new RAMDirectory();
       IndexWriter writer = new IndexWriter(directory, new WhitespaceAnalyzer(),
       true, MaxFieldLength.UNLIMITED);
@@ -136,39 +136,48 @@
   }
   
   private void testRandomTrieAndClassicRangeQuery(final TrieUtils variant) throws Exception {
-    String field="field"+variant.TRIE_BITS;
-    // 50 random tests, the tests may also return 0 results, if min>max, but this is ok
-    for (int i=0; i<50; i++) {
-      long lower=(long)(rnd.nextDouble()*10000L*distance);
-      long upper=(long)(rnd.nextDouble()*10000L*distance);
-      // test inclusive range
-      TrieRangeQuery tq=new TrieRangeQuery(field, new Long(lower), new Long(upper), true, true, variant);
-      RangeQuery cq=new RangeQuery(field, variant.longToTrieCoded(lower), variant.longToTrieCoded(upper), true, true);
-      cq.setConstantScoreRewrite(true);
-      TopDocs tTopDocs = searcher.search(tq, 1);
-      TopDocs cTopDocs = searcher.search(cq, 1);
-      assertEquals("Returned count for TrieRangeQuery and RangeQuery must be equal", tTopDocs.totalHits, cTopDocs.totalHits );
-      // test exclusive range
-      tq=new TrieRangeQuery(field, new Long(lower), new Long(upper), false, false, variant);
-      cq=new RangeQuery(field, variant.longToTrieCoded(lower), variant.longToTrieCoded(upper), false, false);
-      cq.setConstantScoreRewrite(true);
-      tTopDocs = searcher.search(tq, 1);
-      cTopDocs = searcher.search(cq, 1);
-      assertEquals("Returned count for TrieRangeQuery and RangeQuery must be equal", tTopDocs.totalHits, cTopDocs.totalHits );
-      // test left exclusive range
-      tq=new TrieRangeQuery(field, new Long(lower), new Long(upper), false, true, variant);
-      cq=new RangeQuery(field, variant.longToTrieCoded(lower), variant.longToTrieCoded(upper), false, true);
-      cq.setConstantScoreRewrite(true);
-      tTopDocs = searcher.search(tq, 1);
-      cTopDocs = searcher.search(cq, 1);
-      assertEquals("Returned count for TrieRangeQuery and RangeQuery must be equal", tTopDocs.totalHits, cTopDocs.totalHits );
-      // test right exclusive range
-      tq=new TrieRangeQuery(field, new Long(lower), new Long(upper), true, false, variant);
-      cq=new RangeQuery(field, variant.longToTrieCoded(lower), variant.longToTrieCoded(upper), true, false);
-      cq.setConstantScoreRewrite(true);
-      tTopDocs = searcher.search(tq, 1);
-      cTopDocs = searcher.search(cq, 1);
-      assertEquals("Returned count for TrieRangeQuery and RangeQuery must be equal", tTopDocs.totalHits, cTopDocs.totalHits );
+    // for debugging, you can set the seed manually here, to the value that caused the error:
+    final long seed=seedRnd.nextLong();
+    final Random rnd=new Random(seed);
+
+    try {
+      String field="field"+variant.TRIE_BITS;
+      // 50 random tests, the tests may also return 0 results, if min>max, but this is ok
+      for (int i=0; i<50; i++) {
+        long lower=(long)(rnd.nextDouble()*10000L*distance);
+        long upper=(long)(rnd.nextDouble()*10000L*distance);
+        // test inclusive range
+        TrieRangeQuery tq=new TrieRangeQuery(field, new Long(lower), new Long(upper), true, true, variant);
+        RangeQuery cq=new RangeQuery(field, variant.longToTrieCoded(lower), variant.longToTrieCoded(upper), true, true);
+        cq.setConstantScoreRewrite(true);
+        TopDocs tTopDocs = searcher.search(tq, 1);
+        TopDocs cTopDocs = searcher.search(cq, 1);
+        assertEquals("Returned count for TrieRangeQuery and RangeQuery must be equal", tTopDocs.totalHits, cTopDocs.totalHits );
+        // test exclusive range
+        tq=new TrieRangeQuery(field, new Long(lower), new Long(upper), false, false, variant);
+        cq=new RangeQuery(field, variant.longToTrieCoded(lower), variant.longToTrieCoded(upper), false, false);
+        cq.setConstantScoreRewrite(true);
+        tTopDocs = searcher.search(tq, 1);
+        cTopDocs = searcher.search(cq, 1);
+        assertEquals("Returned count for TrieRangeQuery and RangeQuery must be equal", tTopDocs.totalHits, cTopDocs.totalHits );
+        // test left exclusive range
+        tq=new TrieRangeQuery(field, new Long(lower), new Long(upper), false, true, variant);
+        cq=new RangeQuery(field, variant.longToTrieCoded(lower), variant.longToTrieCoded(upper), false, true);
+        cq.setConstantScoreRewrite(true);
+        tTopDocs = searcher.search(tq, 1);
+        cTopDocs = searcher.search(cq, 1);
+        assertEquals("Returned count for TrieRangeQuery and RangeQuery must be equal", tTopDocs.totalHits, cTopDocs.totalHits );
+        // test right exclusive range
+        tq=new TrieRangeQuery(field, new Long(lower), new Long(upper), true, false, variant);
+        cq=new RangeQuery(field, variant.longToTrieCoded(lower), variant.longToTrieCoded(upper), true, false);
+        cq.setConstantScoreRewrite(true);
+        tTopDocs = searcher.search(tq, 1);
+        cTopDocs = searcher.search(cq, 1);
+        assertEquals("Returned count for TrieRangeQuery and RangeQuery must be equal", tTopDocs.totalHits, cTopDocs.totalHits );
+      }
+    } catch (Error e) {
+      System.out.println("Random seed (testRandomTrieAndClassicRangeQuery_"+variant.TRIE_BITS+"bit): "+seed);
+      throw e;
     }
   }
   
@@ -185,30 +194,39 @@
   }
   
   private void testRangeSplit(final TrieUtils variant) throws Exception {
-    String field="ascfield"+variant.TRIE_BITS;
-    // 50 random tests
-    for (int i=0; i<50; i++) {
-      long lower=(long)(rnd.nextDouble()*10000L);
-      long upper=(long)(rnd.nextDouble()*10000L);
-      if (lower>upper) {
-        long a=lower; lower=upper; upper=a;
+    // for debugging, you can set the seed manually here, to the value that caused the error:
+    final long seed=seedRnd.nextLong();
+    final Random rnd=new Random(seed);
+
+    try {
+      String field="ascfield"+variant.TRIE_BITS;
+      // 50 random tests
+      for (int i=0; i<50; i++) {
+        long lower=(long)(rnd.nextDouble()*10000L);
+        long upper=(long)(rnd.nextDouble()*10000L);
+        if (lower>upper) {
+          long a=lower; lower=upper; upper=a;
+        }
+        // test inclusive range
+        TrieRangeQuery tq=new TrieRangeQuery(field, new Long(lower), new Long(upper), true, true, variant);
+        TopDocs tTopDocs = searcher.search(tq, 1);
+        assertEquals("Returned count of range query must be equal to inclusive range length", tTopDocs.totalHits, upper-lower+1 );
+        // test exclusive range
+        tq=new TrieRangeQuery(field, new Long(lower), new Long(upper), false, false, variant);
+        tTopDocs = searcher.search(tq, 1);
+        assertEquals("Returned count of range query must be equal to exclusive range length", tTopDocs.totalHits, Math.max(upper-lower-1, 0) );
+        // test left exclusive range
+        tq=new TrieRangeQuery(field, new Long(lower), new Long(upper), false, true, variant);
+        tTopDocs = searcher.search(tq, 1);
+        assertEquals("Returned count of range query must be equal to half exclusive range length", tTopDocs.totalHits, upper-lower );
+        // test right exclusive range
+        tq=new TrieRangeQuery(field, new Long(lower), new Long(upper), true, false, variant);
+        tTopDocs = searcher.search(tq, 1);
+        assertEquals("Returned count of range query must be equal to half exclusive range length", tTopDocs.totalHits, upper-lower );
       }
-      // test inclusive range
-      TrieRangeQuery tq=new TrieRangeQuery(field, new Long(lower), new Long(upper), true, true, variant);
-      TopDocs tTopDocs = searcher.search(tq, 1);
-      assertEquals("Returned count of range query must be equal to inclusive range length", tTopDocs.totalHits, upper-lower+1 );
-      // test exclusive range
-      tq=new TrieRangeQuery(field, new Long(lower), new Long(upper), false, false, variant);
-      tTopDocs = searcher.search(tq, 1);
-      assertEquals("Returned count of range query must be equal to exclusive range length", tTopDocs.totalHits, Math.max(upper-lower-1, 0) );
-      // test left exclusive range
-      tq=new TrieRangeQuery(field, new Long(lower), new Long(upper), false, true, variant);
-      tTopDocs = searcher.search(tq, 1);
-      assertEquals("Returned count of range query must be equal to half exclusive range length", tTopDocs.totalHits, upper-lower );
-      // test right exclusive range
-      tq=new TrieRangeQuery(field, new Long(lower), new Long(upper), true, false, variant);
-      tTopDocs = searcher.search(tq, 1);
-      assertEquals("Returned count of range query must be equal to half exclusive range length", tTopDocs.totalHits, upper-lower );
+    } catch (Error e) {
+      System.out.println("Random seed (testRandomTrieAndClassicRangeQuery_"+variant.TRIE_BITS+"bit): "+seed);
+      throw e;
     }
   }
 
@@ -225,26 +243,35 @@
   }
   
   private void testSorting(final TrieUtils variant) throws Exception {
-    String field="field"+variant.TRIE_BITS;
-    // 10 random tests, the index order is ascending,
-    // so using a reverse sort field should retun descending documents
-    for (int i=0; i<10; i++) {
-      long lower=(long)(rnd.nextDouble()*10000L*distance);
-      long upper=(long)(rnd.nextDouble()*10000L*distance);
-      if (lower>upper) {
-        long a=lower; lower=upper; upper=a;
+    // for debugging, you can set the seed manually here, to the value that caused the error:
+    final long seed=seedRnd.nextLong();
+    final Random rnd=new Random(seed);
+
+    try {
+      String field="field"+variant.TRIE_BITS;
+      // 10 random tests, the index order is ascending,
+      // so using a reverse sort field should retun descending documents
+      for (int i=0; i<10; i++) {
+        long lower=(long)(rnd.nextDouble()*10000L*distance);
+        long upper=(long)(rnd.nextDouble()*10000L*distance);
+        if (lower>upper) {
+          long a=lower; lower=upper; upper=a;
+        }
+        TrieRangeQuery tq=new TrieRangeQuery(field, new Long(lower), new Long(upper), true, true, variant);
+        TopDocs topDocs = searcher.search(tq, null, 10000, new Sort(variant.getSortField(field, true)));
+        if (topDocs.totalHits==0) continue;
+        ScoreDoc[] sd = topDocs.scoreDocs;
+        assertNotNull(sd);
+        long last=variant.trieCodedToLong(searcher.doc(sd[0].doc).get(field));
+        for (int j=1; j<sd.length; j++) {
+          long act=variant.trieCodedToLong(searcher.doc(sd[j].doc).get(field));
+          assertTrue("Docs should be sorted backwards", last>act );
+          last=act;
+        }
       }
-      TrieRangeQuery tq=new TrieRangeQuery(field, new Long(lower), new Long(upper), true, true, variant);
-      TopDocs topDocs = searcher.search(tq, null, 10000, new Sort(variant.getSortField(field, true)));
-      if (topDocs.totalHits==0) continue;
-      ScoreDoc[] sd = topDocs.scoreDocs;
-      assertNotNull(sd);
-      long last=variant.trieCodedToLong(searcher.doc(sd[0].doc).get(field));
-      for (int j=1; j<sd.length; j++) {
-        long act=variant.trieCodedToLong(searcher.doc(sd[j].doc).get(field));
-        assertTrue("Docs should be sorted backwards", last>act );
-        last=act;
-      }
+    } catch (Error e) {
+      System.out.println("Random seed (testRandomTrieAndClassicRangeQuery_"+variant.TRIE_BITS+"bit): "+seed);
+      throw e;
     }
   }