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.analysis.MockTokenizer;
22 import org.apache.lucene.analysis.SimpleAnalyzer;
23 import org.apache.lucene.document.Document;
24 import org.apache.lucene.document.Field;
25 import org.apache.lucene.index.IndexReader;
26 import org.apache.lucene.index.RandomIndexWriter;
27 import org.apache.lucene.index.Term;
28 import org.apache.lucene.store.Directory;
29 import org.junit.AfterClass;
30 import org.junit.BeforeClass;
31 import org.junit.Test;
33 import java.io.IOException;
34 import java.text.Collator;
35 import java.util.Locale;
37 import junit.framework.Assert;
39 public class TestMultiTermConstantScore extends BaseTestRangeFilter {
41 /** threshold for comparing floats */
42 public static final float SCORE_COMP_THRESH = 1e-6f;
44 static Directory small;
45 static IndexReader reader;
47 static public void assertEquals(String m, float e, float a) {
48 Assert.assertEquals(m, e, a, SCORE_COMP_THRESH);
51 static public void assertEquals(String m, int e, int a) {
52 Assert.assertEquals(m, e, a);
56 public static void beforeClass() throws Exception {
57 String[] data = new String[] { "A 1 2 3 4 5 6", "Z 4 5 6", null,
58 "B 2 4 5 6", "Y 3 5 6", null, "C 3 6",
61 small = newDirectory();
62 RandomIndexWriter writer = new RandomIndexWriter(random, small,
63 newIndexWriterConfig(TEST_VERSION_CURRENT,
64 new MockAnalyzer(random, MockTokenizer.WHITESPACE, false)).setMergePolicy(newLogMergePolicy()));
66 for (int i = 0; i < data.length; i++) {
67 Document doc = new Document();
68 doc.add(newField("id", String.valueOf(i), Field.Store.YES,
69 Field.Index.NOT_ANALYZED));// Field.Keyword("id",String.valueOf(i)));
71 .add(newField("all", "all", Field.Store.YES,
72 Field.Index.NOT_ANALYZED));// Field.Keyword("all","all"));
73 if (null != data[i]) {
74 doc.add(newField("data", data[i], Field.Store.YES,
75 Field.Index.ANALYZED));// Field.Text("data",data[i]));
77 writer.addDocument(doc);
80 reader = writer.getReader();
85 public static void afterClass() throws Exception {
92 /** macro for readability */
93 public static Query csrq(String f, String l, String h, boolean il, boolean ih) {
94 TermRangeQuery query = new TermRangeQuery(f, l, h, il, ih);
95 query.setRewriteMethod(MultiTermQuery.CONSTANT_SCORE_FILTER_REWRITE);
99 public static Query csrq(String f, String l, String h, boolean il, boolean ih, MultiTermQuery.RewriteMethod method) {
100 TermRangeQuery query = new TermRangeQuery(f, l, h, il, ih);
101 query.setRewriteMethod(method);
105 /** macro for readability */
106 public static Query csrq(String f, String l, String h, boolean il,
107 boolean ih, Collator c) {
108 TermRangeQuery query = new TermRangeQuery(f, l, h, il, ih, c);
109 query.setRewriteMethod(MultiTermQuery.CONSTANT_SCORE_FILTER_REWRITE);
113 /** macro for readability */
114 public static Query cspq(Term prefix) {
115 PrefixQuery query = new PrefixQuery(prefix);
116 query.setRewriteMethod(MultiTermQuery.CONSTANT_SCORE_FILTER_REWRITE);
120 /** macro for readability */
121 public static Query cswcq(Term wild) {
122 WildcardQuery query = new WildcardQuery(wild);
123 query.setRewriteMethod(MultiTermQuery.CONSTANT_SCORE_FILTER_REWRITE);
128 public void testBasics() throws IOException {
129 QueryUtils.check(csrq("data", "1", "6", T, T));
130 QueryUtils.check(csrq("data", "A", "Z", T, T));
131 QueryUtils.checkUnequal(csrq("data", "1", "6", T, T), csrq("data", "A",
134 QueryUtils.check(cspq(new Term("data", "p*u?")));
135 QueryUtils.checkUnequal(cspq(new Term("data", "pre*")), cspq(new Term(
138 QueryUtils.check(cswcq(new Term("data", "p")));
139 QueryUtils.checkUnequal(cswcq(new Term("data", "pre*n?t")), cswcq(new Term(
144 public void testBasicsRngCollating() throws IOException {
145 Collator c = Collator.getInstance(Locale.ENGLISH);
146 QueryUtils.check(csrq("data", "1", "6", T, T, c));
147 QueryUtils.check(csrq("data", "A", "Z", T, T, c));
148 QueryUtils.checkUnequal(csrq("data", "1", "6", T, T, c), csrq("data", "A",
153 public void testEqualScores() throws IOException {
154 // NOTE: uses index build in *this* setUp
156 IndexSearcher search = newSearcher(reader);
160 // some hits match more terms then others, score should be the same
162 result = search.search(csrq("data", "1", "6", T, T), null, 1000).scoreDocs;
163 int numHits = result.length;
164 assertEquals("wrong number of results", 6, numHits);
165 float score = result[0].score;
166 for (int i = 1; i < numHits; i++) {
167 assertEquals("score for " + i + " was not the same", score,
168 result[i].score, SCORE_COMP_THRESH);
171 result = search.search(csrq("data", "1", "6", T, T, MultiTermQuery.CONSTANT_SCORE_BOOLEAN_QUERY_REWRITE), null, 1000).scoreDocs;
172 numHits = result.length;
173 assertEquals("wrong number of results", 6, numHits);
174 for (int i = 0; i < numHits; i++) {
175 assertEquals("score for " + i + " was not the same", score,
176 result[i].score, SCORE_COMP_THRESH);
183 public void testBoost() throws IOException {
184 // NOTE: uses index build in *this* setUp
186 IndexSearcher search = newSearcher(reader);
188 // test for correct application of query normalization
189 // must use a non score normalizing method for this.
190 Query q = csrq("data", "1", "6", T, T);
192 search.search(q, null, new Collector() {
193 private int base = 0;
194 private Scorer scorer;
196 public void setScorer(Scorer scorer) throws IOException {
197 this.scorer = scorer;
200 public void collect(int doc) throws IOException {
201 assertEquals("score for doc " + (doc + base) + " was not correct", 1.0f, scorer.score(), SCORE_COMP_THRESH);
204 public void setNextReader(IndexReader reader, int docBase) {
208 public boolean acceptsDocsOutOfOrder() {
214 // Ensure that boosting works to score one clause of a query higher
217 Query q1 = csrq("data", "A", "A", T, T); // matches document #0
219 Query q2 = csrq("data", "Z", "Z", T, T); // matches document #1
220 BooleanQuery bq = new BooleanQuery(true);
221 bq.add(q1, BooleanClause.Occur.SHOULD);
222 bq.add(q2, BooleanClause.Occur.SHOULD);
224 ScoreDoc[] hits = search.search(bq, null, 1000).scoreDocs;
225 Assert.assertEquals(1, hits[0].doc);
226 Assert.assertEquals(0, hits[1].doc);
227 assertTrue(hits[0].score > hits[1].score);
229 q1 = csrq("data", "A", "A", T, T, MultiTermQuery.CONSTANT_SCORE_BOOLEAN_QUERY_REWRITE); // matches document #0
231 q2 = csrq("data", "Z", "Z", T, T, MultiTermQuery.CONSTANT_SCORE_BOOLEAN_QUERY_REWRITE); // matches document #1
232 bq = new BooleanQuery(true);
233 bq.add(q1, BooleanClause.Occur.SHOULD);
234 bq.add(q2, BooleanClause.Occur.SHOULD);
236 hits = search.search(bq, null, 1000).scoreDocs;
237 Assert.assertEquals(1, hits[0].doc);
238 Assert.assertEquals(0, hits[1].doc);
239 assertTrue(hits[0].score > hits[1].score);
241 q1 = csrq("data", "A", "A", T, T); // matches document #0
243 q2 = csrq("data", "Z", "Z", T, T); // matches document #1
244 bq = new BooleanQuery(true);
245 bq.add(q1, BooleanClause.Occur.SHOULD);
246 bq.add(q2, BooleanClause.Occur.SHOULD);
248 hits = search.search(bq, null, 1000).scoreDocs;
249 Assert.assertEquals(0, hits[0].doc);
250 Assert.assertEquals(1, hits[1].doc);
251 assertTrue(hits[0].score > hits[1].score);
256 public void testBooleanOrderUnAffected() throws IOException {
257 // NOTE: uses index build in *this* setUp
259 IndexSearcher search = newSearcher(reader);
261 // first do a regular TermRangeQuery which uses term expansion so
262 // docs with more terms in range get higher scores
264 Query rq = new TermRangeQuery("data", "1", "4", T, T);
266 ScoreDoc[] expected = search.search(rq, null, 1000).scoreDocs;
267 int numHits = expected.length;
269 // now do a boolean where which also contains a
270 // ConstantScoreRangeQuery and make sure hte order is the same
272 BooleanQuery q = new BooleanQuery();
273 q.add(rq, BooleanClause.Occur.MUST);// T, F);
274 q.add(csrq("data", "1", "6", T, T), BooleanClause.Occur.MUST);// T, F);
276 ScoreDoc[] actual = search.search(q, null, 1000).scoreDocs;
278 assertEquals("wrong numebr of hits", numHits, actual.length);
279 for (int i = 0; i < numHits; i++) {
280 assertEquals("mismatch in docid for hit#" + i, expected[i].doc,
288 public void testRangeQueryId() throws IOException {
289 // NOTE: uses index build in *super* setUp
291 IndexReader reader = signedIndexReader;
292 IndexSearcher search = newSearcher(reader);
294 int medId = ((maxId - minId) / 2);
296 String minIP = pad(minId);
297 String maxIP = pad(maxId);
298 String medIP = pad(medId);
300 int numDocs = reader.numDocs();
302 assertEquals("num of docs", numDocs, 1 + maxId - minId);
306 // test id, bounded on both ends
308 result = search.search(csrq("id", minIP, maxIP, T, T), null, numDocs).scoreDocs;
309 assertEquals("find all", numDocs, result.length);
311 result = search.search(csrq("id", minIP, maxIP, T, T, MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT), null, numDocs).scoreDocs;
312 assertEquals("find all", numDocs, result.length);
314 result = search.search(csrq("id", minIP, maxIP, T, F), null, numDocs).scoreDocs;
315 assertEquals("all but last", numDocs - 1, result.length);
317 result = search.search(csrq("id", minIP, maxIP, T, F, MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT), null, numDocs).scoreDocs;
318 assertEquals("all but last", numDocs - 1, result.length);
320 result = search.search(csrq("id", minIP, maxIP, F, T), null, numDocs).scoreDocs;
321 assertEquals("all but first", numDocs - 1, result.length);
323 result = search.search(csrq("id", minIP, maxIP, F, T, MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT), null, numDocs).scoreDocs;
324 assertEquals("all but first", numDocs - 1, result.length);
326 result = search.search(csrq("id", minIP, maxIP, F, F), null, numDocs).scoreDocs;
327 assertEquals("all but ends", numDocs - 2, result.length);
329 result = search.search(csrq("id", minIP, maxIP, F, F, MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT), null, numDocs).scoreDocs;
330 assertEquals("all but ends", numDocs - 2, result.length);
332 result = search.search(csrq("id", medIP, maxIP, T, T), null, numDocs).scoreDocs;
333 assertEquals("med and up", 1 + maxId - medId, result.length);
335 result = search.search(csrq("id", medIP, maxIP, T, T, MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT), null, numDocs).scoreDocs;
336 assertEquals("med and up", 1 + maxId - medId, result.length);
338 result = search.search(csrq("id", minIP, medIP, T, T), null, numDocs).scoreDocs;
339 assertEquals("up to med", 1 + medId - minId, result.length);
341 result = search.search(csrq("id", minIP, medIP, T, T, MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT), null, numDocs).scoreDocs;
342 assertEquals("up to med", 1 + medId - minId, result.length);
346 result = search.search(csrq("id", minIP, null, T, F), null, numDocs).scoreDocs;
347 assertEquals("min and up", numDocs, result.length);
349 result = search.search(csrq("id", null, maxIP, F, T), null, numDocs).scoreDocs;
350 assertEquals("max and down", numDocs, result.length);
352 result = search.search(csrq("id", minIP, null, F, F), null, numDocs).scoreDocs;
353 assertEquals("not min, but up", numDocs - 1, result.length);
355 result = search.search(csrq("id", null, maxIP, F, F), null, numDocs).scoreDocs;
356 assertEquals("not max, but down", numDocs - 1, result.length);
358 result = search.search(csrq("id", medIP, maxIP, T, F), null, numDocs).scoreDocs;
359 assertEquals("med and up, not max", maxId - medId, result.length);
361 result = search.search(csrq("id", minIP, medIP, F, T), null, numDocs).scoreDocs;
362 assertEquals("not min, up to med", medId - minId, result.length);
366 result = search.search(csrq("id", minIP, minIP, F, F), null, numDocs).scoreDocs;
367 assertEquals("min,min,F,F", 0, result.length);
369 result = search.search(csrq("id", minIP, minIP, F, F, MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT), null, numDocs).scoreDocs;
370 assertEquals("min,min,F,F", 0, result.length);
372 result = search.search(csrq("id", medIP, medIP, F, F), null, numDocs).scoreDocs;
373 assertEquals("med,med,F,F", 0, result.length);
375 result = search.search(csrq("id", medIP, medIP, F, F, MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT), null, numDocs).scoreDocs;
376 assertEquals("med,med,F,F", 0, result.length);
378 result = search.search(csrq("id", maxIP, maxIP, F, F), null, numDocs).scoreDocs;
379 assertEquals("max,max,F,F", 0, result.length);
381 result = search.search(csrq("id", maxIP, maxIP, F, F, MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT), null, numDocs).scoreDocs;
382 assertEquals("max,max,F,F", 0, result.length);
384 result = search.search(csrq("id", minIP, minIP, T, T), null, numDocs).scoreDocs;
385 assertEquals("min,min,T,T", 1, result.length);
387 result = search.search(csrq("id", minIP, minIP, T, T, MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT), null, numDocs).scoreDocs;
388 assertEquals("min,min,T,T", 1, result.length);
390 result = search.search(csrq("id", null, minIP, F, T), null, numDocs).scoreDocs;
391 assertEquals("nul,min,F,T", 1, result.length);
393 result = search.search(csrq("id", null, minIP, F, T, MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT), null, numDocs).scoreDocs;
394 assertEquals("nul,min,F,T", 1, result.length);
396 result = search.search(csrq("id", maxIP, maxIP, T, T), null, numDocs).scoreDocs;
397 assertEquals("max,max,T,T", 1, result.length);
399 result = search.search(csrq("id", maxIP, maxIP, T, T, MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT), null, numDocs).scoreDocs;
400 assertEquals("max,max,T,T", 1, result.length);
402 result = search.search(csrq("id", maxIP, null, T, F), null, numDocs).scoreDocs;
403 assertEquals("max,nul,T,T", 1, result.length);
405 result = search.search(csrq("id", maxIP, null, T, F, MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT), null, numDocs).scoreDocs;
406 assertEquals("max,nul,T,T", 1, result.length);
408 result = search.search(csrq("id", medIP, medIP, T, T), null, numDocs).scoreDocs;
409 assertEquals("med,med,T,T", 1, result.length);
411 result = search.search(csrq("id", medIP, medIP, T, T, MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT), null, numDocs).scoreDocs;
412 assertEquals("med,med,T,T", 1, result.length);
418 public void testRangeQueryIdCollating() throws IOException {
419 // NOTE: uses index build in *super* setUp
421 IndexReader reader = signedIndexReader;
422 IndexSearcher search = newSearcher(reader);
424 int medId = ((maxId - minId) / 2);
426 String minIP = pad(minId);
427 String maxIP = pad(maxId);
428 String medIP = pad(medId);
430 int numDocs = reader.numDocs();
432 assertEquals("num of docs", numDocs, 1 + maxId - minId);
436 Collator c = Collator.getInstance(Locale.ENGLISH);
438 // test id, bounded on both ends
440 result = search.search(csrq("id", minIP, maxIP, T, T, c), null, numDocs).scoreDocs;
441 assertEquals("find all", numDocs, result.length);
443 result = search.search(csrq("id", minIP, maxIP, T, F, c), null, numDocs).scoreDocs;
444 assertEquals("all but last", numDocs - 1, result.length);
446 result = search.search(csrq("id", minIP, maxIP, F, T, c), null, numDocs).scoreDocs;
447 assertEquals("all but first", numDocs - 1, result.length);
449 result = search.search(csrq("id", minIP, maxIP, F, F, c), null, numDocs).scoreDocs;
450 assertEquals("all but ends", numDocs - 2, result.length);
452 result = search.search(csrq("id", medIP, maxIP, T, T, c), null, numDocs).scoreDocs;
453 assertEquals("med and up", 1 + maxId - medId, result.length);
455 result = search.search(csrq("id", minIP, medIP, T, T, c), null, numDocs).scoreDocs;
456 assertEquals("up to med", 1 + medId - minId, result.length);
460 result = search.search(csrq("id", minIP, null, T, F, c), null, numDocs).scoreDocs;
461 assertEquals("min and up", numDocs, result.length);
463 result = search.search(csrq("id", null, maxIP, F, T, c), null, numDocs).scoreDocs;
464 assertEquals("max and down", numDocs, result.length);
466 result = search.search(csrq("id", minIP, null, F, F, c), null, numDocs).scoreDocs;
467 assertEquals("not min, but up", numDocs - 1, result.length);
469 result = search.search(csrq("id", null, maxIP, F, F, c), null, numDocs).scoreDocs;
470 assertEquals("not max, but down", numDocs - 1, result.length);
472 result = search.search(csrq("id", medIP, maxIP, T, F, c), null, numDocs).scoreDocs;
473 assertEquals("med and up, not max", maxId - medId, result.length);
475 result = search.search(csrq("id", minIP, medIP, F, T, c), null, numDocs).scoreDocs;
476 assertEquals("not min, up to med", medId - minId, result.length);
480 result = search.search(csrq("id", minIP, minIP, F, F, c), null, numDocs).scoreDocs;
481 assertEquals("min,min,F,F,c", 0, result.length);
482 result = search.search(csrq("id", medIP, medIP, F, F, c), null, numDocs).scoreDocs;
483 assertEquals("med,med,F,F,c", 0, result.length);
484 result = search.search(csrq("id", maxIP, maxIP, F, F, c), null, numDocs).scoreDocs;
485 assertEquals("max,max,F,F,c", 0, result.length);
487 result = search.search(csrq("id", minIP, minIP, T, T, c), null, numDocs).scoreDocs;
488 assertEquals("min,min,T,T,c", 1, result.length);
489 result = search.search(csrq("id", null, minIP, F, T, c), null, numDocs).scoreDocs;
490 assertEquals("nul,min,F,T,c", 1, result.length);
492 result = search.search(csrq("id", maxIP, maxIP, T, T, c), null, numDocs).scoreDocs;
493 assertEquals("max,max,T,T,c", 1, result.length);
494 result = search.search(csrq("id", maxIP, null, T, F, c), null, numDocs).scoreDocs;
495 assertEquals("max,nul,T,T,c", 1, result.length);
497 result = search.search(csrq("id", medIP, medIP, T, T, c), null, numDocs).scoreDocs;
498 assertEquals("med,med,T,T,c", 1, result.length);
504 public void testRangeQueryRand() throws IOException {
505 // NOTE: uses index build in *super* setUp
507 IndexReader reader = signedIndexReader;
508 IndexSearcher search = newSearcher(reader);
510 String minRP = pad(signedIndexDir.minR);
511 String maxRP = pad(signedIndexDir.maxR);
513 int numDocs = reader.numDocs();
515 assertEquals("num of docs", numDocs, 1 + maxId - minId);
519 // test extremes, bounded on both ends
521 result = search.search(csrq("rand", minRP, maxRP, T, T), null, numDocs).scoreDocs;
522 assertEquals("find all", numDocs, result.length);
524 result = search.search(csrq("rand", minRP, maxRP, T, F), null, numDocs).scoreDocs;
525 assertEquals("all but biggest", numDocs - 1, result.length);
527 result = search.search(csrq("rand", minRP, maxRP, F, T), null, numDocs).scoreDocs;
528 assertEquals("all but smallest", numDocs - 1, result.length);
530 result = search.search(csrq("rand", minRP, maxRP, F, F), null, numDocs).scoreDocs;
531 assertEquals("all but extremes", numDocs - 2, result.length);
535 result = search.search(csrq("rand", minRP, null, T, F), null, numDocs).scoreDocs;
536 assertEquals("smallest and up", numDocs, result.length);
538 result = search.search(csrq("rand", null, maxRP, F, T), null, numDocs).scoreDocs;
539 assertEquals("biggest and down", numDocs, result.length);
541 result = search.search(csrq("rand", minRP, null, F, F), null, numDocs).scoreDocs;
542 assertEquals("not smallest, but up", numDocs - 1, result.length);
544 result = search.search(csrq("rand", null, maxRP, F, F), null, numDocs).scoreDocs;
545 assertEquals("not biggest, but down", numDocs - 1, result.length);
549 result = search.search(csrq("rand", minRP, minRP, F, F), null, numDocs).scoreDocs;
550 assertEquals("min,min,F,F", 0, result.length);
551 result = search.search(csrq("rand", maxRP, maxRP, F, F), null, numDocs).scoreDocs;
552 assertEquals("max,max,F,F", 0, result.length);
554 result = search.search(csrq("rand", minRP, minRP, T, T), null, numDocs).scoreDocs;
555 assertEquals("min,min,T,T", 1, result.length);
556 result = search.search(csrq("rand", null, minRP, F, T), null, numDocs).scoreDocs;
557 assertEquals("nul,min,F,T", 1, result.length);
559 result = search.search(csrq("rand", maxRP, maxRP, T, T), null, numDocs).scoreDocs;
560 assertEquals("max,max,T,T", 1, result.length);
561 result = search.search(csrq("rand", maxRP, null, T, F), null, numDocs).scoreDocs;
562 assertEquals("max,nul,T,T", 1, result.length);
568 public void testRangeQueryRandCollating() throws IOException {
569 // NOTE: uses index build in *super* setUp
571 // using the unsigned index because collation seems to ignore hyphens
572 IndexReader reader = unsignedIndexReader;
573 IndexSearcher search = newSearcher(reader);
575 String minRP = pad(unsignedIndexDir.minR);
576 String maxRP = pad(unsignedIndexDir.maxR);
578 int numDocs = reader.numDocs();
580 assertEquals("num of docs", numDocs, 1 + maxId - minId);
584 Collator c = Collator.getInstance(Locale.ENGLISH);
586 // test extremes, bounded on both ends
588 result = search.search(csrq("rand", minRP, maxRP, T, T, c), null, numDocs).scoreDocs;
589 assertEquals("find all", numDocs, result.length);
591 result = search.search(csrq("rand", minRP, maxRP, T, F, c), null, numDocs).scoreDocs;
592 assertEquals("all but biggest", numDocs - 1, result.length);
594 result = search.search(csrq("rand", minRP, maxRP, F, T, c), null, numDocs).scoreDocs;
595 assertEquals("all but smallest", numDocs - 1, result.length);
597 result = search.search(csrq("rand", minRP, maxRP, F, F, c), null, numDocs).scoreDocs;
598 assertEquals("all but extremes", numDocs - 2, result.length);
602 result = search.search(csrq("rand", minRP, null, T, F, c), null, numDocs).scoreDocs;
603 assertEquals("smallest and up", numDocs, result.length);
605 result = search.search(csrq("rand", null, maxRP, F, T, c), null, numDocs).scoreDocs;
606 assertEquals("biggest and down", numDocs, result.length);
608 result = search.search(csrq("rand", minRP, null, F, F, c), null, numDocs).scoreDocs;
609 assertEquals("not smallest, but up", numDocs - 1, result.length);
611 result = search.search(csrq("rand", null, maxRP, F, F, c), null, numDocs).scoreDocs;
612 assertEquals("not biggest, but down", numDocs - 1, result.length);
616 result = search.search(csrq("rand", minRP, minRP, F, F, c), null, numDocs).scoreDocs;
617 assertEquals("min,min,F,F,c", 0, result.length);
618 result = search.search(csrq("rand", maxRP, maxRP, F, F, c), null, numDocs).scoreDocs;
619 assertEquals("max,max,F,F,c", 0, result.length);
621 result = search.search(csrq("rand", minRP, minRP, T, T, c), null, numDocs).scoreDocs;
622 assertEquals("min,min,T,T,c", 1, result.length);
623 result = search.search(csrq("rand", null, minRP, F, T, c), null, numDocs).scoreDocs;
624 assertEquals("nul,min,F,T,c", 1, result.length);
626 result = search.search(csrq("rand", maxRP, maxRP, T, T, c), null, numDocs).scoreDocs;
627 assertEquals("max,max,T,T,c", 1, result.length);
628 result = search.search(csrq("rand", maxRP, null, T, F, c), null, numDocs).scoreDocs;
629 assertEquals("max,nul,T,T,c", 1, result.length);
635 public void testFarsi() throws Exception {
638 Directory farsiIndex = newDirectory();
639 RandomIndexWriter writer = new RandomIndexWriter(random, farsiIndex, new SimpleAnalyzer(TEST_VERSION_CURRENT));
640 Document doc = new Document();
641 doc.add(newField("content", "\u0633\u0627\u0628", Field.Store.YES,
642 Field.Index.NOT_ANALYZED));
644 .add(newField("body", "body", Field.Store.YES,
645 Field.Index.NOT_ANALYZED));
646 writer.addDocument(doc);
648 IndexReader reader = writer.getReader();
651 IndexSearcher search = newSearcher(reader);
653 // Neither Java 1.4.2 nor 1.5.0 has Farsi Locale collation available in
654 // RuleBasedCollator. However, the Arabic Locale seems to order the Farsi
655 // characters properly.
656 Collator c = Collator.getInstance(new Locale("ar"));
658 // Unicode order would include U+0633 in [ U+062F - U+0698 ], but Farsi
659 // orders the U+0698 character before the U+0633 character, so the single
660 // index Term below should NOT be returned by a ConstantScoreRangeQuery
661 // with a Farsi Collator (or an Arabic one for the case when Farsi is
663 ScoreDoc[] result = search.search(csrq("content", "\u062F", "\u0698", T, T,
664 c), null, 1000).scoreDocs;
665 assertEquals("The index Term should not be included.", 0, result.length);
667 result = search.search(csrq("content", "\u0633", "\u0638", T, T, c), null,
669 assertEquals("The index Term should be included.", 1, result.length);
676 public void testDanish() throws Exception {
679 Directory danishIndex = newDirectory();
680 RandomIndexWriter writer = new RandomIndexWriter(random, danishIndex, new SimpleAnalyzer(TEST_VERSION_CURRENT));
682 // Danish collation orders the words below in the given order
683 // (example taken from TestSort.testInternationalSort() ).
684 String[] words = { "H\u00D8T", "H\u00C5T", "MAND" };
685 for (int docnum = 0 ; docnum < words.length ; ++docnum) {
686 Document doc = new Document();
687 doc.add(newField("content", words[docnum],
688 Field.Store.YES, Field.Index.NOT_ANALYZED));
689 doc.add(newField("body", "body",
690 Field.Store.YES, Field.Index.NOT_ANALYZED));
691 writer.addDocument(doc);
693 IndexReader reader = writer.getReader();
696 IndexSearcher search = newSearcher(reader);
698 Collator c = Collator.getInstance(new Locale("da", "dk"));
700 // Unicode order would not include "H\u00C5T" in [ "H\u00D8T", "MAND" ],
701 // but Danish collation does.
702 ScoreDoc[] result = search.search
703 (csrq("content", "H\u00D8T", "MAND", F, F, c), null, 1000).scoreDocs;
704 assertEquals("The index Term should be included.", 1, result.length);
706 result = search.search
707 (csrq("content", "H\u00C5T", "MAND", F, F, c), null, 1000).scoreDocs;
708 assertEquals("The index Term should not be included.", 0, result.length);