<change id="ChildFactory">

        <api name="nodes"/>

        <summary>API for Children objects that asynchronously compute keys/child

            nodes and simplifies implementation of Children.Keys usages</summary>

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

        <date day="20" month="3" year="2007"/>

        <author login="tboudreau"/>

        <compatibility addition="yes" binary="compatible" source="compatible" semantic="compatible" deprecation="no" deletion="no" modification="no"/>

        <description>

            Added the class 

            <a href="@TOP@/org/openide/nodes/ChildFactory.html">ChildFactory</a>

            and the method 

            <a href="@TOP@/org/openide/nodes/Children.html#create(org.openide.nodes.ChildFactory, boolean)">Children.create(ChildFactory factory, boolean asynchronous)</a>

            to the API.  This simplifies creation of Node children which need

            to be computed on a background thread for performance reasons.

            Anyone wishing to do this can simply extend ChildFactory and

            pass that to Children.create() to automatically get a Node that will

            display a Please Wait child node when first expanded.  A ChildFactory

            can either compute all child nodes, or batch them in multiple

            passes.

            <p>

            ChildFactory can also be used to implement synchronous children,

            by setting the <code>useWaitNode</code> parameter passed to

            <code>Children.create()</code> to true.  This could replace most

            common usages of Children.Keys, and make it easy to switch to

            asynchronous child computation if that is determined to be

            necessary for performance reasons.

            </p>

        </description>

        <issue number="91529"/>

    </change>

/*

 * The contents of this file are subject to the terms of the Common Development

 * and Distribution License (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.html

 * or http://www.netbeans.org/cddl.txt.

 *

 * When distributing Covered Code, include this CDDL Header Notice in each file

 * and include the License file at http://www.netbeans.org/cddl.txt.

 * If applicable, add the following below the CDDL Header, with the fields

 * enclosed by brackets [] replaced by your own identifying information:

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

 *

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

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

 * Microsystems, Inc. All Rights Reserved.

 */

package org.openide.nodes;

import java.awt.EventQueue;

import java.lang.Thread;

import java.util.Collections;

import java.util.LinkedList;

import java.util.List;

import org.openide.util.RequestProcessor;

/**

 * Children object which creates its keys on a background thread.  To use,

 * implement AsynchChildren.Provider and pass that to the constructor.

 *

 * @author Tim Boudreau

 */

final class AsynchChildren <T> extends Children.Keys <Object> implements 

                                                          ChildFactory.Observer, 

                                                          Runnable {

    private final ChildFactory<T> factory;

    private final RequestProcessor.Task task;

    private final RequestProcessor PROC = new RequestProcessor("Asynch " //NOI18N

             + "children creator " + this, Thread.NORM_PRIORITY, true); //NOI18N

    /**

     * Create a new AsyncChildren instance with the passed provider object

     * which will manufacture key objects and nodes.

     * @param provider An object which can provide a list of keys and make

     *        Nodes for them

     */ 

    AsynchChildren(ChildFactory<T> factory) {

        factory.setObserver (this);

        this.factory = factory;

        task = PROC.create(this, true);

    }

    volatile boolean initialized = false;

    protected void addNotify() {

        if ((!initialized && task.isFinished()) || cancelled) {

            cancelled = false;

            Node n = factory.getWaitNode();

            if (n != null) {

                setKeys (new Object[] { n });

            }

            task.schedule(0);

        }

    }

    protected void removeNotify() {

        cancelled = true;

        task.cancel();

        initialized = false;

        setKeys (Collections.<Object>emptyList());

    }

    /**

     * Notify this AsynchChildren that it should reconstruct its children,

     * calling <code>provider.asynchCreateKeys()</code> and setting the

     * keys to that.  Call this method if the list of child objects is known

     * or likely to have changed.

     * @param immediate If true, the keys are updated synchronously from the

     *  calling thread.  Set this to true only if you know that updating

     *  the keys will <i>not</i> be an expensive or time-consuming operation.

     */ 

    public void refresh(boolean immediate) {

        immediate &= !EventQueue.isDispatchThread();

        if (immediate) {

            boolean done;

            List <T> keys = new LinkedList <T> ();

            do {

                done = factory.createKeys(keys);

            } while (!done);

            setKeys (keys);

        } else {

            task.schedule (0);

        }

    }

    public Node[] getNodes(boolean optimalResult) {

        if (optimalResult) {

            task.waitFinished();

        }

        return super.getNodes();

    }

    @SuppressWarnings("unchecked") //NOI18N

    protected Node[] createNodes(Object key) {

        if (factory.isWaitNode(key)) {

            return new Node[] { (Node) key };

        } else {

            return factory.createNodesForKey ((T) key);

        }

    }

    volatile boolean cancelled = false;

    public void run() {

        if (Thread.interrupted()) {

            setKeys (Collections.<T>emptyList());

            return;

        }

        List <T> keys = new LinkedList <T> ();

        boolean done;

        do {

            done = factory.createKeys (keys);

            if (cancelled || Thread.interrupted()) {

                setKeys (Collections.<Object>emptyList());

                return;

            }

            setKeys (new LinkedList <Object> (keys));

        } while (!done);

        initialized = done;

    }

}

