lucene-java-3.4.0/lucene/backwards/src/test/org/apache/lucene/search/TestFieldCacheRangeFilter.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 java.io.IOException;
  21
  22
  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;
  31
  32 /**
  33  * A basic 'positive' Unit test class for the FieldCacheRangeFilter class.
  34  *
  35  * <p>
  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.
  40  */
  41 public class TestFieldCacheRangeFilter extends BaseTestRangeFilter {
  42
  43   @Test
  44   public void testRangeFilterId() throws IOException {
  45
  46     IndexReader reader = signedIndexReader;
  47     IndexSearcher search = newSearcher(reader);
  48
  49     int medId = ((maxId - minId) / 2);
  50
  51     String minIP = pad(minId);
  52     String maxIP = pad(maxId);
  53     String medIP = pad(medId);
  54
  55     int numDocs = reader.numDocs();
  56
  57     assertEquals("num of docs", numDocs, 1+ maxId - minId);
  58
  59     ScoreDoc[] result;
  60     Query q = new TermQuery(new Term("body","body"));
  61
  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);
  67
  68     result = search.search(q,FieldCacheRangeFilter.newStringRange("id",minIP,maxIP,T,F), numDocs).scoreDocs;
  69     assertEquals("all but last", numDocs-1, result.length);
  70
  71     result = search.search(q,FieldCacheRangeFilter.newStringRange("id",minIP,maxIP,F,T), numDocs).scoreDocs;
  72     assertEquals("all but first", numDocs-1, result.length);
  73
  74     result = search.search(q,FieldCacheRangeFilter.newStringRange("id",minIP,maxIP,F,F), numDocs).scoreDocs;
  75     assertEquals("all but ends", numDocs-2, result.length);
  76
  77     result = search.search(q,FieldCacheRangeFilter.newStringRange("id",medIP,maxIP,T,T), numDocs).scoreDocs;
  78     assertEquals("med and up", 1+ maxId-medId, result.length);
  79
  80     result = search.search(q,FieldCacheRangeFilter.newStringRange("id",minIP,medIP,T,T), numDocs).scoreDocs;
  81     assertEquals("up to med", 1+ medId-minId, result.length);
  82
  83     // unbounded id
  84
  85     result = search.search(q,FieldCacheRangeFilter.newStringRange("id",null,null,T,T), numDocs).scoreDocs;
  86     assertEquals("find all", numDocs, result.length);
  87
  88     result = search.search(q,FieldCacheRangeFilter.newStringRange("id",minIP,null,T,F), numDocs).scoreDocs;
  89     assertEquals("min and up", numDocs, result.length);
  90
  91     result = search.search(q,FieldCacheRangeFilter.newStringRange("id",null,maxIP,F,T), numDocs).scoreDocs;
  92     assertEquals("max and down", numDocs, result.length);
  93
  94     result = search.search(q,FieldCacheRangeFilter.newStringRange("id",minIP,null,F,F), numDocs).scoreDocs;
  95     assertEquals("not min, but up", numDocs-1, result.length);
  96
  97     result = search.search(q,FieldCacheRangeFilter.newStringRange("id",null,maxIP,F,F), numDocs).scoreDocs;
  98     assertEquals("not max, but down", numDocs-1, result.length);
  99
 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);
 102
 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);
 105
 106     // very small sets
 107
 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);
 114
 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);
 119
 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);
 124
 125     result = search.search(q,FieldCacheRangeFilter.newStringRange("id",medIP,medIP,T,T), numDocs).scoreDocs;
 126     assertEquals("med,med,T,T", 1, result.length);
 127     search.close();
 128   }
 129
 130   @Test
 131   public void testFieldCacheRangeFilterRand() throws IOException {
 132
 133     IndexReader reader = signedIndexReader;
 134     IndexSearcher search = newSearcher(reader);
 135
 136     String minRP = pad(signedIndexDir.minR);
 137     String maxRP = pad(signedIndexDir.maxR);
 138
 139     int numDocs = reader.numDocs();
 140
 141     assertEquals("num of docs", numDocs, 1+ maxId - minId);
 142
 143     ScoreDoc[] result;
 144     Query q = new TermQuery(new Term("body","body"));
 145
 146     // test extremes, bounded on both ends
 147
 148     result = search.search(q,FieldCacheRangeFilter.newStringRange("rand",minRP,maxRP,T,T), numDocs).scoreDocs;
 149     assertEquals("find all", numDocs, result.length);
 150
 151     result = search.search(q,FieldCacheRangeFilter.newStringRange("rand",minRP,maxRP,T,F), numDocs).scoreDocs;
 152     assertEquals("all but biggest", numDocs-1, result.length);
 153
 154     result = search.search(q,FieldCacheRangeFilter.newStringRange("rand",minRP,maxRP,F,T), numDocs).scoreDocs;
 155     assertEquals("all but smallest", numDocs-1, result.length);
 156
 157     result = search.search(q,FieldCacheRangeFilter.newStringRange("rand",minRP,maxRP,F,F), numDocs).scoreDocs;
 158     assertEquals("all but extremes", numDocs-2, result.length);
 159
 160     // unbounded
 161
 162     result = search.search(q,FieldCacheRangeFilter.newStringRange("rand",minRP,null,T,F), numDocs).scoreDocs;
 163     assertEquals("smallest and up", numDocs, result.length);
 164
 165     result = search.search(q,FieldCacheRangeFilter.newStringRange("rand",null,maxRP,F,T), numDocs).scoreDocs;
 166     assertEquals("biggest and down", numDocs, result.length);
 167
 168     result = search.search(q,FieldCacheRangeFilter.newStringRange("rand",minRP,null,F,F), numDocs).scoreDocs;
 169     assertEquals("not smallest, but up", numDocs-1, result.length);
 170
 171     result = search.search(q,FieldCacheRangeFilter.newStringRange("rand",null,maxRP,F,F), numDocs).scoreDocs;
 172     assertEquals("not biggest, but down", numDocs-1, result.length);
 173
 174     // very small sets
 175
 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);
 180
 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);
 185
 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);
 190     search.close();
 191   }
 192
 193   // byte-ranges cannot be tested, because all ranges are too big for bytes, need an extra range for that
 194
 195   @Test
 196   public void testFieldCacheRangeFilterShorts() throws IOException {
 197
 198     IndexReader reader = signedIndexReader;
 199     IndexSearcher search = newSearcher(reader);
 200
 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);
 206
 207     assertEquals("num of docs", numDocs, 1+ maxId - minId);
 208
 209     ScoreDoc[] result;
 210     Query q = new TermQuery(new Term("body","body"));
 211
 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);
 217
 218     result = search.search(q,FieldCacheRangeFilter.newShortRange("id",minIdO,maxIdO,T,F), numDocs).scoreDocs;
 219     assertEquals("all but last", numDocs-1, result.length);
 220
 221     result = search.search(q,FieldCacheRangeFilter.newShortRange("id",minIdO,maxIdO,F,T), numDocs).scoreDocs;
 222     assertEquals("all but first", numDocs-1, result.length);
 223
 224     result = search.search(q,FieldCacheRangeFilter.newShortRange("id",minIdO,maxIdO,F,F), numDocs).scoreDocs;
 225     assertEquals("all but ends", numDocs-2, result.length);
 226
 227     result = search.search(q,FieldCacheRangeFilter.newShortRange("id",medIdO,maxIdO,T,T), numDocs).scoreDocs;
 228     assertEquals("med and up", 1+ maxId-medId, result.length);
 229
 230     result = search.search(q,FieldCacheRangeFilter.newShortRange("id",minIdO,medIdO,T,T), numDocs).scoreDocs;
 231     assertEquals("up to med", 1+ medId-minId, result.length);
 232
 233     // unbounded id
 234
 235     result = search.search(q,FieldCacheRangeFilter.newShortRange("id",null,null,T,T), numDocs).scoreDocs;
 236     assertEquals("find all", numDocs, result.length);
 237
 238     result = search.search(q,FieldCacheRangeFilter.newShortRange("id",minIdO,null,T,F), numDocs).scoreDocs;
 239     assertEquals("min and up", numDocs, result.length);
 240
 241     result = search.search(q,FieldCacheRangeFilter.newShortRange("id",null,maxIdO,F,T), numDocs).scoreDocs;
 242     assertEquals("max and down", numDocs, result.length);
 243
 244     result = search.search(q,FieldCacheRangeFilter.newShortRange("id",minIdO,null,F,F), numDocs).scoreDocs;
 245     assertEquals("not min, but up", numDocs-1, result.length);
 246
 247     result = search.search(q,FieldCacheRangeFilter.newShortRange("id",null,maxIdO,F,F), numDocs).scoreDocs;
 248     assertEquals("not max, but down", numDocs-1, result.length);
 249
 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);
 252
 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);
 255
 256     // very small sets
 257
 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);
 264
 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);
 269
 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);
 274
 275     result = search.search(q,FieldCacheRangeFilter.newShortRange("id",medIdO,medIdO,T,T), numDocs).scoreDocs;
 276     assertEquals("med,med,T,T", 1, result.length);
 277
 278     // special cases
 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);
 285     search.close();
 286   }
 287
 288   @Test
 289   public void testFieldCacheRangeFilterInts() throws IOException {
 290
 291     IndexReader reader = signedIndexReader;
 292     IndexSearcher search = newSearcher(reader);
 293
 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);
 299
 300     assertEquals("num of docs", numDocs, 1+ maxId - minId);
 301
 302     ScoreDoc[] result;
 303     Query q = new TermQuery(new Term("body","body"));
 304
 305     // test id, bounded on both ends
 306
 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);
 311
 312     result = search.search(q,FieldCacheRangeFilter.newIntRange("id",minIdO,maxIdO,T,F), numDocs).scoreDocs;
 313     assertEquals("all but last", numDocs-1, result.length);
 314
 315     result = search.search(q,FieldCacheRangeFilter.newIntRange("id",minIdO,maxIdO,F,T), numDocs).scoreDocs;
 316     assertEquals("all but first", numDocs-1, result.length);
 317
 318     result = search.search(q,FieldCacheRangeFilter.newIntRange("id",minIdO,maxIdO,F,F), numDocs).scoreDocs;
 319     assertEquals("all but ends", numDocs-2, result.length);
 320
 321     result = search.search(q,FieldCacheRangeFilter.newIntRange("id",medIdO,maxIdO,T,T), numDocs).scoreDocs;
 322     assertEquals("med and up", 1+ maxId-medId, result.length);
 323
 324     result = search.search(q,FieldCacheRangeFilter.newIntRange("id",minIdO,medIdO,T,T), numDocs).scoreDocs;
 325     assertEquals("up to med", 1+ medId-minId, result.length);
 326
 327     // unbounded id
 328
 329     result = search.search(q,FieldCacheRangeFilter.newIntRange("id",null,null,T,T), numDocs).scoreDocs;
 330     assertEquals("find all", numDocs, result.length);
 331
 332     result = search.search(q,FieldCacheRangeFilter.newIntRange("id",minIdO,null,T,F), numDocs).scoreDocs;
 333     assertEquals("min and up", numDocs, result.length);
 334
 335     result = search.search(q,FieldCacheRangeFilter.newIntRange("id",null,maxIdO,F,T), numDocs).scoreDocs;
 336     assertEquals("max and down", numDocs, result.length);
 337
 338     result = search.search(q,FieldCacheRangeFilter.newIntRange("id",minIdO,null,F,F), numDocs).scoreDocs;
 339     assertEquals("not min, but up", numDocs-1, result.length);
 340
 341     result = search.search(q,FieldCacheRangeFilter.newIntRange("id",null,maxIdO,F,F), numDocs).scoreDocs;
 342     assertEquals("not max, but down", numDocs-1, result.length);
 343
 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);
 346
 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);
 349
 350     // very small sets
 351
 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);
 358
 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);
 363
 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);
 368
 369     result = search.search(q,FieldCacheRangeFilter.newIntRange("id",medIdO,medIdO,T,T), numDocs).scoreDocs;
 370     assertEquals("med,med,T,T", 1, result.length);
 371
 372     // special cases
 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);
 379     search.close();
 380   }
 381
 382   @Test
 383   public void testFieldCacheRangeFilterLongs() throws IOException {
 384
 385     IndexReader reader = signedIndexReader;
 386     IndexSearcher search = newSearcher(reader);
 387
 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);
 393
 394     assertEquals("num of docs", numDocs, 1+ maxId - minId);
 395
 396     ScoreDoc[] result;
 397     Query q = new TermQuery(new Term("body","body"));
 398
 399     // test id, bounded on both ends
 400
 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);
 405
 406     result = search.search(q,FieldCacheRangeFilter.newLongRange("id",minIdO,maxIdO,T,F), numDocs).scoreDocs;
 407     assertEquals("all but last", numDocs-1, result.length);
 408
 409     result = search.search(q,FieldCacheRangeFilter.newLongRange("id",minIdO,maxIdO,F,T), numDocs).scoreDocs;
 410     assertEquals("all but first", numDocs-1, result.length);
 411
 412     result = search.search(q,FieldCacheRangeFilter.newLongRange("id",minIdO,maxIdO,F,F), numDocs).scoreDocs;
 413     assertEquals("all but ends", numDocs-2, result.length);
 414
 415     result = search.search(q,FieldCacheRangeFilter.newLongRange("id",medIdO,maxIdO,T,T), numDocs).scoreDocs;
 416     assertEquals("med and up", 1+ maxId-medId, result.length);
 417
 418     result = search.search(q,FieldCacheRangeFilter.newLongRange("id",minIdO,medIdO,T,T), numDocs).scoreDocs;
 419     assertEquals("up to med", 1+ medId-minId, result.length);
 420
 421     // unbounded id
 422
 423     result = search.search(q,FieldCacheRangeFilter.newLongRange("id",null,null,T,T), numDocs).scoreDocs;
 424     assertEquals("find all", numDocs, result.length);
 425
 426     result = search.search(q,FieldCacheRangeFilter.newLongRange("id",minIdO,null,T,F), numDocs).scoreDocs;
 427     assertEquals("min and up", numDocs, result.length);
 428
 429     result = search.search(q,FieldCacheRangeFilter.newLongRange("id",null,maxIdO,F,T), numDocs).scoreDocs;
 430     assertEquals("max and down", numDocs, result.length);
 431
 432     result = search.search(q,FieldCacheRangeFilter.newLongRange("id",minIdO,null,F,F), numDocs).scoreDocs;
 433     assertEquals("not min, but up", numDocs-1, result.length);
 434
 435     result = search.search(q,FieldCacheRangeFilter.newLongRange("id",null,maxIdO,F,F), numDocs).scoreDocs;
 436     assertEquals("not max, but down", numDocs-1, result.length);
 437
 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);
 440
 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);
 443
 444     // very small sets
 445
 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);
 452
 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);
 457
 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);
 462
 463     result = search.search(q,FieldCacheRangeFilter.newLongRange("id",medIdO,medIdO,T,T), numDocs).scoreDocs;
 464     assertEquals("med,med,T,T", 1, result.length);
 465
 466     // special cases
 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);
 473     search.close();
 474   }
 475
 476   // float and double tests are a bit minimalistic, but its complicated, because missing precision
 477
 478   @Test
 479   public void testFieldCacheRangeFilterFloats() throws IOException {
 480
 481     IndexReader reader = signedIndexReader;
 482     IndexSearcher search = newSearcher(reader);
 483
 484     int numDocs = reader.numDocs();
 485     Float minIdO = Float.valueOf(minId + .5f);
 486     Float medIdO = Float.valueOf(minIdO.floatValue() + ((maxId-minId))/2.0f);
 487
 488     ScoreDoc[] result;
 489     Query q = new TermQuery(new Term("body","body"));
 490
 491     result = search.search(q,FieldCacheRangeFilter.newFloatRange("id",minIdO,medIdO,T,T), numDocs).scoreDocs;
 492     assertEquals("find all", numDocs/2, result.length);
 493     int count = 0;
 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);
 505     search.close();
 506   }
 507
 508   @Test
 509   public void testFieldCacheRangeFilterDoubles() throws IOException {
 510
 511     IndexReader reader = signedIndexReader;
 512     IndexSearcher search = newSearcher(reader);
 513
 514     int numDocs = reader.numDocs();
 515     Double minIdO = Double.valueOf(minId + .5);
 516     Double medIdO = Double.valueOf(minIdO.floatValue() + ((maxId-minId))/2.0);
 517
 518     ScoreDoc[] result;
 519     Query q = new TermQuery(new Term("body","body"));
 520
 521     result = search.search(q,FieldCacheRangeFilter.newDoubleRange("id",minIdO,medIdO,T,T), numDocs).scoreDocs;
 522     assertEquals("find all", numDocs/2, result.length);
 523     int count = 0;
 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);
 535     search.close();
 536   }
 537
 538   // test using a sparse index (with deleted docs). The DocIdSet should be not cacheable, as it uses TermDocs if the range contains 0
 539   @Test
 540   public void testSparseIndex() throws IOException {
 541     Directory dir = newDirectory();
 542     IndexWriter writer = new IndexWriter(dir, newIndexWriterConfig( TEST_VERSION_CURRENT, new MockAnalyzer(random)));
 543
 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);
 549     }
 550
 551     writer.optimize();
 552     writer.deleteDocuments(new Term("id","0"));
 553     writer.close();
 554
 555     IndexReader reader = IndexReader.open(dir, true);
 556     IndexSearcher search = newSearcher(reader);
 557     assertTrue(reader.hasDeletions());
 558
 559     ScoreDoc[] result;
 560     FieldCacheRangeFilter<Byte> fcrf;
 561     Query q = new TermQuery(new Term("body","body"));
 562
 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);
 566
 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);
 570
 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);
 574
 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);
 578
 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);
 582     search.close();
 583     reader.close();
 584     dir.close();
 585   }
 586
 587 }