package org.apidesign.javamonitorflaws;

 import java.beans.PropertyChangeEvent;

 import java.beans.PropertyChangeListener;

 import org.netbeans.junit.NbTestCase;

 public class CacheTest extends NbTestCase {

     public CacheTest(String n) {

         super(n);

     }

     @Override

     protected int timeOut() {

         return 2000;

     }

     /**

      * To simulate deadlock between the cache's setMultiply method and

      * ToDeadlock's own lock. The root cause is that setMultiply is calling

      * foreign code while holding the caches's <code>this</code> lock:

 Thread Test Watch Dog: testDeadlockWithSetter

   org.apidesign.javamonitorflaws.MultiplyCache.setMultiply:19

   org.apidesign.javamonitorflaws.CacheTest$1ToDeadlock.assertMultiplyByTen:40

   org.apidesign.javamonitorflaws.CacheTest.testDeadlockWithSetter:50

   sun.reflect.NativeMethodAccessorImpl.invoke0:-2

   sun.reflect.NativeMethodAccessorImpl.invoke:39

   sun.reflect.DelegatingMethodAccessorImpl.invoke:25

   java.lang.reflect.Method.invoke:597

   junit.framework.TestCase.runTest:168

   org.netbeans.junit.NbTestCase.access$200:84

   org.netbeans.junit.NbTestCase$2.doSomething:328

   org.netbeans.junit.NbTestCase$1Guard.run:265

   java.lang.Thread.run:619

 Thread to deadlock

   org.apidesign.javamonitorflaws.CacheTest$1ToDeadlock.assertMultiplyByTen:40

   org.apidesign.javamonitorflaws.CacheTest$1ToDeadlock.propertyChange:36

   java.beans.PropertyChangeSupport.firePropertyChange:339

   java.beans.PropertyChangeSupport.firePropertyChange:276

   java.beans.PropertyChangeSupport.firePropertyChange:297

   org.apidesign.javamonitorflaws.MultiplyCache.setMultiply:21

   org.apidesign.javamonitorflaws.CacheTest$1ToDeadlock.run:28

   java.lang.Thread.run:619

      */

     public void testDeadlockWithSetter() throws Exception {

         if (Boolean.getBoolean("no.failures")) return;

         final CacheToTest cache = new MultiplyCache();

         class ToDeadlock implements Runnable, PropertyChangeListener {

             int value;

             public void run() {

                 cache.setMultiply(10);

             }

             public void propertyChange(PropertyChangeEvent evt) {

                 try {

                     Thread.sleep(500);

                 } catch (InterruptedException ex) {

                     // ok

                 }

                 changeMultiplyToSeven();

             }

             public synchronized void changeMultiplyToSeven() {

                 cache.setMultiply(7);

             }

         }

         ToDeadlock toDeadlock = new ToDeadlock();

         cache.addPropertyChangeListener(toDeadlock);

         Thread t = new Thread(toDeadlock, "to deadlock");

         t.start();

         Thread.sleep(100);

         toDeadlock.changeMultiplyToSeven();

     }

     /** Shows that one can deadlock with the cache's API even the API

      * is locally correctly synchronized.

 Thread Test Watch Dog: testDeadlockWithTheAPICacheItself

   org.apidesign.javamonitorflaws.Cache.get:16

   org.apidesign.javamonitorflaws.CacheTest$2ToDeadlock.assertMultiplyByTen

   org.apidesign.javamonitorflaws.CacheTest.testDeadlockViaAPI:112

   java.lang.reflect.Method.invoke:597

   org.netbeans.junit.NbTestCase.access$200:84

   org.netbeans.junit.NbTestCase$2.doSomething:328

   org.netbeans.junit.NbTestCase$1Guard.run:265

   java.lang.Thread.run:619

 Thread Deadlock using API

   org.apidesign.javamonitorflaws.CacheTest$2ToDeadlock.assertMultiplyByTen

   org.apidesign.javamonitorflaws.CacheTest$2ToDeadlock.propertyChange:98

   java.beans.PropertyChangeSupport.firePropertyChange:339

   java.beans.PropertyChangeSupport.firePropertyChange:276

   java.beans.PropertyChangeSupport.firePropertyChange:297

   org.apidesign.javamonitorflaws.MultiplyCache.setMultiply:21

   org.apidesign.javamonitorflaws.CacheTest$2ToDeadlock.run:90

   java.lang.Thread.run:619

      */

     public void testDeadlockViaAPI() throws Exception {

         if (Boolean.getBoolean("no.failures")) return;

         testDeadlockViaAPI(new MultiplyCache());

     }

     // BEGIN: monitor.pitfalls.block.propertychange

     private static void testDeadlockViaAPI(final CacheToTest cache)

     throws Exception {

         class ToDeadlock implements Runnable, PropertyChangeListener {

             int lastMultiply;

             public void run() {

                 cache.setMultiply(10);

             }

             public void propertyChange(PropertyChangeEvent evt) {

                 try {

                     storeMultiply();

                 } catch (InterruptedException ex) {

                     // ok

                 }

             }

             private synchronized void storeMultiply()

             throws InterruptedException {

                 lastMultiply = cache.getMultiply();

                 // simulates "starvation"

                 wait();

             }

             public void assertMultiplyByTen() {

             }

         }

         ToDeadlock toDeadlock = new ToDeadlock();

         cache.addPropertyChangeListener(toDeadlock);

         Thread t = new Thread(toDeadlock, "Deadlock using API");

         t.start();

         Thread.sleep(100);

         // BEGIN: monitor.pitfalls.brokencall

         int value =  cache.get("123");

         assertEquals("3*10=30", 30, value);

         // END: monitor.pitfalls.brokencall

     }

     // END: monitor.pitfalls.block.propertychange

     public void testDeadlockViaAPIWithCacheOK() throws Exception {

         testDeadlockViaAPI(new MultiplyCacheOK());

     }

     static interface CacheToTest {

         public Integer get(String key);

         public void setMultiply(int m);

         public int getMultiply();

         public void addPropertyChangeListener(PropertyChangeListener l);

         public void removePropertyChangeListener(PropertyChangeListener l);

     }

 }