#AsynchChildren

LBL_WAIT=Please Wait...

/*

 * The contents of this file are subject to the terms of the Common Development

 * and Distribution License (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.html

 * or http://www.netbeans.org/cddl.txt.

 *

 * When distributing Covered Code, include this CDDL Header Notice in each file

 * and include the License file at http://www.netbeans.org/cddl.txt.

 * If applicable, add the following below the CDDL Header, with the fields

 * enclosed by brackets [] replaced by your own identifying information:

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

 *

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

 */

package org.openide.nodes;

import java.lang.ref.Reference;

import java.lang.ref.WeakReference;

import java.util.List;

import org.openide.util.NbBundle;

/**

 * Factory used to create <a href="Children.html">Children</a>

 * objects.  Children objects supply child Nodes for a 

 * Node.  Usage is to write a class that extends ChildFactory and

 * pass that to Children.create().  When the Node is expanded or its

 * children are programmatically requested, the 

 * <a href="#createKeys(java.util.List)">createKeys(List &lt;T&gt;)</a> method

 * will be invoked to create the List of objects to be modelled as Nodes.

 * Later, on demand, each object from the List will be passed in turn to

 * <a href="#createNodesForKey(java.lang.Object)">createNodesForKey(T)</a>, 

 * which may return an array of zero or more Nodes for the object. 

 * <p>

 * A ChildFactory can be used either to create typical Children object, or

 * one which will be initialized on a background thread (providing

 * a "Please Wait" Node in the meantime).  It can be used most simple cases

 * that Children.Keys has been historically used for, and makes it easy to

 * change a Children object to compute its keys asynchronously if that is

 * needed for performance reasons.

 * <p>

 * Only one ChildFactory object may be used per Children object;  if you wish

 * to have multiple Nodes modelling children produced by a single 

 * ChildFactory, use @link FilterNode to wrap the Node that owns the

 * Children object for this ChildFactory.

 * <p>

 * To use, simply override 

 * <a href="#createKeys(java.util.List)">createKeys(List &lt;T&gt;) and 

 * <a href="#createNodesForKey(java.lang.Object)">createNodesForKey(T)</a> or

 * <a href="#createNodeForKey(java.lang.Object)">createNodeForKey(T)</a>.

 * 

 * @param T The type of objects in the keys collection

 * @author Tim Boudreau

 * @see Children#create(ChildFactory, boolean)

 */

public abstract class ChildFactory <T> {

    /**

     * Create a Node for a given key that was put into the list passed into

     * createKeys().  Either override this method if there will always be

     * 0 or 1 nodes per key, or createNodesForKey() if there may be more

     * than one.

     * 

     * The default implementation returns null.

     * 

     * @param key An object that was previously put into the list passed 

     *            to createKeys()

     * @return A node, or null if no node should be shown for this object.

     */

    protected Node createNodeForKey (T key) {

        return null;

    }

    /**

     * Create Nodes for a given key object (one from the <code>List</code>

     * passed to createKeys(List <T>)).  The default implementation simply

     * delegates to <code>createNodeForKey</code> and returns the result of

     * that call in an array of nodes.

     * <p>

     * Most Children objects have a 1:1 mapping between keys and nodes.  For

     * convenience in that situation, simply override createNodeForKey(T).

     * 

     * @param key An object from the list returned by 

     *        <code>asynchCreateKeys()</code>

     * @return zero or more Nodes to represent this key

     */

    protected Node[] createNodesForKey (T key) {

        Node n = createNodeForKey (key);

        return n == null ? new Node[0] : new Node[] { n };

    }

