import java.lang.ref.Reference;

import java.util.concurrent.atomic.AtomicBoolean;

import org.openide.util.lookup.implspi.CallbackReferencesSupport;

        private static final AtomicBoolean registered = new AtomicBoolean(false);

        private final CallbackReferencesSupport callbackSupport;

        @Override

        protected final void finalize() throws Throwable {

            callbackSupport.notifyFinalized();

            super.finalize();

        }

        private static final class SupportProvider implements CallbackReferencesSupport.ReferenceSupportProvider {

            @Override

            public CallbackReferencesSupport getSupport(Reference reference) {

                return ((ReferenceToResult) reference).callbackSupport;

            }

        }

/*

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

 *

 * Copyright 2015 Oracle and/or its affiliates. All rights reserved.

 *

 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.

 * Other names may be trademarks of their respective owners.

 *

 * 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.  Oracle designates this

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

 * by Oracle 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]"

 *

 * 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.

 *

 * Contributor(s):

 *

 * Portions Copyrighted 2015 Sun Microsystems, Inc.

 */

package org.openide.util.lookup.implspi;

import java.lang.ref.Reference;

import java.lang.ref.ReferenceQueue;

import java.lang.ref.WeakReference;

import java.util.HashMap;

import java.util.Map;

import java.util.logging.Level;

import java.util.logging.Logger;

/**

 * Support class for building callback references. Callback references are able

 * to execute a dedicated callback when the object the reference refers to, becomes unreachable.

 * <p>

 * Do not use this class, unless you know well what you're doing. Use rather

 * <code>org.openide.util.CallbackReferences</code> instead.

 * <p>

 * <b>Usage:</b>

 * <ol>

 * <li>Create new CallbackReferencesSupport(Runnable) with the desired callback,

 *     or new CallbackReferencesSupport() and set the callback before the reference

 *     object can become unreachable.</li>

 * <li>Create the desired reference with getReferenceQueue().

 *     It's important that there is one reference instance per one

 *     CallbackReferencesSupport instance.</li>

 * <li>Override the reference implementation's finalize method and call

 *     notifyFinalized() in it.</li>

 * <li>Register the reference class with the callback support provider via

 *     addReferenceSupportProvider()</li>

 * </ol>

 * 

 * @author Martin Entlicher

 * @since 8.34

 * @see org.openide.util.CallbackReferences

 */

public final class CallbackReferencesSupport {

    private static final Logger LOGGER = Logger.getLogger(CallbackReferencesSupport.class.getName());

    private static Reference<ReferenceQueue> activeReferenceQueue = new WeakReference<ReferenceQueue>(null);

    private static long activeRefsCount = 0l;

    private static final Map<Class<? extends Reference>, ReferenceSupportProvider> supportProvidersMap = new HashMap<Class<? extends Reference>, ReferenceSupportProvider>();

    private final ReferenceQueue callbackRefQueue;  // Need to hold the reference so that it's not GC'ed prematurely

    Runnable callback;

    /**

     * Gets the active reference queue.

     * @return the singleton queue

     */

    private static synchronized ReferenceQueue<Object> queue() {

        ReferenceQueue rq = activeReferenceQueue.get();

        if (rq == null) {

            rq = new ReferenceQueue();

            activeReferenceQueue = new WeakReference<ReferenceQueue>(rq);

            Daemon.ping();

        }

        return rq;

    }

    /**

     * Register a reference support provider. We need a way how to get the

     * instance of {@link CallbackReferencesSupport} associated with the

     * Reference when the reference is cleared by GC.

     * @param refClass The class type of the reference.

     * @param supportProvider The provider that knows how to retrieve the support from the reference of this class type.

     */

    public static void addReferenceSupportProvider(Class<? extends Reference> refClass, ReferenceSupportProvider supportProvider) {

        synchronized (supportProvidersMap) {

            supportProvidersMap.put(refClass, supportProvider);

        }

    }

    private static CallbackReferencesSupport getSupport(Reference ref) {

        Class refClass = ref.getClass();

        ReferenceSupportProvider rsp = null;

        synchronized (supportProvidersMap) {

            for (Map.Entry<Class<? extends Reference>, ReferenceSupportProvider> entry : supportProvidersMap.entrySet()) {

                if (entry.getKey().isAssignableFrom(refClass)) {

                    rsp = entry.getValue();

                    break;

                }

            }

        }

        if (rsp != null) {

            return rsp.getSupport(ref);

        } else {

            return null;

        }

    }

    private static Runnable checkCallback(Runnable callback) {

        if (callback == null) {

            throw new NullPointerException("The callback should not be null."); // NOI18N

        }

        return callback;

    }

