diff --git a/httpcore5-h2/pom.xml b/httpcore5-h2/pom.xml index 7ea190655f..acd1987bae 100644 --- a/httpcore5-h2/pom.xml +++ b/httpcore5-h2/pom.xml @@ -53,6 +53,11 @@ junit-jupiter test + + org.assertj + assertj-core + test + org.mockito mockito-core diff --git a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/config/H2ConfigTest.java b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/config/H2ConfigTest.java index a6a2859d5f..f89c177ea9 100644 --- a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/config/H2ConfigTest.java +++ b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/config/H2ConfigTest.java @@ -27,11 +27,8 @@ package org.apache.hc.core5.http2.config; -import static org.junit.jupiter.api.Assertions.assertAll; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static org.junit.jupiter.api.Assertions.assertTrue; - +import org.assertj.core.api.Assertions; +import org.assertj.core.api.SoftAssertions; import org.junit.jupiter.api.Test; class H2ConfigTest { @@ -42,7 +39,7 @@ void builder() { final H2Config h2Config = H2Config.custom() .setPushEnabled(false) .build(); - assertNotNull(h2Config); + Assertions.assertThat(h2Config).isNotNull(); } @Test @@ -56,11 +53,11 @@ void checkValues() { .setCompressionEnabled(true) .build(); - assertEquals(1, h2Config.getHeaderTableSize()); - assertEquals(1, h2Config.getMaxConcurrentStreams()); - assertEquals(16384, h2Config.getMaxFrameSize()); - assertTrue(h2Config.isPushEnabled()); - assertTrue(h2Config.isCompressionEnabled()); + Assertions.assertThat(h2Config.getHeaderTableSize()).isEqualTo(1); + Assertions.assertThat(h2Config.getMaxConcurrentStreams()).isEqualTo(1); + Assertions.assertThat(h2Config.getMaxFrameSize()).isEqualTo(16384); + Assertions.assertThat(h2Config.isPushEnabled()).isTrue(); + Assertions.assertThat(h2Config.isCompressionEnabled()).isTrue(); } @Test @@ -77,13 +74,13 @@ void copy() { final H2Config.Builder builder = H2Config.copy(h2Config); final H2Config h2Config2 = builder.build(); - assertAll( - () -> assertEquals(h2Config.getHeaderTableSize(), h2Config2.getHeaderTableSize()), - () -> assertEquals(h2Config.getInitialWindowSize(), h2Config2.getInitialWindowSize()), - () -> assertEquals(h2Config.getMaxConcurrentStreams(), h2Config2.getMaxConcurrentStreams()), - () -> assertEquals(h2Config.getMaxFrameSize(), h2Config2.getMaxFrameSize()), - () -> assertEquals(h2Config.getMaxHeaderListSize(), h2Config2.getMaxHeaderListSize()) - ); + SoftAssertions.assertSoftly(softly -> { + softly.assertThat(h2Config2.getHeaderTableSize()).isEqualTo(h2Config.getHeaderTableSize()); + softly.assertThat(h2Config2.getInitialWindowSize()).isEqualTo(h2Config.getInitialWindowSize()); + softly.assertThat(h2Config2.getMaxConcurrentStreams()).isEqualTo(h2Config.getMaxConcurrentStreams()); + softly.assertThat(h2Config2.getMaxFrameSize()).isEqualTo(h2Config.getMaxFrameSize()); + softly.assertThat(h2Config2.getMaxHeaderListSize()).isEqualTo(h2Config.getMaxHeaderListSize()); + }); } diff --git a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/frame/TestDefaultFrameFactory.java b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/frame/TestDefaultFrameFactory.java index f5cbe857b8..63ddba0c0a 100644 --- a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/frame/TestDefaultFrameFactory.java +++ b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/frame/TestDefaultFrameFactory.java @@ -32,7 +32,7 @@ import org.apache.hc.core5.http2.H2Error; import org.apache.hc.core5.http2.config.H2Param; import org.apache.hc.core5.http2.config.H2Setting; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class TestDefaultFrameFactory { @@ -45,9 +45,9 @@ void testDataFrame() { final byte[] data = new byte[]{'a', 'b', 'c', 'd', 'e', 'f'}; final Frame dataFrame = frameFactory.createData(23, ByteBuffer.wrap(data), true); - Assertions.assertEquals(FrameType.DATA.value, dataFrame.getType()); - Assertions.assertEquals(23, dataFrame.getStreamId()); - Assertions.assertEquals(1L, dataFrame.getFlags()); + Assertions.assertThat(dataFrame.getType()).isEqualTo(FrameType.DATA.value); + Assertions.assertThat(dataFrame.getStreamId()).isEqualTo(23); + Assertions.assertThat(dataFrame.getFlags()).isEqualTo(1L); } @Test @@ -58,12 +58,12 @@ void testSettingFrame() { new H2Setting(H2Param.HEADER_TABLE_SIZE, 1024), new H2Setting(H2Param.MAX_CONCURRENT_STREAMS, 1)); - Assertions.assertEquals(FrameType.SETTINGS.value, settingsFrame.getType()); - Assertions.assertEquals(0, settingsFrame.getStreamId()); - Assertions.assertEquals(0, settingsFrame.getFlags()); + Assertions.assertThat(settingsFrame.getType()).isEqualTo(FrameType.SETTINGS.value); + Assertions.assertThat(settingsFrame.getStreamId()).isEqualTo(0); + Assertions.assertThat(settingsFrame.getFlags()).isEqualTo(0); final ByteBuffer payload = settingsFrame.getPayload(); - Assertions.assertNotNull(payload); - Assertions.assertEquals(12, payload.remaining()); + Assertions.assertThat(payload).isNotNull(); + Assertions.assertThat(payload.remaining()).isEqualTo(12); } @Test @@ -72,13 +72,13 @@ void testResetStreamFrame() { final FrameFactory frameFactory = new DefaultFrameFactory(); final Frame rstStreamFrame = frameFactory.createResetStream(12, H2Error.INTERNAL_ERROR); - Assertions.assertEquals(FrameType.RST_STREAM.value, rstStreamFrame.getType()); - Assertions.assertEquals(12, rstStreamFrame.getStreamId()); - Assertions.assertEquals(0, rstStreamFrame.getFlags()); + Assertions.assertThat(rstStreamFrame.getType()).isEqualTo(FrameType.RST_STREAM.value); + Assertions.assertThat(rstStreamFrame.getStreamId()).isEqualTo(12); + Assertions.assertThat(rstStreamFrame.getFlags()).isEqualTo(0); final ByteBuffer payload = rstStreamFrame.getPayload(); - Assertions.assertNotNull(payload); - Assertions.assertEquals(4, payload.remaining()); - Assertions.assertEquals(H2Error.INTERNAL_ERROR.getCode(), payload.getInt()); + Assertions.assertThat(payload).isNotNull(); + Assertions.assertThat(payload.remaining()).isEqualTo(4); + Assertions.assertThat(payload.getInt()).isEqualTo(H2Error.INTERNAL_ERROR.getCode()); } @Test @@ -87,16 +87,16 @@ void testGoAwayFrame() { final FrameFactory frameFactory = new DefaultFrameFactory(); final Frame goAwayFrame = frameFactory.createGoAway(13, H2Error.INTERNAL_ERROR, "Oopsie"); - Assertions.assertEquals(FrameType.GOAWAY.value, goAwayFrame.getType()); - Assertions.assertEquals(0, goAwayFrame.getStreamId()); - Assertions.assertEquals(0, goAwayFrame.getFlags()); + Assertions.assertThat(goAwayFrame.getType()).isEqualTo(FrameType.GOAWAY.value); + Assertions.assertThat(goAwayFrame.getStreamId()).isEqualTo(0); + Assertions.assertThat(goAwayFrame.getFlags()).isEqualTo(0); final ByteBuffer payload = goAwayFrame.getPayload(); - Assertions.assertNotNull(payload); - Assertions.assertEquals(13, payload.getInt()); - Assertions.assertEquals(H2Error.INTERNAL_ERROR.getCode(), payload.getInt()); + Assertions.assertThat(payload).isNotNull(); + Assertions.assertThat(payload.getInt()).isEqualTo(13); + Assertions.assertThat(payload.getInt()).isEqualTo(H2Error.INTERNAL_ERROR.getCode()); final byte[] tmp = new byte[payload.remaining()]; payload.get(tmp); - Assertions.assertEquals("Oopsie", new String(tmp, StandardCharsets.US_ASCII)); + Assertions.assertThat(new String(tmp, StandardCharsets.US_ASCII)).isEqualTo("Oopsie"); } } diff --git a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/frame/TestFrameFlag.java b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/frame/TestFrameFlag.java index 62a77505eb..212b63f891 100644 --- a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/frame/TestFrameFlag.java +++ b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/frame/TestFrameFlag.java @@ -26,7 +26,7 @@ */ package org.apache.hc.core5.http2.frame; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class TestFrameFlag { @@ -35,7 +35,7 @@ class TestFrameFlag { void testFrameFlagBasics() { final int flags = FrameFlag.of(FrameFlag.END_STREAM, FrameFlag.PADDED, FrameFlag.PRIORITY); - Assertions.assertEquals(0x01 | 0x08 | 0x20, flags); + Assertions.assertThat(flags).isEqualTo(0x01 | 0x08 | 0x20); } } diff --git a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/frame/TestH2Settings.java b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/frame/TestH2Settings.java index c8486708dd..330d1380ac 100644 --- a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/frame/TestH2Settings.java +++ b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/frame/TestH2Settings.java @@ -28,7 +28,7 @@ import org.apache.hc.core5.http2.config.H2Param; import org.apache.hc.core5.http2.config.H2Setting; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class TestH2Settings { @@ -36,13 +36,13 @@ class TestH2Settings { @Test void testH2ParamBasics() { for (final H2Param param: H2Param.values()) { - Assertions.assertEquals(param, H2Param.valueOf(param.getCode())); - Assertions.assertEquals(param.name(), H2Param.toString(param.getCode())); + Assertions.assertThat(H2Param.valueOf(param.getCode())).isEqualTo(param); + Assertions.assertThat(H2Param.toString(param.getCode())).isEqualTo(param.name()); } - Assertions.assertNull(H2Param.valueOf(0)); - Assertions.assertNull(H2Param.valueOf(10)); - Assertions.assertEquals("0", H2Param.toString(0)); - Assertions.assertEquals("10", H2Param.toString(10)); + Assertions.assertThat(H2Param.valueOf(0)).isNull(); + Assertions.assertThat(H2Param.valueOf(10)).isNull(); + Assertions.assertThat(H2Param.toString(0)).isEqualTo("0"); + Assertions.assertThat(H2Param.toString(10)).isEqualTo("10"); } @Test @@ -51,8 +51,8 @@ void testH2SettingBasics() { final H2Setting setting1 = new H2Setting(H2Param.ENABLE_PUSH, 0); final H2Setting setting2 = new H2Setting(H2Param.INITIAL_WINDOW_SIZE, 1024); - Assertions.assertEquals("ENABLE_PUSH: 0", setting1.toString()); - Assertions.assertEquals("INITIAL_WINDOW_SIZE: 1024", setting2.toString()); + Assertions.assertThat(setting1.toString()).isEqualTo("ENABLE_PUSH: 0"); + Assertions.assertThat(setting2.toString()).isEqualTo("INITIAL_WINDOW_SIZE: 1024"); } } diff --git a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/hpack/TestFifoBuffer.java b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/hpack/TestFifoBuffer.java index 172db8419c..6938ac4790 100644 --- a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/hpack/TestFifoBuffer.java +++ b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/hpack/TestFifoBuffer.java @@ -27,7 +27,7 @@ package org.apache.hc.core5.http2.hpack; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class TestFifoBuffer { @@ -43,47 +43,47 @@ void testAddRemoveCycle() { final HPackHeader h4 = new HPackHeader("h", "4"); for (int i = 0; i < 20; i++) { - Assertions.assertEquals(0, fifoBuffer.size()); - Assertions.assertSame(null, fifoBuffer.getFirst()); - Assertions.assertSame(null, fifoBuffer.getLast()); + Assertions.assertThat(fifoBuffer.size()).isEqualTo(0); + Assertions.assertThat(fifoBuffer.getFirst()).isSameAs(null); + Assertions.assertThat(fifoBuffer.getLast()).isSameAs(null); fifoBuffer.addFirst(h1); - Assertions.assertSame(h1, fifoBuffer.getFirst()); - Assertions.assertSame(h1, fifoBuffer.getLast()); - Assertions.assertEquals(1, fifoBuffer.size()); + Assertions.assertThat(fifoBuffer.getFirst()).isSameAs(h1); + Assertions.assertThat(fifoBuffer.getLast()).isSameAs(h1); + Assertions.assertThat(fifoBuffer.size()).isEqualTo(1); fifoBuffer.addFirst(h2); - Assertions.assertEquals(2, fifoBuffer.size()); - Assertions.assertSame(h2, fifoBuffer.getFirst()); - Assertions.assertSame(h1, fifoBuffer.getLast()); + Assertions.assertThat(fifoBuffer.size()).isEqualTo(2); + Assertions.assertThat(fifoBuffer.getFirst()).isSameAs(h2); + Assertions.assertThat(fifoBuffer.getLast()).isSameAs(h1); fifoBuffer.addFirst(h3); - Assertions.assertEquals(3, fifoBuffer.size()); - Assertions.assertSame(h3, fifoBuffer.getFirst()); - Assertions.assertSame(h1, fifoBuffer.getLast()); + Assertions.assertThat(fifoBuffer.size()).isEqualTo(3); + Assertions.assertThat(fifoBuffer.getFirst()).isSameAs(h3); + Assertions.assertThat(fifoBuffer.getLast()).isSameAs(h1); fifoBuffer.addFirst(h4); - Assertions.assertEquals(4, fifoBuffer.size()); - Assertions.assertSame(h4, fifoBuffer.getFirst()); - Assertions.assertSame(h1, fifoBuffer.getLast()); + Assertions.assertThat(fifoBuffer.size()).isEqualTo(4); + Assertions.assertThat(fifoBuffer.getFirst()).isSameAs(h4); + Assertions.assertThat(fifoBuffer.getLast()).isSameAs(h1); - Assertions.assertSame(h4, fifoBuffer.get(0)); - Assertions.assertSame(h3, fifoBuffer.get(1)); - Assertions.assertSame(h2, fifoBuffer.get(2)); - Assertions.assertSame(h1, fifoBuffer.get(3)); + Assertions.assertThat(fifoBuffer.get(0)).isSameAs(h4); + Assertions.assertThat(fifoBuffer.get(1)).isSameAs(h3); + Assertions.assertThat(fifoBuffer.get(2)).isSameAs(h2); + Assertions.assertThat(fifoBuffer.get(3)).isSameAs(h1); fifoBuffer.removeLast(); - Assertions.assertEquals(3, fifoBuffer.size()); - Assertions.assertSame(h4, fifoBuffer.getFirst()); - Assertions.assertSame(h2, fifoBuffer.getLast()); + Assertions.assertThat(fifoBuffer.size()).isEqualTo(3); + Assertions.assertThat(fifoBuffer.getFirst()).isSameAs(h4); + Assertions.assertThat(fifoBuffer.getLast()).isSameAs(h2); fifoBuffer.removeLast(); - Assertions.assertEquals(2, fifoBuffer.size()); - Assertions.assertSame(h4, fifoBuffer.getFirst()); - Assertions.assertSame(h3, fifoBuffer.getLast()); + Assertions.assertThat(fifoBuffer.size()).isEqualTo(2); + Assertions.assertThat(fifoBuffer.getFirst()).isSameAs(h4); + Assertions.assertThat(fifoBuffer.getLast()).isSameAs(h3); fifoBuffer.removeLast(); - Assertions.assertEquals(1, fifoBuffer.size()); - Assertions.assertSame(h4, fifoBuffer.getFirst()); - Assertions.assertSame(h4, fifoBuffer.getLast()); + Assertions.assertThat(fifoBuffer.size()).isEqualTo(1); + Assertions.assertThat(fifoBuffer.getFirst()).isSameAs(h4); + Assertions.assertThat(fifoBuffer.getLast()).isSameAs(h4); fifoBuffer.removeLast(); - Assertions.assertEquals(0, fifoBuffer.size()); - Assertions.assertSame(null, fifoBuffer.getFirst()); - Assertions.assertSame(null, fifoBuffer.getLast()); + Assertions.assertThat(fifoBuffer.size()).isEqualTo(0); + Assertions.assertThat(fifoBuffer.getFirst()).isSameAs(null); + Assertions.assertThat(fifoBuffer.getLast()).isSameAs(null); } } @@ -105,30 +105,30 @@ void testExpand() { fifoBuffer.removeLast(); } - Assertions.assertEquals(0, fifoBuffer.size()); - Assertions.assertSame(null, fifoBuffer.getFirst()); - Assertions.assertSame(null, fifoBuffer.getLast()); + Assertions.assertThat(fifoBuffer.size()).isEqualTo(0); + Assertions.assertThat(fifoBuffer.getFirst()).isSameAs(null); + Assertions.assertThat(fifoBuffer.getLast()).isSameAs(null); fifoBuffer.addFirst(h1); - Assertions.assertSame(h1, fifoBuffer.getFirst()); - Assertions.assertSame(h1, fifoBuffer.getLast()); - Assertions.assertEquals(1, fifoBuffer.size()); + Assertions.assertThat(fifoBuffer.getFirst()).isSameAs(h1); + Assertions.assertThat(fifoBuffer.getLast()).isSameAs(h1); + Assertions.assertThat(fifoBuffer.size()).isEqualTo(1); fifoBuffer.addFirst(h2); - Assertions.assertEquals(2, fifoBuffer.size()); - Assertions.assertSame(h2, fifoBuffer.getFirst()); - Assertions.assertSame(h1, fifoBuffer.getLast()); + Assertions.assertThat(fifoBuffer.size()).isEqualTo(2); + Assertions.assertThat(fifoBuffer.getFirst()).isSameAs(h2); + Assertions.assertThat(fifoBuffer.getLast()).isSameAs(h1); fifoBuffer.addFirst(h3); - Assertions.assertEquals(3, fifoBuffer.size()); - Assertions.assertSame(h3, fifoBuffer.getFirst()); - Assertions.assertSame(h1, fifoBuffer.getLast()); + Assertions.assertThat(fifoBuffer.size()).isEqualTo(3); + Assertions.assertThat(fifoBuffer.getFirst()).isSameAs(h3); + Assertions.assertThat(fifoBuffer.getLast()).isSameAs(h1); fifoBuffer.addFirst(h4); - Assertions.assertEquals(4, fifoBuffer.size()); - Assertions.assertSame(h4, fifoBuffer.getFirst()); - Assertions.assertSame(h1, fifoBuffer.getLast()); - - Assertions.assertSame(h4, fifoBuffer.get(0)); - Assertions.assertSame(h3, fifoBuffer.get(1)); - Assertions.assertSame(h2, fifoBuffer.get(2)); - Assertions.assertSame(h1, fifoBuffer.get(3)); + Assertions.assertThat(fifoBuffer.size()).isEqualTo(4); + Assertions.assertThat(fifoBuffer.getFirst()).isSameAs(h4); + Assertions.assertThat(fifoBuffer.getLast()).isSameAs(h1); + + Assertions.assertThat(fifoBuffer.get(0)).isSameAs(h4); + Assertions.assertThat(fifoBuffer.get(1)).isSameAs(h3); + Assertions.assertThat(fifoBuffer.get(2)).isSameAs(h2); + Assertions.assertThat(fifoBuffer.get(3)).isSameAs(h1); } } diff --git a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/hpack/TestFifoLinkedList.java b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/hpack/TestFifoLinkedList.java index 472d8189ba..fc442cdbb2 100644 --- a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/hpack/TestFifoLinkedList.java +++ b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/hpack/TestFifoLinkedList.java @@ -27,7 +27,7 @@ package org.apache.hc.core5.http2.hpack; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class TestFifoLinkedList { @@ -43,49 +43,49 @@ void testAddRemoveCycle() { final HPackHeader h4 = new HPackHeader("h", "4"); for (int i = 0; i < 5; i++) { - Assertions.assertEquals(0, fifoLinkedList.size()); - Assertions.assertSame(null, fifoLinkedList.getFirst()); - Assertions.assertSame(null, fifoLinkedList.getLast()); + Assertions.assertThat(fifoLinkedList.size()).isEqualTo(0); + Assertions.assertThat(fifoLinkedList.getFirst()).isSameAs(null); + Assertions.assertThat(fifoLinkedList.getLast()).isSameAs(null); fifoLinkedList.addFirst(h1); - Assertions.assertEquals(1, fifoLinkedList.size()); - Assertions.assertSame(h1, fifoLinkedList.getFirst()); - Assertions.assertSame(h1, fifoLinkedList.getLast()); + Assertions.assertThat(fifoLinkedList.size()).isEqualTo(1); + Assertions.assertThat(fifoLinkedList.getFirst()).isSameAs(h1); + Assertions.assertThat(fifoLinkedList.getLast()).isSameAs(h1); fifoLinkedList.addFirst(h2); - Assertions.assertEquals(2, fifoLinkedList.size()); - Assertions.assertSame(h2, fifoLinkedList.getFirst()); - Assertions.assertSame(h1, fifoLinkedList.getLast()); + Assertions.assertThat(fifoLinkedList.size()).isEqualTo(2); + Assertions.assertThat(fifoLinkedList.getFirst()).isSameAs(h2); + Assertions.assertThat(fifoLinkedList.getLast()).isSameAs(h1); fifoLinkedList.addFirst(h3); - Assertions.assertEquals(3, fifoLinkedList.size()); - Assertions.assertSame(h3, fifoLinkedList.getFirst()); - Assertions.assertSame(h1, fifoLinkedList.getLast()); + Assertions.assertThat(fifoLinkedList.size()).isEqualTo(3); + Assertions.assertThat(fifoLinkedList.getFirst()).isSameAs(h3); + Assertions.assertThat(fifoLinkedList.getLast()).isSameAs(h1); fifoLinkedList.addFirst(h4); - Assertions.assertEquals(4, fifoLinkedList.size()); - Assertions.assertSame(h4, fifoLinkedList.getFirst()); - Assertions.assertSame(h1, fifoLinkedList.getLast()); + Assertions.assertThat(fifoLinkedList.size()).isEqualTo(4); + Assertions.assertThat(fifoLinkedList.getFirst()).isSameAs(h4); + Assertions.assertThat(fifoLinkedList.getLast()).isSameAs(h1); fifoLinkedList.removeLast(); - Assertions.assertEquals(3, fifoLinkedList.size()); - Assertions.assertSame(h4, fifoLinkedList.getFirst()); - Assertions.assertSame(h2, fifoLinkedList.getLast()); + Assertions.assertThat(fifoLinkedList.size()).isEqualTo(3); + Assertions.assertThat(fifoLinkedList.getFirst()).isSameAs(h4); + Assertions.assertThat(fifoLinkedList.getLast()).isSameAs(h2); fifoLinkedList.removeLast(); - Assertions.assertEquals(2, fifoLinkedList.size()); - Assertions.assertSame(h4, fifoLinkedList.getFirst()); - Assertions.assertSame(h3, fifoLinkedList.getLast()); + Assertions.assertThat(fifoLinkedList.size()).isEqualTo(2); + Assertions.assertThat(fifoLinkedList.getFirst()).isSameAs(h4); + Assertions.assertThat(fifoLinkedList.getLast()).isSameAs(h3); fifoLinkedList.removeLast(); - Assertions.assertEquals(1, fifoLinkedList.size()); - Assertions.assertSame(h4, fifoLinkedList.getFirst()); - Assertions.assertSame(h4, fifoLinkedList.getLast()); + Assertions.assertThat(fifoLinkedList.size()).isEqualTo(1); + Assertions.assertThat(fifoLinkedList.getFirst()).isSameAs(h4); + Assertions.assertThat(fifoLinkedList.getLast()).isSameAs(h4); fifoLinkedList.removeLast(); - Assertions.assertEquals(0, fifoLinkedList.size()); - Assertions.assertSame(null, fifoLinkedList.getFirst()); - Assertions.assertSame(null, fifoLinkedList.getLast()); + Assertions.assertThat(fifoLinkedList.size()).isEqualTo(0); + Assertions.assertThat(fifoLinkedList.getFirst()).isSameAs(null); + Assertions.assertThat(fifoLinkedList.getLast()).isSameAs(null); } } @@ -104,58 +104,58 @@ void testGetIndex() { final FifoLinkedList.InternalNode node3 = fifoLinkedList.addFirst(h3); final FifoLinkedList.InternalNode node4 = fifoLinkedList.addFirst(h4); - Assertions.assertEquals(0, fifoLinkedList.getIndex(node4)); - Assertions.assertEquals(1, fifoLinkedList.getIndex(node3)); - Assertions.assertEquals(2, fifoLinkedList.getIndex(node2)); - Assertions.assertEquals(3, fifoLinkedList.getIndex(node1)); + Assertions.assertThat(fifoLinkedList.getIndex(node4)).isEqualTo(0); + Assertions.assertThat(fifoLinkedList.getIndex(node3)).isEqualTo(1); + Assertions.assertThat(fifoLinkedList.getIndex(node2)).isEqualTo(2); + Assertions.assertThat(fifoLinkedList.getIndex(node1)).isEqualTo(3); - Assertions.assertEquals(4, fifoLinkedList.size()); - Assertions.assertSame(h4, fifoLinkedList.get(0)); - Assertions.assertSame(h3, fifoLinkedList.get(1)); - Assertions.assertSame(h2, fifoLinkedList.get(2)); - Assertions.assertSame(h1, fifoLinkedList.get(3)); + Assertions.assertThat(fifoLinkedList.size()).isEqualTo(4); + Assertions.assertThat(fifoLinkedList.get(0)).isSameAs(h4); + Assertions.assertThat(fifoLinkedList.get(1)).isSameAs(h3); + Assertions.assertThat(fifoLinkedList.get(2)).isSameAs(h2); + Assertions.assertThat(fifoLinkedList.get(3)).isSameAs(h1); fifoLinkedList.removeLast(); - Assertions.assertEquals(0, fifoLinkedList.getIndex(node4)); - Assertions.assertEquals(1, fifoLinkedList.getIndex(node3)); - Assertions.assertEquals(2, fifoLinkedList.getIndex(node2)); - Assertions.assertEquals(-1, fifoLinkedList.getIndex(node1)); + Assertions.assertThat(fifoLinkedList.getIndex(node4)).isEqualTo(0); + Assertions.assertThat(fifoLinkedList.getIndex(node3)).isEqualTo(1); + Assertions.assertThat(fifoLinkedList.getIndex(node2)).isEqualTo(2); + Assertions.assertThat(fifoLinkedList.getIndex(node1)).isEqualTo(-1); - Assertions.assertEquals(3, fifoLinkedList.size()); - Assertions.assertSame(h4, fifoLinkedList.get(0)); - Assertions.assertSame(h3, fifoLinkedList.get(1)); - Assertions.assertSame(h2, fifoLinkedList.get(2)); + Assertions.assertThat(fifoLinkedList.size()).isEqualTo(3); + Assertions.assertThat(fifoLinkedList.get(0)).isSameAs(h4); + Assertions.assertThat(fifoLinkedList.get(1)).isSameAs(h3); + Assertions.assertThat(fifoLinkedList.get(2)).isSameAs(h2); fifoLinkedList.removeLast(); - Assertions.assertEquals(0, fifoLinkedList.getIndex(node4)); - Assertions.assertEquals(1, fifoLinkedList.getIndex(node3)); - Assertions.assertEquals(-1, fifoLinkedList.getIndex(node2)); - Assertions.assertEquals(-1, fifoLinkedList.getIndex(node1)); + Assertions.assertThat(fifoLinkedList.getIndex(node4)).isEqualTo(0); + Assertions.assertThat(fifoLinkedList.getIndex(node3)).isEqualTo(1); + Assertions.assertThat(fifoLinkedList.getIndex(node2)).isEqualTo(-1); + Assertions.assertThat(fifoLinkedList.getIndex(node1)).isEqualTo(-1); - Assertions.assertEquals(2, fifoLinkedList.size()); - Assertions.assertSame(h4, fifoLinkedList.get(0)); - Assertions.assertSame(h3, fifoLinkedList.get(1)); + Assertions.assertThat(fifoLinkedList.size()).isEqualTo(2); + Assertions.assertThat(fifoLinkedList.get(0)).isSameAs(h4); + Assertions.assertThat(fifoLinkedList.get(1)).isSameAs(h3); fifoLinkedList.removeLast(); - Assertions.assertEquals(0, fifoLinkedList.getIndex(node4)); - Assertions.assertEquals(-1, fifoLinkedList.getIndex(node3)); - Assertions.assertEquals(-1, fifoLinkedList.getIndex(node2)); - Assertions.assertEquals(-1, fifoLinkedList.getIndex(node1)); + Assertions.assertThat(fifoLinkedList.getIndex(node4)).isEqualTo(0); + Assertions.assertThat(fifoLinkedList.getIndex(node3)).isEqualTo(-1); + Assertions.assertThat(fifoLinkedList.getIndex(node2)).isEqualTo(-1); + Assertions.assertThat(fifoLinkedList.getIndex(node1)).isEqualTo(-1); - Assertions.assertEquals(1, fifoLinkedList.size()); - Assertions.assertSame(h4, fifoLinkedList.get(0)); + Assertions.assertThat(fifoLinkedList.size()).isEqualTo(1); + Assertions.assertThat(fifoLinkedList.get(0)).isSameAs(h4); fifoLinkedList.removeLast(); - Assertions.assertEquals(-1, fifoLinkedList.getIndex(node4)); - Assertions.assertEquals(-1, fifoLinkedList.getIndex(node3)); - Assertions.assertEquals(-1, fifoLinkedList.getIndex(node2)); - Assertions.assertEquals(-1, fifoLinkedList.getIndex(node1)); + Assertions.assertThat(fifoLinkedList.getIndex(node4)).isEqualTo(-1); + Assertions.assertThat(fifoLinkedList.getIndex(node3)).isEqualTo(-1); + Assertions.assertThat(fifoLinkedList.getIndex(node2)).isEqualTo(-1); + Assertions.assertThat(fifoLinkedList.getIndex(node1)).isEqualTo(-1); - Assertions.assertEquals(0, fifoLinkedList.size()); + Assertions.assertThat(fifoLinkedList.size()).isEqualTo(0); } } diff --git a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/hpack/TestHPackCoding.java b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/hpack/TestHPackCoding.java index b93cbd0320..bffd2a53f5 100644 --- a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/hpack/TestHPackCoding.java +++ b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/hpack/TestHPackCoding.java @@ -37,7 +37,8 @@ import org.apache.hc.core5.http.Header; import org.apache.hc.core5.http.message.BasicHeader; import org.apache.hc.core5.util.ByteArrayBuffer; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; +import org.assertj.core.api.InstanceOfAssertFactories; import org.junit.jupiter.api.Test; class TestHPackCoding { @@ -48,21 +49,21 @@ void testIntegerEncodingRFC7541Examples() { final ByteArrayBuffer buffer = new ByteArrayBuffer(16); HPackEncoder.encodeInt(buffer, 5, 10, 0x0); - Assertions.assertEquals(1, buffer.length()); - Assertions.assertEquals(0b00001010, buffer.byteAt(0) & 0xFF); + Assertions.assertThat(buffer.length()).isEqualTo(1); + Assertions.assertThat(buffer.byteAt(0) & 0xFF).isEqualTo(0b00001010); buffer.clear(); HPackEncoder.encodeInt(buffer, 5, 1337, 0x0); - Assertions.assertEquals(3, buffer.length()); - Assertions.assertEquals(0b00011111, buffer.byteAt(0) & 0xFF); - Assertions.assertEquals(0b10011010, buffer.byteAt(1) & 0xFF); - Assertions.assertEquals(0b00001010, buffer.byteAt(2) & 0xFF); + Assertions.assertThat(buffer.length()).isEqualTo(3); + Assertions.assertThat(buffer.byteAt(0) & 0xFF).isEqualTo(0b00011111); + Assertions.assertThat(buffer.byteAt(1) & 0xFF).isEqualTo(0b10011010); + Assertions.assertThat(buffer.byteAt(2) & 0xFF).isEqualTo(0b00001010); buffer.clear(); HPackEncoder.encodeInt(buffer, 8, 42, 0x0); - Assertions.assertEquals(1, buffer.length()); - Assertions.assertEquals(0b00101010, buffer.byteAt(0) & 0xFF); + Assertions.assertThat(buffer.length()).isEqualTo(1); + Assertions.assertThat(buffer.byteAt(0) & 0xFF).isEqualTo(0b00101010); } static ByteBuffer wrap(final ByteArrayBuffer src) { @@ -89,17 +90,17 @@ void testIntegerCoding() throws Exception { buffer.clear(); HPackEncoder.encodeInt(buffer, n, 10, 0x0); - Assertions.assertEquals(10, HPackDecoder.decodeInt(wrap(buffer), n)); + Assertions.assertThat(HPackDecoder.decodeInt(wrap(buffer), n)).isEqualTo(10); buffer.clear(); HPackEncoder.encodeInt(buffer, n, 123456, 0x0); - Assertions.assertEquals(123456, HPackDecoder.decodeInt(wrap(buffer), n)); + Assertions.assertThat(HPackDecoder.decodeInt(wrap(buffer), n)).isEqualTo(123456); buffer.clear(); HPackEncoder.encodeInt(buffer, n, Integer.MAX_VALUE, 0x0); - Assertions.assertEquals(Integer.MAX_VALUE, HPackDecoder.decodeInt(wrap(buffer), n)); + Assertions.assertThat(HPackDecoder.decodeInt(wrap(buffer), n)).isEqualTo(Integer.MAX_VALUE); } } @@ -108,7 +109,7 @@ void testIntegerCoding() throws Exception { void testIntegerCodingLimit() throws Exception { final ByteBuffer src1 = createByteBuffer(0x7f, 0x80, 0xff, 0xff, 0xff, 0x07); - Assertions.assertEquals(Integer.MAX_VALUE, HPackDecoder.decodeInt(src1, 7)); + Assertions.assertThat(HPackDecoder.decodeInt(src1, 7)).isEqualTo(Integer.MAX_VALUE); final ByteBuffer src2 = createByteBuffer(0x7f, 0x80, 0xff, 0xff, 0xff, 0x08); try { @@ -140,8 +141,8 @@ void testPlainStringDecoding() throws Exception { final ByteArrayBuffer buffer = new ByteArrayBuffer(16); HPackDecoder.decodePlainString(buffer, src); - Assertions.assertEquals("custom-key", new String(buffer.array(), 0, buffer.length(), StandardCharsets.US_ASCII)); - Assertions.assertFalse(src.hasRemaining(), "Decoding completed"); + Assertions.assertThat(new String(buffer.array(), 0, buffer.length(), StandardCharsets.US_ASCII)).isEqualTo("custom-key"); + Assertions.assertThat(src.hasRemaining()).withFailMessage("Decoding completed").isFalse(); } @Test @@ -152,8 +153,8 @@ void testPlainStringDecodingRemainingContent() throws Exception { final ByteArrayBuffer buffer = new ByteArrayBuffer(16); HPackDecoder.decodePlainString(buffer, src); - Assertions.assertEquals("custom-key", new String(buffer.array(), 0, buffer.length(), StandardCharsets.US_ASCII)); - Assertions.assertEquals(4, src.remaining()); + Assertions.assertThat(new String(buffer.array(), 0, buffer.length(), StandardCharsets.US_ASCII)).isEqualTo("custom-key"); + Assertions.assertThat(src.remaining()).isEqualTo(4); } @Test @@ -165,8 +166,8 @@ void testPlainStringDecodingReadOnly() throws Exception { final ByteBuffer srcRO = src.asReadOnlyBuffer(); final ByteArrayBuffer buffer = new ByteArrayBuffer(16); HPackDecoder.decodePlainString(buffer, srcRO); - Assertions.assertEquals("custom-key", new String(buffer.array(), 0, buffer.length(), StandardCharsets.US_ASCII)); - Assertions.assertEquals(4, srcRO.remaining()); + Assertions.assertThat(new String(buffer.array(), 0, buffer.length(), StandardCharsets.US_ASCII)).isEqualTo("custom-key"); + Assertions.assertThat(srcRO.remaining()).isEqualTo(4); } @Test @@ -176,7 +177,9 @@ void testPlainStringDecodingTruncated() { 0x0a, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2d, 0x6b, 0x65); final ByteArrayBuffer buffer = new ByteArrayBuffer(16); - Assertions.assertThrows(HPackException.class, () -> HPackDecoder.decodePlainString(buffer, src)); + Assertions.assertThatThrownBy(() -> + HPackDecoder.decodePlainString(buffer, src)) + .isInstanceOf(HPackException.class); } @Test @@ -186,9 +189,8 @@ void testHuffmanDecodingRFC7541Examples() throws Exception { final ByteArrayBuffer buffer = new ByteArrayBuffer(16); HPackDecoder.decodeHuffman(buffer, src); - Assertions.assertEquals("www.example.com", - new String(buffer.array(), 0, buffer.length(), StandardCharsets.US_ASCII)); - Assertions.assertFalse(src.hasRemaining(), "Decoding completed"); + Assertions.assertThat(new String(buffer.array(), 0, buffer.length(), StandardCharsets.US_ASCII)).isEqualTo("www.example.com"); + Assertions.assertThat(src.hasRemaining()).withFailMessage("Decoding completed").isFalse(); } private static ByteBuffer createByteBuffer(final String s, final Charset charset) { @@ -202,7 +204,7 @@ void testHuffmanEncoding() { HPackEncoder.encodeHuffman(buffer, createByteBuffer("www.example.com", StandardCharsets.US_ASCII)); final ByteBuffer expected = createByteBuffer( 0xf1, 0xe3, 0xc2, 0xe5, 0xf2, 0x3a, 0x6b, 0xa0, 0xab, 0x90, 0xf4, 0xff); - Assertions.assertArrayEquals(toArray(expected), buffer.toByteArray()); + Assertions.assertThat(buffer.toByteArray()).containsExactly(toArray(expected)); } @Test @@ -216,13 +218,13 @@ void testBasicStringCoding() throws Exception { final StringBuilder strBuf = new StringBuilder(); decoder.decodeString(wrap(buffer), strBuf); - Assertions.assertEquals("this and that", strBuf.toString()); + Assertions.assertThat(strBuf.toString()).isEqualTo("this and that"); buffer.clear(); strBuf.setLength(0); encoder.encodeString(buffer, "this and that and Huffman", true); decoder.decodeString(wrap(buffer), strBuf); - Assertions.assertEquals("this and that and Huffman", strBuf.toString()); + Assertions.assertThat(strBuf.toString()).isEqualTo("this and that and Huffman"); } @Test @@ -239,7 +241,7 @@ void testEnsureCapacity() throws Exception { decoder.decodeString(wrap(buffer), strBuf); strBuf.delete(0,strBuf.length()); } - Assertions.assertEquals(256, decoder.getTmpBufSize()); + Assertions.assertThat(decoder.getTmpBufSize()).isEqualTo(256); } static final int SWISS_GERMAN_HELLO[] = { @@ -286,7 +288,7 @@ void testComplexStringCoding1() throws Exception { strBuf.setLength(0); decoder.decodeString(wrap(buffer), strBuf); final String helloBack = strBuf.toString(); - Assertions.assertEquals(hello, helloBack, "charset: " + charset + "; huffman: " + b); + Assertions.assertThat(helloBack).withFailMessage("charset: " + charset + "; huffman: " + b).isEqualTo(hello); } } } @@ -314,7 +316,7 @@ void testComplexStringCoding2() throws Exception { encoder.encodeString(buffer, hello, b); decoder.decodeString(wrap(buffer), strBuf); final String helloBack = strBuf.toString(); - Assertions.assertEquals(hello, helloBack, "charset: " + charset + "; huffman: " + b); + Assertions.assertThat(helloBack).withFailMessage("charset: " + charset + "; huffman: " + b).isEqualTo(hello); } } } @@ -322,10 +324,10 @@ void testComplexStringCoding2() throws Exception { private static void assertHeaderEquals(final Header expected, final Header actual) { - Assertions.assertNotNull(actual); - Assertions.assertEquals(expected.getName(), actual.getName(), "Header name"); - Assertions.assertEquals(expected.getValue(), actual.getValue(), "Header value"); - Assertions.assertEquals(expected.isSensitive(), actual.isSensitive(), "Header sensitive flag"); + Assertions.assertThat(actual).isNotNull(); + Assertions.assertThat(actual.getName()).withFailMessage("Header name").isEqualTo(expected.getName()); + Assertions.assertThat(actual.getValue()).withFailMessage("Header value").isEqualTo(expected.getValue()); + Assertions.assertThat(actual.isSensitive()).withFailMessage("Header sensitive flag").isEqualTo(expected.isSensitive()); } @Test @@ -339,9 +341,9 @@ void testLiteralHeaderWithIndexingDecodingRFC7541Examples() throws Exception { final HPackDecoder decoder = new HPackDecoder(dynamicTable, StandardCharsets.US_ASCII); final Header header = decoder.decodeLiteralHeader(src, HPackRepresentation.WITH_INDEXING); assertHeaderEquals(new BasicHeader("custom-key", "custom-header"), header); - Assertions.assertFalse(src.hasRemaining(), "Decoding completed"); + Assertions.assertThat(src.hasRemaining()).withFailMessage("Decoding completed").isFalse(); - Assertions.assertEquals(1, dynamicTable.dynamicLength()); + Assertions.assertThat(dynamicTable.dynamicLength()).isEqualTo(1); assertHeaderEquals(header, dynamicTable.getDynamicEntry(0)); } @@ -355,9 +357,9 @@ void testLiteralHeaderWithoutIndexingDecodingRFC7541Examples() throws Exception final HPackDecoder decoder = new HPackDecoder(dynamicTable, StandardCharsets.US_ASCII); final Header header = decoder.decodeLiteralHeader(src, HPackRepresentation.WITHOUT_INDEXING); assertHeaderEquals(new BasicHeader(":path", "/sample/path"), header); - Assertions.assertFalse(src.hasRemaining(), "Decoding completed"); + Assertions.assertThat(src.hasRemaining()).withFailMessage("Decoding completed").isFalse(); - Assertions.assertEquals(0, dynamicTable.dynamicLength()); + Assertions.assertThat(dynamicTable.dynamicLength()).isEqualTo(0); } @Test @@ -370,9 +372,9 @@ void testLiteralHeaderNeverIndexedDecodingRFC7541Examples() throws Exception { final HPackDecoder decoder = new HPackDecoder(dynamicTable, StandardCharsets.US_ASCII); final Header header = decoder.decodeLiteralHeader(src, HPackRepresentation.NEVER_INDEXED); assertHeaderEquals(new BasicHeader("password", "secret", true), header); - Assertions.assertFalse(src.hasRemaining(), "Decoding completed"); + Assertions.assertThat(src.hasRemaining()).withFailMessage("Decoding completed").isFalse(); - Assertions.assertEquals(0, dynamicTable.dynamicLength()); + Assertions.assertThat(dynamicTable.dynamicLength()).isEqualTo(0); } @Test @@ -384,9 +386,9 @@ void testIndexedHeaderDecodingRFC7541Examples() throws Exception { final HPackDecoder decoder = new HPackDecoder(dynamicTable, StandardCharsets.US_ASCII); final Header header = decoder.decodeIndexedHeader(src); assertHeaderEquals(new BasicHeader(":method", "GET"), header); - Assertions.assertFalse(src.hasRemaining(), "Decoding completed"); + Assertions.assertThat(src.hasRemaining()).withFailMessage("Decoding completed").isFalse(); - Assertions.assertEquals(0, dynamicTable.dynamicLength()); + Assertions.assertThat(dynamicTable.dynamicLength()).isEqualTo(0); } @Test @@ -400,32 +402,32 @@ void testRequestDecodingWithoutHuffmanRFC7541Examples() throws Exception { final HPackDecoder decoder = new HPackDecoder(dynamicTable, StandardCharsets.US_ASCII); final List
headers1 = decoder.decodeHeaders(src1); - Assertions.assertEquals(4, headers1.size()); + Assertions.assertThat(headers1.size()).isEqualTo(4); assertHeaderEquals(new BasicHeader(":method", "GET"), headers1.get(0)); assertHeaderEquals(new BasicHeader(":scheme", "http"), headers1.get(1)); assertHeaderEquals(new BasicHeader(":path", "/"), headers1.get(2)); assertHeaderEquals(new BasicHeader(":authority", "www.example.com"), headers1.get(3)); - Assertions.assertEquals(1, dynamicTable.dynamicLength()); + Assertions.assertThat(dynamicTable.dynamicLength()).isEqualTo(1); assertHeaderEquals(new BasicHeader(":authority", "www.example.com"), dynamicTable.getDynamicEntry(0)); - Assertions.assertEquals(57, dynamicTable.getCurrentSize()); + Assertions.assertThat(dynamicTable.getCurrentSize()).isEqualTo(57); final ByteBuffer src2 = createByteBuffer( 0x82, 0x86, 0x84, 0xbe, 0x58, 0x08, 0x6e, 0x6f, 0x2d, 0x63, 0x61, 0x63, 0x68, 0x65); final List
headers2 = decoder.decodeHeaders(src2); - Assertions.assertEquals(5, headers2.size()); + Assertions.assertThat(headers2.size()).isEqualTo(5); assertHeaderEquals(new BasicHeader(":method", "GET"), headers2.get(0)); assertHeaderEquals(new BasicHeader(":scheme", "http"), headers2.get(1)); assertHeaderEquals(new BasicHeader(":path", "/"), headers2.get(2)); assertHeaderEquals(new BasicHeader(":authority", "www.example.com"), headers2.get(3)); assertHeaderEquals(new BasicHeader("cache-control", "no-cache"), headers2.get(4)); - Assertions.assertEquals(2, dynamicTable.dynamicLength()); + Assertions.assertThat(dynamicTable.dynamicLength()).isEqualTo(2); assertHeaderEquals(new BasicHeader("cache-control", "no-cache"), dynamicTable.getDynamicEntry(0)); assertHeaderEquals(new BasicHeader(":authority", "www.example.com"), dynamicTable.getDynamicEntry(1)); - Assertions.assertEquals(110, dynamicTable.getCurrentSize()); + Assertions.assertThat(dynamicTable.getCurrentSize()).isEqualTo(110); final ByteBuffer src3 = createByteBuffer( 0x82, 0x87, 0x85, 0xbf, 0x40, 0x0a, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2d, 0x6b, 0x65, 0x79, @@ -433,18 +435,18 @@ void testRequestDecodingWithoutHuffmanRFC7541Examples() throws Exception { final List
headers3 = decoder.decodeHeaders(src3); - Assertions.assertEquals(5, headers3.size()); + Assertions.assertThat(headers3.size()).isEqualTo(5); assertHeaderEquals(new BasicHeader(":method", "GET"), headers3.get(0)); assertHeaderEquals(new BasicHeader(":scheme", "https"), headers3.get(1)); assertHeaderEquals(new BasicHeader(":path", "/index.html"), headers3.get(2)); assertHeaderEquals(new BasicHeader(":authority", "www.example.com"), headers3.get(3)); assertHeaderEquals(new BasicHeader("custom-key", "custom-value"), headers3.get(4)); - Assertions.assertEquals(3, dynamicTable.dynamicLength()); + Assertions.assertThat(dynamicTable.dynamicLength()).isEqualTo(3); assertHeaderEquals(new BasicHeader("custom-key", "custom-value"), dynamicTable.getDynamicEntry(0)); assertHeaderEquals(new BasicHeader("cache-control", "no-cache"), dynamicTable.getDynamicEntry(1)); assertHeaderEquals(new BasicHeader(":authority", "www.example.com"), dynamicTable.getDynamicEntry(2)); - Assertions.assertEquals(164, dynamicTable.getCurrentSize()); + Assertions.assertThat(dynamicTable.getCurrentSize()).isEqualTo(164); } @Test @@ -457,32 +459,32 @@ void testRequestDecodingWithHuffmanRFC7541Examples() throws Exception { final HPackDecoder decoder = new HPackDecoder(dynamicTable, StandardCharsets.US_ASCII); final List
headers1 = decoder.decodeHeaders(src1); - Assertions.assertEquals(4, headers1.size()); + Assertions.assertThat(headers1.size()).isEqualTo(4); assertHeaderEquals(new BasicHeader(":method", "GET"), headers1.get(0)); assertHeaderEquals(new BasicHeader(":scheme", "http"), headers1.get(1)); assertHeaderEquals(new BasicHeader(":path", "/"), headers1.get(2)); assertHeaderEquals(new BasicHeader(":authority", "www.example.com"), headers1.get(3)); - Assertions.assertEquals(1, dynamicTable.dynamicLength()); + Assertions.assertThat(dynamicTable.dynamicLength()).isEqualTo(1); assertHeaderEquals(new BasicHeader(":authority", "www.example.com"), dynamicTable.getDynamicEntry(0)); - Assertions.assertEquals(57, dynamicTable.getCurrentSize()); + Assertions.assertThat(dynamicTable.getCurrentSize()).isEqualTo(57); final ByteBuffer src2 = createByteBuffer( 0x82, 0x86, 0x84, 0xbe, 0x58, 0x86, 0xa8, 0xeb, 0x10, 0x64, 0x9c, 0xbf); final List
headers2 = decoder.decodeHeaders(src2); - Assertions.assertEquals(5, headers2.size()); + Assertions.assertThat(headers2.size()).isEqualTo(5); assertHeaderEquals(new BasicHeader(":method", "GET"), headers2.get(0)); assertHeaderEquals(new BasicHeader(":scheme", "http"), headers2.get(1)); assertHeaderEquals(new BasicHeader(":path", "/"), headers2.get(2)); assertHeaderEquals(new BasicHeader(":authority", "www.example.com"), headers2.get(3)); assertHeaderEquals(new BasicHeader("cache-control", "no-cache"), headers2.get(4)); - Assertions.assertEquals(2, dynamicTable.dynamicLength()); + Assertions.assertThat(dynamicTable.dynamicLength()).isEqualTo(2); assertHeaderEquals(new BasicHeader("cache-control", "no-cache"), dynamicTable.getDynamicEntry(0)); assertHeaderEquals(new BasicHeader(":authority", "www.example.com"), dynamicTable.getDynamicEntry(1)); - Assertions.assertEquals(110, dynamicTable.getCurrentSize()); + Assertions.assertThat(dynamicTable.getCurrentSize()).isEqualTo(110); final ByteBuffer src3 = createByteBuffer( 0x82, 0x87, 0x85, 0xbf, 0x40, 0x88, 0x25, 0xa8, 0x49, 0xe9, 0x5b, 0xa9, 0x7d, 0x7f, 0x89, 0x25, @@ -490,18 +492,18 @@ void testRequestDecodingWithHuffmanRFC7541Examples() throws Exception { final List
headers3 = decoder.decodeHeaders(src3); - Assertions.assertEquals(5, headers3.size()); + Assertions.assertThat(headers3.size()).isEqualTo(5); assertHeaderEquals(new BasicHeader(":method", "GET"), headers3.get(0)); assertHeaderEquals(new BasicHeader(":scheme", "https"), headers3.get(1)); assertHeaderEquals(new BasicHeader(":path", "/index.html"), headers3.get(2)); assertHeaderEquals(new BasicHeader(":authority", "www.example.com"), headers3.get(3)); assertHeaderEquals(new BasicHeader("custom-key", "custom-value"), headers3.get(4)); - Assertions.assertEquals(3, dynamicTable.dynamicLength()); + Assertions.assertThat(dynamicTable.dynamicLength()).isEqualTo(3); assertHeaderEquals(new BasicHeader("custom-key", "custom-value"), dynamicTable.getDynamicEntry(0)); assertHeaderEquals(new BasicHeader("cache-control", "no-cache"), dynamicTable.getDynamicEntry(1)); assertHeaderEquals(new BasicHeader(":authority", "www.example.com"), dynamicTable.getDynamicEntry(2)); - Assertions.assertEquals(164, dynamicTable.getCurrentSize()); + Assertions.assertThat(dynamicTable.getCurrentSize()).isEqualTo(164); } @Test @@ -519,37 +521,37 @@ void testResponseDecodingWithoutHuffmanRFC7541Examples() throws Exception { final HPackDecoder decoder = new HPackDecoder(dynamicTable, StandardCharsets.US_ASCII); final List
headers1 = decoder.decodeHeaders(src1); - Assertions.assertEquals(4, headers1.size()); + Assertions.assertThat(headers1.size()).isEqualTo(4); assertHeaderEquals(new BasicHeader(":status", "302"), headers1.get(0)); assertHeaderEquals(new BasicHeader("cache-control", "private"), headers1.get(1)); assertHeaderEquals(new BasicHeader("date", "Mon, 21 Oct 2013 20:13:21 GMT"), headers1.get(2)); assertHeaderEquals(new BasicHeader("location", "https://www.example.com"), headers1.get(3)); - Assertions.assertEquals(4, dynamicTable.dynamicLength()); + Assertions.assertThat(dynamicTable.dynamicLength()).isEqualTo(4); assertHeaderEquals(new BasicHeader("location", "https://www.example.com"), dynamicTable.getDynamicEntry(0)); assertHeaderEquals(new BasicHeader("date", "Mon, 21 Oct 2013 20:13:21 GMT"), dynamicTable.getDynamicEntry(1)); assertHeaderEquals(new BasicHeader("cache-control", "private"), dynamicTable.getDynamicEntry(2)); assertHeaderEquals(new BasicHeader(":status", "302"), dynamicTable.getDynamicEntry(3)); - Assertions.assertEquals(222, dynamicTable.getCurrentSize()); + Assertions.assertThat(dynamicTable.getCurrentSize()).isEqualTo(222); final ByteBuffer src2 = createByteBuffer( 0x48, 0x03, 0x33, 0x30, 0x37, 0xc1, 0xc0, 0xbf); final List
headers2 = decoder.decodeHeaders(src2); - Assertions.assertEquals(4, headers2.size()); + Assertions.assertThat(headers2.size()).isEqualTo(4); assertHeaderEquals(new BasicHeader(":status", "307"), headers2.get(0)); assertHeaderEquals(new BasicHeader("cache-control", "private"), headers2.get(1)); assertHeaderEquals(new BasicHeader("date", "Mon, 21 Oct 2013 20:13:21 GMT"), headers2.get(2)); assertHeaderEquals(new BasicHeader("location", "https://www.example.com"), headers2.get(3)); - Assertions.assertEquals(4, dynamicTable.dynamicLength()); + Assertions.assertThat(dynamicTable.dynamicLength()).isEqualTo(4); assertHeaderEquals(new BasicHeader(":status", "307"), dynamicTable.getDynamicEntry(0)); assertHeaderEquals(new BasicHeader("location", "https://www.example.com"), dynamicTable.getDynamicEntry(1)); assertHeaderEquals(new BasicHeader("date", "Mon, 21 Oct 2013 20:13:21 GMT"), dynamicTable.getDynamicEntry(2)); assertHeaderEquals(new BasicHeader("cache-control", "private"), dynamicTable.getDynamicEntry(3)); - Assertions.assertEquals(222, dynamicTable.getCurrentSize()); + Assertions.assertThat(dynamicTable.getCurrentSize()).isEqualTo(222); final ByteBuffer src3 = createByteBuffer( 0x88, 0xc1, 0x61, 0x1d, 0x4d, 0x6f, 0x6e, 0x2c, 0x20, 0x32, 0x31, 0x20, 0x4f, 0x63, 0x74, 0x20, 0x32, @@ -561,7 +563,7 @@ void testResponseDecodingWithoutHuffmanRFC7541Examples() throws Exception { final List
headers3 = decoder.decodeHeaders(src3); - Assertions.assertEquals(6, headers3.size()); + Assertions.assertThat(headers3.size()).isEqualTo(6); assertHeaderEquals(new BasicHeader(":status", "200"), headers3.get(0)); assertHeaderEquals(new BasicHeader("cache-control", "private"), headers3.get(1)); assertHeaderEquals(new BasicHeader("date", "Mon, 21 Oct 2013 20:13:22 GMT"), headers3.get(2)); @@ -569,12 +571,12 @@ void testResponseDecodingWithoutHuffmanRFC7541Examples() throws Exception { assertHeaderEquals(new BasicHeader("content-encoding", "gzip"), headers3.get(4)); assertHeaderEquals(new BasicHeader("set-cookie", "foo=ASDJKHQKBZXOQWEOPIUAXQWEOIU; max-age=3600; version=1"), headers3.get(5)); - Assertions.assertEquals(3, dynamicTable.dynamicLength()); + Assertions.assertThat(dynamicTable.dynamicLength()).isEqualTo(3); assertHeaderEquals(new BasicHeader("set-cookie", "foo=ASDJKHQKBZXOQWEOPIUAXQWEOIU; max-age=3600; version=1"), dynamicTable.getDynamicEntry(0)); assertHeaderEquals(new BasicHeader("content-encoding", "gzip"), dynamicTable.getDynamicEntry(1)); assertHeaderEquals(new BasicHeader("date", "Mon, 21 Oct 2013 20:13:22 GMT"), dynamicTable.getDynamicEntry(2)); - Assertions.assertEquals(215, dynamicTable.getCurrentSize()); + Assertions.assertThat(dynamicTable.getCurrentSize()).isEqualTo(215); } @Test @@ -591,37 +593,37 @@ void testResponseDecodingWithHuffmanRFC7541Examples() throws Exception { final HPackDecoder decoder = new HPackDecoder(dynamicTable, StandardCharsets.US_ASCII); final List
headers1 = decoder.decodeHeaders(src1); - Assertions.assertEquals(4, headers1.size()); + Assertions.assertThat(headers1.size()).isEqualTo(4); assertHeaderEquals(new BasicHeader(":status", "302"), headers1.get(0)); assertHeaderEquals(new BasicHeader("cache-control", "private"), headers1.get(1)); assertHeaderEquals(new BasicHeader("date", "Mon, 21 Oct 2013 20:13:21 GMT"), headers1.get(2)); assertHeaderEquals(new BasicHeader("location", "https://www.example.com"), headers1.get(3)); - Assertions.assertEquals(4, dynamicTable.dynamicLength()); + Assertions.assertThat(dynamicTable.dynamicLength()).isEqualTo(4); assertHeaderEquals(new BasicHeader("location", "https://www.example.com"), dynamicTable.getDynamicEntry(0)); assertHeaderEquals(new BasicHeader("date", "Mon, 21 Oct 2013 20:13:21 GMT"), dynamicTable.getDynamicEntry(1)); assertHeaderEquals(new BasicHeader("cache-control", "private"), dynamicTable.getDynamicEntry(2)); assertHeaderEquals(new BasicHeader(":status", "302"), dynamicTable.getDynamicEntry(3)); - Assertions.assertEquals(222, dynamicTable.getCurrentSize()); + Assertions.assertThat(dynamicTable.getCurrentSize()).isEqualTo(222); final ByteBuffer src2 = createByteBuffer( 0x48, 0x83, 0x64, 0x0e, 0xff, 0xc1, 0xc0, 0xbf); final List
headers2 = decoder.decodeHeaders(src2); - Assertions.assertEquals(4, headers2.size()); + Assertions.assertThat(headers2.size()).isEqualTo(4); assertHeaderEquals(new BasicHeader(":status", "307"), headers2.get(0)); assertHeaderEquals(new BasicHeader("cache-control", "private"), headers2.get(1)); assertHeaderEquals(new BasicHeader("date", "Mon, 21 Oct 2013 20:13:21 GMT"), headers2.get(2)); assertHeaderEquals(new BasicHeader("location", "https://www.example.com"), headers2.get(3)); - Assertions.assertEquals(4, dynamicTable.dynamicLength()); + Assertions.assertThat(dynamicTable.dynamicLength()).isEqualTo(4); assertHeaderEquals(new BasicHeader(":status", "307"), dynamicTable.getDynamicEntry(0)); assertHeaderEquals(new BasicHeader("location", "https://www.example.com"), dynamicTable.getDynamicEntry(1)); assertHeaderEquals(new BasicHeader("date", "Mon, 21 Oct 2013 20:13:21 GMT"), dynamicTable.getDynamicEntry(2)); assertHeaderEquals(new BasicHeader("cache-control", "private"), dynamicTable.getDynamicEntry(3)); - Assertions.assertEquals(222, dynamicTable.getCurrentSize()); + Assertions.assertThat(dynamicTable.getCurrentSize()).isEqualTo(222); final ByteBuffer src3 = createByteBuffer( 0x88, 0xc1, 0x61, 0x96, 0xd0, 0x7a, 0xbe, 0x94, 0x10, 0x54, 0xd4, 0x44, 0xa8, 0x20, 0x05, 0x95, 0x04, @@ -632,7 +634,7 @@ void testResponseDecodingWithHuffmanRFC7541Examples() throws Exception { final List
headers3 = decoder.decodeHeaders(src3); - Assertions.assertEquals(6, headers3.size()); + Assertions.assertThat(headers3.size()).isEqualTo(6); assertHeaderEquals(new BasicHeader(":status", "200"), headers3.get(0)); assertHeaderEquals(new BasicHeader("cache-control", "private"), headers3.get(1)); assertHeaderEquals(new BasicHeader("date", "Mon, 21 Oct 2013 20:13:22 GMT"), headers3.get(2)); @@ -640,12 +642,12 @@ void testResponseDecodingWithHuffmanRFC7541Examples() throws Exception { assertHeaderEquals(new BasicHeader("content-encoding", "gzip"), headers3.get(4)); assertHeaderEquals(new BasicHeader("set-cookie", "foo=ASDJKHQKBZXOQWEOPIUAXQWEOIU; max-age=3600; version=1"), headers3.get(5)); - Assertions.assertEquals(3, dynamicTable.dynamicLength()); + Assertions.assertThat(dynamicTable.dynamicLength()).isEqualTo(3); assertHeaderEquals(new BasicHeader("set-cookie", "foo=ASDJKHQKBZXOQWEOPIUAXQWEOIU; max-age=3600; version=1"), dynamicTable.getDynamicEntry(0)); assertHeaderEquals(new BasicHeader("content-encoding", "gzip"), dynamicTable.getDynamicEntry(1)); assertHeaderEquals(new BasicHeader("date", "Mon, 21 Oct 2013 20:13:22 GMT"), dynamicTable.getDynamicEntry(2)); - Assertions.assertEquals(215, dynamicTable.getCurrentSize()); + Assertions.assertThat(dynamicTable.getCurrentSize()).isEqualTo(215); } private static byte[] createByteArray(final int... bytes) { @@ -671,7 +673,7 @@ void testLiteralHeaderWithIndexingEncodingRFC7541Examples() throws Exception { 0x40, 0x0a, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2d, 0x6b, 0x65, 0x79, 0x0d, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2d, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72); - Assertions.assertArrayEquals(expected, buf.toByteArray()); + Assertions.assertThat(buf.toByteArray()).containsExactly(expected); } @Test @@ -697,7 +699,7 @@ public HPackHeader getHeader() { final byte[] expected = createByteArray( 0x04, 0x0c, 0x2f, 0x73, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x2f, 0x70, 0x61, 0x74, 0x68); - Assertions.assertArrayEquals(expected, buf.toByteArray()); + Assertions.assertThat(buf.toByteArray()).containsExactly(expected); } @Test @@ -713,7 +715,7 @@ void testLiteralHeaderNeverIndexedEncodingRFC7541Examples() throws Exception { final byte[] expected = createByteArray( 0x10, 0x08, 0x70, 0x61, 0x73, 0x73, 0x77, 0x6f, 0x72, 0x64, 0x06, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74); - Assertions.assertArrayEquals(expected, buf.toByteArray()); + Assertions.assertThat(buf.toByteArray()).containsExactly(expected); } @Test @@ -726,7 +728,7 @@ void testIndexedHeaderEncodingRFC7541Examples() { encoder.encodeIndex(buf, 2); final byte[] expected = createByteArray(0x82); - Assertions.assertArrayEquals(expected, buf.toByteArray()); + Assertions.assertThat(buf.toByteArray()).containsExactly(expected); } @Test @@ -747,11 +749,11 @@ void testRequestEncodingWithoutHuffmanRFC7541Examples() throws Exception { final byte[] expected1 = createByteArray( 0x82, 0x86, 0x84, 0x41, 0x0f, 0x77, 0x77, 0x77, 0x2e, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x2e, 0x63, 0x6f, 0x6d); - Assertions.assertArrayEquals(expected1, buf.toByteArray()); + Assertions.assertThat(buf.toByteArray()).containsExactly(expected1); - Assertions.assertEquals(1, dynamicTable.dynamicLength()); + Assertions.assertThat(dynamicTable.dynamicLength()).isEqualTo(1); assertHeaderEquals(new BasicHeader(":authority", "www.example.com"), dynamicTable.getDynamicEntry(0)); - Assertions.assertEquals(57, dynamicTable.getCurrentSize()); + Assertions.assertThat(dynamicTable.getCurrentSize()).isEqualTo(57); final List
headers2 = Arrays.asList( new BasicHeader(":method", "GET"), @@ -765,12 +767,12 @@ void testRequestEncodingWithoutHuffmanRFC7541Examples() throws Exception { final byte[] expected2 = createByteArray( 0x82, 0x86, 0x84, 0xbe, 0x58, 0x08, 0x6e, 0x6f, 0x2d, 0x63, 0x61, 0x63, 0x68, 0x65); - Assertions.assertArrayEquals(expected2, buf.toByteArray()); + Assertions.assertThat(buf.toByteArray()).containsExactly(expected2); - Assertions.assertEquals(2, dynamicTable.dynamicLength()); + Assertions.assertThat(dynamicTable.dynamicLength()).isEqualTo(2); assertHeaderEquals(new BasicHeader("cache-control", "no-cache"), dynamicTable.getDynamicEntry(0)); assertHeaderEquals(new BasicHeader(":authority", "www.example.com"), dynamicTable.getDynamicEntry(1)); - Assertions.assertEquals(110, dynamicTable.getCurrentSize()); + Assertions.assertThat(dynamicTable.getCurrentSize()).isEqualTo(110); final List
headers3 = Arrays.asList( new BasicHeader(":method", "GET"), @@ -785,13 +787,13 @@ void testRequestEncodingWithoutHuffmanRFC7541Examples() throws Exception { final byte[] expected3 = createByteArray( 0x82, 0x87, 0x85, 0xbf, 0x40, 0x0a, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2d, 0x6b, 0x65, 0x79, 0x0c, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2d, 0x76, 0x61, 0x6c, 0x75, 0x65); - Assertions.assertArrayEquals(expected3, buf.toByteArray()); + Assertions.assertThat(buf.toByteArray()).containsExactly(expected3); - Assertions.assertEquals(3, dynamicTable.dynamicLength()); + Assertions.assertThat(dynamicTable.dynamicLength()).isEqualTo(3); assertHeaderEquals(new BasicHeader("custom-key", "custom-value"), dynamicTable.getDynamicEntry(0)); assertHeaderEquals(new BasicHeader("cache-control", "no-cache"), dynamicTable.getDynamicEntry(1)); assertHeaderEquals(new BasicHeader(":authority", "www.example.com"), dynamicTable.getDynamicEntry(2)); - Assertions.assertEquals(164, dynamicTable.getCurrentSize()); + Assertions.assertThat(dynamicTable.getCurrentSize()).isEqualTo(164); } @Test @@ -811,11 +813,11 @@ void testRequestEncodingWithHuffmanRFC7541Examples() throws Exception { final byte[] expected1 = createByteArray( 0x82, 0x86, 0x84, 0x41, 0x8c, 0xf1, 0xe3, 0xc2, 0xe5, 0xf2, 0x3a, 0x6b, 0xa0, 0xab, 0x90, 0xf4, 0xff); - Assertions.assertArrayEquals(expected1, buf.toByteArray()); + Assertions.assertThat(buf.toByteArray()).containsExactly(expected1); - Assertions.assertEquals(1, dynamicTable.dynamicLength()); + Assertions.assertThat(dynamicTable.dynamicLength()).isEqualTo(1); assertHeaderEquals(new BasicHeader(":authority", "www.example.com"), dynamicTable.getDynamicEntry(0)); - Assertions.assertEquals(57, dynamicTable.getCurrentSize()); + Assertions.assertThat(dynamicTable.getCurrentSize()).isEqualTo(57); final List
headers2 = Arrays.asList( new BasicHeader(":method", "GET"), @@ -829,12 +831,12 @@ void testRequestEncodingWithHuffmanRFC7541Examples() throws Exception { final byte[] expected2 = createByteArray( 0x82, 0x86, 0x84, 0xbe, 0x58, 0x86, 0xa8, 0xeb, 0x10, 0x64, 0x9c, 0xbf); - Assertions.assertArrayEquals(expected2, buf.toByteArray()); + Assertions.assertThat(buf.toByteArray()).containsExactly(expected2); - Assertions.assertEquals(2, dynamicTable.dynamicLength()); + Assertions.assertThat(dynamicTable.dynamicLength()).isEqualTo(2); assertHeaderEquals(new BasicHeader("cache-control", "no-cache"), dynamicTable.getDynamicEntry(0)); assertHeaderEquals(new BasicHeader(":authority", "www.example.com"), dynamicTable.getDynamicEntry(1)); - Assertions.assertEquals(110, dynamicTable.getCurrentSize()); + Assertions.assertThat(dynamicTable.getCurrentSize()).isEqualTo(110); final List
headers3 = Arrays.asList( new BasicHeader(":method", "GET"), @@ -849,13 +851,13 @@ void testRequestEncodingWithHuffmanRFC7541Examples() throws Exception { final byte[] expected3 = createByteArray( 0x82, 0x87, 0x85, 0xbf, 0x40, 0x88, 0x25, 0xa8, 0x49, 0xe9, 0x5b, 0xa9, 0x7d, 0x7f, 0x89, 0x25, 0xa8, 0x49, 0xe9, 0x5b, 0xb8, 0xe8, 0xb4, 0xbf); - Assertions.assertArrayEquals(expected3, buf.toByteArray()); + Assertions.assertThat(buf.toByteArray()).containsExactly(expected3); - Assertions.assertEquals(3, dynamicTable.dynamicLength()); + Assertions.assertThat(dynamicTable.dynamicLength()).isEqualTo(3); assertHeaderEquals(new BasicHeader("custom-key", "custom-value"), dynamicTable.getDynamicEntry(0)); assertHeaderEquals(new BasicHeader("cache-control", "no-cache"), dynamicTable.getDynamicEntry(1)); assertHeaderEquals(new BasicHeader(":authority", "www.example.com"), dynamicTable.getDynamicEntry(2)); - Assertions.assertEquals(164, dynamicTable.getCurrentSize()); + Assertions.assertThat(dynamicTable.getCurrentSize()).isEqualTo(164); } @Test @@ -880,14 +882,14 @@ void testResponseEncodingWithoutHuffmanRFC7541Examples() throws Exception { 0x30, 0x3a, 0x31, 0x33, 0x3a, 0x32, 0x31, 0x20, 0x47, 0x4d, 0x54, 0x6e, 0x17, 0x68, 0x74, 0x74, 0x70, 0x73, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x2e, 0x63, 0x6f, 0x6d); - Assertions.assertArrayEquals(expected1, buf.toByteArray()); + Assertions.assertThat(buf.toByteArray()).containsExactly(expected1); - Assertions.assertEquals(4, dynamicTable.dynamicLength()); + Assertions.assertThat(dynamicTable.dynamicLength()).isEqualTo(4); assertHeaderEquals(new BasicHeader("location", "https://www.example.com"), dynamicTable.getDynamicEntry(0)); assertHeaderEquals(new BasicHeader("date", "Mon, 21 Oct 2013 20:13:21 GMT"), dynamicTable.getDynamicEntry(1)); assertHeaderEquals(new BasicHeader("cache-control", "private"), dynamicTable.getDynamicEntry(2)); assertHeaderEquals(new BasicHeader(":status", "302"), dynamicTable.getDynamicEntry(3)); - Assertions.assertEquals(222, dynamicTable.getCurrentSize()); + Assertions.assertThat(dynamicTable.getCurrentSize()).isEqualTo(222); final List
headers2 = Arrays.asList( new BasicHeader(":status", "307"), @@ -900,15 +902,15 @@ void testResponseEncodingWithoutHuffmanRFC7541Examples() throws Exception { final byte[] expected2 = createByteArray( 0x48, 0x03, 0x33, 0x30, 0x37, 0xc1, 0xc0, 0xbf); - Assertions.assertArrayEquals(expected2, buf.toByteArray()); + Assertions.assertThat(buf.toByteArray()).containsExactly(expected2); - Assertions.assertEquals(4, dynamicTable.dynamicLength()); + Assertions.assertThat(dynamicTable.dynamicLength()).isEqualTo(4); assertHeaderEquals(new BasicHeader(":status", "307"), dynamicTable.getDynamicEntry(0)); assertHeaderEquals(new BasicHeader("location", "https://www.example.com"), dynamicTable.getDynamicEntry(1)); assertHeaderEquals(new BasicHeader("date", "Mon, 21 Oct 2013 20:13:21 GMT"), dynamicTable.getDynamicEntry(2)); assertHeaderEquals(new BasicHeader("cache-control", "private"), dynamicTable.getDynamicEntry(3)); - Assertions.assertEquals(222, dynamicTable.getCurrentSize()); + Assertions.assertThat(dynamicTable.getCurrentSize()).isEqualTo(222); final List
headers3 = Arrays.asList( new BasicHeader(":status", "200"), @@ -928,14 +930,14 @@ void testResponseEncodingWithoutHuffmanRFC7541Examples() throws Exception { 0x48, 0x51, 0x4b, 0x42, 0x5a, 0x58, 0x4f, 0x51, 0x57, 0x45, 0x4f, 0x50, 0x49, 0x55, 0x41, 0x58, 0x51, 0x57, 0x45, 0x4f, 0x49, 0x55, 0x3b, 0x20, 0x6d, 0x61, 0x78, 0x2d, 0x61, 0x67, 0x65, 0x3d, 0x33, 0x36, 0x30, 0x30, 0x3b, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x31); - Assertions.assertArrayEquals(expected3, buf.toByteArray()); + Assertions.assertThat(buf.toByteArray()).containsExactly(expected3); - Assertions.assertEquals(3, dynamicTable.dynamicLength()); + Assertions.assertThat(dynamicTable.dynamicLength()).isEqualTo(3); assertHeaderEquals(new BasicHeader("set-cookie", "foo=ASDJKHQKBZXOQWEOPIUAXQWEOIU; max-age=3600; version=1"), dynamicTable.getDynamicEntry(0)); assertHeaderEquals(new BasicHeader("content-encoding", "gzip"), dynamicTable.getDynamicEntry(1)); assertHeaderEquals(new BasicHeader("date", "Mon, 21 Oct 2013 20:13:22 GMT"), dynamicTable.getDynamicEntry(2)); - Assertions.assertEquals(215, dynamicTable.getCurrentSize()); + Assertions.assertThat(dynamicTable.getCurrentSize()).isEqualTo(215); } @Test @@ -959,14 +961,14 @@ void testResponseEncodingWithHuffmanRFC7541Examples() throws Exception { 0x10, 0x54, 0xd4, 0x44, 0xa8, 0x20, 0x05, 0x95, 0x04, 0x0b, 0x81, 0x66, 0xe0, 0x82, 0xa6, 0x2d, 0x1b, 0xff, 0x6e, 0x91, 0x9d, 0x29, 0xad, 0x17, 0x18, 0x63, 0xc7, 0x8f, 0x0b, 0x97, 0xc8, 0xe9, 0xae, 0x82, 0xae, 0x43, 0xd3); - Assertions.assertArrayEquals(expected1, buf.toByteArray()); + Assertions.assertThat(buf.toByteArray()).containsExactly(expected1); - Assertions.assertEquals(4, dynamicTable.dynamicLength()); + Assertions.assertThat(dynamicTable.dynamicLength()).isEqualTo(4); assertHeaderEquals(new BasicHeader("location", "https://www.example.com"), dynamicTable.getDynamicEntry(0)); assertHeaderEquals(new BasicHeader("date", "Mon, 21 Oct 2013 20:13:21 GMT"), dynamicTable.getDynamicEntry(1)); assertHeaderEquals(new BasicHeader("cache-control", "private"), dynamicTable.getDynamicEntry(2)); assertHeaderEquals(new BasicHeader(":status", "302"), dynamicTable.getDynamicEntry(3)); - Assertions.assertEquals(222, dynamicTable.getCurrentSize()); + Assertions.assertThat(dynamicTable.getCurrentSize()).isEqualTo(222); final List
headers2 = Arrays.asList( new BasicHeader(":status", "307"), @@ -979,15 +981,15 @@ void testResponseEncodingWithHuffmanRFC7541Examples() throws Exception { final byte[] expected2 = createByteArray( 0x48, 0x83, 0x64, 0x0e, 0xff, 0xc1, 0xc0, 0xbf); - Assertions.assertArrayEquals(expected2, buf.toByteArray()); + Assertions.assertThat(buf.toByteArray()).containsExactly(expected2); - Assertions.assertEquals(4, dynamicTable.dynamicLength()); + Assertions.assertThat(dynamicTable.dynamicLength()).isEqualTo(4); assertHeaderEquals(new BasicHeader(":status", "307"), dynamicTable.getDynamicEntry(0)); assertHeaderEquals(new BasicHeader("location", "https://www.example.com"), dynamicTable.getDynamicEntry(1)); assertHeaderEquals(new BasicHeader("date", "Mon, 21 Oct 2013 20:13:21 GMT"), dynamicTable.getDynamicEntry(2)); assertHeaderEquals(new BasicHeader("cache-control", "private"), dynamicTable.getDynamicEntry(3)); - Assertions.assertEquals(222, dynamicTable.getCurrentSize()); + Assertions.assertThat(dynamicTable.getCurrentSize()).isEqualTo(222); final List
headers3 = Arrays.asList( new BasicHeader(":status", "200"), @@ -1006,14 +1008,14 @@ void testResponseEncodingWithHuffmanRFC7541Examples() throws Exception { 0x94, 0xe7, 0x82, 0x1d, 0xd7, 0xf2, 0xe6, 0xc7, 0xb3, 0x35, 0xdf, 0xdf, 0xcd, 0x5b, 0x39, 0x60, 0xd5, 0xaf, 0x27, 0x08, 0x7f, 0x36, 0x72, 0xc1, 0xab, 0x27, 0x0f, 0xb5, 0x29, 0x1f, 0x95, 0x87, 0x31, 0x60, 0x65, 0xc0, 0x03, 0xed, 0x4e, 0xe5, 0xb1, 0x06, 0x3d, 0x50, 0x07); - Assertions.assertArrayEquals(expected3, buf.toByteArray()); + Assertions.assertThat(buf.toByteArray()).containsExactly(expected3); - Assertions.assertEquals(3, dynamicTable.dynamicLength()); + Assertions.assertThat(dynamicTable.dynamicLength()).isEqualTo(3); assertHeaderEquals(new BasicHeader("set-cookie", "foo=ASDJKHQKBZXOQWEOPIUAXQWEOIU; max-age=3600; version=1"), dynamicTable.getDynamicEntry(0)); assertHeaderEquals(new BasicHeader("content-encoding", "gzip"), dynamicTable.getDynamicEntry(1)); assertHeaderEquals(new BasicHeader("date", "Mon, 21 Oct 2013 20:13:22 GMT"), dynamicTable.getDynamicEntry(2)); - Assertions.assertEquals(215, dynamicTable.getCurrentSize()); + Assertions.assertThat(dynamicTable.getCurrentSize()).isEqualTo(215); } @Test @@ -1033,8 +1035,8 @@ void testHeaderEntrySizeNonAscii() throws Exception { encoder1.encodeHeader(buffer, header); assertHeaderEquals(header, decoder1.decodeHeader(wrap(buffer))); - Assertions.assertEquals(1, outboundTable1.dynamicLength()); - Assertions.assertEquals(1, inboundTable1.dynamicLength()); + Assertions.assertThat(outboundTable1.dynamicLength()).isEqualTo(1); + Assertions.assertThat(inboundTable1.dynamicLength()).isEqualTo(1); assertHeaderEquals(header, outboundTable1.getDynamicEntry(0)); assertHeaderEquals(header, inboundTable1.getDynamicEntry(0)); @@ -1052,8 +1054,8 @@ void testHeaderEntrySizeNonAscii() throws Exception { encoder2.encodeHeader(buffer, header); assertHeaderEquals(header, decoder2.decodeHeader(wrap(buffer))); - Assertions.assertEquals(0, outboundTable2.dynamicLength()); - Assertions.assertEquals(0, inboundTable2.dynamicLength()); + Assertions.assertThat(outboundTable2.dynamicLength()).isEqualTo(0); + Assertions.assertThat(inboundTable2.dynamicLength()).isEqualTo(0); } @Test @@ -1071,14 +1073,14 @@ void testHeaderSizeLimit() throws Exception { "123456789012345678901234567890123456789012345678901234567890")), false); - Assertions.assertEquals(2, decoder.decodeHeaders(wrap(buf)).size()); + Assertions.assertThat(decoder.decodeHeaders(wrap(buf)).size()).isEqualTo(2); decoder.setMaxListSize(1000000); - Assertions.assertEquals(2, decoder.decodeHeaders(wrap(buf)).size()); + Assertions.assertThat(decoder.decodeHeaders(wrap(buf)).size()).isEqualTo(2); decoder.setMaxListSize(200); - Assertions.assertThrows(HeaderListConstraintException.class, () -> - decoder.decodeHeaders(wrap(buf))); + Assertions.assertThatThrownBy(() -> + decoder.decodeHeaders(wrap(buf))).isInstanceOf(HeaderListConstraintException.class); } @Test @@ -1116,7 +1118,7 @@ void encoderDynamicHeaderTableMaxSizeNotIncreasedBySettingsFrame() throws Except //emulate receiving a settings frame from the receiver encoder.setMaxTableSize(Integer.MAX_VALUE); //actual table size should not change until we are able to send an update to the receiver - Assertions.assertEquals(4096, dynamicTable.getMaxSize()); + Assertions.assertThat(dynamicTable.getMaxSize()).isEqualTo(4096); } @Test @@ -1135,10 +1137,10 @@ void encoderDynamicHeaderTableMaxSizeChangeCausesUpdateHeader() throws Exception final int masked = firstByte & 0xe0; //first header field is table size update - Assertions.assertEquals(0x20, masked); + Assertions.assertThat(masked).isEqualTo(0x20); //update has new table size as value - Assertions.assertEquals(8192, HPackDecoder.decodeInt(wrap(buf), 5)); + Assertions.assertThat(HPackDecoder.decodeInt(wrap(buf), 5)).isEqualTo(8192); } @Test @@ -1149,7 +1151,7 @@ void decoderDynamicHeaderTableMaxSizeNotIncreasedBySettingsFrame() throws Except //this would cause us to send a new settings frame to the sender decoder.setMaxTableSize(Integer.MAX_VALUE); //actual table size should not change until sender sends us a table update - Assertions.assertEquals(4096, dynamicTable.getMaxSize()); + Assertions.assertThat(dynamicTable.getMaxSize()).isEqualTo(4096); } @Test @@ -1163,7 +1165,7 @@ void decoderDynamicHeaderTableMaxSizeUpdatesAfter() throws Exception { decoder.decodeHeaders(wrap(buf)); - Assertions.assertEquals(8192, dynamicTable.getMaxSize()); + Assertions.assertThat(dynamicTable.getMaxSize()).isEqualTo(8192); } @Test @@ -1175,7 +1177,9 @@ void decoderDynamicHeaderTableMaxSizeLimitedByConfig() throws Exception { //emulate receiving header that illegally increases the table size above our max final ByteArrayBuffer buf = new ByteArrayBuffer(128); HPackEncoder.encodeInt(buf, 5, 8192, 0x20); - Assertions.assertThrows(HPackException.class, () -> decoder.decodeHeaders(wrap(buf))); + Assertions.assertThatThrownBy(() -> + decoder.decodeHeaders(wrap(buf))) + .isInstanceOf(HPackException.class); } @Test @@ -1188,8 +1192,10 @@ void decoderRejectsDynamicTableSizeUpdateMidHeaderBlock() { 0x20 // dynamic table size update (0) - illegal after first header field ); - final HPackException ex = Assertions.assertThrows(HPackException.class, () -> decoder.decodeHeaders(src)); - Assertions.assertTrue(ex.getMessage().contains("beginning of a header block")); + final HPackException ex = Assertions.assertThatThrownBy(() -> + decoder.decodeHeaders(src)) + .isInstanceOf(HPackException.class).asInstanceOf(InstanceOfAssertFactories.type(HPackException.class)).actual(); + Assertions.assertThat(ex.getMessage().contains("beginning of a header block")).isTrue(); } @Test @@ -1204,9 +1210,9 @@ void decoderAllowsMultipleLeadingDynamicTableSizeUpdates() throws Exception { ); final List
headers = decoder.decodeHeaders(src); - Assertions.assertEquals(1, headers.size()); + Assertions.assertThat(headers.size()).isEqualTo(1); assertHeaderEquals(new BasicHeader(":method", "GET"), headers.get(0)); - Assertions.assertEquals(10, dynamicTable.getMaxSize()); + Assertions.assertThat(dynamicTable.getMaxSize()).isEqualTo(10); } @Test @@ -1220,16 +1226,18 @@ void decoderRejectsDynamicTableSizeUpdateAfterLeadingUpdateAndHeader() { 0x20 // dynamic table size update (0) - illegal after first header field ); - final HPackException ex = Assertions.assertThrows(HPackException.class, () -> decoder.decodeHeaders(src)); - Assertions.assertTrue(ex.getMessage().contains("beginning of a header block")); + final HPackException ex = Assertions.assertThatThrownBy(() -> + decoder.decodeHeaders(src)) + .isInstanceOf(HPackException.class).asInstanceOf(InstanceOfAssertFactories.type(HPackException.class)).actual(); + Assertions.assertThat(ex.getMessage().contains("beginning of a header block")).isTrue(); } @Test void testIntegerDecodingOverflow() { // 7-bit prefix integer that mathematically decodes to Integer.MAX_VALUE + 127. // Without an overflow guard this wraps to a negative int and leaks into higher-level decoding. - Assertions.assertThrows(HPackException.class, () -> - HPackDecoder.decodeInt(createByteBuffer(0x7f, 0xff, 0xff, 0xff, 0xff, 0x07), 7)); + Assertions.assertThatThrownBy(() -> + HPackDecoder.decodeInt(createByteBuffer(0x7f, 0xff, 0xff, 0xff, 0xff, 0x07), 7)).isInstanceOf(HPackException.class); } diff --git a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/hpack/TestHPackDecoderRfc9113.java b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/hpack/TestHPackDecoderRfc9113.java index a816db1667..4b9e431dce 100644 --- a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/hpack/TestHPackDecoderRfc9113.java +++ b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/hpack/TestHPackDecoderRfc9113.java @@ -35,7 +35,8 @@ import org.apache.hc.core5.http.Header; import org.apache.hc.core5.http.message.BasicHeader; import org.apache.hc.core5.util.ByteArrayBuffer; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; +import org.assertj.core.api.InstanceOfAssertFactories; import org.junit.jupiter.api.Test; class TestHPackDecoderRfc9113 { @@ -54,9 +55,9 @@ void testHeaderListAtExactLimitIsAccepted() throws Exception { final List
decoded = decoder.decodeHeaders(asByteBuffer(block)); - Assertions.assertEquals(1, decoded.size()); - Assertions.assertEquals(header.getName(), decoded.get(0).getName()); - Assertions.assertEquals(header.getValue(), decoded.get(0).getValue()); + Assertions.assertThat(decoded.size()).isEqualTo(1); + Assertions.assertThat(decoded.get(0).getName()).isEqualTo(header.getName()); + Assertions.assertThat(decoded.get(0).getValue()).isEqualTo(header.getValue()); } @Test @@ -72,8 +73,10 @@ void testOversizedHeaderBlockIsFullyProcessed() throws Exception { decoder.setMaxListSize(headerSize(first) - 1); final ByteBuffer src = asByteBuffer(oversizedBlock); - Assertions.assertThrows(HeaderListConstraintException.class, () -> decoder.decodeHeaders(src)); - Assertions.assertFalse(src.hasRemaining(), "The entire field block must be processed"); + Assertions.assertThatThrownBy(() -> + decoder.decodeHeaders(src)) + .isInstanceOf(HeaderListConstraintException.class); + Assertions.assertThat(src.hasRemaining()).withFailMessage("The entire field block must be processed").isFalse(); // The encoder will represent the second header using the dynamic table. // Decoding it proves that the oversized block updated the decoder's @@ -84,9 +87,9 @@ void testOversizedHeaderBlockIsFullyProcessed() throws Exception { decoder.setMaxListSize(Integer.MAX_VALUE); final List
decoded = decoder.decodeHeaders(asByteBuffer(indexedBlock)); - Assertions.assertEquals(1, decoded.size()); - Assertions.assertEquals(second.getName(), decoded.get(0).getName()); - Assertions.assertEquals(second.getValue(), decoded.get(0).getValue()); + Assertions.assertThat(decoded.size()).isEqualTo(1); + Assertions.assertThat(decoded.get(0).getName()).isEqualTo(second.getName()); + Assertions.assertThat(decoded.get(0).getValue()).isEqualTo(second.getValue()); } @Test @@ -104,14 +107,12 @@ void testCompressionErrorAfterHeaderListLimitIsNotMasked() throws Exception { final HPackDecoder decoder = new HPackDecoder(TABLE_SIZE, StandardCharsets.US_ASCII); decoder.setMaxListSize(headerSize(header) - 1); - final HPackException exception = Assertions.assertThrows( - HPackException.class, - () -> decoder.decodeHeaders(asByteBuffer(block))); + final HPackException exception = Assertions.assertThatThrownBy(() -> + decoder.decodeHeaders(asByteBuffer(block))) + .isInstanceOf(HPackException.class).asInstanceOf(InstanceOfAssertFactories.type(HPackException.class)).actual(); - Assertions.assertFalse(exception instanceof HeaderListConstraintException); - Assertions.assertEquals( - "Dynamic table size update must appear at the beginning of a header block", - exception.getMessage()); + Assertions.assertThat(exception instanceof HeaderListConstraintException).isFalse(); + Assertions.assertThat(exception.getMessage()).isEqualTo("Dynamic table size update must appear at the beginning of a header block"); } private static int headerSize(final Header header) { diff --git a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/hpack/TestHPackEncoder.java b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/hpack/TestHPackEncoder.java index 79983ede04..9524a02eab 100644 --- a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/hpack/TestHPackEncoder.java +++ b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/hpack/TestHPackEncoder.java @@ -26,14 +26,11 @@ */ package org.apache.hc.core5.http2.hpack; -import static org.junit.jupiter.api.Assertions.assertArrayEquals; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertNotEquals; - import java.nio.charset.StandardCharsets; import java.util.Arrays; import org.apache.hc.core5.util.ByteArrayBuffer; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class TestHPackEncoder { @@ -48,8 +45,8 @@ void testMultipleTableSizeUpdatesSignalMinimumFirstThenFinal() throws Exception encoder.setMaxTableSize(2048); // No local resize until the next header block is encoded. - assertEquals(4096, dynamicTable.getMaxSize()); - assertEquals(2048, encoder.getMaxTableSize()); + Assertions.assertThat(dynamicTable.getMaxSize()).isEqualTo(4096); + Assertions.assertThat(encoder.getMaxTableSize()).isEqualTo(2048); encoder.encodeHeader(dst, "x-test", "abc", false, false, false); @@ -57,13 +54,13 @@ void testMultipleTableSizeUpdatesSignalMinimumFirstThenFinal() throws Exception // 1024 => 0x3f 0xe1 0x07 // 2048 => 0x3f 0xe1 0x0f final byte[] actual = Arrays.copyOf(dst.array(), dst.length()); - assertArrayEquals(new byte[]{ + Assertions.assertThat(Arrays.copyOf(actual, 6)).containsExactly(new byte[]{ 0x3f, (byte) 0xe1, 0x07, 0x3f, (byte) 0xe1, 0x0f - }, Arrays.copyOf(actual, 6)); + }); // Local encoder state must also end at the final advertised size. - assertEquals(2048, dynamicTable.getMaxSize()); + Assertions.assertThat(dynamicTable.getMaxSize()).isEqualTo(2048); } @Test @@ -78,12 +75,12 @@ void testShrinkThenRestoreOriginalStillEmitsTwoUpdates() throws Exception { encoder.encodeHeader(dst, "x-test", "abc", false, false, false); final byte[] actual = Arrays.copyOf(dst.array(), dst.length()); - assertArrayEquals(new byte[]{ + Assertions.assertThat(Arrays.copyOf(actual, 6)).containsExactly(new byte[]{ 0x3f, (byte) 0xe1, 0x07, 0x3f, (byte) 0xe1, 0x1f - }, Arrays.copyOf(actual, 6)); + }); - assertEquals(4096, dynamicTable.getMaxSize()); + Assertions.assertThat(dynamicTable.getMaxSize()).isEqualTo(4096); } @Test @@ -98,12 +95,12 @@ void testTableSizeUpdateZeroThenRestore() throws Exception { encoder.encodeHeader(dst, "x-test", "abc", false, false, false); final byte[] actual = Arrays.copyOf(dst.array(), dst.length()); - assertArrayEquals(new byte[]{ + Assertions.assertThat(Arrays.copyOf(actual, 4)).containsExactly(new byte[]{ 0x20, 0x3f, (byte) 0xe1, 0x1f - }, Arrays.copyOf(actual, 4)); + }); - assertEquals(4096, dynamicTable.getMaxSize()); + Assertions.assertThat(dynamicTable.getMaxSize()).isEqualTo(4096); } @Test @@ -120,12 +117,12 @@ void testTableSizeUpdateIsNotRepeatedAcrossHeaderBlocks() throws Exception { encoder.encodeHeader(dst2, "x-b", "2", false, false, false); final byte[] first = Arrays.copyOf(dst1.array(), dst1.length()); - assertArrayEquals(new byte[]{ + Assertions.assertThat(Arrays.copyOf(first, 3)).containsExactly(new byte[]{ 0x3f, (byte) 0xe1, 0x07 - }, Arrays.copyOf(first, 3)); + }); final byte[] second = Arrays.copyOf(dst2.array(), dst2.length()); - assertNotEquals(0x20, second[0] & 0xe0); + Assertions.assertThat(second[0] & 0xe0).isNotEqualTo(0x20); } } \ No newline at end of file diff --git a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/hpack/TestHPackEncoderUtf8.java b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/hpack/TestHPackEncoderUtf8.java index 99b7d8fbed..0e4f8e1041 100644 --- a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/hpack/TestHPackEncoderUtf8.java +++ b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/hpack/TestHPackEncoderUtf8.java @@ -26,14 +26,13 @@ */ package org.apache.hc.core5.http2.hpack; -import static org.junit.jupiter.api.Assertions.assertEquals; - import java.nio.ByteBuffer; import java.nio.charset.StandardCharsets; import java.util.List; import org.apache.hc.core5.http.Header; import org.apache.hc.core5.util.ByteArrayBuffer; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class TestHPackEncoderUtf8 { @@ -54,10 +53,10 @@ void testLargeMultibyteHeaderValueRoundTrip() throws Exception { final ByteBuffer src = ByteBuffer.wrap(encoded.array(), 0, encoded.length()); final List
headers = decoder.decodeHeaders(src); - assertEquals(1, headers.size()); - assertEquals("x-test", headers.get(0).getName()); - assertEquals(value, headers.get(0).getValue()); - assertEquals(0, src.remaining()); + Assertions.assertThat(headers.size()).isEqualTo(1); + Assertions.assertThat(headers.get(0).getName()).isEqualTo("x-test"); + Assertions.assertThat(headers.get(0).getValue()).isEqualTo(value); + Assertions.assertThat(src.remaining()).isEqualTo(0); } } diff --git a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/hpack/TestHuffmanDecoder.java b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/hpack/TestHuffmanDecoder.java index f4ddecff63..3d95792f5b 100644 --- a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/hpack/TestHuffmanDecoder.java +++ b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/hpack/TestHuffmanDecoder.java @@ -31,7 +31,7 @@ import java.util.Random; import org.apache.hc.core5.util.ByteArrayBuffer; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class TestHuffmanDecoder { @@ -68,7 +68,8 @@ void testAppendsToExistingOutput() throws Exception { final ByteArrayBuffer output = new ByteArrayBuffer(2); output.append('x'); Huffman.DECODER.decode(output, ByteBuffer.wrap(hex("a8eb10649cbf"))); - Assertions.assertArrayEquals("xno-cache".getBytes(StandardCharsets.US_ASCII), output.toByteArray()); + Assertions.assertThat(output.toByteArray()) + .containsExactly("xno-cache".getBytes(StandardCharsets.US_ASCII)); } @Test @@ -76,15 +77,16 @@ void testGrowsSmallOutputBuffer() throws Exception { final byte[] input = createRepeated("aaaaaaaaaaaaaaaa", 512); final ByteArrayBuffer output = new ByteArrayBuffer(1); Huffman.DECODER.decode(output, ByteBuffer.wrap(encode(input))); - Assertions.assertArrayEquals(input, output.toByteArray()); + Assertions.assertThat(output.toByteArray()).containsExactly(input); } private static void assertDecoded(final String encoded, final String expected) throws Exception { - Assertions.assertArrayEquals(expected.getBytes(StandardCharsets.US_ASCII), decode(hex(encoded))); + Assertions.assertThat(decode(hex(encoded))) + .containsExactly(expected.getBytes(StandardCharsets.US_ASCII)); } private static void assertRoundTrip(final byte[] input) throws Exception { - Assertions.assertArrayEquals(input, decode(encode(input))); + Assertions.assertThat(decode(encode(input))).containsExactly(input); } private static byte[] encode(final byte[] input) { diff --git a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/hpack/TestHuffmanDecoderRfc7541.java b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/hpack/TestHuffmanDecoderRfc7541.java index 93f684901f..e277596c72 100644 --- a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/hpack/TestHuffmanDecoderRfc7541.java +++ b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/hpack/TestHuffmanDecoderRfc7541.java @@ -31,15 +31,19 @@ import java.util.Arrays; import org.apache.hc.core5.util.ByteArrayBuffer; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class TestHuffmanDecoderRfc7541 { @Test void testRejectsPaddingLongerThanSevenBits() { - Assertions.assertThrows(HPackException.class, () -> decode((byte) 0xff)); - Assertions.assertThrows(HPackException.class, () -> decode((byte) 0xff, (byte) 0xff)); + Assertions.assertThatThrownBy(() -> + decode((byte) 0xff)) + .isInstanceOf(HPackException.class); + Assertions.assertThatThrownBy(() -> + decode((byte) 0xff, (byte) 0xff)) + .isInstanceOf(HPackException.class); } @Test @@ -51,7 +55,8 @@ void testValidEncodedValueStillDecodes() throws Exception { final ByteArrayBuffer decoded = new ByteArrayBuffer(32); Huffman.DECODER.decode(decoded, ByteBuffer.wrap(encoded.array(), 0, encoded.length())); - Assertions.assertArrayEquals(input, Arrays.copyOf(decoded.array(), decoded.length())); + Assertions.assertThat(Arrays.copyOf(decoded.array(), decoded.length())) + .containsExactly(input); } private static void decode(final byte... encoded) throws HPackException { diff --git a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/hpack/TestInboundDynamicTable.java b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/hpack/TestInboundDynamicTable.java index 0eb5ae9c60..43adeb4efb 100644 --- a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/hpack/TestInboundDynamicTable.java +++ b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/hpack/TestInboundDynamicTable.java @@ -27,7 +27,7 @@ package org.apache.hc.core5.http2.hpack; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class TestInboundDynamicTable { @@ -36,16 +36,16 @@ class TestInboundDynamicTable { void testBasics() { final InboundDynamicTable table = new InboundDynamicTable(); - Assertions.assertEquals(Integer.MAX_VALUE, table.getMaxSize()); - Assertions.assertEquals(0, table.getCurrentSize()); + Assertions.assertThat(table.getMaxSize()).isEqualTo(Integer.MAX_VALUE); + Assertions.assertThat(table.getCurrentSize()).isEqualTo(0); final HPackHeader header1 = new HPackHeader("h", "1"); table.add(header1); - Assertions.assertEquals(1, table.dynamicLength()); - Assertions.assertEquals(61, table.staticLength()); - Assertions.assertEquals(62, table.length()); - Assertions.assertSame(header1, table.getHeader(62)); - Assertions.assertEquals(34, table.getCurrentSize()); + Assertions.assertThat(table.dynamicLength()).isEqualTo(1); + Assertions.assertThat(table.staticLength()).isEqualTo(61); + Assertions.assertThat(table.length()).isEqualTo(62); + Assertions.assertThat(table.getHeader(62)).isSameAs(header1); + Assertions.assertThat(table.getCurrentSize()).isEqualTo(34); } @Test @@ -56,14 +56,14 @@ void testEviction() { table.add(new HPackHeader("h", "1")); table.add(new HPackHeader("h", "2")); - Assertions.assertEquals(68, table.getCurrentSize()); + Assertions.assertThat(table.getCurrentSize()).isEqualTo(68); table.setMaxSize(256); - Assertions.assertEquals(68, table.getCurrentSize()); + Assertions.assertThat(table.getCurrentSize()).isEqualTo(68); table.setMaxSize(67); - Assertions.assertEquals(34, table.getCurrentSize()); + Assertions.assertThat(table.getCurrentSize()).isEqualTo(34); table.setMaxSize(10); - Assertions.assertEquals(0, table.getCurrentSize()); + Assertions.assertThat(table.getCurrentSize()).isEqualTo(0); } } diff --git a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/hpack/TestOutboundDynamicTable.java b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/hpack/TestOutboundDynamicTable.java index b60bcb13dc..0979395fed 100644 --- a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/hpack/TestOutboundDynamicTable.java +++ b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/hpack/TestOutboundDynamicTable.java @@ -27,7 +27,7 @@ package org.apache.hc.core5.http2.hpack; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class TestOutboundDynamicTable { @@ -36,16 +36,16 @@ class TestOutboundDynamicTable { void testBasics() { final OutboundDynamicTable table = new OutboundDynamicTable(); - Assertions.assertEquals(Integer.MAX_VALUE, table.getMaxSize()); - Assertions.assertEquals(0, table.getCurrentSize()); + Assertions.assertThat(table.getMaxSize()).isEqualTo(Integer.MAX_VALUE); + Assertions.assertThat(table.getCurrentSize()).isEqualTo(0); final HPackHeader header1 = new HPackHeader("h", "1"); table.add(header1); - Assertions.assertEquals(1, table.dynamicLength()); - Assertions.assertEquals(61, table.staticLength()); - Assertions.assertEquals(62, table.length()); - Assertions.assertSame(header1, table.getHeader(62)); - Assertions.assertEquals(34, table.getCurrentSize()); + Assertions.assertThat(table.dynamicLength()).isEqualTo(1); + Assertions.assertThat(table.staticLength()).isEqualTo(61); + Assertions.assertThat(table.length()).isEqualTo(62); + Assertions.assertThat(table.getHeader(62)).isSameAs(header1); + Assertions.assertThat(table.getCurrentSize()).isEqualTo(34); } @Test @@ -56,14 +56,14 @@ void testEviction() { table.add(new HPackHeader("h", "1")); table.add(new HPackHeader("h", "2")); - Assertions.assertEquals(68, table.getCurrentSize()); + Assertions.assertThat(table.getCurrentSize()).isEqualTo(68); table.setMaxSize(256); - Assertions.assertEquals(68, table.getCurrentSize()); + Assertions.assertThat(table.getCurrentSize()).isEqualTo(68); table.setMaxSize(67); - Assertions.assertEquals(34, table.getCurrentSize()); + Assertions.assertThat(table.getCurrentSize()).isEqualTo(34); table.setMaxSize(10); - Assertions.assertEquals(0, table.getCurrentSize()); + Assertions.assertThat(table.getCurrentSize()).isEqualTo(0); } } diff --git a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/TestDefaultH2RequestConverter.java b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/TestDefaultH2RequestConverter.java index 70d25751ad..97075889a2 100644 --- a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/TestDefaultH2RequestConverter.java +++ b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/TestDefaultH2RequestConverter.java @@ -38,7 +38,8 @@ import org.apache.hc.core5.http.message.BasicHeader; import org.apache.hc.core5.http.message.BasicHttpRequest; import org.apache.hc.core5.net.URIAuthority; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; +import org.assertj.core.api.InstanceOfAssertFactories; import org.junit.jupiter.api.Test; class TestDefaultH2RequestConverter { @@ -55,15 +56,15 @@ void testConvertFromFieldsBasic() throws Exception { final DefaultH2RequestConverter converter = new DefaultH2RequestConverter(); final HttpRequest request = converter.convert(headers); - Assertions.assertNotNull(request); - Assertions.assertEquals("GET", request.getMethod()); - Assertions.assertEquals("http", request.getScheme()); - Assertions.assertEquals(new URIAuthority("www.example.com"), request.getAuthority()); - Assertions.assertEquals("/", request.getPath()); + Assertions.assertThat(request).isNotNull(); + Assertions.assertThat(request.getMethod()).isEqualTo("GET"); + Assertions.assertThat(request.getScheme()).isEqualTo("http"); + Assertions.assertThat(request.getAuthority()).isEqualTo(new URIAuthority("www.example.com")); + Assertions.assertThat(request.getPath()).isEqualTo("/"); final Header[] allHeaders = request.getHeaders(); - Assertions.assertEquals(1, allHeaders.length); - Assertions.assertEquals("custom123", allHeaders[0].getName()); - Assertions.assertEquals("value", allHeaders[0].getValue()); + Assertions.assertThat(allHeaders.length).isEqualTo(1); + Assertions.assertThat(allHeaders[0].getName()).isEqualTo("custom123"); + Assertions.assertThat(allHeaders[0].getValue()).isEqualTo("value"); } @Test @@ -76,8 +77,9 @@ void testConvertFromFieldsUpperCaseHeaderName() { new BasicHeader("custom", "value")); final DefaultH2RequestConverter converter = new DefaultH2RequestConverter(); - Assertions.assertThrows(HttpException.class, () -> converter.convert(headers), - "Header name ':Path' is invalid (header name contains uppercase characters)"); + Assertions.assertThatThrownBy(() -> + converter.convert(headers)) + .withFailMessage("Header name ':Path' is invalid (header name contains uppercase characters)").isInstanceOf(HttpException.class); } @Test @@ -90,8 +92,9 @@ void testConvertFromFieldsPseudoHeaderSequence() { new BasicHeader(":path", "/")); final DefaultH2RequestConverter converter = new DefaultH2RequestConverter(); - Assertions.assertThrows(HttpException.class, () -> converter.convert(headers), - "Invalid sequence of headers (pseudo-headers must precede message headers)"); + Assertions.assertThatThrownBy(() -> + converter.convert(headers)) + .withFailMessage("Invalid sequence of headers (pseudo-headers must precede message headers)").isInstanceOf(HttpException.class); } @Test @@ -103,8 +106,9 @@ void testConvertFromFieldsMissingMethod() { new BasicHeader("custom", "value")); final DefaultH2RequestConverter converter = new DefaultH2RequestConverter(); - Assertions.assertThrows(HttpException.class, () -> converter.convert(headers), - "Mandatory request header ':method' not found"); + Assertions.assertThatThrownBy(() -> + converter.convert(headers)) + .withFailMessage("Mandatory request header ':method' not found").isInstanceOf(HttpException.class); } @Test @@ -116,8 +120,9 @@ void testConvertFromFieldsMissingScheme() { new BasicHeader("custom", "value")); final DefaultH2RequestConverter converter = new DefaultH2RequestConverter(); - Assertions.assertThrows(HttpException.class, () -> converter.convert(headers), - "Mandatory request header ':scheme' not found"); + Assertions.assertThatThrownBy(() -> + converter.convert(headers)) + .withFailMessage("Mandatory request header ':scheme' not found").isInstanceOf(HttpException.class); } @Test @@ -129,8 +134,9 @@ void testConvertFromFieldsMissingPath() { new BasicHeader("custom", "value")); final DefaultH2RequestConverter converter = new DefaultH2RequestConverter(); - Assertions.assertThrows(HttpException.class, () -> converter.convert(headers), - "Mandatory request header ':path' not found"); + Assertions.assertThatThrownBy(() -> + converter.convert(headers)) + .withFailMessage("Mandatory request header ':path' not found").isInstanceOf(HttpException.class); } @Test @@ -143,8 +149,9 @@ void testConvertFromFieldsUnknownPseudoHeader() { new BasicHeader(":custom", "value")); final DefaultH2RequestConverter converter = new DefaultH2RequestConverter(); - Assertions.assertThrows(HttpException.class, () -> converter.convert(headers), - "Unsupported request header ':custom'"); + Assertions.assertThatThrownBy(() -> + converter.convert(headers)) + .withFailMessage("Unsupported request header ':custom'").isInstanceOf(HttpException.class); } @Test @@ -158,8 +165,9 @@ void testConvertFromFieldsMultipleMethod() { new BasicHeader("custom", "value")); final DefaultH2RequestConverter converter = new DefaultH2RequestConverter(); - Assertions.assertThrows(HttpException.class, () -> converter.convert(headers), - "Multiple ':method' request headers are illegal"); + Assertions.assertThatThrownBy(() -> + converter.convert(headers)) + .withFailMessage("Multiple ':method' request headers are illegal").isInstanceOf(HttpException.class); } @Test @@ -173,8 +181,9 @@ void testConvertFromFieldsMultipleScheme() { new BasicHeader("custom", "value")); final DefaultH2RequestConverter converter = new DefaultH2RequestConverter(); - Assertions.assertThrows(HttpException.class, () -> converter.convert(headers), - "Multiple ':scheme' request headers are illegal"); + Assertions.assertThatThrownBy(() -> + converter.convert(headers)) + .withFailMessage("Multiple ':scheme' request headers are illegal").isInstanceOf(HttpException.class); } @Test @@ -188,8 +197,9 @@ void testConvertFromFieldsMultiplePath() { new BasicHeader("custom", "value")); final DefaultH2RequestConverter converter = new DefaultH2RequestConverter(); - Assertions.assertThrows(HttpException.class, () -> converter.convert(headers), - "Multiple ':path' request headers are illegal"); + Assertions.assertThatThrownBy(() -> + converter.convert(headers)) + .withFailMessage("Multiple ':path' request headers are illegal").isInstanceOf(HttpException.class); } @Test @@ -211,8 +221,9 @@ void testConvertFromFieldsConnectMissingAuthority() { new BasicHeader("custom", "value")); final DefaultH2RequestConverter converter = new DefaultH2RequestConverter(); - Assertions.assertThrows(HttpException.class, () -> converter.convert(headers), - "Header ':authority' is mandatory for CONNECT request"); + Assertions.assertThatThrownBy(() -> + converter.convert(headers)) + .withFailMessage("Header ':authority' is mandatory for CONNECT request").isInstanceOf(HttpException.class); } @Test @@ -224,8 +235,9 @@ void testConvertFromFieldsConnectPresentScheme() { new BasicHeader("custom", "value")); final DefaultH2RequestConverter converter = new DefaultH2RequestConverter(); - Assertions.assertThrows(HttpException.class, () -> converter.convert(headers), - "Header ':scheme' must not be set for CONNECT request"); + Assertions.assertThatThrownBy(() -> + converter.convert(headers)) + .withFailMessage("Header ':scheme' must not be set for CONNECT request").isInstanceOf(HttpException.class); } @Test @@ -237,8 +249,9 @@ void testConvertFromFieldsConnectPresentPath() { new BasicHeader("custom", "value")); final DefaultH2RequestConverter converter = new DefaultH2RequestConverter(); - Assertions.assertThrows(HttpException.class, () -> converter.convert(headers), - "Header ':path' must not be set for CONNECT request"); + Assertions.assertThatThrownBy(() -> + converter.convert(headers)) + .withFailMessage("Header ':path' must not be set for CONNECT request").isInstanceOf(HttpException.class); } @Test @@ -253,10 +266,10 @@ void testConvertFromFieldsExtendedConnect() throws Exception { final DefaultH2RequestConverter converter = new DefaultH2RequestConverter(); final HttpRequest request = converter.convert(headers); - Assertions.assertEquals("CONNECT", request.getMethod()); - Assertions.assertEquals("https", request.getScheme()); - Assertions.assertEquals("/chat", request.getPath()); - Assertions.assertEquals("websocket", request.getFirstHeader(":protocol").getValue()); + Assertions.assertThat(request.getMethod()).isEqualTo("CONNECT"); + Assertions.assertThat(request.getScheme()).isEqualTo("https"); + Assertions.assertThat(request.getPath()).isEqualTo("/chat"); + Assertions.assertThat(request.getFirstHeader(":protocol").getValue()).isEqualTo("websocket"); } @Test @@ -268,8 +281,9 @@ void testConvertFromFieldsExtendedConnectMissingScheme() { new BasicHeader(":path", "/chat")); final DefaultH2RequestConverter converter = new DefaultH2RequestConverter(); - Assertions.assertThrows(HttpException.class, () -> converter.convert(headers), - "Header ':scheme' is mandatory for extended CONNECT"); + Assertions.assertThatThrownBy(() -> + converter.convert(headers)) + .withFailMessage("Header ':scheme' is mandatory for extended CONNECT").isInstanceOf(HttpException.class); } @Test @@ -281,8 +295,9 @@ void testConvertFromFieldsExtendedConnectMissingPath() { new BasicHeader(":authority", "www.example.com")); final DefaultH2RequestConverter converter = new DefaultH2RequestConverter(); - Assertions.assertThrows(HttpException.class, () -> converter.convert(headers), - "Header ':path' is mandatory for extended CONNECT"); + Assertions.assertThatThrownBy(() -> + converter.convert(headers)) + .withFailMessage("Header ':path' is mandatory for extended CONNECT").isInstanceOf(HttpException.class); } @Test @@ -295,8 +310,9 @@ void testConvertFromFieldsProtocolWithNonConnect() { new BasicHeader(":path", "/")); final DefaultH2RequestConverter converter = new DefaultH2RequestConverter(); - Assertions.assertThrows(HttpException.class, () -> converter.convert(headers), - "Header ':protocol' must not be set for GET request"); + Assertions.assertThatThrownBy(() -> + converter.convert(headers)) + .withFailMessage("Header ':protocol' must not be set for GET request").isInstanceOf(HttpException.class); } @Test @@ -308,23 +324,23 @@ void testConvertFromMessageBasic() throws Exception { final DefaultH2RequestConverter converter = new DefaultH2RequestConverter(); final List
headers = converter.convert(request); - Assertions.assertNotNull(headers); - Assertions.assertEquals(5, headers.size()); + Assertions.assertThat(headers).isNotNull(); + Assertions.assertThat(headers.size()).isEqualTo(5); final Header header1 = headers.get(0); - Assertions.assertEquals(":method", header1.getName()); - Assertions.assertEquals("GET", header1.getValue()); + Assertions.assertThat(header1.getName()).isEqualTo(":method"); + Assertions.assertThat(header1.getValue()).isEqualTo("GET"); final Header header2 = headers.get(1); - Assertions.assertEquals(":scheme", header2.getName()); - Assertions.assertEquals("http", header2.getValue()); + Assertions.assertThat(header2.getName()).isEqualTo(":scheme"); + Assertions.assertThat(header2.getValue()).isEqualTo("http"); final Header header3 = headers.get(2); - Assertions.assertEquals(":authority", header3.getName()); - Assertions.assertEquals("host", header3.getValue()); + Assertions.assertThat(header3.getName()).isEqualTo(":authority"); + Assertions.assertThat(header3.getValue()).isEqualTo("host"); final Header header4 = headers.get(3); - Assertions.assertEquals(":path", header4.getName()); - Assertions.assertEquals("/", header4.getValue()); + Assertions.assertThat(header4.getName()).isEqualTo(":path"); + Assertions.assertThat(header4.getValue()).isEqualTo("/"); final Header header5 = headers.get(4); - Assertions.assertEquals("custom123", header5.getName()); - Assertions.assertEquals("Value", header5.getValue()); + Assertions.assertThat(header5.getName()).isEqualTo("custom123"); + Assertions.assertThat(header5.getValue()).isEqualTo("Value"); } @Test @@ -334,7 +350,9 @@ void testConvertFromMessageMissingScheme() { request.setScheme(null); final DefaultH2RequestConverter converter = new DefaultH2RequestConverter(); - Assertions.assertThrows(HttpException.class, () -> converter.convert(request), "Request scheme is not set"); + Assertions.assertThatThrownBy(() -> + converter.convert(request)) + .withFailMessage("Request scheme is not set").isInstanceOf(HttpException.class); } @Test @@ -344,7 +362,9 @@ void testConvertFromMessageMissingPath() { request.setPath(null); final DefaultH2RequestConverter converter = new DefaultH2RequestConverter(); - Assertions.assertThrows(HttpException.class, () -> converter.convert(request), "Request path is not set"); + Assertions.assertThatThrownBy(() -> + converter.convert(request)) + .withFailMessage("Request path is not set").isInstanceOf(HttpException.class); } @Test @@ -356,17 +376,17 @@ void testConvertFromMessageConnect() throws Exception { final DefaultH2RequestConverter converter = new DefaultH2RequestConverter(); final List
headers = converter.convert(request); - Assertions.assertNotNull(headers); - Assertions.assertEquals(3, headers.size()); + Assertions.assertThat(headers).isNotNull(); + Assertions.assertThat(headers.size()).isEqualTo(3); final Header header1 = headers.get(0); - Assertions.assertEquals(":method", header1.getName()); - Assertions.assertEquals("CONNECT", header1.getValue()); + Assertions.assertThat(header1.getName()).isEqualTo(":method"); + Assertions.assertThat(header1.getValue()).isEqualTo("CONNECT"); final Header header2 = headers.get(1); - Assertions.assertEquals(":authority", header2.getName()); - Assertions.assertEquals("host:80", header2.getValue()); + Assertions.assertThat(header2.getName()).isEqualTo(":authority"); + Assertions.assertThat(header2.getValue()).isEqualTo("host:80"); final Header header3 = headers.get(2); - Assertions.assertEquals("custom123", header3.getName()); - Assertions.assertEquals("Value", header3.getValue()); + Assertions.assertThat(header3.getName()).isEqualTo("custom123"); + Assertions.assertThat(header3.getValue()).isEqualTo("Value"); } @Test @@ -375,8 +395,9 @@ void testConvertFromMessageConnectMissingAuthority() { request.addHeader("Custom123", "Value"); final DefaultH2RequestConverter converter = new DefaultH2RequestConverter(); - Assertions.assertThrows(HttpException.class, () -> converter.convert(request), - "CONNECT request authority is not set"); + Assertions.assertThatThrownBy(() -> + converter.convert(request)) + .withFailMessage("CONNECT request authority is not set").isInstanceOf(HttpException.class); } @Test @@ -386,8 +407,9 @@ void testConvertFromMessageConnectWithPath() { request.addHeader("Custom123", "Value"); final DefaultH2RequestConverter converter = new DefaultH2RequestConverter(); - Assertions.assertThrows(HttpException.class, () -> converter.convert(request), - "CONNECT request path must be null"); + Assertions.assertThatThrownBy(() -> + converter.convert(request)) + .withFailMessage("CONNECT request path must be null").isInstanceOf(HttpException.class); } @Test @@ -400,7 +422,7 @@ void testConvertFromMessageExtendedConnect() throws Exception { final DefaultH2RequestConverter converter = new DefaultH2RequestConverter(); final List
headers = converter.convert(request); - Assertions.assertTrue(headers.stream().anyMatch(h -> ":protocol".equals(h.getName()))); + Assertions.assertThat(headers.stream().anyMatch(h -> ":protocol".equals(h.getName()))).isTrue(); } @Test @@ -411,8 +433,9 @@ void testConvertFromMessageExtendedConnectMissingScheme() { request.addHeader(":protocol", "websocket"); final DefaultH2RequestConverter converter = new DefaultH2RequestConverter(); - Assertions.assertThrows(HttpException.class, () -> converter.convert(request), - "CONNECT request scheme is not set"); + Assertions.assertThatThrownBy(() -> + converter.convert(request)) + .withFailMessage("CONNECT request scheme is not set").isInstanceOf(HttpException.class); } @Test @@ -423,8 +446,9 @@ void testConvertFromMessageExtendedConnectMissingPath() { request.addHeader(":protocol", "websocket"); final DefaultH2RequestConverter converter = new DefaultH2RequestConverter(); - Assertions.assertThrows(HttpException.class, () -> converter.convert(request), - "CONNECT request path is not set"); + Assertions.assertThatThrownBy(() -> + converter.convert(request)) + .withFailMessage("CONNECT request path is not set").isInstanceOf(HttpException.class); } @Test @@ -433,8 +457,9 @@ void testConvertFromMessageProtocolWithNonConnect() { request.addHeader(":protocol", "websocket"); final DefaultH2RequestConverter converter = new DefaultH2RequestConverter(); - Assertions.assertThrows(HttpException.class, () -> converter.convert(request), - "Header name ':protocol' is invalid"); + Assertions.assertThatThrownBy(() -> + converter.convert(request)) + .withFailMessage("Header name ':protocol' is invalid").isInstanceOf(HttpException.class); } @Test @@ -449,15 +474,15 @@ void testConvertFromFieldsTETrailerHeader() throws Exception { final DefaultH2RequestConverter converter = new DefaultH2RequestConverter(); final HttpRequest request = converter.convert(headers); - Assertions.assertNotNull(request); - Assertions.assertEquals("GET", request.getMethod()); - Assertions.assertEquals("http", request.getScheme()); - Assertions.assertEquals(new URIAuthority("www.example.com"), request.getAuthority()); - Assertions.assertEquals("/", request.getPath()); + Assertions.assertThat(request).isNotNull(); + Assertions.assertThat(request.getMethod()).isEqualTo("GET"); + Assertions.assertThat(request.getScheme()).isEqualTo("http"); + Assertions.assertThat(request.getAuthority()).isEqualTo(new URIAuthority("www.example.com")); + Assertions.assertThat(request.getPath()).isEqualTo("/"); final Header[] allHeaders = request.getHeaders(); - Assertions.assertEquals(1, allHeaders.length); - Assertions.assertEquals("te", allHeaders[0].getName()); - Assertions.assertEquals("trailers", allHeaders[0].getValue()); + Assertions.assertThat(allHeaders.length).isEqualTo(1); + Assertions.assertThat(allHeaders[0].getName()).isEqualTo("te"); + Assertions.assertThat(allHeaders[0].getValue()).isEqualTo("trailers"); } @Test @@ -466,8 +491,9 @@ void testConvertFromMessageInvalidHeader() { request.addHeader(":custom", "stuff"); final DefaultH2RequestConverter converter = new DefaultH2RequestConverter(); - Assertions.assertThrows(HttpException.class, () -> converter.convert(request), - "Header name ':custom' is invalid"); + Assertions.assertThatThrownBy(() -> + converter.convert(request)) + .withFailMessage("Header name ':custom' is invalid").isInstanceOf(HttpException.class); } @@ -484,8 +510,8 @@ void testValidPath() throws Exception { final DefaultH2RequestConverter converter = new DefaultH2RequestConverter(); final HttpRequest request = converter.convert(headers); - Assertions.assertNotNull(request); - Assertions.assertEquals("/", request.getPath()); + Assertions.assertThat(request).isNotNull(); + Assertions.assertThat(request.getPath()).isEqualTo("/"); } @@ -500,7 +526,9 @@ void testInvalidPathEmpty() { ); final DefaultH2RequestConverter converter = new DefaultH2RequestConverter(); - Assertions.assertThrows(ProtocolException.class, () -> converter.convert(headers)); + Assertions.assertThatThrownBy(() -> + converter.convert(headers)) + .isInstanceOf(ProtocolException.class); } @Test @@ -514,7 +542,9 @@ void testInvalidPathNoSlash() { ); final DefaultH2RequestConverter converter = new DefaultH2RequestConverter(); - Assertions.assertThrows(ProtocolException.class, () -> converter.convert(headers)); + Assertions.assertThatThrownBy(() -> + converter.convert(headers)) + .isInstanceOf(ProtocolException.class); } @Test @@ -529,8 +559,8 @@ void testValidOptionsAsterisk() throws Exception { final DefaultH2RequestConverter converter = new DefaultH2RequestConverter(); final HttpRequest request = converter.convert(headers); - Assertions.assertNotNull(request); - Assertions.assertEquals("*", request.getPath()); + Assertions.assertThat(request).isNotNull(); + Assertions.assertThat(request.getPath()).isEqualTo("*"); } @Test @@ -545,8 +575,8 @@ void testValidOptionsWithRootPath() throws HttpException { final DefaultH2RequestConverter converter = new DefaultH2RequestConverter(); final HttpRequest request = converter.convert(headers); - Assertions.assertNotNull(request); - Assertions.assertEquals("/", request.getPath()); + Assertions.assertThat(request).isNotNull(); + Assertions.assertThat(request.getPath()).isEqualTo("/"); } @Test @@ -560,7 +590,9 @@ void testInvalidOptionsNeitherAsteriskNorRoot() { ); final DefaultH2RequestConverter converter = new DefaultH2RequestConverter(); - Assertions.assertThrows(ProtocolException.class, () -> converter.convert(headers)); + Assertions.assertThatThrownBy(() -> + converter.convert(headers)) + .isInstanceOf(ProtocolException.class); } @Test @@ -574,13 +606,11 @@ void testConvertFromFieldsMultipleAuthority() { final DefaultH2RequestConverter converter = new DefaultH2RequestConverter(); - final ProtocolException ex = Assertions.assertThrows( - ProtocolException.class, - () -> converter.convert(headers)); + final ProtocolException ex = Assertions.assertThatThrownBy(() -> + converter.convert(headers)) + .isInstanceOf(ProtocolException.class).asInstanceOf(InstanceOfAssertFactories.type(ProtocolException.class)).actual(); - Assertions.assertTrue( - ex.getMessage().contains("Multiple ':authority' request headers are illegal"), - ex::getMessage); + Assertions.assertThat(ex.getMessage().contains("Multiple ':authority' request headers are illegal")).withFailMessage(ex::getMessage).isTrue(); } diff --git a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/TestDefaultH2ResponseConverter.java b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/TestDefaultH2ResponseConverter.java index 08c7bdb38c..5294c34ccc 100644 --- a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/TestDefaultH2ResponseConverter.java +++ b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/TestDefaultH2ResponseConverter.java @@ -36,7 +36,7 @@ import org.apache.hc.core5.http.HttpResponse; import org.apache.hc.core5.http.message.BasicHeader; import org.apache.hc.core5.http.message.BasicHttpResponse; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class TestDefaultH2ResponseConverter { @@ -51,14 +51,14 @@ void testConvertFromFieldsBasic() throws Exception { final DefaultH2ResponseConverter converter = new DefaultH2ResponseConverter(); final HttpResponse response = converter.convert(headers); - Assertions.assertNotNull(response ); - Assertions.assertEquals(200, response .getCode()); + Assertions.assertThat(response).isNotNull(); + Assertions.assertThat(response.getCode()).isEqualTo(200); final Header[] allHeaders = response.getHeaders(); - Assertions.assertEquals(2, allHeaders.length); - Assertions.assertEquals("location", allHeaders[0].getName()); - Assertions.assertEquals("http://www.example.com/", allHeaders[0].getValue()); - Assertions.assertEquals("custom123", allHeaders[1].getName()); - Assertions.assertEquals("value", allHeaders[1].getValue()); + Assertions.assertThat(allHeaders.length).isEqualTo(2); + Assertions.assertThat(allHeaders[0].getName()).isEqualTo("location"); + Assertions.assertThat(allHeaders[0].getValue()).isEqualTo("http://www.example.com/"); + Assertions.assertThat(allHeaders[1].getName()).isEqualTo("custom123"); + Assertions.assertThat(allHeaders[1].getValue()).isEqualTo("value"); } @Test @@ -69,8 +69,9 @@ void testConvertFromFieldsUpperCaseHeaderName() { new BasicHeader("custom123", "value")); final DefaultH2ResponseConverter converter = new DefaultH2ResponseConverter(); - Assertions.assertThrows(HttpException.class, () -> converter.convert(headers), - "Header name ':Status' is invalid (header name contains uppercase characters)"); + Assertions.assertThatThrownBy(() -> + converter.convert(headers)) + .withFailMessage("Header name ':Status' is invalid (header name contains uppercase characters)").isInstanceOf(HttpException.class); } @Test @@ -81,7 +82,9 @@ void testConvertFromFieldsInvalidStatusCode() { new BasicHeader("custom123", "value")); final DefaultH2ResponseConverter converter = new DefaultH2ResponseConverter(); - Assertions.assertThrows(HttpException.class, () -> converter.convert(headers)); + Assertions.assertThatThrownBy(() -> + converter.convert(headers)) + .isInstanceOf(HttpException.class); } @Test @@ -91,8 +94,9 @@ void testConvertFromFieldsMissingStatus() { new BasicHeader("custom", "value")); final DefaultH2ResponseConverter converter = new DefaultH2ResponseConverter(); - Assertions.assertThrows(HttpException.class, () -> converter.convert(headers), - "Mandatory response header ':status' not found"); + Assertions.assertThatThrownBy(() -> + converter.convert(headers)) + .withFailMessage("Mandatory response header ':status' not found").isInstanceOf(HttpException.class); } @Test @@ -104,8 +108,9 @@ void testConvertFromFieldsUnknownPseudoHeader() { new BasicHeader("custom1", "value")); final DefaultH2ResponseConverter converter = new DefaultH2ResponseConverter(); - Assertions.assertThrows(HttpException.class, () -> converter.convert(headers), - "Unsupported response header ':custom'"); + Assertions.assertThatThrownBy(() -> + converter.convert(headers)) + .withFailMessage("Unsupported response header ':custom'").isInstanceOf(HttpException.class); } @Test @@ -117,8 +122,9 @@ void testConvertFromFieldsMultipleStatus() { new BasicHeader("custom1", "value")); final DefaultH2ResponseConverter converter = new DefaultH2ResponseConverter(); - Assertions.assertThrows(HttpException.class, () -> converter.convert(headers), - "Multiple ':status' response headers are illegal"); + Assertions.assertThatThrownBy(() -> + converter.convert(headers)) + .withFailMessage("Multiple ':status' response headers are illegal").isInstanceOf(HttpException.class); } @Test @@ -130,14 +136,14 @@ void testConvertFromMessageBasic() throws Exception { final DefaultH2ResponseConverter converter = new DefaultH2ResponseConverter(); final List
headers = converter.convert(response); - Assertions.assertNotNull(headers); - Assertions.assertEquals(2, headers.size()); + Assertions.assertThat(headers).isNotNull(); + Assertions.assertThat(headers.size()).isEqualTo(2); final Header header1 = headers.get(0); - Assertions.assertEquals(":status", header1.getName()); - Assertions.assertEquals("200", header1.getValue()); + Assertions.assertThat(header1.getName()).isEqualTo(":status"); + Assertions.assertThat(header1.getValue()).isEqualTo("200"); final Header header2 = headers.get(1); - Assertions.assertEquals("custom123", header2.getName()); - Assertions.assertEquals("Value", header2.getValue()); + Assertions.assertThat(header2.getName()).isEqualTo("custom123"); + Assertions.assertThat(header2.getValue()).isEqualTo("Value"); } @Test @@ -146,8 +152,9 @@ void testConvertFromMessageInvalidStatus() { response.addHeader("Custom123", "Value"); final DefaultH2ResponseConverter converter = new DefaultH2ResponseConverter(); - Assertions.assertThrows(HttpException.class, () -> converter.convert(response), - "Response status 99 is invalid"); + Assertions.assertThatThrownBy(() -> + converter.convert(response)) + .withFailMessage("Response status 99 is invalid").isInstanceOf(HttpException.class); } @Test @@ -156,8 +163,9 @@ void testConvertFromMessageInvalidHeader() { response.addHeader(":custom", "stuff"); final DefaultH2ResponseConverter converter = new DefaultH2ResponseConverter(); - Assertions.assertThrows(HttpException.class, () -> converter.convert(response), - "Header name ':custom' is invalid"); + Assertions.assertThatThrownBy(() -> + converter.convert(response)) + .withFailMessage("Header name ':custom' is invalid").isInstanceOf(HttpException.class); } @Test @@ -171,14 +179,14 @@ void testConvertFromFieldsMultipleCookies() throws Exception { final DefaultH2ResponseConverter converter = new DefaultH2ResponseConverter(); final HttpResponse response = converter.convert(headers); - Assertions.assertNotNull(response ); - Assertions.assertEquals(200, response .getCode()); + Assertions.assertThat(response).isNotNull(); + Assertions.assertThat(response.getCode()).isEqualTo(200); final Header[] allHeaders = response.getHeaders(); - Assertions.assertEquals(2, allHeaders.length); - Assertions.assertEquals("location", allHeaders[0].getName()); - Assertions.assertEquals("http://www.example.com/", allHeaders[0].getValue()); - Assertions.assertEquals("cookie", allHeaders[1].getName()); - Assertions.assertEquals("a=b; c=d; e=f", allHeaders[1].getValue()); + Assertions.assertThat(allHeaders.length).isEqualTo(2); + Assertions.assertThat(allHeaders[0].getName()).isEqualTo("location"); + Assertions.assertThat(allHeaders[0].getValue()).isEqualTo("http://www.example.com/"); + Assertions.assertThat(allHeaders[1].getName()).isEqualTo("cookie"); + Assertions.assertThat(allHeaders[1].getValue()).isEqualTo("a=b; c=d; e=f"); } @Test @@ -186,20 +194,26 @@ void testConvertFromFieldsStatusCodeMustBeStrictThreeDigit() { final DefaultH2ResponseConverter converter = new DefaultH2ResponseConverter(); // Demonstrate why Integer.parseInt(...) is insufficient (it accepts non-3-digit formats). - final int parsedPlus = Assertions.assertDoesNotThrow(() -> Integer.parseInt("+200")); - Assertions.assertEquals(200, parsedPlus); + final int parsedPlus = Integer.parseInt("+200"); + Assertions.assertThat(parsedPlus).isEqualTo(200); - final int parsedLeadingZero = Assertions.assertDoesNotThrow(() -> Integer.parseInt("0200")); - Assertions.assertEquals(200, parsedLeadingZero); + final int parsedLeadingZero = Integer.parseInt("0200"); + Assertions.assertThat(parsedLeadingZero).isEqualTo(200); // Converter must be strict: :status is exactly 3 digits, in range 100..599. - Assertions.assertThrows(HttpException.class, - () -> converter.convert(Collections.singletonList(new BasicHeader(":status", "+200")))); - Assertions.assertThrows(HttpException.class, () -> converter.convert(Collections.singletonList(new BasicHeader(":status", "0200")))); - - Assertions.assertThrows(HttpException.class, () -> converter.convert(Collections.singletonList(new BasicHeader(":status", "099")))); - Assertions.assertThrows(HttpException.class, () -> converter.convert(Collections.singletonList(new BasicHeader(":status", "600")))); + Assertions.assertThatThrownBy(() -> + converter.convert(Collections.singletonList(new BasicHeader(":status", "+200")))) + .isInstanceOf(HttpException.class); + Assertions.assertThatThrownBy(() -> + converter.convert(Collections.singletonList(new BasicHeader(":status", "0200")))) + .isInstanceOf(HttpException.class); + + Assertions.assertThatThrownBy(() -> + converter.convert(Collections.singletonList(new BasicHeader(":status", "099")))) + .isInstanceOf(HttpException.class); + Assertions.assertThatThrownBy(() -> + converter.convert(Collections.singletonList(new BasicHeader(":status", "600")))) + .isInstanceOf(HttpException.class); } } - diff --git a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/TestExtendedConnectRequestConverter.java b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/TestExtendedConnectRequestConverter.java index f46338597d..e941c80cfb 100644 --- a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/TestExtendedConnectRequestConverter.java +++ b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/TestExtendedConnectRequestConverter.java @@ -26,10 +26,6 @@ */ package org.apache.hc.core5.http2.impl; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static org.junit.jupiter.api.Assertions.assertTrue; - import java.util.ArrayList; import java.util.List; @@ -39,6 +35,7 @@ import org.apache.hc.core5.http.message.BasicHeader; import org.apache.hc.core5.http2.H2PseudoRequestHeaders; import org.apache.hc.core5.net.URIAuthority; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class TestExtendedConnectRequestConverter { @@ -54,10 +51,10 @@ void parsesExtendedConnect() throws Exception { final DefaultH2RequestConverter converter = new DefaultH2RequestConverter(); final HttpRequest request = converter.convert(headers); - assertNotNull(request); - assertEquals(Method.CONNECT.name(), request.getMethod()); - assertEquals("/echo", request.getPath()); - assertEquals("websocket", request.getFirstHeader(H2PseudoRequestHeaders.PROTOCOL).getValue()); + Assertions.assertThat(request).isNotNull(); + Assertions.assertThat(request.getMethod()).isEqualTo(Method.CONNECT.name()); + Assertions.assertThat(request.getPath()).isEqualTo("/echo"); + Assertions.assertThat(request.getFirstHeader(H2PseudoRequestHeaders.PROTOCOL).getValue()).isEqualTo("websocket"); } @Test @@ -76,6 +73,6 @@ void emitsProtocolPseudoHeader() throws Exception { break; } } - assertTrue(found); + Assertions.assertThat(found).isTrue(); } } diff --git a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/TestFieldValidationSupport.java b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/TestFieldValidationSupport.java index e4f455809b..d8bfcff6bd 100644 --- a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/TestFieldValidationSupport.java +++ b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/TestFieldValidationSupport.java @@ -27,72 +27,72 @@ package org.apache.hc.core5.http2.impl; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class TestFieldValidationSupport { @Test void testNameCharValid() throws Exception { - Assertions.assertFalse(FieldValidationSupport.isNameCharValid(' ')); - Assertions.assertTrue(FieldValidationSupport.isNameCharValid('a')); - Assertions.assertTrue(FieldValidationSupport.isNameCharValid('A')); - Assertions.assertTrue(FieldValidationSupport.isNameCharValid('0')); - Assertions.assertTrue(FieldValidationSupport.isNameCharValid('@')); - Assertions.assertFalse(FieldValidationSupport.isNameCharValid(':')); - Assertions.assertFalse(FieldValidationSupport.isNameCharValid('ä')); + Assertions.assertThat(FieldValidationSupport.isNameCharValid(' ')).isFalse(); + Assertions.assertThat(FieldValidationSupport.isNameCharValid('a')).isTrue(); + Assertions.assertThat(FieldValidationSupport.isNameCharValid('A')).isTrue(); + Assertions.assertThat(FieldValidationSupport.isNameCharValid('0')).isTrue(); + Assertions.assertThat(FieldValidationSupport.isNameCharValid('@')).isTrue(); + Assertions.assertThat(FieldValidationSupport.isNameCharValid(':')).isFalse(); + Assertions.assertThat(FieldValidationSupport.isNameCharValid('ä')).isFalse(); } @Test void testNameCharLowerCaseValid() throws Exception { - Assertions.assertFalse(FieldValidationSupport.isNameCharLowerCaseValid(' ')); - Assertions.assertTrue(FieldValidationSupport.isNameCharLowerCaseValid('a')); - Assertions.assertFalse(FieldValidationSupport.isNameCharLowerCaseValid('A')); - Assertions.assertTrue(FieldValidationSupport.isNameCharLowerCaseValid('0')); - Assertions.assertTrue(FieldValidationSupport.isNameCharLowerCaseValid('@')); - Assertions.assertFalse(FieldValidationSupport.isNameCharLowerCaseValid(':')); - Assertions.assertFalse(FieldValidationSupport.isNameCharLowerCaseValid('ä')); + Assertions.assertThat(FieldValidationSupport.isNameCharLowerCaseValid(' ')).isFalse(); + Assertions.assertThat(FieldValidationSupport.isNameCharLowerCaseValid('a')).isTrue(); + Assertions.assertThat(FieldValidationSupport.isNameCharLowerCaseValid('A')).isFalse(); + Assertions.assertThat(FieldValidationSupport.isNameCharLowerCaseValid('0')).isTrue(); + Assertions.assertThat(FieldValidationSupport.isNameCharLowerCaseValid('@')).isTrue(); + Assertions.assertThat(FieldValidationSupport.isNameCharLowerCaseValid(':')).isFalse(); + Assertions.assertThat(FieldValidationSupport.isNameCharLowerCaseValid('ä')).isFalse(); } @Test void testNameValid() throws Exception { - Assertions.assertTrue(FieldValidationSupport.isNameValid("ABCDEF0123456789")); - Assertions.assertFalse(FieldValidationSupport.isNameValid(":Blah")); - Assertions.assertFalse(FieldValidationSupport.isNameValid("Blah ")); - Assertions.assertFalse(FieldValidationSupport.isNameValid("Bläh")); + Assertions.assertThat(FieldValidationSupport.isNameValid("ABCDEF0123456789")).isTrue(); + Assertions.assertThat(FieldValidationSupport.isNameValid(":Blah")).isFalse(); + Assertions.assertThat(FieldValidationSupport.isNameValid("Blah ")).isFalse(); + Assertions.assertThat(FieldValidationSupport.isNameValid("Bläh")).isFalse(); } @Test void testNameLowerCaseValid() throws Exception { - Assertions.assertTrue(FieldValidationSupport.isNameValid("abcdef0123456789")); - Assertions.assertFalse(FieldValidationSupport.isNameValid(":blah")); - Assertions.assertFalse(FieldValidationSupport.isNameValid("blah ")); - Assertions.assertFalse(FieldValidationSupport.isNameValid("bläh")); + Assertions.assertThat(FieldValidationSupport.isNameValid("abcdef0123456789")).isTrue(); + Assertions.assertThat(FieldValidationSupport.isNameValid(":blah")).isFalse(); + Assertions.assertThat(FieldValidationSupport.isNameValid("blah ")).isFalse(); + Assertions.assertThat(FieldValidationSupport.isNameValid("bläh")).isFalse(); } @Test void testValueCharValid() throws Exception { - Assertions.assertTrue(FieldValidationSupport.isValueCharValid(' ')); - Assertions.assertTrue(FieldValidationSupport.isValueCharValid('a')); - Assertions.assertTrue(FieldValidationSupport.isValueCharValid('A')); - Assertions.assertTrue(FieldValidationSupport.isValueCharValid('0')); - Assertions.assertTrue(FieldValidationSupport.isValueCharValid('@')); - Assertions.assertTrue(FieldValidationSupport.isValueCharValid(':')); - Assertions.assertTrue(FieldValidationSupport.isValueCharValid('ä')); - Assertions.assertFalse(FieldValidationSupport.isValueCharValid((char) 0x00)); - Assertions.assertFalse(FieldValidationSupport.isValueCharValid('\n')); - Assertions.assertFalse(FieldValidationSupport.isValueCharValid('\r')); + Assertions.assertThat(FieldValidationSupport.isValueCharValid(' ')).isTrue(); + Assertions.assertThat(FieldValidationSupport.isValueCharValid('a')).isTrue(); + Assertions.assertThat(FieldValidationSupport.isValueCharValid('A')).isTrue(); + Assertions.assertThat(FieldValidationSupport.isValueCharValid('0')).isTrue(); + Assertions.assertThat(FieldValidationSupport.isValueCharValid('@')).isTrue(); + Assertions.assertThat(FieldValidationSupport.isValueCharValid(':')).isTrue(); + Assertions.assertThat(FieldValidationSupport.isValueCharValid('ä')).isTrue(); + Assertions.assertThat(FieldValidationSupport.isValueCharValid((char) 0x00)).isFalse(); + Assertions.assertThat(FieldValidationSupport.isValueCharValid('\n')).isFalse(); + Assertions.assertThat(FieldValidationSupport.isValueCharValid('\r')).isFalse(); } @Test void testValueValid() throws Exception { - Assertions.assertTrue(FieldValidationSupport.isValueValid("ABCDEF0123456789")); - Assertions.assertTrue(FieldValidationSupport.isValueValid(":Blah")); - Assertions.assertTrue(FieldValidationSupport.isValueValid("Bläh")); - Assertions.assertFalse(FieldValidationSupport.isValueValid(" Blah")); - Assertions.assertFalse(FieldValidationSupport.isValueValid("Blah\t")); - Assertions.assertFalse(FieldValidationSupport.isValueValid("Blah\nBlah")); - Assertions.assertFalse(FieldValidationSupport.isValueValid("\rBlah")); + Assertions.assertThat(FieldValidationSupport.isValueValid("ABCDEF0123456789")).isTrue(); + Assertions.assertThat(FieldValidationSupport.isValueValid(":Blah")).isTrue(); + Assertions.assertThat(FieldValidationSupport.isValueValid("Bläh")).isTrue(); + Assertions.assertThat(FieldValidationSupport.isValueValid(" Blah")).isFalse(); + Assertions.assertThat(FieldValidationSupport.isValueValid("Blah\t")).isFalse(); + Assertions.assertThat(FieldValidationSupport.isValueValid("Blah\nBlah")).isFalse(); + Assertions.assertThat(FieldValidationSupport.isValueValid("\rBlah")).isFalse(); } } diff --git a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/io/TestFrameInOutBuffers.java b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/io/TestFrameInOutBuffers.java index 4af0dc6b1e..34f78eabd3 100644 --- a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/io/TestFrameInOutBuffers.java +++ b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/io/TestFrameInOutBuffers.java @@ -40,7 +40,8 @@ import org.apache.hc.core5.http2.frame.FrameType; import org.apache.hc.core5.http2.frame.RawFrame; import org.apache.hc.core5.http2.impl.BasicH2TransportMetrics; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; +import org.assertj.core.api.InstanceOfAssertFactories; import org.junit.jupiter.api.Test; class TestFrameInOutBuffers { @@ -57,27 +58,27 @@ void testReadWriteFrame() throws Exception { final FrameInputBuffer inBuffer = new FrameInputBuffer(16 * 1024); final byte[] bytes = outputStream.toByteArray(); final ByteArrayInputStream inputStream = new ByteArrayInputStream(bytes); - Assertions.assertEquals(FrameConsts.HEAD_LEN + 5, bytes.length); + Assertions.assertThat(bytes.length).isEqualTo(FrameConsts.HEAD_LEN + 5); - Assertions.assertEquals(1, outbuffer.getMetrics().getFramesTransferred()); - Assertions.assertEquals(bytes.length, outbuffer.getMetrics().getBytesTransferred()); + Assertions.assertThat(outbuffer.getMetrics().getFramesTransferred()).isEqualTo(1); + Assertions.assertThat(outbuffer.getMetrics().getBytesTransferred()).isEqualTo(bytes.length); final RawFrame frame2 = inBuffer.read(inputStream); - Assertions.assertEquals(FrameType.DATA.getValue(), frame2.getType()); - Assertions.assertEquals(0, frame2.getFlags()); - Assertions.assertEquals(1L, frame2.getStreamId()); + Assertions.assertThat(frame2.getType()).isEqualTo(FrameType.DATA.getValue()); + Assertions.assertThat(frame2.getFlags()).isEqualTo(0); + Assertions.assertThat(frame2.getStreamId()).isEqualTo(1L); final ByteBuffer payload2 = frame2.getPayloadContent(); - Assertions.assertNotNull(payload2); - Assertions.assertEquals(5, payload2.remaining()); - Assertions.assertEquals(1, payload2.get()); - Assertions.assertEquals(2, payload2.get()); - Assertions.assertEquals(3, payload2.get()); - Assertions.assertEquals(4, payload2.get()); - Assertions.assertEquals(5, payload2.get()); - Assertions.assertEquals(-1, inputStream.read()); - - Assertions.assertEquals(1, inBuffer.getMetrics().getFramesTransferred()); - Assertions.assertEquals(bytes.length, inBuffer.getMetrics().getBytesTransferred()); + Assertions.assertThat(payload2).isNotNull(); + Assertions.assertThat(payload2.remaining()).isEqualTo(5); + Assertions.assertThat(payload2.get()).isEqualTo((byte) 1); + Assertions.assertThat(payload2.get()).isEqualTo((byte) 2); + Assertions.assertThat(payload2.get()).isEqualTo((byte) 3); + Assertions.assertThat(payload2.get()).isEqualTo((byte) 4); + Assertions.assertThat(payload2.get()).isEqualTo((byte) 5); + Assertions.assertThat(inputStream.read()).isEqualTo(-1); + + Assertions.assertThat(inBuffer.getMetrics().getFramesTransferred()).isEqualTo(1); + Assertions.assertThat(inBuffer.getMetrics().getBytesTransferred()).isEqualTo(bytes.length); } @Test @@ -90,32 +91,32 @@ void testReadFrameMultiple() throws Exception { }); final RawFrame frame1 = inBuffer.read(inputStream); - Assertions.assertEquals(FrameType.DATA, FrameType.valueOf(frame1.getType())); - Assertions.assertEquals(8, frame1.getFlags()); - Assertions.assertEquals(8, frame1.getStreamId()); + Assertions.assertThat(FrameType.valueOf(frame1.getType())).isEqualTo(FrameType.DATA); + Assertions.assertThat(frame1.getFlags()).isEqualTo(8); + Assertions.assertThat(frame1.getStreamId()).isEqualTo(8); final ByteBuffer payload1 = frame1.getPayloadContent(); - Assertions.assertNotNull(payload1); - Assertions.assertEquals(5, payload1.remaining()); - Assertions.assertEquals(0, payload1.get()); - Assertions.assertEquals(1, payload1.get()); - Assertions.assertEquals(2, payload1.get()); - Assertions.assertEquals(3, payload1.get()); - Assertions.assertEquals(4, payload1.get()); + Assertions.assertThat(payload1).isNotNull(); + Assertions.assertThat(payload1.remaining()).isEqualTo(5); + Assertions.assertThat(payload1.get()).isEqualTo((byte) 0); + Assertions.assertThat(payload1.get()).isEqualTo((byte) 1); + Assertions.assertThat(payload1.get()).isEqualTo((byte) 2); + Assertions.assertThat(payload1.get()).isEqualTo((byte) 3); + Assertions.assertThat(payload1.get()).isEqualTo((byte) 4); final RawFrame frame2 = inBuffer.read(inputStream); - Assertions.assertEquals(FrameType.DATA, FrameType.valueOf(frame2.getType())); - Assertions.assertEquals(FrameFlag.of(FrameFlag.END_STREAM, FrameFlag.PADDED), frame2.getFlags()); - Assertions.assertEquals(8, frame2.getStreamId()); + Assertions.assertThat(FrameType.valueOf(frame2.getType())).isEqualTo(FrameType.DATA); + Assertions.assertThat(frame2.getFlags()).isEqualTo(FrameFlag.of(FrameFlag.END_STREAM, FrameFlag.PADDED)); + Assertions.assertThat(frame2.getStreamId()).isEqualTo(8); final ByteBuffer payload2 = frame2.getPayloadContent(); - Assertions.assertNotNull(payload2); - Assertions.assertEquals(5, payload2.remaining()); - Assertions.assertEquals(5, payload2.get()); - Assertions.assertEquals(6, payload2.get()); - Assertions.assertEquals(7, payload2.get()); - Assertions.assertEquals(8, payload2.get()); - Assertions.assertEquals(9, payload2.get()); - - Assertions.assertEquals(-1, inputStream.read()); + Assertions.assertThat(payload2).isNotNull(); + Assertions.assertThat(payload2.remaining()).isEqualTo(5); + Assertions.assertThat(payload2.get()).isEqualTo((byte) 5); + Assertions.assertThat(payload2.get()).isEqualTo((byte) 6); + Assertions.assertThat(payload2.get()).isEqualTo((byte) 7); + Assertions.assertThat(payload2.get()).isEqualTo((byte) 8); + Assertions.assertThat(payload2.get()).isEqualTo((byte) 9); + + Assertions.assertThat(inputStream.read()).isEqualTo(-1); } @Test @@ -129,45 +130,45 @@ void testReadFrameMultipleSmallBuffer() throws Exception { }); final RawFrame frame1 = inBuffer.read(inputStream); - Assertions.assertEquals(FrameType.DATA, FrameType.valueOf(frame1.getType())); - Assertions.assertEquals(8, frame1.getFlags()); - Assertions.assertEquals(8, frame1.getStreamId()); + Assertions.assertThat(FrameType.valueOf(frame1.getType())).isEqualTo(FrameType.DATA); + Assertions.assertThat(frame1.getFlags()).isEqualTo(8); + Assertions.assertThat(frame1.getStreamId()).isEqualTo(8); final ByteBuffer payload1 = frame1.getPayloadContent(); - Assertions.assertNotNull(payload1); - Assertions.assertEquals(5, payload1.remaining()); - Assertions.assertEquals(1, payload1.get()); - Assertions.assertEquals(1, payload1.get()); - Assertions.assertEquals(1, payload1.get()); - Assertions.assertEquals(1, payload1.get()); - Assertions.assertEquals(1, payload1.get()); + Assertions.assertThat(payload1).isNotNull(); + Assertions.assertThat(payload1.remaining()).isEqualTo(5); + Assertions.assertThat(payload1.get()).isEqualTo((byte) 1); + Assertions.assertThat(payload1.get()).isEqualTo((byte) 1); + Assertions.assertThat(payload1.get()).isEqualTo((byte) 1); + Assertions.assertThat(payload1.get()).isEqualTo((byte) 1); + Assertions.assertThat(payload1.get()).isEqualTo((byte) 1); final RawFrame frame2 = inBuffer.read(inputStream); - Assertions.assertEquals(FrameType.DATA, FrameType.valueOf(frame2.getType())); - Assertions.assertEquals(0, frame2.getFlags()); - Assertions.assertEquals(8, frame2.getStreamId()); + Assertions.assertThat(FrameType.valueOf(frame2.getType())).isEqualTo(FrameType.DATA); + Assertions.assertThat(frame2.getFlags()).isEqualTo(0); + Assertions.assertThat(frame2.getStreamId()).isEqualTo(8); final ByteBuffer payload2 = frame2.getPayloadContent(); - Assertions.assertNotNull(payload2); - Assertions.assertEquals(5, payload2.remaining()); - Assertions.assertEquals(2, payload2.get()); - Assertions.assertEquals(2, payload2.get()); - Assertions.assertEquals(2, payload2.get()); - Assertions.assertEquals(2, payload2.get()); - Assertions.assertEquals(2, payload2.get()); + Assertions.assertThat(payload2).isNotNull(); + Assertions.assertThat(payload2.remaining()).isEqualTo(5); + Assertions.assertThat(payload2.get()).isEqualTo((byte) 2); + Assertions.assertThat(payload2.get()).isEqualTo((byte) 2); + Assertions.assertThat(payload2.get()).isEqualTo((byte) 2); + Assertions.assertThat(payload2.get()).isEqualTo((byte) 2); + Assertions.assertThat(payload2.get()).isEqualTo((byte) 2); final RawFrame frame3 = inBuffer.read(inputStream); - Assertions.assertEquals(FrameType.DATA, FrameType.valueOf(frame3.getType())); - Assertions.assertEquals(FrameFlag.of(FrameFlag.END_STREAM, FrameFlag.PADDED), frame3.getFlags()); - Assertions.assertEquals(8, frame3.getStreamId()); + Assertions.assertThat(FrameType.valueOf(frame3.getType())).isEqualTo(FrameType.DATA); + Assertions.assertThat(frame3.getFlags()).isEqualTo(FrameFlag.of(FrameFlag.END_STREAM, FrameFlag.PADDED)); + Assertions.assertThat(frame3.getStreamId()).isEqualTo(8); final ByteBuffer payload3 = frame3.getPayloadContent(); - Assertions.assertNotNull(payload3); - Assertions.assertEquals(5, payload3.remaining()); - Assertions.assertEquals(3, payload3.get()); - Assertions.assertEquals(3, payload3.get()); - Assertions.assertEquals(3, payload3.get()); - Assertions.assertEquals(3, payload3.get()); - Assertions.assertEquals(3, payload3.get()); - - Assertions.assertEquals(-1, inputStream.read()); + Assertions.assertThat(payload3).isNotNull(); + Assertions.assertThat(payload3.remaining()).isEqualTo(5); + Assertions.assertThat(payload3.get()).isEqualTo((byte) 3); + Assertions.assertThat(payload3.get()).isEqualTo((byte) 3); + Assertions.assertThat(payload3.get()).isEqualTo((byte) 3); + Assertions.assertThat(payload3.get()).isEqualTo((byte) 3); + Assertions.assertThat(payload3.get()).isEqualTo((byte) 3); + + Assertions.assertThat(inputStream.read()).isEqualTo(-1); } @Test @@ -183,18 +184,18 @@ void testReadFramePartialReads() throws Exception { new byte[] {0,0,0}); final RawFrame frame = inBuffer.read(inputStream); - Assertions.assertEquals(FrameType.DATA, FrameType.valueOf(frame.getType())); - Assertions.assertEquals(FrameFlag.of(FrameFlag.END_STREAM, FrameFlag.PADDED), frame.getFlags()); - Assertions.assertEquals(8, frame.getStreamId()); + Assertions.assertThat(FrameType.valueOf(frame.getType())).isEqualTo(FrameType.DATA); + Assertions.assertThat(frame.getFlags()).isEqualTo(FrameFlag.of(FrameFlag.END_STREAM, FrameFlag.PADDED)); + Assertions.assertThat(frame.getStreamId()).isEqualTo(8); final ByteBuffer payload = frame.getPayloadContent(); - Assertions.assertNotNull(payload); - Assertions.assertEquals(5, payload.remaining()); - Assertions.assertEquals(1, payload.get()); - Assertions.assertEquals(2, payload.get()); - Assertions.assertEquals(3, payload.get()); - Assertions.assertEquals(4, payload.get()); - Assertions.assertEquals(5, payload.get()); - Assertions.assertEquals(-1, inputStream.read()); + Assertions.assertThat(payload).isNotNull(); + Assertions.assertThat(payload.remaining()).isEqualTo(5); + Assertions.assertThat(payload.get()).isEqualTo((byte) 1); + Assertions.assertThat(payload.get()).isEqualTo((byte) 2); + Assertions.assertThat(payload.get()).isEqualTo((byte) 3); + Assertions.assertThat(payload.get()).isEqualTo((byte) 4); + Assertions.assertThat(payload.get()).isEqualTo((byte) 5); + Assertions.assertThat(inputStream.read()).isEqualTo(-1); } @Test @@ -203,11 +204,11 @@ void testReadEmptyFrame() throws Exception { final ByteArrayInputStream inputStream = new ByteArrayInputStream(new byte[] {0,0,0,0,0,0,0,0,0}); final RawFrame frame = inBuffer.read(inputStream); - Assertions.assertEquals(FrameType.DATA, FrameType.valueOf(frame.getType())); - Assertions.assertEquals(0, frame.getFlags()); - Assertions.assertEquals(0, frame.getStreamId()); + Assertions.assertThat(FrameType.valueOf(frame.getType())).isEqualTo(FrameType.DATA); + Assertions.assertThat(frame.getFlags()).isEqualTo(0); + Assertions.assertThat(frame.getStreamId()).isEqualTo(0); final ByteBuffer payload = frame.getPayloadContent(); - Assertions.assertNull(payload); + Assertions.assertThat(payload).isNull(); } @Test @@ -215,7 +216,9 @@ void testReadFrameConnectionClosed() { final FrameInputBuffer inBuffer = new FrameInputBuffer(16 * 1024); final ByteArrayInputStream inputStream = new ByteArrayInputStream(new byte[] {}); - Assertions.assertThrows(ConnectionClosedException.class, () -> inBuffer.read(inputStream)); + Assertions.assertThatThrownBy(() -> + inBuffer.read(inputStream)) + .isInstanceOf(ConnectionClosedException.class); } @Test @@ -223,7 +226,9 @@ void testReadFrameCorruptFrame() { final FrameInputBuffer inBuffer = new FrameInputBuffer(16 * 1024); final ByteArrayInputStream inputStream = new ByteArrayInputStream(new byte[] {0,0}); - Assertions.assertThrows(H2CorruptFrameException.class, () -> inBuffer.read(inputStream)); + Assertions.assertThatThrownBy(() -> + inBuffer.read(inputStream)) + .isInstanceOf(H2CorruptFrameException.class); } @Test @@ -233,7 +238,9 @@ void testWriteFrameExceedingLimit() { final RawFrame frame = new RawFrame(FrameType.DATA.getValue(), 0, 1, ByteBuffer.wrap(new byte[2048])); - Assertions.assertThrows(H2ConnectionException.class, () -> outbuffer.write(frame, outputStream)); + Assertions.assertThatThrownBy(() -> + outbuffer.write(frame, outputStream)) + .isInstanceOf(H2ConnectionException.class); } @Test @@ -242,7 +249,9 @@ void testReadFrameExceedingLimit() { final ByteArrayInputStream inputStream = new ByteArrayInputStream( new byte[] {0,-128,-128,0,0,0,0,0,1}); - Assertions.assertThrows(H2ConnectionException.class, () -> inBuffer.read(inputStream)); + Assertions.assertThatThrownBy(() -> + inBuffer.read(inputStream)) + .isInstanceOf(H2ConnectionException.class); } @Test @@ -254,14 +263,14 @@ void testPaddedBitOnUnknownFrameTypeIgnored() throws Exception { }); final RawFrame frame = inBuffer.read(inputStream); - Assertions.assertNotNull(frame); - Assertions.assertEquals(0x0a, frame.getType()); - Assertions.assertEquals(0x08, frame.getFlags()); - Assertions.assertEquals(1, frame.getStreamId()); - Assertions.assertEquals(1, frame.getLength()); - Assertions.assertNotNull(frame.getPayload()); - Assertions.assertEquals(1, frame.getPayload().remaining()); - Assertions.assertEquals(42, frame.getPayload().get() & 0xff); + Assertions.assertThat(frame).isNotNull(); + Assertions.assertThat(frame.getType()).isEqualTo(0x0a); + Assertions.assertThat(frame.getFlags()).isEqualTo(0x08); + Assertions.assertThat(frame.getStreamId()).isEqualTo(1); + Assertions.assertThat(frame.getLength()).isEqualTo(1); + Assertions.assertThat(frame.getPayload()).isNotNull(); + Assertions.assertThat(frame.getPayload().remaining()).isEqualTo(1); + Assertions.assertThat(frame.getPayload().get() & 0xff).isEqualTo(42); } @Test @@ -272,8 +281,10 @@ void testPaddedValidationAppliedForDataFrame() { 0, 0, 1, 0, 8, 0, 0, 0, 1, 42 // len=1,type=DATA(flags=0x08),stream=1,padLength=42 -> invalid }); - final H2ConnectionException ex = Assertions.assertThrows(H2ConnectionException.class, () -> inBuffer.read(inputStream)); - Assertions.assertEquals(H2Error.PROTOCOL_ERROR.getCode(), ex.getCode()); + final H2ConnectionException ex = Assertions.assertThatThrownBy(() -> + inBuffer.read(inputStream)) + .isInstanceOf(H2ConnectionException.class).asInstanceOf(InstanceOfAssertFactories.type(H2ConnectionException.class)).actual(); + Assertions.assertThat(ex.getCode()).isEqualTo(H2Error.PROTOCOL_ERROR.getCode()); } } diff --git a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/io/TestFrameInputBuffer.java b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/io/TestFrameInputBuffer.java index 2fe43f836c..3a9c52dbb3 100644 --- a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/io/TestFrameInputBuffer.java +++ b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/io/TestFrameInputBuffer.java @@ -26,11 +26,10 @@ */ package org.apache.hc.core5.http2.impl.io; -import static org.junit.jupiter.api.Assertions.assertEquals; - import java.io.ByteArrayInputStream; import org.apache.hc.core5.http2.frame.RawFrame; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class TestFrameInputBuffer { @@ -48,7 +47,7 @@ void reservedBitInStreamIdIsIgnored() throws Exception { final FrameInputBuffer inBuf = new FrameInputBuffer(16384); final RawFrame rawFrame = inBuf.read(new ByteArrayInputStream(frame)); - assertEquals(0x0A123456, rawFrame.getStreamId()); + Assertions.assertThat(rawFrame.getStreamId()).isEqualTo(0x0A123456); } } diff --git a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestAbstractH2StreamMultiplexer.java b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestAbstractH2StreamMultiplexer.java index 68f38b4f87..bb49b40338 100644 --- a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestAbstractH2StreamMultiplexer.java +++ b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestAbstractH2StreamMultiplexer.java @@ -73,7 +73,8 @@ import org.apache.hc.core5.reactor.ProtocolIOSession; import org.apache.hc.core5.util.ByteArrayBuffer; import org.apache.hc.core5.util.Timeout; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; +import org.assertj.core.api.InstanceOfAssertFactories; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; @@ -259,14 +260,14 @@ void testInputOneFrame() throws Exception { h2StreamListener, () -> streamHandler); - Assertions.assertThrows(H2ConnectionException.class, () -> - streamMultiplexer.onInput(ByteBuffer.wrap(bytes))); + Assertions.assertThatThrownBy(() -> + streamMultiplexer.onInput(ByteBuffer.wrap(bytes))).isInstanceOf(H2ConnectionException.class); Mockito.verify(h2StreamListener).onFrameInput( ArgumentMatchers.same(streamMultiplexer), ArgumentMatchers.eq(1), ArgumentMatchers.any()); - Assertions.assertThrows(H2ConnectionException.class, () -> { + Assertions.assertThatThrownBy(() -> { int pos = 0; int remaining = bytes.length; while (remaining > 0) { @@ -280,7 +281,7 @@ void testInputOneFrame() throws Exception { ArgumentMatchers.same(streamMultiplexer), ArgumentMatchers.eq(1), ArgumentMatchers.any()); - }); + }).isInstanceOf(H2ConnectionException.class); } @Test @@ -311,14 +312,14 @@ void testInputMultipleFrames() throws Exception { h2StreamListener, () -> streamHandler); - Assertions.assertThrows(H2ConnectionException.class, () -> - streamMultiplexer.onInput(ByteBuffer.wrap(bytes))); + Assertions.assertThatThrownBy(() -> + streamMultiplexer.onInput(ByteBuffer.wrap(bytes))).isInstanceOf(H2ConnectionException.class); Mockito.verify(h2StreamListener).onFrameInput( ArgumentMatchers.same(streamMultiplexer), ArgumentMatchers.eq(1), ArgumentMatchers.any()); - Assertions.assertThrows(H2ConnectionException.class, () -> { + Assertions.assertThatThrownBy(() -> { int pos = 0; int remaining = bytes.length; while (remaining > 0) { @@ -332,7 +333,7 @@ void testInputMultipleFrames() throws Exception { ArgumentMatchers.same(streamMultiplexer), ArgumentMatchers.eq(1), ArgumentMatchers.any()); - }); + }).isInstanceOf(H2ConnectionException.class); } @Test @@ -368,7 +369,7 @@ void testInputHeaderContinuationFrame() throws Exception { streamMultiplexer.onInput(ByteBuffer.wrap(bytes)); Mockito.verify(streamHandler).consumeHeader(headersCaptor.capture(), ArgumentMatchers.eq(false)); - Assertions.assertFalse(headersCaptor.getValue().isEmpty()); + Assertions.assertThat(headersCaptor.getValue().isEmpty()).isFalse(); } @Test @@ -406,7 +407,7 @@ void testZeroIncrement() throws Exception { streamMultiplexer.onInput(ByteBuffer.wrap(writableChannel.toByteArray())); Mockito.verify(streamHandler).consumeHeader(headersCaptor.capture(), ArgumentMatchers.eq(true)); - Assertions.assertFalse(headersCaptor.getValue().isEmpty()); + Assertions.assertThat(headersCaptor.getValue().isEmpty()).isFalse(); writableChannel.reset(); final ByteBuffer payload = ByteBuffer.allocate(4); @@ -415,8 +416,8 @@ void testZeroIncrement() throws Exception { final RawFrame incrementFrame = new RawFrame(FrameType.WINDOW_UPDATE.getValue(), 0, 1, payload); outBuffer.write(incrementFrame, writableChannel); - Assertions.assertDoesNotThrow(() -> - streamMultiplexer.onInput(ByteBuffer.wrap(writableChannel.toByteArray()))); + Assertions.assertThatCode(() -> + streamMultiplexer.onInput(ByteBuffer.wrap(writableChannel.toByteArray()))).doesNotThrowAnyException(); } @Test @@ -436,9 +437,10 @@ void testZeroIncrementConnectionWindowUpdate() throws Exception { payload.flip(); final RawFrame incrementFrame = new RawFrame(FrameType.WINDOW_UPDATE.getValue(), 0, 0, payload); - final H2ConnectionException exception = Assertions.assertThrows(H2ConnectionException.class, - () -> mux.onInput(ByteBuffer.wrap(encodeFrame(incrementFrame)))); - Assertions.assertEquals(H2Error.PROTOCOL_ERROR, H2Error.getByCode(exception.getCode())); + final H2ConnectionException exception = Assertions.assertThatThrownBy(() -> + mux.onInput(ByteBuffer.wrap(encodeFrame(incrementFrame)))) + .isInstanceOf(H2ConnectionException.class).asInstanceOf(InstanceOfAssertFactories.type(H2ConnectionException.class)).actual(); + Assertions.assertThat(H2Error.getByCode(exception.getCode())).isEqualTo(H2Error.PROTOCOL_ERROR); } finally { mux.close(); } @@ -462,9 +464,10 @@ void testInvalidInitialWindowSizeSettingIsFlowControlError() throws Exception { payload.flip(); final RawFrame settingsFrame = new RawFrame(FrameType.SETTINGS.getValue(), 0, 0, payload); - final H2ConnectionException exception = Assertions.assertThrows(H2ConnectionException.class, - () -> mux.onInput(ByteBuffer.wrap(encodeFrame(settingsFrame)))); - Assertions.assertEquals(H2Error.FLOW_CONTROL_ERROR, H2Error.getByCode(exception.getCode())); + final H2ConnectionException exception = Assertions.assertThatThrownBy(() -> + mux.onInput(ByteBuffer.wrap(encodeFrame(settingsFrame)))) + .isInstanceOf(H2ConnectionException.class).asInstanceOf(InstanceOfAssertFactories.type(H2ConnectionException.class)).actual(); + Assertions.assertThat(H2Error.getByCode(exception.getCode())).isEqualTo(H2Error.FLOW_CONTROL_ERROR); } finally { mux.close(); } @@ -505,7 +508,7 @@ void testIncrementOverflow() throws Exception { streamMultiplexer.onInput(ByteBuffer.wrap(writableChannel.toByteArray())); Mockito.verify(streamHandler).consumeHeader(headersCaptor.capture(), ArgumentMatchers.eq(true)); - Assertions.assertFalse(headersCaptor.getValue().isEmpty()); + Assertions.assertThat(headersCaptor.getValue().isEmpty()).isFalse(); writableChannel.reset(); final RawFrame incrementFrame1 = FRAME_FACTORY.createWindowUpdate(1, 100); @@ -516,13 +519,12 @@ void testIncrementOverflow() throws Exception { writableChannel.reset(); final RawFrame incrementFrame2 = FRAME_FACTORY.createWindowUpdate(1, 0x7fffffff - 50); outBuffer.write(incrementFrame2, writableChannel); - Assertions.assertDoesNotThrow(() -> - streamMultiplexer.onInput(ByteBuffer.wrap(writableChannel.toByteArray()))); + Assertions.assertThatCode(() -> + streamMultiplexer.onInput(ByteBuffer.wrap(writableChannel.toByteArray()))).doesNotThrowAnyException(); Mockito.verify(streamHandler).failed(exceptionCaptor.capture()); final Exception exception = exceptionCaptor.getValue(); - Assertions.assertInstanceOf(H2StreamResetException.class, exception); - Assertions.assertEquals(H2Error.FLOW_CONTROL_ERROR, - H2Error.getByCode(((H2StreamResetException) exception).getCode())); + Assertions.assertThat(exception).isInstanceOf(H2StreamResetException.class); + Assertions.assertThat(H2Error.getByCode(((H2StreamResetException) exception).getCode())).isEqualTo(H2Error.FLOW_CONTROL_ERROR); } @Test @@ -560,7 +562,7 @@ void testHeadersAfterEndOfStream() throws Exception { streamMultiplexer.onInput(ByteBuffer.wrap(writableChannel.toByteArray())); Mockito.verify(streamHandler).consumeHeader(headersCaptor.capture(), ArgumentMatchers.eq(true)); - Assertions.assertFalse(headersCaptor.getValue().isEmpty()); + Assertions.assertThat(headersCaptor.getValue().isEmpty()).isFalse(); writableChannel.reset(); final RawFrame headerFrame2 = FRAME_FACTORY.createHeaders(1, ByteBuffer.wrap(headerBuf.array(), 0, headerBuf.length()), true, true); @@ -569,16 +571,16 @@ void testHeadersAfterEndOfStream() throws Exception { // Treat the first occurrence as a stream error streamMultiplexer.onInput(ByteBuffer.wrap(writableChannel.toByteArray())); Mockito.verify(streamHandler).failed(exceptionCaptor.capture()); - Assertions.assertInstanceOf(H2StreamResetException.class, exceptionCaptor.getValue()); + Assertions.assertThat(exceptionCaptor.getValue()).isInstanceOf(H2StreamResetException.class); writableChannel.reset(); final RawFrame headerFrame3 = FRAME_FACTORY.createHeaders(1, ByteBuffer.wrap(headerBuf.array(), 0, headerBuf.length()), true, true); outBuffer.write(headerFrame3, writableChannel); // Treat subsequent occurrences as a connection-wide protocol error - final H2ConnectionException exception = Assertions.assertThrows(H2ConnectionException.class, () -> - streamMultiplexer.onInput(ByteBuffer.wrap(writableChannel.toByteArray()))); - Assertions.assertEquals(H2Error.STREAM_CLOSED, H2Error.getByCode(exception.getCode())); + final H2ConnectionException exception = Assertions.assertThatThrownBy(() -> + streamMultiplexer.onInput(ByteBuffer.wrap(writableChannel.toByteArray()))).isInstanceOf(H2ConnectionException.class).asInstanceOf(InstanceOfAssertFactories.type(H2ConnectionException.class)).actual(); + Assertions.assertThat(H2Error.getByCode(exception.getCode())).isEqualTo(H2Error.STREAM_CLOSED); } @Test @@ -616,7 +618,7 @@ void testDataAfterEndOfStream() throws Exception { streamMultiplexer.onInput(ByteBuffer.wrap(writableChannel.toByteArray())); Mockito.verify(streamHandler).consumeHeader(headersCaptor.capture(), ArgumentMatchers.eq(true)); - Assertions.assertFalse(headersCaptor.getValue().isEmpty()); + Assertions.assertThat(headersCaptor.getValue().isEmpty()).isFalse(); writableChannel.reset(); final RawFrame dataFrame1 = FRAME_FACTORY.createData(1, ByteBuffer.wrap(new byte[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 0}), true); @@ -625,16 +627,16 @@ void testDataAfterEndOfStream() throws Exception { // Treat the first occurrence as a stream error streamMultiplexer.onInput(ByteBuffer.wrap(writableChannel.toByteArray())); Mockito.verify(streamHandler).failed(exceptionCaptor.capture()); - Assertions.assertInstanceOf(H2StreamResetException.class, exceptionCaptor.getValue()); + Assertions.assertThat(exceptionCaptor.getValue()).isInstanceOf(H2StreamResetException.class); writableChannel.reset(); final RawFrame dataFrame2 = FRAME_FACTORY.createData(1, ByteBuffer.wrap(new byte[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 0}), true); outBuffer.write(dataFrame2, writableChannel); // Treat subsequent occurrences as a connection-wide protocol error - final H2ConnectionException exception = Assertions.assertThrows(H2ConnectionException.class, () -> - streamMultiplexer.onInput(ByteBuffer.wrap(writableChannel.toByteArray()))); - Assertions.assertEquals(H2Error.STREAM_CLOSED, H2Error.getByCode(exception.getCode())); + final H2ConnectionException exception = Assertions.assertThatThrownBy(() -> + streamMultiplexer.onInput(ByteBuffer.wrap(writableChannel.toByteArray()))).isInstanceOf(H2ConnectionException.class).asInstanceOf(InstanceOfAssertFactories.type(H2ConnectionException.class)).actual(); + Assertions.assertThat(H2Error.getByCode(exception.getCode())).isEqualTo(H2Error.STREAM_CLOSED); } @Test @@ -672,15 +674,15 @@ void testContinuationAfterEndOfStream() throws Exception { streamMultiplexer.onInput(ByteBuffer.wrap(writableChannel.toByteArray())); Mockito.verify(streamHandler).consumeHeader(headersCaptor.capture(), ArgumentMatchers.eq(true)); - Assertions.assertFalse(headersCaptor.getValue().isEmpty()); + Assertions.assertThat(headersCaptor.getValue().isEmpty()).isFalse(); writableChannel.reset(); final RawFrame continuationFrame = FRAME_FACTORY.createContinuation(1, ByteBuffer.wrap(headerBuf.array(), 0, headerBuf.length()), true); outBuffer.write(continuationFrame, writableChannel); - final H2ConnectionException exception = Assertions.assertThrows(H2ConnectionException.class, () -> - streamMultiplexer.onInput(ByteBuffer.wrap(writableChannel.toByteArray()))); - Assertions.assertEquals(H2Error.PROTOCOL_ERROR, H2Error.getByCode(exception.getCode())); + final H2ConnectionException exception = Assertions.assertThatThrownBy(() -> + streamMultiplexer.onInput(ByteBuffer.wrap(writableChannel.toByteArray()))).isInstanceOf(H2ConnectionException.class).asInstanceOf(InstanceOfAssertFactories.type(H2ConnectionException.class)).actual(); + Assertions.assertThat(H2Error.getByCode(exception.getCode())).isEqualTo(H2Error.PROTOCOL_ERROR); } @@ -699,7 +701,7 @@ void testInputHeaderContinuationFramesNoLimit() throws Exception { } encoder.encodeHeaders(headerBuf, headers, h2Config.isCompressionEnabled()); - Assertions.assertTrue(headerBuf.length() > 750); + Assertions.assertThat(headerBuf.length() > 750).isTrue(); final AbstractH2StreamMultiplexer streamMultiplexer = new H2StreamMultiplexerImpl( protocolIOSession, @@ -735,7 +737,7 @@ void testInputHeaderContinuationFramesNoLimit() throws Exception { streamMultiplexer.onInput(ByteBuffer.wrap(writableChannel.toByteArray())); Mockito.verify(streamHandler).consumeHeader(headersCaptor.capture(), ArgumentMatchers.eq(false)); - Assertions.assertFalse(headersCaptor.getValue().isEmpty()); + Assertions.assertThat(headersCaptor.getValue().isEmpty()).isFalse(); } @Test @@ -753,7 +755,7 @@ void testInputHeaderContinuationFramesMaxLimit() throws Exception { } encoder.encodeHeaders(headerBuf, headers, h2Config.isCompressionEnabled()); - Assertions.assertTrue(headerBuf.length() > 750); + Assertions.assertThat(headerBuf.length() > 750).isTrue(); final AbstractH2StreamMultiplexer streamMultiplexer = new H2StreamMultiplexerImpl( protocolIOSession, @@ -787,8 +789,8 @@ void testInputHeaderContinuationFramesMaxLimit() throws Exception { final RawFrame continuationFrame3 = FRAME_FACTORY.createContinuation(2, ByteBuffer.wrap(headerBuf.array(), 750, headerBuf.length() - 750), true); outBuffer.write(continuationFrame3, writableChannel); - Assertions.assertThrows(H2ConnectionException.class, () -> - streamMultiplexer.onInput(ByteBuffer.wrap(writableChannel.toByteArray()))); + Assertions.assertThatThrownBy(() -> + streamMultiplexer.onInput(ByteBuffer.wrap(writableChannel.toByteArray()))).isInstanceOf(H2ConnectionException.class); } @Test @@ -822,19 +824,19 @@ void testStreamRemoteReset() throws Exception { outBuffer.write(headerFrame, writableChannel); streamMultiplexer.onInput(ByteBuffer.wrap(writableChannel.toByteArray())); - Assertions.assertFalse(stream.isRemoteClosed()); - Assertions.assertFalse(stream.isLocalClosed()); + Assertions.assertThat(stream.isRemoteClosed()).isFalse(); + Assertions.assertThat(stream.isLocalClosed()).isFalse(); final RawFrame resetFrame = FRAME_FACTORY.createResetStream(1, H2Error.NO_ERROR); outBuffer.write(resetFrame, writableChannel); streamMultiplexer.onInput(ByteBuffer.wrap(writableChannel.toByteArray())); - Assertions.assertTrue(stream.isRemoteClosed()); - Assertions.assertTrue(stream.isLocalClosed()); + Assertions.assertThat(stream.isRemoteClosed()).isTrue(); + Assertions.assertThat(stream.isLocalClosed()).isTrue(); final ArgumentCaptor exceptionCaptor = ArgumentCaptor.forClass(Exception.class); Mockito.verify(streamHandler).failed(exceptionCaptor.capture()); - Assertions.assertInstanceOf(H2StreamResetException.class, exceptionCaptor.getValue()); + Assertions.assertThat(exceptionCaptor.getValue()).isInstanceOf(H2StreamResetException.class); } @Test @@ -873,16 +875,16 @@ void testStreamRemoteResetNoErrorRemoteAlreadyClosed() throws Exception { outBuffer.write(dataFrame, writableChannel); streamMultiplexer.onInput(ByteBuffer.wrap(writableChannel.toByteArray())); - Assertions.assertTrue(stream.isRemoteClosed()); - Assertions.assertFalse(stream.isLocalClosed()); + Assertions.assertThat(stream.isRemoteClosed()).isTrue(); + Assertions.assertThat(stream.isLocalClosed()).isFalse(); writableChannel.reset(); final RawFrame resetFrame = FRAME_FACTORY.createResetStream(1, H2Error.NO_ERROR); outBuffer.write(resetFrame, writableChannel); streamMultiplexer.onInput(ByteBuffer.wrap(writableChannel.toByteArray())); - Assertions.assertTrue(stream.isRemoteClosed()); - Assertions.assertTrue(stream.isLocalClosed()); + Assertions.assertThat(stream.isRemoteClosed()).isTrue(); + Assertions.assertThat(stream.isLocalClosed()).isTrue(); Mockito.verify(streamHandler, Mockito.never()).failed(ArgumentMatchers.any()); } @@ -916,7 +918,7 @@ void testPriorityUpdateInputAccepted() throws Exception { fob.write(priUpd, writable); final byte[] bytes = writable.toByteArray(); - Assertions.assertDoesNotThrow(() -> mux.onInput(ByteBuffer.wrap(bytes))); + Assertions.assertThatCode(() -> mux.onInput(ByteBuffer.wrap(bytes))).doesNotThrowAnyException(); Mockito.verify(h2StreamListener).onFrameInput( ArgumentMatchers.same(mux), @@ -949,11 +951,11 @@ void testPriorityUpdateInputRejectedForUnseenStream() throws Exception { fob.write(priUpd, writable); final byte[] bytes = writable.toByteArray(); - final H2ConnectionException ex = Assertions.assertThrows( - H2ConnectionException.class, - () -> mux.onInput(ByteBuffer.wrap(bytes))); + final H2ConnectionException ex = Assertions.assertThatThrownBy(() -> + mux.onInput(ByteBuffer.wrap(bytes))) + .isInstanceOf(H2ConnectionException.class).asInstanceOf(InstanceOfAssertFactories.type(H2ConnectionException.class)).actual(); - Assertions.assertEquals("Unexpected stream id: 1", ex.getMessage()); + Assertions.assertThat(ex.getMessage()).isEqualTo("Unexpected stream id: 1"); } @@ -1054,9 +1056,9 @@ void testSubmitWithPriorityHeaderEmitsPriorityUpdateBeforeHeaders() throws Excep if (idxPriUpd < 0 && f.type == FrameType.PRIORITY_UPDATE.getValue() && f.streamId == 0) idxPriUpd = i; if (idxHeaders < 0 && f.type == FrameType.HEADERS.getValue() && f.streamId == 1) idxHeaders = i; } - Assertions.assertTrue(idxPriUpd >= 0, "PRIORITY_UPDATE not emitted"); - Assertions.assertTrue(idxHeaders >= 0, "HEADERS not emitted"); - Assertions.assertTrue(idxPriUpd < idxHeaders, "PRIORITY_UPDATE must precede HEADERS"); + Assertions.assertThat(idxPriUpd >= 0).withFailMessage("PRIORITY_UPDATE not emitted").isTrue(); + Assertions.assertThat(idxHeaders >= 0).withFailMessage("HEADERS not emitted").isTrue(); + Assertions.assertThat(idxPriUpd < idxHeaders).withFailMessage("PRIORITY_UPDATE must precede HEADERS").isTrue(); } // 3) Optional policy: suppress emission when peer’s first SETTINGS omits 0x9 @@ -1102,8 +1104,7 @@ void testPriorityUpdateSuppressedAfterSettingsWithoutNoH2() throws Exception { for (final byte[] a : writes) { System.arraycopy(a, 0, all, p, a.length); p += a.length; } final List frames = parseFrames(all); - Assertions.assertTrue(frames.stream().noneMatch(f -> f.type == FrameType.PRIORITY_UPDATE.getValue()), - "PRIORITY_UPDATE must be suppressed when peer didn't send NO_RFC7540 (policy)"); + Assertions.assertThat(frames.stream().noneMatch(f -> f.type == FrameType.PRIORITY_UPDATE.getValue())).withFailMessage("PRIORITY_UPDATE must be suppressed when peer didn't send NO_RFC7540 (policy)").isTrue(); } // 4) Continue emission when peer sends NO_RFC7540=1 @@ -1155,7 +1156,7 @@ void testPriorityUpdateContinuesAfterSettingsWithNoH2Equals1() throws Exception final int idxPriUpd = IntStream.range(0, frames.size()) .filter(i -> frames.get(i).type == FrameType.PRIORITY_UPDATE.getValue() && frames.get(i).streamId == 0) .findFirst().orElse(-1); - Assertions.assertTrue(idxPriUpd >= 0, "PRIORITY_UPDATE should be emitted when NO_RFC7540=1"); + Assertions.assertThat(idxPriUpd >= 0).withFailMessage("PRIORITY_UPDATE should be emitted when NO_RFC7540=1").isTrue(); } @Test @@ -1191,17 +1192,17 @@ void testStreamIdleTimeoutTriggersH2StreamTimeoutException() throws Exception { Mockito.verify(streamHandler).failed(exceptionCaptor.capture()); final Exception cause = exceptionCaptor.getValue(); - Assertions.assertInstanceOf(H2StreamTimeoutException.class, cause); + Assertions.assertThat(cause).isInstanceOf(H2StreamTimeoutException.class); final H2StreamTimeoutException timeoutEx = (H2StreamTimeoutException) cause; - Assertions.assertEquals(1, timeoutEx.getStreamId()); + Assertions.assertThat(timeoutEx.getStreamId()).isEqualTo(1); - Assertions.assertTrue(stream.isLocalClosed()); - Assertions.assertTrue(stream.isClosed()); + Assertions.assertThat(stream.isLocalClosed()).isTrue(); + Assertions.assertThat(stream.isClosed()).isTrue(); - Assertions.assertTrue(timeoutEx.getMessage().contains("idle timeout")); - Assertions.assertEquals(1L, timeoutEx.getTimeout().toNanoseconds()); - Assertions.assertEquals(1, timeoutEx.getStreamId()); + Assertions.assertThat(timeoutEx.getMessage().contains("idle timeout")).isTrue(); + Assertions.assertThat(timeoutEx.getTimeout().toNanoseconds()).isEqualTo(1L); + Assertions.assertThat(timeoutEx.getStreamId()).isEqualTo(1); } @@ -1229,12 +1230,12 @@ void testResetIfExpiredResetsStreamPastDeadline() throws Exception { lastActivityField.setAccessible(true); lastActivityField.set(stream, System.nanoTime() - TimeUnit.MILLISECONDS.toNanos(100)); - Assertions.assertTrue(mux.resetIfExpired(stream, System.nanoTime())); + Assertions.assertThat(mux.resetIfExpired(stream, System.nanoTime())).isTrue(); Mockito.verify(streamHandler).failed(exceptionCaptor.capture()); - Assertions.assertInstanceOf(H2StreamTimeoutException.class, exceptionCaptor.getValue()); - Assertions.assertTrue(stream.isLocalClosed()); - Assertions.assertTrue(stream.isClosed()); + Assertions.assertThat(exceptionCaptor.getValue()).isInstanceOf(H2StreamTimeoutException.class); + Assertions.assertThat(stream.isLocalClosed()).isTrue(); + Assertions.assertThat(stream.isClosed()).isTrue(); } @Test @@ -1256,8 +1257,8 @@ void testResetIfExpiredIgnoresStreamBeforeDeadline() throws Exception { stream.setTimeout(Timeout.ofMinutes(1)); stream.activate(); - Assertions.assertFalse(mux.resetIfExpired(stream, System.nanoTime())); - Assertions.assertFalse(stream.isLocalClosed()); + Assertions.assertThat(mux.resetIfExpired(stream, System.nanoTime())).isFalse(); + Assertions.assertThat(stream.isLocalClosed()).isFalse(); Mockito.verify(streamHandler, Mockito.never()).failed(ArgumentMatchers.any()); } @@ -1306,7 +1307,7 @@ void testExpiredStreamResetOnInboundData() throws Exception { mux.onInput(ByteBuffer.wrap(writableChannel.toByteArray())); Mockito.verify(streamHandler).consumeHeader(headersCaptor.capture(), ArgumentMatchers.eq(false)); - Assertions.assertFalse(headersCaptor.getValue().isEmpty()); + Assertions.assertThat(headersCaptor.getValue().isEmpty()).isFalse(); // Retrieve the stream and set a short timeout final Field streamsField = AbstractH2StreamMultiplexer.class.getDeclaredField("streams"); @@ -1329,7 +1330,7 @@ void testExpiredStreamResetOnInboundData() throws Exception { // The handler must receive a timeout failure, not data Mockito.verify(streamHandler).failed(exceptionCaptor.capture()); - Assertions.assertInstanceOf(H2StreamTimeoutException.class, exceptionCaptor.getValue()); + Assertions.assertThat(exceptionCaptor.getValue()).isInstanceOf(H2StreamTimeoutException.class); Mockito.verify(streamHandler, Mockito.never()).consumeData( ArgumentMatchers.any(ByteBuffer.class), ArgumentMatchers.anyBoolean()); } @@ -1404,7 +1405,7 @@ void testExpiredStreamResetOnInboundContinuation() throws Exception { // The handler must receive a timeout failure, not header consumption Mockito.verify(streamHandler).failed(exceptionCaptor.capture()); - Assertions.assertInstanceOf(H2StreamTimeoutException.class, exceptionCaptor.getValue()); + Assertions.assertThat(exceptionCaptor.getValue()).isInstanceOf(H2StreamTimeoutException.class); Mockito.verify(streamHandler, Mockito.never()).consumeHeader( ArgumentMatchers.anyList(), ArgumentMatchers.anyBoolean()); } @@ -1427,7 +1428,9 @@ void testOutboundTrailersWithPseudoHeaderRejected() throws Exception { final List
trailers = Arrays.asList( new BasicHeader(":status", "200")); - Assertions.assertThrows(H2ConnectionException.class, () -> channel.endStream(trailers)); + Assertions.assertThatThrownBy(() -> + channel.endStream(trailers)) + .isInstanceOf(H2ConnectionException.class); } @Test @@ -1449,7 +1452,7 @@ void testInputUnknownFrameTypeIgnored() throws Exception { h2StreamListener, () -> streamHandler); - Assertions.assertDoesNotThrow(() -> streamMultiplexer.onInput(ByteBuffer.wrap(writableChannel.toByteArray()))); + Assertions.assertThatCode(() -> streamMultiplexer.onInput(ByteBuffer.wrap(writableChannel.toByteArray()))).doesNotThrowAnyException(); } private static byte[] encodeFrame(final RawFrame frame) throws IOException { final WritableByteChannelMock writableChannel = new WritableByteChannelMock(256); @@ -1560,8 +1563,8 @@ void testKeepAliveNotActiveBeforeSettingsHandshake() throws Exception { mux.onTimeout(idleTime); final List frames = parseFrames(concat(writes)); - Assertions.assertTrue(frames.stream().noneMatch(FrameStub::isPing), "Must not emit PING before handshake"); - Assertions.assertTrue(frames.stream().anyMatch(FrameStub::isGoAway), "Default timeout path must emit GOAWAY"); + Assertions.assertThat(frames.stream().noneMatch(FrameStub::isPing)).withFailMessage("Must not emit PING before handshake").isTrue(); + Assertions.assertThat(frames.stream().anyMatch(FrameStub::isGoAway)).withFailMessage("Default timeout path must emit GOAWAY").isTrue(); } @Test @@ -1619,8 +1622,8 @@ void testValidateAfterInactivitySendsPingAndSetsAckTimeout() throws Exception { .setSocketTimeout(ArgumentMatchers.eq(Timeout.ofSeconds(5))); final List frames = parseFrames(concat(writes)); - Assertions.assertTrue(frames.stream().anyMatch(f -> f.isPing() && !f.isAck()), "Must emit pre-flight PING"); - Assertions.assertTrue(mux.isOpen()); + Assertions.assertThat(frames.stream().anyMatch(f -> f.isPing() && !f.isAck())).withFailMessage("Must emit pre-flight PING").isTrue(); + Assertions.assertThat(mux.isOpen()).isTrue(); } @Test @@ -1658,8 +1661,8 @@ void testValidateAfterInactivityPingAckRestoresPreviousTimeout() throws Exceptio final List frames = parseFrames(concat(writes)); final FrameStub ping = frames.stream().filter(f -> f.isPing() && !f.isAck()).findFirst().orElse(null); - Assertions.assertNotNull(ping, "Expected a pre-flight PING frame"); - Assertions.assertEquals(8, ping.payload.length); + Assertions.assertThat(ping).withFailMessage("Expected a pre-flight PING frame").isNotNull(); + Assertions.assertThat(ping.payload.length).isEqualTo(8); final RawFrame pingAck = new RawFrame( FrameType.PING.getValue(), @@ -1711,8 +1714,7 @@ void testValidateAfterInactivityUsesConfiguredPingAckTimeout() throws Exception .setSocketTimeout(ArgumentMatchers.eq(customPingAckTimeout)); final List frames = parseFrames(concat(writes)); - Assertions.assertTrue(frames.stream().anyMatch(f -> f.isPing() && !f.isAck()), - "Must emit pre-flight PING"); + Assertions.assertThat(frames.stream().anyMatch(f -> f.isPing() && !f.isAck())).withFailMessage("Must emit pre-flight PING").isTrue(); } @Test @@ -1753,12 +1755,12 @@ void testKeepAliveAckTimeoutShutsDownAndFailsStreams() throws Exception { mux.onTimeout(ackTimeout); final List frames = parseFrames(concat(writes)); - Assertions.assertTrue(frames.stream().anyMatch(FrameStub::isGoAway), "Must emit GOAWAY on ping ACK timeout"); + Assertions.assertThat(frames.stream().anyMatch(FrameStub::isGoAway)).withFailMessage("Must emit GOAWAY on ping ACK timeout").isTrue(); Mockito.verify(streamHandler, Mockito.atLeastOnce()).failed(exceptionCaptor.capture()); - Assertions.assertInstanceOf(H2StreamResetException.class, exceptionCaptor.getValue()); + Assertions.assertThat(exceptionCaptor.getValue()).isInstanceOf(H2StreamResetException.class); - Assertions.assertFalse(mux.isOpen(), "Connection must not be open after keepalive shutdown"); + Assertions.assertThat(mux.isOpen()).withFailMessage("Connection must not be open after keepalive shutdown").isFalse(); } @Test @@ -1786,7 +1788,7 @@ void testKeepAliveDisabledNeverEmitsPing() throws Exception { mux.onTimeout(Timeout.ofMilliseconds(1)); final List frames = parseFrames(concat(writes)); - Assertions.assertTrue(frames.stream().noneMatch(FrameStub::isPing), "Disabled policy must never emit PING"); + Assertions.assertThat(frames.stream().noneMatch(FrameStub::isPing)).withFailMessage("Disabled policy must never emit PING").isTrue(); } private static long getValidateAfterInactivityGranularityMillis() throws Exception { @@ -1834,10 +1836,10 @@ void testHpackDecodeFailureInHeadersCausesConnectionCompressionError() throws Ex outBuffer.write(headersFrame, writableChannel); - final H2ConnectionException exception = Assertions.assertThrows(H2ConnectionException.class, () -> - mux.onInput(ByteBuffer.wrap(writableChannel.toByteArray()))); + final H2ConnectionException exception = Assertions.assertThatThrownBy(() -> + mux.onInput(ByteBuffer.wrap(writableChannel.toByteArray()))).isInstanceOf(H2ConnectionException.class).asInstanceOf(InstanceOfAssertFactories.type(H2ConnectionException.class)).actual(); - Assertions.assertEquals(H2Error.COMPRESSION_ERROR, H2Error.getByCode(exception.getCode())); + Assertions.assertThat(H2Error.getByCode(exception.getCode())).isEqualTo(H2Error.COMPRESSION_ERROR); // Must not be delegated to stream-level handlers. Mockito.verify(streamHandler, Mockito.never()) @@ -1896,11 +1898,11 @@ void testHpackExceptionInHeadersMappedToConnectionCompressionError() throws Exce outBuffer.write(headersFrame, writableChannel); - final H2ConnectionException ex = Assertions.assertThrows(H2ConnectionException.class, () -> - mux.onInput(ByteBuffer.wrap(writableChannel.toByteArray()))); + final H2ConnectionException ex = Assertions.assertThatThrownBy(() -> + mux.onInput(ByteBuffer.wrap(writableChannel.toByteArray()))).isInstanceOf(H2ConnectionException.class).asInstanceOf(InstanceOfAssertFactories.type(H2ConnectionException.class)).actual(); - Assertions.assertEquals(H2Error.COMPRESSION_ERROR, H2Error.getByCode(ex.getCode())); - Assertions.assertInstanceOf(HPackException.class, ex.getCause()); + Assertions.assertThat(H2Error.getByCode(ex.getCode())).isEqualTo(H2Error.COMPRESSION_ERROR); + Assertions.assertThat(ex.getCause()).isInstanceOf(HPackException.class); // Must not be handled at stream level Mockito.verify(streamHandler, Mockito.never()) @@ -1935,11 +1937,11 @@ void testInputSettingsAckWithNonEmptyPayloadRejected() throws Exception { 0x00, 0x00, 0x00, 0x01 // setting value }; - final H2ConnectionException ex = Assertions.assertThrows( - H2ConnectionException.class, - () -> mux.onInput(ByteBuffer.wrap(bytes))); + final H2ConnectionException ex = Assertions.assertThatThrownBy(() -> + mux.onInput(ByteBuffer.wrap(bytes))) + .isInstanceOf(H2ConnectionException.class).asInstanceOf(InstanceOfAssertFactories.type(H2ConnectionException.class)).actual(); - Assertions.assertEquals(H2Error.FRAME_SIZE_ERROR, H2Error.getByCode(ex.getCode())); + Assertions.assertThat(H2Error.getByCode(ex.getCode())).isEqualTo(H2Error.FRAME_SIZE_ERROR); } @Test @@ -1960,7 +1962,7 @@ void testWindowUpdateReservedBitIgnored() throws Exception { final RawFrame windowUpdate = new RawFrame(FrameType.WINDOW_UPDATE.getValue(), 0, 0, payload); - Assertions.assertDoesNotThrow(() -> mux.onInput(ByteBuffer.wrap(encodeFrame(windowUpdate)))); + Assertions.assertThatCode(() -> mux.onInput(ByteBuffer.wrap(encodeFrame(windowUpdate)))).doesNotThrowAnyException(); } @Test @@ -1978,7 +1980,7 @@ void testPingReservedBitInStreamIdIgnored() throws Exception { final ByteBuffer payload = ByteBuffer.wrap(new byte[8]); final RawFrame ping = new RawFrame(FrameType.PING.getValue(), 0, 0x80000000, payload); - Assertions.assertDoesNotThrow(() -> mux.onInput(ByteBuffer.wrap(encodeFrame(ping)))); + Assertions.assertThatCode(() -> mux.onInput(ByteBuffer.wrap(encodeFrame(ping)))).doesNotThrowAnyException(); } @Test @@ -2024,7 +2026,7 @@ void testPushPromiseReservedBitInPromisedStreamIdIgnored() throws Exception { 1, payload); - Assertions.assertDoesNotThrow(() -> mux.onInput(ByteBuffer.wrap(encodeFrame(pp)))); + Assertions.assertThatCode(() -> mux.onInput(ByteBuffer.wrap(encodeFrame(pp)))).doesNotThrowAnyException(); Mockito.verify(h2StreamListener).onHeaderInput( ArgumentMatchers.same(mux), @@ -2059,14 +2061,12 @@ void testGoAwayReservedBitInLastStreamIdIgnored() throws Exception { goAwayPayload.flip(); final RawFrame goAway = new RawFrame(FrameType.GOAWAY.getValue(), 0, 0, goAwayPayload); - Assertions.assertDoesNotThrow(() -> mux.onInput(ByteBuffer.wrap(encodeFrame(goAway)))); + Assertions.assertThatCode(() -> mux.onInput(ByteBuffer.wrap(encodeFrame(goAway)))).doesNotThrowAnyException(); Mockito.verify(stream1Handler, Mockito.never()).failed(ArgumentMatchers.any(Exception.class)); Mockito.verify(stream3Handler, Mockito.never()).failed(ArgumentMatchers.any(Exception.class)); Mockito.verify(stream5Handler).failed(exceptionCaptor.capture()); - Assertions.assertInstanceOf( - org.apache.hc.core5.http.RequestNotExecutedException.class, - exceptionCaptor.getValue()); + Assertions.assertThat(exceptionCaptor.getValue()).isInstanceOf(org.apache.hc.core5.http.RequestNotExecutedException.class); } @Test @@ -2087,11 +2087,11 @@ void testWindowUpdateZeroIncrementOnConnectionIsConnectionError() throws Excepti final RawFrame windowUpdate = new RawFrame(FrameType.WINDOW_UPDATE.getValue(), 0, 0, payload); - final H2ConnectionException ex = Assertions.assertThrows( - H2ConnectionException.class, - () -> mux.onInput(ByteBuffer.wrap(encodeFrame(windowUpdate)))); + final H2ConnectionException ex = Assertions.assertThatThrownBy(() -> + mux.onInput(ByteBuffer.wrap(encodeFrame(windowUpdate)))) + .isInstanceOf(H2ConnectionException.class).asInstanceOf(InstanceOfAssertFactories.type(H2ConnectionException.class)).actual(); - Assertions.assertEquals(H2Error.PROTOCOL_ERROR, H2Error.getByCode(ex.getCode())); + Assertions.assertThat(H2Error.getByCode(ex.getCode())).isEqualTo(H2Error.PROTOCOL_ERROR); } @Test @@ -2115,12 +2115,12 @@ void testWindowUpdateZeroIncrementOnStreamIsStreamError() throws Exception { final RawFrame windowUpdate = new RawFrame(FrameType.WINDOW_UPDATE.getValue(), 0, 1, payload); - Assertions.assertDoesNotThrow(() -> mux.onInput(ByteBuffer.wrap(encodeFrame(windowUpdate)))); + Assertions.assertThatCode(() -> mux.onInput(ByteBuffer.wrap(encodeFrame(windowUpdate)))).doesNotThrowAnyException(); Mockito.verify(streamHandler).failed(exceptionCaptor.capture()); final Exception cause = exceptionCaptor.getValue(); - Assertions.assertInstanceOf(H2StreamResetException.class, cause); - Assertions.assertEquals(H2Error.PROTOCOL_ERROR, H2Error.getByCode(((H2StreamResetException) cause).getCode())); + Assertions.assertThat(cause).isInstanceOf(H2StreamResetException.class); + Assertions.assertThat(H2Error.getByCode(((H2StreamResetException) cause).getCode())).isEqualTo(H2Error.PROTOCOL_ERROR); } @Test @@ -2141,11 +2141,11 @@ void testHeadersWithPriorityFlagAndShortPayloadRejected() throws Exception { 2, ByteBuffer.allocate(0)); - final H2ConnectionException ex = Assertions.assertThrows( - H2ConnectionException.class, - () -> mux.onInput(ByteBuffer.wrap(encodeFrame(headers)))); + final H2ConnectionException ex = Assertions.assertThatThrownBy(() -> + mux.onInput(ByteBuffer.wrap(encodeFrame(headers)))) + .isInstanceOf(H2ConnectionException.class).asInstanceOf(InstanceOfAssertFactories.type(H2ConnectionException.class)).actual(); - Assertions.assertEquals(H2Error.FRAME_SIZE_ERROR, H2Error.getByCode(ex.getCode())); + Assertions.assertThat(H2Error.getByCode(ex.getCode())).isEqualTo(H2Error.FRAME_SIZE_ERROR); } @@ -2164,10 +2164,10 @@ void testFirstPeerFrameMustBeSettings() throws Exception { mux.onConnect(); final RawFrame ping = new RawFrame(FrameType.PING.getValue(), 0, 0, ByteBuffer.wrap(new byte[8])); - final H2ConnectionException ex = Assertions.assertThrows( - H2ConnectionException.class, - () -> mux.onInput(ByteBuffer.wrap(encodeFrame(ping)))); - Assertions.assertEquals(H2Error.PROTOCOL_ERROR, H2Error.getByCode(ex.getCode())); + final H2ConnectionException ex = Assertions.assertThatThrownBy(() -> + mux.onInput(ByteBuffer.wrap(encodeFrame(ping)))) + .isInstanceOf(H2ConnectionException.class).asInstanceOf(InstanceOfAssertFactories.type(H2ConnectionException.class)).actual(); + Assertions.assertThat(H2Error.getByCode(ex.getCode())).isEqualTo(H2Error.PROTOCOL_ERROR); } @Test @@ -2185,10 +2185,10 @@ void testFirstPeerSettingsAckRejected() throws Exception { mux.onConnect(); final RawFrame settingsAck = new RawFrame(FrameType.SETTINGS.getValue(), FrameFlag.ACK.getValue(), 0, null); - final H2ConnectionException ex = Assertions.assertThrows( - H2ConnectionException.class, - () -> mux.onInput(ByteBuffer.wrap(encodeFrame(settingsAck)))); - Assertions.assertEquals(H2Error.PROTOCOL_ERROR, H2Error.getByCode(ex.getCode())); + final H2ConnectionException ex = Assertions.assertThatThrownBy(() -> + mux.onInput(ByteBuffer.wrap(encodeFrame(settingsAck)))) + .isInstanceOf(H2ConnectionException.class).asInstanceOf(InstanceOfAssertFactories.type(H2ConnectionException.class)).actual(); + Assertions.assertThat(H2Error.getByCode(ex.getCode())).isEqualTo(H2Error.PROTOCOL_ERROR); } @Test @@ -2218,11 +2218,11 @@ void testInputRstStreamWithInvalidLengthOnUnseenStreamRejected() throws Exceptio final RawFrame badRst = new RawFrame(FrameType.RST_STREAM.getValue(), 0, 1, null); - final H2ConnectionException ex = Assertions.assertThrows( - H2ConnectionException.class, - () -> mux.onInput(ByteBuffer.wrap(encodeFrame(badRst)))); + final H2ConnectionException ex = Assertions.assertThatThrownBy(() -> + mux.onInput(ByteBuffer.wrap(encodeFrame(badRst)))) + .isInstanceOf(H2ConnectionException.class).asInstanceOf(InstanceOfAssertFactories.type(H2ConnectionException.class)).actual(); - Assertions.assertEquals(H2Error.FRAME_SIZE_ERROR, H2Error.getByCode(ex.getCode())); + Assertions.assertThat(H2Error.getByCode(ex.getCode())).isEqualTo(H2Error.FRAME_SIZE_ERROR); } @Test @@ -2264,14 +2264,12 @@ void testHeadersWithPrioritySelfDependencyIsStreamProtocolError() throws Excepti 2, payload); - Assertions.assertDoesNotThrow(() -> mux.onInput(ByteBuffer.wrap(encodeFrame(headersFrame)))); + Assertions.assertThatCode(() -> mux.onInput(ByteBuffer.wrap(encodeFrame(headersFrame)))).doesNotThrowAnyException(); Mockito.verify(streamHandler).failed(exceptionCaptor.capture()); final Exception cause = exceptionCaptor.getValue(); - Assertions.assertInstanceOf(H2StreamResetException.class, cause); - Assertions.assertEquals( - H2Error.PROTOCOL_ERROR, - H2Error.getByCode(((H2StreamResetException) cause).getCode())); + Assertions.assertThat(cause).isInstanceOf(H2StreamResetException.class); + Assertions.assertThat(H2Error.getByCode(((H2StreamResetException) cause).getCode())).isEqualTo(H2Error.PROTOCOL_ERROR); Mockito.verify(streamHandler, Mockito.never()) .consumeHeader(ArgumentMatchers.anyList(), ArgumentMatchers.anyBoolean()); @@ -2298,7 +2296,7 @@ void testHPackDecoderUsesConfiguredMaxHeaderListSizeImmediately() throws Excepti final HPackDecoder hPackDecoder = getHPackDecoder(multiplexer); - Assertions.assertEquals(maxHeaderListSize, getMaxListSize(hPackDecoder)); + Assertions.assertThat(getMaxListSize(hPackDecoder)).isEqualTo(maxHeaderListSize); } private int encoderTableSizeAfterRemoteSettings(final int headerTableSize) throws Exception { @@ -2326,15 +2324,13 @@ private int encoderTableSizeAfterRemoteSettings(final int headerTableSize) throw @Test void testRemoteHeaderTableSizeIsCappedForEncoder() throws Exception { - Assertions.assertEquals( - H2Config.INIT.getHeaderTableSize(), - encoderTableSizeAfterRemoteSettings(Integer.MAX_VALUE)); + Assertions.assertThat(encoderTableSizeAfterRemoteSettings(Integer.MAX_VALUE)).isEqualTo(H2Config.INIT.getHeaderTableSize()); } @Test void testSmallerRemoteHeaderTableSizeIsHonouredByEncoder() throws Exception { - Assertions.assertEquals(1024, encoderTableSizeAfterRemoteSettings(1024)); - Assertions.assertEquals(0, encoderTableSizeAfterRemoteSettings(0)); + Assertions.assertThat(encoderTableSizeAfterRemoteSettings(1024)).isEqualTo(1024); + Assertions.assertThat(encoderTableSizeAfterRemoteSettings(0)).isEqualTo(0); } @Test @@ -2356,7 +2352,7 @@ void testRemoteHeaderTableSizeChangesRemainLocallyBounded() throws Exception { payload.flip(); mux.onInput(ByteBuffer.wrap( encodeFrame(new RawFrame(FrameType.SETTINGS.getValue(), 0, 0, payload)))); - Assertions.assertEquals(1024, encoder.getMaxTableSize()); + Assertions.assertThat(encoder.getMaxTableSize()).isEqualTo(1024); payload = ByteBuffer.allocate(6); payload.putShort((short) H2Param.HEADER_TABLE_SIZE.getCode()); @@ -2364,7 +2360,7 @@ void testRemoteHeaderTableSizeChangesRemainLocallyBounded() throws Exception { payload.flip(); mux.onInput(ByteBuffer.wrap( encodeFrame(new RawFrame(FrameType.SETTINGS.getValue(), 0, 0, payload)))); - Assertions.assertEquals(H2Config.INIT.getHeaderTableSize(), encoder.getMaxTableSize()); + Assertions.assertThat(encoder.getMaxTableSize()).isEqualTo(H2Config.INIT.getHeaderTableSize()); payload = ByteBuffer.allocate(6); payload.putShort((short) H2Param.HEADER_TABLE_SIZE.getCode()); @@ -2372,7 +2368,7 @@ void testRemoteHeaderTableSizeChangesRemainLocallyBounded() throws Exception { payload.flip(); mux.onInput(ByteBuffer.wrap( encodeFrame(new RawFrame(FrameType.SETTINGS.getValue(), 0, 0, payload)))); - Assertions.assertEquals(0, encoder.getMaxTableSize()); + Assertions.assertThat(encoder.getMaxTableSize()).isEqualTo(0); payload = ByteBuffer.allocate(6); payload.putShort((short) H2Param.HEADER_TABLE_SIZE.getCode()); @@ -2380,7 +2376,7 @@ void testRemoteHeaderTableSizeChangesRemainLocallyBounded() throws Exception { payload.flip(); mux.onInput(ByteBuffer.wrap( encodeFrame(new RawFrame(FrameType.SETTINGS.getValue(), 0, 0, payload)))); - Assertions.assertEquals(H2Config.INIT.getHeaderTableSize(), encoder.getMaxTableSize()); + Assertions.assertThat(encoder.getMaxTableSize()).isEqualTo(H2Config.INIT.getHeaderTableSize()); } } @@ -2405,12 +2401,9 @@ void testUnsignedHeaderTableSizeSettingAccepted() throws Exception { final RawFrame settingsFrame = new RawFrame(FrameType.SETTINGS.getValue(), 0, 0, payload); - Assertions.assertDoesNotThrow( - () -> mux.onInput(ByteBuffer.wrap(encodeFrame(settingsFrame)))); - Assertions.assertEquals(-1, getRemoteConfig(mux).getHeaderTableSize()); - Assertions.assertEquals( - H2Config.INIT.getHeaderTableSize(), - getHPackEncoder(mux).getMaxTableSize()); + Assertions.assertThatCode(() -> mux.onInput(ByteBuffer.wrap(encodeFrame(settingsFrame)))).doesNotThrowAnyException(); + Assertions.assertThat(getRemoteConfig(mux).getHeaderTableSize()).isEqualTo(-1); + Assertions.assertThat(getHPackEncoder(mux).getMaxTableSize()).isEqualTo(H2Config.INIT.getHeaderTableSize()); } finally { mux.close(); } @@ -2436,11 +2429,8 @@ void testUnsignedMaxConcurrentStreamsSettingAccepted() throws Exception { final RawFrame settingsFrame = new RawFrame(FrameType.SETTINGS.getValue(), 0, 0, payload); - Assertions.assertDoesNotThrow( - () -> mux.onInput(ByteBuffer.wrap(encodeFrame(settingsFrame)))); - Assertions.assertEquals( - Integer.MIN_VALUE, - getRemoteConfig(mux).getMaxConcurrentStreams()); + Assertions.assertThatCode(() -> mux.onInput(ByteBuffer.wrap(encodeFrame(settingsFrame)))).doesNotThrowAnyException(); + Assertions.assertThat(getRemoteConfig(mux).getMaxConcurrentStreams()).isEqualTo(Integer.MIN_VALUE); } finally { mux.close(); } @@ -2466,9 +2456,8 @@ void testUnsignedMaxHeaderListSizeSettingAccepted() throws Exception { final RawFrame settingsFrame = new RawFrame(FrameType.SETTINGS.getValue(), 0, 0, payload); - Assertions.assertDoesNotThrow( - () -> mux.onInput(ByteBuffer.wrap(encodeFrame(settingsFrame)))); - Assertions.assertEquals(-1, getRemoteConfig(mux).getMaxHeaderListSize()); + Assertions.assertThatCode(() -> mux.onInput(ByteBuffer.wrap(encodeFrame(settingsFrame)))).doesNotThrowAnyException(); + Assertions.assertThat(getRemoteConfig(mux).getMaxHeaderListSize()).isEqualTo(-1); } finally { mux.close(); } @@ -2551,13 +2540,11 @@ void testDataOnReservedRemoteStreamIsConnectionProtocolError() throws Exception ByteBuffer.wrap(new byte[] {1, 2, 3}), false); - final H2ConnectionException ex = Assertions.assertThrows( - H2ConnectionException.class, - () -> mux.onInput(ByteBuffer.wrap(encodeFrame(data)))); + final H2ConnectionException ex = Assertions.assertThatThrownBy(() -> + mux.onInput(ByteBuffer.wrap(encodeFrame(data)))) + .isInstanceOf(H2ConnectionException.class).asInstanceOf(InstanceOfAssertFactories.type(H2ConnectionException.class)).actual(); - Assertions.assertEquals( - H2Error.PROTOCOL_ERROR, - H2Error.getByCode(ex.getCode())); + Assertions.assertThat(H2Error.getByCode(ex.getCode())).isEqualTo(H2Error.PROTOCOL_ERROR); Mockito.verify(streamHandler, Mockito.never()).consumeData( ArgumentMatchers.any(ByteBuffer.class), @@ -2573,7 +2560,7 @@ void testMalformedSettingsAfterOverheadLimitReportsFrameSizeError() throws Excep 1, 1, FrameLimitController.RST_STREAM_CAPACITY, FrameLimitController.RST_STREAM_REFILL_PER_SECOND, FrameLimitController.RST_STREAM_MAX_AGE_NANOS); - Assertions.assertTrue(limiter.acceptControlFrame(Long.MAX_VALUE)); + Assertions.assertThat(limiter.acceptControlFrame(Long.MAX_VALUE)).isTrue(); final AbstractH2StreamMultiplexer mux = new H2StreamMultiplexerImpl( protocolIOSession, @@ -2590,19 +2577,19 @@ void testMalformedSettingsAfterOverheadLimitReportsFrameSizeError() throws Excep final RawFrame malformed = new RawFrame( FrameType.SETTINGS.getValue(), 0, 0, ByteBuffer.wrap(new byte[1])); - final H2ConnectionException frameSizeError = Assertions.assertThrows( - H2ConnectionException.class, - () -> feedFrame(mux, malformed)); - Assertions.assertEquals(H2Error.FRAME_SIZE_ERROR, - H2Error.getByCode(frameSizeError.getCode())); + Assertions.assertThatThrownBy(() -> feedFrame(mux, malformed)) + .isInstanceOf(H2ConnectionException.class) + .asInstanceOf(InstanceOfAssertFactories.type(H2ConnectionException.class)) + .extracting(ex -> H2Error.getByCode(ex.getCode())) + .isEqualTo(H2Error.FRAME_SIZE_ERROR); final RawFrame valid = new RawFrame( FrameType.SETTINGS.getValue(), 0, 0, ByteBuffer.allocate(0)); - final H2ConnectionException overheadError = Assertions.assertThrows( - H2ConnectionException.class, - () -> feedFrame(mux, valid)); - Assertions.assertEquals(H2Error.ENHANCE_YOUR_CALM, - H2Error.getByCode(overheadError.getCode())); + Assertions.assertThatThrownBy(() -> feedFrame(mux, valid)) + .isInstanceOf(H2ConnectionException.class) + .asInstanceOf(InstanceOfAssertFactories.type(H2ConnectionException.class)) + .extracting(ex -> H2Error.getByCode(ex.getCode())) + .isEqualTo(H2Error.ENHANCE_YOUR_CALM); } @Test void testRapidResetRejectsExcessivePeerCancellations() throws Exception { @@ -2630,11 +2617,15 @@ void testRapidResetRejectsExcessivePeerCancellations() throws Exception { mux.onInput(ByteBuffer.wrap(encodeFrame(headers))); final RawFrame reset = FRAME_FACTORY.createResetStream(streamId, H2Error.CANCEL); if (streamId == 1) { - Assertions.assertDoesNotThrow(() -> mux.onInput(ByteBuffer.wrap(encodeFrame(reset)))); + Assertions.assertThatCode(() -> mux.onInput(ByteBuffer.wrap(encodeFrame(reset)))) + .doesNotThrowAnyException(); } else { - final H2ConnectionException ex = Assertions.assertThrows(H2ConnectionException.class, - () -> mux.onInput(ByteBuffer.wrap(encodeFrame(reset)))); - Assertions.assertEquals(H2Error.ENHANCE_YOUR_CALM, H2Error.getByCode(ex.getCode())); + Assertions.assertThatThrownBy(() -> + mux.onInput(ByteBuffer.wrap(encodeFrame(reset)))) + .isInstanceOf(H2ConnectionException.class) + .asInstanceOf(InstanceOfAssertFactories.type(H2ConnectionException.class)) + .extracting(ex -> H2Error.getByCode(ex.getCode())) + .isEqualTo(H2Error.ENHANCE_YOUR_CALM); } } } @@ -2652,7 +2643,8 @@ void testResetOfLocallyInitiatedStreamsDoesNotExhaustRemoteLimit() throws Except for (final int streamId : new int[] {1, 3}) { mux.createStream(mux.createChannel(streamId), streamHandler); final RawFrame reset = FRAME_FACTORY.createResetStream(streamId, H2Error.CANCEL); - Assertions.assertDoesNotThrow(() -> mux.onInput(ByteBuffer.wrap(encodeFrame(reset)))); + Assertions.assertThatCode(() -> mux.onInput(ByteBuffer.wrap(encodeFrame(reset)))) + .doesNotThrowAnyException(); } } diff --git a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestClientH2StreamHandler.java b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestClientH2StreamHandler.java index 17ef4fb80c..eeefb6f045 100644 --- a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestClientH2StreamHandler.java +++ b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestClientH2StreamHandler.java @@ -43,7 +43,7 @@ import org.apache.hc.core5.http.nio.HandlerFactory; import org.apache.hc.core5.http.protocol.HttpCoreContext; import org.apache.hc.core5.http.protocol.HttpProcessor; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; @@ -78,19 +78,21 @@ void prepareMocks() { @Test void defaults() { - Assertions.assertNotNull(handler.getPushHandlerFactory()); - Assertions.assertTrue(handler.isOutputReady()); + Assertions.assertThat(handler.getPushHandlerFactory()).isNotNull(); + Assertions.assertThat(handler.isOutputReady()).isTrue(); } @Test void consumePromiseRejected() { - Assertions.assertThrows(ProtocolException.class, () -> handler.consumePromise(null)); + Assertions.assertThatThrownBy(() -> + handler.consumePromise(null)) + .isInstanceOf(ProtocolException.class); } @Test void consumeDataRejectedBeforeHeaders() { - Assertions.assertThrows(ProtocolException.class, () -> - handler.consumeData(ByteBuffer.allocate(0), true)); + Assertions.assertThatThrownBy(() -> + handler.consumeData(ByteBuffer.allocate(0), true)).isInstanceOf(ProtocolException.class); } @Test @@ -103,8 +105,8 @@ void updateCapacityDelegates() throws Exception { @Test void toStringIncludesStates() { final String text = handler.toString(); - Assertions.assertTrue(text.contains("requestState")); - Assertions.assertTrue(text.contains("responseState")); + Assertions.assertThat(text.contains("requestState")).isTrue(); + Assertions.assertThat(text.contains("responseState")).isTrue(); } @Test @@ -116,7 +118,9 @@ void consumeTrailersWithPseudoHeaderRejected() throws Exception { final List
trailers = Collections.singletonList( new BasicHeader(":status", "200")); - Assertions.assertThrows(ProtocolException.class, () -> handler.consumeHeader(trailers, true)); + Assertions.assertThatThrownBy(() -> + handler.consumeHeader(trailers, true)) + .isInstanceOf(ProtocolException.class); Mockito.verify(exchangeHandler, Mockito.never()).streamEnd(Mockito.anyList()); } @@ -124,7 +128,9 @@ void consumeTrailersWithPseudoHeaderRejected() throws Exception { void informationalResponseWithEndStreamRejected() throws HttpException, IOException { final List
responseHeaders = Collections.singletonList( new BasicHeader(":status", "103")); - Assertions.assertThrows(ProtocolException.class, () -> handler.consumeHeader(responseHeaders, true)); + Assertions.assertThatThrownBy(() -> + handler.consumeHeader(responseHeaders, true)) + .isInstanceOf(ProtocolException.class); Mockito.verify(exchangeHandler, Mockito.never()).consumeInformation(Mockito.any(), Mockito.any()); } @Test @@ -135,7 +141,9 @@ void consumeTrailersWithoutEndStreamRejected() throws Exception { final List
trailers = Collections.singletonList( new BasicHeader("x-checksum", "abc123")); - Assertions.assertThrows(ProtocolException.class, () -> handler.consumeHeader(trailers, false)); + Assertions.assertThatThrownBy(() -> + handler.consumeHeader(trailers, false)) + .isInstanceOf(ProtocolException.class); Mockito.verify(exchangeHandler, Mockito.never()).streamEnd(Mockito.anyList()); } @Test @@ -155,8 +163,8 @@ void contentLengthInvalid() throws Exception { new BasicHeader("content-length", "12")); handler.consumeHeader(responseHeaders, false); handler.consumeData(ByteBuffer.wrap(new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }), false); - Assertions.assertThrows(ProtocolException.class, () -> - handler.consumeData(ByteBuffer.wrap(new byte[] { 0, 1, 2 }), true)); + Assertions.assertThatThrownBy(() -> + handler.consumeData(ByteBuffer.wrap(new byte[]{0, 1, 2}), true)).isInstanceOf(ProtocolException.class); } @Test @@ -164,8 +172,8 @@ void contentLengthInvalidNoBody() throws Exception { final List
responseHeaders = Arrays.asList( new BasicHeader(":status", "200"), new BasicHeader("content-length", "12")); - Assertions.assertThrows(ProtocolException.class, () -> - handler.consumeHeader(responseHeaders, true)); + Assertions.assertThatThrownBy(() -> + handler.consumeHeader(responseHeaders, true)).isInstanceOf(ProtocolException.class); } } diff --git a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestClientH2StreamMultiplexer.java b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestClientH2StreamMultiplexer.java index d667037730..9eee6dd07b 100644 --- a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestClientH2StreamMultiplexer.java +++ b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestClientH2StreamMultiplexer.java @@ -37,7 +37,8 @@ import org.apache.hc.core5.http2.config.H2Param; import org.apache.hc.core5.http2.frame.DefaultFrameFactory; import org.apache.hc.core5.reactor.ProtocolIOSession; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; +import org.assertj.core.api.InstanceOfAssertFactories; import org.junit.jupiter.api.Test; import org.mockito.Mockito; @@ -62,9 +63,9 @@ private ClientH2StreamMultiplexer newMultiplexer() { @Test void validateSettingRejectsEnablePush1OnClient() { final ClientH2StreamMultiplexer multiplexer = newMultiplexer(); - final H2ConnectionException ex = Assertions.assertThrows(H2ConnectionException.class, () -> - multiplexer.validateSetting(H2Param.ENABLE_PUSH, 1)); - Assertions.assertEquals(H2Error.PROTOCOL_ERROR.getCode(), ex.getCode()); + final H2ConnectionException ex = Assertions.assertThatThrownBy(() -> + multiplexer.validateSetting(H2Param.ENABLE_PUSH, 1)).isInstanceOf(H2ConnectionException.class).asInstanceOf(InstanceOfAssertFactories.type(H2ConnectionException.class)).actual(); + Assertions.assertThat(ex.getCode()).isEqualTo(H2Error.PROTOCOL_ERROR.getCode()); } @Test @@ -76,23 +77,23 @@ void validateSettingAcceptsEnablePush0OnClient() throws Exception { @Test void validateSettingRejectsEnablePush2OnClient() { final ClientH2StreamMultiplexer multiplexer = newMultiplexer(); - final H2ConnectionException ex = Assertions.assertThrows(H2ConnectionException.class, () -> - multiplexer.validateSetting(H2Param.ENABLE_PUSH, 2)); - Assertions.assertEquals(H2Error.PROTOCOL_ERROR.getCode(), ex.getCode()); + final H2ConnectionException ex = Assertions.assertThatThrownBy(() -> + multiplexer.validateSetting(H2Param.ENABLE_PUSH, 2)).isInstanceOf(H2ConnectionException.class).asInstanceOf(InstanceOfAssertFactories.type(H2ConnectionException.class)).actual(); + Assertions.assertThat(ex.getCode()).isEqualTo(H2Error.PROTOCOL_ERROR.getCode()); } @Test void validateSettingRejectsEnablePushNegativeOnClient() { final ClientH2StreamMultiplexer multiplexer = newMultiplexer(); - final H2ConnectionException ex = Assertions.assertThrows(H2ConnectionException.class, () -> - multiplexer.validateSetting(H2Param.ENABLE_PUSH, -1)); - Assertions.assertEquals(H2Error.PROTOCOL_ERROR.getCode(), ex.getCode()); + final H2ConnectionException ex = Assertions.assertThatThrownBy(() -> + multiplexer.validateSetting(H2Param.ENABLE_PUSH, -1)).isInstanceOf(H2ConnectionException.class).asInstanceOf(InstanceOfAssertFactories.type(H2ConnectionException.class)).actual(); + Assertions.assertThat(ex.getCode()).isEqualTo(H2Error.PROTOCOL_ERROR.getCode()); } @Test void acceptHeaderFrameRejected() { final ClientH2StreamMultiplexer multiplexer = newMultiplexer(); - Assertions.assertThrows(H2ConnectionException.class, multiplexer::acceptHeaderFrame); + Assertions.assertThatThrownBy(multiplexer::acceptHeaderFrame).isInstanceOf(H2ConnectionException.class); } @Test @@ -103,23 +104,23 @@ void outgoingRequestCreatesHandler() { Mockito.mock(AsyncClientExchangeHandler.class), null, null); - Assertions.assertNotNull(handler); + Assertions.assertThat(handler).isNotNull(); } @Test void incomingRequestRejected() { final ClientH2StreamMultiplexer multiplexer = newMultiplexer(); - Assertions.assertThrows(H2ConnectionException.class, () -> - multiplexer.incomingRequest(Mockito.mock(H2StreamChannel.class))); + Assertions.assertThatThrownBy(() -> + multiplexer.incomingRequest(Mockito.mock(H2StreamChannel.class))).isInstanceOf(H2ConnectionException.class); } @Test void outgoingPushPromiseRejected() { final ClientH2StreamMultiplexer multiplexer = newMultiplexer(); - Assertions.assertThrows(H2ConnectionException.class, () -> + Assertions.assertThatThrownBy(() -> multiplexer.outgoingPushPromise( Mockito.mock(H2StreamChannel.class), - Mockito.mock(AsyncPushProducer.class))); + Mockito.mock(AsyncPushProducer.class))).isInstanceOf(H2ConnectionException.class); } @Test @@ -131,7 +132,7 @@ void incomingPushPromiseCreatesHandler() { final H2StreamHandler handler = multiplexer.incomingPushPromise( Mockito.mock(H2StreamChannel.class), pushHandlerFactory); - Assertions.assertNotNull(handler); + Assertions.assertThat(handler).isNotNull(); } @Test @@ -140,15 +141,15 @@ void allowGracefulAbortUsesRemoteClosed() { final H2Stream stream = Mockito.mock(H2Stream.class); Mockito.when(stream.isRemoteClosed()).thenReturn(true); Mockito.when(stream.isLocalClosed()).thenReturn(false); - Assertions.assertTrue(multiplexer.allowGracefulAbort(stream)); + Assertions.assertThat(multiplexer.allowGracefulAbort(stream)).isTrue(); } @Test void toStringContainsState() { final ClientH2StreamMultiplexer multiplexer = newMultiplexer(); final String text = multiplexer.toString(); - Assertions.assertTrue(text.startsWith("[")); - Assertions.assertTrue(text.endsWith("]")); + Assertions.assertThat(text.startsWith("[")).isTrue(); + Assertions.assertThat(text.endsWith("]")).isTrue(); } } diff --git a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestClientH2StreamMultiplexerFactory.java b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestClientH2StreamMultiplexerFactory.java index fe8a0484e5..e36c4fb329 100644 --- a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestClientH2StreamMultiplexerFactory.java +++ b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestClientH2StreamMultiplexerFactory.java @@ -30,7 +30,7 @@ import org.apache.hc.core5.http.nio.HandlerFactory; import org.apache.hc.core5.http.protocol.HttpProcessor; import org.apache.hc.core5.reactor.ProtocolIOSession; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.mockito.Mockito; @@ -48,7 +48,7 @@ void createUsesDefaults() { final ProtocolIOSession ioSession = Mockito.mock(ProtocolIOSession.class); final ClientH2StreamMultiplexer multiplexer = factory.create(ioSession); - Assertions.assertNotNull(multiplexer); + Assertions.assertThat(multiplexer).isNotNull(); } } diff --git a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestClientHttp1UpgradeHandler.java b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestClientHttp1UpgradeHandler.java index 83bf78e2fd..52884ca564 100644 --- a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestClientHttp1UpgradeHandler.java +++ b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestClientHttp1UpgradeHandler.java @@ -34,7 +34,7 @@ import org.apache.hc.core5.http.impl.nio.ClientHttp1StreamDuplexerFactory; import org.apache.hc.core5.http.protocol.HttpProcessor; import org.apache.hc.core5.reactor.ProtocolIOSession; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.mockito.Mockito; @@ -67,7 +67,7 @@ public void cancelled() { } }); - Assertions.assertSame(ioSession, completed.get()); + Assertions.assertThat(completed.get()).isSameAs(ioSession); Mockito.verify(ioSession).upgrade(Mockito.any()); } diff --git a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestClientHttpProtocolNegotiationStarter.java b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestClientHttpProtocolNegotiationStarter.java index 6cb9112157..295051ba74 100644 --- a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestClientHttpProtocolNegotiationStarter.java +++ b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestClientHttpProtocolNegotiationStarter.java @@ -42,7 +42,7 @@ import org.apache.hc.core5.reactor.ProtocolIOSession; import org.apache.hc.core5.reactor.ssl.TlsDetails; import org.apache.hc.core5.util.Timeout; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.mockito.Mockito; @@ -79,7 +79,7 @@ void forceHttp2UsesPrefaceHandlerAndTlsUpgrade() { final Object handler = starter.createHandler(ioSession, endpoint); - Assertions.assertTrue(handler instanceof ClientH2PrefaceHandler); + Assertions.assertThat(handler instanceof ClientH2PrefaceHandler).isTrue(); Mockito.verify(ioSession).registerProtocol(Mockito.eq(ApplicationProtocol.HTTP_1_1.id), Mockito.any()); Mockito.verify(ioSession).registerProtocol(Mockito.eq(ApplicationProtocol.HTTP_2.id), Mockito.any()); Mockito.verify(tlsStrategy).upgrade(ioSession, endpoint, HttpVersionPolicy.FORCE_HTTP_2, Timeout.ofSeconds(1), null); @@ -98,7 +98,7 @@ void forceHttp1UsesHttp1Handler() { final ProtocolIOSession ioSession = Mockito.mock(ProtocolIOSession.class); final Object handler = starter.createHandler(ioSession, null); - Assertions.assertTrue(handler instanceof ClientHttp1IOEventHandler); + Assertions.assertThat(handler instanceof ClientHttp1IOEventHandler).isTrue(); } @Test @@ -114,7 +114,7 @@ void negotiateUsesProtocolNegotiator() { final ProtocolIOSession ioSession = Mockito.mock(ProtocolIOSession.class); final Object handler = starter.createHandler(ioSession, null); - Assertions.assertTrue(handler instanceof HttpProtocolNegotiator); + Assertions.assertThat(handler instanceof HttpProtocolNegotiator).isTrue(); } @Test @@ -131,7 +131,9 @@ void forceHttp2TlsMissingAlpnFailsStrictHandshake() throws Exception { Mockito.when(ioSession.getTlsDetails()).thenReturn(new TlsDetails(null, null)); final ClientH2PrefaceHandler handler = (ClientH2PrefaceHandler) starter.createHandler(ioSession, null); - Assertions.assertThrows(ProtocolNegotiationException.class, () -> handler.connected(ioSession)); + Assertions.assertThatThrownBy(() -> + handler.connected(ioSession)) + .isInstanceOf(ProtocolNegotiationException.class); } @Test @@ -148,7 +150,9 @@ void forceHttp2TlsUnexpectedAlpnFailsHandshake() throws Exception { Mockito.when(ioSession.getTlsDetails()).thenReturn(new TlsDetails(null, ApplicationProtocol.HTTP_1_1.id)); final ClientH2PrefaceHandler handler = (ClientH2PrefaceHandler) starter.createHandler(ioSession, null); - Assertions.assertThrows(ProtocolNegotiationException.class, () -> handler.connected(ioSession)); + Assertions.assertThatThrownBy(() -> + handler.connected(ioSession)) + .isInstanceOf(ProtocolNegotiationException.class); } } diff --git a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestClientPushH2StreamHandler.java b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestClientPushH2StreamHandler.java index aa0dc947ca..e9bffe531f 100644 --- a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestClientPushH2StreamHandler.java +++ b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestClientPushH2StreamHandler.java @@ -41,7 +41,8 @@ import org.apache.hc.core5.http.protocol.HttpProcessor; import org.apache.hc.core5.http2.H2Error; import org.apache.hc.core5.http2.H2StreamResetException; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; +import org.assertj.core.api.InstanceOfAssertFactories; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; @@ -75,24 +76,24 @@ void prepareMocks() { @Test void consumePromiseRefusedWhenFactoryReturnsNull() throws Exception { - final H2StreamResetException ex = Assertions.assertThrows(H2StreamResetException.class, () -> + final H2StreamResetException ex = Assertions.assertThatThrownBy(() -> handler.consumePromise(java.util.Arrays.asList( new BasicHeader(":method", "GET"), new BasicHeader(":scheme", "https"), new BasicHeader(":authority", "example.com"), - new BasicHeader(":path", "/")))); - Assertions.assertEquals(H2Error.REFUSED_STREAM.getCode(), ex.getCode()); + new BasicHeader(":path", "/")))).isInstanceOf(H2StreamResetException.class).asInstanceOf(InstanceOfAssertFactories.type(H2StreamResetException.class)).actual(); + Assertions.assertThat(ex.getCode()).isEqualTo(H2Error.REFUSED_STREAM.getCode()); } @Test void consumeDataRejectedBeforeBody() { - Assertions.assertThrows(ProtocolException.class, () -> - handler.consumeData(ByteBuffer.allocate(0), true)); + Assertions.assertThatThrownBy(() -> + handler.consumeData(ByteBuffer.allocate(0), true)).isInstanceOf(ProtocolException.class); } @Test void updateCapacityFailsWithoutHandler() { - Assertions.assertThrows(IllegalStateException.class, handler::updateInputCapacity); + Assertions.assertThatThrownBy(handler::updateInputCapacity).isInstanceOf(IllegalStateException.class); } @Test @@ -126,8 +127,8 @@ void contentLengthInvalid() throws Exception { new BasicHeader("content-length", "12")); handler.consumeHeader(responseHeaders, false); handler.consumeData(ByteBuffer.wrap(new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }), false); - Assertions.assertThrows(ProtocolException.class, () -> - handler.consumeData(ByteBuffer.wrap(new byte[] { 0, 1, 2 }), true)); + Assertions.assertThatThrownBy(() -> + handler.consumeData(ByteBuffer.wrap(new byte[]{0, 1, 2}), true)).isInstanceOf(ProtocolException.class); } @Test @@ -142,8 +143,8 @@ void contentLengthInvalidNoBody() throws Exception { final List
responseHeaders = Arrays.asList( new BasicHeader(":status", "200"), new BasicHeader("content-length", "12")); - Assertions.assertThrows(ProtocolException.class, () -> - handler.consumeHeader(responseHeaders, true)); + Assertions.assertThatThrownBy(() -> + handler.consumeHeader(responseHeaders, true)).isInstanceOf(ProtocolException.class); } @@ -179,9 +180,9 @@ void informationalPushResponseWithEndStreamRejected() throws Exception { new BasicHeader(":authority", "example.com"), new BasicHeader(":path", "/"))); - Assertions.assertThrows(ProtocolException.class, () -> + Assertions.assertThatThrownBy(() -> handler.consumeHeader(Arrays.asList( - new BasicHeader(":status", "103")), true)); + new BasicHeader(":status", "103")), true)).isInstanceOf(ProtocolException.class); } @Test @@ -217,9 +218,9 @@ void pushResponseTrailersWithoutEndStreamRejected() throws Exception { handler.consumeHeader(Arrays.asList( new BasicHeader(":status", "200")), false); - Assertions.assertThrows(ProtocolException.class, () -> + Assertions.assertThatThrownBy(() -> handler.consumeHeader(Arrays.asList( - new BasicHeader("x-checksum", "abc123")), false)); + new BasicHeader("x-checksum", "abc123")), false)).isInstanceOf(ProtocolException.class); } @Test @@ -236,9 +237,9 @@ void pushResponseContentLengthMismatchWithTrailersRejected() throws Exception { new BasicHeader("content-length", "3")), false); handler.consumeData(ByteBuffer.wrap(new byte[] { 0, 1 }), false); - Assertions.assertThrows(ProtocolException.class, () -> + Assertions.assertThatThrownBy(() -> handler.consumeHeader(Arrays.asList( - new BasicHeader("x-checksum", "abc123")), true)); + new BasicHeader("x-checksum", "abc123")), true)).isInstanceOf(ProtocolException.class); } diff --git a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestFrameInOutBuffers.java b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestFrameInOutBuffers.java index a415b60da5..b67b62de6b 100644 --- a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestFrameInOutBuffers.java +++ b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestFrameInOutBuffers.java @@ -38,7 +38,7 @@ import org.apache.hc.core5.http2.frame.FrameType; import org.apache.hc.core5.http2.frame.RawFrame; import org.apache.hc.core5.http2.impl.BasicH2TransportMetrics; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class TestFrameInOutBuffers { @@ -54,44 +54,44 @@ void testReadWriteFrame() throws Exception { final FrameInputBuffer inBuffer = new FrameInputBuffer(16 * 1024); final byte[] bytes = writableChannel.toByteArray(); - Assertions.assertEquals(FrameConsts.HEAD_LEN + 5, bytes.length); + Assertions.assertThat(bytes.length).isEqualTo(FrameConsts.HEAD_LEN + 5); - Assertions.assertEquals(1, outbuffer.getMetrics().getFramesTransferred()); - Assertions.assertEquals(bytes.length, outbuffer.getMetrics().getBytesTransferred()); + Assertions.assertThat(outbuffer.getMetrics().getFramesTransferred()).isEqualTo(1); + Assertions.assertThat(outbuffer.getMetrics().getBytesTransferred()).isEqualTo(bytes.length); final ReadableByteChannelMock readableChannel = new ReadableByteChannelMock(bytes); final RawFrame frame2 = inBuffer.read(readableChannel); - Assertions.assertEquals(FrameType.DATA.getValue(), frame2.getType()); - Assertions.assertEquals(0, frame2.getFlags()); - Assertions.assertEquals(1L, frame2.getStreamId()); + Assertions.assertThat(frame2.getType()).isEqualTo(FrameType.DATA.getValue()); + Assertions.assertThat(frame2.getFlags()).isEqualTo(0); + Assertions.assertThat(frame2.getStreamId()).isEqualTo(1L); final ByteBuffer payload2 = frame2.getPayloadContent(); - Assertions.assertNotNull(payload2); - Assertions.assertEquals(5, payload2.remaining()); - Assertions.assertEquals(1, payload2.get()); - Assertions.assertEquals(2, payload2.get()); - Assertions.assertEquals(3, payload2.get()); - Assertions.assertEquals(4, payload2.get()); - Assertions.assertEquals(5, payload2.get()); - Assertions.assertEquals(-1, readableChannel.read(ByteBuffer.allocate(1024))); - - Assertions.assertEquals(1, inBuffer.getMetrics().getFramesTransferred()); - Assertions.assertEquals(bytes.length, inBuffer.getMetrics().getBytesTransferred()); + Assertions.assertThat(payload2).isNotNull(); + Assertions.assertThat(payload2.remaining()).isEqualTo(5); + Assertions.assertThat(payload2.get()).isEqualTo((byte) 1); + Assertions.assertThat(payload2.get()).isEqualTo((byte) 2); + Assertions.assertThat(payload2.get()).isEqualTo((byte) 3); + Assertions.assertThat(payload2.get()).isEqualTo((byte) 4); + Assertions.assertThat(payload2.get()).isEqualTo((byte) 5); + Assertions.assertThat(readableChannel.read(ByteBuffer.allocate(1024))).isEqualTo(-1); + + Assertions.assertThat(inBuffer.getMetrics().getFramesTransferred()).isEqualTo(1); + Assertions.assertThat(inBuffer.getMetrics().getBytesTransferred()).isEqualTo(bytes.length); final RawFrame frame3 = inBuffer.read(ByteBuffer.wrap(bytes), readableChannel); - Assertions.assertEquals(FrameType.DATA.getValue(), frame3.getType()); - Assertions.assertEquals(0, frame3.getFlags()); - Assertions.assertEquals(1L, frame3.getStreamId()); + Assertions.assertThat(frame3.getType()).isEqualTo(FrameType.DATA.getValue()); + Assertions.assertThat(frame3.getFlags()).isEqualTo(0); + Assertions.assertThat(frame3.getStreamId()).isEqualTo(1L); final ByteBuffer payload3 = frame3.getPayloadContent(); - Assertions.assertNotNull(payload3); - Assertions.assertEquals(5, payload3.remaining()); - Assertions.assertEquals(1, payload3.get()); - Assertions.assertEquals(2, payload3.get()); - Assertions.assertEquals(3, payload3.get()); - Assertions.assertEquals(4, payload3.get()); - Assertions.assertEquals(5, payload3.get()); - - Assertions.assertEquals(2, inBuffer.getMetrics().getFramesTransferred()); - Assertions.assertEquals(bytes.length * 2, inBuffer.getMetrics().getBytesTransferred()); + Assertions.assertThat(payload3).isNotNull(); + Assertions.assertThat(payload3.remaining()).isEqualTo(5); + Assertions.assertThat(payload3.get()).isEqualTo((byte) 1); + Assertions.assertThat(payload3.get()).isEqualTo((byte) 2); + Assertions.assertThat(payload3.get()).isEqualTo((byte) 3); + Assertions.assertThat(payload3.get()).isEqualTo((byte) 4); + Assertions.assertThat(payload3.get()).isEqualTo((byte) 5); + + Assertions.assertThat(inBuffer.getMetrics().getFramesTransferred()).isEqualTo(2); + Assertions.assertThat(inBuffer.getMetrics().getBytesTransferred()).isEqualTo(bytes.length * 2); } @Test @@ -102,18 +102,18 @@ void testPartialFrameWrite() throws Exception { ByteBuffer.wrap(new byte[]{'0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'})); outbuffer.write(frame, writableChannel); - Assertions.assertArrayEquals(new byte[] {0,0,16,0,1,0,0,0,5,48,49,50,51,52,53,54,55,56,57}, - writableChannel.toByteArray()); + Assertions.assertThat(writableChannel.toByteArray()) + .containsExactly(new byte[]{0, 0, 16, 0, 1, 0, 0, 0, 5, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57}); - Assertions.assertFalse(outbuffer.isEmpty()); + Assertions.assertThat(outbuffer.isEmpty()).isFalse(); outbuffer.flush(writableChannel); - Assertions.assertArrayEquals(new byte[] {0,0,16,0,1,0,0,0,5,48,49,50,51,52,53,54,55,56,57}, - writableChannel.toByteArray()); + Assertions.assertThat(writableChannel.toByteArray()) + .containsExactly(new byte[]{0, 0, 16, 0, 1, 0, 0, 0, 5, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57}); writableChannel.flush(); outbuffer.flush(writableChannel); - Assertions.assertArrayEquals(new byte[] {0,0,16,0,1,0,0,0,5,48,49,50,51,52,53,54,55,56,57,97,98,99,100,101,102}, - writableChannel.toByteArray()); + Assertions.assertThat(writableChannel.toByteArray()) + .containsExactly(new byte[]{0, 0, 16, 0, 1, 0, 0, 0, 5, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102}); } @Test @@ -126,32 +126,32 @@ void testReadFrameMultiple() throws Exception { }); final RawFrame frame1 = inBuffer.read(readableChannel); - Assertions.assertEquals(FrameType.DATA, FrameType.valueOf(frame1.getType())); - Assertions.assertEquals(8, frame1.getFlags()); - Assertions.assertEquals(8, frame1.getStreamId()); + Assertions.assertThat(FrameType.valueOf(frame1.getType())).isEqualTo(FrameType.DATA); + Assertions.assertThat(frame1.getFlags()).isEqualTo(8); + Assertions.assertThat(frame1.getStreamId()).isEqualTo(8); final ByteBuffer payload1 = frame1.getPayloadContent(); - Assertions.assertNotNull(payload1); - Assertions.assertEquals(5, payload1.remaining()); - Assertions.assertEquals(0, payload1.get()); - Assertions.assertEquals(1, payload1.get()); - Assertions.assertEquals(2, payload1.get()); - Assertions.assertEquals(3, payload1.get()); - Assertions.assertEquals(4, payload1.get()); + Assertions.assertThat(payload1).isNotNull(); + Assertions.assertThat(payload1.remaining()).isEqualTo(5); + Assertions.assertThat(payload1.get()).isEqualTo((byte) 0); + Assertions.assertThat(payload1.get()).isEqualTo((byte) 1); + Assertions.assertThat(payload1.get()).isEqualTo((byte) 2); + Assertions.assertThat(payload1.get()).isEqualTo((byte) 3); + Assertions.assertThat(payload1.get()).isEqualTo((byte) 4); final RawFrame frame2 = inBuffer.read(readableChannel); - Assertions.assertEquals(FrameType.DATA, FrameType.valueOf(frame2.getType())); - Assertions.assertEquals(FrameFlag.of(FrameFlag.END_STREAM, FrameFlag.PADDED), frame2.getFlags()); - Assertions.assertEquals(8, frame2.getStreamId()); + Assertions.assertThat(FrameType.valueOf(frame2.getType())).isEqualTo(FrameType.DATA); + Assertions.assertThat(frame2.getFlags()).isEqualTo(FrameFlag.of(FrameFlag.END_STREAM, FrameFlag.PADDED)); + Assertions.assertThat(frame2.getStreamId()).isEqualTo(8); final ByteBuffer payload2 = frame2.getPayloadContent(); - Assertions.assertNotNull(payload2); - Assertions.assertEquals(5, payload2.remaining()); - Assertions.assertEquals(5, payload2.get()); - Assertions.assertEquals(6, payload2.get()); - Assertions.assertEquals(7, payload2.get()); - Assertions.assertEquals(8, payload2.get()); - Assertions.assertEquals(9, payload2.get()); - - Assertions.assertEquals(-1, readableChannel.read(ByteBuffer.allocate(1024))); + Assertions.assertThat(payload2).isNotNull(); + Assertions.assertThat(payload2.remaining()).isEqualTo(5); + Assertions.assertThat(payload2.get()).isEqualTo((byte) 5); + Assertions.assertThat(payload2.get()).isEqualTo((byte) 6); + Assertions.assertThat(payload2.get()).isEqualTo((byte) 7); + Assertions.assertThat(payload2.get()).isEqualTo((byte) 8); + Assertions.assertThat(payload2.get()).isEqualTo((byte) 9); + + Assertions.assertThat(readableChannel.read(ByteBuffer.allocate(1024))).isEqualTo(-1); } @Test @@ -165,45 +165,45 @@ void testReadFrameMultipleSmallBuffer() throws Exception { }); final RawFrame frame1 = inBuffer.read(readableChannel); - Assertions.assertEquals(FrameType.DATA, FrameType.valueOf(frame1.getType())); - Assertions.assertEquals(8, frame1.getFlags()); - Assertions.assertEquals(8, frame1.getStreamId()); + Assertions.assertThat(FrameType.valueOf(frame1.getType())).isEqualTo(FrameType.DATA); + Assertions.assertThat(frame1.getFlags()).isEqualTo(8); + Assertions.assertThat(frame1.getStreamId()).isEqualTo(8); final ByteBuffer payload1 = frame1.getPayloadContent(); - Assertions.assertNotNull(payload1); - Assertions.assertEquals(5, payload1.remaining()); - Assertions.assertEquals(1, payload1.get()); - Assertions.assertEquals(1, payload1.get()); - Assertions.assertEquals(1, payload1.get()); - Assertions.assertEquals(1, payload1.get()); - Assertions.assertEquals(1, payload1.get()); + Assertions.assertThat(payload1).isNotNull(); + Assertions.assertThat(payload1.remaining()).isEqualTo(5); + Assertions.assertThat(payload1.get()).isEqualTo((byte) 1); + Assertions.assertThat(payload1.get()).isEqualTo((byte) 1); + Assertions.assertThat(payload1.get()).isEqualTo((byte) 1); + Assertions.assertThat(payload1.get()).isEqualTo((byte) 1); + Assertions.assertThat(payload1.get()).isEqualTo((byte) 1); final RawFrame frame2 = inBuffer.read(readableChannel); - Assertions.assertEquals(FrameType.DATA, FrameType.valueOf(frame2.getType())); - Assertions.assertEquals(0, frame2.getFlags()); - Assertions.assertEquals(8, frame2.getStreamId()); + Assertions.assertThat(FrameType.valueOf(frame2.getType())).isEqualTo(FrameType.DATA); + Assertions.assertThat(frame2.getFlags()).isEqualTo(0); + Assertions.assertThat(frame2.getStreamId()).isEqualTo(8); final ByteBuffer payload2 = frame2.getPayloadContent(); - Assertions.assertNotNull(payload2); - Assertions.assertEquals(5, payload2.remaining()); - Assertions.assertEquals(2, payload2.get()); - Assertions.assertEquals(2, payload2.get()); - Assertions.assertEquals(2, payload2.get()); - Assertions.assertEquals(2, payload2.get()); - Assertions.assertEquals(2, payload2.get()); + Assertions.assertThat(payload2).isNotNull(); + Assertions.assertThat(payload2.remaining()).isEqualTo(5); + Assertions.assertThat(payload2.get()).isEqualTo((byte) 2); + Assertions.assertThat(payload2.get()).isEqualTo((byte) 2); + Assertions.assertThat(payload2.get()).isEqualTo((byte) 2); + Assertions.assertThat(payload2.get()).isEqualTo((byte) 2); + Assertions.assertThat(payload2.get()).isEqualTo((byte) 2); final RawFrame frame3 = inBuffer.read(readableChannel); - Assertions.assertEquals(FrameType.DATA, FrameType.valueOf(frame3.getType())); - Assertions.assertEquals(FrameFlag.of(FrameFlag.END_STREAM, FrameFlag.PADDED), frame3.getFlags()); - Assertions.assertEquals(8, frame3.getStreamId()); + Assertions.assertThat(FrameType.valueOf(frame3.getType())).isEqualTo(FrameType.DATA); + Assertions.assertThat(frame3.getFlags()).isEqualTo(FrameFlag.of(FrameFlag.END_STREAM, FrameFlag.PADDED)); + Assertions.assertThat(frame3.getStreamId()).isEqualTo(8); final ByteBuffer payload3 = frame3.getPayloadContent(); - Assertions.assertNotNull(payload3); - Assertions.assertEquals(5, payload3.remaining()); - Assertions.assertEquals(3, payload3.get()); - Assertions.assertEquals(3, payload3.get()); - Assertions.assertEquals(3, payload3.get()); - Assertions.assertEquals(3, payload3.get()); - Assertions.assertEquals(3, payload3.get()); - - Assertions.assertEquals(-1, readableChannel.read(ByteBuffer.allocate(1024))); + Assertions.assertThat(payload3).isNotNull(); + Assertions.assertThat(payload3.remaining()).isEqualTo(5); + Assertions.assertThat(payload3.get()).isEqualTo((byte) 3); + Assertions.assertThat(payload3.get()).isEqualTo((byte) 3); + Assertions.assertThat(payload3.get()).isEqualTo((byte) 3); + Assertions.assertThat(payload3.get()).isEqualTo((byte) 3); + Assertions.assertThat(payload3.get()).isEqualTo((byte) 3); + + Assertions.assertThat(readableChannel.read(ByteBuffer.allocate(1024))).isEqualTo(-1); } @Test @@ -219,19 +219,19 @@ void testReadFramePartialReads() throws Exception { new byte[] {0,0,0}); final RawFrame frame = inBuffer.read(readableChannel); - Assertions.assertEquals(FrameType.DATA, FrameType.valueOf(frame.getType())); - Assertions.assertEquals(FrameFlag.of(FrameFlag.END_STREAM, FrameFlag.PADDED), frame.getFlags()); - Assertions.assertEquals(8, frame.getStreamId()); + Assertions.assertThat(FrameType.valueOf(frame.getType())).isEqualTo(FrameType.DATA); + Assertions.assertThat(frame.getFlags()).isEqualTo(FrameFlag.of(FrameFlag.END_STREAM, FrameFlag.PADDED)); + Assertions.assertThat(frame.getStreamId()).isEqualTo(8); final ByteBuffer payload = frame.getPayloadContent(); - Assertions.assertNotNull(payload); - Assertions.assertEquals(5, payload.remaining()); - Assertions.assertEquals(1, payload.get()); - Assertions.assertEquals(2, payload.get()); - Assertions.assertEquals(3, payload.get()); - Assertions.assertEquals(4, payload.get()); - Assertions.assertEquals(5, payload.get()); - - Assertions.assertEquals(-1, readableChannel.read(ByteBuffer.allocate(1024))); + Assertions.assertThat(payload).isNotNull(); + Assertions.assertThat(payload.remaining()).isEqualTo(5); + Assertions.assertThat(payload.get()).isEqualTo((byte) 1); + Assertions.assertThat(payload.get()).isEqualTo((byte) 2); + Assertions.assertThat(payload.get()).isEqualTo((byte) 3); + Assertions.assertThat(payload.get()).isEqualTo((byte) 4); + Assertions.assertThat(payload.get()).isEqualTo((byte) 5); + + Assertions.assertThat(readableChannel.read(ByteBuffer.allocate(1024))).isEqualTo(-1); } @Test @@ -241,11 +241,11 @@ void testReadEmptyFrame() throws Exception { new byte[] {0,0,0,0,0,0,0,0,0}); final RawFrame frame = inBuffer.read(readableChannel); - Assertions.assertEquals(FrameType.DATA, FrameType.valueOf(frame.getType())); - Assertions.assertEquals(0, frame.getFlags()); - Assertions.assertEquals(0, frame.getStreamId()); + Assertions.assertThat(FrameType.valueOf(frame.getType())).isEqualTo(FrameType.DATA); + Assertions.assertThat(frame.getFlags()).isEqualTo(0); + Assertions.assertThat(frame.getStreamId()).isEqualTo(0); final ByteBuffer payload = frame.getPayloadContent(); - Assertions.assertNull(payload); + Assertions.assertThat(payload).isNull(); } @Test @@ -253,12 +253,12 @@ void testReadFrameConnectionClosed() throws Exception { final FrameInputBuffer inBuffer = new FrameInputBuffer(16 * 1024); final ReadableByteChannelMock readableChannel = new ReadableByteChannelMock(new byte[] {}); - Assertions.assertNull(inBuffer.read(readableChannel)); - Assertions.assertFalse(inBuffer.isEndOfStream()); - Assertions.assertNull(inBuffer.read(readableChannel)); - Assertions.assertTrue(inBuffer.isEndOfStream()); - Assertions.assertNull(inBuffer.read(readableChannel)); - Assertions.assertTrue(inBuffer.isEndOfStream()); + Assertions.assertThat(inBuffer.read(readableChannel)).isNull(); + Assertions.assertThat(inBuffer.isEndOfStream()).isFalse(); + Assertions.assertThat(inBuffer.read(readableChannel)).isNull(); + Assertions.assertThat(inBuffer.isEndOfStream()).isTrue(); + Assertions.assertThat(inBuffer.read(readableChannel)).isNull(); + Assertions.assertThat(inBuffer.isEndOfStream()).isTrue(); } @Test @@ -266,8 +266,8 @@ void testReadFrameCorruptFrame() { final FrameInputBuffer inBuffer = new FrameInputBuffer(16 * 1024); final ReadableByteChannelMock readableChannel = new ReadableByteChannelMock(new byte[] {0,0}); - Assertions.assertThrows(H2CorruptFrameException.class, () -> - inBuffer.read(readableChannel)); + Assertions.assertThatThrownBy(() -> + inBuffer.read(readableChannel)).isInstanceOf(H2CorruptFrameException.class); } @Test @@ -277,8 +277,8 @@ void testWriteFrameExceedingLimit() { final RawFrame frame = new RawFrame(FrameType.DATA.getValue(), 0, 1, ByteBuffer.wrap(new byte[2048])); - Assertions.assertThrows(IllegalArgumentException.class, () -> - outbuffer.write(frame, writableChannel)); + Assertions.assertThatThrownBy(() -> + outbuffer.write(frame, writableChannel)).isInstanceOf(IllegalArgumentException.class); } @Test @@ -287,16 +287,16 @@ void testReadFrameExceedingLimit() { final ReadableByteChannelMock readableChannel = new ReadableByteChannelMock( new byte[] {0,-128,-128,0,0,0,0,0,1}); - Assertions.assertThrows(H2ConnectionException.class, () -> - inBuffer.read(readableChannel)); + Assertions.assertThatThrownBy(() -> + inBuffer.read(readableChannel)).isInstanceOf(H2ConnectionException.class); } @Test void testOutputBufferResize() { final FrameOutputBuffer outBuffer = new FrameOutputBuffer(16 * 1024); - Assertions.assertEquals(16 * 1024, outBuffer.getMaxFramePayloadSize()); + Assertions.assertThat(outBuffer.getMaxFramePayloadSize()).isEqualTo(16 * 1024); outBuffer.resize(1024); - Assertions.assertEquals(1024, outBuffer.getMaxFramePayloadSize()); + Assertions.assertThat(outBuffer.getMaxFramePayloadSize()).isEqualTo(1024); } } diff --git a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestFrameInputBuffer.java b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestFrameInputBuffer.java index baa29c6389..f9889b17ec 100644 --- a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestFrameInputBuffer.java +++ b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestFrameInputBuffer.java @@ -26,10 +26,6 @@ */ package org.apache.hc.core5.http2.impl.nio; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static org.junit.jupiter.api.Assertions.assertThrows; - import java.io.ByteArrayInputStream; import java.nio.channels.Channels; import java.nio.channels.ReadableByteChannel; @@ -37,6 +33,8 @@ import org.apache.hc.core5.http2.H2ConnectionException; import org.apache.hc.core5.http2.H2Error; import org.apache.hc.core5.http2.frame.RawFrame; +import org.assertj.core.api.Assertions; +import org.assertj.core.api.InstanceOfAssertFactories; import org.junit.jupiter.api.Test; class TestFrameInputBuffer { @@ -63,8 +61,10 @@ void payloadLengthWithHighBitMustTriggerFrameSizeError() throws Exception { final FrameInputBuffer inBuf = new FrameInputBuffer(16 * 1024); final ReadableByteChannel ch = Channels.newChannel(new ByteArrayInputStream(frame)); - final H2ConnectionException ex = assertThrows(H2ConnectionException.class, () -> inBuf.read(ch)); - assertEquals(H2Error.FRAME_SIZE_ERROR.getCode(), ex.getCode()); + final H2ConnectionException ex = Assertions.assertThatThrownBy(() -> + inBuf.read(ch)) + .isInstanceOf(H2ConnectionException.class).asInstanceOf(InstanceOfAssertFactories.type(H2ConnectionException.class)).actual(); + Assertions.assertThat(ex.getCode()).isEqualTo(H2Error.FRAME_SIZE_ERROR.getCode()); } @Test @@ -81,8 +81,8 @@ void flagsMustBeTreatedAsUnsignedByte() throws Exception { final ReadableByteChannel ch = Channels.newChannel(new ByteArrayInputStream(frame)); final RawFrame rawFrame = inBuf.read(ch); - assertNotNull(rawFrame); - assertEquals(0x80, rawFrame.getFlags()); + Assertions.assertThat(rawFrame).isNotNull(); + Assertions.assertThat(rawFrame.getFlags()).isEqualTo(0x80); } @Test @@ -103,8 +103,8 @@ void streamIdReservedBitMustBeIgnored() throws Exception { final ReadableByteChannel ch = Channels.newChannel(new ByteArrayInputStream(frame)); final RawFrame rawFrame = inBuf.read(ch); - assertNotNull(rawFrame); - assertEquals(1, rawFrame.getStreamId()); + Assertions.assertThat(rawFrame).isNotNull(); + Assertions.assertThat(rawFrame.getStreamId()).isEqualTo(1); } @Test @@ -120,14 +120,14 @@ void paddedBitOnUnknownFrameTypeMustBeIgnored() throws Exception { final ReadableByteChannel ch = Channels.newChannel(new ByteArrayInputStream(frame)); final RawFrame rawFrame = inBuf.read(ch); - assertNotNull(rawFrame); - assertEquals(0x0a, rawFrame.getType()); - assertEquals(0x08, rawFrame.getFlags()); - assertEquals(1, rawFrame.getStreamId()); - assertEquals(1, rawFrame.getLength()); - assertNotNull(rawFrame.getPayload()); - assertEquals(1, rawFrame.getPayload().remaining()); - assertEquals(0x2a, rawFrame.getPayload().get() & 0xff); + Assertions.assertThat(rawFrame).isNotNull(); + Assertions.assertThat(rawFrame.getType()).isEqualTo(0x0a); + Assertions.assertThat(rawFrame.getFlags()).isEqualTo(0x08); + Assertions.assertThat(rawFrame.getStreamId()).isEqualTo(1); + Assertions.assertThat(rawFrame.getLength()).isEqualTo(1); + Assertions.assertThat(rawFrame.getPayload()).isNotNull(); + Assertions.assertThat(rawFrame.getPayload().remaining()).isEqualTo(1); + Assertions.assertThat(rawFrame.getPayload().get() & 0xff).isEqualTo(0x2a); } @Test @@ -143,7 +143,9 @@ void paddedSemanticsStillApplyToDataFrames() throws Exception { final FrameInputBuffer inBuf = new FrameInputBuffer(16 * 1024); final ReadableByteChannel ch = Channels.newChannel(new ByteArrayInputStream(frame)); - final H2ConnectionException ex = assertThrows(H2ConnectionException.class, () -> inBuf.read(ch)); - assertEquals(H2Error.PROTOCOL_ERROR.getCode(), ex.getCode()); + final H2ConnectionException ex = Assertions.assertThatThrownBy(() -> + inBuf.read(ch)) + .isInstanceOf(H2ConnectionException.class).asInstanceOf(InstanceOfAssertFactories.type(H2ConnectionException.class)).actual(); + Assertions.assertThat(ex.getCode()).isEqualTo(H2Error.PROTOCOL_ERROR.getCode()); } } diff --git a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestNoopAsyncPushHandler.java b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestNoopAsyncPushHandler.java index 1c15cc0d2c..8b71a97112 100644 --- a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestNoopAsyncPushHandler.java +++ b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestNoopAsyncPushHandler.java @@ -30,7 +30,7 @@ import java.util.Collections; import org.apache.hc.core5.http.nio.CapacityChannel; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.mockito.Mockito; @@ -50,10 +50,10 @@ void updateCapacityAllowsAnyPayload() throws Exception { void noOpsDoNotThrow() throws Exception { final NoopAsyncPushHandler handler = new NoopAsyncPushHandler(); - Assertions.assertDoesNotThrow(() -> handler.consume(ByteBuffer.allocate(0))); - Assertions.assertDoesNotThrow(() -> handler.streamEnd(Collections.emptyList())); - Assertions.assertDoesNotThrow(() -> handler.failed(new RuntimeException("boom"))); - Assertions.assertDoesNotThrow(handler::releaseResources); + Assertions.assertThatCode(() -> handler.consume(ByteBuffer.allocate(0))).doesNotThrowAnyException(); + Assertions.assertThatCode(() -> handler.streamEnd(Collections.emptyList())).doesNotThrowAnyException(); + Assertions.assertThatCode(() -> handler.failed(new RuntimeException("boom"))).doesNotThrowAnyException(); + Assertions.assertThatCode(handler::releaseResources).doesNotThrowAnyException(); } } diff --git a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestNoopH2StreamHandler.java b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestNoopH2StreamHandler.java index 2b6573e86d..074415e434 100644 --- a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestNoopH2StreamHandler.java +++ b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestNoopH2StreamHandler.java @@ -30,28 +30,28 @@ import java.util.Collections; import org.apache.hc.core5.http.HttpException; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class TestNoopH2StreamHandler { @Test void singletonDefaults() { - Assertions.assertSame(NoopH2StreamHandler.INSTANCE, NoopH2StreamHandler.INSTANCE); - Assertions.assertFalse(NoopH2StreamHandler.INSTANCE.isOutputReady()); - Assertions.assertNull(NoopH2StreamHandler.INSTANCE.getPushHandlerFactory()); + Assertions.assertThat(NoopH2StreamHandler.INSTANCE).isSameAs(NoopH2StreamHandler.INSTANCE); + Assertions.assertThat(NoopH2StreamHandler.INSTANCE.isOutputReady()).isFalse(); + Assertions.assertThat(NoopH2StreamHandler.INSTANCE.getPushHandlerFactory()).isNull(); } @Test void noOpsDoNotThrow() throws Exception { - Assertions.assertDoesNotThrow(() -> NoopH2StreamHandler.INSTANCE.produceOutput()); - Assertions.assertDoesNotThrow(() -> NoopH2StreamHandler.INSTANCE.consumePromise(Collections.emptyList())); - Assertions.assertDoesNotThrow(() -> NoopH2StreamHandler.INSTANCE.consumeHeader(Collections.emptyList(), false)); - Assertions.assertDoesNotThrow(() -> NoopH2StreamHandler.INSTANCE.updateInputCapacity()); - Assertions.assertDoesNotThrow(() -> NoopH2StreamHandler.INSTANCE.consumeData(ByteBuffer.allocate(0), true)); - Assertions.assertDoesNotThrow(() -> NoopH2StreamHandler.INSTANCE.failed(new RuntimeException("boom"))); - Assertions.assertDoesNotThrow(() -> NoopH2StreamHandler.INSTANCE.handle(new HttpException("oops"), true)); - Assertions.assertDoesNotThrow(NoopH2StreamHandler.INSTANCE::releaseResources); + Assertions.assertThatCode(() -> NoopH2StreamHandler.INSTANCE.produceOutput()).doesNotThrowAnyException(); + Assertions.assertThatCode(() -> NoopH2StreamHandler.INSTANCE.consumePromise(Collections.emptyList())).doesNotThrowAnyException(); + Assertions.assertThatCode(() -> NoopH2StreamHandler.INSTANCE.consumeHeader(Collections.emptyList(), false)).doesNotThrowAnyException(); + Assertions.assertThatCode(() -> NoopH2StreamHandler.INSTANCE.updateInputCapacity()).doesNotThrowAnyException(); + Assertions.assertThatCode(() -> NoopH2StreamHandler.INSTANCE.consumeData(ByteBuffer.allocate(0), true)).doesNotThrowAnyException(); + Assertions.assertThatCode(() -> NoopH2StreamHandler.INSTANCE.failed(new RuntimeException("boom"))).doesNotThrowAnyException(); + Assertions.assertThatCode(() -> NoopH2StreamHandler.INSTANCE.handle(new HttpException("oops"), true)).doesNotThrowAnyException(); + Assertions.assertThatCode(NoopH2StreamHandler.INSTANCE::releaseResources).doesNotThrowAnyException(); } } diff --git a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestPrefaceHandlerBase.java b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestPrefaceHandlerBase.java index 9bd54cf13e..eb51ab94df 100644 --- a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestPrefaceHandlerBase.java +++ b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestPrefaceHandlerBase.java @@ -42,7 +42,7 @@ import org.apache.hc.core5.reactor.ProtocolIOSession; import org.apache.hc.core5.reactor.ssl.TlsDetails; import org.apache.hc.core5.util.Timeout; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.mockito.Mockito; @@ -125,7 +125,7 @@ public void cancelled() { handler.disconnected(ioSession); - Assertions.assertTrue(failed.get() instanceof ConnectionClosedException); + Assertions.assertThat(failed.get() instanceof ConnectionClosedException).isTrue(); } } @@ -138,7 +138,7 @@ void sslSessionIsExposed() throws Exception { try (TestHandler handler = new TestHandler(ioSession, null, null)) { - Assertions.assertSame(sslSession, handler.getSSLSession()); + Assertions.assertThat(handler.getSSLSession()).isSameAs(sslSession); } } @@ -152,14 +152,14 @@ void delegatesSessionProperties() throws Exception { try (TestHandler handler = new TestHandler(ioSession, null, null)) { - Assertions.assertEquals(Timeout.ofSeconds(2), handler.getSocketTimeout()); + Assertions.assertThat(handler.getSocketTimeout()).isEqualTo(Timeout.ofSeconds(2)); handler.setSocketTimeout(Timeout.ofSeconds(1)); Mockito.verify(ioSession).setSocketTimeout(Timeout.ofSeconds(1)); - Assertions.assertEquals(new InetSocketAddress("localhost", 80), handler.getRemoteAddress()); - Assertions.assertEquals(new InetSocketAddress("localhost", 0), handler.getLocalAddress()); - Assertions.assertTrue(handler.isOpen()); + Assertions.assertThat(handler.getRemoteAddress()).isEqualTo(new InetSocketAddress("localhost", 80)); + Assertions.assertThat(handler.getLocalAddress()).isEqualTo(new InetSocketAddress("localhost", 0)); + Assertions.assertThat(handler.isOpen()).isTrue(); final ProtocolVersion protocolVersion = handler.getProtocolVersion(); - Assertions.assertNotNull(protocolVersion); + Assertions.assertThat(protocolVersion).isNotNull(); handler.close(); handler.close(CloseMode.GRACEFUL); Mockito.verify(ioSession).close(); diff --git a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestProtocolNegotiationException.java b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestProtocolNegotiationException.java index 090a390b8f..42ed9de9f1 100644 --- a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestProtocolNegotiationException.java +++ b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestProtocolNegotiationException.java @@ -28,7 +28,7 @@ import java.io.IOException; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class TestProtocolNegotiationException { @@ -36,8 +36,8 @@ class TestProtocolNegotiationException { @Test void messageIsPreserved() { final ProtocolNegotiationException ex = new ProtocolNegotiationException("nope"); - Assertions.assertEquals("nope", ex.getMessage()); - Assertions.assertTrue(ex instanceof IOException); + Assertions.assertThat(ex.getMessage()).isEqualTo("nope"); + Assertions.assertThat(ex instanceof IOException).isTrue(); } } diff --git a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestServerH2IOEventHandler.java b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestServerH2IOEventHandler.java index c81ffbebc1..aca2de89a4 100644 --- a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestServerH2IOEventHandler.java +++ b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestServerH2IOEventHandler.java @@ -28,7 +28,7 @@ import java.net.InetSocketAddress; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.mockito.Mockito; @@ -53,8 +53,8 @@ void toStringIncludesState() throws Exception { handler.close(); } - Assertions.assertTrue(text.contains("state")); - Assertions.assertTrue(text.contains("->")); + Assertions.assertThat(text.contains("state")).isTrue(); + Assertions.assertThat(text.contains("->")).isTrue(); } } diff --git a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestServerH2PrefaceHandler.java b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestServerH2PrefaceHandler.java index 875d72f984..617d2e5de7 100644 --- a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestServerH2PrefaceHandler.java +++ b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestServerH2PrefaceHandler.java @@ -32,7 +32,7 @@ import org.apache.hc.core5.http.nio.HandlerFactory; import org.apache.hc.core5.http.protocol.HttpProcessor; import org.apache.hc.core5.reactor.ProtocolIOSession; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.mockito.Mockito; @@ -54,8 +54,8 @@ void rejectsInvalidPreface() throws Exception { invalid[0] = (byte) (invalid[0] + 1); try { - Assertions.assertThrows(ProtocolNegotiationException.class, () -> - handler.inputReady(ioSession, ByteBuffer.wrap(invalid))); + Assertions.assertThatThrownBy(() -> + handler.inputReady(ioSession, ByteBuffer.wrap(invalid))).isInstanceOf(ProtocolNegotiationException.class); } finally { handler.close(); } diff --git a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestServerH2StreamHandler.java b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestServerH2StreamHandler.java index c3aea6f560..3814c52e60 100644 --- a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestServerH2StreamHandler.java +++ b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestServerH2StreamHandler.java @@ -42,7 +42,8 @@ import org.apache.hc.core5.http.protocol.HttpProcessor; import org.apache.hc.core5.http2.H2Error; import org.apache.hc.core5.http2.H2StreamResetException; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; +import org.assertj.core.api.InstanceOfAssertFactories; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; @@ -78,26 +79,28 @@ void prepareMocks() { @Test void defaults() { - Assertions.assertNull(handler.getPushHandlerFactory()); - Assertions.assertFalse(handler.isOutputReady()); + Assertions.assertThat(handler.getPushHandlerFactory()).isNull(); + Assertions.assertThat(handler.isOutputReady()).isFalse(); } @Test void consumeDataBeforeHeadersRejected() { - Assertions.assertThrows(ProtocolException.class, () -> - handler.consumeData(ByteBuffer.allocate(0), true)); + Assertions.assertThatThrownBy(() -> + handler.consumeData(ByteBuffer.allocate(0), true)).isInstanceOf(ProtocolException.class); } @Test void updateCapacityWithoutHandlerFails() { - Assertions.assertThrows(IllegalStateException.class, () -> handler.updateInputCapacity()); + Assertions.assertThatThrownBy(() -> + handler.updateInputCapacity()) + .isInstanceOf(IllegalStateException.class); } @Test void toStringIncludesStates() { final String text = handler.toString(); - Assertions.assertTrue(text.contains("requestState")); - Assertions.assertTrue(text.contains("responseState")); + Assertions.assertThat(text.contains("requestState")).isTrue(); + Assertions.assertThat(text.contains("responseState")).isTrue(); } @Test @@ -113,7 +116,9 @@ void consumeTrailersWithPseudoHeaderRejected() throws Exception { handler.consumeHeader(requestHeaders, false); final List
trailers = Collections.singletonList(new BasicHeader(":status", "200")); - Assertions.assertThrows(H2StreamResetException.class, () -> handler.consumeHeader(trailers, true)); + Assertions.assertThatThrownBy(() -> + handler.consumeHeader(trailers, true)) + .isInstanceOf(H2StreamResetException.class); Mockito.verify(exchangeHandler, Mockito.never()).streamEnd(ArgumentMatchers.anyList()); } @@ -130,10 +135,10 @@ void consumeTrailersWithoutEndStreamRejected() throws Exception { handler.consumeHeader(requestHeaders, false); final List
trailers = Collections.singletonList(new BasicHeader("x-checksum", "abc123")); - final H2StreamResetException ex = Assertions.assertThrows( - H2StreamResetException.class, - () -> handler.consumeHeader(trailers, false)); - Assertions.assertEquals(H2Error.PROTOCOL_ERROR, H2Error.getByCode(ex.getCode())); + final H2StreamResetException ex = Assertions.assertThatThrownBy(() -> + handler.consumeHeader(trailers, false)) + .isInstanceOf(H2StreamResetException.class).asInstanceOf(InstanceOfAssertFactories.type(H2StreamResetException.class)).actual(); + Assertions.assertThat(H2Error.getByCode(ex.getCode())).isEqualTo(H2Error.PROTOCOL_ERROR); Mockito.verify(exchangeHandler, Mockito.never()).streamEnd(ArgumentMatchers.anyList()); } @@ -164,8 +169,8 @@ void contentLengthInvalid() throws Exception { new BasicHeader("content-length", "12")); handler.consumeHeader(requestHeaders, false); handler.consumeData(ByteBuffer.wrap(new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }), false); - Assertions.assertThrows(ProtocolException.class, () -> - handler.consumeData(ByteBuffer.wrap(new byte[] { 0, 1, 2 }), true)); + Assertions.assertThatThrownBy(() -> + handler.consumeData(ByteBuffer.wrap(new byte[]{0, 1, 2}), true)).isInstanceOf(ProtocolException.class); } @Test @@ -176,8 +181,8 @@ void contentLengthInvalidNoBody() throws Exception { new BasicHeader(":authority", "example.test"), new BasicHeader(":path", "/upload"), new BasicHeader("content-length", "12")); - Assertions.assertThrows(ProtocolException.class, () -> - handler.consumeHeader(requestHeaders, true)); + Assertions.assertThatThrownBy(() -> + handler.consumeHeader(requestHeaders, true)).isInstanceOf(ProtocolException.class); } } diff --git a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestServerH2StreamMultiplexer.java b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestServerH2StreamMultiplexer.java index 4f5bac3c33..a9c76028d1 100644 --- a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestServerH2StreamMultiplexer.java +++ b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestServerH2StreamMultiplexer.java @@ -38,7 +38,8 @@ import org.apache.hc.core5.http2.config.H2Param; import org.apache.hc.core5.http2.frame.DefaultFrameFactory; import org.apache.hc.core5.reactor.ProtocolIOSession; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; +import org.assertj.core.api.InstanceOfAssertFactories; import org.junit.jupiter.api.Test; import org.mockito.Mockito; @@ -75,24 +76,24 @@ void validateSettingAcceptsEnablePush1OnServer() throws Exception { @Test void validateSettingRejectsEnablePush2OnServer() { final ServerH2StreamMultiplexer multiplexer = newMultiplexer(); - final H2ConnectionException ex = Assertions.assertThrows(H2ConnectionException.class, () -> - multiplexer.validateSetting(H2Param.ENABLE_PUSH, 2)); - Assertions.assertEquals(H2Error.PROTOCOL_ERROR.getCode(), ex.getCode()); + final H2ConnectionException ex = Assertions.assertThatThrownBy(() -> + multiplexer.validateSetting(H2Param.ENABLE_PUSH, 2)).isInstanceOf(H2ConnectionException.class).asInstanceOf(InstanceOfAssertFactories.type(H2ConnectionException.class)).actual(); + Assertions.assertThat(ex.getCode()).isEqualTo(H2Error.PROTOCOL_ERROR.getCode()); } @Test void validateSettingRejectsEnablePushNegativeOnServer() { final ServerH2StreamMultiplexer multiplexer = newMultiplexer(); - final H2ConnectionException ex = Assertions.assertThrows(H2ConnectionException.class, () -> - multiplexer.validateSetting(H2Param.ENABLE_PUSH, -1)); - Assertions.assertEquals(H2Error.PROTOCOL_ERROR.getCode(), ex.getCode()); + final H2ConnectionException ex = Assertions.assertThatThrownBy(() -> + multiplexer.validateSetting(H2Param.ENABLE_PUSH, -1)).isInstanceOf(H2ConnectionException.class).asInstanceOf(InstanceOfAssertFactories.type(H2ConnectionException.class)).actual(); + Assertions.assertThat(ex.getCode()).isEqualTo(H2Error.PROTOCOL_ERROR.getCode()); } @Test void acceptPushFrameRejected() { final ServerH2StreamMultiplexer multiplexer = newMultiplexer(); - final H2ConnectionException ex = Assertions.assertThrows(H2ConnectionException.class, multiplexer::acceptPushFrame); - Assertions.assertEquals(H2Error.PROTOCOL_ERROR.getCode(), ex.getCode()); + final H2ConnectionException ex = Assertions.assertThatThrownBy(multiplexer::acceptPushFrame).isInstanceOf(H2ConnectionException.class).asInstanceOf(InstanceOfAssertFactories.type(H2ConnectionException.class)).actual(); + Assertions.assertThat(ex.getCode()).isEqualTo(H2Error.PROTOCOL_ERROR.getCode()); } @Test @@ -101,12 +102,12 @@ void outgoingRequestRejected() { @SuppressWarnings("unchecked") final HandlerFactory pushHandlerFactory = (HandlerFactory) Mockito.mock(HandlerFactory.class); - Assertions.assertThrows(H2ConnectionException.class, () -> + Assertions.assertThatThrownBy(() -> multiplexer.outgoingRequest( Mockito.mock(H2StreamChannel.class), Mockito.mock(AsyncClientExchangeHandler.class), pushHandlerFactory, - null)); + null)).isInstanceOf(H2ConnectionException.class); } @Test @@ -115,8 +116,8 @@ void incomingPushPromiseRejected() { @SuppressWarnings("unchecked") final HandlerFactory pushHandlerFactory = (HandlerFactory) Mockito.mock(HandlerFactory.class); - Assertions.assertThrows(H2ConnectionException.class, () -> - multiplexer.incomingPushPromise(Mockito.mock(H2StreamChannel.class), pushHandlerFactory)); + Assertions.assertThatThrownBy(() -> + multiplexer.incomingPushPromise(Mockito.mock(H2StreamChannel.class), pushHandlerFactory)).isInstanceOf(H2ConnectionException.class); } @Test @@ -125,21 +126,21 @@ void outgoingPushPromiseCreatesHandler() throws Exception { final H2StreamHandler handler = multiplexer.outgoingPushPromise( Mockito.mock(H2StreamChannel.class), Mockito.mock(AsyncPushProducer.class)); - Assertions.assertNotNull(handler); + Assertions.assertThat(handler).isNotNull(); } @Test void allowGracefulAbortIsFalse() { final ServerH2StreamMultiplexer multiplexer = newMultiplexer(); - Assertions.assertFalse(multiplexer.allowGracefulAbort(Mockito.mock(H2Stream.class))); + Assertions.assertThat(multiplexer.allowGracefulAbort(Mockito.mock(H2Stream.class))).isFalse(); } @Test void toStringContainsState() { final ServerH2StreamMultiplexer multiplexer = newMultiplexer(); final String text = multiplexer.toString(); - Assertions.assertTrue(text.startsWith("[")); - Assertions.assertTrue(text.endsWith("]")); + Assertions.assertThat(text.startsWith("[")).isTrue(); + Assertions.assertThat(text.endsWith("]")).isTrue(); } } diff --git a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestServerH2StreamMultiplexerFactory.java b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestServerH2StreamMultiplexerFactory.java index 971b2d1fd5..8d6e8931ec 100644 --- a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestServerH2StreamMultiplexerFactory.java +++ b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestServerH2StreamMultiplexerFactory.java @@ -30,7 +30,7 @@ import org.apache.hc.core5.http.nio.HandlerFactory; import org.apache.hc.core5.http.protocol.HttpProcessor; import org.apache.hc.core5.reactor.ProtocolIOSession; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.mockito.Mockito; @@ -48,7 +48,7 @@ void createUsesDefaults() { final ProtocolIOSession ioSession = Mockito.mock(ProtocolIOSession.class); final ServerH2StreamMultiplexer multiplexer = factory.create(ioSession); - Assertions.assertNotNull(multiplexer); + Assertions.assertThat(multiplexer).isNotNull(); } } diff --git a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestServerHttp1UpgradeHandler.java b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestServerHttp1UpgradeHandler.java index bfdff3a0fa..b96dbd1e20 100644 --- a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestServerHttp1UpgradeHandler.java +++ b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestServerHttp1UpgradeHandler.java @@ -39,7 +39,7 @@ import org.apache.hc.core5.http.protocol.HttpProcessor; import org.apache.hc.core5.reactor.ProtocolIOSession; import org.apache.hc.core5.reactor.ssl.TlsDetails; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.mockito.Mockito; @@ -82,7 +82,7 @@ public void cancelled() { } }); - Assertions.assertSame(ioSession, completed.get()); + Assertions.assertThat(completed.get()).isSameAs(ioSession); Mockito.verify(ioSession, Mockito.times(2)).upgrade(Mockito.any()); } diff --git a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestServerHttpProtocolNegotiationStarter.java b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestServerHttpProtocolNegotiationStarter.java index 060dd66fc3..f7ae88f1dd 100644 --- a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestServerHttpProtocolNegotiationStarter.java +++ b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestServerHttpProtocolNegotiationStarter.java @@ -28,10 +28,10 @@ import org.apache.hc.core5.function.Callback; import org.apache.hc.core5.http.URIScheme; -import org.apache.hc.core5.http.impl.nio.ServerHttp1IOEventHandler; -import org.apache.hc.core5.http.impl.nio.ServerHttp1StreamDuplexerFactory; import org.apache.hc.core5.http.config.CharCodingConfig; import org.apache.hc.core5.http.config.Http1Config; +import org.apache.hc.core5.http.impl.nio.ServerHttp1IOEventHandler; +import org.apache.hc.core5.http.impl.nio.ServerHttp1StreamDuplexerFactory; import org.apache.hc.core5.http.nio.AsyncServerExchangeHandler; import org.apache.hc.core5.http.nio.HandlerFactory; import org.apache.hc.core5.http.nio.ssl.TlsStrategy; @@ -41,7 +41,7 @@ import org.apache.hc.core5.reactor.EndpointParameters; import org.apache.hc.core5.reactor.ProtocolIOSession; import org.apache.hc.core5.util.Timeout; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.mockito.Mockito; @@ -87,7 +87,7 @@ void forceHttp2UsesPrefaceHandlerAndTlsUpgrade() { final Object handler = starter.createHandler(ioSession, endpoint); - Assertions.assertTrue(handler instanceof ServerH2PrefaceHandler); + Assertions.assertThat(handler instanceof ServerH2PrefaceHandler).isTrue(); Mockito.verify(ioSession).registerProtocol(Mockito.eq(ApplicationProtocol.HTTP_1_1.id), Mockito.any()); Mockito.verify(ioSession).registerProtocol(Mockito.eq(ApplicationProtocol.HTTP_2.id), Mockito.any()); Mockito.verify(tlsStrategy).upgrade(ioSession, endpoint, HttpVersionPolicy.FORCE_HTTP_2, Timeout.ofSeconds(1), null); @@ -106,7 +106,7 @@ void forceHttp1UsesHttp1Handler() { final ProtocolIOSession ioSession = Mockito.mock(ProtocolIOSession.class); final Object handler = starter.createHandler(ioSession, null); - Assertions.assertTrue(handler instanceof ServerHttp1IOEventHandler); + Assertions.assertThat(handler instanceof ServerHttp1IOEventHandler).isTrue(); } @Test @@ -122,7 +122,7 @@ void negotiateUsesProtocolNegotiator() { final ProtocolIOSession ioSession = Mockito.mock(ProtocolIOSession.class); final Object handler = starter.createHandler(ioSession, null); - Assertions.assertTrue(handler instanceof HttpProtocolNegotiator); + Assertions.assertThat(handler instanceof HttpProtocolNegotiator).isTrue(); } } diff --git a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestServerPushH2StreamHandler.java b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestServerPushH2StreamHandler.java index 52ff2c8df9..928e31af97 100644 --- a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestServerPushH2StreamHandler.java +++ b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TestServerPushH2StreamHandler.java @@ -34,7 +34,7 @@ import org.apache.hc.core5.http.nio.AsyncPushProducer; import org.apache.hc.core5.http.protocol.HttpCoreContext; import org.apache.hc.core5.http.protocol.HttpProcessor; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.mockito.Mockito; @@ -53,16 +53,22 @@ private ServerPushH2StreamHandler newHandler() { @Test void defaults() { final ServerPushH2StreamHandler handler = newHandler(); - Assertions.assertNull(handler.getPushHandlerFactory()); - Assertions.assertTrue(handler.isOutputReady()); + Assertions.assertThat(handler.getPushHandlerFactory()).isNull(); + Assertions.assertThat(handler.isOutputReady()).isTrue(); } @Test void consumesAreRejected() { final ServerPushH2StreamHandler handler = newHandler(); - Assertions.assertThrows(ProtocolException.class, () -> handler.consumePromise(null)); - Assertions.assertThrows(ProtocolException.class, () -> handler.consumeHeader(null, true)); - Assertions.assertThrows(ProtocolException.class, () -> handler.consumeData(ByteBuffer.allocate(0), true)); + Assertions.assertThatThrownBy(() -> + handler.consumePromise(null)) + .isInstanceOf(ProtocolException.class); + Assertions.assertThatThrownBy(() -> + handler.consumeHeader(null, true)) + .isInstanceOf(ProtocolException.class); + Assertions.assertThatThrownBy(() -> + handler.consumeData(ByteBuffer.allocate(0), true)) + .isInstanceOf(ProtocolException.class); } } diff --git a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TrailersValidationSupportTest.java b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TrailersValidationSupportTest.java index 641d7f8693..3bdbe3e603 100644 --- a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TrailersValidationSupportTest.java +++ b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/impl/nio/TrailersValidationSupportTest.java @@ -31,7 +31,7 @@ import org.apache.hc.core5.http.ProtocolException; import org.apache.hc.core5.http.message.BasicHeader; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class TestTrailersValidationSupport { @@ -45,8 +45,8 @@ void testVerifyInboundAcceptsRegularTrailers() throws Exception { @Test void testVerifyInboundRejectsPseudoHeaders() { - Assertions.assertThrows(ProtocolException.class, () -> + Assertions.assertThatThrownBy(() -> TrailersValidationSupport.verify(Collections.singletonList( - new BasicHeader(":status", "200")))); + new BasicHeader(":status", "200")))).isInstanceOf(ProtocolException.class); } } diff --git a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/nio/command/TestPingCommand.java b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/nio/command/TestPingCommand.java index 84833f40f1..e49ecffb7c 100644 --- a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/nio/command/TestPingCommand.java +++ b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/nio/command/TestPingCommand.java @@ -27,7 +27,7 @@ package org.apache.hc.core5.http2.nio.command; import org.apache.hc.core5.http2.nio.AsyncPingHandler; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.mockito.Mockito; @@ -38,8 +38,8 @@ void testCancelDelegatesToHandler() { final AsyncPingHandler handler = Mockito.mock(AsyncPingHandler.class); final PingCommand command = new PingCommand(handler); - Assertions.assertSame(handler, command.getHandler()); - Assertions.assertTrue(command.cancel()); + Assertions.assertThat(command.getHandler()).isSameAs(handler); + Assertions.assertThat(command.cancel()).isTrue(); Mockito.verify(handler).cancel(); } diff --git a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/nio/command/TestPushResponseCommand.java b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/nio/command/TestPushResponseCommand.java index 8c342454db..c2169cf0f3 100644 --- a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/nio/command/TestPushResponseCommand.java +++ b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/nio/command/TestPushResponseCommand.java @@ -26,24 +26,26 @@ */ package org.apache.hc.core5.http2.nio.command; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class TestPushResponseCommand { @Test void testRejectsNonPositiveStreamId() { - Assertions.assertThrows(IllegalArgumentException.class, () -> new PushResponseCommand(0)); + Assertions.assertThatThrownBy(() -> + new PushResponseCommand(0)) + .isInstanceOf(IllegalArgumentException.class); } @Test void testCancelTogglesState() { final PushResponseCommand command = new PushResponseCommand(1); - Assertions.assertFalse(command.isCancelled()); - Assertions.assertTrue(command.cancel()); - Assertions.assertTrue(command.isCancelled()); - Assertions.assertFalse(command.cancel()); + Assertions.assertThat(command.isCancelled()).isFalse(); + Assertions.assertThat(command.cancel()).isTrue(); + Assertions.assertThat(command.isCancelled()).isTrue(); + Assertions.assertThat(command.cancel()).isFalse(); } } diff --git a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/nio/pool/TestH2ConnPool.java b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/nio/pool/TestH2ConnPool.java index 10251ac15d..952e39f81d 100644 --- a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/nio/pool/TestH2ConnPool.java +++ b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/nio/pool/TestH2ConnPool.java @@ -45,7 +45,7 @@ import org.apache.hc.core5.reactor.ssl.TransportSecurityLayer; import org.apache.hc.core5.util.TimeValue; import org.apache.hc.core5.util.Timeout; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.mockito.Mockito; @@ -86,7 +86,7 @@ void testValidateSessionClosed() { final AtomicReference result = new AtomicReference<>(); pool.validateSession(host, session, result::set); - Assertions.assertEquals(Boolean.FALSE, result.get()); + Assertions.assertThat(result.get()).isEqualTo(Boolean.FALSE); } } @@ -153,7 +153,7 @@ public void cancelled() { }); - Assertions.assertSame(session, result.get()); + Assertions.assertThat(result.get()).isSameAs(session); } } @@ -215,7 +215,7 @@ public void cancelled() { }); - Assertions.assertSame(session, result.get()); + Assertions.assertThat(result.get()).isSameAs(session); Mockito.verify(tlsStrategy).upgrade( Mockito.eq(tlsLayer), Mockito.eq(host), diff --git a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/nio/support/TestBasicPingHandler.java b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/nio/support/TestBasicPingHandler.java index fddfdd0e29..f1df941122 100644 --- a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/nio/support/TestBasicPingHandler.java +++ b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/nio/support/TestBasicPingHandler.java @@ -30,7 +30,7 @@ import java.nio.ByteBuffer; import java.util.concurrent.atomic.AtomicReference; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class TestBasicPingHandler { @@ -42,7 +42,7 @@ void testConsumeResponseMatches() throws Exception { handler.consumeResponse(handler.getData()); - Assertions.assertEquals(Boolean.TRUE, result.get()); + Assertions.assertThat(result.get()).isEqualTo(Boolean.TRUE); } @Test @@ -52,7 +52,7 @@ void testConsumeResponseMismatch() throws Exception { handler.consumeResponse(ByteBuffer.wrap(new byte[] {'x'})); - Assertions.assertEquals(Boolean.FALSE, result.get()); + Assertions.assertThat(result.get()).isEqualTo(Boolean.FALSE); } @Test @@ -61,11 +61,11 @@ void testFailedAndCancel() { final BasicPingHandler handler = new BasicPingHandler(result::set); handler.failed(new IOException("boom")); - Assertions.assertEquals(Boolean.FALSE, result.get()); + Assertions.assertThat(result.get()).isEqualTo(Boolean.FALSE); result.set(Boolean.TRUE); handler.cancel(); - Assertions.assertEquals(Boolean.FALSE, result.get()); + Assertions.assertThat(result.get()).isEqualTo(Boolean.FALSE); } } diff --git a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/nio/support/TestDefaultAsyncPushConsumerFactory.java b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/nio/support/TestDefaultAsyncPushConsumerFactory.java index 861b4e5aa7..47b7d6c79e 100644 --- a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/nio/support/TestDefaultAsyncPushConsumerFactory.java +++ b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/nio/support/TestDefaultAsyncPushConsumerFactory.java @@ -27,12 +27,12 @@ package org.apache.hc.core5.http2.nio.support; import org.apache.hc.core5.function.Supplier; +import org.apache.hc.core5.http.HttpRequestMapper; import org.apache.hc.core5.http.MisdirectedRequestException; import org.apache.hc.core5.http.message.BasicHttpRequest; import org.apache.hc.core5.http.nio.AsyncPushConsumer; import org.apache.hc.core5.http.protocol.HttpCoreContext; -import org.apache.hc.core5.http.HttpRequestMapper; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.mockito.Mockito; @@ -50,7 +50,7 @@ void testCreateResolvesConsumer() throws Exception { new BasicHttpRequest("GET", "/"), HttpCoreContext.create()); - Assertions.assertSame(consumer, result); + Assertions.assertThat(result).isSameAs(consumer); } @Test @@ -64,7 +64,7 @@ void testCreateReturnsNullWhenNotResolved() throws Exception { new BasicHttpRequest("GET", "/"), HttpCoreContext.create()); - Assertions.assertNull(result); + Assertions.assertThat(result).isNull(); } @Test @@ -79,7 +79,7 @@ void testCreateHandlesMisdirectedRequest() throws Exception { new BasicHttpRequest("GET", "/"), HttpCoreContext.create()); - Assertions.assertNull(result); + Assertions.assertThat(result).isNull(); } @SuppressWarnings("unchecked") diff --git a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/priority/TestPriorityMerge.java b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/priority/TestPriorityMerge.java index ecf7c7619a..f67ce9b011 100644 --- a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/priority/TestPriorityMerge.java +++ b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/priority/TestPriorityMerge.java @@ -26,10 +26,7 @@ */ package org.apache.hc.core5.http2.priority; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.junit.jupiter.api.Assertions.assertTrue; - +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; final class TestPriorityMerge { @@ -42,8 +39,8 @@ void rfc_example_server_overrides_urgency_preserves_incremental() { final PriorityParams serverResp = PriorityParamsParser.parse("u=1"); final PriorityValue merged = PriorityMerge.merge(clientReq, serverResp); - assertEquals(1, merged.getUrgency()); - assertTrue(merged.isIncremental()); + Assertions.assertThat(merged.getUrgency()).isEqualTo(1); + Assertions.assertThat(merged.isIncremental()).isTrue(); } @Test @@ -51,8 +48,8 @@ void response_absent_keeps_client_values() { final PriorityValue clientReq = PriorityValue.of(2, false); final PriorityValue merged = PriorityMerge.merge(clientReq, null); - assertEquals(2, merged.getUrgency()); - assertFalse(merged.isIncremental()); + Assertions.assertThat(merged.getUrgency()).isEqualTo(2); + Assertions.assertThat(merged.isIncremental()).isFalse(); } @Test @@ -60,13 +57,13 @@ void client_absent_uses_response_or_defaults() { // Only server response provided final PriorityParams resp1 = PriorityParamsParser.parse("u=0, i"); final PriorityValue merged1 = PriorityMerge.merge(null, resp1); - assertEquals(0, merged1.getUrgency()); - assertTrue(merged1.isIncremental()); + Assertions.assertThat(merged1.getUrgency()).isEqualTo(0); + Assertions.assertThat(merged1.isIncremental()).isTrue(); // Neither side provided => defaults final PriorityValue merged2 = PriorityMerge.merge(null, null); - assertEquals(PriorityValue.DEFAULT_URGENCY, merged2.getUrgency()); - assertEquals(PriorityValue.DEFAULT_INCREMENTAL, merged2.isIncremental()); + Assertions.assertThat(merged2.getUrgency()).isEqualTo(PriorityValue.DEFAULT_URGENCY); + Assertions.assertThat(merged2.isIncremental()).isEqualTo(PriorityValue.DEFAULT_INCREMENTAL); } @Test @@ -75,8 +72,8 @@ void server_sets_only_incremental_true_keeps_client_urgency() { final PriorityParams serverResp = PriorityParamsParser.parse("i"); final PriorityValue merged = PriorityMerge.merge(clientReq, serverResp); - assertEquals(4, merged.getUrgency()); - assertTrue(merged.isIncremental()); + Assertions.assertThat(merged.getUrgency()).isEqualTo(4); + Assertions.assertThat(merged.isIncremental()).isTrue(); } @Test @@ -85,8 +82,8 @@ void server_sets_only_urgency_keeps_client_incremental() { final PriorityParams serverResp = PriorityParamsParser.parse("u=1"); final PriorityValue merged = PriorityMerge.merge(clientReq, serverResp); - assertEquals(1, merged.getUrgency()); - assertTrue(merged.isIncremental()); + Assertions.assertThat(merged.getUrgency()).isEqualTo(1); + Assertions.assertThat(merged.isIncremental()).isTrue(); } @Test @@ -96,15 +93,15 @@ void out_of_range_server_urgency_is_ignored_but_other_members_apply() { final PriorityParams serverResp = PriorityParamsParser.parse("u=9, i"); final PriorityValue merged = PriorityMerge.merge(clientReq, serverResp); - assertEquals(3, merged.getUrgency()); // unchanged - assertTrue(merged.isIncremental()); // from server + Assertions.assertThat(merged.getUrgency()).isEqualTo(3); // unchanged + Assertions.assertThat(merged.isIncremental()).isTrue(); // from server } @Test void null_safety_with_valid_inputs() { // Server provides only u; client null -> defaults for i final PriorityValue merged = PriorityMerge.merge(null, new PriorityParams(2, null)); - assertEquals(2, merged.getUrgency()); - assertEquals(PriorityValue.DEFAULT_INCREMENTAL, merged.isIncremental()); + Assertions.assertThat(merged.getUrgency()).isEqualTo(2); + Assertions.assertThat(merged.isIncremental()).isEqualTo(PriorityValue.DEFAULT_INCREMENTAL); } } \ No newline at end of file diff --git a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/priority/TestPriorityParamsParser.java b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/priority/TestPriorityParamsParser.java index 9615ff513e..04fc731b37 100644 --- a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/priority/TestPriorityParamsParser.java +++ b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/priority/TestPriorityParamsParser.java @@ -26,10 +26,7 @@ */ package org.apache.hc.core5.http2.priority; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertNull; -import static org.junit.jupiter.api.Assertions.assertTrue; - +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; final class TestPriorityParamsParser { @@ -37,30 +34,30 @@ final class TestPriorityParamsParser { @Test void captures_presence_correctly() { final PriorityParams p1 = PriorityParamsParser.parse("u=1"); - assertEquals(1, p1.getUrgency()); - assertNull(p1.getIncremental()); + Assertions.assertThat(p1.getUrgency()).isEqualTo(1); + Assertions.assertThat(p1.getIncremental()).isNull(); final PriorityParams p2 = PriorityParamsParser.parse("i"); - assertNull(p2.getUrgency()); - assertEquals(Boolean.TRUE, p2.getIncremental()); + Assertions.assertThat(p2.getUrgency()).isNull(); + Assertions.assertThat(p2.getIncremental()).isEqualTo(Boolean.TRUE); final PriorityParams p3 = PriorityParamsParser.parse("u=5, i"); - assertEquals(5, p3.getUrgency()); - assertEquals(Boolean.TRUE, p3.getIncremental()); + Assertions.assertThat(p3.getUrgency()).isEqualTo(5); + Assertions.assertThat(p3.getIncremental()).isEqualTo(Boolean.TRUE); } @Test void ignores_unknown_and_out_of_range() { final PriorityParams p = PriorityParamsParser.parse("foo=bar, u=9, i=?0"); - assertNull(p.getUrgency()); // out-of-range ignored => absent - assertEquals(Boolean.FALSE, p.getIncremental()); + Assertions.assertThat(p.getUrgency()).isNull(); // out-of-range ignored => absent + Assertions.assertThat(p.getIncremental()).isEqualTo(Boolean.FALSE); } @Test void toValueWithDefaults_applies_defaults() { final PriorityParams p = PriorityParamsParser.parse("i"); final PriorityValue v = p.toValueWithDefaults(); - assertEquals(3, v.getUrgency()); - assertTrue(v.isIncremental()); + Assertions.assertThat(v.getUrgency()).isEqualTo(3); + Assertions.assertThat(v.isIncremental()).isTrue(); } } diff --git a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/priority/TestPriorityParserAndFormatter.java b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/priority/TestPriorityParserAndFormatter.java index b193bbc1c5..d073a5e5c7 100644 --- a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/priority/TestPriorityParserAndFormatter.java +++ b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/priority/TestPriorityParserAndFormatter.java @@ -26,12 +26,8 @@ */ package org.apache.hc.core5.http2.priority; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.junit.jupiter.api.Assertions.assertNull; -import static org.junit.jupiter.api.Assertions.assertTrue; - import org.apache.hc.core5.http.Header; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; public final class TestPriorityParserAndFormatter { @@ -42,22 +38,22 @@ public final class TestPriorityParserAndFormatter { void rfc_example_css_urgency0() { // From RFC 9218 §4.1: priority = u=0 final PriorityValue v = PriorityParser.parse("u=0"); - assertEquals(0, v.getUrgency()); - assertFalse(v.isIncremental()); + Assertions.assertThat(v.getUrgency()).isEqualTo(0); + Assertions.assertThat(v.isIncremental()).isFalse(); // Formatter emits only non-defaults - assertEquals("u=0", PriorityFormatter.format(v)); + Assertions.assertThat(PriorityFormatter.format(v)).isEqualTo("u=0"); } @Test void rfc_example_jpeg_u5_incremental() { // From RFC 9218 §4.2: priority = u=5, i final PriorityValue v = PriorityParser.parse("u=5, i"); - assertEquals(5, v.getUrgency()); - assertTrue(v.isIncremental()); + Assertions.assertThat(v.getUrgency()).isEqualTo(5); + Assertions.assertThat(v.isIncremental()).isTrue(); // Formatter keeps canonical "u=5, i" - assertEquals("u=5, i", PriorityFormatter.format(v)); + Assertions.assertThat(PriorityFormatter.format(v)).isEqualTo("u=5, i"); } // ---- Defaults & omission ------------------------------------------------- @@ -65,23 +61,23 @@ void rfc_example_jpeg_u5_incremental() { @Test void defaults_when_empty_or_null() { final PriorityValue v1 = PriorityParser.parse(""); - assertEquals(3, v1.getUrgency()); - assertFalse(v1.isIncremental()); + Assertions.assertThat(v1.getUrgency()).isEqualTo(3); + Assertions.assertThat(v1.isIncremental()).isFalse(); final PriorityValue v2 = PriorityParser.parse((Header) null); - assertEquals(3, v2.getUrgency()); - assertFalse(v2.isIncremental()); + Assertions.assertThat(v2.getUrgency()).isEqualTo(3); + Assertions.assertThat(v2.isIncremental()).isFalse(); } // ---- Boolean variants per RFC 8941 -------------------------------------- @Test void boolean_variants_for_incremental() { - assertTrue(PriorityParser.parse("i").isIncremental()); // bare true - assertTrue(PriorityParser.parse("i=?1").isIncremental()); // structured boolean true - assertFalse(PriorityParser.parse("i=?0").isIncremental()); // structured boolean false - assertTrue(PriorityParser.parse("i=1").isIncremental()); // tolerant numeric '1' - assertFalse(PriorityParser.parse("i=0").isIncremental()); // tolerant numeric '0' + Assertions.assertThat(PriorityParser.parse("i").isIncremental()).isTrue(); // bare true + Assertions.assertThat(PriorityParser.parse("i=?1").isIncremental()).isTrue(); // structured boolean true + Assertions.assertThat(PriorityParser.parse("i=?0").isIncremental()).isFalse(); // structured boolean false + Assertions.assertThat(PriorityParser.parse("i=1").isIncremental()).isTrue(); // tolerant numeric '1' + Assertions.assertThat(PriorityParser.parse("i=0").isIncremental()).isFalse(); // tolerant numeric '0' } // ---- Unknown & invalid handling ----------------------------------------- @@ -89,24 +85,24 @@ void boolean_variants_for_incremental() { @Test void unknown_members_are_ignored() { final PriorityValue v = PriorityParser.parse("foo=bar, u=2, i, baz=?1"); - assertEquals(2, v.getUrgency()); - assertTrue(v.isIncremental()); + Assertions.assertThat(v.getUrgency()).isEqualTo(2); + Assertions.assertThat(v.isIncremental()).isTrue(); } @Test void urgency_out_of_range_is_ignored() { final PriorityValue v1 = PriorityParser.parse("u=9"); // >7 - assertEquals(3, v1.getUrgency()); + Assertions.assertThat(v1.getUrgency()).isEqualTo(3); final PriorityValue v2 = PriorityParser.parse("u=-1"); // <0 - assertEquals(3, v2.getUrgency()); + Assertions.assertThat(v2.getUrgency()).isEqualTo(3); } @Test void malformed_members_are_ignored() { final PriorityValue v = PriorityParser.parse("u=abc, i=banana, i=?x"); - assertEquals(3, v.getUrgency()); // default - assertFalse(v.isIncremental()); // default + Assertions.assertThat(v.getUrgency()).isEqualTo(3); // default + Assertions.assertThat(v.isIncremental()).isFalse(); // default } // ---- Whitespace, params, case-insensitivity ----------------------------- @@ -115,20 +111,20 @@ void malformed_members_are_ignored() { void handles_ows_and_parameters_and_case() { // Ignore structured-field parameters after members, and key is case-insensitive final PriorityValue v = PriorityParser.parse(" U = 1 ;p=v , I ;x "); - assertEquals(1, v.getUrgency()); - assertTrue(v.isIncremental()); + Assertions.assertThat(v.getUrgency()).isEqualTo(1); + Assertions.assertThat(v.isIncremental()).isTrue(); // Formatter canonicalizes output (no params, normalized layout) - assertEquals("u=1, i", PriorityFormatter.format(v)); + Assertions.assertThat(PriorityFormatter.format(v)).isEqualTo("u=1, i"); } // ---- Minimal formatting rules ------------------------------------------- @Test void formatter_emits_only_non_defaults_in_canonical_order() { - assertEquals("u=1", PriorityFormatter.format(PriorityValue.of(1, false))); - assertEquals("i", PriorityFormatter.format(PriorityValue.of(3, true))); - assertEquals("u=2, i", PriorityFormatter.format(PriorityValue.of(2, true))); + Assertions.assertThat(PriorityFormatter.format(PriorityValue.of(1, false))).isEqualTo("u=1"); + Assertions.assertThat(PriorityFormatter.format(PriorityValue.of(3, true))).isEqualTo("i"); + Assertions.assertThat(PriorityFormatter.format(PriorityValue.of(2, true))).isEqualTo("u=2, i"); } // ---- Round-trips --------------------------------------------------------- @@ -147,15 +143,15 @@ private static void roundTrip(final String s) { final String out = PriorityFormatter.format(v); // If v equals defaults, formatter returns null; otherwise we expect the canonical equivalent if (v.getUrgency() == 3 && !v.isIncremental()) { - assertNull(out); + Assertions.assertThat(out).isNull(); } else { // Canonical ordering is u first (if non-default), then i if true if (v.getUrgency() != 3 && v.isIncremental()) { - assertEquals("u=" + v.getUrgency() + ", i", out); + Assertions.assertThat(out).isEqualTo("u=" + v.getUrgency() + ", i"); } else if (v.getUrgency() != 3) { - assertEquals("u=" + v.getUrgency(), out); + Assertions.assertThat(out).isEqualTo("u=" + v.getUrgency()); } else { - assertEquals("i", out); + Assertions.assertThat(out).isEqualTo("i"); } } } diff --git a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/priority/TestPriorityValue.java b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/priority/TestPriorityValue.java index af70767b07..7d2b282c57 100644 --- a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/priority/TestPriorityValue.java +++ b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/priority/TestPriorityValue.java @@ -26,14 +26,8 @@ */ package org.apache.hc.core5.http2.priority; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.junit.jupiter.api.Assertions.assertNotEquals; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static org.junit.jupiter.api.Assertions.assertNotSame; -import static org.junit.jupiter.api.Assertions.assertThrows; -import static org.junit.jupiter.api.Assertions.assertTrue; - +import org.assertj.core.api.Assertions; +import org.assertj.core.api.InstanceOfAssertFactories; import org.junit.jupiter.api.Test; final class TestPriorityValue { @@ -41,39 +35,43 @@ final class TestPriorityValue { @Test void defaultsAreAsSpecified() { final PriorityValue v = PriorityValue.defaults(); - assertEquals(3, v.getUrgency()); - assertFalse(v.isIncremental()); + Assertions.assertThat(v.getUrgency()).isEqualTo(3); + Assertions.assertThat(v.isIncremental()).isFalse(); } @Test void factoryOfBuildsEquivalentInstances() { final PriorityValue v1 = new PriorityValue(0, true); final PriorityValue v2 = PriorityValue.of(0, true); - assertEquals(v1, v2); - assertEquals(v1.hashCode(), v2.hashCode()); + Assertions.assertThat(v2).isEqualTo(v1); + Assertions.assertThat(v2.hashCode()).isEqualTo(v1.hashCode()); } @Test void acceptsFullValidRangeZeroToSeven() { for (int u = 0; u <= 7; u++) { final PriorityValue v = PriorityValue.of(u, false); - assertEquals(u, v.getUrgency()); - assertFalse(v.isIncremental()); + Assertions.assertThat(v.getUrgency()).isEqualTo(u); + Assertions.assertThat(v.isIncremental()).isFalse(); } } @Test void rejectsUrgencyBelowZero() { final IllegalArgumentException ex = - assertThrows(IllegalArgumentException.class, () -> new PriorityValue(-1, false)); - assertTrue(ex.getMessage().toLowerCase().contains("range")); + Assertions.assertThatThrownBy(() -> + new PriorityValue(-1, false)) + .isInstanceOf(IllegalArgumentException.class).asInstanceOf(InstanceOfAssertFactories.type(IllegalArgumentException.class)).actual(); + Assertions.assertThat(ex.getMessage().toLowerCase().contains("range")).isTrue(); } @Test void rejectsUrgencyAboveSeven() { final IllegalArgumentException ex = - assertThrows(IllegalArgumentException.class, () -> PriorityValue.of(8, true)); - assertTrue(ex.getMessage().toLowerCase().contains("range")); + Assertions.assertThatThrownBy(() -> + PriorityValue.of(8, true)) + .isInstanceOf(IllegalArgumentException.class).asInstanceOf(InstanceOfAssertFactories.type(IllegalArgumentException.class)).actual(); + Assertions.assertThat(ex.getMessage().toLowerCase().contains("range")).isTrue(); } @Test @@ -83,26 +81,30 @@ void withersReturnNewInstancesAndDoNotMutate() { final PriorityValue inc = base.withIncremental(true); // base remains unchanged - assertEquals(3, base.getUrgency()); - assertFalse(base.isIncremental()); + Assertions.assertThat(base.getUrgency()).isEqualTo(3); + Assertions.assertThat(base.isIncremental()).isFalse(); // new values applied - assertEquals(0, u0.getUrgency()); - assertFalse(u0.isIncremental()); + Assertions.assertThat(u0.getUrgency()).isEqualTo(0); + Assertions.assertThat(u0.isIncremental()).isFalse(); - assertEquals(3, inc.getUrgency()); - assertTrue(inc.isIncremental()); + Assertions.assertThat(inc.getUrgency()).isEqualTo(3); + Assertions.assertThat(inc.isIncremental()).isTrue(); // withers create distinct instances when changing a field - assertNotSame(base, u0); - assertNotSame(base, inc); + Assertions.assertThat(u0).isNotSameAs(base); + Assertions.assertThat(inc).isNotSameAs(base); } @Test void withUrgencyValidatesRange() { final PriorityValue base = PriorityValue.defaults(); - assertThrows(IllegalArgumentException.class, () -> base.withUrgency(-1)); - assertThrows(IllegalArgumentException.class, () -> base.withUrgency(9)); + Assertions.assertThatThrownBy(() -> + base.withUrgency(-1)) + .isInstanceOf(IllegalArgumentException.class); + Assertions.assertThatThrownBy(() -> + base.withUrgency(9)) + .isInstanceOf(IllegalArgumentException.class); } @Test @@ -112,20 +114,20 @@ void equalityAndHashAreBasedOnFields() { final PriorityValue c = PriorityValue.of(2, false); final PriorityValue d = PriorityValue.of(3, true); - assertEquals(a, b); - assertEquals(a.hashCode(), b.hashCode()); + Assertions.assertThat(b).isEqualTo(a); + Assertions.assertThat(b.hashCode()).isEqualTo(a.hashCode()); - assertNotEquals(a, c); - assertNotEquals(a, d); - assertNotEquals(c, d); + Assertions.assertThat(c).isNotEqualTo(a); + Assertions.assertThat(d).isNotEqualTo(a); + Assertions.assertThat(d).isNotEqualTo(c); } @Test void toStringIncludesFields() { final PriorityValue v = PriorityValue.of(1, true); final String s = v.toString(); - assertNotNull(s); - assertTrue(s.contains("u=1")); - assertTrue(s.contains("i=true")); + Assertions.assertThat(s).isNotNull(); + Assertions.assertThat(s.contains("u=1")).isTrue(); + Assertions.assertThat(s.contains("i=true")).isTrue(); } } \ No newline at end of file diff --git a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/protocol/TestH2Interceptors.java b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/protocol/TestH2Interceptors.java index ed3e9365fe..f1cf876ca8 100644 --- a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/protocol/TestH2Interceptors.java +++ b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/protocol/TestH2Interceptors.java @@ -47,7 +47,7 @@ import org.apache.hc.core5.http.message.BasicHttpRequest; import org.apache.hc.core5.http.message.BasicHttpResponse; import org.apache.hc.core5.http.protocol.HttpCoreContext; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -71,8 +71,8 @@ void testH2RequestContentProtocolException() { request.addHeader(new BasicHeader(HttpHeaders.TRANSFER_ENCODING, "chunked")); request.setEntity(new StringEntity("whatever", StandardCharsets.US_ASCII)); final HttpRequestInterceptor interceptor = H2RequestContent.INSTANCE; - Assertions.assertThrows(ProtocolException.class, () -> - interceptor.process(request, request.getEntity(), context)); + Assertions.assertThatThrownBy(() -> + interceptor.process(request, request.getEntity(), context)).isInstanceOf(ProtocolException.class); } @@ -83,8 +83,8 @@ void testH2RequestContentNullEntity() throws Exception { final HttpRequestInterceptor interceptor = H2RequestContent.INSTANCE; interceptor.process(request, request.getEntity(), context); final Header header = request.getFirstHeader(HttpHeaders.CONTENT_LENGTH); - Assertions.assertNull(header); - Assertions.assertNull(request.getFirstHeader(HttpHeaders.TRANSFER_ENCODING)); + Assertions.assertThat(header).isNull(); + Assertions.assertThat(request.getFirstHeader(HttpHeaders.TRANSFER_ENCODING)).isNull(); } @@ -101,10 +101,10 @@ void testH2RequestContentValid() throws Exception { // Assertions to validate headers final Header header1 = request.getFirstHeader(HttpHeaders.CONTENT_TYPE); - Assertions.assertNotNull(header1); + Assertions.assertThat(header1).isNotNull(); final Header header2 = request.getFirstHeader(HttpHeaders.TRAILER); - Assertions.assertNotNull(header2); - Assertions.assertEquals("h1, h2", header2.getValue()); + Assertions.assertThat(header2).isNotNull(); + Assertions.assertThat(header2.getValue()).isEqualTo("h1, h2"); } @Test @@ -115,8 +115,8 @@ void testH2RequestContentOptionMethodNullContentTypeProtocolException() { request.addHeader(new BasicHeader(HttpHeaders.CONTENT_LENGTH, "10")); request.addHeader(new BasicHeader(HttpHeaders.TRANSFER_ENCODING, "whatever")); request.setEntity(new StringEntity("")); - Assertions.assertThrows(ProtocolException.class, () -> - interceptor.process(request, request.getEntity(), context)); + Assertions.assertThatThrownBy(() -> + interceptor.process(request, request.getEntity(), context)).isInstanceOf(ProtocolException.class); } @Test @@ -128,8 +128,8 @@ void testH2RequestContentOptionMethodInvalidContentTypeProtocolException() { request.addHeader(new BasicHeader(HttpHeaders.TRANSFER_ENCODING, "whatever")); request.setEntity(new StringEntity("")); request.addHeader(new BasicHeader(HttpHeaders.CONTENT_TYPE, "text/plain; charset=invalid_charset_name!")); - Assertions.assertThrows(ProtocolException.class, () -> - interceptor.process(request, request.getEntity(), context)); + Assertions.assertThatThrownBy(() -> + interceptor.process(request, request.getEntity(), context)).isInstanceOf(ProtocolException.class); } @Test @@ -145,7 +145,7 @@ void testH2RequestContentValidOptionsMethod() throws Exception { // Assertions to validate headers final Header header1 = request.getFirstHeader(HttpHeaders.CONTENT_TYPE); - Assertions.assertNotNull(header1); + Assertions.assertThat(header1).isNotNull(); } @Test @@ -154,8 +154,9 @@ void testH2RequestConformanceConnectionHeader() { request.addHeader("Connection", "Keep-Alive"); final H2RequestConformance interceptor = new H2RequestConformance(); - Assertions.assertThrows(HttpException.class, () -> interceptor.process(request, null, context), - "Header 'Connection: Keep-Alive' is illegal for HTTP/2 messages"); + Assertions.assertThatThrownBy(() -> + interceptor.process(request, null, context)) + .withFailMessage("Header 'Connection: Keep-Alive' is illegal for HTTP/2 messages").isInstanceOf(HttpException.class); } @Test @@ -164,8 +165,9 @@ void testH2RequestConformanceKeepAliveHeader() { request.addHeader("Keep-Alive", "timeout=5, max=1000"); final H2RequestConformance interceptor = new H2RequestConformance(); - Assertions.assertThrows(HttpException.class, () -> interceptor.process(request, null, context), - "Header 'Keep-Alive: timeout=5, max=1000' is illegal for HTTP/2 messages"); + Assertions.assertThatThrownBy(() -> + interceptor.process(request, null, context)) + .withFailMessage("Header 'Keep-Alive: timeout=5, max=1000' is illegal for HTTP/2 messages").isInstanceOf(HttpException.class); } @Test @@ -174,8 +176,9 @@ void testH2RequestConformanceProxyConnectionHeader() { request.addHeader("Proxy-Connection", "keep-alive"); final H2RequestConformance interceptor = new H2RequestConformance(); - Assertions.assertThrows(HttpException.class, () -> interceptor.process(request, null, context), - "Header 'Proxy-Connection: Keep-Alive' is illegal for HTTP/2 messages"); + Assertions.assertThatThrownBy(() -> + interceptor.process(request, null, context)) + .withFailMessage("Header 'Proxy-Connection: Keep-Alive' is illegal for HTTP/2 messages").isInstanceOf(HttpException.class); } @Test @@ -184,8 +187,9 @@ void testH2RequestConformanceTransferEncodingHeader() { request.addHeader("Transfer-Encoding", "gzip"); final H2RequestConformance interceptor = new H2RequestConformance(); - Assertions.assertThrows(HttpException.class, () -> interceptor.process(request, null, context), - "Header 'Transfer-Encoding: gzip' is illegal for HTTP/2 messages"); + Assertions.assertThatThrownBy(() -> + interceptor.process(request, null, context)) + .withFailMessage("Header 'Transfer-Encoding: gzip' is illegal for HTTP/2 messages").isInstanceOf(HttpException.class); } @Test @@ -194,8 +198,7 @@ void testH2RequestConformanceHostHeader() { request.addHeader("Host", "host"); final H2RequestConformance interceptor = new H2RequestConformance(); - Assertions.assertDoesNotThrow(() -> interceptor.process(request, null, context), - "Header 'Host: host' is permissible for HTTP/2 messages"); + Assertions.assertThatCode(() -> interceptor.process(request, null, context)).withFailMessage("Header 'Host: host' is permissible for HTTP/2 messages").doesNotThrowAnyException(); } @Test @@ -204,8 +207,9 @@ void testH2RequestConformanceUpgradeHeader() { request.addHeader("Upgrade", "example/1, foo/2"); final H2RequestConformance interceptor = new H2RequestConformance(); - Assertions.assertThrows(HttpException.class, () -> interceptor.process(request, null, context), - "Header 'Upgrade: example/1, foo/2' is illegal for HTTP/2 messages"); + Assertions.assertThatThrownBy(() -> + interceptor.process(request, null, context)) + .withFailMessage("Header 'Upgrade: example/1, foo/2' is illegal for HTTP/2 messages").isInstanceOf(HttpException.class); } @Test @@ -214,8 +218,9 @@ void testH2RequestConformanceTEHeader() { request.addHeader("TE", "gzip"); final H2RequestConformance interceptor = new H2RequestConformance(); - Assertions.assertThrows(HttpException.class, () -> interceptor.process(request, null, context), - "Header 'TE: gzip' is illegal for HTTP/2 messages"); + Assertions.assertThatThrownBy(() -> + interceptor.process(request, null, context)) + .withFailMessage("Header 'TE: gzip' is illegal for HTTP/2 messages").isInstanceOf(HttpException.class); } @Test @@ -224,8 +229,9 @@ void testH2ResponseConformanceConnectionHeader() { response.addHeader("Connection", "Keep-Alive"); final H2ResponseConformance interceptor = new H2ResponseConformance(); - Assertions.assertThrows(HttpException.class, () -> interceptor.process(response, null, context), - "Header 'connection: keep-alive' is illegal for HTTP/2 messages"); + Assertions.assertThatThrownBy(() -> + interceptor.process(response, null, context)) + .withFailMessage("Header 'connection: keep-alive' is illegal for HTTP/2 messages").isInstanceOf(HttpException.class); } @Test @@ -234,8 +240,9 @@ void testH2ResponseConformanceKeepAliveHeader() { response.addHeader("keep-alive", "timeout=5, max=1000"); final H2ResponseConformance interceptor = new H2ResponseConformance(); - Assertions.assertThrows(HttpException.class, () -> interceptor.process(response, null, context), - "Header 'keep-alive: timeout=5, max=1000' is illegal for HTTP/2 messages"); + Assertions.assertThatThrownBy(() -> + interceptor.process(response, null, context)) + .withFailMessage("Header 'keep-alive: timeout=5, max=1000' is illegal for HTTP/2 messages").isInstanceOf(HttpException.class); } @Test @@ -244,8 +251,9 @@ void testH2ResponseConformanceTransferEncodingHeader() { response.addHeader("transfer-encoding", "gzip"); final H2ResponseConformance interceptor = new H2ResponseConformance(); - Assertions.assertThrows(HttpException.class, () -> interceptor.process(response, null, context), - "Header 'transfer-encoding: gzip' is illegal for HTTP/2 messages"); + Assertions.assertThatThrownBy(() -> + interceptor.process(response, null, context)) + .withFailMessage("Header 'transfer-encoding: gzip' is illegal for HTTP/2 messages").isInstanceOf(HttpException.class); } @Test @@ -254,8 +262,9 @@ void testH2ResponseConformanceUpgradeHeader() { response.addHeader("upgrade", "example/1, foo/2"); final H2ResponseConformance interceptor = new H2ResponseConformance(); - Assertions.assertThrows(HttpException.class, () -> interceptor.process(response, null, context), - "Header 'upgrade: example/1, foo/2' is illegal for HTTP/2 messages"); + Assertions.assertThatThrownBy(() -> + interceptor.process(response, null, context)) + .withFailMessage("Header 'upgrade: example/1, foo/2' is illegal for HTTP/2 messages").isInstanceOf(HttpException.class); } @Test @@ -263,9 +272,9 @@ void testProxyConnectionRejected() { final BasicHttpResponse response = new BasicHttpResponse(200, "OK"); response.addHeader(HttpHeaders.PROXY_CONNECTION, "keep-alive"); - Assertions.assertThrows( - ProtocolException.class, - () -> H2ResponseConformance.INSTANCE.process(response, null, HttpCoreContext.create())); + Assertions.assertThatThrownBy(() -> + H2ResponseConformance.INSTANCE.process(response, null, HttpCoreContext.create())) + .isInstanceOf(ProtocolException.class); } @Test diff --git a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/protocol/TestH2RequestConformance.java b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/protocol/TestH2RequestConformance.java index e4dc9d3a41..a75b6e4ccc 100644 --- a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/protocol/TestH2RequestConformance.java +++ b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/protocol/TestH2RequestConformance.java @@ -31,7 +31,7 @@ import org.apache.hc.core5.http.ProtocolException; import org.apache.hc.core5.http.message.BasicHttpRequest; import org.apache.hc.core5.http.protocol.HttpCoreContext; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class TestH2RequestConformance { @@ -39,8 +39,9 @@ class TestH2RequestConformance { @Test void testQueryMissingContentType() { final HttpRequest request = new BasicHttpRequest("QUERY", "/"); - Assertions.assertThrows(ProtocolException.class, - () -> H2RequestConformance.INSTANCE.process(request, null, HttpCoreContext.create())); + Assertions.assertThatThrownBy(() -> + H2RequestConformance.INSTANCE.process(request, null, HttpCoreContext.create())) + .isInstanceOf(ProtocolException.class); } @Test @@ -68,8 +69,9 @@ void testTECombinedTokensRejected() { final HttpRequest request = new BasicHttpRequest("GET", "/"); request.addHeader(HttpHeaders.TE, "trailers, gzip"); - Assertions.assertThrows(ProtocolException.class, - () -> H2RequestConformance.INSTANCE.process(request, null, HttpCoreContext.create())); + Assertions.assertThatThrownBy(() -> + H2RequestConformance.INSTANCE.process(request, null, HttpCoreContext.create())) + .isInstanceOf(ProtocolException.class); } @Test @@ -78,8 +80,9 @@ void testTEMultipleHeadersSecondIllegalRejected() { request.addHeader(HttpHeaders.TE, "trailers"); request.addHeader(HttpHeaders.TE, "gzip"); - Assertions.assertThrows(ProtocolException.class, - () -> H2RequestConformance.INSTANCE.process(request, null, HttpCoreContext.create())); + Assertions.assertThatThrownBy(() -> + H2RequestConformance.INSTANCE.process(request, null, HttpCoreContext.create())) + .isInstanceOf(ProtocolException.class); } @Test @@ -111,8 +114,9 @@ void testTECommaListRejected() { final HttpRequest request = new BasicHttpRequest("GET", "/"); request.addHeader(HttpHeaders.TE, "trailers, deflate;q=0.5"); - Assertions.assertThrows(ProtocolException.class, - () -> H2RequestConformance.INSTANCE.process(request, null, HttpCoreContext.create())); + Assertions.assertThatThrownBy(() -> + H2RequestConformance.INSTANCE.process(request, null, HttpCoreContext.create())) + .isInstanceOf(ProtocolException.class); } @@ -131,7 +135,8 @@ void testTEEmptyValueRejected() { final HttpRequest request = new BasicHttpRequest("GET", "/"); request.addHeader(HttpHeaders.TE, ""); - Assertions.assertThrows(ProtocolException.class, - () -> H2RequestConformance.INSTANCE.process(request, null, HttpCoreContext.create())); + Assertions.assertThatThrownBy(() -> + H2RequestConformance.INSTANCE.process(request, null, HttpCoreContext.create())) + .isInstanceOf(ProtocolException.class); } } diff --git a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/protocol/TestH2RequestConnControl.java b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/protocol/TestH2RequestConnControl.java index 0d6b15d99f..390aa47ff3 100644 --- a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/protocol/TestH2RequestConnControl.java +++ b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/protocol/TestH2RequestConnControl.java @@ -30,7 +30,7 @@ import org.apache.hc.core5.http.HttpVersion; import org.apache.hc.core5.http.message.BasicHttpRequest; import org.apache.hc.core5.http.protocol.HttpCoreContext; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class TestH2RequestConnControl { @@ -43,7 +43,7 @@ void addsConnectionHeaderForHttp1() throws Exception { H2RequestConnControl.INSTANCE.process(request, null, context); - Assertions.assertTrue(request.containsHeader(HttpHeaders.CONNECTION)); + Assertions.assertThat(request.containsHeader(HttpHeaders.CONNECTION)).isTrue(); } @Test @@ -54,7 +54,7 @@ void skipsConnectionHeaderForHttp2() throws Exception { H2RequestConnControl.INSTANCE.process(request, null, context); - Assertions.assertFalse(request.containsHeader(HttpHeaders.CONNECTION)); + Assertions.assertThat(request.containsHeader(HttpHeaders.CONNECTION)).isFalse(); } } diff --git a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/protocol/TestH2RequestTargetHost.java b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/protocol/TestH2RequestTargetHost.java index e66cf5420c..e07c7937a9 100644 --- a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/protocol/TestH2RequestTargetHost.java +++ b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/protocol/TestH2RequestTargetHost.java @@ -31,7 +31,7 @@ import org.apache.hc.core5.http.message.BasicHttpRequest; import org.apache.hc.core5.http.protocol.HttpCoreContext; import org.apache.hc.core5.net.URIAuthority; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class TestH2RequestTargetHost { @@ -45,7 +45,7 @@ void addsHostHeaderForHttp1() throws Exception { H2RequestTargetHost.INSTANCE.process(request, null, context); - Assertions.assertTrue(request.containsHeader(HttpHeaders.HOST)); + Assertions.assertThat(request.containsHeader(HttpHeaders.HOST)).isTrue(); } @Test @@ -57,7 +57,7 @@ void skipsHostHeaderForHttp2() throws Exception { H2RequestTargetHost.INSTANCE.process(request, null, context); - Assertions.assertFalse(request.containsHeader(HttpHeaders.HOST)); + Assertions.assertThat(request.containsHeader(HttpHeaders.HOST)).isFalse(); } } diff --git a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/protocol/TestH2RequestValidateHost.java b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/protocol/TestH2RequestValidateHost.java index e9a416ec88..48e5dab54e 100644 --- a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/protocol/TestH2RequestValidateHost.java +++ b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/protocol/TestH2RequestValidateHost.java @@ -35,7 +35,7 @@ import org.apache.hc.core5.http.protocol.HttpContext; import org.apache.hc.core5.http.protocol.HttpCoreContext; import org.apache.hc.core5.net.URIAuthority; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.mockito.Mockito; @@ -50,7 +50,7 @@ void validatesHostForHttp1() throws Exception { H2RequestValidateHost.INSTANCE.process(request, null, context); - Assertions.assertNotNull(request.getAuthority()); + Assertions.assertThat(request.getAuthority()).isNotNull(); } @Test @@ -62,7 +62,7 @@ void skipsValidationForHttp2() throws Exception { H2RequestValidateHost.INSTANCE.process(request, null, context); - Assertions.assertNull(request.getAuthority()); + Assertions.assertThat(request.getAuthority()).isNull(); } @Test @@ -88,8 +88,8 @@ void testHttp2HostMismatchRejected() { final HttpContext context = Mockito.mock(HttpContext.class); Mockito.when(context.getProtocolVersion()).thenReturn(HttpVersion.HTTP_2); - Assertions.assertThrows(ProtocolException.class, () -> - H2RequestValidateHost.INSTANCE.process(request, null, context)); + Assertions.assertThatThrownBy(() -> + H2RequestValidateHost.INSTANCE.process(request, null, context)).isInstanceOf(ProtocolException.class); } @Test @@ -115,8 +115,8 @@ void testHttp2HostPortDiffersRejected() { final HttpContext context = Mockito.mock(HttpContext.class); Mockito.when(context.getProtocolVersion()).thenReturn(HttpVersion.HTTP_2); - Assertions.assertThrows(ProtocolException.class, () -> - H2RequestValidateHost.INSTANCE.process(request, null, context)); + Assertions.assertThatThrownBy(() -> + H2RequestValidateHost.INSTANCE.process(request, null, context)).isInstanceOf(ProtocolException.class); } } diff --git a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/protocol/TestH2ResponseConnControl.java b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/protocol/TestH2ResponseConnControl.java index 7b3af4dccd..14a704e30c 100644 --- a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/protocol/TestH2ResponseConnControl.java +++ b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/protocol/TestH2ResponseConnControl.java @@ -32,7 +32,7 @@ import org.apache.hc.core5.http.HttpVersion; import org.apache.hc.core5.http.message.BasicHttpResponse; import org.apache.hc.core5.http.protocol.HttpCoreContext; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class TestH2ResponseConnControl { @@ -45,7 +45,7 @@ void addsConnectionHeaderForHttp1OnError() throws Exception { H2ResponseConnControl.INSTANCE.process(response, null, context); - Assertions.assertEquals(HeaderElements.CLOSE, response.getFirstHeader(HttpHeaders.CONNECTION).getValue()); + Assertions.assertThat(response.getFirstHeader(HttpHeaders.CONNECTION).getValue()).isEqualTo(HeaderElements.CLOSE); } @Test @@ -56,7 +56,7 @@ void skipsConnectionHeaderForHttp2() throws Exception { H2ResponseConnControl.INSTANCE.process(response, null, context); - Assertions.assertFalse(response.containsHeader(HttpHeaders.CONNECTION)); + Assertions.assertThat(response.containsHeader(HttpHeaders.CONNECTION)).isFalse(); } } diff --git a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/protocol/TestH2ResponseContent.java b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/protocol/TestH2ResponseContent.java index 45a19f9f33..8fe83bd35a 100644 --- a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/protocol/TestH2ResponseContent.java +++ b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/protocol/TestH2ResponseContent.java @@ -32,7 +32,7 @@ import org.apache.hc.core5.http.impl.BasicEntityDetails; import org.apache.hc.core5.http.message.BasicHttpResponse; import org.apache.hc.core5.http.protocol.HttpCoreContext; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class TestH2ResponseContent { @@ -46,8 +46,8 @@ void addsContentHeadersForHttp2Entity() throws Exception { final BasicEntityDetails entity = new BasicEntityDetails(10, ContentType.TEXT_PLAIN); H2ResponseContent.INSTANCE.process(response, entity, context); - Assertions.assertTrue(response.containsHeader(HttpHeaders.CONTENT_TYPE)); - Assertions.assertFalse(response.containsHeader(HttpHeaders.CONTENT_LENGTH)); + Assertions.assertThat(response.containsHeader(HttpHeaders.CONTENT_TYPE)).isTrue(); + Assertions.assertThat(response.containsHeader(HttpHeaders.CONTENT_LENGTH)).isFalse(); } @Test @@ -59,7 +59,7 @@ void addsContentLengthForHttp1() throws Exception { final BasicEntityDetails entity = new BasicEntityDetails(5, ContentType.TEXT_PLAIN); H2ResponseContent.INSTANCE.process(response, entity, context); - Assertions.assertEquals("5", response.getFirstHeader(HttpHeaders.CONTENT_LENGTH).getValue()); + Assertions.assertThat(response.getFirstHeader(HttpHeaders.CONTENT_LENGTH).getValue()).isEqualTo("5"); } } diff --git a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/ssl/ConscryptClientTlsStrategyTest.java b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/ssl/ConscryptClientTlsStrategyTest.java index 2f186d78d3..a5865e22db 100644 --- a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/ssl/ConscryptClientTlsStrategyTest.java +++ b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/ssl/ConscryptClientTlsStrategyTest.java @@ -27,9 +27,8 @@ package org.apache.hc.core5.http2.ssl; -import static org.junit.jupiter.api.Assertions.assertNotNull; - import org.apache.hc.core5.reactor.ssl.SSLSessionVerifier; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.mockito.Mock; @@ -46,12 +45,12 @@ void prepareMocks() { @Test void test_valid_tls_strategy_creation() { final ConscryptClientTlsStrategy strategy = new ConscryptClientTlsStrategy(); - assertNotNull(strategy); + Assertions.assertThat(strategy).isNotNull(); } @Test void test_valid_tls_strategy_creation_with_verifier() { final ConscryptClientTlsStrategy strategy = new ConscryptClientTlsStrategy(sslSessionVerifier); - assertNotNull(strategy); + Assertions.assertThat(strategy).isNotNull(); } } \ No newline at end of file diff --git a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/ssl/TestApplicationProtocol.java b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/ssl/TestApplicationProtocol.java index 5300c7be99..ef0e075596 100644 --- a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/ssl/TestApplicationProtocol.java +++ b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/ssl/TestApplicationProtocol.java @@ -26,15 +26,15 @@ */ package org.apache.hc.core5.http2.ssl; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class TestApplicationProtocol { @Test void toStringReturnsProtocolId() { - Assertions.assertEquals("h2", ApplicationProtocol.HTTP_2.toString()); - Assertions.assertEquals("http/1.1", ApplicationProtocol.HTTP_1_1.toString()); + Assertions.assertThat(ApplicationProtocol.HTTP_2.toString()).isEqualTo("h2"); + Assertions.assertThat(ApplicationProtocol.HTTP_1_1.toString()).isEqualTo("http/1.1"); } } diff --git a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/ssl/TestH2ClientTlsStrategy.java b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/ssl/TestH2ClientTlsStrategy.java index a06805de48..853d95f48c 100644 --- a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/ssl/TestH2ClientTlsStrategy.java +++ b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/ssl/TestH2ClientTlsStrategy.java @@ -39,7 +39,7 @@ import org.apache.hc.core5.reactor.ssl.TransportSecurityLayer; import org.apache.hc.core5.ssl.SSLContexts; import org.apache.hc.core5.util.Timeout; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.mockito.ArgumentCaptor; import org.mockito.Mockito; @@ -72,9 +72,9 @@ void upgradeConfiguresSslParameters() throws Exception { initializer.initialize(endpoint, sslEngine); final SSLParameters sslParameters = sslEngine.getSSLParameters(); - Assertions.assertEquals(URIScheme.HTTPS.id, sslParameters.getEndpointIdentificationAlgorithm()); - Assertions.assertArrayEquals(new String[] { ApplicationProtocol.HTTP_2.id }, - sslParameters.getApplicationProtocols()); + Assertions.assertThat(sslParameters.getEndpointIdentificationAlgorithm()).isEqualTo(URIScheme.HTTPS.id); + Assertions.assertThat(sslParameters.getApplicationProtocols()) + .containsExactly(new String[]{ApplicationProtocol.HTTP_2.id}); } @Test @@ -87,7 +87,7 @@ void deprecatedUpgradeReturnsFalseForNonHttps() { final boolean upgraded = strategy.upgrade(tlsSession, host, null, null, null, Timeout.ofSeconds(1)); - Assertions.assertFalse(upgraded); + Assertions.assertThat(upgraded).isFalse(); Mockito.verifyNoInteractions(tlsSession); } diff --git a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/ssl/TestH2ServerTlsStrategy.java b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/ssl/TestH2ServerTlsStrategy.java index f0e3900b13..3e145830a7 100644 --- a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/ssl/TestH2ServerTlsStrategy.java +++ b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/ssl/TestH2ServerTlsStrategy.java @@ -41,7 +41,7 @@ import org.apache.hc.core5.reactor.ssl.TransportSecurityLayer; import org.apache.hc.core5.ssl.SSLContexts; import org.apache.hc.core5.util.Timeout; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.mockito.ArgumentCaptor; import org.mockito.Mockito; @@ -75,8 +75,8 @@ void upgradeConfiguresSslParameters() throws Exception { initializer.initialize(endpoint, sslEngine); final SSLParameters sslParameters = sslEngine.getSSLParameters(); - Assertions.assertArrayEquals(new String[] { ApplicationProtocol.HTTP_1_1.id }, - sslParameters.getApplicationProtocols()); + Assertions.assertThat(sslParameters.getApplicationProtocols()) + .containsExactly(new String[]{ApplicationProtocol.HTTP_1_1.id}); } @Test @@ -95,7 +95,7 @@ void deprecatedUpgradeRespectsSecurePorts() { null, null, Timeout.ofSeconds(1)); - Assertions.assertFalse(notUpgraded); + Assertions.assertThat(notUpgraded).isFalse(); Mockito.verifyNoInteractions(tlsSession); final boolean upgraded = strategy.upgrade( @@ -105,7 +105,7 @@ void deprecatedUpgradeRespectsSecurePorts() { null, null, Timeout.ofSeconds(1)); - Assertions.assertTrue(upgraded); + Assertions.assertThat(upgraded).isTrue(); Mockito.verify(tlsSession).startTls( Mockito.eq(sslContext), Mockito.eq(host), diff --git a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/ssl/TestH2TlsSupport.java b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/ssl/TestH2TlsSupport.java index 42717df0d1..03578f9fa7 100644 --- a/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/ssl/TestH2TlsSupport.java +++ b/httpcore5-h2/src/test/java/org/apache/hc/core5/http2/ssl/TestH2TlsSupport.java @@ -32,26 +32,23 @@ import org.apache.hc.core5.http2.HttpVersionPolicy; import org.apache.hc.core5.reactor.ssl.SSLSessionInitializer; import org.apache.hc.core5.ssl.SSLContexts; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class TestH2TlsSupport { @Test void selectApplicationProtocolsDefault() { - Assertions.assertArrayEquals( - new String[] { ApplicationProtocol.HTTP_2.id, ApplicationProtocol.HTTP_1_1.id }, - H2TlsSupport.selectApplicationProtocols(null)); + Assertions.assertThat(H2TlsSupport.selectApplicationProtocols(null)) + .containsExactly(new String[]{ApplicationProtocol.HTTP_2.id, ApplicationProtocol.HTTP_1_1.id}); } @Test void selectApplicationProtocolsForced() { - Assertions.assertArrayEquals( - new String[] { ApplicationProtocol.HTTP_2.id }, - H2TlsSupport.selectApplicationProtocols(HttpVersionPolicy.FORCE_HTTP_2)); - Assertions.assertArrayEquals( - new String[] { ApplicationProtocol.HTTP_1_1.id }, - H2TlsSupport.selectApplicationProtocols(HttpVersionPolicy.FORCE_HTTP_1)); + Assertions.assertThat(H2TlsSupport.selectApplicationProtocols(HttpVersionPolicy.FORCE_HTTP_2)) + .containsExactly(new String[]{ApplicationProtocol.HTTP_2.id}); + Assertions.assertThat(H2TlsSupport.selectApplicationProtocols(HttpVersionPolicy.FORCE_HTTP_1)) + .containsExactly(new String[]{ApplicationProtocol.HTTP_1_1.id}); } @Test @@ -62,9 +59,8 @@ void enforceRequirementsSetsApplicationProtocols() { H2TlsSupport.enforceRequirements(HttpVersionPolicy.FORCE_HTTP_2, sslParameters); - Assertions.assertArrayEquals( - new String[] { ApplicationProtocol.HTTP_2.id }, - sslParameters.getApplicationProtocols()); + Assertions.assertThat(sslParameters.getApplicationProtocols()) + .containsExactly(new String[]{ApplicationProtocol.HTTP_2.id}); } @Test @@ -79,7 +75,7 @@ void enforceRequirementsInitializerInvoked() throws Exception { HttpVersionPolicy.FORCE_HTTP_1, initializer); enforcing.initialize(null, sslContext.createSSLEngine()); - Assertions.assertSame(initializer, called[0]); + Assertions.assertThat(called[0]).isSameAs(initializer); } } diff --git a/httpcore5-reactive/pom.xml b/httpcore5-reactive/pom.xml index 59d2c9974b..53b9a3ea29 100644 --- a/httpcore5-reactive/pom.xml +++ b/httpcore5-reactive/pom.xml @@ -54,6 +54,11 @@ junit-jupiter test + + org.assertj + assertj-core + test + io.reactivex.rxjava3 rxjava diff --git a/httpcore5-reactive/src/test/java/org/apache/hc/core5/reactive/TestReactiveDataConsumer.java b/httpcore5-reactive/src/test/java/org/apache/hc/core5/reactive/TestReactiveDataConsumer.java index f7b5b4b381..1859afe35f 100644 --- a/httpcore5-reactive/src/test/java/org/apache/hc/core5/reactive/TestReactiveDataConsumer.java +++ b/httpcore5-reactive/src/test/java/org/apache/hc/core5/reactive/TestReactiveDataConsumer.java @@ -41,7 +41,7 @@ import io.reactivex.rxjava3.core.Single; import org.apache.hc.core5.http.HttpStreamResetException; import org.apache.hc.core5.http.nio.CapacityChannel; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.reactivestreams.Subscriber; import org.reactivestreams.Subscription; @@ -72,11 +72,11 @@ void testStreamThatEndsNormally() throws Exception { consumer.consume(ByteBuffer.wrap(new byte[]{ '3' })); consumer.streamEnd(null); - Assertions.assertTrue(complete.await(1, TimeUnit.SECONDS), "Stream did not finish before timeout"); - Assertions.assertEquals(3, output.size()); - Assertions.assertEquals(ByteBuffer.wrap(new byte[]{ '1' }), output.get(0)); - Assertions.assertEquals(ByteBuffer.wrap(new byte[]{ '2' }), output.get(1)); - Assertions.assertEquals(ByteBuffer.wrap(new byte[]{ '3' }), output.get(2)); + Assertions.assertThat(complete.await(1, TimeUnit.SECONDS)).withFailMessage("Stream did not finish before timeout").isTrue(); + Assertions.assertThat(output.size()).isEqualTo(3); + Assertions.assertThat(output.get(0)).isEqualTo(ByteBuffer.wrap(new byte[]{'1'})); + Assertions.assertThat(output.get(1)).isEqualTo(ByteBuffer.wrap(new byte[]{'2'})); + Assertions.assertThat(output.get(2)).isEqualTo(ByteBuffer.wrap(new byte[]{'3'})); } @Test @@ -89,7 +89,7 @@ void testStreamThatEndsWithError() { final Exception ex = new RuntimeException(); consumer.failed(ex); - Assertions.assertSame(ex, single.blockingGet().get(0).getError()); + Assertions.assertThat(single.blockingGet().get(0).getError()).isSameAs(ex); } @Test @@ -114,8 +114,8 @@ public void onComplete() { } }); - Assertions.assertThrows(HttpStreamResetException.class, () -> - consumer.consume(ByteBuffer.wrap(new byte[1024]))); + Assertions.assertThatThrownBy(() -> + consumer.consume(ByteBuffer.wrap(new byte[1024]))).isInstanceOf(HttpStreamResetException.class); } @Test @@ -126,7 +126,7 @@ void testCapacityIncrements() throws Exception { final AtomicInteger lastIncrement = new AtomicInteger(-1); final CapacityChannel channel = lastIncrement::set; consumer.updateCapacity(channel); - Assertions.assertEquals(-1, lastIncrement.get(), "CapacityChannel#update should not have been invoked yet"); + Assertions.assertThat(lastIncrement.get()).withFailMessage("CapacityChannel#update should not have been invoked yet").isEqualTo(-1); final AtomicInteger received = new AtomicInteger(0); final AtomicReference subscription = new AtomicReference<>(); @@ -156,13 +156,13 @@ public void onComplete() { consumer.consume(data.duplicate()); subscription.get().request(1); - Assertions.assertEquals(1024, lastIncrement.get()); + Assertions.assertThat(lastIncrement.get()).isEqualTo(1024); subscription.get().request(2); - Assertions.assertEquals(2 * 1024, lastIncrement.get()); + Assertions.assertThat(lastIncrement.get()).isEqualTo(2 * 1024); subscription.get().request(99); - Assertions.assertEquals(1024, lastIncrement.get()); + Assertions.assertThat(lastIncrement.get()).isEqualTo(1024); } @Test @@ -177,7 +177,7 @@ void testFullResponseBuffering() throws Exception { consumer.consume(data.duplicate()); consumer.streamEnd(null); - Assertions.assertEquals(3L, Flowable.fromPublisher(consumer).count().blockingGet().longValue()); + Assertions.assertThat(Flowable.fromPublisher(consumer).count().blockingGet().longValue()).isEqualTo(3L); } @Test @@ -195,7 +195,7 @@ void testErrorBuffering() throws Exception { .materialize() .singleOrError() .blockingGet(); - Assertions.assertSame(ex, result.getError()); + Assertions.assertThat(result.getError()).isSameAs(ex); } @Test @@ -214,7 +214,7 @@ void testFailAfterCompletion() { .materialize() .singleOrError() .blockingGet(); - Assertions.assertFalse(result.isOnError()); - Assertions.assertTrue(result.isOnComplete()); + Assertions.assertThat(result.isOnError()).isFalse(); + Assertions.assertThat(result.isOnComplete()).isTrue(); } } diff --git a/httpcore5-reactive/src/test/java/org/apache/hc/core5/reactive/TestReactiveDataProducer.java b/httpcore5-reactive/src/test/java/org/apache/hc/core5/reactive/TestReactiveDataProducer.java index 4440e51b70..8b76814ad2 100644 --- a/httpcore5-reactive/src/test/java/org/apache/hc/core5/reactive/TestReactiveDataProducer.java +++ b/httpcore5-reactive/src/test/java/org/apache/hc/core5/reactive/TestReactiveDataProducer.java @@ -29,13 +29,13 @@ import java.nio.ByteBuffer; import java.nio.charset.StandardCharsets; +import io.reactivex.rxjava3.core.Flowable; import org.apache.hc.core5.http.HttpStreamResetException; import org.apache.hc.core5.http.nio.DataStreamChannel; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; +import org.assertj.core.api.InstanceOfAssertFactories; import org.junit.jupiter.api.Test; -import io.reactivex.rxjava3.core.Flowable; - class TestReactiveDataProducer { @Test void testStreamThatEndsNormally() throws Exception { @@ -49,13 +49,13 @@ void testStreamThatEndsNormally() throws Exception { producer.produce(streamChannel); - Assertions.assertTrue(byteChannel.isOpen()); - Assertions.assertEquals("123456", byteChannel.dump(StandardCharsets.US_ASCII)); + Assertions.assertThat(byteChannel.isOpen()).isTrue(); + Assertions.assertThat(byteChannel.dump(StandardCharsets.US_ASCII)).isEqualTo("123456"); producer.produce(streamChannel); - Assertions.assertFalse(byteChannel.isOpen()); - Assertions.assertEquals("", byteChannel.dump(StandardCharsets.US_ASCII)); + Assertions.assertThat(byteChannel.isOpen()).isFalse(); + Assertions.assertThat(byteChannel.dump(StandardCharsets.US_ASCII)).isEqualTo(""); } @Test @@ -76,11 +76,11 @@ void testStreamThatEndsWithError() throws Exception { final DataStreamChannel streamChannel = new BasicDataStreamChannel(byteChannel); producer.produce(streamChannel); - Assertions.assertEquals("12345", byteChannel.dump(StandardCharsets.US_ASCII)); + Assertions.assertThat(byteChannel.dump(StandardCharsets.US_ASCII)).isEqualTo("12345"); - final HttpStreamResetException exception = Assertions.assertThrows(HttpStreamResetException.class, () -> - producer.produce(streamChannel)); - Assertions.assertInstanceOf(RuntimeException.class, exception.getCause(), "Expected published exception to be rethrown"); - Assertions.assertEquals("", byteChannel.dump(StandardCharsets.US_ASCII)); + final HttpStreamResetException exception = Assertions.assertThatThrownBy(() -> + producer.produce(streamChannel)).isInstanceOf(HttpStreamResetException.class).asInstanceOf(InstanceOfAssertFactories.type(HttpStreamResetException.class)).actual(); + Assertions.assertThat(exception.getCause()).withFailMessage("Expected published exception to be rethrown").isInstanceOf(RuntimeException.class); + Assertions.assertThat(byteChannel.dump(StandardCharsets.US_ASCII)).isEqualTo(""); } } diff --git a/httpcore5-reactive/src/test/java/org/apache/hc/core5/reactive/TestReactiveEntityProducer.java b/httpcore5-reactive/src/test/java/org/apache/hc/core5/reactive/TestReactiveEntityProducer.java index a161ea6ee0..72c7a9864c 100644 --- a/httpcore5-reactive/src/test/java/org/apache/hc/core5/reactive/TestReactiveEntityProducer.java +++ b/httpcore5-reactive/src/test/java/org/apache/hc/core5/reactive/TestReactiveEntityProducer.java @@ -30,14 +30,14 @@ import java.nio.charset.StandardCharsets; import java.util.Collections; +import io.reactivex.rxjava3.core.Flowable; import org.apache.hc.core5.http.ContentType; import org.apache.hc.core5.http.HttpStreamResetException; import org.apache.hc.core5.http.nio.DataStreamChannel; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; +import org.assertj.core.api.InstanceOfAssertFactories; import org.junit.jupiter.api.Test; -import io.reactivex.rxjava3.core.Flowable; - class TestReactiveEntityProducer { private static final long CONTENT_LENGTH = 1; @@ -56,20 +56,20 @@ void testStreamThatEndsNormally() throws Exception { entityProducer.produce(streamChannel); - Assertions.assertTrue(byteChannel.isOpen(), "Should be open"); - Assertions.assertEquals("123456", byteChannel.dump(StandardCharsets.US_ASCII)); + Assertions.assertThat(byteChannel.isOpen()).withFailMessage("Should be open").isTrue(); + Assertions.assertThat(byteChannel.dump(StandardCharsets.US_ASCII)).isEqualTo("123456"); entityProducer.produce(streamChannel); - Assertions.assertFalse(byteChannel.isOpen(), "Should be closed"); - Assertions.assertEquals("", byteChannel.dump(StandardCharsets.US_ASCII)); - Assertions.assertFalse(entityProducer.isChunked()); - Assertions.assertEquals(GZIP_CONTENT_ENCODING, entityProducer.getContentEncoding()); - Assertions.assertEquals(Collections.emptySet(), entityProducer.getTrailerNames()); - Assertions.assertEquals(CONTENT_LENGTH, entityProducer.getContentLength()); - Assertions.assertEquals(CONTENT_TYPE.toString(), entityProducer.getContentType()); - Assertions.assertFalse(entityProducer.isRepeatable()); - Assertions.assertEquals(1, entityProducer.available()); + Assertions.assertThat(byteChannel.isOpen()).withFailMessage("Should be closed").isFalse(); + Assertions.assertThat(byteChannel.dump(StandardCharsets.US_ASCII)).isEqualTo(""); + Assertions.assertThat(entityProducer.isChunked()).isFalse(); + Assertions.assertThat(entityProducer.getContentEncoding()).isEqualTo(GZIP_CONTENT_ENCODING); + Assertions.assertThat(entityProducer.getTrailerNames()).isEqualTo(Collections.emptySet()); + Assertions.assertThat(entityProducer.getContentLength()).isEqualTo(CONTENT_LENGTH); + Assertions.assertThat(entityProducer.getContentType()).isEqualTo(CONTENT_TYPE.toString()); + Assertions.assertThat(entityProducer.isRepeatable()).isFalse(); + Assertions.assertThat(entityProducer.available()).isEqualTo(1); entityProducer.releaseResources(); } @@ -93,24 +93,24 @@ void testStreamThatEndsWithError() throws Exception { final DataStreamChannel streamChannel = new BasicDataStreamChannel(byteChannel); entityProducer.produce(streamChannel); - Assertions.assertEquals("12345", byteChannel.dump(StandardCharsets.US_ASCII)); + Assertions.assertThat(byteChannel.dump(StandardCharsets.US_ASCII)).isEqualTo("12345"); - final HttpStreamResetException exception = Assertions.assertThrows(HttpStreamResetException.class, () -> - entityProducer.produce(streamChannel)); - Assertions.assertInstanceOf(RuntimeException.class, exception.getCause(), "Expected published exception to be rethrown"); - Assertions.assertEquals("", byteChannel.dump(StandardCharsets.US_ASCII)); + final HttpStreamResetException exception = Assertions.assertThatThrownBy(() -> + entityProducer.produce(streamChannel)).isInstanceOf(HttpStreamResetException.class).asInstanceOf(InstanceOfAssertFactories.type(HttpStreamResetException.class)).actual(); + Assertions.assertThat(exception.getCause()).withFailMessage("Expected published exception to be rethrown").isInstanceOf(RuntimeException.class); + Assertions.assertThat(byteChannel.dump(StandardCharsets.US_ASCII)).isEqualTo(""); entityProducer.failed(exception); - Assertions.assertEquals(1, entityProducer.available()); - - Assertions.assertTrue(byteChannel.isOpen()); - Assertions.assertEquals("", byteChannel.dump(StandardCharsets.US_ASCII)); - Assertions.assertFalse(entityProducer.isChunked()); - Assertions.assertEquals(GZIP_CONTENT_ENCODING, entityProducer.getContentEncoding()); - Assertions.assertEquals(Collections.emptySet(), entityProducer.getTrailerNames()); - Assertions.assertEquals(CONTENT_LENGTH, entityProducer.getContentLength()); - Assertions.assertEquals(CONTENT_TYPE.toString(), entityProducer.getContentType()); - Assertions.assertFalse(entityProducer.isRepeatable()); - Assertions.assertEquals(1, entityProducer.available()); + Assertions.assertThat(entityProducer.available()).isEqualTo(1); + + Assertions.assertThat(byteChannel.isOpen()).isTrue(); + Assertions.assertThat(byteChannel.dump(StandardCharsets.US_ASCII)).isEqualTo(""); + Assertions.assertThat(entityProducer.isChunked()).isFalse(); + Assertions.assertThat(entityProducer.getContentEncoding()).isEqualTo(GZIP_CONTENT_ENCODING); + Assertions.assertThat(entityProducer.getTrailerNames()).isEqualTo(Collections.emptySet()); + Assertions.assertThat(entityProducer.getContentLength()).isEqualTo(CONTENT_LENGTH); + Assertions.assertThat(entityProducer.getContentType()).isEqualTo(CONTENT_TYPE.toString()); + Assertions.assertThat(entityProducer.isRepeatable()).isFalse(); + Assertions.assertThat(entityProducer.available()).isEqualTo(1); entityProducer.releaseResources(); } diff --git a/httpcore5-testing/pom.xml b/httpcore5-testing/pom.xml index a0d8968d43..e7ae6c4757 100644 --- a/httpcore5-testing/pom.xml +++ b/httpcore5-testing/pom.xml @@ -90,6 +90,11 @@ junit-jupiter test + + org.assertj + assertj-core + test + org.junit.platform junit-platform-launcher diff --git a/httpcore5-testing/src/test/java/org/apache/hc/core5/benchmark/BenchmarkToolTest.java b/httpcore5-testing/src/test/java/org/apache/hc/core5/benchmark/BenchmarkToolTest.java index 719b3ef5b7..8a68df00a2 100644 --- a/httpcore5-testing/src/test/java/org/apache/hc/core5/benchmark/BenchmarkToolTest.java +++ b/httpcore5-testing/src/test/java/org/apache/hc/core5/benchmark/BenchmarkToolTest.java @@ -56,8 +56,8 @@ import org.apache.hc.core5.io.CloseMode; import org.apache.hc.core5.net.URIBuilder; import org.apache.hc.core5.reactor.ListenerEndpoint; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.AfterEach; -import org.junit.jupiter.api.Assertions; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.Arguments; import org.junit.jupiter.params.provider.MethodSource; @@ -138,14 +138,14 @@ void testBasics(final HttpVersionPolicy versionPolicy) throws Exception { .build(); final HttpBenchmark httpBenchmark = new HttpBenchmark(config); final Results results = httpBenchmark.execute(); - Assertions.assertNotNull(results); - Assertions.assertEquals(100, results.getSuccessCount()); - Assertions.assertEquals(0, results.getFailureCount()); - Assertions.assertEquals(16, results.getContentLength()); - Assertions.assertEquals(3, results.getConcurrencyLevel()); - Assertions.assertEquals(100 * 16, results.getTotalContentBytesRecvd()); + Assertions.assertThat(results).isNotNull(); + Assertions.assertThat(results.getSuccessCount()).isEqualTo(100); + Assertions.assertThat(results.getFailureCount()).isEqualTo(0); + Assertions.assertThat(results.getContentLength()).isEqualTo(16); + Assertions.assertThat(results.getConcurrencyLevel()).isEqualTo(3); + Assertions.assertThat(results.getTotalContentBytesRecvd()).isEqualTo(100 * 16); if (versionPolicy == HttpVersionPolicy.FORCE_HTTP_2) { - Assertions.assertEquals(HttpVersion.HTTP_2, results.getProtocolVersion()); + Assertions.assertThat(results.getProtocolVersion()).isEqualTo(HttpVersion.HTTP_2); } } diff --git a/httpcore5-testing/src/test/java/org/apache/hc/core5/benchmark/ResultFormatterTest.java b/httpcore5-testing/src/test/java/org/apache/hc/core5/benchmark/ResultFormatterTest.java index ba36247820..11f4cad6c0 100644 --- a/httpcore5-testing/src/test/java/org/apache/hc/core5/benchmark/ResultFormatterTest.java +++ b/httpcore5-testing/src/test/java/org/apache/hc/core5/benchmark/ResultFormatterTest.java @@ -27,12 +27,12 @@ package org.apache.hc.core5.benchmark; -import org.junit.jupiter.api.Assertions; import java.io.ByteArrayOutputStream; import java.io.PrintStream; import java.nio.charset.StandardCharsets; import org.apache.hc.core5.http.HttpVersion; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class ResultFormatterTest { @@ -56,8 +56,7 @@ void testBasics() throws Exception { 50000000); final ByteArrayOutputStream buf = new ByteArrayOutputStream(); ResultFormatter.print(new PrintStream(buf, true, StandardCharsets.US_ASCII.name()), results); - Assertions.assertEquals( - "Server Software:\t\tTestServer/1.1\n" + + Assertions.assertThat(new String(buf.toByteArray(), StandardCharsets.US_ASCII).replace("\r\n", "\n")).isEqualTo("Server Software:\t\tTestServer/1.1\n" + "Protocol version:\t\tHTTP/1.1\n" + "Server Hostname:\t\tlocalhost\n" + "Server Port:\t\t\t8080\n" + @@ -74,8 +73,7 @@ void testBasics() throws Exception { "Requests per second:\t5,884.08 [#/sec] (mean)\n" + "Time per request:\t\t0.850 [ms] (mean)\n" + "Time per request:\t\t0.170 [ms] (mean, across all concurrent requests)\n" + - "Transfer rate:\t\t\t17,997.02 [Kbytes/sec] received\n" - , new String(buf.toByteArray(), StandardCharsets.US_ASCII).replace("\r\n", "\n")); + "Transfer rate:\t\t\t17,997.02 [Kbytes/sec] received\n"); } } diff --git a/httpcore5-testing/src/test/java/org/apache/hc/core5/http2/hpack/TestHuffmanDecoderCompatibility.java b/httpcore5-testing/src/test/java/org/apache/hc/core5/http2/hpack/TestHuffmanDecoderCompatibility.java index 2f5247dd82..55ea4c5749 100644 --- a/httpcore5-testing/src/test/java/org/apache/hc/core5/http2/hpack/TestHuffmanDecoderCompatibility.java +++ b/httpcore5-testing/src/test/java/org/apache/hc/core5/http2/hpack/TestHuffmanDecoderCompatibility.java @@ -31,7 +31,7 @@ import java.util.Random; import org.apache.hc.core5.util.ByteArrayBuffer; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class TestHuffmanDecoderCompatibility { @@ -60,8 +60,8 @@ private static byte[] encode(final byte[] input) { private static void assertSameResult(final LegacyHuffmanDecoder legacy, final byte[] encoded) throws Exception { final Result expected = decodeLegacy(legacy, encoded); final Result actual = decodeDfa(encoded); - Assertions.assertEquals(expected.failed, actual.failed); - Assertions.assertArrayEquals(expected.output, actual.output); + Assertions.assertThat(actual.failed).isEqualTo(expected.failed); + Assertions.assertThat(actual.output).containsExactly(expected.output); } private static Result decodeLegacy(final LegacyHuffmanDecoder legacy, final byte[] encoded) { diff --git a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/async/AsyncH2SocketTimeoutCoreTest.java b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/async/AsyncH2SocketTimeoutCoreTest.java index bdab16d2aa..6c6f029a91 100644 --- a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/async/AsyncH2SocketTimeoutCoreTest.java +++ b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/async/AsyncH2SocketTimeoutCoreTest.java @@ -65,7 +65,8 @@ import org.apache.hc.core5.testing.extension.nio.H2AsyncRequesterResource; import org.apache.hc.core5.testing.extension.nio.H2AsyncServerResource; import org.apache.hc.core5.util.Timeout; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; +import org.assertj.core.api.InstanceOfAssertFactories; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.RegisterExtension; @@ -124,15 +125,12 @@ void testHttp2RequestTimeoutYieldsStreamReset() throws Exception { final Future> future = requester.execute(requestProducer, responseConsumer, REQUEST_TIMEOUT, null); - final ExecutionException ex = Assertions.assertThrows( - ExecutionException.class, - () -> future.get(RESULT_TIMEOUT.getDuration(), RESULT_TIMEOUT.getTimeUnit())); + final ExecutionException ex = Assertions.assertThatThrownBy(() -> + future.get(RESULT_TIMEOUT.getDuration(), RESULT_TIMEOUT.getTimeUnit())) + .isInstanceOf(ExecutionException.class).asInstanceOf(InstanceOfAssertFactories.type(ExecutionException.class)).actual(); final Throwable cause = ex.getCause(); - Assertions.assertInstanceOf( - HttpStreamResetException.class, - cause, - "Expected HttpStreamResetException, but got: " + cause); + Assertions.assertThat(cause).withFailMessage("Expected HttpStreamResetException, but got: " + cause).isInstanceOf(HttpStreamResetException.class); } private InetSocketAddress startServer() throws Exception { diff --git a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/classic/ClassicAuthenticationTest.java b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/classic/ClassicAuthenticationTest.java index 93a962e495..1abb2e3d24 100644 --- a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/classic/ClassicAuthenticationTest.java +++ b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/classic/ClassicAuthenticationTest.java @@ -60,7 +60,7 @@ import org.apache.hc.core5.testing.extension.classic.HttpRequesterResource; import org.apache.hc.core5.testing.extension.classic.HttpServerResource; import org.apache.hc.core5.util.Timeout; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.RegisterExtension; @@ -134,16 +134,16 @@ void testGetRequestAuthentication() throws Exception { final HttpCoreContext context = HttpCoreContext.create(); final ClassicHttpRequest request1 = new BasicClassicHttpRequest(Method.GET, "/stuff"); try (final ClassicHttpResponse response1 = requester.execute(target, request1, TIMEOUT, context)) { - Assertions.assertEquals(HttpStatus.SC_UNAUTHORIZED, response1.getCode()); + Assertions.assertThat(response1.getCode()).isEqualTo(HttpStatus.SC_UNAUTHORIZED); final String body1 = EntityUtils.toString(response1.getEntity(), Integer.MAX_VALUE); - Assertions.assertEquals("You shall not pass!!!", body1); + Assertions.assertThat(body1).isEqualTo("You shall not pass!!!"); } final ClassicHttpRequest request2 = new BasicClassicHttpRequest(Method.GET, "/stuff"); request2.setHeader(HttpHeaders.AUTHORIZATION, "let me pass"); try (final ClassicHttpResponse response2 = requester.execute(target, request2, TIMEOUT, context)) { - Assertions.assertEquals(HttpStatus.SC_OK, response2.getCode()); + Assertions.assertThat(response2.getCode()).isEqualTo(HttpStatus.SC_OK); final String body1 = EntityUtils.toString(response2.getEntity(), Integer.MAX_VALUE); - Assertions.assertEquals("", body1); + Assertions.assertThat(body1).isEqualTo(""); } } @@ -162,17 +162,17 @@ void testPostRequestAuthentication() throws Exception { final ClassicHttpRequest request1 = new BasicClassicHttpRequest(Method.POST, "/stuff"); request1.setEntity(new ByteArrayEntity(stuff, ContentType.TEXT_PLAIN)); try (final ClassicHttpResponse response1 = requester.execute(target, request1, TIMEOUT, context)) { - Assertions.assertEquals(HttpStatus.SC_UNAUTHORIZED, response1.getCode()); + Assertions.assertThat(response1.getCode()).isEqualTo(HttpStatus.SC_UNAUTHORIZED); final String body1 = EntityUtils.toString(response1.getEntity(), Integer.MAX_VALUE); - Assertions.assertEquals("You shall not pass!!!", body1); + Assertions.assertThat(body1).isEqualTo("You shall not pass!!!"); } final ClassicHttpRequest request2 = new BasicClassicHttpRequest(Method.POST, "/stuff"); request2.setHeader(HttpHeaders.AUTHORIZATION, "let me pass"); request2.setEntity(new ByteArrayEntity(stuff, ContentType.TEXT_PLAIN)); try (final ClassicHttpResponse response2 = requester.execute(target, request2, TIMEOUT, context)) { - Assertions.assertEquals(HttpStatus.SC_OK, response2.getCode()); + Assertions.assertThat(response2.getCode()).isEqualTo(HttpStatus.SC_OK); final String body1 = EntityUtils.toString(response2.getEntity(), Integer.MAX_VALUE); - Assertions.assertEquals(new String(stuff, StandardCharsets.US_ASCII), body1); + Assertions.assertThat(body1).isEqualTo(new String(stuff, StandardCharsets.US_ASCII)); } } @@ -192,18 +192,18 @@ void testPostRequestAuthenticationNoExpectContinue() throws Exception { request1.setVersion(HttpVersion.HTTP_1_0); request1.setEntity(new ByteArrayEntity(stuff, ContentType.TEXT_PLAIN)); try (final ClassicHttpResponse response1 = requester.execute(target, request1, TIMEOUT, context)) { - Assertions.assertEquals(HttpStatus.SC_UNAUTHORIZED, response1.getCode()); + Assertions.assertThat(response1.getCode()).isEqualTo(HttpStatus.SC_UNAUTHORIZED); final String body1 = EntityUtils.toString(response1.getEntity(), Integer.MAX_VALUE); - Assertions.assertEquals("You shall not pass!!!", body1); + Assertions.assertThat(body1).isEqualTo("You shall not pass!!!"); } final ClassicHttpRequest request2 = new BasicClassicHttpRequest(Method.POST, "/stuff"); request2.setHeader(HttpHeaders.AUTHORIZATION, "let me pass"); request2.setVersion(HttpVersion.HTTP_1_0); request2.setEntity(new ByteArrayEntity(stuff, ContentType.TEXT_PLAIN)); try (final ClassicHttpResponse response2 = requester.execute(target, request2, TIMEOUT, context)) { - Assertions.assertEquals(HttpStatus.SC_OK, response2.getCode()); + Assertions.assertThat(response2.getCode()).isEqualTo(HttpStatus.SC_OK); final String body1 = EntityUtils.toString(response2.getEntity(), Integer.MAX_VALUE); - Assertions.assertEquals(new String(stuff, StandardCharsets.US_ASCII), body1); + Assertions.assertThat(body1).isEqualTo(new String(stuff, StandardCharsets.US_ASCII)); } } diff --git a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/classic/ClassicHttpCoreTransportTest.java b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/classic/ClassicHttpCoreTransportTest.java index 9d0681183c..4978f95377 100644 --- a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/classic/ClassicHttpCoreTransportTest.java +++ b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/classic/ClassicHttpCoreTransportTest.java @@ -50,7 +50,7 @@ import org.apache.hc.core5.http.message.BasicClassicHttpRequest; import org.apache.hc.core5.http.protocol.HttpCoreContext; import org.apache.hc.core5.util.Timeout; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; abstract class ClassicHttpCoreTransportTest { @@ -77,23 +77,23 @@ void testSequentialRequests() throws Exception { final ClassicHttpRequest request1 = new BasicClassicHttpRequest(Method.POST, "/stuff"); request1.setEntity(new StringEntity("some stuff", ContentType.TEXT_PLAIN)); try (final ClassicHttpResponse response1 = requester.execute(target, request1, TIMEOUT, context)) { - Assertions.assertEquals(HttpStatus.SC_OK, response1.getCode()); + Assertions.assertThat(response1.getCode()).isEqualTo(HttpStatus.SC_OK); final String body1 = EntityUtils.toString(response1.getEntity(), Integer.MAX_VALUE); - Assertions.assertEquals("some stuff", body1); + Assertions.assertThat(body1).isEqualTo("some stuff"); } final ClassicHttpRequest request2 = new BasicClassicHttpRequest(Method.POST, "/other-stuff"); request2.setEntity(new StringEntity("some other stuff", ContentType.TEXT_PLAIN)); try (final ClassicHttpResponse response2 = requester.execute(target, request2, TIMEOUT, context)) { - Assertions.assertEquals(HttpStatus.SC_OK, response2.getCode()); + Assertions.assertThat(response2.getCode()).isEqualTo(HttpStatus.SC_OK); final String body2 = EntityUtils.toString(response2.getEntity(), Integer.MAX_VALUE); - Assertions.assertEquals("some other stuff", body2); + Assertions.assertThat(body2).isEqualTo("some other stuff"); } final ClassicHttpRequest request3 = new BasicClassicHttpRequest(Method.POST, "/more-stuff"); request3.setEntity(new StringEntity("some more stuff", ContentType.TEXT_PLAIN)); try (final ClassicHttpResponse response3 = requester.execute(target, request3, TIMEOUT, context)) { - Assertions.assertEquals(HttpStatus.SC_OK, response3.getCode()); + Assertions.assertThat(response3.getCode()).isEqualTo(HttpStatus.SC_OK); final String body3 = EntityUtils.toString(response3.getEntity(), Integer.MAX_VALUE); - Assertions.assertEquals("some more stuff", body3); + Assertions.assertThat(body3).isEqualTo("some more stuff"); } } @@ -107,23 +107,23 @@ void testSequentialRequestsNonPersistentConnection() throws Exception { final ClassicHttpRequest request1 = new BasicClassicHttpRequest(Method.POST, "/no-keep-alive/stuff"); request1.setEntity(new StringEntity("some stuff", ContentType.TEXT_PLAIN)); try (final ClassicHttpResponse response1 = requester.execute(target, request1, TIMEOUT, context)) { - Assertions.assertEquals(HttpStatus.SC_OK, response1.getCode()); + Assertions.assertThat(response1.getCode()).isEqualTo(HttpStatus.SC_OK); final String body1 = EntityUtils.toString(response1.getEntity(), Integer.MAX_VALUE); - Assertions.assertEquals("some stuff", body1); + Assertions.assertThat(body1).isEqualTo("some stuff"); } final ClassicHttpRequest request2 = new BasicClassicHttpRequest(Method.POST, "/no-keep-alive/other-stuff"); request2.setEntity(new StringEntity("some other stuff", ContentType.TEXT_PLAIN)); try (final ClassicHttpResponse response2 = requester.execute(target, request2, TIMEOUT, context)) { - Assertions.assertEquals(HttpStatus.SC_OK, response2.getCode()); + Assertions.assertThat(response2.getCode()).isEqualTo(HttpStatus.SC_OK); final String body2 = EntityUtils.toString(response2.getEntity(), Integer.MAX_VALUE); - Assertions.assertEquals("some other stuff", body2); + Assertions.assertThat(body2).isEqualTo("some other stuff"); } final ClassicHttpRequest request3 = new BasicClassicHttpRequest(Method.POST, "/no-keep-alive/more-stuff"); request3.setEntity(new StringEntity("some more stuff", ContentType.TEXT_PLAIN)); try (final ClassicHttpResponse response3 = requester.execute(target, request3, TIMEOUT, context)) { - Assertions.assertEquals(HttpStatus.SC_OK, response3.getCode()); + Assertions.assertThat(response3.getCode()).isEqualTo(HttpStatus.SC_OK); final String body3 = EntityUtils.toString(response3.getEntity(), Integer.MAX_VALUE); - Assertions.assertEquals("some more stuff", body3); + Assertions.assertThat(body3).isEqualTo("some more stuff"); } } @@ -148,9 +148,8 @@ void testMultiThreadedRequests() throws Exception { final ClassicHttpRequest request1 = new BasicClassicHttpRequest(Method.POST, "/stuff"); request1.setEntity(new StringEntity("some stuff", ContentType.TEXT_PLAIN)); requester.execute(target, request1, TIMEOUT, context, response -> { - Assertions.assertEquals(HttpStatus.SC_OK, response.getCode()); - Assertions.assertEquals("some stuff", - EntityUtils.toString(response.getEntity(), 1024)); + Assertions.assertThat(response.getCode()).isEqualTo(HttpStatus.SC_OK); + Assertions.assertThat(EntityUtils.toString(response.getEntity(), 1024)).isEqualTo("some stuff"); return null; }); } catch (final Exception ex) { @@ -164,7 +163,7 @@ void testMultiThreadedRequests() throws Exception { } }); } - Assertions.assertTrue(latch.await(5, TimeUnit.MINUTES)); + Assertions.assertThat(latch.await(5, TimeUnit.MINUTES)).isTrue(); } finally { executorService.shutdownNow(); } diff --git a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/classic/ClassicIntegrationTest.java b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/classic/ClassicIntegrationTest.java index b9c2f7f5b1..1292ac1923 100644 --- a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/classic/ClassicIntegrationTest.java +++ b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/classic/ClassicIntegrationTest.java @@ -85,7 +85,7 @@ import org.apache.hc.core5.testing.SSLTestContexts; import org.apache.hc.core5.testing.extension.classic.ClassicTestResources; import org.apache.hc.core5.util.Timeout; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.RegisterExtension; @@ -149,9 +149,9 @@ void testSimpleBasicHttpRequests() throws Exception { final byte[] received = EntityUtils.toByteArray(response.getEntity(), Integer.MAX_VALUE); final byte[] expected = testData.get(r); - Assertions.assertEquals(expected.length, received.length); + Assertions.assertThat(received.length).isEqualTo(expected.length); for (int i = 0; i < expected.length; i++) { - Assertions.assertEquals(expected[i], received[i]); + Assertions.assertThat(received[i]).isEqualTo(expected[i]); } } } @@ -204,9 +204,9 @@ void testSimpleHttpPostsWithContentLength() throws Exception { final byte[] received = EntityUtils.toByteArray(response.getEntity(), Integer.MAX_VALUE); final byte[] expected = testData.get(r); - Assertions.assertEquals(expected.length, received.length); + Assertions.assertThat(received.length).isEqualTo(expected.length); for (int i = 0; i < expected.length; i++) { - Assertions.assertEquals(expected[i], received[i]); + Assertions.assertThat(received[i]).isEqualTo(expected[i]); } } } @@ -259,9 +259,9 @@ void testSimpleHttpPostsChunked() throws Exception { final byte[] received = EntityUtils.toByteArray(response.getEntity(), Integer.MAX_VALUE); final byte[] expected = testData.get(r); - Assertions.assertEquals(expected.length, received.length); + Assertions.assertThat(received.length).isEqualTo(expected.length); for (int i = 0; i < expected.length; i++) { - Assertions.assertEquals(expected[i], received[i]); + Assertions.assertThat(received[i]).isEqualTo(expected[i]); } } } @@ -315,9 +315,9 @@ void testSimpleHttpPostsHTTP10() throws Exception { final byte[] received = EntityUtils.toByteArray(response.getEntity(), Integer.MAX_VALUE); final byte[] expected = testData.get(r); - Assertions.assertEquals(expected.length, received.length); + Assertions.assertThat(received.length).isEqualTo(expected.length); for (int i = 0; i < expected.length; i++) { - Assertions.assertEquals(expected[i], received[i]); + Assertions.assertThat(received[i]).isEqualTo(expected[i]); } } } @@ -342,11 +342,11 @@ void testHTTP11FeaturesDisabledWithHTTP10Requests() throws Exception { post.setVersion(HttpVersion.HTTP_1_0); post.setEntity(new ByteArrayEntity(new byte[] {'a', 'b', 'c'}, null, true)); - Assertions.assertThrows(ProtocolException.class, () -> { + Assertions.assertThatThrownBy(() -> { try (final ClassicHttpResponse response = client.execute(host, post, context)) { EntityUtils.consume(response.getEntity()); } - }); + }).isInstanceOf(ProtocolException.class); } /** @@ -396,9 +396,9 @@ void testHttpPostsWithExpectContinue() throws Exception { final byte[] received = EntityUtils.toByteArray(response.getEntity(), Integer.MAX_VALUE); final byte[] expected = testData.get(r); - Assertions.assertEquals(expected.length, received.length); + Assertions.assertThat(received.length).isEqualTo(expected.length); for (int i = 0; i < expected.length; i++) { - Assertions.assertEquals(expected[i], received[i]); + Assertions.assertThat(received[i]).isEqualTo(expected[i]); } } } @@ -459,13 +459,13 @@ protected ClassicHttpResponse verify(final ClassicHttpRequest request, final Htt try (final ClassicHttpResponse response = client.execute(host, post, context)) { final HttpEntity responseEntity = response.getEntity(); - Assertions.assertNotNull(responseEntity); + Assertions.assertThat(responseEntity).isNotNull(); EntityUtils.consume(responseEntity); if (r >= 2) { - Assertions.assertEquals(HttpStatus.SC_EXPECTATION_FAILED, response.getCode()); + Assertions.assertThat(response.getCode()).isEqualTo(HttpStatus.SC_EXPECTATION_FAILED); } else { - Assertions.assertEquals(HttpStatus.SC_OK, response.getCode()); + Assertions.assertThat(response.getCode()).isEqualTo(HttpStatus.SC_OK); } } } @@ -586,20 +586,20 @@ void testHttpContent() throws Exception { try (final ClassicHttpResponse response = client.execute(host, post, context)) { final HttpEntity entity = response.getEntity(); - Assertions.assertNotNull(entity); + Assertions.assertThat(entity).isNotNull(); final InputStream inStream = entity.getContent(); final ContentType contentType = ContentType.parse(entity.getContentType()); final Charset charset = ContentType.getCharset(contentType, StandardCharsets.UTF_8); - Assertions.assertNotNull(inStream); + Assertions.assertThat(inStream).isNotNull(); final BufferedReader reader = new BufferedReader(new InputStreamReader(inStream, charset)); String line; int count = 0; while ((line = reader.readLine()) != null) { - Assertions.assertEquals(pattern, line); + Assertions.assertThat(line).isEqualTo(pattern); count++; } - Assertions.assertEquals(n, count); + Assertions.assertThat(count).isEqualTo(n); } } } @@ -629,9 +629,9 @@ void testHttpPostNoEntity() throws Exception { post.setEntity(null); try (final ClassicHttpResponse response = client.execute(host, post, context)) { - Assertions.assertEquals(HttpStatus.SC_OK, response.getCode()); + Assertions.assertThat(response.getCode()).isEqualTo(HttpStatus.SC_OK); final byte[] received = EntityUtils.toByteArray(response.getEntity(), Integer.MAX_VALUE); - Assertions.assertEquals(0, received.length); + Assertions.assertThat(received.length).isEqualTo(0); } } @@ -665,9 +665,9 @@ void testHttpPostNoContentLength() throws Exception { post.setEntity(null); try (final ClassicHttpResponse response = client.execute(host, post, context)) { - Assertions.assertEquals(HttpStatus.SC_OK, response.getCode()); + Assertions.assertThat(response.getCode()).isEqualTo(HttpStatus.SC_OK); final byte[] received = EntityUtils.toByteArray(response.getEntity(), Integer.MAX_VALUE); - Assertions.assertEquals(0, received.length); + Assertions.assertThat(received.length).isEqualTo(0); } } @@ -701,7 +701,7 @@ void testHttpPostIdentity() throws Exception { post.setEntity(null); try (final ClassicHttpResponse response = client.execute(host, post, context)) { - Assertions.assertEquals(HttpStatus.SC_NOT_IMPLEMENTED, response.getCode()); + Assertions.assertThat(response.getCode()).isEqualTo(HttpStatus.SC_NOT_IMPLEMENTED); } } @@ -724,7 +724,7 @@ void testNoContentResponse() throws Exception { for (int r = 0; r < reqNo; r++) { final BasicClassicHttpRequest get = new BasicClassicHttpRequest(Method.GET, "/?" + r); try (final ClassicHttpResponse response = client.execute(host, get, context)) { - Assertions.assertNull(response.getEntity()); + Assertions.assertThat(response.getEntity()).isNull(); } } } @@ -746,10 +746,10 @@ void testEchoNoEntityRequest() throws Exception { post.setEntity(null); try (final ClassicHttpResponse response = client.execute(host, post, context)) { - Assertions.assertEquals(HttpStatus.SC_OK, response.getCode()); + Assertions.assertThat(response.getCode()).isEqualTo(HttpStatus.SC_OK); if (response.getEntity() != null) { final byte[] received = EntityUtils.toByteArray(response.getEntity(), Integer.MAX_VALUE); - Assertions.assertEquals(0, received.length); + Assertions.assertThat(received.length).isEqualTo(0); } } } @@ -771,9 +771,9 @@ void testEchoEmptyEntity() throws Exception { post.setEntity(new ByteArrayEntity(new byte[0], ContentType.TEXT_PLAIN)); try (final ClassicHttpResponse response = client.execute(host, post, context)) { - Assertions.assertEquals(HttpStatus.SC_OK, response.getCode()); + Assertions.assertThat(response.getCode()).isEqualTo(HttpStatus.SC_OK); final byte[] received = EntityUtils.toByteArray(response.getEntity(), Integer.MAX_VALUE); - Assertions.assertEquals(0, received.length); + Assertions.assertThat(received.length).isEqualTo(0); } } @@ -799,9 +799,9 @@ void testEchoLargeEntity() throws Exception { post.setEntity(new ByteArrayEntity(data, ContentType.APPLICATION_OCTET_STREAM)); try (final ClassicHttpResponse response = client.execute(host, post, context)) { - Assertions.assertEquals(HttpStatus.SC_OK, response.getCode()); + Assertions.assertThat(response.getCode()).isEqualTo(HttpStatus.SC_OK); final byte[] received = EntityUtils.toByteArray(response.getEntity(), Integer.MAX_VALUE); - Assertions.assertArrayEquals(data, received); + Assertions.assertThat(received).containsExactly(data); } } @@ -824,9 +824,9 @@ void testEchoManySmallRequests() throws Exception { post.setEntity(new ByteArrayEntity(data, ContentType.TEXT_PLAIN)); try (final ClassicHttpResponse response = client.execute(host, post, context)) { - Assertions.assertEquals(HttpStatus.SC_OK, response.getCode()); + Assertions.assertThat(response.getCode()).isEqualTo(HttpStatus.SC_OK); final byte[] received = EntityUtils.toByteArray(response.getEntity(), Integer.MAX_VALUE); - Assertions.assertArrayEquals(data, received); + Assertions.assertThat(received).containsExactly(data); } } } @@ -852,7 +852,7 @@ void testHeaderTooLarge() throws Exception { get1.setHeader("big-f-header", "1234567890123456789012345678901234567890123456789012345678901234567890" + "1234567890123456789012345678901234567890"); try (final ClassicHttpResponse response1 = client.execute(host, get1, context)) { - Assertions.assertEquals(431, response1.getCode()); + Assertions.assertThat(response1.getCode()).isEqualTo(431); EntityUtils.consume(response1.getEntity()); } } @@ -887,7 +887,7 @@ void testHeaderTooLargePost() throws Exception { post1.setEntity(new ByteArrayEntity(b, ContentType.TEXT_PLAIN)); try (final ClassicHttpResponse response1 = client.execute(host, post1, context)) { - Assertions.assertEquals(431, response1.getCode()); + Assertions.assertThat(response1.getCode()).isEqualTo(431); EntityUtils.consume(response1.getEntity()); } } @@ -945,9 +945,8 @@ void testImmediateCloseUponSocketTimeout() throws Exception { final long endTime = System.currentTimeMillis(); final long durationMillis = endTime - startTime; // Assert that the timeout occurred around the socket timeout duration - Assertions.assertTrue(durationMillis >= socketTimeoutMillis && durationMillis < socketTimeoutMillis * 2, - String.format("Socket timeout should occur around %dms (took %dms)", - socketTimeoutMillis, durationMillis)); + Assertions.assertThat(durationMillis >= socketTimeoutMillis && durationMillis < socketTimeoutMillis * 2).withFailMessage(String.format("Socket timeout should occur around %dms (took %dms)", + socketTimeoutMillis, durationMillis)).isTrue(); } catch (final IOException | HttpException e) { Assertions.fail("IOException during request execution: " + e.getMessage()); } diff --git a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/classic/ClassicServerBootstrapFilterTest.java b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/classic/ClassicServerBootstrapFilterTest.java index 43b25648d5..a66c018dd3 100644 --- a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/classic/ClassicServerBootstrapFilterTest.java +++ b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/classic/ClassicServerBootstrapFilterTest.java @@ -28,7 +28,6 @@ package org.apache.hc.core5.testing.classic; -import org.junit.jupiter.api.Assertions; import java.io.IOException; import org.apache.hc.core5.http.ClassicHttpRequest; @@ -53,6 +52,7 @@ import org.apache.hc.core5.testing.extension.classic.HttpRequesterResource; import org.apache.hc.core5.testing.extension.classic.HttpServerResource; import org.apache.hc.core5.util.Timeout; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.RegisterExtension; @@ -117,9 +117,9 @@ void testFilters() throws Exception { final ClassicHttpRequest request = new BasicClassicHttpRequest(Method.POST, "/filters"); request.setEntity(new StringEntity("some stuff", ContentType.TEXT_PLAIN)); try (final ClassicHttpResponse response = requester.execute(target, request, TIMEOUT, context)) { - Assertions.assertEquals(HttpStatus.SC_OK, response.getCode()); + Assertions.assertThat(response.getCode()).isEqualTo(HttpStatus.SC_OK); final Header testFilterHeader = response.getHeader("X-Test-Filter"); - Assertions.assertNotNull(testFilterHeader); + Assertions.assertThat(testFilterHeader).isNotNull(); } } diff --git a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/classic/ClassicTLSIntegrationTest.java b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/classic/ClassicTLSIntegrationTest.java index 393ddd8c10..2499c5df98 100644 --- a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/classic/ClassicTLSIntegrationTest.java +++ b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/classic/ClassicTLSIntegrationTest.java @@ -58,7 +58,7 @@ import org.apache.hc.core5.ssl.SSLContexts; import org.apache.hc.core5.testing.SSLTestContexts; import org.apache.hc.core5.util.Timeout; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.AfterEachCallback; import org.junit.jupiter.api.extension.ExtensionContext; @@ -136,15 +136,15 @@ void testTLSSuccess() throws Exception { final ClassicHttpRequest request1 = new BasicClassicHttpRequest(Method.POST, "/stuff"); request1.setEntity(new StringEntity("some stuff", ContentType.TEXT_PLAIN)); try (final ClassicHttpResponse response1 = requester.execute(target, request1, TIMEOUT, context)) { - Assertions.assertEquals(HttpStatus.SC_OK, response1.getCode()); + Assertions.assertThat(response1.getCode()).isEqualTo(HttpStatus.SC_OK); final String body1 = EntityUtils.toString(response1.getEntity(), Integer.MAX_VALUE); - Assertions.assertEquals("some stuff", body1); + Assertions.assertThat(body1).isEqualTo("some stuff"); } final SSLSession sslSession = sslSessionRef.getAndSet(null); final ProtocolVersion tlsVersion = TLS.parse(sslSession.getProtocol()); - Assertions.assertTrue(tlsVersion.greaterEquals(TLS.V_1_2.getVersion())); - Assertions.assertEquals("CN=localhost,OU=Apache HttpComponents,O=Apache Software Foundation", sslSession.getPeerPrincipal().getName()); + Assertions.assertThat(tlsVersion.greaterEquals(TLS.V_1_2.getVersion())).isTrue(); + Assertions.assertThat(sslSession.getPeerPrincipal().getName()).isEqualTo("CN=localhost,OU=Apache HttpComponents,O=Apache Software Foundation"); } @Test @@ -174,11 +174,11 @@ void testTLSTrustFailure() throws Exception { final HttpHost target = new HttpHost("https", "localhost", server.getLocalPort()); final ClassicHttpRequest request1 = new BasicClassicHttpRequest(Method.POST, "/stuff"); request1.setEntity(new StringEntity("some stuff", ContentType.TEXT_PLAIN)); - Assertions.assertThrows(IOException.class, () -> { + Assertions.assertThatThrownBy(() -> { try (final ClassicHttpResponse response1 = requester.execute(target, request1, TIMEOUT, context)) { EntityUtils.consume(response1.getEntity()); } - }); + }).isInstanceOf(IOException.class); } @Test @@ -210,11 +210,11 @@ void testTLSClientAuthFailure() throws Exception { final HttpHost target = new HttpHost("https", "localhost", server.getLocalPort()); final ClassicHttpRequest request1 = new BasicClassicHttpRequest(Method.POST, "/stuff"); request1.setEntity(new StringEntity("some stuff", ContentType.TEXT_PLAIN)); - Assertions.assertThrows(IOException.class, () -> { + Assertions.assertThatThrownBy(() -> { try (final ClassicHttpResponse response1 = requester.execute(target, request1, TIMEOUT, context)) { EntityUtils.consume(response1.getEntity()); } - }); + }).isInstanceOf(IOException.class); } @Test @@ -240,11 +240,11 @@ void testSSLDisabledByDefault() throws Exception { final HttpHost target = new HttpHost("https", "localhost", server.getLocalPort()); final ClassicHttpRequest request1 = new BasicClassicHttpRequest(Method.POST, "/stuff"); request1.setEntity(new StringEntity("some stuff", ContentType.TEXT_PLAIN)); - Assertions.assertThrows(IOException.class, () -> { + Assertions.assertThatThrownBy(() -> { try (final ClassicHttpResponse response1 = requester.execute(target, request1, TIMEOUT, context)) { EntityUtils.consume(response1.getEntity()); } - }); + }).isInstanceOf(IOException.class); } @Test @@ -283,7 +283,7 @@ void testWeakCiphersDisabledByDefault() throws Exception { .setRequestRouter((r, c) -> null) .setSslSetupHandler(sslParameters -> sslParameters.setCipherSuites(new String[]{cipherSuite})) .create(); - Assertions.assertThrows(Exception.class, () -> { + Assertions.assertThatThrownBy(() -> { try { server.start(); @@ -297,7 +297,7 @@ void testWeakCiphersDisabledByDefault() throws Exception { } finally { server.close(CloseMode.IMMEDIATE); } - }); + }).isInstanceOf(Exception.class); } } @@ -327,14 +327,14 @@ void testHostNameVerification() throws Exception { EntityUtils.consume(response1.getEntity()); } - Assertions.assertThrows(SSLHandshakeException.class, () -> { + Assertions.assertThatThrownBy(() -> { final HttpHost target2 = new HttpHost("https", InetAddress.getLoopbackAddress(), "some-other-host", server.getLocalPort()); final ClassicHttpRequest request2 = new BasicClassicHttpRequest(Method.POST, "/stuff"); request2.setEntity(new StringEntity("some stuff", ContentType.TEXT_PLAIN)); try (final ClassicHttpResponse response2 = requester.execute(target2, request2, TIMEOUT, context)) { EntityUtils.consume(response2.getEntity()); } - }); + }).isInstanceOf(SSLHandshakeException.class); } } diff --git a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/classic/MonitoringResponseOutOfOrderStrategyIntegrationTest.java b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/classic/MonitoringResponseOutOfOrderStrategyIntegrationTest.java index 33d9b5c800..230c51d7b8 100644 --- a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/classic/MonitoringResponseOutOfOrderStrategyIntegrationTest.java +++ b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/classic/MonitoringResponseOutOfOrderStrategyIntegrationTest.java @@ -54,7 +54,7 @@ import org.apache.hc.core5.testing.extension.classic.HttpRequesterResource; import org.apache.hc.core5.testing.extension.classic.HttpServerResource; import org.apache.hc.core5.util.Timeout; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Timeout.ThreadMode; import org.junit.jupiter.api.extension.RegisterExtension; @@ -114,10 +114,10 @@ void testResponseOutOfOrderWithDefaultStrategy() throws Exception { post.setEntity(requestEntity); try (final ClassicHttpResponse response = requester.execute(host, post, TIMEOUT, context)) { - Assertions.assertEquals(400, response.getCode()); + Assertions.assertThat(response.getCode()).isEqualTo(400); EntityUtils.consumeQuietly(response.getEntity()); } - Assertions.assertTrue(requestEntity.remaining > 0, "Client should have stopped sending data"); + Assertions.assertThat(requestEntity.remaining > 0).withFailMessage("Client should have stopped sending data").isTrue(); } private static final class AllOnesHttpEntity extends AbstractHttpEntity { diff --git a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/compatibility/classic/ClassicHttpCompatTest.java b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/compatibility/classic/ClassicHttpCompatTest.java index afa4b1d3af..f5f466a02b 100644 --- a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/compatibility/classic/ClassicHttpCompatTest.java +++ b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/compatibility/classic/ClassicHttpCompatTest.java @@ -50,7 +50,7 @@ import org.apache.hc.core5.testing.compatibility.TLSTestContexts; import org.apache.hc.core5.testing.extension.classic.HttpRequesterResource; import org.apache.hc.core5.util.Timeout; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.RegisterExtension; @@ -92,9 +92,9 @@ void test_sequential_requests() throws Exception { .setHttpHost(target) .build(); requester.execute(target, request, TIMEOUT, context, response -> { - Assertions.assertEquals(HttpStatus.SC_OK, response.getCode()); + Assertions.assertThat(response.getCode()).isEqualTo(HttpStatus.SC_OK); final String body1 = EntityUtils.toString(response.getEntity(), Integer.MAX_VALUE); - Assertions.assertEquals(ContainerImages.AAA, body1); + Assertions.assertThat(body1).isEqualTo(ContainerImages.AAA); return null; }); } @@ -135,11 +135,11 @@ void test_multi_threaded_requests() throws Exception { } }); } - Assertions.assertTrue(countDownLatch.await(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()), "Request executions have not completed in time"); + Assertions.assertThat(countDownLatch.await(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit())).withFailMessage("Request executions have not completed in time").isTrue(); for (final Result result : resultQueue) { if (result.isOK()) { - Assertions.assertNotNull(result.response); - Assertions.assertEquals(HttpStatus.SC_OK, result.response.getCode(), "Response message returned non 200 status"); + Assertions.assertThat(result.response).isNotNull(); + Assertions.assertThat(result.response.getCode()).withFailMessage("Response message returned non 200 status").isEqualTo(HttpStatus.SC_OK); } else { Assertions.fail(result.exception); } diff --git a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/compatibility/classic/HttpBinClassicCompatTest.java b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/compatibility/classic/HttpBinClassicCompatTest.java index 6388a3ef8b..87754d4af4 100644 --- a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/compatibility/classic/HttpBinClassicCompatTest.java +++ b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/compatibility/classic/HttpBinClassicCompatTest.java @@ -28,7 +28,6 @@ package org.apache.hc.core5.testing.compatibility.classic; -import org.junit.jupiter.api.Assertions; import java.util.Arrays; import java.util.List; import java.util.function.Consumer; @@ -45,6 +44,7 @@ import org.apache.hc.core5.http.protocol.HttpCoreContext; import org.apache.hc.core5.testing.extension.classic.HttpRequesterResource; import org.apache.hc.core5.util.Timeout; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.RegisterExtension; @@ -111,7 +111,7 @@ void test_sequential_request_execution() throws Exception { for (final ClassicHttpRequest request : requestMessages) { final HttpCoreContext context = HttpCoreContext.create(); client.execute(target, request, TIMEOUT, context, response -> { - Assertions.assertEquals(HttpStatus.SC_OK, response.getCode()); + Assertions.assertThat(response.getCode()).isEqualTo(HttpStatus.SC_OK); return null; }); } diff --git a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/compatibility/nio/AsyncHttp2CompatTest.java b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/compatibility/nio/AsyncHttp2CompatTest.java index a01bf46e24..96f453ffeb 100644 --- a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/compatibility/nio/AsyncHttp2CompatTest.java +++ b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/compatibility/nio/AsyncHttp2CompatTest.java @@ -57,7 +57,7 @@ import org.apache.hc.core5.testing.compatibility.TLSTestContexts; import org.apache.hc.core5.testing.extension.nio.H2AsyncRequesterResource; import org.apache.hc.core5.util.Timeout; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.RegisterExtension; @@ -148,11 +148,11 @@ public void cancelled() { } }); - Assertions.assertTrue(countDownLatch.await(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()), "Request executions have not completed in time"); + Assertions.assertThat(countDownLatch.await(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit())).withFailMessage("Request executions have not completed in time").isTrue(); for (final Result result : resultQueue) { if (result.isOK()) { - Assertions.assertNotNull(result.response); - Assertions.assertEquals(HttpStatus.SC_OK, result.response.getCode(), "Response message returned non 200 status"); + Assertions.assertThat(result.response).isNotNull(); + Assertions.assertThat(result.response.getCode()).withFailMessage("Response message returned non 200 status").isEqualTo(HttpStatus.SC_OK); } else { Assertions.fail(result.exception); } diff --git a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/compatibility/nio/AsyncHttpCompatTest.java b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/compatibility/nio/AsyncHttpCompatTest.java index 3b008c0053..fb5c8fedfc 100644 --- a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/compatibility/nio/AsyncHttpCompatTest.java +++ b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/compatibility/nio/AsyncHttpCompatTest.java @@ -49,7 +49,7 @@ import org.apache.hc.core5.testing.Result; import org.apache.hc.core5.testing.compatibility.ContainerImages; import org.apache.hc.core5.util.Timeout; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; public abstract class AsyncHttpCompatTest { @@ -102,12 +102,12 @@ public void cancelled() { }); } - Assertions.assertTrue(countDownLatch.await(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()), "Request executions have not completed in time"); + Assertions.assertThat(countDownLatch.await(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit())).withFailMessage("Request executions have not completed in time").isTrue(); for (final Result result : resultQueue) { if (result.isOK()) { - Assertions.assertNotNull(result.response); - Assertions.assertEquals(HttpStatus.SC_OK, result.response.getCode(), "Response message returned non 200 status"); - Assertions.assertEquals(ContainerImages.AAA, result.content); + Assertions.assertThat(result.response).isNotNull(); + Assertions.assertThat(result.response.getCode()).withFailMessage("Response message returned non 200 status").isEqualTo(HttpStatus.SC_OK); + Assertions.assertThat(result.content).isEqualTo(ContainerImages.AAA); } else { Assertions.fail(result.exception); } @@ -156,12 +156,12 @@ public void cancelled() { }); } - Assertions.assertTrue(countDownLatch.await(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()), "Request executions have not completed in time"); + Assertions.assertThat(countDownLatch.await(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit())).withFailMessage("Request executions have not completed in time").isTrue(); for (final Result result : resultQueue) { if (result.isOK()) { - Assertions.assertNotNull(result.response); - Assertions.assertEquals(HttpStatus.SC_OK, result.response.getCode(), "Response message returned non 200 status"); - Assertions.assertEquals(ContainerImages.AAA, result.content); + Assertions.assertThat(result.response).isNotNull(); + Assertions.assertThat(result.response.getCode()).withFailMessage("Response message returned non 200 status").isEqualTo(HttpStatus.SC_OK); + Assertions.assertThat(result.content).isEqualTo(ContainerImages.AAA); } else { Assertions.fail(result.exception); } @@ -206,11 +206,11 @@ public void cancelled() { }); } - Assertions.assertTrue(countDownLatch.await(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()), "Request executions have not completed in time"); + Assertions.assertThat(countDownLatch.await(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit())).withFailMessage("Request executions have not completed in time").isTrue(); for (final Result result : resultQueue) { if (result.isOK()) { - Assertions.assertNotNull(result.response); - Assertions.assertEquals(HttpStatus.SC_OK, result.response.getCode(), "Response message returned non 200 status"); + Assertions.assertThat(result.response).isNotNull(); + Assertions.assertThat(result.response.getCode()).withFailMessage("Response message returned non 200 status").isEqualTo(HttpStatus.SC_OK); } else { Assertions.fail(result.exception); } diff --git a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/compatibility/nio/HttpBinAsyncCompatTest.java b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/compatibility/nio/HttpBinAsyncCompatTest.java index 6c1106c0ce..10fed84517 100644 --- a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/compatibility/nio/HttpBinAsyncCompatTest.java +++ b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/compatibility/nio/HttpBinAsyncCompatTest.java @@ -62,7 +62,7 @@ import org.apache.hc.core5.testing.Result; import org.apache.hc.core5.testing.extension.nio.H2AsyncRequesterResource; import org.apache.hc.core5.util.Timeout; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.RegisterExtension; @@ -127,7 +127,7 @@ void test_sequential_request_execution() throws Exception { TIMEOUT, null); final Message response = messageFuture.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertEquals(HttpStatus.SC_OK, response.head().getCode()); + Assertions.assertThat(response.head().getCode()).isEqualTo(HttpStatus.SC_OK); } } @@ -183,11 +183,11 @@ public void cancelled() { }); } - Assertions.assertTrue(countDownLatch.await(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()), "Request executions have not completed in time"); + Assertions.assertThat(countDownLatch.await(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit())).withFailMessage("Request executions have not completed in time").isTrue(); for (final Result result : resultQueue) { if (result.isOK()) { - Assertions.assertNotNull(result.response); - Assertions.assertEquals(HttpStatus.SC_OK, result.response.getCode(), "Response message returned non 200 status"); + Assertions.assertThat(result.response).isNotNull(); + Assertions.assertThat(result.response.getCode()).withFailMessage("Response message returned non 200 status").isEqualTo(HttpStatus.SC_OK); } else { Assertions.fail(result.exception); } diff --git a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/extension/SecurityProviderResource.java b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/extension/SecurityProviderResource.java index 5a50554a36..f007cd5609 100644 --- a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/extension/SecurityProviderResource.java +++ b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/extension/SecurityProviderResource.java @@ -32,8 +32,8 @@ import java.util.HashSet; import java.util.Set; +import org.assertj.core.api.Assertions; import org.conscrypt.Conscrypt; -import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Assumptions; import org.junit.jupiter.api.extension.AfterEachCallback; import org.junit.jupiter.api.extension.BeforeEachCallback; diff --git a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/extension/classic/ClassicTestResources.java b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/extension/classic/ClassicTestResources.java index c5a35710ce..b61d9c288b 100644 --- a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/extension/classic/ClassicTestResources.java +++ b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/extension/classic/ClassicTestResources.java @@ -34,7 +34,7 @@ import org.apache.hc.core5.testing.classic.ClassicTestClient; import org.apache.hc.core5.testing.classic.ClassicTestServer; import org.apache.hc.core5.util.Timeout; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.extension.AfterEachCallback; import org.junit.jupiter.api.extension.BeforeEachCallback; import org.junit.jupiter.api.extension.ExtensionContext; @@ -87,12 +87,12 @@ public void afterEach(final ExtensionContext extensionContext) throws Exception } public ClassicTestClient client() { - Assertions.assertNotNull(client); + Assertions.assertThat(client).isNotNull(); return client; } public ClassicTestServer server() { - Assertions.assertNotNull(server); + Assertions.assertThat(server).isNotNull(); return server; } diff --git a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/extension/nio/H2TestResources.java b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/extension/nio/H2TestResources.java index e6180ab900..213c16bf6d 100644 --- a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/extension/nio/H2TestResources.java +++ b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/extension/nio/H2TestResources.java @@ -34,7 +34,7 @@ import org.apache.hc.core5.testing.nio.H2TestServer; import org.apache.hc.core5.util.TimeValue; import org.apache.hc.core5.util.Timeout; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.extension.AfterEachCallback; import org.junit.jupiter.api.extension.BeforeEachCallback; import org.junit.jupiter.api.extension.ExtensionContext; @@ -87,12 +87,12 @@ public void afterEach(final ExtensionContext extensionContext) throws Exception } public H2TestClient client() { - Assertions.assertNotNull(client); + Assertions.assertThat(client).isNotNull(); return client; } public H2TestServer server() { - Assertions.assertNotNull(server); + Assertions.assertThat(server).isNotNull(); return server; } diff --git a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/extension/nio/Http1TestResources.java b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/extension/nio/Http1TestResources.java index 155089543d..608f2292f4 100644 --- a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/extension/nio/Http1TestResources.java +++ b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/extension/nio/Http1TestResources.java @@ -34,7 +34,7 @@ import org.apache.hc.core5.testing.nio.Http1TestServer; import org.apache.hc.core5.util.TimeValue; import org.apache.hc.core5.util.Timeout; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.extension.AfterEachCallback; import org.junit.jupiter.api.extension.BeforeEachCallback; import org.junit.jupiter.api.extension.ExtensionContext; @@ -87,12 +87,12 @@ public void afterEach(final ExtensionContext extensionContext) throws Exception } public Http1TestClient client() { - Assertions.assertNotNull(client); + Assertions.assertThat(client).isNotNull(); return client; } public Http1TestServer server() { - Assertions.assertNotNull(server); + Assertions.assertThat(server).isNotNull(); return server; } diff --git a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/AlpnTest.java b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/AlpnTest.java index 4977e82284..93b7e322ed 100644 --- a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/AlpnTest.java +++ b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/AlpnTest.java @@ -28,7 +28,6 @@ package org.apache.hc.core5.testing.nio; -import org.junit.jupiter.api.Assertions; import java.net.InetAddress; import java.net.InetSocketAddress; import java.util.concurrent.Future; @@ -65,6 +64,7 @@ import org.apache.hc.core5.testing.extension.nio.H2AsyncRequesterResource; import org.apache.hc.core5.testing.extension.nio.H2AsyncServerResource; import org.apache.hc.core5.util.Timeout; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Order; import org.junit.jupiter.api.Test; @@ -142,10 +142,10 @@ void testForceHttp1() throws Exception { new StringAsyncEntityProducer("some stuff", ContentType.TEXT_PLAIN)), new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null); final Message message1 = resultFuture1.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(message1); + Assertions.assertThat(message1).isNotNull(); final HttpResponse response1 = message1.head(); - Assertions.assertEquals(HttpStatus.SC_OK, response1.getCode()); - Assertions.assertEquals(HttpVersion.HTTP_1_1, response1.getVersion()); + Assertions.assertThat(response1.getCode()).isEqualTo(HttpStatus.SC_OK); + Assertions.assertThat(response1.getVersion()).isEqualTo(HttpVersion.HTTP_1_1); } @Test @@ -167,10 +167,10 @@ void testForceHttp1GlobalPolicy() throws Exception { new StringAsyncEntityProducer("some stuff", ContentType.TEXT_PLAIN)), new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null); final Message message1 = resultFuture1.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(message1); + Assertions.assertThat(message1).isNotNull(); final HttpResponse response1 = message1.head(); - Assertions.assertEquals(HttpStatus.SC_OK, response1.getCode()); - Assertions.assertEquals(HttpVersion.HTTP_1_1, response1.getVersion()); + Assertions.assertThat(response1.getCode()).isEqualTo(HttpStatus.SC_OK); + Assertions.assertThat(response1.getVersion()).isEqualTo(HttpVersion.HTTP_1_1); } @Test @@ -190,10 +190,10 @@ void testForceHttp2() throws Exception { new StringAsyncEntityProducer("some stuff", ContentType.TEXT_PLAIN)), new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null); final Message message1 = resultFuture1.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(message1); + Assertions.assertThat(message1).isNotNull(); final HttpResponse response1 = message1.head(); - Assertions.assertEquals(HttpStatus.SC_OK, response1.getCode()); - Assertions.assertEquals(HttpVersion.HTTP_2, response1.getVersion()); + Assertions.assertThat(response1.getCode()).isEqualTo(HttpStatus.SC_OK); + Assertions.assertThat(response1.getVersion()).isEqualTo(HttpVersion.HTTP_2); } @Test @@ -215,10 +215,10 @@ void testForceHttp2GlobalPolicy() throws Exception { new StringAsyncEntityProducer("some stuff", ContentType.TEXT_PLAIN)), new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null); final Message message1 = resultFuture1.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(message1); + Assertions.assertThat(message1).isNotNull(); final HttpResponse response1 = message1.head(); - Assertions.assertEquals(HttpStatus.SC_OK, response1.getCode()); - Assertions.assertEquals(HttpVersion.HTTP_2, response1.getVersion()); + Assertions.assertThat(response1.getCode()).isEqualTo(HttpStatus.SC_OK); + Assertions.assertThat(response1.getVersion()).isEqualTo(HttpVersion.HTTP_2); } @Test @@ -238,10 +238,10 @@ void testNegotiateProtocol() throws Exception { new StringAsyncEntityProducer("some stuff", ContentType.TEXT_PLAIN)), new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null); final Message message1 = resultFuture1.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(message1); + Assertions.assertThat(message1).isNotNull(); final HttpResponse response1 = message1.head(); - Assertions.assertEquals(HttpStatus.SC_OK, response1.getCode()); - Assertions.assertEquals(HttpVersion.HTTP_2, response1.getVersion()); + Assertions.assertThat(response1.getCode()).isEqualTo(HttpStatus.SC_OK); + Assertions.assertThat(response1.getVersion()).isEqualTo(HttpVersion.HTTP_2); } } diff --git a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/AsyncServerBootstrapFilterTest.java b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/AsyncServerBootstrapFilterTest.java index fc0f79acb6..dbe60591a9 100644 --- a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/AsyncServerBootstrapFilterTest.java +++ b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/AsyncServerBootstrapFilterTest.java @@ -28,7 +28,6 @@ package org.apache.hc.core5.testing.nio; -import org.junit.jupiter.api.Assertions; import java.io.IOException; import java.net.InetAddress; import java.net.InetSocketAddress; @@ -64,6 +63,7 @@ import org.apache.hc.core5.testing.extension.nio.HttpAsyncRequesterResource; import org.apache.hc.core5.testing.extension.nio.HttpAsyncServerResource; import org.apache.hc.core5.util.Timeout; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.RegisterExtension; @@ -136,11 +136,11 @@ void testFilters() throws Exception { new StringAsyncEntityProducer("some stuff", ContentType.TEXT_PLAIN)), new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), TIMEOUT, null); final Message message = resultFuture.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(message); + Assertions.assertThat(message).isNotNull(); final HttpResponse response = message.head(); - Assertions.assertEquals(HttpStatus.SC_OK, response.getCode()); + Assertions.assertThat(response.getCode()).isEqualTo(HttpStatus.SC_OK); final Header testFilterHeader = response.getHeader("X-Test-Filter"); - Assertions.assertNotNull(testFilterHeader); + Assertions.assertThat(testFilterHeader).isNotNull(); } } diff --git a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/ClassicToAsyncHttp1TransportTest.java b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/ClassicToAsyncHttp1TransportTest.java index 16b78b54c2..e2dc7001e7 100644 --- a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/ClassicToAsyncHttp1TransportTest.java +++ b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/ClassicToAsyncHttp1TransportTest.java @@ -47,7 +47,7 @@ import org.apache.hc.core5.http.nio.support.classic.ClassicToAsyncRequestProducer; import org.apache.hc.core5.http.nio.support.classic.ClassicToAsyncResponseConsumer; import org.apache.hc.core5.reactor.ListenerEndpoint; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.ValueSource; @@ -91,10 +91,10 @@ void test_request_handling_no_keep_alive(final int contentSize) throws Exception requestProducer.blockWaiting().execute(); try (ClassicHttpResponse response = responseConsumer.blockWaiting()) { - Assertions.assertEquals(200, response.getCode()); + Assertions.assertThat(response.getCode()).isEqualTo(200); final byte[] bytes = EntityUtils.toByteArray(response.getEntity(), Integer.MAX_VALUE); - Assertions.assertNotNull(bytes); - Assertions.assertArrayEquals(temp, bytes); + Assertions.assertThat(bytes).isNotNull(); + Assertions.assertThat(bytes).containsExactly(temp); } } } diff --git a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/ClassicToAsyncTransportTest.java b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/ClassicToAsyncTransportTest.java index 843bd9eef7..275f5dc440 100644 --- a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/ClassicToAsyncTransportTest.java +++ b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/ClassicToAsyncTransportTest.java @@ -85,7 +85,7 @@ import org.apache.hc.core5.testing.extension.nio.H2AsyncRequesterResource; import org.apache.hc.core5.testing.extension.nio.H2AsyncServerResource; import org.apache.hc.core5.util.Timeout; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.RegisterExtension; import org.junit.jupiter.params.ParameterizedTest; @@ -199,7 +199,7 @@ void test_request_execution() throws Exception { } final StringTokenizer t1 = new StringTokenizer(buffer.toString(), "\r\n"); while (t1.hasMoreTokens()) { - Assertions.assertEquals("0123456789abcdef", t1.nextToken()); + Assertions.assertThat(t1.nextToken()).isEqualTo("0123456789abcdef"); } } } @@ -278,18 +278,18 @@ public void cancelled() { }); } - Assertions.assertTrue(countDownLatch.await(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()), "Request executions have not completed in time"); + Assertions.assertThat(countDownLatch.await(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit())).withFailMessage("Request executions have not completed in time").isTrue(); for (final Result result : resultQueue) { if (result.isOK()) { - Assertions.assertNotNull(result.response); - Assertions.assertEquals(HttpStatus.SC_OK, result.response.getCode(), "Response message returned non 200 status"); + Assertions.assertThat(result.response).isNotNull(); + Assertions.assertThat(result.response.getCode()).withFailMessage("Response message returned non 200 status").isEqualTo(HttpStatus.SC_OK); if (Method.HEAD.isSame(method)) { - Assertions.assertNull(result.content); + Assertions.assertThat(result.content).isNull(); } else { - Assertions.assertNotNull(result.content); + Assertions.assertThat(result.content).isNotNull(); final StringTokenizer t1 = new StringTokenizer(result.content, "\r\n"); while (t1.hasMoreTokens()) { - Assertions.assertEquals("0123456789abcdef", t1.nextToken()); + Assertions.assertThat(t1.nextToken()).isEqualTo("0123456789abcdef"); } } } else { @@ -373,15 +373,15 @@ public void cancelled() { }); } - Assertions.assertTrue(countDownLatch.await(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()), "Request executions have not completed in time"); + Assertions.assertThat(countDownLatch.await(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit())).withFailMessage("Request executions have not completed in time").isTrue(); for (final Result result : resultQueue) { if (result.isOK()) { - Assertions.assertNotNull(result.response); - Assertions.assertEquals(HttpStatus.SC_OK, result.response.getCode(), "Response message returned non 200 status"); - Assertions.assertNotNull(result.content); + Assertions.assertThat(result.response).isNotNull(); + Assertions.assertThat(result.response.getCode()).withFailMessage("Response message returned non 200 status").isEqualTo(HttpStatus.SC_OK); + Assertions.assertThat(result.content).isNotNull(); final StringTokenizer t1 = new StringTokenizer(result.content, "\r\n"); while (t1.hasMoreTokens()) { - Assertions.assertEquals("0123456789abcdef", t1.nextToken()); + Assertions.assertThat(t1.nextToken()).isEqualTo("0123456789abcdef"); } } else { Assertions.fail(result.exception); diff --git a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/H2AlpnTest.java b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/H2AlpnTest.java index 0fd0aadc18..b732b4f2a0 100644 --- a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/H2AlpnTest.java +++ b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/H2AlpnTest.java @@ -27,12 +27,6 @@ package org.apache.hc.core5.testing.nio; -import org.junit.jupiter.api.Assertions; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.junit.jupiter.api.Assertions.assertInstanceOf; -import static org.junit.jupiter.api.Assertions.assertTrue; - import java.net.InetAddress; import java.net.InetSocketAddress; import java.util.concurrent.ExecutionException; @@ -65,6 +59,7 @@ import org.apache.hc.core5.testing.extension.nio.H2AsyncServerResource; import org.apache.hc.core5.testing.extension.nio.H2MultiplexingRequesterResource; import org.apache.hc.core5.util.Timeout; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.RegisterExtension; @@ -130,19 +125,19 @@ void testALPN() throws Exception { message1 = resultFuture1.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); } catch (final ExecutionException e) { final Throwable cause = e.getCause(); - assertFalse(h2Allowed, "h2 negotiation was enabled, but h2 was not negotiated"); - assertInstanceOf(ProtocolNegotiationException.class, cause); - assertEquals("ALPN: missing application protocol", cause.getMessage()); - assertTrue(strictALPN, "strict ALPN mode was not enabled, but the client negotiator still threw"); + Assertions.assertThat(h2Allowed).withFailMessage("h2 negotiation was enabled, but h2 was not negotiated").isFalse(); + Assertions.assertThat(cause).isInstanceOf(ProtocolNegotiationException.class); + Assertions.assertThat(cause.getMessage()).isEqualTo("ALPN: missing application protocol"); + Assertions.assertThat(strictALPN).withFailMessage("strict ALPN mode was not enabled, but the client negotiator still threw").isTrue(); return; } - assertTrue(h2Allowed, "h2 negotiation was disabled, but h2 was negotiated"); - Assertions.assertNotNull(message1); + Assertions.assertThat(h2Allowed).withFailMessage("h2 negotiation was disabled, but h2 was negotiated").isTrue(); + Assertions.assertThat(message1).isNotNull(); final HttpResponse response1 = message1.head(); - Assertions.assertEquals(HttpStatus.SC_OK, response1.getCode()); + Assertions.assertThat(response1.getCode()).isEqualTo(HttpStatus.SC_OK); final String body1 = message1.body(); - Assertions.assertEquals("some stuff", body1); + Assertions.assertThat(body1).isEqualTo("some stuff"); } } diff --git a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/H2ConnPoolTest.java b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/H2ConnPoolTest.java index 7c3a4c5147..6b12bccfb5 100644 --- a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/H2ConnPoolTest.java +++ b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/H2ConnPoolTest.java @@ -54,7 +54,7 @@ import org.apache.hc.core5.testing.extension.nio.H2AsyncServerResource; import org.apache.hc.core5.testing.extension.nio.H2MultiplexingRequesterResource; import org.apache.hc.core5.util.Timeout; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.RegisterExtension; @@ -133,12 +133,12 @@ public void completed(final IOSession session) { for (int i = 0; i < n; i++) { connPool.getSession(target, TIMEOUT, latch); } - Assertions.assertTrue(latch.await(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit())); + Assertions.assertThat(latch.await(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit())).isTrue(); requester.initiateShutdown(); requester.awaitShutdown(TIMEOUT); - Assertions.assertEquals(1, clientConnCount.get()); + Assertions.assertThat(clientConnCount.get()).isEqualTo(1); } @Test @@ -158,7 +158,7 @@ void testManyGetSessionFailures() throws Exception { requester.initiateShutdown(); requester.awaitShutdown(TIMEOUT); - Assertions.assertEquals(0, clientConnCount.get()); + Assertions.assertThat(clientConnCount.get()).isEqualTo(0); } } diff --git a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/H2CoreTransportMultiplexingTest.java b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/H2CoreTransportMultiplexingTest.java index a914e85d35..94b4ff591d 100644 --- a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/H2CoreTransportMultiplexingTest.java +++ b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/H2CoreTransportMultiplexingTest.java @@ -28,7 +28,6 @@ package org.apache.hc.core5.testing.nio; -import org.junit.jupiter.api.Assertions; import java.net.InetAddress; import java.net.InetSocketAddress; import java.util.LinkedList; @@ -69,6 +68,7 @@ import org.apache.hc.core5.testing.extension.nio.H2MultiplexingRequesterResource; import org.apache.hc.core5.util.TimeValue; import org.apache.hc.core5.util.Timeout; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.RegisterExtension; @@ -120,33 +120,33 @@ void testSequentialRequests() throws Exception { new StringAsyncEntityProducer("some stuff", ContentType.TEXT_PLAIN)), new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), TIMEOUT, null); final Message message1 = resultFuture1.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(message1); + Assertions.assertThat(message1).isNotNull(); final HttpResponse response1 = message1.head(); - Assertions.assertEquals(HttpStatus.SC_OK, response1.getCode()); + Assertions.assertThat(response1.getCode()).isEqualTo(HttpStatus.SC_OK); final String body1 = message1.body(); - Assertions.assertEquals("some stuff", body1); + Assertions.assertThat(body1).isEqualTo("some stuff"); final Future> resultFuture2 = requester.execute( new BasicRequestProducer(Method.POST, target, "/other-stuff", new StringAsyncEntityProducer("some other stuff", ContentType.TEXT_PLAIN)), new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), TIMEOUT, null); final Message message2 = resultFuture2.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(message2); + Assertions.assertThat(message2).isNotNull(); final HttpResponse response2 = message2.head(); - Assertions.assertEquals(HttpStatus.SC_OK, response2.getCode()); + Assertions.assertThat(response2.getCode()).isEqualTo(HttpStatus.SC_OK); final String body2 = message2.body(); - Assertions.assertEquals("some other stuff", body2); + Assertions.assertThat(body2).isEqualTo("some other stuff"); final Future> resultFuture3 = requester.execute( new BasicRequestProducer(Method.POST, target, "/more-stuff", new StringAsyncEntityProducer("some more stuff", ContentType.TEXT_PLAIN)), new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), TIMEOUT, null); final Message message3 = resultFuture3.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(message3); + Assertions.assertThat(message3).isNotNull(); final HttpResponse response3 = message3.head(); - Assertions.assertEquals(HttpStatus.SC_OK, response3.getCode()); + Assertions.assertThat(response3.getCode()).isEqualTo(HttpStatus.SC_OK); final String body3 = message3.body(); - Assertions.assertEquals("some more stuff", body3); + Assertions.assertThat(body3).isEqualTo("some more stuff"); } @Test @@ -163,11 +163,11 @@ void testLargeRequest() throws Exception { new BasicRequestProducer(Method.POST, target, "/a-lot-of-stuff", AsyncEntityProducers.create(content, ContentType.TEXT_PLAIN)), new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), TIMEOUT, null); final Message message = resultFuture.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(message); + Assertions.assertThat(message).isNotNull(); final HttpResponse response = message.head(); - Assertions.assertEquals(HttpStatus.SC_OK, response.getCode()); + Assertions.assertThat(response.getCode()).isEqualTo(HttpStatus.SC_OK); final String body = message.body(); - Assertions.assertEquals(content, body); + Assertions.assertThat(body).isEqualTo(content); } @Test @@ -197,11 +197,11 @@ void testMultiplexedRequests() throws Exception { while (!queue.isEmpty()) { final Future> resultFuture = queue.remove(); final Message message = resultFuture.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(message); + Assertions.assertThat(message).isNotNull(); final HttpResponse response = message.head(); - Assertions.assertEquals(HttpStatus.SC_OK, response.getCode()); + Assertions.assertThat(response.getCode()).isEqualTo(HttpStatus.SC_OK); final String body = message.body(); - Assertions.assertTrue(body.contains("stuff")); + Assertions.assertThat(body.contains("stuff")).isTrue(); } } @@ -220,11 +220,11 @@ void testValidityCheck() throws Exception { new StringAsyncEntityProducer("some stuff", ContentType.TEXT_PLAIN)), new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), TIMEOUT, null); final Message message1 = resultFuture1.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(message1); + Assertions.assertThat(message1).isNotNull(); final HttpResponse response1 = message1.head(); - Assertions.assertEquals(HttpStatus.SC_OK, response1.getCode()); + Assertions.assertThat(response1.getCode()).isEqualTo(HttpStatus.SC_OK); final String body1 = message1.body(); - Assertions.assertEquals("some stuff", body1); + Assertions.assertThat(body1).isEqualTo("some stuff"); Thread.sleep(100); @@ -233,11 +233,11 @@ void testValidityCheck() throws Exception { new StringAsyncEntityProducer("some other stuff", ContentType.TEXT_PLAIN)), new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), TIMEOUT, null); final Message message2 = resultFuture2.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(message2); + Assertions.assertThat(message2).isNotNull(); final HttpResponse response2 = message2.head(); - Assertions.assertEquals(HttpStatus.SC_OK, response2.getCode()); + Assertions.assertThat(response2.getCode()).isEqualTo(HttpStatus.SC_OK); final String body2 = message2.body(); - Assertions.assertEquals("some other stuff", body2); + Assertions.assertThat(body2).isEqualTo("some other stuff"); Thread.sleep(100); @@ -246,11 +246,11 @@ void testValidityCheck() throws Exception { new StringAsyncEntityProducer("some more stuff", ContentType.TEXT_PLAIN)), new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), TIMEOUT, null); final Message message3 = resultFuture3.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(message3); + Assertions.assertThat(message3).isNotNull(); final HttpResponse response3 = message3.head(); - Assertions.assertEquals(HttpStatus.SC_OK, response3.getCode()); + Assertions.assertThat(response3.getCode()).isEqualTo(HttpStatus.SC_OK); final String body3 = message3.body(); - Assertions.assertEquals("some more stuff", body3); + Assertions.assertThat(body3).isEqualTo("some more stuff"); } @Test @@ -277,7 +277,7 @@ void testMultiplexedRequestCancellation() throws Exception { Thread.sleep(random.nextInt(10)); cancellable.cancel(); } - Assertions.assertTrue(countDownLatch.await(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit())); + Assertions.assertThat(countDownLatch.await(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit())).isTrue(); } } diff --git a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/H2IntegrationTest.java b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/H2IntegrationTest.java index fc11166e97..d93cf054d7 100644 --- a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/H2IntegrationTest.java +++ b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/H2IntegrationTest.java @@ -74,7 +74,8 @@ import org.apache.hc.core5.reactor.Command; import org.apache.hc.core5.reactor.IOSession; import org.apache.hc.core5.testing.extension.nio.H2TestResources; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; +import org.assertj.core.api.InstanceOfAssertFactories; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.RegisterExtension; @@ -221,32 +222,32 @@ public void cancelled() { })); } - Assertions.assertTrue(latch.await(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit())); + Assertions.assertThat(latch.await(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit())).isTrue(); - Assertions.assertEquals(reqNo, responseQueue.size()); - Assertions.assertEquals(reqNo, pushMessageQueue.size()); + Assertions.assertThat(responseQueue.size()).isEqualTo(reqNo); + Assertions.assertThat(pushMessageQueue.size()).isEqualTo(reqNo); while (!responseQueue.isEmpty()) { final Future> future = responseQueue.remove(); final Message result = future.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(result); + Assertions.assertThat(result).isNotNull(); final HttpResponse response1 = result.head(); final String entity = result.body(); - Assertions.assertNotNull(response1); - Assertions.assertEquals(200, response1.getCode()); - Assertions.assertEquals("Hi there", entity); + Assertions.assertThat(response1).isNotNull(); + Assertions.assertThat(response1.getCode()).isEqualTo(200); + Assertions.assertThat(entity).isEqualTo("Hi there"); } while (!pushMessageQueue.isEmpty()) { final Message pushMessage = pushMessageQueue.remove(); - Assertions.assertNotNull(pushMessage); + Assertions.assertThat(pushMessage).isNotNull(); final HttpResponse response = pushMessage.head(); final String entity = pushMessage.body(); - Assertions.assertEquals(200, response.getCode()); - Assertions.assertNotNull(entity); + Assertions.assertThat(response.getCode()).isEqualTo(200); + Assertions.assertThat(entity).isNotNull(); final StringTokenizer t1 = new StringTokenizer(entity, "\r\n"); while (t1.hasMoreTokens()) { - Assertions.assertEquals("Pushing lots of stuff", t1.nextToken()); + Assertions.assertThat(t1.nextToken()).isEqualTo("Pushing lots of stuff"); } } } @@ -322,26 +323,26 @@ public void failed(final Exception cause) { null, null); final Message result1 = future1.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(result1); + Assertions.assertThat(result1).isNotNull(); final HttpResponse response1 = result1.head(); final String entity1 = result1.body(); - Assertions.assertNotNull(response1); - Assertions.assertEquals(200, response1.getCode()); - Assertions.assertEquals("Hi there", entity1); + Assertions.assertThat(response1).isNotNull(); + Assertions.assertThat(response1.getCode()).isEqualTo(200); + Assertions.assertThat(entity1).isEqualTo("Hi there"); - Assertions.assertTrue(latch.await(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit())); + Assertions.assertThat(latch.await(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit())).isTrue(); - Assertions.assertEquals(2, pushResultQueue.size()); + Assertions.assertThat(pushResultQueue.size()).isEqualTo(2); final Object result2 = pushResultQueue.poll(); - Assertions.assertNotNull(result2); - Assertions.assertInstanceOf(H2StreamResetException.class, result2); - Assertions.assertEquals(H2Error.REFUSED_STREAM.getCode(), ((H2StreamResetException) result2).getCode()); + Assertions.assertThat(result2).isNotNull(); + Assertions.assertThat(result2).isInstanceOf(H2StreamResetException.class); + Assertions.assertThat(((H2StreamResetException) result2).getCode()).isEqualTo(H2Error.REFUSED_STREAM.getCode()); final Object result3 = pushResultQueue.poll(); - Assertions.assertNotNull(result3); - Assertions.assertInstanceOf(H2StreamResetException.class, result3); - Assertions.assertEquals(H2Error.REFUSED_STREAM.getCode(), ((H2StreamResetException) result3).getCode()); + Assertions.assertThat(result3).isNotNull(); + Assertions.assertThat(result3).isInstanceOf(H2StreamResetException.class); + Assertions.assertThat(((H2StreamResetException) result3).getCode()).isEqualTo(H2Error.REFUSED_STREAM.getCode()); } @ParameterizedTest(name = "Max concurrent streams: {0}") @@ -381,10 +382,10 @@ void testExcessOfConcurrentStreams(final int maxConcurrentStreams) throws Except while (!queue.isEmpty()) { final Future> future = queue.remove(); final Message result = future.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(result); + Assertions.assertThat(result).isNotNull(); final HttpResponse response = result.head(); - Assertions.assertNotNull(response); - Assertions.assertEquals(200, response.getCode()); + Assertions.assertThat(response).isNotNull(); + Assertions.assertThat(response.getCode()).isEqualTo(200); } } @@ -421,8 +422,8 @@ void testConnectionPing() throws Exception { })), Command.Priority.NORMAL); } - Assertions.assertTrue(latch.await(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit())); - Assertions.assertEquals(n, count.get()); + Assertions.assertThat(latch.await(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit())).isTrue(); + Assertions.assertThat(count.get()).isEqualTo(n); } @Test @@ -450,12 +451,12 @@ void testRequestWithInvalidConnectionHeader() throws Exception { new BasicRequestProducer(request, null), new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), context, null); - final ExecutionException exception = Assertions.assertThrows(ExecutionException.class, () -> - future.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit())); - Assertions.assertInstanceOf(ProtocolException.class, exception.getCause()); + final ExecutionException exception = Assertions.assertThatThrownBy(() -> + future.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit())).isInstanceOf(ExecutionException.class).asInstanceOf(InstanceOfAssertFactories.type(ExecutionException.class)).actual(); + Assertions.assertThat(exception.getCause()).isInstanceOf(ProtocolException.class); final EndpointDetails endpointDetails = context.getEndpointDetails(); - Assertions.assertEquals(0L, endpointDetails.getRequestCount()); + Assertions.assertThat(endpointDetails.getRequestCount()).isEqualTo(0L); } } diff --git a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/H2ServerBootstrapFiltersTest.java b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/H2ServerBootstrapFiltersTest.java index 6eddf26728..bae09d1e68 100644 --- a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/H2ServerBootstrapFiltersTest.java +++ b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/H2ServerBootstrapFiltersTest.java @@ -28,7 +28,6 @@ package org.apache.hc.core5.testing.nio; -import org.junit.jupiter.api.Assertions; import java.io.IOException; import java.net.InetAddress; import java.net.InetSocketAddress; @@ -65,6 +64,7 @@ import org.apache.hc.core5.testing.extension.nio.H2AsyncRequesterResource; import org.apache.hc.core5.testing.extension.nio.H2AsyncServerResource; import org.apache.hc.core5.util.Timeout; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.RegisterExtension; @@ -140,11 +140,11 @@ void testSequentialRequests() throws Exception { new StringAsyncEntityProducer("some stuff", ContentType.TEXT_PLAIN)), new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), TIMEOUT, null); final Message message = resultFuture.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(message); + Assertions.assertThat(message).isNotNull(); final HttpResponse response = message.head(); - Assertions.assertEquals(HttpStatus.SC_OK, response.getCode()); + Assertions.assertThat(response.getCode()).isEqualTo(HttpStatus.SC_OK); final Header testFilterHeader = response.getHeader("X-Test-Filter"); - Assertions.assertNotNull(testFilterHeader); + Assertions.assertThat(testFilterHeader).isNotNull(); } } diff --git a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/Http1AuthenticationTest.java b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/Http1AuthenticationTest.java index bdc2490f2c..2f3e7120ab 100644 --- a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/Http1AuthenticationTest.java +++ b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/Http1AuthenticationTest.java @@ -28,7 +28,6 @@ package org.apache.hc.core5.testing.nio; -import org.junit.jupiter.api.Assertions; import java.net.InetAddress; import java.net.InetSocketAddress; import java.nio.charset.StandardCharsets; @@ -69,6 +68,7 @@ import org.apache.hc.core5.testing.extension.nio.HttpAsyncRequesterResource; import org.apache.hc.core5.testing.extension.nio.HttpAsyncServerResource; import org.apache.hc.core5.util.Timeout; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.RegisterExtension; @@ -149,11 +149,11 @@ void testGetRequestAuthentication() throws Exception { new BasicRequestProducer(request1, null), new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), TIMEOUT, null); final Message message1 = resultFuture1.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(message1); + Assertions.assertThat(message1).isNotNull(); final HttpResponse response1 = message1.head(); - Assertions.assertEquals(HttpStatus.SC_UNAUTHORIZED, response1.getCode()); + Assertions.assertThat(response1.getCode()).isEqualTo(HttpStatus.SC_UNAUTHORIZED); final String body1 = message1.body(); - Assertions.assertEquals("You shall not pass!!!", body1); + Assertions.assertThat(body1).isEqualTo("You shall not pass!!!"); final HttpRequest request2 = new BasicHttpRequest(Method.GET, target, "/stuff"); request2.setHeader(HttpHeaders.AUTHORIZATION, "let me pass"); @@ -161,11 +161,11 @@ void testGetRequestAuthentication() throws Exception { new BasicRequestProducer(request2, null), new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), TIMEOUT, null); final Message message2 = resultFuture2.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(message2); + Assertions.assertThat(message2).isNotNull(); final HttpResponse response2 = message2.head(); - Assertions.assertEquals(HttpStatus.SC_OK, response2.getCode()); + Assertions.assertThat(response2.getCode()).isEqualTo(HttpStatus.SC_OK); final String body2 = message2.body(); - Assertions.assertEquals("", body2); + Assertions.assertThat(body2).isEqualTo(""); } @Test @@ -187,11 +187,11 @@ void testPostRequestAuthentication() throws Exception { new BasicRequestProducer(request1, AsyncEntityProducers.create(stuff, ContentType.TEXT_PLAIN)), new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), TIMEOUT, null); final Message message1 = resultFuture1.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(message1); + Assertions.assertThat(message1).isNotNull(); final HttpResponse response1 = message1.head(); - Assertions.assertEquals(HttpStatus.SC_UNAUTHORIZED, response1.getCode()); + Assertions.assertThat(response1.getCode()).isEqualTo(HttpStatus.SC_UNAUTHORIZED); final String body1 = message1.body(); - Assertions.assertEquals("You shall not pass!!!", body1); + Assertions.assertThat(body1).isEqualTo("You shall not pass!!!"); final HttpRequest request2 = new BasicHttpRequest(Method.POST, target, "/stuff"); request2.setHeader(HttpHeaders.AUTHORIZATION, "let me pass"); @@ -199,11 +199,11 @@ void testPostRequestAuthentication() throws Exception { new BasicRequestProducer(request2, AsyncEntityProducers.create(stuff, ContentType.TEXT_PLAIN)), new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), TIMEOUT, null); final Message message2 = resultFuture2.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(message2); + Assertions.assertThat(message2).isNotNull(); final HttpResponse response2 = message2.head(); - Assertions.assertEquals(HttpStatus.SC_OK, response2.getCode()); + Assertions.assertThat(response2.getCode()).isEqualTo(HttpStatus.SC_OK); final String body2 = message2.body(); - Assertions.assertEquals(new String(stuff, StandardCharsets.US_ASCII), body2); + Assertions.assertThat(body2).isEqualTo(new String(stuff, StandardCharsets.US_ASCII)); } @Test @@ -227,11 +227,11 @@ void testPostRequestAuthenticationNoExpectContinue() throws Exception { new BasicRequestProducer(request1, AsyncEntityProducers.create(stuff, ContentType.TEXT_PLAIN)), new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), TIMEOUT, null); final Message message1 = resultFuture1.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(message1); + Assertions.assertThat(message1).isNotNull(); final HttpResponse response1 = message1.head(); - Assertions.assertEquals(HttpStatus.SC_UNAUTHORIZED, response1.getCode()); + Assertions.assertThat(response1.getCode()).isEqualTo(HttpStatus.SC_UNAUTHORIZED); final String body1 = message1.body(); - Assertions.assertEquals("You shall not pass!!!", body1); + Assertions.assertThat(body1).isEqualTo("You shall not pass!!!"); final HttpRequest request2 = new BasicHttpRequest(Method.POST, target, "/stuff"); request2.setVersion(HttpVersion.HTTP_1_0); @@ -240,11 +240,11 @@ void testPostRequestAuthenticationNoExpectContinue() throws Exception { new BasicRequestProducer(request2, AsyncEntityProducers.create(stuff, ContentType.TEXT_PLAIN)), new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), TIMEOUT, null); final Message message2 = resultFuture2.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(message2); + Assertions.assertThat(message2).isNotNull(); final HttpResponse response2 = message2.head(); - Assertions.assertEquals(HttpStatus.SC_OK, response2.getCode()); + Assertions.assertThat(response2.getCode()).isEqualTo(HttpStatus.SC_OK); final String body2 = message2.body(); - Assertions.assertEquals(new String(stuff, StandardCharsets.US_ASCII), body2); + Assertions.assertThat(body2).isEqualTo(new String(stuff, StandardCharsets.US_ASCII)); } } diff --git a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/Http1CoreTransportTest.java b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/Http1CoreTransportTest.java index af0ee1ab4d..5d9ab47133 100644 --- a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/Http1CoreTransportTest.java +++ b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/Http1CoreTransportTest.java @@ -28,7 +28,6 @@ package org.apache.hc.core5.testing.nio; -import org.junit.jupiter.api.Assertions; import java.io.IOException; import java.net.InetAddress; import java.net.InetSocketAddress; @@ -66,6 +65,7 @@ import org.apache.hc.core5.testing.extension.nio.HttpAsyncRequesterResource; import org.apache.hc.core5.testing.extension.nio.HttpAsyncServerResource; import org.apache.hc.core5.util.Timeout; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.RegisterExtension; @@ -158,33 +158,33 @@ void testSequentialRequestsNonPersistentConnection() throws Exception { new StringAsyncEntityProducer("some stuff", ContentType.TEXT_PLAIN)), new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), TIMEOUT, null); final Message message1 = resultFuture1.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(message1); + Assertions.assertThat(message1).isNotNull(); final HttpResponse response1 = message1.head(); - Assertions.assertEquals(HttpStatus.SC_OK, response1.getCode()); + Assertions.assertThat(response1.getCode()).isEqualTo(HttpStatus.SC_OK); final String body1 = message1.body(); - Assertions.assertEquals("some stuff", body1); + Assertions.assertThat(body1).isEqualTo("some stuff"); final Future> resultFuture2 = requester.execute( new BasicRequestProducer(Method.POST, target, "/no-keep-alive/other-stuff", new StringAsyncEntityProducer("some other stuff", ContentType.TEXT_PLAIN)), new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), TIMEOUT, null); final Message message2 = resultFuture2.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(message2); + Assertions.assertThat(message2).isNotNull(); final HttpResponse response2 = message2.head(); - Assertions.assertEquals(HttpStatus.SC_OK, response2.getCode()); + Assertions.assertThat(response2.getCode()).isEqualTo(HttpStatus.SC_OK); final String body2 = message2.body(); - Assertions.assertEquals("some other stuff", body2); + Assertions.assertThat(body2).isEqualTo("some other stuff"); final Future> resultFuture3 = requester.execute( new BasicRequestProducer(Method.POST, target, "/no-keep-alive/more-stuff", new StringAsyncEntityProducer("some more stuff", ContentType.TEXT_PLAIN)), new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), TIMEOUT, null); final Message message3 = resultFuture3.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(message3); + Assertions.assertThat(message3).isNotNull(); final HttpResponse response3 = message3.head(); - Assertions.assertEquals(HttpStatus.SC_OK, response3.getCode()); + Assertions.assertThat(response3.getCode()).isEqualTo(HttpStatus.SC_OK); final String body3 = message3.body(); - Assertions.assertEquals("some more stuff", body3); + Assertions.assertThat(body3).isEqualTo("some more stuff"); } } diff --git a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/Http1IntegrationTest.java b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/Http1IntegrationTest.java index 33fc8afb87..71d17089d3 100644 --- a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/Http1IntegrationTest.java +++ b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/Http1IntegrationTest.java @@ -102,7 +102,8 @@ import org.apache.hc.core5.testing.extension.nio.Http1TestResources; import org.apache.hc.core5.util.CharArrayBuffer; import org.apache.hc.core5.util.Timeout; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; +import org.assertj.core.api.InstanceOfAssertFactories; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.RegisterExtension; import org.junit.jupiter.params.ParameterizedTest; @@ -150,12 +151,12 @@ void testGetConnectionClose() throws Exception { .build(), new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null); final Message result = future.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(result); + Assertions.assertThat(result).isNotNull(); final HttpResponse response1 = result.head(); final String entity1 = result.body(); - Assertions.assertNotNull(response1); - Assertions.assertEquals(200, response1.getCode()); - Assertions.assertEquals("Hi there", entity1); + Assertions.assertThat(response1).isNotNull(); + Assertions.assertThat(response1.getCode()).isEqualTo(200); + Assertions.assertThat(entity1).isEqualTo("Hi there"); } } } @@ -188,12 +189,12 @@ void testGetIdentityTransfer() throws Exception { streamEndpoint.close(); - Assertions.assertNotNull(result); + Assertions.assertThat(result).isNotNull(); final HttpResponse response = result.head(); final String entity = result.body(); - Assertions.assertNotNull(response); - Assertions.assertEquals(200, response.getCode()); - Assertions.assertEquals("Hi there", entity); + Assertions.assertThat(response).isNotNull(); + Assertions.assertThat(response.getCode()).isEqualTo(200); + Assertions.assertThat(entity).isEqualTo("Hi there"); } } @@ -226,12 +227,12 @@ void testPostIdentityTransfer() throws Exception { streamEndpoint.close(); - Assertions.assertNotNull(result); + Assertions.assertThat(result).isNotNull(); final HttpResponse response = result.head(); final String entity = result.body(); - Assertions.assertNotNull(response); - Assertions.assertEquals(200, response.getCode()); - Assertions.assertEquals("Hi there", entity); + Assertions.assertThat(response).isNotNull(); + Assertions.assertThat(response.getCode()).isEqualTo(200); + Assertions.assertThat(entity).isEqualTo("Hi there"); } } @@ -263,12 +264,12 @@ void testPostIdentityTransferOutOfSequenceResponseNotOK() throws Exception { streamEndpoint.close(); - Assertions.assertNotNull(result); + Assertions.assertThat(result).isNotNull(); final HttpResponse response = result.head(); final String entity = result.body(); - Assertions.assertNotNull(response); - Assertions.assertEquals(500, response.getCode()); - Assertions.assertEquals("Go away", entity); + Assertions.assertThat(response).isNotNull(); + Assertions.assertThat(response.getCode()).isEqualTo(500); + Assertions.assertThat(entity).isEqualTo("Go away"); } } @@ -296,12 +297,12 @@ void testHTTP10Post() throws Exception { new BasicRequestProducer(request, AsyncEntityProducers.create("Hi there")), new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null); final Message result = future.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(result); + Assertions.assertThat(result).isNotNull(); final HttpResponse response1 = result.head(); final String entity1 = result.body(); - Assertions.assertNotNull(response1); - Assertions.assertEquals(200, response1.getCode()); - Assertions.assertEquals("Hi back", entity1); + Assertions.assertThat(response1).isNotNull(); + Assertions.assertThat(response1.getCode()).isEqualTo(200); + Assertions.assertThat(entity1).isEqualTo("Hi back"); } } @@ -327,8 +328,8 @@ void testHTTP11FeaturesDisabledWithHTTP10Requests() throws Exception { final Future> future = streamEndpoint.execute( new BasicRequestProducer(request, new BasicAsyncEntityProducer(new byte[]{'a', 'b', 'c'}, null, true)), new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null); - final ExecutionException exception = Assertions.assertThrows(ExecutionException.class, future::get); - Assertions.assertInstanceOf(ProtocolException.class, exception.getCause()); + final ExecutionException exception = Assertions.assertThatThrownBy(future::get).isInstanceOf(ExecutionException.class).asInstanceOf(InstanceOfAssertFactories.type(ExecutionException.class)).actual(); + Assertions.assertThat(exception.getCause()).isInstanceOf(ProtocolException.class); } @Test @@ -354,11 +355,11 @@ void testHeadConnectionClose() throws Exception { .build(), new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null); final Message result = future.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(result); + Assertions.assertThat(result).isNotNull(); final HttpResponse response1 = result.head(); - Assertions.assertNotNull(response1); - Assertions.assertEquals(200, response1.getCode()); - Assertions.assertNull(result.body()); + Assertions.assertThat(response1).isNotNull(); + Assertions.assertThat(response1.getCode()).isEqualTo(200); + Assertions.assertThat(result.body()).isNull(); } } } @@ -411,13 +412,13 @@ protected AsyncResponseProducer verify(final HttpRequest request, final HttpCont new BasicRequestProducer(request1, new MultiLineEntityProducer("0123456789abcdef", 1000)), new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null); final Message result1 = future1.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(result1); + Assertions.assertThat(result1).isNotNull(); final HttpResponse response1 = result1.head(); - Assertions.assertNotNull(response1); - Assertions.assertEquals(200, response1.getCode()); - Assertions.assertEquals("All is well", result1.body()); + Assertions.assertThat(response1).isNotNull(); + Assertions.assertThat(response1.getCode()).isEqualTo(200); + Assertions.assertThat(result1.body()).isEqualTo("All is well"); - Assertions.assertTrue(ioSession.isOpen()); + Assertions.assertThat(ioSession.isOpen()).isTrue(); final BasicHttpRequest request2 = BasicRequestBuilder.post() .setHttpHost(target) @@ -427,13 +428,13 @@ protected AsyncResponseProducer verify(final HttpRequest request, final HttpCont new BasicRequestProducer(request2, new MultiLineEntityProducer("0123456789abcdef", 5000)), new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null); final Message result2 = future2.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(result2); + Assertions.assertThat(result2).isNotNull(); final HttpResponse response2 = result2.head(); - Assertions.assertNotNull(response2); - Assertions.assertEquals(HttpStatus.SC_UNAUTHORIZED, response2.getCode()); - Assertions.assertEquals("You shall not pass", result2.body()); + Assertions.assertThat(response2).isNotNull(); + Assertions.assertThat(response2.getCode()).isEqualTo(HttpStatus.SC_UNAUTHORIZED); + Assertions.assertThat(result2.body()).isEqualTo("You shall not pass"); - Assertions.assertTrue(ioSession.isOpen()); + Assertions.assertThat(ioSession.isOpen()).isTrue(); final BasicHttpRequest request3 = BasicRequestBuilder.post() .setHttpHost(target) @@ -444,13 +445,13 @@ protected AsyncResponseProducer verify(final HttpRequest request, final HttpCont new BasicRequestProducer(request3, new MultiLineEntityProducer("0123456789abcdef", 1000)), new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null); final Message result3 = future3.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(result3); + Assertions.assertThat(result3).isNotNull(); final HttpResponse response3 = result3.head(); - Assertions.assertNotNull(response3); - Assertions.assertEquals(200, response3.getCode()); - Assertions.assertEquals("All is well", result3.body()); + Assertions.assertThat(response3).isNotNull(); + Assertions.assertThat(response3.getCode()).isEqualTo(200); + Assertions.assertThat(result3.body()).isEqualTo("All is well"); - Assertions.assertTrue(ioSession.isOpen()); + Assertions.assertThat(ioSession.isOpen()).isTrue(); final BasicHttpRequest request4 = BasicRequestBuilder.post() .setHttpHost(target) @@ -460,13 +461,13 @@ protected AsyncResponseProducer verify(final HttpRequest request, final HttpCont new BasicRequestProducer(request4, AsyncEntityProducers.create("blah")), new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null); final Message result4 = future4.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(result4); + Assertions.assertThat(result4).isNotNull(); final HttpResponse response4 = result4.head(); - Assertions.assertNotNull(response4); - Assertions.assertEquals(HttpStatus.SC_UNAUTHORIZED, response4.getCode()); - Assertions.assertEquals("You shall not pass", result4.body()); + Assertions.assertThat(response4).isNotNull(); + Assertions.assertThat(response4.getCode()).isEqualTo(HttpStatus.SC_UNAUTHORIZED); + Assertions.assertThat(result4.body()).isEqualTo("You shall not pass"); - Assertions.assertFalse(ioSession.isOpen()); + Assertions.assertThat(ioSession.isOpen()).isFalse(); } } @@ -521,13 +522,13 @@ protected AsyncResponseProducer verify(final HttpRequest request, final HttpCont ContentType.TEXT_PLAIN)), new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null); final Message result1 = future1.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(result1); + Assertions.assertThat(result1).isNotNull(); final HttpResponse response1 = result1.head(); - Assertions.assertNotNull(response1); - Assertions.assertEquals(HttpStatus.SC_UNAUTHORIZED, response1.getCode()); - Assertions.assertEquals("You shall not pass", result1.body()); + Assertions.assertThat(response1).isNotNull(); + Assertions.assertThat(response1.getCode()).isEqualTo(HttpStatus.SC_UNAUTHORIZED); + Assertions.assertThat(result1.body()).isEqualTo("You shall not pass"); - Assertions.assertFalse(streamEndpoint.isOpen()); + Assertions.assertThat(streamEndpoint.isOpen()).isFalse(); } } @@ -561,12 +562,12 @@ void testMissingExpectContinueAckClientContinues() throws Exception { new BasicRequestProducer(request, AsyncEntityProducers.create("Hi there")), new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null); final Message result = future.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(result); + Assertions.assertThat(result).isNotNull(); final HttpResponse response1 = result.head(); final String entity1 = result.body(); - Assertions.assertNotNull(response1); - Assertions.assertEquals(200, response1.getCode()); - Assertions.assertEquals("Hi there back", entity1); + Assertions.assertThat(response1).isNotNull(); + Assertions.assertThat(response1.getCode()).isEqualTo(200); + Assertions.assertThat(entity1).isEqualTo("Hi there back"); } } @@ -635,24 +636,24 @@ void testPipelinedConnectionClose() throws Exception { new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null); final Message result1 = future1.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(result1); + Assertions.assertThat(result1).isNotNull(); final HttpResponse response1 = result1.head(); final String entity1 = result1.body(); - Assertions.assertNotNull(response1); - Assertions.assertEquals(200, response1.getCode()); - Assertions.assertEquals("Hi back", entity1); + Assertions.assertThat(response1).isNotNull(); + Assertions.assertThat(response1.getCode()).isEqualTo(200); + Assertions.assertThat(entity1).isEqualTo("Hi back"); final Message result2 = future2.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(result2); + Assertions.assertThat(result2).isNotNull(); final HttpResponse response2 = result2.head(); final String entity2 = result2.body(); - Assertions.assertNotNull(response2); - Assertions.assertEquals(200, response2.getCode()); - Assertions.assertEquals("Hi back", entity2); + Assertions.assertThat(response2).isNotNull(); + Assertions.assertThat(response2.getCode()).isEqualTo(200); + Assertions.assertThat(entity2).isEqualTo("Hi back"); - final Exception exception = Assertions.assertThrows(Exception.class, () -> - future3.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit())); - Assertions.assertTrue(exception instanceof CancellationException || exception instanceof ExecutionException); + final Exception exception = Assertions.assertThatThrownBy(() -> + future3.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit())).isInstanceOf(Exception.class).asInstanceOf(InstanceOfAssertFactories.type(Exception.class)).actual(); + Assertions.assertThat(exception instanceof CancellationException || exception instanceof ExecutionException).isTrue(); final BasicHttpRequest request4 = BasicRequestBuilder.post() .setHttpHost(target) @@ -661,9 +662,9 @@ void testPipelinedConnectionClose() throws Exception { final Future> future4 = streamEndpoint.execute( new BasicRequestProducer(request4, AsyncEntityProducers.create("Hi there")), new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null); - final Exception exception2 = Assertions.assertThrows(Exception.class, () -> - future4.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit())); - Assertions.assertTrue(exception2 instanceof CancellationException || exception2 instanceof ExecutionException); + final Exception exception2 = Assertions.assertThatThrownBy(() -> + future4.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit())).isInstanceOf(Exception.class).asInstanceOf(InstanceOfAssertFactories.type(Exception.class)).actual(); + Assertions.assertThat(exception2 instanceof CancellationException || exception2 instanceof ExecutionException).isTrue(); } @Test @@ -707,25 +708,25 @@ void testPipelinedInvalidRequest() throws Exception { new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null); final Message result1 = future1.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(result1); + Assertions.assertThat(result1).isNotNull(); final HttpResponse response1 = result1.head(); final String entity1 = result1.body(); - Assertions.assertNotNull(response1); - Assertions.assertEquals(200, response1.getCode()); - Assertions.assertEquals("Hi back", entity1); + Assertions.assertThat(response1).isNotNull(); + Assertions.assertThat(response1.getCode()).isEqualTo(200); + Assertions.assertThat(entity1).isEqualTo("Hi back"); final Message result2 = future2.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(result2); + Assertions.assertThat(result2).isNotNull(); final HttpResponse response2 = result2.head(); final String entity2 = result2.body(); - Assertions.assertNotNull(response2); - Assertions.assertEquals(400, response2.getCode()); - Assertions.assertFalse(entity2.isEmpty()); + Assertions.assertThat(response2).isNotNull(); + Assertions.assertThat(response2.getCode()).isEqualTo(400); + Assertions.assertThat(entity2.isEmpty()).isFalse(); - final Exception exception = Assertions.assertThrows(Exception.class, () -> - future3.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit())); - Assertions.assertTrue(exception instanceof CancellationException || exception instanceof ExecutionException); + final Exception exception = Assertions.assertThatThrownBy(() -> + future3.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit())).isInstanceOf(Exception.class).asInstanceOf(InstanceOfAssertFactories.type(Exception.class)).actual(); + Assertions.assertThat(exception instanceof CancellationException || exception instanceof ExecutionException).isTrue(); } private static final byte[] GARBAGE = "garbage".getBytes(StandardCharsets.US_ASCII); @@ -863,11 +864,11 @@ public void releaseResources() { }; final BasicResponseConsumer responseConsumer = new BasicResponseConsumer<>(entityConsumer); final Future> future1 = streamEndpoint.execute(requestProducer, responseConsumer, null); - final ExecutionException exception = Assertions.assertThrows(ExecutionException.class, () -> - future1.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit())); + final ExecutionException exception = Assertions.assertThatThrownBy(() -> + future1.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit())).isInstanceOf(ExecutionException.class).asInstanceOf(InstanceOfAssertFactories.type(ExecutionException.class)).actual(); final Throwable cause = exception.getCause(); - Assertions.assertInstanceOf(MalformedChunkCodingException.class, cause); - Assertions.assertEquals("garbage", entityConsumer.generateContent()); + Assertions.assertThat(cause).isInstanceOf(MalformedChunkCodingException.class); + Assertions.assertThat(entityConsumer.generateContent()).isEqualTo("garbage"); } @ParameterizedTest @@ -915,9 +916,9 @@ protected HttpRequest createMessage(final CharArrayBuffer buffer) throws HttpExc final Future> future = streamEndpoint.execute( new BasicRequestProducer(request, null), new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null); - final ExecutionException executionException = Assertions.assertThrows(ExecutionException.class, () -> - future.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit())); - Assertions.assertInstanceOf(ConnectionClosedException.class, executionException.getCause()); + final ExecutionException executionException = Assertions.assertThatThrownBy(() -> + future.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit())).isInstanceOf(ExecutionException.class).asInstanceOf(InstanceOfAssertFactories.type(ExecutionException.class)).actual(); + Assertions.assertThat(executionException.getCause()).isInstanceOf(ConnectionClosedException.class); } @Test @@ -956,10 +957,10 @@ protected void writeHeadLine(final HttpRequest message, final CharArrayBuffer li new BasicRequestProducer(request, null), new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null); final Message result = future.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(result); + Assertions.assertThat(result).isNotNull(); final HttpResponse response = result.head(); - Assertions.assertNotNull(response); - Assertions.assertEquals(505, response.getCode()); + Assertions.assertThat(response).isNotNull(); + Assertions.assertThat(response.getCode()).isEqualTo(505); } } diff --git a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/HttpCoreTransportTest.java b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/HttpCoreTransportTest.java index fc5ab533a3..d96bf488c3 100644 --- a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/HttpCoreTransportTest.java +++ b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/HttpCoreTransportTest.java @@ -28,7 +28,6 @@ package org.apache.hc.core5.testing.nio; -import org.junit.jupiter.api.Assertions; import java.io.IOException; import java.net.InetAddress; import java.net.InetSocketAddress; @@ -57,6 +56,7 @@ import org.apache.hc.core5.http.nio.support.BasicResponseConsumer; import org.apache.hc.core5.reactor.ListenerEndpoint; import org.apache.hc.core5.util.Timeout; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; abstract class HttpCoreTransportTest { @@ -87,33 +87,33 @@ void testSequentialRequests() throws Exception { new StringAsyncEntityProducer("some stuff", ContentType.TEXT_PLAIN)), new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), TIMEOUT, null); final Message message1 = resultFuture1.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(message1); + Assertions.assertThat(message1).isNotNull(); final HttpResponse response1 = message1.head(); - Assertions.assertEquals(HttpStatus.SC_OK, response1.getCode()); + Assertions.assertThat(response1.getCode()).isEqualTo(HttpStatus.SC_OK); final String body1 = message1.body(); - Assertions.assertEquals("some stuff", body1); + Assertions.assertThat(body1).isEqualTo("some stuff"); final Future> resultFuture2 = requester.execute( new BasicRequestProducer(Method.POST, target, "/other-stuff", new StringAsyncEntityProducer("some other stuff", ContentType.TEXT_PLAIN)), new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), TIMEOUT, null); final Message message2 = resultFuture2.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(message2); + Assertions.assertThat(message2).isNotNull(); final HttpResponse response2 = message2.head(); - Assertions.assertEquals(HttpStatus.SC_OK, response2.getCode()); + Assertions.assertThat(response2.getCode()).isEqualTo(HttpStatus.SC_OK); final String body2 = message2.body(); - Assertions.assertEquals("some other stuff", body2); + Assertions.assertThat(body2).isEqualTo("some other stuff"); final Future> resultFuture3 = requester.execute( new BasicRequestProducer(Method.POST, target, "/more-stuff", new StringAsyncEntityProducer("some more stuff", ContentType.TEXT_PLAIN)), new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), TIMEOUT, null); final Message message3 = resultFuture3.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(message3); + Assertions.assertThat(message3).isNotNull(); final HttpResponse response3 = message3.head(); - Assertions.assertEquals(HttpStatus.SC_OK, response3.getCode()); + Assertions.assertThat(response3.getCode()).isEqualTo(HttpStatus.SC_OK); final String body3 = message3.body(); - Assertions.assertEquals("some more stuff", body3); + Assertions.assertThat(body3).isEqualTo("some more stuff"); } @Test @@ -130,11 +130,11 @@ void testLargeRequest() throws Exception { new BasicRequestProducer(Method.POST, target, "/a-lot-of-stuff", AsyncEntityProducers.create(content, ContentType.TEXT_PLAIN)), new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), TIMEOUT, null); final Message message = resultFuture.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(message); + Assertions.assertThat(message).isNotNull(); final HttpResponse response = message.head(); - Assertions.assertEquals(HttpStatus.SC_OK, response.getCode()); + Assertions.assertThat(response.getCode()).isEqualTo(HttpStatus.SC_OK); final String body = message.body(); - Assertions.assertEquals(content, body); + Assertions.assertThat(body).isEqualTo(content); } @Test @@ -151,33 +151,33 @@ void testSequentialRequestsNonPersistentConnection() throws Exception { new StringAsyncEntityProducer("some stuff", ContentType.TEXT_PLAIN)), new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), TIMEOUT, null); final Message message1 = resultFuture1.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(message1); + Assertions.assertThat(message1).isNotNull(); final HttpResponse response1 = message1.head(); - Assertions.assertEquals(HttpStatus.SC_OK, response1.getCode()); + Assertions.assertThat(response1.getCode()).isEqualTo(HttpStatus.SC_OK); final String body1 = message1.body(); - Assertions.assertEquals("some stuff", body1); + Assertions.assertThat(body1).isEqualTo("some stuff"); final Future> resultFuture2 = requester.execute( new BasicRequestProducer(Method.POST, target, "/no-keep-alive/other-stuff", new StringAsyncEntityProducer("some other stuff", ContentType.TEXT_PLAIN)), new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), TIMEOUT, null); final Message message2 = resultFuture2.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(message2); + Assertions.assertThat(message2).isNotNull(); final HttpResponse response2 = message2.head(); - Assertions.assertEquals(HttpStatus.SC_OK, response2.getCode()); + Assertions.assertThat(response2.getCode()).isEqualTo(HttpStatus.SC_OK); final String body2 = message2.body(); - Assertions.assertEquals("some other stuff", body2); + Assertions.assertThat(body2).isEqualTo("some other stuff"); final Future> resultFuture3 = requester.execute( new BasicRequestProducer(Method.POST, target, "/no-keep-alive/more-stuff", new StringAsyncEntityProducer("some more stuff", ContentType.TEXT_PLAIN)), new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), TIMEOUT, null); final Message message3 = resultFuture3.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(message3); + Assertions.assertThat(message3).isNotNull(); final HttpResponse response3 = message3.head(); - Assertions.assertEquals(HttpStatus.SC_OK, response3.getCode()); + Assertions.assertThat(response3.getCode()).isEqualTo(HttpStatus.SC_OK); final String body3 = message3.body(); - Assertions.assertEquals("some more stuff", body3); + Assertions.assertThat(body3).isEqualTo("some more stuff"); } @Test @@ -198,33 +198,33 @@ void testSequentialRequestsSameEndpoint() throws Exception { new StringAsyncEntityProducer("some stuff", ContentType.TEXT_PLAIN)), new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null); final Message message1 = resultFuture1.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(message1); + Assertions.assertThat(message1).isNotNull(); final HttpResponse response1 = message1.head(); - Assertions.assertEquals(HttpStatus.SC_OK, response1.getCode()); + Assertions.assertThat(response1.getCode()).isEqualTo(HttpStatus.SC_OK); final String body1 = message1.body(); - Assertions.assertEquals("some stuff", body1); + Assertions.assertThat(body1).isEqualTo("some stuff"); final Future> resultFuture2 = endpoint.execute( new BasicRequestProducer(Method.POST, target, "/other-stuff", new StringAsyncEntityProducer("some other stuff", ContentType.TEXT_PLAIN)), new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null); final Message message2 = resultFuture2.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(message2); + Assertions.assertThat(message2).isNotNull(); final HttpResponse response2 = message2.head(); - Assertions.assertEquals(HttpStatus.SC_OK, response2.getCode()); + Assertions.assertThat(response2.getCode()).isEqualTo(HttpStatus.SC_OK); final String body2 = message2.body(); - Assertions.assertEquals("some other stuff", body2); + Assertions.assertThat(body2).isEqualTo("some other stuff"); final Future> resultFuture3 = endpoint.execute( new BasicRequestProducer(Method.POST, target, "/more-stuff", new StringAsyncEntityProducer("some more stuff", ContentType.TEXT_PLAIN)), new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null); final Message message3 = resultFuture3.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(message3); + Assertions.assertThat(message3).isNotNull(); final HttpResponse response3 = message3.head(); - Assertions.assertEquals(HttpStatus.SC_OK, response3.getCode()); + Assertions.assertThat(response3.getCode()).isEqualTo(HttpStatus.SC_OK); final String body3 = message3.body(); - Assertions.assertEquals("some more stuff", body3); + Assertions.assertThat(body3).isEqualTo("some more stuff"); } finally { endpoint.releaseAndReuse(); @@ -262,11 +262,11 @@ void testPipelinedRequests() throws Exception { while (!queue.isEmpty()) { final Future> resultFuture = queue.remove(); final Message message = resultFuture.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(message); + Assertions.assertThat(message).isNotNull(); final HttpResponse response = message.head(); - Assertions.assertEquals(HttpStatus.SC_OK, response.getCode()); + Assertions.assertThat(response.getCode()).isEqualTo(HttpStatus.SC_OK); final String body = message.body(); - Assertions.assertTrue(body.contains("stuff")); + Assertions.assertThat(body.contains("stuff")).isTrue(); } } finally { @@ -295,10 +295,10 @@ void testNonPersistentHeads() throws Exception { while (!queue.isEmpty()) { final Future> resultFuture = queue.remove(); final Message message = resultFuture.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(message); + Assertions.assertThat(message).isNotNull(); final HttpResponse response = message.head(); - Assertions.assertEquals(HttpStatus.SC_OK, response.getCode()); - Assertions.assertNull(message.body()); + Assertions.assertThat(response.getCode()).isEqualTo(HttpStatus.SC_OK); + Assertions.assertThat(message.body()).isNull(); } } diff --git a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/HttpIntegrationTest.java b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/HttpIntegrationTest.java index c58bdc2fe8..1d94a977d8 100644 --- a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/HttpIntegrationTest.java +++ b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/HttpIntegrationTest.java @@ -102,7 +102,7 @@ import org.apache.hc.core5.testing.extension.ExecutorResource; import org.apache.hc.core5.util.TextUtils; import org.apache.hc.core5.util.Timeout; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Disabled; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.RegisterExtension; @@ -153,12 +153,12 @@ void testGet() throws Exception { new BasicRequestProducer(request, null), new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null); final Message result = future.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(result); + Assertions.assertThat(result).isNotNull(); final HttpResponse response1 = result.head(); final String entity1 = result.body(); - Assertions.assertNotNull(response1); - Assertions.assertEquals(200, response1.getCode()); - Assertions.assertEquals("Hi there", entity1); + Assertions.assertThat(response1).isNotNull(); + Assertions.assertThat(response1.getCode()).isEqualTo(200); + Assertions.assertThat(entity1).isEqualTo("Hi there"); } } @@ -189,12 +189,12 @@ void testGetsPipelined() throws Exception { while (!queue.isEmpty()) { final Future> future = queue.remove(); final Message result = future.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(result); + Assertions.assertThat(result).isNotNull(); final HttpResponse response = result.head(); final String entity = result.body(); - Assertions.assertNotNull(response); - Assertions.assertEquals(200, response.getCode()); - Assertions.assertEquals("Hi there", entity); + Assertions.assertThat(response).isNotNull(); + Assertions.assertThat(response.getCode()).isEqualTo(200); + Assertions.assertThat(entity).isEqualTo("Hi there"); } } @@ -222,15 +222,15 @@ void testLargeGet() throws Exception { new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null); final Message result = future.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(result); + Assertions.assertThat(result).isNotNull(); final HttpResponse response = result.head(); - Assertions.assertNotNull(response); - Assertions.assertEquals(200, response.getCode()); + Assertions.assertThat(response).isNotNull(); + Assertions.assertThat(response.getCode()).isEqualTo(200); final String s = result.body(); - Assertions.assertNotNull(s); + Assertions.assertThat(s).isNotNull(); final StringTokenizer t = new StringTokenizer(s, "\r\n"); while (t.hasMoreTokens()) { - Assertions.assertEquals("0123456789abcdef", t.nextToken()); + Assertions.assertThat(t.nextToken()).isEqualTo("0123456789abcdef"); } } } @@ -262,15 +262,15 @@ void testLargeGetsPipelined() throws Exception { while (!queue.isEmpty()) { final Future> future = queue.remove(); final Message result = future.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(result); + Assertions.assertThat(result).isNotNull(); final HttpResponse response = result.head(); - Assertions.assertNotNull(response); - Assertions.assertEquals(200, response.getCode()); + Assertions.assertThat(response).isNotNull(); + Assertions.assertThat(response.getCode()).isEqualTo(200); final String entity = result.body(); - Assertions.assertNotNull(entity); + Assertions.assertThat(entity).isNotNull(); final StringTokenizer t = new StringTokenizer(entity, "\r\n"); while (t.hasMoreTokens()) { - Assertions.assertEquals("0123456789abcdef", t.nextToken()); + Assertions.assertThat(t.nextToken()).isEqualTo("0123456789abcdef"); } } } @@ -298,12 +298,12 @@ void testPost() throws Exception { new BasicRequestProducer(request, AsyncEntityProducers.create("Hi there")), new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null); final Message result = future.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(result); + Assertions.assertThat(result).isNotNull(); final HttpResponse response1 = result.head(); final String entity1 = result.body(); - Assertions.assertNotNull(response1); - Assertions.assertEquals(200, response1.getCode()); - Assertions.assertEquals("Hi back", entity1); + Assertions.assertThat(response1).isNotNull(); + Assertions.assertThat(response1.getCode()).isEqualTo(200); + Assertions.assertThat(entity1).isEqualTo("Hi back"); } } @@ -334,12 +334,12 @@ void testPostPipelined() throws Exception { while (!queue.isEmpty()) { final Future> future = queue.remove(); final Message result = future.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(result); + Assertions.assertThat(result).isNotNull(); final HttpResponse response = result.head(); final String entity = result.body(); - Assertions.assertNotNull(response); - Assertions.assertEquals(200, response.getCode()); - Assertions.assertEquals("Hi back", entity); + Assertions.assertThat(response).isNotNull(); + Assertions.assertThat(response.getCode()).isEqualTo(200); + Assertions.assertThat(entity).isEqualTo("Hi back"); } } @@ -370,15 +370,15 @@ void testLargePostsPipelined() throws Exception { while (!queue.isEmpty()) { final Future> future = queue.remove(); final Message result = future.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(result); + Assertions.assertThat(result).isNotNull(); final HttpResponse response = result.head(); - Assertions.assertNotNull(response); - Assertions.assertEquals(200, response.getCode()); + Assertions.assertThat(response).isNotNull(); + Assertions.assertThat(response.getCode()).isEqualTo(200); final String entity = result.body(); - Assertions.assertNotNull(entity); + Assertions.assertThat(entity).isNotNull(); final StringTokenizer t = new StringTokenizer(entity, "\r\n"); while (t.hasMoreTokens()) { - Assertions.assertEquals("0123456789abcdef", t.nextToken()); + Assertions.assertThat(t.nextToken()).isEqualTo("0123456789abcdef"); } } } @@ -406,13 +406,13 @@ void testEchoEmptyEntity() throws Exception { new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null); final Message result = future.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(result); + Assertions.assertThat(result).isNotNull(); final HttpResponse response = result.head(); final String entity = result.body(); - Assertions.assertNotNull(response); - Assertions.assertEquals(HttpStatus.SC_OK, response.getCode()); - Assertions.assertNotNull(entity); - Assertions.assertEquals("", entity); + Assertions.assertThat(response).isNotNull(); + Assertions.assertThat(response.getCode()).isEqualTo(HttpStatus.SC_OK); + Assertions.assertThat(entity).isNotNull(); + Assertions.assertThat(entity).isEqualTo(""); } @Test @@ -444,12 +444,12 @@ void testEchoLargeEntitySmallBuffer() throws Exception { new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null); final Message result = future.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(result); + Assertions.assertThat(result).isNotNull(); final HttpResponse response = result.head(); final String entity = result.body(); - Assertions.assertNotNull(response); - Assertions.assertEquals(HttpStatus.SC_OK, response.getCode()); - Assertions.assertEquals(content, entity); + Assertions.assertThat(response).isNotNull(); + Assertions.assertThat(response.getCode()).isEqualTo(HttpStatus.SC_OK); + Assertions.assertThat(entity).isEqualTo(content); } @Test @@ -475,12 +475,12 @@ void testEchoNoEntityRequest() throws Exception { new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null); final Message result = future.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(result); + Assertions.assertThat(result).isNotNull(); final HttpResponse response = result.head(); - Assertions.assertNotNull(response); - Assertions.assertEquals(HttpStatus.SC_OK, response.getCode()); + Assertions.assertThat(response).isNotNull(); + Assertions.assertThat(response.getCode()).isEqualTo(HttpStatus.SC_OK); final String body = result.body(); - Assertions.assertTrue(body == null || body.isEmpty()); + Assertions.assertThat(body == null || body.isEmpty()).isTrue(); } @Test @@ -506,11 +506,11 @@ void testEchoHeadNoBody() throws Exception { new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null); final Message result = future.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(result); + Assertions.assertThat(result).isNotNull(); final HttpResponse response = result.head(); - Assertions.assertNotNull(response); - Assertions.assertEquals(HttpStatus.SC_OK, response.getCode()); - Assertions.assertNull(result.body()); + Assertions.assertThat(response).isNotNull(); + Assertions.assertThat(response.getCode()).isEqualTo(HttpStatus.SC_OK); + Assertions.assertThat(result.body()).isNull(); } @Test @@ -541,12 +541,12 @@ void testEchoManySmallRequests() throws Exception { for (int i = 0; i < REQ_NUM; i++) { final Future> future = queue.remove(); final Message result = future.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(result); + Assertions.assertThat(result).isNotNull(); final HttpResponse response = result.head(); final String entity = result.body(); - Assertions.assertNotNull(response); - Assertions.assertEquals(HttpStatus.SC_OK, response.getCode()); - Assertions.assertEquals("hi-" + i, entity); + Assertions.assertThat(response).isNotNull(); + Assertions.assertThat(response.getCode()).isEqualTo(HttpStatus.SC_OK); + Assertions.assertThat(entity).isEqualTo("hi-" + i); } } @@ -573,12 +573,12 @@ void testNoEntityPost() throws Exception { new BasicRequestProducer(request, null), new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null); final Message result = future.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(result); + Assertions.assertThat(result).isNotNull(); final HttpResponse response1 = result.head(); final String entity1 = result.body(); - Assertions.assertNotNull(response1); - Assertions.assertEquals(200, response1.getCode()); - Assertions.assertEquals("Hi back", entity1); + Assertions.assertThat(response1).isNotNull(); + Assertions.assertThat(response1.getCode()).isEqualTo(200); + Assertions.assertThat(entity1).isEqualTo("Hi back"); } } @@ -607,12 +607,12 @@ void testPostOutOfSequenceResponseOK() throws Exception { new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null); final Message result = future.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(result); + Assertions.assertThat(result).isNotNull(); final HttpResponse response = result.head(); final String entity = result.body(); - Assertions.assertNotNull(response); - Assertions.assertEquals(200, response.getCode()); - Assertions.assertEquals("Welcome", entity); + Assertions.assertThat(response).isNotNull(); + Assertions.assertThat(response.getCode()).isEqualTo(200); + Assertions.assertThat(entity).isEqualTo("Welcome"); } } @@ -639,11 +639,11 @@ void testHead() throws Exception { new BasicRequestProducer(request, null), new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null); final Message result = future.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(result); + Assertions.assertThat(result).isNotNull(); final HttpResponse response1 = result.head(); - Assertions.assertNotNull(response1); - Assertions.assertEquals(200, response1.getCode()); - Assertions.assertNull(result.body()); + Assertions.assertThat(response1).isNotNull(); + Assertions.assertThat(response1.getCode()).isEqualTo(200); + Assertions.assertThat(result.body()).isNull(); } } @@ -674,11 +674,11 @@ void testHeadPipelined() throws Exception { while (!queue.isEmpty()) { final Future> future = queue.remove(); final Message result = future.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(result); + Assertions.assertThat(result).isNotNull(); final HttpResponse response1 = result.head(); - Assertions.assertNotNull(response1); - Assertions.assertEquals(200, response1.getCode()); - Assertions.assertNull(result.body()); + Assertions.assertThat(response1).isNotNull(); + Assertions.assertThat(response1.getCode()).isEqualTo(200); + Assertions.assertThat(result.body()).isNull(); } } @@ -723,7 +723,7 @@ void testSlowResponseConsumer() throws Exception { } final StringTokenizer t1 = new StringTokenizer(buffer.toString(), "\r\n"); while (t1.hasMoreTokens()) { - Assertions.assertEquals("0123456789abcd", t1.nextToken()); + Assertions.assertThat(t1.nextToken()).isEqualTo("0123456789abcd"); } } } @@ -775,15 +775,15 @@ void testSlowRequestProducer() throws Exception { requestProducer.blockWaiting().execute(); final Message result1 = future1.get(LONG_TIMEOUT.getDuration(), LONG_TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(result1); + Assertions.assertThat(result1).isNotNull(); final HttpResponse response1 = result1.head(); - Assertions.assertNotNull(response1); - Assertions.assertEquals(200, response1.getCode()); + Assertions.assertThat(response1).isNotNull(); + Assertions.assertThat(response1.getCode()).isEqualTo(200); final String s1 = result1.body(); - Assertions.assertNotNull(s1); + Assertions.assertThat(s1).isNotNull(); final StringTokenizer t1 = new StringTokenizer(s1, "\r\n"); while (t1.hasMoreTokens()) { - Assertions.assertEquals("0123456789abcdef", t1.nextToken()); + Assertions.assertThat(t1.nextToken()).isEqualTo("0123456789abcdef"); } } @@ -843,15 +843,15 @@ void testSlowResponseProducer() throws Exception { new BasicRequestProducer(request1, null), new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null); final Message result1 = future1.get(LONG_TIMEOUT.getDuration(), LONG_TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(result1); + Assertions.assertThat(result1).isNotNull(); final HttpResponse response1 = result1.head(); - Assertions.assertNotNull(response1); - Assertions.assertEquals(200, response1.getCode()); + Assertions.assertThat(response1).isNotNull(); + Assertions.assertThat(response1.getCode()).isEqualTo(200); final String s1 = result1.body(); - Assertions.assertNotNull(s1); + Assertions.assertThat(s1).isNotNull(); final StringTokenizer t1 = new StringTokenizer(s1, "\r\n"); while (t1.hasMoreTokens()) { - Assertions.assertEquals("0123456789abcdef", t1.nextToken()); + Assertions.assertThat(t1.nextToken()).isEqualTo("0123456789abcdef"); } } @@ -931,13 +931,13 @@ public void releaseResources() { new BasicRequestProducer(request1, new MultiLineEntityProducer("0123456789abcdef", 100000)), new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null); final Message result1 = future1.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(result1); + Assertions.assertThat(result1).isNotNull(); final HttpResponse response1 = result1.head(); - Assertions.assertNotNull(response1); - Assertions.assertEquals(HttpStatus.SC_UNAUTHORIZED, response1.getCode()); - Assertions.assertEquals("You shall not pass", result1.body()); + Assertions.assertThat(response1).isNotNull(); + Assertions.assertThat(response1.getCode()).isEqualTo(HttpStatus.SC_UNAUTHORIZED); + Assertions.assertThat(result1.body()).isEqualTo("You shall not pass"); - Assertions.assertTrue(streamEndpoint.isOpen()); + Assertions.assertThat(streamEndpoint.isOpen()).isTrue(); } final BasicHttpRequest request1 = BasicRequestBuilder.post() .setHttpHost(target) @@ -950,11 +950,11 @@ public void releaseResources() { ContentType.TEXT_PLAIN)), new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null); final Message result1 = future1.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(result1); + Assertions.assertThat(result1).isNotNull(); final HttpResponse response1 = result1.head(); - Assertions.assertNotNull(response1); - Assertions.assertEquals(HttpStatus.SC_UNAUTHORIZED, response1.getCode()); - Assertions.assertEquals("You shall not pass", result1.body()); + Assertions.assertThat(response1).isNotNull(); + Assertions.assertThat(response1.getCode()).isEqualTo(HttpStatus.SC_UNAUTHORIZED); + Assertions.assertThat(result1.body()).isEqualTo("You shall not pass"); } @Test @@ -1014,11 +1014,11 @@ protected AsyncResponseProducer verify(final HttpRequest request, final HttpCont new BasicRequestProducer(request1, new MultiLineEntityProducer("0123456789abcdef", 5000)), new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null); final Message result1 = future1.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(result1); + Assertions.assertThat(result1).isNotNull(); final HttpResponse response1 = result1.head(); - Assertions.assertNotNull(response1); - Assertions.assertEquals(200, response1.getCode()); - Assertions.assertEquals("All is well", result1.body()); + Assertions.assertThat(response1).isNotNull(); + Assertions.assertThat(response1.getCode()).isEqualTo(200); + Assertions.assertThat(result1.body()).isEqualTo("All is well"); final BasicHttpRequest request2 = BasicRequestBuilder.post() .setHttpHost(target) @@ -1028,11 +1028,11 @@ protected AsyncResponseProducer verify(final HttpRequest request, final HttpCont new BasicRequestProducer(request2, new MultiLineEntityProducer("0123456789abcdef", 5000)), new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null); final Message result2 = future2.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(result2); + Assertions.assertThat(result2).isNotNull(); final HttpResponse response2 = result2.head(); - Assertions.assertNotNull(response2); - Assertions.assertEquals(HttpStatus.SC_UNAUTHORIZED, response2.getCode()); - Assertions.assertEquals("You shall not pass", result2.body()); + Assertions.assertThat(response2).isNotNull(); + Assertions.assertThat(response2.getCode()).isEqualTo(HttpStatus.SC_UNAUTHORIZED); + Assertions.assertThat(result2.body()).isEqualTo("You shall not pass"); } @Test @@ -1127,11 +1127,11 @@ public void releaseResources() { while (!queue.isEmpty()) { final Future> future = queue.remove(); final Message result = future.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(result); + Assertions.assertThat(result).isNotNull(); final HttpResponse response = result.head(); - Assertions.assertNotNull(response); - Assertions.assertEquals(200, response.getCode()); - Assertions.assertEquals("All is well", result.body()); + Assertions.assertThat(response).isNotNull(); + Assertions.assertThat(response.getCode()).isEqualTo(200); + Assertions.assertThat(result.body()).isEqualTo("All is well"); } } @@ -1166,12 +1166,12 @@ protected void handle( new BasicRequestProducer(request, null), new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null); final Message result = future.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(result); + Assertions.assertThat(result).isNotNull(); final HttpResponse response1 = result.head(); final String entity1 = result.body(); - Assertions.assertNotNull(response1); - Assertions.assertEquals(500, response1.getCode()); - Assertions.assertEquals("Boom", entity1); + Assertions.assertThat(response1).isNotNull(); + Assertions.assertThat(response1.getCode()).isEqualTo(500); + Assertions.assertThat(entity1).isEqualTo("Boom"); } @Test @@ -1218,22 +1218,22 @@ protected void handle( new BasicRequestProducer(request1, null), new BasicResponseConsumer<>(entityConsumer), null); final Message result1 = future1.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(result1); + Assertions.assertThat(result1).isNotNull(); final HttpResponse response1 = result1.head(); - Assertions.assertNotNull(response1); - Assertions.assertEquals(200, response1.getCode()); - Assertions.assertEquals("Hello back with some trailers", result1.body()); + Assertions.assertThat(response1).isNotNull(); + Assertions.assertThat(response1.getCode()).isEqualTo(200); + Assertions.assertThat(result1.body()).isEqualTo("Hello back with some trailers"); final List
trailers = entityConsumer.getTrailers(); - Assertions.assertNotNull(trailers); - Assertions.assertEquals(2, trailers.size()); + Assertions.assertThat(trailers).isNotNull(); + Assertions.assertThat(trailers.size()).isEqualTo(2); final Map map = new HashMap<>(); for (final Header header: trailers) { map.put(TextUtils.toLowerCase(header.getName()), header.getValue()); } final String digest = TextUtils.toHexString(entityConsumer.getDigest()); - Assertions.assertEquals("MD5", map.get("digest-algo")); - Assertions.assertEquals(digest, map.get("digest")); + Assertions.assertThat(map.get("digest-algo")).isEqualTo("MD5"); + Assertions.assertThat(map.get("digest")).isEqualTo(digest); } @Test @@ -1258,12 +1258,12 @@ void testNoServiceHandler() throws Exception { new BasicRequestProducer(request, null), new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null); final Message result = future.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(result); + Assertions.assertThat(result).isNotNull(); final HttpResponse response1 = result.head(); final String entity1 = result.body(); - Assertions.assertNotNull(response1); - Assertions.assertEquals(404, response1.getCode()); - Assertions.assertEquals("Resource not found", entity1); + Assertions.assertThat(response1).isNotNull(); + Assertions.assertThat(response1.getCode()).isEqualTo(404); + Assertions.assertThat(entity1).isEqualTo("Resource not found"); } @Test @@ -1298,11 +1298,11 @@ protected void handle( new BasicRequestProducer(request, null), new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null); final Message result = future.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(result); + Assertions.assertThat(result).isNotNull(); final HttpResponse response1 = result.head(); - Assertions.assertNotNull(response1); - Assertions.assertEquals(204, response1.getCode()); - Assertions.assertNull(result.body()); + Assertions.assertThat(response1).isNotNull(); + Assertions.assertThat(response1.getCode()).isEqualTo(204); + Assertions.assertThat(result.body()).isNull(); } @Test @@ -1378,12 +1378,12 @@ public void failed(final Exception cause) { new BasicRequestProducer(request, null), new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null); final Message result = future.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(result); + Assertions.assertThat(result).isNotNull(); final HttpResponse response1 = result.head(); final String entity1 = result.body(); - Assertions.assertNotNull(response1); - Assertions.assertEquals(HttpStatus.SC_BAD_REQUEST, response1.getCode()); - Assertions.assertEquals("Boom!!!", entity1); + Assertions.assertThat(response1).isNotNull(); + Assertions.assertThat(response1.getCode()).isEqualTo(HttpStatus.SC_BAD_REQUEST); + Assertions.assertThat(entity1).isEqualTo("Boom!!!"); } @Test @Disabled @@ -1456,11 +1456,11 @@ public void releaseResources() { while (!queue.isEmpty()) { final Future> future = queue.remove(); final Message result = future.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(result); + Assertions.assertThat(result).isNotNull(); final HttpResponse response = result.head(); - Assertions.assertNotNull(response); - Assertions.assertEquals(200, response.getCode()); - Assertions.assertEquals("All is well", result.body()); + Assertions.assertThat(response).isNotNull(); + Assertions.assertThat(response.getCode()).isEqualTo(200); + Assertions.assertThat(result.body()).isEqualTo("All is well"); } } @@ -1525,11 +1525,11 @@ protected void handle( while (!queue.isEmpty()) { final Future> future = queue.remove(); final Message result = future.get(LONG_TIMEOUT.getDuration(), LONG_TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(result); + Assertions.assertThat(result).isNotNull(); final HttpResponse response = result.head(); - Assertions.assertNotNull(response); - Assertions.assertEquals(200, response.getCode()); - Assertions.assertTrue(result.body().startsWith("All is well")); + Assertions.assertThat(response).isNotNull(); + Assertions.assertThat(response.getCode()).isEqualTo(200); + Assertions.assertThat(result.body().startsWith("All is well")).isTrue(); } } @@ -1593,10 +1593,10 @@ protected void handle( while (!queue.isEmpty()) { final Future> future = queue.remove(); final Message result = future.get(LONG_TIMEOUT.getDuration(), LONG_TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(result); + Assertions.assertThat(result).isNotNull(); final HttpResponse response = result.head(); - Assertions.assertNotNull(response); - Assertions.assertEquals(200, response.getCode()); + Assertions.assertThat(response).isNotNull(); + Assertions.assertThat(response.getCode()).isEqualTo(200); } } @@ -1638,11 +1638,11 @@ void testHeaderTooLarge(final String method) throws Exception { new BasicRequestProducer(request, entityProducer), new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null); final Message result1 = future1.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(result1); + Assertions.assertThat(result1).isNotNull(); final HttpResponse response1 = result1.head(); - Assertions.assertNotNull(response1); - Assertions.assertEquals(431, response1.getCode()); - Assertions.assertTrue(result1.body().contains("Maximum") && result1.body().contains("exceeded")); + Assertions.assertThat(response1).isNotNull(); + Assertions.assertThat(response1.getCode()).isEqualTo(431); + Assertions.assertThat(result1.body().contains("Maximum") && result1.body().contains("exceeded")).isTrue(); } } diff --git a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/TLSIntegrationTest.java b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/TLSIntegrationTest.java index 53e2e79d75..628e932766 100644 --- a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/TLSIntegrationTest.java +++ b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/TLSIntegrationTest.java @@ -84,7 +84,8 @@ import org.apache.hc.core5.util.Args; import org.apache.hc.core5.util.ReflectionUtils; import org.apache.hc.core5.util.Timeout; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; +import org.assertj.core.api.InstanceOfAssertFactories; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.AfterEachCallback; import org.junit.jupiter.api.extension.ExtensionContext; @@ -217,11 +218,11 @@ void testTLSSuccess(final TLS tlsProtocol) throws Exception { final Future tlsSessionFuture = executeTlsHandshake(); final TlsDetails tlsDetails = tlsSessionFuture.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(tlsDetails); + Assertions.assertThat(tlsDetails).isNotNull(); final SSLSession tlsSession = tlsDetails.getSSLSession(); final ProtocolVersion tlsVersion = TLS.parse(tlsSession.getProtocol()); - Assertions.assertTrue(tlsVersion.greaterEquals(tlsProtocol.version)); - Assertions.assertEquals("CN=localhost,OU=Apache HttpComponents,O=Apache Software Foundation", tlsSession.getPeerPrincipal().getName()); + Assertions.assertThat(tlsVersion.greaterEquals(tlsProtocol.version)).isTrue(); + Assertions.assertThat(tlsSession.getPeerPrincipal().getName()).isEqualTo("CN=localhost,OU=Apache HttpComponents,O=Apache Software Foundation"); } @Test @@ -236,10 +237,10 @@ void testTLSTrustFailure() throws Exception { final Future tlsSessionFuture = executeTlsHandshake(); - final ExecutionException exception = Assertions.assertThrows(ExecutionException.class, () -> - tlsSessionFuture.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit())); + final ExecutionException exception = Assertions.assertThatThrownBy(() -> + tlsSessionFuture.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit())).isInstanceOf(ExecutionException.class).asInstanceOf(InstanceOfAssertFactories.type(ExecutionException.class)).actual(); final Throwable cause = exception.getCause(); - Assertions.assertInstanceOf(SSLHandshakeException.class, cause); + Assertions.assertThat(cause).isInstanceOf(SSLHandshakeException.class); } @Test @@ -266,10 +267,10 @@ void testTLSClientAuthFailure() throws Exception { new StringAsyncEntityProducer("some stuff", ContentType.TEXT_PLAIN)), new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), TIMEOUT, null); - final ExecutionException exception = Assertions.assertThrows(ExecutionException.class, () -> - resultFuture.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit())); + final ExecutionException exception = Assertions.assertThatThrownBy(() -> + resultFuture.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit())).isInstanceOf(ExecutionException.class).asInstanceOf(InstanceOfAssertFactories.type(ExecutionException.class)).actual(); final Throwable cause = exception.getCause(); - Assertions.assertInstanceOf(IOException.class, cause); + Assertions.assertThat(cause).isInstanceOf(IOException.class); } @Test @@ -287,8 +288,8 @@ void testSSLDisabledByDefault() throws Exception { final Future tlsSessionFuture = executeTlsHandshake(); - Assertions.assertThrows(ExecutionException.class, () -> - tlsSessionFuture.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit())); + Assertions.assertThatThrownBy(() -> + tlsSessionFuture.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit())).isInstanceOf(ExecutionException.class); } @ParameterizedTest(name = "cipher {0}") @@ -323,8 +324,8 @@ void testWeakCipherDisabledByDefault(final String cipher) throws Exception { final Future tlsSessionFuture = executeTlsHandshake(); - Assertions.assertThrows(ExecutionException.class, () -> - tlsSessionFuture.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit())); + Assertions.assertThatThrownBy(() -> + tlsSessionFuture.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit())).isInstanceOf(ExecutionException.class); } @Test @@ -351,10 +352,10 @@ void testTLSVersionMismatch() throws Exception { final Future tlsSessionFuture = executeTlsHandshake(); - final ExecutionException exception = Assertions.assertThrows(ExecutionException.class, () -> - tlsSessionFuture.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit())); + final ExecutionException exception = Assertions.assertThatThrownBy(() -> + tlsSessionFuture.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit())).isInstanceOf(ExecutionException.class).asInstanceOf(InstanceOfAssertFactories.type(ExecutionException.class)).actual(); final Throwable cause = exception.getCause(); - Assertions.assertInstanceOf(IOException.class, cause); + Assertions.assertThat(cause).isInstanceOf(IOException.class); } @Test @@ -376,8 +377,8 @@ void testHostNameVerification() throws Exception { new StringAsyncEntityProducer("some stuff", ContentType.TEXT_PLAIN)), new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), TIMEOUT, null); final Message message1 = resultFuture1.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(message1); - Assertions.assertEquals(200, message1.head().getCode()); + Assertions.assertThat(message1).isNotNull(); + Assertions.assertThat(message1.head().getCode()).isEqualTo(200); final HttpHost target2 = new HttpHost(URIScheme.HTTPS.id, InetAddress.getLoopbackAddress(), "some-other-host", address.getPort()); final Future> resultFuture2 = client.execute( @@ -385,10 +386,10 @@ void testHostNameVerification() throws Exception { new BasicRequestProducer(Method.POST, target2, "/stuff", new StringAsyncEntityProducer("some stuff", ContentType.TEXT_PLAIN)), new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), TIMEOUT, null); - final ExecutionException exception = Assertions.assertThrows(ExecutionException.class, () -> - resultFuture2.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit())); + final ExecutionException exception = Assertions.assertThatThrownBy(() -> + resultFuture2.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit())).isInstanceOf(ExecutionException.class).asInstanceOf(InstanceOfAssertFactories.type(ExecutionException.class)).actual(); final Throwable cause = exception.getCause(); - Assertions.assertInstanceOf(SSLHandshakeException.class, cause); + Assertions.assertThat(cause).isInstanceOf(SSLHandshakeException.class); } static class SupportedTLSProtocolProvider implements ArgumentsProvider { diff --git a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/TLSUpgradeTest.java b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/TLSUpgradeTest.java index 6e41290d01..0722edcb42 100644 --- a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/TLSUpgradeTest.java +++ b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/TLSUpgradeTest.java @@ -62,7 +62,7 @@ import org.apache.hc.core5.testing.extension.nio.HttpAsyncRequesterResource; import org.apache.hc.core5.testing.extension.nio.HttpAsyncServerResource; import org.apache.hc.core5.util.Timeout; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.RegisterExtension; @@ -111,25 +111,25 @@ void testTLSUpgrade() throws Exception { new StringAsyncEntityProducer("some stuff", ContentType.TEXT_PLAIN)), new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), TIMEOUT, null); final Message message1 = resultFuture1.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(message1); + Assertions.assertThat(message1).isNotNull(); final HttpResponse response1 = message1.head(); - Assertions.assertEquals(HttpStatus.SC_OK, response1.getCode()); + Assertions.assertThat(response1.getCode()).isEqualTo(HttpStatus.SC_OK); final String body1 = message1.body(); - Assertions.assertEquals("some stuff", body1); + Assertions.assertThat(body1).isEqualTo("some stuff"); // Connect using plain HTTP scheme final Future endpointFuture = requester.connect( new HttpHost(URIScheme.HTTP.id, "localhost", address.getPort()), TIMEOUT); final AsyncClientEndpoint clientEndpoint = endpointFuture.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertInstanceOf(TlsUpgradeCapable.class, clientEndpoint); + Assertions.assertThat(clientEndpoint).isInstanceOf(TlsUpgradeCapable.class); // Upgrade to TLS final BasicFuture tlsFuture = new BasicFuture<>(null); ((TlsUpgradeCapable) clientEndpoint).tlsUpgrade(target, new CompletingFutureContribution<>(tlsFuture, ProtocolIOSession::getTlsDetails)); final TlsDetails tlsDetails = tlsFuture.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(tlsDetails); + Assertions.assertThat(tlsDetails).isNotNull(); // Execute request over HTTPS final Future> resultFuture2 = clientEndpoint.execute( @@ -137,11 +137,11 @@ void testTLSUpgrade() throws Exception { new StringAsyncEntityProducer("some stuff", ContentType.TEXT_PLAIN)), new BasicResponseConsumer<>(new StringAsyncEntityConsumer()), null); final Message message2 = resultFuture2.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit()); - Assertions.assertNotNull(message2); + Assertions.assertThat(message2).isNotNull(); final HttpResponse response2 = message2.head(); - Assertions.assertEquals(HttpStatus.SC_OK, response2.getCode()); + Assertions.assertThat(response2.getCode()).isEqualTo(HttpStatus.SC_OK); final String body2 = message2.body(); - Assertions.assertEquals("some stuff", body2); + Assertions.assertThat(body2).isEqualTo("some stuff"); } } diff --git a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/TestDefaultListeningIOReactor.java b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/TestDefaultListeningIOReactor.java index 3ccd7218a7..57c98f4abc 100644 --- a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/TestDefaultListeningIOReactor.java +++ b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/nio/TestDefaultListeningIOReactor.java @@ -39,8 +39,8 @@ import org.apache.hc.core5.reactor.IOReactorStatus; import org.apache.hc.core5.reactor.ListenerEndpoint; import org.apache.hc.core5.util.TimeValue; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.AfterEach; -import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -71,8 +71,8 @@ void testEndpointUpAndDown() throws Exception { ioReactor.start(); Set endpoints = ioReactor.getEndpoints(); - Assertions.assertNotNull(endpoints); - Assertions.assertEquals(0, endpoints.size()); + Assertions.assertThat(endpoints).isNotNull(); + Assertions.assertThat(endpoints.size()).isEqualTo(0); final Future future1 = ioReactor.listen(new InetSocketAddress(InetAddress.getLoopbackAddress(), 0)); final ListenerEndpoint endpoint1 = future1.get(); @@ -82,22 +82,22 @@ void testEndpointUpAndDown() throws Exception { final int port = ((InetSocketAddress) endpoint2.getAddress()).getPort(); endpoints = ioReactor.getEndpoints(); - Assertions.assertNotNull(endpoints); - Assertions.assertEquals(2, endpoints.size()); + Assertions.assertThat(endpoints).isNotNull(); + Assertions.assertThat(endpoints.size()).isEqualTo(2); endpoint1.close(); endpoints = ioReactor.getEndpoints(); - Assertions.assertNotNull(endpoints); - Assertions.assertEquals(1, endpoints.size()); + Assertions.assertThat(endpoints).isNotNull(); + Assertions.assertThat(endpoints.size()).isEqualTo(1); final ListenerEndpoint endpoint = endpoints.iterator().next(); - Assertions.assertEquals(port, ((InetSocketAddress) endpoint.getAddress()).getPort()); + Assertions.assertThat(((InetSocketAddress) endpoint.getAddress()).getPort()).isEqualTo(port); ioReactor.close(CloseMode.GRACEFUL); ioReactor.awaitShutdown(TimeValue.ofSeconds(5)); - Assertions.assertEquals(IOReactorStatus.SHUT_DOWN, ioReactor.getStatus()); + Assertions.assertThat(ioReactor.getStatus()).isEqualTo(IOReactorStatus.SHUT_DOWN); } @Test @@ -109,11 +109,13 @@ void testEndpointAlreadyBound() throws Exception { final int port = ((InetSocketAddress) endpoint1.getAddress()).getPort(); final Future future2 = ioReactor.listen(new InetSocketAddress(port)); - Assertions.assertThrows(ExecutionException.class, () -> future2.get()); + Assertions.assertThatThrownBy(() -> + future2.get()) + .isInstanceOf(ExecutionException.class); ioReactor.close(CloseMode.GRACEFUL); ioReactor.awaitShutdown(TimeValue.ofSeconds(5)); - Assertions.assertEquals(IOReactorStatus.SHUT_DOWN, ioReactor.getStatus()); + Assertions.assertThat(ioReactor.getStatus()).isEqualTo(IOReactorStatus.SHUT_DOWN); } } diff --git a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/reactive/ReactiveClientTest.java b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/reactive/ReactiveClientTest.java index fcb4db6af8..094f15a584 100644 --- a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/reactive/ReactiveClientTest.java +++ b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/reactive/ReactiveClientTest.java @@ -73,7 +73,8 @@ import org.apache.hc.core5.testing.reactive.Reactive3TestUtils.StreamDescription; import org.apache.hc.core5.util.TextUtils; import org.apache.hc.core5.util.Timeout; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; +import org.assertj.core.api.InstanceOfAssertFactories; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.RegisterExtension; import org.reactivestreams.Publisher; @@ -140,7 +141,7 @@ void testSimpleRequest() throws Exception { } writableByteChannel.close(); final byte[] output = byteArrayOutputStream.toByteArray(); - Assertions.assertArrayEquals(input, output); + Assertions.assertThat(output).containsExactly(input); } private BasicRequestProducer getRequestProducer(final InetSocketAddress address, final ReactiveEntityProducer producer) { @@ -163,8 +164,8 @@ void testLongRunningRequest() throws Exception { .get(RESULT_TIMEOUT.getDuration(), RESULT_TIMEOUT.getTimeUnit()); final StreamDescription desc = Reactive3TestUtils.consumeStream(response.body()).blockingGet(); - Assertions.assertEquals(expectedLength, desc.length); - Assertions.assertEquals(expectedHash.get(), TextUtils.toHexString(desc.md.digest())); + Assertions.assertThat(desc.length).isEqualTo(expectedLength); + Assertions.assertThat(TextUtils.toHexString(desc.md.digest())).isEqualTo(expectedHash.get()); } @Test @@ -189,8 +190,8 @@ void testManySmallBuffers() throws Exception { .get(RESULT_TIMEOUT.getDuration(), RESULT_TIMEOUT.getTimeUnit()); final StreamDescription desc = Reactive3TestUtils.consumeStream(response.body()).blockingGet(); - Assertions.assertEquals(expectedLength, desc.length); - Assertions.assertEquals(expectedHash.get(), TextUtils.toHexString(desc.md.digest())); + Assertions.assertThat(desc.length).isEqualTo(expectedLength); + Assertions.assertThat(TextUtils.toHexString(desc.md.digest())).isEqualTo(expectedHash.get()); } } @@ -208,10 +209,10 @@ void testRequestError() throws Exception { final Future future = requester.execute(request, consumer, SOCKET_TIMEOUT, null); - final ExecutionException exception = Assertions.assertThrows(ExecutionException.class, () -> - future.get(RESULT_TIMEOUT.getDuration(), RESULT_TIMEOUT.getTimeUnit())); - Assertions.assertInstanceOf(HttpStreamResetException.class, exception.getCause()); - Assertions.assertSame(exceptionThrown, exception.getCause().getCause()); + final ExecutionException exception = Assertions.assertThatThrownBy(() -> + future.get(RESULT_TIMEOUT.getDuration(), RESULT_TIMEOUT.getTimeUnit())).isInstanceOf(ExecutionException.class).asInstanceOf(InstanceOfAssertFactories.type(ExecutionException.class)).actual(); + Assertions.assertThat(exception.getCause()).isInstanceOf(HttpStreamResetException.class); + Assertions.assertThat(exception.getCause().getCause()).isSameAs(exceptionThrown); } @Test @@ -227,14 +228,14 @@ void testRequestTimeout() throws Exception { final ReactiveResponseConsumer consumer = new ReactiveResponseConsumer(); final Future future = requester.execute(request, consumer, Timeout.ofSeconds(1), null); - final ExecutionException exception = Assertions.assertThrows(ExecutionException.class, () -> - future.get(RESULT_TIMEOUT.getDuration(), RESULT_TIMEOUT.getTimeUnit())); - Assertions.assertTrue(requestPublisherCancellation.await(RESULT_TIMEOUT.getDuration(), RESULT_TIMEOUT.getTimeUnit())); + final ExecutionException exception = Assertions.assertThatThrownBy(() -> + future.get(RESULT_TIMEOUT.getDuration(), RESULT_TIMEOUT.getTimeUnit())).isInstanceOf(ExecutionException.class).asInstanceOf(InstanceOfAssertFactories.type(ExecutionException.class)).actual(); + Assertions.assertThat(requestPublisherCancellation.await(RESULT_TIMEOUT.getDuration(), RESULT_TIMEOUT.getTimeUnit())).isTrue(); final Throwable cause = exception.getCause(); if (versionPolicy == HttpVersionPolicy.FORCE_HTTP_1) { - Assertions.assertInstanceOf(SocketTimeoutException.class, cause, "Expected SocketTimeoutException, but got " + cause.getClass().getName()); + Assertions.assertThat(cause).withFailMessage("Expected SocketTimeoutException, but got " + cause.getClass().getName()).isInstanceOf(SocketTimeoutException.class); } else if (versionPolicy == HttpVersionPolicy.FORCE_HTTP_2) { - Assertions.assertInstanceOf(HttpStreamResetException.class, cause, format("Expected RST_STREAM, but %s was thrown", cause.getClass().getName())); + Assertions.assertThat(cause).withFailMessage(format("Expected RST_STREAM, but %s was thrown", cause.getClass().getName())).isInstanceOf(HttpStreamResetException.class); } else { Assertions.fail("Unknown HttpVersionPolicy: " + versionPolicy); } @@ -263,14 +264,14 @@ void testResponseCancellation() throws Exception { .take(3) .toList() .blockingGet(); - Assertions.assertEquals(3, outputBuffers.size()); - Assertions.assertTrue(responsePublisherWasCancelled.get(), "The response subscription should have been cancelled"); - final Exception exception = Assertions.assertThrows(Exception.class, () -> - future.get(RESULT_TIMEOUT.getDuration(), RESULT_TIMEOUT.getTimeUnit())); - Assertions.assertTrue(exception instanceof CancellationException || exception instanceof ExecutionException); - Assertions.assertInstanceOf(HttpStreamResetException.class, exception.getCause()); - Assertions.assertTrue(requestPublisherCancellation.await(RESULT_TIMEOUT.getDuration(), RESULT_TIMEOUT.getTimeUnit())); - Assertions.assertNull(requestStreamError.get()); + Assertions.assertThat(outputBuffers.size()).isEqualTo(3); + Assertions.assertThat(responsePublisherWasCancelled.get()).withFailMessage("The response subscription should have been cancelled").isTrue(); + final Exception exception = Assertions.assertThatThrownBy(() -> + future.get(RESULT_TIMEOUT.getDuration(), RESULT_TIMEOUT.getTimeUnit())).isInstanceOf(Exception.class).asInstanceOf(InstanceOfAssertFactories.type(Exception.class)).actual(); + Assertions.assertThat(exception instanceof CancellationException || exception instanceof ExecutionException).isTrue(); + Assertions.assertThat(exception.getCause()).isInstanceOf(HttpStreamResetException.class); + Assertions.assertThat(requestPublisherCancellation.await(RESULT_TIMEOUT.getDuration(), RESULT_TIMEOUT.getTimeUnit())).isTrue(); + Assertions.assertThat(requestStreamError.get()).isNull(); } private InetSocketAddress startServer() throws IOException, InterruptedException, ExecutionException { diff --git a/httpcore5/pom.xml b/httpcore5/pom.xml index 3f21244b24..7bc19cc170 100644 --- a/httpcore5/pom.xml +++ b/httpcore5/pom.xml @@ -45,6 +45,11 @@ junit-jupiter test + + org.assertj + assertj-core + test + org.junit.platform junit-platform-launcher diff --git a/httpcore5/src/test/java/org/apache/hc/core5/annotation/ThreadingBehaviorTest.java b/httpcore5/src/test/java/org/apache/hc/core5/annotation/ThreadingBehaviorTest.java index 1031fd0cbc..4fa665f5a4 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/annotation/ThreadingBehaviorTest.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/annotation/ThreadingBehaviorTest.java @@ -27,20 +27,19 @@ package org.apache.hc.core5.annotation; -import static org.junit.jupiter.api.Assertions.assertEquals; - +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class ThreadingBehaviorTest { @Test void testName() { - assertEquals("SAFE", ThreadingBehavior.SAFE.name()); - assertEquals("SAFE_CONDITIONAL", ThreadingBehavior.SAFE_CONDITIONAL.name()); - assertEquals("IMMUTABLE_CONDITIONAL", ThreadingBehavior.IMMUTABLE_CONDITIONAL.name()); - assertEquals("IMMUTABLE", ThreadingBehavior.IMMUTABLE.name()); - assertEquals("STATELESS", ThreadingBehavior.STATELESS.name()); - assertEquals("UNSAFE", ThreadingBehavior.UNSAFE.name()); + Assertions.assertThat(ThreadingBehavior.SAFE.name()).isEqualTo("SAFE"); + Assertions.assertThat(ThreadingBehavior.SAFE_CONDITIONAL.name()).isEqualTo("SAFE_CONDITIONAL"); + Assertions.assertThat(ThreadingBehavior.IMMUTABLE_CONDITIONAL.name()).isEqualTo("IMMUTABLE_CONDITIONAL"); + Assertions.assertThat(ThreadingBehavior.IMMUTABLE.name()).isEqualTo("IMMUTABLE"); + Assertions.assertThat(ThreadingBehavior.STATELESS.name()).isEqualTo("STATELESS"); + Assertions.assertThat(ThreadingBehavior.UNSAFE.name()).isEqualTo("UNSAFE"); } } \ No newline at end of file diff --git a/httpcore5/src/test/java/org/apache/hc/core5/concurrent/DefaultThreadFactoryTest.java b/httpcore5/src/test/java/org/apache/hc/core5/concurrent/DefaultThreadFactoryTest.java index aff64aff57..9e9c8c9498 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/concurrent/DefaultThreadFactoryTest.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/concurrent/DefaultThreadFactoryTest.java @@ -30,7 +30,7 @@ import java.util.concurrent.ThreadFactory; import java.util.concurrent.TimeUnit; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class DefaultThreadFactoryTest { @@ -40,9 +40,9 @@ void newThread() throws Exception { final ThreadFactory defaultThreadFactory = new DefaultThreadFactory("I/O server dispatch", true); final CountDownLatch lockHeld = new CountDownLatch(1); final Thread thread = defaultThreadFactory.newThread(lockHeld::countDown); - Assertions.assertNotNull(thread); + Assertions.assertThat(thread).isNotNull(); thread.start(); - Assertions.assertTrue(lockHeld.await(15, TimeUnit.SECONDS)); + Assertions.assertThat(lockHeld.await(15, TimeUnit.SECONDS)).isTrue(); } } \ No newline at end of file diff --git a/httpcore5/src/test/java/org/apache/hc/core5/concurrent/TestBasicFuture.java b/httpcore5/src/test/java/org/apache/hc/core5/concurrent/TestBasicFuture.java index 8be1a58c2c..ba072d65c4 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/concurrent/TestBasicFuture.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/concurrent/TestBasicFuture.java @@ -26,13 +26,8 @@ */ package org.apache.hc.core5.concurrent; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertThrows; -import static org.junit.jupiter.api.Assertions.assertTimeoutPreemptively; -import static org.junit.jupiter.api.Assertions.fail; - -import java.time.Duration; import java.util.concurrent.CancellationException; +import java.util.concurrent.CountDownLatch; import java.util.concurrent.ExecutionException; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; @@ -42,7 +37,7 @@ import java.util.concurrent.atomic.AtomicBoolean; import org.apache.hc.core5.util.TimeoutValueException; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.mockito.ArgumentMatchers; import org.mockito.Mockito; @@ -54,7 +49,7 @@ void testCompleted() throws Exception { final FutureCallback callback = Mockito.mock(FutureCallback.class); final BasicFuture future = new BasicFuture<>(callback); - Assertions.assertFalse(future.isDone()); + Assertions.assertThat(future.isDone()).isFalse(); final Object result = new Object(); final Exception boom = new Exception(); @@ -64,9 +59,9 @@ void testCompleted() throws Exception { Mockito.verify(callback, Mockito.never()).failed(ArgumentMatchers.any()); Mockito.verify(callback, Mockito.never()).cancelled(); - Assertions.assertSame(result, future.get()); - Assertions.assertTrue(future.isDone()); - Assertions.assertFalse(future.isCancelled()); + Assertions.assertThat(future.get()).isSameAs(result); + Assertions.assertThat(future.isDone()).isTrue(); + Assertions.assertThat(future.isCancelled()).isFalse(); } @@ -75,7 +70,7 @@ void testCompletedWithTimeout() throws Exception { final FutureCallback callback = Mockito.mock(FutureCallback.class); final BasicFuture future = new BasicFuture<>(callback); - Assertions.assertFalse(future.isDone()); + Assertions.assertThat(future.isDone()).isFalse(); final Object result = new Object(); final Exception boom = new Exception(); @@ -85,9 +80,9 @@ void testCompletedWithTimeout() throws Exception { Mockito.verify(callback, Mockito.never()).failed(ArgumentMatchers.any()); Mockito.verify(callback, Mockito.never()).cancelled(); - Assertions.assertSame(result, future.get(1, TimeUnit.MILLISECONDS)); - Assertions.assertTrue(future.isDone()); - Assertions.assertFalse(future.isCancelled()); + Assertions.assertThat(future.get(1, TimeUnit.MILLISECONDS)).isSameAs(result); + Assertions.assertThat(future.isDone()).isTrue(); + Assertions.assertThat(future.isCancelled()).isFalse(); } @Test @@ -102,10 +97,12 @@ void testFailed() throws Exception { Mockito.verify(callback).failed(boom); Mockito.verify(callback, Mockito.never()).cancelled(); - final ExecutionException ex = assertThrows(ExecutionException.class, future::get); - Assertions.assertSame(boom, ex.getCause()); - Assertions.assertTrue(future.isDone()); - Assertions.assertFalse(future.isCancelled()); + Assertions.assertThatThrownBy(future::get) + .isInstanceOf(ExecutionException.class) + .cause() + .isSameAs(boom); + Assertions.assertThat(future.isDone()).isTrue(); + Assertions.assertThat(future.isCancelled()).isFalse(); } @Test @@ -121,9 +118,9 @@ void testCancelled() { Mockito.verify(callback, Mockito.never()).failed(ArgumentMatchers.any()); Mockito.verify(callback).cancelled(); - assertThrows(CancellationException.class, future::get); - Assertions.assertTrue(future.isDone()); - Assertions.assertTrue(future.isCancelled()); + Assertions.assertThatThrownBy(future::get).isInstanceOf(CancellationException.class); + Assertions.assertThat(future.isDone()).isTrue(); + Assertions.assertThat(future.isCancelled()).isTrue(); } @Test @@ -140,9 +137,9 @@ void testAsyncCompleted() throws Exception { }); t.setDaemon(true); t.start(); - Assertions.assertSame(result, future.get(60, TimeUnit.SECONDS)); - Assertions.assertTrue(future.isDone()); - Assertions.assertFalse(future.isCancelled()); + Assertions.assertThat(future.get(60, TimeUnit.SECONDS)).isSameAs(result); + Assertions.assertThat(future.isDone()).isTrue(); + Assertions.assertThat(future.isCancelled()).isFalse(); } @Test @@ -159,11 +156,12 @@ void testAsyncFailed() throws Exception { }); t.setDaemon(true); t.start(); - final ExecutionException ex = assertThrows(ExecutionException.class, () -> - future.get(60, TimeUnit.SECONDS)); - Assertions.assertSame(boom, ex.getCause()); - Assertions.assertTrue(future.isDone()); - Assertions.assertFalse(future.isCancelled()); + Assertions.assertThatThrownBy(() -> future.get(60, TimeUnit.SECONDS)) + .isInstanceOf(ExecutionException.class) + .cause() + .isSameAs(boom); + Assertions.assertThat(future.isDone()).isTrue(); + Assertions.assertThat(future.isCancelled()).isFalse(); } @Test @@ -179,8 +177,8 @@ void testAsyncCancelled() { }); t.setDaemon(true); t.start(); - assertThrows(CancellationException.class, () -> - future.get(60, TimeUnit.SECONDS)); + Assertions.assertThatThrownBy(() -> future.get(60, TimeUnit.SECONDS)) + .isInstanceOf(CancellationException.class); } @Test @@ -197,15 +195,15 @@ void testAsyncTimeout() { }); t.setDaemon(true); t.start(); - assertThrows(TimeoutException.class, () -> - future.get(1, TimeUnit.MILLISECONDS)); + Assertions.assertThatThrownBy(() -> future.get(1, TimeUnit.MILLISECONDS)) + .isInstanceOf(TimeoutException.class); } @Test void testAsyncNegativeTimeout() { final BasicFuture future = new BasicFuture<>(null); - assertThrows(TimeoutValueException.class, () -> - future.get(-1, TimeUnit.MILLISECONDS)); + Assertions.assertThatThrownBy(() -> future.get(-1, TimeUnit.MILLISECONDS)) + .isInstanceOf(TimeoutValueException.class); } @Test @@ -232,13 +230,13 @@ void testConcurrentOperations() throws InterruptedException, ExecutionException // Verify that the first operation won and the other two failed. if (completedSuccessfully.get()) { - assertEquals(expectedResult, future.get()); + Assertions.assertThat(future.get()).isEqualTo(expectedResult); } else if (failedSuccessfully.get()) { - assertThrows(ExecutionException.class, future::get); + Assertions.assertThatThrownBy(future::get).isInstanceOf(ExecutionException.class); } else if (cancelledSuccessfully.get()) { - assertThrows(CancellationException.class, future::get); + Assertions.assertThatThrownBy(future::get).isInstanceOf(CancellationException.class); } else { - fail("No operation was successful on the future."); + Assertions.fail("No operation was successful on the future."); } // Shutdown the executor. @@ -246,13 +244,13 @@ void testConcurrentOperations() throws InterruptedException, ExecutionException } @Test - void testGetWithTimeout() { - final AtomicBoolean isFutureCompleted = new AtomicBoolean(); + void testGetWithTimeout() throws Exception { + final CountDownLatch futureCompleted = new CountDownLatch(1); final FutureCallback callback = new FutureCallbackAdapter() { @Override public void completed(final String result) { - isFutureCompleted.set(true); + futureCompleted.countDown(); } }; @@ -261,18 +259,7 @@ public void completed(final String result) { new Thread(() -> future.completed("test")).start(); - // Poll until the future is completed or timeout - assertTimeoutPreemptively(Duration.ofMillis(200), () -> { - while (!isFutureCompleted.get()) { - // This loop will spin until the future is completed or the assertTimeoutPreemptively times out. - Thread.yield(); - } - - try { - assertEquals("test", future.get(1, TimeUnit.SECONDS)); - } catch (final ExecutionException | TimeoutException e) { - fail("Test failed due to exception: " + e.getMessage()); - } - }); + Assertions.assertThat(futureCompleted.await(200, TimeUnit.MILLISECONDS)).isTrue(); + Assertions.assertThat(future.get(1, TimeUnit.SECONDS)).isEqualTo("test"); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/concurrent/TestCompletedFuture.java b/httpcore5/src/test/java/org/apache/hc/core5/concurrent/TestCompletedFuture.java index df65f57957..9d5f6a489d 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/concurrent/TestCompletedFuture.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/concurrent/TestCompletedFuture.java @@ -26,7 +26,7 @@ */ package org.apache.hc.core5.concurrent; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class TestCompletedFuture { @@ -35,9 +35,9 @@ class TestCompletedFuture { void testCompleted() { final Object result = new Object(); final CompletedFuture future = new CompletedFuture<>(result); - Assertions.assertSame(result, future.get()); - Assertions.assertTrue(future.isDone()); - Assertions.assertFalse(future.isCancelled()); + Assertions.assertThat(future.get()).isSameAs(result); + Assertions.assertThat(future.isDone()).isTrue(); + Assertions.assertThat(future.isCancelled()).isFalse(); future.cancel(true); future.cancel(); } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/concurrent/TestComplexCancellable.java b/httpcore5/src/test/java/org/apache/hc/core5/concurrent/TestComplexCancellable.java index ce70bfba60..68c34c4480 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/concurrent/TestComplexCancellable.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/concurrent/TestComplexCancellable.java @@ -26,13 +26,11 @@ */ package org.apache.hc.core5.concurrent; -import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.junit.jupiter.api.Assertions.assertTrue; +import java.util.concurrent.CountDownLatch; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; -import java.util.concurrent.CountDownLatch; - class TestComplexCancellable { @Test @@ -42,15 +40,15 @@ void testCancelled() { final BasicFuture dependency1 = new BasicFuture<>(null); cancellable.setDependency(dependency1); - assertFalse(cancellable.isCancelled()); + Assertions.assertThat(cancellable.isCancelled()).isFalse(); cancellable.cancel(); - assertTrue(cancellable.isCancelled()); - assertTrue(dependency1.isCancelled()); + Assertions.assertThat(cancellable.isCancelled()).isTrue(); + Assertions.assertThat(dependency1.isCancelled()).isTrue(); final BasicFuture dependency2 = new BasicFuture<>(null); cancellable.setDependency(dependency2); - assertTrue(dependency2.isCancelled()); + Assertions.assertThat(dependency2.isCancelled()).isTrue(); } @Test @@ -71,7 +69,7 @@ void testSetDependencyRace() throws InterruptedException { } latch.await(); - assertFalse(dependency1.isCancelled()); - assertFalse(dependency2.isCancelled()); + Assertions.assertThat(dependency1.isCancelled()).isFalse(); + Assertions.assertThat(dependency2.isCancelled()).isFalse(); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/concurrent/TestComplexFuture.java b/httpcore5/src/test/java/org/apache/hc/core5/concurrent/TestComplexFuture.java index a644c4911e..799b5799e7 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/concurrent/TestComplexFuture.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/concurrent/TestComplexFuture.java @@ -29,7 +29,7 @@ import java.util.concurrent.Future; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class TestComplexFuture { @@ -41,15 +41,15 @@ void testCancelled() { final Future dependency1 = new BasicFuture<>(null); future.setDependency(dependency1); - Assertions.assertFalse(future.isDone()); + Assertions.assertThat(future.isDone()).isFalse(); future.cancel(); - Assertions.assertTrue(future.isCancelled()); - Assertions.assertTrue(dependency1.isCancelled()); + Assertions.assertThat(future.isCancelled()).isTrue(); + Assertions.assertThat(dependency1.isCancelled()).isTrue(); final Future dependency2 = new BasicFuture<>(null); future.setDependency(dependency2); - Assertions.assertTrue(dependency2.isCancelled()); + Assertions.assertThat(dependency2.isCancelled()).isTrue(); } @Test @@ -59,15 +59,15 @@ void testCompleted() { final Future dependency1 = new BasicFuture<>(null); future.setDependency(dependency1); - Assertions.assertFalse(future.isDone()); + Assertions.assertThat(future.isDone()).isFalse(); future.completed(Boolean.TRUE); - Assertions.assertFalse(future.isCancelled()); - Assertions.assertFalse(dependency1.isCancelled()); + Assertions.assertThat(future.isCancelled()).isFalse(); + Assertions.assertThat(dependency1.isCancelled()).isFalse(); final Future dependency2 = new BasicFuture<>(null); future.setDependency(dependency2); - Assertions.assertTrue(dependency2.isCancelled()); + Assertions.assertThat(dependency2.isCancelled()).isTrue(); } @Test @@ -83,22 +83,22 @@ public void completed(final Object result) { }); future.setDependency(dependency1); - Assertions.assertFalse(future.isDone()); + Assertions.assertThat(future.isDone()).isFalse(); future.cancel(); - Assertions.assertTrue(future.isCancelled()); - Assertions.assertTrue(dependency1.isCancelled()); + Assertions.assertThat(future.isCancelled()).isTrue(); + Assertions.assertThat(dependency1.isCancelled()).isTrue(); final Future dependency2 = new BasicFuture<>(null); future.setDependency(dependency2); - Assertions.assertTrue(dependency2.isCancelled()); + Assertions.assertThat(dependency2.isCancelled()).isTrue(); } @Test void testCanceledAndFailed() { final ComplexFuture future = new ComplexFuture<>(null); - Assertions.assertTrue(future.cancel()); - Assertions.assertFalse(future.failed(new Exception())); + Assertions.assertThat(future.cancel()).isTrue(); + Assertions.assertThat(future.failed(new Exception())).isFalse(); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/HeaderMatcher.java b/httpcore5/src/test/java/org/apache/hc/core5/http/HeaderMatcher.java deleted file mode 100644 index 82b9928201..0000000000 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/HeaderMatcher.java +++ /dev/null @@ -1,48 +0,0 @@ -/* - * ==================================================================== - * Licensed to the Apache Software Foundation (ASF) under one - * or more contributor license agreements. See the NOTICE file - * distributed with this work for additional information - * regarding copyright ownership. The ASF licenses this file - * to you under the Apache License, Version 2.0 (the - * "License"); you may not use this file except in compliance - * with the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, - * software distributed under the License is distributed on an - * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY - * KIND, either express or implied. See the License for the - * specific language governing permissions and limitations - * under the License. - * ==================================================================== - * - * This software consists of voluntary contributions made by many - * individuals on behalf of the Apache Software Foundation. For more - * information on the Apache Software Foundation, please see - * . - * - */ -package org.apache.hc.core5.http; - -import org.junit.jupiter.api.Assertions; - -public final class HeaderMatcher { - - private HeaderMatcher() { - } - - public static void assertSame(final Header actual, final String headerName, final Object headerValue) { - Assertions.assertNotNull(actual, "header should not be null"); - Assertions.assertTrue(headerName.equalsIgnoreCase(actual.getName()), - "header name mismatch: expected=" + headerName + ", actual=" + actual.getName()); - Assertions.assertEquals(headerValue, actual.getValue(), "header value mismatch: expected=" + headerValue + ", actual=" + actual.getValue()); - } - - public static void assertSame(final Header actual, final Header expected) { - Assertions.assertNotNull(expected, "expected header should not be null"); - assertSame(actual, expected.getName(), expected.getValue()); - } - -} diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/HeadersMatcher.java b/httpcore5/src/test/java/org/apache/hc/core5/http/HeadersMatcher.java deleted file mode 100644 index 5bbc140dca..0000000000 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/HeadersMatcher.java +++ /dev/null @@ -1,57 +0,0 @@ -/* - * ==================================================================== - * Licensed to the Apache Software Foundation (ASF) under one - * or more contributor license agreements. See the NOTICE file - * distributed with this work for additional information - * regarding copyright ownership. The ASF licenses this file - * to you under the Apache License, Version 2.0 (the - * "License"); you may not use this file except in compliance - * with the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, - * software distributed under the License is distributed on an - * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY - * KIND, either express or implied. See the License for the - * specific language governing permissions and limitations - * under the License. - * ==================================================================== - * - * This software consists of voluntary contributions made by many - * individuals on behalf of the Apache Software Foundation. For more - * information on the Apache Software Foundation, please see - * . - * - */ -package org.apache.hc.core5.http; - -import org.junit.jupiter.api.Assertions; - -public final class HeadersMatcher { - - private HeadersMatcher() { - } - - public static void assertSame(final Header[] actual, final Header... expected) { - Assertions.assertNotNull(actual, "headers should not be null"); - Assertions.assertEquals(expected.length, actual.length, - "header array length mismatch: expected=" + expected.length + ", actual=" + actual.length); - for (int i = 0; i < actual.length; i++) { - final Header actualHeader = actual[i]; - final Header expectedHeader = expected[i]; - Assertions.assertNotNull(expectedHeader, "expected header at index " + i + " should not be null"); - Assertions.assertNotNull(actualHeader, "actual header at index " + i + " should not be null"); - Assertions.assertTrue(expectedHeader.getName().equalsIgnoreCase(actualHeader.getName()), - "header name mismatch at index " + i + ": expected=" + expectedHeader.getName() - + ", actual=" + actualHeader.getName()); - Assertions.assertEquals(expectedHeader.getValue(), actualHeader.getValue(), "header value mismatch at index " + i + ": expected=" + expectedHeader.getValue() - + ", actual=" + actualHeader.getValue()); - } - } - - public static void assertSame(final Header[] actual) { - assertSame(actual, new Header[0]); - } - -} diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/NameValuePairListMatcher.java b/httpcore5/src/test/java/org/apache/hc/core5/http/NameValuePairListMatcher.java deleted file mode 100644 index 0e6ebdb8cc..0000000000 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/NameValuePairListMatcher.java +++ /dev/null @@ -1,65 +0,0 @@ -/* - * ==================================================================== - * Licensed to the Apache Software Foundation (ASF) under one - * or more contributor license agreements. See the NOTICE file - * distributed with this work for additional information - * regarding copyright ownership. The ASF licenses this file - * to you under the Apache License, Version 2.0 (the - * "License"); you may not use this file except in compliance - * with the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, - * software distributed under the License is distributed on an - * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY - * KIND, either express or implied. See the License for the - * specific language governing permissions and limitations - * under the License. - * ==================================================================== - * - * This software consists of voluntary contributions made by many - * individuals on behalf of the Apache Software Foundation. For more - * information on the Apache Software Foundation, please see - * . - * - */ -package org.apache.hc.core5.http; - -import java.util.Arrays; -import java.util.Collections; -import java.util.List; - -import org.junit.jupiter.api.Assertions; - -public final class NameValuePairListMatcher { - - private NameValuePairListMatcher() { - } - - public static void assertEqualsTo(final List actual, final NameValuePair... expected) { - assertEqualsTo(actual, Arrays.asList(expected)); - } - - public static void assertEmpty(final List actual) { - assertEqualsTo(actual, Collections.emptyList()); - } - - private static void assertEqualsTo(final List actual, - final List expected) { - Assertions.assertNotNull(actual, "name-value list should not be null"); - Assertions.assertEquals(expected.size(), actual.size(), - "name-value list size mismatch: expected=" + expected.size() + ", actual=" + actual.size()); - for (int i = 0; i < actual.size(); i++) { - final NameValuePair actualNvp = actual.get(i); - final NameValuePair expectedNvp = expected.get(i); - Assertions.assertNotNull(expectedNvp, "expected name-value pair at index " + i + " should not be null"); - Assertions.assertNotNull(actualNvp, "actual name-value pair at index " + i + " should not be null"); - Assertions.assertEquals(actualNvp.getName(), expectedNvp.getName(), "name mismatch at index " + i + ": expected=" + expectedNvp.getName() - + ", actual=" + actualNvp.getName()); - Assertions.assertEquals(actualNvp.getValue(), expectedNvp.getValue(), "value mismatch at index " + i + ": expected=" + expectedNvp.getValue() - + ", actual=" + actualNvp.getValue()); - } - } - -} diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/TestContentType.java b/httpcore5/src/test/java/org/apache/hc/core5/http/TestContentType.java index 29e413cd92..83e754f31c 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/TestContentType.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/TestContentType.java @@ -31,7 +31,7 @@ import java.util.Arrays; import org.apache.hc.core5.http.message.BasicNameValuePair; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; /** @@ -43,106 +43,113 @@ class TestContentType { @Test void testApplicationZipCompressed() { final ContentType contentType = ContentType.create("application/x-zip-compressed"); - Assertions.assertEquals(contentType.toString(), ContentType.APPLICATION_ZIP_COMPRESSED.toString()); - Assertions.assertTrue(contentType.isSameMimeType(ContentType.APPLICATION_ZIP_COMPRESSED)); - Assertions.assertTrue(ContentType.APPLICATION_ZIP_COMPRESSED.isSameMimeType(contentType)); + Assertions.assertThat(ContentType.APPLICATION_ZIP_COMPRESSED.toString()).isEqualTo(contentType.toString()); + Assertions.assertThat(contentType.isSameMimeType(ContentType.APPLICATION_ZIP_COMPRESSED)).isTrue(); + Assertions.assertThat(ContentType.APPLICATION_ZIP_COMPRESSED.isSameMimeType(contentType)).isTrue(); } @Test void testBasis() throws Exception { final ContentType contentType = ContentType.create("text/plain", "US-ASCII"); - Assertions.assertEquals("text/plain", contentType.getMimeType()); - Assertions.assertEquals(StandardCharsets.US_ASCII, contentType.getCharset()); - Assertions.assertEquals("text/plain; charset=US-ASCII", contentType.toString()); + Assertions.assertThat(contentType.getMimeType()).isEqualTo("text/plain"); + Assertions.assertThat(contentType.getCharset()).isEqualTo(StandardCharsets.US_ASCII); + Assertions.assertThat(contentType.toString()).isEqualTo("text/plain; charset=US-ASCII"); } @Test void testWithCharset() throws Exception { ContentType contentType = ContentType.create("text/plain", "US-ASCII"); - Assertions.assertEquals("text/plain", contentType.getMimeType()); - Assertions.assertEquals(StandardCharsets.US_ASCII, contentType.getCharset()); - Assertions.assertEquals("text/plain; charset=US-ASCII", contentType.toString()); + Assertions.assertThat(contentType.getMimeType()).isEqualTo("text/plain"); + Assertions.assertThat(contentType.getCharset()).isEqualTo(StandardCharsets.US_ASCII); + Assertions.assertThat(contentType.toString()).isEqualTo("text/plain; charset=US-ASCII"); contentType = contentType.withCharset(StandardCharsets.UTF_8); - Assertions.assertEquals("text/plain", contentType.getMimeType()); - Assertions.assertEquals("UTF-8", contentType.getCharset().name()); - Assertions.assertEquals("text/plain; charset=UTF-8", contentType.toString()); + Assertions.assertThat(contentType.getMimeType()).isEqualTo("text/plain"); + Assertions.assertThat(contentType.getCharset().name()).isEqualTo("UTF-8"); + Assertions.assertThat(contentType.toString()).isEqualTo("text/plain; charset=UTF-8"); } @Test void testWithCharsetString() throws Exception { ContentType contentType = ContentType.create("text/plain", "US-ASCII"); - Assertions.assertEquals("text/plain", contentType.getMimeType()); - Assertions.assertEquals(StandardCharsets.US_ASCII, contentType.getCharset()); - Assertions.assertEquals("text/plain; charset=US-ASCII", contentType.toString()); + Assertions.assertThat(contentType.getMimeType()).isEqualTo("text/plain"); + Assertions.assertThat(contentType.getCharset()).isEqualTo(StandardCharsets.US_ASCII); + Assertions.assertThat(contentType.toString()).isEqualTo("text/plain; charset=US-ASCII"); contentType = contentType.withCharset(StandardCharsets.UTF_8); - Assertions.assertEquals("text/plain", contentType.getMimeType()); - Assertions.assertEquals(StandardCharsets.UTF_8, contentType.getCharset()); - Assertions.assertEquals("text/plain; charset=UTF-8", contentType.toString()); + Assertions.assertThat(contentType.getMimeType()).isEqualTo("text/plain"); + Assertions.assertThat(contentType.getCharset()).isEqualTo(StandardCharsets.UTF_8); + Assertions.assertThat(contentType.toString()).isEqualTo("text/plain; charset=UTF-8"); } @Test void testLowCaseText() throws Exception { final ContentType contentType = ContentType.create("Text/Plain", "ascii"); - Assertions.assertEquals("text/plain", contentType.getMimeType()); - Assertions.assertEquals(StandardCharsets.US_ASCII, contentType.getCharset()); + Assertions.assertThat(contentType.getMimeType()).isEqualTo("text/plain"); + Assertions.assertThat(contentType.getCharset()).isEqualTo(StandardCharsets.US_ASCII); } @Test void testCreateInvalidInput() { - Assertions.assertThrows(NullPointerException.class, () -> ContentType.create(null, (String) null)); - Assertions.assertThrows(IllegalArgumentException.class, () -> ContentType.create(" ", (String) null)); - Assertions.assertThrows(IllegalArgumentException.class, () -> ContentType.create("stuff;", (String) null)); - Assertions.assertThrows(IllegalArgumentException.class, () -> ContentType.create("text/plain", ",")); + Assertions.assertThatThrownBy(() -> + ContentType.create(null, (String) null)) + .isInstanceOf(NullPointerException.class); + Assertions.assertThatThrownBy(() -> + ContentType.create(" ", (String) null)) + .isInstanceOf(IllegalArgumentException.class); + Assertions.assertThatThrownBy(() -> + ContentType.create("stuff;", (String) null)) + .isInstanceOf(IllegalArgumentException.class); + Assertions.assertThatThrownBy(() -> + ContentType.create("text/plain", ",")) + .isInstanceOf(IllegalArgumentException.class); } @Test void testParse() throws Exception { final ContentType contentType = ContentType.parse("text/plain; charset=\"ascii\""); - Assertions.assertEquals("text/plain", contentType.getMimeType()); - Assertions.assertEquals(StandardCharsets.US_ASCII, contentType.getCharset()); - Assertions.assertEquals("text/plain; charset=ascii", contentType.toString()); + Assertions.assertThat(contentType.getMimeType()).isEqualTo("text/plain"); + Assertions.assertThat(contentType.getCharset()).isEqualTo(StandardCharsets.US_ASCII); + Assertions.assertThat(contentType.toString()).isEqualTo("text/plain; charset=ascii"); } @Test void testParseMultiparam() throws Exception { final ContentType contentType = ContentType.parse("text/plain; charset=\"ascii\"; " + "p0 ; p1 = \"blah-blah\" ; p2 = \" yada yada \" "); - Assertions.assertEquals("text/plain", contentType.getMimeType()); - Assertions.assertEquals(StandardCharsets.US_ASCII, contentType.getCharset()); - Assertions.assertEquals("text/plain; charset=ascii; p0; p1=blah-blah; p2=\" yada yada \"", - contentType.toString()); - Assertions.assertNull(contentType.getParameter("p0")); - Assertions.assertEquals("blah-blah", contentType.getParameter("p1")); - Assertions.assertEquals(" yada yada ", contentType.getParameter("p2")); - Assertions.assertNull(contentType.getParameter("p3")); + Assertions.assertThat(contentType.getMimeType()).isEqualTo("text/plain"); + Assertions.assertThat(contentType.getCharset()).isEqualTo(StandardCharsets.US_ASCII); + Assertions.assertThat(contentType.toString()).isEqualTo("text/plain; charset=ascii; p0; p1=blah-blah; p2=\" yada yada \""); + Assertions.assertThat(contentType.getParameter("p0")).isNull(); + Assertions.assertThat(contentType.getParameter("p1")).isEqualTo("blah-blah"); + Assertions.assertThat(contentType.getParameter("p2")).isEqualTo(" yada yada "); + Assertions.assertThat(contentType.getParameter("p3")).isNull(); } @Test void testParseEmptyCharset() throws Exception { final ContentType contentType = ContentType.parse("text/plain; charset=\" \""); - Assertions.assertEquals("text/plain", contentType.getMimeType()); - Assertions.assertNull(contentType.getCharset()); + Assertions.assertThat(contentType.getMimeType()).isEqualTo("text/plain"); + Assertions.assertThat(contentType.getCharset()).isNull(); } @Test void testParseDefaultCharset() throws Exception { final ContentType contentType = ContentType.parse("text/plain; charset=\" \""); - Assertions.assertEquals("text/plain", contentType.getMimeType()); - Assertions.assertNull(contentType.getCharset()); - Assertions.assertEquals(StandardCharsets.US_ASCII, contentType.getCharset(StandardCharsets.US_ASCII)); - Assertions.assertNull(contentType.getCharset(null)); + Assertions.assertThat(contentType.getMimeType()).isEqualTo("text/plain"); + Assertions.assertThat(contentType.getCharset()).isNull(); + Assertions.assertThat(contentType.getCharset(StandardCharsets.US_ASCII)).isEqualTo(StandardCharsets.US_ASCII); + Assertions.assertThat(contentType.getCharset(null)).isNull(); // - Assertions.assertNull(ContentType.getCharset(contentType, null)); - Assertions.assertEquals(StandardCharsets.US_ASCII, ContentType.getCharset(contentType, StandardCharsets.US_ASCII)); + Assertions.assertThat(ContentType.getCharset(contentType, null)).isNull(); + Assertions.assertThat(ContentType.getCharset(contentType, StandardCharsets.US_ASCII)).isEqualTo(StandardCharsets.US_ASCII); } @Test void testParseEmptyValue() throws Exception { - Assertions.assertNull(ContentType.parse(null)); - Assertions.assertNull(ContentType.parse("")); - Assertions.assertNull(ContentType.parse(" ")); - Assertions.assertNull(ContentType.parse(";")); - Assertions.assertNull(ContentType.parse("=")); + Assertions.assertThat(ContentType.parse(null)).isNull(); + Assertions.assertThat(ContentType.parse("")).isNull(); + Assertions.assertThat(ContentType.parse(" ")).isNull(); + Assertions.assertThat(ContentType.parse(";")).isNull(); + Assertions.assertThat(ContentType.parse("=")).isNull(); } @Test @@ -151,14 +158,14 @@ void testWithParamArrayChange() throws Exception { new BasicNameValuePair("p", "this"), new BasicNameValuePair("p", "that")}; final ContentType contentType = ContentType.create("text/plain", params); - Assertions.assertEquals("text/plain", contentType.getMimeType()); - Assertions.assertEquals(StandardCharsets.UTF_8, contentType.getCharset()); - Assertions.assertEquals("text/plain; charset=UTF-8; p=this; p=that", contentType.toString()); + Assertions.assertThat(contentType.getMimeType()).isEqualTo("text/plain"); + Assertions.assertThat(contentType.getCharset()).isEqualTo(StandardCharsets.UTF_8); + Assertions.assertThat(contentType.toString()).isEqualTo("text/plain; charset=UTF-8; p=this; p=that"); Arrays.setAll(params, i -> null); - Assertions.assertEquals("this", contentType.getParameter("p")); - Assertions.assertEquals("text/plain", contentType.getMimeType()); - Assertions.assertEquals(StandardCharsets.UTF_8, contentType.getCharset()); - Assertions.assertEquals("text/plain; charset=UTF-8; p=this; p=that", contentType.toString()); + Assertions.assertThat(contentType.getParameter("p")).isEqualTo("this"); + Assertions.assertThat(contentType.getMimeType()).isEqualTo("text/plain"); + Assertions.assertThat(contentType.getCharset()).isEqualTo(StandardCharsets.UTF_8); + Assertions.assertThat(contentType.toString()).isEqualTo("text/plain; charset=UTF-8; p=this; p=that"); } @Test @@ -167,44 +174,44 @@ void testWithParams() throws Exception { new BasicNameValuePair("charset", "UTF-8"), new BasicNameValuePair("p", "this"), new BasicNameValuePair("p", "that")); - Assertions.assertEquals("text/plain", contentType.getMimeType()); - Assertions.assertEquals(StandardCharsets.UTF_8, contentType.getCharset()); - Assertions.assertEquals("text/plain; charset=UTF-8; p=this; p=that", contentType.toString()); + Assertions.assertThat(contentType.getMimeType()).isEqualTo("text/plain"); + Assertions.assertThat(contentType.getCharset()).isEqualTo(StandardCharsets.UTF_8); + Assertions.assertThat(contentType.toString()).isEqualTo("text/plain; charset=UTF-8; p=this; p=that"); contentType = contentType.withParameters( new BasicNameValuePair("charset", "ascii"), new BasicNameValuePair("p", "this and that")); - Assertions.assertEquals("text/plain", contentType.getMimeType()); - Assertions.assertEquals(StandardCharsets.US_ASCII, contentType.getCharset()); - Assertions.assertEquals("text/plain; charset=ascii; p=\"this and that\"", contentType.toString()); + Assertions.assertThat(contentType.getMimeType()).isEqualTo("text/plain"); + Assertions.assertThat(contentType.getCharset()).isEqualTo(StandardCharsets.US_ASCII); + Assertions.assertThat(contentType.toString()).isEqualTo("text/plain; charset=ascii; p=\"this and that\""); contentType = ContentType.create("text/blah").withParameters( new BasicNameValuePair("p", "blah")); - Assertions.assertEquals("text/blah", contentType.getMimeType()); - Assertions.assertNull(contentType.getCharset()); - Assertions.assertEquals("text/blah; p=blah", contentType.toString()); + Assertions.assertThat(contentType.getMimeType()).isEqualTo("text/blah"); + Assertions.assertThat(contentType.getCharset()).isNull(); + Assertions.assertThat(contentType.toString()).isEqualTo("text/blah; p=blah"); contentType = ContentType.create("text/blah", StandardCharsets.ISO_8859_1).withParameters( new BasicNameValuePair("p", "blah")); - Assertions.assertEquals("text/blah", contentType.getMimeType()); - Assertions.assertEquals(StandardCharsets.ISO_8859_1, contentType.getCharset()); - Assertions.assertEquals("text/blah; charset=ISO-8859-1; p=blah", contentType.toString()); + Assertions.assertThat(contentType.getMimeType()).isEqualTo("text/blah"); + Assertions.assertThat(contentType.getCharset()).isEqualTo(StandardCharsets.ISO_8859_1); + Assertions.assertThat(contentType.toString()).isEqualTo("text/blah; charset=ISO-8859-1; p=blah"); } @Test void testParseLenientIgnoresIllegalCharsetName() { final ContentType contentType = ContentType.parseLenient("text/event-stream;charset=ISO-8859-1'"); - Assertions.assertNotNull(contentType); - Assertions.assertEquals("text/event-stream", contentType.getMimeType()); - Assertions.assertNull(contentType.getCharset()); - Assertions.assertEquals("ISO-8859-1'", contentType.getParameter("charset")); + Assertions.assertThat(contentType).isNotNull(); + Assertions.assertThat(contentType.getMimeType()).isEqualTo("text/event-stream"); + Assertions.assertThat(contentType.getCharset()).isNull(); + Assertions.assertThat(contentType.getParameter("charset")).isEqualTo("ISO-8859-1'"); } @Test void testParseLenientIgnoresUnsupportedCharset() { final ContentType contentType = ContentType.parseLenient("text/plain; charset=__no_such_charset__"); - Assertions.assertNotNull(contentType); - Assertions.assertNull(contentType.getCharset()); + Assertions.assertThat(contentType).isNotNull(); + Assertions.assertThat(contentType.getCharset()).isNull(); } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/TestHttpExceptions.java b/httpcore5/src/test/java/org/apache/hc/core5/http/TestHttpExceptions.java index 4731c84fd1..3c4723ab84 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/TestHttpExceptions.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/TestHttpExceptions.java @@ -27,7 +27,7 @@ package org.apache.hc.core5.http; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; /** @@ -42,48 +42,48 @@ class TestHttpExceptions { @Test void testConstructor() { final Throwable cause = new Exception(); - Assertions.assertDoesNotThrow(() -> new HttpException()); - Assertions.assertDoesNotThrow(() -> new HttpException("Oppsie")); - Assertions.assertDoesNotThrow(() -> new HttpException("Oppsie", cause)); - Assertions.assertDoesNotThrow(() -> new ProtocolException()); - Assertions.assertDoesNotThrow(() -> new ProtocolException("Oppsie")); - Assertions.assertDoesNotThrow(() -> new ProtocolException("Oppsie", cause)); - Assertions.assertDoesNotThrow(() -> new NoHttpResponseException("Oppsie")); - Assertions.assertDoesNotThrow(() -> new ConnectionClosedException("Oppsie")); - Assertions.assertDoesNotThrow(() -> new MethodNotSupportedException("Oppsie")); - Assertions.assertDoesNotThrow(() -> new MethodNotSupportedException("Oppsie", cause)); - Assertions.assertDoesNotThrow(() -> new UnsupportedHttpVersionException()); - Assertions.assertDoesNotThrow(() -> new UnsupportedHttpVersionException("Oppsie")); + Assertions.assertThatCode(() -> new HttpException()).doesNotThrowAnyException(); + Assertions.assertThatCode(() -> new HttpException("Oppsie")).doesNotThrowAnyException(); + Assertions.assertThatCode(() -> new HttpException("Oppsie", cause)).doesNotThrowAnyException(); + Assertions.assertThatCode(() -> new ProtocolException()).doesNotThrowAnyException(); + Assertions.assertThatCode(() -> new ProtocolException("Oppsie")).doesNotThrowAnyException(); + Assertions.assertThatCode(() -> new ProtocolException("Oppsie", cause)).doesNotThrowAnyException(); + Assertions.assertThatCode(() -> new NoHttpResponseException("Oppsie")).doesNotThrowAnyException(); + Assertions.assertThatCode(() -> new ConnectionClosedException("Oppsie")).doesNotThrowAnyException(); + Assertions.assertThatCode(() -> new MethodNotSupportedException("Oppsie")).doesNotThrowAnyException(); + Assertions.assertThatCode(() -> new MethodNotSupportedException("Oppsie", cause)).doesNotThrowAnyException(); + Assertions.assertThatCode(() -> new UnsupportedHttpVersionException()).doesNotThrowAnyException(); + Assertions.assertThatCode(() -> new UnsupportedHttpVersionException("Oppsie")).doesNotThrowAnyException(); } @Test void testNonPrintableCharactersInConnectionClosedException() { - Assertions.assertEquals(CLEAN_MESSAGE, new ConnectionClosedException(nonPrintableMessage).getMessage()); + Assertions.assertThat(new ConnectionClosedException(nonPrintableMessage).getMessage()).isEqualTo(CLEAN_MESSAGE); } @Test void testNonPrintableCharactersInHttpException() { - Assertions.assertEquals(CLEAN_MESSAGE, new HttpException(nonPrintableMessage).getMessage()); + Assertions.assertThat(new HttpException(nonPrintableMessage).getMessage()).isEqualTo(CLEAN_MESSAGE); } @Test void testNonPrintableCharactersInMethodNotSupportedException() { - Assertions.assertEquals(CLEAN_MESSAGE, new MethodNotSupportedException(nonPrintableMessage).getMessage()); + Assertions.assertThat(new MethodNotSupportedException(nonPrintableMessage).getMessage()).isEqualTo(CLEAN_MESSAGE); } @Test void testNonPrintableCharactersInNoHttpResponseException() { - Assertions.assertEquals(CLEAN_MESSAGE, new NoHttpResponseException(nonPrintableMessage).getMessage()); + Assertions.assertThat(new NoHttpResponseException(nonPrintableMessage).getMessage()).isEqualTo(CLEAN_MESSAGE); } @Test void testNonPrintableCharactersInProtocolException() { - Assertions.assertEquals(CLEAN_MESSAGE, new ProtocolException(nonPrintableMessage).getMessage()); + Assertions.assertThat(new ProtocolException(nonPrintableMessage).getMessage()).isEqualTo(CLEAN_MESSAGE); } @Test void testNonPrintableCharactersInUnsupportedHttpVersionException() { - Assertions.assertEquals(CLEAN_MESSAGE, new UnsupportedHttpVersionException(nonPrintableMessage).getMessage()); + Assertions.assertThat(new UnsupportedHttpVersionException(nonPrintableMessage).getMessage()).isEqualTo(CLEAN_MESSAGE); } @@ -91,13 +91,13 @@ void testNonPrintableCharactersInUnsupportedHttpVersionException() { void testControlCharacterEscaping() { final HttpException exception = new HttpException("0123456789abcdef\nsuffix"); - Assertions.assertEquals("0123456789abcdef[0x0a]suffix", exception.getMessage()); + Assertions.assertThat(exception.getMessage()).isEqualTo("0123456789abcdef[0x0a]suffix"); } @Test void testControlCharacterEncodingIndependentOfPosition() { - Assertions.assertEquals("a[0x0a]b", new HttpException("a\nb").getMessage()); - Assertions.assertEquals("0123456789abcdef[0x0a]b", new HttpException("0123456789abcdef\nb").getMessage()); + Assertions.assertThat(new HttpException("a\nb").getMessage()).isEqualTo("a[0x0a]b"); + Assertions.assertThat(new HttpException("0123456789abcdef\nb").getMessage()).isEqualTo("0123456789abcdef[0x0a]b"); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/TestHttpHost.java b/httpcore5/src/test/java/org/apache/hc/core5/http/TestHttpHost.java index f7d16c6e97..9118a1d61d 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/TestHttpHost.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/TestHttpHost.java @@ -35,7 +35,7 @@ import java.net.URI; import java.net.URISyntaxException; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; /** @@ -47,28 +47,34 @@ class TestHttpHost { @Test void testConstructor() { final HttpHost host1 = new HttpHost("somehost"); - Assertions.assertEquals("somehost", host1.getHostName()); - Assertions.assertEquals(-1, host1.getPort()); - Assertions.assertEquals("http", host1.getSchemeName()); + Assertions.assertThat(host1.getHostName()).isEqualTo("somehost"); + Assertions.assertThat(host1.getPort()).isEqualTo(-1); + Assertions.assertThat(host1.getSchemeName()).isEqualTo("http"); final HttpHost host2 = new HttpHost("somehost", 8080); - Assertions.assertEquals("somehost", host2.getHostName()); - Assertions.assertEquals(8080, host2.getPort()); - Assertions.assertEquals("http", host2.getSchemeName()); + Assertions.assertThat(host2.getHostName()).isEqualTo("somehost"); + Assertions.assertThat(host2.getPort()).isEqualTo(8080); + Assertions.assertThat(host2.getSchemeName()).isEqualTo("http"); final HttpHost host3 = new HttpHost("somehost", -1); - Assertions.assertEquals("somehost", host3.getHostName()); - Assertions.assertEquals(-1, host3.getPort()); - Assertions.assertEquals("http", host3.getSchemeName()); + Assertions.assertThat(host3.getHostName()).isEqualTo("somehost"); + Assertions.assertThat(host3.getPort()).isEqualTo(-1); + Assertions.assertThat(host3.getSchemeName()).isEqualTo("http"); final HttpHost host4 = new HttpHost("https", "somehost", 443); - Assertions.assertEquals("somehost", host4.getHostName()); - Assertions.assertEquals(443, host4.getPort()); - Assertions.assertEquals("https", host4.getSchemeName()); + Assertions.assertThat(host4.getHostName()).isEqualTo("somehost"); + Assertions.assertThat(host4.getPort()).isEqualTo(443); + Assertions.assertThat(host4.getSchemeName()).isEqualTo("https"); final HttpHost host5 = new HttpHost("https", "somehost"); - Assertions.assertEquals("somehost", host5.getHostName()); - Assertions.assertEquals(-1, host5.getPort()); - Assertions.assertEquals("https", host5.getSchemeName()); - Assertions.assertThrows(NullPointerException.class, () -> new HttpHost(null, (String) null, -1)); - Assertions.assertThrows(IllegalArgumentException.class, () -> new HttpHost(null, " ", -1)); - Assertions.assertThrows(NullPointerException.class, () -> new HttpHost(null, (InetAddress) null, -1)); + Assertions.assertThat(host5.getHostName()).isEqualTo("somehost"); + Assertions.assertThat(host5.getPort()).isEqualTo(-1); + Assertions.assertThat(host5.getSchemeName()).isEqualTo("https"); + Assertions.assertThatThrownBy(() -> + new HttpHost(null, (String) null, -1)) + .isInstanceOf(NullPointerException.class); + Assertions.assertThatThrownBy(() -> + new HttpHost(null, " ", -1)) + .isInstanceOf(IllegalArgumentException.class); + Assertions.assertThatThrownBy(() -> + new HttpHost(null, (InetAddress) null, -1)) + .isInstanceOf(NullPointerException.class); } @Test @@ -89,17 +95,17 @@ void testHashCode() throws Exception { final HttpHost host11 = new HttpHost( "http", InetAddress.getByAddress("someotherhost",new byte[] {127,0,0,1}), 80); - Assertions.assertEquals(host1.hashCode(), host1.hashCode()); - Assertions.assertNotEquals(host1.hashCode(), host2.hashCode()); - Assertions.assertNotEquals(host1.hashCode(), host3.hashCode()); - Assertions.assertEquals(host2.hashCode(), host4.hashCode()); - Assertions.assertEquals(host2.hashCode(), host5.hashCode()); - Assertions.assertNotEquals(host5.hashCode(), host6.hashCode()); - Assertions.assertNotEquals(host7.hashCode(), host8.hashCode()); - Assertions.assertNotEquals(host8.hashCode(), host9.hashCode()); - Assertions.assertEquals(host9.hashCode(), host10.hashCode()); - Assertions.assertNotEquals(host10.hashCode(), host11.hashCode()); - Assertions.assertNotEquals(host9.hashCode(), host11.hashCode()); + Assertions.assertThat(host1.hashCode()).isEqualTo(host1.hashCode()); + Assertions.assertThat(host2.hashCode()).isNotEqualTo(host1.hashCode()); + Assertions.assertThat(host3.hashCode()).isNotEqualTo(host1.hashCode()); + Assertions.assertThat(host4.hashCode()).isEqualTo(host2.hashCode()); + Assertions.assertThat(host5.hashCode()).isEqualTo(host2.hashCode()); + Assertions.assertThat(host6.hashCode()).isNotEqualTo(host5.hashCode()); + Assertions.assertThat(host8.hashCode()).isNotEqualTo(host7.hashCode()); + Assertions.assertThat(host9.hashCode()).isNotEqualTo(host8.hashCode()); + Assertions.assertThat(host10.hashCode()).isEqualTo(host9.hashCode()); + Assertions.assertThat(host11.hashCode()).isNotEqualTo(host10.hashCode()); + Assertions.assertThat(host11.hashCode()).isNotEqualTo(host9.hashCode()); } @Test @@ -120,54 +126,54 @@ void testEquals() throws Exception { final HttpHost host11 = new HttpHost( "http", InetAddress.getByAddress("someotherhost",new byte[] {127,0,0,1}), 80); - Assertions.assertEquals(host1, host1); - Assertions.assertNotEquals(host1, host2); - Assertions.assertNotEquals(host1, host3); - Assertions.assertEquals(host2, host4); - Assertions.assertEquals(host2, host5); - Assertions.assertNotEquals(host5, host6); - Assertions.assertNotEquals(host7, host8); - Assertions.assertNotEquals(host7, host9); - Assertions.assertNotEquals(null, host1); - Assertions.assertNotEquals("http://somehost", host1); - Assertions.assertNotEquals("http://somehost", host9); - Assertions.assertNotEquals(host8, host9); - Assertions.assertEquals(host9, host10); - Assertions.assertNotEquals(host9, host11); + Assertions.assertThat(host1).isEqualTo(host1); + Assertions.assertThat(host2).isNotEqualTo(host1); + Assertions.assertThat(host3).isNotEqualTo(host1); + Assertions.assertThat(host4).isEqualTo(host2); + Assertions.assertThat(host5).isEqualTo(host2); + Assertions.assertThat(host6).isNotEqualTo(host5); + Assertions.assertThat(host8).isNotEqualTo(host7); + Assertions.assertThat(host9).isNotEqualTo(host7); + Assertions.assertThat(host1).isNotEqualTo(null); + Assertions.assertThat(host1).isNotEqualTo("http://somehost"); + Assertions.assertThat(host9).isNotEqualTo("http://somehost"); + Assertions.assertThat(host9).isNotEqualTo(host8); + Assertions.assertThat(host10).isEqualTo(host9); + Assertions.assertThat(host11).isNotEqualTo(host9); } @Test void testToString() throws Exception { final HttpHost host1 = new HttpHost("somehost"); - Assertions.assertEquals("http://somehost", host1.toString()); + Assertions.assertThat(host1.toString()).isEqualTo("http://somehost"); final HttpHost host2 = new HttpHost("somehost", -1); - Assertions.assertEquals("http://somehost", host2.toString()); + Assertions.assertThat(host2.toString()).isEqualTo("http://somehost"); final HttpHost host3 = new HttpHost("somehost", -1); - Assertions.assertEquals("http://somehost", host3.toString()); + Assertions.assertThat(host3.toString()).isEqualTo("http://somehost"); final HttpHost host4 = new HttpHost("somehost", 8888); - Assertions.assertEquals("http://somehost:8888", host4.toString()); + Assertions.assertThat(host4.toString()).isEqualTo("http://somehost:8888"); final HttpHost host5 = new HttpHost("myhttp", "somehost", -1); - Assertions.assertEquals("myhttp://somehost", host5.toString()); + Assertions.assertThat(host5.toString()).isEqualTo("myhttp://somehost"); final HttpHost host6 = new HttpHost("myhttp", "somehost", 80); - Assertions.assertEquals("myhttp://somehost:80", host6.toString()); + Assertions.assertThat(host6.toString()).isEqualTo("myhttp://somehost:80"); final HttpHost host7 = new HttpHost( "http", InetAddress.getByAddress("127.0.0.1", new byte[] {127,0,0,1}), 80); - Assertions.assertEquals("http://127.0.0.1:80", host7.toString()); + Assertions.assertThat(host7.toString()).isEqualTo("http://127.0.0.1:80"); final HttpHost host9 = new HttpHost( "http", InetAddress.getByAddress("somehost", new byte[] {127,0,0,1}), 80); - Assertions.assertEquals("http://somehost:80", host9.toString()); + Assertions.assertThat(host9.toString()).isEqualTo("http://somehost:80"); } @Test void testToHostString() { final HttpHost host1 = new HttpHost("somehost"); - Assertions.assertEquals("somehost", host1.toHostString()); + Assertions.assertThat(host1.toHostString()).isEqualTo("somehost"); final HttpHost host2 = new HttpHost("somehost"); - Assertions.assertEquals("somehost", host2.toHostString()); + Assertions.assertThat(host2.toHostString()).isEqualTo("somehost"); final HttpHost host3 = new HttpHost("somehost", -1); - Assertions.assertEquals("somehost", host3.toHostString()); + Assertions.assertThat(host3.toHostString()).isEqualTo("somehost"); final HttpHost host4 = new HttpHost("somehost", 8888); - Assertions.assertEquals("somehost:8888", host4.toHostString()); + Assertions.assertThat(host4.toHostString()).isEqualTo("somehost:8888"); } @Test @@ -181,60 +187,70 @@ void testSerialization() throws Exception { final ByteArrayInputStream inBuffer = new ByteArrayInputStream(raw); final ObjectInputStream inStream = new ObjectInputStream(inBuffer); final HttpHost clone = (HttpHost) inStream.readObject(); - Assertions.assertEquals(orig, clone); + Assertions.assertThat(clone).isEqualTo(orig); } @Test void testCreateFromString() throws Exception { - Assertions.assertEquals(new HttpHost("https", "somehost", 8080), HttpHost.create("https://somehost:8080")); - Assertions.assertEquals(new HttpHost("https", "somehost", 8080), HttpHost.create("HttpS://SomeHost:8080")); - Assertions.assertEquals(new HttpHost(null, "somehost", 1234), HttpHost.create("somehost:1234")); - Assertions.assertEquals(new HttpHost(null, "somehost", -1), HttpHost.create("somehost")); + Assertions.assertThat(HttpHost.create("https://somehost:8080")).isEqualTo(new HttpHost("https", "somehost", 8080)); + Assertions.assertThat(HttpHost.create("HttpS://SomeHost:8080")).isEqualTo(new HttpHost("https", "somehost", 8080)); + Assertions.assertThat(HttpHost.create("somehost:1234")).isEqualTo(new HttpHost(null, "somehost", 1234)); + Assertions.assertThat(HttpHost.create("somehost")).isEqualTo(new HttpHost(null, "somehost", -1)); } @Test void testCreateFromURI() { - Assertions.assertEquals(new HttpHost("https", "somehost", 8080), HttpHost.create(URI.create("https://somehost:8080"))); - Assertions.assertEquals(new HttpHost("https", "somehost", 8080), HttpHost.create(URI.create("HttpS://SomeHost:8080"))); - Assertions.assertEquals(new HttpHost("https", "somehost", 8080), HttpHost.create(URI.create("HttpS://SomeHost:8080/foo"))); + Assertions.assertThat(HttpHost.create(URI.create("https://somehost:8080"))).isEqualTo(new HttpHost("https", "somehost", 8080)); + Assertions.assertThat(HttpHost.create(URI.create("HttpS://SomeHost:8080"))).isEqualTo(new HttpHost("https", "somehost", 8080)); + Assertions.assertThat(HttpHost.create(URI.create("HttpS://SomeHost:8080/foo"))).isEqualTo(new HttpHost("https", "somehost", 8080)); } @Test void testCreateFromStringInvalid() { - Assertions.assertThrows(URISyntaxException.class, () -> HttpHost.create(" host ")); - Assertions.assertThrows(URISyntaxException.class, () -> HttpHost.create("host :8080")); - Assertions.assertThrows(IllegalArgumentException.class, () -> HttpHost.create("")); + Assertions.assertThatThrownBy(() -> + HttpHost.create(" host ")) + .isInstanceOf(URISyntaxException.class); + Assertions.assertThatThrownBy(() -> + HttpHost.create("host :8080")) + .isInstanceOf(URISyntaxException.class); + Assertions.assertThatThrownBy(() -> + HttpHost.create("")) + .isInstanceOf(IllegalArgumentException.class); } @Test void testIpv6HostAndPort() throws Exception { final HttpHost host = HttpHost.create("[::1]:80"); - Assertions.assertEquals("http", host.getSchemeName()); - Assertions.assertEquals("::1", host.getHostName()); - Assertions.assertEquals(80, host.getPort()); + Assertions.assertThat(host.getSchemeName()).isEqualTo("http"); + Assertions.assertThat(host.getHostName()).isEqualTo("::1"); + Assertions.assertThat(host.getPort()).isEqualTo(80); } @Test void testIpv6HostAndPortWithScheme() throws Exception { final HttpHost host = HttpHost.create("https://[::1]:80"); - Assertions.assertEquals("https", host.getSchemeName()); - Assertions.assertEquals("::1", host.getHostName()); - Assertions.assertEquals(80, host.getPort()); + Assertions.assertThat(host.getSchemeName()).isEqualTo("https"); + Assertions.assertThat(host.getHostName()).isEqualTo("::1"); + Assertions.assertThat(host.getPort()).isEqualTo(80); } @Test void testIpv6HostAndPortWithoutBrackets() { - Assertions.assertThrows(URISyntaxException.class, () -> HttpHost.create("::1:80")); + Assertions.assertThatThrownBy(() -> + HttpHost.create("::1:80")) + .isInstanceOf(URISyntaxException.class); } @Test void testIpv6HostWithoutPort() { - Assertions.assertThrows(URISyntaxException.class, () -> HttpHost.create("::1")); + Assertions.assertThatThrownBy(() -> + HttpHost.create("::1")) + .isInstanceOf(URISyntaxException.class); } @Test void testIpv6HostToString() { - Assertions.assertEquals("http://[::1]:80", new HttpHost("::1", 80).toString()); - Assertions.assertEquals("http://[::1]", new HttpHost("::1", -1).toString()); + Assertions.assertThat(new HttpHost("::1", 80).toString()).isEqualTo("http://[::1]:80"); + Assertions.assertThat(new HttpHost("::1", -1).toString()).isEqualTo("http://[::1]"); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/TestHttpVersion.java b/httpcore5/src/test/java/org/apache/hc/core5/http/TestHttpVersion.java index c3e078fbe3..6c770e60cc 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/TestHttpVersion.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/TestHttpVersion.java @@ -32,7 +32,7 @@ import java.io.ObjectInputStream; import java.io.ObjectOutputStream; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; /** @@ -42,37 +42,41 @@ class TestHttpVersion { @Test void testEqualsMajorMinor() { - Assertions.assertTrue(HttpVersion.HTTP_0_9.equals(0, 9)); - Assertions.assertTrue(HttpVersion.HTTP_1_0.equals(1, 0)); - Assertions.assertTrue(HttpVersion.HTTP_1_1.equals(1, 1)); - Assertions.assertTrue(HttpVersion.HTTP_2.equals(2, 0)); - Assertions.assertTrue(HttpVersion.HTTP_2_0.equals(2, 0)); + Assertions.assertThat(HttpVersion.HTTP_0_9.equals(0, 9)).isTrue(); + Assertions.assertThat(HttpVersion.HTTP_1_0.equals(1, 0)).isTrue(); + Assertions.assertThat(HttpVersion.HTTP_1_1.equals(1, 1)).isTrue(); + Assertions.assertThat(HttpVersion.HTTP_2.equals(2, 0)).isTrue(); + Assertions.assertThat(HttpVersion.HTTP_2_0.equals(2, 0)).isTrue(); // - Assertions.assertFalse(HttpVersion.HTTP_0_9.equals(2, 0)); + Assertions.assertThat(HttpVersion.HTTP_0_9.equals(2, 0)).isFalse(); } @Test void testGet() { - Assertions.assertEquals(HttpVersion.HTTP_0_9, HttpVersion.get(0, 9)); - Assertions.assertEquals(HttpVersion.HTTP_1_0, HttpVersion.get(1, 0)); - Assertions.assertEquals(HttpVersion.HTTP_1_1, HttpVersion.get(1, 1)); - Assertions.assertEquals(HttpVersion.HTTP_2_0, HttpVersion.get(2, 0)); - Assertions.assertEquals(HttpVersion.HTTP_2, HttpVersion.get(2, 0)); - Assertions.assertNotEquals(HttpVersion.HTTP_2_0, HttpVersion.get(2, 1)); + Assertions.assertThat(HttpVersion.get(0, 9)).isEqualTo(HttpVersion.HTTP_0_9); + Assertions.assertThat(HttpVersion.get(1, 0)).isEqualTo(HttpVersion.HTTP_1_0); + Assertions.assertThat(HttpVersion.get(1, 1)).isEqualTo(HttpVersion.HTTP_1_1); + Assertions.assertThat(HttpVersion.get(2, 0)).isEqualTo(HttpVersion.HTTP_2_0); + Assertions.assertThat(HttpVersion.get(2, 0)).isEqualTo(HttpVersion.HTTP_2); + Assertions.assertThat(HttpVersion.get(2, 1)).isNotEqualTo(HttpVersion.HTTP_2_0); // - Assertions.assertSame(HttpVersion.HTTP_1_0, HttpVersion.get(1, 0)); - Assertions.assertSame(HttpVersion.HTTP_1_1, HttpVersion.get(1, 1)); - Assertions.assertSame(HttpVersion.HTTP_2_0, HttpVersion.get(2, 0)); - Assertions.assertSame(HttpVersion.HTTP_2, HttpVersion.get(2, 0)); - Assertions.assertNotSame(HttpVersion.HTTP_2_0, HttpVersion.get(2, 1)); - Assertions.assertNotSame(HttpVersion.HTTP_0_9, HttpVersion.get(0, 9)); + Assertions.assertThat(HttpVersion.get(1, 0)).isSameAs(HttpVersion.HTTP_1_0); + Assertions.assertThat(HttpVersion.get(1, 1)).isSameAs(HttpVersion.HTTP_1_1); + Assertions.assertThat(HttpVersion.get(2, 0)).isSameAs(HttpVersion.HTTP_2_0); + Assertions.assertThat(HttpVersion.get(2, 0)).isSameAs(HttpVersion.HTTP_2); + Assertions.assertThat(HttpVersion.get(2, 1)).isNotSameAs(HttpVersion.HTTP_2_0); + Assertions.assertThat(HttpVersion.get(0, 9)).isNotSameAs(HttpVersion.HTTP_0_9); } @SuppressWarnings("unused") @Test void testHttpVersionInvalidConstructorInput() { - Assertions.assertThrows(IllegalArgumentException.class, () -> new HttpVersion(-1, -1)); - Assertions.assertThrows(IllegalArgumentException.class, () -> new HttpVersion(0, -1)); + Assertions.assertThatThrownBy(() -> + new HttpVersion(-1, -1)) + .isInstanceOf(IllegalArgumentException.class); + Assertions.assertThatThrownBy(() -> + new HttpVersion(0, -1)) + .isInstanceOf(IllegalArgumentException.class); } @Test @@ -80,39 +84,39 @@ void testHttpVersionEquality() { final HttpVersion ver1 = new HttpVersion(1, 1); final HttpVersion ver2 = new HttpVersion(1, 1); - Assertions.assertEquals(ver1.hashCode(), ver2.hashCode()); - Assertions.assertEquals(ver1, ver1); - Assertions.assertEquals(ver1, ver2); - Assertions.assertEquals(ver1, ver1); - Assertions.assertEquals(ver1, ver2); + Assertions.assertThat(ver2.hashCode()).isEqualTo(ver1.hashCode()); + Assertions.assertThat(ver1).isEqualTo(ver1); + Assertions.assertThat(ver2).isEqualTo(ver1); + Assertions.assertThat(ver1).isEqualTo(ver1); + Assertions.assertThat(ver2).isEqualTo(ver1); - Assertions.assertNotEquals(ver1, Float.valueOf(1.1f)); + Assertions.assertThat(Float.valueOf(1.1f)).isNotEqualTo(ver1); - Assertions.assertEquals(HttpVersion.HTTP_0_9, new HttpVersion(0, 9)); - Assertions.assertEquals(HttpVersion.HTTP_1_0, new HttpVersion(1, 0)); - Assertions.assertEquals(HttpVersion.HTTP_1_1, new HttpVersion(1, 1)); - Assertions.assertNotEquals(HttpVersion.HTTP_1_0, new HttpVersion(1, 1)); + Assertions.assertThat(new HttpVersion(0, 9)).isEqualTo(HttpVersion.HTTP_0_9); + Assertions.assertThat(new HttpVersion(1, 0)).isEqualTo(HttpVersion.HTTP_1_0); + Assertions.assertThat(new HttpVersion(1, 1)).isEqualTo(HttpVersion.HTTP_1_1); + Assertions.assertThat(new HttpVersion(1, 1)).isNotEqualTo(HttpVersion.HTTP_1_0); - Assertions.assertEquals(HttpVersion.HTTP_0_9, new ProtocolVersion("HTTP", 0, 9)); - Assertions.assertEquals(HttpVersion.HTTP_1_0, new ProtocolVersion("HTTP", 1, 0)); - Assertions.assertEquals(HttpVersion.HTTP_1_1, new ProtocolVersion("HTTP", 1, 1)); - Assertions.assertNotEquals(HttpVersion.HTTP_1_1, new ProtocolVersion("http", 1, 1)); + Assertions.assertThat(new ProtocolVersion("HTTP", 0, 9)).isEqualTo(HttpVersion.HTTP_0_9); + Assertions.assertThat(new ProtocolVersion("HTTP", 1, 0)).isEqualTo(HttpVersion.HTTP_1_0); + Assertions.assertThat(new ProtocolVersion("HTTP", 1, 1)).isEqualTo(HttpVersion.HTTP_1_1); + Assertions.assertThat(new ProtocolVersion("http", 1, 1)).isNotEqualTo(HttpVersion.HTTP_1_1); - Assertions.assertEquals(HttpVersion.HTTP_0_9, new ProtocolVersion("HTTP", 0, 9)); - Assertions.assertEquals(HttpVersion.HTTP_1_0, new ProtocolVersion("HTTP", 1, 0)); - Assertions.assertEquals(HttpVersion.HTTP_1_1, new ProtocolVersion("HTTP", 1, 1)); - Assertions.assertNotEquals(HttpVersion.HTTP_1_1, new ProtocolVersion("http", 1, 1)); + Assertions.assertThat(new ProtocolVersion("HTTP", 0, 9)).isEqualTo(HttpVersion.HTTP_0_9); + Assertions.assertThat(new ProtocolVersion("HTTP", 1, 0)).isEqualTo(HttpVersion.HTTP_1_0); + Assertions.assertThat(new ProtocolVersion("HTTP", 1, 1)).isEqualTo(HttpVersion.HTTP_1_1); + Assertions.assertThat(new ProtocolVersion("http", 1, 1)).isNotEqualTo(HttpVersion.HTTP_1_1); } @Test void testHttpVersionComparison() { - Assertions.assertTrue(HttpVersion.HTTP_0_9.lessEquals(HttpVersion.HTTP_1_1)); - Assertions.assertTrue(HttpVersion.HTTP_0_9.greaterEquals(HttpVersion.HTTP_0_9)); - Assertions.assertFalse(HttpVersion.HTTP_0_9.greaterEquals(HttpVersion.HTTP_1_0)); + Assertions.assertThat(HttpVersion.HTTP_0_9.lessEquals(HttpVersion.HTTP_1_1)).isTrue(); + Assertions.assertThat(HttpVersion.HTTP_0_9.greaterEquals(HttpVersion.HTTP_0_9)).isTrue(); + Assertions.assertThat(HttpVersion.HTTP_0_9.greaterEquals(HttpVersion.HTTP_1_0)).isFalse(); - Assertions.assertTrue(HttpVersion.HTTP_1_0.compareToVersion(HttpVersion.HTTP_1_1) < 0); - Assertions.assertTrue(HttpVersion.HTTP_1_0.compareToVersion(HttpVersion.HTTP_0_9) > 0); - Assertions.assertEquals(0, HttpVersion.HTTP_1_0.compareToVersion(HttpVersion.HTTP_1_0)); + Assertions.assertThat(HttpVersion.HTTP_1_0.compareToVersion(HttpVersion.HTTP_1_1) < 0).isTrue(); + Assertions.assertThat(HttpVersion.HTTP_1_0.compareToVersion(HttpVersion.HTTP_0_9) > 0).isTrue(); + Assertions.assertThat(HttpVersion.HTTP_1_0.compareToVersion(HttpVersion.HTTP_1_0)).isEqualTo(0); } @Test @@ -126,7 +130,7 @@ void testSerialization() throws Exception { final ByteArrayInputStream inBuffer = new ByteArrayInputStream(raw); final ObjectInputStream inStream = new ObjectInputStream(inBuffer); final HttpVersion clone = (HttpVersion) inStream.readObject(); - Assertions.assertEquals(orig, clone); + Assertions.assertThat(clone).isEqualTo(orig); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/TestProtocolVersion.java b/httpcore5/src/test/java/org/apache/hc/core5/http/TestProtocolVersion.java index 379f2708a8..5a9ad08022 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/TestProtocolVersion.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/TestProtocolVersion.java @@ -29,7 +29,7 @@ import org.apache.hc.core5.util.Tokenizer; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class TestProtocolVersion { @@ -40,38 +40,50 @@ class TestProtocolVersion { @Test void testEqualsMajorMinor() { - Assertions.assertTrue(PROTOCOL_VERSION_0_0.equals(0, 0)); - Assertions.assertTrue(PROTOCOL_VERSION_1_0.equals(1, 0)); - Assertions.assertTrue(PROTOCOL_VERSION_1_2.equals(1, 2)); + Assertions.assertThat(PROTOCOL_VERSION_0_0.equals(0, 0)).isTrue(); + Assertions.assertThat(PROTOCOL_VERSION_1_0.equals(1, 0)).isTrue(); + Assertions.assertThat(PROTOCOL_VERSION_1_2.equals(1, 2)).isTrue(); // - Assertions.assertFalse(PROTOCOL_VERSION_1_2.equals(2, 0)); + Assertions.assertThat(PROTOCOL_VERSION_1_2.equals(2, 0)).isFalse(); } @Test void testParseBasic() throws Exception { - Assertions.assertEquals(new ProtocolVersion("PROTO", 1, 0), ProtocolVersion.parse("PROTO/1")); - Assertions.assertEquals(new ProtocolVersion("PROTO", 1, 1), ProtocolVersion.parse("PROTO/1.1")); - Assertions.assertEquals(new ProtocolVersion("PROTO", 1, 2), ProtocolVersion.parse("PROTO/1.2")); - Assertions.assertEquals(new ProtocolVersion("PROTO", 1, 3), ProtocolVersion.parse("PROTO/1.3 ")); - Assertions.assertEquals(new ProtocolVersion("PROTO", 0, 0), ProtocolVersion.parse("PROTO/000.0000 ")); - Assertions.assertEquals(new ProtocolVersion("PROTO", 22, 356), ProtocolVersion.parse("PROTO/22.356")); + Assertions.assertThat(ProtocolVersion.parse("PROTO/1")).isEqualTo(new ProtocolVersion("PROTO", 1, 0)); + Assertions.assertThat(ProtocolVersion.parse("PROTO/1.1")).isEqualTo(new ProtocolVersion("PROTO", 1, 1)); + Assertions.assertThat(ProtocolVersion.parse("PROTO/1.2")).isEqualTo(new ProtocolVersion("PROTO", 1, 2)); + Assertions.assertThat(ProtocolVersion.parse("PROTO/1.3 ")).isEqualTo(new ProtocolVersion("PROTO", 1, 3)); + Assertions.assertThat(ProtocolVersion.parse("PROTO/000.0000 ")).isEqualTo(new ProtocolVersion("PROTO", 0, 0)); + Assertions.assertThat(ProtocolVersion.parse("PROTO/22.356")).isEqualTo(new ProtocolVersion("PROTO", 22, 356)); } @Test void testParseBuffer() throws Exception { final Tokenizer.Cursor cursor = new Tokenizer.Cursor(1, 13); - Assertions.assertEquals(new ProtocolVersion("PROTO", 1, 2), ProtocolVersion.parse(" PROTO/1.2,0000", cursor, Tokenizer.delimiters(','))); - Assertions.assertEquals(10, cursor.getPos()); + Assertions.assertThat(ProtocolVersion.parse(" PROTO/1.2,0000", cursor, Tokenizer.delimiters(','))).isEqualTo(new ProtocolVersion("PROTO", 1, 2)); + Assertions.assertThat(cursor.getPos()).isEqualTo(10); } @Test void testParseFailure() { - Assertions.assertThrows(ParseException.class, () -> ProtocolVersion.parse("/1")); - Assertions.assertThrows(ParseException.class, () -> ProtocolVersion.parse(" /1")); - Assertions.assertThrows(ParseException.class, () -> ProtocolVersion.parse("PROTO/")); - Assertions.assertThrows(ParseException.class, () -> ProtocolVersion.parse("PROTO/1A")); - Assertions.assertThrows(ParseException.class, () -> ProtocolVersion.parse("PROTO/1.A")); - Assertions.assertThrows(ParseException.class, () -> ProtocolVersion.parse("PROTO/1.1 huh?")); + Assertions.assertThatThrownBy(() -> + ProtocolVersion.parse("/1")) + .isInstanceOf(ParseException.class); + Assertions.assertThatThrownBy(() -> + ProtocolVersion.parse(" /1")) + .isInstanceOf(ParseException.class); + Assertions.assertThatThrownBy(() -> + ProtocolVersion.parse("PROTO/")) + .isInstanceOf(ParseException.class); + Assertions.assertThatThrownBy(() -> + ProtocolVersion.parse("PROTO/1A")) + .isInstanceOf(ParseException.class); + Assertions.assertThatThrownBy(() -> + ProtocolVersion.parse("PROTO/1.A")) + .isInstanceOf(ParseException.class); + Assertions.assertThatThrownBy(() -> + ProtocolVersion.parse("PROTO/1.1 huh?")) + .isInstanceOf(ParseException.class); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/TestProtocolVersionParser.java b/httpcore5/src/test/java/org/apache/hc/core5/http/TestProtocolVersionParser.java index 9771f4c74e..f017a06ec3 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/TestProtocolVersionParser.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/TestProtocolVersionParser.java @@ -30,7 +30,7 @@ import org.apache.hc.core5.http.message.ParserCursor; import org.apache.hc.core5.util.Tokenizer; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -68,48 +68,70 @@ public ProtocolVersion parseStr(final String s, final Tokenizer.Delimiter delimi @Test void testParseVersion() throws Exception { - Assertions.assertEquals(new ProtocolVersion("PROTO", 1, 0), parseStr("PROTO", "1 ")); - Assertions.assertEquals(new ProtocolVersion("PROTO", 1, 1), parseStr("PROTO", "1.1 ")); - Assertions.assertEquals(new ProtocolVersion("PROTO", 1, 20), parseStr("PROTO", "1.020 ")); - Assertions.assertEquals(new ProtocolVersion("PROTO", 22, 356), parseStr("PROTO", "22.356 ")); - - Assertions.assertEquals(new ProtocolVersion("PROTO", 1, 0), parseStr("PROTO", "1, ", Tokenizer.delimiters(','))); - Assertions.assertEquals(new ProtocolVersion("PROTO", 1, 1), parseStr("PROTO", "1.1; ", Tokenizer.delimiters(',', ';'))); - Assertions.assertEquals(new ProtocolVersion("PROTO", 1, 200), parseStr("PROTO", "1.200 blah; ", Tokenizer.delimiters(','))); + Assertions.assertThat(parseStr("PROTO", "1 ")).isEqualTo(new ProtocolVersion("PROTO", 1, 0)); + Assertions.assertThat(parseStr("PROTO", "1.1 ")).isEqualTo(new ProtocolVersion("PROTO", 1, 1)); + Assertions.assertThat(parseStr("PROTO", "1.020 ")).isEqualTo(new ProtocolVersion("PROTO", 1, 20)); + Assertions.assertThat(parseStr("PROTO", "22.356 ")).isEqualTo(new ProtocolVersion("PROTO", 22, 356)); + + Assertions.assertThat(parseStr("PROTO", "1, ", Tokenizer.delimiters(','))).isEqualTo(new ProtocolVersion("PROTO", 1, 0)); + Assertions.assertThat(parseStr("PROTO", "1.1; ", Tokenizer.delimiters(',', ';'))).isEqualTo(new ProtocolVersion("PROTO", 1, 1)); + Assertions.assertThat(parseStr("PROTO", "1.200 blah; ", Tokenizer.delimiters(','))).isEqualTo(new ProtocolVersion("PROTO", 1, 200)); } @Test void testParseVersionWithCursor() throws Exception { final Tokenizer.Cursor cursor = new Tokenizer.Cursor(2, 13); - Assertions.assertEquals(new ProtocolVersion("PROTO", 1, 20), parseStr("PROTO", " 1.20,0000,00000", cursor, Tokenizer.delimiters(','))); - Assertions.assertEquals(6, cursor.getPos()); + Assertions.assertThat(parseStr("PROTO", " 1.20,0000,00000", cursor, Tokenizer.delimiters(','))).isEqualTo(new ProtocolVersion("PROTO", 1, 20)); + Assertions.assertThat(cursor.getPos()).isEqualTo(6); } @Test void testParseProtocolVersion() throws Exception { - Assertions.assertEquals(new ProtocolVersion("PROTO", 1, 0), parseStr("PROTO/1 ")); - Assertions.assertEquals(new ProtocolVersion("PROTO", 1, 1), parseStr("PROTO/1.1 ")); - Assertions.assertEquals(new ProtocolVersion("PROTO", 1, 20), parseStr("PROTO/1.020 ")); - Assertions.assertEquals(new ProtocolVersion("PROTO", 22, 356), parseStr("PROTO/22.356 ")); - - Assertions.assertEquals(new ProtocolVersion("PROTO", 1, 0), parseStr("PROTO/1, ", Tokenizer.delimiters(','))); - Assertions.assertEquals(new ProtocolVersion("PROTO", 1, 1), parseStr("PROTO/1.1; ", Tokenizer.delimiters(',', ';'))); - Assertions.assertEquals(new ProtocolVersion("PROTO", 1, 200), parseStr("PROTO/1.200 blah; ", Tokenizer.delimiters(','))); + Assertions.assertThat(parseStr("PROTO/1 ")).isEqualTo(new ProtocolVersion("PROTO", 1, 0)); + Assertions.assertThat(parseStr("PROTO/1.1 ")).isEqualTo(new ProtocolVersion("PROTO", 1, 1)); + Assertions.assertThat(parseStr("PROTO/1.020 ")).isEqualTo(new ProtocolVersion("PROTO", 1, 20)); + Assertions.assertThat(parseStr("PROTO/22.356 ")).isEqualTo(new ProtocolVersion("PROTO", 22, 356)); + + Assertions.assertThat(parseStr("PROTO/1, ", Tokenizer.delimiters(','))).isEqualTo(new ProtocolVersion("PROTO", 1, 0)); + Assertions.assertThat(parseStr("PROTO/1.1; ", Tokenizer.delimiters(',', ';'))).isEqualTo(new ProtocolVersion("PROTO", 1, 1)); + Assertions.assertThat(parseStr("PROTO/1.200 blah; ", Tokenizer.delimiters(','))).isEqualTo(new ProtocolVersion("PROTO", 1, 200)); } @Test void testParseFailures() { - Assertions.assertThrows(ParseException.class, () -> parseStr("PROTO", "blah")); - Assertions.assertThrows(ParseException.class, () -> parseStr("PROTO", "1.blah")); - Assertions.assertThrows(ParseException.class, () -> parseStr("PROTO", "1A.0")); - Assertions.assertThrows(ParseException.class, () -> parseStr("PROTO", "")); - Assertions.assertThrows(ParseException.class, () -> parseStr("")); - Assertions.assertThrows(ParseException.class, () -> parseStr(" ")); - Assertions.assertThrows(ParseException.class, () -> parseStr(" /1.0")); - Assertions.assertThrows(ParseException.class, () -> parseStr(" / ")); - Assertions.assertThrows(ParseException.class, () -> parseStr("PROTO")); - Assertions.assertThrows(ParseException.class, () -> parseStr("PROTO/")); - Assertions.assertThrows(ParseException.class, () -> parseStr("PROTO/ 1.0")); + Assertions.assertThatThrownBy(() -> + parseStr("PROTO", "blah")) + .isInstanceOf(ParseException.class); + Assertions.assertThatThrownBy(() -> + parseStr("PROTO", "1.blah")) + .isInstanceOf(ParseException.class); + Assertions.assertThatThrownBy(() -> + parseStr("PROTO", "1A.0")) + .isInstanceOf(ParseException.class); + Assertions.assertThatThrownBy(() -> + parseStr("PROTO", "")) + .isInstanceOf(ParseException.class); + Assertions.assertThatThrownBy(() -> + parseStr("")) + .isInstanceOf(ParseException.class); + Assertions.assertThatThrownBy(() -> + parseStr(" ")) + .isInstanceOf(ParseException.class); + Assertions.assertThatThrownBy(() -> + parseStr(" /1.0")) + .isInstanceOf(ParseException.class); + Assertions.assertThatThrownBy(() -> + parseStr(" / ")) + .isInstanceOf(ParseException.class); + Assertions.assertThatThrownBy(() -> + parseStr("PROTO")) + .isInstanceOf(ParseException.class); + Assertions.assertThatThrownBy(() -> + parseStr("PROTO/")) + .isInstanceOf(ParseException.class); + Assertions.assertThatThrownBy(() -> + parseStr("PROTO/ 1.0")) + .isInstanceOf(ParseException.class); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/config/TestNamedElementChain.java b/httpcore5/src/test/java/org/apache/hc/core5/http/config/TestNamedElementChain.java index 0f1e02a409..4b7bc1e697 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/config/TestNamedElementChain.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/config/TestNamedElementChain.java @@ -28,7 +28,7 @@ package org.apache.hc.core5.http.config; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; /** @@ -39,67 +39,67 @@ class TestNamedElementChain { @Test void testBasics() { final NamedElementChain list = new NamedElementChain<>(); - Assertions.assertNull(list.getFirst()); - Assertions.assertNull(list.getLast()); + Assertions.assertThat(list.getFirst()).isNull(); + Assertions.assertThat(list.getLast()).isNull(); final NamedElementChain.Node nodeA = list.addFirst('a', "a"); - Assertions.assertSame(nodeA, list.getFirst()); - Assertions.assertSame(nodeA, list.getLast()); + Assertions.assertThat(list.getFirst()).isSameAs(nodeA); + Assertions.assertThat(list.getLast()).isSameAs(nodeA); final NamedElementChain.Node nodeB = list.addLast('b', "b"); - Assertions.assertSame(nodeA, list.getFirst()); - Assertions.assertSame(nodeB, list.getLast()); + Assertions.assertThat(list.getFirst()).isSameAs(nodeA); + Assertions.assertThat(list.getLast()).isSameAs(nodeB); final NamedElementChain.Node nodeZ = list.addLast('z', "z"); - Assertions.assertSame(nodeA, list.getFirst()); - Assertions.assertSame(nodeZ, list.getLast()); + Assertions.assertThat(list.getFirst()).isSameAs(nodeA); + Assertions.assertThat(list.getLast()).isSameAs(nodeZ); - Assertions.assertNull(nodeA.getPrevious()); - Assertions.assertSame(nodeB, nodeA.getNext()); - Assertions.assertSame(nodeA, nodeB.getPrevious()); - Assertions.assertSame(nodeZ, nodeB.getNext()); - Assertions.assertSame(nodeB, nodeZ.getPrevious()); - Assertions.assertNull(nodeZ.getNext()); + Assertions.assertThat(nodeA.getPrevious()).isNull(); + Assertions.assertThat(nodeA.getNext()).isSameAs(nodeB); + Assertions.assertThat(nodeB.getPrevious()).isSameAs(nodeA); + Assertions.assertThat(nodeB.getNext()).isSameAs(nodeZ); + Assertions.assertThat(nodeZ.getPrevious()).isSameAs(nodeB); + Assertions.assertThat(nodeZ.getNext()).isNull(); final NamedElementChain.Node nodeD = list.addAfter("b", 'd', "d"); - Assertions.assertSame(nodeB, nodeD.getPrevious()); - Assertions.assertSame(nodeZ, nodeD.getNext()); - Assertions.assertSame(nodeD, nodeB.getNext()); - Assertions.assertSame(nodeD, nodeZ.getPrevious()); + Assertions.assertThat(nodeD.getPrevious()).isSameAs(nodeB); + Assertions.assertThat(nodeD.getNext()).isSameAs(nodeZ); + Assertions.assertThat(nodeB.getNext()).isSameAs(nodeD); + Assertions.assertThat(nodeZ.getPrevious()).isSameAs(nodeD); final NamedElementChain.Node nodeC = list.addBefore("d", 'c', "c"); - Assertions.assertSame(nodeB, nodeC.getPrevious()); - Assertions.assertSame(nodeD, nodeC.getNext()); - Assertions.assertSame(nodeC, nodeB.getNext()); - Assertions.assertSame(nodeC, nodeD.getPrevious()); - Assertions.assertEquals(5, list.getSize()); - - Assertions.assertTrue(list.remove("a")); - Assertions.assertTrue(list.remove("z")); - Assertions.assertTrue(list.remove("c")); - Assertions.assertFalse(list.remove("c")); - Assertions.assertFalse(list.remove("blah")); - - Assertions.assertSame(nodeB, list.getFirst()); - Assertions.assertSame(nodeD, list.getLast()); - - Assertions.assertEquals(2, list.getSize()); - Assertions.assertNull(list.addBefore("blah", 'e', "e")); - Assertions.assertEquals(2, list.getSize()); - - Assertions.assertNull(list.addAfter("yada", 'e', "e")); - Assertions.assertEquals(2, list.getSize()); + Assertions.assertThat(nodeC.getPrevious()).isSameAs(nodeB); + Assertions.assertThat(nodeC.getNext()).isSameAs(nodeD); + Assertions.assertThat(nodeB.getNext()).isSameAs(nodeC); + Assertions.assertThat(nodeD.getPrevious()).isSameAs(nodeC); + Assertions.assertThat(list.getSize()).isEqualTo(5); + + Assertions.assertThat(list.remove("a")).isTrue(); + Assertions.assertThat(list.remove("z")).isTrue(); + Assertions.assertThat(list.remove("c")).isTrue(); + Assertions.assertThat(list.remove("c")).isFalse(); + Assertions.assertThat(list.remove("blah")).isFalse(); + + Assertions.assertThat(list.getFirst()).isSameAs(nodeB); + Assertions.assertThat(list.getLast()).isSameAs(nodeD); + + Assertions.assertThat(list.getSize()).isEqualTo(2); + Assertions.assertThat(list.addBefore("blah", 'e', "e")).isNull(); + Assertions.assertThat(list.getSize()).isEqualTo(2); + + Assertions.assertThat(list.addAfter("yada", 'e', "e")).isNull(); + Assertions.assertThat(list.getSize()).isEqualTo(2); } @Test void testFind() { final NamedElementChain list = new NamedElementChain<>(); list.addLast('c', "c"); - Assertions.assertNotNull(list.find("c")); - Assertions.assertNull(list.find("a")); + Assertions.assertThat(list.find("c")).isNotNull(); + Assertions.assertThat(list.find("a")).isNull(); } @Test @@ -107,11 +107,11 @@ void testReplace() { final NamedElementChain list = new NamedElementChain<>(); list.addLast('c', "c"); final boolean found = list.replace("c",'z' ); - Assertions.assertTrue(found); - Assertions.assertEquals('z', list.find("c").getValue()); - Assertions.assertEquals("c", list.find("c").getName()); + Assertions.assertThat(found).isTrue(); + Assertions.assertThat(list.find("c").getValue()).isEqualTo('z'); + Assertions.assertThat(list.find("c").getName()).isEqualTo("c"); final boolean notFound = list.replace("X",'z' ); - Assertions.assertFalse(notFound); + Assertions.assertThat(notFound).isFalse(); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/config/TestRegistry.java b/httpcore5/src/test/java/org/apache/hc/core5/http/config/TestRegistry.java index b0492f4af6..9aa17e5267 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/config/TestRegistry.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/config/TestRegistry.java @@ -26,7 +26,7 @@ */ package org.apache.hc.core5.http.config; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class TestRegistry { @@ -34,10 +34,10 @@ class TestRegistry { @Test void testCompleted() { final Registry reg = RegistryBuilder.create().register("Stuff", "Stuff").build(); - Assertions.assertEquals("Stuff", reg.lookup("Stuff")); - Assertions.assertEquals("Stuff", reg.lookup("stuff")); - Assertions.assertNull(reg.lookup("miss")); - Assertions.assertNull(reg.lookup(null)); + Assertions.assertThat(reg.lookup("Stuff")).isEqualTo("Stuff"); + Assertions.assertThat(reg.lookup("stuff")).isEqualTo("Stuff"); + Assertions.assertThat(reg.lookup("miss")).isNull(); + Assertions.assertThat(reg.lookup(null)).isNull(); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/digest/TestDigestFields.java b/httpcore5/src/test/java/org/apache/hc/core5/http/digest/TestDigestFields.java index bde283ee09..4f017a29b9 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/digest/TestDigestFields.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/digest/TestDigestFields.java @@ -37,7 +37,7 @@ import org.apache.hc.core5.http.structured.StructuredFieldBareItem; import org.apache.hc.core5.http.structured.StructuredFieldDictionary; import org.apache.hc.core5.http.structured.StructuredFieldItem; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class TestDigestFields { @@ -50,10 +50,9 @@ void testParseContentDigestRfcExample() throws Exception { final StructuredFieldDictionary dictionary = DigestFields.parseDigest(header); final StructuredFieldItem item = (StructuredFieldItem) dictionary.get("sha-256"); - Assertions.assertNotNull(item); - Assertions.assertArrayEquals( - Base64.getDecoder().decode(encoded), - item.getBareItem().getByteSequenceValue()); + Assertions.assertThat(item).isNotNull(); + Assertions.assertThat(item.getBareItem().getByteSequenceValue()) + .containsExactly(Base64.getDecoder().decode(encoded)); } @Test @@ -64,13 +63,11 @@ void testParseMultipleDigestAlgorithms() throws Exception { final StructuredFieldDictionary dictionary = DigestFields.parseDigest(header); - Assertions.assertEquals(2, dictionary.size()); - Assertions.assertArrayEquals( - new byte[]{1, 2, 3}, - ((StructuredFieldItem) dictionary.get("sha-256")).getBareItem().getByteSequenceValue()); - Assertions.assertArrayEquals( - new byte[]{4, 5, 6}, - ((StructuredFieldItem) dictionary.get("sha-512")).getBareItem().getByteSequenceValue()); + Assertions.assertThat(dictionary.size()).isEqualTo(2); + Assertions.assertThat(((StructuredFieldItem) dictionary.get("sha-256")).getBareItem().getByteSequenceValue()) + .containsExactly(new byte[]{1, 2, 3}); + Assertions.assertThat(((StructuredFieldItem) dictionary.get("sha-512")).getBareItem().getByteSequenceValue()) + .containsExactly(new byte[]{4, 5, 6}); } @Test @@ -81,9 +78,9 @@ void testParseDigestAcrossMultipleFieldLines() throws Exception { final StructuredFieldDictionary dictionary = DigestFields.parseDigest(response, HttpHeaders.REPR_DIGEST); - Assertions.assertEquals(2, dictionary.size()); - Assertions.assertNotNull(dictionary.get("sha-256")); - Assertions.assertNotNull(dictionary.get("sha-512")); + Assertions.assertThat(dictionary.size()).isEqualTo(2); + Assertions.assertThat(dictionary.get("sha-256")).isNotNull(); + Assertions.assertThat(dictionary.get("sha-512")).isNotNull(); } @Test @@ -92,21 +89,25 @@ void testParseDigestAcceptsUnknownAlgorithm() throws Exception { final StructuredFieldDictionary dictionary = DigestFields.parseDigest(header); - Assertions.assertNotNull(dictionary.get("example-algorithm")); + Assertions.assertThat(dictionary.get("example-algorithm")).isNotNull(); } @Test void testParseDigestRejectsNonByteSequence() { final Header header = new BasicHeader(HttpHeaders.CONTENT_DIGEST, "sha-256=123"); - Assertions.assertThrows(ParseException.class, () -> DigestFields.parseDigest(header)); + Assertions.assertThatThrownBy(() -> + DigestFields.parseDigest(header)) + .isInstanceOf(ParseException.class); } @Test void testParseDigestRejectsInnerList() { final Header header = new BasicHeader(HttpHeaders.CONTENT_DIGEST, "sha-256=(:AQID:)"); - Assertions.assertThrows(ParseException.class, () -> DigestFields.parseDigest(header)); + Assertions.assertThatThrownBy(() -> + DigestFields.parseDigest(header)) + .isInstanceOf(ParseException.class); } @Test @@ -117,33 +118,36 @@ void testParseWantDigestRfcExample() throws Exception { final StructuredFieldDictionary dictionary = DigestFields.parsePreferences(header); - Assertions.assertEquals(3L, - ((StructuredFieldItem) dictionary.get("sha-512")).getBareItem().getLongValue()); - Assertions.assertEquals(10L, - ((StructuredFieldItem) dictionary.get("sha-256")).getBareItem().getLongValue()); - Assertions.assertEquals(0L, - ((StructuredFieldItem) dictionary.get("unixsum")).getBareItem().getLongValue()); + Assertions.assertThat(((StructuredFieldItem) dictionary.get("sha-512")).getBareItem().getLongValue()).isEqualTo(3L); + Assertions.assertThat(((StructuredFieldItem) dictionary.get("sha-256")).getBareItem().getLongValue()).isEqualTo(10L); + Assertions.assertThat(((StructuredFieldItem) dictionary.get("unixsum")).getBareItem().getLongValue()).isEqualTo(0L); } @Test void testParseWantDigestRejectsBooleanShorthand() { final Header header = new BasicHeader(HttpHeaders.WANT_CONTENT_DIGEST, "sha-256"); - Assertions.assertThrows(ParseException.class, () -> DigestFields.parsePreferences(header)); + Assertions.assertThatThrownBy(() -> + DigestFields.parsePreferences(header)) + .isInstanceOf(ParseException.class); } @Test void testParseWantDigestRejectsNegativePreference() { final Header header = new BasicHeader(HttpHeaders.WANT_CONTENT_DIGEST, "sha-256=-1"); - Assertions.assertThrows(ParseException.class, () -> DigestFields.parsePreferences(header)); + Assertions.assertThatThrownBy(() -> + DigestFields.parsePreferences(header)) + .isInstanceOf(ParseException.class); } @Test void testParseWantDigestRejectsPreferenceGreaterThanTen() { final Header header = new BasicHeader(HttpHeaders.WANT_CONTENT_DIGEST, "sha-256=11"); - Assertions.assertThrows(ParseException.class, () -> DigestFields.parsePreferences(header)); + Assertions.assertThatThrownBy(() -> + DigestFields.parsePreferences(header)) + .isInstanceOf(ParseException.class); } @Test @@ -155,8 +159,8 @@ void testFormatDigest() { final Header header = DigestFields.formatDigest(HttpHeaders.CONTENT_DIGEST, dictionary); - Assertions.assertEquals(HttpHeaders.CONTENT_DIGEST, header.getName()); - Assertions.assertEquals("sha-256=:AQID:, sha-512=:BAUG:", header.getValue()); + Assertions.assertThat(header.getName()).isEqualTo(HttpHeaders.CONTENT_DIGEST); + Assertions.assertThat(header.getValue()).isEqualTo("sha-256=:AQID:, sha-512=:BAUG:"); } @Test @@ -165,9 +169,9 @@ void testFormatDigestRejectsInvalidDictionary() { .put("sha-256", StructuredFieldBareItem.ofInteger(1)) .build(); - Assertions.assertThrows( - IllegalArgumentException.class, - () -> DigestFields.formatDigest(HttpHeaders.CONTENT_DIGEST, dictionary)); + Assertions.assertThatThrownBy(() -> + DigestFields.formatDigest(HttpHeaders.CONTENT_DIGEST, dictionary)) + .isInstanceOf(IllegalArgumentException.class); } @Test @@ -180,8 +184,8 @@ void testFormatPreferences() { final Header header = DigestFields.formatPreferences(HttpHeaders.WANT_REPR_DIGEST, dictionary); - Assertions.assertEquals(HttpHeaders.WANT_REPR_DIGEST, header.getName()); - Assertions.assertEquals("sha-512=3, sha-256=10, unixsum=0", header.getValue()); + Assertions.assertThat(header.getName()).isEqualTo(HttpHeaders.WANT_REPR_DIGEST); + Assertions.assertThat(header.getValue()).isEqualTo("sha-512=3, sha-256=10, unixsum=0"); } @Test @@ -190,9 +194,9 @@ void testFormatPreferencesRejectsInvalidDictionary() { .put("sha-256", StructuredFieldBareItem.ofInteger(11)) .build(); - Assertions.assertThrows( - IllegalArgumentException.class, - () -> DigestFields.formatPreferences(HttpHeaders.WANT_CONTENT_DIGEST, dictionary)); + Assertions.assertThatThrownBy(() -> + DigestFields.formatPreferences(HttpHeaders.WANT_CONTENT_DIGEST, dictionary)) + .isInstanceOf(IllegalArgumentException.class); } @Test @@ -202,7 +206,7 @@ void testParametersArePreserved() throws Exception { final StructuredFieldDictionary dictionary = DigestFields.parseDigest(header); final Header formatted = DigestFields.formatDigest(HttpHeaders.CONTENT_DIGEST, dictionary); - Assertions.assertEquals("sha-256=:AQID:;foo=bar", formatted.getValue()); + Assertions.assertThat(formatted.getValue()).isEqualTo("sha-256=:AQID:;foo=bar"); } @Test @@ -211,6 +215,6 @@ void testMissingFieldProducesEmptyDictionary() throws Exception { final StructuredFieldDictionary dictionary = DigestFields.parseDigest(response, HttpHeaders.CONTENT_DIGEST); - Assertions.assertTrue(dictionary.isEmpty()); + Assertions.assertThat(dictionary.isEmpty()).isTrue(); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/impl/IncomingEntityDetailsTest.java b/httpcore5/src/test/java/org/apache/hc/core5/http/impl/IncomingEntityDetailsTest.java index 87e759c928..c9efe33044 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/impl/IncomingEntityDetailsTest.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/impl/IncomingEntityDetailsTest.java @@ -27,12 +27,6 @@ package org.apache.hc.core5.http.impl; -import static org.junit.jupiter.api.Assertions.assertAll; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.junit.jupiter.api.Assertions.assertNull; -import static org.junit.jupiter.api.Assertions.assertTrue; - import java.util.HashSet; import java.util.Set; import java.util.stream.Collectors; @@ -43,7 +37,8 @@ import org.apache.hc.core5.http.MessageHeaders; import org.apache.hc.core5.http.message.BasicHeader; import org.apache.hc.core5.http.message.HeaderGroup; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; +import org.assertj.core.api.SoftAssertions; import org.junit.jupiter.api.Test; class IncomingEntityDetailsTest { @@ -52,18 +47,19 @@ class IncomingEntityDetailsTest { void getContentLengthEmpty() { final MessageHeaders messageHeaders = new HeaderGroup(); final IncomingEntityDetails incomingEntityDetails = new IncomingEntityDetails(messageHeaders); - assertAll( - () -> assertEquals(-1, incomingEntityDetails.getContentLength()), - () -> assertNull(incomingEntityDetails.getContentType()), - () -> assertNull(incomingEntityDetails.getContentEncoding()), - () -> assertEquals(0, incomingEntityDetails.getTrailerNames().size()) - ); + SoftAssertions.assertSoftly(softly -> { + softly.assertThat(incomingEntityDetails.getContentLength()).isEqualTo(-1); + softly.assertThat(incomingEntityDetails.getContentType()).isNull(); + softly.assertThat(incomingEntityDetails.getContentEncoding()).isNull(); + softly.assertThat(incomingEntityDetails.getTrailerNames()).isEmpty(); + }); } @Test void messageHeadersNull() { - Assertions.assertThrows(NullPointerException.class, () -> new IncomingEntityDetails(null), - "Message Header Null"); + Assertions.assertThatThrownBy(() -> + new IncomingEntityDetails(null)) + .withFailMessage("Message Header Null").isInstanceOf(NullPointerException.class); } @Test @@ -73,10 +69,10 @@ void getContentLength() { final Header header = new BasicHeader("name", "value"); headerGroup.addHeader(header); final IncomingEntityDetails incomingEntityDetails = new IncomingEntityDetails(messageHeaders); - assertAll( - () -> assertEquals(-1, incomingEntityDetails.getContentLength()), - () -> assertTrue(incomingEntityDetails.isChunked()) - ); + SoftAssertions.assertSoftly(softly -> { + softly.assertThat(incomingEntityDetails.getContentLength()).isEqualTo(-1); + softly.assertThat(incomingEntityDetails.isChunked()).isTrue(); + }); } @Test @@ -86,11 +82,11 @@ void getTrailerNames() { messageHeaders.setHeaders(header); final IncomingEntityDetails incomingEntityDetails = new IncomingEntityDetails(messageHeaders); final Set incomingSet = incomingEntityDetails.getTrailerNames(); - assertAll( - () -> assertFalse(incomingSet.isEmpty()), - () -> assertTrue(incomingSet.containsAll(Stream.of("a", "b", "c") - .collect(Collectors.toCollection(HashSet::new)))) - ); + SoftAssertions.assertSoftly(softly -> { + softly.assertThat(incomingSet).isNotEmpty(); + softly.assertThat(incomingSet).containsAll(Stream.of("a", "b", "c") + .collect(Collectors.toCollection(HashSet::new))); + }); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/impl/TestDefaultConnectionReuseStrategy.java b/httpcore5/src/test/java/org/apache/hc/core5/http/impl/TestDefaultConnectionReuseStrategy.java index b9056f072a..a30e34ddf0 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/impl/TestDefaultConnectionReuseStrategy.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/impl/TestDefaultConnectionReuseStrategy.java @@ -36,7 +36,7 @@ import org.apache.hc.core5.http.message.BasicHttpRequest; import org.apache.hc.core5.http.message.BasicHttpResponse; import org.apache.hc.core5.http.protocol.HttpCoreContext; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -56,28 +56,28 @@ void setUp() { @Test void testInvalidResponseArg() { - Assertions.assertThrows(NullPointerException.class, () -> - reuseStrategy.keepAlive(null, null, this.context)); + Assertions.assertThatThrownBy(() -> + reuseStrategy.keepAlive(null, null, this.context)).isInstanceOf(NullPointerException.class); } @Test void testNoContentLengthResponseHttp1_0() { context.setProtocolVersion(HttpVersion.HTTP_1_0); final HttpResponse response = new BasicHttpResponse(200, "OK"); - Assertions.assertFalse(reuseStrategy.keepAlive(null, response, context)); + Assertions.assertThat(reuseStrategy.keepAlive(null, response, context)).isFalse(); } @Test void testNoContentLengthResponseHttp1_1() { final HttpResponse response = new BasicHttpResponse(200, "OK"); - Assertions.assertFalse(reuseStrategy.keepAlive(null, response, context)); + Assertions.assertThat(reuseStrategy.keepAlive(null, response, context)).isFalse(); } @Test void testChunkedContent() { final HttpResponse response = new BasicHttpResponse(200, "OK"); response.addHeader("Transfer-Encoding", "chunked"); - Assertions.assertTrue(reuseStrategy.keepAlive(null, response, context)); + Assertions.assertThat(reuseStrategy.keepAlive(null, response, context)).isTrue(); } @Test @@ -85,7 +85,7 @@ void testIgnoreInvalidKeepAlive() { context.setProtocolVersion(HttpVersion.HTTP_1_0); final HttpResponse response = new BasicHttpResponse(200, "OK"); response.addHeader("Connection", "keep-alive"); - Assertions.assertFalse(reuseStrategy.keepAlive(null, response, context)); + Assertions.assertThat(reuseStrategy.keepAlive(null, response, context)).isFalse(); } @Test @@ -94,7 +94,7 @@ void testExplicitClose() { final HttpResponse response = new BasicHttpResponse(200, "OK"); response.addHeader("Transfer-Encoding", "chunked"); response.addHeader("Connection", "close"); - Assertions.assertFalse(reuseStrategy.keepAlive(null, response, context)); + Assertions.assertThat(reuseStrategy.keepAlive(null, response, context)).isFalse(); } @Test @@ -105,7 +105,7 @@ void testExplicitKeepAlive() { response.addHeader("Content-Length", "10"); response.addHeader("Connection", "keep-alive"); - Assertions.assertTrue(reuseStrategy.keepAlive(null, response, context)); + Assertions.assertThat(reuseStrategy.keepAlive(null, response, context)).isTrue(); } @Test @@ -113,14 +113,14 @@ void testHTTP10Default() { final HttpResponse response = new BasicHttpResponse(200, "OK"); response.setVersion(HttpVersion.HTTP_1_0); response.addHeader("Content-Length", "10"); - Assertions.assertFalse(reuseStrategy.keepAlive(null, response, context)); + Assertions.assertThat(reuseStrategy.keepAlive(null, response, context)).isFalse(); } @Test void testHTTP11Default() { final HttpResponse response = new BasicHttpResponse(200, "OK"); response.addHeader("Content-Length", "10"); - Assertions.assertTrue(reuseStrategy.keepAlive(null, response, context)); + Assertions.assertThat(reuseStrategy.keepAlive(null, response, context)).isTrue(); } @Test @@ -130,7 +130,7 @@ void testBrokenConnectionDirective1() { response.setVersion(HttpVersion.HTTP_1_0); response.addHeader("Content-Length", "10"); response.addHeader("Connection", "keep--alive"); - Assertions.assertFalse(reuseStrategy.keepAlive(null, response, context)); + Assertions.assertThat(reuseStrategy.keepAlive(null, response, context)).isFalse(); } @Test @@ -140,7 +140,7 @@ void testBrokenConnectionDirective2() { response.setVersion(HttpVersion.HTTP_1_0); response.addHeader("Content-Length", "10"); response.addHeader("Connection", null); - Assertions.assertFalse(reuseStrategy.keepAlive(null, response, context)); + Assertions.assertThat(reuseStrategy.keepAlive(null, response, context)).isFalse(); } @Test @@ -149,7 +149,7 @@ void testConnectionTokens1() { final HttpResponse response = new BasicHttpResponse(200, "OK"); response.addHeader("Transfer-Encoding", "chunked"); response.addHeader("Connection", "yadda, cLOSe, dumdy"); - Assertions.assertFalse(reuseStrategy.keepAlive(null, response, context)); + Assertions.assertThat(reuseStrategy.keepAlive(null, response, context)).isFalse(); } @Test @@ -158,7 +158,7 @@ void testConnectionTokens2() { final HttpResponse response = new BasicHttpResponse(200, "OK"); response.addHeader("Transfer-Encoding", "chunked"); response.addHeader("Connection", "yadda, kEEP-alive, dumdy"); - Assertions.assertTrue(reuseStrategy.keepAlive(null, response, context)); + Assertions.assertThat(reuseStrategy.keepAlive(null, response, context)).isTrue(); } @Test @@ -167,7 +167,7 @@ void testConnectionTokens3() { final HttpResponse response = new BasicHttpResponse(200, "OK"); response.addHeader("Transfer-Encoding", "chunked"); response.addHeader("Connection", "yadda, keep-alive, close, dumdy"); - Assertions.assertFalse(reuseStrategy.keepAlive(null, response, context)); + Assertions.assertThat(reuseStrategy.keepAlive(null, response, context)).isFalse(); } @Test @@ -178,7 +178,7 @@ void testConnectionTokens4() { response.addHeader("Connection", "yadda, close, dumdy"); response.addHeader("Proxy-Connection", "keep-alive"); // Connection takes precedence over Proxy-Connection - Assertions.assertFalse(reuseStrategy.keepAlive(null, response, context)); + Assertions.assertThat(reuseStrategy.keepAlive(null, response, context)).isFalse(); } @Test @@ -191,7 +191,7 @@ void testConnectionTokens5() { // Connection takes precedence over Proxy-Connection, // even if it doesn't contain a recognized token. // Default for HTTP/1.1 is to keep alive. - Assertions.assertTrue(reuseStrategy.keepAlive(null, response, context)); + Assertions.assertThat(reuseStrategy.keepAlive(null, response, context)).isTrue(); } @Test @@ -203,7 +203,7 @@ void testConnectionTokens6() { response.addHeader("Proxy-Connection", "close"); // Connection takes precedence over Proxy-Connection, // even if it is empty. Default for HTTP/1.1 is to keep alive. - Assertions.assertTrue(reuseStrategy.keepAlive(null, response, context)); + Assertions.assertThat(reuseStrategy.keepAlive(null, response, context)).isTrue(); } @Test @@ -212,14 +212,14 @@ void testMultipleContentLength() { final HttpResponse response = new BasicHttpResponse(200, "OK"); response.addHeader("Content-Length", "10"); response.addHeader("Content-Length", "11"); - Assertions.assertFalse(reuseStrategy.keepAlive(null, response, context)); + Assertions.assertThat(reuseStrategy.keepAlive(null, response, context)).isFalse(); } @Test void testNoContentResponse() { // Use HTTP 1.1 final HttpResponse response = new BasicHttpResponse(HttpStatus.SC_NO_CONTENT, "No Content"); - Assertions.assertTrue(reuseStrategy.keepAlive(null, response, context)); + Assertions.assertThat(reuseStrategy.keepAlive(null, response, context)).isTrue(); } @Test @@ -227,7 +227,7 @@ void testNoContentResponseHttp10() { // Use HTTP 1.0 final HttpResponse response = new BasicHttpResponse(HttpStatus.SC_NO_CONTENT, "No Content"); response.setVersion(HttpVersion.HTTP_1_0); - Assertions.assertFalse(reuseStrategy.keepAlive(null, response, context)); + Assertions.assertThat(reuseStrategy.keepAlive(null, response, context)).isFalse(); } @Test @@ -238,7 +238,7 @@ void testRequestExplicitClose() { final HttpResponse response = new BasicHttpResponse(200, "OK"); response.addHeader("Transfer-Encoding", "chunked"); response.addHeader("Connection", "keep-alive"); - Assertions.assertFalse(reuseStrategy.keepAlive(request, response, context)); + Assertions.assertThat(reuseStrategy.keepAlive(request, response, context)).isFalse(); } @Test @@ -249,7 +249,7 @@ void testRequestNoExplicitClose() { final HttpResponse response = new BasicHttpResponse(200, "OK"); response.addHeader("Transfer-Encoding", "chunked"); response.addHeader("Connection", "keep-alive"); - Assertions.assertTrue(reuseStrategy.keepAlive(request, response, context)); + Assertions.assertThat(reuseStrategy.keepAlive(request, response, context)).isTrue(); } @Test @@ -262,7 +262,7 @@ void testRequestExplicitCloseMultipleTokens() { final HttpResponse response = new BasicHttpResponse(200, "OK"); response.addHeader("Transfer-Encoding", "chunked"); response.addHeader("Connection", "keep-alive"); - Assertions.assertFalse(reuseStrategy.keepAlive(request, response, context)); + Assertions.assertThat(reuseStrategy.keepAlive(request, response, context)).isFalse(); } @Test @@ -274,7 +274,7 @@ void testRequestClose() { response.addHeader("Content-Length", "10"); response.addHeader("Connection", "keep-alive"); - Assertions.assertFalse(reuseStrategy.keepAlive(request, response, context)); + Assertions.assertThat(reuseStrategy.keepAlive(request, response, context)).isFalse(); } @Test @@ -282,7 +282,7 @@ void testHeadRequestWithout() { final HttpRequest request = new BasicHttpRequest(Method.HEAD, "/"); final HttpResponse response = new BasicHttpResponse(200, "OK"); - Assertions.assertTrue(reuseStrategy.keepAlive(request, response, context)); + Assertions.assertThat(reuseStrategy.keepAlive(request, response, context)).isTrue(); } @Test @@ -290,7 +290,7 @@ void testHttp204ContentLengthGreaterThanZero() { final HttpResponse response = new BasicHttpResponse(204, "OK"); response.addHeader("Content-Length", "10"); response.addHeader("Connection", "keep-alive"); - Assertions.assertFalse(reuseStrategy.keepAlive(null, response, context)); + Assertions.assertThat(reuseStrategy.keepAlive(null, response, context)).isFalse(); } @Test @@ -298,7 +298,7 @@ void testHttp204ContentLengthEqualToZero() { final HttpResponse response = new BasicHttpResponse(204, "OK"); response.addHeader("Content-Length", "0"); response.addHeader("Connection", "keep-alive"); - Assertions.assertTrue(reuseStrategy.keepAlive(null, response, context)); + Assertions.assertThat(reuseStrategy.keepAlive(null, response, context)).isTrue(); } @Test @@ -306,7 +306,7 @@ void testHttp204ChunkedContent() { final HttpResponse response = new BasicHttpResponse(204, "OK"); response.addHeader("Transfer-Encoding", "chunked"); response.addHeader("Connection", "keep-alive"); - Assertions.assertFalse(reuseStrategy.keepAlive(null, response, context)); + Assertions.assertThat(reuseStrategy.keepAlive(null, response, context)).isFalse(); } @Test @@ -315,7 +315,7 @@ void testResponseHTTP10TransferEncodingPresent() { response.setVersion(HttpVersion.HTTP_1_0); response.addHeader("Transfer-Encoding", "chunked"); response.addHeader("Connection", "keep-alive"); - Assertions.assertFalse(reuseStrategy.keepAlive(null, response, context)); + Assertions.assertThat(reuseStrategy.keepAlive(null, response, context)).isFalse(); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/impl/TestDefaultContentLengthStrategy.java b/httpcore5/src/test/java/org/apache/hc/core5/http/impl/TestDefaultContentLengthStrategy.java index fa7b51cae4..8174242761 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/impl/TestDefaultContentLengthStrategy.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/impl/TestDefaultContentLengthStrategy.java @@ -34,7 +34,7 @@ import org.apache.hc.core5.http.ProtocolVersion; import org.apache.hc.core5.http.message.BasicHeader; import org.apache.hc.core5.http.message.HeaderGroup; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class TestDefaultContentLengthStrategy { @@ -70,7 +70,7 @@ void testEntityWithChunkTransferEncoding() throws Exception { final HttpMessage message = new TestHttpMessage(); message.addHeader("Transfer-Encoding", "Chunked"); - Assertions.assertEquals(ContentLengthStrategy.CHUNKED, lenStrategy.determineLength(message)); + Assertions.assertThat(lenStrategy.determineLength(message)).isEqualTo(ContentLengthStrategy.CHUNKED); } @Test @@ -79,7 +79,7 @@ void testEntityWithChunkTransferEncodingAndEmptyTokens() throws Exception { final HttpMessage message = new TestHttpMessage(); message.addHeader("Transfer-Encoding", ",,Chunked,,"); - Assertions.assertEquals(ContentLengthStrategy.CHUNKED, lenStrategy.determineLength(message)); + Assertions.assertThat(lenStrategy.determineLength(message)).isEqualTo(ContentLengthStrategy.CHUNKED); } @Test @@ -87,8 +87,8 @@ void testEntityWithChunkTransferEncodingDoubleChunk() { final ContentLengthStrategy lenStrategy = new DefaultContentLengthStrategy(); final HttpMessage message = new TestHttpMessage(); message.addHeader("Transfer-Encoding", "Chunked,Chunked"); - Assertions.assertThrows(NotImplementedException.class, () -> - lenStrategy.determineLength(message)); + Assertions.assertThatThrownBy(() -> + lenStrategy.determineLength(message)).isInstanceOf(NotImplementedException.class); } @Test @@ -96,8 +96,8 @@ void testEntityWithChunkTransferEncodingUnknown1() { final ContentLengthStrategy lenStrategy = new DefaultContentLengthStrategy(); final HttpMessage message = new TestHttpMessage(); message.addHeader("Transfer-Encoding", "blah"); - Assertions.assertThrows(NotImplementedException.class, () -> - lenStrategy.determineLength(message)); + Assertions.assertThatThrownBy(() -> + lenStrategy.determineLength(message)).isInstanceOf(NotImplementedException.class); } @Test @@ -105,8 +105,8 @@ void testEntityWithChunkTransferEncodingUnknown2() { final ContentLengthStrategy lenStrategy = new DefaultContentLengthStrategy(); final HttpMessage message = new TestHttpMessage(); message.addHeader("Transfer-Encoding", "blah, chunked"); - Assertions.assertThrows(NotImplementedException.class, () -> - lenStrategy.determineLength(message)); + Assertions.assertThatThrownBy(() -> + lenStrategy.determineLength(message)).isInstanceOf(NotImplementedException.class); } @Test @@ -114,8 +114,8 @@ void testEntityWithChunkTransferEncodingUnknown3() { final ContentLengthStrategy lenStrategy = new DefaultContentLengthStrategy(); final HttpMessage message = new TestHttpMessage(); message.addHeader("Transfer-Encoding", "chunked,blah"); - Assertions.assertThrows(NotImplementedException.class, () -> - lenStrategy.determineLength(message)); + Assertions.assertThatThrownBy(() -> + lenStrategy.determineLength(message)).isInstanceOf(NotImplementedException.class); } @Test @@ -123,8 +123,8 @@ void testEntityWithIdentityTransferEncoding() { final ContentLengthStrategy lenStrategy = new DefaultContentLengthStrategy(); final HttpMessage message = new TestHttpMessage(); message.addHeader("Transfer-Encoding", "Identity"); - Assertions.assertThrows(NotImplementedException.class, () -> - lenStrategy.determineLength(message)); + Assertions.assertThatThrownBy(() -> + lenStrategy.determineLength(message)).isInstanceOf(NotImplementedException.class); } @Test @@ -132,7 +132,7 @@ void testEntityWithContentLength() throws Exception { final ContentLengthStrategy lenStrategy = new DefaultContentLengthStrategy(); final HttpMessage message = new TestHttpMessage(); message.addHeader("Content-Length", "100"); - Assertions.assertEquals(100, lenStrategy.determineLength(message)); + Assertions.assertThat(lenStrategy.determineLength(message)).isEqualTo(100); } @Test @@ -140,8 +140,8 @@ void testEntityWithInvalidContentLength() { final ContentLengthStrategy lenStrategy = new DefaultContentLengthStrategy(); final HttpMessage message = new TestHttpMessage(); message.addHeader("Content-Length", "whatever"); - Assertions.assertThrows(ProtocolException.class, () -> - lenStrategy.determineLength(message)); + Assertions.assertThatThrownBy(() -> + lenStrategy.determineLength(message)).isInstanceOf(ProtocolException.class); } @Test @@ -149,8 +149,8 @@ void testEntityWithNegativeContentLength() { final ContentLengthStrategy lenStrategy = new DefaultContentLengthStrategy(); final HttpMessage message = new TestHttpMessage(); message.addHeader("Content-Length", "-10"); - Assertions.assertThrows(ProtocolException.class, () -> - lenStrategy.determineLength(message)); + Assertions.assertThatThrownBy(() -> + lenStrategy.determineLength(message)).isInstanceOf(ProtocolException.class); } @Test @@ -158,16 +158,15 @@ void testEntityWithPlusSignedContentLength() { final ContentLengthStrategy lenStrategy = new DefaultContentLengthStrategy(); final HttpMessage message = new TestHttpMessage(); message.addHeader("Content-Length", "+5"); - Assertions.assertThrows(ProtocolException.class, () -> - lenStrategy.determineLength(message)); + Assertions.assertThatThrownBy(() -> lenStrategy.determineLength(message)) + .isInstanceOf(ProtocolException.class); } @Test void testEntityNoContentDelimiter() throws Exception { final ContentLengthStrategy lenStrategy = new DefaultContentLengthStrategy(); final HttpMessage message = new TestHttpMessage(); - Assertions.assertEquals(ContentLengthStrategy.UNDEFINED, lenStrategy.determineLength(message)); + Assertions.assertThat(lenStrategy.determineLength(message)).isEqualTo(ContentLengthStrategy.UNDEFINED); } } - diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/impl/TestEnglishReasonPhraseCatalog.java b/httpcore5/src/test/java/org/apache/hc/core5/http/impl/TestEnglishReasonPhraseCatalog.java index 749e5b368e..59926b80f2 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/impl/TestEnglishReasonPhraseCatalog.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/impl/TestEnglishReasonPhraseCatalog.java @@ -31,7 +31,7 @@ import java.lang.reflect.Modifier; import org.apache.hc.core5.http.HttpStatus; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; /** @@ -45,9 +45,9 @@ class TestEnglishReasonPhraseCatalog { void testReasonPhrases() throws IllegalAccessException { final Field[] publicFields = HttpStatus.class.getFields(); - Assertions.assertNotNull( publicFields ); + Assertions.assertThat(publicFields).isNotNull(); - Assertions.assertTrue( publicFields.length > 0 ); + Assertions.assertThat(publicFields.length > 0).isTrue(); for (final Field f : publicFields) { final int modifiers = f.getModifiers(); @@ -60,8 +60,8 @@ void testReasonPhrases() throws IllegalAccessException { final int iValue = f.getInt(null); final String text = EnglishReasonPhraseCatalog. INSTANCE.getReason(iValue, null); - Assertions.assertNotNull("text is null for HttpStatus." + f.getName(), text); - Assertions.assertTrue(text.length() > 0); + Assertions.assertThat("text is null for HttpStatus." + f.getName()).withFailMessage(text).isNotNull(); + Assertions.assertThat(text.length() > 0).isTrue(); } } } @@ -69,12 +69,12 @@ void testReasonPhrases() throws IllegalAccessException { @Test void testStatusInvalid() { - Assertions.assertThrows(IllegalArgumentException.class, () -> - EnglishReasonPhraseCatalog.INSTANCE.getReason(-1, null)); - Assertions.assertThrows(IllegalArgumentException.class, () -> - EnglishReasonPhraseCatalog.INSTANCE.getReason(99, null)); - Assertions.assertThrows(IllegalArgumentException.class, () -> - EnglishReasonPhraseCatalog.INSTANCE.getReason(600, null)); + Assertions.assertThatThrownBy(() -> + EnglishReasonPhraseCatalog.INSTANCE.getReason(-1, null)).isInstanceOf(IllegalArgumentException.class); + Assertions.assertThatThrownBy(() -> + EnglishReasonPhraseCatalog.INSTANCE.getReason(99, null)).isInstanceOf(IllegalArgumentException.class); + Assertions.assertThatThrownBy(() -> + EnglishReasonPhraseCatalog.INSTANCE.getReason(600, null)).isInstanceOf(IllegalArgumentException.class); } @Test diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/impl/io/TestBHttpConnectionBase.java b/httpcore5/src/test/java/org/apache/hc/core5/http/impl/io/TestBHttpConnectionBase.java index 85150aa4e6..d2dc4e16eb 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/impl/io/TestBHttpConnectionBase.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/impl/io/TestBHttpConnectionBase.java @@ -42,7 +42,7 @@ import org.apache.hc.core5.http.message.BasicClassicHttpResponse; import org.apache.hc.core5.io.CloseMode; import org.apache.hc.core5.util.Timeout; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; @@ -66,10 +66,10 @@ void prepareMocks() { @Test void testBasics() { - Assertions.assertFalse(conn.isOpen()); - Assertions.assertNull(conn.getLocalAddress()); - Assertions.assertNull(conn.getRemoteAddress()); - Assertions.assertEquals("[Not bound]", conn.toString()); + Assertions.assertThat(conn.isOpen()).isFalse(); + Assertions.assertThat(conn.getLocalAddress()).isNull(); + Assertions.assertThat(conn.getRemoteAddress()).isNull(); + Assertions.assertThat(conn.toString()).isEqualTo("[Not bound]"); } @Test @@ -84,13 +84,13 @@ void testSocketBind() throws Exception { Mockito.when(socket.getRemoteSocketAddress()).thenReturn(remoteSockAddress); conn.bind(socket); - Assertions.assertEquals("127.0.0.1:8888<->10.0.0.2:80", conn.toString()); - Assertions.assertTrue(conn.isOpen()); + Assertions.assertThat(conn.toString()).isEqualTo("127.0.0.1:8888<->10.0.0.2:80"); + Assertions.assertThat(conn.isOpen()).isTrue(); - Assertions.assertEquals(new InetSocketAddress( - InetAddress.getByAddress(new byte[] {127, 0, 0, 1}), 8888), conn.getLocalAddress()); - Assertions.assertEquals(new InetSocketAddress( - InetAddress.getByAddress(new byte[] {10, 0, 0, 2}), 80), conn.getRemoteAddress()); + Assertions.assertThat(conn.getLocalAddress()).isEqualTo(new InetSocketAddress( + InetAddress.getByAddress(new byte[]{127, 0, 0, 1}), 8888)); + Assertions.assertThat(conn.getRemoteAddress()).isEqualTo(new InetSocketAddress( + InetAddress.getByAddress(new byte[]{10, 0, 0, 2}), 80)); } @Test @@ -102,11 +102,11 @@ void testConnectionClose() throws Exception { conn.ensureOpen(); conn.outbuffer.write(0, outStream); - Assertions.assertTrue(conn.isOpen()); + Assertions.assertThat(conn.isOpen()).isTrue(); conn.close(); - Assertions.assertFalse(conn.isOpen()); + Assertions.assertThat(conn.isOpen()).isFalse(); Mockito.verify(outStream, Mockito.times(1)).write( ArgumentMatchers.any(), ArgumentMatchers.anyInt(), ArgumentMatchers.anyInt()); @@ -126,11 +126,11 @@ void testConnectionShutdown() throws Exception { conn.ensureOpen(); conn.outbuffer.write(0, outStream); - Assertions.assertTrue(conn.isOpen()); + Assertions.assertThat(conn.isOpen()).isTrue(); conn.close(CloseMode.GRACEFUL); - Assertions.assertFalse(conn.isOpen()); + Assertions.assertThat(conn.isOpen()).isFalse(); Mockito.verify(outStream, Mockito.never()).write( ArgumentMatchers.any(), ArgumentMatchers.anyInt(), ArgumentMatchers.anyInt()); @@ -153,14 +153,14 @@ void testCreateEntityLengthDelimited() throws Exception { message.addHeader("Content-Type", "stuff"); message.addHeader("Content-Encoding", "chunked"); final HttpEntity entity = conn.createIncomingEntity(message, conn.inBuffer, inStream, 10); - Assertions.assertNotNull(entity); - Assertions.assertFalse(entity.isChunked()); - Assertions.assertEquals(10, entity.getContentLength()); - Assertions.assertEquals("stuff", entity.getContentType()); - Assertions.assertEquals("chunked", entity.getContentEncoding()); + Assertions.assertThat(entity).isNotNull(); + Assertions.assertThat(entity.isChunked()).isFalse(); + Assertions.assertThat(entity.getContentLength()).isEqualTo(10); + Assertions.assertThat(entity.getContentType()).isEqualTo("stuff"); + Assertions.assertThat(entity.getContentEncoding()).isEqualTo("chunked"); final InputStream content = entity.getContent(); - Assertions.assertNotNull(content); - Assertions.assertInstanceOf(ContentLengthInputStream.class, content); + Assertions.assertThat(content).isNotNull(); + Assertions.assertThat(content).isInstanceOf(ContentLengthInputStream.class); } @Test @@ -168,12 +168,12 @@ void testCreateEntityInputChunked() throws Exception { final InputStream inStream = Mockito.mock(InputStream.class); final ClassicHttpResponse message = new BasicClassicHttpResponse(200, "OK"); final HttpEntity entity = conn.createIncomingEntity(message, conn.inBuffer, inStream, ContentLengthStrategy.CHUNKED); - Assertions.assertNotNull(entity); - Assertions.assertTrue(entity.isChunked()); - Assertions.assertEquals(-1, entity.getContentLength()); + Assertions.assertThat(entity).isNotNull(); + Assertions.assertThat(entity.isChunked()).isTrue(); + Assertions.assertThat(entity.getContentLength()).isEqualTo(-1); final InputStream content = entity.getContent(); - Assertions.assertNotNull(content); - Assertions.assertInstanceOf(ChunkedInputStream.class, content); + Assertions.assertThat(content).isNotNull(); + Assertions.assertThat(content).isInstanceOf(ChunkedInputStream.class); } @Test @@ -181,12 +181,12 @@ void testCreateEntityInputUndefined() throws Exception { final InputStream inStream = Mockito.mock(InputStream.class); final ClassicHttpResponse message = new BasicClassicHttpResponse(200, "OK"); final HttpEntity entity = conn.createIncomingEntity(message, conn.inBuffer, inStream, ContentLengthStrategy.UNDEFINED); - Assertions.assertNotNull(entity); - Assertions.assertFalse(entity.isChunked()); - Assertions.assertEquals(-1, entity.getContentLength()); + Assertions.assertThat(entity).isNotNull(); + Assertions.assertThat(entity.isChunked()).isFalse(); + Assertions.assertThat(entity.getContentLength()).isEqualTo(-1); final InputStream content = entity.getContent(); - Assertions.assertNotNull(content); - Assertions.assertInstanceOf(IdentityInputStream.class, content); + Assertions.assertThat(content).isNotNull(); + Assertions.assertThat(content).isInstanceOf(IdentityInputStream.class); } @Test @@ -211,22 +211,22 @@ void testSetSocketTimeoutException() throws Exception { @Test void testGetSocketTimeout() throws Exception { - Assertions.assertEquals(Timeout.INFINITE, conn.getSocketTimeout()); + Assertions.assertThat(conn.getSocketTimeout()).isEqualTo(Timeout.INFINITE); Mockito.when(socket.getSoTimeout()).thenReturn(345); conn.bind(socket); - Assertions.assertEquals(Timeout.ofMilliseconds(345), conn.getSocketTimeout()); + Assertions.assertThat(conn.getSocketTimeout()).isEqualTo(Timeout.ofMilliseconds(345)); } @Test void testGetSocketTimeoutException() throws Exception { - Assertions.assertEquals(Timeout.INFINITE, conn.getSocketTimeout()); + Assertions.assertThat(conn.getSocketTimeout()).isEqualTo(Timeout.INFINITE); Mockito.when(socket.getSoTimeout()).thenThrow(new SocketException()); conn.bind(socket); - Assertions.assertEquals(Timeout.INFINITE, conn.getSocketTimeout()); + Assertions.assertThat(conn.getSocketTimeout()).isEqualTo(Timeout.INFINITE); } @Test @@ -237,7 +237,7 @@ void testAwaitInputInBuffer() throws Exception { conn.ensureOpen(); conn.inBuffer.read(inStream); - Assertions.assertTrue(conn.awaitInput(Timeout.ofMilliseconds(432))); + Assertions.assertThat(conn.awaitInput(Timeout.ofMilliseconds(432))).isTrue(); Mockito.verify(socket, Mockito.never()).setSoTimeout(ArgumentMatchers.anyInt()); } @@ -252,7 +252,7 @@ void testAwaitInputInSocket() throws Exception { conn.bind(socket); conn.ensureOpen(); - Assertions.assertTrue(conn.awaitInput(Timeout.ofMilliseconds(432))); + Assertions.assertThat(conn.awaitInput(Timeout.ofMilliseconds(432))).isTrue(); Mockito.verify(socket, Mockito.times(1)).setSoTimeout(432); Mockito.verify(socket, Mockito.times(1)).setSoTimeout(345); @@ -268,7 +268,7 @@ void testAwaitInputNoData() throws Exception { conn.bind(socket); conn.ensureOpen(); - Assertions.assertFalse(conn.awaitInput(Timeout.ofMilliseconds(432))); + Assertions.assertThat(conn.awaitInput(Timeout.ofMilliseconds(432))).isFalse(); } @Test @@ -280,7 +280,7 @@ void testStaleWhenClosed() throws Exception { conn.bind(socket); conn.ensureOpen(); conn.close(); - Assertions.assertTrue(conn.isStale()); + Assertions.assertThat(conn.isStale()).isTrue(); } @Test @@ -292,7 +292,7 @@ void testNotStaleWhenHasData() throws Exception { conn.bind(socket); conn.ensureOpen(); - Assertions.assertFalse(conn.isStale()); + Assertions.assertThat(conn.isStale()).isFalse(); } @Test @@ -305,7 +305,7 @@ void testStaleWhenEndOfStream() throws Exception { conn.bind(socket); conn.ensureOpen(); - Assertions.assertTrue(conn.isStale()); + Assertions.assertThat(conn.isStale()).isTrue(); } @Test @@ -318,7 +318,7 @@ void testNotStaleWhenTimeout() throws Exception { conn.bind(socket); conn.ensureOpen(); - Assertions.assertFalse(conn.isStale()); + Assertions.assertThat(conn.isStale()).isFalse(); } @Test @@ -331,7 +331,7 @@ void testStaleWhenIOError() throws Exception { conn.bind(socket); conn.ensureOpen(); - Assertions.assertTrue(conn.isStale()); + Assertions.assertThat(conn.isStale()).isTrue(); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/impl/io/TestChunkCoding.java b/httpcore5/src/test/java/org/apache/hc/core5/http/impl/io/TestChunkCoding.java index 7b63bec232..f3d695e1b4 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/impl/io/TestChunkCoding.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/impl/io/TestChunkCoding.java @@ -42,7 +42,7 @@ import org.apache.hc.core5.http.io.SessionInputBuffer; import org.apache.hc.core5.http.io.SessionOutputBuffer; import org.apache.hc.core5.http.message.BasicHeader; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class TestChunkCoding { @@ -64,21 +64,21 @@ void testChunkedInputStreamLargeBuffer() throws IOException { while ((len = in.read(buffer)) > 0) { out.write(buffer, 0, len); } - Assertions.assertEquals(-1, in.read(buffer)); - Assertions.assertEquals(-1, in.read(buffer)); + Assertions.assertThat(in.read(buffer)).isEqualTo(-1); + Assertions.assertThat(in.read(buffer)).isEqualTo(-1); in.close(); final String result = new String(out.toByteArray(), StandardCharsets.US_ASCII); - Assertions.assertEquals(CHUNKED_RESULT, result); + Assertions.assertThat(result).isEqualTo(CHUNKED_RESULT); final Header[] footers = in.getFooters(); - Assertions.assertNotNull(footers); - Assertions.assertEquals(2, footers.length); - Assertions.assertEquals("Footer1", footers[0].getName()); - Assertions.assertEquals("abcde", footers[0].getValue()); - Assertions.assertEquals("Footer2", footers[1].getName()); - Assertions.assertEquals("fghij", footers[1].getValue()); + Assertions.assertThat(footers).isNotNull(); + Assertions.assertThat(footers.length).isEqualTo(2); + Assertions.assertThat(footers[0].getName()).isEqualTo("Footer1"); + Assertions.assertThat(footers[0].getValue()).isEqualTo("abcde"); + Assertions.assertThat(footers[1].getName()).isEqualTo("Footer2"); + Assertions.assertThat(footers[1].getValue()).isEqualTo("fghij"); } //Test for when buffer is smaller than chunk size. @@ -94,18 +94,18 @@ void testChunkedInputStreamSmallBuffer() throws IOException { while ((len = in.read(buffer)) > 0) { out.write(buffer, 0, len); } - Assertions.assertEquals(-1, in.read(buffer)); - Assertions.assertEquals(-1, in.read(buffer)); + Assertions.assertThat(in.read(buffer)).isEqualTo(-1); + Assertions.assertThat(in.read(buffer)).isEqualTo(-1); in.close(); final Header[] footers = in.getFooters(); - Assertions.assertNotNull(footers); - Assertions.assertEquals(2, footers.length); - Assertions.assertEquals("Footer1", footers[0].getName()); - Assertions.assertEquals("abcde", footers[0].getValue()); - Assertions.assertEquals("Footer2", footers[1].getName()); - Assertions.assertEquals("fghij", footers[1].getValue()); + Assertions.assertThat(footers).isNotNull(); + Assertions.assertThat(footers.length).isEqualTo(2); + Assertions.assertThat(footers[0].getName()).isEqualTo("Footer1"); + Assertions.assertThat(footers[0].getValue()).isEqualTo("abcde"); + Assertions.assertThat(footers[1].getName()).isEqualTo("Footer2"); + Assertions.assertThat(footers[1].getValue()).isEqualTo("fghij"); } // One byte read @@ -118,11 +118,11 @@ void testChunkedInputStreamOneByteRead() throws IOException { int ch; int i = '0'; while ((ch = in.read()) != -1) { - Assertions.assertEquals(i, ch); + Assertions.assertThat(ch).isEqualTo(i); i++; } - Assertions.assertEquals(-1, in.read()); - Assertions.assertEquals(-1, in.read()); + Assertions.assertThat(in.read()).isEqualTo(-1); + Assertions.assertThat(in.read()).isEqualTo(-1); } } @@ -132,9 +132,9 @@ void testAvailable() throws IOException { final SessionInputBuffer inBuffer = new SessionInputBufferImpl(16); final ByteArrayInputStream inputStream = new ByteArrayInputStream(s.getBytes(StandardCharsets.US_ASCII)); try (ChunkedInputStream in = new ChunkedInputStream(inBuffer, inputStream)) { - Assertions.assertEquals(0, in.available()); + Assertions.assertThat(in.available()).isEqualTo(0); in.read(); - Assertions.assertEquals(4, in.available()); + Assertions.assertThat(in.available()).isEqualTo(4); } } @@ -146,10 +146,16 @@ void testChunkedInputStreamClose() throws IOException { final ChunkedInputStream in = new ChunkedInputStream(inBuffer, inputStream); in.close(); in.close(); - Assertions.assertThrows(StreamClosedException.class, () -> in.read()); + Assertions.assertThatThrownBy(() -> + in.read()) + .isInstanceOf(StreamClosedException.class); final byte[] tmp = new byte[10]; - Assertions.assertThrows(StreamClosedException.class, () -> in.read(tmp)); - Assertions.assertThrows(StreamClosedException.class, () -> in.read(tmp, 0, tmp.length)); + Assertions.assertThatThrownBy(() -> + in.read(tmp)) + .isInstanceOf(StreamClosedException.class); + Assertions.assertThatThrownBy(() -> + in.read(tmp, 0, tmp.length)) + .isInstanceOf(StreamClosedException.class); } // Missing closing chunk @@ -160,9 +166,13 @@ void testChunkedInputStreamNoClosingChunk() throws IOException { final ByteArrayInputStream inputStream = new ByteArrayInputStream(s.getBytes(StandardCharsets.US_ASCII)); try (ChunkedInputStream in = new ChunkedInputStream(inBuffer, inputStream)) { final byte[] tmp = new byte[5]; - Assertions.assertEquals(5, in.read(tmp)); - Assertions.assertThrows(ConnectionClosedException.class, () -> in.read()); - Assertions.assertThrows(ConnectionClosedException.class, () -> in.close()); + Assertions.assertThat(in.read(tmp)).isEqualTo(5); + Assertions.assertThatThrownBy(() -> + in.read()) + .isInstanceOf(ConnectionClosedException.class); + Assertions.assertThatThrownBy(() -> + in.close()) + .isInstanceOf(ConnectionClosedException.class); } } @@ -174,8 +184,10 @@ void testCorruptChunkedInputStreamTruncatedCRLF() throws IOException { final ByteArrayInputStream inputStream = new ByteArrayInputStream(s.getBytes(StandardCharsets.US_ASCII)); try (ChunkedInputStream in = new ChunkedInputStream(inBuffer, inputStream)) { final byte[] tmp = new byte[5]; - Assertions.assertEquals(5, in.read(tmp)); - Assertions.assertThrows(MalformedChunkCodingException.class, () -> in.read()); + Assertions.assertThat(in.read(tmp)).isEqualTo(5); + Assertions.assertThatThrownBy(() -> + in.read()) + .isInstanceOf(MalformedChunkCodingException.class); } } @@ -188,12 +200,12 @@ void testCorruptChunkedInputStreamMissingCRLF() throws IOException { try (ChunkedInputStream in = new ChunkedInputStream(inBuffer, inputStream)) { final byte[] buffer = new byte[300]; final ByteArrayOutputStream out = new ByteArrayOutputStream(); - Assertions.assertThrows(MalformedChunkCodingException.class, () -> { + Assertions.assertThatThrownBy(() -> { int len; while ((len = in.read(buffer)) > 0) { out.write(buffer, 0, len); } - }); + }).isInstanceOf(MalformedChunkCodingException.class); } } @@ -204,7 +216,7 @@ void testCorruptChunkedInputStreamMissingLF() throws IOException { final SessionInputBuffer inBuffer = new SessionInputBufferImpl(16); final ByteArrayInputStream inputStream = new ByteArrayInputStream(s.getBytes(StandardCharsets.US_ASCII)); try (ChunkedInputStream in = new ChunkedInputStream(inBuffer, inputStream)) { - Assertions.assertThrows(MalformedChunkCodingException.class, in::read); + Assertions.assertThatThrownBy(in::read).isInstanceOf(MalformedChunkCodingException.class); } } @@ -215,7 +227,7 @@ void testCorruptChunkedInputStreamInvalidSize() throws IOException { final SessionInputBuffer inBuffer = new SessionInputBufferImpl(16); final ByteArrayInputStream inputStream = new ByteArrayInputStream(s.getBytes(StandardCharsets.US_ASCII)); try (ChunkedInputStream in = new ChunkedInputStream(inBuffer, inputStream)) { - Assertions.assertThrows(MalformedChunkCodingException.class, in::read); + Assertions.assertThatThrownBy(in::read).isInstanceOf(MalformedChunkCodingException.class); } } @@ -225,7 +237,7 @@ void testCorruptChunkedInputStreamSignedSize() throws IOException { final SessionInputBuffer inBuffer = new SessionInputBufferImpl(16); final ByteArrayInputStream inputStream = new ByteArrayInputStream(s.getBytes(StandardCharsets.US_ASCII)); try (ChunkedInputStream in = new ChunkedInputStream(inBuffer, inputStream)) { - Assertions.assertThrows(MalformedChunkCodingException.class, in::read); + Assertions.assertThatThrownBy(in::read).isInstanceOf(MalformedChunkCodingException.class); } } @@ -235,7 +247,7 @@ void testCorruptChunkedInputStreamMinusZeroSize() throws IOException { final SessionInputBuffer inBuffer = new SessionInputBufferImpl(16); final ByteArrayInputStream inputStream = new ByteArrayInputStream(s.getBytes(StandardCharsets.US_ASCII)); try (ChunkedInputStream in = new ChunkedInputStream(inBuffer, inputStream)) { - Assertions.assertThrows(MalformedChunkCodingException.class, in::read); + Assertions.assertThatThrownBy(in::read).isInstanceOf(MalformedChunkCodingException.class); } } @@ -245,7 +257,7 @@ void testCorruptChunkedInputStreamOverflowSize() throws IOException { final SessionInputBuffer inBuffer = new SessionInputBufferImpl(16); final ByteArrayInputStream inputStream = new ByteArrayInputStream(s.getBytes(StandardCharsets.US_ASCII)); try (ChunkedInputStream in = new ChunkedInputStream(inBuffer, inputStream)) { - Assertions.assertThrows(MalformedChunkCodingException.class, in::read); + Assertions.assertThatThrownBy(in::read).isInstanceOf(MalformedChunkCodingException.class); } } @@ -256,8 +268,8 @@ void testChunkedInputStreamSurroundingWhitespaceSize() throws IOException { final ByteArrayInputStream inputStream = new ByteArrayInputStream(s.getBytes(StandardCharsets.US_ASCII)); try (ChunkedInputStream in = new ChunkedInputStream(inBuffer, inputStream)) { final byte[] tmp = new byte[5]; - Assertions.assertEquals(5, in.read(tmp)); - Assertions.assertEquals("01234", new String(tmp, StandardCharsets.US_ASCII)); + Assertions.assertThat(in.read(tmp)).isEqualTo(5); + Assertions.assertThat(new String(tmp, StandardCharsets.US_ASCII)).isEqualTo("01234"); } } @@ -268,8 +280,8 @@ void testChunkedInputStreamLeadingZerosSize() throws IOException { final ByteArrayInputStream inputStream = new ByteArrayInputStream(s.getBytes(StandardCharsets.US_ASCII)); try (ChunkedInputStream in = new ChunkedInputStream(inBuffer, inputStream)) { final byte[] tmp = new byte[5]; - Assertions.assertEquals(5, in.read(tmp)); - Assertions.assertEquals("01234", new String(tmp, StandardCharsets.US_ASCII)); + Assertions.assertThat(in.read(tmp)).isEqualTo(5); + Assertions.assertThat(new String(tmp, StandardCharsets.US_ASCII)).isEqualTo("01234"); } } @@ -280,7 +292,7 @@ void testCorruptChunkedInputStreamNegativeSize() throws IOException { final SessionInputBuffer inBuffer = new SessionInputBufferImpl(16); final ByteArrayInputStream inputStream = new ByteArrayInputStream(s.getBytes(StandardCharsets.US_ASCII)); try (ChunkedInputStream in = new ChunkedInputStream(inBuffer, inputStream)) { - Assertions.assertThrows(MalformedChunkCodingException.class, in::read); + Assertions.assertThatThrownBy(in::read).isInstanceOf(MalformedChunkCodingException.class); } } @@ -292,8 +304,10 @@ void testCorruptChunkedInputStreamTruncatedChunk() throws IOException { final ByteArrayInputStream inputStream = new ByteArrayInputStream(s.getBytes(StandardCharsets.US_ASCII)); try (ChunkedInputStream in = new ChunkedInputStream(inBuffer, inputStream)) { final byte[] buffer = new byte[300]; - Assertions.assertEquals(2, in.read(buffer)); - Assertions.assertThrows(MalformedChunkCodingException.class, () -> in.read(buffer)); + Assertions.assertThat(in.read(buffer)).isEqualTo(2); + Assertions.assertThatThrownBy(() -> + in.read(buffer)) + .isInstanceOf(MalformedChunkCodingException.class); } } @@ -305,7 +319,7 @@ void testCorruptChunkedInputStreamInvalidFooter() throws IOException { final ByteArrayInputStream inputStream = new ByteArrayInputStream(s.getBytes(StandardCharsets.US_ASCII)); try (ChunkedInputStream in = new ChunkedInputStream(inBuffer, inputStream)) { in.read(); - Assertions.assertThrows(MalformedChunkCodingException.class, in::read); + Assertions.assertThatThrownBy(in::read).isInstanceOf(MalformedChunkCodingException.class); } } @@ -315,7 +329,7 @@ void testCorruptChunkedInputStreamClose() throws IOException { final SessionInputBuffer inBuffer = new SessionInputBufferImpl(16); final ByteArrayInputStream inputStream = new ByteArrayInputStream(s.getBytes(StandardCharsets.US_ASCII)); try (final ChunkedInputStream in = new ChunkedInputStream(inBuffer, inputStream)) { - Assertions.assertThrows(MalformedChunkCodingException.class, in::read); + Assertions.assertThatThrownBy(in::read).isInstanceOf(MalformedChunkCodingException.class); } } @@ -331,7 +345,7 @@ void testEmptyChunkedInputStream() throws IOException { while ((len = in.read(buffer)) > 0) { out.write(buffer, 0, len); } - Assertions.assertEquals(0, out.size()); + Assertions.assertThat(out.size()).isEqualTo(0); } } @@ -342,13 +356,15 @@ void testTooLongChunkHeader() throws IOException { final byte[] buffer = new byte[300]; final ByteArrayInputStream inputStream1 = new ByteArrayInputStream(s.getBytes(StandardCharsets.US_ASCII)); try (final ChunkedInputStream in1 = new ChunkedInputStream(inBuffer1, inputStream1)) { - Assertions.assertEquals(5, in1.read(buffer)); + Assertions.assertThat(in1.read(buffer)).isEqualTo(5); } final SessionInputBuffer inBuffer2 = new SessionInputBufferImpl(16, 10); final ByteArrayInputStream inputStream2 = new ByteArrayInputStream(s.getBytes(StandardCharsets.US_ASCII)); final ChunkedInputStream in2 = new ChunkedInputStream(inBuffer2, inputStream2); - Assertions.assertThrows(MessageConstraintException.class, () -> in2.read(buffer)); + Assertions.assertThatThrownBy(() -> + in2.read(buffer)) + .isInstanceOf(MessageConstraintException.class); // close() would throw here } @@ -359,8 +375,10 @@ void testChunkedOutputStreamClose() throws IOException { final ChunkedOutputStream out = new ChunkedOutputStream(outbuffer, outputStream, 2048); out.close(); out.close(); - Assertions.assertThrows(IOException.class, () -> out.write(new byte[] {1,2,3})); - Assertions.assertThrows(IOException.class, () -> out.write(1)); + Assertions.assertThatThrownBy(() -> + out.write(new byte[]{1, 2, 3})) + .isInstanceOf(IOException.class); + Assertions.assertThatThrownBy(() -> out.write(1)).isInstanceOf(IOException.class); } @Test @@ -385,7 +403,7 @@ void testChunkedConsistence() throws IOException { } final String output = new String(result.toByteArray(), StandardCharsets.US_ASCII); - Assertions.assertEquals(input, output); + Assertions.assertThat(output).isEqualTo(input); } } @@ -402,7 +420,7 @@ void testChunkedOutputStreamWithTrailers() throws IOException { } final String content = new String(outputStream.toByteArray(), StandardCharsets.US_ASCII); - Assertions.assertEquals("1\r\nx\r\n0\r\nE: \r\nY: Z\r\n\r\n", content); + Assertions.assertThat(content).isEqualTo("1\r\nx\r\n0\r\nE: \r\nY: Z\r\n\r\n"); } @Test @@ -418,7 +436,7 @@ void testChunkedOutputStream() throws IOException { } final String content = new String(outputStream.toByteArray(), StandardCharsets.US_ASCII); - Assertions.assertEquals("2\r\n12\r\n2\r\n34\r\n0\r\n\r\n", content); + Assertions.assertThat(content).isEqualTo("2\r\n12\r\n2\r\n34\r\n0\r\n\r\n"); } @Test @@ -431,7 +449,7 @@ void testChunkedOutputStreamLargeChunk() throws IOException { } final String content = new String(outputStream.toByteArray(), StandardCharsets.US_ASCII); - Assertions.assertEquals("4\r\n1234\r\n0\r\n\r\n", content); + Assertions.assertThat(content).isEqualTo("4\r\n1234\r\n0\r\n\r\n"); } @Test @@ -444,7 +462,7 @@ void testChunkedOutputStreamSmallChunk() throws IOException { } final String content = new String(outputStream.toByteArray(), StandardCharsets.US_ASCII); - Assertions.assertEquals("1\r\n1\r\n0\r\n\r\n", content); + Assertions.assertThat(content).isEqualTo("1\r\n1\r\n0\r\n\r\n"); } @Test @@ -470,8 +488,8 @@ void testResumeOnSocketTimeoutInData() throws IOException { timeouts++; } } - Assertions.assertEquals(20, bytesRead); - Assertions.assertEquals(2, timeouts); + Assertions.assertThat(bytesRead).isEqualTo(20); + Assertions.assertThat(timeouts).isEqualTo(2); } } @@ -498,8 +516,8 @@ void testResumeOnSocketTimeoutInChunk() throws IOException { timeouts++; } } - Assertions.assertEquals(20, bytesRead); - Assertions.assertEquals(5, timeouts); + Assertions.assertThat(bytesRead).isEqualTo(20); + Assertions.assertThat(timeouts).isEqualTo(5); } } @@ -518,8 +536,7 @@ void testHugeChunk() throws IOException { } final String result = new String(out.toByteArray(), StandardCharsets.US_ASCII); - Assertions.assertEquals("01234567", result); + Assertions.assertThat(result).isEqualTo("01234567"); } } - diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/impl/io/TestContentLengthInputStream.java b/httpcore5/src/test/java/org/apache/hc/core5/http/impl/io/TestContentLengthInputStream.java index 610c877a40..f392ca9ff6 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/impl/io/TestContentLengthInputStream.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/impl/io/TestContentLengthInputStream.java @@ -36,7 +36,7 @@ import org.apache.hc.core5.http.ConnectionClosedException; import org.apache.hc.core5.http.StreamClosedException; import org.apache.hc.core5.http.io.SessionInputBuffer; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class TestContentLengthInputStream { @@ -56,7 +56,7 @@ void testBasics() throws IOException { outputStream.write(buffer, 0, len); final String result = new String(outputStream.toByteArray(), StandardCharsets.US_ASCII); - Assertions.assertEquals("1234567890", result); + Assertions.assertThat(result).isEqualTo("1234567890"); } } @@ -65,16 +65,16 @@ void testSkip() throws IOException { final ByteArrayInputStream inputStream1 = new ByteArrayInputStream(new byte[20]); final SessionInputBuffer inBuffer1 = new SessionInputBufferImpl(16); try (InputStream in1 = new ContentLengthInputStream(inBuffer1, inputStream1, 10L)) { - Assertions.assertEquals(10, in1.skip(10)); - Assertions.assertEquals(-1, in1.read()); + Assertions.assertThat(in1.skip(10)).isEqualTo(10); + Assertions.assertThat(in1.read()).isEqualTo(-1); } final ByteArrayInputStream inputStream2 = new ByteArrayInputStream(new byte[20]); final SessionInputBuffer inBuffer2 = new SessionInputBufferImpl(16); try (InputStream in2 = new ContentLengthInputStream(inBuffer2, inputStream2, 10L)) { in2.read(); - Assertions.assertEquals(9, in2.skip(10)); - Assertions.assertEquals(-1, in2.read()); + Assertions.assertThat(in2.skip(10)).isEqualTo(9); + Assertions.assertThat(in2.read()).isEqualTo(-1); } final ByteArrayInputStream inputStream3 = new ByteArrayInputStream(new byte[20]); @@ -82,16 +82,16 @@ void testSkip() throws IOException { try (InputStream in3 = new ContentLengthInputStream(inBuffer3, inputStream3, 2L)) { in3.read(); in3.read(); - Assertions.assertTrue(in3.skip(10) <= 0); - Assertions.assertEquals(0, in3.skip(-1)); - Assertions.assertEquals(-1, in3.read()); + Assertions.assertThat(in3.skip(10) <= 0).isTrue(); + Assertions.assertThat(in3.skip(-1)).isEqualTo(0); + Assertions.assertThat(in3.read()).isEqualTo(-1); } final ByteArrayInputStream inputStream4 = new ByteArrayInputStream(new byte[20]); final SessionInputBuffer inBuffer4 = new SessionInputBufferImpl(16); try (InputStream in4 = new ContentLengthInputStream(inBuffer4, inputStream4, 10L)) { - Assertions.assertEquals(5, in4.skip(5)); - Assertions.assertEquals(5, in4.read(new byte[20])); + Assertions.assertThat(in4.skip(5)).isEqualTo(5); + Assertions.assertThat(in4.read(new byte[20])).isEqualTo(5); } } @@ -100,9 +100,9 @@ void testAvailable() throws IOException { final ByteArrayInputStream inputStream = new ByteArrayInputStream(new byte[] {1, 2, 3}); final SessionInputBuffer inBuffer = new SessionInputBufferImpl(16); try (InputStream in = new ContentLengthInputStream(inBuffer, inputStream, 3L)) { - Assertions.assertEquals(0, in.available()); + Assertions.assertThat(in.available()).isEqualTo(0); in.read(); - Assertions.assertEquals(2, in.available()); + Assertions.assertThat(in.available()).isEqualTo(2); } } @@ -114,11 +114,15 @@ void testClose() throws IOException { final InputStream in = new ContentLengthInputStream(inBuffer, inputStream, 16L); in.close(); in.close(); - Assertions.assertThrows(StreamClosedException.class, in::read); + Assertions.assertThatThrownBy(in::read).isInstanceOf(StreamClosedException.class); final byte[] tmp = new byte[10]; - Assertions.assertThrows(StreamClosedException.class, () -> in.read(tmp)); - Assertions.assertThrows(StreamClosedException.class, () -> in.read(tmp, 0, tmp.length)); - Assertions.assertEquals('-', inBuffer.read(inputStream)); + Assertions.assertThatThrownBy(() -> + in.read(tmp)) + .isInstanceOf(StreamClosedException.class); + Assertions.assertThatThrownBy(() -> + in.read(tmp, 0, tmp.length)) + .isInstanceOf(StreamClosedException.class); + Assertions.assertThat(inBuffer.read(inputStream)).isEqualTo('-'); } @Test @@ -129,10 +133,16 @@ void testTruncatedContent() throws IOException { final InputStream in = new ContentLengthInputStream(inBuffer, inputStream, 32L); final byte[] tmp = new byte[32]; final int byteRead = in.read(tmp); - Assertions.assertEquals(16, byteRead); - Assertions.assertThrows(ConnectionClosedException.class, () -> in.read(tmp)); - Assertions.assertThrows(ConnectionClosedException.class, () -> in.read()); - Assertions.assertThrows(ConnectionClosedException.class, () -> in.close()); + Assertions.assertThat(byteRead).isEqualTo(16); + Assertions.assertThatThrownBy(() -> + in.read(tmp)) + .isInstanceOf(ConnectionClosedException.class); + Assertions.assertThatThrownBy(() -> + in.read()) + .isInstanceOf(ConnectionClosedException.class); + Assertions.assertThatThrownBy(() -> + in.close()) + .isInstanceOf(ConnectionClosedException.class); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/impl/io/TestContentLengthOutputStream.java b/httpcore5/src/test/java/org/apache/hc/core5/http/impl/io/TestContentLengthOutputStream.java index 638dce2df8..6219630cbf 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/impl/io/TestContentLengthOutputStream.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/impl/io/TestContentLengthOutputStream.java @@ -32,7 +32,7 @@ import org.apache.hc.core5.http.StreamClosedException; import org.apache.hc.core5.http.io.SessionOutputBuffer; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class TestContentLengthOutputStream { @@ -54,7 +54,7 @@ void testBasics() throws Exception { out.flush(); } final byte[] data = outputStream.toByteArray(); - Assertions.assertEquals(15, data.length); + Assertions.assertThat(data.length).isEqualTo(15); } @Test @@ -65,8 +65,12 @@ void testClose() throws Exception { out.close(); out.close(); final byte[] tmp = new byte[10]; - Assertions.assertThrows(StreamClosedException.class, () -> out.write(tmp)); - Assertions.assertThrows(StreamClosedException.class, () -> out.write(1)); + Assertions.assertThatThrownBy(() -> + out.write(tmp)) + .isInstanceOf(StreamClosedException.class); + Assertions.assertThatThrownBy(() -> + out.write(1)) + .isInstanceOf(StreamClosedException.class); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/impl/io/TestDefaultBHttpClientConnection.java b/httpcore5/src/test/java/org/apache/hc/core5/http/impl/io/TestDefaultBHttpClientConnection.java index 3ed592e956..635a942634 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/impl/io/TestDefaultBHttpClientConnection.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/impl/io/TestDefaultBHttpClientConnection.java @@ -46,7 +46,7 @@ import org.apache.hc.core5.http.io.entity.ByteArrayEntity; import org.apache.hc.core5.http.io.entity.StringEntity; import org.apache.hc.core5.http.message.BasicClassicHttpRequest; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; @@ -74,8 +74,8 @@ void prepareMocks() { @Test void testBasics() { - Assertions.assertFalse(conn.isOpen()); - Assertions.assertEquals("[Not bound]", conn.toString()); + Assertions.assertThat(conn.isOpen()).isFalse(); + Assertions.assertThat(conn.toString()).isEqualTo("[Not bound]"); } @Test @@ -86,13 +86,13 @@ void testReadResponseHead() throws Exception { conn.bind(socket); - Assertions.assertEquals(0, conn.getEndpointDetails().getResponseCount()); + Assertions.assertThat(conn.getEndpointDetails().getResponseCount()).isEqualTo(0); final ClassicHttpResponse response = conn.receiveResponseHeader(); - Assertions.assertNotNull(response); - Assertions.assertEquals(200, response.getCode()); - Assertions.assertTrue(response.containsHeader("User-Agent")); - Assertions.assertEquals(1, conn.getEndpointDetails().getResponseCount()); + Assertions.assertThat(response).isNotNull(); + Assertions.assertThat(response.getCode()).isEqualTo(200); + Assertions.assertThat(response.containsHeader("User-Agent")).isTrue(); + Assertions.assertThat(conn.getEndpointDetails().getResponseCount()).isEqualTo(1); } @Test @@ -103,28 +103,28 @@ void testReadResponseEntityWithoutContentLength() throws Exception { conn.bind(socket); - Assertions.assertEquals(0, conn.getEndpointDetails().getResponseCount()); + Assertions.assertThat(conn.getEndpointDetails().getResponseCount()).isEqualTo(0); final ClassicHttpResponse response = conn.receiveResponseHeader(); - Assertions.assertNotNull(response); - Assertions.assertEquals(200, response.getCode()); - Assertions.assertTrue(response.containsHeader("Server")); - Assertions.assertEquals(1, conn.getEndpointDetails().getResponseCount()); + Assertions.assertThat(response).isNotNull(); + Assertions.assertThat(response.getCode()).isEqualTo(200); + Assertions.assertThat(response.containsHeader("Server")).isTrue(); + Assertions.assertThat(conn.getEndpointDetails().getResponseCount()).isEqualTo(1); conn.receiveResponseEntity(response); final HttpEntity entity = response.getEntity(); - Assertions.assertNotNull(entity); - Assertions.assertEquals(-1, entity.getContentLength()); - Assertions.assertEquals(1, conn.getEndpointDetails().getResponseCount()); + Assertions.assertThat(entity).isNotNull(); + Assertions.assertThat(entity.getContentLength()).isEqualTo(-1); + Assertions.assertThat(conn.getEndpointDetails().getResponseCount()).isEqualTo(1); final InputStream content = entity.getContent(); - Assertions.assertNotNull(content); - Assertions.assertEquals(3, content.available()); - Assertions.assertEquals('1', content.read()); - Assertions.assertEquals('2', content.read()); - Assertions.assertEquals('3', content.read()); + Assertions.assertThat(content).isNotNull(); + Assertions.assertThat(content.available()).isEqualTo(3); + Assertions.assertThat(content.read()).isEqualTo((int) '1'); + Assertions.assertThat(content.read()).isEqualTo((int) '2'); + Assertions.assertThat(content.read()).isEqualTo((int) '3'); } @Test @@ -135,24 +135,24 @@ void testReadResponseEntityWithContentLength() throws Exception { conn.bind(socket); - Assertions.assertEquals(0, conn.getEndpointDetails().getResponseCount()); + Assertions.assertThat(conn.getEndpointDetails().getResponseCount()).isEqualTo(0); final ClassicHttpResponse response = conn.receiveResponseHeader(); - Assertions.assertNotNull(response); - Assertions.assertEquals(200, response.getCode()); - Assertions.assertTrue(response.containsHeader("Server")); - Assertions.assertEquals(1, conn.getEndpointDetails().getResponseCount()); + Assertions.assertThat(response).isNotNull(); + Assertions.assertThat(response.getCode()).isEqualTo(200); + Assertions.assertThat(response.containsHeader("Server")).isTrue(); + Assertions.assertThat(conn.getEndpointDetails().getResponseCount()).isEqualTo(1); conn.receiveResponseEntity(response); final HttpEntity entity = response.getEntity(); - Assertions.assertNotNull(entity); - Assertions.assertEquals(3, entity.getContentLength()); - Assertions.assertEquals(1, conn.getEndpointDetails().getResponseCount()); + Assertions.assertThat(entity).isNotNull(); + Assertions.assertThat(entity.getContentLength()).isEqualTo(3); + Assertions.assertThat(conn.getEndpointDetails().getResponseCount()).isEqualTo(1); final InputStream content = entity.getContent(); - Assertions.assertNotNull(content); - Assertions.assertInstanceOf(ContentLengthInputStream.class, content); + Assertions.assertThat(content).isNotNull(); + Assertions.assertThat(content).isInstanceOf(ContentLengthInputStream.class); } @Test @@ -164,25 +164,25 @@ void testReadResponseEntityChunkCoded() throws Exception { conn.bind(socket); - Assertions.assertEquals(0, conn.getEndpointDetails().getResponseCount()); + Assertions.assertThat(conn.getEndpointDetails().getResponseCount()).isEqualTo(0); final ClassicHttpResponse response = conn.receiveResponseHeader(); - Assertions.assertNotNull(response); - Assertions.assertEquals(200, response.getCode()); - Assertions.assertTrue(response.containsHeader("Server")); - Assertions.assertEquals(1, conn.getEndpointDetails().getResponseCount()); + Assertions.assertThat(response).isNotNull(); + Assertions.assertThat(response.getCode()).isEqualTo(200); + Assertions.assertThat(response.containsHeader("Server")).isTrue(); + Assertions.assertThat(conn.getEndpointDetails().getResponseCount()).isEqualTo(1); conn.receiveResponseEntity(response); final HttpEntity entity = response.getEntity(); - Assertions.assertNotNull(entity); - Assertions.assertEquals(-1, entity.getContentLength()); - Assertions.assertTrue(entity.isChunked()); - Assertions.assertEquals(1, conn.getEndpointDetails().getResponseCount()); + Assertions.assertThat(entity).isNotNull(); + Assertions.assertThat(entity.getContentLength()).isEqualTo(-1); + Assertions.assertThat(entity.isChunked()).isTrue(); + Assertions.assertThat(conn.getEndpointDetails().getResponseCount()).isEqualTo(1); final InputStream content = entity.getContent(); - Assertions.assertNotNull(content); - Assertions.assertInstanceOf(ChunkedInputStream.class, content); + Assertions.assertThat(content).isNotNull(); + Assertions.assertThat(content).isInstanceOf(ChunkedInputStream.class); } @Test @@ -193,17 +193,17 @@ void testReadResponseEntityIdentity() throws Exception { conn.bind(socket); - Assertions.assertEquals(0, conn.getEndpointDetails().getResponseCount()); + Assertions.assertThat(conn.getEndpointDetails().getResponseCount()).isEqualTo(0); final ClassicHttpResponse response = conn.receiveResponseHeader(); - Assertions.assertNotNull(response); - Assertions.assertEquals(200, response.getCode()); - Assertions.assertTrue(response.containsHeader("Server")); - Assertions.assertEquals(1, conn.getEndpointDetails().getResponseCount()); + Assertions.assertThat(response).isNotNull(); + Assertions.assertThat(response.getCode()).isEqualTo(200); + Assertions.assertThat(response.containsHeader("Server")).isTrue(); + Assertions.assertThat(conn.getEndpointDetails().getResponseCount()).isEqualTo(1); - Assertions.assertThrows(NotImplementedException.class, () -> - conn.receiveResponseEntity(response)); + Assertions.assertThatThrownBy(() -> conn.receiveResponseEntity(response)) + .isInstanceOf(NotImplementedException.class); } @Test @@ -214,22 +214,22 @@ void testReadResponseNoEntity() throws Exception { conn.bind(socket); - Assertions.assertEquals(0, conn.getEndpointDetails().getResponseCount()); + Assertions.assertThat(conn.getEndpointDetails().getResponseCount()).isEqualTo(0); final ClassicHttpResponse response = conn.receiveResponseHeader(); - Assertions.assertNotNull(response); - Assertions.assertEquals(200, response.getCode()); - Assertions.assertTrue(response.containsHeader("Server")); - Assertions.assertEquals(1, conn.getEndpointDetails().getResponseCount()); + Assertions.assertThat(response).isNotNull(); + Assertions.assertThat(response.getCode()).isEqualTo(200); + Assertions.assertThat(response.containsHeader("Server")).isTrue(); + Assertions.assertThat(conn.getEndpointDetails().getResponseCount()).isEqualTo(1); conn.receiveResponseEntity(response); final HttpEntity entity = response.getEntity(); - Assertions.assertNotNull(entity); + Assertions.assertThat(entity).isNotNull(); final InputStream content = entity.getContent(); - Assertions.assertNotNull(content); - Assertions.assertInstanceOf(IdentityInputStream.class, content); + Assertions.assertThat(content).isNotNull(); + Assertions.assertThat(content).isInstanceOf(IdentityInputStream.class); } @Test @@ -261,12 +261,12 @@ void testEarlyResponseDoesNotAbortConnection() throws Exception { request.setEntity(new ByteArrayEntity(new byte[16384], ContentType.TEXT_PLAIN, true)); conn.sendRequestHeader(request); - Assertions.assertDoesNotThrow(() -> conn.sendRequestEntity(request)); - Assertions.assertTrue(conn.isOpen()); - Assertions.assertFalse(conn.isConsistent()); - Assertions.assertEquals(400, conn.receiveResponseHeader().getCode()); - Assertions.assertFalse(new String(output.toByteArray(), StandardCharsets.US_ASCII) - .endsWith("0\r\n\r\n")); + Assertions.assertThatCode(() -> conn.sendRequestEntity(request)).doesNotThrowAnyException(); + Assertions.assertThat(conn.isOpen()).isTrue(); + Assertions.assertThat(conn.isConsistent()).isFalse(); + Assertions.assertThat(conn.receiveResponseHeader().getCode()).isEqualTo(400); + Assertions.assertThat(new String(output.toByteArray(), StandardCharsets.US_ASCII)) + .doesNotEndWith("0\r\n\r\n"); } @Test @@ -286,11 +286,13 @@ void testChunkedEntityFailureDoesNotTerminateMessage() throws Exception { request.addHeader("Transfer-Encoding", "chunked"); request.setEntity(entity); conn.sendRequestHeader(request); - Assertions.assertThrows(EOFException.class, () -> conn.sendRequestEntity(request)); - Assertions.assertFalse(conn.isConsistent()); - Assertions.assertFalse(conn.isOpen()); - Assertions.assertFalse(new String(outStream.toByteArray(), StandardCharsets.US_ASCII) - .endsWith("0\r\n\r\n")); + Assertions.assertThatThrownBy(() -> + conn.sendRequestEntity(request)) + .isInstanceOf(EOFException.class); + Assertions.assertThat(conn.isConsistent()).isFalse(); + Assertions.assertThat(conn.isOpen()).isFalse(); + Assertions.assertThat(new String(outStream.toByteArray(), StandardCharsets.US_ASCII)) + .doesNotEndWith("0\r\n\r\n"); } @Test @@ -300,7 +302,7 @@ void testWriteRequestHead() throws Exception { conn.bind(socket); - Assertions.assertEquals(0, conn.getEndpointDetails().getRequestCount()); + Assertions.assertThat(conn.getEndpointDetails().getRequestCount()).isEqualTo(0); final ClassicHttpRequest request = new BasicClassicHttpRequest(Method.GET, "/stuff"); request.addHeader("User-Agent", "test"); @@ -308,9 +310,9 @@ void testWriteRequestHead() throws Exception { conn.sendRequestHeader(request); conn.flush(); - Assertions.assertEquals(1, conn.getEndpointDetails().getRequestCount()); + Assertions.assertThat(conn.getEndpointDetails().getRequestCount()).isEqualTo(1); final String s = new String(outStream.toByteArray(), StandardCharsets.US_ASCII); - Assertions.assertEquals("GET /stuff HTTP/1.1\r\nUser-Agent: test\r\n\r\n", s); + Assertions.assertThat(s).isEqualTo("GET /stuff HTTP/1.1\r\nUser-Agent: test\r\n\r\n"); } @Test @@ -320,7 +322,7 @@ void testWriteRequestEntityWithContentLength() throws Exception { conn.bind(socket); - Assertions.assertEquals(0, conn.getEndpointDetails().getRequestCount()); + Assertions.assertThat(conn.getEndpointDetails().getRequestCount()).isEqualTo(0); final ClassicHttpRequest request = new BasicClassicHttpRequest(Method.POST, "/stuff"); request.addHeader("User-Agent", "test"); @@ -331,9 +333,9 @@ void testWriteRequestEntityWithContentLength() throws Exception { conn.sendRequestEntity(request); conn.flush(); - Assertions.assertEquals(1, conn.getEndpointDetails().getRequestCount()); + Assertions.assertThat(conn.getEndpointDetails().getRequestCount()).isEqualTo(1); final String s = new String(outStream.toByteArray(), StandardCharsets.US_ASCII); - Assertions.assertEquals("POST /stuff HTTP/1.1\r\nUser-Agent: test\r\nContent-Length: 3\r\n\r\n123", s); + Assertions.assertThat(s).isEqualTo("POST /stuff HTTP/1.1\r\nUser-Agent: test\r\nContent-Length: 3\r\n\r\n123"); } @Test @@ -343,7 +345,7 @@ void testWriteRequestEntityChunkCoded() throws Exception { conn.bind(socket); - Assertions.assertEquals(0, conn.getEndpointDetails().getRequestCount()); + Assertions.assertThat(conn.getEndpointDetails().getRequestCount()).isEqualTo(0); final ClassicHttpRequest request = new BasicClassicHttpRequest(Method.POST, "/stuff"); request.addHeader("User-Agent", "test"); @@ -354,10 +356,10 @@ void testWriteRequestEntityChunkCoded() throws Exception { conn.sendRequestEntity(request); conn.flush(); - Assertions.assertEquals(1, conn.getEndpointDetails().getRequestCount()); + Assertions.assertThat(conn.getEndpointDetails().getRequestCount()).isEqualTo(1); final String s = new String(outStream.toByteArray(), StandardCharsets.US_ASCII); - Assertions.assertEquals("POST /stuff HTTP/1.1\r\nUser-Agent: test\r\nTransfer-Encoding: " + - "chunked\r\n\r\n3\r\n123\r\n0\r\n\r\n", s); + Assertions.assertThat(s).isEqualTo("POST /stuff HTTP/1.1\r\nUser-Agent: test\r\nTransfer-Encoding: " + + "chunked\r\n\r\n3\r\n123\r\n0\r\n\r\n"); } @Test @@ -367,15 +369,15 @@ void testWriteRequestEntityNoContentLength() throws Exception { conn.bind(socket); - Assertions.assertEquals(0, conn.getEndpointDetails().getRequestCount()); + Assertions.assertThat(conn.getEndpointDetails().getRequestCount()).isEqualTo(0); final ClassicHttpRequest request = new BasicClassicHttpRequest(Method.POST, "/stuff"); request.addHeader("User-Agent", "test"); request.setEntity(new StringEntity("123", ContentType.TEXT_PLAIN)); conn.sendRequestHeader(request); - Assertions.assertThrows(LengthRequiredException.class, () -> - conn.sendRequestEntity(request)); + Assertions.assertThatThrownBy(() -> conn.sendRequestEntity(request)) + .isInstanceOf(LengthRequiredException.class); } @Test @@ -385,7 +387,7 @@ void testWriteRequestNoEntity() throws Exception { conn.bind(socket); - Assertions.assertEquals(0, conn.getEndpointDetails().getRequestCount()); + Assertions.assertThat(conn.getEndpointDetails().getRequestCount()).isEqualTo(0); final ClassicHttpRequest request = new BasicClassicHttpRequest(Method.POST, "/stuff"); request.addHeader("User-Agent", "test"); @@ -394,9 +396,9 @@ void testWriteRequestNoEntity() throws Exception { conn.sendRequestEntity(request); conn.flush(); - Assertions.assertEquals(1, conn.getEndpointDetails().getRequestCount()); + Assertions.assertThat(conn.getEndpointDetails().getRequestCount()).isEqualTo(1); final String s = new String(outStream.toByteArray(), StandardCharsets.US_ASCII); - Assertions.assertEquals("POST /stuff HTTP/1.1\r\nUser-Agent: test\r\n\r\n", s); + Assertions.assertThat(s).isEqualTo("POST /stuff HTTP/1.1\r\nUser-Agent: test\r\n\r\n"); } @Test @@ -406,7 +408,7 @@ void testTerminateRequestChunkedEntity() throws Exception { conn.bind(socket); - Assertions.assertEquals(0, conn.getEndpointDetails().getRequestCount()); + Assertions.assertThat(conn.getEndpointDetails().getRequestCount()).isEqualTo(0); final ClassicHttpRequest request = new BasicClassicHttpRequest(Method.POST, "/stuff"); request.addHeader("User-Agent", "test"); @@ -419,11 +421,11 @@ void testTerminateRequestChunkedEntity() throws Exception { conn.terminateRequest(request); conn.flush(); - Assertions.assertEquals(1, conn.getEndpointDetails().getRequestCount()); + Assertions.assertThat(conn.getEndpointDetails().getRequestCount()).isEqualTo(1); final String s = new String(outStream.toByteArray(), StandardCharsets.US_ASCII); - Assertions.assertEquals("POST /stuff HTTP/1.1\r\nUser-Agent: test\r\nTransfer-Encoding: " + - "chunked\r\n\r\n0\r\n\r\n", s); - Assertions.assertTrue(conn.isConsistent()); + Assertions.assertThat(s).isEqualTo("POST /stuff HTTP/1.1\r\nUser-Agent: test\r\nTransfer-Encoding: " + + "chunked\r\n\r\n0\r\n\r\n"); + Assertions.assertThat(conn.isConsistent()).isTrue(); } @Test @@ -433,7 +435,7 @@ void testTerminateRequestContentLengthShort() throws Exception { conn.bind(socket); - Assertions.assertEquals(0, conn.getEndpointDetails().getRequestCount()); + Assertions.assertThat(conn.getEndpointDetails().getRequestCount()).isEqualTo(0); final ClassicHttpRequest request = new BasicClassicHttpRequest(Method.POST, "/stuff"); request.addHeader("User-Agent", "test"); @@ -445,11 +447,11 @@ void testTerminateRequestContentLengthShort() throws Exception { conn.terminateRequest(request); conn.flush(); - Assertions.assertEquals(1, conn.getEndpointDetails().getRequestCount()); + Assertions.assertThat(conn.getEndpointDetails().getRequestCount()).isEqualTo(1); final String s = new String(outStream.toByteArray(), StandardCharsets.US_ASCII); - Assertions.assertEquals("POST /stuff HTTP/1.1\r\nUser-Agent: test\r\nContent-Length: " + - "3\r\n\r\n123", s); - Assertions.assertTrue(conn.isConsistent()); + Assertions.assertThat(s).isEqualTo("POST /stuff HTTP/1.1\r\nUser-Agent: test\r\nContent-Length: " + + "3\r\n\r\n123"); + Assertions.assertThat(conn.isConsistent()).isTrue(); } @Test @@ -459,7 +461,7 @@ void testTerminateRequestContentLengthLong() throws Exception { conn.bind(socket); - Assertions.assertEquals(0, conn.getEndpointDetails().getRequestCount()); + Assertions.assertThat(conn.getEndpointDetails().getRequestCount()).isEqualTo(0); final ClassicHttpRequest request = new BasicClassicHttpRequest(Method.POST, "/stuff"); request.addHeader("User-Agent", "test"); @@ -471,11 +473,11 @@ void testTerminateRequestContentLengthLong() throws Exception { conn.terminateRequest(request); conn.flush(); - Assertions.assertEquals(1, conn.getEndpointDetails().getRequestCount()); + Assertions.assertThat(conn.getEndpointDetails().getRequestCount()).isEqualTo(1); final String s = new String(outStream.toByteArray(), StandardCharsets.US_ASCII); - Assertions.assertEquals("POST /stuff HTTP/1.1\r\nUser-Agent: test\r\nContent-Length: " + - "3000\r\n\r\n", s); - Assertions.assertFalse(conn.isConsistent()); + Assertions.assertThat(s).isEqualTo("POST /stuff HTTP/1.1\r\nUser-Agent: test\r\nContent-Length: " + + "3000\r\n\r\n"); + Assertions.assertThat(conn.isConsistent()).isFalse(); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/impl/io/TestDefaultBHttpServerConnection.java b/httpcore5/src/test/java/org/apache/hc/core5/http/impl/io/TestDefaultBHttpServerConnection.java index a4f3b7a6b3..4ac1d13947 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/impl/io/TestDefaultBHttpServerConnection.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/impl/io/TestDefaultBHttpServerConnection.java @@ -46,7 +46,7 @@ import org.apache.hc.core5.http.io.entity.StringEntity; import org.apache.hc.core5.http.message.BasicClassicHttpResponse; import org.apache.hc.core5.util.Timeout; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; @@ -74,8 +74,8 @@ void prepareMocks() { @Test void testBasics() { - Assertions.assertFalse(conn.isOpen()); - Assertions.assertEquals("[Not bound]", conn.toString()); + Assertions.assertThat(conn.isOpen()).isFalse(); + Assertions.assertThat(conn.toString()).isEqualTo("[Not bound]"); } @Test @@ -86,19 +86,19 @@ void testReadRequestHead() throws Exception { conn.bind(socket); - Assertions.assertEquals(0, conn.getEndpointDetails().getRequestCount()); + Assertions.assertThat(conn.getEndpointDetails().getRequestCount()).isEqualTo(0); final ClassicHttpRequest request = conn.receiveRequestHeader(); - Assertions.assertNotNull(request); - Assertions.assertEquals("/", request.getPath()); - Assertions.assertEquals(Method.GET.name(), request.getMethod()); - Assertions.assertTrue(request.containsHeader("User-Agent")); - Assertions.assertEquals(1, conn.getEndpointDetails().getRequestCount()); - Assertions.assertNull(conn.getEndpointDetails().getRemoteAddress()); - Assertions.assertNull(conn.getEndpointDetails().getLocalAddress()); - - Assertions.assertEquals(Timeout.ofMilliseconds(0), conn.getEndpointDetails().getSocketTimeout()); - Assertions.assertEquals("null<->null", conn.getEndpointDetails().toString()); + Assertions.assertThat(request).isNotNull(); + Assertions.assertThat(request.getPath()).isEqualTo("/"); + Assertions.assertThat(request.getMethod()).isEqualTo(Method.GET.name()); + Assertions.assertThat(request.containsHeader("User-Agent")).isTrue(); + Assertions.assertThat(conn.getEndpointDetails().getRequestCount()).isEqualTo(1); + Assertions.assertThat(conn.getEndpointDetails().getRemoteAddress()).isNull(); + Assertions.assertThat(conn.getEndpointDetails().getLocalAddress()).isNull(); + + Assertions.assertThat(conn.getEndpointDetails().getSocketTimeout()).isEqualTo(Timeout.ofMilliseconds(0)); + Assertions.assertThat(conn.getEndpointDetails().toString()).isEqualTo("null<->null"); } @Test @@ -109,26 +109,26 @@ void testReadRequestEntityWithContentLength() throws Exception { conn.bind(socket); - Assertions.assertEquals(0, conn.getEndpointDetails().getRequestCount()); + Assertions.assertThat(conn.getEndpointDetails().getRequestCount()).isEqualTo(0); final ClassicHttpRequest request = conn.receiveRequestHeader(); - Assertions.assertNotNull(request); - Assertions.assertEquals("/", request.getPath()); - Assertions.assertEquals(Method.POST.name(), request.getMethod()); - Assertions.assertTrue(request.containsHeader("User-Agent")); - Assertions.assertNull(request.getEntity()); - Assertions.assertEquals(1, conn.getEndpointDetails().getRequestCount()); + Assertions.assertThat(request).isNotNull(); + Assertions.assertThat(request.getPath()).isEqualTo("/"); + Assertions.assertThat(request.getMethod()).isEqualTo(Method.POST.name()); + Assertions.assertThat(request.containsHeader("User-Agent")).isTrue(); + Assertions.assertThat(request.getEntity()).isNull(); + Assertions.assertThat(conn.getEndpointDetails().getRequestCount()).isEqualTo(1); conn.receiveRequestEntity(request); final HttpEntity entity = request.getEntity(); - Assertions.assertNotNull(entity); - Assertions.assertEquals(3, entity.getContentLength()); - Assertions.assertEquals(1, conn.getEndpointDetails().getRequestCount()); + Assertions.assertThat(entity).isNotNull(); + Assertions.assertThat(entity.getContentLength()).isEqualTo(3); + Assertions.assertThat(conn.getEndpointDetails().getRequestCount()).isEqualTo(1); final InputStream content = entity.getContent(); - Assertions.assertNotNull(content); - Assertions.assertInstanceOf(ContentLengthInputStream.class, content); + Assertions.assertThat(content).isNotNull(); + Assertions.assertThat(content).isInstanceOf(ContentLengthInputStream.class); } @Test @@ -140,27 +140,27 @@ void testReadRequestEntityChunckCoded() throws Exception { conn.bind(socket); - Assertions.assertEquals(0, conn.getEndpointDetails().getRequestCount()); + Assertions.assertThat(conn.getEndpointDetails().getRequestCount()).isEqualTo(0); final ClassicHttpRequest request = conn.receiveRequestHeader(); - Assertions.assertNotNull(request); - Assertions.assertEquals("/stuff", request.getPath()); - Assertions.assertEquals(Method.POST.name(), request.getMethod()); - Assertions.assertTrue(request.containsHeader("User-Agent")); - Assertions.assertNull(request.getEntity()); - Assertions.assertEquals(1, conn.getEndpointDetails().getRequestCount()); + Assertions.assertThat(request).isNotNull(); + Assertions.assertThat(request.getPath()).isEqualTo("/stuff"); + Assertions.assertThat(request.getMethod()).isEqualTo(Method.POST.name()); + Assertions.assertThat(request.containsHeader("User-Agent")).isTrue(); + Assertions.assertThat(request.getEntity()).isNull(); + Assertions.assertThat(conn.getEndpointDetails().getRequestCount()).isEqualTo(1); conn.receiveRequestEntity(request); final HttpEntity entity = request.getEntity(); - Assertions.assertNotNull(entity); - Assertions.assertEquals(-1, entity.getContentLength()); - Assertions.assertTrue(entity.isChunked()); - Assertions.assertEquals(1, conn.getEndpointDetails().getRequestCount()); + Assertions.assertThat(entity).isNotNull(); + Assertions.assertThat(entity.getContentLength()).isEqualTo(-1); + Assertions.assertThat(entity.isChunked()).isTrue(); + Assertions.assertThat(conn.getEndpointDetails().getRequestCount()).isEqualTo(1); final InputStream content = entity.getContent(); - Assertions.assertNotNull(content); - Assertions.assertInstanceOf(ChunkedInputStream.class, content); + Assertions.assertThat(content).isNotNull(); + Assertions.assertThat(content).isInstanceOf(ChunkedInputStream.class); } @Test @@ -172,19 +172,19 @@ void testReadRequestEntityIdentity() throws Exception { conn.bind(socket); - Assertions.assertEquals(0, conn.getEndpointDetails().getRequestCount()); + Assertions.assertThat(conn.getEndpointDetails().getRequestCount()).isEqualTo(0); final ClassicHttpRequest request = conn.receiveRequestHeader(); - Assertions.assertNotNull(request); - Assertions.assertEquals("/stuff", request.getPath()); - Assertions.assertEquals(Method.POST.name(), request.getMethod()); - Assertions.assertTrue(request.containsHeader("User-Agent")); - Assertions.assertNull(request.getEntity()); - Assertions.assertEquals(1, conn.getEndpointDetails().getRequestCount()); + Assertions.assertThat(request).isNotNull(); + Assertions.assertThat(request.getPath()).isEqualTo("/stuff"); + Assertions.assertThat(request.getMethod()).isEqualTo(Method.POST.name()); + Assertions.assertThat(request.containsHeader("User-Agent")).isTrue(); + Assertions.assertThat(request.getEntity()).isNull(); + Assertions.assertThat(conn.getEndpointDetails().getRequestCount()).isEqualTo(1); - Assertions.assertThrows(ProtocolException.class, () -> - conn.receiveRequestEntity(request)); + Assertions.assertThatThrownBy(() -> + conn.receiveRequestEntity(request)).isInstanceOf(ProtocolException.class); } @Test @@ -195,21 +195,21 @@ void testReadRequestNoEntity() throws Exception { conn.bind(socket); - Assertions.assertEquals(0, conn.getEndpointDetails().getRequestCount()); + Assertions.assertThat(conn.getEndpointDetails().getRequestCount()).isEqualTo(0); final ClassicHttpRequest request = conn.receiveRequestHeader(); - Assertions.assertNotNull(request); - Assertions.assertEquals("/stuff", request.getPath()); - Assertions.assertEquals(Method.POST.name(), request.getMethod()); - Assertions.assertTrue(request.containsHeader("User-Agent")); - Assertions.assertNull(request.getEntity()); - Assertions.assertEquals(1, conn.getEndpointDetails().getRequestCount()); + Assertions.assertThat(request).isNotNull(); + Assertions.assertThat(request.getPath()).isEqualTo("/stuff"); + Assertions.assertThat(request.getMethod()).isEqualTo(Method.POST.name()); + Assertions.assertThat(request.containsHeader("User-Agent")).isTrue(); + Assertions.assertThat(request.getEntity()).isNull(); + Assertions.assertThat(conn.getEndpointDetails().getRequestCount()).isEqualTo(1); conn.receiveRequestEntity(request); final HttpEntity entity = request.getEntity(); - Assertions.assertNull(entity); + Assertions.assertThat(entity).isNull(); } @Test @@ -229,10 +229,11 @@ void testChunkedEntityFailureDoesNotTerminateMessage() throws Exception { response.addHeader("Transfer-Encoding", "chunked"); response.setEntity(entity); conn.sendResponseHeader(response); - Assertions.assertThrows(EOFException.class, () -> conn.sendResponseEntity(response)); - Assertions.assertFalse(conn.isOpen()); - Assertions.assertFalse(new String(outStream.toByteArray(), StandardCharsets.US_ASCII) - .endsWith("0\r\n\r\n")); + Assertions.assertThatThrownBy(() -> conn.sendResponseEntity(response)) + .isInstanceOf(EOFException.class); + Assertions.assertThat(conn.isOpen()).isFalse(); + Assertions.assertThat(new String(outStream.toByteArray(), StandardCharsets.US_ASCII) + .endsWith("0\r\n\r\n")).isFalse(); } @Test @@ -242,7 +243,7 @@ void testWriteResponseHead() throws Exception { conn.bind(socket); - Assertions.assertEquals(0, conn.getEndpointDetails().getResponseCount()); + Assertions.assertThat(conn.getEndpointDetails().getResponseCount()).isEqualTo(0); final ClassicHttpResponse response = new BasicClassicHttpResponse(200, "OK"); response.addHeader("User-Agent", "test"); @@ -250,9 +251,9 @@ void testWriteResponseHead() throws Exception { conn.sendResponseHeader(response); conn.flush(); - Assertions.assertEquals(1, conn.getEndpointDetails().getResponseCount()); + Assertions.assertThat(conn.getEndpointDetails().getResponseCount()).isEqualTo(1); final String s = new String(outStream.toByteArray(), StandardCharsets.US_ASCII); - Assertions.assertEquals("HTTP/1.1 200 OK\r\nUser-Agent: test\r\n\r\n", s); + Assertions.assertThat(s).isEqualTo("HTTP/1.1 200 OK\r\nUser-Agent: test\r\n\r\n"); } @Test @@ -262,16 +263,16 @@ void testWriteResponse100Head() throws Exception { conn.bind(socket); - Assertions.assertEquals(0, conn.getEndpointDetails().getResponseCount()); + Assertions.assertThat(conn.getEndpointDetails().getResponseCount()).isEqualTo(0); final ClassicHttpResponse response = new BasicClassicHttpResponse(100, "Go on"); conn.sendResponseHeader(response); conn.flush(); - Assertions.assertEquals(0, conn.getEndpointDetails().getResponseCount()); + Assertions.assertThat(conn.getEndpointDetails().getResponseCount()).isEqualTo(0); final String s = new String(outStream.toByteArray(), StandardCharsets.US_ASCII); - Assertions.assertEquals("HTTP/1.1 100 Go on\r\n\r\n", s); + Assertions.assertThat(s).isEqualTo("HTTP/1.1 100 Go on\r\n\r\n"); } @Test @@ -281,7 +282,7 @@ void testWriteResponseEntityWithContentLength() throws Exception { conn.bind(socket); - Assertions.assertEquals(0, conn.getEndpointDetails().getResponseCount()); + Assertions.assertThat(conn.getEndpointDetails().getResponseCount()).isEqualTo(0); final ClassicHttpResponse response = new BasicClassicHttpResponse(200, "OK"); response.addHeader("Server", "test"); @@ -292,9 +293,9 @@ void testWriteResponseEntityWithContentLength() throws Exception { conn.sendResponseEntity(response); conn.flush(); - Assertions.assertEquals(1, conn.getEndpointDetails().getResponseCount()); + Assertions.assertThat(conn.getEndpointDetails().getResponseCount()).isEqualTo(1); final String s = new String(outStream.toByteArray(), StandardCharsets.US_ASCII); - Assertions.assertEquals("HTTP/1.1 200 OK\r\nServer: test\r\nContent-Length: 3\r\n\r\n123", s); + Assertions.assertThat(s).isEqualTo("HTTP/1.1 200 OK\r\nServer: test\r\nContent-Length: 3\r\n\r\n123"); } @Test @@ -304,7 +305,7 @@ void testWriteResponseEntityChunkCoded() throws Exception { conn.bind(socket); - Assertions.assertEquals(0, conn.getEndpointDetails().getResponseCount()); + Assertions.assertThat(conn.getEndpointDetails().getResponseCount()).isEqualTo(0); final ClassicHttpResponse response = new BasicClassicHttpResponse(200, "OK"); response.addHeader("Server", "test"); @@ -315,10 +316,10 @@ void testWriteResponseEntityChunkCoded() throws Exception { conn.sendResponseEntity(response); conn.flush(); - Assertions.assertEquals(1, conn.getEndpointDetails().getResponseCount()); + Assertions.assertThat(conn.getEndpointDetails().getResponseCount()).isEqualTo(1); final String s = new String(outStream.toByteArray(), StandardCharsets.US_ASCII); - Assertions.assertEquals("HTTP/1.1 200 OK\r\nServer: test\r\nTransfer-Encoding: " + - "chunked\r\n\r\n3\r\n123\r\n0\r\n\r\n", s); + Assertions.assertThat(s).isEqualTo("HTTP/1.1 200 OK\r\nServer: test\r\nTransfer-Encoding: " + + "chunked\r\n\r\n3\r\n123\r\n0\r\n\r\n"); } @Test @@ -328,7 +329,7 @@ void testWriteResponseEntityIdentity() throws Exception { conn.bind(socket); - Assertions.assertEquals(0, conn.getEndpointDetails().getResponseCount()); + Assertions.assertThat(conn.getEndpointDetails().getResponseCount()).isEqualTo(0); final ClassicHttpResponse response = new BasicClassicHttpResponse(200, "OK"); response.addHeader("Server", "test"); @@ -336,8 +337,8 @@ void testWriteResponseEntityIdentity() throws Exception { response.setEntity(new StringEntity("123", ContentType.TEXT_PLAIN)); conn.sendResponseHeader(response); - Assertions.assertThrows(NotImplementedException.class, () -> - conn.sendResponseEntity(response)); + Assertions.assertThatThrownBy(() -> + conn.sendResponseEntity(response)).isInstanceOf(NotImplementedException.class); conn.flush(); } @@ -348,7 +349,7 @@ void testWriteResponseNoEntity() throws Exception { conn.bind(socket); - Assertions.assertEquals(0, conn.getEndpointDetails().getResponseCount()); + Assertions.assertThat(conn.getEndpointDetails().getResponseCount()).isEqualTo(0); final ClassicHttpResponse response = new BasicClassicHttpResponse(200, "OK"); response.addHeader("Server", "test"); @@ -357,9 +358,9 @@ void testWriteResponseNoEntity() throws Exception { conn.sendResponseEntity(response); conn.flush(); - Assertions.assertEquals(1, conn.getEndpointDetails().getResponseCount()); + Assertions.assertThat(conn.getEndpointDetails().getResponseCount()).isEqualTo(1); final String s = new String(outStream.toByteArray(), StandardCharsets.US_ASCII); - Assertions.assertEquals("HTTP/1.1 200 OK\r\nServer: test\r\n\r\n", s); + Assertions.assertThat(s).isEqualTo("HTTP/1.1 200 OK\r\nServer: test\r\n\r\n"); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/impl/io/TestHttpRequestExecutor.java b/httpcore5/src/test/java/org/apache/hc/core5/http/impl/io/TestHttpRequestExecutor.java index c7104dc9f7..31716df25c 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/impl/io/TestHttpRequestExecutor.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/impl/io/TestHttpRequestExecutor.java @@ -27,14 +27,17 @@ package org.apache.hc.core5.http.impl.io; +import java.io.IOException; +import java.util.List; + import org.apache.hc.core5.http.ClassicHttpRequest; import org.apache.hc.core5.http.ClassicHttpResponse; import org.apache.hc.core5.http.HeaderElements; import org.apache.hc.core5.http.HttpEntity; +import org.apache.hc.core5.http.HttpException; import org.apache.hc.core5.http.HttpHeaders; import org.apache.hc.core5.http.HttpResponse; import org.apache.hc.core5.http.Method; -import org.apache.hc.core5.http.HttpException; import org.apache.hc.core5.http.io.HttpClientConnection; import org.apache.hc.core5.http.io.HttpResponseInformationCallback; import org.apache.hc.core5.http.message.BasicClassicHttpRequest; @@ -43,15 +46,12 @@ import org.apache.hc.core5.http.protocol.HttpProcessor; import org.apache.hc.core5.io.CloseMode; import org.apache.hc.core5.util.Timeout; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.mockito.ArgumentCaptor; import org.mockito.ArgumentMatchers; import org.mockito.Mockito; -import java.io.IOException; -import java.util.List; - class TestHttpRequestExecutor { @Test @@ -61,43 +61,43 @@ void testInvalidInput() { final ClassicHttpResponse response = new BasicClassicHttpResponse(200, "OK"); final HttpClientConnection conn = Mockito.mock(HttpClientConnection.class); final HttpProcessor httprocessor = Mockito.mock(HttpProcessor.class); - Assertions.assertThrows(NullPointerException.class, () -> { + Assertions.assertThatThrownBy(() -> { final HttpRequestExecutor executor = new HttpRequestExecutor(); executor.execute(null, conn, context); - }); - Assertions.assertThrows(NullPointerException.class, () -> { + }).isInstanceOf(NullPointerException.class); + Assertions.assertThatThrownBy(() -> { final HttpRequestExecutor executor = new HttpRequestExecutor(); executor.execute(request, null, context); - }); - Assertions.assertThrows(NullPointerException.class, () -> { + }).isInstanceOf(NullPointerException.class); + Assertions.assertThatThrownBy(() -> { final HttpRequestExecutor executor = new HttpRequestExecutor(); executor.execute(request, conn, null); - }); + }).isInstanceOf(NullPointerException.class); - Assertions.assertThrows(NullPointerException.class, () -> { + Assertions.assertThatThrownBy(() -> { final HttpRequestExecutor executor = new HttpRequestExecutor(); executor.preProcess(null, httprocessor, context); - }); - Assertions.assertThrows(NullPointerException.class, () -> { + }).isInstanceOf(NullPointerException.class); + Assertions.assertThatThrownBy(() -> { final HttpRequestExecutor executor = new HttpRequestExecutor(); executor.preProcess(request, null, context); - }); - Assertions.assertThrows(NullPointerException.class, () -> { + }).isInstanceOf(NullPointerException.class); + Assertions.assertThatThrownBy(() -> { final HttpRequestExecutor executor = new HttpRequestExecutor(); executor.preProcess(request, httprocessor, null); - }); - Assertions.assertThrows(NullPointerException.class, () -> { + }).isInstanceOf(NullPointerException.class); + Assertions.assertThatThrownBy(() -> { final HttpRequestExecutor executor = new HttpRequestExecutor(); executor.postProcess(null, httprocessor, context); - }); - Assertions.assertThrows(NullPointerException.class, () -> { + }).isInstanceOf(NullPointerException.class); + Assertions.assertThatThrownBy(() -> { final HttpRequestExecutor executor = new HttpRequestExecutor(); executor.postProcess(response, null, context); - }); - Assertions.assertThrows(NullPointerException.class, () -> { + }).isInstanceOf(NullPointerException.class); + Assertions.assertThatThrownBy(() -> { final HttpRequestExecutor executor = new HttpRequestExecutor(); executor.postProcess(response, httprocessor, null); - }); + }).isInstanceOf(NullPointerException.class); } @Test @@ -124,8 +124,8 @@ void testBasicExecution() throws Exception { executor.postProcess(response, httprocessor, context); Mockito.verify(httprocessor).process(response, response.getEntity(), context); - Assertions.assertSame(request, context.getRequest()); - Assertions.assertSame(response, context.getResponse()); + Assertions.assertThat(context.getRequest()).isSameAs(request); + Assertions.assertThat(context.getResponse()).isSameAs(response); } @Test @@ -157,20 +157,20 @@ void testExecutionSkipIntermediateResponses() throws Exception { final ArgumentCaptor responseCaptor = ArgumentCaptor.forClass(HttpResponse.class); Mockito.verify(callback, Mockito.times(2)).execute(responseCaptor.capture(), ArgumentMatchers.eq(conn), ArgumentMatchers.eq(context)); final List infos = responseCaptor.getAllValues(); - Assertions.assertNotNull(infos); - Assertions.assertEquals(2, infos.size()); + Assertions.assertThat(infos).isNotNull(); + Assertions.assertThat(infos.size()).isEqualTo(2); final HttpResponse info1 = infos.get(0); - Assertions.assertNotNull(info1); - Assertions.assertEquals(110, info1.getCode()); + Assertions.assertThat(info1).isNotNull(); + Assertions.assertThat(info1.getCode()).isEqualTo(110); final HttpResponse info2 = infos.get(1); - Assertions.assertNotNull(info2); - Assertions.assertEquals(111, info2.getCode()); + Assertions.assertThat(info2).isNotNull(); + Assertions.assertThat(info2.getCode()).isEqualTo(111); executor.postProcess(response, httprocessor, context); Mockito.verify(httprocessor).process(response, response.getEntity(), context); - Assertions.assertSame(request, context.getRequest()); - Assertions.assertSame(response, context.getResponse()); + Assertions.assertThat(context.getRequest()).isSameAs(request); + Assertions.assertThat(context.getResponse()).isSameAs(response); } @Test @@ -350,14 +350,14 @@ void testExecutionEntityEnclosingRequestWithExpectContinueMultiple1xxResponses() final ArgumentCaptor responseCaptor = ArgumentCaptor.forClass(HttpResponse.class); Mockito.verify(callback, Mockito.times(2)).execute(responseCaptor.capture(), ArgumentMatchers.eq(conn), ArgumentMatchers.eq(context)); final List infos = responseCaptor.getAllValues(); - Assertions.assertNotNull(infos); - Assertions.assertEquals(2, infos.size()); + Assertions.assertThat(infos).isNotNull(); + Assertions.assertThat(infos.size()).isEqualTo(2); final HttpResponse info1 = infos.get(0); - Assertions.assertNotNull(info1); - Assertions.assertEquals(110, info1.getCode()); + Assertions.assertThat(info1).isNotNull(); + Assertions.assertThat(info1.getCode()).isEqualTo(110); final HttpResponse info2 = infos.get(1); - Assertions.assertNotNull(info2); - Assertions.assertEquals(111, info2.getCode()); + Assertions.assertThat(info2).isNotNull(); + Assertions.assertThat(info2.getCode()).isEqualTo(111); executor.postProcess(response, httprocessor, context); Mockito.verify(httprocessor).process(response, response.getEntity(), context); @@ -403,7 +403,9 @@ void testExecutionIOException() throws Exception { final ClassicHttpRequest request = new BasicClassicHttpRequest(Method.GET, "/"); Mockito.doThrow(new IOException("Oopsie")).when(conn).sendRequestHeader(request); - Assertions.assertThrows(IOException.class, () -> executor.execute(request, conn, context)); + Assertions.assertThatThrownBy(() -> + executor.execute(request, conn, context)) + .isInstanceOf(IOException.class); Mockito.verify(conn).close(CloseMode.IMMEDIATE); } @@ -416,7 +418,9 @@ void testExecutionRuntimeException() throws Exception { final ClassicHttpRequest request = new BasicClassicHttpRequest(Method.GET, "/"); Mockito.doThrow(new RuntimeException("Oopsie")).when(conn).receiveResponseHeader(); - Assertions.assertThrows(RuntimeException.class, () -> executor.execute(request, conn, context)); + Assertions.assertThatThrownBy(() -> + executor.execute(request, conn, context)) + .isInstanceOf(RuntimeException.class); Mockito.verify(conn).close(CloseMode.IMMEDIATE); } @@ -429,7 +433,9 @@ void testExecutionHttpException() throws Exception { final ClassicHttpRequest request = new BasicClassicHttpRequest(Method.GET, "/"); Mockito.doThrow(new HttpException("Oopsie")).when(conn).receiveResponseHeader(); - Assertions.assertThrows(HttpException.class, () -> executor.execute(request, conn, context)); + Assertions.assertThatThrownBy(() -> + executor.execute(request, conn, context)) + .isInstanceOf(HttpException.class); Mockito.verify(conn).close(); } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/impl/io/TestHttpService.java b/httpcore5/src/test/java/org/apache/hc/core5/http/impl/io/TestHttpService.java index c910a0699b..07235ef991 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/impl/io/TestHttpService.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/impl/io/TestHttpService.java @@ -49,7 +49,7 @@ import org.apache.hc.core5.http.message.BasicClassicHttpResponse; import org.apache.hc.core5.http.protocol.HttpCoreContext; import org.apache.hc.core5.http.protocol.HttpProcessor; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; @@ -91,12 +91,12 @@ void prepareMocks() { @Test void testInvalidInitialization() { - Assertions.assertThrows(NullPointerException.class, () -> + Assertions.assertThatThrownBy(() -> new HttpService( null, handlerResolver, connReuseStrategy, - responseFactory)); + responseFactory)).isInstanceOf(NullPointerException.class); } @Test @@ -109,10 +109,10 @@ void testBasicExecution() throws Exception { httpservice.handleRequest(conn, context); - Assertions.assertEquals(HttpStatus.SC_NOT_IMPLEMENTED, response.getCode()); + Assertions.assertThat(response.getCode()).isEqualTo(HttpStatus.SC_NOT_IMPLEMENTED); - Assertions.assertSame(request, context.getRequest()); - Assertions.assertSame(response, context.getResponse()); + Assertions.assertThat(context.getRequest()).isSameAs(request); + Assertions.assertThat(context.getResponse()).isSameAs(response); Mockito.verify(httprocessor).process(request, request.getEntity(), context); Mockito.verify(httprocessor).process(response, response.getEntity(), context); @@ -139,11 +139,11 @@ void testExecutionEntityEnclosingRequest() throws Exception { final ArgumentCaptor responseCaptor = ArgumentCaptor.forClass(ClassicHttpResponse.class); Mockito.verify(conn).sendResponseHeader(responseCaptor.capture()); final ClassicHttpResponse response = responseCaptor.getValue(); - Assertions.assertNotNull(response); + Assertions.assertThat(response).isNotNull(); - Assertions.assertEquals(HttpStatus.SC_NOT_IMPLEMENTED, response.getCode()); + Assertions.assertThat(response.getCode()).isEqualTo(HttpStatus.SC_NOT_IMPLEMENTED); - Assertions.assertSame(request, context.getRequest()); + Assertions.assertThat(context.getRequest()).isSameAs(request); Mockito.verify(httprocessor).process(request, request.getEntity(), context); Mockito.verify(inStream).close(); @@ -172,15 +172,15 @@ void testExecutionEntityEnclosingRequestWithExpectContinue() throws Exception { final ArgumentCaptor responseCaptor = ArgumentCaptor.forClass(ClassicHttpResponse.class); Mockito.verify(conn, Mockito.times(2)).sendResponseHeader(responseCaptor.capture()); final List responses = responseCaptor.getAllValues(); - Assertions.assertNotNull(responses); - Assertions.assertEquals(2, responses.size()); + Assertions.assertThat(responses).isNotNull(); + Assertions.assertThat(responses.size()).isEqualTo(2); final ClassicHttpResponse ack = responses.get(0); final ClassicHttpResponse response = responses.get(1); - Assertions.assertEquals(HttpStatus.SC_CONTINUE, ack.getCode()); - Assertions.assertEquals(HttpStatus.SC_NOT_IMPLEMENTED, response.getCode()); + Assertions.assertThat(ack.getCode()).isEqualTo(HttpStatus.SC_CONTINUE); + Assertions.assertThat(response.getCode()).isEqualTo(HttpStatus.SC_NOT_IMPLEMENTED); - Assertions.assertSame(request, context.getRequest()); + Assertions.assertThat(context.getRequest()).isSameAs(request); Mockito.verify(httprocessor).process(request, request.getEntity(), context); Mockito.verify(inStream).close(); @@ -207,11 +207,11 @@ void testMethodNotSupported() throws Exception { final ArgumentCaptor responseCaptor = ArgumentCaptor.forClass(ClassicHttpResponse.class); Mockito.verify(conn).sendResponseHeader(responseCaptor.capture()); final ClassicHttpResponse error = responseCaptor.getValue(); - Assertions.assertNotNull(error); + Assertions.assertThat(error).isNotNull(); - Assertions.assertSame(request, context.getRequest()); + Assertions.assertThat(context.getRequest()).isSameAs(request); - Assertions.assertEquals(HttpStatus.SC_NOT_IMPLEMENTED, error.getCode()); + Assertions.assertThat(error.getCode()).isEqualTo(HttpStatus.SC_NOT_IMPLEMENTED); Mockito.verify(httprocessor).process(error, error.getEntity(), context); Mockito.verify(conn).sendResponseHeader(error); @@ -234,11 +234,11 @@ void testUnsupportedHttpVersionException() throws Exception { final ArgumentCaptor responseCaptor = ArgumentCaptor.forClass(ClassicHttpResponse.class); Mockito.verify(conn).sendResponseHeader(responseCaptor.capture()); final ClassicHttpResponse error = responseCaptor.getValue(); - Assertions.assertNotNull(error); + Assertions.assertThat(error).isNotNull(); - Assertions.assertSame(request, context.getRequest()); + Assertions.assertThat(context.getRequest()).isSameAs(request); - Assertions.assertEquals(HttpStatus.SC_HTTP_VERSION_NOT_SUPPORTED, error.getCode()); + Assertions.assertThat(error.getCode()).isEqualTo(HttpStatus.SC_HTTP_VERSION_NOT_SUPPORTED); Mockito.verify(httprocessor).process(error, error.getEntity(), context); Mockito.verify(conn).sendResponseHeader(error); @@ -261,11 +261,11 @@ void testProtocolException() throws Exception { final ArgumentCaptor responseCaptor = ArgumentCaptor.forClass(ClassicHttpResponse.class); Mockito.verify(conn).sendResponseHeader(responseCaptor.capture()); final ClassicHttpResponse error = responseCaptor.getValue(); - Assertions.assertNotNull(error); + Assertions.assertThat(error).isNotNull(); - Assertions.assertSame(request, context.getRequest()); + Assertions.assertThat(context.getRequest()).isSameAs(request); - Assertions.assertEquals(HttpStatus.SC_BAD_REQUEST, error.getCode()); + Assertions.assertThat(error.getCode()).isEqualTo(HttpStatus.SC_BAD_REQUEST); Mockito.verify(httprocessor).process(error, error.getEntity(), context); Mockito.verify(conn).sendResponseHeader(error); @@ -284,10 +284,10 @@ void testConnectionKeepAlive() throws Exception { httpservice.handleRequest(conn, context); - Assertions.assertEquals(HttpStatus.SC_OK, response.getCode()); + Assertions.assertThat(response.getCode()).isEqualTo(HttpStatus.SC_OK); - Assertions.assertSame(request, context.getRequest()); - Assertions.assertSame(response, context.getResponse()); + Assertions.assertThat(context.getRequest()).isSameAs(request); + Assertions.assertThat(context.getResponse()).isSameAs(response); Mockito.verify(httprocessor).process(request, request.getEntity(), context); Mockito.verify(httprocessor).process(response, response.getEntity(), context); @@ -310,7 +310,7 @@ void testNoContentResponse() throws Exception { httpservice.handleRequest(conn, context); - Assertions.assertSame(request, context.getRequest()); + Assertions.assertThat(context.getRequest()).isSameAs(request); Mockito.verify(httprocessor).process(response, response.getEntity(), context); @@ -333,7 +333,7 @@ void testResponseToHead() throws Exception { httpservice.handleRequest(conn, context); - Assertions.assertSame(request, context.getRequest()); + Assertions.assertThat(context.getRequest()).isSameAs(request); Mockito.verify(httprocessor).process(response, response.getEntity(), context); Mockito.verify(requestHandler).handle(request, response, context); diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/impl/io/TestIdentityInputStream.java b/httpcore5/src/test/java/org/apache/hc/core5/http/impl/io/TestIdentityInputStream.java index e6fc9522c6..75524b9b12 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/impl/io/TestIdentityInputStream.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/impl/io/TestIdentityInputStream.java @@ -32,7 +32,7 @@ import org.apache.hc.core5.http.StreamClosedException; import org.apache.hc.core5.http.impl.BasicHttpTransportMetrics; import org.apache.hc.core5.http.io.SessionInputBuffer; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; /** @@ -47,14 +47,14 @@ void testBasicRead() throws Exception { final SessionInputBuffer inBuffer = new SessionInputBufferImpl(16); try (IdentityInputStream in = new IdentityInputStream(inBuffer, inputStream)) { final byte[] tmp = new byte[2]; - Assertions.assertEquals(2, in.read(tmp, 0, tmp.length)); - Assertions.assertEquals('a', tmp[0]); - Assertions.assertEquals('b', tmp[1]); - Assertions.assertEquals('c', in.read()); - Assertions.assertEquals(-1, in.read(tmp, 0, tmp.length)); - Assertions.assertEquals(-1, in.read()); - Assertions.assertEquals(-1, in.read(tmp, 0, tmp.length)); - Assertions.assertEquals(-1, in.read()); + Assertions.assertThat(in.read(tmp, 0, tmp.length)).isEqualTo(2); + Assertions.assertThat(tmp[0]).isEqualTo((byte) 'a'); + Assertions.assertThat(tmp[1]).isEqualTo((byte) 'b'); + Assertions.assertThat(in.read()).isEqualTo((int) 'c'); + Assertions.assertThat(in.read(tmp, 0, tmp.length)).isEqualTo(-1); + Assertions.assertThat(in.read()).isEqualTo(-1); + Assertions.assertThat(in.read(tmp, 0, tmp.length)).isEqualTo(-1); + Assertions.assertThat(in.read()).isEqualTo(-1); } } @@ -68,10 +68,14 @@ void testClosedCondition() throws Exception { in.close(); in.close(); - Assertions.assertEquals(0, in.available()); + Assertions.assertThat(in.available()).isEqualTo(0); final byte[] tmp = new byte[2]; - Assertions.assertThrows(StreamClosedException.class, () -> in.read(tmp, 0, tmp.length)); - Assertions.assertThrows(StreamClosedException.class, () -> in.read()); + Assertions.assertThatThrownBy(() -> + in.read(tmp, 0, tmp.length)) + .isInstanceOf(StreamClosedException.class); + Assertions.assertThatThrownBy(() -> + in.read()) + .isInstanceOf(StreamClosedException.class); } @Test @@ -81,7 +85,7 @@ void testAvailable() throws Exception { final SessionInputBuffer inBuffer = new SessionInputBufferImpl(new BasicHttpTransportMetrics(), 16, 16, 1024, null); try (IdentityInputStream in = new IdentityInputStream(inBuffer, inputStream)) { in.read(); - Assertions.assertEquals(2, in.available()); + Assertions.assertThat(in.available()).isEqualTo(2); } } @@ -92,8 +96,8 @@ void testAvailableInStream() throws Exception { final SessionInputBuffer inBuffer = new SessionInputBufferImpl(new BasicHttpTransportMetrics(), 16, 0, 1024, null); try (IdentityInputStream in = new IdentityInputStream(inBuffer, inputStream)) { final byte[] tmp = new byte[3]; - Assertions.assertEquals(3, in.read(tmp)); - Assertions.assertEquals(3, in.available()); + Assertions.assertThat(in.read(tmp)).isEqualTo(3); + Assertions.assertThat(in.available()).isEqualTo(3); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/impl/io/TestIdentityOutputStream.java b/httpcore5/src/test/java/org/apache/hc/core5/http/impl/io/TestIdentityOutputStream.java index e513c96ac7..94f3a00d6b 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/impl/io/TestIdentityOutputStream.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/impl/io/TestIdentityOutputStream.java @@ -33,7 +33,7 @@ import org.apache.hc.core5.http.StreamClosedException; import org.apache.hc.core5.http.io.SessionOutputBuffer; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; /** @@ -54,7 +54,7 @@ void testBasics() throws Exception { out.flush(); } final byte[] data = outputStream.toByteArray(); - Assertions.assertEquals(21, data.length); + Assertions.assertThat(data.length).isEqualTo(21); } @Test @@ -65,8 +65,10 @@ void testClose() throws Exception { out.close(); out.close(); final byte[] tmp = new byte[10]; - Assertions.assertThrows(IOException.class, () -> out.write(tmp)); - Assertions.assertThrows(IOException.class, () -> out.write(1)); + Assertions.assertThatThrownBy(() -> + out.write(tmp)) + .isInstanceOf(IOException.class); + Assertions.assertThatThrownBy(() -> out.write(1)).isInstanceOf(IOException.class); } @Test @@ -80,11 +82,11 @@ void testBasicWrite() throws Exception { final byte[] input = outputStream.toByteArray(); - Assertions.assertNotNull(input); + Assertions.assertThat(input).isNotNull(); final byte[] expected = new byte[] { 'a', 'b', 'c' }; - Assertions.assertEquals(expected.length, input.length); + Assertions.assertThat(input.length).isEqualTo(expected.length); for (int i = 0; i < expected.length; i++) { - Assertions.assertEquals(expected[i], input[i]); + Assertions.assertThat(input[i]).isEqualTo(expected[i]); } } } @@ -97,8 +99,12 @@ void testClosedCondition() throws Exception { out.close(); out.close(); final byte[] tmp = new byte[2]; - Assertions.assertThrows(StreamClosedException.class, () -> out.write(tmp, 0, tmp.length)); - Assertions.assertThrows(StreamClosedException.class, () -> out.write('a')); + Assertions.assertThatThrownBy(() -> + out.write(tmp, 0, tmp.length)) + .isInstanceOf(StreamClosedException.class); + Assertions.assertThatThrownBy(() -> + out.write('a')) + .isInstanceOf(StreamClosedException.class); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/impl/io/TestMessageParser.java b/httpcore5/src/test/java/org/apache/hc/core5/http/impl/io/TestMessageParser.java index 1b2d6a17db..639f5c55dc 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/impl/io/TestMessageParser.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/impl/io/TestMessageParser.java @@ -34,7 +34,7 @@ import org.apache.hc.core5.http.Header; import org.apache.hc.core5.http.ProtocolException; import org.apache.hc.core5.http.io.SessionInputBuffer; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; /** @@ -55,14 +55,14 @@ void testBasicHeaderParsing() throws Exception { final ByteArrayInputStream inputStream = new ByteArrayInputStream(s.getBytes(StandardCharsets.US_ASCII)); final SessionInputBuffer inBuffer = new SessionInputBufferImpl(16, StandardCharsets.US_ASCII.newDecoder()); final Header[] headers = AbstractMessageParser.parseHeaders(inBuffer, inputStream, -1, -1, null); - Assertions.assertNotNull(headers); - Assertions.assertEquals(3, headers.length); - Assertions.assertEquals("header1", headers[0].getName()); - Assertions.assertEquals("stuff", headers[0].getValue()); - Assertions.assertEquals("header2", headers[1].getName()); - Assertions.assertEquals("stuff", headers[1].getValue()); - Assertions.assertEquals("header3", headers[2].getName()); - Assertions.assertEquals("stuff and more stuff and even more stuff", headers[2].getValue()); + Assertions.assertThat(headers).isNotNull(); + Assertions.assertThat(headers.length).isEqualTo(3); + Assertions.assertThat(headers[0].getName()).isEqualTo("header1"); + Assertions.assertThat(headers[0].getValue()).isEqualTo("stuff"); + Assertions.assertThat(headers[1].getName()).isEqualTo("header2"); + Assertions.assertThat(headers[1].getValue()).isEqualTo("stuff"); + Assertions.assertThat(headers[2].getName()).isEqualTo("header3"); + Assertions.assertThat(headers[2].getValue()).isEqualTo("stuff and more stuff and even more stuff"); } @Test @@ -72,9 +72,9 @@ void testParsingHeader() throws Exception { final ByteArrayInputStream inputStream = new ByteArrayInputStream(s.getBytes(StandardCharsets.US_ASCII)); final SessionInputBuffer inBuffer = new SessionInputBufferImpl(16, StandardCharsets.US_ASCII.newDecoder()); final Header[] headers = AbstractMessageParser.parseHeaders(inBuffer, inputStream, -1, -1, null); - Assertions.assertNotNull(headers); - Assertions.assertEquals(1, headers.length); - Assertions.assertEquals("header1: stuff; param1 = value1; param2 = \"value 2\" ", headers[0].toString()); + Assertions.assertThat(headers).isNotNull(); + Assertions.assertThat(headers.length).isEqualTo(1); + Assertions.assertThat(headers[0].toString()).isEqualTo("header1: stuff; param1 = value1; param2 = \"value 2\" "); } @Test @@ -84,15 +84,15 @@ void testParsingInvalidHeaders() { "\r\n"; final ByteArrayInputStream inputStream1 = new ByteArrayInputStream(s1.getBytes(StandardCharsets.US_ASCII)); final SessionInputBuffer inBuffer1 = new SessionInputBufferImpl(16, StandardCharsets.US_ASCII.newDecoder()); - Assertions.assertThrows(ProtocolException.class, () -> - AbstractMessageParser.parseHeaders(inBuffer1, inputStream1, -1, -1, null)); + Assertions.assertThatThrownBy(() -> + AbstractMessageParser.parseHeaders(inBuffer1, inputStream1, -1, -1, null)).isInstanceOf(ProtocolException.class); final String s2 = " : stuff\r\n" + "header1: stuff\r\n" + "\r\n"; final ByteArrayInputStream inputStream2 = new ByteArrayInputStream(s2.getBytes(StandardCharsets.US_ASCII)); final SessionInputBuffer inBuffer2 = new SessionInputBufferImpl(16, StandardCharsets.US_ASCII.newDecoder()); - Assertions.assertThrows(ProtocolException.class, () -> - AbstractMessageParser.parseHeaders(inBuffer2, inputStream2, -1, -1, null)); + Assertions.assertThatThrownBy(() -> + AbstractMessageParser.parseHeaders(inBuffer2, inputStream2, -1, -1, null)).isInstanceOf(ProtocolException.class); } @Test @@ -103,12 +103,12 @@ void testParsingMalformedFirstHeader() throws Exception { final ByteArrayInputStream inputStream = new ByteArrayInputStream(s.getBytes(StandardCharsets.US_ASCII)); final SessionInputBuffer inBuffer = new SessionInputBufferImpl(16, StandardCharsets.US_ASCII.newDecoder()); final Header[] headers = AbstractMessageParser.parseHeaders(inBuffer, inputStream, -1, -1, null); - Assertions.assertNotNull(headers); - Assertions.assertEquals(2, headers.length); - Assertions.assertEquals("header1", headers[0].getName()); - Assertions.assertEquals("stuff", headers[0].getValue()); - Assertions.assertEquals("header2", headers[1].getName()); - Assertions.assertEquals("stuff", headers[1].getValue()); + Assertions.assertThat(headers).isNotNull(); + Assertions.assertThat(headers.length).isEqualTo(2); + Assertions.assertThat(headers[0].getName()).isEqualTo("header1"); + Assertions.assertThat(headers[0].getValue()).isEqualTo("stuff"); + Assertions.assertThat(headers[1].getName()).isEqualTo("header2"); + Assertions.assertThat(headers[1].getValue()).isEqualTo("stuff"); } @Test @@ -117,8 +117,8 @@ void testEmptyDataStream() throws Exception { final ByteArrayInputStream inputStream = new ByteArrayInputStream(s.getBytes(StandardCharsets.US_ASCII)); final SessionInputBuffer inBuffer = new SessionInputBufferImpl(16, StandardCharsets.US_ASCII.newDecoder()); final Header[] headers = AbstractMessageParser.parseHeaders(inBuffer, inputStream, -1, -1, null); - Assertions.assertNotNull(headers); - Assertions.assertEquals(0, headers.length); + Assertions.assertThat(headers).isNotNull(); + Assertions.assertThat(headers.length).isEqualTo(0); } @Test @@ -130,8 +130,8 @@ void testMaxHeaderCount() { "\r\n"; final ByteArrayInputStream inputStream = new ByteArrayInputStream(s.getBytes(StandardCharsets.US_ASCII)); final SessionInputBuffer inBuffer = new SessionInputBufferImpl(16, StandardCharsets.US_ASCII.newDecoder()); - Assertions.assertThrows(IOException.class, () -> - AbstractMessageParser.parseHeaders(inBuffer, inputStream, 2, -1, null)); + Assertions.assertThatThrownBy(() -> + AbstractMessageParser.parseHeaders(inBuffer, inputStream, 2, -1, null)).isInstanceOf(IOException.class); } @Test @@ -143,8 +143,8 @@ void testMaxHeaderCountForFoldedHeader() { "\r\n"; final ByteArrayInputStream inputStream = new ByteArrayInputStream(s.getBytes(StandardCharsets.US_ASCII)); final SessionInputBuffer inBuffer = new SessionInputBufferImpl(16, StandardCharsets.US_ASCII.newDecoder()); - Assertions.assertThrows(IOException.class, () -> - AbstractMessageParser.parseHeaders(inBuffer, inputStream, 2, 15, null)); + Assertions.assertThatThrownBy(() -> + AbstractMessageParser.parseHeaders(inBuffer, inputStream, 2, 15, null)).isInstanceOf(IOException.class); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/impl/io/TestMonitoringResponseOutOfOrderStrategy.java b/httpcore5/src/test/java/org/apache/hc/core5/http/impl/io/TestMonitoringResponseOutOfOrderStrategy.java index 43e4937d16..ccb7452058 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/impl/io/TestMonitoringResponseOutOfOrderStrategy.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/impl/io/TestMonitoringResponseOutOfOrderStrategy.java @@ -37,7 +37,7 @@ import org.apache.hc.core5.http.io.ResponseOutOfOrderStrategy; import org.apache.hc.core5.http.message.BasicClassicHttpRequest; import org.apache.hc.core5.util.Timeout; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.mockito.ArgumentMatchers; import org.mockito.Mockito; @@ -55,7 +55,7 @@ void testFirstByteIsNotCheckedSsl() throws IOException { socketInputStream(0), 0, 1); - Assertions.assertFalse(earlyResponse); + Assertions.assertThat(earlyResponse).isFalse(); } @Test @@ -66,7 +66,7 @@ void testFirstByteIsNotCheckedPlain() throws IOException { socketInputStream(1), 0, 1); - Assertions.assertFalse(earlyResponse); + Assertions.assertThat(earlyResponse).isFalse(); } @Test @@ -77,7 +77,7 @@ void testWritesWithinChunkAreNotChecked() throws IOException { socketInputStream(0), 1, 8190); - Assertions.assertFalse(earlyResponse, "There is data available, but checks shouldn't occur until just prior to the 8192nd byte"); + Assertions.assertThat(earlyResponse).withFailMessage("There is data available, but checks shouldn't occur until just prior to the 8192nd byte").isFalse(); } @Test @@ -88,30 +88,30 @@ void testWritesAcrossChunksAreChecked() throws IOException { socketInputStream(0), 8191, 1); - Assertions.assertTrue(earlyResponse); + Assertions.assertThat(earlyResponse).isTrue(); } @Test void testMaximumChunks() throws IOException { final ResponseOutOfOrderStrategy strategy = new MonitoringResponseOutOfOrderStrategy(1, 2); - Assertions.assertTrue(strategy.isEarlyResponseDetected( + Assertions.assertThat(strategy.isEarlyResponseDetected( REQUEST, connection(true, true), socketInputStream(0), 0, - 1)); - Assertions.assertTrue(strategy.isEarlyResponseDetected( + 1)).isTrue(); + Assertions.assertThat(strategy.isEarlyResponseDetected( REQUEST, connection(true, true), socketInputStream(0), 1, - 2)); - Assertions.assertFalse(strategy.isEarlyResponseDetected( + 2)).isTrue(); + Assertions.assertThat(strategy.isEarlyResponseDetected( REQUEST, connection(true, true), socketInputStream(0), 2, - 3)); + 3)).isFalse(); } private static InputStream socketInputStream(final int available) throws IOException { diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/impl/io/TestRequestParser.java b/httpcore5/src/test/java/org/apache/hc/core5/http/impl/io/TestRequestParser.java index bc65c754ce..c88c83122c 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/impl/io/TestRequestParser.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/impl/io/TestRequestParser.java @@ -36,7 +36,7 @@ import org.apache.hc.core5.http.RequestHeaderFieldsTooLargeException; import org.apache.hc.core5.http.config.Http1Config; import org.apache.hc.core5.http.io.SessionInputBuffer; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; /** @@ -58,10 +58,10 @@ void testBasicMessageParsing() throws Exception { final DefaultHttpRequestParser parser = new DefaultHttpRequestParser(); final ClassicHttpRequest httprequest = parser.parse(inBuffer, inputStream); - Assertions.assertEquals(Method.GET.name(), httprequest.getMethod()); - Assertions.assertEquals("/", httprequest.getPath()); + Assertions.assertThat(httprequest.getMethod()).isEqualTo(Method.GET.name()); + Assertions.assertThat(httprequest.getPath()).isEqualTo("/"); final Header[] headers = httprequest.getHeaders(); - Assertions.assertEquals(3, headers.length); + Assertions.assertThat(headers.length).isEqualTo(3); } @Test @@ -71,7 +71,7 @@ void testConnectionClosedException() throws Exception { final DefaultHttpRequestParser parser = new DefaultHttpRequestParser(); final ClassicHttpRequest request = parser.parse(inBuffer, inputStream); - Assertions.assertNull(request); + Assertions.assertThat(request).isNull(); } @Test @@ -89,10 +89,10 @@ void testBasicMessageParsingLeadingEmptyLines() throws Exception { Http1Config.custom().setMaxEmptyLineCount(3).build()); final ClassicHttpRequest httprequest = parser.parse(inBuffer, inputStream); - Assertions.assertEquals(Method.GET.name(), httprequest.getMethod()); - Assertions.assertEquals("/", httprequest.getPath()); + Assertions.assertThat(httprequest.getMethod()).isEqualTo(Method.GET.name()); + Assertions.assertThat(httprequest.getPath()).isEqualTo("/"); final Header[] headers = httprequest.getHeaders(); - Assertions.assertEquals(1, headers.length); + Assertions.assertThat(headers.length).isEqualTo(1); } @Test @@ -109,8 +109,8 @@ void testBasicMessageParsingTooManyLeadingEmptyLines() { final DefaultHttpRequestParser parser = new DefaultHttpRequestParser( Http1Config.custom().setMaxEmptyLineCount(3).build()); - Assertions.assertThrows(RequestHeaderFieldsTooLargeException.class, () -> - parser.parse(inBuffer, inputStream)); + Assertions.assertThatThrownBy(() -> + parser.parse(inBuffer, inputStream)).isInstanceOf(RequestHeaderFieldsTooLargeException.class); } @Test @@ -138,13 +138,13 @@ void testMessageParsingTimeout() throws Exception { } } - Assertions.assertNotNull(httprequest); - Assertions.assertEquals(5, timeoutCount); + Assertions.assertThat(httprequest).isNotNull(); + Assertions.assertThat(timeoutCount).isEqualTo(5); - Assertions.assertEquals(Method.GET.name(), httprequest.getMethod()); - Assertions.assertEquals("/", httprequest.getPath()); + Assertions.assertThat(httprequest.getMethod()).isEqualTo(Method.GET.name()); + Assertions.assertThat(httprequest.getPath()).isEqualTo("/"); final Header[] headers = httprequest.getHeaders(); - Assertions.assertEquals(3, headers.length); + Assertions.assertThat(headers.length).isEqualTo(3); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/impl/io/TestResponseParser.java b/httpcore5/src/test/java/org/apache/hc/core5/http/impl/io/TestResponseParser.java index 120739cfba..e9d43ac360 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/impl/io/TestResponseParser.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/impl/io/TestResponseParser.java @@ -36,7 +36,7 @@ import org.apache.hc.core5.http.MessageConstraintException; import org.apache.hc.core5.http.config.Http1Config; import org.apache.hc.core5.http.io.SessionInputBuffer; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; /** @@ -58,10 +58,10 @@ void testBasicMessageParsing() throws Exception { final DefaultHttpResponseParser parser = new DefaultHttpResponseParser(); final ClassicHttpResponse httpresponse = parser.parse(inBuffer, inputStream); - Assertions.assertEquals(200, httpresponse.getCode()); - Assertions.assertEquals("OK", httpresponse.getReasonPhrase()); + Assertions.assertThat(httpresponse.getCode()).isEqualTo(200); + Assertions.assertThat(httpresponse.getReasonPhrase()).isEqualTo("OK"); final Header[] headers = httpresponse.getHeaders(); - Assertions.assertEquals(3, headers.length); + Assertions.assertThat(headers.length).isEqualTo(3); } @Test @@ -71,7 +71,7 @@ void testConnectionClosedException() throws Exception { final DefaultHttpResponseParser parser = new DefaultHttpResponseParser(); final ClassicHttpResponse response = parser.parse(inBuffer, inputStream); - Assertions.assertNull(response); + Assertions.assertThat(response).isNull(); } @Test @@ -89,10 +89,10 @@ void testBasicMessageParsingLeadingEmptyLines() throws Exception { Http1Config.custom().setMaxEmptyLineCount(3).build()); final ClassicHttpResponse httpresponse = parser.parse(inBuffer, inputStream); - Assertions.assertEquals(200, httpresponse.getCode()); - Assertions.assertEquals("OK", httpresponse.getReasonPhrase()); + Assertions.assertThat(httpresponse.getCode()).isEqualTo(200); + Assertions.assertThat(httpresponse.getReasonPhrase()).isEqualTo("OK"); final Header[] headers = httpresponse.getHeaders(); - Assertions.assertEquals(1, headers.length); + Assertions.assertThat(headers.length).isEqualTo(1); } @Test @@ -109,8 +109,8 @@ void testBasicMessageParsingTooManyLeadingEmptyLines() { final DefaultHttpResponseParser parser = new DefaultHttpResponseParser( Http1Config.custom().setMaxEmptyLineCount(3).build()); - Assertions.assertThrows(MessageConstraintException.class, () -> - parser.parse(inBuffer, inputStream)); + Assertions.assertThatThrownBy(() -> + parser.parse(inBuffer, inputStream)).isInstanceOf(MessageConstraintException.class); } @Test @@ -137,13 +137,13 @@ void testMessageParsingTimeout() throws Exception { timeoutCount++; } } - Assertions.assertNotNull(httpresponse); - Assertions.assertEquals(5, timeoutCount); + Assertions.assertThat(httpresponse).isNotNull(); + Assertions.assertThat(timeoutCount).isEqualTo(5); - Assertions.assertEquals(200, httpresponse.getCode()); - Assertions.assertEquals("OK", httpresponse.getReasonPhrase()); + Assertions.assertThat(httpresponse.getCode()).isEqualTo(200); + Assertions.assertThat(httpresponse.getReasonPhrase()).isEqualTo("OK"); final Header[] headers = httpresponse.getHeaders(); - Assertions.assertEquals(3, headers.length); + Assertions.assertThat(headers.length).isEqualTo(3); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/impl/io/TestSessionInOutBuffers.java b/httpcore5/src/test/java/org/apache/hc/core5/http/impl/io/TestSessionInOutBuffers.java index 0620051d85..67db1f969b 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/impl/io/TestSessionInOutBuffers.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/impl/io/TestSessionInOutBuffers.java @@ -43,7 +43,7 @@ import org.apache.hc.core5.http.io.SessionInputBuffer; import org.apache.hc.core5.http.io.SessionOutputBuffer; import org.apache.hc.core5.util.CharArrayBuffer; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.mockito.ArgumentMatchers; import org.mockito.Mockito; @@ -61,9 +61,9 @@ void testEncodedWriteLineFiltersControlCharacters() throws Exception { outbuffer.writeLine(line, out); outbuffer.flush(out); - Assertions.assertEquals("X-Test: ok??X-Injected: yes????\t\u00e9\u20ac\r\n", - new String(out.toByteArray(), StandardCharsets.UTF_8)); - Assertions.assertEquals(original, line.toString()); + Assertions.assertThat(new String(out.toByteArray(), StandardCharsets.UTF_8)) + .isEqualTo("X-Test: ok??X-Injected: yes????\t\u00e9\u20ac\r\n"); + Assertions.assertThat(line.toString()).isEqualTo(original); } @Test @@ -76,8 +76,8 @@ void testDefaultWriteLineFilteringIsUnchanged() throws Exception { outbuffer.writeLine(line, out); outbuffer.flush(out); - Assertions.assertEquals("X-Test: ok??X-Injected: yes\r\n", - new String(out.toByteArray(), StandardCharsets.ISO_8859_1)); + Assertions.assertThat(new String(out.toByteArray(), StandardCharsets.ISO_8859_1)) + .isEqualTo("X-Test: ok??X-Injected: yes\r\n"); } @Test @@ -94,28 +94,28 @@ void testWriteBinaryDataWithCharsetEncoder() throws Exception { outbuffer.write(payload, outputStream); outbuffer.flush(outputStream); - Assertions.assertArrayEquals(payload, outputStream.toByteArray()); + Assertions.assertThat(outputStream.toByteArray()).containsExactly(payload); } @Test void testBasicBufferProperties() throws Exception { final SessionInputBuffer inBuffer = new SessionInputBufferImpl(16); final ByteArrayInputStream inputStream = new ByteArrayInputStream(new byte[] { 1, 2 , 3}); - Assertions.assertEquals(16, inBuffer.capacity()); - Assertions.assertEquals(16, inBuffer.available()); - Assertions.assertEquals(0, inBuffer.length()); + Assertions.assertThat(inBuffer.capacity()).isEqualTo(16); + Assertions.assertThat(inBuffer.available()).isEqualTo(16); + Assertions.assertThat(inBuffer.length()).isEqualTo(0); inBuffer.read(inputStream); - Assertions.assertEquals(14, inBuffer.available()); - Assertions.assertEquals(2, inBuffer.length()); + Assertions.assertThat(inBuffer.available()).isEqualTo(14); + Assertions.assertThat(inBuffer.length()).isEqualTo(2); final SessionOutputBuffer outbuffer = new SessionOutputBufferImpl(16); final ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); - Assertions.assertEquals(16, outbuffer.capacity()); - Assertions.assertEquals(16, outbuffer.available()); - Assertions.assertEquals(0, outbuffer.length()); + Assertions.assertThat(outbuffer.capacity()).isEqualTo(16); + Assertions.assertThat(outbuffer.available()).isEqualTo(16); + Assertions.assertThat(outbuffer.length()).isEqualTo(0); outbuffer.write(new byte[] {1, 2, 3}, outputStream); - Assertions.assertEquals(13, outbuffer.available()); - Assertions.assertEquals(3, outbuffer.length()); + Assertions.assertThat(outbuffer.available()).isEqualTo(13); + Assertions.assertThat(outbuffer.length()).isEqualTo(3); } @Test @@ -152,7 +152,7 @@ void testBasicReadWriteLine() throws Exception { for (final String teststr : teststrs) { expected += teststr.length() + 2/*CRLF*/; } - Assertions.assertEquals(expected, bytesWritten); + Assertions.assertThat(bytesWritten).isEqualTo(expected); final SessionInputBuffer inBuffer = new SessionInputBufferImpl(16); final ByteArrayInputStream inputStream = new ByteArrayInputStream(outputStream.toByteArray()); @@ -160,16 +160,16 @@ void testBasicReadWriteLine() throws Exception { for (final String teststr : teststrs) { chbuffer.clear(); inBuffer.readLine(chbuffer, inputStream); - Assertions.assertEquals(teststr, chbuffer.toString()); + Assertions.assertThat(chbuffer.toString()).isEqualTo(teststr); } chbuffer.clear(); - Assertions.assertEquals(-1, inBuffer.readLine(chbuffer, inputStream)); + Assertions.assertThat(inBuffer.readLine(chbuffer, inputStream)).isEqualTo(-1); chbuffer.clear(); - Assertions.assertEquals(-1, inBuffer.readLine(chbuffer, inputStream)); + Assertions.assertThat(inBuffer.readLine(chbuffer, inputStream)).isEqualTo(-1); tmetrics = inBuffer.getMetrics(); final long bytesRead = tmetrics.getBytesTransferred(); - Assertions.assertEquals(expected, bytesRead); + Assertions.assertThat(bytesRead).isEqualTo(expected); } @Test @@ -187,7 +187,7 @@ void testComplexReadWriteLine() throws Exception { outbuffer.flush(outputStream); long bytesWritten = outbuffer.getMetrics().getBytesTransferred(); - Assertions.assertEquals(8, bytesWritten); + Assertions.assertThat(bytesWritten).isEqualTo(8); final StringBuilder buffer = new StringBuilder(); for (int i = 0; i < 14; i++) { @@ -198,7 +198,7 @@ void testComplexReadWriteLine() throws Exception { outbuffer.write(buffer.toString().getBytes(StandardCharsets.US_ASCII), outputStream); outbuffer.flush(outputStream); bytesWritten = outbuffer.getMetrics().getBytesTransferred(); - Assertions.assertEquals(8 + 14 + 2, bytesWritten); + Assertions.assertThat(bytesWritten).isEqualTo(8 + 14 + 2); buffer.setLength(0); for (int i = 0; i < 15; i++) { @@ -209,7 +209,7 @@ void testComplexReadWriteLine() throws Exception { outbuffer.write(buffer.toString().getBytes(StandardCharsets.US_ASCII), outputStream); outbuffer.flush(outputStream); bytesWritten = outbuffer.getMetrics().getBytesTransferred(); - Assertions.assertEquals(8 + 14 + 2 + 15 + 2 , bytesWritten); + Assertions.assertThat(bytesWritten).isEqualTo(8 + 14 + 2 + 15 + 2); buffer.setLength(0); for (int i = 0; i < 16; i++) { @@ -220,12 +220,12 @@ void testComplexReadWriteLine() throws Exception { outbuffer.write(buffer.toString().getBytes(StandardCharsets.US_ASCII), outputStream); outbuffer.flush(outputStream); bytesWritten = outbuffer.getMetrics().getBytesTransferred(); - Assertions.assertEquals(8 + 14 + 2 + 15 + 2 + 16 + 2, bytesWritten); + Assertions.assertThat(bytesWritten).isEqualTo(8 + 14 + 2 + 15 + 2 + 16 + 2); outbuffer.write(new byte[] {'a'}, outputStream); outbuffer.flush(outputStream); bytesWritten = outbuffer.getMetrics().getBytesTransferred(); - Assertions.assertEquals(8 + 14 + 2 + 15 + 2 + 16 + 2 + 1, bytesWritten); + Assertions.assertThat(bytesWritten).isEqualTo(8 + 14 + 2 + 15 + 2 + 16 + 2 + 1); final SessionInputBuffer inBuffer = new SessionInputBufferImpl(16); final ByteArrayInputStream inputStream = new ByteArrayInputStream(outputStream.toByteArray()); @@ -233,36 +233,36 @@ void testComplexReadWriteLine() throws Exception { final CharArrayBuffer chbuffer = new CharArrayBuffer(16); chbuffer.clear(); inBuffer.readLine(chbuffer, inputStream); - Assertions.assertEquals("a", chbuffer.toString()); + Assertions.assertThat(chbuffer.toString()).isEqualTo("a"); chbuffer.clear(); inBuffer.readLine(chbuffer, inputStream); - Assertions.assertEquals("", chbuffer.toString()); + Assertions.assertThat(chbuffer.toString()).isEqualTo(""); chbuffer.clear(); inBuffer.readLine(chbuffer, inputStream); - Assertions.assertEquals("\r", chbuffer.toString()); + Assertions.assertThat(chbuffer.toString()).isEqualTo("\r"); chbuffer.clear(); inBuffer.readLine(chbuffer, inputStream); - Assertions.assertEquals("", chbuffer.toString()); + Assertions.assertThat(chbuffer.toString()).isEqualTo(""); chbuffer.clear(); inBuffer.readLine(chbuffer, inputStream); - Assertions.assertEquals(s1, chbuffer.toString()); + Assertions.assertThat(chbuffer.toString()).isEqualTo(s1); chbuffer.clear(); inBuffer.readLine(chbuffer, inputStream); - Assertions.assertEquals(s2, chbuffer.toString()); + Assertions.assertThat(chbuffer.toString()).isEqualTo(s2); chbuffer.clear(); inBuffer.readLine(chbuffer, inputStream); - Assertions.assertEquals(s3, chbuffer.toString()); + Assertions.assertThat(chbuffer.toString()).isEqualTo(s3); chbuffer.clear(); inBuffer.readLine(chbuffer, inputStream); - Assertions.assertEquals("a", chbuffer.toString()); + Assertions.assertThat(chbuffer.toString()).isEqualTo("a"); chbuffer.clear(); inBuffer.readLine(chbuffer, inputStream); - Assertions.assertEquals(-1, inBuffer.readLine(chbuffer, inputStream)); + Assertions.assertThat(inBuffer.readLine(chbuffer, inputStream)).isEqualTo(-1); chbuffer.clear(); inBuffer.readLine(chbuffer, inputStream); - Assertions.assertEquals(-1, inBuffer.readLine(chbuffer, inputStream)); + Assertions.assertThat(inBuffer.readLine(chbuffer, inputStream)).isEqualTo(-1); final long bytesRead = inBuffer.getMetrics().getBytesTransferred(); - Assertions.assertEquals(bytesWritten, bytesRead); + Assertions.assertThat(bytesRead).isEqualTo(bytesWritten); } @Test @@ -298,7 +298,7 @@ void testBasicReadWriteLineLargeBuffer() throws Exception { for (final String teststr : teststrs) { expected += teststr.length() + 2/*CRLF*/; } - Assertions.assertEquals(expected, bytesWritten); + Assertions.assertThat(bytesWritten).isEqualTo(expected); final SessionInputBuffer inBuffer = new SessionInputBufferImpl(1024); final ByteArrayInputStream inputStream = new ByteArrayInputStream(outputStream.toByteArray()); @@ -306,14 +306,14 @@ void testBasicReadWriteLineLargeBuffer() throws Exception { for (final String teststr : teststrs) { chbuffer.clear(); inBuffer.readLine(chbuffer, inputStream); - Assertions.assertEquals(teststr, chbuffer.toString()); + Assertions.assertThat(chbuffer.toString()).isEqualTo(teststr); } chbuffer.clear(); - Assertions.assertEquals(-1, inBuffer.readLine(chbuffer, inputStream)); + Assertions.assertThat(inBuffer.readLine(chbuffer, inputStream)).isEqualTo(-1); chbuffer.clear(); - Assertions.assertEquals(-1, inBuffer.readLine(chbuffer, inputStream)); + Assertions.assertThat(inBuffer.readLine(chbuffer, inputStream)).isEqualTo(-1); final long bytesRead = inBuffer.getMetrics().getBytesTransferred(); - Assertions.assertEquals(expected, bytesRead); + Assertions.assertThat(bytesRead).isEqualTo(expected); } @Test @@ -338,22 +338,22 @@ void testReadWriteBytes() throws Exception { } outbuffer.flush(outputStream); final long bytesWritten = outbuffer.getMetrics().getBytesTransferred(); - Assertions.assertEquals(out.length, bytesWritten); + Assertions.assertThat(bytesWritten).isEqualTo(out.length); final byte[] tmp = outputStream.toByteArray(); - Assertions.assertEquals(out.length, tmp.length); + Assertions.assertThat(tmp.length).isEqualTo(out.length); for (int i = 0; i < out.length; i++) { - Assertions.assertEquals(out[i], tmp[i]); + Assertions.assertThat(tmp[i]).isEqualTo(out[i]); } final SessionInputBuffer inBuffer = new SessionInputBufferImpl(16); final ByteArrayInputStream inputStream = new ByteArrayInputStream(tmp); // these read operations will have no effect - Assertions.assertEquals(0, inBuffer.read(null, 0, 10, inputStream)); - Assertions.assertEquals(0, inBuffer.read(null, inputStream)); + Assertions.assertThat(inBuffer.read(null, 0, 10, inputStream)).isEqualTo(0); + Assertions.assertThat(inBuffer.read(null, inputStream)).isEqualTo(0); long bytesRead = inBuffer.getMetrics().getBytesTransferred(); - Assertions.assertEquals(0, bytesRead); + Assertions.assertThat(bytesRead).isEqualTo(0); final byte[] in = new byte[40]; off = 0; @@ -371,12 +371,12 @@ void testReadWriteBytes() throws Exception { remaining -= readLen; } for (int i = 0; i < out.length; i++) { - Assertions.assertEquals(out[i], in[i]); + Assertions.assertThat(in[i]).isEqualTo(out[i]); } - Assertions.assertEquals(-1, inBuffer.read(tmp, inputStream)); - Assertions.assertEquals(-1, inBuffer.read(tmp, inputStream)); + Assertions.assertThat(inBuffer.read(tmp, inputStream)).isEqualTo(-1); + Assertions.assertThat(inBuffer.read(tmp, inputStream)).isEqualTo(-1); bytesRead = inBuffer.getMetrics().getBytesTransferred(); - Assertions.assertEquals(out.length, bytesRead); + Assertions.assertThat(bytesRead).isEqualTo(out.length); } @Test @@ -393,12 +393,12 @@ void testReadWriteByte() throws Exception { } outbuffer.flush(outputStream); final long bytesWritten = outbuffer.getMetrics().getBytesTransferred(); - Assertions.assertEquals(out.length, bytesWritten); + Assertions.assertThat(bytesWritten).isEqualTo(out.length); final byte[] tmp = outputStream.toByteArray(); - Assertions.assertEquals(out.length, tmp.length); + Assertions.assertThat(tmp.length).isEqualTo(out.length); for (int i = 0; i < out.length; i++) { - Assertions.assertEquals(out[i], tmp[i]); + Assertions.assertThat(tmp[i]).isEqualTo(out[i]); } final SessionInputBuffer inBuffer = new SessionInputBufferImpl(16); @@ -408,12 +408,12 @@ void testReadWriteByte() throws Exception { in[i] = (byte)inBuffer.read(inputStream); } for (int i = 0; i < out.length; i++) { - Assertions.assertEquals(out[i], in[i]); + Assertions.assertThat(in[i]).isEqualTo(out[i]); } - Assertions.assertEquals(-1, inBuffer.read(inputStream)); - Assertions.assertEquals(-1, inBuffer.read(inputStream)); + Assertions.assertThat(inBuffer.read(inputStream)).isEqualTo(-1); + Assertions.assertThat(inBuffer.read(inputStream)).isEqualTo(-1); final long bytesRead = inBuffer.getMetrics().getBytesTransferred(); - Assertions.assertEquals(out.length, bytesRead); + Assertions.assertThat(bytesRead).isEqualTo(out.length); } @Test @@ -451,14 +451,14 @@ void testLineLimit() throws Exception { final CharArrayBuffer chbuffer = new CharArrayBuffer(16); inBuffer1.readLine(chbuffer, inputStream1); final long bytesRead = inBuffer1.getMetrics().getBytesTransferred(); - Assertions.assertEquals(60, bytesRead); + Assertions.assertThat(bytesRead).isEqualTo(60); // 15 char limit final SessionInputBuffer inBuffer2 = new SessionInputBufferImpl(5, 15); final InputStream inputStream2 = new ByteArrayInputStream(tmp); chbuffer.clear(); - Assertions.assertThrows(MessageConstraintException.class, () -> - inBuffer2.readLine(chbuffer, inputStream2)); + Assertions.assertThatThrownBy(() -> + inBuffer2.readLine(chbuffer, inputStream2)).isInstanceOf(MessageConstraintException.class); } @Test @@ -471,14 +471,14 @@ void testLineLimit2() throws Exception { final CharArrayBuffer chbuffer = new CharArrayBuffer(16); inBuffer1.readLine(chbuffer, inputStream1); final long bytesRead = inBuffer1.getMetrics().getBytesTransferred(); - Assertions.assertEquals(13, bytesRead); + Assertions.assertThat(bytesRead).isEqualTo(13); // 10 char limit final SessionInputBuffer inBuffer2 = new SessionInputBufferImpl(25, 10); final InputStream inputStream2 = new ByteArrayInputStream(tmp); chbuffer.clear(); - Assertions.assertThrows(MessageConstraintException.class, () -> - inBuffer2.readLine(chbuffer, inputStream2)); + Assertions.assertThatThrownBy(() -> + inBuffer2.readLine(chbuffer, inputStream2)).isInstanceOf(MessageConstraintException.class); } @Test //HTTPCORE-472 @@ -489,7 +489,7 @@ void testLineLimit3() throws Exception { final ByteArrayInputStream inputStream = new ByteArrayInputStream(tmp); final CharArrayBuffer chbuffer = new CharArrayBuffer(16); inBuffer1.readLine(chbuffer, inputStream); - Assertions.assertEquals("012345678", chbuffer.toString()); + Assertions.assertThat(chbuffer.toString()).isEqualTo("012345678"); } @Test @@ -498,12 +498,12 @@ void testReadLineFringeCase1() throws Exception { final byte[] tmp = s.getBytes(StandardCharsets.US_ASCII); final SessionInputBuffer inBuffer1 = new SessionInputBufferImpl(128); final ByteArrayInputStream inputStream = new ByteArrayInputStream(tmp); - Assertions.assertEquals('a', inBuffer1.read(inputStream)); - Assertions.assertEquals('b', inBuffer1.read(inputStream)); - Assertions.assertEquals('c', inBuffer1.read(inputStream)); - Assertions.assertEquals('\r', inBuffer1.read(inputStream)); + Assertions.assertThat(inBuffer1.read(inputStream)).isEqualTo('a'); + Assertions.assertThat(inBuffer1.read(inputStream)).isEqualTo('b'); + Assertions.assertThat(inBuffer1.read(inputStream)).isEqualTo('c'); + Assertions.assertThat(inBuffer1.read(inputStream)).isEqualTo('\r'); final CharArrayBuffer chbuffer = new CharArrayBuffer(16); - Assertions.assertEquals(0, inBuffer1.readLine(chbuffer, inputStream)); + Assertions.assertThat(inBuffer1.readLine(chbuffer, inputStream)).isEqualTo(0); } static final int[] SWISS_GERMAN_HELLO = { @@ -551,7 +551,7 @@ void testMultibyteCodedReadWriteLine() throws Exception { final long expected = ((s1.getBytes(StandardCharsets.UTF_8).length + 2) + (s2.getBytes(StandardCharsets.UTF_8).length + 2) + (s3.getBytes(StandardCharsets.UTF_8).length + 2)) * 10L; - Assertions.assertEquals(expected, bytesWritten); + Assertions.assertThat(bytesWritten).isEqualTo(expected); final SessionInputBuffer inBuffer = new SessionInputBufferImpl(16, StandardCharsets.UTF_8.newDecoder()); final ByteArrayInputStream inputStream = new ByteArrayInputStream(outputStream.toByteArray()); @@ -559,20 +559,20 @@ void testMultibyteCodedReadWriteLine() throws Exception { for (int i = 0; i < 10; i++) { chbuffer.clear(); inBuffer.readLine(chbuffer, inputStream); - Assertions.assertEquals(s1, chbuffer.toString()); + Assertions.assertThat(chbuffer.toString()).isEqualTo(s1); chbuffer.clear(); inBuffer.readLine(chbuffer, inputStream); - Assertions.assertEquals(s2, chbuffer.toString()); + Assertions.assertThat(chbuffer.toString()).isEqualTo(s2); chbuffer.clear(); inBuffer.readLine(chbuffer, inputStream); - Assertions.assertEquals(s3, chbuffer.toString()); + Assertions.assertThat(chbuffer.toString()).isEqualTo(s3); } chbuffer.clear(); - Assertions.assertEquals(-1, inBuffer.readLine(chbuffer, inputStream)); + Assertions.assertThat(inBuffer.readLine(chbuffer, inputStream)).isEqualTo(-1); chbuffer.clear(); - Assertions.assertEquals(-1, inBuffer.readLine(chbuffer, inputStream)); + Assertions.assertThat(inBuffer.readLine(chbuffer, inputStream)).isEqualTo(-1); final long bytesRead = inBuffer.getMetrics().getBytesTransferred(); - Assertions.assertEquals(expected, bytesRead); + Assertions.assertThat(bytesRead).isEqualTo(expected); } @Test @@ -599,7 +599,7 @@ void testMultibyteCodedReadWriteLongLine() throws Exception { chbuffer.clear(); inBuffer.readLine(chbuffer, inputStream); - Assertions.assertEquals(s, chbuffer.toString()); + Assertions.assertThat(chbuffer.toString()).isEqualTo(s); } @Test @@ -620,7 +620,7 @@ void testNonAsciiReadWriteLine() throws Exception { outbuffer.flush(outputStream); final long bytesWritten = outbuffer.getMetrics().getBytesTransferred(); final long expected = ((s1.getBytes(StandardCharsets.UTF_8).length + 2)) * 10L + 2; - Assertions.assertEquals(expected, bytesWritten); + Assertions.assertThat(bytesWritten).isEqualTo(expected); final SessionInputBuffer inBuffer = new SessionInputBufferImpl(16, StandardCharsets.UTF_8.newDecoder()); final ByteArrayInputStream inputStream = new ByteArrayInputStream(outputStream.toByteArray()); @@ -628,17 +628,17 @@ void testNonAsciiReadWriteLine() throws Exception { for (int i = 0; i < 10; i++) { chbuffer.clear(); final int len = inBuffer.readLine(chbuffer, inputStream); - Assertions.assertEquals(len, SWISS_GERMAN_HELLO.length); - Assertions.assertEquals(s1, chbuffer.toString()); + Assertions.assertThat(SWISS_GERMAN_HELLO.length).isEqualTo(len); + Assertions.assertThat(chbuffer.toString()).isEqualTo(s1); } chbuffer.clear(); - Assertions.assertEquals(0, inBuffer.readLine(chbuffer, inputStream)); + Assertions.assertThat(inBuffer.readLine(chbuffer, inputStream)).isEqualTo(0); chbuffer.clear(); - Assertions.assertEquals(-1, inBuffer.readLine(chbuffer, inputStream)); + Assertions.assertThat(inBuffer.readLine(chbuffer, inputStream)).isEqualTo(-1); chbuffer.clear(); - Assertions.assertEquals(-1, inBuffer.readLine(chbuffer, inputStream)); + Assertions.assertThat(inBuffer.readLine(chbuffer, inputStream)).isEqualTo(-1); final long bytesRead = inBuffer.getMetrics().getBytesTransferred(); - Assertions.assertEquals(expected, bytesRead); + Assertions.assertThat(bytesRead).isEqualTo(expected); } @Test @@ -651,8 +651,8 @@ void testUnmappableInputActionReport() { final ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); final CharArrayBuffer chbuffer = new CharArrayBuffer(32); chbuffer.append(s); - Assertions.assertThrows(CharacterCodingException.class, () -> - outbuffer.writeLine(chbuffer, outputStream)); + Assertions.assertThatThrownBy(() -> + outbuffer.writeLine(chbuffer, outputStream)).isInstanceOf(CharacterCodingException.class); } @Test @@ -668,7 +668,7 @@ void testUnmappableInputActionReplace() throws Exception { outbuffer.writeLine(chbuffer, outputStream); outbuffer.flush(outputStream); final String result = new String(outputStream.toByteArray(), StandardCharsets.ISO_8859_1); - Assertions.assertEquals("This text contains a circumflex ? !!!\r\n", result); + Assertions.assertThat(result).isEqualTo("This text contains a circumflex ? !!!\r\n"); } @Test @@ -684,7 +684,7 @@ void testUnmappableInputActionIgnore() throws Exception { outbuffer.writeLine(chbuffer, outputStream); outbuffer.flush(outputStream); final String result = new String(outputStream.toByteArray(), StandardCharsets.ISO_8859_1); - Assertions.assertEquals("This text contains a circumflex !!!\r\n", result); + Assertions.assertThat(result).isEqualTo("This text contains a circumflex !!!\r\n"); } @Test @@ -696,8 +696,8 @@ void testMalformedInputActionReport() { final SessionInputBuffer inBuffer = new SessionInputBufferImpl(16, decoder); final ByteArrayInputStream inputStream = new ByteArrayInputStream(tmp); final CharArrayBuffer chbuffer = new CharArrayBuffer(32); - Assertions.assertThrows(CharacterCodingException.class, () -> - inBuffer.readLine(chbuffer, inputStream)); + Assertions.assertThatThrownBy(() -> + inBuffer.readLine(chbuffer, inputStream)).isInstanceOf(CharacterCodingException.class); } @Test @@ -710,7 +710,7 @@ void testMalformedInputActionReplace() throws Exception { final ByteArrayInputStream inputStream = new ByteArrayInputStream(tmp); final CharArrayBuffer chbuffer = new CharArrayBuffer(32); inBuffer.readLine(chbuffer, inputStream); - Assertions.assertEquals("Gr\ufffdezi_z\ufffdm\ufffd", chbuffer.toString()); + Assertions.assertThat(chbuffer.toString()).isEqualTo("Gr\ufffdezi_z\ufffdm\ufffd"); } @Test @@ -723,8 +723,7 @@ void testMalformedInputActionIgnore() throws Exception { final ByteArrayInputStream inputStream = new ByteArrayInputStream(tmp); final CharArrayBuffer chbuffer = new CharArrayBuffer(32); inBuffer.readLine(chbuffer, inputStream); - Assertions.assertEquals("Grezi_zm", chbuffer.toString()); + Assertions.assertThat(chbuffer.toString()).isEqualTo("Grezi_zm"); } } - diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/impl/nio/TestAbstractHttp1StreamDuplexerCapacityWindow.java b/httpcore5/src/test/java/org/apache/hc/core5/http/impl/nio/TestAbstractHttp1StreamDuplexerCapacityWindow.java index f17f3db663..46138f1039 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/impl/nio/TestAbstractHttp1StreamDuplexerCapacityWindow.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/impl/nio/TestAbstractHttp1StreamDuplexerCapacityWindow.java @@ -32,7 +32,7 @@ import org.apache.hc.core5.http.impl.nio.AbstractHttp1StreamDuplexer.CapacityWindow; import org.apache.hc.core5.reactor.IOSession; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; @@ -55,7 +55,7 @@ void prepareMocks() { void testWindowUpdate() throws IOException { final CapacityWindow window = new CapacityWindow(0, ioSession); window.update(1); - Assertions.assertEquals(1, window.getWindow()); + Assertions.assertThat(window.getWindow()).isEqualTo(1); Mockito.verify(ioSession).setEvent(ArgumentMatchers.eq(SelectionKey.OP_READ)); Mockito.verifyNoMoreInteractions(ioSession); } @@ -64,7 +64,7 @@ void testWindowUpdate() throws IOException { void testRemoveCapacity() { final CapacityWindow window = new CapacityWindow(1, ioSession); window.removeCapacity(1); - Assertions.assertEquals(0, window.getWindow()); + Assertions.assertThat(window.getWindow()).isEqualTo(0); Mockito.verify(ioSession).clearEvent(ArgumentMatchers.eq(SelectionKey.OP_READ)); Mockito.verifyNoMoreInteractions(ioSession); } @@ -81,14 +81,14 @@ void noReadsSetAfterWindowIsClosed() throws IOException { void windowCannotUnderflow() { final CapacityWindow window = new CapacityWindow(Integer.MIN_VALUE, ioSession); window.removeCapacity(1); - Assertions.assertEquals(Integer.MIN_VALUE, window.getWindow()); + Assertions.assertThat(window.getWindow()).isEqualTo(Integer.MIN_VALUE); } @Test void windowCannotOverflow() throws IOException { final CapacityWindow window = new CapacityWindow(Integer.MAX_VALUE, ioSession); window.update(1); - Assertions.assertEquals(Integer.MAX_VALUE, window.getWindow()); + Assertions.assertThat(window.getWindow()).isEqualTo(Integer.MAX_VALUE); } @Test @@ -96,7 +96,7 @@ void noChangesIfUpdateIsNonPositive() throws IOException { final CapacityWindow window = new CapacityWindow(1, ioSession); window.update(0); window.update(-1); - Assertions.assertEquals(1, window.getWindow()); + Assertions.assertThat(window.getWindow()).isEqualTo(1); Mockito.verifyNoInteractions(ioSession); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/impl/nio/TestChunkDecoder.java b/httpcore5/src/test/java/org/apache/hc/core5/http/impl/nio/TestChunkDecoder.java index 360a2e3ece..aef0680208 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/impl/nio/TestChunkDecoder.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/impl/nio/TestChunkDecoder.java @@ -42,7 +42,7 @@ import org.apache.hc.core5.http.config.Http1Config; import org.apache.hc.core5.http.impl.BasicHttpTransportMetrics; import org.apache.hc.core5.http.nio.SessionInputBuffer; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; /** @@ -62,16 +62,16 @@ void testBasicDecoding() throws Exception { final ByteBuffer dst = ByteBuffer.allocate(1024); int bytesRead = decoder.read(dst); - Assertions.assertEquals(16, bytesRead); - Assertions.assertEquals("0123456789abcdef", CodecTestUtils.convert(dst)); + Assertions.assertThat(bytesRead).isEqualTo(16); + Assertions.assertThat(CodecTestUtils.convert(dst)).isEqualTo("0123456789abcdef"); final List trailers = decoder.getTrailers(); - Assertions.assertNull(trailers); + Assertions.assertThat(trailers).isNull(); dst.clear(); bytesRead = decoder.read(dst); - Assertions.assertEquals(-1, bytesRead); - Assertions.assertTrue(decoder.isCompleted()); - Assertions.assertEquals("[chunk-coded; completed: true]", decoder.toString()); + Assertions.assertThat(bytesRead).isEqualTo(-1); + Assertions.assertThat(decoder.isCompleted()).isTrue(); + Assertions.assertThat(decoder.toString()).isEqualTo("[chunk-coded; completed: true]"); } @Test @@ -95,20 +95,20 @@ void testComplexDecoding() throws Exception { } } - Assertions.assertEquals(26, bytesRead); - Assertions.assertEquals("12345678901234561234512345", CodecTestUtils.convert(dst)); + Assertions.assertThat(bytesRead).isEqualTo(26); + Assertions.assertThat(CodecTestUtils.convert(dst)).isEqualTo("12345678901234561234512345"); final List trailers = decoder.getTrailers(); - Assertions.assertEquals(2, trailers.size()); - Assertions.assertEquals("Footer1", trailers.get(0).getName()); - Assertions.assertEquals("abcde", trailers.get(0).getValue()); - Assertions.assertEquals("Footer2", trailers.get(1).getName()); - Assertions.assertEquals("fghij", trailers.get(1).getValue()); + Assertions.assertThat(trailers.size()).isEqualTo(2); + Assertions.assertThat(trailers.get(0).getName()).isEqualTo("Footer1"); + Assertions.assertThat(trailers.get(0).getValue()).isEqualTo("abcde"); + Assertions.assertThat(trailers.get(1).getName()).isEqualTo("Footer2"); + Assertions.assertThat(trailers.get(1).getValue()).isEqualTo("fghij"); dst.clear(); bytesRead = decoder.read(dst); - Assertions.assertEquals(-1, bytesRead); - Assertions.assertTrue(decoder.isCompleted()); + Assertions.assertThat(bytesRead).isEqualTo(-1); + Assertions.assertThat(decoder.isCompleted()).isTrue(); } @Test @@ -136,14 +136,14 @@ void testDecodingWithSmallBuffer() throws Exception { tmp.compact(); } - Assertions.assertEquals(16, bytesRead); - Assertions.assertEquals("0123456789abcdef", CodecTestUtils.convert(dst)); - Assertions.assertTrue(decoder.isCompleted()); + Assertions.assertThat(bytesRead).isEqualTo(16); + Assertions.assertThat(CodecTestUtils.convert(dst)).isEqualTo("0123456789abcdef"); + Assertions.assertThat(decoder.isCompleted()).isTrue(); dst.clear(); bytesRead = decoder.read(dst); - Assertions.assertEquals(-1, bytesRead); - Assertions.assertTrue(decoder.isCompleted()); + Assertions.assertThat(bytesRead).isEqualTo(-1); + Assertions.assertThat(decoder.isCompleted()).isTrue(); } @Test @@ -160,7 +160,9 @@ void testMalformedChunk() { final ByteBuffer dst = ByteBuffer.allocate(1024); - Assertions.assertThrows(MalformedChunkCodingException.class, () -> decoder.read(dst)); + Assertions.assertThatThrownBy(() -> + decoder.read(dst)) + .isInstanceOf(MalformedChunkCodingException.class); } private static void decode(final String s) throws Exception { @@ -179,38 +181,39 @@ private static void decode(final String s) throws Exception { @Test void testChunkSizeMinusOneRejected() { - Assertions.assertThrows(MalformedChunkCodingException.class, - () -> decode("-1\r\n5\r\nhello\r\n0\r\n\r\n")); + Assertions.assertThatThrownBy(() -> decode("-1\r\n5\r\nhello\r\n0\r\n\r\n")) + .isInstanceOf(MalformedChunkCodingException.class); } @Test void testChunkSizeNegativeRejected() { - Assertions.assertThrows(MalformedChunkCodingException.class, - () -> decode("-5\r\nhello\r\n0\r\n\r\n")); + Assertions.assertThatThrownBy(() -> decode("-5\r\nhello\r\n0\r\n\r\n")) + .isInstanceOf(MalformedChunkCodingException.class); } @Test void testChunkSizePlusSignRejected() { - Assertions.assertThrows(MalformedChunkCodingException.class, - () -> decode("+5\r\nhello\r\n0\r\n\r\n")); + Assertions.assertThatThrownBy(() -> decode("+5\r\nhello\r\n0\r\n\r\n")) + .isInstanceOf(MalformedChunkCodingException.class); } @Test void testChunkSizeMinusZeroRejected() { - Assertions.assertThrows(MalformedChunkCodingException.class, - () -> decode("-0\r\n\r\n")); + Assertions.assertThatThrownBy(() -> decode("-0\r\n\r\n")) + .isInstanceOf(MalformedChunkCodingException.class); } @Test void testChunkSizeBlankRejected() { - Assertions.assertThrows(MalformedChunkCodingException.class, - () -> decode(" \r\nhello\r\n0\r\n\r\n")); + Assertions.assertThatThrownBy(() -> decode(" \r\nhello\r\n0\r\n\r\n")) + .isInstanceOf(MalformedChunkCodingException.class); } @Test void testChunkSizeOverflowRejected() { - Assertions.assertThrows(MalformedChunkCodingException.class, - () -> decode("FFFFFFFFFFFFFFFFF\r\nhello\r\n0\r\n\r\n")); + Assertions.assertThatThrownBy(() -> + decode("FFFFFFFFFFFFFFFFF\r\nhello\r\n0\r\n\r\n")) + .isInstanceOf(MalformedChunkCodingException.class); } @Test @@ -253,21 +256,21 @@ void testIncompleteChunkDecoding() throws Exception { } } - Assertions.assertEquals(27, bytesRead); - Assertions.assertEquals("123456789012345612345abcdef", CodecTestUtils.convert(dst)); - Assertions.assertTrue(decoder.isCompleted()); + Assertions.assertThat(bytesRead).isEqualTo(27); + Assertions.assertThat(CodecTestUtils.convert(dst)).isEqualTo("123456789012345612345abcdef"); + Assertions.assertThat(decoder.isCompleted()).isTrue(); final List trailers = decoder.getTrailers(); - Assertions.assertEquals(2, trailers.size()); - Assertions.assertEquals("Footer1", trailers.get(0).getName()); - Assertions.assertEquals("abcde", trailers.get(0).getValue()); - Assertions.assertEquals("Footer2", trailers.get(1).getName()); - Assertions.assertEquals("fghij", trailers.get(1).getValue()); + Assertions.assertThat(trailers.size()).isEqualTo(2); + Assertions.assertThat(trailers.get(0).getName()).isEqualTo("Footer1"); + Assertions.assertThat(trailers.get(0).getValue()).isEqualTo("abcde"); + Assertions.assertThat(trailers.get(1).getName()).isEqualTo("Footer2"); + Assertions.assertThat(trailers.get(1).getValue()).isEqualTo("fghij"); dst.clear(); bytesRead = decoder.read(dst); - Assertions.assertEquals(-1, bytesRead); - Assertions.assertTrue(decoder.isCompleted()); + Assertions.assertThat(bytesRead).isEqualTo(-1); + Assertions.assertThat(decoder.isCompleted()).isTrue(); } @Test @@ -281,8 +284,8 @@ void testMalformedChunkSizeDecoding() { final ChunkDecoder decoder = new ChunkDecoder(channel, inbuf, metrics); final ByteBuffer dst = ByteBuffer.allocate(1024); - Assertions.assertThrows(MalformedChunkCodingException.class, () -> - decoder.read(dst)); + Assertions.assertThatThrownBy(() -> + decoder.read(dst)).isInstanceOf(MalformedChunkCodingException.class); } @Test @@ -296,8 +299,8 @@ void testMalformedChunkEndingDecoding() { final ChunkDecoder decoder = new ChunkDecoder(channel, inbuf, metrics); final ByteBuffer dst = ByteBuffer.allocate(1024); - Assertions.assertThrows(MalformedChunkCodingException.class, () -> - decoder.read(dst)); + Assertions.assertThatThrownBy(() -> + decoder.read(dst)).isInstanceOf(MalformedChunkCodingException.class); } @Test @@ -311,9 +314,9 @@ void testMalformedChunkTruncatedChunk() throws Exception { final ChunkDecoder decoder = new ChunkDecoder(channel, inbuf, metrics); final ByteBuffer dst = ByteBuffer.allocate(1024); - Assertions.assertEquals(2, decoder.read(dst)); - Assertions.assertThrows(TruncatedChunkException.class, () -> - decoder.read(dst)); + Assertions.assertThat(decoder.read(dst)).isEqualTo(2); + Assertions.assertThatThrownBy(() -> + decoder.read(dst)).isInstanceOf(TruncatedChunkException.class); } @Test @@ -330,13 +333,13 @@ void testFoldedFooters() throws Exception { final ByteBuffer dst = ByteBuffer.allocate(1024); final int bytesRead = decoder.read(dst); - Assertions.assertEquals(26, bytesRead); - Assertions.assertEquals("12345678901234561234512345", CodecTestUtils.convert(dst)); + Assertions.assertThat(bytesRead).isEqualTo(26); + Assertions.assertThat(CodecTestUtils.convert(dst)).isEqualTo("12345678901234561234512345"); final List trailers = decoder.getTrailers(); - Assertions.assertEquals(1, trailers.size()); - Assertions.assertEquals("Footer1", trailers.get(0).getName()); - Assertions.assertEquals("abcde fghij", trailers.get(0).getValue()); + Assertions.assertThat(trailers.size()).isEqualTo(1); + Assertions.assertThat(trailers.get(0).getName()).isEqualTo("Footer1"); + Assertions.assertThat(trailers.get(0).getValue()).isEqualTo("abcde fghij"); } @Test @@ -351,8 +354,8 @@ void testMalformedFooters() { final ChunkDecoder decoder = new ChunkDecoder(channel, inbuf, metrics); final ByteBuffer dst = ByteBuffer.allocate(1024); - Assertions.assertThrows(IOException.class, () -> - decoder.read(dst)); + Assertions.assertThatThrownBy(() -> + decoder.read(dst)).isInstanceOf(IOException.class); } @Test @@ -368,11 +371,11 @@ void testMissingLastCRLF() { final ByteBuffer dst = ByteBuffer.allocate(1024); - Assertions.assertThrows(MalformedChunkCodingException.class, () -> { + Assertions.assertThatThrownBy(() -> { while (dst.hasRemaining() && !decoder.isCompleted()) { decoder.read(dst); } - }); + }).isInstanceOf(MalformedChunkCodingException.class); } @Test @@ -388,7 +391,7 @@ void testMissingClosingChunk() { final ByteBuffer dst = ByteBuffer.allocate(1024); - Assertions.assertThrows(ConnectionClosedException.class, () -> { + Assertions.assertThatThrownBy(() -> { long bytesRead = 0; try { while (dst.hasRemaining() && !decoder.isCompleted()) { @@ -398,12 +401,12 @@ void testMissingClosingChunk() { } } } catch (final MalformedChunkCodingException ex) { - Assertions.assertEquals(26L, bytesRead); - Assertions.assertEquals("12345678901234561234512345", CodecTestUtils.convert(dst)); - Assertions.assertTrue(decoder.isCompleted()); + Assertions.assertThat(bytesRead).isEqualTo(26L); + Assertions.assertThat(CodecTestUtils.convert(dst)).isEqualTo("12345678901234561234512345"); + Assertions.assertThat(decoder.isCompleted()).isTrue(); throw ex; } - }); + }).isInstanceOf(ConnectionClosedException.class); } @Test @@ -432,11 +435,11 @@ void testReadingWitSmallBuffer() throws Exception { } } - Assertions.assertEquals(80, bytesRead); - Assertions.assertEquals("12345678901234561234567890123456" + + Assertions.assertThat(bytesRead).isEqualTo(80); + Assertions.assertThat(CodecTestUtils.convert(dst)).isEqualTo("12345678901234561234567890123456" + "12345678901234561234567890123456" + - "1234567890123456", CodecTestUtils.convert(dst)); - Assertions.assertTrue(decoder.isCompleted()); + "1234567890123456"); + Assertions.assertThat(decoder.isCompleted()).isTrue(); } @Test @@ -460,9 +463,9 @@ void testEndOfStreamConditionReadingFooters() throws Exception { } } - Assertions.assertEquals(26, bytesRead); - Assertions.assertEquals("12345678901234561234512345", CodecTestUtils.convert(dst)); - Assertions.assertTrue(decoder.isCompleted()); + Assertions.assertThat(bytesRead).isEqualTo(26); + Assertions.assertThat(CodecTestUtils.convert(dst)).isEqualTo("12345678901234561234512345"); + Assertions.assertThat(decoder.isCompleted()).isTrue(); } @Test @@ -480,8 +483,8 @@ void testTooLongChunkHeader() throws Exception { while (dst.hasRemaining() && !decoder1.isCompleted()) { decoder1.read(dst); } - Assertions.assertEquals("12345", CodecTestUtils.convert(dst)); - Assertions.assertTrue(decoder1.isCompleted()); + Assertions.assertThat(CodecTestUtils.convert(dst)).isEqualTo("12345"); + Assertions.assertThat(decoder1.isCompleted()).isTrue(); final ReadableByteChannel channel2 = new ReadableByteChannelMock( new String[] {s}, StandardCharsets.US_ASCII); @@ -491,7 +494,9 @@ void testTooLongChunkHeader() throws Exception { final ChunkDecoder decoder2 = new ChunkDecoder(channel2, inbuf2, metrics2); dst.clear(); - Assertions.assertThrows(MessageConstraintException.class, () -> decoder2.read(dst)); + Assertions.assertThatThrownBy(() -> + decoder2.read(dst)) + .isInstanceOf(MessageConstraintException.class); } @Test @@ -507,11 +512,11 @@ void testTooLongFooter() throws Exception { final ByteBuffer dst = ByteBuffer.allocate(1024); final int bytesRead = decoder1.read(dst); - Assertions.assertEquals(16, bytesRead); - Assertions.assertEquals("1234567890123456", CodecTestUtils.convert(dst)); + Assertions.assertThat(bytesRead).isEqualTo(16); + Assertions.assertThat(CodecTestUtils.convert(dst)).isEqualTo("1234567890123456"); final List trailers = decoder1.getTrailers(); - Assertions.assertNotNull(trailers); - Assertions.assertEquals(1, trailers.size()); + Assertions.assertThat(trailers).isNotNull(); + Assertions.assertThat(trailers.size()).isEqualTo(1); final ReadableByteChannel channel2 = new ReadableByteChannelMock( new String[] {s}, StandardCharsets.US_ASCII); @@ -521,7 +526,9 @@ void testTooLongFooter() throws Exception { final ChunkDecoder decoder2 = new ChunkDecoder(channel2, inbuf2, metrics2); dst.clear(); - Assertions.assertThrows(MessageConstraintException.class, () -> decoder2.read(dst)); + Assertions.assertThatThrownBy(() -> + decoder2.read(dst)) + .isInstanceOf(MessageConstraintException.class); } @Test @@ -538,11 +545,11 @@ void testTooLongFoldedFooter() throws Exception { final ByteBuffer dst = ByteBuffer.allocate(1024); final int bytesRead = decoder1.read(dst); - Assertions.assertEquals(16, bytesRead); - Assertions.assertEquals("1234567890123456", CodecTestUtils.convert(dst)); + Assertions.assertThat(bytesRead).isEqualTo(16); + Assertions.assertThat(CodecTestUtils.convert(dst)).isEqualTo("1234567890123456"); final List trailers = decoder1.getTrailers(); - Assertions.assertNotNull(trailers); - Assertions.assertEquals(1, trailers.size()); + Assertions.assertThat(trailers).isNotNull(); + Assertions.assertThat(trailers.size()).isEqualTo(1); final Http1Config http1Config = Http1Config.custom() .setMaxLineLength(25) @@ -554,7 +561,9 @@ void testTooLongFoldedFooter() throws Exception { final ChunkDecoder decoder2 = new ChunkDecoder(channel2, inbuf2, http1Config, metrics2); dst.clear(); - Assertions.assertThrows(MessageConstraintException.class, () -> decoder2.read(dst)); + Assertions.assertThatThrownBy(() -> + decoder2.read(dst)) + .isInstanceOf(MessageConstraintException.class); } @Test @@ -570,11 +579,11 @@ void testTooManyFooters() throws Exception { final ByteBuffer dst = ByteBuffer.allocate(1024); final int bytesRead = decoder1.read(dst); - Assertions.assertEquals(16, bytesRead); - Assertions.assertEquals("1234567890123456", CodecTestUtils.convert(dst)); + Assertions.assertThat(bytesRead).isEqualTo(16); + Assertions.assertThat(CodecTestUtils.convert(dst)).isEqualTo("1234567890123456"); final List trailers = decoder1.getTrailers(); - Assertions.assertNotNull(trailers); - Assertions.assertEquals(4, trailers.size()); + Assertions.assertThat(trailers).isNotNull(); + Assertions.assertThat(trailers.size()).isEqualTo(4); final Http1Config http1Config = Http1Config.custom() .setMaxHeaderCount(3).build(); @@ -586,7 +595,9 @@ void testTooManyFooters() throws Exception { final ChunkDecoder decoder2 = new ChunkDecoder(channel2, inbuf2, http1Config, metrics2); dst.clear(); - Assertions.assertThrows(MessageConstraintException.class, () -> decoder2.read(dst)); + Assertions.assertThatThrownBy(() -> + decoder2.read(dst)) + .isInstanceOf(MessageConstraintException.class); } @Test @@ -595,8 +606,12 @@ void testInvalidConstructor() { new String[] {"stuff;", "more stuff"}, StandardCharsets.US_ASCII); final SessionInputBuffer inbuf = new SessionInputBufferImpl(1024, 256, 0, StandardCharsets.US_ASCII); - Assertions.assertThrows(NullPointerException.class, () -> new ChunkDecoder(null, null, null)); - Assertions.assertThrows(NullPointerException.class, () -> new ChunkDecoder(channel, inbuf, null)); + Assertions.assertThatThrownBy(() -> + new ChunkDecoder(null, null, null)) + .isInstanceOf(NullPointerException.class); + Assertions.assertThatThrownBy(() -> + new ChunkDecoder(channel, inbuf, null)) + .isInstanceOf(NullPointerException.class); } @Test @@ -609,8 +624,8 @@ void testInvalidInput() { final SessionInputBuffer inbuf = new SessionInputBufferImpl(1024, 256, 0, StandardCharsets.US_ASCII); final BasicHttpTransportMetrics metrics = new BasicHttpTransportMetrics(); final ChunkDecoder decoder = new ChunkDecoder(channel, inbuf, metrics); - Assertions.assertThrows(NullPointerException.class, () -> - decoder.read(null)); + Assertions.assertThatThrownBy(() -> + decoder.read(null)).isInstanceOf(NullPointerException.class); } @Test @@ -624,12 +639,12 @@ void testHugeChunk() throws Exception { final ByteBuffer dst = ByteBuffer.allocate(4); int bytesRead = decoder.read(dst); - Assertions.assertEquals(4, bytesRead); - Assertions.assertEquals("0123", CodecTestUtils.convert(dst)); + Assertions.assertThat(bytesRead).isEqualTo(4); + Assertions.assertThat(CodecTestUtils.convert(dst)).isEqualTo("0123"); dst.clear(); bytesRead = decoder.read(dst); - Assertions.assertEquals(4, bytesRead); - Assertions.assertEquals("4567", CodecTestUtils.convert(dst)); + Assertions.assertThat(bytesRead).isEqualTo(4); + Assertions.assertThat(CodecTestUtils.convert(dst)).isEqualTo("4567"); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/impl/nio/TestChunkEncoder.java b/httpcore5/src/test/java/org/apache/hc/core5/http/impl/nio/TestChunkEncoder.java index 29b8fd13b6..53a314cb1d 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/impl/nio/TestChunkEncoder.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/impl/nio/TestChunkEncoder.java @@ -36,7 +36,7 @@ import org.apache.hc.core5.http.impl.BasicHttpTransportMetrics; import org.apache.hc.core5.http.message.BasicHeader; import org.apache.hc.core5.http.nio.SessionOutputBuffer; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.mockito.ArgumentMatchers; import org.mockito.Mockito; @@ -62,9 +62,9 @@ void testBasicCoding() throws Exception { final String s = channel.dump(StandardCharsets.US_ASCII); - Assertions.assertTrue(encoder.isCompleted()); - Assertions.assertEquals("5\r\n12345\r\n3\r\n678\r\n2\r\n90\r\n0\r\n\r\n", s); - Assertions.assertEquals("[chunk-coded; completed: true]", encoder.toString()); + Assertions.assertThat(encoder.isCompleted()).isTrue(); + Assertions.assertThat(s).isEqualTo("5\r\n12345\r\n3\r\n678\r\n2\r\n90\r\n0\r\n\r\n"); + Assertions.assertThat(encoder.toString()).isEqualTo("[chunk-coded; completed: true]"); } @Test @@ -80,8 +80,8 @@ void testChunkNoExceed() throws Exception { final String s = channel.dump(StandardCharsets.US_ASCII); - Assertions.assertTrue(encoder.isCompleted()); - Assertions.assertEquals("4\r\n1234\r\n0\r\n\r\n", s); + Assertions.assertThat(encoder.isCompleted()).isTrue(); + Assertions.assertThat(s).isEqualTo("4\r\n1234\r\n0\r\n\r\n"); } @Test // See HTTPCORE-239 @@ -97,24 +97,24 @@ void testLimitedChannel() throws Exception { outbuf.write(CodecTestUtils.wrap("0123456789ABCDEF")); final ByteBuffer src = CodecTestUtils.wrap("0123456789ABCDEF"); - Assertions.assertEquals(0, encoder.write(src)); - Assertions.assertEquals(0, encoder.write(src)); - Assertions.assertEquals(0, encoder.write(src)); + Assertions.assertThat(encoder.write(src)).isEqualTo(0); + Assertions.assertThat(encoder.write(src)).isEqualTo(0); + Assertions.assertThat(encoder.write(src)).isEqualTo(0); // should not be able to copy any bytes, until we flush the channel and buffer channel.reset(); outbuf.flush(channel); channel.reset(); - Assertions.assertEquals(10, encoder.write(src)); + Assertions.assertThat(encoder.write(src)).isEqualTo(10); channel.flush(); - Assertions.assertEquals(6, encoder.write(src)); + Assertions.assertThat(encoder.write(src)).isEqualTo(6); channel.flush(); - Assertions.assertEquals(0, encoder.write(src)); + Assertions.assertThat(encoder.write(src)).isEqualTo(0); outbuf.flush(channel); final String s = channel.dump(StandardCharsets.US_ASCII); - Assertions.assertEquals("4\r\n0123\r\n4\r\n4567\r\n2\r\n89\r\n4\r\nABCD\r\n2\r\nEF\r\n", s); + Assertions.assertThat(s).isEqualTo("4\r\n0123\r\n4\r\n4567\r\n2\r\n89\r\n4\r\nABCD\r\n2\r\nEF\r\n"); } @Test @@ -124,16 +124,16 @@ void testBufferFragments() throws Exception { final BasicHttpTransportMetrics metrics = new BasicHttpTransportMetrics(); final ChunkEncoder encoder = new ChunkEncoder(channel, outbuf, metrics, 1024); - Assertions.assertEquals(16, encoder.write(CodecTestUtils.wrap("0123456789ABCDEF"))); - Assertions.assertEquals(16, encoder.write(CodecTestUtils.wrap("0123456789ABCDEF"))); - Assertions.assertEquals(16, encoder.write(CodecTestUtils.wrap("0123456789ABCDEF"))); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("0123456789ABCDEF"))).isEqualTo(16); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("0123456789ABCDEF"))).isEqualTo(16); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("0123456789ABCDEF"))).isEqualTo(16); Mockito.verify(channel, Mockito.never()).write(ArgumentMatchers.any()); outbuf.flush(channel); final String s = channel.dump(StandardCharsets.US_ASCII); - Assertions.assertEquals("10\r\n0123456789ABCDEF\r\n10\r\n0123456789ABCDEF\r\n" + - "10\r\n0123456789ABCDEF\r\n", s); + Assertions.assertThat(s).isEqualTo("10\r\n0123456789ABCDEF\r\n10\r\n0123456789ABCDEF\r\n" + + "10\r\n0123456789ABCDEF\r\n"); } @Test @@ -145,12 +145,12 @@ void testChunkExceed() throws Exception { final ByteBuffer src = CodecTestUtils.wrap("0123456789ABCDEF"); - Assertions.assertEquals(16, encoder.write(src)); - Assertions.assertEquals(0, src.remaining()); + Assertions.assertThat(encoder.write(src)).isEqualTo(16); + Assertions.assertThat(src.remaining()).isEqualTo(0); outbuf.flush(channel); final String s = channel.dump(StandardCharsets.US_ASCII); - Assertions.assertEquals("4\r\n0123\r\n4\r\n4567\r\n4\r\n89AB\r\n4\r\nCDEF\r\n", s); + Assertions.assertThat(s).isEqualTo("4\r\n0123\r\n4\r\n4567\r\n4\r\n89AB\r\n4\r\nCDEF\r\n"); } @@ -176,8 +176,8 @@ void testCodingEmptyBuffer() throws Exception { final String s = channel.dump(StandardCharsets.US_ASCII); - Assertions.assertTrue(encoder.isCompleted()); - Assertions.assertEquals("5\r\n12345\r\n3\r\n678\r\n2\r\n90\r\n0\r\n\r\n", s); + Assertions.assertThat(encoder.isCompleted()).isTrue(); + Assertions.assertThat(s).isEqualTo("5\r\n12345\r\n3\r\n678\r\n2\r\n90\r\n0\r\n\r\n"); } @Test @@ -194,8 +194,12 @@ void testCodingCompleted() throws Exception { final ByteBuffer wrapped = CodecTestUtils.wrap("more stuff"); - Assertions.assertThrows(IllegalStateException.class, () -> encoder.write(wrapped)); - Assertions.assertThrows(IllegalStateException.class, () -> encoder.complete()); + Assertions.assertThatThrownBy(() -> + encoder.write(wrapped)) + .isInstanceOf(IllegalStateException.class); + Assertions.assertThatThrownBy(() -> + encoder.complete()) + .isInstanceOf(IllegalStateException.class); } @Test @@ -203,9 +207,15 @@ void testInvalidConstructor() { final WritableByteChannelMock channel = new WritableByteChannelMock(64); final SessionOutputBuffer outbuf = new SessionOutputBufferImpl(1024, 128); - Assertions.assertThrows(NullPointerException.class, () -> new ChunkEncoder(null, null, null)); - Assertions.assertThrows(NullPointerException.class, () -> new ChunkEncoder(channel, null, null)); - Assertions.assertThrows(NullPointerException.class, () -> new ChunkEncoder(channel, outbuf, null)); + Assertions.assertThatThrownBy(() -> + new ChunkEncoder(null, null, null)) + .isInstanceOf(NullPointerException.class); + Assertions.assertThatThrownBy(() -> + new ChunkEncoder(channel, null, null)) + .isInstanceOf(NullPointerException.class); + Assertions.assertThatThrownBy(() -> + new ChunkEncoder(channel, outbuf, null)) + .isInstanceOf(NullPointerException.class); } @Test @@ -222,8 +232,8 @@ void testTrailers() throws IOException { final String s = channel.dump(StandardCharsets.US_ASCII); - Assertions.assertTrue(encoder.isCompleted()); - Assertions.assertEquals("1\r\n1\r\n2\r\n23\r\n0\r\nE: \r\nY: Z\r\n\r\n", s); - Assertions.assertEquals("[chunk-coded; completed: true]", encoder.toString()); + Assertions.assertThat(encoder.isCompleted()).isTrue(); + Assertions.assertThat(s).isEqualTo("1\r\n1\r\n2\r\n23\r\n0\r\nE: \r\nY: Z\r\n\r\n"); + Assertions.assertThat(encoder.toString()).isEqualTo("[chunk-coded; completed: true]"); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/impl/nio/TestExpandableBuffer.java b/httpcore5/src/test/java/org/apache/hc/core5/http/impl/nio/TestExpandableBuffer.java index 673a36bec0..82fc2d8940 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/impl/nio/TestExpandableBuffer.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/impl/nio/TestExpandableBuffer.java @@ -28,7 +28,7 @@ package org.apache.hc.core5.http.impl.nio; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class TestExpandableBuffer { @@ -36,47 +36,47 @@ class TestExpandableBuffer { @Test void testBasics() { final ExpandableBuffer buffer = new ExpandableBuffer(16); - Assertions.assertEquals(ExpandableBuffer.Mode.INPUT, buffer.mode()); - Assertions.assertFalse(buffer.hasData()); + Assertions.assertThat(buffer.mode()).isEqualTo(ExpandableBuffer.Mode.INPUT); + Assertions.assertThat(buffer.hasData()).isFalse(); buffer.setInputMode(); buffer.buffer().put(new byte[] { 0, 1, 2, 3, 4, 5}); - Assertions.assertTrue(buffer.hasData()); - Assertions.assertEquals(6, buffer.length()); - Assertions.assertEquals(16, buffer.buffer().capacity()); - Assertions.assertEquals(ExpandableBuffer.Mode.OUTPUT, buffer.mode()); + Assertions.assertThat(buffer.hasData()).isTrue(); + Assertions.assertThat(buffer.length()).isEqualTo(6); + Assertions.assertThat(buffer.buffer().capacity()).isEqualTo(16); + Assertions.assertThat(buffer.mode()).isEqualTo(ExpandableBuffer.Mode.OUTPUT); buffer.setInputMode(); buffer.buffer().put(new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }); - Assertions.assertEquals(16, buffer.length()); - Assertions.assertEquals(16, buffer.buffer().capacity()); - Assertions.assertEquals(ExpandableBuffer.Mode.OUTPUT, buffer.mode()); + Assertions.assertThat(buffer.length()).isEqualTo(16); + Assertions.assertThat(buffer.buffer().capacity()).isEqualTo(16); + Assertions.assertThat(buffer.mode()).isEqualTo(ExpandableBuffer.Mode.OUTPUT); buffer.setInputMode(); buffer.ensureCapacity(22); buffer.buffer().put(new byte[] { 0, 1, 2, 3, 4, 5}); - Assertions.assertEquals(22, buffer.length()); - Assertions.assertEquals(22, buffer.buffer().capacity()); - Assertions.assertEquals(ExpandableBuffer.Mode.OUTPUT, buffer.mode()); + Assertions.assertThat(buffer.length()).isEqualTo(22); + Assertions.assertThat(buffer.buffer().capacity()).isEqualTo(22); + Assertions.assertThat(buffer.mode()).isEqualTo(ExpandableBuffer.Mode.OUTPUT); buffer.clear(); - Assertions.assertEquals(ExpandableBuffer.Mode.INPUT, buffer.mode()); - Assertions.assertFalse(buffer.hasData()); - Assertions.assertEquals(22, buffer.capacity()); + Assertions.assertThat(buffer.mode()).isEqualTo(ExpandableBuffer.Mode.INPUT); + Assertions.assertThat(buffer.hasData()).isFalse(); + Assertions.assertThat(buffer.capacity()).isEqualTo(22); } @Test void testAdjustCapacity() { final ExpandableBuffer buffer = new ExpandableBuffer(16); - Assertions.assertEquals(16, buffer.capacity()); + Assertions.assertThat(buffer.capacity()).isEqualTo(16); buffer.ensureCapacity(21); - Assertions.assertEquals(21, buffer.capacity()); + Assertions.assertThat(buffer.capacity()).isEqualTo(21); buffer.ensureAdjustedCapacity(22); - Assertions.assertEquals(1024, buffer.capacity()); + Assertions.assertThat(buffer.capacity()).isEqualTo(1024); buffer.ensureAdjustedCapacity(1024); - Assertions.assertEquals(1024, buffer.capacity()); + Assertions.assertThat(buffer.capacity()).isEqualTo(1024); buffer.ensureAdjustedCapacity(1025); - Assertions.assertEquals(2048, buffer.capacity()); + Assertions.assertThat(buffer.capacity()).isEqualTo(2048); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/impl/nio/TestIdentityDecoder.java b/httpcore5/src/test/java/org/apache/hc/core5/http/impl/nio/TestIdentityDecoder.java index 5051b68e43..10630d1744 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/impl/nio/TestIdentityDecoder.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/impl/nio/TestIdentityDecoder.java @@ -38,8 +38,8 @@ import org.apache.hc.core5.http.ReadableByteChannelMock; import org.apache.hc.core5.http.impl.BasicHttpTransportMetrics; import org.apache.hc.core5.http.nio.SessionInputBuffer; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.AfterEach; -import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; /** @@ -73,31 +73,31 @@ void testBasicDecoding() throws Exception { final ByteBuffer dst = ByteBuffer.allocate(1024); int bytesRead = decoder.read(dst); - Assertions.assertEquals(6, bytesRead); - Assertions.assertEquals("stuff;", CodecTestUtils.convert(dst)); - Assertions.assertFalse(decoder.isCompleted()); - Assertions.assertEquals(6, metrics.getBytesTransferred()); + Assertions.assertThat(bytesRead).isEqualTo(6); + Assertions.assertThat(CodecTestUtils.convert(dst)).isEqualTo("stuff;"); + Assertions.assertThat(decoder.isCompleted()).isFalse(); + Assertions.assertThat(metrics.getBytesTransferred()).isEqualTo(6); dst.clear(); bytesRead = decoder.read(dst); - Assertions.assertEquals(10, bytesRead); - Assertions.assertEquals("more stuff", CodecTestUtils.convert(dst)); - Assertions.assertFalse(decoder.isCompleted()); - Assertions.assertEquals(16, metrics.getBytesTransferred()); + Assertions.assertThat(bytesRead).isEqualTo(10); + Assertions.assertThat(CodecTestUtils.convert(dst)).isEqualTo("more stuff"); + Assertions.assertThat(decoder.isCompleted()).isFalse(); + Assertions.assertThat(metrics.getBytesTransferred()).isEqualTo(16); dst.clear(); bytesRead = decoder.read(dst); - Assertions.assertEquals(-1, bytesRead); - Assertions.assertTrue(decoder.isCompleted()); - Assertions.assertEquals(16, metrics.getBytesTransferred()); + Assertions.assertThat(bytesRead).isEqualTo(-1); + Assertions.assertThat(decoder.isCompleted()).isTrue(); + Assertions.assertThat(metrics.getBytesTransferred()).isEqualTo(16); dst.clear(); bytesRead = decoder.read(dst); - Assertions.assertEquals(-1, bytesRead); - Assertions.assertTrue(decoder.isCompleted()); - Assertions.assertEquals(16, metrics.getBytesTransferred()); + Assertions.assertThat(bytesRead).isEqualTo(-1); + Assertions.assertThat(decoder.isCompleted()).isTrue(); + Assertions.assertThat(metrics.getBytesTransferred()).isEqualTo(16); - Assertions.assertEquals("[identity; completed: true]", decoder.toString()); + Assertions.assertThat(decoder.toString()).isEqualTo("[identity; completed: true]"); } @Test @@ -110,36 +110,36 @@ void testDecodingFromSessionBuffer() throws Exception { inbuf.fill(channel); - Assertions.assertEquals(6, inbuf.length()); + Assertions.assertThat(inbuf.length()).isEqualTo(6); final IdentityDecoder decoder = new IdentityDecoder(channel, inbuf, metrics); final ByteBuffer dst = ByteBuffer.allocate(1024); int bytesRead = decoder.read(dst); - Assertions.assertEquals(6, bytesRead); - Assertions.assertEquals("stuff;", CodecTestUtils.convert(dst)); - Assertions.assertFalse(decoder.isCompleted()); - Assertions.assertEquals(0, metrics.getBytesTransferred()); // doesn't count if from session buffer + Assertions.assertThat(bytesRead).isEqualTo(6); + Assertions.assertThat(CodecTestUtils.convert(dst)).isEqualTo("stuff;"); + Assertions.assertThat(decoder.isCompleted()).isFalse(); + Assertions.assertThat(metrics.getBytesTransferred()).isEqualTo(0); // doesn't count if from session buffer dst.clear(); bytesRead = decoder.read(dst); - Assertions.assertEquals(10, bytesRead); - Assertions.assertEquals("more stuff", CodecTestUtils.convert(dst)); - Assertions.assertFalse(decoder.isCompleted()); - Assertions.assertEquals(10, metrics.getBytesTransferred()); + Assertions.assertThat(bytesRead).isEqualTo(10); + Assertions.assertThat(CodecTestUtils.convert(dst)).isEqualTo("more stuff"); + Assertions.assertThat(decoder.isCompleted()).isFalse(); + Assertions.assertThat(metrics.getBytesTransferred()).isEqualTo(10); dst.clear(); bytesRead = decoder.read(dst); - Assertions.assertEquals(-1, bytesRead); - Assertions.assertTrue(decoder.isCompleted()); - Assertions.assertEquals(10, metrics.getBytesTransferred()); + Assertions.assertThat(bytesRead).isEqualTo(-1); + Assertions.assertThat(decoder.isCompleted()).isTrue(); + Assertions.assertThat(metrics.getBytesTransferred()).isEqualTo(10); dst.clear(); bytesRead = decoder.read(dst); - Assertions.assertEquals(-1, bytesRead); - Assertions.assertTrue(decoder.isCompleted()); - Assertions.assertEquals(10, metrics.getBytesTransferred()); + Assertions.assertThat(bytesRead).isEqualTo(-1); + Assertions.assertThat(decoder.isCompleted()).isTrue(); + Assertions.assertThat(metrics.getBytesTransferred()).isEqualTo(10); } @@ -164,10 +164,9 @@ void testBasicDecodingFile() throws Exception { } } - Assertions.assertEquals(testfile.length(), metrics.getBytesTransferred()); + Assertions.assertThat(metrics.getBytesTransferred()).isEqualTo(testfile.length()); } - Assertions.assertEquals("stuff; more stuff; a lot more stuff!", - CodecTestUtils.readFromFile(this.tmpfile)); + Assertions.assertThat(CodecTestUtils.readFromFile(this.tmpfile)).isEqualTo("stuff; more stuff; a lot more stuff!"); } @Test @@ -181,7 +180,7 @@ void testDecodingFileWithBufferedSessionData() throws Exception { channel, inbuf, metrics); final int i = inbuf.fill(channel); - Assertions.assertEquals(7, i); + Assertions.assertThat(i).isEqualTo(7); createTempFile(); try (RandomAccessFile testfile = new RandomAccessFile(this.tmpfile, "rw")) { @@ -195,10 +194,9 @@ void testDecodingFileWithBufferedSessionData() throws Exception { } // count everything except the initial 7 bytes that went to the session buffer - Assertions.assertEquals(testfile.length() - 7, metrics.getBytesTransferred()); + Assertions.assertThat(metrics.getBytesTransferred()).isEqualTo(testfile.length() - 7); } - Assertions.assertEquals("stuff; more stuff; a lot more stuff!", - CodecTestUtils.readFromFile(this.tmpfile)); + Assertions.assertThat(CodecTestUtils.readFromFile(this.tmpfile)).isEqualTo("stuff; more stuff; a lot more stuff!"); } @Test @@ -212,7 +210,7 @@ void testDecodingFileWithOffsetAndBufferedSessionData() throws Exception { channel, inbuf, metrics); final int i = inbuf.fill(channel); - Assertions.assertEquals(7, i); + Assertions.assertThat(i).isEqualTo(7); final byte[] beginning = "beginning; ".getBytes(StandardCharsets.US_ASCII); @@ -239,13 +237,12 @@ void testDecodingFileWithOffsetAndBufferedSessionData() throws Exception { } // count everything except the initial 7 bytes that went to the session buffer - Assertions.assertEquals(testfile.length() - 7 - beginning.length, metrics.getBytesTransferred()); + Assertions.assertThat(metrics.getBytesTransferred()).isEqualTo(testfile.length() - 7 - beginning.length); } finally { testfile.close(); } - Assertions.assertEquals("beginning; stuff; more stuff; a lot more stuff!", - CodecTestUtils.readFromFile(this.tmpfile)); + Assertions.assertThat(CodecTestUtils.readFromFile(this.tmpfile)).isEqualTo("beginning; stuff; more stuff; a lot more stuff!"); } @Test @@ -258,7 +255,7 @@ void testDecodingFileWithLimit() throws Exception { final IdentityDecoder decoder = new IdentityDecoder(channel, inbuf, metrics); final int i = inbuf.fill(channel); - Assertions.assertEquals(19, i); + Assertions.assertThat(i).isEqualTo(19); createTempFile(); try (RandomAccessFile testfile = new RandomAccessFile(this.tmpfile, "rw")) { @@ -267,49 +264,48 @@ void testDecodingFileWithLimit() throws Exception { // transferred from buffer long bytesRead = decoder.transfer(fchannel, pos, 1); - Assertions.assertEquals(1, bytesRead); - Assertions.assertFalse(decoder.isCompleted()); - Assertions.assertEquals(0, metrics.getBytesTransferred()); + Assertions.assertThat(bytesRead).isEqualTo(1); + Assertions.assertThat(decoder.isCompleted()).isFalse(); + Assertions.assertThat(metrics.getBytesTransferred()).isEqualTo(0); pos += bytesRead; bytesRead = decoder.transfer(fchannel, pos, 2); - Assertions.assertEquals(2, bytesRead); - Assertions.assertFalse(decoder.isCompleted()); - Assertions.assertEquals(0, metrics.getBytesTransferred()); + Assertions.assertThat(bytesRead).isEqualTo(2); + Assertions.assertThat(decoder.isCompleted()).isFalse(); + Assertions.assertThat(metrics.getBytesTransferred()).isEqualTo(0); pos += bytesRead; bytesRead = decoder.transfer(fchannel, pos, 17); - Assertions.assertEquals(16, bytesRead); - Assertions.assertFalse(decoder.isCompleted()); - Assertions.assertEquals(0, metrics.getBytesTransferred()); + Assertions.assertThat(bytesRead).isEqualTo(16); + Assertions.assertThat(decoder.isCompleted()).isFalse(); + Assertions.assertThat(metrics.getBytesTransferred()).isEqualTo(0); pos += bytesRead; // transferred from channel bytesRead = decoder.transfer(fchannel, pos, 1); - Assertions.assertEquals(1, bytesRead); - Assertions.assertFalse(decoder.isCompleted()); - Assertions.assertEquals(1, metrics.getBytesTransferred()); + Assertions.assertThat(bytesRead).isEqualTo(1); + Assertions.assertThat(decoder.isCompleted()).isFalse(); + Assertions.assertThat(metrics.getBytesTransferred()).isEqualTo(1); pos += bytesRead; bytesRead = decoder.transfer(fchannel, pos, 2); - Assertions.assertEquals(2, bytesRead); - Assertions.assertFalse(decoder.isCompleted()); - Assertions.assertEquals(3, metrics.getBytesTransferred()); + Assertions.assertThat(bytesRead).isEqualTo(2); + Assertions.assertThat(decoder.isCompleted()).isFalse(); + Assertions.assertThat(metrics.getBytesTransferred()).isEqualTo(3); pos += bytesRead; bytesRead = decoder.transfer(fchannel, pos, 15); - Assertions.assertEquals(14, bytesRead); - Assertions.assertFalse(decoder.isCompleted()); - Assertions.assertEquals(17, metrics.getBytesTransferred()); + Assertions.assertThat(bytesRead).isEqualTo(14); + Assertions.assertThat(decoder.isCompleted()).isFalse(); + Assertions.assertThat(metrics.getBytesTransferred()).isEqualTo(17); pos += bytesRead; bytesRead = decoder.transfer(fchannel, pos, 1); - Assertions.assertEquals(-1, bytesRead); - Assertions.assertTrue(decoder.isCompleted()); - Assertions.assertEquals(17, metrics.getBytesTransferred()); + Assertions.assertThat(bytesRead).isEqualTo(-1); + Assertions.assertThat(decoder.isCompleted()).isTrue(); + Assertions.assertThat(metrics.getBytesTransferred()).isEqualTo(17); } - Assertions.assertEquals("stuff; more stuff; a lot more stuff!", - CodecTestUtils.readFromFile(this.tmpfile)); + Assertions.assertThat(CodecTestUtils.readFromFile(this.tmpfile)).isEqualTo("stuff; more stuff; a lot more stuff!"); } @Test @@ -324,9 +320,11 @@ void testWriteBeyondFileSize() throws Exception { createTempFile(); try (RandomAccessFile testfile = new RandomAccessFile(this.tmpfile, "rw")) { - Assertions.assertEquals(0, testfile.length()); + Assertions.assertThat(testfile.length()).isEqualTo(0); final FileChannel fchannel = testfile.getChannel(); - Assertions.assertThrows(IOException.class, () -> decoder.transfer(fchannel, 5, 10)); + Assertions.assertThatThrownBy(() -> + decoder.transfer(fchannel, 5, 10)) + .isInstanceOf(IOException.class); } } @@ -336,9 +334,15 @@ void testInvalidConstructor() { new String[] {"stuff;", "more stuff"}, StandardCharsets.US_ASCII); final SessionInputBuffer inbuf = new SessionInputBufferImpl(1024, 256, 0, StandardCharsets.US_ASCII); - Assertions.assertThrows(NullPointerException.class, () -> new IdentityDecoder(null, null, null)); - Assertions.assertThrows(NullPointerException.class, () -> new IdentityDecoder(channel, null, null)); - Assertions.assertThrows(NullPointerException.class, () -> new IdentityDecoder(channel, inbuf, null)); + Assertions.assertThatThrownBy(() -> + new IdentityDecoder(null, null, null)) + .isInstanceOf(NullPointerException.class); + Assertions.assertThatThrownBy(() -> + new IdentityDecoder(channel, null, null)) + .isInstanceOf(NullPointerException.class); + Assertions.assertThatThrownBy(() -> + new IdentityDecoder(channel, inbuf, null)) + .isInstanceOf(NullPointerException.class); } @Test @@ -351,7 +355,9 @@ void testInvalidInput() { final BasicHttpTransportMetrics metrics = new BasicHttpTransportMetrics(); final IdentityDecoder decoder = new IdentityDecoder(channel, inbuf, metrics); - Assertions.assertThrows(NullPointerException.class, () -> decoder.read(null)); + Assertions.assertThatThrownBy(() -> + decoder.read(null)) + .isInstanceOf(NullPointerException.class); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/impl/nio/TestIdentityEncoder.java b/httpcore5/src/test/java/org/apache/hc/core5/http/impl/nio/TestIdentityEncoder.java index 38f2b65257..1fcb5124e1 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/impl/nio/TestIdentityEncoder.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/impl/nio/TestIdentityEncoder.java @@ -38,8 +38,8 @@ import org.apache.hc.core5.http.impl.BasicHttpTransportMetrics; import org.apache.hc.core5.http.nio.SessionOutputBuffer; import org.apache.hc.core5.util.CharArrayBuffer; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.AfterEach; -import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; import org.mockito.ArgumentMatchers; import org.mockito.Mockito; @@ -70,17 +70,17 @@ void testBasicCoding() throws Exception { final BasicHttpTransportMetrics metrics = new BasicHttpTransportMetrics(); final IdentityEncoder encoder = new IdentityEncoder(channel, outbuf, metrics); - Assertions.assertEquals(5, encoder.write(CodecTestUtils.wrap("stuff"))); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("stuff"))).isEqualTo(5); encoder.complete(); - Assertions.assertTrue(encoder.isCompleted()); - Assertions.assertEquals(5, metrics.getBytesTransferred()); + Assertions.assertThat(encoder.isCompleted()).isTrue(); + Assertions.assertThat(metrics.getBytesTransferred()).isEqualTo(5); outbuf.flush(channel); final String s = channel.dump(StandardCharsets.US_ASCII); - Assertions.assertEquals("stuff", s); - Assertions.assertEquals("[identity; completed: true]", encoder.toString()); + Assertions.assertThat(s).isEqualTo("stuff"); + Assertions.assertThat(encoder.toString()).isEqualTo("[identity; completed: true]"); } @Test @@ -101,8 +101,8 @@ void testCodingEmptySrcBuffer() throws Exception { outbuf.flush(channel); final String s = channel.dump(StandardCharsets.US_ASCII); - Assertions.assertTrue(encoder.isCompleted()); - Assertions.assertEquals("stuff", s); + Assertions.assertThat(encoder.isCompleted()).isTrue(); + Assertions.assertThat(s).isEqualTo("stuff"); } @Test @@ -117,7 +117,9 @@ void testCodingCompleted() throws Exception { final ByteBuffer wrapped = CodecTestUtils.wrap("more stuff"); - Assertions.assertThrows(IllegalStateException.class, () -> encoder.write(wrapped)); + Assertions.assertThatThrownBy(() -> + encoder.write(wrapped)) + .isInstanceOf(IllegalStateException.class); } @Test @@ -125,9 +127,15 @@ void testInvalidConstructor() { final WritableByteChannelMock channel = new WritableByteChannelMock(64); final SessionOutputBuffer outbuf = new SessionOutputBufferImpl(1024, 128); - Assertions.assertThrows(NullPointerException.class, () -> new IdentityEncoder(null, null, null)); - Assertions.assertThrows(NullPointerException.class, () -> new IdentityEncoder(channel, null, null)); - Assertions.assertThrows(NullPointerException.class, () -> new IdentityEncoder(channel, outbuf, null)); + Assertions.assertThatThrownBy(() -> + new IdentityEncoder(null, null, null)) + .isInstanceOf(NullPointerException.class); + Assertions.assertThatThrownBy(() -> + new IdentityEncoder(channel, null, null)) + .isInstanceOf(NullPointerException.class); + Assertions.assertThatThrownBy(() -> + new IdentityEncoder(channel, outbuf, null)) + .isInstanceOf(NullPointerException.class); } @Test @@ -157,8 +165,8 @@ void testCodingFromFile() throws Exception { final String s = channel.dump(StandardCharsets.US_ASCII); - Assertions.assertFalse(encoder.isCompleted()); - Assertions.assertEquals("stuff;more stuff", s); + Assertions.assertThat(encoder.isCompleted()).isFalse(); + Assertions.assertThat(s).isEqualTo("stuff;more stuff"); } @Test @@ -186,8 +194,8 @@ void testCodingEmptyFile() throws Exception { final String s = channel.dump(StandardCharsets.US_ASCII); - Assertions.assertFalse(encoder.isCompleted()); - Assertions.assertEquals("stuff;more stuff", s); + Assertions.assertThat(encoder.isCompleted()).isFalse(); + Assertions.assertThat(s).isEqualTo("stuff;more stuff"); } @Test @@ -220,8 +228,8 @@ void testCodingFromFileFlushBuffer() throws Exception { } final String s = channel.dump(StandardCharsets.US_ASCII); - Assertions.assertFalse(encoder.isCompleted()); - Assertions.assertEquals("header\r\nstuff;more stuff", s); + Assertions.assertThat(encoder.isCompleted()).isFalse(); + Assertions.assertThat(s).isEqualTo("header\r\nstuff;more stuff"); } @Test @@ -254,8 +262,8 @@ void testCodingFromFileChannelSaturated() throws Exception { } final String s = channel.dump(StandardCharsets.US_ASCII); - Assertions.assertFalse(encoder.isCompleted()); - Assertions.assertEquals("head", s); + Assertions.assertThat(encoder.isCompleted()).isFalse(); + Assertions.assertThat(s).isEqualTo("head"); } @Test @@ -268,18 +276,18 @@ void testCodingNoFragmentBuffering() throws Exception { chbuffer.append("header"); outbuf.writeLine(chbuffer); final IdentityEncoder encoder = new IdentityEncoder(channel, outbuf, metrics, 0); - Assertions.assertEquals(5, encoder.write(CodecTestUtils.wrap("stuff"))); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("stuff"))).isEqualTo(5); Mockito.verify(channel, Mockito.times(2)).write(ArgumentMatchers.any()); Mockito.verify(outbuf, Mockito.never()).write(ArgumentMatchers.any()); Mockito.verify(outbuf, Mockito.times(1)).flush(channel); - Assertions.assertEquals(13, metrics.getBytesTransferred()); + Assertions.assertThat(metrics.getBytesTransferred()).isEqualTo(13); outbuf.flush(channel); final String s = channel.dump(StandardCharsets.US_ASCII); - Assertions.assertEquals("header\r\nstuff", s); + Assertions.assertThat(s).isEqualTo("header\r\nstuff"); } @Test @@ -292,18 +300,18 @@ void testCodingFragmentBuffering() throws Exception { chbuffer.append("header"); outbuf.writeLine(chbuffer); final IdentityEncoder encoder = new IdentityEncoder(channel, outbuf, metrics, 32); - Assertions.assertEquals(5, encoder.write(CodecTestUtils.wrap("stuff"))); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("stuff"))).isEqualTo(5); Mockito.verify(channel, Mockito.never()).write(ArgumentMatchers.any()); Mockito.verify(outbuf, Mockito.times(1)).write(ArgumentMatchers.any()); Mockito.verify(outbuf, Mockito.never()).flush(channel); - Assertions.assertEquals(0, metrics.getBytesTransferred()); + Assertions.assertThat(metrics.getBytesTransferred()).isEqualTo(0); outbuf.flush(channel); final String s = channel.dump(StandardCharsets.US_ASCII); - Assertions.assertEquals("header\r\nstuff", s); + Assertions.assertThat(s).isEqualTo("header\r\nstuff"); } @Test @@ -313,20 +321,20 @@ void testCodingFragmentBufferingMultipleFragments() throws Exception { final BasicHttpTransportMetrics metrics = new BasicHttpTransportMetrics(); final IdentityEncoder encoder = new IdentityEncoder(channel, outbuf, metrics, 32); - Assertions.assertEquals(5, encoder.write(CodecTestUtils.wrap("stuff"))); - Assertions.assertEquals(1, encoder.write(CodecTestUtils.wrap("-"))); - Assertions.assertEquals(10, encoder.write(CodecTestUtils.wrap("more stuff"))); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("stuff"))).isEqualTo(5); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("-"))).isEqualTo(1); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("more stuff"))).isEqualTo(10); Mockito.verify(channel, Mockito.never()).write(ArgumentMatchers.any()); Mockito.verify(outbuf, Mockito.times(3)).write(ArgumentMatchers.any()); Mockito.verify(outbuf, Mockito.never()).flush(channel); - Assertions.assertEquals(0, metrics.getBytesTransferred()); + Assertions.assertThat(metrics.getBytesTransferred()).isEqualTo(0); outbuf.flush(channel); final String s = channel.dump(StandardCharsets.US_ASCII); - Assertions.assertEquals("stuff-more stuff", s); + Assertions.assertThat(s).isEqualTo("stuff-more stuff"); } @Test @@ -339,17 +347,17 @@ void testCodingFragmentBufferingLargeFragment() throws Exception { chbuffer.append("header"); outbuf.writeLine(chbuffer); final IdentityEncoder encoder = new IdentityEncoder(channel, outbuf, metrics, 2); - Assertions.assertEquals(5, encoder.write(CodecTestUtils.wrap("stuff"))); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("stuff"))).isEqualTo(5); Mockito.verify(channel, Mockito.times(2)).write(ArgumentMatchers.any()); Mockito.verify(outbuf, Mockito.never()).write(ArgumentMatchers.any()); Mockito.verify(outbuf, Mockito.times(1)).flush(channel); - Assertions.assertEquals(13, metrics.getBytesTransferred()); + Assertions.assertThat(metrics.getBytesTransferred()).isEqualTo(13); outbuf.flush(channel); final String s = channel.dump(StandardCharsets.US_ASCII); - Assertions.assertEquals("header\r\nstuff", s); + Assertions.assertThat(s).isEqualTo("header\r\nstuff"); } @Test @@ -359,22 +367,22 @@ void testCodingFragmentBufferingTinyFragments() throws Exception { final BasicHttpTransportMetrics metrics = new BasicHttpTransportMetrics(); final IdentityEncoder encoder = new IdentityEncoder(channel, outbuf, metrics, 1); - Assertions.assertEquals(5, encoder.write(CodecTestUtils.wrap("stuff"))); - Assertions.assertEquals(1, encoder.write(CodecTestUtils.wrap("-"))); - Assertions.assertEquals(1, encoder.write(CodecTestUtils.wrap("-"))); - Assertions.assertEquals(1, encoder.write(CodecTestUtils.wrap("-"))); - Assertions.assertEquals(10, encoder.write(CodecTestUtils.wrap("more stuff"))); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("stuff"))).isEqualTo(5); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("-"))).isEqualTo(1); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("-"))).isEqualTo(1); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("-"))).isEqualTo(1); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("more stuff"))).isEqualTo(10); Mockito.verify(channel, Mockito.times(5)).write(ArgumentMatchers.any()); Mockito.verify(outbuf, Mockito.times(3)).write(ArgumentMatchers.any()); Mockito.verify(outbuf, Mockito.times(3)).flush(channel); - Assertions.assertEquals(18, metrics.getBytesTransferred()); + Assertions.assertThat(metrics.getBytesTransferred()).isEqualTo(18); outbuf.flush(channel); final String s = channel.dump(StandardCharsets.US_ASCII); - Assertions.assertEquals("stuff---more stuff", s); + Assertions.assertThat(s).isEqualTo("stuff---more stuff"); } @Test @@ -384,22 +392,22 @@ void testCodingFragmentBufferingTinyFragments2() throws Exception { final BasicHttpTransportMetrics metrics = new BasicHttpTransportMetrics(); final IdentityEncoder encoder = new IdentityEncoder(channel, outbuf, metrics, 2); - Assertions.assertEquals(5, encoder.write(CodecTestUtils.wrap("stuff"))); - Assertions.assertEquals(1, encoder.write(CodecTestUtils.wrap("-"))); - Assertions.assertEquals(1, encoder.write(CodecTestUtils.wrap("-"))); - Assertions.assertEquals(1, encoder.write(CodecTestUtils.wrap("-"))); - Assertions.assertEquals(10, encoder.write(CodecTestUtils.wrap("more stuff"))); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("stuff"))).isEqualTo(5); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("-"))).isEqualTo(1); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("-"))).isEqualTo(1); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("-"))).isEqualTo(1); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("more stuff"))).isEqualTo(10); Mockito.verify(channel, Mockito.times(4)).write(ArgumentMatchers.any()); Mockito.verify(outbuf, Mockito.times(3)).write(ArgumentMatchers.any()); Mockito.verify(outbuf, Mockito.times(2)).flush(channel); - Assertions.assertEquals(18, metrics.getBytesTransferred()); + Assertions.assertThat(metrics.getBytesTransferred()).isEqualTo(18); outbuf.flush(channel); final String s = channel.dump(StandardCharsets.US_ASCII); - Assertions.assertEquals("stuff---more stuff", s); + Assertions.assertThat(s).isEqualTo("stuff---more stuff"); } @Test @@ -409,24 +417,24 @@ void testCodingFragmentBufferingTinyFragments3() throws Exception { final BasicHttpTransportMetrics metrics = new BasicHttpTransportMetrics(); final IdentityEncoder encoder = new IdentityEncoder(channel, outbuf, metrics, 3); - Assertions.assertEquals(5, encoder.write(CodecTestUtils.wrap("stuff"))); - Assertions.assertEquals(1, encoder.write(CodecTestUtils.wrap("-"))); - Assertions.assertEquals(1, encoder.write(CodecTestUtils.wrap("-"))); - Assertions.assertEquals(1, encoder.write(CodecTestUtils.wrap("-"))); - Assertions.assertEquals(1, encoder.write(CodecTestUtils.wrap("-"))); - Assertions.assertEquals(2, encoder.write(CodecTestUtils.wrap("--"))); - Assertions.assertEquals(10, encoder.write(CodecTestUtils.wrap("more stuff"))); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("stuff"))).isEqualTo(5); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("-"))).isEqualTo(1); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("-"))).isEqualTo(1); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("-"))).isEqualTo(1); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("-"))).isEqualTo(1); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("--"))).isEqualTo(2); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("more stuff"))).isEqualTo(10); Mockito.verify(channel, Mockito.times(4)).write(ArgumentMatchers.any()); Mockito.verify(outbuf, Mockito.times(5)).write(ArgumentMatchers.any()); Mockito.verify(outbuf, Mockito.times(2)).flush(channel); - Assertions.assertEquals(21, metrics.getBytesTransferred()); + Assertions.assertThat(metrics.getBytesTransferred()).isEqualTo(21); outbuf.flush(channel); final String s = channel.dump(StandardCharsets.US_ASCII); - Assertions.assertEquals("stuff------more stuff", s); + Assertions.assertThat(s).isEqualTo("stuff------more stuff"); } @Test @@ -436,20 +444,20 @@ void testCodingFragmentBufferingBufferFlush() throws Exception { final BasicHttpTransportMetrics metrics = new BasicHttpTransportMetrics(); final IdentityEncoder encoder = new IdentityEncoder(channel, outbuf, metrics, 8); - Assertions.assertEquals(5, encoder.write(CodecTestUtils.wrap("stuff"))); - Assertions.assertEquals(6, encoder.write(CodecTestUtils.wrap("-stuff"))); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("stuff"))).isEqualTo(5); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("-stuff"))).isEqualTo(6); Mockito.verify(channel, Mockito.times(1)).write(ArgumentMatchers.any()); Mockito.verify(outbuf, Mockito.times(3)).write(ArgumentMatchers.any()); Mockito.verify(outbuf, Mockito.times(1)).flush(channel); - Assertions.assertEquals(8, metrics.getBytesTransferred()); - Assertions.assertEquals(3, outbuf.length()); + Assertions.assertThat(metrics.getBytesTransferred()).isEqualTo(8); + Assertions.assertThat(outbuf.length()).isEqualTo(3); outbuf.flush(channel); final String s = channel.dump(StandardCharsets.US_ASCII); - Assertions.assertEquals("stuff-stuff", s); + Assertions.assertThat(s).isEqualTo("stuff-stuff"); } @Test @@ -459,20 +467,20 @@ void testCodingFragmentBufferingBufferFlush2() throws Exception { final BasicHttpTransportMetrics metrics = new BasicHttpTransportMetrics(); final IdentityEncoder encoder = new IdentityEncoder(channel, outbuf, metrics, 8); - Assertions.assertEquals(5, encoder.write(CodecTestUtils.wrap("stuff"))); - Assertions.assertEquals(16, encoder.write(CodecTestUtils.wrap("-much more stuff"))); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("stuff"))).isEqualTo(5); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("-much more stuff"))).isEqualTo(16); Mockito.verify(channel, Mockito.times(2)).write(ArgumentMatchers.any()); Mockito.verify(outbuf, Mockito.times(1)).write(ArgumentMatchers.any()); Mockito.verify(outbuf, Mockito.times(1)).flush(channel); - Assertions.assertEquals(21, metrics.getBytesTransferred()); - Assertions.assertEquals(0, outbuf.length()); + Assertions.assertThat(metrics.getBytesTransferred()).isEqualTo(21); + Assertions.assertThat(outbuf.length()).isEqualTo(0); outbuf.flush(channel); final String s = channel.dump(StandardCharsets.US_ASCII); - Assertions.assertEquals("stuff-much more stuff", s); + Assertions.assertThat(s).isEqualTo("stuff-much more stuff"); } @Test @@ -482,27 +490,27 @@ void testCodingFragmentBufferingChannelSaturated() throws Exception { final BasicHttpTransportMetrics metrics = new BasicHttpTransportMetrics(); final IdentityEncoder encoder = new IdentityEncoder(channel, outbuf, metrics, 3); - Assertions.assertEquals(5, encoder.write(CodecTestUtils.wrap("stuff"))); - Assertions.assertEquals(1, encoder.write(CodecTestUtils.wrap("-"))); - Assertions.assertEquals(1, encoder.write(CodecTestUtils.wrap("-"))); - Assertions.assertEquals(1, encoder.write(CodecTestUtils.wrap("-"))); - Assertions.assertEquals(1, encoder.write(CodecTestUtils.wrap("-"))); - Assertions.assertEquals(1, encoder.write(CodecTestUtils.wrap("-"))); - Assertions.assertEquals(1, encoder.write(CodecTestUtils.wrap("-"))); - Assertions.assertEquals(0, encoder.write(CodecTestUtils.wrap("-"))); - Assertions.assertEquals(0, encoder.write(CodecTestUtils.wrap("more stuff"))); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("stuff"))).isEqualTo(5); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("-"))).isEqualTo(1); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("-"))).isEqualTo(1); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("-"))).isEqualTo(1); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("-"))).isEqualTo(1); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("-"))).isEqualTo(1); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("-"))).isEqualTo(1); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("-"))).isEqualTo(0); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("more stuff"))).isEqualTo(0); Mockito.verify(channel, Mockito.times(5)).write(ArgumentMatchers.any()); Mockito.verify(outbuf, Mockito.times(6)).write(ArgumentMatchers.any()); Mockito.verify(outbuf, Mockito.times(4)).flush(channel); - Assertions.assertEquals(8, metrics.getBytesTransferred()); + Assertions.assertThat(metrics.getBytesTransferred()).isEqualTo(8); outbuf.flush(channel); final String s = channel.dump(StandardCharsets.US_ASCII); - Assertions.assertEquals("stuff---", s); - Assertions.assertEquals(3, outbuf.length()); + Assertions.assertThat(s).isEqualTo("stuff---"); + Assertions.assertThat(outbuf.length()).isEqualTo(3); } @Test @@ -512,22 +520,22 @@ void testCodingFragmentBufferingChannelSaturated2() throws Exception { final BasicHttpTransportMetrics metrics = new BasicHttpTransportMetrics(); final IdentityEncoder encoder = new IdentityEncoder(channel, outbuf, metrics, 8); - Assertions.assertEquals(5, encoder.write(CodecTestUtils.wrap("stuff"))); - Assertions.assertEquals(1, encoder.write(CodecTestUtils.wrap("-"))); - Assertions.assertEquals(1, encoder.write(CodecTestUtils.wrap("-"))); - Assertions.assertEquals(1, encoder.write(CodecTestUtils.wrap("much more stuff"))); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("stuff"))).isEqualTo(5); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("-"))).isEqualTo(1); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("-"))).isEqualTo(1); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("much more stuff"))).isEqualTo(1); Mockito.verify(channel, Mockito.times(3)).write(ArgumentMatchers.any()); Mockito.verify(outbuf, Mockito.times(3)).write(ArgumentMatchers.any()); Mockito.verify(outbuf, Mockito.times(1)).flush(channel); - Assertions.assertEquals(8, metrics.getBytesTransferred()); + Assertions.assertThat(metrics.getBytesTransferred()).isEqualTo(8); outbuf.flush(channel); final String s = channel.dump(StandardCharsets.US_ASCII); - Assertions.assertEquals("stuff--m", s); - Assertions.assertEquals(0, outbuf.length()); + Assertions.assertThat(s).isEqualTo("stuff--m"); + Assertions.assertThat(outbuf.length()).isEqualTo(0); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/impl/nio/TestLengthDelimitedDecoder.java b/httpcore5/src/test/java/org/apache/hc/core5/http/impl/nio/TestLengthDelimitedDecoder.java index c97deb57bc..65d3406b8b 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/impl/nio/TestLengthDelimitedDecoder.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/impl/nio/TestLengthDelimitedDecoder.java @@ -39,8 +39,8 @@ import org.apache.hc.core5.http.ReadableByteChannelMock; import org.apache.hc.core5.http.impl.BasicHttpTransportMetrics; import org.apache.hc.core5.http.nio.SessionInputBuffer; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.AfterEach; -import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; /** @@ -75,25 +75,25 @@ void testBasicDecoding() throws Exception { final ByteBuffer dst = ByteBuffer.allocate(1024); int bytesRead = decoder.read(dst); - Assertions.assertEquals(6, bytesRead); - Assertions.assertEquals("stuff;", CodecTestUtils.convert(dst)); - Assertions.assertFalse(decoder.isCompleted()); - Assertions.assertEquals(6, metrics.getBytesTransferred()); + Assertions.assertThat(bytesRead).isEqualTo(6); + Assertions.assertThat(CodecTestUtils.convert(dst)).isEqualTo("stuff;"); + Assertions.assertThat(decoder.isCompleted()).isFalse(); + Assertions.assertThat(metrics.getBytesTransferred()).isEqualTo(6); dst.clear(); bytesRead = decoder.read(dst); - Assertions.assertEquals(10, bytesRead); - Assertions.assertEquals("more stuff", CodecTestUtils.convert(dst)); - Assertions.assertTrue(decoder.isCompleted()); - Assertions.assertEquals(16, metrics.getBytesTransferred()); + Assertions.assertThat(bytesRead).isEqualTo(10); + Assertions.assertThat(CodecTestUtils.convert(dst)).isEqualTo("more stuff"); + Assertions.assertThat(decoder.isCompleted()).isTrue(); + Assertions.assertThat(metrics.getBytesTransferred()).isEqualTo(16); dst.clear(); bytesRead = decoder.read(dst); - Assertions.assertEquals(-1, bytesRead); - Assertions.assertTrue(decoder.isCompleted()); - Assertions.assertEquals(16, metrics.getBytesTransferred()); + Assertions.assertThat(bytesRead).isEqualTo(-1); + Assertions.assertThat(decoder.isCompleted()).isTrue(); + Assertions.assertThat(metrics.getBytesTransferred()).isEqualTo(16); - Assertions.assertEquals("[content length: 16; pos: 16; completed: true]", decoder.toString()); + Assertions.assertThat(decoder.toString()).isEqualTo("[content length: 16; pos: 16; completed: true]"); } @Test @@ -111,23 +111,23 @@ void testCodingBeyondContentLimit() throws Exception { final ByteBuffer dst = ByteBuffer.allocate(1024); int bytesRead = decoder.read(dst); - Assertions.assertEquals(6, bytesRead); - Assertions.assertEquals("stuff;", CodecTestUtils.convert(dst)); - Assertions.assertFalse(decoder.isCompleted()); - Assertions.assertEquals(6, metrics.getBytesTransferred()); + Assertions.assertThat(bytesRead).isEqualTo(6); + Assertions.assertThat(CodecTestUtils.convert(dst)).isEqualTo("stuff;"); + Assertions.assertThat(decoder.isCompleted()).isFalse(); + Assertions.assertThat(metrics.getBytesTransferred()).isEqualTo(6); dst.clear(); bytesRead = decoder.read(dst); - Assertions.assertEquals(10, bytesRead); - Assertions.assertEquals("more stuff", CodecTestUtils.convert(dst)); - Assertions.assertTrue(decoder.isCompleted()); - Assertions.assertEquals(16, metrics.getBytesTransferred()); + Assertions.assertThat(bytesRead).isEqualTo(10); + Assertions.assertThat(CodecTestUtils.convert(dst)).isEqualTo("more stuff"); + Assertions.assertThat(decoder.isCompleted()).isTrue(); + Assertions.assertThat(metrics.getBytesTransferred()).isEqualTo(16); dst.clear(); bytesRead = decoder.read(dst); - Assertions.assertEquals(-1, bytesRead); - Assertions.assertTrue(decoder.isCompleted()); - Assertions.assertEquals(16, metrics.getBytesTransferred()); + Assertions.assertThat(bytesRead).isEqualTo(-1); + Assertions.assertThat(decoder.isCompleted()).isTrue(); + Assertions.assertThat(metrics.getBytesTransferred()).isEqualTo(16); } @Test @@ -143,44 +143,44 @@ void testBasicDecodingSmallBuffer() throws Exception { final ByteBuffer dst = ByteBuffer.allocate(4); int bytesRead = decoder.read(dst); - Assertions.assertEquals(4, bytesRead); - Assertions.assertEquals("stuf", CodecTestUtils.convert(dst)); - Assertions.assertFalse(decoder.isCompleted()); - Assertions.assertEquals(4, metrics.getBytesTransferred()); + Assertions.assertThat(bytesRead).isEqualTo(4); + Assertions.assertThat(CodecTestUtils.convert(dst)).isEqualTo("stuf"); + Assertions.assertThat(decoder.isCompleted()).isFalse(); + Assertions.assertThat(metrics.getBytesTransferred()).isEqualTo(4); dst.clear(); bytesRead = decoder.read(dst); - Assertions.assertEquals(2, bytesRead); - Assertions.assertEquals("f;", CodecTestUtils.convert(dst)); - Assertions.assertFalse(decoder.isCompleted()); - Assertions.assertEquals(6, metrics.getBytesTransferred()); + Assertions.assertThat(bytesRead).isEqualTo(2); + Assertions.assertThat(CodecTestUtils.convert(dst)).isEqualTo("f;"); + Assertions.assertThat(decoder.isCompleted()).isFalse(); + Assertions.assertThat(metrics.getBytesTransferred()).isEqualTo(6); dst.clear(); bytesRead = decoder.read(dst); - Assertions.assertEquals(4, bytesRead); - Assertions.assertEquals("more", CodecTestUtils.convert(dst)); - Assertions.assertFalse(decoder.isCompleted()); - Assertions.assertEquals(10, metrics.getBytesTransferred()); + Assertions.assertThat(bytesRead).isEqualTo(4); + Assertions.assertThat(CodecTestUtils.convert(dst)).isEqualTo("more"); + Assertions.assertThat(decoder.isCompleted()).isFalse(); + Assertions.assertThat(metrics.getBytesTransferred()).isEqualTo(10); dst.clear(); bytesRead = decoder.read(dst); - Assertions.assertEquals(4, bytesRead); - Assertions.assertEquals(" stu", CodecTestUtils.convert(dst)); - Assertions.assertFalse(decoder.isCompleted()); - Assertions.assertEquals(14, metrics.getBytesTransferred()); + Assertions.assertThat(bytesRead).isEqualTo(4); + Assertions.assertThat(CodecTestUtils.convert(dst)).isEqualTo(" stu"); + Assertions.assertThat(decoder.isCompleted()).isFalse(); + Assertions.assertThat(metrics.getBytesTransferred()).isEqualTo(14); dst.clear(); bytesRead = decoder.read(dst); - Assertions.assertEquals(2, bytesRead); - Assertions.assertEquals("ff", CodecTestUtils.convert(dst)); - Assertions.assertTrue(decoder.isCompleted()); - Assertions.assertEquals(16, metrics.getBytesTransferred()); + Assertions.assertThat(bytesRead).isEqualTo(2); + Assertions.assertThat(CodecTestUtils.convert(dst)).isEqualTo("ff"); + Assertions.assertThat(decoder.isCompleted()).isTrue(); + Assertions.assertThat(metrics.getBytesTransferred()).isEqualTo(16); dst.clear(); bytesRead = decoder.read(dst); - Assertions.assertEquals(-1, bytesRead); - Assertions.assertTrue(decoder.isCompleted()); - Assertions.assertEquals(16, metrics.getBytesTransferred()); + Assertions.assertThat(bytesRead).isEqualTo(-1); + Assertions.assertThat(decoder.isCompleted()).isTrue(); + Assertions.assertThat(metrics.getBytesTransferred()).isEqualTo(16); } @Test @@ -193,7 +193,7 @@ void testDecodingFromSessionBuffer1() throws Exception { inbuf.fill(channel); - Assertions.assertEquals(6, inbuf.length()); + Assertions.assertThat(inbuf.length()).isEqualTo(6); final LengthDelimitedDecoder decoder = new LengthDelimitedDecoder( channel, inbuf, metrics, 16); @@ -201,23 +201,23 @@ void testDecodingFromSessionBuffer1() throws Exception { final ByteBuffer dst = ByteBuffer.allocate(1024); int bytesRead = decoder.read(dst); - Assertions.assertEquals(6, bytesRead); - Assertions.assertEquals("stuff;", CodecTestUtils.convert(dst)); - Assertions.assertFalse(decoder.isCompleted()); - Assertions.assertEquals(0, metrics.getBytesTransferred()); + Assertions.assertThat(bytesRead).isEqualTo(6); + Assertions.assertThat(CodecTestUtils.convert(dst)).isEqualTo("stuff;"); + Assertions.assertThat(decoder.isCompleted()).isFalse(); + Assertions.assertThat(metrics.getBytesTransferred()).isEqualTo(0); dst.clear(); bytesRead = decoder.read(dst); - Assertions.assertEquals(10, bytesRead); - Assertions.assertEquals("more stuff", CodecTestUtils.convert(dst)); - Assertions.assertTrue(decoder.isCompleted()); - Assertions.assertEquals(10, metrics.getBytesTransferred()); + Assertions.assertThat(bytesRead).isEqualTo(10); + Assertions.assertThat(CodecTestUtils.convert(dst)).isEqualTo("more stuff"); + Assertions.assertThat(decoder.isCompleted()).isTrue(); + Assertions.assertThat(metrics.getBytesTransferred()).isEqualTo(10); dst.clear(); bytesRead = decoder.read(dst); - Assertions.assertEquals(-1, bytesRead); - Assertions.assertTrue(decoder.isCompleted()); - Assertions.assertEquals(10, metrics.getBytesTransferred()); + Assertions.assertThat(bytesRead).isEqualTo(-1); + Assertions.assertThat(decoder.isCompleted()).isTrue(); + Assertions.assertThat(metrics.getBytesTransferred()).isEqualTo(10); } @Test @@ -233,7 +233,7 @@ void testDecodingFromSessionBuffer2() throws Exception { inbuf.fill(channel); inbuf.fill(channel); - Assertions.assertEquals(38, inbuf.length()); + Assertions.assertThat(inbuf.length()).isEqualTo(38); final LengthDelimitedDecoder decoder = new LengthDelimitedDecoder( channel, inbuf, metrics, 16); @@ -241,16 +241,16 @@ void testDecodingFromSessionBuffer2() throws Exception { final ByteBuffer dst = ByteBuffer.allocate(1024); int bytesRead = decoder.read(dst); - Assertions.assertEquals(16, bytesRead); - Assertions.assertEquals("stuff;more stuff", CodecTestUtils.convert(dst)); - Assertions.assertTrue(decoder.isCompleted()); - Assertions.assertEquals(0, metrics.getBytesTransferred()); + Assertions.assertThat(bytesRead).isEqualTo(16); + Assertions.assertThat(CodecTestUtils.convert(dst)).isEqualTo("stuff;more stuff"); + Assertions.assertThat(decoder.isCompleted()).isTrue(); + Assertions.assertThat(metrics.getBytesTransferred()).isEqualTo(0); dst.clear(); bytesRead = decoder.read(dst); - Assertions.assertEquals(-1, bytesRead); - Assertions.assertTrue(decoder.isCompleted()); - Assertions.assertEquals(0, metrics.getBytesTransferred()); + Assertions.assertThat(bytesRead).isEqualTo(-1); + Assertions.assertThat(decoder.isCompleted()).isTrue(); + Assertions.assertThat(metrics.getBytesTransferred()).isEqualTo(0); } /* ----------------- FileChannel Part testing --------------------------- */ @@ -275,9 +275,8 @@ void testBasicDecodingFile() throws Exception { } } } - Assertions.assertEquals(this.tmpfile.length(), metrics.getBytesTransferred()); - Assertions.assertEquals("stuff; more stuff; a lot more stuff!", - CodecTestUtils.readFromFile(this.tmpfile)); + Assertions.assertThat(metrics.getBytesTransferred()).isEqualTo(this.tmpfile.length()); + Assertions.assertThat(CodecTestUtils.readFromFile(this.tmpfile)).isEqualTo("stuff; more stuff; a lot more stuff!"); } @Test @@ -291,7 +290,7 @@ void testDecodingFileWithBufferedSessionData() throws Exception { channel, inbuf, metrics, 36); final int i = inbuf.fill(channel); - Assertions.assertEquals(7, i); + Assertions.assertThat(i).isEqualTo(7); createTempFile(); try (RandomAccessFile testfile = new RandomAccessFile(this.tmpfile, "rw")) { @@ -304,9 +303,8 @@ void testDecodingFileWithBufferedSessionData() throws Exception { } } } - Assertions.assertEquals(this.tmpfile.length() - 7, metrics.getBytesTransferred()); - Assertions.assertEquals("stuff; more stuff; a lot more stuff!", - CodecTestUtils.readFromFile(this.tmpfile)); + Assertions.assertThat(metrics.getBytesTransferred()).isEqualTo(this.tmpfile.length() - 7); + Assertions.assertThat(CodecTestUtils.readFromFile(this.tmpfile)).isEqualTo("stuff; more stuff; a lot more stuff!"); } @Test @@ -320,7 +318,7 @@ void testDecodingFileWithOffsetAndBufferedSessionData() throws Exception { channel, inbuf, metrics, 36); final int i = inbuf.fill(channel); - Assertions.assertEquals(7, i); + Assertions.assertThat(i).isEqualTo(7); final byte[] beginning = "beginning; ".getBytes(StandardCharsets.US_ASCII); @@ -351,9 +349,8 @@ void testDecodingFileWithOffsetAndBufferedSessionData() throws Exception { } // count everything except the initial 7 bytes that went to the session buffer - Assertions.assertEquals(this.tmpfile.length() - 7 - beginning.length, metrics.getBytesTransferred()); - Assertions.assertEquals("beginning; stuff; more stuff; a lot more stuff!", - CodecTestUtils.readFromFile(this.tmpfile)); + Assertions.assertThat(metrics.getBytesTransferred()).isEqualTo(this.tmpfile.length() - 7 - beginning.length); + Assertions.assertThat(CodecTestUtils.readFromFile(this.tmpfile)).isEqualTo("beginning; stuff; more stuff; a lot more stuff!"); } @Test @@ -366,7 +363,7 @@ void testDecodingFileWithLimit() throws Exception { final LengthDelimitedDecoder decoder = new LengthDelimitedDecoder(channel, inbuf, metrics, 36); final int i = inbuf.fill(channel); - Assertions.assertEquals(19, i); + Assertions.assertThat(i).isEqualTo(19); createTempFile(); try (RandomAccessFile testfile = new RandomAccessFile(this.tmpfile, "rw")) { @@ -375,49 +372,48 @@ void testDecodingFileWithLimit() throws Exception { // transferred from buffer long bytesRead = decoder.transfer(fchannel, pos, 1); - Assertions.assertEquals(1, bytesRead); - Assertions.assertFalse(decoder.isCompleted()); - Assertions.assertEquals(0, metrics.getBytesTransferred()); + Assertions.assertThat(bytesRead).isEqualTo(1); + Assertions.assertThat(decoder.isCompleted()).isFalse(); + Assertions.assertThat(metrics.getBytesTransferred()).isEqualTo(0); pos += bytesRead; bytesRead = decoder.transfer(fchannel, pos, 2); - Assertions.assertEquals(2, bytesRead); - Assertions.assertFalse(decoder.isCompleted()); - Assertions.assertEquals(0, metrics.getBytesTransferred()); + Assertions.assertThat(bytesRead).isEqualTo(2); + Assertions.assertThat(decoder.isCompleted()).isFalse(); + Assertions.assertThat(metrics.getBytesTransferred()).isEqualTo(0); pos += bytesRead; bytesRead = decoder.transfer(fchannel, pos, 17); - Assertions.assertEquals(16, bytesRead); - Assertions.assertFalse(decoder.isCompleted()); - Assertions.assertEquals(0, metrics.getBytesTransferred()); + Assertions.assertThat(bytesRead).isEqualTo(16); + Assertions.assertThat(decoder.isCompleted()).isFalse(); + Assertions.assertThat(metrics.getBytesTransferred()).isEqualTo(0); pos += bytesRead; // transferred from channel bytesRead = decoder.transfer(fchannel, pos, 1); - Assertions.assertEquals(1, bytesRead); - Assertions.assertFalse(decoder.isCompleted()); - Assertions.assertEquals(1, metrics.getBytesTransferred()); + Assertions.assertThat(bytesRead).isEqualTo(1); + Assertions.assertThat(decoder.isCompleted()).isFalse(); + Assertions.assertThat(metrics.getBytesTransferred()).isEqualTo(1); pos += bytesRead; bytesRead = decoder.transfer(fchannel, pos, 2); - Assertions.assertEquals(2, bytesRead); - Assertions.assertFalse(decoder.isCompleted()); - Assertions.assertEquals(3, metrics.getBytesTransferred()); + Assertions.assertThat(bytesRead).isEqualTo(2); + Assertions.assertThat(decoder.isCompleted()).isFalse(); + Assertions.assertThat(metrics.getBytesTransferred()).isEqualTo(3); pos += bytesRead; bytesRead = decoder.transfer(fchannel, pos, 15); - Assertions.assertEquals(14, bytesRead); - Assertions.assertTrue(decoder.isCompleted()); - Assertions.assertEquals(17, metrics.getBytesTransferred()); + Assertions.assertThat(bytesRead).isEqualTo(14); + Assertions.assertThat(decoder.isCompleted()).isTrue(); + Assertions.assertThat(metrics.getBytesTransferred()).isEqualTo(17); pos += bytesRead; bytesRead = decoder.transfer(fchannel, pos, 1); - Assertions.assertEquals(-1, bytesRead); - Assertions.assertTrue(decoder.isCompleted()); - Assertions.assertEquals(17, metrics.getBytesTransferred()); + Assertions.assertThat(bytesRead).isEqualTo(-1); + Assertions.assertThat(decoder.isCompleted()).isTrue(); + Assertions.assertThat(metrics.getBytesTransferred()).isEqualTo(17); } - Assertions.assertEquals("stuff; more stuff; a lot more stuff!", - CodecTestUtils.readFromFile(this.tmpfile)); + Assertions.assertThat(CodecTestUtils.readFromFile(this.tmpfile)).isEqualTo("stuff; more stuff; a lot more stuff!"); } @Test @@ -433,8 +429,10 @@ void testWriteBeyondFileSize() throws Exception { createTempFile(); try (RandomAccessFile testfile = new RandomAccessFile(this.tmpfile, "rw")) { final FileChannel fchannel = testfile.getChannel(); - Assertions.assertEquals(0, testfile.length()); - Assertions.assertThrows(IOException.class, () -> decoder.transfer(fchannel, 5, 10)); + Assertions.assertThat(testfile.length()).isEqualTo(0); + Assertions.assertThatThrownBy(() -> + decoder.transfer(fchannel, 5, 10)) + .isInstanceOf(IOException.class); } } @@ -455,19 +453,19 @@ void testCodingBeyondContentLimitFile() throws Exception { final FileChannel fchannel = testfile.getChannel(); long bytesRead = decoder.transfer(fchannel, 0, 6); - Assertions.assertEquals(6, bytesRead); - Assertions.assertFalse(decoder.isCompleted()); - Assertions.assertEquals(6, metrics.getBytesTransferred()); + Assertions.assertThat(bytesRead).isEqualTo(6); + Assertions.assertThat(decoder.isCompleted()).isFalse(); + Assertions.assertThat(metrics.getBytesTransferred()).isEqualTo(6); bytesRead = decoder.transfer(fchannel,0 , 10); - Assertions.assertEquals(10, bytesRead); - Assertions.assertTrue(decoder.isCompleted()); - Assertions.assertEquals(16, metrics.getBytesTransferred()); + Assertions.assertThat(bytesRead).isEqualTo(10); + Assertions.assertThat(decoder.isCompleted()).isTrue(); + Assertions.assertThat(metrics.getBytesTransferred()).isEqualTo(16); bytesRead = decoder.transfer(fchannel, 0, 1); - Assertions.assertEquals(-1, bytesRead); - Assertions.assertTrue(decoder.isCompleted()); - Assertions.assertEquals(16, metrics.getBytesTransferred()); + Assertions.assertThat(bytesRead).isEqualTo(-1); + Assertions.assertThat(decoder.isCompleted()).isTrue(); + Assertions.assertThat(metrics.getBytesTransferred()).isEqualTo(16); } } @@ -478,10 +476,18 @@ void testInvalidConstructor() { final SessionInputBuffer inbuf = new SessionInputBufferImpl(1024, 256, 0, StandardCharsets.US_ASCII); final BasicHttpTransportMetrics metrics = new BasicHttpTransportMetrics(); - Assertions.assertThrows(NullPointerException.class, () -> new LengthDelimitedDecoder(null, null, null, 10)); - Assertions.assertThrows(NullPointerException.class, () -> new LengthDelimitedDecoder(channel, null, null, 10)); - Assertions.assertThrows(NullPointerException.class, () -> new LengthDelimitedDecoder(channel, inbuf, null, 10)); - Assertions.assertThrows(IllegalArgumentException.class, () -> new LengthDelimitedDecoder(channel, inbuf, metrics, -10)); + Assertions.assertThatThrownBy(() -> + new LengthDelimitedDecoder(null, null, null, 10)) + .isInstanceOf(NullPointerException.class); + Assertions.assertThatThrownBy(() -> + new LengthDelimitedDecoder(channel, null, null, 10)) + .isInstanceOf(NullPointerException.class); + Assertions.assertThatThrownBy(() -> + new LengthDelimitedDecoder(channel, inbuf, null, 10)) + .isInstanceOf(NullPointerException.class); + Assertions.assertThatThrownBy(() -> + new LengthDelimitedDecoder(channel, inbuf, metrics, -10)) + .isInstanceOf(IllegalArgumentException.class); } @Test @@ -495,7 +501,9 @@ void testInvalidInput() { final LengthDelimitedDecoder decoder = new LengthDelimitedDecoder( channel, inbuf, metrics, 3); - Assertions.assertThrows(NullPointerException.class, () -> decoder.read(null)); + Assertions.assertThatThrownBy(() -> + decoder.read(null)) + .isInstanceOf(NullPointerException.class); } @Test @@ -511,9 +519,9 @@ void testZeroLengthDecoding() throws Exception { final ByteBuffer dst = ByteBuffer.allocate(1024); final int bytesRead = decoder.read(dst); - Assertions.assertEquals(-1, bytesRead); - Assertions.assertTrue(decoder.isCompleted()); - Assertions.assertEquals(0, metrics.getBytesTransferred()); + Assertions.assertThat(bytesRead).isEqualTo(-1); + Assertions.assertThat(decoder.isCompleted()).isTrue(); + Assertions.assertThat(metrics.getBytesTransferred()).isEqualTo(0); } @Test @@ -529,9 +537,9 @@ void testTruncatedContent() throws Exception { final ByteBuffer dst = ByteBuffer.allocate(1024); final int bytesRead = decoder.read(dst); - Assertions.assertEquals(10, bytesRead); - Assertions.assertThrows(ConnectionClosedException.class, () -> - decoder.read(dst)); + Assertions.assertThat(bytesRead).isEqualTo(10); + Assertions.assertThatThrownBy(() -> + decoder.read(dst)).isInstanceOf(ConnectionClosedException.class); } @Test @@ -548,9 +556,9 @@ void testTruncatedContentWithFile() throws Exception { try (RandomAccessFile testfile = new RandomAccessFile(this.tmpfile, "rw")) { final FileChannel fchannel = testfile.getChannel(); final long bytesRead = decoder.transfer(fchannel, 0, Integer.MAX_VALUE); - Assertions.assertEquals(10, bytesRead); - Assertions.assertThrows(ConnectionClosedException.class, () -> - decoder.transfer(fchannel, 0, Integer.MAX_VALUE)); + Assertions.assertThat(bytesRead).isEqualTo(10); + Assertions.assertThatThrownBy(() -> + decoder.transfer(fchannel, 0, Integer.MAX_VALUE)).isInstanceOf(ConnectionClosedException.class); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/impl/nio/TestLengthDelimitedEncoder.java b/httpcore5/src/test/java/org/apache/hc/core5/http/impl/nio/TestLengthDelimitedEncoder.java index 927bb83392..a75065271e 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/impl/nio/TestLengthDelimitedEncoder.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/impl/nio/TestLengthDelimitedEncoder.java @@ -38,8 +38,8 @@ import org.apache.hc.core5.http.impl.BasicHttpTransportMetrics; import org.apache.hc.core5.http.nio.SessionOutputBuffer; import org.apache.hc.core5.util.CharArrayBuffer; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.AfterEach; -import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; import org.mockito.ArgumentMatchers; import org.mockito.Mockito; @@ -76,9 +76,9 @@ void testBasicCoding() throws Exception { final String s = channel.dump(StandardCharsets.US_ASCII); - Assertions.assertTrue(encoder.isCompleted()); - Assertions.assertEquals("stuff;more stuff", s); - Assertions.assertEquals("[content length: 16; pos: 16; completed: true]", encoder.toString()); + Assertions.assertThat(encoder.isCompleted()).isTrue(); + Assertions.assertThat(s).isEqualTo("stuff;more stuff"); + Assertions.assertThat(encoder.toString()).isEqualTo("[content length: 16; pos: 16; completed: true]"); } @Test @@ -94,8 +94,8 @@ void testCodingBeyondContentLimit() throws Exception { final String s = channel.dump(StandardCharsets.US_ASCII); - Assertions.assertTrue(encoder.isCompleted()); - Assertions.assertEquals("stuff;more stuff", s); + Assertions.assertThat(encoder.isCompleted()).isTrue(); + Assertions.assertThat(s).isEqualTo("stuff;more stuff"); } @Test @@ -117,8 +117,8 @@ void testCodingEmptyBuffer() throws Exception { final String s = channel.dump(StandardCharsets.US_ASCII); - Assertions.assertTrue(encoder.isCompleted()); - Assertions.assertEquals("stuff;more stuff", s); + Assertions.assertThat(encoder.isCompleted()).isTrue(); + Assertions.assertThat(s).isEqualTo("stuff;more stuff"); } @Test @@ -133,7 +133,9 @@ void testCodingCompleted() throws Exception { final ByteBuffer wrapped = CodecTestUtils.wrap("more stuff"); - Assertions.assertThrows(IllegalStateException.class, () -> encoder.write(wrapped)); + Assertions.assertThatThrownBy(() -> + encoder.write(wrapped)) + .isInstanceOf(IllegalStateException.class); } @Test @@ -142,10 +144,18 @@ void testInvalidConstructor() { final SessionOutputBuffer outbuf = new SessionOutputBufferImpl(1024, 128); final BasicHttpTransportMetrics metrics = new BasicHttpTransportMetrics(); - Assertions.assertThrows(NullPointerException.class, () -> new LengthDelimitedEncoder(null, null, null, 10)); - Assertions.assertThrows(NullPointerException.class, () -> new LengthDelimitedEncoder(channel, null, null, 10)); - Assertions.assertThrows(NullPointerException.class, () -> new LengthDelimitedEncoder(channel, outbuf, null, 10)); - Assertions.assertThrows(IllegalArgumentException.class, () -> new LengthDelimitedEncoder(channel, outbuf, metrics, -10)); + Assertions.assertThatThrownBy(() -> + new LengthDelimitedEncoder(null, null, null, 10)) + .isInstanceOf(NullPointerException.class); + Assertions.assertThatThrownBy(() -> + new LengthDelimitedEncoder(channel, null, null, 10)) + .isInstanceOf(NullPointerException.class); + Assertions.assertThatThrownBy(() -> + new LengthDelimitedEncoder(channel, outbuf, null, 10)) + .isInstanceOf(NullPointerException.class); + Assertions.assertThatThrownBy(() -> + new LengthDelimitedEncoder(channel, outbuf, metrics, -10)) + .isInstanceOf(IllegalArgumentException.class); } @Test @@ -176,8 +186,8 @@ void testCodingBeyondContentLimitFromFile() throws Exception { final String s = channel.dump(StandardCharsets.US_ASCII); - Assertions.assertTrue(encoder.isCompleted()); - Assertions.assertEquals("stuff;more stuff", s); + Assertions.assertThat(encoder.isCompleted()).isTrue(); + Assertions.assertThat(s).isEqualTo("stuff;more stuff"); } @Test @@ -206,8 +216,8 @@ void testCodingEmptyFile() throws Exception { final String s = channel.dump(StandardCharsets.US_ASCII); - Assertions.assertTrue(encoder.isCompleted()); - Assertions.assertEquals("stuff;more stuff", s); + Assertions.assertThat(encoder.isCompleted()).isTrue(); + Assertions.assertThat(s).isEqualTo("stuff;more stuff"); } @Test @@ -227,7 +237,9 @@ void testCodingCompletedFromFile() throws Exception { try (final RandomAccessFile file = new RandomAccessFile(this.tmpfile, "rw"); final FileChannel fchannel = file.getChannel()) { - Assertions.assertThrows(IllegalStateException.class, () -> encoder.transfer(fchannel, 0, 10)); + Assertions.assertThatThrownBy(() -> + encoder.transfer(fchannel, 0, 10)) + .isInstanceOf(IllegalStateException.class); } } @@ -258,8 +270,8 @@ void testCodingFromFileSmaller() throws Exception { } final String s = channel.dump(StandardCharsets.US_ASCII); - Assertions.assertTrue(encoder.isCompleted()); - Assertions.assertEquals("stuff;more stuff", s); + Assertions.assertThat(encoder.isCompleted()).isTrue(); + Assertions.assertThat(s).isEqualTo("stuff;more stuff"); } @Test @@ -293,8 +305,8 @@ void testCodingFromFileFlushBuffer() throws Exception { } final String s = channel.dump(StandardCharsets.US_ASCII); - Assertions.assertTrue(encoder.isCompleted()); - Assertions.assertEquals("header\r\nstuff;more stuff", s); + Assertions.assertThat(encoder.isCompleted()).isTrue(); + Assertions.assertThat(s).isEqualTo("header\r\nstuff;more stuff"); } @Test @@ -328,8 +340,8 @@ void testCodingFromFileChannelSaturated() throws Exception { } final String s = channel.dump(StandardCharsets.US_ASCII); - Assertions.assertFalse(encoder.isCompleted()); - Assertions.assertEquals("head", s); + Assertions.assertThat(encoder.isCompleted()).isFalse(); + Assertions.assertThat(s).isEqualTo("head"); } @Test @@ -343,18 +355,18 @@ void testCodingNoFragmentBuffering() throws Exception { outbuf.writeLine(chbuffer); final LengthDelimitedEncoder encoder = new LengthDelimitedEncoder(channel, outbuf, metrics, 100, 0); - Assertions.assertEquals(5, encoder.write(CodecTestUtils.wrap("stuff"))); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("stuff"))).isEqualTo(5); Mockito.verify(channel, Mockito.times(2)).write(ArgumentMatchers.any()); Mockito.verify(outbuf, Mockito.never()).write(ArgumentMatchers.any()); Mockito.verify(outbuf, Mockito.times(1)).flush(channel); - Assertions.assertEquals(13, metrics.getBytesTransferred()); + Assertions.assertThat(metrics.getBytesTransferred()).isEqualTo(13); outbuf.flush(channel); final String s = channel.dump(StandardCharsets.US_ASCII); - Assertions.assertEquals("header\r\nstuff", s); + Assertions.assertThat(s).isEqualTo("header\r\nstuff"); } @Test @@ -368,18 +380,18 @@ void testCodingFragmentBuffering() throws Exception { outbuf.writeLine(chbuffer); final LengthDelimitedEncoder encoder = new LengthDelimitedEncoder(channel, outbuf, metrics, 100, 32); - Assertions.assertEquals(5, encoder.write(CodecTestUtils.wrap("stuff"))); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("stuff"))).isEqualTo(5); Mockito.verify(channel, Mockito.never()).write(ArgumentMatchers.any()); Mockito.verify(outbuf, Mockito.times(1)).write(ArgumentMatchers.any()); Mockito.verify(outbuf, Mockito.never()).flush(channel); - Assertions.assertEquals(0, metrics.getBytesTransferred()); + Assertions.assertThat(metrics.getBytesTransferred()).isEqualTo(0); outbuf.flush(channel); final String s = channel.dump(StandardCharsets.US_ASCII); - Assertions.assertEquals("header\r\nstuff", s); + Assertions.assertThat(s).isEqualTo("header\r\nstuff"); } @Test @@ -390,20 +402,20 @@ void testCodingFragmentBufferingMultipleFragments() throws Exception { final LengthDelimitedEncoder encoder = new LengthDelimitedEncoder(channel, outbuf, metrics, 100, 32); - Assertions.assertEquals(5, encoder.write(CodecTestUtils.wrap("stuff"))); - Assertions.assertEquals(1, encoder.write(CodecTestUtils.wrap("-"))); - Assertions.assertEquals(10, encoder.write(CodecTestUtils.wrap("more stuff"))); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("stuff"))).isEqualTo(5); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("-"))).isEqualTo(1); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("more stuff"))).isEqualTo(10); Mockito.verify(channel, Mockito.never()).write(ArgumentMatchers.any()); Mockito.verify(outbuf, Mockito.times(3)).write(ArgumentMatchers.any()); Mockito.verify(outbuf, Mockito.never()).flush(channel); - Assertions.assertEquals(0, metrics.getBytesTransferred()); + Assertions.assertThat(metrics.getBytesTransferred()).isEqualTo(0); outbuf.flush(channel); final String s = channel.dump(StandardCharsets.US_ASCII); - Assertions.assertEquals("stuff-more stuff", s); + Assertions.assertThat(s).isEqualTo("stuff-more stuff"); } @Test @@ -414,20 +426,20 @@ void testCodingFragmentBufferingMultipleFragmentsBeyondContentLimit() throws Exc final LengthDelimitedEncoder encoder = new LengthDelimitedEncoder(channel, outbuf, metrics, 16, 32); - Assertions.assertEquals(5, encoder.write(CodecTestUtils.wrap("stuff"))); - Assertions.assertEquals(1, encoder.write(CodecTestUtils.wrap("-"))); - Assertions.assertEquals(10, encoder.write(CodecTestUtils.wrap("more stuff; and a lot more stuff"))); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("stuff"))).isEqualTo(5); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("-"))).isEqualTo(1); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("more stuff; and a lot more stuff"))).isEqualTo(10); Mockito.verify(channel, Mockito.never()).write(ArgumentMatchers.any()); Mockito.verify(outbuf, Mockito.times(3)).write(ArgumentMatchers.any()); Mockito.verify(outbuf, Mockito.never()).flush(channel); - Assertions.assertEquals(0, metrics.getBytesTransferred()); + Assertions.assertThat(metrics.getBytesTransferred()).isEqualTo(0); outbuf.flush(channel); final String s = channel.dump(StandardCharsets.US_ASCII); - Assertions.assertEquals("stuff-more stuff", s); + Assertions.assertThat(s).isEqualTo("stuff-more stuff"); } @Test @@ -441,17 +453,17 @@ void testCodingFragmentBufferingLargeFragment() throws Exception { outbuf.writeLine(chbuffer); final LengthDelimitedEncoder encoder = new LengthDelimitedEncoder(channel, outbuf, metrics, 100, 2); - Assertions.assertEquals(5, encoder.write(CodecTestUtils.wrap("stuff"))); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("stuff"))).isEqualTo(5); Mockito.verify(channel, Mockito.times(2)).write(ArgumentMatchers.any()); Mockito.verify(outbuf, Mockito.never()).write(ArgumentMatchers.any()); Mockito.verify(outbuf, Mockito.times(1)).flush(channel); - Assertions.assertEquals(13, metrics.getBytesTransferred()); + Assertions.assertThat(metrics.getBytesTransferred()).isEqualTo(13); outbuf.flush(channel); final String s = channel.dump(StandardCharsets.US_ASCII); - Assertions.assertEquals("header\r\nstuff", s); + Assertions.assertThat(s).isEqualTo("header\r\nstuff"); } @Test @@ -462,22 +474,22 @@ void testCodingFragmentBufferingTinyFragments() throws Exception { final LengthDelimitedEncoder encoder = new LengthDelimitedEncoder(channel, outbuf, metrics, 100, 1); - Assertions.assertEquals(5, encoder.write(CodecTestUtils.wrap("stuff"))); - Assertions.assertEquals(1, encoder.write(CodecTestUtils.wrap("-"))); - Assertions.assertEquals(1, encoder.write(CodecTestUtils.wrap("-"))); - Assertions.assertEquals(1, encoder.write(CodecTestUtils.wrap("-"))); - Assertions.assertEquals(10, encoder.write(CodecTestUtils.wrap("more stuff"))); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("stuff"))).isEqualTo(5); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("-"))).isEqualTo(1); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("-"))).isEqualTo(1); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("-"))).isEqualTo(1); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("more stuff"))).isEqualTo(10); Mockito.verify(channel, Mockito.times(5)).write(ArgumentMatchers.any()); Mockito.verify(outbuf, Mockito.times(3)).write(ArgumentMatchers.any()); Mockito.verify(outbuf, Mockito.times(3)).flush(channel); - Assertions.assertEquals(18, metrics.getBytesTransferred()); + Assertions.assertThat(metrics.getBytesTransferred()).isEqualTo(18); outbuf.flush(channel); final String s = channel.dump(StandardCharsets.US_ASCII); - Assertions.assertEquals("stuff---more stuff", s); + Assertions.assertThat(s).isEqualTo("stuff---more stuff"); } @Test @@ -488,22 +500,22 @@ void testCodingFragmentBufferingTinyFragments2() throws Exception { final LengthDelimitedEncoder encoder = new LengthDelimitedEncoder(channel, outbuf, metrics, 100, 2); - Assertions.assertEquals(5, encoder.write(CodecTestUtils.wrap("stuff"))); - Assertions.assertEquals(1, encoder.write(CodecTestUtils.wrap("-"))); - Assertions.assertEquals(1, encoder.write(CodecTestUtils.wrap("-"))); - Assertions.assertEquals(1, encoder.write(CodecTestUtils.wrap("-"))); - Assertions.assertEquals(10, encoder.write(CodecTestUtils.wrap("more stuff"))); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("stuff"))).isEqualTo(5); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("-"))).isEqualTo(1); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("-"))).isEqualTo(1); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("-"))).isEqualTo(1); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("more stuff"))).isEqualTo(10); Mockito.verify(channel, Mockito.times(4)).write(ArgumentMatchers.any()); Mockito.verify(outbuf, Mockito.times(3)).write(ArgumentMatchers.any()); Mockito.verify(outbuf, Mockito.times(2)).flush(channel); - Assertions.assertEquals(18, metrics.getBytesTransferred()); + Assertions.assertThat(metrics.getBytesTransferred()).isEqualTo(18); outbuf.flush(channel); final String s = channel.dump(StandardCharsets.US_ASCII); - Assertions.assertEquals("stuff---more stuff", s); + Assertions.assertThat(s).isEqualTo("stuff---more stuff"); } @Test @@ -514,24 +526,24 @@ void testCodingFragmentBufferingTinyFragments3() throws Exception { final LengthDelimitedEncoder encoder = new LengthDelimitedEncoder(channel, outbuf, metrics, 100, 3); - Assertions.assertEquals(5, encoder.write(CodecTestUtils.wrap("stuff"))); - Assertions.assertEquals(1, encoder.write(CodecTestUtils.wrap("-"))); - Assertions.assertEquals(1, encoder.write(CodecTestUtils.wrap("-"))); - Assertions.assertEquals(1, encoder.write(CodecTestUtils.wrap("-"))); - Assertions.assertEquals(1, encoder.write(CodecTestUtils.wrap("-"))); - Assertions.assertEquals(2, encoder.write(CodecTestUtils.wrap("--"))); - Assertions.assertEquals(10, encoder.write(CodecTestUtils.wrap("more stuff"))); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("stuff"))).isEqualTo(5); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("-"))).isEqualTo(1); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("-"))).isEqualTo(1); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("-"))).isEqualTo(1); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("-"))).isEqualTo(1); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("--"))).isEqualTo(2); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("more stuff"))).isEqualTo(10); Mockito.verify(channel, Mockito.times(4)).write(ArgumentMatchers.any()); Mockito.verify(outbuf, Mockito.times(5)).write(ArgumentMatchers.any()); Mockito.verify(outbuf, Mockito.times(2)).flush(channel); - Assertions.assertEquals(21, metrics.getBytesTransferred()); + Assertions.assertThat(metrics.getBytesTransferred()).isEqualTo(21); outbuf.flush(channel); final String s = channel.dump(StandardCharsets.US_ASCII); - Assertions.assertEquals("stuff------more stuff", s); + Assertions.assertThat(s).isEqualTo("stuff------more stuff"); } @Test @@ -542,20 +554,20 @@ void testCodingFragmentBufferingBufferFlush() throws Exception { final LengthDelimitedEncoder encoder = new LengthDelimitedEncoder(channel, outbuf, metrics, 100, 8); - Assertions.assertEquals(5, encoder.write(CodecTestUtils.wrap("stuff"))); - Assertions.assertEquals(6, encoder.write(CodecTestUtils.wrap("-stuff"))); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("stuff"))).isEqualTo(5); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("-stuff"))).isEqualTo(6); Mockito.verify(channel, Mockito.times(1)).write(ArgumentMatchers.any()); Mockito.verify(outbuf, Mockito.times(3)).write(ArgumentMatchers.any()); Mockito.verify(outbuf, Mockito.times(1)).flush(channel); - Assertions.assertEquals(8, metrics.getBytesTransferred()); - Assertions.assertEquals(3, outbuf.length()); + Assertions.assertThat(metrics.getBytesTransferred()).isEqualTo(8); + Assertions.assertThat(outbuf.length()).isEqualTo(3); outbuf.flush(channel); final String s = channel.dump(StandardCharsets.US_ASCII); - Assertions.assertEquals("stuff-stuff", s); + Assertions.assertThat(s).isEqualTo("stuff-stuff"); } @Test @@ -566,20 +578,20 @@ void testCodingFragmentBufferingBufferFlush2() throws Exception { final LengthDelimitedEncoder encoder = new LengthDelimitedEncoder(channel, outbuf, metrics, 100, 8); - Assertions.assertEquals(5, encoder.write(CodecTestUtils.wrap("stuff"))); - Assertions.assertEquals(16, encoder.write(CodecTestUtils.wrap("-much more stuff"))); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("stuff"))).isEqualTo(5); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("-much more stuff"))).isEqualTo(16); Mockito.verify(channel, Mockito.times(2)).write(ArgumentMatchers.any()); Mockito.verify(outbuf, Mockito.times(1)).write(ArgumentMatchers.any()); Mockito.verify(outbuf, Mockito.times(1)).flush(channel); - Assertions.assertEquals(21, metrics.getBytesTransferred()); - Assertions.assertEquals(0, outbuf.length()); + Assertions.assertThat(metrics.getBytesTransferred()).isEqualTo(21); + Assertions.assertThat(outbuf.length()).isEqualTo(0); outbuf.flush(channel); final String s = channel.dump(StandardCharsets.US_ASCII); - Assertions.assertEquals("stuff-much more stuff", s); + Assertions.assertThat(s).isEqualTo("stuff-much more stuff"); } @Test @@ -590,27 +602,27 @@ void testCodingFragmentBufferingChannelSaturated() throws Exception { final LengthDelimitedEncoder encoder = new LengthDelimitedEncoder(channel, outbuf, metrics, 100, 3); - Assertions.assertEquals(5, encoder.write(CodecTestUtils.wrap("stuff"))); - Assertions.assertEquals(1, encoder.write(CodecTestUtils.wrap("-"))); - Assertions.assertEquals(1, encoder.write(CodecTestUtils.wrap("-"))); - Assertions.assertEquals(1, encoder.write(CodecTestUtils.wrap("-"))); - Assertions.assertEquals(1, encoder.write(CodecTestUtils.wrap("-"))); - Assertions.assertEquals(1, encoder.write(CodecTestUtils.wrap("-"))); - Assertions.assertEquals(1, encoder.write(CodecTestUtils.wrap("-"))); - Assertions.assertEquals(0, encoder.write(CodecTestUtils.wrap("-"))); - Assertions.assertEquals(0, encoder.write(CodecTestUtils.wrap("more stuff"))); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("stuff"))).isEqualTo(5); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("-"))).isEqualTo(1); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("-"))).isEqualTo(1); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("-"))).isEqualTo(1); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("-"))).isEqualTo(1); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("-"))).isEqualTo(1); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("-"))).isEqualTo(1); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("-"))).isEqualTo(0); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("more stuff"))).isEqualTo(0); Mockito.verify(channel, Mockito.times(5)).write(ArgumentMatchers.any()); Mockito.verify(outbuf, Mockito.times(6)).write(ArgumentMatchers.any()); Mockito.verify(outbuf, Mockito.times(4)).flush(channel); - Assertions.assertEquals(8, metrics.getBytesTransferred()); + Assertions.assertThat(metrics.getBytesTransferred()).isEqualTo(8); outbuf.flush(channel); final String s = channel.dump(StandardCharsets.US_ASCII); - Assertions.assertEquals("stuff---", s); - Assertions.assertEquals(3, outbuf.length()); + Assertions.assertThat(s).isEqualTo("stuff---"); + Assertions.assertThat(outbuf.length()).isEqualTo(3); } @Test @@ -621,22 +633,22 @@ void testCodingFragmentBufferingChannelSaturated2() throws Exception { final LengthDelimitedEncoder encoder = new LengthDelimitedEncoder(channel, outbuf, metrics, 100, 8); - Assertions.assertEquals(5, encoder.write(CodecTestUtils.wrap("stuff"))); - Assertions.assertEquals(1, encoder.write(CodecTestUtils.wrap("-"))); - Assertions.assertEquals(1, encoder.write(CodecTestUtils.wrap("-"))); - Assertions.assertEquals(1, encoder.write(CodecTestUtils.wrap("much more stuff"))); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("stuff"))).isEqualTo(5); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("-"))).isEqualTo(1); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("-"))).isEqualTo(1); + Assertions.assertThat(encoder.write(CodecTestUtils.wrap("much more stuff"))).isEqualTo(1); Mockito.verify(channel, Mockito.times(3)).write(ArgumentMatchers.any()); Mockito.verify(outbuf, Mockito.times(3)).write(ArgumentMatchers.any()); Mockito.verify(outbuf, Mockito.times(1)).flush(channel); - Assertions.assertEquals(8, metrics.getBytesTransferred()); + Assertions.assertThat(metrics.getBytesTransferred()).isEqualTo(8); outbuf.flush(channel); final String s = channel.dump(StandardCharsets.US_ASCII); - Assertions.assertEquals("stuff--m", s); - Assertions.assertEquals(0, outbuf.length()); + Assertions.assertThat(s).isEqualTo("stuff--m"); + Assertions.assertThat(outbuf.length()).isEqualTo(0); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/impl/nio/TestSessionInOutBuffers.java b/httpcore5/src/test/java/org/apache/hc/core5/http/impl/nio/TestSessionInOutBuffers.java index 7f0f47c299..002d881d8c 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/impl/nio/TestSessionInOutBuffers.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/impl/nio/TestSessionInOutBuffers.java @@ -44,7 +44,7 @@ import org.apache.hc.core5.http.nio.SessionInputBuffer; import org.apache.hc.core5.http.nio.SessionOutputBuffer; import org.apache.hc.core5.util.CharArrayBuffer; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; /** @@ -83,9 +83,9 @@ void testEncodedWriteLineFiltersControlCharacters() throws Exception { outbuffer.flush(channel); } - Assertions.assertEquals("X-Test: ok??X-Injected: yes????\t\u00e9\u20ac\r\n", - new String(out.toByteArray(), StandardCharsets.UTF_8)); - Assertions.assertEquals(original, line.toString()); + Assertions.assertThat(new String(out.toByteArray(), StandardCharsets.UTF_8)) + .isEqualTo("X-Test: ok??X-Injected: yes????\t\u00e9\u20ac\r\n"); + Assertions.assertThat(line.toString()).isEqualTo(original); } @Test @@ -101,8 +101,8 @@ void testDefaultWriteLineFilteringIsUnchanged() throws Exception { outbuffer.flush(channel); } - Assertions.assertEquals("X-Test: ok??X-Injected: yes\r\n", - new String(out.toByteArray(), StandardCharsets.ISO_8859_1)); + Assertions.assertThat(new String(out.toByteArray(), StandardCharsets.ISO_8859_1)) + .isEqualTo("X-Test: ok??X-Injected: yes\r\n"); } @Test @@ -121,10 +121,10 @@ void testWriteBinaryDataWithCharsetEncoder() throws Exception { final WritableByteChannel channel = Channels.newChannel(outputStream); while (outbuffer.hasData()) { - Assertions.assertTrue(outbuffer.flush(channel) > 0); + Assertions.assertThat(outbuffer.flush(channel)).isGreaterThan(0); } - Assertions.assertArrayEquals(payload, outputStream.toByteArray()); + Assertions.assertThat(outputStream.toByteArray()).containsExactly(payload); } @Test @@ -138,31 +138,31 @@ void testReadLineChunks() throws Exception { final CharArrayBuffer line = new CharArrayBuffer(64); line.clear(); - Assertions.assertTrue(inbuf.readLine(line, false)); - Assertions.assertEquals("One", line.toString()); + Assertions.assertThat(inbuf.readLine(line, false)).isTrue(); + Assertions.assertThat(line.toString()).isEqualTo("One"); line.clear(); - Assertions.assertTrue(inbuf.readLine(line, false)); - Assertions.assertEquals("Two", line.toString()); + Assertions.assertThat(inbuf.readLine(line, false)).isTrue(); + Assertions.assertThat(line.toString()).isEqualTo("Two"); line.clear(); - Assertions.assertFalse(inbuf.readLine(line, false)); + Assertions.assertThat(inbuf.readLine(line, false)).isFalse(); channel = newChannel("\r\nFour"); inbuf.fill(channel); line.clear(); - Assertions.assertTrue(inbuf.readLine(line, false)); - Assertions.assertEquals("Three", line.toString()); + Assertions.assertThat(inbuf.readLine(line, false)).isTrue(); + Assertions.assertThat(line.toString()).isEqualTo("Three"); inbuf.fill(channel); line.clear(); - Assertions.assertTrue(inbuf.readLine(line, true)); - Assertions.assertEquals("Four", line.toString()); + Assertions.assertThat(inbuf.readLine(line, true)).isTrue(); + Assertions.assertThat(line.toString()).isEqualTo("Four"); line.clear(); - Assertions.assertFalse(inbuf.readLine(line, true)); + Assertions.assertThat(inbuf.readLine(line, true)).isFalse(); } @Test @@ -173,13 +173,15 @@ void testLineLimit() throws Exception { final ReadableByteChannel channel1 = newChannel(s); inbuf1.fill(channel1); - Assertions.assertTrue(inbuf1.readLine(line, false)); + Assertions.assertThat(inbuf1.readLine(line, false)).isTrue(); line.clear(); final SessionInputBuffer inbuf2 = new SessionInputBufferImpl(128, 128, 10); final ReadableByteChannel channel2 = newChannel(s); inbuf2.fill(channel2); - Assertions.assertThrows(MessageConstraintException.class, () -> inbuf2.readLine(line, false)); + Assertions.assertThatThrownBy(() -> + inbuf2.readLine(line, false)) + .isInstanceOf(MessageConstraintException.class); } @Test @@ -190,13 +192,15 @@ void testLineLimitBufferFull() throws Exception { final ReadableByteChannel channel1 = newChannel(s); inbuf1.fill(channel1); - Assertions.assertFalse(inbuf1.readLine(line, false)); + Assertions.assertThat(inbuf1.readLine(line, false)).isFalse(); line.clear(); final SessionInputBuffer inbuf2 = new SessionInputBufferImpl(32, 32,10); final ReadableByteChannel channel2 = newChannel(s); inbuf2.fill(channel2); - Assertions.assertThrows(MessageConstraintException.class, () -> inbuf2.readLine(line, false)); + Assertions.assertThatThrownBy(() -> + inbuf2.readLine(line, false)) + .isInstanceOf(MessageConstraintException.class); } @Test @@ -211,46 +215,46 @@ void testWriteLineChunks() throws Exception { final CharArrayBuffer line = new CharArrayBuffer(64); line.clear(); - Assertions.assertTrue(inbuf.readLine(line, false)); - Assertions.assertEquals("One", line.toString()); + Assertions.assertThat(inbuf.readLine(line, false)).isTrue(); + Assertions.assertThat(line.toString()).isEqualTo("One"); outbuf.writeLine(line); line.clear(); - Assertions.assertTrue(inbuf.readLine(line, false)); - Assertions.assertEquals("Two", line.toString()); + Assertions.assertThat(inbuf.readLine(line, false)).isTrue(); + Assertions.assertThat(line.toString()).isEqualTo("Two"); outbuf.writeLine(line); line.clear(); - Assertions.assertFalse(inbuf.readLine(line, false)); + Assertions.assertThat(inbuf.readLine(line, false)).isFalse(); inChannel = newChannel("\r\nFour"); inbuf.fill(inChannel); line.clear(); - Assertions.assertTrue(inbuf.readLine(line, false)); - Assertions.assertEquals("Three", line.toString()); + Assertions.assertThat(inbuf.readLine(line, false)).isTrue(); + Assertions.assertThat(line.toString()).isEqualTo("Three"); outbuf.writeLine(line); inbuf.fill(inChannel); line.clear(); - Assertions.assertTrue(inbuf.readLine(line, true)); - Assertions.assertEquals("Four", line.toString()); + Assertions.assertThat(inbuf.readLine(line, true)).isTrue(); + Assertions.assertThat(line.toString()).isEqualTo("Four"); outbuf.writeLine(line); line.clear(); - Assertions.assertFalse(inbuf.readLine(line, true)); + Assertions.assertThat(inbuf.readLine(line, true)).isFalse(); final ByteArrayOutputStream outStream = new ByteArrayOutputStream(); final WritableByteChannel outChannel = newChannel(outStream); outbuf.flush(outChannel); final String s = new String(outStream.toByteArray(), StandardCharsets.US_ASCII); - Assertions.assertEquals("One\r\nTwo\r\nThree\r\nFour\r\n", s); + Assertions.assertThat(s).isEqualTo("One\r\nTwo\r\nThree\r\nFour\r\n"); } @Test @@ -278,7 +282,7 @@ void testNonASCIIWriteLine() throws Exception { inbuf.fill(channel); chbuffer.clear(); inbuf.readLine(chbuffer, true); - Assertions.assertEquals(expectedResult, chbuffer.toString()); + Assertions.assertThat(chbuffer.toString()).isEqualTo(expectedResult); } @Test @@ -319,12 +323,12 @@ void testBasicReadWriteLine() throws Exception { for (final String teststr : teststrs) { chbuffer.clear(); inbuf.readLine(chbuffer, true); - Assertions.assertEquals(teststr, chbuffer.toString()); + Assertions.assertThat(chbuffer.toString()).isEqualTo(teststr); } chbuffer.clear(); - Assertions.assertFalse(inbuf.readLine(chbuffer, true)); + Assertions.assertThat(inbuf.readLine(chbuffer, true)).isFalse(); chbuffer.clear(); - Assertions.assertFalse(inbuf.readLine(chbuffer, true)); + Assertions.assertThat(inbuf.readLine(chbuffer, true)).isFalse(); } @Test @@ -373,34 +377,34 @@ void testComplexReadWriteLine() throws Exception { final CharArrayBuffer chbuffer = new CharArrayBuffer(32); chbuffer.clear(); inbuf.readLine(chbuffer, true); - Assertions.assertEquals("a", chbuffer.toString()); + Assertions.assertThat(chbuffer.toString()).isEqualTo("a"); chbuffer.clear(); inbuf.readLine(chbuffer, true); - Assertions.assertEquals("", chbuffer.toString()); + Assertions.assertThat(chbuffer.toString()).isEqualTo(""); chbuffer.clear(); inbuf.readLine(chbuffer, true); - Assertions.assertEquals("\r", chbuffer.toString()); + Assertions.assertThat(chbuffer.toString()).isEqualTo("\r"); chbuffer.clear(); inbuf.readLine(chbuffer, true); - Assertions.assertEquals("", chbuffer.toString()); + Assertions.assertThat(chbuffer.toString()).isEqualTo(""); chbuffer.clear(); inbuf.readLine(chbuffer, true); - Assertions.assertEquals(s1, chbuffer.toString()); + Assertions.assertThat(chbuffer.toString()).isEqualTo(s1); chbuffer.clear(); inbuf.readLine(chbuffer, true); - Assertions.assertEquals(s2, chbuffer.toString()); + Assertions.assertThat(chbuffer.toString()).isEqualTo(s2); chbuffer.clear(); inbuf.readLine(chbuffer, true); - Assertions.assertEquals(s3, chbuffer.toString()); + Assertions.assertThat(chbuffer.toString()).isEqualTo(s3); chbuffer.clear(); inbuf.readLine(chbuffer, true); - Assertions.assertEquals("a", chbuffer.toString()); + Assertions.assertThat(chbuffer.toString()).isEqualTo("a"); chbuffer.clear(); inbuf.readLine(chbuffer, true); - Assertions.assertFalse(inbuf.readLine(chbuffer, true)); + Assertions.assertThat(inbuf.readLine(chbuffer, true)).isFalse(); chbuffer.clear(); inbuf.readLine(chbuffer, true); - Assertions.assertFalse(inbuf.readLine(chbuffer, true)); + Assertions.assertThat(inbuf.readLine(chbuffer, true)).isFalse(); } @Test @@ -420,7 +424,7 @@ void testReadOneByte() throws Exception { in[i] = (byte)inbuf.read(); } for (int i = 0; i < out.length; i++) { - Assertions.assertEquals(out[i], in[i]); + Assertions.assertThat(in[i]).isEqualTo(out[i]); } } @@ -432,13 +436,13 @@ void testReadByteBuffer() throws Exception { while (inbuf.fill(channel) > 0) { } final ByteBuffer dst = ByteBuffer.allocate(10); - Assertions.assertEquals(10, inbuf.read(dst)); + Assertions.assertThat(inbuf.read(dst)).isEqualTo(10); dst.flip(); - Assertions.assertEquals(dst, ByteBuffer.wrap(pattern, 0, 10)); + Assertions.assertThat(ByteBuffer.wrap(pattern, 0, 10)).isEqualTo(dst); dst.clear(); - Assertions.assertEquals(6, inbuf.read(dst)); + Assertions.assertThat(inbuf.read(dst)).isEqualTo(6); dst.flip(); - Assertions.assertEquals(dst, ByteBuffer.wrap(pattern, 10, 6)); + Assertions.assertThat(ByteBuffer.wrap(pattern, 10, 6)).isEqualTo(dst); } @Test @@ -449,16 +453,16 @@ void testReadByteBufferWithMaxLen() throws Exception { while (inbuf.fill(channel) > 0) { } final ByteBuffer dst = ByteBuffer.allocate(16); - Assertions.assertEquals(10, inbuf.read(dst, 10)); + Assertions.assertThat(inbuf.read(dst, 10)).isEqualTo(10); dst.flip(); - Assertions.assertEquals(dst, ByteBuffer.wrap(pattern, 0, 10)); + Assertions.assertThat(ByteBuffer.wrap(pattern, 0, 10)).isEqualTo(dst); dst.clear(); - Assertions.assertEquals(3, inbuf.read(dst, 3)); + Assertions.assertThat(inbuf.read(dst, 3)).isEqualTo(3); dst.flip(); - Assertions.assertEquals(dst, ByteBuffer.wrap(pattern, 10, 3)); - Assertions.assertEquals(3, inbuf.read(dst, 20)); + Assertions.assertThat(ByteBuffer.wrap(pattern, 10, 3)).isEqualTo(dst); + Assertions.assertThat(inbuf.read(dst, 20)).isEqualTo(3); dst.flip(); - Assertions.assertEquals(dst, ByteBuffer.wrap(pattern, 13, 3)); + Assertions.assertThat(ByteBuffer.wrap(pattern, 13, 3)).isEqualTo(dst); } @Test @@ -472,8 +476,8 @@ void testReadToChannel() throws Exception { final ByteArrayOutputStream outStream = new ByteArrayOutputStream(); final WritableByteChannel dst = newChannel(outStream); - Assertions.assertEquals(16, inbuf.read(dst)); - Assertions.assertEquals(ByteBuffer.wrap(pattern), ByteBuffer.wrap(outStream.toByteArray())); + Assertions.assertThat(inbuf.read(dst)).isEqualTo(16); + Assertions.assertThat(ByteBuffer.wrap(outStream.toByteArray())).isEqualTo(ByteBuffer.wrap(pattern)); } @Test @@ -487,10 +491,10 @@ void testReadToChannelWithMaxLen() throws Exception { final ByteArrayOutputStream outStream = new ByteArrayOutputStream(); final WritableByteChannel dst = newChannel(outStream); - Assertions.assertEquals(10, inbuf.read(dst, 10)); - Assertions.assertEquals(3, inbuf.read(dst, 3)); - Assertions.assertEquals(3, inbuf.read(dst, 10)); - Assertions.assertEquals(ByteBuffer.wrap(pattern), ByteBuffer.wrap(outStream.toByteArray())); + Assertions.assertThat(inbuf.read(dst, 10)).isEqualTo(10); + Assertions.assertThat(inbuf.read(dst, 3)).isEqualTo(3); + Assertions.assertThat(inbuf.read(dst, 10)).isEqualTo(3); + Assertions.assertThat(ByteBuffer.wrap(outStream.toByteArray())).isEqualTo(ByteBuffer.wrap(pattern)); } @Test @@ -505,7 +509,7 @@ void testWriteByteBuffer() throws Exception { final WritableByteChannel channel = newChannel(outStream); while (outbuf.flush(channel) > 0) { } - Assertions.assertEquals(ByteBuffer.wrap(pattern), ByteBuffer.wrap(outStream.toByteArray())); + Assertions.assertThat(ByteBuffer.wrap(outStream.toByteArray())).isEqualTo(ByteBuffer.wrap(pattern)); } @Test @@ -521,7 +525,7 @@ void testWriteFromChannel() throws Exception { final WritableByteChannel channel = newChannel(outStream); while (outbuf.flush(channel) > 0) { } - Assertions.assertEquals(ByteBuffer.wrap(pattern), ByteBuffer.wrap(outStream.toByteArray())); + Assertions.assertThat(ByteBuffer.wrap(outStream.toByteArray())).isEqualTo(ByteBuffer.wrap(pattern)); } static final int SWISS_GERMAN_HELLO [] = { @@ -581,13 +585,13 @@ void testMultibyteCodedReadWriteLine() throws Exception { for (int i = 0; i < 10; i++) { chbuffer.clear(); inbuf.readLine(chbuffer, true); - Assertions.assertEquals(s1, chbuffer.toString()); + Assertions.assertThat(chbuffer.toString()).isEqualTo(s1); chbuffer.clear(); inbuf.readLine(chbuffer, true); - Assertions.assertEquals(s2, chbuffer.toString()); + Assertions.assertThat(chbuffer.toString()).isEqualTo(s2); chbuffer.clear(); inbuf.readLine(chbuffer, true); - Assertions.assertEquals(s3, chbuffer.toString()); + Assertions.assertThat(chbuffer.toString()).isEqualTo(s3); } } @@ -597,7 +601,7 @@ void testInputMatchesBufferLength() { final SessionOutputBuffer outbuf = new SessionOutputBufferImpl(1024, 5); final CharArrayBuffer chbuffer = new CharArrayBuffer(16); chbuffer.append(s1); - Assertions.assertDoesNotThrow(() -> outbuf.writeLine(chbuffer)); + Assertions.assertThatCode(() -> outbuf.writeLine(chbuffer)).doesNotThrowAnyException(); } @Test @@ -613,8 +617,8 @@ void testMalformedInputActionReport() throws Exception { while (inbuf.fill(channel) > 0) { } final CharArrayBuffer chbuffer = new CharArrayBuffer(16); - Assertions.assertThrows(CharacterCodingException.class, () -> - inbuf.readLine(chbuffer, true)); + Assertions.assertThatThrownBy(() -> + inbuf.readLine(chbuffer, true)).isInstanceOf(CharacterCodingException.class); } @Test @@ -631,7 +635,7 @@ void testMalformedInputActionIgnore() throws Exception { } final CharArrayBuffer chbuffer = new CharArrayBuffer(16); inbuf.readLine(chbuffer, true); - Assertions.assertEquals("Grezi_zm", chbuffer.toString()); + Assertions.assertThat(chbuffer.toString()).isEqualTo("Grezi_zm"); } @Test @@ -648,7 +652,7 @@ void testMalformedInputActionReplace() throws Exception { } final CharArrayBuffer chbuffer = new CharArrayBuffer(16); inbuf.readLine(chbuffer, true); - Assertions.assertEquals("Gr\ufffdezi_z\ufffdm\ufffd", chbuffer.toString()); + Assertions.assertThat(chbuffer.toString()).isEqualTo("Gr\ufffdezi_z\ufffdm\ufffd"); } @Test @@ -660,8 +664,8 @@ void testUnmappableInputActionReport() { final SessionOutputBuffer outbuf = new SessionOutputBufferImpl(1024, 16, encoder); final CharArrayBuffer chbuffer = new CharArrayBuffer(16); chbuffer.append(s); - Assertions.assertThrows(CharacterCodingException.class, () -> - outbuf.writeLine(chbuffer)); + Assertions.assertThatThrownBy(() -> + outbuf.writeLine(chbuffer)).isInstanceOf(CharacterCodingException.class); } @Test @@ -679,7 +683,7 @@ void testUnmappableInputActionIgnore() throws Exception { outbuf.flush(channel); final String result = new String(baos.toByteArray(), StandardCharsets.US_ASCII); - Assertions.assertEquals("This text contains a circumflex !!!\r\n", result); + Assertions.assertThat(result).isEqualTo("This text contains a circumflex !!!\r\n"); } @Test @@ -697,7 +701,7 @@ void testUnmappableInputActionReplace() throws Exception { outbuf.flush(channel); final String result = new String(baos.toByteArray(), StandardCharsets.US_ASCII); - Assertions.assertEquals("This text contains a circumflex ? !!!\r\n", result); + Assertions.assertThat(result).isEqualTo("This text contains a circumflex ? !!!\r\n"); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/impl/routing/TestPathPatternMatcher.java b/httpcore5/src/test/java/org/apache/hc/core5/http/impl/routing/TestPathPatternMatcher.java index 0401ca969f..77793e15af 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/impl/routing/TestPathPatternMatcher.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/impl/routing/TestPathPatternMatcher.java @@ -27,7 +27,7 @@ package org.apache.hc.core5.http.impl.routing; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class TestPathPatternMatcher { @@ -36,27 +36,27 @@ class TestPathPatternMatcher { void testPathMatching() { final PathPatternMatcher matcher = PathPatternMatcher.INSTANCE; - Assertions.assertTrue(matcher.match("/*", "/foo/request")); - Assertions.assertTrue(matcher.match("/foo/*", "/foo/request")); - Assertions.assertTrue(matcher.match("/foo/req*", "/foo/request")); - Assertions.assertTrue(matcher.match("/foo/request", "/foo/request")); - Assertions.assertFalse(matcher.match("/foo/request", "/foo/requesta")); - Assertions.assertFalse(matcher.match("/foo/*", "foo/request")); - Assertions.assertFalse(matcher.match("/foo/*", "/bar/foo")); - Assertions.assertTrue(matcher.match("*/action.do", "/xxxxx/action.do")); - Assertions.assertTrue(matcher.match("*/foo/action.do", "/xxxxx/foo/action.do")); - Assertions.assertFalse(matcher.match("*.do", "foo.dont")); + Assertions.assertThat(matcher.match("/*", "/foo/request")).isTrue(); + Assertions.assertThat(matcher.match("/foo/*", "/foo/request")).isTrue(); + Assertions.assertThat(matcher.match("/foo/req*", "/foo/request")).isTrue(); + Assertions.assertThat(matcher.match("/foo/request", "/foo/request")).isTrue(); + Assertions.assertThat(matcher.match("/foo/request", "/foo/requesta")).isFalse(); + Assertions.assertThat(matcher.match("/foo/*", "foo/request")).isFalse(); + Assertions.assertThat(matcher.match("/foo/*", "/bar/foo")).isFalse(); + Assertions.assertThat(matcher.match("*/action.do", "/xxxxx/action.do")).isTrue(); + Assertions.assertThat(matcher.match("*/foo/action.do", "/xxxxx/foo/action.do")).isTrue(); + Assertions.assertThat(matcher.match("*.do", "foo.dont")).isFalse(); } @Test void testBetterMatch() { final PathPatternMatcher matcher = PathPatternMatcher.INSTANCE; - Assertions.assertTrue(matcher.isBetter("/a*", "/*")); - Assertions.assertTrue(matcher.isBetter("/a*", "*")); - Assertions.assertTrue(matcher.isBetter("/*", "*")); - Assertions.assertTrue(matcher.isBetter("/a/b*", "/a*")); - Assertions.assertTrue(matcher.isBetter("/a/*", "/a/b")); + Assertions.assertThat(matcher.isBetter("/a*", "/*")).isTrue(); + Assertions.assertThat(matcher.isBetter("/a*", "*")).isTrue(); + Assertions.assertThat(matcher.isBetter("/*", "*")).isTrue(); + Assertions.assertThat(matcher.isBetter("/a/b*", "/a*")).isTrue(); + Assertions.assertThat(matcher.isBetter("/a/*", "/a/b")).isTrue(); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/impl/routing/TestRequestRouter.java b/httpcore5/src/test/java/org/apache/hc/core5/http/impl/routing/TestRequestRouter.java index f3d3a5ca36..79233e69c8 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/impl/routing/TestRequestRouter.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/impl/routing/TestRequestRouter.java @@ -32,7 +32,7 @@ import org.apache.hc.core5.http.protocol.UriPatternType; import org.apache.hc.core5.http.support.BasicRequestBuilder; import org.apache.hc.core5.net.URIAuthority; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class TestRequestRouter { @@ -48,22 +48,22 @@ void testRequestRouting() throws Exception { .build(); final HttpCoreContext context = HttpCoreContext.create(); - Assertions.assertEquals(1L, requestRouter.resolve( - BasicRequestBuilder.get("http://someotherhost.somedomain/foo/blah").build(), context)); - Assertions.assertEquals(2L, requestRouter.resolve( - BasicRequestBuilder.get("http://somehost.somedomain/foo/blah").build(), context)); - Assertions.assertEquals(3L, requestRouter.resolve( - BasicRequestBuilder.get("http://somehost.somedomain/bar/blah").build(), context)); - Assertions.assertEquals(4L, requestRouter.resolve( - BasicRequestBuilder.get("http://somehost.somedomain/stuff").build(), context)); - Assertions.assertEquals(4L, requestRouter.resolve( - BasicRequestBuilder.get("http://somehost.somedomain/stuff?huh").build(), context)); - Assertions.assertEquals(0L, requestRouter.resolve( - BasicRequestBuilder.get("http://somehost.somedomain/stuffed").build(), context)); - Assertions.assertNull(requestRouter.resolve( - BasicRequestBuilder.get("http://someotherhost.somedomain/stuff").build(), context)); - Assertions.assertThrows(MisdirectedRequestException.class, () -> requestRouter.resolve( - BasicRequestBuilder.get("http://somehere.in.pampa/stuff").build(), context)); + Assertions.assertThat(requestRouter.resolve( + BasicRequestBuilder.get("http://someotherhost.somedomain/foo/blah").build(), context)).isEqualTo(1L); + Assertions.assertThat(requestRouter.resolve( + BasicRequestBuilder.get("http://somehost.somedomain/foo/blah").build(), context)).isEqualTo(2L); + Assertions.assertThat(requestRouter.resolve( + BasicRequestBuilder.get("http://somehost.somedomain/bar/blah").build(), context)).isEqualTo(3L); + Assertions.assertThat(requestRouter.resolve( + BasicRequestBuilder.get("http://somehost.somedomain/stuff").build(), context)).isEqualTo(4L); + Assertions.assertThat(requestRouter.resolve( + BasicRequestBuilder.get("http://somehost.somedomain/stuff?huh").build(), context)).isEqualTo(4L); + Assertions.assertThat(requestRouter.resolve( + BasicRequestBuilder.get("http://somehost.somedomain/stuffed").build(), context)).isEqualTo(0L); + Assertions.assertThat(requestRouter.resolve( + BasicRequestBuilder.get("http://someotherhost.somedomain/stuff").build(), context)).isNull(); + Assertions.assertThatThrownBy(() -> requestRouter.resolve( + BasicRequestBuilder.get("http://somehere.in.pampa/stuff").build(), context)).isInstanceOf(MisdirectedRequestException.class); } @Test @@ -76,16 +76,16 @@ void testDefaultAuthorityResolution() throws Exception { .build(); final HttpCoreContext context = HttpCoreContext.create(); - Assertions.assertEquals(0L, requestRouter.resolve( - BasicRequestBuilder.get("http://somehost/blah").build(), context)); - Assertions.assertEquals(10L, requestRouter.resolve( - BasicRequestBuilder.get("http://someotherhost:80/blah").build(), context)); - Assertions.assertEquals(1L, requestRouter.resolve( - BasicRequestBuilder.get("http://somehost:80/blah").build(), context)); - Assertions.assertEquals(2L, requestRouter.resolve( - BasicRequestBuilder.get("http://somehost:8080/blah").build(), context)); - Assertions.assertThrows(MisdirectedRequestException.class, () -> requestRouter.resolve( - BasicRequestBuilder.get("http://somehere.in.pampa/stuff").build(), context)); + Assertions.assertThat(requestRouter.resolve( + BasicRequestBuilder.get("http://somehost/blah").build(), context)).isEqualTo(0L); + Assertions.assertThat(requestRouter.resolve( + BasicRequestBuilder.get("http://someotherhost:80/blah").build(), context)).isEqualTo(10L); + Assertions.assertThat(requestRouter.resolve( + BasicRequestBuilder.get("http://somehost:80/blah").build(), context)).isEqualTo(1L); + Assertions.assertThat(requestRouter.resolve( + BasicRequestBuilder.get("http://somehost:8080/blah").build(), context)).isEqualTo(2L); + Assertions.assertThatThrownBy(() -> requestRouter.resolve( + BasicRequestBuilder.get("http://somehere.in.pampa/stuff").build(), context)).isInstanceOf(MisdirectedRequestException.class); } @Test @@ -97,18 +97,18 @@ void testCustomAuthorityResolution() throws Exception { .build(); final HttpCoreContext context = HttpCoreContext.create(); - Assertions.assertEquals(1L, requestRouter.resolve( - BasicRequestBuilder.get("http://somehost/blah").build(), context)); - Assertions.assertEquals(2L, requestRouter.resolve( - BasicRequestBuilder.get("http://someotherhost:80/blah").build(), context)); - Assertions.assertEquals(1L, requestRouter.resolve( - BasicRequestBuilder.get("http://somehost:80/blah").build(), context)); - Assertions.assertEquals(1L, requestRouter.resolve( - BasicRequestBuilder.get("http://somehost:8080/blah").build(), context)); - Assertions.assertEquals(1L, requestRouter.resolve( - BasicRequestBuilder.get("/blah").build(), context)); - Assertions.assertThrows(MisdirectedRequestException.class, () -> requestRouter.resolve( - BasicRequestBuilder.get("http://somehere.in.pampa/stuff").build(), context)); + Assertions.assertThat(requestRouter.resolve( + BasicRequestBuilder.get("http://somehost/blah").build(), context)).isEqualTo(1L); + Assertions.assertThat(requestRouter.resolve( + BasicRequestBuilder.get("http://someotherhost:80/blah").build(), context)).isEqualTo(2L); + Assertions.assertThat(requestRouter.resolve( + BasicRequestBuilder.get("http://somehost:80/blah").build(), context)).isEqualTo(1L); + Assertions.assertThat(requestRouter.resolve( + BasicRequestBuilder.get("http://somehost:8080/blah").build(), context)).isEqualTo(1L); + Assertions.assertThat(requestRouter.resolve( + BasicRequestBuilder.get("/blah").build(), context)).isEqualTo(1L); + Assertions.assertThatThrownBy(() -> requestRouter.resolve( + BasicRequestBuilder.get("http://somehere.in.pampa/stuff").build(), context)).isInstanceOf(MisdirectedRequestException.class); } @Test @@ -121,18 +121,18 @@ void testDownstreamResolution() throws Exception { .build(); final HttpCoreContext context = HttpCoreContext.create(); - Assertions.assertEquals(-1L, requestRouter.resolve( - BasicRequestBuilder.get("http://somehost/blah").build(), context)); - Assertions.assertEquals(10L, requestRouter.resolve( - BasicRequestBuilder.get("http://someotherhost:80/blah").build(), context)); - Assertions.assertEquals(1L, requestRouter.resolve( - BasicRequestBuilder.get("http://somehost:80/blah").build(), context)); - Assertions.assertEquals(-1L, requestRouter.resolve( - BasicRequestBuilder.get("http://somehost:8080/blah").build(), context)); - Assertions.assertEquals(-1L, requestRouter.resolve( - BasicRequestBuilder.get("/blah").build(), context)); - Assertions.assertEquals(-1L, requestRouter.resolve( - BasicRequestBuilder.get("http://somehere.in.pampa/stuff").build(), context)); + Assertions.assertThat(requestRouter.resolve( + BasicRequestBuilder.get("http://somehost/blah").build(), context)).isEqualTo(-1L); + Assertions.assertThat(requestRouter.resolve( + BasicRequestBuilder.get("http://someotherhost:80/blah").build(), context)).isEqualTo(10L); + Assertions.assertThat(requestRouter.resolve( + BasicRequestBuilder.get("http://somehost:80/blah").build(), context)).isEqualTo(1L); + Assertions.assertThat(requestRouter.resolve( + BasicRequestBuilder.get("http://somehost:8080/blah").build(), context)).isEqualTo(-1L); + Assertions.assertThat(requestRouter.resolve( + BasicRequestBuilder.get("/blah").build(), context)).isEqualTo(-1L); + Assertions.assertThat(requestRouter.resolve( + BasicRequestBuilder.get("http://somehere.in.pampa/stuff").build(), context)).isEqualTo(-1L); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/impl/routing/TestUriPathRouter.java b/httpcore5/src/test/java/org/apache/hc/core5/http/impl/routing/TestUriPathRouter.java index e7bff9a549..a97aa0e2ce 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/impl/routing/TestUriPathRouter.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/impl/routing/TestUriPathRouter.java @@ -31,7 +31,7 @@ import java.util.List; import java.util.regex.Pattern; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class TestUriPathRouter { @@ -47,13 +47,13 @@ void testBestMatchWildCardMatching() { new PathRoute<>("*.view", 4L), new PathRoute<>("*.form", 5L)); - Assertions.assertEquals(1L, matcher.apply("/one/request", routes)); - Assertions.assertEquals(2L, matcher.apply("/one/two/request", routes)); - Assertions.assertEquals(3L, matcher.apply("/one/two/three/request", routes)); - Assertions.assertEquals(0L, matcher.apply("default/request", routes)); - Assertions.assertEquals(4L, matcher.apply("that.view", routes)); - Assertions.assertEquals(5L, matcher.apply("that.form", routes)); - Assertions.assertEquals(0L, matcher.apply("whatever", routes)); + Assertions.assertThat(matcher.apply("/one/request", routes)).isEqualTo(1L); + Assertions.assertThat(matcher.apply("/one/two/request", routes)).isEqualTo(2L); + Assertions.assertThat(matcher.apply("/one/two/three/request", routes)).isEqualTo(3L); + Assertions.assertThat(matcher.apply("default/request", routes)).isEqualTo(0L); + Assertions.assertThat(matcher.apply("that.view", routes)).isEqualTo(4L); + Assertions.assertThat(matcher.apply("that.form", routes)).isEqualTo(5L); + Assertions.assertThat(matcher.apply("whatever", routes)).isEqualTo(0L); } @Test @@ -62,7 +62,7 @@ void testBestMatchWildCardMatchingSuffixPrefixPrecedence() { final List> routes = Arrays.asList( new PathRoute<>("/ma*", 1L), new PathRoute<>("*tch", 2L)); - Assertions.assertEquals(1L, matcher.apply("/match", routes)); + Assertions.assertThat(matcher.apply("/match", routes)).isEqualTo(1L); } @Test @@ -71,7 +71,7 @@ void testBestMatchWildCardMatchingExactMatch() { final List> routes = Arrays.asList( new PathRoute<>("exact", 1L), new PathRoute<>("*", 0L)); - Assertions.assertEquals(1L, matcher.apply("exact", routes)); + Assertions.assertThat(matcher.apply("exact", routes)).isEqualTo(1L); } @Test @@ -80,7 +80,7 @@ void testBestMatchWildCardMatchingNoMatch() { final List> routes = Arrays.asList( new PathRoute<>("/this/*", 1L), new PathRoute<>("/that/*", 2L)); - Assertions.assertNull(matcher.apply("huh?", routes)); + Assertions.assertThat(matcher.apply("huh?", routes)).isNull(); } @Test @@ -94,13 +94,13 @@ void testOrderedWildCardMatching1() { new PathRoute<>("*.view", 4L), new PathRoute<>("*.form", 5L)); - Assertions.assertEquals(0L, matcher.apply("/one/request", routes)); - Assertions.assertEquals(0L, matcher.apply("/one/two/request", routes)); - Assertions.assertEquals(0L, matcher.apply("/one/two/three/request", routes)); - Assertions.assertEquals(0L, matcher.apply("default/request", routes)); - Assertions.assertEquals(0L, matcher.apply("that.view", routes)); - Assertions.assertEquals(0L, matcher.apply("that.form", routes)); - Assertions.assertEquals(0L, matcher.apply("whatever", routes)); + Assertions.assertThat(matcher.apply("/one/request", routes)).isEqualTo(0L); + Assertions.assertThat(matcher.apply("/one/two/request", routes)).isEqualTo(0L); + Assertions.assertThat(matcher.apply("/one/two/three/request", routes)).isEqualTo(0L); + Assertions.assertThat(matcher.apply("default/request", routes)).isEqualTo(0L); + Assertions.assertThat(matcher.apply("that.view", routes)).isEqualTo(0L); + Assertions.assertThat(matcher.apply("that.form", routes)).isEqualTo(0L); + Assertions.assertThat(matcher.apply("whatever", routes)).isEqualTo(0L); final List> routes2 = Arrays.asList( new PathRoute<>("/one/two/three/*", 3L), @@ -110,13 +110,13 @@ void testOrderedWildCardMatching1() { new PathRoute<>("*.form", 5L), new PathRoute<>("*", 0L)); - Assertions.assertEquals(3L, matcher.apply("/one/two/three/request", routes2)); - Assertions.assertEquals(2L, matcher.apply("/one/two/request", routes2)); - Assertions.assertEquals(1L, matcher.apply("/one/request", routes2)); - Assertions.assertEquals(0L, matcher.apply("default/request", routes2)); - Assertions.assertEquals(4L, matcher.apply("that.view", routes2)); - Assertions.assertEquals(5L, matcher.apply("that.form", routes2)); - Assertions.assertEquals(0L, matcher.apply("whatever", routes2)); + Assertions.assertThat(matcher.apply("/one/two/three/request", routes2)).isEqualTo(3L); + Assertions.assertThat(matcher.apply("/one/two/request", routes2)).isEqualTo(2L); + Assertions.assertThat(matcher.apply("/one/request", routes2)).isEqualTo(1L); + Assertions.assertThat(matcher.apply("default/request", routes2)).isEqualTo(0L); + Assertions.assertThat(matcher.apply("that.view", routes2)).isEqualTo(4L); + Assertions.assertThat(matcher.apply("that.form", routes2)).isEqualTo(5L); + Assertions.assertThat(matcher.apply("whatever", routes2)).isEqualTo(0L); } @Test @@ -125,7 +125,7 @@ void testOrderedWildCardMatchingSuffixPrefixPrecedence() { final List> routes = Arrays.asList( new PathRoute<>("/ma*", 1L), new PathRoute<>("*tch", 2L)); - Assertions.assertEquals(1L, matcher.apply("/match", routes)); + Assertions.assertThat(matcher.apply("/match", routes)).isEqualTo(1L); } @Test @@ -134,7 +134,7 @@ void testOrderedStarAndExact() { final List> routes = Arrays.asList( new PathRoute<>("*", 0L), new PathRoute<>("exact", 1L)); - Assertions.assertEquals(0L, matcher.apply("exact", routes)); + Assertions.assertThat(matcher.apply("exact", routes)).isEqualTo(0L); } @Test @@ -143,7 +143,7 @@ void testOrderedExactAndStar() { final List> routes = Arrays.asList( new PathRoute<>("exact", 1L), new PathRoute<>("*", 0L)); - Assertions.assertEquals(1L, matcher.apply("exact", routes)); + Assertions.assertThat(matcher.apply("exact", routes)).isEqualTo(1L); } @Test @@ -157,12 +157,12 @@ void testRegExMatching() { new PathRoute<>(Pattern.compile(".*\\.form"), 5L), new PathRoute<>(Pattern.compile(".*"), 0L)); - Assertions.assertEquals(1L, matcher.apply("/one/request", routes)); - Assertions.assertEquals(2L, matcher.apply("/one/two/request", routes)); - Assertions.assertEquals(3L, matcher.apply("/one/two/three/request", routes)); - Assertions.assertEquals(4L, matcher.apply("/that.view", routes)); - Assertions.assertEquals(5L, matcher.apply("/that.form", routes)); - Assertions.assertEquals(0L, matcher.apply("/default/request", routes)); + Assertions.assertThat(matcher.apply("/one/request", routes)).isEqualTo(1L); + Assertions.assertThat(matcher.apply("/one/two/request", routes)).isEqualTo(2L); + Assertions.assertThat(matcher.apply("/one/two/three/request", routes)).isEqualTo(3L); + Assertions.assertThat(matcher.apply("/that.view", routes)).isEqualTo(4L); + Assertions.assertThat(matcher.apply("/that.form", routes)).isEqualTo(5L); + Assertions.assertThat(matcher.apply("/default/request", routes)).isEqualTo(0L); } @Test @@ -171,7 +171,7 @@ void testRegExWildCardMatchingSuffixPrefixPrecedence() { final List> routes = Arrays.asList( new PathRoute<>(Pattern.compile("/ma.*"), 1L), new PathRoute<>(Pattern.compile(".*tch"), 2L)); - Assertions.assertEquals(1L, matcher.apply("/match", routes)); + Assertions.assertThat(matcher.apply("/match", routes)).isEqualTo(1L); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/io/TestEofSensorInputStream.java b/httpcore5/src/test/java/org/apache/hc/core5/http/io/TestEofSensorInputStream.java index 322d3d2828..f94f7aead5 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/io/TestEofSensorInputStream.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/io/TestEofSensorInputStream.java @@ -29,7 +29,7 @@ import java.io.IOException; import java.io.InputStream; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.mockito.Mockito; @@ -54,8 +54,8 @@ void testClose() throws Exception { eofstream.close(); - Assertions.assertTrue(eofstream.isSelfClosed()); - Assertions.assertNull(eofstream.getWrappedStream()); + Assertions.assertThat(eofstream.isSelfClosed()).isTrue(); + Assertions.assertThat(eofstream.getWrappedStream()).isNull(); Mockito.verify(inStream, Mockito.times(1)).close(); Mockito.verify(eofwatcher).streamClosed(inStream); @@ -67,9 +67,11 @@ void testClose() throws Exception { void testCloseIOError() throws Exception { Mockito.when(eofwatcher.streamClosed(Mockito.any())).thenThrow(new IOException()); - Assertions.assertThrows(IOException.class, () -> eofstream.close()); - Assertions.assertTrue(eofstream.isSelfClosed()); - Assertions.assertNull(eofstream.getWrappedStream()); + Assertions.assertThatThrownBy(() -> + eofstream.close()) + .isInstanceOf(IOException.class); + Assertions.assertThat(eofstream.isSelfClosed()).isTrue(); + Assertions.assertThat(eofstream.getWrappedStream()).isNull(); Mockito.verify(eofwatcher).streamClosed(inStream); } @@ -80,8 +82,8 @@ void testAbortConnection() throws Exception { eofstream.abort(); - Assertions.assertTrue(eofstream.isSelfClosed()); - Assertions.assertNull(eofstream.getWrappedStream()); + Assertions.assertThat(eofstream.isSelfClosed()).isTrue(); + Assertions.assertThat(eofstream.getWrappedStream()).isNull(); Mockito.verify(inStream, Mockito.times(1)).close(); Mockito.verify(eofwatcher).streamAbort(inStream); @@ -93,9 +95,11 @@ void testAbortConnection() throws Exception { void testAbortConnectionIOError() throws Exception { Mockito.when(eofwatcher.streamAbort(Mockito.any())).thenThrow(new IOException()); - Assertions.assertThrows(IOException.class, () -> eofstream.abort()); - Assertions.assertTrue(eofstream.isSelfClosed()); - Assertions.assertNull(eofstream.getWrappedStream()); + Assertions.assertThatThrownBy(() -> + eofstream.abort()) + .isInstanceOf(IOException.class); + Assertions.assertThat(eofstream.isSelfClosed()).isTrue(); + Assertions.assertThat(eofstream.getWrappedStream()).isNull(); Mockito.verify(eofwatcher).streamAbort(inStream); } @@ -105,22 +109,22 @@ void testRead() throws Exception { Mockito.when(eofwatcher.eofDetected(Mockito.any())).thenReturn(Boolean.TRUE); Mockito.when(inStream.read()).thenReturn(0, -1); - Assertions.assertEquals(0, eofstream.read()); + Assertions.assertThat(eofstream.read()).isEqualTo(0); - Assertions.assertFalse(eofstream.isSelfClosed()); - Assertions.assertNotNull(eofstream.getWrappedStream()); + Assertions.assertThat(eofstream.isSelfClosed()).isFalse(); + Assertions.assertThat(eofstream.getWrappedStream()).isNotNull(); Mockito.verify(eofwatcher, Mockito.never()).eofDetected(inStream); - Assertions.assertEquals(-1, eofstream.read()); + Assertions.assertThat(eofstream.read()).isEqualTo(-1); - Assertions.assertFalse(eofstream.isSelfClosed()); - Assertions.assertNull(eofstream.getWrappedStream()); + Assertions.assertThat(eofstream.isSelfClosed()).isFalse(); + Assertions.assertThat(eofstream.getWrappedStream()).isNull(); Mockito.verify(inStream, Mockito.times(1)).close(); Mockito.verify(eofwatcher).eofDetected(inStream); - Assertions.assertEquals(-1, eofstream.read()); + Assertions.assertThat(eofstream.read()).isEqualTo(-1); } @Test @@ -128,9 +132,11 @@ void testReadIOError() throws Exception { Mockito.when(eofwatcher.eofDetected(Mockito.any())).thenReturn(Boolean.TRUE); Mockito.when(inStream.read()).thenThrow(new IOException()); - Assertions.assertThrows(IOException.class, () -> eofstream.read()); - Assertions.assertFalse(eofstream.isSelfClosed()); - Assertions.assertNull(eofstream.getWrappedStream()); + Assertions.assertThatThrownBy(() -> + eofstream.read()) + .isInstanceOf(IOException.class); + Assertions.assertThat(eofstream.isSelfClosed()).isFalse(); + Assertions.assertThat(eofstream.getWrappedStream()).isNull(); Mockito.verify(eofwatcher).streamAbort(inStream); } @@ -143,22 +149,22 @@ void testReadByteArray() throws Exception { final byte[] tmp = new byte[1]; - Assertions.assertEquals(1, eofstream.read(tmp)); + Assertions.assertThat(eofstream.read(tmp)).isEqualTo(1); - Assertions.assertFalse(eofstream.isSelfClosed()); - Assertions.assertNotNull(eofstream.getWrappedStream()); + Assertions.assertThat(eofstream.isSelfClosed()).isFalse(); + Assertions.assertThat(eofstream.getWrappedStream()).isNotNull(); Mockito.verify(eofwatcher, Mockito.never()).eofDetected(inStream); - Assertions.assertEquals(-1, eofstream.read(tmp)); + Assertions.assertThat(eofstream.read(tmp)).isEqualTo(-1); - Assertions.assertFalse(eofstream.isSelfClosed()); - Assertions.assertNull(eofstream.getWrappedStream()); + Assertions.assertThat(eofstream.isSelfClosed()).isFalse(); + Assertions.assertThat(eofstream.getWrappedStream()).isNull(); Mockito.verify(inStream, Mockito.times(1)).close(); Mockito.verify(eofwatcher).eofDetected(inStream); - Assertions.assertEquals(-1, eofstream.read(tmp)); + Assertions.assertThat(eofstream.read(tmp)).isEqualTo(-1); } @Test @@ -168,9 +174,11 @@ void testReadByteArrayIOError() throws Exception { .thenThrow(new IOException()); final byte[] tmp = new byte[1]; - Assertions.assertThrows(IOException.class, () -> eofstream.read(tmp)); - Assertions.assertFalse(eofstream.isSelfClosed()); - Assertions.assertNull(eofstream.getWrappedStream()); + Assertions.assertThatThrownBy(() -> + eofstream.read(tmp)) + .isInstanceOf(IOException.class); + Assertions.assertThat(eofstream.isSelfClosed()).isFalse(); + Assertions.assertThat(eofstream.getWrappedStream()).isNull(); Mockito.verify(eofwatcher).streamAbort(inStream); } @@ -181,9 +189,13 @@ void testReadAfterAbort() throws Exception { eofstream.abort(); - Assertions.assertThrows(IOException.class, () -> eofstream.read()); + Assertions.assertThatThrownBy(() -> + eofstream.read()) + .isInstanceOf(IOException.class); final byte[] tmp = new byte[1]; - Assertions.assertThrows(IOException.class, () -> eofstream.read(tmp)); + Assertions.assertThatThrownBy(() -> + eofstream.read(tmp)) + .isInstanceOf(IOException.class); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/io/entity/TestBasicHttpEntity.java b/httpcore5/src/test/java/org/apache/hc/core5/http/io/entity/TestBasicHttpEntity.java index 481a086af6..0004afbf26 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/io/entity/TestBasicHttpEntity.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/io/entity/TestBasicHttpEntity.java @@ -32,7 +32,7 @@ import java.nio.charset.StandardCharsets; import org.apache.hc.core5.http.ContentType; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; /** @@ -45,42 +45,64 @@ class TestBasicHttpEntity { void testBasics() { final byte[] bytes = "Message content".getBytes(StandardCharsets.US_ASCII); final BasicHttpEntity httpentity = new BasicHttpEntity(new ByteArrayInputStream(bytes), bytes.length, null); - Assertions.assertEquals(bytes.length, httpentity.getContentLength()); + Assertions.assertThat(httpentity.getContentLength()).isEqualTo(bytes.length); // always false - Assertions.assertFalse(httpentity.isRepeatable()); + Assertions.assertThat(httpentity.isRepeatable()).isFalse(); // always true - Assertions.assertTrue(httpentity.isStreaming()); + Assertions.assertThat(httpentity.isStreaming()).isTrue(); } @Test void testConstructorNullContent() { // BasicHttpEntity(InputStream, ContentType) - Assertions.assertThrows(NullPointerException.class, () -> new BasicHttpEntity(null, ContentType.APPLICATION_ATOM_XML)); - Assertions.assertThrows(NullPointerException.class, () -> new BasicHttpEntity(null, null)); + Assertions.assertThatThrownBy(() -> + new BasicHttpEntity(null, ContentType.APPLICATION_ATOM_XML)) + .isInstanceOf(NullPointerException.class); + Assertions.assertThatThrownBy(() -> + new BasicHttpEntity(null, null)) + .isInstanceOf(NullPointerException.class); // BasicHttpEntity(InputStream, ContentType, boolean) - Assertions.assertThrows(NullPointerException.class, () -> new BasicHttpEntity(null, ContentType.APPLICATION_ATOM_XML, false)); - Assertions.assertThrows(NullPointerException.class, () -> new BasicHttpEntity(null, null, false)); + Assertions.assertThatThrownBy(() -> + new BasicHttpEntity(null, ContentType.APPLICATION_ATOM_XML, false)) + .isInstanceOf(NullPointerException.class); + Assertions.assertThatThrownBy(() -> + new BasicHttpEntity(null, null, false)) + .isInstanceOf(NullPointerException.class); // BasicHttpEntity(InputStream, ContentType, String) - Assertions.assertThrows(NullPointerException.class, () -> new BasicHttpEntity(null, ContentType.APPLICATION_ATOM_XML, "")); - Assertions.assertThrows(NullPointerException.class, () -> new BasicHttpEntity(null, null, "")); + Assertions.assertThatThrownBy(() -> + new BasicHttpEntity(null, ContentType.APPLICATION_ATOM_XML, "")) + .isInstanceOf(NullPointerException.class); + Assertions.assertThatThrownBy(() -> + new BasicHttpEntity(null, null, "")) + .isInstanceOf(NullPointerException.class); // BasicHttpEntity(InputStream, long, ContentType) - Assertions.assertThrows(NullPointerException.class, () -> new BasicHttpEntity(null, 0, ContentType.APPLICATION_ATOM_XML)); - Assertions.assertThrows(NullPointerException.class, () -> new BasicHttpEntity(null, 0, null)); + Assertions.assertThatThrownBy(() -> + new BasicHttpEntity(null, 0, ContentType.APPLICATION_ATOM_XML)) + .isInstanceOf(NullPointerException.class); + Assertions.assertThatThrownBy(() -> + new BasicHttpEntity(null, 0, null)) + .isInstanceOf(NullPointerException.class); // BasicHttpEntity(InputStream, long, ContentType, String) - Assertions.assertThrows(NullPointerException.class, () -> new BasicHttpEntity(null, 0, ContentType.APPLICATION_ATOM_XML, "")); - Assertions.assertThrows(NullPointerException.class, () -> new BasicHttpEntity(null, 0, null, "")); + Assertions.assertThatThrownBy(() -> + new BasicHttpEntity(null, 0, ContentType.APPLICATION_ATOM_XML, "")) + .isInstanceOf(NullPointerException.class); + Assertions.assertThatThrownBy(() -> + new BasicHttpEntity(null, 0, null, "")) + .isInstanceOf(NullPointerException.class); // BasicHttpEntity(InputStream, long, ContentType, String, boolean) - Assertions.assertThrows(NullPointerException.class, () -> new BasicHttpEntity(null, 0, ContentType.APPLICATION_ATOM_XML, "", false)); - Assertions.assertThrows(NullPointerException.class, () -> new BasicHttpEntity(null, 0, null, "", false)); + Assertions.assertThatThrownBy(() -> + new BasicHttpEntity(null, 0, ContentType.APPLICATION_ATOM_XML, "", false)) + .isInstanceOf(NullPointerException.class); + Assertions.assertThatThrownBy(() -> + new BasicHttpEntity(null, 0, null, "", false)) + .isInstanceOf(NullPointerException.class); } @Test void testToString() throws Exception { try (final BasicHttpEntity httpentity = new BasicHttpEntity(EmptyInputStream.INSTANCE, 10, ContentType.parseLenient("blah"), "yada", true)) { - Assertions.assertEquals( - "[Entity-Class: BasicHttpEntity, Content-Type: blah, Content-Encoding: yada, chunked: true]", - httpentity.toString()); + Assertions.assertThat(httpentity.toString()).isEqualTo("[Entity-Class: BasicHttpEntity, Content-Type: blah, Content-Encoding: yada, chunked: true]"); } } @@ -90,16 +112,16 @@ void testWriteTo() throws Exception { final BasicHttpEntity httpentity = new BasicHttpEntity(new ByteArrayInputStream(bytes), bytes.length, ContentType.TEXT_PLAIN); // always false - Assertions.assertFalse(httpentity.isRepeatable()); + Assertions.assertThat(httpentity.isRepeatable()).isFalse(); // always true - Assertions.assertTrue(httpentity.isStreaming()); + Assertions.assertThat(httpentity.isStreaming()).isTrue(); final ByteArrayOutputStream out = new ByteArrayOutputStream(); httpentity.writeTo(out); final byte[] bytes2 = out.toByteArray(); - Assertions.assertNotNull(bytes2); - Assertions.assertEquals(bytes.length, bytes2.length); + Assertions.assertThat(bytes2).isNotNull(); + Assertions.assertThat(bytes2.length).isEqualTo(bytes.length); for (int i = 0; i < bytes.length; i++) { - Assertions.assertEquals(bytes[i], bytes2[i]); + Assertions.assertThat(bytes2[i]).isEqualTo(bytes[i]); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/io/entity/TestBufferedHttpEntity.java b/httpcore5/src/test/java/org/apache/hc/core5/http/io/entity/TestBufferedHttpEntity.java index dc6dd4d063..c5ec2625fe 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/io/entity/TestBufferedHttpEntity.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/io/entity/TestBufferedHttpEntity.java @@ -31,7 +31,7 @@ import java.io.ByteArrayOutputStream; import java.nio.charset.StandardCharsets; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; /** @@ -45,14 +45,14 @@ void testBufferingEntity() throws Exception { final byte[] bytes = "Message content".getBytes(StandardCharsets.US_ASCII); final BufferedHttpEntity entity = new BufferedHttpEntity( new InputStreamEntity(new ByteArrayInputStream(bytes), -1, null)); - Assertions.assertEquals(bytes.length, entity.getContentLength()); - Assertions.assertTrue(entity.isRepeatable()); - Assertions.assertFalse(entity.isChunked()); - Assertions.assertFalse(entity.isStreaming()); + Assertions.assertThat(entity.getContentLength()).isEqualTo(bytes.length); + Assertions.assertThat(entity.isRepeatable()).isTrue(); + Assertions.assertThat(entity.isChunked()).isFalse(); + Assertions.assertThat(entity.isStreaming()).isFalse(); // test if we can obtain contain multiple times - Assertions.assertNotNull(entity.getContent ()); - Assertions.assertNotNull(entity.getContent ()); + Assertions.assertThat(entity.getContent()).isNotNull(); + Assertions.assertThat(entity.getContent()).isNotNull(); } @Test @@ -60,20 +60,22 @@ void testWrappingEntity() throws Exception { final byte[] bytes = "Message content".getBytes(StandardCharsets.US_ASCII); final ByteArrayEntity httpentity = new ByteArrayEntity(bytes, null, true); try (final BufferedHttpEntity bufentity = new BufferedHttpEntity(httpentity)) { - Assertions.assertEquals(bytes.length, bufentity.getContentLength()); - Assertions.assertTrue(bufentity.isRepeatable()); - Assertions.assertTrue(bufentity.isChunked()); - Assertions.assertFalse(bufentity.isStreaming()); + Assertions.assertThat(bufentity.getContentLength()).isEqualTo(bytes.length); + Assertions.assertThat(bufentity.isRepeatable()).isTrue(); + Assertions.assertThat(bufentity.isChunked()).isTrue(); + Assertions.assertThat(bufentity.isStreaming()).isFalse(); // test if we can obtain contain multiple times - Assertions.assertNotNull(bufentity.getContent()); - Assertions.assertNotNull(bufentity.getContent()); + Assertions.assertThat(bufentity.getContent()).isNotNull(); + Assertions.assertThat(bufentity.getContent()).isNotNull(); } } @Test void testIllegalConstructor() { - Assertions.assertThrows(NullPointerException.class, () -> new BufferedHttpEntity(null)); + Assertions.assertThatThrownBy(() -> + new BufferedHttpEntity(null)) + .isInstanceOf(NullPointerException.class); } @Test @@ -85,22 +87,24 @@ void testWriteToBuffered() throws Exception { ByteArrayOutputStream out = new ByteArrayOutputStream(); bufentity.writeTo(out); byte[] bytes2 = out.toByteArray(); - Assertions.assertNotNull(bytes2); - Assertions.assertEquals(bytes.length, bytes2.length); + Assertions.assertThat(bytes2).isNotNull(); + Assertions.assertThat(bytes2.length).isEqualTo(bytes.length); for (int i = 0; i < bytes.length; i++) { - Assertions.assertEquals(bytes[i], bytes2[i]); + Assertions.assertThat(bytes2[i]).isEqualTo(bytes[i]); } out = new ByteArrayOutputStream(); bufentity.writeTo(out); bytes2 = out.toByteArray(); - Assertions.assertNotNull(bytes2); - Assertions.assertEquals(bytes.length, bytes2.length); + Assertions.assertThat(bytes2).isNotNull(); + Assertions.assertThat(bytes2.length).isEqualTo(bytes.length); for (int i = 0; i < bytes.length; i++) { - Assertions.assertEquals(bytes[i], bytes2[i]); + Assertions.assertThat(bytes2[i]).isEqualTo(bytes[i]); } - Assertions.assertThrows(NullPointerException.class, () -> bufentity.writeTo(null)); + Assertions.assertThatThrownBy(() -> + bufentity.writeTo(null)) + .isInstanceOf(NullPointerException.class); } } @@ -113,22 +117,24 @@ void testWriteToWrapped() throws Exception { ByteArrayOutputStream out = new ByteArrayOutputStream(); bufentity.writeTo(out); byte[] bytes2 = out.toByteArray(); - Assertions.assertNotNull(bytes2); - Assertions.assertEquals(bytes.length, bytes2.length); + Assertions.assertThat(bytes2).isNotNull(); + Assertions.assertThat(bytes2.length).isEqualTo(bytes.length); for (int i = 0; i < bytes.length; i++) { - Assertions.assertEquals(bytes[i], bytes2[i]); + Assertions.assertThat(bytes2[i]).isEqualTo(bytes[i]); } out = new ByteArrayOutputStream(); bufentity.writeTo(out); bytes2 = out.toByteArray(); - Assertions.assertNotNull(bytes2); - Assertions.assertEquals(bytes.length, bytes2.length); + Assertions.assertThat(bytes2).isNotNull(); + Assertions.assertThat(bytes2.length).isEqualTo(bytes.length); for (int i = 0; i < bytes.length; i++) { - Assertions.assertEquals(bytes[i], bytes2[i]); + Assertions.assertThat(bytes2[i]).isEqualTo(bytes[i]); } - Assertions.assertThrows(NullPointerException.class, () -> bufentity.writeTo(null)); + Assertions.assertThatThrownBy(() -> + bufentity.writeTo(null)) + .isInstanceOf(NullPointerException.class); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/io/entity/TestByteArrayEntity.java b/httpcore5/src/test/java/org/apache/hc/core5/http/io/entity/TestByteArrayEntity.java index 90e957f9fe..5a7d7d04b6 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/io/entity/TestByteArrayEntity.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/io/entity/TestByteArrayEntity.java @@ -30,7 +30,7 @@ import java.io.ByteArrayOutputStream; import java.nio.charset.StandardCharsets; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; /** @@ -44,10 +44,10 @@ void testBasics() throws Exception { final byte[] bytes = "Message content".getBytes(StandardCharsets.US_ASCII); try (final ByteArrayEntity entity = new ByteArrayEntity(bytes, null)) { - Assertions.assertEquals(bytes.length, entity.getContentLength()); - Assertions.assertNotNull(entity.getContent()); - Assertions.assertTrue(entity.isRepeatable()); - Assertions.assertFalse(entity.isStreaming()); + Assertions.assertThat(entity.getContentLength()).isEqualTo(bytes.length); + Assertions.assertThat(entity.getContent()).isNotNull(); + Assertions.assertThat(entity.isRepeatable()).isTrue(); + Assertions.assertThat(entity.isStreaming()).isFalse(); } } @@ -56,38 +56,38 @@ void testBasicOffLen() throws Exception { final byte[] bytes = "Message content".getBytes(StandardCharsets.US_ASCII); try (final ByteArrayEntity entity = new ByteArrayEntity(bytes, 8, 7, null)) { - Assertions.assertEquals(7, entity.getContentLength()); - Assertions.assertNotNull(entity.getContent()); - Assertions.assertTrue(entity.isRepeatable()); - Assertions.assertFalse(entity.isStreaming()); + Assertions.assertThat(entity.getContentLength()).isEqualTo(7); + Assertions.assertThat(entity.getContent()).isNotNull(); + Assertions.assertThat(entity.isRepeatable()).isTrue(); + Assertions.assertThat(entity.isStreaming()).isFalse(); } } @Test void testIllegalConstructorNullByteArray() { - Assertions.assertThrows(NullPointerException.class, () -> - new ByteArrayEntity(null, null)); + Assertions.assertThatThrownBy(() -> + new ByteArrayEntity(null, null)).isInstanceOf(NullPointerException.class); } @Test void testIllegalConstructorBadLen() { final byte[] bytes = "Message content".getBytes(StandardCharsets.US_ASCII); - Assertions.assertThrows(IllegalArgumentException.class, () -> - new ByteArrayEntity(bytes, 0, bytes.length + 1, null)); + Assertions.assertThatThrownBy(() -> + new ByteArrayEntity(bytes, 0, bytes.length + 1, null)).isInstanceOf(IllegalArgumentException.class); } @Test void testIllegalConstructorBadOff1() { final byte[] bytes = "Message content".getBytes(StandardCharsets.US_ASCII); - Assertions.assertThrows(IllegalArgumentException.class, () -> - new ByteArrayEntity(bytes, -1, bytes.length, null)); + Assertions.assertThatThrownBy(() -> + new ByteArrayEntity(bytes, -1, bytes.length, null)).isInstanceOf(IllegalArgumentException.class); } @Test void testIllegalConstructorBadOff2() { final byte[] bytes = "Message content".getBytes(StandardCharsets.US_ASCII); - Assertions.assertThrows(IllegalArgumentException.class, () -> - new ByteArrayEntity(bytes, bytes.length + 1, bytes.length, null)); + Assertions.assertThatThrownBy(() -> + new ByteArrayEntity(bytes, bytes.length + 1, bytes.length, null)).isInstanceOf(IllegalArgumentException.class); } @Test @@ -98,22 +98,24 @@ void testWriteTo() throws Exception { ByteArrayOutputStream out = new ByteArrayOutputStream(); entity.writeTo(out); byte[] bytes2 = out.toByteArray(); - Assertions.assertNotNull(bytes2); - Assertions.assertEquals(bytes.length, bytes2.length); + Assertions.assertThat(bytes2).isNotNull(); + Assertions.assertThat(bytes2.length).isEqualTo(bytes.length); for (int i = 0; i < bytes.length; i++) { - Assertions.assertEquals(bytes[i], bytes2[i]); + Assertions.assertThat(bytes2[i]).isEqualTo(bytes[i]); } out = new ByteArrayOutputStream(); entity.writeTo(out); bytes2 = out.toByteArray(); - Assertions.assertNotNull(bytes2); - Assertions.assertEquals(bytes.length, bytes2.length); + Assertions.assertThat(bytes2).isNotNull(); + Assertions.assertThat(bytes2.length).isEqualTo(bytes.length); for (int i = 0; i < bytes.length; i++) { - Assertions.assertEquals(bytes[i], bytes2[i]); + Assertions.assertThat(bytes2[i]).isEqualTo(bytes[i]); } - Assertions.assertThrows(NullPointerException.class, () -> entity.writeTo(null)); + Assertions.assertThatThrownBy(() -> + entity.writeTo(null)) + .isInstanceOf(NullPointerException.class); } } @@ -127,22 +129,24 @@ void testWriteToOffLen() throws Exception { ByteArrayOutputStream out = new ByteArrayOutputStream(); entity.writeTo(out); byte[] bytes2 = out.toByteArray(); - Assertions.assertNotNull(bytes2); - Assertions.assertEquals(len, bytes2.length); + Assertions.assertThat(bytes2).isNotNull(); + Assertions.assertThat(bytes2.length).isEqualTo(len); for (int i = 0; i < len; i++) { - Assertions.assertEquals(bytes[i + off], bytes2[i]); + Assertions.assertThat(bytes2[i]).isEqualTo(bytes[i + off]); } out = new ByteArrayOutputStream(); entity.writeTo(out); bytes2 = out.toByteArray(); - Assertions.assertNotNull(bytes2); - Assertions.assertEquals(len, bytes2.length); + Assertions.assertThat(bytes2).isNotNull(); + Assertions.assertThat(bytes2.length).isEqualTo(len); for (int i = 0; i < len; i++) { - Assertions.assertEquals(bytes[i + off], bytes2[i]); + Assertions.assertThat(bytes2[i]).isEqualTo(bytes[i + off]); } - Assertions.assertThrows(NullPointerException.class, () -> entity.writeTo(null)); + Assertions.assertThatThrownBy(() -> + entity.writeTo(null)) + .isInstanceOf(NullPointerException.class); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/io/entity/TestByteBufferEntity.java b/httpcore5/src/test/java/org/apache/hc/core5/http/io/entity/TestByteBufferEntity.java index 15c1ef4274..843545b0ac 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/io/entity/TestByteBufferEntity.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/io/entity/TestByteBufferEntity.java @@ -31,7 +31,7 @@ import java.nio.ByteBuffer; import java.nio.charset.StandardCharsets; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; /** @@ -45,10 +45,10 @@ void testBasics() throws Exception { final ByteBuffer bytes = ByteBuffer.wrap("Message content".getBytes(StandardCharsets.US_ASCII)); try (final ByteBufferEntity httpentity = new ByteBufferEntity(bytes, null)) { - Assertions.assertEquals(bytes.capacity(), httpentity.getContentLength()); - Assertions.assertNotNull(httpentity.getContent()); - Assertions.assertFalse(httpentity.isRepeatable()); - Assertions.assertFalse(httpentity.isStreaming()); + Assertions.assertThat(httpentity.getContentLength()).isEqualTo(bytes.capacity()); + Assertions.assertThat(httpentity.getContent()).isNotNull(); + Assertions.assertThat(httpentity.isRepeatable()).isFalse(); + Assertions.assertThat(httpentity.isStreaming()).isFalse(); } } @@ -61,24 +61,26 @@ void testWriteTo() throws Exception { ByteArrayOutputStream out = new ByteArrayOutputStream(); httpentity.writeTo(out); byte[] bytes2 = out.toByteArray(); - Assertions.assertNotNull(bytes2); - Assertions.assertEquals(bytes.capacity(), bytes2.length); + Assertions.assertThat(bytes2).isNotNull(); + Assertions.assertThat(bytes2.length).isEqualTo(bytes.capacity()); bytes.position(0); for (int i = 0; i < bytes2.length; i++) { - Assertions.assertEquals(bytes.get(i), bytes2[i]); + Assertions.assertThat(bytes2[i]).isEqualTo(bytes.get(i)); } out = new ByteArrayOutputStream(); httpentity.writeTo(out); bytes2 = out.toByteArray(); - Assertions.assertNotNull(bytes2); - Assertions.assertEquals(bytes.capacity(), bytes2.length); + Assertions.assertThat(bytes2).isNotNull(); + Assertions.assertThat(bytes2.length).isEqualTo(bytes.capacity()); bytes.position(0); for (int i = 0; i < bytes.capacity(); i++) { - Assertions.assertEquals(bytes.get(i), bytes2[i]); + Assertions.assertThat(bytes2[i]).isEqualTo(bytes.get(i)); } - Assertions.assertThrows(NullPointerException.class, () -> httpentity.writeTo(null)); + Assertions.assertThatThrownBy(() -> + httpentity.writeTo(null)) + .isInstanceOf(NullPointerException.class); } } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/io/entity/TestEntityUtils.java b/httpcore5/src/test/java/org/apache/hc/core5/http/io/entity/TestEntityUtils.java index 2c26d2b148..0e73718f9e 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/io/entity/TestEntityUtils.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/io/entity/TestEntityUtils.java @@ -44,7 +44,7 @@ import org.apache.hc.core5.http.ParseException; import org.apache.hc.core5.http.message.BasicNameValuePair; import org.apache.hc.core5.net.WWWFormCodec; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; /** @@ -55,8 +55,8 @@ class TestEntityUtils { @Test void testNullEntityToByteArray() { - Assertions.assertThrows(NullPointerException.class, () -> - EntityUtils.toByteArray(null, 1024)); + Assertions.assertThatThrownBy(() -> + EntityUtils.toByteArray(null, 1024)).isInstanceOf(NullPointerException.class); } @Test @@ -64,8 +64,8 @@ void testMaxIntContentToByteArray() { final byte[] content = "Message content".getBytes(StandardCharsets.US_ASCII); final BasicHttpEntity entity = new BasicHttpEntity(new ByteArrayInputStream(content), Integer.MAX_VALUE + 100L, ContentType.TEXT_PLAIN.withCharset(StandardCharsets.US_ASCII)); - Assertions.assertThrows(IllegalArgumentException.class, () -> - EntityUtils.toByteArray(entity, 1024)); + Assertions.assertThatThrownBy(() -> + EntityUtils.toByteArray(entity, 1024)).isInstanceOf(IllegalArgumentException.class); } @Test @@ -73,10 +73,10 @@ void testUnknownLengthContentToByteArray() throws Exception { final byte[] bytes = "Message content".getBytes(StandardCharsets.US_ASCII); final BasicHttpEntity entity = new BasicHttpEntity(new ByteArrayInputStream(bytes), -1, null); final byte[] bytes2 = EntityUtils.toByteArray(entity, 1024); - Assertions.assertNotNull(bytes2); - Assertions.assertEquals(bytes.length, bytes2.length); + Assertions.assertThat(bytes2).isNotNull(); + Assertions.assertThat(bytes2.length).isEqualTo(bytes.length); for (int i = 0; i < bytes.length; i++) { - Assertions.assertEquals(bytes[i], bytes2[i]); + Assertions.assertThat(bytes2[i]).isEqualTo(bytes[i]); } } @@ -85,16 +85,18 @@ void testKnownLengthContentToByteArray() throws Exception { final byte[] bytes = "Message content".getBytes(StandardCharsets.US_ASCII); final BasicHttpEntity entity = new BasicHttpEntity(new ByteArrayInputStream(bytes), bytes.length, null); final byte[] bytes2 = EntityUtils.toByteArray(entity, 1024); - Assertions.assertNotNull(bytes2); - Assertions.assertEquals(bytes.length, bytes2.length); + Assertions.assertThat(bytes2).isNotNull(); + Assertions.assertThat(bytes2.length).isEqualTo(bytes.length); for (int i = 0; i < bytes.length; i++) { - Assertions.assertEquals(bytes[i], bytes2[i]); + Assertions.assertThat(bytes2[i]).isEqualTo(bytes[i]); } } @Test void testNullEntityToString() { - Assertions.assertThrows(NullPointerException.class, () -> EntityUtils.toString(null, 1024)); + Assertions.assertThatThrownBy(() -> + EntityUtils.toString(null, 1024)) + .isInstanceOf(NullPointerException.class); } @Test @@ -102,8 +104,8 @@ void testMaxIntContentToString() { final byte[] content = "Message content".getBytes(StandardCharsets.US_ASCII); final BasicHttpEntity entity = new BasicHttpEntity(new ByteArrayInputStream(content), Integer.MAX_VALUE + 100L, ContentType.TEXT_PLAIN.withCharset(StandardCharsets.US_ASCII)); - Assertions.assertThrows(IllegalArgumentException.class, () -> - EntityUtils.toString(entity, "US-ASCII")); + Assertions.assertThatThrownBy(() -> + EntityUtils.toString(entity, "US-ASCII")).isInstanceOf(IllegalArgumentException.class); } @Test @@ -111,7 +113,7 @@ void testUnknownLengthContentToString() throws Exception { final byte[] bytes = "Message content".getBytes(StandardCharsets.US_ASCII); final BasicHttpEntity entity = new BasicHttpEntity(new ByteArrayInputStream(bytes), -1, null); final String s = EntityUtils.toString(entity, "US-ASCII"); - Assertions.assertEquals("Message content", s); + Assertions.assertThat(s).isEqualTo("Message content"); } @Test @@ -120,7 +122,7 @@ void testKnownLengthContentToString() throws Exception { final BasicHttpEntity entity = new BasicHttpEntity(new ByteArrayInputStream(bytes), bytes.length, ContentType.TEXT_PLAIN.withCharset(StandardCharsets.US_ASCII)); final String s = EntityUtils.toString(entity, StandardCharsets.US_ASCII, 1024); - Assertions.assertEquals("Message content", s); + Assertions.assertThat(s).isEqualTo("Message content"); } static final int SWISS_GERMAN_HELLO [] = { @@ -147,7 +149,7 @@ void testNoCharsetContentToString() { final String content = constructString(SWISS_GERMAN_HELLO); final byte[] bytes = content.getBytes(StandardCharsets.UTF_8); final BasicHttpEntity entity = new BasicHttpEntity(new ByteArrayInputStream(bytes), ContentType.TEXT_PLAIN); - Assertions.assertDoesNotThrow(() -> EntityUtils.toString(entity, 1024)); + Assertions.assertThatCode(() -> EntityUtils.toString(entity, 1024)).doesNotThrowAnyException(); } @Test @@ -157,7 +159,7 @@ void testDefaultCharsetContentToString() throws Exception { final BasicHttpEntity entity = new BasicHttpEntity(new ByteArrayInputStream(bytes), ContentType.parse("text/plain")); final String s = EntityUtils.toString(entity, Charset.forName("KOI8-R"), 1024); - Assertions.assertEquals(content, s); + Assertions.assertThat(s).isEqualTo(content); } @Test @@ -167,7 +169,7 @@ void testContentWithContentTypeToString() throws Exception { final BasicHttpEntity entity = new BasicHttpEntity(new ByteArrayInputStream(bytes), ContentType.TEXT_PLAIN.withCharset(StandardCharsets.UTF_8)); final String s = EntityUtils.toString(entity, "ISO-8859-1"); - Assertions.assertEquals(content, s); + Assertions.assertThat(s).isEqualTo(content); } @Test @@ -197,26 +199,26 @@ public void close() throws IOException { }; final String s = EntityUtils.toString(entity, "UTF-8"); - Assertions.assertEquals(content, s); + Assertions.assertThat(s).isEqualTo(content); } private static void assertNameValuePair ( final NameValuePair parameter, final String expectedName, final String expectedValue) { - Assertions.assertEquals(parameter.getName(), expectedName); - Assertions.assertEquals(parameter.getValue(), expectedValue); + Assertions.assertThat(expectedName).isEqualTo(parameter.getName()); + Assertions.assertThat(expectedValue).isEqualTo(parameter.getValue()); } @Test void testParseEntity() throws Exception { final StringEntity entity1 = new StringEntity("Name1=Value1", ContentType.APPLICATION_FORM_URLENCODED); final List result = EntityUtils.parse(entity1, 1024); - Assertions.assertEquals(1, result.size()); + Assertions.assertThat(result.size()).isEqualTo(1); assertNameValuePair(result.get(0), "Name1", "Value1"); final StringEntity entity2 = new StringEntity("Name1=Value1", ContentType.parse("text/test")); - Assertions.assertTrue(EntityUtils.parse(entity2, 1024).isEmpty()); + Assertions.assertThat(EntityUtils.parse(entity2, 1024).isEmpty()).isTrue(); } @Test @@ -229,12 +231,12 @@ void testParseUTF8Entity() throws Exception { final String s = WWWFormCodec.format(parameters, StandardCharsets.UTF_8); - Assertions.assertEquals("russian=%D0%92%D1%81%D0%B5%D0%BC_%D0%BF%D1%80%D0%B8%D0%B2%D0%B5%D1%82" + - "&swiss=Gr%C3%BCezi_z%C3%A4m%C3%A4", s); + Assertions.assertThat(s).isEqualTo("russian=%D0%92%D1%81%D0%B5%D0%BC_%D0%BF%D1%80%D0%B8%D0%B2%D0%B5%D1%82" + + "&swiss=Gr%C3%BCezi_z%C3%A4m%C3%A4"); final StringEntity entity = new StringEntity(s, ContentType.APPLICATION_FORM_URLENCODED.withCharset(StandardCharsets.UTF_8)); final List result = EntityUtils.parse(entity, 1024); - Assertions.assertEquals(2, result.size()); + Assertions.assertThat(result.size()).isEqualTo(2); assertNameValuePair(result.get(0), "russian", ru_hello); assertNameValuePair(result.get(1), "swiss", ch_hello); } @@ -253,10 +255,10 @@ void testByteArrayMaxResultLength() throws IOException { final byte[] bytes = EntityUtils.toByteArray(entity, tc.getKey()); final byte[] expectedBytes = tc.getValue(); - Assertions.assertNotNull(bytes); - Assertions.assertEquals(expectedBytes.length, bytes.length); + Assertions.assertThat(bytes).isNotNull(); + Assertions.assertThat(bytes.length).isEqualTo(expectedBytes.length); for (int i = 0; i < expectedBytes.length; i++) { - Assertions.assertEquals(expectedBytes[i], bytes[i]); + Assertions.assertThat(bytes[i]).isEqualTo(expectedBytes[i]); } } } @@ -277,10 +279,10 @@ void testByteArrayMaxResultLengthWithNoContentLength() throws IOException { final byte[] bytes = EntityUtils.toByteArray(entity, tc.getKey()); final byte[] expectedBytes = tc.getValue(); - Assertions.assertNotNull(bytes); - Assertions.assertEquals(expectedBytes.length, bytes.length); + Assertions.assertThat(bytes).isNotNull(); + Assertions.assertThat(bytes.length).isEqualTo(expectedBytes.length); for (int i = 0; i < expectedBytes.length; i++) { - Assertions.assertEquals(expectedBytes[i], bytes[i]); + Assertions.assertThat(bytes[i]).isEqualTo(expectedBytes[i]); } } } @@ -298,8 +300,8 @@ void testStringMaxResultLength() throws IOException, ParseException { final BasicHttpEntity entity = new BasicHttpEntity(new ByteArrayInputStream(allBytes), allBytes.length, null); final String string = EntityUtils.toString(entity, StandardCharsets.US_ASCII, tc.getKey()); final String expectedString = tc.getValue(); - Assertions.assertNotNull(string); - Assertions.assertEquals(expectedString, string); + Assertions.assertThat(string).isNotNull(); + Assertions.assertThat(string).isEqualTo(expectedString); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/io/entity/TestFileEntity.java b/httpcore5/src/test/java/org/apache/hc/core5/http/io/entity/TestFileEntity.java index dfe2198e2f..98c8ead720 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/io/entity/TestFileEntity.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/io/entity/TestFileEntity.java @@ -33,7 +33,7 @@ import java.io.InputStream; import org.apache.hc.core5.http.ContentType; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; /** @@ -48,19 +48,21 @@ void testBasics() throws Exception { tmpfile.deleteOnExit(); try (final FileEntity httpentity = new FileEntity(tmpfile, ContentType.TEXT_PLAIN)) { - Assertions.assertEquals(tmpfile.length(), httpentity.getContentLength()); + Assertions.assertThat(httpentity.getContentLength()).isEqualTo(tmpfile.length()); try (InputStream content = httpentity.getContent()) { - Assertions.assertNotNull(content); + Assertions.assertThat(content).isNotNull(); } - Assertions.assertTrue(httpentity.isRepeatable()); - Assertions.assertFalse(httpentity.isStreaming()); - Assertions.assertTrue(tmpfile.delete(), "Failed to delete " + tmpfile); + Assertions.assertThat(httpentity.isRepeatable()).isTrue(); + Assertions.assertThat(httpentity.isStreaming()).isFalse(); + Assertions.assertThat(tmpfile.delete()).withFailMessage("Failed to delete " + tmpfile).isTrue(); } } @Test void testNullConstructor() { - Assertions.assertThrows(NullPointerException.class, () -> new FileEntity(null, ContentType.TEXT_PLAIN)); + Assertions.assertThatThrownBy(() -> + new FileEntity(null, ContentType.TEXT_PLAIN)) + .isInstanceOf(NullPointerException.class); } @Test @@ -80,14 +82,16 @@ void testWriteTo() throws Exception { final ByteArrayOutputStream out = new ByteArrayOutputStream(); httpentity.writeTo(out); final byte[] bytes = out.toByteArray(); - Assertions.assertNotNull(bytes); - Assertions.assertEquals(tmpfile.length(), bytes.length); + Assertions.assertThat(bytes).isNotNull(); + Assertions.assertThat(bytes.length).isEqualTo(tmpfile.length()); for (int i = 0; i < 4; i++) { - Assertions.assertEquals(i, bytes[i]); + Assertions.assertThat(bytes[i]).isEqualTo((byte) i); } - Assertions.assertTrue(tmpfile.delete(), "Failed to delete: " + tmpfile); + Assertions.assertThat(tmpfile.delete()).withFailMessage("Failed to delete: " + tmpfile).isTrue(); - Assertions.assertThrows(NullPointerException.class, () -> httpentity.writeTo(null)); + Assertions.assertThatThrownBy(() -> + httpentity.writeTo(null)) + .isInstanceOf(NullPointerException.class); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/io/entity/TestHttpEntityWrapper.java b/httpcore5/src/test/java/org/apache/hc/core5/http/io/entity/TestHttpEntityWrapper.java index 1b80ad3fad..d5da6dd707 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/io/entity/TestHttpEntityWrapper.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/io/entity/TestHttpEntityWrapper.java @@ -31,7 +31,7 @@ import java.nio.charset.StandardCharsets; import org.apache.hc.core5.http.ContentType; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; /** @@ -45,19 +45,21 @@ void testBasics() throws Exception { final StringEntity entity = new StringEntity("Message content", ContentType.TEXT_PLAIN, "blah", false); try (final HttpEntityWrapper wrapped = new HttpEntityWrapper(entity)) { - Assertions.assertEquals(entity.getContentLength(), wrapped.getContentLength()); - Assertions.assertEquals(entity.getContentType(), wrapped.getContentType()); - Assertions.assertEquals(entity.getContentEncoding(), wrapped.getContentEncoding()); - Assertions.assertEquals(entity.isChunked(), wrapped.isChunked()); - Assertions.assertEquals(entity.isRepeatable(), wrapped.isRepeatable()); - Assertions.assertEquals(entity.isStreaming(), wrapped.isStreaming()); - Assertions.assertNotNull(wrapped.getContent()); + Assertions.assertThat(wrapped.getContentLength()).isEqualTo(entity.getContentLength()); + Assertions.assertThat(wrapped.getContentType()).isEqualTo(entity.getContentType()); + Assertions.assertThat(wrapped.getContentEncoding()).isEqualTo(entity.getContentEncoding()); + Assertions.assertThat(wrapped.isChunked()).isEqualTo(entity.isChunked()); + Assertions.assertThat(wrapped.isRepeatable()).isEqualTo(entity.isRepeatable()); + Assertions.assertThat(wrapped.isStreaming()).isEqualTo(entity.isStreaming()); + Assertions.assertThat(wrapped.getContent()).isNotNull(); } } @Test void testIllegalConstructor() { - Assertions.assertThrows(NullPointerException.class, () -> new HttpEntityWrapper(null)); + Assertions.assertThatThrownBy(() -> + new HttpEntityWrapper(null)) + .isInstanceOf(NullPointerException.class); } @Test @@ -70,22 +72,24 @@ void testWriteTo() throws Exception { ByteArrayOutputStream out = new ByteArrayOutputStream(); wrapped.writeTo(out); byte[] bytes2 = out.toByteArray(); - Assertions.assertNotNull(bytes2); - Assertions.assertEquals(bytes.length, bytes2.length); + Assertions.assertThat(bytes2).isNotNull(); + Assertions.assertThat(bytes2.length).isEqualTo(bytes.length); for (int i = 0; i < bytes.length; i++) { - Assertions.assertEquals(bytes[i], bytes2[i]); + Assertions.assertThat(bytes2[i]).isEqualTo(bytes[i]); } out = new ByteArrayOutputStream(); wrapped.writeTo(out); bytes2 = out.toByteArray(); - Assertions.assertNotNull(bytes2); - Assertions.assertEquals(bytes.length, bytes2.length); + Assertions.assertThat(bytes2).isNotNull(); + Assertions.assertThat(bytes2.length).isEqualTo(bytes.length); for (int i = 0; i < bytes.length; i++) { - Assertions.assertEquals(bytes[i], bytes2[i]); + Assertions.assertThat(bytes2[i]).isEqualTo(bytes[i]); } - Assertions.assertThrows(NullPointerException.class, () -> wrapped.writeTo(null)); + Assertions.assertThatThrownBy(() -> + wrapped.writeTo(null)) + .isInstanceOf(NullPointerException.class); } } @@ -95,7 +99,7 @@ void testConsumeContent() throws Exception { final StringEntity entity = new StringEntity(s); final HttpEntityWrapper wrapped = new HttpEntityWrapper(entity); EntityUtils.consume(wrapped); - Assertions.assertDoesNotThrow(() -> EntityUtils.consume(wrapped)); + Assertions.assertThatCode(() -> EntityUtils.consume(wrapped)).doesNotThrowAnyException(); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/io/entity/TestInputStreamEntity.java b/httpcore5/src/test/java/org/apache/hc/core5/http/io/entity/TestInputStreamEntity.java index b9a973230a..89e5eb062b 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/io/entity/TestInputStreamEntity.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/io/entity/TestInputStreamEntity.java @@ -33,7 +33,7 @@ import java.nio.charset.StandardCharsets; import org.apache.hc.core5.http.ContentType; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; /** @@ -47,22 +47,22 @@ void testBasics() throws Exception { final byte[] bytes = "Message content".getBytes(StandardCharsets.US_ASCII); final InputStreamEntity entity = new InputStreamEntity(new ByteArrayInputStream(bytes), bytes.length, null); - Assertions.assertEquals(bytes.length, entity.getContentLength()); - Assertions.assertNotNull(entity.getContent()); - Assertions.assertFalse(entity.isRepeatable()); - Assertions.assertTrue(entity.isStreaming()); + Assertions.assertThat(entity.getContentLength()).isEqualTo(bytes.length); + Assertions.assertThat(entity.getContent()).isNotNull(); + Assertions.assertThat(entity.isRepeatable()).isFalse(); + Assertions.assertThat(entity.isStreaming()).isTrue(); } @Test void testNullConstructor() { - Assertions.assertThrows(NullPointerException.class, () -> - new InputStreamEntity(null, 0, null)); + Assertions.assertThatThrownBy(() -> + new InputStreamEntity(null, 0, null)).isInstanceOf(NullPointerException.class); } @Test void testUnknownLengthConstructor() throws Exception { try (final InputStreamEntity entity = new InputStreamEntity(EmptyInputStream.INSTANCE, null)) { - Assertions.assertEquals(-1, entity.getContentLength()); + Assertions.assertThat(entity.getContentLength()).isEqualTo(-1); } } @@ -76,11 +76,11 @@ void testWriteTo() throws Exception { final ByteArrayOutputStream out = new ByteArrayOutputStream(); entity.writeTo(out); final byte[] writtenBytes = out.toByteArray(); - Assertions.assertNotNull(writtenBytes); - Assertions.assertEquals(bytes.length, writtenBytes.length); + Assertions.assertThat(writtenBytes).isNotNull(); + Assertions.assertThat(writtenBytes.length).isEqualTo(bytes.length); final String s = new String(writtenBytes, StandardCharsets.US_ASCII.name()); - Assertions.assertEquals(message, s); + Assertions.assertThat(s).isEqualTo(message); } } @@ -96,11 +96,11 @@ void testWriteToPartialContent() throws Exception { final ByteArrayOutputStream out = new ByteArrayOutputStream(); entity.writeTo(out); final byte[] writtenBytes = out.toByteArray(); - Assertions.assertNotNull(writtenBytes); - Assertions.assertEquals(contentLength, writtenBytes.length); + Assertions.assertThat(writtenBytes).isNotNull(); + Assertions.assertThat(writtenBytes.length).isEqualTo(contentLength); final String s = new String(writtenBytes, StandardCharsets.US_ASCII.name()); - Assertions.assertEquals(message.substring(0, contentLength), s); + Assertions.assertThat(s).isEqualTo(message.substring(0, contentLength)); } } @@ -114,17 +114,19 @@ void testWriteToUnknownLength() throws Exception { final ByteArrayOutputStream out = new ByteArrayOutputStream(); entity.writeTo(out); final byte[] writtenBytes = out.toByteArray(); - Assertions.assertNotNull(writtenBytes); - Assertions.assertEquals(bytes.length, writtenBytes.length); + Assertions.assertThat(writtenBytes).isNotNull(); + Assertions.assertThat(writtenBytes.length).isEqualTo(bytes.length); final String s = new String(writtenBytes, StandardCharsets.US_ASCII.name()); - Assertions.assertEquals(message, s); + Assertions.assertThat(s).isEqualTo(message); } @Test void testWriteToNull() throws Exception { try (final InputStreamEntity entity = new InputStreamEntity(EmptyInputStream.INSTANCE, 0, null)) { - Assertions.assertThrows(NullPointerException.class, () -> entity.writeTo(null)); + Assertions.assertThatThrownBy(() -> + entity.writeTo(null)) + .isInstanceOf(NullPointerException.class); } } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/io/entity/TestNullEntity.java b/httpcore5/src/test/java/org/apache/hc/core5/http/io/entity/TestNullEntity.java index 3a068c670b..fe687d571f 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/io/entity/TestNullEntity.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/io/entity/TestNullEntity.java @@ -27,47 +27,44 @@ package org.apache.hc.core5.http.io.entity; -import org.junit.jupiter.api.Test; - import java.io.ByteArrayOutputStream; import java.io.IOException; import java.io.InputStream; import java.util.Collections; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.junit.jupiter.api.Assertions.assertNull; +import org.assertj.core.api.Assertions; +import org.junit.jupiter.api.Test; class TestNullEntity { @Test void testLength() { - assertEquals(0, NullEntity.INSTANCE.getContentLength()); + Assertions.assertThat(NullEntity.INSTANCE.getContentLength()).isEqualTo(0); } @Test void testContentType() { - assertNull(NullEntity.INSTANCE.getContentType()); + Assertions.assertThat(NullEntity.INSTANCE.getContentType()).isNull(); } @Test void testContentEncoding() { - assertNull(NullEntity.INSTANCE.getContentEncoding()); + Assertions.assertThat(NullEntity.INSTANCE.getContentEncoding()).isNull(); } @Test void testTrailerNames() { - assertEquals(Collections.emptySet(), NullEntity.INSTANCE.getTrailerNames()); + Assertions.assertThat(NullEntity.INSTANCE.getTrailerNames()).isEqualTo(Collections.emptySet()); } @Test void testContentStream() throws IOException { try (InputStream content = NullEntity.INSTANCE.getContent()) { - assertEquals(-1, content.read()); + Assertions.assertThat(content.read()).isEqualTo(-1); } // Closing the resource should have no impact try (InputStream content = NullEntity.INSTANCE.getContent()) { - assertEquals(-1, content.read()); + Assertions.assertThat(content.read()).isEqualTo(-1); } } @@ -75,16 +72,16 @@ void testContentStream() throws IOException { void testWriteTo() throws IOException { final ByteArrayOutputStream baos = new ByteArrayOutputStream(); NullEntity.INSTANCE.writeTo(baos); - assertEquals(0, baos.size()); + Assertions.assertThat(baos.size()).isEqualTo(0); } @Test void testIsStreaming() { - assertFalse(NullEntity.INSTANCE.isStreaming()); + Assertions.assertThat(NullEntity.INSTANCE.isStreaming()).isFalse(); } @Test void testIsChunked() { - assertFalse(NullEntity.INSTANCE.isChunked()); + Assertions.assertThat(NullEntity.INSTANCE.isChunked()).isFalse(); } } \ No newline at end of file diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/io/entity/TestPathEntity.java b/httpcore5/src/test/java/org/apache/hc/core5/http/io/entity/TestPathEntity.java index 2facca2104..7387d9b162 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/io/entity/TestPathEntity.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/io/entity/TestPathEntity.java @@ -34,7 +34,7 @@ import java.nio.file.Path; import org.apache.hc.core5.http.ContentType; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; /** @@ -48,20 +48,22 @@ void testBasics() throws Exception { // Mark the file for deletion on VM exit if an assertion fails. tmpPath.toFile().deleteOnExit(); try (final PathEntity httpEntity = new PathEntity(tmpPath, ContentType.TEXT_PLAIN)) { - Assertions.assertEquals(Files.size(tmpPath), httpEntity.getContentLength()); + Assertions.assertThat(httpEntity.getContentLength()).isEqualTo(Files.size(tmpPath)); try (final InputStream content = httpEntity.getContent()) { - Assertions.assertNotNull(content); + Assertions.assertThat(content).isNotNull(); } - Assertions.assertTrue(httpEntity.isRepeatable()); - Assertions.assertFalse(httpEntity.isStreaming()); + Assertions.assertThat(httpEntity.isRepeatable()).isTrue(); + Assertions.assertThat(httpEntity.isStreaming()).isFalse(); // If we can't delete the file now, then the PathEntity or test is hanging on to a file handle. - Assertions.assertTrue(Files.deleteIfExists(tmpPath), "Failed to delete " + tmpPath); + Assertions.assertThat(Files.deleteIfExists(tmpPath)).withFailMessage("Failed to delete " + tmpPath).isTrue(); } } @Test void testNullConstructor() { - Assertions.assertThrows(NullPointerException.class, () -> new PathEntity(null, ContentType.TEXT_PLAIN)); + Assertions.assertThatThrownBy(() -> + new PathEntity(null, ContentType.TEXT_PLAIN)) + .isInstanceOf(NullPointerException.class); } @Test @@ -80,14 +82,16 @@ void testWriteTo() throws Exception { final ByteArrayOutputStream out = new ByteArrayOutputStream(); httpEntity.writeTo(out); final byte[] bytes = out.toByteArray(); - Assertions.assertNotNull(bytes); - Assertions.assertEquals(Files.size(tmpPath), bytes.length); + Assertions.assertThat(bytes).isNotNull(); + Assertions.assertThat(bytes.length).isEqualTo(Files.size(tmpPath)); for (int i = 0; i < 4; i++) { - Assertions.assertEquals(i, bytes[i]); + Assertions.assertThat(bytes[i]).isEqualTo((byte) i); } // If we can't delete the file now, then the PathEntity or test is hanging on to a file handle - Assertions.assertTrue(Files.deleteIfExists(tmpPath), "Failed to delete " + tmpPath); - Assertions.assertThrows(NullPointerException.class, () -> httpEntity.writeTo(null)); + Assertions.assertThat(Files.deleteIfExists(tmpPath)).withFailMessage("Failed to delete " + tmpPath).isTrue(); + Assertions.assertThatThrownBy(() -> + httpEntity.writeTo(null)) + .isInstanceOf(NullPointerException.class); } } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/io/entity/TestSerializableEntity.java b/httpcore5/src/test/java/org/apache/hc/core5/http/io/entity/TestSerializableEntity.java index 5e73fc02a6..d039030fc5 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/io/entity/TestSerializableEntity.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/io/entity/TestSerializableEntity.java @@ -33,7 +33,7 @@ import java.io.ObjectOutputStream; import java.io.Serializable; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class TestSerializableEntity { @@ -61,10 +61,10 @@ void testBasics() throws Exception { try (final SerializableEntity httpentity = new SerializableEntity(serializableObj, null)) { - Assertions.assertEquals(-1, httpentity.getContentLength()); - Assertions.assertNotNull(httpentity.getContent()); - Assertions.assertTrue(httpentity.isRepeatable()); - Assertions.assertFalse(httpentity.isStreaming()); + Assertions.assertThat(httpentity.getContentLength()).isEqualTo(-1); + Assertions.assertThat(httpentity.getContent()).isNotNull(); + Assertions.assertThat(httpentity.isRepeatable()).isTrue(); + Assertions.assertThat(httpentity.isStreaming()).isFalse(); } } @@ -76,13 +76,15 @@ void testWriteTo() throws Exception { final ByteArrayOutputStream out = new ByteArrayOutputStream(); httpentity.writeTo(out); final byte[] bytes = out.toByteArray(); - Assertions.assertNotNull(bytes); + Assertions.assertThat(bytes).isNotNull(); final ObjectInputStream oin = new ObjectInputStream(new ByteArrayInputStream(bytes)); final SerializableObject serIn = (SerializableObject) oin.readObject(); - Assertions.assertEquals(4, serIn.intValue); - Assertions.assertEquals("Hello", serIn.stringValue); + Assertions.assertThat(serIn.intValue).isEqualTo(4); + Assertions.assertThat(serIn.stringValue).isEqualTo("Hello"); - Assertions.assertThrows(NullPointerException.class, () -> httpentity.writeTo(null)); + Assertions.assertThatThrownBy(() -> + httpentity.writeTo(null)) + .isInstanceOf(NullPointerException.class); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/io/entity/TestStringEntity.java b/httpcore5/src/test/java/org/apache/hc/core5/http/io/entity/TestStringEntity.java index 665945ebce..3684b917f3 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/io/entity/TestStringEntity.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/io/entity/TestStringEntity.java @@ -32,7 +32,7 @@ import java.nio.charset.StandardCharsets; import org.apache.hc.core5.http.ContentType; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; /** @@ -46,27 +46,29 @@ void testBasics() throws Exception { try (final StringEntity httpentity = new StringEntity(s, ContentType.TEXT_PLAIN)) { final byte[] bytes = s.getBytes(StandardCharsets.US_ASCII); - Assertions.assertEquals(bytes.length, httpentity.getContentLength()); - Assertions.assertNotNull(httpentity.getContent()); - Assertions.assertTrue(httpentity.isRepeatable()); - Assertions.assertFalse(httpentity.isStreaming()); + Assertions.assertThat(httpentity.getContentLength()).isEqualTo(bytes.length); + Assertions.assertThat(httpentity.getContent()).isNotNull(); + Assertions.assertThat(httpentity.isRepeatable()).isTrue(); + Assertions.assertThat(httpentity.isStreaming()).isFalse(); } } @Test void testNullConstructor() { - Assertions.assertThrows(NullPointerException.class, () -> new StringEntity(null)); + Assertions.assertThatThrownBy(() -> + new StringEntity(null)) + .isInstanceOf(NullPointerException.class); } @Test void testDefaultContent() throws Exception { final String s = "Message content"; StringEntity httpentity = new StringEntity(s, ContentType.create("text/csv", "ANSI_X3.4-1968")); - Assertions.assertEquals("text/csv; charset=US-ASCII", httpentity.getContentType()); + Assertions.assertThat(httpentity.getContentType()).isEqualTo("text/csv; charset=US-ASCII"); httpentity = new StringEntity(s, StandardCharsets.US_ASCII); - Assertions.assertEquals("text/plain; charset=US-ASCII", httpentity.getContentType()); + Assertions.assertThat(httpentity.getContentType()).isEqualTo("text/plain; charset=US-ASCII"); httpentity = new StringEntity(s); - Assertions.assertEquals("text/plain; charset=UTF-8", httpentity.getContentType()); + Assertions.assertThat(httpentity.getContentType()).isEqualTo("text/plain; charset=UTF-8"); } private static String constructString(final int [] unicodeChars) { @@ -87,13 +89,13 @@ private static String constructString(final int [] unicodeChars) { void testNullCharset() throws Exception { final String s = constructString(SWISS_GERMAN_HELLO); StringEntity httpentity = new StringEntity(s, ContentType.create("text/plain", (Charset) null)); - Assertions.assertNotNull(httpentity.getContentType()); - Assertions.assertEquals("text/plain", httpentity.getContentType()); - Assertions.assertEquals(s, EntityUtils.toString(httpentity, 1024)); + Assertions.assertThat(httpentity.getContentType()).isNotNull(); + Assertions.assertThat(httpentity.getContentType()).isEqualTo("text/plain"); + Assertions.assertThat(EntityUtils.toString(httpentity, 1024)).isEqualTo(s); httpentity = new StringEntity(s, (Charset) null); - Assertions.assertNotNull(httpentity.getContentType()); - Assertions.assertEquals("text/plain", httpentity.getContentType()); - Assertions.assertEquals(s, EntityUtils.toString(httpentity, 1024)); + Assertions.assertThat(httpentity.getContentType()).isNotNull(); + Assertions.assertThat(httpentity.getContentType()).isEqualTo("text/plain"); + Assertions.assertThat(EntityUtils.toString(httpentity, 1024)).isEqualTo(s); } @Test @@ -105,22 +107,24 @@ void testWriteTo() throws Exception { ByteArrayOutputStream out = new ByteArrayOutputStream(); httpentity.writeTo(out); byte[] bytes2 = out.toByteArray(); - Assertions.assertNotNull(bytes2); - Assertions.assertEquals(bytes.length, bytes2.length); + Assertions.assertThat(bytes2).isNotNull(); + Assertions.assertThat(bytes2.length).isEqualTo(bytes.length); for (int i = 0; i < bytes.length; i++) { - Assertions.assertEquals(bytes[i], bytes2[i]); + Assertions.assertThat(bytes2[i]).isEqualTo(bytes[i]); } out = new ByteArrayOutputStream(); httpentity.writeTo(out); bytes2 = out.toByteArray(); - Assertions.assertNotNull(bytes2); - Assertions.assertEquals(bytes.length, bytes2.length); + Assertions.assertThat(bytes2).isNotNull(); + Assertions.assertThat(bytes2.length).isEqualTo(bytes.length); for (int i = 0; i < bytes.length; i++) { - Assertions.assertEquals(bytes[i], bytes2[i]); + Assertions.assertThat(bytes2[i]).isEqualTo(bytes[i]); } - Assertions.assertThrows(NullPointerException.class, () -> httpentity.writeTo(null)); + Assertions.assertThatThrownBy(() -> + httpentity.writeTo(null)) + .isInstanceOf(NullPointerException.class); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/io/support/ClassicRequestBuilderTest.java b/httpcore5/src/test/java/org/apache/hc/core5/http/io/support/ClassicRequestBuilderTest.java index 3fc2dd3a5e..15dc43f98e 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/io/support/ClassicRequestBuilderTest.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/io/support/ClassicRequestBuilderTest.java @@ -27,10 +27,6 @@ package org.apache.hc.core5.http.io.support; -import static org.junit.jupiter.api.Assertions.assertAll; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertNotNull; - import java.io.IOException; import java.net.URISyntaxException; import java.net.UnknownHostException; @@ -42,6 +38,7 @@ import org.apache.hc.core5.http.HttpHost; import org.apache.hc.core5.http.HttpVersion; import org.apache.hc.core5.http.Method; +import org.apache.hc.core5.http.ParseException; import org.apache.hc.core5.http.io.entity.ByteArrayEntity; import org.apache.hc.core5.http.io.entity.EntityUtils; import org.apache.hc.core5.http.io.entity.StringEntity; @@ -49,7 +46,8 @@ import org.apache.hc.core5.http.message.BasicNameValuePair; import org.apache.hc.core5.net.URIAuthority; import org.apache.hc.core5.net.URIBuilder; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; +import org.assertj.core.api.SoftAssertions; import org.junit.jupiter.api.Test; class ClassicRequestBuilderTest { @@ -57,149 +55,149 @@ class ClassicRequestBuilderTest { @Test void constructor() throws UnknownHostException, URISyntaxException { final ClassicRequestBuilder classicRequestBuilder = new ClassicRequestBuilder(Method.HEAD); - assertEquals(Method.HEAD.name(), classicRequestBuilder.getMethod()); + Assertions.assertThat(classicRequestBuilder.getMethod()).isEqualTo(Method.HEAD.name()); final ClassicRequestBuilder classicRequestBuilder2 = new ClassicRequestBuilder(Method.HEAD.name()); - assertEquals(Method.HEAD.name(), classicRequestBuilder2.getMethod()); + Assertions.assertThat(classicRequestBuilder2.getMethod()).isEqualTo(Method.HEAD.name()); final ClassicRequestBuilder classicRequestBuilder3 = new ClassicRequestBuilder(Method.HEAD.name(), URIBuilder.localhost().build()); - assertEquals(Method.HEAD.name(), classicRequestBuilder3.getMethod()); - assertEquals(URIBuilder.localhost().getHost(), classicRequestBuilder3.getAuthority().getHostName()); + Assertions.assertThat(classicRequestBuilder3.getMethod()).isEqualTo(Method.HEAD.name()); + Assertions.assertThat(classicRequestBuilder3.getAuthority().getHostName()).isEqualTo(URIBuilder.localhost().getHost()); final ClassicRequestBuilder classicRequestBuilder4 = new ClassicRequestBuilder(Method.HEAD, URIBuilder.localhost().build()); - assertEquals(Method.HEAD.name(), classicRequestBuilder4.getMethod()); - assertEquals(URIBuilder.localhost().getHost(), classicRequestBuilder4.getAuthority().getHostName()); + Assertions.assertThat(classicRequestBuilder4.getMethod()).isEqualTo(Method.HEAD.name()); + Assertions.assertThat(classicRequestBuilder4.getAuthority().getHostName()).isEqualTo(URIBuilder.localhost().getHost()); final ClassicRequestBuilder classicRequestBuilder5 = new ClassicRequestBuilder(Method.HEAD, "/localhost"); - assertEquals(Method.HEAD.name(), classicRequestBuilder5.getMethod()); - assertEquals("/localhost", classicRequestBuilder5.getPath()); + Assertions.assertThat(classicRequestBuilder5.getMethod()).isEqualTo(Method.HEAD.name()); + Assertions.assertThat(classicRequestBuilder5.getPath()).isEqualTo("/localhost"); final ClassicRequestBuilder classicRequestBuilder6 = new ClassicRequestBuilder(Method.HEAD.name(), "/localhost"); - assertEquals(Method.HEAD.name(), classicRequestBuilder6.getMethod()); - assertEquals("/localhost", classicRequestBuilder6.getPath()); + Assertions.assertThat(classicRequestBuilder6.getMethod()).isEqualTo(Method.HEAD.name()); + Assertions.assertThat(classicRequestBuilder6.getPath()).isEqualTo("/localhost"); } @Test void create() { final ClassicHttpRequest classicHttpRequest = ClassicRequestBuilder.create(Method.HEAD.name()).build(); - assertEquals(Method.HEAD.name(), classicHttpRequest.getMethod()); + Assertions.assertThat(classicHttpRequest.getMethod()).isEqualTo(Method.HEAD.name()); } @Test void get() throws UnknownHostException, URISyntaxException { final ClassicRequestBuilder classicRequestBuilder = ClassicRequestBuilder.get(); - assertEquals(Method.GET.name(), classicRequestBuilder.getMethod()); + Assertions.assertThat(classicRequestBuilder.getMethod()).isEqualTo(Method.GET.name()); final ClassicRequestBuilder classicRequestBuilder1 = ClassicRequestBuilder.get(URIBuilder.localhost().build()); - assertEquals(Method.GET.name(), classicRequestBuilder1.getMethod()); + Assertions.assertThat(classicRequestBuilder1.getMethod()).isEqualTo(Method.GET.name()); final ClassicRequestBuilder classicRequestBuilder3 = ClassicRequestBuilder.get("/localhost"); - assertEquals(Method.GET.name(), classicRequestBuilder3.getMethod()); - assertEquals("/localhost", classicRequestBuilder3.getPath()); + Assertions.assertThat(classicRequestBuilder3.getMethod()).isEqualTo(Method.GET.name()); + Assertions.assertThat(classicRequestBuilder3.getPath()).isEqualTo("/localhost"); } @Test void head() throws UnknownHostException, URISyntaxException { final ClassicRequestBuilder classicRequestBuilder = ClassicRequestBuilder.head(); - assertEquals(Method.HEAD.name(), classicRequestBuilder.getMethod()); + Assertions.assertThat(classicRequestBuilder.getMethod()).isEqualTo(Method.HEAD.name()); final ClassicRequestBuilder classicRequestBuilder1 = ClassicRequestBuilder.head(URIBuilder.localhost().build()); - assertEquals(Method.HEAD.name(), classicRequestBuilder1.getMethod()); + Assertions.assertThat(classicRequestBuilder1.getMethod()).isEqualTo(Method.HEAD.name()); final ClassicRequestBuilder classicRequestBuilder3 = ClassicRequestBuilder.head("/localhost"); - assertEquals(Method.HEAD.name(), classicRequestBuilder3.getMethod()); - assertEquals("/localhost", classicRequestBuilder3.getPath()); + Assertions.assertThat(classicRequestBuilder3.getMethod()).isEqualTo(Method.HEAD.name()); + Assertions.assertThat(classicRequestBuilder3.getPath()).isEqualTo("/localhost"); } @Test void query() throws UnknownHostException, URISyntaxException { final ClassicRequestBuilder classicRequestBuilder = ClassicRequestBuilder.query(); - assertEquals(Method.QUERY.name(), classicRequestBuilder.getMethod()); + Assertions.assertThat(classicRequestBuilder.getMethod()).isEqualTo(Method.QUERY.name()); final ClassicRequestBuilder classicRequestBuilder1 = ClassicRequestBuilder.query(URIBuilder.localhost().build()); - assertEquals(Method.QUERY.name(), classicRequestBuilder1.getMethod()); + Assertions.assertThat(classicRequestBuilder1.getMethod()).isEqualTo(Method.QUERY.name()); final ClassicRequestBuilder classicRequestBuilder3 = ClassicRequestBuilder.query("/localhost"); - assertEquals(Method.QUERY.name(), classicRequestBuilder3.getMethod()); - assertEquals("/localhost", classicRequestBuilder3.getPath()); + Assertions.assertThat(classicRequestBuilder3.getMethod()).isEqualTo(Method.QUERY.name()); + Assertions.assertThat(classicRequestBuilder3.getPath()).isEqualTo("/localhost"); } @Test void patch() throws UnknownHostException, URISyntaxException { final ClassicRequestBuilder classicRequestBuilder = ClassicRequestBuilder.patch(); - assertEquals(Method.PATCH.name(), classicRequestBuilder.getMethod()); + Assertions.assertThat(classicRequestBuilder.getMethod()).isEqualTo(Method.PATCH.name()); final ClassicRequestBuilder classicRequestBuilder1 = ClassicRequestBuilder.patch(URIBuilder.localhost().build()); - assertEquals(Method.PATCH.name(), classicRequestBuilder1.getMethod()); + Assertions.assertThat(classicRequestBuilder1.getMethod()).isEqualTo(Method.PATCH.name()); final ClassicRequestBuilder classicRequestBuilder3 = ClassicRequestBuilder.patch("/localhost"); - assertEquals(Method.PATCH.name(), classicRequestBuilder3.getMethod()); - assertEquals("/localhost", classicRequestBuilder3.getPath()); + Assertions.assertThat(classicRequestBuilder3.getMethod()).isEqualTo(Method.PATCH.name()); + Assertions.assertThat(classicRequestBuilder3.getPath()).isEqualTo("/localhost"); } @Test void post() throws UnknownHostException, URISyntaxException { final ClassicRequestBuilder classicRequestBuilder = ClassicRequestBuilder.post(); - assertEquals(Method.POST.name(), classicRequestBuilder.getMethod()); + Assertions.assertThat(classicRequestBuilder.getMethod()).isEqualTo(Method.POST.name()); final ClassicRequestBuilder classicRequestBuilder1 = ClassicRequestBuilder.post(URIBuilder.localhost().build()); - assertEquals(Method.POST.name(), classicRequestBuilder1.getMethod()); + Assertions.assertThat(classicRequestBuilder1.getMethod()).isEqualTo(Method.POST.name()); final ClassicRequestBuilder classicRequestBuilder3 = ClassicRequestBuilder.post("/localhost"); - assertEquals(Method.POST.name(), classicRequestBuilder3.getMethod()); - assertEquals("/localhost", classicRequestBuilder3.getPath()); + Assertions.assertThat(classicRequestBuilder3.getMethod()).isEqualTo(Method.POST.name()); + Assertions.assertThat(classicRequestBuilder3.getPath()).isEqualTo("/localhost"); } @Test void put() throws UnknownHostException, URISyntaxException { final ClassicRequestBuilder classicRequestBuilder = ClassicRequestBuilder.put(); - assertEquals(Method.PUT.name(), classicRequestBuilder.getMethod()); + Assertions.assertThat(classicRequestBuilder.getMethod()).isEqualTo(Method.PUT.name()); final ClassicRequestBuilder classicRequestBuilder1 = ClassicRequestBuilder.put(URIBuilder.localhost().build()); - assertEquals(Method.PUT.name(), classicRequestBuilder1.getMethod()); + Assertions.assertThat(classicRequestBuilder1.getMethod()).isEqualTo(Method.PUT.name()); final ClassicRequestBuilder classicRequestBuilder3 = ClassicRequestBuilder.put("/localhost"); - assertEquals(Method.PUT.name(), classicRequestBuilder3.getMethod()); - assertEquals("/localhost", classicRequestBuilder3.getPath()); + Assertions.assertThat(classicRequestBuilder3.getMethod()).isEqualTo(Method.PUT.name()); + Assertions.assertThat(classicRequestBuilder3.getPath()).isEqualTo("/localhost"); } @Test void delete() throws UnknownHostException, URISyntaxException { final ClassicRequestBuilder classicRequestBuilder = ClassicRequestBuilder.delete(); - assertEquals(Method.DELETE.name(), classicRequestBuilder.getMethod()); + Assertions.assertThat(classicRequestBuilder.getMethod()).isEqualTo(Method.DELETE.name()); final ClassicRequestBuilder classicRequestBuilder1 = ClassicRequestBuilder.delete(URIBuilder.localhost().build()); - assertEquals(Method.DELETE.name(), classicRequestBuilder1.getMethod()); + Assertions.assertThat(classicRequestBuilder1.getMethod()).isEqualTo(Method.DELETE.name()); final ClassicRequestBuilder classicRequestBuilder3 = ClassicRequestBuilder.delete("/localhost"); - assertEquals(Method.DELETE.name(), classicRequestBuilder3.getMethod()); - assertEquals("/localhost", classicRequestBuilder3.getPath()); + Assertions.assertThat(classicRequestBuilder3.getMethod()).isEqualTo(Method.DELETE.name()); + Assertions.assertThat(classicRequestBuilder3.getPath()).isEqualTo("/localhost"); } @Test void trace() throws UnknownHostException, URISyntaxException { final ClassicRequestBuilder classicRequestBuilder = ClassicRequestBuilder.trace(); - assertEquals(Method.TRACE.name(), classicRequestBuilder.getMethod()); + Assertions.assertThat(classicRequestBuilder.getMethod()).isEqualTo(Method.TRACE.name()); final ClassicRequestBuilder classicRequestBuilder1 = ClassicRequestBuilder.trace(URIBuilder.localhost().build()); - assertEquals(Method.TRACE.name(), classicRequestBuilder1.getMethod()); + Assertions.assertThat(classicRequestBuilder1.getMethod()).isEqualTo(Method.TRACE.name()); final ClassicRequestBuilder classicRequestBuilder3 = ClassicRequestBuilder.trace("/localhost"); - assertEquals(Method.TRACE.name(), classicRequestBuilder3.getMethod()); - assertEquals("/localhost", classicRequestBuilder3.getPath()); + Assertions.assertThat(classicRequestBuilder3.getMethod()).isEqualTo(Method.TRACE.name()); + Assertions.assertThat(classicRequestBuilder3.getPath()).isEqualTo("/localhost"); } @Test void option() throws UnknownHostException, URISyntaxException { final ClassicRequestBuilder classicRequestBuilder = ClassicRequestBuilder.options(); - assertEquals(Method.OPTIONS.name(), classicRequestBuilder.getMethod()); + Assertions.assertThat(classicRequestBuilder.getMethod()).isEqualTo(Method.OPTIONS.name()); final ClassicRequestBuilder classicRequestBuilder1 = ClassicRequestBuilder.options(URIBuilder.localhost().build()); - assertEquals(Method.OPTIONS.name(), classicRequestBuilder1.getMethod()); + Assertions.assertThat(classicRequestBuilder1.getMethod()).isEqualTo(Method.OPTIONS.name()); final ClassicRequestBuilder classicRequestBuilder3 = ClassicRequestBuilder.options("/localhost"); - assertEquals(Method.OPTIONS.name(), classicRequestBuilder3.getMethod()); - assertEquals("/localhost", classicRequestBuilder3.getPath()); + Assertions.assertThat(classicRequestBuilder3.getMethod()).isEqualTo(Method.OPTIONS.name()); + Assertions.assertThat(classicRequestBuilder3.getPath()).isEqualTo("/localhost"); } @Test @@ -229,30 +227,31 @@ void builder() { .setHttpHost(new HttpHost("httpbin.org")) .build(); - assertAll("Should return address of Oracle's headquarter", - () -> assertNotNull(classicHttpRequest.getEntity()), - () -> assertEquals(Method.GET.name(), classicHttpRequest.getMethod()), - () -> assertEquals("http", classicHttpRequest.getScheme()), - () -> assertEquals("httpbin.org", classicHttpRequest.getAuthority().getHostName()), - () -> assertEquals(HttpVersion.HTTP_1_1, classicHttpRequest.getVersion()), - () -> assertEquals(4, classicHttpRequest.getHeaders().length), - () -> assertNotNull(ClassicRequestBuilder.get().toString()), - () -> assertEquals("http://httpbin.org/theUri?header2=blah¶m1=value1¶m3=value3¶m4", new String(classicHttpRequest.getRequestUri().getBytes())) - ); + SoftAssertions.assertSoftly(softly -> { + softly.assertThat(classicHttpRequest.getEntity()).isNotNull(); + softly.assertThat(classicHttpRequest.getMethod()).isEqualTo(Method.GET.name()); + softly.assertThat(classicHttpRequest.getScheme()).isEqualTo("http"); + softly.assertThat(classicHttpRequest.getAuthority().getHostName()).isEqualTo("httpbin.org"); + softly.assertThat(classicHttpRequest.getVersion()).isEqualTo(HttpVersion.HTTP_1_1); + softly.assertThat(classicHttpRequest.getHeaders()).hasSize(4); + softly.assertThat(ClassicRequestBuilder.get().toString()).isNotNull(); + softly.assertThat(new String(classicHttpRequest.getRequestUri().getBytes())) + .isEqualTo("http://httpbin.org/theUri?header2=blah¶m1=value1¶m3=value3¶m4"); + }); } @Test void builderTraceThrowsIllegalStateException() { - Assertions.assertThrows(IllegalStateException.class, () -> + Assertions.assertThatThrownBy(() -> ClassicRequestBuilder.trace() .setVersion(HttpVersion.HTTP_1_1) .setEntity(new ByteArrayEntity(new byte[10240], ContentType.TEXT_PLAIN)) - .build()); + .build()).isInstanceOf(IllegalStateException.class); } @Test - void builderQuery() throws IOException { + void builderQuery() throws IOException, ParseException { final ClassicHttpRequest classicHttpRequest = ClassicRequestBuilder.query() .setHttpHost(new HttpHost("httpbin.org")) .setPath("/theUri") @@ -260,14 +259,16 @@ void builderQuery() throws IOException { .addParameter("param2", "value2") .build(); - assertAll("QUERY builder tests", - () -> assertEquals(Method.QUERY.name(), classicHttpRequest.getMethod()), - () -> assertEquals("httpbin.org", classicHttpRequest.getAuthority().getHostName()), - () -> assertEquals("/theUri", classicHttpRequest.getPath()), - () -> assertNotNull(classicHttpRequest.getEntity()), - () -> assertEquals(ContentType.APPLICATION_FORM_URLENCODED.getMimeType(), ContentType.parse(classicHttpRequest.getEntity().getContentType()).getMimeType()), - () -> assertEquals("param1=value1¶m2=value2", EntityUtils.toString(classicHttpRequest.getEntity(), 1024)) - ); + final String entityContent = EntityUtils.toString(classicHttpRequest.getEntity(), 1024); + final String contentType = ContentType.parse(classicHttpRequest.getEntity().getContentType()).getMimeType(); + SoftAssertions.assertSoftly(softly -> { + softly.assertThat(classicHttpRequest.getMethod()).isEqualTo(Method.QUERY.name()); + softly.assertThat(classicHttpRequest.getAuthority().getHostName()).isEqualTo("httpbin.org"); + softly.assertThat(classicHttpRequest.getPath()).isEqualTo("/theUri"); + softly.assertThat(classicHttpRequest.getEntity()).isNotNull(); + softly.assertThat(contentType).isEqualTo(ContentType.APPLICATION_FORM_URLENCODED.getMimeType()); + softly.assertThat(entityContent).isEqualTo("param1=value1¶m2=value2"); + }); } } \ No newline at end of file diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/io/support/ClassicResponseBuilderTest.java b/httpcore5/src/test/java/org/apache/hc/core5/http/io/support/ClassicResponseBuilderTest.java index e29b67465d..98f4b59726 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/io/support/ClassicResponseBuilderTest.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/io/support/ClassicResponseBuilderTest.java @@ -43,7 +43,7 @@ import org.apache.hc.core5.http.impl.io.DefaultHttpResponseWriterFactory; import org.apache.hc.core5.http.io.entity.StringEntity; import org.apache.hc.core5.http.message.BasicHeader; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; @@ -72,7 +72,7 @@ void prepareMocks() throws IOException { outStream = new ByteArrayOutputStream(); Mockito.when(socket.getOutputStream()).thenReturn(outStream); conn.bind(socket); - Assertions.assertEquals(0, conn.getEndpointDetails().getResponseCount()); + Assertions.assertThat(conn.getEndpointDetails().getResponseCount()).isEqualTo(0); } @Test @@ -93,10 +93,10 @@ void create() throws IOException, HttpException { conn.sendResponseHeader(response); conn.flush(); - Assertions.assertEquals(1, conn.getEndpointDetails().getResponseCount()); + Assertions.assertThat(conn.getEndpointDetails().getResponseCount()).isEqualTo(1); final String s = new String(outStream.toByteArray(), StandardCharsets.US_ASCII); - Assertions.assertEquals("HTTP/1.1 200 OK\r\nX-Test-Filter: active\r\nheader1: blah\r\nheader2: blah\r\nheader3: blah\r\nUser-Agent: test\r\n\r\n", s); - Assertions.assertNotNull(response.getEntity()); + Assertions.assertThat(s).isEqualTo("HTTP/1.1 200 OK\r\nX-Test-Filter: active\r\nheader1: blah\r\nheader2: blah\r\nheader3: blah\r\nUser-Agent: test\r\n\r\n"); + Assertions.assertThat(response.getEntity()).isNotNull(); } @Test @@ -119,10 +119,10 @@ void remove() throws IOException, HttpException { conn.sendResponseHeader(response); conn.flush(); - Assertions.assertEquals(1, conn.getEndpointDetails().getResponseCount()); + Assertions.assertThat(conn.getEndpointDetails().getResponseCount()).isEqualTo(1); final String s = new String(outStream.toByteArray(), StandardCharsets.US_ASCII); - Assertions.assertEquals("HTTP/1.1 200 OK\r\nheader1: blah\r\nheader3: blah\r\n\r\n", s); - Assertions.assertNotNull(response.getEntity()); + Assertions.assertThat(s).isEqualTo("HTTP/1.1 200 OK\r\nheader1: blah\r\nheader3: blah\r\n\r\n"); + Assertions.assertThat(response.getEntity()).isNotNull(); } @@ -145,10 +145,10 @@ void copy() throws IOException, HttpException { conn.sendResponseHeader(response2); conn.flush(); - Assertions.assertEquals(1, conn.getEndpointDetails().getResponseCount()); + Assertions.assertThat(conn.getEndpointDetails().getResponseCount()).isEqualTo(1); final String s = new String(outStream.toByteArray(), StandardCharsets.US_ASCII); - Assertions.assertEquals("HTTP/1.1 200 OK\r\nheader1: blah\r\nheader3: blah\r\n\r\n", s); - Assertions.assertNotNull(response.getEntity()); - Assertions.assertNotNull(classicResponseBuilder.toString()); + Assertions.assertThat(s).isEqualTo("HTTP/1.1 200 OK\r\nheader1: blah\r\nheader3: blah\r\n\r\n"); + Assertions.assertThat(response.getEntity()).isNotNull(); + Assertions.assertThat(classicResponseBuilder.toString()).isNotNull(); } } \ No newline at end of file diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/message/HttpRequestWrapperTest.java b/httpcore5/src/test/java/org/apache/hc/core5/http/message/HttpRequestWrapperTest.java index d169f4ee4a..9bcd519e81 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/message/HttpRequestWrapperTest.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/message/HttpRequestWrapperTest.java @@ -34,7 +34,7 @@ import org.apache.hc.core5.http.Method; import org.apache.hc.core5.http.URIScheme; import org.apache.hc.core5.net.URIAuthority; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class HttpRequestWrapperTest { @@ -44,28 +44,28 @@ void testRequestBasics() throws Exception { final HttpRequest request = new BasicHttpRequest(Method.GET, "/stuff"); final HttpRequestWrapper httpRequestWrapper = new HttpRequestWrapper(request); - Assertions.assertEquals(Method.GET.name(), httpRequestWrapper.getMethod()); - Assertions.assertEquals("/stuff", httpRequestWrapper.getPath()); - Assertions.assertNull(httpRequestWrapper.getAuthority()); - Assertions.assertEquals(new URI("/stuff"), httpRequestWrapper.getUri()); + Assertions.assertThat(httpRequestWrapper.getMethod()).isEqualTo(Method.GET.name()); + Assertions.assertThat(httpRequestWrapper.getPath()).isEqualTo("/stuff"); + Assertions.assertThat(httpRequestWrapper.getAuthority()).isNull(); + Assertions.assertThat(httpRequestWrapper.getUri()).isEqualTo(new URI("/stuff")); httpRequestWrapper.setPath("/another-stuff"); - Assertions.assertEquals("/another-stuff", httpRequestWrapper.getPath()); + Assertions.assertThat(httpRequestWrapper.getPath()).isEqualTo("/another-stuff"); } @Test void testDefaultRequestConstructors() { final HttpRequest request1 = new BasicHttpRequest("WHATEVER", "/"); final HttpRequestWrapper httpRequestWrapper = new HttpRequestWrapper(request1); - Assertions.assertEquals("WHATEVER", httpRequestWrapper.getMethod()); - Assertions.assertEquals("/", httpRequestWrapper.getPath()); + Assertions.assertThat(httpRequestWrapper.getMethod()).isEqualTo("WHATEVER"); + Assertions.assertThat(httpRequestWrapper.getPath()).isEqualTo("/"); final HttpRequest request2 = new BasicHttpRequest(Method.GET, "/"); final HttpRequestWrapper httpRequestWrapper2 = new HttpRequestWrapper(request2); - Assertions.assertEquals(Method.GET.name(), httpRequestWrapper2.getMethod()); - Assertions.assertEquals("/", httpRequestWrapper2.getPath()); + Assertions.assertThat(httpRequestWrapper2.getMethod()).isEqualTo(Method.GET.name()); + Assertions.assertThat(httpRequestWrapper2.getPath()).isEqualTo("/"); - Assertions.assertThrows(NullPointerException.class, () -> - new BasicHttpRequest(Method.GET, (URI) null)); + Assertions.assertThatThrownBy(() -> + new BasicHttpRequest(Method.GET, (URI) null)).isInstanceOf(NullPointerException.class); } @@ -73,69 +73,69 @@ void testDefaultRequestConstructors() { void testRequestWithRelativeURI() throws Exception { final HttpRequest request = new BasicHttpRequest(Method.GET, new URI("/stuff")); final HttpRequestWrapper httpRequestWrapper = new HttpRequestWrapper(request); - Assertions.assertEquals(Method.GET.name(), httpRequestWrapper.getMethod()); - Assertions.assertEquals("/stuff", httpRequestWrapper.getPath()); - Assertions.assertNull(httpRequestWrapper.getAuthority()); - Assertions.assertEquals(new URI("/stuff"), httpRequestWrapper.getUri()); + Assertions.assertThat(httpRequestWrapper.getMethod()).isEqualTo(Method.GET.name()); + Assertions.assertThat(httpRequestWrapper.getPath()).isEqualTo("/stuff"); + Assertions.assertThat(httpRequestWrapper.getAuthority()).isNull(); + Assertions.assertThat(httpRequestWrapper.getUri()).isEqualTo(new URI("/stuff")); } @Test void testRequestWithAbsoluteURI() throws Exception { final HttpRequest request = new BasicHttpRequest(Method.GET, new URI("https://host:9443/stuff?param=value")); final HttpRequestWrapper httpRequestWrapper = new HttpRequestWrapper(request); - Assertions.assertEquals(Method.GET.name(), httpRequestWrapper.getMethod()); - Assertions.assertEquals("/stuff?param=value", httpRequestWrapper.getPath()); - Assertions.assertEquals(new URIAuthority("host", 9443), httpRequestWrapper.getAuthority()); - Assertions.assertEquals("https", httpRequestWrapper.getScheme()); - Assertions.assertEquals(new URI("https://host:9443/stuff?param=value"), httpRequestWrapper.getUri()); + Assertions.assertThat(httpRequestWrapper.getMethod()).isEqualTo(Method.GET.name()); + Assertions.assertThat(httpRequestWrapper.getPath()).isEqualTo("/stuff?param=value"); + Assertions.assertThat(httpRequestWrapper.getAuthority()).isEqualTo(new URIAuthority("host", 9443)); + Assertions.assertThat(httpRequestWrapper.getScheme()).isEqualTo("https"); + Assertions.assertThat(httpRequestWrapper.getUri()).isEqualTo(new URI("https://host:9443/stuff?param=value")); httpRequestWrapper.setScheme(URIScheme.HTTP.id); - Assertions.assertEquals("http", httpRequestWrapper.getScheme()); + Assertions.assertThat(httpRequestWrapper.getScheme()).isEqualTo("http"); } @Test void testRequestWithAbsoluteURIAsPath() throws Exception { final HttpRequest request = new BasicHttpRequest(Method.GET, "https://host:9443/stuff?param=value"); final HttpRequestWrapper httpRequestWrapper = new HttpRequestWrapper(request); - Assertions.assertEquals(Method.GET.name(), httpRequestWrapper.getMethod()); - Assertions.assertEquals("/stuff?param=value", httpRequestWrapper.getPath()); - Assertions.assertEquals(new URIAuthority("host", 9443), httpRequestWrapper.getAuthority()); - Assertions.assertEquals("https", httpRequestWrapper.getScheme()); - Assertions.assertEquals(new URI("https://host:9443/stuff?param=value"), httpRequestWrapper.getUri()); + Assertions.assertThat(httpRequestWrapper.getMethod()).isEqualTo(Method.GET.name()); + Assertions.assertThat(httpRequestWrapper.getPath()).isEqualTo("/stuff?param=value"); + Assertions.assertThat(httpRequestWrapper.getAuthority()).isEqualTo(new URIAuthority("host", 9443)); + Assertions.assertThat(httpRequestWrapper.getScheme()).isEqualTo("https"); + Assertions.assertThat(httpRequestWrapper.getUri()).isEqualTo(new URI("https://host:9443/stuff?param=value")); } @Test void testRequestWithNoPath() throws Exception { final HttpRequest request = new BasicHttpRequest(Method.GET, new URI("http://host")); final HttpRequestWrapper httpRequestWrapper = new HttpRequestWrapper(request); - Assertions.assertEquals(Method.GET.name(), httpRequestWrapper.getMethod()); - Assertions.assertEquals("/", httpRequestWrapper.getPath()); - Assertions.assertEquals(new URIAuthority("host"), httpRequestWrapper.getAuthority()); - Assertions.assertEquals("http", httpRequestWrapper.getScheme()); - Assertions.assertEquals(new URI("http://host/"), httpRequestWrapper.getUri()); + Assertions.assertThat(httpRequestWrapper.getMethod()).isEqualTo(Method.GET.name()); + Assertions.assertThat(httpRequestWrapper.getPath()).isEqualTo("/"); + Assertions.assertThat(httpRequestWrapper.getAuthority()).isEqualTo(new URIAuthority("host")); + Assertions.assertThat(httpRequestWrapper.getScheme()).isEqualTo("http"); + Assertions.assertThat(httpRequestWrapper.getUri()).isEqualTo(new URI("http://host/")); } @Test void testRequestWithUserInfo() throws Exception { final HttpRequest request = new BasicHttpRequest(Method.GET, new URI("https://user:pwd@host:9443/stuff?param=value")); final HttpRequestWrapper httpRequestWrapper = new HttpRequestWrapper(request); - Assertions.assertEquals(Method.GET.name(), httpRequestWrapper.getMethod()); - Assertions.assertEquals("/stuff?param=value", httpRequestWrapper.getPath()); - Assertions.assertEquals(new URIAuthority("user:pwd", "host", 9443), httpRequestWrapper.getAuthority()); - Assertions.assertEquals("https", httpRequestWrapper.getScheme()); - Assertions.assertEquals(new URI("https://host:9443/stuff?param=value"), httpRequestWrapper.getUri()); + Assertions.assertThat(httpRequestWrapper.getMethod()).isEqualTo(Method.GET.name()); + Assertions.assertThat(httpRequestWrapper.getPath()).isEqualTo("/stuff?param=value"); + Assertions.assertThat(httpRequestWrapper.getAuthority()).isEqualTo(new URIAuthority("user:pwd", "host", 9443)); + Assertions.assertThat(httpRequestWrapper.getScheme()).isEqualTo("https"); + Assertions.assertThat(httpRequestWrapper.getUri()).isEqualTo(new URI("https://host:9443/stuff?param=value")); } @Test void testRequestWithAuthority() throws Exception { final HttpRequest request = new BasicHttpRequest(Method.GET, new HttpHost("http", "somehost", -1), "/stuff"); final HttpRequestWrapper httpRequestWrapper = new HttpRequestWrapper(request); - Assertions.assertEquals(Method.GET.name(), httpRequestWrapper.getMethod()); - Assertions.assertEquals("/stuff", httpRequestWrapper.getPath()); - Assertions.assertEquals(new URIAuthority("somehost"), httpRequestWrapper.getAuthority()); - Assertions.assertEquals(new URI("http://somehost/stuff"), httpRequestWrapper.getUri()); + Assertions.assertThat(httpRequestWrapper.getMethod()).isEqualTo(Method.GET.name()); + Assertions.assertThat(httpRequestWrapper.getPath()).isEqualTo("/stuff"); + Assertions.assertThat(httpRequestWrapper.getAuthority()).isEqualTo(new URIAuthority("somehost")); + Assertions.assertThat(httpRequestWrapper.getUri()).isEqualTo(new URI("http://somehost/stuff")); httpRequestWrapper.setAuthority(new URIAuthority("newHost")); - Assertions.assertEquals(new URIAuthority("newHost"), httpRequestWrapper.getAuthority()); + Assertions.assertThat(httpRequestWrapper.getAuthority()).isEqualTo(new URIAuthority("newHost")); } @@ -143,20 +143,20 @@ void testRequestWithAuthority() throws Exception { void testRequestWithAuthorityRelativePath() throws Exception { final HttpRequest request = new BasicHttpRequest(Method.GET, new HttpHost("http", "somehost", -1), "stuff"); final HttpRequestWrapper httpRequestWrapper = new HttpRequestWrapper(request); - Assertions.assertEquals(Method.GET.name(), httpRequestWrapper.getMethod()); - Assertions.assertEquals("stuff", httpRequestWrapper.getPath()); - Assertions.assertEquals("stuff", httpRequestWrapper.getRequestUri()); - Assertions.assertEquals(new URIAuthority("somehost"), httpRequestWrapper.getAuthority()); - Assertions.assertEquals(new URI("http://somehost/stuff"), httpRequestWrapper.getUri()); + Assertions.assertThat(httpRequestWrapper.getMethod()).isEqualTo(Method.GET.name()); + Assertions.assertThat(httpRequestWrapper.getPath()).isEqualTo("stuff"); + Assertions.assertThat(httpRequestWrapper.getRequestUri()).isEqualTo("stuff"); + Assertions.assertThat(httpRequestWrapper.getAuthority()).isEqualTo(new URIAuthority("somehost")); + Assertions.assertThat(httpRequestWrapper.getUri()).isEqualTo(new URI("http://somehost/stuff")); } @Test void testRequestHostWithReservedChars() throws Exception { final HttpRequest request = new BasicHttpRequest(Method.GET, URI.create("http://someuser%21@%21example%21.com/stuff")); final HttpRequestWrapper httpRequestWrapper = new HttpRequestWrapper(request); - Assertions.assertEquals(Method.GET.name(), httpRequestWrapper.getMethod()); - Assertions.assertEquals("/stuff", httpRequestWrapper.getPath()); - Assertions.assertEquals(new URIAuthority("someuser%21", "%21example%21.com", -1), httpRequestWrapper.getAuthority()); - Assertions.assertEquals(new URI("http://%21example%21.com/stuff"), httpRequestWrapper.getUri()); + Assertions.assertThat(httpRequestWrapper.getMethod()).isEqualTo(Method.GET.name()); + Assertions.assertThat(httpRequestWrapper.getPath()).isEqualTo("/stuff"); + Assertions.assertThat(httpRequestWrapper.getAuthority()).isEqualTo(new URIAuthority("someuser%21", "%21example%21.com", -1)); + Assertions.assertThat(httpRequestWrapper.getUri()).isEqualTo(new URI("http://%21example%21.com/stuff")); } } \ No newline at end of file diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/message/HttpResponseWrapperTest.java b/httpcore5/src/test/java/org/apache/hc/core5/http/message/HttpResponseWrapperTest.java index 445971bce7..172b794bb2 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/message/HttpResponseWrapperTest.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/message/HttpResponseWrapperTest.java @@ -31,7 +31,7 @@ import org.apache.hc.core5.http.HttpResponse; import org.apache.hc.core5.http.HttpStatus; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class HttpResponseWrapperTest { @@ -41,15 +41,15 @@ void testDefaultResponseConstructors() { final HttpResponse response1 = new BasicHttpResponse(HttpStatus.SC_BAD_REQUEST, "Bad Request"); final HttpResponseWrapper httpResponseWrapper1 = new HttpResponseWrapper(response1); - Assertions.assertEquals(HttpStatus.SC_BAD_REQUEST, httpResponseWrapper1.getCode()); + Assertions.assertThat(httpResponseWrapper1.getCode()).isEqualTo(HttpStatus.SC_BAD_REQUEST); final HttpResponse response2 = new BasicHttpResponse(HttpStatus.SC_INTERNAL_SERVER_ERROR, "whatever"); final HttpResponseWrapper httpResponseWrapper2 = new HttpResponseWrapper(response2); - Assertions.assertEquals(HttpStatus.SC_INTERNAL_SERVER_ERROR, httpResponseWrapper2.getCode()); - Assertions.assertEquals("whatever", httpResponseWrapper2.getReasonPhrase()); + Assertions.assertThat(httpResponseWrapper2.getCode()).isEqualTo(HttpStatus.SC_INTERNAL_SERVER_ERROR); + Assertions.assertThat(httpResponseWrapper2.getReasonPhrase()).isEqualTo("whatever"); httpResponseWrapper2.setReasonPhrase("another-whatever"); - Assertions.assertEquals("another-whatever", httpResponseWrapper2.getReasonPhrase()); + Assertions.assertThat(httpResponseWrapper2.getReasonPhrase()).isEqualTo("another-whatever"); } @Test @@ -57,20 +57,22 @@ void testSetResponseStatus() { final HttpResponse response1 = new BasicHttpResponse(200, "OK"); final HttpResponseWrapper httpResponseWrapper1 = new HttpResponseWrapper(response1); - Assertions.assertEquals(200, httpResponseWrapper1.getCode()); + Assertions.assertThat(httpResponseWrapper1.getCode()).isEqualTo(200); final HttpResponse response2 = new BasicHttpResponse(HttpStatus.SC_BAD_REQUEST, "Bad Request"); final HttpResponseWrapper httpResponseWrapper2 = new HttpResponseWrapper(response2); - Assertions.assertEquals(HttpStatus.SC_BAD_REQUEST, httpResponseWrapper2.getCode()); + Assertions.assertThat(httpResponseWrapper2.getCode()).isEqualTo(HttpStatus.SC_BAD_REQUEST); final HttpResponse response3 = new BasicHttpResponse(HttpStatus.SC_INTERNAL_SERVER_ERROR, "whatever"); final HttpResponseWrapper httpResponseWrapper3 = new HttpResponseWrapper(response3); - Assertions.assertEquals(HttpStatus.SC_INTERNAL_SERVER_ERROR, httpResponseWrapper3.getCode()); - Assertions.assertEquals("whatever", httpResponseWrapper3.getReasonPhrase()); + Assertions.assertThat(httpResponseWrapper3.getCode()).isEqualTo(HttpStatus.SC_INTERNAL_SERVER_ERROR); + Assertions.assertThat(httpResponseWrapper3.getReasonPhrase()).isEqualTo("whatever"); final HttpResponse response4 = new BasicHttpResponse(HttpStatus.SC_OK, "OK"); final HttpResponseWrapper httpResponseWrapper4 = new HttpResponseWrapper(response4); - Assertions.assertThrows(IllegalArgumentException.class, () -> httpResponseWrapper4.setCode(-23)); + Assertions.assertThatThrownBy(() -> + httpResponseWrapper4.setCode(-23)) + .isInstanceOf(IllegalArgumentException.class); } @Test @@ -78,7 +80,7 @@ void testLocale() { final HttpResponse response = new BasicHttpResponse(200, "OK"); final HttpResponseWrapper httpResponseWrapper = new HttpResponseWrapper(response); httpResponseWrapper.setLocale(Locale.US); - Assertions.assertEquals("US", httpResponseWrapper.getLocale().getCountry()); + Assertions.assertThat(httpResponseWrapper.getLocale().getCountry()).isEqualTo("US"); } } \ No newline at end of file diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/message/TestBasicHeader.java b/httpcore5/src/test/java/org/apache/hc/core5/http/message/TestBasicHeader.java index b7cfecc3dc..0755bfdc14 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/message/TestBasicHeader.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/message/TestBasicHeader.java @@ -27,7 +27,7 @@ package org.apache.hc.core5.http.message; import org.apache.hc.core5.http.Header; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; /** @@ -38,21 +38,23 @@ class TestBasicHeader { @Test void testConstructor() { final Header param = new BasicHeader("name", "value"); - Assertions.assertEquals("name", param.getName()); - Assertions.assertEquals("value", param.getValue()); + Assertions.assertThat(param.getName()).isEqualTo("name"); + Assertions.assertThat(param.getValue()).isEqualTo("value"); } @Test void testInvalidName() { - Assertions.assertThrows(NullPointerException.class, () -> new BasicHeader(null, null)); + Assertions.assertThatThrownBy(() -> + new BasicHeader(null, null)) + .isInstanceOf(NullPointerException.class); } @Test void testToString() { final Header param1 = new BasicHeader("name1", "value1"); - Assertions.assertEquals("name1: value1", param1.toString()); + Assertions.assertThat(param1.toString()).isEqualTo("name1: value1"); final Header param2 = new BasicHeader("name1", null); - Assertions.assertEquals("name1: ", param2.toString()); + Assertions.assertThat(param2.toString()).isEqualTo("name1: "); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/message/TestBasicHeaderElementIterator.java b/httpcore5/src/test/java/org/apache/hc/core5/http/message/TestBasicHeaderElementIterator.java index 6355610dc2..b48815ccc2 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/message/TestBasicHeaderElementIterator.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/message/TestBasicHeaderElementIterator.java @@ -31,7 +31,7 @@ import org.apache.hc.core5.http.Header; import org.apache.hc.core5.http.HeaderElement; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; /** @@ -50,19 +50,23 @@ void testMultiHeader() { final Iterator hei = new BasicHeaderElementIterator( new BasicHeaderIterator(headers, "Name")); - Assertions.assertTrue(hei.hasNext()); + Assertions.assertThat(hei.hasNext()).isTrue(); HeaderElement elem = hei.next(); - Assertions.assertEquals("value0", elem.getName(), "The two header values must be equal"); + Assertions.assertThat(elem.getName()).withFailMessage("The two header values must be equal").isEqualTo("value0"); - Assertions.assertTrue(hei.hasNext()); + Assertions.assertThat(hei.hasNext()).isTrue(); elem = hei.next(); - Assertions.assertEquals("value1", elem.getName(), "The two header values must be equal"); + Assertions.assertThat(elem.getName()).withFailMessage("The two header values must be equal").isEqualTo("value1"); - Assertions.assertFalse(hei.hasNext()); - Assertions.assertThrows(NoSuchElementException.class, () -> hei.next()); + Assertions.assertThat(hei.hasNext()).isFalse(); + Assertions.assertThatThrownBy(() -> + hei.next()) + .isInstanceOf(NoSuchElementException.class); - Assertions.assertFalse(hei.hasNext()); - Assertions.assertThrows(NoSuchElementException.class, () -> hei.next()); + Assertions.assertThat(hei.hasNext()).isFalse(); + Assertions.assertThatThrownBy(() -> + hei.next()) + .isInstanceOf(NoSuchElementException.class); } @Test @@ -76,16 +80,16 @@ void testMultiHeaderSameLine() { new BasicHeaderIterator(headers, "Name")); HeaderElement elem = hei.next(); - Assertions.assertEquals("value0", elem.getName(), "The two header values must be equal"); + Assertions.assertThat(elem.getName()).withFailMessage("The two header values must be equal").isEqualTo("value0"); elem = hei.next(); - Assertions.assertEquals("value1", elem.getName(), "The two header values must be equal"); + Assertions.assertThat(elem.getName()).withFailMessage("The two header values must be equal").isEqualTo("value1"); elem = hei.next(); - Assertions.assertEquals("cookie1", elem.getName(), "The two header values must be equal"); - Assertions.assertEquals("1", elem.getValue(), "The two header values must be equal"); + Assertions.assertThat(elem.getName()).withFailMessage("The two header values must be equal").isEqualTo("cookie1"); + Assertions.assertThat(elem.getValue()).withFailMessage("The two header values must be equal").isEqualTo("1"); elem = hei.next(); - Assertions.assertEquals("cookie2", elem.getName(), "The two header values must be equal"); - Assertions.assertEquals("2", elem.getValue(), "The two header values must be equal"); + Assertions.assertThat(elem.getName()).withFailMessage("The two header values must be equal").isEqualTo("cookie2"); + Assertions.assertThat(elem.getValue()).withFailMessage("The two header values must be equal").isEqualTo("2"); } @Test @@ -99,10 +103,14 @@ void testFringeCases() { final Iterator hei = new BasicHeaderElementIterator( new BasicHeaderIterator(headers, "Name")); - Assertions.assertFalse(hei.hasNext()); - Assertions.assertThrows(NoSuchElementException.class, () -> hei.next()); - Assertions.assertFalse(hei.hasNext()); - Assertions.assertThrows(NoSuchElementException.class, () -> hei.next()); + Assertions.assertThat(hei.hasNext()).isFalse(); + Assertions.assertThatThrownBy(() -> + hei.next()) + .isInstanceOf(NoSuchElementException.class); + Assertions.assertThat(hei.hasNext()).isFalse(); + Assertions.assertThatThrownBy(() -> + hei.next()) + .isInstanceOf(NoSuchElementException.class); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/message/TestBasicHeaderIterator.java b/httpcore5/src/test/java/org/apache/hc/core5/http/message/TestBasicHeaderIterator.java index b0217450dc..498950419f 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/message/TestBasicHeaderIterator.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/message/TestBasicHeaderIterator.java @@ -30,7 +30,7 @@ import java.util.NoSuchElementException; import org.apache.hc.core5.http.Header; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; @@ -51,27 +51,27 @@ void testAllSame() { // without filter Iterator
hit = new BasicHeaderIterator(headers, null); - Assertions.assertTrue(hit.hasNext()); - Assertions.assertEquals(headers[0], hit.next(), "0"); - Assertions.assertTrue(hit.hasNext()); - Assertions.assertEquals(headers[1], hit.next(), "1"); - Assertions.assertTrue(hit.hasNext()); - Assertions.assertEquals(headers[2], hit.next(), "2"); - Assertions.assertTrue(hit.hasNext()); - Assertions.assertEquals(headers[3], hit.next(), "3"); - Assertions.assertFalse(hit.hasNext()); + Assertions.assertThat(hit.hasNext()).isTrue(); + Assertions.assertThat(hit.next()).withFailMessage("0").isEqualTo(headers[0]); + Assertions.assertThat(hit.hasNext()).isTrue(); + Assertions.assertThat(hit.next()).withFailMessage("1").isEqualTo(headers[1]); + Assertions.assertThat(hit.hasNext()).isTrue(); + Assertions.assertThat(hit.next()).withFailMessage("2").isEqualTo(headers[2]); + Assertions.assertThat(hit.hasNext()).isTrue(); + Assertions.assertThat(hit.next()).withFailMessage("3").isEqualTo(headers[3]); + Assertions.assertThat(hit.hasNext()).isFalse(); // with filter hit = new BasicHeaderIterator(headers, "name"); - Assertions.assertTrue(hit.hasNext()); - Assertions.assertEquals(headers[0], hit.next(), "0"); - Assertions.assertTrue(hit.hasNext()); - Assertions.assertEquals(headers[1], hit.next(), "1"); - Assertions.assertTrue(hit.hasNext()); - Assertions.assertEquals(headers[2], hit.next(), "2"); - Assertions.assertTrue(hit.hasNext()); - Assertions.assertEquals(headers[3], hit.next(), "3"); - Assertions.assertFalse(hit.hasNext()); + Assertions.assertThat(hit.hasNext()).isTrue(); + Assertions.assertThat(hit.next()).withFailMessage("0").isEqualTo(headers[0]); + Assertions.assertThat(hit.hasNext()).isTrue(); + Assertions.assertThat(hit.next()).withFailMessage("1").isEqualTo(headers[1]); + Assertions.assertThat(hit.hasNext()).isTrue(); + Assertions.assertThat(hit.next()).withFailMessage("2").isEqualTo(headers[2]); + Assertions.assertThat(hit.hasNext()).isTrue(); + Assertions.assertThat(hit.next()).withFailMessage("3").isEqualTo(headers[3]); + Assertions.assertThat(hit.hasNext()).isFalse(); } @@ -86,33 +86,33 @@ void testFirstLastOneNone() { // without filter Iterator
hit = new BasicHeaderIterator(headers, null); - Assertions.assertTrue(hit.hasNext()); - Assertions.assertEquals(headers[0], hit.next(), "0"); - Assertions.assertTrue(hit.hasNext()); - Assertions.assertEquals(headers[1], hit.next(), "1"); - Assertions.assertTrue(hit.hasNext()); - Assertions.assertEquals(headers[2], hit.next(), "2"); - Assertions.assertTrue(hit.hasNext()); - Assertions.assertEquals(headers[3], hit.next(), "3"); - Assertions.assertFalse(hit.hasNext()); + Assertions.assertThat(hit.hasNext()).isTrue(); + Assertions.assertThat(hit.next()).withFailMessage("0").isEqualTo(headers[0]); + Assertions.assertThat(hit.hasNext()).isTrue(); + Assertions.assertThat(hit.next()).withFailMessage("1").isEqualTo(headers[1]); + Assertions.assertThat(hit.hasNext()).isTrue(); + Assertions.assertThat(hit.next()).withFailMessage("2").isEqualTo(headers[2]); + Assertions.assertThat(hit.hasNext()).isTrue(); + Assertions.assertThat(hit.next()).withFailMessage("3").isEqualTo(headers[3]); + Assertions.assertThat(hit.hasNext()).isFalse(); // with filter, first & last hit = new BasicHeaderIterator(headers, "match"); - Assertions.assertTrue(hit.hasNext()); - Assertions.assertEquals(headers[0], hit.next()); - Assertions.assertTrue(hit.hasNext()); - Assertions.assertEquals(headers[3], hit.next()); - Assertions.assertFalse(hit.hasNext()); + Assertions.assertThat(hit.hasNext()).isTrue(); + Assertions.assertThat(hit.next()).isEqualTo(headers[0]); + Assertions.assertThat(hit.hasNext()).isTrue(); + Assertions.assertThat(hit.next()).isEqualTo(headers[3]); + Assertions.assertThat(hit.hasNext()).isFalse(); // with filter, one match hit = new BasicHeaderIterator(headers, "single"); - Assertions.assertTrue(hit.hasNext()); - Assertions.assertEquals(headers[2], hit.next()); - Assertions.assertFalse(hit.hasNext()); + Assertions.assertThat(hit.hasNext()).isTrue(); + Assertions.assertThat(hit.next()).isEqualTo(headers[2]); + Assertions.assertThat(hit.hasNext()).isFalse(); // with filter, no match hit = new BasicHeaderIterator(headers, "way-off"); - Assertions.assertFalse(hit.hasNext()); + Assertions.assertThat(hit.hasNext()).isFalse(); } @@ -138,91 +138,95 @@ void testInterspersed() { // without filter Iterator
hit = new BasicHeaderIterator(headers, null); - Assertions.assertTrue(hit.hasNext()); - Assertions.assertEquals(headers[0], hit.next(), "0"); - Assertions.assertTrue(hit.hasNext()); - Assertions.assertEquals(headers[1], hit.next(), "1"); - Assertions.assertTrue(hit.hasNext()); - Assertions.assertEquals(headers[2], hit.next(), "2"); - Assertions.assertTrue(hit.hasNext()); - Assertions.assertEquals(headers[3], hit.next(), "3"); - Assertions.assertTrue(hit.hasNext()); - Assertions.assertEquals(headers[4], hit.next(), "4"); - Assertions.assertTrue(hit.hasNext()); - Assertions.assertEquals(headers[5], hit.next(), "5"); - Assertions.assertTrue(hit.hasNext()); - Assertions.assertEquals(headers[6], hit.next(), "6"); - Assertions.assertTrue(hit.hasNext()); - Assertions.assertEquals(headers[7], hit.next(), "7"); - Assertions.assertTrue(hit.hasNext()); - Assertions.assertEquals(headers[8], hit.next(), "8"); - Assertions.assertTrue(hit.hasNext()); - Assertions.assertEquals(headers[9], hit.next(), "9"); - Assertions.assertTrue(hit.hasNext()); - Assertions.assertEquals(headers[10], hit.next(), "a"); - Assertions.assertTrue(hit.hasNext()); - Assertions.assertEquals(headers[11], hit.next(), "b"); - Assertions.assertTrue(hit.hasNext()); - Assertions.assertEquals(headers[12], hit.next(), "c"); - Assertions.assertTrue(hit.hasNext()); - Assertions.assertEquals(headers[13], hit.next(), "d"); - Assertions.assertTrue(hit.hasNext()); - Assertions.assertEquals(headers[14], hit.next(), "e"); - Assertions.assertFalse(hit.hasNext()); + Assertions.assertThat(hit.hasNext()).isTrue(); + Assertions.assertThat(hit.next()).withFailMessage("0").isEqualTo(headers[0]); + Assertions.assertThat(hit.hasNext()).isTrue(); + Assertions.assertThat(hit.next()).withFailMessage("1").isEqualTo(headers[1]); + Assertions.assertThat(hit.hasNext()).isTrue(); + Assertions.assertThat(hit.next()).withFailMessage("2").isEqualTo(headers[2]); + Assertions.assertThat(hit.hasNext()).isTrue(); + Assertions.assertThat(hit.next()).withFailMessage("3").isEqualTo(headers[3]); + Assertions.assertThat(hit.hasNext()).isTrue(); + Assertions.assertThat(hit.next()).withFailMessage("4").isEqualTo(headers[4]); + Assertions.assertThat(hit.hasNext()).isTrue(); + Assertions.assertThat(hit.next()).withFailMessage("5").isEqualTo(headers[5]); + Assertions.assertThat(hit.hasNext()).isTrue(); + Assertions.assertThat(hit.next()).withFailMessage("6").isEqualTo(headers[6]); + Assertions.assertThat(hit.hasNext()).isTrue(); + Assertions.assertThat(hit.next()).withFailMessage("7").isEqualTo(headers[7]); + Assertions.assertThat(hit.hasNext()).isTrue(); + Assertions.assertThat(hit.next()).withFailMessage("8").isEqualTo(headers[8]); + Assertions.assertThat(hit.hasNext()).isTrue(); + Assertions.assertThat(hit.next()).withFailMessage("9").isEqualTo(headers[9]); + Assertions.assertThat(hit.hasNext()).isTrue(); + Assertions.assertThat(hit.next()).withFailMessage("a").isEqualTo(headers[10]); + Assertions.assertThat(hit.hasNext()).isTrue(); + Assertions.assertThat(hit.next()).withFailMessage("b").isEqualTo(headers[11]); + Assertions.assertThat(hit.hasNext()).isTrue(); + Assertions.assertThat(hit.next()).withFailMessage("c").isEqualTo(headers[12]); + Assertions.assertThat(hit.hasNext()).isTrue(); + Assertions.assertThat(hit.next()).withFailMessage("d").isEqualTo(headers[13]); + Assertions.assertThat(hit.hasNext()).isTrue(); + Assertions.assertThat(hit.next()).withFailMessage("e").isEqualTo(headers[14]); + Assertions.assertThat(hit.hasNext()).isFalse(); // yellow 0, 5, 9, 11, 13 hit = new BasicHeaderIterator(headers, "Yellow"); - Assertions.assertTrue(hit.hasNext()); - Assertions.assertEquals(headers[0], hit.next()); - Assertions.assertTrue(hit.hasNext()); - Assertions.assertEquals(headers[5], hit.next(), "5"); - Assertions.assertTrue(hit.hasNext()); - Assertions.assertEquals(headers[9], hit.next(), "9"); - Assertions.assertTrue(hit.hasNext()); - Assertions.assertEquals(headers[11], hit.next(), "b"); - Assertions.assertTrue(hit.hasNext()); - Assertions.assertEquals(headers[13], hit.next(), "d"); - Assertions.assertFalse(hit.hasNext()); + Assertions.assertThat(hit.hasNext()).isTrue(); + Assertions.assertThat(hit.next()).isEqualTo(headers[0]); + Assertions.assertThat(hit.hasNext()).isTrue(); + Assertions.assertThat(hit.next()).withFailMessage("5").isEqualTo(headers[5]); + Assertions.assertThat(hit.hasNext()).isTrue(); + Assertions.assertThat(hit.next()).withFailMessage("9").isEqualTo(headers[9]); + Assertions.assertThat(hit.hasNext()).isTrue(); + Assertions.assertThat(hit.next()).withFailMessage("b").isEqualTo(headers[11]); + Assertions.assertThat(hit.hasNext()).isTrue(); + Assertions.assertThat(hit.next()).withFailMessage("d").isEqualTo(headers[13]); + Assertions.assertThat(hit.hasNext()).isFalse(); // maroon 1, 6, 7, 8, 10 hit = new BasicHeaderIterator(headers, "marOOn"); - Assertions.assertTrue(hit.hasNext()); - Assertions.assertEquals(headers[1], hit.next(),"1"); - Assertions.assertTrue(hit.hasNext()); - Assertions.assertEquals(headers[6], hit.next(),"6"); - Assertions.assertTrue(hit.hasNext()); - Assertions.assertEquals(headers[7], hit.next(), "7"); - Assertions.assertTrue(hit.hasNext()); - Assertions.assertEquals(headers[8], hit.next(), "8"); - Assertions.assertTrue(hit.hasNext()); - Assertions.assertEquals(headers[10], hit.next(), "a"); - Assertions.assertFalse(hit.hasNext()); + Assertions.assertThat(hit.hasNext()).isTrue(); + Assertions.assertThat(hit.next()).withFailMessage("1").isEqualTo(headers[1]); + Assertions.assertThat(hit.hasNext()).isTrue(); + Assertions.assertThat(hit.next()).withFailMessage("6").isEqualTo(headers[6]); + Assertions.assertThat(hit.hasNext()).isTrue(); + Assertions.assertThat(hit.next()).withFailMessage("7").isEqualTo(headers[7]); + Assertions.assertThat(hit.hasNext()).isTrue(); + Assertions.assertThat(hit.next()).withFailMessage("8").isEqualTo(headers[8]); + Assertions.assertThat(hit.hasNext()).isTrue(); + Assertions.assertThat(hit.next()).withFailMessage("a").isEqualTo(headers[10]); + Assertions.assertThat(hit.hasNext()).isFalse(); // orange 2, 3, 4, 12, 14 hit = new BasicHeaderIterator(headers, "OranGe"); - Assertions.assertTrue(hit.hasNext()); - Assertions.assertEquals(headers[2], hit.next()); - Assertions.assertTrue(hit.hasNext()); - Assertions.assertEquals(headers[3], hit.next()); - Assertions.assertTrue(hit.hasNext()); - Assertions.assertEquals(headers[4], hit.next(), "4"); - Assertions.assertTrue(hit.hasNext()); - Assertions.assertEquals(headers[12], hit.next(), "b"); - Assertions.assertTrue(hit.hasNext()); - Assertions.assertEquals(headers[14], hit.next(), "e"); - Assertions.assertFalse(hit.hasNext()); + Assertions.assertThat(hit.hasNext()).isTrue(); + Assertions.assertThat(hit.next()).isEqualTo(headers[2]); + Assertions.assertThat(hit.hasNext()).isTrue(); + Assertions.assertThat(hit.next()).isEqualTo(headers[3]); + Assertions.assertThat(hit.hasNext()).isTrue(); + Assertions.assertThat(hit.next()).withFailMessage("4").isEqualTo(headers[4]); + Assertions.assertThat(hit.hasNext()).isTrue(); + Assertions.assertThat(hit.next()).withFailMessage("b").isEqualTo(headers[12]); + Assertions.assertThat(hit.hasNext()).isTrue(); + Assertions.assertThat(hit.next()).withFailMessage("e").isEqualTo(headers[14]); + Assertions.assertThat(hit.hasNext()).isFalse(); } @Test void testInvalid() { - Assertions.assertThrows(NullPointerException.class, () -> new BasicHeaderIterator(null, "whatever")); + Assertions.assertThatThrownBy(() -> + new BasicHeaderIterator(null, "whatever")) + .isInstanceOf(NullPointerException.class); // this is not invalid final Iterator
hit = new BasicHeaderIterator(new Header[0], "whatever"); - Assertions.assertFalse(hit.hasNext()); + Assertions.assertThat(hit.hasNext()).isFalse(); // but this is - Assertions.assertThrows(NoSuchElementException.class, () -> hit.next()); + Assertions.assertThatThrownBy(() -> + hit.next()) + .isInstanceOf(NoSuchElementException.class); } @Test @@ -238,18 +242,20 @@ void testRemaining() { // without filter, using plain next() final Iterator
hit = new BasicHeaderIterator(headers, null); - Assertions.assertTrue(hit.hasNext()); - Assertions.assertEquals(headers[0], hit.next(), "0"); - Assertions.assertTrue(hit.hasNext()); - Assertions.assertEquals(headers[1], hit.next(), "1"); - Assertions.assertTrue(hit.hasNext()); - Assertions.assertEquals(headers[2], hit.next(), "2"); - Assertions.assertTrue(hit.hasNext()); - Assertions.assertEquals(headers[3], hit.next(), "3"); - Assertions.assertFalse(hit.hasNext()); + Assertions.assertThat(hit.hasNext()).isTrue(); + Assertions.assertThat(hit.next()).withFailMessage("0").isEqualTo(headers[0]); + Assertions.assertThat(hit.hasNext()).isTrue(); + Assertions.assertThat(hit.next()).withFailMessage("1").isEqualTo(headers[1]); + Assertions.assertThat(hit.hasNext()).isTrue(); + Assertions.assertThat(hit.next()).withFailMessage("2").isEqualTo(headers[2]); + Assertions.assertThat(hit.hasNext()).isTrue(); + Assertions.assertThat(hit.next()).withFailMessage("3").isEqualTo(headers[3]); + Assertions.assertThat(hit.hasNext()).isFalse(); final Iterator
hit2 = new BasicHeaderIterator(headers, null); - Assertions.assertTrue(hit2.hasNext()); - Assertions.assertThrows(UnsupportedOperationException.class, () -> hit2.remove()); + Assertions.assertThat(hit2.hasNext()).isTrue(); + Assertions.assertThatThrownBy(() -> + hit2.remove()) + .isInstanceOf(UnsupportedOperationException.class); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/message/TestBasicHeaderValueFormatter.java b/httpcore5/src/test/java/org/apache/hc/core5/http/message/TestBasicHeaderValueFormatter.java index 079ad8caa3..751107df83 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/message/TestBasicHeaderValueFormatter.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/message/TestBasicHeaderValueFormatter.java @@ -29,7 +29,7 @@ import org.apache.hc.core5.http.HeaderElement; import org.apache.hc.core5.http.NameValuePair; import org.apache.hc.core5.util.CharArrayBuffer; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -61,47 +61,47 @@ void testNVPFormatting() { buf.clear(); this.formatter.formatNameValuePair(buf, param1, false); - Assertions.assertEquals("param=regular_stuff", buf.toString()); + Assertions.assertThat(buf.toString()).isEqualTo("param=regular_stuff"); buf.clear(); this.formatter.formatNameValuePair(buf, param2, false); - Assertions.assertEquals("param=\"this\\\\that\"", buf.toString()); + Assertions.assertThat(buf.toString()).isEqualTo("param=\"this\\\\that\""); buf.clear(); this.formatter.formatNameValuePair(buf, param3, false); - Assertions.assertEquals("param=\"this,that\"", buf.toString()); + Assertions.assertThat(buf.toString()).isEqualTo("param=\"this,that\""); buf.clear(); this.formatter.formatNameValuePair(buf, param4, false); - Assertions.assertEquals("param=\"quote marks (\\\") must be escaped\"", buf.toString()); + Assertions.assertThat(buf.toString()).isEqualTo("param=\"quote marks (\\\") must be escaped\""); buf.clear(); this.formatter.formatNameValuePair(buf, param5, false); - Assertions.assertEquals("param=\"back slash (\\\\) must be escaped too\"", buf.toString()); + Assertions.assertThat(buf.toString()).isEqualTo("param=\"back slash (\\\\) must be escaped too\""); buf.clear(); this.formatter.formatNameValuePair(buf, param6, false); - Assertions.assertEquals("param=\"values with\tblanks must always be quoted\"", buf.toString()); + Assertions.assertThat(buf.toString()).isEqualTo("param=\"values with\tblanks must always be quoted\""); buf.clear(); this.formatter.formatNameValuePair(buf, param7, false); - Assertions.assertEquals("param", buf.toString()); + Assertions.assertThat(buf.toString()).isEqualTo("param"); buf.clear(); this.formatter.formatNameValuePair(buf, param1, true); - Assertions.assertEquals("param=\"regular_stuff\"", buf.toString()); + Assertions.assertThat(buf.toString()).isEqualTo("param=\"regular_stuff\""); buf.clear(); this.formatter.formatNameValuePair(buf, param2, true); - Assertions.assertEquals("param=\"this\\\\that\"", buf.toString()); + Assertions.assertThat(buf.toString()).isEqualTo("param=\"this\\\\that\""); buf.clear(); this.formatter.formatNameValuePair(buf, param3, true); - Assertions.assertEquals("param=\"this,that\"", buf.toString()); + Assertions.assertThat(buf.toString()).isEqualTo("param=\"this,that\""); buf.clear(); this.formatter.formatNameValuePair(buf, param4, true); - Assertions.assertEquals("param=\"quote marks (\\\") must be escaped\"", buf.toString()); + Assertions.assertThat(buf.toString()).isEqualTo("param=\"quote marks (\\\") must be escaped\""); buf.clear(); this.formatter.formatNameValuePair(buf, param5, true); - Assertions.assertEquals("param=\"back slash (\\\\) must be escaped too\"", buf.toString()); + Assertions.assertThat(buf.toString()).isEqualTo("param=\"back slash (\\\\) must be escaped too\""); buf.clear(); this.formatter.formatNameValuePair(buf, param6, true); - Assertions.assertEquals("param=\"values with\tblanks must always be quoted\"", buf.toString()); + Assertions.assertThat(buf.toString()).isEqualTo("param=\"values with\tblanks must always be quoted\""); buf.clear(); this.formatter.formatNameValuePair(buf, param7, true); - Assertions.assertEquals("param", buf.toString()); + Assertions.assertThat(buf.toString()).isEqualTo("param"); } @Test @@ -115,12 +115,10 @@ void testParamsFormatting() { buf.clear(); this.formatter.formatParameters(buf, params, false); - Assertions.assertEquals("param=regular_stuff; param=\"this\\\\that\"; param=\"this,that\"", - buf.toString()); + Assertions.assertThat(buf.toString()).isEqualTo("param=regular_stuff; param=\"this\\\\that\"; param=\"this,that\""); buf.clear(); this.formatter.formatParameters(buf, params, true); - Assertions.assertEquals("param=\"regular_stuff\"; param=\"this\\\\that\"; param=\"this,that\"", - buf.toString()); + Assertions.assertThat(buf.toString()).isEqualTo("param=\"regular_stuff\"; param=\"this\\\\that\"; param=\"this,that\""); } @Test @@ -135,8 +133,7 @@ void testHEFormatting() { final CharArrayBuffer buf = new CharArrayBuffer(64); this.formatter.formatHeaderElement(buf, element, false); - Assertions.assertEquals("name=value; param=regular_stuff; param=\"this\\\\that\"; param=\"this,that\"; param", - buf.toString()); + Assertions.assertThat(buf.toString()).isEqualTo("name=value; param=regular_stuff; param=\"this\\\\that\"; param=\"this,that\"; param"); } @Test @@ -155,9 +152,9 @@ void testElementsFormatting() { final CharArrayBuffer buf = new CharArrayBuffer(64); this.formatter.formatElements(buf, elements, false); - Assertions.assertEquals("name1=value1; param=regular_stuff, name2=value2; " + + Assertions.assertThat(buf.toString()).isEqualTo("name1=value1; param=regular_stuff, name2=value2; " + "param=\"this\\\\that\", name3=value3; param=\"this,that\", " + - "name4=value4; param, name5", buf.toString()); + "name4=value4; param, name5"); } @@ -169,22 +166,22 @@ void testInvalidArguments() { final HeaderElement element = new BasicHeaderElement("name1", "value1", (NameValuePair[]) null); final HeaderElement[] elements = new HeaderElement[] {element}; - Assertions.assertThrows(NullPointerException.class, () -> - formatter.formatNameValuePair(null, param, false)); - Assertions.assertThrows(NullPointerException.class, () -> - formatter.formatNameValuePair(buf, null, false)); - Assertions.assertThrows(NullPointerException.class, () -> - formatter.formatParameters(null, params, false)); - Assertions.assertThrows(NullPointerException.class, () -> - formatter.formatParameters(buf, null, false)); - Assertions.assertThrows(NullPointerException.class, () -> - formatter.formatHeaderElement(null, element, false)); - Assertions.assertThrows(NullPointerException.class, () -> - formatter.formatHeaderElement(buf, null, false)); - Assertions.assertThrows(NullPointerException.class, () -> - formatter.formatElements(null, elements, false)); - Assertions.assertThrows(NullPointerException.class, () -> - formatter.formatElements(buf, null, false)); + Assertions.assertThatThrownBy(() -> + formatter.formatNameValuePair(null, param, false)).isInstanceOf(NullPointerException.class); + Assertions.assertThatThrownBy(() -> + formatter.formatNameValuePair(buf, null, false)).isInstanceOf(NullPointerException.class); + Assertions.assertThatThrownBy(() -> + formatter.formatParameters(null, params, false)).isInstanceOf(NullPointerException.class); + Assertions.assertThatThrownBy(() -> + formatter.formatParameters(buf, null, false)).isInstanceOf(NullPointerException.class); + Assertions.assertThatThrownBy(() -> + formatter.formatHeaderElement(null, element, false)).isInstanceOf(NullPointerException.class); + Assertions.assertThatThrownBy(() -> + formatter.formatHeaderElement(buf, null, false)).isInstanceOf(NullPointerException.class); + Assertions.assertThatThrownBy(() -> + formatter.formatElements(null, elements, false)).isInstanceOf(NullPointerException.class); + Assertions.assertThatThrownBy(() -> + formatter.formatElements(buf, null, false)).isInstanceOf(NullPointerException.class); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/message/TestBasicHeaderValueParser.java b/httpcore5/src/test/java/org/apache/hc/core5/http/message/TestBasicHeaderValueParser.java index 0c0f672f81..d0249e5b0b 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/message/TestBasicHeaderValueParser.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/message/TestBasicHeaderValueParser.java @@ -29,7 +29,7 @@ import org.apache.hc.core5.http.HeaderElement; import org.apache.hc.core5.http.NameValuePair; import org.apache.hc.core5.util.CharArrayBuffer; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -56,32 +56,32 @@ void testParseHeaderElements() { final ParserCursor cursor = new ParserCursor(0, buf.length()); final HeaderElement[] elements = this.parser.parseElements(buf, cursor); // there are 3 elements - Assertions.assertEquals(3,elements.length); + Assertions.assertThat(elements.length).isEqualTo(3); // 1st element - Assertions.assertEquals("name1",elements[0].getName()); - Assertions.assertEquals("value1",elements[0].getValue()); + Assertions.assertThat(elements[0].getName()).isEqualTo("name1"); + Assertions.assertThat(elements[0].getValue()).isEqualTo("value1"); // 1st element has 2 getParameters() - Assertions.assertEquals(2,elements[0].getParameters().length); - Assertions.assertEquals("name2",elements[0].getParameters()[0].getName()); - Assertions.assertNull(elements[0].getParameters()[0].getValue()); - Assertions.assertEquals("name3",elements[0].getParameters()[1].getName()); - Assertions.assertEquals("value3",elements[0].getParameters()[1].getValue()); + Assertions.assertThat(elements[0].getParameters().length).isEqualTo(2); + Assertions.assertThat(elements[0].getParameters()[0].getName()).isEqualTo("name2"); + Assertions.assertThat(elements[0].getParameters()[0].getValue()).isNull(); + Assertions.assertThat(elements[0].getParameters()[1].getName()).isEqualTo("name3"); + Assertions.assertThat(elements[0].getParameters()[1].getValue()).isEqualTo("value3"); // 2nd element - Assertions.assertEquals("name4",elements[1].getName()); - Assertions.assertEquals("value4",elements[1].getValue()); + Assertions.assertThat(elements[1].getName()).isEqualTo("name4"); + Assertions.assertThat(elements[1].getValue()).isEqualTo("value4"); // 2nd element has 1 parameter - Assertions.assertEquals(1,elements[1].getParameters().length); - Assertions.assertEquals("name5",elements[1].getParameters()[0].getName()); - Assertions.assertEquals("value5",elements[1].getParameters()[0].getValue()); + Assertions.assertThat(elements[1].getParameters().length).isEqualTo(1); + Assertions.assertThat(elements[1].getParameters()[0].getName()).isEqualTo("name5"); + Assertions.assertThat(elements[1].getParameters()[0].getValue()).isEqualTo("value5"); // 3rd element - Assertions.assertEquals("name6",elements[2].getName()); - Assertions.assertEquals("",elements[2].getValue()); + Assertions.assertThat(elements[2].getName()).isEqualTo("name6"); + Assertions.assertThat(elements[2].getValue()).isEqualTo(""); // 3rd element has 2 getParameters() - Assertions.assertEquals(2,elements[2].getParameters().length); - Assertions.assertEquals("name7",elements[2].getParameters()[0].getName()); - Assertions.assertEquals("value7",elements[2].getParameters()[0].getValue()); - Assertions.assertEquals("name8",elements[2].getParameters()[1].getName()); - Assertions.assertEquals(" value8",elements[2].getParameters()[1].getValue()); + Assertions.assertThat(elements[2].getParameters().length).isEqualTo(2); + Assertions.assertThat(elements[2].getParameters()[0].getName()).isEqualTo("name7"); + Assertions.assertThat(elements[2].getParameters()[0].getValue()).isEqualTo("value7"); + Assertions.assertThat(elements[2].getParameters()[1].getName()).isEqualTo("name8"); + Assertions.assertThat(elements[2].getParameters()[1].getValue()).isEqualTo(" value8"); } @Test @@ -92,13 +92,13 @@ void testParseHEEscaped() { buf.append(headerValue); final ParserCursor cursor = new ParserCursor(0, buf.length()); final HeaderElement[] elements = this.parser.parseElements(buf, cursor); - Assertions.assertEquals(3, elements.length); - Assertions.assertEquals("test1", elements[0].getName()); - Assertions.assertEquals("\"stuff\"", elements[0].getValue()); - Assertions.assertEquals("test2", elements[1].getName()); - Assertions.assertEquals("\\", elements[1].getValue()); - Assertions.assertEquals("test3", elements[2].getName()); - Assertions.assertEquals("stuff, stuff", elements[2].getValue()); + Assertions.assertThat(elements.length).isEqualTo(3); + Assertions.assertThat(elements[0].getName()).isEqualTo("test1"); + Assertions.assertThat(elements[0].getValue()).isEqualTo("\"stuff\""); + Assertions.assertThat(elements[1].getName()).isEqualTo("test2"); + Assertions.assertThat(elements[1].getValue()).isEqualTo("\\"); + Assertions.assertThat(elements[2].getName()).isEqualTo("test3"); + Assertions.assertThat(elements[2].getValue()).isEqualTo("stuff, stuff"); } @Test @@ -108,7 +108,7 @@ void testHEFringeCase1() { buf.append(headerValue); final ParserCursor cursor = new ParserCursor(0, buf.length()); final HeaderElement[] elements = this.parser.parseElements(buf, cursor); - Assertions.assertEquals(1, elements.length, "Number of elements"); + Assertions.assertThat(elements.length).withFailMessage("Number of elements").isEqualTo(1); } @Test @@ -118,7 +118,7 @@ void testHEFringeCase2() { buf.append(headerValue); final ParserCursor cursor = new ParserCursor(0, buf.length()); final HeaderElement[] elements = this.parser.parseElements(buf, cursor); - Assertions.assertEquals(1, elements.length, "Number of elements"); + Assertions.assertThat(elements.length).withFailMessage("Number of elements").isEqualTo(1); } @Test @@ -128,7 +128,7 @@ void testHEFringeCase3() { buf.append(headerValue); final ParserCursor cursor = new ParserCursor(0, buf.length()); final HeaderElement[] elements = this.parser.parseElements(buf, cursor); - Assertions.assertEquals(0, elements.length, "Number of elements"); + Assertions.assertThat(elements.length).withFailMessage("Number of elements").isEqualTo(0); } @Test @@ -140,10 +140,10 @@ void testNVParse() { ParserCursor cursor = new ParserCursor(0, s.length()); NameValuePair param = this.parser.parseNameValuePair(buffer, cursor); - Assertions.assertEquals("test", param.getName()); - Assertions.assertNull(param.getValue()); - Assertions.assertEquals(s.length(), cursor.getPos()); - Assertions.assertTrue(cursor.atEnd()); + Assertions.assertThat(param.getName()).isEqualTo("test"); + Assertions.assertThat(param.getValue()).isNull(); + Assertions.assertThat(cursor.getPos()).isEqualTo(s.length()); + Assertions.assertThat(cursor.atEnd()).isTrue(); s = "test;"; buffer = new CharArrayBuffer(16); @@ -151,10 +151,10 @@ void testNVParse() { cursor = new ParserCursor(0, s.length()); param = this.parser.parseNameValuePair(buffer, cursor); - Assertions.assertEquals("test", param.getName()); - Assertions.assertNull(param.getValue()); - Assertions.assertEquals(s.length() - 1, cursor.getPos()); - Assertions.assertFalse(cursor.atEnd()); + Assertions.assertThat(param.getName()).isEqualTo("test"); + Assertions.assertThat(param.getValue()).isNull(); + Assertions.assertThat(cursor.getPos()).isEqualTo(s.length() - 1); + Assertions.assertThat(cursor.atEnd()).isFalse(); s = "test ,12"; buffer = new CharArrayBuffer(16); @@ -162,10 +162,10 @@ void testNVParse() { cursor = new ParserCursor(0, s.length()); param = this.parser.parseNameValuePair(buffer, cursor); - Assertions.assertEquals("test", param.getName()); - Assertions.assertNull(param.getValue()); - Assertions.assertEquals(s.length() - 3, cursor.getPos()); - Assertions.assertFalse(cursor.atEnd()); + Assertions.assertThat(param.getName()).isEqualTo("test"); + Assertions.assertThat(param.getValue()).isNull(); + Assertions.assertThat(cursor.getPos()).isEqualTo(s.length() - 3); + Assertions.assertThat(cursor.atEnd()).isFalse(); s = "test=stuff"; buffer = new CharArrayBuffer(16); @@ -173,10 +173,10 @@ void testNVParse() { cursor = new ParserCursor(0, s.length()); param = this.parser.parseNameValuePair(buffer, cursor); - Assertions.assertEquals("test", param.getName()); - Assertions.assertEquals("stuff", param.getValue()); - Assertions.assertEquals(s.length(), cursor.getPos()); - Assertions.assertTrue(cursor.atEnd()); + Assertions.assertThat(param.getName()).isEqualTo("test"); + Assertions.assertThat(param.getValue()).isEqualTo("stuff"); + Assertions.assertThat(cursor.getPos()).isEqualTo(s.length()); + Assertions.assertThat(cursor.atEnd()).isTrue(); s = " test = stuff "; buffer = new CharArrayBuffer(16); @@ -184,10 +184,10 @@ void testNVParse() { cursor = new ParserCursor(0, s.length()); param = this.parser.parseNameValuePair(buffer, cursor); - Assertions.assertEquals("test", param.getName()); - Assertions.assertEquals("stuff", param.getValue()); - Assertions.assertEquals(s.length(), cursor.getPos()); - Assertions.assertTrue(cursor.atEnd()); + Assertions.assertThat(param.getName()).isEqualTo("test"); + Assertions.assertThat(param.getValue()).isEqualTo("stuff"); + Assertions.assertThat(cursor.getPos()).isEqualTo(s.length()); + Assertions.assertThat(cursor.atEnd()).isTrue(); s = " test = stuff ;1234"; buffer = new CharArrayBuffer(16); @@ -195,10 +195,10 @@ void testNVParse() { cursor = new ParserCursor(0, s.length()); param = this.parser.parseNameValuePair(buffer, cursor); - Assertions.assertEquals("test", param.getName()); - Assertions.assertEquals("stuff", param.getValue()); - Assertions.assertEquals(s.length() - 5, cursor.getPos()); - Assertions.assertFalse(cursor.atEnd()); + Assertions.assertThat(param.getName()).isEqualTo("test"); + Assertions.assertThat(param.getValue()).isEqualTo("stuff"); + Assertions.assertThat(cursor.getPos()).isEqualTo(s.length() - 5); + Assertions.assertThat(cursor.atEnd()).isFalse(); s = "test = \"stuff\""; buffer = new CharArrayBuffer(16); @@ -206,8 +206,8 @@ void testNVParse() { cursor = new ParserCursor(0, s.length()); param = this.parser.parseNameValuePair(buffer, cursor); - Assertions.assertEquals("test", param.getName()); - Assertions.assertEquals("stuff", param.getValue()); + Assertions.assertThat(param.getName()).isEqualTo("test"); + Assertions.assertThat(param.getValue()).isEqualTo("stuff"); s = "test = \" stuff\\\"\""; buffer = new CharArrayBuffer(16); @@ -215,8 +215,8 @@ void testNVParse() { cursor = new ParserCursor(0, s.length()); param = this.parser.parseNameValuePair(buffer, cursor); - Assertions.assertEquals("test", param.getName()); - Assertions.assertEquals(" stuff\"", param.getValue()); + Assertions.assertThat(param.getName()).isEqualTo("test"); + Assertions.assertThat(param.getValue()).isEqualTo(" stuff\""); s = " test"; buffer = new CharArrayBuffer(16); @@ -224,8 +224,8 @@ void testNVParse() { cursor = new ParserCursor(0, s.length()); param = this.parser.parseNameValuePair(buffer, cursor); - Assertions.assertEquals("test", param.getName()); - Assertions.assertNull(param.getValue()); + Assertions.assertThat(param.getName()).isEqualTo("test"); + Assertions.assertThat(param.getValue()).isNull(); s = " "; buffer = new CharArrayBuffer(16); @@ -233,8 +233,8 @@ void testNVParse() { cursor = new ParserCursor(0, s.length()); param = this.parser.parseNameValuePair(buffer, cursor); - Assertions.assertEquals("", param.getName()); - Assertions.assertNull(param.getValue()); + Assertions.assertThat(param.getName()).isEqualTo(""); + Assertions.assertThat(param.getValue()).isNull(); s = " = stuff "; buffer = new CharArrayBuffer(16); @@ -242,8 +242,8 @@ void testNVParse() { cursor = new ParserCursor(0, s.length()); param = this.parser.parseNameValuePair(buffer, cursor); - Assertions.assertEquals("", param.getName()); - Assertions.assertEquals("stuff", param.getValue()); + Assertions.assertThat(param.getName()).isEqualTo(""); + Assertions.assertThat(param.getValue()).isEqualTo("stuff"); } @Test @@ -255,16 +255,16 @@ void testNVParseAll() { ParserCursor cursor = new ParserCursor(0, s.length()); NameValuePair[] params = this.parser.parseParameters(buffer, cursor); - Assertions.assertEquals("test", params[0].getName()); - Assertions.assertNull(params[0].getValue()); - Assertions.assertEquals("test1", params[1].getName()); - Assertions.assertEquals("stuff", params[1].getValue()); - Assertions.assertEquals("test2", params[2].getName()); - Assertions.assertEquals("stuff; stuff", params[2].getValue()); - Assertions.assertEquals("test3", params[3].getName()); - Assertions.assertEquals("stuff", params[3].getValue()); - Assertions.assertEquals(s.length(), cursor.getPos()); - Assertions.assertTrue(cursor.atEnd()); + Assertions.assertThat(params[0].getName()).isEqualTo("test"); + Assertions.assertThat(params[0].getValue()).isNull(); + Assertions.assertThat(params[1].getName()).isEqualTo("test1"); + Assertions.assertThat(params[1].getValue()).isEqualTo("stuff"); + Assertions.assertThat(params[2].getName()).isEqualTo("test2"); + Assertions.assertThat(params[2].getValue()).isEqualTo("stuff; stuff"); + Assertions.assertThat(params[3].getName()).isEqualTo("test3"); + Assertions.assertThat(params[3].getValue()).isEqualTo("stuff"); + Assertions.assertThat(cursor.getPos()).isEqualTo(s.length()); + Assertions.assertThat(cursor.atEnd()).isTrue(); s = "test; test1 = stuff ; test2 = \"stuff; stuff\"; test3=\"stuff\",123"; @@ -273,23 +273,23 @@ void testNVParseAll() { cursor = new ParserCursor(0, s.length()); params = this.parser.parseParameters(buffer, cursor); - Assertions.assertEquals("test", params[0].getName()); - Assertions.assertNull(params[0].getValue()); - Assertions.assertEquals("test1", params[1].getName()); - Assertions.assertEquals("stuff", params[1].getValue()); - Assertions.assertEquals("test2", params[2].getName()); - Assertions.assertEquals("stuff; stuff", params[2].getValue()); - Assertions.assertEquals("test3", params[3].getName()); - Assertions.assertEquals("stuff", params[3].getValue()); - Assertions.assertEquals(s.length() - 4, cursor.getPos()); - Assertions.assertFalse(cursor.atEnd()); + Assertions.assertThat(params[0].getName()).isEqualTo("test"); + Assertions.assertThat(params[0].getValue()).isNull(); + Assertions.assertThat(params[1].getName()).isEqualTo("test1"); + Assertions.assertThat(params[1].getValue()).isEqualTo("stuff"); + Assertions.assertThat(params[2].getName()).isEqualTo("test2"); + Assertions.assertThat(params[2].getValue()).isEqualTo("stuff; stuff"); + Assertions.assertThat(params[3].getName()).isEqualTo("test3"); + Assertions.assertThat(params[3].getValue()).isEqualTo("stuff"); + Assertions.assertThat(cursor.getPos()).isEqualTo(s.length() - 4); + Assertions.assertThat(cursor.atEnd()).isFalse(); s = " "; buffer = new CharArrayBuffer(16); buffer.append(s); cursor = new ParserCursor(0, s.length()); params = this.parser.parseParameters(buffer, cursor); - Assertions.assertEquals(0, params.length); + Assertions.assertThat(params.length).isEqualTo(0); } @Test @@ -300,13 +300,13 @@ void testNVParseEscaped() { buf.append(headerValue); final ParserCursor cursor = new ParserCursor(0, buf.length()); final NameValuePair[] params = this.parser.parseParameters(buf, cursor); - Assertions.assertEquals(3, params.length); - Assertions.assertEquals("test1", params[0].getName()); - Assertions.assertEquals("\"stuff\"", params[0].getValue()); - Assertions.assertEquals("test2", params[1].getName()); - Assertions.assertEquals("\\", params[1].getValue()); - Assertions.assertEquals("test3", params[2].getName()); - Assertions.assertEquals("stuff; stuff", params[2].getValue()); + Assertions.assertThat(params.length).isEqualTo(3); + Assertions.assertThat(params[0].getName()).isEqualTo("test1"); + Assertions.assertThat(params[0].getValue()).isEqualTo("\"stuff\""); + Assertions.assertThat(params[1].getName()).isEqualTo("test2"); + Assertions.assertThat(params[1].getValue()).isEqualTo("\\"); + Assertions.assertThat(params[2].getName()).isEqualTo("test3"); + Assertions.assertThat(params[2].getValue()).isEqualTo("stuff; stuff"); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/message/TestBasicLineFormatter.java b/httpcore5/src/test/java/org/apache/hc/core5/http/message/TestBasicLineFormatter.java index c7892ac912..a28b4ba5f6 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/message/TestBasicLineFormatter.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/message/TestBasicLineFormatter.java @@ -32,7 +32,7 @@ import org.apache.hc.core5.http.HttpVersion; import org.apache.hc.core5.http.Method; import org.apache.hc.core5.util.CharArrayBuffer; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -52,7 +52,7 @@ void setup() { void testHttpVersionFormatting() { final CharArrayBuffer buf = new CharArrayBuffer(64); this.formatter.formatProtocolVersion(buf, HttpVersion.HTTP_1_1); - Assertions.assertEquals("HTTP/1.1", buf.toString()); + Assertions.assertThat(buf.toString()).isEqualTo("HTTP/1.1"); } @Test @@ -60,17 +60,17 @@ void testRLFormatting() { final RequestLine requestline = new RequestLine(Method.GET.name(), "/stuff", HttpVersion.HTTP_1_1); final CharArrayBuffer buf = new CharArrayBuffer(64); this.formatter.formatRequestLine(buf, requestline); - Assertions.assertEquals("GET /stuff HTTP/1.1", buf.toString()); + Assertions.assertThat(buf.toString()).isEqualTo("GET /stuff HTTP/1.1"); } @Test void testRLFormattingInvalidInput() { final CharArrayBuffer buf = new CharArrayBuffer(64); final RequestLine requestline = new RequestLine(Method.GET.name(), "/stuff", HttpVersion.HTTP_1_1); - Assertions.assertThrows(NullPointerException.class, () -> - formatter.formatRequestLine(null, requestline)); - Assertions.assertThrows(NullPointerException.class, () -> - formatter.formatRequestLine(buf, null)); + Assertions.assertThatThrownBy(() -> + formatter.formatRequestLine(null, requestline)).isInstanceOf(NullPointerException.class); + Assertions.assertThatThrownBy(() -> + formatter.formatRequestLine(buf, null)).isInstanceOf(NullPointerException.class); } @Test @@ -78,12 +78,12 @@ void testSLFormatting() { final CharArrayBuffer buf = new CharArrayBuffer(64); final StatusLine statusline1 = new StatusLine(HttpVersion.HTTP_1_1, HttpStatus.SC_OK, "OK"); this.formatter.formatStatusLine(buf, statusline1); - Assertions.assertEquals("HTTP/1.1 200 OK", buf.toString()); + Assertions.assertThat(buf.toString()).isEqualTo("HTTP/1.1 200 OK"); buf.clear(); final StatusLine statusline2 = new StatusLine(HttpVersion.HTTP_1_1, HttpStatus.SC_OK, null); this.formatter.formatStatusLine(buf, statusline2); - Assertions.assertEquals("HTTP/1.1 200 ", buf.toString()); + Assertions.assertThat(buf.toString()).isEqualTo("HTTP/1.1 200 "); // see "testSLParseSuccess" in TestBasicLineParser: // trailing space is correct } @@ -92,10 +92,10 @@ void testSLFormatting() { void testSLFormattingInvalidInput() { final CharArrayBuffer buf = new CharArrayBuffer(64); final StatusLine statusline = new StatusLine(HttpVersion.HTTP_1_1, HttpStatus.SC_OK, "OK"); - Assertions.assertThrows(NullPointerException.class, () -> - formatter.formatStatusLine(null, statusline)); - Assertions.assertThrows(NullPointerException.class, () -> - formatter.formatStatusLine(buf, null)); + Assertions.assertThatThrownBy(() -> + formatter.formatStatusLine(null, statusline)).isInstanceOf(NullPointerException.class); + Assertions.assertThatThrownBy(() -> + formatter.formatStatusLine(buf, null)).isInstanceOf(NullPointerException.class); } @Test @@ -103,22 +103,22 @@ void testHeaderFormatting() { final CharArrayBuffer buf = new CharArrayBuffer(64); final Header header1 = new BasicHeader("name", "value"); this.formatter.formatHeader(buf, header1); - Assertions.assertEquals("name: value", buf.toString()); + Assertions.assertThat(buf.toString()).isEqualTo("name: value"); buf.clear(); final Header header2 = new BasicHeader("name", null); this.formatter.formatHeader(buf, header2); - Assertions.assertEquals("name: ", buf.toString()); + Assertions.assertThat(buf.toString()).isEqualTo("name: "); } @Test void testHeaderFormattingInvalidInput() { final CharArrayBuffer buf = new CharArrayBuffer(64); final Header header = new BasicHeader("name", "value"); - Assertions.assertThrows(NullPointerException.class, () -> - formatter.formatHeader(null, header)); - Assertions.assertThrows(NullPointerException.class, () -> - formatter.formatHeader(buf, null)); + Assertions.assertThatThrownBy(() -> + formatter.formatHeader(null, header)).isInstanceOf(NullPointerException.class); + Assertions.assertThatThrownBy(() -> + formatter.formatHeader(buf, null)).isInstanceOf(NullPointerException.class); } @Test @@ -127,7 +127,7 @@ void testHeaderFormattingRequestSplitting() { final Header header = new BasicHeader("Host", "apache.org\r\nOops: oops"); formatter.formatHeader(buf, header); final String s = buf.toString(); - Assertions.assertFalse(s.contains("\n")); - Assertions.assertEquals("Host: apache.org Oops: oops", s); + Assertions.assertThat(s.contains("\n")).isFalse(); + Assertions.assertThat(s).isEqualTo("Host: apache.org Oops: oops"); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/message/TestBasicLineParser.java b/httpcore5/src/test/java/org/apache/hc/core5/http/message/TestBasicLineParser.java index 30f7b39dd4..0f434ffda6 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/message/TestBasicLineParser.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/message/TestBasicLineParser.java @@ -33,7 +33,7 @@ import org.apache.hc.core5.http.ParseException; import org.apache.hc.core5.http.ProtocolVersion; import org.apache.hc.core5.util.CharArrayBuffer; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -57,27 +57,27 @@ void testRLParse() throws Exception { buf.clear(); buf.append("GET /stuff HTTP/1.1"); RequestLine requestline = this.parser.parseRequestLine(buf); - Assertions.assertEquals("GET /stuff HTTP/1.1", requestline.toString()); - Assertions.assertEquals(Method.GET.name(), requestline.getMethod()); - Assertions.assertEquals("/stuff", requestline.getUri()); - Assertions.assertEquals(HttpVersion.HTTP_1_1, requestline.getProtocolVersion()); + Assertions.assertThat(requestline.toString()).isEqualTo("GET /stuff HTTP/1.1"); + Assertions.assertThat(requestline.getMethod()).isEqualTo(Method.GET.name()); + Assertions.assertThat(requestline.getUri()).isEqualTo("/stuff"); + Assertions.assertThat(requestline.getProtocolVersion()).isEqualTo(HttpVersion.HTTP_1_1); //Lots of blanks buf.clear(); buf.append(" GET /stuff HTTP/1.1 "); requestline = this.parser.parseRequestLine(buf); - Assertions.assertEquals("GET /stuff HTTP/1.1", requestline.toString()); - Assertions.assertEquals(Method.GET.name(), requestline.getMethod()); - Assertions.assertEquals("/stuff", requestline.getUri()); - Assertions.assertEquals(HttpVersion.HTTP_1_1, requestline.getProtocolVersion()); + Assertions.assertThat(requestline.toString()).isEqualTo("GET /stuff HTTP/1.1"); + Assertions.assertThat(requestline.getMethod()).isEqualTo(Method.GET.name()); + Assertions.assertThat(requestline.getUri()).isEqualTo("/stuff"); + Assertions.assertThat(requestline.getProtocolVersion()).isEqualTo(HttpVersion.HTTP_1_1); //this is not strictly valid, but is lenient buf.clear(); buf.append("\rGET /stuff HTTP/1.1"); requestline = this.parser.parseRequestLine(buf); - Assertions.assertEquals(Method.GET.name(), requestline.getMethod()); - Assertions.assertEquals("/stuff", requestline.getUri()); - Assertions.assertEquals(HttpVersion.HTTP_1_1, requestline.getProtocolVersion()); + Assertions.assertThat(requestline.getMethod()).isEqualTo(Method.GET.name()); + Assertions.assertThat(requestline.getUri()).isEqualTo("/stuff"); + Assertions.assertThat(requestline.getProtocolVersion()).isEqualTo(HttpVersion.HTTP_1_1); } @Test @@ -85,19 +85,29 @@ void testRLParseFailure() { final CharArrayBuffer buf = new CharArrayBuffer(64); buf.clear(); buf.append(" "); - Assertions.assertThrows(ParseException.class, () -> parser.parseRequestLine(buf)); + Assertions.assertThatThrownBy(() -> + parser.parseRequestLine(buf)) + .isInstanceOf(ParseException.class); buf.clear(); buf.append(" GET"); - Assertions.assertThrows(ParseException.class, () -> parser.parseRequestLine(buf)); + Assertions.assertThatThrownBy(() -> + parser.parseRequestLine(buf)) + .isInstanceOf(ParseException.class); buf.clear(); buf.append("GET /stuff"); - Assertions.assertThrows(ParseException.class, () -> parser.parseRequestLine(buf)); + Assertions.assertThatThrownBy(() -> + parser.parseRequestLine(buf)) + .isInstanceOf(ParseException.class); buf.clear(); buf.append("GET/stuff HTTP/1.1"); - Assertions.assertThrows(ParseException.class, () -> parser.parseRequestLine(buf)); + Assertions.assertThatThrownBy(() -> + parser.parseRequestLine(buf)) + .isInstanceOf(ParseException.class); buf.clear(); buf.append("GET /stuff HTTP/1.1 Oooooooooooppsie"); - Assertions.assertThrows(ParseException.class, () -> parser.parseRequestLine(buf)); + Assertions.assertThatThrownBy(() -> + parser.parseRequestLine(buf)) + .isInstanceOf(ParseException.class); } @Test @@ -107,66 +117,66 @@ void testSLParse() throws Exception { buf.clear(); buf.append("HTTP/1.1 200 OK"); StatusLine statusLine = this.parser.parseStatusLine(buf); - Assertions.assertEquals("HTTP/1.1 200 OK", statusLine.toString()); - Assertions.assertEquals(HttpVersion.HTTP_1_1, statusLine.getProtocolVersion()); - Assertions.assertEquals(200, statusLine.getStatusCode()); - Assertions.assertEquals("OK", statusLine.getReasonPhrase()); + Assertions.assertThat(statusLine.toString()).isEqualTo("HTTP/1.1 200 OK"); + Assertions.assertThat(statusLine.getProtocolVersion()).isEqualTo(HttpVersion.HTTP_1_1); + Assertions.assertThat(statusLine.getStatusCode()).isEqualTo(200); + Assertions.assertThat(statusLine.getReasonPhrase()).isEqualTo("OK"); //status line with multi word reason phrase buf.clear(); buf.append("HTTP/1.1 404 Not Found"); statusLine = this.parser.parseStatusLine(buf); - Assertions.assertEquals(404, statusLine.getStatusCode()); - Assertions.assertEquals("Not Found", statusLine.getReasonPhrase()); + Assertions.assertThat(statusLine.getStatusCode()).isEqualTo(404); + Assertions.assertThat(statusLine.getReasonPhrase()).isEqualTo("Not Found"); //reason phrase can be anyting buf.clear(); buf.append("HTTP/1.1 404 Non Trouve"); statusLine = this.parser.parseStatusLine(buf); - Assertions.assertEquals("Non Trouve", statusLine.getReasonPhrase()); + Assertions.assertThat(statusLine.getReasonPhrase()).isEqualTo("Non Trouve"); //its ok to end with a \n\r buf.clear(); buf.append("HTTP/1.1 404 Not Found\r\n"); statusLine = this.parser.parseStatusLine(buf); - Assertions.assertEquals("Not Found", statusLine.getReasonPhrase()); + Assertions.assertThat(statusLine.getReasonPhrase()).isEqualTo("Not Found"); //this is valid according to the Status-Line BNF buf.clear(); buf.append("HTTP/1.1 200 "); statusLine = this.parser.parseStatusLine(buf); - Assertions.assertEquals(200, statusLine.getStatusCode()); - Assertions.assertEquals("", statusLine.getReasonPhrase()); + Assertions.assertThat(statusLine.getStatusCode()).isEqualTo(200); + Assertions.assertThat(statusLine.getReasonPhrase()).isEqualTo(""); //this is not strictly valid, but is lenient buf.clear(); buf.append("HTTP/1.1 200"); statusLine = this.parser.parseStatusLine(buf); - Assertions.assertEquals(200, statusLine.getStatusCode()); - Assertions.assertEquals("", statusLine.getReasonPhrase()); + Assertions.assertThat(statusLine.getStatusCode()).isEqualTo(200); + Assertions.assertThat(statusLine.getReasonPhrase()).isEqualTo(""); //this is not strictly valid, but is lenient buf.clear(); buf.append("HTTP/1.1 200 OK"); statusLine = this.parser.parseStatusLine(buf); - Assertions.assertEquals(200, statusLine.getStatusCode()); - Assertions.assertEquals("OK", statusLine.getReasonPhrase()); + Assertions.assertThat(statusLine.getStatusCode()).isEqualTo(200); + Assertions.assertThat(statusLine.getReasonPhrase()).isEqualTo("OK"); //this is not strictly valid, but is lenient buf.clear(); buf.append("\nHTTP/1.1 200 OK"); statusLine = this.parser.parseStatusLine(buf); - Assertions.assertEquals(200, statusLine.getStatusCode()); - Assertions.assertEquals("OK", statusLine.getReasonPhrase()); - Assertions.assertEquals(HttpVersion.HTTP_1_1, statusLine.getProtocolVersion()); + Assertions.assertThat(statusLine.getStatusCode()).isEqualTo(200); + Assertions.assertThat(statusLine.getReasonPhrase()).isEqualTo("OK"); + Assertions.assertThat(statusLine.getProtocolVersion()).isEqualTo(HttpVersion.HTTP_1_1); //this is not strictly valid, but is lenient buf.clear(); buf.append(" HTTP/1.1 200 OK"); statusLine = this.parser.parseStatusLine(buf); - Assertions.assertEquals(200, statusLine.getStatusCode()); - Assertions.assertEquals("OK", statusLine.getReasonPhrase()); - Assertions.assertEquals(HttpVersion.HTTP_1_1, statusLine.getProtocolVersion()); + Assertions.assertThat(statusLine.getStatusCode()).isEqualTo(200); + Assertions.assertThat(statusLine.getReasonPhrase()).isEqualTo("OK"); + Assertions.assertThat(statusLine.getProtocolVersion()).isEqualTo(HttpVersion.HTTP_1_1); } @Test @@ -174,25 +184,39 @@ void testSLParseFailure() { final CharArrayBuffer buf = new CharArrayBuffer(64); buf.clear(); buf.append("xxx 200 OK"); - Assertions.assertThrows(ParseException.class, () -> parser.parseStatusLine(buf)); + Assertions.assertThatThrownBy(() -> + parser.parseStatusLine(buf)) + .isInstanceOf(ParseException.class); buf.clear(); buf.append("HTTP/1.1 xxx OK"); - Assertions.assertThrows(ParseException.class, () -> parser.parseStatusLine(buf)); + Assertions.assertThatThrownBy(() -> + parser.parseStatusLine(buf)) + .isInstanceOf(ParseException.class); buf.clear(); buf.append("HTTP/1.1 "); - Assertions.assertThrows(ParseException.class, () -> parser.parseStatusLine(buf)); + Assertions.assertThatThrownBy(() -> + parser.parseStatusLine(buf)) + .isInstanceOf(ParseException.class); buf.clear(); buf.append("HTTP/1.1"); - Assertions.assertThrows(ParseException.class, () -> parser.parseStatusLine(buf)); + Assertions.assertThatThrownBy(() -> + parser.parseStatusLine(buf)) + .isInstanceOf(ParseException.class); buf.clear(); buf.append("HTTP/1.1 -200 OK"); - Assertions.assertThrows(ParseException.class, () -> parser.parseStatusLine(buf)); + Assertions.assertThatThrownBy(() -> + parser.parseStatusLine(buf)) + .isInstanceOf(ParseException.class); buf.clear(); buf.append("HTTP/1.1 0200 OK"); - Assertions.assertThrows(ParseException.class, () -> parser.parseStatusLine(buf)); + Assertions.assertThatThrownBy(() -> + parser.parseStatusLine(buf)) + .isInstanceOf(ParseException.class); buf.clear(); buf.append("HTTP/1.1 2000 OK"); - Assertions.assertThrows(ParseException.class, () -> parser.parseStatusLine(buf)); + Assertions.assertThatThrownBy(() -> + parser.parseStatusLine(buf)) + .isInstanceOf(ParseException.class); } @Test @@ -202,25 +226,25 @@ void testHttpVersionParsing() throws Exception { final ParserCursor cursor = new ParserCursor(0, buffer.length()); final ProtocolVersion version = parser.parseProtocolVersion(buffer, cursor); - Assertions.assertEquals("HTTP", version.getProtocol(), "HTTP protocol name"); - Assertions.assertEquals(1, version.getMajor(), "HTTP major version number"); - Assertions.assertEquals(1, version.getMinor(), "HTTP minor version number"); - Assertions.assertEquals("HTTP/1.1", version.toString(), "HTTP version number"); - Assertions.assertEquals(buffer.length(), cursor.getPos()); - Assertions.assertTrue(cursor.atEnd()); + Assertions.assertThat(version.getProtocol()).withFailMessage("HTTP protocol name").isEqualTo("HTTP"); + Assertions.assertThat(version.getMajor()).withFailMessage("HTTP major version number").isEqualTo(1); + Assertions.assertThat(version.getMinor()).withFailMessage("HTTP minor version number").isEqualTo(1); + Assertions.assertThat(version.toString()).withFailMessage("HTTP version number").isEqualTo("HTTP/1.1"); + Assertions.assertThat(cursor.getPos()).isEqualTo(buffer.length()); + Assertions.assertThat(cursor.atEnd()).isTrue(); buffer.clear(); buffer.append("HTTP/1.123 123"); final ParserCursor cursor2 = new ParserCursor(0, buffer.length()); final ProtocolVersion version2 = parser.parseProtocolVersion(buffer, cursor2); - Assertions.assertEquals( "HTTP", version2.getProtocol(), "HTTP protocol name"); - Assertions.assertEquals( 1, version2.getMajor(), "HTTP major version number"); - Assertions.assertEquals(123, version2.getMinor(), "HTTP minor version number"); - Assertions.assertEquals("HTTP/1.123", version2.toString(), "HTTP version number"); - Assertions.assertEquals(' ', buffer.charAt(cursor2.getPos())); - Assertions.assertEquals(buffer.length() - 4, cursor2.getPos()); - Assertions.assertFalse(cursor2.atEnd()); + Assertions.assertThat(version2.getProtocol()).withFailMessage("HTTP protocol name").isEqualTo("HTTP"); + Assertions.assertThat(version2.getMajor()).withFailMessage("HTTP major version number").isEqualTo(1); + Assertions.assertThat(version2.getMinor()).withFailMessage("HTTP minor version number").isEqualTo(123); + Assertions.assertThat(version2.toString()).withFailMessage("HTTP version number").isEqualTo("HTTP/1.123"); + Assertions.assertThat(buffer.charAt(cursor2.getPos())).isEqualTo(' '); + Assertions.assertThat(cursor2.getPos()).isEqualTo(buffer.length() - 4); + Assertions.assertThat(cursor2.atEnd()).isFalse(); } @Test @@ -229,43 +253,43 @@ void testInvalidHttpVersionParsing() { buffer.clear(); buffer.append(" "); final ParserCursor cursor1 = new ParserCursor(0, buffer.length()); - Assertions.assertThrows(ParseException.class, () -> - parser.parseProtocolVersion(buffer, cursor1)); + Assertions.assertThatThrownBy(() -> + parser.parseProtocolVersion(buffer, cursor1)).isInstanceOf(ParseException.class); buffer.clear(); buffer.append("HTT"); final ParserCursor cursor2 = new ParserCursor(0, buffer.length()); - Assertions.assertThrows(ParseException.class, () -> - parser.parseProtocolVersion(buffer, cursor2)); + Assertions.assertThatThrownBy(() -> + parser.parseProtocolVersion(buffer, cursor2)).isInstanceOf(ParseException.class); buffer.clear(); buffer.append("crap"); final ParserCursor cursor3 = new ParserCursor(0, buffer.length()); - Assertions.assertThrows(ParseException.class, () -> - parser.parseProtocolVersion(buffer, cursor3)); + Assertions.assertThatThrownBy(() -> + parser.parseProtocolVersion(buffer, cursor3)).isInstanceOf(ParseException.class); buffer.clear(); buffer.append("HTTP/crap"); final ParserCursor cursor4 = new ParserCursor(0, buffer.length()); - Assertions.assertThrows(ParseException.class, () -> - parser.parseProtocolVersion(buffer, cursor4)); + Assertions.assertThatThrownBy(() -> + parser.parseProtocolVersion(buffer, cursor4)).isInstanceOf(ParseException.class); buffer.clear(); buffer.append("HTTP/1"); final ParserCursor cursor5 = new ParserCursor(0, buffer.length()); - Assertions.assertThrows(ParseException.class, () -> - parser.parseProtocolVersion(buffer, cursor5)); + Assertions.assertThatThrownBy(() -> + parser.parseProtocolVersion(buffer, cursor5)).isInstanceOf(ParseException.class); buffer.clear(); buffer.append("HTTP/1."); final ParserCursor cursor7 = new ParserCursor(0, buffer.length()); - Assertions.assertThrows(ParseException.class, () -> - parser.parseProtocolVersion(buffer, cursor7)); + Assertions.assertThatThrownBy(() -> + parser.parseProtocolVersion(buffer, cursor7)).isInstanceOf(ParseException.class); buffer.clear(); buffer.append("HTTP/whatever.whatever whatever"); final ParserCursor cursor8 = new ParserCursor(0, buffer.length()); - Assertions.assertThrows(ParseException.class, () -> - parser.parseProtocolVersion(buffer, cursor8)); + Assertions.assertThatThrownBy(() -> + parser.parseProtocolVersion(buffer, cursor8)).isInstanceOf(ParseException.class); buffer.clear(); buffer.append("HTTP/1.whatever whatever"); final ParserCursor cursor9 = new ParserCursor(0, buffer.length()); - Assertions.assertThrows(ParseException.class, () -> - parser.parseProtocolVersion(buffer, cursor9)); + Assertions.assertThatThrownBy(() -> + parser.parseProtocolVersion(buffer, cursor9)).isInstanceOf(ParseException.class); } @Test @@ -275,15 +299,15 @@ void testHeaderParse() throws Exception { buf.clear(); buf.append("header: blah"); Header header = this.parser.parseHeader(buf); - Assertions.assertEquals("header", header.getName()); - Assertions.assertEquals("blah", header.getValue()); + Assertions.assertThat(header.getName()).isEqualTo("header"); + Assertions.assertThat(header.getValue()).isEqualTo("blah"); //Lots of blanks buf.clear(); buf.append(" header: blah "); header = this.parser.parseHeader(buf); - Assertions.assertEquals("header", header.getName()); - Assertions.assertEquals("blah", header.getValue()); + Assertions.assertThat(header.getName()).isEqualTo("header"); + Assertions.assertThat(header.getValue()).isEqualTo("blah"); } @Test @@ -291,25 +315,39 @@ void testInvalidHeaderParsing() { final CharArrayBuffer buffer = new CharArrayBuffer(16); buffer.clear(); buffer.append(""); - Assertions.assertThrows(ParseException.class, () -> parser.parseHeader(buffer)); + Assertions.assertThatThrownBy(() -> + parser.parseHeader(buffer)) + .isInstanceOf(ParseException.class); buffer.clear(); buffer.append("blah"); - Assertions.assertThrows(ParseException.class, () -> parser.parseHeader(buffer)); + Assertions.assertThatThrownBy(() -> + parser.parseHeader(buffer)) + .isInstanceOf(ParseException.class); buffer.clear(); buffer.append(":"); - Assertions.assertThrows(ParseException.class, () -> parser.parseHeader(buffer)); + Assertions.assertThatThrownBy(() -> + parser.parseHeader(buffer)) + .isInstanceOf(ParseException.class); buffer.clear(); buffer.append(" :"); - Assertions.assertThrows(ParseException.class, () -> parser.parseHeader(buffer)); + Assertions.assertThatThrownBy(() -> + parser.parseHeader(buffer)) + .isInstanceOf(ParseException.class); buffer.clear(); buffer.append(": blah"); - Assertions.assertThrows(ParseException.class, () -> parser.parseHeader(buffer)); + Assertions.assertThatThrownBy(() -> + parser.parseHeader(buffer)) + .isInstanceOf(ParseException.class); buffer.clear(); buffer.append(" : blah"); - Assertions.assertThrows(ParseException.class, () -> parser.parseHeader(buffer)); + Assertions.assertThatThrownBy(() -> + parser.parseHeader(buffer)) + .isInstanceOf(ParseException.class); buffer.clear(); buffer.append("header : blah"); - Assertions.assertThrows(ParseException.class, () -> parser.parseHeader(buffer)); + Assertions.assertThatThrownBy(() -> + parser.parseHeader(buffer)) + .isInstanceOf(ParseException.class); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/message/TestBasicMessages.java b/httpcore5/src/test/java/org/apache/hc/core5/http/message/TestBasicMessages.java index d31bb63beb..1787fddfed 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/message/TestBasicMessages.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/message/TestBasicMessages.java @@ -36,7 +36,7 @@ import org.apache.hc.core5.http.Method; import org.apache.hc.core5.net.URIAuthority; import org.apache.hc.core5.net.URIBuilder; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; /** @@ -48,161 +48,167 @@ class TestBasicMessages { @Test void testDefaultResponseConstructors() { final HttpResponse response1 = new BasicHttpResponse(HttpStatus.SC_BAD_REQUEST, "Bad Request"); - Assertions.assertEquals(HttpStatus.SC_BAD_REQUEST, response1.getCode()); + Assertions.assertThat(response1.getCode()).isEqualTo(HttpStatus.SC_BAD_REQUEST); final HttpResponse response2 = new BasicHttpResponse(HttpStatus.SC_INTERNAL_SERVER_ERROR, "whatever"); - Assertions.assertEquals(HttpStatus.SC_INTERNAL_SERVER_ERROR, response2.getCode()); - Assertions.assertEquals("whatever", response2.getReasonPhrase()); + Assertions.assertThat(response2.getCode()).isEqualTo(HttpStatus.SC_INTERNAL_SERVER_ERROR); + Assertions.assertThat(response2.getReasonPhrase()).isEqualTo("whatever"); } @Test void testSetResponseStatus() { final HttpResponse response1 = new BasicHttpResponse(200, "OK"); - Assertions.assertEquals(200, response1.getCode()); + Assertions.assertThat(response1.getCode()).isEqualTo(200); final HttpResponse response2 = new BasicHttpResponse(HttpStatus.SC_BAD_REQUEST, "Bad Request"); - Assertions.assertEquals(HttpStatus.SC_BAD_REQUEST, response2.getCode()); + Assertions.assertThat(response2.getCode()).isEqualTo(HttpStatus.SC_BAD_REQUEST); final HttpResponse response3 = new BasicHttpResponse(HttpStatus.SC_INTERNAL_SERVER_ERROR, "whatever"); - Assertions.assertEquals(HttpStatus.SC_INTERNAL_SERVER_ERROR, response3.getCode()); - Assertions.assertEquals("whatever", response3.getReasonPhrase()); + Assertions.assertThat(response3.getCode()).isEqualTo(HttpStatus.SC_INTERNAL_SERVER_ERROR); + Assertions.assertThat(response3.getReasonPhrase()).isEqualTo("whatever"); final HttpResponse response4 = new BasicHttpResponse(HttpStatus.SC_OK, "OK"); - Assertions.assertThrows(IllegalArgumentException.class, () -> response4.setCode(-23)); + Assertions.assertThatThrownBy(() -> + response4.setCode(-23)) + .isInstanceOf(IllegalArgumentException.class); } @Test void testDefaultRequestConstructors() { final HttpRequest request1 = new BasicHttpRequest("WHATEVER", "/"); - Assertions.assertEquals("WHATEVER", request1.getMethod()); - Assertions.assertEquals("/", request1.getPath()); + Assertions.assertThat(request1.getMethod()).isEqualTo("WHATEVER"); + Assertions.assertThat(request1.getPath()).isEqualTo("/"); final HttpRequest request2 = new BasicHttpRequest(Method.GET, "/"); - Assertions.assertEquals(Method.GET.name(), request2.getMethod()); - Assertions.assertEquals("/", request2.getPath()); + Assertions.assertThat(request2.getMethod()).isEqualTo(Method.GET.name()); + Assertions.assertThat(request2.getPath()).isEqualTo("/"); - Assertions.assertThrows(NullPointerException.class, () -> - new BasicHttpRequest(Method.GET, (URI) null)); + Assertions.assertThatThrownBy(() -> + new BasicHttpRequest(Method.GET, (URI) null)).isInstanceOf(NullPointerException.class); } @Test void testResponseBasics() { final BasicHttpResponse response = new BasicHttpResponse(200, "OK"); - Assertions.assertEquals(200, response.getCode()); - Assertions.assertEquals("OK", response.getReasonPhrase()); + Assertions.assertThat(response.getCode()).isEqualTo(200); + Assertions.assertThat(response.getReasonPhrase()).isEqualTo("OK"); } @Test void testResponseStatusLineMutation() { final BasicHttpResponse response = new BasicHttpResponse(200, "OK"); - Assertions.assertEquals(200, response.getCode()); - Assertions.assertEquals("OK", response.getReasonPhrase()); + Assertions.assertThat(response.getCode()).isEqualTo(200); + Assertions.assertThat(response.getReasonPhrase()).isEqualTo("OK"); response.setReasonPhrase("Kind of OK"); - Assertions.assertEquals(200, response.getCode()); - Assertions.assertEquals("Kind of OK", response.getReasonPhrase()); + Assertions.assertThat(response.getCode()).isEqualTo(200); + Assertions.assertThat(response.getReasonPhrase()).isEqualTo("Kind of OK"); response.setCode(299); - Assertions.assertEquals(299, response.getCode()); - Assertions.assertNull(response.getReasonPhrase()); + Assertions.assertThat(response.getCode()).isEqualTo(299); + Assertions.assertThat(response.getReasonPhrase()).isNull(); } @Test void testResponseInvalidStatusCode() { - Assertions.assertThrows(IllegalArgumentException.class, () -> new BasicHttpResponse(-200, "OK")); + Assertions.assertThatThrownBy(() -> + new BasicHttpResponse(-200, "OK")) + .isInstanceOf(IllegalArgumentException.class); final BasicHttpResponse response = new BasicHttpResponse(200, "OK"); - Assertions.assertThrows(IllegalArgumentException.class, () -> response.setCode(-1)); + Assertions.assertThatThrownBy(() -> + response.setCode(-1)) + .isInstanceOf(IllegalArgumentException.class); } @Test void testRequestBasics() throws Exception { final HttpRequest request = new BasicHttpRequest(Method.GET, "/stuff"); - Assertions.assertEquals(Method.GET.name(), request.getMethod()); - Assertions.assertEquals("/stuff", request.getPath()); - Assertions.assertNull(request.getAuthority()); - Assertions.assertEquals(new URI("/stuff"), request.getUri()); + Assertions.assertThat(request.getMethod()).isEqualTo(Method.GET.name()); + Assertions.assertThat(request.getPath()).isEqualTo("/stuff"); + Assertions.assertThat(request.getAuthority()).isNull(); + Assertions.assertThat(request.getUri()).isEqualTo(new URI("/stuff")); } @Test void testRequestWithRelativeURI() throws Exception { final HttpRequest request = new BasicHttpRequest(Method.GET, new URI("/stuff")); - Assertions.assertEquals(Method.GET.name(), request.getMethod()); - Assertions.assertEquals("/stuff", request.getPath()); - Assertions.assertNull(request.getAuthority()); - Assertions.assertEquals(new URI("/stuff"), request.getUri()); + Assertions.assertThat(request.getMethod()).isEqualTo(Method.GET.name()); + Assertions.assertThat(request.getPath()).isEqualTo("/stuff"); + Assertions.assertThat(request.getAuthority()).isNull(); + Assertions.assertThat(request.getUri()).isEqualTo(new URI("/stuff")); } @Test void testRequestWithAbsoluteURI() throws Exception { final HttpRequest request = new BasicHttpRequest(Method.GET, new URI("https://host:9443/stuff?param=value")); - Assertions.assertEquals(Method.GET.name(), request.getMethod()); - Assertions.assertEquals("/stuff?param=value", request.getPath()); - Assertions.assertEquals(new URIAuthority("host", 9443), request.getAuthority()); - Assertions.assertEquals("https", request.getScheme()); - Assertions.assertEquals(new URI("https://host:9443/stuff?param=value"), request.getUri()); + Assertions.assertThat(request.getMethod()).isEqualTo(Method.GET.name()); + Assertions.assertThat(request.getPath()).isEqualTo("/stuff?param=value"); + Assertions.assertThat(request.getAuthority()).isEqualTo(new URIAuthority("host", 9443)); + Assertions.assertThat(request.getScheme()).isEqualTo("https"); + Assertions.assertThat(request.getUri()).isEqualTo(new URI("https://host:9443/stuff?param=value")); } @Test void testRequestWithAbsoluteURIAsPath() throws Exception { final HttpRequest request = new BasicHttpRequest(Method.GET, "https://host:9443/stuff?param=value"); - Assertions.assertEquals(Method.GET.name(), request.getMethod()); - Assertions.assertEquals("/stuff?param=value", request.getPath()); - Assertions.assertEquals(new URIAuthority("host", 9443), request.getAuthority()); - Assertions.assertEquals("https", request.getScheme()); - Assertions.assertEquals(new URI("https://host:9443/stuff?param=value"), request.getUri()); + Assertions.assertThat(request.getMethod()).isEqualTo(Method.GET.name()); + Assertions.assertThat(request.getPath()).isEqualTo("/stuff?param=value"); + Assertions.assertThat(request.getAuthority()).isEqualTo(new URIAuthority("host", 9443)); + Assertions.assertThat(request.getScheme()).isEqualTo("https"); + Assertions.assertThat(request.getUri()).isEqualTo(new URI("https://host:9443/stuff?param=value")); } @Test void testRequestWithNoPath() throws Exception { final HttpRequest request = new BasicHttpRequest(Method.GET, new URI("http://host")); - Assertions.assertEquals(Method.GET.name(), request.getMethod()); - Assertions.assertEquals("/", request.getPath()); - Assertions.assertEquals(new URIAuthority("host"), request.getAuthority()); - Assertions.assertEquals("http", request.getScheme()); - Assertions.assertEquals(new URI("http://host/"), request.getUri()); + Assertions.assertThat(request.getMethod()).isEqualTo(Method.GET.name()); + Assertions.assertThat(request.getPath()).isEqualTo("/"); + Assertions.assertThat(request.getAuthority()).isEqualTo(new URIAuthority("host")); + Assertions.assertThat(request.getScheme()).isEqualTo("http"); + Assertions.assertThat(request.getUri()).isEqualTo(new URI("http://host/")); } @Test void testRequestWithUserInfo() throws Exception { final HttpRequest request = new BasicHttpRequest(Method.GET, new URI("https://user:pwd@host:9443/stuff?param=value")); - Assertions.assertEquals(Method.GET.name(), request.getMethod()); - Assertions.assertEquals("/stuff?param=value", request.getPath()); - Assertions.assertEquals(new URIAuthority("user:pwd", "host", 9443), request.getAuthority()); - Assertions.assertEquals("https", request.getScheme()); - Assertions.assertEquals(new URI("https://host:9443/stuff?param=value"), request.getUri()); + Assertions.assertThat(request.getMethod()).isEqualTo(Method.GET.name()); + Assertions.assertThat(request.getPath()).isEqualTo("/stuff?param=value"); + Assertions.assertThat(request.getAuthority()).isEqualTo(new URIAuthority("user:pwd", "host", 9443)); + Assertions.assertThat(request.getScheme()).isEqualTo("https"); + Assertions.assertThat(request.getUri()).isEqualTo(new URI("https://host:9443/stuff?param=value")); } @Test void testRequestWithAuthority() throws Exception { final HttpRequest request = new BasicHttpRequest(Method.GET, new HttpHost("http", "somehost", -1), "/stuff"); - Assertions.assertEquals(Method.GET.name(), request.getMethod()); - Assertions.assertEquals("/stuff", request.getPath()); - Assertions.assertEquals(new URIAuthority("somehost"), request.getAuthority()); - Assertions.assertEquals(new URI("http://somehost/stuff"), request.getUri()); + Assertions.assertThat(request.getMethod()).isEqualTo(Method.GET.name()); + Assertions.assertThat(request.getPath()).isEqualTo("/stuff"); + Assertions.assertThat(request.getAuthority()).isEqualTo(new URIAuthority("somehost")); + Assertions.assertThat(request.getUri()).isEqualTo(new URI("http://somehost/stuff")); } @Test void testRequestWithAuthorityRelativePath() throws Exception { final HttpRequest request = new BasicHttpRequest(Method.GET, new HttpHost("http", "somehost", -1), "stuff"); - Assertions.assertEquals(Method.GET.name(), request.getMethod()); - Assertions.assertEquals("stuff", request.getPath()); - Assertions.assertEquals(new URIAuthority("somehost"), request.getAuthority()); - Assertions.assertEquals(new URI("http://somehost/stuff"), request.getUri()); + Assertions.assertThat(request.getMethod()).isEqualTo(Method.GET.name()); + Assertions.assertThat(request.getPath()).isEqualTo("stuff"); + Assertions.assertThat(request.getAuthority()).isEqualTo(new URIAuthority("somehost")); + Assertions.assertThat(request.getUri()).isEqualTo(new URI("http://somehost/stuff")); } @Test void testRequestHostWithReservedChars() throws Exception { final HttpRequest request = new BasicHttpRequest(Method.GET, URI.create("http://someuser%21@%21example%21.com/stuff")); - Assertions.assertEquals(Method.GET.name(), request.getMethod()); - Assertions.assertEquals("/stuff", request.getPath()); - Assertions.assertEquals(new URIAuthority("someuser%21", "%21example%21.com", -1), request.getAuthority()); - Assertions.assertEquals(new URI("http://%21example%21.com/stuff"), request.getUri()); + Assertions.assertThat(request.getMethod()).isEqualTo(Method.GET.name()); + Assertions.assertThat(request.getPath()).isEqualTo("/stuff"); + Assertions.assertThat(request.getAuthority()).isEqualTo(new URIAuthority("someuser%21", "%21example%21.com", -1)); + Assertions.assertThat(request.getUri()).isEqualTo(new URI("http://%21example%21.com/stuff")); } @Test void testRequestAbsoluteRequestUri() { final BasicHttpRequest request = new BasicHttpRequest(Method.GET, new HttpHost("http", "somehost", -1), "stuff"); - Assertions.assertEquals("stuff", request.getRequestUri()); + Assertions.assertThat(request.getRequestUri()).isEqualTo("stuff"); request.setAbsoluteRequestUri(true); - Assertions.assertEquals("http://somehost/stuff", request.getRequestUri()); + Assertions.assertThat(request.getRequestUri()).isEqualTo("http://somehost/stuff"); } @Test @@ -215,7 +221,7 @@ void testModifyingExistingRequest() throws Exception { .build(); request.setUri(newUri); - Assertions.assertEquals(newUri, request.getUri()); + Assertions.assertThat(request.getUri()).isEqualTo(newUri); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/message/TestBasicStatusLine.java b/httpcore5/src/test/java/org/apache/hc/core5/http/message/TestBasicStatusLine.java index d647a405be..b1a147f46d 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/message/TestBasicStatusLine.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/message/TestBasicStatusLine.java @@ -28,7 +28,7 @@ package org.apache.hc.core5.http.message; import org.apache.hc.core5.http.message.StatusLine.StatusClass; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; /** @@ -39,49 +39,49 @@ class TestBasicStatusLine { @Test void testGetStatusClass() { StatusLine statusLine = new StatusLine(new BasicHttpResponse(100, "Continue")); - Assertions.assertEquals(StatusClass.INFORMATIONAL, statusLine.getStatusClass()); + Assertions.assertThat(statusLine.getStatusClass()).isEqualTo(StatusClass.INFORMATIONAL); statusLine = new StatusLine(new BasicHttpResponse(200, "OK")); - Assertions.assertEquals(StatusClass.SUCCESSFUL, statusLine.getStatusClass()); + Assertions.assertThat(statusLine.getStatusClass()).isEqualTo(StatusClass.SUCCESSFUL); statusLine = new StatusLine(new BasicHttpResponse(302, "Found")); - Assertions.assertEquals(StatusClass.REDIRECTION, statusLine.getStatusClass()); + Assertions.assertThat(statusLine.getStatusClass()).isEqualTo(StatusClass.REDIRECTION); statusLine = new StatusLine(new BasicHttpResponse(409, "Conflict")); - Assertions.assertEquals(StatusClass.CLIENT_ERROR, statusLine.getStatusClass()); + Assertions.assertThat(statusLine.getStatusClass()).isEqualTo(StatusClass.CLIENT_ERROR); statusLine = new StatusLine(new BasicHttpResponse(502, "Bad Gateway")); - Assertions.assertEquals(StatusClass.SERVER_ERROR, statusLine.getStatusClass()); + Assertions.assertThat(statusLine.getStatusClass()).isEqualTo(StatusClass.SERVER_ERROR); statusLine = new StatusLine(new BasicHttpResponse(999, "Not a status")); - Assertions.assertEquals(StatusClass.OTHER, statusLine.getStatusClass()); + Assertions.assertThat(statusLine.getStatusClass()).isEqualTo(StatusClass.OTHER); } @Test void testGetStatusShorthand() { StatusLine statusLine = new StatusLine(new BasicHttpResponse(100, "Continue")); - Assertions.assertTrue(statusLine.isInformational()); - Assertions.assertFalse(statusLine.isSuccessful()); - Assertions.assertFalse(statusLine.isError()); + Assertions.assertThat(statusLine.isInformational()).isTrue(); + Assertions.assertThat(statusLine.isSuccessful()).isFalse(); + Assertions.assertThat(statusLine.isError()).isFalse(); statusLine = new StatusLine(new BasicHttpResponse(200, "OK")); - Assertions.assertTrue(statusLine.isSuccessful()); - Assertions.assertFalse(statusLine.isRedirection()); - Assertions.assertFalse(statusLine.isError()); + Assertions.assertThat(statusLine.isSuccessful()).isTrue(); + Assertions.assertThat(statusLine.isRedirection()).isFalse(); + Assertions.assertThat(statusLine.isError()).isFalse(); statusLine = new StatusLine(new BasicHttpResponse(302, "Found")); - Assertions.assertTrue(statusLine.isRedirection()); - Assertions.assertFalse(statusLine.isClientError()); - Assertions.assertFalse(statusLine.isError()); + Assertions.assertThat(statusLine.isRedirection()).isTrue(); + Assertions.assertThat(statusLine.isClientError()).isFalse(); + Assertions.assertThat(statusLine.isError()).isFalse(); statusLine = new StatusLine(new BasicHttpResponse(409, "Conflict")); - Assertions.assertTrue(statusLine.isClientError()); - Assertions.assertTrue(statusLine.isError()); - Assertions.assertFalse(statusLine.isServerError()); + Assertions.assertThat(statusLine.isClientError()).isTrue(); + Assertions.assertThat(statusLine.isError()).isTrue(); + Assertions.assertThat(statusLine.isServerError()).isFalse(); statusLine = new StatusLine(new BasicHttpResponse(502, "Bad Gateway")); - Assertions.assertTrue(statusLine.isServerError()); - Assertions.assertTrue(statusLine.isError()); - Assertions.assertFalse(statusLine.isSuccessful()); + Assertions.assertThat(statusLine.isServerError()).isTrue(); + Assertions.assertThat(statusLine.isError()).isTrue(); + Assertions.assertThat(statusLine.isSuccessful()).isFalse(); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/message/TestBasicTokenIterator.java b/httpcore5/src/test/java/org/apache/hc/core5/http/message/TestBasicTokenIterator.java index 32ffa96cd1..58af55a235 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/message/TestBasicTokenIterator.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/message/TestBasicTokenIterator.java @@ -31,7 +31,7 @@ import java.util.NoSuchElementException; import org.apache.hc.core5.http.Header; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; @@ -48,15 +48,15 @@ void testSingleHeader() { Iterator
hit = new BasicHeaderIterator(headers, null); Iterator ti = new BasicTokenIterator(hit); - Assertions.assertTrue(ti.hasNext()); - Assertions.assertEquals("token0", ti.next()); - Assertions.assertTrue(ti.hasNext()); - Assertions.assertEquals("token1", ti.next()); - Assertions.assertTrue(ti.hasNext()); - Assertions.assertEquals("token2", ti.next()); - Assertions.assertTrue(ti.hasNext()); - Assertions.assertEquals("token3", ti.next()); - Assertions.assertFalse(ti.hasNext()); + Assertions.assertThat(ti.hasNext()).isTrue(); + Assertions.assertThat(ti.next()).isEqualTo("token0"); + Assertions.assertThat(ti.hasNext()).isTrue(); + Assertions.assertThat(ti.next()).isEqualTo("token1"); + Assertions.assertThat(ti.hasNext()).isTrue(); + Assertions.assertThat(ti.next()).isEqualTo("token2"); + Assertions.assertThat(ti.hasNext()).isTrue(); + Assertions.assertThat(ti.next()).isEqualTo("token3"); + Assertions.assertThat(ti.hasNext()).isFalse(); headers = new Header[]{ @@ -65,9 +65,9 @@ void testSingleHeader() { hit = new BasicHeaderIterator(headers, null); ti = new BasicTokenIterator(hit); - Assertions.assertTrue(ti.hasNext()); - Assertions.assertEquals("token0", ti.next()); - Assertions.assertFalse(ti.hasNext()); + Assertions.assertThat(ti.hasNext()).isTrue(); + Assertions.assertThat(ti.next()).isEqualTo("token0"); + Assertions.assertThat(ti.hasNext()).isFalse(); } @@ -85,17 +85,17 @@ void testMultiHeader() { final Iterator
hit = new BasicHeaderIterator(headers, null); final Iterator ti = new BasicTokenIterator(hit); - Assertions.assertTrue(ti.hasNext()); - Assertions.assertEquals("token0", ti.next()); - Assertions.assertTrue(ti.hasNext()); - Assertions.assertEquals("token1", ti.next()); - Assertions.assertTrue(ti.hasNext()); - Assertions.assertEquals("token2", ti.next()); - Assertions.assertTrue(ti.hasNext()); - Assertions.assertEquals("token3", ti.next()); - Assertions.assertTrue(ti.hasNext()); - Assertions.assertEquals("token4", ti.next()); - Assertions.assertFalse(ti.hasNext()); + Assertions.assertThat(ti.hasNext()).isTrue(); + Assertions.assertThat(ti.next()).isEqualTo("token0"); + Assertions.assertThat(ti.hasNext()).isTrue(); + Assertions.assertThat(ti.next()).isEqualTo("token1"); + Assertions.assertThat(ti.hasNext()).isTrue(); + Assertions.assertThat(ti.next()).isEqualTo("token2"); + Assertions.assertThat(ti.hasNext()).isTrue(); + Assertions.assertThat(ti.next()).isEqualTo("token3"); + Assertions.assertThat(ti.hasNext()).isTrue(); + Assertions.assertThat(ti.next()).isEqualTo("token4"); + Assertions.assertThat(ti.hasNext()).isFalse(); } @@ -110,13 +110,13 @@ void testEmpty() { Iterator
hit = new BasicHeaderIterator(headers, null); Iterator ti = new BasicTokenIterator(hit); - Assertions.assertFalse(ti.hasNext()); + Assertions.assertThat(ti.hasNext()).isFalse(); hit = new BasicHeaderIterator(headers, "empty"); ti = new BasicTokenIterator(hit); - Assertions.assertFalse(ti.hasNext()); + Assertions.assertThat(ti.hasNext()).isFalse(); } @@ -133,19 +133,19 @@ void testValueStart() { final Iterator
hit = new BasicHeaderIterator(headers, null); final Iterator ti = new BasicTokenIterator(hit); - Assertions.assertTrue(ti.hasNext()); - Assertions.assertEquals("token0", ti.next()); - Assertions.assertTrue(ti.hasNext()); - Assertions.assertEquals("token1", ti.next()); - Assertions.assertTrue(ti.hasNext()); - Assertions.assertEquals("token2", ti.next()); - Assertions.assertTrue(ti.hasNext()); - Assertions.assertEquals("token3", ti.next()); - Assertions.assertTrue(ti.hasNext()); - Assertions.assertEquals("token4", ti.next()); - Assertions.assertTrue(ti.hasNext()); - Assertions.assertEquals("token5", ti.next()); - Assertions.assertFalse(ti.hasNext()); + Assertions.assertThat(ti.hasNext()).isTrue(); + Assertions.assertThat(ti.next()).isEqualTo("token0"); + Assertions.assertThat(ti.hasNext()).isTrue(); + Assertions.assertThat(ti.next()).isEqualTo("token1"); + Assertions.assertThat(ti.hasNext()).isTrue(); + Assertions.assertThat(ti.next()).isEqualTo("token2"); + Assertions.assertThat(ti.hasNext()).isTrue(); + Assertions.assertThat(ti.next()).isEqualTo("token3"); + Assertions.assertThat(ti.hasNext()).isTrue(); + Assertions.assertThat(ti.next()).isEqualTo("token4"); + Assertions.assertThat(ti.hasNext()).isTrue(); + Assertions.assertThat(ti.next()).isEqualTo("token5"); + Assertions.assertThat(ti.hasNext()).isFalse(); } @@ -162,24 +162,26 @@ void testValueEnd() { final Iterator
hit = new BasicHeaderIterator(headers, null); final Iterator ti = new BasicTokenIterator(hit); - Assertions.assertTrue(ti.hasNext()); - Assertions.assertEquals("token0", ti.next()); - Assertions.assertTrue(ti.hasNext()); - Assertions.assertEquals("token1", ti.next()); - Assertions.assertTrue(ti.hasNext()); - Assertions.assertEquals("token2", ti.next()); - Assertions.assertTrue(ti.hasNext()); - Assertions.assertEquals("token3", ti.next()); - Assertions.assertTrue(ti.hasNext()); - Assertions.assertEquals("token4", ti.next()); - Assertions.assertTrue(ti.hasNext()); - Assertions.assertEquals("token5", ti.next()); - Assertions.assertFalse(ti.hasNext()); + Assertions.assertThat(ti.hasNext()).isTrue(); + Assertions.assertThat(ti.next()).isEqualTo("token0"); + Assertions.assertThat(ti.hasNext()).isTrue(); + Assertions.assertThat(ti.next()).isEqualTo("token1"); + Assertions.assertThat(ti.hasNext()).isTrue(); + Assertions.assertThat(ti.next()).isEqualTo("token2"); + Assertions.assertThat(ti.hasNext()).isTrue(); + Assertions.assertThat(ti.next()).isEqualTo("token3"); + Assertions.assertThat(ti.hasNext()).isTrue(); + Assertions.assertThat(ti.next()).isEqualTo("token4"); + Assertions.assertThat(ti.hasNext()).isTrue(); + Assertions.assertThat(ti.next()).isEqualTo("token5"); + Assertions.assertThat(ti.hasNext()).isFalse(); } @Test void testWrongPublic() { - Assertions.assertThrows(NullPointerException.class, () -> new BasicTokenIterator(null)); + Assertions.assertThatThrownBy(() -> + new BasicTokenIterator(null)) + .isInstanceOf(NullPointerException.class); final Header[] headers = new Header[]{ new BasicHeader("Name", " "), @@ -190,8 +192,12 @@ void testWrongPublic() { final Iterator
hit = new BasicHeaderIterator(headers, null); final Iterator ti = new BasicTokenIterator(hit); - Assertions.assertThrows(NoSuchElementException.class, () -> ti.next()); - Assertions.assertThrows(UnsupportedOperationException.class, () -> ti.remove()); + Assertions.assertThatThrownBy(() -> + ti.next()) + .isInstanceOf(NoSuchElementException.class); + Assertions.assertThatThrownBy(() -> + ti.remove()) + .isInstanceOf(UnsupportedOperationException.class); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/message/TestBufferedHeader.java b/httpcore5/src/test/java/org/apache/hc/core5/http/message/TestBufferedHeader.java index 99409f4b07..9ab33a75b4 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/message/TestBufferedHeader.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/message/TestBufferedHeader.java @@ -34,7 +34,7 @@ import org.apache.hc.core5.http.ParseException; import org.apache.hc.core5.util.CharArrayBuffer; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; /** @@ -48,10 +48,10 @@ void testBasicConstructor() throws Exception { final CharArrayBuffer buf = new CharArrayBuffer(32); buf.append("name: value"); final BufferedHeader header = new BufferedHeader(buf, false); - Assertions.assertEquals("name", header.getName()); - Assertions.assertEquals("value", header.getValue()); - Assertions.assertSame(buf, header.getBuffer()); - Assertions.assertEquals(5, header.getValuePos()); + Assertions.assertThat(header.getName()).isEqualTo("name"); + Assertions.assertThat(header.getValue()).isEqualTo("value"); + Assertions.assertThat(header.getBuffer()).isSameAs(buf); + Assertions.assertThat(header.getValuePos()).isEqualTo(5); } @Test @@ -67,8 +67,8 @@ void testSerialization() throws Exception { final ByteArrayInputStream inBuffer = new ByteArrayInputStream(raw); final ObjectInputStream inStream = new ObjectInputStream(inBuffer); final BufferedHeader clone = (BufferedHeader) inStream.readObject(); - Assertions.assertEquals(orig.getName(), clone.getName()); - Assertions.assertEquals(orig.getValue(), clone.getValue()); + Assertions.assertThat(clone.getName()).isEqualTo(orig.getName()); + Assertions.assertThat(clone.getValue()).isEqualTo(orig.getValue()); } @Test @@ -76,25 +76,39 @@ void testInvalidHeaderParsing() { final CharArrayBuffer buf = new CharArrayBuffer(16); buf.clear(); buf.append(""); - Assertions.assertThrows(ParseException.class, () -> new BufferedHeader(buf, false)); + Assertions.assertThatThrownBy(() -> + new BufferedHeader(buf, false)) + .isInstanceOf(ParseException.class); buf.clear(); buf.append("blah"); - Assertions.assertThrows(ParseException.class, () -> new BufferedHeader(buf, false)); + Assertions.assertThatThrownBy(() -> + new BufferedHeader(buf, false)) + .isInstanceOf(ParseException.class); buf.clear(); buf.append(":"); - Assertions.assertThrows(ParseException.class, () -> new BufferedHeader(buf, false)); + Assertions.assertThatThrownBy(() -> + new BufferedHeader(buf, false)) + .isInstanceOf(ParseException.class); buf.clear(); buf.append(" :"); - Assertions.assertThrows(ParseException.class, () -> new BufferedHeader(buf, false)); + Assertions.assertThatThrownBy(() -> + new BufferedHeader(buf, false)) + .isInstanceOf(ParseException.class); buf.clear(); buf.append(": blah"); - Assertions.assertThrows(ParseException.class, () -> new BufferedHeader(buf, false)); + Assertions.assertThatThrownBy(() -> + new BufferedHeader(buf, false)) + .isInstanceOf(ParseException.class); buf.clear(); buf.append(" : blah"); - Assertions.assertThrows(ParseException.class, () -> new BufferedHeader(buf, false)); + Assertions.assertThatThrownBy(() -> + new BufferedHeader(buf, false)) + .isInstanceOf(ParseException.class); buf.clear(); buf.append("header : blah"); - Assertions.assertThrows(ParseException.class, () -> new BufferedHeader(buf, true)); + Assertions.assertThatThrownBy(() -> + new BufferedHeader(buf, true)) + .isInstanceOf(ParseException.class); } @Test @@ -103,20 +117,20 @@ void testCRLFNullInHeaderValue() throws Exception { buf.clear(); buf.append("name: blah\0blah "); final BufferedHeader header1 = new BufferedHeader(buf, false); - Assertions.assertEquals("name", header1.getName()); - Assertions.assertEquals("blah blah", header1.getValue()); + Assertions.assertThat(header1.getName()).isEqualTo("name"); + Assertions.assertThat(header1.getValue()).isEqualTo("blah blah"); buf.clear(); buf.append("name: blah\rblah "); final BufferedHeader header2 = new BufferedHeader(buf, false); - Assertions.assertEquals("name", header2.getName()); - Assertions.assertEquals("blah blah", header2.getValue()); + Assertions.assertThat(header2.getName()).isEqualTo("name"); + Assertions.assertThat(header2.getValue()).isEqualTo("blah blah"); buf.clear(); buf.append("name: blah\nblah "); final BufferedHeader header3 = new BufferedHeader(buf, false); - Assertions.assertEquals("name", header3.getName()); - Assertions.assertEquals("blah blah", header3.getValue()); + Assertions.assertThat(header3.getName()).isEqualTo("name"); + Assertions.assertThat(header3.getValue()).isEqualTo("blah blah"); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/message/TestHeader.java b/httpcore5/src/test/java/org/apache/hc/core5/http/message/TestHeader.java index f7323d098a..c06c528dfe 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/message/TestHeader.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/message/TestHeader.java @@ -33,7 +33,7 @@ import java.io.ObjectOutputStream; import org.apache.hc.core5.http.Header; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; /** @@ -44,28 +44,30 @@ class TestHeader { @Test void testBasicConstructor() { final Header header = new BasicHeader("name", "value"); - Assertions.assertEquals("name", header.getName()); - Assertions.assertEquals("value", header.getValue()); + Assertions.assertThat(header.getName()).isEqualTo("name"); + Assertions.assertThat(header.getValue()).isEqualTo("value"); } @Test void testBasicConstructorNullValue() { final Header header = new BasicHeader("name", null); - Assertions.assertEquals("name", header.getName()); - Assertions.assertNull(header.getValue()); + Assertions.assertThat(header.getName()).isEqualTo("name"); + Assertions.assertThat(header.getValue()).isNull(); } @Test void testInvalidName() { - Assertions.assertThrows(NullPointerException.class, () -> new BasicHeader(null, null)); + Assertions.assertThatThrownBy(() -> + new BasicHeader(null, null)) + .isInstanceOf(NullPointerException.class); } @Test void testToString() { final Header header1 = new BasicHeader("name1", "value1"); - Assertions.assertEquals("name1: value1", header1.toString()); + Assertions.assertThat(header1.toString()).isEqualTo("name1: value1"); final Header header2 = new BasicHeader("name2", null); - Assertions.assertEquals("name2: ", header2.toString()); + Assertions.assertThat(header2.toString()).isEqualTo("name2: "); } @Test @@ -79,8 +81,8 @@ void testSerialization() throws Exception { final ByteArrayInputStream inBuffer = new ByteArrayInputStream(raw); final ObjectInputStream inStream = new ObjectInputStream(inBuffer); final BasicHeader clone = (BasicHeader) inStream.readObject(); - Assertions.assertEquals(orig.getName(), clone.getName()); - Assertions.assertEquals(orig.getValue(), clone.getValue()); + Assertions.assertThat(clone.getName()).isEqualTo(orig.getName()); + Assertions.assertThat(clone.getValue()).isEqualTo(orig.getValue()); } @@ -88,8 +90,8 @@ void testSerialization() throws Exception { void testClone() throws Exception { final BasicHeader orig = new BasicHeader("name1", "value1"); final BasicHeader clone = orig.clone(); - Assertions.assertEquals(orig.getName(), clone.getName()); - Assertions.assertEquals(orig.getValue(), clone.getValue()); + Assertions.assertThat(clone.getName()).isEqualTo(orig.getName()); + Assertions.assertThat(clone.getValue()).isEqualTo(orig.getValue()); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/message/TestHeaderElement.java b/httpcore5/src/test/java/org/apache/hc/core5/http/message/TestHeaderElement.java index d7cc507178..b2b789b220 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/message/TestHeaderElement.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/message/TestHeaderElement.java @@ -30,7 +30,7 @@ import org.apache.hc.core5.http.HeaderElement; import org.apache.hc.core5.http.NameValuePair; import org.apache.hc.core5.util.CharArrayBuffer; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; /** @@ -43,25 +43,27 @@ void testConstructor3() { final HeaderElement element = new BasicHeaderElement("name", "value", new BasicNameValuePair("param1", "value1"), new BasicNameValuePair("param2", "value2")); - Assertions.assertEquals("name", element.getName()); - Assertions.assertEquals("value", element.getValue()); - Assertions.assertEquals(2, element.getParameters().length); - Assertions.assertEquals("value1", element.getParameterByName("param1").getValue()); - Assertions.assertEquals("value2", element.getParameterByName("param2").getValue()); + Assertions.assertThat(element.getName()).isEqualTo("name"); + Assertions.assertThat(element.getValue()).isEqualTo("value"); + Assertions.assertThat(element.getParameters().length).isEqualTo(2); + Assertions.assertThat(element.getParameterByName("param1").getValue()).isEqualTo("value1"); + Assertions.assertThat(element.getParameterByName("param2").getValue()).isEqualTo("value2"); } @Test void testConstructor2() { final HeaderElement element = new BasicHeaderElement("name", "value"); - Assertions.assertEquals("name", element.getName()); - Assertions.assertEquals("value", element.getValue()); - Assertions.assertEquals(0, element.getParameters().length); + Assertions.assertThat(element.getName()).isEqualTo("name"); + Assertions.assertThat(element.getValue()).isEqualTo("value"); + Assertions.assertThat(element.getParameters().length).isEqualTo(0); } @Test void testInvalidName() { - Assertions.assertThrows(NullPointerException.class, () -> new BasicHeaderElement(null, null, (NameValuePair[]) null)); + Assertions.assertThatThrownBy(() -> + new BasicHeaderElement(null, null, (NameValuePair[]) null)) + .isInstanceOf(NullPointerException.class); } @Test @@ -71,10 +73,12 @@ void testParamByName() { buf.append(s); final ParserCursor cursor = new ParserCursor(0, buf.length()); final HeaderElement element = BasicHeaderValueParser.INSTANCE.parseHeaderElement(buf, cursor); - Assertions.assertEquals("value1", element.getParameterByName("param1").getValue()); - Assertions.assertEquals("value2", element.getParameterByName("param2").getValue()); - Assertions.assertNull(element.getParameterByName("param3")); - Assertions.assertThrows(NullPointerException.class, () -> element.getParameterByName(null)); + Assertions.assertThat(element.getParameterByName("param1").getValue()).isEqualTo("value1"); + Assertions.assertThat(element.getParameterByName("param2").getValue()).isEqualTo("value2"); + Assertions.assertThat(element.getParameterByName("param3")).isNull(); + Assertions.assertThatThrownBy(() -> + element.getParameterByName(null)) + .isInstanceOf(NullPointerException.class); } @Test @@ -82,7 +86,7 @@ void testToString() { final BasicHeaderElement element = new BasicHeaderElement("name", "value", new BasicNameValuePair("param1", "value1"), new BasicNameValuePair("param2", "value2")); - Assertions.assertEquals("name=value; param1=value1; param2=value2", element.toString()); + Assertions.assertThat(element.toString()).isEqualTo("name=value; param1=value1; param2=value2"); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/message/TestHeaderGroup.java b/httpcore5/src/test/java/org/apache/hc/core5/http/message/TestHeaderGroup.java index 286eb2f988..c5f332a8db 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/message/TestHeaderGroup.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/message/TestHeaderGroup.java @@ -34,7 +34,7 @@ import java.util.Iterator; import org.apache.hc.core5.http.Header; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; /** @@ -46,17 +46,17 @@ class TestHeaderGroup { @Test void testConstructor() { final HeaderGroup headergroup = new HeaderGroup(); - Assertions.assertNotNull(headergroup.getHeaders()); - Assertions.assertEquals(0, headergroup.getHeaders().length); + Assertions.assertThat(headergroup.getHeaders()).isNotNull(); + Assertions.assertThat(headergroup.getHeaders().length).isEqualTo(0); } @Test void testClear() { final HeaderGroup headergroup = new HeaderGroup(); headergroup.addHeader(new BasicHeader("name", "value")); - Assertions.assertEquals(1, headergroup.getHeaders().length); + Assertions.assertThat(headergroup.getHeaders().length).isEqualTo(1); headergroup.clear(); - Assertions.assertEquals(0, headergroup.getHeaders().length); + Assertions.assertThat(headergroup.getHeaders().length).isEqualTo(0); } @Test @@ -65,10 +65,10 @@ void testAddRemoveHeader() { final Header header = new BasicHeader("name", "value"); headerGroup.addHeader(header); headerGroup.addHeader(null); - Assertions.assertEquals(1, headerGroup.getHeaders().length); - Assertions.assertTrue(headerGroup.removeHeader(header)); - Assertions.assertFalse(headerGroup.removeHeader(null)); - Assertions.assertEquals(0, headerGroup.getHeaders().length); + Assertions.assertThat(headerGroup.getHeaders().length).isEqualTo(1); + Assertions.assertThat(headerGroup.removeHeader(header)).isTrue(); + Assertions.assertThat(headerGroup.removeHeader(null)).isFalse(); + Assertions.assertThat(headerGroup.getHeaders().length).isEqualTo(0); } @Test @@ -77,11 +77,11 @@ void testAddRemoveHeaders() { final Header header = new BasicHeader("name", "value"); headergroup.addHeader(header); headergroup.addHeader(header); - Assertions.assertEquals(2, headergroup.getHeaders().length); - Assertions.assertFalse(headergroup.removeHeaders((Header) null)); - Assertions.assertTrue(headergroup.removeHeaders(header)); - Assertions.assertFalse(headergroup.removeHeaders((Header) null)); - Assertions.assertEquals(0, headergroup.getHeaders().length); + Assertions.assertThat(headergroup.getHeaders().length).isEqualTo(2); + Assertions.assertThat(headergroup.removeHeaders((Header) null)).isFalse(); + Assertions.assertThat(headergroup.removeHeaders(header)).isTrue(); + Assertions.assertThat(headergroup.removeHeaders((Header) null)).isFalse(); + Assertions.assertThat(headergroup.getHeaders().length).isEqualTo(0); } @Test @@ -90,9 +90,9 @@ void testAddRemoveHeaderWithDifferentButEqualHeaders() { final Header header = new BasicHeader("name", "value"); final Header header2 = new BasicHeader("name", "value"); headergroup.addHeader(header); - Assertions.assertEquals(1, headergroup.getHeaders().length); - Assertions.assertTrue(headergroup.removeHeader(header2)); - Assertions.assertEquals(0, headergroup.getHeaders().length); + Assertions.assertThat(headergroup.getHeaders().length).isEqualTo(1); + Assertions.assertThat(headergroup.removeHeader(header2)).isTrue(); + Assertions.assertThat(headergroup.getHeaders().length).isEqualTo(0); } @Test @@ -107,8 +107,8 @@ void testUpdateHeader() { headergroup.setHeader(new BasicHeader("name2", "newvalue")); headergroup.setHeader(new BasicHeader("name4", "value4")); headergroup.setHeader(null); - Assertions.assertEquals(4, headergroup.getHeaders().length); - Assertions.assertEquals("newvalue", headergroup.getFirstHeader("name2").getValue()); + Assertions.assertThat(headergroup.getHeaders().length).isEqualTo(4); + Assertions.assertThat(headergroup.getFirstHeader("name2").getValue()).isEqualTo("newvalue"); } @Test @@ -119,15 +119,15 @@ void testSetHeaders() { final Header header3 = new BasicHeader("name3", "value3"); headergroup.addHeader(header1); headergroup.setHeaders(header2, header3); - Assertions.assertEquals(2, headergroup.getHeaders().length); - Assertions.assertEquals(0, headergroup.getHeaders("name1").length); - Assertions.assertFalse(headergroup.containsHeader("name1")); - Assertions.assertEquals(1, headergroup.getHeaders("name2").length); - Assertions.assertTrue(headergroup.containsHeader("name2")); - Assertions.assertEquals(1, headergroup.getHeaders("name3").length); - Assertions.assertTrue(headergroup.containsHeader("name3")); + Assertions.assertThat(headergroup.getHeaders().length).isEqualTo(2); + Assertions.assertThat(headergroup.getHeaders("name1").length).isEqualTo(0); + Assertions.assertThat(headergroup.containsHeader("name1")).isFalse(); + Assertions.assertThat(headergroup.getHeaders("name2").length).isEqualTo(1); + Assertions.assertThat(headergroup.containsHeader("name2")).isTrue(); + Assertions.assertThat(headergroup.getHeaders("name3").length).isEqualTo(1); + Assertions.assertThat(headergroup.containsHeader("name3")).isTrue(); headergroup.setHeaders(); - Assertions.assertEquals(0, headergroup.getHeaders().length); + Assertions.assertThat(headergroup.getHeaders().length).isEqualTo(0); } @Test @@ -138,43 +138,43 @@ void testFirstLastHeaders() { final Header header3 = new BasicHeader("name", "value3"); headergroup.setHeaders(header1, header2, header3); - Assertions.assertNull(headergroup.getFirstHeader("whatever")); - Assertions.assertNull(headergroup.getLastHeader("whatever")); + Assertions.assertThat(headergroup.getFirstHeader("whatever")).isNull(); + Assertions.assertThat(headergroup.getLastHeader("whatever")).isNull(); - Assertions.assertEquals("value1", headergroup.getFirstHeader("name").getValue()); - Assertions.assertEquals("value3", headergroup.getLastHeader("name").getValue()); + Assertions.assertThat(headergroup.getFirstHeader("name").getValue()).isEqualTo("value1"); + Assertions.assertThat(headergroup.getLastHeader("name").getValue()).isEqualTo("value3"); } @Test void testCondensedHeader() { final HeaderGroup headergroup = new HeaderGroup(); - Assertions.assertNull(headergroup.getCondensedHeader("name")); + Assertions.assertThat(headergroup.getCondensedHeader("name")).isNull(); final Header header1 = new BasicHeader("name", "value1"); final Header header2 = new BasicHeader("name", "value2"); final Header header3 = new BasicHeader("name", "value3"); headergroup.setHeaders(header1, header2, header3); - Assertions.assertEquals("value1, value2, value3", headergroup.getCondensedHeader("name").getValue()); + Assertions.assertThat(headergroup.getCondensedHeader("name").getValue()).isEqualTo("value1, value2, value3"); headergroup.setHeaders(header1); - Assertions.assertEquals(header1, headergroup.getCondensedHeader("name")); + Assertions.assertThat(headergroup.getCondensedHeader("name")).isEqualTo(header1); } @Test void testEmptyListIterator() { final HeaderGroup headergroup = new HeaderGroup(); final Iterator
i = headergroup.headerIterator(); - Assertions.assertNotNull(i); - Assertions.assertFalse(i.hasNext()); + Assertions.assertThat(i).isNotNull(); + Assertions.assertThat(i.hasNext()).isFalse(); } @Test void testEmptyListIteratorByName() { final HeaderGroup headergroup = new HeaderGroup(); final Iterator
i = headergroup.headerIterator("some-header"); - Assertions.assertNotNull(i); - Assertions.assertFalse(i.hasNext()); + Assertions.assertThat(i).isNotNull(); + Assertions.assertThat(i.hasNext()).isFalse(); } @Test @@ -187,22 +187,22 @@ void testNonEmptyListIteratorByName() { new BasicHeader("b", "b-two"), new BasicHeader("b", "b-three")); final Iterator
it1 = headergroup.headerIterator("a"); - Assertions.assertNotNull(it1); - Assertions.assertTrue(it1.hasNext()); - Assertions.assertEquals("a-one", it1.next().getValue()); - Assertions.assertTrue(it1.hasNext()); - Assertions.assertEquals("a-two", it1.next().getValue()); - Assertions.assertFalse(it1.hasNext()); + Assertions.assertThat(it1).isNotNull(); + Assertions.assertThat(it1.hasNext()).isTrue(); + Assertions.assertThat(it1.next().getValue()).isEqualTo("a-one"); + Assertions.assertThat(it1.hasNext()).isTrue(); + Assertions.assertThat(it1.next().getValue()).isEqualTo("a-two"); + Assertions.assertThat(it1.hasNext()).isFalse(); final Iterator
it2 = headergroup.headerIterator("b"); - Assertions.assertNotNull(it2); - Assertions.assertTrue(it2.hasNext()); - Assertions.assertEquals("b-one", it2.next().getValue()); - Assertions.assertTrue(it2.hasNext()); - Assertions.assertEquals("b-two", it2.next().getValue()); - Assertions.assertTrue(it2.hasNext()); - Assertions.assertEquals("b-three", it2.next().getValue()); - Assertions.assertFalse(it2.hasNext()); + Assertions.assertThat(it2).isNotNull(); + Assertions.assertThat(it2.hasNext()).isTrue(); + Assertions.assertThat(it2.next().getValue()).isEqualTo("b-one"); + Assertions.assertThat(it2.hasNext()).isTrue(); + Assertions.assertThat(it2.next().getValue()).isEqualTo("b-two"); + Assertions.assertThat(it2.hasNext()).isTrue(); + Assertions.assertThat(it2.next().getValue()).isEqualTo("b-three"); + Assertions.assertThat(it2.hasNext()).isFalse(); } @@ -215,10 +215,9 @@ void testIteratorByNameRemoveBeforeNext() { final Iterator
iterator = headerGroup.headerIterator("b"); - Assertions.assertThrows(IllegalStateException.class, iterator::remove); - Assertions.assertArrayEquals( - new Header[] { headerA, headerB }, - headerGroup.getHeaders()); + Assertions.assertThatThrownBy(iterator::remove).isInstanceOf(IllegalStateException.class); + Assertions.assertThat(headerGroup.getHeaders()) + .containsExactly(new Header[]{headerA, headerB}); } @Test @@ -229,18 +228,18 @@ void testHeaderRemove() { final Header header3 = new BasicHeader("name", "value3"); headergroup.setHeaders(header1, header2, header3); final Iterator
i = headergroup.headerIterator(); - Assertions.assertNotNull(i); - Assertions.assertTrue(i.hasNext()); + Assertions.assertThat(i).isNotNull(); + Assertions.assertThat(i.hasNext()).isTrue(); i.next(); - Assertions.assertTrue(i.hasNext()); + Assertions.assertThat(i.hasNext()).isTrue(); i.next(); i.remove(); - Assertions.assertEquals(2, headergroup.getHeaders().length); - Assertions.assertTrue(i.hasNext()); + Assertions.assertThat(headergroup.getHeaders().length).isEqualTo(2); + Assertions.assertThat(i.hasNext()).isTrue(); i.next(); i.remove(); - Assertions.assertEquals(1, headergroup.getHeaders().length); - Assertions.assertFalse(i.hasNext()); + Assertions.assertThat(headergroup.getHeaders().length).isEqualTo(1); + Assertions.assertThat(i.hasNext()).isFalse(); } @Test @@ -260,12 +259,12 @@ void testSerialization() throws Exception { final HeaderGroup clone = (HeaderGroup) inStream.readObject(); final Header[] headers1 = orig.getHeaders(); final Header[] headers2 = clone.getHeaders(); - Assertions.assertNotNull(headers1); - Assertions.assertNotNull(headers2); - Assertions.assertEquals(headers1.length, headers2.length); + Assertions.assertThat(headers1).isNotNull(); + Assertions.assertThat(headers2).isNotNull(); + Assertions.assertThat(headers2.length).isEqualTo(headers1.length); for (int i = 0; i < headers1.length; i++) { - Assertions.assertEquals(headers1[i].getName(), headers2[i].getName()); - Assertions.assertEquals(headers1[i].getValue(), headers2[i].getValue()); + Assertions.assertThat(headers2[i].getName()).isEqualTo(headers1[i].getName()); + Assertions.assertThat(headers2[i].getValue()).isEqualTo(headers1[i].getValue()); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/message/TestMessageSupport.java b/httpcore5/src/test/java/org/apache/hc/core5/http/message/TestMessageSupport.java index 174a07c3d2..aa97a5043d 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/message/TestMessageSupport.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/message/TestMessageSupport.java @@ -55,7 +55,7 @@ import org.apache.hc.core5.http.support.BasicResponseBuilder; import org.apache.hc.core5.util.CharArrayBuffer; import org.apache.hc.core5.util.Tokenizer; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class TestMessageSupport { @@ -72,37 +72,37 @@ private static Set makeSet(final String... tokens) { @Test void testTokenSetFormatting() { final Header header = MessageSupport.header(HttpHeaders.TRAILER, makeSet("z", "b", "a")); - Assertions.assertNotNull(header); - Assertions.assertEquals("z, b, a", header.getValue()); + Assertions.assertThat(header).isNotNull(); + Assertions.assertThat(header.getValue()).isEqualTo("z, b, a"); } @Test void testTokenListFormatting() { final Header header = MessageSupport.headerOfTokens(HttpHeaders.TRAILER, Arrays.asList("z", "b", "a", "a")); - Assertions.assertNotNull(header); - Assertions.assertEquals("z, b, a, a", header.getValue()); + Assertions.assertThat(header).isNotNull(); + Assertions.assertThat(header.getValue()).isEqualTo("z, b, a, a"); } @Test void testTokenListFormattingWithTransformation() { final Header header = MessageSupport.headerOfTokens(HttpHeaders.TRAILER, Arrays.asList("z", "b", "a", "a"), e -> e.toUpperCase(Locale.ROOT)); - Assertions.assertNotNull(header); - Assertions.assertEquals("Z, B, A, A", header.getValue()); + Assertions.assertThat(header).isNotNull(); + Assertions.assertThat(header.getValue()).isEqualTo("Z, B, A, A"); } @Test void testTokenSetFormattingSameName() { final Header header = MessageSupport.header(HttpHeaders.TRAILER, makeSet("a", "a", "a")); - Assertions.assertNotNull(header); - Assertions.assertEquals("a", header.getValue()); + Assertions.assertThat(header).isNotNull(); + Assertions.assertThat(header.getValue()).isEqualTo("a"); } @Test void testTokenListFormattingSameName() { final Header header = MessageSupport.header(HttpHeaders.TRAILER, "a", "a", "a"); - Assertions.assertNotNull(header); - Assertions.assertEquals("a, a, a", header.getValue()); + Assertions.assertThat(header).isNotNull(); + Assertions.assertThat(header.getValue()).isEqualTo("a, a, a"); } @Test @@ -111,7 +111,7 @@ void testParseTokensWithConsumer() { final ParserCursor cursor = new ParserCursor(0, s.length()); final List tokens = new ArrayList<>(); MessageSupport.parseTokens(s, cursor, tokens::add); - Assertions.assertEquals(Arrays.asList("a", "b", "c", "c"), tokens); + Assertions.assertThat(tokens).isEqualTo(Arrays.asList("a", "b", "c", "c")); } @Test @@ -120,7 +120,7 @@ void testParseTokensWithConsumerAndCustomDelimiter() { final ParserCursor cursor = new ParserCursor(0, s.length()); final List tokens = new ArrayList<>(); MessageSupport.parseTokens(s, cursor, Tokenizer.delimiters(';'), tokens::add); - Assertions.assertEquals(Arrays.asList("a, b", "c, c"), tokens); + Assertions.assertThat(tokens).isEqualTo(Arrays.asList("a, b", "c, c")); } @Test @@ -128,7 +128,7 @@ void testParseTokenHeaderWithConsumer() { final Header header = new BasicHeader(HttpHeaders.TRAILER, "a, b, c, c"); final List tokens = new ArrayList<>(); MessageSupport.parseTokens(header, tokens::add); - Assertions.assertEquals(Arrays.asList("a", "b", "c", "c"), tokens); + Assertions.assertThat(tokens).isEqualTo(Arrays.asList("a", "b", "c", "c")); } @Test @@ -136,20 +136,20 @@ void testParseTokenBufferWithConsumer() { final CharArrayBuffer buf = new CharArrayBuffer(128); buf.append("stuff: a, b, c, c"); final Header header = BufferedHeader.create(buf); - Assertions.assertEquals(makeSet("a", "b", "c", "c"), MessageSupport.parseTokens(header)); + Assertions.assertThat(MessageSupport.parseTokens(header)).isEqualTo(makeSet("a", "b", "c", "c")); } @Test void testParseTokens() { final String s = "a, b, c, c"; final ParserCursor cursor = new ParserCursor(0, s.length()); - Assertions.assertEquals(makeSet("a", "b", "c"), MessageSupport.parseTokens(s, cursor)); + Assertions.assertThat(MessageSupport.parseTokens(s, cursor)).isEqualTo(makeSet("a", "b", "c")); } @Test void testParseTokenHeader() { final Header header = new BasicHeader(HttpHeaders.TRAILER, "a, b, c, c"); - Assertions.assertEquals(makeSet("a", "b", "c"), MessageSupport.parseTokens(header)); + Assertions.assertThat(MessageSupport.parseTokens(header)).isEqualTo(makeSet("a", "b", "c")); } @Test @@ -157,7 +157,7 @@ void testParseTokenBuffer() { final CharArrayBuffer buf = new CharArrayBuffer(128); buf.append("stuff: a, b, c, c"); final Header header = BufferedHeader.create(buf); - Assertions.assertEquals(makeSet("a", "b", "c"), MessageSupport.parseTokens(header)); + Assertions.assertThat(MessageSupport.parseTokens(header)).isEqualTo(makeSet("a", "b", "c")); } @Test @@ -170,10 +170,10 @@ void testElementListFormatting() { new BasicHeaderElement("name5", null)); final Header header = MessageSupport.headerOfElements("Some-header", elements); - Assertions.assertNotNull(header); - Assertions.assertEquals("name1=value1; param=regular_stuff, name2=value2; " + + Assertions.assertThat(header).isNotNull(); + Assertions.assertThat(header.getValue()).isEqualTo("name1=value1; param=regular_stuff, name2=value2; " + "param=\"this\\\\that\", name3=value3; param=\"this,that\", " + - "name4=value4; param, name5", header.getValue()); + "name4=value4; param, name5"); } @Test @@ -186,10 +186,10 @@ void testElementArrayFormatting() { new BasicHeaderElement("name5", null)}; final Header header = MessageSupport.header("Some-Header", elements); - Assertions.assertNotNull(header); - Assertions.assertEquals("name1=value1; param=regular_stuff, name2=value2; " + + Assertions.assertThat(header).isNotNull(); + Assertions.assertThat(header.getValue()).isEqualTo("name1=value1; param=regular_stuff, name2=value2; " + "param=\"this\\\\that\", name3=value3; param=\"this,that\", " + - "name4=value4; param, name5", header.getValue()); + "name4=value4; param, name5"); } @Test @@ -201,32 +201,32 @@ void testParseElementsBufferWithConsumer() { final ParserCursor cursor = new ParserCursor(0, buf.length()); MessageSupport.parseElements(buf, cursor, elements::add); // there are 3 elements - Assertions.assertEquals(3,elements.size()); + Assertions.assertThat(elements.size()).isEqualTo(3); // 1st element - Assertions.assertEquals("name1", elements.get(0).getName()); - Assertions.assertEquals("value1", elements.get(0).getValue()); + Assertions.assertThat(elements.get(0).getName()).isEqualTo("name1"); + Assertions.assertThat(elements.get(0).getValue()).isEqualTo("value1"); // 1st element has 2 getParameters() - Assertions.assertEquals(2, elements.get(0).getParameters().length); - Assertions.assertEquals("name2", elements.get(0).getParameters()[0].getName()); - Assertions.assertNull(elements.get(0).getParameters()[0].getValue()); - Assertions.assertEquals("name3", elements.get(0).getParameters()[1].getName()); - Assertions.assertEquals("value3", elements.get(0).getParameters()[1].getValue()); + Assertions.assertThat(elements.get(0).getParameters().length).isEqualTo(2); + Assertions.assertThat(elements.get(0).getParameters()[0].getName()).isEqualTo("name2"); + Assertions.assertThat(elements.get(0).getParameters()[0].getValue()).isNull(); + Assertions.assertThat(elements.get(0).getParameters()[1].getName()).isEqualTo("name3"); + Assertions.assertThat(elements.get(0).getParameters()[1].getValue()).isEqualTo("value3"); // 2nd element - Assertions.assertEquals("name4", elements.get(1).getName()); - Assertions.assertEquals("value4", elements.get(1).getValue()); + Assertions.assertThat(elements.get(1).getName()).isEqualTo("name4"); + Assertions.assertThat(elements.get(1).getValue()).isEqualTo("value4"); // 2nd element has 1 parameter - Assertions.assertEquals(1, elements.get(1).getParameters().length); - Assertions.assertEquals("name5", elements.get(1).getParameters()[0].getName()); - Assertions.assertEquals("value5", elements.get(1).getParameters()[0].getValue()); + Assertions.assertThat(elements.get(1).getParameters().length).isEqualTo(1); + Assertions.assertThat(elements.get(1).getParameters()[0].getName()).isEqualTo("name5"); + Assertions.assertThat(elements.get(1).getParameters()[0].getValue()).isEqualTo("value5"); // 3rd element - Assertions.assertEquals("name6", elements.get(2).getName()); - Assertions.assertEquals("", elements.get(2).getValue()); + Assertions.assertThat(elements.get(2).getName()).isEqualTo("name6"); + Assertions.assertThat(elements.get(2).getValue()).isEqualTo(""); // 3rd element has 2 getParameters() - Assertions.assertEquals(2, elements.get(2).getParameters().length); - Assertions.assertEquals("name7", elements.get(2).getParameters()[0].getName()); - Assertions.assertEquals("value7", elements.get(2).getParameters()[0].getValue()); - Assertions.assertEquals("name8", elements.get(2).getParameters()[1].getName()); - Assertions.assertEquals(" value8", elements.get(2).getParameters()[1].getValue()); + Assertions.assertThat(elements.get(2).getParameters().length).isEqualTo(2); + Assertions.assertThat(elements.get(2).getParameters()[0].getName()).isEqualTo("name7"); + Assertions.assertThat(elements.get(2).getParameters()[0].getValue()).isEqualTo("value7"); + Assertions.assertThat(elements.get(2).getParameters()[1].getName()).isEqualTo("name8"); + Assertions.assertThat(elements.get(2).getParameters()[1].getValue()).isEqualTo(" value8"); } @Test @@ -237,32 +237,32 @@ void testParseElementsHeaderWithConsumer() { final List elements = new ArrayList<>(); MessageSupport.parseElements(header, elements::add); // there are 3 elements - Assertions.assertEquals(3,elements.size()); + Assertions.assertThat(elements.size()).isEqualTo(3); // 1st element - Assertions.assertEquals("name1", elements.get(0).getName()); - Assertions.assertEquals("value1", elements.get(0).getValue()); + Assertions.assertThat(elements.get(0).getName()).isEqualTo("name1"); + Assertions.assertThat(elements.get(0).getValue()).isEqualTo("value1"); // 1st element has 2 getParameters() - Assertions.assertEquals(2, elements.get(0).getParameters().length); - Assertions.assertEquals("name2", elements.get(0).getParameters()[0].getName()); - Assertions.assertNull(elements.get(0).getParameters()[0].getValue()); - Assertions.assertEquals("name3", elements.get(0).getParameters()[1].getName()); - Assertions.assertEquals("value3", elements.get(0).getParameters()[1].getValue()); + Assertions.assertThat(elements.get(0).getParameters().length).isEqualTo(2); + Assertions.assertThat(elements.get(0).getParameters()[0].getName()).isEqualTo("name2"); + Assertions.assertThat(elements.get(0).getParameters()[0].getValue()).isNull(); + Assertions.assertThat(elements.get(0).getParameters()[1].getName()).isEqualTo("name3"); + Assertions.assertThat(elements.get(0).getParameters()[1].getValue()).isEqualTo("value3"); // 2nd element - Assertions.assertEquals("name4", elements.get(1).getName()); - Assertions.assertEquals("value4", elements.get(1).getValue()); + Assertions.assertThat(elements.get(1).getName()).isEqualTo("name4"); + Assertions.assertThat(elements.get(1).getValue()).isEqualTo("value4"); // 2nd element has 1 parameter - Assertions.assertEquals(1, elements.get(1).getParameters().length); - Assertions.assertEquals("name5", elements.get(1).getParameters()[0].getName()); - Assertions.assertEquals("value5", elements.get(1).getParameters()[0].getValue()); + Assertions.assertThat(elements.get(1).getParameters().length).isEqualTo(1); + Assertions.assertThat(elements.get(1).getParameters()[0].getName()).isEqualTo("name5"); + Assertions.assertThat(elements.get(1).getParameters()[0].getValue()).isEqualTo("value5"); // 3rd element - Assertions.assertEquals("name6", elements.get(2).getName()); - Assertions.assertEquals("", elements.get(2).getValue()); + Assertions.assertThat(elements.get(2).getName()).isEqualTo("name6"); + Assertions.assertThat(elements.get(2).getValue()).isEqualTo(""); // 3rd element has 2 getParameters() - Assertions.assertEquals(2, elements.get(2).getParameters().length); - Assertions.assertEquals("name7", elements.get(2).getParameters()[0].getName()); - Assertions.assertEquals("value7", elements.get(2).getParameters()[0].getValue()); - Assertions.assertEquals("name8", elements.get(2).getParameters()[1].getName()); - Assertions.assertEquals(" value8", elements.get(2).getParameters()[1].getValue()); + Assertions.assertThat(elements.get(2).getParameters().length).isEqualTo(2); + Assertions.assertThat(elements.get(2).getParameters()[0].getName()).isEqualTo("name7"); + Assertions.assertThat(elements.get(2).getParameters()[0].getValue()).isEqualTo("value7"); + Assertions.assertThat(elements.get(2).getParameters()[1].getName()).isEqualTo("name8"); + Assertions.assertThat(elements.get(2).getParameters()[1].getValue()).isEqualTo(" value8"); } @Test @@ -272,32 +272,32 @@ void testParseElementsHeader() { "name5=value5, name6= ; name7 = value7; name8 = \" value8\""); final List elements = MessageSupport.parseElements(header); // there are 3 elements - Assertions.assertEquals(3,elements.size()); + Assertions.assertThat(elements.size()).isEqualTo(3); // 1st element - Assertions.assertEquals("name1", elements.get(0).getName()); - Assertions.assertEquals("value1", elements.get(0).getValue()); + Assertions.assertThat(elements.get(0).getName()).isEqualTo("name1"); + Assertions.assertThat(elements.get(0).getValue()).isEqualTo("value1"); // 1st element has 2 getParameters() - Assertions.assertEquals(2, elements.get(0).getParameters().length); - Assertions.assertEquals("name2", elements.get(0).getParameters()[0].getName()); - Assertions.assertNull(elements.get(0).getParameters()[0].getValue()); - Assertions.assertEquals("name3", elements.get(0).getParameters()[1].getName()); - Assertions.assertEquals("value3", elements.get(0).getParameters()[1].getValue()); + Assertions.assertThat(elements.get(0).getParameters().length).isEqualTo(2); + Assertions.assertThat(elements.get(0).getParameters()[0].getName()).isEqualTo("name2"); + Assertions.assertThat(elements.get(0).getParameters()[0].getValue()).isNull(); + Assertions.assertThat(elements.get(0).getParameters()[1].getName()).isEqualTo("name3"); + Assertions.assertThat(elements.get(0).getParameters()[1].getValue()).isEqualTo("value3"); // 2nd element - Assertions.assertEquals("name4", elements.get(1).getName()); - Assertions.assertEquals("value4", elements.get(1).getValue()); + Assertions.assertThat(elements.get(1).getName()).isEqualTo("name4"); + Assertions.assertThat(elements.get(1).getValue()).isEqualTo("value4"); // 2nd element has 1 parameter - Assertions.assertEquals(1, elements.get(1).getParameters().length); - Assertions.assertEquals("name5", elements.get(1).getParameters()[0].getName()); - Assertions.assertEquals("value5", elements.get(1).getParameters()[0].getValue()); + Assertions.assertThat(elements.get(1).getParameters().length).isEqualTo(1); + Assertions.assertThat(elements.get(1).getParameters()[0].getName()).isEqualTo("name5"); + Assertions.assertThat(elements.get(1).getParameters()[0].getValue()).isEqualTo("value5"); // 3rd element - Assertions.assertEquals("name6", elements.get(2).getName()); - Assertions.assertEquals("", elements.get(2).getValue()); + Assertions.assertThat(elements.get(2).getName()).isEqualTo("name6"); + Assertions.assertThat(elements.get(2).getValue()).isEqualTo(""); // 3rd element has 2 getParameters() - Assertions.assertEquals(2, elements.get(2).getParameters().length); - Assertions.assertEquals("name7", elements.get(2).getParameters()[0].getName()); - Assertions.assertEquals("value7", elements.get(2).getParameters()[0].getValue()); - Assertions.assertEquals("name8", elements.get(2).getParameters()[1].getName()); - Assertions.assertEquals(" value8", elements.get(2).getParameters()[1].getValue()); + Assertions.assertThat(elements.get(2).getParameters().length).isEqualTo(2); + Assertions.assertThat(elements.get(2).getParameters()[0].getName()).isEqualTo("name7"); + Assertions.assertThat(elements.get(2).getParameters()[0].getValue()).isEqualTo("value7"); + Assertions.assertThat(elements.get(2).getParameters()[1].getName()).isEqualTo("name8"); + Assertions.assertThat(elements.get(2).getParameters()[1].getValue()).isEqualTo(" value8"); } @Test @@ -308,8 +308,7 @@ void testParamListFormatting() { new BasicNameValuePair("param", "this\\that"), new BasicNameValuePair("param", "this,that") )); - Assertions.assertEquals("param=regular_stuff; param=\"this\\\\that\"; param=\"this,that\"", - buf.toString()); + Assertions.assertThat(buf.toString()).isEqualTo("param=regular_stuff; param=\"this\\\\that\"; param=\"this,that\""); } @Test @@ -320,8 +319,7 @@ void testParamArrayFormatting() { new BasicNameValuePair("param", "this\\that"), new BasicNameValuePair("param", "this,that") ); - Assertions.assertEquals("param=regular_stuff; param=\"this\\\\that\"; param=\"this,that\"", - buf.toString()); + Assertions.assertThat(buf.toString()).isEqualTo("param=regular_stuff; param=\"this\\\\that\"; param=\"this,that\""); } @Test @@ -334,16 +332,16 @@ void testParseParams() { final List params = new ArrayList<>(); MessageSupport.parseParameters(buffer, cursor, params::add); - Assertions.assertEquals("test", params.get(0).getName()); - Assertions.assertNull(params.get(0).getValue()); - Assertions.assertEquals("test1", params.get(1).getName()); - Assertions.assertEquals("stuff", params.get(1).getValue()); - Assertions.assertEquals("test2", params.get(2).getName()); - Assertions.assertEquals("stuff; stuff", params.get(2).getValue()); - Assertions.assertEquals("test3", params.get(3).getName()); - Assertions.assertEquals("stuff", params.get(3).getValue()); - Assertions.assertEquals(s.length() - 4, cursor.getPos()); - Assertions.assertFalse(cursor.atEnd()); + Assertions.assertThat(params.get(0).getName()).isEqualTo("test"); + Assertions.assertThat(params.get(0).getValue()).isNull(); + Assertions.assertThat(params.get(1).getName()).isEqualTo("test1"); + Assertions.assertThat(params.get(1).getValue()).isEqualTo("stuff"); + Assertions.assertThat(params.get(2).getName()).isEqualTo("test2"); + Assertions.assertThat(params.get(2).getValue()).isEqualTo("stuff; stuff"); + Assertions.assertThat(params.get(3).getName()).isEqualTo("test3"); + Assertions.assertThat(params.get(3).getValue()).isEqualTo("stuff"); + Assertions.assertThat(cursor.getPos()).isEqualTo(s.length() - 4); + Assertions.assertThat(cursor.atEnd()).isFalse(); } static String copyHeader(final CharSequence charSequence, final ParserCursor cursor) { @@ -385,14 +383,14 @@ void testParseHeaders() { final String headerValue = copyHeader(charSequence, cursor); headerValues.add(headerValue); }); - Assertions.assertEquals(Arrays.asList("this", "that", " this, that, what not"), headerValues); + Assertions.assertThat(headerValues).isEqualTo(Arrays.asList("this", "that", " this, that, what not")); final List tokens = new LinkedList<>(); MessageSupport.parseElementList(message, "Some-header", (charSequence, cursor) -> { final String token = copyToken(charSequence, cursor); tokens.add(token); }); - Assertions.assertEquals(Arrays.asList("this", "that", "this", "that", "what not"), tokens); + Assertions.assertThat(tokens).isEqualTo(Arrays.asList("this", "that", "this", "that", "what not")); } @Test @@ -407,13 +405,12 @@ void testParseHeadersElementWhitespace() throws Exception { final String ver = copyToken(charSequence, cursor); versions.add(ver); }); - Assertions.assertEquals(Arrays.asList( + Assertions.assertThat(versions).isEqualTo(Arrays.asList( "HTTP/1.0", "HTTP/1.1", "HTTP/2", "HTTP/2.0", - "HTTP/0.9"), - versions); + "HTTP/0.9")); } @Test @@ -428,16 +425,16 @@ void testParseHeadersStrict() throws Exception { final String headerValue = copyHeader(charSequence, cursor); headerValues.add(headerValue); }); - Assertions.assertEquals(Arrays.asList("this", "that", " this, that, what not"), headerValues); + Assertions.assertThat(headerValues).isEqualTo(Arrays.asList("this", "that", " this, that, what not")); final List tokens = new LinkedList<>(); MessageSupport.parseElementListStrict(message, "Some-header", (charSequence, cursor) -> { final String token = copyToken(charSequence, cursor); tokens.add(token); }); - Assertions.assertEquals(Arrays.asList("this", "that", "this", "that", "what not"), tokens); + Assertions.assertThat(tokens).isEqualTo(Arrays.asList("this", "that", "this", "that", "what not")); - Assertions.assertThrows(ParseException.class, () -> + Assertions.assertThatThrownBy(() -> MessageSupport.parseElementListStrict( message, "Some-header", @@ -446,7 +443,7 @@ void testParseHeadersStrict() throws Exception { if (token.equalsIgnoreCase("what not")) { throw new ParseException("How awful!"); } - })); + })).isInstanceOf(ParseException.class); } @Test @@ -461,13 +458,12 @@ void testParseHeadersStrictElementWhitespace() throws Exception { final ProtocolVersion ver = HttpVersion.parse(charSequence, cursor, Tokenizer.delimiters(',')); versions.add(ver); }); - Assertions.assertEquals(Arrays.asList( + Assertions.assertThat(versions).isEqualTo(Arrays.asList( HttpVersion.HTTP_1_0, HttpVersion.HTTP_1_1, HttpVersion.HTTP_2_0, HttpVersion.HTTP_2_0, - HttpVersion.HTTP_0_9), - versions); + HttpVersion.HTTP_0_9)); } @Test @@ -476,12 +472,11 @@ void testParseHeadersStrictInvalidElement() throws Exception { message.addHeader("Some-Header", "HTTP/1.0"); message.addHeader("Some-Header", " HTTP/1.1 HTTP/1.1"); - Assertions.assertThrows(ProtocolException.class, () -> { + Assertions.assertThatThrownBy(() -> { MessageSupport.parseElementListStrict(message, "Some-header", (charSequence, cursor) -> { HttpVersion.parse(charSequence, cursor, Tokenizer.delimiters(',')); }); - } - ); + }).isInstanceOf(ProtocolException.class); } @Test @@ -495,10 +490,10 @@ void testAddContentHeaders() { final Header h1 = message.getFirstHeader(HttpHeaders.TRAILER); final Header h2 = message.getFirstHeader(HttpHeaders.CONTENT_TYPE); - Assertions.assertNotNull(h1); - Assertions.assertEquals("z, b, a", h1.getValue()); - Assertions.assertNotNull(h2); - Assertions.assertEquals("text/plain; charset=US-ASCII", h2.getValue()); + Assertions.assertThat(h1).isNotNull(); + Assertions.assertThat(h1.getValue()).isEqualTo("z, b, a"); + Assertions.assertThat(h2).isNotNull(); + Assertions.assertThat(h2.getValue()).isEqualTo("text/plain; charset=US-ASCII"); } @Test @@ -515,19 +510,19 @@ void testContentHeadersAlreadyPresent() { final Header h1 = message.getFirstHeader(HttpHeaders.TRAILER); final Header h2 = message.getFirstHeader(HttpHeaders.CONTENT_TYPE); - Assertions.assertNotNull(h1); - Assertions.assertEquals("a, a, a", h1.getValue()); - Assertions.assertNotNull(h2); - Assertions.assertEquals("text/plain; charset=ascii", h2.getValue()); + Assertions.assertThat(h1).isNotNull(); + Assertions.assertThat(h1.getValue()).isEqualTo("a, a, a"); + Assertions.assertThat(h2).isNotNull(); + Assertions.assertThat(h2.getValue()).isEqualTo("text/plain; charset=ascii"); } @Test void testHopByHopHeaders() { - Assertions.assertTrue(MessageSupport.isHopByHop("Connection")); - Assertions.assertTrue(MessageSupport.isHopByHop("connection")); - Assertions.assertTrue(MessageSupport.isHopByHop("coNNection")); - Assertions.assertFalse(MessageSupport.isHopByHop("Content-Type")); - Assertions.assertFalse(MessageSupport.isHopByHop("huh")); + Assertions.assertThat(MessageSupport.isHopByHop("Connection")).isTrue(); + Assertions.assertThat(MessageSupport.isHopByHop("connection")).isTrue(); + Assertions.assertThat(MessageSupport.isHopByHop("coNNection")).isTrue(); + Assertions.assertThat(MessageSupport.isHopByHop("Content-Type")).isFalse(); + Assertions.assertThat(MessageSupport.isHopByHop("huh")).isFalse(); } @Test @@ -537,88 +532,88 @@ void testHopByHopHeadersConnectionSpecific() { .addHeader(HttpHeaders.CONTENT_TYPE, ContentType.TEXT_PLAIN.toString()) .build(); final Set hopByHopConnectionSpecific = MessageSupport.hopByHopConnectionSpecific(response); - Assertions.assertTrue(hopByHopConnectionSpecific.contains("Connection")); - Assertions.assertTrue(hopByHopConnectionSpecific.contains("connection")); - Assertions.assertTrue(hopByHopConnectionSpecific.contains("coNNection")); - Assertions.assertFalse(hopByHopConnectionSpecific.contains("Content-Type")); - Assertions.assertTrue(hopByHopConnectionSpecific.contains("blah")); - Assertions.assertTrue(hopByHopConnectionSpecific.contains("Blah")); - Assertions.assertTrue(hopByHopConnectionSpecific.contains("This")); - Assertions.assertTrue(hopByHopConnectionSpecific.contains("That")); + Assertions.assertThat(hopByHopConnectionSpecific.contains("Connection")).isTrue(); + Assertions.assertThat(hopByHopConnectionSpecific.contains("connection")).isTrue(); + Assertions.assertThat(hopByHopConnectionSpecific.contains("coNNection")).isTrue(); + Assertions.assertThat(hopByHopConnectionSpecific.contains("Content-Type")).isFalse(); + Assertions.assertThat(hopByHopConnectionSpecific.contains("blah")).isTrue(); + Assertions.assertThat(hopByHopConnectionSpecific.contains("Blah")).isTrue(); + Assertions.assertThat(hopByHopConnectionSpecific.contains("This")).isTrue(); + Assertions.assertThat(hopByHopConnectionSpecific.contains("That")).isTrue(); } @Test void testMessageWithContentLength() throws Exception { final HttpMessage message = new BasicHttpResponse(200); message.addHeader("Content-Length", "100"); - Assertions.assertEquals(100, MessageSupport.getContentLength(message)); + Assertions.assertThat(MessageSupport.getContentLength(message)).isEqualTo(100); } @Test void testMessageWithInvalidContentLength() { final HttpMessage message = new BasicHttpResponse(200); message.addHeader("Content-Length", "whatever"); - Assertions.assertThrows(ProtocolException.class, () -> - MessageSupport.getContentLength(message)); + Assertions.assertThatThrownBy(() -> + MessageSupport.getContentLength(message)).isInstanceOf(ProtocolException.class); } @Test void testMessageWithNegativeContentLength() { final HttpMessage message = new BasicHttpResponse(200); message.addHeader("Content-Length", "-10"); - Assertions.assertThrows(ProtocolException.class, () -> - MessageSupport.getContentLength(message)); + Assertions.assertThatThrownBy(() -> + MessageSupport.getContentLength(message)).isInstanceOf(ProtocolException.class); } @Test void testMessageWithPlusSignedContentLength() { final HttpMessage message = new BasicHttpResponse(200); message.addHeader("Content-Length", "+5"); - Assertions.assertThrows(ProtocolException.class, () -> - MessageSupport.getContentLength(message)); + Assertions.assertThatThrownBy(() -> MessageSupport.getContentLength(message)) + .isInstanceOf(ProtocolException.class); } @Test void testMessageWithEmptyContentLength() { final HttpMessage message = new BasicHttpResponse(200); message.addHeader("Content-Length", ""); - Assertions.assertThrows(ProtocolException.class, () -> - MessageSupport.getContentLength(message)); + Assertions.assertThatThrownBy(() -> MessageSupport.getContentLength(message)) + .isInstanceOf(ProtocolException.class); } @Test void testIsSignedOrEmpty() { - Assertions.assertTrue(MessageSupport.isSignedOrEmpty(null)); - Assertions.assertTrue(MessageSupport.isSignedOrEmpty("")); - Assertions.assertTrue(MessageSupport.isSignedOrEmpty("+5")); - Assertions.assertTrue(MessageSupport.isSignedOrEmpty("-5")); - Assertions.assertTrue(MessageSupport.isSignedOrEmpty("-0")); - Assertions.assertFalse(MessageSupport.isSignedOrEmpty("5")); - Assertions.assertFalse(MessageSupport.isSignedOrEmpty("0005")); - Assertions.assertFalse(MessageSupport.isSignedOrEmpty("a+")); + Assertions.assertThat(MessageSupport.isSignedOrEmpty(null)).isTrue(); + Assertions.assertThat(MessageSupport.isSignedOrEmpty("")).isTrue(); + Assertions.assertThat(MessageSupport.isSignedOrEmpty("+5")).isTrue(); + Assertions.assertThat(MessageSupport.isSignedOrEmpty("-5")).isTrue(); + Assertions.assertThat(MessageSupport.isSignedOrEmpty("-0")).isTrue(); + Assertions.assertThat(MessageSupport.isSignedOrEmpty("5")).isFalse(); + Assertions.assertThat(MessageSupport.isSignedOrEmpty("0005")).isFalse(); + Assertions.assertThat(MessageSupport.isSignedOrEmpty("a+")).isFalse(); } @Test void testMessageWithMinusZeroContentLength() { final HttpMessage message = new BasicHttpResponse(200); message.addHeader("Content-Length", "-0"); - Assertions.assertThrows(ProtocolException.class, () -> - MessageSupport.getContentLength(message)); + Assertions.assertThatThrownBy(() -> MessageSupport.getContentLength(message)) + .isInstanceOf(ProtocolException.class); } @Test void testMessageWithOverflowContentLength() { final HttpMessage message = new BasicHttpResponse(200); message.addHeader("Content-Length", "99999999999999999999"); - Assertions.assertThrows(ProtocolException.class, () -> - MessageSupport.getContentLength(message)); + Assertions.assertThatThrownBy(() -> MessageSupport.getContentLength(message)) + .isInstanceOf(ProtocolException.class); } @Test void testMessageWithLeadingZerosContentLength() throws Exception { final HttpMessage message = new BasicHttpResponse(200); message.addHeader("Content-Length", "005"); - Assertions.assertEquals(5, MessageSupport.getContentLength(message)); + Assertions.assertThat(MessageSupport.getContentLength(message)).isEqualTo(5); } @Test @@ -626,8 +621,8 @@ void testMessageWithMultipleContentLength() throws Exception { final HttpMessage message = new BasicHttpResponse(200); message.addHeader("Content-Length", "100"); message.addHeader("Content-Length", "100"); - Assertions.assertThrows(ProtocolException.class, () -> - MessageSupport.getContentLength(message)); + Assertions.assertThatThrownBy(() -> + MessageSupport.getContentLength(message)).isInstanceOf(ProtocolException.class); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/message/TestNameValuePair.java b/httpcore5/src/test/java/org/apache/hc/core5/http/message/TestNameValuePair.java index 0e2194a3f4..bcbdc409d2 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/message/TestNameValuePair.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/message/TestNameValuePair.java @@ -28,7 +28,7 @@ package org.apache.hc.core5.http.message; import org.apache.hc.core5.http.NameValuePair; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; /** @@ -40,35 +40,37 @@ class TestNameValuePair { @Test void testConstructor() { final NameValuePair param = new BasicNameValuePair("name", "value"); - Assertions.assertEquals("name", param.getName()); - Assertions.assertEquals("value", param.getValue()); + Assertions.assertThat(param.getName()).isEqualTo("name"); + Assertions.assertThat(param.getValue()).isEqualTo("value"); } @Test void testInvalidName() { - Assertions.assertThrows(NullPointerException.class, () -> new BasicNameValuePair(null, null)); + Assertions.assertThatThrownBy(() -> + new BasicNameValuePair(null, null)) + .isInstanceOf(NullPointerException.class); } @Test void testToString() { final NameValuePair param1 = new BasicNameValuePair("name1", "value1"); - Assertions.assertEquals("name1=value1", param1.toString()); + Assertions.assertThat(param1.toString()).isEqualTo("name1=value1"); final NameValuePair param2 = new BasicNameValuePair("name1", null); - Assertions.assertEquals("name1", param2.toString()); + Assertions.assertThat(param2.toString()).isEqualTo("name1"); } @Test void testNullNotEqual() { final NameValuePair NameValuePair = new BasicNameValuePair("name", "value"); - Assertions.assertNotEquals(null, NameValuePair); + Assertions.assertThat(NameValuePair).isNotEqualTo(null); } @Test void testObjectNotEqual() { final NameValuePair NameValuePair = new BasicNameValuePair("name", "value"); - Assertions.assertNotEquals(new Object(), NameValuePair); + Assertions.assertThat(NameValuePair).isNotEqualTo(new Object()); } @Test @@ -76,14 +78,14 @@ void testNameEquals() { final NameValuePair NameValuePair = new BasicNameValuePair("name", "value"); final NameValuePair NameValuePair2 = new BasicNameValuePair("NAME", "value"); - Assertions.assertEquals(NameValuePair, NameValuePair2); - Assertions.assertEquals(NameValuePair.hashCode(), NameValuePair2.hashCode()); + Assertions.assertThat(NameValuePair2).isEqualTo(NameValuePair); + Assertions.assertThat(NameValuePair2.hashCode()).isEqualTo(NameValuePair.hashCode()); final NameValuePair NameValuePair3 = new BasicNameValuePair("NAME", "value"); final NameValuePair NameValuePair4 = new BasicNameValuePair("name", "value"); - Assertions.assertEquals(NameValuePair3, NameValuePair4); - Assertions.assertEquals(NameValuePair3.hashCode(), NameValuePair4.hashCode()); + Assertions.assertThat(NameValuePair4).isEqualTo(NameValuePair3); + Assertions.assertThat(NameValuePair4.hashCode()).isEqualTo(NameValuePair3.hashCode()); } @Test @@ -91,8 +93,8 @@ void testValueEquals() { final NameValuePair NameValuePair = new BasicNameValuePair("name", "value"); final NameValuePair NameValuePair2 = new BasicNameValuePair("name", "value"); - Assertions.assertEquals(NameValuePair, NameValuePair2); - Assertions.assertEquals(NameValuePair.hashCode(), NameValuePair2.hashCode()); + Assertions.assertThat(NameValuePair2).isEqualTo(NameValuePair); + Assertions.assertThat(NameValuePair2.hashCode()).isEqualTo(NameValuePair.hashCode()); } @Test @@ -100,7 +102,7 @@ void testNameNotEqual() { final NameValuePair NameValuePair = new BasicNameValuePair("name", "value"); final NameValuePair NameValuePair2 = new BasicNameValuePair("name2", "value"); - Assertions.assertNotEquals(NameValuePair, NameValuePair2); + Assertions.assertThat(NameValuePair2).isNotEqualTo(NameValuePair); } @Test @@ -108,17 +110,17 @@ void testValueNotEqual() { final NameValuePair NameValuePair = new BasicNameValuePair("name", "value"); final NameValuePair NameValuePair2 = new BasicNameValuePair("name", "value2"); - Assertions.assertNotEquals(NameValuePair, NameValuePair2); + Assertions.assertThat(NameValuePair2).isNotEqualTo(NameValuePair); final NameValuePair NameValuePair3 = new BasicNameValuePair("name", "value"); final NameValuePair NameValuePair4 = new BasicNameValuePair("name", "VALUE"); - Assertions.assertNotEquals(NameValuePair3, NameValuePair4); + Assertions.assertThat(NameValuePair4).isNotEqualTo(NameValuePair3); final NameValuePair NameValuePair5 = new BasicNameValuePair("name", "VALUE"); final NameValuePair NameValuePair6 = new BasicNameValuePair("name", "value"); - Assertions.assertNotEquals(NameValuePair5, NameValuePair6); + Assertions.assertThat(NameValuePair6).isNotEqualTo(NameValuePair5); } @Test @@ -126,8 +128,8 @@ void testNullValuesEquals() { final NameValuePair NameValuePair = new BasicNameValuePair("name", null); final NameValuePair NameValuePair2 = new BasicNameValuePair("name", null); - Assertions.assertEquals(NameValuePair, NameValuePair2); - Assertions.assertEquals(NameValuePair.hashCode(), NameValuePair2.hashCode()); + Assertions.assertThat(NameValuePair2).isEqualTo(NameValuePair); + Assertions.assertThat(NameValuePair2.hashCode()).isEqualTo(NameValuePair.hashCode()); } @Test @@ -135,7 +137,7 @@ void testNullValueNotEqual() { final NameValuePair NameValuePair = new BasicNameValuePair("name", null); final NameValuePair NameValuePair2 = new BasicNameValuePair("name", "value"); - Assertions.assertNotEquals(NameValuePair, NameValuePair2); + Assertions.assertThat(NameValuePair2).isNotEqualTo(NameValuePair); } @Test @@ -143,7 +145,7 @@ void testNullValue2NotEqual() { final NameValuePair NameValuePair = new BasicNameValuePair("name", "value"); final NameValuePair NameValuePair2 = new BasicNameValuePair("name", null); - Assertions.assertNotEquals(NameValuePair, NameValuePair2); + Assertions.assertThat(NameValuePair2).isNotEqualTo(NameValuePair); } @Test @@ -151,12 +153,12 @@ void testEquals() { final NameValuePair NameValuePair = new BasicNameValuePair("name", "value"); final NameValuePair NameValuePair2 = new BasicNameValuePair("name", "value"); - Assertions.assertEquals(NameValuePair, NameValuePair); - Assertions.assertEquals(NameValuePair.hashCode(), NameValuePair.hashCode()); - Assertions.assertEquals(NameValuePair2, NameValuePair2); - Assertions.assertEquals(NameValuePair2.hashCode(), NameValuePair2.hashCode()); - Assertions.assertEquals(NameValuePair, NameValuePair2); - Assertions.assertEquals(NameValuePair.hashCode(), NameValuePair2.hashCode()); + Assertions.assertThat(NameValuePair).isEqualTo(NameValuePair); + Assertions.assertThat(NameValuePair.hashCode()).isEqualTo(NameValuePair.hashCode()); + Assertions.assertThat(NameValuePair2).isEqualTo(NameValuePair2); + Assertions.assertThat(NameValuePair2.hashCode()).isEqualTo(NameValuePair2.hashCode()); + Assertions.assertThat(NameValuePair2).isEqualTo(NameValuePair); + Assertions.assertThat(NameValuePair2.hashCode()).isEqualTo(NameValuePair.hashCode()); } @Test @@ -164,17 +166,17 @@ void testHashCode() { final NameValuePair NameValuePair = new BasicNameValuePair("name", null); final NameValuePair NameValuePair2 = new BasicNameValuePair("name2", null); - Assertions.assertNotEquals(NameValuePair.hashCode(), NameValuePair2.hashCode()); + Assertions.assertThat(NameValuePair2.hashCode()).isNotEqualTo(NameValuePair.hashCode()); final NameValuePair NameValuePair3 = new BasicNameValuePair("name", "value"); final NameValuePair NameValuePair4 = new BasicNameValuePair("name", "value2"); - Assertions.assertNotEquals(NameValuePair3.hashCode(), NameValuePair4.hashCode()); + Assertions.assertThat(NameValuePair4.hashCode()).isNotEqualTo(NameValuePair3.hashCode()); final NameValuePair NameValuePair5 = new BasicNameValuePair("name", "value"); final NameValuePair NameValuePair6 = new BasicNameValuePair("name", null); - Assertions.assertNotEquals(NameValuePair5.hashCode(), NameValuePair6.hashCode()); + Assertions.assertThat(NameValuePair6.hashCode()).isNotEqualTo(NameValuePair5.hashCode()); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/nio/command/TestRequestExecutionCommand.java b/httpcore5/src/test/java/org/apache/hc/core5/http/nio/command/TestRequestExecutionCommand.java index 970cdb0731..fbe9018610 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/nio/command/TestRequestExecutionCommand.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/nio/command/TestRequestExecutionCommand.java @@ -34,7 +34,7 @@ import org.apache.hc.core5.http.nio.AsyncPushConsumer; import org.apache.hc.core5.http.nio.HandlerFactory; import org.apache.hc.core5.http.protocol.HttpCoreContext; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.mockito.Mockito; @@ -85,8 +85,8 @@ void cancelInvokesNotExecutedExceptionOnce() { final AsyncClientExchangeHandler handler = Mockito.mock(AsyncClientExchangeHandler.class); final RequestExecutionCommand command = new RequestExecutionCommand(handler, HttpCoreContext.create()); - Assertions.assertTrue(command.cancel()); - Assertions.assertFalse(command.cancel()); + Assertions.assertThat(command.cancel()).isTrue(); + Assertions.assertThat(command.cancel()).isFalse(); Mockito.verify(handler).failed(Mockito.isA(RequestNotExecutedException.class)); Mockito.verify(handler).releaseResources(); @@ -99,9 +99,9 @@ void gettersExposeConstructorValues() { final HandlerFactory pushFactory = Mockito.mock(HandlerFactory.class); final RequestExecutionCommand command = new RequestExecutionCommand(handler, pushFactory, HttpCoreContext.create()); - Assertions.assertSame(handler, command.getExchangeHandler()); - Assertions.assertSame(pushFactory, command.getPushHandlerFactory()); - Assertions.assertNotNull(command.getContext()); + Assertions.assertThat(command.getExchangeHandler()).isSameAs(handler); + Assertions.assertThat(command.getPushHandlerFactory()).isSameAs(pushFactory); + Assertions.assertThat(command.getContext()).isNotNull(); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/nio/command/TestShutdownCommand.java b/httpcore5/src/test/java/org/apache/hc/core5/http/nio/command/TestShutdownCommand.java index 82e7e6e716..b3fefd072f 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/nio/command/TestShutdownCommand.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/nio/command/TestShutdownCommand.java @@ -29,7 +29,7 @@ import org.apache.hc.core5.io.CloseMode; import org.apache.hc.core5.reactor.Command; import org.apache.hc.core5.reactor.IOSession; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.mockito.Mockito; @@ -38,7 +38,7 @@ class TestShutdownCommand { @Test void cancelAlwaysReturnsTrue() { final ShutdownCommand command = new ShutdownCommand(CloseMode.GRACEFUL); - Assertions.assertTrue(command.cancel()); + Assertions.assertThat(command.cancel()).isTrue(); } @Test @@ -55,7 +55,7 @@ void callbacksEnqueueGracefulShutdown() { @Test void toStringIncludesType() { final ShutdownCommand command = new ShutdownCommand(CloseMode.IMMEDIATE); - Assertions.assertTrue(command.toString().contains("IMMEDIATE")); + Assertions.assertThat(command.toString().contains("IMMEDIATE")).isTrue(); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/nio/command/TestStaleCheckCommand.java b/httpcore5/src/test/java/org/apache/hc/core5/http/nio/command/TestStaleCheckCommand.java index d37eb2f1da..98eab15912 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/nio/command/TestStaleCheckCommand.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/nio/command/TestStaleCheckCommand.java @@ -28,7 +28,7 @@ import java.util.concurrent.atomic.AtomicReference; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class TestStaleCheckCommand { @@ -38,8 +38,8 @@ void cancelInvokesCallbackFalse() { final AtomicReference called = new AtomicReference<>(); final StaleCheckCommand command = new StaleCheckCommand(called::set); - Assertions.assertTrue(command.cancel()); - Assertions.assertEquals(Boolean.FALSE, called.get()); + Assertions.assertThat(command.cancel()).isTrue(); + Assertions.assertThat(called.get()).isEqualTo(Boolean.FALSE); } @Test @@ -49,7 +49,7 @@ void exposesCallback() { command.getCallback().accept(Boolean.TRUE); - Assertions.assertEquals(Boolean.TRUE, called.get()); + Assertions.assertThat(called.get()).isEqualTo(Boolean.TRUE); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/nio/entity/TestAbstractBinAsyncEntityConsumer.java b/httpcore5/src/test/java/org/apache/hc/core5/http/nio/entity/TestAbstractBinAsyncEntityConsumer.java index f20e95232b..971e5d1b80 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/nio/entity/TestAbstractBinAsyncEntityConsumer.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/nio/entity/TestAbstractBinAsyncEntityConsumer.java @@ -36,7 +36,7 @@ import org.apache.hc.core5.http.impl.BasicEntityDetails; import org.apache.hc.core5.http.nio.AsyncEntityConsumer; import org.apache.hc.core5.util.ByteArrayBuffer; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class TestAbstractBinAsyncEntityConsumer { @@ -85,11 +85,12 @@ void testConsumeData() throws Exception { consumer.consume(ByteBuffer.wrap(new byte[]{'4', '5'})); consumer.consume(ByteBuffer.wrap(new byte[]{})); - Assertions.assertNull(consumer.getContent()); + Assertions.assertThat(consumer.getContent()).isNull(); consumer.streamEnd(null); - Assertions.assertArrayEquals(new byte[] {'1', '2', '3', '4', '5'}, consumer.getContent()); - Assertions.assertEquals(1L, countingCallback.getCount()); + Assertions.assertThat(consumer.getContent()) + .containsExactly(new byte[]{'1', '2', '3', '4', '5'}); + Assertions.assertThat(countingCallback.getCount()).isEqualTo(1L); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/nio/entity/TestAbstractBinAsyncEntityProducer.java b/httpcore5/src/test/java/org/apache/hc/core5/http/nio/entity/TestAbstractBinAsyncEntityProducer.java index ec2ff08f85..7ec3ab08df 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/nio/entity/TestAbstractBinAsyncEntityProducer.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/nio/entity/TestAbstractBinAsyncEntityProducer.java @@ -37,7 +37,7 @@ import org.apache.hc.core5.http.nio.BasicDataStreamChannel; import org.apache.hc.core5.http.nio.DataStreamChannel; import org.apache.hc.core5.http.nio.StreamChannel; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class TestAbstractBinAsyncEntityProducer { @@ -132,22 +132,22 @@ void testProduceDataNoBuffering() throws Exception { new byte[] { '1', '2', '3' }, new byte[] { '4', '5', '6' }); - Assertions.assertEquals(-1, producer.getContentLength()); - Assertions.assertEquals(ContentType.TEXT_PLAIN.toString(), producer.getContentType()); - Assertions.assertNull(producer.getContentEncoding()); + Assertions.assertThat(producer.getContentLength()).isEqualTo(-1); + Assertions.assertThat(producer.getContentType()).isEqualTo(ContentType.TEXT_PLAIN.toString()); + Assertions.assertThat(producer.getContentEncoding()).isNull(); final WritableByteChannelMock byteChannel = new WritableByteChannelMock(1024); final DataStreamChannel streamChannel = new BasicDataStreamChannel(byteChannel); producer.produce(streamChannel); - Assertions.assertTrue(byteChannel.isOpen()); - Assertions.assertEquals("123", byteChannel.dump(StandardCharsets.US_ASCII)); + Assertions.assertThat(byteChannel.isOpen()).isTrue(); + Assertions.assertThat(byteChannel.dump(StandardCharsets.US_ASCII)).isEqualTo("123"); producer.produce(streamChannel); - Assertions.assertFalse(byteChannel.isOpen()); - Assertions.assertEquals("456", byteChannel.dump(StandardCharsets.US_ASCII)); + Assertions.assertThat(byteChannel.isOpen()).isFalse(); + Assertions.assertThat(byteChannel.dump(StandardCharsets.US_ASCII)).isEqualTo("456"); } @Test @@ -164,20 +164,20 @@ void testProduceDataWithBuffering1() throws Exception { final DataStreamChannel streamChannel = new BasicDataStreamChannel(byteChannel); producer.produce(streamChannel); - Assertions.assertTrue(byteChannel.isOpen()); - Assertions.assertEquals("", byteChannel.dump(StandardCharsets.US_ASCII)); + Assertions.assertThat(byteChannel.isOpen()).isTrue(); + Assertions.assertThat(byteChannel.dump(StandardCharsets.US_ASCII)).isEqualTo(""); producer.produce(streamChannel); - Assertions.assertTrue(byteChannel.isOpen()); - Assertions.assertEquals("123", byteChannel.dump(StandardCharsets.US_ASCII)); + Assertions.assertThat(byteChannel.isOpen()).isTrue(); + Assertions.assertThat(byteChannel.dump(StandardCharsets.US_ASCII)).isEqualTo("123"); producer.produce(streamChannel); - Assertions.assertTrue(byteChannel.isOpen()); - Assertions.assertEquals("45678", byteChannel.dump(StandardCharsets.US_ASCII)); + Assertions.assertThat(byteChannel.isOpen()).isTrue(); + Assertions.assertThat(byteChannel.dump(StandardCharsets.US_ASCII)).isEqualTo("45678"); producer.produce(streamChannel); - Assertions.assertFalse(byteChannel.isOpen()); - Assertions.assertEquals("90", byteChannel.dump(StandardCharsets.US_ASCII)); + Assertions.assertThat(byteChannel.isOpen()).isFalse(); + Assertions.assertThat(byteChannel.dump(StandardCharsets.US_ASCII)).isEqualTo("90"); } @Test @@ -197,32 +197,32 @@ void testProduceDataWithBuffering2() throws Exception { final DataStreamChannel streamChannel = new BasicDataStreamChannel(byteChannel); producer.produce(streamChannel); - Assertions.assertTrue(byteChannel.isOpen()); - Assertions.assertEquals("", byteChannel.dump(StandardCharsets.US_ASCII)); + Assertions.assertThat(byteChannel.isOpen()).isTrue(); + Assertions.assertThat(byteChannel.dump(StandardCharsets.US_ASCII)).isEqualTo(""); producer.produce(streamChannel); - Assertions.assertTrue(byteChannel.isOpen()); - Assertions.assertEquals("", byteChannel.dump(StandardCharsets.US_ASCII)); + Assertions.assertThat(byteChannel.isOpen()).isTrue(); + Assertions.assertThat(byteChannel.dump(StandardCharsets.US_ASCII)).isEqualTo(""); producer.produce(streamChannel); - Assertions.assertTrue(byteChannel.isOpen()); - Assertions.assertEquals("", byteChannel.dump(StandardCharsets.US_ASCII)); + Assertions.assertThat(byteChannel.isOpen()).isTrue(); + Assertions.assertThat(byteChannel.dump(StandardCharsets.US_ASCII)).isEqualTo(""); producer.produce(streamChannel); - Assertions.assertTrue(byteChannel.isOpen()); - Assertions.assertEquals("12345", byteChannel.dump(StandardCharsets.US_ASCII)); + Assertions.assertThat(byteChannel.isOpen()).isTrue(); + Assertions.assertThat(byteChannel.dump(StandardCharsets.US_ASCII)).isEqualTo("12345"); producer.produce(streamChannel); - Assertions.assertTrue(byteChannel.isOpen()); - Assertions.assertEquals("", byteChannel.dump(StandardCharsets.US_ASCII)); + Assertions.assertThat(byteChannel.isOpen()).isTrue(); + Assertions.assertThat(byteChannel.dump(StandardCharsets.US_ASCII)).isEqualTo(""); producer.produce(streamChannel); - Assertions.assertTrue(byteChannel.isOpen()); - Assertions.assertEquals("", byteChannel.dump(StandardCharsets.US_ASCII)); + Assertions.assertThat(byteChannel.isOpen()).isTrue(); + Assertions.assertThat(byteChannel.dump(StandardCharsets.US_ASCII)).isEqualTo(""); producer.produce(streamChannel); - Assertions.assertFalse(byteChannel.isOpen()); - Assertions.assertEquals("67890", byteChannel.dump(StandardCharsets.US_ASCII)); + Assertions.assertThat(byteChannel.isOpen()).isFalse(); + Assertions.assertThat(byteChannel.dump(StandardCharsets.US_ASCII)).isEqualTo("67890"); } @@ -233,15 +233,15 @@ void testProduceDataRepeatableAfterPartialWrite() throws Exception { final WritableByteChannelMock partialByteChannel = new WritableByteChannelMock(1024, 3); producer.produce(new BasicDataStreamChannel(partialByteChannel)); - Assertions.assertEquals("abc", partialByteChannel.dump(StandardCharsets.US_ASCII)); + Assertions.assertThat(partialByteChannel.dump(StandardCharsets.US_ASCII)).isEqualTo("abc"); producer.releaseResources(); final WritableByteChannelMock byteChannel = new WritableByteChannelMock(1024); final DataStreamChannel streamChannel = new BasicDataStreamChannel(byteChannel); producer.produce(streamChannel); - Assertions.assertFalse(byteChannel.isOpen()); - Assertions.assertEquals("abcdef", byteChannel.dump(StandardCharsets.US_ASCII)); + Assertions.assertThat(byteChannel.isOpen()).isFalse(); + Assertions.assertThat(byteChannel.dump(StandardCharsets.US_ASCII)).isEqualTo("abcdef"); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/nio/entity/TestAbstractCharAsyncEntityProducer.java b/httpcore5/src/test/java/org/apache/hc/core5/http/nio/entity/TestAbstractCharAsyncEntityProducer.java index f1497f2a14..beae4af294 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/nio/entity/TestAbstractCharAsyncEntityProducer.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/nio/entity/TestAbstractCharAsyncEntityProducer.java @@ -37,7 +37,7 @@ import org.apache.hc.core5.http.nio.BasicDataStreamChannel; import org.apache.hc.core5.http.nio.DataStreamChannel; import org.apache.hc.core5.http.nio.StreamChannel; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class TestAbstractCharAsyncEntityProducer { @@ -89,22 +89,22 @@ void testProduceDataNoBuffering() throws Exception { final AsyncEntityProducer producer = new ChunkCharAsyncEntityProducer( 256, 0, ContentType.TEXT_PLAIN, "this", "this and that"); - Assertions.assertEquals(-1, producer.getContentLength()); - Assertions.assertEquals(ContentType.TEXT_PLAIN.toString(), producer.getContentType()); - Assertions.assertNull(producer.getContentEncoding()); + Assertions.assertThat(producer.getContentLength()).isEqualTo(-1); + Assertions.assertThat(producer.getContentType()).isEqualTo(ContentType.TEXT_PLAIN.toString()); + Assertions.assertThat(producer.getContentEncoding()).isNull(); final WritableByteChannelMock byteChannel = new WritableByteChannelMock(1024); final DataStreamChannel streamChannel = new BasicDataStreamChannel(byteChannel); producer.produce(streamChannel); - Assertions.assertTrue(byteChannel.isOpen()); - Assertions.assertEquals("this", byteChannel.dump(StandardCharsets.US_ASCII)); + Assertions.assertThat(byteChannel.isOpen()).isTrue(); + Assertions.assertThat(byteChannel.dump(StandardCharsets.US_ASCII)).isEqualTo("this"); producer.produce(streamChannel); - Assertions.assertFalse(byteChannel.isOpen()); - Assertions.assertEquals("this and that", byteChannel.dump(StandardCharsets.US_ASCII)); + Assertions.assertThat(byteChannel.isOpen()).isFalse(); + Assertions.assertThat(byteChannel.dump(StandardCharsets.US_ASCII)).isEqualTo("this and that"); } @Test @@ -117,20 +117,20 @@ void testProduceDataWithBuffering() throws Exception { final DataStreamChannel streamChannel = new BasicDataStreamChannel(byteChannel); producer.produce(streamChannel); - Assertions.assertTrue(byteChannel.isOpen()); - Assertions.assertEquals("", byteChannel.dump(StandardCharsets.US_ASCII)); + Assertions.assertThat(byteChannel.isOpen()).isTrue(); + Assertions.assertThat(byteChannel.dump(StandardCharsets.US_ASCII)).isEqualTo(""); producer.produce(streamChannel); - Assertions.assertTrue(byteChannel.isOpen()); - Assertions.assertEquals("this and that", byteChannel.dump(StandardCharsets.US_ASCII)); + Assertions.assertThat(byteChannel.isOpen()).isTrue(); + Assertions.assertThat(byteChannel.dump(StandardCharsets.US_ASCII)).isEqualTo("this and that"); producer.produce(streamChannel); - Assertions.assertTrue(byteChannel.isOpen()); - Assertions.assertEquals("", byteChannel.dump(StandardCharsets.US_ASCII)); + Assertions.assertThat(byteChannel.isOpen()).isTrue(); + Assertions.assertThat(byteChannel.dump(StandardCharsets.US_ASCII)).isEqualTo(""); producer.produce(streamChannel); - Assertions.assertFalse(byteChannel.isOpen()); - Assertions.assertEquals("all sorts of stuff", byteChannel.dump(StandardCharsets.US_ASCII)); + Assertions.assertThat(byteChannel.isOpen()).isFalse(); + Assertions.assertThat(byteChannel.dump(StandardCharsets.US_ASCII)).isEqualTo("all sorts of stuff"); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/nio/entity/TestAsyncEntityProducers.java b/httpcore5/src/test/java/org/apache/hc/core5/http/nio/entity/TestAsyncEntityProducers.java index 237965305a..f7adf0a7d4 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/nio/entity/TestAsyncEntityProducers.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/nio/entity/TestAsyncEntityProducers.java @@ -38,7 +38,7 @@ import org.apache.hc.core5.http.Header; import org.apache.hc.core5.http.message.BasicHeader; import org.apache.hc.core5.http.nio.AsyncEntityProducer; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; /** @@ -52,9 +52,9 @@ void testPathEntityProducer() throws IOException { final AsyncEntityProducer producer = AsyncEntityProducers.create(path, ContentType.APPLICATION_OCTET_STREAM, StandardOpenOption.READ, LinkOption.NOFOLLOW_LINKS); try { - Assertions.assertFalse(producer.isChunked()); - Assertions.assertEquals(Files.size(path), producer.getContentLength()); - Assertions.assertEquals(ContentType.APPLICATION_OCTET_STREAM.toString(), producer.getContentType()); + Assertions.assertThat(producer.isChunked()).isFalse(); + Assertions.assertThat(producer.getContentLength()).isEqualTo(Files.size(path)); + Assertions.assertThat(producer.getContentType()).isEqualTo(ContentType.APPLICATION_OCTET_STREAM.toString()); } finally { producer.releaseResources(); } @@ -68,9 +68,9 @@ void testPathEntityProducerWithTrailers() throws IOException { final AsyncEntityProducer producer = AsyncEntityProducers.create(path, ContentType.APPLICATION_OCTET_STREAM, header1, header2); try { - Assertions.assertTrue(producer.isChunked()); - Assertions.assertEquals(-1, producer.getContentLength()); - Assertions.assertEquals(ContentType.APPLICATION_OCTET_STREAM.toString(), producer.getContentType()); + Assertions.assertThat(producer.isChunked()).isTrue(); + Assertions.assertThat(producer.getContentLength()).isEqualTo(-1); + Assertions.assertThat(producer.getContentType()).isEqualTo(ContentType.APPLICATION_OCTET_STREAM.toString()); } finally { producer.releaseResources(); } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/nio/entity/TestBasicAsyncEntityProducer.java b/httpcore5/src/test/java/org/apache/hc/core5/http/nio/entity/TestBasicAsyncEntityProducer.java index 0a66cf5965..109ccef7a9 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/nio/entity/TestBasicAsyncEntityProducer.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/nio/entity/TestBasicAsyncEntityProducer.java @@ -34,7 +34,7 @@ import org.apache.hc.core5.http.nio.AsyncEntityProducer; import org.apache.hc.core5.http.nio.BasicDataStreamChannel; import org.apache.hc.core5.http.nio.DataStreamChannel; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class TestBasicAsyncEntityProducer { @@ -45,17 +45,17 @@ void testBinaryContent() throws Exception { final AsyncEntityProducer producer = new BasicAsyncEntityProducer( new byte[] { 'a', 'b', 'c' }, ContentType.DEFAULT_BINARY); - Assertions.assertEquals(3, producer.getContentLength()); - Assertions.assertEquals(ContentType.DEFAULT_BINARY.toString(), producer.getContentType()); - Assertions.assertNull(producer.getContentEncoding()); + Assertions.assertThat(producer.getContentLength()).isEqualTo(3); + Assertions.assertThat(producer.getContentType()).isEqualTo(ContentType.DEFAULT_BINARY.toString()); + Assertions.assertThat(producer.getContentEncoding()).isNull(); final WritableByteChannelMock byteChannel = new WritableByteChannelMock(1024); final DataStreamChannel streamChannel = new BasicDataStreamChannel(byteChannel); producer.produce(streamChannel); - Assertions.assertFalse(byteChannel.isOpen()); - Assertions.assertEquals("abc", byteChannel.dump(StandardCharsets.US_ASCII)); + Assertions.assertThat(byteChannel.isOpen()).isFalse(); + Assertions.assertThat(byteChannel.dump(StandardCharsets.US_ASCII)).isEqualTo("abc"); } @Test @@ -64,17 +64,17 @@ void testTextContent() throws Exception { final AsyncEntityProducer producer = new BasicAsyncEntityProducer( "abc", ContentType.TEXT_PLAIN); - Assertions.assertEquals(3, producer.getContentLength()); - Assertions.assertEquals(ContentType.TEXT_PLAIN.toString(), producer.getContentType()); - Assertions.assertNull(producer.getContentEncoding()); + Assertions.assertThat(producer.getContentLength()).isEqualTo(3); + Assertions.assertThat(producer.getContentType()).isEqualTo(ContentType.TEXT_PLAIN.toString()); + Assertions.assertThat(producer.getContentEncoding()).isNull(); final WritableByteChannelMock byteChannel = new WritableByteChannelMock(1024); final DataStreamChannel streamChannel = new BasicDataStreamChannel(byteChannel); producer.produce(streamChannel); - Assertions.assertFalse(byteChannel.isOpen()); - Assertions.assertEquals("abc", byteChannel.dump(StandardCharsets.US_ASCII)); + Assertions.assertThat(byteChannel.isOpen()).isFalse(); + Assertions.assertThat(byteChannel.dump(StandardCharsets.US_ASCII)).isEqualTo("abc"); } @Test @@ -82,9 +82,9 @@ void testTextContentRepeatable() throws Exception { final AsyncEntityProducer producer = new BasicAsyncEntityProducer( "abc", ContentType.TEXT_PLAIN); - Assertions.assertEquals(3, producer.getContentLength()); - Assertions.assertEquals(ContentType.TEXT_PLAIN.toString(), producer.getContentType()); - Assertions.assertNull(producer.getContentEncoding()); + Assertions.assertThat(producer.getContentLength()).isEqualTo(3); + Assertions.assertThat(producer.getContentType()).isEqualTo(ContentType.TEXT_PLAIN.toString()); + Assertions.assertThat(producer.getContentEncoding()).isNull(); for (int i = 0; i < 3; i++) { final WritableByteChannelMock byteChannel = new WritableByteChannelMock(1024); @@ -92,8 +92,8 @@ void testTextContentRepeatable() throws Exception { producer.produce(streamChannel); - Assertions.assertFalse(byteChannel.isOpen()); - Assertions.assertEquals("abc", byteChannel.dump(StandardCharsets.US_ASCII)); + Assertions.assertThat(byteChannel.isOpen()).isFalse(); + Assertions.assertThat(byteChannel.dump(StandardCharsets.US_ASCII)).isEqualTo("abc"); producer.releaseResources(); } @@ -107,8 +107,8 @@ void testTextContentRepeatableUTF() throws Exception { final WritableByteChannelMock byteChannel = new WritableByteChannelMock(1024); final DataStreamChannel streamChannel = new BasicDataStreamChannel(byteChannel); producer.produce(streamChannel); - Assertions.assertFalse(byteChannel.isOpen()); - Assertions.assertEquals(content, byteChannel.dump(StandardCharsets.UTF_8)); + Assertions.assertThat(byteChannel.isOpen()).isFalse(); + Assertions.assertThat(byteChannel.dump(StandardCharsets.UTF_8)).isEqualTo(content); producer.releaseResources(); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/nio/entity/TestCharSequenceAsyncEntityConsumer.java b/httpcore5/src/test/java/org/apache/hc/core5/http/nio/entity/TestCharSequenceAsyncEntityConsumer.java index 2a4f199ef8..ecfc6f6142 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/nio/entity/TestCharSequenceAsyncEntityConsumer.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/nio/entity/TestCharSequenceAsyncEntityConsumer.java @@ -35,7 +35,7 @@ import org.apache.hc.core5.http.impl.BasicEntityDetails; import org.apache.hc.core5.http.nio.AsyncEntityConsumer; import org.apache.hc.core5.util.ByteArrayBuffer; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class TestCharSequenceAsyncEntityConsumer { @@ -50,11 +50,11 @@ void testConsumeData() throws Exception { consumer.consume(ByteBuffer.wrap(new byte[]{'4', '5'})); consumer.consume(ByteBuffer.wrap(new byte[]{})); - Assertions.assertNull(consumer.getContent()); + Assertions.assertThat(consumer.getContent()).isNull(); consumer.streamEnd(null); - Assertions.assertEquals("12345", consumer.getContent()); - Assertions.assertEquals(1L, countingCallback.getCount()); + Assertions.assertThat(consumer.getContent()).isEqualTo("12345"); + Assertions.assertThat(countingCallback.getCount()).isEqualTo(1L); } @Test @@ -86,8 +86,8 @@ void testConsumeIncompleteData() throws Exception { consumer.streamEnd(null); - Assertions.assertEquals("stuff£stuff£stuff", consumer.getContent()); - Assertions.assertEquals(1L, countingCallback.getCount()); + Assertions.assertThat(consumer.getContent()).isEqualTo("stuff£stuff£stuff"); + Assertions.assertThat(countingCallback.getCount()).isEqualTo(1L); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/nio/entity/TestDigestingEntityConsumer.java b/httpcore5/src/test/java/org/apache/hc/core5/http/nio/entity/TestDigestingEntityConsumer.java index 2c61df6750..1e23b9e768 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/nio/entity/TestDigestingEntityConsumer.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/nio/entity/TestDigestingEntityConsumer.java @@ -30,7 +30,7 @@ import java.nio.ByteBuffer; import org.apache.hc.core5.util.TextUtils; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class TestDigestingEntityConsumer { @@ -46,8 +46,8 @@ void testConsumeData() throws Exception { consumer.consume(ByteBuffer.wrap(new byte[]{})); consumer.streamEnd(null); - Assertions.assertEquals("12345", consumer.getContent()); - Assertions.assertEquals("827ccb0eea8a706c4c34a16891f84e7b", TextUtils.toHexString(consumer.getDigest())); + Assertions.assertThat(consumer.getContent()).isEqualTo("12345"); + Assertions.assertThat(TextUtils.toHexString(consumer.getDigest())).isEqualTo("827ccb0eea8a706c4c34a16891f84e7b"); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/nio/entity/TestDigestingEntityProducer.java b/httpcore5/src/test/java/org/apache/hc/core5/http/nio/entity/TestDigestingEntityProducer.java index 2d0ec05969..2c596d8679 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/nio/entity/TestDigestingEntityProducer.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/nio/entity/TestDigestingEntityProducer.java @@ -35,7 +35,7 @@ import org.apache.hc.core5.http.WritableByteChannelMock; import org.apache.hc.core5.http.nio.BasicDataStreamChannel; import org.apache.hc.core5.util.TextUtils; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class TestDigestingEntityProducer { @@ -52,15 +52,15 @@ void testProduceData() throws Exception { producer.produce(dataStreamChannel); } - Assertions.assertEquals("12345", byteChannel.dump(StandardCharsets.US_ASCII)); + Assertions.assertThat(byteChannel.dump(StandardCharsets.US_ASCII)).isEqualTo("12345"); final List
trailers = dataStreamChannel.getTrailers(); - Assertions.assertNotNull(trailers); - Assertions.assertEquals(2, trailers.size()); + Assertions.assertThat(trailers).isNotNull(); + Assertions.assertThat(trailers.size()).isEqualTo(2); - Assertions.assertEquals("digest-algo", trailers.get(0).getName()); - Assertions.assertEquals("MD5", trailers.get(0).getValue()); - Assertions.assertEquals("digest", trailers.get(1).getName()); - Assertions.assertEquals("827ccb0eea8a706c4c34a16891f84e7b", trailers.get(1).getValue()); + Assertions.assertThat(trailers.get(0).getName()).isEqualTo("digest-algo"); + Assertions.assertThat(trailers.get(0).getValue()).isEqualTo("MD5"); + Assertions.assertThat(trailers.get(1).getName()).isEqualTo("digest"); + Assertions.assertThat(trailers.get(1).getValue()).isEqualTo("827ccb0eea8a706c4c34a16891f84e7b"); } @Test @@ -70,7 +70,7 @@ void testProduceDataRepeatableAfterPartialWrite() throws Exception { final WritableByteChannelMock partialByteChannel = new WritableByteChannelMock(1024, 3); producer.produce(new BasicDataStreamChannel(partialByteChannel)); - Assertions.assertEquals("abc", partialByteChannel.dump(StandardCharsets.US_ASCII)); + Assertions.assertThat(partialByteChannel.dump(StandardCharsets.US_ASCII)).isEqualTo("abc"); producer.releaseResources(); final WritableByteChannelMock byteChannel = new WritableByteChannelMock(1024); @@ -79,13 +79,13 @@ void testProduceDataRepeatableAfterPartialWrite() throws Exception { producer.produce(dataStreamChannel); } - Assertions.assertEquals("abcdef", byteChannel.dump(StandardCharsets.US_ASCII)); - Assertions.assertEquals("e80b5017098950fc58aad83c8c14978e", TextUtils.toHexString(producer.getDigest())); + Assertions.assertThat(byteChannel.dump(StandardCharsets.US_ASCII)).isEqualTo("abcdef"); + Assertions.assertThat(TextUtils.toHexString(producer.getDigest())).isEqualTo("e80b5017098950fc58aad83c8c14978e"); final List
trailers = dataStreamChannel.getTrailers(); - Assertions.assertNotNull(trailers); - Assertions.assertEquals("digest", trailers.get(1).getName()); - Assertions.assertEquals("e80b5017098950fc58aad83c8c14978e", trailers.get(1).getValue()); + Assertions.assertThat(trailers).isNotNull(); + Assertions.assertThat(trailers.get(1).getName()).isEqualTo("digest"); + Assertions.assertThat(trailers.get(1).getValue()).isEqualTo("e80b5017098950fc58aad83c8c14978e"); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/nio/entity/TestFileAsyncEntityProducer.java b/httpcore5/src/test/java/org/apache/hc/core5/http/nio/entity/TestFileAsyncEntityProducer.java index 442032ad21..f6b2b55333 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/nio/entity/TestFileAsyncEntityProducer.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/nio/entity/TestFileAsyncEntityProducer.java @@ -38,8 +38,8 @@ import org.apache.hc.core5.http.nio.AsyncEntityProducer; import org.apache.hc.core5.http.nio.BasicDataStreamChannel; import org.apache.hc.core5.http.nio.DataStreamChannel; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.AfterEach; -import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -68,9 +68,9 @@ void testTextContent() throws Exception { final AsyncEntityProducer producer = new FileEntityProducer(tempFile, ContentType.TEXT_PLAIN); - Assertions.assertEquals(6, producer.getContentLength()); - Assertions.assertEquals(ContentType.TEXT_PLAIN.toString(), producer.getContentType()); - Assertions.assertNull(producer.getContentEncoding()); + Assertions.assertThat(producer.getContentLength()).isEqualTo(6); + Assertions.assertThat(producer.getContentType()).isEqualTo(ContentType.TEXT_PLAIN.toString()); + Assertions.assertThat(producer.getContentEncoding()).isNull(); final WritableByteChannelMock byteChannel = new WritableByteChannelMock(1024); final DataStreamChannel streamChannel = new BasicDataStreamChannel(byteChannel); @@ -78,17 +78,17 @@ void testTextContent() throws Exception { producer.produce(streamChannel); producer.produce(streamChannel); - Assertions.assertFalse(byteChannel.isOpen()); - Assertions.assertEquals("abcdef", byteChannel.dump(StandardCharsets.US_ASCII)); + Assertions.assertThat(byteChannel.isOpen()).isFalse(); + Assertions.assertThat(byteChannel.dump(StandardCharsets.US_ASCII)).isEqualTo("abcdef"); } @Test void testTextContentRepeatable() throws Exception { final AsyncEntityProducer producer = new FileEntityProducer(tempFile, ContentType.TEXT_PLAIN); - Assertions.assertEquals(6, producer.getContentLength()); - Assertions.assertEquals(ContentType.TEXT_PLAIN.toString(), producer.getContentType()); - Assertions.assertNull(producer.getContentEncoding()); + Assertions.assertThat(producer.getContentLength()).isEqualTo(6); + Assertions.assertThat(producer.getContentType()).isEqualTo(ContentType.TEXT_PLAIN.toString()); + Assertions.assertThat(producer.getContentEncoding()).isNull(); for (int i = 0; i < 3; i++) { final WritableByteChannelMock byteChannel = new WritableByteChannelMock(1024); @@ -97,8 +97,8 @@ void testTextContentRepeatable() throws Exception { producer.produce(streamChannel); producer.produce(streamChannel); - Assertions.assertFalse(byteChannel.isOpen()); - Assertions.assertEquals("abcdef", byteChannel.dump(StandardCharsets.US_ASCII)); + Assertions.assertThat(byteChannel.isOpen()).isFalse(); + Assertions.assertThat(byteChannel.dump(StandardCharsets.US_ASCII)).isEqualTo("abcdef"); producer.releaseResources(); } @@ -110,7 +110,7 @@ void testTextContentRepeatableAfterPartialWrite() throws Exception { final WritableByteChannelMock partialByteChannel = new WritableByteChannelMock(1024, 3); producer.produce(new BasicDataStreamChannel(partialByteChannel)); - Assertions.assertEquals("abc", partialByteChannel.dump(StandardCharsets.US_ASCII)); + Assertions.assertThat(partialByteChannel.dump(StandardCharsets.US_ASCII)).isEqualTo("abc"); producer.releaseResources(); final WritableByteChannelMock byteChannel = new WritableByteChannelMock(1024); @@ -118,8 +118,8 @@ void testTextContentRepeatableAfterPartialWrite() throws Exception { producer.produce(streamChannel); producer.produce(streamChannel); - Assertions.assertFalse(byteChannel.isOpen()); - Assertions.assertEquals("abcdef", byteChannel.dump(StandardCharsets.US_ASCII)); + Assertions.assertThat(byteChannel.isOpen()).isFalse(); + Assertions.assertThat(byteChannel.dump(StandardCharsets.US_ASCII)).isEqualTo("abcdef"); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/nio/entity/TestFileEntityProducer.java b/httpcore5/src/test/java/org/apache/hc/core5/http/nio/entity/TestFileEntityProducer.java index f01d6c7200..37550be1d0 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/nio/entity/TestFileEntityProducer.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/nio/entity/TestFileEntityProducer.java @@ -31,7 +31,7 @@ import java.nio.file.Files; import java.nio.file.Path; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.io.TempDir; @@ -47,7 +47,7 @@ void testFileLengthMaxIntPlusOne(@TempDir final Path tempFolder) throws IOExcept final long expectedLength = 1L + Integer.MAX_VALUE; raFile.setLength(expectedLength); final FileEntityProducer fileEntityProducer = new FileEntityProducer(path.toFile()); - Assertions.assertEquals(expectedLength, fileEntityProducer.getContentLength()); + Assertions.assertThat(fileEntityProducer.getContentLength()).isEqualTo(expectedLength); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/nio/entity/TestPathAsyncEntityProducer.java b/httpcore5/src/test/java/org/apache/hc/core5/http/nio/entity/TestPathAsyncEntityProducer.java index 975603f582..5332b89e2b 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/nio/entity/TestPathAsyncEntityProducer.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/nio/entity/TestPathAsyncEntityProducer.java @@ -40,8 +40,8 @@ import org.apache.hc.core5.http.nio.AsyncEntityProducer; import org.apache.hc.core5.http.nio.BasicDataStreamChannel; import org.apache.hc.core5.http.nio.DataStreamChannel; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.AfterEach; -import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -72,9 +72,9 @@ void testTextContent() throws Exception { final Path tempPath = tempFile.toPath(); final AsyncEntityProducer producer = new PathEntityProducer(tempPath, ContentType.TEXT_PLAIN, StandardOpenOption.READ); - Assertions.assertEquals(6, producer.getContentLength()); - Assertions.assertEquals(ContentType.TEXT_PLAIN.toString(), producer.getContentType()); - Assertions.assertNull(producer.getContentEncoding()); + Assertions.assertThat(producer.getContentLength()).isEqualTo(6); + Assertions.assertThat(producer.getContentType()).isEqualTo(ContentType.TEXT_PLAIN.toString()); + Assertions.assertThat(producer.getContentEncoding()).isNull(); final WritableByteChannelMock byteChannel = new WritableByteChannelMock(1024); final DataStreamChannel streamChannel = new BasicDataStreamChannel(byteChannel); @@ -82,8 +82,8 @@ void testTextContent() throws Exception { producer.produce(streamChannel); producer.produce(streamChannel); - Assertions.assertFalse(byteChannel.isOpen()); - Assertions.assertEquals("abcdef", byteChannel.dump(StandardCharsets.US_ASCII)); + Assertions.assertThat(byteChannel.isOpen()).isFalse(); + Assertions.assertThat(byteChannel.dump(StandardCharsets.US_ASCII)).isEqualTo("abcdef"); } @Test @@ -91,9 +91,9 @@ void testTextContentRepeatable() throws Exception { final Path tempPath = tempFile.toPath(); final AsyncEntityProducer producer = new PathEntityProducer(tempPath, ContentType.TEXT_PLAIN, StandardOpenOption.READ); - Assertions.assertEquals(6, producer.getContentLength()); - Assertions.assertEquals(ContentType.TEXT_PLAIN.toString(), producer.getContentType()); - Assertions.assertNull(producer.getContentEncoding()); + Assertions.assertThat(producer.getContentLength()).isEqualTo(6); + Assertions.assertThat(producer.getContentType()).isEqualTo(ContentType.TEXT_PLAIN.toString()); + Assertions.assertThat(producer.getContentEncoding()).isNull(); for (int i = 0; i < 3; i++) { final WritableByteChannelMock byteChannel = new WritableByteChannelMock(1024); @@ -102,8 +102,8 @@ void testTextContentRepeatable() throws Exception { producer.produce(streamChannel); producer.produce(streamChannel); - Assertions.assertFalse(byteChannel.isOpen()); - Assertions.assertEquals("abcdef", byteChannel.dump(StandardCharsets.US_ASCII)); + Assertions.assertThat(byteChannel.isOpen()).isFalse(); + Assertions.assertThat(byteChannel.dump(StandardCharsets.US_ASCII)).isEqualTo("abcdef"); producer.releaseResources(); } @@ -116,7 +116,7 @@ void testTextContentRepeatableAfterPartialWrite() throws Exception { final WritableByteChannelMock partialByteChannel = new WritableByteChannelMock(1024, 3); producer.produce(new BasicDataStreamChannel(partialByteChannel)); - Assertions.assertEquals("abc", partialByteChannel.dump(StandardCharsets.US_ASCII)); + Assertions.assertThat(partialByteChannel.dump(StandardCharsets.US_ASCII)).isEqualTo("abc"); producer.releaseResources(); final WritableByteChannelMock byteChannel = new WritableByteChannelMock(1024); @@ -124,8 +124,8 @@ void testTextContentRepeatableAfterPartialWrite() throws Exception { producer.produce(streamChannel); producer.produce(streamChannel); - Assertions.assertFalse(byteChannel.isOpen()); - Assertions.assertEquals("abcdef", byteChannel.dump(StandardCharsets.US_ASCII)); + Assertions.assertThat(byteChannel.isOpen()).isFalse(); + Assertions.assertThat(byteChannel.dump(StandardCharsets.US_ASCII)).isEqualTo("abcdef"); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/nio/entity/TestPathEntityProducer.java b/httpcore5/src/test/java/org/apache/hc/core5/http/nio/entity/TestPathEntityProducer.java index c1b02127c4..d91c7179dc 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/nio/entity/TestPathEntityProducer.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/nio/entity/TestPathEntityProducer.java @@ -32,7 +32,7 @@ import java.nio.file.Path; import java.nio.file.StandardOpenOption; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.io.TempDir; @@ -48,7 +48,7 @@ void testFileLengthMaxIntPlusOne(@TempDir final Path tempFolder) throws IOExcept final long expectedLength = 1L + Integer.MAX_VALUE; raFile.setLength(expectedLength); final PathEntityProducer fileEntityProducer = new PathEntityProducer(path, StandardOpenOption.READ); - Assertions.assertEquals(expectedLength, fileEntityProducer.getContentLength()); + Assertions.assertThat(fileEntityProducer.getContentLength()).isEqualTo(expectedLength); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/nio/entity/TestStringAsyncEntityProducer.java b/httpcore5/src/test/java/org/apache/hc/core5/http/nio/entity/TestStringAsyncEntityProducer.java index abc3c1cfc3..40a54d2d49 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/nio/entity/TestStringAsyncEntityProducer.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/nio/entity/TestStringAsyncEntityProducer.java @@ -34,7 +34,7 @@ import org.apache.hc.core5.http.nio.AsyncEntityProducer; import org.apache.hc.core5.http.nio.BasicDataStreamChannel; import org.apache.hc.core5.http.nio.DataStreamChannel; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class TestStringAsyncEntityProducer { @@ -45,17 +45,17 @@ void testTextContent() throws Exception { final AsyncEntityProducer producer = new StringAsyncEntityProducer( "abc", ContentType.TEXT_PLAIN); - Assertions.assertEquals(-1, producer.getContentLength()); - Assertions.assertEquals(ContentType.TEXT_PLAIN.toString(), producer.getContentType()); - Assertions.assertNull(producer.getContentEncoding()); + Assertions.assertThat(producer.getContentLength()).isEqualTo(-1); + Assertions.assertThat(producer.getContentType()).isEqualTo(ContentType.TEXT_PLAIN.toString()); + Assertions.assertThat(producer.getContentEncoding()).isNull(); final WritableByteChannelMock byteChannel = new WritableByteChannelMock(1024); final DataStreamChannel streamChannel = new BasicDataStreamChannel(byteChannel); producer.produce(streamChannel); - Assertions.assertFalse(byteChannel.isOpen()); - Assertions.assertEquals("abc", byteChannel.dump(StandardCharsets.US_ASCII)); + Assertions.assertThat(byteChannel.isOpen()).isFalse(); + Assertions.assertThat(byteChannel.dump(StandardCharsets.US_ASCII)).isEqualTo("abc"); } @Test @@ -63,9 +63,9 @@ void testTextContentRepeatable() throws Exception { final AsyncEntityProducer producer = new StringAsyncEntityProducer( "abc", ContentType.TEXT_PLAIN); - Assertions.assertEquals(-1, producer.getContentLength()); - Assertions.assertEquals(ContentType.TEXT_PLAIN.toString(), producer.getContentType()); - Assertions.assertNull(producer.getContentEncoding()); + Assertions.assertThat(producer.getContentLength()).isEqualTo(-1); + Assertions.assertThat(producer.getContentType()).isEqualTo(ContentType.TEXT_PLAIN.toString()); + Assertions.assertThat(producer.getContentEncoding()).isNull(); for (int i = 0; i < 3; i++) { final WritableByteChannelMock byteChannel = new WritableByteChannelMock(1024); @@ -73,8 +73,8 @@ void testTextContentRepeatable() throws Exception { producer.produce(streamChannel); - Assertions.assertFalse(byteChannel.isOpen()); - Assertions.assertEquals("abc", byteChannel.dump(StandardCharsets.US_ASCII)); + Assertions.assertThat(byteChannel.isOpen()).isFalse(); + Assertions.assertThat(byteChannel.dump(StandardCharsets.US_ASCII)).isEqualTo("abc"); producer.releaseResources(); } @@ -87,7 +87,7 @@ void testTextContentRepeatableAfterPartialWrite() throws Exception { final WritableByteChannelMock partialByteChannel = new WritableByteChannelMock(1024, 3); producer.produce(new BasicDataStreamChannel(partialByteChannel)); - Assertions.assertEquals("abc", partialByteChannel.dump(StandardCharsets.US_ASCII)); + Assertions.assertThat(partialByteChannel.dump(StandardCharsets.US_ASCII)).isEqualTo("abc"); producer.releaseResources(); final WritableByteChannelMock byteChannel = new WritableByteChannelMock(1024); @@ -95,8 +95,8 @@ void testTextContentRepeatableAfterPartialWrite() throws Exception { producer.produce(streamChannel); producer.produce(streamChannel); - Assertions.assertFalse(byteChannel.isOpen()); - Assertions.assertEquals("abcdef", byteChannel.dump(StandardCharsets.US_ASCII)); + Assertions.assertThat(byteChannel.isOpen()).isFalse(); + Assertions.assertThat(byteChannel.dump(StandardCharsets.US_ASCII)).isEqualTo("abcdef"); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/nio/ssl/BasicClientTlsStrategyTest.java b/httpcore5/src/test/java/org/apache/hc/core5/http/nio/ssl/BasicClientTlsStrategyTest.java index c789672d58..0828abdce5 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/nio/ssl/BasicClientTlsStrategyTest.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/nio/ssl/BasicClientTlsStrategyTest.java @@ -27,9 +27,8 @@ package org.apache.hc.core5.http.nio.ssl; -import static org.junit.jupiter.api.Assertions.assertNotNull; - import org.apache.hc.core5.reactor.ssl.SSLSessionVerifier; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; @@ -49,7 +48,7 @@ void prepareMocks() { @Test void test_valid_tls_strategy_creation_with_verifier() { final BasicClientTlsStrategy strategy = new BasicClientTlsStrategy(sslSessionVerifier); - assertNotNull(strategy); + Assertions.assertThat(strategy).isNotNull(); } } \ No newline at end of file diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/nio/ssl/BasicServerTlsStrategyTest.java b/httpcore5/src/test/java/org/apache/hc/core5/http/nio/ssl/BasicServerTlsStrategyTest.java index 4a400dc142..a271846ff2 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/nio/ssl/BasicServerTlsStrategyTest.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/nio/ssl/BasicServerTlsStrategyTest.java @@ -27,9 +27,8 @@ package org.apache.hc.core5.http.nio.ssl; -import static org.junit.jupiter.api.Assertions.assertNotNull; - import org.apache.hc.core5.reactor.ssl.SSLSessionVerifier; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; @@ -49,7 +48,7 @@ void prepareMocks() { @Test void test_valid_tls_strategy_creation_with_verifier() { final BasicServerTlsStrategy strategy = new BasicServerTlsStrategy(sslSessionVerifier); - assertNotNull(strategy); + Assertions.assertThat(strategy).isNotNull(); } } \ No newline at end of file diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/nio/support/classic/TestSharedInputBuffer.java b/httpcore5/src/test/java/org/apache/hc/core5/http/nio/support/classic/TestSharedInputBuffer.java index 38eeb1b5d5..8673500017 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/nio/support/classic/TestSharedInputBuffer.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/nio/support/classic/TestSharedInputBuffer.java @@ -40,7 +40,8 @@ import org.apache.hc.core5.http.nio.CapacityChannel; import org.apache.hc.core5.util.Timeout; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; +import org.assertj.core.api.InstanceOfAssertFactories; import org.junit.jupiter.api.Test; import org.mockito.ArgumentMatchers; import org.mockito.Mockito; @@ -55,7 +56,7 @@ void testBasis() throws Exception { final Charset charset = StandardCharsets.US_ASCII; final SharedInputBuffer inputBuffer = new SharedInputBuffer(10); inputBuffer.fill(charset.encode("1234567890")); - Assertions.assertEquals(10, inputBuffer.length()); + Assertions.assertThat(inputBuffer.length()).isEqualTo(10); final CapacityChannel capacityChannel = Mockito.mock(CapacityChannel.class); @@ -64,26 +65,26 @@ void testBasis() throws Exception { inputBuffer.fill(charset.encode("1234567890")); inputBuffer.fill(charset.encode("1234567890")); - Assertions.assertEquals(30, inputBuffer.length()); + Assertions.assertThat(inputBuffer.length()).isEqualTo(30); Mockito.verifyNoInteractions(capacityChannel); final byte[] tmp = new byte[20]; final int bytesRead1 = inputBuffer.read(tmp, 0, tmp.length); - Assertions.assertEquals(20, bytesRead1); + Assertions.assertThat(bytesRead1).isEqualTo(20); Mockito.verifyNoInteractions(capacityChannel); inputBuffer.markEndStream(); - Assertions.assertEquals('1', inputBuffer.read()); - Assertions.assertEquals('2', inputBuffer.read()); + Assertions.assertThat(inputBuffer.read()).isEqualTo('1'); + Assertions.assertThat(inputBuffer.read()).isEqualTo('2'); final int bytesRead2 = inputBuffer.read(tmp, 0, tmp.length); - Assertions.assertEquals(8, bytesRead2); + Assertions.assertThat(bytesRead2).isEqualTo(8); Mockito.verifyNoInteractions(capacityChannel); - Assertions.assertEquals(-1, inputBuffer.read(tmp, 0, tmp.length)); - Assertions.assertEquals(-1, inputBuffer.read(tmp, 0, tmp.length)); - Assertions.assertEquals(-1, inputBuffer.read()); - Assertions.assertEquals(-1, inputBuffer.read()); + Assertions.assertThat(inputBuffer.read(tmp, 0, tmp.length)).isEqualTo(-1); + Assertions.assertThat(inputBuffer.read(tmp, 0, tmp.length)).isEqualTo(-1); + Assertions.assertThat(inputBuffer.read()).isEqualTo(-1); + Assertions.assertThat(inputBuffer.read()).isEqualTo(-1); } @Test @@ -108,8 +109,8 @@ void testMultithreadingRead() throws Exception { return inputBuffer.read(tmp, 0, tmp.length); }); - Assertions.assertEquals(Boolean.TRUE, task1.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit())); - Assertions.assertEquals(Integer.valueOf(10), task2.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit())); + Assertions.assertThat(task1.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit())).isEqualTo(Boolean.TRUE); + Assertions.assertThat(task2.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit())).isEqualTo(Integer.valueOf(10)); Mockito.verify(capacityChannel).update(10); } @@ -132,8 +133,8 @@ void testMultithreadingSingleRead() throws Exception { }); final Future task2 = executorService.submit((Callable) inputBuffer::read); - Assertions.assertEquals(Boolean.TRUE, task1.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit())); - Assertions.assertEquals(Integer.valueOf('a'), task2.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit())); + Assertions.assertThat(task1.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit())).isEqualTo(Boolean.TRUE); + Assertions.assertThat(task2.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit())).isEqualTo(Integer.valueOf('a')); Mockito.verify(capacityChannel).update(1); } @@ -170,9 +171,8 @@ void testMultithreadingReadStream() throws Exception { return buf.toString(); }); - Assertions.assertEquals(Boolean.TRUE, task1.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit())); - Assertions.assertEquals("12345678901234567890123456789012345678901234567890", - task2.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit())); + Assertions.assertThat(task1.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit())).isEqualTo(Boolean.TRUE); + Assertions.assertThat(task2.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit())).isEqualTo("12345678901234567890123456789012345678901234567890"); Mockito.verify(capacityChannel, Mockito.atLeast(1)).update(ArgumentMatchers.anyInt()); } @@ -195,9 +195,11 @@ void testMultithreadingReadStreamAbort() throws Exception { }); final Future task2 = executorService.submit((Callable) inputBuffer::read); - Assertions.assertEquals(Boolean.TRUE, task1.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit())); - final ExecutionException ex = Assertions.assertThrows(ExecutionException.class, () -> task2.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit())); - Assertions.assertInstanceOf(InterruptedIOException.class, ex.getCause()); + Assertions.assertThat(task1.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit())).isEqualTo(Boolean.TRUE); + final ExecutionException ex = Assertions.assertThatThrownBy(() -> + task2.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit())) + .isInstanceOf(ExecutionException.class).asInstanceOf(InstanceOfAssertFactories.type(ExecutionException.class)).actual(); + Assertions.assertThat(ex.getCause()).isInstanceOf(InterruptedIOException.class); Mockito.verify(capacityChannel, Mockito.never()).update(10); } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/nio/support/classic/TestSharedOutputBuffer.java b/httpcore5/src/test/java/org/apache/hc/core5/http/nio/support/classic/TestSharedOutputBuffer.java index ee1f340991..ef6e0cbf22 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/nio/support/classic/TestSharedOutputBuffer.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/nio/support/classic/TestSharedOutputBuffer.java @@ -43,7 +43,7 @@ import org.apache.hc.core5.http.WritableByteChannelMock; import org.apache.hc.core5.http.nio.DataStreamChannel; import org.apache.hc.core5.util.Timeout; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.RepeatedTest; import org.junit.jupiter.api.Test; import org.mockito.Mockito; @@ -106,8 +106,8 @@ void testBasis() throws Exception { Mockito.verifyNoInteractions(dataStreamChannel); - Assertions.assertEquals(0, outputBuffer.length()); - Assertions.assertEquals(30, outputBuffer.capacity()); + Assertions.assertThat(outputBuffer.length()).isEqualTo(0); + Assertions.assertThat(outputBuffer.capacity()).isEqualTo(30); final byte[] tmp = "1234567890".getBytes(charset); outputBuffer.write(tmp, 0, tmp.length); @@ -115,8 +115,8 @@ void testBasis() throws Exception { outputBuffer.write('1'); outputBuffer.write('2'); - Assertions.assertEquals(22, outputBuffer.length()); - Assertions.assertEquals(8, outputBuffer.capacity()); + Assertions.assertThat(outputBuffer.length()).isEqualTo(22); + Assertions.assertThat(outputBuffer.capacity()).isEqualTo(8); Mockito.verifyNoInteractions(dataStreamChannel); } @@ -131,8 +131,8 @@ void testFlush() throws Exception { final DataStreamChannel dataStreamChannel = new DataStreamChannelMock(channel); outputBuffer.flush(dataStreamChannel); - Assertions.assertEquals(0, outputBuffer.length()); - Assertions.assertEquals(30, outputBuffer.capacity()); + Assertions.assertThat(outputBuffer.length()).isEqualTo(0); + Assertions.assertThat(outputBuffer.capacity()).isEqualTo(30); final byte[] tmp = "1234567890".getBytes(charset); outputBuffer.write(tmp, 0, tmp.length); @@ -142,8 +142,8 @@ void testFlush() throws Exception { outputBuffer.flush(dataStreamChannel); - Assertions.assertEquals(0, outputBuffer.length()); - Assertions.assertEquals(30, outputBuffer.capacity()); + Assertions.assertThat(outputBuffer.length()).isEqualTo(0); + Assertions.assertThat(outputBuffer.capacity()).isEqualTo(30); } @RepeatedTest(20) @@ -180,10 +180,10 @@ void testMultithreadingWriteStream() throws Exception { return Boolean.TRUE; }); - Assertions.assertEquals(Boolean.TRUE, task1.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit())); - Assertions.assertEquals(Boolean.TRUE, task2.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit())); + Assertions.assertThat(task1.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit())).isTrue(); + Assertions.assertThat(task2.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit())).isTrue(); - Assertions.assertEquals("1234567890123456789012123456789012345678901234567890", new String(channel.toByteArray(), charset)); + Assertions.assertThat(new String(channel.toByteArray(), charset)).isEqualTo("1234567890123456789012123456789012345678901234567890"); } finally { executorService.shutdownNow(); } @@ -210,10 +210,12 @@ void testMultithreadingWriteStreamAbort() throws Exception { return Boolean.TRUE; }); - Assertions.assertEquals(Boolean.TRUE, task2.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit())); - final ExecutionException ex = Assertions.assertThrows(ExecutionException.class, () -> - task1.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit())); - Assertions.assertInstanceOf(InterruptedIOException.class, ex.getCause()); + Assertions.assertThat(task2.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit())).isTrue(); + Assertions.assertThatThrownBy(() -> + task1.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit())) + .isInstanceOf(ExecutionException.class) + .cause() + .isInstanceOf(InterruptedIOException.class); } @Test @@ -239,8 +241,8 @@ void testEndStreamOnlyCalledOnce() throws Exception { return Boolean.TRUE; }); - Assertions.assertEquals(Boolean.TRUE, task1.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit())); - Assertions.assertEquals(Boolean.TRUE, task2.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit())); + Assertions.assertThat(task1.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit())).isTrue(); + Assertions.assertThat(task2.get(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit())).isTrue(); Mockito.verify(dataStreamChannel, Mockito.times(1)).endStream(); } finally { @@ -249,4 +251,3 @@ void testEndStreamOnlyCalledOnce() throws Exception { } } - diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/protocol/TestChainBuilder.java b/httpcore5/src/test/java/org/apache/hc/core5/http/protocol/TestChainBuilder.java index c53cbf92cd..d71f7b5e09 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/protocol/TestChainBuilder.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/protocol/TestChainBuilder.java @@ -31,7 +31,7 @@ import java.util.List; import org.apache.hc.core5.http.HttpRequestInterceptor; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class TestChainBuilder { @@ -55,13 +55,13 @@ void testBuildChain() { cb.addFirst(i1); cb.addAllLast(i3, i4, i5); final LinkedList list = cb.build(); - Assertions.assertNotNull(list); - Assertions.assertEquals(5, list.size()); - Assertions.assertSame(i1, list.get(0)); - Assertions.assertSame(i2, list.get(1)); - Assertions.assertSame(i3, list.get(2)); - Assertions.assertSame(i4, list.get(3)); - Assertions.assertSame(i5, list.get(4)); + Assertions.assertThat(list).isNotNull(); + Assertions.assertThat(list.size()).isEqualTo(5); + Assertions.assertThat(list.get(0)).isSameAs(i1); + Assertions.assertThat(list.get(1)).isSameAs(i2); + Assertions.assertThat(list.get(2)).isSameAs(i3); + Assertions.assertThat(list.get(3)).isSameAs(i4); + Assertions.assertThat(list.get(4)).isSameAs(i5); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/protocol/TestDefaultHttpProcessor.java b/httpcore5/src/test/java/org/apache/hc/core5/http/protocol/TestDefaultHttpProcessor.java index d572c46eb6..7b0f9c9edc 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/protocol/TestDefaultHttpProcessor.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/protocol/TestDefaultHttpProcessor.java @@ -38,7 +38,7 @@ import org.apache.hc.core5.http.HttpResponseInterceptor; import org.apache.hc.core5.http.message.BasicHttpRequest; import org.apache.hc.core5.http.message.BasicHttpResponse; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class TestDefaultHttpProcessor { @@ -58,7 +58,7 @@ void processesRequestAndResponseInterceptorsInOrder() throws Exception { processor.process(new BasicHttpRequest("GET", "/"), null, HttpCoreContext.create()); processor.process(new BasicHttpResponse(200), null, HttpCoreContext.create()); - Assertions.assertEquals(Arrays.asList("r1", "r2", "s1", "s2"), events); + Assertions.assertThat(events).isEqualTo(Arrays.asList("r1", "r2", "s1", "s2")); } @Test @@ -73,7 +73,7 @@ void copiesInterceptorArrays() throws Exception { processor.process(new BasicHttpRequest("GET", "/"), null, HttpCoreContext.create()); - Assertions.assertEquals(Arrays.asList("orig"), events); + Assertions.assertThat(events).isEqualTo(Arrays.asList("orig")); } @Test @@ -100,7 +100,7 @@ void listConstructorBuildsChains() throws Exception { processor.process(new BasicHttpRequest("GET", "/"), null, HttpCoreContext.create()); processor.process(new BasicHttpResponse(200), null, HttpCoreContext.create()); - Assertions.assertEquals(Arrays.asList("r1", "r2", "s1"), events); + Assertions.assertThat(events).isEqualTo(Arrays.asList("r1", "r2", "s1")); } @Test @@ -114,8 +114,8 @@ public void process(final HttpRequest request, final EntityDetails entity, final }; final DefaultHttpProcessor processor = new DefaultHttpProcessor(interceptor); - Assertions.assertThrows(HttpException.class, () -> - processor.process(new BasicHttpRequest("GET", "/"), null, HttpCoreContext.create())); + Assertions.assertThatThrownBy(() -> + processor.process(new BasicHttpRequest("GET", "/"), null, HttpCoreContext.create())).isInstanceOf(HttpException.class); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/protocol/TestForwardedRequest.java b/httpcore5/src/test/java/org/apache/hc/core5/http/protocol/TestForwardedRequest.java index 815324459e..7d94e2a9ef 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/protocol/TestForwardedRequest.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/protocol/TestForwardedRequest.java @@ -27,8 +27,6 @@ package org.apache.hc.core5.http.protocol; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertThrows; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; @@ -47,6 +45,7 @@ import org.apache.hc.core5.http.message.BasicHeader; import org.apache.hc.core5.http.message.BasicHttpRequest; import org.apache.hc.core5.net.URIAuthority; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class TestForwardedRequest { @@ -86,7 +85,7 @@ void testProcess() throws IOException, HttpException { "for=" + localAddress.getAddress().getHostAddress() + ":" + localAddress.getPort() + ";" + "host=\"" + host + "\";port=" + port + ";proto=" + version.getProtocol(); - assertEquals(expectedValue, request.getFirstHeader(FORWARDED_HEADER_NAME).getValue()); + Assertions.assertThat(request.getFirstHeader(FORWARDED_HEADER_NAME).getValue()).isEqualTo(expectedValue); } @@ -121,7 +120,7 @@ void testProcessWithIPv6() throws IOException, HttpException { ";for=" + localAddress.getHostName() + ":" + localAddress.getPort() + ";host=\"" + host + "\";port=" + port + ";proto=" + version.getProtocol(); - assertEquals(expectedValue, request.getFirstHeader(FORWARDED_HEADER_NAME).getValue()); + Assertions.assertThat(request.getFirstHeader(FORWARDED_HEADER_NAME).getValue()).isEqualTo(expectedValue); } @Test @@ -145,7 +144,7 @@ void testProcess_withNullEndpointDetails_shouldAddValidHeader() throws Exception // Check the value of the Forwarded header final String expectedValue = "host=\"" + host + "\";port=" + port + ";proto=" + version.getProtocol(); - assertEquals(expectedValue, request.getFirstHeader(FORWARDED_HEADER_NAME).getValue()); + Assertions.assertThat(request.getFirstHeader(FORWARDED_HEADER_NAME).getValue()).isEqualTo(expectedValue); } @Test @@ -172,24 +171,30 @@ void testWithForwardedHeader() throws Exception { // Check the value of the Forwarded header final String expectedValue = forwaredHeaderValue + ", " + "host=\"" + host + "\";port=" + port + ";proto=" + version.getProtocol(); - assertEquals(expectedValue, request.getFirstHeader(FORWARDED_HEADER_NAME).getValue()); + Assertions.assertThat(request.getFirstHeader(FORWARDED_HEADER_NAME).getValue()).isEqualTo(expectedValue); } @Test void testProcessWithNullHttpRequest() { final ForwardedRequest httpRequestModifier = new ForwardedRequest(); - assertThrows(NullPointerException.class, () -> httpRequestModifier.process(null, null, context)); + Assertions.assertThatThrownBy(() -> + httpRequestModifier.process(null, null, context)) + .isInstanceOf(NullPointerException.class); } @Test void testProcessWithNullHttpContext() { final ForwardedRequest httpRequestModifier = new ForwardedRequest(); - assertThrows(NullPointerException.class, () -> httpRequestModifier.process(request, null, null)); + Assertions.assertThatThrownBy(() -> + httpRequestModifier.process(request, null, null)) + .isInstanceOf(NullPointerException.class); } @Test void testProcessWithNullAuthority() { final ForwardedRequest httpRequestModifier = new ForwardedRequest(); - assertThrows(ProtocolException.class, () -> httpRequestModifier.process(request, null, context)); + Assertions.assertThatThrownBy(() -> + httpRequestModifier.process(request, null, context)) + .isInstanceOf(ProtocolException.class); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/protocol/TestHttpExecutionContext.java b/httpcore5/src/test/java/org/apache/hc/core5/http/protocol/TestHttpExecutionContext.java index 2023f4adc7..91672d5f12 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/protocol/TestHttpExecutionContext.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/protocol/TestHttpExecutionContext.java @@ -27,7 +27,7 @@ package org.apache.hc.core5.http.protocol; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; // the name of this test is historic, the implementation classes of HttpContext @@ -44,32 +44,32 @@ void testContextOperations() { currentContext.setAttribute("param3", "3"); currentContext.setAttribute("param2", "4"); - Assertions.assertEquals("1", parentContext.getAttribute("param1")); - Assertions.assertEquals("2", parentContext.getAttribute("param2")); - Assertions.assertNull(parentContext.getAttribute("param3")); + Assertions.assertThat(parentContext.getAttribute("param1")).isEqualTo("1"); + Assertions.assertThat(parentContext.getAttribute("param2")).isEqualTo("2"); + Assertions.assertThat(parentContext.getAttribute("param3")).isNull(); - Assertions.assertEquals("1", currentContext.getAttribute("param1")); - Assertions.assertEquals("4", currentContext.getAttribute("param2")); - Assertions.assertEquals("3", currentContext.getAttribute("param3")); - Assertions.assertNull(currentContext.getAttribute("param4")); + Assertions.assertThat(currentContext.getAttribute("param1")).isEqualTo("1"); + Assertions.assertThat(currentContext.getAttribute("param2")).isEqualTo("4"); + Assertions.assertThat(currentContext.getAttribute("param3")).isEqualTo("3"); + Assertions.assertThat(currentContext.getAttribute("param4")).isNull(); currentContext.removeAttribute("param1"); currentContext.removeAttribute("param2"); currentContext.removeAttribute("param3"); currentContext.removeAttribute("param4"); - Assertions.assertEquals("1", currentContext.getAttribute("param1")); - Assertions.assertEquals("2", currentContext.getAttribute("param2")); - Assertions.assertNull(currentContext.getAttribute("param3")); - Assertions.assertNull(currentContext.getAttribute("param4")); + Assertions.assertThat(currentContext.getAttribute("param1")).isEqualTo("1"); + Assertions.assertThat(currentContext.getAttribute("param2")).isEqualTo("2"); + Assertions.assertThat(currentContext.getAttribute("param3")).isNull(); + Assertions.assertThat(currentContext.getAttribute("param4")).isNull(); } @Test void testEmptyContextOperations() { final HttpCoreContext currentContext = new HttpCoreContext(); - Assertions.assertNull(currentContext.getAttribute("param1")); + Assertions.assertThat(currentContext.getAttribute("param1")).isNull(); currentContext.removeAttribute("param1"); - Assertions.assertNull(currentContext.getAttribute("param1")); + Assertions.assertThat(currentContext.getAttribute("param1")).isNull(); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/protocol/TestHttpProcessorBuilder.java b/httpcore5/src/test/java/org/apache/hc/core5/http/protocol/TestHttpProcessorBuilder.java index e9f54a0097..47df179efb 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/protocol/TestHttpProcessorBuilder.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/protocol/TestHttpProcessorBuilder.java @@ -34,7 +34,7 @@ import org.apache.hc.core5.http.HttpResponseInterceptor; import org.apache.hc.core5.http.message.BasicHttpRequest; import org.apache.hc.core5.http.message.BasicHttpResponse; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class TestHttpProcessorBuilder { @@ -55,7 +55,7 @@ void buildsRequestChainInOrder() throws Exception { processor.process(new BasicHttpRequest("GET", "/"), null, HttpCoreContext.create()); - Assertions.assertEquals(Arrays.asList("r1", "r2", "r3"), events); + Assertions.assertThat(events).isEqualTo(Arrays.asList("r1", "r2", "r3")); } @Test @@ -72,7 +72,7 @@ void buildsResponseChainInOrder() throws Exception { processor.process(new BasicHttpResponse(200), null, HttpCoreContext.create()); - Assertions.assertEquals(Arrays.asList("s2", "s1"), events); + Assertions.assertThat(events).isEqualTo(Arrays.asList("s2", "s1")); } @Test diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/protocol/TestRequestTE.java b/httpcore5/src/test/java/org/apache/hc/core5/http/protocol/TestRequestTE.java index 990c4909b1..70732c505b 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/protocol/TestRequestTE.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/protocol/TestRequestTE.java @@ -27,18 +27,13 @@ package org.apache.hc.core5.http.protocol; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static org.junit.jupiter.api.Assertions.assertNull; -import static org.junit.jupiter.api.Assertions.assertTrue; - import org.apache.hc.core5.http.HttpHeaders; import org.apache.hc.core5.http.HttpRequestInterceptor; import org.apache.hc.core5.http.HttpVersion; import org.apache.hc.core5.http.Method; import org.apache.hc.core5.http.ProtocolException; import org.apache.hc.core5.http.message.BasicClassicHttpRequest; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class TestRequestTE { @@ -56,8 +51,8 @@ void testValidTEHeader() throws Exception { final HttpRequestInterceptor interceptor = new RequestTE(); interceptor.process(request, request.getEntity(), context); - assertNotNull(request.getHeader(HttpHeaders.TE)); - assertEquals("trailers", request.getHeader(HttpHeaders.TE).getValue()); + Assertions.assertThat(request.getHeader(HttpHeaders.TE)).isNotNull(); + Assertions.assertThat(request.getHeader(HttpHeaders.TE).getValue()).isEqualTo("trailers"); } @@ -74,8 +69,8 @@ void testMultipleValidTEHeaders() throws Exception { final HttpRequestInterceptor interceptor = new RequestTE(); interceptor.process(request, request.getEntity(), context); - assertNotNull(request.getHeader(HttpHeaders.TE)); - assertEquals("trailers, deflate;q=0.5", request.getHeader(HttpHeaders.TE).getValue()); + Assertions.assertThat(request.getHeader(HttpHeaders.TE)).isNotNull(); + Assertions.assertThat(request.getHeader(HttpHeaders.TE).getValue()).isEqualTo("trailers, deflate;q=0.5"); } @@ -89,7 +84,7 @@ void testTEHeaderNotPresent() throws Exception { interceptor.process(request, request.getEntity(), context); // No TE header, no validation should occur - assertNull(request.getHeader(HttpHeaders.TE)); + Assertions.assertThat(request.getHeader(HttpHeaders.TE)).isNull(); } @Test @@ -100,8 +95,8 @@ void testTEHeaderContainsChunked() { request.setHeader(HttpHeaders.TE, "chunked"); final HttpRequestInterceptor interceptor = new RequestTE(); - Assertions.assertThrows(ProtocolException.class, () -> - interceptor.process(request, request.getEntity(), context)); + Assertions.assertThatThrownBy(() -> + interceptor.process(request, request.getEntity(), context)).isInstanceOf(ProtocolException.class); } @Test @@ -112,8 +107,8 @@ void testTEHeaderInvalidTransferCoding() { request.setHeader(HttpHeaders.TE, "invalid;q=abc"); final HttpRequestInterceptor interceptor = new RequestTE(); - Assertions.assertThrows(ProtocolException.class, () -> - interceptor.process(request, request.getEntity(), context)); + Assertions.assertThatThrownBy(() -> + interceptor.process(request, request.getEntity(), context)).isInstanceOf(ProtocolException.class); } @Test @@ -129,9 +124,9 @@ void testTEHeaderAlreadySet() throws Exception { final HttpRequestInterceptor interceptor = new RequestTE(); interceptor.process(request, request.getEntity(), context); - assertEquals(HttpHeaders.TE, request.getHeader(HttpHeaders.TE).getName()); - assertNotNull(request.getHeader(HttpHeaders.TE)); - assertEquals(teValue, request.getHeader(HttpHeaders.TE).getValue()); + Assertions.assertThat(request.getHeader(HttpHeaders.TE).getName()).isEqualTo(HttpHeaders.TE); + Assertions.assertThat(request.getHeader(HttpHeaders.TE)).isNotNull(); + Assertions.assertThat(request.getHeader(HttpHeaders.TE).getValue()).isEqualTo(teValue); } @@ -146,9 +141,9 @@ void testTEHeaderWithConnectionHeaderValidation() throws Exception { final HttpRequestInterceptor interceptor = new RequestTE(); interceptor.process(request, request.getEntity(), context); - assertEquals(HttpHeaders.TE, request.getHeader(HttpHeaders.TE).getName()); - assertNotNull(request.getHeader(HttpHeaders.TE)); - assertEquals("trailers", request.getHeader(HttpHeaders.TE).getValue()); + Assertions.assertThat(request.getHeader(HttpHeaders.TE).getName()).isEqualTo(HttpHeaders.TE); + Assertions.assertThat(request.getHeader(HttpHeaders.TE)).isNotNull(); + Assertions.assertThat(request.getHeader(HttpHeaders.TE).getValue()).isEqualTo("trailers"); } @Test @@ -159,8 +154,8 @@ void testTEHeaderWithoutConnectionHeaderThrowsException() { request.setHeader(HttpHeaders.TE, "trailers"); final HttpRequestInterceptor interceptor = new RequestTE(); - Assertions.assertThrows(ProtocolException.class, () -> - interceptor.process(request, request.getEntity(), context)); + Assertions.assertThatThrownBy(() -> + interceptor.process(request, request.getEntity(), context)).isInstanceOf(ProtocolException.class); } @Test @@ -173,8 +168,8 @@ void testTEHeaderWithoutTEInConnectionHeaderThrowsException() { request.setHeader(HttpHeaders.CONNECTION, "keep-alive"); // Missing "TE" final HttpRequestInterceptor interceptor = new RequestTE(); - Assertions.assertThrows(ProtocolException.class, () -> - interceptor.process(request, request.getEntity(), context)); + Assertions.assertThatThrownBy(() -> + interceptor.process(request, request.getEntity(), context)).isInstanceOf(ProtocolException.class); } @Test @@ -190,8 +185,8 @@ void testTEHeaderWithMultipleDirectivesInConnectionHeader() throws Exception { final HttpRequestInterceptor interceptor = new RequestTE(); interceptor.process(request, request.getEntity(), context); - assertNotNull(request.getHeader(HttpHeaders.CONNECTION)); - assertTrue(request.getHeader(HttpHeaders.CONNECTION).getValue().contains("TE")); + Assertions.assertThat(request.getHeader(HttpHeaders.CONNECTION)).isNotNull(); + Assertions.assertThat(request.getHeader(HttpHeaders.CONNECTION).getValue().contains("TE")).isTrue(); } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/protocol/TestStandardInterceptors.java b/httpcore5/src/test/java/org/apache/hc/core5/http/protocol/TestStandardInterceptors.java index 5d37b6ad08..daa9eb228e 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/protocol/TestStandardInterceptors.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/protocol/TestStandardInterceptors.java @@ -50,7 +50,7 @@ import org.apache.hc.core5.http.message.BasicClassicHttpResponse; import org.apache.hc.core5.http.message.BasicHeader; import org.apache.hc.core5.net.URIAuthority; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.mockito.Mockito; @@ -63,8 +63,8 @@ void testRequestConnControlGenerated() throws Exception { final HttpRequestInterceptor interceptor = RequestConnControl.INSTANCE; interceptor.process(request, request.getEntity(), context); final Header header = request.getFirstHeader(HttpHeaders.CONNECTION); - Assertions.assertNotNull(header); - Assertions.assertEquals("keep-alive", header.getValue()); + Assertions.assertThat(header).isNotNull(); + Assertions.assertThat(header.getValue()).isEqualTo("keep-alive"); } @Test @@ -74,7 +74,7 @@ void testRequestConnControlConnectMethod() throws Exception { final HttpRequestInterceptor interceptor = RequestConnControl.INSTANCE; interceptor.process(request, request.getEntity(), context); final Header header = request.getFirstHeader(HttpHeaders.CONNECTION); - Assertions.assertNull(header); + Assertions.assertThat(header).isNull(); } @Test @@ -86,9 +86,9 @@ void testRequestConnControlCustom() throws Exception { final HttpRequestInterceptor interceptor = RequestConnControl.INSTANCE; interceptor.process(request, request.getEntity(), context); final Header header = request.getFirstHeader(HttpHeaders.CONNECTION); - Assertions.assertNotNull(header); - Assertions.assertEquals("close", header.getValue()); - Assertions.assertSame(header, myheader); + Assertions.assertThat(header).isNotNull(); + Assertions.assertThat(header.getValue()).isEqualTo("close"); + Assertions.assertThat(myheader).isSameAs(header); } @Test @@ -99,14 +99,16 @@ void testRequestConnControlUpgrade() throws Exception { final HttpRequestInterceptor interceptor = RequestConnControl.INSTANCE; interceptor.process(request, request.getEntity(), context); final Header header = request.getFirstHeader(HttpHeaders.CONNECTION); - Assertions.assertNotNull(header); - Assertions.assertEquals("upgrade", header.getValue()); + Assertions.assertThat(header).isNotNull(); + Assertions.assertThat(header.getValue()).isEqualTo("upgrade"); } @Test void testRequestConnControlInvalidInput() { final HttpRequestInterceptor interceptor = RequestConnControl.INSTANCE; - Assertions.assertThrows(NullPointerException.class, () -> interceptor.process(null, null, null)); + Assertions.assertThatThrownBy(() -> + interceptor.process(null, null, null)) + .isInstanceOf(NullPointerException.class); } @Test @@ -118,10 +120,10 @@ void testRequestContentProtocolException() { request2.addHeader(new BasicHeader(HttpHeaders.CONTENT_LENGTH, "12")); final HttpRequestInterceptor interceptor = RequestContent.INSTANCE; - Assertions.assertThrows(ProtocolException.class, () -> - interceptor.process(request1, request1.getEntity(), context)); - Assertions.assertThrows(ProtocolException.class, () -> - interceptor.process(request2, request2.getEntity(), context)); + Assertions.assertThatThrownBy(() -> + interceptor.process(request1, request1.getEntity(), context)).isInstanceOf(ProtocolException.class); + Assertions.assertThatThrownBy(() -> + interceptor.process(request2, request2.getEntity(), context)).isInstanceOf(ProtocolException.class); } @Test @@ -132,9 +134,9 @@ void testRequestContentNullEntity() throws Exception { final HttpRequestInterceptor interceptor = RequestContent.INSTANCE; interceptor.process(request, request.getEntity(), context); final Header header = request.getFirstHeader(HttpHeaders.CONTENT_LENGTH); - Assertions.assertNotNull(header); - Assertions.assertEquals(0, Integer.parseInt(header.getValue())); - Assertions.assertNull(request.getFirstHeader(HttpHeaders.TRANSFER_ENCODING)); + Assertions.assertThat(header).isNotNull(); + Assertions.assertThat(Integer.parseInt(header.getValue())).isEqualTo(0); + Assertions.assertThat(request.getFirstHeader(HttpHeaders.TRANSFER_ENCODING)).isNull(); } @Test @@ -145,8 +147,8 @@ void testRequestContentNullEntityNonEnclosingMethod() throws Exception { final HttpRequestInterceptor interceptor = RequestContent.INSTANCE; interceptor.process(request, request.getEntity(), context); final Header header = request.getFirstHeader(HttpHeaders.CONTENT_LENGTH); - Assertions.assertNull(header); - Assertions.assertNull(request.getFirstHeader(HttpHeaders.TRANSFER_ENCODING)); + Assertions.assertThat(header).isNull(); + Assertions.assertThat(request.getFirstHeader(HttpHeaders.TRANSFER_ENCODING)).isNull(); } @Test void testRequestContentEntityContentLengthDelimitedHTTP11() throws Exception { @@ -157,9 +159,9 @@ void testRequestContentEntityContentLengthDelimitedHTTP11() throws Exception { final HttpRequestInterceptor interceptor = RequestContent.INSTANCE; interceptor.process(request, request.getEntity(), context); final Header header = request.getFirstHeader(HttpHeaders.CONTENT_LENGTH); - Assertions.assertNotNull(header); - Assertions.assertEquals(8, Integer.parseInt(header.getValue())); - Assertions.assertNull(request.getFirstHeader(HttpHeaders.TRANSFER_ENCODING)); + Assertions.assertThat(header).isNotNull(); + Assertions.assertThat(Integer.parseInt(header.getValue())).isEqualTo(8); + Assertions.assertThat(request.getFirstHeader(HttpHeaders.TRANSFER_ENCODING)).isNull(); } @Test @@ -171,9 +173,9 @@ void testRequestContentEntityChunkedHTTP11() throws Exception { final HttpRequestInterceptor interceptor = RequestContent.INSTANCE; interceptor.process(request, request.getEntity(), context); final Header header = request.getFirstHeader(HttpHeaders.TRANSFER_ENCODING); - Assertions.assertNotNull(header); - Assertions.assertEquals("chunked", header.getValue()); - Assertions.assertNull(request.getFirstHeader(HttpHeaders.CONTENT_LENGTH)); + Assertions.assertThat(header).isNotNull(); + Assertions.assertThat(header.getValue()).isEqualTo("chunked"); + Assertions.assertThat(request.getFirstHeader(HttpHeaders.CONTENT_LENGTH)).isNull(); } @Test @@ -185,9 +187,9 @@ void testRequestContentEntityUnknownLengthHTTP11() throws Exception { final HttpRequestInterceptor interceptor = RequestContent.INSTANCE; interceptor.process(request, request.getEntity(), context); final Header header = request.getFirstHeader(HttpHeaders.TRANSFER_ENCODING); - Assertions.assertNotNull(header); - Assertions.assertEquals("chunked", header.getValue()); - Assertions.assertNull(request.getFirstHeader(HttpHeaders.CONTENT_LENGTH)); + Assertions.assertThat(header).isNotNull(); + Assertions.assertThat(header.getValue()).isEqualTo("chunked"); + Assertions.assertThat(request.getFirstHeader(HttpHeaders.CONTENT_LENGTH)).isNull(); } @Test @@ -198,8 +200,8 @@ void testRequestContentEntityChunkedHTTP10() { request.setEntity(new StringEntity("whatever", StandardCharsets.US_ASCII, true)); final HttpRequestInterceptor interceptor = RequestContent.INSTANCE; - Assertions.assertThrows(ProtocolException.class, () -> - interceptor.process(request, request.getEntity(), context)); + Assertions.assertThatThrownBy(() -> + interceptor.process(request, request.getEntity(), context)).isInstanceOf(ProtocolException.class); } @Test @@ -212,11 +214,11 @@ void testRequestContentTypeAndEncoding() throws Exception { final HttpRequestInterceptor interceptor = RequestContent.INSTANCE; interceptor.process(request, request.getEntity(), context); final Header h1 = request.getFirstHeader(HttpHeaders.CONTENT_TYPE); - Assertions.assertNotNull(h1); - Assertions.assertEquals("whatever", h1.getValue()); + Assertions.assertThat(h1).isNotNull(); + Assertions.assertThat(h1.getValue()).isEqualTo("whatever"); final Header h2 = request.getFirstHeader(HttpHeaders.CONTENT_ENCODING); - Assertions.assertNotNull(h2); - Assertions.assertEquals("whatever", h2.getValue()); + Assertions.assertThat(h2).isNotNull(); + Assertions.assertThat(h2.getValue()).isEqualTo("whatever"); } @Test @@ -227,8 +229,8 @@ void testRequestContentNullTypeAndEncoding() throws Exception { final HttpRequestInterceptor interceptor = RequestContent.INSTANCE; interceptor.process(request, request.getEntity(), context); - Assertions.assertNull(request.getFirstHeader(HttpHeaders.CONTENT_TYPE)); - Assertions.assertNull(request.getFirstHeader(HttpHeaders.CONTENT_ENCODING)); + Assertions.assertThat(request.getFirstHeader(HttpHeaders.CONTENT_TYPE)).isNull(); + Assertions.assertThat(request.getFirstHeader(HttpHeaders.CONTENT_ENCODING)).isNull(); } @Test @@ -239,15 +241,15 @@ void testRequestContentEntityUnknownLengthHTTP10() { request.setEntity(new BasicHttpEntity(EmptyInputStream.INSTANCE, -1, null)); final HttpRequestInterceptor interceptor = RequestContent.INSTANCE; - Assertions.assertThrows(ProtocolException.class, () -> - interceptor.process(request, request.getEntity(), context)); + Assertions.assertThatThrownBy(() -> + interceptor.process(request, request.getEntity(), context)).isInstanceOf(ProtocolException.class); } @Test void testRequestContentInvalidInput() { final HttpRequestInterceptor interceptor = RequestContent.INSTANCE; - Assertions.assertThrows(NullPointerException.class, () -> - interceptor.process(null, null, null)); + Assertions.assertThatThrownBy(() -> + interceptor.process(null, null, null)).isInstanceOf(NullPointerException.class); } @Test @@ -256,7 +258,7 @@ void testRequestContentIgnoreNonenclosingRequests() throws Exception { final BasicClassicHttpRequest request = new BasicClassicHttpRequest(Method.POST, "/"); final HttpRequestInterceptor interceptor = RequestContent.INSTANCE; interceptor.process(request, request.getEntity(), context); - Assertions.assertEquals(1, request.getHeaders().length); + Assertions.assertThat(request.getHeaders().length).isEqualTo(1); } @Test @@ -269,8 +271,8 @@ void testRequestContentOverwriteHeaders() throws Exception { request.setEntity(new StringEntity("")); interceptor.process(request, request.getEntity(), context); final Header h1 = request.getFirstHeader(HttpHeaders.CONTENT_LENGTH); - Assertions.assertNotNull(h1); - Assertions.assertEquals("0", h1.getValue()); + Assertions.assertThat(h1).isNotNull(); + Assertions.assertThat(h1.getValue()).isEqualTo("0"); } @Test @@ -281,10 +283,10 @@ void testRequestContentAddHeaders() throws Exception { request.setEntity(new StringEntity("")); interceptor.process(request, request.getEntity(), context); final Header h1 = request.getFirstHeader(HttpHeaders.CONTENT_LENGTH); - Assertions.assertNotNull(h1); - Assertions.assertEquals("0", h1.getValue()); + Assertions.assertThat(h1).isNotNull(); + Assertions.assertThat(h1.getValue()).isEqualTo("0"); final Header h2 = request.getFirstHeader(HttpHeaders.TRANSFER_ENCODING); - Assertions.assertNull(h2); + Assertions.assertThat(h2).isNull(); } @Test @@ -297,10 +299,10 @@ void testRequestContentEntityWithTrailers() throws Exception { final HttpRequestInterceptor interceptor = RequestContent.INSTANCE; interceptor.process(request, request.getEntity(), context); final Header header1 = request.getFirstHeader(HttpHeaders.TRANSFER_ENCODING); - Assertions.assertNotNull(header1); + Assertions.assertThat(header1).isNotNull(); final Header header2 = request.getFirstHeader(HttpHeaders.TRAILER); - Assertions.assertNotNull(header2); - Assertions.assertEquals("h1, h2", header2.getValue()); + Assertions.assertThat(header2).isNotNull(); + Assertions.assertThat(header2.getValue()).isEqualTo("h1, h2"); } @Test @@ -309,8 +311,8 @@ void testRequestContentTraceWithEntity() { final BasicClassicHttpRequest request = new BasicClassicHttpRequest(Method.TRACE, "/"); request.setEntity(new StringEntity("stuff")); final HttpRequestInterceptor interceptor = RequestContent.INSTANCE; - Assertions.assertThrows(ProtocolException.class, () -> - interceptor.process(request, request.getEntity(), context)); + Assertions.assertThatThrownBy(() -> + interceptor.process(request, request.getEntity(), context)).isInstanceOf(ProtocolException.class); } @Test @@ -321,8 +323,8 @@ void testRequestExpectContinueGenerated() throws Exception { final RequestExpectContinue interceptor = RequestExpectContinue.INSTANCE; interceptor.process(request, request.getEntity(), context); final Header header = request.getFirstHeader(HttpHeaders.EXPECT); - Assertions.assertNotNull(header); - Assertions.assertEquals(HeaderElements.CONTINUE, header.getValue()); + Assertions.assertThat(header).isNotNull(); + Assertions.assertThat(header.getValue()).isEqualTo(HeaderElements.CONTINUE); } @Test @@ -334,7 +336,7 @@ void testRequestExpectContinueHTTP10() throws Exception { final RequestExpectContinue interceptor = RequestExpectContinue.INSTANCE; interceptor.process(request, request.getEntity(), context); final Header header = request.getFirstHeader(HttpHeaders.EXPECT); - Assertions.assertNull(header); + Assertions.assertThat(header).isNull(); } @Test @@ -345,14 +347,14 @@ void testRequestExpectContinueZeroContent() throws Exception { final RequestExpectContinue interceptor = RequestExpectContinue.INSTANCE; interceptor.process(request, request.getEntity(), context); final Header header = request.getFirstHeader(HttpHeaders.EXPECT); - Assertions.assertNull(header); + Assertions.assertThat(header).isNull(); } @Test void testRequestExpectContinueInvalidInput() { final RequestExpectContinue interceptor = RequestExpectContinue.INSTANCE; - Assertions.assertThrows(NullPointerException.class, () -> - interceptor.process(null, null, null)); + Assertions.assertThatThrownBy(() -> + interceptor.process(null, null, null)).isInstanceOf(NullPointerException.class); } @Test @@ -361,7 +363,7 @@ void testRequestExpectContinueIgnoreNonenclosingRequests() throws Exception { final BasicClassicHttpRequest request = new BasicClassicHttpRequest(Method.POST, "/"); final RequestExpectContinue interceptor = RequestExpectContinue.INSTANCE; interceptor.process(request, request.getEntity(), context); - Assertions.assertEquals(0, request.getHeaders().length); + Assertions.assertThat(request.getHeaders().length).isEqualTo(0); } @Test @@ -372,8 +374,8 @@ void testRequestTargetHostGenerated() throws Exception { final HttpRequestInterceptor interceptor = RequestTargetHost.INSTANCE; interceptor.process(request, request.getEntity(), context); final Header header = request.getFirstHeader(HttpHeaders.HOST); - Assertions.assertNotNull(header); - Assertions.assertEquals("somehost:8080", header.getValue()); + Assertions.assertThat(header).isNotNull(); + Assertions.assertThat(header.getValue()).isEqualTo("somehost:8080"); } @Test @@ -385,8 +387,8 @@ void testRequestTargetHostNotGenerated() throws Exception { final HttpRequestInterceptor interceptor = RequestTargetHost.INSTANCE; interceptor.process(request, request.getEntity(), context); final Header header = request.getFirstHeader(HttpHeaders.HOST); - Assertions.assertNotNull(header); - Assertions.assertEquals("whatever", header.getValue()); + Assertions.assertThat(header).isNotNull(); + Assertions.assertThat(header.getValue()).isEqualTo("whatever"); } @Test @@ -397,7 +399,7 @@ void testRequestTargetHostMissingHostHTTP10() throws Exception { final HttpRequestInterceptor interceptor = RequestTargetHost.INSTANCE; interceptor.process(request, request.getEntity(), context); final Header header = request.getFirstHeader(HttpHeaders.HOST); - Assertions.assertNull(header); + Assertions.assertThat(header).isNull(); } @Test @@ -405,17 +407,17 @@ void testRequestTargetHostMissingHostHTTP11() { final HttpCoreContext context = HttpCoreContext.create(); final BasicClassicHttpRequest request = new BasicClassicHttpRequest(Method.GET, "/"); final HttpRequestInterceptor interceptor = RequestTargetHost.INSTANCE; - Assertions.assertThrows(ProtocolException.class, () -> - interceptor.process(request, request.getEntity(), context)); + Assertions.assertThatThrownBy(() -> + interceptor.process(request, request.getEntity(), context)).isInstanceOf(ProtocolException.class); } @Test void testRequestTargetHostInvalidInput() { final HttpRequestInterceptor interceptor = RequestTargetHost.INSTANCE; - Assertions.assertThrows(NullPointerException.class, () -> - interceptor.process(null, null, null)); - Assertions.assertThrows(NullPointerException.class, () -> - interceptor.process(new BasicClassicHttpRequest(Method.GET, "/"), null, null)); + Assertions.assertThatThrownBy(() -> + interceptor.process(null, null, null)).isInstanceOf(NullPointerException.class); + Assertions.assertThatThrownBy(() -> + interceptor.process(new BasicClassicHttpRequest(Method.GET, "/"), null, null)).isInstanceOf(NullPointerException.class); } @Test @@ -426,8 +428,8 @@ void testRequestTargetHostConnectHttp11() throws Exception { final HttpRequestInterceptor interceptor = RequestTargetHost.INSTANCE; interceptor.process(request, request.getEntity(), context); final Header header = request.getFirstHeader(HttpHeaders.HOST); - Assertions.assertNotNull(header); - Assertions.assertEquals("somehost:8080", header.getValue()); + Assertions.assertThat(header).isNotNull(); + Assertions.assertThat(header.getValue()).isEqualTo("somehost:8080"); } @Test @@ -439,7 +441,7 @@ void testRequestTargetHostConnectHttp10() throws Exception { final HttpRequestInterceptor interceptor = RequestTargetHost.INSTANCE; interceptor.process(request, request.getEntity(), context); final Header header = request.getFirstHeader(HttpHeaders.HOST); - Assertions.assertNull(header); + Assertions.assertThat(header).isNull(); } @Test @@ -456,8 +458,8 @@ void testTEHeaderWithConnectionTE() throws Exception { interceptor.process(request, request.getEntity(), context); final Header connectionHeader = request.getFirstHeader(HttpHeaders.CONNECTION); - Assertions.assertNotNull(connectionHeader); - Assertions.assertEquals("TE", connectionHeader.getValue()); + Assertions.assertThat(connectionHeader).isNotNull(); + Assertions.assertThat(connectionHeader.getValue()).isEqualTo("TE"); } @@ -468,8 +470,8 @@ void testRequestUserAgentGenerated() throws Exception { final RequestUserAgent interceptor = new RequestUserAgent("some agent"); interceptor.process(request, request.getEntity(), context); final Header header = request.getFirstHeader(HttpHeaders.USER_AGENT); - Assertions.assertNotNull(header); - Assertions.assertEquals("some agent", header.getValue()); + Assertions.assertThat(header).isNotNull(); + Assertions.assertThat(header.getValue()).isEqualTo("some agent"); } @Test @@ -480,8 +482,8 @@ void testRequestUserAgentNotGenerated() throws Exception { final RequestUserAgent interceptor = new RequestUserAgent("some agent"); interceptor.process(request, request.getEntity(), context); final Header header = request.getFirstHeader(HttpHeaders.USER_AGENT); - Assertions.assertNotNull(header); - Assertions.assertEquals("whatever", header.getValue()); + Assertions.assertThat(header).isNotNull(); + Assertions.assertThat(header.getValue()).isEqualTo("whatever"); } @Test @@ -491,13 +493,15 @@ void testRequestUserAgentMissingUserAgent() throws Exception { final HttpRequestInterceptor interceptor = RequestUserAgent.INSTANCE; interceptor.process(request, request.getEntity(), context); final Header header = request.getFirstHeader(HttpHeaders.USER_AGENT); - Assertions.assertNull(header); + Assertions.assertThat(header).isNull(); } @Test void testRequestUserAgentInvalidInput() { final HttpRequestInterceptor interceptor = RequestUserAgent.INSTANCE; - Assertions.assertThrows(NullPointerException.class, () -> interceptor.process(null, null, null)); + Assertions.assertThatThrownBy(() -> + interceptor.process(null, null, null)) + .isInstanceOf(NullPointerException.class); } @Test @@ -507,7 +511,7 @@ void testResponseConnControlNoEntity() throws Exception { final ResponseConnControl interceptor = new ResponseConnControl(); interceptor.process(response, response.getEntity(), context); final Header header = response.getFirstHeader(HttpHeaders.CONNECTION); - Assertions.assertNull(header); + Assertions.assertThat(header).isNull(); } @Test @@ -518,7 +522,7 @@ void testResponseConnControlEntityContentLength() throws Exception { final ResponseConnControl interceptor = new ResponseConnControl(); interceptor.process(response, response.getEntity(), context); final Header header = response.getFirstHeader(HttpHeaders.CONNECTION); - Assertions.assertNull(header); + Assertions.assertThat(header).isNull(); } @Test @@ -532,8 +536,8 @@ void testResponseConnControlEntityUnknownContentLengthExplicitKeepAlive() throws final ResponseConnControl interceptor = new ResponseConnControl(); interceptor.process(response, response.getEntity(), context); final Header header = response.getFirstHeader(HttpHeaders.CONNECTION); - Assertions.assertNotNull(header); - Assertions.assertEquals("keep-alive", header.getValue()); + Assertions.assertThat(header).isNotNull(); + Assertions.assertThat(header.getValue()).isEqualTo("keep-alive"); } @Test @@ -544,7 +548,7 @@ void testResponseConnControlEntityChunked() throws Exception { final ResponseConnControl interceptor = new ResponseConnControl(); interceptor.process(response, response.getEntity(), context); final Header header = response.getFirstHeader(HttpHeaders.CONNECTION); - Assertions.assertNull(header); + Assertions.assertThat(header).isNull(); } @Test @@ -560,8 +564,8 @@ void testResponseConnControlEntityUnknownContentLengthHTTP10() throws Exception final ResponseConnControl interceptor = new ResponseConnControl(); interceptor.process(response, response.getEntity(), context); final Header header = response.getFirstHeader(HttpHeaders.CONNECTION); - Assertions.assertNotNull(header); - Assertions.assertEquals("close", header.getValue()); + Assertions.assertThat(header).isNotNull(); + Assertions.assertThat(header.getValue()).isEqualTo("close"); } @Test @@ -576,8 +580,8 @@ void testResponseConnControlClientRequest() throws Exception { final ResponseConnControl interceptor = new ResponseConnControl(); interceptor.process(response, response.getEntity(), context); final Header header = response.getFirstHeader(HttpHeaders.CONNECTION); - Assertions.assertNotNull(header); - Assertions.assertEquals("keep-alive", header.getValue()); + Assertions.assertThat(header).isNotNull(); + Assertions.assertThat(header.getValue()).isEqualTo("keep-alive"); } @Test @@ -591,7 +595,7 @@ void testResponseConnControlClientRequest2() throws Exception { final ResponseConnControl interceptor = new ResponseConnControl(); interceptor.process(response, response.getEntity(), context); final Header header = response.getFirstHeader(HttpHeaders.CONNECTION); - Assertions.assertNull(header); + Assertions.assertThat(header).isNull(); } @Test @@ -606,8 +610,8 @@ void testResponseConnControl10Client11Response() throws Exception { final ResponseConnControl interceptor = new ResponseConnControl(); interceptor.process(response, response.getEntity(), context); final Header header = response.getFirstHeader(HttpHeaders.CONNECTION); - Assertions.assertNotNull(header); - Assertions.assertEquals("close", header.getValue()); + Assertions.assertThat(header).isNotNull(); + Assertions.assertThat(header.getValue()).isEqualTo("close"); } @Test @@ -632,8 +636,8 @@ void testResponseConnControlStatusCode() throws Exception { final ClassicHttpResponse response = new BasicClassicHttpResponse(statusCode, "Unreasonable"); interceptor.process(response, response.getEntity(), context); final Header header = response.getFirstHeader(HttpHeaders.CONNECTION); - Assertions.assertNotNull(header); - Assertions.assertEquals("close", header.getValue()); + Assertions.assertThat(header).isNotNull(); + Assertions.assertThat(header.getValue()).isEqualTo("close"); } } @@ -651,8 +655,8 @@ void testResponseConnControlExplicitClose() throws Exception { response.setHeader(HttpHeaders.CONNECTION, "close"); interceptor.process(response, response.getEntity(), context); final Header header = response.getFirstHeader(HttpHeaders.CONNECTION); - Assertions.assertNotNull(header); - Assertions.assertEquals("close", header.getValue()); + Assertions.assertThat(header).isNotNull(); + Assertions.assertThat(header.getValue()).isEqualTo("close"); } @Test @@ -667,8 +671,8 @@ void testResponseConnControlClientRequestMixUp() throws Exception { final ClassicHttpResponse response = new BasicClassicHttpResponse(200, "OK"); interceptor.process(response, response.getEntity(), context); final Header header = response.getFirstHeader(HttpHeaders.CONNECTION); - Assertions.assertNotNull(header); - Assertions.assertEquals("close", header.getValue()); + Assertions.assertThat(header).isNotNull(); + Assertions.assertThat(header.getValue()).isEqualTo("close"); } @Test @@ -681,18 +685,18 @@ void testResponseConnControlUpgrade() throws Exception { response.addHeader(HttpHeaders.UPGRADE, "HTTP/2"); interceptor.process(response, response.getEntity(), context); final Header header = response.getFirstHeader(HttpHeaders.CONNECTION); - Assertions.assertNotNull(header); - Assertions.assertEquals("upgrade", header.getValue()); + Assertions.assertThat(header).isNotNull(); + Assertions.assertThat(header.getValue()).isEqualTo("upgrade"); } @Test void testResponseConnControlHostInvalidInput() { final ResponseConnControl interceptor = new ResponseConnControl(); - Assertions.assertThrows(NullPointerException.class, () -> - interceptor.process(null, null, null)); + Assertions.assertThatThrownBy(() -> + interceptor.process(null, null, null)).isInstanceOf(NullPointerException.class); final ClassicHttpResponse response = new BasicClassicHttpResponse(HttpStatus.SC_OK, "OK"); - Assertions.assertThrows(NullPointerException.class, () -> - interceptor.process(response, null, null)); + Assertions.assertThatThrownBy(() -> + interceptor.process(response, null, null)).isInstanceOf(NullPointerException.class); } @Test @@ -702,8 +706,8 @@ void testResponseContentNoEntity() throws Exception { final ResponseContent interceptor = new ResponseContent(); interceptor.process(response, response.getEntity(), context); final Header header = response.getFirstHeader(HttpHeaders.CONTENT_LENGTH); - Assertions.assertNotNull(header); - Assertions.assertEquals("0", header.getValue()); + Assertions.assertThat(header).isNotNull(); + Assertions.assertThat(header.getValue()).isEqualTo("0"); } @Test @@ -714,7 +718,7 @@ void testResponseContentStatusNoContent() throws Exception { final ResponseContent interceptor = new ResponseContent(); interceptor.process(response, response.getEntity(), context); final Header header = response.getFirstHeader(HttpHeaders.CONTENT_LENGTH); - Assertions.assertNull(header); + Assertions.assertThat(header).isNull(); } @Test @@ -725,7 +729,7 @@ void testResponseContentStatusNotModified() throws Exception { final ResponseContent interceptor = new ResponseContent(); interceptor.process(response, response.getEntity(), context); final Header header = response.getFirstHeader(HttpHeaders.CONTENT_LENGTH); - Assertions.assertNull(header); + Assertions.assertThat(header).isNull(); } @Test @@ -736,10 +740,10 @@ void testResponseContentEntityChunked() throws Exception { final ResponseContent interceptor = new ResponseContent(); interceptor.process(response, response.getEntity(), context); final Header h1 = response.getFirstHeader(HttpHeaders.TRANSFER_ENCODING); - Assertions.assertNotNull(h1); - Assertions.assertEquals("chunked", h1.getValue()); + Assertions.assertThat(h1).isNotNull(); + Assertions.assertThat(h1.getValue()).isEqualTo("chunked"); final Header h2 = response.getFirstHeader(HttpHeaders.CONTENT_LENGTH); - Assertions.assertNull(h2); + Assertions.assertThat(h2).isNull(); } @Test @@ -750,10 +754,10 @@ void testResponseContentEntityContentLenghtDelimited() throws Exception { final ResponseContent interceptor = new ResponseContent(); interceptor.process(response, response.getEntity(), context); final Header h1 = response.getFirstHeader(HttpHeaders.CONTENT_LENGTH); - Assertions.assertNotNull(h1); - Assertions.assertEquals("10", h1.getValue()); + Assertions.assertThat(h1).isNotNull(); + Assertions.assertThat(h1.getValue()).isEqualTo("10"); final Header h2 = response.getFirstHeader(HttpHeaders.TRANSFER_ENCODING); - Assertions.assertNull(h2); + Assertions.assertThat(h2).isNull(); } @Test @@ -764,10 +768,10 @@ void testResponseContentEntityUnknownContentLength() throws Exception { final ResponseContent interceptor = new ResponseContent(); interceptor.process(response, response.getEntity(), context); final Header h1 = response.getFirstHeader(HttpHeaders.TRANSFER_ENCODING); - Assertions.assertNotNull(h1); - Assertions.assertEquals("chunked", h1.getValue()); + Assertions.assertThat(h1).isNotNull(); + Assertions.assertThat(h1.getValue()).isEqualTo("chunked"); final Header h2 = response.getFirstHeader(HttpHeaders.CONTENT_LENGTH); - Assertions.assertNull(h2); + Assertions.assertThat(h2).isNull(); } @Test @@ -779,9 +783,9 @@ void testResponseContentEntityChunkedHTTP10() throws Exception { final ResponseContent interceptor = new ResponseContent(); interceptor.process(response, response.getEntity(), context); final Header h1 = response.getFirstHeader(HttpHeaders.TRANSFER_ENCODING); - Assertions.assertNull(h1); + Assertions.assertThat(h1).isNull(); final Header h2 = response.getFirstHeader(HttpHeaders.CONTENT_LENGTH); - Assertions.assertNull(h2); + Assertions.assertThat(h2).isNull(); } @Test @@ -792,9 +796,9 @@ void testResponseContentEntityNoContentTypeAndEncoding() throws Exception { final ResponseContent interceptor = new ResponseContent(); interceptor.process(response, response.getEntity(), context); final Header h1 = response.getFirstHeader(HttpHeaders.CONTENT_TYPE); - Assertions.assertNull(h1); + Assertions.assertThat(h1).isNull(); final Header h2 = response.getFirstHeader(HttpHeaders.CONTENT_ENCODING); - Assertions.assertNull(h2); + Assertions.assertThat(h2).isNull(); } @Test @@ -806,17 +810,19 @@ void testResponseContentEntityContentTypeAndEncoding() throws Exception { final ResponseContent interceptor = new ResponseContent(); interceptor.process(response, response.getEntity(), context); final Header h1 = response.getFirstHeader(HttpHeaders.CONTENT_TYPE); - Assertions.assertNotNull(h1); - Assertions.assertEquals("whatever", h1.getValue()); + Assertions.assertThat(h1).isNotNull(); + Assertions.assertThat(h1.getValue()).isEqualTo("whatever"); final Header h2 = response.getFirstHeader(HttpHeaders.CONTENT_ENCODING); - Assertions.assertNotNull(h2); - Assertions.assertEquals("whatever", h2.getValue()); + Assertions.assertThat(h2).isNotNull(); + Assertions.assertThat(h2.getValue()).isEqualTo("whatever"); } @Test void testResponseContentInvalidInput() { final ResponseContent interceptor = new ResponseContent(); - Assertions.assertThrows(NullPointerException.class, () -> interceptor.process(null, null, null)); + Assertions.assertThatThrownBy(() -> + interceptor.process(null, null, null)) + .isInstanceOf(NullPointerException.class); } @Test @@ -825,12 +831,12 @@ void testResponseContentInvalidResponseState() { final HttpCoreContext context = HttpCoreContext.create(); final ClassicHttpResponse response1 = new BasicClassicHttpResponse(HttpStatus.SC_OK, "OK"); response1.addHeader(new BasicHeader(HttpHeaders.CONTENT_LENGTH, "10")); - Assertions.assertThrows(ProtocolException.class, () -> - interceptor.process(response1, response1.getEntity(), context)); + Assertions.assertThatThrownBy(() -> + interceptor.process(response1, response1.getEntity(), context)).isInstanceOf(ProtocolException.class); final ClassicHttpResponse response2 = new BasicClassicHttpResponse(HttpStatus.SC_OK, "OK"); response2.addHeader(new BasicHeader(HttpHeaders.TRANSFER_ENCODING, "stuff")); - Assertions.assertThrows(ProtocolException.class, () -> - interceptor.process(response2, response2.getEntity(), context)); + Assertions.assertThatThrownBy(() -> + interceptor.process(response2, response2.getEntity(), context)).isInstanceOf(ProtocolException.class); } @Test @@ -841,7 +847,7 @@ void testResponseContentOverwriteHeaders() throws Exception { response.addHeader(new BasicHeader(HttpHeaders.CONTENT_LENGTH, "10")); response.addHeader(new BasicHeader(HttpHeaders.TRANSFER_ENCODING, "whatever")); interceptor.process(response, response.getEntity(), context); - Assertions.assertEquals("0", response.getFirstHeader(HttpHeaders.CONTENT_LENGTH).getValue()); + Assertions.assertThat(response.getFirstHeader(HttpHeaders.CONTENT_LENGTH).getValue()).isEqualTo("0"); } @Test @@ -850,8 +856,8 @@ void testResponseContentAddHeaders() throws Exception { final HttpCoreContext context = HttpCoreContext.create(); final ClassicHttpResponse response = new BasicClassicHttpResponse(HttpStatus.SC_OK, "OK"); interceptor.process(response, response.getEntity(), context); - Assertions.assertEquals("0", response.getFirstHeader(HttpHeaders.CONTENT_LENGTH).getValue()); - Assertions.assertNull(response.getFirstHeader(HttpHeaders.TRANSFER_ENCODING)); + Assertions.assertThat(response.getFirstHeader(HttpHeaders.CONTENT_LENGTH).getValue()).isEqualTo("0"); + Assertions.assertThat(response.getFirstHeader(HttpHeaders.TRANSFER_ENCODING)).isNull(); } @Test @@ -864,10 +870,10 @@ void testResponseContentEntityWithTrailers() throws Exception { final ResponseContent interceptor = new ResponseContent(); interceptor.process(response, response.getEntity(), context); final Header header1 = response.getFirstHeader(HttpHeaders.TRANSFER_ENCODING); - Assertions.assertNotNull(header1); + Assertions.assertThat(header1).isNotNull(); final Header header2 = response.getFirstHeader(HttpHeaders.TRAILER); - Assertions.assertNotNull(header2); - Assertions.assertEquals("h1, h2", header2.getValue()); + Assertions.assertThat(header2).isNotNull(); + Assertions.assertThat(header2.getValue()).isEqualTo("h1, h2"); } @Test @@ -877,17 +883,17 @@ void testResponseDateGenerated() throws Exception { final ResponseDate interceptor = new ResponseDate(); interceptor.process(response, response.getEntity(), context); final Header h1 = response.getFirstHeader(HttpHeaders.DATE); - Assertions.assertNotNull(h1); + Assertions.assertThat(h1).isNotNull(); interceptor.process(response, response.getEntity(), context); final Header h2 = response.getFirstHeader(HttpHeaders.DATE); - Assertions.assertNotNull(h2); + Assertions.assertThat(h2).isNotNull(); } @Test void testResponseDateInvalidInput() { final ResponseDate interceptor = new ResponseDate(); - Assertions.assertThrows(NullPointerException.class, () -> - interceptor.process(null, null, null)); + Assertions.assertThatThrownBy(() -> + interceptor.process(null, null, null)).isInstanceOf(NullPointerException.class); } @Test @@ -899,10 +905,10 @@ void testRequestDateGenerated() throws Exception { final HttpRequestInterceptor interceptor = RequestDate.INSTANCE; interceptor.process(request, request.getEntity(), context); final Header h1 = request.getFirstHeader(HttpHeaders.DATE); - Assertions.assertNotNull(h1); + Assertions.assertThat(h1).isNotNull(); interceptor.process(request, request.getEntity(), context); final Header h2 = request.getFirstHeader(HttpHeaders.DATE); - Assertions.assertNotNull(h2); + Assertions.assertThat(h2).isNotNull(); } @Test @@ -913,14 +919,14 @@ void testRequestDateNotGenerated() throws Exception { final HttpRequestInterceptor interceptor = RequestDate.INSTANCE; interceptor.process(request, request.getEntity(), context); final Header h1 = request.getFirstHeader(HttpHeaders.DATE); - Assertions.assertNull(h1); + Assertions.assertThat(h1).isNull(); } @Test void testRequestDateInvalidInput() { final HttpRequestInterceptor interceptor = RequestDate.INSTANCE; - Assertions.assertThrows(NullPointerException.class, () -> - interceptor.process(null, null, null)); + Assertions.assertThatThrownBy(() -> + interceptor.process(null, null, null)).isInstanceOf(NullPointerException.class); } @Test @@ -930,8 +936,8 @@ void testResponseServerGenerated() throws Exception { final ResponseServer interceptor = new ResponseServer("some server"); interceptor.process(response, response.getEntity(), context); final Header h1 = response.getFirstHeader(HttpHeaders.SERVER); - Assertions.assertNotNull(h1); - Assertions.assertEquals("some server", h1.getValue()); + Assertions.assertThat(h1).isNotNull(); + Assertions.assertThat(h1.getValue()).isEqualTo("some server"); } @Test @@ -942,8 +948,8 @@ void testResponseServerNotGenerated() throws Exception { final ResponseServer interceptor = new ResponseServer("some server"); interceptor.process(response, response.getEntity(), context); final Header h1 = response.getFirstHeader(HttpHeaders.SERVER); - Assertions.assertNotNull(h1); - Assertions.assertEquals("whatever", h1.getValue()); + Assertions.assertThat(h1).isNotNull(); + Assertions.assertThat(h1.getValue()).isEqualTo("whatever"); } @Test @@ -953,13 +959,15 @@ void testResponseServerMissing() throws Exception { final ResponseServer interceptor = new ResponseServer(); interceptor.process(response, response.getEntity(), context); final Header h1 = response.getFirstHeader(HttpHeaders.SERVER); - Assertions.assertNull(h1); + Assertions.assertThat(h1).isNull(); } @Test void testResponseServerInvalidInput() { final ResponseServer interceptor = new ResponseServer(); - Assertions.assertThrows(NullPointerException.class, () -> interceptor.process(null, null, null)); + Assertions.assertThatThrownBy(() -> + interceptor.process(null, null, null)) + .isInstanceOf(NullPointerException.class); } @Test @@ -968,7 +976,7 @@ void testRequestHttp10HostHeaderAbsent() { final BasicClassicHttpRequest request = new BasicClassicHttpRequest(Method.GET, "/"); request.setVersion(HttpVersion.HTTP_1_0); final RequestValidateHost interceptor = new RequestValidateHost(); - Assertions.assertDoesNotThrow(() -> interceptor.process(request, request.getEntity(), context)); + Assertions.assertThatCode(() -> interceptor.process(request, request.getEntity(), context)).doesNotThrowAnyException(); } @Test @@ -979,7 +987,7 @@ void testRequestHttpHostHeader() throws Exception { request.setHeader(HttpHeaders.HOST, "host:8888"); final RequestValidateHost interceptor = new RequestValidateHost(); interceptor.process(request, request.getEntity(), context); - Assertions.assertEquals(new URIAuthority("host", 8888), request.getAuthority()); + Assertions.assertThat(request.getAuthority()).isEqualTo(new URIAuthority("host", 8888)); } @Test @@ -990,7 +998,7 @@ void testRequestHttpHostHeaderNoPort() throws Exception { request.setHeader(HttpHeaders.HOST, "host"); final RequestValidateHost interceptor = new RequestValidateHost(); interceptor.process(request, request.getEntity(), context); - Assertions.assertEquals(new URIAuthority("host"), request.getAuthority()); + Assertions.assertThat(request.getAuthority()).isEqualTo(new URIAuthority("host")); } @Test @@ -1007,8 +1015,8 @@ void testRequestHttp11HostHeaderAbsent() { final HttpCoreContext context = HttpCoreContext.create(); final BasicClassicHttpRequest request = new BasicClassicHttpRequest(Method.GET, "/"); final RequestValidateHost interceptor = new RequestValidateHost(); - Assertions.assertThrows(ProtocolException.class, () -> - interceptor.process(request, request.getEntity(), context)); + Assertions.assertThatThrownBy(() -> + interceptor.process(request, request.getEntity(), context)).isInstanceOf(ProtocolException.class); } @Test @@ -1018,8 +1026,8 @@ void testRequestHttp11MultipleHostHeaders() { request.addHeader(HttpHeaders.HOST, "blah"); request.addHeader(HttpHeaders.HOST, "blah"); final RequestValidateHost interceptor = new RequestValidateHost(); - Assertions.assertThrows(ProtocolException.class, () -> - interceptor.process(request, request.getEntity(), context)); + Assertions.assertThatThrownBy(() -> + interceptor.process(request, request.getEntity(), context)).isInstanceOf(ProtocolException.class); } @Test @@ -1029,7 +1037,7 @@ void testRequestAbsoluteRequestURITakesPrecedenceOverHostHeader() throws Excepti request.setHeader(HttpHeaders.HOST, "blah"); final RequestValidateHost interceptor = new RequestValidateHost(); interceptor.process(request, request.getEntity(), context); - Assertions.assertEquals(new URIAuthority("somehost"), request.getAuthority()); + Assertions.assertThat(request.getAuthority()).isEqualTo(new URIAuthority("somehost")); } @Test @@ -1040,7 +1048,7 @@ void testRequestConformance() { request.setAuthority(new URIAuthority("somehost", 8888)); request.setPath("/path"); final RequestConformance interceptor = new RequestConformance(); - Assertions.assertDoesNotThrow(() -> interceptor.process(request, request.getEntity(), context)); + Assertions.assertThatCode(() -> interceptor.process(request, request.getEntity(), context)).doesNotThrowAnyException(); } @Test @@ -1051,8 +1059,8 @@ void testRequestConformanceQueryMissingContentType() { request.setAuthority(new URIAuthority("somehost", 8888)); request.setPath("/path"); final RequestConformance interceptor = new RequestConformance(); - Assertions.assertThrows(ProtocolException.class, () -> - interceptor.process(request, request.getEntity(), context)); + Assertions.assertThatThrownBy(() -> + interceptor.process(request, request.getEntity(), context)).isInstanceOf(ProtocolException.class); } @Test @@ -1064,7 +1072,7 @@ void testRequestConformanceQueryWithContentType() { request.setPath("/path"); request.setHeader(HttpHeaders.CONTENT_TYPE, "application/jsonpath"); final RequestConformance interceptor = new RequestConformance(); - Assertions.assertDoesNotThrow(() -> interceptor.process(request, request.getEntity(), context)); + Assertions.assertThatCode(() -> interceptor.process(request, request.getEntity(), context)).doesNotThrowAnyException(); } @Test @@ -1074,8 +1082,8 @@ void testRequestConformanceSchemeMissing() { request.setAuthority(new URIAuthority("somehost", 8888)); request.setPath("/path"); final RequestConformance interceptor = new RequestConformance(); - Assertions.assertThrows(ProtocolException.class, () -> - interceptor.process(request, request.getEntity(), context)); + Assertions.assertThatThrownBy(() -> + interceptor.process(request, request.getEntity(), context)).isInstanceOf(ProtocolException.class); } @Test @@ -1086,8 +1094,8 @@ void testRequestConformancePathMissing() { request.setAuthority(new URIAuthority("somehost", 8888)); request.setPath(""); final RequestConformance interceptor = new RequestConformance(); - Assertions.assertThrows(ProtocolException.class, () -> - interceptor.process(request, request.getEntity(), context)); + Assertions.assertThatThrownBy(() -> + interceptor.process(request, request.getEntity(), context)).isInstanceOf(ProtocolException.class); } @Test @@ -1098,8 +1106,8 @@ void testRequestConformanceHostMissing() { request.setAuthority(new URIAuthority("", -1)); request.setPath("/path"); final RequestConformance interceptor = new RequestConformance(); - Assertions.assertThrows(ProtocolException.class, () -> - interceptor.process(request, request.getEntity(), context)); + Assertions.assertThatThrownBy(() -> + interceptor.process(request, request.getEntity(), context)).isInstanceOf(ProtocolException.class); } @Test @@ -1111,7 +1119,7 @@ void testRequestConformanceHttps() { request.setAuthority(new URIAuthority("somehost", 8888)); request.setPath("/path"); final RequestConformance interceptor = new RequestConformance(); - Assertions.assertDoesNotThrow(() -> interceptor.process(request, request.getEntity(), context)); + Assertions.assertThatCode(() -> interceptor.process(request, request.getEntity(), context)).doesNotThrowAnyException(); } @Test @@ -1123,8 +1131,8 @@ void testRequestConformanceHttpsInsecureConnection() { request.setAuthority(new URIAuthority("somehost", 8888)); request.setPath("/path"); final RequestConformance interceptor = new RequestConformance(); - Assertions.assertThrows(MisdirectedRequestException.class, () -> - interceptor.process(request, request.getEntity(), context)); + Assertions.assertThatThrownBy(() -> + interceptor.process(request, request.getEntity(), context)).isInstanceOf(MisdirectedRequestException.class); } @Test @@ -1132,7 +1140,7 @@ void testResponseConformanceNoContent() { final HttpCoreContext context = HttpCoreContext.create(); final ClassicHttpResponse response = new BasicClassicHttpResponse(HttpStatus.SC_NO_CONTENT, "No Content"); final ResponseConformance interceptor = new ResponseConformance(); - Assertions.assertDoesNotThrow(() -> interceptor.process(response, response.getEntity(), context)); + Assertions.assertThatCode(() -> interceptor.process(response, response.getEntity(), context)).doesNotThrowAnyException(); } @Test @@ -1140,7 +1148,7 @@ void testResponseConformanceNotModified() { final HttpCoreContext context = HttpCoreContext.create(); final ClassicHttpResponse response = new BasicClassicHttpResponse(HttpStatus.SC_NOT_MODIFIED, "Not Modified"); final ResponseConformance interceptor = new ResponseConformance(); - Assertions.assertDoesNotThrow(() -> interceptor.process(response, response.getEntity(), context)); + Assertions.assertThatCode(() -> interceptor.process(response, response.getEntity(), context)).doesNotThrowAnyException(); } @Test @@ -1149,8 +1157,8 @@ void testResponseConformanceNoContentWithEntity() { final ClassicHttpResponse response = new BasicClassicHttpResponse(HttpStatus.SC_NO_CONTENT, "No Content"); response.setEntity(new StringEntity("stuff")); final ResponseConformance interceptor = new ResponseConformance(); - Assertions.assertThrows(ProtocolException.class, () -> - interceptor.process(response, response.getEntity(), context)); + Assertions.assertThatThrownBy(() -> + interceptor.process(response, response.getEntity(), context)).isInstanceOf(ProtocolException.class); } @Test @@ -1159,8 +1167,8 @@ void testResponseConformanceNotModifiedWithEntity() { final ClassicHttpResponse response = new BasicClassicHttpResponse(HttpStatus.SC_NOT_MODIFIED, "Not Modified"); response.setEntity(new StringEntity("stuff")); final ResponseConformance interceptor = new ResponseConformance(); - Assertions.assertThrows(ProtocolException.class, () -> - interceptor.process(response, response.getEntity(), context)); + Assertions.assertThatThrownBy(() -> + interceptor.process(response, response.getEntity(), context)).isInstanceOf(ProtocolException.class); } @Test @@ -1179,8 +1187,8 @@ void testInvalidDateReplaced() throws Exception { // Assert that the Date header has been replaced final Header newDateHeader = response.getFirstHeader(HttpHeaders.DATE); - Assertions.assertNotNull(newDateHeader); - Assertions.assertNotEquals("Invalid Date", newDateHeader.getValue()); + Assertions.assertThat(newDateHeader).isNotNull(); + Assertions.assertThat(newDateHeader.getValue()).isNotEqualTo("Invalid Date"); } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/protocol/ViaRequestTest.java b/httpcore5/src/test/java/org/apache/hc/core5/http/protocol/ViaRequestTest.java index 5324b12008..08b111544d 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/protocol/ViaRequestTest.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/protocol/ViaRequestTest.java @@ -26,9 +26,6 @@ */ package org.apache.hc.core5.http.protocol; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertNotNull; - import org.apache.hc.core5.http.HttpHeaders; import org.apache.hc.core5.http.HttpRequestInterceptor; import org.apache.hc.core5.http.HttpVersion; @@ -36,7 +33,7 @@ import org.apache.hc.core5.http.ProtocolException; import org.apache.hc.core5.http.message.BasicClassicHttpRequest; import org.apache.hc.core5.net.URIAuthority; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; @@ -52,9 +49,9 @@ void testViaRequestGenerated() throws Exception { final ViaRequest interceptor = new ViaRequest(); interceptor.process(request, request.getEntity(), context); - assertEquals(HttpHeaders.VIA, request.getHeader(HttpHeaders.VIA).getName()); - assertNotNull(request.getHeader(HttpHeaders.VIA)); - assertEquals("HTTP 1.1 somehost:8888", request.getHeader(HttpHeaders.VIA).getValue()); + Assertions.assertThat(request.getHeader(HttpHeaders.VIA).getName()).isEqualTo(HttpHeaders.VIA); + Assertions.assertThat(request.getHeader(HttpHeaders.VIA)).isNotNull(); + Assertions.assertThat(request.getHeader(HttpHeaders.VIA).getValue()).isEqualTo("HTTP 1.1 somehost:8888"); } @@ -68,9 +65,9 @@ void testViaRequestGeneratedWithOutPort() throws Exception { final ViaRequest interceptor = new ViaRequest(); interceptor.process(request, request.getEntity(), context); - assertEquals(HttpHeaders.VIA, request.getHeader(HttpHeaders.VIA).getName()); - assertNotNull(request.getHeader(HttpHeaders.VIA)); - assertEquals("HTTP 1.1 somehost", request.getHeader(HttpHeaders.VIA).getValue()); + Assertions.assertThat(request.getHeader(HttpHeaders.VIA).getName()).isEqualTo(HttpHeaders.VIA); + Assertions.assertThat(request.getHeader(HttpHeaders.VIA)).isNotNull(); + Assertions.assertThat(request.getHeader(HttpHeaders.VIA).getValue()).isEqualTo("HTTP 1.1 somehost"); } @@ -82,8 +79,8 @@ void testViaRequestInvalidHttpVersion() { request.setAuthority(new URIAuthority("somehost", 8888)); final HttpRequestInterceptor interceptor = ViaRequest.INSTANCE; - Assertions.assertThrows(ProtocolException.class, () -> - interceptor.process(request, request.getEntity(), context)); + Assertions.assertThatThrownBy(() -> + interceptor.process(request, request.getEntity(), context)).isInstanceOf(ProtocolException.class); } @Test @@ -93,8 +90,8 @@ void testViaRequestInvalidAuthority() { context.setProtocolVersion(HttpVersion.HTTP_1_1); final HttpRequestInterceptor interceptor = ViaRequest.INSTANCE; - Assertions.assertThrows(ProtocolException.class, () -> - interceptor.process(request, request.getEntity(), context)); + Assertions.assertThatThrownBy(() -> + interceptor.process(request, request.getEntity(), context)).isInstanceOf(ProtocolException.class); } @Test @@ -109,9 +106,9 @@ void testViaRequestNotCreatedAlreadyAdded() throws Exception { final ViaRequest interceptor = new ViaRequest(); interceptor.process(request, request.getEntity(), context); - assertEquals(HttpHeaders.VIA, request.getHeader(HttpHeaders.VIA).getName()); - assertNotNull(request.getHeader(HttpHeaders.VIA)); - assertEquals(viaValue, request.getHeader(HttpHeaders.VIA).getValue()); + Assertions.assertThat(request.getHeader(HttpHeaders.VIA).getName()).isEqualTo(HttpHeaders.VIA); + Assertions.assertThat(request.getHeader(HttpHeaders.VIA)).isNotNull(); + Assertions.assertThat(request.getHeader(HttpHeaders.VIA).getValue()).isEqualTo(viaValue); } } \ No newline at end of file diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/ssl/TLSTest.java b/httpcore5/src/test/java/org/apache/hc/core5/http/ssl/TLSTest.java index a7edb2befe..5482737f64 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/ssl/TLSTest.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/ssl/TLSTest.java @@ -27,13 +27,10 @@ package org.apache.hc.core5.http.ssl; -import static org.junit.jupiter.api.Assertions.assertNull; -import static org.junit.jupiter.api.Assertions.assertTrue; - import org.apache.hc.core5.http.ParseException; import org.apache.hc.core5.http.ProtocolVersion; import org.apache.hc.core5.util.Tokenizer; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class TLSTest { @@ -41,37 +38,37 @@ class TLSTest { @Test void isSame() throws ParseException { - assertTrue(TLS.V_1_0.isSame(TLS.parse("TLSv1"))); + Assertions.assertThat(TLS.V_1_0.isSame(TLS.parse("TLSv1"))).isTrue(); } @Test void isComparable() throws ParseException { - assertTrue(TLS.V_1_0.isComparable(TLS.parse("TLSv1"))); + Assertions.assertThat(TLS.V_1_0.isComparable(TLS.parse("TLSv1"))).isTrue(); } @Test void greaterEquals() throws ParseException { - assertTrue(TLS.V_1_3.greaterEquals(TLS.parse("TLSv1"))); + Assertions.assertThat(TLS.V_1_3.greaterEquals(TLS.parse("TLSv1"))).isTrue(); } @Test void lessEquals() throws ParseException { - assertTrue(TLS.V_1_0.lessEquals(TLS.parse("TLSv1.3"))); + Assertions.assertThat(TLS.V_1_0.lessEquals(TLS.parse("TLSv1.3"))).isTrue(); } @Test void parse() throws ParseException { - assertTrue(TLS.V_1_0.lessEquals(TLS.parse("TLSv1.3"))); + Assertions.assertThat(TLS.V_1_0.lessEquals(TLS.parse("TLSv1.3"))).isTrue(); } @Test void parseNull() throws ParseException { - assertNull(TLS.parse(null)); + Assertions.assertThat(TLS.parse(null)).isNull(); } @Test void excludeWeakNull() { - assertNull(TLS.excludeWeak((String[]) null)); + Assertions.assertThat(TLS.excludeWeak((String[]) null)).isNull(); } @Test @@ -85,34 +82,46 @@ void excludeWeak() { }; final String[] strongProtocols = TLS.excludeWeak(mixProtocol); for (final String protocol : strongProtocols) { - Assertions.assertTrue(TLS.isSecure(protocol)); + Assertions.assertThat(TLS.isSecure(protocol)).isTrue(); } } @Test void testParseBasic() throws Exception { - Assertions.assertEquals(TLS.V_1_0.getVersion(), TLS.parse("TLSv1")); - Assertions.assertEquals(TLS.V_1_1.getVersion(), TLS.parse("TLSv1.1")); - Assertions.assertEquals(TLS.V_1_2.getVersion(), TLS.parse("TLSv1.2")); - Assertions.assertEquals(TLS.V_1_3.getVersion(), TLS.parse("TLSv1.3 ")); - Assertions.assertEquals(new ProtocolVersion("TLS", 22, 356), TLS.parse("TLSv22.356")); + Assertions.assertThat(TLS.parse("TLSv1")).isEqualTo(TLS.V_1_0.getVersion()); + Assertions.assertThat(TLS.parse("TLSv1.1")).isEqualTo(TLS.V_1_1.getVersion()); + Assertions.assertThat(TLS.parse("TLSv1.2")).isEqualTo(TLS.V_1_2.getVersion()); + Assertions.assertThat(TLS.parse("TLSv1.3 ")).isEqualTo(TLS.V_1_3.getVersion()); + Assertions.assertThat(TLS.parse("TLSv22.356")).isEqualTo(new ProtocolVersion("TLS", 22, 356)); } @Test void testParseBuffer() throws Exception { final Tokenizer.Cursor cursor = new Tokenizer.Cursor(1, 13); - Assertions.assertEquals(TLS.V_1_2.getVersion(), TLS.parse(" TLSv1.2,0000", cursor, Tokenizer.delimiters(','))); - Assertions.assertEquals(8, cursor.getPos()); + Assertions.assertThat(TLS.parse(" TLSv1.2,0000", cursor, Tokenizer.delimiters(','))).isEqualTo(TLS.V_1_2.getVersion()); + Assertions.assertThat(cursor.getPos()).isEqualTo(8); } @Test void testParseFailure() { - Assertions.assertThrows(ParseException.class, () -> TLS.parse("Tlsv1")); - Assertions.assertThrows(ParseException.class, () -> TLS.parse("TLSV1")); - Assertions.assertThrows(ParseException.class, () -> TLS.parse("TLSv")); - Assertions.assertThrows(ParseException.class, () -> TLS.parse("TLSv1A")); - Assertions.assertThrows(ParseException.class, () -> TLS.parse("TLSv1.A")); - Assertions.assertThrows(ParseException.class, () -> TLS.parse("TLSv1.1 huh?")); + Assertions.assertThatThrownBy(() -> + TLS.parse("Tlsv1")) + .isInstanceOf(ParseException.class); + Assertions.assertThatThrownBy(() -> + TLS.parse("TLSV1")) + .isInstanceOf(ParseException.class); + Assertions.assertThatThrownBy(() -> + TLS.parse("TLSv")) + .isInstanceOf(ParseException.class); + Assertions.assertThatThrownBy(() -> + TLS.parse("TLSv1A")) + .isInstanceOf(ParseException.class); + Assertions.assertThatThrownBy(() -> + TLS.parse("TLSv1.A")) + .isInstanceOf(ParseException.class); + Assertions.assertThatThrownBy(() -> + TLS.parse("TLSv1.1 huh?")) + .isInstanceOf(ParseException.class); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/ssl/TestTlsCiphers.java b/httpcore5/src/test/java/org/apache/hc/core5/http/ssl/TestTlsCiphers.java index a118704973..9d28e8b67e 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/ssl/TestTlsCiphers.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/ssl/TestTlsCiphers.java @@ -27,7 +27,7 @@ package org.apache.hc.core5.http.ssl; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.MethodSource; @@ -80,26 +80,26 @@ static String[] testExcludeWeak() { @Test void testCipherTLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384() { final String cipherSuite = "TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384"; - Assertions.assertTrue(TlsCiphers.isH2Blacklisted(cipherSuite)); - Assertions.assertTrue(TlsCiphers.isWeak(cipherSuite)); + Assertions.assertThat(TlsCiphers.isH2Blacklisted(cipherSuite)).isTrue(); + Assertions.assertThat(TlsCiphers.isWeak(cipherSuite)).isTrue(); } @ParameterizedTest @MethodSource void testExcludeH2Blacklisted(final String strongCipherSuite) { - Assertions.assertFalse(TlsCiphers.isH2Blacklisted(strongCipherSuite), strongCipherSuite); - Assertions.assertFalse(TlsCiphers.isWeak(strongCipherSuite), strongCipherSuite); + Assertions.assertThat(TlsCiphers.isH2Blacklisted(strongCipherSuite)).withFailMessage(strongCipherSuite).isFalse(); + Assertions.assertThat(TlsCiphers.isWeak(strongCipherSuite)).withFailMessage(strongCipherSuite).isFalse(); } @ParameterizedTest @MethodSource void testExcludeWeak(final String strongCipherSuite) { - Assertions.assertTrue(TlsCiphers.isWeak(strongCipherSuite), strongCipherSuite); + Assertions.assertThat(TlsCiphers.isWeak(strongCipherSuite)).withFailMessage(strongCipherSuite).isTrue(); } @Test void testExcludeWeakNull() { - Assertions.assertNull(TlsCiphers.excludeWeak((String[]) null)); + Assertions.assertThat(TlsCiphers.excludeWeak((String[]) null)).isNull(); } /** @@ -115,9 +115,9 @@ void testExcludeWeakNull() { @MethodSource("org.apache.hc.core5.http.ssl.TlsCiphers#getH2Blacklisted()") void testH2BlacklistedIsWeak(final String h2BlacklistedCipherSuite) { // Sanity assert - Assertions.assertTrue(TlsCiphers.isH2Blacklisted(h2BlacklistedCipherSuite), h2BlacklistedCipherSuite); + Assertions.assertThat(TlsCiphers.isH2Blacklisted(h2BlacklistedCipherSuite)).withFailMessage(h2BlacklistedCipherSuite).isTrue(); // Test - Assertions.assertTrue(TlsCiphers.isWeak(h2BlacklistedCipherSuite), h2BlacklistedCipherSuite); + Assertions.assertThat(TlsCiphers.isWeak(h2BlacklistedCipherSuite)).withFailMessage(h2BlacklistedCipherSuite).isTrue(); } /** @@ -191,7 +191,7 @@ void testH2BlacklistedIsWeak(final String h2BlacklistedCipherSuite) { "TLS_DH_anon_WITH_CAMELLIA_256_GCM_SHA384", // RFC6367 }) void testRfc10015Section5_1_DhDepreacted(final String deprecatedCipherSuite) { - Assertions.assertTrue(TlsCiphers.isWeak(deprecatedCipherSuite), deprecatedCipherSuite); + Assertions.assertThat(TlsCiphers.isWeak(deprecatedCipherSuite)).withFailMessage(deprecatedCipherSuite).isTrue(); } /** @@ -242,7 +242,7 @@ void testRfc10015Section5_1_DhDepreacted(final String deprecatedCipherSuite) { "TLS_ECDH_RSA_WITH_CAMELLIA_256_GCM_SHA384", // RFC6367 }) void testRfc10015Section5_2_EcdhDiscouraged(final String discouragedCipherSuite) { - Assertions.assertTrue(TlsCiphers.isWeak(discouragedCipherSuite), discouragedCipherSuite); + Assertions.assertThat(TlsCiphers.isWeak(discouragedCipherSuite)).withFailMessage(discouragedCipherSuite).isTrue(); } /** @@ -323,7 +323,7 @@ void testRfc10015Section5_2_EcdhDiscouraged(final String discouragedCipherSuite) "TLS_PSK_DHE_WITH_AES_256_CCM_8", // RFC6655 }) void testRfc10015Section5_3_DheDeprecated(final String deprecatedCipherSuite) { - Assertions.assertTrue(TlsCiphers.isWeak(deprecatedCipherSuite), deprecatedCipherSuite); + Assertions.assertThat(TlsCiphers.isWeak(deprecatedCipherSuite)).withFailMessage(deprecatedCipherSuite).isTrue(); } /** @@ -387,7 +387,7 @@ void testRfc10015Section5_3_DheDeprecated(final String deprecatedCipherSuite) { "TLS_RSA_PSK_WITH_CHACHA20_POLY1305_SHA256", // RFC7905 }) void testRfc10015Section5_4_RsaDeprecated(final String deprecatedCipherSuite) { - Assertions.assertTrue(TlsCiphers.isWeak(deprecatedCipherSuite), deprecatedCipherSuite); + Assertions.assertThat(TlsCiphers.isWeak(deprecatedCipherSuite)).withFailMessage(deprecatedCipherSuite).isTrue(); } @ParameterizedTest @@ -411,7 +411,7 @@ void testRfc10015Section5_4_RsaDeprecated(final String deprecatedCipherSuite) { "TLS_ECDHE_PSK_WITH_AES_128_CCM_SHA256", // RFC8442 }) void testStrongCipherSuites(final String strongCipherSuite) { - Assertions.assertFalse(TlsCiphers.isWeak(strongCipherSuite), strongCipherSuite); + Assertions.assertThat(TlsCiphers.isWeak(strongCipherSuite)).withFailMessage(strongCipherSuite).isFalse(); } @ParameterizedTest @@ -433,7 +433,7 @@ void testStrongCipherSuites(final String strongCipherSuite) { "SSL_RSA_EXPORT_WITH_RC2_CBC_40_MD5" }) void testWeakCiphersDisabledByDefault(final String weakCiphersSuite) { - Assertions.assertTrue(TlsCiphers.isWeak(weakCiphersSuite), weakCiphersSuite); + Assertions.assertThat(TlsCiphers.isWeak(weakCiphersSuite)).withFailMessage(weakCiphersSuite).isTrue(); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/structured/TestStructuredFieldConformance.java b/httpcore5/src/test/java/org/apache/hc/core5/http/structured/TestStructuredFieldConformance.java index 9f13c22724..b21ac1ae3d 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/structured/TestStructuredFieldConformance.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/structured/TestStructuredFieldConformance.java @@ -40,7 +40,7 @@ import java.util.Map; import org.apache.hc.core5.http.ParseException; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; /** @@ -93,7 +93,7 @@ void testOfficialCorpus() throws Exception { for (final String file : SERIALIZATION_FILES) { count += runFile(file, false, failures); } - Assertions.assertEquals(2135, count, "Unexpected number of HTTPWG test cases"); + Assertions.assertThat(count).withFailMessage("Unexpected number of HTTPWG test cases").isEqualTo(2135); if (!failures.isEmpty()) { Assertions.fail(failures.size() + " HTTPWG conformance failure(s):\n" + String.join("\n", failures)); } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/structured/TestStructuredFieldParser.java b/httpcore5/src/test/java/org/apache/hc/core5/http/structured/TestStructuredFieldParser.java index 4c1e3fb4a4..9575191197 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/structured/TestStructuredFieldParser.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/structured/TestStructuredFieldParser.java @@ -33,7 +33,7 @@ import org.apache.hc.core5.http.ParseException; import org.apache.hc.core5.util.Tokenizer; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class TestStructuredFieldParser { @@ -50,53 +50,54 @@ void testAllBareItemTypes() throws Exception { assertItem("%\"f%c3%bc%c3%bc\"", StructuredFieldType.DISPLAY_STRING, "füü"); final StructuredFieldBareItem bytes = StructuredFieldParser.parseItem(":aGVsbG8=:").getBareItem(); - Assertions.assertEquals(StructuredFieldType.BYTE_SEQUENCE, bytes.getType()); - Assertions.assertArrayEquals("hello".getBytes(StandardCharsets.US_ASCII), bytes.getByteSequenceValue()); + Assertions.assertThat(bytes.getType()).isEqualTo(StructuredFieldType.BYTE_SEQUENCE); + Assertions.assertThat(bytes.getByteSequenceValue()) + .containsExactly("hello".getBytes(StandardCharsets.US_ASCII)); } @Test void testListAndInnerList() throws Exception { final StructuredFieldList list = StructuredFieldParser.parseList( "sugar, (tea \"with milk\";q=0.7);fresh, rum;proof=40"); - Assertions.assertEquals(3, list.size()); - Assertions.assertEquals("sugar", ((StructuredFieldItem) list.get(0)).getBareItem().getTextValue()); + Assertions.assertThat(list.size()).isEqualTo(3); + Assertions.assertThat(((StructuredFieldItem) list.get(0)).getBareItem().getTextValue()).isEqualTo("sugar"); final StructuredFieldInnerList inner = (StructuredFieldInnerList) list.get(1); - Assertions.assertEquals(2, inner.size()); - Assertions.assertEquals(new BigDecimal("0.7"), inner.get(1).getParameters().get("q").getDecimalValue()); - Assertions.assertTrue(inner.getParameters().get("fresh").getBooleanValue()); - Assertions.assertEquals(40L, ((StructuredFieldItem) list.get(2)).getParameters().get("proof").getLongValue()); + Assertions.assertThat(inner.size()).isEqualTo(2); + Assertions.assertThat(inner.get(1).getParameters().get("q").getDecimalValue()).isEqualTo(new BigDecimal("0.7")); + Assertions.assertThat(inner.getParameters().get("fresh").getBooleanValue()).isTrue(); + Assertions.assertThat(((StructuredFieldItem) list.get(2)).getParameters().get("proof").getLongValue()).isEqualTo(40L); } @Test void testDictionaryAndDuplicateReplacement() throws Exception { final StructuredFieldDictionary dictionary = StructuredFieldParser.parseDictionary( "a=?0, b, c;foo=bar, a=(1 2);valid"); - Assertions.assertEquals(3, dictionary.size()); - Assertions.assertEquals("a", dictionary.getName(0)); - Assertions.assertTrue(dictionary.get("a") instanceof StructuredFieldInnerList); - Assertions.assertTrue(((StructuredFieldItem) dictionary.get("b")).getBareItem().getBooleanValue()); - Assertions.assertEquals("bar", ((StructuredFieldItem) dictionary.get("c")) - .getParameters().get("foo").getTextValue()); + Assertions.assertThat(dictionary.size()).isEqualTo(3); + Assertions.assertThat(dictionary.getName(0)).isEqualTo("a"); + Assertions.assertThat(dictionary.get("a") instanceof StructuredFieldInnerList).isTrue(); + Assertions.assertThat(((StructuredFieldItem) dictionary.get("b")).getBareItem().getBooleanValue()).isTrue(); + Assertions.assertThat(((StructuredFieldItem) dictionary.get("c")) + .getParameters().get("foo").getTextValue()).isEqualTo("bar"); } @Test void testDuplicateParameterReplacementPreservesPosition() throws Exception { final StructuredFieldParameters parameters = StructuredFieldParser.parseItem("token;a=1;b=2;a=3") .getParameters(); - Assertions.assertEquals(2, parameters.size()); - Assertions.assertEquals("a", parameters.getName(0)); - Assertions.assertEquals(3L, parameters.get("a").getLongValue()); + Assertions.assertThat(parameters.size()).isEqualTo(2); + Assertions.assertThat(parameters.getName(0)).isEqualTo("a"); + Assertions.assertThat(parameters.get("a").getLongValue()).isEqualTo(3L); } @Test void testMultipleFieldLines() throws Exception { final StructuredFieldList list = StructuredFieldParser.parseListLines(Arrays.asList("one, two", "three")); - Assertions.assertEquals(3, list.size()); - Assertions.assertEquals("one, two, three", StructuredFieldSerializer.serializeList(list)); + Assertions.assertThat(list.size()).isEqualTo(3); + Assertions.assertThat(StructuredFieldSerializer.serializeList(list)).isEqualTo("one, two, three"); final StructuredFieldDictionary dictionary = StructuredFieldParser.parseDictionaryLines( Arrays.asList("a=1", "b=2")); - Assertions.assertEquals("a=1, b=2", StructuredFieldSerializer.serializeDictionary(dictionary)); + Assertions.assertThat(StructuredFieldSerializer.serializeDictionary(dictionary)).isEqualTo("a=1, b=2"); } @Test @@ -104,8 +105,8 @@ void testTokenizerCursorBoundsAndPosition() throws Exception { final String input = "xx 42 yy"; final Tokenizer.Cursor cursor = new Tokenizer.Cursor(2, 6); final StructuredFieldItem item = StructuredFieldParser.parseItem(input, cursor); - Assertions.assertEquals(42L, item.getBareItem().getLongValue()); - Assertions.assertEquals(6, cursor.getPos()); + Assertions.assertThat(item.getBareItem().getLongValue()).isEqualTo(42L); + Assertions.assertThat(cursor.getPos()).isEqualTo(6); } @Test @@ -117,19 +118,19 @@ void testRfcMinimumContainerSizes() throws Exception { } listValue.append(i); } - Assertions.assertEquals(1024, StructuredFieldParser.parseList(listValue).size()); + Assertions.assertThat(StructuredFieldParser.parseList(listValue).size()).isEqualTo(1024); final StringBuilder parameters = new StringBuilder("token"); for (int i = 0; i < 256; i++) { parameters.append(";p").append(i); } - Assertions.assertEquals(256, StructuredFieldParser.parseItem(parameters).getParameters().size()); + Assertions.assertThat(StructuredFieldParser.parseItem(parameters).getParameters().size()).isEqualTo(256); } private static void assertItem( final String encoded, final StructuredFieldType type, final Object expected) throws ParseException { final StructuredFieldBareItem item = StructuredFieldParser.parseItem(encoded).getBareItem(); - Assertions.assertEquals(type, item.getType()); - Assertions.assertEquals(expected, item.getValue()); + Assertions.assertThat(item.getType()).isEqualTo(type); + Assertions.assertThat(item.getValue()).isEqualTo(expected); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/structured/TestStructuredFieldRealWorldHeaders.java b/httpcore5/src/test/java/org/apache/hc/core5/http/structured/TestStructuredFieldRealWorldHeaders.java index a0a7772d97..de1b8a9737 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/structured/TestStructuredFieldRealWorldHeaders.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/structured/TestStructuredFieldRealWorldHeaders.java @@ -32,7 +32,7 @@ import org.apache.hc.core5.http.Header; import org.apache.hc.core5.http.message.BasicHeader; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class TestStructuredFieldRealWorldHeaders { @@ -41,8 +41,8 @@ class TestStructuredFieldRealWorldHeaders { void testRfc9218Priority() throws Exception { final StructuredFieldDictionary priority = StructuredFieldHeaders.parseDictionary( new BasicHeader("Priority", "u=0, i")); - Assertions.assertEquals(0L, item(priority, "u").getBareItem().getLongValue()); - Assertions.assertTrue(item(priority, "i").getBareItem().getBooleanValue()); + Assertions.assertThat(item(priority, "u").getBareItem().getLongValue()).isEqualTo(0L); + Assertions.assertThat(item(priority, "i").getBareItem().getBooleanValue()).isTrue(); } @Test @@ -55,7 +55,7 @@ void testRfc9530ContentDigest() throws Exception { final Header header = StructuredFieldHeaders.format("Content-Digest", value); final byte[] parsed = item(StructuredFieldHeaders.parseDictionary(header), "sha-256") .getBareItem().getByteSequenceValue(); - Assertions.assertTrue(MessageDigest.isEqual(digest, parsed)); + Assertions.assertThat(MessageDigest.isEqual(digest, parsed)).isTrue(); } @Test @@ -63,9 +63,9 @@ void testRfc9211CacheStatus() throws Exception { final StructuredFieldList status = StructuredFieldHeaders.parseList( new BasicHeader("Cache-Status", "ExampleCache;hit;ttl=376")); final StructuredFieldItem cache = (StructuredFieldItem) status.get(0); - Assertions.assertEquals("ExampleCache", cache.getBareItem().getTextValue()); - Assertions.assertTrue(cache.getParameters().get("hit").getBooleanValue()); - Assertions.assertEquals(376L, cache.getParameters().get("ttl").getLongValue()); + Assertions.assertThat(cache.getBareItem().getTextValue()).isEqualTo("ExampleCache"); + Assertions.assertThat(cache.getParameters().get("hit").getBooleanValue()).isTrue(); + Assertions.assertThat(cache.getParameters().get("ttl").getLongValue()).isEqualTo(376L); } @Test @@ -73,10 +73,8 @@ void testRfc9209ProxyStatus() throws Exception { final StructuredFieldList status = StructuredFieldHeaders.parseList(new BasicHeader( "Proxy-Status", "ExampleCDN;error=connection_timeout;received-status=504")); final StructuredFieldItem proxy = (StructuredFieldItem) status.get(0); - Assertions.assertEquals("connection_timeout", - proxy.getParameters().get("error").getTextValue()); - Assertions.assertEquals(504L, - proxy.getParameters().get("received-status").getLongValue()); + Assertions.assertThat(proxy.getParameters().get("error").getTextValue()).isEqualTo("connection_timeout"); + Assertions.assertThat(proxy.getParameters().get("received-status").getLongValue()).isEqualTo(504L); } @Test @@ -85,12 +83,10 @@ void testRfc9421SignatureInput() throws Exception { "Signature-Input", "sig1=(\"@method\" \"@target-uri\" \"content-digest\")" + ";created=1618884475;keyid=\"test-key-rsa-pss\"")); final StructuredFieldInnerList signature = (StructuredFieldInnerList) signatureInput.get("sig1"); - Assertions.assertEquals(3, signature.size()); - Assertions.assertEquals("@method", signature.get(0).getBareItem().getTextValue()); - Assertions.assertEquals(1618884475L, - signature.getParameters().get("created").getLongValue()); - Assertions.assertEquals("test-key-rsa-pss", - signature.getParameters().get("keyid").getTextValue()); + Assertions.assertThat(signature.size()).isEqualTo(3); + Assertions.assertThat(signature.get(0).getBareItem().getTextValue()).isEqualTo("@method"); + Assertions.assertThat(signature.getParameters().get("created").getLongValue()).isEqualTo(1618884475L); + Assertions.assertThat(signature.getParameters().get("keyid").getTextValue()).isEqualTo("test-key-rsa-pss"); } private static StructuredFieldItem item(final StructuredFieldDictionary dictionary, final String key) { diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/structured/TestStructuredFieldSerializer.java b/httpcore5/src/test/java/org/apache/hc/core5/http/structured/TestStructuredFieldSerializer.java index be02880a2b..0df347eea9 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/structured/TestStructuredFieldSerializer.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/structured/TestStructuredFieldSerializer.java @@ -36,24 +36,23 @@ import org.apache.hc.core5.http.message.BufferedHeader; import org.apache.hc.core5.http.message.HeaderGroup; import org.apache.hc.core5.util.CharArrayBuffer; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class TestStructuredFieldSerializer { @Test void testCanonicalNumbersAndDisplayString() { - Assertions.assertEquals("0.0", bare(StructuredFieldBareItem.ofDecimal(new BigDecimal("-0.0001")))); - Assertions.assertEquals("1.234", bare(StructuredFieldBareItem.ofDecimal(new BigDecimal("1.2344")))); - Assertions.assertEquals("1.234", bare(StructuredFieldBareItem.ofDecimal(new BigDecimal("1.2345")))); - Assertions.assertEquals("1.236", bare(StructuredFieldBareItem.ofDecimal(new BigDecimal("1.2355")))); - Assertions.assertEquals("0.002", bare(StructuredFieldBareItem.ofDecimal(new BigDecimal("0.0015")))); - Assertions.assertEquals("0.002", bare(StructuredFieldBareItem.ofDecimal(new BigDecimal("0.0025")))); - Assertions.assertEquals("-0.002", bare(StructuredFieldBareItem.ofDecimal(new BigDecimal("-0.0015")))); - Assertions.assertEquals("-0.002", bare(StructuredFieldBareItem.ofDecimal(new BigDecimal("-0.0025")))); - Assertions.assertEquals("10.0", bare(StructuredFieldBareItem.ofDecimal(new BigDecimal("9.9995")))); - Assertions.assertEquals("%\"F%c3%bc%c3%9fe %22%25%22\"", - bare(StructuredFieldBareItem.ofDisplayString("Füße \"%\""))); + Assertions.assertThat(bare(StructuredFieldBareItem.ofDecimal(new BigDecimal("-0.0001")))).isEqualTo("0.0"); + Assertions.assertThat(bare(StructuredFieldBareItem.ofDecimal(new BigDecimal("1.2344")))).isEqualTo("1.234"); + Assertions.assertThat(bare(StructuredFieldBareItem.ofDecimal(new BigDecimal("1.2345")))).isEqualTo("1.234"); + Assertions.assertThat(bare(StructuredFieldBareItem.ofDecimal(new BigDecimal("1.2355")))).isEqualTo("1.236"); + Assertions.assertThat(bare(StructuredFieldBareItem.ofDecimal(new BigDecimal("0.0015")))).isEqualTo("0.002"); + Assertions.assertThat(bare(StructuredFieldBareItem.ofDecimal(new BigDecimal("0.0025")))).isEqualTo("0.002"); + Assertions.assertThat(bare(StructuredFieldBareItem.ofDecimal(new BigDecimal("-0.0015")))).isEqualTo("-0.002"); + Assertions.assertThat(bare(StructuredFieldBareItem.ofDecimal(new BigDecimal("-0.0025")))).isEqualTo("-0.002"); + Assertions.assertThat(bare(StructuredFieldBareItem.ofDecimal(new BigDecimal("9.9995")))).isEqualTo("10.0"); + Assertions.assertThat(bare(StructuredFieldBareItem.ofDisplayString("Füße \"%\""))).isEqualTo("%\"F%c3%bc%c3%9fe %22%25%22\""); } @Test @@ -71,20 +70,18 @@ void testCanonicalDictionaryAndParameters() { StructuredFieldItem.of(StructuredFieldBareItem.ofToken("joy")), StructuredFieldItem.of(StructuredFieldBareItem.ofToken("sadness")))) .build(); - Assertions.assertEquals( - "available;valid;cached=?0;ttl=60, rating=1.5, feelings=(joy sadness)", - StructuredFieldSerializer.serializeDictionary(dictionary)); + Assertions.assertThat(StructuredFieldSerializer.serializeDictionary(dictionary)).isEqualTo("available;valid;cached=?0;ttl=60, rating=1.5, feelings=(joy sadness)"); } @Test void testEmptyContainersOmitField() throws Exception { final StructuredFieldList list = StructuredFieldList.of(); final StructuredFieldDictionary dictionary = StructuredFieldDictionary.builder().build(); - Assertions.assertNull(StructuredFieldSerializer.serializeList(list)); - Assertions.assertNull(StructuredFieldSerializer.serializeDictionary(dictionary)); - Assertions.assertNull(StructuredFieldHeaders.format("Example", list)); - Assertions.assertTrue(StructuredFieldParser.parseList("").isEmpty()); - Assertions.assertTrue(StructuredFieldParser.parseDictionary("").isEmpty()); + Assertions.assertThat(StructuredFieldSerializer.serializeList(list)).isNull(); + Assertions.assertThat(StructuredFieldSerializer.serializeDictionary(dictionary)).isNull(); + Assertions.assertThat(StructuredFieldHeaders.format("Example", list)).isNull(); + Assertions.assertThat(StructuredFieldParser.parseList("").isEmpty()).isTrue(); + Assertions.assertThat(StructuredFieldParser.parseDictionary("").isEmpty()).isTrue(); } @Test @@ -93,12 +90,12 @@ void testMessageHeadersCombineLinesCaseInsensitively() throws Exception { headers.addHeader(new BasicHeader("Example", "one, two")); headers.addHeader(new BasicHeader("EXAMPLE", "three")); final StructuredFieldList value = StructuredFieldHeaders.parseList(headers, "example"); - Assertions.assertEquals(3, value.size()); + Assertions.assertThat(value.size()).isEqualTo(3); final Header formatted = StructuredFieldHeaders.format("Example", value); - Assertions.assertNotNull(formatted); - Assertions.assertTrue(formatted instanceof BufferedHeader); - Assertions.assertEquals("one, two, three", formatted.getValue()); - Assertions.assertEquals(value, StructuredFieldHeaders.parseList(formatted)); + Assertions.assertThat(formatted).isNotNull(); + Assertions.assertThat(formatted instanceof BufferedHeader).isTrue(); + Assertions.assertThat(formatted.getValue()).isEqualTo("one, two, three"); + Assertions.assertThat(StructuredFieldHeaders.parseList(formatted)).isEqualTo(value); } @Test @@ -107,32 +104,31 @@ void testMessageHeadersCombineFormattedHeaderLines() throws Exception { headers.addHeader(bufferedHeader("Example: one, two")); headers.addHeader(bufferedHeader("Example: three")); final StructuredFieldList value = StructuredFieldHeaders.parseList(headers, "example"); - Assertions.assertEquals(3, value.size()); - Assertions.assertEquals("one, two, three", - StructuredFieldHeaders.format("Example", value).getValue()); + Assertions.assertThat(value.size()).isEqualTo(3); + Assertions.assertThat(StructuredFieldHeaders.format("Example", value).getValue()).isEqualTo("one, two, three"); } @Test void testMessageHeadersItemMustNotSpanFieldLines() throws Exception { final HeaderGroup single = new HeaderGroup(); single.addHeader(new BasicHeader("Example", "10")); - Assertions.assertEquals( - StructuredFieldHeaders.parseItem(new BasicHeader("Example", "10")), - StructuredFieldHeaders.parseItem(single, "example")); + Assertions.assertThat(StructuredFieldHeaders.parseItem(single, "example")).isEqualTo(StructuredFieldHeaders.parseItem(new BasicHeader("Example", "10"))); final HeaderGroup multiple = new HeaderGroup(); multiple.addHeader(new BasicHeader("Example", "10")); multiple.addHeader(new BasicHeader("Example", "20")); - Assertions.assertThrows(ParseException.class, - () -> StructuredFieldHeaders.parseItem(multiple, "example")); + Assertions.assertThatThrownBy(() -> + StructuredFieldHeaders.parseItem(multiple, "example")) + .isInstanceOf(ParseException.class); } @Test void testMessageHeadersListMembersMustBeCommaSeparated() { final HeaderGroup headers = new HeaderGroup(); headers.addHeader(new BasicHeader("Example", "a b")); - Assertions.assertThrows(ParseException.class, - () -> StructuredFieldHeaders.parseList(headers, "example")); + Assertions.assertThatThrownBy(() -> + StructuredFieldHeaders.parseList(headers, "example")) + .isInstanceOf(ParseException.class); } private static BufferedHeader bufferedHeader(final String line) { @@ -149,7 +145,7 @@ void testSerializeIntoExistingBuffer() { .put("u", StructuredFieldItem.ofInteger(0)) .put("i", StructuredFieldItem.ofBoolean(true)) .build()); - Assertions.assertEquals("Priority: u=0, i", buffer.toString()); + Assertions.assertThat(buffer.toString()).isEqualTo("Priority: u=0, i"); } @Test @@ -157,32 +153,41 @@ void testImmutabilityAndValueSemantics() { final byte[] bytes = {1, 2, 3}; final StructuredFieldBareItem item = StructuredFieldBareItem.ofByteSequence(bytes); bytes[0] = 9; - Assertions.assertArrayEquals(new byte[] {1, 2, 3}, item.getByteSequenceValue()); + Assertions.assertThat(item.getByteSequenceValue()) + .containsExactly(new byte[]{1, 2, 3}); final byte[] returned = item.getByteSequenceValue(); returned[0] = 8; - Assertions.assertArrayEquals(new byte[] {1, 2, 3}, item.getByteSequenceValue()); + Assertions.assertThat(item.getByteSequenceValue()) + .containsExactly(new byte[]{1, 2, 3}); final StructuredFieldList list = StructuredFieldList.of( StructuredFieldItem.of(StructuredFieldBareItem.ofInteger(1))); - Assertions.assertThrows(UnsupportedOperationException.class, - () -> list.getMembers().add(StructuredFieldItem.of(StructuredFieldBareItem.ofInteger(2)))); - Assertions.assertEquals(list, StructuredFieldList.of(Arrays.asList(list.get(0)))); + Assertions.assertThatThrownBy(() -> + list.getMembers().add(StructuredFieldItem.of(StructuredFieldBareItem.ofInteger(2)))) + .isInstanceOf(UnsupportedOperationException.class); + Assertions.assertThat(StructuredFieldList.of(Arrays.asList(list.get(0)))).isEqualTo(list); } @Test void testValidationAtConstructionBoundary() { - Assertions.assertThrows(IllegalArgumentException.class, - () -> StructuredFieldBareItem.ofInteger(1000000000000000L)); - Assertions.assertThrows(IllegalArgumentException.class, - () -> StructuredFieldBareItem.ofDecimal(new BigDecimal("999999999999.9995"))); - Assertions.assertThrows(IllegalArgumentException.class, - () -> StructuredFieldBareItem.ofString("é")); - Assertions.assertThrows(IllegalArgumentException.class, - () -> StructuredFieldBareItem.ofToken("1token")); - Assertions.assertThrows(IllegalArgumentException.class, - () -> StructuredFieldParameters.builder().putBoolean("Upper", true)); - Assertions.assertThrows(IllegalArgumentException.class, - () -> StructuredFieldBareItem.ofDisplayString("\ud800")); + Assertions.assertThatThrownBy(() -> + StructuredFieldBareItem.ofInteger(1000000000000000L)) + .isInstanceOf(IllegalArgumentException.class); + Assertions.assertThatThrownBy(() -> + StructuredFieldBareItem.ofDecimal(new BigDecimal("999999999999.9995"))) + .isInstanceOf(IllegalArgumentException.class); + Assertions.assertThatThrownBy(() -> + StructuredFieldBareItem.ofString("é")) + .isInstanceOf(IllegalArgumentException.class); + Assertions.assertThatThrownBy(() -> + StructuredFieldBareItem.ofToken("1token")) + .isInstanceOf(IllegalArgumentException.class); + Assertions.assertThatThrownBy(() -> + StructuredFieldParameters.builder().putBoolean("Upper", true)) + .isInstanceOf(IllegalArgumentException.class); + Assertions.assertThatThrownBy(() -> + StructuredFieldBareItem.ofDisplayString("\ud800")) + .isInstanceOf(IllegalArgumentException.class); } private static String bare(final StructuredFieldBareItem item) { diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/structured/TestStructuredFieldStrictness.java b/httpcore5/src/test/java/org/apache/hc/core5/http/structured/TestStructuredFieldStrictness.java index c8484e4168..e05de3f76a 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/structured/TestStructuredFieldStrictness.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/structured/TestStructuredFieldStrictness.java @@ -28,7 +28,7 @@ package org.apache.hc.core5.http.structured; import org.apache.hc.core5.http.ParseException; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; /** @@ -50,25 +50,24 @@ void testInvalidContainers() { @Test void testStrictByteSequences() throws Exception { - Assertions.assertEquals(5, - StructuredFieldParser.parseItem(":aGVsbG8:").getBareItem().getByteSequenceValue().length); - Assertions.assertEquals(":YQ==:", StructuredFieldSerializer.serializeItem( - StructuredFieldParser.parseItem(":YQ=:"))); + Assertions.assertThat(StructuredFieldParser.parseItem(":aGVsbG8:").getBareItem().getByteSequenceValue().length).isEqualTo(5); + Assertions.assertThat(StructuredFieldSerializer.serializeItem( + StructuredFieldParser.parseItem(":YQ=:"))).isEqualTo(":YQ==:"); assertItemFails(":=aGVsbG8=:", ":a=GVsbG8=:", ":aGVsb G8=:", ":aGVsbG8=", ":_-Ah:", ":", ":YQ===:"); final StructuredFieldItem nonZeroPadBits = StructuredFieldParser.parseItem(":iZ==:"); - Assertions.assertEquals(":iQ==:", StructuredFieldSerializer.serializeItem(nonZeroPadBits)); + Assertions.assertThat(StructuredFieldSerializer.serializeItem(nonZeroPadBits)).isEqualTo(":iQ==:"); } @Test void testStrictDisplayStrings() throws Exception { final StructuredFieldItem item = StructuredFieldParser.parseItem("%\"foo %22bar%22 \\ baz\""); - Assertions.assertEquals("foo \"bar\" \\ baz", item.getBareItem().getTextValue()); - Assertions.assertEquals("%\"foo %22bar%22 \\ baz\"", StructuredFieldSerializer.serializeItem(item)); + Assertions.assertThat(item.getBareItem().getTextValue()).isEqualTo("foo \"bar\" \\ baz"); + Assertions.assertThat(StructuredFieldSerializer.serializeItem(item)).isEqualTo("%\"foo %22bar%22 \\ baz\""); final StructuredFieldItem overEncoded = StructuredFieldParser.parseItem("%\"%61\""); - Assertions.assertEquals("%\"a\"", StructuredFieldSerializer.serializeItem(overEncoded)); + Assertions.assertThat(StructuredFieldSerializer.serializeItem(overEncoded)).isEqualTo("%\"a\""); assertItemFails("%\"f%C3%BC\"", "%\"füü\"", "%\"%c3%28\"", "%\"%a0%a1\"", "%\"%e2%28%a1\"", "%\"%f0%28%8c%28\"", "%\"%g0\"", "%\"%\"", "%foo"); @@ -76,31 +75,38 @@ void testStrictDisplayStrings() throws Exception { @Test void testOnlySpacesAreAllowedAtTopLevel() throws Exception { - Assertions.assertEquals(1L, StructuredFieldParser.parseItem(" 1 ").getBareItem().getLongValue()); + Assertions.assertThat(StructuredFieldParser.parseItem(" 1 ").getBareItem().getLongValue()).isEqualTo(1L); assertItemFails(" \t 1", "1 \t "); } @Test void testUnicodeDigitsAreNotRfcDigits() { - Assertions.assertThrows(IllegalArgumentException.class, - () -> StructuredFieldParameters.builder().putBoolean("a١", true)); + Assertions.assertThatThrownBy(() -> + StructuredFieldParameters.builder().putBoolean("a١", true)) + .isInstanceOf(IllegalArgumentException.class); } private static void assertItemFails(final String... values) { for (final String value : values) { - Assertions.assertThrows(ParseException.class, () -> StructuredFieldParser.parseItem(value), value); + Assertions.assertThatThrownBy(() -> + StructuredFieldParser.parseItem(value)) + .withFailMessage(value).isInstanceOf(ParseException.class); } } private static void assertListFails(final String... values) { for (final String value : values) { - Assertions.assertThrows(ParseException.class, () -> StructuredFieldParser.parseList(value), value); + Assertions.assertThatThrownBy(() -> + StructuredFieldParser.parseList(value)) + .withFailMessage(value).isInstanceOf(ParseException.class); } } private static void assertDictionaryFails(final String... values) { for (final String value : values) { - Assertions.assertThrows(ParseException.class, () -> StructuredFieldParser.parseDictionary(value), value); + Assertions.assertThatThrownBy(() -> + StructuredFieldParser.parseDictionary(value)) + .withFailMessage(value).isInstanceOf(ParseException.class); } } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/support/TestBasicMessageBuilders.java b/httpcore5/src/test/java/org/apache/hc/core5/http/support/TestBasicMessageBuilders.java index aad3194334..425065b34d 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/support/TestBasicMessageBuilders.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/support/TestBasicMessageBuilders.java @@ -27,14 +27,10 @@ package org.apache.hc.core5.http.support; -import static org.junit.jupiter.api.Assertions.assertEquals; - import java.net.URI; import java.nio.charset.StandardCharsets; import java.util.Arrays; -import org.apache.hc.core5.http.HeaderMatcher; -import org.apache.hc.core5.http.HeadersMatcher; import org.apache.hc.core5.http.HttpRequest; import org.apache.hc.core5.http.HttpResponse; import org.apache.hc.core5.http.HttpVersion; @@ -44,7 +40,7 @@ import org.apache.hc.core5.http.message.BasicHttpResponse; import org.apache.hc.core5.http.message.BasicNameValuePair; import org.apache.hc.core5.net.URIAuthority; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; /** @@ -55,153 +51,204 @@ class TestBasicMessageBuilders { @Test void testResponseBasics() { final BasicResponseBuilder builder = BasicResponseBuilder.create(200); - Assertions.assertEquals(200, builder.getStatus()); - Assertions.assertNull(builder.getHeaders()); - Assertions.assertNull(builder.getVersion()); + Assertions.assertThat(builder.getStatus()).isEqualTo(200); + Assertions.assertThat(builder.getHeaders()).isNull(); + Assertions.assertThat(builder.getVersion()).isNull(); final BasicHttpResponse r1 = builder.build(); - Assertions.assertNotNull(r1); - Assertions.assertEquals(200, r1.getCode()); - Assertions.assertNull(r1.getVersion()); + Assertions.assertThat(r1).isNotNull(); + Assertions.assertThat(r1.getCode()).isEqualTo(200); + Assertions.assertThat(r1.getVersion()).isNull(); builder.setStatus(500); builder.setVersion(HttpVersion.HTTP_1_0); - Assertions.assertEquals(500, builder.getStatus()); - Assertions.assertEquals(HttpVersion.HTTP_1_0, builder.getVersion()); + Assertions.assertThat(builder.getStatus()).isEqualTo(500); + Assertions.assertThat(builder.getVersion()).isEqualTo(HttpVersion.HTTP_1_0); final BasicHttpResponse r2 = builder.build(); - Assertions.assertEquals(500, r2.getCode()); - Assertions.assertEquals(HttpVersion.HTTP_1_0, r2.getVersion()); + Assertions.assertThat(r2.getCode()).isEqualTo(500); + Assertions.assertThat(r2.getVersion()).isEqualTo(HttpVersion.HTTP_1_0); builder.addHeader("h1", "v1"); builder.addHeader("h1", "v2"); builder.addHeader("h2", "v2"); - HeadersMatcher.assertSame(builder.getHeaders(), - new BasicHeader("h1", "v1"), new BasicHeader("h1", "v2"), new BasicHeader("h2", "v2")); - HeadersMatcher.assertSame(builder.getHeaders("h1"), - new BasicHeader("h1", "v1"), new BasicHeader("h1", "v2")); - HeaderMatcher.assertSame(builder.getFirstHeader("h1"), "h1", "v1"); - HeaderMatcher.assertSame(builder.getLastHeader("h1"), "h1", "v2"); + Assertions.assertThat(builder.getHeaders()) + .extracting(header -> Assertions.tuple(header.getName(), header.getValue())) + .isEqualTo(Arrays.asList(Assertions.tuple("h1", "v1"), Assertions.tuple("h1", "v2"), Assertions.tuple("h2", "v2"))); + Assertions.assertThat(builder.getHeaders("h1")) + .extracting(header -> Assertions.tuple(header.getName(), header.getValue())) + .isEqualTo(Arrays.asList(Assertions.tuple("h1", "v1"), Assertions.tuple("h1", "v2"))); + Assertions.assertThat(builder.getFirstHeader("h1")) + .extracting(header -> Assertions.tuple(header.getName(), header.getValue())) + .isEqualTo(Assertions.tuple("h1", "v1")); + Assertions.assertThat(builder.getLastHeader("h1")) + .extracting(header -> Assertions.tuple(header.getName(), header.getValue())) + .isEqualTo(Assertions.tuple("h1", "v2")); final BasicHttpResponse r3 = builder.build(); - HeadersMatcher.assertSame(r3.getHeaders(), - new BasicHeader("h1", "v1"), new BasicHeader("h1", "v2"), new BasicHeader("h2", "v2")); - HeadersMatcher.assertSame(r3.getHeaders("h1"), - new BasicHeader("h1", "v1"), new BasicHeader("h1", "v2")); - HeaderMatcher.assertSame(r3.getFirstHeader("h1"), "h1", "v1"); - HeaderMatcher.assertSame(r3.getLastHeader("h1"), "h1", "v2"); + Assertions.assertThat(r3.getHeaders()) + .extracting(header -> Assertions.tuple(header.getName(), header.getValue())) + .isEqualTo(Arrays.asList(Assertions.tuple("h1", "v1"), Assertions.tuple("h1", "v2"), Assertions.tuple("h2", "v2"))); + Assertions.assertThat(r3.getHeaders("h1")) + .extracting(header -> Assertions.tuple(header.getName(), header.getValue())) + .isEqualTo(Arrays.asList(Assertions.tuple("h1", "v1"), Assertions.tuple("h1", "v2"))); + Assertions.assertThat(r3.getFirstHeader("h1")) + .extracting(header -> Assertions.tuple(header.getName(), header.getValue())) + .isEqualTo(Assertions.tuple("h1", "v1")); + Assertions.assertThat(r3.getLastHeader("h1")) + .extracting(header -> Assertions.tuple(header.getName(), header.getValue())) + .isEqualTo(Assertions.tuple("h1", "v2")); builder.removeHeader(new BasicHeader("h1", "v2")); - HeadersMatcher.assertSame(builder.getHeaders("h1"), new BasicHeader("h1", "v1")); - HeadersMatcher.assertSame(builder.getHeaders(), - new BasicHeader("h1", "v1"), new BasicHeader("h2", "v2")); + Assertions.assertThat(builder.getHeaders("h1")) + .extracting(header -> Assertions.tuple(header.getName(), header.getValue())) + .isEqualTo(Arrays.asList(Assertions.tuple("h1", "v1"))); + Assertions.assertThat(builder.getHeaders()) + .extracting(header -> Assertions.tuple(header.getName(), header.getValue())) + .isEqualTo(Arrays.asList(Assertions.tuple("h1", "v1"), Assertions.tuple("h2", "v2"))); final BasicHttpResponse r4 = builder.build(); - HeadersMatcher.assertSame(r4.getHeaders("h1"), new BasicHeader("h1", "v1")); - HeadersMatcher.assertSame(r4.getHeaders(), - new BasicHeader("h1", "v1"), new BasicHeader("h2", "v2")); + Assertions.assertThat(r4.getHeaders("h1")) + .extracting(header -> Assertions.tuple(header.getName(), header.getValue())) + .isEqualTo(Arrays.asList(Assertions.tuple("h1", "v1"))); + Assertions.assertThat(r4.getHeaders()) + .extracting(header -> Assertions.tuple(header.getName(), header.getValue())) + .isEqualTo(Arrays.asList(Assertions.tuple("h1", "v1"), Assertions.tuple("h2", "v2"))); builder.removeHeaders("h1"); - HeadersMatcher.assertSame(builder.getHeaders("h1")); - HeadersMatcher.assertSame(builder.getHeaders(), new BasicHeader("h2", "v2")); + Assertions.assertThat(builder.getHeaders("h1")) + .extracting(header -> Assertions.tuple(header.getName(), header.getValue())) + .isEqualTo(Arrays.asList()); + Assertions.assertThat(builder.getHeaders()) + .extracting(header -> Assertions.tuple(header.getName(), header.getValue())) + .isEqualTo(Arrays.asList(Assertions.tuple("h2", "v2"))); final BasicHttpResponse r5 = builder.build(); - HeadersMatcher.assertSame(r5.getHeaders("h1")); - HeadersMatcher.assertSame(r5.getHeaders(), new BasicHeader("h2", "v2")); + Assertions.assertThat(r5.getHeaders("h1")) + .extracting(header -> Assertions.tuple(header.getName(), header.getValue())) + .isEqualTo(Arrays.asList()); + Assertions.assertThat(r5.getHeaders()) + .extracting(header -> Assertions.tuple(header.getName(), header.getValue())) + .isEqualTo(Arrays.asList(Assertions.tuple("h2", "v2"))); } @Test void testRequestBasics() throws Exception { final BasicRequestBuilder builder = BasicRequestBuilder.get(); - Assertions.assertEquals(URI.create("/"), builder.getUri()); - Assertions.assertEquals("GET", builder.getMethod()); - Assertions.assertNull(builder.getScheme()); - Assertions.assertNull(builder.getAuthority()); - Assertions.assertNull(builder.getPath()); - Assertions.assertNull(builder.getHeaders()); - Assertions.assertNull(builder.getVersion()); - Assertions.assertNull(builder.getCharset()); - Assertions.assertNull(builder.getParameters()); + Assertions.assertThat(builder.getUri()).isEqualTo(URI.create("/")); + Assertions.assertThat(builder.getMethod()).isEqualTo("GET"); + Assertions.assertThat(builder.getScheme()).isNull(); + Assertions.assertThat(builder.getAuthority()).isNull(); + Assertions.assertThat(builder.getPath()).isNull(); + Assertions.assertThat(builder.getHeaders()).isNull(); + Assertions.assertThat(builder.getVersion()).isNull(); + Assertions.assertThat(builder.getCharset()).isNull(); + Assertions.assertThat(builder.getParameters()).isNull(); final BasicHttpRequest r1 = builder.build(); - Assertions.assertNotNull(r1); - Assertions.assertEquals("GET", r1.getMethod()); - Assertions.assertNull(r1.getScheme()); - Assertions.assertNull(r1.getAuthority()); - Assertions.assertNull(r1.getPath()); - Assertions.assertEquals(URI.create("/"), r1.getUri()); - Assertions.assertNull(r1.getVersion()); + Assertions.assertThat(r1).isNotNull(); + Assertions.assertThat(r1.getMethod()).isEqualTo("GET"); + Assertions.assertThat(r1.getScheme()).isNull(); + Assertions.assertThat(r1.getAuthority()).isNull(); + Assertions.assertThat(r1.getPath()).isNull(); + Assertions.assertThat(r1.getUri()).isEqualTo(URI.create("/")); + Assertions.assertThat(r1.getVersion()).isNull(); builder.setUri(URI.create("http://host:1234/blah?param=value")); builder.setVersion(HttpVersion.HTTP_1_1); - Assertions.assertEquals("http", builder.getScheme()); - Assertions.assertEquals(new URIAuthority("host", 1234), builder.getAuthority()); - Assertions.assertEquals("/blah?param=value", builder.getPath()); - Assertions.assertEquals(URI.create("http://host:1234/blah?param=value"), builder.getUri()); - Assertions.assertEquals(HttpVersion.HTTP_1_1, builder.getVersion()); + Assertions.assertThat(builder.getScheme()).isEqualTo("http"); + Assertions.assertThat(builder.getAuthority()).isEqualTo(new URIAuthority("host", 1234)); + Assertions.assertThat(builder.getPath()).isEqualTo("/blah?param=value"); + Assertions.assertThat(builder.getUri()).isEqualTo(URI.create("http://host:1234/blah?param=value")); + Assertions.assertThat(builder.getVersion()).isEqualTo(HttpVersion.HTTP_1_1); final BasicHttpRequest r2 = builder.build(); - Assertions.assertEquals("GET", r2.getMethod()); - Assertions.assertEquals("http", r2.getScheme()); - Assertions.assertEquals(new URIAuthority("host", 1234), r2.getAuthority()); - Assertions.assertEquals("/blah?param=value", r2.getPath()); - Assertions.assertEquals(URI.create("http://host:1234/blah?param=value"), r2.getUri()); - Assertions.assertEquals(HttpVersion.HTTP_1_1, builder.getVersion()); + Assertions.assertThat(r2.getMethod()).isEqualTo("GET"); + Assertions.assertThat(r2.getScheme()).isEqualTo("http"); + Assertions.assertThat(r2.getAuthority()).isEqualTo(new URIAuthority("host", 1234)); + Assertions.assertThat(r2.getPath()).isEqualTo("/blah?param=value"); + Assertions.assertThat(r2.getUri()).isEqualTo(URI.create("http://host:1234/blah?param=value")); + Assertions.assertThat(builder.getVersion()).isEqualTo(HttpVersion.HTTP_1_1); builder.setCharset(StandardCharsets.US_ASCII); builder.addParameter("param1", "value1"); builder.addParameter("param2", null); builder.addParameters(new BasicNameValuePair("param3", "value3"), new BasicNameValuePair("param4", null)); - Assertions.assertEquals(builder.getParameters(), Arrays.asList( + Assertions.assertThat(Arrays.asList( new BasicNameValuePair("param1", "value1"), new BasicNameValuePair("param2", null), new BasicNameValuePair("param3", "value3"), new BasicNameValuePair("param4", null) - )); - Assertions.assertEquals(URI.create("http://host:1234/blah?param=value"), builder.getUri()); + )).isEqualTo(builder.getParameters()); + Assertions.assertThat(builder.getUri()).isEqualTo(URI.create("http://host:1234/blah?param=value")); final BasicHttpRequest r3 = builder.build(); - Assertions.assertEquals("GET", r3.getMethod()); - Assertions.assertEquals("http", r3.getScheme()); - Assertions.assertEquals(new URIAuthority("host", 1234), r3.getAuthority()); - Assertions.assertEquals("/blah?param=value¶m1=value1¶m2¶m3=value3¶m4", r3.getPath()); - Assertions.assertEquals(URI.create("http://host:1234/blah?param=value¶m1=value1¶m2¶m3=value3¶m4"), - r3.getUri()); + Assertions.assertThat(r3.getMethod()).isEqualTo("GET"); + Assertions.assertThat(r3.getScheme()).isEqualTo("http"); + Assertions.assertThat(r3.getAuthority()).isEqualTo(new URIAuthority("host", 1234)); + Assertions.assertThat(r3.getPath()).isEqualTo("/blah?param=value¶m1=value1¶m2¶m3=value3¶m4"); + Assertions.assertThat(r3.getUri()).isEqualTo(URI.create("http://host:1234/blah?param=value¶m1=value1¶m2¶m3=value3¶m4")); builder.addHeader("h1", "v1"); builder.addHeader("h1", "v2"); builder.addHeader("h2", "v2"); - HeadersMatcher.assertSame(builder.getHeaders(), - new BasicHeader("h1", "v1"), new BasicHeader("h1", "v2"), new BasicHeader("h2", "v2")); - HeadersMatcher.assertSame(builder.getHeaders("h1"), - new BasicHeader("h1", "v1"), new BasicHeader("h1", "v2")); - HeaderMatcher.assertSame(builder.getFirstHeader("h1"), "h1", "v1"); - HeaderMatcher.assertSame(builder.getLastHeader("h1"), "h1", "v2"); + Assertions.assertThat(builder.getHeaders()) + .extracting(header -> Assertions.tuple(header.getName(), header.getValue())) + .isEqualTo(Arrays.asList(Assertions.tuple("h1", "v1"), Assertions.tuple("h1", "v2"), Assertions.tuple("h2", "v2"))); + Assertions.assertThat(builder.getHeaders("h1")) + .extracting(header -> Assertions.tuple(header.getName(), header.getValue())) + .isEqualTo(Arrays.asList(Assertions.tuple("h1", "v1"), Assertions.tuple("h1", "v2"))); + Assertions.assertThat(builder.getFirstHeader("h1")) + .extracting(header -> Assertions.tuple(header.getName(), header.getValue())) + .isEqualTo(Assertions.tuple("h1", "v1")); + Assertions.assertThat(builder.getLastHeader("h1")) + .extracting(header -> Assertions.tuple(header.getName(), header.getValue())) + .isEqualTo(Assertions.tuple("h1", "v2")); final BasicHttpRequest r4 = builder.build(); - HeadersMatcher.assertSame(r4.getHeaders(), - new BasicHeader("h1", "v1"), new BasicHeader("h1", "v2"), new BasicHeader("h2", "v2")); - HeadersMatcher.assertSame(r4.getHeaders("h1"), - new BasicHeader("h1", "v1"), new BasicHeader("h1", "v2")); - HeaderMatcher.assertSame(r4.getFirstHeader("h1"), "h1", "v1"); - HeaderMatcher.assertSame(r4.getLastHeader("h1"), "h1", "v2"); + Assertions.assertThat(r4.getHeaders()) + .extracting(header -> Assertions.tuple(header.getName(), header.getValue())) + .isEqualTo(Arrays.asList(Assertions.tuple("h1", "v1"), Assertions.tuple("h1", "v2"), Assertions.tuple("h2", "v2"))); + Assertions.assertThat(r4.getHeaders("h1")) + .extracting(header -> Assertions.tuple(header.getName(), header.getValue())) + .isEqualTo(Arrays.asList(Assertions.tuple("h1", "v1"), Assertions.tuple("h1", "v2"))); + Assertions.assertThat(r4.getFirstHeader("h1")) + .extracting(header -> Assertions.tuple(header.getName(), header.getValue())) + .isEqualTo(Assertions.tuple("h1", "v1")); + Assertions.assertThat(r4.getLastHeader("h1")) + .extracting(header -> Assertions.tuple(header.getName(), header.getValue())) + .isEqualTo(Assertions.tuple("h1", "v2")); builder.removeHeader(new BasicHeader("h1", "v2")); - HeadersMatcher.assertSame(builder.getHeaders("h1"), new BasicHeader("h1", "v1")); - HeadersMatcher.assertSame(builder.getHeaders(), - new BasicHeader("h1", "v1"), new BasicHeader("h2", "v2")); + Assertions.assertThat(builder.getHeaders("h1")) + .extracting(header -> Assertions.tuple(header.getName(), header.getValue())) + .isEqualTo(Arrays.asList(Assertions.tuple("h1", "v1"))); + Assertions.assertThat(builder.getHeaders()) + .extracting(header -> Assertions.tuple(header.getName(), header.getValue())) + .isEqualTo(Arrays.asList(Assertions.tuple("h1", "v1"), Assertions.tuple("h2", "v2"))); final BasicHttpRequest r5 = builder.build(); - HeadersMatcher.assertSame(r5.getHeaders("h1"), new BasicHeader("h1", "v1")); - HeadersMatcher.assertSame(r5.getHeaders(), - new BasicHeader("h1", "v1"), new BasicHeader("h2", "v2")); + Assertions.assertThat(r5.getHeaders("h1")) + .extracting(header -> Assertions.tuple(header.getName(), header.getValue())) + .isEqualTo(Arrays.asList(Assertions.tuple("h1", "v1"))); + Assertions.assertThat(r5.getHeaders()) + .extracting(header -> Assertions.tuple(header.getName(), header.getValue())) + .isEqualTo(Arrays.asList(Assertions.tuple("h1", "v1"), Assertions.tuple("h2", "v2"))); builder.removeHeaders("h1"); - HeadersMatcher.assertSame(builder.getHeaders("h1")); - HeadersMatcher.assertSame(builder.getHeaders(), new BasicHeader("h2", "v2")); + Assertions.assertThat(builder.getHeaders("h1")) + .extracting(header -> Assertions.tuple(header.getName(), header.getValue())) + .isEqualTo(Arrays.asList()); + Assertions.assertThat(builder.getHeaders()) + .extracting(header -> Assertions.tuple(header.getName(), header.getValue())) + .isEqualTo(Arrays.asList(Assertions.tuple("h2", "v2"))); final BasicHttpRequest r6 = builder.build(); - HeadersMatcher.assertSame(r6.getHeaders("h1")); - HeadersMatcher.assertSame(r6.getHeaders(), new BasicHeader("h2", "v2")); + Assertions.assertThat(r6.getHeaders("h1")) + .extracting(header -> Assertions.tuple(header.getName(), header.getValue())) + .isEqualTo(Arrays.asList()); + Assertions.assertThat(r6.getHeaders()) + .extracting(header -> Assertions.tuple(header.getName(), header.getValue())) + .isEqualTo(Arrays.asList(Assertions.tuple("h2", "v2"))); } @Test @@ -213,10 +260,11 @@ void testResponseCopy() { response.setVersion(HttpVersion.HTTP_2); final BasicResponseBuilder builder = BasicResponseBuilder.copy(response); - Assertions.assertEquals(400, builder.getStatus()); - Assertions.assertEquals(HttpVersion.HTTP_2, builder.getVersion()); - HeadersMatcher.assertSame(builder.getHeaders(), - new BasicHeader("h1", "v1"), new BasicHeader("h1", "v2"), new BasicHeader("h2", "v2")); + Assertions.assertThat(builder.getStatus()).isEqualTo(400); + Assertions.assertThat(builder.getVersion()).isEqualTo(HttpVersion.HTTP_2); + Assertions.assertThat(builder.getHeaders()) + .extracting(header -> Assertions.tuple(header.getName(), header.getValue())) + .isEqualTo(Arrays.asList(Assertions.tuple("h1", "v1"), Assertions.tuple("h1", "v2"), Assertions.tuple("h2", "v2"))); } @Test @@ -228,20 +276,21 @@ void testRequestCopy() { request.setVersion(HttpVersion.HTTP_2); final BasicRequestBuilder builder = BasicRequestBuilder.copy(request); - Assertions.assertEquals("GET", builder.getMethod()); - Assertions.assertEquals("https", builder.getScheme()); - Assertions.assertEquals(new URIAuthority("host", 3456), builder.getAuthority()); - Assertions.assertEquals("/stuff?blah", builder.getPath()); - Assertions.assertEquals(HttpVersion.HTTP_2, builder.getVersion()); - HeadersMatcher.assertSame(builder.getHeaders(), - new BasicHeader("h1", "v1"), new BasicHeader("h1", "v2"), new BasicHeader("h2", "v2")); + Assertions.assertThat(builder.getMethod()).isEqualTo("GET"); + Assertions.assertThat(builder.getScheme()).isEqualTo("https"); + Assertions.assertThat(builder.getAuthority()).isEqualTo(new URIAuthority("host", 3456)); + Assertions.assertThat(builder.getPath()).isEqualTo("/stuff?blah"); + Assertions.assertThat(builder.getVersion()).isEqualTo(HttpVersion.HTTP_2); + Assertions.assertThat(builder.getHeaders()) + .extracting(header -> Assertions.tuple(header.getName(), header.getValue())) + .isEqualTo(Arrays.asList(Assertions.tuple("h1", "v1"), Assertions.tuple("h1", "v2"), Assertions.tuple("h2", "v2"))); } @Test void testIDNIntegration() { final String url = "http://müller.example.com:8080/path"; final HttpRequest request = new BasicHttpRequest(Method.GET, URI.create(url)); - assertEquals(new URIAuthority("xn--mller-kva.example.com", 8080), request.getAuthority()); + Assertions.assertThat(request.getAuthority()).isEqualTo(new URIAuthority("xn--mller-kva.example.com", 8080)); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/http/support/TestExpectSupport.java b/httpcore5/src/test/java/org/apache/hc/core5/http/support/TestExpectSupport.java index 2177a4d7b0..459d105fd1 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/http/support/TestExpectSupport.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/http/support/TestExpectSupport.java @@ -31,80 +31,75 @@ import org.apache.hc.core5.http.HttpVersion; import org.apache.hc.core5.http.ProtocolException; import org.apache.hc.core5.http.impl.BasicEntityDetails; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class TestExpectSupport { @Test void testExpectParsingBasics() throws Exception { - Assertions.assertEquals(Expectation.CONTINUE, - ExpectSupport.parse( + Assertions.assertThat(ExpectSupport.parse( BasicRequestBuilder.post() .addHeader("Expect", "100-continue") .build(), - new BasicEntityDetails(100, ContentType.TEXT_PLAIN))); + new BasicEntityDetails(100, ContentType.TEXT_PLAIN))).isEqualTo(Expectation.CONTINUE); } @Test void testExpectParsingTolerateEmptyTokens() throws Exception { - Assertions.assertEquals(Expectation.CONTINUE, - ExpectSupport.parse( + Assertions.assertThat(ExpectSupport.parse( BasicRequestBuilder.post() .addHeader("Expect", ",,,") .addHeader("Expect", ",100-continue") .addHeader("Expect", ",,,") .build(), - new BasicEntityDetails(100, ContentType.TEXT_PLAIN))); + new BasicEntityDetails(100, ContentType.TEXT_PLAIN))).isEqualTo(Expectation.CONTINUE); } @Test void testExpectParsingMissingEntity() { - Assertions.assertThrows(ProtocolException.class, - () -> ExpectSupport.parse( + Assertions.assertThatThrownBy(() -> ExpectSupport.parse( BasicRequestBuilder.post() .addHeader("Expect", "100-continue") .build(), - null)); + null)).isInstanceOf(ProtocolException.class); } @Test void testExpectParsingUnknownExpectation() throws Exception { - Assertions.assertEquals(Expectation.UNKNOWN, - ExpectSupport.parse( + Assertions.assertThat(ExpectSupport.parse( BasicRequestBuilder.post() .addHeader("Expect", "whatever") .addHeader("Expect", "100-continue") .build(), - new BasicEntityDetails(100, ContentType.TEXT_PLAIN))); + new BasicEntityDetails(100, ContentType.TEXT_PLAIN))).isEqualTo(Expectation.UNKNOWN); } @Test void testExpectParsingUnknownExpectation2() throws Exception { - Assertions.assertEquals(Expectation.UNKNOWN, - ExpectSupport.parse( + Assertions.assertThat(ExpectSupport.parse( BasicRequestBuilder.post() .addHeader("Expect", "100-continue, whatever") .build(), - new BasicEntityDetails(100, ContentType.TEXT_PLAIN))); + new BasicEntityDetails(100, ContentType.TEXT_PLAIN))).isEqualTo(Expectation.UNKNOWN); } @Test void testExpectParsingNoExpectation() throws Exception { - Assertions.assertNull(ExpectSupport.parse( + Assertions.assertThat(ExpectSupport.parse( BasicRequestBuilder.post() .build(), - new BasicEntityDetails(100, ContentType.TEXT_PLAIN))); + new BasicEntityDetails(100, ContentType.TEXT_PLAIN))).isNull(); } @Test void testExpectParsingIgnoreHTTP10() throws Exception { - Assertions.assertNull(ExpectSupport.parse( + Assertions.assertThat(ExpectSupport.parse( BasicRequestBuilder.post() .setVersion(HttpVersion.HTTP_1_0) .addHeader("Expect", "100-continue") .build(), - new BasicEntityDetails(100, ContentType.TEXT_PLAIN))); + new BasicEntityDetails(100, ContentType.TEXT_PLAIN))).isNull(); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/net/TestHost.java b/httpcore5/src/test/java/org/apache/hc/core5/net/TestHost.java index 96877cd3ff..22e2880034 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/net/TestHost.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/net/TestHost.java @@ -33,7 +33,7 @@ import java.io.ObjectOutputStream; import java.net.URISyntaxException; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; /** @@ -45,21 +45,23 @@ class TestHost { @Test void testConstructor() { final Host host1 = new Host("somehost", 8080); - Assertions.assertEquals("somehost", host1.getHostName()); - Assertions.assertEquals(8080, host1.getPort()); + Assertions.assertThat(host1.getHostName()).isEqualTo("somehost"); + Assertions.assertThat(host1.getPort()).isEqualTo(8080); final Host host2 = new Host("somehost", 0); - Assertions.assertEquals("somehost", host2.getHostName()); - Assertions.assertEquals(0, host2.getPort()); + Assertions.assertThat(host2.getHostName()).isEqualTo("somehost"); + Assertions.assertThat(host2.getPort()).isEqualTo(0); final Host host3 = new Host("Яндекс.Ру", 0); - Assertions.assertEquals("Яндекс.Ру", host3.getHostName()); - Assertions.assertEquals(0, host3.getPort()); + Assertions.assertThat(host3.getHostName()).isEqualTo("Яндекс.Ру"); + Assertions.assertThat(host3.getPort()).isEqualTo(0); final Host host4 = new Host("xn--d1acpjx3f.xn--p1ag", 0); - Assertions.assertEquals("яндекс.ру", host4.getHostName()); - Assertions.assertEquals(0, host4.getPort()); + Assertions.assertThat(host4.getHostName()).isEqualTo("яндекс.ру"); + Assertions.assertThat(host4.getPort()).isEqualTo(0); final Host host5 = new Host("XN--D1Acpjx3f.xn--p1ag", 0); - Assertions.assertEquals("яндекс.ру", host5.getHostName()); - Assertions.assertEquals(0, host5.getPort()); - Assertions.assertThrows(NullPointerException.class, () -> new Host(null, 0)); + Assertions.assertThat(host5.getHostName()).isEqualTo("яндекс.ру"); + Assertions.assertThat(host5.getPort()).isEqualTo(0); + Assertions.assertThatThrownBy(() -> + new Host(null, 0)) + .isInstanceOf(NullPointerException.class); } @Test @@ -69,10 +71,10 @@ void testHashCode() { final Host host3 = new Host("someotherhost", 8080); final Host host4 = new Host("somehost", 80); - Assertions.assertEquals(host1.hashCode(), host1.hashCode()); - Assertions.assertNotEquals(host1.hashCode(), host2.hashCode()); - Assertions.assertNotEquals(host1.hashCode(), host3.hashCode()); - Assertions.assertEquals(host2.hashCode(), host4.hashCode()); + Assertions.assertThat(host1.hashCode()).isEqualTo(host1.hashCode()); + Assertions.assertThat(host2.hashCode()).isNotEqualTo(host1.hashCode()); + Assertions.assertThat(host3.hashCode()).isNotEqualTo(host1.hashCode()); + Assertions.assertThat(host4.hashCode()).isEqualTo(host2.hashCode()); } @Test @@ -82,16 +84,16 @@ void testEquals() { final Host host3 = new Host("someotherhost", 8080); final Host host4 = new Host("somehost", 80); - Assertions.assertEquals(host1, host1); - Assertions.assertNotEquals(host1, host2); - Assertions.assertNotEquals(host1, host3); - Assertions.assertEquals(host2, host4); + Assertions.assertThat(host1).isEqualTo(host1); + Assertions.assertThat(host2).isNotEqualTo(host1); + Assertions.assertThat(host3).isNotEqualTo(host1); + Assertions.assertThat(host4).isEqualTo(host2); } @Test void testToString() { final Host host1 = new Host("somehost", 8888); - Assertions.assertEquals("somehost:8888", host1.toString()); + Assertions.assertThat(host1.toString()).isEqualTo("somehost:8888"); } @Test @@ -105,46 +107,56 @@ void testSerialization() throws Exception { final ByteArrayInputStream inBuffer = new ByteArrayInputStream(raw); final ObjectInputStream inStream = new ObjectInputStream(inBuffer); final Host clone = (Host) inStream.readObject(); - Assertions.assertEquals(orig, clone); + Assertions.assertThat(clone).isEqualTo(orig); } @Test void testCreateFromString() throws Exception { - Assertions.assertEquals(new Host("somehost", 8080), Host.create("somehost:8080")); - Assertions.assertEquals(new Host("somehost", 1234), Host.create("somehost:1234")); - Assertions.assertEquals(new Host("somehost", 0), Host.create("somehost:0")); - Assertions.assertEquals(new Host("яндекс.ру", -1), Host.create("xn--d1acpjx3f.xn--p1ag")); - Assertions.assertEquals(new Host("Яндекс.Ру", -1), Host.create("Яндекс.Ру")); + Assertions.assertThat(Host.create("somehost:8080")).isEqualTo(new Host("somehost", 8080)); + Assertions.assertThat(Host.create("somehost:1234")).isEqualTo(new Host("somehost", 1234)); + Assertions.assertThat(Host.create("somehost:0")).isEqualTo(new Host("somehost", 0)); + Assertions.assertThat(Host.create("xn--d1acpjx3f.xn--p1ag")).isEqualTo(new Host("яндекс.ру", -1)); + Assertions.assertThat(Host.create("Яндекс.Ру")).isEqualTo(new Host("Яндекс.Ру", -1)); } @Test void testCreateFromStringInvalid() { - Assertions.assertThrows(URISyntaxException.class, () -> Host.create(" host ")); - Assertions.assertThrows(URISyntaxException.class, () -> Host.create("host :8080")); - Assertions.assertThrows(IllegalArgumentException.class, () -> Host.create("")); + Assertions.assertThatThrownBy(() -> + Host.create(" host ")) + .isInstanceOf(URISyntaxException.class); + Assertions.assertThatThrownBy(() -> + Host.create("host :8080")) + .isInstanceOf(URISyntaxException.class); + Assertions.assertThatThrownBy(() -> + Host.create("")) + .isInstanceOf(IllegalArgumentException.class); } @Test void testIpv6HostAndPort() throws Exception { final Host host = Host.create("[::1]:80"); - Assertions.assertEquals("::1", host.getHostName()); - Assertions.assertEquals(80, host.getPort()); + Assertions.assertThat(host.getHostName()).isEqualTo("::1"); + Assertions.assertThat(host.getPort()).isEqualTo(80); } @Test void testIpv6HostAndPortWithoutBrackets() { // ambiguous - Assertions.assertThrows(URISyntaxException.class, () -> Host.create("::1:80")); + Assertions.assertThatThrownBy(() -> + Host.create("::1:80")) + .isInstanceOf(URISyntaxException.class); } @Test void testIpv6HostWithoutPort() { - Assertions.assertThrows(URISyntaxException.class, () -> Host.create("::1")); + Assertions.assertThatThrownBy(() -> + Host.create("::1")) + .isInstanceOf(URISyntaxException.class); } @Test void testIpv6HostToString() { - Assertions.assertEquals("[::1]:80", new Host("::1", 80).toString()); - Assertions.assertEquals("[::1]", new Host("::1", -1).toString()); + Assertions.assertThat(new Host("::1", 80).toString()).isEqualTo("[::1]:80"); + Assertions.assertThat(new Host("::1", -1).toString()).isEqualTo("[::1]"); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/net/TestInetAddressUtils.java b/httpcore5/src/test/java/org/apache/hc/core5/net/TestInetAddressUtils.java index 32e080a26f..ddac318a2b 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/net/TestInetAddressUtils.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/net/TestInetAddressUtils.java @@ -31,7 +31,7 @@ import java.net.URISyntaxException; import org.apache.hc.core5.http.HttpHost; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; /** @@ -41,247 +41,251 @@ class TestInetAddressUtils { @Test void testValidIPv4Address() { - Assertions.assertTrue(InetAddressUtils.isIPv4("127.0.0.1")); - Assertions.assertTrue(InetAddressUtils.isIPv4("192.168.0.0")); - Assertions.assertTrue(InetAddressUtils.isIPv4("255.255.255.255")); - Assertions.assertTrue(InetAddressUtils.isIPv4("0.168.0.0")); + Assertions.assertThat(InetAddressUtils.isIPv4("127.0.0.1")).isTrue(); + Assertions.assertThat(InetAddressUtils.isIPv4("192.168.0.0")).isTrue(); + Assertions.assertThat(InetAddressUtils.isIPv4("255.255.255.255")).isTrue(); + Assertions.assertThat(InetAddressUtils.isIPv4("0.168.0.0")).isTrue(); } @Test void testInvalidIPv4Address() { - Assertions.assertFalse(InetAddressUtils.isIPv4(" 127.0.0.1 ")); // Blanks not allowed - Assertions.assertFalse(InetAddressUtils.isIPv4("g.ar.ba.ge")); - Assertions.assertFalse(InetAddressUtils.isIPv4("192.168.0")); - Assertions.assertFalse(InetAddressUtils.isIPv4("256.255.255.255")); + Assertions.assertThat(InetAddressUtils.isIPv4(" 127.0.0.1 ")).isFalse(); // Blanks not allowed + Assertions.assertThat(InetAddressUtils.isIPv4("g.ar.ba.ge")).isFalse(); + Assertions.assertThat(InetAddressUtils.isIPv4("192.168.0")).isFalse(); + Assertions.assertThat(InetAddressUtils.isIPv4("256.255.255.255")).isFalse(); } @Test void testValidIPv6Address() { - Assertions.assertTrue(InetAddressUtils.isIPv6Std("2001:0db8:0000:0000:0000:0000:1428:57ab")); - Assertions.assertTrue(InetAddressUtils.isIPv6Std("2001:db8:0:0:0:0:1428:57ab")); - Assertions.assertTrue(InetAddressUtils.isIPv6Std("0:0:0:0:0:0:0:0")); - Assertions.assertTrue(InetAddressUtils.isIPv6Std("0:0:0:0:0:0:0:1")); - - Assertions.assertTrue(InetAddressUtils.isIPv6HexCompressed("2001:0db8:0:0::1428:57ab")); - Assertions.assertTrue(InetAddressUtils.isIPv6HexCompressed("2001:0db8::1428:57ab")); - Assertions.assertTrue(InetAddressUtils.isIPv6HexCompressed("2001:db8::1428:57ab")); - Assertions.assertTrue(InetAddressUtils.isIPv6HexCompressed("::1")); - Assertions.assertTrue(InetAddressUtils.isIPv6HexCompressed("::")); // http://tools.ietf.org/html/rfc4291#section-2.2 - - Assertions.assertTrue(InetAddressUtils.isIPv6("2001:0db8:0000:0000:0000:0000:1428:57ab")); - Assertions.assertTrue(InetAddressUtils.isIPv6("2001:db8:0:0:0:0:1428:57ab")); - Assertions.assertTrue(InetAddressUtils.isIPv6("0:0:0:0:0:0:0:0")); - Assertions.assertTrue(InetAddressUtils.isIPv6("0:0:0:0:0:0:0:1")); - Assertions.assertTrue(InetAddressUtils.isIPv6("2001:0db8:0:0::1428:57ab")); - Assertions.assertTrue(InetAddressUtils.isIPv6("2001:0db8::1428:57ab")); - Assertions.assertTrue(InetAddressUtils.isIPv6("2001:db8::1428:57ab")); - Assertions.assertTrue(InetAddressUtils.isIPv6("::1")); - Assertions.assertTrue(InetAddressUtils.isIPv6("::")); // http://tools.ietf.org/html/rfc4291#section-2.2 + Assertions.assertThat(InetAddressUtils.isIPv6Std("2001:0db8:0000:0000:0000:0000:1428:57ab")).isTrue(); + Assertions.assertThat(InetAddressUtils.isIPv6Std("2001:db8:0:0:0:0:1428:57ab")).isTrue(); + Assertions.assertThat(InetAddressUtils.isIPv6Std("0:0:0:0:0:0:0:0")).isTrue(); + Assertions.assertThat(InetAddressUtils.isIPv6Std("0:0:0:0:0:0:0:1")).isTrue(); + + Assertions.assertThat(InetAddressUtils.isIPv6HexCompressed("2001:0db8:0:0::1428:57ab")).isTrue(); + Assertions.assertThat(InetAddressUtils.isIPv6HexCompressed("2001:0db8::1428:57ab")).isTrue(); + Assertions.assertThat(InetAddressUtils.isIPv6HexCompressed("2001:db8::1428:57ab")).isTrue(); + Assertions.assertThat(InetAddressUtils.isIPv6HexCompressed("::1")).isTrue(); + Assertions.assertThat(InetAddressUtils.isIPv6HexCompressed("::")).isTrue(); // http://tools.ietf.org/html/rfc4291#section-2.2 + + Assertions.assertThat(InetAddressUtils.isIPv6("2001:0db8:0000:0000:0000:0000:1428:57ab")).isTrue(); + Assertions.assertThat(InetAddressUtils.isIPv6("2001:db8:0:0:0:0:1428:57ab")).isTrue(); + Assertions.assertThat(InetAddressUtils.isIPv6("0:0:0:0:0:0:0:0")).isTrue(); + Assertions.assertThat(InetAddressUtils.isIPv6("0:0:0:0:0:0:0:1")).isTrue(); + Assertions.assertThat(InetAddressUtils.isIPv6("2001:0db8:0:0::1428:57ab")).isTrue(); + Assertions.assertThat(InetAddressUtils.isIPv6("2001:0db8::1428:57ab")).isTrue(); + Assertions.assertThat(InetAddressUtils.isIPv6("2001:db8::1428:57ab")).isTrue(); + Assertions.assertThat(InetAddressUtils.isIPv6("::1")).isTrue(); + Assertions.assertThat(InetAddressUtils.isIPv6("::")).isTrue(); // http://tools.ietf.org/html/rfc4291#section-2.2 //HTTPCORE-674 InetAddressUtils scoped ID support - Assertions.assertTrue(InetAddressUtils.isIPv6("fe80::1ff:fe23:4567:890a")); - Assertions.assertTrue(InetAddressUtils.isIPv6("fe80::1ff:fe23:4567:890a%eth2")); - Assertions.assertTrue(InetAddressUtils.isIPv6("fe80::1ff:fe23:4567:890a%3")); + Assertions.assertThat(InetAddressUtils.isIPv6("fe80::1ff:fe23:4567:890a")).isTrue(); + Assertions.assertThat(InetAddressUtils.isIPv6("fe80::1ff:fe23:4567:890a%eth2")).isTrue(); + Assertions.assertThat(InetAddressUtils.isIPv6("fe80::1ff:fe23:4567:890a%3")).isTrue(); } @Test void testInvalidIPv6Address() { - Assertions.assertFalse(InetAddressUtils.isIPv6("2001:0db8:0000:garb:age0:0000:1428:57ab")); - Assertions.assertFalse(InetAddressUtils.isIPv6("2001:0gb8:0000:0000:0000:0000:1428:57ab")); - Assertions.assertFalse(InetAddressUtils.isIPv6Std("0:0:0:0:0:0:0:0:0")); // Too many - Assertions.assertFalse(InetAddressUtils.isIPv6Std("0:0:0:0:0:0:0")); // Too few - Assertions.assertFalse(InetAddressUtils.isIPv6HexCompressed(":1")); - Assertions.assertFalse(InetAddressUtils.isIPv6(":1")); - Assertions.assertFalse(InetAddressUtils.isIPv6("2001:0db8::0000::57ab")); // Cannot have two contractions - Assertions.assertFalse(InetAddressUtils.isIPv6HexCompressed("1:2:3:4:5:6:7::9")); // too many fields before :: - Assertions.assertFalse(InetAddressUtils.isIPv6HexCompressed("1::3:4:5:6:7:8:9")); // too many fields after :: - Assertions.assertFalse(InetAddressUtils.isIPv6HexCompressed("::3:4:5:6:7:8:9")); // too many fields after :: - Assertions.assertFalse(InetAddressUtils.isIPv6("")); // empty + Assertions.assertThat(InetAddressUtils.isIPv6("2001:0db8:0000:garb:age0:0000:1428:57ab")).isFalse(); + Assertions.assertThat(InetAddressUtils.isIPv6("2001:0gb8:0000:0000:0000:0000:1428:57ab")).isFalse(); + Assertions.assertThat(InetAddressUtils.isIPv6Std("0:0:0:0:0:0:0:0:0")).isFalse(); // Too many + Assertions.assertThat(InetAddressUtils.isIPv6Std("0:0:0:0:0:0:0")).isFalse(); // Too few + Assertions.assertThat(InetAddressUtils.isIPv6HexCompressed(":1")).isFalse(); + Assertions.assertThat(InetAddressUtils.isIPv6(":1")).isFalse(); + Assertions.assertThat(InetAddressUtils.isIPv6("2001:0db8::0000::57ab")).isFalse(); // Cannot have two contractions + Assertions.assertThat(InetAddressUtils.isIPv6HexCompressed("1:2:3:4:5:6:7::9")).isFalse(); // too many fields before :: + Assertions.assertThat(InetAddressUtils.isIPv6HexCompressed("1::3:4:5:6:7:8:9")).isFalse(); // too many fields after :: + Assertions.assertThat(InetAddressUtils.isIPv6HexCompressed("::3:4:5:6:7:8:9")).isFalse(); // too many fields after :: + Assertions.assertThat(InetAddressUtils.isIPv6("")).isFalse(); // empty //Invalid scoped IDs - Assertions.assertFalse(InetAddressUtils.isIPv6("fe80::1ff:fe23:4567:890a%eth2#")); - Assertions.assertFalse(InetAddressUtils.isIPv6("fe80::1ff:fe23:4567:890a%3@")); - Assertions.assertFalse(InetAddressUtils.isIPv6("fe80::1ff:fe23:4567:890a#eth2")); - Assertions.assertFalse(InetAddressUtils.isIPv6("fe80::1ff:fe23:4567:890a%")); - Assertions.assertFalse(InetAddressUtils.isIPv6("fe80::1ff:fe23:4567:890a%eth2!")); - Assertions.assertFalse(InetAddressUtils.isIPv6("2001:0db8:0:0::1428:57ab%")); - Assertions.assertFalse(InetAddressUtils.isIPv6("2001:0db8:0:0::1428:57ab%eth2#")); - Assertions.assertFalse(InetAddressUtils.isIPv6("fe80::1ff:fe23:4567:890a%eth2#3")); - Assertions.assertFalse(InetAddressUtils.isIPv6("2001:0db8:0:0::1428:57ab%eth2#3")); - Assertions.assertFalse(InetAddressUtils.isIPv6("fe80::1ff:fe23:4567:890a%3#eth2")); - Assertions.assertFalse(InetAddressUtils.isIPv6("2001:0db8:0:0::1428:57ab%3#eth2")); + Assertions.assertThat(InetAddressUtils.isIPv6("fe80::1ff:fe23:4567:890a%eth2#")).isFalse(); + Assertions.assertThat(InetAddressUtils.isIPv6("fe80::1ff:fe23:4567:890a%3@")).isFalse(); + Assertions.assertThat(InetAddressUtils.isIPv6("fe80::1ff:fe23:4567:890a#eth2")).isFalse(); + Assertions.assertThat(InetAddressUtils.isIPv6("fe80::1ff:fe23:4567:890a%")).isFalse(); + Assertions.assertThat(InetAddressUtils.isIPv6("fe80::1ff:fe23:4567:890a%eth2!")).isFalse(); + Assertions.assertThat(InetAddressUtils.isIPv6("2001:0db8:0:0::1428:57ab%")).isFalse(); + Assertions.assertThat(InetAddressUtils.isIPv6("2001:0db8:0:0::1428:57ab%eth2#")).isFalse(); + Assertions.assertThat(InetAddressUtils.isIPv6("fe80::1ff:fe23:4567:890a%eth2#3")).isFalse(); + Assertions.assertThat(InetAddressUtils.isIPv6("2001:0db8:0:0::1428:57ab%eth2#3")).isFalse(); + Assertions.assertThat(InetAddressUtils.isIPv6("fe80::1ff:fe23:4567:890a%3#eth2")).isFalse(); + Assertions.assertThat(InetAddressUtils.isIPv6("2001:0db8:0:0::1428:57ab%3#eth2")).isFalse(); } @Test void testValidIPv6BracketAddress() { - Assertions.assertTrue(InetAddressUtils.isIPv6URLBracketed("[2001:0db8:0000:0000:0000:0000:1428:57ab]")); - Assertions.assertTrue(InetAddressUtils.isIPv6URLBracketed("[2001:db8:0:0:0:0:1428:57ab]")); - Assertions.assertTrue(InetAddressUtils.isIPv6URLBracketed("[0:0:0:0:0:0:0:0]")); - Assertions.assertTrue(InetAddressUtils.isIPv6URLBracketed("[0:0:0:0:0:0:0:1]")); - Assertions.assertTrue(InetAddressUtils.isIPv6URLBracketed("[2001:0db8:0:0::1428:57ab]")); - Assertions.assertTrue(InetAddressUtils.isIPv6URLBracketed("[2001:0db8::1428:57ab]")); - Assertions.assertTrue(InetAddressUtils.isIPv6URLBracketed("[2001:db8::1428:57ab]")); - Assertions.assertTrue(InetAddressUtils.isIPv6URLBracketed("[::1]")); + Assertions.assertThat(InetAddressUtils.isIPv6URLBracketed("[2001:0db8:0000:0000:0000:0000:1428:57ab]")).isTrue(); + Assertions.assertThat(InetAddressUtils.isIPv6URLBracketed("[2001:db8:0:0:0:0:1428:57ab]")).isTrue(); + Assertions.assertThat(InetAddressUtils.isIPv6URLBracketed("[0:0:0:0:0:0:0:0]")).isTrue(); + Assertions.assertThat(InetAddressUtils.isIPv6URLBracketed("[0:0:0:0:0:0:0:1]")).isTrue(); + Assertions.assertThat(InetAddressUtils.isIPv6URLBracketed("[2001:0db8:0:0::1428:57ab]")).isTrue(); + Assertions.assertThat(InetAddressUtils.isIPv6URLBracketed("[2001:0db8::1428:57ab]")).isTrue(); + Assertions.assertThat(InetAddressUtils.isIPv6URLBracketed("[2001:db8::1428:57ab]")).isTrue(); + Assertions.assertThat(InetAddressUtils.isIPv6URLBracketed("[::1]")).isTrue(); // http://tools.ietf.org/html/rfc4291#section-2.2 - Assertions.assertTrue(InetAddressUtils.isIPv6URLBracketed("[::]")); + Assertions.assertThat(InetAddressUtils.isIPv6URLBracketed("[::]")).isTrue(); } @Test void testInvalidIPv6BracketAddress() { - Assertions.assertFalse(InetAddressUtils.isIPv6URLBracketed("2001:0db8:0000:garb:age0:0000:1428:57ab")); - Assertions.assertFalse(InetAddressUtils.isIPv6URLBracketed("[2001:0db8:0000:garb:age0:0000:1428:57ab]")); - Assertions.assertFalse(InetAddressUtils.isIPv6URLBracketed("2001:0gb8:0000:0000:0000:0000:1428:57ab")); - Assertions.assertFalse(InetAddressUtils.isIPv6URLBracketed("[2001:0gb8:0000:0000:0000:0000:1428:57ab]")); + Assertions.assertThat(InetAddressUtils.isIPv6URLBracketed("2001:0db8:0000:garb:age0:0000:1428:57ab")).isFalse(); + Assertions.assertThat(InetAddressUtils.isIPv6URLBracketed("[2001:0db8:0000:garb:age0:0000:1428:57ab]")).isFalse(); + Assertions.assertThat(InetAddressUtils.isIPv6URLBracketed("2001:0gb8:0000:0000:0000:0000:1428:57ab")).isFalse(); + Assertions.assertThat(InetAddressUtils.isIPv6URLBracketed("[2001:0gb8:0000:0000:0000:0000:1428:57ab]")).isFalse(); // Too many - Assertions.assertFalse(InetAddressUtils.isIPv6URLBracketed("0:0:0:0:0:0:0:0:0")); - Assertions.assertFalse(InetAddressUtils.isIPv6URLBracketed("[0:0:0:0:0:0:0:0:0]")); + Assertions.assertThat(InetAddressUtils.isIPv6URLBracketed("0:0:0:0:0:0:0:0:0")).isFalse(); + Assertions.assertThat(InetAddressUtils.isIPv6URLBracketed("[0:0:0:0:0:0:0:0:0]")).isFalse(); // Too few - Assertions.assertFalse(InetAddressUtils.isIPv6URLBracketed("0:0:0:0:0:0:0")); - Assertions.assertFalse(InetAddressUtils.isIPv6URLBracketed("[0:0:0:0:0:0:0]")); - Assertions.assertFalse(InetAddressUtils.isIPv6URLBracketed(":1")); - Assertions.assertFalse(InetAddressUtils.isIPv6URLBracketed("[:1]")); + Assertions.assertThat(InetAddressUtils.isIPv6URLBracketed("0:0:0:0:0:0:0")).isFalse(); + Assertions.assertThat(InetAddressUtils.isIPv6URLBracketed("[0:0:0:0:0:0:0]")).isFalse(); + Assertions.assertThat(InetAddressUtils.isIPv6URLBracketed(":1")).isFalse(); + Assertions.assertThat(InetAddressUtils.isIPv6URLBracketed("[:1]")).isFalse(); // Cannot have two contractions - Assertions.assertFalse(InetAddressUtils.isIPv6URLBracketed("2001:0db8::0000::57ab")); - Assertions.assertFalse(InetAddressUtils.isIPv6URLBracketed("[2001:0db8::0000::57ab]")); + Assertions.assertThat(InetAddressUtils.isIPv6URLBracketed("2001:0db8::0000::57ab")).isFalse(); + Assertions.assertThat(InetAddressUtils.isIPv6URLBracketed("[2001:0db8::0000::57ab]")).isFalse(); // too many fields before :: - Assertions.assertFalse(InetAddressUtils.isIPv6URLBracketed("1:2:3:4:5:6:7::9")); - Assertions.assertFalse(InetAddressUtils.isIPv6URLBracketed("[1:2:3:4:5:6:7::9]")); + Assertions.assertThat(InetAddressUtils.isIPv6URLBracketed("1:2:3:4:5:6:7::9")).isFalse(); + Assertions.assertThat(InetAddressUtils.isIPv6URLBracketed("[1:2:3:4:5:6:7::9]")).isFalse(); // too many fields after :: - Assertions.assertFalse(InetAddressUtils.isIPv6URLBracketed("1::3:4:5:6:7:8:9")); - Assertions.assertFalse(InetAddressUtils.isIPv6URLBracketed("[1::3:4:5:6:7:8:9]")); + Assertions.assertThat(InetAddressUtils.isIPv6URLBracketed("1::3:4:5:6:7:8:9")).isFalse(); + Assertions.assertThat(InetAddressUtils.isIPv6URLBracketed("[1::3:4:5:6:7:8:9]")).isFalse(); // too many fields after :: - Assertions.assertFalse(InetAddressUtils.isIPv6URLBracketed("::3:4:5:6:7:8:9")); - Assertions.assertFalse(InetAddressUtils.isIPv6URLBracketed("[::3:4:5:6:7:8:9]")); + Assertions.assertThat(InetAddressUtils.isIPv6URLBracketed("::3:4:5:6:7:8:9")).isFalse(); + Assertions.assertThat(InetAddressUtils.isIPv6URLBracketed("[::3:4:5:6:7:8:9]")).isFalse(); // empty - Assertions.assertFalse(InetAddressUtils.isIPv6URLBracketed("")); - Assertions.assertFalse(InetAddressUtils.isIPv6URLBracketed("[]")); + Assertions.assertThat(InetAddressUtils.isIPv6URLBracketed("")).isFalse(); + Assertions.assertThat(InetAddressUtils.isIPv6URLBracketed("[]")).isFalse(); // missing brackets - Assertions.assertFalse(InetAddressUtils.isIPv6URLBracketed("::")); - Assertions.assertFalse(InetAddressUtils.isIPv6URLBracketed("::1")); - Assertions.assertFalse(InetAddressUtils.isIPv6URLBracketed("2001:db8::1428:57ab")); + Assertions.assertThat(InetAddressUtils.isIPv6URLBracketed("::")).isFalse(); + Assertions.assertThat(InetAddressUtils.isIPv6URLBracketed("::1")).isFalse(); + Assertions.assertThat(InetAddressUtils.isIPv6URLBracketed("2001:db8::1428:57ab")).isFalse(); } @Test // Test HTTPCLIENT-1319 void testInvalidIPv6AddressIncorrectGroupCount() { - Assertions.assertFalse(InetAddressUtils.isIPv6HexCompressed("1:2::4:5:6:7:8:9")); // too many fields in total - Assertions.assertFalse(InetAddressUtils.isIPv6HexCompressed("1:2:3:4:5:6::8:9")); // too many fields in total + Assertions.assertThat(InetAddressUtils.isIPv6HexCompressed("1:2::4:5:6:7:8:9")).isFalse(); // too many fields in total + Assertions.assertThat(InetAddressUtils.isIPv6HexCompressed("1:2:3:4:5:6::8:9")).isFalse(); // too many fields in total } @Test void testHasValidIPv6ColonCount() { - Assertions.assertFalse(InetAddressUtils.hasValidIPv6ColonCount("")); - Assertions.assertFalse(InetAddressUtils.hasValidIPv6ColonCount(":")); - Assertions.assertFalse(InetAddressUtils.hasValidIPv6ColonCount("127.0.0.1")); - Assertions.assertFalse(InetAddressUtils.hasValidIPv6ColonCount(":0")); - Assertions.assertFalse(InetAddressUtils.hasValidIPv6ColonCount("0:")); - Assertions.assertFalse(InetAddressUtils.hasValidIPv6ColonCount("1:2:3:4:5:6:7:8:")); - Assertions.assertFalse(InetAddressUtils.hasValidIPv6ColonCount("1:2:3:4:5:6:7:8:9")); - - Assertions.assertTrue(InetAddressUtils.hasValidIPv6ColonCount("2001:0db8:0000:0000:0000:0000:1428:57ab")); - Assertions.assertTrue(InetAddressUtils.hasValidIPv6ColonCount("2001:db8:0:0:0:0:1428:57ab")); - Assertions.assertTrue(InetAddressUtils.hasValidIPv6ColonCount("0:0:0:0:0:0:0:0")); - Assertions.assertTrue(InetAddressUtils.hasValidIPv6ColonCount("0:0:0:0:0:0:0:1")); - Assertions.assertTrue(InetAddressUtils.hasValidIPv6ColonCount("2001:0db8:0:0::1428:57ab")); - Assertions.assertTrue(InetAddressUtils.hasValidIPv6ColonCount("2001:0db8::1428:57ab")); - Assertions.assertTrue(InetAddressUtils.hasValidIPv6ColonCount("2001:db8::1428:57ab")); - Assertions.assertTrue(InetAddressUtils.hasValidIPv6ColonCount("::1")); - Assertions.assertTrue(InetAddressUtils.hasValidIPv6ColonCount("::")); // http://tools.ietf.org/html/rfc4291#section-2.2 + Assertions.assertThat(InetAddressUtils.hasValidIPv6ColonCount("")).isFalse(); + Assertions.assertThat(InetAddressUtils.hasValidIPv6ColonCount(":")).isFalse(); + Assertions.assertThat(InetAddressUtils.hasValidIPv6ColonCount("127.0.0.1")).isFalse(); + Assertions.assertThat(InetAddressUtils.hasValidIPv6ColonCount(":0")).isFalse(); + Assertions.assertThat(InetAddressUtils.hasValidIPv6ColonCount("0:")).isFalse(); + Assertions.assertThat(InetAddressUtils.hasValidIPv6ColonCount("1:2:3:4:5:6:7:8:")).isFalse(); + Assertions.assertThat(InetAddressUtils.hasValidIPv6ColonCount("1:2:3:4:5:6:7:8:9")).isFalse(); + + Assertions.assertThat(InetAddressUtils.hasValidIPv6ColonCount("2001:0db8:0000:0000:0000:0000:1428:57ab")).isTrue(); + Assertions.assertThat(InetAddressUtils.hasValidIPv6ColonCount("2001:db8:0:0:0:0:1428:57ab")).isTrue(); + Assertions.assertThat(InetAddressUtils.hasValidIPv6ColonCount("0:0:0:0:0:0:0:0")).isTrue(); + Assertions.assertThat(InetAddressUtils.hasValidIPv6ColonCount("0:0:0:0:0:0:0:1")).isTrue(); + Assertions.assertThat(InetAddressUtils.hasValidIPv6ColonCount("2001:0db8:0:0::1428:57ab")).isTrue(); + Assertions.assertThat(InetAddressUtils.hasValidIPv6ColonCount("2001:0db8::1428:57ab")).isTrue(); + Assertions.assertThat(InetAddressUtils.hasValidIPv6ColonCount("2001:db8::1428:57ab")).isTrue(); + Assertions.assertThat(InetAddressUtils.hasValidIPv6ColonCount("::1")).isTrue(); + Assertions.assertThat(InetAddressUtils.hasValidIPv6ColonCount("::")).isTrue(); // http://tools.ietf.org/html/rfc4291#section-2.2 } @Test void testValidIPv4MappedIPv6Address() { - Assertions.assertTrue(InetAddressUtils.isIPv4MappedIPv6("::FFFF:1.2.3.4")); - Assertions.assertTrue(InetAddressUtils.isIPv4MappedIPv6("::ffff:255.255.255.255")); + Assertions.assertThat(InetAddressUtils.isIPv4MappedIPv6("::FFFF:1.2.3.4")).isTrue(); + Assertions.assertThat(InetAddressUtils.isIPv4MappedIPv6("::ffff:255.255.255.255")).isTrue(); } @Test void testInValidIPv4MappedIPv6Address() { - Assertions.assertFalse(InetAddressUtils.isIPv4MappedIPv6("2001:0db8:0000:0000:0000:0000:1428:57ab")); - Assertions.assertFalse(InetAddressUtils.isIPv4MappedIPv6("::ffff:1:2:3:4")); + Assertions.assertThat(InetAddressUtils.isIPv4MappedIPv6("2001:0db8:0000:0000:0000:0000:1428:57ab")).isFalse(); + Assertions.assertThat(InetAddressUtils.isIPv4MappedIPv6("::ffff:1:2:3:4")).isFalse(); } @Test void testValidIPv4MappedIPv6AddressWithLeadingZeros() { - Assertions.assertTrue(InetAddressUtils.isIPv4MappedIPv6("::ffff:001.002.003.004")); - Assertions.assertTrue(InetAddressUtils.isIPv4MappedIPv6("::FFFF:000.000.000.255")); - Assertions.assertTrue(InetAddressUtils.isIPv4MappedIPv6("::ffff:010.020.030.040")); + Assertions.assertThat(InetAddressUtils.isIPv4MappedIPv6("::ffff:001.002.003.004")).isTrue(); + Assertions.assertThat(InetAddressUtils.isIPv4MappedIPv6("::FFFF:000.000.000.255")).isTrue(); + Assertions.assertThat(InetAddressUtils.isIPv4MappedIPv6("::ffff:010.020.030.040")).isTrue(); } @Test void testInvalidIPv4MappedIPv6AddressWithBadOctets() { // >255 not allowed - Assertions.assertFalse(InetAddressUtils.isIPv4MappedIPv6("::ffff:256.000.000.000")); + Assertions.assertThat(InetAddressUtils.isIPv4MappedIPv6("::ffff:256.000.000.000")).isFalse(); // too few octets - Assertions.assertFalse(InetAddressUtils.isIPv4MappedIPv6("::ffff:01.02.03")); + Assertions.assertThat(InetAddressUtils.isIPv4MappedIPv6("::ffff:01.02.03")).isFalse(); // too many digits in an octet (4 digits) - Assertions.assertFalse(InetAddressUtils.isIPv4MappedIPv6("::ffff:0255.000.000.000")); + Assertions.assertThat(InetAddressUtils.isIPv4MappedIPv6("::ffff:0255.000.000.000")).isFalse(); } @Test void parseAuthorityWithZoneId_decodesDelimiter() throws URISyntaxException { final URIAuthority a = URIAuthority.parse("[fe80::1%25eth0]:8080"); - Assertions.assertNotNull(a); - Assertions.assertEquals("fe80::1%eth0", a.getHostName()); - Assertions.assertEquals(8080, a.getPort()); - Assertions.assertNull(a.getUserInfo()); + Assertions.assertThat(a).isNotNull(); + Assertions.assertThat(a.getHostName()).isEqualTo("fe80::1%eth0"); + Assertions.assertThat(a.getPort()).isEqualTo(8080); + Assertions.assertThat(a.getUserInfo()).isNull(); } @Test void formatAuthorityWithZoneId_emitsPercent25() { final URIAuthority a = new URIAuthority(null, "fe80::1%eth0", 8080); - Assertions.assertEquals("[fe80::1%25eth0]:8080", a.toString()); + Assertions.assertThat(a.toString()).isEqualTo("[fe80::1%25eth0]:8080"); } @Test void httpHost_toURI_formatsZoneId() { final HttpHost h = new HttpHost("http", "fe80::1%eth0", 8080); - Assertions.assertEquals("http://[fe80::1%25eth0]:8080", h.toURI()); + Assertions.assertThat(h.toURI()).isEqualTo("http://[fe80::1%25eth0]:8080"); } @Test void uriBuilder_roundTrip_zoneId() throws Exception { final URI u = new URI("http://[fe80::1%25eth0]:8080/path?q=1"); final URIBuilder b = new URIBuilder(u); - Assertions.assertEquals("fe80::1%eth0", b.getHost()); + Assertions.assertThat(b.getHost()).isEqualTo("fe80::1%eth0"); final URI rebuilt = b.build(); - Assertions.assertEquals("http://[fe80::1%25eth0]:8080/path?q=1", rebuilt.toASCIIString()); + Assertions.assertThat(rebuilt.toASCIIString()).isEqualTo("http://[fe80::1%25eth0]:8080/path?q=1"); } @Test void zoneId_validation_rejects_bad_pct() { // empty zone — invalid - Assertions.assertThrows(IllegalArgumentException.class, - () -> URIAuthority.parse("[fe80::1%25]:80")); + Assertions.assertThatThrownBy(() -> + URIAuthority.parse("[fe80::1%25]:80")) + .isInstanceOf(IllegalArgumentException.class); // dangling percent-triplet — invalid - Assertions.assertThrows(IllegalArgumentException.class, - () -> URIAuthority.parse("[fe80::1%25%]:80")); + Assertions.assertThatThrownBy(() -> + URIAuthority.parse("[fe80::1%25%]:80")) + .isInstanceOf(IllegalArgumentException.class); // non-hex in percent-triplet — invalid - Assertions.assertThrows(IllegalArgumentException.class, - () -> URIAuthority.parse("[fe80::1%25%G1]:80")); + Assertions.assertThatThrownBy(() -> + URIAuthority.parse("[fe80::1%25%G1]:80")) + .isInstanceOf(IllegalArgumentException.class); // character not in RFC 3986 "unreserved" — invalid - Assertions.assertThrows(IllegalArgumentException.class, - () -> URIAuthority.parse("[fe80::1%25!]:80")); + Assertions.assertThatThrownBy(() -> + URIAuthority.parse("[fe80::1%25!]:80")) + .isInstanceOf(IllegalArgumentException.class); } @Test void zoneId_allows_unreserved_and_pct() throws URISyntaxException { final URIAuthority a = URIAuthority.parse("[fe80::1%25en1-._~x%20]:443"); - Assertions.assertNotNull(a); - Assertions.assertEquals("fe80::1%en1-._~x ", a.getHostName()); - Assertions.assertEquals("[fe80::1%25en1-._~x%20]:443", a.toString()); + Assertions.assertThat(a).isNotNull(); + Assertions.assertThat(a.getHostName()).isEqualTo("fe80::1%en1-._~x "); + Assertions.assertThat(a.toString()).isEqualTo("[fe80::1%25en1-._~x%20]:443"); } @Test void inetAddressUtils_helper_accepts_zone() { - Assertions.assertTrue(ZoneIdSupport.looksLikeIPv6AddressPart("fe80::1%eth0")); - Assertions.assertTrue(ZoneIdSupport.looksLikeIPv6AddressPart("fe80::1234:0:0:0:0:0%en1")); - Assertions.assertFalse(ZoneIdSupport.looksLikeIPv6AddressPart("not-an-ip")); + Assertions.assertThat(ZoneIdSupport.looksLikeIPv6AddressPart("fe80::1%eth0")).isTrue(); + Assertions.assertThat(ZoneIdSupport.looksLikeIPv6AddressPart("fe80::1234:0:0:0:0:0%en1")).isTrue(); + Assertions.assertThat(ZoneIdSupport.looksLikeIPv6AddressPart("not-an-ip")).isFalse(); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/net/TestPercentCodec.java b/httpcore5/src/test/java/org/apache/hc/core5/net/TestPercentCodec.java index 42c220c8fc..904f849435 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/net/TestPercentCodec.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/net/TestPercentCodec.java @@ -27,12 +27,11 @@ package org.apache.hc.core5.net; -import static org.junit.jupiter.api.Assertions.assertEquals; - import java.nio.charset.StandardCharsets; import java.util.BitSet; import java.util.stream.Stream; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.MethodSource; @@ -48,7 +47,7 @@ void testCoding() { PercentCodec.encode(buf, "blah!", StandardCharsets.UTF_8); PercentCodec.encode(buf, " ~ ", StandardCharsets.UTF_8); PercentCodec.encode(buf, "huh?", StandardCharsets.UTF_8); - assertEquals("blah%21%20~%20huh%3F", buf.toString()); + Assertions.assertThat(buf.toString()).isEqualTo("blah%21%20~%20huh%3F"); } @Test @@ -56,29 +55,29 @@ void testLowerCaseHexEncoding() { final BitSet safeChars = new BitSet(256); safeChars.set(' '); final PercentCodec codec = new PercentCodec(safeChars, true); - assertEquals(" %c3%bc%22%25", codec.encode(" ü\"%")); - assertEquals("%C3%BC", PercentCodec.RFC3986.encode("ü")); + Assertions.assertThat(codec.encode(" ü\"%")).isEqualTo(" %c3%bc%22%25"); + Assertions.assertThat(PercentCodec.RFC3986.encode("ü")).isEqualTo("%C3%BC"); } @Test void testDecoding() { - assertEquals("blah! ~ huh?", PercentCodec.decode("blah%21%20~%20huh%3F", StandardCharsets.UTF_8)); - assertEquals("blah!+~ huh?", PercentCodec.decode("blah%21+~%20huh%3F", StandardCharsets.UTF_8)); - assertEquals("blah! ~ huh?", PercentCodec.decode("blah%21+~%20huh%3F", StandardCharsets.UTF_8, true)); + Assertions.assertThat(PercentCodec.decode("blah%21%20~%20huh%3F", StandardCharsets.UTF_8)).isEqualTo("blah! ~ huh?"); + Assertions.assertThat(PercentCodec.decode("blah%21+~%20huh%3F", StandardCharsets.UTF_8)).isEqualTo("blah!+~ huh?"); + Assertions.assertThat(PercentCodec.decode("blah%21+~%20huh%3F", StandardCharsets.UTF_8, true)).isEqualTo("blah! ~ huh?"); } @Test void testDecodingPartialContent() { - assertEquals("blah! %", PercentCodec.decode("blah%21%20%", StandardCharsets.UTF_8)); - assertEquals("blah! %a", PercentCodec.decode("blah%21%20%a", StandardCharsets.UTF_8)); - assertEquals("blah! %wa", PercentCodec.decode("blah%21%20%wa", StandardCharsets.UTF_8)); + Assertions.assertThat(PercentCodec.decode("blah%21%20%", StandardCharsets.UTF_8)).isEqualTo("blah! %"); + Assertions.assertThat(PercentCodec.decode("blah%21%20%a", StandardCharsets.UTF_8)).isEqualTo("blah! %a"); + Assertions.assertThat(PercentCodec.decode("blah%21%20%wa", StandardCharsets.UTF_8)).isEqualTo("blah! %wa"); } @ParameterizedTest @MethodSource("params") void testRfc5987EncodingDecoding(final String input, final String expected) { - assertEquals(expected, PercentCodec.RFC5987.encode(input)); - assertEquals(input, PercentCodec.RFC5987.decode(expected)); + Assertions.assertThat(PercentCodec.RFC5987.encode(input)).isEqualTo(expected); + Assertions.assertThat(PercentCodec.RFC5987.decode(expected)).isEqualTo(input); } static Stream params() { @@ -97,7 +96,7 @@ static Stream params() { @Test void verifyRfc5987EncodingandDecoding() { final String s = "!\"$£%^&*()_-+={[}]:@~;'#,./<>?\\|✓éèæðŃœ"; - assertEquals(s, PercentCodec.RFC5987.decode(PercentCodec.RFC5987.encode(s))); + Assertions.assertThat(PercentCodec.RFC5987.decode(PercentCodec.RFC5987.encode(s))).isEqualTo(s); } @Test @@ -107,44 +106,38 @@ void testRfc7639CanonicalAlpnTokenEncoding() { // - '%' MUST be percent-encoded. // - Octets that are valid token characters MUST NOT be percent-encoded (except '%'). // - Uppercase hex digits MUST be used. - assertEquals("h2", PercentCodec.HTTP_TOKEN.encode("h2")); - assertEquals("http%2F1.1", PercentCodec.HTTP_TOKEN.encode("http/1.1")); - assertEquals("%25", PercentCodec.HTTP_TOKEN.encode("%")); - assertEquals("foo+bar", PercentCodec.HTTP_TOKEN.encode("foo+bar")); - assertEquals("!#$&'*+-.^_`|~", PercentCodec.HTTP_TOKEN.encode("!#$&'*+-.^_`|~")); - assertEquals("foo bar", PercentCodec.HTTP_TOKEN.decode("foo%20bar")); - assertEquals("ws/é", PercentCodec.HTTP_TOKEN.decode("ws%2F%C3%A9")); + Assertions.assertThat(PercentCodec.HTTP_TOKEN.encode("h2")).isEqualTo("h2"); + Assertions.assertThat(PercentCodec.HTTP_TOKEN.encode("http/1.1")).isEqualTo("http%2F1.1"); + Assertions.assertThat(PercentCodec.HTTP_TOKEN.encode("%")).isEqualTo("%25"); + Assertions.assertThat(PercentCodec.HTTP_TOKEN.encode("foo+bar")).isEqualTo("foo+bar"); + Assertions.assertThat(PercentCodec.HTTP_TOKEN.encode("!#$&'*+-.^_`|~")).isEqualTo("!#$&'*+-.^_`|~"); + Assertions.assertThat(PercentCodec.HTTP_TOKEN.decode("foo%20bar")).isEqualTo("foo bar"); + Assertions.assertThat(PercentCodec.HTTP_TOKEN.decode("ws%2F%C3%A9")).isEqualTo("ws/é"); } @Test void testPercentCodecEncodeIsNotRfc7639Canonical() { // PercentCodec.encode(..) uses RFC 3986 UNRESERVED as the safe set. // This percent-encodes valid RFC 7230 tchar like '+', '*', '!', '|', which RFC 7639 forbids. - assertEquals("foo%2Bbar", PercentCodec.encode("foo+bar", StandardCharsets.UTF_8)); - assertEquals("%2A", PercentCodec.encode("*", StandardCharsets.UTF_8)); - assertEquals("%21", PercentCodec.encode("!", StandardCharsets.UTF_8)); - assertEquals("%7C", PercentCodec.encode("|", StandardCharsets.UTF_8)); + Assertions.assertThat(PercentCodec.encode("foo+bar", StandardCharsets.UTF_8)).isEqualTo("foo%2Bbar"); + Assertions.assertThat(PercentCodec.encode("*", StandardCharsets.UTF_8)).isEqualTo("%2A"); + Assertions.assertThat(PercentCodec.encode("!", StandardCharsets.UTF_8)).isEqualTo("%21"); + Assertions.assertThat(PercentCodec.encode("|", StandardCharsets.UTF_8)).isEqualTo("%7C"); } @Test void decodeIllegalChars() { - assertEquals( - "1?2?3?4", - PercentCodec.decode("1\u012E2\u012E3\u012E4", StandardCharsets.UTF_8)); + Assertions.assertThat(PercentCodec.decode("1\u012E2\u012E3\u012E4", StandardCharsets.UTF_8)).isEqualTo("1?2?3?4"); } @Test void testDecodeDoesNotCombineEscapedBytesAcrossLiteralCharacters() { - assertEquals( - "\uFFFDx\uFFFD", - PercentCodec.decode("%C3x%A4", StandardCharsets.UTF_8)); + Assertions.assertThat(PercentCodec.decode("%C3x%A4", StandardCharsets.UTF_8)).isEqualTo("\uFFFDx\uFFFD"); } @Test void testEncodeHonorsUtf16Charset() { - assertEquals( - "%FE%FF%00a%00b%00c", - PercentCodec.encode("abc", StandardCharsets.UTF_16)); + Assertions.assertThat(PercentCodec.encode("abc", StandardCharsets.UTF_16)).isEqualTo("%FE%FF%00a%00b%00c"); } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/net/TestURIAuthority.java b/httpcore5/src/test/java/org/apache/hc/core5/net/TestURIAuthority.java index b2fcb4dfa3..c4f229df56 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/net/TestURIAuthority.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/net/TestURIAuthority.java @@ -34,7 +34,7 @@ import java.io.ObjectOutputStream; import java.net.URISyntaxException; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; /** @@ -46,14 +46,14 @@ class TestURIAuthority { @Test void testConstructor() { final URIAuthority host1 = new URIAuthority("somehost"); - Assertions.assertEquals("somehost", host1.getHostName()); - Assertions.assertEquals(-1, host1.getPort()); + Assertions.assertThat(host1.getHostName()).isEqualTo("somehost"); + Assertions.assertThat(host1.getPort()).isEqualTo(-1); final URIAuthority host2 = new URIAuthority("somehost", 8080); - Assertions.assertEquals("somehost", host2.getHostName()); - Assertions.assertEquals(8080, host2.getPort()); + Assertions.assertThat(host2.getHostName()).isEqualTo("somehost"); + Assertions.assertThat(host2.getPort()).isEqualTo(8080); final URIAuthority host3 = new URIAuthority("somehost", -1); - Assertions.assertEquals("somehost", host3.getHostName()); - Assertions.assertEquals(-1, host3.getPort()); + Assertions.assertThat(host3.getHostName()).isEqualTo("somehost"); + Assertions.assertThat(host3.getPort()).isEqualTo(-1); } @Test @@ -66,13 +66,13 @@ void testHashCode() { final URIAuthority host6 = new URIAuthority("user", "SomeHost", 80); final URIAuthority host7 = new URIAuthority("user", "somehost", 80); - Assertions.assertEquals(host1.hashCode(), host1.hashCode()); - Assertions.assertNotEquals(host1.hashCode(), host2.hashCode()); - Assertions.assertNotEquals(host1.hashCode(), host3.hashCode()); - Assertions.assertEquals(host2.hashCode(), host4.hashCode()); - Assertions.assertEquals(host2.hashCode(), host5.hashCode()); - Assertions.assertNotEquals(host5.hashCode(), host6.hashCode()); - Assertions.assertEquals(host6.hashCode(), host7.hashCode()); + Assertions.assertThat(host1.hashCode()).isEqualTo(host1.hashCode()); + Assertions.assertThat(host2.hashCode()).isNotEqualTo(host1.hashCode()); + Assertions.assertThat(host3.hashCode()).isNotEqualTo(host1.hashCode()); + Assertions.assertThat(host4.hashCode()).isEqualTo(host2.hashCode()); + Assertions.assertThat(host5.hashCode()).isEqualTo(host2.hashCode()); + Assertions.assertThat(host6.hashCode()).isNotEqualTo(host5.hashCode()); + Assertions.assertThat(host7.hashCode()).isEqualTo(host6.hashCode()); } @Test @@ -85,23 +85,23 @@ void testEquals() { final URIAuthority host6 = new URIAuthority("user", "SomeHost", 80); final URIAuthority host7 = new URIAuthority("user", "somehost", 80); - Assertions.assertEquals(host1, host1); - Assertions.assertNotEquals(host1, host2); - Assertions.assertNotEquals(host1, host3); - Assertions.assertEquals(host2, host4); - Assertions.assertEquals(host2, host5); - Assertions.assertNotEquals(host5, host6); - Assertions.assertEquals(host6, host7); + Assertions.assertThat(host1).isEqualTo(host1); + Assertions.assertThat(host2).isNotEqualTo(host1); + Assertions.assertThat(host3).isNotEqualTo(host1); + Assertions.assertThat(host4).isEqualTo(host2); + Assertions.assertThat(host5).isEqualTo(host2); + Assertions.assertThat(host6).isNotEqualTo(host5); + Assertions.assertThat(host7).isEqualTo(host6); } @Test void testToString() { final URIAuthority host1 = new URIAuthority("somehost"); - Assertions.assertEquals("somehost", host1.toString()); + Assertions.assertThat(host1.toString()).isEqualTo("somehost"); final URIAuthority host2 = new URIAuthority("somehost", -1); - Assertions.assertEquals("somehost", host2.toString()); + Assertions.assertThat(host2.toString()).isEqualTo("somehost"); final URIAuthority host3 = new URIAuthority("somehost", 8888); - Assertions.assertEquals("somehost:8888", host3.toString()); + Assertions.assertThat(host3.toString()).isEqualTo("somehost:8888"); } @Test @@ -115,72 +115,90 @@ void testSerialization() throws Exception { final ByteArrayInputStream inBuffer = new ByteArrayInputStream(raw); final ObjectInputStream inStream = new ObjectInputStream(inBuffer); final URIAuthority clone = (URIAuthority) inStream.readObject(); - Assertions.assertEquals(orig, clone); + Assertions.assertThat(clone).isEqualTo(orig); } @Test void testParse() throws Exception { - Assertions.assertEquals(new URIAuthority("somehost", -1), URIAuthority.parse("somehost")); - Assertions.assertEquals(new URIAuthority("somehost", -1), URIAuthority.parse("somehost/blah")); - Assertions.assertEquals(new URIAuthority("somehost", -1), URIAuthority.parse("somehost?blah")); - Assertions.assertEquals(new URIAuthority("somehost", -1), URIAuthority.parse("somehost#blah")); - Assertions.assertEquals(new URIAuthority("aaaa", "", 8080), URIAuthority.parse("aaaa@:8080")); - Assertions.assertEquals(new URIAuthority(null, "", -1), URIAuthority.parse("@:")); - Assertions.assertEquals(new URIAuthority("somehost", 8080), URIAuthority.parse("somehost:8080")); - Assertions.assertEquals(new URIAuthority("somehost", 8080), URIAuthority.parse("somehost:8080/blah")); - Assertions.assertEquals(new URIAuthority("somehost", 8080), URIAuthority.parse("somehost:8080?blah")); - Assertions.assertEquals(new URIAuthority("somehost", 8080), URIAuthority.parse("somehost:8080#blah")); - Assertions.assertEquals(new URIAuthority("somehost", 8080), URIAuthority.parse("somehost:008080")); - Assertions.assertThrows(URISyntaxException.class, () -> URIAuthority.create("somehost:aaaaa")); - Assertions.assertThrows(URISyntaxException.class, () -> URIAuthority.create("somehost:90ab")); - - Assertions.assertEquals(new URIAuthority("someuser", "somehost", -1), URIAuthority.parse("someuser@somehost")); - Assertions.assertEquals(new URIAuthority("someuser", "somehost", -1), URIAuthority.parse("someuser@somehost/blah")); - Assertions.assertEquals(new URIAuthority("someuser", "somehost", -1), URIAuthority.parse("someuser@somehost?blah")); - Assertions.assertEquals(new URIAuthority("someuser", "somehost", -1), URIAuthority.parse("someuser@somehost#blah")); - - Assertions.assertEquals(new URIAuthority("someuser", "somehost", -1), URIAuthority.parse("someuser@somehost:")); - Assertions.assertEquals(new URIAuthority("someuser", "somehost", -1), URIAuthority.parse("someuser@somehost:/blah")); - Assertions.assertEquals(new URIAuthority("someuser", "somehost", -1), URIAuthority.parse("someuser@somehost:?blah")); - Assertions.assertEquals(new URIAuthority("someuser", "somehost", -1), URIAuthority.parse("someuser@somehost:#blah")); - - Assertions.assertEquals(new URIAuthority("someuser", "somehost", 8080), URIAuthority.parse("someuser@somehost:8080")); - Assertions.assertEquals(new URIAuthority("someuser", "somehost", 8080), URIAuthority.parse("someuser@somehost:8080/blah")); - Assertions.assertEquals(new URIAuthority("someuser", "somehost", 8080), URIAuthority.parse("someuser@somehost:8080?blah")); - Assertions.assertEquals(new URIAuthority("someuser", "somehost", 8080), URIAuthority.parse("someuser@somehost:8080#blah")); - Assertions.assertEquals(new URIAuthority("somehost", 8080), URIAuthority.parse("@somehost:8080")); - Assertions.assertEquals(new URIAuthority("test:test", "localhost", 38339), URIAuthority.parse("test:test@localhost:38339")); - Assertions.assertThrows(URISyntaxException.class, () -> - URIAuthority.create("blah@goggle.com:80@google.com/")); + Assertions.assertThat(URIAuthority.parse("somehost")).isEqualTo(new URIAuthority("somehost", -1)); + Assertions.assertThat(URIAuthority.parse("somehost/blah")).isEqualTo(new URIAuthority("somehost", -1)); + Assertions.assertThat(URIAuthority.parse("somehost?blah")).isEqualTo(new URIAuthority("somehost", -1)); + Assertions.assertThat(URIAuthority.parse("somehost#blah")).isEqualTo(new URIAuthority("somehost", -1)); + Assertions.assertThat(URIAuthority.parse("aaaa@:8080")).isEqualTo(new URIAuthority("aaaa", "", 8080)); + Assertions.assertThat(URIAuthority.parse("@:")).isEqualTo(new URIAuthority(null, "", -1)); + Assertions.assertThat(URIAuthority.parse("somehost:8080")).isEqualTo(new URIAuthority("somehost", 8080)); + Assertions.assertThat(URIAuthority.parse("somehost:8080/blah")).isEqualTo(new URIAuthority("somehost", 8080)); + Assertions.assertThat(URIAuthority.parse("somehost:8080?blah")).isEqualTo(new URIAuthority("somehost", 8080)); + Assertions.assertThat(URIAuthority.parse("somehost:8080#blah")).isEqualTo(new URIAuthority("somehost", 8080)); + Assertions.assertThat(URIAuthority.parse("somehost:008080")).isEqualTo(new URIAuthority("somehost", 8080)); + Assertions.assertThatThrownBy(() -> + URIAuthority.create("somehost:aaaaa")) + .isInstanceOf(URISyntaxException.class); + Assertions.assertThatThrownBy(() -> + URIAuthority.create("somehost:90ab")) + .isInstanceOf(URISyntaxException.class); + + Assertions.assertThat(URIAuthority.parse("someuser@somehost")).isEqualTo(new URIAuthority("someuser", "somehost", -1)); + Assertions.assertThat(URIAuthority.parse("someuser@somehost/blah")).isEqualTo(new URIAuthority("someuser", "somehost", -1)); + Assertions.assertThat(URIAuthority.parse("someuser@somehost?blah")).isEqualTo(new URIAuthority("someuser", "somehost", -1)); + Assertions.assertThat(URIAuthority.parse("someuser@somehost#blah")).isEqualTo(new URIAuthority("someuser", "somehost", -1)); + + Assertions.assertThat(URIAuthority.parse("someuser@somehost:")).isEqualTo(new URIAuthority("someuser", "somehost", -1)); + Assertions.assertThat(URIAuthority.parse("someuser@somehost:/blah")).isEqualTo(new URIAuthority("someuser", "somehost", -1)); + Assertions.assertThat(URIAuthority.parse("someuser@somehost:?blah")).isEqualTo(new URIAuthority("someuser", "somehost", -1)); + Assertions.assertThat(URIAuthority.parse("someuser@somehost:#blah")).isEqualTo(new URIAuthority("someuser", "somehost", -1)); + + Assertions.assertThat(URIAuthority.parse("someuser@somehost:8080")).isEqualTo(new URIAuthority("someuser", "somehost", 8080)); + Assertions.assertThat(URIAuthority.parse("someuser@somehost:8080/blah")).isEqualTo(new URIAuthority("someuser", "somehost", 8080)); + Assertions.assertThat(URIAuthority.parse("someuser@somehost:8080?blah")).isEqualTo(new URIAuthority("someuser", "somehost", 8080)); + Assertions.assertThat(URIAuthority.parse("someuser@somehost:8080#blah")).isEqualTo(new URIAuthority("someuser", "somehost", 8080)); + Assertions.assertThat(URIAuthority.parse("@somehost:8080")).isEqualTo(new URIAuthority("somehost", 8080)); + Assertions.assertThat(URIAuthority.parse("test:test@localhost:38339")).isEqualTo(new URIAuthority("test:test", "localhost", 38339)); + Assertions.assertThatThrownBy(() -> + URIAuthority.create("blah@goggle.com:80@google.com/")).isInstanceOf(URISyntaxException.class); } @Test void testCreateFromString() throws Exception { - Assertions.assertEquals(new URIAuthority("somehost", 8080), URIAuthority.create("somehost:8080")); - Assertions.assertEquals(new URIAuthority("SomeHost", 8080), URIAuthority.create("SomeHost:8080")); - Assertions.assertEquals(new URIAuthority("somehost", 1234), URIAuthority.create("somehost:1234")); - Assertions.assertEquals(new URIAuthority("somehost", -1), URIAuthority.create("somehost")); - Assertions.assertEquals(new URIAuthority("user", "somehost", -1), URIAuthority.create("user@somehost")); - Assertions.assertThrows(URISyntaxException.class, () -> URIAuthority.create(" host")); - Assertions.assertThrows(URISyntaxException.class, () -> URIAuthority.create("host ")); - Assertions.assertThrows(URISyntaxException.class, () -> URIAuthority.create("host :8080")); - Assertions.assertThrows(URISyntaxException.class, () -> URIAuthority.create("user @ host:8080")); + Assertions.assertThat(URIAuthority.create("somehost:8080")).isEqualTo(new URIAuthority("somehost", 8080)); + Assertions.assertThat(URIAuthority.create("SomeHost:8080")).isEqualTo(new URIAuthority("SomeHost", 8080)); + Assertions.assertThat(URIAuthority.create("somehost:1234")).isEqualTo(new URIAuthority("somehost", 1234)); + Assertions.assertThat(URIAuthority.create("somehost")).isEqualTo(new URIAuthority("somehost", -1)); + Assertions.assertThat(URIAuthority.create("user@somehost")).isEqualTo(new URIAuthority("user", "somehost", -1)); + Assertions.assertThatThrownBy(() -> + URIAuthority.create(" host")) + .isInstanceOf(URISyntaxException.class); + Assertions.assertThatThrownBy(() -> + URIAuthority.create("host ")) + .isInstanceOf(URISyntaxException.class); + Assertions.assertThatThrownBy(() -> + URIAuthority.create("host :8080")) + .isInstanceOf(URISyntaxException.class); + Assertions.assertThatThrownBy(() -> + URIAuthority.create("user @ host:8080")) + .isInstanceOf(URISyntaxException.class); } @Test void testCreateFromIPv6String() throws Exception { - Assertions.assertEquals(new URIAuthority("::1", 8080), URIAuthority.create("[::1]:8080")); - Assertions.assertEquals(new URIAuthority("::1", -1), URIAuthority.create("[::1]")); - Assertions.assertThrows(URISyntaxException.class, () -> URIAuthority.create("::1")); - Assertions.assertThrows(URISyntaxException.class, () -> URIAuthority.create("[::1")); - Assertions.assertThrows(URISyntaxException.class, () -> URIAuthority.create("[a]:8080")); + Assertions.assertThat(URIAuthority.create("[::1]:8080")).isEqualTo(new URIAuthority("::1", 8080)); + Assertions.assertThat(URIAuthority.create("[::1]")).isEqualTo(new URIAuthority("::1", -1)); + Assertions.assertThatThrownBy(() -> + URIAuthority.create("::1")) + .isInstanceOf(URISyntaxException.class); + Assertions.assertThatThrownBy(() -> + URIAuthority.create("[::1")) + .isInstanceOf(URISyntaxException.class); + Assertions.assertThatThrownBy(() -> + URIAuthority.create("[a]:8080")) + .isInstanceOf(URISyntaxException.class); } @Test void testIpv6HostToString() { - Assertions.assertEquals("[::1]:80", new URIAuthority("::1", 80).toString()); - Assertions.assertEquals("user@[::1]:80", new URIAuthority("user", "::1", 80).toString()); - Assertions.assertEquals("[::1]", new URIAuthority("::1", -1).toString()); - Assertions.assertEquals("user@[::1]", new URIAuthority("user", "::1", -1).toString()); + Assertions.assertThat(new URIAuthority("::1", 80).toString()).isEqualTo("[::1]:80"); + Assertions.assertThat(new URIAuthority("user", "::1", 80).toString()).isEqualTo("user@[::1]:80"); + Assertions.assertThat(new URIAuthority("::1", -1).toString()).isEqualTo("[::1]"); + Assertions.assertThat(new URIAuthority("user", "::1", -1).toString()).isEqualTo("user@[::1]"); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/net/TestURIBuilder.java b/httpcore5/src/test/java/org/apache/hc/core5/net/TestURIBuilder.java index fcef8d1254..37b8e8eac8 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/net/TestURIBuilder.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/net/TestURIBuilder.java @@ -39,10 +39,9 @@ import org.apache.hc.core5.http.HttpHost; import org.apache.hc.core5.http.NameValuePair; -import org.apache.hc.core5.http.NameValuePairListMatcher; import org.apache.hc.core5.http.URIScheme; import org.apache.hc.core5.http.message.BasicNameValuePair; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; @SuppressWarnings("deprecation") @@ -57,14 +56,14 @@ static List parsePath(final CharSequence s) { @Test void testParseSegments() { - Assertions.assertEquals(Arrays.asList("this", "that"), parsePath("/this/that")); - Assertions.assertEquals(Arrays.asList("this", "that"), parsePath("this/that")); - Assertions.assertEquals(Arrays.asList("this", "", "that"), parsePath("this//that")); - Assertions.assertEquals(Arrays.asList("this", "", "that", ""), parsePath("this//that/")); - Assertions.assertEquals(Arrays.asList("this", "", "that", "/this and that"), parsePath("this//that/%2fthis%20and%20that")); - Assertions.assertEquals(Arrays.asList("this", "", "", "that", "", ""), parsePath("this///that//")); - Assertions.assertEquals(Collections.singletonList(""), parsePath("/")); - Assertions.assertEquals(Collections.emptyList(), parsePath("")); + Assertions.assertThat(parsePath("/this/that")).isEqualTo(Arrays.asList("this", "that")); + Assertions.assertThat(parsePath("this/that")).isEqualTo(Arrays.asList("this", "that")); + Assertions.assertThat(parsePath("this//that")).isEqualTo(Arrays.asList("this", "", "that")); + Assertions.assertThat(parsePath("this//that/")).isEqualTo(Arrays.asList("this", "", "that", "")); + Assertions.assertThat(parsePath("this//that/%2fthis%20and%20that")).isEqualTo(Arrays.asList("this", "", "that", "/this and that")); + Assertions.assertThat(parsePath("this///that//")).isEqualTo(Arrays.asList("this", "", "", "that", "", "")); + Assertions.assertThat(parsePath("/")).isEqualTo(Collections.singletonList("")); + Assertions.assertThat(parsePath("")).isEqualTo(Collections.emptyList()); } static String formatPath(final String... pathSegments) { @@ -75,12 +74,12 @@ static String formatPath(final String... pathSegments) { @Test void testFormatSegments() { - Assertions.assertEquals("/this/that", formatPath("this", "that")); - Assertions.assertEquals("/this//that", formatPath("this", "", "that")); - Assertions.assertEquals("/this//that/%2Fthis%20and%20that", formatPath("this", "", "that", "/this and that")); - Assertions.assertEquals("/this///that//", formatPath("this", "", "", "that", "", "")); - Assertions.assertEquals("/", formatPath("")); - Assertions.assertEquals("", formatPath()); + Assertions.assertThat(formatPath("this", "that")).isEqualTo("/this/that"); + Assertions.assertThat(formatPath("this", "", "that")).isEqualTo("/this//that"); + Assertions.assertThat(formatPath("this", "", "that", "/this and that")).isEqualTo("/this//that/%2Fthis%20and%20that"); + Assertions.assertThat(formatPath("this", "", "", "that", "", "")).isEqualTo("/this///that//"); + Assertions.assertThat(formatPath("")).isEqualTo("/"); + Assertions.assertThat(formatPath()).isEqualTo(""); } static List parseQuery(final CharSequence s) { @@ -89,30 +88,49 @@ static List parseQuery(final CharSequence s) { @Test void testParseQuery() { - NameValuePairListMatcher.assertEmpty(parseQuery("")); - NameValuePairListMatcher.assertEqualsTo(parseQuery("Name0"), new BasicNameValuePair("Name0", null)); - NameValuePairListMatcher.assertEqualsTo(parseQuery("Name1=Value1"), new BasicNameValuePair("Name1", "Value1")); - NameValuePairListMatcher.assertEqualsTo(parseQuery("Name2="), new BasicNameValuePair("Name2", "")); - NameValuePairListMatcher.assertEqualsTo(parseQuery(" Name3 "), new BasicNameValuePair("Name3", null)); - NameValuePairListMatcher.assertEqualsTo(parseQuery("Name4=Value%204%21"), new BasicNameValuePair("Name4", "Value 4!")); - NameValuePairListMatcher.assertEqualsTo(parseQuery("Name4=Value%2B4%21"), new BasicNameValuePair("Name4", "Value+4!")); - NameValuePairListMatcher.assertEqualsTo(parseQuery("Name4=Value%204%21%20%214"), new BasicNameValuePair("Name4", "Value 4! !4")); - NameValuePairListMatcher.assertEqualsTo(parseQuery("Name5=aaa&Name6=bbb"), - new BasicNameValuePair("Name5", "aaa"), - new BasicNameValuePair("Name6", "bbb")); - NameValuePairListMatcher.assertEqualsTo(parseQuery("Name7=aaa&Name7=b%2Cb&Name7=ccc"), - new BasicNameValuePair("Name7", "aaa"), - new BasicNameValuePair("Name7", "b,b"), - new BasicNameValuePair("Name7", "ccc")); - NameValuePairListMatcher.assertEqualsTo(parseQuery("Name8=xx%2C%20%20yy%20%20%2Czz"), new BasicNameValuePair("Name8", "xx, yy ,zz")); - NameValuePairListMatcher.assertEqualsTo(parseQuery("price=10%20%E2%82%AC"), new BasicNameValuePair("price", "10 \u20AC")); - NameValuePairListMatcher.assertEqualsTo(parseQuery("a=b\"c&d=e"), - new BasicNameValuePair("a", "b\"c"), - new BasicNameValuePair("d", "e")); - NameValuePairListMatcher.assertEqualsTo(parseQuery("russian=" + PercentCodec.encode(RU_HELLO, StandardCharsets.UTF_8) + - "&swiss=" + PercentCodec.encode(CH_HELLO, StandardCharsets.UTF_8)), - new BasicNameValuePair("russian", RU_HELLO), - new BasicNameValuePair("swiss", CH_HELLO)); + Assertions.assertThat(parseQuery("")) + .extracting(nvp -> Assertions.tuple(nvp.getName(), nvp.getValue())) + .isEqualTo(Collections.emptyList()); + Assertions.assertThat(parseQuery("Name0")) + .extracting(nvp -> Assertions.tuple(nvp.getName(), nvp.getValue())) + .isEqualTo(Arrays.asList(Assertions.tuple("Name0", null))); + Assertions.assertThat(parseQuery("Name1=Value1")) + .extracting(nvp -> Assertions.tuple(nvp.getName(), nvp.getValue())) + .isEqualTo(Arrays.asList(Assertions.tuple("Name1", "Value1"))); + Assertions.assertThat(parseQuery("Name2=")) + .extracting(nvp -> Assertions.tuple(nvp.getName(), nvp.getValue())) + .isEqualTo(Arrays.asList(Assertions.tuple("Name2", ""))); + Assertions.assertThat(parseQuery(" Name3 ")) + .extracting(nvp -> Assertions.tuple(nvp.getName(), nvp.getValue())) + .isEqualTo(Arrays.asList(Assertions.tuple("Name3", null))); + Assertions.assertThat(parseQuery("Name4=Value%204%21")) + .extracting(nvp -> Assertions.tuple(nvp.getName(), nvp.getValue())) + .isEqualTo(Arrays.asList(Assertions.tuple("Name4", "Value 4!"))); + Assertions.assertThat(parseQuery("Name4=Value%2B4%21")) + .extracting(nvp -> Assertions.tuple(nvp.getName(), nvp.getValue())) + .isEqualTo(Arrays.asList(Assertions.tuple("Name4", "Value+4!"))); + Assertions.assertThat(parseQuery("Name4=Value%204%21%20%214")) + .extracting(nvp -> Assertions.tuple(nvp.getName(), nvp.getValue())) + .isEqualTo(Arrays.asList(Assertions.tuple("Name4", "Value 4! !4"))); + Assertions.assertThat(parseQuery("Name5=aaa&Name6=bbb")) + .extracting(nvp -> Assertions.tuple(nvp.getName(), nvp.getValue())) + .isEqualTo(Arrays.asList(Assertions.tuple("Name5", "aaa"), Assertions.tuple("Name6", "bbb"))); + Assertions.assertThat(parseQuery("Name7=aaa&Name7=b%2Cb&Name7=ccc")) + .extracting(nvp -> Assertions.tuple(nvp.getName(), nvp.getValue())) + .isEqualTo(Arrays.asList(Assertions.tuple("Name7", "aaa"), Assertions.tuple("Name7", "b,b"), Assertions.tuple("Name7", "ccc"))); + Assertions.assertThat(parseQuery("Name8=xx%2C%20%20yy%20%20%2Czz")) + .extracting(nvp -> Assertions.tuple(nvp.getName(), nvp.getValue())) + .isEqualTo(Arrays.asList(Assertions.tuple("Name8", "xx, yy ,zz"))); + Assertions.assertThat(parseQuery("price=10%20%E2%82%AC")) + .extracting(nvp -> Assertions.tuple(nvp.getName(), nvp.getValue())) + .isEqualTo(Arrays.asList(Assertions.tuple("price", "10 \u20AC"))); + Assertions.assertThat(parseQuery("a=b\"c&d=e")) + .extracting(nvp -> Assertions.tuple(nvp.getName(), nvp.getValue())) + .isEqualTo(Arrays.asList(Assertions.tuple("a", "b\"c"), Assertions.tuple("d", "e"))); + Assertions.assertThat(parseQuery("russian=" + PercentCodec.encode(RU_HELLO, StandardCharsets.UTF_8) + + "&swiss=" + PercentCodec.encode(CH_HELLO, StandardCharsets.UTF_8))) + .extracting(nvp -> Assertions.tuple(nvp.getName(), nvp.getValue())) + .isEqualTo(Arrays.asList(Assertions.tuple("russian", RU_HELLO), Assertions.tuple("swiss", CH_HELLO))); } static String formatQuery(final NameValuePair... params) { @@ -123,25 +141,25 @@ static String formatQuery(final NameValuePair... params) { @Test void testFormatQuery() { - Assertions.assertEquals("Name0", formatQuery(new BasicNameValuePair("Name0", null))); - Assertions.assertEquals("Name1=Value1", formatQuery(new BasicNameValuePair("Name1", "Value1"))); - Assertions.assertEquals("Name2=", formatQuery(new BasicNameValuePair("Name2", ""))); - Assertions.assertEquals("Name4=Value%204%26", formatQuery(new BasicNameValuePair("Name4", "Value 4&"))); - Assertions.assertEquals("Name4=Value%2B4%26", formatQuery(new BasicNameValuePair("Name4", "Value+4&"))); - Assertions.assertEquals("Name4=Value%204%26%20%3D4", formatQuery(new BasicNameValuePair("Name4", "Value 4& =4"))); - Assertions.assertEquals("Name5=aaa&Name6=bbb", formatQuery( + Assertions.assertThat(formatQuery(new BasicNameValuePair("Name0", null))).isEqualTo("Name0"); + Assertions.assertThat(formatQuery(new BasicNameValuePair("Name1", "Value1"))).isEqualTo("Name1=Value1"); + Assertions.assertThat(formatQuery(new BasicNameValuePair("Name2", ""))).isEqualTo("Name2="); + Assertions.assertThat(formatQuery(new BasicNameValuePair("Name4", "Value 4&"))).isEqualTo("Name4=Value%204%26"); + Assertions.assertThat(formatQuery(new BasicNameValuePair("Name4", "Value+4&"))).isEqualTo("Name4=Value%2B4%26"); + Assertions.assertThat(formatQuery(new BasicNameValuePair("Name4", "Value 4& =4"))).isEqualTo("Name4=Value%204%26%20%3D4"); + Assertions.assertThat(formatQuery( new BasicNameValuePair("Name5", "aaa"), - new BasicNameValuePair("Name6", "bbb"))); - Assertions.assertEquals("Name7=aaa&Name7=b%2Cb&Name7=ccc", formatQuery( + new BasicNameValuePair("Name6", "bbb"))).isEqualTo("Name5=aaa&Name6=bbb"); + Assertions.assertThat(formatQuery( new BasicNameValuePair("Name7", "aaa"), new BasicNameValuePair("Name7", "b,b"), new BasicNameValuePair("Name7", "ccc") - )); - Assertions.assertEquals("Name8=xx%2C%20%20yy%20%20%2Czz", formatQuery(new BasicNameValuePair("Name8", "xx, yy ,zz"))); - Assertions.assertEquals("russian=" + PercentCodec.encode(RU_HELLO, StandardCharsets.UTF_8) + - "&swiss=" + PercentCodec.encode(CH_HELLO, StandardCharsets.UTF_8), formatQuery( + )).isEqualTo("Name7=aaa&Name7=b%2Cb&Name7=ccc"); + Assertions.assertThat(formatQuery(new BasicNameValuePair("Name8", "xx, yy ,zz"))).isEqualTo("Name8=xx%2C%20%20yy%20%20%2Czz"); + Assertions.assertThat(formatQuery( new BasicNameValuePair("russian", RU_HELLO), - new BasicNameValuePair("swiss", CH_HELLO))); + new BasicNameValuePair("swiss", CH_HELLO))).isEqualTo("russian=" + PercentCodec.encode(RU_HELLO, StandardCharsets.UTF_8) + + "&swiss=" + PercentCodec.encode(CH_HELLO, StandardCharsets.UTF_8)); } @Test @@ -149,28 +167,28 @@ void testHierarchicalUri() throws Exception { final URI uri = new URI("http", "stuff", "localhost", 80, "/some stuff", "param=stuff", "fragment"); final URIBuilder uribuilder = new URIBuilder(uri).setEncodingPolicy(URIBuilder.EncodingPolicy.ALL_RESERVED); final URI result = uribuilder.build(); - Assertions.assertEquals(new URI("http://stuff@localhost:80/some%20stuff?param=stuff#fragment"), result); + Assertions.assertThat(result).isEqualTo(new URI("http://stuff@localhost:80/some%20stuff?param=stuff#fragment")); } @Test void testMutationRemoveFragment() throws Exception { final URI uri = new URI("http://stuff@localhost:80/stuff?param=stuff#fragment"); final URI result = new URIBuilder(uri).setFragment(null).build(); - Assertions.assertEquals(new URI("http://stuff@localhost:80/stuff?param=stuff"), result); + Assertions.assertThat(result).isEqualTo(new URI("http://stuff@localhost:80/stuff?param=stuff")); } @Test void testMutationRemoveUserInfo() throws Exception { final URI uri = new URI("http://stuff@localhost:80/stuff?param=stuff#fragment"); final URI result = new URIBuilder(uri).setUserInfo(null).build(); - Assertions.assertEquals(new URI("http://localhost:80/stuff?param=stuff#fragment"), result); + Assertions.assertThat(result).isEqualTo(new URI("http://localhost:80/stuff?param=stuff#fragment")); } @Test void testMutationRemovePort() throws Exception { final URI uri = new URI("http://stuff@localhost:80/stuff?param=stuff#fragment"); final URI result = new URIBuilder(uri).setPort(-1).build(); - Assertions.assertEquals(new URI("http://stuff@localhost/stuff?param=stuff#fragment"), result); + Assertions.assertThat(result).isEqualTo(new URI("http://stuff@localhost/stuff?param=stuff#fragment")); } @Test @@ -178,20 +196,20 @@ void testOpaqueUri() throws Exception { final URI uri = new URI("stuff", "some-stuff", "fragment"); final URIBuilder uribuilder = new URIBuilder(uri); final URI result = uribuilder.build(); - Assertions.assertEquals(uri, result); + Assertions.assertThat(result).isEqualTo(uri); } @Test void testOpaqueUriMutation() throws Exception { final URI uri = new URI("stuff", "some-stuff", "fragment"); final URIBuilder uribuilder = new URIBuilder(uri).setCustomQuery("param1¶m2=stuff").setFragment(null); - Assertions.assertEquals(new URI("stuff:?param1¶m2=stuff"), uribuilder.build()); + Assertions.assertThat(uribuilder.build()).isEqualTo(new URI("stuff:?param1¶m2=stuff")); } @Test void testHierarchicalUriMutation() throws Exception { final URIBuilder uribuilder = new URIBuilder("/").setScheme("http").setHost("localhost").setPort(80).setPath("/stuff"); - Assertions.assertEquals(new URI("http://localhost:80/stuff"), uribuilder.build()); + Assertions.assertThat(uribuilder.build()).isEqualTo(new URI("http://localhost:80/stuff")); } @Test @@ -210,11 +228,11 @@ void testLocalhost() throws Exception { .setFragment(specials) .build(); - Assertions.assertEquals(uri.getHost(), bld.getHost()); - Assertions.assertEquals(uri.getUserInfo(), bld.getUserInfo()); - Assertions.assertEquals(uri.getPath(), bld.getPath()); - Assertions.assertEquals(uri.getQuery(), bld.getQuery()); - Assertions.assertEquals(uri.getFragment(), bld.getFragment()); + Assertions.assertThat(bld.getHost()).isEqualTo(uri.getHost()); + Assertions.assertThat(bld.getUserInfo()).isEqualTo(uri.getUserInfo()); + Assertions.assertThat(bld.getPath()).isEqualTo(uri.getPath()); + Assertions.assertThat(bld.getQuery()).isEqualTo(uri.getQuery()); + Assertions.assertThat(bld.getFragment()).isEqualTo(uri.getFragment()); } @Test @@ -233,49 +251,51 @@ void testLoopbackAddress() throws Exception { .setFragment(specials) .build(); - Assertions.assertEquals(uri.getHost(), bld.getHost()); - Assertions.assertEquals(uri.getUserInfo(), bld.getUserInfo()); - Assertions.assertEquals(uri.getPath(), bld.getPath()); - Assertions.assertEquals(uri.getQuery(), bld.getQuery()); - Assertions.assertEquals(uri.getFragment(), bld.getFragment()); + Assertions.assertThat(bld.getHost()).isEqualTo(uri.getHost()); + Assertions.assertThat(bld.getUserInfo()).isEqualTo(uri.getUserInfo()); + Assertions.assertThat(bld.getPath()).isEqualTo(uri.getPath()); + Assertions.assertThat(bld.getQuery()).isEqualTo(uri.getQuery()); + Assertions.assertThat(bld.getFragment()).isEqualTo(uri.getFragment()); } @Test void testEmpty() throws Exception { final URIBuilder uribuilder = new URIBuilder(); final URI result = uribuilder.build(); - Assertions.assertEquals(new URI(""), result); + Assertions.assertThat(result).isEqualTo(new URI("")); } @Test void testEmptyPath() throws Exception { final URIBuilder uribuilder = new URIBuilder("http://thathost"); - Assertions.assertTrue(uribuilder.isPathEmpty()); + Assertions.assertThat(uribuilder.isPathEmpty()).isTrue(); } @Test void testRemoveParameter() throws Exception { final URI uri = new URI("http", null, "localhost", 80, "/", "param=stuff&blah&blah", null); final URIBuilder uribuilder = new URIBuilder(uri); - Assertions.assertFalse(uribuilder.isQueryEmpty()); + Assertions.assertThat(uribuilder.isQueryEmpty()).isFalse(); - Assertions.assertThrows(NullPointerException.class, () -> uribuilder.removeParameter(null)); + Assertions.assertThatThrownBy(() -> + uribuilder.removeParameter(null)) + .isInstanceOf(NullPointerException.class); uribuilder.removeParameter("DoesNotExist"); - Assertions.assertEquals("stuff", uribuilder.getFirstQueryParam("param").getValue()); - Assertions.assertNull(uribuilder.getFirstQueryParam("blah").getValue()); + Assertions.assertThat(uribuilder.getFirstQueryParam("param").getValue()).isEqualTo("stuff"); + Assertions.assertThat(uribuilder.getFirstQueryParam("blah").getValue()).isNull(); uribuilder.removeParameter("blah"); - Assertions.assertEquals("stuff", uribuilder.getFirstQueryParam("param").getValue()); - Assertions.assertNull(uribuilder.getFirstQueryParam("blah")); + Assertions.assertThat(uribuilder.getFirstQueryParam("param").getValue()).isEqualTo("stuff"); + Assertions.assertThat(uribuilder.getFirstQueryParam("blah")).isNull(); uribuilder.removeParameter("param"); - Assertions.assertNull(uribuilder.getFirstQueryParam("param")); - Assertions.assertTrue(uribuilder.isQueryEmpty()); + Assertions.assertThat(uribuilder.getFirstQueryParam("param")).isNull(); + Assertions.assertThat(uribuilder.isQueryEmpty()).isTrue(); uribuilder.removeParameter("AlreadyEmpty"); - Assertions.assertTrue(uribuilder.isQueryEmpty()); - Assertions.assertEquals(new URI("http://localhost:80/"), uribuilder.build()); + Assertions.assertThat(uribuilder.isQueryEmpty()).isTrue(); + Assertions.assertThat(uribuilder.build()).isEqualTo(new URI("http://localhost:80/")); } @Test @@ -283,7 +303,7 @@ void testRemoveQuery() throws Exception { final URI uri = new URI("http", null, "localhost", 80, "/", "param=stuff", null); final URIBuilder uribuilder = new URIBuilder(uri).removeQuery(); final URI result = uribuilder.build(); - Assertions.assertEquals(new URI("http://localhost:80/"), result); + Assertions.assertThat(result).isEqualTo(new URI("http://localhost:80/")); } @Test @@ -291,14 +311,14 @@ void testSetAuthorityFromNamedEndpointHost() throws Exception { final Host host = Host.create("localhost:88"); final URIBuilder uribuilder = new URIBuilder().setScheme(URIScheme.HTTP.id).setAuthority(host); // Check builder - Assertions.assertNull(uribuilder.getUserInfo()); - Assertions.assertEquals(host.getHostName(), uribuilder.getAuthority().getHostName()); - Assertions.assertEquals(host.getHostName(), uribuilder.getHost()); + Assertions.assertThat(uribuilder.getUserInfo()).isNull(); + Assertions.assertThat(uribuilder.getAuthority().getHostName()).isEqualTo(host.getHostName()); + Assertions.assertThat(uribuilder.getHost()).isEqualTo(host.getHostName()); // Check result final URI result = uribuilder.build(); - Assertions.assertEquals(host.getHostName(), result.getHost()); - Assertions.assertEquals(host.getPort(), result.getPort()); - Assertions.assertEquals(new URI("http://localhost:88"), result); + Assertions.assertThat(result.getHost()).isEqualTo(host.getHostName()); + Assertions.assertThat(result.getPort()).isEqualTo(host.getPort()); + Assertions.assertThat(result).isEqualTo(new URI("http://localhost:88")); } @Test @@ -306,14 +326,14 @@ void testSetAuthorityFromNamedEndpointHttpHost() throws Exception { final HttpHost httpHost = HttpHost.create("localhost:88"); final URIBuilder uribuilder = new URIBuilder().setScheme(URIScheme.HTTP.id).setAuthority(httpHost); // Check builder - Assertions.assertNull(uribuilder.getUserInfo()); - Assertions.assertEquals(httpHost.getHostName(), uribuilder.getAuthority().getHostName()); - Assertions.assertEquals(httpHost.getHostName(), uribuilder.getHost()); + Assertions.assertThat(uribuilder.getUserInfo()).isNull(); + Assertions.assertThat(uribuilder.getAuthority().getHostName()).isEqualTo(httpHost.getHostName()); + Assertions.assertThat(uribuilder.getHost()).isEqualTo(httpHost.getHostName()); // Check result final URI result = uribuilder.build(); - Assertions.assertEquals(httpHost.getHostName(), result.getHost()); - Assertions.assertEquals(httpHost.getPort(), result.getPort()); - Assertions.assertEquals(new URI("http://localhost:88"), result); + Assertions.assertThat(result.getHost()).isEqualTo(httpHost.getHostName()); + Assertions.assertThat(result.getPort()).isEqualTo(httpHost.getPort()); + Assertions.assertThat(result).isEqualTo(new URI("http://localhost:88")); } @Test @@ -321,16 +341,16 @@ void testSetAuthorityFromURIAuthority() throws Exception { final URIAuthority authority = URIAuthority.create("u:p@localhost:88"); final URIBuilder uribuilder = new URIBuilder().setScheme(URIScheme.HTTP.id).setAuthority(authority); // Check builder - Assertions.assertEquals(authority.getUserInfo(), uribuilder.getAuthority().getUserInfo()); - Assertions.assertEquals(authority.getHostName(), uribuilder.getAuthority().getHostName()); - Assertions.assertEquals(authority.getHostName(), uribuilder.getHost()); + Assertions.assertThat(uribuilder.getAuthority().getUserInfo()).isEqualTo(authority.getUserInfo()); + Assertions.assertThat(uribuilder.getAuthority().getHostName()).isEqualTo(authority.getHostName()); + Assertions.assertThat(uribuilder.getHost()).isEqualTo(authority.getHostName()); // Check result final URI result = uribuilder.build(); - Assertions.assertEquals(authority.getUserInfo(), result.getUserInfo()); - Assertions.assertEquals(authority.getHostName(), result.getHost()); - Assertions.assertEquals(authority.getPort(), result.getPort()); - Assertions.assertEquals(authority.toString(), result.getAuthority()); - Assertions.assertEquals(new URI("http://u:p@localhost:88"), result); + Assertions.assertThat(result.getUserInfo()).isEqualTo(authority.getUserInfo()); + Assertions.assertThat(result.getHost()).isEqualTo(authority.getHostName()); + Assertions.assertThat(result.getPort()).isEqualTo(authority.getPort()); + Assertions.assertThat(result.getAuthority()).isEqualTo(authority.toString()); + Assertions.assertThat(result).isEqualTo(new URI("http://u:p@localhost:88")); } @Test @@ -340,7 +360,7 @@ void testSetParameter() throws Exception { .setParameter("blah", "blah") .setParameter("blah", "blah2"); final URI result = uribuilder.build(); - Assertions.assertEquals(new URI("http://localhost:80/?param=some%20other%20stuff&blah=blah2"), result); + Assertions.assertThat(result).isEqualTo(new URI("http://localhost:80/?param=some%20other%20stuff&blah=blah2")); } @Test @@ -348,14 +368,14 @@ void testGetFirstNamedParameter() throws Exception { final URI uri = new URI("http", null, "localhost", 80, "/", "param=stuff&blah&blah", null); URIBuilder uribuilder = new URIBuilder(uri).setParameter("param", "some other stuff") .setParameter("blah", "blah"); - Assertions.assertEquals("some other stuff", uribuilder.getFirstQueryParam("param").getValue()); - Assertions.assertEquals("blah", uribuilder.getFirstQueryParam("blah").getValue()); - Assertions.assertNull(uribuilder.getFirstQueryParam("DoesNotExist")); + Assertions.assertThat(uribuilder.getFirstQueryParam("param").getValue()).isEqualTo("some other stuff"); + Assertions.assertThat(uribuilder.getFirstQueryParam("blah").getValue()).isEqualTo("blah"); + Assertions.assertThat(uribuilder.getFirstQueryParam("DoesNotExist")).isNull(); // uribuilder = new URIBuilder("http://localhost:80/?param=some%20other%20stuff&blah=blah&blah=blah2"); - Assertions.assertEquals("blah", uribuilder.getFirstQueryParam("blah").getValue()); + Assertions.assertThat(uribuilder.getFirstQueryParam("blah").getValue()).isEqualTo("blah"); uribuilder.removeQuery(); - Assertions.assertNull(uribuilder.getFirstQueryParam("param")); + Assertions.assertThat(uribuilder.getFirstQueryParam("param")).isNull(); } @Test @@ -363,7 +383,7 @@ void testSetParametersWithEmptyArrayArg() throws Exception { final URI uri = new URI("http", null, "localhost", 80, "/test", "param=test", null); final URIBuilder uribuilder = new URIBuilder(uri).setParameters(); final URI result = uribuilder.build(); - Assertions.assertEquals(new URI("http://localhost:80/test"), result); + Assertions.assertThat(result).isEqualTo(new URI("http://localhost:80/test")); } @Test @@ -371,7 +391,7 @@ void testSetParametersWithNullArrayArg() throws Exception { final URI uri = new URI("http", null, "localhost", 80, "/test", "param=test", null); final URIBuilder uribuilder = new URIBuilder(uri).setParameters((NameValuePair[]) null); final URI result = uribuilder.build(); - Assertions.assertEquals(new URI("http://localhost:80/test"), result); + Assertions.assertThat(result).isEqualTo(new URI("http://localhost:80/test")); } @Test @@ -379,7 +399,7 @@ void testSetParametersWithEmptyList() throws Exception { final URI uri = new URI("http", null, "localhost", 80, "/test", "param=test", null); final URIBuilder uribuilder = new URIBuilder(uri).setParameters(Collections.emptyList()); final URI result = uribuilder.build(); - Assertions.assertEquals(new URI("http://localhost:80/test"), result); + Assertions.assertThat(result).isEqualTo(new URI("http://localhost:80/test")); } @Test @@ -387,7 +407,7 @@ void testSetParametersWithNullList() throws Exception { final URI uri = new URI("http", null, "localhost", 80, "/test", "param=test", null); final URIBuilder uribuilder = new URIBuilder(uri).setParameters((List) null); final URI result = uribuilder.build(); - Assertions.assertEquals(new URI("http://localhost:80/test"), result); + Assertions.assertThat(result).isEqualTo(new URI("http://localhost:80/test")); } @Test @@ -396,8 +416,8 @@ void testParameterWithSpecialChar() throws Exception { final URIBuilder uribuilder = new URIBuilder(uri).addParameter("param", "1 + 1 = 2") .addParameter("param", "blah&blah"); final URI result = uribuilder.build(); - Assertions.assertEquals(new URI("http://localhost:80/?param=stuff¶m=1%20%2B%201%20%3D%202&" + - "param=blah%26blah"), result); + Assertions.assertThat(result).isEqualTo(new URI("http://localhost:80/?param=stuff¶m=1%20%2B%201%20%3D%202&" + + "param=blah%26blah")); } @Test @@ -406,8 +426,8 @@ void testAddParameter() throws Exception { final URIBuilder uribuilder = new URIBuilder(uri).addParameter("param", "some other stuff") .addParameter("blah", "blah"); final URI result = uribuilder.build(); - Assertions.assertEquals(new URI("http://localhost:80/?param=stuff&blah&blah&" + - "param=some%20other%20stuff&blah=blah"), result); + Assertions.assertThat(result).isEqualTo(new URI("http://localhost:80/?param=stuff&blah&blah&" + + "param=some%20other%20stuff&blah=blah")); } @Test @@ -417,7 +437,7 @@ void testQueryEncoding() throws Exception { final URI uri2 = new URIBuilder("https://somehost.com/stuff") .addParameter("client_id", "1234567890") .addParameter("redirect_uri", "https://somehost.com/blah blah/").build(); - Assertions.assertEquals(uri1, uri2); + Assertions.assertThat(uri2).isEqualTo(uri1); } @Test @@ -427,7 +447,7 @@ void testQueryAndParameterEncoding() throws Exception { .setCustomQuery("this&that") .addParameter("param1", "12345") .addParameter("param2", "67890").build(); - Assertions.assertEquals(uri1, uri2); + Assertions.assertThat(uri2).isEqualTo(uri1); } @Test @@ -438,7 +458,7 @@ void testPathEncoding() throws Exception { .setHost("somehost.com") .setPath("/some path with blanks/") .build(); - Assertions.assertEquals(uri1, uri2); + Assertions.assertThat(uri2).isEqualTo(uri1); } @Test @@ -449,7 +469,7 @@ void testFragmentEncoding() throws Exception { .setHost("somehost.com") .setFragment("some fragment with all sorts of $tuff in it!!!") .build(); - Assertions.assertEquals(uri1, uri2); + Assertions.assertThat(uri2).isEqualTo(uri1); } @Test @@ -469,11 +489,11 @@ void testAgainstURI() throws Exception { .setFragment(specials) .build(); - Assertions.assertEquals(uri.getHost(), bld.getHost()); - Assertions.assertEquals(uri.getUserInfo(), bld.getUserInfo()); - Assertions.assertEquals(uri.getPath(), bld.getPath()); - Assertions.assertEquals(uri.getQuery(), bld.getQuery()); - Assertions.assertEquals(uri.getFragment(), bld.getFragment()); + Assertions.assertThat(bld.getHost()).isEqualTo(uri.getHost()); + Assertions.assertThat(bld.getUserInfo()).isEqualTo(uri.getUserInfo()); + Assertions.assertThat(bld.getPath()).isEqualTo(uri.getPath()); + Assertions.assertThat(bld.getQuery()).isEqualTo(uri.getQuery()); + Assertions.assertThat(bld.getFragment()).isEqualTo(uri.getFragment()); } @Test @@ -497,7 +517,7 @@ void assertAddParameters(final Charset charset) throws Exception { .setCharset(charset) .addParameters(null).build(); - Assertions.assertEquals("https://somehost.com/stuff", uri2.toString()); + Assertions.assertThat(uri2.toString()).isEqualTo("https://somehost.com/stuff"); } @Test @@ -524,7 +544,7 @@ void assertBuild(final Charset charset, final URI uri) { final String uriExpected = String.format("https://somehost.com/stuff?parameter1=value1¶meter2=%s¶meter3=%s", encodedData1, encodedData2); - Assertions.assertEquals(uriExpected, uri.toString()); + Assertions.assertThat(uri.toString()).isEqualTo(uriExpected); } private List createParameterList() { @@ -539,24 +559,24 @@ private List createParameterList() { void testMalformedPath() throws Exception { final String path = "@notexample.com/mypath"; final URI uri = new URIBuilder(path).setHost("example.com").build(); - Assertions.assertEquals("example.com", uri.getHost()); + Assertions.assertThat(uri.getHost()).isEqualTo("example.com"); } @Test void testRelativePath() throws Exception { final URI uri = new URIBuilder("./mypath").build(); - Assertions.assertEquals(new URI("./mypath"), uri); + Assertions.assertThat(uri).isEqualTo(new URI("./mypath")); } @Test void testRelativePathWithAuthority() throws Exception { final URI uri = new URIBuilder("./mypath").setHost("somehost").setScheme("http").build(); - Assertions.assertEquals(new URI("http://somehost/./mypath"), uri); + Assertions.assertThat(uri).isEqualTo(new URI("http://somehost/./mypath")); } @Test void testTolerateNullInput() throws Exception { - Assertions.assertEquals(URI.create("//localhost:8443"), new URIBuilder() + Assertions.assertThat(new URIBuilder() .setScheme(null) .setHost("localhost") .setUserInfo(null) @@ -564,12 +584,12 @@ void testTolerateNullInput() throws Exception { .setPath(null) .setCustomQuery(null) .setFragment(null) - .build()); + .build()).isEqualTo(URI.create("//localhost:8443")); } @Test void testTolerateBlankInput() throws Exception { - Assertions.assertEquals(URI.create("//localhost:8443"), new URIBuilder() + Assertions.assertThat(new URIBuilder() .setScheme("") .setHost("localhost") .setUserInfo("") @@ -578,7 +598,7 @@ void testTolerateBlankInput() throws Exception { .setPath("") .setCustomQuery("") .setFragment("") - .build()); + .build()).isEqualTo(URI.create("//localhost:8443")); } @Test @@ -586,21 +606,21 @@ void testHttpHost() throws Exception { final HttpHost httpHost = new HttpHost("http", "example.com", 1234); final URIBuilder uribuilder = new URIBuilder(); uribuilder.setHttpHost(httpHost); - Assertions.assertEquals(URI.create("http://example.com:1234"), uribuilder.build()); + Assertions.assertThat(uribuilder.build()).isEqualTo(URI.create("http://example.com:1234")); } @Test void testSetHostWithReservedChars() throws Exception { final URIBuilder uribuilder = new URIBuilder(); uribuilder.setScheme("http").setHost("!example!.com"); - Assertions.assertEquals(URI.create("http://%21example%21.com"), uribuilder.build()); + Assertions.assertThat(uribuilder.build()).isEqualTo(URI.create("http://%21example%21.com")); } @Test void testGetHostWithReservedChars() throws Exception { final URIBuilder uribuilder = new URIBuilder("http://someuser%21@%21example%21.com/"); - Assertions.assertEquals("!example!.com", uribuilder.getHost()); - Assertions.assertEquals("someuser!", uribuilder.getUserInfo()); + Assertions.assertThat(uribuilder.getHost()).isEqualTo("!example!.com"); + Assertions.assertThat(uribuilder.getUserInfo()).isEqualTo("someuser!"); } @Test @@ -610,7 +630,7 @@ void testMultipleLeadingPathSlashes() throws Exception { .setHost("somehost") .setPath("//blah//blah") .build(); - Assertions.assertEquals(URI.create("ftp://somehost//blah//blah"), uri); + Assertions.assertThat(uri).isEqualTo(URI.create("ftp://somehost//blah//blah")); } @Test @@ -619,7 +639,7 @@ void testNoAuthorityAndPath() throws Exception { .setScheme("file") .setPath("/blah") .build(); - Assertions.assertEquals(URI.create("file:/blah"), uri); + Assertions.assertThat(uri).isEqualTo(URI.create("file:/blah")); } @Test @@ -629,7 +649,7 @@ void testSetPathSegmentList() throws Exception { .setHost("somehost") .setPathSegments(Arrays.asList("api", "products")) .build(); - Assertions.assertEquals(URI.create("https://somehost/api/products"), uri); + Assertions.assertThat(uri).isEqualTo(URI.create("https://somehost/api/products")); } @Test @@ -639,7 +659,7 @@ void testSetPathSegmentsVarargs() throws Exception { .setHost("somehost") .setPathSegments("api", "products") .build(); - Assertions.assertEquals(URI.create("https://somehost/api/products"), uri); + Assertions.assertThat(uri).isEqualTo(URI.create("https://somehost/api/products")); } @Test @@ -648,7 +668,7 @@ void testSetPathSegmentsRootlessList() throws Exception { .setScheme("file") .setPathSegmentsRootless(Arrays.asList("dir", "foo")) .build(); - Assertions.assertEquals(URI.create("file:dir/foo"), uri); + Assertions.assertThat(uri).isEqualTo(URI.create("file:dir/foo")); } @Test @@ -657,7 +677,7 @@ void testSetPathSegmentsRootlessVarargs() throws Exception { .setScheme("file") .setPathSegmentsRootless("dir", "foo") .build(); - Assertions.assertEquals(URI.create("file:dir/foo"), uri); + Assertions.assertThat(uri).isEqualTo(URI.create("file:dir/foo")); } @Test @@ -669,7 +689,7 @@ void testAppendToExistingPath() throws Exception { .appendPath("v1/resources") .appendPath("idA") .build(); - Assertions.assertEquals(URI.create("https://somehost/api/v1/resources/idA"), uri); + Assertions.assertThat(uri).isEqualTo(URI.create("https://somehost/api/v1/resources/idA")); } @Test @@ -680,7 +700,7 @@ void testAppendToNonExistingPath() throws Exception { .appendPath("api/v2/customers") .appendPath("idA") .build(); - Assertions.assertEquals(URI.create("https://somehost/api/v2/customers/idA"), uri); + Assertions.assertThat(uri).isEqualTo(URI.create("https://somehost/api/v2/customers/idA")); } @Test @@ -691,7 +711,7 @@ void testAppendNullToExistingPath() throws Exception { .setPath("api") .appendPath(null) .build(); - Assertions.assertEquals(URI.create("https://somehost/api"), uri); + Assertions.assertThat(uri).isEqualTo(URI.create("https://somehost/api")); } @Test @@ -701,7 +721,7 @@ void testAppendNullToNonExistingPath() throws Exception { .setHost("somehost") .appendPath(null) .build(); - Assertions.assertEquals(URI.create("https://somehost"), uri); + Assertions.assertThat(uri).isEqualTo(URI.create("https://somehost")); } @Test @@ -713,7 +733,7 @@ void testAppendSegmentsVarargsToExistingPath() throws Exception { .appendPathSegments("v3", "products") .appendPathSegments("idA") .build(); - Assertions.assertEquals(URI.create("https://myhost/api/v3/products/idA"), uri); + Assertions.assertThat(uri).isEqualTo(URI.create("https://myhost/api/v3/products/idA")); } @Test @@ -724,7 +744,7 @@ void testAppendSegmentsVarargsToNonExistingPath() throws Exception { .appendPathSegments("api", "v2", "customers") .appendPathSegments("idA") .build(); - Assertions.assertEquals(URI.create("https://somehost/api/v2/customers/idA"), uri); + Assertions.assertThat(uri).isEqualTo(URI.create("https://somehost/api/v2/customers/idA")); } @Test @@ -735,7 +755,7 @@ void testAppendNullSegmentsVarargs() throws Exception { .setHost("somehost") .appendPathSegments(pathSegment) .build(); - Assertions.assertEquals(URI.create("https://somehost/"), uri); + Assertions.assertThat(uri).isEqualTo(URI.create("https://somehost/")); } @Test @@ -746,7 +766,7 @@ void testAppendSegmentsListToExistingPath() throws Exception { .setPath("api") .appendPathSegments(Arrays.asList("v3", "products")) .build(); - Assertions.assertEquals(URI.create("http://myhost/api/v3/products"), uri); + Assertions.assertThat(uri).isEqualTo(URI.create("http://myhost/api/v3/products")); } @Test @@ -756,7 +776,7 @@ void testAppendSegmentsListToNonExistingPath() throws Exception { .setHost("myhost") .appendPathSegments(Arrays.asList("api", "v3", "customers")) .build(); - Assertions.assertEquals(URI.create("http://myhost/api/v3/customers"), uri); + Assertions.assertThat(uri).isEqualTo(URI.create("http://myhost/api/v3/customers")); } @Test @@ -767,7 +787,7 @@ void testAppendNullSegmentsList() throws Exception { .setHost("myhost") .appendPathSegments(pathSegments) .build(); - Assertions.assertEquals(URI.create("http://myhost"), uri); + Assertions.assertThat(uri).isEqualTo(URI.create("http://myhost")); } @Test @@ -776,7 +796,7 @@ void testNoAuthorityAndPathSegments() throws Exception { .setScheme("file") .setPathSegments("this", "that") .build(); - Assertions.assertEquals(URI.create("file:/this/that"), uri); + Assertions.assertThat(uri).isEqualTo(URI.create("file:/this/that")); } @Test @@ -785,7 +805,7 @@ void testNoAuthorityAndRootlessPath() throws Exception { .setScheme("file") .setPath("blah") .build(); - Assertions.assertEquals(URI.create("file:blah"), uri); + Assertions.assertThat(uri).isEqualTo(URI.create("file:blah")); } @Test @@ -794,14 +814,14 @@ void testNoAuthorityAndRootlessPathSegments() throws Exception { .setScheme("file") .setPathSegmentsRootless("this", "that") .build(); - Assertions.assertEquals(URI.create("file:this/that"), uri); + Assertions.assertThat(uri).isEqualTo(URI.create("file:this/that")); } @Test void testOpaque() throws Exception { final URIBuilder uriBuilder = new URIBuilder("http://host.com"); final URI uri = uriBuilder.build(); - Assertions.assertEquals(uri.isOpaque(), uriBuilder.isOpaque()); + Assertions.assertThat(uriBuilder.isOpaque()).isEqualTo(uri.isOpaque()); } @Test @@ -811,20 +831,20 @@ void testAddParameterEncodingEquivalence() throws Exception { final URIBuilder uribuilder = new URIBuilder().setScheme("http").setHost("localhost").setPort(80).setPath("/").addParameter( "param", "stuff with spaces"); final URI result = uribuilder.build(); - Assertions.assertEquals(uri, result); + Assertions.assertThat(result).isEqualTo(uri); } @Test void testSchemeSpecificPartParametersNull() throws Exception { final URIBuilder uribuilder = new URIBuilder("http://host.com").setParameter("par", "parvalue") .setSchemeSpecificPart("", (NameValuePair) null); - Assertions.assertEquals(new URI("http://host.com?par=parvalue"), uribuilder.build()); + Assertions.assertThat(uribuilder.build()).isEqualTo(new URI("http://host.com?par=parvalue")); } @Test void testSchemeSpecificPartSetGet() { final URIBuilder uribuilder = new URIBuilder().setSchemeSpecificPart("specificpart"); - Assertions.assertEquals("specificpart", uribuilder.getSchemeSpecificPart()); + Assertions.assertThat(uribuilder.getSchemeSpecificPart()).isEqualTo("specificpart"); } /** @@ -835,8 +855,8 @@ void testSchemeSpecificPartNameValuePairByRFC6068Sample() throws Exception { final URIBuilder uribuilder = new URIBuilder().setScheme("mailto") .setSchemeSpecificPart("my@email.server", new BasicNameValuePair("subject", "mail subject")); final String result = uribuilder.build().toString(); - Assertions.assertTrue(result.contains("my@email.server"), "mail address as scheme specific part expected"); - Assertions.assertTrue(result.contains("mail%20subject"), "correct parameter encoding expected for that scheme"); + Assertions.assertThat(result.contains("my@email.server")).withFailMessage("mail address as scheme specific part expected").isTrue(); + Assertions.assertThat(result.contains("mail%20subject")).withFailMessage("correct parameter encoding expected for that scheme").isTrue(); } /** @@ -849,55 +869,43 @@ void testSchemeSpecificPartNameValuePairListByRFC6068Sample() throws Exception { final URIBuilder uribuilder = new URIBuilder().setScheme("mailto").setSchemeSpecificPart("my@email.server", parameters); final String result = uribuilder.build().toString(); - Assertions.assertTrue(result.contains("my@email.server"), "mail address as scheme specific part expected"); - Assertions.assertTrue(result.contains("mail%20subject"), "correct parameter encoding expected for that scheme"); + Assertions.assertThat(result.contains("my@email.server")).withFailMessage("mail address as scheme specific part expected").isTrue(); + Assertions.assertThat(result.contains("mail%20subject")).withFailMessage("correct parameter encoding expected for that scheme").isTrue(); } @Test void testOptimize() throws Exception { - Assertions.assertEquals("example://a/b/c/%7Bfoo%7D", - new URIBuilder("eXAMPLE://a/./b/../b/%63/%7bfoo%7d").optimize().build().toASCIIString()); - Assertions.assertEquals("http://www.example.com/%3C", - new URIBuilder("http://www.example.com/%3c").optimize().build().toASCIIString()); - Assertions.assertEquals("http://www.example.com/", - new URIBuilder("HTTP://www.EXAMPLE.com/").optimize().build().toASCIIString()); - Assertions.assertEquals("http://www.example.com/a%2F", - new URIBuilder("http://www.example.com/a%2f").optimize().build().toASCIIString()); - Assertions.assertEquals("http://www.example.com/?a%2F", - new URIBuilder("http://www.example.com/?a%2f").optimize().build().toASCIIString()); - Assertions.assertEquals("http://www.example.com/?q=%26", - new URIBuilder("http://www.example.com/?q=%26").optimize().build().toASCIIString()); - Assertions.assertEquals("http://www.example.com/%23?q=%26", - new URIBuilder("http://www.example.com/%23?q=%26").optimize().build().toASCIIString()); - Assertions.assertEquals("http://www.example.com/blah-%28%20-blah-%20%26%20-blah-%20%29-blah/", - new URIBuilder("http://www.example.com/blah-%28%20-blah-%20&%20-blah-%20)-blah/").optimize().build().toASCIIString()); - Assertions.assertEquals("../../.././", - new URIBuilder("../../.././").optimize().build().toASCIIString()); - Assertions.assertEquals("file:../../.././", - new URIBuilder("file:../../.././").optimize().build().toASCIIString()); - Assertions.assertEquals("http://host/", - new URIBuilder("http://host/../../.././").optimize().build().toASCIIString()); - Assertions.assertEquals("http://host/a/", - new URIBuilder("http://host/a/b/..").optimize().build().toASCIIString()); - Assertions.assertEquals("http://host/a/b/", - new URIBuilder("http://host/a/b/.").optimize().build().toASCIIString()); - Assertions.assertEquals("http://host/a/b/..../...", - new URIBuilder("http://host/a/b/..../...").optimize().build().toASCIIString()); - Assertions.assertThrows(URISyntaxException.class, () -> new URIBuilder("http:///../../.././").optimize().build().toASCIIString()); + Assertions.assertThat(new URIBuilder("eXAMPLE://a/./b/../b/%63/%7bfoo%7d").optimize().build().toASCIIString()).isEqualTo("example://a/b/c/%7Bfoo%7D"); + Assertions.assertThat(new URIBuilder("http://www.example.com/%3c").optimize().build().toASCIIString()).isEqualTo("http://www.example.com/%3C"); + Assertions.assertThat(new URIBuilder("HTTP://www.EXAMPLE.com/").optimize().build().toASCIIString()).isEqualTo("http://www.example.com/"); + Assertions.assertThat(new URIBuilder("http://www.example.com/a%2f").optimize().build().toASCIIString()).isEqualTo("http://www.example.com/a%2F"); + Assertions.assertThat(new URIBuilder("http://www.example.com/?a%2f").optimize().build().toASCIIString()).isEqualTo("http://www.example.com/?a%2F"); + Assertions.assertThat(new URIBuilder("http://www.example.com/?q=%26").optimize().build().toASCIIString()).isEqualTo("http://www.example.com/?q=%26"); + Assertions.assertThat(new URIBuilder("http://www.example.com/%23?q=%26").optimize().build().toASCIIString()).isEqualTo("http://www.example.com/%23?q=%26"); + Assertions.assertThat(new URIBuilder("http://www.example.com/blah-%28%20-blah-%20&%20-blah-%20)-blah/").optimize().build().toASCIIString()).isEqualTo("http://www.example.com/blah-%28%20-blah-%20%26%20-blah-%20%29-blah/"); + Assertions.assertThat(new URIBuilder("../../.././").optimize().build().toASCIIString()).isEqualTo("../../.././"); + Assertions.assertThat(new URIBuilder("file:../../.././").optimize().build().toASCIIString()).isEqualTo("file:../../.././"); + Assertions.assertThat(new URIBuilder("http://host/../../.././").optimize().build().toASCIIString()).isEqualTo("http://host/"); + Assertions.assertThat(new URIBuilder("http://host/a/b/..").optimize().build().toASCIIString()).isEqualTo("http://host/a/"); + Assertions.assertThat(new URIBuilder("http://host/a/b/.").optimize().build().toASCIIString()).isEqualTo("http://host/a/b/"); + Assertions.assertThat(new URIBuilder("http://host/a/b/..../...").optimize().build().toASCIIString()).isEqualTo("http://host/a/b/..../..."); + Assertions.assertThatThrownBy(() -> + new URIBuilder("http:///../../.././").optimize().build().toASCIIString()) + .isInstanceOf(URISyntaxException.class); } @Test void testIpv6Host() throws Exception { final URIBuilder builder = new URIBuilder("https://[::1]:432/path"); final URI uri = builder.build(); - Assertions.assertEquals(432, builder.getPort()); - Assertions.assertEquals(432, uri.getPort()); - Assertions.assertEquals("https", builder.getScheme()); - Assertions.assertEquals("https", uri.getScheme()); - Assertions.assertEquals("::1", builder.getHost()); - Assertions.assertEquals("[::1]", uri.getHost()); - Assertions.assertEquals("/path", builder.getPath()); - Assertions.assertEquals("/path", uri.getPath()); + Assertions.assertThat(builder.getPort()).isEqualTo(432); + Assertions.assertThat(uri.getPort()).isEqualTo(432); + Assertions.assertThat(builder.getScheme()).isEqualTo("https"); + Assertions.assertThat(uri.getScheme()).isEqualTo("https"); + Assertions.assertThat(builder.getHost()).isEqualTo("::1"); + Assertions.assertThat(uri.getHost()).isEqualTo("[::1]"); + Assertions.assertThat(builder.getPath()).isEqualTo("/path"); + Assertions.assertThat(uri.getPath()).isEqualTo("/path"); } @Test @@ -906,28 +914,28 @@ void testIpv6HostWithPortUpdate() throws Exception { // and bypasses the fast/simple path which preserves input. final URIBuilder builder = new URIBuilder("https://[::1]:432/path").setPort(123); final URI uri = builder.build(); - Assertions.assertEquals(123, builder.getPort()); - Assertions.assertEquals(123, uri.getPort()); - Assertions.assertEquals("https", builder.getScheme()); - Assertions.assertEquals("https", uri.getScheme()); - Assertions.assertEquals("::1", builder.getHost()); - Assertions.assertEquals("[::1]", uri.getHost()); - Assertions.assertEquals("/path", builder.getPath()); - Assertions.assertEquals("/path", uri.getPath()); + Assertions.assertThat(builder.getPort()).isEqualTo(123); + Assertions.assertThat(uri.getPort()).isEqualTo(123); + Assertions.assertThat(builder.getScheme()).isEqualTo("https"); + Assertions.assertThat(uri.getScheme()).isEqualTo("https"); + Assertions.assertThat(builder.getHost()).isEqualTo("::1"); + Assertions.assertThat(uri.getHost()).isEqualTo("[::1]"); + Assertions.assertThat(builder.getPath()).isEqualTo("/path"); + Assertions.assertThat(uri.getPath()).isEqualTo("/path"); } @Test void testBuilderWithUnbracketedIpv6Host() throws Exception { final URIBuilder builder = new URIBuilder().setScheme("https").setHost("::1").setPort(443).setPath("/path"); final URI uri = builder.build(); - Assertions.assertEquals("https", builder.getScheme()); - Assertions.assertEquals("https", uri.getScheme()); - Assertions.assertEquals(443, builder.getPort()); - Assertions.assertEquals(443, uri.getPort()); - Assertions.assertEquals("::1", builder.getHost()); - Assertions.assertEquals("[::1]", uri.getHost()); - Assertions.assertEquals("/path", builder.getPath()); - Assertions.assertEquals("/path", uri.getPath()); + Assertions.assertThat(builder.getScheme()).isEqualTo("https"); + Assertions.assertThat(uri.getScheme()).isEqualTo("https"); + Assertions.assertThat(builder.getPort()).isEqualTo(443); + Assertions.assertThat(uri.getPort()).isEqualTo(443); + Assertions.assertThat(builder.getHost()).isEqualTo("::1"); + Assertions.assertThat(uri.getHost()).isEqualTo("[::1]"); + Assertions.assertThat(builder.getPath()).isEqualTo("/path"); + Assertions.assertThat(uri.getPath()).isEqualTo("/path"); } @Test @@ -940,7 +948,7 @@ void testHttpsUriWithEmptyHost() { .setPath("/some stuff") .setParameter("param", "stuff") .setFragment("fragment"); - Assertions.assertThrows(URISyntaxException.class, uribuilder::build); + Assertions.assertThatThrownBy(uribuilder::build).isInstanceOf(URISyntaxException.class); } @Test @@ -953,7 +961,7 @@ void testHttpUriWithEmptyHost() { .setPath("/some stuff") .setParameter("param", "stuff") .setFragment("fragment"); - Assertions.assertThrows(URISyntaxException.class, uribuilder::build); + Assertions.assertThatThrownBy(uribuilder::build).isInstanceOf(URISyntaxException.class); } @Test @@ -962,24 +970,24 @@ void testSetPlusAsBlank() throws Exception { URIBuilder uriBuilder = new URIBuilder("http://localhost?param=hello+world") .setPlusAsBlank(true); List params = uriBuilder.getQueryParams(); - Assertions.assertEquals("hello world", params.get(0).getValue()); + Assertions.assertThat(params.get(0).getValue()).isEqualTo("hello world"); // Case 2: Plus as plus, "+" should remain "+" uriBuilder = new URIBuilder("http://localhost?param=hello+world") .setPlusAsBlank(false); params = uriBuilder.getQueryParams(); - Assertions.assertEquals("hello+world", params.get(0).getValue()); + Assertions.assertThat(params.get(0).getValue()).isEqualTo("hello+world"); // Case 3: '%20' always interpreted as space uriBuilder = new URIBuilder("http://localhost?param=hello%20world") .setPlusAsBlank(true); params = uriBuilder.getQueryParams(); - Assertions.assertEquals("hello world", params.get(0).getValue()); + Assertions.assertThat(params.get(0).getValue()).isEqualTo("hello world"); uriBuilder = new URIBuilder("http://localhost?param=hello%20world") .setPlusAsBlank(false); params = uriBuilder.getQueryParams(); - Assertions.assertEquals("hello world", params.get(0).getValue()); + Assertions.assertThat(params.get(0).getValue()).isEqualTo("hello world"); } @Test @@ -992,11 +1000,11 @@ void testDefaultEncodingPolicy() throws Exception { .setFragment("a/b"); final URI expected = new URI("http://example.com/a%3Ab?key=a%2Fb#a%2Fb"); - Assertions.assertEquals(expected, builder.build()); + Assertions.assertThat(builder.build()).isEqualTo(expected); builder.setEncodingPolicy(URIBuilder.EncodingPolicy.ALL_RESERVED); - Assertions.assertEquals(expected, builder.build()); + Assertions.assertThat(builder.build()).isEqualTo(expected); builder.setEncodingPolicy(null); - Assertions.assertEquals(expected, builder.build()); + Assertions.assertThat(builder.build()).isEqualTo(expected); } @Test @@ -1010,9 +1018,9 @@ void testResetEncodingPolicy() throws Exception { .setFragment("a/b") .setEncodingPolicy(URIBuilder.EncodingPolicy.RFC_3986); - Assertions.assertEquals(new URI("http://user!@example.com/a:b?a/b#a/b"), builder.build()); - Assertions.assertSame(builder, builder.setEncodingPolicy(null)); - Assertions.assertEquals(new URI("http://user%21@example.com/a%3Ab?a%2Fb#a%2Fb"), builder.build()); + Assertions.assertThat(builder.build()).isEqualTo(new URI("http://user!@example.com/a:b?a/b#a/b")); + Assertions.assertThat(builder.setEncodingPolicy(null)).isSameAs(builder); + Assertions.assertThat(builder.build()).isEqualTo(new URI("http://user%21@example.com/a%3Ab?a%2Fb#a%2Fb")); } @Test @@ -1027,7 +1035,7 @@ void testCustomQueryEncoding() throws Exception { .setEncodingPolicy(URIBuilder.EncodingPolicy.RFC_3986) .build(); - Assertions.assertEquals(expectedEncodedQuery, uri.getRawQuery()); + Assertions.assertThat(uri.getRawQuery()).isEqualTo(expectedEncodedQuery); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/net/TestWWWFormCodec.java b/httpcore5/src/test/java/org/apache/hc/core5/net/TestWWWFormCodec.java index 44933476ea..471c9be9d9 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/net/TestWWWFormCodec.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/net/TestWWWFormCodec.java @@ -30,12 +30,12 @@ import java.nio.charset.StandardCharsets; import java.util.Arrays; +import java.util.Collections; import java.util.List; import org.apache.hc.core5.http.NameValuePair; -import org.apache.hc.core5.http.NameValuePairListMatcher; import org.apache.hc.core5.http.message.BasicNameValuePair; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class TestWWWFormCodec { @@ -49,30 +49,49 @@ private static List parse(final String params) { @Test void testParse() { - NameValuePairListMatcher.assertEmpty(parse("")); - NameValuePairListMatcher.assertEqualsTo(parse("Name0"), new BasicNameValuePair("Name0", null)); - NameValuePairListMatcher.assertEqualsTo(parse("Name1=Value1"), new BasicNameValuePair("Name1", "Value1")); - NameValuePairListMatcher.assertEqualsTo(parse("Name2="), new BasicNameValuePair("Name2", "")); - NameValuePairListMatcher.assertEqualsTo(parse(" Name3 "), new BasicNameValuePair("Name3", null)); - NameValuePairListMatcher.assertEqualsTo(parse("Name4=Value%204%21"), new BasicNameValuePair("Name4", "Value 4!")); - NameValuePairListMatcher.assertEqualsTo(parse("Name4=Value%2B4%21"), new BasicNameValuePair("Name4", "Value+4!")); - NameValuePairListMatcher.assertEqualsTo(parse("Name4=Value%204%21%20%214"), new BasicNameValuePair("Name4", "Value 4! !4")); - NameValuePairListMatcher.assertEqualsTo(parse("Name5=aaa&Name6=bbb"), - new BasicNameValuePair("Name5", "aaa"), - new BasicNameValuePair("Name6", "bbb")); - NameValuePairListMatcher.assertEqualsTo(parse("Name7=aaa&Name7=b%2Cb&Name7=ccc"), - new BasicNameValuePair("Name7", "aaa"), - new BasicNameValuePair("Name7", "b,b"), - new BasicNameValuePair("Name7", "ccc")); - NameValuePairListMatcher.assertEqualsTo(parse("Name8=xx%2C%20%20yy%20%20%2Czz"), new BasicNameValuePair("Name8", "xx, yy ,zz")); - NameValuePairListMatcher.assertEqualsTo(parse("price=10%20%E2%82%AC"), new BasicNameValuePair("price", "10 \u20AC")); - NameValuePairListMatcher.assertEqualsTo(parse("a=b\"c&d=e"), - new BasicNameValuePair("a", "b\"c"), - new BasicNameValuePair("d", "e")); - NameValuePairListMatcher.assertEqualsTo(parse("russian=" + PercentCodec.encode(RU_HELLO, StandardCharsets.UTF_8) + - "&swiss=" + PercentCodec.encode(CH_HELLO, StandardCharsets.UTF_8)), - new BasicNameValuePair("russian", RU_HELLO), - new BasicNameValuePair("swiss", CH_HELLO)); + Assertions.assertThat(parse("")) + .extracting(nvp -> Assertions.tuple(nvp.getName(), nvp.getValue())) + .isEqualTo(Collections.emptyList()); + Assertions.assertThat(parse("Name0")) + .extracting(nvp -> Assertions.tuple(nvp.getName(), nvp.getValue())) + .isEqualTo(Arrays.asList(Assertions.tuple("Name0", null))); + Assertions.assertThat(parse("Name1=Value1")) + .extracting(nvp -> Assertions.tuple(nvp.getName(), nvp.getValue())) + .isEqualTo(Arrays.asList(Assertions.tuple("Name1", "Value1"))); + Assertions.assertThat(parse("Name2=")) + .extracting(nvp -> Assertions.tuple(nvp.getName(), nvp.getValue())) + .isEqualTo(Arrays.asList(Assertions.tuple("Name2", ""))); + Assertions.assertThat(parse(" Name3 ")) + .extracting(nvp -> Assertions.tuple(nvp.getName(), nvp.getValue())) + .isEqualTo(Arrays.asList(Assertions.tuple("Name3", null))); + Assertions.assertThat(parse("Name4=Value%204%21")) + .extracting(nvp -> Assertions.tuple(nvp.getName(), nvp.getValue())) + .isEqualTo(Arrays.asList(Assertions.tuple("Name4", "Value 4!"))); + Assertions.assertThat(parse("Name4=Value%2B4%21")) + .extracting(nvp -> Assertions.tuple(nvp.getName(), nvp.getValue())) + .isEqualTo(Arrays.asList(Assertions.tuple("Name4", "Value+4!"))); + Assertions.assertThat(parse("Name4=Value%204%21%20%214")) + .extracting(nvp -> Assertions.tuple(nvp.getName(), nvp.getValue())) + .isEqualTo(Arrays.asList(Assertions.tuple("Name4", "Value 4! !4"))); + Assertions.assertThat(parse("Name5=aaa&Name6=bbb")) + .extracting(nvp -> Assertions.tuple(nvp.getName(), nvp.getValue())) + .isEqualTo(Arrays.asList(Assertions.tuple("Name5", "aaa"), Assertions.tuple("Name6", "bbb"))); + Assertions.assertThat(parse("Name7=aaa&Name7=b%2Cb&Name7=ccc")) + .extracting(nvp -> Assertions.tuple(nvp.getName(), nvp.getValue())) + .isEqualTo(Arrays.asList(Assertions.tuple("Name7", "aaa"), Assertions.tuple("Name7", "b,b"), Assertions.tuple("Name7", "ccc"))); + Assertions.assertThat(parse("Name8=xx%2C%20%20yy%20%20%2Czz")) + .extracting(nvp -> Assertions.tuple(nvp.getName(), nvp.getValue())) + .isEqualTo(Arrays.asList(Assertions.tuple("Name8", "xx, yy ,zz"))); + Assertions.assertThat(parse("price=10%20%E2%82%AC")) + .extracting(nvp -> Assertions.tuple(nvp.getName(), nvp.getValue())) + .isEqualTo(Arrays.asList(Assertions.tuple("price", "10 \u20AC"))); + Assertions.assertThat(parse("a=b\"c&d=e")) + .extracting(nvp -> Assertions.tuple(nvp.getName(), nvp.getValue())) + .isEqualTo(Arrays.asList(Assertions.tuple("a", "b\"c"), Assertions.tuple("d", "e"))); + Assertions.assertThat(parse("russian=" + PercentCodec.encode(RU_HELLO, StandardCharsets.UTF_8) + + "&swiss=" + PercentCodec.encode(CH_HELLO, StandardCharsets.UTF_8))) + .extracting(nvp -> Assertions.tuple(nvp.getName(), nvp.getValue())) + .isEqualTo(Arrays.asList(Assertions.tuple("russian", RU_HELLO), Assertions.tuple("swiss", CH_HELLO))); } private static String format(final NameValuePair... nvps) { @@ -81,25 +100,25 @@ private static String format(final NameValuePair... nvps) { @Test void testFormat() { - Assertions.assertEquals("Name0", format(new BasicNameValuePair("Name0", null))); - Assertions.assertEquals("Name1=Value1", format(new BasicNameValuePair("Name1", "Value1"))); - Assertions.assertEquals("Name2=", format(new BasicNameValuePair("Name2", ""))); - Assertions.assertEquals("Name4=Value+4%26", format(new BasicNameValuePair("Name4", "Value 4&"))); - Assertions.assertEquals("Name4=Value%2B4%26", format(new BasicNameValuePair("Name4", "Value+4&"))); - Assertions.assertEquals("Name4=Value+4%26+%3D4", format(new BasicNameValuePair("Name4", "Value 4& =4"))); - Assertions.assertEquals("Name5=aaa&Name6=bbb", format( + Assertions.assertThat(format(new BasicNameValuePair("Name0", null))).isEqualTo("Name0"); + Assertions.assertThat(format(new BasicNameValuePair("Name1", "Value1"))).isEqualTo("Name1=Value1"); + Assertions.assertThat(format(new BasicNameValuePair("Name2", ""))).isEqualTo("Name2="); + Assertions.assertThat(format(new BasicNameValuePair("Name4", "Value 4&"))).isEqualTo("Name4=Value+4%26"); + Assertions.assertThat(format(new BasicNameValuePair("Name4", "Value+4&"))).isEqualTo("Name4=Value%2B4%26"); + Assertions.assertThat(format(new BasicNameValuePair("Name4", "Value 4& =4"))).isEqualTo("Name4=Value+4%26+%3D4"); + Assertions.assertThat(format( new BasicNameValuePair("Name5", "aaa"), - new BasicNameValuePair("Name6", "bbb"))); - Assertions.assertEquals("Name7=aaa&Name7=b%2Cb&Name7=ccc", format( + new BasicNameValuePair("Name6", "bbb"))).isEqualTo("Name5=aaa&Name6=bbb"); + Assertions.assertThat(format( new BasicNameValuePair("Name7", "aaa"), new BasicNameValuePair("Name7", "b,b"), new BasicNameValuePair("Name7", "ccc") - )); - Assertions.assertEquals("Name8=xx%2C++yy++%2Czz", format(new BasicNameValuePair("Name8", "xx, yy ,zz"))); - Assertions.assertEquals("russian=" + PercentCodec.encode(RU_HELLO, StandardCharsets.UTF_8) + - "&swiss=" + PercentCodec.encode(CH_HELLO, StandardCharsets.UTF_8), format( + )).isEqualTo("Name7=aaa&Name7=b%2Cb&Name7=ccc"); + Assertions.assertThat(format(new BasicNameValuePair("Name8", "xx, yy ,zz"))).isEqualTo("Name8=xx%2C++yy++%2Czz"); + Assertions.assertThat(format( new BasicNameValuePair("russian", RU_HELLO), - new BasicNameValuePair("swiss", CH_HELLO))); + new BasicNameValuePair("swiss", CH_HELLO))).isEqualTo("russian=" + PercentCodec.encode(RU_HELLO, StandardCharsets.UTF_8) + + "&swiss=" + PercentCodec.encode(CH_HELLO, StandardCharsets.UTF_8)); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/pool/TestConnPoolClockInjection.java b/httpcore5/src/test/java/org/apache/hc/core5/pool/TestConnPoolClockInjection.java index 14832b3373..1329bc4bc5 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/pool/TestConnPoolClockInjection.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/pool/TestConnPoolClockInjection.java @@ -26,17 +26,13 @@ */ package org.apache.hc.core5.pool; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static org.junit.jupiter.api.Assertions.assertTrue; - import java.util.concurrent.Future; import java.util.concurrent.TimeUnit; import org.apache.hc.core5.io.CloseMode; import org.apache.hc.core5.util.TimeValue; import org.apache.hc.core5.util.Timeout; +import org.assertj.core.api.Assertions; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.EnumSource; @@ -53,27 +49,27 @@ void closeIdleUsesInjectedClock(final PoolConcurrencyPolicy policy) throws Excep final Future> f1 = pool.lease("r1", null, Timeout.ofSeconds(1), null); final PoolEntry e1 = f1.get(1, TimeUnit.SECONDS); - assertNotNull(e1); + Assertions.assertThat(e1).isNotNull(); final PoolTestSupport.DummyConn conn = new PoolTestSupport.DummyConn(); e1.assignConnection(conn); pool.release(e1, true); pool.closeIdle(TimeValue.ofMilliseconds(1)); - assertFalse(conn.isClosed()); - assertEquals(1, pool.getTotalStats().getAvailable()); - assertEquals(0, pool.getTotalStats().getLeased()); - assertEquals(0, pool.getTotalStats().getPending()); + Assertions.assertThat(conn.isClosed()).isFalse(); + Assertions.assertThat(pool.getTotalStats().getAvailable()).isEqualTo(1); + Assertions.assertThat(pool.getTotalStats().getLeased()).isEqualTo(0); + Assertions.assertThat(pool.getTotalStats().getPending()).isEqualTo(0); clock.advanceMillis(10_000L); pool.closeIdle(TimeValue.ofMilliseconds(1)); - assertEquals(0, pool.getTotalStats().getAvailable()); - assertEquals(0, pool.getTotalStats().getLeased()); - assertEquals(0, pool.getTotalStats().getPending()); + Assertions.assertThat(pool.getTotalStats().getAvailable()).isEqualTo(0); + Assertions.assertThat(pool.getTotalStats().getLeased()).isEqualTo(0); + Assertions.assertThat(pool.getTotalStats().getPending()).isEqualTo(0); if (policy != PoolConcurrencyPolicy.OFFLOCK) { - assertTrue(conn.isClosed()); + Assertions.assertThat(conn.isClosed()).isTrue(); } } finally { pool.close(CloseMode.IMMEDIATE); diff --git a/httpcore5/src/test/java/org/apache/hc/core5/pool/TestConnPoolDeterministicFuzzer.java b/httpcore5/src/test/java/org/apache/hc/core5/pool/TestConnPoolDeterministicFuzzer.java index 21374b1ba1..6edda43126 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/pool/TestConnPoolDeterministicFuzzer.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/pool/TestConnPoolDeterministicFuzzer.java @@ -36,7 +36,7 @@ import org.apache.hc.core5.io.CloseMode; import org.apache.hc.core5.util.TimeValue; import org.apache.hc.core5.util.Timeout; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.Arguments; import org.junit.jupiter.params.provider.MethodSource; @@ -78,10 +78,10 @@ void fuzzSingleThreaded(final PoolConcurrencyPolicy policy, final long seed) thr final int steps = 10_000; - Assertions.assertTrue(pool.getMaxTotal() >= 0); - Assertions.assertTrue(pool.getDefaultMaxPerRoute() >= 0); + Assertions.assertThat(pool.getMaxTotal() >= 0).isTrue(); + Assertions.assertThat(pool.getDefaultMaxPerRoute() >= 0).isTrue(); for (final String route : routes) { - Assertions.assertTrue(pool.getMaxPerRoute(route) >= 0); + Assertions.assertThat(pool.getMaxPerRoute(route) >= 0).isTrue(); } for (int i = 0; i < steps; i++) { @@ -217,35 +217,35 @@ private static void assertCoreInvariants( final PoolStats totals = pool.getTotalStats(); - Assertions.assertTrue(pool.getMaxTotal() >= 0); - Assertions.assertTrue(pool.getDefaultMaxPerRoute() >= 0); + Assertions.assertThat(pool.getMaxTotal() >= 0).isTrue(); + Assertions.assertThat(pool.getDefaultMaxPerRoute() >= 0).isTrue(); - Assertions.assertTrue(totals.getAvailable() >= 0); - Assertions.assertTrue(totals.getLeased() >= 0); - Assertions.assertTrue(totals.getPending() >= 0); - Assertions.assertTrue(totals.getMax() >= 0); + Assertions.assertThat(totals.getAvailable() >= 0).isTrue(); + Assertions.assertThat(totals.getLeased() >= 0).isTrue(); + Assertions.assertThat(totals.getPending() >= 0).isTrue(); + Assertions.assertThat(totals.getMax() >= 0).isTrue(); final long allocated = (long) totals.getAvailable() + (long) totals.getLeased(); - Assertions.assertTrue(allocated <= (long) totals.getMax(), "allocated > max"); + Assertions.assertThat(allocated <= (long) totals.getMax()).withFailMessage("allocated > max").isTrue(); if (policy != PoolConcurrencyPolicy.LAX) { - Assertions.assertTrue(totals.getLeased() <= pool.getMaxTotal(), "leased > max total"); + Assertions.assertThat(totals.getLeased() <= pool.getMaxTotal()).withFailMessage("leased > max total").isTrue(); } - Assertions.assertEquals(leased.size(), totals.getLeased(), "leased count mismatch"); + Assertions.assertThat(totals.getLeased()).withFailMessage("leased count mismatch").isEqualTo(leased.size()); final int expectedPending = pending != null && !pending.isDone() && !pending.isCancelled() ? 1 : 0; - Assertions.assertEquals(expectedPending, totals.getPending(), "pending count mismatch"); + Assertions.assertThat(totals.getPending()).withFailMessage("pending count mismatch").isEqualTo(expectedPending); if (policy != PoolConcurrencyPolicy.LAX) { for (final String route : routes) { final PoolStats routeStats = pool.getStats(route); - Assertions.assertTrue(routeStats.getAvailable() >= 0); - Assertions.assertTrue(routeStats.getLeased() >= 0); - Assertions.assertTrue(routeStats.getPending() >= 0); - Assertions.assertTrue(routeStats.getMax() >= 0); + Assertions.assertThat(routeStats.getAvailable() >= 0).isTrue(); + Assertions.assertThat(routeStats.getLeased() >= 0).isTrue(); + Assertions.assertThat(routeStats.getPending() >= 0).isTrue(); + Assertions.assertThat(routeStats.getMax() >= 0).isTrue(); final long routeAllocated = (long) routeStats.getAvailable() + (long) routeStats.getLeased(); - Assertions.assertTrue(routeAllocated <= (long) routeStats.getMax(), "route allocated > max"); + Assertions.assertThat(routeAllocated <= (long) routeStats.getMax()).withFailMessage("route allocated > max").isTrue(); } } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/pool/TestDefaultDisposalCallback.java b/httpcore5/src/test/java/org/apache/hc/core5/pool/TestDefaultDisposalCallback.java index 59d96e2fce..d1b36c72dc 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/pool/TestDefaultDisposalCallback.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/pool/TestDefaultDisposalCallback.java @@ -31,7 +31,7 @@ import org.apache.hc.core5.http.SocketModalCloseable; import org.apache.hc.core5.io.CloseMode; import org.apache.hc.core5.util.Timeout; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class TestDefaultDisposalCallback { @@ -72,13 +72,13 @@ void setsDefaultTimeoutWhenMissingOrTooLarge() { callback.execute(closeable, CloseMode.IMMEDIATE); - Assertions.assertEquals(Timeout.ofSeconds(1), closeable.getSocketTimeout()); - Assertions.assertEquals(CloseMode.IMMEDIATE, closeable.closedWith.get()); + Assertions.assertThat(closeable.getSocketTimeout()).isEqualTo(Timeout.ofSeconds(1)); + Assertions.assertThat(closeable.closedWith.get()).isEqualTo(CloseMode.IMMEDIATE); final TestCloseable closeableTooLarge = new TestCloseable(Timeout.ofSeconds(5)); callback.execute(closeableTooLarge, CloseMode.GRACEFUL); - Assertions.assertEquals(Timeout.ofSeconds(1), closeableTooLarge.getSocketTimeout()); - Assertions.assertEquals(CloseMode.GRACEFUL, closeableTooLarge.closedWith.get()); + Assertions.assertThat(closeableTooLarge.getSocketTimeout()).isEqualTo(Timeout.ofSeconds(1)); + Assertions.assertThat(closeableTooLarge.closedWith.get()).isEqualTo(CloseMode.GRACEFUL); } @Test @@ -88,8 +88,8 @@ void keepsReasonableTimeout() { callback.execute(closeable, CloseMode.GRACEFUL); - Assertions.assertEquals(Timeout.ofMilliseconds(500), closeable.getSocketTimeout()); - Assertions.assertEquals(CloseMode.GRACEFUL, closeable.closedWith.get()); + Assertions.assertThat(closeable.getSocketTimeout()).isEqualTo(Timeout.ofMilliseconds(500)); + Assertions.assertThat(closeable.closedWith.get()).isEqualTo(CloseMode.GRACEFUL); } @Test @@ -99,7 +99,7 @@ void normalizesZeroOrNegativeTimeout() { callback.execute(closeable, CloseMode.IMMEDIATE); - Assertions.assertEquals(Timeout.ofSeconds(1), closeable.getSocketTimeout()); + Assertions.assertThat(closeable.getSocketTimeout()).isEqualTo(Timeout.ofSeconds(1)); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/pool/TestLaxConnPool.java b/httpcore5/src/test/java/org/apache/hc/core5/pool/TestLaxConnPool.java index c1a7aa20b6..f648eedf4a 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/pool/TestLaxConnPool.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/pool/TestLaxConnPool.java @@ -40,7 +40,7 @@ import org.apache.hc.core5.io.CloseMode; import org.apache.hc.core5.util.TimeValue; import org.apache.hc.core5.util.Timeout; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.mockito.ArgumentMatchers; import org.mockito.Mockito; @@ -51,24 +51,24 @@ class TestLaxConnPool { void testEmptyPool() { try (final LaxConnPool pool = new LaxConnPool<>(2)) { final PoolStats totals = pool.getTotalStats(); - Assertions.assertEquals(0, totals.getAvailable()); - Assertions.assertEquals(0, totals.getLeased()); - Assertions.assertEquals(0, totals.getPending()); - Assertions.assertEquals(0, totals.getMax()); - Assertions.assertEquals(Collections.emptySet(), pool.getRoutes()); + Assertions.assertThat(totals.getAvailable()).isEqualTo(0); + Assertions.assertThat(totals.getLeased()).isEqualTo(0); + Assertions.assertThat(totals.getPending()).isEqualTo(0); + Assertions.assertThat(totals.getMax()).isEqualTo(0); + Assertions.assertThat(pool.getRoutes()).isEqualTo(Collections.emptySet()); final PoolStats stats = pool.getStats("somehost"); - Assertions.assertEquals(0, stats.getAvailable()); - Assertions.assertEquals(0, stats.getLeased()); - Assertions.assertEquals(0, stats.getPending()); - Assertions.assertEquals(2, stats.getMax()); - Assertions.assertEquals("[leased: 0][available: 0][pending: 0]", pool.toString()); + Assertions.assertThat(stats.getAvailable()).isEqualTo(0); + Assertions.assertThat(stats.getLeased()).isEqualTo(0); + Assertions.assertThat(stats.getPending()).isEqualTo(0); + Assertions.assertThat(stats.getMax()).isEqualTo(2); + Assertions.assertThat(pool.toString()).isEqualTo("[leased: 0][available: 0][pending: 0]"); } } @Test void testInvalidConstruction() { - Assertions.assertThrows(IllegalArgumentException.class, () -> - new LaxConnPool(-1)); + Assertions.assertThatThrownBy(() -> + new LaxConnPool(-1)).isInstanceOf(IllegalArgumentException.class); } @Test @@ -83,13 +83,13 @@ void testLeaseRelease() throws Exception { final Future> future3 = pool.lease("otherhost", null); final PoolEntry entry1 = future1.get(); - Assertions.assertNotNull(entry1); + Assertions.assertThat(entry1).isNotNull(); entry1.assignConnection(conn1); final PoolEntry entry2 = future2.get(); - Assertions.assertNotNull(entry2); + Assertions.assertThat(entry2).isNotNull(); entry2.assignConnection(conn2); final PoolEntry entry3 = future3.get(); - Assertions.assertNotNull(entry3); + Assertions.assertThat(entry3).isNotNull(); entry3.assignConnection(conn3); pool.release(entry1, true); @@ -100,9 +100,9 @@ void testLeaseRelease() throws Exception { Mockito.verify(conn3, Mockito.times(1)).close(CloseMode.GRACEFUL); final PoolStats totals = pool.getTotalStats(); - Assertions.assertEquals(2, totals.getAvailable()); - Assertions.assertEquals(0, totals.getLeased()); - Assertions.assertEquals(0, totals.getPending()); + Assertions.assertThat(totals.getAvailable()).isEqualTo(2); + Assertions.assertThat(totals.getLeased()).isEqualTo(0); + Assertions.assertThat(totals.getPending()).isEqualTo(0); } } @@ -139,7 +139,7 @@ void testLeaseReleaseMultiThreaded() throws Exception { }); } - Assertions.assertTrue(latch.await(5, TimeUnit.MINUTES)); + Assertions.assertThat(latch.await(5, TimeUnit.MINUTES)).isTrue(); } finally { executorService.shutdownNow(); } @@ -154,15 +154,18 @@ void testLeaseReleaseMultiThreaded() throws Exception { @Test void testLeaseInvalid() { try (final LaxConnPool pool = new LaxConnPool<>(2)) { - Assertions.assertThrows(NullPointerException.class, - () -> pool.lease(null, null, Timeout.ZERO_MILLISECONDS, null)); + Assertions.assertThatThrownBy(() -> + pool.lease(null, null, Timeout.ZERO_MILLISECONDS, null)) + .isInstanceOf(NullPointerException.class); } } @Test void testReleaseUnknownEntry() { try (final LaxConnPool pool = new LaxConnPool<>(2)) { - Assertions.assertThrows(IllegalStateException.class, () -> pool.release(new PoolEntry<>("somehost"), true)); + Assertions.assertThatThrownBy(() -> + pool.release(new PoolEntry<>("somehost"), true)) + .isInstanceOf(IllegalStateException.class); } } @@ -181,13 +184,13 @@ void testMaxLimits() throws Exception { final Future> future3 = pool.lease("otherhost", null); final PoolEntry entry1 = future1.get(); - Assertions.assertNotNull(entry1); + Assertions.assertThat(entry1).isNotNull(); entry1.assignConnection(conn1); final PoolEntry entry2 = future2.get(); - Assertions.assertNotNull(entry2); + Assertions.assertThat(entry2).isNotNull(); entry2.assignConnection(conn2); final PoolEntry entry3 = future3.get(); - Assertions.assertNotNull(entry3); + Assertions.assertThat(entry3).isNotNull(); entry3.assignConnection(conn3); pool.release(entry1, true); @@ -195,9 +198,9 @@ void testMaxLimits() throws Exception { pool.release(entry3, true); final PoolStats totals = pool.getTotalStats(); - Assertions.assertEquals(3, totals.getAvailable()); - Assertions.assertEquals(0, totals.getLeased()); - Assertions.assertEquals(0, totals.getPending()); + Assertions.assertThat(totals.getAvailable()).isEqualTo(3); + Assertions.assertThat(totals.getLeased()).isEqualTo(0); + Assertions.assertThat(totals.getPending()).isEqualTo(0); final Future> future4 = pool.lease("somehost", null); final Future> future5 = pool.lease("somehost", null); @@ -206,43 +209,43 @@ void testMaxLimits() throws Exception { final Future> future8 = pool.lease("somehost", null); final Future> future9 = pool.lease("otherhost", null); - Assertions.assertTrue(future4.isDone()); + Assertions.assertThat(future4.isDone()).isTrue(); final PoolEntry entry4 = future4.get(); - Assertions.assertNotNull(entry4); - Assertions.assertSame(conn2, entry4.getConnection()); + Assertions.assertThat(entry4).isNotNull(); + Assertions.assertThat(entry4.getConnection()).isSameAs(conn2); - Assertions.assertTrue(future5.isDone()); + Assertions.assertThat(future5.isDone()).isTrue(); final PoolEntry entry5 = future5.get(); - Assertions.assertNotNull(entry5); - Assertions.assertSame(conn1, entry5.getConnection()); + Assertions.assertThat(entry5).isNotNull(); + Assertions.assertThat(entry5.getConnection()).isSameAs(conn1); - Assertions.assertTrue(future6.isDone()); + Assertions.assertThat(future6.isDone()).isTrue(); final PoolEntry entry6 = future6.get(); - Assertions.assertNotNull(entry6); - Assertions.assertSame(conn3, entry6.getConnection()); + Assertions.assertThat(entry6).isNotNull(); + Assertions.assertThat(entry6.getConnection()).isSameAs(conn3); - Assertions.assertFalse(future7.isDone()); - Assertions.assertFalse(future8.isDone()); - Assertions.assertFalse(future9.isDone()); + Assertions.assertThat(future7.isDone()).isFalse(); + Assertions.assertThat(future8.isDone()).isFalse(); + Assertions.assertThat(future9.isDone()).isFalse(); pool.release(entry4, true); pool.release(entry5, false); pool.release(entry6, true); - Assertions.assertTrue(future7.isDone()); + Assertions.assertThat(future7.isDone()).isTrue(); final PoolEntry entry7 = future7.get(); - Assertions.assertNotNull(entry7); - Assertions.assertSame(conn2, entry7.getConnection()); + Assertions.assertThat(entry7).isNotNull(); + Assertions.assertThat(entry7.getConnection()).isSameAs(conn2); - Assertions.assertTrue(future8.isDone()); + Assertions.assertThat(future8.isDone()).isTrue(); final PoolEntry entry8 = future8.get(); - Assertions.assertNotNull(entry8); - Assertions.assertNull(entry8.getConnection()); + Assertions.assertThat(entry8).isNotNull(); + Assertions.assertThat(entry8.getConnection()).isNull(); - Assertions.assertTrue(future9.isDone()); + Assertions.assertThat(future9.isDone()).isTrue(); final PoolEntry entry9 = future9.get(); - Assertions.assertNotNull(entry9); - Assertions.assertSame(conn3, entry9.getConnection()); + Assertions.assertThat(entry9).isNotNull(); + Assertions.assertThat(entry9.getConnection()).isSameAs(conn3); } } @@ -254,9 +257,9 @@ void testCreateNewIfExpired() throws Exception { final Future> future1 = pool.lease("somehost", null); - Assertions.assertTrue(future1.isDone()); + Assertions.assertThat(future1.isDone()).isTrue(); final PoolEntry entry1 = future1.get(); - Assertions.assertNotNull(entry1); + Assertions.assertThat(entry1).isNotNull(); entry1.assignConnection(conn1); entry1.updateExpiry(TimeValue.of(1, TimeUnit.MILLISECONDS)); @@ -266,17 +269,17 @@ void testCreateNewIfExpired() throws Exception { final Future> future2 = pool.lease("somehost", null); - Assertions.assertTrue(future2.isDone()); + Assertions.assertThat(future2.isDone()).isTrue(); Mockito.verify(conn1).close(CloseMode.GRACEFUL); final PoolStats totals = pool.getTotalStats(); - Assertions.assertEquals(0, totals.getAvailable()); - Assertions.assertEquals(1, totals.getLeased()); - Assertions.assertEquals(Collections.singleton("somehost"), pool.getRoutes()); + Assertions.assertThat(totals.getAvailable()).isEqualTo(0); + Assertions.assertThat(totals.getLeased()).isEqualTo(1); + Assertions.assertThat(pool.getRoutes()).isEqualTo(Collections.singleton("somehost")); final PoolStats stats = pool.getStats("somehost"); - Assertions.assertEquals(0, stats.getAvailable()); - Assertions.assertEquals(1, stats.getLeased()); + Assertions.assertThat(stats.getAvailable()).isEqualTo(0); + Assertions.assertThat(stats.getLeased()).isEqualTo(1); } } @@ -290,13 +293,13 @@ void testCloseExpired() throws Exception { final Future> future1 = pool.lease("somehost", null); final Future> future2 = pool.lease("somehost", null); - Assertions.assertTrue(future1.isDone()); + Assertions.assertThat(future1.isDone()).isTrue(); final PoolEntry entry1 = future1.get(); - Assertions.assertNotNull(entry1); + Assertions.assertThat(entry1).isNotNull(); entry1.assignConnection(conn1); - Assertions.assertTrue(future2.isDone()); + Assertions.assertThat(future2.isDone()).isTrue(); final PoolEntry entry2 = future2.get(); - Assertions.assertNotNull(entry2); + Assertions.assertThat(entry2).isNotNull(); entry2.assignConnection(conn2); entry1.updateExpiry(TimeValue.of(1, TimeUnit.MILLISECONDS)); @@ -313,13 +316,13 @@ void testCloseExpired() throws Exception { Mockito.verify(conn2, Mockito.never()).close(ArgumentMatchers.any()); final PoolStats totals = pool.getTotalStats(); - Assertions.assertEquals(1, totals.getAvailable()); - Assertions.assertEquals(0, totals.getLeased()); - Assertions.assertEquals(0, totals.getPending()); + Assertions.assertThat(totals.getAvailable()).isEqualTo(1); + Assertions.assertThat(totals.getLeased()).isEqualTo(0); + Assertions.assertThat(totals.getPending()).isEqualTo(0); final PoolStats stats = pool.getStats("somehost"); - Assertions.assertEquals(1, stats.getAvailable()); - Assertions.assertEquals(0, stats.getLeased()); - Assertions.assertEquals(0, stats.getPending()); + Assertions.assertThat(stats.getAvailable()).isEqualTo(1); + Assertions.assertThat(stats.getLeased()).isEqualTo(0); + Assertions.assertThat(stats.getPending()).isEqualTo(0); } } @@ -333,13 +336,13 @@ void testCloseIdle() throws Exception { final Future> future1 = pool.lease("somehost", null); final Future> future2 = pool.lease("somehost", null); - Assertions.assertTrue(future1.isDone()); + Assertions.assertThat(future1.isDone()).isTrue(); final PoolEntry entry1 = future1.get(); - Assertions.assertNotNull(entry1); + Assertions.assertThat(entry1).isNotNull(); entry1.assignConnection(conn1); - Assertions.assertTrue(future2.isDone()); + Assertions.assertThat(future2.isDone()).isTrue(); final PoolEntry entry2 = future2.get(); - Assertions.assertNotNull(entry2); + Assertions.assertThat(entry2).isNotNull(); entry2.assignConnection(conn2); entry1.updateState(null); @@ -356,28 +359,28 @@ void testCloseIdle() throws Exception { Mockito.verify(conn2, Mockito.never()).close(ArgumentMatchers.any()); PoolStats totals = pool.getTotalStats(); - Assertions.assertEquals(1, totals.getAvailable()); - Assertions.assertEquals(0, totals.getLeased()); - Assertions.assertEquals(0, totals.getPending()); + Assertions.assertThat(totals.getAvailable()).isEqualTo(1); + Assertions.assertThat(totals.getLeased()).isEqualTo(0); + Assertions.assertThat(totals.getPending()).isEqualTo(0); PoolStats stats = pool.getStats("somehost"); - Assertions.assertEquals(1, stats.getAvailable()); - Assertions.assertEquals(0, stats.getLeased()); - Assertions.assertEquals(0, stats.getPending()); + Assertions.assertThat(stats.getAvailable()).isEqualTo(1); + Assertions.assertThat(stats.getLeased()).isEqualTo(0); + Assertions.assertThat(stats.getPending()).isEqualTo(0); pool.closeIdle(TimeValue.of(-1, TimeUnit.MILLISECONDS)); Mockito.verify(conn2).close(CloseMode.GRACEFUL); totals = pool.getTotalStats(); - Assertions.assertEquals(0, totals.getAvailable()); - Assertions.assertEquals(0, totals.getLeased()); - Assertions.assertEquals(0, totals.getPending()); + Assertions.assertThat(totals.getAvailable()).isEqualTo(0); + Assertions.assertThat(totals.getLeased()).isEqualTo(0); + Assertions.assertThat(totals.getPending()).isEqualTo(0); stats = pool.getStats("somehost"); - Assertions.assertEquals(0, stats.getAvailable()); - Assertions.assertEquals(0, stats.getLeased()); - Assertions.assertEquals(0, stats.getPending()); + Assertions.assertThat(stats.getAvailable()).isEqualTo(0); + Assertions.assertThat(stats.getLeased()).isEqualTo(0); + Assertions.assertThat(stats.getPending()).isEqualTo(0); - Assertions.assertFalse(pool.isShutdown()); + Assertions.assertThat(pool.isShutdown()).isFalse(); } } @@ -391,19 +394,19 @@ void testLeaseRequestTimeout() throws Exception { final Future> future2 = pool.lease("somehost", null, Timeout.ofMilliseconds(0), null); final Future> future3 = pool.lease("somehost", null, Timeout.ofMilliseconds(10), null); - Assertions.assertTrue(future1.isDone()); + Assertions.assertThat(future1.isDone()).isTrue(); final PoolEntry entry1 = future1.get(); - Assertions.assertNotNull(entry1); + Assertions.assertThat(entry1).isNotNull(); entry1.assignConnection(conn1); - Assertions.assertFalse(future2.isDone()); - Assertions.assertFalse(future3.isDone()); + Assertions.assertThat(future2.isDone()).isFalse(); + Assertions.assertThat(future3.isDone()).isFalse(); Thread.sleep(100); pool.validatePendingRequests(); - Assertions.assertFalse(future2.isDone()); - Assertions.assertTrue(future3.isDone()); + Assertions.assertThat(future2.isDone()).isFalse(); + Assertions.assertThat(future3.isDone()).isTrue(); } } @@ -414,9 +417,9 @@ void testLeaseRequestCanceled() throws Exception { final Future> future1 = pool.lease("somehost", null, Timeout.ofMilliseconds(0), null); - Assertions.assertTrue(future1.isDone()); + Assertions.assertThat(future1.isDone()).isTrue(); final PoolEntry entry1 = future1.get(); - Assertions.assertNotNull(entry1); + Assertions.assertThat(entry1).isNotNull(); entry1.assignConnection(Mockito.mock(HttpConnection.class)); final Future> future2 = pool.lease("somehost", null, @@ -426,23 +429,29 @@ void testLeaseRequestCanceled() throws Exception { pool.release(entry1, true); final PoolStats totals = pool.getTotalStats(); - Assertions.assertEquals(1, totals.getAvailable()); - Assertions.assertEquals(0, totals.getLeased()); + Assertions.assertThat(totals.getAvailable()).isEqualTo(1); + Assertions.assertThat(totals.getLeased()).isEqualTo(0); } } @Test void testGetStatsInvalid() { try (final LaxConnPool pool = new LaxConnPool<>(2)) { - Assertions.assertThrows(NullPointerException.class, () -> pool.getStats(null)); + Assertions.assertThatThrownBy(() -> + pool.getStats(null)) + .isInstanceOf(NullPointerException.class); } } @Test void testSetMaxInvalid() { try (final LaxConnPool pool = new LaxConnPool<>(2)) { - Assertions.assertThrows(NullPointerException.class, () -> pool.setMaxPerRoute(null, 1)); - Assertions.assertThrows(IllegalArgumentException.class, () -> pool.setDefaultMaxPerRoute(-1)); + Assertions.assertThatThrownBy(() -> + pool.setMaxPerRoute(null, 1)) + .isInstanceOf(NullPointerException.class); + Assertions.assertThatThrownBy(() -> + pool.setDefaultMaxPerRoute(-1)) + .isInstanceOf(IllegalArgumentException.class); } } @@ -450,7 +459,9 @@ void testSetMaxInvalid() { void testShutdown() { final LaxConnPool pool = new LaxConnPool<>(2); pool.close(CloseMode.GRACEFUL); - Assertions.assertThrows(IllegalStateException.class, () -> pool.lease("somehost", null)); + Assertions.assertThatThrownBy(() -> + pool.lease("somehost", null)) + .isInstanceOf(IllegalStateException.class); // Ignored if shut down pool.release(new PoolEntry<>("somehost"), true); } @@ -460,7 +471,9 @@ void testClose() { final LaxConnPool pool = new LaxConnPool<>(2); pool.setMaxPerRoute("someRoute", 2); pool.close(); - Assertions.assertThrows(IllegalStateException.class, () -> pool.lease("someHost", null)); + Assertions.assertThatThrownBy(() -> + pool.lease("someHost", null)) + .isInstanceOf(IllegalStateException.class); // Ignored if shut down pool.release(new PoolEntry<>("someHost"), true); @@ -472,7 +485,7 @@ void testGetMaxPerRoute() { final int max = 2; try (final LaxConnPool pool = new LaxConnPool<>(2)) { pool.setMaxPerRoute(route, max); - Assertions.assertEquals(max, pool.getMaxPerRoute(route)); + Assertions.assertThat(pool.getMaxPerRoute(route)).isEqualTo(max); } } @@ -492,15 +505,15 @@ void testExpiredEntryDeallocatesSlot() throws Exception { // Lease again — the expired entry should be discarded and the slot freed final Future> future2 = pool.lease("somehost", null); - Assertions.assertTrue(future2.isDone()); + Assertions.assertThat(future2.isDone()).isTrue(); final PoolEntry entry2 = future2.get(); - Assertions.assertNotNull(entry2); + Assertions.assertThat(entry2).isNotNull(); // The expired entry was discarded, so a new entry was allocated. // With maxPerRoute=1, this only works if the expired entry's slot was deallocated. final PoolStats stats = pool.getStats("somehost"); - Assertions.assertEquals(1, stats.getLeased()); - Assertions.assertEquals(0, stats.getAvailable()); + Assertions.assertThat(stats.getLeased()).isEqualTo(1); + Assertions.assertThat(stats.getAvailable()).isEqualTo(0); } } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/pool/TestPoolEntry.java b/httpcore5/src/test/java/org/apache/hc/core5/pool/TestPoolEntry.java index cfc6b50c03..35cf70858c 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/pool/TestPoolEntry.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/pool/TestPoolEntry.java @@ -36,7 +36,7 @@ import org.apache.hc.core5.io.CloseMode; import org.apache.hc.core5.util.Deadline; import org.apache.hc.core5.util.TimeValue; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.mockito.Mockito; @@ -81,26 +81,26 @@ void testBasics() { final PoolEntry entry1 = new PoolEntry<>( "route1", TimeValue.of(10L, TimeUnit.MILLISECONDS), clock); - Assertions.assertEquals("route1", entry1.getRoute()); - Assertions.assertEquals(0, entry1.getUpdated()); - Assertions.assertEquals(Deadline.MIN_VALUE, entry1.getExpiryDeadline()); + Assertions.assertThat(entry1.getRoute()).isEqualTo("route1"); + Assertions.assertThat(entry1.getUpdated()).isEqualTo(0); + Assertions.assertThat(entry1.getExpiryDeadline()).isEqualTo(Deadline.MIN_VALUE); entry1.assignConnection(Mockito.mock(HttpConnection.class)); final long now = System.currentTimeMillis(); - Assertions.assertEquals("route1", entry1.getRoute()); - Assertions.assertTrue(now >= entry1.getUpdated()); - Assertions.assertEquals(entry1.getValidityDeadline(), entry1.getExpiryDeadline()); - Assertions.assertEquals(entry1.getUpdated() + 10L, entry1.getValidityDeadline().getValue()); + Assertions.assertThat(entry1.getRoute()).isEqualTo("route1"); + Assertions.assertThat(now >= entry1.getUpdated()).isTrue(); + Assertions.assertThat(entry1.getExpiryDeadline()).isEqualTo(entry1.getValidityDeadline()); + Assertions.assertThat(entry1.getValidityDeadline().getValue()).isEqualTo(entry1.getUpdated() + 10L); entry1.discardConnection(CloseMode.IMMEDIATE); - Assertions.assertEquals(0, entry1.getUpdated()); - Assertions.assertEquals(Deadline.MIN_VALUE, entry1.getExpiryDeadline()); + Assertions.assertThat(entry1.getUpdated()).isEqualTo(0); + Assertions.assertThat(entry1.getExpiryDeadline()).isEqualTo(Deadline.MIN_VALUE); } @Test void testNullConstructor() { - Assertions.assertThrows(NullPointerException.class, () -> - new PoolEntry(null)); + Assertions.assertThatThrownBy(() -> + new PoolEntry(null)).isInstanceOf(NullPointerException.class); } @Test @@ -108,8 +108,8 @@ void testValidInfinitely() { final PoolEntry entry1 = new PoolEntry<>( "route1", TimeValue.ZERO_MILLISECONDS, clock); entry1.assignConnection(Mockito.mock(HttpConnection.class)); - Assertions.assertEquals(Deadline.MAX_VALUE, entry1.getValidityDeadline()); - Assertions.assertEquals(entry1.getValidityDeadline(), entry1.getExpiryDeadline()); + Assertions.assertThat(entry1.getValidityDeadline()).isEqualTo(Deadline.MAX_VALUE); + Assertions.assertThat(entry1.getExpiryDeadline()).isEqualTo(entry1.getValidityDeadline()); } @Test @@ -117,29 +117,29 @@ void testExpiry() { final PoolEntry entry1 = new PoolEntry<>( "route1", TimeValue.ZERO_MILLISECONDS, clock); entry1.assignConnection(Mockito.mock(HttpConnection.class)); - Assertions.assertEquals(Deadline.MAX_VALUE, entry1.getExpiryDeadline()); + Assertions.assertThat(entry1.getExpiryDeadline()).isEqualTo(Deadline.MAX_VALUE); entry1.updateExpiry(TimeValue.of(50L, TimeUnit.MILLISECONDS)); - Assertions.assertEquals(entry1.getUpdated() + 50L, entry1.getExpiryDeadline().getValue()); + Assertions.assertThat(entry1.getExpiryDeadline().getValue()).isEqualTo(entry1.getUpdated() + 50L); entry1.updateExpiry(TimeValue.ZERO_MILLISECONDS); - Assertions.assertEquals(Deadline.MAX_VALUE, entry1.getExpiryDeadline()); + Assertions.assertThat(entry1.getExpiryDeadline()).isEqualTo(Deadline.MAX_VALUE); final PoolEntry entry2 = new PoolEntry<>( "route1", TimeValue.of(100L, TimeUnit.MILLISECONDS), clock); entry2.assignConnection(Mockito.mock(HttpConnection.class)); final Deadline validityDeadline = entry2.getValidityDeadline(); - Assertions.assertEquals(entry2.getUpdated() + 100L, entry2.getExpiryDeadline().getValue()); + Assertions.assertThat(entry2.getExpiryDeadline().getValue()).isEqualTo(entry2.getUpdated() + 100L); entry2.updateExpiry(TimeValue.of(50L, TimeUnit.MILLISECONDS)); - Assertions.assertEquals(entry2.getUpdated() + 50L, entry2.getExpiryDeadline().getValue()); + Assertions.assertThat(entry2.getExpiryDeadline().getValue()).isEqualTo(entry2.getUpdated() + 50L); entry2.updateExpiry(TimeValue.of(150L, TimeUnit.MILLISECONDS)); - Assertions.assertEquals(validityDeadline, entry2.getExpiryDeadline()); + Assertions.assertThat(entry2.getExpiryDeadline()).isEqualTo(validityDeadline); } @Test void testInvalidExpiry() { final PoolEntry entry = new PoolEntry<>( "route1", TimeValue.of(0L, TimeUnit.MILLISECONDS), clock); - Assertions.assertThrows(NullPointerException.class, () -> - entry.updateExpiry(null)); + Assertions.assertThatThrownBy(() -> + entry.updateExpiry(null)).isInstanceOf(NullPointerException.class); } @Test @@ -147,7 +147,7 @@ void testExpiryDoesNotOverflow() { final PoolEntry entry = new PoolEntry<>( "route1", TimeValue.of(Long.MAX_VALUE, TimeUnit.MILLISECONDS), clock); entry.assignConnection(Mockito.mock(HttpConnection.class)); - Assertions.assertEquals(Deadline.MAX_VALUE, entry.getValidityDeadline()); + Assertions.assertThat(entry.getValidityDeadline()).isEqualTo(Deadline.MAX_VALUE); } } \ No newline at end of file diff --git a/httpcore5/src/test/java/org/apache/hc/core5/pool/TestStrictConnPool.java b/httpcore5/src/test/java/org/apache/hc/core5/pool/TestStrictConnPool.java index 201964c878..16af4379a8 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/pool/TestStrictConnPool.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/pool/TestStrictConnPool.java @@ -43,7 +43,8 @@ import org.apache.hc.core5.util.DeadlineTimeoutException; import org.apache.hc.core5.util.TimeValue; import org.apache.hc.core5.util.Timeout; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; +import org.assertj.core.api.InstanceOfAssertFactories; import org.junit.jupiter.api.Test; import org.mockito.ArgumentMatchers; import org.mockito.Mockito; @@ -54,26 +55,26 @@ class TestStrictConnPool { void testEmptyPool() { try (final StrictConnPool pool = new StrictConnPool<>(2, 10)) { final PoolStats totals = pool.getTotalStats(); - Assertions.assertEquals(0, totals.getAvailable()); - Assertions.assertEquals(0, totals.getLeased()); - Assertions.assertEquals(0, totals.getPending()); - Assertions.assertEquals(10, totals.getMax()); - Assertions.assertEquals(Collections.emptySet(), pool.getRoutes()); + Assertions.assertThat(totals.getAvailable()).isEqualTo(0); + Assertions.assertThat(totals.getLeased()).isEqualTo(0); + Assertions.assertThat(totals.getPending()).isEqualTo(0); + Assertions.assertThat(totals.getMax()).isEqualTo(10); + Assertions.assertThat(pool.getRoutes()).isEqualTo(Collections.emptySet()); final PoolStats stats = pool.getStats("somehost"); - Assertions.assertEquals(0, stats.getAvailable()); - Assertions.assertEquals(0, stats.getLeased()); - Assertions.assertEquals(0, stats.getPending()); - Assertions.assertEquals(2, stats.getMax()); - Assertions.assertEquals("[leased: 0][available: 0][pending: 0]", pool.toString()); + Assertions.assertThat(stats.getAvailable()).isEqualTo(0); + Assertions.assertThat(stats.getLeased()).isEqualTo(0); + Assertions.assertThat(stats.getPending()).isEqualTo(0); + Assertions.assertThat(stats.getMax()).isEqualTo(2); + Assertions.assertThat(pool.toString()).isEqualTo("[leased: 0][available: 0][pending: 0]"); } } @Test void testInvalidConstruction() { - Assertions.assertThrows(IllegalArgumentException.class, () -> - new StrictConnPool(-1, 1)); - Assertions.assertThrows(IllegalArgumentException.class, () -> - new StrictConnPool(1, -1)); + Assertions.assertThatThrownBy(() -> + new StrictConnPool(-1, 1)).isInstanceOf(IllegalArgumentException.class); + Assertions.assertThatThrownBy(() -> + new StrictConnPool(1, -1)).isInstanceOf(IllegalArgumentException.class); } @Test @@ -88,13 +89,13 @@ void testLeaseRelease() throws Exception { final Future> future3 = pool.lease("otherhost", null); final PoolEntry entry1 = future1.get(); - Assertions.assertNotNull(entry1); + Assertions.assertThat(entry1).isNotNull(); entry1.assignConnection(conn1); final PoolEntry entry2 = future2.get(); - Assertions.assertNotNull(entry2); + Assertions.assertThat(entry2).isNotNull(); entry2.assignConnection(conn2); final PoolEntry entry3 = future3.get(); - Assertions.assertNotNull(entry3); + Assertions.assertThat(entry3).isNotNull(); entry3.assignConnection(conn3); pool.release(entry1, true); @@ -105,9 +106,9 @@ void testLeaseRelease() throws Exception { Mockito.verify(conn3, Mockito.times(1)).close(CloseMode.GRACEFUL); final PoolStats totals = pool.getTotalStats(); - Assertions.assertEquals(2, totals.getAvailable()); - Assertions.assertEquals(0, totals.getLeased()); - Assertions.assertEquals(0, totals.getPending()); + Assertions.assertThat(totals.getAvailable()).isEqualTo(2); + Assertions.assertThat(totals.getLeased()).isEqualTo(0); + Assertions.assertThat(totals.getPending()).isEqualTo(0); } } @@ -144,7 +145,7 @@ void testLeaseReleaseMultiThreaded() throws Exception { }); } - Assertions.assertTrue(latch.await(5, TimeUnit.MINUTES)); + Assertions.assertThat(latch.await(5, TimeUnit.MINUTES)).isTrue(); } finally { executorService.shutdownNow(); } @@ -159,18 +160,18 @@ void testLeaseReleaseMultiThreaded() throws Exception { @Test void testLeaseInvalid() { try (final StrictConnPool pool = new StrictConnPool<>(2, 10)) { - Assertions.assertThrows(NullPointerException.class, () -> - pool.lease(null, null, Timeout.ZERO_MILLISECONDS, null)); - Assertions.assertThrows(NullPointerException.class, () -> - pool.lease("somehost", null, null, null)); + Assertions.assertThatThrownBy(() -> + pool.lease(null, null, Timeout.ZERO_MILLISECONDS, null)).isInstanceOf(NullPointerException.class); + Assertions.assertThatThrownBy(() -> + pool.lease("somehost", null, null, null)).isInstanceOf(NullPointerException.class); } } @Test void testReleaseUnknownEntry() { try (final StrictConnPool pool = new StrictConnPool<>(2, 2)) { - Assertions.assertThrows(IllegalStateException.class, () -> - pool.release(new PoolEntry<>("somehost"), true)); + Assertions.assertThatThrownBy(() -> + pool.release(new PoolEntry<>("somehost"), true)).isInstanceOf(IllegalStateException.class); } } @@ -190,13 +191,13 @@ void testMaxLimits() throws Exception { final Future> future3 = pool.lease("otherhost", null); final PoolEntry entry1 = future1.get(); - Assertions.assertNotNull(entry1); + Assertions.assertThat(entry1).isNotNull(); entry1.assignConnection(conn1); final PoolEntry entry2 = future2.get(); - Assertions.assertNotNull(entry2); + Assertions.assertThat(entry2).isNotNull(); entry2.assignConnection(conn2); final PoolEntry entry3 = future3.get(); - Assertions.assertNotNull(entry3); + Assertions.assertThat(entry3).isNotNull(); entry3.assignConnection(conn3); pool.release(entry1, true); @@ -204,9 +205,9 @@ void testMaxLimits() throws Exception { pool.release(entry3, true); final PoolStats totals = pool.getTotalStats(); - Assertions.assertEquals(3, totals.getAvailable()); - Assertions.assertEquals(0, totals.getLeased()); - Assertions.assertEquals(0, totals.getPending()); + Assertions.assertThat(totals.getAvailable()).isEqualTo(3); + Assertions.assertThat(totals.getLeased()).isEqualTo(0); + Assertions.assertThat(totals.getPending()).isEqualTo(0); final Future> future4 = pool.lease("somehost", null); final Future> future5 = pool.lease("somehost", null); @@ -215,43 +216,43 @@ void testMaxLimits() throws Exception { final Future> future8 = pool.lease("somehost", null); final Future> future9 = pool.lease("otherhost", null); - Assertions.assertTrue(future4.isDone()); + Assertions.assertThat(future4.isDone()).isTrue(); final PoolEntry entry4 = future4.get(); - Assertions.assertNotNull(entry4); - Assertions.assertSame(conn2, entry4.getConnection()); + Assertions.assertThat(entry4).isNotNull(); + Assertions.assertThat(entry4.getConnection()).isSameAs(conn2); - Assertions.assertTrue(future5.isDone()); + Assertions.assertThat(future5.isDone()).isTrue(); final PoolEntry entry5 = future5.get(); - Assertions.assertNotNull(entry5); - Assertions.assertSame(conn1, entry5.getConnection()); + Assertions.assertThat(entry5).isNotNull(); + Assertions.assertThat(entry5.getConnection()).isSameAs(conn1); - Assertions.assertTrue(future6.isDone()); + Assertions.assertThat(future6.isDone()).isTrue(); final PoolEntry entry6 = future6.get(); - Assertions.assertNotNull(entry6); - Assertions.assertSame(conn3, entry6.getConnection()); + Assertions.assertThat(entry6).isNotNull(); + Assertions.assertThat(entry6.getConnection()).isSameAs(conn3); - Assertions.assertFalse(future7.isDone()); - Assertions.assertFalse(future8.isDone()); - Assertions.assertFalse(future9.isDone()); + Assertions.assertThat(future7.isDone()).isFalse(); + Assertions.assertThat(future8.isDone()).isFalse(); + Assertions.assertThat(future9.isDone()).isFalse(); pool.release(entry4, true); pool.release(entry5, false); pool.release(entry6, true); - Assertions.assertTrue(future7.isDone()); + Assertions.assertThat(future7.isDone()).isTrue(); final PoolEntry entry7 = future7.get(); - Assertions.assertNotNull(entry7); - Assertions.assertSame(conn2, entry7.getConnection()); + Assertions.assertThat(entry7).isNotNull(); + Assertions.assertThat(entry7.getConnection()).isSameAs(conn2); - Assertions.assertTrue(future8.isDone()); + Assertions.assertThat(future8.isDone()).isTrue(); final PoolEntry entry8 = future8.get(); - Assertions.assertNotNull(entry8); - Assertions.assertNull(entry8.getConnection()); + Assertions.assertThat(entry8).isNotNull(); + Assertions.assertThat(entry8.getConnection()).isNull(); - Assertions.assertTrue(future9.isDone()); + Assertions.assertThat(future9.isDone()).isTrue(); final PoolEntry entry9 = future9.get(); - Assertions.assertNotNull(entry9); - Assertions.assertSame(conn3, entry9.getConnection()); + Assertions.assertThat(entry9).isNotNull(); + Assertions.assertThat(entry9.getConnection()).isSameAs(conn3); } } @@ -273,43 +274,43 @@ void testConnectionRedistributionOnTotalMaxLimit() throws Exception { final Future> future3 = pool.lease("otherhost", null); final Future> future4 = pool.lease("otherhost", null); - Assertions.assertTrue(future1.isDone()); + Assertions.assertThat(future1.isDone()).isTrue(); final PoolEntry entry1 = future1.get(); - Assertions.assertNotNull(entry1); - Assertions.assertFalse(entry1.hasConnection()); + Assertions.assertThat(entry1).isNotNull(); + Assertions.assertThat(entry1.hasConnection()).isFalse(); entry1.assignConnection(conn1); - Assertions.assertTrue(future2.isDone()); + Assertions.assertThat(future2.isDone()).isTrue(); final PoolEntry entry2 = future2.get(); - Assertions.assertNotNull(entry2); - Assertions.assertFalse(entry2.hasConnection()); + Assertions.assertThat(entry2).isNotNull(); + Assertions.assertThat(entry2.hasConnection()).isFalse(); entry2.assignConnection(conn2); - Assertions.assertFalse(future3.isDone()); - Assertions.assertFalse(future4.isDone()); + Assertions.assertThat(future3.isDone()).isFalse(); + Assertions.assertThat(future4.isDone()).isFalse(); PoolStats totals = pool.getTotalStats(); - Assertions.assertEquals(0, totals.getAvailable()); - Assertions.assertEquals(2, totals.getLeased()); - Assertions.assertEquals(2, totals.getPending()); + Assertions.assertThat(totals.getAvailable()).isEqualTo(0); + Assertions.assertThat(totals.getLeased()).isEqualTo(2); + Assertions.assertThat(totals.getPending()).isEqualTo(2); pool.release(entry1, true); pool.release(entry2, true); - Assertions.assertTrue(future3.isDone()); + Assertions.assertThat(future3.isDone()).isTrue(); final PoolEntry entry3 = future3.get(); - Assertions.assertNotNull(entry3); - Assertions.assertFalse(entry3.hasConnection()); + Assertions.assertThat(entry3).isNotNull(); + Assertions.assertThat(entry3.hasConnection()).isFalse(); entry3.assignConnection(conn3); - Assertions.assertTrue(future4.isDone()); + Assertions.assertThat(future4.isDone()).isTrue(); final PoolEntry entry4 = future4.get(); - Assertions.assertNotNull(entry4); - Assertions.assertFalse(entry4.hasConnection()); + Assertions.assertThat(entry4).isNotNull(); + Assertions.assertThat(entry4.hasConnection()).isFalse(); entry4.assignConnection(conn4); totals = pool.getTotalStats(); - Assertions.assertEquals(0, totals.getAvailable()); - Assertions.assertEquals(2, totals.getLeased()); - Assertions.assertEquals(0, totals.getPending()); + Assertions.assertThat(totals.getAvailable()).isEqualTo(0); + Assertions.assertThat(totals.getLeased()).isEqualTo(2); + Assertions.assertThat(totals.getPending()).isEqualTo(0); final Future> future5 = pool.lease("somehost", null); final Future> future6 = pool.lease("otherhost", null); @@ -317,29 +318,29 @@ void testConnectionRedistributionOnTotalMaxLimit() throws Exception { pool.release(entry3, true); pool.release(entry4, true); - Assertions.assertTrue(future5.isDone()); + Assertions.assertThat(future5.isDone()).isTrue(); final PoolEntry entry5 = future5.get(); - Assertions.assertNotNull(entry5); - Assertions.assertFalse(entry5.hasConnection()); + Assertions.assertThat(entry5).isNotNull(); + Assertions.assertThat(entry5.hasConnection()).isFalse(); entry5.assignConnection(conn5); - Assertions.assertTrue(future6.isDone()); + Assertions.assertThat(future6.isDone()).isTrue(); final PoolEntry entry6 = future6.get(); - Assertions.assertNotNull(entry6); - Assertions.assertTrue(entry6.hasConnection()); - Assertions.assertSame(conn4, entry6.getConnection()); + Assertions.assertThat(entry6).isNotNull(); + Assertions.assertThat(entry6.hasConnection()).isTrue(); + Assertions.assertThat(entry6.getConnection()).isSameAs(conn4); totals = pool.getTotalStats(); - Assertions.assertEquals(0, totals.getAvailable()); - Assertions.assertEquals(2, totals.getLeased()); - Assertions.assertEquals(0, totals.getPending()); + Assertions.assertThat(totals.getAvailable()).isEqualTo(0); + Assertions.assertThat(totals.getLeased()).isEqualTo(2); + Assertions.assertThat(totals.getPending()).isEqualTo(0); pool.release(entry5, true); pool.release(entry6, true); totals = pool.getTotalStats(); - Assertions.assertEquals(2, totals.getAvailable()); - Assertions.assertEquals(0, totals.getLeased()); - Assertions.assertEquals(0, totals.getPending()); + Assertions.assertThat(totals.getAvailable()).isEqualTo(2); + Assertions.assertThat(totals.getLeased()).isEqualTo(0); + Assertions.assertThat(totals.getPending()).isEqualTo(0); } } @@ -355,19 +356,19 @@ void testStatefulConnectionRedistributionOnPerRouteMaxLimit() throws Exception { final Future> future1 = pool.lease("somehost", null); final Future> future2 = pool.lease("somehost", null); - Assertions.assertTrue(future1.isDone()); + Assertions.assertThat(future1.isDone()).isTrue(); final PoolEntry entry1 = future1.get(); entry1.assignConnection(conn1); - Assertions.assertNotNull(entry1); - Assertions.assertTrue(future2.isDone()); + Assertions.assertThat(entry1).isNotNull(); + Assertions.assertThat(future2.isDone()).isTrue(); final PoolEntry entry2 = future2.get(); - Assertions.assertNotNull(entry2); + Assertions.assertThat(entry2).isNotNull(); entry2.assignConnection(conn2); PoolStats totals = pool.getTotalStats(); - Assertions.assertEquals(0, totals.getAvailable()); - Assertions.assertEquals(2, totals.getLeased()); - Assertions.assertEquals(0, totals.getPending()); + Assertions.assertThat(totals.getAvailable()).isEqualTo(0); + Assertions.assertThat(totals.getLeased()).isEqualTo(2); + Assertions.assertThat(totals.getPending()).isEqualTo(0); entry1.updateState("some-stuff"); pool.release(entry1, true); @@ -377,33 +378,33 @@ void testStatefulConnectionRedistributionOnPerRouteMaxLimit() throws Exception { final Future> future3 = pool.lease("somehost", "some-stuff"); final Future> future4 = pool.lease("somehost", "some-stuff"); - Assertions.assertTrue(future1.isDone()); + Assertions.assertThat(future1.isDone()).isTrue(); final PoolEntry entry3 = future3.get(); - Assertions.assertNotNull(entry3); - Assertions.assertSame(conn2, entry3.getConnection()); - Assertions.assertTrue(future4.isDone()); + Assertions.assertThat(entry3).isNotNull(); + Assertions.assertThat(entry3.getConnection()).isSameAs(conn2); + Assertions.assertThat(future4.isDone()).isTrue(); final PoolEntry entry4 = future4.get(); - Assertions.assertNotNull(entry4); - Assertions.assertSame(conn1, entry4.getConnection()); + Assertions.assertThat(entry4).isNotNull(); + Assertions.assertThat(entry4.getConnection()).isSameAs(conn1); pool.release(entry3, true); pool.release(entry4, true); totals = pool.getTotalStats(); - Assertions.assertEquals(2, totals.getAvailable()); - Assertions.assertEquals(0, totals.getLeased()); - Assertions.assertEquals(0, totals.getPending()); + Assertions.assertThat(totals.getAvailable()).isEqualTo(2); + Assertions.assertThat(totals.getLeased()).isEqualTo(0); + Assertions.assertThat(totals.getPending()).isEqualTo(0); final Future> future5 = pool.lease("somehost", "some-other-stuff"); - Assertions.assertTrue(future5.isDone()); + Assertions.assertThat(future5.isDone()).isTrue(); Mockito.verify(conn2).close(CloseMode.GRACEFUL); Mockito.verify(conn1, Mockito.never()).close(ArgumentMatchers.any()); totals = pool.getTotalStats(); - Assertions.assertEquals(1, totals.getAvailable()); - Assertions.assertEquals(1, totals.getLeased()); + Assertions.assertThat(totals.getAvailable()).isEqualTo(1); + Assertions.assertThat(totals.getLeased()).isEqualTo(1); } } @@ -415,9 +416,9 @@ void testCreateNewIfExpired() throws Exception { final Future> future1 = pool.lease("somehost", null); - Assertions.assertTrue(future1.isDone()); + Assertions.assertThat(future1.isDone()).isTrue(); final PoolEntry entry1 = future1.get(); - Assertions.assertNotNull(entry1); + Assertions.assertThat(entry1).isNotNull(); entry1.assignConnection(conn1); entry1.updateExpiry(TimeValue.of(1, TimeUnit.MILLISECONDS)); @@ -427,17 +428,17 @@ void testCreateNewIfExpired() throws Exception { final Future> future2 = pool.lease("somehost", null); - Assertions.assertTrue(future2.isDone()); + Assertions.assertThat(future2.isDone()).isTrue(); Mockito.verify(conn1).close(CloseMode.GRACEFUL); final PoolStats totals = pool.getTotalStats(); - Assertions.assertEquals(0, totals.getAvailable()); - Assertions.assertEquals(1, totals.getLeased()); - Assertions.assertEquals(Collections.singleton("somehost"), pool.getRoutes()); + Assertions.assertThat(totals.getAvailable()).isEqualTo(0); + Assertions.assertThat(totals.getLeased()).isEqualTo(1); + Assertions.assertThat(pool.getRoutes()).isEqualTo(Collections.singleton("somehost")); final PoolStats stats = pool.getStats("somehost"); - Assertions.assertEquals(0, stats.getAvailable()); - Assertions.assertEquals(1, stats.getLeased()); + Assertions.assertThat(stats.getAvailable()).isEqualTo(0); + Assertions.assertThat(stats.getLeased()).isEqualTo(1); } } @@ -451,13 +452,13 @@ void testCloseExpired() throws Exception { final Future> future1 = pool.lease("somehost", null); final Future> future2 = pool.lease("somehost", null); - Assertions.assertTrue(future1.isDone()); + Assertions.assertThat(future1.isDone()).isTrue(); final PoolEntry entry1 = future1.get(); - Assertions.assertNotNull(entry1); + Assertions.assertThat(entry1).isNotNull(); entry1.assignConnection(conn1); - Assertions.assertTrue(future2.isDone()); + Assertions.assertThat(future2.isDone()).isTrue(); final PoolEntry entry2 = future2.get(); - Assertions.assertNotNull(entry2); + Assertions.assertThat(entry2).isNotNull(); entry2.assignConnection(conn2); entry1.updateExpiry(TimeValue.of(1, TimeUnit.MILLISECONDS)); @@ -474,13 +475,13 @@ void testCloseExpired() throws Exception { Mockito.verify(conn2, Mockito.never()).close(ArgumentMatchers.any()); final PoolStats totals = pool.getTotalStats(); - Assertions.assertEquals(1, totals.getAvailable()); - Assertions.assertEquals(0, totals.getLeased()); - Assertions.assertEquals(0, totals.getPending()); + Assertions.assertThat(totals.getAvailable()).isEqualTo(1); + Assertions.assertThat(totals.getLeased()).isEqualTo(0); + Assertions.assertThat(totals.getPending()).isEqualTo(0); final PoolStats stats = pool.getStats("somehost"); - Assertions.assertEquals(1, stats.getAvailable()); - Assertions.assertEquals(0, stats.getLeased()); - Assertions.assertEquals(0, stats.getPending()); + Assertions.assertThat(stats.getAvailable()).isEqualTo(1); + Assertions.assertThat(stats.getLeased()).isEqualTo(0); + Assertions.assertThat(stats.getPending()).isEqualTo(0); } } @@ -494,13 +495,13 @@ void testCloseIdle() throws Exception { final Future> future1 = pool.lease("somehost", null); final Future> future2 = pool.lease("somehost", null); - Assertions.assertTrue(future1.isDone()); + Assertions.assertThat(future1.isDone()).isTrue(); final PoolEntry entry1 = future1.get(); - Assertions.assertNotNull(entry1); + Assertions.assertThat(entry1).isNotNull(); entry1.assignConnection(conn1); - Assertions.assertTrue(future2.isDone()); + Assertions.assertThat(future2.isDone()).isTrue(); final PoolEntry entry2 = future2.get(); - Assertions.assertNotNull(entry2); + Assertions.assertThat(entry2).isNotNull(); entry2.assignConnection(conn2); entry1.updateState(null); @@ -517,26 +518,26 @@ void testCloseIdle() throws Exception { Mockito.verify(conn2, Mockito.never()).close(ArgumentMatchers.any()); PoolStats totals = pool.getTotalStats(); - Assertions.assertEquals(1, totals.getAvailable()); - Assertions.assertEquals(0, totals.getLeased()); - Assertions.assertEquals(0, totals.getPending()); + Assertions.assertThat(totals.getAvailable()).isEqualTo(1); + Assertions.assertThat(totals.getLeased()).isEqualTo(0); + Assertions.assertThat(totals.getPending()).isEqualTo(0); PoolStats stats = pool.getStats("somehost"); - Assertions.assertEquals(1, stats.getAvailable()); - Assertions.assertEquals(0, stats.getLeased()); - Assertions.assertEquals(0, stats.getPending()); + Assertions.assertThat(stats.getAvailable()).isEqualTo(1); + Assertions.assertThat(stats.getLeased()).isEqualTo(0); + Assertions.assertThat(stats.getPending()).isEqualTo(0); pool.closeIdle(TimeValue.of(-1, TimeUnit.MILLISECONDS)); Mockito.verify(conn2).close(CloseMode.GRACEFUL); totals = pool.getTotalStats(); - Assertions.assertEquals(0, totals.getAvailable()); - Assertions.assertEquals(0, totals.getLeased()); - Assertions.assertEquals(0, totals.getPending()); + Assertions.assertThat(totals.getAvailable()).isEqualTo(0); + Assertions.assertThat(totals.getLeased()).isEqualTo(0); + Assertions.assertThat(totals.getPending()).isEqualTo(0); stats = pool.getStats("somehost"); - Assertions.assertEquals(0, stats.getAvailable()); - Assertions.assertEquals(0, stats.getLeased()); - Assertions.assertEquals(0, stats.getPending()); + Assertions.assertThat(stats.getAvailable()).isEqualTo(0); + Assertions.assertThat(stats.getLeased()).isEqualTo(0); + Assertions.assertThat(stats.getPending()).isEqualTo(0); } } @@ -550,19 +551,19 @@ void testLeaseRequestTimeout() throws Exception { final Future> future2 = pool.lease("somehost", null, Timeout.ofMilliseconds(0), null); final Future> future3 = pool.lease("somehost", null, Timeout.ofMilliseconds(10), null); - Assertions.assertTrue(future1.isDone()); + Assertions.assertThat(future1.isDone()).isTrue(); final PoolEntry entry1 = future1.get(); - Assertions.assertNotNull(entry1); + Assertions.assertThat(entry1).isNotNull(); entry1.assignConnection(conn1); - Assertions.assertFalse(future2.isDone()); - Assertions.assertFalse(future3.isDone()); + Assertions.assertThat(future2.isDone()).isFalse(); + Assertions.assertThat(future3.isDone()).isFalse(); Thread.sleep(100); pool.validatePendingRequests(); - Assertions.assertFalse(future2.isDone()); - Assertions.assertTrue(future3.isDone()); + Assertions.assertThat(future2.isDone()).isFalse(); + Assertions.assertThat(future3.isDone()).isTrue(); } } @@ -593,9 +594,9 @@ void testLeaseRequestLockTimeout() throws Exception { // Attempt to get a connection while lock is held final Future> future2 = pool.lease("somehost", null, Timeout.ofMilliseconds(10), null); - final ExecutionException executionException = Assertions.assertThrows(ExecutionException.class, () -> - future2.get()); - Assertions.assertInstanceOf(DeadlineTimeoutException.class, executionException.getCause()); + final ExecutionException executionException = Assertions.assertThatThrownBy(() -> + future2.get()).isInstanceOf(ExecutionException.class).asInstanceOf(InstanceOfAssertFactories.type(ExecutionException.class)).actual(); + Assertions.assertThat(executionException.getCause()).isInstanceOf(DeadlineTimeoutException.class); holdInternalLock.interrupt(); // Cleanup } @@ -612,8 +613,10 @@ void testLeaseRequestInterrupted() throws Exception { // Attempt to get a connection while lock is held and thread is interrupted final Future> future2 = pool.lease("somehost", null, Timeout.ofMilliseconds(10), null); - Assertions.assertTrue(Thread.interrupted()); - Assertions.assertThrows(CancellationException.class, () -> future2.get()); + Assertions.assertThat(Thread.interrupted()).isTrue(); + Assertions.assertThatThrownBy(() -> + future2.get()) + .isInstanceOf(CancellationException.class); holdInternalLock.interrupt(); // Cleanup } @@ -624,9 +627,9 @@ void testLeaseRequestCanceled() throws Exception { final Future> future1 = pool.lease("somehost", null, Timeout.ofMilliseconds(0), null); - Assertions.assertTrue(future1.isDone()); + Assertions.assertThat(future1.isDone()).isTrue(); final PoolEntry entry1 = future1.get(); - Assertions.assertNotNull(entry1); + Assertions.assertThat(entry1).isNotNull(); entry1.assignConnection(Mockito.mock(HttpConnection.class)); final Future> future2 = pool.lease("somehost", null, @@ -636,27 +639,29 @@ void testLeaseRequestCanceled() throws Exception { pool.release(entry1, true); final PoolStats totals = pool.getTotalStats(); - Assertions.assertEquals(1, totals.getAvailable()); - Assertions.assertEquals(0, totals.getLeased()); + Assertions.assertThat(totals.getAvailable()).isEqualTo(1); + Assertions.assertThat(totals.getLeased()).isEqualTo(0); } } @Test void testGetStatsInvalid() { try (final StrictConnPool pool = new StrictConnPool<>(2, 2)) { - Assertions.assertThrows(NullPointerException.class, () -> pool.getStats(null)); + Assertions.assertThatThrownBy(() -> + pool.getStats(null)) + .isInstanceOf(NullPointerException.class); } } @Test void testSetMaxInvalid() { try (final StrictConnPool pool = new StrictConnPool<>(2, 2)) { - Assertions.assertThrows(IllegalArgumentException.class, () -> - pool.setMaxTotal(-1)); - Assertions.assertThrows(NullPointerException.class, () -> - pool.setMaxPerRoute(null, 1)); - Assertions.assertThrows(IllegalArgumentException.class, () -> - pool.setDefaultMaxPerRoute(-1)); + Assertions.assertThatThrownBy(() -> + pool.setMaxTotal(-1)).isInstanceOf(IllegalArgumentException.class); + Assertions.assertThatThrownBy(() -> + pool.setMaxPerRoute(null, 1)).isInstanceOf(NullPointerException.class); + Assertions.assertThatThrownBy(() -> + pool.setDefaultMaxPerRoute(-1)).isInstanceOf(IllegalArgumentException.class); } } @@ -664,11 +669,11 @@ void testSetMaxInvalid() { void testSetMaxPerRoute() { try (final StrictConnPool pool = new StrictConnPool<>(2, 2)) { pool.setMaxPerRoute("somehost", 1); - Assertions.assertEquals(1, pool.getMaxPerRoute("somehost")); + Assertions.assertThat(pool.getMaxPerRoute("somehost")).isEqualTo(1); pool.setMaxPerRoute("somehost", 0); - Assertions.assertEquals(0, pool.getMaxPerRoute("somehost")); + Assertions.assertThat(pool.getMaxPerRoute("somehost")).isEqualTo(0); pool.setMaxPerRoute("somehost", -1); - Assertions.assertEquals(2, pool.getMaxPerRoute("somehost")); + Assertions.assertThat(pool.getMaxPerRoute("somehost")).isEqualTo(2); } } @@ -676,7 +681,9 @@ void testSetMaxPerRoute() { void testShutdown() { final StrictConnPool pool = new StrictConnPool<>(2, 2); pool.close(CloseMode.GRACEFUL); - Assertions.assertThrows(IllegalStateException.class, () -> pool.lease("somehost", null)); + Assertions.assertThatThrownBy(() -> + pool.lease("somehost", null)) + .isInstanceOf(IllegalStateException.class); // Ignored if shut down pool.release(new PoolEntry<>("somehost"), true); } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/pool/TestStrictConnPoolLeaseTimeoutRace.java b/httpcore5/src/test/java/org/apache/hc/core5/pool/TestStrictConnPoolLeaseTimeoutRace.java index f2a19a6b5f..faf9f76bc0 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/pool/TestStrictConnPoolLeaseTimeoutRace.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/pool/TestStrictConnPoolLeaseTimeoutRace.java @@ -42,7 +42,7 @@ import org.apache.hc.core5.io.CloseMode; import org.apache.hc.core5.util.TimeValue; import org.apache.hc.core5.util.Timeout; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.MethodSource; @@ -144,12 +144,12 @@ void testLeaseTimeoutDoesNotLeakLeasedEntries(final PoolCase poolCase) throws Ex }); } - Assertions.assertTrue(countDownLatch.await(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit())); - Assertions.assertTrue(n.get() <= 0); - Assertions.assertNull(unexpectedException.get()); + Assertions.assertThat(countDownLatch.await(TIMEOUT.getDuration(), TIMEOUT.getTimeUnit())).isTrue(); + Assertions.assertThat(n.get() <= 0).isTrue(); + Assertions.assertThat(unexpectedException.get()).isNull(); final PoolStats stats = pool.getStats(route); - Assertions.assertEquals(0, stats.getLeased()); + Assertions.assertThat(stats.getLeased()).isEqualTo(0); } finally { executorService.shutdownNow(); diff --git a/httpcore5/src/test/java/org/apache/hc/core5/reactor/IOReactorConfigTest.java b/httpcore5/src/test/java/org/apache/hc/core5/reactor/IOReactorConfigTest.java index ff1bb120bf..aa2ad85310 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/reactor/IOReactorConfigTest.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/reactor/IOReactorConfigTest.java @@ -30,7 +30,7 @@ import org.apache.hc.core5.util.TimeValue; import org.apache.hc.core5.util.Timeout; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class IOReactorConfigTest { @@ -56,22 +56,22 @@ void testCustomIOReactorConfig() { .setSocksProxyPassword("socksProxyPassword") .build(); - Assertions.assertEquals(TimeValue.ofMilliseconds(500), reactorConfig.getSelectInterval()); - Assertions.assertEquals(2, reactorConfig.getIoThreadCount()); - Assertions.assertEquals(Timeout.ofSeconds(10), reactorConfig.getSoTimeout()); - Assertions.assertTrue(reactorConfig.isSoReuseAddress()); - Assertions.assertEquals(TimeValue.ofSeconds(30), reactorConfig.getSoLinger()); - Assertions.assertTrue(reactorConfig.isSoKeepAlive()); - Assertions.assertFalse(reactorConfig.isTcpNoDelay()); - Assertions.assertEquals(0x02, reactorConfig.getTrafficClass()); - Assertions.assertEquals(32767, reactorConfig.getSndBufSize()); - Assertions.assertEquals(8192, reactorConfig.getRcvBufSize()); - Assertions.assertEquals(5, reactorConfig.getBacklogSize()); - Assertions.assertEquals(100, reactorConfig.getTcpKeepIdle()); - Assertions.assertEquals(12, reactorConfig.getTcpKeepInterval()); - Assertions.assertEquals(4, reactorConfig.getTcpKeepCount()); - Assertions.assertEquals(new InetSocketAddress(8888), reactorConfig.getSocksProxyAddress()); - Assertions.assertEquals("socksProxyUsername", reactorConfig.getSocksProxyUsername()); - Assertions.assertEquals("socksProxyPassword", reactorConfig.getSocksProxyPassword()); + Assertions.assertThat(reactorConfig.getSelectInterval()).isEqualTo(TimeValue.ofMilliseconds(500)); + Assertions.assertThat(reactorConfig.getIoThreadCount()).isEqualTo(2); + Assertions.assertThat(reactorConfig.getSoTimeout()).isEqualTo(Timeout.ofSeconds(10)); + Assertions.assertThat(reactorConfig.isSoReuseAddress()).isTrue(); + Assertions.assertThat(reactorConfig.getSoLinger()).isEqualTo(TimeValue.ofSeconds(30)); + Assertions.assertThat(reactorConfig.isSoKeepAlive()).isTrue(); + Assertions.assertThat(reactorConfig.isTcpNoDelay()).isFalse(); + Assertions.assertThat(reactorConfig.getTrafficClass()).isEqualTo(0x02); + Assertions.assertThat(reactorConfig.getSndBufSize()).isEqualTo(32767); + Assertions.assertThat(reactorConfig.getRcvBufSize()).isEqualTo(8192); + Assertions.assertThat(reactorConfig.getBacklogSize()).isEqualTo(5); + Assertions.assertThat(reactorConfig.getTcpKeepIdle()).isEqualTo(100); + Assertions.assertThat(reactorConfig.getTcpKeepInterval()).isEqualTo(12); + Assertions.assertThat(reactorConfig.getTcpKeepCount()).isEqualTo(4); + Assertions.assertThat(reactorConfig.getSocksProxyAddress()).isEqualTo(new InetSocketAddress(8888)); + Assertions.assertThat(reactorConfig.getSocksProxyUsername()).isEqualTo("socksProxyUsername"); + Assertions.assertThat(reactorConfig.getSocksProxyPassword()).isEqualTo("socksProxyPassword"); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/reactor/IOWorkerSelectorsTest.java b/httpcore5/src/test/java/org/apache/hc/core5/reactor/IOWorkerSelectorsTest.java index 3910445627..8d0d1f7cf4 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/reactor/IOWorkerSelectorsTest.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/reactor/IOWorkerSelectorsTest.java @@ -26,7 +26,7 @@ */ package org.apache.hc.core5.reactor; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.ValueSource; import org.mockito.Mockito; @@ -44,7 +44,7 @@ void testIndexOverflow(final int workerCount) { } final IOWorkerSelector selector = IOWorkerSelectors.newSelector(workerCount, (int) start); for (long i = start; i < end; i++) { - Assertions.assertTrue(selector.select(workers) < workerCount); + Assertions.assertThat(selector.select(workers) < workerCount).isTrue(); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/reactor/TestAbstractIOReactorBase.java b/httpcore5/src/test/java/org/apache/hc/core5/reactor/TestAbstractIOReactorBase.java index d5e256db32..c724541edf 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/reactor/TestAbstractIOReactorBase.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/reactor/TestAbstractIOReactorBase.java @@ -35,7 +35,7 @@ import org.apache.hc.core5.net.NamedEndpoint; import org.apache.hc.core5.util.TimeValue; import org.apache.hc.core5.util.Timeout; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.mockito.Mockito; @@ -125,8 +125,8 @@ void connectFailsWhenReactorShuttingDown() { try (StubSingleCoreIOReactor worker = new StubSingleCoreIOReactor(new BasicFuture<>(null))) { final TestReactor reactor = new TestReactor(IOReactorStatus.SHUTTING_DOWN, worker); try { - Assertions.assertThrows(IOReactorShutdownException.class, () -> - reactor.connect(endpoint(), new InetSocketAddress("localhost", 80), null, Timeout.ofSeconds(1), null, null)); + Assertions.assertThatThrownBy(() -> + reactor.connect(endpoint(), new InetSocketAddress("localhost", 80), null, Timeout.ofSeconds(1), null, null)).isInstanceOf(IOReactorShutdownException.class); } finally { reactor.close(); } @@ -139,10 +139,10 @@ void connectFailsWhenWorkerShutdownTriggersShutdown() { worker.initiateShutdown(); final TestReactor reactor = new TestReactor(IOReactorStatus.ACTIVE, worker); try { - Assertions.assertThrows(IOReactorShutdownException.class, () -> - reactor.connect(endpoint(), new InetSocketAddress("localhost", 80), null, Timeout.ofSeconds(1), null, null)); - Assertions.assertTrue(reactor.shutdownCalled); - Assertions.assertFalse(worker.isConnectCalled()); + Assertions.assertThatThrownBy(() -> + reactor.connect(endpoint(), new InetSocketAddress("localhost", 80), null, Timeout.ofSeconds(1), null, null)).isInstanceOf(IOReactorShutdownException.class); + Assertions.assertThat(reactor.shutdownCalled).isTrue(); + Assertions.assertThat(worker.isConnectCalled()).isFalse(); } finally { reactor.close(); } @@ -163,8 +163,8 @@ void connectDelegatesToWorker() throws Exception { null, null); - Assertions.assertSame(future, result); - Assertions.assertTrue(worker.isConnectCalled()); + Assertions.assertThat(result).isSameAs(future); + Assertions.assertThat(worker.isConnectCalled()).isTrue(); } finally { reactor.close(); } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/reactor/TestAbstractIOSessionPool.java b/httpcore5/src/test/java/org/apache/hc/core5/reactor/TestAbstractIOSessionPool.java index 961ae07172..a21db41467 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/reactor/TestAbstractIOSessionPool.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/reactor/TestAbstractIOSessionPool.java @@ -44,7 +44,7 @@ import org.apache.hc.core5.io.CloseMode; import org.apache.hc.core5.util.TimeValue; import org.apache.hc.core5.util.Timeout; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; @@ -107,9 +107,9 @@ void testGetSessions() throws Exception { Mockito.when(ioSession1.isOpen()).thenReturn(true); final Future future1 = impl.getSession("somehost", Timeout.ofSeconds(123L), null); - Assertions.assertNotNull(future1); - Assertions.assertFalse(future1.isDone()); - Assertions.assertTrue(impl.getRoutes().contains("somehost")); + Assertions.assertThat(future1).isNotNull(); + Assertions.assertThat(future1.isDone()).isFalse(); + Assertions.assertThat(impl.getRoutes().contains("somehost")).isTrue(); Mockito.verify(impl).connectSession( ArgumentMatchers.eq("somehost"), @@ -117,9 +117,9 @@ void testGetSessions() throws Exception { ArgumentMatchers.any()); final Future future2 = impl.getSession("somehost", Timeout.ofSeconds(123L), null); - Assertions.assertNotNull(future2); - Assertions.assertFalse(future2.isDone()); - Assertions.assertTrue(impl.getRoutes().contains("somehost")); + Assertions.assertThat(future2).isNotNull(); + Assertions.assertThat(future2.isDone()).isFalse(); + Assertions.assertThat(impl.getRoutes().contains("somehost")).isTrue(); Mockito.verify(impl, Mockito.times(1)).connectSession( ArgumentMatchers.eq("somehost"), @@ -129,11 +129,11 @@ void testGetSessions() throws Exception { return true; })); - Assertions.assertTrue(future1.isDone()); - Assertions.assertSame(ioSession1, future1.get()); + Assertions.assertThat(future1.isDone()).isTrue(); + Assertions.assertThat(future1.get()).isSameAs(ioSession1); - Assertions.assertTrue(future2.isDone()); - Assertions.assertSame(ioSession1, future2.get()); + Assertions.assertThat(future2.isDone()).isTrue(); + Assertions.assertThat(future2.get()).isSameAs(ioSession1); Mockito.verify(impl, Mockito.times(2)).validateSession( ArgumentMatchers.eq("somehost"), @@ -152,8 +152,8 @@ void testGetSessions() throws Exception { ArgumentMatchers.any(), ArgumentMatchers.any()); - Assertions.assertTrue(future3.isDone()); - Assertions.assertSame(ioSession1, future3.get()); + Assertions.assertThat(future3.isDone()).isTrue(); + Assertions.assertThat(future3.get()).isSameAs(ioSession1); } @Test @@ -165,9 +165,9 @@ void testGetSessionConnectFailure() { ArgumentMatchers.any())).thenReturn(connectFuture); final Future future1 = impl.getSession("somehost", Timeout.ofSeconds(123L), null); - Assertions.assertNotNull(future1); - Assertions.assertFalse(future1.isDone()); - Assertions.assertTrue(impl.getRoutes().contains("somehost")); + Assertions.assertThat(future1).isNotNull(); + Assertions.assertThat(future1.isDone()).isFalse(); + Assertions.assertThat(impl.getRoutes().contains("somehost")).isTrue(); Mockito.verify(impl).connectSession( ArgumentMatchers.eq("somehost"), @@ -175,31 +175,31 @@ void testGetSessionConnectFailure() { connectCallbackCaptor.capture()); final Future future2 = impl.getSession("somehost", Timeout.ofSeconds(123L), null); - Assertions.assertNotNull(future2); - Assertions.assertFalse(future2.isDone()); - Assertions.assertTrue(impl.getRoutes().contains("somehost")); + Assertions.assertThat(future2).isNotNull(); + Assertions.assertThat(future2.isDone()).isFalse(); + Assertions.assertThat(impl.getRoutes().contains("somehost")).isTrue(); final FutureCallback connectCallback = connectCallbackCaptor.getValue(); - Assertions.assertNotNull(connectCallback); + Assertions.assertThat(connectCallback).isNotNull(); connectCallback.failed(new Exception("Boom")); // Ensure connect failure invalidates all pending futures - Assertions.assertTrue(future1.isDone()); - Assertions.assertTrue(future2.isDone()); + Assertions.assertThat(future1.isDone()).isTrue(); + Assertions.assertThat(future2.isDone()).isTrue(); } @Test void testShutdownPool() { final AbstractIOSessionPool.PoolEntry entry1 = impl.getPoolEntry("host1"); - Assertions.assertNotNull(entry1); + Assertions.assertThat(entry1).isNotNull(); entry1.session = ioSession1; final AbstractIOSessionPool.PoolEntry entry2 = impl.getPoolEntry("host2"); - Assertions.assertNotNull(entry2); + Assertions.assertThat(entry2).isNotNull(); entry2.session = ioSession2; final AbstractIOSessionPool.PoolEntry entry3 = impl.getPoolEntry("host3"); - Assertions.assertNotNull(entry3); + Assertions.assertThat(entry3).isNotNull(); entry3.sessionFuture = connectFuture; entry3.requestQueue.add(callback1); entry3.requestQueue.add(callback2); @@ -216,11 +216,11 @@ void testShutdownPool() { @Test void testEnumSessions() { final AbstractIOSessionPool.PoolEntry entry1 = impl.getPoolEntry("host1"); - Assertions.assertNotNull(entry1); + Assertions.assertThat(entry1).isNotNull(); entry1.session = ioSession1; final AbstractIOSessionPool.PoolEntry entry2 = impl.getPoolEntry("host2"); - Assertions.assertNotNull(entry2); + Assertions.assertThat(entry2).isNotNull(); entry2.session = ioSession2; Mockito.doReturn(true).when(ioSession1).isOpen(); @@ -229,17 +229,17 @@ void testEnumSessions() { final Map sessionMap = new LinkedHashMap<>(); impl.enumAvailable(sessionMap::put); - Assertions.assertEquals(sessionMap.keySet(), new HashSet<>(Arrays.asList("host1", "host2"))); + Assertions.assertThat(new HashSet<>(Arrays.asList("host1", "host2"))).isEqualTo(sessionMap.keySet()); } @Test void testEnumSessionsWithClosedSession() { final AbstractIOSessionPool.PoolEntry entry1 = impl.getPoolEntry("host1"); - Assertions.assertNotNull(entry1); + Assertions.assertThat(entry1).isNotNull(); entry1.session = ioSession1; final AbstractIOSessionPool.PoolEntry entry2 = impl.getPoolEntry("host2"); - Assertions.assertNotNull(entry2); + Assertions.assertThat(entry2).isNotNull(); entry2.session = ioSession2; Mockito.doReturn(false).when(ioSession1).isOpen(); @@ -248,13 +248,13 @@ void testEnumSessionsWithClosedSession() { final Map sessionMap = new LinkedHashMap<>(); impl.enumAvailable(sessionMap::put); - Assertions.assertEquals(sessionMap.keySet(), new HashSet<>(Arrays.asList("host2"))); + Assertions.assertThat(new HashSet<>(Arrays.asList("host2"))).isEqualTo(sessionMap.keySet()); } @Test void testGetSessionReconnectAfterValidate() { final AbstractIOSessionPool.PoolEntry entry1 = impl.getPoolEntry("somehost"); - Assertions.assertNotNull(entry1); + Assertions.assertThat(entry1).isNotNull(); entry1.session = ioSession1; Mockito.when(ioSession1.isOpen()).thenReturn(true); @@ -278,7 +278,7 @@ void testGetSessionReconnectAfterValidate() { @Test void testGetSessionReconnectIfExpired() { final AbstractIOSessionPool.PoolEntry entry1 = impl.getPoolEntry("somehost"); - Assertions.assertNotNull(entry1); + Assertions.assertThat(entry1).isNotNull(); entry1.session = ioSession1; Mockito.when(ioSession1.isOpen()).thenReturn(true); @@ -296,7 +296,7 @@ void testGetSessionReconnectIfExpired() { @Test void testGetSessionReconnectIfClosed() { final AbstractIOSessionPool.PoolEntry entry1 = impl.getPoolEntry("somehost"); - Assertions.assertNotNull(entry1); + Assertions.assertThat(entry1).isNotNull(); entry1.session = ioSession1; Mockito.when(ioSession1.isOpen()).thenReturn(false); @@ -320,22 +320,22 @@ void testGetSessionConnectUnknownHost() { }))).thenReturn(connectFuture); final Future future1 = impl.getSession("somehost", Timeout.ofSeconds(123L), null); - Assertions.assertNotNull(future1); - Assertions.assertTrue(future1.isDone()); + Assertions.assertThat(future1).isNotNull(); + Assertions.assertThat(future1.isDone()).isTrue(); final Future future2 = impl.getSession("somehost", Timeout.ofSeconds(123L), null); - Assertions.assertNotNull(future2); - Assertions.assertTrue(future2.isDone()); + Assertions.assertThat(future2).isNotNull(); + Assertions.assertThat(future2.isDone()).isTrue(); } @Test void testCloseIdleOnly() { final AbstractIOSessionPool.PoolEntry entry1 = impl.getPoolEntry("host1"); - Assertions.assertNotNull(entry1); + Assertions.assertThat(entry1).isNotNull(); entry1.session = ioSession1; final AbstractIOSessionPool.PoolEntry entry2 = impl.getPoolEntry("host2"); - Assertions.assertNotNull(entry2); + Assertions.assertThat(entry2).isNotNull(); entry2.session = ioSession2; Mockito.doReturn(true).when(ioSession1).isOpen(); @@ -354,11 +354,11 @@ void testCloseIdleOnly() { @Test void testCloseIdlePastDeadline() { final AbstractIOSessionPool.PoolEntry entry1 = impl.getPoolEntry("host1"); - Assertions.assertNotNull(entry1); + Assertions.assertThat(entry1).isNotNull(); entry1.session = ioSession1; final AbstractIOSessionPool.PoolEntry entry2 = impl.getPoolEntry("host2"); - Assertions.assertNotNull(entry2); + Assertions.assertThat(entry2).isNotNull(); entry2.session = ioSession2; Mockito.doReturn(true).when(ioSession1).isOpen(); @@ -379,11 +379,11 @@ void testCloseIdlePastDeadline() { @Test void testEvictExpired() { final AbstractIOSessionPool.PoolEntry entry1 = impl.getPoolEntry("host1"); - Assertions.assertNotNull(entry1); + Assertions.assertThat(entry1).isNotNull(); entry1.session = ioSession1; final AbstractIOSessionPool.PoolEntry entry2 = impl.getPoolEntry("host2"); - Assertions.assertNotNull(entry2); + Assertions.assertThat(entry2).isNotNull(); entry2.session = ioSession2; Mockito.doReturn(true).when(ioSession1).isOpen(); @@ -402,11 +402,11 @@ void testEvictExpired() { @Test void testEvictExpiredNonIdleDoNotGetEvicted() { final AbstractIOSessionPool.PoolEntry entry1 = impl.getPoolEntry("host1"); - Assertions.assertNotNull(entry1); + Assertions.assertThat(entry1).isNotNull(); entry1.session = ioSession1; final AbstractIOSessionPool.PoolEntry entry2 = impl.getPoolEntry("host2"); - Assertions.assertNotNull(entry2); + Assertions.assertThat(entry2).isNotNull(); entry2.session = ioSession2; Mockito.doReturn(true).when(ioSession1).isOpen(); diff --git a/httpcore5/src/test/java/org/apache/hc/core5/reactor/TestDefaultConnectingIOReactor.java b/httpcore5/src/test/java/org/apache/hc/core5/reactor/TestDefaultConnectingIOReactor.java index df27afe873..f0c108373f 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/reactor/TestDefaultConnectingIOReactor.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/reactor/TestDefaultConnectingIOReactor.java @@ -31,7 +31,7 @@ import org.apache.hc.core5.function.Decorator; import org.apache.hc.core5.net.NamedEndpoint; import org.apache.hc.core5.util.Timeout; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.mockito.Mockito; @@ -61,7 +61,7 @@ void selectWorkerUsesSelector() { final DefaultConnectingIOReactor reactor = newReactor(selector); try { final SingleCoreIOReactor worker = reactor.selectWorker(); - Assertions.assertNotNull(worker); + Assertions.assertThat(worker).isNotNull(); } finally { reactor.close(org.apache.hc.core5.io.CloseMode.IMMEDIATE); } @@ -86,7 +86,7 @@ public int getPort() { reactor.connect(endpoint, new InetSocketAddress("localhost", 80), null, Timeout.ofSeconds(1), null, null); - Assertions.assertEquals(1, reactor.selectWorker().pendingChannelCount()); + Assertions.assertThat(reactor.selectWorker().pendingChannelCount()).isEqualTo(1); } finally { reactor.close(org.apache.hc.core5.io.CloseMode.IMMEDIATE); } @@ -96,7 +96,7 @@ public int getPort() { void statusDelegatesToInnerReactor() { final DefaultConnectingIOReactor reactor = newReactor(dispatchers -> 0); try { - Assertions.assertEquals(IOReactorStatus.INACTIVE, reactor.getStatus()); + Assertions.assertThat(reactor.getStatus()).isEqualTo(IOReactorStatus.INACTIVE); } finally { reactor.close(org.apache.hc.core5.io.CloseMode.IMMEDIATE); } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/reactor/TestDefaultListeningIOReactor.java b/httpcore5/src/test/java/org/apache/hc/core5/reactor/TestDefaultListeningIOReactor.java index c81ed2109c..c3274b11f9 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/reactor/TestDefaultListeningIOReactor.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/reactor/TestDefaultListeningIOReactor.java @@ -31,7 +31,7 @@ import org.apache.hc.core5.function.Decorator; import org.apache.hc.core5.net.NamedEndpoint; import org.apache.hc.core5.util.Timeout; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.mockito.Mockito; @@ -62,7 +62,7 @@ void selectWorkerUsesSelector() { final DefaultListeningIOReactor reactor = newReactor(selector); try { final SingleCoreIOReactor worker = reactor.selectWorker(); - Assertions.assertNotNull(worker); + Assertions.assertThat(worker).isNotNull(); } finally { reactor.close(org.apache.hc.core5.io.CloseMode.IMMEDIATE); } @@ -87,7 +87,7 @@ public int getPort() { reactor.connect(endpoint, new InetSocketAddress("localhost", 80), null, Timeout.ofSeconds(1), null, null); - Assertions.assertEquals(1, reactor.selectWorker().pendingChannelCount()); + Assertions.assertThat(reactor.selectWorker().pendingChannelCount()).isEqualTo(1); } finally { reactor.close(org.apache.hc.core5.io.CloseMode.IMMEDIATE); } @@ -97,7 +97,7 @@ public int getPort() { void statusDelegatesToInnerReactor() { final DefaultListeningIOReactor reactor = newReactor(dispatchers -> 0); try { - Assertions.assertEquals(IOReactorStatus.INACTIVE, reactor.getStatus()); + Assertions.assertThat(reactor.getStatus()).isEqualTo(IOReactorStatus.INACTIVE); } finally { reactor.close(org.apache.hc.core5.io.CloseMode.IMMEDIATE); } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/reactor/TestIOReactorWorker.java b/httpcore5/src/test/java/org/apache/hc/core5/reactor/TestIOReactorWorker.java index c84665ac18..42727d092a 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/reactor/TestIOReactorWorker.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/reactor/TestIOReactorWorker.java @@ -28,7 +28,8 @@ import java.io.IOException; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; +import org.assertj.core.api.InstanceOfAssertFactories; import org.junit.jupiter.api.Test; class TestIOReactorWorker { @@ -70,7 +71,7 @@ void capturesRuntimeException() { worker.run(); - Assertions.assertSame(ex, worker.getThrowable()); + Assertions.assertThat(worker.getThrowable()).isSameAs(ex); } @Test @@ -78,9 +79,9 @@ void rethrowsError() { final Error err = new AssertionError("fatal"); final IOReactorWorker worker = new IOReactorWorker(new TestReactor(null, err)); - final Error thrown = Assertions.assertThrows(Error.class, worker::run); - Assertions.assertSame(err, thrown); - Assertions.assertSame(err, worker.getThrowable()); + final Error thrown = Assertions.assertThatThrownBy(worker::run).isInstanceOf(Error.class).asInstanceOf(InstanceOfAssertFactories.type(Error.class)).actual(); + Assertions.assertThat(thrown).isSameAs(err); + Assertions.assertThat(worker.getThrowable()).isSameAs(err); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/reactor/TestIOSessionImpl.java b/httpcore5/src/test/java/org/apache/hc/core5/reactor/TestIOSessionImpl.java index d92c14d6aa..a0b81d6016 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/reactor/TestIOSessionImpl.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/reactor/TestIOSessionImpl.java @@ -41,7 +41,7 @@ import java.util.concurrent.atomic.AtomicReference; import org.apache.hc.core5.io.CloseMode; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class TestIOSessionImpl { @@ -189,15 +189,15 @@ void enqueueUpdatesInterestOpsAndOrders() throws Exception { session.enqueue(normal, Command.Priority.NORMAL); session.enqueue(immediate, Command.Priority.IMMEDIATE); - Assertions.assertTrue(session.hasCommands()); - Assertions.assertEquals(2, session.getPendingCommandCount()); - Assertions.assertSame(immediate, session.poll()); - Assertions.assertSame(normal, session.poll()); + Assertions.assertThat(session.hasCommands()).isTrue(); + Assertions.assertThat(session.getPendingCommandCount()).isEqualTo(2); + Assertions.assertThat(session.poll()).isSameAs(immediate); + Assertions.assertThat(session.poll()).isSameAs(normal); - Assertions.assertEquals(SelectionKey.OP_READ | SelectionKey.OP_WRITE, key.interestOps()); + Assertions.assertThat(key.interestOps()).isEqualTo(SelectionKey.OP_READ | SelectionKey.OP_WRITE); } finally { session.close(CloseMode.IMMEDIATE); - Assertions.assertSame(session, closedRef.get()); + Assertions.assertThat(closedRef.get()).isSameAs(session); } } } @@ -216,7 +216,7 @@ void enqueueOnClosedCancels() throws Exception { final TestCommand command = new TestCommand(); session.enqueue(command, Command.Priority.NORMAL); - Assertions.assertTrue(command.cancelled.get()); + Assertions.assertThat(command.cancelled.get()).isTrue(); } finally { session.close(CloseMode.IMMEDIATE); } @@ -233,13 +233,13 @@ void eventMaskHelpersWork() throws Exception { final IOSessionImpl session = new IOSessionImpl("t", key, channel, null); try { session.setEvent(SelectionKey.OP_WRITE); - Assertions.assertEquals(SelectionKey.OP_READ | SelectionKey.OP_WRITE, session.getEventMask()); + Assertions.assertThat(session.getEventMask()).isEqualTo(SelectionKey.OP_READ | SelectionKey.OP_WRITE); session.clearEvent(SelectionKey.OP_READ); - Assertions.assertEquals(SelectionKey.OP_WRITE, session.getEventMask()); + Assertions.assertThat(session.getEventMask()).isEqualTo(SelectionKey.OP_WRITE); session.setEventMask(SelectionKey.OP_READ); - Assertions.assertEquals(SelectionKey.OP_READ, session.getEventMask()); + Assertions.assertThat(session.getEventMask()).isEqualTo(SelectionKey.OP_READ); } finally { session.close(CloseMode.IMMEDIATE); } @@ -256,7 +256,7 @@ void eventMaskIsEmptyOnceClosed() throws Exception { final IOSessionImpl session = new IOSessionImpl("t", key, channel, null); session.close(CloseMode.IMMEDIATE); - Assertions.assertEquals(0, session.getEventMask()); + Assertions.assertThat(session.getEventMask()).isEqualTo(0); } } @@ -270,7 +270,7 @@ void toStringIncludesStatus() throws Exception { final IOSessionImpl session = new IOSessionImpl("t", key, channel, null); try { final String text = session.toString(); - Assertions.assertTrue(text.contains("ACTIVE")); + Assertions.assertThat(text.contains("ACTIVE")).isTrue(); } finally { session.close(CloseMode.IMMEDIATE); } @@ -295,13 +295,13 @@ void largeHeapBufferWriteIsChunked() throws Exception { final int bytesWritten = session.write(src); - Assertions.assertEquals(content.length, bytesWritten); - Assertions.assertFalse(src.hasRemaining()); - Assertions.assertEquals(3, mockChannel.writeSizes.size()); + Assertions.assertThat(bytesWritten).isEqualTo(content.length); + Assertions.assertThat(src.hasRemaining()).isFalse(); + Assertions.assertThat(mockChannel.writeSizes.size()).isEqualTo(3); for (final int size : mockChannel.writeSizes) { - Assertions.assertTrue(size <= 16 * 1024); + Assertions.assertThat(size <= 16 * 1024).isTrue(); } - Assertions.assertArrayEquals(content, mockChannel.toByteArray()); + Assertions.assertThat(mockChannel.toByteArray()).containsExactly(content); } } @@ -320,10 +320,10 @@ void smallHeapBufferWriteIsNotChunked() throws Exception { final int bytesWritten = session.write(src); - Assertions.assertEquals(content.length, bytesWritten); - Assertions.assertEquals(1, mockChannel.writeSizes.size()); - Assertions.assertEquals(content.length, mockChannel.writeSizes.get(0)); - Assertions.assertArrayEquals(content, mockChannel.toByteArray()); + Assertions.assertThat(bytesWritten).isEqualTo(content.length); + Assertions.assertThat(mockChannel.writeSizes.size()).isEqualTo(1); + Assertions.assertThat(mockChannel.writeSizes.get(0)).isEqualTo(content.length); + Assertions.assertThat(mockChannel.toByteArray()).containsExactly(content); } } @@ -346,9 +346,9 @@ void directBufferWriteIsNotChunked() throws Exception { final int bytesWritten = session.write(src); - Assertions.assertEquals(contentSize, bytesWritten); - Assertions.assertEquals(1, mockChannel.writeSizes.size()); - Assertions.assertEquals(contentSize, mockChannel.writeSizes.get(0)); + Assertions.assertThat(bytesWritten).isEqualTo(contentSize); + Assertions.assertThat(mockChannel.writeSizes.size()).isEqualTo(1); + Assertions.assertThat(mockChannel.writeSizes.get(0)).isEqualTo(contentSize); } } @@ -371,9 +371,9 @@ void partialWriteDrainsAll() throws Exception { final int bytesWritten = session.write(src); - Assertions.assertEquals(content.length, bytesWritten); - Assertions.assertFalse(src.hasRemaining()); - Assertions.assertArrayEquals(content, mockChannel.toByteArray()); + Assertions.assertThat(bytesWritten).isEqualTo(content.length); + Assertions.assertThat(src.hasRemaining()).isFalse(); + Assertions.assertThat(mockChannel.toByteArray()).containsExactly(content); } } @@ -393,8 +393,8 @@ void saturatedChannelWriteReturnsZero() throws Exception { final int bytesWritten = session.write(src); - Assertions.assertEquals(0, bytesWritten); - Assertions.assertTrue(src.hasRemaining()); + Assertions.assertThat(bytesWritten).isEqualTo(0); + Assertions.assertThat(src.hasRemaining()).isTrue(); } } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/reactor/TestInternalChannel.java b/httpcore5/src/test/java/org/apache/hc/core5/reactor/TestInternalChannel.java index cfd2356098..4a77b4857c 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/reactor/TestInternalChannel.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/reactor/TestInternalChannel.java @@ -33,7 +33,7 @@ import org.apache.hc.core5.io.CloseMode; import org.apache.hc.core5.util.Timeout; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class TestInternalChannel { @@ -97,8 +97,8 @@ void handleIoEventClosesOnCancelledKey() { channel.handleIOEvent(0); - Assertions.assertTrue(channel.closed.get()); - Assertions.assertEquals(CloseMode.GRACEFUL, channel.closeMode.get()); + Assertions.assertThat(channel.closed.get()).isTrue(); + Assertions.assertThat(channel.closeMode.get()).isEqualTo(CloseMode.GRACEFUL); } } @@ -109,9 +109,9 @@ void handleIoEventClosesOnException() { channel.handleIOEvent(0); - Assertions.assertTrue(channel.closed.get()); - Assertions.assertEquals(CloseMode.GRACEFUL, channel.closeMode.get()); - Assertions.assertNotNull(channel.exceptionRef.get()); + Assertions.assertThat(channel.closed.get()).isTrue(); + Assertions.assertThat(channel.closeMode.get()).isEqualTo(CloseMode.GRACEFUL); + Assertions.assertThat(channel.exceptionRef.get()).isNotNull(); } } @@ -123,8 +123,8 @@ void checkTimeoutInvokesCallback() { final boolean result = channel.checkTimeout(10); - Assertions.assertFalse(result); - Assertions.assertTrue(channel.timedOut.get()); + Assertions.assertThat(result).isFalse(); + Assertions.assertThat(channel.timedOut.get()).isTrue(); } } @@ -135,8 +135,8 @@ void checkTimeoutSkipsWhenDisabled() { final boolean result = channel.checkTimeout(System.currentTimeMillis()); - Assertions.assertTrue(result); - Assertions.assertFalse(channel.timedOut.get()); + Assertions.assertThat(result).isTrue(); + Assertions.assertThat(channel.timedOut.get()).isFalse(); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/reactor/TestInternalConnectChannel.java b/httpcore5/src/test/java/org/apache/hc/core5/reactor/TestInternalConnectChannel.java index d786832152..bd63de7952 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/reactor/TestInternalConnectChannel.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/reactor/TestInternalConnectChannel.java @@ -36,7 +36,7 @@ import org.apache.hc.core5.concurrent.FutureCallback; import org.apache.hc.core5.net.NamedEndpoint; import org.apache.hc.core5.util.Timeout; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class TestInternalConnectChannel { @@ -89,8 +89,8 @@ public void cancelled() { IOReactorConfig.DEFAULT)) { connectChannel.onTimeout(Timeout.ofMilliseconds(1)); - Assertions.assertTrue(failure.get() instanceof SocketTimeoutException); - Assertions.assertFalse(channel.isOpen()); + Assertions.assertThat(failure.get() instanceof SocketTimeoutException).isTrue(); + Assertions.assertThat(channel.isOpen()).isFalse(); } } } @@ -126,7 +126,7 @@ public int getPort() { null, null, IOReactorConfig.DEFAULT)) { - Assertions.assertTrue(connectChannel.toString().contains("remoteEndpoint")); + Assertions.assertThat(connectChannel.toString().contains("remoteEndpoint")).isTrue(); } } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/reactor/TestInternalDataChannel.java b/httpcore5/src/test/java/org/apache/hc/core5/reactor/TestInternalDataChannel.java index 2b66fd5ed9..fff187b8d0 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/reactor/TestInternalDataChannel.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/reactor/TestInternalDataChannel.java @@ -30,7 +30,7 @@ import org.apache.hc.core5.concurrent.FutureCallback; import org.apache.hc.core5.util.Timeout; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.mockito.Mockito; @@ -93,7 +93,9 @@ void registerAndSwitchProtocol() { channel.switchProtocol("H2", null); Mockito.verify(upgradeHandler).upgrade(Mockito.eq(channel), Mockito.isNull()); - Assertions.assertThrows(IllegalStateException.class, () -> channel.switchProtocol("unknown", null)); + Assertions.assertThatThrownBy(() -> + channel.switchProtocol("unknown", null)) + .isInstanceOf(IllegalStateException.class); } finally { channel.close(org.apache.hc.core5.io.CloseMode.IMMEDIATE); } @@ -139,7 +141,9 @@ void upgradeHandlerMissingThrows() { @SuppressWarnings("unchecked") final FutureCallback callback = (FutureCallback) Mockito.mock(FutureCallback.class); - Assertions.assertThrows(IllegalStateException.class, () -> channel.switchProtocol("h2", callback)); + Assertions.assertThatThrownBy(() -> + channel.switchProtocol("h2", callback)) + .isInstanceOf(IllegalStateException.class); } finally { channel.close(org.apache.hc.core5.io.CloseMode.IMMEDIATE); } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/reactor/TestMultiCoreIOReactor.java b/httpcore5/src/test/java/org/apache/hc/core5/reactor/TestMultiCoreIOReactor.java index dc4bbc9a36..548583c866 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/reactor/TestMultiCoreIOReactor.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/reactor/TestMultiCoreIOReactor.java @@ -30,7 +30,7 @@ import org.apache.hc.core5.io.CloseMode; import org.apache.hc.core5.util.TimeValue; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class TestMultiCoreIOReactor { @@ -81,23 +81,23 @@ void startAndShutdown() throws Exception { try (MultiCoreIOReactor reactor = new MultiCoreIOReactor( new IOReactor[] { r1, r2 }, new Thread[] { t1, t2 })) { reactor.start(); - Assertions.assertEquals(IOReactorStatus.ACTIVE, reactor.getStatus()); + Assertions.assertThat(reactor.getStatus()).isEqualTo(IOReactorStatus.ACTIVE); reactor.initiateShutdown(); - Assertions.assertTrue(r1.shutdown.get()); - Assertions.assertTrue(r2.shutdown.get()); + Assertions.assertThat(r1.shutdown.get()).isTrue(); + Assertions.assertThat(r2.shutdown.get()).isTrue(); reactor.close(CloseMode.IMMEDIATE); - Assertions.assertTrue(r1.closed.get()); - Assertions.assertTrue(r2.closed.get()); - Assertions.assertEquals(IOReactorStatus.SHUT_DOWN, reactor.getStatus()); + Assertions.assertThat(r1.closed.get()).isTrue(); + Assertions.assertThat(r2.closed.get()).isTrue(); + Assertions.assertThat(reactor.getStatus()).isEqualTo(IOReactorStatus.SHUT_DOWN); } } @Test void toStringIncludesStatus() { try (MultiCoreIOReactor reactor = new MultiCoreIOReactor(new IOReactor[] {}, new Thread[] {})) { - Assertions.assertTrue(reactor.toString().contains("status")); + Assertions.assertThat(reactor.toString().contains("status")).isTrue(); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/reactor/TestReactorBasics.java b/httpcore5/src/test/java/org/apache/hc/core5/reactor/TestReactorBasics.java index 3e50d0c8e0..c5cd2f41d9 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/reactor/TestReactorBasics.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/reactor/TestReactorBasics.java @@ -30,7 +30,7 @@ import java.nio.channels.SocketChannel; import org.apache.hc.core5.http.HttpHost; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class TestReactorBasics { @@ -39,50 +39,50 @@ class TestReactorBasics { void channelEntryToString() throws Exception { try (SocketChannel channel = SocketChannel.open()) { final ChannelEntry entry = new ChannelEntry(channel, "att"); - Assertions.assertTrue(entry.toString().contains("attachment=att")); + Assertions.assertThat(entry.toString().contains("attachment=att")).isTrue(); } } @Test void eventMaskConstantsMatchSelectionKey() { - Assertions.assertEquals(SelectionKey.OP_READ, EventMask.READ); - Assertions.assertEquals(SelectionKey.OP_WRITE, EventMask.WRITE); - Assertions.assertEquals(SelectionKey.OP_READ | SelectionKey.OP_WRITE, EventMask.READ_WRITE); + Assertions.assertThat(EventMask.READ).isEqualTo(SelectionKey.OP_READ); + Assertions.assertThat(EventMask.WRITE).isEqualTo(SelectionKey.OP_WRITE); + Assertions.assertThat(EventMask.READ_WRITE).isEqualTo(SelectionKey.OP_READ | SelectionKey.OP_WRITE); } @Test void endpointParametersExposeValues() { final EndpointParameters params = new EndpointParameters("https", "example.com", 8443, "tag"); - Assertions.assertEquals("https", params.getScheme()); - Assertions.assertEquals("example.com", params.getHostName()); - Assertions.assertEquals(8443, params.getPort()); - Assertions.assertEquals("tag", params.getAttachment()); + Assertions.assertThat(params.getScheme()).isEqualTo("https"); + Assertions.assertThat(params.getHostName()).isEqualTo("example.com"); + Assertions.assertThat(params.getPort()).isEqualTo(8443); + Assertions.assertThat(params.getAttachment()).isEqualTo("tag"); final EndpointParameters fromHost = new EndpointParameters(new HttpHost("http", "localhost", 80), null); - Assertions.assertEquals("http", fromHost.getScheme()); - Assertions.assertEquals("localhost", fromHost.getHostName()); - Assertions.assertEquals(80, fromHost.getPort()); + Assertions.assertThat(fromHost.getScheme()).isEqualTo("http"); + Assertions.assertThat(fromHost.getHostName()).isEqualTo("localhost"); + Assertions.assertThat(fromHost.getPort()).isEqualTo(80); } @Test void ioReactorShutdownExceptionKeepsMessage() { final IOReactorShutdownException ex = new IOReactorShutdownException("down"); - Assertions.assertEquals("down", ex.getMessage()); + Assertions.assertThat(ex.getMessage()).isEqualTo("down"); } @Test void ioReactorStatusValuesPresent() { - Assertions.assertNotNull(IOReactorStatus.INACTIVE); - Assertions.assertNotNull(IOReactorStatus.ACTIVE); - Assertions.assertNotNull(IOReactorStatus.SHUTTING_DOWN); - Assertions.assertNotNull(IOReactorStatus.SHUT_DOWN); - Assertions.assertNotEquals(IOReactorStatus.INACTIVE, IOReactorStatus.ACTIVE); + Assertions.assertThat(IOReactorStatus.INACTIVE).isNotNull(); + Assertions.assertThat(IOReactorStatus.ACTIVE).isNotNull(); + Assertions.assertThat(IOReactorStatus.SHUTTING_DOWN).isNotNull(); + Assertions.assertThat(IOReactorStatus.SHUT_DOWN).isNotNull(); + Assertions.assertThat(IOReactorStatus.ACTIVE).isNotEqualTo(IOReactorStatus.INACTIVE); } @Test void commandPriorityEnumValuesPresent() { - Assertions.assertNotNull(Command.Priority.NORMAL); - Assertions.assertNotNull(Command.Priority.IMMEDIATE); + Assertions.assertThat(Command.Priority.NORMAL).isNotNull(); + Assertions.assertThat(Command.Priority.IMMEDIATE).isNotNull(); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/reactor/TestSingleCoreIOReactor.java b/httpcore5/src/test/java/org/apache/hc/core5/reactor/TestSingleCoreIOReactor.java index 8b2e2ad97f..bf47ad8b45 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/reactor/TestSingleCoreIOReactor.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/reactor/TestSingleCoreIOReactor.java @@ -39,7 +39,7 @@ import org.apache.hc.core5.io.CloseMode; import org.apache.hc.core5.net.NamedEndpoint; import org.apache.hc.core5.util.Timeout; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.mockito.Mockito; @@ -57,12 +57,12 @@ private SingleCoreIOReactor newReactor() { void enqueueChannelAndPendingCounts() throws Exception { try (SingleCoreIOReactor reactor = newReactor(); SocketChannel channel = SocketChannel.open()) { - Assertions.assertEquals(0, reactor.pendingChannelCount()); + Assertions.assertThat(reactor.pendingChannelCount()).isEqualTo(0); reactor.enqueueChannel(new ChannelEntry(channel, "att")); - Assertions.assertEquals(1, reactor.pendingChannelCount()); - Assertions.assertEquals(0, reactor.totalChannelCount()); + Assertions.assertThat(reactor.pendingChannelCount()).isEqualTo(1); + Assertions.assertThat(reactor.totalChannelCount()).isEqualTo(0); } } @@ -83,7 +83,7 @@ public int getPort() { reactor.connect(endpoint, new InetSocketAddress("localhost", 80), null, Timeout.ofSeconds(1), null, null); - Assertions.assertEquals(1, reactor.pendingChannelCount()); + Assertions.assertThat(reactor.pendingChannelCount()).isEqualTo(1); } } @@ -93,8 +93,8 @@ void enqueueAfterShutdownThrows() throws Exception { SocketChannel channel = SocketChannel.open()) { reactor.initiateShutdown(); - Assertions.assertThrows(IOReactorShutdownException.class, () -> - reactor.enqueueChannel(new ChannelEntry(channel, null))); + Assertions.assertThatThrownBy(() -> + reactor.enqueueChannel(new ChannelEntry(channel, null))).isInstanceOf(IOReactorShutdownException.class); } } @@ -118,14 +118,14 @@ void terminatesWhenSelectorClosedByAnotherThread() throws Exception { final Thread worker = new Thread(reactor::execute); worker.start(); reactor.enqueueChannel(new ChannelEntry(channel, null)); - Assertions.assertTrue(connected.await(5, TimeUnit.SECONDS)); + Assertions.assertThat(connected.await(5, TimeUnit.SECONDS)).isTrue(); reactor.close(CloseMode.IMMEDIATE); reactorClosed.countDown(); worker.join(TimeUnit.SECONDS.toMillis(5)); - Assertions.assertFalse(worker.isAlive()); - Assertions.assertTrue(exceptions.isEmpty(), exceptions::toString); + Assertions.assertThat(worker.isAlive()).isFalse(); + Assertions.assertThat(exceptions.isEmpty()).withFailMessage(exceptions::toString).isTrue(); Mockito.verify(handler).disconnected(Mockito.any()); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/reactor/TestSingleCoreListeningIOReactor.java b/httpcore5/src/test/java/org/apache/hc/core5/reactor/TestSingleCoreListeningIOReactor.java index f8b8598566..1ba4bb2469 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/reactor/TestSingleCoreListeningIOReactor.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/reactor/TestSingleCoreListeningIOReactor.java @@ -35,7 +35,7 @@ import org.apache.hc.core5.concurrent.FutureCallback; import org.apache.hc.core5.util.TimeValue; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class TestSingleCoreListeningIOReactor { @@ -76,22 +76,22 @@ public void cancelled() { final ListenerEndpoint endpoint = reactor.listen(new InetSocketAddress("localhost", 0), "att", callback) .get(1, TimeUnit.SECONDS); - Assertions.assertNotNull(endpoint); - Assertions.assertNotNull(endpoint.getAddress()); + Assertions.assertThat(endpoint).isNotNull(); + Assertions.assertThat(endpoint.getAddress()).isNotNull(); try (SocketChannel client = SocketChannel.open()) { client.connect(endpoint.getAddress()); } - Assertions.assertTrue(accepted.await(1, TimeUnit.SECONDS)); - Assertions.assertNotNull(entryRef.get()); - Assertions.assertEquals("att", entryRef.get().attachment); + Assertions.assertThat(accepted.await(1, TimeUnit.SECONDS)).isTrue(); + Assertions.assertThat(entryRef.get()).isNotNull(); + Assertions.assertThat(entryRef.get().attachment).isEqualTo("att"); final Set endpointsBeforePause = reactor.getEndpoints(); - Assertions.assertFalse(endpointsBeforePause.isEmpty()); + Assertions.assertThat(endpointsBeforePause.isEmpty()).isFalse(); reactor.pause(); - Assertions.assertTrue(reactor.getEndpoints().isEmpty()); + Assertions.assertThat(reactor.getEndpoints().isEmpty()).isTrue(); reactor.resume(); @@ -106,8 +106,8 @@ void listenAfterShutdownThrows() { })) { reactor.initiateShutdown(); - Assertions.assertThrows(IOReactorShutdownException.class, () -> - reactor.listen(new InetSocketAddress("localhost", 0), null)); + Assertions.assertThatThrownBy(() -> + reactor.listen(new InetSocketAddress("localhost", 0), null)).isInstanceOf(IOReactorShutdownException.class); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/reactor/TestSocketChannelFactory.java b/httpcore5/src/test/java/org/apache/hc/core5/reactor/TestSocketChannelFactory.java index 2036a2e16d..434bbee4e8 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/reactor/TestSocketChannelFactory.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/reactor/TestSocketChannelFactory.java @@ -41,7 +41,8 @@ import org.apache.hc.core5.io.IOFunction; import org.apache.hc.core5.net.NamedEndpoint; import org.apache.hc.core5.util.Timeout; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; +import org.assertj.core.api.InstanceOfAssertFactories; import org.junit.jupiter.api.Test; import org.mockito.Mockito; @@ -72,8 +73,8 @@ void testCustomSocketChannelFactory() throws Exception { null, null); final IOSession ioSession = future.get(5, TimeUnit.SECONDS); - Assertions.assertNotNull(ioSession); - Assertions.assertEquals(remoteAddress, requestedAddress.get()); + Assertions.assertThat(ioSession).isNotNull(); + Assertions.assertThat(requestedAddress.get()).isEqualTo(remoteAddress); } finally { reactor.close(); } @@ -115,9 +116,10 @@ private static void assertFactoryFailure( Timeout.ofSeconds(1), null, null); - final ExecutionException ex = Assertions.assertThrows( - ExecutionException.class, () -> future.get(5, TimeUnit.SECONDS)); - Assertions.assertSame(expected, ex.getCause()); + final ExecutionException ex = Assertions.assertThatThrownBy(() -> + future.get(5, TimeUnit.SECONDS)) + .isInstanceOf(ExecutionException.class).asInstanceOf(InstanceOfAssertFactories.type(ExecutionException.class)).actual(); + Assertions.assertThat(ex.getCause()).isSameAs(expected); } finally { reactor.close(); } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/reactor/TestSocksProxyProtocolHandler.java b/httpcore5/src/test/java/org/apache/hc/core5/reactor/TestSocksProxyProtocolHandler.java index 67e3620783..eba2911096 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/reactor/TestSocksProxyProtocolHandler.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/reactor/TestSocksProxyProtocolHandler.java @@ -26,11 +26,6 @@ */ package org.apache.hc.core5.reactor; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertSame; -import static org.junit.jupiter.api.Assertions.assertThrows; -import static org.junit.jupiter.api.Assertions.assertTrue; - import java.io.IOException; import java.net.InetAddress; import java.net.InetSocketAddress; @@ -49,6 +44,8 @@ import org.apache.hc.core5.io.CloseMode; import org.apache.hc.core5.net.NamedEndpoint; import org.apache.hc.core5.util.Timeout; +import org.assertj.core.api.Assertions; +import org.assertj.core.api.InstanceOfAssertFactories; import org.junit.jupiter.api.Test; class TestSocksProxyProtocolHandler { @@ -84,37 +81,36 @@ public int getPort() { final SocksProxyProtocolHandler handler = new SocksProxyProtocolHandler(null, sessionRequest, null, reactorConfig); final TestIOSession session = new TestIOSession(); - assertEquals(0, session.getEventMask()); + Assertions.assertThat(session.getEventMask()).isEqualTo(0); // 1) Client sends auth methods handler.connected(session); - assertEquals(SelectionKey.OP_WRITE, session.getEventMask()); + Assertions.assertThat(session.getEventMask()).isEqualTo(SelectionKey.OP_WRITE); handler.outputReady(session); - assertEquals(SelectionKey.OP_READ, session.getEventMask()); + Assertions.assertThat(session.getEventMask()).isEqualTo(SelectionKey.OP_READ); // 2) Server replies: VER=5, METHOD=NO_AUTH(0) handler.inputReady(session, ByteBuffer.wrap(new byte[]{0x05, 0x00})); - assertEquals(SelectionKey.OP_WRITE, session.getEventMask()); + Assertions.assertThat(session.getEventMask()).isEqualTo(SelectionKey.OP_WRITE); // 3) Client sends CONNECT, then expects 2 bytes: VER + REP handler.outputReady(session); - assertEquals(SelectionKey.OP_READ, session.getEventMask()); + Assertions.assertThat(session.getEventMask()).isEqualTo(SelectionKey.OP_READ); // 4) Now simulate proxy closing the TCP connection: read() returns -1. - final ConnectionClosedException ex = assertThrows( - ConnectionClosedException.class, - () -> handler.inputReady(session, null), - "EOF during SOCKS handshake must fail the exchange"); + final ConnectionClosedException ex = Assertions.assertThatThrownBy(() -> + handler.inputReady(session, null)) + .withFailMessage("EOF during SOCKS handshake must fail the exchange").isInstanceOf(ConnectionClosedException.class).asInstanceOf(InstanceOfAssertFactories.type(ConnectionClosedException.class)).actual(); // This is what the reactor would do: route the exception to the handler. handler.exception(session, ex); - assertTrue(sessionRequest.isDone(), "Session request future must be completed"); - final ExecutionException ee = assertThrows(ExecutionException.class, sessionRequest::get); - assertSame(ex, ee.getCause(), "Cause must be the original EOF/close exception"); + Assertions.assertThat(sessionRequest.isDone()).withFailMessage("Session request future must be completed").isTrue(); + final ExecutionException ee = Assertions.assertThatThrownBy(sessionRequest::get).isInstanceOf(ExecutionException.class).asInstanceOf(InstanceOfAssertFactories.type(ExecutionException.class)).actual(); + Assertions.assertThat(ee.getCause()).withFailMessage("Cause must be the original EOF/close exception").isSameAs(ex); - assertEquals(CloseMode.IMMEDIATE, session.getLastCloseMode(), "Session must be closed immediately"); + Assertions.assertThat(session.getLastCloseMode()).withFailMessage("Session must be closed immediately").isEqualTo(CloseMode.IMMEDIATE); } private static final class TestIOSession implements IOSession { diff --git a/httpcore5/src/test/java/org/apache/hc/core5/reactor/ssl/SSLIOSessionTest.java b/httpcore5/src/test/java/org/apache/hc/core5/reactor/ssl/SSLIOSessionTest.java index ace6dc8d87..0666ced67c 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/reactor/ssl/SSLIOSessionTest.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/reactor/ssl/SSLIOSessionTest.java @@ -47,7 +47,7 @@ import org.apache.hc.core5.reactor.IOEventHandler; import org.apache.hc.core5.reactor.IOSession; import org.apache.hc.core5.util.Timeout; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.mockito.Mockito; @@ -133,8 +133,8 @@ void testConstructorWhenSSLEngineOk() { resultCallback); // Assert - Assertions.assertDoesNotThrow(() -> sslioSession.beginHandshake(ioSession)); - Assertions.assertEquals(protocol, sslioSession.getTlsDetails().getApplicationProtocol()); + Assertions.assertThatCode(() -> sslioSession.beginHandshake(ioSession)).doesNotThrowAnyException(); + Assertions.assertThat(sslioSession.getTlsDetails().getApplicationProtocol()).isEqualTo(protocol); } @Test @@ -149,8 +149,8 @@ void testConstructorWhenSSLEngineThrowsException() { resultCallback); // Assert - Assertions.assertDoesNotThrow(() -> sslioSession.beginHandshake(ioSession)); - Assertions.assertEquals(protocol, sslioSession.getTlsDetails().getApplicationProtocol()); + Assertions.assertThatCode(() -> sslioSession.beginHandshake(ioSession)).doesNotThrowAnyException(); + Assertions.assertThat(sslioSession.getTlsDetails().getApplicationProtocol()).isEqualTo(protocol); } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/ssl/SSLContextsTest.java b/httpcore5/src/test/java/org/apache/hc/core5/ssl/SSLContextsTest.java index 6fb082f6a0..4332b43da3 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/ssl/SSLContextsTest.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/ssl/SSLContextsTest.java @@ -27,10 +27,6 @@ package org.apache.hc.core5.ssl; -import static org.junit.jupiter.api.Assertions.assertAll; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertNotNull; - import java.security.KeyManagementException; import java.security.KeyStore; import java.security.KeyStoreException; @@ -41,6 +37,7 @@ import javax.net.ssl.SSLContext; import javax.net.ssl.TrustManagerFactory; +import org.assertj.core.api.SoftAssertions; import org.junit.jupiter.api.Test; class SSLContextsTest { @@ -48,22 +45,22 @@ class SSLContextsTest { @Test void createDefault() { final SSLContext sslContext = SSLContexts.createDefault(); - assertAll( - () -> assertNotNull(sslContext), - () -> assertEquals("Default", sslContext.getProtocol()), - () -> assertNotNull(sslContext.getProvider()) - ); + SoftAssertions.assertSoftly(softly -> { + softly.assertThat(sslContext).isNotNull(); + softly.assertThat(sslContext.getProtocol()).isEqualTo("Default"); + softly.assertThat(sslContext.getProvider()).isNotNull(); + }); } @Test @SuppressWarnings("deprecation") void createSystemDefault() { final SSLContext sslContext = SSLContexts.createSystemDefault(); - assertAll( - () -> assertNotNull(sslContext), - () -> assertEquals("Default", sslContext.getProtocol()), - () -> assertNotNull(sslContext.getProvider()) - ); + SoftAssertions.assertSoftly(softly -> { + softly.assertThat(sslContext).isNotNull(); + softly.assertThat(sslContext.getProtocol()).isEqualTo("Default"); + softly.assertThat(sslContext.getProvider()).isNotNull(); + }); } @Test @@ -80,10 +77,10 @@ void custom() throws NoSuchAlgorithmException, KeyStoreException, UnrecoverableK .loadKeyMaterial((KeyStore) null, null, null) .build(); - assertAll( - () -> assertNotNull(sslContext), - () -> assertEquals(SSLContextBuilder.TLS, sslContext.getProtocol()), - () -> assertEquals("SunJSSE", sslContext.getProvider().getName()) - ); + SoftAssertions.assertSoftly(softly -> { + softly.assertThat(sslContext).isNotNull(); + softly.assertThat(sslContext.getProtocol()).isEqualTo(SSLContextBuilder.TLS); + softly.assertThat(sslContext.getProvider().getName()).isEqualTo("SunJSSE"); + }); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/ssl/TestSSLContextBuilder.java b/httpcore5/src/test/java/org/apache/hc/core5/ssl/TestSSLContextBuilder.java index 16539124dc..234dec1a12 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/ssl/TestSSLContextBuilder.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/ssl/TestSSLContextBuilder.java @@ -63,8 +63,8 @@ import javax.net.ssl.TrustManagerFactory; import org.apache.hc.core5.util.Timeout; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.AfterEach; -import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.parallel.Isolated; @@ -108,9 +108,9 @@ void testBuildAllDefaults() throws Exception { .loadTrustMaterial((KeyStore) null, null) .loadKeyMaterial((KeyStore) null, null, null) .build(); - Assertions.assertNotNull(sslContext); - Assertions.assertEquals("TLS", sslContext.getProtocol()); - Assertions.assertEquals(PROVIDER_SUN_JSSE, sslContext.getProvider().getName()); + Assertions.assertThat(sslContext).isNotNull(); + Assertions.assertThat(sslContext.getProtocol()).isEqualTo("TLS"); + Assertions.assertThat(sslContext.getProvider().getName()).isEqualTo(PROVIDER_SUN_JSSE); } @Test @@ -125,9 +125,9 @@ void testBuildAllNull() throws Exception { .loadTrustMaterial((KeyStore) null, null) .loadKeyMaterial((KeyStore) null, null, null) .build(); - Assertions.assertNotNull(sslContext); - Assertions.assertEquals("TLS", sslContext.getProtocol()); - Assertions.assertEquals(PROVIDER_SUN_JSSE, sslContext.getProvider().getName()); + Assertions.assertThat(sslContext).isNotNull(); + Assertions.assertThat(sslContext.getProtocol()).isEqualTo("TLS"); + Assertions.assertThat(sslContext.getProvider().getName()).isEqualTo(PROVIDER_SUN_JSSE); } @Test @@ -138,13 +138,13 @@ void testBuildAllNull_deprecated() throws Exception { .loadTrustMaterial((KeyStore) null, null) .loadKeyMaterial((KeyStore) null, null, null) .build(); - Assertions.assertNotNull(sslContext); - Assertions.assertEquals("TLS", sslContext.getProtocol()); + Assertions.assertThat(sslContext).isNotNull(); + Assertions.assertThat(sslContext.getProtocol()).isEqualTo("TLS"); } @Test void testBuildDefault() { - Assertions.assertDoesNotThrow(() -> new SSLContextBuilder().build()); + Assertions.assertThatCode(() -> new SSLContextBuilder().build()).doesNotThrowAnyException(); } @Test @@ -152,11 +152,11 @@ void testBuildNoSuchKeyManagerFactoryAlgorithm() { final URL resource1 = getResource("/test-keypasswd.p12"); final String storePassword = "nopassword"; final String keyPassword = "password"; - Assertions.assertThrows(NoSuchAlgorithmException.class, () -> + Assertions.assertThatThrownBy(() -> SSLContextBuilder.create() .setKeyManagerFactoryAlgorithm(" BAD ") .loadKeyMaterial(resource1, storePassword.toCharArray(), keyPassword.toCharArray()) - .build()); + .build()).isInstanceOf(NoSuchAlgorithmException.class); } @Test @@ -164,22 +164,22 @@ void testBuildNoSuchKeyStoreType() { final URL resource1 = getResource("/test-keypasswd.p12"); final String storePassword = "nopassword"; final String keyPassword = "password"; - Assertions.assertThrows(KeyStoreException.class, () -> + Assertions.assertThatThrownBy(() -> SSLContextBuilder.create() .setKeyStoreType(" BAD ") .loadKeyMaterial(resource1, storePassword.toCharArray(), keyPassword.toCharArray()) - .build()); + .build()).isInstanceOf(KeyStoreException.class); } @Test void testBuildNoSuchTrustManagerFactoryAlgorithm() { final URL resource1 = getResource("/test-keypasswd.p12"); final String storePassword = "nopassword"; - Assertions.assertThrows(NoSuchAlgorithmException.class, () -> + Assertions.assertThatThrownBy(() -> SSLContextBuilder.create() .setTrustManagerFactoryAlgorithm(" BAD ") .loadTrustMaterial(resource1, storePassword.toCharArray()) - .build()); + .build()).isInstanceOf(NoSuchAlgorithmException.class); } @Test @@ -192,7 +192,7 @@ void testBuildWithProvider() throws Exception { .setProvider(provider) .loadKeyMaterial(resource1, storePassword.toCharArray(), keyPassword.toCharArray()) .build(); - Assertions.assertTrue(provider.hasBeenRequested("SSLContext")); + Assertions.assertThat(provider.hasBeenRequested("SSLContext")).isTrue(); } @Test @@ -209,7 +209,7 @@ void testBuildWithProviderName() throws Exception { .setProvider(DummyProvider.NAME) .loadKeyMaterial(resource1, storePassword.toCharArray(), keyPassword.toCharArray()) .build(); - Assertions.assertTrue(provider.hasBeenRequested("SSLContext")); + Assertions.assertThat(provider.hasBeenRequested("SSLContext")).isTrue(); } finally { Security.removeProvider(DummyProvider.NAME); @@ -218,10 +218,9 @@ void testBuildWithProviderName() throws Exception { @Test void testBuildKSWithNoSuchProvider() { - Assertions.assertThrows(NoSuchProviderException.class, - () -> SSLContextBuilder.create() + Assertions.assertThatThrownBy(() -> SSLContextBuilder.create() .setKeyStoreProvider("no-such-provider") - .build()); + .build()).isInstanceOf(NoSuchProviderException.class); } @Test @@ -234,7 +233,7 @@ void testBuildKSWithProvider() throws Exception { .setKeyStoreProvider(provider) .loadKeyMaterial(resource1, storePassword.toCharArray(), keyPassword.toCharArray()) .build(); - Assertions.assertTrue(provider.hasBeenRequested("KeyManagerFactory")); + Assertions.assertThat(provider.hasBeenRequested("KeyManagerFactory")).isTrue(); } @Test @@ -251,7 +250,7 @@ void testBuildKSWithProviderName() throws Exception { .setKeyStoreProvider(DummyProvider.NAME) .loadKeyMaterial(resource1, storePassword.toCharArray(), keyPassword.toCharArray()) .build(); - Assertions.assertTrue(provider.hasBeenRequested("KeyManagerFactory")); + Assertions.assertThat(provider.hasBeenRequested("KeyManagerFactory")).isTrue(); } finally { Security.removeProvider(DummyProvider.NAME); @@ -260,10 +259,10 @@ void testBuildKSWithProviderName() throws Exception { @Test void testBuildTSWithNoSuchProvider() { - Assertions.assertThrows(NoSuchProviderException.class, () -> + Assertions.assertThatThrownBy(() -> SSLContextBuilder.create() .setTrustStoreProvider("no-such-provider") - .build()); + .build()).isInstanceOf(NoSuchProviderException.class); } @Test @@ -273,7 +272,7 @@ void testBuildTSWithProvider() throws Exception { .setTrustStoreProvider(provider) .loadTrustMaterial((KeyStore) null, null) .build(); - Assertions.assertTrue(provider.hasBeenRequested("TrustManagerFactory")); + Assertions.assertThat(provider.hasBeenRequested("TrustManagerFactory")).isTrue(); } @Test @@ -287,7 +286,7 @@ void testBuildTSWithProviderName() throws Exception { .setTrustStoreProvider(DummyProvider.NAME) .loadTrustMaterial((KeyStore) null, null) .build(); - Assertions.assertTrue(provider.hasBeenRequested("TrustManagerFactory")); + Assertions.assertThat(provider.hasBeenRequested("TrustManagerFactory")).isTrue(); } finally { Security.removeProvider(DummyProvider.NAME); @@ -300,11 +299,11 @@ void testKeyWithAlternatePasswordInvalid() { final URL resource1 = getResource("/test-keypasswd.p12"); final String storePassword = "nopassword"; final String keyPassword = "!password"; - Assertions.assertThrows(UnrecoverableKeyException.class, () -> + Assertions.assertThatThrownBy(() -> SSLContextBuilder.create() .loadKeyMaterial(resource1, storePassword.toCharArray(), keyPassword.toCharArray()) .loadTrustMaterial(resource1, storePassword.toCharArray()) - .build()); + .build()).isInstanceOf(UnrecoverableKeyException.class); } @Test @@ -315,11 +314,11 @@ void testSSLHandshakeServerTrusted() throws Exception { final SSLContext serverSslContext = SSLContextBuilder.create() .loadKeyMaterial(resource1, storePassword.toCharArray(), keyPassword.toCharArray()) .build(); - Assertions.assertNotNull(serverSslContext); + Assertions.assertThat(serverSslContext).isNotNull(); final SSLContext clientSslContext = SSLContextBuilder.create() .loadTrustMaterial(resource1, storePassword.toCharArray()) .build(); - Assertions.assertNotNull(clientSslContext); + Assertions.assertThat(clientSslContext).isNotNull(); final ServerSocket serverSocket = serverSslContext.getServerSocketFactory().createServerSocket(); serverSocket.bind(new InetSocketAddress(InetAddress.getLoopbackAddress(), 0)); @@ -338,13 +337,13 @@ void testSSLHandshakeServerTrusted() throws Exception { clientSocket.connect(new InetSocketAddress("localhost", localPort), TIMEOUT.toMillisecondsIntBound()); clientSocket.setSoTimeout(TIMEOUT.toMillisecondsIntBound()); final InputStream inputStream = clientSocket.getInputStream(); - Assertions.assertEquals('H', inputStream.read()); - Assertions.assertEquals('i', inputStream.read()); - Assertions.assertEquals(-1, inputStream.read()); + Assertions.assertThat(inputStream.read()).isEqualTo('H'); + Assertions.assertThat(inputStream.read()).isEqualTo('i'); + Assertions.assertThat(inputStream.read()).isEqualTo(-1); } final Boolean result = future.get(5, TimeUnit.SECONDS); - Assertions.assertNotNull(result); + Assertions.assertThat(result).isNotNull(); } @Test @@ -355,12 +354,12 @@ void testSSLHandshakeServerNotTrusted() throws Exception { final SSLContext serverSslContext = SSLContextBuilder.create() .loadKeyMaterial(resource1, storePassword.toCharArray(), keyPassword.toCharArray()) .build(); - Assertions.assertNotNull(serverSslContext); + Assertions.assertThat(serverSslContext).isNotNull(); final URL resource2 = getResource("/test.p12"); final SSLContext clientSslContext = SSLContextBuilder.create() .loadTrustMaterial(resource2, storePassword.toCharArray()) .build(); - Assertions.assertNotNull(clientSslContext); + Assertions.assertThat(clientSslContext).isNotNull(); final ServerSocket serverSocket = serverSslContext.getServerSocketFactory().createServerSocket(); serverSocket.bind(new InetSocketAddress(InetAddress.getLoopbackAddress(), 0)); @@ -375,7 +374,7 @@ void testSSLHandshakeServerNotTrusted() throws Exception { try (final SSLSocket clientSocket = (SSLSocket) clientSslContext.getSocketFactory().createSocket()) { clientSocket.connect(new InetSocketAddress("localhost", localPort), TIMEOUT.toMillisecondsIntBound()); clientSocket.setSoTimeout(TIMEOUT.toMillisecondsIntBound()); - Assertions.assertThrows(IOException.class, clientSocket::startHandshake); + Assertions.assertThatThrownBy(clientSocket::startHandshake).isInstanceOf(IOException.class); } } @@ -387,7 +386,7 @@ void testSSLHandshakeServerCustomTrustStrategy() throws Exception { final SSLContext serverSslContext = SSLContextBuilder.create() .loadKeyMaterial(resource1, storePassword.toCharArray(), keyPassword.toCharArray()) .build(); - Assertions.assertNotNull(serverSslContext); + Assertions.assertThat(serverSslContext).isNotNull(); final AtomicReference certChainRef = new AtomicReference<>(); @@ -400,7 +399,7 @@ void testSSLHandshakeServerCustomTrustStrategy() throws Exception { .loadTrustMaterial(trustStrategy) .build(); - Assertions.assertNotNull(clientSslContext); + Assertions.assertThat(clientSslContext).isNotNull(); final ServerSocket serverSocket = serverSslContext.getServerSocketFactory().createServerSocket(); serverSocket.bind(new InetSocketAddress(InetAddress.getLoopbackAddress(), 0)); @@ -419,30 +418,30 @@ void testSSLHandshakeServerCustomTrustStrategy() throws Exception { clientSocket.connect(new InetSocketAddress("localhost", localPort), TIMEOUT.toMillisecondsIntBound()); clientSocket.setSoTimeout(TIMEOUT.toMillisecondsIntBound()); final InputStream inputStream = clientSocket.getInputStream(); - Assertions.assertEquals('H', inputStream.read()); - Assertions.assertEquals('i', inputStream.read()); - Assertions.assertEquals(-1, inputStream.read()); + Assertions.assertThat(inputStream.read()).isEqualTo('H'); + Assertions.assertThat(inputStream.read()).isEqualTo('i'); + Assertions.assertThat(inputStream.read()).isEqualTo(-1); } final Boolean result = future.get(5, TimeUnit.SECONDS); - Assertions.assertNotNull(result); + Assertions.assertThat(result).isNotNull(); final X509Certificate[] certs = certChainRef.get(); - Assertions.assertNotNull(certs); - Assertions.assertEquals(2, certs.length); + Assertions.assertThat(certs).isNotNull(); + Assertions.assertThat(certs.length).isEqualTo(2); final X509Certificate cert1 = certs[0]; final Principal subjectDN1 = cert1.getSubjectDN(); - Assertions.assertNotNull(subjectDN1); - Assertions.assertEquals("CN=Test Server, OU=HttpComponents Project, O=Apache Software Foundation", subjectDN1.getName()); + Assertions.assertThat(subjectDN1).isNotNull(); + Assertions.assertThat(subjectDN1.getName()).isEqualTo("CN=Test Server, OU=HttpComponents Project, O=Apache Software Foundation"); final X509Certificate cert2 = certs[1]; final Principal subjectDN2 = cert2.getSubjectDN(); - Assertions.assertNotNull(subjectDN2); - Assertions.assertEquals("EMAILADDRESS=dev@hc.apache.org, " + - "CN=Test CA, OU=HttpComponents Project, O=Apache Software Foundation", subjectDN2.getName()); + Assertions.assertThat(subjectDN2).isNotNull(); + Assertions.assertThat(subjectDN2.getName()).isEqualTo("EMAILADDRESS=dev@hc.apache.org, " + + "CN=Test CA, OU=HttpComponents Project, O=Apache Software Foundation"); final Principal issuerDN = cert2.getIssuerDN(); - Assertions.assertNotNull(issuerDN); - Assertions.assertEquals("EMAILADDRESS=dev@hc.apache.org, " + - "CN=Test CA, OU=HttpComponents Project, O=Apache Software Foundation", issuerDN.getName()); + Assertions.assertThat(issuerDN).isNotNull(); + Assertions.assertThat(issuerDN.getName()).isEqualTo("EMAILADDRESS=dev@hc.apache.org, " + + "CN=Test CA, OU=HttpComponents Project, O=Apache Software Foundation"); } @@ -454,12 +453,12 @@ void testSSLHandshakeClientUnauthenticated() throws Exception { final SSLContext serverSslContext = SSLContextBuilder.create() .loadKeyMaterial(resource1, storePassword.toCharArray(), keyPassword.toCharArray()) .build(); - Assertions.assertNotNull(serverSslContext); + Assertions.assertThat(serverSslContext).isNotNull(); final URL resource2 = getResource("/test-client.p12"); final SSLContext clientSslContext = SSLContextBuilder.create() .loadTrustMaterial(resource2, storePassword.toCharArray()) .build(); - Assertions.assertNotNull(clientSslContext); + Assertions.assertThat(clientSslContext).isNotNull(); final SSLServerSocket serverSocket = (SSLServerSocket) serverSslContext.getServerSocketFactory().createServerSocket(); serverSocket.setWantClientAuth(true); serverSocket.bind(new InetSocketAddress(InetAddress.getLoopbackAddress(), 0)); @@ -486,13 +485,13 @@ void testSSLHandshakeClientUnauthenticated() throws Exception { clientSocket.setSoTimeout(TIMEOUT.toMillisecondsIntBound()); clientSocket.startHandshake(); final InputStream inputStream = clientSocket.getInputStream(); - Assertions.assertEquals('H', inputStream.read()); - Assertions.assertEquals('i', inputStream.read()); - Assertions.assertEquals(-1, inputStream.read()); + Assertions.assertThat(inputStream.read()).isEqualTo('H'); + Assertions.assertThat(inputStream.read()).isEqualTo('i'); + Assertions.assertThat(inputStream.read()).isEqualTo(-1); } final Principal clientPrincipal = future.get(5, TimeUnit.SECONDS); - Assertions.assertNull(clientPrincipal); + Assertions.assertThat(clientPrincipal).isNull(); } @Test @@ -503,12 +502,12 @@ void testSSLHandshakeClientUnauthenticatedError() throws Exception { final SSLContext serverSslContext = SSLContextBuilder.create() .loadKeyMaterial(resource1, storePassword.toCharArray(), keyPassword.toCharArray()) .build(); - Assertions.assertNotNull(serverSslContext); + Assertions.assertThat(serverSslContext).isNotNull(); final URL resource2 = getResource("/test-client.p12"); final SSLContext clientSslContext = SSLContextBuilder.create() .loadTrustMaterial(resource2, storePassword.toCharArray()) .build(); - Assertions.assertNotNull(clientSslContext); + Assertions.assertThat(clientSslContext).isNotNull(); final SSLServerSocket serverSocket = (SSLServerSocket) serverSslContext.getServerSocketFactory().createServerSocket(); serverSocket.setNeedClientAuth(true); serverSocket.bind(new InetSocketAddress(InetAddress.getLoopbackAddress(), 0)); @@ -525,11 +524,11 @@ void testSSLHandshakeClientUnauthenticatedError() throws Exception { try (final SSLSocket clientSocket = (SSLSocket) clientSslContext.getSocketFactory().createSocket()) { clientSocket.connect(new InetSocketAddress("localhost", localPort), TIMEOUT.toMillisecondsIntBound()); clientSocket.setSoTimeout(TIMEOUT.toMillisecondsIntBound()); - Assertions.assertThrows(IOException.class, () -> { + Assertions.assertThatThrownBy(() -> { clientSocket.startHandshake(); final InputStream inputStream = clientSocket.getInputStream(); inputStream.read(); - }); + }).isInstanceOf(IOException.class); } } @@ -542,13 +541,13 @@ void testSSLHandshakeClientAuthenticated() throws Exception { .loadTrustMaterial(resource1, storePassword.toCharArray()) .loadKeyMaterial(resource1, storePassword.toCharArray(), keyPassword.toCharArray()) .build(); - Assertions.assertNotNull(serverSslContext); + Assertions.assertThat(serverSslContext).isNotNull(); final URL resource2 = getResource("/test-client.p12"); final SSLContext clientSslContext = SSLContextBuilder.create() .loadTrustMaterial(resource2, storePassword.toCharArray()) .loadKeyMaterial(resource2, storePassword.toCharArray(), storePassword.toCharArray()) .build(); - Assertions.assertNotNull(clientSslContext); + Assertions.assertThat(clientSslContext).isNotNull(); final SSLServerSocket serverSocket = (SSLServerSocket) serverSslContext.getServerSocketFactory().createServerSocket(); serverSocket.setNeedClientAuth(true); serverSocket.bind(new InetSocketAddress(InetAddress.getLoopbackAddress(), 0)); @@ -570,13 +569,13 @@ void testSSLHandshakeClientAuthenticated() throws Exception { clientSocket.setSoTimeout(TIMEOUT.toMillisecondsIntBound()); clientSocket.startHandshake(); final InputStream inputStream = clientSocket.getInputStream(); - Assertions.assertEquals('H', inputStream.read()); - Assertions.assertEquals('i', inputStream.read()); - Assertions.assertEquals(-1, inputStream.read()); + Assertions.assertThat(inputStream.read()).isEqualTo('H'); + Assertions.assertThat(inputStream.read()).isEqualTo('i'); + Assertions.assertThat(inputStream.read()).isEqualTo(-1); } final Principal clientPrincipal = future.get(5, TimeUnit.SECONDS); - Assertions.assertNotNull(clientPrincipal); + Assertions.assertThat(clientPrincipal).isNotNull(); } @Test @@ -588,7 +587,7 @@ void testSSLHandshakeClientAuthenticatedPrivateKeyStrategy() throws Exception { .loadTrustMaterial(resource1, storePassword.toCharArray()) .loadKeyMaterial(resource1, storePassword.toCharArray(), keyPassword.toCharArray()) .build(); - Assertions.assertNotNull(serverSslContext); + Assertions.assertThat(serverSslContext).isNotNull(); final PrivateKeyStrategy privateKeyStrategy = (aliases, sslParameters) -> aliases.containsKey("client2") ? "client2" : null; @@ -597,7 +596,7 @@ void testSSLHandshakeClientAuthenticatedPrivateKeyStrategy() throws Exception { .loadTrustMaterial(resource2, storePassword.toCharArray()) .loadKeyMaterial(resource2, storePassword.toCharArray(), storePassword.toCharArray(), privateKeyStrategy) .build(); - Assertions.assertNotNull(clientSslContext); + Assertions.assertThat(clientSslContext).isNotNull(); final SSLServerSocket serverSocket = (SSLServerSocket) serverSslContext.getServerSocketFactory().createServerSocket(); serverSocket.setNeedClientAuth(true); serverSocket.bind(new InetSocketAddress(InetAddress.getLoopbackAddress(), 0)); @@ -619,14 +618,14 @@ void testSSLHandshakeClientAuthenticatedPrivateKeyStrategy() throws Exception { clientSocket.setSoTimeout(TIMEOUT.toMillisecondsIntBound()); clientSocket.startHandshake(); final InputStream inputStream = clientSocket.getInputStream(); - Assertions.assertEquals('H', inputStream.read()); - Assertions.assertEquals('i', inputStream.read()); - Assertions.assertEquals(-1, inputStream.read()); + Assertions.assertThat(inputStream.read()).isEqualTo('H'); + Assertions.assertThat(inputStream.read()).isEqualTo('i'); + Assertions.assertThat(inputStream.read()).isEqualTo(-1); } final Principal clientPrincipal = future.get(5, TimeUnit.SECONDS); - Assertions.assertNotNull(clientPrincipal); - Assertions.assertEquals("CN=Test Client 2,OU=HttpComponents Project,O=Apache Software Foundation", clientPrincipal.getName()); + Assertions.assertThat(clientPrincipal).isNotNull(); + Assertions.assertThat(clientPrincipal.getName()).isEqualTo("CN=Test Client 2,OU=HttpComponents Project,O=Apache Software Foundation"); } @@ -638,15 +637,15 @@ void testSSLHandshakeProtocolMismatch1() throws Exception { final SSLContext serverSslContext = SSLContextBuilder.create() .loadKeyMaterial(resource1, storePassword.toCharArray(), keyPassword.toCharArray()) .build(); - Assertions.assertNotNull(serverSslContext); + Assertions.assertThat(serverSslContext).isNotNull(); final URL resource2 = getResource("/test-client.p12"); final SSLContext clientSslContext = SSLContextBuilder.create() .loadTrustMaterial(resource2, storePassword.toCharArray()) .build(); - Assertions.assertNotNull(clientSslContext); + Assertions.assertThat(clientSslContext).isNotNull(); final SSLServerSocket serverSocket = (SSLServerSocket) serverSslContext.getServerSocketFactory().createServerSocket(); final Set supportedServerProtocols = new LinkedHashSet<>(Arrays.asList(serverSocket.getSupportedProtocols())); - Assertions.assertTrue(supportedServerProtocols.contains("TLSv1")); + Assertions.assertThat(supportedServerProtocols.contains("TLSv1")).isTrue(); serverSocket.setEnabledProtocols(new String[] {"TLSv1"}); serverSocket.bind(new InetSocketAddress(InetAddress.getLoopbackAddress(), 0)); @@ -661,14 +660,14 @@ void testSSLHandshakeProtocolMismatch1() throws Exception { final int localPort = serverSocket.getLocalPort(); try (final SSLSocket clientSocket = (SSLSocket) clientSslContext.getSocketFactory().createSocket()) { final Set supportedClientProtocols = new LinkedHashSet<>(Arrays.asList(clientSocket.getSupportedProtocols())); - Assertions.assertTrue(supportedClientProtocols.contains("SSLv3")); + Assertions.assertThat(supportedClientProtocols.contains("SSLv3")).isTrue(); clientSocket.setEnabledProtocols(new String[] {"SSLv3"} ); clientSocket.connect(new InetSocketAddress("localhost", localPort), TIMEOUT.toMillisecondsIntBound()); clientSocket.setSoTimeout(TIMEOUT.toMillisecondsIntBound()); if (isWindows()) { - Assertions.assertThrows(IOException.class, clientSocket::startHandshake); + Assertions.assertThatThrownBy(clientSocket::startHandshake).isInstanceOf(IOException.class); } else { - Assertions.assertThrows(SSLException.class, clientSocket::startHandshake); + Assertions.assertThatThrownBy(clientSocket::startHandshake).isInstanceOf(SSLException.class); } } } @@ -681,15 +680,15 @@ void testSSLHandshakeProtocolMismatch2() throws Exception { final SSLContext serverSslContext = SSLContextBuilder.create() .loadKeyMaterial(resource1, storePassword.toCharArray(), keyPassword.toCharArray()) .build(); - Assertions.assertNotNull(serverSslContext); + Assertions.assertThat(serverSslContext).isNotNull(); final URL resource2 = getResource("/test-client.p12"); final SSLContext clientSslContext = SSLContextBuilder.create() .loadTrustMaterial(resource2, storePassword.toCharArray()) .build(); - Assertions.assertNotNull(clientSslContext); + Assertions.assertThat(clientSslContext).isNotNull(); final SSLServerSocket serverSocket = (SSLServerSocket) serverSslContext.getServerSocketFactory().createServerSocket(); final Set supportedServerProtocols = new LinkedHashSet<>(Arrays.asList(serverSocket.getSupportedProtocols())); - Assertions.assertTrue(supportedServerProtocols.contains("SSLv3")); + Assertions.assertThat(supportedServerProtocols.contains("SSLv3")).isTrue(); serverSocket.setEnabledProtocols(new String[] {"SSLv3"}); serverSocket.bind(new InetSocketAddress(InetAddress.getLoopbackAddress(), 0)); @@ -705,14 +704,14 @@ void testSSLHandshakeProtocolMismatch2() throws Exception { try (final SSLSocket clientSocket = (SSLSocket) clientSslContext.getSocketFactory().createSocket()) { final Set supportedClientProtocols = new LinkedHashSet<>( Arrays.asList(clientSocket.getSupportedProtocols())); - Assertions.assertTrue(supportedClientProtocols.contains("TLSv1")); + Assertions.assertThat(supportedClientProtocols.contains("TLSv1")).isTrue(); clientSocket.setEnabledProtocols(new String[]{"TLSv1"}); clientSocket.connect(new InetSocketAddress("localhost", localPort), TIMEOUT.toMillisecondsIntBound()); clientSocket.setSoTimeout(TIMEOUT.toMillisecondsIntBound()); if (isWindows()) { - Assertions.assertThrows(IOException.class, clientSocket::startHandshake); + Assertions.assertThatThrownBy(clientSocket::startHandshake).isInstanceOf(IOException.class); } else { - Assertions.assertThrows(SSLException.class, clientSocket::startHandshake); + Assertions.assertThatThrownBy(clientSocket::startHandshake).isInstanceOf(SSLException.class); } } } @@ -725,12 +724,12 @@ void testJSSEEndpointIdentification() throws Exception { final SSLContext serverSslContext = SSLContextBuilder.create() .loadKeyMaterial(resource1, storePassword.toCharArray(), keyPassword.toCharArray()) .build(); - Assertions.assertNotNull(serverSslContext); + Assertions.assertThat(serverSslContext).isNotNull(); final URL resource2 = getResource("/test-client.p12"); final SSLContext clientSslContext = SSLContextBuilder.create() .loadTrustMaterial(resource2, storePassword.toCharArray()) .build(); - Assertions.assertNotNull(clientSslContext); + Assertions.assertThat(clientSslContext).isNotNull(); final SSLServerSocket serverSocket = (SSLServerSocket) serverSslContext.getServerSocketFactory().createServerSocket(); serverSocket.bind(new InetSocketAddress(InetAddress.getLoopbackAddress(), 0)); @@ -768,7 +767,7 @@ void testJSSEEndpointIdentification() throws Exception { } final int localPort3 = serverSocket.getLocalPort(); - Assertions.assertThrows(SSLException.class, () -> { + Assertions.assertThatThrownBy(() -> { try (final Socket clientSocket = new Socket()) { clientSocket.connect(new InetSocketAddress("localhost", localPort3)); try (SSLSocket sslSocket = (SSLSocket) clientSslContext.getSocketFactory().createSocket(clientSocket, "otherhost", -1, true)) { @@ -778,7 +777,7 @@ void testJSSEEndpointIdentification() throws Exception { sslSocket.startHandshake(); } } - }); + }).isInstanceOf(SSLException.class); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/util/TestArgs.java b/httpcore5/src/test/java/org/apache/hc/core5/util/TestArgs.java index 7d645c8f9b..aaf27c2b92 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/util/TestArgs.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/util/TestArgs.java @@ -36,7 +36,7 @@ import java.util.Map; import java.util.Set; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; /** @@ -51,145 +51,145 @@ void testArgCheckPass() { @Test void testArgCheckFail() { - Assertions.assertThrows(IllegalArgumentException.class, () -> - Args.check(false, "Oopsie")); + Assertions.assertThatThrownBy(() -> + Args.check(false, "Oopsie")).isInstanceOf(IllegalArgumentException.class); } @Test void testArgNotNullPass() { final String stuff = "stuff"; - Assertions.assertSame(stuff, Args.notNull(stuff, "Stuff")); + Assertions.assertThat(Args.notNull(stuff, "Stuff")).isSameAs(stuff); } @Test void testArgNotNullFail() { - Assertions.assertThrows(NullPointerException.class, () -> - Args.notNull(null, "Stuff")); + Assertions.assertThatThrownBy(() -> + Args.notNull(null, "Stuff")).isInstanceOf(NullPointerException.class); } @Test void testArgNotEmptyPass() { final String stuff = "stuff"; - Assertions.assertSame(stuff, Args.notEmpty(stuff, "Stuff")); + Assertions.assertThat(Args.notEmpty(stuff, "Stuff")).isSameAs(stuff); } @Test void testArgNotEmptyFail1() { - Assertions.assertThrows(NullPointerException.class, () -> - Args.notEmpty((String) null, "Stuff")); + Assertions.assertThatThrownBy(() -> + Args.notEmpty((String) null, "Stuff")).isInstanceOf(NullPointerException.class); } @Test void testArgNotEmptyFail2() { - Assertions.assertThrows(IllegalArgumentException.class, () -> - Args.notEmpty("", "Stuff")); + Assertions.assertThatThrownBy(() -> + Args.notEmpty("", "Stuff")).isInstanceOf(IllegalArgumentException.class); } @Test void testArgNotBlankFail1() { - Assertions.assertThrows(NullPointerException.class, () -> - Args.notBlank((String) null, "Stuff")); + Assertions.assertThatThrownBy(() -> + Args.notBlank((String) null, "Stuff")).isInstanceOf(NullPointerException.class); } @Test void testArgNotBlankFail2() { - Assertions.assertThrows(IllegalArgumentException.class, () -> - Args.notBlank("", "Stuff")); + Assertions.assertThatThrownBy(() -> + Args.notBlank("", "Stuff")).isInstanceOf(IllegalArgumentException.class); } @Test void testArgNotBlankFail3() { - Assertions.assertThrows(IllegalArgumentException.class, () -> - Args.notBlank(" \t \n\r", "Stuff")); + Assertions.assertThatThrownBy(() -> + Args.notBlank(" \t \n\r", "Stuff")).isInstanceOf(IllegalArgumentException.class); } @Test void testArgCollectionNotEmptyPass() { final List list = Collections.singletonList("stuff"); - Assertions.assertSame(list, Args.notEmpty(list, "List")); + Assertions.assertThat(Args.notEmpty(list, "List")).isSameAs(list); } @Test void testArgCollectionNotEmptyFail1() { - Assertions.assertThrows(NullPointerException.class, () -> - Args.notEmpty((List) null, "List")); + Assertions.assertThatThrownBy(() -> + Args.notEmpty((List) null, "List")).isInstanceOf(NullPointerException.class); } @Test void testArgCollectionNotEmptyFail2() { - Assertions.assertThrows(IllegalArgumentException.class, () -> - Args.notEmpty(Collections.emptyList(), "List")); + Assertions.assertThatThrownBy(() -> + Args.notEmpty(Collections.emptyList(), "List")).isInstanceOf(IllegalArgumentException.class); } @Test void testPositiveIntPass() { - Assertions.assertEquals(1, Args.positive(1, "Number")); + Assertions.assertThat(Args.positive(1, "Number")).isEqualTo(1); } @Test void testPositiveIntFail1() { - Assertions.assertThrows(IllegalArgumentException.class, () -> - Args.positive(-1, "Number")); + Assertions.assertThatThrownBy(() -> + Args.positive(-1, "Number")).isInstanceOf(IllegalArgumentException.class); } @Test void testPositiveIntFail2() { - Assertions.assertThrows(IllegalArgumentException.class, () -> - Args.positive(0, "Number")); + Assertions.assertThatThrownBy(() -> + Args.positive(0, "Number")).isInstanceOf(IllegalArgumentException.class); } @Test void testPositiveLongPass() { - Assertions.assertEquals(1L, Args.positive(1L, "Number")); + Assertions.assertThat(Args.positive(1L, "Number")).isEqualTo(1L); } @Test void testPositiveTimeValuePass() throws ParseException { final Timeout timeout = Timeout.parse("1200 MILLISECONDS"); - Assertions.assertEquals(timeout, Args.positive(timeout, "No Error")); + Assertions.assertThat(Args.positive(timeout, "No Error")).isEqualTo(timeout); } @Test void testPositiveLongFail1() { - Assertions.assertThrows(IllegalArgumentException.class, () -> - Args.positive(-1L, "Number")); + Assertions.assertThatThrownBy(() -> + Args.positive(-1L, "Number")).isInstanceOf(IllegalArgumentException.class); } @Test void testPositiveLongFail2() { - Assertions.assertThrows(IllegalArgumentException.class, () -> - Args.positive(0L, "Number")); + Assertions.assertThatThrownBy(() -> + Args.positive(0L, "Number")).isInstanceOf(IllegalArgumentException.class); } @Test void testNotNegativeIntPass1() { - Assertions.assertEquals(1, Args.notNegative(1, "Number")); + Assertions.assertThat(Args.notNegative(1, "Number")).isEqualTo(1); } @Test void testNotNegativeIntPass2() { - Assertions.assertEquals(0, Args.notNegative(0, "Number")); + Assertions.assertThat(Args.notNegative(0, "Number")).isEqualTo(0); } @Test void testNotNegativeIntFail1() { - Assertions.assertThrows(IllegalArgumentException.class, () -> - Args.notNegative(-1, "Number")); + Assertions.assertThatThrownBy(() -> + Args.notNegative(-1, "Number")).isInstanceOf(IllegalArgumentException.class); } @Test void testNotNegativeLongPass1() { - Assertions.assertEquals(1L, Args.notNegative(1L, "Number")); + Assertions.assertThat(Args.notNegative(1L, "Number")).isEqualTo(1L); } @Test void testNotNegativeLongPass2() { - Assertions.assertEquals(0L, Args.notNegative(0L, "Number")); + Assertions.assertThat(Args.notNegative(0L, "Number")).isEqualTo(0L); } @Test void testNotNegativeLongFail1() { - Assertions.assertThrows(IllegalArgumentException.class, () -> - Args.notNegative(-1L, "Number")); + Assertions.assertThatThrownBy(() -> + Args.notNegative(-1L, "Number")).isInstanceOf(IllegalArgumentException.class); } @Test @@ -199,26 +199,26 @@ void testIntSmallestRangeOK() { @Test void testIntSmallestRangeFailLow() { - Assertions.assertThrows(IllegalArgumentException.class, () -> - Args.checkRange(-1, 0, 0, "Number")); + Assertions.assertThatThrownBy(() -> + Args.checkRange(-1, 0, 0, "Number")).isInstanceOf(IllegalArgumentException.class); } @Test void testIntRangeFailLow() { - Assertions.assertThrows(IllegalArgumentException.class, () -> - Args.checkRange(-101, -100, 100, "Number")); + Assertions.assertThatThrownBy(() -> + Args.checkRange(-101, -100, 100, "Number")).isInstanceOf(IllegalArgumentException.class); } @Test void testIntRangeFailHigh() { - Assertions.assertThrows(IllegalArgumentException.class, () -> - Args.checkRange(101, -100, 100, "Number")); + Assertions.assertThatThrownBy(() -> + Args.checkRange(101, -100, 100, "Number")).isInstanceOf(IllegalArgumentException.class); } @Test void testIntSmallestRangeFailHigh() { - Assertions.assertThrows(IllegalArgumentException.class, () -> - Args.checkRange(1, 0, 0, "Number")); + Assertions.assertThatThrownBy(() -> + Args.checkRange(1, 0, 0, "Number")).isInstanceOf(IllegalArgumentException.class); } @Test @@ -233,26 +233,26 @@ void testLongSmallestRangeOK() { @Test void testLongSmallestRangeFailLow() { - Assertions.assertThrows(IllegalArgumentException.class, () -> - Args.checkRange(-1L, 0L, 0L, "Number")); + Assertions.assertThatThrownBy(() -> + Args.checkRange(-1L, 0L, 0L, "Number")).isInstanceOf(IllegalArgumentException.class); } @Test void testLongRangeFailLow() { - Assertions.assertThrows(IllegalArgumentException.class, () -> - Args.checkRange(-101L, -100L, 100L, "Number")); + Assertions.assertThatThrownBy(() -> + Args.checkRange(-101L, -100L, 100L, "Number")).isInstanceOf(IllegalArgumentException.class); } @Test void testLongRangeFailHigh() { - Assertions.assertThrows(IllegalArgumentException.class, () -> - Args.checkRange(101L, -100L, 100L, "Number")); + Assertions.assertThatThrownBy(() -> + Args.checkRange(101L, -100L, 100L, "Number")).isInstanceOf(IllegalArgumentException.class); } @Test void testLongSmallestRangeFailHigh() { - Assertions.assertThrows(IllegalArgumentException.class, () -> - Args.checkRange(1L, 0L, 0L, "Number")); + Assertions.assertThatThrownBy(() -> + Args.checkRange(1L, 0L, 0L, "Number")).isInstanceOf(IllegalArgumentException.class); } @Test @@ -272,31 +272,31 @@ void testIsEmpty() { final Map NON_EMPTY_MAP = new HashMap<>(); NON_EMPTY_MAP.put("ABG", "MNL"); - Assertions.assertTrue(Args.isEmpty(null)); - Assertions.assertTrue(Args.isEmpty("")); - Assertions.assertTrue(Args.isEmpty(new int[] {})); - Assertions.assertTrue(Args.isEmpty(Collections.emptyList())); - Assertions.assertTrue(Args.isEmpty(Collections.emptySet())); - Assertions.assertTrue(Args.isEmpty(Collections.emptyMap())); + Assertions.assertThat(Args.isEmpty(null)).isTrue(); + Assertions.assertThat(Args.isEmpty("")).isTrue(); + Assertions.assertThat(Args.isEmpty(new int[]{})).isTrue(); + Assertions.assertThat(Args.isEmpty(Collections.emptyList())).isTrue(); + Assertions.assertThat(Args.isEmpty(Collections.emptySet())).isTrue(); + Assertions.assertThat(Args.isEmpty(Collections.emptyMap())).isTrue(); - Assertions.assertFalse(Args.isEmpty(" ")); - Assertions.assertFalse(Args.isEmpty("ab")); - Assertions.assertFalse(Args.isEmpty(NON_EMPTY_ARRAY)); - Assertions.assertFalse(Args.isEmpty(NON_EMPTY_LIST)); - Assertions.assertFalse(Args.isEmpty(NON_EMPTY_SET)); - Assertions.assertFalse(Args.isEmpty(NON_EMPTY_MAP)); + Assertions.assertThat(Args.isEmpty(" ")).isFalse(); + Assertions.assertThat(Args.isEmpty("ab")).isFalse(); + Assertions.assertThat(Args.isEmpty(NON_EMPTY_ARRAY)).isFalse(); + Assertions.assertThat(Args.isEmpty(NON_EMPTY_LIST)).isFalse(); + Assertions.assertThat(Args.isEmpty(NON_EMPTY_SET)).isFalse(); + Assertions.assertThat(Args.isEmpty(NON_EMPTY_MAP)).isFalse(); } @Test void testContainsNoBlanks() { final String stuff = "abg"; - Assertions.assertSame(stuff, Args.containsNoBlanks(stuff, "abg")); + Assertions.assertThat(Args.containsNoBlanks(stuff, "abg")).isSameAs(stuff); } @Test void check() { - Assertions.assertThrows(IllegalArgumentException.class, () -> - Args.check(false, "Error,", "ABG")); + Assertions.assertThatThrownBy(() -> + Args.check(false, "Error,", "ABG")).isInstanceOf(IllegalArgumentException.class); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/util/TestAsserts.java b/httpcore5/src/test/java/org/apache/hc/core5/util/TestAsserts.java index 434d353270..8f9313b619 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/util/TestAsserts.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/util/TestAsserts.java @@ -27,7 +27,7 @@ package org.apache.hc.core5.util; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; /** @@ -42,44 +42,44 @@ void testExpressionCheckPass() { @Test void testExpressionCheckFail() { - Assertions.assertThrows(IllegalStateException.class, () -> - Asserts.check(false, "Oopsie")); + Assertions.assertThatThrownBy(() -> + Asserts.check(false, "Oopsie")).isInstanceOf(IllegalStateException.class); } @Test void testExpressionNotNullFail() { - Assertions.assertThrows(IllegalStateException.class, () -> - Asserts.notNull(null, "Stuff")); + Assertions.assertThatThrownBy(() -> + Asserts.notNull(null, "Stuff")).isInstanceOf(IllegalStateException.class); } @Test void testExpressionNotEmptyFail1() { - Assertions.assertThrows(IllegalStateException.class, () -> - Asserts.notEmpty(null, "Stuff")); + Assertions.assertThatThrownBy(() -> + Asserts.notEmpty(null, "Stuff")).isInstanceOf(IllegalStateException.class); } @Test void testExpressionNotEmptyFail2() { - Assertions.assertThrows(IllegalStateException.class, () -> - Asserts.notEmpty("", "Stuff")); + Assertions.assertThatThrownBy(() -> + Asserts.notEmpty("", "Stuff")).isInstanceOf(IllegalStateException.class); } @Test void testExpressionNotEmptyBlank1() { - Assertions.assertThrows(IllegalStateException.class, () -> - Asserts.notBlank(null, "Stuff")); + Assertions.assertThatThrownBy(() -> + Asserts.notBlank(null, "Stuff")).isInstanceOf(IllegalStateException.class); } @Test void testExpressionNotEmptyBlank2() { - Assertions.assertThrows(IllegalStateException.class, () -> - Asserts.notBlank("", "Stuff")); + Assertions.assertThatThrownBy(() -> + Asserts.notBlank("", "Stuff")).isInstanceOf(IllegalStateException.class); } @Test void testExpressionNotBlankFail3() { - Assertions.assertThrows(IllegalStateException.class, () -> - Asserts.notBlank(" \t \n\r", "Stuff")); + Assertions.assertThatThrownBy(() -> + Asserts.notBlank(" \t \n\r", "Stuff")).isInstanceOf(IllegalStateException.class); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/util/TestByteArrayBuffer.java b/httpcore5/src/test/java/org/apache/hc/core5/util/TestByteArrayBuffer.java index c2444b049b..ee5d55f208 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/util/TestByteArrayBuffer.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/util/TestByteArrayBuffer.java @@ -34,7 +34,7 @@ import java.nio.ByteBuffer; import java.nio.charset.StandardCharsets; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; /** @@ -46,129 +46,134 @@ class TestByteArrayBuffer { @Test void testConstructor() { final ByteArrayBuffer buffer = new ByteArrayBuffer(16); - Assertions.assertEquals(16, buffer.capacity()); - Assertions.assertEquals(0, buffer.length()); - Assertions.assertNotNull(buffer.array()); - Assertions.assertEquals(16, buffer.array().length); - Assertions.assertThrows(IllegalArgumentException.class, () -> new ByteArrayBuffer(-1)); + Assertions.assertThat(buffer.capacity()).isEqualTo(16); + Assertions.assertThat(buffer.length()).isEqualTo(0); + Assertions.assertThat(buffer.array()).isNotNull(); + Assertions.assertThat(buffer.array().length).isEqualTo(16); + Assertions.assertThatThrownBy(() -> + new ByteArrayBuffer(-1)) + .isInstanceOf(IllegalArgumentException.class); } @Test void testSimpleAppend() { final ByteArrayBuffer buffer = new ByteArrayBuffer(16); - Assertions.assertEquals(16, buffer.capacity()); - Assertions.assertEquals(0, buffer.length()); + Assertions.assertThat(buffer.capacity()).isEqualTo(16); + Assertions.assertThat(buffer.length()).isEqualTo(0); final byte[] b1 = buffer.toByteArray(); - Assertions.assertNotNull(b1); - Assertions.assertEquals(0, b1.length); - Assertions.assertTrue(buffer.isEmpty()); - Assertions.assertFalse(buffer.isFull()); + Assertions.assertThat(b1).isNotNull(); + Assertions.assertThat(b1.length).isEqualTo(0); + Assertions.assertThat(buffer.isEmpty()).isTrue(); + Assertions.assertThat(buffer.isFull()).isFalse(); final byte[] tmp = new byte[] { 1, 2, 3, 4}; buffer.append(tmp, 0, tmp.length); - Assertions.assertEquals(16, buffer.capacity()); - Assertions.assertEquals(4, buffer.length()); - Assertions.assertFalse(buffer.isEmpty()); - Assertions.assertFalse(buffer.isFull()); + Assertions.assertThat(buffer.capacity()).isEqualTo(16); + Assertions.assertThat(buffer.length()).isEqualTo(4); + Assertions.assertThat(buffer.isEmpty()).isFalse(); + Assertions.assertThat(buffer.isFull()).isFalse(); final byte[] b2 = buffer.toByteArray(); - Assertions.assertNotNull(b2); - Assertions.assertEquals(4, b2.length); + Assertions.assertThat(b2).isNotNull(); + Assertions.assertThat(b2.length).isEqualTo(4); for (int i = 0; i < tmp.length; i++) { - Assertions.assertEquals(tmp[i], b2[i]); - Assertions.assertEquals(tmp[i], buffer.byteAt(i)); + Assertions.assertThat(b2[i]).isEqualTo(tmp[i]); + Assertions.assertThat(buffer.byteAt(i)).isEqualTo(tmp[i]); } buffer.clear(); - Assertions.assertEquals(16, buffer.capacity()); - Assertions.assertEquals(0, buffer.length()); - Assertions.assertTrue(buffer.isEmpty()); - Assertions.assertFalse(buffer.isFull()); + Assertions.assertThat(buffer.capacity()).isEqualTo(16); + Assertions.assertThat(buffer.length()).isEqualTo(0); + Assertions.assertThat(buffer.isEmpty()).isTrue(); + Assertions.assertThat(buffer.isFull()).isFalse(); } @Test void testExpandAppend() { final ByteArrayBuffer buffer = new ByteArrayBuffer(4); - Assertions.assertEquals(4, buffer.capacity()); + Assertions.assertThat(buffer.capacity()).isEqualTo(4); final byte[] tmp = new byte[] { 1, 2, 3, 4}; buffer.append(tmp, 0, 2); buffer.append(tmp, 0, 4); buffer.append(tmp, 0, 0); - Assertions.assertEquals(8, buffer.capacity()); - Assertions.assertEquals(6, buffer.length()); + Assertions.assertThat(buffer.capacity()).isEqualTo(8); + Assertions.assertThat(buffer.length()).isEqualTo(6); buffer.append(tmp, 0, 4); - Assertions.assertEquals(16, buffer.capacity()); - Assertions.assertEquals(10, buffer.length()); + Assertions.assertThat(buffer.capacity()).isEqualTo(16); + Assertions.assertThat(buffer.length()).isEqualTo(10); } @Test void testAppendHeapByteBuffer() { final ByteArrayBuffer buffer = new ByteArrayBuffer(4); - Assertions.assertEquals(4, buffer.capacity()); + Assertions.assertThat(buffer.capacity()).isEqualTo(4); final ByteBuffer tmp = ByteBuffer.wrap(new byte[] { 1, 2, 3, 4, 5, 6}); buffer.append(tmp); - Assertions.assertFalse(tmp.hasRemaining(), "The input buffer should be drained"); - Assertions.assertEquals(8, buffer.capacity()); - Assertions.assertEquals(6, buffer.length()); + Assertions.assertThat(tmp.hasRemaining()).withFailMessage("The input buffer should be drained").isFalse(); + Assertions.assertThat(buffer.capacity()).isEqualTo(8); + Assertions.assertThat(buffer.length()).isEqualTo(6); tmp.clear(); buffer.append(tmp); - Assertions.assertFalse(tmp.hasRemaining(), "The input buffer should be drained"); - Assertions.assertEquals(16, buffer.capacity()); - Assertions.assertEquals(12, buffer.length()); - Assertions.assertArrayEquals(new byte[] {1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6}, buffer.toByteArray()); + Assertions.assertThat(tmp.hasRemaining()).withFailMessage("The input buffer should be drained").isFalse(); + Assertions.assertThat(buffer.capacity()).isEqualTo(16); + Assertions.assertThat(buffer.length()).isEqualTo(12); + Assertions.assertThat(buffer.toByteArray()) + .containsExactly(new byte[]{1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6}); } @Test void testAppendHeapByteBufferWithOffset() { final ByteArrayBuffer buffer = new ByteArrayBuffer(4); - Assertions.assertEquals(4, buffer.capacity()); + Assertions.assertThat(buffer.capacity()).isEqualTo(4); final ByteBuffer tmp = ByteBuffer.wrap(new byte[] { 7, 7, 1, 2, 3, 4, 5, 6, 7, 7}, 2, 6).slice(); - Assertions.assertTrue(tmp.arrayOffset() > 0, "Validate this is testing a buffer with an array offset"); + Assertions.assertThat(tmp.arrayOffset() > 0).withFailMessage("Validate this is testing a buffer with an array offset").isTrue(); buffer.append(tmp); - Assertions.assertFalse(tmp.hasRemaining(), "The input buffer should be drained"); - Assertions.assertEquals(8, buffer.capacity()); - Assertions.assertEquals(6, buffer.length()); + Assertions.assertThat(tmp.hasRemaining()).withFailMessage("The input buffer should be drained").isFalse(); + Assertions.assertThat(buffer.capacity()).isEqualTo(8); + Assertions.assertThat(buffer.length()).isEqualTo(6); tmp.clear(); - Assertions.assertEquals(6, tmp.remaining()); + Assertions.assertThat(tmp.remaining()).isEqualTo(6); buffer.append(tmp); - Assertions.assertFalse(tmp.hasRemaining(), "The input buffer should be drained"); - Assertions.assertEquals(16, buffer.capacity()); - Assertions.assertEquals(12, buffer.length()); - Assertions.assertArrayEquals(new byte[] {1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6}, buffer.toByteArray()); + Assertions.assertThat(tmp.hasRemaining()).withFailMessage("The input buffer should be drained").isFalse(); + Assertions.assertThat(buffer.capacity()).isEqualTo(16); + Assertions.assertThat(buffer.length()).isEqualTo(12); + Assertions.assertThat(buffer.toByteArray()) + .containsExactly(new byte[]{1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6}); } @Test void testAppendDirectByteBuffer() { final ByteArrayBuffer buffer = new ByteArrayBuffer(4); - Assertions.assertEquals(4, buffer.capacity()); + Assertions.assertThat(buffer.capacity()).isEqualTo(4); final ByteBuffer tmp = ByteBuffer.allocateDirect(6); tmp.put(new byte[] { 1, 2, 3, 4, 5, 6}).flip(); buffer.append(tmp); - Assertions.assertFalse(tmp.hasRemaining(), "The input buffer should be drained"); - Assertions.assertEquals(8, buffer.capacity()); - Assertions.assertEquals(6, buffer.length()); + Assertions.assertThat(tmp.hasRemaining()).withFailMessage("The input buffer should be drained").isFalse(); + Assertions.assertThat(buffer.capacity()).isEqualTo(8); + Assertions.assertThat(buffer.length()).isEqualTo(6); tmp.clear(); buffer.append(tmp); - Assertions.assertFalse(tmp.hasRemaining(), "The input buffer should be drained"); - Assertions.assertEquals(16, buffer.capacity()); - Assertions.assertEquals(12, buffer.length()); - Assertions.assertArrayEquals(new byte[] {1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6}, buffer.toByteArray()); + Assertions.assertThat(tmp.hasRemaining()).withFailMessage("The input buffer should be drained").isFalse(); + Assertions.assertThat(buffer.capacity()).isEqualTo(16); + Assertions.assertThat(buffer.length()).isEqualTo(12); + Assertions.assertThat(buffer.toByteArray()) + .containsExactly(new byte[]{1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6}); } @Test @@ -177,27 +182,37 @@ void testInvalidAppend() { buffer.append((byte[])null, 0, 0); final byte[] tmp = new byte[] { 1, 2, 3, 4}; - Assertions.assertThrows(IndexOutOfBoundsException.class, () -> buffer.append(tmp, -1, 0)); - Assertions.assertThrows(IndexOutOfBoundsException.class, () -> buffer.append(tmp, 0, -1)); - Assertions.assertThrows(IndexOutOfBoundsException.class, () -> buffer.append(tmp, 0, 8)); - Assertions.assertThrows(IndexOutOfBoundsException.class, () -> buffer.append(tmp, 10, Integer.MAX_VALUE)); - Assertions.assertThrows(IndexOutOfBoundsException.class, () -> buffer.append(tmp, 2, 4)); + Assertions.assertThatThrownBy(() -> + buffer.append(tmp, -1, 0)) + .isInstanceOf(IndexOutOfBoundsException.class); + Assertions.assertThatThrownBy(() -> + buffer.append(tmp, 0, -1)) + .isInstanceOf(IndexOutOfBoundsException.class); + Assertions.assertThatThrownBy(() -> + buffer.append(tmp, 0, 8)) + .isInstanceOf(IndexOutOfBoundsException.class); + Assertions.assertThatThrownBy(() -> + buffer.append(tmp, 10, Integer.MAX_VALUE)) + .isInstanceOf(IndexOutOfBoundsException.class); + Assertions.assertThatThrownBy(() -> + buffer.append(tmp, 2, 4)) + .isInstanceOf(IndexOutOfBoundsException.class); } @Test void testAppendOneByte() { final ByteArrayBuffer buffer = new ByteArrayBuffer(4); - Assertions.assertEquals(4, buffer.capacity()); + Assertions.assertThat(buffer.capacity()).isEqualTo(4); final byte[] tmp = new byte[] { 1, 127, -1, -128, 1, -2}; for (final byte element : tmp) { buffer.append(element); } - Assertions.assertEquals(8, buffer.capacity()); - Assertions.assertEquals(6, buffer.length()); + Assertions.assertThat(buffer.capacity()).isEqualTo(8); + Assertions.assertThat(buffer.length()).isEqualTo(6); for (int i = 0; i < tmp.length; i++) { - Assertions.assertEquals(tmp[i], buffer.byteAt(i)); + Assertions.assertThat(buffer.byteAt(i)).isEqualTo(tmp[i]); } } @@ -205,23 +220,27 @@ void testAppendOneByte() { void testSetLength() { final ByteArrayBuffer buffer = new ByteArrayBuffer(4); buffer.setLength(2); - Assertions.assertEquals(2, buffer.length()); + Assertions.assertThat(buffer.length()).isEqualTo(2); } @Test void testSetInvalidLength() { final ByteArrayBuffer buffer = new ByteArrayBuffer(4); - Assertions.assertThrows(IndexOutOfBoundsException.class, () -> buffer.setLength(-2)); - Assertions.assertThrows(IndexOutOfBoundsException.class, () -> buffer.setLength(200)); + Assertions.assertThatThrownBy(() -> + buffer.setLength(-2)) + .isInstanceOf(IndexOutOfBoundsException.class); + Assertions.assertThatThrownBy(() -> + buffer.setLength(200)) + .isInstanceOf(IndexOutOfBoundsException.class); } @Test void testEnsureCapacity() { final ByteArrayBuffer buffer = new ByteArrayBuffer(4); buffer.ensureCapacity(2); - Assertions.assertEquals(4, buffer.capacity()); + Assertions.assertThat(buffer.capacity()).isEqualTo(4); buffer.ensureCapacity(8); - Assertions.assertEquals(8, buffer.capacity()); + Assertions.assertThat(buffer.capacity()).isEqualTo(8); } @Test @@ -235,12 +254,12 @@ void testIndexOf() { final ByteArrayBuffer buffer = new ByteArrayBuffer(16); buffer.append(bytes, 0, bytes.length); - Assertions.assertEquals(index1, buffer.indexOf(COLON)); - Assertions.assertEquals(-1, buffer.indexOf(COMMA)); - Assertions.assertEquals(index1, buffer.indexOf(COLON, -1, 11)); - Assertions.assertEquals(index1, buffer.indexOf(COLON, 0, 1000)); - Assertions.assertEquals(-1, buffer.indexOf(COLON, 2, 1)); - Assertions.assertEquals(index2, buffer.indexOf(COLON, index1 + 1, buffer.length())); + Assertions.assertThat(buffer.indexOf(COLON)).isEqualTo(index1); + Assertions.assertThat(buffer.indexOf(COMMA)).isEqualTo(-1); + Assertions.assertThat(buffer.indexOf(COLON, -1, 11)).isEqualTo(index1); + Assertions.assertThat(buffer.indexOf(COLON, 0, 1000)).isEqualTo(index1); + Assertions.assertThat(buffer.indexOf(COLON, 2, 1)).isEqualTo(-1); + Assertions.assertThat(buffer.indexOf(COLON, index1 + 1, buffer.length())).isEqualTo(index2); } @Test @@ -254,28 +273,28 @@ void testAppendCharArrayAsAscii() { buffer.append(b1, 0, b1.length); buffer.append(b2, 0, b2.length); - Assertions.assertEquals(s1 + s2, new String(buffer.toByteArray(), StandardCharsets.US_ASCII)); + Assertions.assertThat(new String(buffer.toByteArray(), StandardCharsets.US_ASCII)).isEqualTo(s1 + s2); } @Test void testAppendNullCharArray() { final ByteArrayBuffer buffer = new ByteArrayBuffer(8); buffer.append((char[])null, 0, 0); - Assertions.assertEquals(0, buffer.length()); + Assertions.assertThat(buffer.length()).isEqualTo(0); } @Test void testAppendEmptyCharArray() { final ByteArrayBuffer buffer = new ByteArrayBuffer(8); buffer.append(new char[] {}, 0, 0); - Assertions.assertEquals(0, buffer.length()); + Assertions.assertThat(buffer.length()).isEqualTo(0); } @Test void testAppendNullCharArrayBuffer() { final ByteArrayBuffer buffer = new ByteArrayBuffer(8); buffer.append((CharArrayBuffer)null, 0, 0); - Assertions.assertEquals(0, buffer.length()); + Assertions.assertThat(buffer.length()).isEqualTo(0); } @Test @@ -283,7 +302,7 @@ void testAppendNullByteBuffer() { final ByteArrayBuffer buffer = new ByteArrayBuffer(8); final ByteBuffer nullBuffer = null; buffer.append(nullBuffer); - Assertions.assertEquals(0, buffer.length()); + Assertions.assertThat(buffer.length()).isEqualTo(0); } @Test @@ -292,11 +311,21 @@ void testInvalidAppendCharArrayAsAscii() { buffer.append((char[])null, 0, 0); final char[] tmp = new char[] { '1', '2', '3', '4'}; - Assertions.assertThrows(IndexOutOfBoundsException.class, () -> buffer.append(tmp, -1, 0)); - Assertions.assertThrows(IndexOutOfBoundsException.class, () -> buffer.append(tmp, 0, -1)); - Assertions.assertThrows(IndexOutOfBoundsException.class, () -> buffer.append(tmp, 0, 8)); - Assertions.assertThrows(IndexOutOfBoundsException.class, () -> buffer.append(tmp, 10, Integer.MAX_VALUE)); - Assertions.assertThrows(IndexOutOfBoundsException.class, () -> buffer.append(tmp, 2, 4)); + Assertions.assertThatThrownBy(() -> + buffer.append(tmp, -1, 0)) + .isInstanceOf(IndexOutOfBoundsException.class); + Assertions.assertThatThrownBy(() -> + buffer.append(tmp, 0, -1)) + .isInstanceOf(IndexOutOfBoundsException.class); + Assertions.assertThatThrownBy(() -> + buffer.append(tmp, 0, 8)) + .isInstanceOf(IndexOutOfBoundsException.class); + Assertions.assertThatThrownBy(() -> + buffer.append(tmp, 10, Integer.MAX_VALUE)) + .isInstanceOf(IndexOutOfBoundsException.class); + Assertions.assertThatThrownBy(() -> + buffer.append(tmp, 2, 4)) + .isInstanceOf(IndexOutOfBoundsException.class); } @Test @@ -313,14 +342,14 @@ void testSerialization() throws Exception { final ByteArrayInputStream inBuffer = new ByteArrayInputStream(raw); final ObjectInputStream inStream = new ObjectInputStream(inBuffer); final ByteArrayBuffer clone = (ByteArrayBuffer) inStream.readObject(); - Assertions.assertEquals(orig.capacity(), clone.capacity()); - Assertions.assertEquals(orig.length(), clone.length()); + Assertions.assertThat(clone.capacity()).isEqualTo(orig.capacity()); + Assertions.assertThat(clone.length()).isEqualTo(orig.length()); final byte[] data = clone.toByteArray(); - Assertions.assertNotNull(data); - Assertions.assertEquals(3, data.length); - Assertions.assertEquals(1, data[0]); - Assertions.assertEquals(2, data[1]); - Assertions.assertEquals(3, data[2]); + Assertions.assertThat(data).isNotNull(); + Assertions.assertThat(data.length).isEqualTo(3); + Assertions.assertThat(data[0]).isEqualTo((byte) 1); + Assertions.assertThat(data[1]).isEqualTo((byte) 2); + Assertions.assertThat(data[2]).isEqualTo((byte) 3); } @Test @@ -332,8 +361,7 @@ void testControlCharFiltering() { final byte[] bytes = asByteArray(chars); - Assertions.assertEquals( - "?????????\t??????????????????????" + Assertions.assertThat(new String(bytes, StandardCharsets.ISO_8859_1)).isEqualTo("?????????\t??????????????????????" + " !\"#$%&'()*+,-./0123456789:;<=>?" + "@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_" + "`abcdefghijklmnopqrstuvwxyz" @@ -341,21 +369,20 @@ void testControlCharFiltering() { + "??????????\u00A0¡¢£¤¥¦§¨©ª«¬\u00AD®¯" + "°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏ" + "ÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîï" - + "ðñòóôõö÷øùúûüýþÿ", - new String(bytes, StandardCharsets.ISO_8859_1)); + + "ðñòóôõö÷øùúûüýþÿ"); } @Test void testUnicodeFiltering() { // Various languages - Assertions.assertEquals("?????", new String(asByteArray("буквы".toCharArray()), StandardCharsets.ISO_8859_1)); - Assertions.assertEquals("????", new String(asByteArray("四字熟語".toCharArray()), StandardCharsets.ISO_8859_1)); + Assertions.assertThat(new String(asByteArray("буквы".toCharArray()), StandardCharsets.ISO_8859_1)).isEqualTo("?????"); + Assertions.assertThat(new String(asByteArray("四字熟語".toCharArray()), StandardCharsets.ISO_8859_1)).isEqualTo("????"); // Unicode snowman - Assertions.assertEquals("?", new String(asByteArray("☃".toCharArray()), StandardCharsets.ISO_8859_1)); + Assertions.assertThat(new String(asByteArray("☃".toCharArray()), StandardCharsets.ISO_8859_1)).isEqualTo("?"); // Emoji (surrogate pair) - Assertions.assertEquals("??", new String(asByteArray("\uD83D\uDE00".toCharArray()), StandardCharsets.ISO_8859_1)); + Assertions.assertThat(new String(asByteArray("\uD83D\uDE00".toCharArray()), StandardCharsets.ISO_8859_1)).isEqualTo("??"); } private static byte[] asByteArray(final char[] chars) { diff --git a/httpcore5/src/test/java/org/apache/hc/core5/util/TestCharArrayBuffer.java b/httpcore5/src/test/java/org/apache/hc/core5/util/TestCharArrayBuffer.java index 50a9cb5936..03a0a7ed90 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/util/TestCharArrayBuffer.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/util/TestCharArrayBuffer.java @@ -33,7 +33,7 @@ import java.io.ObjectOutputStream; import java.nio.charset.StandardCharsets; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; /** @@ -45,66 +45,68 @@ class TestCharArrayBuffer { @Test void testConstructor() { final CharArrayBuffer buffer = new CharArrayBuffer(16); - Assertions.assertEquals(16, buffer.capacity()); - Assertions.assertEquals(0, buffer.length()); - Assertions.assertNotNull(buffer.array()); - Assertions.assertEquals(16, buffer.array().length); - Assertions.assertThrows(IllegalArgumentException.class, () -> new CharArrayBuffer(-1)); + Assertions.assertThat(buffer.capacity()).isEqualTo(16); + Assertions.assertThat(buffer.length()).isEqualTo(0); + Assertions.assertThat(buffer.array()).isNotNull(); + Assertions.assertThat(buffer.array().length).isEqualTo(16); + Assertions.assertThatThrownBy(() -> + new CharArrayBuffer(-1)) + .isInstanceOf(IllegalArgumentException.class); } @Test void testSimpleAppend() { final CharArrayBuffer buffer = new CharArrayBuffer(16); - Assertions.assertEquals(16, buffer.capacity()); - Assertions.assertEquals(0, buffer.length()); + Assertions.assertThat(buffer.capacity()).isEqualTo(16); + Assertions.assertThat(buffer.length()).isEqualTo(0); final char[] b1 = buffer.toCharArray(); - Assertions.assertNotNull(b1); - Assertions.assertEquals(0, b1.length); - Assertions.assertTrue(buffer.isEmpty()); - Assertions.assertFalse(buffer.isFull()); + Assertions.assertThat(b1).isNotNull(); + Assertions.assertThat(b1.length).isEqualTo(0); + Assertions.assertThat(buffer.isEmpty()).isTrue(); + Assertions.assertThat(buffer.isFull()).isFalse(); final char[] tmp = new char[] { '1', '2', '3', '4'}; buffer.append(tmp, 0, tmp.length); - Assertions.assertEquals(16, buffer.capacity()); - Assertions.assertEquals(4, buffer.length()); - Assertions.assertFalse(buffer.isEmpty()); - Assertions.assertFalse(buffer.isFull()); + Assertions.assertThat(buffer.capacity()).isEqualTo(16); + Assertions.assertThat(buffer.length()).isEqualTo(4); + Assertions.assertThat(buffer.isEmpty()).isFalse(); + Assertions.assertThat(buffer.isFull()).isFalse(); final char[] b2 = buffer.toCharArray(); - Assertions.assertNotNull(b2); - Assertions.assertEquals(4, b2.length); + Assertions.assertThat(b2).isNotNull(); + Assertions.assertThat(b2.length).isEqualTo(4); for (int i = 0; i < tmp.length; i++) { - Assertions.assertEquals(tmp[i], b2[i]); - Assertions.assertEquals(tmp[i], buffer.charAt(i)); + Assertions.assertThat(b2[i]).isEqualTo(tmp[i]); + Assertions.assertThat(buffer.charAt(i)).isEqualTo(tmp[i]); } - Assertions.assertEquals("1234", buffer.toString()); + Assertions.assertThat(buffer.toString()).isEqualTo("1234"); buffer.clear(); - Assertions.assertEquals(16, buffer.capacity()); - Assertions.assertEquals(0, buffer.length()); - Assertions.assertTrue(buffer.isEmpty()); - Assertions.assertFalse(buffer.isFull()); + Assertions.assertThat(buffer.capacity()).isEqualTo(16); + Assertions.assertThat(buffer.length()).isEqualTo(0); + Assertions.assertThat(buffer.isEmpty()).isTrue(); + Assertions.assertThat(buffer.isFull()).isFalse(); } @Test void testExpandAppend() { final CharArrayBuffer buffer = new CharArrayBuffer(4); - Assertions.assertEquals(4, buffer.capacity()); + Assertions.assertThat(buffer.capacity()).isEqualTo(4); final char[] tmp = new char[] { '1', '2', '3', '4'}; buffer.append(tmp, 0, 2); buffer.append(tmp, 0, 4); buffer.append(tmp, 0, 0); - Assertions.assertEquals(8, buffer.capacity()); - Assertions.assertEquals(6, buffer.length()); + Assertions.assertThat(buffer.capacity()).isEqualTo(8); + Assertions.assertThat(buffer.length()).isEqualTo(6); buffer.append(tmp, 0, 4); - Assertions.assertEquals(16, buffer.capacity()); - Assertions.assertEquals(10, buffer.length()); + Assertions.assertThat(buffer.capacity()).isEqualTo(16); + Assertions.assertThat(buffer.length()).isEqualTo(10); - Assertions.assertEquals("1212341234", buffer.toString()); + Assertions.assertThat(buffer.toString()).isEqualTo("1212341234"); } @Test @@ -112,14 +114,14 @@ void testAppendString() { final CharArrayBuffer buffer = new CharArrayBuffer(8); buffer.append("stuff"); buffer.append(" and more stuff"); - Assertions.assertEquals("stuff and more stuff", buffer.toString()); + Assertions.assertThat(buffer.toString()).isEqualTo("stuff and more stuff"); } @Test void testAppendNullString() { final CharArrayBuffer buffer = new CharArrayBuffer(8); buffer.append((String)null); - Assertions.assertEquals("null", buffer.toString()); + Assertions.assertThat(buffer.toString()).isEqualTo("null"); } @Test @@ -129,7 +131,7 @@ void testAppendCharArrayBuffer() { final CharArrayBuffer buffer2 = new CharArrayBuffer(8); buffer2.append("stuff"); buffer2.append(buffer1); - Assertions.assertEquals("stuff and more stuff", buffer2.toString()); + Assertions.assertThat(buffer2.toString()).isEqualTo("stuff and more stuff"); } @Test @@ -137,7 +139,7 @@ void testAppendNullCharArrayBuffer() { final CharArrayBuffer buffer = new CharArrayBuffer(8); buffer.append((CharArrayBuffer)null); buffer.append((CharArrayBuffer)null, 0, 0); - Assertions.assertEquals("", buffer.toString()); + Assertions.assertThat(buffer.toString()).isEqualTo(""); } @Test @@ -149,7 +151,7 @@ void testAppendSingleChar() { buffer.append('4'); buffer.append('5'); buffer.append('6'); - Assertions.assertEquals("123456", buffer.toString()); + Assertions.assertThat(buffer.toString()).isEqualTo("123456"); } @Test @@ -158,69 +160,95 @@ void testInvalidCharArrayAppend() { buffer.append((char[])null, 0, 0); final char[] tmp = new char[] { '1', '2', '3', '4'}; - Assertions.assertThrows(IndexOutOfBoundsException.class, () -> buffer.append(tmp, -1, 0)); - Assertions.assertThrows(IndexOutOfBoundsException.class, () -> buffer.append(tmp, 0, -1)); - Assertions.assertThrows(IndexOutOfBoundsException.class, () -> buffer.append(tmp, 0, 8)); - Assertions.assertThrows(IndexOutOfBoundsException.class, () -> buffer.append(tmp, 10, Integer.MAX_VALUE)); - Assertions.assertThrows(IndexOutOfBoundsException.class, () -> buffer.append(tmp, 2, 4)); + Assertions.assertThatThrownBy(() -> + buffer.append(tmp, -1, 0)) + .isInstanceOf(IndexOutOfBoundsException.class); + Assertions.assertThatThrownBy(() -> + buffer.append(tmp, 0, -1)) + .isInstanceOf(IndexOutOfBoundsException.class); + Assertions.assertThatThrownBy(() -> + buffer.append(tmp, 0, 8)) + .isInstanceOf(IndexOutOfBoundsException.class); + Assertions.assertThatThrownBy(() -> + buffer.append(tmp, 10, Integer.MAX_VALUE)) + .isInstanceOf(IndexOutOfBoundsException.class); + Assertions.assertThatThrownBy(() -> + buffer.append(tmp, 2, 4)) + .isInstanceOf(IndexOutOfBoundsException.class); } @Test void testSetLength() { final CharArrayBuffer buffer = new CharArrayBuffer(4); buffer.setLength(2); - Assertions.assertEquals(2, buffer.length()); + Assertions.assertThat(buffer.length()).isEqualTo(2); } @Test void testSetInvalidLength() { final CharArrayBuffer buffer = new CharArrayBuffer(4); - Assertions.assertThrows(IndexOutOfBoundsException.class, () -> buffer.setLength(-2)); - Assertions.assertThrows(IndexOutOfBoundsException.class, () -> buffer.setLength(200)); + Assertions.assertThatThrownBy(() -> + buffer.setLength(-2)) + .isInstanceOf(IndexOutOfBoundsException.class); + Assertions.assertThatThrownBy(() -> + buffer.setLength(200)) + .isInstanceOf(IndexOutOfBoundsException.class); } @Test void testEnsureCapacity() { final CharArrayBuffer buffer = new CharArrayBuffer(4); buffer.ensureCapacity(2); - Assertions.assertEquals(4, buffer.capacity()); + Assertions.assertThat(buffer.capacity()).isEqualTo(4); buffer.ensureCapacity(8); - Assertions.assertEquals(8, buffer.capacity()); + Assertions.assertThat(buffer.capacity()).isEqualTo(8); } @Test void testIndexOf() { final CharArrayBuffer buffer = new CharArrayBuffer(16); buffer.append("name: value"); - Assertions.assertEquals(4, buffer.indexOf(':')); - Assertions.assertEquals(-1, buffer.indexOf(',')); - Assertions.assertEquals(4, buffer.indexOf(':', -1, 11)); - Assertions.assertEquals(4, buffer.indexOf(':', 0, 1000)); - Assertions.assertEquals(-1, buffer.indexOf(':', 2, 1)); + Assertions.assertThat(buffer.indexOf(':')).isEqualTo(4); + Assertions.assertThat(buffer.indexOf(',')).isEqualTo(-1); + Assertions.assertThat(buffer.indexOf(':', -1, 11)).isEqualTo(4); + Assertions.assertThat(buffer.indexOf(':', 0, 1000)).isEqualTo(4); + Assertions.assertThat(buffer.indexOf(':', 2, 1)).isEqualTo(-1); } @Test void testSubstring() { final CharArrayBuffer buffer = new CharArrayBuffer(16); buffer.append(" name: value "); - Assertions.assertEquals(5, buffer.indexOf(':')); - Assertions.assertEquals(" name", buffer.substring(0, 5)); - Assertions.assertEquals(" value ", buffer.substring(6, buffer.length())); - Assertions.assertEquals("name", buffer.substringTrimmed(0, 5)); - Assertions.assertEquals("value", buffer.substringTrimmed(6, buffer.length())); - Assertions.assertEquals("", buffer.substringTrimmed(13, buffer.length())); + Assertions.assertThat(buffer.indexOf(':')).isEqualTo(5); + Assertions.assertThat(buffer.substring(0, 5)).isEqualTo(" name"); + Assertions.assertThat(buffer.substring(6, buffer.length())).isEqualTo(" value "); + Assertions.assertThat(buffer.substringTrimmed(0, 5)).isEqualTo("name"); + Assertions.assertThat(buffer.substringTrimmed(6, buffer.length())).isEqualTo("value"); + Assertions.assertThat(buffer.substringTrimmed(13, buffer.length())).isEqualTo(""); } @Test void testSubstringIndexOfOutBound() { final CharArrayBuffer buffer = new CharArrayBuffer(16); buffer.append("stuff"); - Assertions.assertThrows(IndexOutOfBoundsException.class, () -> buffer.substring(-2, 10)); - Assertions.assertThrows(IndexOutOfBoundsException.class, () -> buffer.substringTrimmed(-2, 10)); - Assertions.assertThrows(IndexOutOfBoundsException.class, () -> buffer.substring(12, 10)); - Assertions.assertThrows(IndexOutOfBoundsException.class, () -> buffer.substringTrimmed(12, 10)); - Assertions.assertThrows(IndexOutOfBoundsException.class, () -> buffer.substring(2, 1)); - Assertions.assertThrows(IndexOutOfBoundsException.class, () -> buffer.substringTrimmed(2, 1)); + Assertions.assertThatThrownBy(() -> + buffer.substring(-2, 10)) + .isInstanceOf(IndexOutOfBoundsException.class); + Assertions.assertThatThrownBy(() -> + buffer.substringTrimmed(-2, 10)) + .isInstanceOf(IndexOutOfBoundsException.class); + Assertions.assertThatThrownBy(() -> + buffer.substring(12, 10)) + .isInstanceOf(IndexOutOfBoundsException.class); + Assertions.assertThatThrownBy(() -> + buffer.substringTrimmed(12, 10)) + .isInstanceOf(IndexOutOfBoundsException.class); + Assertions.assertThatThrownBy(() -> + buffer.substring(2, 1)) + .isInstanceOf(IndexOutOfBoundsException.class); + Assertions.assertThatThrownBy(() -> + buffer.substringTrimmed(2, 1)) + .isInstanceOf(IndexOutOfBoundsException.class); } @Test @@ -234,7 +262,7 @@ void testAppendAsciiByteArray() { buffer.append(b1, 0, b1.length); buffer.append(b2, 0, b2.length); - Assertions.assertEquals("stuff and more stuff", buffer.toString()); + Assertions.assertThat(buffer.toString()).isEqualTo("stuff and more stuff"); } @Test @@ -244,27 +272,27 @@ void testAppendISOByteArray() { final CharArrayBuffer buffer = new CharArrayBuffer(8); buffer.append(b, 0, b.length); final char[] ch = buffer.toCharArray(); - Assertions.assertNotNull(ch); - Assertions.assertEquals(5, ch.length); - Assertions.assertEquals(0x00, ch[0]); - Assertions.assertEquals(0x20, ch[1]); - Assertions.assertEquals(0x7F, ch[2]); - Assertions.assertEquals(0x80, ch[3]); - Assertions.assertEquals(0xFF, ch[4]); + Assertions.assertThat(ch).isNotNull(); + Assertions.assertThat(ch.length).isEqualTo(5); + Assertions.assertThat(ch[0]).isEqualTo((char) 0x00); + Assertions.assertThat(ch[1]).isEqualTo((char) 0x20); + Assertions.assertThat(ch[2]).isEqualTo((char) 0x7F); + Assertions.assertThat(ch[3]).isEqualTo((char) 0x80); + Assertions.assertThat(ch[4]).isEqualTo((char) 0xFF); } @Test void testAppendNullByteArray() { final CharArrayBuffer buffer = new CharArrayBuffer(8); buffer.append((byte[])null, 0, 0); - Assertions.assertEquals("", buffer.toString()); + Assertions.assertThat(buffer.toString()).isEqualTo(""); } @Test void testAppendNullByteArrayBuffer() { final CharArrayBuffer buffer = new CharArrayBuffer(8); buffer.append((ByteArrayBuffer)null, 0, 0); - Assertions.assertEquals("", buffer.toString()); + Assertions.assertThat(buffer.toString()).isEqualTo(""); } @Test @@ -273,11 +301,21 @@ void testInvalidAppendAsciiByteArray() { buffer.append((byte[])null, 0, 0); final byte[] tmp = new byte[] { '1', '2', '3', '4'}; - Assertions.assertThrows(IndexOutOfBoundsException.class, () -> buffer.append(tmp, -1, 0)); - Assertions.assertThrows(IndexOutOfBoundsException.class, () -> buffer.append(tmp, 0, -1)); - Assertions.assertThrows(IndexOutOfBoundsException.class, () -> buffer.append(tmp, 0, 8)); - Assertions.assertThrows(IndexOutOfBoundsException.class, () -> buffer.append(tmp, 10, Integer.MAX_VALUE)); - Assertions.assertThrows(IndexOutOfBoundsException.class, () -> buffer.append(tmp, 2, 4)); + Assertions.assertThatThrownBy(() -> + buffer.append(tmp, -1, 0)) + .isInstanceOf(IndexOutOfBoundsException.class); + Assertions.assertThatThrownBy(() -> + buffer.append(tmp, 0, -1)) + .isInstanceOf(IndexOutOfBoundsException.class); + Assertions.assertThatThrownBy(() -> + buffer.append(tmp, 0, 8)) + .isInstanceOf(IndexOutOfBoundsException.class); + Assertions.assertThatThrownBy(() -> + buffer.append(tmp, 10, Integer.MAX_VALUE)) + .isInstanceOf(IndexOutOfBoundsException.class); + Assertions.assertThatThrownBy(() -> + buffer.append(tmp, 2, 4)) + .isInstanceOf(IndexOutOfBoundsException.class); } @Test @@ -294,33 +332,38 @@ void testSerialization() throws Exception { final ByteArrayInputStream inBuffer = new ByteArrayInputStream(raw); final ObjectInputStream inStream = new ObjectInputStream(inBuffer); final CharArrayBuffer clone = (CharArrayBuffer) inStream.readObject(); - Assertions.assertEquals(orig.capacity(), clone.capacity()); - Assertions.assertEquals(orig.length(), clone.length()); + Assertions.assertThat(clone.capacity()).isEqualTo(orig.capacity()); + Assertions.assertThat(clone.length()).isEqualTo(orig.length()); final char[] data = clone.toCharArray(); - Assertions.assertNotNull(data); - Assertions.assertEquals(3, data.length); - Assertions.assertEquals('a', data[0]); - Assertions.assertEquals('b', data[1]); - Assertions.assertEquals('c', data[2]); + Assertions.assertThat(data).isNotNull(); + Assertions.assertThat(data.length).isEqualTo(3); + Assertions.assertThat(data[0]).isEqualTo('a'); + Assertions.assertThat(data[1]).isEqualTo('b'); + Assertions.assertThat(data[2]).isEqualTo('c'); } @Test void testSubSequence() { final CharArrayBuffer buffer = new CharArrayBuffer(16); buffer.append(" name: value "); - Assertions.assertEquals(5, buffer.indexOf(':')); - Assertions.assertEquals(" name", buffer.subSequence(0, 5).toString()); - Assertions.assertEquals(" value ", - buffer.subSequence(6, buffer.length()).toString()); + Assertions.assertThat(buffer.indexOf(':')).isEqualTo(5); + Assertions.assertThat(buffer.subSequence(0, 5).toString()).isEqualTo(" name"); + Assertions.assertThat(buffer.subSequence(6, buffer.length()).toString()).isEqualTo(" value "); } @Test void testSubSequenceIndexOfOutBound() { final CharArrayBuffer buffer = new CharArrayBuffer(16); buffer.append("stuff"); - Assertions.assertThrows(IndexOutOfBoundsException.class, () -> buffer.subSequence(-2, 10)); - Assertions.assertThrows(IndexOutOfBoundsException.class, () -> buffer.subSequence(12, 10)); - Assertions.assertThrows(IndexOutOfBoundsException.class, () -> buffer.subSequence(2, 1)); + Assertions.assertThatThrownBy(() -> + buffer.subSequence(-2, 10)) + .isInstanceOf(IndexOutOfBoundsException.class); + Assertions.assertThatThrownBy(() -> + buffer.subSequence(12, 10)) + .isInstanceOf(IndexOutOfBoundsException.class); + Assertions.assertThatThrownBy(() -> + buffer.subSequence(2, 1)) + .isInstanceOf(IndexOutOfBoundsException.class); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/util/TestDeadline.java b/httpcore5/src/test/java/org/apache/hc/core5/util/TestDeadline.java index d4e6b4784f..fa39d23711 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/util/TestDeadline.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/util/TestDeadline.java @@ -29,7 +29,7 @@ import java.text.ParseException; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; /** @@ -41,66 +41,66 @@ class TestDeadline { void testFormat() throws ParseException { final Deadline deadline = Deadline.fromUnixMilliseconds(1000); final Deadline deadline2 = Deadline.parse(deadline.toString()); - Assertions.assertEquals(1000, deadline2.getValue()); + Assertions.assertThat(deadline2.getValue()).isEqualTo(1000); } @Test void testIsBefore() { final long nowPlusOneMin = System.currentTimeMillis() + 60000; final Deadline deadline = Deadline.fromUnixMilliseconds(nowPlusOneMin); - Assertions.assertTrue(deadline.isBefore(nowPlusOneMin + 1)); + Assertions.assertThat(deadline.isBefore(nowPlusOneMin + 1)).isTrue(); } @Test void testIsExpired() { - Assertions.assertTrue(Deadline.fromUnixMilliseconds(0).isExpired()); - Assertions.assertTrue(Deadline.fromUnixMilliseconds(1).isExpired()); - Assertions.assertFalse(Deadline.MAX_VALUE.isExpired()); - Assertions.assertTrue(Deadline.MIN_VALUE.isExpired()); + Assertions.assertThat(Deadline.fromUnixMilliseconds(0).isExpired()).isTrue(); + Assertions.assertThat(Deadline.fromUnixMilliseconds(1).isExpired()).isTrue(); + Assertions.assertThat(Deadline.MAX_VALUE.isExpired()).isFalse(); + Assertions.assertThat(Deadline.MIN_VALUE.isExpired()).isTrue(); } @Test void testIsMax() { - Assertions.assertFalse(Deadline.fromUnixMilliseconds(0).isMax()); - Assertions.assertFalse(Deadline.fromUnixMilliseconds(1000).isMax()); - Assertions.assertFalse(Deadline.MIN_VALUE.isMax()); - Assertions.assertTrue(Deadline.MAX_VALUE.isMax()); + Assertions.assertThat(Deadline.fromUnixMilliseconds(0).isMax()).isFalse(); + Assertions.assertThat(Deadline.fromUnixMilliseconds(1000).isMax()).isFalse(); + Assertions.assertThat(Deadline.MIN_VALUE.isMax()).isFalse(); + Assertions.assertThat(Deadline.MAX_VALUE.isMax()).isTrue(); } @Test void testIsMin() { - Assertions.assertTrue(Deadline.fromUnixMilliseconds(0).isMin()); - Assertions.assertFalse(Deadline.fromUnixMilliseconds(1000).isMin()); - Assertions.assertFalse(Deadline.MAX_VALUE.isMin()); - Assertions.assertTrue(Deadline.MIN_VALUE.isMin()); + Assertions.assertThat(Deadline.fromUnixMilliseconds(0).isMin()).isTrue(); + Assertions.assertThat(Deadline.fromUnixMilliseconds(1000).isMin()).isFalse(); + Assertions.assertThat(Deadline.MAX_VALUE.isMin()).isFalse(); + Assertions.assertThat(Deadline.MIN_VALUE.isMin()).isTrue(); } @Test void testIsNotExpired() { - Assertions.assertFalse(Deadline.fromUnixMilliseconds(0).isNotExpired()); - Assertions.assertFalse(Deadline.fromUnixMilliseconds(1).isNotExpired()); - Assertions.assertTrue(Deadline.MAX_VALUE.isNotExpired()); - Assertions.assertFalse(Deadline.MIN_VALUE.isNotExpired()); + Assertions.assertThat(Deadline.fromUnixMilliseconds(0).isNotExpired()).isFalse(); + Assertions.assertThat(Deadline.fromUnixMilliseconds(1).isNotExpired()).isFalse(); + Assertions.assertThat(Deadline.MAX_VALUE.isNotExpired()).isTrue(); + Assertions.assertThat(Deadline.MIN_VALUE.isNotExpired()).isFalse(); } @Test void testMin() { - Assertions.assertEquals(Deadline.MIN_VALUE, Deadline.MIN_VALUE.min(Deadline.MAX_VALUE)); - Assertions.assertEquals(Deadline.MIN_VALUE, Deadline.MAX_VALUE.min(Deadline.MIN_VALUE)); + Assertions.assertThat(Deadline.MIN_VALUE.min(Deadline.MAX_VALUE)).isEqualTo(Deadline.MIN_VALUE); + Assertions.assertThat(Deadline.MAX_VALUE.min(Deadline.MIN_VALUE)).isEqualTo(Deadline.MIN_VALUE); // final Deadline deadline0 = Deadline.fromUnixMilliseconds(0); - Assertions.assertEquals(Deadline.MIN_VALUE, deadline0.min(Deadline.MIN_VALUE)); - Assertions.assertEquals(deadline0, deadline0.min(Deadline.MAX_VALUE)); + Assertions.assertThat(deadline0.min(Deadline.MIN_VALUE)).isEqualTo(Deadline.MIN_VALUE); + Assertions.assertThat(deadline0.min(Deadline.MAX_VALUE)).isEqualTo(deadline0); // final Deadline deadline1 = Deadline.fromUnixMilliseconds(0); - Assertions.assertEquals(Deadline.MIN_VALUE, deadline1.min(Deadline.MIN_VALUE)); - Assertions.assertEquals(deadline0, deadline1.min(Deadline.MAX_VALUE)); + Assertions.assertThat(deadline1.min(Deadline.MIN_VALUE)).isEqualTo(Deadline.MIN_VALUE); + Assertions.assertThat(deadline1.min(Deadline.MAX_VALUE)).isEqualTo(deadline0); } @Test void testParse() throws ParseException { final Deadline deadline = Deadline.parse("1969-12-31T17:00:01.000-0700"); - Assertions.assertEquals(1000, deadline.getValue()); + Assertions.assertThat(deadline.getValue()).isEqualTo(1000); } @Test @@ -108,9 +108,9 @@ void testRemaining() { final int oneHourInMillis = 60_000 * 60; final long nowPlusOneHour = System.currentTimeMillis() + oneHourInMillis; final Deadline deadline = Deadline.fromUnixMilliseconds(nowPlusOneHour); - Assertions.assertEquals(nowPlusOneHour, deadline.getValue()); - Assertions.assertTrue(deadline.remaining() > 0); - Assertions.assertTrue(deadline.remaining() <= oneHourInMillis); + Assertions.assertThat(deadline.getValue()).isEqualTo(nowPlusOneHour); + Assertions.assertThat(deadline.remaining() > 0).isTrue(); + Assertions.assertThat(deadline.remaining() <= oneHourInMillis).isTrue(); } @Test @@ -118,17 +118,17 @@ void testRemainingTimeValue() { final int oneHourInMillis = 60_000 * 60; final long nowPlusOneHour = System.currentTimeMillis() + oneHourInMillis; final Deadline deadline = Deadline.fromUnixMilliseconds(nowPlusOneHour); - Assertions.assertEquals(nowPlusOneHour, deadline.getValue()); - Assertions.assertTrue(deadline.remainingTimeValue().toNanoseconds() > 0); - Assertions.assertTrue(deadline.remainingTimeValue().toMicroseconds() > 0); - Assertions.assertTrue(deadline.remainingTimeValue().toMilliseconds() > 0); + Assertions.assertThat(deadline.getValue()).isEqualTo(nowPlusOneHour); + Assertions.assertThat(deadline.remainingTimeValue().toNanoseconds() > 0).isTrue(); + Assertions.assertThat(deadline.remainingTimeValue().toMicroseconds() > 0).isTrue(); + Assertions.assertThat(deadline.remainingTimeValue().toMilliseconds() > 0).isTrue(); } @Test void testValue() { final long nowPlusOneMin = System.currentTimeMillis() + 60000; final Deadline deadline = Deadline.fromUnixMilliseconds(nowPlusOneMin); - Assertions.assertEquals(nowPlusOneMin, deadline.getValue()); + Assertions.assertThat(deadline.getValue()).isEqualTo(nowPlusOneMin); } @Test @@ -137,7 +137,6 @@ void testOverflowHandling() { final TimeValue tenSeconds = TimeValue.ofMilliseconds(10000); // 10 seconds final Deadline deadline = Deadline.calculate(currentTime, tenSeconds); - Assertions.assertEquals(Deadline.MAX_VALUE, deadline, - "Overflow should result in the maximum deadline value."); + Assertions.assertThat(deadline).withFailMessage("Overflow should result in the maximum deadline value.").isEqualTo(Deadline.MAX_VALUE); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/util/TestDeadlineTimeoutException.java b/httpcore5/src/test/java/org/apache/hc/core5/util/TestDeadlineTimeoutException.java index d13a4d57f3..cbeb7a937e 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/util/TestDeadlineTimeoutException.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/util/TestDeadlineTimeoutException.java @@ -27,7 +27,7 @@ package org.apache.hc.core5.util; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class TestDeadlineTimeoutException { @@ -35,18 +35,16 @@ class TestDeadlineTimeoutException { @Test void testMessage() { final Deadline deadline = Deadline.fromUnixMilliseconds(1000).freeze(); - Assertions.assertTrue(deadline.isExpired(), deadline.toString()); + Assertions.assertThat(deadline.isExpired()).withFailMessage(deadline.toString()).isTrue(); final String format = deadline.formatTarget(); final TimeValue diff = TimeValue.ofMilliseconds(deadline.remaining()); - Assertions.assertEquals("Deadline: " + format + ", " + diff + " overdue", - DeadlineTimeoutException.from(deadline).getMessage()); + Assertions.assertThat(DeadlineTimeoutException.from(deadline).getMessage()).isEqualTo("Deadline: " + format + ", " + diff + " overdue"); } @Test void testInfiniteDeadlineMessage() { final Deadline deadline = Deadline.calculate(Timeout.ZERO_MILLISECONDS); - Assertions.assertEquals("No deadline (infinite)", - DeadlineTimeoutException.from(deadline).getMessage()); + Assertions.assertThat(DeadlineTimeoutException.from(deadline).getMessage()).isEqualTo("No deadline (infinite)"); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/util/TestLangUtils.java b/httpcore5/src/test/java/org/apache/hc/core5/util/TestLangUtils.java index d95ecb1df2..2e1a1da221 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/util/TestLangUtils.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/util/TestLangUtils.java @@ -27,7 +27,7 @@ package org.apache.hc.core5.util; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; /** @@ -41,14 +41,14 @@ void testBasicHash() { final Integer i = Integer.valueOf(1234); final int h1 = LangUtils.hashCode(LangUtils.HASH_SEED, i.hashCode()); final int h2 = LangUtils.hashCode(LangUtils.HASH_SEED, i); - Assertions.assertEquals(h1, h2); + Assertions.assertThat(h2).isEqualTo(h1); } @Test void testNullObjectHash() { final int h1 = LangUtils.hashCode(LangUtils.HASH_SEED, null); final int h2 = LangUtils.hashCode(LangUtils.HASH_SEED, 0); - Assertions.assertEquals(h1, h2); + Assertions.assertThat(h2).isEqualTo(h1); } @Test @@ -57,9 +57,9 @@ void testBooleanHash() { final int h2 = LangUtils.hashCode(LangUtils.HASH_SEED, false); final int h3 = LangUtils.hashCode(LangUtils.HASH_SEED, true); final int h4 = LangUtils.hashCode(LangUtils.HASH_SEED, false); - Assertions.assertNotEquals(h1, h2); - Assertions.assertEquals(h1, h3); - Assertions.assertEquals(h2, h4); + Assertions.assertThat(h2).isNotEqualTo(h1); + Assertions.assertThat(h3).isEqualTo(h1); + Assertions.assertThat(h4).isEqualTo(h2); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/util/TestTextUtils.java b/httpcore5/src/test/java/org/apache/hc/core5/util/TestTextUtils.java index 0c67cc4ebb..f809cb85ea 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/util/TestTextUtils.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/util/TestTextUtils.java @@ -27,7 +27,7 @@ package org.apache.hc.core5.util; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; /** @@ -38,44 +38,48 @@ class TestTextUtils { @Test void testTextEmpty() { - Assertions.assertTrue(TextUtils.isEmpty(null)); - Assertions.assertTrue(TextUtils.isEmpty("")); - Assertions.assertFalse(TextUtils.isEmpty("\t")); + Assertions.assertThat(TextUtils.isEmpty(null)).isTrue(); + Assertions.assertThat(TextUtils.isEmpty("")).isTrue(); + Assertions.assertThat(TextUtils.isEmpty("\t")).isFalse(); } @Test void testTextBlank() { - Assertions.assertTrue(TextUtils.isBlank(null)); - Assertions.assertTrue(TextUtils.isBlank("")); - Assertions.assertTrue(TextUtils.isBlank(" ")); - Assertions.assertTrue(TextUtils.isBlank("\t")); + Assertions.assertThat(TextUtils.isBlank(null)).isTrue(); + Assertions.assertThat(TextUtils.isBlank("")).isTrue(); + Assertions.assertThat(TextUtils.isBlank(" ")).isTrue(); + Assertions.assertThat(TextUtils.isBlank("\t")).isTrue(); } @Test void testTextContainsBlanks() { - Assertions.assertFalse(TextUtils.containsBlanks(null)); - Assertions.assertFalse(TextUtils.containsBlanks("")); - Assertions.assertTrue(TextUtils.containsBlanks(" ")); - Assertions.assertTrue(TextUtils.containsBlanks("\t")); - Assertions.assertTrue(TextUtils.containsBlanks(" a")); - Assertions.assertFalse(TextUtils.containsBlanks("a")); + Assertions.assertThat(TextUtils.containsBlanks(null)).isFalse(); + Assertions.assertThat(TextUtils.containsBlanks("")).isFalse(); + Assertions.assertThat(TextUtils.containsBlanks(" ")).isTrue(); + Assertions.assertThat(TextUtils.containsBlanks("\t")).isTrue(); + Assertions.assertThat(TextUtils.containsBlanks(" a")).isTrue(); + Assertions.assertThat(TextUtils.containsBlanks("a")).isFalse(); } @Test void testToHexString() { - Assertions.assertEquals("000c2001ff", TextUtils.toHexString(new byte[] { 0, 12, 32, 1 , -1})); - Assertions.assertNull(TextUtils.toHexString(null)); + Assertions.assertThat(TextUtils.toHexString(new byte[]{0, 12, 32, 1, -1})).isEqualTo("000c2001ff"); + Assertions.assertThat(TextUtils.toHexString(null)).isNull(); } @Test void testPrintableCharactersAndByteConversion() { for (int c = 0; c <= 0xFF; c++) { final boolean expected = c == '\t' || c >= 0x20 && c <= 0x7E || c >= 0xA0; - Assertions.assertEquals(expected, TextUtils.isPrintable(c), "Character: " + c); - Assertions.assertEquals(expected ? (byte) c : (byte) '?', TextUtils.castAsByte(c), "Character: " + c); + Assertions.assertThat(TextUtils.isPrintable(c)) + .as("Character: " + c) + .isEqualTo(expected); + Assertions.assertThat(TextUtils.castAsByte(c)) + .as("Character: " + c) + .isEqualTo(expected ? (byte) c : (byte) '?'); } - Assertions.assertTrue(TextUtils.isPrintable(0x20AC)); - Assertions.assertEquals((byte) '?', TextUtils.castAsByte(0x20AC)); + Assertions.assertThat(TextUtils.isPrintable(0x20AC)).isTrue(); + Assertions.assertThat(TextUtils.castAsByte(0x20AC)).isEqualTo((byte) '?'); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/util/TestTimeValue.java b/httpcore5/src/test/java/org/apache/hc/core5/util/TestTimeValue.java index e3d71a3f80..1149efd585 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/util/TestTimeValue.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/util/TestTimeValue.java @@ -32,37 +32,37 @@ import java.time.Duration; import java.util.concurrent.TimeUnit; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class TestTimeValue { private void checkToDays(final long value, final TimeUnit timeUnit) { - Assertions.assertEquals(timeUnit.toDays(value), TimeValue.of(value, timeUnit).toDays()); + Assertions.assertThat(TimeValue.of(value, timeUnit).toDays()).isEqualTo(timeUnit.toDays(value)); } private void checkToHours(final long value, final TimeUnit timeUnit) { - Assertions.assertEquals(timeUnit.toHours(value), TimeValue.of(value, timeUnit).toHours()); + Assertions.assertThat(TimeValue.of(value, timeUnit).toHours()).isEqualTo(timeUnit.toHours(value)); } private void checkToMicroseconds(final long value, final TimeUnit timeUnit) { - Assertions.assertEquals(timeUnit.toMicros(value), TimeValue.of(value, timeUnit).toMicroseconds()); + Assertions.assertThat(TimeValue.of(value, timeUnit).toMicroseconds()).isEqualTo(timeUnit.toMicros(value)); } private void checkToMilliseconds(final long value, final TimeUnit timeUnit) { - Assertions.assertEquals(timeUnit.toMillis(value), TimeValue.of(value, timeUnit).toMilliseconds()); + Assertions.assertThat(TimeValue.of(value, timeUnit).toMilliseconds()).isEqualTo(timeUnit.toMillis(value)); } private void checkToMinutes(final long value, final TimeUnit timeUnit) { - Assertions.assertEquals(timeUnit.toMinutes(value), TimeValue.of(value, timeUnit).toMinutes()); + Assertions.assertThat(TimeValue.of(value, timeUnit).toMinutes()).isEqualTo(timeUnit.toMinutes(value)); } private void checkToNanoseconds(final long value, final TimeUnit timeUnit) { - Assertions.assertEquals(timeUnit.toNanos(value), TimeValue.of(value, timeUnit).toNanoseconds()); + Assertions.assertThat(TimeValue.of(value, timeUnit).toNanoseconds()).isEqualTo(timeUnit.toNanos(value)); } private void checkToSeconds(final long value, final TimeUnit timeUnit) { - Assertions.assertEquals(timeUnit.toSeconds(value), TimeValue.of(value, timeUnit).toSeconds()); + Assertions.assertThat(TimeValue.of(value, timeUnit).toSeconds()).isEqualTo(timeUnit.toSeconds(value)); } private void test(final long value) { @@ -89,37 +89,37 @@ void test1() { @Test void testConvert() { - Assertions.assertEquals(0, TimeValue.ofMilliseconds(0).convert(TimeUnit.DAYS)); - Assertions.assertEquals(1000, TimeValue.ofSeconds(1).convert(TimeUnit.MILLISECONDS)); + Assertions.assertThat(TimeValue.ofMilliseconds(0).convert(TimeUnit.DAYS)).isEqualTo(0); + Assertions.assertThat(TimeValue.ofSeconds(1).convert(TimeUnit.MILLISECONDS)).isEqualTo(1000); } @Test void testDivide() { // nominator is 0, result should be 0. - Assertions.assertEquals(0, TimeValue.ofMilliseconds(0).divide(2).toDays()); - Assertions.assertEquals(0, TimeValue.ofMilliseconds(0).divide(2).toHours()); - Assertions.assertEquals(0, TimeValue.ofMilliseconds(0).divide(2).toMicroseconds()); - Assertions.assertEquals(0, TimeValue.ofMilliseconds(0).divide(2).toMilliseconds()); - Assertions.assertEquals(0, TimeValue.ofMilliseconds(0).divide(2).toMinutes()); - Assertions.assertEquals(0, TimeValue.ofMilliseconds(0).divide(2).toNanoseconds()); - Assertions.assertEquals(0, TimeValue.ofMilliseconds(0).divide(2).toSeconds()); - Assertions.assertEquals(0, TimeValue.ofMilliseconds(0).divide(2).toMillisecondsIntBound()); - Assertions.assertEquals(0, TimeValue.ofMilliseconds(0).divide(2).toSecondsIntBound()); + Assertions.assertThat(TimeValue.ofMilliseconds(0).divide(2).toDays()).isEqualTo(0); + Assertions.assertThat(TimeValue.ofMilliseconds(0).divide(2).toHours()).isEqualTo(0); + Assertions.assertThat(TimeValue.ofMilliseconds(0).divide(2).toMicroseconds()).isEqualTo(0); + Assertions.assertThat(TimeValue.ofMilliseconds(0).divide(2).toMilliseconds()).isEqualTo(0); + Assertions.assertThat(TimeValue.ofMilliseconds(0).divide(2).toMinutes()).isEqualTo(0); + Assertions.assertThat(TimeValue.ofMilliseconds(0).divide(2).toNanoseconds()).isEqualTo(0); + Assertions.assertThat(TimeValue.ofMilliseconds(0).divide(2).toSeconds()).isEqualTo(0); + Assertions.assertThat(TimeValue.ofMilliseconds(0).divide(2).toMillisecondsIntBound()).isEqualTo(0); + Assertions.assertThat(TimeValue.ofMilliseconds(0).divide(2).toSecondsIntBound()).isEqualTo(0); // - Assertions.assertEquals(50, TimeValue.ofMilliseconds(100).divide(2).toMilliseconds()); - Assertions.assertEquals(0, TimeValue.ofMinutes(1).divide(2).toSeconds()); - Assertions.assertEquals(30, TimeValue.ofMinutes(1).divide(2, TimeUnit.SECONDS).toSeconds()); - Assertions.assertEquals(30000, TimeValue.ofMinutes(1).divide(2, TimeUnit.MILLISECONDS).toMilliseconds()); + Assertions.assertThat(TimeValue.ofMilliseconds(100).divide(2).toMilliseconds()).isEqualTo(50); + Assertions.assertThat(TimeValue.ofMinutes(1).divide(2).toSeconds()).isEqualTo(0); + Assertions.assertThat(TimeValue.ofMinutes(1).divide(2, TimeUnit.SECONDS).toSeconds()).isEqualTo(30); + Assertions.assertThat(TimeValue.ofMinutes(1).divide(2, TimeUnit.MILLISECONDS).toMilliseconds()).isEqualTo(30000); } @Test void testDivideBy0() { - Assertions.assertThrows(ArithmeticException.class, () -> - TimeValue.ofMilliseconds(0).divide(0)); + Assertions.assertThatThrownBy(() -> + TimeValue.ofMilliseconds(0).divide(0)).isInstanceOf(ArithmeticException.class); } private void testFactory(final TimeUnit timeUnit) { - Assertions.assertEquals(timeUnit, TimeValue.of(1, timeUnit).getTimeUnit()); + Assertions.assertThat(TimeValue.of(1, timeUnit).getTimeUnit()).isEqualTo(timeUnit); // final Duration duration = Duration.of(1, TimeValue.toChronoUnit(timeUnit)); assertConvertion(duration); @@ -142,7 +142,7 @@ void testFactoryForDuration() { } private void assertConvertion(final Duration duration) { - Assertions.assertEquals(duration, TimeValue.of(duration).toDuration()); + Assertions.assertThat(TimeValue.of(duration).toDuration()).isEqualTo(duration); } @Test @@ -185,69 +185,69 @@ void testMin() { final TimeValue hours1 = TimeValue.ofHours(1); final TimeValue days1 = TimeValue.ofDays(1); // - Assertions.assertEquals(TimeValue.ZERO_MILLISECONDS, TimeValue.ZERO_MILLISECONDS.min(nanos1)); - Assertions.assertEquals(TimeValue.ZERO_MILLISECONDS, TimeValue.ZERO_MILLISECONDS.min(micros1)); - Assertions.assertEquals(TimeValue.ZERO_MILLISECONDS, TimeValue.ZERO_MILLISECONDS.min(millis1)); - Assertions.assertEquals(TimeValue.ZERO_MILLISECONDS, TimeValue.ZERO_MILLISECONDS.min(seconds1)); - Assertions.assertEquals(TimeValue.ZERO_MILLISECONDS, TimeValue.ZERO_MILLISECONDS.min(minutes1)); - Assertions.assertEquals(TimeValue.ZERO_MILLISECONDS, TimeValue.ZERO_MILLISECONDS.min(hours1)); - Assertions.assertEquals(TimeValue.ZERO_MILLISECONDS, TimeValue.ZERO_MILLISECONDS.min(days1)); + Assertions.assertThat(TimeValue.ZERO_MILLISECONDS.min(nanos1)).isEqualTo(TimeValue.ZERO_MILLISECONDS); + Assertions.assertThat(TimeValue.ZERO_MILLISECONDS.min(micros1)).isEqualTo(TimeValue.ZERO_MILLISECONDS); + Assertions.assertThat(TimeValue.ZERO_MILLISECONDS.min(millis1)).isEqualTo(TimeValue.ZERO_MILLISECONDS); + Assertions.assertThat(TimeValue.ZERO_MILLISECONDS.min(seconds1)).isEqualTo(TimeValue.ZERO_MILLISECONDS); + Assertions.assertThat(TimeValue.ZERO_MILLISECONDS.min(minutes1)).isEqualTo(TimeValue.ZERO_MILLISECONDS); + Assertions.assertThat(TimeValue.ZERO_MILLISECONDS.min(hours1)).isEqualTo(TimeValue.ZERO_MILLISECONDS); + Assertions.assertThat(TimeValue.ZERO_MILLISECONDS.min(days1)).isEqualTo(TimeValue.ZERO_MILLISECONDS); // - Assertions.assertEquals(nanos1, nanos1.min(nanos1)); - Assertions.assertEquals(nanos1, nanos1.min(micros1)); - Assertions.assertEquals(nanos1, nanos1.min(millis1)); - Assertions.assertEquals(nanos1, nanos1.min(seconds1)); - Assertions.assertEquals(nanos1, nanos1.min(minutes1)); - Assertions.assertEquals(nanos1, nanos1.min(hours1)); - Assertions.assertEquals(nanos1, nanos1.min(days1)); + Assertions.assertThat(nanos1.min(nanos1)).isEqualTo(nanos1); + Assertions.assertThat(nanos1.min(micros1)).isEqualTo(nanos1); + Assertions.assertThat(nanos1.min(millis1)).isEqualTo(nanos1); + Assertions.assertThat(nanos1.min(seconds1)).isEqualTo(nanos1); + Assertions.assertThat(nanos1.min(minutes1)).isEqualTo(nanos1); + Assertions.assertThat(nanos1.min(hours1)).isEqualTo(nanos1); + Assertions.assertThat(nanos1.min(days1)).isEqualTo(nanos1); // - Assertions.assertEquals(nanos1, micros1.min(nanos1)); - Assertions.assertEquals(micros1, micros1.min(micros1)); - Assertions.assertEquals(micros1, micros1.min(millis1)); - Assertions.assertEquals(micros1, micros1.min(seconds1)); - Assertions.assertEquals(micros1, micros1.min(minutes1)); - Assertions.assertEquals(micros1, micros1.min(hours1)); - Assertions.assertEquals(micros1, micros1.min(days1)); + Assertions.assertThat(micros1.min(nanos1)).isEqualTo(nanos1); + Assertions.assertThat(micros1.min(micros1)).isEqualTo(micros1); + Assertions.assertThat(micros1.min(millis1)).isEqualTo(micros1); + Assertions.assertThat(micros1.min(seconds1)).isEqualTo(micros1); + Assertions.assertThat(micros1.min(minutes1)).isEqualTo(micros1); + Assertions.assertThat(micros1.min(hours1)).isEqualTo(micros1); + Assertions.assertThat(micros1.min(days1)).isEqualTo(micros1); // - Assertions.assertEquals(nanos1, millis1.min(nanos1)); - Assertions.assertEquals(micros1, millis1.min(micros1)); - Assertions.assertEquals(millis1, millis1.min(millis1)); - Assertions.assertEquals(millis1, millis1.min(seconds1)); - Assertions.assertEquals(millis1, millis1.min(minutes1)); - Assertions.assertEquals(millis1, millis1.min(hours1)); - Assertions.assertEquals(millis1, millis1.min(days1)); + Assertions.assertThat(millis1.min(nanos1)).isEqualTo(nanos1); + Assertions.assertThat(millis1.min(micros1)).isEqualTo(micros1); + Assertions.assertThat(millis1.min(millis1)).isEqualTo(millis1); + Assertions.assertThat(millis1.min(seconds1)).isEqualTo(millis1); + Assertions.assertThat(millis1.min(minutes1)).isEqualTo(millis1); + Assertions.assertThat(millis1.min(hours1)).isEqualTo(millis1); + Assertions.assertThat(millis1.min(days1)).isEqualTo(millis1); // - Assertions.assertEquals(nanos1, seconds1.min(nanos1)); - Assertions.assertEquals(micros1, seconds1.min(micros1)); - Assertions.assertEquals(millis1, seconds1.min(millis1)); - Assertions.assertEquals(seconds1, seconds1.min(seconds1)); - Assertions.assertEquals(seconds1, seconds1.min(minutes1)); - Assertions.assertEquals(seconds1, seconds1.min(hours1)); - Assertions.assertEquals(seconds1, seconds1.min(days1)); + Assertions.assertThat(seconds1.min(nanos1)).isEqualTo(nanos1); + Assertions.assertThat(seconds1.min(micros1)).isEqualTo(micros1); + Assertions.assertThat(seconds1.min(millis1)).isEqualTo(millis1); + Assertions.assertThat(seconds1.min(seconds1)).isEqualTo(seconds1); + Assertions.assertThat(seconds1.min(minutes1)).isEqualTo(seconds1); + Assertions.assertThat(seconds1.min(hours1)).isEqualTo(seconds1); + Assertions.assertThat(seconds1.min(days1)).isEqualTo(seconds1); // - Assertions.assertEquals(nanos1, minutes1.min(nanos1)); - Assertions.assertEquals(micros1, minutes1.min(micros1)); - Assertions.assertEquals(millis1, minutes1.min(millis1)); - Assertions.assertEquals(seconds1, minutes1.min(seconds1)); - Assertions.assertEquals(minutes1, minutes1.min(minutes1)); - Assertions.assertEquals(minutes1, minutes1.min(hours1)); - Assertions.assertEquals(minutes1, minutes1.min(days1)); + Assertions.assertThat(minutes1.min(nanos1)).isEqualTo(nanos1); + Assertions.assertThat(minutes1.min(micros1)).isEqualTo(micros1); + Assertions.assertThat(minutes1.min(millis1)).isEqualTo(millis1); + Assertions.assertThat(minutes1.min(seconds1)).isEqualTo(seconds1); + Assertions.assertThat(minutes1.min(minutes1)).isEqualTo(minutes1); + Assertions.assertThat(minutes1.min(hours1)).isEqualTo(minutes1); + Assertions.assertThat(minutes1.min(days1)).isEqualTo(minutes1); // - Assertions.assertEquals(nanos1, hours1.min(nanos1)); - Assertions.assertEquals(micros1, hours1.min(micros1)); - Assertions.assertEquals(millis1, hours1.min(millis1)); - Assertions.assertEquals(seconds1, hours1.min(seconds1)); - Assertions.assertEquals(minutes1, hours1.min(minutes1)); - Assertions.assertEquals(hours1, hours1.min(hours1)); - Assertions.assertEquals(hours1, hours1.min(days1)); + Assertions.assertThat(hours1.min(nanos1)).isEqualTo(nanos1); + Assertions.assertThat(hours1.min(micros1)).isEqualTo(micros1); + Assertions.assertThat(hours1.min(millis1)).isEqualTo(millis1); + Assertions.assertThat(hours1.min(seconds1)).isEqualTo(seconds1); + Assertions.assertThat(hours1.min(minutes1)).isEqualTo(minutes1); + Assertions.assertThat(hours1.min(hours1)).isEqualTo(hours1); + Assertions.assertThat(hours1.min(days1)).isEqualTo(hours1); // - Assertions.assertEquals(nanos1, days1.min(nanos1)); - Assertions.assertEquals(micros1, days1.min(micros1)); - Assertions.assertEquals(millis1, days1.min(millis1)); - Assertions.assertEquals(seconds1, days1.min(seconds1)); - Assertions.assertEquals(minutes1, days1.min(minutes1)); - Assertions.assertEquals(hours1, days1.min(hours1)); - Assertions.assertEquals(days1, days1.min(days1)); + Assertions.assertThat(days1.min(nanos1)).isEqualTo(nanos1); + Assertions.assertThat(days1.min(micros1)).isEqualTo(micros1); + Assertions.assertThat(days1.min(millis1)).isEqualTo(millis1); + Assertions.assertThat(days1.min(seconds1)).isEqualTo(seconds1); + Assertions.assertThat(days1.min(minutes1)).isEqualTo(minutes1); + Assertions.assertThat(days1.min(hours1)).isEqualTo(hours1); + Assertions.assertThat(days1.min(days1)).isEqualTo(days1); } @Test @@ -267,26 +267,26 @@ void testNegative1() { @Test void testToString() { - Assertions.assertEquals("9223372036854775807 SECONDS", TimeValue.ofSeconds(Long.MAX_VALUE).toString()); - Assertions.assertEquals("0 MILLISECONDS", TimeValue.ZERO_MILLISECONDS.toString()); + Assertions.assertThat(TimeValue.ofSeconds(Long.MAX_VALUE).toString()).isEqualTo("9223372036854775807 SECONDS"); + Assertions.assertThat(TimeValue.ZERO_MILLISECONDS.toString()).isEqualTo("0 MILLISECONDS"); } @Test void testFromString() throws ParseException { final TimeValue maxSeconds = TimeValue.ofSeconds(Long.MAX_VALUE); - Assertions.assertEquals(maxSeconds, TimeValue.parse("9223372036854775807 SECONDS")); - Assertions.assertEquals(maxSeconds, TimeValue.parse("9223372036854775807 SECONDS")); - Assertions.assertEquals(maxSeconds, TimeValue.parse(" 9223372036854775807 SECONDS ")); - Assertions.assertEquals(maxSeconds, TimeValue.parse("9223372036854775807 Seconds")); - Assertions.assertEquals(maxSeconds, TimeValue.parse("9223372036854775807 Seconds")); - Assertions.assertEquals(maxSeconds, TimeValue.parse("9223372036854775807\tSeconds")); - Assertions.assertEquals(TimeValue.ZERO_MILLISECONDS, TimeValue.parse("0 MILLISECONDS")); - Assertions.assertEquals(TimeValue.ofMilliseconds(1), TimeValue.parse("1 MILLISECOND")); + Assertions.assertThat(TimeValue.parse("9223372036854775807 SECONDS")).isEqualTo(maxSeconds); + Assertions.assertThat(TimeValue.parse("9223372036854775807 SECONDS")).isEqualTo(maxSeconds); + Assertions.assertThat(TimeValue.parse(" 9223372036854775807 SECONDS ")).isEqualTo(maxSeconds); + Assertions.assertThat(TimeValue.parse("9223372036854775807 Seconds")).isEqualTo(maxSeconds); + Assertions.assertThat(TimeValue.parse("9223372036854775807 Seconds")).isEqualTo(maxSeconds); + Assertions.assertThat(TimeValue.parse("9223372036854775807\tSeconds")).isEqualTo(maxSeconds); + Assertions.assertThat(TimeValue.parse("0 MILLISECONDS")).isEqualTo(TimeValue.ZERO_MILLISECONDS); + Assertions.assertThat(TimeValue.parse("1 MILLISECOND")).isEqualTo(TimeValue.ofMilliseconds(1)); } @Test void testToDuration() throws ParseException { - Assertions.assertEquals(Long.MAX_VALUE, TimeValue.parse("9223372036854775807 SECONDS").toDuration().getSeconds()); + Assertions.assertThat(TimeValue.parse("9223372036854775807 SECONDS").toDuration().getSeconds()).isEqualTo(Long.MAX_VALUE); } @Test @@ -297,19 +297,19 @@ void testEqualsAndHashCode() { final TimeValue tv4 = TimeValue.ofSeconds(1L); final TimeValue tv5 = TimeValue.ofSeconds(1000L); - Assertions.assertEquals(tv1, tv1); - Assertions.assertNotEquals(null, tv1); - Assertions.assertNotEquals(tv1, tv2); - Assertions.assertEquals(tv1, tv3); - Assertions.assertEquals(tv1, tv4); - Assertions.assertEquals(tv4, tv1); - Assertions.assertNotEquals(tv1, tv5); + Assertions.assertThat(tv1).isEqualTo(tv1); + Assertions.assertThat(tv1).isNotEqualTo(null); + Assertions.assertThat(tv2).isNotEqualTo(tv1); + Assertions.assertThat(tv3).isEqualTo(tv1); + Assertions.assertThat(tv4).isEqualTo(tv1); + Assertions.assertThat(tv1).isEqualTo(tv4); + Assertions.assertThat(tv5).isNotEqualTo(tv1); - Assertions.assertNotEquals(tv1.hashCode(), tv2.hashCode()); - Assertions.assertEquals(tv1.hashCode(), tv3.hashCode()); - Assertions.assertEquals(tv1.hashCode(), tv4.hashCode()); - Assertions.assertEquals(tv4.hashCode(), tv1.hashCode()); - Assertions.assertNotEquals(tv1.hashCode(), tv5.hashCode()); + Assertions.assertThat(tv2.hashCode()).isNotEqualTo(tv1.hashCode()); + Assertions.assertThat(tv3.hashCode()).isEqualTo(tv1.hashCode()); + Assertions.assertThat(tv4.hashCode()).isEqualTo(tv1.hashCode()); + Assertions.assertThat(tv1.hashCode()).isEqualTo(tv4.hashCode()); + Assertions.assertThat(tv5.hashCode()).isNotEqualTo(tv1.hashCode()); } @Test @@ -321,14 +321,16 @@ void testCompareTo() { final TimeValue tv5 = TimeValue.ofSeconds(60L); final TimeValue tv6 = TimeValue.ofMinutes(1L); - Assertions.assertTrue(tv1.compareTo(tv1) == 0); - Assertions.assertTrue(tv1.compareTo(tv2) < 0); - Assertions.assertTrue(tv1.compareTo(tv3) == 0); - Assertions.assertTrue(tv1.compareTo(tv4) == 0); - Assertions.assertTrue(tv1.compareTo(tv5) < 0); - Assertions.assertTrue(tv6.compareTo(tv5) == 0); - Assertions.assertTrue(tv6.compareTo(tv4) > 0); - Assertions.assertThrows(NullPointerException.class, () -> tv1.compareTo(null)); + Assertions.assertThat(tv1.compareTo(tv1) == 0).isTrue(); + Assertions.assertThat(tv1.compareTo(tv2) < 0).isTrue(); + Assertions.assertThat(tv1.compareTo(tv3) == 0).isTrue(); + Assertions.assertThat(tv1.compareTo(tv4) == 0).isTrue(); + Assertions.assertThat(tv1.compareTo(tv5) < 0).isTrue(); + Assertions.assertThat(tv6.compareTo(tv5) == 0).isTrue(); + Assertions.assertThat(tv6.compareTo(tv4) > 0).isTrue(); + Assertions.assertThatThrownBy(() -> + tv1.compareTo(null)) + .isInstanceOf(NullPointerException.class); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/util/TestTimeout.java b/httpcore5/src/test/java/org/apache/hc/core5/util/TestTimeout.java index 6c96bdaf36..b1b6fab343 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/util/TestTimeout.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/util/TestTimeout.java @@ -31,37 +31,37 @@ import java.time.Duration; import java.util.concurrent.TimeUnit; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class TestTimeout { private void checkToDays(final long value, final TimeUnit timeUnit) { - Assertions.assertEquals(timeUnit.toDays(value), Timeout.of(value, timeUnit).toDays()); + Assertions.assertThat(Timeout.of(value, timeUnit).toDays()).isEqualTo(timeUnit.toDays(value)); } private void checkToHours(final long value, final TimeUnit timeUnit) { - Assertions.assertEquals(timeUnit.toHours(value), Timeout.of(value, timeUnit).toHours()); + Assertions.assertThat(Timeout.of(value, timeUnit).toHours()).isEqualTo(timeUnit.toHours(value)); } private void checkToMicroseconds(final long value, final TimeUnit timeUnit) { - Assertions.assertEquals(timeUnit.toMicros(value), Timeout.of(value, timeUnit).toMicroseconds()); + Assertions.assertThat(Timeout.of(value, timeUnit).toMicroseconds()).isEqualTo(timeUnit.toMicros(value)); } private void checkToMilliseconds(final long value, final TimeUnit timeUnit) { - Assertions.assertEquals(timeUnit.toMillis(value), Timeout.of(value, timeUnit).toMilliseconds()); + Assertions.assertThat(Timeout.of(value, timeUnit).toMilliseconds()).isEqualTo(timeUnit.toMillis(value)); } private void checkToMinutes(final long value, final TimeUnit timeUnit) { - Assertions.assertEquals(timeUnit.toMinutes(value), Timeout.of(value, timeUnit).toMinutes()); + Assertions.assertThat(Timeout.of(value, timeUnit).toMinutes()).isEqualTo(timeUnit.toMinutes(value)); } private void checkToNanoseconds(final long value, final TimeUnit timeUnit) { - Assertions.assertEquals(timeUnit.toNanos(value), Timeout.of(value, timeUnit).toNanoseconds()); + Assertions.assertThat(Timeout.of(value, timeUnit).toNanoseconds()).isEqualTo(timeUnit.toNanos(value)); } private void checkToSeconds(final long value, final TimeUnit timeUnit) { - Assertions.assertEquals(timeUnit.toSeconds(value), Timeout.of(value, timeUnit).toSeconds()); + Assertions.assertThat(Timeout.of(value, timeUnit).toSeconds()).isEqualTo(timeUnit.toSeconds(value)); } private void test(final long value) { @@ -88,12 +88,12 @@ void test1() { @Test void testDisabled() { - Assertions.assertTrue(Timeout.DISABLED.isDisabled()); - Assertions.assertFalse(Timeout.DISABLED.isEnabled()); + Assertions.assertThat(Timeout.DISABLED.isDisabled()).isTrue(); + Assertions.assertThat(Timeout.DISABLED.isEnabled()).isFalse(); } private void testFactory(final TimeUnit timeUnit) { - Assertions.assertEquals(timeUnit, Timeout.of(1, timeUnit).getTimeUnit()); + Assertions.assertThat(Timeout.of(1, timeUnit).getTimeUnit()).isEqualTo(timeUnit); } @Test @@ -113,7 +113,7 @@ void testFactoryForDuration() { } private void assertConvertion(final Duration duration) { - Assertions.assertEquals(duration, Timeout.of(duration).toDuration()); + Assertions.assertThat(Timeout.of(duration).toDuration()).isEqualTo(duration); } @Test @@ -158,23 +158,23 @@ void testMaxLong() { @Test void testNegative1() { - Assertions.assertThrows(IllegalArgumentException.class, () -> - test(-1)); + Assertions.assertThatThrownBy(() -> + test(-1)).isInstanceOf(IllegalArgumentException.class); } @Test void testToString() { - Assertions.assertEquals("9223372036854775807 SECONDS", Timeout.ofSeconds(Long.MAX_VALUE).toString()); - Assertions.assertEquals("0 MILLISECONDS", Timeout.ZERO_MILLISECONDS.toString()); + Assertions.assertThat(Timeout.ofSeconds(Long.MAX_VALUE).toString()).isEqualTo("9223372036854775807 SECONDS"); + Assertions.assertThat(Timeout.ZERO_MILLISECONDS.toString()).isEqualTo("0 MILLISECONDS"); } @Test void testFromString() throws ParseException { - Assertions.assertEquals(Timeout.ofSeconds(Long.MAX_VALUE), Timeout.parse("9223372036854775807 SECONDS")); - Assertions.assertEquals(Timeout.ofSeconds(Long.MAX_VALUE), Timeout.parse("9223372036854775807 Seconds")); - Assertions.assertEquals(Timeout.ofSeconds(Long.MAX_VALUE), Timeout.parse("9223372036854775807 Seconds")); - Assertions.assertEquals(Timeout.ofSeconds(Long.MAX_VALUE), Timeout.parse("9223372036854775807\tSeconds")); - Assertions.assertEquals(Timeout.ZERO_MILLISECONDS, Timeout.parse("0 MILLISECONDS")); + Assertions.assertThat(Timeout.parse("9223372036854775807 SECONDS")).isEqualTo(Timeout.ofSeconds(Long.MAX_VALUE)); + Assertions.assertThat(Timeout.parse("9223372036854775807 Seconds")).isEqualTo(Timeout.ofSeconds(Long.MAX_VALUE)); + Assertions.assertThat(Timeout.parse("9223372036854775807 Seconds")).isEqualTo(Timeout.ofSeconds(Long.MAX_VALUE)); + Assertions.assertThat(Timeout.parse("9223372036854775807\tSeconds")).isEqualTo(Timeout.ofSeconds(Long.MAX_VALUE)); + Assertions.assertThat(Timeout.parse("0 MILLISECONDS")).isEqualTo(Timeout.ZERO_MILLISECONDS); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/util/TestTimeoutValueException.java b/httpcore5/src/test/java/org/apache/hc/core5/util/TestTimeoutValueException.java index bf67891d5e..9cf737f0a7 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/util/TestTimeoutValueException.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/util/TestTimeoutValueException.java @@ -27,14 +27,13 @@ package org.apache.hc.core5.util; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; class TestTimeoutValueException { @Test void testMessage() { - Assertions.assertEquals("Timeout deadline: 1000 MILLISECONDS, actual: 2000 MILLISECONDS", - TimeoutValueException.fromMilliseconds(1000, 2000).getMessage()); + Assertions.assertThat(TimeoutValueException.fromMilliseconds(1000, 2000).getMessage()).isEqualTo("Timeout deadline: 1000 MILLISECONDS, actual: 2000 MILLISECONDS"); } } diff --git a/httpcore5/src/test/java/org/apache/hc/core5/util/TestTokenizer.java b/httpcore5/src/test/java/org/apache/hc/core5/util/TestTokenizer.java index 5038f2922c..e79540f6ef 100644 --- a/httpcore5/src/test/java/org/apache/hc/core5/util/TestTokenizer.java +++ b/httpcore5/src/test/java/org/apache/hc/core5/util/TestTokenizer.java @@ -27,7 +27,7 @@ package org.apache.hc.core5.util; -import org.junit.jupiter.api.Assertions; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -57,34 +57,34 @@ void testBasicTokenParsing() { parser.skipWhiteSpace(raw, cursor); - Assertions.assertFalse(cursor.atEnd()); - Assertions.assertEquals(3, cursor.getPos()); + Assertions.assertThat(cursor.atEnd()).isFalse(); + Assertions.assertThat(cursor.getPos()).isEqualTo(3); final StringBuilder strbuf1 = new StringBuilder(); parser.copyContent(raw, cursor, Tokenizer.delimiters(':'), strbuf1); - Assertions.assertFalse(cursor.atEnd()); - Assertions.assertEquals(6, cursor.getPos()); - Assertions.assertEquals("raw", strbuf1.toString()); - Assertions.assertEquals(':', raw.charAt(cursor.getPos())); + Assertions.assertThat(cursor.atEnd()).isFalse(); + Assertions.assertThat(cursor.getPos()).isEqualTo(6); + Assertions.assertThat(strbuf1.toString()).isEqualTo("raw"); + Assertions.assertThat(raw.charAt(cursor.getPos())).isEqualTo(':'); cursor.updatePos(cursor.getPos() + 1); parser.skipWhiteSpace(raw, cursor); - Assertions.assertFalse(cursor.atEnd()); - Assertions.assertEquals(8, cursor.getPos()); + Assertions.assertThat(cursor.atEnd()).isFalse(); + Assertions.assertThat(cursor.getPos()).isEqualTo(8); final StringBuilder strbuf2 = new StringBuilder(); parser.copyQuotedContent(raw, cursor, strbuf2); - Assertions.assertTrue(cursor.atEnd()); - Assertions.assertEquals(" some stuff ", strbuf2.toString()); + Assertions.assertThat(cursor.atEnd()).isTrue(); + Assertions.assertThat(strbuf2.toString()).isEqualTo(" some stuff "); parser.copyQuotedContent(raw, cursor, strbuf2); - Assertions.assertTrue(cursor.atEnd()); + Assertions.assertThat(cursor.atEnd()).isTrue(); parser.skipWhiteSpace(raw, cursor); - Assertions.assertTrue(cursor.atEnd()); + Assertions.assertThat(cursor.atEnd()).isTrue(); } @Test @@ -95,26 +95,26 @@ void testTokenParsingWithQuotedPairs() { parser.skipWhiteSpace(raw, cursor); - Assertions.assertFalse(cursor.atEnd()); - Assertions.assertEquals(0, cursor.getPos()); + Assertions.assertThat(cursor.atEnd()).isFalse(); + Assertions.assertThat(cursor.getPos()).isEqualTo(0); final StringBuilder strbuf1 = new StringBuilder(); parser.copyContent(raw, cursor, Tokenizer.delimiters(':'), strbuf1); - Assertions.assertFalse(cursor.atEnd()); - Assertions.assertEquals("raw", strbuf1.toString()); - Assertions.assertEquals(':', raw.charAt(cursor.getPos())); + Assertions.assertThat(cursor.atEnd()).isFalse(); + Assertions.assertThat(strbuf1.toString()).isEqualTo("raw"); + Assertions.assertThat(raw.charAt(cursor.getPos())).isEqualTo(':'); cursor.updatePos(cursor.getPos() + 1); parser.skipWhiteSpace(raw, cursor); - Assertions.assertFalse(cursor.atEnd()); + Assertions.assertThat(cursor.atEnd()).isFalse(); final StringBuilder strbuf2 = new StringBuilder(); parser.copyQuotedContent(raw, cursor, strbuf2); - Assertions.assertTrue(cursor.atEnd()); - Assertions.assertEquals("\"some\\stuff\\", strbuf2.toString()); + Assertions.assertThat(cursor.atEnd()).isTrue(); + Assertions.assertThat(strbuf2.toString()).isEqualTo("\"some\\stuff\\"); } @Test @@ -124,7 +124,7 @@ void testTokenParsingIncompleteQuote() { final Tokenizer.Cursor cursor = new Tokenizer.Cursor(0, s.length()); final StringBuilder strbuf1 = new StringBuilder(); parser.copyQuotedContent(raw, cursor, strbuf1); - Assertions.assertEquals("stuff and more stuff ", strbuf1.toString()); + Assertions.assertThat(strbuf1.toString()).isEqualTo("stuff and more stuff "); } @Test @@ -133,7 +133,7 @@ void testTokenParsingTokensWithUnquotedBlanks() { final CharArrayBuffer raw = createBuffer(s); final Tokenizer.Cursor cursor = new Tokenizer.Cursor(0, s.length()); final String result = parser.parseToken(raw, cursor, Tokenizer.delimiters(';')); - Assertions.assertEquals("stuff and some more stuff", result); + Assertions.assertThat(result).isEqualTo("stuff and some more stuff"); } @Test @@ -142,7 +142,7 @@ void testTokenParsingMixedValuesAndQuotedValues() { final CharArrayBuffer raw = createBuffer(s); final Tokenizer.Cursor cursor = new Tokenizer.Cursor(0, s.length()); final String result = parser.parseValue(raw, cursor, Tokenizer.delimiters(';')); - Assertions.assertEquals("stuff and some more stuff ;", result); + Assertions.assertThat(result).isEqualTo("stuff and some more stuff ;"); } @Test @@ -151,7 +151,7 @@ void testTokenParsingMixedValuesAndQuotedValues2() { final CharArrayBuffer raw = createBuffer(s); final Tokenizer.Cursor cursor = new Tokenizer.Cursor(0, s.length()); final String result = parser.parseValue(raw, cursor, Tokenizer.delimiters(';')); - Assertions.assertEquals("stuffmorestuff", result); + Assertions.assertThat(result).isEqualTo("stuffmorestuff"); } @Test @@ -160,7 +160,7 @@ void testTokenParsingEscapedQuotes() { final CharArrayBuffer raw = createBuffer(s); final Tokenizer.Cursor cursor = new Tokenizer.Cursor(0, s.length()); final String result = parser.parseValue(raw, cursor, Tokenizer.delimiters(';')); - Assertions.assertEquals("stuff\"more\"stuff", result); + Assertions.assertThat(result).isEqualTo("stuff\"more\"stuff"); } @Test @@ -169,7 +169,7 @@ void testTokenParsingEscapedDelimiter() { final CharArrayBuffer raw = createBuffer(s); final Tokenizer.Cursor cursor = new Tokenizer.Cursor(0, s.length()); final String result = parser.parseValue(raw, cursor, Tokenizer.delimiters(';')); - Assertions.assertEquals("stuff\"more\";stuff", result); + Assertions.assertThat(result).isEqualTo("stuff\"more\";stuff"); } @Test @@ -178,7 +178,7 @@ void testTokenParsingEscapedSlash() { final CharArrayBuffer raw = createBuffer(s); final Tokenizer.Cursor cursor = new Tokenizer.Cursor(0, s.length()); final String result = parser.parseValue(raw, cursor, Tokenizer.delimiters(';')); - Assertions.assertEquals("stuff\"more\";\\stuff", result); + Assertions.assertThat(result).isEqualTo("stuff\"more\";\\stuff"); } @Test @@ -187,6 +187,6 @@ void testTokenParsingSlashOutsideQuotes() { final CharArrayBuffer raw = createBuffer(s); final Tokenizer.Cursor cursor = new Tokenizer.Cursor(0, s.length()); final String result = parser.parseValue(raw, cursor, Tokenizer.delimiters(';')); - Assertions.assertEquals("stuff\\", result); + Assertions.assertThat(result).isEqualTo("stuff\\"); } }