X-Git-Url: https://git.mdrn.pl/pylucene.git/blobdiff_plain/a2e61f0c04805cfcb8706176758d1283c7e3a55c..aaeed5504b982cf3545252ab528713250aa33eed:/lucene-java-3.5.0/lucene/backwards/src/test/org/apache/lucene/search/TestBooleanQuery.java?ds=sidebyside diff --git a/lucene-java-3.5.0/lucene/backwards/src/test/org/apache/lucene/search/TestBooleanQuery.java b/lucene-java-3.5.0/lucene/backwards/src/test/org/apache/lucene/search/TestBooleanQuery.java new file mode 100644 index 0000000..eea83e8 --- /dev/null +++ b/lucene-java-3.5.0/lucene/backwards/src/test/org/apache/lucene/search/TestBooleanQuery.java @@ -0,0 +1,158 @@ +package org.apache.lucene.search; + +/** + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.TimeUnit; + +import org.apache.lucene.analysis.MockAnalyzer; +import org.apache.lucene.analysis.WhitespaceAnalyzer; +import org.apache.lucene.document.Document; +import org.apache.lucene.document.Field; +import org.apache.lucene.index.IndexReader; +import org.apache.lucene.index.MultiReader; +import org.apache.lucene.index.RandomIndexWriter; +import org.apache.lucene.index.Term; +import org.apache.lucene.queryParser.QueryParser; +import org.apache.lucene.store.Directory; +import org.apache.lucene.util.LuceneTestCase; + +public class TestBooleanQuery extends LuceneTestCase { + + public void testEquality() throws Exception { + BooleanQuery bq1 = new BooleanQuery(); + bq1.add(new TermQuery(new Term("field", "value1")), BooleanClause.Occur.SHOULD); + bq1.add(new TermQuery(new Term("field", "value2")), BooleanClause.Occur.SHOULD); + BooleanQuery nested1 = new BooleanQuery(); + nested1.add(new TermQuery(new Term("field", "nestedvalue1")), BooleanClause.Occur.SHOULD); + nested1.add(new TermQuery(new Term("field", "nestedvalue2")), BooleanClause.Occur.SHOULD); + bq1.add(nested1, BooleanClause.Occur.SHOULD); + + BooleanQuery bq2 = new BooleanQuery(); + bq2.add(new TermQuery(new Term("field", "value1")), BooleanClause.Occur.SHOULD); + bq2.add(new TermQuery(new Term("field", "value2")), BooleanClause.Occur.SHOULD); + BooleanQuery nested2 = new BooleanQuery(); + nested2.add(new TermQuery(new Term("field", "nestedvalue1")), BooleanClause.Occur.SHOULD); + nested2.add(new TermQuery(new Term("field", "nestedvalue2")), BooleanClause.Occur.SHOULD); + bq2.add(nested2, BooleanClause.Occur.SHOULD); + + assertEquals(bq1, bq2); + } + + public void testException() { + try { + BooleanQuery.setMaxClauseCount(0); + fail(); + } catch (IllegalArgumentException e) { + // okay + } + } + + // LUCENE-1630 + public void testNullOrSubScorer() throws Throwable { + Directory dir = newDirectory(); + RandomIndexWriter w = new RandomIndexWriter(random, dir); + Document doc = new Document(); + doc.add(newField("field", "a b c d", Field.Store.NO, Field.Index.ANALYZED)); + w.addDocument(doc); + + IndexReader r = w.getReader(); + IndexSearcher s = newSearcher(r); + BooleanQuery q = new BooleanQuery(); + q.add(new TermQuery(new Term("field", "a")), BooleanClause.Occur.SHOULD); + + // LUCENE-2617: make sure that a term not in the index still contributes to the score via coord factor + float score = s.search(q, 10).getMaxScore(); + Query subQuery = new TermQuery(new Term("field", "not_in_index")); + subQuery.setBoost(0); + q.add(subQuery, BooleanClause.Occur.SHOULD); + float score2 = s.search(q, 10).getMaxScore(); + assertEquals(score*.5, score2, 1e-6); + + // now test BooleanScorer2 + subQuery = new TermQuery(new Term("field", "b")); + subQuery.setBoost(0); + q.add(subQuery, BooleanClause.Occur.MUST); + score2 = s.search(q, 10).getMaxScore(); + assertEquals(score*(2.0/3), score2, 1e-6); + + // PhraseQuery w/ no terms added returns a null scorer + PhraseQuery pq = new PhraseQuery(); + q.add(pq, BooleanClause.Occur.SHOULD); + assertEquals(1, s.search(q, 10).totalHits); + + // A required clause which returns null scorer should return null scorer to + // IndexSearcher. + q = new BooleanQuery(); + pq = new PhraseQuery(); + q.add(new TermQuery(new Term("field", "a")), BooleanClause.Occur.SHOULD); + q.add(pq, BooleanClause.Occur.MUST); + assertEquals(0, s.search(q, 10).totalHits); + + DisjunctionMaxQuery dmq = new DisjunctionMaxQuery(1.0f); + dmq.add(new TermQuery(new Term("field", "a"))); + dmq.add(pq); + assertEquals(1, s.search(dmq, 10).totalHits); + + s.close(); + r.close(); + w.close(); + dir.close(); + } + + public void testDeMorgan() throws Exception { + Directory dir1 = newDirectory(); + RandomIndexWriter iw1 = new RandomIndexWriter(random, dir1); + Document doc1 = new Document(); + doc1.add(newField("field", "foo bar", Field.Index.ANALYZED)); + iw1.addDocument(doc1); + IndexReader reader1 = iw1.getReader(); + iw1.close(); + + Directory dir2 = newDirectory(); + RandomIndexWriter iw2 = new RandomIndexWriter(random, dir2); + Document doc2 = new Document(); + doc2.add(newField("field", "foo baz", Field.Index.ANALYZED)); + iw2.addDocument(doc2); + IndexReader reader2 = iw2.getReader(); + iw2.close(); + + QueryParser qp = new QueryParser(TEST_VERSION_CURRENT, "field", new MockAnalyzer(random)); + qp.setMultiTermRewriteMethod(MultiTermQuery.SCORING_BOOLEAN_QUERY_REWRITE); + + MultiReader multireader = new MultiReader(reader1, reader2); + IndexSearcher searcher = newSearcher(multireader); + assertEquals(0, searcher.search(qp.parse("+foo -ba*"), 10).totalHits); + searcher.close(); + + final ExecutorService es = Executors.newCachedThreadPool(); + searcher = new IndexSearcher(multireader, es); + if (VERBOSE) + System.out.println("rewritten form: " + searcher.rewrite(qp.parse("+foo -ba*"))); + assertEquals(0, searcher.search(qp.parse("+foo -ba*"), 10).totalHits); + es.shutdown(); + es.awaitTermination(1, TimeUnit.SECONDS); + + multireader.close(); + reader1.close(); + reader2.close(); + dir1.close(); + dir2.close(); + } +}