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/02/24 18:43:11 UTC
svn commit: r1662059 [3/5] - in /lucene/dev/trunk: lucene/
lucene/analysis/common/src/test/org/apache/lucene/analysis/shingle/
lucene/backward-codecs/src/test/org/apache/lucene/index/
lucene/benchmark/src/java/org/apache/lucene/benchmark/byTask/tasks/ ...
Modified: lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/TestTermRangeFilter.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/TestTermRangeFilter.java?rev=1662059&r1=1662058&r2=1662059&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/TestTermRangeFilter.java (original)
+++ lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/TestTermRangeFilter.java Tue Feb 24 17:43:10 2015
@@ -54,83 +54,83 @@ public class TestTermRangeFilter extends
// test id, bounded on both ends
- result = search.search(q, TermRangeFilter.newStringRange("id", minIP, maxIP, T, T),
+ result = search.search(new FilteredQuery(q, TermRangeFilter.newStringRange("id", minIP, maxIP, T, T)),
numDocs).scoreDocs;
assertEquals("find all", numDocs, result.length);
- result = search.search(q, TermRangeFilter.newStringRange("id", minIP, maxIP, T, F),
+ result = search.search(new FilteredQuery(q, TermRangeFilter.newStringRange("id", minIP, maxIP, T, F)),
numDocs).scoreDocs;
assertEquals("all but last", numDocs - 1, result.length);
- result = search.search(q, TermRangeFilter.newStringRange("id", minIP, maxIP, F, T),
+ result = search.search(new FilteredQuery(q, TermRangeFilter.newStringRange("id", minIP, maxIP, F, T)),
numDocs).scoreDocs;
assertEquals("all but first", numDocs - 1, result.length);
- result = search.search(q, TermRangeFilter.newStringRange("id", minIP, maxIP, F, F),
+ result = search.search(new FilteredQuery(q, TermRangeFilter.newStringRange("id", minIP, maxIP, F, F)),
numDocs).scoreDocs;
assertEquals("all but ends", numDocs - 2, result.length);
- result = search.search(q, TermRangeFilter.newStringRange("id", medIP, maxIP, T, T),
+ result = search.search(new FilteredQuery(q, TermRangeFilter.newStringRange("id", medIP, maxIP, T, T)),
numDocs).scoreDocs;
assertEquals("med and up", 1 + maxId - medId, result.length);
- result = search.search(q, TermRangeFilter.newStringRange("id", minIP, medIP, T, T),
+ result = search.search(new FilteredQuery(q, TermRangeFilter.newStringRange("id", minIP, medIP, T, T)),
numDocs).scoreDocs;
assertEquals("up to med", 1 + medId - minId, result.length);
// unbounded id
- result = search.search(q, TermRangeFilter.newStringRange("id", minIP, null, T, F),
+ result = search.search(new FilteredQuery(q, TermRangeFilter.newStringRange("id", minIP, null, T, F)),
numDocs).scoreDocs;
assertEquals("min and up", numDocs, result.length);
- result = search.search(q, TermRangeFilter.newStringRange("id", null, maxIP, F, T),
+ result = search.search(new FilteredQuery(q, TermRangeFilter.newStringRange("id", null, maxIP, F, T)),
numDocs).scoreDocs;
assertEquals("max and down", numDocs, result.length);
- result = search.search(q, TermRangeFilter.newStringRange("id", minIP, null, F, F),
+ result = search.search(new FilteredQuery(q, TermRangeFilter.newStringRange("id", minIP, null, F, F)),
numDocs).scoreDocs;
assertEquals("not min, but up", numDocs - 1, result.length);
- result = search.search(q, TermRangeFilter.newStringRange("id", null, maxIP, F, F),
+ result = search.search(new FilteredQuery(q, TermRangeFilter.newStringRange("id", null, maxIP, F, F)),
numDocs).scoreDocs;
assertEquals("not max, but down", numDocs - 1, result.length);
- result = search.search(q, TermRangeFilter.newStringRange("id", medIP, maxIP, T, F),
+ result = search.search(new FilteredQuery(q, TermRangeFilter.newStringRange("id", medIP, maxIP, T, F)),
numDocs).scoreDocs;
assertEquals("med and up, not max", maxId - medId, result.length);
- result = search.search(q, TermRangeFilter.newStringRange("id", minIP, medIP, F, T),
+ result = search.search(new FilteredQuery(q, TermRangeFilter.newStringRange("id", minIP, medIP, F, T)),
numDocs).scoreDocs;
assertEquals("not min, up to med", medId - minId, result.length);
// very small sets
- result = search.search(q, TermRangeFilter.newStringRange("id", minIP, minIP, F, F),
+ result = search.search(new FilteredQuery(q, TermRangeFilter.newStringRange("id", minIP, minIP, F, F)),
numDocs).scoreDocs;
assertEquals("min,min,F,F", 0, result.length);
- result = search.search(q, TermRangeFilter.newStringRange("id", medIP, medIP, F, F),
+ result = search.search(new FilteredQuery(q, TermRangeFilter.newStringRange("id", medIP, medIP, F, F)),
numDocs).scoreDocs;
assertEquals("med,med,F,F", 0, result.length);
- result = search.search(q, TermRangeFilter.newStringRange("id", maxIP, maxIP, F, F),
+ result = search.search(new FilteredQuery(q, TermRangeFilter.newStringRange("id", maxIP, maxIP, F, F)),
numDocs).scoreDocs;
assertEquals("max,max,F,F", 0, result.length);
- result = search.search(q, TermRangeFilter.newStringRange("id", minIP, minIP, T, T),
+ result = search.search(new FilteredQuery(q, TermRangeFilter.newStringRange("id", minIP, minIP, T, T)),
numDocs).scoreDocs;
assertEquals("min,min,T,T", 1, result.length);
- result = search.search(q, TermRangeFilter.newStringRange("id", null, minIP, F, T),
+ result = search.search(new FilteredQuery(q, TermRangeFilter.newStringRange("id", null, minIP, F, T)),
numDocs).scoreDocs;
assertEquals("nul,min,F,T", 1, result.length);
- result = search.search(q, TermRangeFilter.newStringRange("id", maxIP, maxIP, T, T),
+ result = search.search(new FilteredQuery(q, TermRangeFilter.newStringRange("id", maxIP, maxIP, T, T)),
numDocs).scoreDocs;
assertEquals("max,max,T,T", 1, result.length);
- result = search.search(q, TermRangeFilter.newStringRange("id", maxIP, null, T, F),
+ result = search.search(new FilteredQuery(q, TermRangeFilter.newStringRange("id", maxIP, null, T, F)),
numDocs).scoreDocs;
assertEquals("max,nul,T,T", 1, result.length);
- result = search.search(q, TermRangeFilter.newStringRange("id", medIP, medIP, T, T),
+ result = search.search(new FilteredQuery(q, TermRangeFilter.newStringRange("id", medIP, medIP, T, T)),
numDocs).scoreDocs;
assertEquals("med,med,T,T", 1, result.length);
}
@@ -153,60 +153,60 @@ public class TestTermRangeFilter extends
// test extremes, bounded on both ends
- result = search.search(q, TermRangeFilter.newStringRange("rand", minRP, maxRP, T, T),
+ result = search.search(new FilteredQuery(q, TermRangeFilter.newStringRange("rand", minRP, maxRP, T, T)),
numDocs).scoreDocs;
assertEquals("find all", numDocs, result.length);
- result = search.search(q, TermRangeFilter.newStringRange("rand", minRP, maxRP, T, F),
+ result = search.search(new FilteredQuery(q, TermRangeFilter.newStringRange("rand", minRP, maxRP, T, F)),
numDocs).scoreDocs;
assertEquals("all but biggest", numDocs - 1, result.length);
- result = search.search(q, TermRangeFilter.newStringRange("rand", minRP, maxRP, F, T),
+ result = search.search(new FilteredQuery(q, TermRangeFilter.newStringRange("rand", minRP, maxRP, F, T)),
numDocs).scoreDocs;
assertEquals("all but smallest", numDocs - 1, result.length);
- result = search.search(q, TermRangeFilter.newStringRange("rand", minRP, maxRP, F, F),
+ result = search.search(new FilteredQuery(q, TermRangeFilter.newStringRange("rand", minRP, maxRP, F, F)),
numDocs).scoreDocs;
assertEquals("all but extremes", numDocs - 2, result.length);
// unbounded
- result = search.search(q, TermRangeFilter.newStringRange("rand", minRP, null, T, F),
+ result = search.search(new FilteredQuery(q, TermRangeFilter.newStringRange("rand", minRP, null, T, F)),
numDocs).scoreDocs;
assertEquals("smallest and up", numDocs, result.length);
- result = search.search(q, TermRangeFilter.newStringRange("rand", null, maxRP, F, T),
+ result = search.search(new FilteredQuery(q, TermRangeFilter.newStringRange("rand", null, maxRP, F, T)),
numDocs).scoreDocs;
assertEquals("biggest and down", numDocs, result.length);
- result = search.search(q, TermRangeFilter.newStringRange("rand", minRP, null, F, F),
+ result = search.search(new FilteredQuery(q, TermRangeFilter.newStringRange("rand", minRP, null, F, F)),
numDocs).scoreDocs;
assertEquals("not smallest, but up", numDocs - 1, result.length);
- result = search.search(q, TermRangeFilter.newStringRange("rand", null, maxRP, F, F),
+ result = search.search(new FilteredQuery(q, TermRangeFilter.newStringRange("rand", null, maxRP, F, F)),
numDocs).scoreDocs;
assertEquals("not biggest, but down", numDocs - 1, result.length);
// very small sets
- result = search.search(q, TermRangeFilter.newStringRange("rand", minRP, minRP, F, F),
+ result = search.search(new FilteredQuery(q, TermRangeFilter.newStringRange("rand", minRP, minRP, F, F)),
numDocs).scoreDocs;
assertEquals("min,min,F,F", 0, result.length);
- result = search.search(q, TermRangeFilter.newStringRange("rand", maxRP, maxRP, F, F),
+ result = search.search(new FilteredQuery(q, TermRangeFilter.newStringRange("rand", maxRP, maxRP, F, F)),
numDocs).scoreDocs;
assertEquals("max,max,F,F", 0, result.length);
- result = search.search(q, TermRangeFilter.newStringRange("rand", minRP, minRP, T, T),
+ result = search.search(new FilteredQuery(q, TermRangeFilter.newStringRange("rand", minRP, minRP, T, T)),
numDocs).scoreDocs;
assertEquals("min,min,T,T", 1, result.length);
- result = search.search(q, TermRangeFilter.newStringRange("rand", null, minRP, F, T),
+ result = search.search(new FilteredQuery(q, TermRangeFilter.newStringRange("rand", null, minRP, F, T)),
numDocs).scoreDocs;
assertEquals("nul,min,F,T", 1, result.length);
- result = search.search(q, TermRangeFilter.newStringRange("rand", maxRP, maxRP, T, T),
+ result = search.search(new FilteredQuery(q, TermRangeFilter.newStringRange("rand", maxRP, maxRP, T, T)),
numDocs).scoreDocs;
assertEquals("max,max,T,T", 1, result.length);
- result = search.search(q, TermRangeFilter.newStringRange("rand", maxRP, null, T, F),
+ result = search.search(new FilteredQuery(q, TermRangeFilter.newStringRange("rand", maxRP, null, T, F)),
numDocs).scoreDocs;
assertEquals("max,nul,T,T", 1, result.length);
}
Modified: lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/TestTermRangeQuery.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/TestTermRangeQuery.java?rev=1662059&r1=1662058&r2=1662059&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/TestTermRangeQuery.java (original)
+++ lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/TestTermRangeQuery.java Tue Feb 24 17:43:10 2015
@@ -56,21 +56,21 @@ public class TestTermRangeQuery extends
initializeIndex(new String[] {"A", "B", "C", "D"});
IndexReader reader = DirectoryReader.open(dir);
IndexSearcher searcher = newSearcher(reader);
- ScoreDoc[] hits = searcher.search(query, null, 1000).scoreDocs;
+ ScoreDoc[] hits = searcher.search(query, 1000).scoreDocs;
assertEquals("A,B,C,D, only B in range", 1, hits.length);
reader.close();
initializeIndex(new String[] {"A", "B", "D"});
reader = DirectoryReader.open(dir);
searcher = newSearcher(reader);
- hits = searcher.search(query, null, 1000).scoreDocs;
+ hits = searcher.search(query, 1000).scoreDocs;
assertEquals("A,B,D, only B in range", 1, hits.length);
reader.close();
addDoc("C");
reader = DirectoryReader.open(dir);
searcher = newSearcher(reader);
- hits = searcher.search(query, null, 1000).scoreDocs;
+ hits = searcher.search(query, 1000).scoreDocs;
assertEquals("C added, still only B in range", 1, hits.length);
reader.close();
}
@@ -81,21 +81,21 @@ public class TestTermRangeQuery extends
initializeIndex(new String[]{"A", "B", "C", "D"});
IndexReader reader = DirectoryReader.open(dir);
IndexSearcher searcher = newSearcher(reader);
- ScoreDoc[] hits = searcher.search(query, null, 1000).scoreDocs;
+ ScoreDoc[] hits = searcher.search(query, 1000).scoreDocs;
assertEquals("A,B,C,D - A,B,C in range", 3, hits.length);
reader.close();
initializeIndex(new String[]{"A", "B", "D"});
reader = DirectoryReader.open(dir);
searcher = newSearcher(reader);
- hits = searcher.search(query, null, 1000).scoreDocs;
+ hits = searcher.search(query, 1000).scoreDocs;
assertEquals("A,B,D - A and B in range", 2, hits.length);
reader.close();
addDoc("C");
reader = DirectoryReader.open(dir);
searcher = newSearcher(reader);
- hits = searcher.search(query, null, 1000).scoreDocs;
+ hits = searcher.search(query, 1000).scoreDocs;
assertEquals("C added - A, B, C in range", 3, hits.length);
reader.close();
}
@@ -107,17 +107,17 @@ public class TestTermRangeQuery extends
TermRangeQuery query = new TermRangeQuery("content", null, null, true, true);
Terms terms = MultiFields.getTerms(searcher.getIndexReader(), "content");
assertFalse(query.getTermsEnum(terms) instanceof TermRangeTermsEnum);
- assertEquals(4, searcher.search(query, null, 1000).scoreDocs.length);
+ assertEquals(4, searcher.search(query, 1000).scoreDocs.length);
query = new TermRangeQuery("content", null, null, false, false);
assertFalse(query.getTermsEnum(terms) instanceof TermRangeTermsEnum);
- assertEquals(4, searcher.search(query, null, 1000).scoreDocs.length);
+ assertEquals(4, searcher.search(query, 1000).scoreDocs.length);
query = TermRangeQuery.newStringRange("content", "", null, true, false);
assertFalse(query.getTermsEnum(terms) instanceof TermRangeTermsEnum);
- assertEquals(4, searcher.search(query, null, 1000).scoreDocs.length);
+ assertEquals(4, searcher.search(query, 1000).scoreDocs.length);
// and now anothe one
query = TermRangeQuery.newStringRange("content", "B", null, true, false);
assertTrue(query.getTermsEnum(terms) instanceof TermRangeTermsEnum);
- assertEquals(3, searcher.search(query, null, 1000).scoreDocs.length);
+ assertEquals(3, searcher.search(query, 1000).scoreDocs.length);
reader.close();
}
@@ -276,7 +276,7 @@ public class TestTermRangeQuery extends
initializeIndex(new String[] {"A", "B", "", "C", "D"}, analyzer);
IndexReader reader = DirectoryReader.open(dir);
IndexSearcher searcher = newSearcher(reader);
- int numHits = searcher.search(query, null, 1000).totalHits;
+ int numHits = searcher.search(query, 1000).totalHits;
// When Lucene-38 is fixed, use the assert on the next line:
assertEquals("A,B,<empty string>,C,D => A, B & <empty string> are in range", 3, numHits);
// until Lucene-38 is fixed, use this assert:
@@ -286,7 +286,7 @@ public class TestTermRangeQuery extends
initializeIndex(new String[] {"A", "B", "", "D"}, analyzer);
reader = DirectoryReader.open(dir);
searcher = newSearcher(reader);
- numHits = searcher.search(query, null, 1000).totalHits;
+ numHits = searcher.search(query, 1000).totalHits;
// When Lucene-38 is fixed, use the assert on the next line:
assertEquals("A,B,<empty string>,D => A, B & <empty string> are in range", 3, numHits);
// until Lucene-38 is fixed, use this assert:
@@ -295,7 +295,7 @@ public class TestTermRangeQuery extends
addDoc("C");
reader = DirectoryReader.open(dir);
searcher = newSearcher(reader);
- numHits = searcher.search(query, null, 1000).totalHits;
+ numHits = searcher.search(query, 1000).totalHits;
// When Lucene-38 is fixed, use the assert on the next line:
assertEquals("C added, still A, B & <empty string> are in range", 3, numHits);
// until Lucene-38 is fixed, use this assert
@@ -311,7 +311,7 @@ public class TestTermRangeQuery extends
initializeIndex(new String[]{"A", "B", "","C", "D"}, analyzer);
IndexReader reader = DirectoryReader.open(dir);
IndexSearcher searcher = newSearcher(reader);
- int numHits = searcher.search(query, null, 1000).totalHits;
+ int numHits = searcher.search(query, 1000).totalHits;
// When Lucene-38 is fixed, use the assert on the next line:
assertEquals("A,B,<empty string>,C,D => A,B,<empty string>,C in range", 4, numHits);
// until Lucene-38 is fixed, use this assert
@@ -320,7 +320,7 @@ public class TestTermRangeQuery extends
initializeIndex(new String[]{"A", "B", "", "D"}, analyzer);
reader = DirectoryReader.open(dir);
searcher = newSearcher(reader);
- numHits = searcher.search(query, null, 1000).totalHits;
+ numHits = searcher.search(query, 1000).totalHits;
// When Lucene-38 is fixed, use the assert on the next line:
assertEquals("A,B,<empty string>,D - A, B and <empty string> in range", 3, numHits);
// until Lucene-38 is fixed, use this assert
@@ -329,7 +329,7 @@ public class TestTermRangeQuery extends
addDoc("C");
reader = DirectoryReader.open(dir);
searcher = newSearcher(reader);
- numHits = searcher.search(query, null, 1000).totalHits;
+ numHits = searcher.search(query, 1000).totalHits;
// When Lucene-38 is fixed, use the assert on the next line:
assertEquals("C added => A,B,<empty string>,C in range", 4, numHits);
// until Lucene-38 is fixed, use this assert
Modified: lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/TestTimeLimitingCollector.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/TestTimeLimitingCollector.java?rev=1662059&r1=1662058&r2=1662059&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/TestTimeLimitingCollector.java (original)
+++ lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/TestTimeLimitingCollector.java Tue Feb 24 17:43:10 2015
@@ -105,7 +105,7 @@ public class TestTimeLimitingCollector e
query = booleanQuery;
// warm the searcher
- searcher.search(query, null, 1000);
+ searcher.search(query, 1000);
}
@Override
Modified: lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/TestTotalHitCountCollector.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/TestTotalHitCountCollector.java?rev=1662059&r1=1662058&r2=1662059&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/TestTotalHitCountCollector.java (original)
+++ lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/TestTotalHitCountCollector.java Tue Feb 24 17:43:10 2015
@@ -41,7 +41,7 @@ public class TestTotalHitCountCollector
IndexSearcher searcher = newSearcher(reader);
TotalHitCountCollector c = new TotalHitCountCollector();
- searcher.search(new MatchAllDocsQuery(), null, c);
+ searcher.search(new MatchAllDocsQuery(), c);
assertEquals(5, c.getTotalHits());
reader.close();
indexStore.close();
Modified: lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/TestWildcard.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/TestWildcard.java?rev=1662059&r1=1662058&r2=1662059&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/TestWildcard.java (original)
+++ lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/TestWildcard.java Tue Feb 24 17:43:10 2015
@@ -254,7 +254,7 @@ public class TestWildcard
private void assertMatches(IndexSearcher searcher, Query q, int expectedMatches)
throws IOException {
- ScoreDoc[] result = searcher.search(q, null, 1000).scoreDocs;
+ ScoreDoc[] result = searcher.search(q, 1000).scoreDocs;
assertEquals(expectedMatches, result.length);
}
@@ -354,14 +354,14 @@ public class TestWildcard
// test queries that must find all
for (Query q : matchAll) {
if (VERBOSE) System.out.println("matchAll: q=" + q + " " + q.getClass().getName());
- ScoreDoc[] hits = searcher.search(q, null, 1000).scoreDocs;
+ ScoreDoc[] hits = searcher.search(q, 1000).scoreDocs;
assertEquals(docs.length, hits.length);
}
// test queries that must find none
for (Query q : matchNone) {
if (VERBOSE) System.out.println("matchNone: q=" + q + " " + q.getClass().getName());
- ScoreDoc[] hits = searcher.search(q, null, 1000).scoreDocs;
+ ScoreDoc[] hits = searcher.search(q, 1000).scoreDocs;
assertEquals(0, hits.length);
}
@@ -370,7 +370,7 @@ public class TestWildcard
for (int j = 0; j < matchOneDocPrefix[i].length; j++) {
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;
+ ScoreDoc[] hits = searcher.search(q, 1000).scoreDocs;
assertEquals(1,hits.length);
assertEquals(i,hits[0].doc);
}
@@ -381,7 +381,7 @@ public class TestWildcard
for (int j = 0; j < matchOneDocWild[i].length; j++) {
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;
+ ScoreDoc[] hits = searcher.search(q, 1000).scoreDocs;
assertEquals(1,hits.length);
assertEquals(i,hits[0].doc);
}
Modified: lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/payloads/TestPayloadNearQuery.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/payloads/TestPayloadNearQuery.java?rev=1662059&r1=1662058&r2=1662059&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/payloads/TestPayloadNearQuery.java (original)
+++ lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/payloads/TestPayloadNearQuery.java Tue Feb 24 17:43:10 2015
@@ -141,7 +141,7 @@ public class TestPayloadNearQuery extend
// all 10 hits should have score = 3 because adjacent terms have payloads of 2,4
// and all the similarity factors are set to 1
- hits = searcher.search(query, null, 100);
+ hits = searcher.search(query, 100);
assertTrue("hits is null and it shouldn't be", hits != null);
assertTrue("should be 10 hits", hits.totalHits == 10);
for (int j = 0; j < hits.scoreDocs.length; j++) {
@@ -155,7 +155,7 @@ public class TestPayloadNearQuery extend
}
// all should have score = 3 because adjacent terms have payloads of 2,4
// and all the similarity factors are set to 1
- hits = searcher.search(query, null, 100);
+ hits = searcher.search(query, 100);
assertTrue("hits is null and it shouldn't be", hits != null);
assertEquals("should be 100 hits", 100, hits.totalHits);
for (int j = 0; j < hits.scoreDocs.length; j++) {
@@ -179,7 +179,7 @@ public class TestPayloadNearQuery extend
clauses[1] = q2;
query = new PayloadNearQuery(clauses, 10, false);
//System.out.println(query.toString());
- assertEquals(12, searcher.search(query, null, 100).totalHits);
+ assertEquals(12, searcher.search(query, 100).totalHits);
/*
System.out.println(hits.totalHits);
for (int j = 0; j < hits.scoreDocs.length; j++) {
@@ -197,7 +197,7 @@ public class TestPayloadNearQuery extend
QueryUtils.check(query);
// all 10 hits should have score = 3 because adjacent terms have payloads of 2,4
// and all the similarity factors are set to 1
- hits = searcher.search(query, null, 100);
+ hits = searcher.search(query, 100);
assertTrue("hits is null and it shouldn't be", hits != null);
assertTrue("should be 10 hits", hits.totalHits == 10);
for (int j = 0; j < hits.scoreDocs.length; j++) {
@@ -216,7 +216,7 @@ public class TestPayloadNearQuery extend
query = newPhraseQuery("field", "twenty two", true, new MaxPayloadFunction());
QueryUtils.check(query);
// all 10 hits should have score = 4 (max payload value)
- hits = searcher.search(query, null, 100);
+ hits = searcher.search(query, 100);
assertTrue("hits is null and it shouldn't be", hits != null);
assertTrue("should be 10 hits", hits.totalHits == 10);
for (int j = 0; j < hits.scoreDocs.length; j++) {
@@ -235,7 +235,7 @@ public class TestPayloadNearQuery extend
query = newPhraseQuery("field", "twenty two", true, new MinPayloadFunction());
QueryUtils.check(query);
// all 10 hits should have score = 2 (min payload value)
- hits = searcher.search(query, null, 100);
+ hits = searcher.search(query, 100);
assertTrue("hits is null and it shouldn't be", hits != null);
assertTrue("should be 10 hits", hits.totalHits == 10);
for (int j = 0; j < hits.scoreDocs.length; j++) {
@@ -269,7 +269,7 @@ public class TestPayloadNearQuery extend
PayloadNearQuery query;
TopDocs hits;
query = newPhraseQuery("field", "nine hundred ninety nine", true, new AveragePayloadFunction());
- hits = searcher.search(query, null, 100);
+ hits = searcher.search(query, 100);
assertTrue("hits is null and it shouldn't be", hits != null);
ScoreDoc doc = hits.scoreDocs[0];
// System.out.println("Doc: " + doc.toString());
@@ -291,7 +291,7 @@ public class TestPayloadNearQuery extend
SpanQuery q4 = newPhraseQuery("field", "hundred nine", false, new AveragePayloadFunction());
SpanQuery[]clauses = new SpanQuery[] {new PayloadNearQuery(new SpanQuery[] {q1,q2}, 0, true), new PayloadNearQuery(new SpanQuery[] {q3,q4}, 0, false)};
query = new PayloadNearQuery(clauses, 0, false);
- hits = searcher.search(query, null, 100);
+ hits = searcher.search(query, 100);
assertTrue("hits is null and it shouldn't be", hits != null);
// should be only 1 hit - doc 999
assertTrue("should only be one hit", hits.scoreDocs.length == 1);
Modified: lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/payloads/TestPayloadTermQuery.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/payloads/TestPayloadTermQuery.java?rev=1662059&r1=1662058&r2=1662059&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/payloads/TestPayloadTermQuery.java (original)
+++ lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/payloads/TestPayloadTermQuery.java Tue Feb 24 17:43:10 2015
@@ -147,7 +147,7 @@ public class TestPayloadTermQuery extend
public void test() throws IOException {
PayloadTermQuery query = new PayloadTermQuery(new Term("field", "seventy"),
new MaxPayloadFunction());
- TopDocs hits = searcher.search(query, null, 100);
+ TopDocs hits = searcher.search(query, 100);
assertTrue("hits is null and it shouldn't be", hits != null);
assertTrue("hits Size: " + hits.totalHits + " is not: " + 100, hits.totalHits == 100);
@@ -188,7 +188,7 @@ public class TestPayloadTermQuery extend
public void testMultipleMatchesPerDoc() throws Exception {
PayloadTermQuery query = new PayloadTermQuery(new Term(PayloadHelper.MULTI_FIELD, "seventy"),
new MaxPayloadFunction());
- TopDocs hits = searcher.search(query, null, 100);
+ TopDocs hits = searcher.search(query, 100);
assertTrue("hits is null and it shouldn't be", hits != null);
assertTrue("hits Size: " + hits.totalHits + " is not: " + 100, hits.totalHits == 100);
@@ -230,7 +230,7 @@ public class TestPayloadTermQuery extend
IndexReader reader = DirectoryReader.open(directory);
IndexSearcher theSearcher = newSearcher(reader);
theSearcher.setSimilarity(new FullSimilarity());
- TopDocs hits = searcher.search(query, null, 100);
+ TopDocs hits = searcher.search(query, 100);
assertTrue("hits is null and it shouldn't be", hits != null);
assertTrue("hits Size: " + hits.totalHits + " is not: " + 100, hits.totalHits == 100);
@@ -267,7 +267,7 @@ public class TestPayloadTermQuery extend
public void testNoMatch() throws Exception {
PayloadTermQuery query = new PayloadTermQuery(new Term(PayloadHelper.FIELD, "junk"),
new MaxPayloadFunction());
- TopDocs hits = searcher.search(query, null, 100);
+ TopDocs hits = searcher.search(query, 100);
assertTrue("hits is null and it shouldn't be", hits != null);
assertTrue("hits Size: " + hits.totalHits + " is not: " + 0, hits.totalHits == 0);
@@ -283,7 +283,7 @@ public class TestPayloadTermQuery extend
BooleanQuery query = new BooleanQuery();
query.add(c1);
query.add(c2);
- TopDocs hits = searcher.search(query, null, 100);
+ TopDocs hits = searcher.search(query, 100);
assertTrue("hits is null and it shouldn't be", hits != null);
assertTrue("hits Size: " + hits.totalHits + " is not: " + 1, hits.totalHits == 1);
int[] results = new int[1];
Modified: lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/spans/TestSpansAdvanced.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/spans/TestSpansAdvanced.java?rev=1662059&r1=1662058&r2=1662059&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/spans/TestSpansAdvanced.java (original)
+++ lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/search/spans/TestSpansAdvanced.java Tue Feb 24 17:43:10 2015
@@ -136,7 +136,7 @@ public class TestSpansAdvanced extends L
// Hits hits = searcher.search(query);
// hits normalizes and throws things off if one score is greater than 1.0
- TopDocs topdocs = s.search(query, null, 10000);
+ TopDocs topdocs = s.search(query, 10000);
/*****
* // display the hits System.out.println(hits.length() +
Modified: lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/store/TestBufferedIndexInput.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/store/TestBufferedIndexInput.java?rev=1662059&r1=1662058&r2=1662059&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/store/TestBufferedIndexInput.java (original)
+++ lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/store/TestBufferedIndexInput.java Tue Feb 24 17:43:10 2015
@@ -237,7 +237,7 @@ public class TestBufferedIndexInput exte
writer.deleteDocuments(new Term("id", "0"));
reader = DirectoryReader.open(writer, true);
IndexSearcher searcher = newSearcher(reader);
- ScoreDoc[] hits = searcher.search(new TermQuery(bbb), null, 1000).scoreDocs;
+ ScoreDoc[] hits = searcher.search(new TermQuery(bbb), 1000).scoreDocs;
dir.tweakBufferSizes();
assertEquals(36, hits.length);
@@ -248,14 +248,14 @@ public class TestBufferedIndexInput exte
reader = DirectoryReader.open(writer, true);
searcher = newSearcher(reader);
- hits = searcher.search(new TermQuery(bbb), null, 1000).scoreDocs;
+ hits = searcher.search(new TermQuery(bbb), 1000).scoreDocs;
dir.tweakBufferSizes();
assertEquals(35, hits.length);
dir.tweakBufferSizes();
- hits = searcher.search(new TermQuery(new Term("id", "33")), null, 1000).scoreDocs;
+ hits = searcher.search(new TermQuery(new Term("id", "33")), 1000).scoreDocs;
dir.tweakBufferSizes();
assertEquals(1, hits.length);
- hits = searcher.search(new TermQuery(aaa), null, 1000).scoreDocs;
+ hits = searcher.search(new TermQuery(aaa), 1000).scoreDocs;
dir.tweakBufferSizes();
assertEquals(35, hits.length);
writer.close();
Modified: lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/store/TestLockFactory.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/store/TestLockFactory.java?rev=1662059&r1=1662058&r2=1662059&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/store/TestLockFactory.java (original)
+++ lucene/dev/trunk/lucene/core/src/test/org/apache/lucene/store/TestLockFactory.java Tue Feb 24 17:43:10 2015
@@ -280,7 +280,7 @@ public class TestLockFactory extends Luc
break;
}
try {
- searcher.search(query, null, 1000);
+ searcher.search(query, 1000);
} catch (IOException e) {
hitException = true;
System.out.println("Stress Test Index Searcher: search hit unexpected exception: " + e.toString());
Modified: lucene/dev/trunk/lucene/demo/src/java/org/apache/lucene/demo/SearchFiles.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/demo/src/java/org/apache/lucene/demo/SearchFiles.java?rev=1662059&r1=1662058&r2=1662059&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/demo/src/java/org/apache/lucene/demo/SearchFiles.java (original)
+++ lucene/dev/trunk/lucene/demo/src/java/org/apache/lucene/demo/SearchFiles.java Tue Feb 24 17:43:10 2015
@@ -120,7 +120,7 @@ public class SearchFiles {
if (repeat > 0) { // repeat & time as benchmark
Date start = new Date();
for (int i = 0; i < repeat; i++) {
- searcher.search(query, null, 100);
+ searcher.search(query, 100);
}
Date end = new Date();
System.out.println("Time: "+(end.getTime()-start.getTime())+"ms");
Modified: lucene/dev/trunk/lucene/demo/src/java/org/apache/lucene/demo/facet/SimpleFacetsExample.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/demo/src/java/org/apache/lucene/demo/facet/SimpleFacetsExample.java?rev=1662059&r1=1662058&r2=1662059&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/demo/src/java/org/apache/lucene/demo/facet/SimpleFacetsExample.java (original)
+++ lucene/dev/trunk/lucene/demo/src/java/org/apache/lucene/demo/facet/SimpleFacetsExample.java Tue Feb 24 17:43:10 2015
@@ -131,7 +131,7 @@ public class SimpleFacetsExample {
// MatchAllDocsQuery is for "browsing" (counts facets
// for all non-deleted docs in the index); normally
// you'd use a "normal" query:
- searcher.search(new MatchAllDocsQuery(), null /*Filter */, fc);
+ searcher.search(new MatchAllDocsQuery(), fc);
// Retrieve results
List<FacetResult> results = new ArrayList<>();
Modified: lucene/dev/trunk/lucene/expressions/src/test/org/apache/lucene/expressions/TestDemoExpressions.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/expressions/src/test/org/apache/lucene/expressions/TestDemoExpressions.java?rev=1662059&r1=1662058&r2=1662059&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/expressions/src/test/org/apache/lucene/expressions/TestDemoExpressions.java (original)
+++ lucene/dev/trunk/lucene/expressions/src/test/org/apache/lucene/expressions/TestDemoExpressions.java Tue Feb 24 17:43:10 2015
@@ -105,7 +105,7 @@ public class TestDemoExpressions extend
// create a sort field and sort by it (reverse order)
Sort sort = new Sort(expr.getSortField(bindings, true));
Query query = new TermQuery(new Term("body", "contents"));
- searcher.search(query, null, 3, sort);
+ searcher.search(query, 3, sort);
}
/** tests the returned sort values are correct */
@@ -117,7 +117,7 @@ public class TestDemoExpressions extend
Sort sort = new Sort(expr.getSortField(bindings, true));
Query query = new TermQuery(new Term("body", "contents"));
- TopFieldDocs td = searcher.search(query, null, 3, sort, true, true);
+ TopFieldDocs td = searcher.search(query, 3, sort, true, true);
for (int i = 0; i < 3; i++) {
FieldDoc d = (FieldDoc) td.scoreDocs[i];
float expected = (float) Math.sqrt(d.score);
@@ -135,7 +135,7 @@ public class TestDemoExpressions extend
Sort sort = new Sort(expr.getSortField(bindings, true));
Query query = new TermQuery(new Term("body", "contents"));
- TopFieldDocs td = searcher.search(query, null, 3, sort, true, true);
+ TopFieldDocs td = searcher.search(query, 3, sort, true, true);
for (int i = 0; i < 3; i++) {
FieldDoc d = (FieldDoc) td.scoreDocs[i];
float expected = 2*d.score;
@@ -154,7 +154,7 @@ public class TestDemoExpressions extend
Sort sort = new Sort(expr.getSortField(bindings, true));
Query query = new TermQuery(new Term("body", "contents"));
- TopFieldDocs td = searcher.search(query, null, 3, sort, true, true);
+ TopFieldDocs td = searcher.search(query, 3, sort, true, true);
for (int i = 0; i < 3; i++) {
FieldDoc d = (FieldDoc) td.scoreDocs[i];
float expected = 2*d.score;
@@ -174,7 +174,7 @@ public class TestDemoExpressions extend
Sort sort = new Sort(expr2.getSortField(bindings, true));
Query query = new TermQuery(new Term("body", "contents"));
- TopFieldDocs td = searcher.search(query, null, 3, sort, true, true);
+ TopFieldDocs td = searcher.search(query, 3, sort, true, true);
for (int i = 0; i < 3; i++) {
FieldDoc d = (FieldDoc) td.scoreDocs[i];
float expected = 2*d.score;
@@ -206,7 +206,7 @@ public class TestDemoExpressions extend
Expression expr = JavascriptCompiler.compile(sb.toString());
Sort sort = new Sort(expr.getSortField(bindings, true));
Query query = new TermQuery(new Term("body", "contents"));
- TopFieldDocs td = searcher.search(query, null, 3, sort, true, true);
+ TopFieldDocs td = searcher.search(query, 3, sort, true, true);
for (int i = 0; i < 3; i++) {
FieldDoc d = (FieldDoc) td.scoreDocs[i];
float expected = n*d.score;
@@ -221,7 +221,7 @@ public class TestDemoExpressions extend
bindings.add(new SortField("latitude", SortField.Type.DOUBLE));
bindings.add(new SortField("longitude", SortField.Type.DOUBLE));
Sort sort = new Sort(distance.getSortField(bindings, false));
- TopFieldDocs td = searcher.search(new MatchAllDocsQuery(), null, 3, sort);
+ TopFieldDocs td = searcher.search(new MatchAllDocsQuery(), 3, sort);
FieldDoc d = (FieldDoc) td.scoreDocs[0];
assertEquals(0.4619D, (Double)d.fields[0], 1E-4);
@@ -238,7 +238,7 @@ public class TestDemoExpressions extend
SimpleBindings bindings = new SimpleBindings();
bindings.add("doc['popularity'].value", new IntFieldSource("popularity"));
Sort sort = new Sort(popularity.getSortField(bindings, true));
- TopFieldDocs td = searcher.search(new MatchAllDocsQuery(), null, 3, sort);
+ TopFieldDocs td = searcher.search(new MatchAllDocsQuery(), 3, sort);
FieldDoc d = (FieldDoc)td.scoreDocs[0];
assertEquals(20D, (Double)d.fields[0], 1E-4);
@@ -288,7 +288,7 @@ public class TestDemoExpressions extend
}
};
Sort sort = new Sort(popularity.getSortField(bindings, false));
- TopFieldDocs td = searcher.search(new MatchAllDocsQuery(), null, 3, sort);
+ TopFieldDocs td = searcher.search(new MatchAllDocsQuery(), 3, sort);
FieldDoc d = (FieldDoc)td.scoreDocs[0];
assertEquals(2092D, (Double)d.fields[0], 1E-4);
Modified: lucene/dev/trunk/lucene/expressions/src/test/org/apache/lucene/expressions/TestExpressionSorts.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/expressions/src/test/org/apache/lucene/expressions/TestExpressionSorts.java?rev=1662059&r1=1662058&r2=1662059&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/expressions/src/test/org/apache/lucene/expressions/TestExpressionSorts.java (original)
+++ lucene/dev/trunk/lucene/expressions/src/test/org/apache/lucene/expressions/TestExpressionSorts.java Tue Feb 24 17:43:10 2015
@@ -86,23 +86,20 @@ public class TestExpressionSorts extends
public void testQueries() throws Exception {
int n = atLeast(4);
for (int i = 0; i < n; i++) {
- Filter odd = new QueryWrapperFilter(new TermQuery(new Term("oddeven", "odd")));
- assertQuery(new MatchAllDocsQuery(), null);
- assertQuery(new TermQuery(new Term("english", "one")), null);
- assertQuery(new MatchAllDocsQuery(), odd);
- assertQuery(new TermQuery(new Term("english", "four")), odd);
+ assertQuery(new MatchAllDocsQuery());
+ assertQuery(new TermQuery(new Term("english", "one")));
BooleanQuery bq = new BooleanQuery();
bq.add(new TermQuery(new Term("english", "one")), BooleanClause.Occur.SHOULD);
bq.add(new TermQuery(new Term("oddeven", "even")), BooleanClause.Occur.SHOULD);
- assertQuery(bq, null);
+ assertQuery(bq);
// force in order
bq.add(new TermQuery(new Term("english", "two")), BooleanClause.Occur.SHOULD);
bq.setMinimumNumberShouldMatch(2);
- assertQuery(bq, null);
+ assertQuery(bq);
}
}
- void assertQuery(Query query, Filter filter) throws Exception {
+ void assertQuery(Query query) throws Exception {
for (int i = 0; i < 10; i++) {
boolean reversed = random().nextBoolean();
SortField fields[] = new SortField[] {
@@ -114,13 +111,13 @@ public class TestExpressionSorts extends
};
Collections.shuffle(Arrays.asList(fields), random());
int numSorts = TestUtil.nextInt(random(), 1, fields.length);
- assertQuery(query, filter, new Sort(Arrays.copyOfRange(fields, 0, numSorts)));
+ assertQuery(query, new Sort(Arrays.copyOfRange(fields, 0, numSorts)));
}
}
- void assertQuery(Query query, Filter filter, Sort sort) throws Exception {
+ void assertQuery(Query query, Sort sort) throws Exception {
int size = TestUtil.nextInt(random(), 1, searcher.getIndexReader().maxDoc() / 5);
- TopDocs expected = searcher.search(query, filter, size, sort, random().nextBoolean(), random().nextBoolean());
+ TopDocs expected = searcher.search(query, size, sort, random().nextBoolean(), random().nextBoolean());
// make our actual sort, mutating original by replacing some of the
// sortfields with equivalent expressions
@@ -141,12 +138,12 @@ public class TestExpressionSorts extends
}
Sort mutatedSort = new Sort(mutated);
- TopDocs actual = searcher.search(query, filter, size, mutatedSort, random().nextBoolean(), random().nextBoolean());
+ TopDocs actual = searcher.search(query, size, mutatedSort, random().nextBoolean(), random().nextBoolean());
CheckHits.checkEqual(query, expected.scoreDocs, actual.scoreDocs);
if (size < actual.totalHits) {
- expected = searcher.searchAfter(expected.scoreDocs[size-1], query, filter, size, sort);
- actual = searcher.searchAfter(actual.scoreDocs[size-1], query, filter, size, mutatedSort);
+ expected = searcher.searchAfter(expected.scoreDocs[size-1], query, size, sort);
+ actual = searcher.searchAfter(actual.scoreDocs[size-1], query, size, mutatedSort);
CheckHits.checkEqual(query, expected.scoreDocs, actual.scoreDocs);
}
}
Modified: lucene/dev/trunk/lucene/facet/src/test/org/apache/lucene/facet/TestDrillSideways.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/facet/src/test/org/apache/lucene/facet/TestDrillSideways.java?rev=1662059&r1=1662058&r2=1662059&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/facet/src/test/org/apache/lucene/facet/TestDrillSideways.java (original)
+++ lucene/dev/trunk/lucene/facet/src/test/org/apache/lucene/facet/TestDrillSideways.java Tue Feb 24 17:43:10 2015
@@ -46,6 +46,7 @@ import org.apache.lucene.index.RandomInd
import org.apache.lucene.index.Term;
import org.apache.lucene.search.DocIdSet;
import org.apache.lucene.search.Filter;
+import org.apache.lucene.search.FilteredQuery;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.MatchAllDocsQuery;
import org.apache.lucene.search.Query;
@@ -752,7 +753,11 @@ public class TestDrillSideways extends F
verifyEquals(dimValues, s, expected, actual, scores, doUseDV);
// Make sure drill down doesn't change score:
- TopDocs ddqHits = s.search(ddq, filter, numDocs);
+ Query q = ddq;
+ if (filter != null) {
+ q = new FilteredQuery(q, filter);
+ }
+ TopDocs ddqHits = s.search(q, numDocs);
assertEquals(expected.hits.size(), ddqHits.totalHits);
for(int i=0;i<expected.hits.size();i++) {
// Score should be IDENTICAL:
Modified: lucene/dev/trunk/lucene/grouping/src/java/org/apache/lucene/search/grouping/GroupingSearch.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/grouping/src/java/org/apache/lucene/search/grouping/GroupingSearch.java?rev=1662059&r1=1662058&r2=1662059&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/grouping/src/java/org/apache/lucene/search/grouping/GroupingSearch.java (original)
+++ lucene/dev/trunk/lucene/grouping/src/java/org/apache/lucene/search/grouping/GroupingSearch.java Tue Feb 24 17:43:10 2015
@@ -124,34 +124,19 @@ public class GroupingSearch {
* @return the grouped result as a {@link TopGroups} instance
* @throws IOException If any I/O related errors occur
*/
- public <T> TopGroups<T> search(IndexSearcher searcher, Query query, int groupOffset, int groupLimit) throws IOException {
- return search(searcher, null, query, groupOffset, groupLimit);
- }
-
- /**
- * Executes a grouped search. Both the first pass and second pass are executed on the specified searcher.
- *
- * @param searcher The {@link org.apache.lucene.search.IndexSearcher} instance to execute the grouped search on.
- * @param filter The filter to execute with the grouping
- * @param query The query to execute with the grouping
- * @param groupOffset The group offset
- * @param groupLimit The number of groups to return from the specified group offset
- * @return the grouped result as a {@link TopGroups} instance
- * @throws IOException If any I/O related errors occur
- */
@SuppressWarnings("unchecked")
- public <T> TopGroups<T> search(IndexSearcher searcher, Filter filter, Query query, int groupOffset, int groupLimit) throws IOException {
+ public <T> TopGroups<T> search(IndexSearcher searcher, Query query, int groupOffset, int groupLimit) throws IOException {
if (groupField != null || groupFunction != null) {
- return groupByFieldOrFunction(searcher, filter, query, groupOffset, groupLimit);
+ return groupByFieldOrFunction(searcher, query, groupOffset, groupLimit);
} else if (groupEndDocs != null) {
- return (TopGroups<T>) groupByDocBlock(searcher, filter, query, groupOffset, groupLimit);
+ return (TopGroups<T>) groupByDocBlock(searcher, query, groupOffset, groupLimit);
} else {
throw new IllegalStateException("Either groupField, groupFunction or groupEndDocs must be set."); // This can't happen...
}
}
@SuppressWarnings({"unchecked", "rawtypes"})
- protected TopGroups groupByFieldOrFunction(IndexSearcher searcher, Filter filter, Query query, int groupOffset, int groupLimit) throws IOException {
+ protected TopGroups groupByFieldOrFunction(IndexSearcher searcher, Query query, int groupOffset, int groupLimit) throws IOException {
int topN = groupOffset + groupLimit;
final AbstractFirstPassGroupingCollector firstPassCollector;
final AbstractAllGroupsCollector allGroupsCollector;
@@ -204,9 +189,9 @@ public class GroupingSearch {
} else {
cachedCollector = CachingCollector.create(firstRound, cacheScores, maxDocsToCache);
}
- searcher.search(query, filter, cachedCollector);
+ searcher.search(query, cachedCollector);
} else {
- searcher.search(query, filter, firstRound);
+ searcher.search(query, firstRound);
}
if (allGroups) {
@@ -236,7 +221,7 @@ public class GroupingSearch {
if (cachedCollector != null && cachedCollector.isCached()) {
cachedCollector.replay(secondPassCollector);
} else {
- searcher.search(query, filter, secondPassCollector);
+ searcher.search(query, secondPassCollector);
}
if (allGroups) {
@@ -246,10 +231,10 @@ public class GroupingSearch {
}
}
- protected TopGroups<?> groupByDocBlock(IndexSearcher searcher, Filter filter, Query query, int groupOffset, int groupLimit) throws IOException {
+ protected TopGroups<?> groupByDocBlock(IndexSearcher searcher, Query query, int groupOffset, int groupLimit) throws IOException {
int topN = groupOffset + groupLimit;
BlockGroupingCollector c = new BlockGroupingCollector(groupSort, topN, includeScores, groupEndDocs);
- searcher.search(query, filter, c);
+ searcher.search(query, c);
int topNInsideGroup = groupDocsOffset + groupDocsLimit;
return c.getTopGroups(sortWithinGroup, groupOffset, groupDocsOffset, topNInsideGroup, fillSortFields);
}
Modified: lucene/dev/trunk/lucene/grouping/src/test/org/apache/lucene/search/grouping/GroupingSearchTest.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/grouping/src/test/org/apache/lucene/search/grouping/GroupingSearchTest.java?rev=1662059&r1=1662058&r2=1662059&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/grouping/src/test/org/apache/lucene/search/grouping/GroupingSearchTest.java (original)
+++ lucene/dev/trunk/lucene/grouping/src/test/org/apache/lucene/search/grouping/GroupingSearchTest.java Tue Feb 24 17:43:10 2015
@@ -123,7 +123,7 @@ public class GroupingSearchTest extends
Sort groupSort = Sort.RELEVANCE;
GroupingSearch groupingSearch = createRandomGroupingSearch(groupField, groupSort, 5, canUseIDV);
- TopGroups<?> groups = groupingSearch.search(indexSearcher, null, new TermQuery(new Term("content", "random")), 0, 10);
+ TopGroups<?> groups = groupingSearch.search(indexSearcher, new TermQuery(new Term("content", "random")), 0, 10);
assertEquals(7, groups.totalHitCount);
assertEquals(7, groups.totalGroupedHitCount);
@@ -161,7 +161,7 @@ public class GroupingSearchTest extends
Filter lastDocInBlock = new CachingWrapperFilter(new QueryWrapperFilter(new TermQuery(new Term("groupend", "x"))));
groupingSearch = new GroupingSearch(lastDocInBlock);
- groups = groupingSearch.search(indexSearcher, null, new TermQuery(new Term("content", "random")), 0, 10);
+ groups = groupingSearch.search(indexSearcher, new TermQuery(new Term("content", "random")), 0, 10);
assertEquals(7, groups.totalHitCount);
assertEquals(7, groups.totalGroupedHitCount);
@@ -237,7 +237,7 @@ public class GroupingSearchTest extends
GroupingSearch gs = new GroupingSearch("group");
gs.setAllGroups(true);
- TopGroups<?> groups = gs.search(indexSearcher, null, new TermQuery(new Term("group", "foo")), 0, 10);
+ TopGroups<?> groups = gs.search(indexSearcher, new TermQuery(new Term("group", "foo")), 0, 10);
assertEquals(1, groups.totalHitCount);
//assertEquals(1, groups.totalGroupCount.intValue());
assertEquals(1, groups.totalGroupedHitCount);
Modified: lucene/dev/trunk/lucene/highlighter/src/test/org/apache/lucene/search/highlight/HighlighterTest.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/highlighter/src/test/org/apache/lucene/search/highlight/HighlighterTest.java?rev=1662059&r1=1662058&r2=1662059&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/highlighter/src/test/org/apache/lucene/search/highlight/HighlighterTest.java (original)
+++ lucene/dev/trunk/lucene/highlighter/src/test/org/apache/lucene/search/highlight/HighlighterTest.java Tue Feb 24 17:43:10 2015
@@ -1014,7 +1014,7 @@ public class HighlighterTest extends Bas
// it rewrites to ConstantScoreQuery which cannot be highlighted
// query = unReWrittenQuery.rewrite(reader);
if (VERBOSE) System.out.println("Searching for: " + query.toString(FIELD_NAME));
- hits = searcher.search(query, null, 1000);
+ hits = searcher.search(query, 1000);
for (int i = 0; i < hits.totalHits; i++) {
final StoredDocument doc = searcher.doc(hits.scoreDocs[i].doc);
@@ -1036,7 +1036,7 @@ public class HighlighterTest extends Bas
// try null field
- hits = searcher.search(query, null, 1000);
+ hits = searcher.search(query, 1000);
numHighlights = 0;
@@ -1061,7 +1061,7 @@ public class HighlighterTest extends Bas
// try default field
- hits = searcher.search(query, null, 1000);
+ hits = searcher.search(query, 1000);
numHighlights = 0;
@@ -1541,7 +1541,7 @@ public class HighlighterTest extends Bas
if (VERBOSE) System.out.println("Searching with primitive query");
// forget to set this and...
// query=query.rewrite(reader);
- TopDocs hits = searcher.search(query, null, 1000);
+ TopDocs hits = searcher.search(query, 1000);
// create an instance of the highlighter with the tags used to surround
// highlighted text
@@ -1913,7 +1913,7 @@ public class HighlighterTest extends Bas
//Scorer scorer = new QueryTermScorer( query, "t_text1" );
Highlighter h = new Highlighter( scorer );
- TopDocs hits = searcher.search(query, null, 10);
+ TopDocs hits = searcher.search(query, 10);
for( int i = 0; i < hits.totalHits; i++ ){
StoredDocument doc = searcher.doc( hits.scoreDocs[i].doc );
String result = h.getBestFragment( a, "t_text1", doc.get( "t_text1" ));
@@ -1944,7 +1944,7 @@ public class HighlighterTest extends Bas
scorer.setUsePayloads(true);
Highlighter h = new Highlighter(scorer);
- TopDocs hits = searcher.search(query, null, 10);
+ TopDocs hits = searcher.search(query, 10);
assertEquals(1, hits.scoreDocs.length);
TokenStream stream = TokenSources.getAnyTokenStream(searcher.getIndexReader(), 0, FIELD_NAME, analyzer);
if (random().nextBoolean()) {
@@ -1996,7 +1996,7 @@ public class HighlighterTest extends Bas
// you must use a rewritten query!
query = unReWrittenQuery.rewrite(reader);
if (VERBOSE) System.out.println("Searching for: " + query.toString(FIELD_NAME));
- hits = searcher.search(query, null, 1000);
+ hits = searcher.search(query, 1000);
}
public void assertExpectedHighlightCount(final int maxNumFragmentsRequired,
Modified: lucene/dev/trunk/lucene/highlighter/src/test/org/apache/lucene/search/postingshighlight/TestMultiTermHighlighting.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/highlighter/src/test/org/apache/lucene/search/postingshighlight/TestMultiTermHighlighting.java?rev=1662059&r1=1662058&r2=1662059&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/highlighter/src/test/org/apache/lucene/search/postingshighlight/TestMultiTermHighlighting.java (original)
+++ lucene/dev/trunk/lucene/highlighter/src/test/org/apache/lucene/search/postingshighlight/TestMultiTermHighlighting.java Tue Feb 24 17:43:10 2015
@@ -92,7 +92,7 @@ public class TestMultiTermHighlighting e
}
};
Query query = new WildcardQuery(new Term("body", "te*"));
- TopDocs topDocs = searcher.search(query, null, 10, Sort.INDEXORDER);
+ TopDocs topDocs = searcher.search(query, 10, Sort.INDEXORDER);
assertEquals(2, topDocs.totalHits);
String snippets[] = highlighter.highlight("body", query, searcher, topDocs);
assertEquals(2, snippets.length);
@@ -103,7 +103,7 @@ public class TestMultiTermHighlighting e
BooleanQuery bq = new BooleanQuery();
bq.add(new MatchAllDocsQuery(), BooleanClause.Occur.SHOULD);
bq.add(new WildcardQuery(new Term("bogus", "te*")), BooleanClause.Occur.SHOULD);
- topDocs = searcher.search(bq, null, 10, Sort.INDEXORDER);
+ topDocs = searcher.search(bq, 10, Sort.INDEXORDER);
assertEquals(2, topDocs.totalHits);
snippets = highlighter.highlight("body", bq, searcher, topDocs);
assertEquals(2, snippets.length);
@@ -144,7 +144,7 @@ public class TestMultiTermHighlighting e
}
};
Query query = new PrefixQuery(new Term("body", "te"));
- TopDocs topDocs = searcher.search(query, null, 10, Sort.INDEXORDER);
+ TopDocs topDocs = searcher.search(query, 10, Sort.INDEXORDER);
assertEquals(2, topDocs.totalHits);
String snippets[] = highlighter.highlight("body", query, searcher, topDocs);
assertEquals(2, snippets.length);
@@ -155,7 +155,7 @@ public class TestMultiTermHighlighting e
BooleanQuery bq = new BooleanQuery();
bq.add(new MatchAllDocsQuery(), BooleanClause.Occur.SHOULD);
bq.add(new PrefixQuery(new Term("bogus", "te")), BooleanClause.Occur.SHOULD);
- topDocs = searcher.search(bq, null, 10, Sort.INDEXORDER);
+ topDocs = searcher.search(bq, 10, Sort.INDEXORDER);
assertEquals(2, topDocs.totalHits);
snippets = highlighter.highlight("body", bq, searcher, topDocs);
assertEquals(2, snippets.length);
@@ -196,7 +196,7 @@ public class TestMultiTermHighlighting e
}
};
Query query = new RegexpQuery(new Term("body", "te.*"));
- TopDocs topDocs = searcher.search(query, null, 10, Sort.INDEXORDER);
+ TopDocs topDocs = searcher.search(query, 10, Sort.INDEXORDER);
assertEquals(2, topDocs.totalHits);
String snippets[] = highlighter.highlight("body", query, searcher, topDocs);
assertEquals(2, snippets.length);
@@ -207,7 +207,7 @@ public class TestMultiTermHighlighting e
BooleanQuery bq = new BooleanQuery();
bq.add(new MatchAllDocsQuery(), BooleanClause.Occur.SHOULD);
bq.add(new RegexpQuery(new Term("bogus", "te.*")), BooleanClause.Occur.SHOULD);
- topDocs = searcher.search(bq, null, 10, Sort.INDEXORDER);
+ topDocs = searcher.search(bq, 10, Sort.INDEXORDER);
assertEquals(2, topDocs.totalHits);
snippets = highlighter.highlight("body", bq, searcher, topDocs);
assertEquals(2, snippets.length);
@@ -248,7 +248,7 @@ public class TestMultiTermHighlighting e
}
};
Query query = new FuzzyQuery(new Term("body", "tets"), 1);
- TopDocs topDocs = searcher.search(query, null, 10, Sort.INDEXORDER);
+ TopDocs topDocs = searcher.search(query, 10, Sort.INDEXORDER);
assertEquals(2, topDocs.totalHits);
String snippets[] = highlighter.highlight("body", query, searcher, topDocs);
assertEquals(2, snippets.length);
@@ -257,7 +257,7 @@ public class TestMultiTermHighlighting e
// with prefix
query = new FuzzyQuery(new Term("body", "tets"), 1, 2);
- topDocs = searcher.search(query, null, 10, Sort.INDEXORDER);
+ topDocs = searcher.search(query, 10, Sort.INDEXORDER);
assertEquals(2, topDocs.totalHits);
snippets = highlighter.highlight("body", query, searcher, topDocs);
assertEquals(2, snippets.length);
@@ -268,7 +268,7 @@ public class TestMultiTermHighlighting e
BooleanQuery bq = new BooleanQuery();
bq.add(new MatchAllDocsQuery(), BooleanClause.Occur.SHOULD);
bq.add(new FuzzyQuery(new Term("bogus", "tets"), 1), BooleanClause.Occur.SHOULD);
- topDocs = searcher.search(bq, null, 10, Sort.INDEXORDER);
+ topDocs = searcher.search(bq, 10, Sort.INDEXORDER);
assertEquals(2, topDocs.totalHits);
snippets = highlighter.highlight("body", bq, searcher, topDocs);
assertEquals(2, snippets.length);
@@ -309,7 +309,7 @@ public class TestMultiTermHighlighting e
}
};
Query query = TermRangeQuery.newStringRange("body", "ta", "tf", true, true);
- TopDocs topDocs = searcher.search(query, null, 10, Sort.INDEXORDER);
+ TopDocs topDocs = searcher.search(query, 10, Sort.INDEXORDER);
assertEquals(2, topDocs.totalHits);
String snippets[] = highlighter.highlight("body", query, searcher, topDocs);
assertEquals(2, snippets.length);
@@ -318,7 +318,7 @@ public class TestMultiTermHighlighting e
// null start
query = TermRangeQuery.newStringRange("body", null, "tf", true, true);
- topDocs = searcher.search(query, null, 10, Sort.INDEXORDER);
+ topDocs = searcher.search(query, 10, Sort.INDEXORDER);
assertEquals(2, topDocs.totalHits);
snippets = highlighter.highlight("body", query, searcher, topDocs);
assertEquals(2, snippets.length);
@@ -327,7 +327,7 @@ public class TestMultiTermHighlighting e
// null end
query = TermRangeQuery.newStringRange("body", "ta", null, true, true);
- topDocs = searcher.search(query, null, 10, Sort.INDEXORDER);
+ topDocs = searcher.search(query, 10, Sort.INDEXORDER);
assertEquals(2, topDocs.totalHits);
snippets = highlighter.highlight("body", query, searcher, topDocs);
assertEquals(2, snippets.length);
@@ -336,7 +336,7 @@ public class TestMultiTermHighlighting e
// exact start inclusive
query = TermRangeQuery.newStringRange("body", "test", "tf", true, true);
- topDocs = searcher.search(query, null, 10, Sort.INDEXORDER);
+ topDocs = searcher.search(query, 10, Sort.INDEXORDER);
assertEquals(2, topDocs.totalHits);
snippets = highlighter.highlight("body", query, searcher, topDocs);
assertEquals(2, snippets.length);
@@ -345,7 +345,7 @@ public class TestMultiTermHighlighting e
// exact end inclusive
query = TermRangeQuery.newStringRange("body", "ta", "test", true, true);
- topDocs = searcher.search(query, null, 10, Sort.INDEXORDER);
+ topDocs = searcher.search(query, 10, Sort.INDEXORDER);
assertEquals(2, topDocs.totalHits);
snippets = highlighter.highlight("body", query, searcher, topDocs);
assertEquals(2, snippets.length);
@@ -356,7 +356,7 @@ public class TestMultiTermHighlighting e
BooleanQuery bq = new BooleanQuery();
bq.add(new MatchAllDocsQuery(), BooleanClause.Occur.SHOULD);
bq.add(TermRangeQuery.newStringRange("body", "test", "tf", false, true), BooleanClause.Occur.SHOULD);
- topDocs = searcher.search(bq, null, 10, Sort.INDEXORDER);
+ topDocs = searcher.search(bq, 10, Sort.INDEXORDER);
assertEquals(2, topDocs.totalHits);
snippets = highlighter.highlight("body", bq, searcher, topDocs);
assertEquals(2, snippets.length);
@@ -367,7 +367,7 @@ public class TestMultiTermHighlighting e
bq = new BooleanQuery();
bq.add(new MatchAllDocsQuery(), BooleanClause.Occur.SHOULD);
bq.add(TermRangeQuery.newStringRange("body", "ta", "test", true, false), BooleanClause.Occur.SHOULD);
- topDocs = searcher.search(bq, null, 10, Sort.INDEXORDER);
+ topDocs = searcher.search(bq, 10, Sort.INDEXORDER);
assertEquals(2, topDocs.totalHits);
snippets = highlighter.highlight("body", bq, searcher, topDocs);
assertEquals(2, snippets.length);
@@ -378,7 +378,7 @@ public class TestMultiTermHighlighting e
bq = new BooleanQuery();
bq.add(new MatchAllDocsQuery(), BooleanClause.Occur.SHOULD);
bq.add(TermRangeQuery.newStringRange("bogus", "ta", "tf", true, true), BooleanClause.Occur.SHOULD);
- topDocs = searcher.search(bq, null, 10, Sort.INDEXORDER);
+ topDocs = searcher.search(bq, 10, Sort.INDEXORDER);
assertEquals(2, topDocs.totalHits);
snippets = highlighter.highlight("body", bq, searcher, topDocs);
assertEquals(2, snippets.length);
@@ -420,7 +420,7 @@ public class TestMultiTermHighlighting e
};
BooleanQuery query = new BooleanQuery();
query.add(new WildcardQuery(new Term("body", "te*")), BooleanClause.Occur.SHOULD);
- TopDocs topDocs = searcher.search(query, null, 10, Sort.INDEXORDER);
+ TopDocs topDocs = searcher.search(query, 10, Sort.INDEXORDER);
assertEquals(2, topDocs.totalHits);
String snippets[] = highlighter.highlight("body", query, searcher, topDocs);
assertEquals(2, snippets.length);
@@ -431,7 +431,7 @@ public class TestMultiTermHighlighting e
query = new BooleanQuery();
query.add(new MatchAllDocsQuery(), BooleanClause.Occur.SHOULD);
query.add(new WildcardQuery(new Term("bogus", "te*")), BooleanClause.Occur.MUST_NOT);
- topDocs = searcher.search(query, null, 10, Sort.INDEXORDER);
+ topDocs = searcher.search(query, 10, Sort.INDEXORDER);
assertEquals(2, topDocs.totalHits);
snippets = highlighter.highlight("body", query, searcher, topDocs);
assertEquals(2, snippets.length);
@@ -474,7 +474,7 @@ public class TestMultiTermHighlighting e
FilteredQuery query = new FilteredQuery(
new WildcardQuery(new Term("body", "te*")),
new QueryWrapperFilter(new TermQuery(new Term("body", "test"))));
- TopDocs topDocs = searcher.search(query, null, 10, Sort.INDEXORDER);
+ TopDocs topDocs = searcher.search(query, 10, Sort.INDEXORDER);
assertEquals(2, topDocs.totalHits);
String snippets[] = highlighter.highlight("body", query, searcher, topDocs);
assertEquals(2, snippets.length);
@@ -515,7 +515,7 @@ public class TestMultiTermHighlighting e
}
};
ConstantScoreQuery query = new ConstantScoreQuery(new WildcardQuery(new Term("body", "te*")));
- TopDocs topDocs = searcher.search(query, null, 10, Sort.INDEXORDER);
+ TopDocs topDocs = searcher.search(query, 10, Sort.INDEXORDER);
assertEquals(2, topDocs.totalHits);
String snippets[] = highlighter.highlight("body", query, searcher, topDocs);
assertEquals(2, snippets.length);
@@ -557,7 +557,7 @@ public class TestMultiTermHighlighting e
};
DisjunctionMaxQuery query = new DisjunctionMaxQuery(0);
query.add(new WildcardQuery(new Term("body", "te*")));
- TopDocs topDocs = searcher.search(query, null, 10, Sort.INDEXORDER);
+ TopDocs topDocs = searcher.search(query, 10, Sort.INDEXORDER);
assertEquals(2, topDocs.totalHits);
String snippets[] = highlighter.highlight("body", query, searcher, topDocs);
assertEquals(2, snippets.length);
@@ -598,7 +598,7 @@ public class TestMultiTermHighlighting e
}
};
Query query = new SpanMultiTermQueryWrapper<>(new WildcardQuery(new Term("body", "te*")));
- TopDocs topDocs = searcher.search(query, null, 10, Sort.INDEXORDER);
+ TopDocs topDocs = searcher.search(query, 10, Sort.INDEXORDER);
assertEquals(2, topDocs.totalHits);
String snippets[] = highlighter.highlight("body", query, searcher, topDocs);
assertEquals(2, snippets.length);
@@ -640,7 +640,7 @@ public class TestMultiTermHighlighting e
};
SpanQuery childQuery = new SpanMultiTermQueryWrapper<>(new WildcardQuery(new Term("body", "te*")));
Query query = new SpanOrQuery(new SpanQuery[] { childQuery });
- TopDocs topDocs = searcher.search(query, null, 10, Sort.INDEXORDER);
+ TopDocs topDocs = searcher.search(query, 10, Sort.INDEXORDER);
assertEquals(2, topDocs.totalHits);
String snippets[] = highlighter.highlight("body", query, searcher, topDocs);
assertEquals(2, snippets.length);
@@ -682,7 +682,7 @@ public class TestMultiTermHighlighting e
};
SpanQuery childQuery = new SpanMultiTermQueryWrapper<>(new WildcardQuery(new Term("body", "te*")));
Query query = new SpanNearQuery(new SpanQuery[] { childQuery }, 0, true);
- TopDocs topDocs = searcher.search(query, null, 10, Sort.INDEXORDER);
+ TopDocs topDocs = searcher.search(query, 10, Sort.INDEXORDER);
assertEquals(2, topDocs.totalHits);
String snippets[] = highlighter.highlight("body", query, searcher, topDocs);
assertEquals(2, snippets.length);
@@ -725,7 +725,7 @@ public class TestMultiTermHighlighting e
SpanQuery include = new SpanMultiTermQueryWrapper<>(new WildcardQuery(new Term("body", "te*")));
SpanQuery exclude = new SpanTermQuery(new Term("body", "bogus"));
Query query = new SpanNotQuery(include, exclude);
- TopDocs topDocs = searcher.search(query, null, 10, Sort.INDEXORDER);
+ TopDocs topDocs = searcher.search(query, 10, Sort.INDEXORDER);
assertEquals(2, topDocs.totalHits);
String snippets[] = highlighter.highlight("body", query, searcher, topDocs);
assertEquals(2, snippets.length);
@@ -767,7 +767,7 @@ public class TestMultiTermHighlighting e
};
SpanQuery childQuery = new SpanMultiTermQueryWrapper<>(new WildcardQuery(new Term("body", "te*")));
Query query = new SpanFirstQuery(childQuery, 1000000);
- TopDocs topDocs = searcher.search(query, null, 10, Sort.INDEXORDER);
+ TopDocs topDocs = searcher.search(query, 10, Sort.INDEXORDER);
assertEquals(2, topDocs.totalHits);
String snippets[] = highlighter.highlight("body", query, searcher, topDocs);
assertEquals(2, snippets.length);
@@ -811,7 +811,7 @@ public class TestMultiTermHighlighting e
query.add(new WildcardQuery(new Term("body", "te*")), BooleanClause.Occur.SHOULD);
query.add(new WildcardQuery(new Term("body", "one")), BooleanClause.Occur.SHOULD);
query.add(new WildcardQuery(new Term("body", "se*")), BooleanClause.Occur.SHOULD);
- TopDocs topDocs = searcher.search(query, null, 10, Sort.INDEXORDER);
+ TopDocs topDocs = searcher.search(query, 10, Sort.INDEXORDER);
assertEquals(1, topDocs.totalHits);
String snippets[] = highlighter.highlight("body", query, searcher, topDocs);
assertEquals(1, snippets.length);
Modified: lucene/dev/trunk/lucene/highlighter/src/test/org/apache/lucene/search/postingshighlight/TestPostingsHighlighter.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/highlighter/src/test/org/apache/lucene/search/postingshighlight/TestPostingsHighlighter.java?rev=1662059&r1=1662058&r2=1662059&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/highlighter/src/test/org/apache/lucene/search/postingshighlight/TestPostingsHighlighter.java (original)
+++ lucene/dev/trunk/lucene/highlighter/src/test/org/apache/lucene/search/postingshighlight/TestPostingsHighlighter.java Tue Feb 24 17:43:10 2015
@@ -76,7 +76,7 @@ public class TestPostingsHighlighter ext
IndexSearcher searcher = newSearcher(ir);
PostingsHighlighter highlighter = new PostingsHighlighter();
Query query = new TermQuery(new Term("body", "highlighting"));
- TopDocs topDocs = searcher.search(query, null, 10, Sort.INDEXORDER);
+ TopDocs topDocs = searcher.search(query, 10, Sort.INDEXORDER);
assertEquals(2, topDocs.totalHits);
String snippets[] = highlighter.highlight("body", query, searcher, topDocs);
assertEquals(2, snippets.length);
@@ -145,7 +145,7 @@ public class TestPostingsHighlighter ext
Query query = new TermQuery(new Term("body", "test"));
- TopDocs topDocs = searcher.search(query, null, 10, Sort.INDEXORDER);
+ TopDocs topDocs = searcher.search(query, 10, Sort.INDEXORDER);
assertEquals(1, topDocs.totalHits);
PostingsHighlighter highlighter = new PostingsHighlighter(maxLength);
@@ -179,7 +179,7 @@ public class TestPostingsHighlighter ext
IndexSearcher searcher = newSearcher(ir);
PostingsHighlighter highlighter = new PostingsHighlighter();
Query query = new TermQuery(new Term("body", "test"));
- TopDocs topDocs = searcher.search(query, null, 10, Sort.INDEXORDER);
+ TopDocs topDocs = searcher.search(query, 10, Sort.INDEXORDER);
assertEquals(1, topDocs.totalHits);
String snippets[] = highlighter.highlight("body", query, searcher, topDocs);
assertEquals(1, snippets.length);
@@ -214,7 +214,7 @@ public class TestPostingsHighlighter ext
IndexSearcher searcher = newSearcher(ir);
PostingsHighlighter highlighter = new PostingsHighlighter();
Query query = new TermQuery(new Term("body", "test"));
- TopDocs topDocs = searcher.search(query, null, 10, Sort.INDEXORDER);
+ TopDocs topDocs = searcher.search(query, 10, Sort.INDEXORDER);
assertEquals(2, topDocs.totalHits);
String snippets[] = highlighter.highlight("body", query, searcher, topDocs);
assertEquals(2, snippets.length);
@@ -251,7 +251,7 @@ public class TestPostingsHighlighter ext
IndexSearcher searcher = newSearcher(ir);
PostingsHighlighter highlighter = new PostingsHighlighter(40);
Query query = new TermQuery(new Term("body", "field"));
- TopDocs topDocs = searcher.search(query, null, 10, Sort.INDEXORDER);
+ TopDocs topDocs = searcher.search(query, 10, Sort.INDEXORDER);
assertEquals(1, topDocs.totalHits);
String snippets[] = highlighter.highlight("body", query, searcher, topDocs);
assertEquals(1, snippets.length);
@@ -291,7 +291,7 @@ public class TestPostingsHighlighter ext
BooleanQuery query = new BooleanQuery();
query.add(new TermQuery(new Term("body", "highlighting")), BooleanClause.Occur.SHOULD);
query.add(new TermQuery(new Term("title", "best")), BooleanClause.Occur.SHOULD);
- TopDocs topDocs = searcher.search(query, null, 10, Sort.INDEXORDER);
+ TopDocs topDocs = searcher.search(query, 10, Sort.INDEXORDER);
assertEquals(2, topDocs.totalHits);
Map<String,String[]> snippets = highlighter.highlightFields(new String [] { "body", "title" }, query, searcher, topDocs);
assertEquals(2, snippets.size());
@@ -329,7 +329,7 @@ public class TestPostingsHighlighter ext
query.add(new TermQuery(new Term("body", "highlighting")), BooleanClause.Occur.SHOULD);
query.add(new TermQuery(new Term("body", "just")), BooleanClause.Occur.SHOULD);
query.add(new TermQuery(new Term("body", "first")), BooleanClause.Occur.SHOULD);
- TopDocs topDocs = searcher.search(query, null, 10, Sort.INDEXORDER);
+ TopDocs topDocs = searcher.search(query, 10, Sort.INDEXORDER);
assertEquals(2, topDocs.totalHits);
String snippets[] = highlighter.highlight("body", query, searcher, topDocs);
assertEquals(2, snippets.length);
@@ -363,7 +363,7 @@ public class TestPostingsHighlighter ext
IndexSearcher searcher = newSearcher(ir);
PostingsHighlighter highlighter = new PostingsHighlighter();
Query query = new TermQuery(new Term("body", "test"));
- TopDocs topDocs = searcher.search(query, null, 10, Sort.INDEXORDER);
+ TopDocs topDocs = searcher.search(query, 10, Sort.INDEXORDER);
assertEquals(2, topDocs.totalHits);
String snippets[] = highlighter.highlight("body", query, searcher, topDocs, 2);
assertEquals(2, snippets.length);
@@ -401,7 +401,7 @@ public class TestPostingsHighlighter ext
IndexSearcher searcher = newSearcher(ir);
PostingsHighlighter highlighter = new PostingsHighlighter();
Query query = new TermQuery(new Term("body", "test"));
- TopDocs topDocs = searcher.search(query, null, 10, Sort.INDEXORDER);
+ TopDocs topDocs = searcher.search(query, 10, Sort.INDEXORDER);
assertEquals(2, topDocs.totalHits);
try {
highlighter.highlight("body", query, searcher, topDocs, 2);
@@ -539,7 +539,7 @@ public class TestPostingsHighlighter ext
IndexSearcher searcher = newSearcher(ir);
PostingsHighlighter highlighter = new PostingsHighlighter();
Query query = new TermQuery(new Term("body", "test"));
- TopDocs topDocs = searcher.search(query, null, 10, Sort.INDEXORDER);
+ TopDocs topDocs = searcher.search(query, 10, Sort.INDEXORDER);
assertEquals(1, topDocs.totalHits);
String snippets[] = highlighter.highlight("body", query, searcher, topDocs, 2);
assertEquals(1, snippets.length);
@@ -603,7 +603,7 @@ public class TestPostingsHighlighter ext
}
};
Query query = new TermQuery(new Term("body", "test"));
- TopDocs topDocs = searcher.search(query, null, 10, Sort.INDEXORDER);
+ TopDocs topDocs = searcher.search(query, 10, Sort.INDEXORDER);
assertEquals(1, topDocs.totalHits);
String snippets[] = highlighter.highlight("body", query, searcher, topDocs, 2);
assertEquals(1, snippets.length);
@@ -636,7 +636,7 @@ public class TestPostingsHighlighter ext
IndexSearcher searcher = newSearcher(ir);
PostingsHighlighter highlighter = new PostingsHighlighter();
Query query = new TermQuery(new Term("body", "highlighting"));
- TopDocs topDocs = searcher.search(query, null, 10, Sort.INDEXORDER);
+ TopDocs topDocs = searcher.search(query, 10, Sort.INDEXORDER);
assertEquals(2, topDocs.totalHits);
ScoreDoc[] hits = topDocs.scoreDocs;
int[] docIDs = new int[2];
@@ -688,7 +688,7 @@ public class TestPostingsHighlighter ext
};
Query query = new TermQuery(new Term("body", "test"));
- TopDocs topDocs = searcher.search(query, null, 10, Sort.INDEXORDER);
+ TopDocs topDocs = searcher.search(query, 10, Sort.INDEXORDER);
assertEquals(1, topDocs.totalHits);
String snippets[] = highlighter.highlight("body", query, searcher, topDocs, 2);
assertEquals(1, snippets.length);
@@ -1015,7 +1015,7 @@ public class TestPostingsHighlighter ext
}
};
Query query = new TermQuery(new Term("body", "highlighting"));
- TopDocs topDocs = searcher.search(query, null, 10, Sort.INDEXORDER);
+ TopDocs topDocs = searcher.search(query, 10, Sort.INDEXORDER);
assertEquals(1, topDocs.totalHits);
String snippets[] = highlighter.highlight("body", query, searcher, topDocs);
assertEquals(1, snippets.length);
@@ -1059,7 +1059,7 @@ public class TestPostingsHighlighter ext
}
};
Query query = new TermQuery(new Term("body", "field"));
- TopDocs topDocs = searcher.search(query, null, 10, Sort.INDEXORDER);
+ TopDocs topDocs = searcher.search(query, 10, Sort.INDEXORDER);
assertEquals(1, topDocs.totalHits);
String snippets[] = highlighter.highlight("body", query, searcher, topDocs);
assertEquals(1, snippets.length);
@@ -1106,7 +1106,7 @@ public class TestPostingsHighlighter ext
};
Query query = new TermQuery(new Term("body", "highlighting"));
- TopDocs topDocs = searcher.search(query, null, 10, Sort.INDEXORDER);
+ TopDocs topDocs = searcher.search(query, 10, Sort.INDEXORDER);
assertEquals(1, topDocs.totalHits);
int[] docIDs = new int[1];
docIDs[0] = topDocs.scoreDocs[0].doc;
Modified: lucene/dev/trunk/lucene/highlighter/src/test/org/apache/lucene/search/postingshighlight/TestPostingsHighlighterRanking.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/highlighter/src/test/org/apache/lucene/search/postingshighlight/TestPostingsHighlighterRanking.java?rev=1662059&r1=1662058&r2=1662059&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/highlighter/src/test/org/apache/lucene/search/postingshighlight/TestPostingsHighlighterRanking.java (original)
+++ lucene/dev/trunk/lucene/highlighter/src/test/org/apache/lucene/search/postingshighlight/TestPostingsHighlighterRanking.java Tue Feb 24 17:43:10 2015
@@ -272,7 +272,7 @@ public class TestPostingsHighlighterRank
}
};
Query query = new TermQuery(new Term("body", "test"));
- TopDocs topDocs = searcher.search(query, null, 10, Sort.INDEXORDER);
+ TopDocs topDocs = searcher.search(query, 10, Sort.INDEXORDER);
assertEquals(1, topDocs.totalHits);
String snippets[] = highlighter.highlight("body", query, searcher, topDocs, 1);
assertEquals(1, snippets.length);
@@ -313,7 +313,7 @@ public class TestPostingsHighlighterRank
BooleanQuery query = new BooleanQuery();
query.add(new TermQuery(new Term("body", "foo")), BooleanClause.Occur.SHOULD);
query.add(new TermQuery(new Term("body", "bar")), BooleanClause.Occur.SHOULD);
- TopDocs topDocs = searcher.search(query, null, 10, Sort.INDEXORDER);
+ TopDocs topDocs = searcher.search(query, 10, Sort.INDEXORDER);
assertEquals(1, topDocs.totalHits);
String snippets[] = highlighter.highlight("body", query, searcher, topDocs, 1);
assertEquals(1, snippets.length);