← Back to branch summary

~slub.team/goobi-indexserver/3.x

« back to all changes in this revision

Viewing changes to lucene/backwards/src/test/org/apache/lucene/search/spans/TestBasics.java

  • Committer: Sebastian Meyer
  • Date: 2012-08-03 09:12:40 UTC
  • Revision ID: sebastian.meyer@slub-dresden.de-20120803091240-x6861b0vabq1xror
https://launchpad.net/bugs/985487
Remove Lucene and Solr source code and add patches instead
Fix Bug #985487: Auto-suggestion for the search interface

Show diffs side-by-side

added added

removed removed

Lines of Context:
lucene/backwards/src/test/org/apache/lucene/search/spans/TestBasics.java
1
 
package org.apache.lucene.search.spans;
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.io.Reader;
22
 
import java.util.ArrayList;
23
 
import java.util.Collection;
24
 
import java.util.Collections;
25
 
import java.util.List;
26
 
 
27
 
import org.apache.lucene.analysis.Analyzer;
28
 
import org.apache.lucene.analysis.LowerCaseTokenizer;
29
 
import org.apache.lucene.analysis.MockAnalyzer;
30
 
import org.apache.lucene.analysis.TokenFilter;
31
 
import org.apache.lucene.analysis.TokenStream;
32
 
import org.apache.lucene.analysis.tokenattributes.CharTermAttribute;
33
 
import org.apache.lucene.analysis.tokenattributes.PayloadAttribute;
34
 
import org.apache.lucene.document.Document;
35
 
import org.apache.lucene.document.Field;
36
 
import org.apache.lucene.index.IndexReader;
37
 
import org.apache.lucene.index.Payload;
38
 
import org.apache.lucene.index.RandomIndexWriter;
39
 
import org.apache.lucene.index.Term;
40
 
import org.apache.lucene.search.BooleanClause;
41
 
import org.apache.lucene.search.BooleanQuery;
42
 
import org.apache.lucene.search.CheckHits;
43
 
import org.apache.lucene.search.IndexSearcher;
44
 
import org.apache.lucene.search.PhraseQuery;
45
 
import org.apache.lucene.search.Query;
46
 
import org.apache.lucene.search.QueryUtils;
47
 
import org.apache.lucene.search.TermQuery;
48
 
import org.apache.lucene.store.Directory;
49
 
import org.apache.lucene.util.English;
50
 
import org.apache.lucene.util.LuceneTestCase;
51
 
import org.apache.lucene.util._TestUtil;
52
 
import org.junit.AfterClass;
53
 
import org.junit.BeforeClass;
54
 
import org.junit.Test;
55
 
 
56
 
/**
57
 
 * Tests basic search capabilities.
58
 
 *
59
 
 * <p>Uses a collection of 1000 documents, each the english rendition of their
60
 
 * document number.  For example, the document numbered 333 has text "three
61
 
 * hundred thirty three".
62
 
 *
63
 
 * <p>Tests are each a single query, and its hits are checked to ensure that
64
 
 * all and only the correct documents are returned, thus providing end-to-end
65
 
 * testing of the indexing and search code.
66
 
 *
67
 
 */
68
 
public class TestBasics extends LuceneTestCase {
69
 
  private static IndexSearcher searcher;
70
 
  private static IndexReader reader;
71
 
  private static Directory directory;
72
 
 
73
 
  static final class SimplePayloadFilter extends TokenFilter {
74
 
    String fieldName;
75
 
    int pos;
76
 
    final PayloadAttribute payloadAttr;
77
 
    final CharTermAttribute termAttr;
78
 
 
79
 
    public SimplePayloadFilter(TokenStream input, String fieldName) {
80
 
      super(input);
81
 
      this.fieldName = fieldName;
82
 
      pos = 0;
83
 
      payloadAttr = input.addAttribute(PayloadAttribute.class);
84
 
      termAttr = input.addAttribute(CharTermAttribute.class);
85
 
    }
86
 
 
87
 
    @Override
88
 
    public boolean incrementToken() throws IOException {
89
 
      if (input.incrementToken()) {
90
 
        payloadAttr.setPayload(new Payload(("pos: " + pos).getBytes()));
91
 
        pos++;
92
 
        return true;
93
 
      } else {
94
 
        return false;
95
 
      }
96
 
    }
97
 
 
98
 
    @Override
99
 
    public void reset() throws IOException {
100
 
      super.reset();
101
 
      pos = 0;
102
 
    }
103
 
  }
104
 
  
105
 
  static final Analyzer simplePayloadAnalyzer = new Analyzer() {
106
 
 
107
 
    @Override
108
 
    public TokenStream tokenStream(String fieldName, Reader reader) {
109
 
      return new SimplePayloadFilter(new LowerCaseTokenizer(TEST_VERSION_CURRENT, reader), fieldName);
110
 
    }
111
 
    
112
 
  };
113
 
  
114
 
