Test recursive updates and compute interactions

Co-authored-by: martinfrancois <f.martin@fastmail.com>

Author: mpkorstanje

platform-tests/src/test/java/org/junit/platform/engine/support/store/NamespacedHierarchicalStoreTests.java

@@ -25,6 +25,7 @@
 import static org.mockito.Mockito.verifyNoInteractions;
 import static org.mockito.Mockito.verifyNoMoreInteractions;
 
+import java.io.Serial;
 import java.util.List;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.function.Function;
@@ -82,6 +83,13 @@ void valueIsComputedIfAbsent() {
 			assertEquals(value, store.get(namespace, key));
 		}
 
+		@Test
+		void valueIsComputedIfNull() {
+			assertNull(store.put(namespace, key, null));
+			assertEquals(value, store.computeIfAbsent(namespace, key, __ -> value));
+			assertEquals(value, store.get(namespace, key));
+		}
+
 		@SuppressWarnings("deprecation")
 		@Test
 		void valueIsNotComputedIfPresentLocally() {
@@ -316,22 +324,42 @@ void computeIfAbsentWithTypeSafetyAndPrimitiveValueType() {
 		@SuppressWarnings("deprecation")
 		@Test
 		void getOrComputeIfAbsentWithExceptionThrowingCreatorFunction() {
-			var e = assertThrows(RuntimeException.class, () -> store.getOrComputeIfAbsent(namespace, key, __ -> {
-				throw new RuntimeException("boom");
+			var e = assertThrows(ComputeException.class, () -> store.getOrComputeIfAbsent(namespace, key, __ -> {
+				throw new ComputeException("boom");
 			}));
-			assertSame(e, assertThrows(RuntimeException.class, () -> store.get(namespace, key)));
-			assertSame(e, assertThrows(RuntimeException.class, () -> store.remove(namespace, key)));
+			assertSame(e, assertThrows(ComputeException.class, () -> store.get(namespace, key)));
+			assertSame(e, assertThrows(ComputeException.class, () -> store.remove(namespace, key)));
 		}
 
 		@Test
 		void computeIfAbsentWithExceptionThrowingCreatorFunction() {
-			assertThrows(RuntimeException.class, () -> store.computeIfAbsent(namespace, key, __ -> {
-				throw new RuntimeException("boom");
+			assertThrows(ComputeException.class, () -> store.computeIfAbsent(namespace, key, __ -> {
+				throw new ComputeException("boom");
 			}));
 			assertNull(store.get(namespace, key));
 			assertNull(store.remove(namespace, key));
 		}
 
+		@SuppressWarnings("deprecation")
+		@Test
+		void getOrComputeIfAbsentDoesNotSeeComputeIfAbsentWithExceptionThrowingCreatorFunction() {
+			assertThrows(ComputeException.class, () -> store.computeIfAbsent(namespace, key, __ -> {
+				throw new ComputeException("boom");
+			}));
+			assertNull(store.get(namespace, key));
+			assertEquals(value, store.getOrComputeIfAbsent(namespace, key, __ -> value));
+		}
+
+		@SuppressWarnings("deprecation")
+		@Test
+		void computeIfAbsentSeesGetOrComputeIfAbsentWithExceptionThrowingCreatorFunction() {
+			assertThrows(ComputeException.class, () -> store.getOrComputeIfAbsent(namespace, key, __ -> {
+				throw new ComputeException("boom");
+			}));
+			assertThrows(ComputeException.class, () -> store.get(namespace, key));
+			assertThrows(ComputeException.class, () -> store.computeIfAbsent(namespace, key, __ -> value));
+		}
+
 		@Test
 		void removeWithTypeSafetyAndInvalidRequiredTypeThrowsException() {
 			Integer key = 42;
@@ -416,6 +444,35 @@ void simulateRaceConditionInComputeIfAbsent() throws Exception {
 			assertEquals(1, counter.get());
 			assertThat(values).hasSize(threads).containsOnly(1);
 		}
+
+		@SuppressWarnings("deprecation")
+		@Test
+		void updateRecursivelyGetOrComputeIfAbsent() {
+			try (var localStore = new NamespacedHierarchicalStore<>(null)) {
+				var value = localStore.getOrComputeIfAbsent(namespace, new CollidingKey("a"), //
+					a -> requireNonNull(localStore.getOrComputeIfAbsent(namespace, new CollidingKey("b"), //
+						b -> "enigma")));
+				assertEquals("enigma", value);
+			}
+		}
+
+		@Test
+		void updateRecursivelyComputeIfAbsent() {
+			try (var localStore = new NamespacedHierarchicalStore<>(null)) {
+				var value = localStore.computeIfAbsent(namespace, new CollidingKey("a"), //
+					a -> localStore.computeIfAbsent(namespace, new CollidingKey("b"), //
+						b -> "enigma"));
+				assertEquals("enigma", value);
+			}
+		}
+
+		private record CollidingKey(String value) {
+
+			@Override
+			public int hashCode() {
+				return 42;
+			}
+		}
 	}
 
 	@Nested
@@ -522,19 +579,19 @@ void doesNotCallCloseActionForNullValues() {
 		@Test
 		void doesNotCallCloseActionForValuesThatThrowExceptionsDuringCleanup() throws Throwable {
 			store.put(namespace, "key1", "value1");
-			assertThrows(RuntimeException.class, () -> store.computeIfAbsent(namespace, "key2", __ -> {
-				throw new RuntimeException("boom");
+			assertThrows(ComputeException.class, () -> store.computeIfAbsent(namespace, "key2", __ -> {
+				throw new ComputeException("boom");
 			}));
-			assertThrows(RuntimeException.class, () -> store.getOrComputeIfAbsent(namespace, "key2", __ -> {
-				throw new RuntimeException("boom");
+			assertThrows(ComputeException.class, () -> store.getOrComputeIfAbsent(namespace, "key3", __ -> {
+				throw new ComputeException("boom");
 			}));
-			store.put(namespace, "key3", "value3");
+			store.put(namespace, "key4", "value4");
 
 			store.close();
 			assertClosed();
 
 			var inOrder = inOrder(closeAction);
-			inOrder.verify(closeAction).close(namespace, "key3", "value3");
+			inOrder.verify(closeAction).close(namespace, "key4", "value4");
 			inOrder.verify(closeAction).close(namespace, "key1", "value1");
 			inOrder.verifyNoMoreInteractions();
 		}
@@ -672,4 +729,17 @@ public String toString() {
 			}
 		};
 	}
+
+	/**
+	 * To avoid confusion with other Runtime exceptions that can be thrown.
+	 */
+	private static final class ComputeException extends RuntimeException {
+
+		@Serial
+		private static final long serialVersionUID = 1L;
+
+		ComputeException(String msg) {
+			super(msg);
+		}
+	}
 }