/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

package org.openide.util;

import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.netbeans.junit.Log;
import org.netbeans.junit.NbTestCase;
import org.netbeans.junit.RandomlyFails;
import org.netbeans.modules.openide.util.DefaultMutexImplementation;

public class ReadWriteAccessTest extends NbTestCase {
    Mutex.Privileged p;
    Mutex m;



    public ReadWriteAccessTest(java.lang.String testName) {
        super(testName);
    }

    /** Sets up the test.
     */
    @Override
    protected void setUp () {
        p = new Mutex.Privileged ();
        m = new Mutex (p);
        DefaultMutexImplementation.beStrict = true;
    }
    @Override 
    protected Level logLevel() {
        return Level.FINEST;
    }

    public void testReadWriteRead() throws Exception {
        
        final Object lock = new Object();
        final Mutex.Privileged mPriv =  new Mutex.Privileged();
        final Mutex tmpMutex = new Mutex( mPriv );
        
        synchronized ( lock ) {
            mPriv.enterReadAccess();
            
            new Thread() {
                @Override
                public void run () {
                    synchronized( lock ) {
                        lock.notifyAll();
                    }
                    mPriv.enterWriteAccess();
                    synchronized ( lock ) {
                        lock.notifyAll();
                        mPriv.exitWriteAccess();
                    }
                }
            }.start();
            
            lock.wait();
                       
        }
        Thread.sleep (100);
        
        mPriv.enterReadAccess();
        
        mPriv.exitReadAccess();
        
        synchronized ( lock ) {
            mPriv.exitReadAccess();
            lock.wait();
        }
    }
    
    /** Simple test to execute read access and write access imediatelly.
     */
    public void testPostImmediatelly () {
        State s = new State ();
        
        m.postReadRequest(s);
        
        if (s.state != 1) {
            fail ("Read request not started immediatelly");
        }
        
        m.postWriteRequest (s);
        
        if (s.state != 2) {
            fail ("Write request not started immediately");
        }
    }

    /** Behaviour of postWriteRequest is defined by this test.
     */
    public void testPostWriteRequest () {
        
        State s = new State ();
        
        // first enter
        p.enterWriteAccess ();
            p.enterReadAccess ();
        
            m.postWriteRequest(s);
            
            if (s.state != 0) {
                fail ("Write request started when we are in read access");
            }
                
            p.exitReadAccess ();
            
        if (s.state != 1) {
            fail ("Write request not run when leaving read access: " + s.state);
        }
                
        // exiting
        p.exitWriteAccess ();
        
        if (s.state != 1) {
            fail ("Run more times?: " + s.state);
        }
    }    
    
    /** Behaviour of postReadRequest is defined by this test.
     */
    public void testPostReadRequest () {
        
        State s = new State ();
        
        // first enter
            p.enterWriteAccess ();
        
            m.postReadRequest(s);
            
            if (s.state != 0) {
                fail ("Read request started when we are in write access");
            }
                
            p.exitWriteAccess ();
            
            if (s.state != 1) {
                fail ("Read request not run when leaving write access: " + s.state);
            }
                
        
        if (s.state != 1) {
            fail ("Run more times?: " + s.state);
        }
    }
    
    /** Test enter from S mode to X mode *
    public void testXtoS() {
        State s = new State ();
        
        p.enterReadAccess ();
        p.enterWriteAccess ();
        s.run();
        p.exitWriteAccess();
        p.exitReadAccess();
        if (s.state != 1) {
            fail ("Run more times?: " + s.state);
        }
    }
*/

    /** Tests posting write and read requests while the SimpleMutex is held
     * in X mode and was entered in S mode as well
     */
    public void testPostWriteReadRequests() {
        State s = new State ();
        
        // first enter
        p.enterWriteAccess ();
            p.enterReadAccess ();
        
            m.postWriteRequest(s);
            
            if (s.state != 0) {
                fail ("Write request started when we are in read access");
            }
                
            m.postReadRequest(s);
            
            if (s.state != 0) {
                fail ("Read request started when we are in write access");
            }
            
            p.exitReadAccess ();
            
            if (s.state != 1) {
                fail ("Write request not run when leaving read access: " + s.state);
            }
            
        // exiting
        p.exitWriteAccess ();
        
        if (s.state != 2) {
            fail ("Read request not run when leaving write access: " + s.state);
        }
        
        consistencyCheck();
    }
       