  @BeforeClass
115
 
  public static void beforeClass() throws Exception {
116
 
    directory = newDirectory();
117
 
    RandomIndexWriter writer = new RandomIndexWriter(random, directory,
118
 
        newIndexWriterConfig(TEST_VERSION_CURRENT, simplePayloadAnalyzer)
119
 
                                                     .setMaxBufferedDocs(_TestUtil.nextInt(random, 50, 1000)).setMergePolicy(newLogMergePolicy()));
120
 
    //writer.infoStream = System.out;
121
 
    for (int i = 0; i < 2000; i++) {
122
 
      Document doc = new Document();
123
 
      doc.add(newField("field", English.intToEnglish(i), Field.Store.YES, Field.Index.ANALYZED));
124
 
      writer.addDocument(doc);
125
 
    }
126
 
    reader = writer.getReader();
127
 
    searcher = newSearcher(reader);
128
 
    writer.close();
129
 
  }
130
 
 
131
 
  @AfterClass
132
 
  public static void afterClass() throws Exception {
133
 
    searcher.close();
134
 
    reader.close();
135
 
    directory.close();
136
 
    searcher = null;
137
 
    reader = null;
138
 
    directory = null;
139
 
  }
140
 
 
141
 
  @Test
142
 
  public void testTerm() throws Exception {
143
 
    Query query = new TermQuery(new Term("field", "seventy"));
144
 
    checkHits(query, new int[]
145
 
      {70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 170, 171, 172, 173, 174, 175,
146
 
              176, 177, 178, 179, 270, 271, 272, 273, 274, 275, 276, 277, 278,
147
 
              279, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 470, 471,
148
 
              472, 473, 474, 475, 476, 477, 478, 479, 570, 571, 572, 573, 574,
149
 
              575, 576, 577, 578, 579, 670, 671, 672, 673, 674, 675, 676, 677,
150
 
              678, 679, 770, 771, 772, 773, 774, 775, 776, 777, 778, 779, 870,
151
 
              871, 872, 873, 874, 875, 876, 877, 878, 879, 970, 971, 972, 973,
152
 
              974, 975, 976, 977, 978, 979, 1070, 1071, 1072, 1073, 1074, 1075,
153
 
              1076, 1077, 1078, 1079, 1170, 1171, 1172, 1173, 1174, 1175, 1176,
154
 
              1177, 1178, 1179, 1270, 1271, 1272, 1273, 1274, 1275, 1276, 1277,
155
 
              1278, 1279, 1370, 1371, 1372, 1373, 1374, 1375, 1376, 1377, 1378,
156
 
              1379, 1470, 1471, 1472, 1473, 1474, 1475, 1476, 1477, 1478, 1479,
157
 
              1570, 1571, 1572, 1573, 1574, 1575, 1576, 1577, 1578, 1579, 1670,
158
 
              1671, 1672, 1673, 1674, 1675, 1676, 1677, 1678, 1679, 1770, 1771,
159
 
              1772, 1773, 1774, 1775, 1776, 1777, 1778, 1779, 1870, 1871, 1872,
160
 
              1873, 1874, 1875, 1876, 1877,
161
 
              1878, 1879, 1970, 1971, 1972, 1973, 1974, 1975, 1976, 1977, 1978,
162
 
              1979});
163
 
    }
164
 
 
165
 
  @Test
166
 
  public void testTerm2() throws Exception {
167
 
    Query query = new TermQuery(new Term("field", "seventish"));
168
 
    checkHits(query, new int[] {});
169
 
  }
170
 
 
171
 
  @Test
172
 
  public void testPhrase() throws Exception {
173
 
    PhraseQuery query = new PhraseQuery();
174
 
    query.add(new Term("field", "seventy"));
175
 
    query.add(new Term("field", "seven"));
176
 
    checkHits(query, new int[]
177
 
      {77, 177, 277, 377, 477, 577, 677, 777, 877,
178
 
              977, 1077, 1177, 1277, 1377, 1477, 1577, 1677, 1777, 1877, 1977});
179
 
  }
180
 
 
181
 
  @Test
182
 
  public void testPhrase2() throws Exception {
183
 
    PhraseQuery query = new PhraseQuery();
184
 
    query.add(new Term("field", "seventish"));
185
 
    query.add(new Term("field", "sevenon"));
186
 
    checkHits(query, new int[] {});
187
 
  }
188
 
 
189
 
  @Test
190
 
  public void testBoolean() throws Exception {
191
 
    BooleanQuery query = new BooleanQuery();
192
 
    query.add(new TermQuery(new Term("field", "seventy")), BooleanClause.Occur.MUST);
193
 
    query.add(new TermQuery(new Term("field", "seven")), BooleanClause.Occur.MUST);
194
 
    checkHits(query, new int[]
195
 
      {77, 177, 277, 377, 477, 577, 677, 770, 771, 772, 773, 774, 775, 776, 777,
196
 
              778, 779, 877, 977, 1077, 1177, 1277, 1377, 1477, 1577, 1677,
197
 
              1770, 1771, 1772, 1773, 1774, 1775, 1776, 1777, 1778, 1779, 1877,
198
 
              1977});
199
 
  }
200
 
 
201
 
