← Back to branch summary

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

« back to all changes in this revision

Viewing changes to lucene/src/test/org/apache/lucene/search/TestSimpleExplanations.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/src/test/org/apache/lucene/search/TestSimpleExplanations.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 org.apache.lucene.analysis.standard.StandardAnalyzer;
21
 
 
22
 
import org.apache.lucene.document.Document;
23
 
import org.apache.lucene.document.Field;
24
 
import org.apache.lucene.index.IndexWriter;
25
 
import org.apache.lucene.index.Term;
26
 
import org.apache.lucene.queryParser.QueryParser;
27
 
import org.apache.lucene.search.spans.SpanNearQuery;
28
 
import org.apache.lucene.search.spans.SpanQuery;
29
 
import org.apache.lucene.search.spans.SpanTermQuery;
30
 
import org.apache.lucene.store.Directory;
31
 
 
32
 
 
33
 
/**
34
 
 * TestExplanations subclass focusing on basic query types
35
 
 */
36
 
public class TestSimpleExplanations extends TestExplanations {
37
 
 
38
 
  // we focus on queries that don't rewrite to other queries.
39
 
  // if we get those covered well, then the ones that rewrite should
40
 
  // also be covered.
41
 
  
42
 
 
43
 
  /* simple term tests */
44
 
  
45
 
  public void testT1() throws Exception {
46
 
    qtest("w1", new int[] { 0,1,2,3 });
47
 
  }
48
 
  public void testT2() throws Exception {
49
 
    qtest("w1^1000", new int[] { 0,1,2,3 });
50
 
  }
51
 
  
52
 
  /* MatchAllDocs */
53
 
  
54
 
  public void testMA1() throws Exception {
55
 
    qtest(new MatchAllDocsQuery(), new int[] { 0,1,2,3 });
56
 
  }
57
 
  public void testMA2() throws Exception {
58
 
    Query q=new MatchAllDocsQuery();
59
 
    q.setBoost(1000);
60
 
    qtest(q, new int[] { 0,1,2,3 });
61
 
  }
62
 
 
63
 
  /* some simple phrase tests */
64
 
  
65
 
  public void testP1() throws Exception {
66
 
    qtest("\"w1 w2\"", new int[] { 0 });
67
 
  }
68
 
  public void testP2() throws Exception {
69
 
    qtest("\"w1 w3\"", new int[] { 1,3 });
70
 
  }
71
 
  public void testP3() throws Exception {
72
 
    qtest("\"w1 w2\"~1", new int[] { 0,1,2 });
73
 
  }
74
 
  public void testP4() throws Exception {
75
 
    qtest("\"w2 w3\"~1", new int[] { 0,1,2,3 });
76
 
  }
77
 
  public void testP5() throws Exception {
78
 
    qtest("\"w3 w2\"~1", new int[] { 1,3 });
79
 
  }
80
 
  public void testP6() throws Exception {
81
 
    qtest("\"w3 w2\"~2", new int[] { 0,1,3 });
82
 
  }
83
 
  public void testP7() throws Exception {
84
 
    qtest("\"w3 w2\"~3", new int[] { 0,1,2,3 });
85
 
  }
86
 
 
87
 
  /* some simple filtered query tests */
88
 
  
89
 
  public void testFQ1() throws Exception {
90
 
    qtest(new FilteredQuery(qp.parse("w1"),
91
 
                            new ItemizedFilter(new int[] {0,1,2,3})),
92
 
          new int[] {0,1,2,3});
93
 
  }
94
 
  public void testFQ2() throws Exception {
95
 
    qtest(new FilteredQuery(qp.parse("w1"),
96
 
                            new ItemizedFilter(new int[] {0,2,3})),
97
 
          new int[] {0,2,3});
98
 
  }
99
 
  public void testFQ3() throws Exception {
100
 
    qtest(new FilteredQuery(qp.parse("xx"),
101
 
                            new ItemizedFilter(new int[] {1,3})),
102
 
          new int[] {3});
103
 
  }
104
 
  public void testFQ4() throws Exception {
105
 
    qtest(new FilteredQuery(qp.parse("xx^1000"),
106
 
                            new ItemizedFilter(new int[] {1,3})),
107
 
          new int[] {3});
108
 
  }
109
 
  public void testFQ6() throws Exception {
110
 
    Query q = new FilteredQuery(qp.parse("xx"),
111
 
                                new ItemizedFilter(new int[] {1,3}));
112
 
    q.setBoost(1000);
113
 
    qtest(q, new int[] {3});
114
 
  }
115
 
 
116
 
