A few more

Author: thecoop

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);

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 {

lucene/core/src/test/org/apache/lucene/search/TestTopDocsMerge.java

@@ -16,6 +16,8 @@
  */
 package org.apache.lucene.search;
 
+import static org.hamcrest.Matchers.greaterThan;
+
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Collections;
@@ -124,9 +126,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.length, greaterThan(0));
     for (ScoreDoc scoreDoc : merge.scoreDocs) {
-      assertTrue(scoreDoc.shardIndex != -1);
+      assertNotEquals(-1, scoreDoc.shardIndex);
       TopDocs shardTopDocs = shardResultMapping.get(scoreDoc.shardIndex);
       assertNotNull(shardTopDocs);
       boolean found = false;

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);

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(1 << (WANDScorer.FLOAT_MANTISSA_BITS - 1)));
+    assertThat(scaled, lessThan(1 << WANDScorer.FLOAT_MANTISSA_BITS));
   }
 
   public void testScaleMaxScore() {

lucene/core/src/test/org/apache/lucene/search/TestWildcardQuery.java

@@ -17,6 +17,7 @@
 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;
@@ -77,31 +78,31 @@ 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(
             new WildcardQuery(
                 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(
             new WildcardQuery(
                 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(
             new WildcardQuery(
                 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();
   }
@@ -119,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();
   }
@@ -139,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");
-    assertThat(wq.getTermsEnum(terms), instanceOf(AutomatonTermsEnum.class));
+    assertThat(wq.getTermsEnum(terms), not(instanceOf(AutomatonTermsEnum.class)));
     reader.close();
     indexStore.close();
   }