    /**

     * Create a list of keys which can be individually passed to

     * createNodes() to create child Nodes.  Implementations of

     * this method should regularly check Thread.interrupted(), and

     * if it returns true (meaning the parent Node was collapsed or

     * destroyed), stop creating keys immediately and return

     * true.  This method is guaranteed <i>not</i> to be called on the

     * AWT event thread if this ChildFactory was passed to

     * Children.create() with the <code>asynchronous</code> parameter

     * set to true.  If not, then no guarantees are made as to what

     * the calling thread is.

     * 

     * @param toPopulate A list to add key objects to

     * @return true if the list of keys has been completely populated,

     *         false if the list has only been partially populated and

     *         this method should be called again to batch more keys

     */ 

    protected abstract boolean createKeys (List <T> toPopulate);

    /**

     * Call this method when the list of objects being modelled by the

     * has changed and the child Nodes of this Node should be updated.  The

     * boolean argument is a <i>hint</i> to the refresh mechanism (which

     * will cause createKeys() to be invoked again) that it is safe to

     * synchronously recreate.

     * 

     * @param immediate If true, the refresh should occur in the calling

     *   thread (be careful not to be holding any locks that might

     *   deadlock with your key/child creation methods if you pass true).

     *   Note that this parameter is only meaningful when using an 

     *   asynchronous children instance (i.e. true was passed as the

     *   second parameter to <code>Children.create()</code>).  If the

     *   Children object for this ChildFactory is called with <code>immediate</code>

     *   true on the AWT event dispatch thread, and it is an asynchronous

     *   Children object, this parameter will be ignored and computation

     *   will be scheduled on a background thread.

     */ 

    protected final void refresh (boolean immediate) {

        Observer obs = observer == null ? null : observer.get();

        if (obs != null) {

            obs.refresh(immediate);

        }

    }

    Node getWaitNode() {

        Node n = createWaitNode();

        return n == null ? null : new WaitFilterNode (n);

    }

    /**

     * Create the Node that should be shown while the keys are being computed

     * on a background thread.  

     * This method will not be called if this ChildFactory is used for a 

     * synchronous children which does not compute its keys on a background

     * thread.  Whether an instance is synchronous or not is determined by a

     * parameter to 

     * <a href="Children.html#create(ChildFactory, boolean)">Children.create()</a>.

     * <p>

     * To show no node at all when the Children object is initially expanded in

     * the UI, simply return null.

     * <p>

     * The default implementation returns a Node that shows an hourglass cursor

     * and the localized text "Please Wait...".

     * 

     * @return A Node, or null if no wait node should be shown.

     */ 

    protected Node createWaitNode() {

        AbstractNode n = new AbstractNode (Children.LEAF);

        n.setIconBaseWithExtension("org/openide/nodes/wait.gif");

        n.setDisplayName (NbBundle.getMessage (ChildFactory.class, "LBL_WAIT")); //NOI18N

        return n;

    }

    private Reference <Observer> observer = null;

    final void setObserver (Observer observer) {

        if (this.observer != null) {

            throw new IllegalStateException ("Attempting to create two Children" + //NOI18N

                    " objects for a single ChildFactory.  Use " + //NOI18N

                    "FilterNode.Children over the existing Children object " + //NOI18N

                    "instead"); //NOI18N

        }

        this.observer = new WeakReference <Observer> (observer);

    }

    interface Observer {

        public void refresh (boolean immediate);

    }

    static boolean isWaitNode (Object n) {

        return n instanceof WaitFilterNode;

    }

    /**

     * This class exists to uniquify/mark any Node returned by createWaitNode

     * such that AsynchChildren can identify it absolutely as not being an

     * object that should be passed to createNodeForKey().

     */ 

    private static final class WaitFilterNode extends FilterNode {