  /* ConstantScoreQueries */
117
 
  
118
 
  public void testCSQ1() throws Exception {
119
 
    Query q = new ConstantScoreQuery(new ItemizedFilter(new int[] {0,1,2,3}));
120
 
    qtest(q, new int[] {0,1,2,3});
121
 
  }
122
 
  public void testCSQ2() throws Exception {
123
 
    Query q = new ConstantScoreQuery(new ItemizedFilter(new int[] {1,3}));
124
 
    qtest(q, new int[] {1,3});
125
 
  }
126
 
  public void testCSQ3() throws Exception {
127
 
    Query q = new ConstantScoreQuery(new ItemizedFilter(new int[] {0,2}));
128
 
    q.setBoost(1000);
129
 
    qtest(q, new int[] {0,2});
130
 
  }
131
 
  
132
 
  /* DisjunctionMaxQuery */
133
 
  
134
 
  public void testDMQ1() throws Exception {
135
 
    DisjunctionMaxQuery q = new DisjunctionMaxQuery(0.0f);
136
 
    q.add(qp.parse("w1"));
137
 
    q.add(qp.parse("w5"));
138
 
    qtest(q, new int[] { 0,1,2,3 });
139
 
  }
140
 
  public void testDMQ2() throws Exception {
141
 
    DisjunctionMaxQuery q = new DisjunctionMaxQuery(0.5f);
142
 
    q.add(qp.parse("w1"));
143
 
    q.add(qp.parse("w5"));
144
 
    qtest(q, new int[] { 0,1,2,3 });
145
 
  }
146
 
  public void testDMQ3() throws Exception {
147
 
    DisjunctionMaxQuery q = new DisjunctionMaxQuery(0.5f);
148
 
    q.add(qp.parse("QQ"));
149
 
    q.add(qp.parse("w5"));
150
 
    qtest(q, new int[] { 0 });
151
 
  }
152
 
  public void testDMQ4() throws Exception {
153
 
    DisjunctionMaxQuery q = new DisjunctionMaxQuery(0.5f);
154
 
    q.add(qp.parse("QQ"));
155
 
    q.add(qp.parse("xx"));
156
 
    qtest(q, new int[] { 2,3 });
157
 
  }
158
 
  public void testDMQ5() throws Exception {
159
 
    DisjunctionMaxQuery q = new DisjunctionMaxQuery(0.5f);
160
 
    q.add(qp.parse("yy -QQ"));
161
 
    q.add(qp.parse("xx"));
162
 
    qtest(q, new int[] { 2,3 });
163
 
  }
164
 
  public void testDMQ6() throws Exception {
165
 
    DisjunctionMaxQuery q = new DisjunctionMaxQuery(0.5f);
166
 
    q.add(qp.parse("-yy w3"));
167
 
    q.add(qp.parse("xx"));
168
 
    qtest(q, new int[] { 0,1,2,3 });
169
 
  }
170
 
  public void testDMQ7() throws Exception {
171
 
    DisjunctionMaxQuery q = new DisjunctionMaxQuery(0.5f);
172
 
    q.add(qp.parse("-yy w3"));
173
 
    q.add(qp.parse("w2"));
174
 
    qtest(q, new int[] { 0,1,2,3 });
175
 
  }
176
 
  public void testDMQ8() throws Exception {
177
 
    DisjunctionMaxQuery q = new DisjunctionMaxQuery(0.5f);
178
 
    q.add(qp.parse("yy w5^100"));
179
 
    q.add(qp.parse("xx^100000"));
180
 
    qtest(q, new int[] { 0,2,3 });
181
 
  }
182
 
  public void testDMQ9() throws Exception {
183
 
    DisjunctionMaxQuery q = new DisjunctionMaxQuery(0.5f);
184
 
    q.add(qp.parse("yy w5^100"));
185
 
    q.add(qp.parse("xx^0"));
186
 
    qtest(q, new int[] { 0,2,3 });
187
 
  }
188
 
  
189
 
  /* MultiPhraseQuery */
190
 
  
191
 
  public void testMPQ1() throws Exception {
192
 
    MultiPhraseQuery q = new MultiPhraseQuery();
193
 
    q.add(ta(new String[] {"w1"}));
194
 
    q.add(ta(new String[] {"w2","w3", "xx"}));
195
 
    qtest(q, new int[] { 0,1,2,3 });
196
 
  }
197
 
