1 files changed, 123 insertions, 0 deletions
diff --git a/docs/sandbox/inoculated/src/Injection.java b/docs/sandbox/inoculated/src/Injection.java
new file mode 100644
index 000000000..6a857ef7a
--- /dev/null
+++ b/docs/sandbox/inoculated/src/Injection.java
@@ -0,0 +1,123 @@
+/*
+ * Copyright (c) 1998-2002 PARC Inc.  All rights reserved.
+ *
+ * Use and copying of this software and preparation of derivative works based
+ * upon this software are permitted.  Any distribution of this software or
+ * derivative works must comply with all applicable United States export
+ * control laws.
+ *
+ * This software is made available AS IS, and PARC Inc. makes no
+ * warranty about the software, its performance or its conformity to any
+ * specification.
+ */
+    
+import java.io.*;
+
+/** 
+ * Demonstrate technique of fault-injection 
+ * as coordinated by test driver.
+ * @author Wes Isberg
+ */
+aspect InjectingIOException { 
+    
+    // article page 43 - fault injection
+    // START-SAMPLE testing-inoculated-injectIOException Inject IOException on test driver command
+    /** the test starts when the driver starts executing */
+    pointcut testEntryPoint(TestDriver driver) :
+        target(driver) && execution(* TestDriver.startTest());
+
+    /** 
+     * The fault may be injected at the execution of any
+     * (non-static) PrinterStream  method that throws an IOException
+     */
+    pointcut testCheckPoint(PrinterStream stream) : target(stream) 
+        && execution(public * PrinterStream+.*(..) throws IOException);
+
+    /**
+     * After the method returns normally, query the
+     * test driver to see if we should instead throw
+     * an exception ("inject" the fault).
+     */
+    after (TestDriver driver, PrinterStream stream) returning 
+            throws IOException :
+            cflowbelow(testEntryPoint(driver))
+            && testCheckPoint(stream) {
+        IOException e = driver.createException(stream);
+        if (null != e) {
+            System.out.println("InjectingIOException - injecting " + e);
+            throw e;
+        }
+    }
+    /* Comment on the after advice IOException declaration:
+
+       "throws IOException" is a declaration of the advice,
+       not the pointcut.
+
+       Since the advice might throw the injected fault, it
+       must declare that it throws IOException. When advice declares
+       exceptions thrown, the compiler will emit an error if any 
+       join point is not also declared to throw an IOException.  
+
+       In this case, the testCheckPoint pointcut only picks out 
+       methods that throw IOException, so the compile will not
+       signal any errors.
+    */
+    // END-SAMPLE testing-inoculated-injectIOException
+}
+
+/** this runs the test case */
+public class Injection {
+    /** Run three print jobs, two as a test and one normally */
+    public static void main(String[] args) throws Exception {
+        Runnable r = new Runnable() {
+                public void run() { 
+                    try { new TestDriver().startTest(); } 
+                    catch (IOException e) {
+                        System.err.println("got expected injected error " + e.getMessage());
+                    }
+                }
+            };
+
+        System.out.println("Injection.main() - starting separate test thread");
+        Thread t = new Thread(r);
+        t.start();
+
+        System.out.println("Injection.main() - running test in this thread");
+        r.run();
+        t.join();
+
+        System.out.println("Injection.main() - running job normally, not by TestDriver");
+        new PrintJob().runPrintJob();
+    }
+}
+
+/** handle starting of test and determining whether to inject failure */
+class TestDriver {
+
+    /** start a new test */
+    public void startTest() throws IOException {
+        new PrintJob().runPrintJob();
+    }
+
+    /** this implementation always injects a failure */
+    public IOException createException(PrinterStream p) {
+        return new IOException(""+p);
+    }
+}
+
+//--------------------------------------- target classes 
+
+class PrintJob {
+    /** this job writes to the printer stream */
+    void runPrintJob() throws IOException {
+        new PrinterStream().write();
+    }
+}
+
+class PrinterStream {
+    /** this printer stream writes without exception */
+    public void write() throws IOException {
+        System.err.println("PrinterStream.write() - not throwing exception");
+    }
+}
+