Fix IDEA-detected nullability problems in main source sets

Author: marcphilipp

documentation/src/main/java/example/util/StringUtils.java

@@ -10,10 +10,14 @@
 
 package example.util;
 
+import static java.util.Objects.requireNonNull;
+
+import org.jspecify.annotations.Nullable;
+
 public class StringUtils {
 
-	public static boolean isPalindrome(String candidate) {
-		int length = candidate.length();
+	public static boolean isPalindrome(@Nullable String candidate) {
+		int length = requireNonNull(candidate).length();
 		for (int i = 0; i < length / 2; i++) {
 			if (candidate.charAt(i) != candidate.charAt(length - (i + 1))) {
 				return false;

junit-jupiter-api/src/main/java/org/junit/jupiter/api/condition/MethodBasedCondition.java

@@ -68,7 +68,7 @@ Method getConditionMethod(String fullyQualifiedMethodName, ExtensionContext cont
 		String className = methodParts[0];
 		String methodName = methodParts[1];
 		ClassLoader classLoader = ClassLoaderUtils.getClassLoader(testClass);
-		Class<?> clazz = ReflectionSupport.tryToLoadClass(className, classLoader).getOrThrow(
+		Class<?> clazz = ReflectionSupport.tryToLoadClass(className, classLoader).getNonNullOrThrow(
 			cause -> new JUnitException("Could not load class [%s]".formatted(className), cause));
 		return findMethod(clazz, methodName);
 	}

junit-jupiter-params/src/jmh/java/org/junit/jupiter/params/ParameterizedInvocationNameFormatterBenchmarks.java

@@ -10,6 +10,7 @@
 
 package org.junit.jupiter.params;
 
+import static java.util.Objects.requireNonNull;
 import static org.junit.jupiter.params.ParameterizedInvocationConstants.DEFAULT_DISPLAY_NAME;
 import static org.junit.jupiter.params.ParameterizedInvocationConstants.DISPLAY_NAME_PLACEHOLDER;
 
@@ -50,7 +51,9 @@ public void formatTestNames(Blackhole blackhole) throws Exception {
 		var method = TestCase.class.getDeclaredMethod("parameterizedTest", int.class);
 		var formatter = new ParameterizedInvocationNameFormatter(
 			DISPLAY_NAME_PLACEHOLDER + " " + DEFAULT_DISPLAY_NAME + " ({0})", "displayName",
-			new ParameterizedTestContext(TestCase.class, method, method.getAnnotation(ParameterizedTest.class)), 512);
+			new ParameterizedTestContext(TestCase.class, method,
+				requireNonNull(method.getAnnotation(ParameterizedTest.class))),
+			512);
 		for (int i = 0; i < argumentsList.size(); i++) {
 			Arguments arguments = argumentsList.get(i);
 			blackhole.consume(formatter.format(i, EvaluatedArgumentSet.allOf(arguments)));

junit-jupiter-params/src/main/java/org/junit/jupiter/params/provider/NullArgumentsProvider.java

@@ -14,6 +14,7 @@
 
 import java.util.stream.Stream;
 
+import org.jspecify.annotations.Nullable;
 import org.junit.jupiter.api.extension.ExtensionContext;
 import org.junit.jupiter.params.support.ParameterDeclarations;
 import org.junit.platform.commons.util.Preconditions;
@@ -24,7 +25,7 @@
  */
 class NullArgumentsProvider implements ArgumentsProvider {
 
-	private static final Arguments nullArguments = arguments(new Object[] { null });
+	private static final Arguments nullArguments = arguments(new @Nullable Object[] { null });
 
 	@Override
 	public Stream<? extends Arguments> provideArguments(ParameterDeclarations parameters, ExtensionContext context) {

junit-platform-commons/src/main/java/org/junit/platform/commons/support/conversion/FallbackStringToObjectConverter.java

@@ -67,7 +67,7 @@ class FallbackStringToObjectConverter implements StringToObjectConverter {
 	 * This prevents the framework from repeatedly searching for things which
 	 * are already known not to exist.
 	 */
-	private static final ConcurrentHashMap<Class<?>, Function<String, Object>> factoryExecutableCache //
+	private static final ConcurrentHashMap<Class<?>, Function<String, @Nullable Object>> factoryExecutableCache //
 		= new ConcurrentHashMap<>(64);
 
 	@Override
@@ -76,15 +76,16 @@ public boolean canConvertTo(Class<?> targetType) {
 	}
 
 	@Override
+	@Nullable
 	public Object convert(String source, Class<?> targetType) throws Exception {
-		Function<String, Object> executable = findFactoryExecutable(targetType);
+		Function<String, @Nullable Object> executable = findFactoryExecutable(targetType);
 		Preconditions.condition(executable != NULL_EXECUTABLE,
 			"Illegal state: convert() must not be called if canConvert() returned false");
 
 		return executable.apply(source);
 	}
 
-	private static Function<String, Object> findFactoryExecutable(Class<?> targetType) {
+	private static Function<String, @Nullable Object> findFactoryExecutable(Class<?> targetType) {
 		return factoryExecutableCache.computeIfAbsent(targetType, type -> {
 			Method factoryMethod = findFactoryMethod(type);
 			if (factoryMethod != null) {

junit-platform-commons/src/main/java/org/junit/platform/commons/util/ModuleUtils.java

@@ -10,6 +10,7 @@
 
 package org.junit.platform.commons.util;
 
+import static java.util.Objects.requireNonNull;
 import static java.util.function.Predicate.isEqual;
 import static java.util.stream.Collectors.toCollection;
 import static java.util.stream.Collectors.toSet;
@@ -298,10 +299,10 @@ List<Resource> scan(ModuleReference reference) {
 
 		private Resource loadResourceUnchecked(String binaryName) {
 			try {
-				URI uri = classLoader.getResource(binaryName).toURI();
+				URI uri = requireNonNull(classLoader.getResource(binaryName)).toURI();
 				return new DefaultResource(binaryName, uri);
 			}
-			catch (URISyntaxException e) {
+			catch (NullPointerException | URISyntaxException e) {
 				throw new JUnitException("Failed to load resource with name '" + binaryName + "'.", e);
 			}
 		}

junit-platform-engine/src/main/java/org/junit/platform/engine/discovery/MethodSelector.java

@@ -219,44 +219,50 @@ public Class<?>[] getParameterTypes() {
 	}
 
 	private Class<?> lazyLoadJavaClass() {
-		// @formatter:off
-		if (this.javaClass == null) {
+		Class<?> value = this.javaClass;
+		if (value == null) {
+			// @formatter:off
 			Try<Class<?>> tryToLoadClass = this.classLoader == null
 				? ReflectionSupport.tryToLoadClass(this.className)
 				: ReflectionSupport.tryToLoadClass(this.className, this.classLoader);
-			this.javaClass = tryToLoadClass.getNonNullOrThrow(cause ->
+			value = tryToLoadClass.getNonNullOrThrow(cause ->
 				new PreconditionViolationException("Could not load class with name: " + this.className, cause));
+			// @formatter:on
+			this.javaClass = value;
 		}
-		// @formatter:on
-		return this.javaClass;
+		return value;
 	}
 
 	private Method lazyLoadJavaMethod() {
-		if (this.javaMethod == null) {
+		var value = this.javaMethod;
+		if (value == null) {
 			Class<?> javaClass = lazyLoadJavaClass();
 			var parameterTypes = lazyLoadParameterTypes();
 			if (parameterTypes.length > 0) {
-				this.javaMethod = ReflectionSupport.findMethod(javaClass, this.methodName, parameterTypes).orElseThrow(
+				value = ReflectionSupport.findMethod(javaClass, this.methodName, parameterTypes).orElseThrow(
 					() -> new PreconditionViolationException(
 						"Could not find method with name [%s] and parameter types [%s] in class [%s].".formatted(
 							this.methodName, this.parameterTypeNames, javaClass.getName())));
 			}
 			else {
-				this.javaMethod = ReflectionSupport.findMethod(javaClass, this.methodName).orElseThrow(
+				value = ReflectionSupport.findMethod(javaClass, this.methodName).orElseThrow(
 					() -> new PreconditionViolationException(
 						"Could not find method with name [%s] in class [%s].".formatted(this.methodName,
 							javaClass.getName())));
 			}
+			this.javaMethod = value;
 		}
-		return this.javaMethod;
+		return value;
 	}
 
 	private Class<?>[] lazyLoadParameterTypes() {
-		if (this.parameterTypes == null) {
-			this.parameterTypes = ReflectionUtils.resolveParameterTypes(lazyLoadJavaClass(), this.methodName,
+		var value = this.parameterTypes;
+		if (value == null) {
+			value = ReflectionUtils.resolveParameterTypes(lazyLoadJavaClass(), this.methodName,
 				this.parameterTypeNames);
+			this.parameterTypes = value;
 		}
-		return this.parameterTypes;
+		return value;
 	}
 
 	/**

junit-platform-launcher/src/main/java/org/junit/platform/launcher/core/HierarchicalOutputDirectoryProvider.java

@@ -57,10 +57,12 @@ public Path createOutputDirectory(TestDescriptor testDescriptor) throws IOExcept
 
 	@Override
 	public synchronized Path getRootDirectory() {
-		if (rootDir == null) {
-			rootDir = rootDirSupplier.get();
+		var currentRootDir = rootDir;
+		if (currentRootDir == null) {
+			currentRootDir = rootDirSupplier.get();
+			rootDir = currentRootDir;
 		}
-		return rootDir;
+		return currentRootDir;
 	}
 
 	private static Path toSanitizedPath(Segment segment) {

junit-vintage-engine/src/main/java/org/junit/vintage/engine/discovery/ClassSelectorResolver.java

@@ -56,7 +56,7 @@ public Resolution resolve(UniqueIdSelector selector, Context context) {
 			String testClassName = lastSegment.getValue();
 			if (classFilter.match(testClassName)) {
 				Class<?> testClass = ReflectionSupport.tryToLoadClass(testClassName)//
-						.getOrThrow(cause -> new JUnitException("Unknown class: " + testClassName, cause));
+						.getNonNullOrThrow(cause -> new JUnitException("Unknown class: " + testClassName, cause));
 				return resolveTestClassThatPassedNameFilter(testClass, context);
 			}
 		}

junit-vintage-engine/src/main/java/org/junit/vintage/engine/execution/RunListenerAdapter.java

@@ -15,6 +15,7 @@
 import java.util.Optional;
 import java.util.function.Function;
 
+import org.jspecify.annotations.Nullable;
 import org.junit.Ignore;
 import org.junit.platform.engine.EngineExecutionListener;
 import org.junit.platform.engine.TestDescriptor;
@@ -192,7 +193,7 @@ private Optional<String> determineReasonForIgnoredTest(TestDescriptor testDescri
 				.flatMap(testClass -> getReason(testClass.getAnnotation(Ignore.class)));
 	}
 
-	private static Optional<String> getReason(Ignore annotation) {
+	private static Optional<String> getReason(@Nullable Ignore annotation) {
 		return Optional.ofNullable(annotation).map(Ignore::value);
 	}