Use enhanced switch expressions

marcphilipp · marcphilipp · commit 86c9ff534314 · 2025-05-24T19:45:29.000+02:00
diff --git a/junit-jupiter-engine/src/main/java/org/junit/jupiter/engine/descriptor/AbstractExtensionContext.java b/junit-jupiter-engine/src/main/java/org/junit/jupiter/engine/descriptor/AbstractExtensionContext.java
@@ -221,16 +221,11 @@ public Store getStore(Namespace namespace) {
 
 	@Override
 	public Store getStore(StoreScope scope, Namespace namespace) {
-		// TODO [#4246] Use switch expression
-		switch (scope) {
-			case LAUNCHER_SESSION:
-				return launcherStoreFacade.getSessionLevelStore(namespace);
-			case EXECUTION_REQUEST:
-				return launcherStoreFacade.getRequestLevelStore(namespace);
-			case EXTENSION_CONTEXT:
-				return getStore(namespace);
-		}
-		throw new JUnitException("Unknown StoreScope: " + scope);
+		return switch (scope) {
+			case LAUNCHER_SESSION -> launcherStoreFacade.getSessionLevelStore(namespace);
+			case EXECUTION_REQUEST -> launcherStoreFacade.getRequestLevelStore(namespace);
+			case EXTENSION_CONTEXT -> getStore(namespace);
+		};
 	}
 
 	@Override
@@ -267,12 +262,9 @@ public <E extends Extension> List<E> getExtensions(Class<E> extensionType) {
 	protected abstract Node.ExecutionMode getPlatformExecutionMode();
 
 	private ExecutionMode toJupiterExecutionMode(Node.ExecutionMode mode) {
-		switch (mode) {
-			case CONCURRENT:
-				return ExecutionMode.CONCURRENT;
-			case SAME_THREAD:
-				return ExecutionMode.SAME_THREAD;
-		}
-		throw new JUnitException("Unknown ExecutionMode: " + mode);
+		return switch (mode) {
+			case CONCURRENT -> ExecutionMode.CONCURRENT;
+			case SAME_THREAD -> ExecutionMode.SAME_THREAD;
+		};
 	}
 }
diff --git a/junit-jupiter-engine/src/main/java/org/junit/jupiter/engine/descriptor/ExclusiveResourceCollector.java b/junit-jupiter-engine/src/main/java/org/junit/jupiter/engine/descriptor/ExclusiveResourceCollector.java
@@ -26,7 +26,6 @@
 import org.junit.jupiter.api.parallel.ResourceLock;
 import org.junit.jupiter.api.parallel.ResourceLockTarget;
 import org.junit.jupiter.api.parallel.ResourceLocksProvider;
-import org.junit.platform.commons.JUnitException;
 import org.junit.platform.commons.util.ReflectionUtils;
 import org.junit.platform.commons.util.StringUtils;
 import org.junit.platform.engine.support.hierarchical.ExclusiveResource;
@@ -113,13 +112,10 @@ private List<ResourceLocksProvider> getProviders() {
 		}
 
 		private static ExclusiveResource.LockMode toLockMode(ResourceAccessMode mode) {
-			switch (mode) {
-				case READ:
-					return ExclusiveResource.LockMode.READ;
-				case READ_WRITE:
-					return ExclusiveResource.LockMode.READ_WRITE;
-			}
-			throw new JUnitException("Unknown ResourceAccessMode: " + mode);
+			return switch (mode) {
+				case READ -> ExclusiveResource.LockMode.READ;
+				case READ_WRITE -> ExclusiveResource.LockMode.READ_WRITE;
+			};
 		}
 	}
 }
