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 0f9a6c84578b..32215cad5e0b 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.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 @@ public void testTimeLimitingKnnCollectorManager() throws IOException { 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 @@ public void testTimeLimitingKnnCollectorManager() throws IOException { 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 4a024b9c2cb3..11a287516dc6 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 @@ 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 @@ public void testSomeDeletes() throws IOException { 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 9a2c177c62d5..918769084b81 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 void testGetChildrenMinShouldMatchSumScorer() throws IOException { 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 void testGetChildrenBoosterScorer() throws IOException { 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 f4f02d2969c0..cfa339dfbfd3 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 void testEquals() { } 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 4badfc294fc8..8122c27173e1 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 void testSetEquals() { 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 e9839ed722b6..7f6c673c4012 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 void testDocValuesRewriteWithTermsPresent() throws IOException { 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 void testDocValuesRewriteWithPointValuesPresent() throws IOException { 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 void testDocValuesNoRewrite() throws IOException { 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 void testDocValuesNoRewriteWithDocValues() throws IOException { 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 void testDocValuesQueryMatchesCount() throws IOException { 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 void testKnnVectorAllDocsHaveField() throws IOException { 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 void testKnnVectorConjunction() throws IOException { .build(); int count = searcher.count(booleanQuery); - assertTrue(count <= numVectors); + assertThat(count, lessThanOrEqualTo(numVectors)); if (allDocsHaveVector) { assertEquals(numDocs / 2, count); } @@ -816,7 +828,8 @@ public void testDeleteAllPointDocs() throws Exception { 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 void testDeleteAllTermDocs() throws Exception { 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 d633b3e83db2..d0d347a3872a 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 void testFlattenInnerDisjunctionsWithMoreThan1024Terms() throws IOExcepti () -> { 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 636dda9deb62..622f5ea120d0 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 void testHashCodeAndEquals() { 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 1153a2dc9705..229ca31580a0 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 void testRangeOptimizesIfAllPointsMatch() throws IOException { 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 952b8a9212ca..2449152ed2bc 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 @@ protected float combine( 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 fb3f031ef8d1..24e9a586b514 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 void testMinRequiredScore() { } 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 e8f7b6ac5128..d73b4adfdf07 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 void testCustomDirectoryReader() throws Exception { 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 03bea2aee60d..afdbef97b49e 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 void testBasics() throws Exception { 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 5322b2e87962..d94cfcc81ae5 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 @@ 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 int compare(Integer a, Integer b) { } }); - 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 9ea2d4672bdc..8d2d2a04c553 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 void testHashCodeAndEquals() { 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 38401d312053..90efa41ae180 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 void test() throws IOException { 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 void collect(int doc) throws IOException { 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 ScoreMode scoreMode() { 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 void testNext() throws Exception { 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 void testAdvance() throws Exception { 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 1d5b346c29db..6bba5a4a89a7 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 void testPreAssignedShardIndex() { // 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 231b4696e085..34eaf8794474 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 void testConcurrentMinScore() throws Exception { 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 void testRandomMinCompetitiveScore() throws Exception { 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 void testRelationVsTopDocsCount() throws Exception { 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 d439b2f07bed..32d11daa44e8 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 void testScalingFactor() { 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 4dfca8101fdb..10a8a65f1441 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 void testTermWithoutWildcard() throws IOException { 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 void testTermWithoutWildcard() throws IOException { 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 void testTermWithoutWildcard() throws IOException { 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 void testTermWithoutWildcard() throws IOException { 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 void testEmptyTerm() throws IOException { 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 void testPrefixTerm() throws IOException { 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(); }