    /**

     * Creates a new empty callback support, one instance to be used with one {@link Reference}.

     * It's necessary to set the callback runnable via

     * {@link #setCallback(java.lang.Runnable)} before the associated reference

     * is cleared.

     */

    public CallbackReferencesSupport() {

        this(null, queue());

    }

    /**

     * Creates a new callback support with associated callback runnable,

     * one instance to be used with one {@link Reference}.

     * @param callback The runnable which is run after the associated reference is cleared by GC.

     */

    public CallbackReferencesSupport(Runnable callback) {

        this(checkCallback(callback), queue());

    }

    private CallbackReferencesSupport(Runnable callback, ReferenceQueue queue) {

        this.callbackRefQueue = queue;

        this.callback = callback;

        synchronized (CallbackReferencesSupport.class) {

            activeRefsCount++;

        }

    }

    /**

     * Get the reference queue, solely for the purpose of reference creation.

     * @return The reference queue.

     */

    public ReferenceQueue getReferenceQueue() {

        return callbackRefQueue;

    }

    /**

     * Set a callback runnable to be called after the associated reference is cleared by GC.

     * @param callback 

     */

    public void setCallback(Runnable callback) {

        this.callback = callback;

    }

    void cleanup() {

        try {

            callback.run();

        } finally {

            callback = null;

            died();

        }

    }

    /**

     * Notify that the associated reference was finalized.

     */

    public void notifyFinalized() {

        if (callback != null) {

            callback = null;

            died();

        }

    }

    void died() {

        synchronized (CallbackReferencesSupport.class) {

            if (--activeRefsCount == 0) {

                activeReferenceQueue.clear();

                Daemon.finish();

            }

        }

    }

    /**

     * A provider of {@link CallbackReferencesSupport} for the given {@link Reference}.

     * @see #addReferenceSupportProvider(java.lang.Class, org.openide.util.lookup.implspi.CallbackReferencesSupport.ReferenceSupportProvider)

     */

    public static interface ReferenceSupportProvider {

        /**

         * Retrieve the {@link CallbackReferencesSupport} for the given {@link Reference}.

         * @param reference The reference

         * @return callback support associated with the reference.

         */

        CallbackReferencesSupport getSupport(Reference reference);

    }

    static final class Daemon extends Thread {

        private static Daemon running;

        public Daemon() {

            super("Cleanable Reference Queue Daemon");

        }

        static synchronized void ping() {

            if (running == null) {

                Daemon t = new Daemon();

                t.setPriority(Thread.MIN_PRIORITY);

                t.setDaemon(true);

                t.start();

                LOGGER.fine("starting thread");

                running = t;

            }

        }

        static synchronized boolean isActive() {

            return running != null;

        }

        static synchronized void finish() {

            if (running != null) {

                running.doFinish();

            }

        }

        static synchronized ReferenceQueue obtainQueue() {

            ReferenceQueue rq= activeReferenceQueue.get();

            if (rq == null) {

                running = null;

            }

            return rq;

        }

        private void doFinish() {

            interrupt();

        }

        @Override

        public void run() {

            while (true) {

                try {

                    ReferenceQueue rq = obtainQueue();

                    if (rq == null) {

                        return;

                    }

                    Reference<?> ref = rq.remove();

                    LOGGER.log(Level.FINE, "Got {0} with {1}", new Object[]{ref, ref == null ? null : ref.get()});

                    CallbackReferencesSupport support = getSupport(ref);

                    if (support == null) {

                        LOGGER.log(Level.WARNING, "An unexpected reference in the queue: {0}", ref.getClass());

                        continue;

                    }

                    // do the cleanup

                    try {

                        support.cleanup();

                    } catch (ThreadDeath td) {

                        throw td;

                    } catch (Throwable t) {

                        // Should not happen.

                        // If it happens, it is a bug in client code, notify!

                        LOGGER.log(Level.WARNING, "Cannot process " + ref, t);

                    } finally {

                        // to allow GC

                        ref = null;

                        support = null;

                    }

                } catch (InterruptedException ex) {

                    // Can happen during VM shutdown, it seems. Ignore.

                    continue;

                }

            }

        }

    }

}

    <change id="callback-references">

        <api name="util_base"/>

        <summary>CallbackReferences class provides references that are able to

            call a defined callback, after the referent object becomes unreachable.</summary>

        <version major="9" minor="8"/>

        <date year="2015" month="12" day="15"/>

        <author login="mentlicher"/>

        <compatibility addition="yes" binary="compatible" source="compatible"/>

        <description>

            <p>

                <code>CallbackReferences</code> class provides a set of reference

                implementations that are able to process the given callback runnable,

                after their referent object becomes unreachable. The callback

                processing is performed on a dedicated daemon thread,

                which is shut down when there are no more callbacks to process.

            </p>

        </description>

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

        <issue number="257013"/>

    </change>

     * @Deprecated This API requires an indefinitely running background thread.

     *             Use {@link CallbackReferences} instead.

