Merge branch 'matcher'

* matcher:
  Fix up imports and some stragglers to use assertThat style.
  Converting all tests to user accepts() in the assertFalse case
  Convert all other tests to use accepts() in assertTrue clauses.
  Convert all of FormatTester
  Add matchers for Accepts, AcceptedTypes, and an override to Not that propagates describeMismatch()

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
@@ -126,59 +129,59 @@ public class SchemaTest {
 		tests.put("maximum", new NumberTester(d -> d <= 1.0));
 		Schema schema = new Schema(tests);
 		
-		assertFalse(schema.accepts(new DoubleNode(0.0)));
-		assertTrue(schema.accepts(new DoubleNode(0.5)));
-		assertTrue(schema.accepts(new DoubleNode(0.6)));
-		assertTrue(schema.accepts(new DoubleNode(1.0)));
-		assertFalse(schema.accepts(new DoubleNode(1.1)));
+		assertThat(schema, not(accepts(new DoubleNode(0.0))));
+		assertThat(schema, accepts(new DoubleNode(0.5)));
+		assertThat(schema, accepts(new DoubleNode(0.6)));
+		assertThat(schema, accepts(new DoubleNode(1.0)));
+		assertThat(schema, not(accepts(new DoubleNode(1.1))));
 	}
 
 	@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
