lucene-java-3.5.0/lucene/src/test/org/apache/lucene/search/TestTermRangeFilter.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 import java.text.Collator;
  22 import java.util.Locale;
  23
  24 import org.apache.lucene.index.IndexReader;
  25 import org.apache.lucene.index.RandomIndexWriter;
  26 import org.apache.lucene.index.Term;
  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 TermRangeFilter class.
  34  *
  35  * <p>
  36  * NOTE: at the moment, this class only tests for 'positive' results, it does
  37  * not verify the results to ensure there are no 'false positives', nor does it
  38  * adequately test 'negative' results. It also does not test that garbage in
  39  * results in an Exception.
  40  */
  41 public class TestTermRangeFilter 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
  64     result = search.search(q, new TermRangeFilter("id", minIP, maxIP, T, T),
  65         numDocs).scoreDocs;
  66     assertEquals("find all", numDocs, result.length);
  67
  68     result = search.search(q, new TermRangeFilter("id", minIP, maxIP, T, F),
  69         numDocs).scoreDocs;
  70     assertEquals("all but last", numDocs - 1, result.length);
  71
  72     result = search.search(q, new TermRangeFilter("id", minIP, maxIP, F, T),
  73         numDocs).scoreDocs;
  74     assertEquals("all but first", numDocs - 1, result.length);
  75
  76     result = search.search(q, new TermRangeFilter("id", minIP, maxIP, F, F),
  77         numDocs).scoreDocs;
  78     assertEquals("all but ends", numDocs - 2, result.length);
  79
  80     result = search.search(q, new TermRangeFilter("id", medIP, maxIP, T, T),
  81         numDocs).scoreDocs;
  82     assertEquals("med and up", 1 + maxId - medId, result.length);
  83
  84     result = search.search(q, new TermRangeFilter("id", minIP, medIP, T, T),
  85         numDocs).scoreDocs;
  86     assertEquals("up to med", 1 + medId - minId, result.length);
  87
  88     // unbounded id
  89
  90     result = search.search(q, new TermRangeFilter("id", minIP, null, T, F),
  91         numDocs).scoreDocs;
  92     assertEquals("min and up", numDocs, result.length);
  93
  94     result = search.search(q, new TermRangeFilter("id", null, maxIP, F, T),
  95         numDocs).scoreDocs;
  96     assertEquals("max and down", numDocs, result.length);
  97
  98     result = search.search(q, new TermRangeFilter("id", minIP, null, F, F),
  99         numDocs).scoreDocs;
 100     assertEquals("not min, but up", numDocs - 1, result.length);
 101
 102     result = search.search(q, new TermRangeFilter("id", null, maxIP, F, F),
 103         numDocs).scoreDocs;
 104     assertEquals("not max, but down", numDocs - 1, result.length);
 105
 106     result = search.search(q, new TermRangeFilter("id", medIP, maxIP, T, F),
 107         numDocs).scoreDocs;
 108     assertEquals("med and up, not max", maxId - medId, result.length);
 109
 110     result = search.search(q, new TermRangeFilter("id", minIP, medIP, F, T),
 111         numDocs).scoreDocs;
 112     assertEquals("not min, up to med", medId - minId, result.length);
 113
 114     // very small sets
 115
 116     result = search.search(q, new TermRangeFilter("id", minIP, minIP, F, F),
 117         numDocs).scoreDocs;
 118     assertEquals("min,min,F,F", 0, result.length);
 119     result = search.search(q, new TermRangeFilter("id", medIP, medIP, F, F),
 120         numDocs).scoreDocs;
 121     assertEquals("med,med,F,F", 0, result.length);
 122     result = search.search(q, new TermRangeFilter("id", maxIP, maxIP, F, F),
 123         numDocs).scoreDocs;
 124     assertEquals("max,max,F,F", 0, result.length);
 125
 126     result = search.search(q, new TermRangeFilter("id", minIP, minIP, T, T),
 127         numDocs).scoreDocs;
 128     assertEquals("min,min,T,T", 1, result.length);
 129     result = search.search(q, new TermRangeFilter("id", null, minIP, F, T),
 130         numDocs).scoreDocs;
 131     assertEquals("nul,min,F,T", 1, result.length);
 132
 133     result = search.search(q, new TermRangeFilter("id", maxIP, maxIP, T, T),
 134         numDocs).scoreDocs;
 135     assertEquals("max,max,T,T", 1, result.length);
 136     result = search.search(q, new TermRangeFilter("id", maxIP, null, T, F),
 137         numDocs).scoreDocs;
 138     assertEquals("max,nul,T,T", 1, result.length);
 139
 140     result = search.search(q, new TermRangeFilter("id", medIP, medIP, T, T),
 141         numDocs).scoreDocs;
 142     assertEquals("med,med,T,T", 1, result.length);
 143
 144     search.close();
 145   }
 146
 147   @Test
 148   public void testRangeFilterIdCollating() throws IOException {
 149
 150     IndexReader reader = signedIndexReader;
 151     IndexSearcher search = newSearcher(reader);
 152
 153     Collator c = Collator.getInstance(Locale.ENGLISH);
 154
 155     int medId = ((maxId - minId) / 2);
 156
 157     String minIP = pad(minId);
 158     String maxIP = pad(maxId);
 159     String medIP = pad(medId);
 160
 161     int numDocs = reader.numDocs();
 162
 163     assertEquals("num of docs", numDocs, 1 + maxId - minId);
 164
 165     Query q = new TermQuery(new Term("body", "body"));
 166
 167     // test id, bounded on both ends
 168     int numHits = search.search(q, new TermRangeFilter("id", minIP, maxIP, T,
 169         T, c), 1000).totalHits;
 170     assertEquals("find all", numDocs, numHits);
 171
 172     numHits = search.search(q,
 173         new TermRangeFilter("id", minIP, maxIP, T, F, c), 1000).totalHits;
 174     assertEquals("all but last", numDocs - 1, numHits);
 175
 176     numHits = search.search(q,
 177         new TermRangeFilter("id", minIP, maxIP, F, T, c), 1000).totalHits;
 178     assertEquals("all but first", numDocs - 1, numHits);
 179
 180     numHits = search.search(q,
 181         new TermRangeFilter("id", minIP, maxIP, F, F, c), 1000).totalHits;
 182     assertEquals("all but ends", numDocs - 2, numHits);
 183
 184     numHits = search.search(q,
 185         new TermRangeFilter("id", medIP, maxIP, T, T, c), 1000).totalHits;
 186     assertEquals("med and up", 1 + maxId - medId, numHits);
 187
 188     numHits = search.search(q,
 189         new TermRangeFilter("id", minIP, medIP, T, T, c), 1000).totalHits;
 190     assertEquals("up to med", 1 + medId - minId, numHits);
 191
 192     // unbounded id
 193
 194     numHits = search.search(q, new TermRangeFilter("id", minIP, null, T, F, c),
 195         1000).totalHits;
 196     assertEquals("min and up", numDocs, numHits);
 197
 198     numHits = search.search(q, new TermRangeFilter("id", null, maxIP, F, T, c),
 199         1000).totalHits;
 200     assertEquals("max and down", numDocs, numHits);
 201
 202     numHits = search.search(q, new TermRangeFilter("id", minIP, null, F, F, c),
 203         1000).totalHits;
 204     assertEquals("not min, but up", numDocs - 1, numHits);
 205
 206     numHits = search.search(q, new TermRangeFilter("id", null, maxIP, F, F, c),
 207         1000).totalHits;
 208     assertEquals("not max, but down", numDocs - 1, numHits);
 209
 210     numHits = search.search(q,
 211         new TermRangeFilter("id", medIP, maxIP, T, F, c), 1000).totalHits;
 212     assertEquals("med and up, not max", maxId - medId, numHits);
 213
 214     numHits = search.search(q,
 215         new TermRangeFilter("id", minIP, medIP, F, T, c), 1000).totalHits;
 216     assertEquals("not min, up to med", medId - minId, numHits);
 217
 218     // very small sets
 219
 220     numHits = search.search(q,
 221         new TermRangeFilter("id", minIP, minIP, F, F, c), 1000).totalHits;
 222     assertEquals("min,min,F,F", 0, numHits);
 223     numHits = search.search(q,
 224         new TermRangeFilter("id", medIP, medIP, F, F, c), 1000).totalHits;
 225     assertEquals("med,med,F,F", 0, numHits);
 226     numHits = search.search(q,
 227         new TermRangeFilter("id", maxIP, maxIP, F, F, c), 1000).totalHits;
 228     assertEquals("max,max,F,F", 0, numHits);
 229
 230     numHits = search.search(q,
 231         new TermRangeFilter("id", minIP, minIP, T, T, c), 1000).totalHits;
 232     assertEquals("min,min,T,T", 1, numHits);
 233     numHits = search.search(q, new TermRangeFilter("id", null, minIP, F, T, c),
 234         1000).totalHits;
 235     assertEquals("nul,min,F,T", 1, numHits);
 236
 237     numHits = search.search(q,
 238         new TermRangeFilter("id", maxIP, maxIP, T, T, c), 1000).totalHits;
 239     assertEquals("max,max,T,T", 1, numHits);
 240     numHits = search.search(q, new TermRangeFilter("id", maxIP, null, T, F, c),
 241         1000).totalHits;
 242     assertEquals("max,nul,T,T", 1, numHits);
 243
 244     numHits = search.search(q,
 245         new TermRangeFilter("id", medIP, medIP, T, T, c), 1000).totalHits;
 246     assertEquals("med,med,T,T", 1, numHits);
 247
 248     search.close();
 249   }
 250
 251   @Test
 252   public void testRangeFilterRand() throws IOException {
 253
 254     IndexReader reader = signedIndexReader;
 255     IndexSearcher search = newSearcher(reader);
 256
 257     String minRP = pad(signedIndexDir.minR);
 258     String maxRP = pad(signedIndexDir.maxR);
 259
 260     int numDocs = reader.numDocs();
 261
 262     assertEquals("num of docs", numDocs, 1 + maxId - minId);
 263
 264     ScoreDoc[] result;
 265     Query q = new TermQuery(new Term("body", "body"));
 266
 267     // test extremes, bounded on both ends
 268
 269     result = search.search(q, new TermRangeFilter("rand", minRP, maxRP, T, T),
 270         numDocs).scoreDocs;
 271     assertEquals("find all", numDocs, result.length);
 272
 273     result = search.search(q, new TermRangeFilter("rand", minRP, maxRP, T, F),
 274         numDocs).scoreDocs;
 275     assertEquals("all but biggest", numDocs - 1, result.length);
 276
 277     result = search.search(q, new TermRangeFilter("rand", minRP, maxRP, F, T),
 278         numDocs).scoreDocs;
 279     assertEquals("all but smallest", numDocs - 1, result.length);
 280
 281     result = search.search(q, new TermRangeFilter("rand", minRP, maxRP, F, F),
 282         numDocs).scoreDocs;
 283     assertEquals("all but extremes", numDocs - 2, result.length);
 284
 285     // unbounded
 286
 287     result = search.search(q, new TermRangeFilter("rand", minRP, null, T, F),
 288         numDocs).scoreDocs;
 289     assertEquals("smallest and up", numDocs, result.length);
 290
 291     result = search.search(q, new TermRangeFilter("rand", null, maxRP, F, T),
 292         numDocs).scoreDocs;
 293     assertEquals("biggest and down", numDocs, result.length);
 294
 295     result = search.search(q, new TermRangeFilter("rand", minRP, null, F, F),
 296         numDocs).scoreDocs;
 297     assertEquals("not smallest, but up", numDocs - 1, result.length);
 298
 299     result = search.search(q, new TermRangeFilter("rand", null, maxRP, F, F),
 300         numDocs).scoreDocs;
 301     assertEquals("not biggest, but down", numDocs - 1, result.length);
 302
 303     // very small sets
 304
 305     result = search.search(q, new TermRangeFilter("rand", minRP, minRP, F, F),
 306         numDocs).scoreDocs;
 307     assertEquals("min,min,F,F", 0, result.length);
 308     result = search.search(q, new TermRangeFilter("rand", maxRP, maxRP, F, F),
 309         numDocs).scoreDocs;
 310     assertEquals("max,max,F,F", 0, result.length);
 311
 312     result = search.search(q, new TermRangeFilter("rand", minRP, minRP, T, T),
 313         numDocs).scoreDocs;
 314     assertEquals("min,min,T,T", 1, result.length);
 315     result = search.search(q, new TermRangeFilter("rand", null, minRP, F, T),
 316         numDocs).scoreDocs;
 317     assertEquals("nul,min,F,T", 1, result.length);
 318
 319     result = search.search(q, new TermRangeFilter("rand", maxRP, maxRP, T, T),
 320         numDocs).scoreDocs;
 321     assertEquals("max,max,T,T", 1, result.length);
 322     result = search.search(q, new TermRangeFilter("rand", maxRP, null, T, F),
 323         numDocs).scoreDocs;
 324     assertEquals("max,nul,T,T", 1, result.length);
 325
 326     search.close();
 327   }
 328
 329   @Test
 330   public void testRangeFilterRandCollating() throws IOException {
 331
 332     // using the unsigned index because collation seems to ignore hyphens
 333     IndexReader reader = unsignedIndexReader;
 334     IndexSearcher search = newSearcher(reader);
 335
 336     Collator c = Collator.getInstance(Locale.ENGLISH);
 337
 338     String minRP = pad(unsignedIndexDir.minR);
 339     String maxRP = pad(unsignedIndexDir.maxR);
 340
 341     int numDocs = reader.numDocs();
 342
 343     assertEquals("num of docs", numDocs, 1 + maxId - minId);
 344
 345     Query q = new TermQuery(new Term("body", "body"));
 346
 347     // test extremes, bounded on both ends
 348
 349     int numHits = search.search(q, new TermRangeFilter("rand", minRP, maxRP, T,
 350         T, c), 1000).totalHits;
 351     assertEquals("find all", numDocs, numHits);
 352
 353     numHits = search.search(q, new TermRangeFilter("rand", minRP, maxRP, T, F,
 354         c), 1000).totalHits;
 355     assertEquals("all but biggest", numDocs - 1, numHits);
 356
 357     numHits = search.search(q, new TermRangeFilter("rand", minRP, maxRP, F, T,
 358         c), 1000).totalHits;
 359     assertEquals("all but smallest", numDocs - 1, numHits);
 360
 361     numHits = search.search(q, new TermRangeFilter("rand", minRP, maxRP, F, F,
 362         c), 1000).totalHits;
 363     assertEquals("all but extremes", numDocs - 2, numHits);
 364
 365     // unbounded
 366
 367     numHits = search.search(q,
 368         new TermRangeFilter("rand", minRP, null, T, F, c), 1000).totalHits;
 369     assertEquals("smallest and up", numDocs, numHits);
 370
 371     numHits = search.search(q,
 372         new TermRangeFilter("rand", null, maxRP, F, T, c), 1000).totalHits;
 373     assertEquals("biggest and down", numDocs, numHits);
 374
 375     numHits = search.search(q,
 376         new TermRangeFilter("rand", minRP, null, F, F, c), 1000).totalHits;
 377     assertEquals("not smallest, but up", numDocs - 1, numHits);
 378
 379     numHits = search.search(q,
 380         new TermRangeFilter("rand", null, maxRP, F, F, c), 1000).totalHits;
 381     assertEquals("not biggest, but down", numDocs - 1, numHits);
 382
 383     // very small sets
 384
 385     numHits = search.search(q, new TermRangeFilter("rand", minRP, minRP, F, F,
 386         c), 1000).totalHits;
 387     assertEquals("min,min,F,F", 0, numHits);
 388     numHits = search.search(q, new TermRangeFilter("rand", maxRP, maxRP, F, F,
 389         c), 1000).totalHits;
 390     assertEquals("max,max,F,F", 0, numHits);
 391
 392     numHits = search.search(q, new TermRangeFilter("rand", minRP, minRP, T, T,
 393         c), 1000).totalHits;
 394     assertEquals("min,min,T,T", 1, numHits);
 395     numHits = search.search(q,
 396         new TermRangeFilter("rand", null, minRP, F, T, c), 1000).totalHits;
 397     assertEquals("nul,min,F,T", 1, numHits);
 398
 399     numHits = search.search(q, new TermRangeFilter("rand", maxRP, maxRP, T, T,
 400         c), 1000).totalHits;
 401     assertEquals("max,max,T,T", 1, numHits);
 402     numHits = search.search(q,
 403         new TermRangeFilter("rand", maxRP, null, T, F, c), 1000).totalHits;
 404     assertEquals("max,nul,T,T", 1, numHits);
 405
 406     search.close();
 407   }
 408
 409   @Test
 410   public void testFarsi() throws Exception {
 411
 412     /* build an index */
 413     Directory farsiIndex = newDirectory();
 414     RandomIndexWriter writer = new RandomIndexWriter(random, farsiIndex);
 415     Document doc = new Document();
 416     doc.add(newField("content", "\u0633\u0627\u0628", Field.Store.YES,
 417         Field.Index.NOT_ANALYZED));
 418     doc
 419         .add(newField("body", "body", Field.Store.YES,
 420             Field.Index.NOT_ANALYZED));
 421     writer.addDocument(doc);
 422
 423     IndexReader reader = writer.getReader();
 424     writer.close();
 425
 426     IndexSearcher search = newSearcher(reader);
 427     Query q = new TermQuery(new Term("body", "body"));
 428
 429     // Neither Java 1.4.2 nor 1.5.0 has Farsi Locale collation available in
 430     // RuleBasedCollator. However, the Arabic Locale seems to order the Farsi
 431     // characters properly.
 432     Collator collator = Collator.getInstance(new Locale("ar"));
 433
 434     // Unicode order would include U+0633 in [ U+062F - U+0698 ], but Farsi
 435     // orders the U+0698 character before the U+0633 character, so the single
 436     // index Term below should NOT be returned by a TermRangeFilter with a Farsi
 437     // Collator (or an Arabic one for the case when Farsi is not supported).
 438     int numHits = search.search(q, new TermRangeFilter("content", "\u062F",
 439         "\u0698", T, T, collator), 1000).totalHits;
 440     assertEquals("The index Term should not be included.", 0, numHits);
 441
 442     numHits = search.search(q, new TermRangeFilter("content", "\u0633",
 443         "\u0638", T, T, collator), 1000).totalHits;
 444     assertEquals("The index Term should be included.", 1, numHits);
 445     search.close();
 446     reader.close();
 447     farsiIndex.close();
 448   }
 449
 450   @Test
 451   public void testDanish() throws Exception {
 452
 453     /* build an index */
 454     Directory danishIndex = newDirectory();
 455     RandomIndexWriter writer = new RandomIndexWriter(random, danishIndex);
 456     // Danish collation orders the words below in the given order
 457     // (example taken from TestSort.testInternationalSort() ).
 458     String[] words = {"H\u00D8T", "H\u00C5T", "MAND"};
 459     for (int docnum = 0; docnum < words.length; ++docnum) {
 460       Document doc = new Document();
 461       doc.add(newField("content", words[docnum], Field.Store.YES,
 462           Field.Index.NOT_ANALYZED));
 463       doc.add(newField("body", "body", Field.Store.YES,
 464           Field.Index.NOT_ANALYZED));
 465       writer.addDocument(doc);
 466     }
 467     IndexReader reader = writer.getReader();
 468     writer.close();
 469
 470     IndexSearcher search = newSearcher(reader);
 471     Query q = new TermQuery(new Term("body", "body"));
 472
 473     Collator collator = Collator.getInstance(new Locale("da", "dk"));
 474
 475     // Unicode order would not include "H\u00C5T" in [ "H\u00D8T", "MAND" ],
 476     // but Danish collation does.
 477     int numHits = search.search(q, new TermRangeFilter("content", "H\u00D8T",
 478         "MAND", F, F, collator), 1000).totalHits;
 479     assertEquals("The index Term should be included.", 1, numHits);
 480
 481     numHits = search.search(q, new TermRangeFilter("content", "H\u00C5T",
 482         "MAND", F, F, collator), 1000).totalHits;
 483     assertEquals("The index Term should not be included.", 0, numHits);
 484     search.close();
 485     reader.close();
 486     danishIndex.close();
 487   }
 488 }