/*

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

 *

 * Copyright 2015 Oracle and/or its affiliates. All rights reserved.

 *

 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.

 * Other names may be trademarks of their respective owners.

 *

 * 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.  Oracle designates this

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

 * by Oracle 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]"

 *

 * 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.

 *

 * Contributor(s):

 *

 * Portions Copyrighted 2015 Sun Microsystems, Inc.

 */

package org.openide.util;

import java.lang.ref.PhantomReference;

import java.lang.ref.Reference;

import java.lang.ref.SoftReference;

import java.lang.ref.WeakReference;

import java.util.concurrent.atomic.AtomicBoolean;

import org.openide.util.lookup.implspi.CallbackReferencesSupport;

/**

 * This class provides references, that are able to call a defined callback,

 * after the referent object becomes unreachable. It is useful when there is

 * a need to run a callback code after the referent is collected.

 * <p>

 * Usually, in order to implement such logic, one needs to either create

 * a dedicated thread that blocks on the queue and is <code>Object.notify</code>-ed,

 * which is the right approach but consumes valuable system resources (threads),

 * or one can periodically check the content of the queue by

 * <code>RequestProcessor.Task.schedule</code> which is completely wrong,

 * because it wakes up the system every (say) 15 seconds.

 * <p>

 * In order to provide an efficient support for this problem, these references

 * has been provided. They share one background thread to process the callbacks,

 * which dies when there are no more callbacks to process.<br>

 * Be sure not to block in such callbacks for a long time as this prevents other

 * waiting references from processing.

 * 

 * @author Martin Entlicher

 * @since 9.8

 */

public final class CallbackReferences {

    private CallbackReferences() {}

    private static <T> T referentCheck(T referent) {

        if (referent == null) {

            throw new NullPointerException("The referent must not be null.");   // NOI18N

        }

        return referent;

    }

    /**

     * An implementation of {@link PhantomReference} with a callback functionality.

     * After the referent becomes unreachable, the provided Runnable callback is executed.

     */

    public static class Phantom<T> extends PhantomReference<T> {

        private static final AtomicBoolean REGISTERED = new AtomicBoolean(false);

        final CallbackReferencesSupport support;

        /**

         * Create a new phantom reference with a callback. Both referent and the

         * callback should not be <code>null</code>.

         * @param referent the object the new phantom reference will refer to

         * @param callback the callback executed after the referent becomes unreachable.

         */

        public Phantom(T referent, Runnable callback) {

            this(referentCheck(referent), new CallbackReferencesSupport(callback));

        }

        private Phantom(T referent, CallbackReferencesSupport support) {

            super(referent, support.getReferenceQueue());

            this.support = support;

            if (!REGISTERED.getAndSet(true)) {

                CallbackReferencesSupport.addReferenceSupportProvider(Phantom.class, new SupportProvider());

            }

        }

        @Override

        protected final void finalize() throws Throwable {

            super.finalize();

            support.notifyFinalized();

        }

        private static final class SupportProvider implements CallbackReferencesSupport.ReferenceSupportProvider {

            @Override

            public CallbackReferencesSupport getSupport(Reference reference) {

                return ((Phantom) reference).support;

            }

        }

    }

    /**

     * An implementation of {@link SoftReference} with a callback functionality.

     * After the referent becomes unreachable, the provided Runnable callback is executed.

     */

    public static class Soft<T> extends SoftReference<T> {

        private static final AtomicBoolean REGISTERED = new AtomicBoolean(false);

        final CallbackReferencesSupport support;

        /**

         * Create a new soft reference with a callback. Both referent and the

         * callback should not be <code>null</code>.

         * @param referent the object the new soft reference will refer to

         * @param callback the callback executed after the referent becomes unreachable.

         */

        public Soft(T referent, Runnable callback) {

            this(referentCheck(referent), new CallbackReferencesSupport(callback));

        }

        private Soft(T referent, CallbackReferencesSupport support) {

            super(referent, support.getReferenceQueue());

            this.support = support;

            if (!REGISTERED.getAndSet(true)) {

                CallbackReferencesSupport.addReferenceSupportProvider(Soft.class, new SupportProvider());

            }

        }