@@ -191,15 +194,15 @@ public class SchemaTest {
 		final ArrayNode node = new ArrayNode(JsonNodeFactory.instance);
 		node.add(0.5);
 		node.add("https://google.com");
-		assertTrue(schema.accepts(node));
+		assertThat(schema, accepts(node));
 		node.add(true);
-		assertFalse(schema.accepts(node));
+		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
@@ -213,7 +216,7 @@ public class SchemaTest {
 		node.add(0.5);
 		node.add("https://a");
 		node.add(true);
-		assertFalse(schema.accepts(node));
+		assertThat(schema, not(accepts(node)));
 	}
 	
 	@Test
@@ -226,27 +229,27 @@ public class SchemaTest {
 		Schema schema = new Schema(tests);
 
 		final ArrayNode node = new ArrayNode(JsonNodeFactory.instance);
-		assertFalse(schema.accepts(node));
+		assertThat(schema, not(accepts(node)));
 		node.add(true);
-		assertTrue(schema.accepts(node));
+		assertThat(schema, accepts(node));
 	}
 
 
 	@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
@@ -261,15 +264,15 @@ public class SchemaTest {
 		final ObjectNode node = new ObjectNode(JsonNodeFactory.instance);
 		node.set("float", new DoubleNode(0.5));
 		node.set("string", new TextNode("https://google.com"));
-		assertTrue(schema.accepts(node));
+		assertThat(schema, accepts(node));
 		node.set("boolean", BooleanNode.TRUE);
-		assertFalse(schema.accepts(node));
+		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
@@ -281,9 +284,9 @@ public class SchemaTest {
 
 		final ObjectNode node = new ObjectNode(JsonNodeFactory.instance);
 		node.set("string", new TextNode("https://google.com"));
-		assertTrue(schema.accepts(node));
+		assertThat(schema, accepts(node));
 		node.set("float", new DoubleNode(0.5));
-		assertFalse(schema.accepts(node));
+		assertThat(schema, not(accepts(node)));
 	}
 
 	@Test
@@ -299,7 +302,7 @@ public class SchemaTest {
 		node.set("float", new DoubleNode(0.5));
 		node.set("string", new TextNode("https://a"));
 		node.set("boolean", BooleanNode.TRUE);
-		assertFalse(schema.accepts(node));
+		assertThat(schema, not(accepts(node)));
 	}
 	
 	@Test
@@ -312,7 +315,7 @@ public class SchemaTest {
 		Schema schema = new Schema(tests);
 
 		final ObjectNode node = new ObjectNode(JsonNodeFactory.instance);
-		assertFalse(schema.accepts(node));
+		assertThat(schema, not(accepts(node)));
 		node.set("A", BooleanNode.TRUE);
-		assertTrue(schema.accepts(node));
+		assertThat(schema, accepts(node));
 	}}

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;
@@ -52,174 +55,174 @@ public class SchemaV6FactoryTest {
 	@Test
 	public void testIDSchema() {
 		Tester test = fromSingleElement("{ \"$id\": \"test.json\" }");
-		assertTrue(test.accepts(NullNode.getInstance()));
+		assertThat(test, accepts(NullNode.getInstance()));
 	}
 	
 	@Test
 	public void testSchemaSchema() {
 		Tester test = fromSingleElement("{ \"$schema\": \"http://json-schema.org/draft-06/schema#\" }");
-		assertTrue(test.accepts(NullNode.getInstance()));
+		assertThat(test, accepts(NullNode.getInstance()));
 	}
 	
 	@Test
 	public void testTitleSchema() {
 		Tester test = fromSingleElement("{ \"title\": \"This is a schema\" }");
-		assertTrue(test.accepts(NullNode.getInstance()));
+		assertThat(test, accepts(NullNode.getInstance()));
 	}
 	
 	@Test
 	public void testDescriptionSchema() {
 		Tester test = fromSingleElement("{ \"description\": \"This is a schema\" }");
-		assertTrue(test.accepts(NullNode.getInstance()));
+		assertThat(test, accepts(NullNode.getInstance()));
 	}
 	
 	@Test
 	public void testDefaultSchema() {
 		Tester test = fromSingleElement("{ \"default\": {} }");
-		assertTrue(test.accepts(NullNode.getInstance()));
+		assertThat(test, accepts(NullNode.getInstance()));
 	}
 
 	@Test
 	public void testExamplesSchema() {
 		Tester test = fromSingleElement("{ \"examples\": [] }");
-		assertTrue(test.accepts(NullNode.getInstance()));
+		assertThat(test, accepts(NullNode.getInstance()));
 	}
 	
 	@Test
 	public void testMultipleOfSchema() {
 		Tester test = fromSingleElement("{ \"multipleOf\": 1.5 }");
-		assertFalse(test.accepts(NullNode.getInstance()));
-		assertTrue(test.accepts(new DoubleNode(1.5)));
-		assertTrue(test.accepts(new DoubleNode(3.0)));
-		assertTrue(test.accepts(new IntNode(3)));
-		assertFalse(test.accepts(new DoubleNode(2.5)));
+		assertThat(test, not(accepts(NullNode.getInstance())));
+		assertThat(test, accepts(new DoubleNode(1.5)));
+		assertThat(test, accepts(new DoubleNode(3.0)));
+		assertThat(test, accepts(new IntNode(3)));
+		assertThat(test, not(accepts(new DoubleNode(2.5))));
 	}
 	
 	@Test
 	public void testMaximumSchema() {
 		Tester test = fromSingleElement("{ \"maximum\": 2.5 }");
-		assertFalse(test.accepts(NullNode.getInstance()));
-		assertTrue(test.accepts(new DoubleNode(1.5)));
-		assertFalse(test.accepts(new DoubleNode(3.0)));
-		assertTrue(test.accepts(new IntNode(2)));
-		assertFalse(test.accepts(new IntNode(3)));
-		assertTrue(test.accepts(new DoubleNode(2.5)));
+		assertThat(test, not(accepts(NullNode.getInstance())));
+		assertThat(test, accepts(new DoubleNode(1.5)));
+		assertThat(test, not(accepts(new DoubleNode(3.0))));
+		assertThat(test, accepts(new IntNode(2)));
+		assertThat(test, not(accepts(new IntNode(3))));
+		assertThat(test, accepts(new DoubleNode(2.5)));
 	}
 	
 	@Test
 	public void testExclusiveMaximumSchema() {
 		Tester test = fromSingleElement("{ \"exclusiveMaximum\": 2.5 }");
-		assertFalse(test.accepts(NullNode.getInstance()));
-		assertTrue(test.accepts(new DoubleNode(1.5)));
-		assertFalse(test.accepts(new DoubleNode(3.0)));
-		assertTrue(test.accepts(new IntNode(2)));
-		assertFalse(test.accepts(new IntNode(3)));
-		assertFalse(test.accepts(new DoubleNode(2.5)));
+		assertThat(test, not(accepts(NullNode.getInstance())));
+		assertThat(test, accepts(new DoubleNode(1.5)));
+		assertThat(test, not(accepts(new DoubleNode(3.0))));
+		assertThat(test, accepts(new IntNode(2)));
+		assertThat(test, not(accepts(new IntNode(3))));
+		assertThat(test, not(accepts(new DoubleNode(2.5))));
 	}
 	
 	@Test
 	public void testMinimumSchema() {
 		Tester test = fromSingleElement("{ \"minimum\": 2.5 }");
-		assertFalse(test.accepts(NullNode.getInstance()));
-		assertFalse(test.accepts(new DoubleNode(1.5)));
-		assertTrue(test.accepts(new DoubleNode(3.0)));
-		assertFalse(test.accepts(new IntNode(2)));
-		assertTrue(test.accepts(new IntNode(3)));
-		assertTrue(test.accepts(new DoubleNode(2.5)));
+		assertThat(test, not(accepts(NullNode.getInstance())));
+		assertThat(test, not(accepts(new DoubleNode(1.5))));
+		assertThat(test, accepts(new DoubleNode(3.0)));
+		assertThat(test, not(accepts(new IntNode(2))));
+		assertThat(test, accepts(new IntNode(3)));
+		assertThat(test, accepts(new DoubleNode(2.5)));
 	}
 	
 	@Test
 	public void testExclusiveMinimumSchema() {
 		Tester test = fromSingleElement("{ \"exclusiveMinimum\": 2.5 }");
-		assertFalse(test.accepts(NullNode.getInstance()));
-		assertFalse(test.accepts(new DoubleNode(1.5)));
-		assertTrue(test.accepts(new DoubleNode(3.0)));
-		assertFalse(test.accepts(new IntNode(2)));
-		assertTrue(test.accepts(new IntNode(3)));
-		assertFalse(test.accepts(new DoubleNode(2.5)));
+		assertThat(test, not(accepts(NullNode.getInstance())));
+		assertThat(test, not(accepts(new DoubleNode(1.5))));
+		assertThat(test, accepts(new DoubleNode(3.0)));
+		assertThat(test, not(accepts(new IntNode(2))));
+		assertThat(test, accepts(new IntNode(3)));
+		assertThat(test, not(accepts(new DoubleNode(2.5))));
 	}
 	
 	@Test
 	public void testMaxLengthSchema() {
 		Tester test = fromSingleElement("{ \"maxLength\": 1 }");
-		assertFalse(test.accepts(NullNode.getInstance()));
-		assertFalse(test.accepts(new DoubleNode(1.5)));
-		assertTrue(test.accepts(new TextNode("")));
-		assertFalse(test.accepts(new TextNode("  ")));
+		assertThat(test, not(accepts(NullNode.getInstance())));
+		assertThat(test, not(accepts(new DoubleNode(1.5))));
+		assertThat(test, accepts(new TextNode("")));
+		assertThat(test, not(accepts(new TextNode("  "))));
 	}
 	
 	@Test
 	public void testMinLengthSchema() {
 		Tester test = fromSingleElement("{ \"minLength\": 2 }");
-		assertFalse(test.accepts(NullNode.getInstance()));
-		assertFalse(test.accepts(new DoubleNode(1.5)));
-		assertFalse(test.accepts(new TextNode("")));
-		assertTrue(test.accepts(new TextNode("  ")));
+		assertThat(test, not(accepts(NullNode.getInstance())));
+		assertThat(test, not(accepts(new DoubleNode(1.5))));
+		assertThat(test, not(accepts(new TextNode(""))));
+		assertThat(test, accepts(new TextNode("  ")));
 	}
 	
 	@Test
 	public void testPatternSchema() {
 		Tester test = fromSingleElement("{ \"pattern\": \"^\\\\s.*\" }");
-		assertFalse(test.accepts(NullNode.getInstance()));
-		assertFalse(test.accepts(new TextNode("S ")));
-		assertTrue(test.accepts(new TextNode(" S")));
+		assertThat(test, not(accepts(NullNode.getInstance())));
+		assertThat(test, not(accepts(new TextNode("S "))));
+		assertThat(test, accepts(new TextNode(" S")));
 	}
 	
 	@Test
 	public void testAdditionalItemsSchema() {
 		Tester test = fromSingleElement("{ \"additionalItems\": false }");
 		final ArrayNode node = new ArrayNode(JsonNodeFactory.instance);
-		assertTrue(test.accepts(node));
+		assertThat(test, accepts(node));
 		node.add(false);
-		assertFalse(test.accepts(node));
+		assertThat(test, not(accepts(node)));
 		node.add(false);
-		assertFalse(test.accepts(node));
+		assertThat(test, not(accepts(node)));
 	}
 	
 	@Test
 	public void testItemsSchema() {
 		Tester test = fromSingleElement("{ \"items\": [ true, false ] }");
 		final ArrayNode node = new ArrayNode(JsonNodeFactory.instance);
-		assertTrue(test.accepts(node));
+		assertThat(test, accepts(node));
 		node.add(false);
-		assertTrue(test.accepts(node));
+		assertThat(test, accepts(node));
 		node.add(false);
-		assertFalse(test.accepts(node));
+		assertThat(test, not(accepts(node)));
 	}
 
 	@Test
 	public void testItemsSchemaSingle() {
 		Tester test = fromSingleElement("{ \"items\": true }");
 		final ArrayNode node = new ArrayNode(JsonNodeFactory.instance);
-		assertTrue(test.accepts(node));
+		assertThat(test, accepts(node));
 		node.add(false);
-		assertTrue(test.accepts(node));
+		assertThat(test, accepts(node));
 		node.add(false);
-		assertTrue(test.accepts(node));
+		assertThat(test, accepts(node));
 	}
 	
 	@Test
 	public void testMaxItemsSchema() {
 		Tester test = fromSingleElement("{ \"maxItems\": 1 }");
-		assertFalse(test.accepts(NullNode.getInstance()));
-		assertFalse(test.accepts(new DoubleNode(1.5)));
+		assertThat(test, not(accepts(NullNode.getInstance())));
+		assertThat(test, not(accepts(new DoubleNode(1.5))));
 		final ArrayNode node = new ArrayNode(JsonNodeFactory.instance);
-		assertTrue(test.accepts(node));
+		assertThat(test, accepts(node));
 		node.add(false);
 		node.add(false);
-		assertFalse(test.accepts(node));
+		assertThat(test, not(accepts(node)));
 	}
 	
 	@Test
 	public void testMinItemsSchema() {
 		Tester test = fromSingleElement("{ \"minItems\": 2 }");
-		assertFalse(test.accepts(NullNode.getInstance()));
-		assertFalse(test.accepts(new DoubleNode(1.5)));
+		assertThat(test, not(accepts(NullNode.getInstance())));
+		assertThat(test, not(accepts(new DoubleNode(1.5))));
 		final ArrayNode node = new ArrayNode(JsonNodeFactory.instance);
-		assertFalse(test.accepts(node));
+		assertThat(test, not(accepts(node)));
 		node.add(false);
 		node.add(false);
-		assertTrue(test.accepts(node));
+		assertThat(test, accepts(node));
 	}
 	
 	@Test
@@ -228,11 +231,11 @@ public class SchemaV6FactoryTest {
 		Tester any = fromSingleElement("{ \"uniqueItems\": false }");
 		final ArrayNode node = new ArrayNode(JsonNodeFactory.instance);
 		node.add(false);
-		assertTrue(uniq.accepts(node));
-		assertTrue(any.accepts(node));
+		assertThat(uniq, accepts(node));
+		assertThat(any, accepts(node));
 		node.add(false);
-		assertFalse(uniq.accepts(node));
-		assertTrue(any.accepts(node));
+		assertThat(uniq, not(accepts(node)));
+		assertThat(any, accepts(node));
 	}
 	
 	@Test
@@ -240,34 +243,34 @@ public class SchemaV6FactoryTest {
 		Tester test = fromSingleElement("{ \"contains\": { } }");
 		final ArrayNode node = new ArrayNode(JsonNodeFactory.instance);
 		
-		assertFalse(test.accepts(node));
+		assertThat(test, not(accepts(node)));
 		
 		node.add(new ObjectNode(JsonNodeFactory.instance));
-		assertTrue(test.accepts(node));
+		assertThat(test, accepts(node));
 	}
 	
 	@Test
 	public void testMaxPropertiesSchema() {
 		Tester test = fromSingleElement("{ \"maxProperties\": 1 }");
-		assertFalse(test.accepts(NullNode.getInstance()));
-		assertFalse(test.accepts(new DoubleNode(1.5)));
+		assertThat(test, not(accepts(NullNode.getInstance())));
+		assertThat(test, not(accepts(new DoubleNode(1.5))));
 		final ObjectNode node = new ObjectNode(JsonNodeFactory.instance);
-		assertTrue(test.accepts(node));
+		assertThat(test, accepts(node));
 		node.set("A", BooleanNode.FALSE);
 		node.set("B", BooleanNode.FALSE);
-		assertFalse(test.accepts(node));
+		assertThat(test, not(accepts(node)));
 	}
 	
 	@Test
 	public void testMinPropertiesSchema() {
 		Tester test = fromSingleElement("{ \"minProperties\": 2 }");
-		assertFalse(test.accepts(NullNode.getInstance()));
-		assertFalse(test.accepts(new DoubleNode(1.5)));
+		assertThat(test, not(accepts(NullNode.getInstance())));
+		assertThat(test, not(accepts(new DoubleNode(1.5))));
 		final ObjectNode node = new ObjectNode(JsonNodeFactory.instance);
-		assertFalse(test.accepts(node));
+		assertThat(test, not(accepts(node)));
 		node.set("A", BooleanNode.FALSE);
 		node.set("B", BooleanNode.FALSE);
-		assertTrue(test.accepts(node));
+		assertThat(test, accepts(node));
 	}
 	
 	@Test
@@ -276,17 +279,17 @@ public class SchemaV6FactoryTest {
 		final ObjectNode node = new ObjectNode(JsonNodeFactory.instance);
 		node.set("A", BooleanNode.FALSE);
 		node.set("C", BooleanNode.FALSE);
-		assertFalse(test.accepts(node));
+		assertThat(test, not(accepts(node)));
 		node.set("B", BooleanNode.FALSE);
-		assertTrue(test.accepts(node));
+		assertThat(test, accepts(node));
 	}
 
 	@Test
 	public void testAdditionalPropertiesSchema() {
 		Tester test = fromSingleElement("{ \"additionalProperties\": false }");
-		assertTrue(test.accepts(readTree("{ }")));
-		assertFalse(test.accepts(readTree("{ \"A\": {} }")));
-		assertFalse(test.accepts(readTree("{ \"B\": {} }")));
+		assertThat(test, accepts(readTree("{ }")));
+		assertThat(test, not(accepts(readTree("{ \"A\": {} }"))));
+		assertThat(test, not(accepts(readTree("{ \"B\": {} }"))));
 	}
 	
 	@Test
@@ -297,27 +300,27 @@ public class SchemaV6FactoryTest {
 				"{ \"type\": \"boolean\" }" +
 			"]" +
 		"}"));
-		assertFalse(defArray.accepts(NullNode.instance));
-		assertFalse(defArray.accepts(new ObjectNode(JsonNodeFactory.instance)));
-		assertTrue(defArray.accepts(BooleanNode.TRUE));
+		assertThat(defArray, not(accepts(NullNode.instance)));
+		assertThat(defArray, not(accepts(new ObjectNode(JsonNodeFactory.instance))));
+		assertThat(defArray, accepts(BooleanNode.TRUE));
 	}
 	
 	@Test
 	public void testPropertiesSchema() {
 		Tester test = fromSingleElement("{ \"properties\": { \"A\": true, \"B\": false } }");
-		assertTrue(test.accepts(readTree("{ }")));
-		assertTrue(test.accepts(readTree("{ \"A\": {} }")));
-		assertFalse(test.accepts(readTree("{ \"B\": {} }")));
-		assertFalse(test.accepts(readTree("{ \"A\": {}, \"B\": {} }")));
+		assertThat(test, accepts(readTree("{ }")));
+		assertThat(test, accepts(readTree("{ \"A\": {} }")));
+		assertThat(test, not(accepts(readTree("{ \"B\": {} }"))));
+		assertThat(test, not(accepts(readTree("{ \"A\": {}, \"B\": {} }"))));
 	}
 	
 	@Test
 	public void testPatternPropertiesSchema() {
 		Tester test = fromSingleElement("{ \"patternProperties\": { \"A\": true, \"A.\": false } }");
-		assertTrue(test.accepts(readTree("{ }")));
-		assertTrue(test.accepts(readTree("{ \"A\": {} }")));
-		assertFalse(test.accepts(readTree("{ \"A.\": {} }")));
-		assertFalse(test.accepts(readTree("{ \"A_\": {} }")));
+		assertThat(test, accepts(readTree("{ }")));
+		assertThat(test, accepts(readTree("{ \"A\": {} }")));
+		assertThat(test, not(accepts(readTree("{ \"A.\": {} }"))));
+		assertThat(test, not(accepts(readTree("{ \"A_\": {} }"))));
 	}
 	
 	@Test
