lucene-java-3.4.0/lucene/src/test/org/apache/lucene/search/TestNumericRangeQuery32.java

   1 package org.apache.lucene.search;
   2
   3 /**
   4  * Licensed to the Apache Software Foundation (ASF) under one or more
   5  * contributor license agreements.  See the NOTICE file distributed with
   6  * this work for additional information regarding copyright ownership.
   7  * The ASF licenses this file to You under the Apache License, Version 2.0
   8  * (the "License"); you may not use this file except in compliance with
   9  * the License.  You may obtain a copy of the License at
  10  *
  11  *     http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  */
  19
  20 import org.apache.lucene.analysis.MockAnalyzer;
  21 import org.apache.lucene.document.Document;
  22 import org.apache.lucene.document.Field;
  23 import org.apache.lucene.document.NumericField;
  24 import org.apache.lucene.index.IndexReader;
  25 import org.apache.lucene.index.IndexWriter;
  26 import org.apache.lucene.index.Term;
  27 import org.apache.lucene.index.RandomIndexWriter;
  28 import org.apache.lucene.store.Directory;
  29 import org.apache.lucene.util.LuceneTestCase;
  30 import org.apache.lucene.util.NumericUtils;
  31 import org.apache.lucene.util._TestUtil;
  32
  33 import org.junit.Test;
  34 import org.junit.AfterClass;
  35 import org.junit.BeforeClass;
  36
  37 public class TestNumericRangeQuery32 extends LuceneTestCase {
  38   // distance of entries
  39   private static final int distance = 6666;
  40   // shift the starting of the values to the left, to also have negative values:
  41   private static final int startOffset = - 1 << 15;
  42   // number of docs to generate for testing
  43   private static int noDocs;
  44
  45   private static Directory directory = null;
  46   private static IndexReader reader = null;
  47   private static IndexSearcher searcher = null;
  48
  49   @BeforeClass
  50   public static void beforeClass() throws Exception {
  51     noDocs = atLeast(4096);
  52     directory = newDirectory();
  53     RandomIndexWriter writer = new RandomIndexWriter(random, directory,
  54         newIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(random))
  55         .setMaxBufferedDocs(_TestUtil.nextInt(random, 100, 1000))
  56         .setMergePolicy(newLogMergePolicy()));
  57
  58     NumericField
  59       field8 = new NumericField("field8", 8, Field.Store.YES, true),
  60       field4 = new NumericField("field4", 4, Field.Store.YES, true),
  61       field2 = new NumericField("field2", 2, Field.Store.YES, true),
  62       fieldNoTrie = new NumericField("field"+Integer.MAX_VALUE, Integer.MAX_VALUE, Field.Store.YES, true),
  63       ascfield8 = new NumericField("ascfield8", 8, Field.Store.NO, true),
  64       ascfield4 = new NumericField("ascfield4", 4, Field.Store.NO, true),
  65       ascfield2 = new NumericField("ascfield2", 2, Field.Store.NO, true);
  66
  67     Document doc = new Document();
  68     // add fields, that have a distance to test general functionality
  69     doc.add(field8); doc.add(field4); doc.add(field2); doc.add(fieldNoTrie);
  70     // add ascending fields with a distance of 1, beginning at -noDocs/2 to test the correct splitting of range and inclusive/exclusive
  71     doc.add(ascfield8); doc.add(ascfield4); doc.add(ascfield2);
  72
  73     // Add a series of noDocs docs with increasing int values
  74     for (int l=0; l<noDocs; l++) {
  75       int val=distance*l+startOffset;
  76       field8.setIntValue(val);
  77       field4.setIntValue(val);
  78       field2.setIntValue(val);
  79       fieldNoTrie.setIntValue(val);
  80
  81       val=l-(noDocs/2);
  82       ascfield8.setIntValue(val);
  83       ascfield4.setIntValue(val);
  84       ascfield2.setIntValue(val);
  85       writer.addDocument(doc);
  86     }
  87
  88     reader = writer.getReader();
  89     searcher=newSearcher(reader);
  90     writer.close();
  91   }
  92
  93   @AfterClass
  94   public static void afterClass() throws Exception {
  95     searcher.close();
  96     searcher = null;
  97     reader.close();
  98     reader = null;
  99     directory.close();
 100     directory = null;
 101   }
 102
 103   @Override
 104   public void setUp() throws Exception {
 105     super.setUp();
 106     // set the theoretical maximum term count for 8bit (see docs for the number)
 107     // super.tearDown will restore the default
 108     BooleanQuery.setMaxClauseCount(3*255*2 + 255);
 109   }
 110
 111   /** test for both constant score and boolean query, the other tests only use the constant score mode */
 112   private void testRange(int precisionStep) throws Exception {
 113     String field="field"+precisionStep;
 114     int count=3000;
 115     int lower=(distance*3/2)+startOffset, upper=lower + count*distance + (distance/3);
 116     NumericRangeQuery<Integer> q = NumericRangeQuery.newIntRange(field, precisionStep, lower, upper, true, true);
 117     NumericRangeFilter<Integer> f = NumericRangeFilter.newIntRange(field, precisionStep, lower, upper, true, true);
 118     int lastTerms = 0;
 119     for (byte i=0; i<3; i++) {
 120       TopDocs topDocs;
 121       int terms;
 122       String type;
 123       q.clearTotalNumberOfTerms();
 124       f.clearTotalNumberOfTerms();
 125       switch (i) {
 126         case 0:
 127           type = " (constant score filter rewrite)";
 128           q.setRewriteMethod(MultiTermQuery.CONSTANT_SCORE_FILTER_REWRITE);
 129           topDocs = searcher.search(q, null, noDocs, Sort.INDEXORDER);
 130           terms = q.getTotalNumberOfTerms();
 131           break;
 132         case 1:
 133           type = " (constant score boolean rewrite)";
 134           q.setRewriteMethod(MultiTermQuery.CONSTANT_SCORE_BOOLEAN_QUERY_REWRITE);
 135           topDocs = searcher.search(q, null, noDocs, Sort.INDEXORDER);
 136           terms = q.getTotalNumberOfTerms();
 137           break;
 138         case 2:
 139           type = " (filter)";
 140           topDocs = searcher.search(new MatchAllDocsQuery(), f, noDocs, Sort.INDEXORDER);
 141           terms = f.getTotalNumberOfTerms();
 142           break;
 143         default:
 144           return;
 145       }
 146       if (VERBOSE) System.out.println("Found "+terms+" distinct terms in range for field '"+field+"'"+type+".");
 147       ScoreDoc[] sd = topDocs.scoreDocs;
 148       assertNotNull(sd);
 149       assertEquals("Score doc count"+type, count, sd.length );
 150       Document doc=searcher.doc(sd[0].doc);
 151       assertEquals("First doc"+type, 2*distance+startOffset, Integer.parseInt(doc.get(field)) );
 152       doc=searcher.doc(sd[sd.length-1].doc);
 153       assertEquals("Last doc"+type, (1+count)*distance+startOffset, Integer.parseInt(doc.get(field)) );
 154       if (i>0 &&
 155           (searcher.getIndexReader().getSequentialSubReaders() == null ||
 156            searcher.getIndexReader().getSequentialSubReaders().length == 1)) {
 157         assertEquals("Distinct term number is equal for all query types", lastTerms, terms);
 158       }
 159       lastTerms = terms;
 160     }
 161   }
 162
 163   @Test
 164   public void testRange_8bit() throws Exception {
 165     testRange(8);
 166   }
 167
 168   @Test
 169   public void testRange_4bit() throws Exception {
 170     testRange(4);
 171   }
 172
 173   @Test
 174   public void testRange_2bit() throws Exception {
 175     testRange(2);
 176   }
 177
 178   @Test
 179   public void testInverseRange() throws Exception {
 180     NumericRangeFilter<Integer> f = NumericRangeFilter.newIntRange("field8", 8, 1000, -1000, true, true);
 181     assertSame("A inverse range should return the EMPTY_DOCIDSET instance", DocIdSet.EMPTY_DOCIDSET, f.getDocIdSet(searcher.getIndexReader()));
 182     f = NumericRangeFilter.newIntRange("field8", 8, Integer.MAX_VALUE, null, false, false);
 183     assertSame("A exclusive range starting with Integer.MAX_VALUE should return the EMPTY_DOCIDSET instance",
 184       DocIdSet.EMPTY_DOCIDSET, f.getDocIdSet(searcher.getIndexReader()));
 185     f = NumericRangeFilter.newIntRange("field8", 8, null, Integer.MIN_VALUE, false, false);
 186     assertSame("A exclusive range ending with Integer.MIN_VALUE should return the EMPTY_DOCIDSET instance",
 187       DocIdSet.EMPTY_DOCIDSET, f.getDocIdSet(searcher.getIndexReader()));
 188   }
 189
 190   @Test
 191   public void testOneMatchQuery() throws Exception {
 192     NumericRangeQuery<Integer> q = NumericRangeQuery.newIntRange("ascfield8", 8, 1000, 1000, true, true);
 193     assertSame(MultiTermQuery.CONSTANT_SCORE_BOOLEAN_QUERY_REWRITE, q.getRewriteMethod());
 194     TopDocs topDocs = searcher.search(q, noDocs);
 195     ScoreDoc[] sd = topDocs.scoreDocs;
 196     assertNotNull(sd);
 197     assertEquals("Score doc count", 1, sd.length );
 198   }
 199
 200   private void testLeftOpenRange(int precisionStep) throws Exception {
 201     String field="field"+precisionStep;
 202     int count=3000;
 203     int upper=(count-1)*distance + (distance/3) + startOffset;
 204     NumericRangeQuery<Integer> q=NumericRangeQuery.newIntRange(field, precisionStep, null, upper, true, true);
 205     TopDocs topDocs = searcher.search(q, null, noDocs, Sort.INDEXORDER);
 206     if (VERBOSE) System.out.println("Found "+q.getTotalNumberOfTerms()+" distinct terms in left open range for field '"+field+"'.");
 207     ScoreDoc[] sd = topDocs.scoreDocs;
 208     assertNotNull(sd);
 209     assertEquals("Score doc count", count, sd.length );
 210     Document doc=searcher.doc(sd[0].doc);
 211     assertEquals("First doc", startOffset, Integer.parseInt(doc.get(field)) );
 212     doc=searcher.doc(sd[sd.length-1].doc);
 213     assertEquals("Last doc", (count-1)*distance+startOffset, Integer.parseInt(doc.get(field)) );
 214
 215     q=NumericRangeQuery.newIntRange(field, precisionStep, null, upper, false, true);
 216     topDocs = searcher.search(q, null, noDocs, Sort.INDEXORDER);
 217     sd = topDocs.scoreDocs;
 218     assertNotNull(sd);
 219     assertEquals("Score doc count", count, sd.length );
 220     doc=searcher.doc(sd[0].doc);
 221     assertEquals("First doc", startOffset, Integer.parseInt(doc.get(field)) );
 222     doc=searcher.doc(sd[sd.length-1].doc);
 223     assertEquals("Last doc", (count-1)*distance+startOffset, Integer.parseInt(doc.get(field)) );
 224   }
 225
 226   @Test
 227   public void testLeftOpenRange_8bit() throws Exception {
 228     testLeftOpenRange(8);
 229   }
 230
 231   @Test
 232   public void testLeftOpenRange_4bit() throws Exception {
 233     testLeftOpenRange(4);
 234   }
 235
 236   @Test
 237   public void testLeftOpenRange_2bit() throws Exception {
 238     testLeftOpenRange(2);
 239   }
 240
 241   private void testRightOpenRange(int precisionStep) throws Exception {
 242     String field="field"+precisionStep;
 243     int count=3000;
 244     int lower=(count-1)*distance + (distance/3) +startOffset;
 245     NumericRangeQuery<Integer> q=NumericRangeQuery.newIntRange(field, precisionStep, lower, null, true, true);
 246     TopDocs topDocs = searcher.search(q, null, noDocs, Sort.INDEXORDER);
 247     if (VERBOSE) System.out.println("Found "+q.getTotalNumberOfTerms()+" distinct terms in right open range for field '"+field+"'.");
 248     ScoreDoc[] sd = topDocs.scoreDocs;
 249     assertNotNull(sd);
 250     assertEquals("Score doc count", noDocs-count, sd.length );
 251     Document doc=searcher.doc(sd[0].doc);
 252     assertEquals("First doc", count*distance+startOffset, Integer.parseInt(doc.get(field)) );
 253     doc=searcher.doc(sd[sd.length-1].doc);
 254     assertEquals("Last doc", (noDocs-1)*distance+startOffset, Integer.parseInt(doc.get(field)) );
 255
 256     q=NumericRangeQuery.newIntRange(field, precisionStep, lower, null, true, false);
 257     topDocs = searcher.search(q, null, noDocs, Sort.INDEXORDER);
 258     sd = topDocs.scoreDocs;
 259     assertNotNull(sd);
 260     assertEquals("Score doc count", noDocs-count, sd.length );
 261     doc=searcher.doc(sd[0].doc);
 262     assertEquals("First doc", count*distance+startOffset, Integer.parseInt(doc.get(field)) );
 263     doc=searcher.doc(sd[sd.length-1].doc);
 264     assertEquals("Last doc", (noDocs-1)*distance+startOffset, Integer.parseInt(doc.get(field)) );
 265   }
 266
 267   @Test
 268   public void testRightOpenRange_8bit() throws Exception {
 269     testRightOpenRange(8);
 270   }
 271
 272   @Test
 273   public void testRightOpenRange_4bit() throws Exception {
 274     testRightOpenRange(4);
 275   }
 276
 277   @Test
 278   public void testRightOpenRange_2bit() throws Exception {
 279     testRightOpenRange(2);
 280   }
 281
 282   @Test
 283   public void testInfiniteValues() throws Exception {
 284     Directory dir = newDirectory();
 285     IndexWriter writer = new IndexWriter(dir, newIndexWriterConfig( TEST_VERSION_CURRENT, new MockAnalyzer(random)));
 286     Document doc = new Document();
 287     doc.add(new NumericField("float").setFloatValue(Float.NEGATIVE_INFINITY));
 288     doc.add(new NumericField("int").setIntValue(Integer.MIN_VALUE));
 289     writer.addDocument(doc);
 290
 291     doc = new Document();
 292     doc.add(new NumericField("float").setFloatValue(Float.POSITIVE_INFINITY));
 293     doc.add(new NumericField("int").setIntValue(Integer.MAX_VALUE));
 294     writer.addDocument(doc);
 295
 296     doc = new Document();
 297     doc.add(new NumericField("float").setFloatValue(0.0f));
 298     doc.add(new NumericField("int").setIntValue(0));
 299     writer.addDocument(doc);
 300     writer.close();
 301
 302     IndexSearcher s = new IndexSearcher(dir);
 303
 304     Query q=NumericRangeQuery.newIntRange("int", null, null, true, true);
 305     TopDocs topDocs = s.search(q, 10);
 306     assertEquals("Score doc count", 3,  topDocs.scoreDocs.length );
 307
 308     q=NumericRangeQuery.newIntRange("int", null, null, false, false);
 309     topDocs = s.search(q, 10);
 310     assertEquals("Score doc count", 3,  topDocs.scoreDocs.length );
 311
 312     q=NumericRangeQuery.newIntRange("int", Integer.MIN_VALUE, Integer.MAX_VALUE, true, true);
 313     topDocs = s.search(q, 10);
 314     assertEquals("Score doc count", 3,  topDocs.scoreDocs.length );
 315
 316     q=NumericRangeQuery.newIntRange("int", Integer.MIN_VALUE, Integer.MAX_VALUE, false, false);
 317     topDocs = s.search(q, 10);
 318     assertEquals("Score doc count", 1,  topDocs.scoreDocs.length );
 319
 320     q=NumericRangeQuery.newFloatRange("float", null, null, true, true);
 321     topDocs = s.search(q, 10);
 322     assertEquals("Score doc count", 3,  topDocs.scoreDocs.length );
 323
 324     q=NumericRangeQuery.newFloatRange("float", null, null, false, false);
 325     topDocs = s.search(q, 10);
 326     assertEquals("Score doc count", 3,  topDocs.scoreDocs.length );
 327
 328     s.close();
 329     dir.close();
 330   }
 331
 332   private void testRandomTrieAndClassicRangeQuery(int precisionStep) throws Exception {
 333     String field="field"+precisionStep;
 334     int termCountT=0,termCountC=0;
 335     int num = _TestUtil.nextInt(random, 10, 20);
 336     for (int i = 0; i < num; i++) {
 337       int lower=(int)(random.nextDouble()*noDocs*distance)+startOffset;
 338       int upper=(int)(random.nextDouble()*noDocs*distance)+startOffset;
 339       if (lower>upper) {
 340         int a=lower; lower=upper; upper=a;
 341       }
 342       // test inclusive range
 343       NumericRangeQuery<Integer> tq=NumericRangeQuery.newIntRange(field, precisionStep, lower, upper, true, true);
 344       TermRangeQuery cq=new TermRangeQuery(field, NumericUtils.intToPrefixCoded(lower), NumericUtils.intToPrefixCoded(upper), true, true);
 345       TopDocs tTopDocs = searcher.search(tq, 1);
 346       TopDocs cTopDocs = searcher.search(cq, 1);
 347       assertEquals("Returned count for NumericRangeQuery and TermRangeQuery must be equal", cTopDocs.totalHits, tTopDocs.totalHits );
 348       termCountT += tq.getTotalNumberOfTerms();
 349       termCountC += cq.getTotalNumberOfTerms();
 350       // test exclusive range
 351       tq=NumericRangeQuery.newIntRange(field, precisionStep, lower, upper, false, false);
 352       cq=new TermRangeQuery(field, NumericUtils.intToPrefixCoded(lower), NumericUtils.intToPrefixCoded(upper), false, false);
 353       tTopDocs = searcher.search(tq, 1);
 354       cTopDocs = searcher.search(cq, 1);
 355       assertEquals("Returned count for NumericRangeQuery and TermRangeQuery must be equal", cTopDocs.totalHits, tTopDocs.totalHits );
 356       termCountT += tq.getTotalNumberOfTerms();
 357       termCountC += cq.getTotalNumberOfTerms();
 358       // test left exclusive range
 359       tq=NumericRangeQuery.newIntRange(field, precisionStep, lower, upper, false, true);
 360       cq=new TermRangeQuery(field, NumericUtils.intToPrefixCoded(lower), NumericUtils.intToPrefixCoded(upper), false, true);
 361       tTopDocs = searcher.search(tq, 1);
 362       cTopDocs = searcher.search(cq, 1);
 363       assertEquals("Returned count for NumericRangeQuery and TermRangeQuery must be equal", cTopDocs.totalHits, tTopDocs.totalHits );
 364       termCountT += tq.getTotalNumberOfTerms();
 365       termCountC += cq.getTotalNumberOfTerms();
 366       // test right exclusive range
 367       tq=NumericRangeQuery.newIntRange(field, precisionStep, lower, upper, true, false);
 368       cq=new TermRangeQuery(field, NumericUtils.intToPrefixCoded(lower), NumericUtils.intToPrefixCoded(upper), true, false);
 369       tTopDocs = searcher.search(tq, 1);
 370       cTopDocs = searcher.search(cq, 1);
 371       assertEquals("Returned count for NumericRangeQuery and TermRangeQuery must be equal", cTopDocs.totalHits, tTopDocs.totalHits );
 372       termCountT += tq.getTotalNumberOfTerms();
 373       termCountC += cq.getTotalNumberOfTerms();
 374     }
 375     if (precisionStep == Integer.MAX_VALUE &&
 376         (searcher.getIndexReader().getSequentialSubReaders() == null ||
 377          searcher.getIndexReader().getSequentialSubReaders().length == 1)) {
 378       assertEquals("Total number of terms should be equal for unlimited precStep", termCountT, termCountC);
 379     } else if (VERBOSE) {
 380       System.out.println("Average number of terms during random search on '" + field + "':");
 381       System.out.println(" Trie query: " + (((double)termCountT)/(num * 4)));
 382       System.out.println(" Classical query: " + (((double)termCountC)/(num * 4)));
 383     }
 384   }
 385
 386   @Test
 387   public void testRandomTrieAndClassicRangeQuery_8bit() throws Exception {
 388     testRandomTrieAndClassicRangeQuery(8);
 389   }
 390
 391   @Test
 392   public void testRandomTrieAndClassicRangeQuery_4bit() throws Exception {
 393     testRandomTrieAndClassicRangeQuery(4);
 394   }
 395
 396   @Test
 397   public void testRandomTrieAndClassicRangeQuery_2bit() throws Exception {
 398     testRandomTrieAndClassicRangeQuery(2);
 399   }
 400
 401   @Test
 402   public void testRandomTrieAndClassicRangeQuery_NoTrie() throws Exception {
 403     testRandomTrieAndClassicRangeQuery(Integer.MAX_VALUE);
 404   }
 405
 406   private void testRangeSplit(int precisionStep) throws Exception {
 407     String field="ascfield"+precisionStep;
 408     // 10 random tests
 409     int num = _TestUtil.nextInt(random, 10, 20);
 410     for (int  i =0;  i< num; i++) {
 411       int lower=(int)(random.nextDouble()*noDocs - noDocs/2);
 412       int upper=(int)(random.nextDouble()*noDocs - noDocs/2);
 413       if (lower>upper) {
 414         int a=lower; lower=upper; upper=a;
 415       }
 416       // test inclusive range
 417       Query tq=NumericRangeQuery.newIntRange(field, precisionStep, lower, upper, true, true);
 418       TopDocs tTopDocs = searcher.search(tq, 1);
 419       assertEquals("Returned count of range query must be equal to inclusive range length", upper-lower+1, tTopDocs.totalHits );
 420       // test exclusive range
 421       tq=NumericRangeQuery.newIntRange(field, precisionStep, lower, upper, false, false);
 422       tTopDocs = searcher.search(tq, 1);
 423       assertEquals("Returned count of range query must be equal to exclusive range length", Math.max(upper-lower-1, 0), tTopDocs.totalHits );
 424       // test left exclusive range
 425       tq=NumericRangeQuery.newIntRange(field, precisionStep, lower, upper, false, true);
 426       tTopDocs = searcher.search(tq, 1);
 427       assertEquals("Returned count of range query must be equal to half exclusive range length", upper-lower, tTopDocs.totalHits );
 428       // test right exclusive range
 429       tq=NumericRangeQuery.newIntRange(field, precisionStep, lower, upper, true, false);
 430       tTopDocs = searcher.search(tq, 1);
 431       assertEquals("Returned count of range query must be equal to half exclusive range length", upper-lower, tTopDocs.totalHits );
 432     }
 433   }
 434
 435   @Test
 436   public void testRangeSplit_8bit() throws Exception {
 437     testRangeSplit(8);
 438   }
 439
 440   @Test
 441   public void testRangeSplit_4bit() throws Exception {
 442     testRangeSplit(4);
 443   }
 444
 445   @Test
 446   public void testRangeSplit_2bit() throws Exception {
 447     testRangeSplit(2);
 448   }
 449
 450   /** we fake a float test using int2float conversion of NumericUtils */
 451   private void testFloatRange(int precisionStep) throws Exception {
 452     final String field="ascfield"+precisionStep;
 453     final int lower=-1000, upper=+2000;
 454
 455     Query tq=NumericRangeQuery.newFloatRange(field, precisionStep,
 456       NumericUtils.sortableIntToFloat(lower), NumericUtils.sortableIntToFloat(upper), true, true);
 457     TopDocs tTopDocs = searcher.search(tq, 1);
 458     assertEquals("Returned count of range query must be equal to inclusive range length", upper-lower+1, tTopDocs.totalHits );
 459
 460     Filter tf=NumericRangeFilter.newFloatRange(field, precisionStep,
 461       NumericUtils.sortableIntToFloat(lower), NumericUtils.sortableIntToFloat(upper), true, true);
 462     tTopDocs = searcher.search(new MatchAllDocsQuery(), tf, 1);
 463     assertEquals("Returned count of range filter must be equal to inclusive range length", upper-lower+1, tTopDocs.totalHits );
 464   }
 465
 466   @Test
 467   public void testFloatRange_8bit() throws Exception {
 468     testFloatRange(8);
 469   }
 470
 471   @Test
 472   public void testFloatRange_4bit() throws Exception {
 473     testFloatRange(4);
 474   }
 475
 476   @Test
 477   public void testFloatRange_2bit() throws Exception {
 478     testFloatRange(2);
 479   }
 480
 481   private void testSorting(int precisionStep) throws Exception {
 482     String field="field"+precisionStep;
 483     // 10 random tests, the index order is ascending,
 484     // so using a reverse sort field should retun descending documents
 485     int num = _TestUtil.nextInt(random, 10, 20);
 486     for (int i = 0; i < num; i++) {
 487       int lower=(int)(random.nextDouble()*noDocs*distance)+startOffset;
 488       int upper=(int)(random.nextDouble()*noDocs*distance)+startOffset;
 489       if (lower>upper) {
 490         int a=lower; lower=upper; upper=a;
 491       }
 492       Query tq=NumericRangeQuery.newIntRange(field, precisionStep, lower, upper, true, true);
 493       TopDocs topDocs = searcher.search(tq, null, noDocs, new Sort(new SortField(field, SortField.INT, true)));
 494       if (topDocs.totalHits==0) continue;
 495       ScoreDoc[] sd = topDocs.scoreDocs;
 496       assertNotNull(sd);
 497       int last=Integer.parseInt(searcher.doc(sd[0].doc).get(field));
 498       for (int j=1; j<sd.length; j++) {
 499         int act=Integer.parseInt(searcher.doc(sd[j].doc).get(field));
 500         assertTrue("Docs should be sorted backwards", last>act );
 501         last=act;
 502       }
 503     }
 504   }
 505
 506   @Test
 507   public void testSorting_8bit() throws Exception {
 508     testSorting(8);
 509   }
 510
 511   @Test
 512   public void testSorting_4bit() throws Exception {
 513     testSorting(4);
 514   }
 515
 516   @Test
 517   public void testSorting_2bit() throws Exception {
 518     testSorting(2);
 519   }
 520
 521   @Test
 522   public void testEqualsAndHash() throws Exception {
 523     QueryUtils.checkHashEquals(NumericRangeQuery.newIntRange("test1", 4, 10, 20, true, true));
 524     QueryUtils.checkHashEquals(NumericRangeQuery.newIntRange("test2", 4, 10, 20, false, true));
 525     QueryUtils.checkHashEquals(NumericRangeQuery.newIntRange("test3", 4, 10, 20, true, false));
 526     QueryUtils.checkHashEquals(NumericRangeQuery.newIntRange("test4", 4, 10, 20, false, false));
 527     QueryUtils.checkHashEquals(NumericRangeQuery.newIntRange("test5", 4, 10, null, true, true));
 528     QueryUtils.checkHashEquals(NumericRangeQuery.newIntRange("test6", 4, null, 20, true, true));
 529     QueryUtils.checkHashEquals(NumericRangeQuery.newIntRange("test7", 4, null, null, true, true));
 530     QueryUtils.checkEqual(
 531       NumericRangeQuery.newIntRange("test8", 4, 10, 20, true, true),
 532       NumericRangeQuery.newIntRange("test8", 4, 10, 20, true, true)
 533     );
 534     QueryUtils.checkUnequal(
 535       NumericRangeQuery.newIntRange("test9", 4, 10, 20, true, true),
 536       NumericRangeQuery.newIntRange("test9", 8, 10, 20, true, true)
 537     );
 538     QueryUtils.checkUnequal(
 539       NumericRangeQuery.newIntRange("test10a", 4, 10, 20, true, true),
 540       NumericRangeQuery.newIntRange("test10b", 4, 10, 20, true, true)
 541     );
 542     QueryUtils.checkUnequal(
 543       NumericRangeQuery.newIntRange("test11", 4, 10, 20, true, true),
 544       NumericRangeQuery.newIntRange("test11", 4, 20, 10, true, true)
 545     );
 546     QueryUtils.checkUnequal(
 547       NumericRangeQuery.newIntRange("test12", 4, 10, 20, true, true),
 548       NumericRangeQuery.newIntRange("test12", 4, 10, 20, false, true)
 549     );
 550     QueryUtils.checkUnequal(
 551       NumericRangeQuery.newIntRange("test13", 4, 10, 20, true, true),
 552       NumericRangeQuery.newFloatRange("test13", 4, 10f, 20f, true, true)
 553     );
 554     // the following produces a hash collision, because Long and Integer have the same hashcode, so only test equality:
 555     Query q1 = NumericRangeQuery.newIntRange("test14", 4, 10, 20, true, true);
 556     Query q2 = NumericRangeQuery.newLongRange("test14", 4, 10L, 20L, true, true);
 557     assertFalse(q1.equals(q2));
 558     assertFalse(q2.equals(q1));
 559   }
 560
 561   private void testEnum(int lower, int upper) throws Exception {
 562     NumericRangeQuery<Integer> q = NumericRangeQuery.newIntRange("field4", 4, lower, upper, true, true);
 563     FilteredTermEnum termEnum = q.getEnum(searcher.getIndexReader());
 564     try {
 565       int count = 0;
 566       do {
 567         final Term t = termEnum.term();
 568         if (t != null) {
 569           final int val = NumericUtils.prefixCodedToInt(t.text());
 570           assertTrue("value not in bounds", val >= lower && val <= upper);
 571           count++;
 572         } else break;
 573       } while (termEnum.next());
 574       assertFalse(termEnum.next());
 575       if (VERBOSE) System.out.println("TermEnum on 'field4' for range [" + lower + "," + upper + "] contained " + count + " terms.");
 576     } finally {
 577       termEnum.close();
 578     }
 579   }
 580
 581   @Test
 582   public void testEnum() throws Exception {
 583     int count=3000;
 584     int lower=(distance*3/2)+startOffset, upper=lower + count*distance + (distance/3);
 585     // test enum with values
 586     testEnum(lower, upper);
 587     // test empty enum
 588     testEnum(upper, lower);
 589     // test empty enum outside of bounds
 590     lower = distance*noDocs+startOffset;
 591     upper = 2 * lower;
 592     testEnum(lower, upper);
 593   }
 594
 595 }