You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@lucene.apache.org by jp...@apache.org on 2015/07/29 09:09:41 UTC
svn commit: r1693190 [2/8] - in /lucene/dev/branches/branch_5x: ./ lucene/
lucene/analysis/common/src/test/org/apache/lucene/analysis/shingle/
lucene/benchmark/
lucene/benchmark/src/java/org/apache/lucene/benchmark/byTask/feeds/
lucene/benchmark/src/ja...
Modified: lucene/dev/branches/branch_5x/lucene/core/src/test/org/apache/lucene/index/TestParallelCompositeReader.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/branch_5x/lucene/core/src/test/org/apache/lucene/index/TestParallelCompositeReader.java?rev=1693190&r1=1693189&r2=1693190&view=diff
==============================================================================
--- lucene/dev/branches/branch_5x/lucene/core/src/test/org/apache/lucene/index/TestParallelCompositeReader.java (original)
+++ lucene/dev/branches/branch_5x/lucene/core/src/test/org/apache/lucene/index/TestParallelCompositeReader.java Wed Jul 29 07:09:39 2015
@@ -75,10 +75,10 @@ public class TestParallelCompositeReader
queryTest(new TermQuery(new Term("f4", "v1")));
queryTest(new TermQuery(new Term("f4", "v2")));
- BooleanQuery bq1 = new BooleanQuery();
+ BooleanQuery.Builder bq1 = new BooleanQuery.Builder();
bq1.add(new TermQuery(new Term("f1", "v1")), Occur.MUST);
bq1.add(new TermQuery(new Term("f4", "v1")), Occur.MUST);
- queryTest(bq1);
+ queryTest(bq1.build());
}
public void testRefCounts1() throws IOException {
Modified: lucene/dev/branches/branch_5x/lucene/core/src/test/org/apache/lucene/index/TestParallelLeafReader.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/branch_5x/lucene/core/src/test/org/apache/lucene/index/TestParallelLeafReader.java?rev=1693190&r1=1693189&r2=1693190&view=diff
==============================================================================
--- lucene/dev/branches/branch_5x/lucene/core/src/test/org/apache/lucene/index/TestParallelLeafReader.java (original)
+++ lucene/dev/branches/branch_5x/lucene/core/src/test/org/apache/lucene/index/TestParallelLeafReader.java Wed Jul 29 07:09:39 2015
@@ -48,10 +48,10 @@ public class TestParallelLeafReader exte
queryTest(new TermQuery(new Term("f4", "v1")));
queryTest(new TermQuery(new Term("f4", "v2")));
- BooleanQuery bq1 = new BooleanQuery();
+ BooleanQuery.Builder bq1 = new BooleanQuery.Builder();
bq1.add(new TermQuery(new Term("f1", "v1")), Occur.MUST);
bq1.add(new TermQuery(new Term("f4", "v1")), Occur.MUST);
- queryTest(bq1);
+ queryTest(bq1.build());
single.getIndexReader().close(); single = null;
parallel.getIndexReader().close(); parallel = null;
Modified: lucene/dev/branches/branch_5x/lucene/core/src/test/org/apache/lucene/search/TestApproximationSearchEquivalence.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/branch_5x/lucene/core/src/test/org/apache/lucene/search/TestApproximationSearchEquivalence.java?rev=1693190&r1=1693189&r2=1693190&view=diff
==============================================================================
--- lucene/dev/branches/branch_5x/lucene/core/src/test/org/apache/lucene/search/TestApproximationSearchEquivalence.java (original)
+++ lucene/dev/branches/branch_5x/lucene/core/src/test/org/apache/lucene/search/TestApproximationSearchEquivalence.java Wed Jul 29 07:09:39 2015
@@ -31,15 +31,15 @@ public class TestApproximationSearchEqui
TermQuery q1 = new TermQuery(t1);
TermQuery q2 = new TermQuery(t2);
- BooleanQuery bq1 = new BooleanQuery();
+ BooleanQuery.Builder bq1 = new BooleanQuery.Builder();
bq1.add(q1, Occur.MUST);
bq1.add(q2, Occur.MUST);
- BooleanQuery bq2 = new BooleanQuery();
+ BooleanQuery.Builder bq2 = new BooleanQuery.Builder();
bq2.add(new RandomApproximationQuery(q1, random()), Occur.MUST);
bq2.add(new RandomApproximationQuery(q2, random()), Occur.MUST);
- assertSameScores(bq1, bq2);
+ assertSameScores(bq1.build(), bq2.build());
}
public void testNestedConjunction() throws Exception {
@@ -50,23 +50,23 @@ public class TestApproximationSearchEqui
TermQuery q2 = new TermQuery(t2);
TermQuery q3 = new TermQuery(t3);
- BooleanQuery bq1 = new BooleanQuery();
+ BooleanQuery.Builder bq1 = new BooleanQuery.Builder();
bq1.add(q1, Occur.MUST);
bq1.add(q2, Occur.MUST);
- BooleanQuery bq2 = new BooleanQuery();
- bq2.add(bq1, Occur.MUST);
+ BooleanQuery.Builder bq2 = new BooleanQuery.Builder();
+ bq2.add(bq1.build(), Occur.MUST);
bq2.add(q3, Occur.MUST);
- BooleanQuery bq3 = new BooleanQuery();
+ BooleanQuery.Builder bq3 = new BooleanQuery.Builder();
bq3.add(new RandomApproximationQuery(q1, random()), Occur.MUST);
bq3.add(new RandomApproximationQuery(q2, random()), Occur.MUST);
- BooleanQuery bq4 = new BooleanQuery();
- bq4.add(bq3, Occur.MUST);
+ BooleanQuery.Builder bq4 = new BooleanQuery.Builder();
+ bq4.add(bq3.build(), Occur.MUST);
bq4.add(q3, Occur.MUST);
- assertSameScores(bq2, bq4);
+ assertSameScores(bq2.build(), bq4.build());
}
public void testDisjunction() throws Exception {
@@ -75,15 +75,15 @@ public class TestApproximationSearchEqui
TermQuery q1 = new TermQuery(t1);
TermQuery q2 = new TermQuery(t2);
- BooleanQuery bq1 = new BooleanQuery();
+ BooleanQuery.Builder bq1 = new BooleanQuery.Builder();
bq1.add(q1, Occur.SHOULD);
bq1.add(q2, Occur.SHOULD);
- BooleanQuery bq2 = new BooleanQuery();
+ BooleanQuery.Builder bq2 = new BooleanQuery.Builder();
bq2.add(new RandomApproximationQuery(q1, random()), Occur.SHOULD);
bq2.add(new RandomApproximationQuery(q2, random()), Occur.SHOULD);
- assertSameScores(bq1, bq2);
+ assertSameScores(bq1.build(), bq2.build());
}
public void testNestedDisjunction() throws Exception {
@@ -94,23 +94,23 @@ public class TestApproximationSearchEqui
TermQuery q2 = new TermQuery(t2);
TermQuery q3 = new TermQuery(t3);
- BooleanQuery bq1 = new BooleanQuery();
+ BooleanQuery.Builder bq1 = new BooleanQuery.Builder();
bq1.add(q1, Occur.SHOULD);
bq1.add(q2, Occur.SHOULD);
- BooleanQuery bq2 = new BooleanQuery();
- bq2.add(bq1, Occur.SHOULD);
+ BooleanQuery.Builder bq2 = new BooleanQuery.Builder();
+ bq2.add(bq1.build(), Occur.SHOULD);
bq2.add(q3, Occur.SHOULD);
- BooleanQuery bq3 = new BooleanQuery();
+ BooleanQuery.Builder bq3 = new BooleanQuery.Builder();
bq3.add(new RandomApproximationQuery(q1, random()), Occur.SHOULD);
bq3.add(new RandomApproximationQuery(q2, random()), Occur.SHOULD);
- BooleanQuery bq4 = new BooleanQuery();
- bq4.add(bq3, Occur.SHOULD);
+ BooleanQuery.Builder bq4 = new BooleanQuery.Builder();
+ bq4.add(bq3.build(), Occur.SHOULD);
bq4.add(q3, Occur.SHOULD);
- assertSameScores(bq2, bq4);
+ assertSameScores(bq2.build(), bq4.build());
}
public void testDisjunctionInConjunction() throws Exception {
@@ -121,23 +121,23 @@ public class TestApproximationSearchEqui
TermQuery q2 = new TermQuery(t2);
TermQuery q3 = new TermQuery(t3);
- BooleanQuery bq1 = new BooleanQuery();
+ BooleanQuery.Builder bq1 = new BooleanQuery.Builder();
bq1.add(q1, Occur.SHOULD);
bq1.add(q2, Occur.SHOULD);
- BooleanQuery bq2 = new BooleanQuery();
- bq2.add(bq1, Occur.MUST);
+ BooleanQuery.Builder bq2 = new BooleanQuery.Builder();
+ bq2.add(bq1.build(), Occur.MUST);
bq2.add(q3, Occur.MUST);
- BooleanQuery bq3 = new BooleanQuery();
+ BooleanQuery.Builder bq3 = new BooleanQuery.Builder();
bq3.add(new RandomApproximationQuery(q1, random()), Occur.SHOULD);
bq3.add(new RandomApproximationQuery(q2, random()), Occur.SHOULD);
- BooleanQuery bq4 = new BooleanQuery();
- bq4.add(bq3, Occur.MUST);
+ BooleanQuery.Builder bq4 = new BooleanQuery.Builder();
+ bq4.add(bq3.build(), Occur.MUST);
bq4.add(q3, Occur.MUST);
- assertSameScores(bq2, bq4);
+ assertSameScores(bq2.build(), bq4.build());
}
public void testConjunctionInDisjunction() throws Exception {
@@ -148,23 +148,23 @@ public class TestApproximationSearchEqui
TermQuery q2 = new TermQuery(t2);
TermQuery q3 = new TermQuery(t3);
- BooleanQuery bq1 = new BooleanQuery();
+ BooleanQuery.Builder bq1 = new BooleanQuery.Builder();
bq1.add(q1, Occur.MUST);
bq1.add(q2, Occur.MUST);
- BooleanQuery bq2 = new BooleanQuery();
- bq2.add(bq1, Occur.SHOULD);
+ BooleanQuery.Builder bq2 = new BooleanQuery.Builder();
+ bq2.add(bq1.build(), Occur.SHOULD);
bq2.add(q3, Occur.SHOULD);
- BooleanQuery bq3 = new BooleanQuery();
+ BooleanQuery.Builder bq3 = new BooleanQuery.Builder();
bq3.add(new RandomApproximationQuery(q1, random()), Occur.MUST);
bq3.add(new RandomApproximationQuery(q2, random()), Occur.MUST);
- BooleanQuery bq4 = new BooleanQuery();
- bq4.add(bq3, Occur.SHOULD);
+ BooleanQuery.Builder bq4 = new BooleanQuery.Builder();
+ bq4.add(bq3.build(), Occur.SHOULD);
bq4.add(q3, Occur.SHOULD);
- assertSameScores(bq2, bq4);
+ assertSameScores(bq2.build(), bq4.build());
}
public void testConstantScore() throws Exception {
@@ -173,15 +173,15 @@ public class TestApproximationSearchEqui
TermQuery q1 = new TermQuery(t1);
TermQuery q2 = new TermQuery(t2);
- BooleanQuery bq1 = new BooleanQuery();
+ BooleanQuery.Builder bq1 = new BooleanQuery.Builder();
bq1.add(new ConstantScoreQuery(q1), Occur.MUST);
bq1.add(new ConstantScoreQuery(q2), Occur.MUST);
- BooleanQuery bq2 = new BooleanQuery();
+ BooleanQuery.Builder bq2 = new BooleanQuery.Builder();
bq2.add(new ConstantScoreQuery(new RandomApproximationQuery(q1, random())), Occur.MUST);
bq2.add(new ConstantScoreQuery(new RandomApproximationQuery(q2, random())), Occur.MUST);
- assertSameScores(bq1, bq2);
+ assertSameScores(bq1.build(), bq2.build());
}
public void testExclusion() throws Exception {
@@ -190,15 +190,15 @@ public class TestApproximationSearchEqui
TermQuery q1 = new TermQuery(t1);
TermQuery q2 = new TermQuery(t2);
- BooleanQuery bq1 = new BooleanQuery();
+ BooleanQuery.Builder bq1 = new BooleanQuery.Builder();
bq1.add(q1, Occur.MUST);
bq1.add(q2, Occur.MUST_NOT);
- BooleanQuery bq2 = new BooleanQuery();
+ BooleanQuery.Builder bq2 = new BooleanQuery.Builder();
bq2.add(new RandomApproximationQuery(q1, random()), Occur.MUST);
bq2.add(new RandomApproximationQuery(q2, random()), Occur.MUST_NOT);
- assertSameScores(bq1, bq2);
+ assertSameScores(bq1.build(), bq2.build());
}
public void testNestedExclusion() throws Exception {
@@ -209,46 +209,46 @@ public class TestApproximationSearchEqui
TermQuery q2 = new TermQuery(t2);
TermQuery q3 = new TermQuery(t3);
- BooleanQuery bq1 = new BooleanQuery();
+ BooleanQuery.Builder bq1 = new BooleanQuery.Builder();
bq1.add(q1, Occur.MUST);
bq1.add(q2, Occur.MUST_NOT);
- BooleanQuery bq2 = new BooleanQuery();
- bq2.add(bq1, Occur.MUST);
+ BooleanQuery.Builder bq2 = new BooleanQuery.Builder();
+ bq2.add(bq1.build(), Occur.MUST);
bq2.add(q3, Occur.MUST);
// Both req and excl have approximations
- BooleanQuery bq3 = new BooleanQuery();
+ BooleanQuery.Builder bq3 = new BooleanQuery.Builder();
bq3.add(new RandomApproximationQuery(q1, random()), Occur.MUST);
bq3.add(new RandomApproximationQuery(q2, random()), Occur.MUST_NOT);
- BooleanQuery bq4 = new BooleanQuery();
- bq4.add(bq3, Occur.MUST);
+ BooleanQuery.Builder bq4 = new BooleanQuery.Builder();
+ bq4.add(bq3.build(), Occur.MUST);
bq4.add(q3, Occur.MUST);
- assertSameScores(bq2, bq4);
+ assertSameScores(bq2.build(), bq4.build());
// Only req has an approximation
- bq3 = new BooleanQuery();
+ bq3 = new BooleanQuery.Builder();
bq3.add(new RandomApproximationQuery(q1, random()), Occur.MUST);
bq3.add(q2, Occur.MUST_NOT);
- bq4 = new BooleanQuery();
- bq4.add(bq3, Occur.MUST);
+ bq4 = new BooleanQuery.Builder();
+ bq4.add(bq3.build(), Occur.MUST);
bq4.add(q3, Occur.MUST);
- assertSameScores(bq2, bq4);
+ assertSameScores(bq2.build(), bq4.build());
// Only excl has an approximation
- bq3 = new BooleanQuery();
+ bq3 = new BooleanQuery.Builder();
bq3.add(q1, Occur.MUST);
bq3.add(new RandomApproximationQuery(q2, random()), Occur.MUST_NOT);
- bq4 = new BooleanQuery();
- bq4.add(bq3, Occur.MUST);
+ bq4 = new BooleanQuery.Builder();
+ bq4.add(bq3.build(), Occur.MUST);
bq4.add(q3, Occur.MUST);
- assertSameScores(bq2, bq4);
+ assertSameScores(bq2.build(), bq4.build());
}
public void testReqOpt() throws Exception {
@@ -259,23 +259,23 @@ public class TestApproximationSearchEqui
TermQuery q2 = new TermQuery(t2);
TermQuery q3 = new TermQuery(t3);
- BooleanQuery bq1 = new BooleanQuery();
+ BooleanQuery.Builder bq1 = new BooleanQuery.Builder();
bq1.add(q1, Occur.MUST);
bq1.add(q2, Occur.SHOULD);
- BooleanQuery bq2 = new BooleanQuery();
- bq2.add(bq1, Occur.MUST);
+ BooleanQuery.Builder bq2 = new BooleanQuery.Builder();
+ bq2.add(bq1.build(), Occur.MUST);
bq2.add(q3, Occur.MUST);
- BooleanQuery bq3 = new BooleanQuery();
+ BooleanQuery.Builder bq3 = new BooleanQuery.Builder();
bq3.add(new RandomApproximationQuery(q1, random()), Occur.MUST);
bq3.add(new RandomApproximationQuery(q2, random()), Occur.SHOULD);
- BooleanQuery bq4 = new BooleanQuery();
- bq4.add(bq3, Occur.MUST);
+ BooleanQuery.Builder bq4 = new BooleanQuery.Builder();
+ bq4.add(bq3.build(), Occur.MUST);
bq4.add(q3, Occur.MUST);
- assertSameScores(bq2, bq4);
+ assertSameScores(bq2.build(), bq4.build());
}
}
Modified: lucene/dev/branches/branch_5x/lucene/core/src/test/org/apache/lucene/search/TestBoolean2.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/branch_5x/lucene/core/src/test/org/apache/lucene/search/TestBoolean2.java?rev=1693190&r1=1693189&r2=1693190&view=diff
==============================================================================
--- lucene/dev/branches/branch_5x/lucene/core/src/test/org/apache/lucene/search/TestBoolean2.java (original)
+++ lucene/dev/branches/branch_5x/lucene/core/src/test/org/apache/lucene/search/TestBoolean2.java Wed Jul 29 07:09:39 2015
@@ -31,7 +31,6 @@ import org.apache.lucene.search.similari
import org.apache.lucene.search.similarities.Similarity;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.MockDirectoryWrapper;
-import org.apache.lucene.util.BytesRef;
import org.apache.lucene.util.LuceneTestCase;
import org.apache.lucene.util.TestUtil;
import org.junit.AfterClass;
@@ -148,93 +147,93 @@ public class TestBoolean2 extends Lucene
@Test
public void testQueries01() throws Exception {
- BooleanQuery query = new BooleanQuery();
+ BooleanQuery.Builder query = new BooleanQuery.Builder();
query.add(new TermQuery(new Term(field, "w3")), BooleanClause.Occur.MUST);
query.add(new TermQuery(new Term(field, "xx")), BooleanClause.Occur.MUST);
int[] expDocNrs = {2,3};
- queriesTest(query, expDocNrs);
+ queriesTest(query.build(), expDocNrs);
}
@Test
public void testQueries02() throws Exception {
- BooleanQuery query = new BooleanQuery();
+ BooleanQuery.Builder query = new BooleanQuery.Builder();
query.add(new TermQuery(new Term(field, "w3")), BooleanClause.Occur.MUST);
query.add(new TermQuery(new Term(field, "xx")), BooleanClause.Occur.SHOULD);
int[] expDocNrs = {2,3,1,0};
- queriesTest(query, expDocNrs);
+ queriesTest(query.build(), expDocNrs);
}
@Test
public void testQueries03() throws Exception {
- BooleanQuery query = new BooleanQuery();
+ BooleanQuery.Builder query = new BooleanQuery.Builder();
query.add(new TermQuery(new Term(field, "w3")), BooleanClause.Occur.SHOULD);
query.add(new TermQuery(new Term(field, "xx")), BooleanClause.Occur.SHOULD);
int[] expDocNrs = {2,3,1,0};
- queriesTest(query, expDocNrs);
+ queriesTest(query.build(), expDocNrs);
}
@Test
public void testQueries04() throws Exception {
- BooleanQuery query = new BooleanQuery();
+ BooleanQuery.Builder query = new BooleanQuery.Builder();
query.add(new TermQuery(new Term(field, "w3")), BooleanClause.Occur.SHOULD);
query.add(new TermQuery(new Term(field, "xx")), BooleanClause.Occur.MUST_NOT);
int[] expDocNrs = {1,0};
- queriesTest(query, expDocNrs);
+ queriesTest(query.build(), expDocNrs);
}
@Test
public void testQueries05() throws Exception {
- BooleanQuery query = new BooleanQuery();
+ BooleanQuery.Builder query = new BooleanQuery.Builder();
query.add(new TermQuery(new Term(field, "w3")), BooleanClause.Occur.MUST);
query.add(new TermQuery(new Term(field, "xx")), BooleanClause.Occur.MUST_NOT);
int[] expDocNrs = {1,0};
- queriesTest(query, expDocNrs);
+ queriesTest(query.build(), expDocNrs);
}
@Test
public void testQueries06() throws Exception {
- BooleanQuery query = new BooleanQuery();
+ BooleanQuery.Builder query = new BooleanQuery.Builder();
query.add(new TermQuery(new Term(field, "w3")), BooleanClause.Occur.MUST);
query.add(new TermQuery(new Term(field, "xx")), BooleanClause.Occur.MUST_NOT);
query.add(new TermQuery(new Term(field, "w5")), BooleanClause.Occur.MUST_NOT);
int[] expDocNrs = {1};
- queriesTest(query, expDocNrs);
+ queriesTest(query.build(), expDocNrs);
}
@Test
public void testQueries07() throws Exception {
- BooleanQuery query = new BooleanQuery();
+ BooleanQuery.Builder query = new BooleanQuery.Builder();
query.add(new TermQuery(new Term(field, "w3")), BooleanClause.Occur.MUST_NOT);
query.add(new TermQuery(new Term(field, "xx")), BooleanClause.Occur.MUST_NOT);
query.add(new TermQuery(new Term(field, "w5")), BooleanClause.Occur.MUST_NOT);
int[] expDocNrs = {};
- queriesTest(query, expDocNrs);
+ queriesTest(query.build(), expDocNrs);
}
@Test
public void testQueries08() throws Exception {
- BooleanQuery query = new BooleanQuery();
+ BooleanQuery.Builder query = new BooleanQuery.Builder();
query.add(new TermQuery(new Term(field, "w3")), BooleanClause.Occur.MUST);
query.add(new TermQuery(new Term(field, "xx")), BooleanClause.Occur.SHOULD);
query.add(new TermQuery(new Term(field, "w5")), BooleanClause.Occur.MUST_NOT);
int[] expDocNrs = {2,3,1};
- queriesTest(query, expDocNrs);
+ queriesTest(query.build(), expDocNrs);
}
@Test
public void testQueries09() throws Exception {
- BooleanQuery query = new BooleanQuery();
+ BooleanQuery.Builder query = new BooleanQuery.Builder();
query.add(new TermQuery(new Term(field, "w3")), BooleanClause.Occur.MUST);
query.add(new TermQuery(new Term(field, "xx")), BooleanClause.Occur.MUST);
query.add(new TermQuery(new Term(field, "w2")), BooleanClause.Occur.MUST);
query.add(new TermQuery(new Term(field, "zz")), BooleanClause.Occur.SHOULD);
int[] expDocNrs = {2, 3};
- queriesTest(query, expDocNrs);
+ queriesTest(query.build(), expDocNrs);
}
@Test
public void testQueries10() throws Exception {
- BooleanQuery query = new BooleanQuery();
+ BooleanQuery.Builder query = new BooleanQuery.Builder();
query.add(new TermQuery(new Term(field, "w3")), BooleanClause.Occur.MUST);
query.add(new TermQuery(new Term(field, "xx")), BooleanClause.Occur.MUST);
query.add(new TermQuery(new Term(field, "w2")), BooleanClause.Occur.MUST);
@@ -249,7 +248,7 @@ public class TestBoolean2 extends Lucene
return overlap / ((float)maxOverlap - 1);
}
});
- queriesTest(query, expDocNrs);
+ queriesTest(query.build(), expDocNrs);
} finally {
searcher.setSimilarity(oldSimilarity);
}
@@ -268,7 +267,7 @@ public class TestBoolean2 extends Lucene
int num = atLeast(20);
for (int i=0; i<num; i++) {
int level = random().nextInt(3);
- q1 = randBoolQuery(new Random(random().nextLong()), random().nextBoolean(), level, field, vals, null);
+ q1 = randBoolQuery(new Random(random().nextLong()), random().nextBoolean(), level, field, vals, null).build();
// Can't sort by relevance since floating point numbers may not quite
// match up.
@@ -297,10 +296,10 @@ public class TestBoolean2 extends Lucene
tot+=hits2.length;
CheckHits.checkEqual(q1, hits1, hits2);
- BooleanQuery q3 = new BooleanQuery();
+ BooleanQuery.Builder q3 = new BooleanQuery.Builder();
q3.add(q1, BooleanClause.Occur.SHOULD);
q3.add(new PrefixQuery(new Term("field2", "b")), BooleanClause.Occur.SHOULD);
- TopDocs hits4 = bigSearcher.search(q3, 1);
+ TopDocs hits4 = bigSearcher.search(q3.build(), 1);
assertEquals(mulFactor*collector.totalHits + NUM_EXTRA_DOCS/2, hits4.totalHits);
}
@@ -317,13 +316,14 @@ public class TestBoolean2 extends Lucene
// used to set properties or change every BooleanQuery
// generated from randBoolQuery.
public static interface Callback {
- public void postCreate(BooleanQuery q);
+ public void postCreate(BooleanQuery.Builder q);
}
// Random rnd is passed in so that the exact same random query may be created
// more than once.
- public static BooleanQuery randBoolQuery(Random rnd, boolean allowMust, int level, String field, String[] vals, Callback cb) {
- BooleanQuery current = new BooleanQuery(rnd.nextInt()<0);
+ public static BooleanQuery.Builder randBoolQuery(Random rnd, boolean allowMust, int level, String field, String[] vals, Callback cb) {
+ BooleanQuery.Builder current = new BooleanQuery.Builder();
+ current.setDisableCoord(rnd.nextBoolean());
for (int i=0; i<rnd.nextInt(vals.length)+1; i++) {
int qType=0; // term query
if (level>0) {
@@ -339,7 +339,7 @@ public class TestBoolean2 extends Lucene
} else if (qType < 7) {
q = new WildcardQuery(new Term(field, "w*"));
} else {
- q = randBoolQuery(rnd, allowMust, level-1, field, vals, cb);
+ q = randBoolQuery(rnd, allowMust, level-1, field, vals, cb).build();
}
int r = rnd.nextInt(10);
Modified: lucene/dev/branches/branch_5x/lucene/core/src/test/org/apache/lucene/search/TestBooleanCoord.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/branch_5x/lucene/core/src/test/org/apache/lucene/search/TestBooleanCoord.java?rev=1693190&r1=1693189&r2=1693190&view=diff
==============================================================================
--- lucene/dev/branches/branch_5x/lucene/core/src/test/org/apache/lucene/search/TestBooleanCoord.java (original)
+++ lucene/dev/branches/branch_5x/lucene/core/src/test/org/apache/lucene/search/TestBooleanCoord.java Wed Jul 29 07:09:39 2015
@@ -130,654 +130,692 @@ public class TestBooleanCoord extends Lu
// disjunctions
public void testDisjunction1TermMatches() throws Exception {
- BooleanQuery bq = new BooleanQuery();
+ BooleanQuery.Builder bq = new BooleanQuery.Builder();
bq.add(term("A"), BooleanClause.Occur.SHOULD);
// LUCENE-4300: coord(1,1) is always treated as 1
- assertScore(1 * 1, bq);
+ assertScore(1 * 1, bq.build());
}
public void testDisjunction2TermMatches() throws Exception {
- BooleanQuery bq = new BooleanQuery();
+ BooleanQuery.Builder bq = new BooleanQuery.Builder();
bq.add(term("A"), BooleanClause.Occur.SHOULD);
bq.add(term("B"), BooleanClause.Occur.SHOULD);
- assertScore(2 * 2/(2f + 1), bq);
+ assertScore(2 * 2/(2f + 1), bq.build());
}
public void testDisjunction1OutOf2() throws Exception {
- BooleanQuery bq = new BooleanQuery();
+ BooleanQuery.Builder bq = new BooleanQuery.Builder();
bq.add(term("A"), BooleanClause.Occur.SHOULD);
bq.add(term("1"), BooleanClause.Occur.SHOULD);
- assertScore(1 * 1/(2f + 1), bq);
+ assertScore(1 * 1/(2f + 1), bq.build());
}
public void testDisjunction1OutOf2Missing() throws Exception {
- BooleanQuery bq = new BooleanQuery();
+ BooleanQuery.Builder bq = new BooleanQuery.Builder();
bq.add(term("A"), BooleanClause.Occur.SHOULD);
bq.add(term("Z"), BooleanClause.Occur.SHOULD);
- assertScore(1 * 1/(2f + 1), bq);
+ assertScore(1 * 1/(2f + 1), bq.build());
}
public void testDisjunction1OutOf3() throws Exception {
- BooleanQuery bq = new BooleanQuery();
+ BooleanQuery.Builder bq = new BooleanQuery.Builder();
bq.add(term("A"), BooleanClause.Occur.SHOULD);
bq.add(term("1"), BooleanClause.Occur.SHOULD);
bq.add(term("2"), BooleanClause.Occur.SHOULD);
- assertScore(1 * 1/(3f + 1), bq);
+ assertScore(1 * 1/(3f + 1), bq.build());
}
public void testDisjunction1OutOf3MissingOne() throws Exception {
- BooleanQuery bq = new BooleanQuery();
+ BooleanQuery.Builder bq = new BooleanQuery.Builder();
bq.add(term("A"), BooleanClause.Occur.SHOULD);
bq.add(term("1"), BooleanClause.Occur.SHOULD);
bq.add(term("Z"), BooleanClause.Occur.SHOULD);
- assertScore(1 * 1/(3f + 1), bq);
+ assertScore(1 * 1/(3f + 1), bq.build());
}
public void testDisjunction1OutOf3MissingTwo() throws Exception {
- BooleanQuery bq = new BooleanQuery();
+ BooleanQuery.Builder bq = new BooleanQuery.Builder();
bq.add(term("A"), BooleanClause.Occur.SHOULD);
bq.add(term("Y"), BooleanClause.Occur.SHOULD);
bq.add(term("Z"), BooleanClause.Occur.SHOULD);
- assertScore(1 * 1/(3f + 1), bq);
+ assertScore(1 * 1/(3f + 1), bq.build());
}
public void testDisjunction2OutOf3() throws Exception {
- BooleanQuery bq = new BooleanQuery();
+ BooleanQuery.Builder bq = new BooleanQuery.Builder();
bq.add(term("A"), BooleanClause.Occur.SHOULD);
bq.add(term("B"), BooleanClause.Occur.SHOULD);
bq.add(term("1"), BooleanClause.Occur.SHOULD);
- assertScore(2 * 2/(3f + 1), bq);
+ assertScore(2 * 2/(3f + 1), bq.build());
}
public void testDisjunction2OutOf3Missing() throws Exception {
- BooleanQuery bq = new BooleanQuery();
+ BooleanQuery.Builder bq = new BooleanQuery.Builder();
bq.add(term("A"), BooleanClause.Occur.SHOULD);
bq.add(term("B"), BooleanClause.Occur.SHOULD);
bq.add(term("Z"), BooleanClause.Occur.SHOULD);
- assertScore(2 * 2/(3f + 1), bq);
+ assertScore(2 * 2/(3f + 1), bq.build());
}
// disjunctions with coord disabled
public void testDisjunction1TermMatchesCoordDisabled() throws Exception {
- BooleanQuery bq = new BooleanQuery(true);
+ BooleanQuery.Builder bq =new BooleanQuery.Builder();
+ bq.setDisableCoord(true);
bq.add(term("A"), BooleanClause.Occur.SHOULD);
- assertScore(1, bq);
+ assertScore(1, bq.build());
}
public void testDisjunction2TermMatchesCoordDisabled() throws Exception {
- BooleanQuery bq = new BooleanQuery(true);
+ BooleanQuery.Builder bq =new BooleanQuery.Builder();
+ bq.setDisableCoord(true);
bq.add(term("A"), BooleanClause.Occur.SHOULD);
bq.add(term("B"), BooleanClause.Occur.SHOULD);
- assertScore(2, bq);
+ assertScore(2, bq.build());
}
public void testDisjunction1OutOf2CoordDisabled() throws Exception {
- BooleanQuery bq = new BooleanQuery(true);
+ BooleanQuery.Builder bq =new BooleanQuery.Builder();
+ bq.setDisableCoord(true);
bq.add(term("A"), BooleanClause.Occur.SHOULD);
bq.add(term("1"), BooleanClause.Occur.SHOULD);
- assertScore(1, bq);
+ assertScore(1, bq.build());
}
public void testDisjunction1OutOf2MissingCoordDisabled() throws Exception {
- BooleanQuery bq = new BooleanQuery(true);
+ BooleanQuery.Builder bq =new BooleanQuery.Builder();
+ bq.setDisableCoord(true);
bq.add(term("A"), BooleanClause.Occur.SHOULD);
bq.add(term("Z"), BooleanClause.Occur.SHOULD);
- assertScore(1, bq);
+ assertScore(1, bq.build());
}
public void testDisjunction1OutOf3CoordDisabled() throws Exception {
- BooleanQuery bq = new BooleanQuery(true);
+ BooleanQuery.Builder bq =new BooleanQuery.Builder();
+ bq.setDisableCoord(true);
bq.add(term("A"), BooleanClause.Occur.SHOULD);
bq.add(term("1"), BooleanClause.Occur.SHOULD);
bq.add(term("2"), BooleanClause.Occur.SHOULD);
- assertScore(1, bq);
+ assertScore(1, bq.build());
}
public void testDisjunction1OutOf3MissingOneCoordDisabled() throws Exception {
- BooleanQuery bq = new BooleanQuery(true);
+ BooleanQuery.Builder bq =new BooleanQuery.Builder();
+ bq.setDisableCoord(true);
bq.add(term("A"), BooleanClause.Occur.SHOULD);
bq.add(term("1"), BooleanClause.Occur.SHOULD);
bq.add(term("Z"), BooleanClause.Occur.SHOULD);
- assertScore(1, bq);
+ assertScore(1, bq.build());
}
public void testDisjunction1OutOf3MissingTwoCoordDisabled() throws Exception {
- BooleanQuery bq = new BooleanQuery(true);
+ BooleanQuery.Builder bq =new BooleanQuery.Builder();
+ bq.setDisableCoord(true);
bq.add(term("A"), BooleanClause.Occur.SHOULD);
bq.add(term("Y"), BooleanClause.Occur.SHOULD);
bq.add(term("Z"), BooleanClause.Occur.SHOULD);
- assertScore(1, bq);
+ assertScore(1, bq.build());
}
public void testDisjunction2OutOf3CoordDisabled() throws Exception {
- BooleanQuery bq = new BooleanQuery(true);
+ BooleanQuery.Builder bq =new BooleanQuery.Builder();
+ bq.setDisableCoord(true);
bq.add(term("A"), BooleanClause.Occur.SHOULD);
bq.add(term("B"), BooleanClause.Occur.SHOULD);
bq.add(term("1"), BooleanClause.Occur.SHOULD);
- assertScore(2, bq);
+ assertScore(2, bq.build());
}
public void testDisjunction2OutOf3MissingCoordDisabled() throws Exception {
- BooleanQuery bq = new BooleanQuery(true);
+ BooleanQuery.Builder bq =new BooleanQuery.Builder();
+ bq.setDisableCoord(true);
bq.add(term("A"), BooleanClause.Occur.SHOULD);
bq.add(term("B"), BooleanClause.Occur.SHOULD);
bq.add(term("Z"), BooleanClause.Occur.SHOULD);
- assertScore(2, bq);
+ assertScore(2, bq.build());
}
// minShouldMatch
public void testMinShouldMatch1TermMatches() throws Exception {
- BooleanQuery bq = new BooleanQuery();
+ BooleanQuery.Builder bq = new BooleanQuery.Builder();
bq.setMinimumNumberShouldMatch(1);
bq.add(term("A"), BooleanClause.Occur.SHOULD);
// LUCENE-4300: coord(1,1) is always treated as 1
- assertScore(1 * 1, bq);
+ assertScore(1 * 1, bq.build());
}
public void testMinShouldMatchn2TermMatches() throws Exception {
- BooleanQuery bq = new BooleanQuery();
+ BooleanQuery.Builder bq = new BooleanQuery.Builder();
bq.setMinimumNumberShouldMatch(1);
bq.add(term("A"), BooleanClause.Occur.SHOULD);
bq.add(term("B"), BooleanClause.Occur.SHOULD);
- assertScore(2 * 2/(2f + 1), bq);
+ assertScore(2 * 2/(2f + 1), bq.build());
}
public void testMinShouldMatch1OutOf2() throws Exception {
- BooleanQuery bq = new BooleanQuery();
+ BooleanQuery.Builder bq = new BooleanQuery.Builder();
bq.setMinimumNumberShouldMatch(1);
bq.add(term("A"), BooleanClause.Occur.SHOULD);
bq.add(term("1"), BooleanClause.Occur.SHOULD);
- assertScore(1 * 1/(2f + 1), bq);
+ assertScore(1 * 1/(2f + 1), bq.build());
}
public void testMinShouldMatch1OutOf2Missing() throws Exception {
- BooleanQuery bq = new BooleanQuery();
+ BooleanQuery.Builder bq = new BooleanQuery.Builder();
bq.setMinimumNumberShouldMatch(1);
bq.add(term("A"), BooleanClause.Occur.SHOULD);
bq.add(term("Z"), BooleanClause.Occur.SHOULD);
- assertScore(1 * 1/(2f + 1), bq);
+ assertScore(1 * 1/(2f + 1), bq.build());
}
public void testMinShouldMatch1OutOf3() throws Exception {
- BooleanQuery bq = new BooleanQuery();
+ BooleanQuery.Builder bq = new BooleanQuery.Builder();
bq.setMinimumNumberShouldMatch(1);
bq.add(term("A"), BooleanClause.Occur.SHOULD);
bq.add(term("1"), BooleanClause.Occur.SHOULD);
bq.add(term("2"), BooleanClause.Occur.SHOULD);
- assertScore(1 * 1/(3f + 1), bq);
+ assertScore(1 * 1/(3f + 1), bq.build());
}
public void testMinShouldMatch1OutOf3MissingOne() throws Exception {
- BooleanQuery bq = new BooleanQuery();
+ BooleanQuery.Builder bq = new BooleanQuery.Builder();
bq.setMinimumNumberShouldMatch(1);
bq.add(term("A"), BooleanClause.Occur.SHOULD);
bq.add(term("1"), BooleanClause.Occur.SHOULD);
bq.add(term("Z"), BooleanClause.Occur.SHOULD);
- assertScore(1 * 1/(3f + 1), bq);
+ assertScore(1 * 1/(3f + 1), bq.build());
}
public void testMinShouldMatch1OutOf3MissingTwo() throws Exception {
- BooleanQuery bq = new BooleanQuery();
+ BooleanQuery.Builder bq = new BooleanQuery.Builder();
bq.setMinimumNumberShouldMatch(1);
bq.add(term("A"), BooleanClause.Occur.SHOULD);
bq.add(term("Y"), BooleanClause.Occur.SHOULD);
bq.add(term("Z"), BooleanClause.Occur.SHOULD);
- assertScore(1 * 1/(3f + 1), bq);
+ assertScore(1 * 1/(3f + 1), bq.build());
}
public void testMinShouldMatch2OutOf3() throws Exception {
- BooleanQuery bq = new BooleanQuery();
+ BooleanQuery.Builder bq = new BooleanQuery.Builder();
bq.setMinimumNumberShouldMatch(2);
bq.add(term("A"), BooleanClause.Occur.SHOULD);
bq.add(term("B"), BooleanClause.Occur.SHOULD);
bq.add(term("1"), BooleanClause.Occur.SHOULD);
- assertScore(2 * 2/(3f + 1), bq);
+ assertScore(2 * 2/(3f + 1), bq.build());
}
public void testMinShouldMatch2OutOf3Missing() throws Exception {
- BooleanQuery bq = new BooleanQuery();
+ BooleanQuery.Builder bq = new BooleanQuery.Builder();
bq.setMinimumNumberShouldMatch(2);
bq.add(term("A"), BooleanClause.Occur.SHOULD);
bq.add(term("B"), BooleanClause.Occur.SHOULD);
bq.add(term("Z"), BooleanClause.Occur.SHOULD);
- assertScore(2 * 2/(3f + 1), bq);
+ assertScore(2 * 2/(3f + 1), bq.build());
}
public void testMinShouldMatch2OutOf4() throws Exception {
- BooleanQuery bq = new BooleanQuery();
+ BooleanQuery.Builder bq = new BooleanQuery.Builder();
bq.setMinimumNumberShouldMatch(2);
bq.add(term("A"), BooleanClause.Occur.SHOULD);
bq.add(term("B"), BooleanClause.Occur.SHOULD);
bq.add(term("1"), BooleanClause.Occur.SHOULD);
bq.add(term("2"), BooleanClause.Occur.SHOULD);
- assertScore(2 * 2/(4f + 1), bq);
+ assertScore(2 * 2/(4f + 1), bq.build());
}
public void testMinShouldMatch2OutOf4Missing() throws Exception {
- BooleanQuery bq = new BooleanQuery();
+ BooleanQuery.Builder bq = new BooleanQuery.Builder();
bq.setMinimumNumberShouldMatch(2);
bq.add(term("A"), BooleanClause.Occur.SHOULD);
bq.add(term("B"), BooleanClause.Occur.SHOULD);
bq.add(term("1"), BooleanClause.Occur.SHOULD);
bq.add(term("Z"), BooleanClause.Occur.SHOULD);
- assertScore(2 * 2/(4f + 1), bq);
+ assertScore(2 * 2/(4f + 1), bq.build());
}
// minShouldMatch with coord disabled
public void testMinShouldMatch1TermMatchesCoordDisabled() throws Exception {
- BooleanQuery bq = new BooleanQuery(true);
+ BooleanQuery.Builder bq =new BooleanQuery.Builder();
+ bq.setDisableCoord(true);
bq.setMinimumNumberShouldMatch(1);
bq.add(term("A"), BooleanClause.Occur.SHOULD);
- assertScore(1, bq);
+ assertScore(1, bq.build());
}
public void testMinShouldMatch2TermMatchesCoordDisabled() throws Exception {
- BooleanQuery bq = new BooleanQuery(true);
+ BooleanQuery.Builder bq =new BooleanQuery.Builder();
+ bq.setDisableCoord(true);
bq.setMinimumNumberShouldMatch(1);
bq.add(term("A"), BooleanClause.Occur.SHOULD);
bq.add(term("B"), BooleanClause.Occur.SHOULD);
- assertScore(2, bq);
+ assertScore(2, bq.build());
}
public void testMinShouldMatch1OutOf2CoordDisabled() throws Exception {
- BooleanQuery bq = new BooleanQuery(true);
+ BooleanQuery.Builder bq =new BooleanQuery.Builder();
+ bq.setDisableCoord(true);
bq.setMinimumNumberShouldMatch(1);
bq.add(term("A"), BooleanClause.Occur.SHOULD);
bq.add(term("1"), BooleanClause.Occur.SHOULD);
- assertScore(1, bq);
+ assertScore(1, bq.build());
}
public void testMinShouldMatch1OutOf2MissingCoordDisabled() throws Exception {
- BooleanQuery bq = new BooleanQuery(true);
+ BooleanQuery.Builder bq =new BooleanQuery.Builder();
+ bq.setDisableCoord(true);
bq.setMinimumNumberShouldMatch(1);
bq.add(term("A"), BooleanClause.Occur.SHOULD);
bq.add(term("Z"), BooleanClause.Occur.SHOULD);
- assertScore(1, bq);
+ assertScore(1, bq.build());
}
public void testMinShouldMatch1OutOf3CoordDisabled() throws Exception {
- BooleanQuery bq = new BooleanQuery(true);
+ BooleanQuery.Builder bq =new BooleanQuery.Builder();
+ bq.setDisableCoord(true);
bq.setMinimumNumberShouldMatch(1);
bq.add(term("A"), BooleanClause.Occur.SHOULD);
bq.add(term("1"), BooleanClause.Occur.SHOULD);
bq.add(term("2"), BooleanClause.Occur.SHOULD);
- assertScore(1, bq);
+ assertScore(1, bq.build());
}
public void testMinShouldMatch1OutOf3MissingOneCoordDisabled() throws Exception {
- BooleanQuery bq = new BooleanQuery(true);
+ BooleanQuery.Builder bq =new BooleanQuery.Builder();
+ bq.setDisableCoord(true);
bq.setMinimumNumberShouldMatch(1);
bq.add(term("A"), BooleanClause.Occur.SHOULD);
bq.add(term("1"), BooleanClause.Occur.SHOULD);
bq.add(term("Z"), BooleanClause.Occur.SHOULD);
- assertScore(1, bq);
+ assertScore(1, bq.build());
}
public void testMinShouldMatch1OutOf3MissingTwoCoordDisabled() throws Exception {
- BooleanQuery bq = new BooleanQuery(true);
+ BooleanQuery.Builder bq =new BooleanQuery.Builder();
+ bq.setDisableCoord(true);
bq.setMinimumNumberShouldMatch(1);
bq.add(term("A"), BooleanClause.Occur.SHOULD);
bq.add(term("Y"), BooleanClause.Occur.SHOULD);
bq.add(term("Z"), BooleanClause.Occur.SHOULD);
- assertScore(1, bq);
+ assertScore(1, bq.build());
}
public void testMinShouldMatch2OutOf3CoordDisabled() throws Exception {
- BooleanQuery bq = new BooleanQuery(true);
+ BooleanQuery.Builder bq =new BooleanQuery.Builder();
+ bq.setDisableCoord(true);
bq.setMinimumNumberShouldMatch(2);
bq.add(term("A"), BooleanClause.Occur.SHOULD);
bq.add(term("B"), BooleanClause.Occur.SHOULD);
bq.add(term("1"), BooleanClause.Occur.SHOULD);
- assertScore(2, bq);
+ assertScore(2, bq.build());
}
public void testMinShouldMatch2OutOf3MissingCoordDisabled() throws Exception {
- BooleanQuery bq = new BooleanQuery(true);
+ BooleanQuery.Builder bq =new BooleanQuery.Builder();
+ bq.setDisableCoord(true);
bq.setMinimumNumberShouldMatch(2);
bq.add(term("A"), BooleanClause.Occur.SHOULD);
bq.add(term("B"), BooleanClause.Occur.SHOULD);
bq.add(term("Z"), BooleanClause.Occur.SHOULD);
- assertScore(2, bq);
+ assertScore(2, bq.build());
}
public void testMinShouldMatch2OutOf4CoordDisabled() throws Exception {
- BooleanQuery bq = new BooleanQuery(true);
+ BooleanQuery.Builder bq =new BooleanQuery.Builder();
+ bq.setDisableCoord(true);
bq.setMinimumNumberShouldMatch(2);
bq.add(term("A"), BooleanClause.Occur.SHOULD);
bq.add(term("B"), BooleanClause.Occur.SHOULD);
bq.add(term("1"), BooleanClause.Occur.SHOULD);
bq.add(term("2"), BooleanClause.Occur.SHOULD);
- assertScore(2, bq);
+ assertScore(2, bq.build());
}
public void testMinShouldMatch2OutOf4MissingCoordDisabled() throws Exception {
- BooleanQuery bq = new BooleanQuery(true);
+ BooleanQuery.Builder bq =new BooleanQuery.Builder();
+ bq.setDisableCoord(true);
bq.setMinimumNumberShouldMatch(2);
bq.add(term("A"), BooleanClause.Occur.SHOULD);
bq.add(term("B"), BooleanClause.Occur.SHOULD);
bq.add(term("1"), BooleanClause.Occur.SHOULD);
bq.add(term("Z"), BooleanClause.Occur.SHOULD);
- assertScore(2, bq);
+ assertScore(2, bq.build());
}
// conjunctions
public void testConjunction1TermMatches() throws Exception {
- BooleanQuery bq = new BooleanQuery();
+ BooleanQuery.Builder bq = new BooleanQuery.Builder();
bq.add(term("A"), BooleanClause.Occur.MUST);
// LUCENE-4300: coord(1,1) is always treated as 1
- assertScore(1 * 1, bq);
+ assertScore(1 * 1, bq.build());
}
public void testConjunction1TermMatches1Prohib() throws Exception {
- BooleanQuery bq = new BooleanQuery();
+ BooleanQuery.Builder bq = new BooleanQuery.Builder();
bq.add(term("A"), BooleanClause.Occur.MUST);
bq.add(term("1"), BooleanClause.Occur.MUST_NOT);
// LUCENE-4300: coord(1,1) is always treated as 1
- assertScore(1 * 1, bq);
+ assertScore(1 * 1, bq.build());
}
public void testConjunction1TermMatches2Prohib() throws Exception {
- BooleanQuery bq = new BooleanQuery();
+ BooleanQuery.Builder bq = new BooleanQuery.Builder();
bq.add(term("A"), BooleanClause.Occur.MUST);
bq.add(term("1"), BooleanClause.Occur.MUST_NOT);
bq.add(term("2"), BooleanClause.Occur.MUST_NOT);
// LUCENE-4300: coord(1,1) is always treated as 1
- assertScore(1 * 1, bq);
+ assertScore(1 * 1, bq.build());
}
public void testConjunction2TermMatches() throws Exception {
- BooleanQuery bq = new BooleanQuery();
+ BooleanQuery.Builder bq = new BooleanQuery.Builder();
bq.add(term("A"), BooleanClause.Occur.MUST);
bq.add(term("B"), BooleanClause.Occur.MUST);
- assertScore(2 * 2/(2f + 1), bq);
+ assertScore(2 * 2/(2f + 1), bq.build());
}
public void testConjunction3TermMatches() throws Exception {
- BooleanQuery bq = new BooleanQuery();
+ BooleanQuery.Builder bq = new BooleanQuery.Builder();
bq.add(term("A"), BooleanClause.Occur.MUST);
bq.add(term("B"), BooleanClause.Occur.MUST);
bq.add(term("C"), BooleanClause.Occur.MUST);
- assertScore(3 * 3/(3f + 1), bq);
+ assertScore(3 * 3/(3f + 1), bq.build());
}
// conjunctions coord disabled
public void testConjunction1TermMatchesCoordDisabled() throws Exception {
- BooleanQuery bq = new BooleanQuery(true);
+ BooleanQuery.Builder bq =new BooleanQuery.Builder();
+ bq.setDisableCoord(true);
bq.add(term("A"), BooleanClause.Occur.MUST);
- assertScore(1, bq);
+ assertScore(1, bq.build());
}
public void testConjunction1TermMatches1ProhibCoordDisabled() throws Exception {
- BooleanQuery bq = new BooleanQuery(true);
+ BooleanQuery.Builder bq =new BooleanQuery.Builder();
+ bq.setDisableCoord(true);
bq.add(term("A"), BooleanClause.Occur.MUST);
bq.add(term("1"), BooleanClause.Occur.MUST_NOT);
- assertScore(1, bq);
+ assertScore(1, bq.build());
}
public void testConjunction1TermMatches2ProhibCoordDisabled() throws Exception {
- BooleanQuery bq = new BooleanQuery(true);
+ BooleanQuery.Builder bq =new BooleanQuery.Builder();
+ bq.setDisableCoord(true);
bq.add(term("A"), BooleanClause.Occur.MUST);
bq.add(term("1"), BooleanClause.Occur.MUST_NOT);
bq.add(term("2"), BooleanClause.Occur.MUST_NOT);
- assertScore(1, bq);
+ assertScore(1, bq.build());
}
public void testConjunction2TermMatchesCoordDisabled() throws Exception {
- BooleanQuery bq = new BooleanQuery(true);
+ BooleanQuery.Builder bq =new BooleanQuery.Builder();
+ bq.setDisableCoord(true);
bq.add(term("A"), BooleanClause.Occur.MUST);
bq.add(term("B"), BooleanClause.Occur.MUST);
- assertScore(2, bq);
+ assertScore(2, bq.build());
}
// optional + mandatory mix
public void testMix2TermMatches() throws Exception {
- BooleanQuery bq = new BooleanQuery();
+ BooleanQuery.Builder bq = new BooleanQuery.Builder();
bq.add(term("A"), BooleanClause.Occur.MUST);
bq.add(term("B"), BooleanClause.Occur.SHOULD);
- assertScore(2 * 2/(2f + 1), bq);
+ assertScore(2 * 2/(2f + 1), bq.build());
}
public void testMixMatch1OutOfTwo() throws Exception {
- BooleanQuery bq = new BooleanQuery();
+ BooleanQuery.Builder bq = new BooleanQuery.Builder();
bq.add(term("A"), BooleanClause.Occur.MUST);
bq.add(term("1"), BooleanClause.Occur.SHOULD);
- assertScore(1 * 1/(2f + 1), bq);
+ assertScore(1 * 1/(2f + 1), bq.build());
}
public void testMixMatch1OutOfTwoMissing() throws Exception {
- BooleanQuery bq = new BooleanQuery();
+ BooleanQuery.Builder bq = new BooleanQuery.Builder();
bq.add(term("A"), BooleanClause.Occur.MUST);
bq.add(term("Z"), BooleanClause.Occur.SHOULD);
- assertScore(1 * 1/(2f + 1), bq);
+ assertScore(1 * 1/(2f + 1), bq.build());
}
public void testMixMatch1OutOfThree() throws Exception {
- BooleanQuery bq = new BooleanQuery();
+ BooleanQuery.Builder bq = new BooleanQuery.Builder();
bq.add(term("A"), BooleanClause.Occur.MUST);
bq.add(term("1"), BooleanClause.Occur.SHOULD);
bq.add(term("2"), BooleanClause.Occur.SHOULD);
- assertScore(1 * 1/(3f + 1), bq);
+ assertScore(1 * 1/(3f + 1), bq.build());
}
public void testMixMatch1OutOfThreeOneMissing() throws Exception {
- BooleanQuery bq = new BooleanQuery();
+ BooleanQuery.Builder bq = new BooleanQuery.Builder();
bq.add(term("A"), BooleanClause.Occur.MUST);
bq.add(term("1"), BooleanClause.Occur.SHOULD);
bq.add(term("Z"), BooleanClause.Occur.SHOULD);
- assertScore(1 * 1/(3f + 1), bq);
+ assertScore(1 * 1/(3f + 1), bq.build());
}
public void testMixMatch2OutOfThree() throws Exception {
- BooleanQuery bq = new BooleanQuery();
+ BooleanQuery.Builder bq = new BooleanQuery.Builder();
bq.add(term("A"), BooleanClause.Occur.MUST);
bq.add(term("B"), BooleanClause.Occur.SHOULD);
bq.add(term("1"), BooleanClause.Occur.SHOULD);
- assertScore(2 * 2/(3f + 1), bq);
+ assertScore(2 * 2/(3f + 1), bq.build());
}
public void testMixMatch2OutOfThreeMissing() throws Exception {
- BooleanQuery bq = new BooleanQuery();
+ BooleanQuery.Builder bq = new BooleanQuery.Builder();
bq.add(term("A"), BooleanClause.Occur.MUST);
bq.add(term("B"), BooleanClause.Occur.SHOULD);
bq.add(term("Z"), BooleanClause.Occur.SHOULD);
- assertScore(2 * 2/(3f + 1), bq);
+ assertScore(2 * 2/(3f + 1), bq.build());
}
public void testMix2TermMatchesCoordDisabled() throws Exception {
- BooleanQuery bq = new BooleanQuery(true);
+ BooleanQuery.Builder bq =new BooleanQuery.Builder();
+ bq.setDisableCoord(true);
bq.add(term("A"), BooleanClause.Occur.MUST);
bq.add(term("B"), BooleanClause.Occur.SHOULD);
- assertScore(2, bq);
+ assertScore(2, bq.build());
}
public void testMixMatch1OutOfTwoCoordDisabled() throws Exception {
- BooleanQuery bq = new BooleanQuery(true);
+ BooleanQuery.Builder bq =new BooleanQuery.Builder();
+ bq.setDisableCoord(true);
bq.add(term("A"), BooleanClause.Occur.MUST);
bq.add(term("1"), BooleanClause.Occur.SHOULD);
- assertScore(1, bq);
+ assertScore(1, bq.build());
}
public void testMixMatch1OutOfTwoMissingCoordDisabled() throws Exception {
- BooleanQuery bq = new BooleanQuery(true);
+ BooleanQuery.Builder bq =new BooleanQuery.Builder();
+ bq.setDisableCoord(true);
bq.add(term("A"), BooleanClause.Occur.MUST);
bq.add(term("Z"), BooleanClause.Occur.SHOULD);
- assertScore(1, bq);
+ assertScore(1, bq.build());
}
public void testMixMatch1OutOfThreeCoordDisabled() throws Exception {
- BooleanQuery bq = new BooleanQuery(true);
+ BooleanQuery.Builder bq =new BooleanQuery.Builder();
+ bq.setDisableCoord(true);
bq.add(term("A"), BooleanClause.Occur.MUST);
bq.add(term("1"), BooleanClause.Occur.SHOULD);
bq.add(term("2"), BooleanClause.Occur.SHOULD);
- assertScore(1, bq);
+ assertScore(1, bq.build());
}
public void testMixMatch1OutOfThreeOneMissingCoordDisabled() throws Exception {
- BooleanQuery bq = new BooleanQuery();
+ BooleanQuery.Builder bq = new BooleanQuery.Builder();
bq.add(term("A"), BooleanClause.Occur.MUST);
bq.add(term("1"), BooleanClause.Occur.SHOULD);
bq.add(term("Z"), BooleanClause.Occur.SHOULD);
- assertScore(1 * 1/(3f + 1), bq);
+ assertScore(1 * 1/(3f + 1), bq.build());
}
public void testMixMatch2OutOfThreeCoordDisabled() throws Exception {
- BooleanQuery bq = new BooleanQuery(true);
+ BooleanQuery.Builder bq =new BooleanQuery.Builder();
+ bq.setDisableCoord(true);
bq.add(term("A"), BooleanClause.Occur.MUST);
bq.add(term("B"), BooleanClause.Occur.SHOULD);
bq.add(term("1"), BooleanClause.Occur.SHOULD);
- assertScore(2, bq);
+ assertScore(2, bq.build());
}
public void testMixMatch2OutOfThreeMissingCoordDisabled() throws Exception {
- BooleanQuery bq = new BooleanQuery(true);
+ BooleanQuery.Builder bq =new BooleanQuery.Builder();
+ bq.setDisableCoord(true);
bq.add(term("A"), BooleanClause.Occur.MUST);
bq.add(term("B"), BooleanClause.Occur.SHOULD);
bq.add(term("Z"), BooleanClause.Occur.SHOULD);
- assertScore(2, bq);
+ assertScore(2, bq.build());
}
// min should match + mandatory mix
public void testMixMinShouldMatch2OutOfThree() throws Exception {
- BooleanQuery bq = new BooleanQuery();
+ BooleanQuery.Builder bq = new BooleanQuery.Builder();
bq.setMinimumNumberShouldMatch(1);
bq.add(term("A"), BooleanClause.Occur.MUST);
bq.add(term("B"), BooleanClause.Occur.SHOULD);
bq.add(term("1"), BooleanClause.Occur.SHOULD);
- assertScore(2 * 2/(3f + 1), bq);
+ assertScore(2 * 2/(3f + 1), bq.build());
}
public void testMixMinShouldMatch2OutOfThreeMissing() throws Exception {
- BooleanQuery bq = new BooleanQuery();
+ BooleanQuery.Builder bq = new BooleanQuery.Builder();
bq.setMinimumNumberShouldMatch(1);
bq.add(term("A"), BooleanClause.Occur.MUST);
bq.add(term("B"), BooleanClause.Occur.SHOULD);
bq.add(term("Z"), BooleanClause.Occur.SHOULD);
- assertScore(2 * 2/(3f + 1), bq);
+ assertScore(2 * 2/(3f + 1), bq.build());
}
public void testMixMinShouldMatch3OutOfFour() throws Exception {
- BooleanQuery bq = new BooleanQuery();
+ BooleanQuery.Builder bq = new BooleanQuery.Builder();
bq.setMinimumNumberShouldMatch(2);
bq.add(term("A"), BooleanClause.Occur.MUST);
bq.add(term("B"), BooleanClause.Occur.SHOULD);
bq.add(term("C"), BooleanClause.Occur.SHOULD);
bq.add(term("1"), BooleanClause.Occur.SHOULD);
- assertScore(3 * 3/(4f + 1), bq);
+ assertScore(3 * 3/(4f + 1), bq.build());
}
public void testMixMinShouldMatch3OutOfFourMissing() throws Exception {
- BooleanQuery bq = new BooleanQuery();
+ BooleanQuery.Builder bq = new BooleanQuery.Builder();
bq.setMinimumNumberShouldMatch(2);
bq.add(term("A"), BooleanClause.Occur.MUST);
bq.add(term("B"), BooleanClause.Occur.SHOULD);
bq.add(term("C"), BooleanClause.Occur.SHOULD);
bq.add(term("Z"), BooleanClause.Occur.SHOULD);
- assertScore(3 * 3/(4f + 1), bq);
+ assertScore(3 * 3/(4f + 1), bq.build());
}
public void testMixMinShouldMatch2OutOfThreeCoordDisabled() throws Exception {
- BooleanQuery bq = new BooleanQuery(true);
+ BooleanQuery.Builder bq =new BooleanQuery.Builder();
+ bq.setDisableCoord(true);
bq.setMinimumNumberShouldMatch(1);
bq.add(term("A"), BooleanClause.Occur.MUST);
bq.add(term("B"), BooleanClause.Occur.SHOULD);
bq.add(term("1"), BooleanClause.Occur.SHOULD);
- assertScore(2, bq);
+ assertScore(2, bq.build());
}
public void testMixMinShouldMatch2OutOfThreeMissingCoordDisabled() throws Exception {
- BooleanQuery bq = new BooleanQuery(true);
+ BooleanQuery.Builder bq =new BooleanQuery.Builder();
+ bq.setDisableCoord(true);
bq.setMinimumNumberShouldMatch(1);
bq.add(term("A"), BooleanClause.Occur.MUST);
bq.add(term("B"), BooleanClause.Occur.SHOULD);
bq.add(term("Z"), BooleanClause.Occur.SHOULD);
- assertScore(2, bq);
+ assertScore(2, bq.build());
}
public void testMixMinShouldMatch3OutOfFourCoordDisabled() throws Exception {
- BooleanQuery bq = new BooleanQuery(true);
+ BooleanQuery.Builder bq =new BooleanQuery.Builder();
+ bq.setDisableCoord(true);
bq.setMinimumNumberShouldMatch(2);
bq.add(term("A"), BooleanClause.Occur.MUST);
bq.add(term("B"), BooleanClause.Occur.SHOULD);
bq.add(term("C"), BooleanClause.Occur.SHOULD);
bq.add(term("1"), BooleanClause.Occur.SHOULD);
- assertScore(3, bq);
+ assertScore(3, bq.build());
}
public void testMixMinShouldMatch3OutOfFourMissingCoordDisabled() throws Exception {
- BooleanQuery bq = new BooleanQuery(true);
+ BooleanQuery.Builder bq =new BooleanQuery.Builder();
+ bq.setDisableCoord(true);
bq.setMinimumNumberShouldMatch(2);
bq.add(term("A"), BooleanClause.Occur.MUST);
bq.add(term("B"), BooleanClause.Occur.SHOULD);
bq.add(term("C"), BooleanClause.Occur.SHOULD);
bq.add(term("Z"), BooleanClause.Occur.SHOULD);
- assertScore(3, bq);
+ assertScore(3, bq.build());
}
// nested cases, make sure conjunctions propagate scoring
public void testConjunctionNested() throws Exception {
- BooleanQuery inner = new BooleanQuery();
+ BooleanQuery.Builder inner = new BooleanQuery.Builder();
inner.add(term("A"), BooleanClause.Occur.MUST);
inner.add(term("B"), BooleanClause.Occur.MUST);
- BooleanQuery outer = new BooleanQuery();
- outer.add(inner, BooleanClause.Occur.MUST);
+ BooleanQuery.Builder outer = new BooleanQuery.Builder();
+ outer.add(inner.build(), BooleanClause.Occur.MUST);
outer.add(term("C"), BooleanClause.Occur.MUST);
float innerScore = (1 + 1) * 2/(2f+1);
float outerScore = (innerScore + 1) * 2/(2f+1);
- assertScore(outerScore, outer);
+ assertScore(outerScore, outer.build());
}
public void testConjunctionNestedOuterCoordDisabled() throws Exception {
- BooleanQuery inner = new BooleanQuery();
+ BooleanQuery.Builder inner = new BooleanQuery.Builder();
inner.add(term("A"), BooleanClause.Occur.MUST);
inner.add(term("B"), BooleanClause.Occur.MUST);
- BooleanQuery outer = new BooleanQuery(true);
- outer.add(inner, BooleanClause.Occur.MUST);
+ BooleanQuery.Builder outer = new BooleanQuery.Builder();
+ outer.setDisableCoord(true);
+ outer.add(inner.build(), BooleanClause.Occur.MUST);
outer.add(term("C"), BooleanClause.Occur.MUST);
float innerScore = (1 + 1) * 2/(2f+1);
float outerScore = (innerScore + 1);
- assertScore(outerScore, outer);
+ assertScore(outerScore, outer.build());
}
public void testConjunctionNestedInnerCoordDisabled() throws Exception {
- BooleanQuery inner = new BooleanQuery(true);
+ BooleanQuery.Builder inner = new BooleanQuery.Builder();
+ inner.setDisableCoord(true);
inner.add(term("A"), BooleanClause.Occur.MUST);
inner.add(term("B"), BooleanClause.Occur.MUST);
- BooleanQuery outer = new BooleanQuery();
- outer.add(inner, BooleanClause.Occur.MUST);
+ BooleanQuery.Builder outer = new BooleanQuery.Builder();
+ outer.add(inner.build(), BooleanClause.Occur.MUST);
outer.add(term("C"), BooleanClause.Occur.MUST);
float innerScore = (1 + 1);
float outerScore = (innerScore + 1) * 2/(2f+1);
- assertScore(outerScore, outer);
+ assertScore(outerScore, outer.build());
}
public void testConjunctionNestedCoordDisabledEverywhere() throws Exception {
- BooleanQuery inner = new BooleanQuery(true);
+ BooleanQuery.Builder inner = new BooleanQuery.Builder();
+ inner.setDisableCoord(true);
inner.add(term("A"), BooleanClause.Occur.MUST);
inner.add(term("B"), BooleanClause.Occur.MUST);
- BooleanQuery outer = new BooleanQuery(true);
- outer.add(inner, BooleanClause.Occur.MUST);
+ BooleanQuery.Builder outer = new BooleanQuery.Builder();
+ outer.setDisableCoord(true);
+ outer.add(inner.build(), BooleanClause.Occur.MUST);
outer.add(term("C"), BooleanClause.Occur.MUST);
float innerScore = (1 + 1);
float outerScore = (innerScore + 1);
- assertScore(outerScore, outer);
+ assertScore(outerScore, outer.build());
}
public void testConjunctionNestedSingle() throws Exception {
- BooleanQuery inner = new BooleanQuery();
+ BooleanQuery.Builder inner = new BooleanQuery.Builder();
inner.add(term("A"), BooleanClause.Occur.MUST);
inner.add(term("B"), BooleanClause.Occur.MUST);
- BooleanQuery outer = new BooleanQuery();
- outer.add(inner, BooleanClause.Occur.MUST);
+ BooleanQuery.Builder outer = new BooleanQuery.Builder();
+ outer.add(inner.build(), BooleanClause.Occur.MUST);
float innerScore = (1 + 1) * 2/(2f+1);
// LUCENE-4300: coord(1,1) is always treated as 1
float outerScore = innerScore * 1;
- assertScore(outerScore, outer);
+ assertScore(outerScore, outer.build());
}
/** asserts score for our single matching good doc */
Modified: lucene/dev/branches/branch_5x/lucene/core/src/test/org/apache/lucene/search/TestBooleanMinShouldMatch.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/branch_5x/lucene/core/src/test/org/apache/lucene/search/TestBooleanMinShouldMatch.java?rev=1693190&r1=1693189&r2=1693190&view=diff
==============================================================================
--- lucene/dev/branches/branch_5x/lucene/core/src/test/org/apache/lucene/search/TestBooleanMinShouldMatch.java (original)
+++ lucene/dev/branches/branch_5x/lucene/core/src/test/org/apache/lucene/search/TestBooleanMinShouldMatch.java Wed Jul 29 07:09:39 2015
@@ -106,18 +106,18 @@ public class TestBooleanMinShouldMatch e
public void testAllOptional() throws Exception {
- BooleanQuery q = new BooleanQuery();
+ BooleanQuery.Builder q = new BooleanQuery.Builder();
for (int i = 1; i <=4; i++) {
q.add(new TermQuery(new Term("data",""+i)), BooleanClause.Occur.SHOULD);//false, false);
}
q.setMinimumNumberShouldMatch(2); // match at least two of 4
- verifyNrHits(q, 2);
+ verifyNrHits(q.build(), 2);
}
public void testOneReqAndSomeOptional() throws Exception {
/* one required, some optional */
- BooleanQuery q = new BooleanQuery();
+ BooleanQuery.Builder q = new BooleanQuery.Builder();
q.add(new TermQuery(new Term("all", "all" )), BooleanClause.Occur.MUST);//true, false);
q.add(new TermQuery(new Term("data", "5" )), BooleanClause.Occur.SHOULD);//false, false);
q.add(new TermQuery(new Term("data", "4" )), BooleanClause.Occur.SHOULD);//false, false);
@@ -125,13 +125,13 @@ public class TestBooleanMinShouldMatch e
q.setMinimumNumberShouldMatch(2); // 2 of 3 optional
- verifyNrHits(q, 5);
+ verifyNrHits(q.build(), 5);
}
public void testSomeReqAndSomeOptional() throws Exception {
/* two required, some optional */
- BooleanQuery q = new BooleanQuery();
+ BooleanQuery.Builder q = new BooleanQuery.Builder();
q.add(new TermQuery(new Term("all", "all" )), BooleanClause.Occur.MUST);//true, false);
q.add(new TermQuery(new Term("data", "6" )), BooleanClause.Occur.MUST);//true, false);
q.add(new TermQuery(new Term("data", "5" )), BooleanClause.Occur.SHOULD);//false, false);
@@ -140,13 +140,13 @@ public class TestBooleanMinShouldMatch e
q.setMinimumNumberShouldMatch(2); // 2 of 3 optional
- verifyNrHits(q, 5);
+ verifyNrHits(q.build(), 5);
}
public void testOneProhibAndSomeOptional() throws Exception {
/* one prohibited, some optional */
- BooleanQuery q = new BooleanQuery();
+ BooleanQuery.Builder q = new BooleanQuery.Builder();
q.add(new TermQuery(new Term("data", "1" )), BooleanClause.Occur.SHOULD);//false, false);
q.add(new TermQuery(new Term("data", "2" )), BooleanClause.Occur.SHOULD);//false, false);
q.add(new TermQuery(new Term("data", "3" )), BooleanClause.Occur.MUST_NOT);//false, true );
@@ -154,13 +154,13 @@ public class TestBooleanMinShouldMatch e
q.setMinimumNumberShouldMatch(2); // 2 of 3 optional
- verifyNrHits(q, 1);
+ verifyNrHits(q.build(), 1);
}
public void testSomeProhibAndSomeOptional() throws Exception {
/* two prohibited, some optional */
- BooleanQuery q = new BooleanQuery();
+ BooleanQuery.Builder q = new BooleanQuery.Builder();
q.add(new TermQuery(new Term("data", "1" )), BooleanClause.Occur.SHOULD);//false, false);
q.add(new TermQuery(new Term("data", "2" )), BooleanClause.Occur.SHOULD);//false, false);
q.add(new TermQuery(new Term("data", "3" )), BooleanClause.Occur.MUST_NOT);//false, true );
@@ -169,13 +169,13 @@ public class TestBooleanMinShouldMatch e
q.setMinimumNumberShouldMatch(2); // 2 of 3 optional
- verifyNrHits(q, 1);
+ verifyNrHits(q.build(), 1);
}
public void testOneReqOneProhibAndSomeOptional() throws Exception {
/* one required, one prohibited, some optional */
- BooleanQuery q = new BooleanQuery();
+ BooleanQuery.Builder q = new BooleanQuery.Builder();
q.add(new TermQuery(new Term("data", "6" )), BooleanClause.Occur.MUST);// true, false);
q.add(new TermQuery(new Term("data", "5" )), BooleanClause.Occur.SHOULD);//false, false);
q.add(new TermQuery(new Term("data", "4" )), BooleanClause.Occur.SHOULD);//false, false);
@@ -185,13 +185,13 @@ public class TestBooleanMinShouldMatch e
q.setMinimumNumberShouldMatch(3); // 3 of 4 optional
- verifyNrHits(q, 1);
+ verifyNrHits(q.build(), 1);
}
public void testSomeReqOneProhibAndSomeOptional() throws Exception {
/* two required, one prohibited, some optional */
- BooleanQuery q = new BooleanQuery();
+ BooleanQuery.Builder q = new BooleanQuery.Builder();
q.add(new TermQuery(new Term("all", "all")), BooleanClause.Occur.MUST);//true, false);
q.add(new TermQuery(new Term("data", "6" )), BooleanClause.Occur.MUST);//true, false);
q.add(new TermQuery(new Term("data", "5" )), BooleanClause.Occur.SHOULD);//false, false);
@@ -202,13 +202,13 @@ public class TestBooleanMinShouldMatch e
q.setMinimumNumberShouldMatch(3); // 3 of 4 optional
- verifyNrHits(q, 1);
+ verifyNrHits(q.build(), 1);
}
public void testOneReqSomeProhibAndSomeOptional() throws Exception {
/* one required, two prohibited, some optional */
- BooleanQuery q = new BooleanQuery();
+ BooleanQuery.Builder q = new BooleanQuery.Builder();
q.add(new TermQuery(new Term("data", "6" )), BooleanClause.Occur.MUST);//true, false);
q.add(new TermQuery(new Term("data", "5" )), BooleanClause.Occur.SHOULD);//false, false);
q.add(new TermQuery(new Term("data", "4" )), BooleanClause.Occur.SHOULD);//false, false);
@@ -219,13 +219,13 @@ public class TestBooleanMinShouldMatch e
q.setMinimumNumberShouldMatch(3); // 3 of 4 optional
- verifyNrHits(q, 1);
+ verifyNrHits(q.build(), 1);
}
public void testSomeReqSomeProhibAndSomeOptional() throws Exception {
/* two required, two prohibited, some optional */
- BooleanQuery q = new BooleanQuery();
+ BooleanQuery.Builder q = new BooleanQuery.Builder();
q.add(new TermQuery(new Term("all", "all")), BooleanClause.Occur.MUST);//true, false);
q.add(new TermQuery(new Term("data", "6" )), BooleanClause.Occur.MUST);//true, false);
q.add(new TermQuery(new Term("data", "5" )), BooleanClause.Occur.SHOULD);//false, false);
@@ -237,13 +237,13 @@ public class TestBooleanMinShouldMatch e
q.setMinimumNumberShouldMatch(3); // 3 of 4 optional
- verifyNrHits(q, 1);
+ verifyNrHits(q.build(), 1);
}
public void testMinHigherThenNumOptional() throws Exception {
/* two required, two prohibited, some optional */
- BooleanQuery q = new BooleanQuery();
+ BooleanQuery.Builder q = new BooleanQuery.Builder();
q.add(new TermQuery(new Term("all", "all")), BooleanClause.Occur.MUST);//true, false);
q.add(new TermQuery(new Term("data", "6" )), BooleanClause.Occur.MUST);//true, false);
q.add(new TermQuery(new Term("data", "5" )), BooleanClause.Occur.SHOULD);//false, false);
@@ -255,13 +255,13 @@ public class TestBooleanMinShouldMatch e
q.setMinimumNumberShouldMatch(90); // 90 of 4 optional ?!?!?!
- verifyNrHits(q, 0);
+ verifyNrHits(q.build(), 0);
}
public void testMinEqualToNumOptional() throws Exception {
/* two required, two optional */
- BooleanQuery q = new BooleanQuery();
+ BooleanQuery.Builder q = new BooleanQuery.Builder();
q.add(new TermQuery(new Term("all", "all" )), BooleanClause.Occur.SHOULD);//false, false);
q.add(new TermQuery(new Term("data", "6" )), BooleanClause.Occur.MUST);//true, false);
q.add(new TermQuery(new Term("data", "3" )), BooleanClause.Occur.MUST);//true, false);
@@ -269,43 +269,43 @@ public class TestBooleanMinShouldMatch e
q.setMinimumNumberShouldMatch(2); // 2 of 2 optional
- verifyNrHits(q, 1);
+ verifyNrHits(q.build(), 1);
}
public void testOneOptionalEqualToMin() throws Exception {
/* two required, one optional */
- BooleanQuery q = new BooleanQuery();
+ BooleanQuery.Builder q = new BooleanQuery.Builder();
q.add(new TermQuery(new Term("all", "all" )), BooleanClause.Occur.MUST);//true, false);
q.add(new TermQuery(new Term("data", "3" )), BooleanClause.Occur.SHOULD);//false, false);
q.add(new TermQuery(new Term("data", "2" )), BooleanClause.Occur.MUST);//true, false);
q.setMinimumNumberShouldMatch(1); // 1 of 1 optional
- verifyNrHits(q, 1);
+ verifyNrHits(q.build(), 1);
}
public void testNoOptionalButMin() throws Exception {
/* two required, no optional */
- BooleanQuery q = new BooleanQuery();
+ BooleanQuery.Builder q = new BooleanQuery.Builder();
q.add(new TermQuery(new Term("all", "all" )), BooleanClause.Occur.MUST);//true, false);
q.add(new TermQuery(new Term("data", "2" )), BooleanClause.Occur.MUST);//true, false);
q.setMinimumNumberShouldMatch(1); // 1 of 0 optional
- verifyNrHits(q, 0);
+ verifyNrHits(q.build(), 0);
}
public void testNoOptionalButMin2() throws Exception {
/* one required, no optional */
- BooleanQuery q = new BooleanQuery();
+ BooleanQuery.Builder q = new BooleanQuery.Builder();
q.add(new TermQuery(new Term("all", "all" )), BooleanClause.Occur.MUST);//true, false);
q.setMinimumNumberShouldMatch(1); // 1 of 0 optional
- verifyNrHits(q, 0);
+ verifyNrHits(q.build(), 0);
}
public void testRandomQueries() throws Exception {
@@ -316,11 +316,10 @@ public class TestBooleanMinShouldMatch e
// callback object to set a random setMinimumNumberShouldMatch
TestBoolean2.Callback minNrCB = new TestBoolean2.Callback() {
@Override
- public void postCreate(BooleanQuery q) {
- BooleanClause[] c =q.getClauses();
+ public void postCreate(BooleanQuery.Builder q) {
int opt=0;
- for (int i=0; i<c.length;i++) {
- if (c[i].getOccur() == BooleanClause.Occur.SHOULD) opt++;
+ for (BooleanClause clause : q.build().clauses()) {
+ if (clause.getOccur() == BooleanClause.Occur.SHOULD) opt++;
}
q.setMinimumNumberShouldMatch(random().nextInt(opt+2));
if (random().nextBoolean()) {
@@ -338,9 +337,9 @@ public class TestBooleanMinShouldMatch e
for (int i=0; i<num; i++) {
int lev = random().nextInt(maxLev);
final long seed = random().nextLong();
- BooleanQuery q1 = TestBoolean2.randBoolQuery(new Random(seed), true, lev, field, vals, null);
+ BooleanQuery.Builder q1 = TestBoolean2.randBoolQuery(new Random(seed), true, lev, field, vals, null);
// BooleanQuery q2 = TestBoolean2.randBoolQuery(new Random(seed), lev, field, vals, minNrCB);
- BooleanQuery q2 = TestBoolean2.randBoolQuery(new Random(seed), true, lev, field, vals, null);
+ BooleanQuery.Builder q2 = TestBoolean2.randBoolQuery(new Random(seed), true, lev, field, vals, null);
// only set minimumNumberShouldMatch on the top level query since setting
// at a lower level can change the score.
minNrCB.postCreate(q2);
@@ -348,13 +347,13 @@ public class TestBooleanMinShouldMatch e
// Can't use Hits because normalized scores will mess things
// up. The non-sorting version of search() that returns TopDocs
// will not normalize scores.
- TopDocs top1 = s.search(q1,100);
- TopDocs top2 = s.search(q2,100);
+ TopDocs top1 = s.search(q1.build(),100);
+ TopDocs top2 = s.search(q2.build(),100);
if (i < 100) {
- QueryUtils.check(random(), q1,s);
- QueryUtils.check(random(), q2,s);
+ QueryUtils.check(random(), q1.build(),s);
+ QueryUtils.check(random(), q2.build(),s);
}
- assertSubsetOfSameScores(q2, top1, top2);
+ assertSubsetOfSameScores(q2.build(), top1, top2);
}
// System.out.println("Total hits:"+tot);
}
@@ -404,14 +403,14 @@ public class TestBooleanMinShouldMatch e
return overlap / ((float)maxOverlap + 1);
}
});
- BooleanQuery q1 = new BooleanQuery();
+ BooleanQuery.Builder q1 = new BooleanQuery.Builder();
q1.add(new TermQuery(new Term("data", "1")), BooleanClause.Occur.SHOULD);
- BooleanQuery q2 = new BooleanQuery();
+ BooleanQuery.Builder q2 = new BooleanQuery.Builder();
q2.add(new TermQuery(new Term("data", "1")), BooleanClause.Occur.SHOULD);
q2.setMinimumNumberShouldMatch(1);
- TopDocs top1 = s.search(q1,100);
- TopDocs top2 = s.search(q2,100);
- assertSubsetOfSameScores(q2, top1, top2);
+ TopDocs top1 = s.search(q1.build(),100);
+ TopDocs top2 = s.search(q2.build(),100);
+ assertSubsetOfSameScores(q2.build(), top1, top2);
} finally {
s.setSimilarity(oldSimilarity);
}
@@ -426,14 +425,14 @@ public class TestBooleanMinShouldMatch e
return overlap / ((float)maxOverlap + 1);
}
});
- BooleanQuery q1 = new BooleanQuery();
+ BooleanQuery.Builder q1 = new BooleanQuery.Builder();
q1.add(new TermQuery(new Term("data", "1")), BooleanClause.Occur.SHOULD);
- BooleanQuery q2 = new BooleanQuery();
+ BooleanQuery.Builder q2 = new BooleanQuery.Builder();
q2.add(new TermQuery(new Term("data", "1")), BooleanClause.Occur.SHOULD);
q2.add(new TermQuery(new Term("data", "Z")), BooleanClause.Occur.MUST_NOT);
- TopDocs top1 = s.search(q1,100);
- TopDocs top2 = s.search(q2,100);
- assertSubsetOfSameScores(q2, top1, top2);
+ TopDocs top1 = s.search(q1.build(),100);
+ TopDocs top2 = s.search(q2.build(),100);
+ assertSubsetOfSameScores(q2.build(), top1, top2);
} finally {
s.setSimilarity(oldSimilarity);
}
Modified: lucene/dev/branches/branch_5x/lucene/core/src/test/org/apache/lucene/search/TestBooleanOr.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/branch_5x/lucene/core/src/test/org/apache/lucene/search/TestBooleanOr.java?rev=1693190&r1=1693189&r2=1693190&view=diff
==============================================================================
--- lucene/dev/branches/branch_5x/lucene/core/src/test/org/apache/lucene/search/TestBooleanOr.java (original)
+++ lucene/dev/branches/branch_5x/lucene/core/src/test/org/apache/lucene/search/TestBooleanOr.java Wed Jul 29 07:09:39 2015
@@ -27,7 +27,6 @@ import com.carrotsearch.randomizedtestin
import org.apache.lucene.analysis.MockAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.TextField;
-import org.apache.lucene.index.PostingsEnum;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.RandomIndexWriter;
import org.apache.lucene.index.Term;
@@ -71,12 +70,12 @@ public class TestBooleanOr extends Lucen
* it works.
*/
public void testFlat() throws IOException {
- BooleanQuery q = new BooleanQuery();
+ BooleanQuery.Builder q = new BooleanQuery.Builder();
q.add(new BooleanClause(t1, BooleanClause.Occur.SHOULD));
q.add(new BooleanClause(t2, BooleanClause.Occur.SHOULD));
q.add(new BooleanClause(c1, BooleanClause.Occur.SHOULD));
q.add(new BooleanClause(c2, BooleanClause.Occur.SHOULD));
- assertEquals(1, search(q));
+ assertEquals(1, search(q.build()));
}
/**
@@ -84,16 +83,16 @@ public class TestBooleanOr extends Lucen
* it works.
*/
public void testParenthesisMust() throws IOException {
- BooleanQuery q3 = new BooleanQuery();
+ BooleanQuery.Builder q3 = new BooleanQuery.Builder();
q3.add(new BooleanClause(t1, BooleanClause.Occur.SHOULD));
q3.add(new BooleanClause(t2, BooleanClause.Occur.SHOULD));
- BooleanQuery q4 = new BooleanQuery();
+ BooleanQuery.Builder q4 = new BooleanQuery.Builder();
q4.add(new BooleanClause(c1, BooleanClause.Occur.MUST));
q4.add(new BooleanClause(c2, BooleanClause.Occur.MUST));
- BooleanQuery q2 = new BooleanQuery();
- q2.add(q3, BooleanClause.Occur.SHOULD);
- q2.add(q4, BooleanClause.Occur.SHOULD);
- assertEquals(1, search(q2));
+ BooleanQuery.Builder q2 = new BooleanQuery.Builder();
+ q2.add(q3.build(), BooleanClause.Occur.SHOULD);
+ q2.add(q4.build(), BooleanClause.Occur.SHOULD);
+ assertEquals(1, search(q2.build()));
}
/**
@@ -101,16 +100,16 @@ public class TestBooleanOr extends Lucen
* not working. results NO HIT.
*/
public void testParenthesisMust2() throws IOException {
- BooleanQuery q3 = new BooleanQuery();
+ BooleanQuery.Builder q3 = new BooleanQuery.Builder();
q3.add(new BooleanClause(t1, BooleanClause.Occur.SHOULD));
q3.add(new BooleanClause(t2, BooleanClause.Occur.SHOULD));
- BooleanQuery q4 = new BooleanQuery();
+ BooleanQuery.Builder q4 = new BooleanQuery.Builder();
q4.add(new BooleanClause(c1, BooleanClause.Occur.SHOULD));
q4.add(new BooleanClause(c2, BooleanClause.Occur.SHOULD));
- BooleanQuery q2 = new BooleanQuery();
- q2.add(q3, BooleanClause.Occur.SHOULD);
- q2.add(q4, BooleanClause.Occur.MUST);
- assertEquals(1, search(q2));
+ BooleanQuery.Builder q2 = new BooleanQuery.Builder();
+ q2.add(q3.build(), BooleanClause.Occur.SHOULD);
+ q2.add(q4.build(), BooleanClause.Occur.MUST);
+ assertEquals(1, search(q2.build()));
}
/**
@@ -118,16 +117,16 @@ public class TestBooleanOr extends Lucen
* not working. results NO HIT.
*/
public void testParenthesisShould() throws IOException {
- BooleanQuery q3 = new BooleanQuery();
+ BooleanQuery.Builder q3 = new BooleanQuery.Builder();
q3.add(new BooleanClause(t1, BooleanClause.Occur.SHOULD));
q3.add(new BooleanClause(t2, BooleanClause.Occur.SHOULD));
- BooleanQuery q4 = new BooleanQuery();
+ BooleanQuery.Builder q4 = new BooleanQuery.Builder();
q4.add(new BooleanClause(c1, BooleanClause.Occur.SHOULD));
q4.add(new BooleanClause(c2, BooleanClause.Occur.SHOULD));
- BooleanQuery q2 = new BooleanQuery();
- q2.add(q3, BooleanClause.Occur.SHOULD);
- q2.add(q4, BooleanClause.Occur.SHOULD);
- assertEquals(1, search(q2));
+ BooleanQuery.Builder q2 = new BooleanQuery.Builder();
+ q2.add(q3.build(), BooleanClause.Occur.SHOULD);
+ q2.add(q4.build(), BooleanClause.Occur.SHOULD);
+ assertEquals(1, search(q2.build()));
}
@Override
@@ -185,11 +184,11 @@ public class TestBooleanOr extends Lucen
riw.close();
IndexSearcher s = newSearcher(r);
- BooleanQuery bq = new BooleanQuery();
+ BooleanQuery.Builder bq = new BooleanQuery.Builder();
bq.add(new TermQuery(new Term("field", "a")), BooleanClause.Occur.SHOULD);
bq.add(new TermQuery(new Term("field", "a")), BooleanClause.Occur.SHOULD);
- Weight w = s.createNormalizedWeight(bq, true);
+ Weight w = s.createNormalizedWeight(bq.build(), true);
assertEquals(1, s.getIndexReader().leaves().size());
BulkScorer scorer = w.bulkScorer(s.getIndexReader().leaves().get(0));