diff options
author | Håvard Pettersen <havardpe@yahooinc.com> | 2023-03-29 13:52:30 +0000 |
---|---|---|
committer | Håvard Pettersen <havardpe@yahooinc.com> | 2023-03-30 10:36:47 +0000 |
commit | 97d7ab6a1f4606710eb4dcf9a690e861d5cce3dd (patch) | |
tree | 9b5c3c847fb94a7046be9a7fd9cb624cae6452fd /vespajlib/src | |
parent | fb55d2e1f4e31465ab5b6758d41077f70bd2c589 (diff) |
avoid hamcrest and mockito
Diffstat (limited to 'vespajlib/src')
6 files changed, 380 insertions, 369 deletions
diff --git a/vespajlib/src/test/java/com/yahoo/slime/ArrayValueTestCase.java b/vespajlib/src/test/java/com/yahoo/slime/ArrayValueTestCase.java index c9ff86e7c2e..730c3909b4c 100644 --- a/vespajlib/src/test/java/com/yahoo/slime/ArrayValueTestCase.java +++ b/vespajlib/src/test/java/com/yahoo/slime/ArrayValueTestCase.java @@ -2,11 +2,11 @@ package com.yahoo.slime; import org.junit.Test; - -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.CoreMatchers.not; -import static org.hamcrest.CoreMatchers.sameInstance; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertSame; +import static org.junit.Assert.assertNotSame; import java.util.List; import java.util.ArrayList; @@ -20,17 +20,17 @@ public class ArrayValueTestCase { @Test public void testSymbolTableForwarding() { SymbolTable names = new SymbolTable(); - assertThat(names.symbols(), is(0)); + assertEquals(0, names.symbols()); new ArrayValue(names).addArray().addObject().setLong("foo", 3); - assertThat(names.symbols(), is(1)); + assertEquals(1, names.symbols()); } @Test public void testOutOfBoundsAccess() { var array = makeArray(); array.addBool(true); - assertThat(array.entry(-1).valid(), is(false)); - assertThat(array.entry(1).valid(), is(false)); + assertFalse(array.entry(-1).valid()); + assertFalse(array.entry(1).valid()); } @Test @@ -44,8 +44,8 @@ public class ArrayValueTestCase { var e1 = array.entry(i); var e2 = array.entry(i); var e3 = added.get(i); - assertThat(e1, sameInstance(e2)); - assertThat(e1, sameInstance(e3)); + assertSame(e2, e1); + assertSame(e3, e1); } } @@ -61,12 +61,12 @@ public class ArrayValueTestCase { var e1 = array.entry(i); var e2 = array.entry(i); var e3 = added.get(i); - assertThat(e1, not(sameInstance(e2))); - assertThat(e1, not(sameInstance(e3))); - assertThat(e1.equalTo(e2), is(true)); - assertThat(e1.equalTo(e3), is(true)); - assertThat(e1.type(), is(Type.LONG)); - assertThat(e1.asLong(), is(expect)); + assertNotSame(e2, e1); + assertNotSame(e3, e1); + assertTrue(e1.equalTo(e2)); + assertTrue(e1.equalTo(e3)); + assertEquals(Type.LONG, e1.type()); + assertEquals(expect, e1.asLong()); } } @@ -82,12 +82,12 @@ public class ArrayValueTestCase { var e1 = array.entry(i); var e2 = array.entry(i); var e3 = added.get(i); - assertThat(e1, not(sameInstance(e2))); - assertThat(e1, not(sameInstance(e3))); - assertThat(e1.equalTo(e2), is(true)); - assertThat(e1.equalTo(e3), is(true)); - assertThat(e1.type(), is(Type.DOUBLE)); - assertThat(e1.asDouble(), is(expect)); + assertNotSame(e2, e1); + assertNotSame(e3, e1); + assertTrue(e1.equalTo(e2)); + assertTrue(e1.equalTo(e3)); + assertEquals(Type.DOUBLE, e1.type()); + assertEquals(expect, e1.asDouble(), 0.0); } } @@ -109,20 +109,20 @@ public class ArrayValueTestCase { case ARRAY: added.add(array.addArray()); break; case OBJECT: added.add(array.addObject()); break; } - assertThat(array.entries(), is(65)); - assertThat(array.entry(64).type(), is(type)); - assertThat(added.get(64), sameInstance(array.entry(64))); + assertEquals(65, array.entries()); + assertEquals(type, array.entry(64).type()); + assertSame(array.entry(64), added.get(64)); for (int i = 0; i < 64; ++i) { var e1 = array.entry(i); var e2 = array.entry(i); var e3 = added.get(i); long expect = i; - assertThat(e1, sameInstance(e2)); - assertThat(e1, not(sameInstance(e3))); - assertThat(e1.equalTo(e2), is(true)); - assertThat(e1.equalTo(e3), is(true)); - assertThat(e1.type(), is(Type.LONG)); - assertThat(e1.asLong(), is(expect)); + assertSame(e2, e1); + assertNotSame(e3, e1); + assertTrue(e1.equalTo(e2)); + assertTrue(e1.equalTo(e3)); + assertEquals(Type.LONG, e1.type()); + assertEquals(expect, e1.asLong()); } } } @@ -146,20 +146,20 @@ public class ArrayValueTestCase { case ARRAY: added.add(array.addArray()); break; case OBJECT: added.add(array.addObject()); break; } - assertThat(array.entries(), is(65)); - assertThat(array.entry(64).type(), is(type)); - assertThat(added.get(64), sameInstance(array.entry(64))); + assertEquals(65, array.entries()); + assertEquals(type, array.entry(64).type()); + assertSame(array.entry(64), added.get(64)); for (int i = 0; i < 64; ++i) { var e1 = array.entry(i); var e2 = array.entry(i); var e3 = added.get(i); double expect = i; - assertThat(e1, sameInstance(e2)); - assertThat(e1, not(sameInstance(e3))); - assertThat(e1.equalTo(e2), is(true)); - assertThat(e1.equalTo(e3), is(true)); - assertThat(e1.type(), is(Type.DOUBLE)); - assertThat(e1.asDouble(), is(expect)); + assertSame(e2, e1); + assertNotSame(e3, e1); + assertTrue(e1.equalTo(e2)); + assertTrue(e1.equalTo(e3)); + assertEquals(Type.DOUBLE, e1.type()); + assertEquals(expect, e1.asDouble(), 0.0); } } } @@ -179,9 +179,9 @@ public class ArrayValueTestCase { case ARRAY: added = array.addArray(); break; case OBJECT: added = array.addObject(); break; } - assertThat(array.entries(), is(1)); - assertThat(array.entry(0).type(), is(type)); - assertThat(added, sameInstance(array.entry(0))); + assertEquals(1, array.entries()); + assertEquals(type, array.entry(0).type()); + assertSame(array.entry(0), added); } } } diff --git a/vespajlib/src/test/java/com/yahoo/slime/BinaryFormatTestCase.java b/vespajlib/src/test/java/com/yahoo/slime/BinaryFormatTestCase.java index db001a9276b..5f96247b77e 100644 --- a/vespajlib/src/test/java/com/yahoo/slime/BinaryFormatTestCase.java +++ b/vespajlib/src/test/java/com/yahoo/slime/BinaryFormatTestCase.java @@ -12,9 +12,10 @@ import static com.yahoo.slime.BinaryFormat.decode_zigzag; import static com.yahoo.slime.BinaryFormat.encode_double; import static com.yahoo.slime.BinaryFormat.encode_type_and_meta; import static com.yahoo.slime.BinaryFormat.encode_zigzag; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; - +import static org.junit.Assert.assertArrayEquals; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.assertFalse; public class BinaryFormatTestCase { @@ -36,50 +37,50 @@ public class BinaryFormatTestCase { BinaryEncoder bof = new BinaryEncoder(output); bof.encode_cmpr_int(value); byte[] actual = output.toArray(); - assertThat(actual, is(expect)); + assertArrayEquals(expect, actual); BinaryDecoder bif = new BinaryDecoder(); bif.in = new BufferedInput(expect); int got = bif.in.read_cmpr_int(); - assertThat(got, is(value)); - assertThat(bif.in.failed(), is(false)); + assertEquals(value, got); + assertFalse(bif.in.failed()); bif = new BinaryDecoder(); bif.in = new BufferedInput(expect); got = bif.in.skip_cmpr_int(); - assertThat(got, is(expect.length - 1)); - assertThat(bif.in.getPosition(), is(expect.length)); - assertThat(bif.in.failed(), is(false)); + assertEquals(expect.length - 1, got); + assertEquals(expect.length, bif.in.getPosition()); + assertFalse(bif.in.failed()); - assertThat(BinaryView.peek_cmpr_int_for_testing(expect, 0), is(value)); - assertThat(BinaryView.skip_cmpr_int_for_testing(expect, 0), is(expect.length)); + assertEquals(value, BinaryView.peek_cmpr_int_for_testing(expect, 0)); + assertEquals(expect.length, BinaryView.skip_cmpr_int_for_testing(expect, 0)); } void verify_read_cmpr_int_fails(byte[] data) { BinaryDecoder bif = new BinaryDecoder(); bif.in = new BufferedInput(data); int got = bif.in.read_cmpr_int(); - assertThat(got, is(0)); - assertThat(bif.in.failed(), is(true)); + assertEquals(0, got); + assertTrue(bif.in.failed()); bif = new BinaryDecoder(); bif.in = new BufferedInput(data); got = bif.in.skip_cmpr_int(); - assertThat(got, is(data.length - 1)); - assertThat(bif.in.getPosition(), is(data.length)); - assertThat(bif.in.failed(), is(false)); + assertEquals(data.length - 1, got); + assertEquals(data.length, bif.in.getPosition()); + assertFalse(bif.in.failed()); - assertThat(BinaryView.skip_cmpr_int_for_testing(data, 0), is(data.length)); + assertEquals(data.length, BinaryView.skip_cmpr_int_for_testing(data, 0)); } // was verifyBasic void verifyEncoding(Slime slime, byte[] expect) { - assertThat(BinaryFormat.encode(slime), is(expect)); - assertThat(slime.get().equalTo(BinaryView.inspect(expect)), is(true)); + assertArrayEquals(expect, BinaryFormat.encode(slime)); + assertTrue(slime.get().equalTo(BinaryView.inspect(expect))); Compressor compressor = new Compressor(CompressionType.LZ4, 3, 2, 0); Compressor.Compression result = BinaryFormat.encode_and_compress(slime, compressor); byte [] decompressed = compressor.decompress(result); - assertThat(decompressed, is(expect)); + assertArrayEquals(expect, decompressed); verifyMultiEncode(expect); } @@ -90,65 +91,65 @@ public class BinaryFormatTestCase { for (int i = 0; i < 5; ++i) { Slime slime = BinaryFormat.decode(buffers[i]); buffers[i+1] = BinaryFormat.encode(slime); - assertThat(buffers[i+1], is(expect)); + assertArrayEquals(expect, buffers[i+1]); } } @Test public void testZigZagConversion() { - assertThat(encode_zigzag(0), is(0L)); - assertThat(decode_zigzag(encode_zigzag(0)), is(0L)); + assertEquals(0L, encode_zigzag(0)); + assertEquals(0L, decode_zigzag(encode_zigzag(0))); - assertThat(encode_zigzag(-1), is(1L)); - assertThat(decode_zigzag(encode_zigzag(-1)), is(-1L)); + assertEquals(1L, encode_zigzag(-1)); + assertEquals(-1L, decode_zigzag(encode_zigzag(-1))); - assertThat(encode_zigzag(1), is(2L)); - assertThat(decode_zigzag(encode_zigzag(1)), is(1L)); + assertEquals(2L, encode_zigzag(1)); + assertEquals(1L, decode_zigzag(encode_zigzag(1))); - assertThat(encode_zigzag(-2), is(3L)); - assertThat(decode_zigzag(encode_zigzag(-2)), is(-2L)); + assertEquals(3L, encode_zigzag(-2)); + assertEquals(-2L, decode_zigzag(encode_zigzag(-2))); - assertThat(encode_zigzag(2), is(4L)); - assertThat(decode_zigzag(encode_zigzag(2)), is(2L)); + assertEquals(4L, encode_zigzag(2)); + assertEquals(2L, decode_zigzag(encode_zigzag(2))); - assertThat(encode_zigzag(-1000), is(1999L)); - assertThat(decode_zigzag(encode_zigzag(-1000)), is(-1000L)); + assertEquals(1999L, encode_zigzag(-1000)); + assertEquals(-1000L, decode_zigzag(encode_zigzag(-1000))); - assertThat(encode_zigzag(1000), is(2000L)); - assertThat(decode_zigzag(encode_zigzag(1000)), is(1000L)); + assertEquals(2000L, encode_zigzag(1000)); + assertEquals(1000L, decode_zigzag(encode_zigzag(1000))); - assertThat(encode_zigzag(-0x8000000000000000L), is(-1L)); - assertThat(decode_zigzag(encode_zigzag(-0x8000000000000000L)), is(-0x8000000000000000L)); + assertEquals(-1L, encode_zigzag(-0x8000000000000000L)); + assertEquals(-0x8000000000000000L, decode_zigzag(encode_zigzag(-0x8000000000000000L))); - assertThat(encode_zigzag(0x7fffffffffffffffL), is(-2L)); - assertThat(decode_zigzag(encode_zigzag(0x7fffffffffffffffL)), is(0x7fffffffffffffffL)); + assertEquals(-2L, encode_zigzag(0x7fffffffffffffffL)); + assertEquals(0x7fffffffffffffffL, decode_zigzag(encode_zigzag(0x7fffffffffffffffL))); } @Test public void testDoubleConversion() { - assertThat(encode_double(0.0), is(0L)); - assertThat(decode_double(encode_double(0.0)), is(0.0)); + assertEquals(0L, encode_double(0.0)); + assertEquals(0.0, decode_double(encode_double(0.0)), 0.0); - assertThat(encode_double(1.0), is(0x3ff0000000000000L)); - assertThat(decode_double(encode_double(1.0)), is(1.0)); + assertEquals(0x3ff0000000000000L, encode_double(1.0)); + assertEquals(1.0, decode_double(encode_double(1.0)), 0.0); - assertThat(encode_double(-1.0), is(0xbff0000000000000L)); - assertThat(decode_double(encode_double(-1.0)), is(-1.0)); + assertEquals(0xbff0000000000000L, encode_double(-1.0)); + assertEquals(-1.0, decode_double(encode_double(-1.0)), 0.0); - assertThat(encode_double(2.0), is(0x4000000000000000L)); - assertThat(decode_double(encode_double(2.0)), is(2.0)); + assertEquals(0x4000000000000000L, encode_double(2.0)); + assertEquals(2.0, decode_double(encode_double(2.0)), 0.0); - assertThat(encode_double(-2.0), is(0xc000000000000000L)); - assertThat(decode_double(encode_double(-2.0)), is(-2.0)); + assertEquals(0xc000000000000000L, encode_double(-2.0)); + assertEquals(-2.0, decode_double(encode_double(-2.0)), 0.0); - assertThat(encode_double(-0.0), is(0x8000000000000000L)); - assertThat(decode_double(encode_double(-0.0)), is(-0.0)); + assertEquals(0x8000000000000000L, encode_double(-0.0)); + assertEquals(-0.0, decode_double(encode_double(-0.0)), 0.0); - assertThat(encode_double(3.5), is(0x400c000000000000L)); - assertThat(decode_double(encode_double(3.5)), is(3.5)); + assertEquals(0x400c000000000000L, encode_double(3.5)); + assertEquals(3.5, decode_double(encode_double(3.5)), 0.0); - assertThat(encode_double(65535.875), is(0x40EFFFFC00000000L)); - assertThat(decode_double(encode_double(65535.875)), is(65535.875)); + assertEquals(0x40EFFFFC00000000L, encode_double(65535.875)); + assertEquals(65535.875, decode_double(encode_double(65535.875)), 0.0); } @Test @@ -156,8 +157,8 @@ public class BinaryFormatTestCase { for (byte type = 0; type < TYPE_LIMIT; ++type) { for (int meta = 0; meta < META_LIMIT; ++meta) { byte mangled = encode_type_and_meta(type, meta); - assertThat(decode_type(mangled).ID, is(type)); - assertThat(decode_meta(mangled), is(meta)); + assertEquals(type, decode_type(mangled).ID); + assertEquals(meta, decode_meta(mangled)); } } } @@ -241,7 +242,7 @@ public class BinaryFormatTestCase { BinaryEncoder encoder = new BinaryEncoder(actual); encoder.write_type_and_size(type, size); } - assertThat(actual.toArray(), is(expect.toArray())); + assertArrayEquals(expect.toArray(), actual.toArray()); byte[] got = expect.toArray(); BinaryDecoder bif = new BinaryDecoder(); @@ -249,12 +250,12 @@ public class BinaryFormatTestCase { byte b = bif.in.getByte(); Type decodedType = decode_type(b); int decodedSize = bif.in.read_size(decode_meta(b)); - assertThat(decodedType.ID, is(type)); - assertThat(decodedSize, is(size)); - assertThat(bif.in.getConsumedSize(), is(got.length)); - assertThat(bif.in.failed(), is(false)); + assertEquals(type, decodedType.ID); + assertEquals(size, decodedSize); + assertEquals(got.length, bif.in.getConsumedSize()); + assertFalse(bif.in.failed()); - assertThat(BinaryView.extract_children_for_testing(got, 0), is(size)); + assertEquals(size, BinaryView.extract_children_for_testing(got, 0)); } } @@ -292,21 +293,21 @@ public class BinaryFormatTestCase { bof.write_type_and_bytes_le(type, bits); } byte[] actual = output.toArray(); - assertThat(actual, is(expect)); + assertArrayEquals(expect, actual); // test input: BinaryDecoder bif = new BinaryDecoder(); bif.in = new BufferedInput(expect); int size = decode_meta(bif.in.getByte()); long decodedBits = (hi != 0) ? bif.read_bytes_be(size) : bif.read_bytes_le(size); - assertThat(decodedBits, is(bits)); - assertThat(bif.in.getConsumedSize(), is(expect.length)); - assertThat(bif.in.failed(), is(false)); + assertEquals(bits, decodedBits); + assertEquals(expect.length, bif.in.getConsumedSize()); + assertFalse(bif.in.failed()); if (hi != 0) { - assertThat(encode_double(BinaryView.extract_double_for_testing(expect, 0)), is(bits)); + assertEquals(bits, encode_double(BinaryView.extract_double_for_testing(expect, 0))); } else { - assertThat(encode_zigzag(BinaryView.extract_long_for_testing(expect, 0)), is(bits)); + assertEquals(bits, encode_zigzag(BinaryView.extract_long_for_testing(expect, 0))); } } } @@ -322,7 +323,7 @@ public class BinaryFormatTestCase { expect.put((byte)0); // nix byte[] actual = BinaryFormat.encode(slime); - assertThat(actual, is(expect.toArray())); + assertArrayEquals(expect.toArray(), actual); verifyMultiEncode(expect.toArray()); } @@ -428,7 +429,7 @@ public class BinaryFormatTestCase { System.arraycopy(expect, 0, overlappingBuffer, 1, expect.length); overlappingBuffer[overlappingBuffer.length - 1] = 0; Slime copy = BinaryFormat.decode(overlappingBuffer, 1, expect.length); - assertThat(BinaryFormat.encode(slime), is(BinaryFormat.encode(copy))); + assertArrayEquals(BinaryFormat.encode(copy), BinaryFormat.encode(slime)); } @Test @@ -550,18 +551,17 @@ public class BinaryFormatTestCase { BinaryDecoder decoder = new BinaryDecoder(); Slime slime = decoder.decode(data); int consumed = decoder.in.getConsumedSize(); - assertThat(consumed, is(data.length)); + assertEquals(data.length, consumed); Cursor c = slime.get(); - assertThat(c.valid(), is(true)); - assertThat(c.type(), is(Type.OBJECT)); - assertThat(c.children(), is(5)); - assertThat(c.field("b").asBool(), is(true)); - assertThat(c.field("c").asLong(), is(5L)); - assertThat(c.field("d").asDouble(), is(3.5)); - assertThat(c.field("e").asString(), is("string")); + assertTrue(c.valid()); + assertEquals(Type.OBJECT, c.type()); + assertEquals(5, c.children()); + assertTrue(c.field("b").asBool()); + assertEquals(5L, c.field("c").asLong()); + assertEquals(3.5, c.field("d").asDouble(), 0.0); + assertEquals("string", c.field("e").asString()); byte[] expd = { 'd', 'a', 't', 'a' }; - assertThat(c.field("f").asData(), is(expd)); - assertThat(c.entry(5).valid(), is(false)); // not ARRAY + assertArrayEquals(expd, c.field("f").asData()); + assertFalse(c.entry(5).valid()); // not ARRAY } - } diff --git a/vespajlib/src/test/java/com/yahoo/slime/BinaryViewTest.java b/vespajlib/src/test/java/com/yahoo/slime/BinaryViewTest.java index 568124369d4..920a25b96c9 100644 --- a/vespajlib/src/test/java/com/yahoo/slime/BinaryViewTest.java +++ b/vespajlib/src/test/java/com/yahoo/slime/BinaryViewTest.java @@ -140,99 +140,43 @@ public class BinaryViewTest { } } - class MyVisitor implements Visitor { - enum Called { NONE, INVALID, NIX, BOOL, LONG, DOUBLE, UTF8, DATA, ARRAY, OBJECT } - Called called = Called.NONE; - boolean boolValue; - long longValue; - double doubleValue; - byte[] bytes; - Inspector stuff; - @Override public void visitInvalid() { - assertEquals(ctx, Called.NONE, called); - called = Called.INVALID; - } - @Override public void visitNix() { - assertEquals(ctx, Called.NONE, called); - called = Called.NIX; - } - @Override public void visitBool(boolean bit) { - assertEquals(ctx, Called.NONE, called); - called = Called.BOOL; - boolValue = bit; - } - @Override public void visitLong(long l) { - assertEquals(ctx, Called.NONE, called); - called = Called.LONG; - longValue = l; - } - @Override public void visitDouble(double d) { - assertEquals(ctx, Called.NONE, called); - called = Called.DOUBLE; - doubleValue = d; - } - @Override public void visitString(String str) { - fail(ctx + ", strings are never utf-16 in binary view"); - } - @Override public void visitString(byte[] utf8) { - assertEquals(ctx, Called.NONE, called); - called = Called.UTF8; - bytes = utf8; - } - @Override public void visitData(byte[] data) { - assertEquals(ctx, Called.NONE, called); - called = Called.DATA; - bytes = data; - } - @Override public void visitArray(Inspector arr) { - assertEquals(ctx, Called.NONE, called); - called = Called.ARRAY; - stuff = arr; - } - @Override public void visitObject(Inspector obj) { - assertEquals(ctx, Called.NONE, called); - called = Called.OBJECT; - stuff = obj; - } - }; - void checkVisitor(Inspector view) { - var visitor = new MyVisitor(); + var visitor = new MockVisitor(ctx); view.accept(visitor); if (!view.valid()) { - assertEquals(ctx, MyVisitor.Called.INVALID, visitor.called); + assertEquals(ctx, MockVisitor.Called.INVALID, visitor.called); return; } switch (view.type()) { case NIX: - assertEquals(ctx, MyVisitor.Called.NIX, visitor.called); + assertEquals(ctx, MockVisitor.Called.NIX, visitor.called); break; case BOOL: - assertEquals(ctx, MyVisitor.Called.BOOL, visitor.called); + assertEquals(ctx, MockVisitor.Called.BOOL, visitor.called); assertEquals(ctx, view.asBool(), visitor.boolValue); break; case LONG: - assertEquals(ctx, MyVisitor.Called.LONG, visitor.called); + assertEquals(ctx, MockVisitor.Called.LONG, visitor.called); assertEquals(ctx, view.asLong(), visitor.longValue); break; case DOUBLE: - assertEquals(ctx, MyVisitor.Called.DOUBLE, visitor.called); + assertEquals(ctx, MockVisitor.Called.DOUBLE, visitor.called); assertEquals(ctx, view.asDouble(), visitor.doubleValue, 0.0); break; case STRING: - assertEquals(ctx, MyVisitor.Called.UTF8, visitor.called); + assertEquals(ctx, MockVisitor.Called.UTF8, visitor.called); assertArrayEquals(ctx, view.asUtf8(), visitor.bytes); break; case DATA: - assertEquals(ctx, MyVisitor.Called.DATA, visitor.called); + assertEquals(ctx, MockVisitor.Called.DATA, visitor.called); assertArrayEquals(ctx, view.asData(), visitor.bytes); break; case ARRAY: - assertEquals(ctx, MyVisitor.Called.ARRAY, visitor.called); + assertEquals(ctx, MockVisitor.Called.ARRAY, visitor.called); assertSame(ctx, view, visitor.stuff); break; case OBJECT: - assertEquals(ctx, MyVisitor.Called.OBJECT, visitor.called); + assertEquals(ctx, MockVisitor.Called.OBJECT, visitor.called); assertSame(ctx, view, visitor.stuff); break; default: diff --git a/vespajlib/src/test/java/com/yahoo/slime/MockVisitor.java b/vespajlib/src/test/java/com/yahoo/slime/MockVisitor.java new file mode 100644 index 00000000000..a4354adbcd0 --- /dev/null +++ b/vespajlib/src/test/java/com/yahoo/slime/MockVisitor.java @@ -0,0 +1,69 @@ +// Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. +package com.yahoo.slime; + +import static org.junit.Assert.assertEquals; + +class MockVisitor implements Visitor { + enum Called { NONE, INVALID, NIX, BOOL, LONG, DOUBLE, STRING, UTF8, DATA, ARRAY, OBJECT } + Called called = Called.NONE; + boolean boolValue; + long longValue; + double doubleValue; + String string; + byte[] bytes; + Inspector stuff; + String ctx; + + MockVisitor(String context) { + ctx = context; + } + MockVisitor() { this(""); } + @Override public void visitInvalid() { + assertEquals(ctx, Called.NONE, called); + called = Called.INVALID; + } + @Override public void visitNix() { + assertEquals(ctx, Called.NONE, called); + called = Called.NIX; + } + @Override public void visitBool(boolean bit) { + assertEquals(ctx, Called.NONE, called); + called = Called.BOOL; + boolValue = bit; + } + @Override public void visitLong(long l) { + assertEquals(ctx, Called.NONE, called); + called = Called.LONG; + longValue = l; + } + @Override public void visitDouble(double d) { + assertEquals(ctx, Called.NONE, called); + called = Called.DOUBLE; + doubleValue = d; + } + @Override public void visitString(String str) { + assertEquals(ctx, Called.NONE, called); + called = Called.STRING; + string = str; + } + @Override public void visitString(byte[] utf8) { + assertEquals(ctx, Called.NONE, called); + called = Called.UTF8; + bytes = utf8; + } + @Override public void visitData(byte[] data) { + assertEquals(ctx, Called.NONE, called); + called = Called.DATA; + bytes = data; + } + @Override public void visitArray(Inspector arr) { + assertEquals(ctx, Called.NONE, called); + called = Called.ARRAY; + stuff = arr; + } + @Override public void visitObject(Inspector obj) { + assertEquals(ctx, Called.NONE, called); + called = Called.OBJECT; + stuff = obj; + } +} diff --git a/vespajlib/src/test/java/com/yahoo/slime/SlimeTestCase.java b/vespajlib/src/test/java/com/yahoo/slime/SlimeTestCase.java index 6ee8fb6c7e2..0a5c69b2d73 100644 --- a/vespajlib/src/test/java/com/yahoo/slime/SlimeTestCase.java +++ b/vespajlib/src/test/java/com/yahoo/slime/SlimeTestCase.java @@ -2,10 +2,11 @@ package com.yahoo.slime; import org.junit.Test; - -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.CoreMatchers.sameInstance; +import static org.junit.Assert.assertArrayEquals; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertSame; +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.assertFalse; public class SlimeTestCase { @@ -21,25 +22,25 @@ public class SlimeTestCase { public void testTypeIds() { System.out.println("testing type identifiers..."); - assertThat(Type.NIX.ID, is((byte)0)); - assertThat(Type.BOOL.ID, is((byte)1)); - assertThat(Type.LONG.ID, is((byte)2)); - assertThat(Type.DOUBLE.ID, is((byte)3)); - assertThat(Type.STRING.ID, is((byte)4)); - assertThat(Type.DATA.ID, is((byte)5)); - assertThat(Type.ARRAY.ID, is((byte)6)); - assertThat(Type.OBJECT.ID, is((byte)7)); + assertEquals((byte)0, Type.NIX.ID); + assertEquals((byte)1, Type.BOOL.ID); + assertEquals((byte)2, Type.LONG.ID); + assertEquals((byte)3, Type.DOUBLE.ID); + assertEquals((byte)4, Type.STRING.ID); + assertEquals((byte)5, Type.DATA.ID); + assertEquals((byte)6, Type.ARRAY.ID); + assertEquals((byte)7, Type.OBJECT.ID); - assertThat(Type.values().length, is(8)); + assertEquals(8, Type.values().length); - assertThat(Type.values()[0], sameInstance(Type.NIX)); - assertThat(Type.values()[1], sameInstance(Type.BOOL)); - assertThat(Type.values()[2], sameInstance(Type.LONG)); - assertThat(Type.values()[3], sameInstance(Type.DOUBLE)); - assertThat(Type.values()[4], sameInstance(Type.STRING)); - assertThat(Type.values()[5], sameInstance(Type.DATA)); - assertThat(Type.values()[6], sameInstance(Type.ARRAY)); - assertThat(Type.values()[7], sameInstance(Type.OBJECT)); + assertSame(Type.NIX, Type.values()[0]); + assertSame(Type.BOOL, Type.values()[1]); + assertSame(Type.LONG, Type.values()[2]); + assertSame(Type.DOUBLE, Type.values()[3]); + assertSame(Type.STRING, Type.values()[4]); + assertSame(Type.DATA, Type.values()[5]); + assertSame(Type.ARRAY, Type.values()[6]); + assertSame(Type.OBJECT, Type.values()[7]); } @Test @@ -50,41 +51,41 @@ public class SlimeTestCase { for (int i = 0; i < 2; i++) { if (i == 0) { cur = slime.get(); - assertThat(cur.valid(), is(true)); + assertTrue(cur.valid()); } else { cur = NixValue.invalid(); - assertThat(cur.valid(), is(false)); + assertFalse(cur.valid()); } - assertThat(cur.type(), is(Type.NIX)); - assertThat(cur.children(), is(0)); - assertThat(cur.asBool(), is(false)); - assertThat(cur.asLong(), is((long)0)); - assertThat(cur.asDouble(), is(0.0)); - assertThat(cur.asString(), is("")); - assertThat(cur.asData(), is(new byte[0])); - assertThat(cur.entry(0).valid(), is(false)); - assertThat(cur.field(0).valid(), is(false)); - assertThat(cur.field("foo").valid(), is(false)); + assertEquals(Type.NIX, cur.type()); + assertEquals(0, cur.children()); + assertFalse(cur.asBool()); + assertEquals(0L, cur.asLong()); + assertEquals(0.0, cur.asDouble(), 0.0); + assertEquals("", cur.asString()); + assertArrayEquals(new byte[0], cur.asData()); + assertFalse(cur.entry(0).valid()); + assertFalse(cur.field(0).valid()); + assertFalse(cur.field("foo").valid()); } Inspector insp; for (int i = 0; i < 2; i++) { if (i == 0) { insp = slime.get(); - assertThat(insp.valid(), is(true)); + assertTrue(insp.valid()); } else { insp = NixValue.invalid(); - assertThat(insp.valid(), is(false)); + assertFalse(insp.valid()); } - assertThat(insp.type(), is(Type.NIX)); - assertThat(insp.children(), is(0)); - assertThat(insp.asBool(), is(false)); - assertThat(insp.asLong(), is((long)0)); - assertThat(insp.asDouble(), is(0.0)); - assertThat(insp.asString(), is("")); - assertThat(insp.asData(), is(new byte[0])); - assertThat(insp.entry(0).valid(), is(false)); - assertThat(insp.field(0).valid(), is(false)); - assertThat(insp.field("foo").valid(), is(false)); + assertEquals(Type.NIX, insp.type()); + assertEquals(0, insp.children()); + assertFalse(insp.asBool()); + assertEquals(0L, insp.asLong()); + assertEquals(0.0, insp.asDouble(), 0.0); + assertEquals("", insp.asString()); + assertArrayEquals(new byte[0], insp.asData()); + assertFalse(insp.entry(0).valid()); + assertFalse(insp.field(0).valid()); + assertFalse(insp.field("foo").valid()); } } @@ -96,63 +97,63 @@ public class SlimeTestCase { System.out.println("testing boolean value"); slime.setBool(true); Inspector insp = slime.get(); - assertThat(insp.valid(), is(true)); - assertThat(insp.type(), sameInstance(Type.BOOL)); - assertThat(insp.asBool(), is(true)); + assertTrue(insp.valid()); + assertSame(Type.BOOL, insp.type()); + assertTrue(insp.asBool()); Cursor cur = slime.get(); - assertThat(cur.valid(), is(true)); - assertThat(cur.type(), sameInstance(Type.BOOL)); - assertThat(cur.asBool(), is(true)); + assertTrue(cur.valid()); + assertSame(Type.BOOL, cur.type()); + assertTrue(cur.asBool()); System.out.println("testing long value"); slime.setLong(42); cur = slime.get(); insp = slime.get(); - assertThat(cur.valid(), is(true)); - assertThat(insp.valid(), is(true)); - assertThat(cur.type(), sameInstance(Type.LONG)); - assertThat(insp.type(), sameInstance(Type.LONG)); - assertThat(cur.asLong(), is((long)42)); - assertThat(insp.asLong(), is((long)42)); + assertTrue(cur.valid()); + assertTrue(insp.valid()); + assertSame(Type.LONG, cur.type()); + assertSame(Type.LONG, insp.type()); + assertEquals(42L, cur.asLong()); + assertEquals(42L, insp.asLong()); System.out.println("testing double value"); slime.setDouble(4.2); cur = slime.get(); insp = slime.get(); - assertThat(cur.valid(), is(true)); - assertThat(insp.valid(), is(true)); - assertThat(cur.type(), sameInstance(Type.DOUBLE)); - assertThat(insp.type(), sameInstance(Type.DOUBLE)); - assertThat(cur.asDouble(), is(4.2)); - assertThat(insp.asDouble(), is(4.2)); + assertTrue(cur.valid()); + assertTrue(insp.valid()); + assertSame(Type.DOUBLE, cur.type()); + assertSame(Type.DOUBLE, insp.type()); + assertEquals(4.2, cur.asDouble(), 0.0); + assertEquals(4.2, insp.asDouble(), 0.0); System.out.println("testing string value"); slime.setString("fortytwo"); cur = slime.get(); insp = slime.get(); - assertThat(cur.valid(), is(true)); - assertThat(insp.valid(), is(true)); - assertThat(cur.type(), sameInstance(Type.STRING)); - assertThat(insp.type(), sameInstance(Type.STRING)); - assertThat(cur.asString(), is("fortytwo")); - assertThat(insp.asString(), is("fortytwo")); + assertTrue(cur.valid()); + assertTrue(insp.valid()); + assertSame(Type.STRING, cur.type()); + assertSame(Type.STRING, insp.type()); + assertEquals("fortytwo", cur.asString()); + assertEquals("fortytwo", insp.asString()); System.out.println("testing data value"); byte[] data = { (byte)4, (byte)2 }; slime.setData(data); cur = slime.get(); insp = slime.get(); - assertThat(cur.valid(), is(true)); - assertThat(insp.valid(), is(true)); - assertThat(cur.type(), sameInstance(Type.DATA)); - assertThat(insp.type(), sameInstance(Type.DATA)); - assertThat(cur.asData(), is(data)); - assertThat(insp.asData(), is(data)); + assertTrue(cur.valid()); + assertTrue(insp.valid()); + assertSame(Type.DATA, cur.type()); + assertSame(Type.DATA, insp.type()); + assertArrayEquals(data, cur.asData()); + assertArrayEquals(data, insp.asData()); data[0] = 10; data[1] = 20; byte[] data2 = { 10, 20 }; - assertThat(cur.asData(), is(data2)); - assertThat(insp.asData(), is(data2)); + assertArrayEquals(data2, cur.asData()); + assertArrayEquals(data2, insp.asData()); } @Test @@ -160,13 +161,13 @@ public class SlimeTestCase { System.out.println("testing array values..."); Slime slime = new Slime(); Cursor c = slime.setArray(); - assertThat(c.valid(), is(true)); - assertThat(c.type(), is(Type.ARRAY)); - assertThat(c.children(), is(0)); + assertTrue(c.valid()); + assertEquals(Type.ARRAY, c.type()); + assertEquals(0, c.children()); Inspector i = slime.get(); - assertThat(i.valid(), is(true)); - assertThat(i.type(), is(Type.ARRAY)); - assertThat(i.children(), is(0)); + assertTrue(i.valid()); + assertEquals(Type.ARRAY, i.type()); + assertEquals(0, i.children()); c.addNix(); c.addBool(true); c.addLong(5); @@ -174,23 +175,23 @@ public class SlimeTestCase { c.addString("string"); byte[] data = { (byte)'d', (byte)'a', (byte)'t', (byte)'a' }; c.addData(data); - assertThat(c.children(), is(6)); - assertThat(c.entry(0).valid(), is(true)); - assertThat(c.entry(1).asBool(), is(true)); - assertThat(c.entry(2).asLong(), is((long)5)); - assertThat(c.entry(3).asDouble(), is(3.5)); - assertThat(c.entry(4).asString(), is("string")); - assertThat(c.entry(5).asData(), is(data)); - assertThat(c.field(5).valid(), is(false)); // not OBJECT + assertEquals(6, c.children()); + assertTrue(c.entry(0).valid()); + assertTrue(c.entry(1).asBool()); + assertEquals(5L, c.entry(2).asLong()); + assertEquals(3.5, c.entry(3).asDouble(), 0.0); + assertEquals("string", c.entry(4).asString()); + assertArrayEquals(data, c.entry(5).asData()); + assertFalse(c.field(5).valid()); // not OBJECT - assertThat(i.children(), is(6)); - assertThat(i.entry(0).valid(), is(true)); - assertThat(i.entry(1).asBool(), is(true)); - assertThat(i.entry(2).asLong(), is((long)5)); - assertThat(i.entry(3).asDouble(), is(3.5)); - assertThat(i.entry(4).asString(), is("string")); - assertThat(i.entry(5).asData(), is(data)); - assertThat(i.field(5).valid(), is(false)); // not OBJECT + assertEquals(6, i.children()); + assertTrue(i.entry(0).valid()); + assertTrue(i.entry(1).asBool()); + assertEquals(5L, i.entry(2).asLong()); + assertEquals(3.5, i.entry(3).asDouble(), 0.0); + assertEquals("string", i.entry(4).asString()); + assertArrayEquals(data, i.entry(5).asData()); + assertFalse(i.field(5).valid()); // not OBJECT } @Test @@ -199,13 +200,13 @@ public class SlimeTestCase { Slime slime = new Slime(); Cursor c = slime.setObject(); - assertThat(c.valid(), is(true)); - assertThat(c.type(), is(Type.OBJECT)); - assertThat(c.children(), is(0)); + assertTrue(c.valid()); + assertEquals(Type.OBJECT, c.type()); + assertEquals(0, c.children()); Inspector i = slime.get(); - assertThat(i.valid(), is(true)); - assertThat(i.type(), is(Type.OBJECT)); - assertThat(i.children(), is(0)); + assertTrue(i.valid()); + assertEquals(Type.OBJECT, i.type()); + assertEquals(0, i.children()); c.setNix("a"); c.setBool("b", true); @@ -215,23 +216,23 @@ public class SlimeTestCase { byte[] data = { (byte)'d', (byte)'a', (byte)'t', (byte)'a' }; c.setData("f", data); - assertThat(c.children(), is(6)); - assertThat(c.field("a").valid(), is(true)); - assertThat(c.field("b").asBool(), is(true)); - assertThat(c.field("c").asLong(), is((long)5)); - assertThat(c.field("d").asDouble(), is(3.5)); - assertThat(c.field("e").asString(), is("string")); - assertThat(c.field("f").asData(), is(data)); - assertThat(c.entry(4).valid(), is(false)); // not ARRAY + assertEquals(6, c.children()); + assertTrue(c.field("a").valid()); + assertTrue(c.field("b").asBool()); + assertEquals(5L, c.field("c").asLong()); + assertEquals(3.5, c.field("d").asDouble(), 0.0); + assertEquals("string", c.field("e").asString()); + assertArrayEquals(data, c.field("f").asData()); + assertFalse(c.entry(4).valid()); // not ARRAY - assertThat(i.children(), is(6)); - assertThat(i.field("a").valid(), is(true)); - assertThat(i.field("b").asBool(), is(true)); - assertThat(i.field("c").asLong(), is((long)5)); - assertThat(i.field("d").asDouble(), is(3.5)); - assertThat(i.field("e").asString(), is("string")); - assertThat(i.field("f").asData(), is(data)); - assertThat(i.entry(4).valid(), is(false)); // not ARRAY + assertEquals(6, i.children()); + assertTrue(i.field("a").valid()); + assertTrue(i.field("b").asBool()); + assertEquals(5L, i.field("c").asLong()); + assertEquals(3.5, i.field("d").asDouble(), 0.0); + assertEquals("string", i.field("e").asString()); + assertArrayEquals(data, i.field("f").asData()); + assertFalse(i.entry(4).valid()); // not ARRAY } @Test @@ -240,12 +241,12 @@ public class SlimeTestCase { { Slime slime = new Slime(); Cursor c = slime.setArray(); - assertThat(c.addLong(5).asLong(), is((long)5)); + assertEquals(5L, c.addLong(5).asLong()); } { Slime slime = new Slime(); Cursor c = slime.setObject(); - assertThat(c.setLong("a", 5).asLong(), is((long)5)); + assertEquals(5L, c.setLong("a", 5).asLong()); } } @@ -256,10 +257,10 @@ public class SlimeTestCase { Slime slime = new Slime(); Cursor c = slime.setLong(10); Inspector i1 = c; - assertThat(i1.asLong(), is((long)10)); + assertEquals(10L, i1.asLong()); Inspector i2 = slime.get(); - assertThat(i2.asLong(), is((long)10)); + assertEquals(10L, i2.asLong()); } @Test @@ -275,14 +276,14 @@ public class SlimeTestCase { c3.setLong("answer", 42); } Inspector i = slime.get(); - assertThat(i.field("bar").asLong(), is((long)10)); - assertThat(i.field("foo").entry(0).asLong(), is((long)20)); - assertThat(i.field("foo").entry(1).field("answer").asLong(), is((long)42)); + assertEquals(10L, i.field("bar").asLong()); + assertEquals(20L, i.field("foo").entry(0).asLong()); + assertEquals(42L, i.field("foo").entry(1).field("answer").asLong()); Cursor c = slime.get(); - assertThat(c.field("bar").asLong(), is((long)10)); - assertThat(c.field("foo").entry(0).asLong(), is((long)20)); - assertThat(c.field("foo").entry(1).field("answer").asLong(), is((long)42)); + assertEquals(10L, c.field("bar").asLong()); + assertEquals(20L, c.field("foo").entry(0).asLong()); + assertEquals(42L, c.field("foo").entry(1).field("answer").asLong()); } @Test @@ -293,19 +294,19 @@ public class SlimeTestCase { Cursor c = slime.setObject(); for (int i = 0; i < n; i++) { String str = ("" + i + "_str_" + i); - assertThat(slime.lookup(str), is(SymbolTable.INVALID)); - assertThat(c.field(str).type(), sameInstance(Type.NIX)); + assertEquals(SymbolTable.INVALID, slime.lookup(str)); + assertSame(Type.NIX, c.field(str).type()); switch (i % 2) { - case 0: assertThat((int)c.setLong(str, i).asLong(), is(i)); break; - case 1: assertThat(slime.insert(str), is(i)); break; + case 0: assertEquals(i, (int)c.setLong(str, i).asLong()); break; + case 1: assertEquals(i, slime.insert(str)); break; } } for (int i = 0; i < n; i++) { String str = ("" + i + "_str_" + i); - assertThat(slime.lookup(str), is(i)); + assertEquals(i, slime.lookup(str)); switch (i % 2) { - case 0: assertThat((int)c.field(str).asLong(), is(i)); break; - case 1: assertThat((int)c.field(str).asLong(), is(0)); break; + case 0: assertEquals(i, (int)c.field(str).asLong()); break; + case 1: assertEquals(0, (int)c.field(str).asLong()); break; } } } @@ -317,12 +318,12 @@ public class SlimeTestCase { Slime slime = new Slime(); Cursor c = slime.setArray(); for (int i = 0; i < n; i++) { - assertThat((int)c.addLong(i).asLong(), is(i)); + assertEquals(i, (int)c.addLong(i).asLong()); } for (int i = 0; i < n; i++) { - assertThat((int)c.entry(i).asLong(), is(i)); + assertEquals(i, (int)c.entry(i).asLong()); } - assertThat((int)c.entry(n).asLong(), is(0)); + assertEquals(0, (int)c.entry(n).asLong()); } @Test @@ -332,8 +333,8 @@ public class SlimeTestCase { c1.addLong(20); Cursor c2 = c1.addObject(); c2.setLong("answer", 42); - assertThat(slime.get().toString(), is("[20,{\"answer\":42}]")); + assertEquals("[20,{\"answer\":42}]", slime.get().toString()); c1.addString("\u2008"); - assertThat(slime.get().toString(), is("[20,{\"answer\":42},\"\u2008\"]")); + assertEquals("[20,{\"answer\":42},\"\u2008\"]", slime.get().toString()); } } diff --git a/vespajlib/src/test/java/com/yahoo/slime/VisitorTestCase.java b/vespajlib/src/test/java/com/yahoo/slime/VisitorTestCase.java index 916cddac56b..cc4bf5d16e2 100644 --- a/vespajlib/src/test/java/com/yahoo/slime/VisitorTestCase.java +++ b/vespajlib/src/test/java/com/yahoo/slime/VisitorTestCase.java @@ -2,100 +2,97 @@ package com.yahoo.slime; import org.junit.Test; -import org.mockito.Mockito; - -import static org.hamcrest.CoreMatchers.sameInstance; -import static org.mockito.hamcrest.MockitoHamcrest.argThat; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertArrayEquals; +import static org.junit.Assert.assertSame; public class VisitorTestCase { @Test public void testVisitInvalid() { - Visitor visitor = Mockito.mock(Visitor.class); + var visitor = new MockVisitor(); Inspector inspector = new Slime().get().field("invalid"); inspector.accept(visitor); - Mockito.verify(visitor).visitInvalid(); - Mockito.verifyNoMoreInteractions(visitor); + assertEquals(MockVisitor.Called.INVALID, visitor.called); } @Test public void testVisitNix() { - Visitor visitor = Mockito.mock(Visitor.class); + var visitor = new MockVisitor(); Inspector inspector = new Slime().get(); inspector.accept(visitor); - Mockito.verify(visitor).visitNix(); - Mockito.verifyNoMoreInteractions(visitor); + assertEquals(MockVisitor.Called.NIX, visitor.called); } @Test public void testVisitBool() { - Visitor visitor = Mockito.mock(Visitor.class); + var visitor = new MockVisitor(); Inspector inspector = new Slime().setBool(true); inspector.accept(visitor); - Mockito.verify(visitor).visitBool(true); - Mockito.verifyNoMoreInteractions(visitor); + assertEquals(MockVisitor.Called.BOOL, visitor.called); + assertEquals(true, visitor.boolValue); } @Test public void testVisitLong() { - Visitor visitor = Mockito.mock(Visitor.class); + var visitor = new MockVisitor(); Inspector inspector = new Slime().setLong(123); inspector.accept(visitor); - Mockito.verify(visitor).visitLong(123); - Mockito.verifyNoMoreInteractions(visitor); + assertEquals(MockVisitor.Called.LONG, visitor.called); + assertEquals(123, visitor.longValue); } @Test public void testVisitDouble() { - Visitor visitor = Mockito.mock(Visitor.class); + var visitor = new MockVisitor(); Inspector inspector = new Slime().setDouble(123.0); inspector.accept(visitor); - Mockito.verify(visitor).visitDouble(123.0); - Mockito.verifyNoMoreInteractions(visitor); + assertEquals(MockVisitor.Called.DOUBLE, visitor.called); + assertEquals(123.0, visitor.doubleValue, 0.0); } @Test public void testVisitStringUtf16() { - Visitor visitor = Mockito.mock(Visitor.class); + var visitor = new MockVisitor(); Inspector inspector = new Slime().setString("abc"); inspector.accept(visitor); - Mockito.verify(visitor).visitString("abc"); - Mockito.verifyNoMoreInteractions(visitor); + assertEquals(MockVisitor.Called.STRING, visitor.called); + assertEquals("abc", visitor.string); } @Test public void testVisitStringUtf8() { - Visitor visitor = Mockito.mock(Visitor.class); + var visitor = new MockVisitor(); Inspector inspector = new Slime().setString(new byte[] {65,66,67}); inspector.accept(visitor); - Mockito.verify(visitor).visitString(new byte[] {65,66,67}); - Mockito.verifyNoMoreInteractions(visitor); + assertEquals(MockVisitor.Called.UTF8, visitor.called); + assertArrayEquals(new byte[] {65,66,67}, visitor.bytes); } @Test public void testVisitData() { - Visitor visitor = Mockito.mock(Visitor.class); + var visitor = new MockVisitor(); Inspector inspector = new Slime().setData(new byte[] {1,2,3}); inspector.accept(visitor); - Mockito.verify(visitor).visitData(new byte[] {1,2,3}); - Mockito.verifyNoMoreInteractions(visitor); + assertEquals(MockVisitor.Called.DATA, visitor.called); + assertArrayEquals(new byte[] {1,2,3}, visitor.bytes); } @Test public void testVisitArray() { - Visitor visitor = Mockito.mock(Visitor.class); + var visitor = new MockVisitor(); Inspector inspector = new Slime().setArray(); inspector.accept(visitor); - Mockito.verify(visitor).visitArray(argThat(sameInstance(inspector))); - Mockito.verifyNoMoreInteractions(visitor); + assertEquals(MockVisitor.Called.ARRAY, visitor.called); + assertSame(inspector, visitor.stuff); } @Test public void testVisitObject() { - Visitor visitor = Mockito.mock(Visitor.class); + var visitor = new MockVisitor(); Inspector inspector = new Slime().setObject(); inspector.accept(visitor); - Mockito.verify(visitor).visitObject(argThat(sameInstance(inspector))); - Mockito.verifyNoMoreInteractions(visitor); + assertEquals(MockVisitor.Called.OBJECT, visitor.called); + assertSame(inspector, visitor.stuff); } } |