@@ -327,18 +330,18 @@ public class SchemaV6FactoryTest {
 				"\"A\": [ \"B\", \"C\" ]" +
 			"}" +
 		"}");
-		assertTrue(arrayDep.accepts(readTree("{ \"B\": true }")));
-		assertFalse(arrayDep.accepts(readTree("{ \"A\": true, \"B\": true }")));
-		assertTrue(arrayDep.accepts(readTree("{ \"A\": true, \"B\": true, \"C\": true }")));
+		assertThat(arrayDep, accepts(readTree("{ \"B\": true }")));
+		assertThat(arrayDep, not(accepts(readTree("{ \"A\": true, \"B\": true }"))));
+		assertThat(arrayDep, accepts(readTree("{ \"A\": true, \"B\": true, \"C\": true }")));
 		
 		Tester schemaDep = fromSingleElement("{" +
 			"\"dependencies\": {" +
 				"\"D\": { \"properties\": { \"B\": { \"type\": \"integer\" } } }" +
 			"}" +
 		"}");
-		assertTrue(schemaDep.accepts(readTree("{ \"B\": true }")));
-		assertFalse(schemaDep.accepts(readTree("{ \"D\": true, \"B\": true }")));
-		assertTrue(schemaDep.accepts(readTree("{ \"D\": true, \"B\": 5 }")));
+		assertThat(schemaDep, accepts(readTree("{ \"B\": true }")));
+		assertThat(schemaDep, not(accepts(readTree("{ \"D\": true, \"B\": true }"))));
+		assertThat(schemaDep, accepts(readTree("{ \"D\": true, \"B\": 5 }")));
 		
 		Tester bothDep = fromSingleElement("{" +
 			"\"dependencies\": {" +
@@ -346,46 +349,46 @@ public class SchemaV6FactoryTest {
 				"\"D\": { \"properties\": { \"B\": { \"type\": \"integer\" } } }" +
 			"}" +
 		"}");
-		assertTrue(bothDep.accepts(readTree("{ \"A\": true, \"B\": true, \"C\": true }")));
-		assertTrue(bothDep.accepts(readTree("{ \"D\": true, \"B\": 5 }")));
-		assertFalse(bothDep.accepts(readTree("{ \"A\": true, \"D\": true, \"B\": true, \"C\": true }")));
-		assertTrue(bothDep.accepts(readTree("{ \"A\": true, \"D\": true, \"B\": 5, \"C\": true }")));
+		assertThat(bothDep, accepts(readTree("{ \"A\": true, \"B\": true, \"C\": true }")));
+		assertThat(bothDep, accepts(readTree("{ \"D\": true, \"B\": 5 }")));
+		assertThat(bothDep, not(accepts(readTree("{ \"A\": true, \"D\": true, \"B\": true, \"C\": true }"))));
+		assertThat(bothDep, accepts(readTree("{ \"A\": true, \"D\": true, \"B\": 5, \"C\": true }")));
 	}
 	
 	@Test
 	public void testPropertyNamesSchema() {
 		Tester test = fromSingleElement("{ \"propertyNames\": false }");
-		assertTrue(test.accepts(readTree("{ }")));
-		assertFalse(test.accepts(readTree("{ \"A\": {} }")));
+		assertThat(test, accepts(readTree("{ }")));
+		assertThat(test, not(accepts(readTree("{ \"A\": {} }"))));
 	}
 	
 	@Test
 	public void testConstSchema() {
 		Tester test = fromSingleElement("{ \"const\": { \"nice\": \"meme\" } }");
 		JsonNode matching = readTree("{ \"nice\": \"meme\" }");
-		assertTrue(test.accepts(matching));
+		assertThat(test, accepts(matching));
 	}
 	
 	@Test
 	public void testEnumSchema() {
 		Tester test = fromSingleElement("{ \"enum\": [ \"A\", \"B\", \"D\" ] }");
-		assertTrue(test.accepts(new TextNode("A")));
-		assertFalse(test.accepts(new TextNode("a")));
-		assertTrue(test.accepts(new TextNode("B")));
-		assertFalse(test.accepts(new TextNode("AB")));
-		assertFalse(test.accepts(new TextNode("C")));
-		assertTrue(test.accepts(new TextNode("D")));
+		assertThat(test, accepts(new TextNode("A")));
+		assertThat(test, not(accepts(new TextNode("a"))));
+		assertThat(test, accepts(new TextNode("B")));
+		assertThat(test, not(accepts(new TextNode("AB"))));
+		assertThat(test, not(accepts(new TextNode("C"))));
+		assertThat(test, accepts(new TextNode("D")));
 	}
 	
 	@Test
 	public void testTypeSchema() {
 		Tester multi = fromSingleElement("{ \"type\": [ \"boolean\", \"number\" ] }");
-		assertTrue(multi.accepts(BooleanNode.TRUE));
-		assertTrue(multi.accepts(new DoubleNode(1.5)));
-		assertFalse(multi.accepts(new TextNode("hi")));
+		assertThat(multi, accepts(BooleanNode.TRUE));
+		assertThat(multi, accepts(new DoubleNode(1.5)));
+		assertThat(multi, not(accepts(new TextNode("hi"))));
 		Tester sing = fromSingleElement("{ \"type\": \"boolean\" }");
-		assertTrue(sing.accepts(BooleanNode.TRUE));
-		assertFalse(sing.accepts(new DoubleNode(1.5)));
+		assertThat(sing, accepts(BooleanNode.TRUE));
+		assertThat(sing, not(accepts(new DoubleNode(1.5))));
 	}
 	
 	@Test(expected=IllegalArgumentException.class)

