Merge pull request #26647 from vespa-engine/havardpe/stop-using-hamcrest-and-mockito

avoid hamcrest and mockito

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