andreacavalli/netty5
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Migrate codec-http tests to JUnit 5 (#11316)

Browse Source 
Motivation:

JUnit 5 is more expressive, extensible, and composable in many ways, and it's better able to run tests in parallel.

Modifications:

Use JUnit5 in tests

Result:

Related to https://github.com/netty/netty/issues/10757
This commit is contained in:
Riley Park 2021-05-27 00:06:23 -07:00 committed by Norman Maurer
parent b646a2670a
commit ac3f823cce
74 changed files with 928 additions and 628 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
codec-http/src/test/java/io/netty/handler/codec/http/CombinedHttpHeadersTest.java
View File

@ -16,7 +16,8 @@
package io.netty.handler.codec.http; package io.netty.handler.codec.http;
import io.netty.handler.codec.http.HttpHeadersTestUtils.HeaderValue; import io.netty.handler.codec.http.HttpHeadersTestUtils.HeaderValue;
import org.junit.Test; import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.function.Executable;
import java.util.Arrays; import java.util.Arrays;
import java.util.Collections; import java.util.Collections;
@ -26,9 +27,10 @@ import static io.netty.handler.codec.http.HttpHeaderNames.SET_COOKIE;
import static io.netty.util.AsciiString.contentEquals; import static io.netty.util.AsciiString.contentEquals;
import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.hasSize; import static org.hamcrest.Matchers.hasSize;
import static org.junit.Assert.assertEquals; import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.Assert.assertFalse; import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.Assert.assertTrue; import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
public class CombinedHttpHeadersTest { public class CombinedHttpHeadersTest {
private static final CharSequence HEADER_NAME = "testHeader"; private static final CharSequence HEADER_NAME = "testHeader";
@ -140,12 +142,17 @@ public class CombinedHttpHeadersTest {
assertEquals(HeaderValue.EIGHT.subset(6), headers.getAll(HEADER_NAME)); assertEquals(HeaderValue.EIGHT.subset(6), headers.getAll(HEADER_NAME));
} }
@Test (expected = NullPointerException.class) @Test
public void addCharSequencesCsvNullValue() { public void addCharSequencesCsvNullValue() {
final CombinedHttpHeaders headers = newCombinedHttpHeaders(); final CombinedHttpHeaders headers = newCombinedHttpHeaders();
final String value = null; final String value = null;
assertThrows(NullPointerException.class, new Executable() {
@Override
public void execute() {
headers.add(HEADER_NAME, value); headers.add(HEADER_NAME, value);
} }
});
}
@Test @Test
public void addCharSequencesCsvMultipleTimes() { public void addCharSequencesCsvMultipleTimes() {

42
codec-http/src/test/java/io/netty/handler/codec/http/DefaultHttpHeadersTest.java
View File

@ -18,7 +18,8 @@ package io.netty.handler.codec.http;
import io.netty.handler.codec.http.HttpHeadersTestUtils.HeaderValue; import io.netty.handler.codec.http.HttpHeadersTestUtils.HeaderValue;
import io.netty.util.AsciiString; import io.netty.util.AsciiString;
import io.netty.util.internal.StringUtil; import io.netty.util.internal.StringUtil;
import org.junit.Test; import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.function.Executable;
import java.util.Arrays; import java.util.Arrays;
import java.util.Iterator; import java.util.Iterator;
@ -30,20 +31,35 @@ import static io.netty.util.AsciiString.contentEquals;
import static java.util.Arrays.asList; import static java.util.Arrays.asList;
import static org.hamcrest.CoreMatchers.is; import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.*; import static org.junit.jupiter.api.Assertions.assertArrayEquals;
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.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
public class DefaultHttpHeadersTest { public class DefaultHttpHeadersTest {
private static final CharSequence HEADER_NAME = "testHeader"; private static final CharSequence HEADER_NAME = "testHeader";
@Test(expected = IllegalArgumentException.class) @Test
public void nullHeaderNameNotAllowed() { public void nullHeaderNameNotAllowed() {
assertThrows(IllegalArgumentException.class, new Executable() {
@Override
public void execute() {
new DefaultHttpHeaders().add(null, "foo"); new DefaultHttpHeaders().add(null, "foo");
} }
});
}
@Test(expected = IllegalArgumentException.class) @Test
public void emptyHeaderNameNotAllowed() { public void emptyHeaderNameNotAllowed() {
assertThrows(IllegalArgumentException.class, new Executable() {
@Override
public void execute() {
new DefaultHttpHeaders().add(StringUtil.EMPTY_STRING, "foo"); new DefaultHttpHeaders().add(StringUtil.EMPTY_STRING, "foo");
} }
});
}
@Test @Test
public void keysShouldBeCaseInsensitive() { public void keysShouldBeCaseInsensitive() {
@ -146,17 +162,27 @@ public class DefaultHttpHeadersTest {
assertThat(AsciiString.contentEqualsIgnoreCase("FoO", "fOo"), is(true)); assertThat(AsciiString.contentEqualsIgnoreCase("FoO", "fOo"), is(true));
} }
@Test(expected = NullPointerException.class) @Test
public void testSetNullHeaderValueValidate() { public void testSetNullHeaderValueValidate() {
HttpHeaders headers = new DefaultHttpHeaders(true); final HttpHeaders headers = new DefaultHttpHeaders(true);
assertThrows(NullPointerException.class, new Executable() {
@Override
public void execute() {
headers.set(of("test"), (CharSequence) null); headers.set(of("test"), (CharSequence) null);
} }
});
}
@Test(expected = NullPointerException.class) @Test
public void testSetNullHeaderValueNotValidate() { public void testSetNullHeaderValueNotValidate() {
HttpHeaders headers = new DefaultHttpHeaders(false); final HttpHeaders headers = new DefaultHttpHeaders(false);
assertThrows(NullPointerException.class, new Executable() {
@Override
public void execute() {
headers.set(of("test"), (CharSequence) null); headers.set(of("test"), (CharSequence) null);
} }
});
}
@Test @Test
public void addCharSequences() { public void addCharSequences() {

6
codec-http/src/test/java/io/netty/handler/codec/http/DefaultHttpRequestTest.java
View File

@ -16,11 +16,11 @@
package io.netty.handler.codec.http; package io.netty.handler.codec.http;
import io.netty.util.AsciiString; import io.netty.util.AsciiString;
import org.junit.Test; import org.junit.jupiter.api.Test;
import static io.netty.handler.codec.http.HttpHeadersTestUtils.of; import static io.netty.handler.codec.http.HttpHeadersTestUtils.of;
import static org.junit.Assert.assertNull; import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.Assert.assertTrue; import static org.junit.jupiter.api.Assertions.assertTrue;
public class DefaultHttpRequestTest { public class DefaultHttpRequestTest {

6
codec-http/src/test/java/io/netty/handler/codec/http/DefaultHttpResponseTest.java
View File

@ -15,10 +15,10 @@
*/ */
package io.netty.handler.codec.http; package io.netty.handler.codec.http;
import org.junit.Test; import org.junit.jupiter.api.Test;
import static org.junit.Assert.assertEquals; import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.Assert.assertNotEquals; import static org.junit.jupiter.api.Assertions.assertNotEquals;
public class DefaultHttpResponseTest { public class DefaultHttpResponseTest {

13
codec-http/src/test/java/io/netty/handler/codec/http/HttpChunkedInputTest.java
View File

@ -26,7 +26,7 @@ import io.netty.handler.stream.ChunkedNioStream;
import io.netty.handler.stream.ChunkedStream; import io.netty.handler.stream.ChunkedStream;
import io.netty.handler.stream.ChunkedWriteHandler; import io.netty.handler.stream.ChunkedWriteHandler;
import io.netty.util.internal.PlatformDependent; import io.netty.util.internal.PlatformDependent;
import org.junit.Test; import org.junit.jupiter.api.Test;
import java.io.ByteArrayInputStream; import java.io.ByteArrayInputStream;
import java.io.File; import java.io.File;
@ -34,7 +34,10 @@ import java.io.FileOutputStream;
import java.io.IOException; import java.io.IOException;
import java.nio.channels.Channels; import java.nio.channels.Channels;
import static org.junit.Assert.*; import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertSame;
import static org.junit.jupiter.api.Assertions.assertTrue;
public class HttpChunkedInputTest { public class HttpChunkedInputTest {
private static final byte[] BYTES = new byte[1024 * 64]; private static final byte[] BYTES = new byte[1024 * 64];
@ -139,7 +142,7 @@ public class HttpChunkedInputTest {
break; break;
} }
if (lastHttpContent != null) { if (lastHttpContent != null) {
assertTrue("Chunk must be DefaultHttpContent", lastHttpContent instanceof DefaultHttpContent); assertTrue(lastHttpContent instanceof DefaultHttpContent, "Chunk must be DefaultHttpContent");
} }
ByteBuf buffer = httpContent.content(); ByteBuf buffer = httpContent.content();
@ -157,7 +160,7 @@ public class HttpChunkedInputTest {
} }
assertEquals(BYTES.length * inputs.length, read); assertEquals(BYTES.length * inputs.length, read);
assertSame("Last chunk must be LastHttpContent.EMPTY_LAST_CONTENT", assertSame(LastHttpContent.EMPTY_LAST_CONTENT, lastHttpContent,
LastHttpContent.EMPTY_LAST_CONTENT, lastHttpContent); "Last chunk must be LastHttpContent.EMPTY_LAST_CONTENT");
} }
} }

38
codec-http/src/test/java/io/netty/handler/codec/http/HttpClientCodecTest.java
View File

@ -36,7 +36,7 @@ import io.netty.handler.codec.PrematureChannelClosureException;
import io.netty.util.CharsetUtil; import io.netty.util.CharsetUtil;
import io.netty.util.NetUtil; import io.netty.util.NetUtil;
import org.hamcrest.CoreMatchers; import org.hamcrest.CoreMatchers;
import org.junit.Test; import org.junit.jupiter.api.Test;
import java.net.InetSocketAddress; import java.net.InetSocketAddress;
import java.util.concurrent.CountDownLatch; import java.util.concurrent.CountDownLatch;
@ -46,7 +46,11 @@ import static java.util.concurrent.TimeUnit.SECONDS;
import static org.hamcrest.CoreMatchers.*; import static org.hamcrest.CoreMatchers.*;
import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.not; import static org.hamcrest.Matchers.not;
import static org.junit.Assert.*; import static org.junit.jupiter.api.Assertions.assertFalse;
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 static org.junit.jupiter.api.Assertions.fail;
public class HttpClientCodecTest { public class HttpClientCodecTest {
@ -218,7 +222,7 @@ public class HttpClientCodecTest {
Consumer connectResponseConsumer = new Consumer(); Consumer connectResponseConsumer = new Consumer();
sendRequestAndReadResponse(ch, HttpMethod.CONNECT, EMPTY_RESPONSE, connectResponseConsumer); sendRequestAndReadResponse(ch, HttpMethod.CONNECT, EMPTY_RESPONSE, connectResponseConsumer);
assertTrue("No connect response messages received.", connectResponseConsumer.getReceivedCount() > 0); assertTrue(connectResponseConsumer.getReceivedCount() > 0, "No connect response messages received.");
Consumer responseConsumer = new Consumer() { Consumer responseConsumer = new Consumer() {
@Override @Override
void accept(Object object) { void accept(Object object) {
@ -230,8 +234,8 @@ public class HttpClientCodecTest {
} }
}; };
sendRequestAndReadResponse(ch, HttpMethod.GET, RESPONSE, responseConsumer); sendRequestAndReadResponse(ch, HttpMethod.GET, RESPONSE, responseConsumer);
assertTrue("No response messages received.", responseConsumer.getReceivedCount() > 0); assertTrue(responseConsumer.getReceivedCount() > 0, "No response messages received.");
assertFalse("Channel finish failed.", ch.finish()); assertFalse(ch.finish(), "Channel finish failed.");
} }
private static void sendRequestAndReadResponse(EmbeddedChannel ch, HttpMethod httpMethod, String response) { private static void sendRequestAndReadResponse(EmbeddedChannel ch, HttpMethod httpMethod, String response) {
@ -240,10 +244,10 @@ public class HttpClientCodecTest {
private static void sendRequestAndReadResponse(EmbeddedChannel ch, HttpMethod httpMethod, String response, private static void sendRequestAndReadResponse(EmbeddedChannel ch, HttpMethod httpMethod, String response,
Consumer responseConsumer) { Consumer responseConsumer) {
assertTrue("Channel outbound write failed.", assertTrue(ch.writeOutbound(new DefaultFullHttpRequest(HttpVersion.HTTP_1_1, httpMethod, "http://localhost/")),
ch.writeOutbound(new DefaultFullHttpRequest(HttpVersion.HTTP_1_1, httpMethod, "http://localhost/"))); "Channel outbound write failed.");
assertTrue("Channel inbound write failed.", assertTrue(ch.writeInbound(Unpooled.copiedBuffer(response, CharsetUtil.ISO_8859_1)),
ch.writeInbound(Unpooled.copiedBuffer(response, CharsetUtil.ISO_8859_1))); "Channel inbound write failed.");
for (;;) { for (;;) {
Object msg = ch.readOutbound(); Object msg = ch.readOutbound();
@ -292,22 +296,22 @@ public class HttpClientCodecTest {
HttpRequest request = new DefaultFullHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.GET, "http://localhost/"); HttpRequest request = new DefaultFullHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.GET, "http://localhost/");
request.headers().set(HttpHeaderNames.CONNECTION, HttpHeaderValues.UPGRADE); request.headers().set(HttpHeaderNames.CONNECTION, HttpHeaderValues.UPGRADE);
request.headers().set(HttpHeaderNames.UPGRADE, "TLS/1.2"); request.headers().set(HttpHeaderNames.UPGRADE, "TLS/1.2");
assertTrue("Channel outbound write failed.", ch.writeOutbound(request)); assertTrue(ch.writeOutbound(request), "Channel outbound write failed.");
assertTrue("Channel inbound write failed.", assertTrue(ch.writeInbound(Unpooled.copiedBuffer(SWITCHING_PROTOCOLS_RESPONSE, CharsetUtil.ISO_8859_1)),
ch.writeInbound(Unpooled.copiedBuffer(SWITCHING_PROTOCOLS_RESPONSE, CharsetUtil.ISO_8859_1))); "Channel inbound write failed.");
Object switchingProtocolsResponse = ch.readInbound(); Object switchingProtocolsResponse = ch.readInbound();
assertNotNull("No response received", switchingProtocolsResponse); assertNotNull(switchingProtocolsResponse, "No response received");
assertThat("Response was not decoded", switchingProtocolsResponse, instanceOf(FullHttpResponse.class)); assertThat("Response was not decoded", switchingProtocolsResponse, instanceOf(FullHttpResponse.class));
((FullHttpResponse) switchingProtocolsResponse).release(); ((FullHttpResponse) switchingProtocolsResponse).release();
assertTrue("Channel inbound write failed", assertTrue(ch.writeInbound(Unpooled.copiedBuffer(RESPONSE, CharsetUtil.ISO_8859_1)),
ch.writeInbound(Unpooled.copiedBuffer(RESPONSE, CharsetUtil.ISO_8859_1))); "Channel inbound write failed");
Object finalResponse = ch.readInbound(); Object finalResponse = ch.readInbound();
assertNotNull("No response received", finalResponse); assertNotNull(finalResponse, "No response received");
assertThat("Response was not decoded", finalResponse, instanceOf(FullHttpResponse.class)); assertThat("Response was not decoded", finalResponse, instanceOf(FullHttpResponse.class));
((FullHttpResponse) finalResponse).release(); ((FullHttpResponse) finalResponse).release();
assertTrue("Channel finish failed", ch.finishAndReleaseAll()); assertTrue(ch.finishAndReleaseAll(), "Channel finish failed");
} }
@Test @Test

10
codec-http/src/test/java/io/netty/handler/codec/http/HttpClientUpgradeHandlerTest.java
View File

@ -23,12 +23,12 @@ import java.util.Collection;
import java.util.Collections; import java.util.Collections;
import java.util.List; import java.util.List;
import org.junit.Test; import org.junit.jupiter.api.Test;
import static org.junit.Assert.assertEquals; import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.Assert.assertFalse; import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.Assert.assertNull; import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.Assert.assertTrue; import static org.junit.jupiter.api.Assertions.assertTrue;
public class HttpClientUpgradeHandlerTest { public class HttpClientUpgradeHandlerTest {

17
codec-http/src/test/java/io/netty/handler/codec/http/HttpContentCompressorTest.java
View File

@ -41,7 +41,8 @@ import java.util.UUID;
import java.util.concurrent.BlockingQueue; import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue; import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeUnit;
import org.junit.Test;
import org.junit.jupiter.api.Test;
import static io.netty.handler.codec.http.HttpHeadersTestUtils.of; import static io.netty.handler.codec.http.HttpHeadersTestUtils.of;
import static org.hamcrest.CoreMatchers.instanceOf; import static org.hamcrest.CoreMatchers.instanceOf;
@ -49,13 +50,13 @@ import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.not; import static org.hamcrest.CoreMatchers.not;
import static org.hamcrest.CoreMatchers.nullValue; import static org.hamcrest.CoreMatchers.nullValue;
import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals; import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.Assert.assertFalse; import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.Assert.assertNotNull; import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.Assert.assertNull; import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.Assert.assertSame; import static org.junit.jupiter.api.Assertions.assertSame;
import static org.junit.Assert.assertTrue; import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.Assert.fail; import static org.junit.jupiter.api.Assertions.fail;
public class HttpContentCompressorTest { public class HttpContentCompressorTest {

45
codec-http/src/test/java/io/netty/handler/codec/http/HttpContentDecoderTest.java
View File

@ -32,8 +32,7 @@ import io.netty.util.CharsetUtil;
import io.netty.util.ReferenceCountUtil; import io.netty.util.ReferenceCountUtil;
import io.netty.util.internal.PlatformDependent; import io.netty.util.internal.PlatformDependent;
import org.apache.commons.io.IOUtils; import org.apache.commons.io.IOUtils;
import org.junit.Assume; import org.junit.jupiter.api.Test;
import org.junit.Test;
import java.io.InputStream; import java.io.InputStream;
import java.util.ArrayList; import java.util.ArrayList;
@ -45,7 +44,13 @@ import java.util.concurrent.atomic.AtomicReference;
import static org.hamcrest.CoreMatchers.instanceOf; import static org.hamcrest.CoreMatchers.instanceOf;
import static org.hamcrest.CoreMatchers.is; import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.*; 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.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.Assertions.fail;
import static org.junit.jupiter.api.Assumptions.assumeFalse;
public class HttpContentDecoderTest { public class HttpContentDecoderTest {
private static final String HELLO_WORLD = "hello, world"; private static final String HELLO_WORLD = "hello, world";
@ -191,7 +196,7 @@ public class HttpContentDecoderTest {
public void testResponseBrotliDecompression() throws Throwable { public void testResponseBrotliDecompression() throws Throwable {
Brotli.ensureAvailability(); Brotli.ensureAvailability();
// Failing on windows atm // Failing on windows atm
Assume.assumeFalse(PlatformDependent.isWindows()); assumeFalse(PlatformDependent.isWindows());
HttpResponseDecoder decoder = new HttpResponseDecoder(); HttpResponseDecoder decoder = new HttpResponseDecoder();
HttpContentDecoder decompressor = new HttpContentDecompressor(); HttpContentDecoder decompressor = new HttpContentDecompressor();
HttpObjectAggregator aggregator = new HttpObjectAggregator(Integer.MAX_VALUE); HttpObjectAggregator aggregator = new HttpObjectAggregator(Integer.MAX_VALUE);
@ -207,13 +212,12 @@ public class HttpContentDecoderTest {
Object o = channel.readInbound(); Object o = channel.readInbound();
assertThat(o, is(instanceOf(FullHttpResponse.class))); assertThat(o, is(instanceOf(FullHttpResponse.class)));
FullHttpResponse resp = (FullHttpResponse) o; FullHttpResponse resp = (FullHttpResponse) o;
assertNull("Content-Encoding header should be removed", resp.headers().get(HttpHeaderNames.CONTENT_ENCODING)); assertNull(resp.headers().get(HttpHeaderNames.CONTENT_ENCODING), "Content-Encoding header should be removed");
assertEquals("Content-Length header should match uncompressed string's length", assertEquals(SAMPLE_STRING.length(),
SAMPLE_STRING.length(), resp.headers().getInt(HttpHeaderNames.CONTENT_LENGTH).intValue(),
resp.headers().getInt(HttpHeaderNames.CONTENT_LENGTH).intValue()); "Content-Length header should match uncompressed string's length");
assertEquals("Response body should match uncompressed string", assertEquals(SAMPLE_STRING, resp.content().toString(CharsetUtil.UTF_8),
SAMPLE_STRING, "Response body should match uncompressed string");
resp.content().toString(CharsetUtil.UTF_8));
resp.release(); resp.release();
assertHasInboundMessages(channel, false); assertHasInboundMessages(channel, false);
@ -225,7 +229,7 @@ public class HttpContentDecoderTest {
public void testResponseChunksBrotliDecompression() throws Throwable { public void testResponseChunksBrotliDecompression() throws Throwable {
Brotli.ensureAvailability(); Brotli.ensureAvailability();
// Failing on windows atm // Failing on windows atm
Assume.assumeFalse(PlatformDependent.isWindows()); assumeFalse(PlatformDependent.isWindows());
HttpResponseDecoder decoder = new HttpResponseDecoder(); HttpResponseDecoder decoder = new HttpResponseDecoder();
HttpContentDecoder decompressor = new HttpContentDecompressor(); HttpContentDecoder decompressor = new HttpContentDecompressor();
HttpObjectAggregator aggregator = new HttpObjectAggregator(Integer.MAX_VALUE); HttpObjectAggregator aggregator = new HttpObjectAggregator(Integer.MAX_VALUE);
@ -253,12 +257,11 @@ public class HttpContentDecoderTest {
Object o = channel.readInbound(); Object o = channel.readInbound();
assertThat(o, is(instanceOf(FullHttpResponse.class))); assertThat(o, is(instanceOf(FullHttpResponse.class)));
FullHttpResponse resp = (FullHttpResponse) o; FullHttpResponse resp = (FullHttpResponse) o;
assertEquals("Content-Length header should match uncompressed string's length", assertEquals(SAMPLE_STRING.length(),
SAMPLE_STRING.length(), resp.headers().getInt(HttpHeaderNames.CONTENT_LENGTH).intValue(),
resp.headers().getInt(HttpHeaderNames.CONTENT_LENGTH).intValue()); "Content-Length header should match uncompressed string's length");
assertEquals("Response body should match uncompressed string", assertEquals(SAMPLE_STRING, resp.content().toString(CharsetUtil.UTF_8),
SAMPLE_STRING, "Response body should match uncompressed string");
resp.content().toString(CharsetUtil.UTF_8));
resp.release(); resp.release();
assertHasInboundMessages(channel, false); assertHasInboundMessages(channel, false);
@ -511,11 +514,11 @@ public class HttpContentDecoderTest {
assertThat(o, is(instanceOf(HttpResponse.class))); assertThat(o, is(instanceOf(HttpResponse.class)));
HttpResponse r = (HttpResponse) o; HttpResponse r = (HttpResponse) o;
assertFalse("Content-Length header not removed.", r.headers().contains(HttpHeaderNames.CONTENT_LENGTH)); assertFalse(r.headers().contains(HttpHeaderNames.CONTENT_LENGTH), "Content-Length header not removed.");
String transferEncoding = r.headers().get(HttpHeaderNames.TRANSFER_ENCODING); String transferEncoding = r.headers().get(HttpHeaderNames.TRANSFER_ENCODING);
assertNotNull("Content-length as well as transfer-encoding not set.", transferEncoding); assertNotNull(transferEncoding, "Content-length as well as transfer-encoding not set.");
assertEquals("Unexpected transfer-encoding value.", HttpHeaderValues.CHUNKED.toString(), transferEncoding); assertEquals(HttpHeaderValues.CHUNKED.toString(), transferEncoding, "Unexpected transfer-encoding value.");
assertHasInboundMessages(channel, true); assertHasInboundMessages(channel, true);
assertHasOutboundMessages(channel, false); assertHasOutboundMessages(channel, false);

19
codec-http/src/test/java/io/netty/handler/codec/http/HttpContentDecompressorTest.java
View File

@ -20,11 +20,14 @@ import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter; import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.channel.ChannelOutboundHandlerAdapter; import io.netty.channel.ChannelOutboundHandlerAdapter;
import io.netty.channel.embedded.EmbeddedChannel; import io.netty.channel.embedded.EmbeddedChannel;
import org.junit.Assert; import org.junit.jupiter.api.Test;
import org.junit.Test;
import java.util.concurrent.atomic.AtomicInteger; import java.util.concurrent.atomic.AtomicInteger;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
public class HttpContentDecompressorTest { public class HttpContentDecompressorTest {
// See https://github.com/netty/netty/issues/8915. // See https://github.com/netty/netty/issues/8915.
@ -53,18 +56,18 @@ public class HttpContentDecompressorTest {
response.headers().set(HttpHeaderNames.CONTENT_TYPE, "application/json;charset=UTF-8"); response.headers().set(HttpHeaderNames.CONTENT_TYPE, "application/json;charset=UTF-8");
response.headers().set(HttpHeaderNames.TRANSFER_ENCODING, HttpHeaderValues.CHUNKED); response.headers().set(HttpHeaderNames.TRANSFER_ENCODING, HttpHeaderValues.CHUNKED);
Assert.assertTrue(channel.writeInbound(response)); assertTrue(channel.writeInbound(response));
// we triggered read explicitly // we triggered read explicitly
Assert.assertEquals(1, readCalled.get()); assertEquals(1, readCalled.get());
Assert.assertTrue(channel.readInbound() instanceof HttpResponse); assertTrue(channel.readInbound() instanceof HttpResponse);
Assert.assertFalse(channel.writeInbound(new DefaultHttpContent(Unpooled.EMPTY_BUFFER))); assertFalse(channel.writeInbound(new DefaultHttpContent(Unpooled.EMPTY_BUFFER)));
// read was triggered by the HttpContentDecompressor itself as it did not produce any message to the next // read was triggered by the HttpContentDecompressor itself as it did not produce any message to the next
// inbound handler. // inbound handler.
Assert.assertEquals(2, readCalled.get()); assertEquals(2, readCalled.get());
Assert.assertFalse(channel.finishAndReleaseAll()); assertFalse(channel.finishAndReleaseAll());
} }
} }

6
codec-http/src/test/java/io/netty/handler/codec/http/HttpContentEncoderTest.java
View File

@ -36,7 +36,11 @@ import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.not; import static org.hamcrest.CoreMatchers.not;
import static org.hamcrest.CoreMatchers.nullValue; import static org.hamcrest.CoreMatchers.nullValue;
import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.*; import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertSame;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.Assertions.fail;
public class HttpContentEncoderTest { public class HttpContentEncoderTest {

37
codec-http/src/test/java/io/netty/handler/codec/http/HttpHeadersTest.java
View File

@ -16,16 +16,18 @@
package io.netty.handler.codec.http; package io.netty.handler.codec.http;
import io.netty.util.AsciiString; import io.netty.util.AsciiString;
import org.junit.Test; import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.function.Executable;
import java.util.List; import java.util.List;
import static io.netty.handler.codec.http.HttpHeadersTestUtils.of; import static io.netty.handler.codec.http.HttpHeadersTestUtils.of;
import static org.hamcrest.CoreMatchers.is; import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals; import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.Assert.assertFalse; import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.Assert.assertTrue; import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
public class HttpHeadersTest { public class HttpHeadersTest {
@ -61,23 +63,38 @@ public class HttpHeadersTest {
assertThat(AsciiString.contentEqualsIgnoreCase("FoO", "fOo"), is(true)); assertThat(AsciiString.contentEqualsIgnoreCase("FoO", "fOo"), is(true));
} }
@Test(expected = NullPointerException.class) @Test
public void testSetNullHeaderValueValidate() { public void testSetNullHeaderValueValidate() {
HttpHeaders headers = new DefaultHttpHeaders(true); final HttpHeaders headers = new DefaultHttpHeaders(true);
assertThrows(NullPointerException.class, new Executable() {
@Override
public void execute() {
headers.set(of("test"), (CharSequence) null); headers.set(of("test"), (CharSequence) null);
} }
});
}
@Test(expected = NullPointerException.class) @Test
public void testSetNullHeaderValueNotValidate() { public void testSetNullHeaderValueNotValidate() {
HttpHeaders headers = new DefaultHttpHeaders(false); final HttpHeaders headers = new DefaultHttpHeaders(false);
assertThrows(NullPointerException.class, new Executable() {
@Override
public void execute() {
headers.set(of("test"), (CharSequence) null); headers.set(of("test"), (CharSequence) null);
} }
});
}
@Test(expected = IllegalArgumentException.class) @Test
public void testAddSelf() { public void testAddSelf() {
HttpHeaders headers = new DefaultHttpHeaders(false); final HttpHeaders headers = new DefaultHttpHeaders(false);
assertThrows(IllegalArgumentException.class, new Executable() {
@Override
public void execute() {
headers.add(headers); headers.add(headers);
} }
});
}
@Test @Test
public void testSetSelfIsNoOp() { public void testSetSelfIsNoOp() {

8
codec-http/src/test/java/io/netty/handler/codec/http/HttpInvalidMessageTest.java
View File

@ -25,10 +25,10 @@ import org.junit.Test;
import java.util.Random; import java.util.Random;
import static io.netty.handler.codec.http.HttpHeadersTestUtils.of; import static io.netty.handler.codec.http.HttpHeadersTestUtils.of;
import static org.junit.Assert.assertEquals; import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.Assert.assertFalse; import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.Assert.assertNull; import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.Assert.assertTrue; import static org.junit.jupiter.api.Assertions.assertTrue;
public class HttpInvalidMessageTest { public class HttpInvalidMessageTest {

16
codec-http/src/test/java/io/netty/handler/codec/http/HttpObjectAggregatorTest.java
View File

@ -37,14 +37,14 @@ import static io.netty.handler.codec.http.HttpHeadersTestUtils.of;
import static org.hamcrest.CoreMatchers.instanceOf; import static org.hamcrest.CoreMatchers.instanceOf;
import static org.hamcrest.CoreMatchers.is; import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertArrayEquals; import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.Assert.assertEquals; import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.Assert.assertFalse; import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.Assert.assertNotNull; import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.Assert.assertNull; import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.Assert.assertTrue; import static org.junit.jupiter.api.Assertions.assertSame;
import static org.junit.Assert.fail; import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.Assert.assertSame; import static org.junit.jupiter.api.Assertions.fail;
public class HttpObjectAggregatorTest { public class HttpObjectAggregatorTest {

10
codec-http/src/test/java/io/netty/handler/codec/http/HttpRequestDecoderTest.java
View File

@ -31,11 +31,11 @@ import static org.hamcrest.CoreMatchers.instanceOf;
import static org.hamcrest.CoreMatchers.is; import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.nullValue; import static org.hamcrest.CoreMatchers.nullValue;
import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals; import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.Assert.assertFalse; import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.Assert.assertNotNull; import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.Assert.assertNull; import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.Assert.assertTrue; import static org.junit.jupiter.api.Assertions.assertTrue;
public class HttpRequestDecoderTest { public class HttpRequestDecoderTest {
private static final byte[] CONTENT_CRLF_DELIMITERS = createContent("\r\n"); private static final byte[] CONTENT_CRLF_DELIMITERS = createContent("\r\n");

5
codec-http/src/test/java/io/netty/handler/codec/http/HttpRequestEncoderTest.java
View File

@ -31,7 +31,10 @@ import java.util.concurrent.ExecutionException;
import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.instanceOf; import static org.hamcrest.Matchers.instanceOf;
import static org.hamcrest.Matchers.is; import static org.hamcrest.Matchers.is;
import static org.junit.Assert.*; 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 static org.junit.jupiter.api.Assertions.fail;
/** /**
*/ */

12
codec-http/src/test/java/io/netty/handler/codec/http/HttpResponseDecoderTest.java
View File

@ -21,7 +21,7 @@ import io.netty.channel.embedded.EmbeddedChannel;
import io.netty.handler.codec.PrematureChannelClosureException; import io.netty.handler.codec.PrematureChannelClosureException;
import io.netty.handler.codec.TooLongFrameException; import io.netty.handler.codec.TooLongFrameException;
import io.netty.util.CharsetUtil; import io.netty.util.CharsetUtil;
import org.junit.Test; import org.junit.jupiter.api.Test;
import java.util.Arrays; import java.util.Arrays;
import java.util.List; import java.util.List;
@ -33,11 +33,11 @@ import static org.hamcrest.CoreMatchers.not;
import static org.hamcrest.CoreMatchers.nullValue; import static org.hamcrest.CoreMatchers.nullValue;
import static org.hamcrest.CoreMatchers.sameInstance; import static org.hamcrest.CoreMatchers.sameInstance;
import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertArrayEquals; import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.Assert.assertEquals; import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.Assert.assertFalse; import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.Assert.assertNull; import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.Assert.assertTrue; import static org.junit.jupiter.api.Assertions.assertTrue;
public class HttpResponseDecoderTest { public class HttpResponseDecoderTest {

7
codec-http/src/test/java/io/netty/handler/codec/http/HttpResponseEncoderTest.java
View File

@ -20,14 +20,17 @@ import io.netty.buffer.Unpooled;
import io.netty.channel.FileRegion; import io.netty.channel.FileRegion;
import io.netty.channel.embedded.EmbeddedChannel; import io.netty.channel.embedded.EmbeddedChannel;
import io.netty.util.CharsetUtil; import io.netty.util.CharsetUtil;
import org.junit.Test; import org.junit.jupiter.api.Test;
import java.io.IOException; import java.io.IOException;
import java.nio.channels.WritableByteChannel; import java.nio.channels.WritableByteChannel;
import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.*; import static org.hamcrest.Matchers.*;
import static org.junit.Assert.*; import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertSame;
import static org.junit.jupiter.api.Assertions.assertTrue;
public class HttpResponseEncoderTest { public class HttpResponseEncoderTest {
private static final long INTEGER_OVERFLOW = (long) Integer.MAX_VALUE + 1; private static final long INTEGER_OVERFLOW = (long) Integer.MAX_VALUE + 1;

36
codec-http/src/test/java/io/netty/handler/codec/http/HttpResponseStatusTest.java
View File

@ -16,11 +16,13 @@
package io.netty.handler.codec.http; package io.netty.handler.codec.http;
import io.netty.util.AsciiString; import io.netty.util.AsciiString;
import org.junit.Test; import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.function.Executable;
import static io.netty.handler.codec.http.HttpResponseStatus.parseLine; import static io.netty.handler.codec.http.HttpResponseStatus.parseLine;
import static org.junit.Assert.assertEquals; import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.Assert.assertSame; import static org.junit.jupiter.api.Assertions.assertSame;
import static org.junit.jupiter.api.Assertions.assertThrows;
public class HttpResponseStatusTest { public class HttpResponseStatusTest {
@Test @Test
@ -46,15 +48,25 @@ public class HttpResponseStatusTest {
assertEquals("FOO", customStatus.reasonPhrase()); assertEquals("FOO", customStatus.reasonPhrase());
} }
@Test(expected = IllegalArgumentException.class) @Test
public void parseLineStringMalformedCode() { public void parseLineStringMalformedCode() {
assertThrows(IllegalArgumentException.class, new Executable() {
@Override
public void execute() {
parseLine("200a"); parseLine("200a");
} }
});
}
@Test(expected = IllegalArgumentException.class) @Test
public void parseLineStringMalformedCodeWithPhrase() { public void parseLineStringMalformedCodeWithPhrase() {
assertThrows(IllegalArgumentException.class, new Executable() {
@Override
public void execute() {
parseLine("200a foo"); parseLine("200a foo");
} }
});
}
@Test @Test
public void parseLineAsciiStringJustCode() { public void parseLineAsciiStringJustCode() {
@ -79,13 +91,23 @@ public class HttpResponseStatusTest {
assertEquals("FOO", customStatus.reasonPhrase()); assertEquals("FOO", customStatus.reasonPhrase());
} }
@Test(expected = IllegalArgumentException.class) @Test
public void parseLineAsciiStringMalformedCode() { public void parseLineAsciiStringMalformedCode() {
assertThrows(IllegalArgumentException.class, new Executable() {
@Override
public void execute() {
parseLine(new AsciiString("200a")); parseLine(new AsciiString("200a"));
} }
});
}
@Test(expected = IllegalArgumentException.class) @Test
public void parseLineAsciiStringMalformedCodeWithPhrase() { public void parseLineAsciiStringMalformedCodeWithPhrase() {
assertThrows(IllegalArgumentException.class, new Executable() {
@Override
public void execute() {
parseLine(new AsciiString("200a foo")); parseLine(new AsciiString("200a foo"));
} }
});
}
} }

7
codec-http/src/test/java/io/netty/handler/codec/http/HttpServerCodecTest.java
View File

@ -19,11 +19,14 @@ import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled; import io.netty.buffer.Unpooled;
import io.netty.channel.embedded.EmbeddedChannel; import io.netty.channel.embedded.EmbeddedChannel;
import io.netty.util.CharsetUtil; import io.netty.util.CharsetUtil;
import org.junit.Test; import org.junit.jupiter.api.Test;
import static org.hamcrest.CoreMatchers.*; import static org.hamcrest.CoreMatchers.*;
import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.*; 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;
public class HttpServerCodecTest { public class HttpServerCodecTest {

3
codec-http/src/test/java/io/netty/handler/codec/http/HttpServerExpectContinueHandlerTest.java
View File

@ -21,7 +21,8 @@ import org.junit.Test;
import static org.hamcrest.CoreMatchers.*; import static org.hamcrest.CoreMatchers.*;
import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.*; import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
public class HttpServerExpectContinueHandlerTest { public class HttpServerExpectContinueHandlerTest {

26
codec-http/src/test/java/io/netty/handler/codec/http/HttpServerKeepAliveHandlerTest.java
View File

@ -37,9 +37,9 @@ import static io.netty.handler.codec.http.HttpUtil.isKeepAlive;
import static io.netty.handler.codec.http.HttpUtil.setContentLength; import static io.netty.handler.codec.http.HttpUtil.setContentLength;
import static io.netty.handler.codec.http.HttpUtil.setKeepAlive; import static io.netty.handler.codec.http.HttpUtil.setKeepAlive;
import static io.netty.handler.codec.http.HttpUtil.setTransferEncodingChunked; import static io.netty.handler.codec.http.HttpUtil.setTransferEncodingChunked;
import static org.junit.Assert.assertEquals; import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.Assert.assertFalse; import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.Assert.assertTrue; import static org.junit.jupiter.api.Assertions.assertTrue;
@RunWith(Parameterized.class) @RunWith(Parameterized.class)
public class HttpServerKeepAliveHandlerTest { public class HttpServerKeepAliveHandlerTest {
@ -111,8 +111,8 @@ public class HttpServerKeepAliveHandlerTest {
channel.writeAndFlush(response); channel.writeAndFlush(response);
HttpResponse writtenResponse = channel.readOutbound(); HttpResponse writtenResponse = channel.readOutbound();
assertEquals("channel.isOpen", isKeepAliveResponseExpected, channel.isOpen()); assertEquals(isKeepAliveResponseExpected, channel.isOpen(), "channel.isOpen");
assertEquals("response keep-alive", isKeepAliveResponseExpected, isKeepAlive(writtenResponse)); assertEquals(isKeepAliveResponseExpected, isKeepAlive(writtenResponse), "response keep-alive");
ReferenceCountUtil.release(writtenResponse); ReferenceCountUtil.release(writtenResponse);
assertFalse(channel.finishAndReleaseAll()); assertFalse(channel.finishAndReleaseAll());
} }
@ -167,8 +167,8 @@ public class HttpServerKeepAliveHandlerTest {
channel.writeAndFlush(response.retainedDuplicate()); channel.writeAndFlush(response.retainedDuplicate());
HttpResponse firstResponse = channel.readOutbound(); HttpResponse firstResponse = channel.readOutbound();
assertTrue("channel.isOpen", channel.isOpen()); assertTrue(channel.isOpen(), "channel.isOpen");
assertTrue("response keep-alive", isKeepAlive(firstResponse)); assertTrue(isKeepAlive(firstResponse), "response keep-alive");
ReferenceCountUtil.release(firstResponse); ReferenceCountUtil.release(firstResponse);
requestForwarded = channel.readInbound(); requestForwarded = channel.readInbound();
@ -177,8 +177,8 @@ public class HttpServerKeepAliveHandlerTest {
channel.writeAndFlush(informationalResp); channel.writeAndFlush(informationalResp);
HttpResponse writtenInfoResp = channel.readOutbound(); HttpResponse writtenInfoResp = channel.readOutbound();
assertTrue("channel.isOpen", channel.isOpen()); assertTrue(channel.isOpen(), "channel.isOpen");
assertTrue("response keep-alive", isKeepAlive(writtenInfoResp)); assertTrue(isKeepAlive(writtenInfoResp), "response keep-alive");
ReferenceCountUtil.release(writtenInfoResp); ReferenceCountUtil.release(writtenInfoResp);
if (!StringUtil.isNullOrEmpty(setResponseConnection)) { if (!StringUtil.isNullOrEmpty(setResponseConnection)) {
@ -189,8 +189,8 @@ public class HttpServerKeepAliveHandlerTest {
setupMessageLength(response); setupMessageLength(response);
channel.writeAndFlush(response.retainedDuplicate()); channel.writeAndFlush(response.retainedDuplicate());
HttpResponse secondResponse = channel.readOutbound(); HttpResponse secondResponse = channel.readOutbound();
assertEquals("channel.isOpen", isKeepAliveResponseExpected, channel.isOpen()); assertEquals(isKeepAliveResponseExpected, channel.isOpen(), "channel.isOpen");
assertEquals("response keep-alive", isKeepAliveResponseExpected, isKeepAlive(secondResponse)); assertEquals(isKeepAliveResponseExpected, isKeepAlive(secondResponse), "response keep-alive");
ReferenceCountUtil.release(secondResponse); ReferenceCountUtil.release(secondResponse);
requestForwarded = channel.readInbound(); requestForwarded = channel.readInbound();
@ -200,8 +200,8 @@ public class HttpServerKeepAliveHandlerTest {
if (isKeepAliveResponseExpected) { if (isKeepAliveResponseExpected) {
channel.writeAndFlush(response); channel.writeAndFlush(response);
HttpResponse finalResponse = channel.readOutbound(); HttpResponse finalResponse = channel.readOutbound();
assertFalse("channel.isOpen", channel.isOpen()); assertFalse(channel.isOpen(), "channel.isOpen");
assertFalse("response keep-alive", isKeepAlive(finalResponse)); assertFalse(isKeepAlive(finalResponse), "response keep-alive");
} }
ReferenceCountUtil.release(response); ReferenceCountUtil.release(response);
assertFalse(channel.finishAndReleaseAll()); assertFalse(channel.finishAndReleaseAll());

7
codec-http/src/test/java/io/netty/handler/codec/http/HttpServerUpgradeHandlerTest.java
View File

@ -34,7 +34,12 @@ import io.netty.handler.codec.http.HttpServerUpgradeHandler.UpgradeCodec;
import io.netty.handler.codec.http.HttpServerUpgradeHandler.UpgradeCodecFactory; import io.netty.handler.codec.http.HttpServerUpgradeHandler.UpgradeCodecFactory;
import io.netty.util.CharsetUtil; import io.netty.util.CharsetUtil;
import static org.junit.Assert.*; 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.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.Assertions.fail;
public class HttpServerUpgradeHandlerTest { public class HttpServerUpgradeHandlerTest {

10
codec-http/src/test/java/io/netty/handler/codec/http/HttpUtilTest.java
View File

@ -27,11 +27,11 @@ import io.netty.util.ReferenceCountUtil;
import org.junit.Test; import org.junit.Test;
import static io.netty.handler.codec.http.HttpHeadersTestUtils.of; import static io.netty.handler.codec.http.HttpHeadersTestUtils.of;
import static org.junit.Assert.assertEquals; import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.Assert.assertFalse; import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.Assert.assertNull; import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.Assert.assertTrue; import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.Assert.fail; import static org.junit.jupiter.api.Assertions.fail;
public class HttpUtilTest { public class HttpUtilTest {

272
codec-http/src/test/java/io/netty/handler/codec/http/QueryStringDecoderTest.java
View File

@ -16,8 +16,7 @@
package io.netty.handler.codec.http; package io.netty.handler.codec.http;
import io.netty.util.CharsetUtil; import io.netty.util.CharsetUtil;
import org.junit.Assert; import org.junit.jupiter.api.Test;
import org.junit.Test;
import java.net.URI; import java.net.URI;
import java.net.URISyntaxException; import java.net.URISyntaxException;
@ -26,12 +25,17 @@ import java.util.List;
import java.util.Map; import java.util.Map;
import java.util.Map.Entry; import java.util.Map.Entry;
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;
public class QueryStringDecoderTest { public class QueryStringDecoderTest {
@Test @Test
public void testBasicUris() throws URISyntaxException { public void testBasicUris() throws URISyntaxException {
QueryStringDecoder d = new QueryStringDecoder(new URI("http://localhost/path")); QueryStringDecoder d = new QueryStringDecoder(new URI("http://localhost/path"));
Assert.assertEquals(0, d.parameters().size()); assertEquals(0, d.parameters().size());
} }
@Test @Test
@ -39,68 +43,68 @@ public class QueryStringDecoderTest {
QueryStringDecoder d; QueryStringDecoder d;
d = new QueryStringDecoder("/foo"); d = new QueryStringDecoder("/foo");
Assert.assertEquals("/foo", d.path()); assertEquals("/foo", d.path());
Assert.assertEquals(0, d.parameters().size()); assertEquals(0, d.parameters().size());
d = new QueryStringDecoder("/foo%20bar"); d = new QueryStringDecoder("/foo%20bar");
Assert.assertEquals("/foo bar", d.path()); assertEquals("/foo bar", d.path());
Assert.assertEquals(0, d.parameters().size()); assertEquals(0, d.parameters().size());
d = new QueryStringDecoder("/foo?a=b=c"); d = new QueryStringDecoder("/foo?a=b=c");
Assert.assertEquals("/foo", d.path()); assertEquals("/foo", d.path());
Assert.assertEquals(1, d.parameters().size()); assertEquals(1, d.parameters().size());
Assert.assertEquals(1, d.parameters().get("a").size()); assertEquals(1, d.parameters().get("a").size());
Assert.assertEquals("b=c", d.parameters().get("a").get(0)); assertEquals("b=c", d.parameters().get("a").get(0));
d = new QueryStringDecoder("/foo?a=1&a=2"); d = new QueryStringDecoder("/foo?a=1&a=2");
Assert.assertEquals("/foo", d.path()); assertEquals("/foo", d.path());
Assert.assertEquals(1, d.parameters().size()); assertEquals(1, d.parameters().size());
Assert.assertEquals(2, d.parameters().get("a").size()); assertEquals(2, d.parameters().get("a").size());
Assert.assertEquals("1", d.parameters().get("a").get(0)); assertEquals("1", d.parameters().get("a").get(0));
Assert.assertEquals("2", d.parameters().get("a").get(1)); assertEquals("2", d.parameters().get("a").get(1));
d = new QueryStringDecoder("/foo%20bar?a=1&a=2"); d = new QueryStringDecoder("/foo%20bar?a=1&a=2");
Assert.assertEquals("/foo bar", d.path()); assertEquals("/foo bar", d.path());
Assert.assertEquals(1, d.parameters().size()); assertEquals(1, d.parameters().size());
Assert.assertEquals(2, d.parameters().get("a").size()); assertEquals(2, d.parameters().get("a").size());
Assert.assertEquals("1", d.parameters().get("a").get(0)); assertEquals("1", d.parameters().get("a").get(0));
Assert.assertEquals("2", d.parameters().get("a").get(1)); assertEquals("2", d.parameters().get("a").get(1));
d = new QueryStringDecoder("/foo?a=&a=2"); d = new QueryStringDecoder("/foo?a=&a=2");
Assert.assertEquals("/foo", d.path()); assertEquals("/foo", d.path());
Assert.assertEquals(1, d.parameters().size()); assertEquals(1, d.parameters().size());
Assert.assertEquals(2, d.parameters().get("a").size()); assertEquals(2, d.parameters().get("a").size());
Assert.assertEquals("", d.parameters().get("a").get(0)); assertEquals("", d.parameters().get("a").get(0));
Assert.assertEquals("2", d.parameters().get("a").get(1)); assertEquals("2", d.parameters().get("a").get(1));
d = new QueryStringDecoder("/foo?a=1&a="); d = new QueryStringDecoder("/foo?a=1&a=");
Assert.assertEquals("/foo", d.path()); assertEquals("/foo", d.path());
Assert.assertEquals(1, d.parameters().size()); assertEquals(1, d.parameters().size());
Assert.assertEquals(2, d.parameters().get("a").size()); assertEquals(2, d.parameters().get("a").size());
Assert.assertEquals("1", d.parameters().get("a").get(0)); assertEquals("1", d.parameters().get("a").get(0));
Assert.assertEquals("", d.parameters().get("a").get(1)); assertEquals("", d.parameters().get("a").get(1));
d = new QueryStringDecoder("/foo?a=1&a=&a="); d = new QueryStringDecoder("/foo?a=1&a=&a=");
Assert.assertEquals("/foo", d.path()); assertEquals("/foo", d.path());
Assert.assertEquals(1, d.parameters().size()); assertEquals(1, d.parameters().size());
Assert.assertEquals(3, d.parameters().get("a").size()); assertEquals(3, d.parameters().get("a").size());
Assert.assertEquals("1", d.parameters().get("a").get(0)); assertEquals("1", d.parameters().get("a").get(0));
Assert.assertEquals("", d.parameters().get("a").get(1)); assertEquals("", d.parameters().get("a").get(1));
Assert.assertEquals("", d.parameters().get("a").get(2)); assertEquals("", d.parameters().get("a").get(2));
d = new QueryStringDecoder("/foo?a=1=&a==2"); d = new QueryStringDecoder("/foo?a=1=&a==2");
Assert.assertEquals("/foo", d.path()); assertEquals("/foo", d.path());
Assert.assertEquals(1, d.parameters().size()); assertEquals(1, d.parameters().size());
Assert.assertEquals(2, d.parameters().get("a").size()); assertEquals(2, d.parameters().get("a").size());
Assert.assertEquals("1=", d.parameters().get("a").get(0)); assertEquals("1=", d.parameters().get("a").get(0));
Assert.assertEquals("=2", d.parameters().get("a").get(1)); assertEquals("=2", d.parameters().get("a").get(1));
d = new QueryStringDecoder("/foo?abc=1%2023&abc=124%20"); d = new QueryStringDecoder("/foo?abc=1%2023&abc=124%20");
Assert.assertEquals("/foo", d.path()); assertEquals("/foo", d.path());
Assert.assertEquals(1, d.parameters().size()); assertEquals(1, d.parameters().size());
Assert.assertEquals(2, d.parameters().get("abc").size()); assertEquals(2, d.parameters().get("abc").size());
Assert.assertEquals("1 23", d.parameters().get("abc").get(0)); assertEquals("1 23", d.parameters().get("abc").get(0));
Assert.assertEquals("124 ", d.parameters().get("abc").get(1)); assertEquals("124 ", d.parameters().get("abc").get(1));
} }
@Test @Test
@ -139,32 +143,32 @@ public class QueryStringDecoderTest {
@Test @Test
public void testPathSpecific() { public void testPathSpecific() {
// decode escaped characters // decode escaped characters
Assert.assertEquals("/foo bar/", new QueryStringDecoder("/foo%20bar/?").path()); assertEquals("/foo bar/", new QueryStringDecoder("/foo%20bar/?").path());
Assert.assertEquals("/foo\r\n\\bar/", new QueryStringDecoder("/foo%0D%0A\\bar/?").path()); assertEquals("/foo\r\n\\bar/", new QueryStringDecoder("/foo%0D%0A\\bar/?").path());
// a 'fragment' after '#' should be cuted (see RFC 3986) // a 'fragment' after '#' should be cuted (see RFC 3986)
Assert.assertEquals("", new QueryStringDecoder("#123").path()); assertEquals("", new QueryStringDecoder("#123").path());
Assert.assertEquals("foo", new QueryStringDecoder("foo?bar#anchor").path()); assertEquals("foo", new QueryStringDecoder("foo?bar#anchor").path());
Assert.assertEquals("/foo-bar", new QueryStringDecoder("/foo-bar#anchor").path()); assertEquals("/foo-bar", new QueryStringDecoder("/foo-bar#anchor").path());
Assert.assertEquals("/foo-bar", new QueryStringDecoder("/foo-bar#a#b?c=d").path()); assertEquals("/foo-bar", new QueryStringDecoder("/foo-bar#a#b?c=d").path());
// '+' is not escape ' ' for the path // '+' is not escape ' ' for the path
Assert.assertEquals("+", new QueryStringDecoder("+").path()); assertEquals("+", new QueryStringDecoder("+").path());
Assert.assertEquals("/foo+bar/", new QueryStringDecoder("/foo+bar/?").path()); assertEquals("/foo+bar/", new QueryStringDecoder("/foo+bar/?").path());
Assert.assertEquals("/foo++", new QueryStringDecoder("/foo++?index.php").path()); assertEquals("/foo++", new QueryStringDecoder("/foo++?index.php").path());
Assert.assertEquals("/foo +", new QueryStringDecoder("/foo%20+?index.php").path()); assertEquals("/foo +", new QueryStringDecoder("/foo%20+?index.php").path());
Assert.assertEquals("/foo+ ", new QueryStringDecoder("/foo+%20").path()); assertEquals("/foo+ ", new QueryStringDecoder("/foo+%20").path());
} }
@Test @Test
public void testExcludeFragment() { public void testExcludeFragment() {
// a 'fragment' after '#' should be cuted (see RFC 3986) // a 'fragment' after '#' should be cuted (see RFC 3986)
Assert.assertEquals("a", new QueryStringDecoder("?a#anchor").parameters().keySet().iterator().next()); assertEquals("a", new QueryStringDecoder("?a#anchor").parameters().keySet().iterator().next());
Assert.assertEquals("b", new QueryStringDecoder("?a=b#anchor").parameters().get("a").get(0)); assertEquals("b", new QueryStringDecoder("?a=b#anchor").parameters().get("a").get(0));
Assert.assertTrue(new QueryStringDecoder("?#").parameters().isEmpty()); assertTrue(new QueryStringDecoder("?#").parameters().isEmpty());
Assert.assertTrue(new QueryStringDecoder("?#anchor").parameters().isEmpty()); assertTrue(new QueryStringDecoder("?#anchor").parameters().isEmpty());
Assert.assertTrue(new QueryStringDecoder("#?a=b#anchor").parameters().isEmpty()); assertTrue(new QueryStringDecoder("#?a=b#anchor").parameters().isEmpty());
Assert.assertTrue(new QueryStringDecoder("?#a=b#anchor").parameters().isEmpty()); assertTrue(new QueryStringDecoder("?#a=b#anchor").parameters().isEmpty());
} }
@Test @Test
@ -178,20 +182,20 @@ public class QueryStringDecoderTest {
buf.append(i); buf.append(i);
buf.append('&'); buf.append('&');
} }
Assert.assertEquals(1024, new QueryStringDecoder(buf.toString()).parameters().size()); assertEquals(1024, new QueryStringDecoder(buf.toString()).parameters().size());
} }
@Test @Test
public void testHasPath() { public void testHasPath() {
QueryStringDecoder decoder = new QueryStringDecoder("1=2", false); QueryStringDecoder decoder = new QueryStringDecoder("1=2", false);
Assert.assertEquals("", decoder.path()); assertEquals("", decoder.path());
Map<String, List<String>> params = decoder.parameters(); Map<String, List<String>> params = decoder.parameters();
Assert.assertEquals(1, params.size()); assertEquals(1, params.size());
Assert.assertTrue(params.containsKey("1")); assertTrue(params.containsKey("1"));
List<String> param = params.get("1"); List<String> param = params.get("1");
Assert.assertNotNull(param); assertNotNull(param);
Assert.assertEquals(1, param.size()); assertEquals(1, param.size());
Assert.assertEquals("2", param.get(0)); assertEquals("2", param.get(0));
} }
@Test @Test
@ -224,9 +228,9 @@ public class QueryStringDecoderTest {
final String expected = tests[i + 1]; final String expected = tests[i + 1];
try { try {
final String decoded = QueryStringDecoder.decodeComponent(encoded); final String decoded = QueryStringDecoder.decodeComponent(encoded);
Assert.assertEquals(expected, decoded); assertEquals(expected, decoded);
} catch (IllegalArgumentException e) { } catch (IllegalArgumentException e) {
Assert.assertEquals(expected, e.getMessage()); assertEquals(expected, e.getMessage());
} }
} }
} }
@ -240,8 +244,8 @@ public class QueryStringDecoderTest {
1024, semicolonIsNormalChar); 1024, semicolonIsNormalChar);
QueryStringDecoder ad = new QueryStringDecoder(actual, CharsetUtil.UTF_8, true, QueryStringDecoder ad = new QueryStringDecoder(actual, CharsetUtil.UTF_8, true,
1024, semicolonIsNormalChar); 1024, semicolonIsNormalChar);
Assert.assertEquals(ed.path(), ad.path()); assertEquals(ed.path(), ad.path());
Assert.assertEquals(ed.parameters(), ad.parameters()); assertEquals(ed.parameters(), ad.parameters());
} }
// See #189 // See #189
@ -249,29 +253,29 @@ public class QueryStringDecoderTest {
public void testURI() { public void testURI() {
URI uri = URI.create("http://localhost:8080/foo?param1=value1&param2=value2&param3=value3"); URI uri = URI.create("http://localhost:8080/foo?param1=value1&param2=value2&param3=value3");
QueryStringDecoder decoder = new QueryStringDecoder(uri); QueryStringDecoder decoder = new QueryStringDecoder(uri);
Assert.assertEquals("/foo", decoder.path()); assertEquals("/foo", decoder.path());
Assert.assertEquals("/foo", decoder.rawPath()); assertEquals("/foo", decoder.rawPath());
Assert.assertEquals("param1=value1&param2=value2&param3=value3", decoder.rawQuery()); assertEquals("param1=value1&param2=value2&param3=value3", decoder.rawQuery());
Map<String, List<String>> params = decoder.parameters(); Map<String, List<String>> params = decoder.parameters();
Assert.assertEquals(3, params.size()); assertEquals(3, params.size());
Iterator<Entry<String, List<String>>> entries = params.entrySet().iterator(); Iterator<Entry<String, List<String>>> entries = params.entrySet().iterator();
Entry<String, List<String>> entry = entries.next(); Entry<String, List<String>> entry = entries.next();
Assert.assertEquals("param1", entry.getKey()); assertEquals("param1", entry.getKey());
Assert.assertEquals(1, entry.getValue().size()); assertEquals(1, entry.getValue().size());
Assert.assertEquals("value1", entry.getValue().get(0)); assertEquals("value1", entry.getValue().get(0));
entry = entries.next(); entry = entries.next();
Assert.assertEquals("param2", entry.getKey()); assertEquals("param2", entry.getKey());
Assert.assertEquals(1, entry.getValue().size()); assertEquals(1, entry.getValue().size());
Assert.assertEquals("value2", entry.getValue().get(0)); assertEquals("value2", entry.getValue().get(0));
entry = entries.next(); entry = entries.next();
Assert.assertEquals("param3", entry.getKey()); assertEquals("param3", entry.getKey());
Assert.assertEquals(1, entry.getValue().size()); assertEquals(1, entry.getValue().size());
Assert.assertEquals("value3", entry.getValue().get(0)); assertEquals("value3", entry.getValue().get(0));
Assert.assertFalse(entries.hasNext()); assertFalse(entries.hasNext());
} }
// See #189 // See #189
@ -279,30 +283,30 @@ public class QueryStringDecoderTest {
public void testURISlashPath() { public void testURISlashPath() {
URI uri = URI.create("http://localhost:8080/?param1=value1&param2=value2&param3=value3"); URI uri = URI.create("http://localhost:8080/?param1=value1&param2=value2&param3=value3");
QueryStringDecoder decoder = new QueryStringDecoder(uri); QueryStringDecoder decoder = new QueryStringDecoder(uri);
Assert.assertEquals("/", decoder.path()); assertEquals("/", decoder.path());
Assert.assertEquals("/", decoder.rawPath()); assertEquals("/", decoder.rawPath());
Assert.assertEquals("param1=value1&param2=value2&param3=value3", decoder.rawQuery()); assertEquals("param1=value1&param2=value2&param3=value3", decoder.rawQuery());
Map<String, List<String>> params = decoder.parameters(); Map<String, List<String>> params = decoder.parameters();
Assert.assertEquals(3, params.size()); assertEquals(3, params.size());
Iterator<Entry<String, List<String>>> entries = params.entrySet().iterator(); Iterator<Entry<String, List<String>>> entries = params.entrySet().iterator();
Entry<String, List<String>> entry = entries.next(); Entry<String, List<String>> entry = entries.next();
Assert.assertEquals("param1", entry.getKey()); assertEquals("param1", entry.getKey());
Assert.assertEquals(1, entry.getValue().size()); assertEquals(1, entry.getValue().size());
Assert.assertEquals("value1", entry.getValue().get(0)); assertEquals("value1", entry.getValue().get(0));
entry = entries.next(); entry = entries.next();
Assert.assertEquals("param2", entry.getKey()); assertEquals("param2", entry.getKey());
Assert.assertEquals(1, entry.getValue().size()); assertEquals(1, entry.getValue().size());
Assert.assertEquals("value2", entry.getValue().get(0)); assertEquals("value2", entry.getValue().get(0));
entry = entries.next(); entry = entries.next();
Assert.assertEquals("param3", entry.getKey()); assertEquals("param3", entry.getKey());
Assert.assertEquals(1, entry.getValue().size()); assertEquals(1, entry.getValue().size());
Assert.assertEquals("value3", entry.getValue().get(0)); assertEquals("value3", entry.getValue().get(0));
Assert.assertFalse(entries.hasNext()); assertFalse(entries.hasNext());
} }
// See #189 // See #189
@ -310,30 +314,30 @@ public class QueryStringDecoderTest {
public void testURINoPath() { public void testURINoPath() {
URI uri = URI.create("http://localhost:8080?param1=value1&param2=value2&param3=value3"); URI uri = URI.create("http://localhost:8080?param1=value1&param2=value2&param3=value3");
QueryStringDecoder decoder = new QueryStringDecoder(uri); QueryStringDecoder decoder = new QueryStringDecoder(uri);
Assert.assertEquals("", decoder.path()); assertEquals("", decoder.path());
Assert.assertEquals("", decoder.rawPath()); assertEquals("", decoder.rawPath());
Assert.assertEquals("param1=value1&param2=value2&param3=value3", decoder.rawQuery()); assertEquals("param1=value1&param2=value2&param3=value3", decoder.rawQuery());
Map<String, List<String>> params = decoder.parameters(); Map<String, List<String>> params = decoder.parameters();
Assert.assertEquals(3, params.size()); assertEquals(3, params.size());
Iterator<Entry<String, List<String>>> entries = params.entrySet().iterator(); Iterator<Entry<String, List<String>>> entries = params.entrySet().iterator();
Entry<String, List<String>> entry = entries.next(); Entry<String, List<String>> entry = entries.next();
Assert.assertEquals("param1", entry.getKey()); assertEquals("param1", entry.getKey());
Assert.assertEquals(1, entry.getValue().size()); assertEquals(1, entry.getValue().size());
Assert.assertEquals("value1", entry.getValue().get(0)); assertEquals("value1", entry.getValue().get(0));
entry = entries.next(); entry = entries.next();
Assert.assertEquals("param2", entry.getKey()); assertEquals("param2", entry.getKey());
Assert.assertEquals(1, entry.getValue().size()); assertEquals(1, entry.getValue().size());
Assert.assertEquals("value2", entry.getValue().get(0)); assertEquals("value2", entry.getValue().get(0));
entry = entries.next(); entry = entries.next();
Assert.assertEquals("param3", entry.getKey()); assertEquals("param3", entry.getKey());
Assert.assertEquals(1, entry.getValue().size()); assertEquals(1, entry.getValue().size());
Assert.assertEquals("value3", entry.getValue().get(0)); assertEquals("value3", entry.getValue().get(0));
Assert.assertFalse(entries.hasNext()); assertFalse(entries.hasNext());
} }
// See https://github.com/netty/netty/issues/1833 // See https://github.com/netty/netty/issues/1833
@ -341,37 +345,37 @@ public class QueryStringDecoderTest {
public void testURI2() { public void testURI2() {
URI uri = URI.create("http://foo.com/images;num=10?query=name;value=123"); URI uri = URI.create("http://foo.com/images;num=10?query=name;value=123");
QueryStringDecoder decoder = new QueryStringDecoder(uri); QueryStringDecoder decoder = new QueryStringDecoder(uri);
Assert.assertEquals("/images;num=10", decoder.path()); assertEquals("/images;num=10", decoder.path());
Assert.assertEquals("/images;num=10", decoder.rawPath()); assertEquals("/images;num=10", decoder.rawPath());
Assert.assertEquals("query=name;value=123", decoder.rawQuery()); assertEquals("query=name;value=123", decoder.rawQuery());
Map<String, List<String>> params = decoder.parameters(); Map<String, List<String>> params = decoder.parameters();
Assert.assertEquals(2, params.size()); assertEquals(2, params.size());
Iterator<Entry<String, List<String>>> entries = params.entrySet().iterator(); Iterator<Entry<String, List<String>>> entries = params.entrySet().iterator();
Entry<String, List<String>> entry = entries.next(); Entry<String, List<String>> entry = entries.next();
Assert.assertEquals("query", entry.getKey()); assertEquals("query", entry.getKey());
Assert.assertEquals(1, entry.getValue().size()); assertEquals(1, entry.getValue().size());
Assert.assertEquals("name", entry.getValue().get(0)); assertEquals("name", entry.getValue().get(0));
entry = entries.next(); entry = entries.next();
Assert.assertEquals("value", entry.getKey()); assertEquals("value", entry.getKey());
Assert.assertEquals(1, entry.getValue().size()); assertEquals(1, entry.getValue().size());
Assert.assertEquals("123", entry.getValue().get(0)); assertEquals("123", entry.getValue().get(0));
Assert.assertFalse(entries.hasNext()); assertFalse(entries.hasNext());
} }
@Test @Test
public void testEmptyStrings() { public void testEmptyStrings() {
QueryStringDecoder pathSlash = new QueryStringDecoder("path/"); QueryStringDecoder pathSlash = new QueryStringDecoder("path/");
Assert.assertEquals("path/", pathSlash.rawPath()); assertEquals("path/", pathSlash.rawPath());
Assert.assertEquals("", pathSlash.rawQuery()); assertEquals("", pathSlash.rawQuery());
QueryStringDecoder pathQuestion = new QueryStringDecoder("path?"); QueryStringDecoder pathQuestion = new QueryStringDecoder("path?");
Assert.assertEquals("path", pathQuestion.rawPath()); assertEquals("path", pathQuestion.rawPath());
Assert.assertEquals("", pathQuestion.rawQuery()); assertEquals("", pathQuestion.rawQuery());
QueryStringDecoder empty = new QueryStringDecoder(""); QueryStringDecoder empty = new QueryStringDecoder("");
Assert.assertEquals("", empty.rawPath()); assertEquals("", empty.rawPath());
Assert.assertEquals("", empty.rawQuery()); assertEquals("", empty.rawQuery());
} }
} }

33
codec-http/src/test/java/io/netty/handler/codec/http/QueryStringEncoderTest.java
View File

@ -15,12 +15,13 @@
*/ */
package io.netty.handler.codec.http; package io.netty.handler.codec.http;
import org.junit.Assert; import org.junit.jupiter.api.Test;
import org.junit.Test;
import java.net.URI; import java.net.URI;
import java.nio.charset.Charset; import java.nio.charset.Charset;
import static org.junit.jupiter.api.Assertions.assertEquals;
public class QueryStringEncoderTest { public class QueryStringEncoderTest {
@Test @Test
@ -29,47 +30,47 @@ public class QueryStringEncoderTest {
e = new QueryStringEncoder("/foo"); e = new QueryStringEncoder("/foo");
e.addParam("a", "b=c"); e.addParam("a", "b=c");
Assert.assertEquals("/foo?a=b%3Dc", e.toString()); assertEquals("/foo?a=b%3Dc", e.toString());
Assert.assertEquals(new URI("/foo?a=b%3Dc"), e.toUri()); assertEquals(new URI("/foo?a=b%3Dc"), e.toUri());
e = new QueryStringEncoder("/foo/\u00A5"); e = new QueryStringEncoder("/foo/\u00A5");
e.addParam("a", "\u00A5"); e.addParam("a", "\u00A5");
Assert.assertEquals("/foo/\u00A5?a=%C2%A5", e.toString()); assertEquals("/foo/\u00A5?a=%C2%A5", e.toString());
Assert.assertEquals(new URI("/foo/\u00A5?a=%C2%A5"), e.toUri()); assertEquals(new URI("/foo/\u00A5?a=%C2%A5"), e.toUri());
e = new QueryStringEncoder("/foo/\u00A5"); e = new QueryStringEncoder("/foo/\u00A5");
e.addParam("a", "abc\u00A5"); e.addParam("a", "abc\u00A5");
Assert.assertEquals("/foo/\u00A5?a=abc%C2%A5", e.toString()); assertEquals("/foo/\u00A5?a=abc%C2%A5", e.toString());
Assert.assertEquals(new URI("/foo/\u00A5?a=abc%C2%A5"), e.toUri()); assertEquals(new URI("/foo/\u00A5?a=abc%C2%A5"), e.toUri());
e = new QueryStringEncoder("/foo"); e = new QueryStringEncoder("/foo");
e.addParam("a", "1"); e.addParam("a", "1");
e.addParam("b", "2"); e.addParam("b", "2");
Assert.assertEquals("/foo?a=1&b=2", e.toString()); assertEquals("/foo?a=1&b=2", e.toString());
Assert.assertEquals(new URI("/foo?a=1&b=2"), e.toUri()); assertEquals(new URI("/foo?a=1&b=2"), e.toUri());
e = new QueryStringEncoder("/foo"); e = new QueryStringEncoder("/foo");
e.addParam("a", "1"); e.addParam("a", "1");
e.addParam("b", ""); e.addParam("b", "");
e.addParam("c", null); e.addParam("c", null);
e.addParam("d", null); e.addParam("d", null);
Assert.assertEquals("/foo?a=1&b=&c&d", e.toString()); assertEquals("/foo?a=1&b=&c&d", e.toString());
Assert.assertEquals(new URI("/foo?a=1&b=&c&d"), e.toUri()); assertEquals(new URI("/foo?a=1&b=&c&d"), e.toUri());
} }
@Test @Test
public void testNonDefaultEncoding() throws Exception { public void testNonDefaultEncoding() throws Exception {
QueryStringEncoder e = new QueryStringEncoder("/foo/\u00A5", Charset.forName("UTF-16")); QueryStringEncoder e = new QueryStringEncoder("/foo/\u00A5", Charset.forName("UTF-16"));
e.addParam("a", "\u00A5"); e.addParam("a", "\u00A5");
Assert.assertEquals("/foo/\u00A5?a=%FE%FF%00%A5", e.toString()); assertEquals("/foo/\u00A5?a=%FE%FF%00%A5", e.toString());
Assert.assertEquals(new URI("/foo/\u00A5?a=%FE%FF%00%A5"), e.toUri()); assertEquals(new URI("/foo/\u00A5?a=%FE%FF%00%A5"), e.toUri());
} }
@Test @Test
public void testWhitespaceEncoding() throws Exception { public void testWhitespaceEncoding() throws Exception {
QueryStringEncoder e = new QueryStringEncoder("/foo"); QueryStringEncoder e = new QueryStringEncoder("/foo");
e.addParam("a", "b c"); e.addParam("a", "b c");
Assert.assertEquals("/foo?a=b%20c", e.toString()); assertEquals("/foo?a=b%20c", e.toString());
Assert.assertEquals(new URI("/foo?a=b%20c"), e.toUri()); assertEquals(new URI("/foo?a=b%20c"), e.toUri());
} }
} }

33
codec-http/src/test/java/io/netty/handler/codec/http/ReadOnlyHttpHeadersTest.java
View File

@ -16,7 +16,8 @@
package io.netty.handler.codec.http; package io.netty.handler.codec.http;
import io.netty.util.AsciiString; import io.netty.util.AsciiString;
import org.junit.Test; import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.function.Executable;
import java.util.Iterator; import java.util.Iterator;
import java.util.List; import java.util.List;
@ -30,10 +31,11 @@ import static io.netty.handler.codec.http.HttpHeaderValues.APPLICATION_JSON;
import static io.netty.handler.codec.http.HttpHeaderValues.APPLICATION_OCTET_STREAM; import static io.netty.handler.codec.http.HttpHeaderValues.APPLICATION_OCTET_STREAM;
import static io.netty.handler.codec.http.HttpHeaderValues.CLOSE; import static io.netty.handler.codec.http.HttpHeaderValues.CLOSE;
import static io.netty.handler.codec.http.HttpHeaderValues.ZERO; import static io.netty.handler.codec.http.HttpHeaderValues.ZERO;
import static org.junit.Assert.assertEquals; import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.Assert.assertFalse; import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.Assert.assertNull; import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.Assert.assertTrue; import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
public class ReadOnlyHttpHeadersTest { public class ReadOnlyHttpHeadersTest {
@Test @Test
@ -113,23 +115,38 @@ public class ReadOnlyHttpHeadersTest {
assertTrue(APPLICATION_OCTET_STREAM.contentEqualsIgnoreCase(names.get(1))); assertTrue(APPLICATION_OCTET_STREAM.contentEqualsIgnoreCase(names.get(1)));
} }
@Test(expected = IllegalArgumentException.class) @Test
public void validateNamesFail() { public void validateNamesFail() {
assertThrows(IllegalArgumentException.class, new Executable() {
@Override
public void execute() {
new ReadOnlyHttpHeaders(true, new ReadOnlyHttpHeaders(true,
ACCEPT, APPLICATION_JSON, AsciiString.cached(" ")); ACCEPT, APPLICATION_JSON, AsciiString.cached(" "));
} }
});
}
@Test(expected = IllegalArgumentException.class) @Test
public void emptyHeaderName() { public void emptyHeaderName() {
assertThrows(IllegalArgumentException.class, new Executable() {
@Override
public void execute() {
new ReadOnlyHttpHeaders(true, new ReadOnlyHttpHeaders(true,
ACCEPT, APPLICATION_JSON, AsciiString.cached(" "), ZERO); ACCEPT, APPLICATION_JSON, AsciiString.cached(" "), ZERO);
} }
});
}
@Test(expected = IllegalArgumentException.class) @Test
public void headerWithoutValue() { public void headerWithoutValue() {
assertThrows(IllegalArgumentException.class, new Executable() {
@Override
public void execute() {
new ReadOnlyHttpHeaders(false, new ReadOnlyHttpHeaders(false,
ACCEPT, APPLICATION_JSON, CONTENT_LENGTH); ACCEPT, APPLICATION_JSON, CONTENT_LENGTH);
} }
});
}
private static void assert3ParisEquals(Iterator<Entry<String, String>> itr) { private static void assert3ParisEquals(Iterator<Entry<String, String>> itr) {
assertTrue(itr.hasNext()); assertTrue(itr.hasNext());

17
codec-http/src/test/java/io/netty/handler/codec/http/cookie/ClientCookieDecoderTest.java
View File

@ -17,7 +17,7 @@ package io.netty.handler.codec.http.cookie;
import io.netty.handler.codec.DateFormatter; import io.netty.handler.codec.DateFormatter;
import io.netty.handler.codec.http.cookie.CookieHeaderNames.SameSite; import io.netty.handler.codec.http.cookie.CookieHeaderNames.SameSite;
import org.junit.Test; import org.junit.jupiter.api.Test;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Calendar; import java.util.Calendar;
@ -29,7 +29,12 @@ import java.util.TimeZone;
import static org.hamcrest.CoreMatchers.instanceOf; import static org.hamcrest.CoreMatchers.instanceOf;
import static org.hamcrest.CoreMatchers.is; import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.*; 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.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
public class ClientCookieDecoderTest { public class ClientCookieDecoderTest {
@Test @Test
@ -42,10 +47,10 @@ public class ClientCookieDecoderTest {
assertNotNull(cookie); assertNotNull(cookie);
assertEquals("myValue", cookie.value()); assertEquals("myValue", cookie.value());
assertEquals(".adomainsomewhere", cookie.domain()); assertEquals(".adomainsomewhere", cookie.domain());
assertNotEquals("maxAge should be defined when parsing cookie " + cookieString, assertNotEquals(Long.MIN_VALUE, cookie.maxAge(),
Long.MIN_VALUE, cookie.maxAge()); "maxAge should be defined when parsing cookie " + cookieString);
assertTrue("maxAge should be about 50ms when parsing cookie " + cookieString, assertTrue(cookie.maxAge() >= 40 && cookie.maxAge() <= 60,
cookie.maxAge() >= 40 && cookie.maxAge() <= 60); "maxAge should be about 50ms when parsing cookie " + cookieString);
assertEquals("/apathsomewhere", cookie.path()); assertEquals("/apathsomewhere", cookie.path());
assertTrue(cookie.isSecure()); assertTrue(cookie.isSecure());

13
codec-http/src/test/java/io/netty/handler/codec/http/cookie/ClientCookieEncoderTest.java
View File

@ -15,9 +15,11 @@
*/ */
package io.netty.handler.codec.http.cookie; package io.netty.handler.codec.http.cookie;
import static org.junit.Assert.*; import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import org.junit.Test; import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.function.Executable;
public class ClientCookieEncoderTest { public class ClientCookieEncoderTest {
@ -47,10 +49,15 @@ public class ClientCookieEncoderTest {
ClientCookieEncoder.STRICT.encode(new DefaultCookie("myCookie", "\"foo\"")); ClientCookieEncoder.STRICT.encode(new DefaultCookie("myCookie", "\"foo\""));
} }
@Test(expected = IllegalArgumentException.class) @Test
public void testRejectCookieValueWithSemicolon() { public void testRejectCookieValueWithSemicolon() {
assertThrows(IllegalArgumentException.class, new Executable() {
@Override
public void execute() {
ClientCookieEncoder.STRICT.encode(new DefaultCookie("myCookie", "foo;bar")); ClientCookieEncoder.STRICT.encode(new DefaultCookie("myCookie", "foo;bar"));
} }
});
}
@Test @Test
public void testComparatorForSamePathLength() { public void testComparatorForSamePathLength() {

7
codec-http/src/test/java/io/netty/handler/codec/http/cookie/ServerCookieDecoderTest.java
View File

@ -16,12 +16,15 @@
package io.netty.handler.codec.http.cookie; package io.netty.handler.codec.http.cookie;
import java.util.List; import java.util.List;
import org.junit.Test; import org.junit.jupiter.api.Test;
import java.util.Iterator; import java.util.Iterator;
import java.util.Set; import java.util.Set;
import static org.junit.Assert.*; 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;
public class ServerCookieDecoderTest { public class ServerCookieDecoderTest {
@Test @Test

10
codec-http/src/test/java/io/netty/handler/codec/http/cookie/ServerCookieEncoderTest.java
View File

@ -17,10 +17,10 @@ package io.netty.handler.codec.http.cookie;
import static org.hamcrest.CoreMatchers.containsString; import static org.hamcrest.CoreMatchers.containsString;
import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals; import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.Assert.assertNotNull; import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.Assert.assertNull; import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.Assert.assertTrue; import static org.junit.jupiter.api.Assertions.assertTrue;
import io.netty.handler.codec.DateFormatter; import io.netty.handler.codec.DateFormatter;
@ -34,7 +34,7 @@ import java.util.regex.Matcher;
import java.util.regex.Pattern; import java.util.regex.Pattern;
import io.netty.handler.codec.http.cookie.CookieHeaderNames.SameSite; import io.netty.handler.codec.http.cookie.CookieHeaderNames.SameSite;
import org.junit.Test; import org.junit.jupiter.api.Test;
public class ServerCookieEncoderTest { public class ServerCookieEncoderTest {

11
codec-http/src/test/java/io/netty/handler/codec/http/cors/CorsConfigTest.java
View File

@ -19,7 +19,8 @@ import io.netty.handler.codec.http.EmptyHttpHeaders;
import io.netty.handler.codec.http.HttpHeaderNames; import io.netty.handler.codec.http.HttpHeaderNames;
import io.netty.handler.codec.http.HttpHeaders; import io.netty.handler.codec.http.HttpHeaders;
import io.netty.handler.codec.http.HttpMethod; import io.netty.handler.codec.http.HttpMethod;
import org.junit.Test; import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.function.Executable;
import static io.netty.handler.codec.http.HttpHeadersTestUtils.of; import static io.netty.handler.codec.http.HttpHeadersTestUtils.of;
import static io.netty.handler.codec.http.cors.CorsConfigBuilder.forAnyOrigin; import static io.netty.handler.codec.http.cors.CorsConfigBuilder.forAnyOrigin;
@ -30,6 +31,7 @@ import static org.hamcrest.CoreMatchers.hasItems;
import static org.hamcrest.CoreMatchers.is; import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.notNullValue; import static org.hamcrest.CoreMatchers.notNullValue;
import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.jupiter.api.Assertions.assertThrows;
public class CorsConfigTest { public class CorsConfigTest {
@ -125,10 +127,15 @@ public class CorsConfigTest {
assertThat(cors.preflightResponseHeaders(), equalTo((HttpHeaders) EmptyHttpHeaders.INSTANCE)); assertThat(cors.preflightResponseHeaders(), equalTo((HttpHeaders) EmptyHttpHeaders.INSTANCE));
} }
@Test (expected = IllegalArgumentException.class) @Test
public void shouldThrowIfValueIsNull() { public void shouldThrowIfValueIsNull() {
assertThrows(IllegalArgumentException.class, new Executable() {
@Override
public void execute() {
forOrigin("*").preflightResponseHeader("HeaderName", new Object[]{null}).build(); forOrigin("*").preflightResponseHeader("HeaderName", new Object[]{null}).build();
} }
});
}
@Test @Test
public void shortCircuit() { public void shortCircuit() {

2
codec-http/src/test/java/io/netty/handler/codec/http/cors/CorsHandlerTest.java
View File

@ -27,7 +27,7 @@ import io.netty.handler.codec.http.HttpUtil;
import io.netty.util.AsciiString; import io.netty.util.AsciiString;
import io.netty.util.ReferenceCountUtil; import io.netty.util.ReferenceCountUtil;
import org.hamcrest.core.IsEqual; import org.hamcrest.core.IsEqual;
import org.junit.Test; import org.junit.jupiter.api.Test;
import java.util.Arrays; import java.util.Arrays;
import java.util.Collections; import java.util.Collections;

10
codec-http/src/test/java/io/netty/handler/codec/http/multipart/AbstractDiskHttpDataTest.java
View File

@ -18,7 +18,7 @@ package io.netty.handler.codec.http.multipart;
import io.netty.buffer.ByteBuf; import io.netty.buffer.ByteBuf;
import io.netty.buffer.ByteBufUtil; import io.netty.buffer.ByteBufUtil;
import io.netty.util.internal.PlatformDependent; import io.netty.util.internal.PlatformDependent;
import org.junit.Test; import org.junit.jupiter.api.Test;
import java.io.File; import java.io.File;
import java.io.FileOutputStream; import java.io.FileOutputStream;
@ -27,8 +27,8 @@ import java.util.Arrays;
import java.util.UUID; import java.util.UUID;
import static io.netty.util.CharsetUtil.UTF_8; import static io.netty.util.CharsetUtil.UTF_8;
import static org.junit.Assert.assertEquals; import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.Assert.assertFalse; import static org.junit.jupiter.api.Assertions.assertFalse;
/** /**
* {@link AbstractDiskHttpData} test cases * {@link AbstractDiskHttpData} test cases
@ -57,8 +57,8 @@ public class AbstractDiskHttpDataTest {
ByteBuf buf2 = test.getChunk(1024); ByteBuf buf2 = test.getChunk(1024);
assertEquals(buf2.readerIndex(), 0); assertEquals(buf2.readerIndex(), 0);
assertEquals(buf2.writerIndex(), 1024); assertEquals(buf2.writerIndex(), 1024);
assertFalse("Arrays should not be equal", assertFalse(Arrays.equals(ByteBufUtil.getBytes(buf1), ByteBufUtil.getBytes(buf2)),
Arrays.equals(ByteBufUtil.getBytes(buf1), ByteBufUtil.getBytes(buf2))); "Arrays should not be equal");
} finally { } finally {
test.delete(); test.delete();
} }

7
codec-http/src/test/java/io/netty/handler/codec/http/multipart/AbstractMemoryHttpDataTest.java
View File

@ -21,7 +21,7 @@ import io.netty.buffer.ByteBufUtil;
import io.netty.buffer.Unpooled; import io.netty.buffer.Unpooled;
import io.netty.util.internal.PlatformDependent; import io.netty.util.internal.PlatformDependent;
import org.junit.Test; import org.junit.jupiter.api.Test;
import java.io.ByteArrayInputStream; import java.io.ByteArrayInputStream;
import java.io.File; import java.io.File;
@ -34,7 +34,10 @@ import java.util.Random;
import java.util.UUID; import java.util.UUID;
import static io.netty.util.CharsetUtil.*; import static io.netty.util.CharsetUtil.*;
import static org.junit.Assert.*; import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
/** {@link AbstractMemoryHttpData} test cases. */ /** {@link AbstractMemoryHttpData} test cases. */
public class AbstractMemoryHttpDataTest { public class AbstractMemoryHttpDataTest {

24
codec-http/src/test/java/io/netty/handler/codec/http/multipart/DefaultHttpDataFactoryTest.java
View File

@ -18,21 +18,21 @@ package io.netty.handler.codec.http.multipart;
import io.netty.buffer.Unpooled; import io.netty.buffer.Unpooled;
import io.netty.handler.codec.http.DefaultHttpRequest; import io.netty.handler.codec.http.DefaultHttpRequest;
import io.netty.handler.codec.http.HttpRequest; import io.netty.handler.codec.http.HttpRequest;
import org.junit.After; import org.junit.jupiter.api.AfterEach;
import org.junit.Before; import org.junit.jupiter.api.BeforeAll;
import org.junit.BeforeClass; import org.junit.jupiter.api.BeforeEach;
import org.junit.Test; import org.junit.jupiter.api.Test;
import static io.netty.handler.codec.http.HttpHeaderValues.IDENTITY; import static io.netty.handler.codec.http.HttpHeaderValues.IDENTITY;
import static io.netty.handler.codec.http.HttpMethod.POST; import static io.netty.handler.codec.http.HttpMethod.POST;
import static io.netty.handler.codec.http.HttpVersion.HTTP_1_1; import static io.netty.handler.codec.http.HttpVersion.HTTP_1_1;
import static io.netty.handler.codec.http.multipart.HttpPostBodyUtil.DEFAULT_TEXT_CONTENT_TYPE; import static io.netty.handler.codec.http.multipart.HttpPostBodyUtil.DEFAULT_TEXT_CONTENT_TYPE;
import static io.netty.util.CharsetUtil.UTF_8; import static io.netty.util.CharsetUtil.UTF_8;
import static org.junit.Assert.assertEquals; import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.Assert.assertFalse; import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.Assert.assertNotNull; import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.Assert.assertNull; import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.Assert.assertTrue; import static org.junit.jupiter.api.Assertions.assertTrue;
public class DefaultHttpDataFactoryTest { public class DefaultHttpDataFactoryTest {
// req1 equals req2 // req1 equals req2
@ -41,19 +41,19 @@ public class DefaultHttpDataFactoryTest {
private DefaultHttpDataFactory factory; private DefaultHttpDataFactory factory;
@BeforeClass @BeforeAll
public static void assertReq1EqualsReq2() { public static void assertReq1EqualsReq2() {
// Before doing anything, assert that the requests are equal // Before doing anything, assert that the requests are equal
assertEquals(req1.hashCode(), req2.hashCode()); assertEquals(req1.hashCode(), req2.hashCode());
assertTrue(req1.equals(req2)); assertTrue(req1.equals(req2));
} }
@Before @BeforeEach
public void setupFactory() { public void setupFactory() {
factory = new DefaultHttpDataFactory(); factory = new DefaultHttpDataFactory();
} }
@After @AfterEach
public void cleanupFactory() { public void cleanupFactory() {
factory.cleanAllHttpData(); factory.cleanAllHttpData();
} }

10
codec-http/src/test/java/io/netty/handler/codec/http/multipart/DeleteFileOnExitHookTest.java
View File

@ -18,8 +18,8 @@ package io.netty.handler.codec.http.multipart;
import io.netty.buffer.Unpooled; import io.netty.buffer.Unpooled;
import io.netty.handler.codec.http.DefaultHttpRequest; import io.netty.handler.codec.http.DefaultHttpRequest;
import io.netty.handler.codec.http.HttpRequest; import io.netty.handler.codec.http.HttpRequest;
import org.junit.Before; import org.junit.jupiter.api.BeforeEach;
import org.junit.Test; import org.junit.jupiter.api.Test;
import java.io.File; import java.io.File;
import java.io.FilenameFilter; import java.io.FilenameFilter;
@ -27,7 +27,9 @@ import java.io.IOException;
import static io.netty.handler.codec.http.HttpMethod.POST; import static io.netty.handler.codec.http.HttpMethod.POST;
import static io.netty.handler.codec.http.HttpVersion.HTTP_1_1; import static io.netty.handler.codec.http.HttpVersion.HTTP_1_1;
import static org.junit.Assert.*; import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
/** /**
* Test DeleteFileOnExitHook * Test DeleteFileOnExitHook
@ -37,7 +39,7 @@ public class DeleteFileOnExitHookTest {
private static final String HOOK_TEST_TMP = "target/DeleteFileOnExitHookTest/tmp"; private static final String HOOK_TEST_TMP = "target/DeleteFileOnExitHookTest/tmp";
private FileUpload fu; private FileUpload fu;
@Before @BeforeEach
public void setUp() throws IOException { public void setUp() throws IOException {
DefaultHttpDataFactory defaultHttpDataFactory = new DefaultHttpDataFactory(true); DefaultHttpDataFactory defaultHttpDataFactory = new DefaultHttpDataFactory(true);
defaultHttpDataFactory.setBaseDir(HOOK_TEST_TMP); defaultHttpDataFactory.setBaseDir(HOOK_TEST_TMP);

16
codec-http/src/test/java/io/netty/handler/codec/http/multipart/DiskFileUploadTest.java
View File

@ -22,7 +22,7 @@ import io.netty.buffer.Unpooled;
import io.netty.util.CharsetUtil; import io.netty.util.CharsetUtil;
import io.netty.util.internal.PlatformDependent; import io.netty.util.internal.PlatformDependent;
import org.junit.Test; import org.junit.jupiter.api.Test;
import java.io.File; import java.io.File;
import java.io.FileInputStream; import java.io.FileInputStream;
@ -31,13 +31,13 @@ import java.io.IOException;
import java.io.InputStream; import java.io.InputStream;
import java.util.UUID; import java.util.UUID;
import static org.junit.Assert.assertArrayEquals; import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.Assert.assertEquals; import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.Assert.assertFalse; import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.Assert.assertNotNull; import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.Assert.assertNull; import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.Assert.assertTrue; import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.Assert.fail; import static org.junit.jupiter.api.Assertions.fail;
public class DiskFileUploadTest { public class DiskFileUploadTest {
@Test @Test

28
codec-http/src/test/java/io/netty/handler/codec/http/multipart/HttpPostMultiPartRequestDecoderTest.java
View File

@ -28,17 +28,17 @@ import io.netty.handler.codec.http.HttpMethod;
import io.netty.handler.codec.http.HttpRequest; import io.netty.handler.codec.http.HttpRequest;
import io.netty.handler.codec.http.HttpVersion; import io.netty.handler.codec.http.HttpVersion;
import io.netty.util.CharsetUtil; import io.netty.util.CharsetUtil;
import org.junit.Test; import org.junit.jupiter.api.Test;
import java.io.IOException; import java.io.IOException;
import java.util.Arrays; import java.util.Arrays;
import static org.junit.Assert.assertEquals; import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.Assert.assertFalse; import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.Assert.assertNotNull; import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.Assert.assertNull; import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.Assert.assertTrue; import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.Assert.fail; import static org.junit.jupiter.api.Assertions.fail;
public class HttpPostMultiPartRequestDecoderTest { public class HttpPostMultiPartRequestDecoderTest {
@ -173,22 +173,22 @@ public class HttpPostMultiPartRequestDecoderTest {
assertEquals(inMemory, data.isInMemory()); assertEquals(inMemory, data.isInMemory());
if (data.isInMemory()) { if (data.isInMemory()) {
// To be done only if not inMemory: assertEquals(data.get().length, fileSize); // To be done only if not inMemory: assertEquals(data.get().length, fileSize);
assertFalse("Capacity should be higher than 1M", data.getByteBuf().capacity() assertFalse(data.getByteBuf().capacity() < 1024 * 1024,
< 1024 * 1024); "Capacity should be higher than 1M");
} }
assertTrue("Capacity should be less than 1M", decoder.getCurrentAllocatedCapacity() assertTrue(decoder.getCurrentAllocatedCapacity() < 1024 * 1024,
< 1024 * 1024); "Capacity should be less than 1M");
InterfaceHttpData[] httpDatas = decoder.getBodyHttpDatas().toArray(new InterfaceHttpData[0]); InterfaceHttpData[] httpDatas = decoder.getBodyHttpDatas().toArray(new InterfaceHttpData[0]);
for (InterfaceHttpData httpData : httpDatas) { for (InterfaceHttpData httpData : httpDatas) {
assertEquals("Before cleanAllHttpData should be 1", 1, httpData.refCnt()); assertEquals(1, httpData.refCnt(), "Before cleanAllHttpData should be 1");
} }
factory.cleanAllHttpData(); factory.cleanAllHttpData();
for (InterfaceHttpData httpData : httpDatas) { for (InterfaceHttpData httpData : httpDatas) {
assertEquals("Before cleanAllHttpData should be 1 if in Memory", inMemory? 1 : 0, httpData.refCnt()); assertEquals(inMemory? 1 : 0, httpData.refCnt(), "Before cleanAllHttpData should be 1 if in Memory");
} }
decoder.destroy(); decoder.destroy();
for (InterfaceHttpData httpData : httpDatas) { for (InterfaceHttpData httpData : httpDatas) {
assertEquals("RefCnt should be 0", 0, httpData.refCnt()); assertEquals(0, httpData.refCnt(), "RefCnt should be 0");
} }
} }

55
codec-http/src/test/java/io/netty/handler/codec/http/multipart/HttpPostRequestDecoderTest.java
View File

@ -32,13 +32,19 @@ import io.netty.handler.codec.http.HttpRequest;
import io.netty.handler.codec.http.HttpVersion; import io.netty.handler.codec.http.HttpVersion;
import io.netty.handler.codec.http.LastHttpContent; import io.netty.handler.codec.http.LastHttpContent;
import io.netty.util.CharsetUtil; import io.netty.util.CharsetUtil;
import org.junit.Test; import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.function.Executable;
import java.net.URLEncoder; import java.net.URLEncoder;
import java.nio.charset.UnsupportedCharsetException; import java.nio.charset.UnsupportedCharsetException;
import java.util.Arrays; import java.util.Arrays;
import static org.junit.Assert.*; 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.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.Assertions.fail;
/** /**
* {@link HttpPostRequestDecoder} test case. * {@link HttpPostRequestDecoder} test case.
@ -97,8 +103,8 @@ public class HttpPostRequestDecoderTest {
MemoryFileUpload upload = (MemoryFileUpload) decoder.next(); MemoryFileUpload upload = (MemoryFileUpload) decoder.next();
// Validate data has been parsed correctly as it was passed into request. // Validate data has been parsed correctly as it was passed into request.
assertEquals("Invalid decoded data [data=" + data.replaceAll("\r", "\\\\r") + ", upload=" + upload + ']', assertEquals(data, upload.getString(CharsetUtil.UTF_8),
data, upload.getString(CharsetUtil.UTF_8)); "Invalid decoded data [data=" + data.replaceAll("\r", "\\\\r") + ", upload=" + upload + ']');
upload.release(); upload.release();
decoder.destroy(); decoder.destroy();
buf.release(); buf.release();
@ -266,7 +272,7 @@ public class HttpPostRequestDecoderTest {
aDecoder.offer(LastHttpContent.EMPTY_LAST_CONTENT); aDecoder.offer(LastHttpContent.EMPTY_LAST_CONTENT);
assertTrue("Should have a piece of data", aDecoder.hasNext()); assertTrue(aDecoder.hasNext(), "Should have a piece of data");
InterfaceHttpData aDecodedData = aDecoder.next(); InterfaceHttpData aDecodedData = aDecoder.next();
assertEquals(InterfaceHttpData.HttpDataType.Attribute, aDecodedData.getHttpDataType()); assertEquals(InterfaceHttpData.HttpDataType.Attribute, aDecodedData.getHttpDataType());
@ -465,10 +471,10 @@ public class HttpPostRequestDecoderTest {
final HttpPostRequestDecoder decoder = new HttpPostRequestDecoder(inMemoryFactory, req); final HttpPostRequestDecoder decoder = new HttpPostRequestDecoder(inMemoryFactory, req);
assertFalse(decoder.getBodyHttpDatas().isEmpty()); assertFalse(decoder.getBodyHttpDatas().isEmpty());
InterfaceHttpData part1 = decoder.getBodyHttpDatas().get(0); InterfaceHttpData part1 = decoder.getBodyHttpDatas().get(0);
assertTrue("the item should be a FileUpload", part1 instanceof FileUpload); assertTrue(part1 instanceof FileUpload, "the item should be a FileUpload");
FileUpload fileUpload = (FileUpload) part1; FileUpload fileUpload = (FileUpload) part1;
byte[] fileBytes = fileUpload.get(); byte[] fileBytes = fileUpload.get();
assertTrue("the filecontent should not be decoded", filecontent.equals(new String(fileBytes))); assertTrue(filecontent.equals(new String(fileBytes)), "the filecontent should not be decoded");
decoder.destroy(); decoder.destroy();
assertTrue(req.release()); assertTrue(req.release());
} }
@ -580,9 +586,9 @@ public class HttpPostRequestDecoderTest {
final HttpPostRequestDecoder decoder = new HttpPostRequestDecoder(inMemoryFactory, req); final HttpPostRequestDecoder decoder = new HttpPostRequestDecoder(inMemoryFactory, req);
assertFalse(decoder.getBodyHttpDatas().isEmpty()); assertFalse(decoder.getBodyHttpDatas().isEmpty());
InterfaceHttpData part1 = decoder.getBodyHttpDatas().get(0); InterfaceHttpData part1 = decoder.getBodyHttpDatas().get(0);
assertTrue("the item should be a FileUpload", part1 instanceof FileUpload); assertTrue(part1 instanceof FileUpload, "the item should be a FileUpload");
FileUpload fileUpload = (FileUpload) part1; FileUpload fileUpload = (FileUpload) part1;
assertEquals("the filename should be decoded", filename, fileUpload.getFilename()); assertEquals(filename, fileUpload.getFilename(), "the filename should be decoded");
decoder.destroy(); decoder.destroy();
assertTrue(req.release()); assertTrue(req.release());
} }
@ -616,9 +622,9 @@ public class HttpPostRequestDecoderTest {
final HttpPostRequestDecoder decoder = new HttpPostRequestDecoder(inMemoryFactory, req); final HttpPostRequestDecoder decoder = new HttpPostRequestDecoder(inMemoryFactory, req);
assertFalse(decoder.getBodyHttpDatas().isEmpty()); assertFalse(decoder.getBodyHttpDatas().isEmpty());
InterfaceHttpData part1 = decoder.getBodyHttpDatas().get(0); InterfaceHttpData part1 = decoder.getBodyHttpDatas().get(0);
assertTrue("the item should be a FileUpload", part1 instanceof FileUpload); assertTrue(part1 instanceof FileUpload, "the item should be a FileUpload");
FileUpload fileUpload = (FileUpload) part1; FileUpload fileUpload = (FileUpload) part1;
assertEquals("the filename should be decoded", filename, fileUpload.getFilename()); assertEquals(filename, fileUpload.getFilename(), "the filename should be decoded");
decoder.destroy(); decoder.destroy();
assertTrue(req.release()); assertTrue(req.release());
} }
@ -758,26 +764,41 @@ public class HttpPostRequestDecoderTest {
assertTrue(req.release()); assertTrue(req.release());
} }
@Test(expected = HttpPostRequestDecoder.ErrorDataDecoderException.class) @Test
public void testNotLeak() { public void testNotLeak() {
FullHttpRequest request = new DefaultFullHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.POST, "/", final FullHttpRequest request = new DefaultFullHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.POST, "/",
Unpooled.copiedBuffer("a=1&&b=2", CharsetUtil.US_ASCII)); Unpooled.copiedBuffer("a=1&&b=2", CharsetUtil.US_ASCII));
try { try {
assertThrows(HttpPostRequestDecoder.ErrorDataDecoderException.class, new Executable() {
@Override
public void execute() {
new HttpPostStandardRequestDecoder(request).destroy(); new HttpPostStandardRequestDecoder(request).destroy();
}
});
} finally { } finally {
assertTrue(request.release()); assertTrue(request.release());
} }
} }
@Test(expected = HttpPostRequestDecoder.ErrorDataDecoderException.class) @Test
public void testNotLeakDirectBufferWhenWrapIllegalArgumentException() { public void testNotLeakDirectBufferWhenWrapIllegalArgumentException() {
assertThrows(HttpPostRequestDecoder.ErrorDataDecoderException.class, new Executable() {
@Override
public void execute() {
testNotLeakWhenWrapIllegalArgumentException(Unpooled.directBuffer()); testNotLeakWhenWrapIllegalArgumentException(Unpooled.directBuffer());
} }
});
}
@Test(expected = HttpPostRequestDecoder.ErrorDataDecoderException.class) @Test
public void testNotLeakHeapBufferWhenWrapIllegalArgumentException() { public void testNotLeakHeapBufferWhenWrapIllegalArgumentException() {
assertThrows(HttpPostRequestDecoder.ErrorDataDecoderException.class, new Executable() {
@Override
public void execute() throws Throwable {
testNotLeakWhenWrapIllegalArgumentException(Unpooled.buffer()); testNotLeakWhenWrapIllegalArgumentException(Unpooled.buffer());
} }
});
}
private static void testNotLeakWhenWrapIllegalArgumentException(ByteBuf buf) { private static void testNotLeakWhenWrapIllegalArgumentException(ByteBuf buf) {
buf.writeCharSequence("a=b&foo=%22bar%22&==", CharsetUtil.US_ASCII); buf.writeCharSequence("a=b&foo=%22bar%22&==", CharsetUtil.US_ASCII);
@ -830,9 +851,9 @@ public class HttpPostRequestDecoderTest {
final HttpPostRequestDecoder decoder = new HttpPostRequestDecoder(inMemoryFactory, req); final HttpPostRequestDecoder decoder = new HttpPostRequestDecoder(inMemoryFactory, req);
assertFalse(decoder.getBodyHttpDatas().isEmpty()); assertFalse(decoder.getBodyHttpDatas().isEmpty());
InterfaceHttpData part1 = decoder.getBodyHttpDatas().get(0); InterfaceHttpData part1 = decoder.getBodyHttpDatas().get(0);
assertTrue("the item should be a FileUpload", part1 instanceof FileUpload); assertTrue(part1 instanceof FileUpload, "the item should be a FileUpload");
FileUpload fileUpload = (FileUpload) part1; FileUpload fileUpload = (FileUpload) part1;
assertEquals("the filename should be decoded", filename, fileUpload.getFilename()); assertEquals(filename, fileUpload.getFilename(), "the filename should be decoded");
decoder.destroy(); decoder.destroy();
assertTrue(req.release()); assertTrue(req.release());

28
codec-http/src/test/java/io/netty/handler/codec/http/multipart/HttpPostRequestEncoderTest.java
View File

@ -30,7 +30,7 @@ import io.netty.handler.codec.http.multipart.HttpPostRequestEncoder.EncoderMode;
import io.netty.handler.codec.http.multipart.HttpPostRequestEncoder.ErrorDataEncoderException; import io.netty.handler.codec.http.multipart.HttpPostRequestEncoder.ErrorDataEncoderException;
import io.netty.util.CharsetUtil; import io.netty.util.CharsetUtil;
import io.netty.util.internal.StringUtil; import io.netty.util.internal.StringUtil;
import org.junit.Test; import org.junit.jupiter.api.Test;
import java.io.ByteArrayInputStream; import java.io.ByteArrayInputStream;
import java.io.File; import java.io.File;
@ -41,10 +41,10 @@ import static io.netty.handler.codec.http.HttpHeaderNames.CONTENT_DISPOSITION;
import static io.netty.handler.codec.http.HttpHeaderNames.CONTENT_LENGTH; import static io.netty.handler.codec.http.HttpHeaderNames.CONTENT_LENGTH;
import static io.netty.handler.codec.http.HttpHeaderNames.CONTENT_TRANSFER_ENCODING; import static io.netty.handler.codec.http.HttpHeaderNames.CONTENT_TRANSFER_ENCODING;
import static io.netty.handler.codec.http.HttpHeaderNames.CONTENT_TYPE; import static io.netty.handler.codec.http.HttpHeaderNames.CONTENT_TYPE;
import static org.junit.Assert.assertEquals; import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.Assert.assertNotNull; import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.Assert.assertTrue; import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.Assert.fail; import static org.junit.jupiter.api.Assertions.fail;
/** {@link HttpPostRequestEncoder} test case. */ /** {@link HttpPostRequestEncoder} test case. */
public class HttpPostRequestEncoderTest { public class HttpPostRequestEncoderTest {
@ -345,9 +345,9 @@ public class HttpPostRequestEncoderTest {
HttpContent httpContent = encoder.readChunk((ByteBufAllocator) null); HttpContent httpContent = encoder.readChunk((ByteBufAllocator) null);
ByteBuf content = httpContent.content(); ByteBuf content = httpContent.content();
int refCnt = content.refCnt(); int refCnt = content.refCnt();
assertTrue("content: " + content + " content.unwrap(): " + content.unwrap() + " refCnt: " + refCnt, assertTrue((content.unwrap() == content || content.unwrap() == null) && refCnt == 1 ||
(content.unwrap() == content || content.unwrap() == null) && refCnt == 1 || content.unwrap() != content && refCnt == 2,
content.unwrap() != content && refCnt == 2); "content: " + content + " content.unwrap(): " + content.unwrap() + " refCnt: " + refCnt);
httpContent.release(); httpContent.release();
} }
encoder.cleanFiles(); encoder.cleanFiles();
@ -401,10 +401,10 @@ public class HttpPostRequestEncoderTest {
checkNextChunkSize(encoder, 8080); checkNextChunkSize(encoder, 8080);
HttpContent httpContent = encoder.readChunk((ByteBufAllocator) null); HttpContent httpContent = encoder.readChunk((ByteBufAllocator) null);
assertTrue("Expected LastHttpContent is not received", httpContent instanceof LastHttpContent); assertTrue(httpContent instanceof LastHttpContent, "Expected LastHttpContent is not received");
httpContent.release(); httpContent.release();
assertTrue("Expected end of input is not receive", encoder.isEndOfInput()); assertTrue(encoder.isEndOfInput(), "Expected end of input is not receive");
} }
@Test @Test
@ -423,10 +423,10 @@ public class HttpPostRequestEncoderTest {
checkNextChunkSize(encoder, 8080); checkNextChunkSize(encoder, 8080);
HttpContent httpContent = encoder.readChunk((ByteBufAllocator) null); HttpContent httpContent = encoder.readChunk((ByteBufAllocator) null);
assertTrue("Expected LastHttpContent is not received", httpContent instanceof LastHttpContent); assertTrue(httpContent instanceof LastHttpContent, "Expected LastHttpContent is not received");
httpContent.release(); httpContent.release();
assertTrue("Expected end of input is not receive", encoder.isEndOfInput()); assertTrue(encoder.isEndOfInput(), "Expected end of input is not receive");
} }
private static void checkNextChunkSize(HttpPostRequestEncoder encoder, int sizeWithoutDelimiter) throws Exception { private static void checkNextChunkSize(HttpPostRequestEncoder encoder, int sizeWithoutDelimiter) throws Exception {
@ -441,8 +441,8 @@ public class HttpPostRequestEncoderTest {
int readable = httpContent.content().readableBytes(); int readable = httpContent.content().readableBytes();
boolean expectedSize = readable >= expectedSizeMin && readable <= expectedSizeMax; boolean expectedSize = readable >= expectedSizeMin && readable <= expectedSizeMax;
assertTrue("Chunk size is not in expected range (" + expectedSizeMin + " - " + expectedSizeMax + "), was: " assertTrue(expectedSize, "Chunk size is not in expected range (" + expectedSizeMin + " - "
+ readable, expectedSize); + expectedSizeMax + "), was: " + readable);
httpContent.release(); httpContent.release();
} }

7
codec-http/src/test/java/io/netty/handler/codec/http/multipart/MemoryFileUploadTest.java
View File

@ -15,8 +15,9 @@
*/ */
package io.netty.handler.codec.http.multipart; package io.netty.handler.codec.http.multipart;
import org.junit.Assert; import org.junit.jupiter.api.Test;
import org.junit.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;
public class MemoryFileUploadTest { public class MemoryFileUploadTest {
@ -24,6 +25,6 @@ public class MemoryFileUploadTest {
public final void testMemoryFileUploadEquals() { public final void testMemoryFileUploadEquals() {
MemoryFileUpload f1 = MemoryFileUpload f1 =
new MemoryFileUpload("m1", "m1", "application/json", null, null, 100); new MemoryFileUpload("m1", "m1", "application/json", null, null, 100);
Assert.assertEquals(f1, f1); assertEquals(f1, f1);
} }
} }

21
codec-http/src/test/java/io/netty/handler/codec/http/websocketx/WebSocket00FrameEncoderTest.java
View File

@ -17,8 +17,11 @@ package io.netty.handler.codec.http.websocketx;
import io.netty.buffer.ByteBuf; import io.netty.buffer.ByteBuf;
import io.netty.channel.embedded.EmbeddedChannel; import io.netty.channel.embedded.EmbeddedChannel;
import org.junit.Assert; import org.junit.jupiter.api.Test;
import org.junit.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
public class WebSocket00FrameEncoderTest { public class WebSocket00FrameEncoderTest {
@ -26,19 +29,19 @@ public class WebSocket00FrameEncoderTest {
@Test @Test
public void testMultipleWebSocketCloseFrames() { public void testMultipleWebSocketCloseFrames() {
EmbeddedChannel channel = new EmbeddedChannel(new WebSocket00FrameEncoder()); EmbeddedChannel channel = new EmbeddedChannel(new WebSocket00FrameEncoder());
Assert.assertTrue(channel.writeOutbound(new CloseWebSocketFrame())); assertTrue(channel.writeOutbound(new CloseWebSocketFrame()));
Assert.assertTrue(channel.writeOutbound(new CloseWebSocketFrame())); assertTrue(channel.writeOutbound(new CloseWebSocketFrame()));
Assert.assertTrue(channel.finish()); assertTrue(channel.finish());
assertCloseWebSocketFrame(channel); assertCloseWebSocketFrame(channel);
assertCloseWebSocketFrame(channel); assertCloseWebSocketFrame(channel);
Assert.assertNull(channel.readOutbound()); assertNull(channel.readOutbound());
} }
private static void assertCloseWebSocketFrame(EmbeddedChannel channel) { private static void assertCloseWebSocketFrame(EmbeddedChannel channel) {
ByteBuf buf = channel.readOutbound(); ByteBuf buf = channel.readOutbound();
Assert.assertEquals(2, buf.readableBytes()); assertEquals(2, buf.readableBytes());
Assert.assertEquals((byte) 0xFF, buf.readByte()); assertEquals((byte) 0xFF, buf.readByte());
Assert.assertEquals((byte) 0x00, buf.readByte()); assertEquals((byte) 0x00, buf.readByte());
buf.release(); buf.release();
} }
} }

47
codec-http/src/test/java/io/netty/handler/codec/http/websocketx/WebSocket08EncoderDecoderTest.java
View File

@ -18,8 +18,13 @@ package io.netty.handler.codec.http.websocketx;
import io.netty.buffer.ByteBuf; import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled; import io.netty.buffer.Unpooled;
import io.netty.channel.embedded.EmbeddedChannel; import io.netty.channel.embedded.EmbeddedChannel;
import org.junit.Assert; import org.junit.jupiter.api.Test;
import org.junit.Test;
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.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
/** /**
* Tests the WebSocket08FrameEncoder and Decoder implementation.<br> * Tests the WebSocket08FrameEncoder and Decoder implementation.<br>
@ -73,13 +78,13 @@ public class WebSocket08EncoderDecoderTest {
executeProtocolViolationTest(outChannel, inChannel, maxPayloadLength + 1, expectedStatus, errorMessage); executeProtocolViolationTest(outChannel, inChannel, maxPayloadLength + 1, expectedStatus, errorMessage);
CloseWebSocketFrame response = inChannel.readOutbound(); CloseWebSocketFrame response = inChannel.readOutbound();
Assert.assertNotNull(response); assertNotNull(response);
Assert.assertEquals(expectedStatus.code(), response.statusCode()); assertEquals(expectedStatus.code(), response.statusCode());
Assert.assertEquals(errorMessage, response.reasonText()); assertEquals(errorMessage, response.reasonText());
response.release(); response.release();
Assert.assertFalse(inChannel.finish()); assertFalse(inChannel.finish());
Assert.assertFalse(outChannel.finish()); assertFalse(outChannel.finish());
// Without auto-close // Without auto-close
config = WebSocketDecoderConfig.newBuilder() config = WebSocketDecoderConfig.newBuilder()
@ -92,10 +97,10 @@ public class WebSocket08EncoderDecoderTest {
executeProtocolViolationTest(outChannel, inChannel, maxPayloadLength + 1, expectedStatus, errorMessage); executeProtocolViolationTest(outChannel, inChannel, maxPayloadLength + 1, expectedStatus, errorMessage);
response = inChannel.readOutbound(); response = inChannel.readOutbound();
Assert.assertNull(response); assertNull(response);
Assert.assertFalse(inChannel.finish()); assertFalse(inChannel.finish());
Assert.assertFalse(outChannel.finish()); assertFalse(outChannel.finish());
// Release test data // Release test data
binTestData.release(); binTestData.release();
@ -112,11 +117,11 @@ public class WebSocket08EncoderDecoderTest {
} }
BinaryWebSocketFrame exceedingFrame = inChannel.readInbound(); BinaryWebSocketFrame exceedingFrame = inChannel.readInbound();
Assert.assertNull(exceedingFrame); assertNull(exceedingFrame);
Assert.assertNotNull(corrupted); assertNotNull(corrupted);
Assert.assertEquals(expectedStatus, corrupted.closeStatus()); assertEquals(expectedStatus, corrupted.closeStatus());
Assert.assertEquals(errorMessage, corrupted.getMessage()); assertEquals(errorMessage, corrupted.getMessage());
} }
@Test @Test
@ -177,10 +182,10 @@ public class WebSocket08EncoderDecoderTest {
transfer(outChannel, inChannel); transfer(outChannel, inChannel);
Object decoded = inChannel.readInbound(); Object decoded = inChannel.readInbound();
Assert.assertNotNull(decoded); assertNotNull(decoded);
Assert.assertTrue(decoded instanceof TextWebSocketFrame); assertTrue(decoded instanceof TextWebSocketFrame);
TextWebSocketFrame txt = (TextWebSocketFrame) decoded; TextWebSocketFrame txt = (TextWebSocketFrame) decoded;
Assert.assertEquals(txt.text(), testStr); assertEquals(txt.text(), testStr);
txt.release(); txt.release();
} }
@ -192,13 +197,13 @@ public class WebSocket08EncoderDecoderTest {
transfer(outChannel, inChannel); transfer(outChannel, inChannel);
Object decoded = inChannel.readInbound(); Object decoded = inChannel.readInbound();
Assert.assertNotNull(decoded); assertNotNull(decoded);
Assert.assertTrue(decoded instanceof BinaryWebSocketFrame); assertTrue(decoded instanceof BinaryWebSocketFrame);
BinaryWebSocketFrame binFrame = (BinaryWebSocketFrame) decoded; BinaryWebSocketFrame binFrame = (BinaryWebSocketFrame) decoded;
int readable = binFrame.content().readableBytes(); int readable = binFrame.content().readableBytes();
Assert.assertEquals(readable, testDataLength); assertEquals(readable, testDataLength);
for (int i = 0; i < testDataLength; i++) { for (int i = 0; i < testDataLength; i++) {
Assert.assertEquals(binTestData.getByte(i), binFrame.content().getByte(i)); assertEquals(binTestData.getByte(i), binFrame.content().getByte(i));
} }
binFrame.release(); binFrame.release();
} }

8
codec-http/src/test/java/io/netty/handler/codec/http/websocketx/WebSocket08FrameDecoderTest.java
View File

@ -15,14 +15,14 @@ package io.netty.handler.codec.http.websocketx;
import io.netty.buffer.ByteBuf; import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext; import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.embedded.EmbeddedChannel; import io.netty.channel.embedded.EmbeddedChannel;
import org.junit.Test; import org.junit.jupiter.api.Test;
import java.util.HashSet; import java.util.HashSet;
import java.util.Set; import java.util.Set;
import static org.junit.Assert.assertEquals; import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.Assert.assertNull; import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.Assert.assertTrue; import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.Mockito.mock; import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify; import static org.mockito.Mockito.verify;

4
codec-http/src/test/java/io/netty/handler/codec/http/websocketx/WebSocketClientHandshaker07Test.java
View File

@ -19,11 +19,11 @@ import io.netty.handler.codec.http.DefaultHttpHeaders;
import io.netty.handler.codec.http.FullHttpRequest; import io.netty.handler.codec.http.FullHttpRequest;
import io.netty.handler.codec.http.HttpHeaderNames; import io.netty.handler.codec.http.HttpHeaderNames;
import io.netty.handler.codec.http.HttpHeaders; import io.netty.handler.codec.http.HttpHeaders;
import org.junit.Test; import org.junit.jupiter.api.Test;
import java.net.URI; import java.net.URI;
import static org.junit.Assert.assertEquals; import static org.junit.jupiter.api.Assertions.assertEquals;
public class WebSocketClientHandshaker07Test extends WebSocketClientHandshakerTest { public class WebSocketClientHandshaker07Test extends WebSocketClientHandshakerTest {

15
codec-http/src/test/java/io/netty/handler/codec/http/websocketx/WebSocketClientHandshakerTest.java
View File

@ -35,12 +35,15 @@ import io.netty.handler.codec.http.HttpResponseDecoder;
import io.netty.handler.codec.http.HttpResponseStatus; import io.netty.handler.codec.http.HttpResponseStatus;
import io.netty.handler.codec.http.HttpVersion; import io.netty.handler.codec.http.HttpVersion;
import io.netty.util.CharsetUtil; import io.netty.util.CharsetUtil;
import org.junit.jupiter.api.Test;
import org.junit.Test; import org.junit.jupiter.api.Timeout;
import java.net.URI; import java.net.URI;
import java.util.concurrent.TimeUnit;
import static org.junit.Assert.*; import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
public abstract class WebSocketClientHandshakerTest { public abstract class WebSocketClientHandshakerTest {
protected abstract WebSocketClientHandshaker newHandshaker(URI uri, String subprotocol, HttpHeaders headers, protected abstract WebSocketClientHandshaker newHandshaker(URI uri, String subprotocol, HttpHeaders headers,
@ -256,12 +259,14 @@ public abstract class WebSocketClientHandshakerTest {
} }
} }
@Test(timeout = 3000) @Test
@Timeout(value = 3000, unit = TimeUnit.MILLISECONDS)
public void testHttpResponseAndFrameInSameBuffer() { public void testHttpResponseAndFrameInSameBuffer() {
testHttpResponseAndFrameInSameBuffer(false); testHttpResponseAndFrameInSameBuffer(false);
} }
@Test(timeout = 3000) @Test
@Timeout(value = 3000, unit = TimeUnit.MILLISECONDS)
public void testHttpResponseAndFrameInSameBufferCodec() { public void testHttpResponseAndFrameInSameBufferCodec() {
testHttpResponseAndFrameInSameBuffer(true); testHttpResponseAndFrameInSameBuffer(true);
} }

8
codec-http/src/test/java/io/netty/handler/codec/http/websocketx/WebSocketCloseStatusTest.java
View File

@ -20,13 +20,13 @@ import java.util.TreeSet;
import org.assertj.core.api.ThrowableAssert; import org.assertj.core.api.ThrowableAssert;
import org.hamcrest.Matchers; import org.hamcrest.Matchers;
import org.junit.Test; import org.junit.jupiter.api.Test;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType; import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals; import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.Assert.assertNotSame; import static org.junit.jupiter.api.Assertions.assertNotSame;
import static org.junit.Assert.assertSame; import static org.junit.jupiter.api.Assertions.assertSame;
import static io.netty.handler.codec.http.websocketx.WebSocketCloseStatus.*; import static io.netty.handler.codec.http.websocketx.WebSocketCloseStatus.*;

69
codec-http/src/test/java/io/netty/handler/codec/http/websocketx/WebSocketFrameAggregatorTest.java
View File

@ -21,8 +21,13 @@ import io.netty.channel.embedded.EmbeddedChannel;
import io.netty.handler.codec.TooLongFrameException; import io.netty.handler.codec.TooLongFrameException;
import io.netty.util.CharsetUtil; import io.netty.util.CharsetUtil;
import io.netty.util.ReferenceCountUtil; import io.netty.util.ReferenceCountUtil;
import org.junit.Assert; import org.junit.jupiter.api.Test;
import org.junit.Test;
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
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 static org.junit.jupiter.api.Assertions.fail;
public class WebSocketFrameAggregatorTest { public class WebSocketFrameAggregatorTest {
@ -46,29 +51,29 @@ public class WebSocketFrameAggregatorTest {
channel.writeInbound(new PongWebSocketFrame(Unpooled.wrappedBuffer(content1))); channel.writeInbound(new PongWebSocketFrame(Unpooled.wrappedBuffer(content1)));
channel.writeInbound(new ContinuationWebSocketFrame(true, 0, Unpooled.wrappedBuffer(content3))); channel.writeInbound(new ContinuationWebSocketFrame(true, 0, Unpooled.wrappedBuffer(content3)));
Assert.assertTrue(channel.finish()); assertTrue(channel.finish());
BinaryWebSocketFrame frame = channel.readInbound(); BinaryWebSocketFrame frame = channel.readInbound();
Assert.assertTrue(frame.isFinalFragment()); assertTrue(frame.isFinalFragment());
Assert.assertEquals(1, frame.rsv()); assertEquals(1, frame.rsv());
Assert.assertArrayEquals(content1, toBytes(frame.content())); assertArrayEquals(content1, toBytes(frame.content()));
PingWebSocketFrame frame2 = channel.readInbound(); PingWebSocketFrame frame2 = channel.readInbound();
Assert.assertTrue(frame2.isFinalFragment()); assertTrue(frame2.isFinalFragment());
Assert.assertEquals(0, frame2.rsv()); assertEquals(0, frame2.rsv());
Assert.assertArrayEquals(content1, toBytes(frame2.content())); assertArrayEquals(content1, toBytes(frame2.content()));
PongWebSocketFrame frame3 = channel.readInbound(); PongWebSocketFrame frame3 = channel.readInbound();
Assert.assertTrue(frame3.isFinalFragment()); assertTrue(frame3.isFinalFragment());
Assert.assertEquals(0, frame3.rsv()); assertEquals(0, frame3.rsv());
Assert.assertArrayEquals(content1, toBytes(frame3.content())); assertArrayEquals(content1, toBytes(frame3.content()));
BinaryWebSocketFrame frame4 = channel.readInbound(); BinaryWebSocketFrame frame4 = channel.readInbound();
Assert.assertTrue(frame4.isFinalFragment()); assertTrue(frame4.isFinalFragment());
Assert.assertEquals(0, frame4.rsv()); assertEquals(0, frame4.rsv());
Assert.assertArrayEquals(aggregatedContent, toBytes(frame4.content())); assertArrayEquals(aggregatedContent, toBytes(frame4.content()));
Assert.assertNull(channel.readInbound()); assertNull(channel.readInbound());
} }
@Test @Test
@ -81,29 +86,29 @@ public class WebSocketFrameAggregatorTest {
channel.writeInbound(new PongWebSocketFrame(Unpooled.wrappedBuffer(content1))); channel.writeInbound(new PongWebSocketFrame(Unpooled.wrappedBuffer(content1)));
channel.writeInbound(new ContinuationWebSocketFrame(true, 0, Unpooled.wrappedBuffer(content3))); channel.writeInbound(new ContinuationWebSocketFrame(true, 0, Unpooled.wrappedBuffer(content3)));
Assert.assertTrue(channel.finish()); assertTrue(channel.finish());
TextWebSocketFrame frame = channel.readInbound(); TextWebSocketFrame frame = channel.readInbound();
Assert.assertTrue(frame.isFinalFragment()); assertTrue(frame.isFinalFragment());
Assert.assertEquals(1, frame.rsv()); assertEquals(1, frame.rsv());
Assert.assertArrayEquals(content1, toBytes(frame.content())); assertArrayEquals(content1, toBytes(frame.content()));
PingWebSocketFrame frame2 = channel.readInbound(); PingWebSocketFrame frame2 = channel.readInbound();
Assert.assertTrue(frame2.isFinalFragment()); assertTrue(frame2.isFinalFragment());
Assert.assertEquals(0, frame2.rsv()); assertEquals(0, frame2.rsv());
Assert.assertArrayEquals(content1, toBytes(frame2.content())); assertArrayEquals(content1, toBytes(frame2.content()));
PongWebSocketFrame frame3 = channel.readInbound(); PongWebSocketFrame frame3 = channel.readInbound();
Assert.assertTrue(frame3.isFinalFragment()); assertTrue(frame3.isFinalFragment());
Assert.assertEquals(0, frame3.rsv()); assertEquals(0, frame3.rsv());
Assert.assertArrayEquals(content1, toBytes(frame3.content())); assertArrayEquals(content1, toBytes(frame3.content()));
TextWebSocketFrame frame4 = channel.readInbound(); TextWebSocketFrame frame4 = channel.readInbound();
Assert.assertTrue(frame4.isFinalFragment()); assertTrue(frame4.isFinalFragment());
Assert.assertEquals(0, frame4.rsv()); assertEquals(0, frame4.rsv());
Assert.assertArrayEquals(aggregatedContent, toBytes(frame4.content())); assertArrayEquals(aggregatedContent, toBytes(frame4.content()));
Assert.assertNull(channel.readInbound()); assertNull(channel.readInbound());
} }
@Test @Test
@ -113,7 +118,7 @@ public class WebSocketFrameAggregatorTest {
channel.writeInbound(new BinaryWebSocketFrame(false, 0, Unpooled.wrappedBuffer(content1))); channel.writeInbound(new BinaryWebSocketFrame(false, 0, Unpooled.wrappedBuffer(content1)));
try { try {
channel.writeInbound(new ContinuationWebSocketFrame(false, 0, Unpooled.wrappedBuffer(content2))); channel.writeInbound(new ContinuationWebSocketFrame(false, 0, Unpooled.wrappedBuffer(content2)));
Assert.fail(); fail();
} catch (TooLongFrameException e) { } catch (TooLongFrameException e) {
// expected // expected
} }
@ -124,7 +129,7 @@ public class WebSocketFrameAggregatorTest {
channel.writeInbound(new BinaryWebSocketFrame(false, 0, Unpooled.wrappedBuffer(content1))); channel.writeInbound(new BinaryWebSocketFrame(false, 0, Unpooled.wrappedBuffer(content1)));
try { try {
channel.writeInbound(new ContinuationWebSocketFrame(false, 0, Unpooled.wrappedBuffer(content2))); channel.writeInbound(new ContinuationWebSocketFrame(false, 0, Unpooled.wrappedBuffer(content2)));
Assert.fail(); fail();
} catch (TooLongFrameException e) { } catch (TooLongFrameException e) {
// expected // expected
} }

6
codec-http/src/test/java/io/netty/handler/codec/http/websocketx/WebSocketHandshakeExceptionTest.java
View File

@ -22,9 +22,11 @@ import io.netty.handler.codec.http.HttpRequest;
import io.netty.handler.codec.http.HttpResponse; import io.netty.handler.codec.http.HttpResponse;
import io.netty.handler.codec.http.HttpResponseStatus; import io.netty.handler.codec.http.HttpResponseStatus;
import io.netty.handler.codec.http.HttpVersion; import io.netty.handler.codec.http.HttpVersion;
import org.junit.Test; import org.junit.jupiter.api.Test;
import static org.junit.Assert.*; import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;
public class WebSocketHandshakeExceptionTest { public class WebSocketHandshakeExceptionTest {

29
codec-http/src/test/java/io/netty/handler/codec/http/websocketx/WebSocketHandshakeHandOverTest.java
View File

@ -29,13 +29,20 @@ import io.netty.handler.codec.http.HttpObjectAggregator;
import io.netty.handler.codec.http.HttpServerCodec; import io.netty.handler.codec.http.HttpServerCodec;
import io.netty.handler.codec.http.websocketx.WebSocketClientProtocolHandler.ClientHandshakeStateEvent; import io.netty.handler.codec.http.websocketx.WebSocketClientProtocolHandler.ClientHandshakeStateEvent;
import io.netty.handler.codec.http.websocketx.WebSocketServerProtocolHandler.ServerHandshakeStateEvent; import io.netty.handler.codec.http.websocketx.WebSocketServerProtocolHandler.ServerHandshakeStateEvent;
import org.junit.Before; import java.util.concurrent.TimeUnit;
import org.junit.Test; import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import java.net.URI; import java.net.URI;
import java.util.List; import java.util.List;
import org.junit.jupiter.api.Timeout;
import org.junit.jupiter.api.function.Executable;
import static org.junit.Assert.*; 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.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
public class WebSocketHandshakeHandOverTest { public class WebSocketHandshakeHandOverTest {
@ -66,7 +73,7 @@ public class WebSocketHandshakeHandOverTest {
} }
} }
@Before @BeforeEach
public void setUp() { public void setUp() {
serverReceivedHandshake = false; serverReceivedHandshake = false;
serverHandshakeComplete = null; serverHandshakeComplete = null;
@ -124,8 +131,8 @@ public class WebSocketHandshakeHandOverTest {
assertTrue(clientReceivedMessage); assertTrue(clientReceivedMessage);
} }
@Test(expected = WebSocketHandshakeException.class) @Test
public void testClientHandshakeTimeout() throws Exception { public void testClientHandshakeTimeout() throws Throwable {
EmbeddedChannel serverChannel = createServerChannel(new SimpleChannelInboundHandler<Object>() { EmbeddedChannel serverChannel = createServerChannel(new SimpleChannelInboundHandler<Object>() {
@Override @Override
public void userEventTriggered(ChannelHandlerContext ctx, Object evt) { public void userEventTriggered(ChannelHandlerContext ctx, Object evt) {
@ -164,7 +171,7 @@ public class WebSocketHandshakeHandOverTest {
transferAllDataWithMerge(clientChannel, serverChannel); transferAllDataWithMerge(clientChannel, serverChannel);
// Server do not send the response back // Server do not send the response back
// transferAllDataWithMerge(serverChannel, clientChannel); // transferAllDataWithMerge(serverChannel, clientChannel);
WebSocketClientProtocolHandshakeHandler handshakeHandler = final WebSocketClientProtocolHandshakeHandler handshakeHandler =
(WebSocketClientProtocolHandshakeHandler) clientChannel (WebSocketClientProtocolHandshakeHandler) clientChannel
.pipeline().get(WebSocketClientProtocolHandshakeHandler.class.getName()); .pipeline().get(WebSocketClientProtocolHandshakeHandler.class.getName());
@ -178,7 +185,12 @@ public class WebSocketHandshakeHandOverTest {
assertFalse(clientReceivedMessage); assertFalse(clientReceivedMessage);
// Should throw WebSocketHandshakeException // Should throw WebSocketHandshakeException
try { try {
assertThrows(WebSocketHandshakeException.class, new Executable() {
@Override
public void execute() {
handshakeHandler.getHandshakeFuture().syncUninterruptibly(); handshakeHandler.getHandshakeFuture().syncUninterruptibly();
}
});
} finally { } finally {
serverChannel.finishAndReleaseAll(); serverChannel.finishAndReleaseAll();
} }
@ -218,7 +230,8 @@ public class WebSocketHandshakeHandOverTest {
} }
} }
@Test(timeout = 10000) @Test
@Timeout(value = 10000, unit = TimeUnit.MILLISECONDS)
public void testClientHandshakerForceClose() throws Exception { public void testClientHandshakerForceClose() throws Exception {
final WebSocketClientHandshaker handshaker = WebSocketClientHandshakerFactory.newHandshaker( final WebSocketClientHandshaker handshaker = WebSocketClientHandshakerFactory.newHandshaker(
new URI("ws://localhost:1234/test"), WebSocketVersion.V13, null, true, new URI("ws://localhost:1234/test"), WebSocketVersion.V13, null, true,

7
codec-http/src/test/java/io/netty/handler/codec/http/websocketx/WebSocketProtocolHandlerTest.java
View File

@ -26,13 +26,16 @@ import io.netty.channel.embedded.EmbeddedChannel;
import io.netty.handler.flow.FlowControlHandler; import io.netty.handler.flow.FlowControlHandler;
import io.netty.util.ReferenceCountUtil; import io.netty.util.ReferenceCountUtil;
import org.hamcrest.Matchers; import org.hamcrest.Matchers;
import org.junit.Test; import org.junit.jupiter.api.Test;
import java.util.concurrent.atomic.AtomicReference; import java.util.concurrent.atomic.AtomicReference;
import static io.netty.util.CharsetUtil.UTF_8; import static io.netty.util.CharsetUtil.UTF_8;
import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.*; 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;
/** /**
* Tests common, abstract class functionality in {@link WebSocketClientProtocolHandler}. * Tests common, abstract class functionality in {@link WebSocketClientProtocolHandler}.

16
codec-http/src/test/java/io/netty/handler/codec/http/websocketx/WebSocketServerHandshaker00Test.java
View File

@ -29,12 +29,12 @@ import io.netty.handler.codec.http.HttpResponseDecoder;
import io.netty.handler.codec.http.HttpResponseEncoder; import io.netty.handler.codec.http.HttpResponseEncoder;
import io.netty.handler.codec.http.LastHttpContent; import io.netty.handler.codec.http.LastHttpContent;
import io.netty.util.CharsetUtil; import io.netty.util.CharsetUtil;
import org.junit.Assert; import org.junit.jupiter.api.Test;
import org.junit.Test;
import static io.netty.handler.codec.http.HttpVersion.HTTP_1_1; import static io.netty.handler.codec.http.HttpVersion.HTTP_1_1;
import static org.junit.Assert.assertEquals; import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.Assert.fail; import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.fail;
public class WebSocketServerHandshaker00Test extends WebSocketServerHandshakerTest { public class WebSocketServerHandshaker00Test extends WebSocketServerHandshakerTest {
@ -114,16 +114,16 @@ public class WebSocketServerHandshaker00Test extends WebSocketServerHandshakerTe
ch2.writeInbound(ch.readOutbound()); ch2.writeInbound(ch.readOutbound());
HttpResponse res = ch2.readInbound(); HttpResponse res = ch2.readInbound();
Assert.assertEquals("ws://example.com/chat", res.headers().get(HttpHeaderNames.SEC_WEBSOCKET_LOCATION)); assertEquals("ws://example.com/chat", res.headers().get(HttpHeaderNames.SEC_WEBSOCKET_LOCATION));
if (subProtocol) { if (subProtocol) {
Assert.assertEquals("chat", res.headers().get(HttpHeaderNames.SEC_WEBSOCKET_PROTOCOL)); assertEquals("chat", res.headers().get(HttpHeaderNames.SEC_WEBSOCKET_PROTOCOL));
} else { } else {
Assert.assertNull(res.headers().get(HttpHeaderNames.SEC_WEBSOCKET_PROTOCOL)); assertNull(res.headers().get(HttpHeaderNames.SEC_WEBSOCKET_PROTOCOL));
} }
LastHttpContent content = ch2.readInbound(); LastHttpContent content = ch2.readInbound();
Assert.assertEquals("8jKS'y:G*Co,Wxa-", content.content().toString(CharsetUtil.US_ASCII)); assertEquals("8jKS'y:G*Co,Wxa-", content.content().toString(CharsetUtil.US_ASCII));
content.release(); content.release();
req.release(); req.release();
} }

11
codec-http/src/test/java/io/netty/handler/codec/http/websocketx/WebSocketServerHandshaker08Test.java
View File

@ -28,10 +28,11 @@ import io.netty.handler.codec.http.HttpResponse;
import io.netty.handler.codec.http.HttpResponseDecoder; import io.netty.handler.codec.http.HttpResponseDecoder;
import io.netty.handler.codec.http.HttpResponseEncoder; import io.netty.handler.codec.http.HttpResponseEncoder;
import io.netty.util.ReferenceCountUtil; import io.netty.util.ReferenceCountUtil;
import org.junit.Assert; import org.junit.jupiter.api.Test;
import org.junit.Test;
import static io.netty.handler.codec.http.HttpVersion.*; import static io.netty.handler.codec.http.HttpVersion.*;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNull;
public class WebSocketServerHandshaker08Test extends WebSocketServerHandshakerTest { public class WebSocketServerHandshaker08Test extends WebSocketServerHandshakerTest {
@ -83,12 +84,12 @@ public class WebSocketServerHandshaker08Test extends WebSocketServerHandshakerTe
ch2.writeInbound(resBuf); ch2.writeInbound(resBuf);
HttpResponse res = ch2.readInbound(); HttpResponse res = ch2.readInbound();
Assert.assertEquals( assertEquals(
"s3pPLMBiTxaQ9kYGzzhZRbK+xOo=", res.headers().get(HttpHeaderNames.SEC_WEBSOCKET_ACCEPT)); "s3pPLMBiTxaQ9kYGzzhZRbK+xOo=", res.headers().get(HttpHeaderNames.SEC_WEBSOCKET_ACCEPT));
if (subProtocol) { if (subProtocol) {
Assert.assertEquals("chat", res.headers().get(HttpHeaderNames.SEC_WEBSOCKET_PROTOCOL)); assertEquals("chat", res.headers().get(HttpHeaderNames.SEC_WEBSOCKET_PROTOCOL));
} else { } else {
Assert.assertNull(res.headers().get(HttpHeaderNames.SEC_WEBSOCKET_PROTOCOL)); assertNull(res.headers().get(HttpHeaderNames.SEC_WEBSOCKET_PROTOCOL));
} }
ReferenceCountUtil.release(res); ReferenceCountUtil.release(res);
req.release(); req.release();

10
codec-http/src/test/java/io/netty/handler/codec/http/websocketx/WebSocketServerHandshaker13Test.java
View File

@ -33,16 +33,16 @@ import io.netty.handler.codec.http.HttpServerCodec;
import io.netty.util.ReferenceCountUtil; import io.netty.util.ReferenceCountUtil;
import io.netty.util.ReferenceCounted; import io.netty.util.ReferenceCounted;
import org.hamcrest.CoreMatchers; import org.hamcrest.CoreMatchers;
import org.junit.Test; import org.junit.jupiter.api.Test;
import java.util.Iterator; import java.util.Iterator;
import static io.netty.handler.codec.http.HttpVersion.*; import static io.netty.handler.codec.http.HttpVersion.*;
import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals; import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.Assert.assertFalse; import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.Assert.assertNull; import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.Assert.fail; import static org.junit.jupiter.api.Assertions.fail;
public class WebSocketServerHandshaker13Test extends WebSocketServerHandshakerTest { public class WebSocketServerHandshaker13Test extends WebSocketServerHandshakerTest {

7
codec-http/src/test/java/io/netty/handler/codec/http/websocketx/WebSocketServerHandshakerFactoryTest.java
View File

@ -22,9 +22,12 @@ import io.netty.handler.codec.http.HttpHeaderNames;
import io.netty.handler.codec.http.HttpUtil; import io.netty.handler.codec.http.HttpUtil;
import io.netty.handler.codec.http.HttpResponseStatus; import io.netty.handler.codec.http.HttpResponseStatus;
import io.netty.util.ReferenceCountUtil; import io.netty.util.ReferenceCountUtil;
import org.junit.Test; import org.junit.jupiter.api.Test;
import static org.junit.Assert.*; 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 static org.junit.jupiter.api.Assertions.fail;
public class WebSocketServerHandshakerFactoryTest { public class WebSocketServerHandshakerFactoryTest {

7
codec-http/src/test/java/io/netty/handler/codec/http/websocketx/WebSocketServerHandshakerTest.java
View File

@ -24,9 +24,12 @@ import io.netty.handler.codec.http.HttpHeaderValues;
import io.netty.handler.codec.http.HttpHeaders; import io.netty.handler.codec.http.HttpHeaders;
import io.netty.handler.codec.http.HttpMethod; import io.netty.handler.codec.http.HttpMethod;
import io.netty.handler.codec.http.HttpVersion; import io.netty.handler.codec.http.HttpVersion;
import org.junit.Test; import org.junit.jupiter.api.Test;
import static org.junit.Assert.*; 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;
public abstract class WebSocketServerHandshakerTest { public abstract class WebSocketServerHandshakerTest {

12
codec-http/src/test/java/io/netty/handler/codec/http/websocketx/WebSocketServerProtocolHandlerTest.java
View File

@ -36,21 +36,25 @@ import io.netty.handler.codec.http.HttpServerCodec;
import io.netty.handler.codec.http.HttpHeaderNames; import io.netty.handler.codec.http.HttpHeaderNames;
import io.netty.util.CharsetUtil; import io.netty.util.CharsetUtil;
import io.netty.util.ReferenceCountUtil; import io.netty.util.ReferenceCountUtil;
import org.junit.Before; import org.junit.jupiter.api.BeforeEach;
import org.junit.Test; import org.junit.jupiter.api.Test;
import java.util.ArrayDeque; import java.util.ArrayDeque;
import java.util.Queue; import java.util.Queue;
import static io.netty.handler.codec.http.HttpResponseStatus.*; import static io.netty.handler.codec.http.HttpResponseStatus.*;
import static io.netty.handler.codec.http.HttpVersion.*; import static io.netty.handler.codec.http.HttpVersion.*;
import static org.junit.Assert.*; 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.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
public class WebSocketServerProtocolHandlerTest { public class WebSocketServerProtocolHandlerTest {
private final Queue<FullHttpResponse> responses = new ArrayDeque<FullHttpResponse>(); private final Queue<FullHttpResponse> responses = new ArrayDeque<FullHttpResponse>();
@Before @BeforeEach
public void setUp() { public void setUp() {
responses.clear(); responses.clear();
} }

22
codec-http/src/test/java/io/netty/handler/codec/http/websocketx/WebSocketUtf8FrameValidatorTest.java
View File

@ -19,8 +19,14 @@ import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled; import io.netty.buffer.Unpooled;
import io.netty.channel.embedded.EmbeddedChannel; import io.netty.channel.embedded.EmbeddedChannel;
import io.netty.handler.codec.CorruptedFrameException; import io.netty.handler.codec.CorruptedFrameException;
import org.junit.Assert; import org.junit.jupiter.api.Test;
import org.junit.Test;
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.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.Assertions.fail;
public class WebSocketUtf8FrameValidatorTest { public class WebSocketUtf8FrameValidatorTest {
@ -39,19 +45,19 @@ public class WebSocketUtf8FrameValidatorTest {
TextWebSocketFrame frame = new TextWebSocketFrame(Unpooled.copiedBuffer(data)); TextWebSocketFrame frame = new TextWebSocketFrame(Unpooled.copiedBuffer(data));
try { try {
channel.writeInbound(frame); channel.writeInbound(frame);
Assert.fail(); fail();
} catch (CorruptedFrameException e) { } catch (CorruptedFrameException e) {
// expected exception // expected exception
} }
Assert.assertTrue(channel.finish()); assertTrue(channel.finish());
ByteBuf buf = channel.readOutbound(); ByteBuf buf = channel.readOutbound();
Assert.assertNotNull(buf); assertNotNull(buf);
try { try {
Assert.assertFalse(buf.isReadable()); assertFalse(buf.isReadable());
} finally { } finally {
buf.release(); buf.release();
} }
Assert.assertNull(channel.readOutbound()); assertNull(channel.readOutbound());
Assert.assertEquals(0, frame.refCnt()); assertEquals(0, frame.refCnt());
} }
} }

8
codec-http/src/test/java/io/netty/handler/codec/http/websocketx/WebSocketUtilTest.java
View File

@ -15,7 +15,7 @@
*/ */
package io.netty.handler.codec.http.websocketx; package io.netty.handler.codec.http.websocketx;
import org.junit.Test; import org.junit.jupiter.api.Test;
import io.netty.buffer.ByteBuf; import io.netty.buffer.ByteBuf;
import io.netty.buffer.ByteBufUtil; import io.netty.buffer.ByteBufUtil;
@ -24,9 +24,9 @@ import io.netty.handler.codec.base64.Base64;
import io.netty.util.CharsetUtil; import io.netty.util.CharsetUtil;
import io.netty.util.internal.EmptyArrays; import io.netty.util.internal.EmptyArrays;
import static org.junit.Assert.assertEquals; import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.Assert.assertNotNull; import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.Assert.assertTrue; import static org.junit.jupiter.api.Assertions.assertTrue;
public class WebSocketUtilTest { public class WebSocketUtilTest {

14
codec-http/src/test/java/io/netty/handler/codec/http/websocketx/extensions/WebSocketClientExtensionHandlerTest.java
View File

@ -24,10 +24,13 @@ import io.netty.handler.codec.http.HttpResponse;
import java.util.Collections; import java.util.Collections;
import java.util.List; import java.util.List;
import org.junit.Test; import org.junit.jupiter.api.Test;
import static io.netty.handler.codec.http.websocketx.extensions.WebSocketExtensionTestUtil.*; import static io.netty.handler.codec.http.websocketx.extensions.WebSocketExtensionTestUtil.*;
import static org.junit.Assert.*; 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 static org.junit.jupiter.api.Assertions.fail;
import static org.mockito.Mockito.any; import static org.mockito.Mockito.any;
import static org.mockito.Mockito.atLeastOnce; import static org.mockito.Mockito.atLeastOnce;
import static org.mockito.Mockito.mock; import static org.mockito.Mockito.mock;
@ -218,7 +221,7 @@ public class WebSocketClientExtensionHandlerTest {
verify(fallbackExtensionMock).newExtensionDecoder(); verify(fallbackExtensionMock).newExtensionDecoder();
} }
@Test(expected = CodecException.class) @Test
public void testIfMainAndFallbackUseRSV1WillFail() { public void testIfMainAndFallbackUseRSV1WillFail() {
// initialize // initialize
when(mainHandshakerMock.newRequestData()). when(mainHandshakerMock.newRequestData()).
@ -248,7 +251,12 @@ public class WebSocketClientExtensionHandlerTest {
req2.headers().get(HttpHeaderNames.SEC_WEBSOCKET_EXTENSIONS)); req2.headers().get(HttpHeaderNames.SEC_WEBSOCKET_EXTENSIONS));
HttpResponse res = newUpgradeResponse("main, fallback"); HttpResponse res = newUpgradeResponse("main, fallback");
try {
ch.writeInbound(res); ch.writeInbound(res);
} catch (CodecException e) {
return;
}
fail("Expected to encounter a CodecException");
// test // test
assertEquals(2, reqExts.size()); assertEquals(2, reqExts.size());

5
codec-http/src/test/java/io/netty/handler/codec/http/websocketx/extensions/WebSocketExtensionFilterProviderTest.java
View File

@ -15,9 +15,10 @@
*/ */
package io.netty.handler.codec.http.websocketx.extensions; package io.netty.handler.codec.http.websocketx.extensions;
import org.junit.Test; import org.junit.jupiter.api.Test;
import static org.junit.Assert.*; import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
public class WebSocketExtensionFilterProviderTest { public class WebSocketExtensionFilterProviderTest {

5
codec-http/src/test/java/io/netty/handler/codec/http/websocketx/extensions/WebSocketExtensionFilterTest.java
View File

@ -21,9 +21,10 @@ import io.netty.handler.codec.http.websocketx.ContinuationWebSocketFrame;
import io.netty.handler.codec.http.websocketx.PingWebSocketFrame; import io.netty.handler.codec.http.websocketx.PingWebSocketFrame;
import io.netty.handler.codec.http.websocketx.PongWebSocketFrame; import io.netty.handler.codec.http.websocketx.PongWebSocketFrame;
import io.netty.handler.codec.http.websocketx.TextWebSocketFrame; import io.netty.handler.codec.http.websocketx.TextWebSocketFrame;
import org.junit.Test; import org.junit.jupiter.api.Test;
import static org.junit.Assert.*; import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
public class WebSocketExtensionFilterTest { public class WebSocketExtensionFilterTest {

6
codec-http/src/test/java/io/netty/handler/codec/http/websocketx/extensions/WebSocketExtensionUtilTest.java
View File

@ -19,12 +19,14 @@ import io.netty.handler.codec.http.DefaultHttpHeaders;
import io.netty.handler.codec.http.HttpHeaderNames; import io.netty.handler.codec.http.HttpHeaderNames;
import io.netty.handler.codec.http.HttpHeaderValues; import io.netty.handler.codec.http.HttpHeaderValues;
import io.netty.handler.codec.http.HttpHeaders; import io.netty.handler.codec.http.HttpHeaders;
import org.junit.Test; import org.junit.jupiter.api.Test;
import java.util.List; import java.util.List;
import static org.junit.Assert.*;
import static io.netty.handler.codec.http.websocketx.extensions.WebSocketExtensionUtil.*; import static io.netty.handler.codec.http.websocketx.extensions.WebSocketExtensionUtil.*;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
public class WebSocketExtensionUtilTest { public class WebSocketExtensionUtilTest {

8
codec-http/src/test/java/io/netty/handler/codec/http/websocketx/extensions/WebSocketServerExtensionHandlerTest.java
View File

@ -25,10 +25,14 @@ import java.io.IOException;
import java.util.Collections; import java.util.Collections;
import java.util.List; import java.util.List;
import org.junit.Test; import org.junit.jupiter.api.Test;
import static io.netty.handler.codec.http.websocketx.extensions.WebSocketExtensionTestUtil.*; import static io.netty.handler.codec.http.websocketx.extensions.WebSocketExtensionTestUtil.*;
import static org.junit.Assert.*; 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.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.Mockito.*; import static org.mockito.Mockito.*;
public class WebSocketServerExtensionHandlerTest { public class WebSocketServerExtensionHandlerTest {

8
codec-http/src/test/java/io/netty/handler/codec/http/websocketx/extensions/compression/DeflateFrameClientExtensionHandshakerTest.java
View File

@ -17,7 +17,11 @@ package io.netty.handler.codec.http.websocketx.extensions.compression;
import static io.netty.handler.codec.http.websocketx.extensions.compression. import static io.netty.handler.codec.http.websocketx.extensions.compression.
DeflateFrameServerExtensionHandshaker.*; DeflateFrameServerExtensionHandshaker.*;
import static org.junit.Assert.*; 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 io.netty.handler.codec.http.websocketx.extensions.WebSocketClientExtension; import io.netty.handler.codec.http.websocketx.extensions.WebSocketClientExtension;
import io.netty.handler.codec.http.websocketx.extensions.WebSocketExtensionData; import io.netty.handler.codec.http.websocketx.extensions.WebSocketExtensionData;
@ -25,7 +29,7 @@ import java.util.Collections;
import java.util.HashMap; import java.util.HashMap;
import java.util.Map; import java.util.Map;
import org.junit.Test; import org.junit.jupiter.api.Test;
public class DeflateFrameClientExtensionHandshakerTest { public class DeflateFrameClientExtensionHandshakerTest {

8
codec-http/src/test/java/io/netty/handler/codec/http/websocketx/extensions/compression/DeflateFrameServerExtensionHandshakerTest.java
View File

@ -17,7 +17,11 @@ package io.netty.handler.codec.http.websocketx.extensions.compression;
import static io.netty.handler.codec.http.websocketx.extensions.compression. import static io.netty.handler.codec.http.websocketx.extensions.compression.
DeflateFrameServerExtensionHandshaker.*; DeflateFrameServerExtensionHandshaker.*;
import static org.junit.Assert.*; 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 io.netty.handler.codec.http.websocketx.extensions.WebSocketServerExtension; import io.netty.handler.codec.http.websocketx.extensions.WebSocketServerExtension;
import io.netty.handler.codec.http.websocketx.extensions.WebSocketExtensionData; import io.netty.handler.codec.http.websocketx.extensions.WebSocketExtensionData;
@ -25,7 +29,7 @@ import java.util.Collections;
import java.util.HashMap; import java.util.HashMap;
import java.util.Map; import java.util.Map;
import org.junit.Test; import org.junit.jupiter.api.Test;
public class DeflateFrameServerExtensionHandshakerTest { public class DeflateFrameServerExtensionHandshakerTest {

8
codec-http/src/test/java/io/netty/handler/codec/http/websocketx/extensions/compression/PerFrameDeflateDecoderTest.java
View File

@ -22,13 +22,17 @@ import io.netty.handler.codec.compression.ZlibCodecFactory;
import io.netty.handler.codec.compression.ZlibWrapper; import io.netty.handler.codec.compression.ZlibWrapper;
import io.netty.handler.codec.http.websocketx.BinaryWebSocketFrame; import io.netty.handler.codec.http.websocketx.BinaryWebSocketFrame;
import io.netty.handler.codec.http.websocketx.extensions.WebSocketExtension; import io.netty.handler.codec.http.websocketx.extensions.WebSocketExtension;
import org.junit.Test; import org.junit.jupiter.api.Test;
import java.util.Random; import java.util.Random;
import static io.netty.handler.codec.http.websocketx.extensions.WebSocketExtension.*; import static io.netty.handler.codec.http.websocketx.extensions.WebSocketExtension.*;
import static io.netty.handler.codec.http.websocketx.extensions.WebSocketExtensionFilter.*; import static io.netty.handler.codec.http.websocketx.extensions.WebSocketExtensionFilter.*;
import static org.junit.Assert.*; import static org.junit.jupiter.api.Assertions.assertArrayEquals;
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;
public class PerFrameDeflateDecoderTest { public class PerFrameDeflateDecoderTest {

8
codec-http/src/test/java/io/netty/handler/codec/http/websocketx/extensions/compression/PerFrameDeflateEncoderTest.java
View File

@ -24,12 +24,16 @@ import io.netty.handler.codec.compression.ZlibWrapper;
import io.netty.handler.codec.http.websocketx.BinaryWebSocketFrame; import io.netty.handler.codec.http.websocketx.BinaryWebSocketFrame;
import io.netty.handler.codec.http.websocketx.ContinuationWebSocketFrame; import io.netty.handler.codec.http.websocketx.ContinuationWebSocketFrame;
import io.netty.handler.codec.http.websocketx.extensions.WebSocketExtension; import io.netty.handler.codec.http.websocketx.extensions.WebSocketExtension;
import org.junit.Test; import org.junit.jupiter.api.Test;
import java.util.Random; import java.util.Random;
import static io.netty.handler.codec.http.websocketx.extensions.WebSocketExtensionFilter.*; import static io.netty.handler.codec.http.websocketx.extensions.WebSocketExtensionFilter.*;
import static org.junit.Assert.*; import static org.junit.jupiter.api.Assertions.assertArrayEquals;
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;
public class PerFrameDeflateEncoderTest { public class PerFrameDeflateEncoderTest {

8
codec-http/src/test/java/io/netty/handler/codec/http/websocketx/extensions/compression/PerMessageDeflateClientExtensionHandshakerTest.java
View File

@ -18,7 +18,11 @@ package io.netty.handler.codec.http.websocketx.extensions.compression;
import static io.netty.handler.codec.http.websocketx.extensions.WebSocketExtension.RSV1; import static io.netty.handler.codec.http.websocketx.extensions.WebSocketExtension.RSV1;
import static io.netty.handler.codec.http.websocketx.extensions.compression. import static io.netty.handler.codec.http.websocketx.extensions.compression.
PerMessageDeflateServerExtensionHandshaker.*; PerMessageDeflateServerExtensionHandshaker.*;
import static org.junit.Assert.*; 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.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import io.netty.buffer.Unpooled; import io.netty.buffer.Unpooled;
import io.netty.channel.embedded.EmbeddedChannel; import io.netty.channel.embedded.EmbeddedChannel;
@ -31,7 +35,7 @@ import java.util.Collections;
import java.util.HashMap; import java.util.HashMap;
import java.util.Map; import java.util.Map;
import org.junit.Test; import org.junit.jupiter.api.Test;
public class PerMessageDeflateClientExtensionHandshakerTest { public class PerMessageDeflateClientExtensionHandshakerTest {

21
codec-http/src/test/java/io/netty/handler/codec/http/websocketx/extensions/compression/PerMessageDeflateDecoderTest.java
View File

@ -28,14 +28,20 @@ import io.netty.handler.codec.http.websocketx.TextWebSocketFrame;
import io.netty.handler.codec.http.websocketx.WebSocketFrame; import io.netty.handler.codec.http.websocketx.WebSocketFrame;
import io.netty.handler.codec.http.websocketx.extensions.WebSocketExtension; import io.netty.handler.codec.http.websocketx.extensions.WebSocketExtension;
import io.netty.handler.codec.http.websocketx.extensions.WebSocketExtensionFilter; import io.netty.handler.codec.http.websocketx.extensions.WebSocketExtensionFilter;
import org.junit.Test; import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.function.Executable;
import java.util.Random; import java.util.Random;
import static io.netty.handler.codec.http.websocketx.extensions.WebSocketExtensionFilter.*; import static io.netty.handler.codec.http.websocketx.extensions.WebSocketExtensionFilter.*;
import static io.netty.handler.codec.http.websocketx.extensions.compression.DeflateDecoder.*; import static io.netty.handler.codec.http.websocketx.extensions.compression.DeflateDecoder.*;
import static io.netty.util.CharsetUtil.*; import static io.netty.util.CharsetUtil.*;
import static org.junit.Assert.*; import static org.junit.jupiter.api.Assertions.assertArrayEquals;
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.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
public class PerMessageDeflateDecoderTest { public class PerMessageDeflateDecoderTest {
@ -264,7 +270,7 @@ public class PerMessageDeflateDecoderTest {
assertFalse(decoderChannel.finish()); assertFalse(decoderChannel.finish());
} }
@Test(expected = DecoderException.class) @Test
public void testIllegalStateWhenDecompressionInProgress() { public void testIllegalStateWhenDecompressionInProgress() {
WebSocketExtensionFilter selectivityDecompressionFilter = new WebSocketExtensionFilter() { WebSocketExtensionFilter selectivityDecompressionFilter = new WebSocketExtensionFilter() {
@Override @Override
@ -275,7 +281,7 @@ public class PerMessageDeflateDecoderTest {
EmbeddedChannel encoderChannel = new EmbeddedChannel( EmbeddedChannel encoderChannel = new EmbeddedChannel(
ZlibCodecFactory.newZlibEncoder(ZlibWrapper.NONE, 9, 15, 8)); ZlibCodecFactory.newZlibEncoder(ZlibWrapper.NONE, 9, 15, 8));
EmbeddedChannel decoderChannel = new EmbeddedChannel( final EmbeddedChannel decoderChannel = new EmbeddedChannel(
new PerMessageDeflateDecoder(false, selectivityDecompressionFilter)); new PerMessageDeflateDecoder(false, selectivityDecompressionFilter));
byte[] firstPayload = new byte[200]; byte[] firstPayload = new byte[200];
@ -292,7 +298,7 @@ public class PerMessageDeflateDecoderTest {
BinaryWebSocketFrame firstPart = new BinaryWebSocketFrame(false, WebSocketExtension.RSV1, BinaryWebSocketFrame firstPart = new BinaryWebSocketFrame(false, WebSocketExtension.RSV1,
compressedFirstPayload); compressedFirstPayload);
ContinuationWebSocketFrame finalPart = new ContinuationWebSocketFrame(true, WebSocketExtension.RSV1, final ContinuationWebSocketFrame finalPart = new ContinuationWebSocketFrame(true, WebSocketExtension.RSV1,
compressedFinalPayload); compressedFinalPayload);
assertTrue(decoderChannel.writeInbound(firstPart)); assertTrue(decoderChannel.writeInbound(firstPart));
@ -304,7 +310,12 @@ public class PerMessageDeflateDecoderTest {
//final part throwing exception //final part throwing exception
try { try {
assertThrows(DecoderException.class, new Executable() {
@Override
public void execute() {
decoderChannel.writeInbound(finalPart); decoderChannel.writeInbound(finalPart);
}
});
} finally { } finally {
assertTrue(finalPart.release()); assertTrue(finalPart.release());
assertFalse(encoderChannel.finishAndReleaseAll()); assertFalse(encoderChannel.finishAndReleaseAll());

32
codec-http/src/test/java/io/netty/handler/codec/http/websocketx/extensions/compression/PerMessageDeflateEncoderTest.java
View File

@ -28,7 +28,8 @@ import io.netty.handler.codec.http.websocketx.TextWebSocketFrame;
import io.netty.handler.codec.http.websocketx.WebSocketFrame; import io.netty.handler.codec.http.websocketx.WebSocketFrame;
import io.netty.handler.codec.http.websocketx.extensions.WebSocketExtension; import io.netty.handler.codec.http.websocketx.extensions.WebSocketExtension;
import io.netty.handler.codec.http.websocketx.extensions.WebSocketExtensionFilter; import io.netty.handler.codec.http.websocketx.extensions.WebSocketExtensionFilter;
import org.junit.Test; import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.function.Executable;
import java.util.Arrays; import java.util.Arrays;
import java.util.Random; import java.util.Random;
@ -36,7 +37,12 @@ import java.util.Random;
import static io.netty.handler.codec.http.websocketx.extensions.WebSocketExtensionFilter.*; import static io.netty.handler.codec.http.websocketx.extensions.WebSocketExtensionFilter.*;
import static io.netty.handler.codec.http.websocketx.extensions.compression.DeflateDecoder.*; import static io.netty.handler.codec.http.websocketx.extensions.compression.DeflateDecoder.*;
import static io.netty.util.CharsetUtil.*; import static io.netty.util.CharsetUtil.*;
import static org.junit.Assert.*; import static org.junit.jupiter.api.Assertions.assertArrayEquals;
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.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
public class PerMessageDeflateEncoderTest { public class PerMessageDeflateEncoderTest {
@ -236,7 +242,7 @@ public class PerMessageDeflateEncoderTest {
assertFalse(decoderChannel.finish()); assertFalse(decoderChannel.finish());
} }
@Test(expected = EncoderException.class) @Test
public void testIllegalStateWhenCompressionInProgress() { public void testIllegalStateWhenCompressionInProgress() {
WebSocketExtensionFilter selectivityCompressionFilter = new WebSocketExtensionFilter() { WebSocketExtensionFilter selectivityCompressionFilter = new WebSocketExtensionFilter() {
@Override @Override
@ -244,7 +250,7 @@ public class PerMessageDeflateEncoderTest {
return frame.content().readableBytes() < 100; return frame.content().readableBytes() < 100;
} }
}; };
EmbeddedChannel encoderChannel = new EmbeddedChannel( final EmbeddedChannel encoderChannel = new EmbeddedChannel(
new PerMessageDeflateEncoder(9, 15, false, selectivityCompressionFilter)); new PerMessageDeflateEncoder(9, 15, false, selectivityCompressionFilter));
byte[] firstPayload = new byte[200]; byte[] firstPayload = new byte[200];
@ -254,7 +260,7 @@ public class PerMessageDeflateEncoderTest {
random.nextBytes(finalPayload); random.nextBytes(finalPayload);
BinaryWebSocketFrame firstPart = new BinaryWebSocketFrame(false, 0, Unpooled.wrappedBuffer(firstPayload)); BinaryWebSocketFrame firstPart = new BinaryWebSocketFrame(false, 0, Unpooled.wrappedBuffer(firstPayload));
ContinuationWebSocketFrame finalPart = new ContinuationWebSocketFrame(true, 0, final ContinuationWebSocketFrame finalPart = new ContinuationWebSocketFrame(true, 0,
Unpooled.wrappedBuffer(finalPayload)); Unpooled.wrappedBuffer(finalPayload));
assertTrue(encoderChannel.writeOutbound(firstPart)); assertTrue(encoderChannel.writeOutbound(firstPart));
@ -266,7 +272,12 @@ public class PerMessageDeflateEncoderTest {
//final part throwing exception //final part throwing exception
try { try {
assertThrows(EncoderException.class, new Executable() {
@Override
public void execute() throws Throwable {
encoderChannel.writeOutbound(finalPart); encoderChannel.writeOutbound(finalPart);
}
});
} finally { } finally {
assertTrue(finalPart.release()); assertTrue(finalPart.release());
assertFalse(encoderChannel.finishAndReleaseAll()); assertFalse(encoderChannel.finishAndReleaseAll());
@ -290,14 +301,19 @@ public class PerMessageDeflateEncoderTest {
assertFalse(encoderChannel.finish()); assertFalse(encoderChannel.finish());
} }
@Test(expected = EncoderException.class) @Test
public void testCodecExceptionForNotFinEmptyFrame() { public void testCodecExceptionForNotFinEmptyFrame() {
EmbeddedChannel encoderChannel = new EmbeddedChannel(new PerMessageDeflateEncoder(9, 15, false)); final EmbeddedChannel encoderChannel = new EmbeddedChannel(new PerMessageDeflateEncoder(9, 15, false));
TextWebSocketFrame emptyNotFinFrame = new TextWebSocketFrame(false, 0, ""); final TextWebSocketFrame emptyNotFinFrame = new TextWebSocketFrame(false, 0, "");
try { try {
assertThrows(EncoderException.class, new Executable() {
@Override
public void execute() {
encoderChannel.writeOutbound(emptyNotFinFrame); encoderChannel.writeOutbound(emptyNotFinFrame);
}
});
} finally { } finally {
// EmptyByteBuf buffer // EmptyByteBuf buffer
assertFalse(emptyNotFinFrame.release()); assertFalse(emptyNotFinFrame.release());

8
codec-http/src/test/java/io/netty/handler/codec/http/websocketx/extensions/compression/PerMessageDeflateServerExtensionHandshakerTest.java
View File

@ -17,7 +17,11 @@ package io.netty.handler.codec.http.websocketx.extensions.compression;
import static io.netty.handler.codec.http.websocketx.extensions.compression. import static io.netty.handler.codec.http.websocketx.extensions.compression.
PerMessageDeflateServerExtensionHandshaker.*; PerMessageDeflateServerExtensionHandshaker.*;
import static org.junit.Assert.*; 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 io.netty.handler.codec.http.websocketx.extensions.WebSocketServerExtension; import io.netty.handler.codec.http.websocketx.extensions.WebSocketServerExtension;
import io.netty.handler.codec.http.websocketx.extensions.WebSocketExtensionData; import io.netty.handler.codec.http.websocketx.extensions.WebSocketExtensionData;
@ -25,7 +29,7 @@ import java.util.Collections;
import java.util.HashMap; import java.util.HashMap;
import java.util.Map; import java.util.Map;
import org.junit.Test; import org.junit.jupiter.api.Test;
public class PerMessageDeflateServerExtensionHandshakerTest { public class PerMessageDeflateServerExtensionHandshakerTest {

68
codec-http/src/test/java/io/netty/handler/codec/http/websocketx/extensions/compression/WebSocketServerCompressionHandlerTest.java
View File

@ -25,12 +25,16 @@ import io.netty.handler.codec.http.websocketx.extensions.WebSocketServerExtensio
import java.util.List; import java.util.List;
import org.junit.Assert; import org.junit.jupiter.api.Test;
import org.junit.Test;
import static io.netty.handler.codec.http.websocketx.extensions.compression. import static io.netty.handler.codec.http.websocketx.extensions.compression.
PerMessageDeflateServerExtensionHandshaker.*; PerMessageDeflateServerExtensionHandshaker.*;
import static io.netty.handler.codec.http.websocketx.extensions.WebSocketExtensionTestUtil.*; import static io.netty.handler.codec.http.websocketx.extensions.WebSocketExtensionTestUtil.*;
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.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
public class WebSocketServerCompressionHandlerTest { public class WebSocketServerCompressionHandlerTest {
@ -48,10 +52,10 @@ public class WebSocketServerCompressionHandlerTest {
List<WebSocketExtensionData> exts = WebSocketExtensionUtil.extractExtensions( List<WebSocketExtensionData> exts = WebSocketExtensionUtil.extractExtensions(
res2.headers().get(HttpHeaderNames.SEC_WEBSOCKET_EXTENSIONS)); res2.headers().get(HttpHeaderNames.SEC_WEBSOCKET_EXTENSIONS));
Assert.assertEquals(PERMESSAGE_DEFLATE_EXTENSION, exts.get(0).name()); assertEquals(PERMESSAGE_DEFLATE_EXTENSION, exts.get(0).name());
Assert.assertTrue(exts.get(0).parameters().isEmpty()); assertTrue(exts.get(0).parameters().isEmpty());
Assert.assertNotNull(ch.pipeline().get(PerMessageDeflateDecoder.class)); assertNotNull(ch.pipeline().get(PerMessageDeflateDecoder.class));
Assert.assertNotNull(ch.pipeline().get(PerMessageDeflateEncoder.class)); assertNotNull(ch.pipeline().get(PerMessageDeflateEncoder.class));
} }
@Test @Test
@ -69,10 +73,10 @@ public class WebSocketServerCompressionHandlerTest {
List<WebSocketExtensionData> exts = WebSocketExtensionUtil.extractExtensions( List<WebSocketExtensionData> exts = WebSocketExtensionUtil.extractExtensions(
res2.headers().get(HttpHeaderNames.SEC_WEBSOCKET_EXTENSIONS)); res2.headers().get(HttpHeaderNames.SEC_WEBSOCKET_EXTENSIONS));
Assert.assertEquals(PERMESSAGE_DEFLATE_EXTENSION, exts.get(0).name()); assertEquals(PERMESSAGE_DEFLATE_EXTENSION, exts.get(0).name());
Assert.assertEquals("10", exts.get(0).parameters().get(CLIENT_MAX_WINDOW)); assertEquals("10", exts.get(0).parameters().get(CLIENT_MAX_WINDOW));
Assert.assertNotNull(ch.pipeline().get(PerMessageDeflateDecoder.class)); assertNotNull(ch.pipeline().get(PerMessageDeflateDecoder.class));
Assert.assertNotNull(ch.pipeline().get(PerMessageDeflateEncoder.class)); assertNotNull(ch.pipeline().get(PerMessageDeflateEncoder.class));
} }
@Test @Test
@ -90,10 +94,10 @@ public class WebSocketServerCompressionHandlerTest {
List<WebSocketExtensionData> exts = WebSocketExtensionUtil.extractExtensions( List<WebSocketExtensionData> exts = WebSocketExtensionUtil.extractExtensions(
res2.headers().get(HttpHeaderNames.SEC_WEBSOCKET_EXTENSIONS)); res2.headers().get(HttpHeaderNames.SEC_WEBSOCKET_EXTENSIONS));
Assert.assertEquals(PERMESSAGE_DEFLATE_EXTENSION, exts.get(0).name()); assertEquals(PERMESSAGE_DEFLATE_EXTENSION, exts.get(0).name());
Assert.assertTrue(exts.get(0).parameters().isEmpty()); assertTrue(exts.get(0).parameters().isEmpty());
Assert.assertNotNull(ch.pipeline().get(PerMessageDeflateDecoder.class)); assertNotNull(ch.pipeline().get(PerMessageDeflateDecoder.class));
Assert.assertNotNull(ch.pipeline().get(PerMessageDeflateEncoder.class)); assertNotNull(ch.pipeline().get(PerMessageDeflateEncoder.class));
} }
@Test @Test
@ -111,10 +115,10 @@ public class WebSocketServerCompressionHandlerTest {
List<WebSocketExtensionData> exts = WebSocketExtensionUtil.extractExtensions( List<WebSocketExtensionData> exts = WebSocketExtensionUtil.extractExtensions(
res2.headers().get(HttpHeaderNames.SEC_WEBSOCKET_EXTENSIONS)); res2.headers().get(HttpHeaderNames.SEC_WEBSOCKET_EXTENSIONS));
Assert.assertEquals(PERMESSAGE_DEFLATE_EXTENSION, exts.get(0).name()); assertEquals(PERMESSAGE_DEFLATE_EXTENSION, exts.get(0).name());
Assert.assertEquals("10", exts.get(0).parameters().get(SERVER_MAX_WINDOW)); assertEquals("10", exts.get(0).parameters().get(SERVER_MAX_WINDOW));
Assert.assertNotNull(ch.pipeline().get(PerMessageDeflateDecoder.class)); assertNotNull(ch.pipeline().get(PerMessageDeflateDecoder.class));
Assert.assertNotNull(ch.pipeline().get(PerMessageDeflateEncoder.class)); assertNotNull(ch.pipeline().get(PerMessageDeflateEncoder.class));
} }
@Test @Test
@ -130,9 +134,9 @@ public class WebSocketServerCompressionHandlerTest {
HttpResponse res2 = ch.readOutbound(); HttpResponse res2 = ch.readOutbound();
Assert.assertFalse(res2.headers().contains(HttpHeaderNames.SEC_WEBSOCKET_EXTENSIONS)); assertFalse(res2.headers().contains(HttpHeaderNames.SEC_WEBSOCKET_EXTENSIONS));
Assert.assertNull(ch.pipeline().get(PerMessageDeflateDecoder.class)); assertNull(ch.pipeline().get(PerMessageDeflateDecoder.class));
Assert.assertNull(ch.pipeline().get(PerMessageDeflateEncoder.class)); assertNull(ch.pipeline().get(PerMessageDeflateEncoder.class));
} }
@Test @Test
@ -147,9 +151,9 @@ public class WebSocketServerCompressionHandlerTest {
HttpResponse res2 = ch.readOutbound(); HttpResponse res2 = ch.readOutbound();
Assert.assertFalse(res2.headers().contains(HttpHeaderNames.SEC_WEBSOCKET_EXTENSIONS)); assertFalse(res2.headers().contains(HttpHeaderNames.SEC_WEBSOCKET_EXTENSIONS));
Assert.assertNull(ch.pipeline().get(PerMessageDeflateDecoder.class)); assertNull(ch.pipeline().get(PerMessageDeflateDecoder.class));
Assert.assertNull(ch.pipeline().get(PerMessageDeflateEncoder.class)); assertNull(ch.pipeline().get(PerMessageDeflateEncoder.class));
} }
@Test @Test
@ -166,10 +170,10 @@ public class WebSocketServerCompressionHandlerTest {
List<WebSocketExtensionData> exts = WebSocketExtensionUtil.extractExtensions( List<WebSocketExtensionData> exts = WebSocketExtensionUtil.extractExtensions(
res2.headers().get(HttpHeaderNames.SEC_WEBSOCKET_EXTENSIONS)); res2.headers().get(HttpHeaderNames.SEC_WEBSOCKET_EXTENSIONS));
Assert.assertEquals(PERMESSAGE_DEFLATE_EXTENSION, exts.get(0).name()); assertEquals(PERMESSAGE_DEFLATE_EXTENSION, exts.get(0).name());
Assert.assertTrue(exts.get(0).parameters().isEmpty()); assertTrue(exts.get(0).parameters().isEmpty());
Assert.assertNotNull(ch.pipeline().get(PerMessageDeflateDecoder.class)); assertNotNull(ch.pipeline().get(PerMessageDeflateDecoder.class));
Assert.assertNotNull(ch.pipeline().get(PerMessageDeflateEncoder.class)); assertNotNull(ch.pipeline().get(PerMessageDeflateEncoder.class));
} }
@Test @Test
@ -188,10 +192,10 @@ public class WebSocketServerCompressionHandlerTest {
List<WebSocketExtensionData> exts = WebSocketExtensionUtil.extractExtensions( List<WebSocketExtensionData> exts = WebSocketExtensionUtil.extractExtensions(
res2.headers().get(HttpHeaderNames.SEC_WEBSOCKET_EXTENSIONS)); res2.headers().get(HttpHeaderNames.SEC_WEBSOCKET_EXTENSIONS));
Assert.assertEquals(PERMESSAGE_DEFLATE_EXTENSION, exts.get(0).name()); assertEquals(PERMESSAGE_DEFLATE_EXTENSION, exts.get(0).name());
Assert.assertTrue(exts.get(0).parameters().isEmpty()); assertTrue(exts.get(0).parameters().isEmpty());
Assert.assertNotNull(ch.pipeline().get(PerMessageDeflateDecoder.class)); assertNotNull(ch.pipeline().get(PerMessageDeflateDecoder.class));
Assert.assertNotNull(ch.pipeline().get(PerMessageDeflateEncoder.class)); assertNotNull(ch.pipeline().get(PerMessageDeflateEncoder.class));
} }
} }