  @Test
202
 
  public void testBoolean2() throws Exception {
203
 
    BooleanQuery query = new BooleanQuery();
204
 
    query.add(new TermQuery(new Term("field", "sevento")), BooleanClause.Occur.MUST);
205
 
    query.add(new TermQuery(new Term("field", "sevenly")), BooleanClause.Occur.MUST);
206
 
    checkHits(query, new int[] {});
207
 
  }
208
 
 
209
 
  @Test
210
 
  public void testSpanNearExact() throws Exception {
211
 
    SpanTermQuery term1 = new SpanTermQuery(new Term("field", "seventy"));
212
 
    SpanTermQuery term2 = new SpanTermQuery(new Term("field", "seven"));
213
 
    SpanNearQuery query = new SpanNearQuery(new SpanQuery[] {term1, term2},
214
 
                                            0, true);
215
 
    checkHits(query, new int[]
216
 
      {77, 177, 277, 377, 477, 577, 677, 777, 877, 977, 1077, 1177, 1277, 1377, 1477, 1577, 1677, 1777, 1877, 1977});
217
 
 
218
 
    assertTrue(searcher.explain(query, 77).getValue() > 0.0f);
219
 
    assertTrue(searcher.explain(query, 977).getValue() > 0.0f);
220
 
 
221
 
    QueryUtils.check(term1);
222
 
    QueryUtils.check(term2);
223
 
    QueryUtils.checkUnequal(term1,term2);
224
 
  }
225
 
  
226
 
  public void testSpanTermQuery() throws Exception {
227
 
    SpanTermQuery term1 = new SpanTermQuery(new Term("field", "seventy"));
228
 
    checkHits(term1, new int[]
229
 
                             { 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 170,
230
 
        171, 172, 173, 174, 175, 176, 177, 178, 179, 270, 271, 272, 273, 274,
231
 
        275, 276, 277, 278, 279, 370, 371, 372, 373, 374, 375, 376, 377, 378,
232
 
        379, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 570, 571, 572,
233
 
        573, 574, 575, 576, 577, 578, 579, 670, 671, 672, 673, 674, 675, 676,
234
 
        677, 678, 679, 770, 771, 772, 773, 774, 775, 776, 777, 778, 779, 870,
235
 
        871, 872, 873, 874, 875, 876, 877, 878, 879, 970, 971, 972, 973, 974,
236
 
        975, 976, 977, 978, 979, 1070, 1071, 1072, 1073, 1074, 1075, 1076,
237
 
        1077, 1078, 1079, 1170, 1270, 1370, 1470, 1570, 1670, 1770, 1870, 1970,
238
 
        1171, 1172, 1173, 1174, 1175, 1176, 1177, 1178, 1179, 1271, 1272, 1273,
239
 
        1274, 1275, 1276, 1277, 1278, 1279, 1371, 1372, 1373, 1374, 1375, 1376,
240
 
        1377, 1378, 1379, 1471, 1472, 1473, 1474, 1475, 1476, 1477, 1478, 1479,
241
 
        1571, 1572, 1573, 1574, 1575, 1576, 1577, 1578, 1579, 1671, 1672, 1673,
242
 
        1674, 1675, 1676, 1677, 1678, 1679, 1771, 1772, 1773, 1774, 1775, 1776,
243
 
        1777, 1778, 1779, 1871, 1872, 1873, 1874, 1875, 1876, 1877, 1878, 1879,
244
 
        1971, 1972, 1973, 1974, 1975, 1976, 1977, 1978, 1979 });
245
 
  }
246
 
 
247
 
  @Test
248
 
  public void testSpanNearUnordered() throws Exception {
249
 
    SpanTermQuery term1 = new SpanTermQuery(new Term("field", "nine"));
250
 
    SpanTermQuery term2 = new SpanTermQuery(new Term("field", "six"));
251
 
    SpanNearQuery query = new SpanNearQuery(new SpanQuery[] {term1, term2},
252
 
                                            4, false);
253
 
 
254
 
    checkHits(query, new int[]
255
 
      {609, 629, 639, 649, 659, 669, 679, 689, 699, 906, 926, 936, 946, 956,
256
 
              966, 976, 986, 996, 1609, 1629, 1639, 1649, 1659, 1669,
257
 
              1679, 1689, 1699, 1906, 1926, 1936, 1946, 1956, 1966, 1976, 1986,
258
 
              1996});
259
 
  }
260
 
 
261
 
  @Test
262
 
