From 20d229889380c162bd532f800615d2399a3edd82 Mon Sep 17 00:00:00 2001 From: Kevin Cooney Date: Sun, 1 Jan 2017 16:56:44 -0800 Subject: [PATCH 1/3] Add back public CategoryFilter constructor that was removed in JUnit 4.12. --- .../experimental/categories/Categories.java | 29 ++++++++++++++----- .../experimental/categories/CategoryTest.java | 29 ++++++++++++++++++- 2 files changed, 50 insertions(+), 8 deletions(-) diff --git a/src/main/java/org/junit/experimental/categories/Categories.java b/src/main/java/org/junit/experimental/categories/Categories.java index 34bf78c1606f..898d77c2b04b 100644 --- a/src/main/java/org/junit/experimental/categories/Categories.java +++ b/src/main/java/org/junit/experimental/categories/Categories.java @@ -2,6 +2,7 @@ import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; +import java.util.Arrays; import java.util.Collections; import java.util.HashSet; import java.util.Set; @@ -120,7 +121,7 @@ public static CategoryFilter include(boolean matchAny, Class... categories) { if (hasNull(categories)) { throw new NullPointerException("has null category"); } - return categoryFilter(matchAny, createSet(categories), true, null); + return new CategoryFilter(matchAny, categories, true, null); } public static CategoryFilter include(Class category) { @@ -135,7 +136,7 @@ public static CategoryFilter exclude(boolean matchAny, Class... categories) { if (hasNull(categories)) { throw new NullPointerException("has null category"); } - return categoryFilter(true, null, matchAny, createSet(categories)); + return new CategoryFilter(true, null, matchAny, categories); } public static CategoryFilter exclude(Class category) { @@ -151,14 +152,27 @@ public static CategoryFilter categoryFilter(boolean matchAnyInclusions, Set includedCategory, Class excludedCategory) { + this(true, createSet(includedCategory), true, createSet(excludedCategory)); + } + protected CategoryFilter(boolean matchAnyIncludes, Set> includes, - boolean matchAnyExcludes, Set> excludes) { + boolean matchAnyExcludes, Set> excludes) { includedAny = matchAnyIncludes; excludedAny = matchAnyExcludes; included = copyAndRefine(includes); excluded = copyAndRefine(excludes); } + private CategoryFilter(boolean matchAnyIncludes, Class[] inclusions, + boolean matchAnyExcludes, Class[] exclusions) { + includedAny = matchAnyIncludes; + excludedAny = matchAnyExcludes; + included = createSet(inclusions); + excluded = createSet(exclusions); + } + /** * @see #toString() */ @@ -347,10 +361,11 @@ private static boolean hasAssignableTo(Set> assigns, Class to) { } private static Set> createSet(Class... t) { - final Set> set= new HashSet>(); - if (t != null) { - Collections.addAll(set, t); + if (t == null || t.length == 0) { + return Collections.emptySet(); + } else if (t.length == 1) { + return Collections.>singleton(t[0]); } - return set; + return new HashSet>(Arrays.asList(t)); } } diff --git a/src/test/java/org/junit/experimental/categories/CategoryTest.java b/src/test/java/org/junit/experimental/categories/CategoryTest.java index 552f689c93b6..3d3ad682ce1d 100644 --- a/src/test/java/org/junit/experimental/categories/CategoryTest.java +++ b/src/test/java/org/junit/experimental/categories/CategoryTest.java @@ -179,7 +179,7 @@ public static class TestSuiteWithNoCategories { } @Test - public void testCountWithExplicitFilter() throws Throwable { + public void testCountWithExplicitIncludeFilter() throws Throwable { CategoryFilter include = CategoryFilter.include(SlowTests.class); Request baseRequest = Request.aClass(TestSuiteWithNoCategories.class); Result result = new JUnitCore().run(baseRequest.filterWith(include)); @@ -187,6 +187,24 @@ public void testCountWithExplicitFilter() throws Throwable { assertEquals(2, result.getRunCount()); } + @Test + public void testCountWithExplicitExcludeFilter() throws Throwable { + CategoryFilter include = CategoryFilter.exclude(SlowTests.class); + Request baseRequest = Request.aClass(TestSuiteWithNoCategories.class); + Result result = new JUnitCore().run(baseRequest.filterWith(include)); + assertEquals(2, result.getFailureCount()); + assertEquals(2, result.getRunCount()); + } + + @Test + public void testCountWithExplicitExcludeFilter_usingConstructor() throws Throwable { + CategoryFilter include = new CategoryFilter(null, SlowTests.class); + Request baseRequest = Request.aClass(TestSuiteWithNoCategories.class); + Result result = new JUnitCore().run(baseRequest.filterWith(include)); + assertEquals(2, result.getFailureCount()); + assertEquals(2, result.getRunCount()); + } + @Test public void categoryFilterLeavesOnlyMatchingMethods() throws InitializationError, NoTestsRemainException { @@ -196,6 +214,15 @@ public void categoryFilterLeavesOnlyMatchingMethods() assertEquals(1, runner.testCount()); } + @Test + public void categoryFilterLeavesOnlyMatchingMethods_usingConstructor() + throws InitializationError, NoTestsRemainException { + CategoryFilter filter = new CategoryFilter(SlowTests.class, null); + BlockJUnit4ClassRunner runner = new BlockJUnit4ClassRunner(A.class); + filter.apply(runner); + assertEquals(1, runner.testCount()); + } + public static class OneFastOneSlow { @Category(FastTests.class) @Test From a1555eb46a420ce191319f6c31998b0bfd8b37cb Mon Sep 17 00:00:00 2001 From: Kevin Cooney Date: Mon, 2 Jan 2017 20:31:46 -0800 Subject: [PATCH 2/3] Remove duplicated code that handles null categories. --- .../experimental/categories/Categories.java | 47 ++++++++++--------- 1 file changed, 25 insertions(+), 22 deletions(-) diff --git a/src/main/java/org/junit/experimental/categories/Categories.java b/src/main/java/org/junit/experimental/categories/Categories.java index 898d77c2b04b..12ecaa645425 100644 --- a/src/main/java/org/junit/experimental/categories/Categories.java +++ b/src/main/java/org/junit/experimental/categories/Categories.java @@ -118,9 +118,6 @@ public static class CategoryFilter extends Filter { private final boolean excludedAny; public static CategoryFilter include(boolean matchAny, Class... categories) { - if (hasNull(categories)) { - throw new NullPointerException("has null category"); - } return new CategoryFilter(matchAny, categories, true, null); } @@ -133,9 +130,6 @@ public static CategoryFilter include(Class... categories) { } public static CategoryFilter exclude(boolean matchAny, Class... categories) { - if (hasNull(categories)) { - throw new NullPointerException("has null category"); - } return new CategoryFilter(true, null, matchAny, categories); } @@ -154,7 +148,10 @@ public static CategoryFilter categoryFilter(boolean matchAnyInclusions, Set includedCategory, Class excludedCategory) { - this(true, createSet(includedCategory), true, createSet(excludedCategory)); + includedAny = true; + excludedAny = true; + included = nullableClassToSet(includedCategory); + excluded = nullableClassToSet(excludedCategory); } protected CategoryFilter(boolean matchAnyIncludes, Set> includes, @@ -305,16 +302,6 @@ private static Set> copyAndRefine(Set> classes) { c.remove(null); return c; } - - private static boolean hasNull(Class... classes) { - if (classes == null) return false; - for (Class clazz : classes) { - if (clazz == null) { - return true; - } - } - return false; - } } public Categories(Class klass, RunnerBuilder builder) throws InitializationError { @@ -360,12 +347,28 @@ private static boolean hasAssignableTo(Set> assigns, Class to) { return false; } - private static Set> createSet(Class... t) { - if (t == null || t.length == 0) { + private static Set> createSet(Class[] classes) { + // Not throwing a NPE if t is null is a bad idea, but it's the behavior from JUnit 4.12 + // for include(boolean, Class...) and exclude(boolean, Class...) + if (classes == null || classes.length == 0) { return Collections.emptySet(); - } else if (t.length == 1) { - return Collections.>singleton(t[0]); } - return new HashSet>(Arrays.asList(t)); + for (Class category : classes) { + if (category == null) { + throw new NullPointerException("has null category"); + } + } + + return classes.length == 1 + ? Collections.>singleton(classes[0]) + : new HashSet>(Arrays.asList(classes)); + } + + private static Set> nullableClassToSet(Class nullableClass) { + // Not throwing a NPE if t is null is a bad idea, but it's the behavior from JUnit 4.11 + // for CategoryFilter(Class includedCategory, Class excludedCategory) + return nullableClass == null + ? Collections.>emptySet() + : Collections.>singleton(nullableClass); } } From 07bd5832b912ef2ab9ca884fe9f7c694dffc4a80 Mon Sep 17 00:00:00 2001 From: Kevin Cooney Date: Mon, 2 Jan 2017 20:34:53 -0800 Subject: [PATCH 3/3] Change CategoryFilter to use LinkedHashSet(). This makes describe() and toString() print the categories in the same order that they were provided to the user. --- .../java/org/junit/experimental/categories/Categories.java | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/main/java/org/junit/experimental/categories/Categories.java b/src/main/java/org/junit/experimental/categories/Categories.java index 12ecaa645425..0c73ed82afff 100644 --- a/src/main/java/org/junit/experimental/categories/Categories.java +++ b/src/main/java/org/junit/experimental/categories/Categories.java @@ -5,6 +5,7 @@ import java.util.Arrays; import java.util.Collections; import java.util.HashSet; +import java.util.LinkedHashSet; import java.util.Set; import org.junit.runner.Description; @@ -295,7 +296,7 @@ private static Class[] directCategories(Description description) { } private static Set> copyAndRefine(Set> classes) { - Set> c= new HashSet>(); + Set> c= new LinkedHashSet>(); if (classes != null) { c.addAll(classes); } @@ -361,7 +362,7 @@ private static Set> createSet(Class[] classes) { return classes.length == 1 ? Collections.>singleton(classes[0]) - : new HashSet>(Arrays.asList(classes)); + : new LinkedHashSet>(Arrays.asList(classes)); } private static Set> nullableClassToSet(Class nullableClass) {