        @Override

        protected final void finalize() throws Throwable {

            support.notifyFinalized();

            super.finalize();

        }

        private static final class SupportProvider implements CallbackReferencesSupport.ReferenceSupportProvider {

            @Override

            public CallbackReferencesSupport getSupport(Reference reference) {

                return ((Soft) reference).support;

            }

        }

    }

    /**

     * An implementation of {@link WeakReference} with a callback functionality.

     * After the referent becomes unreachable, the provided Runnable callback is executed.

     */

    public static class Weak<T> extends WeakReference<T> {

        private static final AtomicBoolean REGISTERED = new AtomicBoolean(false);

        final CallbackReferencesSupport support;

        /**

         * Create a new weak reference with a callback. Both referent and the

         * callback should not be <code>null</code>.

         * @param referent the object the new weak reference will refer to

         * @param callback the callback executed after the referent becomes unreachable.

         */

        public Weak(T referent, Runnable callback) {

            this(referentCheck(referent), new CallbackReferencesSupport(callback));

        }

        private Weak(T referent, CallbackReferencesSupport support) {

            super(referent, support.getReferenceQueue());

            this.support = support;

            if (!REGISTERED.getAndSet(true)) {

                CallbackReferencesSupport.addReferenceSupportProvider(Weak.class, new SupportProvider());

            }

        }

        @Override

        protected final void finalize() throws Throwable {

            support.notifyFinalized();

            super.finalize();

        }

        private static final class SupportProvider implements CallbackReferencesSupport.ReferenceSupportProvider {

            @Override

            public CallbackReferencesSupport getSupport(Reference reference) {

                return ((Weak) reference).support;

            }

        }

    }

    /**

     * An abstract {@link PhantomReference}, which acts itself as a callback

     * by implementing {@link Runable}.

     * After the referent becomes unreachable, it's <code>run()</code> method

     * is executed.

     */

    public static abstract class PhantomCallback<T> extends Phantom<T> implements Runnable {

        /**

         * Create a new phantom callback reference.

         * @param referent the object the new phantom reference will refer to

         */

        public PhantomCallback(T referent) {

            super(referentCheck(referent), new CallbackReferencesSupport());

            support.setCallback(this);

        }

    }

    /**

     * An abstract {@link SoftReference}, which acts itself as a callback

     * by implementing {@link Runable}.

     * After the referent becomes unreachable, it's <code>run()</code> method

     * is executed.

     */

    public static abstract class SoftCallback<T> extends Soft<T> implements Runnable {

        /**

         * Create a new soft callback reference.

         * @param referent the object the new phantom reference will refer to

         */

        public SoftCallback(T referent) {

            super(referentCheck(referent), new CallbackReferencesSupport());

            support.setCallback(this);

        }

    }

    /**

     * An abstract {@link WeakReference}, which acts itself as a callback

     * by implementing {@link Runable}.

     * After the referent becomes unreachable, it's <code>run()</code> method

     * is executed.

     */

    public static abstract class WeakCallback<T> extends Weak<T> implements Runnable {

        /**

         * Create a new weak callback reference.

         * @param referent the object the new phantom reference will refer to

         */

        public WeakCallback(T referent) {

            super(referentCheck(referent), new CallbackReferencesSupport());

            support.setCallback(this);

        }

    }

}

/*

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

 *

 * Copyright 2015 Oracle and/or its affiliates. All rights reserved.

 *

 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.

 * Other names may be trademarks of their respective owners.

 *

 * 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.  Oracle designates this

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

 * by Oracle 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]"

 *

 * 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.

 *

 * Contributor(s):

 *

 * Portions Copyrighted 2015 Sun Microsystems, Inc.

 */

package org.openide.util;

import java.lang.ref.WeakReference;

import java.lang.reflect.Method;

import static junit.framework.TestCase.assertTrue;

import static junit.framework.TestCase.fail;

import org.netbeans.junit.NbTestCase;

import static org.netbeans.junit.NbTestCase.assertGC;

import org.openide.util.lookup.implspi.CallbackReferencesSupport;

/**

 *

 * @author Martin Entlicher

 */

public class CallbackReferencesTest extends NbTestCase {

    public CallbackReferencesTest(String testName) {

        super(testName);

    }

    private boolean isDaemonActive() throws Exception {

        // CallbackReferencesSupport.Daemon.isActive()

        Class daemonClass = Class.forName("org.openide.util.lookup.implspi.CallbackReferencesSupport$Daemon");

        Method isActiveMethod = daemonClass.getDeclaredMethod("isActive");

        isActiveMethod.setAccessible(true);

        return (Boolean) isActiveMethod.invoke(null);

    }