src/test/java/org/leumasjaffe/json/schema/matcher/AcceptedTypes.java

@@ -0,0 +1,47 @@
+package org.leumasjaffe.json.schema.matcher;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+
+import org.hamcrest.BaseMatcher;
+import org.hamcrest.Description;
+import org.hamcrest.Matcher;
+import org.leumasjaffe.json.schema.Tester;
+
+import com.fasterxml.jackson.databind.node.JsonNodeType;
+
+public class AcceptedTypes extends BaseMatcher<Tester> {
+	public static Matcher<Tester> acceptsTypes(JsonNodeType...types) {
+		return new AcceptedTypes(types);
+	}
+	
+	Set<JsonNodeType> typesAccepted;
+
+	private AcceptedTypes(JsonNodeType...types) {
+		typesAccepted = new HashSet<>(Arrays.asList(types));
+	}
+
+	@Override
+	public boolean matches(Object arg0) {
+		if (!(arg0 instanceof Tester)) {
+			return false;
+		}
+		return actualTypes((Tester) arg0).equals(typesAccepted);
+	}
+
+	private Set<JsonNodeType> actualTypes(Tester arg0) {
+		return new HashSet<>(Arrays.asList(arg0.acceptedTypes()));
+	}
+
+	@Override
+	public void describeTo(Description arg0) {
+		arg0.appendText("accepts types ").appendValue(typesAccepted);
+	}
+
+	@Override
+	public void describeMismatch(Object arg0, Description arg1) {
+		arg1.appendText("instead accepts ").appendValue(actualTypes((Tester) arg0));
+	}
+
+}

src/test/java/org/leumasjaffe/json/schema/matcher/Accepts.java

@@ -0,0 +1,35 @@
+package org.leumasjaffe.json.schema.matcher;
+
+import org.hamcrest.BaseMatcher;
+import org.hamcrest.Description;
+import org.hamcrest.Matcher;
+import org.leumasjaffe.json.schema.Tester;
+
+import com.fasterxml.jackson.databind.JsonNode;
+
+public class Accepts extends BaseMatcher<Tester> {
+	public static Matcher<Tester> accepts(JsonNode json) {
+		return new Accepts(json);
+	}
+	
+	JsonNode jsonToMatch;
+
+	private Accepts(JsonNode json) {
+		jsonToMatch = json;
+	}
+
+	@Override
+	public boolean matches(Object arg0) {
+		if (!(arg0 instanceof Tester)) {
+			return false;
+		}
+		return ((Tester) arg0).accepts(jsonToMatch);
+	}
+
+	@Override
+	public void describeTo(Description arg0) {
+		arg0.appendText("the schema accepts JSON ");
+		arg0.appendValue(jsonToMatch);
+	}
+	
+}

