Remove all allowedTypes() code.

Failing unit tests:
- testHandlesMultipleTestsForArray
- testRejectsWrongType

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,13 +1,7 @@
 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();
 	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

@@ -6,7 +6,6 @@ import java.util.List;
 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;
@@ -20,11 +19,6 @@ public class EqualsTester implements Tester {
 	public EqualsTester(JsonNode...values) {
 		this(Arrays.asList(values));
 	}
-
-	@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

@@ -135,11 +135,6 @@ public abstract class FormatTester implements Tester {
 	
 	String 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

@@ -5,7 +5,6 @@ import java.util.function.DoublePredicate;
 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;
@@ -15,11 +14,6 @@ import lombok.experimental.FieldDefaults;
 @FieldDefaults(level=AccessLevel.PRIVATE, makeFinal=true)
 public class NumberTester implements Tester {
 	DoublePredicate pred;
-	
-	@Override
-	public JsonNodeType[] acceptedTypes() {
-		return new JsonNodeType[]{JsonNodeType.NUMBER};
-	}
 
 	@Override
 	public boolean accepts(JsonNode node) {

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

@@ -16,11 +16,6 @@ import lombok.experimental.FieldDefaults;
 public class SizeTester implements Tester {
 	JsonNodeType type;
 	IntPredicate pred;
-	
-	@Override
-	public JsonNodeType[] acceptedTypes() {
-		return new JsonNodeType[]{type};
-	}
 
 	@Override
 	public boolean accepts(JsonNode node) {

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

@@ -5,7 +5,6 @@ import java.util.function.Predicate;
 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;
@@ -29,11 +28,6 @@ public class TypeTester implements Tester {
 	}
 	
 	Predicate<JsonNode> test;
-	
-	@Override
-	public JsonNodeType[] acceptedTypes() {
-		return ANY;
-	}
 
 	@Override
 	public boolean accepts(JsonNode 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;
 
@@ -64,7 +61,7 @@ public class SchemaTest {
 		Map<String, Tester> tests = new HashMap<>();
 		tests.put("maxLength", new SizeTester(STRING, s -> s <= 30));
 		tests.put("minLength", new SizeTester(STRING, s -> s >= 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);
 	}
@@ -82,21 +79,16 @@ public class SchemaTest {
 		Map<String, Tester> tests = new HashMap<>();
 		tests.put("maxProperties", new SizeTester(OBJECT, s -> s <= 3));
 		tests.put("minProperties", new SizeTester(OBJECT, s -> s >= 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() {
 		Map<String, Tester> tests = new HashMap<>();
-		tests.put("example", new MockTester(STRING, FixedTester.ACCEPT));
+		tests.put("example", FixedTester.ACCEPT);
 		assertThat(new Schema(tests), not(accepts(NullNode.getInstance())));
 	}
 

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,28 +1,19 @@
 package org.leumasjaffe.json.schema.tester;
 
 import static org.junit.Assert.*;
-import static org.hamcrest.core.Is.is;
 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)
@@ -47,7 +38,7 @@ public class AllItemsTesterTest {
 	
 	@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);
@@ -56,7 +47,7 @@ public class AllItemsTesterTest {
 	
 	@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);

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,23 +1,16 @@
 package org.leumasjaffe.json.schema.tester;
 
 import static org.junit.Assert.*;
-import static org.hamcrest.core.Is.*;
 
 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() {
@@ -40,7 +33,7 @@ public class ContainsTesterTest {
 	
 	@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);

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

@@ -1,6 +1,5 @@
 package org.leumasjaffe.json.schema.tester;
 
-import static org.hamcrest.core.Is.is;
 import static org.junit.Assert.*;
 
 import java.util.HashMap;
@@ -12,17 +11,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<>();

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

@@ -2,13 +2,11 @@ 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;
 
-import com.fasterxml.jackson.databind.node.JsonNodeType;
 import com.fasterxml.jackson.databind.node.NullNode;
 import com.fasterxml.jackson.databind.node.TextNode;
 
@@ -22,7 +20,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"))));
@@ -32,7 +29,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")));
@@ -46,7 +42,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"))));
@@ -56,7 +51,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"))));
@@ -67,7 +61,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"))));
@@ -77,7 +70,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"))));
@@ -87,7 +79,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"))));
@@ -99,7 +90,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")));
@@ -111,7 +101,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")));
@@ -123,7 +112,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"))));
@@ -133,7 +121,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,23 +1,16 @@
 package org.leumasjaffe.json.schema.tester;
 
-import static org.hamcrest.core.Is.is;
 import static org.junit.Assert.*;
 
 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() {
@@ -40,7 +33,7 @@ public class ItemsTesterTest {
 	
 	@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);
@@ -49,7 +42,7 @@ public class ItemsTesterTest {
 	
 	@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);

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,6 +1,5 @@
 package org.leumasjaffe.json.schema.tester;
 
-import static org.hamcrest.core.Is.is;
 import static org.junit.Assert.*;
 
 import java.util.function.DoublePredicate;
@@ -8,18 +7,11 @@ import java.util.function.DoublePredicate;
 import org.junit.Test;
 
 import com.fasterxml.jackson.databind.node.DoubleNode;
-import com.fasterxml.jackson.databind.node.JsonNodeType;
 import com.fasterxml.jackson.databind.node.NullNode;
 
 public class NumberTesterTest {
 	DoublePredicate nonZero = d -> d != 0;
 	
-	@Test
-	public void testAcceptedTypeIsArgument() {
-		assertThat(new NumberTester(nonZero).acceptedTypes(),
-				is(new JsonNodeType[]{JsonNodeType.NUMBER}));
-	}
-	
 	@Test
 	public void testRejectsNonNumber() {
 		assertFalse(new NumberTester(nonZero).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,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 java.util.function.IntPredicate;
@@ -24,16 +23,6 @@ import com.fasterxml.jackson.databind.node.TextNode;
 public class SizeTesterTest {
 	static IntPredicate NON_ZERO = i -> i > 0;
 
-	@Test
-	public void testAcceptedTypeIsArgument() {
-		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);

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

@@ -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;
@@ -36,7 +35,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)));
@@ -49,7 +47,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)));
@@ -62,7 +59,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));
@@ -75,7 +71,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));
@@ -88,7 +83,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)));
@@ -101,7 +95,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)));
@@ -114,7 +107,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,22 +1,14 @@
 package org.leumasjaffe.json.schema.tester;
 
-import static org.hamcrest.core.Is.is;
 import static org.junit.Assert.*;
 
 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() {