jdk-sandbox: comparison test/jdk/java/net/Socket/Timeouts.java

equal deleted inserted replaced

-:b2c5d70eecf6
+:f22d38b23756
 /*
 * @test
 * @library /test/lib
 * @build jdk.test.lib.Utils
-* @run testng Timeouts
+* @run testng/timeout=180 Timeouts
 * @summary Test Socket timeouts
 */
 import java.io.Closeable;
 import java.io.IOException;
 * Test timed read where the read times out
 */
 public void testTimedRead3() throws IOException {
 withConnection((s1, s2) -> {
 s2.setSoTimeout(2000);
+long start = System.currentTimeMillis();
 try {
 s2.getInputStream().read();
 assertTrue(false);
-} catch (SocketTimeoutException expected) { }
+} catch (SocketTimeoutException expected) {
+int timeout = s2.getSoTimeout();
+checkDuration(start, timeout-100, timeout+2000);
+}
 });
 }
 /**
 * Test timed read that succeeds after a previous read has timed out
 * Test timed accept where the accept times out
 */
 public void testTimedAccept3() throws IOException {
 try (ServerSocket ss = new ServerSocket(0)) {
 ss.setSoTimeout(2000);
+long start = System.currentTimeMillis();
 try {
 Socket s = ss.accept();
 s.close();
 assertTrue(false);
-} catch (SocketTimeoutException expected) { }
+} catch (SocketTimeoutException expected) {
+int timeout = ss.getSoTimeout();
+checkDuration(start, timeout-100, timeout+2000);
+}
 }
 }
 /**
 * Test timed accept where a connection is established immediately after a
 * Test async close of a timed accept
 */
 public void testTimedAccept7() throws IOException {
 try (ServerSocket ss = new ServerSocket(0)) {
 ss.setSoTimeout(30*1000);
-scheduleClose(ss, 2000);
+long delay = 2000;
+scheduleClose(ss, delay);
+long start = System.currentTimeMillis();
 try {
 ss.accept().close();
 assertTrue(false);
-} catch (SocketException expected) { }
+} catch (SocketException expected) {
+checkDuration(start, delay-100, delay+2000);
+}
 }
 }
 /**
 * Test timed accept with the thread interrupt status set.
 try {
 Socket s = ss.accept();
 s.close();
 assertTrue(false);
 } catch (SocketTimeoutException expected) {
-// accept should have blocked for 2000ms
+// accept should have blocked for 2 seconds
-assertTrue((System.currentTimeMillis() - start) > 1800);
+int timeout = ss.getSoTimeout();
+checkDuration(start, timeout-100, timeout+2000);
 assertTrue(Thread.currentThread().isInterrupted());
 } finally {
 Thread.interrupted(); // clear interrupt status
 }
 }
 * Test interrupt of thread blocked in timed accept.
 */
 public void testTimedAccept9() throws IOException {
 try (ServerSocket ss = new ServerSocket(0)) {
 ss.setSoTimeout(4000);
-// interrupt thread after 1000ms
+// interrupt thread after 1 second
 Future<?> interrupter = scheduleInterrupt(Thread.currentThread(), 1000);
 long start = System.currentTimeMillis();
 try {
-Socket s = ss.accept();   // should block for 4000
+Socket s = ss.accept();   // should block for 4 seconds
 s.close();
 assertTrue(false);
 } catch (SocketTimeoutException expected) {
-// accept should have blocked for 4000ms
+// accept should have blocked for 4 seconds
-assertTrue((System.currentTimeMillis() - start) > 3800);
+int timeout = ss.getSoTimeout();
+checkDuration(start, timeout-100, timeout+2000);
 assertTrue(Thread.currentThread().isInterrupted());
 } finally {
 interrupter.cancel(true);
 Thread.interrupted(); // clear interrupt status
 }
 Throwable e = expectThrows(ExecutionException.class, result1::get);
 assertTrue(e.getCause() instanceof SocketTimeoutException);
 e = expectThrows(ExecutionException.class, result2::get);
 assertTrue(e.getCause() instanceof SocketTimeoutException);
-// both tasks should completed in a little over 4000ms
+// should get here in 4 seconds, not 8 seconds
-assertTrue((System.currentTimeMillis() - start) < 5000);
+int timeout = ss.getSoTimeout();
+checkDuration(start, timeout-100, timeout+2000);
 } finally {
 pool.shutdown();
 }
 }
 long start = System.currentTimeMillis();
 Future<Socket> result1 = pool.submit(ss::accept);
 Future<Socket> result2 = pool.submit(ss::accept);
-scheduleConnect(ss.getLocalSocketAddress(), 1500);
+// establish connection after 3 seconds
+scheduleConnect(ss.getLocalSocketAddress(), 3000);
 // one task should have accepted the connection, the other should
 // have completed with SocketTimeoutException
 Socket s1 = null;
 try {
 } catch (ExecutionException e) {
 assertTrue(e.getCause() instanceof SocketTimeoutException);
 }
 assertTrue((s1 != null) ^ (s2 != null));
-// both tasks should completed in a little over 4000ms
+// should get here in 4 seconds, not 7 seconds
-long duration = System.currentTimeMillis() - start;
+int timeout = ss.getSoTimeout();
-assertTrue(duration > 3800 && duration < 5000);
+checkDuration(start, timeout-100, timeout+2000);
 } finally {
 pool.shutdown();
 }
 }
 return executor.schedule(task, delay, TimeUnit.MILLISECONDS);
 } finally {
 executor.shutdown();
 }
 }
+/**
+* Check the duration of a task
+* @param start start time, in milliseconds
+* @param min minimum expected duration, in milliseconds
+* @param max maximum expected duration, in milliseconds
+* @return the duration (now - start), in milliseconds
+*/
+private static long checkDuration(long start, long min, long max) {
+long duration = System.currentTimeMillis() - start;
+assertTrue(duration >= min && duration <= max);
+return duration;
+}
 }

branch	niosocketimpl-branch
changeset 57308	f22d38b23756
parent 57305	b2c5d70eecf6
child 57309	dbd1beb994ab