Converting all tests to user accepts() in the assertFalse case

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

@@ -126,11 +126,11 @@ public class SchemaTest {
 		tests.put("maximum", new NumberTester(d -> d <= 1.0));
 		Schema schema = new Schema(tests);
 		
-		assertFalse(schema.accepts(new DoubleNode(0.0)));
+		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)));
-		assertFalse(schema.accepts(new DoubleNode(1.1)));
+		assertThat(schema, not(accepts(new DoubleNode(1.1))));
 	}
 
 	@Test
@@ -193,7 +193,7 @@ public class SchemaTest {
 		node.add("https://google.com");
 		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));
@@ -213,7 +213,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,7 +226,7 @@ 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);
 		assertThat(schema, accepts(node));
 	}
@@ -263,7 +263,7 @@ public class SchemaTest {
 		node.set("string", new TextNode("https://google.com"));
 		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));
@@ -283,7 +283,7 @@ public class SchemaTest {
 		node.set("string", new TextNode("https://google.com"));
 		assertThat(schema, accepts(node));
 		node.set("float", new DoubleNode(0.5));
-		assertFalse(schema.accepts(node));
+		assertThat(schema, not(accepts(node)));
 	}
 
 	@Test
@@ -299,7 +299,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 +312,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);
 		assertThat(schema, accepts(node));
 	}}

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

@@ -88,42 +88,42 @@ public class SchemaV6FactoryTest {
 	@Test
 	public void testMultipleOfSchema() {
 		Tester test = fromSingleElement("{ \"multipleOf\": 1.5 }");
-		assertFalse(test.accepts(NullNode.getInstance()));
+		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)));
-		assertFalse(test.accepts(new DoubleNode(2.5)));
+		assertThat(test, not(accepts(new DoubleNode(2.5))));
 	}
 	
 	@Test
 	public void testMaximumSchema() {
 		Tester test = fromSingleElement("{ \"maximum\": 2.5 }");
-		assertFalse(test.accepts(NullNode.getInstance()));
+		assertThat(test, not(accepts(NullNode.getInstance())));
 		assertThat(test, accepts(new DoubleNode(1.5)));
-		assertFalse(test.accepts(new DoubleNode(3.0)));
+		assertThat(test, not(accepts(new DoubleNode(3.0))));
 		assertThat(test, accepts(new IntNode(2)));
-		assertFalse(test.accepts(new IntNode(3)));
+		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()));
+		assertThat(test, not(accepts(NullNode.getInstance())));
 		assertThat(test, accepts(new DoubleNode(1.5)));
-		assertFalse(test.accepts(new DoubleNode(3.0)));
+		assertThat(test, not(accepts(new DoubleNode(3.0))));
 		assertThat(test, accepts(new IntNode(2)));
-		assertFalse(test.accepts(new IntNode(3)));
-		assertFalse(test.accepts(new DoubleNode(2.5)));
+		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)));
+		assertThat(test, not(accepts(NullNode.getInstance())));
+		assertThat(test, not(accepts(new DoubleNode(1.5))));
 		assertThat(test, accepts(new DoubleNode(3.0)));
-		assertFalse(test.accepts(new IntNode(2)));
+		assertThat(test, not(accepts(new IntNode(2))));
 		assertThat(test, accepts(new IntNode(3)));
 		assertThat(test, accepts(new DoubleNode(2.5)));
 	}
@@ -131,37 +131,37 @@ public class SchemaV6FactoryTest {
 	@Test
 	public void testExclusiveMinimumSchema() {
 		Tester test = fromSingleElement("{ \"exclusiveMinimum\": 2.5 }");
-		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))));
 		assertThat(test, accepts(new DoubleNode(3.0)));
-		assertFalse(test.accepts(new IntNode(2)));
+		assertThat(test, not(accepts(new IntNode(2))));
 		assertThat(test, accepts(new IntNode(3)));
-		assertFalse(test.accepts(new DoubleNode(2.5)));
+		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)));
+		assertThat(test, not(accepts(NullNode.getInstance())));
+		assertThat(test, not(accepts(new DoubleNode(1.5))));
 		assertThat(test, accepts(new TextNode("")));
-		assertFalse(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("")));
+		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 ")));
+		assertThat(test, not(accepts(NullNode.getInstance())));
+		assertThat(test, not(accepts(new TextNode("S "))));
 		assertThat(test, accepts(new TextNode(" S")));
 	}
 	
@@ -171,9 +171,9 @@ public class SchemaV6FactoryTest {
 		final ArrayNode node = new ArrayNode(JsonNodeFactory.instance);
 		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
@@ -184,7 +184,7 @@ public class SchemaV6FactoryTest {
 		node.add(false);
 		assertThat(test, accepts(node));
 		node.add(false);
-		assertFalse(test.accepts(node));
+		assertThat(test, not(accepts(node)));
 	}
 
 	@Test
@@ -201,22 +201,22 @@ public class SchemaV6FactoryTest {
 	@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);
 		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);
 		assertThat(test, accepts(node));