  public void testMPQ2() throws Exception {
198
 
    MultiPhraseQuery q = new MultiPhraseQuery();
199
 
    q.add(ta(new String[] {"w1"}));
200
 
    q.add(ta(new String[] {"w2","w3"}));
201
 
    qtest(q, new int[] { 0,1,3 });
202
 
  }
203
 
  public void testMPQ3() throws Exception {
204
 
    MultiPhraseQuery q = new MultiPhraseQuery();
205
 
    q.add(ta(new String[] {"w1","xx"}));
206
 
    q.add(ta(new String[] {"w2","w3"}));
207
 
    qtest(q, new int[] { 0,1,2,3 });
208
 
  }
209
 
  public void testMPQ4() throws Exception {
210
 
    MultiPhraseQuery q = new MultiPhraseQuery();
211
 
    q.add(ta(new String[] {"w1"}));
212
 
    q.add(ta(new String[] {"w2"}));
213
 
    qtest(q, new int[] { 0 });
214
 
  }
215
 
  public void testMPQ5() throws Exception {
216
 
    MultiPhraseQuery q = new MultiPhraseQuery();
217
 
    q.add(ta(new String[] {"w1"}));
218
 
    q.add(ta(new String[] {"w2"}));
219
 
    q.setSlop(1);
220
 
    qtest(q, new int[] { 0,1,2 });
221
 
  }
222
 
  public void testMPQ6() throws Exception {
223
 
    MultiPhraseQuery q = new MultiPhraseQuery();
224
 
    q.add(ta(new String[] {"w1","w3"}));
225
 
    q.add(ta(new String[] {"w2"}));
226
 
    q.setSlop(1);
227
 
    qtest(q, new int[] { 0,1,2,3 });
228
 
  }
229
 
 
230
 
  /* some simple tests of boolean queries containing term queries */
231
 
  
232
 
  public void testBQ1() throws Exception {
233
 
    qtest("+w1 +w2", new int[] { 0,1,2,3 });
234
 
  }
235
 
  public void testBQ2() throws Exception {
236
 
    qtest("+yy +w3", new int[] { 2,3 });
237
 
  }
238
 
  public void testBQ3() throws Exception {
239
 
    qtest("yy +w3", new int[] { 0,1,2,3 });
240
 
  }
241
 
  public void testBQ4() throws Exception {
242
 
    qtest("w1 (-xx w2)", new int[] { 0,1,2,3 });
243
 
  }
244
 
  public void testBQ5() throws Exception {
245
 
    qtest("w1 (+qq w2)", new int[] { 0,1,2,3 });
246
 
  }
247
 
  public void testBQ6() throws Exception {
248
 
    qtest("w1 -(-qq w5)", new int[] { 1,2,3 });
249
 
  }
250
 
  public void testBQ7() throws Exception {
251
 
    qtest("+w1 +(qq (xx -w2) (+w3 +w4))", new int[] { 0 });
252
 
  }
253
 
  public void testBQ8() throws Exception {
254
 
    qtest("+w1 (qq (xx -w2) (+w3 +w4))", new int[] { 0,1,2,3 });
255
 
  }
256
 
  public void testBQ9() throws Exception {
257
 
    qtest("+w1 (qq (-xx w2) -(+w3 +w4))", new int[] { 0,1,2,3 });
258
 
  }
259
 
  public void testBQ10() throws Exception {
260
 
    qtest("+w1 +(qq (-xx w2) -(+w3 +w4))", new int[] { 1 });
261
 
  }
262
 
  public void testBQ11() throws Exception {
263
 
    qtest("w1 w2^1000.0", new int[] { 0,1,2,3 });
264
 
  }
265
 
  public void testBQ14() throws Exception {
266
 
    BooleanQuery q = new BooleanQuery(true);
267
 
    q.add(qp.parse("QQQQQ"), BooleanClause.Occur.SHOULD);
268
 
    q.add(qp.parse("w1"), BooleanClause.Occur.SHOULD);
269
 
    qtest(q, new int[] { 0,1,2,3 });
270
 
  }
271
 
  public void testBQ15() throws Exception {
272
 
    BooleanQuery q = new BooleanQuery(true);
273
 
    q.add(qp.parse("QQQQQ"), BooleanClause.Occur.MUST_NOT);
274
 
    q.add(qp.parse("w1"), BooleanClause.Occur.SHOULD);
275
 
    qtest(q, new int[] { 0,1,2,3 });
276
 
  }
277
 