  public void testSpanNearOrdered() throws Exception {
263
 
    SpanTermQuery term1 = new SpanTermQuery(new Term("field", "nine"));
264
 
    SpanTermQuery term2 = new SpanTermQuery(new Term("field", "six"));
265
 
    SpanNearQuery query = new SpanNearQuery(new SpanQuery[] {term1, term2},
266
 
                                            4, true);
267
 
    checkHits(query, new int[]
268
 
      {906, 926, 936, 946, 956, 966, 976, 986, 996, 1906, 1926, 1936, 1946, 1956, 1966, 1976, 1986, 1996});
269
 
  }
270
 
 
271
 
  @Test
272
 
  public void testSpanNot() throws Exception {
273
 
    SpanTermQuery term1 = new SpanTermQuery(new Term("field", "eight"));
274
 
    SpanTermQuery term2 = new SpanTermQuery(new Term("field", "one"));
275
 
    SpanNearQuery near = new SpanNearQuery(new SpanQuery[] {term1, term2},
276
 
                                           4, true);
277
 
    SpanTermQuery term3 = new SpanTermQuery(new Term("field", "forty"));
278
 
    SpanNotQuery query = new SpanNotQuery(near, term3);
279
 
 
280
 
    checkHits(query, new int[]
281
 
      {801, 821, 831, 851, 861, 871, 881, 891, 1801, 1821, 1831, 1851, 1861, 1871, 1881, 1891});
282
 
 
283
 
    assertTrue(searcher.explain(query, 801).getValue() > 0.0f);
284
 
    assertTrue(searcher.explain(query, 891).getValue() > 0.0f);
285
 
  }
286
 
  
287
 
  @Test
288
 
  public void testSpanWithMultipleNotSingle() throws Exception {
289
 
    SpanTermQuery term1 = new SpanTermQuery(new Term("field", "eight"));
290
 
    SpanTermQuery term2 = new SpanTermQuery(new Term("field", "one"));
291
 
    SpanNearQuery near = new SpanNearQuery(new SpanQuery[] {term1, term2},
292
 
                                           4, true);
293
 
    SpanTermQuery term3 = new SpanTermQuery(new Term("field", "forty"));
294
 
 
295
 
    SpanOrQuery or = new SpanOrQuery(term3);
296
 
 
297
 
    SpanNotQuery query = new SpanNotQuery(near, or);
298
 
 
299
 
    checkHits(query, new int[]
300
 
      {801, 821, 831, 851, 861, 871, 881, 891,
301
 
              1801, 1821, 1831, 1851, 1861, 1871, 1881, 1891});
302
 
 
303
 
    assertTrue(searcher.explain(query, 801).getValue() > 0.0f);
304
 
    assertTrue(searcher.explain(query, 891).getValue() > 0.0f);
305
 
  }
306
 
 
307
 
  @Test
308
 
  public void testSpanWithMultipleNotMany() throws Exception {
309
 
    SpanTermQuery term1 = new SpanTermQuery(new Term("field", "eight"));
310
 
    SpanTermQuery term2 = new SpanTermQuery(new Term("field", "one"));
311
 
    SpanNearQuery near = new SpanNearQuery(new SpanQuery[] {term1, term2},
312
 
                                           4, true);
313
 
    SpanTermQuery term3 = new SpanTermQuery(new Term("field", "forty"));
314
 
    SpanTermQuery term4 = new SpanTermQuery(new Term("field", "sixty"));
315
 
    SpanTermQuery term5 = new SpanTermQuery(new Term("field", "eighty"));
316
 
 
317
 
    SpanOrQuery or = new SpanOrQuery(term3, term4, term5);
318
 
 
319
 
    SpanNotQuery query = new SpanNotQuery(near, or);
320
 
 
321
 
    checkHits(query, new int[]
322
 
      {801, 821, 831, 851, 871, 891, 1801, 1821, 1831, 1851, 1871, 1891});
323
 
 
324
 
    assertTrue(searcher.explain(query, 801).getValue() > 0.0f);
325
 
    assertTrue(searcher.explain(query, 891).getValue() > 0.0f);
326
 
  }
327
 
 
328
 
  @Test
329
 
  public void testNpeInSpanNearWithSpanNot() throws Exception {
330
 
    SpanTermQuery term1 = new SpanTermQuery(new Term("field", "eight"));
331
 
    SpanTermQuery term2 = new SpanTermQuery(new Term("field", "one"));
332
 
    SpanNearQuery near = new SpanNearQuery(new SpanQuery[] {term1, term2},
333
 
                                           4, true);
334
 
    SpanTermQuery hun = new SpanTermQuery(new Term("field", "hundred"));
335
 
    SpanTermQuery term3 = new SpanTermQuery(new Term("field", "forty"));
336
 
    SpanNearQuery exclude = new SpanNearQuery(new SpanQuery[] {hun, term3},
337
 
                                              1, true);
338
 
    
339
 
    SpanNotQuery query = new SpanNotQuery(near, exclude);
340
 
 
341
 
    checkHits(query, new int[]
342
 
      {801, 821, 831, 851, 861, 871, 881, 891,
343
 
              1801, 1821, 1831, 1851, 1861, 1871, 1881, 1891});
344
 
 
345
 
    assertTrue(searcher.explain(query, 801).getValue() > 0.0f);
346
 
    assertTrue(searcher.explain(query, 891).getValue() > 0.0f);
347
 
  }
348
 
 
349
 