src/test/java/org/leumasjaffe/json/schema/matcher/Not.java

@@ -0,0 +1,33 @@
+package org.leumasjaffe.json.schema.matcher;
+
+import org.hamcrest.BaseMatcher;
+import org.hamcrest.Description;
+import org.hamcrest.Matcher;
+
+public class Not<T> extends BaseMatcher<T> {
+	public static <T> BaseMatcher<T> not(Matcher<T> matcher) {
+		return new Not<>(matcher);
+	}
+	
+	private final Matcher<T> matcher;
+
+	public Not(Matcher<T> matcher) {
+		this.matcher = matcher;
+	}
+
+	@Override
+	public boolean matches(Object item) {
+		return !matcher.matches(item);
+	}
+
+	@Override
+	public void describeTo(Description description) {
+		description.appendText("not ");
+		matcher.describeTo(description);
+	}
+
+	@Override
+	public void describeMismatch(Object arg0, Description arg1) {
+		matcher.describeMismatch(arg0, arg1);
+	}
+}

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,18 +23,18 @@ 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
 	public void testFailsIfAllFail() {
 		Tester fails = new AllOfTester(isArray, isObject);
-		assertFalse(fails.accepts(NullNode.getInstance()));
+		assertThat(fails, not(accepts(NullNode.getInstance())));
 	}
 
 	@Test
@@ -40,7 +42,7 @@ public class AllOfTesterTest {
 		Tester fails = new AllOfTester(isArray, notEmpty);
 		final ArrayNode node = new ArrayNode(JsonNodeFactory.instance);
 		node.add(true);
-		assertTrue(fails.accepts(node));
+		assertThat(fails, accepts(node));
 	}
 	
 	@Test
@@ -48,13 +50,13 @@ public class AllOfTesterTest {
 		Tester fails = new AllOfTester(isArray, isObject, notEmpty);
 		final ArrayNode node = new ArrayNode(JsonNodeFactory.instance);
 		node.add(true);
-		assertFalse(fails.accepts(node));
+		assertThat(fails, not(accepts(node)));
 	}
 	
 	@Test
 	public void testFailsIfPreciselyOnePasses() {
 		Tester fails = new AllOfTester(isArray, notEmpty);
 		final ArrayNode node = new ArrayNode(JsonNodeFactory.instance);
-		assertFalse(fails.accepts(node));
+		assertThat(fails, not(accepts(node)));
 	}
 }

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,18 +23,18 @@ 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
 	public void testFailsIfAllFail() {
 		Tester fails = new AnyOfTester(isArray, isObject);
-		assertFalse(fails.accepts(NullNode.getInstance()));
+		assertThat(fails, not(accepts(NullNode.getInstance())));
 	}
 
 	@Test
@@ -40,7 +42,7 @@ public class AnyOfTesterTest {
 		Tester fails = new AnyOfTester(isArray, notEmpty);
 		final ArrayNode node = new ArrayNode(JsonNodeFactory.instance);
 		node.add(true);
-		assertTrue(fails.accepts(node));
+		assertThat(fails, accepts(node));
 	}
 	
 	@Test
@@ -48,13 +50,13 @@ public class AnyOfTesterTest {
 		Tester fails = new AnyOfTester(isArray, isObject, notEmpty);
 		final ArrayNode node = new ArrayNode(JsonNodeFactory.instance);
 		node.add(true);
-		assertTrue(fails.accepts(node));
+		assertThat(fails, accepts(node));
 	}
 	
 	@Test
 	public void testPassesIfPreciselyOnePasses() {
 		Tester fails = new AnyOfTester(isArray, notEmpty);
 		final ArrayNode node = new ArrayNode(JsonNodeFactory.instance);
-		assertTrue(fails.accepts(node));
+		assertThat(fails, accepts(node));
 	}
 }

