<change id="Mutex.Wrapper">

        <api name="util"/>

        <summary>Mutex made pluggable</summary>

        <version major="7" minor="10"/>

        <date day="7" month="1" year="2008"/>

        <author login="mkubec"/>

        <compatibility addition="yes"/>

        <description>

            <p>

                Added <a href="@TOP@/org/openide/util/Mutex.Wrapper.html">Mutex.Wrapper</a>

                that allows creators of some mutex to intercept and wrap posted actions

                with custom code.

            </p>

        </description> 

        <class package="org.openide.util" name="Mutex"/>

        <issue number="123832"/>

    </change>

    /** @param privileged can enter privileged states of this Mutex

     *  @param wrapper a factory that allows Runnables from API to be wrapped into different onces

     * @since 7.12

     */

    public Mutex(Privileged privileged, Wrapper wrapper) {

        if (privileged == null) {

            throw new IllegalArgumentException("privileged == null"); //NOI18N

        } else {

            init(new InternalLock());

            privileged.setParent(this);

        }

    }

    /** Factory to wrap runnables into custom ones. This can be used 

     * to always do some action before and after a runnable passed to a 

     * mutex method is executed.

     * 

     * @since 7.12

     */

    public static interface Wrapper {

        /** Creates a custom runnable that is supposed to wrap those 

         * provided by mutex API methods.

         * 

         * @param run runnable to wrap

         * @return a custom runnable to execute custom pre and/or post action

         */

        public Runnable wrap(Runnable run);

    }

/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

 *

 * Copyright 1997-2007 Sun Microsystems, Inc. All rights reserved.

 *

 * The contents of this file are subject to the terms of either the GNU

 * General Public License Version 2 only ("GPL") or the Common

 * Development and Distribution License("CDDL") (collectively, the

 * "License"). You may not use this file except in compliance with the

 * License. You can obtain a copy of the License at

 * http://www.netbeans.org/cddl-gplv2.html

 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the

 * specific language governing permissions and limitations under the

 * License.  When distributing the software, include this License Header

 * Notice in each file and include the License file at

 * nbbuild/licenses/CDDL-GPL-2-CP.  Sun designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Sun in the GPL Version 2 section of the License file that

 * accompanied this code. If applicable, add the following below the

 * License Header, with the fields enclosed by brackets [] replaced by

 * your own identifying information:

 * "Portions Copyrighted [year] [name of copyright owner]"

 *

 * Contributor(s):

 *

 * The Original Software is NetBeans. The Initial Developer of the Original

 * Software is Sun Microsystems, Inc. Portions Copyright 1997-2006 Sun

 * Microsystems, Inc. All Rights Reserved.

 *

 * If you wish your version of this file to be governed by only the CDDL

 * or only the GPL Version 2, indicate your decision by adding

 * "[Contributor] elects to include this software in this distribution

 * under the [CDDL or GPL Version 2] license." If you do not indicate a

 * single choice of license, a recipient has the option to distribute

 * your version of this file under either the CDDL, the GPL Version 2 or

 * to extend the choice of license to its licensees as provided above.

 * However, if you add GPL Version 2 code and therefore, elected the GPL

 * Version 2 license, then the option applies only if the new code is

 * made subject to such option by the copyright holder.

 */

package org.openide.util;

import junit.framework.Test;

import org.netbeans.junit.NbTestCase;

import org.netbeans.junit.NbTestSuite;

public class MutexWrapTest extends NbTestCase implements Mutex.Wrapper {

    Mutex.Privileged p;

    Mutex m;

    ThreadLocal<Object> IN = new ThreadLocal<Object>();

    public MutexWrapTest(java.lang.String testName) {

        super(testName);

    }

    public static Test suite() {

        NbTestSuite suite = new NbTestSuite(MutexWrapTest.class);

        return suite;

    }

    /** Sets up the test.

     */

    @Override

    protected void setUp () {

        p = new Mutex.Privileged ();

        m = new Mutex (p, this);

    }

    public void testRead() throws Exception {

        A arg = new A();

        Object ret = m.readAccess(arg);

        assertEquals("Return type is ok", arg, ret);

    }

    public void testWrite() throws Exception {

        A arg = new A();

        Object ret = m.writeAccess(arg);

        assertEquals("Return type is ok", arg, ret);

    }

    public void testExRead() throws Exception {

        E arg = new E();

        Object ret = m.readAccess(arg);

        assertEquals("Return type is ok", arg, ret);

    }

    public void testExWrite() throws Exception {

        E arg = new E();

        Object ret = m.writeAccess(arg);

        assertEquals("Return type is ok", arg, ret);

    }

    public void testPostRead() throws Exception {

        R arg = new R();

        m.postReadRequest(arg);

        assertTrue("Executed", arg.exec);

    }

    public void testPostReadFromWrite() throws Exception {

        R arg = new R();

        Del del = new Del();

        del.read = arg;

        m.writeAccess(del);

        assertTrue("Executed", arg.exec);

    }

    public void testPostWrite() throws Exception {

        R arg = new R();

        m.postWriteRequest(arg);

        assertTrue("Executed", arg.exec);

    }

    public void testPostWriteFromRead() throws Exception {

        R arg = new R();

        Del del = new Del();

        del.write = arg;

        m.readAccess(del);

        assertTrue("Executed", arg.exec);

    }

    public Runnable wrap(final Runnable run) {

        return new Runnable() {

            public void run() {

                Object prev = IN.get();

                IN.set(MutexWrapTest.this);

                try {

                    run.run();

                } finally {

                    IN.set(prev);

                }

                assertFalse("No read", m.isReadAccess());

                assertFalse("No write", m.isWriteAccess());

            }

        };

    }

    private class A implements Mutex.Action<Object> {

        boolean exec;

        public Object run() {

            exec = true;

            assertEquals("I am wrapped", MutexWrapTest.this, IN.get());

            return this;

        }

    }

    private class E implements Mutex.ExceptionAction<Object> {

        boolean exec;

        public Object run() {

            exec = true;

            assertEquals("I am wrapped", MutexWrapTest.this, IN.get());

            return this;

        }

    }

    private class R implements Runnable {

        boolean exec;

        public void run() {

            exec = true;

            assertEquals("I am wrapped", MutexWrapTest.this, IN.get());

        }

    }

    private class Del implements Runnable {

        Runnable write;

        Runnable read;

        public void run() {

            if (write != null) {

                m.writeAccess(write);

            }

            if (read != null) {

                m.writeAccess(read);

            }

        }

    }

}