  @Test
350
 
  public void testNpeInSpanNearInSpanFirstInSpanNot() throws Exception {
351
 
    int n = 5;
352
 
    SpanTermQuery hun = new SpanTermQuery(new Term("field", "hundred"));
353
 
    SpanTermQuery term40 = new SpanTermQuery(new Term("field", "forty"));
354
 
    SpanTermQuery term40c = (SpanTermQuery)term40.clone();
355
 
 
356
 
    SpanFirstQuery include = new SpanFirstQuery(term40, n);
357
 
    SpanNearQuery near = new SpanNearQuery(new SpanQuery[]{hun, term40c},
358
 
                                           n-1, true);
359
 
    SpanFirstQuery exclude = new SpanFirstQuery(near, n-1);
360
 
    SpanNotQuery q = new SpanNotQuery(include, exclude);
361
 
    
362
 
    checkHits(q, new int[]{40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 1040, 1041, 1042, 1043, 1044, 1045, 1046, 1047, 1048,
363
 
            1049, 1140, 1141, 1142, 1143, 1144, 1145, 1146, 1147, 1148, 1149, 1240, 1241, 1242, 1243, 1244,
364
 
            1245, 1246, 1247, 1248, 1249, 1340, 1341, 1342, 1343, 1344, 1345, 1346, 1347, 1348, 1349, 1440, 1441, 1442,
365
 
            1443, 1444, 1445, 1446, 1447, 1448, 1449, 1540, 1541, 1542, 1543, 1544, 1545, 1546, 1547, 1548, 1549, 1640,
366
 
            1641, 1642, 1643, 1644, 1645, 1646, 1647,
367
 
            1648, 1649, 1740, 1741, 1742, 1743, 1744, 1745, 1746, 1747, 1748, 1749, 1840, 1841, 1842, 1843, 1844, 1845, 1846,
368
 
            1847, 1848, 1849, 1940, 1941, 1942, 1943, 1944, 1945, 1946, 1947, 1948, 1949});
369
 
  }
370
 
  
371
 
  @Test
372
 
  public void testSpanFirst() throws Exception {
373
 
    SpanTermQuery term1 = new SpanTermQuery(new Term("field", "five"));
374
 
    SpanFirstQuery query = new SpanFirstQuery(term1, 1);
375
 
 
376
 
    checkHits(query, new int[]
377
 
      {5, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513,
378
 
       514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527,
379
 
       528, 529, 530, 531, 532, 533, 534, 535, 536, 537, 538, 539, 540, 541,
380
 
       542, 543, 544, 545, 546, 547, 548, 549, 550, 551, 552, 553, 554, 555,
381
 
       556, 557, 558, 559, 560, 561, 562, 563, 564, 565, 566, 567, 568, 569,
382
 
       570, 571, 572, 573, 574, 575, 576, 577, 578, 579, 580, 581, 582, 583,
383
 
       584, 585, 586, 587, 588, 589, 590, 591, 592, 593, 594, 595, 596, 597,
384
 
       598, 599});
385
 
 
386
 
    assertTrue(searcher.explain(query, 5).getValue() > 0.0f);
387
 
    assertTrue(searcher.explain(query, 599).getValue() > 0.0f);
388
 
 
389
 
  }
390
 
 
391
 
  @Test
392
 
  public void testSpanPositionRange() throws Exception {
393
 
    SpanPositionRangeQuery query;
394
 
    SpanTermQuery term1 = new SpanTermQuery(new Term("field", "five"));
395
 
    query = new SpanPositionRangeQuery(term1, 1, 2);
396
 
    checkHits(query, new int[]
397
 
      {25,35, 45, 55, 65, 75, 85, 95});
398
 
    assertTrue(searcher.explain(query, 25).getValue() > 0.0f);
399
 
    assertTrue(searcher.explain(query, 95).getValue() > 0.0f);
400
 
 
401
 
    query = new SpanPositionRangeQuery(term1, 0, 1);
402
 
    checkHits(query, new int[]
403
 
      {5, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512,
404
 
              513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525,
405
 
              526, 527, 528, 529, 530, 531, 532, 533, 534, 535, 536, 537, 538,
406
 
              539, 540, 541, 542, 543, 544, 545, 546, 547, 548, 549, 550, 551,
407
 
              552, 553, 554, 555, 556, 557, 558, 559, 560, 561, 562, 563, 564,
408
 
              565, 566, 567, 568, 569, 570, 571, 572, 573, 574, 575, 576, 577,
409
 
              578, 579, 580, 581, 582, 583, 584,
410
 
              585, 586, 587, 588, 589, 590, 591, 592, 593, 594, 595, 596, 597,
411
 
              598, 599});
412
 
 
413
 
    query = new SpanPositionRangeQuery(term1, 6, 7);
414
 
    checkHits(query, new int[]{});
415
 
  }
416
 
 
417
 
