Fix up imports and some stragglers to use assertThat style.

src/test/java/org/leumasjaffe/json/schema/SchemaTest.java

@@ -1,8 +1,10 @@
 package org.leumasjaffe.json.schema;
 
 import static com.fasterxml.jackson.databind.node.JsonNodeType.*;
-import static org.hamcrest.core.Is.is;
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertThat;
+import static org.leumasjaffe.json.schema.matcher.Accepts.accepts;
+import static org.leumasjaffe.json.schema.matcher.AcceptedTypes.acceptsTypes;
+import static org.leumasjaffe.json.schema.matcher.Not.not;
 
 import java.util.Arrays;
 import java.util.HashMap;
@@ -88,35 +90,36 @@ public class SchemaTest {
 
 	@Test
 	public void testAcceptsAnyIfNoMatchers() {
-		assertThat(new Schema().acceptedTypes().length, is(Tester.ANY.length));
+		assertThat(new Schema(), acceptsTypes(Tester.ANY));
 	}
 
 	@Test
 	public void testRejectsWrongType() {
 		Map<String, Tester> tests = new HashMap<>();
 		tests.put("example", new MockTester(STRING, FixedTester.ACCEPT));
-		assertFalse(new Schema(tests).accepts(NullNode.getInstance()));
+		assertThat(new Schema(tests), not(accepts(NullNode.getInstance())));
 	}
 
 	@Test
 	public void testHandlesUniversalChecksForBoolean() {
-		assertTrue(getConstSchema(BooleanNode.TRUE).accepts(BooleanNode.TRUE));
-		assertFalse(getConstSchema(BooleanNode.TRUE).accepts(NullNode.getInstance()));
-		assertTrue(getEnumSchema(BooleanNode.TRUE, BooleanNode.FALSE)
-				.accepts(BooleanNode.TRUE));
-		assertTrue(getEnumSchema(BooleanNode.TRUE, BooleanNode.FALSE)
-				.accepts(BooleanNode.FALSE));
-		assertFalse(getEnumSchema(BooleanNode.TRUE, BooleanNode.FALSE)
-				.accepts(NullNode.getInstance()));
+		assertThat(getConstSchema(BooleanNode.TRUE), accepts(BooleanNode.TRUE));
+		assertThat(getConstSchema(BooleanNode.TRUE),
+				not(accepts(NullNode.getInstance())));
+		assertThat(getEnumSchema(BooleanNode.TRUE, BooleanNode.FALSE),
+				accepts(BooleanNode.TRUE));
+		assertThat(getEnumSchema(BooleanNode.TRUE, BooleanNode.FALSE),
+				accepts(BooleanNode.FALSE));
+		assertThat(getEnumSchema(BooleanNode.TRUE, BooleanNode.FALSE),
+				not(accepts(NullNode.getInstance())));
 	}
 
 	@Test
 	public void testHandlesMultipleTestsForNumber() {
-		assertFalse(getNumberSchema().accepts(new DoubleNode(-0.25)));
-		assertTrue(getNumberSchema().accepts(new DoubleNode(0.0)));
-		assertTrue(getNumberSchema().accepts(new DoubleNode(0.5)));
-		assertFalse(getNumberSchema().accepts(new DoubleNode(0.6)));
-		assertFalse(getNumberSchema().accepts(new DoubleNode(1.0)));
+		assertThat(getNumberSchema(), not(accepts(new DoubleNode(-0.25))));
+		assertThat(getNumberSchema(), accepts(new DoubleNode(0.0)));
+		assertThat(getNumberSchema(), accepts(new DoubleNode(0.5)));
+		assertThat(getNumberSchema(), not(accepts(new DoubleNode(0.6))));
+		assertThat(getNumberSchema(), not(accepts(new DoubleNode(1.0))));
 	}
 
 	@Test
@@ -135,50 +138,50 @@ public class SchemaTest {
 
 	@Test
 	public void testHandlesUniversalChecksForNumber() {
-		assertTrue(getConstSchema(new DoubleNode(0.0)).accepts(new DoubleNode(0.0)));
-		assertFalse(getConstSchema(new DoubleNode(0.0)).accepts(new DoubleNode(0.5)));
-		assertTrue(getEnumSchema(new DoubleNode(0.0), new DoubleNode(1.0))
-				.accepts(new DoubleNode(0.0)));
-		assertTrue(getEnumSchema(new DoubleNode(0.0), new DoubleNode(1.0))
-				.accepts(new DoubleNode(1.0)));
-		assertFalse(getEnumSchema(new DoubleNode(0.0), new DoubleNode(1.0))
-				.accepts(new DoubleNode(0.5)));
+		assertThat(getConstSchema(new DoubleNode(0.0)), accepts(new DoubleNode(0.0)));
+		assertThat(getConstSchema(new DoubleNode(0.0)), not(accepts(new DoubleNode(0.5))));
+		assertThat(getEnumSchema(new DoubleNode(0.0), new DoubleNode(1.0)),
+				accepts(new DoubleNode(0.0)));
+		assertThat(getEnumSchema(new DoubleNode(0.0), new DoubleNode(1.0)),
+				accepts(new DoubleNode(1.0)));
+		assertThat(getEnumSchema(new DoubleNode(0.0), new DoubleNode(1.0)),
+				not(accepts(new DoubleNode(0.5))));
 	}
 	
 	@Test
 	public void testHandlesMultipleTestsForString() {
-		assertFalse(getStringSchema().accepts(new TextNode("https://a")));
-		assertTrue(getStringSchema().accepts(new TextNode("https://google.com")));
-		assertFalse(getStringSchema().accepts(new TextNode("http://google.com")));
-		assertFalse(getStringSchema().accepts(new TextNode("https://google.com/query?q=Hippopotomonstrosesquippedaliophobia")));
+		assertThat(getStringSchema(), not(accepts(new TextNode("https://a"))));
+		assertThat(getStringSchema(), accepts(new TextNode("https://google.com")));
+		assertThat(getStringSchema(), not(accepts(new TextNode("http://google.com"))));
+		assertThat(getStringSchema(), not(accepts(new TextNode("https://google.com/query?q=Hippopotomonstrosesquippedaliophobia"))));
 	}
 	
 	@Test
 	public void testHandlesUniversalChecksForString() {
-		assertTrue(getConstSchema(new TextNode("A")).accepts(new TextNode("A")));
-		assertFalse(getConstSchema(new TextNode("A")).accepts(new TextNode("C")));
-		assertTrue(getEnumSchema(new TextNode("A"), new TextNode("B"))
-				.accepts(new TextNode("A")));
-		assertTrue(getEnumSchema(new TextNode("A"), new TextNode("B"))
-				.accepts(new TextNode("B")));
-		assertFalse(getEnumSchema(new TextNode("A"), new TextNode("B"))
-				.accepts(new TextNode("C")));
+		assertThat(getConstSchema(new TextNode("A")), accepts(new TextNode("A")));
+		assertThat(getConstSchema(new TextNode("A")), not(accepts(new TextNode("C"))));
+		assertThat(getEnumSchema(new TextNode("A"), new TextNode("B")),
+				accepts(new TextNode("A")));
+		assertThat(getEnumSchema(new TextNode("A"), new TextNode("B")),
+				accepts(new TextNode("B")));
+		assertThat(getEnumSchema(new TextNode("A"), new TextNode("B")),
+				not(accepts(new TextNode("C"))));
 	}
 
 	@Test
 	public void testHandlesMultipleTestsForArray() {
 		final ArrayNode array = new ArrayNode(JsonNodeFactory.instance);
-		assertFalse(getArraySchema().accepts(array));
+		assertThat(getArraySchema(), not(accepts(array)));
 		array.add("Test");
-		assertFalse(getArraySchema().accepts(array));
+		assertThat(getArraySchema(), not(accepts(array)));
 		array.add(0.5);
-		assertTrue(getArraySchema().accepts(array));
+		assertThat(getArraySchema(), accepts(array));
 		array.add(0.5);
-		assertFalse(getArraySchema().accepts(array));
+		assertThat(getArraySchema(), not(accepts(array)));
 		array.remove(2);
 		array.add(true);
 		array.add(false);
-		assertFalse(getArraySchema().accepts(array));
+		assertThat(getArraySchema(), not(accepts(array)));
 	}
 	
 	@Test
@@ -196,10 +199,10 @@ public class SchemaTest {
 		assertThat(schema, not(accepts(node)));
 
 		tests.put("additionalItems", FixedTester.ACCEPT);
-		assertTrue(new Schema(tests).accepts(node));
+		assertThat(new Schema(tests), accepts(node));
 
 		tests.remove("additionalItems");
-		assertTrue(new Schema(tests).accepts(node));
+		assertThat(new Schema(tests), accepts(node));
 	}
 
 	@Test
@@ -235,18 +238,18 @@ public class SchemaTest {
 	@Test
 	public void testHandlesMultipleTestsForObject() {
 		final ObjectNode object = new ObjectNode(JsonNodeFactory.instance);
-		assertFalse(getObjectSchema().accepts(object));
+		assertThat(getObjectSchema(), not(accepts(object)));
 		object.set("string", new TextNode("https://google.com"));
-		assertFalse(getObjectSchema().accepts(object));
+		assertThat(getObjectSchema(), not(accepts(object)));
 		object.set("float", new DoubleNode(0.5));
-		assertTrue(getObjectSchema().accepts(object));
+		assertThat(getObjectSchema(), accepts(object));
 		object.set("Caps", BooleanNode.TRUE);
-		assertFalse(getObjectSchema().accepts(object));
+		assertThat(getObjectSchema(), not(accepts(object)));
 		object.remove("Caps");
 		object.set("bool", BooleanNode.TRUE);
-		assertTrue(getObjectSchema().accepts(object));
+		assertThat(getObjectSchema(), accepts(object));
 		object.set("null", NullNode.getInstance());
-		assertFalse(getObjectSchema().accepts(object));
+		assertThat(getObjectSchema(), not(accepts(object)));
 	}
 	
 	@Test
@@ -266,10 +269,10 @@ public class SchemaTest {
 		assertThat(schema, not(accepts(node)));
 
 		tests.put("additionalProperties", FixedTester.ACCEPT);
-		assertTrue(new Schema(tests).accepts(node));
+		assertThat(new Schema(tests), accepts(node));
 
 		tests.remove("additionalProperties");
-		assertTrue(new Schema(tests).accepts(node));
+		assertThat(new Schema(tests), accepts(node));
 	}
 		
 	@Test

src/test/java/org/leumasjaffe/json/schema/factory/SchemaV6FactoryTest.java

@@ -1,6 +1,9 @@
 package org.leumasjaffe.json.schema.factory;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertThat;
+import static org.junit.Assert.fail;
+import static org.leumasjaffe.json.schema.matcher.Accepts.accepts;
+import static org.leumasjaffe.json.schema.matcher.Not.not;
 
 import java.io.IOException;
 import java.util.Map;

src/test/java/org/leumasjaffe/json/schema/tester/AllOfTesterTest.java

@@ -1,7 +1,9 @@
 package org.leumasjaffe.json.schema.tester;
 
-import static org.junit.Assert.*;
-import static org.hamcrest.core.Is.*;
+import static org.junit.Assert.assertThat;
+import static org.leumasjaffe.json.schema.matcher.Accepts.accepts;
+import static org.leumasjaffe.json.schema.matcher.AcceptedTypes.acceptsTypes;
+import static org.leumasjaffe.json.schema.matcher.Not.not;
 
 import org.junit.Test;
 import org.leumasjaffe.json.schema.Tester;
@@ -21,12 +23,12 @@ public class AllOfTesterTest {
 	public void testAcceptedTypesIsIntersect() {
 		Tester impossible = new AllOfTester(new MockTester(JsonNodeType.OBJECT, null),
 				new MockTester(JsonNodeType.ARRAY, null));
-		assertThat(impossible.acceptedTypes(), is(new JsonNodeType[0]));
+		assertThat(impossible, acceptsTypes());
 		Tester resticted = new AllOfTester(new MockTester(JsonNodeType.OBJECT, null),
 				isArray);
-		assertThat(resticted.acceptedTypes(), is(new JsonNodeType[]{JsonNodeType.OBJECT}));
+		assertThat(resticted, acceptsTypes(JsonNodeType.OBJECT));
 		Tester free = new AllOfTester(isObject,	isArray); // lol
-		assertThat(free.acceptedTypes().length, is(Tester.ANY.length));
+		assertThat(free, acceptsTypes(Tester.ANY));
 	}
 
 	@Test

src/test/java/org/leumasjaffe/json/schema/tester/AnyOfTesterTest.java

@@ -1,7 +1,9 @@
 package org.leumasjaffe.json.schema.tester;
 
-import static org.hamcrest.core.Is.is;
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertThat;
+import static org.leumasjaffe.json.schema.matcher.Accepts.accepts;
+import static org.leumasjaffe.json.schema.matcher.AcceptedTypes.acceptsTypes;
+import static org.leumasjaffe.json.schema.matcher.Not.not;
 
 import org.junit.Test;
 import org.leumasjaffe.json.schema.Tester;
@@ -21,12 +23,12 @@ public class AnyOfTesterTest {
 	public void testAcceptedTypesIsUnion() {
 		Tester impossible = new AnyOfTester(new MockTester(JsonNodeType.OBJECT, null),
 				new MockTester(JsonNodeType.ARRAY, null));
-		assertThat(impossible.acceptedTypes().length, is(2));
+		assertThat(impossible, acceptsTypes(JsonNodeType.ARRAY, JsonNodeType.OBJECT));
 		Tester resticted = new AnyOfTester(new MockTester(JsonNodeType.OBJECT, null),
 				isArray);
-		assertThat(resticted.acceptedTypes().length, is(Tester.ANY.length));
+		assertThat(resticted, acceptsTypes(Tester.ANY));
 		Tester free = new AnyOfTester(isObject,	isArray); // lol
-		assertThat(free.acceptedTypes().length, is(Tester.ANY.length));
+		assertThat(free, acceptsTypes(Tester.ANY));
 	}
 
 	@Test

src/test/java/org/leumasjaffe/json/schema/tester/FormatTesterTest.java

@@ -1,7 +1,6 @@
 package org.leumasjaffe.json.schema.tester;
 
-import static org.hamcrest.core.Is.is;
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertThat;
 import static org.leumasjaffe.json.schema.matcher.Accepts.accepts;
 import static org.leumasjaffe.json.schema.matcher.AcceptedTypes.acceptsTypes;
 import static org.leumasjaffe.json.schema.matcher.Not.not;

src/test/java/org/leumasjaffe/json/schema/tester/NotTesterTest.java

@@ -1,7 +1,9 @@
 package org.leumasjaffe.json.schema.tester;
 
-import static org.hamcrest.core.Is.is;
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertThat;
+import static org.leumasjaffe.json.schema.matcher.Accepts.accepts;
+import static org.leumasjaffe.json.schema.matcher.AcceptedTypes.acceptsTypes;
+import static org.leumasjaffe.json.schema.matcher.Not.not;
 
 import org.junit.Test;
 import org.leumasjaffe.json.schema.Tester;
@@ -16,23 +18,22 @@ public class NotTesterTest {
 	@Test
 	public void testInheritsAcceptedTypes() {
 		StubTester stub = JsonNode::isNull;
-		assertThat(new NotTester(stub).acceptedTypes(), is(Tester.ANY));
+		assertThat(new NotTester(stub), acceptsTypes(Tester.ANY));
 		MockTester mock = new MockTester(JsonNodeType.STRING, stub);
-		assertThat(new NotTester(mock).acceptedTypes(),
-				is(new JsonNodeType[]{JsonNodeType.STRING}));
+		assertThat(new NotTester(mock), acceptsTypes(JsonNodeType.STRING));
 	}
 
 	@Test
 	public void testNotInvertsOutputTrue() {
 		StubTester impl = JsonNode::isNull;
 		assertThat(impl, accepts(NullNode.getInstance()));
-		assertFalse(new NotTester(impl).accepts(NullNode.getInstance()));
+		assertThat(new NotTester(impl), not(accepts(NullNode.getInstance())));
 	}
 
 	@Test
 	public void testNotInvertsOutputFalse() {
 		StubTester impl = JsonNode::isNull;
 		assertThat(impl, not(accepts(BooleanNode.TRUE)));
-		assertTrue(new NotTester(impl).accepts(BooleanNode.TRUE));
+		assertThat(new NotTester(impl), accepts(BooleanNode.TRUE));
 	}
 }

src/test/java/org/leumasjaffe/json/schema/tester/OneOfTesterTest.java

@@ -1,7 +1,9 @@
 package org.leumasjaffe.json.schema.tester;
 
-import static org.hamcrest.core.Is.is;
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertThat;
+import static org.leumasjaffe.json.schema.matcher.Accepts.accepts;
+import static org.leumasjaffe.json.schema.matcher.AcceptedTypes.acceptsTypes;
+import static org.leumasjaffe.json.schema.matcher.Not.not;
 
 import org.junit.Test;
 import org.leumasjaffe.json.schema.Tester;
@@ -21,12 +23,12 @@ public class OneOfTesterTest {
 	public void testAcceptedTypesIsUnion() {
 		Tester impossible = new OneOfTester(new MockTester(JsonNodeType.OBJECT, null),
 				new MockTester(JsonNodeType.ARRAY, null));
-		assertThat(impossible.acceptedTypes().length, is(2));
+		assertThat(impossible, acceptsTypes(JsonNodeType.ARRAY, JsonNodeType.OBJECT));
 		Tester resticted = new OneOfTester(new MockTester(JsonNodeType.OBJECT, null),
 				isArray);
-		assertThat(resticted.acceptedTypes().length, is(Tester.ANY.length));
+		assertThat(resticted, acceptsTypes(Tester.ANY));
 		Tester free = new OneOfTester(isObject,	isArray); // lol
-		assertThat(free.acceptedTypes().length, is(Tester.ANY.length));
+		assertThat(free, acceptsTypes(Tester.ANY));
 	}
 	
 	@Test

src/test/java/org/leumasjaffe/json/schema/tester/PropertyNameTesterTest.java

@@ -1,7 +1,9 @@
 package org.leumasjaffe.json.schema.tester;
 
-import static org.hamcrest.core.Is.is;
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertThat;
+import static org.leumasjaffe.json.schema.matcher.Accepts.accepts;
+import static org.leumasjaffe.json.schema.matcher.AcceptedTypes.acceptsTypes;
+import static org.leumasjaffe.json.schema.matcher.Not.not;
 
 import org.junit.Test;
 
@@ -13,8 +15,8 @@ import com.fasterxml.jackson.databind.node.ObjectNode;
 public class PropertyNameTesterTest {
 	@Test
 	public void testAcceptedTypeIsObject() {
-		assertThat(new PropertyNameTester(FixedTester.REJECT).acceptedTypes(),
-				is(new JsonNodeType[]{JsonNodeType.OBJECT}));
+		assertThat(new PropertyNameTester(FixedTester.REJECT),
+				acceptsTypes(JsonNodeType.OBJECT));
 	}
 	
 	@Test

src/test/java/org/leumasjaffe/json/schema/tester/PropertyTesterTest.java

@@ -1,7 +1,9 @@
 package org.leumasjaffe.json.schema.tester;
 
-import static org.hamcrest.core.Is.is;
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertThat;
+import static org.leumasjaffe.json.schema.matcher.Accepts.accepts;
+import static org.leumasjaffe.json.schema.matcher.AcceptedTypes.acceptsTypes;
+import static org.leumasjaffe.json.schema.matcher.Not.not;
 
 import org.junit.Test;
 import org.leumasjaffe.json.schema.tester.PropertyTester.Pair;
@@ -14,8 +16,8 @@ import com.fasterxml.jackson.databind.node.ObjectNode;
 public class PropertyTesterTest {
 	@Test
 	public void testAcceptedTypeIsObject() {
-		assertThat(new PropertyTester(new Pair[0]).acceptedTypes(),
-				is(new JsonNodeType[]{JsonNodeType.OBJECT}));
+		assertThat(new PropertyTester(new Pair[0]),
+				acceptsTypes(JsonNodeType.OBJECT));
 	}
 
 	@Test

src/test/java/org/leumasjaffe/json/schema/tester/SizeTesterTest.java

@@ -1,7 +1,9 @@
 package org.leumasjaffe.json.schema.tester;
 
-import static org.hamcrest.core.Is.is;
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertThat;
+import static org.leumasjaffe.json.schema.matcher.Accepts.accepts;
+import static org.leumasjaffe.json.schema.matcher.AcceptedTypes.acceptsTypes;
+import static org.leumasjaffe.json.schema.matcher.Not.not;
 
 import java.util.function.IntPredicate;
 
@@ -15,7 +17,6 @@ import org.leumasjaffe.json.schema.tester.SizeTester;
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.node.ArrayNode;
 import com.fasterxml.jackson.databind.node.JsonNodeFactory;
-import com.fasterxml.jackson.databind.node.JsonNodeType;
 import com.fasterxml.jackson.databind.node.NullNode;
 import com.fasterxml.jackson.databind.node.ObjectNode;
 import com.fasterxml.jackson.databind.node.TextNode;
@@ -25,12 +26,12 @@ public class SizeTesterTest {
 
 	@Test
 	public void testAcceptedTypeIsArgument() {
-		assertThat(new SizeTester(ARRAY, NON_ZERO).acceptedTypes(),
-				is(new JsonNodeType[]{ARRAY}));
-		assertThat(new SizeTester(OBJECT, NON_ZERO).acceptedTypes(),
-				is(new JsonNodeType[]{OBJECT}));
-		assertThat(new SizeTester(STRING, NON_ZERO).acceptedTypes(),
-				is(new JsonNodeType[]{STRING}));
+		assertThat(new SizeTester(ARRAY, NON_ZERO),
+				acceptsTypes(ARRAY));
+		assertThat(new SizeTester(OBJECT, NON_ZERO),
+				acceptsTypes(OBJECT));
+		assertThat(new SizeTester(STRING, NON_ZERO),
+				acceptsTypes(STRING));
 	}
 
 	@Test

src/test/java/org/leumasjaffe/json/schema/tester/TypeTesterTest.java

@@ -1,7 +1,9 @@
 package org.leumasjaffe.json.schema.tester;
 
-import static org.hamcrest.core.Is.is;
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertThat;
+import static org.leumasjaffe.json.schema.matcher.Accepts.accepts;
+import static org.leumasjaffe.json.schema.matcher.AcceptedTypes.acceptsTypes;
+import static org.leumasjaffe.json.schema.matcher.Not.not;
 
 import org.junit.Test;
 import org.leumasjaffe.json.schema.Tester;
@@ -34,7 +36,7 @@ public class TypeTesterTest {
 	@Test
 	public void testMatcheNullNode() {
 		final Tester t = TypeTester.fromType("null");
-		assertThat(t.acceptedTypes(), is(Tester.ANY));
+		assertThat(t, acceptsTypes(Tester.ANY));
 		assertThat(t, accepts(jNull));
 		assertThat(t, not(accepts(bool)));
 		assertThat(t, not(accepts(integral)));
@@ -47,7 +49,7 @@ public class TypeTesterTest {
 	@Test
 	public void testMatchesBooleanNode() {
 		final Tester t = TypeTester.fromType("boolean");
-		assertThat(t.acceptedTypes(), is(Tester.ANY));
+		assertThat(t, acceptsTypes(Tester.ANY));
 		assertThat(t, not(accepts(jNull)));
 		assertThat(t, accepts(bool));
 		assertThat(t, not(accepts(integral)));
@@ -60,7 +62,7 @@ public class TypeTesterTest {
 	@Test
 	public void testMatchesIntegerNode() {
 		final Tester t = TypeTester.fromType("integer");
-		assertThat(t.acceptedTypes(), is(Tester.ANY));
+		assertThat(t, acceptsTypes(Tester.ANY));
 		assertThat(t, not(accepts(jNull)));
 		assertThat(t, not(accepts(bool)));
 		assertThat(t, accepts(integral));
@@ -73,7 +75,7 @@ public class TypeTesterTest {
 	@Test
 	public void testMatchesDoubleNode() {
 		final Tester t = TypeTester.fromType("number");
-		assertThat(t.acceptedTypes(), is(Tester.ANY));
+		assertThat(t, acceptsTypes(Tester.ANY));
 		assertThat(t, not(accepts(jNull)));
 		assertThat(t, not(accepts(bool)));
 		assertThat(t, accepts(integral));
@@ -86,7 +88,7 @@ public class TypeTesterTest {
 	@Test
 	public void testMatchesTextNode() {
 		final Tester t = TypeTester.fromType("string");
-		assertThat(t.acceptedTypes(), is(Tester.ANY));
+		assertThat(t, acceptsTypes(Tester.ANY));
 		assertThat(t, not(accepts(jNull)));
 		assertThat(t, not(accepts(bool)));
 		assertThat(t, not(accepts(integral)));
@@ -99,7 +101,7 @@ public class TypeTesterTest {
 	@Test
 	public void testMatchesArrayNode() {
 		final Tester t = TypeTester.fromType("array");
-		assertThat(t.acceptedTypes(), is(Tester.ANY));
+		assertThat(t, acceptsTypes(Tester.ANY));
 		assertThat(t, not(accepts(jNull)));
 		assertThat(t, not(accepts(bool)));
 		assertThat(t, not(accepts(integral)));
@@ -112,7 +114,7 @@ public class TypeTesterTest {
 	@Test
 	public void testMatchesObjectNode() {
 		final Tester t = TypeTester.fromType("object");
-		assertThat(t.acceptedTypes(), is(Tester.ANY));
+		assertThat(t, acceptsTypes(Tester.ANY));
 		assertThat(t, not(accepts(jNull)));
 		assertThat(t, not(accepts(bool)));
 		assertThat(t, not(accepts(integral)));