Move combine methods for DiscoveryFilters to interface and document them

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

@@ -0,0 +1,55 @@
+/*
+ * Copyright 2015-2016 the original author or authors.
+ *
+ * All rights reserved. This program and the accompanying materials are
+ * made available under the terms of the Eclipse Public License v1.0 which
+ * accompanies this distribution and is available at
+ *
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+
+package org.junit.gen5.engine;
+
+import static java.lang.String.format;
+import static java.util.stream.Collectors.joining;
+import static org.junit.gen5.engine.FilterResult.included;
+
+import java.util.Collection;
+
+/**
+ * Combines a collection of {@link DiscoveryFilter DiscoveryFilters} into a new
+ * filter that will include elements if and only if all of the filters in the
+ * specified collection include it.
+ */
+class CombinedDiscoveryFilter<T> implements DiscoveryFilter<T> {
+
+	@SuppressWarnings("rawtypes")
+	private static final DiscoveryFilter ALWAYS_INCLUDED_DISCOVERY_FILTER = obj -> included("Always included");
+
+	@SuppressWarnings("unchecked")
+	static <T> DiscoveryFilter<T> alwaysIncluded() {
+		return ALWAYS_INCLUDED_DISCOVERY_FILTER;
+	}
+
+	private final Collection<DiscoveryFilter<T>> filters;
+
+	public CombinedDiscoveryFilter(Collection<DiscoveryFilter<T>> filters) {
+		this.filters = filters;
+	}
+
+	@Override
+	public FilterResult filter(T element) {
+		// @formatter:off
+		return filters.stream()
+				.map(filter -> filter.filter(element))
+				.filter(FilterResult::excluded)
+				.findFirst()
+				.orElse(FilterResult.included("Element was included by all filters."));
+		// @formatter:on
+	}
+
+	@Override
+	public String toString() {
+		return filters.stream().map(Object::toString).map(value -> format("(%s)", value)).collect(joining(" and "));
+	}
+}

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

@@ -10,14 +10,62 @@
 
 package org.junit.gen5.engine;
 
+import static java.util.Arrays.asList;
+import static org.junit.gen5.commons.util.CollectionUtils.getOnlyElement;
+import static org.junit.gen5.engine.CombinedDiscoveryFilter.alwaysIncluded;
+
+import java.util.Collection;
+
 /**
- * A {@code DiscoveryFilter} filters particular tests during test discovery.
- * These filters need to be applied by the {@link TestEngine} during test
+ * Filters particular tests during test discovery.
+ *
+ * <p>These filters need to be applied by the {@link TestEngine} during test
  * discovery.
  *
  * @since 5.0
  * @see EngineDiscoveryRequest
  * @see TestEngine
  */
 public interface DiscoveryFilter<T> extends GenericFilter<T> {
+
+	/**
+	 * Combines an array of {@code DiscoveryFilters} into a new filter that will
+	 * include elements if and only if all of the filters in the specified array
+	 * include it.
+	 *
+	 * <p>If the array is {@code null} or empty, the returned filter will
+	 * include all elements it is asked to filter.
+	 *
+	 * <p>If the length of the array is 1, this method will return the filter
+	 * contained in the array.
+	 */
+	@SafeVarargs
+	public static <T> DiscoveryFilter<T> combine(DiscoveryFilter<T>... filters) {
+		if (filters == null) {
+			return alwaysIncluded();
+		}
+		return combine(asList(filters));
+	}
+
+	/**
+	 * Combines a collection of {@code DiscoveryFilters} into a new filter that
+	 * will include elements if and only if all of the filters in the specified
+	 * collection include it.
+	 *
+	 * <p>If the collection is {@code null} or empty, the returned filter will
+	 * include all elements it is asked to filter.
+	 *
+	 * <p>If the size of the collection is 1, this method will return the filter
+	 * contained in the collection.
+	 */
+	public static <T> DiscoveryFilter<T> combine(Collection<DiscoveryFilter<T>> filters) {
+		if (filters == null || filters.isEmpty()) {
+			return alwaysIncluded();
+		}
+		if (filters.size() == 1) {
+			return getOnlyElement(filters);
+		}
+		return new CombinedDiscoveryFilter<>(filters);
+	}
+
 }

