Provide better names for the test plan specification

- Renamed isAccepted() into included()
- Renamed isFiltered() into excluded()

Issue: #116

junit-engine-api/src/main/java/org/junit/gen5/engine/DiscoveryRequest.java

@@ -93,7 +93,7 @@ public boolean acceptDescriptor(TestDescriptor testDescriptor) {
 		// @formatter:off
 		return this.getPostDiscoveryFilters().stream()
 				.map(filter -> filter.filter(testDescriptor))
-				.allMatch(FilterResult::isAccepted);
+				.allMatch(FilterResult::included);
 		// @formatter:on
 	}
 

junit-engine-api/src/main/java/org/junit/gen5/engine/EngineIdFilter.java

@@ -10,8 +10,8 @@
 
 package org.junit.gen5.engine;
 
-import static org.junit.gen5.engine.FilterResult.accepted;
-import static org.junit.gen5.engine.FilterResult.filtered;
+import static org.junit.gen5.engine.FilterResult.excluded;
+import static org.junit.gen5.engine.FilterResult.included;
 
 public class EngineIdFilter implements GenericFilter<String> {
 	private final String engineId;
@@ -23,10 +23,10 @@ public EngineIdFilter(String engineId) {
 	@Override
 	public FilterResult filter(String engineId) {
 		if (this.engineId.equals(engineId)) {
-			return accepted("EngineId matches");
+			return included("EngineId matches");
 		}
 		else {
-			return filtered("EngineId matches");
+			return excluded("EngineId matches");
 		}
 	}
 }

junit-engine-api/src/main/java/org/junit/gen5/engine/FilterResult.java

@@ -21,61 +21,67 @@
  */
 public class FilterResult {
 	/**
-	 * Factory for creating <em>filtered</em> results.
+	 * Factory for creating <em>included</em> results.
 	 *
-	 * @param reason the reason why the result was filtered
-	 * @return a filtered {@code FilterResult} with the given reason
+	 * @param reason the reason why the result was included
+	 * @return an included {@code FilterResult} with the given reason
 	 */
-	public static FilterResult filtered(String reason) {
-		return new FilterResult(false, reason);
+	public static FilterResult included(String reason) {
+		return new FilterResult(true, reason);
 	}
 
 	/**
-	 * Factory for creating <em>active</em> results.
+	 * Factory for creating <em>excluded</em> results.
 	 *
-	 * @param reason the reason why the result was filtered
-	 * @return an accepted {@code FilterResult} with the given reason
+	 * @param reason the reason why the result was excluded
+	 * @return a excluded {@code FilterResult} with the given reason
 	 */
-	public static FilterResult accepted(String reason) {
-		return new FilterResult(true, reason);
+	public static FilterResult excluded(String reason) {
+		return new FilterResult(false, reason);
 	}
 
 	/**
 	 * Factory for creating filter results based on the condition given.
 	 *
-	 * @param isAccepted whether or not the returned {@code FilterResult} should be accepted
+	 * @param included whether or not the returned {@code FilterResult} should be included
 	 * @return a valid {@code FilterResult} for the given condition
 	 */
-	public static FilterResult acceptedIf(boolean isAccepted) {
-		return acceptedIf(isAccepted, null);
+	public static FilterResult includedIf(boolean included) {
+		return includedIf(included, null);
 	}
 
 	/**
 	 * Factory for creating filter results based on the condition given.
 	 *
-	 * @param isAccepted whether or not the returned {@code FilterResult} should be accepted
-	 * @param reason     the reason why the result was filtered
+	 * @param included whether or not the returned {@code FilterResult} should be included
+	 * @param reason the reason for the result
 	 * @return a valid {@code FilterResult} for the given condition
 	 */
-	public static FilterResult acceptedIf(boolean isAccepted, String reason) {
-		return isAccepted ? accepted(reason) : filtered(reason);
+	public static FilterResult includedIf(boolean included, String reason) {
+		return included ? included(reason) : excluded(reason);
 	}
 
-	private final boolean accepted;
+	private final boolean included;
 
 	private final Optional<String> reason;
 
-	private FilterResult(boolean isAccepted, String reason) {
-		this.accepted = isAccepted;
+	private FilterResult(boolean included, String reason) {
+		this.included = included;
 		this.reason = Optional.ofNullable(reason);
 	}
 
-	public boolean isAccepted() {
-		return accepted;
+	/**
+	 * @return {@code true} if the filtered object should be included in the test plan
+	 */
+	public boolean included() {
+		return included;
 	}
 
-	public boolean isDeclined() {
-		return !isAccepted();
+	/**
+	 * @return {@code true} if the filtered object should be excluded from the test plan
+	 */
+	public boolean excluded() {
+		return !included();
 	}
 
 	public Optional<String> getReason() {
@@ -86,7 +92,7 @@ public Optional<String> getReason() {
 	public String toString() {
 		// @formatter:off
         return new ToStringBuilder(this)
-                .append("accepted", this.accepted)
+                .append("included", this.included)
                 .append("reason", this.reason)
                 .toString();
         // @formatter:on

junit-engine-api/src/main/java/org/junit/gen5/engine/specification/AllClassFilters.java

@@ -11,7 +11,7 @@
 package org.junit.gen5.engine.specification;
 
 import static java.util.stream.Collectors.joining;
-import static org.junit.gen5.engine.FilterResult.accepted;
+import static org.junit.gen5.engine.FilterResult.included;
 
 import java.util.List;
 
@@ -28,14 +28,14 @@ public AllClassFilters(List<ClassFilter> classFilters) {
 	@Override
 	public FilterResult filter(Class<?> testClass) {
 		if (classFilters == null) {
-			return accepted("No filters to be applied on test class");
+			return included("No filters to be applied on test class");
 		}
 		else {
 			// @formatter:off
-			return FilterResult.acceptedIf(
+			return FilterResult.includedIf(
 				classFilters.stream()
 						.map(filter -> filter.filter(testClass))
-						.allMatch(FilterResult::isAccepted));
+						.allMatch(FilterResult::included));
 			// @formatter:on
 		}
 	}

junit-engine-api/src/main/java/org/junit/gen5/engine/specification/ClassNameFilter.java

@@ -10,8 +10,8 @@
 
 package org.junit.gen5.engine.specification;
 
-import static org.junit.gen5.engine.FilterResult.accepted;
-import static org.junit.gen5.engine.FilterResult.filtered;
+import static org.junit.gen5.engine.FilterResult.excluded;
+import static org.junit.gen5.engine.FilterResult.included;
 
 import java.util.regex.Pattern;
 
@@ -28,10 +28,10 @@ public ClassNameFilter(String regex) {
 	@Override
 	public FilterResult filter(Class<?> testClass) {
 		if (pattern.matcher(testClass.getName()).matches()) {
-			return accepted("TestClass matches name pattern");
+			return included("TestClass matches name pattern");
 		}
 		else {
-			return filtered("TestClass does not match name pattern");
+			return excluded("TestClass does not match name pattern");
 		}
 	}
 

junit-engine-api/src/main/java/org/junit/gen5/engine/specification/PredicateBasedClassFilter.java

@@ -10,8 +10,8 @@
 
 package org.junit.gen5.engine.specification;
 
-import static org.junit.gen5.engine.FilterResult.accepted;
-import static org.junit.gen5.engine.FilterResult.filtered;
+import static org.junit.gen5.engine.FilterResult.excluded;
+import static org.junit.gen5.engine.FilterResult.included;
 
 import java.util.function.Predicate;
 import java.util.function.Supplier;
@@ -36,10 +36,10 @@ public String toString() {
 	@Override
 	public FilterResult filter(Class<?> testClass) {
 		if (predicate.test(testClass)) {
-			return accepted("TestClass matches predicate");
+			return included("TestClass matches predicate");
 		}
 		else {
-			return filtered("TestClass does not match predicate");
+			return excluded("TestClass does not match predicate");
 		}
 	}
 }

junit-engine-api/src/main/java/org/junit/gen5/engine/specification/dsl/TagFilterBuilder.java

@@ -11,10 +11,10 @@
 package org.junit.gen5.engine.specification.dsl;
 
 import static java.util.Arrays.asList;
-import static org.junit.gen5.engine.FilterResult.acceptedIf;
 
 import java.util.List;
 
+import org.junit.gen5.engine.FilterResult;
 import org.junit.gen5.engine.PostDiscoveryFilter;
 import org.junit.gen5.engine.TestTag;
 
@@ -25,7 +25,7 @@ public static PostDiscoveryFilter includeTags(String... tagNames) {
 
 	public static PostDiscoveryFilter includeTags(List<String> includeTags) {
 		// @formatter:off
-        return descriptor -> acceptedIf(
+        return descriptor -> FilterResult.includedIf(
 				descriptor.getTags().stream()
 					.map(TestTag::getName)
 					.anyMatch(includeTags::contains));
@@ -38,7 +38,7 @@ public static PostDiscoveryFilter excludeTags(String... tagNames) {
 
 	public static PostDiscoveryFilter excludeTags(List<String> excludeTags) {
 		// @formatter:off
-        return descriptor -> acceptedIf(
+        return descriptor -> FilterResult.includedIf(
 				descriptor.getTags().stream()
                 	.map(TestTag::getName)
 					.noneMatch(excludeTags::contains));

junit-launcher/src/main/java/org/junit/gen5/launcher/Launcher.java

@@ -99,7 +99,7 @@ private RootTestDescriptor discoverRootDescriptor(DiscoveryRequest specification
 		RootTestDescriptor root = new RootTestDescriptor();
 		for (TestEngine testEngine : testEngineRegistry.getTestEngines()) {
 			if (specification.getEngineIdFilters().stream().map(
-				engineIdFilter -> engineIdFilter.filter(testEngine.getId())).anyMatch(FilterResult::isDeclined)) {
+				engineIdFilter -> engineIdFilter.filter(testEngine.getId())).anyMatch(FilterResult::excluded)) {
 				LOG.fine(
 					() -> String.format("Test discovery for engine '%s' was skipped due to a filter in phase '%s'.",
 						testEngine.getId(), phase));

junit-tests/src/test/java/org/junit/gen5/engine/ClassFiltersTests.java

@@ -27,17 +27,17 @@ void classNameMatches() {
 		ClassFilter filter = ClassFilters.classNameMatches(regex);
 
 		assertEquals("Filter class names with regular expression: " + regex, filter.toString());
-		assertTrue(filter.filter(String.class).isAccepted());
-		assertFalse(filter.filter(Collection.class).isAccepted());
+		assertTrue(filter.filter(String.class).included());
+		assertFalse(filter.filter(Collection.class).included());
 	}
 
 	@Test
 	void anyClass() {
 		ClassFilter filter = ClassFilters.anyClass();
 
 		assertEquals("Any class", filter.toString());
-		assertTrue(filter.filter(String.class).isAccepted());
-		assertTrue(filter.filter(this.getClass()).isAccepted());
+		assertTrue(filter.filter(String.class).included());
+		assertTrue(filter.filter(this.getClass()).included());
 	}
 
 	@Test
@@ -47,8 +47,8 @@ void allOfWithoutFilter() {
 		ClassFilter filter = ClassFilters.allOf(noFilters);
 
 		assertEquals("Any class", filter.toString());
-		assertTrue(filter.filter(String.class).isAccepted());
-		assertTrue(filter.filter(Object.class).isAccepted());
+		assertTrue(filter.filter(String.class).included());
+		assertTrue(filter.filter(Object.class).included());
 	}
 
 	@Test
@@ -67,8 +67,8 @@ void allOfWithMultipleFiltersIsConjunction() {
 
 		ClassFilter filter = ClassFilters.allOf(firstFilter, secondFilter);
 
-		assertFalse(filter.filter(String.class).isAccepted());
-		assertTrue(filter.filter(StringJoiner.class).isAccepted());
+		assertFalse(filter.filter(String.class).included());
+		assertTrue(filter.filter(StringJoiner.class).included());
 	}
 
 	@Test

junit4-engine/src/main/java/org/junit/gen5/engine/junit4/discovery/JUnit4DiscoveryRequestResolver.java

@@ -63,7 +63,7 @@ private Set<TestClassRequest> filterAndConvertToTestClassRequests(DiscoveryReque
 			TestClassCollector collector) {
 		// TODO #40 Log classes that are filtered out
 		ClassFilter classFilter = new AllClassFilters(request.getFilterByType(ClassFilter.class));
-		return collector.toRequests(testClass -> classFilter.filter(testClass).isAccepted());
+		return collector.toRequests(testClass -> classFilter.filter(testClass).included());
 	}
 
 	private void populateEngineDescriptor(Set<TestClassRequest> requests) {

junit5-engine/src/main/java/org/junit/gen5/engine/junit5/JUnit5TestEngine.java

@@ -58,7 +58,7 @@ private void applyEngineFilters(DiscoveryRequest specification, JUnit5EngineDesc
 				// @formatter:off
 				if (classFilters.stream()
 						.map(filter -> filter.filter(testClass))
-						.anyMatch(FilterResult::isDeclined)) {
+						.anyMatch(FilterResult::excluded)) {
 					remove.run();
 				}
 				// @formatter:on