Consistently use switch expressions

sbrannen · sbrannen · commit 037d4df2881e · 2025-05-30T12:55:45.000+02:00
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
@@ -285,15 +285,9 @@ public void nodeFinished(JupiterEngineExecutionContext context, TestDescriptor d
 
 		invokeTestWatchers(context, true, watcher -> {
 			switch (status) {
-				case SUCCESSFUL:
-					watcher.testSuccessful(extensionContext);
-					break;
-				case ABORTED:
-					watcher.testAborted(extensionContext, result.getThrowable().orElse(null));
-					break;
-				case FAILED:
-					watcher.testFailed(extensionContext, result.getThrowable().orElse(null));
-					break;
+				case SUCCESSFUL -> watcher.testSuccessful(extensionContext);
+				case ABORTED -> watcher.testAborted(extensionContext, result.getThrowable().orElse(null));
+				case FAILED -> watcher.testFailed(extensionContext, result.getThrowable().orElse(null));
 			}
 		});
 	}
diff --git a/junit-jupiter-params/src/main/java/org/junit/jupiter/params/ArgumentCountValidationMode.java b/junit-jupiter-params/src/main/java/org/junit/jupiter/params/ArgumentCountValidationMode.java
@@ -55,5 +55,6 @@ public enum ArgumentCountValidationMode {
 	 * <p>When there are more arguments provided than declared by the
 	 * parameterized class or method, this raises an error.
 	 */
-	STRICT,
+	STRICT
+
 }
diff --git a/junit-jupiter-params/src/main/java/org/junit/jupiter/params/ArgumentCountValidator.java b/junit-jupiter-params/src/main/java/org/junit/jupiter/params/ArgumentCountValidator.java
@@ -40,10 +40,9 @@ class ArgumentCountValidator {
 	void validate(ExtensionContext extensionContext) {
 		ArgumentCountValidationMode argumentCountValidationMode = getArgumentCountValidationMode(extensionContext);
 		switch (argumentCountValidationMode) {
-			case DEFAULT:
-			case NONE:
-				return;
-			case STRICT:
+			case DEFAULT, NONE -> {
+			}
+			case STRICT -> {
 				int consumedCount = this.declarationContext.getResolverFacade().determineConsumedArgumentCount(
 					this.arguments);
 				int totalCount = this.arguments.getTotalLength();
@@ -53,10 +52,9 @@ void validate(ExtensionContext extensionContext) {
 						pluralize(consumedCount, "parameter", "parameters"), pluralize(totalCount, "was", "were"),
 						totalCount, pluralize(totalCount, "argument", "arguments"),
 						Arrays.toString(this.arguments.getAllPayloads())));
-				break;
-			default:
-				throw new ExtensionConfigurationException(
-					"Unsupported argument count validation mode: " + argumentCountValidationMode);
+			}
+			default -> throw new ExtensionConfigurationException(
+				"Unsupported argument count validation mode: " + argumentCountValidationMode);
 		}
 	}
 