diff --git a/junit-jupiter-engine/src/main/java/org/junit/jupiter/engine/descriptor/JupiterTestDescriptor.java b/junit-jupiter-engine/src/main/java/org/junit/jupiter/engine/descriptor/JupiterTestDescriptor.java
@@ -41,7 +41,6 @@
 import org.junit.jupiter.engine.execution.ConditionEvaluator;
 import org.junit.jupiter.engine.execution.JupiterEngineExecutionContext;
 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.UnrecoverableExceptions;
 import org.junit.platform.engine.DiscoveryIssue;
@@ -171,13 +170,10 @@ Optional<ExecutionMode> getExecutionModeFromAnnotation(AnnotatedElement element)
 	}
 
 	public static ExecutionMode toExecutionMode(org.junit.jupiter.api.parallel.ExecutionMode mode) {
-		switch (mode) {
-			case CONCURRENT:
-				return ExecutionMode.CONCURRENT;
-			case SAME_THREAD:
-				return ExecutionMode.SAME_THREAD;
-		}
-		throw new JUnitException("Unknown ExecutionMode: " + mode);
+		return switch (mode) {
+			case CONCURRENT -> ExecutionMode.CONCURRENT;
+			case SAME_THREAD -> ExecutionMode.SAME_THREAD;
+		};
 	}
 
 	@Override