        public WaitFilterNode (Node orig) {

            super (orig);

        }

    }

}

    /**

     * Create a <code>Children</code> object using the passed <code>ChildFactory</code>

     * object.  The <code>ChildFactory</code> will be asked to create a list

     * of model objects that are the children;  then for each object in the list,

     * <code>ChildFactory.createNodesFor()</code> will be called to instantiate

     * one or more <code>Node</code>s for that object.

     * @param factory A ChildFactory which will provide child objects

     * @param asynchronous If true, the ChildFactory will always be called to

     *   create the list of keys on

     *   a background thread, displaying a "Please Wait" child Node until

     *   some or all child Nodes have been computed.  If so, 

     *   when it is expanded, the Node that owns

     *   the returned <code>Children</code> object will display a &quot;please wait&quot;

     *   node while the children are computed in the background.  Pass true

     *   for any case where computing child nodes is expensive and should

     *   not be done in the event thread.

     * @return A <code>Children</code> object which 

     *   will invoke the ChildFactory instance as needed to supply model

     *   objects and child nodes for it

     * @throws IllegalStateException if the passed ChildFactory has already

     *   been used in a previous call to <code>Children.create()</code>.

     * @since 7.1

     */ 

    public static <T> Children create (ChildFactory <T> factory, boolean asynchronous) {

        if (factory == null) throw new NullPointerException ("Null factory");

        return asynchronous ? new AsynchChildren <T> (factory) : 

            new SynchChildren <T> (factory);

    }

    * Note that for simple cases, it may be preferable to subclass

    * <a href="ChildFactory.html">ChildFactory</a> and pass the result to

    * <a href="Children.html#create(org.openide.nodes.ChildFactory, boolean)">

    * create()</a>; doing so makes it easy to switch to using child

    * nodes computed on a background thread if necessary for performance

    * reasons.

/*

 * The contents of this file are subject to the terms of the Common Development

 * and Distribution License (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.html

 * or http://www.netbeans.org/cddl.txt.

 *

 * When distributing Covered Code, include this CDDL Header Notice in each file

 * and include the License file at http://www.netbeans.org/cddl.txt.

 * If applicable, add the following below the CDDL Header, with the fields

 * enclosed by brackets [] replaced by your own identifying information:

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

 *

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

 */

package org.openide.nodes;

import java.util.Collections;

import java.util.LinkedList;

import java.util.List;

/**

 * Synchronous children implementation that takes a ChildFactory.

 *

 * @author Tim Boudreau

 */

final class SynchChildren <T> extends Children.Keys <Object> implements ChildFactory.Observer {

    private final ChildFactory<T> factory;

    /** Creates a new instance of SynchChildren */

    SynchChildren(ChildFactory<T> factory) {

        this.factory = factory;

        factory.setObserver(this);

    }

    volatile boolean active = false;

    protected void addNotify() {

        active = true;

        refresh (true);

    }

    protected void removeNotify() {

        active = false;

        setKeys (Collections.<Object>emptyList());

    }

    @SuppressWarnings("unchecked") //NOI18N

    protected Node[] createNodes(Object key) {

        return factory.createNodesForKey((T) key);

    }

    public void refresh(boolean immediate) {

        if (active) {

            List <T> toPopulate = new LinkedList<T>();

            while (!factory.createKeys(toPopulate)) {}

            setKeys (toPopulate);

        }

    }

}

/*

 * The contents of this file are subject to the terms of the Common Development

 * and Distribution License (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.html

 * or http://www.netbeans.org/cddl.txt.

 *

 * When distributing Covered Code, include this CDDL Header Notice in each file

 * and include the License file at http://www.netbeans.org/cddl.txt.

 * If applicable, add the following below the CDDL Header, with the fields

 * enclosed by brackets [] replaced by your own identifying information:

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

 *

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

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

 * Microsystems, Inc. All Rights Reserved.

 */

package org.openide.nodes;

import java.awt.EventQueue;

import java.beans.*;

import java.util.*;

import junit.framework.TestCase;

import org.openide.nodes.*;

import org.openide.nodes.NodeAdapter;

import org.openide.util.NbBundle;

/** Test for AsynchChildren

 * 

 * @author Tim Boudreau

 */

public class ChildFactoryTest extends TestCase {

    public ChildFactoryTest(String name) {

        super(name);

    }

    private ProviderImpl factory;

    private BatchProviderImpl factory2;

    private AsynchChildren kids2;

    private Node node2;

    private AsynchChildren kids;

    private Node node;

    public void setUp() throws Exception {

        factory = new ProviderImpl();

        kids = new AsynchChildren (factory);

        node = new AbstractNode (kids);

        factory2 = new BatchProviderImpl();

        kids2 = new AsynchChildren (factory2);

        node2 = new AbstractNode (kids2);

    }