  @Test
418
 
  public void testSpanPayloadCheck() throws Exception {
419
 
    SpanTermQuery term1 = new SpanTermQuery(new Term("field", "five"));
420
 
    Payload pay = new Payload(("pos: " + 5).getBytes());
421
 
    SpanQuery query = new SpanPayloadCheckQuery(term1, Collections.singletonList(pay.getData()));
422
 
    checkHits(query, new int[]
423
 
      {1125, 1135, 1145, 1155, 1165, 1175, 1185, 1195, 1225, 1235, 1245, 1255, 1265, 1275, 1285, 1295, 1325, 1335, 1345, 1355, 1365, 1375, 1385, 1395, 1425, 1435, 1445, 1455, 1465, 1475, 1485, 1495, 1525, 1535, 1545, 1555, 1565, 1575, 1585, 1595, 1625, 1635, 1645, 1655, 1665, 1675, 1685, 1695, 1725, 1735, 1745, 1755, 1765, 1775, 1785, 1795, 1825, 1835, 1845, 1855, 1865, 1875, 1885, 1895, 1925, 1935, 1945, 1955, 1965, 1975, 1985, 1995});
424
 
    assertTrue(searcher.explain(query, 1125).getValue() > 0.0f);
425
 
 
426
 
    SpanTermQuery term2 = new SpanTermQuery(new Term("field", "hundred"));
427
 
    SpanNearQuery snq;
428
 
    SpanQuery[] clauses;
429
 
    List<byte[]> list;
430
 
    Payload pay2;
431
 
    clauses = new SpanQuery[2];
432
 
    clauses[0] = term1;
433
 
    clauses[1] = term2;
434
 
    snq = new SpanNearQuery(clauses, 0, true);
435
 
    pay = new Payload(("pos: " + 0).getBytes());
436
 
    pay2 = new Payload(("pos: " + 1).getBytes());
437
 
    list = new ArrayList<byte[]>();
438
 
    list.add(pay.getData());
439
 
    list.add(pay2.getData());
440
 
    query = new SpanNearPayloadCheckQuery(snq, list);
441
 
    checkHits(query, new int[]
442
 
      {500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 532, 533, 534, 535, 536, 537, 538, 539, 540, 541, 542, 543, 544, 545, 546, 547, 548, 549, 550, 551, 552, 553, 554, 555, 556, 557, 558, 559, 560, 561, 562, 563, 564, 565, 566, 567, 568, 569, 570, 571, 572, 573, 574, 575, 576, 577, 578, 579, 580, 581, 582, 583, 584, 585, 586, 587, 588, 589, 590, 591, 592, 593, 594, 595, 596, 597, 598, 599});
443
 
    clauses = new SpanQuery[3];
444
 
    clauses[0] = term1;
445
 
    clauses[1] = term2;
446
 
    clauses[2] = new SpanTermQuery(new Term("field", "five"));
447
 
    snq = new SpanNearQuery(clauses, 0, true);
448
 
    pay = new Payload(("pos: " + 0).getBytes());
449
 
    pay2 = new Payload(("pos: " + 1).getBytes());
450
 
    Payload pay3 = new Payload(("pos: " + 2).getBytes());
451
 
    list = new ArrayList<byte[]>();
452
 
    list.add(pay.getData());
453
 
    list.add(pay2.getData());
454
 
    list.add(pay3.getData());
455
 
    query = new SpanNearPayloadCheckQuery(snq, list);
456
 
    checkHits(query, new int[]
457
 
      {505});
458
 
  }
459
 
 
460
 