src/test/java/org/leumasjaffe/json/schema/tester/FormatTesterTest.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;
@@ -20,111 +22,111 @@ public class FormatTesterTest {
 	@Test
 	public void testUUIDMatcher() {
 		Tester test = FormatTester.forCode("uuid");
-		assertThat(test.acceptedTypes(), is(new JsonNodeType[]{JsonNodeType.STRING}));
-		assertFalse(test.accepts(NullNode.getInstance()));
-		assertTrue(test.accepts(new TextNode("00000000-0000-0000-0000-000000000000")));
-		assertFalse(test.accepts(new TextNode("0000000-0000-0000-0000-000000000000")));
-		assertFalse(test.accepts(new TextNode("X0000000-0000-0000-0000-000000000000")));
+		assertThat(test, acceptsTypes(JsonNodeType.STRING));
+		assertThat(test, not(accepts(NullNode.getInstance())));
+		assertThat(test, accepts(new TextNode("00000000-0000-0000-0000-000000000000")));
+		assertThat(test, not(accepts(new TextNode("0000000-0000-0000-0000-000000000000"))));
+		assertThat(test, not(accepts(new TextNode("X0000000-0000-0000-0000-000000000000"))));
 	}
 	
 	@Test
 	public void testDateTimeMatcher() {
 		Tester test = FormatTester.forCode("date-time");
-		assertThat(test.acceptedTypes(), is(new JsonNodeType[]{JsonNodeType.STRING}));
-		assertFalse(test.accepts(NullNode.getInstance()));
-		assertTrue(test.accepts(new TextNode("2000-01-01T21:10:10Z")));
-		assertTrue(test.accepts(new TextNode("2000-01-01T21:10:10+01:00")));
-		assertTrue(test.accepts(new TextNode("2000-01-01T21:10:10-01:00")));
-		assertFalse(test.accepts(new TextNode("2000-01-01")));
-		assertFalse(test.accepts(new TextNode("21:10:10Z")));
-		assertFalse(test.accepts(new TextNode("21:10:10+01:00")));
-		assertFalse(test.accepts(new TextNode("21:10:10001:00")));
+		assertThat(test, acceptsTypes(JsonNodeType.STRING));
+		assertThat(test, not(accepts(NullNode.getInstance())));
+		assertThat(test, accepts(new TextNode("2000-01-01T21:10:10Z")));
+		assertThat(test, accepts(new TextNode("2000-01-01T21:10:10+01:00")));
+		assertThat(test, accepts(new TextNode("2000-01-01T21:10:10-01:00")));
+		assertThat(test, not(accepts(new TextNode("2000-01-01"))));
+		assertThat(test, not(accepts(new TextNode("21:10:10Z"))));
+		assertThat(test, not(accepts(new TextNode("21:10:10+01:00"))));
+		assertThat(test, not(accepts(new TextNode("21:10:10001:00"))));
 	}
 	
 	@Test
 	public void testEmailMatcher() {
 		Tester test = FormatTester.forCode("email");
-		assertThat(test.acceptedTypes(), is(new JsonNodeType[]{JsonNodeType.STRING}));
-		assertFalse(test.accepts(NullNode.getInstance()));
-		assertTrue(test.accepts(new TextNode("user@mail.com")));
-		assertFalse(test.accepts(new TextNode("user@mail")));
-		assertFalse(test.accepts(new TextNode("@mail.com")));
+		assertThat(test, acceptsTypes(JsonNodeType.STRING));
+		assertThat(test, not(accepts(NullNode.getInstance())));
+		assertThat(test, accepts(new TextNode("user@mail.com")));
+		assertThat(test, not(accepts(new TextNode("user@mail"))));
+		assertThat(test, not(accepts(new TextNode("@mail.com"))));
 	}
 
 	@Test
 	public void testHostnameMatcher() {
 		Tester test = FormatTester.forCode("hostname");
-		assertThat(test.acceptedTypes(), is(new JsonNodeType[]{JsonNodeType.STRING}));
-		assertFalse(test.accepts(NullNode.getInstance()));
-		assertTrue(test.accepts(new TextNode("google.com")));
-		assertFalse(test.accepts(new TextNode("192.168.0.1")));
-		assertFalse(test.accepts(new TextNode("user@google.com")));
-		assertFalse(test.accepts(new TextNode("http://google.com")));
+		assertThat(test, acceptsTypes(JsonNodeType.STRING));
+		assertThat(test, not(accepts(NullNode.getInstance())));
+		assertThat(test, accepts(new TextNode("google.com")));
+		assertThat(test, not(accepts(new TextNode("192.168.0.1"))));
+		assertThat(test, not(accepts(new TextNode("user@google.com"))));
+		assertThat(test, not(accepts(new TextNode("http://google.com"))));
 	}
 
 	@Test
 	public void testipv4Matcher() {
 		Tester test = FormatTester.forCode("ipv4");
-		assertThat(test.acceptedTypes(), is(new JsonNodeType[]{JsonNodeType.STRING}));
-		assertFalse(test.accepts(NullNode.getInstance()));
-		assertTrue(test.accepts(new TextNode("192.168.0.1")));
-		assertFalse(test.accepts(new TextNode("192.168.0.1/24")));
-		assertFalse(test.accepts(new TextNode("192.168.0.1:80")));
+		assertThat(test, acceptsTypes(JsonNodeType.STRING));
+		assertThat(test, not(accepts(NullNode.getInstance())));
+		assertThat(test, accepts(new TextNode("192.168.0.1")));
+		assertThat(test, not(accepts(new TextNode("192.168.0.1/24"))));
+		assertThat(test, not(accepts(new TextNode("192.168.0.1:80"))));
 	}
 	
 	@Test
 	public void testipv6Matcher() {
 		Tester test = FormatTester.forCode("ipv6");
-		assertThat(test.acceptedTypes(), is(new JsonNodeType[]{JsonNodeType.STRING}));
-		assertFalse(test.accepts(NullNode.getInstance()));
-		assertTrue(test.accepts(new TextNode("::1")));
-		assertFalse(test.accepts(new TextNode("[::1]:80")));
+		assertThat(test, acceptsTypes(JsonNodeType.STRING));
+		assertThat(test, not(accepts(NullNode.getInstance())));
+		assertThat(test, accepts(new TextNode("::1")));
+		assertThat(test, not(accepts(new TextNode("[::1]:80"))));
 	}
 	
 
 	@Test
 	public void testURIMatcher() {
 		Tester test = FormatTester.forCode("uri");
-		assertThat(test.acceptedTypes(), is(new JsonNodeType[]{JsonNodeType.STRING}));
-		assertFalse(test.accepts(NullNode.getInstance()));
-		assertTrue(test.accepts(new TextNode("file:///var/log/syslog")));
-		assertFalse(test.accepts(new TextNode("#/definitions/schemaArray")));
-		assertTrue(test.accepts(new TextNode("http://google.com")));
-		assertFalse(test.accepts(new TextNode("100:file")));
-		assertFalse(test.accepts(new TextNode("http://google.com/{domain}")));
+		assertThat(test, acceptsTypes(JsonNodeType.STRING));
+		assertThat(test, not(accepts(NullNode.getInstance())));
+		assertThat(test, accepts(new TextNode("file:///var/log/syslog")));
+		assertThat(test, not(accepts(new TextNode("#/definitions/schemaArray"))));
+		assertThat(test, accepts(new TextNode("http://google.com")));
+		assertThat(test, not(accepts(new TextNode("100:file"))));
+		assertThat(test, not(accepts(new TextNode("http://google.com/{domain}"))));
 	}
 	
 	@Test
 	public void testURIReferenceMatcher() {
 		Tester test = FormatTester.forCode("uri-reference");
-		assertThat(test.acceptedTypes(), is(new JsonNodeType[]{JsonNodeType.STRING}));
-		assertFalse(test.accepts(NullNode.getInstance()));
-		assertTrue(test.accepts(new TextNode("file:///var/log/syslog")));
-		assertTrue(test.accepts(new TextNode("#/definitions/schemaArray")));
-		assertTrue(test.accepts(new TextNode("http://google.com")));
-		assertFalse(test.accepts(new TextNode("100:file")));
-		assertFalse(test.accepts(new TextNode("http://google.com/{domain}")));
+		assertThat(test, acceptsTypes(JsonNodeType.STRING));
+		assertThat(test, not(accepts(NullNode.getInstance())));
+		assertThat(test, accepts(new TextNode("file:///var/log/syslog")));
+		assertThat(test, accepts(new TextNode("#/definitions/schemaArray")));
+		assertThat(test, accepts(new TextNode("http://google.com")));
+		assertThat(test, not(accepts(new TextNode("100:file"))));
+		assertThat(test, not(accepts(new TextNode("http://google.com/{domain}"))));
 	}
 
 	@Test
 	public void testURITemplateeMatcher() {
 		Tester test = FormatTester.forCode("uri-template");
-		assertThat(test.acceptedTypes(), is(new JsonNodeType[]{JsonNodeType.STRING}));
-		assertFalse(test.accepts(NullNode.getInstance()));
-		assertTrue(test.accepts(new TextNode("file:///var/log/syslog")));
-		assertTrue(test.accepts(new TextNode("#/definitions/schemaArray")));
-		assertTrue(test.accepts(new TextNode("http://google.com")));
-		assertFalse(test.accepts(new TextNode("100:file")));
-		assertTrue(test.accepts(new TextNode("http://google.com/{domain}")));
+		assertThat(test, acceptsTypes(JsonNodeType.STRING));
+		assertThat(test, not(accepts(NullNode.getInstance())));
+		assertThat(test, accepts(new TextNode("file:///var/log/syslog")));
+		assertThat(test, accepts(new TextNode("#/definitions/schemaArray")));
+		assertThat(test, accepts(new TextNode("http://google.com")));
+		assertThat(test, not(accepts(new TextNode("100:file"))));
+		assertThat(test, accepts(new TextNode("http://google.com/{domain}")));
 	}
 	
 	@Test
 	public void testJsonPointerMatcher() {
 		Tester test = FormatTester.forCode("json-pointer");
-		assertThat(test.acceptedTypes(), is(new JsonNodeType[]{JsonNodeType.STRING}));
-		assertFalse(test.accepts(NullNode.getInstance()));
-		assertTrue(test.accepts(new TextNode("/definitions/schemaArray")));
-		assertFalse(test.accepts(new TextNode("#/definitions/schemaArray")));
-		assertTrue(test.accepts(new TextNode("/definitions/schemas/5/")));
+		assertThat(test, acceptsTypes(JsonNodeType.STRING));
+		assertThat(test, not(accepts(NullNode.getInstance())));
+		assertThat(test, accepts(new TextNode("/definitions/schemaArray")));
+		assertThat(test, not(accepts(new TextNode("#/definitions/schemaArray"))));
+		assertThat(test, accepts(new TextNode("/definitions/schemas/5/")));
 	}
 }

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;
-		assertTrue(impl.accepts(NullNode.getInstance()));
-		assertFalse(new NotTester(impl).accepts(NullNode.getInstance()));
+		assertThat(impl, accepts(NullNode.getInstance()));
+		assertThat(new NotTester(impl), not(accepts(NullNode.getInstance())));
 	}
 
 	@Test
 	public void testNotInvertsOutputFalse() {
 		StubTester impl = JsonNode::isNull;
-		assertFalse(impl.accepts(BooleanNode.TRUE));
-		assertTrue(new NotTester(impl).accepts(BooleanNode.TRUE));
+		assertThat(impl, not(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,18 +23,18 @@ 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
 	public void testFailsIfAllFail() {
 		Tester fails = new OneOfTester(isArray, isObject);
-		assertFalse(fails.accepts(NullNode.getInstance()));
+		assertThat(fails, not(accepts(NullNode.getInstance())));
 	}
 
 	@Test
@@ -40,7 +42,7 @@ public class OneOfTesterTest {
 		Tester fails = new OneOfTester(isArray, notEmpty);
 		final ArrayNode node = new ArrayNode(JsonNodeFactory.instance);
 		node.add(true);
-		assertFalse(fails.accepts(node));
+		assertThat(fails, not(accepts(node)));
 	}
 	
 	@Test
@@ -48,13 +50,13 @@ public class OneOfTesterTest {
 		Tester fails = new OneOfTester(isArray, isObject, notEmpty);
 		final ArrayNode node = new ArrayNode(JsonNodeFactory.instance);
 		node.add(true);
-		assertFalse(fails.accepts(node));
+		assertThat(fails, not(accepts(node)));
 	}
 	
 	@Test
 	public void testPassesIfPreciselyOnePasses() {
 		Tester fails = new OneOfTester(isArray, notEmpty);
 		final ArrayNode node = new ArrayNode(JsonNodeFactory.instance);
-		assertTrue(fails.accepts(node));
+		assertThat(fails, accepts(node));
 	}
 }

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,15 +15,15 @@ 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
 	public void testPassesEmptyObject() {
 		PropertyNameTester test = new PropertyNameTester(FixedTester.REJECT);
 		final ObjectNode node = new ObjectNode(JsonNodeFactory.instance);
-		assertTrue(test.accepts(node));
+		assertThat(test, accepts(node));
 	}
 	
 	@Test
@@ -29,6 +31,6 @@ public class PropertyNameTesterTest {
 		PropertyNameTester test = new PropertyNameTester(FixedTester.REJECT);
 		final ObjectNode node = new ObjectNode(JsonNodeFactory.instance);
 		node.set("A", NullNode.getInstance());
-		assertFalse(test.accepts(node));
+		assertThat(test, not(accepts(node)));
 	}
 }

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
@@ -23,7 +25,7 @@ public class PropertyTesterTest {
 		PropertyTester test = new PropertyTester(new Pair[0]);
 		final ObjectNode node = new ObjectNode(JsonNodeFactory.instance);
 		node.set("A", NullNode.getInstance());
-		assertTrue(test.accepts(node));
+		assertThat(test, accepts(node));
 	}
 
 	@Test
@@ -32,7 +34,7 @@ public class PropertyTesterTest {
 				FixedTester.REJECT));
 		final ObjectNode node = new ObjectNode(JsonNodeFactory.instance);
 		node.set("A", NullNode.getInstance());