junit-tests/src/test/java/org/junit/gen5/engine/discovery/CommonFilterTests.java → junit-tests/src/test/java/org/junit/gen5/engine/DiscoveryFilterTests.java

@@ -8,24 +8,29 @@
  * http://www.eclipse.org/legal/epl-v10.html
  */
 
-package org.junit.gen5.engine.discovery;
+package org.junit.gen5.engine;
 
-import static org.junit.gen5.api.Assertions.*;
-import static org.junit.gen5.engine.FilterResult.*;
+import static org.junit.gen5.api.Assertions.assertEquals;
+import static org.junit.gen5.api.Assertions.assertFalse;
+import static org.junit.gen5.api.Assertions.assertSame;
+import static org.junit.gen5.api.Assertions.assertTrue;
+import static org.junit.gen5.engine.FilterResult.excluded;
+import static org.junit.gen5.engine.FilterResult.included;
 
 import java.util.StringJoiner;
 
 import org.junit.gen5.api.Test;
 import org.junit.gen5.engine.DiscoveryFilter;
+import org.junit.gen5.engine.discovery.ClassFilter;
 import org.junit.gen5.launcher.DiscoveryFilterMock;
 
-public class CommonFilterTests {
+class DiscoveryFilterTests {
 
 	@SuppressWarnings("unchecked")
 	@Test
 	void allOfWithoutFilter() {
 		DiscoveryFilter<Object>[] noFilters = new DiscoveryFilter[0];
-		DiscoveryFilter<Object> combinedFilter = CommonFilter.combine(noFilters);
+		DiscoveryFilter<Object> combinedFilter = DiscoveryFilter.combine(noFilters);
 
 		assertTrue(combinedFilter.filter(String.class).included());
 		assertTrue(combinedFilter.filter(Object.class).included());
@@ -34,7 +39,7 @@ void allOfWithoutFilter() {
 	@Test
 	void allOfWithSingleFilter() {
 		DiscoveryFilter<Class<?>> singleFilter = ClassFilter.byNamePattern(".*ring.*");
-		DiscoveryFilter<Class<?>> combined = CommonFilter.combine(singleFilter);
+		DiscoveryFilter<Class<?>> combined = DiscoveryFilter.combine(singleFilter);
 		assertSame(singleFilter, combined);
 	}
 
@@ -43,7 +48,7 @@ void allOfWithMultipleFiltersIsConjunction() {
 		DiscoveryFilter<Class<?>> firstFilter = ClassFilter.byNamePattern(".*ring.*");
 		DiscoveryFilter<Class<?>> secondFilter = ClassFilter.byNamePattern(".*Join.*");
 
-		DiscoveryFilter<Class<?>> combined = CommonFilter.combine(firstFilter, secondFilter);
+		DiscoveryFilter<Class<?>> combined = DiscoveryFilter.combine(firstFilter, secondFilter);
 
 		assertFalse(combined.filter(String.class).included());
 		assertTrue(combined.filter(StringJoiner.class).included());
@@ -54,7 +59,7 @@ void allOfWithMultipleFiltersHasReadableDescription() {
 		DiscoveryFilter<Object> firstFilter = new DiscoveryFilterMock(o -> excluded("wrong"), () -> "1st");
 		DiscoveryFilter<Object> secondFilter = new DiscoveryFilterMock(o -> included("right"), () -> "2nd");
 
-		DiscoveryFilter<Object> combined = CommonFilter.combine(firstFilter, secondFilter);
+		DiscoveryFilter<Object> combined = DiscoveryFilter.combine(firstFilter, secondFilter);
 
 		assertFalse(combined.filter(String.class).included());
 		assertEquals("(1st) and (2nd)", combined.toString());