diff --git a/junit-platform-launcher/src/main/java/org/junit/platform/launcher/listeners/SummaryGeneratingListener.java b/junit-platform-launcher/src/main/java/org/junit/platform/launcher/listeners/SummaryGeneratingListener.java
@@ -113,27 +113,25 @@ public void executionFinished(TestIdentifier testIdentifier, TestExecutionResult
 
 		switch (testExecutionResult.getStatus()) {
 
-			case SUCCESSFUL: {
+			case SUCCESSFUL -> {
 				if (testIdentifier.isContainer()) {
 					summary.containersSucceeded.incrementAndGet();
 				}
 				if (testIdentifier.isTest()) {
 					summary.testsSucceeded.incrementAndGet();
 				}
-				break;
 			}
 
-			case ABORTED: {
+			case ABORTED -> {
 				if (testIdentifier.isContainer()) {
 					summary.containersAborted.incrementAndGet();
 				}
 				if (testIdentifier.isTest()) {
 					summary.testsAborted.incrementAndGet();
 				}
-				break;
 			}
 
-			case FAILED: {
+			case FAILED -> {
 				if (testIdentifier.isContainer()) {
 					summary.containersFailed.incrementAndGet();
 				}
@@ -142,12 +140,10 @@ public void executionFinished(TestIdentifier testIdentifier, TestExecutionResult
 				}
 				testExecutionResult.getThrowable().ifPresent(
 					throwable -> summary.addFailure(testIdentifier, throwable));
-				break;
 			}
 
-			default:
-				throw new PreconditionViolationException(
-					"Unsupported execution status:" + testExecutionResult.getStatus());
+			default -> throw new PreconditionViolationException(
+				"Unsupported execution status:" + testExecutionResult.getStatus());
 		}
 	}
 
diff --git a/junit-platform-launcher/src/main/java/org/junit/platform/launcher/listeners/discovery/LoggingLauncherDiscoveryListener.java b/junit-platform-launcher/src/main/java/org/junit/platform/launcher/listeners/discovery/LoggingLauncherDiscoveryListener.java
@@ -69,14 +69,10 @@ public void engineDiscoveryFinished(UniqueId engineId, EngineDiscoveryResult res
 	@Override
 	public void selectorProcessed(UniqueId engineId, DiscoverySelector selector, SelectorResolutionResult result) {
 		switch (result.getStatus()) {
-			case RESOLVED:
-				logger.debug(() -> selector + " was resolved by " + engineId);
-				break;
-			case FAILED:
-				logger.error(result.getThrowable().orElse(null),
-					() -> "Resolution of " + selector + " by " + engineId + " failed");
-				break;
-			case UNRESOLVED:
+			case RESOLVED -> logger.debug(() -> selector + " was resolved by " + engineId);
+			case FAILED -> logger.error(result.getThrowable().orElse(null),
+				() -> "Resolution of " + selector + " by " + engineId + " failed");
+			case UNRESOLVED -> {
 				Consumer<Supplier<String>> loggingConsumer = logger::debug;
 				if (selector instanceof UniqueIdSelector uniqueIdSelector) {
 					UniqueId uniqueId = uniqueIdSelector.getUniqueId();
@@ -85,7 +81,7 @@ public void selectorProcessed(UniqueId engineId, DiscoverySelector selector, Sel
 					}
 				}
 				loggingConsumer.accept(() -> selector + " could not be resolved by " + engineId);
-				break;
+			}
 		}
 	}
 
diff --git a/junit-platform-testkit/src/main/java/org/junit/platform/testkit/engine/Executions.java b/junit-platform-testkit/src/main/java/org/junit/platform/testkit/engine/Executions.java
@@ -254,11 +254,8 @@ private static List<Execution> createExecutions(List<Event> events) {
 
 		for (Event event : events) {
 			switch (event.getType()) {
-				case STARTED: {
-					executionStarts.put(event.getTestDescriptor(), event.getTimestamp());
-					break;
-				}
-				case SKIPPED: {
+				case STARTED -> executionStarts.put(event.getTestDescriptor(), event.getTimestamp());
+				case SKIPPED -> {
 					// Based on the Javadoc for EngineExecutionListener.executionSkipped(...),
 					// a skipped descriptor must never be reported as started or finished,
 					// but just in case a TestEngine does not adhere to that contract, we
@@ -271,9 +268,8 @@ private static List<Execution> createExecutions(List<Event> events) {
 					Execution skippedEvent = Execution.skipped(event.getTestDescriptor(), timestamp, timestamp,
 						event.getRequiredPayload(String.class));
 					executions.add(skippedEvent);
-					break;
 				}
-				case FINISHED: {
+				case FINISHED -> {
 					Instant startInstant = executionStarts.remove(event.getTestDescriptor());
 					Instant endInstant = event.getTimestamp();
 
@@ -285,11 +281,9 @@ private static List<Execution> createExecutions(List<Event> events) {
 							endInstant, event.getRequiredPayload(TestExecutionResult.class));
 						executions.add(finishedEvent);
 					}
-					break;
 				}
-				default: {
+				default -> {
 					// Ignore other events
-					break;
 				}
 			}
 		}
diff --git a/jupiter-tests/src/test/java/org/junit/jupiter/engine/extension/RepeatedTestTests.java b/jupiter-tests/src/test/java/org/junit/jupiter/engine/extension/RepeatedTestTests.java
@@ -136,15 +136,13 @@ public LifecycleMethodTests(RepetitionInfo repetitionInfo) {
 		@AfterEach
 		void beforeAndAfterEach(TestInfo testInfo, RepetitionInfo repetitionInfo) {
 			switch (testInfo.getTestMethod().get().getName()) {
-				case "repeatedOnce": {
+				case "repeatedOnce" -> {
 					assertThat(repetitionInfo.getCurrentRepetition()).isEqualTo(1);
 					assertThat(repetitionInfo.getTotalRepetitions()).isEqualTo(1);
-					break;
 				}
-				case "repeatedFortyTwoTimes": {
+				case "repeatedFortyTwoTimes" -> {
 					assertThat(repetitionInfo.getCurrentRepetition()).isBetween(1, 42);
 					assertThat(repetitionInfo.getTotalRepetitions()).isEqualTo(42);
-					break;
 				}
 			}
 		}
diff --git a/platform-tooling-support-tests/src/test/java/platform/tooling/support/tests/MavenRepoProxy.java b/platform-tooling-support-tests/src/test/java/platform/tooling/support/tests/MavenRepoProxy.java
@@ -40,19 +40,16 @@ private MavenRepoProxy(String proxiedUrl, int port) throws IOException {
 		httpServer.createContext("/", exchange -> {
 			try (exchange) {
 				switch (exchange.getRequestMethod()) {
-					case "HEAD":
-					case "GET":
-						if (FORBIDDEN_PATHS.stream().anyMatch(
-							it -> exchange.getRequestURI().getPath().startsWith(it))) {
+					case "HEAD", "GET" -> {
+						if (FORBIDDEN_PATHS.stream().anyMatch(exchange.getRequestURI().getPath()::startsWith)) {
 							exchange.sendResponseHeaders(404, -1);
 							break;
 						}
 						var redirectUrl = proxiedUrl + exchange.getRequestURI().getPath();
 						exchange.getResponseHeaders().add("Location", redirectUrl);
 						exchange.sendResponseHeaders(302, -1);
-						break;
-					default:
-						exchange.sendResponseHeaders(405, -1);
+					}
+					default -> exchange.sendResponseHeaders(405, -1);
 				}
 			}
 			catch (Exception e) {

Original file line number	Diff line number	Diff line change
`@@ -55,5 +55,6 @@ public enum ArgumentCountValidationMode {`
`55`	`55`	`* <p>When there are more arguments provided than declared by the`
`56`	`56`	`* parameterized class or method, this raises an error.`
`57`	`57`	`*/`
`58`		`- STRICT,`
	`58`	`+ STRICT`
	`59`	`+`
`59`	`60`	`}`
Original file line number	Diff line number	Diff line change
`@@ -113,27 +113,25 @@ public void executionFinished(TestIdentifier testIdentifier, TestExecutionResult`
`113`	`113`
`114`	`114`	`switch (testExecutionResult.getStatus()) {`
`115`	`115`
`116`		`- case SUCCESSFUL: {`
	`116`	`+ case SUCCESSFUL -> {`
`117`	`117`	`if (testIdentifier.isContainer()) {`
`118`	`118`	`summary.containersSucceeded.incrementAndGet();`
`119`	`119`	`}`
`120`	`120`	`if (testIdentifier.isTest()) {`
`121`	`121`	`summary.testsSucceeded.incrementAndGet();`
`122`	`122`	`}`
`123`		`- break;`
`124`	`123`	`}`
`125`	`124`
`126`		`- case ABORTED: {`
	`125`	`+ case ABORTED -> {`
`127`	`126`	`if (testIdentifier.isContainer()) {`
`128`	`127`	`summary.containersAborted.incrementAndGet();`
`129`	`128`	`}`
`130`	`129`	`if (testIdentifier.isTest()) {`
`131`	`130`	`summary.testsAborted.incrementAndGet();`
`132`	`131`	`}`
`133`		`- break;`
`134`	`132`	`}`
`135`	`133`
`136`		`- case FAILED: {`
	`134`	`+ case FAILED -> {`
`137`	`135`	`if (testIdentifier.isContainer()) {`
`138`	`136`	`summary.containersFailed.incrementAndGet();`
`139`	`137`	`}`
`@@ -142,12 +140,10 @@ public void executionFinished(TestIdentifier testIdentifier, TestExecutionResult`
`142`	`140`	`}`
`143`	`141`	`testExecutionResult.getThrowable().ifPresent(`
`144`	`142`	`throwable -> summary.addFailure(testIdentifier, throwable));`
`145`		`- break;`
`146`	`143`	`}`
`147`	`144`
`148`		`- default:`
`149`		`- throw new PreconditionViolationException(`
`150`		`- "Unsupported execution status:" + testExecutionResult.getStatus());`
	`145`	`+ default -> throw new PreconditionViolationException(`
	`146`	`+ "Unsupported execution status:" + testExecutionResult.getStatus());`
`151`	`147`	`}`
`152`	`148`	`}`
`153`	`149`
Original file line number	Diff line number	Diff line change
`@@ -254,11 +254,8 @@ private static List<Execution> createExecutions(List<Event> events) {`
`254`	`254`
`255`	`255`	`for (Event event : events) {`
`256`	`256`	`switch (event.getType()) {`
`257`		`- case STARTED: {`
`258`		`- executionStarts.put(event.getTestDescriptor(), event.getTimestamp());`
`259`		`- break;`
`260`		`- }`
`261`		`- case SKIPPED: {`
	`257`	`+ case STARTED -> executionStarts.put(event.getTestDescriptor(), event.getTimestamp());`
	`258`	`+ case SKIPPED -> {`
`262`	`259`	`// Based on the Javadoc for EngineExecutionListener.executionSkipped(...),`
`263`	`260`	`// a skipped descriptor must never be reported as started or finished,`
`264`	`261`	`// but just in case a TestEngine does not adhere to that contract, we`
`@@ -271,9 +268,8 @@ private static List<Execution> createExecutions(List<Event> events) {`
`271`	`268`	`Execution skippedEvent = Execution.skipped(event.getTestDescriptor(), timestamp, timestamp,`
`272`	`269`	`event.getRequiredPayload(String.class));`
`273`	`270`	`executions.add(skippedEvent);`
`274`		`- break;`
`275`	`271`	`}`
`276`		`- case FINISHED: {`
	`272`	`+ case FINISHED -> {`
`277`	`273`	`Instant startInstant = executionStarts.remove(event.getTestDescriptor());`
`278`	`274`	`Instant endInstant = event.getTimestamp();`
`279`	`275`
`@@ -285,11 +281,9 @@ private static List<Execution> createExecutions(List<Event> events) {`
`285`	`281`	`endInstant, event.getRequiredPayload(TestExecutionResult.class));`
`286`	`282`	`executions.add(finishedEvent);`
`287`	`283`	`}`
`288`		`- break;`
`289`	`284`	`}`
`290`		`- default: {`
	`285`	`+ default -> {`
`291`	`286`	`// Ignore other events`
`292`		`- break;`
`293`	`287`	`}`
`294`	`288`	`}`
`295`	`289`	`}`
Original file line number	Diff line number	Diff line change
`@@ -136,15 +136,13 @@ public LifecycleMethodTests(RepetitionInfo repetitionInfo) {`
`136`	`136`	`@AfterEach`
`137`	`137`	`void beforeAndAfterEach(TestInfo testInfo, RepetitionInfo repetitionInfo) {`
`138`	`138`	`switch (testInfo.getTestMethod().get().getName()) {`
`139`		`- case "repeatedOnce": {`
	`139`	`+ case "repeatedOnce" -> {`
`140`	`140`	`assertThat(repetitionInfo.getCurrentRepetition()).isEqualTo(1);`
`141`	`141`	`assertThat(repetitionInfo.getTotalRepetitions()).isEqualTo(1);`
`142`		`- break;`
`143`	`142`	`}`
`144`		`- case "repeatedFortyTwoTimes": {`
	`143`	`+ case "repeatedFortyTwoTimes" -> {`
`145`	`144`	`assertThat(repetitionInfo.getCurrentRepetition()).isBetween(1, 42);`
`146`	`145`	`assertThat(repetitionInfo.getTotalRepetitions()).isEqualTo(42);`
`147`		`- break;`
`148`	`146`	`}`
`149`	`147`	`}`
`150`	`148`	`}`