You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@maven.apache.org by ti...@apache.org on 2017/08/03 14:37:52 UTC
[02/17] maven-surefire git commit: Convert spaces to tabs
Convert spaces to tabs
Project: http://git-wip-us.apache.org/repos/asf/maven-surefire/repo
Commit: http://git-wip-us.apache.org/repos/asf/maven-surefire/commit/68722a85
Tree: http://git-wip-us.apache.org/repos/asf/maven-surefire/tree/68722a85
Diff: http://git-wip-us.apache.org/repos/asf/maven-surefire/diff/68722a85
Branch: refs/heads/junit5
Commit: 68722a859522efbc9654a7dd6881108c86dafe1d
Parents: 91e6d96
Author: Benedikt Ritter <br...@apache.org>
Authored: Mon Feb 6 14:23:03 2017 +0100
Committer: Benedikt Ritter <br...@apache.org>
Committed: Mon Jun 12 08:18:33 2017 +0200
----------------------------------------------------------------------
.../provider/JUnitPlatformProvider.java | 236 ++++++------
.../surefire/provider/RunListenerAdapter.java | 164 ++++----
.../provider/TestPlanScannerFilter.java | 38 +-
.../provider/JUnitPlatformProviderTests.java | 382 +++++++++----------
.../provider/RunListenerAdapterTests.java | 334 ++++++++--------
.../provider/TestPlanScannerFilterTests.java | 228 +++++------
.../src/test/resources/log4j2-test.xml | 26 +-
7 files changed, 704 insertions(+), 704 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/maven-surefire/blob/68722a85/surefire-providers/surefire-junit5/src/main/java/org/junit/platform/surefire/provider/JUnitPlatformProvider.java
----------------------------------------------------------------------
diff --git a/surefire-providers/surefire-junit5/src/main/java/org/junit/platform/surefire/provider/JUnitPlatformProvider.java b/surefire-providers/surefire-junit5/src/main/java/org/junit/platform/surefire/provider/JUnitPlatformProvider.java
index 676d33f..99f0fd5 100644
--- a/surefire-providers/surefire-junit5/src/main/java/org/junit/platform/surefire/provider/JUnitPlatformProvider.java
+++ b/surefire-providers/surefire-junit5/src/main/java/org/junit/platform/surefire/provider/JUnitPlatformProvider.java
@@ -48,123 +48,123 @@ import org.junit.platform.launcher.core.LauncherFactory;
*/
public class JUnitPlatformProvider extends AbstractProvider {
- // Parameter names processed to determine which @Tags should be executed.
- static final String EXCLUDE_GROUPS = "excludedGroups";
- static final String EXCLUDE_TAGS = "excludeTags";
- static final String INCLUDE_GROUPS = "groups";
- static final String INCLUDE_TAGS = "includeTags";
-
- static final String EXCEPTION_MESSAGE_BOTH_NOT_ALLOWED = "The " + INCLUDE_GROUPS + " and " + INCLUDE_TAGS
- + " parameters (or the " + EXCLUDE_GROUPS + " and " + EXCLUDE_TAGS + " parameters) are synonyms - "
- + "only one of each is allowed (though neither is required).";
-
- private final ProviderParameters parameters;
- private final Launcher launcher;
- final Filter<?>[] includeAndExcludeFilters;
-
- public JUnitPlatformProvider(ProviderParameters parameters) {
- this(parameters, LauncherFactory.create());
- }
-
- JUnitPlatformProvider(ProviderParameters parameters, Launcher launcher) {
- this.parameters = parameters;
- this.launcher = launcher;
- this.includeAndExcludeFilters = getIncludeAndExcludeFilters();
- Logger.getLogger("org.junit").setLevel(Level.WARNING);
- }
-
- @Override
- public Iterable<Class<?>> getSuites() {
- return scanClasspath();
- }
-
- @Override
- public RunResult invoke(Object forkTestSet)
- throws TestSetFailedException, ReporterException, InvocationTargetException {
- if (forkTestSet instanceof TestsToRun) {
- return invokeAllTests((TestsToRun) forkTestSet);
- }
- else if (forkTestSet instanceof Class) {
- return invokeAllTests(TestsToRun.fromClass((Class<?>) forkTestSet));
- }
- else if (forkTestSet == null) {
- return invokeAllTests(scanClasspath());
- }
- else {
- throw new IllegalArgumentException("Unexpected value of forkTestSet: " + forkTestSet);
- }
- }
-
- private TestsToRun scanClasspath() {
- TestsToRun scannedClasses = parameters.getScanResult().applyFilter(
- new TestPlanScannerFilter(launcher, includeAndExcludeFilters), parameters.getTestClassLoader());
- return parameters.getRunOrderCalculator().orderTestClasses(scannedClasses);
- }
-
- private RunResult invokeAllTests(TestsToRun testsToRun) {
- RunResult runResult;
- ReporterFactory reporterFactory = parameters.getReporterFactory();
- try {
- RunListener runListener = reporterFactory.createReporter();
- launcher.registerTestExecutionListeners(new RunListenerAdapter(runListener));
-
- for (Class<?> testClass : testsToRun) {
- invokeSingleClass(testClass, runListener);
- }
- }
- finally {
- runResult = reporterFactory.close();
- }
- return runResult;
- }
-
- private void invokeSingleClass(Class<?> testClass, RunListener runListener) {
- SimpleReportEntry classEntry = new SimpleReportEntry(getClass().getName(), testClass.getName());
- runListener.testSetStarting(classEntry);
-
- LauncherDiscoveryRequest discoveryRequest = request().selectors(selectClass(testClass)).filters(
- includeAndExcludeFilters).build();
- launcher.execute(discoveryRequest);
-
- runListener.testSetCompleted(classEntry);
- }
-
- private Filter<?>[] getIncludeAndExcludeFilters() {
- List<Filter<?>> filters = new ArrayList<>();
-
- Optional<List<String>> includes = getGroupsOrTags(getPropertiesList(INCLUDE_GROUPS),
- getPropertiesList(INCLUDE_TAGS));
- includes.map(TagFilter::includeTags).ifPresent(filters::add);
-
- Optional<List<String>> excludes = getGroupsOrTags(getPropertiesList(EXCLUDE_GROUPS),
- getPropertiesList(EXCLUDE_TAGS));
- excludes.map(TagFilter::excludeTags).ifPresent(filters::add);
-
- return filters.toArray(new Filter<?>[filters.size()]);
- }
-
- private Optional<List<String>> getPropertiesList(String key) {
- List<String> compoundProperties = null;
- String property = parameters.getProviderProperties().get(key);
- if (property != null) {
- compoundProperties = Arrays.asList(property.split("[, ]+"));
- }
- return Optional.ofNullable(compoundProperties);
- }
-
- private Optional<List<String>> getGroupsOrTags(Optional<List<String>> groups, Optional<List<String>> tags) {
- Optional<List<String>> elements = Optional.empty();
-
- Preconditions.condition(!groups.isPresent() || !tags.isPresent(), EXCEPTION_MESSAGE_BOTH_NOT_ALLOWED);
-
- if (groups.isPresent()) {
- elements = groups;
- }
- else if (tags.isPresent()) {
- elements = tags;
- }
-
- return elements;
- }
+ // Parameter names processed to determine which @Tags should be executed.
+ static final String EXCLUDE_GROUPS = "excludedGroups";
+ static final String EXCLUDE_TAGS = "excludeTags";
+ static final String INCLUDE_GROUPS = "groups";
+ static final String INCLUDE_TAGS = "includeTags";
+
+ static final String EXCEPTION_MESSAGE_BOTH_NOT_ALLOWED = "The " + INCLUDE_GROUPS + " and " + INCLUDE_TAGS
+ + " parameters (or the " + EXCLUDE_GROUPS + " and " + EXCLUDE_TAGS + " parameters) are synonyms - "
+ + "only one of each is allowed (though neither is required).";
+
+ private final ProviderParameters parameters;
+ private final Launcher launcher;
+ final Filter<?>[] includeAndExcludeFilters;
+
+ public JUnitPlatformProvider(ProviderParameters parameters) {
+ this(parameters, LauncherFactory.create());
+ }
+
+ JUnitPlatformProvider(ProviderParameters parameters, Launcher launcher) {
+ this.parameters = parameters;
+ this.launcher = launcher;
+ this.includeAndExcludeFilters = getIncludeAndExcludeFilters();
+ Logger.getLogger("org.junit").setLevel(Level.WARNING);
+ }
+
+ @Override
+ public Iterable<Class<?>> getSuites() {
+ return scanClasspath();
+ }
+
+ @Override
+ public RunResult invoke(Object forkTestSet)
+ throws TestSetFailedException, ReporterException, InvocationTargetException {
+ if (forkTestSet instanceof TestsToRun) {
+ return invokeAllTests((TestsToRun) forkTestSet);
+ }
+ else if (forkTestSet instanceof Class) {
+ return invokeAllTests(TestsToRun.fromClass((Class<?>) forkTestSet));
+ }
+ else if (forkTestSet == null) {
+ return invokeAllTests(scanClasspath());
+ }
+ else {
+ throw new IllegalArgumentException("Unexpected value of forkTestSet: " + forkTestSet);
+ }
+ }
+
+ private TestsToRun scanClasspath() {
+ TestsToRun scannedClasses = parameters.getScanResult().applyFilter(
+ new TestPlanScannerFilter(launcher, includeAndExcludeFilters), parameters.getTestClassLoader());
+ return parameters.getRunOrderCalculator().orderTestClasses(scannedClasses);
+ }
+
+ private RunResult invokeAllTests(TestsToRun testsToRun) {
+ RunResult runResult;
+ ReporterFactory reporterFactory = parameters.getReporterFactory();
+ try {
+ RunListener runListener = reporterFactory.createReporter();
+ launcher.registerTestExecutionListeners(new RunListenerAdapter(runListener));
+
+ for (Class<?> testClass : testsToRun) {
+ invokeSingleClass(testClass, runListener);
+ }
+ }
+ finally {
+ runResult = reporterFactory.close();
+ }
+ return runResult;
+ }
+
+ private void invokeSingleClass(Class<?> testClass, RunListener runListener) {
+ SimpleReportEntry classEntry = new SimpleReportEntry(getClass().getName(), testClass.getName());
+ runListener.testSetStarting(classEntry);
+
+ LauncherDiscoveryRequest discoveryRequest = request().selectors(selectClass(testClass)).filters(
+ includeAndExcludeFilters).build();
+ launcher.execute(discoveryRequest);
+
+ runListener.testSetCompleted(classEntry);
+ }
+
+ private Filter<?>[] getIncludeAndExcludeFilters() {
+ List<Filter<?>> filters = new ArrayList<>();
+
+ Optional<List<String>> includes = getGroupsOrTags(getPropertiesList(INCLUDE_GROUPS),
+ getPropertiesList(INCLUDE_TAGS));
+ includes.map(TagFilter::includeTags).ifPresent(filters::add);
+
+ Optional<List<String>> excludes = getGroupsOrTags(getPropertiesList(EXCLUDE_GROUPS),
+ getPropertiesList(EXCLUDE_TAGS));
+ excludes.map(TagFilter::excludeTags).ifPresent(filters::add);
+
+ return filters.toArray(new Filter<?>[filters.size()]);
+ }
+
+ private Optional<List<String>> getPropertiesList(String key) {
+ List<String> compoundProperties = null;
+ String property = parameters.getProviderProperties().get(key);
+ if (property != null) {
+ compoundProperties = Arrays.asList(property.split("[, ]+"));
+ }
+ return Optional.ofNullable(compoundProperties);
+ }
+
+ private Optional<List<String>> getGroupsOrTags(Optional<List<String>> groups, Optional<List<String>> tags) {
+ Optional<List<String>> elements = Optional.empty();
+
+ Preconditions.condition(!groups.isPresent() || !tags.isPresent(), EXCEPTION_MESSAGE_BOTH_NOT_ALLOWED);
+
+ if (groups.isPresent()) {
+ elements = groups;
+ }
+ else if (tags.isPresent()) {
+ elements = tags;
+ }
+
+ return elements;
+ }
}
http://git-wip-us.apache.org/repos/asf/maven-surefire/blob/68722a85/surefire-providers/surefire-junit5/src/main/java/org/junit/platform/surefire/provider/RunListenerAdapter.java
----------------------------------------------------------------------
diff --git a/surefire-providers/surefire-junit5/src/main/java/org/junit/platform/surefire/provider/RunListenerAdapter.java b/surefire-providers/surefire-junit5/src/main/java/org/junit/platform/surefire/provider/RunListenerAdapter.java
index 70fb928..ab79ddd 100644
--- a/surefire-providers/surefire-junit5/src/main/java/org/junit/platform/surefire/provider/RunListenerAdapter.java
+++ b/surefire-providers/surefire-junit5/src/main/java/org/junit/platform/surefire/provider/RunListenerAdapter.java
@@ -39,86 +39,86 @@ import org.junit.platform.launcher.TestPlan;
*/
final class RunListenerAdapter implements TestExecutionListener {
- private final RunListener runListener;
- private Optional<TestPlan> testPlan = Optional.empty();
-
- public RunListenerAdapter(RunListener runListener) {
- this.runListener = runListener;
- }
-
- @Override
- public void testPlanExecutionStarted(TestPlan testPlan) {
- this.testPlan = Optional.of(testPlan);
- }
-
- @Override
- public void testPlanExecutionFinished(TestPlan testPlan) {
- this.testPlan = Optional.empty();
- }
-
- @Override
- public void executionStarted(TestIdentifier testIdentifier) {
- if (testIdentifier.isTest()) {
- runListener.testStarting(createReportEntry(testIdentifier, Optional.empty()));
- }
- }
-
- @Override
- public void executionSkipped(TestIdentifier testIdentifier, String reason) {
- String source = getClassName(testIdentifier).orElseGet(() -> parentDisplayName(testIdentifier));
- runListener.testSkipped(ignored(source, testIdentifier.getDisplayName(), reason));
- }
-
- @Override
- public void executionFinished(TestIdentifier testIdentifier, TestExecutionResult testExecutionResult) {
- if (testExecutionResult.getStatus() == ABORTED) {
- runListener.testAssumptionFailure(createReportEntry(testIdentifier, testExecutionResult.getThrowable()));
- }
- else if (testExecutionResult.getStatus() == FAILED) {
- runListener.testFailed(createReportEntry(testIdentifier, testExecutionResult.getThrowable()));
- }
- else if (testIdentifier.isTest()) {
- runListener.testSucceeded(createReportEntry(testIdentifier, Optional.empty()));
- }
- }
-
- private SimpleReportEntry createReportEntry(TestIdentifier testIdentifier, Optional<Throwable> throwable) {
- Optional<String> className = getClassName(testIdentifier);
- if (className.isPresent()) {
- StackTraceWriter traceWriter = new PojoStackTraceWriter(className.get(),
- getMethodName(testIdentifier).orElse(""), throwable.orElse(null));
- return new SimpleReportEntry(className.get(), testIdentifier.getDisplayName(), traceWriter, null);
- }
- else {
- return new SimpleReportEntry(parentDisplayName(testIdentifier), testIdentifier.getDisplayName(), null);
- }
- }
-
- private Optional<String> getClassName(TestIdentifier testIdentifier) {
- TestSource testSource = testIdentifier.getSource().orElse(null);
- if (testSource instanceof ClassSource) {
- return Optional.of(((ClassSource) testSource).getJavaClass().getName());
- }
- if (testSource instanceof MethodSource) {
- return Optional.of(((MethodSource) testSource).getClassName());
- }
- return Optional.empty();
- }
-
- private Optional<String> getMethodName(TestIdentifier testIdentifier) {
- TestSource testSource = testIdentifier.getSource().orElse(null);
- if (testSource instanceof MethodSource) {
- return Optional.of(((MethodSource) testSource).getMethodName());
- }
- return Optional.empty();
- }
-
- private String parentDisplayName(TestIdentifier testIdentifier) {
- // @formatter:off
- return testPlan
- .flatMap(plan -> plan.getParent(testIdentifier))
- .map(TestIdentifier::getDisplayName)
- .orElseGet(testIdentifier::getUniqueId);
- // @formatter:on
- }
+ private final RunListener runListener;
+ private Optional<TestPlan> testPlan = Optional.empty();
+
+ public RunListenerAdapter(RunListener runListener) {
+ this.runListener = runListener;
+ }
+
+ @Override
+ public void testPlanExecutionStarted(TestPlan testPlan) {
+ this.testPlan = Optional.of(testPlan);
+ }
+
+ @Override
+ public void testPlanExecutionFinished(TestPlan testPlan) {
+ this.testPlan = Optional.empty();
+ }
+
+ @Override
+ public void executionStarted(TestIdentifier testIdentifier) {
+ if (testIdentifier.isTest()) {
+ runListener.testStarting(createReportEntry(testIdentifier, Optional.empty()));
+ }
+ }
+
+ @Override
+ public void executionSkipped(TestIdentifier testIdentifier, String reason) {
+ String source = getClassName(testIdentifier).orElseGet(() -> parentDisplayName(testIdentifier));
+ runListener.testSkipped(ignored(source, testIdentifier.getDisplayName(), reason));
+ }
+
+ @Override
+ public void executionFinished(TestIdentifier testIdentifier, TestExecutionResult testExecutionResult) {
+ if (testExecutionResult.getStatus() == ABORTED) {
+ runListener.testAssumptionFailure(createReportEntry(testIdentifier, testExecutionResult.getThrowable()));
+ }
+ else if (testExecutionResult.getStatus() == FAILED) {
+ runListener.testFailed(createReportEntry(testIdentifier, testExecutionResult.getThrowable()));
+ }
+ else if (testIdentifier.isTest()) {
+ runListener.testSucceeded(createReportEntry(testIdentifier, Optional.empty()));
+ }
+ }
+
+ private SimpleReportEntry createReportEntry(TestIdentifier testIdentifier, Optional<Throwable> throwable) {
+ Optional<String> className = getClassName(testIdentifier);
+ if (className.isPresent()) {
+ StackTraceWriter traceWriter = new PojoStackTraceWriter(className.get(),
+ getMethodName(testIdentifier).orElse(""), throwable.orElse(null));
+ return new SimpleReportEntry(className.get(), testIdentifier.getDisplayName(), traceWriter, null);
+ }
+ else {
+ return new SimpleReportEntry(parentDisplayName(testIdentifier), testIdentifier.getDisplayName(), null);
+ }
+ }
+
+ private Optional<String> getClassName(TestIdentifier testIdentifier) {
+ TestSource testSource = testIdentifier.getSource().orElse(null);
+ if (testSource instanceof ClassSource) {
+ return Optional.of(((ClassSource) testSource).getJavaClass().getName());
+ }
+ if (testSource instanceof MethodSource) {
+ return Optional.of(((MethodSource) testSource).getClassName());
+ }
+ return Optional.empty();
+ }
+
+ private Optional<String> getMethodName(TestIdentifier testIdentifier) {
+ TestSource testSource = testIdentifier.getSource().orElse(null);
+ if (testSource instanceof MethodSource) {
+ return Optional.of(((MethodSource) testSource).getMethodName());
+ }
+ return Optional.empty();
+ }
+
+ private String parentDisplayName(TestIdentifier testIdentifier) {
+ // @formatter:off
+ return testPlan
+ .flatMap(plan -> plan.getParent(testIdentifier))
+ .map(TestIdentifier::getDisplayName)
+ .orElseGet(testIdentifier::getUniqueId);
+ // @formatter:on
+ }
}
http://git-wip-us.apache.org/repos/asf/maven-surefire/blob/68722a85/surefire-providers/surefire-junit5/src/main/java/org/junit/platform/surefire/provider/TestPlanScannerFilter.java
----------------------------------------------------------------------
diff --git a/surefire-providers/surefire-junit5/src/main/java/org/junit/platform/surefire/provider/TestPlanScannerFilter.java b/surefire-providers/surefire-junit5/src/main/java/org/junit/platform/surefire/provider/TestPlanScannerFilter.java
index fd1796d..29d2f52 100644
--- a/surefire-providers/surefire-junit5/src/main/java/org/junit/platform/surefire/provider/TestPlanScannerFilter.java
+++ b/surefire-providers/surefire-junit5/src/main/java/org/junit/platform/surefire/provider/TestPlanScannerFilter.java
@@ -33,24 +33,24 @@ import org.junit.platform.launcher.TestPlan;
*/
final class TestPlanScannerFilter implements ScannerFilter {
- private static final Predicate<TestIdentifier> hasTests = testIdentifier -> testIdentifier.isTest()
- || testIdentifier.isContainer();
-
- private final Launcher launcher;
- private final Filter<?>[] includeAndExcludeFilters;
-
- public TestPlanScannerFilter(Launcher launcher, Filter<?>[] includeAndExcludeFilters) {
- this.launcher = launcher;
- this.includeAndExcludeFilters = includeAndExcludeFilters;
- }
-
- @Override
- @SuppressWarnings("rawtypes")
- public boolean accept(Class testClass) {
- LauncherDiscoveryRequest discoveryRequest = request().selectors(selectClass(testClass)).filters(
- includeAndExcludeFilters).build();
- TestPlan testPlan = launcher.discover(discoveryRequest);
- return testPlan.countTestIdentifiers(hasTests) > 0;
- }
+ private static final Predicate<TestIdentifier> hasTests = testIdentifier -> testIdentifier.isTest()
+ || testIdentifier.isContainer();
+
+ private final Launcher launcher;
+ private final Filter<?>[] includeAndExcludeFilters;
+
+ public TestPlanScannerFilter(Launcher launcher, Filter<?>[] includeAndExcludeFilters) {
+ this.launcher = launcher;
+ this.includeAndExcludeFilters = includeAndExcludeFilters;
+ }
+
+ @Override
+ @SuppressWarnings("rawtypes")
+ public boolean accept(Class testClass) {
+ LauncherDiscoveryRequest discoveryRequest = request().selectors(selectClass(testClass)).filters(
+ includeAndExcludeFilters).build();
+ TestPlan testPlan = launcher.discover(discoveryRequest);
+ return testPlan.countTestIdentifiers(hasTests) > 0;
+ }
}
http://git-wip-us.apache.org/repos/asf/maven-surefire/blob/68722a85/surefire-providers/surefire-junit5/src/test/java/org/junit/platform/surefire/provider/JUnitPlatformProviderTests.java
----------------------------------------------------------------------
diff --git a/surefire-providers/surefire-junit5/src/test/java/org/junit/platform/surefire/provider/JUnitPlatformProviderTests.java b/surefire-providers/surefire-junit5/src/test/java/org/junit/platform/surefire/provider/JUnitPlatformProviderTests.java
index 798e471..ef9201a 100644
--- a/surefire-providers/surefire-junit5/src/test/java/org/junit/platform/surefire/provider/JUnitPlatformProviderTests.java
+++ b/surefire-providers/surefire-junit5/src/test/java/org/junit/platform/surefire/provider/JUnitPlatformProviderTests.java
@@ -53,234 +53,234 @@ import org.junit.platform.launcher.listeners.TestExecutionSummary;
*/
class JUnitPlatformProviderTests {
- @Test
- void getSuitesReturnsScannedClasses() throws Exception {
- ProviderParameters providerParameters = providerParametersMock(TestClass1.class, TestClass2.class);
- JUnitPlatformProvider provider = new JUnitPlatformProvider(providerParameters);
+ @Test
+ void getSuitesReturnsScannedClasses() throws Exception {
+ ProviderParameters providerParameters = providerParametersMock(TestClass1.class, TestClass2.class);
+ JUnitPlatformProvider provider = new JUnitPlatformProvider(providerParameters);
- assertThat(provider.getSuites()).containsOnly(TestClass1.class, TestClass2.class);
- }
-
- @Test
- void invokeThrowsForWrongForkTestSet() throws Exception {
- ProviderParameters providerParameters = providerParametersMock(Integer.class);
- JUnitPlatformProvider provider = new JUnitPlatformProvider(providerParameters);
+ assertThat(provider.getSuites()).containsOnly(TestClass1.class, TestClass2.class);
+ }
+
+ @Test
+ void invokeThrowsForWrongForkTestSet() throws Exception {
+ ProviderParameters providerParameters = providerParametersMock(Integer.class);
+ JUnitPlatformProvider provider = new JUnitPlatformProvider(providerParameters);
- assertThrows(IllegalArgumentException.class, () -> provider.invoke("wrong forkTestSet"));
- }
+ assertThrows(IllegalArgumentException.class, () -> provider.invoke("wrong forkTestSet"));
+ }
- @Test
- void allGivenTestsToRunAreInvoked() throws Exception {
- Launcher launcher = LauncherFactory.create();
- JUnitPlatformProvider provider = new JUnitPlatformProvider(providerParametersMock(), launcher);
+ @Test
+ void allGivenTestsToRunAreInvoked() throws Exception {
+ Launcher launcher = LauncherFactory.create();
+ JUnitPlatformProvider provider = new JUnitPlatformProvider(providerParametersMock(), launcher);
- TestPlanSummaryListener executionListener = new TestPlanSummaryListener();
- launcher.registerTestExecutionListeners(executionListener);
+ TestPlanSummaryListener executionListener = new TestPlanSummaryListener();
+ launcher.registerTestExecutionListeners(executionListener);
- TestsToRun testsToRun = newTestsToRun(TestClass1.class, TestClass2.class);
- provider.invoke(testsToRun);
+ TestsToRun testsToRun = newTestsToRun(TestClass1.class, TestClass2.class);
+ provider.invoke(testsToRun);
- assertThat(executionListener.summaries).hasSize(2);
- TestClass1.verifyExecutionSummary(executionListener.summaries.get(0));
- TestClass2.verifyExecutionSummary(executionListener.summaries.get(1));
- }
+ assertThat(executionListener.summaries).hasSize(2);
+ TestClass1.verifyExecutionSummary(executionListener.summaries.get(0));
+ TestClass2.verifyExecutionSummary(executionListener.summaries.get(1));
+ }
- @Test
- void singleTestClassIsInvoked() throws Exception {
- Launcher launcher = LauncherFactory.create();
- JUnitPlatformProvider provider = new JUnitPlatformProvider(providerParametersMock(), launcher);
+ @Test
+ void singleTestClassIsInvoked() throws Exception {
+ Launcher launcher = LauncherFactory.create();
+ JUnitPlatformProvider provider = new JUnitPlatformProvider(providerParametersMock(), launcher);
- TestPlanSummaryListener executionListener = new TestPlanSummaryListener();
- launcher.registerTestExecutionListeners(executionListener);
+ TestPlanSummaryListener executionListener = new TestPlanSummaryListener();
+ launcher.registerTestExecutionListeners(executionListener);
- provider.invoke(TestClass1.class);
+ provider.invoke(TestClass1.class);
- assertThat(executionListener.summaries).hasSize(1);
- TestClass1.verifyExecutionSummary(executionListener.summaries.get(0));
- }
+ assertThat(executionListener.summaries).hasSize(1);
+ TestClass1.verifyExecutionSummary(executionListener.summaries.get(0));
+ }
- @Test
- void allDiscoveredTestsAreInvokedForNullArgument() throws Exception {
- ProviderParameters providerParameters = providerParametersMock(TestClass1.class, TestClass2.class);
- Launcher launcher = LauncherFactory.create();
- JUnitPlatformProvider provider = new JUnitPlatformProvider(providerParameters, launcher);
+ @Test
+ void allDiscoveredTestsAreInvokedForNullArgument() throws Exception {
+ ProviderParameters providerParameters = providerParametersMock(TestClass1.class, TestClass2.class);
+ Launcher launcher = LauncherFactory.create();
+ JUnitPlatformProvider provider = new JUnitPlatformProvider(providerParameters, launcher);
- TestPlanSummaryListener executionListener = new TestPlanSummaryListener();
- launcher.registerTestExecutionListeners(executionListener);
+ TestPlanSummaryListener executionListener = new TestPlanSummaryListener();
+ launcher.registerTestExecutionListeners(executionListener);
- provider.invoke(null);
+ provider.invoke(null);
- assertThat(executionListener.summaries).hasSize(2);
- TestClass1.verifyExecutionSummary(executionListener.summaries.get(0));
- TestClass2.verifyExecutionSummary(executionListener.summaries.get(1));
- }
+ assertThat(executionListener.summaries).hasSize(2);
+ TestClass1.verifyExecutionSummary(executionListener.summaries.get(0));
+ TestClass2.verifyExecutionSummary(executionListener.summaries.get(1));
+ }
- @Test
- void bothGroupsAndIncludeTagsThrowsException() {
- Map<String, String> properties = new HashMap<>();
- properties.put(JUnitPlatformProvider.INCLUDE_GROUPS, "groupOne, groupTwo");
- properties.put(JUnitPlatformProvider.INCLUDE_TAGS, "tagOne, tagTwo");
- verifyPreconditionViolationException(properties);
- }
+ @Test
+ void bothGroupsAndIncludeTagsThrowsException() {
+ Map<String, String> properties = new HashMap<>();
+ properties.put(JUnitPlatformProvider.INCLUDE_GROUPS, "groupOne, groupTwo");
+ properties.put(JUnitPlatformProvider.INCLUDE_TAGS, "tagOne, tagTwo");
+ verifyPreconditionViolationException(properties);
+ }
- @Test
- void bothExcludedGroupsAndExcludeTagsThrowsException() {
- Map<String, String> properties = new HashMap<>();
- properties.put(JUnitPlatformProvider.EXCLUDE_GROUPS, "groupOne, groupTwo");
- properties.put(JUnitPlatformProvider.EXCLUDE_TAGS, "tagOne, tagTwo");
- verifyPreconditionViolationException(properties);
- }
+ @Test
+ void bothExcludedGroupsAndExcludeTagsThrowsException() {
+ Map<String, String> properties = new HashMap<>();
+ properties.put(JUnitPlatformProvider.EXCLUDE_GROUPS, "groupOne, groupTwo");
+ properties.put(JUnitPlatformProvider.EXCLUDE_TAGS, "tagOne, tagTwo");
+ verifyPreconditionViolationException(properties);
+ }
- @Test
- void onlyGroupsIsDeclared() throws Exception {
- Map<String, String> properties = new HashMap<>();
- properties.put(JUnitPlatformProvider.INCLUDE_GROUPS, "groupOne, groupTwo");
+ @Test
+ void onlyGroupsIsDeclared() throws Exception {
+ Map<String, String> properties = new HashMap<>();
+ properties.put(JUnitPlatformProvider.INCLUDE_GROUPS, "groupOne, groupTwo");
- ProviderParameters providerParameters = providerParametersMock(TestClass1.class);
- when(providerParameters.getProviderProperties()).thenReturn(properties);
+ ProviderParameters providerParameters = providerParametersMock(TestClass1.class);
+ when(providerParameters.getProviderProperties()).thenReturn(properties);
- JUnitPlatformProvider provider = new JUnitPlatformProvider(providerParameters);
+ JUnitPlatformProvider provider = new JUnitPlatformProvider(providerParameters);
- assertEquals(1, provider.includeAndExcludeFilters.length);
- }
+ assertEquals(1, provider.includeAndExcludeFilters.length);
+ }
- @Test
- void onlyExcludeTagsIsDeclared() throws Exception {
- Map<String, String> properties = new HashMap<>();
- properties.put(JUnitPlatformProvider.EXCLUDE_TAGS, "tagOne, tagTwo");
+ @Test
+ void onlyExcludeTagsIsDeclared() throws Exception {
+ Map<String, String> properties = new HashMap<>();
+ properties.put(JUnitPlatformProvider.EXCLUDE_TAGS, "tagOne, tagTwo");
- ProviderParameters providerParameters = providerParametersMock(TestClass1.class);
- when(providerParameters.getProviderProperties()).thenReturn(properties);
+ ProviderParameters providerParameters = providerParametersMock(TestClass1.class);
+ when(providerParameters.getProviderProperties()).thenReturn(properties);
- JUnitPlatformProvider provider = new JUnitPlatformProvider(providerParameters);
+ JUnitPlatformProvider provider = new JUnitPlatformProvider(providerParameters);
- assertEquals(1, provider.includeAndExcludeFilters.length);
- }
+ assertEquals(1, provider.includeAndExcludeFilters.length);
+ }
- @Test
- void bothIncludeAndExcludeAreAllowed() throws Exception {
- Map<String, String> properties = new HashMap<>();
- properties.put(JUnitPlatformProvider.INCLUDE_TAGS, "tagOne, tagTwo");
- properties.put(JUnitPlatformProvider.EXCLUDE_TAGS, "tagThree, tagFour");
+ @Test
+ void bothIncludeAndExcludeAreAllowed() throws Exception {
+ Map<String, String> properties = new HashMap<>();
+ properties.put(JUnitPlatformProvider.INCLUDE_TAGS, "tagOne, tagTwo");
+ properties.put(JUnitPlatformProvider.EXCLUDE_TAGS, "tagThree, tagFour");
- ProviderParameters providerParameters = providerParametersMock(TestClass1.class);
- when(providerParameters.getProviderProperties()).thenReturn(properties);
+ ProviderParameters providerParameters = providerParametersMock(TestClass1.class);
+ when(providerParameters.getProviderProperties()).thenReturn(properties);
- JUnitPlatformProvider provider = new JUnitPlatformProvider(providerParameters);
+ JUnitPlatformProvider provider = new JUnitPlatformProvider(providerParameters);
- assertEquals(2, provider.includeAndExcludeFilters.length);
- }
+ assertEquals(2, provider.includeAndExcludeFilters.length);
+ }
- @Test
- void noFiltersAreCreatedIfNoPropertiesAreDeclared() throws Exception {
- ProviderParameters providerParameters = providerParametersMock(TestClass1.class);
+ @Test
+ void noFiltersAreCreatedIfNoPropertiesAreDeclared() throws Exception {
+ ProviderParameters providerParameters = providerParametersMock(TestClass1.class);
- JUnitPlatformProvider provider = new JUnitPlatformProvider(providerParameters);
+ JUnitPlatformProvider provider = new JUnitPlatformProvider(providerParameters);
- assertEquals(0, provider.includeAndExcludeFilters.length);
- }
+ assertEquals(0, provider.includeAndExcludeFilters.length);
+ }
- private void verifyPreconditionViolationException(Map<String, String> properties) {
- ProviderParameters providerParameters = providerParametersMock(TestClass1.class);
- when(providerParameters.getProviderProperties()).thenReturn(properties);
-
- Throwable throwable = assertThrows(PreconditionViolationException.class, () -> {
- new JUnitPlatformProvider(providerParameters);
- });
-
- assertEquals(JUnitPlatformProvider.EXCEPTION_MESSAGE_BOTH_NOT_ALLOWED, throwable.getMessage());
- }
-
- private static ProviderParameters providerParametersMock(Class<?>... testClasses) {
- TestsToRun testsToRun = newTestsToRun(testClasses);
-
- ScanResult scanResult = mock(ScanResult.class);
- when(scanResult.applyFilter(any(), any())).thenReturn(testsToRun);
-
- RunOrderCalculator runOrderCalculator = mock(RunOrderCalculator.class);
- when(runOrderCalculator.orderTestClasses(any())).thenReturn(testsToRun);
-
- ReporterFactory reporterFactory = mock(ReporterFactory.class);
- RunListener runListener = mock(RunListener.class);
- when(reporterFactory.createReporter()).thenReturn(runListener);
-
- ProviderParameters providerParameters = mock(ProviderParameters.class);
- when(providerParameters.getScanResult()).thenReturn(scanResult);
- when(providerParameters.getRunOrderCalculator()).thenReturn(runOrderCalculator);
- when(providerParameters.getReporterFactory()).thenReturn(reporterFactory);
-
- return providerParameters;
- }
-
- private static TestsToRun newTestsToRun(Class<?>... testClasses) {
- List<Class<?>> classesList = Arrays.asList(testClasses);
- return new TestsToRun(new LinkedHashSet<>(classesList));
- }
-
- private class TestPlanSummaryListener extends SummaryGeneratingListener {
-
- final List<TestExecutionSummary> summaries = new ArrayList<>();
+ private void verifyPreconditionViolationException(Map<String, String> properties) {
+ ProviderParameters providerParameters = providerParametersMock(TestClass1.class);
+ when(providerParameters.getProviderProperties()).thenReturn(properties);
+
+ Throwable throwable = assertThrows(PreconditionViolationException.class, () -> {
+ new JUnitPlatformProvider(providerParameters);
+ });
+
+ assertEquals(JUnitPlatformProvider.EXCEPTION_MESSAGE_BOTH_NOT_ALLOWED, throwable.getMessage());
+ }
+
+ private static ProviderParameters providerParametersMock(Class<?>... testClasses) {
+ TestsToRun testsToRun = newTestsToRun(testClasses);
+
+ ScanResult scanResult = mock(ScanResult.class);
+ when(scanResult.applyFilter(any(), any())).thenReturn(testsToRun);
+
+ RunOrderCalculator runOrderCalculator = mock(RunOrderCalculator.class);
+ when(runOrderCalculator.orderTestClasses(any())).thenReturn(testsToRun);
+
+ ReporterFactory reporterFactory = mock(ReporterFactory.class);
+ RunListener runListener = mock(RunListener.class);
+ when(reporterFactory.createReporter()).thenReturn(runListener);
+
+ ProviderParameters providerParameters = mock(ProviderParameters.class);
+ when(providerParameters.getScanResult()).thenReturn(scanResult);
+ when(providerParameters.getRunOrderCalculator()).thenReturn(runOrderCalculator);
+ when(providerParameters.getReporterFactory()).thenReturn(reporterFactory);
+
+ return providerParameters;
+ }
+
+ private static TestsToRun newTestsToRun(Class<?>... testClasses) {
+ List<Class<?>> classesList = Arrays.asList(testClasses);
+ return new TestsToRun(new LinkedHashSet<>(classesList));
+ }
+
+ private class TestPlanSummaryListener extends SummaryGeneratingListener {
+
+ final List<TestExecutionSummary> summaries = new ArrayList<>();
- @Override
- public void testPlanExecutionFinished(TestPlan testPlan) {
- super.testPlanExecutionFinished(testPlan);
- summaries.add(getSummary());
- }
- }
+ @Override
+ public void testPlanExecutionFinished(TestPlan testPlan) {
+ super.testPlanExecutionFinished(testPlan);
+ summaries.add(getSummary());
+ }
+ }
- private static class TestClass1 {
+ private static class TestClass1 {
- @Test
- void test1() {
- }
+ @Test
+ void test1() {
+ }
- @Test
- void test2() {
- }
+ @Test
+ void test2() {
+ }
- @Disabled
- @Test
- void test3() {
- }
+ @Disabled
+ @Test
+ void test3() {
+ }
- @Test
- void test4() {
- throw new RuntimeException();
- }
+ @Test
+ void test4() {
+ throw new RuntimeException();
+ }
- static void verifyExecutionSummary(TestExecutionSummary summary) {
- assertEquals(4, summary.getTestsFoundCount());
- assertEquals(3, summary.getTestsStartedCount());
- assertEquals(2, summary.getTestsSucceededCount());
- assertEquals(1, summary.getTestsSkippedCount());
- assertEquals(0, summary.getTestsAbortedCount());
- assertEquals(1, summary.getTestsFailedCount());
- }
- }
-
- private static class TestClass2 {
-
- @Test
- void test1() {
- }
-
- @Test
- void test2() {
- throw new RuntimeException();
- }
-
- @Test
- void test3() {
- assumeTrue(false);
- }
-
- static void verifyExecutionSummary(TestExecutionSummary summary) {
- assertEquals(3, summary.getTestsFoundCount());
- assertEquals(3, summary.getTestsStartedCount());
- assertEquals(1, summary.getTestsSucceededCount());
- assertEquals(0, summary.getTestsSkippedCount());
- assertEquals(1, summary.getTestsAbortedCount());
- assertEquals(1, summary.getTestsFailedCount());
- }
- }
+ static void verifyExecutionSummary(TestExecutionSummary summary) {
+ assertEquals(4, summary.getTestsFoundCount());
+ assertEquals(3, summary.getTestsStartedCount());
+ assertEquals(2, summary.getTestsSucceededCount());
+ assertEquals(1, summary.getTestsSkippedCount());
+ assertEquals(0, summary.getTestsAbortedCount());
+ assertEquals(1, summary.getTestsFailedCount());
+ }
+ }
+
+ private static class TestClass2 {
+
+ @Test
+ void test1() {
+ }
+
+ @Test
+ void test2() {
+ throw new RuntimeException();
+ }
+
+ @Test
+ void test3() {
+ assumeTrue(false);
+ }
+
+ static void verifyExecutionSummary(TestExecutionSummary summary) {
+ assertEquals(3, summary.getTestsFoundCount());
+ assertEquals(3, summary.getTestsStartedCount());
+ assertEquals(1, summary.getTestsSucceededCount());
+ assertEquals(0, summary.getTestsSkippedCount());
+ assertEquals(1, summary.getTestsAbortedCount());
+ assertEquals(1, summary.getTestsFailedCount());
+ }
+ }
}
http://git-wip-us.apache.org/repos/asf/maven-surefire/blob/68722a85/surefire-providers/surefire-junit5/src/test/java/org/junit/platform/surefire/provider/RunListenerAdapterTests.java
----------------------------------------------------------------------
diff --git a/surefire-providers/surefire-junit5/src/test/java/org/junit/platform/surefire/provider/RunListenerAdapterTests.java b/surefire-providers/surefire-junit5/src/test/java/org/junit/platform/surefire/provider/RunListenerAdapterTests.java
index c343ff6..3b8f34c 100644
--- a/surefire-providers/surefire-junit5/src/test/java/org/junit/platform/surefire/provider/RunListenerAdapterTests.java
+++ b/surefire-providers/surefire-junit5/src/test/java/org/junit/platform/surefire/provider/RunListenerAdapterTests.java
@@ -49,171 +49,171 @@ import org.mockito.ArgumentCaptor;
*/
class RunListenerAdapterTests {
- private RunListener listener;
- private RunListenerAdapter adapter;
-
- @BeforeEach
- public void setUp() {
- listener = mock(RunListener.class);
- adapter = new RunListenerAdapter(listener);
- }
-
- @Test
- void notifiedWithCorrectNamesWhenMethodExecutionStarted() throws Exception {
- ArgumentCaptor<ReportEntry> entryCaptor = ArgumentCaptor.forClass(ReportEntry.class);
-
- adapter.executionStarted(newMethodIdentifier());
- verify(listener).testStarting(entryCaptor.capture());
-
- ReportEntry entry = entryCaptor.getValue();
- assertEquals(MY_TEST_METHOD_NAME + "()", entry.getName());
- assertEquals(MyTestClass.class.getName(), entry.getSourceName());
- assertNotNull(entry.getStackTraceWriter());
- }
-
- @Test
- void notNotifiedWhenClassExecutionStarted() throws Exception {
- adapter.executionStarted(newClassIdentifier());
- verify(listener, never()).testStarting(any());
- }
-
- @Test
- void notNotifiedWhenEngineExecutionStarted() throws Exception {
- adapter.executionStarted(newEngineIdentifier());
- verify(listener, never()).testStarting(any());
- }
-
- @Test
- void notifiedWhenMethodExecutionSkipped() throws Exception {
- adapter.executionSkipped(newMethodIdentifier(), "test");
- verify(listener).testSkipped(any());
- }
-
- @Test
- void notifiedWithCorrectNamesWhenClassExecutionSkipped() throws Exception {
- ArgumentCaptor<ReportEntry> entryCaptor = ArgumentCaptor.forClass(ReportEntry.class);
-
- adapter.executionSkipped(newClassIdentifier(), "test");
- verify(listener).testSkipped(entryCaptor.capture());
-
- ReportEntry entry = entryCaptor.getValue();
- assertTrue(MyTestClass.class.getTypeName().contains(entry.getName()));
- assertEquals(MyTestClass.class.getName(), entry.getSourceName());
- }
-
- @Test
- void notifiedWhenEngineExecutionSkipped() throws Exception {
- adapter.executionSkipped(newEngineIdentifier(), "test");
- verify(listener).testSkipped(any());
- }
-
- @Test
- void notifiedWhenMethodExecutionAborted() throws Exception {
- adapter.executionFinished(newMethodIdentifier(), TestExecutionResult.aborted(null));
- verify(listener).testAssumptionFailure(any());
- }
-
- @Test
- void notifiedWhenClassExecutionAborted() throws Exception {
- adapter.executionFinished(newClassIdentifier(), TestExecutionResult.aborted(null));
- verify(listener).testAssumptionFailure(any());
- }
-
- @Test
- void notifiedWhenMethodExecutionFailed() throws Exception {
- adapter.executionFinished(newMethodIdentifier(), TestExecutionResult.failed(new RuntimeException()));
- verify(listener).testFailed(any());
- }
-
- @Test
- void notifiedWithCorrectNamesWhenClassExecutionFailed() throws Exception {
- ArgumentCaptor<ReportEntry> entryCaptor = ArgumentCaptor.forClass(ReportEntry.class);
-
- adapter.executionFinished(newClassIdentifier(), TestExecutionResult.failed(new RuntimeException()));
- verify(listener).testFailed(entryCaptor.capture());
-
- ReportEntry entry = entryCaptor.getValue();
- assertEquals(MyTestClass.class.getName(), entry.getSourceName());
- assertNotNull(entry.getStackTraceWriter());
- }
-
- @Test
- void notifiedWhenMethodExecutionSucceeded() throws Exception {
- adapter.executionFinished(newMethodIdentifier(), TestExecutionResult.successful());
- verify(listener).testSucceeded(any());
- }
-
- @Test
- void notNotifiedWhenClassExecutionSucceeded() throws Exception {
- adapter.executionFinished(newClassIdentifier(), TestExecutionResult.successful());
- verify(listener, never()).testSucceeded(any());
- }
-
- @Test
- void notifiedWithParentDisplayNameWhenTestClassUnknown() throws Exception {
- // Set up a test plan
- TestPlan plan = TestPlan.from(Collections.singletonList(new EngineDescriptor(newId(), "Luke's Plan")));
- adapter.testPlanExecutionStarted(plan);
-
- // Use the test plan to set up child with parent.
- final String parentDisplay = "I am your father";
- TestIdentifier child = newSourcelessIdentifierWithParent(plan, parentDisplay);
- adapter.executionStarted(child);
-
- // Check that the adapter has informed Surefire that the test has been invoked,
- // with the parent name as source (since the test case itself had no source).
- ArgumentCaptor<ReportEntry> entryCaptor = ArgumentCaptor.forClass(ReportEntry.class);
- verify(listener).testStarting(entryCaptor.capture());
- assertEquals(parentDisplay, entryCaptor.getValue().getSourceName());
- }
-
- private static TestIdentifier newMethodIdentifier() throws Exception {
- TestDescriptor testDescriptor = new MethodTestDescriptor(newId(), MyTestClass.class,
- MyTestClass.class.getDeclaredMethod(MY_TEST_METHOD_NAME));
- return TestIdentifier.from(testDescriptor);
- }
-
- private static TestIdentifier newClassIdentifier() {
- TestDescriptor testDescriptor = new ClassTestDescriptor(newId(), MyTestClass.class);
- return TestIdentifier.from(testDescriptor);
- }
-
- private static TestIdentifier newSourcelessIdentifierWithParent(TestPlan testPlan, String parentDisplay) {
- // A parent test identifier with a name.
- TestDescriptor parent = mock(TestDescriptor.class);
- when(parent.getUniqueId()).thenReturn(newId());
- when(parent.getDisplayName()).thenReturn(parentDisplay);
- TestIdentifier parentId = TestIdentifier.from(parent);
-
- // The (child) test case that is to be executed as part of a test plan.
- TestDescriptor child = mock(TestDescriptor.class);
- when(child.getUniqueId()).thenReturn(newId());
- when(child.isTest()).thenReturn(true);
-
- // Ensure the child source is null yet that there is a parent -- the special case to be tested.
- when(child.getSource()).thenReturn(Optional.empty());
- when(child.getParent()).thenReturn(Optional.of(parent));
- TestIdentifier childId = TestIdentifier.from(child);
-
- testPlan.add(childId);
- testPlan.add(parentId);
-
- return childId;
- }
-
- private static TestIdentifier newEngineIdentifier() {
- TestDescriptor testDescriptor = new EngineDescriptor(newId(), "engine");
- return TestIdentifier.from(testDescriptor);
- }
-
- private static UniqueId newId() {
- return UniqueId.forEngine("engine");
- }
-
- private static final String MY_TEST_METHOD_NAME = "myTestMethod";
- private static class MyTestClass {
- @Test
- void myTestMethod() {
- }
- }
+ private RunListener listener;
+ private RunListenerAdapter adapter;
+
+ @BeforeEach
+ public void setUp() {
+ listener = mock(RunListener.class);
+ adapter = new RunListenerAdapter(listener);
+ }
+
+ @Test
+ void notifiedWithCorrectNamesWhenMethodExecutionStarted() throws Exception {
+ ArgumentCaptor<ReportEntry> entryCaptor = ArgumentCaptor.forClass(ReportEntry.class);
+
+ adapter.executionStarted(newMethodIdentifier());
+ verify(listener).testStarting(entryCaptor.capture());
+
+ ReportEntry entry = entryCaptor.getValue();
+ assertEquals(MY_TEST_METHOD_NAME + "()", entry.getName());
+ assertEquals(MyTestClass.class.getName(), entry.getSourceName());
+ assertNotNull(entry.getStackTraceWriter());
+ }
+
+ @Test
+ void notNotifiedWhenClassExecutionStarted() throws Exception {
+ adapter.executionStarted(newClassIdentifier());
+ verify(listener, never()).testStarting(any());
+ }
+
+ @Test
+ void notNotifiedWhenEngineExecutionStarted() throws Exception {
+ adapter.executionStarted(newEngineIdentifier());
+ verify(listener, never()).testStarting(any());
+ }
+
+ @Test
+ void notifiedWhenMethodExecutionSkipped() throws Exception {
+ adapter.executionSkipped(newMethodIdentifier(), "test");
+ verify(listener).testSkipped(any());
+ }
+
+ @Test
+ void notifiedWithCorrectNamesWhenClassExecutionSkipped() throws Exception {
+ ArgumentCaptor<ReportEntry> entryCaptor = ArgumentCaptor.forClass(ReportEntry.class);
+
+ adapter.executionSkipped(newClassIdentifier(), "test");
+ verify(listener).testSkipped(entryCaptor.capture());
+
+ ReportEntry entry = entryCaptor.getValue();
+ assertTrue(MyTestClass.class.getTypeName().contains(entry.getName()));
+ assertEquals(MyTestClass.class.getName(), entry.getSourceName());
+ }
+
+ @Test
+ void notifiedWhenEngineExecutionSkipped() throws Exception {
+ adapter.executionSkipped(newEngineIdentifier(), "test");
+ verify(listener).testSkipped(any());
+ }
+
+ @Test
+ void notifiedWhenMethodExecutionAborted() throws Exception {
+ adapter.executionFinished(newMethodIdentifier(), TestExecutionResult.aborted(null));
+ verify(listener).testAssumptionFailure(any());
+ }
+
+ @Test
+ void notifiedWhenClassExecutionAborted() throws Exception {
+ adapter.executionFinished(newClassIdentifier(), TestExecutionResult.aborted(null));
+ verify(listener).testAssumptionFailure(any());
+ }
+
+ @Test
+ void notifiedWhenMethodExecutionFailed() throws Exception {
+ adapter.executionFinished(newMethodIdentifier(), TestExecutionResult.failed(new RuntimeException()));
+ verify(listener).testFailed(any());
+ }
+
+ @Test
+ void notifiedWithCorrectNamesWhenClassExecutionFailed() throws Exception {
+ ArgumentCaptor<ReportEntry> entryCaptor = ArgumentCaptor.forClass(ReportEntry.class);
+
+ adapter.executionFinished(newClassIdentifier(), TestExecutionResult.failed(new RuntimeException()));
+ verify(listener).testFailed(entryCaptor.capture());
+
+ ReportEntry entry = entryCaptor.getValue();
+ assertEquals(MyTestClass.class.getName(), entry.getSourceName());
+ assertNotNull(entry.getStackTraceWriter());
+ }
+
+ @Test
+ void notifiedWhenMethodExecutionSucceeded() throws Exception {
+ adapter.executionFinished(newMethodIdentifier(), TestExecutionResult.successful());
+ verify(listener).testSucceeded(any());
+ }
+
+ @Test
+ void notNotifiedWhenClassExecutionSucceeded() throws Exception {
+ adapter.executionFinished(newClassIdentifier(), TestExecutionResult.successful());
+ verify(listener, never()).testSucceeded(any());
+ }
+
+ @Test
+ void notifiedWithParentDisplayNameWhenTestClassUnknown() throws Exception {
+ // Set up a test plan
+ TestPlan plan = TestPlan.from(Collections.singletonList(new EngineDescriptor(newId(), "Luke's Plan")));
+ adapter.testPlanExecutionStarted(plan);
+
+ // Use the test plan to set up child with parent.
+ final String parentDisplay = "I am your father";
+ TestIdentifier child = newSourcelessIdentifierWithParent(plan, parentDisplay);
+ adapter.executionStarted(child);
+
+ // Check that the adapter has informed Surefire that the test has been invoked,
+ // with the parent name as source (since the test case itself had no source).
+ ArgumentCaptor<ReportEntry> entryCaptor = ArgumentCaptor.forClass(ReportEntry.class);
+ verify(listener).testStarting(entryCaptor.capture());
+ assertEquals(parentDisplay, entryCaptor.getValue().getSourceName());
+ }
+
+ private static TestIdentifier newMethodIdentifier() throws Exception {
+ TestDescriptor testDescriptor = new MethodTestDescriptor(newId(), MyTestClass.class,
+ MyTestClass.class.getDeclaredMethod(MY_TEST_METHOD_NAME));
+ return TestIdentifier.from(testDescriptor);
+ }
+
+ private static TestIdentifier newClassIdentifier() {
+ TestDescriptor testDescriptor = new ClassTestDescriptor(newId(), MyTestClass.class);
+ return TestIdentifier.from(testDescriptor);
+ }
+
+ private static TestIdentifier newSourcelessIdentifierWithParent(TestPlan testPlan, String parentDisplay) {
+ // A parent test identifier with a name.
+ TestDescriptor parent = mock(TestDescriptor.class);
+ when(parent.getUniqueId()).thenReturn(newId());
+ when(parent.getDisplayName()).thenReturn(parentDisplay);
+ TestIdentifier parentId = TestIdentifier.from(parent);
+
+ // The (child) test case that is to be executed as part of a test plan.
+ TestDescriptor child = mock(TestDescriptor.class);
+ when(child.getUniqueId()).thenReturn(newId());
+ when(child.isTest()).thenReturn(true);
+
+ // Ensure the child source is null yet that there is a parent -- the special case to be tested.
+ when(child.getSource()).thenReturn(Optional.empty());
+ when(child.getParent()).thenReturn(Optional.of(parent));
+ TestIdentifier childId = TestIdentifier.from(child);
+
+ testPlan.add(childId);
+ testPlan.add(parentId);
+
+ return childId;
+ }
+
+ private static TestIdentifier newEngineIdentifier() {
+ TestDescriptor testDescriptor = new EngineDescriptor(newId(), "engine");
+ return TestIdentifier.from(testDescriptor);
+ }
+
+ private static UniqueId newId() {
+ return UniqueId.forEngine("engine");
+ }
+
+ private static final String MY_TEST_METHOD_NAME = "myTestMethod";
+ private static class MyTestClass {
+ @Test
+ void myTestMethod() {
+ }
+ }
}
http://git-wip-us.apache.org/repos/asf/maven-surefire/blob/68722a85/surefire-providers/surefire-junit5/src/test/java/org/junit/platform/surefire/provider/TestPlanScannerFilterTests.java
----------------------------------------------------------------------
diff --git a/surefire-providers/surefire-junit5/src/test/java/org/junit/platform/surefire/provider/TestPlanScannerFilterTests.java b/surefire-providers/surefire-junit5/src/test/java/org/junit/platform/surefire/provider/TestPlanScannerFilterTests.java
index bd48d66..37e6b7f 100644
--- a/surefire-providers/surefire-junit5/src/test/java/org/junit/platform/surefire/provider/TestPlanScannerFilterTests.java
+++ b/surefire-providers/surefire-junit5/src/test/java/org/junit/platform/surefire/provider/TestPlanScannerFilterTests.java
@@ -36,122 +36,122 @@ import org.junit.platform.launcher.core.LauncherFactory;
*/
public class TestPlanScannerFilterTests {
- @Test
- void emptyClassAccepted() {
- assertTrue(newFilter().accept(EmptyClass.class), "accepts empty class because it is a container");
- }
-
- @Test
- void classWithNoTestMethodsIsAccepted() {
- assertTrue(newFilter().accept(ClassWithMethods.class),
- "accepts class with no @Test methods because it is a container");
- }
+ @Test
+ void emptyClassAccepted() {
+ assertTrue(newFilter().accept(EmptyClass.class), "accepts empty class because it is a container");
+ }
+
+ @Test
+ void classWithNoTestMethodsIsAccepted() {
+ assertTrue(newFilter().accept(ClassWithMethods.class),
+ "accepts class with no @Test methods because it is a container");
+ }
- @Test
- void classWithTestMethodsIsAccepted() {
- assertTrue(newFilter().accept(ClassWithTestMethods.class));
- }
-
- @Test
- void classWithNestedTestClassIsAccepted() {
- assertTrue(newFilter().accept(ClassWithNestedTestClass.class));
- }
-
- @Test
- void classWithDeeplyNestedTestClassIsAccepted() {
- assertTrue(newFilter().accept(ClassWithDeeplyNestedTestClass.class));
- }
-
- @Test
- void classWithTestFactoryIsAccepted() {
- assertTrue(newFilter().accept(ClassWithTestFactory.class));
- }
-
- @Test
- void classWithNestedTestFactoryIsAccepted() {
- assertTrue(newFilter().accept(ClassWithNestedTestFactory.class));
- }
-
- private TestPlanScannerFilter newFilter() {
- return new TestPlanScannerFilter(LauncherFactory.create(), new Filter<?>[0]);
- }
-
- private static class EmptyClass {
- }
-
- @SuppressWarnings("unused")
- private static class ClassWithMethods {
-
- void method1() {
- }
-
- void method2() {
- }
- }
-
- private static class ClassWithTestMethods {
-
- @Test
- void test1() {
- }
-
- @Test
- public void test2() {
- }
- }
-
- private static class ClassWithNestedTestClass {
-
- @SuppressWarnings("unused")
- void method() {
- }
-
- @Nested
- class TestClass {
-
- @Test
- void test1() {
- }
- }
- }
-
- private static class ClassWithDeeplyNestedTestClass {
-
- @Nested
- class Level1 {
-
- @Nested
- class Level2 {
-
- @Nested
- class TestClass {
-
- @Test
- void test1() {
- }
- }
- }
- }
- }
-
- private static class ClassWithTestFactory {
-
- @TestFactory
- Stream<DynamicTest> tests() {
- return Stream.empty();
- }
- }
-
- private static class ClassWithNestedTestFactory {
+ @Test
+ void classWithTestMethodsIsAccepted() {
+ assertTrue(newFilter().accept(ClassWithTestMethods.class));
+ }
+
+ @Test
+ void classWithNestedTestClassIsAccepted() {
+ assertTrue(newFilter().accept(ClassWithNestedTestClass.class));
+ }
+
+ @Test
+ void classWithDeeplyNestedTestClassIsAccepted() {
+ assertTrue(newFilter().accept(ClassWithDeeplyNestedTestClass.class));
+ }
+
+ @Test
+ void classWithTestFactoryIsAccepted() {
+ assertTrue(newFilter().accept(ClassWithTestFactory.class));
+ }
+
+ @Test
+ void classWithNestedTestFactoryIsAccepted() {
+ assertTrue(newFilter().accept(ClassWithNestedTestFactory.class));
+ }
+
+ private TestPlanScannerFilter newFilter() {
+ return new TestPlanScannerFilter(LauncherFactory.create(), new Filter<?>[0]);
+ }
+
+ private static class EmptyClass {
+ }
+
+ @SuppressWarnings("unused")
+ private static class ClassWithMethods {
+
+ void method1() {
+ }
+
+ void method2() {
+ }
+ }
+
+ private static class ClassWithTestMethods {
+
+ @Test
+ void test1() {
+ }
+
+ @Test
+ public void test2() {
+ }
+ }
+
+ private static class ClassWithNestedTestClass {
+
+ @SuppressWarnings("unused")
+ void method() {
+ }
+
+ @Nested
+ class TestClass {
+
+ @Test
+ void test1() {
+ }
+ }
+ }
+
+ private static class ClassWithDeeplyNestedTestClass {
+
+ @Nested
+ class Level1 {
+
+ @Nested
+ class Level2 {
+
+ @Nested
+ class TestClass {
+
+ @Test
+ void test1() {
+ }
+ }
+ }
+ }
+ }
+
+ private static class ClassWithTestFactory {
+
+ @TestFactory
+ Stream<DynamicTest> tests() {
+ return Stream.empty();
+ }
+ }
+
+ private static class ClassWithNestedTestFactory {
- @Nested
- class TestClass {
+ @Nested
+ class TestClass {
- @TestFactory
- List<DynamicTest> tests() {
- return emptyList();
- }
- }
- }
+ @TestFactory
+ List<DynamicTest> tests() {
+ return emptyList();
+ }
+ }
+ }
}
http://git-wip-us.apache.org/repos/asf/maven-surefire/blob/68722a85/surefire-providers/surefire-junit5/src/test/resources/log4j2-test.xml
----------------------------------------------------------------------
diff --git a/surefire-providers/surefire-junit5/src/test/resources/log4j2-test.xml b/surefire-providers/surefire-junit5/src/test/resources/log4j2-test.xml
index 27875d9..c1b215e 100644
--- a/surefire-providers/surefire-junit5/src/test/resources/log4j2-test.xml
+++ b/surefire-providers/surefire-junit5/src/test/resources/log4j2-test.xml
@@ -1,15 +1,15 @@
<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="WARN">
- <Appenders>
- <Console name="Console" target="SYSTEM_OUT">
- <PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n" />
- </Console>
- </Appenders>
- <Loggers>
- <Logger name="org.junit" level="warn" />
- <Logger name="org.junit.platform.surefire" level="error" />
- <Root level="error">
- <AppenderRef ref="Console" />
- </Root>
- </Loggers>
-</Configuration>
\ No newline at end of file
+ <Appenders>
+ <Console name="Console" target="SYSTEM_OUT">
+ <PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n" />
+ </Console>
+ </Appenders>
+ <Loggers>
+ <Logger name="org.junit" level="warn" />
+ <Logger name="org.junit.platform.surefire" level="error" />
+ <Root level="error">
+ <AppenderRef ref="Console" />
+ </Root>
+ </Loggers>
+</Configuration>