Simplify testing by sticking to assertEquals/True/False

8 files changed, 71 insertions, 89 deletions

diff --git a/searchlib/src/test/java/com/yahoo/searchlib/expression/FloatBucketResultNodeTestCase.java b/searchlib/src/test/java/com/yahoo/searchlib/expression/FloatBucketResultNodeTestCase.java
index 1acfb3cdc7e..78db838cefe 100644
--- a/searchlib/src/test/java/com/yahoo/searchlib/expression/FloatBucketResultNodeTestCase.java
+++ b/searchlib/src/test/java/com/yahoo/searchlib/expression/FloatBucketResultNodeTestCase.java
@@ -3,8 +3,9 @@ package com.yahoo.searchlib.expression;
 
 import org.junit.Test;
 
-import static org.hamcrest.core.Is.is;
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
 
 /**
  * @author Ulf Lilleengen
diff --git a/searchlib/src/test/java/com/yahoo/searchlib/expression/IntegerBucketResultNodeTestCase.java b/searchlib/src/test/java/com/yahoo/searchlib/expression/IntegerBucketResultNodeTestCase.java
index c038a207ba2..00c0739ed9a 100644
--- a/searchlib/src/test/java/com/yahoo/searchlib/expression/IntegerBucketResultNodeTestCase.java
+++ b/searchlib/src/test/java/com/yahoo/searchlib/expression/IntegerBucketResultNodeTestCase.java
@@ -1,12 +1,10 @@
 // Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
 package com.yahoo.searchlib.expression;
 
-import com.yahoo.vespa.objects.BufferSerializer;
 import org.junit.Test;
 
-import static org.hamcrest.core.Is.is;
+import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertThat;
 import static org.junit.Assert.assertTrue;
 
 /**
@@ -25,8 +23,8 @@ public class IntegerBucketResultNodeTestCase extends ResultNodeTest {
     @Test
     public void testRange() {
         IntegerBucketResultNode bucket = new IntegerBucketResultNode(4, 10);
-        assertThat(bucket.getFrom(), is(4l));
-        assertThat(bucket.getTo(), is(10l));
+        assertEquals(4, bucket.getFrom());
+        assertEquals(10, bucket.getTo());
         assertFalse(bucket.empty());
         assertTrue(dumpNode(bucket).contains("from: 4"));
         assertTrue(dumpNode(bucket).contains("to: 10"));
diff --git a/searchlib/src/test/java/com/yahoo/searchlib/expression/IntegerResultNodeTestCase.java b/searchlib/src/test/java/com/yahoo/searchlib/expression/IntegerResultNodeTestCase.java
index b081506dca8..744df472fb2 100644
--- a/searchlib/src/test/java/com/yahoo/searchlib/expression/IntegerResultNodeTestCase.java
+++ b/searchlib/src/test/java/com/yahoo/searchlib/expression/IntegerResultNodeTestCase.java
@@ -1,17 +1,14 @@
 // Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
 package com.yahoo.searchlib.expression;
 
-import com.yahoo.vespa.objects.BufferSerializer;
-import com.yahoo.vespa.objects.ObjectDumper;
 import org.junit.Test;
 
 import java.lang.reflect.InvocationTargetException;
 import java.util.Arrays;
 import java.util.List;
 
-import static org.hamcrest.core.Is.is;
+import static org.junit.Assert.assertArrayEquals;
 import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertThat;
 import static org.junit.Assert.assertTrue;
 
 /**
@@ -29,52 +26,52 @@ public class IntegerResultNodeTestCase extends ResultNodeTest {
 
     @Test
     public void testClassId() {
-        assertThat(new Int8ResultNode().getClassId(), is(Int8ResultNode.classId));
-        assertThat(new Int16ResultNode().getClassId(), is(Int16ResultNode.classId));
-        assertThat(new Int32ResultNode().getClassId(), is(Int32ResultNode.classId));
-        assertThat(new IntegerResultNode().getClassId(), is(IntegerResultNode.classId));
-        assertThat(new BoolResultNode().getClassId(), is(BoolResultNode.classId));
+        assertEquals(Int8ResultNode.classId, new Int8ResultNode().getClassId());
+        assertEquals(Int16ResultNode.classId, new Int16ResultNode().getClassId());
+        assertEquals(Int32ResultNode.classId, new Int32ResultNode().getClassId());
+        assertEquals(IntegerResultNode.classId, new IntegerResultNode().getClassId());
+        assertEquals(BoolResultNode.classId, new BoolResultNode().getClassId());
     }
 
     @Test
     public void testTypeConversion() {
         for (NumericResultNode node : getResultNodes(3)) {
-            assertThat(node.getInteger(), is(3l));
-            assertEquals(node.getFloat(), 3.0, 0.01);
-            assertThat(node.getRaw(), is(new byte[]{0, 0, 0, 0, 0, 0, 0, (byte) 3}));
-            assertThat(node.getString(), is("3"));
-            assertThat(node.getNumber().toString(), is("3"));
+            assertEquals(3, node.getInteger());
+            assertEquals(3.0, node.getFloat(), 0.01);
+            assertArrayEquals(new byte[]{0, 0, 0, 0, 0, 0, 0, (byte) 3}, node.getRaw());
+            assertEquals("3", node.getString());
+            assertEquals("3", node.getNumber().toString());
         }
     }
 
     @Test
     public void testMath() {
         for (NumericResultNode node : getResultNodes(5)) {
-            assertThat(node.getInteger(), is(5l));
+            assertEquals(5, node.getInteger());
             node.negate();
-            assertThat(node.getInteger(), is(-5l));
+            assertEquals(-5, node.getInteger());
             node.multiply(new Int32ResultNode(3));
-            assertThat(node.getInteger(), is(-15l));
+            assertEquals(-15, node.getInteger());
             node.add(new Int32ResultNode(1));
-            assertThat(node.getInteger(), is(-14l));
+            assertEquals(-14, node.getInteger());
             node.divide(new Int32ResultNode(2));
-            assertThat(node.getInteger(), is(-7l));
+            assertEquals(-7, node.getInteger());
             node.modulo(new Int32ResultNode(3));
-            assertThat(node.getInteger(), is(-1l));
+            assertEquals(-1, node.getInteger());
             node.min(new Int32ResultNode(2));
-            assertThat(node.getInteger(), is(-1l));
+            assertEquals(-1, node.getInteger());
             node.min(new Int32ResultNode(-2));
-            assertThat(node.getInteger(), is(-2l));
+            assertEquals(-2, node.getInteger());
             node.max(new Int32ResultNode(-4));
-            assertThat(node.getInteger(), is(-2l));
+            assertEquals(-2, node.getInteger());
             node.max(new Int32ResultNode(4));
-            assertThat(node.getInteger(), is(4l));
-            assertThat(node.onCmp(new Int32ResultNode(3)), is(1));
-            assertThat(node.onCmp(new Int32ResultNode(4)), is(0));
-            assertThat(node.onCmp(new Int32ResultNode(5)), is(-1));
+            assertEquals(4, node.getInteger());
+            assertEquals(1, node.onCmp(new Int32ResultNode(3)));
+            assertEquals(0, node.onCmp(new Int32ResultNode(4)));
+            assertEquals(-1, node.onCmp(new Int32ResultNode(5)));
             node.set(new Int32ResultNode(8));
-            assertThat(node.getInteger(), is(8l));
-            assertThat(node.hashCode(), is((int)(8 + node.getClassId())));
+            assertEquals(8, node.getInteger());
+            assertEquals(8 + node.getClassId(), node.hashCode());
             assertTrue(dumpNode(node).contains("value: 8"));
         }
     }
@@ -95,37 +92,37 @@ public class IntegerResultNodeTestCase extends ResultNodeTest {
     public void testInt8() {
         Int8ResultNode node = new Int8ResultNode();
         node.setValue((byte) 5);
-        assertThat(node.getInteger(), is(5l));
+        assertEquals(5, node.getInteger());
     }
 
     @Test
     public void testInt16() {
         Int16ResultNode node = new Int16ResultNode();
         node.setValue((short)5);
-        assertThat(node.getInteger(), is(5l));
+        assertEquals(5, node.getInteger());
     }
 
     @Test
     public void testInt32() {
         Int32ResultNode node = new Int32ResultNode();
         node.setValue(5);
-        assertThat(node.getInteger(), is(5l));
+        assertEquals(5, node.getInteger());
     }
 
     @Test
     public void testLong() {
         IntegerResultNode node = new IntegerResultNode();
         node.setValue(5);
-        assertThat(node.getInteger(), is(5l));
+        assertEquals(5, node.getInteger());
     }
 
     @Test
     public void testSerialization() throws IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
         for (NumericResultNode node : getResultNodes(8)) {
-            assertThat(node.getInteger(), is(8L));
+            assertEquals(8, node.getInteger());
             NumericResultNode out = node.getClass().getConstructor().newInstance();
             assertCorrectSerialization(node, out);
-            assertThat(out.getInteger(), is(node.getInteger()));
+            assertEquals(out.getInteger(), node.getInteger());
         }
     }
 }
diff --git a/searchlib/src/test/java/com/yahoo/searchlib/expression/NullResultNodeTestCase.java b/searchlib/src/test/java/com/yahoo/searchlib/expression/NullResultNodeTestCase.java
index ff2af418ad4..64c30769f60 100644
--- a/searchlib/src/test/java/com/yahoo/searchlib/expression/NullResultNodeTestCase.java
+++ b/searchlib/src/test/java/com/yahoo/searchlib/expression/NullResultNodeTestCase.java
@@ -3,13 +3,8 @@ package com.yahoo.searchlib.expression;
 
 import com.yahoo.vespa.objects.ObjectDumper;
 import org.junit.Test;
-
-import java.util.regex.Pattern;
-
-import static org.hamcrest.core.Is.is;
-import static org.hamcrest.core.IsNot.not;
 import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertThat;
+import static org.junit.Assert.assertNotEquals;
 import static org.junit.Assert.assertTrue;
 
 /**
@@ -20,17 +15,17 @@ public class NullResultNodeTestCase {
     @Test
     public void testNullResultNode() {
         NullResultNode nullRes = new NullResultNode();
-        assertThat(nullRes.onGetClassId(), is(NullResultNode.classId));
-        assertThat(nullRes.getInteger(), is(0l));
-        assertThat(nullRes.getString(), is(""));
-        assertThat(nullRes.getRaw(), is(new byte[0]));
-        assertEquals(nullRes.getFloat(), 0.0, 0.01);
-        assertThat(nullRes.onCmp(new NullResultNode()), is(0));
-        assertThat(nullRes.onCmp(new IntegerResultNode(0)), is(not(0)));
+        assertEquals(NullResultNode.classId, nullRes.onGetClassId());
+        assertEquals(0, nullRes.getInteger());
+        assertTrue(nullRes.getString().isEmpty());
+        assertEquals(0, nullRes.getRaw().length);
+        assertEquals(0.0, nullRes.getFloat(), 0.01);
+        assertEquals(0, nullRes.onCmp(new NullResultNode()));
+        assertNotEquals(0, nullRes.onCmp(new IntegerResultNode(0)));
         ObjectDumper dumper = new ObjectDumper();
         nullRes.visitMembers(dumper);
         assertTrue(dumper.toString().contains("result: <NULL>"));
         nullRes.set(new IntegerResultNode(3));
-        assertThat(nullRes.onCmp(new IntegerResultNode(3)), is(not(0)));
+        assertNotEquals(0, nullRes.onCmp(new IntegerResultNode(3)));
     }
 }
diff --git a/searchlib/src/test/java/com/yahoo/searchlib/expression/RawBucketResultNodeTestCase.java b/searchlib/src/test/java/com/yahoo/searchlib/expression/RawBucketResultNodeTestCase.java
index eef4f225778..ab9fb2e2e50 100644
--- a/searchlib/src/test/java/com/yahoo/searchlib/expression/RawBucketResultNodeTestCase.java
+++ b/searchlib/src/test/java/com/yahoo/searchlib/expression/RawBucketResultNodeTestCase.java
@@ -3,9 +3,8 @@ package com.yahoo.searchlib.expression;
 
 import org.junit.Test;
 
-import static org.hamcrest.core.Is.is;
+import static org.junit.Assert.assertArrayEquals;
 import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertThat;
 import static org.junit.Assert.assertTrue;
 
 /**
@@ -24,8 +23,8 @@ public class RawBucketResultNodeTestCase extends ResultNodeTest {
     public void testRange() {
         RawBucketResultNode bucket = new RawBucketResultNode(new RawResultNode(new byte[]{6, 9}), new RawResultNode(new byte[]{9, 6}));
         assertFalse(bucket.empty());
-        assertThat(bucket.getFrom(), is(new byte[]{6, 9}));
-        assertThat(bucket.getTo(), is(new byte[]{9, 6}));
+        assertArrayEquals(new byte[]{6, 9}, bucket.getFrom());
+        assertArrayEquals(new byte[]{9, 6}, bucket.getTo());
         assertCorrectSerialization(bucket, new RawBucketResultNode());
         assertTrue(dumpNode(bucket).contains("value: RawData(data = [6, 9])"));
         assertTrue(dumpNode(bucket).contains("value: RawData(data = [9, 6])"));
diff --git a/searchlib/src/test/java/com/yahoo/searchlib/expression/ResultNodeTest.java b/searchlib/src/test/java/com/yahoo/searchlib/expression/ResultNodeTest.java
index fb033801352..52be4d422d5 100644
--- a/searchlib/src/test/java/com/yahoo/searchlib/expression/ResultNodeTest.java
+++ b/searchlib/src/test/java/com/yahoo/searchlib/expression/ResultNodeTest.java
@@ -4,8 +4,7 @@ package com.yahoo.searchlib.expression;
 import com.yahoo.vespa.objects.BufferSerializer;
 import com.yahoo.vespa.objects.ObjectDumper;
 
-import static org.hamcrest.core.Is.is;
-import static org.junit.Assert.assertThat;
+import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
 
 /**
@@ -24,7 +23,7 @@ public class ResultNodeTest {
         from.serialize(buffer);
         buffer.flip();
         to.deserialize(buffer);
-        assertThat(from.onCmp(to), is(0));
+        assertEquals(0, from.onCmp(to));
     }
 
     public void assertOrder(ResultNode a, ResultNode b, ResultNode c) {
diff --git a/searchlib/src/test/java/com/yahoo/searchlib/expression/ResultNodeVectorTestCase.java b/searchlib/src/test/java/com/yahoo/searchlib/expression/ResultNodeVectorTestCase.java
index 54f4744897a..614e6bb608a 100644
--- a/searchlib/src/test/java/com/yahoo/searchlib/expression/ResultNodeVectorTestCase.java
+++ b/searchlib/src/test/java/com/yahoo/searchlib/expression/ResultNodeVectorTestCase.java
@@ -1,14 +1,9 @@
 // Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
 package com.yahoo.searchlib.expression;
 
-import com.yahoo.vespa.objects.BufferSerializer;
 import org.junit.Test;
-
-import java.util.List;
-
-import static org.hamcrest.core.Is.is;
-import static org.hamcrest.core.IsNot.not;
-import static org.junit.Assert.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotEquals;
 import static org.junit.Assert.assertTrue;
 
 /**
@@ -18,12 +13,12 @@ import static org.junit.Assert.assertTrue;
 public class ResultNodeVectorTestCase extends ResultNodeTest {
     @Test
     public void testClassId() {
-        assertThat(new IntegerResultNodeVector().getClassId(), is(IntegerResultNodeVector.classId));
-        assertThat(new Int32ResultNodeVector().getClassId(), is(Int32ResultNodeVector.classId));
-        assertThat(new Int16ResultNodeVector().getClassId(), is(Int16ResultNodeVector.classId));
-        assertThat(new Int8ResultNodeVector().getClassId(), is(Int8ResultNodeVector.classId));
-        assertThat(new FloatResultNodeVector().getClassId(), is(FloatResultNodeVector.classId));
-        assertThat(new BoolResultNodeVector().getClassId(), is(BoolResultNodeVector.classId));
+        assertEquals(IntegerResultNodeVector.classId, new IntegerResultNodeVector().getClassId());
+        assertEquals(Int32ResultNodeVector.classId, new Int32ResultNodeVector().getClassId());
+        assertEquals(Int16ResultNodeVector.classId, new Int16ResultNodeVector().getClassId());
+        assertEquals(Int8ResultNodeVector.classId, new Int8ResultNodeVector().getClassId());
+        assertEquals(FloatResultNodeVector.classId, new FloatResultNodeVector().getClassId());
+        assertEquals(BoolResultNodeVector.classId, new BoolResultNodeVector().getClassId());
     }
 
     @Test
@@ -32,37 +27,37 @@ public class ResultNodeVectorTestCase extends ResultNodeTest {
         b.add(new BoolResultNode(true));
         b.add(new BoolResultNode(false));
         b.add((ResultNode)new BoolResultNode(false));
-        assertThat(b.getVector().size(), is(3));
+        assertEquals(3, b.getVector().size());
 
         Int8ResultNodeVector i8 = new Int8ResultNodeVector();
         i8.add(new Int8ResultNode((byte)9));
         i8.add(new Int8ResultNode((byte)2));
         i8.add((ResultNode)new Int8ResultNode((byte)5));
-        assertThat(i8.getVector().size(), is(3));
+        assertEquals(3, i8.getVector().size());
 
         Int16ResultNodeVector i16 = new Int16ResultNodeVector();
         i16.add(new Int16ResultNode((short)9));
         i16.add(new Int16ResultNode((short)2));
         i16.add((ResultNode)new Int16ResultNode((short)5));
-        assertThat(i16.getVector().size(), is(3));
+        assertEquals(3, i16.getVector().size());
 
         Int32ResultNodeVector i32 = new Int32ResultNodeVector();
         i32.add(new Int32ResultNode(9));
         i32.add(new Int32ResultNode(2));
         i32.add((ResultNode)new Int32ResultNode(5));
-        assertThat(i32.getVector().size(), is(3));
+        assertEquals(3, i32.getVector().size());
 
         IntegerResultNodeVector ieger = new IntegerResultNodeVector();
         ieger.add(new IntegerResultNode(9));
         ieger.add(new IntegerResultNode(2));
         ieger.add((ResultNode)new IntegerResultNode(5));
-        assertThat(ieger.getVector().size(), is(3));
+        assertEquals(3, ieger.getVector().size());
 
         FloatResultNodeVector floatvec = new FloatResultNodeVector();
         floatvec.add(new FloatResultNode(3.3));
         floatvec.add(new FloatResultNode(3.4));
         floatvec.add((ResultNode)new FloatResultNode(3.5));
-        assertThat(floatvec.getVector().size(), is(3));
+        assertEquals(3, floatvec.getVector().size());
     }
 
     @Test
@@ -155,11 +150,11 @@ public class ResultNodeVectorTestCase extends ResultNodeTest {
     }
 
     private void assertVecEqual(ResultNodeVector vec1, ResultNodeVector vec2) {
-        assertThat(vec1.onCmp(vec2), is(0));
+        assertEquals(0, vec1.onCmp(vec2));
     }
 
     private void assertClassCmp(ResultNodeVector add) {
-        assertThat(add.onCmp(new NullResultNode()), is(not(0)));
+        assertNotEquals(0, add.onCmp(new NullResultNode()));
     }
 
     @Test
diff --git a/searchlib/src/test/java/com/yahoo/searchlib/expression/StringBucketResultNodeTestCase.java b/searchlib/src/test/java/com/yahoo/searchlib/expression/StringBucketResultNodeTestCase.java
index 15c89b4beb3..fee60c9df7b 100644
--- a/searchlib/src/test/java/com/yahoo/searchlib/expression/StringBucketResultNodeTestCase.java
+++ b/searchlib/src/test/java/com/yahoo/searchlib/expression/StringBucketResultNodeTestCase.java
@@ -2,9 +2,7 @@
 package com.yahoo.searchlib.expression;
 
 import org.junit.Test;
-
-import static org.hamcrest.core.Is.is;
-import static org.junit.Assert.assertThat;
+import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
 
 /**
@@ -22,8 +20,8 @@ public class StringBucketResultNodeTestCase extends ResultNodeTest {
     @Test
     public void testRange() {
         StringBucketResultNode bucket = new StringBucketResultNode("a", "d");
-        assertThat(bucket.getFrom(), is("a"));
-        assertThat(bucket.getTo(), is("d"));
+        assertEquals("a", bucket.getFrom());
+        assertEquals("d", bucket.getTo());
         assertTrue(dumpNode(bucket).contains("value: 'a'"));
         assertTrue(dumpNode(bucket).contains("value: 'd'"));
         assertCorrectSerialization(bucket, new StringBucketResultNode());