Annotate nullability in org.junit.platform.engine.support.store

Author: marcphilipp

junit-platform-engine/src/main/java/org/junit/platform/engine/support/store/NamespacedHierarchicalStore.java

@@ -11,6 +11,7 @@
 package org.junit.platform.engine.support.store;
 
 import static java.util.Comparator.comparing;
+import static java.util.Objects.requireNonNull;
 import static org.apiguardian.api.API.Status.EXPERIMENTAL;
 import static org.junit.platform.commons.util.ReflectionUtils.getWrapperType;
 import static org.junit.platform.commons.util.ReflectionUtils.isAssignableTo;
@@ -25,6 +26,7 @@
 import java.util.function.Supplier;
 
 import org.apiguardian.api.API;
+import org.jspecify.annotations.Nullable;
 import org.junit.platform.commons.util.ExceptionUtils;
 import org.junit.platform.commons.util.Preconditions;
 import org.junit.platform.commons.util.UnrecoverableExceptions;
@@ -51,8 +53,10 @@ public final class NamespacedHierarchicalStore<N> implements AutoCloseable {
 
 	private final ConcurrentMap<CompositeKey<N>, StoredValue> storedValues = new ConcurrentHashMap<>(4);
 
+	@Nullable
 	private final NamespacedHierarchicalStore<N> parentStore;
 
+	@Nullable
 	private final CloseAction<N> closeAction;
 
 	private volatile boolean closed = false;
@@ -62,7 +66,7 @@ public final class NamespacedHierarchicalStore<N> implements AutoCloseable {
 	 *
 	 * @param parentStore the parent store to use for lookups; may be {@code null}
 	 */
-	public NamespacedHierarchicalStore(NamespacedHierarchicalStore<N> parentStore) {
+	public NamespacedHierarchicalStore(@Nullable NamespacedHierarchicalStore<N> parentStore) {
 		this(parentStore, null);
 	}
 
@@ -73,7 +77,8 @@ public NamespacedHierarchicalStore(NamespacedHierarchicalStore<N> parentStore) {
 	 * @param closeAction the action to be called for each stored value when this
 	 * store is closed; may be {@code null}
 	 */
-	public NamespacedHierarchicalStore(NamespacedHierarchicalStore<N> parentStore, CloseAction<N> closeAction) {
+	public NamespacedHierarchicalStore(@Nullable NamespacedHierarchicalStore<N> parentStore,
+			@Nullable CloseAction<N> closeAction) {
 		this.parentStore = parentStore;
 		this.closeAction = closeAction;
 	}
@@ -152,6 +157,7 @@ public void close() {
 	 * @throws NamespacedHierarchicalStoreException if this store has already been
 	 * closed
 	 */
+	@Nullable
 	public Object get(N namespace, Object key) {
 		StoredValue storedValue = getStoredValue(new CompositeKey<>(namespace, key));
 		return StoredValue.evaluateIfNotNull(storedValue);
@@ -168,6 +174,7 @@ public Object get(N namespace, Object key) {
 	 * @throws NamespacedHierarchicalStoreException if the stored value cannot
 	 * be cast to the required type, or if this store has already been closed
 	 */
+	@Nullable
 	public <T> T get(N namespace, Object key, Class<T> requiredType) throws NamespacedHierarchicalStoreException {
 		Object value = get(namespace, key);
 		return castToRequiredType(key, value, requiredType);
@@ -185,13 +192,14 @@ public <T> T get(N namespace, Object key, Class<T> requiredType) throws Namespac
 	 * @throws NamespacedHierarchicalStoreException if this store has already been
 	 * closed
 	 */
-	public <K, V> Object getOrComputeIfAbsent(N namespace, K key, Function<K, V> defaultCreator) {
+	@Nullable
+	public <K, V> Object getOrComputeIfAbsent(N namespace, K key, Function<K, @Nullable V> defaultCreator) {
 		Preconditions.notNull(defaultCreator, "defaultCreator must not be null");
 		CompositeKey<N> compositeKey = new CompositeKey<>(namespace, key);
 		StoredValue storedValue = getStoredValue(compositeKey);
 		if (storedValue == null) {
 			storedValue = this.storedValues.computeIfAbsent(compositeKey,
-				__ -> storedValue(new MemoizingSupplier(() -> {
+				__ -> newStoredValue(new MemoizingSupplier(() -> {
 					rejectIfClosed();
 					return defaultCreator.apply(key);
 				})));
@@ -213,8 +221,9 @@ public <K, V> Object getOrComputeIfAbsent(N namespace, K key, Function<K, V> def
 	 * @throws NamespacedHierarchicalStoreException if the stored value cannot
 	 * be cast to the required type, or if this store has already been closed
 	 */
-	public <K, V> V getOrComputeIfAbsent(N namespace, K key, Function<K, V> defaultCreator, Class<V> requiredType)
-			throws NamespacedHierarchicalStoreException {
+	@Nullable
+	public <K, V> V getOrComputeIfAbsent(N namespace, K key, Function<K, @Nullable V> defaultCreator,
+			Class<V> requiredType) throws NamespacedHierarchicalStoreException {
 
 		Object value = getOrComputeIfAbsent(namespace, key, defaultCreator);
 		return castToRequiredType(key, value, requiredType);
@@ -234,9 +243,10 @@ public <K, V> V getOrComputeIfAbsent(N namespace, K key, Function<K, V> defaultC
 	 * @throws NamespacedHierarchicalStoreException if an error occurs while
 	 * storing the value, or if this store has already been closed
 	 */
-	public Object put(N namespace, Object key, Object value) throws NamespacedHierarchicalStoreException {
+	@Nullable
+	public Object put(N namespace, Object key, @Nullable Object value) throws NamespacedHierarchicalStoreException {
 		rejectIfClosed();
-		StoredValue oldValue = this.storedValues.put(new CompositeKey<>(namespace, key), storedValue(() -> value));
+		StoredValue oldValue = this.storedValues.put(new CompositeKey<>(namespace, key), newStoredValue(() -> value));
 		return StoredValue.evaluateIfNotNull(oldValue);
 	}
 
@@ -253,6 +263,7 @@ public Object put(N namespace, Object key, Object value) throws NamespacedHierar
 	 * @throws NamespacedHierarchicalStoreException if this store has already been
 	 * closed
 	 */
+	@Nullable
 	public Object remove(N namespace, Object key) {
 		rejectIfClosed();
 		StoredValue previous = this.storedValues.remove(new CompositeKey<>(namespace, key));
@@ -273,16 +284,18 @@ public Object remove(N namespace, Object key) {
 	 * @throws NamespacedHierarchicalStoreException if the stored value cannot
 	 * be cast to the required type, or if this store has already been closed
 	 */
+	@Nullable
 	public <T> T remove(N namespace, Object key, Class<T> requiredType) throws NamespacedHierarchicalStoreException {
 		rejectIfClosed();
 		Object value = remove(namespace, key);
 		return castToRequiredType(key, value, requiredType);
 	}
 
-	private StoredValue storedValue(Supplier<Object> value) {
+	private StoredValue newStoredValue(Supplier<@Nullable Object> value) {
 		return new StoredValue(this.insertOrderSequence.getAndIncrement(), value);
 	}
 
+	@Nullable
 	private StoredValue getStoredValue(CompositeKey<N> compositeKey) {
 		StoredValue storedValue = this.storedValues.get(compositeKey);
 		if (storedValue != null) {
@@ -294,15 +307,16 @@ private StoredValue getStoredValue(CompositeKey<N> compositeKey) {
 		return null;
 	}
 
+	@Nullable
 	@SuppressWarnings("unchecked")
-	private <T> T castToRequiredType(Object key, Object value, Class<T> requiredType) {
+	private <T> T castToRequiredType(Object key, @Nullable Object value, Class<T> requiredType) {
 		Preconditions.notNull(requiredType, "requiredType must not be null");
 		if (value == null) {
 			return null;
 		}
 		if (isAssignableTo(value, requiredType)) {
 			if (requiredType.isPrimitive()) {
-				return (T) getWrapperType(requiredType).cast(value);
+				return (T) requireNonNull(getWrapperType(requiredType)).cast(value);
 			}
 			return requiredType.cast(value);
 		}
@@ -351,13 +365,14 @@ public int hashCode() {
 	private static class StoredValue {
 
 		private final int order;
-		private final Supplier<Object> supplier;
+		private final Supplier<@Nullable Object> supplier;
 
-		StoredValue(int order, Supplier<Object> supplier) {
+		StoredValue(int order, Supplier<@Nullable Object> supplier) {
 			this.order = order;
 			this.supplier = supplier;
 		}
 
+		@Nullable
 		private <N> EvaluatedValue<N> evaluateSafely(CompositeKey<N> compositeKey) {
 			try {
 				return new EvaluatedValue<>(compositeKey, this.order, evaluate());
@@ -368,11 +383,13 @@ private <N> EvaluatedValue<N> evaluateSafely(CompositeKey<N> compositeKey) {
 			}
 		}
 
+		@Nullable
 		private Object evaluate() {
 			return this.supplier.get();
 		}
 
-		static Object evaluateIfNotNull(StoredValue value) {
+		@Nullable
+		static Object evaluateIfNotNull(@Nullable StoredValue value) {
 			return value != null ? value.evaluate() : null;
 		}
 
@@ -385,16 +402,20 @@ private static class EvaluatedValue<N> {
 
 		private final CompositeKey<N> compositeKey;
 		private final int order;
+
+		@Nullable
 		private final Object value;
 
-		private EvaluatedValue(CompositeKey<N> compositeKey, int order, Object value) {
+		private EvaluatedValue(CompositeKey<N> compositeKey, int order, @Nullable Object value) {
 			this.compositeKey = compositeKey;
 			this.order = order;
 			this.value = value;
 		}
 
 		private void close(CloseAction<N> closeAction) throws Throwable {
-			closeAction.close(this.compositeKey.namespace, this.compositeKey.key, this.value);
+			if (this.value != null) {
+				closeAction.close(this.compositeKey.namespace, this.compositeKey.key, this.value);
+			}
 		}
 
 	}
@@ -408,18 +429,21 @@ private void close(CloseAction<N> closeAction) throws Throwable {
 	 *
 	 * @see StoredValue
 	 */
-	private static class MemoizingSupplier implements Supplier<Object> {
+	private static class MemoizingSupplier implements Supplier<@Nullable Object> {
 
 		private static final Object NO_VALUE_SET = new Object();
 
-		private final Supplier<Object> delegate;
+		private final Supplier<@Nullable Object> delegate;
+
+		@Nullable
 		private volatile Object value = NO_VALUE_SET;
 
-		private MemoizingSupplier(Supplier<Object> delegate) {
+		private MemoizingSupplier(Supplier<@Nullable Object> delegate) {
 			this.delegate = delegate;
 		}
 
 		@Override
+		@Nullable
 		public Object get() {
 			if (this.value == NO_VALUE_SET) {
 				computeValue();

junit-platform-engine/src/main/java/org/junit/platform/engine/support/store/package-info.java

@@ -2,4 +2,7 @@
  * Reusable data structures for test engines and their extensions.
  */
 
+@NullMarked
 package org.junit.platform.engine.support.store;
+
+import org.jspecify.annotations.NullMarked;