From 4c56b0aedb0284140ef94aa3db0531da7342c628 Mon Sep 17 00:00:00 2001 From: Henning Baldersheim Date: Sun, 19 Dec 2021 19:19:28 +0100 Subject: Simplify testing by sticking to assertEquals/True/False --- .../expression/FloatBucketResultNodeTestCase.java | 5 +- .../IntegerBucketResultNodeTestCase.java | 8 +-- .../expression/IntegerResultNodeTestCase.java | 67 +++++++++++----------- .../expression/NullResultNodeTestCase.java | 23 +++----- .../expression/RawBucketResultNodeTestCase.java | 7 +-- .../yahoo/searchlib/expression/ResultNodeTest.java | 5 +- .../expression/ResultNodeVectorTestCase.java | 37 ++++++------ .../expression/StringBucketResultNodeTestCase.java | 8 +-- 8 files changed, 71 insertions(+), 89 deletions(-) (limited to 'searchlib') 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: ")); 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()); -- cgit v1.2.3