From 3df85c783f3440cb2ce5bb004791dadd430e9125 Mon Sep 17 00:00:00 2001 From: Sam Brannen Date: Mon, 12 Aug 2019 13:35:56 +0200 Subject: [PATCH] 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 https://github.com/junit-team/junit5/issues/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 https://github.com/junit-team/junit5/issues/878 is resolved, we should consider migrating to parameterized test classes. See gh-23451 --- ...ableTableParameterNameDiscovererTests.java | 4 +- ...=> AbstractDataBufferAllocatingTests.java} | 70 +++-- .../core/io/buffer/DataBufferTests.java | 236 +++++++++----- .../core/io/buffer/DataBufferUtilsTests.java | 293 +++++++++++------- .../LeakAwareDataBufferFactoryTests.java | 2 +- .../core/io/buffer/PooledDataBufferTests.java | 90 ++++-- .../support/DataBufferTestUtilsTests.java | 20 +- ...ServerSentEventHttpMessageWriterTests.java | 73 +++-- .../WebClientDataBufferAllocatingTests.java | 57 ++-- 9 files changed, 528 insertions(+), 317 deletions(-) rename spring-core/src/test/java/org/springframework/core/io/buffer/{AbstractDataBufferAllocatingTestCase.java => AbstractDataBufferAllocatingTests.java} (62%) diff --git a/spring-core/src/test/java/org/springframework/core/LocalVariableTableParameterNameDiscovererTests.java b/spring-core/src/test/java/org/springframework/core/LocalVariableTableParameterNameDiscovererTests.java index 4d92c296ea..88c4c2d2fd 100644 --- a/spring-core/src/test/java/org/springframework/core/LocalVariableTableParameterNameDiscovererTests.java +++ b/spring-core/src/test/java/org/springframework/core/LocalVariableTableParameterNameDiscovererTests.java @@ -22,7 +22,7 @@ import java.lang.reflect.Constructor; 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 class LocalVariableTableParameterNameDiscovererTests { 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) diff --git a/spring-core/src/test/java/org/springframework/core/io/buffer/AbstractDataBufferAllocatingTestCase.java b/spring-core/src/test/java/org/springframework/core/io/buffer/AbstractDataBufferAllocatingTests.java similarity index 62% rename from spring-core/src/test/java/org/springframework/core/io/buffer/AbstractDataBufferAllocatingTestCase.java rename to spring-core/src/test/java/org/springframework/core/io/buffer/AbstractDataBufferAllocatingTests.java index 595c34859d..2398405d3a 100644 --- a/spring-core/src/test/java/org/springframework/core/io/buffer/AbstractDataBufferAllocatingTestCase.java +++ b/spring-core/src/test/java/org/springframework/core/io/buffer/AbstractDataBufferAllocatingTests.java @@ -16,27 +16,34 @@ 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 @@ -44,29 +51,14 @@ import static org.assertj.core.api.Assertions.assertThat; * * @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 @@ public abstract class AbstractDataBufferAllocatingTestCase { protected Consumer 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 @@ public abstract class AbstractDataBufferAllocatingTestCase { } - 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 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)) + ); } } diff --git a/spring-core/src/test/java/org/springframework/core/io/buffer/DataBufferTests.java b/spring-core/src/test/java/org/springframework/core/io/buffer/DataBufferTests.java index 99a72e8303..71c221dba4 100644 --- a/spring-core/src/test/java/org/springframework/core/io/buffer/DataBufferTests.java +++ b/spring-core/src/test/java/org/springframework/core/io/buffer/DataBufferTests.java @@ -16,26 +16,26 @@ package org.springframework.core.io.buffer; -import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.nio.ByteBuffer; import java.nio.charset.StandardCharsets; import java.util.Arrays; -import org.junit.Test; - import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatExceptionOfType; import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException; /** * @author Arjen Poutsma + * @author Sam Brannen */ -public class DataBufferTests extends AbstractDataBufferAllocatingTestCase { +class DataBufferTests extends AbstractDataBufferAllocatingTests { + + @ParameterizedDataBufferAllocatingTest + public void byteCountsAndPositions(String displayName, DataBufferFactory bufferFactory) { + super.bufferFactory = bufferFactory; - @Test - public void byteCountsAndPositions() { DataBuffer buffer = createDataBuffer(2); assertThat(buffer.readPosition()).isEqualTo(0); @@ -75,8 +75,10 @@ public class DataBufferTests extends AbstractDataBufferAllocatingTestCase { release(buffer); } - @Test - public void readPositionSmallerThanZero() { + @ParameterizedDataBufferAllocatingTest + public void readPositionSmallerThanZero(String displayName, DataBufferFactory bufferFactory) { + super.bufferFactory = bufferFactory; + DataBuffer buffer = createDataBuffer(1); try { assertThatExceptionOfType(IndexOutOfBoundsException.class).isThrownBy(() -> @@ -87,8 +89,10 @@ public class DataBufferTests extends AbstractDataBufferAllocatingTestCase { } } - @Test - public void readPositionGreaterThanWritePosition() { + @ParameterizedDataBufferAllocatingTest + public void readPositionGreaterThanWritePosition(String displayName, DataBufferFactory bufferFactory) { + super.bufferFactory = bufferFactory; + DataBuffer buffer = createDataBuffer(1); try { assertThatExceptionOfType(IndexOutOfBoundsException.class).isThrownBy(() -> @@ -99,8 +103,10 @@ public class DataBufferTests extends AbstractDataBufferAllocatingTestCase { } } - @Test - public void writePositionSmallerThanReadPosition() { + @ParameterizedDataBufferAllocatingTest + public void writePositionSmallerThanReadPosition(String displayName, DataBufferFactory bufferFactory) { + super.bufferFactory = bufferFactory; + DataBuffer buffer = createDataBuffer(2); try { buffer.write((byte) 'a'); @@ -113,8 +119,10 @@ public class DataBufferTests extends AbstractDataBufferAllocatingTestCase { } } - @Test - public void writePositionGreaterThanCapacity() { + @ParameterizedDataBufferAllocatingTest + public void writePositionGreaterThanCapacity(String displayName, DataBufferFactory bufferFactory) { + super.bufferFactory = bufferFactory; + DataBuffer buffer = createDataBuffer(1); try { assertThatExceptionOfType(IndexOutOfBoundsException.class).isThrownBy(() -> @@ -125,8 +133,10 @@ public class DataBufferTests extends AbstractDataBufferAllocatingTestCase { } } - @Test - public void writeAndRead() { + @ParameterizedDataBufferAllocatingTest + public void writeAndRead(String displayName, DataBufferFactory bufferFactory) { + super.bufferFactory = bufferFactory; + DataBuffer buffer = createDataBuffer(5); buffer.write(new byte[]{'a', 'b', 'c'}); @@ -144,8 +154,10 @@ public class DataBufferTests extends AbstractDataBufferAllocatingTestCase { release(buffer); } - @Test - public void writeNullString() { + @ParameterizedDataBufferAllocatingTest + public void writeNullString(String displayName, DataBufferFactory bufferFactory) { + super.bufferFactory = bufferFactory; + DataBuffer buffer = createDataBuffer(1); try { assertThatIllegalArgumentException().isThrownBy(() -> @@ -156,8 +168,10 @@ public class DataBufferTests extends AbstractDataBufferAllocatingTestCase { } } - @Test - public void writeNullCharset() { + @ParameterizedDataBufferAllocatingTest + public void writeNullCharset(String displayName, DataBufferFactory bufferFactory) { + super.bufferFactory = bufferFactory; + DataBuffer buffer = createDataBuffer(1); try { assertThatIllegalArgumentException().isThrownBy(() -> @@ -168,8 +182,10 @@ public class DataBufferTests extends AbstractDataBufferAllocatingTestCase { } } - @Test - public void writeEmptyString() { + @ParameterizedDataBufferAllocatingTest + public void writeEmptyString(String displayName, DataBufferFactory bufferFactory) { + super.bufferFactory = bufferFactory; + DataBuffer buffer = createDataBuffer(1); buffer.write("", StandardCharsets.UTF_8); @@ -178,8 +194,10 @@ public class DataBufferTests extends AbstractDataBufferAllocatingTestCase { release(buffer); } - @Test - public void writeUtf8String() { + @ParameterizedDataBufferAllocatingTest + public void writeUtf8String(String displayName, DataBufferFactory bufferFactory) { + super.bufferFactory = bufferFactory; + DataBuffer buffer = createDataBuffer(6); buffer.write("Spring", StandardCharsets.UTF_8); @@ -190,8 +208,10 @@ public class DataBufferTests extends AbstractDataBufferAllocatingTestCase { release(buffer); } - @Test - public void writeUtf8StringOutGrowsCapacity() { + @ParameterizedDataBufferAllocatingTest + public void writeUtf8StringOutGrowsCapacity(String displayName, DataBufferFactory bufferFactory) { + super.bufferFactory = bufferFactory; + DataBuffer buffer = createDataBuffer(5); buffer.write("Spring €", StandardCharsets.UTF_8); @@ -202,8 +222,10 @@ public class DataBufferTests extends AbstractDataBufferAllocatingTestCase { release(buffer); } - @Test - public void writeIsoString() { + @ParameterizedDataBufferAllocatingTest + public void writeIsoString(String displayName, DataBufferFactory bufferFactory) { + super.bufferFactory = bufferFactory; + DataBuffer buffer = createDataBuffer(3); buffer.write("\u00A3", StandardCharsets.ISO_8859_1); @@ -214,8 +236,9 @@ public class DataBufferTests extends AbstractDataBufferAllocatingTestCase { release(buffer); } - @Test - public void writeMultipleUtf8String() { + @ParameterizedDataBufferAllocatingTest + public void writeMultipleUtf8String(String displayName, DataBufferFactory bufferFactory) { + super.bufferFactory = bufferFactory; DataBuffer buffer = createDataBuffer(1); buffer.write("abc", StandardCharsets.UTF_8); @@ -235,8 +258,10 @@ public class DataBufferTests extends AbstractDataBufferAllocatingTestCase { release(buffer); } - @Test - public void toStringNullCharset() { + @ParameterizedDataBufferAllocatingTest + public void toStringNullCharset(String displayName, DataBufferFactory bufferFactory) { + super.bufferFactory = bufferFactory; + DataBuffer buffer = createDataBuffer(1); try { assertThatIllegalArgumentException().isThrownBy(() -> @@ -247,8 +272,10 @@ public class DataBufferTests extends AbstractDataBufferAllocatingTestCase { } } - @Test - public void toStringUtf8() { + @ParameterizedDataBufferAllocatingTest + public void toStringUtf8(String displayName, DataBufferFactory bufferFactory) { + super.bufferFactory = bufferFactory; + String spring = "Spring"; byte[] bytes = spring.getBytes(StandardCharsets.UTF_8); DataBuffer buffer = createDataBuffer(bytes.length); @@ -260,8 +287,10 @@ public class DataBufferTests extends AbstractDataBufferAllocatingTestCase { release(buffer); } - @Test - public void toStringSection() { + @ParameterizedDataBufferAllocatingTest + public void toStringSection(String displayName, DataBufferFactory bufferFactory) { + super.bufferFactory = bufferFactory; + String spring = "Spring"; byte[] bytes = spring.getBytes(StandardCharsets.UTF_8); DataBuffer buffer = createDataBuffer(bytes.length); @@ -273,8 +302,10 @@ public class DataBufferTests extends AbstractDataBufferAllocatingTestCase { release(buffer); } - @Test - public void inputStream() throws IOException { + @ParameterizedDataBufferAllocatingTest + public void inputStream(String displayName, DataBufferFactory bufferFactory) throws Exception { + super.bufferFactory = bufferFactory; + DataBuffer buffer = createDataBuffer(4); buffer.write(new byte[]{'a', 'b', 'c', 'd', 'e'}); buffer.readPosition(1); @@ -305,8 +336,10 @@ public class DataBufferTests extends AbstractDataBufferAllocatingTestCase { release(buffer); } - @Test - public void inputStreamReleaseOnClose() throws IOException { + @ParameterizedDataBufferAllocatingTest + public void inputStreamReleaseOnClose(String displayName, DataBufferFactory bufferFactory) throws Exception { + super.bufferFactory = bufferFactory; + DataBuffer buffer = createDataBuffer(3); byte[] bytes = {'a', 'b', 'c'}; buffer.write(bytes); @@ -323,12 +356,13 @@ public class DataBufferTests extends AbstractDataBufferAllocatingTestCase { inputStream.close(); } - // AbstractDataBufferAllocatingTestCase.LeakDetector will verify the buffer's release - + // AbstractDataBufferAllocatingTests.leakDetector will verify the buffer's release } - @Test - public void outputStream() throws IOException { + @ParameterizedDataBufferAllocatingTest + public void outputStream(String displayName, DataBufferFactory bufferFactory) throws Exception { + super.bufferFactory = bufferFactory; + DataBuffer buffer = createDataBuffer(4); buffer.write((byte) 'a'); @@ -345,8 +379,10 @@ public class DataBufferTests extends AbstractDataBufferAllocatingTestCase { release(buffer); } - @Test - public void expand() { + @ParameterizedDataBufferAllocatingTest + public void expand(String displayName, DataBufferFactory bufferFactory) { + super.bufferFactory = bufferFactory; + DataBuffer buffer = createDataBuffer(1); buffer.write((byte) 'a'); assertThat(buffer.capacity()).isEqualTo(1); @@ -357,8 +393,10 @@ public class DataBufferTests extends AbstractDataBufferAllocatingTestCase { release(buffer); } - @Test - public void increaseCapacity() { + @ParameterizedDataBufferAllocatingTest + public void increaseCapacity(String displayName, DataBufferFactory bufferFactory) { + super.bufferFactory = bufferFactory; + DataBuffer buffer = createDataBuffer(1); assertThat(buffer.capacity()).isEqualTo(1); @@ -368,8 +406,10 @@ public class DataBufferTests extends AbstractDataBufferAllocatingTestCase { release(buffer); } - @Test - public void decreaseCapacityLowReadPosition() { + @ParameterizedDataBufferAllocatingTest + public void decreaseCapacityLowReadPosition(String displayName, DataBufferFactory bufferFactory) { + super.bufferFactory = bufferFactory; + DataBuffer buffer = createDataBuffer(2); buffer.writePosition(2); buffer.capacity(1); @@ -378,8 +418,10 @@ public class DataBufferTests extends AbstractDataBufferAllocatingTestCase { release(buffer); } - @Test - public void decreaseCapacityHighReadPosition() { + @ParameterizedDataBufferAllocatingTest + public void decreaseCapacityHighReadPosition(String displayName, DataBufferFactory bufferFactory) { + super.bufferFactory = bufferFactory; + DataBuffer buffer = createDataBuffer(2); buffer.writePosition(2); buffer.readPosition(2); @@ -389,8 +431,10 @@ public class DataBufferTests extends AbstractDataBufferAllocatingTestCase { release(buffer); } - @Test - public void capacityLessThanZero() { + @ParameterizedDataBufferAllocatingTest + public void capacityLessThanZero(String displayName, DataBufferFactory bufferFactory) { + super.bufferFactory = bufferFactory; + DataBuffer buffer = createDataBuffer(1); try { assertThatIllegalArgumentException().isThrownBy(() -> @@ -401,8 +445,10 @@ public class DataBufferTests extends AbstractDataBufferAllocatingTestCase { } } - @Test - public void writeByteBuffer() { + @ParameterizedDataBufferAllocatingTest + public void writeByteBuffer(String displayName, DataBufferFactory bufferFactory) { + super.bufferFactory = bufferFactory; + DataBuffer buffer1 = createDataBuffer(1); buffer1.write((byte) 'a'); ByteBuffer buffer2 = createByteBuffer(2); @@ -428,8 +474,10 @@ public class DataBufferTests extends AbstractDataBufferAllocatingTestCase { return ByteBuffer.allocate(capacity); } - @Test - public void writeDataBuffer() { + @ParameterizedDataBufferAllocatingTest + public void writeDataBuffer(String displayName, DataBufferFactory bufferFactory) { + super.bufferFactory = bufferFactory; + DataBuffer buffer1 = createDataBuffer(1); buffer1.write((byte) 'a'); DataBuffer buffer2 = createDataBuffer(2); @@ -449,8 +497,10 @@ public class DataBufferTests extends AbstractDataBufferAllocatingTestCase { release(buffer1, buffer2, buffer3); } - @Test - public void asByteBuffer() { + @ParameterizedDataBufferAllocatingTest + public void asByteBuffer(String displayName, DataBufferFactory bufferFactory) { + super.bufferFactory = bufferFactory; + DataBuffer buffer = createDataBuffer(4); buffer.write(new byte[]{'a', 'b', 'c'}); buffer.read(); // skip a @@ -468,8 +518,10 @@ public class DataBufferTests extends AbstractDataBufferAllocatingTestCase { release(buffer); } - @Test - public void asByteBufferIndexLength() { + @ParameterizedDataBufferAllocatingTest + public void asByteBufferIndexLength(String displayName, DataBufferFactory bufferFactory) { + super.bufferFactory = bufferFactory; + DataBuffer buffer = createDataBuffer(3); buffer.write(new byte[]{'a', 'b'}); @@ -486,8 +538,10 @@ public class DataBufferTests extends AbstractDataBufferAllocatingTestCase { release(buffer); } - @Test - public void byteBufferContainsDataBufferChanges() { + @ParameterizedDataBufferAllocatingTest + public void byteBufferContainsDataBufferChanges(String displayName, DataBufferFactory bufferFactory) { + super.bufferFactory = bufferFactory; + DataBuffer dataBuffer = createDataBuffer(1); ByteBuffer byteBuffer = dataBuffer.asByteBuffer(0, 1); @@ -500,8 +554,10 @@ public class DataBufferTests extends AbstractDataBufferAllocatingTestCase { release(dataBuffer); } - @Test - public void dataBufferContainsByteBufferChanges() { + @ParameterizedDataBufferAllocatingTest + public void dataBufferContainsByteBufferChanges(String displayName, DataBufferFactory bufferFactory) { + super.bufferFactory = bufferFactory; + DataBuffer dataBuffer = createDataBuffer(1); ByteBuffer byteBuffer = dataBuffer.asByteBuffer(0, 1); @@ -514,8 +570,10 @@ public class DataBufferTests extends AbstractDataBufferAllocatingTestCase { release(dataBuffer); } - @Test - public void emptyAsByteBuffer() { + @ParameterizedDataBufferAllocatingTest + public void emptyAsByteBuffer(String displayName, DataBufferFactory bufferFactory) { + super.bufferFactory = bufferFactory; + DataBuffer buffer = createDataBuffer(1); ByteBuffer result = buffer.asByteBuffer(); @@ -524,8 +582,10 @@ public class DataBufferTests extends AbstractDataBufferAllocatingTestCase { release(buffer); } - @Test - public void indexOf() { + @ParameterizedDataBufferAllocatingTest + public void indexOf(String displayName, DataBufferFactory bufferFactory) { + super.bufferFactory = bufferFactory; + DataBuffer buffer = createDataBuffer(3); buffer.write(new byte[]{'a', 'b', 'c'}); @@ -544,8 +604,10 @@ public class DataBufferTests extends AbstractDataBufferAllocatingTestCase { release(buffer); } - @Test - public void lastIndexOf() { + @ParameterizedDataBufferAllocatingTest + public void lastIndexOf(String displayName, DataBufferFactory bufferFactory) { + super.bufferFactory = bufferFactory; + DataBuffer buffer = createDataBuffer(3); buffer.write(new byte[]{'a', 'b', 'c'}); @@ -573,8 +635,10 @@ public class DataBufferTests extends AbstractDataBufferAllocatingTestCase { release(buffer); } - @Test - public void slice() { + @ParameterizedDataBufferAllocatingTest + public void slice(String displayName, DataBufferFactory bufferFactory) { + super.bufferFactory = bufferFactory; + DataBuffer buffer = createDataBuffer(3); buffer.write(new byte[]{'a', 'b'}); @@ -600,8 +664,10 @@ public class DataBufferTests extends AbstractDataBufferAllocatingTestCase { release(buffer); } - @Test - public void retainedSlice() { + @ParameterizedDataBufferAllocatingTest + public void retainedSlice(String displayName, DataBufferFactory bufferFactory) { + super.bufferFactory = bufferFactory; + DataBuffer buffer = createDataBuffer(3); buffer.write(new byte[]{'a', 'b'}); @@ -627,8 +693,10 @@ public class DataBufferTests extends AbstractDataBufferAllocatingTestCase { release(buffer, slice); } - @Test - public void spr16351() { + @ParameterizedDataBufferAllocatingTest + public void spr16351(String displayName, DataBufferFactory bufferFactory) { + super.bufferFactory = bufferFactory; + DataBuffer buffer = createDataBuffer(6); byte[] bytes = {'a', 'b', 'c', 'd', 'e', 'f'}; buffer.write(bytes); @@ -645,8 +713,10 @@ public class DataBufferTests extends AbstractDataBufferAllocatingTestCase { release(buffer); } - @Test - public void join() { + @ParameterizedDataBufferAllocatingTest + public void join(String displayName, DataBufferFactory bufferFactory) { + super.bufferFactory = bufferFactory; + DataBuffer composite = this.bufferFactory.join(Arrays.asList(stringBuffer("a"), stringBuffer("b"), stringBuffer("c"))); assertThat(composite.readableByteCount()).isEqualTo(3); @@ -658,8 +728,10 @@ public class DataBufferTests extends AbstractDataBufferAllocatingTestCase { release(composite); } - @Test - public void getByte() { + @ParameterizedDataBufferAllocatingTest + public void getByte(String displayName, DataBufferFactory bufferFactory) { + super.bufferFactory = bufferFactory; + DataBuffer buffer = stringBuffer("abc"); assertThat(buffer.getByte(0)).isEqualTo((byte) 'a'); diff --git a/spring-core/src/test/java/org/springframework/core/io/buffer/DataBufferUtilsTests.java b/spring-core/src/test/java/org/springframework/core/io/buffer/DataBufferUtilsTests.java index 15d2de4b3a..836074b5e8 100644 --- a/spring-core/src/test/java/org/springframework/core/io/buffer/DataBufferUtilsTests.java +++ b/spring-core/src/test/java/org/springframework/core/io/buffer/DataBufferUtilsTests.java @@ -35,8 +35,6 @@ import java.util.List; import java.util.concurrent.CountDownLatch; import io.netty.buffer.ByteBuf; -import org.junit.Before; -import org.junit.Test; import org.mockito.stubbing.Answer; import org.reactivestreams.Subscription; import reactor.core.publisher.BaseSubscriber; @@ -59,40 +57,46 @@ import static org.mockito.Mockito.mock; /** * @author Arjen Poutsma + * @author Sam Brannen */ -public class DataBufferUtilsTests extends AbstractDataBufferAllocatingTestCase { +class DataBufferUtilsTests extends AbstractDataBufferAllocatingTests { - private Resource resource; + private final Resource resource; + private final Path tempFile; - private Path tempFile; - - @Before - public void setUp() throws IOException { + DataBufferUtilsTests() throws Exception { this.resource = new ClassPathResource("DataBufferUtilsTests.txt", getClass()); this.tempFile = Files.createTempFile("DataBufferUtilsTests", null); } - @Test - public void readInputStream() { + + @ParameterizedDataBufferAllocatingTest + public void readInputStream(String displayName, DataBufferFactory bufferFactory) { + super.bufferFactory = bufferFactory; + Flux flux = DataBufferUtils.readInputStream( - () -> this.resource.getInputStream(), this.bufferFactory, 3); + () -> this.resource.getInputStream(), super.bufferFactory, 3); verifyReadData(flux); } - @Test - public void readByteChannel() throws Exception { + @ParameterizedDataBufferAllocatingTest + public void readByteChannel(String displayName, DataBufferFactory bufferFactory) throws Exception { + super.bufferFactory = bufferFactory; + URI uri = this.resource.getURI(); Flux result = DataBufferUtils.readByteChannel(() -> FileChannel.open(Paths.get(uri), StandardOpenOption.READ), - this.bufferFactory, 3); + super.bufferFactory, 3); verifyReadData(result); } - @Test - public void readByteChannelError() throws Exception { + @ParameterizedDataBufferAllocatingTest + public void readByteChannelError(String displayName, DataBufferFactory bufferFactory) throws Exception { + super.bufferFactory = bufferFactory; + ReadableByteChannel channel = mock(ReadableByteChannel.class); given(channel.read(any())) .willAnswer(invocation -> { @@ -104,7 +108,7 @@ public class DataBufferUtilsTests extends AbstractDataBufferAllocatingTestCase { .willThrow(new IOException()); Flux result = - DataBufferUtils.readByteChannel(() -> channel, this.bufferFactory, 3); + DataBufferUtils.readByteChannel(() -> channel, super.bufferFactory, 3); StepVerifier.create(result) .consumeNextWith(stringConsumer("foo")) @@ -112,12 +116,14 @@ public class DataBufferUtilsTests extends AbstractDataBufferAllocatingTestCase { .verify(Duration.ofSeconds(3)); } - @Test - public void readByteChannelCancel() throws Exception { + @ParameterizedDataBufferAllocatingTest + public void readByteChannelCancel(String displayName, DataBufferFactory bufferFactory) throws Exception { + super.bufferFactory = bufferFactory; + URI uri = this.resource.getURI(); Flux result = DataBufferUtils.readByteChannel(() -> FileChannel.open(Paths.get(uri), StandardOpenOption.READ), - this.bufferFactory, 3); + super.bufferFactory, 3); StepVerifier.create(result) .consumeNextWith(stringConsumer("foo")) @@ -125,22 +131,26 @@ public class DataBufferUtilsTests extends AbstractDataBufferAllocatingTestCase { .verify(); } - @Test - public void readAsynchronousFileChannel() throws Exception { + @ParameterizedDataBufferAllocatingTest + public void readAsynchronousFileChannel(String displayName, DataBufferFactory bufferFactory) throws Exception { + super.bufferFactory = bufferFactory; + URI uri = this.resource.getURI(); Flux flux = DataBufferUtils.readAsynchronousFileChannel( () -> AsynchronousFileChannel.open(Paths.get(uri), StandardOpenOption.READ), - this.bufferFactory, 3); + super.bufferFactory, 3); verifyReadData(flux); } - @Test - public void readAsynchronousFileChannelPosition() throws Exception { + @ParameterizedDataBufferAllocatingTest + public void readAsynchronousFileChannelPosition(String displayName, DataBufferFactory bufferFactory) throws Exception { + super.bufferFactory = bufferFactory; + URI uri = this.resource.getURI(); Flux flux = DataBufferUtils.readAsynchronousFileChannel( () -> AsynchronousFileChannel.open(Paths.get(uri), StandardOpenOption.READ), - 9, this.bufferFactory, 3); + 9, super.bufferFactory, 3); StepVerifier.create(flux) .consumeNextWith(stringConsumer("qux")) @@ -148,8 +158,10 @@ public class DataBufferUtilsTests extends AbstractDataBufferAllocatingTestCase { .verify(Duration.ofSeconds(5)); } - @Test - public void readAsynchronousFileChannelError() throws Exception { + @ParameterizedDataBufferAllocatingTest + public void readAsynchronousFileChannelError(String displayName, DataBufferFactory bufferFactory) throws Exception { + super.bufferFactory = bufferFactory; + AsynchronousFileChannel channel = mock(AsynchronousFileChannel.class); willAnswer(invocation -> { ByteBuffer byteBuffer = invocation.getArgument(0); @@ -170,7 +182,7 @@ public class DataBufferUtilsTests extends AbstractDataBufferAllocatingTestCase { .given(channel).read(any(), anyLong(), any(), any()); Flux result = - DataBufferUtils.readAsynchronousFileChannel(() -> channel, this.bufferFactory, 3); + DataBufferUtils.readAsynchronousFileChannel(() -> channel, super.bufferFactory, 3); StepVerifier.create(result) .consumeNextWith(stringConsumer("foo")) @@ -178,12 +190,14 @@ public class DataBufferUtilsTests extends AbstractDataBufferAllocatingTestCase { .verify(Duration.ofSeconds(3)); } - @Test - public void readAsynchronousFileChannelCancel() throws Exception { + @ParameterizedDataBufferAllocatingTest + public void readAsynchronousFileChannelCancel(String displayName, DataBufferFactory bufferFactory) throws Exception { + super.bufferFactory = bufferFactory; + URI uri = this.resource.getURI(); Flux flux = DataBufferUtils.readAsynchronousFileChannel( () -> AsynchronousFileChannel.open(Paths.get(uri), StandardOpenOption.READ), - this.bufferFactory, 3); + super.bufferFactory, 3); StepVerifier.create(flux) .consumeNextWith(stringConsumer("foo")) @@ -191,35 +205,43 @@ public class DataBufferUtilsTests extends AbstractDataBufferAllocatingTestCase { .verify(); } - @Test // gh-22107 - public void readAsynchronousFileChannelCancelWithoutDemand() throws Exception { + @ParameterizedDataBufferAllocatingTest // gh-22107 + public void readAsynchronousFileChannelCancelWithoutDemand(String displayName, DataBufferFactory bufferFactory) throws Exception { + super.bufferFactory = bufferFactory; + URI uri = this.resource.getURI(); Flux flux = DataBufferUtils.readAsynchronousFileChannel( () -> AsynchronousFileChannel.open(Paths.get(uri), StandardOpenOption.READ), - this.bufferFactory, 3); + super.bufferFactory, 3); BaseSubscriber subscriber = new ZeroDemandSubscriber(); flux.subscribe(subscriber); subscriber.cancel(); } - @Test - public void readPath() throws IOException { - Flux flux = DataBufferUtils.read(this.resource.getFile().toPath(), this.bufferFactory, 3); + @ParameterizedDataBufferAllocatingTest + public void readPath(String displayName, DataBufferFactory bufferFactory) throws Exception { + super.bufferFactory = bufferFactory; + + Flux flux = DataBufferUtils.read(this.resource.getFile().toPath(), super.bufferFactory, 3); verifyReadData(flux); } - @Test - public void readResource() throws Exception { - Flux flux = DataBufferUtils.read(this.resource, this.bufferFactory, 3); + @ParameterizedDataBufferAllocatingTest + public void readResource(String displayName, DataBufferFactory bufferFactory) throws Exception { + super.bufferFactory = bufferFactory; + + Flux flux = DataBufferUtils.read(this.resource, super.bufferFactory, 3); verifyReadData(flux); } - @Test - public void readResourcePosition() throws Exception { - Flux flux = DataBufferUtils.read(this.resource, 9, this.bufferFactory, 3); + @ParameterizedDataBufferAllocatingTest + public void readResourcePosition(String displayName, DataBufferFactory bufferFactory) throws Exception { + super.bufferFactory = bufferFactory; + + Flux flux = DataBufferUtils.read(this.resource, 9, super.bufferFactory, 3); StepVerifier.create(flux) .consumeNextWith(stringConsumer("qux")) @@ -237,10 +259,12 @@ public class DataBufferUtilsTests extends AbstractDataBufferAllocatingTestCase { .verify(Duration.ofSeconds(3)); } - @Test - public void readResourcePositionAndTakeUntil() throws Exception { + @ParameterizedDataBufferAllocatingTest + public void readResourcePositionAndTakeUntil(String displayName, DataBufferFactory bufferFactory) throws Exception { + super.bufferFactory = bufferFactory; + Resource resource = new ClassPathResource("DataBufferUtilsTests.txt", getClass()); - Flux flux = DataBufferUtils.read(resource, 3, this.bufferFactory, 3); + Flux flux = DataBufferUtils.read(resource, 3, super.bufferFactory, 3); flux = DataBufferUtils.takeUntilByteCount(flux, 5); @@ -252,10 +276,12 @@ public class DataBufferUtilsTests extends AbstractDataBufferAllocatingTestCase { .verify(Duration.ofSeconds(5)); } - @Test - public void readByteArrayResourcePositionAndTakeUntil() throws Exception { + @ParameterizedDataBufferAllocatingTest + public void readByteArrayResourcePositionAndTakeUntil(String displayName, DataBufferFactory bufferFactory) throws Exception { + super.bufferFactory = bufferFactory; + Resource resource = new ByteArrayResource("foobarbazqux" .getBytes()); - Flux flux = DataBufferUtils.read(resource, 3, this.bufferFactory, 3); + Flux flux = DataBufferUtils.read(resource, 3, super.bufferFactory, 3); flux = DataBufferUtils.takeUntilByteCount(flux, 5); @@ -267,8 +293,10 @@ public class DataBufferUtilsTests extends AbstractDataBufferAllocatingTestCase { .verify(Duration.ofSeconds(5)); } - @Test - public void writeOutputStream() throws Exception { + @ParameterizedDataBufferAllocatingTest + public void writeOutputStream(String displayName, DataBufferFactory bufferFactory) throws Exception { + super.bufferFactory = bufferFactory; + DataBuffer foo = stringBuffer("foo"); DataBuffer bar = stringBuffer("bar"); DataBuffer baz = stringBuffer("baz"); @@ -282,8 +310,10 @@ public class DataBufferUtilsTests extends AbstractDataBufferAllocatingTestCase { os.close(); } - @Test - public void writeWritableByteChannel() throws Exception { + @ParameterizedDataBufferAllocatingTest + public void writeWritableByteChannel(String displayName, DataBufferFactory bufferFactory) throws Exception { + super.bufferFactory = bufferFactory; + DataBuffer foo = stringBuffer("foo"); DataBuffer bar = stringBuffer("bar"); DataBuffer baz = stringBuffer("baz"); @@ -297,8 +327,10 @@ public class DataBufferUtilsTests extends AbstractDataBufferAllocatingTestCase { channel.close(); } - @Test - public void writeWritableByteChannelErrorInFlux() throws Exception { + @ParameterizedDataBufferAllocatingTest + public void writeWritableByteChannelErrorInFlux(String displayName, DataBufferFactory bufferFactory) throws Exception { + super.bufferFactory = bufferFactory; + DataBuffer foo = stringBuffer("foo"); DataBuffer bar = stringBuffer("bar"); Flux flux = Flux.just(foo, bar).concatWith(Flux.error(new RuntimeException())); @@ -318,8 +350,10 @@ public class DataBufferUtilsTests extends AbstractDataBufferAllocatingTestCase { channel.close(); } - @Test - public void writeWritableByteChannelErrorInWrite() throws Exception { + @ParameterizedDataBufferAllocatingTest + public void writeWritableByteChannelErrorInWrite(String displayName, DataBufferFactory bufferFactory) throws Exception { + super.bufferFactory = bufferFactory; + DataBuffer foo = stringBuffer("foo"); DataBuffer bar = stringBuffer("bar"); Flux flux = Flux.just(foo, bar); @@ -344,8 +378,10 @@ public class DataBufferUtilsTests extends AbstractDataBufferAllocatingTestCase { channel.close(); } - @Test - public void writeWritableByteChannelCancel() throws Exception { + @ParameterizedDataBufferAllocatingTest + public void writeWritableByteChannelCancel(String displayName, DataBufferFactory bufferFactory) throws Exception { + super.bufferFactory = bufferFactory; + DataBuffer foo = stringBuffer("foo"); DataBuffer bar = stringBuffer("bar"); Flux flux = Flux.just(foo, bar); @@ -366,8 +402,10 @@ public class DataBufferUtilsTests extends AbstractDataBufferAllocatingTestCase { flux.subscribe(DataBufferUtils::release); } - @Test - public void writeAsynchronousFileChannel() throws Exception { + @ParameterizedDataBufferAllocatingTest + public void writeAsynchronousFileChannel(String displayName, DataBufferFactory bufferFactory) throws Exception { + super.bufferFactory = bufferFactory; + DataBuffer foo = stringBuffer("foo"); DataBuffer bar = stringBuffer("bar"); DataBuffer baz = stringBuffer("baz"); @@ -396,8 +434,10 @@ public class DataBufferUtilsTests extends AbstractDataBufferAllocatingTestCase { assertThat(result).isEqualTo("foobarbazqux"); } - @Test - public void writeAsynchronousFileChannelErrorInFlux() throws Exception { + @ParameterizedDataBufferAllocatingTest + public void writeAsynchronousFileChannelErrorInFlux(String displayName, DataBufferFactory bufferFactory) throws Exception { + super.bufferFactory = bufferFactory; + DataBuffer foo = stringBuffer("foo"); DataBuffer bar = stringBuffer("bar"); Flux flux = @@ -419,9 +459,11 @@ public class DataBufferUtilsTests extends AbstractDataBufferAllocatingTestCase { channel.close(); } - @Test + @ParameterizedDataBufferAllocatingTest @SuppressWarnings("unchecked") - public void writeAsynchronousFileChannelErrorInWrite() throws Exception { + public void writeAsynchronousFileChannelErrorInWrite(String displayName, DataBufferFactory bufferFactory) throws Exception { + super.bufferFactory = bufferFactory; + DataBuffer foo = stringBuffer("foo"); DataBuffer bar = stringBuffer("bar"); Flux flux = Flux.just(foo, bar); @@ -459,8 +501,10 @@ public class DataBufferUtilsTests extends AbstractDataBufferAllocatingTestCase { channel.close(); } - @Test - public void writeAsynchronousFileChannelCanceled() throws Exception { + @ParameterizedDataBufferAllocatingTest + public void writeAsynchronousFileChannelCanceled(String displayName, DataBufferFactory bufferFactory) throws Exception { + super.bufferFactory = bufferFactory; + DataBuffer foo = stringBuffer("foo"); DataBuffer bar = stringBuffer("bar"); Flux flux = Flux.just(foo, bar); @@ -482,8 +526,10 @@ public class DataBufferUtilsTests extends AbstractDataBufferAllocatingTestCase { flux.subscribe(DataBufferUtils::release); } - @Test - public void writePath() throws IOException { + @ParameterizedDataBufferAllocatingTest + public void writePath(String displayName, DataBufferFactory bufferFactory) throws Exception { + super.bufferFactory = bufferFactory; + DataBuffer foo = stringBuffer("foo"); DataBuffer bar = stringBuffer("bar"); Flux flux = Flux.just(foo, bar); @@ -497,14 +543,16 @@ public class DataBufferUtilsTests extends AbstractDataBufferAllocatingTestCase { assertThat(written).contains("foobar"); } - @Test - public void readAndWriteByteChannel() throws Exception { + @ParameterizedDataBufferAllocatingTest + public void readAndWriteByteChannel(String displayName, DataBufferFactory bufferFactory) throws Exception { + super.bufferFactory = bufferFactory; + Path source = Paths.get( DataBufferUtilsTests.class.getResource("DataBufferUtilsTests.txt").toURI()); Flux sourceFlux = DataBufferUtils .readByteChannel(() -> FileChannel.open(source, StandardOpenOption.READ), - this.bufferFactory, 3); + super.bufferFactory, 3); Path destination = Files.createTempFile("DataBufferUtilsTests", null); WritableByteChannel channel = Files.newByteChannel(destination, StandardOpenOption.WRITE); @@ -529,13 +577,15 @@ public class DataBufferUtilsTests extends AbstractDataBufferAllocatingTestCase { }); } - @Test - public void readAndWriteAsynchronousFileChannel() throws Exception { + @ParameterizedDataBufferAllocatingTest + public void readAndWriteAsynchronousFileChannel(String displayName, DataBufferFactory bufferFactory) throws Exception { + super.bufferFactory = bufferFactory; + Path source = Paths.get( DataBufferUtilsTests.class.getResource("DataBufferUtilsTests.txt").toURI()); Flux sourceFlux = DataBufferUtils.readAsynchronousFileChannel( () -> AsynchronousFileChannel.open(source, StandardOpenOption.READ), - this.bufferFactory, 3); + super.bufferFactory, 3); Path destination = Files.createTempFile("DataBufferUtilsTests", null); AsynchronousFileChannel channel = @@ -568,8 +618,9 @@ public class DataBufferUtilsTests extends AbstractDataBufferAllocatingTestCase { latch.await(); } - @Test - public void takeUntilByteCount() { + @ParameterizedDataBufferAllocatingTest + public void takeUntilByteCount(String displayName, DataBufferFactory bufferFactory) { + super.bufferFactory = bufferFactory; Flux result = DataBufferUtils.takeUntilByteCount( Flux.just(stringBuffer("foo"), stringBuffer("bar")), 5L); @@ -581,8 +632,10 @@ public class DataBufferUtilsTests extends AbstractDataBufferAllocatingTestCase { .verify(Duration.ofSeconds(5)); } - @Test - public void takeUntilByteCountCanceled() { + @ParameterizedDataBufferAllocatingTest + public void takeUntilByteCountCanceled(String displayName, DataBufferFactory bufferFactory) { + super.bufferFactory = bufferFactory; + Flux source = Flux.concat( deferStringBuffer("foo"), deferStringBuffer("bar") @@ -596,8 +649,10 @@ public class DataBufferUtilsTests extends AbstractDataBufferAllocatingTestCase { .verify(Duration.ofSeconds(5)); } - @Test - public void takeUntilByteCountError() { + @ParameterizedDataBufferAllocatingTest + public void takeUntilByteCountError(String displayName, DataBufferFactory bufferFactory) { + super.bufferFactory = bufferFactory; + Flux source = Flux.concat( Mono.defer(() -> Mono.just(stringBuffer("foo"))), Mono.error(new RuntimeException()) @@ -611,8 +666,10 @@ public class DataBufferUtilsTests extends AbstractDataBufferAllocatingTestCase { .verify(Duration.ofSeconds(5)); } - @Test - public void takeUntilByteCountExact() { + @ParameterizedDataBufferAllocatingTest + public void takeUntilByteCountExact(String displayName, DataBufferFactory bufferFactory) { + super.bufferFactory = bufferFactory; + Flux source = Flux.concat( deferStringBuffer("foo"), deferStringBuffer("bar"), @@ -628,8 +685,10 @@ public class DataBufferUtilsTests extends AbstractDataBufferAllocatingTestCase { .verify(Duration.ofSeconds(5)); } - @Test - public void skipUntilByteCount() { + @ParameterizedDataBufferAllocatingTest + public void skipUntilByteCount(String displayName, DataBufferFactory bufferFactory) { + super.bufferFactory = bufferFactory; + Flux source = Flux.concat( deferStringBuffer("foo"), deferStringBuffer("bar"), @@ -644,8 +703,10 @@ public class DataBufferUtilsTests extends AbstractDataBufferAllocatingTestCase { .verify(Duration.ofSeconds(5)); } - @Test - public void skipUntilByteCountCancelled() { + @ParameterizedDataBufferAllocatingTest + public void skipUntilByteCountCancelled(String displayName, DataBufferFactory bufferFactory) { + super.bufferFactory = bufferFactory; + Flux source = Flux.concat( deferStringBuffer("foo"), deferStringBuffer("bar") @@ -658,8 +719,10 @@ public class DataBufferUtilsTests extends AbstractDataBufferAllocatingTestCase { .verify(Duration.ofSeconds(5)); } - @Test - public void skipUntilByteCountErrorInFlux() { + @ParameterizedDataBufferAllocatingTest + public void skipUntilByteCountErrorInFlux(String displayName, DataBufferFactory bufferFactory) { + super.bufferFactory = bufferFactory; + DataBuffer foo = stringBuffer("foo"); Flux flux = Flux.just(foo).concatWith(Mono.error(new RuntimeException())); @@ -670,8 +733,10 @@ public class DataBufferUtilsTests extends AbstractDataBufferAllocatingTestCase { .verify(Duration.ofSeconds(5)); } - @Test - public void skipUntilByteCountShouldSkipAll() { + @ParameterizedDataBufferAllocatingTest + public void skipUntilByteCountShouldSkipAll(String displayName, DataBufferFactory bufferFactory) { + super.bufferFactory = bufferFactory; + DataBuffer foo = stringBuffer("foo"); DataBuffer bar = stringBuffer("bar"); DataBuffer baz = stringBuffer("baz"); @@ -683,8 +748,10 @@ public class DataBufferUtilsTests extends AbstractDataBufferAllocatingTestCase { .verify(Duration.ofSeconds(5)); } - @Test - public void releaseConsumer() { + @ParameterizedDataBufferAllocatingTest + public void releaseConsumer(String displayName, DataBufferFactory bufferFactory) { + super.bufferFactory = bufferFactory; + DataBuffer foo = stringBuffer("foo"); DataBuffer bar = stringBuffer("bar"); DataBuffer baz = stringBuffer("baz"); @@ -704,8 +771,10 @@ public class DataBufferUtilsTests extends AbstractDataBufferAllocatingTestCase { } } - @Test - public void SPR16070() throws Exception { + @ParameterizedDataBufferAllocatingTest + public void SPR16070(String displayName, DataBufferFactory bufferFactory) throws Exception { + super.bufferFactory = bufferFactory; + ReadableByteChannel channel = mock(ReadableByteChannel.class); given(channel.read(any())) .willAnswer(putByte('a')) @@ -714,7 +783,7 @@ public class DataBufferUtilsTests extends AbstractDataBufferAllocatingTestCase { .willReturn(-1); Flux read = - DataBufferUtils.readByteChannel(() -> channel, this.bufferFactory, 1); + DataBufferUtils.readByteChannel(() -> channel, super.bufferFactory, 1); StepVerifier.create(read) .consumeNextWith(stringConsumer("a")) @@ -733,8 +802,10 @@ public class DataBufferUtilsTests extends AbstractDataBufferAllocatingTestCase { }; } - @Test - public void join() { + @ParameterizedDataBufferAllocatingTest + public void join(String displayName, DataBufferFactory bufferFactory) { + super.bufferFactory = bufferFactory; + DataBuffer foo = stringBuffer("foo"); DataBuffer bar = stringBuffer("bar"); DataBuffer baz = stringBuffer("baz"); @@ -749,8 +820,10 @@ public class DataBufferUtilsTests extends AbstractDataBufferAllocatingTestCase { .verifyComplete(); } - @Test - public void joinErrors() { + @ParameterizedDataBufferAllocatingTest + public void joinErrors(String displayName, DataBufferFactory bufferFactory) { + super.bufferFactory = bufferFactory; + DataBuffer foo = stringBuffer("foo"); DataBuffer bar = stringBuffer("bar"); Flux flux = Flux.just(foo, bar).concatWith(Flux.error(new RuntimeException())); @@ -761,8 +834,10 @@ public class DataBufferUtilsTests extends AbstractDataBufferAllocatingTestCase { .verify(); } - @Test - public void joinCanceled() { + @ParameterizedDataBufferAllocatingTest + public void joinCanceled(String displayName, DataBufferFactory bufferFactory) { + super.bufferFactory = bufferFactory; + Flux source = Flux.concat( deferStringBuffer("foo"), deferStringBuffer("bar"), @@ -775,8 +850,10 @@ public class DataBufferUtilsTests extends AbstractDataBufferAllocatingTestCase { .verify(); } - @Test - public void matcher() { + @ParameterizedDataBufferAllocatingTest + public void matcher(String displayName, DataBufferFactory bufferFactory) { + super.bufferFactory = bufferFactory; + DataBuffer foo = stringBuffer("foo"); DataBuffer bar = stringBuffer("bar"); @@ -791,8 +868,10 @@ public class DataBufferUtilsTests extends AbstractDataBufferAllocatingTestCase { release(foo, bar); } - @Test - public void matcher2() { + @ParameterizedDataBufferAllocatingTest + public void matcher2(String displayName, DataBufferFactory bufferFactory) { + super.bufferFactory = bufferFactory; + DataBuffer foo = stringBuffer("fooobar"); byte[] delims = "oo".getBytes(StandardCharsets.UTF_8); diff --git a/spring-core/src/test/java/org/springframework/core/io/buffer/LeakAwareDataBufferFactoryTests.java b/spring-core/src/test/java/org/springframework/core/io/buffer/LeakAwareDataBufferFactoryTests.java index 5df94eba4b..4e1d5f27de 100644 --- a/spring-core/src/test/java/org/springframework/core/io/buffer/LeakAwareDataBufferFactoryTests.java +++ b/spring-core/src/test/java/org/springframework/core/io/buffer/LeakAwareDataBufferFactoryTests.java @@ -24,7 +24,7 @@ import static org.springframework.core.io.buffer.DataBufferUtils.release; /** * @author Arjen Poutsma */ -public class LeakAwareDataBufferFactoryTests { +class LeakAwareDataBufferFactoryTests { private final LeakAwareDataBufferFactory bufferFactory = new LeakAwareDataBufferFactory(); diff --git a/spring-core/src/test/java/org/springframework/core/io/buffer/PooledDataBufferTests.java b/spring-core/src/test/java/org/springframework/core/io/buffer/PooledDataBufferTests.java index 71fe1f4629..71a1fed232 100644 --- a/spring-core/src/test/java/org/springframework/core/io/buffer/PooledDataBufferTests.java +++ b/spring-core/src/test/java/org/springframework/core/io/buffer/PooledDataBufferTests.java @@ -18,57 +18,81 @@ package org.springframework.core.io.buffer; import io.netty.buffer.PooledByteBufAllocator; import io.netty.buffer.UnpooledByteBufAllocator; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.junit.runners.Parameterized; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatIllegalStateException; /** * @author Arjen Poutsma + * @author Sam Brannen */ -@RunWith(Parameterized.class) -public class PooledDataBufferTests { +class PooledDataBufferTests { - @Parameterized.Parameter - public DataBufferFactory dataBufferFactory; + @Nested + class UnpooledByteBufAllocatorWithPreferDirectTrueTests implements PooledDataBufferTestingTrait { - @Parameterized.Parameters(name = "{0}") - public static Object[][] buffers() { - - return new Object[][]{ - {new NettyDataBufferFactory(new UnpooledByteBufAllocator(true))}, - {new NettyDataBufferFactory(new UnpooledByteBufAllocator(false))}, - {new NettyDataBufferFactory(new PooledByteBufAllocator(true))}, - {new NettyDataBufferFactory(new PooledByteBufAllocator(false))}}; + @Override + public DataBufferFactory createDataBufferFactory() { + return new NettyDataBufferFactory(new UnpooledByteBufAllocator(true)); + } } - private PooledDataBuffer createDataBuffer(int capacity) { - return (PooledDataBuffer) dataBufferFactory.allocateBuffer(capacity); + @Nested + class UnpooledByteBufAllocatorWithPreferDirectFalseTests implements PooledDataBufferTestingTrait { + + @Override + public DataBufferFactory createDataBufferFactory() { + return new NettyDataBufferFactory(new UnpooledByteBufAllocator(true)); + } } - @Test - public void retainAndRelease() { - PooledDataBuffer buffer = createDataBuffer(1); - buffer.write((byte) 'a'); + @Nested + class PooledByteBufAllocatorWithPreferDirectTrueTests implements PooledDataBufferTestingTrait { - buffer.retain(); - boolean result = buffer.release(); - assertThat(result).isFalse(); - result = buffer.release(); - assertThat(result).isTrue(); + @Override + public DataBufferFactory createDataBufferFactory() { + return new NettyDataBufferFactory(new PooledByteBufAllocator(true)); + } } - @Test - public void tooManyReleases() { - PooledDataBuffer buffer = createDataBuffer(1); - buffer.write((byte) 'a'); + @Nested + class PooledByteBufAllocatorWithPreferDirectFalseTests implements PooledDataBufferTestingTrait { - buffer.release(); - assertThatIllegalStateException().isThrownBy( - buffer::release); + @Override + public DataBufferFactory createDataBufferFactory() { + return new NettyDataBufferFactory(new PooledByteBufAllocator(true)); + } } + interface PooledDataBufferTestingTrait { + + DataBufferFactory createDataBufferFactory(); + + default PooledDataBuffer createDataBuffer(int capacity) { + return (PooledDataBuffer) createDataBufferFactory().allocateBuffer(capacity); + } + + @Test + default void retainAndRelease() { + PooledDataBuffer buffer = createDataBuffer(1); + buffer.write((byte) 'a'); + + buffer.retain(); + assertThat(buffer.release()).isFalse(); + assertThat(buffer.release()).isTrue(); + } + + @Test + default void tooManyReleases() { + PooledDataBuffer buffer = createDataBuffer(1); + buffer.write((byte) 'a'); + + buffer.release(); + assertThatIllegalStateException().isThrownBy(buffer::release); + } + + } } diff --git a/spring-core/src/test/java/org/springframework/core/io/buffer/support/DataBufferTestUtilsTests.java b/spring-core/src/test/java/org/springframework/core/io/buffer/support/DataBufferTestUtilsTests.java index 89dcb20fe2..b39b820dd8 100644 --- a/spring-core/src/test/java/org/springframework/core/io/buffer/support/DataBufferTestUtilsTests.java +++ b/spring-core/src/test/java/org/springframework/core/io/buffer/support/DataBufferTestUtilsTests.java @@ -18,20 +18,22 @@ package org.springframework.core.io.buffer.support; import java.nio.charset.StandardCharsets; -import org.junit.Test; - -import org.springframework.core.io.buffer.AbstractDataBufferAllocatingTestCase; +import org.springframework.core.io.buffer.AbstractDataBufferAllocatingTests; import org.springframework.core.io.buffer.DataBuffer; +import org.springframework.core.io.buffer.DataBufferFactory; import static org.assertj.core.api.Assertions.assertThat; /** * @author Arjen Poutsma + * @author Sam Brannen */ -public class DataBufferTestUtilsTests extends AbstractDataBufferAllocatingTestCase { +class DataBufferTestUtilsTests extends AbstractDataBufferAllocatingTests { + + @ParameterizedDataBufferAllocatingTest + public void dumpBytes(String displayName, DataBufferFactory bufferFactory) { + this.bufferFactory = bufferFactory; - @Test - public void dumpBytes() { DataBuffer buffer = this.bufferFactory.allocateBuffer(4); byte[] source = {'a', 'b', 'c', 'd'}; buffer.write(source); @@ -43,8 +45,10 @@ public class DataBufferTestUtilsTests extends AbstractDataBufferAllocatingTestCa release(buffer); } - @Test - public void dumpString() { + @ParameterizedDataBufferAllocatingTest + public void dumpString(String displayName, DataBufferFactory bufferFactory) { + this.bufferFactory = bufferFactory; + DataBuffer buffer = this.bufferFactory.allocateBuffer(4); String source = "abcd"; buffer.write(source.getBytes(StandardCharsets.UTF_8)); diff --git a/spring-web/src/test/java/org/springframework/http/codec/ServerSentEventHttpMessageWriterTests.java b/spring-web/src/test/java/org/springframework/http/codec/ServerSentEventHttpMessageWriterTests.java index 79f088be95..1fd2a75336 100644 --- a/spring-web/src/test/java/org/springframework/http/codec/ServerSentEventHttpMessageWriterTests.java +++ b/spring-web/src/test/java/org/springframework/http/codec/ServerSentEventHttpMessageWriterTests.java @@ -23,15 +23,14 @@ import java.util.Collections; import java.util.Map; import com.fasterxml.jackson.databind.ObjectMapper; -import org.junit.Before; -import org.junit.Test; import org.reactivestreams.Publisher; import reactor.core.publisher.Flux; import reactor.core.publisher.Mono; import reactor.test.StepVerifier; import org.springframework.core.ResolvableType; -import org.springframework.core.io.buffer.AbstractDataBufferAllocatingTestCase; +import org.springframework.core.io.buffer.AbstractDataBufferAllocatingTests; +import org.springframework.core.io.buffer.DataBufferFactory; import org.springframework.core.io.buffer.DataBufferUtils; import org.springframework.core.io.buffer.support.DataBufferTestUtils; import org.springframework.http.MediaType; @@ -47,27 +46,21 @@ import static org.springframework.core.ResolvableType.forClass; * * @author Sebastien Deleuze * @author Rossen Stoyanchev + * @author Sam Brannen */ @SuppressWarnings("rawtypes") -public class ServerSentEventHttpMessageWriterTests extends AbstractDataBufferAllocatingTestCase { +public class ServerSentEventHttpMessageWriterTests extends AbstractDataBufferAllocatingTests { private static final Map HINTS = Collections.emptyMap(); private ServerSentEventHttpMessageWriter messageWriter = new ServerSentEventHttpMessageWriter(new Jackson2JsonEncoder()); - private MockServerHttpResponse outputMessage; + @ParameterizedDataBufferAllocatingTest + public void canWrite(String displayName, DataBufferFactory bufferFactory) { + super.bufferFactory = bufferFactory; - @Before - public void setUp() { - this.outputMessage = new MockServerHttpResponse(this.bufferFactory); - } - - - - @Test - public void canWrite() { assertThat(this.messageWriter.canWrite(forClass(Object.class), null)).isTrue(); assertThat(this.messageWriter.canWrite(forClass(Object.class), new MediaType("foo", "bar"))).isFalse(); @@ -79,11 +72,14 @@ public class ServerSentEventHttpMessageWriterTests extends AbstractDataBufferAll assertThat(this.messageWriter.canWrite(ResolvableType.NONE, new MediaType("foo", "bar"))).isFalse(); } - @Test - public void writeServerSentEvent() { + @ParameterizedDataBufferAllocatingTest + public void writeServerSentEvent(String displayName, DataBufferFactory bufferFactory) { + super.bufferFactory = bufferFactory; + ServerSentEvent event = ServerSentEvent.builder().data("bar").id("c42").event("foo") .comment("bla\nbla bla\nbla bla bla").retry(Duration.ofMillis(123L)).build(); + MockServerHttpResponse outputMessage = new MockServerHttpResponse(super.bufferFactory); Mono source = Mono.just(event); testWrite(source, outputMessage, ServerSentEvent.class); @@ -94,8 +90,11 @@ public class ServerSentEventHttpMessageWriterTests extends AbstractDataBufferAll .verify(); } - @Test - public void writeString() { + @ParameterizedDataBufferAllocatingTest + public void writeString(String displayName, DataBufferFactory bufferFactory) { + super.bufferFactory = bufferFactory; + + MockServerHttpResponse outputMessage = new MockServerHttpResponse(super.bufferFactory); Flux source = Flux.just("foo", "bar"); testWrite(source, outputMessage, String.class); @@ -106,8 +105,11 @@ public class ServerSentEventHttpMessageWriterTests extends AbstractDataBufferAll .verify(); } - @Test - public void writeMultiLineString() { + @ParameterizedDataBufferAllocatingTest + public void writeMultiLineString(String displayName, DataBufferFactory bufferFactory) { + super.bufferFactory = bufferFactory; + + MockServerHttpResponse outputMessage = new MockServerHttpResponse(super.bufferFactory); Flux source = Flux.just("foo\nbar", "foo\nbaz"); testWrite(source, outputMessage, String.class); @@ -118,8 +120,11 @@ public class ServerSentEventHttpMessageWriterTests extends AbstractDataBufferAll .verify(); } - @Test // SPR-16516 - public void writeStringWithCustomCharset() { + @ParameterizedDataBufferAllocatingTest // SPR-16516 + public void writeStringWithCustomCharset(String displayName, DataBufferFactory bufferFactory) { + super.bufferFactory = bufferFactory; + + MockServerHttpResponse outputMessage = new MockServerHttpResponse(super.bufferFactory); Flux source = Flux.just("\u00A3"); Charset charset = StandardCharsets.ISO_8859_1; MediaType mediaType = new MediaType("text", "event-stream", charset); @@ -136,8 +141,11 @@ public class ServerSentEventHttpMessageWriterTests extends AbstractDataBufferAll .verify(); } - @Test - public void writePojo() { + @ParameterizedDataBufferAllocatingTest + public void writePojo(String displayName, DataBufferFactory bufferFactory) { + super.bufferFactory = bufferFactory; + + MockServerHttpResponse outputMessage = new MockServerHttpResponse(super.bufferFactory); Flux source = Flux.just(new Pojo("foofoo", "barbar"), new Pojo("foofoofoo", "barbarbar")); testWrite(source, outputMessage, Pojo.class); @@ -148,11 +156,14 @@ public class ServerSentEventHttpMessageWriterTests extends AbstractDataBufferAll .verify(); } - @Test // SPR-14899 - public void writePojoWithPrettyPrint() { + @ParameterizedDataBufferAllocatingTest // SPR-14899 + public void writePojoWithPrettyPrint(String displayName, DataBufferFactory bufferFactory) { + super.bufferFactory = bufferFactory; + ObjectMapper mapper = Jackson2ObjectMapperBuilder.json().indentOutput(true).build(); this.messageWriter = new ServerSentEventHttpMessageWriter(new Jackson2JsonEncoder(mapper)); + MockServerHttpResponse outputMessage = new MockServerHttpResponse(super.bufferFactory); Flux source = Flux.just(new Pojo("foofoo", "barbar"), new Pojo("foofoofoo", "barbarbar")); testWrite(source, outputMessage, Pojo.class); @@ -167,8 +178,11 @@ public class ServerSentEventHttpMessageWriterTests extends AbstractDataBufferAll .verify(); } - @Test // SPR-16516, SPR-16539 - public void writePojoWithCustomEncoding() { + @ParameterizedDataBufferAllocatingTest // SPR-16516, SPR-16539 + public void writePojoWithCustomEncoding(String displayName, DataBufferFactory bufferFactory) { + super.bufferFactory = bufferFactory; + + MockServerHttpResponse outputMessage = new MockServerHttpResponse(super.bufferFactory); Flux source = Flux.just(new Pojo("foo\uD834\uDD1E", "bar\uD834\uDD1E")); Charset charset = StandardCharsets.UTF_16LE; MediaType mediaType = new MediaType("text", "event-stream", charset); @@ -196,8 +210,7 @@ public class ServerSentEventHttpMessageWriterTests extends AbstractDataBufferAll Mono result = this.messageWriter.write(source, forClass(clazz), mediaType, response, HINTS); - StepVerifier.create(result) - .verifyComplete(); + StepVerifier.create(result).verifyComplete(); } } diff --git a/spring-webflux/src/test/java/org/springframework/web/reactive/function/client/WebClientDataBufferAllocatingTests.java b/spring-webflux/src/test/java/org/springframework/web/reactive/function/client/WebClientDataBufferAllocatingTests.java index 69f1f50e2a..cc3213ab30 100644 --- a/spring-webflux/src/test/java/org/springframework/web/reactive/function/client/WebClientDataBufferAllocatingTests.java +++ b/spring-webflux/src/test/java/org/springframework/web/reactive/function/client/WebClientDataBufferAllocatingTests.java @@ -23,14 +23,14 @@ import io.netty.buffer.ByteBufAllocator; import io.netty.channel.ChannelOption; import okhttp3.mockwebserver.MockResponse; import okhttp3.mockwebserver.MockWebServer; -import org.junit.After; -import org.junit.Before; -import org.junit.Test; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; import reactor.core.publisher.Mono; import reactor.test.StepVerifier; import org.springframework.core.ParameterizedTypeReference; -import org.springframework.core.io.buffer.AbstractDataBufferAllocatingTestCase; +import org.springframework.core.io.buffer.AbstractDataBufferAllocatingTests; +import org.springframework.core.io.buffer.DataBufferFactory; import org.springframework.core.io.buffer.NettyDataBufferFactory; import org.springframework.http.HttpStatus; import org.springframework.http.MediaType; @@ -44,8 +44,9 @@ import static org.assertj.core.api.Assertions.assertThat; * WebClient integration tests focusing on data buffer management. * * @author Rossen Stoyanchev + * @author Sam Brannen */ -public class WebClientDataBufferAllocatingTests extends AbstractDataBufferAllocatingTestCase { +public class WebClientDataBufferAllocatingTests extends AbstractDataBufferAllocatingTests { private static final Duration DELAY = Duration.ofSeconds(5); @@ -57,9 +58,8 @@ public class WebClientDataBufferAllocatingTests extends AbstractDataBufferAlloca private ReactorResourceFactory factory; - @Before + @BeforeEach public void setUp() { - this.factory = new ReactorResourceFactory(); this.factory.afterPropertiesSet(); @@ -82,16 +82,16 @@ public class WebClientDataBufferAllocatingTests extends AbstractDataBufferAlloca } } - @After + @AfterEach public void shutDown() throws InterruptedException { waitForDataBufferRelease(Duration.ofSeconds(2)); this.factory.destroy(); } - - @Test - public void bodyToMonoVoid() { + @ParameterizedDataBufferAllocatingTest + public void bodyToMonoVoid(String displayName, DataBufferFactory bufferFactory) { + super.bufferFactory = bufferFactory; this.server.enqueue(new MockResponse() .setResponseCode(201) @@ -107,8 +107,9 @@ public class WebClientDataBufferAllocatingTests extends AbstractDataBufferAlloca assertThat(this.server.getRequestCount()).isEqualTo(1); } - @Test // SPR-17482 - public void bodyToMonoVoidWithoutContentType() { + @ParameterizedDataBufferAllocatingTest // SPR-17482 + public void bodyToMonoVoidWithoutContentType(String displayName, DataBufferFactory bufferFactory) { + super.bufferFactory = bufferFactory; this.server.enqueue(new MockResponse() .setResponseCode(HttpStatus.ACCEPTED.value()) @@ -123,32 +124,42 @@ public class WebClientDataBufferAllocatingTests extends AbstractDataBufferAlloca assertThat(this.server.getRequestCount()).isEqualTo(1); } - @Test - public void onStatusWithBodyNotConsumed() { + @ParameterizedDataBufferAllocatingTest + public void onStatusWithBodyNotConsumed(String displayName, DataBufferFactory bufferFactory) { + super.bufferFactory = bufferFactory; + RuntimeException ex = new RuntimeException("response error"); testOnStatus(ex, response -> Mono.just(ex)); } - @Test - public void onStatusWithBodyConsumed() { + @ParameterizedDataBufferAllocatingTest + public void onStatusWithBodyConsumed(String displayName, DataBufferFactory bufferFactory) { + super.bufferFactory = bufferFactory; + RuntimeException ex = new RuntimeException("response error"); testOnStatus(ex, response -> response.bodyToMono(Void.class).thenReturn(ex)); } - @Test // SPR-17473 - public void onStatusWithMonoErrorAndBodyNotConsumed() { + @ParameterizedDataBufferAllocatingTest // SPR-17473 + public void onStatusWithMonoErrorAndBodyNotConsumed(String displayName, DataBufferFactory bufferFactory) { + super.bufferFactory = bufferFactory; + RuntimeException ex = new RuntimeException("response error"); testOnStatus(ex, response -> Mono.error(ex)); } - @Test - public void onStatusWithMonoErrorAndBodyConsumed() { + @ParameterizedDataBufferAllocatingTest + public void onStatusWithMonoErrorAndBodyConsumed(String displayName, DataBufferFactory bufferFactory) { + super.bufferFactory = bufferFactory; + RuntimeException ex = new RuntimeException("response error"); testOnStatus(ex, response -> response.bodyToMono(Void.class).then(Mono.error(ex))); } - @Test // gh-23230 - public void onStatusWithImmediateErrorAndBodyNotConsumed() { + @ParameterizedDataBufferAllocatingTest // gh-23230 + public void onStatusWithImmediateErrorAndBodyNotConsumed(String displayName, DataBufferFactory bufferFactory) { + super.bufferFactory = bufferFactory; + RuntimeException ex = new RuntimeException("response error"); testOnStatus(ex, response -> { throw ex; -- GitLab