lucene-java-3.4.0/lucene/backwards/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.optimize();
 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 }