@@ -231,7 +231,7 @@ public class SchemaV6FactoryTest {
 		assertThat(uniq, accepts(node));
 		assertThat(any, accepts(node));
 		node.add(false);
-		assertFalse(uniq.accepts(node));
+		assertThat(uniq, not(accepts(node)));
 		assertThat(any, accepts(node));
 	}
 	
@@ -240,7 +240,7 @@ 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));
 		assertThat(test, accepts(node));
@@ -249,22 +249,22 @@ public class SchemaV6FactoryTest {
 	@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);
 		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);
 		assertThat(test, accepts(node));
@@ -276,7 +276,7 @@ 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);
 		assertThat(test, accepts(node));
 	}
@@ -285,8 +285,8 @@ public class SchemaV6FactoryTest {
 	public void testAdditionalPropertiesSchema() {
 		Tester test = fromSingleElement("{ \"additionalProperties\": false }");
 		assertThat(test, accepts(readTree("{ }")));
-		assertFalse(test.accepts(readTree("{ \"A\": {} }")));
-		assertFalse(test.accepts(readTree("{ \"B\": {} }")));
+		assertThat(test, not(accepts(readTree("{ \"A\": {} }"))));
+		assertThat(test, not(accepts(readTree("{ \"B\": {} }"))));
 	}
 	
 	@Test
@@ -297,8 +297,8 @@ public class SchemaV6FactoryTest {
 				"{ \"type\": \"boolean\" }" +
 			"]" +
 		"}"));
-		assertFalse(defArray.accepts(NullNode.instance));
-		assertFalse(defArray.accepts(new ObjectNode(JsonNodeFactory.instance)));
+		assertThat(defArray, not(accepts(NullNode.instance)));
+		assertThat(defArray, not(accepts(new ObjectNode(JsonNodeFactory.instance))));
 		assertThat(defArray, accepts(BooleanNode.TRUE));
 	}
 	
@@ -307,8 +307,8 @@ public class SchemaV6FactoryTest {
 		Tester test = fromSingleElement("{ \"properties\": { \"A\": true, \"B\": false } }");
 		assertThat(test, accepts(readTree("{ }")));
 		assertThat(test, accepts(readTree("{ \"A\": {} }")));
-		assertFalse(test.accepts(readTree("{ \"B\": {} }")));
-		assertFalse(test.accepts(readTree("{ \"A\": {}, \"B\": {} }")));
+		assertThat(test, not(accepts(readTree("{ \"B\": {} }"))));
+		assertThat(test, not(accepts(readTree("{ \"A\": {}, \"B\": {} }"))));
 	}
 	
 	@Test
@@ -316,8 +316,8 @@ public class SchemaV6FactoryTest {
 		Tester test = fromSingleElement("{ \"patternProperties\": { \"A\": true, \"A.\": false } }");
 		assertThat(test, accepts(readTree("{ }")));
 		assertThat(test, accepts(readTree("{ \"A\": {} }")));
-		assertFalse(test.accepts(readTree("{ \"A.\": {} }")));
-		assertFalse(test.accepts(readTree("{ \"A_\": {} }")));
+		assertThat(test, not(accepts(readTree("{ \"A.\": {} }"))));
+		assertThat(test, not(accepts(readTree("{ \"A_\": {} }"))));
 	}
 	
 	@Test
@@ -328,7 +328,7 @@ public class SchemaV6FactoryTest {
 			"}" +
 		"}");
 		assertThat(arrayDep, accepts(readTree("{ \"B\": true }")));
-		assertFalse(arrayDep.accepts(readTree("{ \"A\": true, \"B\": true }")));
+		assertThat(arrayDep, not(accepts(readTree("{ \"A\": true, \"B\": true }"))));
 		assertThat(arrayDep, accepts(readTree("{ \"A\": true, \"B\": true, \"C\": true }")));
 		
 		Tester schemaDep = fromSingleElement("{" +
@@ -337,7 +337,7 @@ public class SchemaV6FactoryTest {
 			"}" +
 		"}");
 		assertThat(schemaDep, accepts(readTree("{ \"B\": true }")));
-		assertFalse(schemaDep.accepts(readTree("{ \"D\": true, \"B\": true }")));
+		assertThat(schemaDep, not(accepts(readTree("{ \"D\": true, \"B\": true }"))));
 		assertThat(schemaDep, accepts(readTree("{ \"D\": true, \"B\": 5 }")));
 		
 		Tester bothDep = fromSingleElement("{" +
@@ -348,7 +348,7 @@ public class SchemaV6FactoryTest {
 		"}");
 		assertThat(bothDep, accepts(readTree("{ \"A\": true, \"B\": true, \"C\": true }")));
 		assertThat(bothDep, accepts(readTree("{ \"D\": true, \"B\": 5 }")));
-		assertFalse(bothDep.accepts(readTree("{ \"A\": true, \"D\": true, \"B\": true, \"C\": true }")));
+		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 }")));
 	}
 	
