You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@lucene.apache.org by ch...@apache.org on 2011/07/06 02:08:08 UTC
svn commit: r1143231 [2/2] - in
/lucene/dev/trunk/lucene/src/test/org/apache/lucene: ./ index/values/
queryParser/ search/ search/spans/
Modified: lucene/dev/trunk/lucene/src/test/org/apache/lucene/search/TestSimpleExplanations.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/src/test/org/apache/lucene/search/TestSimpleExplanations.java?rev=1143231&r1=1143230&r2=1143231&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/src/test/org/apache/lucene/search/TestSimpleExplanations.java (original)
+++ lucene/dev/trunk/lucene/src/test/org/apache/lucene/search/TestSimpleExplanations.java Wed Jul 6 00:08:07 2011
@@ -17,6 +17,8 @@ package org.apache.lucene.search;
* limitations under the License.
*/
+import org.apache.lucene.index.Term;
+
/**
* TestExplanations subclass focusing on basic query types
*/
@@ -30,10 +32,12 @@ public class TestSimpleExplanations exte
/* simple term tests */
public void testT1() throws Exception {
- qtest("w1", new int[] { 0,1,2,3 });
+ qtest(new TermQuery(new Term(FIELD, "w1")), new int[] { 0,1,2,3 });
}
public void testT2() throws Exception {
- qtest("w1^1000", new int[] { 0,1,2,3 });
+ TermQuery termQuery = new TermQuery(new Term(FIELD, "w1"));
+ termQuery.setBoost(100);
+ qtest(termQuery, new int[] { 0,1,2,3 });
}
/* MatchAllDocs */
@@ -50,51 +54,78 @@ public class TestSimpleExplanations exte
/* some simple phrase tests */
public void testP1() throws Exception {
- qtest("\"w1 w2\"", new int[] { 0 });
+ PhraseQuery phraseQuery = new PhraseQuery();
+ phraseQuery.add(new Term(FIELD, "w1"));
+ phraseQuery.add(new Term(FIELD, "w2"));
+ qtest(phraseQuery, new int[] { 0 });
}
public void testP2() throws Exception {
- qtest("\"w1 w3\"", new int[] { 1,3 });
+ PhraseQuery phraseQuery = new PhraseQuery();
+ phraseQuery.add(new Term(FIELD, "w1"));
+ phraseQuery.add(new Term(FIELD, "w3"));
+ qtest(phraseQuery, new int[] { 1,3 });
}
public void testP3() throws Exception {
- qtest("\"w1 w2\"~1", new int[] { 0,1,2 });
+ PhraseQuery phraseQuery = new PhraseQuery();
+ phraseQuery.setSlop(1);
+ phraseQuery.add(new Term(FIELD, "w1"));
+ phraseQuery.add(new Term(FIELD, "w2"));
+ qtest(phraseQuery, new int[] { 0,1,2 });
}
public void testP4() throws Exception {
- qtest("\"w2 w3\"~1", new int[] { 0,1,2,3 });
+ PhraseQuery phraseQuery = new PhraseQuery();
+ phraseQuery.setSlop(1);
+ phraseQuery.add(new Term(FIELD, "w2"));
+ phraseQuery.add(new Term(FIELD, "w3"));
+ qtest(phraseQuery, new int[] { 0,1,2,3 });
}
public void testP5() throws Exception {
- qtest("\"w3 w2\"~1", new int[] { 1,3 });
+ PhraseQuery phraseQuery = new PhraseQuery();
+ phraseQuery.setSlop(1);
+ phraseQuery.add(new Term(FIELD, "w3"));
+ phraseQuery.add(new Term(FIELD, "w2"));
+ qtest(phraseQuery, new int[] { 1,3 });
}
public void testP6() throws Exception {
- qtest("\"w3 w2\"~2", new int[] { 0,1,3 });
+ PhraseQuery phraseQuery = new PhraseQuery();
+ phraseQuery.setSlop(2);
+ phraseQuery.add(new Term(FIELD, "w3"));
+ phraseQuery.add(new Term(FIELD, "w2"));
+ qtest(phraseQuery, new int[] { 0,1,3 });
}
public void testP7() throws Exception {
- qtest("\"w3 w2\"~3", new int[] { 0,1,2,3 });
+ PhraseQuery phraseQuery = new PhraseQuery();
+ phraseQuery.setSlop(3);
+ phraseQuery.add(new Term(FIELD, "w3"));
+ phraseQuery.add(new Term(FIELD, "w2"));
+ qtest(phraseQuery, new int[] { 0,1,2,3 });
}
/* some simple filtered query tests */
public void testFQ1() throws Exception {
- qtest(new FilteredQuery(qp.parse("w1"),
+ qtest(new FilteredQuery(new TermQuery(new Term(FIELD, "w1")),
new ItemizedFilter(new int[] {0,1,2,3})),
new int[] {0,1,2,3});
}
public void testFQ2() throws Exception {
- qtest(new FilteredQuery(qp.parse("w1"),
+ qtest(new FilteredQuery(new TermQuery(new Term(FIELD, "w1")),
new ItemizedFilter(new int[] {0,2,3})),
new int[] {0,2,3});
}
public void testFQ3() throws Exception {
- qtest(new FilteredQuery(qp.parse("xx"),
+ qtest(new FilteredQuery(new TermQuery(new Term(FIELD, "xx")),
new ItemizedFilter(new int[] {1,3})),
new int[] {3});
}
public void testFQ4() throws Exception {
- qtest(new FilteredQuery(qp.parse("xx^1000"),
- new ItemizedFilter(new int[] {1,3})),
+ TermQuery termQuery = new TermQuery(new Term(FIELD, "xx"));
+ termQuery.setBoost(1000);
+ qtest(new FilteredQuery(termQuery, new ItemizedFilter(new int[] {1,3})),
new int[] {3});
}
public void testFQ6() throws Exception {
- Query q = new FilteredQuery(qp.parse("xx"),
+ Query q = new FilteredQuery(new TermQuery(new Term(FIELD, "xx")),
new ItemizedFilter(new int[] {1,3}));
q.setBoost(1000);
qtest(q, new int[] {3});
@@ -120,56 +151,93 @@ public class TestSimpleExplanations exte
public void testDMQ1() throws Exception {
DisjunctionMaxQuery q = new DisjunctionMaxQuery(0.0f);
- q.add(qp.parse("w1"));
- q.add(qp.parse("w5"));
+ q.add(new TermQuery(new Term(FIELD, "w1")));
+ q.add(new TermQuery(new Term(FIELD, "w5")));
qtest(q, new int[] { 0,1,2,3 });
}
public void testDMQ2() throws Exception {
DisjunctionMaxQuery q = new DisjunctionMaxQuery(0.5f);
- q.add(qp.parse("w1"));
- q.add(qp.parse("w5"));
+ q.add(new TermQuery(new Term(FIELD, "w1")));
+ q.add(new TermQuery(new Term(FIELD, "w5")));
qtest(q, new int[] { 0,1,2,3 });
}
public void testDMQ3() throws Exception {
DisjunctionMaxQuery q = new DisjunctionMaxQuery(0.5f);
- q.add(qp.parse("QQ"));
- q.add(qp.parse("w5"));
+ q.add(new TermQuery(new Term(FIELD, "QQ")));
+ q.add(new TermQuery(new Term(FIELD, "w5")));
qtest(q, new int[] { 0 });
}
public void testDMQ4() throws Exception {
DisjunctionMaxQuery q = new DisjunctionMaxQuery(0.5f);
- q.add(qp.parse("QQ"));
- q.add(qp.parse("xx"));
+ q.add(new TermQuery(new Term(FIELD, "QQ")));
+ q.add(new TermQuery(new Term(FIELD, "xx")));
qtest(q, new int[] { 2,3 });
}
public void testDMQ5() throws Exception {
DisjunctionMaxQuery q = new DisjunctionMaxQuery(0.5f);
- q.add(qp.parse("yy -QQ"));
- q.add(qp.parse("xx"));
+
+ BooleanQuery booleanQuery = new BooleanQuery();
+ booleanQuery.add(new TermQuery(new Term(FIELD, "yy")), BooleanClause.Occur.SHOULD);
+ booleanQuery.add(new TermQuery(new Term(FIELD, "QQ")), BooleanClause.Occur.MUST_NOT);
+
+ q.add(booleanQuery);
+ q.add(new TermQuery(new Term(FIELD, "xx")));
qtest(q, new int[] { 2,3 });
}
public void testDMQ6() throws Exception {
DisjunctionMaxQuery q = new DisjunctionMaxQuery(0.5f);
- q.add(qp.parse("-yy w3"));
- q.add(qp.parse("xx"));
+
+ BooleanQuery booleanQuery = new BooleanQuery();
+ booleanQuery.add(new TermQuery(new Term(FIELD, "yy")), BooleanClause.Occur.MUST_NOT);
+ booleanQuery.add(new TermQuery(new Term(FIELD, "w3")), BooleanClause.Occur.SHOULD);
+
+ q.add(booleanQuery);
+ q.add(new TermQuery(new Term(FIELD, "xx")));
qtest(q, new int[] { 0,1,2,3 });
}
public void testDMQ7() throws Exception {
DisjunctionMaxQuery q = new DisjunctionMaxQuery(0.5f);
- q.add(qp.parse("-yy w3"));
- q.add(qp.parse("w2"));
+
+ BooleanQuery booleanQuery = new BooleanQuery();
+ booleanQuery.add(new TermQuery(new Term(FIELD, "yy")), BooleanClause.Occur.MUST_NOT);
+ booleanQuery.add(new TermQuery(new Term(FIELD, "w3")), BooleanClause.Occur.SHOULD);
+
+ q.add(booleanQuery);
+ q.add(new TermQuery(new Term(FIELD, "w2")));
qtest(q, new int[] { 0,1,2,3 });
}
public void testDMQ8() throws Exception {
DisjunctionMaxQuery q = new DisjunctionMaxQuery(0.5f);
- q.add(qp.parse("yy w5^100"));
- q.add(qp.parse("xx^100000"));
+
+ BooleanQuery booleanQuery = new BooleanQuery();
+ booleanQuery.add(new TermQuery(new Term(FIELD, "yy")), BooleanClause.Occur.SHOULD);
+
+ TermQuery boostedQuery = new TermQuery(new Term(FIELD, "w5"));
+ boostedQuery.setBoost(100);
+ booleanQuery.add(boostedQuery, BooleanClause.Occur.SHOULD);
+ q.add(booleanQuery);
+
+ TermQuery xxBoostedQuery = new TermQuery(new Term(FIELD, "xx"));
+ xxBoostedQuery.setBoost(100000);
+ q.add(xxBoostedQuery);
+
qtest(q, new int[] { 0,2,3 });
}
public void testDMQ9() throws Exception {
DisjunctionMaxQuery q = new DisjunctionMaxQuery(0.5f);
- q.add(qp.parse("yy w5^100"));
- q.add(qp.parse("xx^0"));
+
+ BooleanQuery booleanQuery = new BooleanQuery();
+ booleanQuery.add(new TermQuery(new Term(FIELD, "yy")), BooleanClause.Occur.SHOULD);
+
+ TermQuery boostedQuery = new TermQuery(new Term(FIELD, "w5"));
+ boostedQuery.setBoost(100);
+ booleanQuery.add(boostedQuery, BooleanClause.Occur.SHOULD);
+ q.add(booleanQuery);
+
+ TermQuery xxBoostedQuery = new TermQuery(new Term(FIELD, "xx"));
+ xxBoostedQuery.setBoost(0);
+ q.add(xxBoostedQuery);
+
qtest(q, new int[] { 0,2,3 });
}
@@ -217,74 +285,199 @@ public class TestSimpleExplanations exte
/* some simple tests of boolean queries containing term queries */
public void testBQ1() throws Exception {
- qtest("+w1 +w2", new int[] { 0,1,2,3 });
+ BooleanQuery query = new BooleanQuery();
+ query.add(new TermQuery(new Term(FIELD, "w1")), BooleanClause.Occur.MUST);
+ query.add(new TermQuery(new Term(FIELD, "w2")), BooleanClause.Occur.MUST);
+ qtest(query, new int[] { 0,1,2,3 });
}
public void testBQ2() throws Exception {
- qtest("+yy +w3", new int[] { 2,3 });
+ BooleanQuery query = new BooleanQuery();
+ query.add(new TermQuery(new Term(FIELD, "yy")), BooleanClause.Occur.MUST);
+ query.add(new TermQuery(new Term(FIELD, "w3")), BooleanClause.Occur.MUST);
+ qtest(query, new int[] { 2,3 });
}
public void testBQ3() throws Exception {
- qtest("yy +w3", new int[] { 0,1,2,3 });
+ BooleanQuery query = new BooleanQuery();
+ query.add(new TermQuery(new Term(FIELD, "yy")), BooleanClause.Occur.SHOULD);
+ query.add(new TermQuery(new Term(FIELD, "w3")), BooleanClause.Occur.MUST);
+ qtest(query, new int[] { 0,1,2,3 });
}
public void testBQ4() throws Exception {
- qtest("w1 (-xx w2)", new int[] { 0,1,2,3 });
+ BooleanQuery outerQuery = new BooleanQuery();
+ outerQuery.add(new TermQuery(new Term(FIELD, "w1")), BooleanClause.Occur.SHOULD);
+
+ BooleanQuery innerQuery = new BooleanQuery();
+ innerQuery.add(new TermQuery(new Term(FIELD, "xx")), BooleanClause.Occur.MUST_NOT);
+ innerQuery.add(new TermQuery(new Term(FIELD, "w2")), BooleanClause.Occur.SHOULD);
+ outerQuery.add(innerQuery, BooleanClause.Occur.SHOULD);
+
+ qtest(outerQuery, new int[] { 0,1,2,3 });
}
public void testBQ5() throws Exception {
- qtest("w1 (+qq w2)", new int[] { 0,1,2,3 });
+ BooleanQuery outerQuery = new BooleanQuery();
+ outerQuery.add(new TermQuery(new Term(FIELD, "w1")), BooleanClause.Occur.SHOULD);
+
+ BooleanQuery innerQuery = new BooleanQuery();
+ innerQuery.add(new TermQuery(new Term(FIELD, "qq")), BooleanClause.Occur.MUST);
+ innerQuery.add(new TermQuery(new Term(FIELD, "w2")), BooleanClause.Occur.SHOULD);
+ outerQuery.add(innerQuery, BooleanClause.Occur.SHOULD);
+
+ qtest(outerQuery, new int[] { 0,1,2,3 });
}
public void testBQ6() throws Exception {
- qtest("w1 -(-qq w5)", new int[] { 1,2,3 });
+ BooleanQuery outerQuery = new BooleanQuery();
+ outerQuery.add(new TermQuery(new Term(FIELD, "w1")), BooleanClause.Occur.SHOULD);
+
+ BooleanQuery innerQuery = new BooleanQuery();
+ innerQuery.add(new TermQuery(new Term(FIELD, "qq")), BooleanClause.Occur.MUST_NOT);
+ innerQuery.add(new TermQuery(new Term(FIELD, "w5")), BooleanClause.Occur.SHOULD);
+ outerQuery.add(innerQuery, BooleanClause.Occur.MUST_NOT);
+
+ qtest(outerQuery, new int[] { 1,2,3 });
}
public void testBQ7() throws Exception {
- qtest("+w1 +(qq (xx -w2) (+w3 +w4))", new int[] { 0 });
+ BooleanQuery outerQuery = new BooleanQuery();
+ outerQuery.add(new TermQuery(new Term(FIELD, "w1")), BooleanClause.Occur.MUST);
+
+ BooleanQuery innerQuery = new BooleanQuery();
+ innerQuery.add(new TermQuery(new Term(FIELD, "qq")), BooleanClause.Occur.SHOULD);
+
+ BooleanQuery childLeft = new BooleanQuery();
+ childLeft.add(new TermQuery(new Term(FIELD, "xx")), BooleanClause.Occur.SHOULD);
+ childLeft.add(new TermQuery(new Term(FIELD, "w2")), BooleanClause.Occur.MUST_NOT);
+ innerQuery.add(childLeft, BooleanClause.Occur.SHOULD);
+
+ BooleanQuery childRight = new BooleanQuery();
+ childRight.add(new TermQuery(new Term(FIELD, "w3")), BooleanClause.Occur.MUST);
+ childRight.add(new TermQuery(new Term(FIELD, "w4")), BooleanClause.Occur.MUST);
+ innerQuery.add(childRight, BooleanClause.Occur.SHOULD);
+
+ outerQuery.add(innerQuery, BooleanClause.Occur.MUST);
+
+ qtest(outerQuery, new int[] { 0 });
}
public void testBQ8() throws Exception {
- qtest("+w1 (qq (xx -w2) (+w3 +w4))", new int[] { 0,1,2,3 });
+ BooleanQuery outerQuery = new BooleanQuery();
+ outerQuery.add(new TermQuery(new Term(FIELD, "w1")), BooleanClause.Occur.MUST);
+
+ BooleanQuery innerQuery = new BooleanQuery();
+ innerQuery.add(new TermQuery(new Term(FIELD, "qq")), BooleanClause.Occur.SHOULD);
+
+ BooleanQuery childLeft = new BooleanQuery();
+ childLeft.add(new TermQuery(new Term(FIELD, "xx")), BooleanClause.Occur.SHOULD);
+ childLeft.add(new TermQuery(new Term(FIELD, "w2")), BooleanClause.Occur.MUST_NOT);
+ innerQuery.add(childLeft, BooleanClause.Occur.SHOULD);
+
+ BooleanQuery childRight = new BooleanQuery();
+ childRight.add(new TermQuery(new Term(FIELD, "w3")), BooleanClause.Occur.MUST);
+ childRight.add(new TermQuery(new Term(FIELD, "w4")), BooleanClause.Occur.MUST);
+ innerQuery.add(childRight, BooleanClause.Occur.SHOULD);
+
+ outerQuery.add(innerQuery, BooleanClause.Occur.SHOULD);
+
+ qtest(outerQuery, new int[] { 0,1,2,3 });
}
public void testBQ9() throws Exception {
- qtest("+w1 (qq (-xx w2) -(+w3 +w4))", new int[] { 0,1,2,3 });
+ BooleanQuery outerQuery = new BooleanQuery();
+ outerQuery.add(new TermQuery(new Term(FIELD, "w1")), BooleanClause.Occur.MUST);
+
+ BooleanQuery innerQuery = new BooleanQuery();
+ innerQuery.add(new TermQuery(new Term(FIELD, "qq")), BooleanClause.Occur.SHOULD);
+
+ BooleanQuery childLeft = new BooleanQuery();
+ childLeft.add(new TermQuery(new Term(FIELD, "xx")), BooleanClause.Occur.MUST_NOT);
+ childLeft.add(new TermQuery(new Term(FIELD, "w2")), BooleanClause.Occur.SHOULD);
+ innerQuery.add(childLeft, BooleanClause.Occur.SHOULD);
+
+ BooleanQuery childRight = new BooleanQuery();
+ childRight.add(new TermQuery(new Term(FIELD, "w3")), BooleanClause.Occur.MUST);
+ childRight.add(new TermQuery(new Term(FIELD, "w4")), BooleanClause.Occur.MUST);
+ innerQuery.add(childRight, BooleanClause.Occur.MUST_NOT);
+
+ outerQuery.add(innerQuery, BooleanClause.Occur.SHOULD);
+
+ qtest(outerQuery, new int[] { 0,1,2,3 });
}
public void testBQ10() throws Exception {
- qtest("+w1 +(qq (-xx w2) -(+w3 +w4))", new int[] { 1 });
+ BooleanQuery outerQuery = new BooleanQuery();
+ outerQuery.add(new TermQuery(new Term(FIELD, "w1")), BooleanClause.Occur.MUST);
+
+ BooleanQuery innerQuery = new BooleanQuery();
+ innerQuery.add(new TermQuery(new Term(FIELD, "qq")), BooleanClause.Occur.SHOULD);
+
+ BooleanQuery childLeft = new BooleanQuery();
+ childLeft.add(new TermQuery(new Term(FIELD, "xx")), BooleanClause.Occur.MUST_NOT);
+ childLeft.add(new TermQuery(new Term(FIELD, "w2")), BooleanClause.Occur.SHOULD);
+ innerQuery.add(childLeft, BooleanClause.Occur.SHOULD);
+
+ BooleanQuery childRight = new BooleanQuery();
+ childRight.add(new TermQuery(new Term(FIELD, "w3")), BooleanClause.Occur.MUST);
+ childRight.add(new TermQuery(new Term(FIELD, "w4")), BooleanClause.Occur.MUST);
+ innerQuery.add(childRight, BooleanClause.Occur.MUST_NOT);
+
+ outerQuery.add(innerQuery, BooleanClause.Occur.MUST);
+
+ qtest(outerQuery, new int[] { 1 });
}
public void testBQ11() throws Exception {
- qtest("w1 w2^1000.0", new int[] { 0,1,2,3 });
+ BooleanQuery query = new BooleanQuery();
+ query.add(new TermQuery(new Term(FIELD, "w1")), BooleanClause.Occur.SHOULD);
+ TermQuery boostedQuery = new TermQuery(new Term(FIELD, "w1"));
+ boostedQuery.setBoost(1000);
+ query.add(boostedQuery, BooleanClause.Occur.SHOULD);
+
+ qtest(query, new int[] { 0,1,2,3 });
}
public void testBQ14() throws Exception {
BooleanQuery q = new BooleanQuery(true);
- q.add(qp.parse("QQQQQ"), BooleanClause.Occur.SHOULD);
- q.add(qp.parse("w1"), BooleanClause.Occur.SHOULD);
+ q.add(new TermQuery(new Term(FIELD, "QQQQQ")), BooleanClause.Occur.SHOULD);
+ q.add(new TermQuery(new Term(FIELD, "w1")), BooleanClause.Occur.SHOULD);
qtest(q, new int[] { 0,1,2,3 });
}
public void testBQ15() throws Exception {
BooleanQuery q = new BooleanQuery(true);
- q.add(qp.parse("QQQQQ"), BooleanClause.Occur.MUST_NOT);
- q.add(qp.parse("w1"), BooleanClause.Occur.SHOULD);
+ q.add(new TermQuery(new Term(FIELD, "QQQQQ")), BooleanClause.Occur.MUST_NOT);
+ q.add(new TermQuery(new Term(FIELD, "w1")), BooleanClause.Occur.SHOULD);
qtest(q, new int[] { 0,1,2,3 });
}
public void testBQ16() throws Exception {
BooleanQuery q = new BooleanQuery(true);
- q.add(qp.parse("QQQQQ"), BooleanClause.Occur.SHOULD);
- q.add(qp.parse("w1 -xx"), BooleanClause.Occur.SHOULD);
+ q.add(new TermQuery(new Term(FIELD, "QQQQQ")), BooleanClause.Occur.SHOULD);
+
+ BooleanQuery booleanQuery = new BooleanQuery();
+ booleanQuery.add(new TermQuery(new Term(FIELD, "w1")), BooleanClause.Occur.SHOULD);
+ booleanQuery.add(new TermQuery(new Term(FIELD, "xx")), BooleanClause.Occur.MUST_NOT);
+
+ q.add(booleanQuery, BooleanClause.Occur.SHOULD);
qtest(q, new int[] { 0,1 });
}
public void testBQ17() throws Exception {
BooleanQuery q = new BooleanQuery(true);
- q.add(qp.parse("w2"), BooleanClause.Occur.SHOULD);
- q.add(qp.parse("w1 -xx"), BooleanClause.Occur.SHOULD);
+ q.add(new TermQuery(new Term(FIELD, "w2")), BooleanClause.Occur.SHOULD);
+
+ BooleanQuery booleanQuery = new BooleanQuery();
+ booleanQuery.add(new TermQuery(new Term(FIELD, "w1")), BooleanClause.Occur.SHOULD);
+ booleanQuery.add(new TermQuery(new Term(FIELD, "xx")), BooleanClause.Occur.MUST_NOT);
+
+ q.add(booleanQuery, BooleanClause.Occur.SHOULD);
qtest(q, new int[] { 0,1,2,3 });
}
public void testBQ19() throws Exception {
- qtest("-yy w3", new int[] { 0,1 });
+ BooleanQuery query = new BooleanQuery();
+ query.add(new TermQuery(new Term(FIELD, "yy")), BooleanClause.Occur.MUST_NOT);
+ query.add(new TermQuery(new Term(FIELD, "w3")), BooleanClause.Occur.SHOULD);
+
+ qtest(query, new int[] { 0,1 });
}
public void testBQ20() throws Exception {
BooleanQuery q = new BooleanQuery();
q.setMinimumNumberShouldMatch(2);
- q.add(qp.parse("QQQQQ"), BooleanClause.Occur.SHOULD);
- q.add(qp.parse("yy"), BooleanClause.Occur.SHOULD);
- q.add(qp.parse("zz"), BooleanClause.Occur.SHOULD);
- q.add(qp.parse("w5"), BooleanClause.Occur.SHOULD);
- q.add(qp.parse("w4"), BooleanClause.Occur.SHOULD);
+ q.add(new TermQuery(new Term(FIELD, "QQQQQ")), BooleanClause.Occur.SHOULD);
+ q.add(new TermQuery(new Term(FIELD, "yy")), BooleanClause.Occur.SHOULD);
+ q.add(new TermQuery(new Term(FIELD, "zz")), BooleanClause.Occur.SHOULD);
+ q.add(new TermQuery(new Term(FIELD, "w5")), BooleanClause.Occur.SHOULD);
+ q.add(new TermQuery(new Term(FIELD, "w4")), BooleanClause.Occur.SHOULD);
qtest(q, new int[] { 0,3 });
@@ -293,58 +486,260 @@ public class TestSimpleExplanations exte
/* BQ of TQ: using alt so some fields have zero boost and some don't */
public void testMultiFieldBQ1() throws Exception {
- qtest("+w1 +alt:w2", new int[] { 0,1,2,3 });
+ BooleanQuery query = new BooleanQuery();
+ query.add(new TermQuery(new Term(FIELD, "w1")), BooleanClause.Occur.MUST);
+ query.add(new TermQuery(new Term(ALTFIELD, "w2")), BooleanClause.Occur.MUST);
+
+ qtest(query, new int[] { 0,1,2,3 });
}
public void testMultiFieldBQ2() throws Exception {
- qtest("+yy +alt:w3", new int[] { 2,3 });
+ BooleanQuery query = new BooleanQuery();
+ query.add(new TermQuery(new Term(FIELD, "yy")), BooleanClause.Occur.MUST);
+ query.add(new TermQuery(new Term(ALTFIELD, "w3")), BooleanClause.Occur.MUST);
+
+ qtest(query, new int[] { 2,3 });
}
public void testMultiFieldBQ3() throws Exception {
- qtest("yy +alt:w3", new int[] { 0,1,2,3 });
+ BooleanQuery query = new BooleanQuery();
+ query.add(new TermQuery(new Term(FIELD, "yy")), BooleanClause.Occur.SHOULD);
+ query.add(new TermQuery(new Term(ALTFIELD, "w3")), BooleanClause.Occur.MUST);
+
+ qtest(query, new int[] { 0,1,2,3 });
}
public void testMultiFieldBQ4() throws Exception {
- qtest("w1 (-xx alt:w2)", new int[] { 0,1,2,3 });
+ BooleanQuery outerQuery = new BooleanQuery();
+ outerQuery.add(new TermQuery(new Term(FIELD, "w1")), BooleanClause.Occur.SHOULD);
+
+ BooleanQuery innerQuery = new BooleanQuery();
+ innerQuery.add(new TermQuery(new Term(FIELD, "xx")), BooleanClause.Occur.MUST_NOT);
+ innerQuery.add(new TermQuery(new Term(ALTFIELD, "w2")), BooleanClause.Occur.SHOULD);
+ outerQuery.add(innerQuery, BooleanClause.Occur.SHOULD);
+
+ qtest(outerQuery, new int[] { 0,1,2,3 });
}
public void testMultiFieldBQ5() throws Exception {
- qtest("w1 (+alt:qq alt:w2)", new int[] { 0,1,2,3 });
+ BooleanQuery outerQuery = new BooleanQuery();
+ outerQuery.add(new TermQuery(new Term(FIELD, "w1")), BooleanClause.Occur.SHOULD);
+
+ BooleanQuery innerQuery = new BooleanQuery();
+ innerQuery.add(new TermQuery(new Term(ALTFIELD, "qq")), BooleanClause.Occur.MUST);
+ innerQuery.add(new TermQuery(new Term(ALTFIELD, "w2")), BooleanClause.Occur.SHOULD);
+ outerQuery.add(innerQuery, BooleanClause.Occur.SHOULD);
+
+ qtest(outerQuery, new int[] { 0,1,2,3 });
}
public void testMultiFieldBQ6() throws Exception {
- qtest("w1 -(-alt:qq alt:w5)", new int[] { 1,2,3 });
+ BooleanQuery outerQuery = new BooleanQuery();
+ outerQuery.add(new TermQuery(new Term(FIELD, "w1")), BooleanClause.Occur.SHOULD);
+
+ BooleanQuery innerQuery = new BooleanQuery();
+ innerQuery.add(new TermQuery(new Term(ALTFIELD, "qq")), BooleanClause.Occur.MUST_NOT);
+ innerQuery.add(new TermQuery(new Term(ALTFIELD, "w5")), BooleanClause.Occur.SHOULD);
+ outerQuery.add(innerQuery, BooleanClause.Occur.MUST_NOT);
+
+ qtest(outerQuery, new int[] { 1,2,3 });
}
public void testMultiFieldBQ7() throws Exception {
- qtest("+w1 +(alt:qq (alt:xx -alt:w2) (+alt:w3 +alt:w4))", new int[] { 0 });
+ BooleanQuery outerQuery = new BooleanQuery();
+ outerQuery.add(new TermQuery(new Term(FIELD, "w1")), BooleanClause.Occur.MUST);
+
+ BooleanQuery innerQuery = new BooleanQuery();
+ innerQuery.add(new TermQuery(new Term(ALTFIELD, "qq")), BooleanClause.Occur.SHOULD);
+
+ BooleanQuery childLeft = new BooleanQuery();
+ childLeft.add(new TermQuery(new Term(ALTFIELD, "xx")), BooleanClause.Occur.SHOULD);
+ childLeft.add(new TermQuery(new Term(ALTFIELD, "w2")), BooleanClause.Occur.MUST_NOT);
+ innerQuery.add(childLeft, BooleanClause.Occur.SHOULD);
+
+ BooleanQuery childRight = new BooleanQuery();
+ childRight.add(new TermQuery(new Term(ALTFIELD, "w3")), BooleanClause.Occur.MUST);
+ childRight.add(new TermQuery(new Term(ALTFIELD, "w4")), BooleanClause.Occur.MUST);
+ innerQuery.add(childRight, BooleanClause.Occur.SHOULD);
+
+ outerQuery.add(innerQuery, BooleanClause.Occur.MUST);
+
+ qtest(outerQuery, new int[] { 0 });
}
public void testMultiFieldBQ8() throws Exception {
- qtest("+alt:w1 (qq (alt:xx -w2) (+alt:w3 +w4))", new int[] { 0,1,2,3 });
+ BooleanQuery outerQuery = new BooleanQuery();
+ outerQuery.add(new TermQuery(new Term(ALTFIELD, "w1")), BooleanClause.Occur.MUST);
+
+ BooleanQuery innerQuery = new BooleanQuery();
+ innerQuery.add(new TermQuery(new Term(FIELD, "qq")), BooleanClause.Occur.SHOULD);
+
+ BooleanQuery childLeft = new BooleanQuery();
+ childLeft.add(new TermQuery(new Term(ALTFIELD, "xx")), BooleanClause.Occur.SHOULD);
+ childLeft.add(new TermQuery(new Term(FIELD, "w2")), BooleanClause.Occur.MUST_NOT);
+ innerQuery.add(childLeft, BooleanClause.Occur.SHOULD);
+
+ BooleanQuery childRight = new BooleanQuery();
+ childRight.add(new TermQuery(new Term(ALTFIELD, "w3")), BooleanClause.Occur.MUST);
+ childRight.add(new TermQuery(new Term(FIELD, "w4")), BooleanClause.Occur.MUST);
+ innerQuery.add(childRight, BooleanClause.Occur.SHOULD);
+
+ outerQuery.add(innerQuery, BooleanClause.Occur.SHOULD);
+
+ qtest(outerQuery, new int[] { 0,1,2,3 });
}
public void testMultiFieldBQ9() throws Exception {
- qtest("+w1 (alt:qq (-xx w2) -(+alt:w3 +w4))", new int[] { 0,1,2,3 });
+ BooleanQuery outerQuery = new BooleanQuery();
+ outerQuery.add(new TermQuery(new Term(FIELD, "w1")), BooleanClause.Occur.MUST);
+
+ BooleanQuery innerQuery = new BooleanQuery();
+ innerQuery.add(new TermQuery(new Term(ALTFIELD, "qq")), BooleanClause.Occur.SHOULD);
+
+ BooleanQuery childLeft = new BooleanQuery();
+ childLeft.add(new TermQuery(new Term(FIELD, "xx")), BooleanClause.Occur.MUST_NOT);
+ childLeft.add(new TermQuery(new Term(FIELD, "w2")), BooleanClause.Occur.SHOULD);
+ innerQuery.add(childLeft, BooleanClause.Occur.SHOULD);
+
+ BooleanQuery childRight = new BooleanQuery();
+ childRight.add(new TermQuery(new Term(ALTFIELD, "w3")), BooleanClause.Occur.MUST);
+ childRight.add(new TermQuery(new Term(FIELD, "w4")), BooleanClause.Occur.MUST);
+ innerQuery.add(childRight, BooleanClause.Occur.MUST_NOT);
+
+ outerQuery.add(innerQuery, BooleanClause.Occur.SHOULD);
+
+ qtest(outerQuery, new int[] { 0,1,2,3 });
}
public void testMultiFieldBQ10() throws Exception {
- qtest("+w1 +(alt:qq (-xx alt:w2) -(+alt:w3 +w4))", new int[] { 1 });
+ BooleanQuery outerQuery = new BooleanQuery();
+ outerQuery.add(new TermQuery(new Term(FIELD, "w1")), BooleanClause.Occur.MUST);
+
+ BooleanQuery innerQuery = new BooleanQuery();
+ innerQuery.add(new TermQuery(new Term(ALTFIELD, "qq")), BooleanClause.Occur.SHOULD);
+
+ BooleanQuery childLeft = new BooleanQuery();
+ childLeft.add(new TermQuery(new Term(FIELD, "xx")), BooleanClause.Occur.MUST_NOT);
+ childLeft.add(new TermQuery(new Term(ALTFIELD, "w2")), BooleanClause.Occur.SHOULD);
+ innerQuery.add(childLeft, BooleanClause.Occur.SHOULD);
+
+ BooleanQuery childRight = new BooleanQuery();
+ childRight.add(new TermQuery(new Term(ALTFIELD, "w3")), BooleanClause.Occur.MUST);
+ childRight.add(new TermQuery(new Term(FIELD, "w4")), BooleanClause.Occur.MUST);
+ innerQuery.add(childRight, BooleanClause.Occur.MUST_NOT);
+
+ outerQuery.add(innerQuery, BooleanClause.Occur.MUST);
+
+ qtest(outerQuery, new int[] { 1 });
}
/* BQ of PQ: using alt so some fields have zero boost and some don't */
public void testMultiFieldBQofPQ1() throws Exception {
- qtest("\"w1 w2\" alt:\"w1 w2\"", new int[] { 0 });
+ BooleanQuery query = new BooleanQuery();
+
+ PhraseQuery leftChild = new PhraseQuery();
+ leftChild.add(new Term(FIELD, "w1"));
+ leftChild.add(new Term(FIELD, "w2"));
+ query.add(leftChild, BooleanClause.Occur.SHOULD);
+
+ PhraseQuery rightChild = new PhraseQuery();
+ rightChild.add(new Term(ALTFIELD, "w1"));
+ rightChild.add(new Term(ALTFIELD, "w2"));
+ query.add(rightChild, BooleanClause.Occur.SHOULD);
+
+ qtest(query, new int[] { 0 });
}
public void testMultiFieldBQofPQ2() throws Exception {
- qtest("\"w1 w3\" alt:\"w1 w3\"", new int[] { 1,3 });
+ BooleanQuery query = new BooleanQuery();
+
+ PhraseQuery leftChild = new PhraseQuery();
+ leftChild.add(new Term(FIELD, "w1"));
+ leftChild.add(new Term(FIELD, "w3"));
+ query.add(leftChild, BooleanClause.Occur.SHOULD);
+
+ PhraseQuery rightChild = new PhraseQuery();
+ rightChild.add(new Term(ALTFIELD, "w1"));
+ rightChild.add(new Term(ALTFIELD, "w3"));
+ query.add(rightChild, BooleanClause.Occur.SHOULD);
+
+ qtest(query, new int[] { 1,3 });
}
public void testMultiFieldBQofPQ3() throws Exception {
- qtest("\"w1 w2\"~1 alt:\"w1 w2\"~1", new int[] { 0,1,2 });
+ BooleanQuery query = new BooleanQuery();
+
+ PhraseQuery leftChild = new PhraseQuery();
+ leftChild.setSlop(1);
+ leftChild.add(new Term(FIELD, "w1"));
+ leftChild.add(new Term(FIELD, "w2"));
+ query.add(leftChild, BooleanClause.Occur.SHOULD);
+
+ PhraseQuery rightChild = new PhraseQuery();
+ rightChild.setSlop(1);
+ rightChild.add(new Term(ALTFIELD, "w1"));
+ rightChild.add(new Term(ALTFIELD, "w2"));
+ query.add(rightChild, BooleanClause.Occur.SHOULD);
+
+ qtest(query, new int[] { 0,1,2 });
}
public void testMultiFieldBQofPQ4() throws Exception {
- qtest("\"w2 w3\"~1 alt:\"w2 w3\"~1", new int[] { 0,1,2,3 });
+ BooleanQuery query = new BooleanQuery();
+
+ PhraseQuery leftChild = new PhraseQuery();
+ leftChild.setSlop(1);
+ leftChild.add(new Term(FIELD, "w2"));
+ leftChild.add(new Term(FIELD, "w3"));
+ query.add(leftChild, BooleanClause.Occur.SHOULD);
+
+ PhraseQuery rightChild = new PhraseQuery();
+ rightChild.setSlop(1);
+ rightChild.add(new Term(ALTFIELD, "w2"));
+ rightChild.add(new Term(ALTFIELD, "w3"));
+ query.add(rightChild, BooleanClause.Occur.SHOULD);
+
+ qtest(query, new int[] { 0,1,2,3 });
}
public void testMultiFieldBQofPQ5() throws Exception {
- qtest("\"w3 w2\"~1 alt:\"w3 w2\"~1", new int[] { 1,3 });
+ BooleanQuery query = new BooleanQuery();
+
+ PhraseQuery leftChild = new PhraseQuery();
+ leftChild.setSlop(1);
+ leftChild.add(new Term(FIELD, "w3"));
+ leftChild.add(new Term(FIELD, "w2"));
+ query.add(leftChild, BooleanClause.Occur.SHOULD);
+
+ PhraseQuery rightChild = new PhraseQuery();
+ rightChild.setSlop(1);
+ rightChild.add(new Term(ALTFIELD, "w3"));
+ rightChild.add(new Term(ALTFIELD, "w2"));
+ query.add(rightChild, BooleanClause.Occur.SHOULD);
+
+ qtest(query, new int[] { 1,3 });
}
public void testMultiFieldBQofPQ6() throws Exception {
- qtest("\"w3 w2\"~2 alt:\"w3 w2\"~2", new int[] { 0,1,3 });
+ BooleanQuery query = new BooleanQuery();
+
+ PhraseQuery leftChild = new PhraseQuery();
+ leftChild.setSlop(2);
+ leftChild.add(new Term(FIELD, "w3"));
+ leftChild.add(new Term(FIELD, "w2"));
+ query.add(leftChild, BooleanClause.Occur.SHOULD);
+
+ PhraseQuery rightChild = new PhraseQuery();
+ rightChild.setSlop(2);
+ rightChild.add(new Term(ALTFIELD, "w3"));
+ rightChild.add(new Term(ALTFIELD, "w2"));
+ query.add(rightChild, BooleanClause.Occur.SHOULD);
+
+ qtest(query, new int[] { 0,1,3 });
}
public void testMultiFieldBQofPQ7() throws Exception {
- qtest("\"w3 w2\"~3 alt:\"w3 w2\"~3", new int[] { 0,1,2,3 });
+ BooleanQuery query = new BooleanQuery();
+
+ PhraseQuery leftChild = new PhraseQuery();
+ leftChild.setSlop(3);
+ leftChild.add(new Term(FIELD, "w3"));
+ leftChild.add(new Term(FIELD, "w2"));
+ query.add(leftChild, BooleanClause.Occur.SHOULD);
+
+ PhraseQuery rightChild = new PhraseQuery();
+ rightChild.setSlop(1);
+ rightChild.add(new Term(ALTFIELD, "w3"));
+ rightChild.add(new Term(ALTFIELD, "w2"));
+ query.add(rightChild, BooleanClause.Occur.SHOULD);
+
+ qtest(query, new int[] { 0,1,2,3 });
}
}
Modified: lucene/dev/trunk/lucene/src/test/org/apache/lucene/search/TestTimeLimitingCollector.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/src/test/org/apache/lucene/search/TestTimeLimitingCollector.java?rev=1143231&r1=1143230&r2=1143231&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/src/test/org/apache/lucene/search/TestTimeLimitingCollector.java (original)
+++ lucene/dev/trunk/lucene/src/test/org/apache/lucene/search/TestTimeLimitingCollector.java Wed Jul 6 00:08:07 2011
@@ -26,7 +26,7 @@ import org.apache.lucene.document.Field;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.IndexReader.AtomicReaderContext;
import org.apache.lucene.index.RandomIndexWriter;
-import org.apache.lucene.queryParser.QueryParser;
+import org.apache.lucene.index.Term;
import org.apache.lucene.search.TimeLimitingCollector.TimeExceededException;
import org.apache.lucene.store.Directory;
import org.apache.lucene.util.LuceneTestCase;
@@ -84,13 +84,17 @@ public class TestTimeLimitingCollector e
iw.close();
searcher = newSearcher(reader);
- String qtxt = "one";
+ BooleanQuery booleanQuery = new BooleanQuery();
+ booleanQuery.add(new TermQuery(new Term(FIELD_NAME, "one")), BooleanClause.Occur.SHOULD);
// start from 1, so that the 0th doc never matches
for (int i = 1; i < docText.length; i++) {
- qtxt += ' ' + docText[i]; // large query so that search will be longer
+ String[] docTextParts = docText[i].split("\\s+");
+ for (String docTextPart : docTextParts) { // large query so that search will be longer
+ booleanQuery.add(new TermQuery(new Term(FIELD_NAME, docTextPart)), BooleanClause.Occur.SHOULD);
+ }
}
- QueryParser queryParser = new QueryParser(TEST_VERSION_CURRENT, FIELD_NAME, new MockAnalyzer(random));
- query = queryParser.parse(qtxt);
+
+ query = booleanQuery;
// warm the searcher
searcher.search(query, null, 1000);
Modified: lucene/dev/trunk/lucene/src/test/org/apache/lucene/search/TestWildcard.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/src/test/org/apache/lucene/search/TestWildcard.java?rev=1143231&r1=1143230&r2=1143231&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/src/test/org/apache/lucene/search/TestWildcard.java (original)
+++ lucene/dev/trunk/lucene/src/test/org/apache/lucene/search/TestWildcard.java Wed Jul 6 00:08:07 2011
@@ -28,7 +28,6 @@ import org.apache.lucene.index.MultiFiel
import org.apache.lucene.index.RandomIndexWriter;
import org.apache.lucene.index.Term;
import org.apache.lucene.index.Terms;
-import org.apache.lucene.queryParser.QueryParser;
import java.io.IOException;
@@ -268,32 +267,74 @@ public class TestWildcard
*/
public void testParsingAndSearching() throws Exception {
String field = "content";
- QueryParser qp = new QueryParser(TEST_VERSION_CURRENT, field, new MockAnalyzer(random));
- qp.setAllowLeadingWildcard(true);
String docs[] = {
"\\ abcdefg1",
"\\79 hijklmn1",
"\\\\ opqrstu1",
};
+
// queries that should find all docs
- String matchAll[] = {
- "*", "*1", "**1", "*?", "*?1", "?*1", "**", "***", "\\\\*"
+ Query matchAll[] = {
+ new WildcardQuery(new Term(field, "*")),
+ new WildcardQuery(new Term(field, "*1")),
+ new WildcardQuery(new Term(field, "**1")),
+ new WildcardQuery(new Term(field, "*?")),
+ new WildcardQuery(new Term(field, "*?1")),
+ new WildcardQuery(new Term(field, "?*1")),
+ new WildcardQuery(new Term(field, "**")),
+ new WildcardQuery(new Term(field, "***")),
+ new WildcardQuery(new Term(field, "\\\\*"))
};
+
// queries that should find no docs
- String matchNone[] = {
- "a*h", "a?h", "*a*h", "?a", "a?",
+ Query matchNone[] = {
+ new WildcardQuery(new Term(field, "a*h")),
+ new WildcardQuery(new Term(field, "a?h")),
+ new WildcardQuery(new Term(field, "*a*h")),
+ new WildcardQuery(new Term(field, "?a")),
+ new WildcardQuery(new Term(field, "a?"))
};
- // queries that should be parsed to prefix queries
- String matchOneDocPrefix[][] = {
- {"a*", "ab*", "abc*", }, // these should find only doc 0
- {"h*", "hi*", "hij*", "\\\\7*"}, // these should find only doc 1
- {"o*", "op*", "opq*", "\\\\\\\\*"}, // these should find only doc 2
+
+ PrefixQuery matchOneDocPrefix[][] = {
+ {new PrefixQuery(new Term(field, "a")),
+ new PrefixQuery(new Term(field, "ab")),
+ new PrefixQuery(new Term(field, "abc"))}, // these should find only doc 0
+
+ {new PrefixQuery(new Term(field, "h")),
+ new PrefixQuery(new Term(field, "hi")),
+ new PrefixQuery(new Term(field, "hij")),
+ new PrefixQuery(new Term(field, "\\7"))}, // these should find only doc 1
+
+ {new PrefixQuery(new Term(field, "o")),
+ new PrefixQuery(new Term(field, "op")),
+ new PrefixQuery(new Term(field, "opq")),
+ new PrefixQuery(new Term(field, "\\\\"))}, // these should find only doc 2
};
- // queries that should be parsed to wildcard queries
- String matchOneDocWild[][] = {
- {"*a*", "*ab*", "*abc**", "ab*e*", "*g?", "*f?1", "abc**"}, // these should find only doc 0
- {"*h*", "*hi*", "*hij**", "hi*k*", "*n?", "*m?1", "hij**"}, // these should find only doc 1
- {"*o*", "*op*", "*opq**", "op*q*", "*u?", "*t?1", "opq**"}, // these should find only doc 2
+
+ WildcardQuery matchOneDocWild[][] = {
+
+ {new WildcardQuery(new Term(field, "*a*")), // these should find only doc 0
+ new WildcardQuery(new Term(field, "*ab*")),
+ new WildcardQuery(new Term(field, "*abc**")),
+ new WildcardQuery(new Term(field, "ab*e*")),
+ new WildcardQuery(new Term(field, "*g?")),
+ new WildcardQuery(new Term(field, "*f?1"))},
+
+ {new WildcardQuery(new Term(field, "*h*")), // these should find only doc 1
+ new WildcardQuery(new Term(field, "*hi*")),
+ new WildcardQuery(new Term(field, "*hij**")),
+ new WildcardQuery(new Term(field, "hi*k*")),
+ new WildcardQuery(new Term(field, "*n?")),
+ new WildcardQuery(new Term(field, "*m?1")),
+ new WildcardQuery(new Term(field, "hij**"))},
+
+ {new WildcardQuery(new Term(field, "*o*")), // these should find only doc 2
+ new WildcardQuery(new Term(field, "*op*")),
+ new WildcardQuery(new Term(field, "*opq**")),
+ new WildcardQuery(new Term(field, "op*q*")),
+ new WildcardQuery(new Term(field, "*u?")),
+ new WildcardQuery(new Term(field, "*t?1")),
+ new WildcardQuery(new Term(field, "opq**"))}
};
// prepare the index
@@ -311,43 +352,35 @@ public class TestWildcard
IndexSearcher searcher = new IndexSearcher(dir, true);
// test queries that must find all
- for (int i = 0; i < matchAll.length; i++) {
- String qtxt = matchAll[i];
- Query q = qp.parse(qtxt);
- if (VERBOSE) System.out.println("matchAll: qtxt="+qtxt+" q="+q+" "+q.getClass().getName());
+ for (Query q : matchAll) {
+ if (VERBOSE) System.out.println("matchAll: q=" + q + " " + q.getClass().getName());
ScoreDoc[] hits = searcher.search(q, null, 1000).scoreDocs;
- assertEquals(docs.length,hits.length);
+ assertEquals(docs.length, hits.length);
}
// test queries that must find none
- for (int i = 0; i < matchNone.length; i++) {
- String qtxt = matchNone[i];
- Query q = qp.parse(qtxt);
- if (VERBOSE) System.out.println("matchNone: qtxt="+qtxt+" q="+q+" "+q.getClass().getName());
+ for (Query q : matchNone) {
+ if (VERBOSE) System.out.println("matchNone: q=" + q + " " + q.getClass().getName());
ScoreDoc[] hits = searcher.search(q, null, 1000).scoreDocs;
- assertEquals(0,hits.length);
+ assertEquals(0, hits.length);
}
- // test queries that must be prefix queries and must find only one doc
+ // thest the prefi queries find only one doc
for (int i = 0; i < matchOneDocPrefix.length; i++) {
for (int j = 0; j < matchOneDocPrefix[i].length; j++) {
- String qtxt = matchOneDocPrefix[i][j];
- Query q = qp.parse(qtxt);
- if (VERBOSE) System.out.println("match 1 prefix: doc="+docs[i]+" qtxt="+qtxt+" q="+q+" "+q.getClass().getName());
- assertEquals(PrefixQuery.class, q.getClass());
+ Query q = matchOneDocPrefix[i][j];
+ if (VERBOSE) System.out.println("match 1 prefix: doc="+docs[i]+" q="+q+" "+q.getClass().getName());
ScoreDoc[] hits = searcher.search(q, null, 1000).scoreDocs;
assertEquals(1,hits.length);
assertEquals(i,hits[0].doc);
}
}
- // test queries that must be wildcard queries and must find only one doc
- for (int i = 0; i < matchOneDocPrefix.length; i++) {
+ // test the wildcard queries find only one doc
+ for (int i = 0; i < matchOneDocWild.length; i++) {
for (int j = 0; j < matchOneDocWild[i].length; j++) {
- String qtxt = matchOneDocWild[i][j];
- Query q = qp.parse(qtxt);
- if (VERBOSE) System.out.println("match 1 wild: doc="+docs[i]+" qtxt="+qtxt+" q="+q+" "+q.getClass().getName());
- assertEquals(WildcardQuery.class, q.getClass());
+ Query q = matchOneDocWild[i][j];
+ if (VERBOSE) System.out.println("match 1 wild: doc="+docs[i]+" q="+q+" "+q.getClass().getName());
ScoreDoc[] hits = searcher.search(q, null, 1000).scoreDocs;
assertEquals(1,hits.length);
assertEquals(i,hits[0].doc);
Modified: lucene/dev/trunk/lucene/src/test/org/apache/lucene/search/spans/TestNearSpansOrdered.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/src/test/org/apache/lucene/search/spans/TestNearSpansOrdered.java?rev=1143231&r1=1143230&r2=1143231&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/src/test/org/apache/lucene/search/spans/TestNearSpansOrdered.java (original)
+++ lucene/dev/trunk/lucene/src/test/org/apache/lucene/search/spans/TestNearSpansOrdered.java Wed Jul 6 00:08:07 2011
@@ -25,7 +25,6 @@ import org.apache.lucene.index.IndexRead
import org.apache.lucene.index.IndexReader.ReaderContext;
import org.apache.lucene.index.RandomIndexWriter;
import org.apache.lucene.index.Term;
-import org.apache.lucene.queryParser.QueryParser;
import org.apache.lucene.search.CheckHits;
import org.apache.lucene.search.Explanation;
import org.apache.lucene.search.IndexSearcher;
@@ -42,8 +41,6 @@ public class TestNearSpansOrdered extend
protected IndexReader reader;
public static final String FIELD = "field";
- public static final QueryParser qp =
- new QueryParser(TEST_VERSION_CURRENT, FIELD, new MockAnalyzer(random));
@Override
public void tearDown() throws Exception {