merge branch master into validate_throw

src/main/lombok/org/leumasjaffe/json/schema/Schema.java

@@ -12,7 +12,6 @@ import java.util.Set;
 import org.leumasjaffe.json.JsonHelper;
 
 import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.node.JsonNodeType;
 
 import lombok.AccessLevel;
 import lombok.experimental.FieldDefaults;
@@ -47,14 +46,6 @@ public class Schema implements Tester {
 		children.putAll(fields);
 	}
 	
-	@Override
-	public JsonNodeType[] acceptedTypes() {
-		final Set<JsonNodeType> set = new HashSet<>();
-		children.values().stream().map(Tester::acceptedTypes)
-				.forEach(a -> set.addAll(Arrays.asList(a)));
-		return set.toArray(new JsonNodeType[0]);
-	}
-
 	@Override
 	public boolean accepts(JsonNode node) {
 		if (children.isEmpty()) {
@@ -63,8 +54,6 @@ public class Schema implements Tester {
 			return children.get(SELF).accepts(node);
 		} else if (children.containsKey("$ref")) {
 			return children.get("$ref").accepts(node);
-		} else if (!canProcess(node)) {
-			return false;
 		}
 		switch (node.getNodeType()) {
 		case NUMBER: return acceptsNumber(node);
@@ -142,7 +131,4 @@ public class Schema implements Tester {
 		return keys;
 	}
 
-	private boolean canProcess(JsonNode node) {
-		return Arrays.asList(acceptedTypes()).contains(node.getNodeType());
-	}
 }

src/main/lombok/org/leumasjaffe/json/schema/Tester.java

@@ -1,14 +1,8 @@
 package org.leumasjaffe.json.schema;
 
 import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.node.JsonNodeType;
 
 public interface Tester {
-	static final JsonNodeType[] ANY = {
-			JsonNodeType.ARRAY, JsonNodeType.OBJECT, JsonNodeType.STRING,
-			JsonNodeType.NUMBER, JsonNodeType.BOOLEAN, JsonNodeType.NULL
-	};
-	JsonNodeType[] acceptedTypes();
 	default void validate(final JsonNode node) throws ValidationException {}
 	boolean accepts(final JsonNode node);
 }

src/main/lombok/org/leumasjaffe/json/schema/factory/SchemaFactory.java

@@ -31,11 +31,6 @@ public class SchemaFactory {
 		JsonNodeType type;
 		Predicate<JsonNode> acceptor;
 		
-		@Override
-		public JsonNodeType[] acceptedTypes() {
-			return new JsonNodeType[]{ type };
-		}
-		
 		@Override
 		public boolean accepts(JsonNode node) {
 			return acceptor.test(node);
@@ -45,11 +40,6 @@ public class SchemaFactory {
 	@AllArgsConstructor
 	static final class DeferredTester implements Tester {
 		Supplier<Tester> actual;
-		
-		@Override
-		public JsonNodeType[] acceptedTypes() {
-			return ANY;
-		}
 
 		@Override
 		public boolean accepts(JsonNode node) {

src/main/lombok/org/leumasjaffe/json/schema/tester/AllItemsTester.java

@@ -20,11 +20,6 @@ import lombok.experimental.FieldDefaults;
 public class AllItemsTester implements Tester, ArrayTester, ObjectTester {
 	JsonNodeType type;
 	Tester schema;
-	
-	@Override
-	public JsonNodeType[] acceptedTypes() {
-		return new JsonNodeType[]{type};
-	}
 
 	@Override
 	public boolean accepts(JsonNode node) {

src/main/lombok/org/leumasjaffe/json/schema/tester/AllOfTester.java

@@ -1,14 +1,11 @@
 package org.leumasjaffe.json.schema.tester;
 
 import java.util.Arrays;
-import java.util.HashSet;
 import java.util.List;
-import java.util.Set;
 
 import org.leumasjaffe.json.schema.Tester;
 
 import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.node.JsonNodeType;
 
 import lombok.AccessLevel;
 import lombok.RequiredArgsConstructor;
@@ -22,14 +19,6 @@ public class AllOfTester implements Tester {
 	public AllOfTester(Tester...testers) {
 		this(Arrays.asList(testers));
 	}
-	
-	@Override
-	public JsonNodeType[] acceptedTypes() {
-		final Set<JsonNodeType> set = new HashSet<>(Arrays.asList(ANY));
-		children.stream().map(Tester::acceptedTypes)
-				.forEach(a -> set.retainAll(Arrays.asList(a)));
-		return set.toArray(new JsonNodeType[0]);
-	}
 
 	@Override
 	public boolean accepts(JsonNode node) {

src/main/lombok/org/leumasjaffe/json/schema/tester/AnyOfTester.java

@@ -1,14 +1,11 @@
 package org.leumasjaffe.json.schema.tester;
 
 import java.util.Arrays;
-import java.util.HashSet;
 import java.util.List;
-import java.util.Set;
 
 import org.leumasjaffe.json.schema.Tester;
 
 import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.node.JsonNodeType;
 
 import lombok.AccessLevel;
 import lombok.RequiredArgsConstructor;
@@ -22,14 +19,6 @@ public class AnyOfTester implements Tester {
 	public AnyOfTester(Tester...testers) {
 		this(Arrays.asList(testers));
 	}
-	
-	@Override
-	public JsonNodeType[] acceptedTypes() {
-		final Set<JsonNodeType> set = new HashSet<>();
-		children.stream().map(Tester::acceptedTypes)
-				.forEach(a -> set.addAll(Arrays.asList(a)));
-		return set.toArray(new JsonNodeType[0]);
-	}
 
 	@Override
 	public boolean accepts(JsonNode node) {

src/main/lombok/org/leumasjaffe/json/schema/tester/ContainsTester.java

@@ -4,7 +4,6 @@ import org.leumasjaffe.json.JsonHelper;
 import org.leumasjaffe.json.schema.Tester;
 
 import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.node.JsonNodeType;
 
 import lombok.AccessLevel;
 import lombok.RequiredArgsConstructor;
@@ -14,11 +13,6 @@ import lombok.experimental.FieldDefaults;
 @FieldDefaults(level=AccessLevel.PRIVATE, makeFinal=true)
 public class ContainsTester implements Tester {
 	Tester schema;
-	
-	@Override
-	public JsonNodeType[] acceptedTypes() {
-		return new JsonNodeType[]{JsonNodeType.ARRAY};
-	}
 
 	@Override
 	public boolean accepts(JsonNode node) {

src/main/lombok/org/leumasjaffe/json/schema/tester/DependencyTester.java

@@ -6,7 +6,6 @@ import org.leumasjaffe.json.JsonHelper;
 import org.leumasjaffe.json.schema.Tester;
 
 import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.node.JsonNodeType;
 
 import lombok.AccessLevel;
 import lombok.RequiredArgsConstructor;
@@ -17,11 +16,6 @@ import lombok.experimental.FieldDefaults;
 public class DependencyTester implements Tester {
 	Map<String, Tester> testers;
 
-	@Override
-	public JsonNodeType[] acceptedTypes() {
-		return new JsonNodeType[]{JsonNodeType.OBJECT};
-	}
-
 	@Override
 	public boolean accepts(JsonNode node) {
 		final Map<String, JsonNode> object = JsonHelper.fields(node);

src/main/lombok/org/leumasjaffe/json/schema/tester/EqualsTester.java

@@ -4,7 +4,6 @@ import java.util.Arrays;
 import java.util.List;
 
 import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.node.JsonNodeType;
 
 import lombok.AccessLevel;
 import lombok.RequiredArgsConstructor;
@@ -39,11 +38,6 @@ public class EqualsTester extends SimpleValidationTester {
 	String errorMessage(final JsonNode node) {
 		return node + (isExplicitlySingleValue ? ERROR_CONST : ERROR_ENUM);
 	}
-
-	@Override
-	public JsonNodeType[] acceptedTypes() {
-		return ANY;
-	}
 	
 	@Override
 	public boolean accepts(JsonNode node) {

src/main/lombok/org/leumasjaffe/json/schema/tester/FixedTester.java

@@ -8,7 +8,6 @@ import org.leumasjaffe.json.schema.ObjectTester;
 import org.leumasjaffe.json.schema.Tester;
 
 import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.node.JsonNodeType;
 
 import lombok.AccessLevel;
 import lombok.RequiredArgsConstructor;
@@ -22,11 +21,6 @@ public class FixedTester implements Tester, ArrayTester, ObjectTester {
 	
 	boolean returns;
 
-	@Override
-	public JsonNodeType[] acceptedTypes() {
-		return ANY;
-	}
-
 	@Override
 	public boolean accepts(JsonNode node) {
 		return returns;

src/main/lombok/org/leumasjaffe/json/schema/tester/FormatTester.java

@@ -12,7 +12,6 @@ import org.apache.commons.validator.routines.InetAddressValidator;
 import org.leumasjaffe.json.schema.Tester;
 
 import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.node.JsonNodeType;
 
 import lombok.AccessLevel;
 import lombok.RequiredArgsConstructor;
@@ -145,11 +144,6 @@ public abstract class FormatTester extends SimpleValidationTester {
 		return node + " does not match format: '" + format + "'";
 	}
 	
-	@Override
-	public JsonNodeType[] acceptedTypes() {
-		return new JsonNodeType[] {JsonNodeType.STRING};
-	}
-	
 	public static Tester forCode(String asText) {
 		switch (asText) {
 		case "date-time": return DATE_TIME;

src/main/lombok/org/leumasjaffe/json/schema/tester/ItemsTester.java

@@ -8,7 +8,6 @@ import org.leumasjaffe.json.schema.Tester;
 import org.leumasjaffe.json.schema.ArrayTester;
 
 import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.node.JsonNodeType;
 
 import lombok.AccessLevel;
 import lombok.RequiredArgsConstructor;
@@ -23,11 +22,6 @@ public class ItemsTester implements ArrayTester {
 		this(Arrays.asList(testers));
 	}
 
-	@Override
-	public JsonNodeType[] acceptedTypes() {
-		return new JsonNodeType[]{JsonNodeType.ARRAY};
-	}
-
 	@Override
 	public boolean accepts(JsonNode node) {
 		if (!node.isArray()) return false;

src/main/lombok/org/leumasjaffe/json/schema/tester/NotTester.java

@@ -3,7 +3,6 @@ package org.leumasjaffe.json.schema.tester;
 import org.leumasjaffe.json.schema.Tester;
 
 import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.node.JsonNodeType;
 
 import lombok.AccessLevel;
 import lombok.RequiredArgsConstructor;
@@ -14,11 +13,6 @@ import lombok.experimental.FieldDefaults;
 public class NotTester implements Tester {
 	Tester child;
 
-	@Override
-	public JsonNodeType[] acceptedTypes() {
-		return child.acceptedTypes();
-	}
-
 	@Override
 	public boolean accepts(JsonNode node) {
 		return !child.accepts(node);

src/main/lombok/org/leumasjaffe/json/schema/tester/NumberTester.java

@@ -1,7 +1,6 @@
 package org.leumasjaffe.json.schema.tester;
 
 import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.node.JsonNodeType;
 
 import lombok.AccessLevel;
 import lombok.RequiredArgsConstructor;
@@ -69,11 +68,6 @@ public class NumberTester extends SimpleValidationTester {
 		return node + " is not " + rule.toString() + value;
 	}
 	
-	@Override
-	public JsonNodeType[] acceptedTypes() {
-		return new JsonNodeType[]{JsonNodeType.NUMBER};
-	}
-
 	@Override
 	public boolean accepts(JsonNode node) {
 		return node.isNumber() && rule.test(value, node.asDouble());

src/main/lombok/org/leumasjaffe/json/schema/tester/OneOfTester.java

@@ -1,14 +1,11 @@
 package org.leumasjaffe.json.schema.tester;
 
 import java.util.Arrays;
-import java.util.HashSet;
 import java.util.List;
-import java.util.Set;
 
 import org.leumasjaffe.json.schema.Tester;
 
 import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.node.JsonNodeType;
 
 import lombok.AccessLevel;
 import lombok.RequiredArgsConstructor;
@@ -22,14 +19,6 @@ public class OneOfTester implements Tester {
 	public OneOfTester(Tester...testers) {
 		this(Arrays.asList(testers));
 	}
-
-	@Override
-	public JsonNodeType[] acceptedTypes() {
-		final Set<JsonNodeType> set = new HashSet<>();
-		children.stream().map(Tester::acceptedTypes)
-				.forEach(a -> set.addAll(Arrays.asList(a)));
-		return set.toArray(new JsonNodeType[0]);
-	}
 	
 	@Override
 	public boolean accepts(JsonNode node) {

src/main/lombok/org/leumasjaffe/json/schema/tester/PropertyNameTester.java

@@ -4,7 +4,6 @@ import org.leumasjaffe.json.JsonHelper;
 import org.leumasjaffe.json.schema.Tester;
 
 import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.node.JsonNodeType;
 import com.fasterxml.jackson.databind.node.TextNode;
 
 import lombok.AccessLevel;
@@ -15,11 +14,6 @@ import lombok.experimental.FieldDefaults;
 @FieldDefaults(level=AccessLevel.PRIVATE, makeFinal=true)
 public class PropertyNameTester implements Tester {
 	Tester schema;
-	
-	@Override
-	public JsonNodeType[] acceptedTypes() {
-		return new JsonNodeType[]{JsonNodeType.OBJECT};
-	}
 
 	@Override
 	public boolean accepts(JsonNode node) {

src/main/lombok/org/leumasjaffe/json/schema/tester/PropertyTester.java

@@ -11,7 +11,6 @@ import org.leumasjaffe.json.schema.ObjectTester;
 import org.leumasjaffe.json.schema.Tester;
 
 import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.node.JsonNodeType;
 
 import lombok.AccessLevel;
 import lombok.AllArgsConstructor;
@@ -32,11 +31,6 @@ public class PropertyTester implements ObjectTester {
 	public PropertyTester(Pair...pairs) {
 		this(Arrays.asList(pairs));
 	}
-	
-	@Override
-	public JsonNodeType[] acceptedTypes() {
-		return new JsonNodeType[]{JsonNodeType.OBJECT};
-	}
 
 	@Override
 	public boolean accepts(final JsonNode node) {

src/main/lombok/org/leumasjaffe/json/schema/tester/SizeTester.java

@@ -52,11 +52,6 @@ public class SizeTester implements Tester {
 	Rule rule;
 	int elems;
 	
-	@Override
-	public JsonNodeType[] acceptedTypes() {
-		return new JsonNodeType[]{type};
-	}
-
 	@Override
 	public boolean accepts(JsonNode node) {
 		return node.getNodeType() == type && rule.test(elems, getSize(node));

src/main/lombok/org/leumasjaffe/json/schema/tester/TypeTester.java

@@ -3,7 +3,6 @@ package org.leumasjaffe.json.schema.tester;
 import java.util.function.Predicate;
 
 import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.node.JsonNodeType;
 
 import lombok.AccessLevel;
 import lombok.RequiredArgsConstructor;
@@ -39,11 +38,6 @@ public class TypeTester extends SimpleValidationTester {
 		return "type mismatch. expected: " + name + " got: " + node.getNodeType();
 	}
 	
-	@Override
-	public JsonNodeType[] acceptedTypes() {
-		return ANY;
-	}
-
 	@Override
 	public boolean accepts(JsonNode node) {
 		return test.test(node);

src/main/lombok/org/leumasjaffe/json/schema/tester/UniqueItemTester.java

@@ -6,15 +6,9 @@ import java.util.Set;
 import org.leumasjaffe.json.schema.Tester;
 
 import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.node.JsonNodeType;
 
 public class UniqueItemTester implements Tester {
 	public static final Tester INSTANCE = new UniqueItemTester();
-	
-	@Override
-	public JsonNodeType[] acceptedTypes() {
-		return new JsonNodeType[]{JsonNodeType.ARRAY};
-	}
 
 	@Override
 	public boolean accepts(final JsonNode node) {

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

@@ -3,7 +3,6 @@ package org.leumasjaffe.json.schema;
 import static com.fasterxml.jackson.databind.node.JsonNodeType.*;
 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;
@@ -17,12 +16,10 @@ import org.leumasjaffe.json.schema.tester.EqualsTester;
 import org.leumasjaffe.json.schema.tester.FixedTester;
 import org.leumasjaffe.json.schema.tester.FormatTester;
 import org.leumasjaffe.json.schema.tester.ItemsTester;
-import org.leumasjaffe.json.schema.tester.MockTester;
 import org.leumasjaffe.json.schema.tester.NumberTester;
 import org.leumasjaffe.json.schema.tester.PropertyNameTester;
 import org.leumasjaffe.json.schema.tester.PropertyTester;
 import org.leumasjaffe.json.schema.tester.SizeTester;
-import org.leumasjaffe.json.schema.tester.StubTester;
 import org.leumasjaffe.json.schema.tester.TypeTester;
 import org.leumasjaffe.json.schema.tester.UniqueItemTester;
 
@@ -54,6 +51,7 @@ public class SchemaTest {
 
 	private Schema getNumberSchema() {
 		Map<String, Tester> tests = new HashMap<>();
+		tests.put("type", TypeTester.fromType("number"));
 		tests.put("minimum", NumberTester.minimum(0.0));
 		tests.put("multipleOf", NumberTester.multipleOf(0.25));
 		tests.put("exclusiveMaximum", NumberTester.exclusiveMaximum(1.0));
@@ -62,15 +60,17 @@ public class SchemaTest {
 	
 	private Schema getStringSchema() {
 		Map<String, Tester> tests = new HashMap<>();
+		tests.put("type", TypeTester.fromType("string"));
 		tests.put("maxLength", SizeTester.maxLength(30));
 		tests.put("minLength", SizeTester.minLength(10));
-		tests.put("pattern", (StubTester) j -> j.asText().matches("^https://.*"));
+		tests.put("pattern", j -> j.asText().matches("^https://.*"));
 		tests.put("format", FormatTester.forCode("uri"));
 		return new Schema(tests);
 	}
 	
 	private Schema getArraySchema() {
 		Map<String, Tester> tests = new HashMap<>();
+		tests.put("type", TypeTester.fromType("array"));
 		tests.put("maxItems", SizeTester.maxItems(3));
 		tests.put("minItems", SizeTester.minItems(1));
 		tests.put("uniqueItems", new UniqueItemTester());
@@ -80,23 +80,21 @@ public class SchemaTest {
 
 	private Schema getObjectSchema() {
 		Map<String, Tester> tests = new HashMap<>();
+		tests.put("type", TypeTester.fromType("object"));
 		tests.put("maxProperties", SizeTester.maxProperties(3));
 		tests.put("minProperties", SizeTester.minProperties(2));
-		tests.put("required", (StubTester) json -> json.has("string"));
-		tests.put("propertyNames", new PropertyNameTester((StubTester) j -> j.asText().matches("^[a-z]*$")));
+		tests.put("required", json -> json.has("string"));
+		tests.put("propertyNames", new PropertyNameTester(j -> j.asText().matches("^[a-z]*$")));
 		// TODO Dependencies
 		return new Schema(tests);
 	}
 
 	@Test
-	public void testAcceptsAnyIfNoMatchers() {
-		assertThat(new Schema(), acceptsTypes(Tester.ANY));
-	}
-
-	@Test
-	public void testRejectsWrongType() {
+	public void testRejectsWrongTypeOnlyIfHasTypeArg() {
 		Map<String, Tester> tests = new HashMap<>();
-		tests.put("example", new MockTester(STRING, FixedTester.ACCEPT));
+		tests.put("minProperties", FixedTester.REJECT);
+		assertThat(new Schema(tests), accepts(NullNode.getInstance()));
+		tests.put("type", TypeTester.fromType("string"));
 		assertThat(new Schema(tests), not(accepts(NullNode.getInstance())));
 	}
 

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

@@ -1,6 +1,8 @@
 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 java.io.File;
 import java.io.IOException;
@@ -94,7 +96,7 @@ public class SchemaFactoryTest {
 	@Test
 	public void testSchemaValidatesDraftV6Schema() throws JsonProcessingException, IOException {
 		JsonNode node = mapper.readTree(new File("src/test/resources/schema6.json"));
-		assertTrue(factory.create(node).accepts(node));
+		assertThat(factory.create(node), accepts(node));
 	}
 
 }

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

@@ -1,47 +0,0 @@
-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/tester/AllItemsTesterTest.java

@@ -1,40 +1,33 @@
 package org.leumasjaffe.json.schema.tester;
 
-import static org.junit.Assert.*;
-import static org.hamcrest.core.Is.is;
+import static org.junit.Assert.assertThat;
+import static org.leumasjaffe.json.schema.matcher.Accepts.accepts;
+import static org.leumasjaffe.json.schema.matcher.Not.not;
 import static com.fasterxml.jackson.databind.node.JsonNodeType.ARRAY;
 import static com.fasterxml.jackson.databind.node.JsonNodeType.OBJECT;
 
 import org.junit.Test;
+import org.leumasjaffe.json.schema.Tester;
 
 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.ObjectNode;
 
 public class AllItemsTesterTest {
 
-	@Test
-	public void testAcceptsType() {
-		assertThat(new AllItemsTester(ARRAY, FixedTester.ACCEPT).acceptedTypes(),
-				is(new JsonNodeType[]{ARRAY}));
-		assertThat(new AllItemsTester(OBJECT, FixedTester.ACCEPT).acceptedTypes(),
-				is(new JsonNodeType[]{OBJECT}));
-	}
-	
 	@Test
 	public void testRejectsNonMatching() {
-		assertFalse(new AllItemsTester(ARRAY, FixedTester.ACCEPT)
-				.accepts(new ObjectNode(JsonNodeFactory.instance)));
-		assertFalse(new AllItemsTester(OBJECT, FixedTester.ACCEPT)
-				.accepts(new ArrayNode(JsonNodeFactory.instance)));
+		assertThat(new AllItemsTester(ARRAY, FixedTester.ACCEPT),
+				not(accepts(new ObjectNode(JsonNodeFactory.instance))));
+		assertThat(new AllItemsTester(OBJECT, FixedTester.ACCEPT),
+				not(accepts(new ArrayNode(JsonNodeFactory.instance))));
 	}
 
 	@Test
 	public void testAcceptsEmptyArray() {
 		final ArrayNode node = new ArrayNode(JsonNodeFactory.instance);
-		assertTrue(new AllItemsTester(ARRAY, FixedTester.ACCEPT).accepts(node));
+		assertThat(new AllItemsTester(ARRAY, FixedTester.ACCEPT), accepts(node));
 	}
 	
 	@Test
@@ -42,24 +35,24 @@ public class AllItemsTesterTest {
 		final ArrayNode node = new ArrayNode(JsonNodeFactory.instance);
 		node.add(false);
 		node.add(true);
-		assertFalse(new AllItemsTester(ARRAY, FixedTester.REJECT).accepts(node));
+		assertThat(new AllItemsTester(ARRAY, FixedTester.REJECT), not(accepts(node)));
 	}
 	
 	@Test
 	public void testRejectsIfAnyPass() {
-		StubTester test = JsonNode::asBoolean;
+		Tester test = JsonNode::asBoolean;
 		final ArrayNode node = new ArrayNode(JsonNodeFactory.instance);
 		node.add(false);
 		node.add(true);
-		assertFalse(new AllItemsTester(ARRAY, test).accepts(node));
+		assertThat(new AllItemsTester(ARRAY, test), not(accepts(node)));
 	}
 	
 	@Test
 	public void testAcceptsIfAllPass() {
-		StubTester test = JsonNode::asBoolean;
+		Tester test = JsonNode::asBoolean;
 		final ArrayNode node = new ArrayNode(JsonNodeFactory.instance);
 		node.add(true);
 		node.add(true);
-		assertTrue(new AllItemsTester(ARRAY, test).accepts(node));
+		assertThat(new AllItemsTester(ARRAY, test), accepts(node));
 	}
 }

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

@@ -2,7 +2,6 @@ package org.leumasjaffe.json.schema.tester;
 
 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;
@@ -11,25 +10,12 @@ import org.leumasjaffe.json.schema.Tester;
 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;
 
 public class AllOfTesterTest {
-	StubTester isArray = JsonNode::isArray;
-	StubTester isObject = JsonNode::isObject;
-	StubTester notEmpty = j -> j.size() != 0;
-	
-	@Test
-	public void testAcceptedTypesIsIntersect() {
-		Tester impossible = new AllOfTester(new MockTester(JsonNodeType.OBJECT, null),
-				new MockTester(JsonNodeType.ARRAY, null));
-		assertThat(impossible, acceptsTypes());
-		Tester resticted = new AllOfTester(new MockTester(JsonNodeType.OBJECT, null),
-				isArray);
-		assertThat(resticted, acceptsTypes(JsonNodeType.OBJECT));
-		Tester free = new AllOfTester(isObject,	isArray); // lol
-		assertThat(free, acceptsTypes(Tester.ANY));
-	}
+	Tester isArray = JsonNode::isArray;
+	Tester isObject = JsonNode::isObject;
+	Tester notEmpty = j -> j.size() != 0;
 
 	@Test
 	public void testFailsIfAllFail() {

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

@@ -2,7 +2,6 @@ package org.leumasjaffe.json.schema.tester;
 
 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;
@@ -11,25 +10,12 @@ import org.leumasjaffe.json.schema.Tester;
 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;
 
 public class AnyOfTesterTest {
-	StubTester isArray = JsonNode::isArray;
-	StubTester isObject = JsonNode::isObject;
-	StubTester notEmpty = j -> j.size() != 0;
-	
-	@Test
-	public void testAcceptedTypesIsUnion() {
-		Tester impossible = new AnyOfTester(new MockTester(JsonNodeType.OBJECT, null),
-				new MockTester(JsonNodeType.ARRAY, null));
-		assertThat(impossible, acceptsTypes(JsonNodeType.ARRAY, JsonNodeType.OBJECT));
-		Tester resticted = new AnyOfTester(new MockTester(JsonNodeType.OBJECT, null),
-				isArray);
-		assertThat(resticted, acceptsTypes(Tester.ANY));
-		Tester free = new AnyOfTester(isObject,	isArray); // lol
-		assertThat(free, acceptsTypes(Tester.ANY));
-	}
+	Tester isArray = JsonNode::isArray;
+	Tester isObject = JsonNode::isObject;
+	Tester notEmpty = j -> j.size() != 0;
 
 	@Test
 	public void testFailsIfAllFail() {

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

@@ -1,33 +1,29 @@
 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.Not.not;
 
 import org.junit.Test;
+import org.leumasjaffe.json.schema.Tester;
 
 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;
 
 public class ContainsTesterTest {
-	
-	@Test
-	public void testAcceptedTypes() {
-		assertThat(new ContainsTester(FixedTester.ACCEPT).acceptedTypes(),
-				is(new JsonNodeType[]{JsonNodeType.ARRAY}));
-	}
 
 	@Test
 	public void testRejectsNonArray() {
-		assertFalse(new ContainsTester(FixedTester.ACCEPT).accepts(NullNode.getInstance()));
+		assertThat(new ContainsTester(FixedTester.ACCEPT),
+				not(accepts(NullNode.getInstance())));
 	}
 
 	@Test
 	public void testRejectsEmptyArray() {
 		final ArrayNode node = new ArrayNode(JsonNodeFactory.instance);
-		assertFalse(new ContainsTester(FixedTester.ACCEPT).accepts(node));
+		assertThat(new ContainsTester(FixedTester.ACCEPT), not(accepts(node)));
 	}
 	
 	@Test
@@ -35,15 +31,15 @@ public class ContainsTesterTest {
 		final ArrayNode node = new ArrayNode(JsonNodeFactory.instance);
 		node.add(false);
 		node.add(true);
-		assertFalse(new ContainsTester(FixedTester.REJECT).accepts(node));
+		assertThat(new ContainsTester(FixedTester.REJECT), not(accepts(node)));
 	}
 	
 	@Test
 	public void testAcceptsIfAnyPass() {
-		StubTester test = JsonNode::asBoolean;
+		Tester test = JsonNode::asBoolean;
 		final ArrayNode node = new ArrayNode(JsonNodeFactory.instance);
 		node.add(false);
 		node.add(true);
-		assertTrue(new ContainsTester(test).accepts(node));
+		assertThat(new ContainsTester(test), accepts(node));
 	}
 }

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

@@ -1,7 +1,8 @@
 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.Not.not;
 
 import java.util.HashMap;
 import java.util.Map;
@@ -12,17 +13,10 @@ import org.leumasjaffe.json.schema.tester.PropertyTester.Pair;
 
 import com.fasterxml.jackson.databind.node.BooleanNode;
 import com.fasterxml.jackson.databind.node.JsonNodeFactory;
-import com.fasterxml.jackson.databind.node.JsonNodeType;
 import com.fasterxml.jackson.databind.node.ObjectNode;
 
 public class DependencyTesterTest {
 
-	@Test
-	public void testAcceptsObjects() {
-		assertThat(new DependencyTester(new HashMap<>()).acceptedTypes(),
-				is(new JsonNodeType[]{JsonNodeType.OBJECT}));
-	}
-	
 	@Test
 	public void testDependencyAppliesToSourceJson() {
 		Map<String, Tester> expect = new HashMap<>();
@@ -31,7 +25,7 @@ public class DependencyTesterTest {
 		final ObjectNode node = new ObjectNode(JsonNodeFactory.instance);
 		node.set("A", BooleanNode.TRUE);
 		
-		assertFalse(new DependencyTester(expect).accepts(node));
+		assertThat(new DependencyTester(expect), not(accepts(node)));
 	}
 
 	@Test
@@ -42,6 +36,6 @@ public class DependencyTesterTest {
 		final ObjectNode node = new ObjectNode(JsonNodeFactory.instance);
 		node.set("A", BooleanNode.TRUE);
 		
-		assertTrue(new DependencyTester(expect).accepts(node));
+		assertThat(new DependencyTester(expect), accepts(node));
 	}
 }

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

@@ -3,7 +3,6 @@ package org.leumasjaffe.json.schema.tester;
 import static org.junit.Assert.assertThat;
 import static org.leumasjaffe.json.schema.matcher.Accepts.accepts;
 import static org.leumasjaffe.json.schema.matcher.JsonPath.jsonPath;
-import static org.leumasjaffe.json.schema.matcher.AcceptedTypes.acceptsTypes;
 import static org.leumasjaffe.json.schema.matcher.Not.not;
 
 import org.junit.Rule;
@@ -12,7 +11,6 @@ import org.junit.rules.ExpectedException;
 import org.leumasjaffe.json.schema.Tester;
 import org.leumasjaffe.json.schema.ValidationException;
 
-import com.fasterxml.jackson.databind.node.JsonNodeType;
 import com.fasterxml.jackson.databind.node.NullNode;
 import com.fasterxml.jackson.databind.node.TextNode;
 
@@ -27,7 +25,6 @@ public class FormatTesterTest {
 	@Test
 	public void testUUIDMatcher() {
 		Tester test = FormatTester.forCode("uuid");
-		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"))));
@@ -37,7 +34,6 @@ public class FormatTesterTest {
 	@Test
 	public void testDateTimeMatcher() {
 		Tester test = FormatTester.forCode("date-time");
-		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")));
@@ -51,7 +47,6 @@ public class FormatTesterTest {
 	@Test
 	public void testEmailMatcher() {
 		Tester test = FormatTester.forCode("email");
-		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"))));
@@ -61,7 +56,6 @@ public class FormatTesterTest {
 	@Test
 	public void testHostnameMatcher() {
 		Tester test = FormatTester.forCode("hostname");
-		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"))));
@@ -72,7 +66,6 @@ public class FormatTesterTest {
 	@Test
 	public void testipv4Matcher() {
 		Tester test = FormatTester.forCode("ipv4");
-		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"))));
@@ -82,7 +75,6 @@ public class FormatTesterTest {
 	@Test
 	public void testipv6Matcher() {
 		Tester test = FormatTester.forCode("ipv6");
-		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"))));
@@ -92,7 +84,6 @@ public class FormatTesterTest {
 	@Test
 	public void testURIMatcher() {
 		Tester test = FormatTester.forCode("uri");
-		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"))));
@@ -104,7 +95,6 @@ public class FormatTesterTest {
 	@Test
 	public void testURIReferenceMatcher() {
 		Tester test = FormatTester.forCode("uri-reference");
-		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")));
@@ -116,7 +106,6 @@ public class FormatTesterTest {
 	@Test
 	public void testURITemplateeMatcher() {
 		Tester test = FormatTester.forCode("uri-template");
-		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")));
@@ -128,7 +117,6 @@ public class FormatTesterTest {
 	@Test
 	public void testJsonPointerMatcher() {
 		Tester test = FormatTester.forCode("json-pointer");
-		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"))));
@@ -138,7 +126,6 @@ public class FormatTesterTest {
 	@Test
 	public void testRegexMatcher() {
 		Tester test = FormatTester.forCode("regex");
-		assertThat(test, acceptsTypes(JsonNodeType.STRING));
 		assertThat(test, accepts(new TextNode("")));
 		assertThat(test, accepts(new TextNode("This is some normal text")));
 		assertThat(test, accepts(new TextNode("Birthdate: \\d{4}-\\d{2}-\\d{2}")));

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

@@ -1,33 +1,28 @@
 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.Not.not;
 
 import org.junit.Test;
+import org.leumasjaffe.json.schema.Tester;
 
 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;
 
 public class ItemsTesterTest {
-
-	@Test
-	public void testAcceptedTypes() {
-		assertThat(new ItemsTester(FixedTester.ACCEPT).acceptedTypes(),
-				is(new JsonNodeType[]{JsonNodeType.ARRAY}));
-	}
 	
 	@Test
 	public void testRejectsNonArray() {
-		assertFalse(new ItemsTester(FixedTester.ACCEPT).accepts(NullNode.getInstance()));
+		assertThat(new ItemsTester(FixedTester.ACCEPT), not(accepts(NullNode.getInstance())));
 	}
 
 	@Test
 	public void testAcceptsEmptyArray() {
 		final ArrayNode node = new ArrayNode(JsonNodeFactory.instance);
-		assertTrue(new ItemsTester(FixedTester.ACCEPT).accepts(node));
+		assertThat(new ItemsTester(FixedTester.ACCEPT), accepts(node));
 	}
 	
 	@Test
@@ -35,25 +30,25 @@ public class ItemsTesterTest {
 		final ArrayNode node = new ArrayNode(JsonNodeFactory.instance);
 		node.add(false);
 		node.add(true);
-		assertFalse(new ItemsTester(FixedTester.REJECT).accepts(node));
+		assertThat(new ItemsTester(FixedTester.REJECT), not(accepts(node)));
 	}
 	
 	@Test
 	public void testAcceptsIfNumTestersPass() {
-		StubTester test = JsonNode::asBoolean;
+		Tester test = JsonNode::asBoolean;
 		final ArrayNode node = new ArrayNode(JsonNodeFactory.instance);
 		node.add(true);
 		node.add(false);
-		assertTrue(new ItemsTester(test).accepts(node));
+		assertThat(new ItemsTester(test), accepts(node));
 	}
 	
 	@Test
 	public void testAcceptsIfNumElemsPass() {
-		StubTester test = JsonNode::asBoolean;
+		Tester test = JsonNode::asBoolean;
 		final ArrayNode node = new ArrayNode(JsonNodeFactory.instance);
 		node.add(true);
 		node.add(false);
-		assertTrue(new ItemsTester(test, FixedTester.ACCEPT, FixedTester.REJECT)
-				.accepts(node));
+		assertThat(new ItemsTester(test, FixedTester.ACCEPT, FixedTester.REJECT),
+				accepts(node));
 	}
 }

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

@@ -1,31 +0,0 @@
-package org.leumasjaffe.json.schema.tester;
-
-import org.leumasjaffe.json.schema.Tester;
-
-import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.node.JsonNodeType;
-
-public class MockTester implements Tester {
-	JsonNodeType type;
-	Tester actual;
-	
-	MockTester() {
-		this(null, null);
-	}
-		
-	public MockTester(JsonNodeType type, Tester actual) {
-		this.type = type;
-		this.actual = actual;
-	}
-
-	@Override
-	public JsonNodeType[] acceptedTypes() {
-		return new JsonNodeType[] {type};
-	}
-
-	@Override
-	public boolean accepts(JsonNode node) {
-		return actual.accepts(node);
-	}
-
-}

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

@@ -2,7 +2,6 @@ package org.leumasjaffe.json.schema.tester;
 
 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;
@@ -11,28 +10,20 @@ import org.leumasjaffe.json.schema.tester.NotTester;
 
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.node.BooleanNode;
-import com.fasterxml.jackson.databind.node.JsonNodeType;
 import com.fasterxml.jackson.databind.node.NullNode;
 
 public class NotTesterTest {
-	@Test
-	public void testInheritsAcceptedTypes() {
-		StubTester stub = JsonNode::isNull;
-		assertThat(new NotTester(stub), acceptsTypes(Tester.ANY));
-		MockTester mock = new MockTester(JsonNodeType.STRING, stub);
-		assertThat(new NotTester(mock), acceptsTypes(JsonNodeType.STRING));
-	}
 
 	@Test
 	public void testNotInvertsOutputTrue() {
-		StubTester impl = JsonNode::isNull;
+		Tester impl = JsonNode::isNull;
 		assertThat(impl, accepts(NullNode.getInstance()));
 		assertThat(new NotTester(impl), not(accepts(NullNode.getInstance())));
 	}
 
 	@Test
 	public void testNotInvertsOutputFalse() {
-		StubTester impl = JsonNode::isNull;
+		Tester impl = JsonNode::isNull;
 		assertThat(impl, not(accepts(BooleanNode.TRUE)));
 		assertThat(new NotTester(impl), accepts(BooleanNode.TRUE));
 	}

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

@@ -1,7 +1,6 @@
 package org.leumasjaffe.json.schema.tester;
 
 import static org.junit.Assert.assertThat;
-import static org.leumasjaffe.json.schema.matcher.AcceptedTypes.acceptsTypes;
 import static org.leumasjaffe.json.schema.matcher.Accepts.accepts;
 import static org.leumasjaffe.json.schema.matcher.JsonPath.jsonPath;
 import static org.leumasjaffe.json.schema.matcher.Not.not;
@@ -14,22 +13,12 @@ import org.junit.rules.ExpectedException;
 import org.leumasjaffe.json.schema.ValidationException;
 
 import com.fasterxml.jackson.databind.node.DoubleNode;
-import com.fasterxml.jackson.databind.node.JsonNodeType;
 import com.fasterxml.jackson.databind.node.NullNode;
 
 public class NumberTesterTest {
     @Rule public ExpectedException thrown = ExpectedException.none();
 	DoublePredicate nonZero = d -> d != 0;
-	
-	@Test
-	public void testAcceptedTypeIsArgument() {
-		assertThat(NumberTester.minimum(0.0), acceptsTypes(JsonNodeType.NUMBER));
-		assertThat(NumberTester.exclusiveMinimum(0.0), acceptsTypes(JsonNodeType.NUMBER));
-		assertThat(NumberTester.maximum(0.0), acceptsTypes(JsonNodeType.NUMBER));
-		assertThat(NumberTester.exclusiveMaximum(0.0), acceptsTypes(JsonNodeType.NUMBER));
-		assertThat(NumberTester.multipleOf(1.0), acceptsTypes(JsonNodeType.NUMBER));
-	}
-	
+		
 	@Test
 	public void testRejectsNonNumber() {
 		assertThat(NumberTester.minimum(0.0), not(accepts(NullNode.getInstance())));

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

@@ -2,7 +2,6 @@ package org.leumasjaffe.json.schema.tester;
 
 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;
@@ -11,26 +10,13 @@ import org.leumasjaffe.json.schema.Tester;
 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;
 
 public class OneOfTesterTest {
-	StubTester isArray = JsonNode::isArray;
-	StubTester isObject = JsonNode::isObject;
-	StubTester notEmpty = j -> j.size() != 0;
+	Tester isArray = JsonNode::isArray;
+	Tester isObject = JsonNode::isObject;
+	Tester notEmpty = j -> j.size() != 0;
 
-	@Test
-	public void testAcceptedTypesIsUnion() {
-		Tester impossible = new OneOfTester(new MockTester(JsonNodeType.OBJECT, null),
-				new MockTester(JsonNodeType.ARRAY, null));
-		assertThat(impossible, acceptsTypes(JsonNodeType.ARRAY, JsonNodeType.OBJECT));
-		Tester resticted = new OneOfTester(new MockTester(JsonNodeType.OBJECT, null),
-				isArray);
-		assertThat(resticted, acceptsTypes(Tester.ANY));
-		Tester free = new OneOfTester(isObject,	isArray); // lol
-		assertThat(free, acceptsTypes(Tester.ANY));
-	}
-	
 	@Test
 	public void testFailsIfAllFail() {
 		Tester fails = new OneOfTester(isArray, isObject);

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

@@ -2,23 +2,16 @@ package org.leumasjaffe.json.schema.tester;
 
 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 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;
 
 public class PropertyNameTesterTest {
-	@Test
-	public void testAcceptedTypeIsObject() {
-		assertThat(new PropertyNameTester(FixedTester.REJECT),
-				acceptsTypes(JsonNodeType.OBJECT));
-	}
-	
+
 	@Test
 	public void testPassesEmptyObject() {
 		PropertyNameTester test = new PropertyNameTester(FixedTester.REJECT);

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

@@ -2,23 +2,16 @@ package org.leumasjaffe.json.schema.tester;
 
 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;
 
 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;
 
 public class PropertyTesterTest {
-	@Test
-	public void testAcceptedTypeIsObject() {
-		assertThat(new PropertyTester(new Pair[0]),
-				acceptsTypes(JsonNodeType.OBJECT));
-	}
 
 	@Test
 	public void testPassesUnmatchedProperty() {

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

@@ -2,13 +2,8 @@ package org.leumasjaffe.json.schema.tester;
 
 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 static com.fasterxml.jackson.databind.node.JsonNodeType.ARRAY;
-import static com.fasterxml.jackson.databind.node.JsonNodeType.OBJECT;
-import static com.fasterxml.jackson.databind.node.JsonNodeType.STRING;
-
 import org.junit.Test;
 import org.leumasjaffe.json.schema.tester.SizeTester;
 
@@ -20,13 +15,6 @@ import com.fasterxml.jackson.databind.node.ObjectNode;
 import com.fasterxml.jackson.databind.node.TextNode;
 
 public class SizeTesterTest {
-	@Test
-	public void testAcceptedTypeIsArgument() {
-		assertThat(SizeTester.minItems(0), acceptsTypes(ARRAY));
-		assertThat(SizeTester.minProperties(0), acceptsTypes(OBJECT));
-		assertThat(SizeTester.minLength(0),	acceptsTypes(STRING));
-	}
-
 	@Test
 	public void arrayMatcherRejectsObject() {
 		final SizeTester notEmptyArray = SizeTester.minItems(0);

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

@@ -1,9 +0,0 @@
-package org.leumasjaffe.json.schema.tester;
-
-import org.leumasjaffe.json.schema.Tester;
-
-import com.fasterxml.jackson.databind.node.JsonNodeType;
-
-public interface StubTester extends Tester {
-	default JsonNodeType[] acceptedTypes() { return ANY; }
-}

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

@@ -3,7 +3,6 @@ package org.leumasjaffe.json.schema.tester;
 import static org.junit.Assert.assertThat;
 import static org.leumasjaffe.json.schema.matcher.Accepts.accepts;
 import static org.leumasjaffe.json.schema.matcher.JsonPath.jsonPath;
-import static org.leumasjaffe.json.schema.matcher.AcceptedTypes.acceptsTypes;
 import static org.leumasjaffe.json.schema.matcher.Not.not;
 
 import org.junit.Rule;
@@ -41,7 +40,6 @@ public class TypeTesterTest {
 	@Test
 	public void testMatcheNullNode() {
 		final Tester t = TypeTester.fromType("null");
-		assertThat(t, acceptsTypes(Tester.ANY));
 		assertThat(t, accepts(jNull));
 		assertThat(t, not(accepts(bool)));
 		assertThat(t, not(accepts(integral)));
@@ -54,7 +52,6 @@ public class TypeTesterTest {
 	@Test
 	public void testMatchesBooleanNode() {
 		final Tester t = TypeTester.fromType("boolean");
-		assertThat(t, acceptsTypes(Tester.ANY));
 		assertThat(t, not(accepts(jNull)));
 		assertThat(t, accepts(bool));
 		assertThat(t, not(accepts(integral)));
@@ -67,7 +64,6 @@ public class TypeTesterTest {
 	@Test
 	public void testMatchesIntegerNode() {
 		final Tester t = TypeTester.fromType("integer");
-		assertThat(t, acceptsTypes(Tester.ANY));
 		assertThat(t, not(accepts(jNull)));
 		assertThat(t, not(accepts(bool)));
 		assertThat(t, accepts(integral));
@@ -80,7 +76,6 @@ public class TypeTesterTest {
 	@Test
 	public void testMatchesDoubleNode() {
 		final Tester t = TypeTester.fromType("number");
-		assertThat(t, acceptsTypes(Tester.ANY));
 		assertThat(t, not(accepts(jNull)));
 		assertThat(t, not(accepts(bool)));
 		assertThat(t, accepts(integral));
@@ -93,7 +88,6 @@ public class TypeTesterTest {
 	@Test
 	public void testMatchesTextNode() {
 		final Tester t = TypeTester.fromType("string");
-		assertThat(t, acceptsTypes(Tester.ANY));
 		assertThat(t, not(accepts(jNull)));
 		assertThat(t, not(accepts(bool)));
 		assertThat(t, not(accepts(integral)));
@@ -106,7 +100,6 @@ public class TypeTesterTest {
 	@Test
 	public void testMatchesArrayNode() {
 		final Tester t = TypeTester.fromType("array");
-		assertThat(t, acceptsTypes(Tester.ANY));
 		assertThat(t, not(accepts(jNull)));
 		assertThat(t, not(accepts(bool)));
 		assertThat(t, not(accepts(integral)));
@@ -119,7 +112,6 @@ public class TypeTesterTest {
 	@Test
 	public void testMatchesObjectNode() {
 		final Tester t = TypeTester.fromType("object");
-		assertThat(t, acceptsTypes(Tester.ANY));
 		assertThat(t, not(accepts(jNull)));
 		assertThat(t, not(accepts(bool)));
 		assertThat(t, not(accepts(integral)));

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

@@ -1,33 +1,27 @@
 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.Not.not;
 
 import org.junit.Test;
 
 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.ObjectNode;
 
 public class UniqueItemTesterTest {
-	
-	@Test
-	public void testAcceptedTypeIsArray() {
-		assertThat(new UniqueItemTester().acceptedTypes(),
-				is(new JsonNodeType[]{JsonNodeType.ARRAY}));
-	}
 
 	@Test
 	public void testAcceptsEmptyArray() {
 		final ArrayNode node = new ArrayNode(JsonNodeFactory.instance);
-		assertTrue(new UniqueItemTester().accepts(node));
+		assertThat(new UniqueItemTester(), accepts(node));
 	}
 
 	@Test
 	public void testRejectsNonArray() {
 		final ObjectNode node = new ObjectNode(JsonNodeFactory.instance);
-		assertFalse(new UniqueItemTester().accepts(node));
+		assertThat(new UniqueItemTester(), not(accepts(node)));
 	}
 	
 	@Test
@@ -35,6 +29,6 @@ public class UniqueItemTesterTest {
 		final ArrayNode node = new ArrayNode(JsonNodeFactory.instance);
 		node.add(1.5);
 		node.add(1.5);
-		assertFalse(new UniqueItemTester().accepts(node));
+		assertThat(new UniqueItemTester(), not(accepts(node)));
 	}
 }