  public void testComplexSpanChecks() throws Exception {
461
 
    SpanTermQuery one = new SpanTermQuery(new Term("field", "one"));
462
 
    SpanTermQuery thous = new SpanTermQuery(new Term("field", "thousand"));
463
 
    //should be one position in between
464
 
    SpanTermQuery hundred = new SpanTermQuery(new Term("field", "hundred"));
465
 
    SpanTermQuery three = new SpanTermQuery(new Term("field", "three"));
466
 
 
467
 
    SpanNearQuery oneThous = new SpanNearQuery(new SpanQuery[]{one, thous}, 0, true);
468
 
    SpanNearQuery hundredThree = new SpanNearQuery(new SpanQuery[]{hundred, three}, 0, true);
469
 
    SpanNearQuery oneThousHunThree = new SpanNearQuery(new SpanQuery[]{oneThous, hundredThree}, 1, true);
470
 
    SpanQuery query;
471
 
    //this one's too small
472
 
    query = new SpanPositionRangeQuery(oneThousHunThree, 1, 2);
473
 
    checkHits(query, new int[]{});
474
 
    //this one's just right
475
 
    query = new SpanPositionRangeQuery(oneThousHunThree, 0, 6);
476
 
    checkHits(query, new int[]{1103, 1203,1303,1403,1503,1603,1703,1803,1903});
477
 
 
478
 
    Collection<byte[]> payloads = new ArrayList<byte[]>();
479
 
    Payload pay = new Payload(("pos: " + 0).getBytes());
480
 
    Payload pay2 = new Payload(("pos: " + 1).getBytes());
481
 
    Payload pay3 = new Payload(("pos: " + 3).getBytes());
482
 
    Payload pay4 = new Payload(("pos: " + 4).getBytes());
483
 
    payloads.add(pay.getData());
484
 
    payloads.add(pay2.getData());
485
 
    payloads.add(pay3.getData());
486
 
    payloads.add(pay4.getData());
487
 
    query = new SpanNearPayloadCheckQuery(oneThousHunThree, payloads);
488
 
    checkHits(query, new int[]{1103, 1203,1303,1403,1503,1603,1703,1803,1903});
489
 
 
490
 
  }
491
 
 
492
 
 
493
 
  @Test
494
 
  public void testSpanOr() throws Exception {
495
 
    SpanTermQuery term1 = new SpanTermQuery(new Term("field", "thirty"));
496
 
    SpanTermQuery term2 = new SpanTermQuery(new Term("field", "three"));
497
 
    SpanNearQuery near1 = new SpanNearQuery(new SpanQuery[] {term1, term2},
498
 
                                            0, true);
499
 
    SpanTermQuery term3 = new SpanTermQuery(new Term("field", "forty"));
500
 
    SpanTermQuery term4 = new SpanTermQuery(new Term("field", "seven"));
501
 
    SpanNearQuery near2 = new SpanNearQuery(new SpanQuery[] {term3, term4},
502
 
                                            0, true);
503
 
 
504
 
    SpanOrQuery query = new SpanOrQuery(near1, near2);
505
 
 
506
 
    checkHits(query, new int[]
507
 
      {33, 47, 133, 147, 233, 247, 333, 347, 433, 447, 533, 547, 633, 647, 733,
508
 
              747, 833, 847, 933, 947, 1033, 1047, 1133, 1147, 1233, 1247, 1333,
509
 
              1347, 1433, 1447, 1533, 1547, 1633, 1647, 1733, 1747, 1833, 1847, 1933, 1947});
510
 
 
511
 
    assertTrue(searcher.explain(query, 33).getValue() > 0.0f);
512
 
    assertTrue(searcher.explain(query, 947).getValue() > 0.0f);
513
 
  }
514
 
 
515
 
  @Test
516
 
  public void testSpanExactNested() throws Exception {
517
 
    SpanTermQuery term1 = new SpanTermQuery(new Term("field", "three"));
518
 
    SpanTermQuery term2 = new SpanTermQuery(new Term("field", "hundred"));
519
 
    SpanNearQuery near1 = new SpanNearQuery(new SpanQuery[] {term1, term2},
520
 
                                            0, true);
521
 
    SpanTermQuery term3 = new SpanTermQuery(new Term("field", "thirty"));
522
 
    SpanTermQuery term4 = new SpanTermQuery(new Term("field", "three"));
523
 
    SpanNearQuery near2 = new SpanNearQuery(new SpanQuery[] {term3, term4},
524
 
                                            0, true);
525
 
 
526
 
    SpanNearQuery query = new SpanNearQuery(new SpanQuery[] {near1, near2},
527
 
                                            0, true);
528
 
 
529
 
    checkHits(query, new int[] {333, 1333});
530
 
 
531
 
    assertTrue(searcher.explain(query, 333).getValue() > 0.0f);
532
 
  }
533
 
 
534
 
  @Test
535
 
