From 3d9070021cf8649a4a06c5afe99f67c05e63c98a Mon Sep 17 00:00:00 2001 From: phoenix384 Date: Thu, 26 Jul 2018 17:29:01 +0200 Subject: [PATCH 01/21] Update TestExecutionExceptionHandler.java --- .../api/extension/TestExecutionExceptionHandler.java | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/junit-jupiter-api/src/main/java/org/junit/jupiter/api/extension/TestExecutionExceptionHandler.java b/junit-jupiter-api/src/main/java/org/junit/jupiter/api/extension/TestExecutionExceptionHandler.java index 318356df327c..511a2a3f9142 100644 --- a/junit-jupiter-api/src/main/java/org/junit/jupiter/api/extension/TestExecutionExceptionHandler.java +++ b/junit-jupiter-api/src/main/java/org/junit/jupiter/api/extension/TestExecutionExceptionHandler.java @@ -61,4 +61,11 @@ public interface TestExecutionExceptionHandler extends Extension { */ void handleTestExecutionException(ExtensionContext context, Throwable throwable) throws Throwable; + default void handleExceptionInBeforeEachMethod(ExtensionContext context, Throwable throwable) throws Throwable { + throw throwable; + } + + default void handleExceptionInAfterEachMethod(ExtensionContext context, Throwable throwable) throws Throwable { + throw throwable; + } } From 8a432dbcf20e898a80f15ecd1c277c4d3acbfabd Mon Sep 17 00:00:00 2001 From: phoenix384 Date: Thu, 26 Jul 2018 17:35:00 +0200 Subject: [PATCH 02/21] Update TestMethodTestDescriptor.java --- .../descriptor/TestMethodTestDescriptor.java | 52 ++++++++++++------- 1 file changed, 33 insertions(+), 19 deletions(-) diff --git a/junit-jupiter-engine/src/main/java/org/junit/jupiter/engine/descriptor/TestMethodTestDescriptor.java b/junit-jupiter-engine/src/main/java/org/junit/jupiter/engine/descriptor/TestMethodTestDescriptor.java index 0ee14ece676b..b70f3ccef08d 100644 --- a/junit-jupiter-engine/src/main/java/org/junit/jupiter/engine/descriptor/TestMethodTestDescriptor.java +++ b/junit-jupiter-engine/src/main/java/org/junit/jupiter/engine/descriptor/TestMethodTestDescriptor.java @@ -133,7 +133,14 @@ private void invokeBeforeEachCallbacks(JupiterEngineExecutionContext context) { private void invokeBeforeEachMethods(JupiterEngineExecutionContext context) { ExtensionRegistry registry = context.getExtensionRegistry(); invokeBeforeMethodsOrCallbacksUntilExceptionOccurs(context, - ((extensionContext, adapter) -> () -> adapter.invokeBeforeEachMethod(extensionContext, registry)), + ((extensionContext, adapter) -> () -> { + try { + adapter.invokeBeforeEachMethod(extensionContext, registry); + } catch (Throwable throwable) { + invokeTestExecutionExceptionHandlers(context.getExtensionRegistry(), throwable, + ((ex, handler) -> () -> handler.handleExceptionInBeforeEachMethod(extensionContext, ex))); + } + }), BeforeEachMethodAdapter.class); } @@ -163,40 +170,40 @@ private void invokeBeforeMethodsOrCallbacksUntilExceptionO protected void invokeTestMethod(JupiterEngineExecutionContext context, DynamicTestExecutor dynamicTestExecutor) { ExtensionContext extensionContext = context.getExtensionContext(); ThrowableCollector throwableCollector = context.getThrowableCollector(); - + throwableCollector.execute(() -> { try { Method testMethod = getTestMethod(); Object instance = extensionContext.getRequiredTestInstance(); executableInvoker.invoke(testMethod, instance, extensionContext, context.getExtensionRegistry()); - } - catch (Throwable throwable) { - invokeTestExecutionExceptionHandlers(context.getExtensionRegistry(), extensionContext, throwable); + } catch (Throwable throwable) { + invokeTestExecutionExceptionHandlers(context.getExtensionRegistry(), throwable, + ((ex, handler) -> () -> handler.handleTestExecutionException(extensionContext, ex))); } }); } - - private void invokeTestExecutionExceptionHandlers(ExtensionRegistry registry, ExtensionContext context, - Throwable ex) { - + + private void invokeTestExecutionExceptionHandlers(ExtensionRegistry registry, Throwable ex, + BiFunction generator) { + invokeTestExecutionExceptionHandlers(ex, registry.getReversedExtensions(TestExecutionExceptionHandler.class), - context); + generator); } - + private void invokeTestExecutionExceptionHandlers(Throwable ex, List handlers, - ExtensionContext context) { - + BiFunction generator) { + // No handlers left? if (handlers.isEmpty()) { ExceptionUtils.throwAsUncheckedException(ex); } - + try { // Invoke next available handler - handlers.remove(0).handleTestExecutionException(context, ex); - } - catch (Throwable t) { - invokeTestExecutionExceptionHandlers(t, handlers, context); + Executable executable = generator.apply(ex, handlers.remove(0)); + executable.execute(); + } catch (Throwable t) { + invokeTestExecutionExceptionHandlers(t, handlers, generator); } } @@ -209,7 +216,14 @@ private void invokeAfterTestExecutionCallbacks(JupiterEngineExecutionContext con private void invokeAfterEachMethods(JupiterEngineExecutionContext context) { ExtensionRegistry registry = context.getExtensionRegistry(); invokeAllAfterMethodsOrCallbacks(context, - ((extensionContext, adapter) -> () -> adapter.invokeAfterEachMethod(extensionContext, registry)), + ((extensionContext, adapter) -> () -> { + try { + adapter.invokeAfterEachMethod(extensionContext, registry); + } catch (Throwable throwable) { + invokeTestExecutionExceptionHandlers(context.getExtensionRegistry(), throwable, + ((ex, handler) -> () -> handler.handleExceptionInAfterEachMethod(extensionContext, ex))); + } + }), AfterEachMethodAdapter.class); } From 0971059aecae091318968802a3dfd95ddc3eefb0 Mon Sep 17 00:00:00 2001 From: phoenix384 Date: Thu, 26 Jul 2018 17:37:37 +0200 Subject: [PATCH 03/21] Update TestMethodTestDescriptor.java --- .../engine/descriptor/TestMethodTestDescriptor.java | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/junit-jupiter-engine/src/main/java/org/junit/jupiter/engine/descriptor/TestMethodTestDescriptor.java b/junit-jupiter-engine/src/main/java/org/junit/jupiter/engine/descriptor/TestMethodTestDescriptor.java index b70f3ccef08d..c7668d244006 100644 --- a/junit-jupiter-engine/src/main/java/org/junit/jupiter/engine/descriptor/TestMethodTestDescriptor.java +++ b/junit-jupiter-engine/src/main/java/org/junit/jupiter/engine/descriptor/TestMethodTestDescriptor.java @@ -170,7 +170,7 @@ private void invokeBeforeMethodsOrCallbacksUntilExceptionO protected void invokeTestMethod(JupiterEngineExecutionContext context, DynamicTestExecutor dynamicTestExecutor) { ExtensionContext extensionContext = context.getExtensionContext(); ThrowableCollector throwableCollector = context.getThrowableCollector(); - + throwableCollector.execute(() -> { try { Method testMethod = getTestMethod(); @@ -185,19 +185,19 @@ protected void invokeTestMethod(JupiterEngineExecutionContext context, DynamicTe private void invokeTestExecutionExceptionHandlers(ExtensionRegistry registry, Throwable ex, BiFunction generator) { - + invokeTestExecutionExceptionHandlers(ex, registry.getReversedExtensions(TestExecutionExceptionHandler.class), generator); } - + private void invokeTestExecutionExceptionHandlers(Throwable ex, List handlers, BiFunction generator) { - + // No handlers left? if (handlers.isEmpty()) { ExceptionUtils.throwAsUncheckedException(ex); } - + try { // Invoke next available handler Executable executable = generator.apply(ex, handlers.remove(0)); From 11232594c63c9a06b623e519457906c747e7de7e Mon Sep 17 00:00:00 2001 From: phoenix384 Date: Thu, 26 Jul 2018 17:38:52 +0200 Subject: [PATCH 04/21] Update TestMethodTestDescriptor.java --- .../jupiter/engine/descriptor/TestMethodTestDescriptor.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/junit-jupiter-engine/src/main/java/org/junit/jupiter/engine/descriptor/TestMethodTestDescriptor.java b/junit-jupiter-engine/src/main/java/org/junit/jupiter/engine/descriptor/TestMethodTestDescriptor.java index c7668d244006..d9535975a912 100644 --- a/junit-jupiter-engine/src/main/java/org/junit/jupiter/engine/descriptor/TestMethodTestDescriptor.java +++ b/junit-jupiter-engine/src/main/java/org/junit/jupiter/engine/descriptor/TestMethodTestDescriptor.java @@ -182,7 +182,7 @@ protected void invokeTestMethod(JupiterEngineExecutionContext context, DynamicTe } }); } - + private void invokeTestExecutionExceptionHandlers(ExtensionRegistry registry, Throwable ex, BiFunction generator) { From 5d485ea0f6d734aea4be5d15050b75abb93a2615 Mon Sep 17 00:00:00 2001 From: phoenix384 Date: Thu, 26 Jul 2018 17:39:35 +0200 Subject: [PATCH 05/21] Update TestExecutionExceptionHandler.java --- .../jupiter/api/extension/TestExecutionExceptionHandler.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/junit-jupiter-api/src/main/java/org/junit/jupiter/api/extension/TestExecutionExceptionHandler.java b/junit-jupiter-api/src/main/java/org/junit/jupiter/api/extension/TestExecutionExceptionHandler.java index 511a2a3f9142..34db9c03497c 100644 --- a/junit-jupiter-api/src/main/java/org/junit/jupiter/api/extension/TestExecutionExceptionHandler.java +++ b/junit-jupiter-api/src/main/java/org/junit/jupiter/api/extension/TestExecutionExceptionHandler.java @@ -64,7 +64,7 @@ public interface TestExecutionExceptionHandler extends Extension { default void handleExceptionInBeforeEachMethod(ExtensionContext context, Throwable throwable) throws Throwable { throw throwable; } - + default void handleExceptionInAfterEachMethod(ExtensionContext context, Throwable throwable) throws Throwable { throw throwable; } From 586f097cb2c5ab7b08045521536bb6ad70b4544e Mon Sep 17 00:00:00 2001 From: phoenix384 Date: Thu, 26 Jul 2018 17:42:46 +0200 Subject: [PATCH 06/21] Update TestMethodTestDescriptor.java --- .../engine/descriptor/TestMethodTestDescriptor.java | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/junit-jupiter-engine/src/main/java/org/junit/jupiter/engine/descriptor/TestMethodTestDescriptor.java b/junit-jupiter-engine/src/main/java/org/junit/jupiter/engine/descriptor/TestMethodTestDescriptor.java index d9535975a912..421c41d71cba 100644 --- a/junit-jupiter-engine/src/main/java/org/junit/jupiter/engine/descriptor/TestMethodTestDescriptor.java +++ b/junit-jupiter-engine/src/main/java/org/junit/jupiter/engine/descriptor/TestMethodTestDescriptor.java @@ -136,7 +136,8 @@ private void invokeBeforeEachMethods(JupiterEngineExecutionContext context) { ((extensionContext, adapter) -> () -> { try { adapter.invokeBeforeEachMethod(extensionContext, registry); - } catch (Throwable throwable) { + } + catch (Throwable throwable) { invokeTestExecutionExceptionHandlers(context.getExtensionRegistry(), throwable, ((ex, handler) -> () -> handler.handleExceptionInBeforeEachMethod(extensionContext, ex))); } @@ -176,7 +177,8 @@ protected void invokeTestMethod(JupiterEngineExecutionContext context, DynamicTe Method testMethod = getTestMethod(); Object instance = extensionContext.getRequiredTestInstance(); executableInvoker.invoke(testMethod, instance, extensionContext, context.getExtensionRegistry()); - } catch (Throwable throwable) { + } + catch (Throwable throwable) { invokeTestExecutionExceptionHandlers(context.getExtensionRegistry(), throwable, ((ex, handler) -> () -> handler.handleTestExecutionException(extensionContext, ex))); } @@ -202,7 +204,8 @@ private void invokeTestExecutionExceptionHandlers(Throwable ex, List () -> { try { adapter.invokeAfterEachMethod(extensionContext, registry); - } catch (Throwable throwable) { + } + catch (Throwable throwable) { invokeTestExecutionExceptionHandlers(context.getExtensionRegistry(), throwable, ((ex, handler) -> () -> handler.handleExceptionInAfterEachMethod(extensionContext, ex))); } From 6c50204b04caa21e19df9b642e74aabd99e8bd28 Mon Sep 17 00:00:00 2001 From: phoenix384 Date: Tue, 31 Jul 2018 12:27:21 +0200 Subject: [PATCH 07/21] Update TestMethodTestDescriptor.java --- .../engine/descriptor/TestMethodTestDescriptor.java | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/junit-jupiter-engine/src/main/java/org/junit/jupiter/engine/descriptor/TestMethodTestDescriptor.java b/junit-jupiter-engine/src/main/java/org/junit/jupiter/engine/descriptor/TestMethodTestDescriptor.java index 421c41d71cba..7d7897d2bce4 100644 --- a/junit-jupiter-engine/src/main/java/org/junit/jupiter/engine/descriptor/TestMethodTestDescriptor.java +++ b/junit-jupiter-engine/src/main/java/org/junit/jupiter/engine/descriptor/TestMethodTestDescriptor.java @@ -138,7 +138,7 @@ private void invokeBeforeEachMethods(JupiterEngineExecutionContext context) { adapter.invokeBeforeEachMethod(extensionContext, registry); } catch (Throwable throwable) { - invokeTestExecutionExceptionHandlers(context.getExtensionRegistry(), throwable, + invokeTestExecutionExceptionHandlers(throwable, registry, ((ex, handler) -> () -> handler.handleExceptionInBeforeEachMethod(extensionContext, ex))); } }), @@ -179,13 +179,13 @@ protected void invokeTestMethod(JupiterEngineExecutionContext context, DynamicTe executableInvoker.invoke(testMethod, instance, extensionContext, context.getExtensionRegistry()); } catch (Throwable throwable) { - invokeTestExecutionExceptionHandlers(context.getExtensionRegistry(), throwable, + invokeTestExecutionExceptionHandlers(throwable, context.getExtensionRegistry(), ((ex, handler) -> () -> handler.handleTestExecutionException(extensionContext, ex))); } }); } - private void invokeTestExecutionExceptionHandlers(ExtensionRegistry registry, Throwable ex, + private void invokeTestExecutionExceptionHandlers(Throwable ex, ExtensionRegistry registry, BiFunction generator) { invokeTestExecutionExceptionHandlers(ex, registry.getReversedExtensions(TestExecutionExceptionHandler.class), @@ -224,7 +224,7 @@ private void invokeAfterEachMethods(JupiterEngineExecutionContext context) { adapter.invokeAfterEachMethod(extensionContext, registry); } catch (Throwable throwable) { - invokeTestExecutionExceptionHandlers(context.getExtensionRegistry(), throwable, + invokeTestExecutionExceptionHandlers(throwable, registry, ((ex, handler) -> () -> handler.handleExceptionInAfterEachMethod(extensionContext, ex))); } }), From ae047f47dbf00cfe62545ef97424e0c86d938feb Mon Sep 17 00:00:00 2001 From: phoenix384 Date: Tue, 31 Jul 2018 12:28:31 +0200 Subject: [PATCH 08/21] Update TestExecutionExceptionHandler.java --- .../api/extension/TestExecutionExceptionHandler.java | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/junit-jupiter-api/src/main/java/org/junit/jupiter/api/extension/TestExecutionExceptionHandler.java b/junit-jupiter-api/src/main/java/org/junit/jupiter/api/extension/TestExecutionExceptionHandler.java index 34db9c03497c..54640f43feaa 100644 --- a/junit-jupiter-api/src/main/java/org/junit/jupiter/api/extension/TestExecutionExceptionHandler.java +++ b/junit-jupiter-api/src/main/java/org/junit/jupiter/api/extension/TestExecutionExceptionHandler.java @@ -61,6 +61,10 @@ public interface TestExecutionExceptionHandler extends Extension { */ void handleTestExecutionException(ExtensionContext context, Throwable throwable) throws Throwable; + default void handleExceptionInBeforeAllMethod(ExtensionContext context, Throwable throwable) throws Throwable { + throw throwable; + } + default void handleExceptionInBeforeEachMethod(ExtensionContext context, Throwable throwable) throws Throwable { throw throwable; } @@ -68,4 +72,8 @@ default void handleExceptionInBeforeEachMethod(ExtensionContext context, Throwab default void handleExceptionInAfterEachMethod(ExtensionContext context, Throwable throwable) throws Throwable { throw throwable; } + + default void handleExceptionInAfterAllMethod(ExtensionContext context, Throwable throwable) throws Throwable { + throw throwable; + } } From 2bb07cba0ddd0a902a7837e14cfb303dc74d9623 Mon Sep 17 00:00:00 2001 From: phoenix384 Date: Tue, 31 Jul 2018 12:36:45 +0200 Subject: [PATCH 09/21] Update ClassTestDescriptor.java --- .../descriptor/ClassTestDescriptor.java | 53 +++++++++++++++++-- 1 file changed, 48 insertions(+), 5 deletions(-) diff --git a/junit-jupiter-engine/src/main/java/org/junit/jupiter/engine/descriptor/ClassTestDescriptor.java b/junit-jupiter-engine/src/main/java/org/junit/jupiter/engine/descriptor/ClassTestDescriptor.java index e0aead7dfe37..e8468f3a2730 100644 --- a/junit-jupiter-engine/src/main/java/org/junit/jupiter/engine/descriptor/ClassTestDescriptor.java +++ b/junit-jupiter-engine/src/main/java/org/junit/jupiter/engine/descriptor/ClassTestDescriptor.java @@ -28,6 +28,7 @@ import java.util.List; import java.util.Optional; import java.util.Set; +import java.util.function.BiFunction; import java.util.function.Function; import org.apiguardian.api.API; @@ -37,9 +38,11 @@ import org.junit.jupiter.api.extension.Extension; import org.junit.jupiter.api.extension.ExtensionConfigurationException; import org.junit.jupiter.api.extension.ExtensionContext; +import org.junit.jupiter.api.extension.TestExecutionExceptionHandler; import org.junit.jupiter.api.extension.TestInstanceFactory; import org.junit.jupiter.api.extension.TestInstancePostProcessor; import org.junit.jupiter.api.extension.TestInstantiationException; +import org.junit.jupiter.api.function.Executable; import org.junit.jupiter.engine.execution.AfterEachMethodAdapter; import org.junit.jupiter.engine.execution.BeforeEachMethodAdapter; import org.junit.jupiter.engine.execution.ExecutableInvoker; @@ -47,6 +50,7 @@ import org.junit.jupiter.engine.execution.TestInstanceProvider; import org.junit.jupiter.engine.extension.ExtensionRegistry; import org.junit.platform.commons.JUnitException; +import org.junit.platform.commons.util.ExceptionUtils; import org.junit.platform.commons.util.BlacklistedExceptions; import org.junit.platform.commons.util.Preconditions; import org.junit.platform.commons.util.ReflectionUtils; @@ -358,9 +362,16 @@ private void invokeBeforeAllMethods(JupiterEngineExecutionContext context) { ThrowableCollector throwableCollector = context.getThrowableCollector(); Object testInstance = extensionContext.getTestInstance().orElse(null); - for (Method method : this.beforeAllMethods) { - throwableCollector.execute( - () -> executableInvoker.invoke(method, testInstance, extensionContext, registry)); + for (Method method: this.beforeAllMethods) { + throwableCollector.execute(() -> { + try { + executableInvoker.invoke(method, testInstance, extensionContext, registry); + } + catch (Throwable throwable) { + invokeTestExecutionExceptionHandlers(throwable, registry, + ((ex, handler) -> () -> handler.handleExceptionInBeforeAllMethod(extensionContext, ex))); + } + }); if (throwableCollector.isNotEmpty()) { break; } @@ -373,8 +384,15 @@ private void invokeAfterAllMethods(JupiterEngineExecutionContext context) { ThrowableCollector throwableCollector = context.getThrowableCollector(); Object testInstance = extensionContext.getTestInstance().orElse(null); - this.afterAllMethods.forEach(method -> throwableCollector.execute( - () -> executableInvoker.invoke(method, testInstance, extensionContext, registry))); + this.afterAllMethods.forEach(method -> throwableCollector.execute(() -> { + try { + executableInvoker.invoke(method, testInstance, extensionContext, registry); + } + catch (Throwable throwable) { + invokeTestExecutionExceptionHandlers(throwable, registry, + ((ex, handler) -> () -> handler.handleExceptionInAfterAllMethod(extensionContext, ex))); + } + })); } private void invokeAfterAllCallbacks(JupiterEngineExecutionContext context) { @@ -386,6 +404,31 @@ private void invokeAfterAllCallbacks(JupiterEngineExecutionContext context) { .forEach(extension -> throwableCollector.execute(() -> extension.afterAll(extensionContext))); } + private void invokeTestExecutionExceptionHandlers(Throwable ex, ExtensionRegistry registry, + BiFunction generator) { + + invokeTestExecutionExceptionHandlers(ex, registry.getReversedExtensions(TestExecutionExceptionHandler.class), + generator); + } + + private void invokeTestExecutionExceptionHandlers(Throwable ex, List handlers, + BiFunction generator) { + + // No handlers left? + if (handlers.isEmpty()) { + ExceptionUtils.throwAsUncheckedException(ex); + } + + try { + // Invoke next available handler + Executable executable = generator.apply(ex, handlers.remove(0)); + executable.execute(); + } + catch (Throwable t) { + invokeTestExecutionExceptionHandlers(t, handlers, generator); + } + } + private void registerBeforeEachMethodAdapters(ExtensionRegistry registry) { List beforeEachMethods = findBeforeEachMethods(this.testClass); registerMethodsAsExtensions(beforeEachMethods, registry, this::synthesizeBeforeEachMethodAdapter); From 7e16c23350a825cf01c8fd9fc75f0f176da794f6 Mon Sep 17 00:00:00 2001 From: phoenix384 Date: Tue, 31 Jul 2018 14:27:33 +0200 Subject: [PATCH 10/21] Update ClassTestDescriptor.java --- .../junit/jupiter/engine/descriptor/ClassTestDescriptor.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/junit-jupiter-engine/src/main/java/org/junit/jupiter/engine/descriptor/ClassTestDescriptor.java b/junit-jupiter-engine/src/main/java/org/junit/jupiter/engine/descriptor/ClassTestDescriptor.java index e8468f3a2730..46cd7f3457e9 100644 --- a/junit-jupiter-engine/src/main/java/org/junit/jupiter/engine/descriptor/ClassTestDescriptor.java +++ b/junit-jupiter-engine/src/main/java/org/junit/jupiter/engine/descriptor/ClassTestDescriptor.java @@ -362,7 +362,7 @@ private void invokeBeforeAllMethods(JupiterEngineExecutionContext context) { ThrowableCollector throwableCollector = context.getThrowableCollector(); Object testInstance = extensionContext.getTestInstance().orElse(null); - for (Method method: this.beforeAllMethods) { + for (Method method : this.beforeAllMethods) { throwableCollector.execute(() -> { try { executableInvoker.invoke(method, testInstance, extensionContext, registry); From 4f548b4ce98afa0a37bf096000c4a2ef09b8cd30 Mon Sep 17 00:00:00 2001 From: phoenix384 Date: Tue, 7 Aug 2018 14:51:13 +0200 Subject: [PATCH 11/21] Added Tests --- ...eforeAndAfterAllExceptionHandlerTests.java | 254 ++++++++++++++++++ 1 file changed, 254 insertions(+) create mode 100644 junit-jupiter-engine/src/test/java/org/junit/jupiter/engine/extension/BeforeAndAfterAllExceptionHandlerTests.java diff --git a/junit-jupiter-engine/src/test/java/org/junit/jupiter/engine/extension/BeforeAndAfterAllExceptionHandlerTests.java b/junit-jupiter-engine/src/test/java/org/junit/jupiter/engine/extension/BeforeAndAfterAllExceptionHandlerTests.java new file mode 100644 index 000000000000..3789127bfdf3 --- /dev/null +++ b/junit-jupiter-engine/src/test/java/org/junit/jupiter/engine/extension/BeforeAndAfterAllExceptionHandlerTests.java @@ -0,0 +1,254 @@ +/* + * Copyright 2015-2018 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 v2.0 which + * accompanies this distribution and is available at + * + * http://www.eclipse.org/legal/epl-v20.html + */ + +package org.junit.jupiter.engine.extension; + +import static org.assertj.core.api.Assertions.allOf; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.platform.engine.discovery.DiscoverySelectors.selectMethod; +import static org.junit.platform.engine.test.event.ExecutionEventConditions.assertRecordedExecutionEventsContainsExactly; +import static org.junit.platform.engine.test.event.ExecutionEventConditions.container; +import static org.junit.platform.engine.test.event.ExecutionEventConditions.engine; +import static org.junit.platform.engine.test.event.ExecutionEventConditions.event; +import static org.junit.platform.engine.test.event.ExecutionEventConditions.finishedSuccessfully; +import static org.junit.platform.engine.test.event.ExecutionEventConditions.finishedWithFailure; +import static org.junit.platform.engine.test.event.ExecutionEventConditions.started; +import static org.junit.platform.engine.test.event.ExecutionEventConditions.test; +import static org.junit.platform.engine.test.event.TestExecutionResultConditions.isA; +import static org.junit.platform.engine.test.event.TestExecutionResultConditions.message; +import static org.junit.platform.launcher.core.LauncherDiscoveryRequestBuilder.request; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.junit.jupiter.api.extension.ExtensionContext; +import org.junit.jupiter.api.extension.TestExecutionExceptionHandler; +import org.junit.jupiter.engine.AbstractJupiterTestEngineTests; +import org.junit.platform.engine.test.event.ExecutionEventRecorder; +import org.junit.platform.launcher.LauncherDiscoveryRequest; + +/** + * Integration tests that verify exception handling of {@code @BeforeAll} and {@code @AfterAll} methods in + * {@link TestExecutionExceptionHandler}. + */ +class BeforeAndAfterAllExceptionHandlerTests extends AbstractJupiterTestEngineTests { + + static List handlerCalls = new ArrayList<>(); + + @BeforeEach + void resetStatics() { + handlerCalls.clear(); + } + + @Test + void exceptionHandlerRethrowsException() { + LauncherDiscoveryRequest request = request().selectors(selectMethod(RethrowTestCase.class, "test")).build(); + ExecutionEventRecorder eventRecorder = executeTests(request); + + assertRecordedExecutionEventsContainsExactly(eventRecorder.getExecutionEvents(), + event(engine(), started()), + event(container(RethrowTestCase.class), started()), + event(container(RethrowTestCase.class), finishedWithFailure(allOf(isA(IOException.class), message("checked")))), + event(engine(), finishedSuccessfully())); + + assertEquals(Arrays.asList("rethrowBeforeAll", "rethrowAfterAll", "rethrowAfterAll"), + handlerCalls); + } + + @Test + void exceptionHandlerSwallowsException() { + LauncherDiscoveryRequest request = request().selectors(selectMethod(SwallowTestCase.class, "test")).build(); + ExecutionEventRecorder eventRecorder = executeTests(request); + + assertRecordedExecutionEventsContainsExactly(eventRecorder.getExecutionEvents(), + event(engine(), started()), + event(container(SwallowTestCase.class), started()), + event(test("test"), started()), + event(test("test"), finishedSuccessfully()), + event(container(SwallowTestCase.class), finishedSuccessfully()), + event(engine(), finishedSuccessfully())); + + assertEquals(Arrays.asList( + "swallowBeforeAll", "swallowBeforeAll", "swallowTest", "swallowAfterAll", "swallowAfterAll"), + handlerCalls); + } + + @Test + void exceptionHandlerConvertsException() { + LauncherDiscoveryRequest request = request().selectors(selectMethod(ConvertTestCase.class, "test")).build(); + ExecutionEventRecorder eventRecorder = executeTests(request); + + assertRecordedExecutionEventsContainsExactly(eventRecorder.getExecutionEvents(), + event(engine(), started()), + event(container(ConvertTestCase.class), started()), + event(container(ConvertTestCase.class), finishedWithFailure(allOf(isA(RuntimeException.class), message("unchecked")))), + event(engine(), finishedSuccessfully())); + + assertEquals(Arrays.asList("convertBeforeAll", "convertAfterAll", "convertAfterAll"), + handlerCalls); + } + + @Test + void severalHandlersAreCalledInOrder() { + LauncherDiscoveryRequest request = request().selectors(selectMethod(SeveralTestCase.class, "test")).build(); + ExecutionEventRecorder eventRecorder = executeTests(request); + + assertRecordedExecutionEventsContainsExactly(eventRecorder.getExecutionEvents(), + event(engine(), started()), + event(container(SeveralTestCase.class), started()), + event(test("test"), started()), + event(test("test"), finishedSuccessfully()), + event(container(SeveralTestCase.class), finishedSuccessfully()), + event(engine(), finishedSuccessfully())); + + assertEquals(Arrays.asList( + "convertBeforeAll", "rethrowBeforeAll", "swallowBeforeAll", + "convertBeforeAll", "rethrowBeforeAll", "swallowBeforeAll", + "convertTest", "rethrowTest", "swallowTest", + "convertAfterAll", "rethrowAfterAll", "swallowAfterAll", + "convertAfterAll", "rethrowAfterAll", "swallowAfterAll"), + handlerCalls); + } + + // ------------------------------------------------------------------- + + static abstract class ATestCase { + + @BeforeAll + static void beforeAll() throws IOException { + throw new IOException("checked"); + } + + @BeforeAll + static void beforeAll2() throws IOException { + throw new IOException("checked"); + } + + @Test + void test() throws IOException { + throw new IOException("checked"); + } + + @AfterAll + static void afterAll() throws IOException { + throw new IOException("checked"); + } + + @AfterAll + static void afterAll2() throws IOException { + throw new IOException("checked"); + } + } + + @ExtendWith(RethrowException.class) + static class RethrowTestCase extends ATestCase { + } + + @ExtendWith(SwallowException.class) + static class SwallowTestCase extends ATestCase { + } + + @ExtendWith(ConvertException.class) + static class ConvertTestCase extends ATestCase { + } + + @ExtendWith(ShouldNotBeCalled.class) + @ExtendWith(SwallowException.class) + @ExtendWith(RethrowException.class) + @ExtendWith(ConvertException.class) + static class SeveralTestCase extends ATestCase { + } + + static class RethrowException implements TestExecutionExceptionHandler { + + @Override + public void handleTestExecutionException(ExtensionContext context, Throwable throwable) throws Throwable { + handlerCalls.add("rethrowTest"); + throw throwable; + } + + @Override + public void handleExceptionInBeforeAllMethod(ExtensionContext context, Throwable throwable) throws Throwable { + handlerCalls.add("rethrowBeforeAll"); + throw throwable; + } + + @Override + public void handleExceptionInAfterAllMethod(ExtensionContext context, Throwable throwable) throws Throwable { + handlerCalls.add("rethrowAfterAll"); + throw throwable; + } + } + + static class SwallowException implements TestExecutionExceptionHandler { + // swallow exception by not rethrowing it + + @Override + public void handleTestExecutionException(ExtensionContext context, Throwable throwable) throws Throwable { + handlerCalls.add("swallowTest"); + } + + @Override + public void handleExceptionInBeforeAllMethod(ExtensionContext context, Throwable throwable) throws Throwable { + handlerCalls.add("swallowBeforeAll"); + } + + @Override + public void handleExceptionInAfterAllMethod(ExtensionContext context, Throwable throwable) throws Throwable { + handlerCalls.add("swallowAfterAll"); + } + } + + static class ConvertException implements TestExecutionExceptionHandler { + + @Override + public void handleTestExecutionException(ExtensionContext context, Throwable throwable) throws Throwable { + handlerCalls.add("convertTest"); + throw new RuntimeException("unchecked"); + } + + @Override + public void handleExceptionInBeforeAllMethod(ExtensionContext context, Throwable throwable) throws Throwable { + handlerCalls.add("convertBeforeAll"); + throw new RuntimeException("unchecked"); + } + + @Override + public void handleExceptionInAfterAllMethod(ExtensionContext context, Throwable throwable) throws Throwable { + handlerCalls.add("convertAfterAll"); + throw new RuntimeException("unchecked"); + } + } + + static class ShouldNotBeCalled implements TestExecutionExceptionHandler { + + @Override + public void handleTestExecutionException(ExtensionContext context, Throwable throwable) throws Throwable { + handlerCalls.add("shouldNotBeCalledTest"); + } + + @Override + public void handleExceptionInBeforeAllMethod(ExtensionContext context, Throwable throwable) throws Throwable { + handlerCalls.add("shouldNotBeCalledBeforeAll"); + } + + @Override + public void handleExceptionInAfterAllMethod(ExtensionContext context, Throwable throwable) throws Throwable { + handlerCalls.add("shouldNotBeCalledAfterAll"); + } + } +} From 5176418ae35ac4840c7ac3046164788f692ec912 Mon Sep 17 00:00:00 2001 From: phoenix384 Date: Tue, 7 Aug 2018 14:52:27 +0200 Subject: [PATCH 12/21] Added tests --- ...foreAndAfterEachExceptionHandlerTests.java | 219 ++++++++++++++++++ 1 file changed, 219 insertions(+) create mode 100644 junit-jupiter-engine/src/test/java/org/junit/jupiter/engine/extension/BeforeAndAfterEachExceptionHandlerTests.java diff --git a/junit-jupiter-engine/src/test/java/org/junit/jupiter/engine/extension/BeforeAndAfterEachExceptionHandlerTests.java b/junit-jupiter-engine/src/test/java/org/junit/jupiter/engine/extension/BeforeAndAfterEachExceptionHandlerTests.java new file mode 100644 index 000000000000..01b212dd53ed --- /dev/null +++ b/junit-jupiter-engine/src/test/java/org/junit/jupiter/engine/extension/BeforeAndAfterEachExceptionHandlerTests.java @@ -0,0 +1,219 @@ +/* + * Copyright 2015-2018 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 v2.0 which + * accompanies this distribution and is available at + * + * http://www.eclipse.org/legal/epl-v20.html + */ + +package org.junit.jupiter.engine.extension; + +import static org.assertj.core.api.Assertions.allOf; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.platform.engine.discovery.DiscoverySelectors.selectMethod; +import static org.junit.platform.engine.test.event.ExecutionEventConditions.assertRecordedExecutionEventsContainsExactly; +import static org.junit.platform.engine.test.event.ExecutionEventConditions.container; +import static org.junit.platform.engine.test.event.ExecutionEventConditions.engine; +import static org.junit.platform.engine.test.event.ExecutionEventConditions.event; +import static org.junit.platform.engine.test.event.ExecutionEventConditions.finishedSuccessfully; +import static org.junit.platform.engine.test.event.ExecutionEventConditions.finishedWithFailure; +import static org.junit.platform.engine.test.event.ExecutionEventConditions.started; +import static org.junit.platform.engine.test.event.ExecutionEventConditions.test; +import static org.junit.platform.engine.test.event.TestExecutionResultConditions.isA; +import static org.junit.platform.engine.test.event.TestExecutionResultConditions.message; +import static org.junit.platform.launcher.core.LauncherDiscoveryRequestBuilder.request; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.junit.jupiter.api.extension.ExtensionContext; +import org.junit.jupiter.api.extension.TestExecutionExceptionHandler; +import org.junit.jupiter.engine.AbstractJupiterTestEngineTests; +import org.junit.platform.engine.test.event.ExecutionEventRecorder; +import org.junit.platform.launcher.LauncherDiscoveryRequest; + +/** + * Integration tests that verify exception handling of {@code @BeforeEach} and {@code @AfterEach} methods in + * {@link TestExecutionExceptionHandler}. + */ +class BeforeAndAfterEachExceptionHandlerTests extends AbstractJupiterTestEngineTests { + static List handlerCalls = new ArrayList<>(); + @BeforeEach + void resetStatics() { + handlerCalls.clear(); + } + @Test + void exceptionHandlerRethrowsException() { + LauncherDiscoveryRequest request = request().selectors(selectMethod(ATestCase.class, "testRethrow")).build(); + ExecutionEventRecorder eventRecorder = executeTests(request); + assertRecordedExecutionEventsContainsExactly(eventRecorder.getExecutionEvents(), + event(engine(), started()), + event(container(ATestCase.class), started()), + event(test("testRethrow"), started()), + event(test("testRethrow"), finishedWithFailure(allOf(isA(IOException.class), message("checked")))), + event(container(ATestCase.class), finishedSuccessfully()), + event(engine(), finishedSuccessfully())); + assertEquals(Arrays.asList("rethrowBeforeEach", "rethrowAfterEach", "rethrowAfterEach"), + handlerCalls); + } + @Test + void exceptionHandlerSwallowsException() { + LauncherDiscoveryRequest request = request().selectors(selectMethod(ATestCase.class, "testSwallow")).build(); + ExecutionEventRecorder eventRecorder = executeTests(request); + assertRecordedExecutionEventsContainsExactly(eventRecorder.getExecutionEvents(), + event(engine(), started()), + event(container(ATestCase.class), started()), + event(test("testSwallow"), started()), + event(test("testSwallow"), finishedSuccessfully()), + event(container(ATestCase.class), finishedSuccessfully()), + event(engine(), finishedSuccessfully())); + assertEquals(Arrays.asList("swallowBeforeEach", "swallowBeforeEach", "swallowTest", "swallowAfterEach", "swallowAfterEach"), + handlerCalls); + } + @Test + void exceptionHandlerConvertsException() { + LauncherDiscoveryRequest request = request().selectors(selectMethod(ATestCase.class, "testConvert")).build(); + ExecutionEventRecorder eventRecorder = executeTests(request); + assertRecordedExecutionEventsContainsExactly(eventRecorder.getExecutionEvents(), + event(engine(), started()), + event(container(ATestCase.class), started()), + event(test("testConvert"), started()), + event(test("testConvert"), finishedWithFailure(allOf(isA(RuntimeException.class), message("unchecked")))), + event(container(ATestCase.class), finishedSuccessfully()), + event(engine(), finishedSuccessfully())); + assertEquals(Arrays.asList("convertBeforeEach", "convertAfterEach", "convertAfterEach"), + handlerCalls); + } + @Test + void severalHandlersAreCalledInOrder() { + LauncherDiscoveryRequest request = request().selectors(selectMethod(ATestCase.class, "testSeveral")).build(); + ExecutionEventRecorder eventRecorder = executeTests(request); + assertRecordedExecutionEventsContainsExactly(eventRecorder.getExecutionEvents(), + event(engine(), started()), + event(container(ATestCase.class), started()), + event(test("testSeveral"), started()), + event(test("testSeveral"), finishedSuccessfully()), + event(container(ATestCase.class), finishedSuccessfully()), + event(engine(), finishedSuccessfully())); + assertEquals(Arrays.asList( + "convertBeforeEach", "rethrowBeforeEach", "swallowBeforeEach", + "convertBeforeEach", "rethrowBeforeEach", "swallowBeforeEach", + "convertTest", "rethrowTest", "swallowTest", + "convertAfterEach", "rethrowAfterEach", "swallowAfterEach", + "convertAfterEach", "rethrowAfterEach", "swallowAfterEach"), + handlerCalls); + } + // ------------------------------------------------------------------- + static class ATestCase { + @BeforeEach + void beforeEach() throws IOException { + throw new IOException("checked"); + } + @BeforeEach + void beforeEach2() throws IOException { + throw new IOException("checked"); + } + @Test + @ExtendWith(RethrowException.class) + void testRethrow() throws IOException { + throw new IOException("checked"); + } + @Test + @ExtendWith(SwallowException.class) + void testSwallow() throws IOException { + throw new IOException("checked"); + } + @Test + @ExtendWith(ConvertException.class) + void testConvert() throws IOException { + throw new IOException("checked"); + } + @Test + @ExtendWith(ShouldNotBeCalled.class) + @ExtendWith(SwallowException.class) + @ExtendWith(RethrowException.class) + @ExtendWith(ConvertException.class) + void testSeveral() throws IOException { + throw new IOException("checked"); + } + @AfterEach + void afterEach() throws IOException { + throw new IOException("checked"); + } + @AfterEach + void afterEach2() throws IOException { + throw new IOException("checked"); + } + } + static class RethrowException implements TestExecutionExceptionHandler { + @Override + public void handleTestExecutionException(ExtensionContext context, Throwable throwable) throws Throwable { + handlerCalls.add("rethrowTest"); + throw throwable; + } + @Override + public void handleExceptionInBeforeEachMethod(ExtensionContext context, Throwable throwable) throws Throwable { + handlerCalls.add("rethrowBeforeEach"); + throw throwable; + } + @Override + public void handleExceptionInAfterEachMethod(ExtensionContext context, Throwable throwable) throws Throwable { + handlerCalls.add("rethrowAfterEach"); + throw throwable; + } + } + static class SwallowException implements TestExecutionExceptionHandler { + // swallow exception by not rethrowing it + @Override + public void handleTestExecutionException(ExtensionContext context, Throwable throwable) throws Throwable { + handlerCalls.add("swallowTest"); + } + @Override + public void handleExceptionInBeforeEachMethod(ExtensionContext context, Throwable throwable) throws Throwable { + handlerCalls.add("swallowBeforeEach"); + } + @Override + public void handleExceptionInAfterEachMethod(ExtensionContext context, Throwable throwable) throws Throwable { + handlerCalls.add("swallowAfterEach"); + } + } + static class ConvertException implements TestExecutionExceptionHandler { + @Override + public void handleTestExecutionException(ExtensionContext context, Throwable throwable) throws Throwable { + handlerCalls.add("convertTest"); + throw new RuntimeException("unchecked"); + } + @Override + public void handleExceptionInBeforeEachMethod(ExtensionContext context, Throwable throwable) throws Throwable { + handlerCalls.add("convertBeforeEach"); + throw new RuntimeException("unchecked"); + } + @Override + public void handleExceptionInAfterEachMethod(ExtensionContext context, Throwable throwable) throws Throwable { + handlerCalls.add("convertAfterEach"); + throw new RuntimeException("unchecked"); + } + } + static class ShouldNotBeCalled implements TestExecutionExceptionHandler { + @Override + public void handleTestExecutionException(ExtensionContext context, Throwable throwable) throws Throwable { + handlerCalls.add("shouldNotBeCalledTest"); + } + @Override + public void handleExceptionInBeforeEachMethod(ExtensionContext context, Throwable throwable) throws Throwable { + handlerCalls.add("shouldNotBeCalledBeforeEach"); + } + @Override + public void handleExceptionInAfterEachMethod(ExtensionContext context, Throwable throwable) throws Throwable { + handlerCalls.add("shouldNotBeCalledAfterEach"); + } + } +} From bb13e611f6a962269bbda4d98388e115c76dccbc Mon Sep 17 00:00:00 2001 From: phoenix384 Date: Wed, 8 Aug 2018 17:21:42 +0200 Subject: [PATCH 13/21] Fix formatting --- .../junit/jupiter/engine/descriptor/ClassTestDescriptor.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/junit-jupiter-engine/src/main/java/org/junit/jupiter/engine/descriptor/ClassTestDescriptor.java b/junit-jupiter-engine/src/main/java/org/junit/jupiter/engine/descriptor/ClassTestDescriptor.java index 46cd7f3457e9..b3111593cb5b 100644 --- a/junit-jupiter-engine/src/main/java/org/junit/jupiter/engine/descriptor/ClassTestDescriptor.java +++ b/junit-jupiter-engine/src/main/java/org/junit/jupiter/engine/descriptor/ClassTestDescriptor.java @@ -50,8 +50,8 @@ import org.junit.jupiter.engine.execution.TestInstanceProvider; import org.junit.jupiter.engine.extension.ExtensionRegistry; import org.junit.platform.commons.JUnitException; -import org.junit.platform.commons.util.ExceptionUtils; import org.junit.platform.commons.util.BlacklistedExceptions; +import org.junit.platform.commons.util.ExceptionUtils; import org.junit.platform.commons.util.Preconditions; import org.junit.platform.commons.util.ReflectionUtils; import org.junit.platform.commons.util.StringUtils; @@ -408,7 +408,7 @@ private void invokeTestExecutionExceptionHandlers(Throwable ex, ExtensionRegistr BiFunction generator) { invokeTestExecutionExceptionHandlers(ex, registry.getReversedExtensions(TestExecutionExceptionHandler.class), - generator); + generator); } private void invokeTestExecutionExceptionHandlers(Throwable ex, List handlers, From 7f2185f3b3592d5052d9d54c6d83df43935bc0f0 Mon Sep 17 00:00:00 2001 From: phoenix384 Date: Wed, 8 Aug 2018 17:28:45 +0200 Subject: [PATCH 14/21] Fix formatting --- .../descriptor/TestMethodTestDescriptor.java | 44 +++++++++---------- 1 file changed, 21 insertions(+), 23 deletions(-) diff --git a/junit-jupiter-engine/src/main/java/org/junit/jupiter/engine/descriptor/TestMethodTestDescriptor.java b/junit-jupiter-engine/src/main/java/org/junit/jupiter/engine/descriptor/TestMethodTestDescriptor.java index 7d7897d2bce4..0905780e7085 100644 --- a/junit-jupiter-engine/src/main/java/org/junit/jupiter/engine/descriptor/TestMethodTestDescriptor.java +++ b/junit-jupiter-engine/src/main/java/org/junit/jupiter/engine/descriptor/TestMethodTestDescriptor.java @@ -132,17 +132,16 @@ private void invokeBeforeEachCallbacks(JupiterEngineExecutionContext context) { private void invokeBeforeEachMethods(JupiterEngineExecutionContext context) { ExtensionRegistry registry = context.getExtensionRegistry(); - invokeBeforeMethodsOrCallbacksUntilExceptionOccurs(context, - ((extensionContext, adapter) -> () -> { - try { - adapter.invokeBeforeEachMethod(extensionContext, registry); - } - catch (Throwable throwable) { - invokeTestExecutionExceptionHandlers(throwable, registry, - ((ex, handler) -> () -> handler.handleExceptionInBeforeEachMethod(extensionContext, ex))); - } - }), - BeforeEachMethodAdapter.class); + invokeBeforeMethodsOrCallbacksUntilExceptionOccurs(context, ((extensionContext, adapter) -> () -> { + try { + adapter.invokeBeforeEachMethod(extensionContext, registry); + } + catch (Throwable throwable) { + invokeTestExecutionExceptionHandlers(throwable, registry, + ((ex, handler) -> () -> handler.handleExceptionInBeforeEachMethod(extensionContext, ex))); + } + }), + BeforeEachMethodAdapter.class); } private void invokeBeforeTestExecutionCallbacks(JupiterEngineExecutionContext context) { @@ -189,7 +188,7 @@ private void invokeTestExecutionExceptionHandlers(Throwable ex, ExtensionRegistr BiFunction generator) { invokeTestExecutionExceptionHandlers(ex, registry.getReversedExtensions(TestExecutionExceptionHandler.class), - generator); + generator); } private void invokeTestExecutionExceptionHandlers(Throwable ex, List handlers, @@ -218,17 +217,16 @@ private void invokeAfterTestExecutionCallbacks(JupiterEngineExecutionContext con private void invokeAfterEachMethods(JupiterEngineExecutionContext context) { ExtensionRegistry registry = context.getExtensionRegistry(); - invokeAllAfterMethodsOrCallbacks(context, - ((extensionContext, adapter) -> () -> { - try { - adapter.invokeAfterEachMethod(extensionContext, registry); - } - catch (Throwable throwable) { - invokeTestExecutionExceptionHandlers(throwable, registry, - ((ex, handler) -> () -> handler.handleExceptionInAfterEachMethod(extensionContext, ex))); - } - }), - AfterEachMethodAdapter.class); + invokeAllAfterMethodsOrCallbacks(context, ((extensionContext, adapter) -> () -> { + try { + adapter.invokeAfterEachMethod(extensionContext, registry); + } + catch (Throwable throwable) { + invokeTestExecutionExceptionHandlers(throwable, registry, + ((ex, handler) -> () -> handler.handleExceptionInAfterEachMethod(extensionContext, ex))); + } + }), + AfterEachMethodAdapter.class); } private void invokeAfterEachCallbacks(JupiterEngineExecutionContext context) { From 89ed782e3e2abb625240a26d05ca563b459afff9 Mon Sep 17 00:00:00 2001 From: phoenix384 Date: Wed, 8 Aug 2018 18:33:48 +0200 Subject: [PATCH 15/21] Fix formatting --- .../jupiter/engine/descriptor/TestMethodTestDescriptor.java | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/junit-jupiter-engine/src/main/java/org/junit/jupiter/engine/descriptor/TestMethodTestDescriptor.java b/junit-jupiter-engine/src/main/java/org/junit/jupiter/engine/descriptor/TestMethodTestDescriptor.java index 0905780e7085..5403750676e7 100644 --- a/junit-jupiter-engine/src/main/java/org/junit/jupiter/engine/descriptor/TestMethodTestDescriptor.java +++ b/junit-jupiter-engine/src/main/java/org/junit/jupiter/engine/descriptor/TestMethodTestDescriptor.java @@ -140,8 +140,7 @@ private void invokeBeforeEachMethods(JupiterEngineExecutionContext context) { invokeTestExecutionExceptionHandlers(throwable, registry, ((ex, handler) -> () -> handler.handleExceptionInBeforeEachMethod(extensionContext, ex))); } - }), - BeforeEachMethodAdapter.class); + }), BeforeEachMethodAdapter.class); } private void invokeBeforeTestExecutionCallbacks(JupiterEngineExecutionContext context) { @@ -225,8 +224,7 @@ private void invokeAfterEachMethods(JupiterEngineExecutionContext context) { invokeTestExecutionExceptionHandlers(throwable, registry, ((ex, handler) -> () -> handler.handleExceptionInAfterEachMethod(extensionContext, ex))); } - }), - AfterEachMethodAdapter.class); + }), AfterEachMethodAdapter.class); } private void invokeAfterEachCallbacks(JupiterEngineExecutionContext context) { From cea8010fc9989854517a81715c3d6d1f708d8463 Mon Sep 17 00:00:00 2001 From: phoenix384 Date: Wed, 8 Aug 2018 18:44:43 +0200 Subject: [PATCH 16/21] Fix formatting --- ...foreAndAfterEachExceptionHandlerTests.java | 115 +++++++++++------- 1 file changed, 74 insertions(+), 41 deletions(-) diff --git a/junit-jupiter-engine/src/test/java/org/junit/jupiter/engine/extension/BeforeAndAfterEachExceptionHandlerTests.java b/junit-jupiter-engine/src/test/java/org/junit/jupiter/engine/extension/BeforeAndAfterEachExceptionHandlerTests.java index 01b212dd53ed..64af5f262713 100644 --- a/junit-jupiter-engine/src/test/java/org/junit/jupiter/engine/extension/BeforeAndAfterEachExceptionHandlerTests.java +++ b/junit-jupiter-engine/src/test/java/org/junit/jupiter/engine/extension/BeforeAndAfterEachExceptionHandlerTests.java @@ -45,97 +45,112 @@ * {@link TestExecutionExceptionHandler}. */ class BeforeAndAfterEachExceptionHandlerTests extends AbstractJupiterTestEngineTests { + static List handlerCalls = new ArrayList<>(); + @BeforeEach void resetStatics() { handlerCalls.clear(); } + @Test void exceptionHandlerRethrowsException() { LauncherDiscoveryRequest request = request().selectors(selectMethod(ATestCase.class, "testRethrow")).build(); ExecutionEventRecorder eventRecorder = executeTests(request); - assertRecordedExecutionEventsContainsExactly(eventRecorder.getExecutionEvents(), - event(engine(), started()), - event(container(ATestCase.class), started()), - event(test("testRethrow"), started()), - event(test("testRethrow"), finishedWithFailure(allOf(isA(IOException.class), message("checked")))), - event(container(ATestCase.class), finishedSuccessfully()), - event(engine(), finishedSuccessfully())); - assertEquals(Arrays.asList("rethrowBeforeEach", "rethrowAfterEach", "rethrowAfterEach"), - handlerCalls); + + assertRecordedExecutionEventsContainsExactly(eventRecorder.getExecutionEvents(), // + event(engine(), started()), // + event(container(ATestCase.class), started()), // + event(test("testRethrow"), started()), // + event(test("testRethrow"), finishedWithFailure(allOf(isA(IOException.class), message("checked")))), // + event(container(ATestCase.class), finishedSuccessfully()), // + event(engine(), finishedSuccessfully())); + + assertEquals(Arrays.asList("rethrowBeforeEach", "rethrowAfterEach", "rethrowAfterEach"), handlerCalls); } @Test void exceptionHandlerSwallowsException() { LauncherDiscoveryRequest request = request().selectors(selectMethod(ATestCase.class, "testSwallow")).build(); ExecutionEventRecorder eventRecorder = executeTests(request); - assertRecordedExecutionEventsContainsExactly(eventRecorder.getExecutionEvents(), - event(engine(), started()), - event(container(ATestCase.class), started()), - event(test("testSwallow"), started()), - event(test("testSwallow"), finishedSuccessfully()), - event(container(ATestCase.class), finishedSuccessfully()), - event(engine(), finishedSuccessfully())); - assertEquals(Arrays.asList("swallowBeforeEach", "swallowBeforeEach", "swallowTest", "swallowAfterEach", "swallowAfterEach"), - handlerCalls); + + assertRecordedExecutionEventsContainsExactly(eventRecorder.getExecutionEvents(), // + event(engine(), started()), // + event(container(ATestCase.class), started()), // + event(test("testSwallow"), started()), // + event(test("testSwallow"), finishedSuccessfully()), // + event(container(ATestCase.class), finishedSuccessfully()), // + event(engine(), finishedSuccessfully())); + + assertEquals(Arrays.asList("swallowBeforeEach", "swallowBeforeEach", "swallowTest", "swallowAfterEach", "swallowAfterEach"), handlerCalls); } @Test void exceptionHandlerConvertsException() { LauncherDiscoveryRequest request = request().selectors(selectMethod(ATestCase.class, "testConvert")).build(); ExecutionEventRecorder eventRecorder = executeTests(request); - assertRecordedExecutionEventsContainsExactly(eventRecorder.getExecutionEvents(), - event(engine(), started()), - event(container(ATestCase.class), started()), - event(test("testConvert"), started()), - event(test("testConvert"), finishedWithFailure(allOf(isA(RuntimeException.class), message("unchecked")))), - event(container(ATestCase.class), finishedSuccessfully()), - event(engine(), finishedSuccessfully())); - assertEquals(Arrays.asList("convertBeforeEach", "convertAfterEach", "convertAfterEach"), - handlerCalls); + + assertRecordedExecutionEventsContainsExactly(eventRecorder.getExecutionEvents(), // + event(engine(), started()), // + event(container(ATestCase.class), started()), // + event(test("testConvert"), started()), // + event(test("testConvert"), finishedWithFailure(allOf(isA(RuntimeException.class), message("unchecked")))), // + event(container(ATestCase.class), finishedSuccessfully()), // + event(engine(), finishedSuccessfully())); + assertEquals(Arrays.asList("convertBeforeEach", "convertAfterEach", "convertAfterEach"), handlerCalls); } @Test void severalHandlersAreCalledInOrder() { LauncherDiscoveryRequest request = request().selectors(selectMethod(ATestCase.class, "testSeveral")).build(); ExecutionEventRecorder eventRecorder = executeTests(request); - assertRecordedExecutionEventsContainsExactly(eventRecorder.getExecutionEvents(), - event(engine(), started()), - event(container(ATestCase.class), started()), - event(test("testSeveral"), started()), - event(test("testSeveral"), finishedSuccessfully()), - event(container(ATestCase.class), finishedSuccessfully()), - event(engine(), finishedSuccessfully())); - assertEquals(Arrays.asList( - "convertBeforeEach", "rethrowBeforeEach", "swallowBeforeEach", - "convertBeforeEach", "rethrowBeforeEach", "swallowBeforeEach", - "convertTest", "rethrowTest", "swallowTest", - "convertAfterEach", "rethrowAfterEach", "swallowAfterEach", - "convertAfterEach", "rethrowAfterEach", "swallowAfterEach"), - handlerCalls); + + assertRecordedExecutionEventsContainsExactly(eventRecorder.getExecutionEvents(), // + event(engine(), started()), // + event(container(ATestCase.class), started()), // + event(test("testSeveral"), started()), // + event(test("testSeveral"), finishedSuccessfully()), // + event(container(ATestCase.class), finishedSuccessfully()), // + event(engine(), finishedSuccessfully())); + + assertEquals(Arrays.asList( // + "convertBeforeEach", "rethrowBeforeEach", "swallowBeforeEach", // + "convertBeforeEach", "rethrowBeforeEach", "swallowBeforeEach", // + "convertTest", "rethrowTest", "swallowTest", // + "convertAfterEach", "rethrowAfterEach", "swallowAfterEach", // + "convertAfterEach", "rethrowAfterEach", "swallowAfterEach"), // + handlerCalls); } + // ------------------------------------------------------------------- + static class ATestCase { + @BeforeEach void beforeEach() throws IOException { throw new IOException("checked"); } + @BeforeEach void beforeEach2() throws IOException { throw new IOException("checked"); } + @Test @ExtendWith(RethrowException.class) void testRethrow() throws IOException { throw new IOException("checked"); } + @Test @ExtendWith(SwallowException.class) void testSwallow() throws IOException { throw new IOException("checked"); } + @Test @ExtendWith(ConvertException.class) void testConvert() throws IOException { throw new IOException("checked"); } + @Test @ExtendWith(ShouldNotBeCalled.class) @ExtendWith(SwallowException.class) @@ -144,73 +159,91 @@ void testConvert() throws IOException { void testSeveral() throws IOException { throw new IOException("checked"); } + @AfterEach void afterEach() throws IOException { throw new IOException("checked"); } + @AfterEach void afterEach2() throws IOException { throw new IOException("checked"); } } + static class RethrowException implements TestExecutionExceptionHandler { + @Override public void handleTestExecutionException(ExtensionContext context, Throwable throwable) throws Throwable { handlerCalls.add("rethrowTest"); throw throwable; } + @Override public void handleExceptionInBeforeEachMethod(ExtensionContext context, Throwable throwable) throws Throwable { handlerCalls.add("rethrowBeforeEach"); throw throwable; } + @Override public void handleExceptionInAfterEachMethod(ExtensionContext context, Throwable throwable) throws Throwable { handlerCalls.add("rethrowAfterEach"); throw throwable; } } + static class SwallowException implements TestExecutionExceptionHandler { // swallow exception by not rethrowing it + @Override public void handleTestExecutionException(ExtensionContext context, Throwable throwable) throws Throwable { handlerCalls.add("swallowTest"); } + @Override public void handleExceptionInBeforeEachMethod(ExtensionContext context, Throwable throwable) throws Throwable { handlerCalls.add("swallowBeforeEach"); } + @Override public void handleExceptionInAfterEachMethod(ExtensionContext context, Throwable throwable) throws Throwable { handlerCalls.add("swallowAfterEach"); } } + static class ConvertException implements TestExecutionExceptionHandler { + @Override public void handleTestExecutionException(ExtensionContext context, Throwable throwable) throws Throwable { handlerCalls.add("convertTest"); throw new RuntimeException("unchecked"); } + @Override public void handleExceptionInBeforeEachMethod(ExtensionContext context, Throwable throwable) throws Throwable { handlerCalls.add("convertBeforeEach"); throw new RuntimeException("unchecked"); } + @Override public void handleExceptionInAfterEachMethod(ExtensionContext context, Throwable throwable) throws Throwable { handlerCalls.add("convertAfterEach"); throw new RuntimeException("unchecked"); } } + static class ShouldNotBeCalled implements TestExecutionExceptionHandler { + @Override public void handleTestExecutionException(ExtensionContext context, Throwable throwable) throws Throwable { handlerCalls.add("shouldNotBeCalledTest"); } + @Override public void handleExceptionInBeforeEachMethod(ExtensionContext context, Throwable throwable) throws Throwable { handlerCalls.add("shouldNotBeCalledBeforeEach"); } + @Override public void handleExceptionInAfterEachMethod(ExtensionContext context, Throwable throwable) throws Throwable { handlerCalls.add("shouldNotBeCalledAfterEach"); From 7f264884fb686dc21a0cd870c6d6685ce665b107 Mon Sep 17 00:00:00 2001 From: phoenix384 Date: Wed, 8 Aug 2018 18:47:22 +0200 Subject: [PATCH 17/21] Fix formatting --- ...eforeAndAfterAllExceptionHandlerTests.java | 72 +++++++++---------- 1 file changed, 34 insertions(+), 38 deletions(-) diff --git a/junit-jupiter-engine/src/test/java/org/junit/jupiter/engine/extension/BeforeAndAfterAllExceptionHandlerTests.java b/junit-jupiter-engine/src/test/java/org/junit/jupiter/engine/extension/BeforeAndAfterAllExceptionHandlerTests.java index 3789127bfdf3..fd01d904a82a 100644 --- a/junit-jupiter-engine/src/test/java/org/junit/jupiter/engine/extension/BeforeAndAfterAllExceptionHandlerTests.java +++ b/junit-jupiter-engine/src/test/java/org/junit/jupiter/engine/extension/BeforeAndAfterAllExceptionHandlerTests.java @@ -59,14 +59,13 @@ void exceptionHandlerRethrowsException() { LauncherDiscoveryRequest request = request().selectors(selectMethod(RethrowTestCase.class, "test")).build(); ExecutionEventRecorder eventRecorder = executeTests(request); - assertRecordedExecutionEventsContainsExactly(eventRecorder.getExecutionEvents(), - event(engine(), started()), - event(container(RethrowTestCase.class), started()), - event(container(RethrowTestCase.class), finishedWithFailure(allOf(isA(IOException.class), message("checked")))), - event(engine(), finishedSuccessfully())); + assertRecordedExecutionEventsContainsExactly(eventRecorder.getExecutionEvents(), // + event(engine(), started()), // + event(container(RethrowTestCase.class), started()), // + event(container(RethrowTestCase.class), finishedWithFailure(allOf(isA(IOException.class), message("checked")))), // + event(engine(), finishedSuccessfully())); - assertEquals(Arrays.asList("rethrowBeforeAll", "rethrowAfterAll", "rethrowAfterAll"), - handlerCalls); + assertEquals(Arrays.asList("rethrowBeforeAll", "rethrowAfterAll", "rethrowAfterAll"), handlerCalls); } @Test @@ -74,17 +73,15 @@ void exceptionHandlerSwallowsException() { LauncherDiscoveryRequest request = request().selectors(selectMethod(SwallowTestCase.class, "test")).build(); ExecutionEventRecorder eventRecorder = executeTests(request); - assertRecordedExecutionEventsContainsExactly(eventRecorder.getExecutionEvents(), - event(engine(), started()), - event(container(SwallowTestCase.class), started()), - event(test("test"), started()), - event(test("test"), finishedSuccessfully()), - event(container(SwallowTestCase.class), finishedSuccessfully()), - event(engine(), finishedSuccessfully())); + assertRecordedExecutionEventsContainsExactly(eventRecorder.getExecutionEvents(), // + event(engine(), started()), // + event(container(SwallowTestCase.class), started()), // + event(test("test"), started()), // + event(test("test"), finishedSuccessfully()), // + event(container(SwallowTestCase.class), finishedSuccessfully()), // + event(engine(), finishedSuccessfully())); - assertEquals(Arrays.asList( - "swallowBeforeAll", "swallowBeforeAll", "swallowTest", "swallowAfterAll", "swallowAfterAll"), - handlerCalls); + assertEquals(Arrays.asList("swallowBeforeAll", "swallowBeforeAll", "swallowTest", "swallowAfterAll", "swallowAfterAll"), handlerCalls); } @Test @@ -92,14 +89,13 @@ void exceptionHandlerConvertsException() { LauncherDiscoveryRequest request = request().selectors(selectMethod(ConvertTestCase.class, "test")).build(); ExecutionEventRecorder eventRecorder = executeTests(request); - assertRecordedExecutionEventsContainsExactly(eventRecorder.getExecutionEvents(), - event(engine(), started()), - event(container(ConvertTestCase.class), started()), - event(container(ConvertTestCase.class), finishedWithFailure(allOf(isA(RuntimeException.class), message("unchecked")))), - event(engine(), finishedSuccessfully())); + assertRecordedExecutionEventsContainsExactly(eventRecorder.getExecutionEvents(), // + event(engine(), started()), // + event(container(ConvertTestCase.class), started()), // + event(container(ConvertTestCase.class), finishedWithFailure(allOf(isA(RuntimeException.class), message("unchecked")))), // + event(engine(), finishedSuccessfully())); - assertEquals(Arrays.asList("convertBeforeAll", "convertAfterAll", "convertAfterAll"), - handlerCalls); + assertEquals(Arrays.asList("convertBeforeAll", "convertAfterAll", "convertAfterAll"), handlerCalls); } @Test @@ -107,20 +103,20 @@ void severalHandlersAreCalledInOrder() { LauncherDiscoveryRequest request = request().selectors(selectMethod(SeveralTestCase.class, "test")).build(); ExecutionEventRecorder eventRecorder = executeTests(request); - assertRecordedExecutionEventsContainsExactly(eventRecorder.getExecutionEvents(), - event(engine(), started()), - event(container(SeveralTestCase.class), started()), - event(test("test"), started()), - event(test("test"), finishedSuccessfully()), - event(container(SeveralTestCase.class), finishedSuccessfully()), - event(engine(), finishedSuccessfully())); - - assertEquals(Arrays.asList( - "convertBeforeAll", "rethrowBeforeAll", "swallowBeforeAll", - "convertBeforeAll", "rethrowBeforeAll", "swallowBeforeAll", - "convertTest", "rethrowTest", "swallowTest", - "convertAfterAll", "rethrowAfterAll", "swallowAfterAll", - "convertAfterAll", "rethrowAfterAll", "swallowAfterAll"), + assertRecordedExecutionEventsContainsExactly(eventRecorder.getExecutionEvents(), // + event(engine(), started()), // + event(container(SeveralTestCase.class), started()), // + event(test("test"), started()), // + event(test("test"), finishedSuccessfully()), // + event(container(SeveralTestCase.class), finishedSuccessfully()), // + event(engine(), finishedSuccessfully())); + + assertEquals(Arrays.asList( // + "convertBeforeAll", "rethrowBeforeAll", "swallowBeforeAll", // + "convertBeforeAll", "rethrowBeforeAll", "swallowBeforeAll", // + "convertTest", "rethrowTest", "swallowTest", // + "convertAfterAll", "rethrowAfterAll", "swallowAfterAll", // + "convertAfterAll", "rethrowAfterAll", "swallowAfterAll"), // handlerCalls); } From 1adcc3c6b9a1e6d72b693a67de212441c13bd90d Mon Sep 17 00:00:00 2001 From: phoenix384 Date: Wed, 8 Aug 2018 18:48:06 +0200 Subject: [PATCH 18/21] Fix formatting --- .../extension/BeforeAndAfterEachExceptionHandlerTests.java | 1 + 1 file changed, 1 insertion(+) diff --git a/junit-jupiter-engine/src/test/java/org/junit/jupiter/engine/extension/BeforeAndAfterEachExceptionHandlerTests.java b/junit-jupiter-engine/src/test/java/org/junit/jupiter/engine/extension/BeforeAndAfterEachExceptionHandlerTests.java index 64af5f262713..5944ce57a991 100644 --- a/junit-jupiter-engine/src/test/java/org/junit/jupiter/engine/extension/BeforeAndAfterEachExceptionHandlerTests.java +++ b/junit-jupiter-engine/src/test/java/org/junit/jupiter/engine/extension/BeforeAndAfterEachExceptionHandlerTests.java @@ -95,6 +95,7 @@ void exceptionHandlerConvertsException() { event(test("testConvert"), finishedWithFailure(allOf(isA(RuntimeException.class), message("unchecked")))), // event(container(ATestCase.class), finishedSuccessfully()), // event(engine(), finishedSuccessfully())); + assertEquals(Arrays.asList("convertBeforeEach", "convertAfterEach", "convertAfterEach"), handlerCalls); } @Test From 6babbfae93a81762d5b258e1dc4b19c2400cc33f Mon Sep 17 00:00:00 2001 From: phoenix384 Date: Wed, 8 Aug 2018 19:38:42 +0200 Subject: [PATCH 19/21] Fix formatting --- ...eforeAndAfterAllExceptionHandlerTests.java | 22 +++++++++++-------- 1 file changed, 13 insertions(+), 9 deletions(-) diff --git a/junit-jupiter-engine/src/test/java/org/junit/jupiter/engine/extension/BeforeAndAfterAllExceptionHandlerTests.java b/junit-jupiter-engine/src/test/java/org/junit/jupiter/engine/extension/BeforeAndAfterAllExceptionHandlerTests.java index fd01d904a82a..e48365232ef3 100644 --- a/junit-jupiter-engine/src/test/java/org/junit/jupiter/engine/extension/BeforeAndAfterAllExceptionHandlerTests.java +++ b/junit-jupiter-engine/src/test/java/org/junit/jupiter/engine/extension/BeforeAndAfterAllExceptionHandlerTests.java @@ -62,7 +62,8 @@ void exceptionHandlerRethrowsException() { assertRecordedExecutionEventsContainsExactly(eventRecorder.getExecutionEvents(), // event(engine(), started()), // event(container(RethrowTestCase.class), started()), // - event(container(RethrowTestCase.class), finishedWithFailure(allOf(isA(IOException.class), message("checked")))), // + event(container(RethrowTestCase.class), + finishedWithFailure(allOf(isA(IOException.class), message("checked")))), // event(engine(), finishedSuccessfully())); assertEquals(Arrays.asList("rethrowBeforeAll", "rethrowAfterAll", "rethrowAfterAll"), handlerCalls); @@ -81,7 +82,9 @@ void exceptionHandlerSwallowsException() { event(container(SwallowTestCase.class), finishedSuccessfully()), // event(engine(), finishedSuccessfully())); - assertEquals(Arrays.asList("swallowBeforeAll", "swallowBeforeAll", "swallowTest", "swallowAfterAll", "swallowAfterAll"), handlerCalls); + assertEquals( + Arrays.asList("swallowBeforeAll", "swallowBeforeAll", "swallowTest", "swallowAfterAll", "swallowAfterAll"), + handlerCalls); } @Test @@ -92,7 +95,8 @@ void exceptionHandlerConvertsException() { assertRecordedExecutionEventsContainsExactly(eventRecorder.getExecutionEvents(), // event(engine(), started()), // event(container(ConvertTestCase.class), started()), // - event(container(ConvertTestCase.class), finishedWithFailure(allOf(isA(RuntimeException.class), message("unchecked")))), // + event(container(ConvertTestCase.class), + finishedWithFailure(allOf(isA(RuntimeException.class), message("unchecked")))), // event(engine(), finishedSuccessfully())); assertEquals(Arrays.asList("convertBeforeAll", "convertAfterAll", "convertAfterAll"), handlerCalls); @@ -112,12 +116,12 @@ void severalHandlersAreCalledInOrder() { event(engine(), finishedSuccessfully())); assertEquals(Arrays.asList( // - "convertBeforeAll", "rethrowBeforeAll", "swallowBeforeAll", // - "convertBeforeAll", "rethrowBeforeAll", "swallowBeforeAll", // - "convertTest", "rethrowTest", "swallowTest", // - "convertAfterAll", "rethrowAfterAll", "swallowAfterAll", // - "convertAfterAll", "rethrowAfterAll", "swallowAfterAll"), // - handlerCalls); + "convertBeforeAll", "rethrowBeforeAll", "swallowBeforeAll", // + "convertBeforeAll", "rethrowBeforeAll", "swallowBeforeAll", // + "convertTest", "rethrowTest", "swallowTest", // + "convertAfterAll", "rethrowAfterAll", "swallowAfterAll", // + "convertAfterAll", "rethrowAfterAll", "swallowAfterAll"), // + handlerCalls); } // ------------------------------------------------------------------- From 1584f4adfae8438275d030af79e41d31117d439a Mon Sep 17 00:00:00 2001 From: phoenix384 Date: Wed, 8 Aug 2018 19:53:49 +0200 Subject: [PATCH 20/21] Fix formatting --- .../extension/BeforeAndAfterEachExceptionHandlerTests.java | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/junit-jupiter-engine/src/test/java/org/junit/jupiter/engine/extension/BeforeAndAfterEachExceptionHandlerTests.java b/junit-jupiter-engine/src/test/java/org/junit/jupiter/engine/extension/BeforeAndAfterEachExceptionHandlerTests.java index 5944ce57a991..4355805a0b57 100644 --- a/junit-jupiter-engine/src/test/java/org/junit/jupiter/engine/extension/BeforeAndAfterEachExceptionHandlerTests.java +++ b/junit-jupiter-engine/src/test/java/org/junit/jupiter/engine/extension/BeforeAndAfterEachExceptionHandlerTests.java @@ -68,6 +68,7 @@ void exceptionHandlerRethrowsException() { assertEquals(Arrays.asList("rethrowBeforeEach", "rethrowAfterEach", "rethrowAfterEach"), handlerCalls); } + @Test void exceptionHandlerSwallowsException() { LauncherDiscoveryRequest request = request().selectors(selectMethod(ATestCase.class, "testSwallow")).build(); @@ -81,8 +82,11 @@ void exceptionHandlerSwallowsException() { event(container(ATestCase.class), finishedSuccessfully()), // event(engine(), finishedSuccessfully())); - assertEquals(Arrays.asList("swallowBeforeEach", "swallowBeforeEach", "swallowTest", "swallowAfterEach", "swallowAfterEach"), handlerCalls); + assertEquals(Arrays.asList( // + "swallowBeforeEach", "swallowBeforeEach", "swallowTest", "swallowAfterEach", "swallowAfterEach"), // + handlerCalls); } + @Test void exceptionHandlerConvertsException() { LauncherDiscoveryRequest request = request().selectors(selectMethod(ATestCase.class, "testConvert")).build(); @@ -98,6 +102,7 @@ void exceptionHandlerConvertsException() { assertEquals(Arrays.asList("convertBeforeEach", "convertAfterEach", "convertAfterEach"), handlerCalls); } + @Test void severalHandlersAreCalledInOrder() { LauncherDiscoveryRequest request = request().selectors(selectMethod(ATestCase.class, "testSeveral")).build(); From c0f2678b8e84fadabc56eb9b9eae1e4eab1d0c0e Mon Sep 17 00:00:00 2001 From: phoenix384 Date: Wed, 8 Aug 2018 19:55:38 +0200 Subject: [PATCH 21/21] Fix formatting --- .../extension/BeforeAndAfterAllExceptionHandlerTests.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/junit-jupiter-engine/src/test/java/org/junit/jupiter/engine/extension/BeforeAndAfterAllExceptionHandlerTests.java b/junit-jupiter-engine/src/test/java/org/junit/jupiter/engine/extension/BeforeAndAfterAllExceptionHandlerTests.java index e48365232ef3..e44a90def80a 100644 --- a/junit-jupiter-engine/src/test/java/org/junit/jupiter/engine/extension/BeforeAndAfterAllExceptionHandlerTests.java +++ b/junit-jupiter-engine/src/test/java/org/junit/jupiter/engine/extension/BeforeAndAfterAllExceptionHandlerTests.java @@ -63,7 +63,7 @@ void exceptionHandlerRethrowsException() { event(engine(), started()), // event(container(RethrowTestCase.class), started()), // event(container(RethrowTestCase.class), - finishedWithFailure(allOf(isA(IOException.class), message("checked")))), // + finishedWithFailure(allOf(isA(IOException.class), message("checked")))), // event(engine(), finishedSuccessfully())); assertEquals(Arrays.asList("rethrowBeforeAll", "rethrowAfterAll", "rethrowAfterAll"), handlerCalls); @@ -96,7 +96,7 @@ void exceptionHandlerConvertsException() { event(engine(), started()), // event(container(ConvertTestCase.class), started()), // event(container(ConvertTestCase.class), - finishedWithFailure(allOf(isA(RuntimeException.class), message("unchecked")))), // + finishedWithFailure(allOf(isA(RuntimeException.class), message("unchecked")))), // event(engine(), finishedSuccessfully())); assertEquals(Arrays.asList("convertBeforeAll", "convertAfterAll", "convertAfterAll"), handlerCalls);