Migrate parameterized tests in spring-core

This commit migrates parameterized tests in spring-core using the
"composed @ParameterizedTest" approach. This approach is reused in
follow-up commits for the migration of the remaining modules.

For a concrete example, see AbstractDataBufferAllocatingTests and its
subclasses (e.g., DataBufferTests).

Specifically, AbstractDataBufferAllocatingTests declares a custom
@ParameterizedDataBufferAllocatingTest annotation that is
meta-annotated with @ParameterizedTest and
@MethodSource("org.springframework.core.io.buffer.AbstractDataBufferAllocatingTests#dataBufferFactories()").

Individual methods in concrete subclasses are then annotated with
@ParameterizedDataBufferAllocatingTest instead of @ParameterizedTest or
@test.

The approach makes the migration from JUnit 4 to JUnit Jupiter rather
straightforward; however, there is one major downside. The arguments
for a @ParameterizedTest test method can only be accessed by the test
method itself. It is not possible to access them in an @beforeeach
method (see junit-team/junit-framework#944).
Consequently, we are forced to declare the parameters in each such
method and delegate to a custom "setup" method. Although this is a bit
cumbersome, I feel it is currently the best way to achieve fine grained
parameterized tests within our test suite without implementing a custom
TestTemplateInvocationContextProvider for each specific use case.

Once junit-team/junit-framework#878 is resolved, we
should consider migrating to parameterized test classes.

See gh-23451

Author: sbrannen

spring-core/src/test/java/org/springframework/core/LocalVariableTableParameterNameDiscovererTests.java

@@ -22,7 +22,7 @@
 import java.lang.reflect.Method;
 import java.util.Date;
 
-import org.junit.Ignore;
+import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
 
 import org.springframework.tests.sample.objects.TestObject;
@@ -203,7 +203,7 @@ public void generifiedClass() throws Exception {
 		assertThat(names.length).isEqualTo(0);
 	}
 
-	@Ignore("Ignored because Ubuntu packages OpenJDK with debug symbols enabled. See SPR-8078.")
+	@Disabled("Ignored because Ubuntu packages OpenJDK with debug symbols enabled. See SPR-8078.")
 	@Test
 	public void classesWithoutDebugSymbols() throws Exception {
 		// JDK classes don't have debug information (usually)

spring-core/src/test/java/org/springframework/core/io/buffer/AbstractDataBufferAllocatingTestCase.java renamed to spring-core/src/test/java/org/springframework/core/io/buffer/AbstractDataBufferAllocatingTests.java

@@ -16,57 +16,49 @@
 
 package org.springframework.core.io.buffer;
 
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
 import java.nio.charset.StandardCharsets;
 import java.time.Duration;
 import java.time.Instant;
 import java.util.Arrays;
 import java.util.List;
 import java.util.function.Consumer;
+import java.util.stream.Stream;
 
 import io.netty.buffer.ByteBufAllocator;
 import io.netty.buffer.PoolArenaMetric;
 import io.netty.buffer.PooledByteBufAllocator;
 import io.netty.buffer.PooledByteBufAllocatorMetric;
 import io.netty.buffer.UnpooledByteBufAllocator;
-import org.junit.Rule;
-import org.junit.rules.Verifier;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
+import org.junit.jupiter.api.extension.AfterEachCallback;
+import org.junit.jupiter.api.extension.RegisterExtension;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
 import reactor.core.publisher.Mono;
 
 import org.springframework.core.io.buffer.support.DataBufferTestUtils;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.params.provider.Arguments.arguments;
 
 /**
  * Base class for tests that read or write data buffers with a rule to check
  * that allocated buffers have been released.
  *
  * @author Arjen Poutsma
  * @author Rossen Stoyanchev
+ * @author Sam Brannen
  */
-@RunWith(Parameterized.class)
-public abstract class AbstractDataBufferAllocatingTestCase {
-
-	@Parameterized.Parameter
-	public DataBufferFactory bufferFactory;
-
-	@Parameterized.Parameters(name = "{0}")
-	public static Object[][] dataBufferFactories() {
-		return new Object[][] {
-				{new NettyDataBufferFactory(new UnpooledByteBufAllocator(true))},
-				{new NettyDataBufferFactory(new UnpooledByteBufAllocator(false))},
-				// disable caching for reliable leak detection, see https://github.com/netty/netty/issues/5275
-				{new NettyDataBufferFactory(new PooledByteBufAllocator(true, 1, 1, 8192, 11, 0, 0, 0, true))},
-				{new NettyDataBufferFactory(new PooledByteBufAllocator(false, 1, 1, 8192, 11, 0, 0, 0, true))},
-				{new DefaultDataBufferFactory(true)},
-				{new DefaultDataBufferFactory(false)}
+public abstract class AbstractDataBufferAllocatingTests {
 
-		};
-	}
+	@RegisterExtension
+	AfterEachCallback leakDetector = context -> verifyAllocations();
 
-	@Rule
-	public final Verifier leakDetector = new LeakDetector();
+	protected DataBufferFactory bufferFactory;
 
 
 	protected DataBuffer createDataBuffer(int capacity) {
@@ -93,8 +85,7 @@ protected void release(DataBuffer... buffers) {
 
 	protected Consumer<DataBuffer> stringConsumer(String expected) {
 		return dataBuffer -> {
-			String value =
-					DataBufferTestUtils.dumpString(dataBuffer, StandardCharsets.UTF_8);
+			String value = DataBufferTestUtils.dumpString(dataBuffer, StandardCharsets.UTF_8);
 			DataBufferUtils.release(dataBuffer);
 			assertThat(value).isEqualTo(expected);
 		};
@@ -150,12 +141,29 @@ private static long getAllocations(List<PoolArenaMetric> metrics) {
 	}
 
 
-	protected class LeakDetector extends Verifier {
+	@Retention(RetentionPolicy.RUNTIME)
+	@Target(ElementType.METHOD)
+	@ParameterizedTest(name = "{0}")
+	@MethodSource("org.springframework.core.io.buffer.AbstractDataBufferAllocatingTests#dataBufferFactories()")
+	public @interface ParameterizedDataBufferAllocatingTest {
+	}
 
-		@Override
-		public void verify() {
-			AbstractDataBufferAllocatingTestCase.this.verifyAllocations();
-		}
+	public static Stream<Arguments> dataBufferFactories() {
+		return Stream.of(
+			arguments("NettyDataBufferFactory - UnpooledByteBufAllocator - preferDirect = true",
+					new NettyDataBufferFactory(new UnpooledByteBufAllocator(true))),
+			arguments("NettyDataBufferFactory - UnpooledByteBufAllocator - preferDirect = false",
+					new NettyDataBufferFactory(new UnpooledByteBufAllocator(false))),
+			// disable caching for reliable leak detection, see https://github.com/netty/netty/issues/5275
+			arguments("NettyDataBufferFactory - PooledByteBufAllocator - preferDirect = true",
+					new NettyDataBufferFactory(new PooledByteBufAllocator(true, 1, 1, 4096, 2, 0, 0, 0, true))),
+			arguments("NettyDataBufferFactory - PooledByteBufAllocator - preferDirect = false",
+					new NettyDataBufferFactory(new PooledByteBufAllocator(false, 1, 1, 4096, 2, 0, 0, 0, true))),
+			arguments("DefaultDataBufferFactory - preferDirect = true",
+					new DefaultDataBufferFactory(true)),
+			arguments("DefaultDataBufferFactory - preferDirect = false",
+					new DefaultDataBufferFactory(false))
+		);
 	}
 
 }