    /** Tests simple postWriteRequest */
    public void testSimplePostWriteRequest() {
        State s = new State ();
        
        m.postWriteRequest(s);
        
        if (s.state != 1) {
            fail ("Write request not run: " + s.state);
        }
        
        consistencyCheck();
    }
    
    /** Tests simple postReadRequest */
    public void testSimplePostReadRequest() {
        State s = new State ();
        
        m.postReadRequest(s);
        
        if (s.state != 1) {
            fail ("Read request not run: " + s.state);
        }
        
        consistencyCheck();
    }
    
    // starts a new thread, after return the thread will hold lock "p" in
    // mode X for timeout milliseconds
    private static void asyncEnter(final Mutex.Privileged p, final boolean X, final long timeout) throws InterruptedException {
        asyncEnter(p, X, timeout, null);
    }

     // starts a new thread, after return the thread will hold lock "p" in
    // mode X for timeout milliseconds, the new thread execs "run" first
    private static void asyncEnter(final Mutex.Privileged p, final boolean X, final long timeout, final Runnable run) throws InterruptedException {
        final Object lock = new Object();
        
        synchronized (lock) {
            new Thread(new Runnable() {
                public void run() {
                    if (X) {
                        p.enterWriteAccess();
                    } else {
                        p.enterReadAccess();
                    }
                    
                    synchronized (lock) {
                        lock.notify();
                    }
                    
                    if (run != null) {
                        run.run();
                    }
                    
                    try {
                        Thread.sleep(timeout);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    
                    if (X) {
                        p.exitWriteAccess();
                    } else {
                        p.exitReadAccess();
                    }
                    
                }
            }).start();
            
            lock.wait();
        }
    }
    
    /** Tests enterWriteAccess while the SimpleMutex is contended in X mode by
     * another thread
     */
    public void testXContendedX() throws InterruptedException {
        asyncEnter(p, true, 2000);
        
        // first enter
        p.enterWriteAccess();
        p.exitWriteAccess();
        
        consistencyCheck();
    }
    
    /** Tests enterReadAccess while the SimpleMutex is contended in X mode by
     * another thread
     */
    public void testXContendedS() throws InterruptedException {
        asyncEnter(p, true, 2000);
        
        // first enter
        p.enterReadAccess();
        p.exitReadAccess();
        
        consistencyCheck();
    }
    
    /** Tests enterWriteAccess while the SimpleMutex is contended in S mode by
     * another thread
     */
    public void testSContendedX() throws InterruptedException {
        asyncEnter(p, false, 2000);
        
        // first enter
        p.enterWriteAccess();
        p.exitWriteAccess();
        
        consistencyCheck();
    }
    
    /** Tests enterReadAccess while the SimpleMutex is contended in S mode by
     * another thread
     */
    public void testSContendedS() throws InterruptedException {
        asyncEnter(p, false, 2000);
        
        // first enter
        p.enterReadAccess();
        p.exitReadAccess();
        
        consistencyCheck();
    }
    
    /** Tests postWriteRequest while the SimpleMutex is contended in X mode by
     * another thread
     */
    public void testXContendedPx() throws InterruptedException {
        asyncEnter(p, true, 2000);
        
        State s = new State ();
        
        m.postWriteRequest(s);
        
        if (s.state != 1) {
            fail ("Write request not run: " + s.state);
        }
        
        consistencyCheck();
    }
    
    /** Tests postReadRequest while the SimpleMutex is contended in X mode by
     * another thread
     */
    public void testXContendedPs() throws InterruptedException {
        asyncEnter(p, true, 2000);
        
        State s = new State ();
        
        m.postReadRequest(s);
        
        if (s.state != 1) {
            fail ("Read request not run: " + s.state);
        }
        
        consistencyCheck();
    }
    
    /** Tests postWriteRequest while the SimpleMutex is contended in S mode by
     * another thread
     */
    public void testSContendedPx() throws InterruptedException {
        asyncEnter(p, false, 2000);
        
        State s = new State ();
        
        m.postWriteRequest(s);
        
        if (s.state != 1) {
            fail ("Write request not run: " + s.state);
        }
        
        consistencyCheck();
    }
    
    /** Tests postReadRequest while the SimpleMutex is contended in S mode by
     * another thread
     */
    public void testSContendedPs() throws InterruptedException {
        asyncEnter(p, false, 2000);
        
        State s = new State ();
        
        m.postReadRequest(s);
        
        if (s.state != 1) {
            fail ("Write request not run: " + s.state);
        }
        
        consistencyCheck();
    }
    
    /** Tests postWriteRequest and postReadRequest while the SimpleMutex is contended in S mode by
     * another thread as well as this thread.
     */
    public void testSContendedSPsPx() throws InterruptedException {
        asyncEnter(p, false, 2000);
        
        State s = new State ();
        
        p.enterReadAccess();
        m.postReadRequest(s);
        
        if (s.state != 1) {
            fail ("Read request not run: " + s.state);
        }
        
        m.postWriteRequest(s);
        
        if (s.state != 1) {
            fail ("Write request run: " + s.state);
        }
        
        p.exitReadAccess();
        
        if (s.state != 2) {
            fail ("Write request not run: " + s.state);
        }
        
        consistencyCheck();
    }
    
    /** The SimpleMutex is held in S mode by a thread which also posted a
     * write request. Another thread tries enterWriteAccess.
     */
    public void testSPxContendedX() throws Exception {
        final State s = new State ();

        asyncEnter(p, false, 2000, new Runnable() {
            public void run() {
                try {
                    Thread.sleep(1000);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                m.postWriteRequest(s);
                if (s.state == 1) {
                    fail ("Write request run: " + s.state);
                }
            }
        });
        
        p.enterWriteAccess();
        if (s.state != 1) {
            fail ("Write request not run: " + s.state);
        }
        p.exitWriteAccess();
        
        consistencyCheck();
    }
    
    /**
     * Test case for #16577. Grab X,S and post X request,
     * the second thread waits for X, causing the mutex to be 
     * in CHAINED.
     */
    public void testXSPxContendedX() throws Exception {
        final State s = new State ();

        asyncEnter(p, true, 2000, new Runnable() {
            public void run() {
                p.enterReadAccess();
                try {
                    Thread.sleep(1000);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                m.postWriteRequest(s);
                p.exitReadAccess();
                
                if (s.state != 1) {
                    fail ("Write request not run: " + s.state);
                }
            }
        });
        
        p.enterWriteAccess();
        p.exitWriteAccess();
        
        consistencyCheck();
    }
    
    /**
     * The scenario:
     * Cast:
     *  Thread A: M.reader [X] trying to lock(L)
     *  Thread B: L owner [X] trying to enter M.read
     *  Thread C: M.reader trying to M.writeReenter on leave
     * 
     * Actions:
     *  - first let A and B reach point [X]
     *  - unfuse A so it block on lock(L)
     *  - start C, it will reach exitReadAccess and block on reenter as writer
     *  - unfuse B so it should perform its legitimate read access
     *
     * What should happen then (if SimpleMutex works OK):
     * - B unlocks L and die
     * - A locks/unlocks L, leave readAccess and die
     * - C performs its write and die
     */
    public void testStarvation68106() throws Exception {
        final Mutex.Privileged PR = new Mutex.Privileged();
        final Mutex M = new Mutex(PR);
        final Object L = new Object();
        final boolean[] done = new boolean[3];
        
        final Ticker tickX1 = new Ticker();     
        final Ticker tickX2 = new Ticker();     
        final Ticker tickX3 = new Ticker();     
        
        Thread A = new Thread("A") { public @Override void run() {
            PR.enterReadAccess();
            
            tickX1.tick();
            tickX2.waitOn();
            
            synchronized(L) {
                done[0] = true;
            }

            PR.exitReadAccess();
        }};
               
        Thread B = new Thread("B") { public @Override void run() {
            synchronized(L) {
                
                tickX2.tick();
                tickX3.tick();
                tickX1.waitOn();
                
                PR.enterReadAccess();
                done[1] = true;
                PR.exitReadAccess();
            }
        }};

        Thread C = new Thread("C") { public @Override void run() {
            PR.enterReadAccess();
            M.postWriteRequest(new Runnable() {public void run() {
                   done[2] = true;
            }});
            PR.exitReadAccess();
        }};
        
        A.start();
        tickX1.waitOn();
        // A reached point X
       
        B.start();
        tickX3.waitOn();
        // B reached point X, unlocked A so in would block on lock(L)
        
        C.start();
	Thread.sleep(100); // wait for C to perform exitReadAccess (can't
                           // tick as it will block in case of failure...)
	
        tickX1.tick();
        // push B, everything should finish after this
        
        // wait for them for a while
        A.join(2000);
        B.join(2000);
        C.join(2000);

        if (!done[0] || !done[1] || !done[2]) {
            StringBuffer sb = new StringBuffer();
            sb.append("A: "); sb.append(done[0]);
            sb.append(" B: "); sb.append(done[1]);
            sb.append(" C: "); sb.append(done[2]);
            sb.append("\n");
            dumpStrackTrace(A, sb);
            dumpStrackTrace(B, sb);
            dumpStrackTrace(C, sb);

            fail(sb.toString());
        }
    }

    
    /**
     * The scenario:
     * - Have 3 threads, A, B and C
     * - writeLock mutex1 in A
     * - writeLock mutex2 in B
     *   - postReadLock mutex2 in B
     *     - writeLock mutex1 in B
     * - writeLock mutex2 in C
     *   - readLock mutex2 in A
     * - leaveWriteLock mutex2 in B
     *
     */
    public void testStarvation49466() throws Exception {
        final Mutex.Privileged pr1 = new Mutex.Privileged();
        final Mutex mutex1 = new Mutex(pr1);
        
        final Mutex.Privileged pr2 = new Mutex.Privileged();
        final Mutex mutex2 = new Mutex(pr2);
        
        final boolean[] done = new boolean[3];

        final Ticker tick0 = new Ticker();
        final Ticker tick1 = new Ticker();
        final Ticker tick2 = new Ticker();
        final Ticker tick3 = new Ticker();
        
        Thread A = new Thread() {
            public @Override void run() {
                pr1.enterWriteAccess();
                tick0.tick();
                
                tick1.waitOn();
                
                pr2.enterReadAccess();
                done[0] = true;
                pr2.exitReadAccess();
                    
                pr1.exitWriteAccess();
            }        
        };

        // writeLock mutex1 in A
        A.start();
        tick0.waitOn();

        
        Thread B = new Thread() {
            public @Override void run() {
                pr2.enterWriteAccess();
                
                mutex2.postReadRequest(new Runnable() {
                   public void run() {
                       tick0.tick();
                       pr1.enterWriteAccess();
                       done[1] = true;
                       pr1.exitWriteAccess();
                   } 
                });

                tick0.tick();
                
                tick2.waitOn();
                
                pr2.exitWriteAccess();
            }        
        };
        
        // writeLock mutex2 in B
        B.start();
        tick0.waitOn();

/*
 * The test fails even when using only first two threads.
 *
        Thread C = new Thread() {
            public void run() {
                tick0.tick(); // have to tick in advance and wait :-(
                pr2.enterWriteAccess();
                done[2] = true;
                pr2.exitWriteAccess();
            }        
        };
        
        // writeLock mutex2 in C
        C.start();
        tick0.waitOn();
        Thread.sleep(1000); // between tick and C enqueued ...
*/
        
        // readLock mutex2 in A
        tick1.tick(); // enqueues A in mutex2's queue
        Thread.sleep(1000); // between tick and A enqueued ...
        
        // leaveWriteLock mutex2 in B
        tick2.tick();
        
        //  postReadLock mutex2 in B
        tick0.waitOn();

        // System.err.println("Do a thread dump now!");
        Thread.sleep(2000); // give them some time ...
        
        assertTrue("Thread A finished", done[0]);
        assertTrue("Thread B finished", done[1]);
        
//        assertTrue("Thread C succeed", done[2]);
    }

    
    public void testReadEnterAfterPostWriteWasContended87932() throws Exception {
        final Logger LOG = Logger.getLogger("org.openide.util.test");//testReadEnterAfterPostWriteWasContended87932");
        
        final Mutex.Privileged pr = new Mutex.Privileged();
        final Mutex mutex = new Mutex(pr);
        final Ticker tick = new Ticker();
        class WR implements Runnable {
            boolean inWrite;
            public void run() {
                inWrite = true;
                // just keep the write lock for a while
                ReadWriteAccessTest.sleep(1000);
                inWrite = false;
            }            
        }
        WR wr = new WR();
        
        class T extends Thread {
            public T() {
                super("testReadEnterAfterPostWriteWasContended87932-reader");
            }
            @Override
            public void run() {
                pr.enterReadAccess();
                tick.tick();
                
                // wait for exploitable place in SimpleMutex
                LOG.log(Level.FINE, "wait for exploitable place in SimpleMutex");

                pr.exitReadAccess();
                
                //Let the othe thread continue
                LOG.log(Level.FINE, "Let the other thread continue");
                
                // the writer gets in now, lets' give him some time.
                ReadWriteAccessTest.sleep(50);
                pr.enterReadAccess();
//                if (inWrite.get()) fail("Another reader inside while writer keeps lock");
                pr.exitReadAccess();
                
                
            }
        }
        
        Thread t = new T();
        String str = "THREAD:testReadEnterAfterPostWriteWasContended87932-reader MSG:wait for exploitable place in SimpleMutex" + 
                "THREAD:main MSG:.*Processing posted requests: 2" +
                "THREAD:testReadEnterAfterPostWriteWasContended87932-reader MSG:Let the other thread continue";
        Log.controlFlow(Logger.getLogger("org.openide.util"), null, str, 100);
        
        pr.enterReadAccess();
        t.start();
        
        tick.waitOn();
        
        
        mutex.postWriteRequest(wr);
        pr.exitReadAccess();
        
        t.join(10000);
    }
    
    private static class Ticker {
        boolean state;
        
        public void waitOn() {
            synchronized(this) {
                while (!state) {
                    try {
                        wait();
                    } catch (InterruptedException e) {
                        throw new InternalError();
                    }
                }
                state = false; // reusable
            }
        }
        
        public void tick() {
            synchronized(this) {
                state = true;
                notifyAll();
            }
        }
    }
    
    
    
    /**
     * Grab X and post S request,
     * the second thread waits for X, causing the mutex to be 
     * in CHAINED.
     */
    public void testXPsContendedX() throws Exception {
        final State s = new State ();

        asyncEnter(p, true, 2000, new Runnable() {
            public void run() {
                try {
                    Thread.sleep(1000);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                m.postReadRequest(s);
                
                if (s.state == 1) {
                    fail ("Read request run: " + s.state);
                }
            }
        });
        
        p.enterWriteAccess();
        Thread.sleep(4000);
        p.exitWriteAccess();
        
        consistencyCheck();
    }
    
    /** Checks the SimpleMutex is in the consistent state, i.e. enterWriteAccess must pass */
    private void consistencyCheck() {
        p.enterWriteAccess();
        p.exitWriteAccess();
    }
    
    public void testNoWayToDoReadAndThenWrite () {
        class R implements Runnable {
            public void run () {
                m.writeAccess (this);
            }
        }
        
        try {
            m.readAccess (new R ());
            fail ("This is supposed to throw an IllegalStateException");
        } catch (IllegalStateException ex) {
            // ok, this is expected
        }
    }

    public void testNoWayToDoWriteThenReadAndThenWrite () {
        class R implements Runnable {
            public boolean second;
            public boolean end;
            public boolean ending;
            
            public void run () {
                if (end) {
                    ending = true;
                    return;
                }
                
                if (second) {
                    end = true;
                    m.writeAccess (this);
                } else {
                    second = true;
                    m.readAccess (this);
                }
            }
        }
        R r = new R ();
        try {
            m.writeAccess (r);
            fail ("This is supposed to throw an IllegalStateException");
        } catch (IllegalStateException ex) {
            // ok, this is expected
            assertTrue ("We were in the write access section", r.second);
            assertTrue ("We were before the writeAcess(this)", r.end);
            assertFalse ("We never reached ending", r.ending);
        }
    }
    
    public void testIsOrIsNotInReadOrWriteAccess () {
        new ReadWriteChecking ("No r/w", Boolean.FALSE, Boolean.FALSE).run ();
        m.readAccess (new ReadWriteChecking ("r but no w", Boolean.TRUE, Boolean.FALSE));
        m.writeAccess (new ReadWriteChecking ("w but no r", Boolean.FALSE, Boolean.TRUE));
        m.readAccess (new Runnable () {
            public void run () {
                m.postReadRequest (new ReadWriteChecking ("+r -w", Boolean.TRUE, Boolean.FALSE));
            }
        });
        m.readAccess (new Runnable () {
            public void run () {
                m.postWriteRequest (new ReadWriteChecking ("-r +w", Boolean.FALSE, Boolean.TRUE));
            }
        });
        m.writeAccess (new Runnable () {
            public void run () {
                m.postReadRequest (new ReadWriteChecking ("+r -w", Boolean.TRUE, Boolean.FALSE));
            }
        });
        m.writeAccess (new Runnable () {
            public void run () {
                m.postWriteRequest (new ReadWriteChecking ("-r +w", Boolean.FALSE, Boolean.TRUE));
            }
        });
        
        // write->read->test (downgrade from write to read)
        m.writeAccess (new Runnable () {
            public boolean second;
            
            public void run () {
                if (!second) {
                    second = true;
                    m.readAccess (this);
                    return;
                }
                
                class P implements Runnable {
                    public boolean exec;
                    public void run () {
                        exec = true;
                    }
                }
                P r = new P ();
                P w = new P ();
                m.postWriteRequest (w);
                m.postReadRequest (r);
                assertFalse ("Writer not executed", w.exec);
                assertFalse ("Reader not executed", r.exec);
                
                m.readAccess (new ReadWriteChecking ("+r +w", Boolean.TRUE, Boolean.TRUE));
            }
        });
        
        new ReadWriteChecking ("None at the end", Boolean.FALSE, Boolean.FALSE).run ();
    }

    // [pnejedly:] There was an attempt to fix Starvation68106 by allowing read
    // enter while SimpleMutex is currently in CHAIN mode, but that's wrong, as it can
    // be CHAIN/W (write granted, readers waiting). Let's cover this with a test.
    @RandomlyFails // NB-Core-Build #8070: B finished after unblocking M
    public void testReaderCannotEnterWriteChainedMutex() throws Exception {
        final Mutex.Privileged PR = new Mutex.Privileged();
        final Mutex M = new Mutex(PR);
        final boolean[] done = new boolean[2];
        
        final Ticker tickX1 = new Ticker();     
        final Ticker tickX2 = new Ticker();     
        final Ticker tickX3 = new Ticker();     
        
        PR.enterWriteAccess();
        
        Thread A = new Thread("A") { public @Override void run() {
            PR.enterReadAccess();
            done[0] = true;
            PR.exitReadAccess();
        }};
               
        Thread B = new Thread("B") { public @Override void run() {
            PR.enterReadAccess();
            done[1] = true;
            PR.exitReadAccess();
        }};

        A.start();
        Thread.sleep(100); // wait for A to chain in M
        
        B.start();
        Thread.sleep(100); // B should chain as well
        
        assertFalse ("B should chain-wait", done[1]);
        
        // final cleanup and consistency check:
        PR.exitWriteAccess();
        A.join(1000);
        B.join(1000);
        assertTrue("A finished after unblocking M", done[0]);
        assertTrue("B finished after unblocking M", done[1]);
    }
    
    private void exceptionsReporting(final Throwable t) throws Exception {
        final IOException e1 = new IOException();
        final Mutex mm = m;
        final Runnable secondRequest = new Runnable() {
            public void run() {
                if (t instanceof RuntimeException) {
                    throw (RuntimeException)t;
                } else {
                    throw (Error)t;
                }
            }
        };
        Mutex.ExceptionAction<Object> firstRequest = new Mutex.ExceptionAction<Object>() {
            public Object run () throws Exception {
                mm.postWriteRequest(secondRequest);
                throw e1;
            }
        };
        try {
            m.readAccess(firstRequest);
        } catch (MutexException mu) {
            Exception e = mu.getException();
            assertEquals("IOException correctly reported", e, e1);
            return;
        } catch (Throwable e) {
            fail("a problem in postWriteRequest() should not swallow any " +
                    "exception thrown in readAccess() because that might be " +
                    "the cause of the problem. "+e.toString());
        }
        fail("should never get here");
    }

    public void testThrowingAssertionErrorInSpecialCase() throws Exception {
        exceptionsReporting(new AssertionError());
    }
    
    public void testThrowingRuntimeExceptionInSpecialCase() throws Exception {
        exceptionsReporting(new RuntimeException());
    } 

    private void dumpStrackTrace(Thread thread, StringBuffer sb) throws IllegalAccessException, InvocationTargetException {
        sb.append("StackTrace for thread: " + thread.getName() + "\n");

        StackTraceElement[] arr = thread.getStackTrace();

        for (int i = 0; i < arr.length; i++) {
            sb.append(arr[i].toString());
            sb.append("\n");
        }
    }
    
    private class ReadWriteChecking implements Runnable {
        public Boolean read;
        public Boolean write;
        public String msg;

        public ReadWriteChecking (String msg, Boolean read, Boolean write) {
            assertNotNull ("Msg cannot be null", msg);
            this.msg = msg;
            this.read = read;
            this.write = write;
        }

        @Override
        protected void finalize () {
            assertNull ("Run method was not called!", msg);
        }

        public void run () {
            if (write != null) assertEquals (msg, write.booleanValue (), m.isWriteAccess ());
            if (read != null) assertEquals (msg, read.booleanValue (), m.isReadAccess ());
            msg = null;
        }
    }
    
    
    private static class State implements Runnable {
        public int state;

        public void run () {
            state++;
        }
        
    } // end of State            
    
    private static final void sleep(long ms) {
        try {
            Thread.sleep(ms);
        } catch (InterruptedException ex) {
            ex.printStackTrace();
        }
    }

    /** Test that interrupted flag of thread entering SimpleMutex is not eaten in
     * SimpleMutex.QueueCell.sleep.
     * - enter read access in main thread
     * - start another thread which tries to aquire write access
     * - interrupt that thread
     * - wait until thread is stopped at wait() in SimpleMutex.QueueCell.sleep
     * - exit read access to release waiting thread
     * - check interrupted flag is set
     */
    public void testInterruptedException129003() throws InterruptedException {
        final AtomicBoolean interrupted = new AtomicBoolean(false);
        p.enterReadAccess();
        Thread enteringThread = new Thread("Entering thread") {
            @Override
            public void run() {
                p.enterWriteAccess();
                interrupted.set(Thread.interrupted());
                p.exitWriteAccess();
            }
        };
        enteringThread.start();
        enteringThread.interrupt();
        // let enteringThread reach wait() in SimpleMutex.QueueCell.sleep
        while(!enteringThread.getState().equals(Thread.State.WAITING)) {
            Thread.sleep(100);
        }
        p.exitReadAccess();
        enteringThread.join();
        assertTrue("Interrupted thread entering SimpleMutex should be set as interrupted.", interrupted.get());
    }
}