  public void testBQ16() throws Exception {
278
 
    BooleanQuery q = new BooleanQuery(true);
279
 
    q.add(qp.parse("QQQQQ"), BooleanClause.Occur.SHOULD);
280
 
    q.add(qp.parse("w1 -xx"), BooleanClause.Occur.SHOULD);
281
 
    qtest(q, new int[] { 0,1 });
282
 
  }
283
 
  public void testBQ17() throws Exception {
284
 
    BooleanQuery q = new BooleanQuery(true);
285
 
    q.add(qp.parse("w2"), BooleanClause.Occur.SHOULD);
286
 
    q.add(qp.parse("w1 -xx"), BooleanClause.Occur.SHOULD);
287
 
    qtest(q, new int[] { 0,1,2,3 });
288
 
  }
289
 
  public void testBQ19() throws Exception {
290
 
    qtest("-yy w3", new int[] { 0,1 });
291
 
  }
292
 
  
293
 
  public void testBQ20() throws Exception {
294
 
    BooleanQuery q = new BooleanQuery();
295
 
    q.setMinimumNumberShouldMatch(2);
296
 
    q.add(qp.parse("QQQQQ"), BooleanClause.Occur.SHOULD);
297
 
    q.add(qp.parse("yy"), BooleanClause.Occur.SHOULD);
298
 
    q.add(qp.parse("zz"), BooleanClause.Occur.SHOULD);
299
 
    q.add(qp.parse("w5"), BooleanClause.Occur.SHOULD);
300
 
    q.add(qp.parse("w4"), BooleanClause.Occur.SHOULD);
301
 
    
302
 
    qtest(q, new int[] { 0,3 });
303
 
    
304
 
  }
305
 
  
306
 
  public void testTermQueryMultiSearcherExplain() throws Exception {
307
 
    // creating two directories for indices
308
 
    Directory indexStoreA = newDirectory();
309
 
    Directory indexStoreB = newDirectory();
310
 
 
311
 
    Document lDoc = new Document();
312
 
    lDoc.add(newField("handle", "1 2", Field.Store.YES, Field.Index.ANALYZED));
313
 
    Document lDoc2 = new Document();
314
 
    lDoc2.add(newField("handle", "1 2", Field.Store.YES, Field.Index.ANALYZED));
315
 
    Document lDoc3 = new Document();
316
 
    lDoc3.add(newField("handle", "1 2", Field.Store.YES, Field.Index.ANALYZED));
317
 
 
318
 
    IndexWriter writerA = new IndexWriter(indexStoreA, newIndexWriterConfig(
319
 
        TEST_VERSION_CURRENT, new StandardAnalyzer(
320
 
        TEST_VERSION_CURRENT)));
321
 
    IndexWriter writerB = new IndexWriter(indexStoreB, newIndexWriterConfig(
322
 
        TEST_VERSION_CURRENT, new StandardAnalyzer(
323
 
        TEST_VERSION_CURRENT)));
324
 
 
325
 
    writerA.addDocument(lDoc);
326
 
    writerA.addDocument(lDoc2);
327
 
    writerA.forceMerge(1);
328
 
    writerA.close();
329
 
 
330
 
    writerB.addDocument(lDoc3);
331
 
    writerB.close();
332
 
 
333
 
    QueryParser parser = new QueryParser(TEST_VERSION_CURRENT, "fulltext", new StandardAnalyzer(TEST_VERSION_CURRENT));
334
 
    Query query = parser.parse("handle:1");
335
 
 
336
 
    Searcher[] searchers = new Searcher[2];
337
 
    searchers[0] = new IndexSearcher(indexStoreB, true);
338
 
    searchers[1] = new IndexSearcher(indexStoreA, true);
339
 
    Searcher mSearcher = new MultiSearcher(searchers);
340
 
    ScoreDoc[] hits = mSearcher.search(query, null, 1000).scoreDocs;
341
 
 
342
 
    assertEquals(3, hits.length);
343
 
 
344
 
    Explanation explain = mSearcher.explain(query, hits[0].doc);
345
 
    String exp = explain.toString(0);
346
 
    assertTrue(exp, exp.indexOf("maxDocs=3") > -1);
347
 
    assertTrue(exp, exp.indexOf("docFreq=3") > -1);
348
 
    
349
 
    query = parser.parse("handle:\"1 2\"");
350
 
    hits = mSearcher.search(query, null, 1000).scoreDocs;
351
 
 
352
 
    assertEquals(3, hits.length);
353
 
 
354
 
    explain = mSearcher.explain(query, hits[0].doc);
355
 
    exp = explain.toString(0);
356
 
    assertTrue(exp, exp.indexOf("1=3") > -1);
357
 
    assertTrue(exp, exp.indexOf("2=3") > -1);
358
 
    
359
 
    query = new SpanNearQuery(new SpanQuery[] {
360
 
        new SpanTermQuery(new Term("handle", "1")),
361
 
        new SpanTermQuery(new Term("handle", "2")) }, 0, true);
362
 
    hits = mSearcher.search(query, null, 1000).scoreDocs;
363
 
 
364
 
    assertEquals(3, hits.length);
365
 
 
366
 
    explain = mSearcher.explain(query, hits[0].doc);
367
 
    exp = explain.toString(0);
368
 
    assertTrue(exp, exp.indexOf("1=3") > -1);
369
 
    assertTrue(exp, exp.indexOf("2=3") > -1);
370
 
    mSearcher.close();
371
 
    indexStoreA.close();
372
 
    indexStoreB.close();
373
 
  }
374
 
 
375
 
