undefect. CWE-407 — 63 sites patched across 27 ecosystems
Authors: russell@unturf.com · brackishbert@gmail.com · foxhop.net · TimeHexOn.com Patches, unit tests, benchmarks, whitepaper, and outreach briefs. Public domain — no copyright claimed. Use freely.
This commit is contained in:
commit
0a580b313d
70422 changed files with 17213626 additions and 0 deletions
785
test/jdk/java/nio/channels/AsyncCloseAndInterrupt.java
Normal file
785
test/jdk/java/nio/channels/AsyncCloseAndInterrupt.java
Normal file
|
|
@ -0,0 +1,785 @@
|
|||
/*
|
||||
* Copyright (c) 2002, 2024, Oracle and/or its affiliates. All rights reserved.
|
||||
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
||||
*
|
||||
* This code is free software; you can redistribute it and/or modify it
|
||||
* under the terms of the GNU General Public License version 2 only, as
|
||||
* published by the Free Software Foundation.
|
||||
*
|
||||
* This code is distributed in the hope that it will be useful, but WITHOUT
|
||||
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
||||
* version 2 for more details (a copy is included in the LICENSE file that
|
||||
* accompanied this code).
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License version
|
||||
* 2 along with this work; if not, write to the Free Software Foundation,
|
||||
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
||||
*
|
||||
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
||||
* or visit www.oracle.com if you need additional information or have any
|
||||
* questions.
|
||||
*/
|
||||
|
||||
/* @test
|
||||
* @bug 4460583 4470470 4840199 6419424 6710579 6596323 6824135 6395224 7142919
|
||||
* 8151582 8068693 8153209
|
||||
* @library /test/lib
|
||||
* @run main/othervm --enable-native-access=ALL-UNNAMED AsyncCloseAndInterrupt
|
||||
* @key intermittent
|
||||
* @summary Comprehensive test of asynchronous closing and interruption
|
||||
* @author Mark Reinhold
|
||||
*/
|
||||
|
||||
import java.io.*;
|
||||
import java.net.*;
|
||||
import java.nio.channels.*;
|
||||
import java.nio.ByteBuffer;
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
import java.util.concurrent.ExecutorService;
|
||||
import java.util.concurrent.Executors;
|
||||
import java.util.concurrent.ThreadFactory;
|
||||
import java.util.concurrent.Callable;
|
||||
import java.util.concurrent.Future;
|
||||
import java.util.concurrent.TimeUnit;
|
||||
|
||||
import java.lang.foreign.Arena;
|
||||
import java.lang.foreign.FunctionDescriptor;
|
||||
import java.lang.foreign.Linker;
|
||||
import java.lang.foreign.MemorySegment;
|
||||
import java.lang.foreign.SymbolLookup;
|
||||
import java.lang.foreign.ValueLayout;
|
||||
import java.lang.invoke.MethodHandle;
|
||||
|
||||
public class AsyncCloseAndInterrupt {
|
||||
|
||||
static PrintStream log = System.err;
|
||||
|
||||
static void sleep(int ms) {
|
||||
try {
|
||||
Thread.sleep(ms);
|
||||
} catch (InterruptedException x) { }
|
||||
}
|
||||
|
||||
private static int mkfifo(String path) throws Throwable {
|
||||
Linker linker = Linker.nativeLinker();
|
||||
SymbolLookup stdlib = linker.defaultLookup();
|
||||
MethodHandle mkfifo = linker.downcallHandle(
|
||||
stdlib.find("mkfifo").orElseThrow(),
|
||||
FunctionDescriptor.of(ValueLayout.JAVA_INT,
|
||||
ValueLayout.ADDRESS, ValueLayout.JAVA_INT)
|
||||
);
|
||||
|
||||
try (Arena arena = Arena.ofConfined()) {
|
||||
MemorySegment cString = arena.allocateFrom(path);
|
||||
int mode = 0666;
|
||||
int returnValue = (int)mkfifo.invokeExact(cString, mode);
|
||||
return returnValue;
|
||||
}
|
||||
}
|
||||
|
||||
// Wildcard address localized to this machine -- Windoze doesn't allow
|
||||
// connecting to a server socket that was previously bound to a true
|
||||
// wildcard, namely new InetSocketAddress((InetAddress)null, 0).
|
||||
//
|
||||
private static InetSocketAddress wildcardAddress;
|
||||
|
||||
|
||||
// Server socket that blindly accepts all connections
|
||||
|
||||
static ServerSocketChannel acceptor;
|
||||
|
||||
private static void initAcceptor() throws IOException {
|
||||
acceptor = ServerSocketChannel.open();
|
||||
acceptor.socket().bind(wildcardAddress);
|
||||
|
||||
Thread th = new Thread("Acceptor") {
|
||||
public void run() {
|
||||
try {
|
||||
for (;;) {
|
||||
SocketChannel sc = acceptor.accept();
|
||||
}
|
||||
} catch (IOException x) {
|
||||
x.printStackTrace();
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
th.setDaemon(true);
|
||||
th.start();
|
||||
}
|
||||
|
||||
|
||||
// Server socket that refuses all connections
|
||||
|
||||
static ServerSocketChannel refuser;
|
||||
|
||||
private static void initRefuser() throws IOException {
|
||||
refuser = ServerSocketChannel.open();
|
||||
refuser.bind(wildcardAddress, 1); // use minimum backlog
|
||||
}
|
||||
|
||||
// Dead pipe source and sink
|
||||
|
||||
static Pipe.SourceChannel deadSource;
|
||||
static Pipe.SinkChannel deadSink;
|
||||
|
||||
private static void initPipes() throws IOException {
|
||||
if (deadSource != null)
|
||||
deadSource.close();
|
||||
deadSource = Pipe.open().source();
|
||||
if (deadSink != null)
|
||||
deadSink.close();
|
||||
deadSink = Pipe.open().sink();
|
||||
}
|
||||
|
||||
|
||||
// Files
|
||||
|
||||
private static File fifoFile = null; // File that blocks on reads and writes
|
||||
private static File diskFile = null; // Disk file
|
||||
|
||||
private static void initFile() throws Exception {
|
||||
|
||||
diskFile = File.createTempFile("aci", ".tmp");
|
||||
diskFile.deleteOnExit();
|
||||
FileChannel fc = new FileOutputStream(diskFile).getChannel();
|
||||
buffer.clear();
|
||||
if (fc.write(buffer) != buffer.capacity())
|
||||
throw new RuntimeException("Cannot create disk file");
|
||||
fc.close();
|
||||
|
||||
if (TestUtil.onWindows()) {
|
||||
log.println("WARNING: Cannot completely test FileChannels on Windows");
|
||||
return;
|
||||
}
|
||||
fifoFile = new File("x.fifo");
|
||||
fifoFile.deleteOnExit();
|
||||
if (fifoFile.exists()) {
|
||||
if (!fifoFile.delete())
|
||||
throw new IOException("Cannot delete existing fifo " + fifoFile);
|
||||
}
|
||||
|
||||
try {
|
||||
if (mkfifo(fifoFile.toString()) != 0) {
|
||||
fifoFile = null;
|
||||
log.println("WARNING: mkfifo failed - cannot completely test FileChannels");
|
||||
return;
|
||||
}
|
||||
} catch (Throwable cause) {
|
||||
throw new IOException(cause);
|
||||
}
|
||||
new RandomAccessFile(fifoFile, "rw").close();
|
||||
}
|
||||
|
||||
|
||||
// Channel factories
|
||||
|
||||
static abstract class ChannelFactory {
|
||||
private final String name;
|
||||
ChannelFactory(String name) {
|
||||
this.name = name;
|
||||
}
|
||||
public String toString() {
|
||||
return name;
|
||||
}
|
||||
abstract InterruptibleChannel create() throws IOException;
|
||||
}
|
||||
|
||||
static ChannelFactory socketChannelFactory
|
||||
= new ChannelFactory("SocketChannel") {
|
||||
InterruptibleChannel create() throws IOException {
|
||||
return SocketChannel.open();
|
||||
}
|
||||
};
|
||||
|
||||
static ChannelFactory connectedSocketChannelFactory
|
||||
= new ChannelFactory("SocketChannel") {
|
||||
InterruptibleChannel create() throws IOException {
|
||||
SocketAddress sa = acceptor.socket().getLocalSocketAddress();
|
||||
return SocketChannel.open(sa);
|
||||
}
|
||||
};
|
||||
|
||||
static ChannelFactory serverSocketChannelFactory
|
||||
= new ChannelFactory("ServerSocketChannel") {
|
||||
InterruptibleChannel create() throws IOException {
|
||||
ServerSocketChannel ssc = ServerSocketChannel.open();
|
||||
ssc.socket().bind(wildcardAddress);
|
||||
return ssc;
|
||||
}
|
||||
};
|
||||
|
||||
static ChannelFactory datagramChannelFactory
|
||||
= new ChannelFactory("DatagramChannel") {
|
||||
InterruptibleChannel create() throws IOException {
|
||||
DatagramChannel dc = DatagramChannel.open();
|
||||
InetAddress lb = InetAddress.getLoopbackAddress();
|
||||
dc.bind(new InetSocketAddress(lb, 0));
|
||||
dc.connect(new InetSocketAddress(lb, 80));
|
||||
return dc;
|
||||
}
|
||||
};
|
||||
|
||||
static ChannelFactory pipeSourceChannelFactory
|
||||
= new ChannelFactory("Pipe.SourceChannel") {
|
||||
InterruptibleChannel create() throws IOException {
|
||||
// ## arrange to close sink
|
||||
return Pipe.open().source();
|
||||
}
|
||||
};
|
||||
|
||||
static ChannelFactory pipeSinkChannelFactory
|
||||
= new ChannelFactory("Pipe.SinkChannel") {
|
||||
InterruptibleChannel create() throws IOException {
|
||||
// ## arrange to close source
|
||||
return Pipe.open().sink();
|
||||
}
|
||||
};
|
||||
|
||||
static ChannelFactory fifoFileChannelFactory
|
||||
= new ChannelFactory("FileChannel") {
|
||||
InterruptibleChannel create() throws IOException {
|
||||
return new RandomAccessFile(fifoFile, "rw").getChannel();
|
||||
}
|
||||
};
|
||||
|
||||
static ChannelFactory diskFileChannelFactory
|
||||
= new ChannelFactory("FileChannel") {
|
||||
InterruptibleChannel create() throws IOException {
|
||||
return new RandomAccessFile(diskFile, "rw").getChannel();
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
// I/O operations
|
||||
|
||||
static abstract class Op {
|
||||
private final String name;
|
||||
protected Op(String name) {
|
||||
this.name = name;
|
||||
}
|
||||
abstract void doIO(InterruptibleChannel ich) throws IOException;
|
||||
void setup() throws IOException { }
|
||||
public String toString() { return name; }
|
||||
}
|
||||
|
||||
static ByteBuffer buffer = ByteBuffer.allocateDirect(1 << 20);
|
||||
|
||||
static ByteBuffer[] buffers = new ByteBuffer[] {
|
||||
ByteBuffer.allocateDirect(1 << 19),
|
||||
ByteBuffer.allocateDirect(1 << 19)
|
||||
};
|
||||
|
||||
static void clearBuffers() {
|
||||
buffers[0].clear();
|
||||
buffers[1].clear();
|
||||
}
|
||||
|
||||
static void show(Channel ch) {
|
||||
log.print("Channel " + (ch.isOpen() ? "open" : "closed"));
|
||||
if (ch.isOpen() && (ch instanceof SocketChannel)) {
|
||||
SocketChannel sc = (SocketChannel)ch;
|
||||
if (sc.socket().isInputShutdown())
|
||||
log.print(", input shutdown");
|
||||
if (sc.socket().isOutputShutdown())
|
||||
log.print(", output shutdown");
|
||||
}
|
||||
log.println();
|
||||
}
|
||||
|
||||
static final Op READ = new Op("read") {
|
||||
void doIO(InterruptibleChannel ich) throws IOException {
|
||||
ReadableByteChannel rbc = (ReadableByteChannel)ich;
|
||||
buffer.clear();
|
||||
int n = rbc.read(buffer);
|
||||
log.println("Read returned " + n);
|
||||
show(rbc);
|
||||
if (rbc.isOpen()
|
||||
&& (n == -1)
|
||||
&& (rbc instanceof SocketChannel)
|
||||
&& ((SocketChannel)rbc).socket().isInputShutdown()) {
|
||||
return;
|
||||
}
|
||||
throw new RuntimeException("Read succeeded");
|
||||
}
|
||||
};
|
||||
|
||||
static final Op READV = new Op("readv") {
|
||||
void doIO(InterruptibleChannel ich) throws IOException {
|
||||
ScatteringByteChannel sbc = (ScatteringByteChannel)ich;
|
||||
clearBuffers();
|
||||
int n = (int)sbc.read(buffers);
|
||||
log.println("Read returned " + n);
|
||||
show(sbc);
|
||||
if (sbc.isOpen()
|
||||
&& (n == -1)
|
||||
&& (sbc instanceof SocketChannel)
|
||||
&& ((SocketChannel)sbc).socket().isInputShutdown()) {
|
||||
return;
|
||||
}
|
||||
throw new RuntimeException("Read succeeded");
|
||||
}
|
||||
};
|
||||
|
||||
static final Op RECEIVE = new Op("receive") {
|
||||
void doIO(InterruptibleChannel ich) throws IOException {
|
||||
DatagramChannel dc = (DatagramChannel)ich;
|
||||
buffer.clear();
|
||||
dc.receive(buffer);
|
||||
show(dc);
|
||||
throw new RuntimeException("Read succeeded");
|
||||
}
|
||||
};
|
||||
|
||||
static final Op WRITE = new Op("write") {
|
||||
void doIO(InterruptibleChannel ich) throws IOException {
|
||||
|
||||
WritableByteChannel wbc = (WritableByteChannel)ich;
|
||||
|
||||
SocketChannel sc = null;
|
||||
if (wbc instanceof SocketChannel)
|
||||
sc = (SocketChannel)wbc;
|
||||
|
||||
int n = 0;
|
||||
for (;;) {
|
||||
buffer.clear();
|
||||
int d = wbc.write(buffer);
|
||||
n += d;
|
||||
if (!wbc.isOpen())
|
||||
break;
|
||||
if ((sc != null) && sc.socket().isOutputShutdown())
|
||||
break;
|
||||
}
|
||||
log.println("Wrote " + n + " bytes");
|
||||
show(wbc);
|
||||
}
|
||||
};
|
||||
|
||||
static final Op WRITEV = new Op("writev") {
|
||||
void doIO(InterruptibleChannel ich) throws IOException {
|
||||
|
||||
GatheringByteChannel gbc = (GatheringByteChannel)ich;
|
||||
|
||||
SocketChannel sc = null;
|
||||
if (gbc instanceof SocketChannel)
|
||||
sc = (SocketChannel)gbc;
|
||||
|
||||
int n = 0;
|
||||
for (;;) {
|
||||
clearBuffers();
|
||||
int d = (int)gbc.write(buffers);
|
||||
n += d;
|
||||
if (!gbc.isOpen())
|
||||
break;
|
||||
if ((sc != null) && sc.socket().isOutputShutdown())
|
||||
break;
|
||||
}
|
||||
log.println("Wrote " + n + " bytes");
|
||||
show(gbc);
|
||||
|
||||
}
|
||||
};
|
||||
|
||||
static final Op CONNECT = new Op("connect") {
|
||||
void setup() {
|
||||
waitPump("connect waiting for pumping refuser ...");
|
||||
}
|
||||
void doIO(InterruptibleChannel ich) throws IOException {
|
||||
SocketChannel sc = (SocketChannel)ich;
|
||||
if (sc.connect(refuser.socket().getLocalSocketAddress()))
|
||||
throw new RuntimeException("Connection succeeded");
|
||||
throw new RuntimeException("Connection did not block");
|
||||
}
|
||||
};
|
||||
|
||||
static final Op FINISH_CONNECT = new Op("finishConnect") {
|
||||
void setup() {
|
||||
waitPump("finishConnect waiting for pumping refuser ...");
|
||||
}
|
||||
void doIO(InterruptibleChannel ich) throws IOException {
|
||||
SocketChannel sc = (SocketChannel)ich;
|
||||
sc.configureBlocking(false);
|
||||
SocketAddress sa = refuser.socket().getLocalSocketAddress();
|
||||
if (sc.connect(sa))
|
||||
throw new RuntimeException("Connection succeeded");
|
||||
sc.configureBlocking(true);
|
||||
if (sc.finishConnect())
|
||||
throw new RuntimeException("Connection succeeded");
|
||||
throw new RuntimeException("Connection did not block");
|
||||
}
|
||||
};
|
||||
|
||||
static final Op ACCEPT = new Op("accept") {
|
||||
void doIO(InterruptibleChannel ich) throws IOException {
|
||||
ServerSocketChannel ssc = (ServerSocketChannel)ich;
|
||||
ssc.accept();
|
||||
throw new RuntimeException("Accept succeeded");
|
||||
}
|
||||
};
|
||||
|
||||
// Use only with diskFileChannelFactory
|
||||
static final Op TRANSFER_TO = new Op("transferTo") {
|
||||
void doIO(InterruptibleChannel ich) throws IOException {
|
||||
FileChannel fc = (FileChannel)ich;
|
||||
long n = fc.transferTo(0, fc.size(), deadSink);
|
||||
log.println("Transferred " + n + " bytes");
|
||||
show(fc);
|
||||
}
|
||||
};
|
||||
|
||||
// Use only with diskFileChannelFactory
|
||||
static final Op TRANSFER_FROM = new Op("transferFrom") {
|
||||
void doIO(InterruptibleChannel ich) throws IOException {
|
||||
FileChannel fc = (FileChannel)ich;
|
||||
long n = fc.transferFrom(deadSource, 0, 1 << 20);
|
||||
log.println("Transferred " + n + " bytes");
|
||||
show(fc);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
// Test modes
|
||||
|
||||
static final int TEST_PREINTR = 0; // Interrupt thread before I/O
|
||||
static final int TEST_INTR = 1; // Interrupt thread during I/O
|
||||
static final int TEST_CLOSE = 2; // Close channel during I/O
|
||||
static final int TEST_SHUTI = 3; // Shutdown input during I/O
|
||||
static final int TEST_SHUTO = 4; // Shutdown output during I/O
|
||||
|
||||
static final String[] testName = new String[] {
|
||||
"pre-interrupt", "interrupt", "close",
|
||||
"shutdown-input", "shutdown-output"
|
||||
};
|
||||
|
||||
|
||||
static class Tester extends TestThread {
|
||||
|
||||
private InterruptibleChannel ch;
|
||||
private Op op;
|
||||
private int test;
|
||||
volatile boolean ready = false;
|
||||
|
||||
protected Tester(ChannelFactory cf, InterruptibleChannel ch,
|
||||
Op op, int test)
|
||||
{
|
||||
super(cf + "/" + op + "/" + testName[test]);
|
||||
this.ch = ch;
|
||||
this.op = op;
|
||||
this.test = test;
|
||||
}
|
||||
|
||||
@SuppressWarnings("fallthrough")
|
||||
private void caught(Channel ch, IOException x) {
|
||||
String xn = x.getClass().getName();
|
||||
switch (test) {
|
||||
|
||||
case TEST_PREINTR:
|
||||
case TEST_INTR:
|
||||
if (!xn.equals("java.nio.channels.ClosedByInterruptException"))
|
||||
throw new RuntimeException("Wrong exception thrown: " + x);
|
||||
break;
|
||||
|
||||
case TEST_CLOSE:
|
||||
case TEST_SHUTO:
|
||||
if (!xn.equals("java.nio.channels.AsynchronousCloseException"))
|
||||
throw new RuntimeException("Wrong exception thrown: " + x);
|
||||
break;
|
||||
|
||||
case TEST_SHUTI:
|
||||
if (TestUtil.onWindows())
|
||||
break;
|
||||
// FALL THROUGH
|
||||
|
||||
default:
|
||||
throw new Error(x);
|
||||
}
|
||||
|
||||
if (ch.isOpen()) {
|
||||
if (test == TEST_SHUTO) {
|
||||
SocketChannel sc = (SocketChannel)ch;
|
||||
if (!sc.socket().isOutputShutdown())
|
||||
throw new RuntimeException("Output not shutdown");
|
||||
} else if ((test == TEST_INTR || test == TEST_PREINTR)
|
||||
&& (op == TRANSFER_FROM)) {
|
||||
// Let these cases pass -- CBIE applies to other channel
|
||||
} else {
|
||||
throw new RuntimeException("Channel still open");
|
||||
}
|
||||
}
|
||||
|
||||
log.println("Thrown as expected: " + x);
|
||||
}
|
||||
|
||||
final void go() throws Exception {
|
||||
if (test == TEST_PREINTR)
|
||||
Thread.currentThread().interrupt();
|
||||
ready = true;
|
||||
try {
|
||||
op.doIO(ch);
|
||||
} catch (ClosedByInterruptException x) {
|
||||
caught(ch, x);
|
||||
} catch (AsynchronousCloseException x) {
|
||||
caught(ch, x);
|
||||
} finally {
|
||||
ch.close();
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
private static volatile boolean pumpDone = false;
|
||||
private static volatile boolean pumpReady = false;
|
||||
|
||||
private static void waitPump(String msg){
|
||||
log.println(msg);
|
||||
while (!pumpReady){
|
||||
sleep(200);
|
||||
}
|
||||
log.println(msg + " done");
|
||||
}
|
||||
|
||||
// Create a pump thread dedicated to saturate refuser's connection backlog
|
||||
private static Future<Integer> pumpRefuser(ExecutorService pumperExecutor) {
|
||||
|
||||
Callable<Integer> pumpTask = new Callable<Integer>() {
|
||||
|
||||
@Override
|
||||
public Integer call() throws IOException {
|
||||
// Can't reliably saturate connection backlog on Windows Server editions
|
||||
assert !TestUtil.onWindows();
|
||||
log.println("Start pumping refuser ...");
|
||||
List<SocketChannel> refuserClients = new ArrayList<>();
|
||||
|
||||
// Saturate the refuser's connection backlog so that further connection
|
||||
// attempts will be blocked
|
||||
pumpReady = false;
|
||||
while (!pumpDone) {
|
||||
SocketChannel sc = SocketChannel.open();
|
||||
sc.configureBlocking(false);
|
||||
boolean connected = sc.connect(refuser.socket().getLocalSocketAddress());
|
||||
|
||||
// Assume that the connection backlog is saturated if a
|
||||
// client cannot connect to the refuser within 50 milliseconds
|
||||
long start = System.currentTimeMillis();
|
||||
while (!pumpReady && !connected
|
||||
&& (System.currentTimeMillis() - start < 50)) {
|
||||
connected = sc.finishConnect();
|
||||
}
|
||||
|
||||
if (connected) {
|
||||
// Retain so that finalizer doesn't close
|
||||
refuserClients.add(sc);
|
||||
} else {
|
||||
sc.close();
|
||||
pumpReady = true;
|
||||
}
|
||||
}
|
||||
|
||||
for (SocketChannel sc : refuserClients) {
|
||||
sc.close();
|
||||
}
|
||||
refuser.close();
|
||||
|
||||
log.println("Stop pumping refuser ...");
|
||||
return refuserClients.size();
|
||||
}
|
||||
};
|
||||
|
||||
return pumperExecutor.submit(pumpTask);
|
||||
}
|
||||
|
||||
// Test
|
||||
static void test(ChannelFactory cf, Op op, int test) throws Exception {
|
||||
test(cf, op, test, true);
|
||||
}
|
||||
|
||||
static void test(ChannelFactory cf, Op op, int test, boolean extraSleep)
|
||||
throws Exception
|
||||
{
|
||||
log.println();
|
||||
initPipes();
|
||||
InterruptibleChannel ch = cf.create();
|
||||
Tester t = new Tester(cf, ch, op, test);
|
||||
log.println(t);
|
||||
op.setup();
|
||||
t.start();
|
||||
do {
|
||||
sleep(50);
|
||||
} while (!t.ready);
|
||||
|
||||
if (extraSleep) {
|
||||
sleep(100);
|
||||
}
|
||||
|
||||
switch (test) {
|
||||
|
||||
case TEST_INTR:
|
||||
t.interrupt();
|
||||
break;
|
||||
|
||||
case TEST_CLOSE:
|
||||
ch.close();
|
||||
break;
|
||||
|
||||
case TEST_SHUTI:
|
||||
if (TestUtil.onWindows()) {
|
||||
log.println("WARNING: Asynchronous shutdown not working on Windows");
|
||||
ch.close();
|
||||
} else {
|
||||
((SocketChannel)ch).socket().shutdownInput();
|
||||
}
|
||||
break;
|
||||
|
||||
case TEST_SHUTO:
|
||||
if (TestUtil.onWindows()) {
|
||||
log.println("WARNING: Asynchronous shutdown not working on Windows");
|
||||
ch.close();
|
||||
} else {
|
||||
((SocketChannel)ch).socket().shutdownOutput();
|
||||
}
|
||||
break;
|
||||
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
t.finishAndThrow(10000);
|
||||
}
|
||||
|
||||
static void test(ChannelFactory cf, Op op) throws Exception {
|
||||
test(cf, op, true);
|
||||
}
|
||||
|
||||
static void test(ChannelFactory cf, Op op, boolean extraSleep) throws Exception {
|
||||
// Test INTR cases before PREINTER cases since sometimes
|
||||
// interrupted threads can't load classes
|
||||
test(cf, op, TEST_INTR, extraSleep);
|
||||
test(cf, op, TEST_PREINTR, extraSleep);
|
||||
|
||||
// Bugs, see FileChannelImpl for details
|
||||
if (op == TRANSFER_FROM) {
|
||||
log.println("WARNING: transferFrom/close not tested");
|
||||
return;
|
||||
}
|
||||
if ((op == TRANSFER_TO) && !TestUtil.onWindows()) {
|
||||
log.println("WARNING: transferTo/close not tested");
|
||||
return;
|
||||
}
|
||||
|
||||
test(cf, op, TEST_CLOSE, extraSleep);
|
||||
}
|
||||
|
||||
static void test(ChannelFactory cf)
|
||||
throws Exception
|
||||
{
|
||||
InterruptibleChannel ch = cf.create(); // Sample channel
|
||||
ch.close();
|
||||
|
||||
if (ch instanceof ReadableByteChannel) {
|
||||
test(cf, READ);
|
||||
if (ch instanceof SocketChannel)
|
||||
test(cf, READ, TEST_SHUTI);
|
||||
}
|
||||
|
||||
if (ch instanceof ScatteringByteChannel) {
|
||||
test(cf, READV);
|
||||
if (ch instanceof SocketChannel)
|
||||
test(cf, READV, TEST_SHUTI);
|
||||
}
|
||||
|
||||
if (ch instanceof DatagramChannel) {
|
||||
test(cf, RECEIVE);
|
||||
|
||||
// Return here: We can't effectively test writes since, if they
|
||||
// block, they do so only for a fleeting moment unless the network
|
||||
// interface is overloaded.
|
||||
return;
|
||||
|
||||
}
|
||||
|
||||
if (ch instanceof WritableByteChannel) {
|
||||
test(cf, WRITE);
|
||||
if (ch instanceof SocketChannel)
|
||||
test(cf, WRITE, TEST_SHUTO);
|
||||
}
|
||||
|
||||
if (ch instanceof GatheringByteChannel) {
|
||||
test(cf, WRITEV);
|
||||
if (ch instanceof SocketChannel)
|
||||
test(cf, WRITEV, TEST_SHUTO);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
public static void main(String[] args) throws Exception {
|
||||
|
||||
wildcardAddress = new InetSocketAddress(InetAddress.getLocalHost(), 0);
|
||||
initAcceptor();
|
||||
if (!TestUtil.onWindows())
|
||||
initRefuser();
|
||||
initPipes();
|
||||
initFile();
|
||||
|
||||
if (TestUtil.onWindows()) {
|
||||
log.println("WARNING: Cannot test FileChannel transfer operations"
|
||||
+ " on Windows");
|
||||
} else {
|
||||
test(diskFileChannelFactory, TRANSFER_TO);
|
||||
test(diskFileChannelFactory, TRANSFER_FROM);
|
||||
}
|
||||
if (fifoFile != null)
|
||||
test(fifoFileChannelFactory);
|
||||
|
||||
// Testing positional file reads and writes is impractical: It requires
|
||||
// access to a large file soft-mounted via NFS, and even then isn't
|
||||
// completely guaranteed to work.
|
||||
//
|
||||
// Testing map is impractical and arguably unnecessary: It's
|
||||
// unclear under what conditions mmap(2) will actually block.
|
||||
|
||||
test(connectedSocketChannelFactory);
|
||||
|
||||
if (TestUtil.onWindows()) {
|
||||
log.println("WARNING Cannot reliably test connect/finishConnect"
|
||||
+ " operations on this platform");
|
||||
} else {
|
||||
// Only the following tests need refuser's connection backlog
|
||||
// to be saturated
|
||||
ExecutorService pumperExecutor =
|
||||
Executors.newSingleThreadExecutor(
|
||||
new ThreadFactory() {
|
||||
|
||||
@Override
|
||||
public Thread newThread(Runnable r) {
|
||||
Thread t = new Thread(r);
|
||||
t.setDaemon(true);
|
||||
t.setName("Pumper");
|
||||
return t;
|
||||
}
|
||||
});
|
||||
|
||||
pumpDone = false;
|
||||
try {
|
||||
Future<Integer> pumpFuture = pumpRefuser(pumperExecutor);
|
||||
waitPump("\nWait for initial Pump");
|
||||
|
||||
test(socketChannelFactory, CONNECT, false);
|
||||
test(socketChannelFactory, FINISH_CONNECT, false);
|
||||
|
||||
pumpDone = true;
|
||||
Integer newConn = pumpFuture.get(30, TimeUnit.SECONDS);
|
||||
log.println("Pump " + newConn + " connections.");
|
||||
} finally {
|
||||
pumperExecutor.shutdown();
|
||||
}
|
||||
}
|
||||
|
||||
test(serverSocketChannelFactory, ACCEPT);
|
||||
test(datagramChannelFactory);
|
||||
test(pipeSourceChannelFactory);
|
||||
test(pipeSinkChannelFactory);
|
||||
}
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue