fix tests, disable two jctools maps test (not relevant for netty), hack test for PerMessageDeflateClientExtensionHandshakerTest, move target to build directory for gradle
parent
fcd9b342e9
commit
5e8af038c8
@ -0,0 +1,214 @@
|
||||
/*
|
||||
* Copyright 2017 The Netty Project
|
||||
*
|
||||
* The Netty Project licenses this file to you under the Apache License,
|
||||
* version 2.0 (the "License"); you may not use this file except in compliance
|
||||
* with the License. You may obtain a copy of the License at:
|
||||
*
|
||||
* https://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
||||
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
||||
* License for the specific language governing permissions and limitations
|
||||
* under the License.
|
||||
*/
|
||||
package io.netty.channel.unix;
|
||||
|
||||
import io.netty.bootstrap.Bootstrap;
|
||||
import io.netty.bootstrap.ServerBootstrap;
|
||||
import io.netty.buffer.ByteBuf;
|
||||
import io.netty.channel.Channel;
|
||||
import io.netty.channel.ChannelFutureListener;
|
||||
import io.netty.channel.ChannelHandlerContext;
|
||||
import io.netty.channel.ChannelInboundHandlerAdapter;
|
||||
import io.netty.channel.ChannelInitializer;
|
||||
import io.netty.channel.ChannelOption;
|
||||
import io.netty.channel.EventLoopGroup;
|
||||
import io.netty.channel.FixedRecvByteBufAllocator;
|
||||
import io.netty.channel.ServerChannel;
|
||||
import io.netty.channel.SimpleChannelInboundHandler;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.junit.jupiter.api.Timeout;
|
||||
|
||||
import java.net.InetSocketAddress;
|
||||
import java.util.concurrent.CountDownLatch;
|
||||
import java.util.concurrent.TimeUnit;
|
||||
import java.util.concurrent.atomic.AtomicInteger;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
|
||||
public abstract class DetectPeerCloseWithoutReadTest {
|
||||
protected abstract EventLoopGroup newGroup();
|
||||
protected abstract Class<? extends ServerChannel> serverChannel();
|
||||
protected abstract Class<? extends Channel> clientChannel();
|
||||
|
||||
@Test
|
||||
@Timeout(value = 10000, unit = TimeUnit.MILLISECONDS)
|
||||
public void clientCloseWithoutServerReadIsDetectedNoExtraReadRequested() throws InterruptedException {
|
||||
clientCloseWithoutServerReadIsDetected0(false);
|
||||
}
|
||||
|
||||
@Test
|
||||
@Timeout(value = 10000, unit = TimeUnit.MILLISECONDS)
|
||||
public void clientCloseWithoutServerReadIsDetectedExtraReadRequested() throws InterruptedException {
|
||||
clientCloseWithoutServerReadIsDetected0(true);
|
||||
}
|
||||
|
||||
private void clientCloseWithoutServerReadIsDetected0(final boolean extraReadRequested)
|
||||
throws InterruptedException {
|
||||
EventLoopGroup serverGroup = null;
|
||||
EventLoopGroup clientGroup = null;
|
||||
Channel serverChannel = null;
|
||||
try {
|
||||
final CountDownLatch latch = new CountDownLatch(1);
|
||||
final AtomicInteger bytesRead = new AtomicInteger();
|
||||
final int expectedBytes = 100;
|
||||
serverGroup = newGroup();
|
||||
clientGroup = newGroup();
|
||||
ServerBootstrap sb = new ServerBootstrap();
|
||||
sb.group(serverGroup);
|
||||
sb.channel(serverChannel());
|
||||
// Ensure we read only one message per read() call and that we need multiple read()
|
||||
// calls to consume everything.
|
||||
sb.childOption(ChannelOption.AUTO_READ, false);
|
||||
sb.childOption(ChannelOption.MAX_MESSAGES_PER_READ, 1);
|
||||
sb.childOption(ChannelOption.RCVBUF_ALLOCATOR, new FixedRecvByteBufAllocator(expectedBytes / 10));
|
||||
sb.childHandler(new ChannelInitializer<Channel>() {
|
||||
@Override
|
||||
protected void initChannel(Channel ch) {
|
||||
ch.pipeline().addLast(new TestHandler(bytesRead, extraReadRequested, latch));
|
||||
}
|
||||
});
|
||||
|
||||
serverChannel = sb.bind(new InetSocketAddress(0)).syncUninterruptibly().channel();
|
||||
|
||||
Bootstrap cb = new Bootstrap();
|
||||
cb.group(serverGroup);
|
||||
cb.channel(clientChannel());
|
||||
cb.handler(new ChannelInboundHandlerAdapter());
|
||||
Channel clientChannel = cb.connect(serverChannel.localAddress()).syncUninterruptibly().channel();
|
||||
ByteBuf buf = clientChannel.alloc().buffer(expectedBytes);
|
||||
buf.writerIndex(buf.writerIndex() + expectedBytes);
|
||||
clientChannel.writeAndFlush(buf).addListener(ChannelFutureListener.CLOSE);
|
||||
|
||||
latch.await();
|
||||
assertEquals(expectedBytes, bytesRead.get());
|
||||
} finally {
|
||||
if (serverChannel != null) {
|
||||
serverChannel.close().syncUninterruptibly();
|
||||
}
|
||||
if (serverGroup != null) {
|
||||
serverGroup.shutdownGracefully();
|
||||
}
|
||||
if (clientGroup != null) {
|
||||
clientGroup.shutdownGracefully();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
@Timeout(value = 10000, unit = TimeUnit.MILLISECONDS)
|
||||
public void serverCloseWithoutClientReadIsDetectedNoExtraReadRequested() throws InterruptedException {
|
||||
serverCloseWithoutClientReadIsDetected0(false);
|
||||
}
|
||||
|
||||
@Test
|
||||
@Timeout(value = 10000, unit = TimeUnit.MILLISECONDS)
|
||||
public void serverCloseWithoutClientReadIsDetectedExtraReadRequested() throws InterruptedException {
|
||||
serverCloseWithoutClientReadIsDetected0(true);
|
||||
}
|
||||
|
||||
private void serverCloseWithoutClientReadIsDetected0(final boolean extraReadRequested) throws InterruptedException {
|
||||
EventLoopGroup serverGroup = null;
|
||||
EventLoopGroup clientGroup = null;
|
||||
Channel serverChannel = null;
|
||||
Channel clientChannel = null;
|
||||
try {
|
||||
final CountDownLatch latch = new CountDownLatch(1);
|
||||
final AtomicInteger bytesRead = new AtomicInteger();
|
||||
final int expectedBytes = 100;
|
||||
serverGroup = newGroup();
|
||||
clientGroup = newGroup();
|
||||
ServerBootstrap sb = new ServerBootstrap();
|
||||
sb.group(serverGroup);
|
||||
sb.channel(serverChannel());
|
||||
sb.childHandler(new ChannelInitializer<Channel>() {
|
||||
@Override
|
||||
protected void initChannel(Channel ch) {
|
||||
ch.pipeline().addLast(new ChannelInboundHandlerAdapter() {
|
||||
@Override
|
||||
public void channelActive(ChannelHandlerContext ctx) {
|
||||
ByteBuf buf = ctx.alloc().buffer(expectedBytes);
|
||||
buf.writerIndex(buf.writerIndex() + expectedBytes);
|
||||
ctx.writeAndFlush(buf).addListener(ChannelFutureListener.CLOSE);
|
||||
ctx.fireChannelActive();
|
||||
}
|
||||
});
|
||||
}
|
||||
});
|
||||
|
||||
serverChannel = sb.bind(new InetSocketAddress(0)).syncUninterruptibly().channel();
|
||||
|
||||
Bootstrap cb = new Bootstrap();
|
||||
cb.group(serverGroup);
|
||||
cb.channel(clientChannel());
|
||||
// Ensure we read only one message per read() call and that we need multiple read()
|
||||
// calls to consume everything.
|
||||
cb.option(ChannelOption.AUTO_READ, false);
|
||||
cb.option(ChannelOption.MAX_MESSAGES_PER_READ, 1);
|
||||
cb.option(ChannelOption.RCVBUF_ALLOCATOR, new FixedRecvByteBufAllocator(expectedBytes / 10));
|
||||
cb.handler(new ChannelInitializer<Channel>() {
|
||||
@Override
|
||||
protected void initChannel(Channel ch) throws Exception {
|
||||
ch.pipeline().addLast(new TestHandler(bytesRead, extraReadRequested, latch));
|
||||
}
|
||||
});
|
||||
clientChannel = cb.connect(serverChannel.localAddress()).syncUninterruptibly().channel();
|
||||
|
||||
latch.await();
|
||||
assertEquals(expectedBytes, bytesRead.get());
|
||||
} finally {
|
||||
if (serverChannel != null) {
|
||||
serverChannel.close().syncUninterruptibly();
|
||||
}
|
||||
if (clientChannel != null) {
|
||||
clientChannel.close().syncUninterruptibly();
|
||||
}
|
||||
if (serverGroup != null) {
|
||||
serverGroup.shutdownGracefully();
|
||||
}
|
||||
if (clientGroup != null) {
|
||||
clientGroup.shutdownGracefully();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private static final class TestHandler extends SimpleChannelInboundHandler<ByteBuf> {
|
||||
private final AtomicInteger bytesRead;
|
||||
private final boolean extraReadRequested;
|
||||
private final CountDownLatch latch;
|
||||
|
||||
TestHandler(AtomicInteger bytesRead, boolean extraReadRequested, CountDownLatch latch) {
|
||||
this.bytesRead = bytesRead;
|
||||
this.extraReadRequested = extraReadRequested;
|
||||
this.latch = latch;
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void channelRead0(ChannelHandlerContext ctx, ByteBuf msg) {
|
||||
bytesRead.addAndGet(msg.readableBytes());
|
||||
|
||||
if (extraReadRequested) {
|
||||
// Because autoread is off, we call read to consume all data until we detect the close.
|
||||
ctx.read();
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void channelInactive(ChannelHandlerContext ctx) {
|
||||
latch.countDown();
|
||||
ctx.fireChannelInactive();
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,64 @@
|
||||
/*
|
||||
* Copyright 2020 The Netty Project
|
||||
*
|
||||
* The Netty Project licenses this file to you under the Apache License,
|
||||
* version 2.0 (the "License"); you may not use this file except in compliance
|
||||
* with the License. You may obtain a copy of the License at:
|
||||
*
|
||||
* https://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
||||
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
||||
* License for the specific language governing permissions and limitations
|
||||
* under the License.
|
||||
*/
|
||||
package io.netty.channel.unix;
|
||||
|
||||
import io.netty.buffer.ByteBuf;
|
||||
import io.netty.buffer.Unpooled;
|
||||
import io.netty.buffer.UnpooledByteBufAllocator;
|
||||
import io.netty.buffer.UnpooledDirectByteBuf;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
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 IovArrayTest {
|
||||
|
||||
@Test
|
||||
public void testNotFailsWihtoutMemoryAddress() {
|
||||
ByteBuf buffer = new NoMemoryAddressByteBuf(128);
|
||||
IovArray array = new IovArray(buffer);
|
||||
|
||||
ByteBuf buf = Unpooled.directBuffer().writeZero(8);
|
||||
ByteBuf buf2 = new NoMemoryAddressByteBuf(8).writeZero(8);
|
||||
assertTrue(array.add(buf, 0, buf.readableBytes()));
|
||||
assertTrue(array.add(buf, 0, buf2.readableBytes()));
|
||||
assertEquals(2, array.count());
|
||||
assertEquals(16, array.size());
|
||||
assertTrue(buf.release());
|
||||
assertTrue(buf2.release());
|
||||
assertNotEquals(-1, array.memoryAddress(0));
|
||||
array.release();
|
||||
assertEquals(0, buffer.refCnt());
|
||||
}
|
||||
|
||||
private static final class NoMemoryAddressByteBuf extends UnpooledDirectByteBuf {
|
||||
|
||||
NoMemoryAddressByteBuf(int capacity) {
|
||||
super(UnpooledByteBufAllocator.DEFAULT, capacity, Integer.MAX_VALUE);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean hasMemoryAddress() {
|
||||
return false;
|
||||
}
|
||||
|
||||
@Override
|
||||
public long memoryAddress() {
|
||||
throw new UnsupportedOperationException();
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,134 @@
|
||||
/*
|
||||
* Copyright 2015 The Netty Project
|
||||
*
|
||||
* The Netty Project licenses this file to you under the Apache License,
|
||||
* version 2.0 (the "License"); you may not use this file except in compliance
|
||||
* with the License. You may obtain a copy of the License at:
|
||||
*
|
||||
* https://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
||||
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
||||
* License for the specific language governing permissions and limitations
|
||||
* under the License.
|
||||
*/
|
||||
package io.netty.channel.unix;
|
||||
|
||||
import org.junit.jupiter.api.AfterEach;
|
||||
import org.junit.jupiter.api.BeforeEach;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.opentest4j.TestAbortedException;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.nio.ByteBuffer;
|
||||
|
||||
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.assertTrue;
|
||||
|
||||
public abstract class SocketTest<T extends Socket> {
|
||||
protected T socket;
|
||||
|
||||
protected abstract T newSocket();
|
||||
|
||||
@BeforeEach
|
||||
public void setup() {
|
||||
socket = newSocket();
|
||||
}
|
||||
|
||||
@AfterEach
|
||||
public void tearDown() throws IOException {
|
||||
socket.close();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testKeepAlive() throws Exception {
|
||||
assertFalse(socket.isKeepAlive());
|
||||
socket.setKeepAlive(true);
|
||||
assertTrue(socket.isKeepAlive());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testTcpNoDelay() throws Exception {
|
||||
assertFalse(socket.isTcpNoDelay());
|
||||
socket.setTcpNoDelay(true);
|
||||
assertTrue(socket.isTcpNoDelay());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testReceivedBufferSize() throws Exception {
|
||||
int size = socket.getReceiveBufferSize();
|
||||
int newSize = 65535;
|
||||
assertTrue(size > 0);
|
||||
socket.setReceiveBufferSize(newSize);
|
||||
// Linux usually set it to double what is specified
|
||||
assertTrue(newSize <= socket.getReceiveBufferSize());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testSendBufferSize() throws Exception {
|
||||
int size = socket.getSendBufferSize();
|
||||
int newSize = 65535;
|
||||
assertTrue(size > 0);
|
||||
socket.setSendBufferSize(newSize);
|
||||
// Linux usually set it to double what is specified
|
||||
assertTrue(newSize <= socket.getSendBufferSize());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testSoLinger() throws Exception {
|
||||
assertEquals(-1, socket.getSoLinger());
|
||||
socket.setSoLinger(10);
|
||||
assertEquals(10, socket.getSoLinger());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testDoubleCloseDoesNotThrow() throws IOException {
|
||||
Socket socket = Socket.newSocketStream();
|
||||
socket.close();
|
||||
socket.close();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testTrafficClass() throws IOException {
|
||||
// IPTOS_THROUGHPUT
|
||||
final int value = 0x08;
|
||||
socket.setTrafficClass(value);
|
||||
assertEquals(value, socket.getTrafficClass());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testIntOpt() throws IOException {
|
||||
socket.setReuseAddress(false);
|
||||
socket.setIntOpt(level(), optname(), 1);
|
||||
// Anything which is != 0 is considered enabled
|
||||
assertNotEquals(0, socket.getIntOpt(level(), optname()));
|
||||
socket.setIntOpt(level(), optname(), 0);
|
||||
// This should be disabled again
|
||||
assertEquals(0, socket.getIntOpt(level(), optname()));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testRawOpt() throws IOException {
|
||||
ByteBuffer buffer = Buffer.allocateDirectWithNativeOrder(4);
|
||||
buffer.putInt(1).flip();
|
||||
socket.setRawOpt(level(), optname(), buffer);
|
||||
|
||||
ByteBuffer out = ByteBuffer.allocate(4);
|
||||
socket.getRawOpt(level(), optname(), out);
|
||||
assertFalse(out.hasRemaining());
|
||||
|
||||
out.flip();
|
||||
assertNotEquals(ByteBuffer.allocate(0), out);
|
||||
}
|
||||
|
||||
protected int level() {
|
||||
throw new TestAbortedException("Not supported");
|
||||
}
|
||||
|
||||
protected int optname() {
|
||||
throw new TestAbortedException("Not supported");
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,82 @@
|
||||
/*
|
||||
* Copyright 2016 The Netty Project
|
||||
*
|
||||
* The Netty Project licenses this file to you under the Apache License,
|
||||
* version 2.0 (the "License"); you may not use this file except in compliance
|
||||
* with the License. You may obtain a copy of the License at:
|
||||
*
|
||||
* https://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
||||
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
||||
* License for the specific language governing permissions and limitations
|
||||
* under the License.
|
||||
*/
|
||||
package io.netty.channel.unix;
|
||||
|
||||
import io.netty.util.internal.PlatformDependent;
|
||||
|
||||
import java.io.File;
|
||||
import java.io.IOException;
|
||||
import java.lang.reflect.Method;
|
||||
import java.net.InetAddress;
|
||||
import java.net.InetSocketAddress;
|
||||
import java.net.SocketAddress;
|
||||
|
||||
import static org.junit.jupiter.api.Assumptions.assumeTrue;
|
||||
|
||||
public final class UnixTestUtils {
|
||||
private static final Object INET_LOOPBACK_UNAVAILABLE = new Object();
|
||||
private static volatile Object inetLoopbackCache;
|
||||
|
||||
/**
|
||||
* @deprecated Use {@link #newDomainSocketAddress()} instead.
|
||||
*/
|
||||
@Deprecated
|
||||
public static DomainSocketAddress newSocketAddress() {
|
||||
return newDomainSocketAddress();
|
||||
}
|
||||
|
||||
public static DomainSocketAddress newDomainSocketAddress() {
|
||||
try {
|
||||
File file;
|
||||
do {
|
||||
file = PlatformDependent.createTempFile("NETTY", "UDS", null);
|
||||
if (!file.delete()) {
|
||||
throw new IOException("failed to delete: " + file);
|
||||
}
|
||||
} while (file.getAbsolutePath().length() > 128);
|
||||
return new DomainSocketAddress(file);
|
||||
} catch (IOException e) {
|
||||
throw new IllegalStateException(e);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* The JDK method may produce IPv4 loopback addresses where {@link io.netty.util.NetUtil#LOCALHOST} might be an
|
||||
* IPv6 addresses.
|
||||
* This difference can stress the system in different ways that are important to test.
|
||||
*/
|
||||
public static SocketAddress newInetLoopbackSocketAddress() {
|
||||
Object loopback = inetLoopbackCache;
|
||||
|
||||
if (loopback == null) {
|
||||
inetLoopbackCache = loopback = getLoopbackAddress();
|
||||
}
|
||||
|
||||
assumeTrue(loopback != INET_LOOPBACK_UNAVAILABLE, "InetAddress.getLoopbackAddress() is not available");
|
||||
return new InetSocketAddress((InetAddress) loopback, 0);
|
||||
}
|
||||
|
||||
private static Object getLoopbackAddress() {
|
||||
try {
|
||||
Method method = InetAddress.class.getMethod("getLoopbackAddress");
|
||||
return method.invoke(null);
|
||||
} catch (Exception ignore) {
|
||||
return INET_LOOPBACK_UNAVAILABLE;
|
||||
}
|
||||
}
|
||||
|
||||
private UnixTestUtils() { }
|
||||
}
|
||||
@ -0,0 +1,20 @@
|
||||
/*
|
||||
* Copyright 2016 The Netty Project
|
||||
*
|
||||
* The Netty Project licenses this file to you under the Apache License,
|
||||
* version 2.0 (the "License"); you may not use this file except in compliance
|
||||
* with the License. You may obtain a copy of the License at:
|
||||
*
|
||||
* https://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
||||
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
||||
* License for the specific language governing permissions and limitations
|
||||
* under the License.
|
||||
*/
|
||||
|
||||
/**
|
||||
* Unix specific transport tests.
|
||||
*/
|
||||
package io.netty.channel.unix;
|
||||
Loading…
Reference in New Issue