-		assertFalse(test.accepts(node));
+		assertThat(test, not(accepts(node)));
 	}
 	
 	@Test
@@ -44,7 +46,7 @@ public class PropertyTesterTest {
 		final ObjectNode node = new ObjectNode(JsonNodeFactory.instance);
 		node.set("A", NullNode.getInstance());
 		node.set("B", NullNode.getInstance());
-		assertFalse(test.accepts(node));
+		assertThat(test, not(accepts(node)));
 	}
 
 	@Test
@@ -56,7 +58,7 @@ public class PropertyTesterTest {
 		final ObjectNode node = new ObjectNode(JsonNodeFactory.instance);
 		node.set("A", NullNode.getInstance());
 		node.set("B", NullNode.getInstance());
-		assertFalse(test.accepts(node));
+		assertThat(test, not(accepts(node)));
 	}
 	
 	@Test
@@ -68,7 +70,7 @@ public class PropertyTesterTest {
 		final ObjectNode node = new ObjectNode(JsonNodeFactory.instance);
 		node.set("A", NullNode.getInstance());
 		node.set("B", NullNode.getInstance());
-		assertTrue(test.accepts(node));
+		assertThat(test, accepts(node));
 	}
 	
 	@Test
@@ -80,6 +82,6 @@ public class PropertyTesterTest {
 		final ObjectNode node = new ObjectNode(JsonNodeFactory.instance);
 		node.set("A", NullNode.getInstance());
 		node.set("B", NullNode.getInstance());
-		assertFalse(test.accepts(node));
+		assertThat(test, not(accepts(node)));
 	}
 }

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,53 +26,53 @@ 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
 	public void arrayMatcherRejectsObject() {
 		final SizeTester notEmptyArray = new SizeTester(ARRAY, NON_ZERO);
 		final JsonNode node = new ObjectNode(JsonNodeFactory.instance);
-		assertFalse(notEmptyArray.accepts(node));
+		assertThat(notEmptyArray, not(accepts(node)));
 	}
 
 	@Test
 	public void objectMatcherRejectsArray() {
 		final SizeTester notEmptyArray = new SizeTester(OBJECT, NON_ZERO);
 		final JsonNode node = new ArrayNode(JsonNodeFactory.instance);
-		assertFalse(notEmptyArray.accepts(node));
+		assertThat(notEmptyArray, not(accepts(node)));
 	}
 	
 	@Test
 	public void textMatcherRejectsArray() {
 		final SizeTester notEmptyArray = new SizeTester(STRING, NON_ZERO);
 		final JsonNode node = new ArrayNode(JsonNodeFactory.instance);
-		assertFalse(notEmptyArray.accepts(node));
+		assertThat(notEmptyArray, not(accepts(node)));
 	}
 
 	@Test
 	public void arrayMatcherRejectsTooSmall() {
 		final SizeTester notEmptyArray = new SizeTester(ARRAY, NON_ZERO);
 		final JsonNode node = new ArrayNode(JsonNodeFactory.instance);
-		assertFalse(notEmptyArray.accepts(node));
+		assertThat(notEmptyArray, not(accepts(node)));
 	}
 
 	@Test
 	public void objectMatcherRejectsTooSmall() {
 		final SizeTester notEmptyArray = new SizeTester(OBJECT, NON_ZERO);
 		final JsonNode node = new ObjectNode(JsonNodeFactory.instance);
-		assertFalse(notEmptyArray.accepts(node));
+		assertThat(notEmptyArray, not(accepts(node)));
 	}
 
 	@Test
 	public void testMatcherRejectsTooSmall() {
 		final SizeTester notEmptyArray = new SizeTester(STRING, NON_ZERO);
-		assertFalse(notEmptyArray.accepts(new TextNode("")));
+		assertThat(notEmptyArray, not(accepts(new TextNode(""))));
 	}
 
 	@Test
