forked from #450 and improved

src/main/java/org/junit/internal/runners/statements/FailOnTimeout.java

@@ -2,14 +2,21 @@
 
 import org.junit.runners.model.Statement;
 
+import java.util.concurrent.TimeUnit;
+
 public class FailOnTimeout extends Statement {
     private final Statement fOriginalStatement;
-
+    private final TimeUnit fTimeUnit;
     private final long fTimeout;
 
-    public FailOnTimeout(Statement originalStatement, long timeout) {
+    public FailOnTimeout(Statement originalStatement, long millis) {
+        this(originalStatement, millis, TimeUnit.MILLISECONDS);
+    }
+
+    public FailOnTimeout(Statement originalStatement, long timeout, TimeUnit unit) {
         fOriginalStatement = originalStatement;
         fTimeout = timeout;
+        fTimeUnit = unit;
     }
 
     @Override
@@ -23,7 +30,7 @@ public void evaluate() throws Throwable {
     private StatementThread evaluateStatement() throws InterruptedException {
         StatementThread thread = new StatementThread(fOriginalStatement);
         thread.start();
-        thread.join(fTimeout);
+        fTimeUnit.timedJoin(thread, fTimeout);
         if (!thread.fFinished) {
             thread.recordStackTrace();
         }
@@ -42,7 +49,7 @@ private void throwExceptionForUnfinishedThread(StatementThread thread)
 
     private void throwTimeoutException(StatementThread thread) throws Exception {
         Exception exception = new Exception(String.format(
-                "test timed out after %d milliseconds", fTimeout));
+                "test timed out after %d %s", fTimeout, fTimeUnit.name().toLowerCase()));
         exception.setStackTrace(thread.getRecordedStackTrace());
         throw exception;
     }

src/main/java/org/junit/rules/Timeout.java

@@ -4,45 +4,95 @@
 import org.junit.runner.Description;
 import org.junit.runners.model.Statement;
 
+import java.util.concurrent.TimeUnit;
+
 /**
  * The Timeout Rule applies the same timeout to all test methods in a class:
  *
  * <pre>
- * public static class HasGlobalTimeout {
- *  public static String log;
+ * public static class HasGlobalLongTimeout {
  *
  *  &#064;Rule
  *  public Timeout globalTimeout= new Timeout(20);
  *
  *  &#064;Test
- *  public void testInfiniteLoop1() {
- *      log+= &quot;ran1&quot;;
- *      for (;;) {
- *         }
- *     }
+ *  public void run1() throws InterruptedException {
+ *      Thread.sleep(100);
+ *  }
+ *
+ *  &#064;Test
+ *  public void run2() throws InterruptedException {
+ *      reentrantLock.lockInterruptibly();
+ *      try {
+ *         ...
+ *      } finally {
+ *         reentrantLock.unlock();
+ *      }
+ *  }
+ *
+ *  &#064;Test
+ *  public synchronized void run3() throws InterruptedException {
+ *      ...
+ *      wait();
+ *  }
  *
  *  &#064;Test
- *  public void testInfiniteLoop2() {
- *      log+= &quot;ran2&quot;;
- *      for (;;) {
- *         }
- *     }
+ *  public void run4() {
+ *      //uninterrupted code
+ *      for (;;)
+ *         ; //extremely, an infinite loop
+ *  }
  * }
  * </pre>
  *
+ * A test is running in an extra thread, and its execution is interrupted via {@link Thread#interrupt}
+ * when the timeout elapsed. This happens in interruptable I/O and locks, and methods in {@link Object}
+ * and {@link Thread} throwing {@link InterruptedException}.
+ *
  * @since 4.7
  */
 public class Timeout implements TestRule {
-    private final int fMillis;
+    private final long fTimeout;
+    private final TimeUnit fTimeUnit;
 
     /**
-     * @param millis the millisecond timeout
+     * Create a {@code Timeout} instance with the timeout specified
+     * in milliseconds.
+     * This constructor is deprecated and will be removed in the next release.
+     * Instead use {@link #Timeout(long)} or
+     * {@link #Timeout(long, java.util.concurrent.TimeUnit)}.
+     *
+     * @param millis the maximum time in milliseconds to allow the
+     * test to run before it should timeout
      */
+    @Deprecated
     public Timeout(int millis) {
-        fMillis = millis;
+        this((long) millis);
+    }
+
+    /**
+     * @param millis the millisecond timeout
+     * @since 4.11
+     */
+    public Timeout(long millis) {
+        this(millis, TimeUnit.MILLISECONDS);
+    }
+
+    /**
+     * Create a {@code Timeout} instance with the timeout specified
+     * at the unit of granularity of the provided {@code TimeUnit}.
+     *
+     * @param timeout the maximum time to allow the test to run
+     * before it should timeout
+     * @param unit the time unit for the {@code timeout}
+     * @since 4.11
+     */
+    public Timeout(long timeout, TimeUnit unit) {
+        fTimeout = timeout;
+        fTimeUnit = unit;
     }
 
     public Statement apply(Statement base, Description description) {
-        return new FailOnTimeout(base, fMillis);
+        return new FailOnTimeout(base, fTimeout, fTimeUnit);
     }
 }

src/test/java/org/junit/tests/experimental/rules/TimeoutRuleTest.java

@@ -1,46 +1,121 @@
 package org.junit.tests.experimental.rules;
 
-import static org.hamcrest.CoreMatchers.containsString;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertThat;
-
-import org.junit.Ignore;
+import org.junit.After;
+import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.TestRule;
 import org.junit.rules.Timeout;
 import org.junit.runner.JUnitCore;
 import org.junit.runner.Result;
 
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.locks.ReentrantLock;
+
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertThat;
+
 public class TimeoutRuleTest {
-    public static class HasGlobalTimeout {
-        public static String log;
+    private static final ReentrantLock run1Lock = new ReentrantLock();
+
+    private static volatile boolean run4done = false;
+
+    public static class HasGlobalLongTimeout {
+        public static final StringBuffer logger = new StringBuffer();
 
         @Rule
-        public TestRule globalTimeout = new Timeout(20);
+        public final TestRule globalTimeout = new Timeout(50L);
+
+        @Test
+        public void run1() throws InterruptedException {
+            logger.append("run1");
+            TimeoutRuleTest.run1Lock.lockInterruptibly();
+            TimeoutRuleTest.run1Lock.unlock();
+        }
+
+        @Test
+        public void run2() throws InterruptedException {
+            logger.append("run2");
+            Thread.currentThread().join();
+        }
+
+        @Test
+        public synchronized void run3() throws InterruptedException {
+            logger.append("run3");
+            wait();
+        }
 
         @Test
-        public void testInfiniteLoop1() {
-            log += "ran1";
-            for (; ; ) {
+        public void run4() {
+            logger.append("run4");
+            while (!run4done) {
             }
         }
+    }
+
+    public static class HasGlobalTimeUnitTimeout {
+        public static final StringBuffer logger = new StringBuffer();
+
+        @Rule
+        public final TestRule globalTimeout = new Timeout(50, TimeUnit.MILLISECONDS);
+
+        @Test
+        public void run1() throws InterruptedException {
+            logger.append("run1");
+            TimeoutRuleTest.run1Lock.lockInterruptibly();
+            TimeoutRuleTest.run1Lock.unlock();
+        }
+
+        @Test
+        public void run2() throws InterruptedException {
+            logger.append("run2");
+            Thread.currentThread().join();
+        }
 
         @Test
-        public void testInfiniteLoop2() {
-            log += "ran2";
-            for (; ; ) {
+        public synchronized void run3() throws InterruptedException {
+            logger.append("run3");
+            wait();
+        }
+
+        @Test
+        public void run4() {
+            logger.append("run4");
+            while (!run4done) {
             }
         }
     }
 
-    @Ignore("For gump, for now")
-    @Test(timeout = 100)
-    public void globalTimeoutAvoidsInfiniteLoop() {
-        HasGlobalTimeout.log = "";
-        Result result = JUnitCore.runClasses(HasGlobalTimeout.class);
-        assertEquals(2, result.getFailureCount());
-        assertThat(HasGlobalTimeout.log, containsString("ran1"));
-        assertThat(HasGlobalTimeout.log, containsString("ran2"));
+    @Before public void before() {
+        run4done = false;
+        run1Lock.lock();
+    }
+
+    @After public void after() {
+        run4done = true;//to make sure that the thread won't continue at run4()
+        run1Lock.unlock();
+    }
+
+    @Test
+    public void timeUnitTimeout() throws InterruptedException {
+        HasGlobalTimeUnitTimeout.logger.setLength(0);
+        Result result = JUnitCore.runClasses(HasGlobalTimeUnitTimeout.class);
+        assertEquals(4, result.getFailureCount());
+        assertThat(HasGlobalTimeUnitTimeout.logger.toString(), containsString("run1"));
+        assertThat(HasGlobalTimeUnitTimeout.logger.toString(), containsString("run2"));
+        assertThat(HasGlobalTimeUnitTimeout.logger.toString(), containsString("run3"));
+        assertThat(HasGlobalTimeUnitTimeout.logger.toString(), containsString("run4"));
+    }
+
+    @Test
+    public void longTimeout() throws InterruptedException {
+        HasGlobalLongTimeout.logger.setLength(0);
+        Result result = JUnitCore.runClasses(HasGlobalLongTimeout.class);
+        assertEquals(4, result.getFailureCount());
+        assertThat(HasGlobalLongTimeout.logger.toString(), containsString("run1"));
+        assertThat(HasGlobalLongTimeout.logger.toString(), containsString("run2"));
+        assertThat(HasGlobalLongTimeout.logger.toString(), containsString("run3"));
+        assertThat(HasGlobalLongTimeout.logger.toString(), containsString("run4"));
     }
 }