    public void testChildrenCreate() {

        System.out.println("testChildrenCreate");

        ChildFactory f = new ProviderImpl();

        Children kids = Children.create (f, true);

        assertTrue (kids instanceof AsynchChildren);

        ChildFactory ff = new ProviderImpl();

        Children kids2 = Children.create (ff, false);

        assertFalse (kids2 instanceof AsynchChildren);

        assertTrue (kids2 instanceof SynchChildren);

        RuntimeException e = null;

        Children kids3 = null;

        try {

            kids3 = Children.create (ff, true);

        } catch (RuntimeException ex) {

            e = ex;

        }

        assertNull (kids3);

        assertNotNull ("Exception should have been thrown creating two " +

                "Children objects over the same ChildFactory", e);

    }

    //A word of caution re adding tests:

    //Almost anything (getNodes(), justCreateNodes(), etc. can trigger a

    //fresh call to Children.addNotify().  Any test that expects a synchronous

    //change in the child nodes as a result of having triggered a call

    //to setKeys() is probably testing a race condition, not the behavior

    //of the children implementation

    public void testGetNodesWaits() throws Exception {

        System.out.println("testGetNodesWaits");

        factory.wait = false;

        kids.getNodes (false);

        synchronized (factory.lock) {

            factory.lock.wait (300);

        }

        Thread.currentThread().yield();

        new NL (node);

        Node[] n = kids.getNodes(true);

        assertEquals (4, n.length);

    }

    public void testInitialNodeIsWaitNode() throws Exception {

        System.out.println("testInitialNodeIsWaitNode");

        factory.wait = true;

        kids.addNotify();

        Node[] n = kids.getNodes(false);

        factory.wait = false;

        assertEquals (1, n.length);

        assertEquals (NbBundle.getMessage(AsynchChildren.class, "LBL_WAIT"),

                n[0].getDisplayName());

        factory.wait = false;

        synchronized (factory) {

            factory.wait (2000);

        }

        for (int i = 0; i < 5 && n.length != 4; i++) {

            n = kids.getNodes(true);

            java.lang.Thread.currentThread().yield();

        }

        assertEquals (4, n.length);

    }

    public void testBatch() throws Exception {

        System.out.println("testBatch");

        kids2.addNotify();

        Thread.currentThread().yield();

        synchronized (factory2.lock) {

            factory2.lock.notifyAll();

        }

        new NL (node2);

        Node[] n = n = kids2.getNodes(true);

        assertEquals (4, n.length);

        assertEquals (2, factory2.callCount);

    } 

    public void testSynchChildren() throws Exception {

        System.out.println("testSynchChildren");

        final SynchProviderImpl factory = new SynchProviderImpl();

        final Children ch = Children.create (factory, false);

        assertTrue (ch instanceof SynchChildren);

        factory.assertCreateKeysNotCalled();

        factory.assertCreateNodesForKeyNotCalled();

        final Node nd = new AbstractNode (ch);

        NodeAdapter adap = new NodeAdapter() {};

        nd.addNodeListener (adap);

        EventQueue.invokeAndWait (new Runnable() {

            public void run() {

                ch.getNodes(true);

            }

        });

        ((SynchChildren) ch).active = true;

        synchronized (factory) {

            factory.wait (1000);

        }

        factory.assertCreateKeysCalled();

        factory.assertCreateNodesForKeyCalled();

        Node[] nodes = nd.getChildren().getNodes(true);

        assertEquals (factory.CONTENTS1.size(), nodes.length);

        int ix = 0;

        for (String s : factory.CONTENTS1) {

            assertEquals (s, nodes[ix].getName());

            ix++;

        }

        factory.switchChildren();

        nodes = nd.getChildren().getNodes(true);

        assertEquals (factory.CONTENTS2.size(), nodes.length);

        ix = 0;

        for (String s : factory.CONTENTS2) {

            assertEquals (s, nodes[ix].getName());

            ix++;

        }

    }

    public void testCancel() throws Exception {

        System.out.println("testCancel");

        Thread.interrupted();

        factory.wait = true;

        kids.addNotify();

        Thread.currentThread().yield();

        synchronized (factory.lock) {

            factory.lock.wait (500);

        }

        kids.removeNotify();

        factory.wait = false;

        synchronized (factory) {

            factory.wait (2000);

        }

        assertTrue (kids.cancelled);

        assertTrue (factory.cancelled);

    }