@@ -356,7 +356,7 @@ public class SchemaV6FactoryTest {
 	public void testPropertyNamesSchema() {
 		Tester test = fromSingleElement("{ \"propertyNames\": false }");
 		assertThat(test, accepts(readTree("{ }")));
-		assertFalse(test.accepts(readTree("{ \"A\": {} }")));
+		assertThat(test, not(accepts(readTree("{ \"A\": {} }"))));
 	}
 	
 	@Test
@@ -370,10 +370,10 @@ public class SchemaV6FactoryTest {
 	public void testEnumSchema() {
 		Tester test = fromSingleElement("{ \"enum\": [ \"A\", \"B\", \"D\" ] }");
 		assertThat(test, accepts(new TextNode("A")));
-		assertFalse(test.accepts(new TextNode("a")));
+		assertThat(test, not(accepts(new TextNode("a"))));
 		assertThat(test, accepts(new TextNode("B")));
-		assertFalse(test.accepts(new TextNode("AB")));
-		assertFalse(test.accepts(new TextNode("C")));
+		assertThat(test, not(accepts(new TextNode("AB"))));
+		assertThat(test, not(accepts(new TextNode("C"))));
 		assertThat(test, accepts(new TextNode("D")));
 	}
 	
@@ -382,10 +382,10 @@ public class SchemaV6FactoryTest {
 		Tester multi = fromSingleElement("{ \"type\": [ \"boolean\", \"number\" ] }");
 		assertThat(multi, accepts(BooleanNode.TRUE));
 		assertThat(multi, accepts(new DoubleNode(1.5)));
-		assertFalse(multi.accepts(new TextNode("hi")));
+		assertThat(multi, not(accepts(new TextNode("hi"))));
 		Tester sing = fromSingleElement("{ \"type\": \"boolean\" }");
 		assertThat(sing, accepts(BooleanNode.TRUE));
-		assertFalse(sing.accepts(new DoubleNode(1.5)));
+		assertThat(sing, not(accepts(new DoubleNode(1.5))));
 	}
 	
 	@Test(expected=IllegalArgumentException.class)

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

@@ -32,7 +32,7 @@ public class AllOfTesterTest {
 	@Test
 	public void testFailsIfAllFail() {
 		Tester fails = new AllOfTester(isArray, isObject);
-		assertFalse(fails.accepts(NullNode.getInstance()));
+		assertThat(fails, not(accepts(NullNode.getInstance())));
 	}
 
 	@Test
@@ -48,13 +48,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

@@ -32,7 +32,7 @@ public class AnyOfTesterTest {
 	@Test
 	public void testFailsIfAllFail() {
 		Tester fails = new AnyOfTester(isArray, isObject);
-		assertFalse(fails.accepts(NullNode.getInstance()));
+		assertThat(fails, not(accepts(NullNode.getInstance())));
 	}
 
 	@Test

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

@@ -32,7 +32,7 @@ public class NotTesterTest {
 	@Test
 	public void testNotInvertsOutputFalse() {
 		StubTester impl = JsonNode::isNull;
-		assertFalse(impl.accepts(BooleanNode.TRUE));
+		assertThat(impl, not(accepts(BooleanNode.TRUE)));
 		assertTrue(new NotTester(impl).accepts(BooleanNode.TRUE));
 	}
 }

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

@@ -32,7 +32,7 @@ public class OneOfTesterTest {
 	@Test
 	public void testFailsIfAllFail() {
 		Tester fails = new OneOfTester(isArray, isObject);
-		assertFalse(fails.accepts(NullNode.getInstance()));
+		assertThat(fails, not(accepts(NullNode.getInstance())));
 	}
 
 	@Test
@@ -40,7 +40,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,7 +48,7 @@ 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

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

@@ -29,6 +29,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

@@ -32,7 +32,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 +44,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 +56,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
@@ -80,6 +80,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

@@ -37,41 +37,41 @@ public class SizeTesterTest {
 	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

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

@@ -36,89 +36,89 @@ public class TypeTesterTest {
 		final Tester t = TypeTester.fromType("null");
 		assertThat(t.acceptedTypes(), is(Tester.ANY));
 		assertThat(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, 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));
+		assertThat(t, not(accepts(jNull)));
 		assertThat(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, 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));
+		assertThat(t, not(accepts(jNull)));
+		assertThat(t, not(accepts(bool)));
 		assertThat(t, accepts(integral));
-		assertFalse(t.accepts(floating));
-		assertFalse(t.accepts(text));
-		assertFalse(t.accepts(array));
-		assertFalse(t.accepts(object));
+		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));
+		assertThat(t, not(accepts(jNull)));
+		assertThat(t, not(accepts(bool)));
 		assertThat(t, accepts(integral));
 		assertThat(t, accepts(floating));
-		assertFalse(t.accepts(text));
-		assertFalse(t.accepts(array));
-		assertFalse(t.accepts(object));
+		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));
+		assertThat(t, not(accepts(jNull)));
+		assertThat(t, not(accepts(bool)));
+		assertThat(t, not(accepts(integral)));
+		assertThat(t, not(accepts(floating)));
 		assertThat(t, accepts(text));
-		assertFalse(t.accepts(array));
-		assertFalse(t.accepts(object));
+		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));
+		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));
-		assertFalse(t.accepts(object));
+		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));
+		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));
 	}
 }