Apache Lucene open-source search software
Change several test assertions to use assertThat (#14518)
Simon Cooperdba021ed129a
diff --git a/lucene/core/src/test/org/apache/lucene/document/TestDocument.java b/lucene/core/src/test/org/apache/lucene/document/TestDocument.javaindex ef4eaa86438..674c89e13e0 100644--- a/lucene/core/src/test/org/apache/lucene/document/TestDocument.java+++ b/lucene/core/src/test/org/apache/lucene/document/TestDocument.java@@ -16,9 +16,21 @@*/package org.apache.lucene.document;+import static org.hamcrest.Matchers.arrayContaining;+import static org.hamcrest.Matchers.arrayWithSize;+import static org.hamcrest.Matchers.containsInAnyOrder;+import static org.hamcrest.Matchers.empty;+import static org.hamcrest.Matchers.equalTo;+import static org.hamcrest.Matchers.hasSize;+import static org.hamcrest.Matchers.not;+import static org.hamcrest.Matchers.notNullValue;+import static org.hamcrest.Matchers.nullValue;+import java.io.StringReader;import java.nio.charset.StandardCharsets;+import java.util.HashSet;import java.util.List;+import java.util.Set;import org.apache.lucene.analysis.Tokenizer;import org.apache.lucene.index.DirectoryReader;import org.apache.lucene.index.IndexOptions;@@ -55,39 +67,39 @@ public class TestDocument extends LuceneTestCase {doc.add(stringFld);doc.add(binaryFld);- assertEquals(2, doc.getFields().size());+ assertThat(doc.getFields(), hasSize(2));- assertTrue(binaryFld.binaryValue() != null);+ assertThat(binaryFld.binaryValue(), notNullValue());assertTrue(binaryFld.fieldType().stored());assertEquals(IndexOptions.NONE, binaryFld.fieldType().indexOptions());String binaryTest = doc.getBinaryValue("binary").utf8ToString();- assertTrue(binaryTest.equals(binaryVal));+ assertThat(binaryTest, equalTo(binaryVal));String stringTest = doc.get("string");- assertTrue(binaryTest.equals(stringTest));+ assertThat(binaryTest, equalTo(stringTest));doc.add(binaryFld2);- assertEquals(3, doc.getFields().size());+ assertThat(doc.getFields(), hasSize(3));BytesRef[] binaryTests = doc.getBinaryValues("binary");- assertEquals(2, binaryTests.length);+ assertThat(binaryTests, arrayWithSize(2));binaryTest = binaryTests[0].utf8ToString();String binaryTest2 = binaryTests[1].utf8ToString();- assertFalse(binaryTest.equals(binaryTest2));+ assertThat(binaryTest, not(equalTo(binaryTest2)));- assertTrue(binaryTest.equals(binaryVal));- assertTrue(binaryTest2.equals(binaryVal2));+ assertThat(binaryTest, equalTo(binaryVal));+ assertThat(binaryTest2, equalTo(binaryVal2));doc.removeField("string");- assertEquals(2, doc.getFields().size());+ assertThat(doc.getFields(), hasSize(2));doc.removeFields("binary");- assertEquals(0, doc.getFields().size());+ assertThat(doc.getFields(), empty());}/**@@ -98,32 +110,32 @@ public class TestDocument extends LuceneTestCase {*/public void testRemoveForNewDocument() throws Exception {Document doc = makeDocumentWithFields();- assertEquals(10, doc.getFields().size());+ assertThat(doc.getFields(), hasSize(10));doc.removeFields("keyword");- assertEquals(8, doc.getFields().size());+ assertThat(doc.getFields(), hasSize(8));doc.removeFields("doesnotexists"); // removing non-existing fields is- // siltenlty ignored+ // silently ignoreddoc.removeFields("keyword"); // removing a field more than once- assertEquals(8, doc.getFields().size());+ assertThat(doc.getFields(), hasSize(8));doc.removeField("text");- assertEquals(7, doc.getFields().size());+ assertThat(doc.getFields(), hasSize(7));doc.removeField("text");- assertEquals(6, doc.getFields().size());+ assertThat(doc.getFields(), hasSize(6));doc.removeField("text");- assertEquals(6, doc.getFields().size());+ assertThat(doc.getFields(), hasSize(6));doc.removeField("doesnotexists"); // removing non-existing fields is- // siltenlty ignored- assertEquals(6, doc.getFields().size());+ // silently ignored+ assertThat(doc.getFields(), hasSize(6));doc.removeFields("unindexed");- assertEquals(4, doc.getFields().size());+ assertThat(doc.getFields(), hasSize(4));doc.removeFields("unstored");- assertEquals(2, doc.getFields().size());+ assertThat(doc.getFields(), hasSize(2));doc.removeFields("doesnotexists"); // removing non-existing fields is- // siltenlty ignored- assertEquals(2, doc.getFields().size());+ // silently ignored+ assertThat(doc.getFields(), hasSize(2));doc.removeFields("indexed_not_tokenized");- assertEquals(0, doc.getFields().size());+ assertThat(doc.getFields(), empty());}public void testConstructorExceptions() throws Exception {@@ -156,15 +168,15 @@ public class TestDocument extends LuceneTestCase {public void testClearDocument() {Document doc = makeDocumentWithFields();- assertEquals(10, doc.getFields().size());+ assertThat(doc.getFields(), hasSize(10));doc.clear();- assertEquals(0, doc.getFields().size());+ assertThat(doc.getFields(), empty());}/** test that Document.getFields() actually returns an immutable list */public void testGetFieldsImmutable() {Document doc = makeDocumentWithFields();- assertEquals(10, doc.getFields().size());+ assertThat(doc.getFields(), hasSize(10));List<IndexableField> fields = doc.getFields();expectThrows(UnsupportedOperationException.class,@@ -207,7 +219,7 @@ public class TestDocument extends LuceneTestCase {// ensure that queries return expected results without DateFilter firstScoreDoc[] hits = searcher.search(query, 1000).scoreDocs;- assertEquals(1, hits.length);+ assertThat(hits, arrayWithSize(1));doAssert(searcher.storedFields().document(hits[0].doc), true);writer.close();@@ -233,7 +245,7 @@ public class TestDocument extends LuceneTestCase {PhraseQuery query = new PhraseQuery("indexed_not_tokenized", "test1", "test2");ScoreDoc[] hits = searcher.search(query, 1000).scoreDocs;- assertEquals(1, hits.length);+ assertThat(hits, arrayWithSize(1));doAssert(searcher.storedFields().document(hits[0].doc), true);writer.close();@@ -267,26 +279,26 @@ public class TestDocument extends LuceneTestCase {IndexableField[] unindexedFieldValues = doc.getFields("unindexed");IndexableField[] unstoredFieldValues = doc.getFields("unstored");- assertTrue(keywordFieldValues.length == 2);- assertTrue(textFieldValues.length == 2);- assertTrue(unindexedFieldValues.length == 2);+ assertThat(keywordFieldValues, arrayWithSize(2));+ assertThat(textFieldValues, arrayWithSize(2));+ assertThat(unindexedFieldValues, arrayWithSize(2));// this test cannot work for documents retrieved from the index// since unstored fields will obviously not be returnedif (!fromIndex) {- assertTrue(unstoredFieldValues.length == 2);+ assertThat(unstoredFieldValues, arrayWithSize(2));}- assertTrue(keywordFieldValues[0].stringValue().equals("test1"));- assertTrue(keywordFieldValues[1].stringValue().equals("test2"));- assertTrue(textFieldValues[0].stringValue().equals("test1"));- assertTrue(textFieldValues[1].stringValue().equals("test2"));- assertTrue(unindexedFieldValues[0].stringValue().equals("test1"));- assertTrue(unindexedFieldValues[1].stringValue().equals("test2"));+ assertThat(keywordFieldValues[0].stringValue(), equalTo("test1"));+ assertThat(keywordFieldValues[1].stringValue(), equalTo("test2"));+ assertThat(textFieldValues[0].stringValue(), equalTo("test1"));+ assertThat(textFieldValues[1].stringValue(), equalTo("test2"));+ assertThat(unindexedFieldValues[0].stringValue(), equalTo("test1"));+ assertThat(unindexedFieldValues[1].stringValue(), equalTo("test2"));// this test cannot work for documents retrieved from the index// since unstored fields will obviously not be returnedif (!fromIndex) {- assertTrue(unstoredFieldValues[0].stringValue().equals("test1"));- assertTrue(unstoredFieldValues[1].stringValue().equals("test2"));+ assertThat(unstoredFieldValues[0].stringValue(), equalTo("test1"));+ assertThat(unstoredFieldValues[1].stringValue(), equalTo("test2"));}}@@ -312,21 +324,21 @@ public class TestDocument extends LuceneTestCase {// ensure that queries return expected results without DateFilter firstScoreDoc[] hits = searcher.search(query, 1000).scoreDocs;- assertEquals(3, hits.length);- int result = 0;+ assertThat(hits, arrayWithSize(3));+ Set<String> seen = new HashSet<>();StoredFields storedFields = searcher.storedFields();for (int i = 0; i < 3; i++) {Document doc2 = storedFields.document(hits[i].doc);Field f = (Field) doc2.getField("id");- if (f.stringValue().equals("id1")) result |= 1;- else if (f.stringValue().equals("id2")) result |= 2;- else if (f.stringValue().equals("id3")) result |= 4;- else fail("unexpected id field");+ switch (f.stringValue()) {+ case "id1", "id2", "id3" -> seen.add(f.stringValue());+ default -> fail("unexpected id field");+ }}writer.close();reader.close();dir.close();- assertEquals("did not see all IDs", 7, result);+ assertThat("did not see all IDs", seen, containsInAnyOrder("id1", "id2", "id3"));}// LUCENE-3616@@ -343,19 +355,19 @@ public class TestDocument extends LuceneTestCase {public void testNumericFieldAsString() throws Exception {Document doc = new Document();doc.add(new StoredField("int", 5));- assertEquals("5", doc.get("int"));- assertNull(doc.get("somethingElse"));+ assertThat(doc.get("int"), equalTo("5"));+ assertThat(doc.get("somethingElse"), nullValue());doc.add(new StoredField("int", 4));- assertArrayEquals(new String[] {"5", "4"}, doc.getValues("int"));+ assertThat(doc.getValues("int"), arrayContaining("5", "4"));Directory dir = newDirectory();RandomIndexWriter iw = new RandomIndexWriter(random(), dir);iw.addDocument(doc);DirectoryReader ir = iw.getReader();Document sdoc = ir.storedFields().document(0);- assertEquals("5", sdoc.get("int"));- assertNull(sdoc.get("somethingElse"));- assertArrayEquals(new String[] {"5", "4"}, sdoc.getValues("int"));+ assertThat(sdoc.get("int"), equalTo("5"));+ assertThat(sdoc.get("somethingElse"), nullValue());+ assertThat(doc.getValues("int"), arrayContaining("5", "4"));ir.close();iw.close();dir.close();diff --git a/lucene/core/src/test/org/apache/lucene/index/TestAddIndexes.java b/lucene/core/src/test/org/apache/lucene/index/TestAddIndexes.javaindex 212c1fff9b4..0943c08ba68 100644--- a/lucene/core/src/test/org/apache/lucene/index/TestAddIndexes.java+++ b/lucene/core/src/test/org/apache/lucene/index/TestAddIndexes.java@@ -23,7 +23,7 @@ import java.util.ArrayList;import java.util.Arrays;import java.util.Collections;import java.util.List;-import java.util.stream.Collectors;+import java.util.Set;import org.apache.lucene.codecs.Codec;import org.apache.lucene.codecs.FilterCodec;import org.apache.lucene.codecs.PostingsFormat;@@ -810,10 +810,7 @@ public class TestAddIndexes extends LuceneTestCase {}for (MergePolicy.OneMerge merge : merges) {if (merge.getMergeInfo() != null) {- assertFalse(- Arrays.stream(c.destDir.listAll())- .collect(Collectors.toSet())- .containsAll(merge.getMergeInfo().files()));+ assertFalse(Set.of(c.destDir.listAll()).containsAll(merge.getMergeInfo().files()));}}c.closeAll();diff --git a/lucene/core/src/test/org/apache/lucene/search/TestBooleanScorer.java b/lucene/core/src/test/org/apache/lucene/search/TestBooleanScorer.javaindex 1258dd8b10e..67c7ed2fe5a 100644--- a/lucene/core/src/test/org/apache/lucene/search/TestBooleanScorer.java+++ b/lucene/core/src/test/org/apache/lucene/search/TestBooleanScorer.java@@ -16,6 +16,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.document.Document;@@ -187,7 +190,7 @@ public class TestBooleanScorer extends LuceneTestCase {Weight weight = searcher.createWeight(searcher.rewrite(query), ScoreMode.COMPLETE_NO_SCORES, 1);ScorerSupplier ss = weight.scorerSupplier(ctx);BulkScorer scorer = ((BooleanScorerSupplier) ss).booleanScorer();- assertTrue(scorer instanceof DefaultBulkScorer); // term scorer+ assertThat(scorer, instanceOf(DefaultBulkScorer.class)); // term scorer// scores -> term scorer tooquery =@@ -198,7 +201,7 @@ public class TestBooleanScorer extends LuceneTestCase {weight = searcher.createWeight(searcher.rewrite(query), ScoreMode.COMPLETE, 1);ss = weight.scorerSupplier(ctx);scorer = ((BooleanScorerSupplier) ss).booleanScorer();- assertTrue(scorer instanceof DefaultBulkScorer); // term scorer+ assertThat(scorer, instanceOf(DefaultBulkScorer.class)); // term scorerw.close();reader.close();@@ -229,7 +232,7 @@ public class TestBooleanScorer extends LuceneTestCase {Weight weight = searcher.createWeight(searcher.rewrite(query), ScoreMode.COMPLETE, 1);ScorerSupplier ss = weight.scorerSupplier(ctx);BulkScorer scorer = ((BooleanScorerSupplier) ss).booleanScorer();- assertTrue(scorer instanceof ReqExclBulkScorer);+ assertThat(scorer, instanceOf(ReqExclBulkScorer.class));query =new BooleanQuery.Builder()@@ -240,7 +243,7 @@ public class TestBooleanScorer extends LuceneTestCase {weight = searcher.createWeight(searcher.rewrite(query), ScoreMode.COMPLETE, 1);ss = weight.scorerSupplier(ctx);scorer = ((BooleanScorerSupplier) ss).booleanScorer();- assertTrue(scorer instanceof ReqExclBulkScorer);+ assertThat(scorer, instanceOf(ReqExclBulkScorer.class));query =new BooleanQuery.Builder()@@ -250,7 +253,7 @@ public class TestBooleanScorer extends LuceneTestCase {weight = searcher.createWeight(searcher.rewrite(query), ScoreMode.COMPLETE, 1);ss = weight.scorerSupplier(ctx);scorer = ((BooleanScorerSupplier) ss).booleanScorer();- assertTrue(scorer instanceof ReqExclBulkScorer);+ assertThat(scorer, instanceOf(ReqExclBulkScorer.class));query =new BooleanQuery.Builder()@@ -260,7 +263,7 @@ public class TestBooleanScorer extends LuceneTestCase {weight = searcher.createWeight(searcher.rewrite(query), ScoreMode.COMPLETE, 1);ss = weight.scorerSupplier(ctx);scorer = ((BooleanScorerSupplier) ss).booleanScorer();- assertTrue(scorer instanceof ReqExclBulkScorer);+ assertThat(scorer, instanceOf(ReqExclBulkScorer.class));w.close();reader.close();@@ -330,8 +333,8 @@ public class TestBooleanScorer extends LuceneTestCase {.add(new TermQuery(new Term("foo", "bar")), Occur.FILTER).build();Query rewrite = searcher.rewrite(query);- assertTrue(rewrite instanceof BoostQuery);- assertTrue(((BoostQuery) rewrite).getQuery() instanceof ConstantScoreQuery);+ assertThat(rewrite, instanceOf(BoostQuery.class));+ assertThat(((BoostQuery) rewrite).getQuery(), instanceOf(ConstantScoreQuery.class));}Query[] queries =@@ -359,9 +362,9 @@ public class TestBooleanScorer extends LuceneTestCase {Weight weight = searcher.createWeight(rewrite, scoreMode, 1f);Scorer scorer = weight.scorer(reader.leaves().get(0));if (scoreMode == ScoreMode.TOP_SCORES) {- assertTrue(scorer instanceof ConstantScoreScorer);+ assertThat(scorer, instanceOf(ConstantScoreScorer.class));} else {- assertFalse(scorer instanceof ConstantScoreScorer);+ assertThat(scorer, not(instanceOf(ConstantScoreScorer.class)));}}}@@ -391,7 +394,7 @@ public class TestBooleanScorer extends LuceneTestCase {for (ScoreMode scoreMode : ScoreMode.values()) {Weight weight = searcher.createWeight(rewrite, scoreMode, 1f);Scorer scorer = weight.scorer(reader.leaves().get(0));- assertFalse(scorer instanceof ConstantScoreScorer);+ assertThat(scorer, not(instanceOf(ConstantScoreScorer.class)));}}diff --git a/lucene/core/src/test/org/apache/lucene/util/TestArrayUtil.java b/lucene/core/src/test/org/apache/lucene/util/TestArrayUtil.javaindex 41f320ba007..90e5bafc9fa 100644--- a/lucene/core/src/test/org/apache/lucene/util/TestArrayUtil.java+++ b/lucene/core/src/test/org/apache/lucene/util/TestArrayUtil.java@@ -20,6 +20,12 @@ import static org.apache.lucene.util.ArrayUtil.copyOfSubArray;import static org.apache.lucene.util.ArrayUtil.growExact;import static org.apache.lucene.util.ArrayUtil.growInRange;import static org.apache.lucene.util.ArrayUtil.oversize;+import static org.hamcrest.Matchers.equalTo;+import static org.hamcrest.Matchers.greaterThan;+import static org.hamcrest.Matchers.greaterThanOrEqualTo;+import static org.hamcrest.Matchers.lessThan;+import static org.hamcrest.Matchers.lessThanOrEqualTo;+import static org.hamcrest.Matchers.sameInstance;import java.util.Arrays;import java.util.Collections;@@ -38,11 +44,11 @@ public class TestArrayUtil extends LuceneTestCase {// Make sure ArrayUtil hits Integer.MAX_VALUE, if we insist:while (currentSize != ArrayUtil.MAX_ARRAY_LENGTH) {int nextSize = ArrayUtil.oversize(1 + currentSize, RamUsageEstimator.NUM_BYTES_OBJECT_REF);- assertTrue(nextSize > currentSize);+ assertThat(nextSize, greaterThan(currentSize));if (currentSize > 0) {copyCost += currentSize;double copyCostPerElement = ((double) copyCost) / currentSize;- assertTrue("cost " + copyCostPerElement, copyCostPerElement < 10.0);+ assertThat(copyCostPerElement, lessThan(10.0));}currentSize = nextSize;}@@ -77,7 +83,7 @@ public class TestArrayUtil extends LuceneTestCase {final int minTargetSize = rnd.nextInt(ArrayUtil.MAX_ARRAY_LENGTH);final int elemSize = rnd.nextInt(11);final int v = ArrayUtil.oversize(minTargetSize, elemSize);- assertTrue(v >= minTargetSize);+ assertThat(v, greaterThanOrEqualTo(minTargetSize));}}@@ -113,16 +119,11 @@ public class TestArrayUtil extends LuceneTestCase {parseInt("0.34");});- int test = parseInt("1");- assertTrue(test + " does not equal: " + 1, test == 1);- test = parseInt("-10000");- assertTrue(test + " does not equal: " + -10000, test == -10000);- test = parseInt("1923");- assertTrue(test + " does not equal: " + 1923, test == 1923);- test = parseInt("-1");- assertTrue(test + " does not equal: " + -1, test == -1);- test = ArrayUtil.parseInt("foo 1923 bar".toCharArray(), 4, 4);- assertTrue(test + " does not equal: " + 1923, test == 1923);+ assertThat(parseInt("1"), equalTo(1));+ assertThat(parseInt("-10000"), equalTo(-10000));+ assertThat(parseInt("1923"), equalTo(1923));+ assertThat(parseInt("-1"), equalTo(-1));+ assertThat(ArrayUtil.parseInt("foo 1923 bar".toCharArray(), 4, 4), equalTo(1923));}private Integer[] createRandomArray(int maxSize) {@@ -232,9 +233,9 @@ public class TestArrayUtil extends LuceneTestCase {final Item act = items[i];if (act.order == 0) {// order of "equal" items should be not mixed up- assertTrue(act.val > last.val);+ assertThat(act.val, greaterThan(last.val));}- assertTrue(act.order >= last.order);+ assertThat(act.order, greaterThanOrEqualTo(last.order));last = act;}}@@ -261,9 +262,9 @@ public class TestArrayUtil extends LuceneTestCase {final Item act = items[i];if (act.order == 0) {// order of "equal" items should be not mixed up- assertTrue(act.val > last.val);+ assertThat(act.val, greaterThan(last.val));}- assertTrue(act.order >= last.order);+ assertThat(act.order, greaterThanOrEqualTo(last.order));last = act;}}@@ -302,11 +303,11 @@ public class TestArrayUtil extends LuceneTestCase {assertEquals(expected[k], actual[k]);for (int i = 0; i < actual.length; ++i) {if (i < from || i >= to) {- assertSame(arr[i], actual[i]);+ assertThat(actual[i], sameInstance(arr[i]));} else if (i <= k) {- assertTrue(actual[i].intValue() <= actual[k].intValue());+ assertThat(actual[i], lessThanOrEqualTo(actual[k]));} else {- assertTrue(actual[i].intValue() >= actual[k].intValue());+ assertThat(actual[i], greaterThanOrEqualTo(actual[k]));}}}diff --git a/lucene/core/src/test/org/apache/lucene/util/TestPriorityQueue.java b/lucene/core/src/test/org/apache/lucene/util/TestPriorityQueue.javaindex ed226570eee..dc7f2feb9e0 100644--- a/lucene/core/src/test/org/apache/lucene/util/TestPriorityQueue.java+++ b/lucene/core/src/test/org/apache/lucene/util/TestPriorityQueue.java@@ -16,6 +16,10 @@*/package org.apache.lucene.util;+import static org.hamcrest.Matchers.equalTo;+import static org.hamcrest.Matchers.greaterThanOrEqualTo;+import static org.hamcrest.Matchers.lessThanOrEqualTo;+import java.util.ArrayList;import java.util.Collections;import java.util.Iterator;@@ -24,7 +28,6 @@ import java.util.NoSuchElementException;import java.util.Random;import org.apache.lucene.tests.util.LuceneTestCase;import org.apache.lucene.tests.util.TestUtil;-import org.hamcrest.MatcherAssert;import org.hamcrest.Matchers;@SuppressWarnings("BoxedPrimitiveEquality")@@ -94,7 +97,7 @@ public class TestPriorityQueue extends LuceneTestCase {// All elements are "equal" so we should have exactly the indexes of those elements that were// added first.- MatcherAssert.assertThat(indexes, Matchers.containsInAnyOrder(0, 1, 2, 3, 4));+ assertThat(indexes, Matchers.containsInAnyOrder(0, 1, 2, 3, 4));}public void testPQ() throws Exception {@@ -114,7 +117,7 @@ public class TestPriorityQueue extends LuceneTestCase {int last = Integer.MIN_VALUE;for (int i = 0; i < count; i++) {Integer next = pq.pop();- assertTrue(next.intValue() >= last);+ assertThat(next, greaterThanOrEqualTo(last));last = next.intValue();sum2 += last;}@@ -158,10 +161,10 @@ public class TestPriorityQueue extends LuceneTestCase {assertNull(pq.insertWithOverflow(i2));assertNull(pq.insertWithOverflow(i3));assertNull(pq.insertWithOverflow(i4));- assertTrue(pq.insertWithOverflow(i5) == i3); // i3 should have been dropped- assertTrue(pq.insertWithOverflow(i6) == i6); // i6 should not have been inserted- assertEquals(size, pq.size());- assertEquals((Integer) 2, pq.top());+ assertThat(pq.insertWithOverflow(i5), equalTo(i3)); // i3 should have been dropped+ assertThat(pq.insertWithOverflow(i6), equalTo(i6)); // i6 should not have been inserted+ assertThat(pq.size(), equalTo(size));+ assertThat(pq.top(), equalTo(2));}public void testAddAllToEmptyQueue() {@@ -236,8 +239,8 @@ public class TestPriorityQueue extends LuceneTestCase {if ((lastLeast != null) && (newLeast != newEntry) && (newLeast != lastLeast)) {// If there has been a change of least entry and it wasn't our new// addition we expect the scores to increase- assertTrue(newLeast <= newEntry);- assertTrue(newLeast >= lastLeast);+ assertThat(newLeast, lessThanOrEqualTo(newEntry));+ assertThat(newLeast, greaterThanOrEqualTo(lastLeast));}lastLeast = newLeast;}@@ -259,8 +262,8 @@ public class TestPriorityQueue extends LuceneTestCase {// If there has been a change of least entry and it wasn't our new// addition or the loss of our randomly removed entry we expect the// scores to increase- assertTrue(newLeast <= newEntry);- assertTrue(newLeast >= lastLeast);+ assertThat(newLeast, lessThanOrEqualTo(newEntry));+ assertThat(newLeast, greaterThanOrEqualTo(lastLeast));}lastLeast = newLeast;}diff --git a/lucene/core/src/test/org/apache/lucene/util/TestRadixSelector.java b/lucene/core/src/test/org/apache/lucene/util/TestRadixSelector.javaindex 1f60dfb3555..ec1849dc3b5 100644--- a/lucene/core/src/test/org/apache/lucene/util/TestRadixSelector.java+++ b/lucene/core/src/test/org/apache/lucene/util/TestRadixSelector.java@@ -16,6 +16,11 @@*/package org.apache.lucene.util;+import static org.hamcrest.Matchers.equalTo;+import static org.hamcrest.Matchers.greaterThanOrEqualTo;+import static org.hamcrest.Matchers.lessThanOrEqualTo;+import static org.hamcrest.Matchers.sameInstance;+import java.util.Arrays;import org.apache.lucene.tests.util.LuceneTestCase;import org.apache.lucene.tests.util.TestUtil;@@ -98,14 +103,14 @@ public class TestRadixSelector extends LuceneTestCase {};selector.select(from, to, k);- assertEquals(expected[k], actual[k]);+ assertThat(actual[k], equalTo(expected[k]));for (int i = 0; i < actual.length; ++i) {if (i < from || i >= to) {- assertSame(arr[i], actual[i]);+ assertThat(actual[i], sameInstance(arr[i]));} else if (i <= k) {- assertTrue(actual[i].compareTo(actual[k]) <= 0);+ assertThat(actual[i], lessThanOrEqualTo(actual[k]));} else {- assertTrue(actual[i].compareTo(actual[k]) >= 0);+ assertThat(actual[i], greaterThanOrEqualTo(actual[k]));}}}diff --git a/lucene/core/src/test/org/apache/lucene/util/automaton/TestIntSet.java b/lucene/core/src/test/org/apache/lucene/util/automaton/TestIntSet.javaindex 5b02437a38f..271240c3fc4 100644--- a/lucene/core/src/test/org/apache/lucene/util/automaton/TestIntSet.java+++ b/lucene/core/src/test/org/apache/lucene/util/automaton/TestIntSet.java@@ -16,6 +16,9 @@*/package org.apache.lucene.util.automaton;+import static org.hamcrest.Matchers.equalTo;+import static org.hamcrest.Matchers.greaterThan;+import org.apache.lucene.tests.util.LuceneTestCase;import org.junit.Test;@@ -56,14 +59,14 @@ public class TestIntSet extends LuceneTestCase {set.incr(i);}- assertTrue(set.size() > 32);+ assertThat(set.size(), greaterThan(32));for (int i = 0; i < 35; i++) {// This is pretty much the worst case, perf wiseset.decr(i);}- assertTrue(set.size() == 0);+ assertThat(set.size(), equalTo(0));}@Testdiff --git a/lucene/core/src/test/org/apache/lucene/util/automaton/TestRegExp.java b/lucene/core/src/test/org/apache/lucene/util/automaton/TestRegExp.javaindex 37cb5ddfc6b..d1348781526 100644--- a/lucene/core/src/test/org/apache/lucene/util/automaton/TestRegExp.java+++ b/lucene/core/src/test/org/apache/lucene/util/automaton/TestRegExp.java@@ -16,8 +16,13 @@*/package org.apache.lucene.util.automaton;+import static org.hamcrest.Matchers.containsString;+import static org.hamcrest.Matchers.emptyString;+import static org.hamcrest.Matchers.hasToString;+import static org.hamcrest.Matchers.matchesRegex;+import static org.hamcrest.Matchers.not;+import java.util.Locale;-import java.util.regex.Matcher;import java.util.regex.Pattern;import org.apache.lucene.tests.util.LuceneTestCase;import org.apache.lucene.tests.util.automaton.AutomatonTestUtil;@@ -97,19 +102,19 @@ public class TestRegExp extends LuceneTestCase {public void testRepeatWithEmptyString() throws Exception {Automaton a = new RegExp("[^y]*{1,2}").toAutomaton();// paranoia:- assertTrue(a.toString().length() > 0);+ assertThat(a, hasToString(not(emptyString())));}public void testRepeatWithEmptyLanguage() throws Exception {Automaton a = new RegExp("#*").toAutomaton();// paranoia:- assertTrue(a.toString().length() > 0);+ assertThat(a, hasToString(not(emptyString())));a = new RegExp("#+").toAutomaton();- assertTrue(a.toString().length() > 0);+ assertThat(a, hasToString(not(emptyString())));a = new RegExp("#{2,10}").toAutomaton();- assertTrue(a.toString().length() > 0);+ assertThat(a, hasToString(not(emptyString())));a = new RegExp("#?").toAutomaton();- assertTrue(a.toString().length() > 0);+ assertThat(a, hasToString(not(emptyString())));}boolean caseSensitiveQuery = true;@@ -140,7 +145,7 @@ public class TestRegExp extends LuceneTestCase {() -> {new RegExp(illegalExpression);});- assertTrue(expected.getMessage().contains("invalid character class"));+ assertThat(expected.getMessage(), containsString("invalid character class"));}}@@ -160,7 +165,7 @@ public class TestRegExp extends LuceneTestCase {() -> {new RegExp("a{99,11}");});- assertTrue(expected.getMessage().contains("out of order"));+ assertThat(expected.getMessage(), containsString("out of order"));}static String randomDocValue(int minLength, boolean includeUnicode) {@@ -291,9 +296,7 @@ public class TestRegExp extends LuceneTestCase {caseSensitiveQuery? Pattern.compile(regexPattern): Pattern.compile(regexPattern, Pattern.CASE_INSENSITIVE | Pattern.UNICODE_CASE);- Matcher matcher = pattern.matcher(docValue);- assertTrue(- "Java regex " + regexPattern + " did not match doc value " + docValue, matcher.matches());+ assertThat(docValue, matchesRegex(pattern));int matchFlags =caseSensitiveQuery ? 0 : RegExp.ASCII_CASE_INSENSITIVE | RegExp.CASE_INSENSITIVE;diff --git a/lucene/test-framework/src/java/module-info.java b/lucene/test-framework/src/java/module-info.javaindex f366d1f52b7..27753354048 100644--- a/lucene/test-framework/src/java/module-info.java+++ b/lucene/test-framework/src/java/module-info.java@@ -22,6 +22,7 @@ module org.apache.lucene.test_framework {requires org.apache.lucene.codecs;requires transitive junit;requires transitive randomizedtesting.runner;+ requires org.hamcrest;// Open certain packages for junit because it scans methods via reflection.opens org.apache.lucene.tests.index todiff --git a/lucene/test-framework/src/java/org/apache/lucene/tests/index/BaseCompressingDocValuesFormatTestCase.java b/lucene/test-framework/src/java/org/apache/lucene/tests/index/BaseCompressingDocValuesFormatTestCase.javaindex e00954243ae..88a36a190e3 100644--- a/lucene/test-framework/src/java/org/apache/lucene/tests/index/BaseCompressingDocValuesFormatTestCase.java+++ b/lucene/test-framework/src/java/org/apache/lucene/tests/index/BaseCompressingDocValuesFormatTestCase.java@@ -16,6 +16,8 @@*/package org.apache.lucene.tests.index;+import static org.hamcrest.Matchers.lessThan;+import com.carrotsearch.randomizedtesting.generators.RandomPicks;import java.io.IOException;import java.util.ArrayList;@@ -72,7 +74,7 @@ public abstract class BaseCompressingDocValuesFormatTestCase extends BaseDocValuiwriter.forceMerge(1);final long size2 = dirSize(dir);// make sure the new longs did not cost 8 bytes each- assertTrue(size2 < size1 + 8 * 20);+ assertThat(size2, lessThan(size1 + 8 * 20));}}@@ -100,7 +102,7 @@ public abstract class BaseCompressingDocValuesFormatTestCase extends BaseDocValuiwriter.forceMerge(1);final long size2 = dirSize(dir);// make sure the new longs costed less than if they had only been packed- assertTrue(size2 < size1 + (PackedInts.bitsRequired(day) * 50) / 8);+ assertThat(size2, lessThan(size1 + (PackedInts.bitsRequired(day) * 50) / 8));}}@@ -123,7 +125,7 @@ public abstract class BaseCompressingDocValuesFormatTestCase extends BaseDocValuiwriter.forceMerge(1);final long size2 = dirSize(dir);// make sure the new value did not grow the bpv for every other value- assertTrue(size2 < size1 + (20000 * (63 - 10)) / 8);+ assertThat(size2, lessThan(size1 + (20000 * (63 - 10)) / 8));}}}diff --git a/lucene/test-framework/src/java/org/apache/lucene/tests/store/BaseDirectoryTestCase.java b/lucene/test-framework/src/java/org/apache/lucene/tests/store/BaseDirectoryTestCase.javaindex f00b3811d0c..cbcd953edbf 100644--- a/lucene/test-framework/src/java/org/apache/lucene/tests/store/BaseDirectoryTestCase.java+++ b/lucene/test-framework/src/java/org/apache/lucene/tests/store/BaseDirectoryTestCase.java@@ -17,6 +17,10 @@package org.apache.lucene.tests.store;import static com.carrotsearch.randomizedtesting.generators.RandomPicks.randomFrom;+import static org.hamcrest.Matchers.containsInAnyOrder;+import static org.hamcrest.Matchers.containsString;+import static org.hamcrest.Matchers.hasItemInArray;+import static org.hamcrest.Matchers.not;import com.carrotsearch.randomizedtesting.RandomizedTest;import com.carrotsearch.randomizedtesting.generators.RandomBytes;@@ -67,7 +71,6 @@ import org.apache.lucene.util.Constants;import org.apache.lucene.util.GroupVIntUtil;import org.apache.lucene.util.IOUtils;import org.apache.lucene.util.packed.PackedInts;-import org.junit.Assert;/** Base class for {@link Directory} implementations. */public abstract class BaseDirectoryTestCase extends LuceneTestCase {@@ -132,13 +135,13 @@ public abstract class BaseDirectoryTestCase extends LuceneTestCase {public void testDeleteFile() throws Exception {try (Directory dir = getDirectory(createTempDir("testDeleteFile"))) {String file = "foo.txt";- Assert.assertFalse(Arrays.asList(dir.listAll()).contains(file));+ assertThat(dir.listAll(), not(hasItemInArray(file)));dir.createOutput("foo.txt", IOContext.DEFAULT).close();- Assert.assertTrue(Arrays.asList(dir.listAll()).contains(file));+ assertThat(dir.listAll(), hasItemInArray(file));dir.deleteFile("foo.txt");- Assert.assertFalse(Arrays.asList(dir.listAll()).contains(file));+ assertThat(dir.listAll(), not(hasItemInArray(file)));expectThrowsAnyOf(Arrays.asList(NoSuchFileException.class, FileNotFoundException.class),@@ -681,7 +684,7 @@ public abstract class BaseDirectoryTestCase extends LuceneTestCase {String name = "file";dir.createOutput(name, newIOContext(random())).close();assertTrue(slowFileExists(dir, name));- assertTrue(Arrays.asList(dir.listAll()).contains(name));+ assertThat(dir.listAll(), hasItemInArray(name));}}@@ -1258,7 +1261,7 @@ public abstract class BaseDirectoryTestCase extends LuceneTestCase {public void testIndexOutputToString() throws Throwable {try (Directory dir = getDirectory(createTempDir())) {IndexOutput out = dir.createOutput("camelCase.txt", newIOContext(random()));- assertTrue(out.toString(), out.toString().contains("camelCase.txt"));+ assertThat(out.toString(), containsString("camelCase.txt"));out.close();}}@@ -1305,7 +1308,7 @@ public abstract class BaseDirectoryTestCase extends LuceneTestCase {.filter(file -> !ExtrasFS.isExtra(file)) // remove any ExtrasFS stuff..collect(Collectors.toSet());- assertEquals(new HashSet<String>(names), files);+ assertThat(files, containsInAnyOrder(names.toArray()));}}@@ -1396,7 +1399,7 @@ public abstract class BaseDirectoryTestCase extends LuceneTestCase {}// Make sure listAll does NOT include the file:- assertFalse(Arrays.asList(fsDir.listAll()).contains(fileName));+ assertThat(fsDir.listAll(), not(hasItemInArray(fileName)));// Make sure fileLength claims it's deleted:expectThrows(diff --git a/lucene/test-framework/src/java/org/apache/lucene/tests/util/LuceneTestCase.java b/lucene/test-framework/src/java/org/apache/lucene/tests/util/LuceneTestCase.javaindex fb2ea781212..922762a1e1a 100644--- a/lucene/test-framework/src/java/org/apache/lucene/tests/util/LuceneTestCase.java+++ b/lucene/test-framework/src/java/org/apache/lucene/tests/util/LuceneTestCase.java@@ -205,6 +205,8 @@ import org.apache.lucene.util.automaton.Automaton;import org.apache.lucene.util.automaton.CompiledAutomaton;import org.apache.lucene.util.automaton.Operations;import org.apache.lucene.util.automaton.RegExp;+import org.hamcrest.Matcher;+import org.hamcrest.MatcherAssert;import org.junit.After;import org.junit.AfterClass;import org.junit.Assert;@@ -2086,6 +2088,15 @@ public abstract class LuceneTestCase extends Assert {return IOUtils.requireResourceNonNull(this.getClass().getResourceAsStream(name), name);}+ // these hide the deprecated Assert.assertThat method+ public static <T> void assertThat(T actual, Matcher<? super T> matcher) {+ MatcherAssert.assertThat(actual, matcher);+ }++ public static <T> void assertThat(String reason, T actual, Matcher<? super T> matcher) {+ MatcherAssert.assertThat(reason, actual, matcher);+ }+public void assertReaderEquals(String info, IndexReader leftReader, IndexReader rightReader)throws IOException {assertReaderStatisticsEquals(info, leftReader, rightReader);diff --git a/lucene/test-framework/src/java/org/apache/lucene/tests/util/TestUtil.java b/lucene/test-framework/src/java/org/apache/lucene/tests/util/TestUtil.javaindex f1e42ed2f47..aa21b822782 100644--- a/lucene/test-framework/src/java/org/apache/lucene/tests/util/TestUtil.java+++ b/lucene/test-framework/src/java/org/apache/lucene/tests/util/TestUtil.java@@ -17,6 +17,13 @@package org.apache.lucene.tests.util;import static java.nio.charset.StandardCharsets.UTF_8;+import static org.hamcrest.MatcherAssert.assertThat;+import static org.hamcrest.Matchers.arrayWithSize;+import static org.hamcrest.Matchers.equalTo;+import static org.hamcrest.Matchers.greaterThanOrEqualTo;+import static org.hamcrest.Matchers.instanceOf;+import static org.hamcrest.Matchers.lessThanOrEqualTo;+import static org.hamcrest.Matchers.not;import com.carrotsearch.randomizedtesting.RandomizedTest;import com.carrotsearch.randomizedtesting.generators.RandomNumbers;@@ -1478,29 +1485,34 @@ public final class TestUtil {"wrong total hits", expected.totalHits.value() == 0, actual.totalHits.value() == 0);if (expected.totalHits.relation() == TotalHits.Relation.EQUAL_TO) {if (actual.totalHits.relation() == TotalHits.Relation.EQUAL_TO) {- Assert.assertEquals(- "wrong total hits", expected.totalHits.value(), actual.totalHits.value());+ assertThat(+ "wrong total hits", actual.totalHits.value(), equalTo(expected.totalHits.value()));} else {- Assert.assertTrue(- "wrong total hits", expected.totalHits.value() >= actual.totalHits.value());+ assertThat(+ "wrong total hits",+ actual.totalHits.value(),+ lessThanOrEqualTo(expected.totalHits.value()));}} else if (actual.totalHits.relation() == TotalHits.Relation.EQUAL_TO) {- Assert.assertTrue("wrong total hits", expected.totalHits.value() <= actual.totalHits.value());+ assertThat(+ "wrong total hits",+ actual.totalHits.value(),+ greaterThanOrEqualTo(expected.totalHits.value()));}- Assert.assertEquals("wrong hit count", expected.scoreDocs.length, actual.scoreDocs.length);+ assertThat("wrong hit count", actual.scoreDocs, arrayWithSize(expected.scoreDocs.length));for (int hitIDX = 0; hitIDX < expected.scoreDocs.length; hitIDX++) {final ScoreDoc expectedSD = expected.scoreDocs[hitIDX];final ScoreDoc actualSD = actual.scoreDocs[hitIDX];- Assert.assertEquals("wrong hit docID", expectedSD.doc, actualSD.doc);+ assertThat("wrong hit docID", actualSD.doc, equalTo(expectedSD.doc));Assert.assertEquals("wrong hit score", expectedSD.score, actualSD.score, 0.0);if (expectedSD instanceof FieldDoc) {- Assert.assertTrue(actualSD instanceof FieldDoc);+ assertThat(actualSD, instanceOf(FieldDoc.class));Assert.assertArrayEquals("wrong sort field values",((FieldDoc) expectedSD).fields,((FieldDoc) actualSD).fields);} else {- Assert.assertFalse(actualSD instanceof FieldDoc);+ assertThat(actualSD, not(instanceOf(FieldDoc.class)));}}}diff --git a/lucene/test-framework/src/test/org/apache/lucene/tests/store/TestSerializedIOCountingDirectory.java b/lucene/test-framework/src/test/org/apache/lucene/tests/store/TestSerializedIOCountingDirectory.javaindex 7c6f232aef0..b7596e3fec1 100644--- a/lucene/test-framework/src/test/org/apache/lucene/tests/store/TestSerializedIOCountingDirectory.java+++ b/lucene/test-framework/src/test/org/apache/lucene/tests/store/TestSerializedIOCountingDirectory.java@@ -16,6 +16,9 @@*/package org.apache.lucene.tests.store;+import static org.hamcrest.Matchers.equalTo;+import static org.hamcrest.Matchers.not;+import java.io.IOException;import java.nio.file.Path;import org.apache.lucene.store.Directory;@@ -47,7 +50,7 @@ public class TestSerializedIOCountingDirectory extends BaseDirectoryTestCase {in.readByte();}// Sequential reads are free with the normal advice- assertEquals(count, dir.count());+ assertThat(dir.count(), equalTo(count));}try (IndexInput in =dir.openInput("test", IOContext.DEFAULT.withReadAdvice(ReadAdvice.RANDOM))) {@@ -57,7 +60,7 @@ public class TestSerializedIOCountingDirectory extends BaseDirectoryTestCase {in.readByte();}// But not with the random advice- assertFalse(count == dir.count());+ assertThat(dir.count(), not(equalTo(count)));}}}