     static final class ProviderImpl extends ChildFactory <String> {

        Object lock = new Object();

        volatile boolean wait = false;

        public Node[] createNodesForKey(String key) {

            AbstractNode nd = new AbstractNode (Children.LEAF);

            nd.setDisplayName (key);

            return new Node[] { nd };

        }

        boolean cancelled = false;

        public boolean createKeys(List <String> result) {

            try {

                while (wait) {

                    Thread.currentThread().yield();

                }

                synchronized (lock) {

                    lock.notifyAll();

                }

                if (Thread.interrupted()) {

                    cancelled = true;

                    return true;

                }

                result.add ("A");

                result.add ("B");

                result.add ("C");

                result.add ("D");

                if (Thread.interrupted()) {

                    cancelled = true;

                }

                return true;

            } finally {

                synchronized (this) {

                    notifyAll();

                }

            }

        }

    }

     static final class BatchProviderImpl extends ChildFactory <String> {

        boolean firstCycle = true;

        public Node[] createNodesForKey(String key) {

            AbstractNode nd = new AbstractNode (Children.LEAF);

            nd.setDisplayName (key);

            return new Node[] { nd };

        }

        Object lock = new Object();

        int callCount = 0;

        public boolean createKeys(List <String> result) {

            callCount++;

            synchronized (lock) {

                try {

                    lock.wait(500);

                } catch (InterruptedException ex) {

                    //re-interrupt

                    Thread.currentThread().interrupt();

                }

            }

            if (Thread.interrupted()) {

                return true;

            }

            boolean wasFirstCycle = firstCycle;

            if (wasFirstCycle) {

                result.add ("A");

                result.add ("B");

                firstCycle = false;

                return false;

            } else {

                result.add ("C");

                result.add ("D");

            }

            if (Thread.interrupted()) {

                return true;

            }

            synchronized (this) {

                notifyAll();

            }

            return true;

        }

    }

    private static final class NL implements NodeListener {

        NL (Node n) {

            n.addNodeListener (this);

            try {

                waitFor();

            } catch (InterruptedException ex) {

                Thread.currentThread().interrupt();

            } catch (Exception e) {

                throw new Error (e);

            }

        }

        NL () {

        }

        public void childrenAdded(NodeMemberEvent ev) {

            go();

        }

        public void childrenRemoved(NodeMemberEvent ev) {

            go();

        }

        public void childrenReordered(NodeReorderEvent ev) {

            go();

        }

        public void nodeDestroyed(NodeEvent ev) {

        }

        public void propertyChange(PropertyChangeEvent arg0) {

        }

        private void go() {

            synchronized (this) {

                notifyAll();

            }

        }

        void waitFor() throws Exception {

            System.err.println("Enter waitfor");

            synchronized (this) {

                wait (1000);

            }

        }

    }

    private static final class SynchProviderImpl extends ChildFactory <String> {

        static List <String> CONTENTS1 = Arrays.<String>asList (new String[] {

            "One", "Two", "Three", "Four"

        });

        static List <String> CONTENTS2 = Arrays.<String>asList (new String[] {

            "Five", "Six", "Seven", "Eight", "Nine"

        });

        boolean createNodesForKeyCalled = false;

        public Node[] createNodesForKey(String key) {

            createNodesForKeyCalled = true;

            Node result = new AbstractNode(Children.LEAF);

            result.setDisplayName (key);

            result.setName (key);

            return new Node[] { result };

        }

        boolean createKeysCalled = false;

        public boolean createKeys(List <String> toPopulate) {

            createKeysCalled = true;

            List <String> l = switched ? CONTENTS2 : CONTENTS1;

            toPopulate.addAll (l);

            return true;

        }

        void assertCreateNodesForKeyNotCalled() {

            assertFalse (createNodesForKeyCalled);

        }

        void assertCreateKeysNotCalled() {

            assertFalse (createKeysCalled);

        }

        boolean assertCreateNodesForKeyCalled() {

            boolean result = createNodesForKeyCalled;

            createNodesForKeyCalled = false;

            assertTrue (result);

            return result;

        }

        boolean assertCreateKeysCalled() {

            boolean result = createKeysCalled;

            createKeysCalled = false;

            assertTrue (result);

            return result;

        }

        volatile boolean switched = false;

        void switchChildren() {

            switched = !switched;

            refresh(true);

        }

    }

}