Skip to content

Apache Lucene open-source search software

Update some asserts in search tests (#15251)

Simon Cooperca9b680591c1
diff --git a/lucene/core/src/test/org/apache/lucene/search/BaseKnnVectorQueryTestCase.java b/lucene/core/src/test/org/apache/lucene/search/BaseKnnVectorQueryTestCase.java
index 0f9a6c84578..32215cad5e0 100644
--- a/lucene/core/src/test/org/apache/lucene/search/BaseKnnVectorQueryTestCase.java
+++ b/lucene/core/src/test/org/apache/lucene/search/BaseKnnVectorQueryTestCase.java
@@ -20,7 +20,9 @@ import static com.carrotsearch.randomizedtesting.RandomizedTest.frequently;
import static com.carrotsearch.randomizedtesting.RandomizedTest.randomBoolean;
import static com.carrotsearch.randomizedtesting.RandomizedTest.randomIntBetween;
import static org.apache.lucene.search.DocIdSetIterator.NO_MORE_DOCS;
+import static org.hamcrest.Matchers.instanceOf;
import static org.hamcrest.Matchers.lessThanOrEqualTo;
+import static org.hamcrest.Matchers.not;
import java.io.IOException;
import java.util.HashSet;
@@ -915,8 +917,9 @@ abstract class BaseKnnVectorQueryTestCase extends LuceneTestCase {
noTimeoutManager.newCollector(Integer.MAX_VALUE, null, searcher.leafContexts.get(0));
// Check that a normal collector is created without timeout
- assertFalse(
- noTimeoutCollector instanceof TimeLimitingKnnCollectorManager.TimeLimitingKnnCollector);
+ assertThat(
+ noTimeoutCollector,
+ not(instanceOf(TimeLimitingKnnCollectorManager.TimeLimitingKnnCollector.class)));
noTimeoutCollector.collect(0, 0);
assertFalse(noTimeoutCollector.earlyTerminated());
@@ -932,7 +935,7 @@ abstract class BaseKnnVectorQueryTestCase extends LuceneTestCase {
timeoutManager.newCollector(Integer.MAX_VALUE, null, searcher.leafContexts.get(0));
// Check that a time limiting collector is created, which returns partial results
- assertFalse(timeoutCollector instanceof TopKnnCollector);
+ assertThat(timeoutCollector, not(instanceOf(TopKnnCollector.class)));
timeoutCollector.collect(0, 0);
assertTrue(timeoutCollector.earlyTerminated());
diff --git a/lucene/core/src/test/org/apache/lucene/search/BaseVectorSimilarityQueryTestCase.java b/lucene/core/src/test/org/apache/lucene/search/BaseVectorSimilarityQueryTestCase.java
index 4a024b9c2cb..11a287516dc 100644
--- a/lucene/core/src/test/org/apache/lucene/search/BaseVectorSimilarityQueryTestCase.java
+++ b/lucene/core/src/test/org/apache/lucene/search/BaseVectorSimilarityQueryTestCase.java
@@ -19,6 +19,9 @@ package org.apache.lucene.search;
import static org.apache.lucene.codecs.lucene99.Lucene99HnswVectorsFormat.DEFAULT_BEAM_WIDTH;
import static org.apache.lucene.codecs.lucene99.Lucene99HnswVectorsFormat.DEFAULT_MAX_CONN;
import static org.apache.lucene.search.DocIdSetIterator.NO_MORE_DOCS;
+import static org.hamcrest.Matchers.either;
+import static org.hamcrest.Matchers.greaterThan;
+import static org.hamcrest.Matchers.lessThan;
import java.io.IOException;
import java.util.Arrays;
@@ -317,7 +320,7 @@ abstract class BaseVectorSimilarityQueryTestCase<
int id = getId(searcher, scoreDoc.doc);
// Check that returned document is not deleted
- assertFalse(id >= startIndex && id <= endIndex);
+ assertThat(id, either(lessThan(startIndex)).or(greaterThan(endIndex)));
}
// Check that all live docs are returned
assertEquals(numDocs - endIndex + startIndex - 1, scoreDocs.length);
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestBooleanQueryVisitSubscorers.java b/lucene/core/src/test/org/apache/lucene/search/TestBooleanQueryVisitSubscorers.java
index 9a2c177c62d..918769084b8 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestBooleanQueryVisitSubscorers.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestBooleanQueryVisitSubscorers.java
@@ -16,6 +16,10 @@
*/
package org.apache.lucene.search;
+import static org.hamcrest.Matchers.contains;
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.everyItem;
+
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
@@ -249,17 +253,17 @@ public class TestBooleanQueryVisitSubscorers extends LuceneTestCase {
ScoreSummary scoreSummary =
searcher.search(query.build(), new ScorerSummarizingCollectorManager());
assertEquals(1, scoreSummary.numHits.get());
- assertFalse(scoreSummary.summaries.isEmpty());
- for (String summary : scoreSummary.summaries) {
- assertEquals(
- "ConjunctionScorer\n"
- + " MUST ConstantScoreScorer\n"
- + " MUST WANDScorer\n"
- + " SHOULD TermScorer\n"
- + " SHOULD TermScorer\n"
- + " SHOULD TermScorer",
- summary);
- }
+ assertThat(
+ scoreSummary.summaries,
+ everyItem(
+ equalTo(
+ """
+ ConjunctionScorer
+ MUST ConstantScoreScorer
+ MUST WANDScorer
+ SHOULD TermScorer
+ SHOULD TermScorer
+ SHOULD TermScorer""")));
}
public void testGetChildrenBoosterScorer() throws IOException {
@@ -269,10 +273,7 @@ public class TestBooleanQueryVisitSubscorers extends LuceneTestCase {
ScoreSummary scoreSummary =
scorerSearcher.search(query.build(), new ScorerSummarizingCollectorManager());
assertEquals(1, scoreSummary.numHits.get());
- assertFalse(scoreSummary.summaries.isEmpty());
- for (String summary : scoreSummary.summaries) {
- assertEquals("TermScorer", summary);
- }
+ assertThat(scoreSummary.summaries, contains("TermScorer"));
}
private static class ScoreSummary {
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestBoostQuery.java b/lucene/core/src/test/org/apache/lucene/search/TestBoostQuery.java
index f4f02d2969c..cfa339dfbfd 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestBoostQuery.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestBoostQuery.java
@@ -55,7 +55,7 @@ public class TestBoostQuery extends LuceneTestCase {
}
BoostQuery q3 = new BoostQuery(new MatchAllDocsQuery(), boost2);
assertFalse(q1.equals(q3));
- assertFalse(q1.hashCode() == q3.hashCode());
+ assertNotEquals(q3.hashCode(), q1.hashCode());
}
public void testToString() {
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestDocValuesQueries.java b/lucene/core/src/test/org/apache/lucene/search/TestDocValuesQueries.java
index 4badfc294fc..8122c27173e 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestDocValuesQueries.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestDocValuesQueries.java
@@ -502,12 +502,12 @@ public class TestDocValuesQueries extends LuceneTestCase {
assertEquals(
NumericDocValuesField.newSlowSetQuery("field", 17L, 42L, 32416190071L),
NumericDocValuesField.newSlowSetQuery("field", 17L, 32416190071L, 42L));
- assertFalse(
- NumericDocValuesField.newSlowSetQuery("field", 42L)
- .equals(NumericDocValuesField.newSlowSetQuery("field2", 42L)));
- assertFalse(
- NumericDocValuesField.newSlowSetQuery("field", 17L, 42L)
- .equals(NumericDocValuesField.newSlowSetQuery("field", 17L, 32416190071L)));
+ assertNotEquals(
+ NumericDocValuesField.newSlowSetQuery("field", 42L),
+ NumericDocValuesField.newSlowSetQuery("field2", 42L));
+ assertNotEquals(
+ NumericDocValuesField.newSlowSetQuery("field", 17L, 42L),
+ NumericDocValuesField.newSlowSetQuery("field", 17L, 32416190071L));
}
public void testDuelSetVsTermsQuery() throws IOException {
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestFieldExistsQuery.java b/lucene/core/src/test/org/apache/lucene/search/TestFieldExistsQuery.java
index e9839ed722b..7f6c673c401 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestFieldExistsQuery.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestFieldExistsQuery.java
@@ -16,6 +16,11 @@
*/
package org.apache.lucene.search;
+import static org.hamcrest.Matchers.hasSize;
+import static org.hamcrest.Matchers.instanceOf;
+import static org.hamcrest.Matchers.lessThanOrEqualTo;
+import static org.hamcrest.Matchers.not;
+
import java.io.IOException;
import org.apache.lucene.document.BinaryPoint;
import org.apache.lucene.document.Document;
@@ -62,8 +67,9 @@ public class TestFieldExistsQuery extends LuceneTestCase {
final IndexReader reader = iw.getReader();
iw.close();
- assertTrue(
- (new FieldExistsQuery("f")).rewrite(newSearcher(reader)) instanceof MatchAllDocsQuery);
+ assertThat(
+ new FieldExistsQuery("f").rewrite(newSearcher(reader)),
+ instanceOf(MatchAllDocsQuery.class));
reader.close();
dir.close();
}
@@ -82,8 +88,9 @@ public class TestFieldExistsQuery extends LuceneTestCase {
final IndexReader reader = iw.getReader();
iw.close();
- assertTrue(
- new FieldExistsQuery("dim").rewrite(newSearcher(reader)) instanceof MatchAllDocsQuery);
+ assertThat(
+ new FieldExistsQuery("dim").rewrite(newSearcher(reader)),
+ instanceOf(MatchAllDocsQuery.class));
reader.close();
dir.close();
}
@@ -127,8 +134,10 @@ public class TestFieldExistsQuery extends LuceneTestCase {
iw.close();
final IndexSearcher searcher = newSearcher(reader);
- assertFalse((new FieldExistsQuery("dim")).rewrite(searcher) instanceof MatchAllDocsQuery);
- assertFalse((new FieldExistsQuery("f")).rewrite(searcher) instanceof MatchAllDocsQuery);
+ assertThat(
+ new FieldExistsQuery("dim").rewrite(searcher), not(instanceOf(MatchAllDocsQuery.class)));
+ assertThat(
+ new FieldExistsQuery("f").rewrite(searcher), not(instanceOf(MatchAllDocsQuery.class)));
reader.close();
dir.close();
}
@@ -149,9 +158,12 @@ public class TestFieldExistsQuery extends LuceneTestCase {
iw.close();
final IndexSearcher searcher = newSearcher(reader);
- assertFalse((new FieldExistsQuery("dv1")).rewrite(searcher) instanceof MatchAllDocsQuery);
- assertFalse((new FieldExistsQuery("dv2")).rewrite(searcher) instanceof MatchAllDocsQuery);
- assertFalse((new FieldExistsQuery("dv3")).rewrite(searcher) instanceof MatchAllDocsQuery);
+ assertThat(
+ new FieldExistsQuery("dv1").rewrite(searcher), not(instanceOf(MatchAllDocsQuery.class)));
+ assertThat(
+ new FieldExistsQuery("dv2").rewrite(searcher), not(instanceOf(MatchAllDocsQuery.class)));
+ assertThat(
+ new FieldExistsQuery("dv3").rewrite(searcher), not(instanceOf(MatchAllDocsQuery.class)));
reader.close();
dir.close();
}
@@ -368,7 +380,7 @@ public class TestFieldExistsQuery extends LuceneTestCase {
final IndexSearcher searcher2 = new IndexSearcher(reader2);
final Query testQuery = new FieldExistsQuery("long");
final Weight weight2 = searcher2.createWeight(testQuery, ScoreMode.COMPLETE, 1);
- assertEquals(weight2.count(reader2.leaves().get(0)), -1);
+ assertEquals(-1, weight2.count(reader2.leaves().get(0)));
IOUtils.close(reader, reader2, w, dir);
}
@@ -660,7 +672,7 @@ public class TestFieldExistsQuery extends LuceneTestCase {
try (IndexReader reader = iw.getReader()) {
IndexSearcher searcher = newSearcher(reader);
Query query = new FieldExistsQuery("vector");
- assertTrue(searcher.rewrite(query) instanceof MatchAllDocsQuery);
+ assertThat(searcher.rewrite(query), instanceOf(MatchAllDocsQuery.class));
assertEquals(100, searcher.count(query));
}
}
@@ -725,7 +737,7 @@ public class TestFieldExistsQuery extends LuceneTestCase {
.build();
int count = searcher.count(booleanQuery);
- assertTrue(count <= numVectors);
+ assertThat(count, lessThanOrEqualTo(numVectors));
if (allDocsHaveVector) {
assertEquals(numDocs / 2, count);
}
@@ -816,7 +828,8 @@ public class TestFieldExistsQuery extends LuceneTestCase {
iw.forceMerge(1);
try (IndexReader reader = iw.getReader()) {
- assertTrue(reader.leaves().size() == 1 && reader.hasDeletions() == false);
+ assertThat(reader.leaves(), hasSize(1));
+ assertFalse(reader.hasDeletions());
IndexSearcher searcher = newSearcher(reader);
assertEquals(0, searcher.count(new FieldExistsQuery("long")));
}
@@ -845,7 +858,8 @@ public class TestFieldExistsQuery extends LuceneTestCase {
iw.forceMerge(1);
try (IndexReader reader = iw.getReader()) {
- assertTrue(reader.leaves().size() == 1 && reader.hasDeletions() == false);
+ assertThat(reader.leaves(), hasSize(1));
+ assertFalse(reader.hasDeletions());
IndexSearcher searcher = newSearcher(reader);
assertEquals(0, searcher.count(new FieldExistsQuery("str")));
}
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestMaxClauseLimit.java b/lucene/core/src/test/org/apache/lucene/search/TestMaxClauseLimit.java
index d633b3e83db..d0d347a3872 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestMaxClauseLimit.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestMaxClauseLimit.java
@@ -17,6 +17,9 @@
package org.apache.lucene.search;
+import static org.hamcrest.Matchers.instanceOf;
+import static org.hamcrest.Matchers.not;
+
import java.io.IOException;
import java.util.Arrays;
import org.apache.lucene.index.MultiReader;
@@ -57,9 +60,10 @@ public class TestMaxClauseLimit extends LuceneTestCase {
() -> {
searcher.rewrite(query);
});
- assertFalse(
+ assertThat(
"Should have been caught during flattening and not required full nested walk",
- e instanceof IndexSearcher.TooManyNestedClauses);
+ e,
+ not(instanceOf(IndexSearcher.TooManyNestedClauses.class)));
}
public void testLargeTermsNestedFirst() throws IOException {
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestMultiPhraseQuery.java b/lucene/core/src/test/org/apache/lucene/search/TestMultiPhraseQuery.java
index 636dda9deb6..622f5ea120d 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestMultiPhraseQuery.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestMultiPhraseQuery.java
@@ -305,7 +305,7 @@ public class TestMultiPhraseQuery extends LuceneTestCase {
query1builder.add(term2);
query1 = query1builder.build();
- assertFalse(query1.hashCode() == query2.hashCode());
+ assertNotEquals(query1.hashCode(), query2.hashCode());
assertFalse(query1.equals(query2));
query2builder.add(term2);
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestPointQueries.java b/lucene/core/src/test/org/apache/lucene/search/TestPointQueries.java
index 1153a2dc970..229ca31580a 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestPointQueries.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestPointQueries.java
@@ -2161,7 +2161,7 @@ public class TestPointQueries extends LuceneTestCase {
searcher.setQueryCache(null);
weight = searcher.createWeight(query, ScoreMode.COMPLETE_NO_SCORES, 1);
scorer = weight.scorer(searcher.getIndexReader().leaves().get(0));
- assertFalse(DocIdSetIterator.all(1).getClass().equals(scorer.iterator().getClass()));
+ assertNotEquals(DocIdSetIterator.all(1).getClass(), scorer.iterator().getClass());
reader.close();
w.close();
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestQueryRescorer.java b/lucene/core/src/test/org/apache/lucene/search/TestQueryRescorer.java
index 952b8a9212c..2449152ed2b 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestQueryRescorer.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestQueryRescorer.java
@@ -16,6 +16,9 @@
*/
package org.apache.lucene.search;
+import static org.hamcrest.Matchers.containsString;
+import static org.hamcrest.Matchers.not;
+
import com.carrotsearch.randomizedtesting.generators.RandomPicks;
import java.io.IOException;
import java.util.Arrays;
@@ -333,20 +336,20 @@ public class TestQueryRescorer extends LuceneTestCase {
int docID = hits2.scoreDocs[0].doc;
Explanation explain = rescorer.explain(searcher, searcher.explain(bq.build(), docID), docID);
String s = explain.toString();
- assertTrue(s.contains("TestQueryRescorer$"));
- assertTrue(s.contains("combined first and second pass score"));
- assertTrue(s.contains("first pass score"));
- assertTrue(s.contains("= second pass score"));
+ assertThat(s, containsString("TestQueryRescorer$"));
+ assertThat(s, containsString("combined first and second pass score"));
+ assertThat(s, containsString("first pass score"));
+ assertThat(s, containsString("= second pass score"));
assertEquals(hits2.scoreDocs[0].score, explain.getValue().doubleValue(), 0.0f);
docID = hits2.scoreDocs[1].doc;
explain = rescorer.explain(searcher, searcher.explain(bq.build(), docID), docID);
s = explain.toString();
- assertTrue(s.contains("TestQueryRescorer$"));
- assertTrue(s.contains("combined first and second pass score"));
- assertTrue(s.contains("first pass score"));
- assertTrue(s.contains("no second pass score"));
- assertFalse(s.contains("= second pass score"));
+ assertThat(s, containsString("TestQueryRescorer$"));
+ assertThat(s, containsString("combined first and second pass score"));
+ assertThat(s, containsString("first pass score"));
+ assertThat(s, containsString("no second pass score"));
+ assertThat(s, not(containsString("= second pass score")));
assertEquals(hits2.scoreDocs[1].score, explain.getValue().doubleValue(), 0.0f);
r.close();
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestScorerUtil.java b/lucene/core/src/test/org/apache/lucene/search/TestScorerUtil.java
index fb3f031ef8d..24e9a586b51 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestScorerUtil.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestScorerUtil.java
@@ -16,6 +16,8 @@
*/
package org.apache.lucene.search;
+import static org.hamcrest.Matchers.lessThan;
+
import java.io.IOException;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.FeatureField;
@@ -109,11 +111,11 @@ public class TestScorerUtil extends LuceneTestCase {
} else {
// The value before minRequiredScore must not be able to produce a score >=
// minCompetitiveScore.
- assertFalse(
+ assertThat(
(float)
- MathUtil.sumUpperBound(
- Math.nextDown(minRequiredScore) + maxRemainingScore, numScorers)
- >= minCompetitiveScore);
+ MathUtil.sumUpperBound(
+ Math.nextDown(minRequiredScore) + maxRemainingScore, numScorers),
+ lessThan(minCompetitiveScore));
}
// NOTE: we need to assert the internal while loop ends within an acceptable iterations. But
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestSearcherManager.java b/lucene/core/src/test/org/apache/lucene/search/TestSearcherManager.java
index e8f7b6ac512..d73b4adfdf0 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestSearcherManager.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestSearcherManager.java
@@ -16,6 +16,8 @@
*/
package org.apache.lucene.search;
+import static org.hamcrest.Matchers.instanceOf;
+
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
@@ -531,9 +533,9 @@ public class TestSearcherManager extends ThreadedIndexingAndSearchingTestCase {
mgr.maybeRefresh();
IndexSearcher s = mgr.acquire();
try {
- assertTrue(s.getIndexReader() instanceof MyFilterDirectoryReader);
+ assertThat(s.getIndexReader(), instanceOf(MyFilterDirectoryReader.class));
for (LeafReaderContext ctx : s.getIndexReader().leaves()) {
- assertTrue(ctx.reader() instanceof MyFilterLeafReader);
+ assertThat(ctx.reader(), instanceOf(MyFilterLeafReader.class));
}
} finally {
mgr.release(s);
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestSimilarityProvider.java b/lucene/core/src/test/org/apache/lucene/search/TestSimilarityProvider.java
index 03bea2aee60..afdbef97b49 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestSimilarityProvider.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestSimilarityProvider.java
@@ -76,7 +76,7 @@ public class TestSimilarityProvider extends LuceneTestCase {
for (int i = 0; i < reader.maxDoc(); i++) {
assertEquals(i, fooNorms.nextDoc());
assertEquals(i, barNorms.nextDoc());
- assertFalse(fooNorms.longValue() == barNorms.longValue());
+ assertNotEquals(fooNorms.longValue(), barNorms.longValue());
}
// sanity check of searching
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestSortRescorer.java b/lucene/core/src/test/org/apache/lucene/search/TestSortRescorer.java
index 5322b2e8796..d94cfcc81ae 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestSortRescorer.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestSortRescorer.java
@@ -19,6 +19,7 @@ package org.apache.lucene.search;
import java.io.IOException;
import java.util.Arrays;
import java.util.Comparator;
+import java.util.stream.Stream;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.document.NumericDocValuesField;
@@ -213,11 +214,8 @@ public class TestSortRescorer extends LuceneTestCase {
}
});
- boolean fail = false;
- for (int i = 0; i < numHits; i++) {
- fail |= expected[i].intValue() != hits2.scoreDocs[i].doc;
- }
- assertFalse(fail);
+ Integer[] rescored = Stream.of(hits2.scoreDocs).map(d -> d.doc).toArray(Integer[]::new);
+ assertArrayEquals(expected, rescored);
r.close();
dir.close();
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestTermInSetQuery.java b/lucene/core/src/test/org/apache/lucene/search/TestTermInSetQuery.java
index 9ea2d4672bd..8d2d2a04c55 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestTermInSetQuery.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestTermInSetQuery.java
@@ -319,12 +319,12 @@ public class TestTermInSetQuery extends LuceneTestCase {
TermInSetQuery tq1 = new TermInSetQuery("thing", List.of(newBytesRef("apple")));
TermInSetQuery tq2 = new TermInSetQuery("thing", List.of(newBytesRef("orange")));
- assertFalse(tq1.hashCode() == tq2.hashCode());
+ assertNotEquals(tq1.hashCode(), tq2.hashCode());
// different fields with the same term should have differing hashcodes
tq1 = new TermInSetQuery("thing", List.of(newBytesRef("apple")));
tq2 = new TermInSetQuery("thing2", List.of(newBytesRef("apple")));
- assertFalse(tq1.hashCode() == tq2.hashCode());
+ assertNotEquals(tq1.hashCode(), tq2.hashCode());
}
public void testSimpleEquals() {
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestTermScorer.java b/lucene/core/src/test/org/apache/lucene/search/TestTermScorer.java
index 38401d31205..90efa41ae18 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestTermScorer.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestTermScorer.java
@@ -16,6 +16,12 @@
*/
package org.apache.lucene.search;
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.greaterThan;
+import static org.hamcrest.Matchers.hasSize;
+import static org.hamcrest.Matchers.instanceOf;
+import static org.hamcrest.Matchers.oneOf;
+
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
@@ -86,7 +92,7 @@ public class TestTermScorer extends LuceneTestCase {
TermQuery termQuery = new TermQuery(allTerm);
Weight weight = indexSearcher.createWeight(termQuery, ScoreMode.COMPLETE, 1);
- assertTrue(indexSearcher.getTopReaderContext() instanceof LeafReaderContext);
+ assertThat(indexSearcher.getTopReaderContext(), instanceOf(LeafReaderContext.class));
LeafReaderContext context = (LeafReaderContext) indexSearcher.getTopReaderContext();
BulkScorer ts = weight.bulkScorer(context);
// we have 2 documents with the term all in them, one document for all the
@@ -109,9 +115,8 @@ public class TestTermScorer extends LuceneTestCase {
float score = scorer.score();
doc = doc + base;
docs.add(new TestHit(doc, score));
- assertTrue("score " + score + " is not greater than 0", score > 0);
- assertTrue(
- "Doc: " + doc + " does not equal 0 or doc does not equal 5", doc == 0 || doc == 5);
+ assertThat(score, greaterThan(0f));
+ assertThat(doc, oneOf(0, 5));
}
@Override
@@ -127,11 +132,11 @@ public class TestTermScorer extends LuceneTestCase {
null,
0,
DocIdSetIterator.NO_MORE_DOCS);
- assertTrue("docs Size: " + docs.size() + " is not: " + 2, docs.size() == 2);
+ assertThat(docs, hasSize(2));
TestHit doc0 = docs.get(0);
TestHit doc5 = docs.get(1);
// The scores should be the same
- assertTrue(doc0.score + " does not equal: " + doc5.score, doc0.score == doc5.score);
+ assertEquals(doc5.score, doc0.score, 0);
}
public void testNext() throws Exception {
@@ -140,7 +145,7 @@ public class TestTermScorer extends LuceneTestCase {
TermQuery termQuery = new TermQuery(allTerm);
Weight weight = indexSearcher.createWeight(termQuery, ScoreMode.COMPLETE, 1);
- assertTrue(indexSearcher.getTopReaderContext() instanceof LeafReaderContext);
+ assertThat(indexSearcher.getTopReaderContext(), instanceOf(LeafReaderContext.class));
LeafReaderContext context = (LeafReaderContext) indexSearcher.getTopReaderContext();
Scorer ts = weight.scorer(context);
assertTrue(
@@ -158,12 +163,12 @@ public class TestTermScorer extends LuceneTestCase {
TermQuery termQuery = new TermQuery(allTerm);
Weight weight = indexSearcher.createWeight(termQuery, ScoreMode.COMPLETE, 1);
- assertTrue(indexSearcher.getTopReaderContext() instanceof LeafReaderContext);
+ assertThat(indexSearcher.getTopReaderContext(), instanceOf(LeafReaderContext.class));
LeafReaderContext context = (LeafReaderContext) indexSearcher.getTopReaderContext();
Scorer ts = weight.scorer(context);
assertTrue("Didn't skip", ts.iterator().advance(3) != DocIdSetIterator.NO_MORE_DOCS);
// The next doc should be doc 5
- assertTrue("doc should be number 5", ts.docID() == 5);
+ assertThat(ts.docID(), equalTo(5));
}
private static class TestHit {
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestTopDocsMerge.java b/lucene/core/src/test/org/apache/lucene/search/TestTopDocsMerge.java
index 1d5b346c29d..6bba5a4a89a 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestTopDocsMerge.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestTopDocsMerge.java
@@ -16,6 +16,9 @@
*/
package org.apache.lucene.search;
+import static org.hamcrest.Matchers.emptyArray;
+import static org.hamcrest.Matchers.not;
+
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
@@ -124,9 +127,9 @@ public class TestTopDocsMerge extends LuceneTestCase {
// that we already set, instead of the position of that TopDocs in the array:
TopDocs merge = TopDocs.merge(from, size, topDocs.toArray(new TopDocs[0]));
- assertTrue(merge.scoreDocs.length > 0);
+ assertThat(merge.scoreDocs, not(emptyArray()));
for (ScoreDoc scoreDoc : merge.scoreDocs) {
- assertTrue(scoreDoc.shardIndex != -1);
+ assertNotEquals(-1, scoreDoc.shardIndex);
TopDocs shardTopDocs = shardResultMapping.get(scoreDoc.shardIndex);
assertNotNull(shardTopDocs);
boolean found = false;
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestTopFieldCollector.java b/lucene/core/src/test/org/apache/lucene/search/TestTopFieldCollector.java
index 231b4696e08..34eaf879447 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestTopFieldCollector.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestTopFieldCollector.java
@@ -17,6 +17,9 @@
package org.apache.lucene.search;
import static org.apache.lucene.search.SortField.FIELD_SCORE;
+import static org.hamcrest.Matchers.greaterThan;
+import static org.hamcrest.Matchers.lessThanOrEqualTo;
+import static org.hamcrest.Matchers.sameInstance;
import java.io.IOException;
import java.util.Arrays;
@@ -560,7 +563,7 @@ public class TestTopFieldCollector extends LuceneTestCase {
new TopFieldCollectorManager(sort, 2, 0);
TopFieldCollector collector = manager.newCollector();
TopFieldCollector collector2 = manager.newCollector();
- assertTrue(collector.minScoreAcc == collector2.minScoreAcc);
+ assertThat(collector2.minScoreAcc, sameInstance(collector.minScoreAcc));
MaxScoreAccumulator minValueChecker = collector.minScoreAcc;
// force the check of the global minimum score on every round
minValueChecker.modInterval = 0;
@@ -691,8 +694,8 @@ public class TestTopFieldCollector extends LuceneTestCase {
TopDocs tdc = doConcurrentSearchWithThreshold(5, 0, query, sort, indexReader);
TopDocs tdc2 = doSearchWithThreshold(5, 0, query, sort, indexReader);
- assertTrue(tdc.totalHits.value() > 0);
- assertTrue(tdc2.totalHits.value() > 0);
+ assertThat(tdc.totalHits.value(), greaterThan(0L));
+ assertThat(tdc2.totalHits.value(), greaterThan(0L));
CheckHits.checkEqual(query, tdc.scoreDocs, tdc2.scoreDocs);
}
@@ -721,7 +724,7 @@ public class TestTopFieldCollector extends LuceneTestCase {
collectorManager = new TopFieldCollectorManager(sort, 2, null, 2);
topDocs = searcher.search(new TermQuery(new Term("f", "foo")), collectorManager);
- assertTrue(10 >= topDocs.totalHits.value());
+ assertThat(topDocs.totalHits.value(), lessThanOrEqualTo(10L));
assertEquals(TotalHits.Relation.GREATER_THAN_OR_EQUAL_TO, topDocs.totalHits.relation());
collectorManager = new TopFieldCollectorManager(sort, 10, null, 2);
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestWANDScorer.java b/lucene/core/src/test/org/apache/lucene/search/TestWANDScorer.java
index d439b2f07be..32d11daa44e 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestWANDScorer.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestWANDScorer.java
@@ -16,6 +16,9 @@
*/
package org.apache.lucene.search;
+import static org.hamcrest.Matchers.greaterThanOrEqualTo;
+import static org.hamcrest.Matchers.lessThan;
+
import java.io.IOException;
import java.util.Arrays;
import java.util.List;
@@ -63,8 +66,8 @@ public class TestWANDScorer extends LuceneTestCase {
private void doTestScalingFactor(float f) {
int scalingFactor = WANDScorer.scalingFactor(f);
float scaled = Math.scalb(f, scalingFactor);
- assertTrue("" + scaled, scaled >= 1 << (WANDScorer.FLOAT_MANTISSA_BITS - 1));
- assertTrue("" + scaled, scaled < 1 << WANDScorer.FLOAT_MANTISSA_BITS);
+ assertThat(scaled, greaterThanOrEqualTo((float) (1 << (WANDScorer.FLOAT_MANTISSA_BITS - 1))));
+ assertThat(scaled, lessThan((float) (1 << WANDScorer.FLOAT_MANTISSA_BITS)));
}
public void testScaleMaxScore() {
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestWildcardQuery.java b/lucene/core/src/test/org/apache/lucene/search/TestWildcardQuery.java
index 4dfca8101fd..10a8a65f144 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestWildcardQuery.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestWildcardQuery.java
@@ -16,9 +16,13 @@
*/
package org.apache.lucene.search;
+import static org.hamcrest.Matchers.instanceOf;
+import static org.hamcrest.Matchers.not;
+
import java.io.IOException;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
+import org.apache.lucene.index.AutomatonTermsEnum;
import org.apache.lucene.index.DirectoryReader;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.LeafReaderContext;
@@ -74,7 +78,7 @@ public class TestWildcardQuery extends LuceneTestCase {
new Term("field", "nowildcard"),
Operations.DEFAULT_DETERMINIZE_WORK_LIMIT,
MultiTermQuery.SCORING_BOOLEAN_REWRITE));
- assertTrue(q instanceof TermQuery);
+ assertThat(q, instanceOf(TermQuery.class));
q =
searcher.rewrite(
@@ -82,7 +86,7 @@ public class TestWildcardQuery extends LuceneTestCase {
new Term("field", "nowildcard"),
Operations.DEFAULT_DETERMINIZE_WORK_LIMIT,
MultiTermQuery.CONSTANT_SCORE_REWRITE));
- assertTrue(q instanceof MultiTermQueryConstantScoreWrapper);
+ assertThat(q, instanceOf(MultiTermQueryConstantScoreWrapper.class));
q =
searcher.rewrite(
@@ -90,7 +94,7 @@ public class TestWildcardQuery extends LuceneTestCase {
new Term("field", "nowildcard"),
Operations.DEFAULT_DETERMINIZE_WORK_LIMIT,
MultiTermQuery.CONSTANT_SCORE_BLENDED_REWRITE));
- assertTrue(q instanceof MultiTermQueryConstantScoreBlendedWrapper);
+ assertThat(q, instanceOf(MultiTermQueryConstantScoreBlendedWrapper.class));
q =
searcher.rewrite(
@@ -98,7 +102,7 @@ public class TestWildcardQuery extends LuceneTestCase {
new Term("field", "nowildcard"),
Operations.DEFAULT_DETERMINIZE_WORK_LIMIT,
MultiTermQuery.CONSTANT_SCORE_BOOLEAN_REWRITE));
- assertTrue(q instanceof ConstantScoreQuery);
+ assertThat(q, instanceOf(ConstantScoreQuery.class));
reader.close();
indexStore.close();
}
@@ -116,7 +120,7 @@ public class TestWildcardQuery extends LuceneTestCase {
MultiTermQuery.SCORING_BOOLEAN_REWRITE);
assertMatches(searcher, wq, 0);
Query q = searcher.rewrite(wq);
- assertTrue(q instanceof MatchNoDocsQuery);
+ assertThat(q, instanceOf(MatchNoDocsQuery.class));
reader.close();
indexStore.close();
}
@@ -136,7 +140,7 @@ public class TestWildcardQuery extends LuceneTestCase {
wq = new WildcardQuery(new Term("field", "*"));
assertMatches(searcher, wq, 2);
Terms terms = MultiTerms.getTerms(searcher.getIndexReader(), "field");
- assertFalse(wq.getTermsEnum(terms).getClass().getSimpleName().contains("AutomatonTermsEnum"));
+ assertThat(wq.getTermsEnum(terms), not(instanceOf(AutomatonTermsEnum.class)));
reader.close();
indexStore.close();
}