Removed {TimeOutDuringTesting}

Bruce Eckel · Bruce Eckel · commit 85ff83410f82 · 2016-07-07T15:12:55.000-06:00
diff --git a/polymorphism/Frog.java b/polymorphism/Frog.java
@@ -3,6 +3,7 @@
 // We make no guarantees that this code is fit for any purpose.
 // Visit http://mindviewinc.com/Books/OnJava/ for more book information.
 // Cleanup and inheritance
+// {main: polymorphism.Frog}
 package polymorphism;
 
 class Characteristic {
diff --git a/standardio/Echo.java b/standardio/Echo.java
@@ -3,12 +3,13 @@
 // We make no guarantees that this code is fit for any purpose.
 // Visit http://mindviewinc.com/Books/OnJava/ for more book information.
 // How to read from standard input
-// {TimeOutDuringTesting}
 import java.io.*;
+import onjava.TimedAbort;
 
 public class Echo {
   public static void
   main(String[] args) throws IOException {
+    new TimedAbort(4);
     BufferedReader stdin = new BufferedReader(
       new InputStreamReader(System.in));
     String s;
diff --git a/threads/AtomicEvenSupplier.java b/threads/AtomicEvenSupplier.java
@@ -3,9 +3,9 @@
 // We make no guarantees that this code is fit for any purpose.
 // Visit http://mindviewinc.com/Books/OnJava/ for more book information.
 // Atomic classes are occasionally useful in regular code
-// {TimeOutDuringTesting}
 // {IgnoreOutput} // No output validation
 import java.util.concurrent.atomic.*;
+import onjava.TimedAbort;
 
 public class AtomicEvenSupplier extends IntSupplier {
   private AtomicInteger currentEvenValue =
@@ -15,6 +15,7 @@ public int next() {
     return currentEvenValue.addAndGet(2);
   }
   public static void main(String[] args) {
+    new TimedAbort(4);
     EvenChecker.test(new AtomicEvenSupplier());
   }
 }
diff --git a/threads/AtomicityTest.java b/threads/AtomicityTest.java
@@ -2,8 +2,8 @@
 // (c)2016 MindView LLC: see Copyright.txt
 // We make no guarantees that this code is fit for any purpose.
 // Visit http://mindviewinc.com/Books/OnJava/ for more book information.
-// {TimeOutDuringTesting}
 import java.util.concurrent.*;
+import onjava.TimedAbort;
 
 public class AtomicityTest implements Runnable {
   private int i = 0;
@@ -15,6 +15,7 @@ public void run() {
       evenIncrement();
   }
   public static void main(String[] args) {
+    new TimedAbort(4);
     ExecutorService es = Executors.newCachedThreadPool();
     AtomicityTest at = new AtomicityTest();
     es.execute(at);
diff --git a/threads/CaptureUncaughtException.java b/threads/CaptureUncaughtException.java
@@ -2,8 +2,8 @@
 // (c)2016 MindView LLC: see Copyright.txt
 // We make no guarantees that this code is fit for any purpose.
 // Visit http://mindviewinc.com/Books/OnJava/ for more book information.
-// {TimeOutDuringTesting}
 import java.util.concurrent.*;
+import onjava.TimedAbort;
 
 class ExceptionThread2 implements Runnable {
   @Override
@@ -40,6 +40,7 @@ public Thread newThread(Runnable r) {
 
 public class CaptureUncaughtException {
   public static void main(String[] args) {
+    new TimedAbort(4);
     ExecutorService exec = Executors.newCachedThreadPool(
       new HandlerThreadFactory());
     exec.execute(new ExceptionThread2());
diff --git a/threads/CriticalSection.java b/threads/CriticalSection.java
@@ -2,7 +2,6 @@
 // (c)2016 MindView LLC: see Copyright.txt
 // We make no guarantees that this code is fit for any purpose.
 // Visit http://mindviewinc.com/Books/OnJava/ for more book information.
-// {TimeOutDuringTesting}
 // (Behavior may have changed in Java 8)
 // Synchronizing blocks instead of entire methods. Also
 // demonstrates protection of a non-thread-safe class
@@ -11,6 +10,7 @@
 import java.util.concurrent.*;
 import java.util.concurrent.atomic.*;
 import java.util.*;
+import onjava.TimedAbort;
 
 class Pair { // Not thread-safe
   private int x, y;
@@ -139,6 +139,7 @@ public class CriticalSection {
     System.exit(0);
   }
   public static void main(String[] args) {
+    new TimedAbort(4);
     PairManager
       pman1 = new PairManager1(),
       pman2 = new PairManager2();
diff --git a/threads/EvenSupplier.java b/threads/EvenSupplier.java
@@ -3,7 +3,7 @@
 // We make no guarantees that this code is fit for any purpose.
 // Visit http://mindviewinc.com/Books/OnJava/ for more book information.
 // When threads collide
-// {TimeOutDuringTesting} 
+import onjava.TimedAbort;
 
 public class EvenSupplier extends IntSupplier {
   private int currentEvenValue = 0;
@@ -14,6 +14,7 @@ public int next() {
     return currentEvenValue;
   }
   public static void main(String[] args) {
+    new TimedAbort(4);
     EvenChecker.test(new EvenSupplier());
   }
 }
diff --git a/threads/MutexEvenSupplier.java b/threads/MutexEvenSupplier.java
@@ -3,9 +3,9 @@
 // We make no guarantees that this code is fit for any purpose.
 // Visit http://mindviewinc.com/Books/OnJava/ for more book information.
 // Preventing thread collisions with mutexes
-// {TimeOutDuringTesting}
 // {IgnoreOutput} // No output validation
 import java.util.concurrent.locks.*;
+import onjava.TimedAbort;
 
 public class MutexEvenSupplier extends IntSupplier {
   private int currentEvenValue = 0;
@@ -23,6 +23,7 @@ public int next() {
     }
   }
   public static void main(String[] args) {
+    new TimedAbort(4);
     EvenChecker.test(new MutexEvenSupplier());
   }
 }
diff --git a/threads/SettingDefaultHandler.java b/threads/SettingDefaultHandler.java
@@ -2,11 +2,12 @@
 // (c)2016 MindView LLC: see Copyright.txt
 // We make no guarantees that this code is fit for any purpose.
 // Visit http://mindviewinc.com/Books/OnJava/ for more book information.
-// {TimeOutDuringTesting}
 import java.util.concurrent.*;
+import onjava.TimedAbort;
 
 public class SettingDefaultHandler {
   public static void main(String[] args) {
+    new TimedAbort(4);
     Thread.setDefaultUncaughtExceptionHandler(
       new MyUncaughtExceptionHandler());
     ExecutorService es = Executors.newCachedThreadPool();
diff --git a/threads/SynchronizedEvenSupplier.java b/threads/SynchronizedEvenSupplier.java
@@ -3,8 +3,8 @@
 // We make no guarantees that this code is fit for any purpose.
 // Visit http://mindviewinc.com/Books/OnJava/ for more book information.
 // Simplifying mutexes with the synchronized keyword
-// {TimeOutDuringTesting}
 // {IgnoreOutput} // No output validation
+import onjava.TimedAbort;
 
 public class
 SynchronizedEvenSupplier extends IntSupplier {
@@ -17,6 +17,7 @@ public synchronized int next() {
     return currentEvenValue;
   }
   public static void main(String[] args) {
+    new TimedAbort(4);
     EvenChecker.test(new SynchronizedEvenSupplier());
   }
 }

Original file line number	Diff line number	Diff line change
`@@ -3,9 +3,9 @@`
`3`	`3`	`// We make no guarantees that this code is fit for any purpose.`
`4`	`4`	`// Visit http://mindviewinc.com/Books/OnJava/ for more book information.`
`5`	`5`	`// Atomic classes are occasionally useful in regular code`
`6`		`-// {TimeOutDuringTesting}`
`7`	`6`	`// {IgnoreOutput} // No output validation`
`8`	`7`	`import java.util.concurrent.atomic.*;`
	`8`	`+import onjava.TimedAbort;`
`9`	`9`
`10`	`10`	`public class AtomicEvenSupplier extends IntSupplier {`
`11`	`11`	`private AtomicInteger currentEvenValue =`
`@@ -15,6 +15,7 @@ public int next() {`
`15`	`15`	`return currentEvenValue.addAndGet(2);`
`16`	`16`	`}`
`17`	`17`	`public static void main(String[] args) {`
	`18`	`+ new TimedAbort(4);`
`18`	`19`	`EvenChecker.test(new AtomicEvenSupplier());`
`19`	`20`	`}`
`20`	`21`	`}`
Original file line number	Diff line number	Diff line change
`@@ -3,7 +3,7 @@`
`3`	`3`	`// We make no guarantees that this code is fit for any purpose.`
`4`	`4`	`// Visit http://mindviewinc.com/Books/OnJava/ for more book information.`
`5`	`5`	`// When threads collide`
`6`		`-// {TimeOutDuringTesting}`
	`6`	`+import onjava.TimedAbort;`
`7`	`7`
`8`	`8`	`public class EvenSupplier extends IntSupplier {`
`9`	`9`	`private int currentEvenValue = 0;`
`@@ -14,6 +14,7 @@ public int next() {`
`14`	`14`	`return currentEvenValue;`
`15`	`15`	`}`
`16`	`16`	`public static void main(String[] args) {`
	`17`	`+ new TimedAbort(4);`
`17`	`18`	`EvenChecker.test(new EvenSupplier());`
`18`	`19`	`}`
`19`	`20`	`}`
Original file line number	Diff line number	Diff line change
`@@ -3,8 +3,8 @@`
`3`	`3`	`// We make no guarantees that this code is fit for any purpose.`
`4`	`4`	`// Visit http://mindviewinc.com/Books/OnJava/ for more book information.`
`5`	`5`	`// Simplifying mutexes with the synchronized keyword`
`6`		`-// {TimeOutDuringTesting}`
`7`	`6`	`// {IgnoreOutput} // No output validation`
	`7`	`+import onjava.TimedAbort;`
`8`	`8`
`9`	`9`	`public class`
`10`	`10`	`SynchronizedEvenSupplier extends IntSupplier {`
`@@ -17,6 +17,7 @@ public synchronized int next() {`
`17`	`17`	`return currentEvenValue;`
`18`	`18`	`}`
`19`	`19`	`public static void main(String[] args) {`
	`20`	`+ new TimedAbort(4);`
`20`	`21`	`EvenChecker.test(new SynchronizedEvenSupplier());`
`21`	`22`	`}`
`22`	`23`	`}`