  public void testSpanNearOr() throws Exception {
536
 
 
537
 
    SpanTermQuery t1 = new SpanTermQuery(new Term("field","six"));
538
 
    SpanTermQuery t3 = new SpanTermQuery(new Term("field","seven"));
539
 
    
540
 
    SpanTermQuery t5 = new SpanTermQuery(new Term("field","seven"));
541
 
    SpanTermQuery t6 = new SpanTermQuery(new Term("field","six"));
542
 
 
543
 
    SpanOrQuery to1 = new SpanOrQuery(t1, t3);
544
 
    SpanOrQuery to2 = new SpanOrQuery(t5, t6);
545
 
    
546
 
    SpanNearQuery query = new SpanNearQuery(new SpanQuery[] {to1, to2},
547
 
                                            10, true);
548
 
 
549
 
    checkHits(query, new int[]
550
 
      {606, 607, 626, 627, 636, 637, 646, 647, 656, 657, 666, 667, 676, 677,
551
 
              686, 687, 696, 697, 706, 707, 726, 727, 736, 737, 746, 747, 756,
552
 
              757, 766, 767, 776, 777, 786, 787, 796, 797, 1606, 1607, 1626,
553
 
              1627, 1636, 1637, 1646, 1647, 1656, 1657, 1666, 1667, 1676, 1677,
554
 
              1686, 1687, 1696, 1697, 1706, 1707, 1726, 1727, 1736, 1737,
555
 
              1746, 1747, 1756, 1757, 1766, 1767, 1776, 1777, 1786, 1787, 1796,
556
 
              1797});
557
 
  }
558
 
 
559
 
  @Test
560
 
  public void testSpanComplex1() throws Exception {
561
 
      
562
 
    SpanTermQuery t1 = new SpanTermQuery(new Term("field","six"));
563
 
    SpanTermQuery t2 = new SpanTermQuery(new Term("field","hundred"));
564
 
    SpanNearQuery tt1 = new SpanNearQuery(new SpanQuery[] {t1, t2}, 0,true);
565
 
 
566
 
    SpanTermQuery t3 = new SpanTermQuery(new Term("field","seven"));
567
 
    SpanTermQuery t4 = new SpanTermQuery(new Term("field","hundred"));
568
 
    SpanNearQuery tt2 = new SpanNearQuery(new SpanQuery[] {t3, t4}, 0,true);
569
 
    
570
 
    SpanTermQuery t5 = new SpanTermQuery(new Term("field","seven"));
571
 
    SpanTermQuery t6 = new SpanTermQuery(new Term("field","six"));
572
 
 
573
 
    SpanOrQuery to1 = new SpanOrQuery(tt1, tt2);
574
 
    SpanOrQuery to2 = new SpanOrQuery(t5, t6);
575
 
    
576
 
    SpanNearQuery query = new SpanNearQuery(new SpanQuery[] {to1, to2},
577
 
                                            100, true);
578
 
    
579
 
    checkHits(query, new int[]
580
 
      {606, 607, 626, 627, 636, 637, 646, 647, 656, 657, 666, 667, 676, 677, 686, 687, 696,
581
 
              697, 706, 707, 726, 727, 736, 737, 746, 747, 756, 757,
582
 
              766, 767, 776, 777, 786, 787, 796, 797, 1606, 1607, 1626, 1627, 1636, 1637, 1646,
583
 
              1647, 1656, 1657,
584
 
              1666, 1667, 1676, 1677, 1686, 1687, 1696, 1697, 1706, 1707, 1726, 1727, 1736, 1737,
585
 
              1746, 1747, 1756, 1757, 1766, 1767, 1776, 1777, 1786, 1787, 1796, 1797});
586
 
  }
587
 
  
588
 
  @Test
589
 
  public void testSpansSkipTo() throws Exception {
590
 
    SpanTermQuery t1 = new SpanTermQuery(new Term("field", "seventy"));
591
 
    SpanTermQuery t2 = new SpanTermQuery(new Term("field", "seventy"));
592
 
    Spans s1 = t1.getSpans(searcher.getIndexReader());
593
 
    Spans s2 = t2.getSpans(searcher.getIndexReader());
594
 
 
595
 
    assertTrue(s1.next());
596
 
    assertTrue(s2.next());
597
 
 
598
 
    boolean hasMore = true;
599
 
 
600
 
    do {
601
 
      hasMore = skipToAccoringToJavaDocs(s1, s1.doc());
602
 
      assertEquals(hasMore, s2.skipTo(s2.doc()));
603
 
      assertEquals(s1.doc(), s2.doc());
604
 
    } while (hasMore);
605
 
  }
606
 
 
607
 
  /** Skips to the first match beyond the current, whose document number is
608
 
   * greater than or equal to <i>target</i>. <p>Returns true iff there is such
609
 
   * a match.  <p>Behaves as if written: <pre>
610
 
   *   boolean skipTo(int target) {
611
 
   *     do {
612
 
   *       if (!next())
613
 
   *       return false;
614
 
   *     } while (target > doc());
615
 
   *     return true;
616
 
   *   }
617
 
   * </pre>
618
 
   */
619
 
  private boolean skipToAccoringToJavaDocs(Spans s, int target)
620
 
      throws Exception {
621
 
    do {
622
 
      if (!s.next())
623
 
        return false;
624
 
    } while (target > s.doc());
625
 
    return true;
626
 
 
627
 
  }
628
 
 
629
 
  private void checkHits(Query query, int[] results) throws IOException {
630
 
    CheckHits.checkHits(random, query, "field", searcher, results);
631
 
  }
632
 
}