  /* BQ of TQ: using alt so some fields have zero boost and some don't */
376
 
  
377
 
  public void testMultiFieldBQ1() throws Exception {
378
 
    qtest("+w1 +alt:w2", new int[] { 0,1,2,3 });
379
 
  }
380
 
  public void testMultiFieldBQ2() throws Exception {
381
 
    qtest("+yy +alt:w3", new int[] { 2,3 });
382
 
  }
383
 
  public void testMultiFieldBQ3() throws Exception {
384
 
    qtest("yy +alt:w3", new int[] { 0,1,2,3 });
385
 
  }
386
 
  public void testMultiFieldBQ4() throws Exception {
387
 
    qtest("w1 (-xx alt:w2)", new int[] { 0,1,2,3 });
388
 
  }
389
 
  public void testMultiFieldBQ5() throws Exception {
390
 
    qtest("w1 (+alt:qq alt:w2)", new int[] { 0,1,2,3 });
391
 
  }
392
 
  public void testMultiFieldBQ6() throws Exception {
393
 
    qtest("w1 -(-alt:qq alt:w5)", new int[] { 1,2,3 });
394
 
  }
395
 
  public void testMultiFieldBQ7() throws Exception {
396
 
    qtest("+w1 +(alt:qq (alt:xx -alt:w2) (+alt:w3 +alt:w4))", new int[] { 0 });
397
 
  }
398
 
  public void testMultiFieldBQ8() throws Exception {
399
 
    qtest("+alt:w1 (qq (alt:xx -w2) (+alt:w3 +w4))", new int[] { 0,1,2,3 });
400
 
  }
401
 
  public void testMultiFieldBQ9() throws Exception {
402
 
    qtest("+w1 (alt:qq (-xx w2) -(+alt:w3 +w4))", new int[] { 0,1,2,3 });
403
 
  }
404
 
  public void testMultiFieldBQ10() throws Exception {
405
 
    qtest("+w1 +(alt:qq (-xx alt:w2) -(+alt:w3 +w4))", new int[] { 1 });
406
 
  }
407
 
 
408
 
  /* BQ of PQ: using alt so some fields have zero boost and some don't */
409
 
  
410
 
  public void testMultiFieldBQofPQ1() throws Exception {
411
 
    qtest("\"w1 w2\" alt:\"w1 w2\"", new int[] { 0 });
412
 
  }
413
 
  public void testMultiFieldBQofPQ2() throws Exception {
414
 
    qtest("\"w1 w3\" alt:\"w1 w3\"", new int[] { 1,3 });
415
 
  }
416
 
  public void testMultiFieldBQofPQ3() throws Exception {
417
 
    qtest("\"w1 w2\"~1 alt:\"w1 w2\"~1", new int[] { 0,1,2 });
418
 
  }
419
 
  public void testMultiFieldBQofPQ4() throws Exception {
420
 
    qtest("\"w2 w3\"~1 alt:\"w2 w3\"~1", new int[] { 0,1,2,3 });
421
 
  }
422
 
  public void testMultiFieldBQofPQ5() throws Exception {
423
 
    qtest("\"w3 w2\"~1 alt:\"w3 w2\"~1", new int[] { 1,3 });
424
 
  }
425
 
  public void testMultiFieldBQofPQ6() throws Exception {
426
 
    qtest("\"w3 w2\"~2 alt:\"w3 w2\"~2", new int[] { 0,1,3 });
427
 
  }
428
 
  public void testMultiFieldBQofPQ7() throws Exception {
429
 
    qtest("\"w3 w2\"~3 alt:\"w3 w2\"~3", new int[] { 0,1,2,3 });
430
 
  }
431
 
 
432
 
}