@@ -79,7 +80,7 @@ public class SizeTesterTest {
 		final SizeTester notEmptyArray = new SizeTester(ARRAY, NON_ZERO);
 		final ArrayNode node = new ArrayNode(JsonNodeFactory.instance);
 		node.add(NullNode.getInstance());
-		assertTrue(notEmptyArray.accepts(node));
+		assertThat(notEmptyArray, accepts(node));
 	}
 
 	@Test
@@ -87,13 +88,13 @@ public class SizeTesterTest {
 		final SizeTester notEmptyArray = new SizeTester(OBJECT, NON_ZERO);
 		final ObjectNode node = new ObjectNode(JsonNodeFactory.instance);
 		node.set("_", NullNode.getInstance());
-		assertTrue(notEmptyArray.accepts(node));
+		assertThat(notEmptyArray, accepts(node));
 	}
 
 	@Test
 	public void testMatcherAcceptsGoodSize() {
 		final SizeTester notEmptyArray = new SizeTester(STRING, NON_ZERO);
-		assertTrue(notEmptyArray.accepts(new TextNode("_")));
+		assertThat(notEmptyArray, accepts(new TextNode("_")));
 	}
 	
 }

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,91 +36,91 @@ public class TypeTesterTest {
 	@Test
 	public void testMatcheNullNode() {
 		final Tester t = TypeTester.fromType("null");
-		assertThat(t.acceptedTypes(), is(Tester.ANY));
-		assertTrue(t.accepts(jNull));
-		assertFalse(t.accepts(bool));
-		assertFalse(t.accepts(integral));
-		assertFalse(t.accepts(floating));
-		assertFalse(t.accepts(text));
-		assertFalse(t.accepts(array));
-		assertFalse(t.accepts(object));
+		assertThat(t, acceptsTypes(Tester.ANY));
+		assertThat(t, accepts(jNull));
+		assertThat(t, not(accepts(bool)));
+		assertThat(t, not(accepts(integral)));
+		assertThat(t, not(accepts(floating)));
+		assertThat(t, not(accepts(text)));
+		assertThat(t, not(accepts(array)));
+		assertThat(t, not(accepts(object)));
 	}
 
 	@Test
 	public void testMatchesBooleanNode() {
 		final Tester t = TypeTester.fromType("boolean");
-		assertThat(t.acceptedTypes(), is(Tester.ANY));
-		assertFalse(t.accepts(jNull));
-		assertTrue(t.accepts(bool));
-		assertFalse(t.accepts(integral));
-		assertFalse(t.accepts(floating));
-		assertFalse(t.accepts(text));
-		assertFalse(t.accepts(array));
-		assertFalse(t.accepts(object));
+		assertThat(t, acceptsTypes(Tester.ANY));
+		assertThat(t, not(accepts(jNull)));
+		assertThat(t, accepts(bool));
+		assertThat(t, not(accepts(integral)));
+		assertThat(t, not(accepts(floating)));
+		assertThat(t, not(accepts(text)));
+		assertThat(t, not(accepts(array)));
+		assertThat(t, not(accepts(object)));
 	}
 	
 	@Test
 	public void testMatchesIntegerNode() {
 		final Tester t = TypeTester.fromType("integer");
-		assertThat(t.acceptedTypes(), is(Tester.ANY));
-		assertFalse(t.accepts(jNull));
-		assertFalse(t.accepts(bool));
-		assertTrue(t.accepts(integral));
-		assertFalse(t.accepts(floating));
-		assertFalse(t.accepts(text));
-		assertFalse(t.accepts(array));
-		assertFalse(t.accepts(object));
+		assertThat(t, acceptsTypes(Tester.ANY));
+		assertThat(t, not(accepts(jNull)));
+		assertThat(t, not(accepts(bool)));
+		assertThat(t, accepts(integral));
+		assertThat(t, not(accepts(floating)));
+		assertThat(t, not(accepts(text)));
+		assertThat(t, not(accepts(array)));
+		assertThat(t, not(accepts(object)));
 	}
 	
 	@Test
 	public void testMatchesDoubleNode() {
 		final Tester t = TypeTester.fromType("number");
-		assertThat(t.acceptedTypes(), is(Tester.ANY));
-		assertFalse(t.accepts(jNull));
-		assertFalse(t.accepts(bool));
-		assertTrue(t.accepts(integral));
-		assertTrue(t.accepts(floating));
-		assertFalse(t.accepts(text));
-		assertFalse(t.accepts(array));
-		assertFalse(t.accepts(object));
+		assertThat(t, acceptsTypes(Tester.ANY));
+		assertThat(t, not(accepts(jNull)));
+		assertThat(t, not(accepts(bool)));
+		assertThat(t, accepts(integral));
+		assertThat(t, accepts(floating));
+		assertThat(t, not(accepts(text)));
+		assertThat(t, not(accepts(array)));
+		assertThat(t, not(accepts(object)));
 	}
 	
 	@Test
 	public void testMatchesTextNode() {
 		final Tester t = TypeTester.fromType("string");
-		assertThat(t.acceptedTypes(), is(Tester.ANY));
-		assertFalse(t.accepts(jNull));
-		assertFalse(t.accepts(bool));
-		assertFalse(t.accepts(integral));
-		assertFalse(t.accepts(floating));
-		assertTrue(t.accepts(text));
-		assertFalse(t.accepts(array));
-		assertFalse(t.accepts(object));
+		assertThat(t, acceptsTypes(Tester.ANY));
+		assertThat(t, not(accepts(jNull)));
+		assertThat(t, not(accepts(bool)));
+		assertThat(t, not(accepts(integral)));
+		assertThat(t, not(accepts(floating)));
+		assertThat(t, accepts(text));
+		assertThat(t, not(accepts(array)));
+		assertThat(t, not(accepts(object)));
 	}
 	
 	@Test
 	public void testMatchesArrayNode() {
 		final Tester t = TypeTester.fromType("array");
-		assertThat(t.acceptedTypes(), is(Tester.ANY));
-		assertFalse(t.accepts(jNull));
-		assertFalse(t.accepts(bool));
-		assertFalse(t.accepts(integral));
-		assertFalse(t.accepts(floating));
-		assertFalse(t.accepts(text));
-		assertTrue(t.accepts(array));
-		assertFalse(t.accepts(object));
+		assertThat(t, acceptsTypes(Tester.ANY));
+		assertThat(t, not(accepts(jNull)));
+		assertThat(t, not(accepts(bool)));
+		assertThat(t, not(accepts(integral)));
+		assertThat(t, not(accepts(floating)));
+		assertThat(t, not(accepts(text)));
+		assertThat(t, accepts(array));
+		assertThat(t, not(accepts(object)));
 	}
 	
 	@Test
 	public void testMatchesObjectNode() {
 		final Tester t = TypeTester.fromType("object");
-		assertThat(t.acceptedTypes(), is(Tester.ANY));
-		assertFalse(t.accepts(jNull));
-		assertFalse(t.accepts(bool));
-		assertFalse(t.accepts(integral));
-		assertFalse(t.accepts(floating));
-		assertFalse(t.accepts(text));
-		assertFalse(t.accepts(array));
-		assertTrue(t.accepts(object));
+		assertThat(t, acceptsTypes(Tester.ANY));
+		assertThat(t, not(accepts(jNull)));
+		assertThat(t, not(accepts(bool)));
+		assertThat(t, not(accepts(integral)));
+		assertThat(t, not(accepts(floating)));
+		assertThat(t, not(accepts(text)));
+		assertThat(t, not(accepts(array)));
+		assertThat(t, accepts(object));
 	}
 }