1 package org.apache.lucene.search.spans;
4 * Licensed to the Apache Software Foundation (ASF) under one or more
5 * contributor license agreements. See the NOTICE file distributed with
6 * this work for additional information regarding copyright ownership.
7 * The ASF licenses this file to You under the Apache License, Version 2.0
8 * (the "License"); you may not use this file except in compliance with
9 * the License. You may obtain a copy of the License at
11 * http://www.apache.org/licenses/LICENSE-2.0
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
20 import java.io.IOException;
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;
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;
57 * Tests basic search capabilities.
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".
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.
68 public class TestBasics extends LuceneTestCase {
69 private static IndexSearcher searcher;
70 private static IndexReader reader;
71 private static Directory directory;
73 static final class SimplePayloadFilter extends TokenFilter {
76 final PayloadAttribute payloadAttr;
77 final CharTermAttribute termAttr;
79 public SimplePayloadFilter(TokenStream input, String fieldName) {
81 this.fieldName = fieldName;
83 payloadAttr = input.addAttribute(PayloadAttribute.class);
84 termAttr = input.addAttribute(CharTermAttribute.class);
88 public boolean incrementToken() throws IOException {
89 if (input.incrementToken()) {
90 payloadAttr.setPayload(new Payload(("pos: " + pos).getBytes()));
99 public void reset() throws IOException {
105 static final Analyzer simplePayloadAnalyzer = new Analyzer() {
108 public TokenStream tokenStream(String fieldName, Reader reader) {
109 return new SimplePayloadFilter(new LowerCaseTokenizer(TEST_VERSION_CURRENT, reader), fieldName);
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);
126 reader = writer.getReader();
127 searcher = newSearcher(reader);
132 public static void afterClass() throws Exception {
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,
166 public void testTerm2() throws Exception {
167 Query query = new TermQuery(new Term("field", "seventish"));
168 checkHits(query, new int[] {});
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});
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[] {});
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,
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[] {});
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},
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});
218 assertTrue(searcher.explain(query, 77).getValue() > 0.0f);
219 assertTrue(searcher.explain(query, 977).getValue() > 0.0f);
221 QueryUtils.check(term1);
222 QueryUtils.check(term2);
223 QueryUtils.checkUnequal(term1,term2);
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 });
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},
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,
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},
267 checkHits(query, new int[]
268 {906, 926, 936, 946, 956, 966, 976, 986, 996, 1906, 1926, 1936, 1946, 1956, 1966, 1976, 1986, 1996});
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},
277 SpanTermQuery term3 = new SpanTermQuery(new Term("field", "forty"));
278 SpanNotQuery query = new SpanNotQuery(near, term3);
280 checkHits(query, new int[]
281 {801, 821, 831, 851, 861, 871, 881, 891, 1801, 1821, 1831, 1851, 1861, 1871, 1881, 1891});
283 assertTrue(searcher.explain(query, 801).getValue() > 0.0f);
284 assertTrue(searcher.explain(query, 891).getValue() > 0.0f);
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},
293 SpanTermQuery term3 = new SpanTermQuery(new Term("field", "forty"));
295 SpanOrQuery or = new SpanOrQuery(term3);
297 SpanNotQuery query = new SpanNotQuery(near, or);
299 checkHits(query, new int[]
300 {801, 821, 831, 851, 861, 871, 881, 891,
301 1801, 1821, 1831, 1851, 1861, 1871, 1881, 1891});
303 assertTrue(searcher.explain(query, 801).getValue() > 0.0f);
304 assertTrue(searcher.explain(query, 891).getValue() > 0.0f);
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},
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"));
317 SpanOrQuery or = new SpanOrQuery(term3, term4, term5);
319 SpanNotQuery query = new SpanNotQuery(near, or);
321 checkHits(query, new int[]
322 {801, 821, 831, 851, 871, 891, 1801, 1821, 1831, 1851, 1871, 1891});
324 assertTrue(searcher.explain(query, 801).getValue() > 0.0f);
325 assertTrue(searcher.explain(query, 891).getValue() > 0.0f);
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},
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},
339 SpanNotQuery query = new SpanNotQuery(near, exclude);
341 checkHits(query, new int[]
342 {801, 821, 831, 851, 861, 871, 881, 891,
343 1801, 1821, 1831, 1851, 1861, 1871, 1881, 1891});
345 assertTrue(searcher.explain(query, 801).getValue() > 0.0f);
346 assertTrue(searcher.explain(query, 891).getValue() > 0.0f);
350 public void testNpeInSpanNearInSpanFirstInSpanNot() throws Exception {
352 SpanTermQuery hun = new SpanTermQuery(new Term("field", "hundred"));
353 SpanTermQuery term40 = new SpanTermQuery(new Term("field", "forty"));
354 SpanTermQuery term40c = (SpanTermQuery)term40.clone();
356 SpanFirstQuery include = new SpanFirstQuery(term40, n);
357 SpanNearQuery near = new SpanNearQuery(new SpanQuery[]{hun, term40c},
359 SpanFirstQuery exclude = new SpanFirstQuery(near, n-1);
360 SpanNotQuery q = new SpanNotQuery(include, exclude);
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});
372 public void testSpanFirst() throws Exception {
373 SpanTermQuery term1 = new SpanTermQuery(new Term("field", "five"));
374 SpanFirstQuery query = new SpanFirstQuery(term1, 1);
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,
386 assertTrue(searcher.explain(query, 5).getValue() > 0.0f);
387 assertTrue(searcher.explain(query, 599).getValue() > 0.0f);
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);
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,
413 query = new SpanPositionRangeQuery(term1, 6, 7);
414 checkHits(query, new int[]{});
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);
426 SpanTermQuery term2 = new SpanTermQuery(new Term("field", "hundred"));
431 clauses = new SpanQuery[2];
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];
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[]
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"));
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);
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});
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});
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},
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},
504 SpanOrQuery query = new SpanOrQuery(near1, near2);
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});
511 assertTrue(searcher.explain(query, 33).getValue() > 0.0f);
512 assertTrue(searcher.explain(query, 947).getValue() > 0.0f);
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},
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},
526 SpanNearQuery query = new SpanNearQuery(new SpanQuery[] {near1, near2},
529 checkHits(query, new int[] {333, 1333});
531 assertTrue(searcher.explain(query, 333).getValue() > 0.0f);
535 public void testSpanNearOr() throws Exception {
537 SpanTermQuery t1 = new SpanTermQuery(new Term("field","six"));
538 SpanTermQuery t3 = new SpanTermQuery(new Term("field","seven"));
540 SpanTermQuery t5 = new SpanTermQuery(new Term("field","seven"));
541 SpanTermQuery t6 = new SpanTermQuery(new Term("field","six"));
543 SpanOrQuery to1 = new SpanOrQuery(t1, t3);
544 SpanOrQuery to2 = new SpanOrQuery(t5, t6);
546 SpanNearQuery query = new SpanNearQuery(new SpanQuery[] {to1, to2},
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,
560 public void testSpanComplex1() throws Exception {
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);
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);
570 SpanTermQuery t5 = new SpanTermQuery(new Term("field","seven"));
571 SpanTermQuery t6 = new SpanTermQuery(new Term("field","six"));
573 SpanOrQuery to1 = new SpanOrQuery(tt1, tt2);
574 SpanOrQuery to2 = new SpanOrQuery(t5, t6);
576 SpanNearQuery query = new SpanNearQuery(new SpanQuery[] {to1, to2},
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,
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});
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());
595 assertTrue(s1.next());
596 assertTrue(s2.next());
598 boolean hasMore = true;
601 hasMore = skipToAccoringToJavaDocs(s1, s1.doc());
602 assertEquals(hasMore, s2.skipTo(s2.doc()));
603 assertEquals(s1.doc(), s2.doc());
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) {
614 * } while (target > doc());
619 private boolean skipToAccoringToJavaDocs(Spans s, int target)
624 } while (target > s.doc());
629 private void checkHits(Query query, int[] results) throws IOException {
630 CheckHits.checkHits(random, query, "field", searcher, results);