1 package org.apache.lucene.search;
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
11 * http://www.apache.org/licenses/LICENSE-2.0
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.
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;
33 import org.junit.Test;
34 import org.junit.AfterClass;
35 import org.junit.BeforeClass;
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;
45 private static Directory directory = null;
46 private static IndexReader reader = null;
47 private static IndexSearcher searcher = null;
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()));
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);
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);
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);
82 ascfield8.setIntValue(val);
83 ascfield4.setIntValue(val);
84 ascfield2.setIntValue(val);
85 writer.addDocument(doc);
88 reader = writer.getReader();
89 searcher=newSearcher(reader);
94 public static void afterClass() throws Exception {
104 public void setUp() throws Exception {
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);
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;
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);
119 for (byte i=0; i<3; i++) {
123 q.clearTotalNumberOfTerms();
124 f.clearTotalNumberOfTerms();
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();
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();
140 topDocs = searcher.search(new MatchAllDocsQuery(), f, noDocs, Sort.INDEXORDER);
141 terms = f.getTotalNumberOfTerms();
146 if (VERBOSE) System.out.println("Found "+terms+" distinct terms in range for field '"+field+"'"+type+".");
147 ScoreDoc[] sd = topDocs.scoreDocs;
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)) );
155 (searcher.getIndexReader().getSequentialSubReaders() == null ||
156 searcher.getIndexReader().getSequentialSubReaders().length == 1)) {
157 assertEquals("Distinct term number is equal for all query types", lastTerms, terms);
164 public void testRange_8bit() throws Exception {
169 public void testRange_4bit() throws Exception {
174 public void testRange_2bit() throws Exception {
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()));
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;
197 assertEquals("Score doc count", 1, sd.length );
200 private void testLeftOpenRange(int precisionStep) throws Exception {
201 String field="field"+precisionStep;
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;
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)) );
215 q=NumericRangeQuery.newIntRange(field, precisionStep, null, upper, false, true);
216 topDocs = searcher.search(q, null, noDocs, Sort.INDEXORDER);
217 sd = topDocs.scoreDocs;
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)) );
227 public void testLeftOpenRange_8bit() throws Exception {
228 testLeftOpenRange(8);
232 public void testLeftOpenRange_4bit() throws Exception {
233 testLeftOpenRange(4);
237 public void testLeftOpenRange_2bit() throws Exception {
238 testLeftOpenRange(2);
241 private void testRightOpenRange(int precisionStep) throws Exception {
242 String field="field"+precisionStep;
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;
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)) );
256 q=NumericRangeQuery.newIntRange(field, precisionStep, lower, null, true, false);
257 topDocs = searcher.search(q, null, noDocs, Sort.INDEXORDER);
258 sd = topDocs.scoreDocs;
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)) );
268 public void testRightOpenRange_8bit() throws Exception {
269 testRightOpenRange(8);
273 public void testRightOpenRange_4bit() throws Exception {
274 testRightOpenRange(4);
278 public void testRightOpenRange_2bit() throws Exception {
279 testRightOpenRange(2);
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);
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);
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);
302 IndexSearcher s = new IndexSearcher(dir);
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 );
308 q=NumericRangeQuery.newIntRange("int", null, null, false, false);
309 topDocs = s.search(q, 10);
310 assertEquals("Score doc count", 3, topDocs.scoreDocs.length );
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 );
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 );
320 q=NumericRangeQuery.newFloatRange("float", null, null, true, true);
321 topDocs = s.search(q, 10);
322 assertEquals("Score doc count", 3, topDocs.scoreDocs.length );
324 q=NumericRangeQuery.newFloatRange("float", null, null, false, false);
325 topDocs = s.search(q, 10);
326 assertEquals("Score doc count", 3, topDocs.scoreDocs.length );
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;
340 int a=lower; lower=upper; upper=a;
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();
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)));
387 public void testRandomTrieAndClassicRangeQuery_8bit() throws Exception {
388 testRandomTrieAndClassicRangeQuery(8);
392 public void testRandomTrieAndClassicRangeQuery_4bit() throws Exception {
393 testRandomTrieAndClassicRangeQuery(4);
397 public void testRandomTrieAndClassicRangeQuery_2bit() throws Exception {
398 testRandomTrieAndClassicRangeQuery(2);
402 public void testRandomTrieAndClassicRangeQuery_NoTrie() throws Exception {
403 testRandomTrieAndClassicRangeQuery(Integer.MAX_VALUE);
406 private void testRangeSplit(int precisionStep) throws Exception {
407 String field="ascfield"+precisionStep;
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);
414 int a=lower; lower=upper; upper=a;
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 );
436 public void testRangeSplit_8bit() throws Exception {
441 public void testRangeSplit_4bit() throws Exception {
446 public void testRangeSplit_2bit() throws Exception {
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;
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 );
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 );
467 public void testFloatRange_8bit() throws Exception {
472 public void testFloatRange_4bit() throws Exception {
477 public void testFloatRange_2bit() throws Exception {
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;
490 int a=lower; lower=upper; upper=a;
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;
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 );
507 public void testSorting_8bit() throws Exception {
512 public void testSorting_4bit() throws Exception {
517 public void testSorting_2bit() throws Exception {
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)
534 QueryUtils.checkUnequal(
535 NumericRangeQuery.newIntRange("test9", 4, 10, 20, true, true),
536 NumericRangeQuery.newIntRange("test9", 8, 10, 20, true, true)
538 QueryUtils.checkUnequal(
539 NumericRangeQuery.newIntRange("test10a", 4, 10, 20, true, true),
540 NumericRangeQuery.newIntRange("test10b", 4, 10, 20, true, true)
542 QueryUtils.checkUnequal(
543 NumericRangeQuery.newIntRange("test11", 4, 10, 20, true, true),
544 NumericRangeQuery.newIntRange("test11", 4, 20, 10, true, true)
546 QueryUtils.checkUnequal(
547 NumericRangeQuery.newIntRange("test12", 4, 10, 20, true, true),
548 NumericRangeQuery.newIntRange("test12", 4, 10, 20, false, true)
550 QueryUtils.checkUnequal(
551 NumericRangeQuery.newIntRange("test13", 4, 10, 20, true, true),
552 NumericRangeQuery.newFloatRange("test13", 4, 10f, 20f, true, true)
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));
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());
567 final Term t = termEnum.term();
569 final int val = NumericUtils.prefixCodedToInt(t.text());
570 assertTrue("value not in bounds", val >= lower && val <= upper);
573 } while (termEnum.next());
574 assertFalse(termEnum.next());
575 if (VERBOSE) System.out.println("TermEnum on 'field4' for range [" + lower + "," + upper + "] contained " + count + " terms.");
582 public void testEnum() throws Exception {
584 int lower=(distance*3/2)+startOffset, upper=lower + count*distance + (distance/3);
585 // test enum with values
586 testEnum(lower, upper);
588 testEnum(upper, lower);
589 // test empty enum outside of bounds
590 lower = distance*noDocs+startOffset;
592 testEnum(lower, upper);