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 java.io.IOException;
23 import org.apache.lucene.index.IndexReader;
24 import org.apache.lucene.index.Term;
25 import org.apache.lucene.index.IndexWriter;
26 import org.apache.lucene.analysis.MockAnalyzer;
27 import org.apache.lucene.document.Document;
28 import org.apache.lucene.document.Field;
29 import org.apache.lucene.store.Directory;
30 import org.junit.Test;
33 * A basic 'positive' Unit test class for the FieldCacheRangeFilter class.
36 * NOTE: at the moment, this class only tests for 'positive' results,
37 * it does not verify the results to ensure there are no 'false positives',
38 * nor does it adequately test 'negative' results. It also does not test
39 * that garbage in results in an Exception.
41 public class TestFieldCacheRangeFilter extends BaseTestRangeFilter {
44 public void testRangeFilterId() throws IOException {
46 IndexReader reader = signedIndexReader;
47 IndexSearcher search = newSearcher(reader);
49 int medId = ((maxId - minId) / 2);
51 String minIP = pad(minId);
52 String maxIP = pad(maxId);
53 String medIP = pad(medId);
55 int numDocs = reader.numDocs();
57 assertEquals("num of docs", numDocs, 1+ maxId - minId);
60 Query q = new TermQuery(new Term("body","body"));
62 // test id, bounded on both ends
63 FieldCacheRangeFilter<String> fcrf;
64 result = search.search(q,fcrf = FieldCacheRangeFilter.newStringRange("id",minIP,maxIP,T,T), numDocs).scoreDocs;
65 assertTrue(fcrf.getDocIdSet(reader.getSequentialSubReaders()[0]).isCacheable());
66 assertEquals("find all", numDocs, result.length);
68 result = search.search(q,FieldCacheRangeFilter.newStringRange("id",minIP,maxIP,T,F), numDocs).scoreDocs;
69 assertEquals("all but last", numDocs-1, result.length);
71 result = search.search(q,FieldCacheRangeFilter.newStringRange("id",minIP,maxIP,F,T), numDocs).scoreDocs;
72 assertEquals("all but first", numDocs-1, result.length);
74 result = search.search(q,FieldCacheRangeFilter.newStringRange("id",minIP,maxIP,F,F), numDocs).scoreDocs;
75 assertEquals("all but ends", numDocs-2, result.length);
77 result = search.search(q,FieldCacheRangeFilter.newStringRange("id",medIP,maxIP,T,T), numDocs).scoreDocs;
78 assertEquals("med and up", 1+ maxId-medId, result.length);
80 result = search.search(q,FieldCacheRangeFilter.newStringRange("id",minIP,medIP,T,T), numDocs).scoreDocs;
81 assertEquals("up to med", 1+ medId-minId, result.length);
85 result = search.search(q,FieldCacheRangeFilter.newStringRange("id",null,null,T,T), numDocs).scoreDocs;
86 assertEquals("find all", numDocs, result.length);
88 result = search.search(q,FieldCacheRangeFilter.newStringRange("id",minIP,null,T,F), numDocs).scoreDocs;
89 assertEquals("min and up", numDocs, result.length);
91 result = search.search(q,FieldCacheRangeFilter.newStringRange("id",null,maxIP,F,T), numDocs).scoreDocs;
92 assertEquals("max and down", numDocs, result.length);
94 result = search.search(q,FieldCacheRangeFilter.newStringRange("id",minIP,null,F,F), numDocs).scoreDocs;
95 assertEquals("not min, but up", numDocs-1, result.length);
97 result = search.search(q,FieldCacheRangeFilter.newStringRange("id",null,maxIP,F,F), numDocs).scoreDocs;
98 assertEquals("not max, but down", numDocs-1, result.length);
100 result = search.search(q,FieldCacheRangeFilter.newStringRange("id",medIP,maxIP,T,F), numDocs).scoreDocs;
101 assertEquals("med and up, not max", maxId-medId, result.length);
103 result = search.search(q,FieldCacheRangeFilter.newStringRange("id",minIP,medIP,F,T), numDocs).scoreDocs;
104 assertEquals("not min, up to med", medId-minId, result.length);
108 result = search.search(q,FieldCacheRangeFilter.newStringRange("id",minIP,minIP,F,F), numDocs).scoreDocs;
109 assertEquals("min,min,F,F", 0, result.length);
110 result = search.search(q,FieldCacheRangeFilter.newStringRange("id",medIP,medIP,F,F), numDocs).scoreDocs;
111 assertEquals("med,med,F,F", 0, result.length);
112 result = search.search(q,FieldCacheRangeFilter.newStringRange("id",maxIP,maxIP,F,F), numDocs).scoreDocs;
113 assertEquals("max,max,F,F", 0, result.length);
115 result = search.search(q,FieldCacheRangeFilter.newStringRange("id",minIP,minIP,T,T), numDocs).scoreDocs;
116 assertEquals("min,min,T,T", 1, result.length);
117 result = search.search(q,FieldCacheRangeFilter.newStringRange("id",null,minIP,F,T), numDocs).scoreDocs;
118 assertEquals("nul,min,F,T", 1, result.length);
120 result = search.search(q,FieldCacheRangeFilter.newStringRange("id",maxIP,maxIP,T,T), numDocs).scoreDocs;
121 assertEquals("max,max,T,T", 1, result.length);
122 result = search.search(q,FieldCacheRangeFilter.newStringRange("id",maxIP,null,T,F), numDocs).scoreDocs;
123 assertEquals("max,nul,T,T", 1, result.length);
125 result = search.search(q,FieldCacheRangeFilter.newStringRange("id",medIP,medIP,T,T), numDocs).scoreDocs;
126 assertEquals("med,med,T,T", 1, result.length);
131 public void testFieldCacheRangeFilterRand() throws IOException {
133 IndexReader reader = signedIndexReader;
134 IndexSearcher search = newSearcher(reader);
136 String minRP = pad(signedIndexDir.minR);
137 String maxRP = pad(signedIndexDir.maxR);
139 int numDocs = reader.numDocs();
141 assertEquals("num of docs", numDocs, 1+ maxId - minId);
144 Query q = new TermQuery(new Term("body","body"));
146 // test extremes, bounded on both ends
148 result = search.search(q,FieldCacheRangeFilter.newStringRange("rand",minRP,maxRP,T,T), numDocs).scoreDocs;
149 assertEquals("find all", numDocs, result.length);
151 result = search.search(q,FieldCacheRangeFilter.newStringRange("rand",minRP,maxRP,T,F), numDocs).scoreDocs;
152 assertEquals("all but biggest", numDocs-1, result.length);
154 result = search.search(q,FieldCacheRangeFilter.newStringRange("rand",minRP,maxRP,F,T), numDocs).scoreDocs;
155 assertEquals("all but smallest", numDocs-1, result.length);
157 result = search.search(q,FieldCacheRangeFilter.newStringRange("rand",minRP,maxRP,F,F), numDocs).scoreDocs;
158 assertEquals("all but extremes", numDocs-2, result.length);
162 result = search.search(q,FieldCacheRangeFilter.newStringRange("rand",minRP,null,T,F), numDocs).scoreDocs;
163 assertEquals("smallest and up", numDocs, result.length);
165 result = search.search(q,FieldCacheRangeFilter.newStringRange("rand",null,maxRP,F,T), numDocs).scoreDocs;
166 assertEquals("biggest and down", numDocs, result.length);
168 result = search.search(q,FieldCacheRangeFilter.newStringRange("rand",minRP,null,F,F), numDocs).scoreDocs;
169 assertEquals("not smallest, but up", numDocs-1, result.length);
171 result = search.search(q,FieldCacheRangeFilter.newStringRange("rand",null,maxRP,F,F), numDocs).scoreDocs;
172 assertEquals("not biggest, but down", numDocs-1, result.length);
176 result = search.search(q,FieldCacheRangeFilter.newStringRange("rand",minRP,minRP,F,F), numDocs).scoreDocs;
177 assertEquals("min,min,F,F", 0, result.length);
178 result = search.search(q,FieldCacheRangeFilter.newStringRange("rand",maxRP,maxRP,F,F), numDocs).scoreDocs;
179 assertEquals("max,max,F,F", 0, result.length);
181 result = search.search(q,FieldCacheRangeFilter.newStringRange("rand",minRP,minRP,T,T), numDocs).scoreDocs;
182 assertEquals("min,min,T,T", 1, result.length);
183 result = search.search(q,FieldCacheRangeFilter.newStringRange("rand",null,minRP,F,T), numDocs).scoreDocs;
184 assertEquals("nul,min,F,T", 1, result.length);
186 result = search.search(q,FieldCacheRangeFilter.newStringRange("rand",maxRP,maxRP,T,T), numDocs).scoreDocs;
187 assertEquals("max,max,T,T", 1, result.length);
188 result = search.search(q,FieldCacheRangeFilter.newStringRange("rand",maxRP,null,T,F), numDocs).scoreDocs;
189 assertEquals("max,nul,T,T", 1, result.length);
193 // byte-ranges cannot be tested, because all ranges are too big for bytes, need an extra range for that
196 public void testFieldCacheRangeFilterShorts() throws IOException {
198 IndexReader reader = signedIndexReader;
199 IndexSearcher search = newSearcher(reader);
201 int numDocs = reader.numDocs();
202 int medId = ((maxId - minId) / 2);
203 Short minIdO = Short.valueOf((short) minId);
204 Short maxIdO = Short.valueOf((short) maxId);
205 Short medIdO = Short.valueOf((short) medId);
207 assertEquals("num of docs", numDocs, 1+ maxId - minId);
210 Query q = new TermQuery(new Term("body","body"));
212 // test id, bounded on both ends
213 FieldCacheRangeFilter<Short> fcrf;
214 result = search.search(q,fcrf=FieldCacheRangeFilter.newShortRange("id",minIdO,maxIdO,T,T), numDocs).scoreDocs;
215 assertTrue(fcrf.getDocIdSet(reader.getSequentialSubReaders()[0]).isCacheable());
216 assertEquals("find all", numDocs, result.length);
218 result = search.search(q,FieldCacheRangeFilter.newShortRange("id",minIdO,maxIdO,T,F), numDocs).scoreDocs;
219 assertEquals("all but last", numDocs-1, result.length);
221 result = search.search(q,FieldCacheRangeFilter.newShortRange("id",minIdO,maxIdO,F,T), numDocs).scoreDocs;
222 assertEquals("all but first", numDocs-1, result.length);
224 result = search.search(q,FieldCacheRangeFilter.newShortRange("id",minIdO,maxIdO,F,F), numDocs).scoreDocs;
225 assertEquals("all but ends", numDocs-2, result.length);
227 result = search.search(q,FieldCacheRangeFilter.newShortRange("id",medIdO,maxIdO,T,T), numDocs).scoreDocs;
228 assertEquals("med and up", 1+ maxId-medId, result.length);
230 result = search.search(q,FieldCacheRangeFilter.newShortRange("id",minIdO,medIdO,T,T), numDocs).scoreDocs;
231 assertEquals("up to med", 1+ medId-minId, result.length);
235 result = search.search(q,FieldCacheRangeFilter.newShortRange("id",null,null,T,T), numDocs).scoreDocs;
236 assertEquals("find all", numDocs, result.length);
238 result = search.search(q,FieldCacheRangeFilter.newShortRange("id",minIdO,null,T,F), numDocs).scoreDocs;
239 assertEquals("min and up", numDocs, result.length);
241 result = search.search(q,FieldCacheRangeFilter.newShortRange("id",null,maxIdO,F,T), numDocs).scoreDocs;
242 assertEquals("max and down", numDocs, result.length);
244 result = search.search(q,FieldCacheRangeFilter.newShortRange("id",minIdO,null,F,F), numDocs).scoreDocs;
245 assertEquals("not min, but up", numDocs-1, result.length);
247 result = search.search(q,FieldCacheRangeFilter.newShortRange("id",null,maxIdO,F,F), numDocs).scoreDocs;
248 assertEquals("not max, but down", numDocs-1, result.length);
250 result = search.search(q,FieldCacheRangeFilter.newShortRange("id",medIdO,maxIdO,T,F), numDocs).scoreDocs;
251 assertEquals("med and up, not max", maxId-medId, result.length);
253 result = search.search(q,FieldCacheRangeFilter.newShortRange("id",minIdO,medIdO,F,T), numDocs).scoreDocs;
254 assertEquals("not min, up to med", medId-minId, result.length);
258 result = search.search(q,FieldCacheRangeFilter.newShortRange("id",minIdO,minIdO,F,F), numDocs).scoreDocs;
259 assertEquals("min,min,F,F", 0, result.length);
260 result = search.search(q,FieldCacheRangeFilter.newShortRange("id",medIdO,medIdO,F,F), numDocs).scoreDocs;
261 assertEquals("med,med,F,F", 0, result.length);
262 result = search.search(q,FieldCacheRangeFilter.newShortRange("id",maxIdO,maxIdO,F,F), numDocs).scoreDocs;
263 assertEquals("max,max,F,F", 0, result.length);
265 result = search.search(q,FieldCacheRangeFilter.newShortRange("id",minIdO,minIdO,T,T), numDocs).scoreDocs;
266 assertEquals("min,min,T,T", 1, result.length);
267 result = search.search(q,FieldCacheRangeFilter.newShortRange("id",null,minIdO,F,T), numDocs).scoreDocs;
268 assertEquals("nul,min,F,T", 1, result.length);
270 result = search.search(q,FieldCacheRangeFilter.newShortRange("id",maxIdO,maxIdO,T,T), numDocs).scoreDocs;
271 assertEquals("max,max,T,T", 1, result.length);
272 result = search.search(q,FieldCacheRangeFilter.newShortRange("id",maxIdO,null,T,F), numDocs).scoreDocs;
273 assertEquals("max,nul,T,T", 1, result.length);
275 result = search.search(q,FieldCacheRangeFilter.newShortRange("id",medIdO,medIdO,T,T), numDocs).scoreDocs;
276 assertEquals("med,med,T,T", 1, result.length);
279 result = search.search(q,FieldCacheRangeFilter.newShortRange("id",Short.valueOf(Short.MAX_VALUE),null,F,F), numDocs).scoreDocs;
280 assertEquals("overflow special case", 0, result.length);
281 result = search.search(q,FieldCacheRangeFilter.newShortRange("id",null,Short.valueOf(Short.MIN_VALUE),F,F), numDocs).scoreDocs;
282 assertEquals("overflow special case", 0, result.length);
283 result = search.search(q,FieldCacheRangeFilter.newShortRange("id",maxIdO,minIdO,T,T), numDocs).scoreDocs;
284 assertEquals("inverse range", 0, result.length);
289 public void testFieldCacheRangeFilterInts() throws IOException {
291 IndexReader reader = signedIndexReader;
292 IndexSearcher search = newSearcher(reader);
294 int numDocs = reader.numDocs();
295 int medId = ((maxId - minId) / 2);
296 Integer minIdO = Integer.valueOf(minId);
297 Integer maxIdO = Integer.valueOf(maxId);
298 Integer medIdO = Integer.valueOf(medId);
300 assertEquals("num of docs", numDocs, 1+ maxId - minId);
303 Query q = new TermQuery(new Term("body","body"));
305 // test id, bounded on both ends
307 FieldCacheRangeFilter<Integer> fcrf;
308 result = search.search(q,fcrf=FieldCacheRangeFilter.newIntRange("id",minIdO,maxIdO,T,T), numDocs).scoreDocs;
309 assertTrue(fcrf.getDocIdSet(reader.getSequentialSubReaders()[0]).isCacheable());
310 assertEquals("find all", numDocs, result.length);
312 result = search.search(q,FieldCacheRangeFilter.newIntRange("id",minIdO,maxIdO,T,F), numDocs).scoreDocs;
313 assertEquals("all but last", numDocs-1, result.length);
315 result = search.search(q,FieldCacheRangeFilter.newIntRange("id",minIdO,maxIdO,F,T), numDocs).scoreDocs;
316 assertEquals("all but first", numDocs-1, result.length);
318 result = search.search(q,FieldCacheRangeFilter.newIntRange("id",minIdO,maxIdO,F,F), numDocs).scoreDocs;
319 assertEquals("all but ends", numDocs-2, result.length);
321 result = search.search(q,FieldCacheRangeFilter.newIntRange("id",medIdO,maxIdO,T,T), numDocs).scoreDocs;
322 assertEquals("med and up", 1+ maxId-medId, result.length);
324 result = search.search(q,FieldCacheRangeFilter.newIntRange("id",minIdO,medIdO,T,T), numDocs).scoreDocs;
325 assertEquals("up to med", 1+ medId-minId, result.length);
329 result = search.search(q,FieldCacheRangeFilter.newIntRange("id",null,null,T,T), numDocs).scoreDocs;
330 assertEquals("find all", numDocs, result.length);
332 result = search.search(q,FieldCacheRangeFilter.newIntRange("id",minIdO,null,T,F), numDocs).scoreDocs;
333 assertEquals("min and up", numDocs, result.length);
335 result = search.search(q,FieldCacheRangeFilter.newIntRange("id",null,maxIdO,F,T), numDocs).scoreDocs;
336 assertEquals("max and down", numDocs, result.length);
338 result = search.search(q,FieldCacheRangeFilter.newIntRange("id",minIdO,null,F,F), numDocs).scoreDocs;
339 assertEquals("not min, but up", numDocs-1, result.length);
341 result = search.search(q,FieldCacheRangeFilter.newIntRange("id",null,maxIdO,F,F), numDocs).scoreDocs;
342 assertEquals("not max, but down", numDocs-1, result.length);
344 result = search.search(q,FieldCacheRangeFilter.newIntRange("id",medIdO,maxIdO,T,F), numDocs).scoreDocs;
345 assertEquals("med and up, not max", maxId-medId, result.length);
347 result = search.search(q,FieldCacheRangeFilter.newIntRange("id",minIdO,medIdO,F,T), numDocs).scoreDocs;
348 assertEquals("not min, up to med", medId-minId, result.length);
352 result = search.search(q,FieldCacheRangeFilter.newIntRange("id",minIdO,minIdO,F,F), numDocs).scoreDocs;
353 assertEquals("min,min,F,F", 0, result.length);
354 result = search.search(q,FieldCacheRangeFilter.newIntRange("id",medIdO,medIdO,F,F), numDocs).scoreDocs;
355 assertEquals("med,med,F,F", 0, result.length);
356 result = search.search(q,FieldCacheRangeFilter.newIntRange("id",maxIdO,maxIdO,F,F), numDocs).scoreDocs;
357 assertEquals("max,max,F,F", 0, result.length);
359 result = search.search(q,FieldCacheRangeFilter.newIntRange("id",minIdO,minIdO,T,T), numDocs).scoreDocs;
360 assertEquals("min,min,T,T", 1, result.length);
361 result = search.search(q,FieldCacheRangeFilter.newIntRange("id",null,minIdO,F,T), numDocs).scoreDocs;
362 assertEquals("nul,min,F,T", 1, result.length);
364 result = search.search(q,FieldCacheRangeFilter.newIntRange("id",maxIdO,maxIdO,T,T), numDocs).scoreDocs;
365 assertEquals("max,max,T,T", 1, result.length);
366 result = search.search(q,FieldCacheRangeFilter.newIntRange("id",maxIdO,null,T,F), numDocs).scoreDocs;
367 assertEquals("max,nul,T,T", 1, result.length);
369 result = search.search(q,FieldCacheRangeFilter.newIntRange("id",medIdO,medIdO,T,T), numDocs).scoreDocs;
370 assertEquals("med,med,T,T", 1, result.length);
373 result = search.search(q,FieldCacheRangeFilter.newIntRange("id",Integer.valueOf(Integer.MAX_VALUE),null,F,F), numDocs).scoreDocs;
374 assertEquals("overflow special case", 0, result.length);
375 result = search.search(q,FieldCacheRangeFilter.newIntRange("id",null,Integer.valueOf(Integer.MIN_VALUE),F,F), numDocs).scoreDocs;
376 assertEquals("overflow special case", 0, result.length);
377 result = search.search(q,FieldCacheRangeFilter.newIntRange("id",maxIdO,minIdO,T,T), numDocs).scoreDocs;
378 assertEquals("inverse range", 0, result.length);
383 public void testFieldCacheRangeFilterLongs() throws IOException {
385 IndexReader reader = signedIndexReader;
386 IndexSearcher search = newSearcher(reader);
388 int numDocs = reader.numDocs();
389 int medId = ((maxId - minId) / 2);
390 Long minIdO = Long.valueOf(minId);
391 Long maxIdO = Long.valueOf(maxId);
392 Long medIdO = Long.valueOf(medId);
394 assertEquals("num of docs", numDocs, 1+ maxId - minId);
397 Query q = new TermQuery(new Term("body","body"));
399 // test id, bounded on both ends
401 FieldCacheRangeFilter<Long> fcrf;
402 result = search.search(q,fcrf=FieldCacheRangeFilter.newLongRange("id",minIdO,maxIdO,T,T), numDocs).scoreDocs;
403 assertTrue(fcrf.getDocIdSet(reader.getSequentialSubReaders()[0]).isCacheable());
404 assertEquals("find all", numDocs, result.length);
406 result = search.search(q,FieldCacheRangeFilter.newLongRange("id",minIdO,maxIdO,T,F), numDocs).scoreDocs;
407 assertEquals("all but last", numDocs-1, result.length);
409 result = search.search(q,FieldCacheRangeFilter.newLongRange("id",minIdO,maxIdO,F,T), numDocs).scoreDocs;
410 assertEquals("all but first", numDocs-1, result.length);
412 result = search.search(q,FieldCacheRangeFilter.newLongRange("id",minIdO,maxIdO,F,F), numDocs).scoreDocs;
413 assertEquals("all but ends", numDocs-2, result.length);
415 result = search.search(q,FieldCacheRangeFilter.newLongRange("id",medIdO,maxIdO,T,T), numDocs).scoreDocs;
416 assertEquals("med and up", 1+ maxId-medId, result.length);
418 result = search.search(q,FieldCacheRangeFilter.newLongRange("id",minIdO,medIdO,T,T), numDocs).scoreDocs;
419 assertEquals("up to med", 1+ medId-minId, result.length);
423 result = search.search(q,FieldCacheRangeFilter.newLongRange("id",null,null,T,T), numDocs).scoreDocs;
424 assertEquals("find all", numDocs, result.length);
426 result = search.search(q,FieldCacheRangeFilter.newLongRange("id",minIdO,null,T,F), numDocs).scoreDocs;
427 assertEquals("min and up", numDocs, result.length);
429 result = search.search(q,FieldCacheRangeFilter.newLongRange("id",null,maxIdO,F,T), numDocs).scoreDocs;
430 assertEquals("max and down", numDocs, result.length);
432 result = search.search(q,FieldCacheRangeFilter.newLongRange("id",minIdO,null,F,F), numDocs).scoreDocs;
433 assertEquals("not min, but up", numDocs-1, result.length);
435 result = search.search(q,FieldCacheRangeFilter.newLongRange("id",null,maxIdO,F,F), numDocs).scoreDocs;
436 assertEquals("not max, but down", numDocs-1, result.length);
438 result = search.search(q,FieldCacheRangeFilter.newLongRange("id",medIdO,maxIdO,T,F), numDocs).scoreDocs;
439 assertEquals("med and up, not max", maxId-medId, result.length);
441 result = search.search(q,FieldCacheRangeFilter.newLongRange("id",minIdO,medIdO,F,T), numDocs).scoreDocs;
442 assertEquals("not min, up to med", medId-minId, result.length);
446 result = search.search(q,FieldCacheRangeFilter.newLongRange("id",minIdO,minIdO,F,F), numDocs).scoreDocs;
447 assertEquals("min,min,F,F", 0, result.length);
448 result = search.search(q,FieldCacheRangeFilter.newLongRange("id",medIdO,medIdO,F,F), numDocs).scoreDocs;
449 assertEquals("med,med,F,F", 0, result.length);
450 result = search.search(q,FieldCacheRangeFilter.newLongRange("id",maxIdO,maxIdO,F,F), numDocs).scoreDocs;
451 assertEquals("max,max,F,F", 0, result.length);
453 result = search.search(q,FieldCacheRangeFilter.newLongRange("id",minIdO,minIdO,T,T), numDocs).scoreDocs;
454 assertEquals("min,min,T,T", 1, result.length);
455 result = search.search(q,FieldCacheRangeFilter.newLongRange("id",null,minIdO,F,T), numDocs).scoreDocs;
456 assertEquals("nul,min,F,T", 1, result.length);
458 result = search.search(q,FieldCacheRangeFilter.newLongRange("id",maxIdO,maxIdO,T,T), numDocs).scoreDocs;
459 assertEquals("max,max,T,T", 1, result.length);
460 result = search.search(q,FieldCacheRangeFilter.newLongRange("id",maxIdO,null,T,F), numDocs).scoreDocs;
461 assertEquals("max,nul,T,T", 1, result.length);
463 result = search.search(q,FieldCacheRangeFilter.newLongRange("id",medIdO,medIdO,T,T), numDocs).scoreDocs;
464 assertEquals("med,med,T,T", 1, result.length);
467 result = search.search(q,FieldCacheRangeFilter.newLongRange("id",Long.valueOf(Long.MAX_VALUE),null,F,F), numDocs).scoreDocs;
468 assertEquals("overflow special case", 0, result.length);
469 result = search.search(q,FieldCacheRangeFilter.newLongRange("id",null,Long.valueOf(Long.MIN_VALUE),F,F), numDocs).scoreDocs;
470 assertEquals("overflow special case", 0, result.length);
471 result = search.search(q,FieldCacheRangeFilter.newLongRange("id",maxIdO,minIdO,T,T), numDocs).scoreDocs;
472 assertEquals("inverse range", 0, result.length);
476 // float and double tests are a bit minimalistic, but its complicated, because missing precision
479 public void testFieldCacheRangeFilterFloats() throws IOException {
481 IndexReader reader = signedIndexReader;
482 IndexSearcher search = newSearcher(reader);
484 int numDocs = reader.numDocs();
485 Float minIdO = Float.valueOf(minId + .5f);
486 Float medIdO = Float.valueOf(minIdO.floatValue() + ((maxId-minId))/2.0f);
489 Query q = new TermQuery(new Term("body","body"));
491 result = search.search(q,FieldCacheRangeFilter.newFloatRange("id",minIdO,medIdO,T,T), numDocs).scoreDocs;
492 assertEquals("find all", numDocs/2, result.length);
494 result = search.search(q,FieldCacheRangeFilter.newFloatRange("id",null,medIdO,F,T), numDocs).scoreDocs;
495 count += result.length;
496 result = search.search(q,FieldCacheRangeFilter.newFloatRange("id",medIdO,null,F,F), numDocs).scoreDocs;
497 count += result.length;
498 assertEquals("sum of two concenatted ranges", numDocs, count);
499 result = search.search(q,FieldCacheRangeFilter.newFloatRange("id",null,null,T,T), numDocs).scoreDocs;
500 assertEquals("find all", numDocs, result.length);
501 result = search.search(q,FieldCacheRangeFilter.newFloatRange("id",Float.valueOf(Float.POSITIVE_INFINITY),null,F,F), numDocs).scoreDocs;
502 assertEquals("infinity special case", 0, result.length);
503 result = search.search(q,FieldCacheRangeFilter.newFloatRange("id",null,Float.valueOf(Float.NEGATIVE_INFINITY),F,F), numDocs).scoreDocs;
504 assertEquals("infinity special case", 0, result.length);
509 public void testFieldCacheRangeFilterDoubles() throws IOException {
511 IndexReader reader = signedIndexReader;
512 IndexSearcher search = newSearcher(reader);
514 int numDocs = reader.numDocs();
515 Double minIdO = Double.valueOf(minId + .5);
516 Double medIdO = Double.valueOf(minIdO.floatValue() + ((maxId-minId))/2.0);
519 Query q = new TermQuery(new Term("body","body"));
521 result = search.search(q,FieldCacheRangeFilter.newDoubleRange("id",minIdO,medIdO,T,T), numDocs).scoreDocs;
522 assertEquals("find all", numDocs/2, result.length);
524 result = search.search(q,FieldCacheRangeFilter.newDoubleRange("id",null,medIdO,F,T), numDocs).scoreDocs;
525 count += result.length;
526 result = search.search(q,FieldCacheRangeFilter.newDoubleRange("id",medIdO,null,F,F), numDocs).scoreDocs;
527 count += result.length;
528 assertEquals("sum of two concenatted ranges", numDocs, count);
529 result = search.search(q,FieldCacheRangeFilter.newDoubleRange("id",null,null,T,T), numDocs).scoreDocs;
530 assertEquals("find all", numDocs, result.length);
531 result = search.search(q,FieldCacheRangeFilter.newDoubleRange("id",Double.valueOf(Double.POSITIVE_INFINITY),null,F,F), numDocs).scoreDocs;
532 assertEquals("infinity special case", 0, result.length);
533 result = search.search(q,FieldCacheRangeFilter.newDoubleRange("id",null, Double.valueOf(Double.NEGATIVE_INFINITY),F,F), numDocs).scoreDocs;
534 assertEquals("infinity special case", 0, result.length);
538 // test using a sparse index (with deleted docs). The DocIdSet should be not cacheable, as it uses TermDocs if the range contains 0
540 public void testSparseIndex() throws IOException {
541 Directory dir = newDirectory();
542 IndexWriter writer = new IndexWriter(dir, newIndexWriterConfig( TEST_VERSION_CURRENT, new MockAnalyzer(random)));
544 for (int d = -20; d <= 20; d++) {
545 Document doc = new Document();
546 doc.add(newField("id",Integer.toString(d), Field.Store.NO, Field.Index.NOT_ANALYZED));
547 doc.add(newField("body","body", Field.Store.NO, Field.Index.NOT_ANALYZED));
548 writer.addDocument(doc);
552 writer.deleteDocuments(new Term("id","0"));
555 IndexReader reader = IndexReader.open(dir, true);
556 IndexSearcher search = newSearcher(reader);
557 assertTrue(reader.hasDeletions());
560 FieldCacheRangeFilter<Byte> fcrf;
561 Query q = new TermQuery(new Term("body","body"));
563 result = search.search(q,fcrf=FieldCacheRangeFilter.newByteRange("id",Byte.valueOf((byte) -20),Byte.valueOf((byte) 20),T,T), 100).scoreDocs;
564 assertFalse("DocIdSet must be not cacheable", fcrf.getDocIdSet(reader.getSequentialSubReaders()[0]).isCacheable());
565 assertEquals("find all", 40, result.length);
567 result = search.search(q,fcrf=FieldCacheRangeFilter.newByteRange("id",Byte.valueOf((byte) 0),Byte.valueOf((byte) 20),T,T), 100).scoreDocs;
568 assertFalse("DocIdSet must be not cacheable", fcrf.getDocIdSet(reader.getSequentialSubReaders()[0]).isCacheable());
569 assertEquals("find all", 20, result.length);
571 result = search.search(q,fcrf=FieldCacheRangeFilter.newByteRange("id",Byte.valueOf((byte) -20),Byte.valueOf((byte) 0),T,T), 100).scoreDocs;
572 assertFalse("DocIdSet must be not cacheable", fcrf.getDocIdSet(reader.getSequentialSubReaders()[0]).isCacheable());
573 assertEquals("find all", 20, result.length);
575 result = search.search(q,fcrf=FieldCacheRangeFilter.newByteRange("id",Byte.valueOf((byte) 10),Byte.valueOf((byte) 20),T,T), 100).scoreDocs;
576 assertTrue("DocIdSet must be cacheable", fcrf.getDocIdSet(reader.getSequentialSubReaders()[0]).isCacheable());
577 assertEquals("find all", 11, result.length);
579 result = search.search(q,fcrf=FieldCacheRangeFilter.newByteRange("id",Byte.valueOf((byte) -20),Byte.valueOf((byte) -10),T,T), 100).scoreDocs;
580 assertTrue("DocIdSet must be cacheable", fcrf.getDocIdSet(reader.getSequentialSubReaders()[0]).isCacheable());
581 assertEquals("find all", 11, result.length);