    @Override

    protected void tearDown() throws Exception {

        // Test that the Daemon thread finishes eventually

        while (isDaemonActive()) {

            System.gc();

            Thread.sleep(10);

        }

    }

    public void testRunnableReferenceIsExecuted () throws Exception {

        Object obj = new Object ();

        RunnableRef ref = new RunnableRef (obj);

        synchronized (ref) {

            obj = null;

            assertGC ("Should be GCed quickly", ref);

            ref.wait ();

            assertTrue ("Run method has been executed", ref.executed);

        }

    }

    public void testRunnablesAreProcessedOneByOne () throws Exception {

        Object obj = new Object ();

        RunnableRef ref = new RunnableRef (obj);

        ref.wait = true;

        synchronized (ref) {

            obj = null;

            assertGC ("Is garbage collected", ref);

            ref.wait ();

            assertTrue ("Still not executed, it is blocked", !ref.executed);

        }    

        RunnableRef after = new RunnableRef (new Object ());

        synchronized (after) {

            assertGC ("Is garbage collected", after);

            after.wait (100); // will fail

            assertTrue ("Even if GCed, still not processed", !after.executed);

        }

        synchronized (after) {

            synchronized (ref) {

                ref.notify ();

                ref.wait ();

                assertTrue ("Processed", ref.executed);

            }

            after.wait ();

            assertTrue ("Processed too", after.executed);

        }

    }

    public void testManyReferencesProcessed() throws InterruptedException {

        int n = 100;

        Object[] objects = new Object[n];

        ExpensiveRef[] refs = new ExpensiveRef[n];

        for (int i = 0; i < n; i++) {

            objects[i] = new Object();

            refs[i] = new ExpensiveRef(objects[i], Integer.toString(i));

        }

        objects = null;

        for (int i = 0; i < n; i++) {

            assertGC("is GC'ed", refs[i]);

        }

        for (int i = 0; i < n; i++) {

            synchronized (refs[i]) {

                while (!refs[i].executed) {

                    refs[i].wait();

                }

            }

        }

    }

    public void testNullNotAccepted() {

        NullPointerException npe = null;

        try {

            new CallbackReferences.Phantom<Object>(null, new Runnable() { public void run() {}});

        } catch (NullPointerException ex) {

            npe = ex;

        }

        assertNotNull("NullPointerException not thrown!", npe);

        npe = null;

        try {

            new CallbackReferences.Phantom<Object>(new Object(), null);

        } catch (NullPointerException ex) {

            npe = ex;

        }

        assertNotNull("NullPointerException not thrown!", npe);

        npe = null;

        try {

            new CallbackReferences.Soft<Object>(null, new Runnable() { public void run() {}});

        } catch (NullPointerException ex) {

            npe = ex;

        }

        assertNotNull("NullPointerException not thrown!", npe);

        npe = null;

        try {

            new CallbackReferences.Soft<Object>(new Object(), null);

        } catch (NullPointerException ex) {

            npe = ex;

        }

        assertNotNull("NullPointerException not thrown!", npe);

        npe = null;

        try {

            new CallbackReferences.Weak<Object>(null, new Runnable() { public void run() {}});

        } catch (NullPointerException ex) {

            npe = ex;

        }

        assertNotNull("NullPointerException not thrown!", npe);

        npe = null;

        try {

            new CallbackReferences.Weak<Object>(new Object(), null);

        } catch (NullPointerException ex) {

            npe = ex;

        }

        assertNotNull("NullPointerException not thrown!", npe);

    }

    private static class RunnableRef extends CallbackReferences.WeakCallback<Object>

    implements Runnable {

        public boolean wait;

        public boolean entered;

        public boolean executed;

        public RunnableRef (Object o) {

            super(o);

        }

        @Override

        public synchronized void run () {

            entered = true;

            if (wait) {

                // notify we are here

                notify ();

                try {

                    wait ();

                } catch (InterruptedException ex) {

                }

            }

            executed = true;

            notifyAll ();

        }

    }

    private static class ExpensiveRef extends CallbackReferences.WeakCallback<Object>

    implements Runnable {

        public boolean executed;

        private final String name;

        public ExpensiveRef (Object o, String name) {

            super(o);

            this.name = name;

        }

        @Override

        public synchronized void run () {

            executed = true;

            try {

                Thread.sleep(10);

                System.gc();

                Thread.sleep(10);

            } catch (InterruptedException iex) {}

            notifyAll ();

            //System.err.println(name+" executed.");

        }

    }

}