diff --git a/junit-jupiter-engine/src/main/java/org/junit/jupiter/engine/discovery/ClassSelectorResolver.java b/junit-jupiter-engine/src/main/java/org/junit/jupiter/engine/discovery/ClassSelectorResolver.java
@@ -125,31 +125,29 @@ else if (isInnerClass(nestedClass) && predicates.looksLikeIntendedTestClass(nest
 	public Resolution resolve(UniqueIdSelector selector, Context context) {
 		UniqueId uniqueId = selector.getUniqueId();
 		UniqueId.Segment lastSegment = uniqueId.getLastSegment();
-		if (ClassTestDescriptor.SEGMENT_TYPE.equals(lastSegment.getType())) {
-			return resolveStandaloneClassUniqueId(context, lastSegment, __ -> true, this::newClassTestDescriptor);
-		}
-		if (ClassTemplateTestDescriptor.STANDALONE_CLASS_SEGMENT_TYPE.equals(lastSegment.getType())) {
-			return resolveStandaloneClassUniqueId(context, lastSegment, this.predicates.isAnnotatedWithClassTemplate,
-				this::newClassTemplateTestDescriptor);
-		}
-		if (NestedClassTestDescriptor.SEGMENT_TYPE.equals(lastSegment.getType())) {
-			return resolveNestedClassUniqueId(context, uniqueId, __ -> true, this::newNestedClassTestDescriptor);
-		}
-		if (ClassTemplateTestDescriptor.NESTED_CLASS_SEGMENT_TYPE.equals(lastSegment.getType())) {
-			return resolveNestedClassUniqueId(context, uniqueId, this.predicates.isAnnotatedWithClassTemplate,
-				this::newNestedClassTemplateTestDescriptor);
-		}
-		if (ClassTemplateInvocationTestDescriptor.SEGMENT_TYPE.equals(lastSegment.getType())) {
-			Optional<ClassTemplateInvocationTestDescriptor> testDescriptor = context.addToParent(
-				() -> selectUniqueId(uniqueId.removeLastSegment()), parent -> {
-					int index = Integer.parseInt(lastSegment.getValue().substring(1));
-					return Optional.of(newDummyClassTemplateInvocationTestDescriptor(parent, index));
-				});
-			return toInvocationMatch(testDescriptor) //
-					.map(Resolution::match) //
-					.orElse(unresolved());
-		}
-		return unresolved();
+		return switch (lastSegment.getType()) {
+			case ClassTestDescriptor.SEGMENT_TYPE -> //
+					resolveStandaloneClassUniqueId(context, lastSegment, __ -> true, this::newClassTestDescriptor);
+			case ClassTemplateTestDescriptor.STANDALONE_CLASS_SEGMENT_TYPE -> //
+					resolveStandaloneClassUniqueId(context, lastSegment, this.predicates.isAnnotatedWithClassTemplate,
+						this::newClassTemplateTestDescriptor);
+			case NestedClassTestDescriptor.SEGMENT_TYPE -> //
+					resolveNestedClassUniqueId(context, uniqueId, __ -> true, this::newNestedClassTestDescriptor);
+			case ClassTemplateTestDescriptor.NESTED_CLASS_SEGMENT_TYPE -> //
+					resolveNestedClassUniqueId(context, uniqueId, this.predicates.isAnnotatedWithClassTemplate,
+						this::newNestedClassTemplateTestDescriptor);
+			case ClassTemplateInvocationTestDescriptor.SEGMENT_TYPE -> {
+				Optional<ClassTemplateInvocationTestDescriptor> testDescriptor = context.addToParent(
+					() -> selectUniqueId(uniqueId.removeLastSegment()), parent -> {
+						int index = Integer.parseInt(lastSegment.getValue().substring(1));
+						return Optional.of(newDummyClassTemplateInvocationTestDescriptor(parent, index));
+					});
+				yield toInvocationMatch(testDescriptor) //
+						.map(Resolution::match) //
+						.orElse(unresolved());
+			}
+			default -> unresolved();
+		};
 	}
 
 	@Override
diff --git a/junit-jupiter-engine/src/main/java/org/junit/jupiter/engine/extension/TimeoutDuration.java b/junit-jupiter-engine/src/main/java/org/junit/jupiter/engine/extension/TimeoutDuration.java
@@ -76,23 +76,15 @@ public Duration toDuration() {
 	}
 
 	private ChronoUnit toChronoUnit() {
-		switch (unit) {
-			case NANOSECONDS:
-				return ChronoUnit.NANOS;
-			case MICROSECONDS:
-				return ChronoUnit.MICROS;
-			case MILLISECONDS:
-				return ChronoUnit.MILLIS;
-			case SECONDS:
-				return ChronoUnit.SECONDS;
-			case MINUTES:
-				return ChronoUnit.MINUTES;
-			case HOURS:
-				return ChronoUnit.HOURS;
-			case DAYS:
-				return ChronoUnit.DAYS;
-			default:
-				throw new JUnitException("Could not map TimeUnit " + unit + " to ChronoUnit");
-		}
+		return switch (unit) {
+			case NANOSECONDS -> ChronoUnit.NANOS;
+			case MICROSECONDS -> ChronoUnit.MICROS;
+			case MILLISECONDS -> ChronoUnit.MILLIS;
+			case SECONDS -> ChronoUnit.SECONDS;
+			case MINUTES -> ChronoUnit.MINUTES;
+			case HOURS -> ChronoUnit.HOURS;
+			case DAYS -> ChronoUnit.DAYS;
+			default -> throw new JUnitException("Could not map TimeUnit " + unit + " to ChronoUnit");
+		};
 	}
 }
diff --git a/junit-jupiter-engine/src/main/java/org/junit/jupiter/engine/extension/TimeoutExtension.java b/junit-jupiter-engine/src/main/java/org/junit/jupiter/engine/extension/TimeoutExtension.java
@@ -221,16 +221,12 @@ private boolean isTimeoutDisabled(ExtensionContext extensionContext) {
 	 * Determine if timeouts are disabled for the supplied mode.
 	 */
 	private boolean isTimeoutDisabled(String mode) {
-		switch (mode) {
-			case ENABLED_MODE_VALUE:
-				return false;
-			case DISABLED_MODE_VALUE:
-				return true;
-			case DISABLED_ON_DEBUG_MODE_VALUE:
-				return RuntimeUtils.isDebugMode();
-			default:
-				throw new ExtensionConfigurationException("Unsupported timeout mode: " + mode);
-		}
+		return switch (mode) {
+			case ENABLED_MODE_VALUE -> false;
+			case DISABLED_MODE_VALUE -> true;
+			case DISABLED_ON_DEBUG_MODE_VALUE -> RuntimeUtils.isDebugMode();
+			default -> throw new ExtensionConfigurationException("Unsupported timeout mode: " + mode);
+		};
 	}
 
 	@FunctionalInterface
diff --git a/junit-jupiter-params/src/main/java/org/junit/jupiter/params/ParameterizedClassInvocationContext.java b/junit-jupiter-params/src/main/java/org/junit/jupiter/params/ParameterizedClassInvocationContext.java
@@ -22,7 +22,6 @@
 import org.junit.jupiter.api.extension.ExtensionContext;
 import org.junit.jupiter.params.ParameterizedClassContext.InjectionType;
 import org.junit.jupiter.params.provider.Arguments;
-import org.junit.platform.commons.JUnitException;
 import org.junit.platform.commons.util.Preconditions;
 
 class ParameterizedClassInvocationContext extends ParameterizedInvocationContext<ParameterizedClassContext>
@@ -53,13 +52,10 @@ public void prepareInvocation(ExtensionContext context) {
 
 	private Extension createParameterInjector() {
 		InjectionType injectionType = this.declarationContext.getInjectionType();
-		switch (injectionType) {
-			case CONSTRUCTOR:
-				return createExtensionForConstructorInjection();
-			case FIELDS:
-				return createExtensionForFieldInjection();
-		}
-		throw new JUnitException("Unsupported injection type: " + injectionType);
+		return switch (injectionType) {
+			case CONSTRUCTOR -> createExtensionForConstructorInjection();
+			case FIELDS -> createExtensionForFieldInjection();
+		};
 	}
 
 	private ClassTemplateConstructorParameterResolver createExtensionForConstructorInjection() {
@@ -72,15 +68,12 @@ private ClassTemplateConstructorParameterResolver createExtensionForConstructorI
 	private Extension createExtensionForFieldInjection() {
 		ResolverFacade resolverFacade = this.declarationContext.getResolverFacade();
 		TestInstance.Lifecycle lifecycle = this.declarationContext.getTestInstanceLifecycle();
-		switch (lifecycle) {
-			case PER_CLASS:
-				return new BeforeClassTemplateInvocationFieldInjector(resolverFacade, this.arguments,
-					this.invocationIndex, this.resolutionCache);
-			case PER_METHOD:
-				return new InstancePostProcessingClassTemplateFieldInjector(resolverFacade, this.arguments,
-					this.invocationIndex, this.resolutionCache);
-		}
-		throw new JUnitException("Unsupported lifecycle: " + lifecycle);
+		return switch (lifecycle) {
+			case PER_CLASS -> new BeforeClassTemplateInvocationFieldInjector(resolverFacade, this.arguments,
+				this.invocationIndex, this.resolutionCache);
+			case PER_METHOD -> new InstancePostProcessingClassTemplateFieldInjector(resolverFacade, this.arguments,
+				this.invocationIndex, this.resolutionCache);
+		};
 	}
 
 	private Stream<Extension> createLifecycleMethodInvokers() {
diff --git a/junit-platform-console/src/main/java/org/junit/platform/console/options/Theme.java b/junit-platform-console/src/main/java/org/junit/platform/console/options/Theme.java
@@ -116,16 +116,11 @@ public final String skipped() {
 	}
 
 	public final String status(TestExecutionResult result) {
-		switch (result.getStatus()) {
-			case SUCCESSFUL:
-				return successful();
-			case ABORTED:
-				return aborted();
-			case FAILED:
-				return failed();
-			default:
-				return result.getStatus().name();
-		}
+		return switch (result.getStatus()) {
+			case SUCCESSFUL -> successful();
+			case ABORTED -> aborted();
+			case FAILED -> failed();
+		};
 	}
 
 	/**
diff --git a/junit-platform-console/src/main/java/org/junit/platform/console/tasks/ConsoleTestExecutor.java b/junit-platform-console/src/main/java/org/junit/platform/console/tasks/ConsoleTestExecutor.java
@@ -180,21 +180,16 @@ private SummaryGeneratingListener registerListeners(PrintWriter out, Optional<Pa
 	private Optional<DetailsPrintingListener> createDetailsPrintingListener(PrintWriter out) {
 		ColorPalette colorPalette = getColorPalette();
 		Theme theme = outputOptions.getTheme();
-		switch (outputOptions.getDetails()) {
-			case SUMMARY:
-				// summary listener is always created and registered
-				return Optional.empty();
-			case FLAT:
-				return Optional.of(new FlatPrintingListener(out, colorPalette));
-			case TREE:
-				return Optional.of(new TreePrintingListener(out, colorPalette, theme));
-			case VERBOSE:
-				return Optional.of(new VerboseTreePrintingListener(out, colorPalette, 16, theme));
-			case TESTFEED:
-				return Optional.of(new TestFeedPrintingListener(out, colorPalette));
-			default:
-				return Optional.empty();
-		}
+		return switch (outputOptions.getDetails()) {
+			case SUMMARY ->
+					// summary listener is always created and registered
+					Optional.empty();
+			case FLAT -> Optional.of(new FlatPrintingListener(out, colorPalette));
+			case TREE -> Optional.of(new TreePrintingListener(out, colorPalette, theme));
+			case VERBOSE -> Optional.of(new VerboseTreePrintingListener(out, colorPalette, 16, theme));
+			case TESTFEED -> Optional.of(new TestFeedPrintingListener(out, colorPalette));
+			case NONE -> Optional.empty();
+		};
 	}
 
 	private ColorPalette getColorPalette() {
diff --git a/junit-platform-console/src/main/java/org/junit/platform/console/tasks/Style.java b/junit-platform-console/src/main/java/org/junit/platform/console/tasks/Style.java
@@ -21,16 +21,11 @@ enum Style {
 	NONE, SUCCESSFUL, ABORTED, FAILED, SKIPPED, CONTAINER, TEST, DYNAMIC, REPORTED;
 
 	static Style valueOf(TestExecutionResult result) {
-		switch (result.getStatus()) {
-			case SUCCESSFUL:
-				return Style.SUCCESSFUL;
-			case ABORTED:
-				return Style.ABORTED;
-			case FAILED:
-				return Style.FAILED;
-			default:
-				return Style.NONE;
-		}
+		return switch (result.getStatus()) {
+			case SUCCESSFUL -> Style.SUCCESSFUL;
+			case ABORTED -> Style.ABORTED;
+			case FAILED -> Style.FAILED;
+		};
 	}
 
 	static Style valueOf(TestIdentifier testIdentifier) {
diff --git a/junit-platform-engine/src/main/java/org/junit/platform/engine/support/hierarchical/LockManager.java b/junit-platform-engine/src/main/java/org/junit/platform/engine/support/hierarchical/LockManager.java
@@ -71,14 +71,11 @@ private List<ExclusiveResource> toDistinctSortedResources(Collection<ExclusiveRe
 	}
 
 	private ResourceLock toResourceLock(List<ExclusiveResource> resources) {
-		switch (resources.size()) {
-			case 0:
-				return NopLock.INSTANCE;
-			case 1:
-				return toSingleLock(getOnlyElement(resources));
-			default:
-				return new CompositeLock(resources, toLocks(resources));
-		}
+		return switch (resources.size()) {
+			case 0 -> NopLock.INSTANCE;
+			case 1 -> toSingleLock(getOnlyElement(resources));
+			default -> new CompositeLock(resources, toLocks(resources));
+		};
 	}
 
 	private SingleLock toSingleLock(ExclusiveResource resource) {
diff --git a/junit-platform-launcher/src/main/java/org/junit/platform/launcher/TestIdentifier.java b/junit-platform-launcher/src/main/java/org/junit/platform/launcher/TestIdentifier.java
@@ -98,14 +98,11 @@ private TestIdentifier(UniqueId uniqueId, String displayName, @Nullable TestSour
 	}
 
 	private Set<TestTag> copyOf(Set<TestTag> tags) {
-		switch (tags.size()) {
-			case 0:
-				return emptySet();
-			case 1:
-				return singleton(getOnlyElement(tags));
-			default:
-				return new LinkedHashSet<>(tags);
-		}
+		return switch (tags.size()) {
+			case 0 -> emptySet();
+			case 1 -> singleton(getOnlyElement(tags));
+			default -> new LinkedHashSet<>(tags);
+		};
 	}
 
 	/**
diff --git a/junit-platform-launcher/src/main/java/org/junit/platform/launcher/core/DiscoveryIssueNotifier.java b/junit-platform-launcher/src/main/java/org/junit/platform/launcher/core/DiscoveryIssueNotifier.java
@@ -98,17 +98,11 @@ private void logIssues(TestEngine testEngine, List<DiscoveryIssue> issues, Strin
 	}
 
 	private static Consumer<Supplier<String>> logger(Severity severity) {
-		// TODO [#4246] Use switch expression
-		switch (severity) {
-			case INFO:
-				return logger::info;
-			case WARNING:
-				return logger::warn;
-			case ERROR:
-				return logger::error;
-			default:
-				throw new IllegalArgumentException("Unknown severity: " + severity);
-		}
+		return switch (severity) {
+			case INFO -> logger::info;
+			case WARNING -> logger::warn;
+			case ERROR -> logger::error;
+		};
 	}
 
 	private static String formatMessage(TestEngine testEngine, List<DiscoveryIssue> issues, String adjective) {
diff --git a/junit-platform-launcher/src/main/java/org/junit/platform/launcher/core/EngineIdValidator.java b/junit-platform-launcher/src/main/java/org/junit/platform/launcher/core/EngineIdValidator.java
diff --git a/junit-platform-reporting/src/main/java/org/junit/platform/reporting/open/xml/OpenTestReportGeneratingListener.java b/junit-platform-reporting/src/main/java/org/junit/platform/reporting/open/xml/OpenTestReportGeneratingListener.java

Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,6 @@`
`26`	`26`	`import org.junit.jupiter.api.parallel.ResourceLock;`
`27`	`27`	`import org.junit.jupiter.api.parallel.ResourceLockTarget;`
`28`	`28`	`import org.junit.jupiter.api.parallel.ResourceLocksProvider;`
`29`		`-import org.junit.platform.commons.JUnitException;`
`30`	`29`	`import org.junit.platform.commons.util.ReflectionUtils;`
`31`	`30`	`import org.junit.platform.commons.util.StringUtils;`
`32`	`31`	`import org.junit.platform.engine.support.hierarchical.ExclusiveResource;`
`@@ -113,13 +112,10 @@ private List<ResourceLocksProvider> getProviders() {`
`113`	`112`	`}`
`114`	`113`
`115`	`114`	`private static ExclusiveResource.LockMode toLockMode(ResourceAccessMode mode) {`
`116`		`- switch (mode) {`
`117`		`- case READ:`
`118`		`- return ExclusiveResource.LockMode.READ;`
`119`		`- case READ_WRITE:`
`120`		`- return ExclusiveResource.LockMode.READ_WRITE;`
`121`		`- }`
`122`		`- throw new JUnitException("Unknown ResourceAccessMode: " + mode);`
	`115`	`+ return switch (mode) {`
	`116`	`+ case READ -> ExclusiveResource.LockMode.READ;`
	`117`	`+ case READ_WRITE -> ExclusiveResource.LockMode.READ_WRITE;`
	`118`	`+ };`
`123`	`119`	`}`
`124`	`120`	`}`
`125`	`121`	`}`