/*

 *                 Sun Public License Notice

 * 

 * The contents of this file are subject to the Sun Public License

 * Version 1.0 (the "License"). You may not use this file except in

 * compliance with the License. A copy of the License is available at

 * http://www.sun.com/

 * 

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

 * Code is Sun Microsystems, Inc. Portions Copyright 1997-2004 Sun

 * Microsystems, Inc. All Rights Reserved.

 */

package org.netbeans.core;

import java.io.*;

import java.util.*;

import org.openide.filesystems.*;

import org.openide.actions.*;

import org.openide.util.actions.SystemAction;

/**

 *

 * @author Jaroslav Tulach

 */

public class LoaderPoolNodeTest extends org.netbeans.junit.NbTestCase {

    private OldStyleLoader oldL;

    private NewStyleLoader newL;

    public LoaderPoolNodeTest (String testName) {

        super (testName);

    }

    protected void setUp () throws java.lang.Exception {

        oldL = (OldStyleLoader)OldStyleLoader.getLoader (OldStyleLoader.class);

        newL = (NewStyleLoader)NewStyleLoader.getLoader (NewStyleLoader.class);

        LoaderPoolNode.doAdd (oldL, null);

        LoaderPoolNode.doAdd (newL, null);

    }

    protected void tearDown () throws java.lang.Exception {

        LoaderPoolNode.remove (oldL);

        LoaderPoolNode.remove (newL);

    }

    public void testOldLoaderThatChangesActionsBecomesModified () throws Exception {

        assertFalse ("Not modified at begining", LoaderPoolNode.isModified (oldL));

        Object actions = oldL.getActions ();

        assertNotNull ("Some actions there", actions);

        assertTrue ("Default actions called", oldL.defaultActionsCalled);

        assertFalse ("Still not modified", LoaderPoolNode.isModified (oldL));

        ArrayList list = new ArrayList ();

        list.add (OpenAction.get (OpenAction.class));

        list.add (NewAction.get (NewAction.class));

        oldL.setActions ((SystemAction[])list.toArray (new SystemAction[0]));

        assertTrue ("Now it is modified", LoaderPoolNode.isModified (oldL));

        List l = Arrays.asList (oldL.getActions ());

        assertEquals ("Actions are the same", list, l);        

    }

    public void testNewLoaderThatChangesActionsBecomesModified () throws Exception {

        assertFalse ("Not modified at begining", LoaderPoolNode.isModified (newL));

        Object actions = newL.getActions ();

        assertNotNull ("Some actions there", actions);

        assertTrue ("Default actions called", newL.defaultActionsCalled);

        assertFalse ("Still not modified", LoaderPoolNode.isModified (newL));

        ArrayList list = new ArrayList ();

        list.add (OpenAction.get (OpenAction.class));

        list.add (NewAction.get (NewAction.class));

        newL.setActions ((SystemAction[])list.toArray (new SystemAction[0]));

        assertFalse ("Even if we changed actions, it is not modified", LoaderPoolNode.isModified (newL));

        List l = Arrays.asList (newL.getActions ());

        assertEquals ("But actions are changed", list, l);        

    }

    public static class OldStyleLoader extends org.openide.loaders.UniFileLoader {

        boolean defaultActionsCalled;

        public OldStyleLoader () {

            super (org.openide.loaders.MultiDataObject.class);

        }

        protected org.openide.loaders.MultiDataObject createMultiObject (FileObject fo) throws IOException {

            throw new IOException ("Not implemented");

        }

        protected SystemAction[] defaultActions () {

            defaultActionsCalled = true;

            SystemAction[] retValue;

            retValue = super.defaultActions();

            return retValue;

        }

    }

    public static final class NewStyleLoader extends OldStyleLoader {

        protected String actionsContext () {

            return "Loaders/IamTheNewBeggining";

        }

    }

}

    /** Checks whether a loader is modified. E.g. whether the loader

     * considers it to be modified and necessary to be saved.

     */

    static synchronized boolean isModified (DataLoader l) {

        return modifiedLoaders.contains (l);

    }

            if (DataLoader.PROP_ACTIONS.equals (prop) && ev.getNewValue () == null) {

                // skip this change as this means the loader is using new storage mechanism

                return;

            }

            modifiedLoaders.add(l);

     */

  <folder name="Loaders">

    <folder name="text">

        <folder name="x-java">

            <folder name="Actions">

              <attr boolvalue="true" name="OpenAction.instance/java-project-separator-1.instance" />

              <file name="java-project-separator-1.instance">

                <attr name="instanceClass" stringvalue="javax.swing.JSeparator" />

              </file>

              <attr boolvalue="true" name="java-project-separator-1.instance/CompileFile.instance" />

              <file name="CompileFile.instance">

                <attr name="instanceClass" stringvalue="org.netbeans.modules.java.project.JavaProjectModule$CompileWrapper" />

              </file>

              <attr boolvalue="true" name="CompileFile.instance/java-project-separator-2.instance" />

              <file name="java-project-separator-2.instance">

                <attr name="instanceClass" stringvalue="javax.swing.JSeparator" />

              </file>

              <attr boolvalue="true" name="java-project-separator-2.instance/RunFile.instance" />

              <file name="RunFile.instance">

                <attr name="instanceClass" stringvalue="org.netbeans.modules.java.project.JavaProjectModule$RunWrapper" />

              </file>

              <attr boolvalue="true" name="RunFile.instance/DebugFile.instance" />

              <file name="DebugFile.instance">

                <attr name="instanceClass" stringvalue="org.netbeans.modules.java.project.JavaProjectModule$DebugWrapper" />

              </file>

              <attr boolvalue="true" name="DebugFile.instance/java-project-separator-3.instance" />

              <file name="java-project-separator-3.instance">

                <attr name="instanceClass" stringvalue="javax.swing.JSeparator" />

              </file>

              <attr boolvalue="true" name="java-project-separator-3.instance/FileSystemAction.instance" />

            </folder>

        </folder>

    </folder>

  </folder>

    protected String actionsContext () {

        return "Loaders/text/x-java/Actions/"; // NOI18N

    }

    // XXX JST: Can be deleted? Replaced by actionsContext.

    // XXX JST: Can be deleted? Replaced by actionsContext.

  <folder name="Loaders">

    <folder name="text">

        <folder name="x-java">

            <folder name="Actions">

              <file name="OpenAction.instance">

                <attr name="instanceClass" stringvalue="org.openide.actions.OpenAction" />

              </file>

              <attr boolvalue="true" name="OpenAction.instance/FileSystemAction.instance" />

              <file name="FileSystemAction.instance">

                <attr name="instanceClass" stringvalue="org.openide.actions.FileSystemAction" />

              </file>

              <attr boolvalue="true" name="FileSystemAction.instance/Separator1.instance" />

              <file name="Separator1.instance">

                <attr name="instanceClass" stringvalue="javax.swing.JSeparator" />

              </file>

              <attr boolvalue="true" name="Separator1.instance/CutAction.instance" />

              <file name="CutAction.instance">

                <attr name="instanceClass" stringvalue="org.openide.actions.CutAction" />

              </file>

              <attr boolvalue="true" name="CutAction.instance/CopyAction.instance" />

              <file name="CopyAction.instance">

                <attr name="instanceClass" stringvalue="org.openide.actions.CopyAction" />

              </file>

              <attr boolvalue="true" name="CopyAction.instance/PasteAction.instance" />

              <file name="PasteAction.instance">

                <attr name="instanceClass" stringvalue="org.openide.actions.PasteAction" />

              </file>

              <attr boolvalue="true" name="PasteAction.instance/Separator2.instance" />

              <file name="Separator2.instance">

                <attr name="instanceClass" stringvalue="javax.swing.JSeparator" />

              </file>

              <attr boolvalue="true" name="Separator2.instance/NewAction.instance" />

              <file name="NewAction.instance">

                <attr name="instanceClass" stringvalue="org.openide.actions.NewAction" />

              </file>

              <attr boolvalue="true" name="NewAction.instance/DeleteAction.instance" />

              <file name="DeleteAction.instance">

                <attr name="instanceClass" stringvalue="org.openide.actions.DeleteAction" />

              </file>

              <attr boolvalue="true" name="DeleteAction.instance/RenameAction.instance" />

              <file name="RenameAction.instance">

                <attr name="instanceClass" stringvalue="org.openide.actions.RenameAction" />

              </file>

              <attr boolvalue="true" name="RenameAction.instance/Separator3.instance" />

              <file name="Separator3.instance">

                <attr name="instanceClass" stringvalue="javax.swing.JSeparator" />

              </file>

              <attr boolvalue="true" name="Separator3.instance/SaveAsTemplateAction.instance" />

              <file name="SaveAsTemplateAction.instance">

                <attr name="instanceClass" stringvalue="org.openide.actions.SaveAsTemplateAction" />

              </file>

              <attr boolvalue="true" name="SaveAsTemplateAction.instance/Separator4.instance" />

              <file name="Separator4.instance">

                <attr name="instanceClass" stringvalue="javax.swing.JSeparator" />

              </file>

              <attr boolvalue="true" name="Separator4.instance/ToolsAction.instance" />

              <file name="ToolsAction.instance">

                <attr name="instanceClass" stringvalue="org.openide.actions.ToolsAction" />

              </file>

              <attr boolvalue="true" name="ToolsAction.instance/PropertiesAction.instance" />

              <file name="PropertiesAction.instance">

                <attr name="instanceClass" stringvalue="org.openide.actions.PropertiesAction" />

              </file>

            </folder>

        </folder>

    </folder>

  </folder>

/*

 *                 Sun Public License Notice

 * 

 * The contents of this file are subject to the Sun Public License

 * Version 1.0 (the "License"). You may not use this file except in

 * compliance with the License. A copy of the License is available at

 * http://www.sun.com/

 * 

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

 * Code is Sun Microsystems, Inc. Portions Copyright 1997-2000 Sun

 * Microsystems, Inc. All Rights Reserved.

 */

package org.openide.loaders;

import java.beans.*;

import java.io.*;

import java.util.*;

import org.openide.ErrorManager;

import org.openide.cookies.InstanceCookie;

import org.openide.filesystems.*;

import org.openide.nodes.NodeOp;

import org.openide.util.Lookup;

import org.openide.util.NbBundle;

import org.openide.util.SharedClassObject;

import org.openide.util.Utilities;

import org.openide.util.actions.SystemAction;

import org.openide.util.io.SafeException;

/** Manages actions read and write for a given loader.

 *

 * @author Jaroslav Tulach

 */

final class DataLdrActions extends FolderInstance {

    /** Reference<DataLoader> to know for what loader we work */

    private java.lang.ref.Reference ref;

    /** last creating task */

    private org.openide.util.Task creation;

    /** processor to use */

    private static org.openide.util.RequestProcessor RP = new org.openide.util.RequestProcessor ("Loader Actions");

    public DataLdrActions (DataFolder f, DataLoader l) {

        super (f);

        this.ref = new java.lang.ref.WeakReference (l);

    }

    /** Asks the manager to store these actions to disk. Provided for

     * backward compatibility.

     */

    public synchronized void setActions (final SystemAction[] arr) {

        class DoTheWork implements Runnable, FileSystem.AtomicAction {

            private int state;

            /** The goal of this method is to make sure that all actions

             * will really be stored on the disk.

             */

            private void work () throws IOException {

                DataObject[] now = folder.getChildren ();

                HashMap nowToObj = new HashMap ();

                LinkedList sepObjs = new LinkedList ();

                for (int i = 0; i < now.length; i++) {

                    InstanceCookie ic = (InstanceCookie)now[i].getCookie (InstanceCookie.class);

                    if (ic != null) {

                        try {

                            Object instance = ic.instanceCreate ();

                            if (instance instanceof javax.swing.Action) {

                                nowToObj.put (instance, now[i]);

                                continue;

                            }

                            if (instance instanceof javax.swing.JSeparator) {

                                sepObjs.add (now[i]);

                                continue;

                            }

                        } catch (ClassNotFoundException ex) {

                            ErrorManager.getDefault ().notify (ex);

                        }

                    }

                }

                ArrayList order = new ArrayList ();

                for (int i = 0; i < arr.length; i++) {

                    DataObject obj = (DataObject)nowToObj.remove (arr[i]);

                    if (obj == null) {

                        if (arr[i] != null) {

                            obj = InstanceDataObject.create (folder, null, arr[i].getClass ());

                        } else {

                            if (!sepObjs.isEmpty ()) {

                                obj = (DataObject)sepObjs.removeFirst ();

                            } else {

                                obj = InstanceDataObject.create (folder, "Separator" + order.size (), javax.swing.JSeparator.class);

                            }

                        }

                    }

                    order.add (obj);

                }

                // these were there but are not there anymore

                for (Iterator it = nowToObj.values ().iterator (); it.hasNext (); ) {

                    DataObject obj = (DataObject)it.next ();

                    obj.delete ();

                }

                for (Iterator it = sepObjs.iterator (); it.hasNext (); ) {

                    DataObject obj = (DataObject)it.next ();

                    obj.delete ();

                }

                folder.setOrder ((DataObject[])order.toArray (new DataObject[0]));

            }

            public void run () {

                try {

                    switch (state) {

                        case 0:

                            state = 1;

                            folder.getPrimaryFile ().getFileSystem ().runAtomicAction (this);

                            break;

                        case 1:

                            work ();

                            break;

                    }

                } catch (IOException ex) {

                    ErrorManager.getDefault ().notify (ex);

                }

            }

        }

        DoTheWork dtw = new DoTheWork ();

        creation = RP.post (dtw);

    }

    /** Creates the actions and notifies the loader.

     */

    protected Object createInstance (org.openide.cookies.InstanceCookie[] cookies) throws java.io.IOException, ClassNotFoundException {

        ArrayList list = new ArrayList ();

        for (int i = 0; i < cookies.length; i++) {

            Class clazz = cookies[i].instanceClass ();

            if (javax.swing.JSeparator.class.isAssignableFrom (clazz)) {

                list.add (null);

                continue;

            }

            Object action = cookies[i].instanceCreate ();

            if (action instanceof javax.swing.Action) {

                list.add (action);

                continue;

            }

        }

        DataLoader l = (DataLoader)ref.get ();

        if (l != null) {

            l.setSwingActions (list);

        }

        return list.toArray (new javax.swing.Action[0]);

    }

    /** Currently not recursive */

    protected org.openide.cookies.InstanceCookie acceptFolder (DataFolder df) {

        return null;

    }

    /** Creation in our own thread, so we can exclude storage modifications */

    protected org.openide.util.Task postCreationTask (Runnable run) {

        return RP.post (run);

    }

    public void waitFinished () {

        org.openide.util.Task t;

        synchronized (this) {

            t = creation;

        }

        if (t != null) {

            t.waitFinished ();

        }

        super.waitFinished ();

    }

}

   /** key to hold reference to out action manager */

    private static final Object ACTION_MANAGER = new Object ();

    /** Actions manager.

     */

    private final DataLdrActions findManager () {

        Object manager = getProperty (ACTION_MANAGER);

        if (manager instanceof Class) {

            return null;

        }

        DataLdrActions mgr = (DataLdrActions)manager;

        boolean newlyCreated = false;

        if (mgr == null) {

            String context = actionsContext ();

            if (context == null) {

                // mark we have no context

                putProperty (ACTION_MANAGER, getClass ());

                return null;

            }

            FileObject fo = Repository.getDefault ().getDefaultFileSystem ().findResource (context);

            if (fo == null) {

                fo = Repository.getDefault ().getDefaultFileSystem ().getRoot ();

                try {

                    fo = FileUtil.createFolder (fo, context);

                } catch (IOException ex) {

                    ErrorManager.getDefault ().notify (ex);

                }

                newlyCreated = true;

            }

            mgr = new DataLdrActions (DataFolder.findFolder (fo), this);

            if (newlyCreated) {

                SystemAction[] arr = defaultActions ();

                if (arr != null) {

                    mgr.setActions (arr);

                }

            }

            putProperty (ACTION_MANAGER, mgr);

        }

        return mgr;

    }

    /** Allows the friend code (package and tests) to wait while actions

     * are synchronized with the state of disk.

     */

    final void waitForActions () {

        DataLdrActions mgr = findManager ();

        if (mgr != null) {

            mgr.waitFinished ();

        }

    }

                ClassLoader loader = (ClassLoader)Lookup.getDefault().lookup(ClassLoader.class);

                if (loader == null) {

                    loader = getClass ().getClassLoader ();

                }

    public Action[] getActions (boolean context) {

        if (systemActions == null) {

            systemActions = createActions ();

        }

        if (systemActions != null) {

            return systemActions;

        }

        return obj.getLoader ().getSwingActions ();

    }

    /** Get actions for this data object.

    * @deprecated Use getActions(boolean)

    * @return array of actions or <code>null</code>

    */

/*

 *                 Sun Public License Notice

 * 

 * The contents of this file are subject to the Sun Public License

 * Version 1.0 (the "License"). You may not use this file except in

 * compliance with the License. A copy of the License is available at

 * http://www.sun.com/

 * 

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

 * Code is Sun Microsystems, Inc. Portions Copyright 1997-2001 Sun

 * Microsystems, Inc. All Rights Reserved.

 */

package org.openide.loaders;

import junit.textui.TestRunner;

import org.openide.filesystems.*;

import org.openide.util.Lookup;

import java.io.IOException;

import java.util.*;

import org.netbeans.junit.*;

import java.beans.PropertyChangeListener;

import javax.swing.Action;

import org.openide.util.io.NbMarshalledObject;

/** Check how the default behaviour of DataLoader without overriden

 * actionsContext works.

 *

 * @author Jaroslav Tulach 

 */

public class DataLoaderGetActionsCompatibilityTest extends NbTestCase {

    /** sample data object */

    private DataObject obj;

    /** its node */

    private org.openide.nodes.Node node;

    /** monitor sfs */

    private PCL sfs;

    public DataLoaderGetActionsCompatibilityTest (String name) {

        super(name);

    }

    public static void main(String[] args) {

        if (args.length == 1) {

            TestRunner.run (new DataLoaderGetActionsCompatibilityTest (args[0]));

        } else {

            TestRunner.run(new NbTestSuite(DataLoaderGetActionsCompatibilityTest.class));

        }

    }

    /**

     * Sets up the testing environment by creating testing folders

     * on the system file system.

     */

    protected void setUp () throws Exception {

        System.setProperty ("org.openide.util.Lookup", "org.openide.loaders.DataLoaderGetActionsCompatibilityTest$Lkp");

        assertEquals ("Our lookup is installed", Lookup.getDefault ().getClass (), Lkp.class);

        MyDL loader = (MyDL)MyDL.getLoader (MyDL.class);

        FileSystem dfs = Repository.getDefault().getDefaultFileSystem();

        dfs.refresh (true);        

        FileObject fo = FileUtil.createData (dfs.getRoot (), "a.txt");

        obj = DataObject.find (fo);

        assertEquals ("The correct loader", loader, obj.getLoader ());

        node = obj.getNodeDelegate ();    

        sfs = new PCL ();

        dfs.addFileChangeListener (sfs);

    }

    /**

     * Deletes the folders created in method setUp().

     */

    protected void tearDown() throws Exception {

        obj.getLoader ().setActions (new org.openide.util.actions.SystemAction[0]);

        int l = node.getActions (false).length;

        if (l != 0) {

            fail ("Not empty actions at the end!!!");

        }

        Repository.getDefault ().getDefaultFileSystem ().removeFileChangeListener (sfs);

        // no suspicious activity on getDefaultFileSystem

        sfs.assertEvent (0, null);

    }

    public void testDefaultActionContextReturnsNull () {

        assertNull (obj.getLoader ().actionsContext ());

    }

    public void testDefaultActionsUsedWhenCreatedForTheFirstTime () throws Exception {

        SndDL loader = (SndDL)SndDL.getLoader (SndDL.class);

        org.openide.util.actions.SystemAction[] arr = loader.getActions ();

        assertEquals (

            "Arrays of actions are the same", 

            java.util.Arrays.asList (loader.defaultActions ()),

            java.util.Arrays.asList (arr)

        );

    }

    /** Test to check that the deserialization of actions works as expected.

     */

    public void testNoDeserializationOfActions () throws Exception {

        assertEquals("No actions at the start", 0, node.getActions(false).length);

        PCL pcl = new PCL ();

        obj.getLoader ().addPropertyChangeListener (pcl);

        obj.getLoader ().setActions (new org.openide.util.actions.SystemAction[] {

                org.openide.util.actions.SystemAction.get (org.openide.actions.PropertiesAction.class)

        });

        pcl.assertEvent (1, "actions");

        Action [] res = node.getActions(false);

        assertEquals("There should be exactly one action.", 1, res.length);

        NbMarshalledObject m = new NbMarshalledObject (obj.getLoader ());

        obj.getLoader ().setActions (new org.openide.util.actions.SystemAction[0]);

        pcl.assertEvent (2, "actions");

        assertEquals("No actions after setting empty array", 0, node.getActions(false).length);

        assertEquals ("Loader deserialized", obj.getLoader (), m.get ());

        res = node.getActions(false);

        assertEquals("One action", 1, res.length);

        assertEquals (

            "and that is the property action", 

            org.openide.util.actions.SystemAction.get (org.openide.actions.PropertiesAction.class),

            res[0]

        );

        obj.getLoader ().removePropertyChangeListener (pcl);

    }

    /** Loader that does not override the actionsContext.

     */

    private static class MyDL extends UniFileLoader {

        public MyDL () {

            super ("org.openide.loaders.DataObject");

            getExtensions ().addExtension ("txt");

        }

        protected org.openide.loaders.MultiDataObject createMultiObject (FileObject primaryFile) throws org.openide.loaders.DataObjectExistsException, IOException {

            return new MultiDataObject (primaryFile, this);

        }

        protected org.openide.util.actions.SystemAction[] defaultActions () {

            return new org.openide.util.actions.SystemAction[0];

        }

    } // end of MyDL

    //

    // Our fake lookup

    //

    public static final class Lkp extends org.openide.util.lookup.AbstractLookup {

        public Lkp () throws Exception {

            this (new org.openide.util.lookup.InstanceContent ());

        }

        private Lkp (org.openide.util.lookup.InstanceContent ic) throws Exception {

            super (ic);

            TestUtilHid.destroyLocalFileSystem (Lkp.class.getName ());

            ic.add (new Repository (TestUtilHid.createLocalFileSystem (Lkp.class.getName (), new String[0])));

            ic.add (new Pool ());

//            ic.add (new EM ());

        }

    }

    private static final class Pool extends DataLoaderPool {

        protected java.util.Enumeration loaders () {

            return org.openide.util.Enumerations.singleton (

                DataLoader.getLoader(MyDL.class)

            );

        }

    } // end of Pool

    private final class PCL implements org.openide.filesystems.FileChangeListener, java.beans.PropertyChangeListener {

        int cnt;

        String name;

        public void propertyChange (java.beans.PropertyChangeEvent ev) {

            name = ev.getPropertyName();

            cnt++;

        }

        public void assertEvent (int cnt, String name) {

            obj.getLoader ().waitForActions ();

            if (cnt != this.cnt) {

                fail ("Excepted more changes then we got: expected: " + cnt + " we got: " + this.cnt + " with name: " + this.name);

            }

        }

        public void fileAttributeChanged(org.openide.filesystems.FileAttributeEvent fe) {

            cnt++;

            name = "fileAttributeChanged";

        }

        public void fileChanged(org.openide.filesystems.FileEvent fe) {

            cnt++;

            name = "fileChanged";

        }

        public void fileDataCreated(org.openide.filesystems.FileEvent fe) {

            cnt++;

            name = "fileDataCreated";

        }

        public void fileDeleted(org.openide.filesystems.FileEvent fe) {

            cnt++;

            name = "fileDeleted";

        }

        public void fileFolderCreated(org.openide.filesystems.FileEvent fe) {

            cnt++;

            name = "fileFolderCreated";

        }

        public void fileRenamed(org.openide.filesystems.FileRenameEvent fe) {

            cnt++;

            name = "fileRenamed";

        }

    } // end of PCL

    public static final class SndDL extends MyDL {

        public SndDL () {

            getExtensions ().addExtension ("bla");

        }

        protected org.openide.util.actions.SystemAction[] defaultActions () {

            return new org.openide.util.actions.SystemAction[] {

                org.openide.util.actions.SystemAction.get (org.openide.actions.CutAction.class),

                null,

                org.openide.util.actions.SystemAction.get (org.openide.actions.CopyAction.class),

                null,

                org.openide.util.actions.SystemAction.get (org.openide.actions.DeleteAction.class),

            };

        }

    }

}

/*

 *                 Sun Public License Notice

 * 

 * The contents of this file are subject to the Sun Public License

 * Version 1.0 (the "License"). You may not use this file except in

 * compliance with the License. A copy of the License is available at

 * http://www.sun.com/

 * 

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

 * Code is Sun Microsystems, Inc. Portions Copyright 1997-2001 Sun

 * Microsystems, Inc. All Rights Reserved.

 */

package org.openide.loaders;

import junit.textui.TestRunner;

import org.openide.filesystems.*;

import org.openide.util.Lookup;

import java.io.IOException;

import java.util.*;

import org.netbeans.junit.*;

import java.beans.PropertyChangeListener;

import javax.swing.Action;

import org.openide.util.io.NbMarshalledObject;

/** Tests the proposed behaviour of DataLoader.getActions that is going 

 * to read its values from layer.

 *

 * @author Jaroslav Tulach (taken from openidex/enode by David Strupl)

 */

public class DataLoaderGetActionsTest extends NbTestCase {

    /** root folder FileObject */

    private FileObject root;

    /** sample data object */

    private DataObject obj;

    /** its node */

    private org.openide.nodes.Node node;

    public DataLoaderGetActionsTest (String name) {

        super(name);

    }

    public static void main(String[] args) {

        if (args.length == 1) {

            TestRunner.run (new DataLoaderGetActionsTest (args[0]));

        } else {

            TestRunner.run(new NbTestSuite(DataLoaderGetActionsTest.class));

        }

    }

    /**

     * Sets up the testing environment by creating testing folders

     * on the system file system.

     */

    protected void setUp () throws Exception {

        System.setProperty ("org.openide.util.Lookup", "org.openide.loaders.DataLoaderGetActionsTest$Lkp");

        assertEquals ("Our lookup is installed", Lookup.getDefault ().getClass (), Lkp.class);

        MyDL loader = (MyDL)MyDL.getLoader (MyDL.class);

        FileSystem dfs = Repository.getDefault().getDefaultFileSystem();

        dfs.refresh (true);        

        root = FileUtil.createFolder (dfs.getRoot (), loader.actionsContext ());

        FileObject fo = FileUtil.createData (dfs.getRoot (), "a.txt");

        obj = DataObject.find (fo);

        assertEquals ("The correct loader", loader, obj.getLoader ());

        node = obj.getNodeDelegate ();    

    }

    /**

     * Deletes the folders created in method setUp().

     */

    protected void tearDown() throws Exception {

        FileObject[] arr = root.getChildren ();

        for (int i = 0; i < arr.length; i++) {

            arr[i].delete();

        }

        int l = node.getActions (false).length;

        if (l != 0) {

            System.err.println("Not empty actions at the end!!!");

        }

    }

    /**

     * This test tests the presence of declarative actions from

     * system file system without the hierarchical flag set (the ExtensibleNode

     * instance is created with constructor ExtensibleNode("test", false).

     * The tests performs following steps:

     * <OL><LI> Create an instance of ExtensibleNode with folder set to "test"

     *     <LI> No actions should be returned by getActions since the "test" folder

     *          is not there

     *     <LI> Create one action in the testing folder

     *     <LI> The action should be visible in the result of getActions

     *     <LI> After deleting the action from the folder the action should

     *          not be returned from getActions().

     * </OL>

     */

    public void testCreateAndDeleteAction() throws Exception {

        assertEquals("No actions at the start", 0, node.getActions(false).length);

        FileObject test = root;

        PCL pcl = new PCL ();

        obj.getLoader ().addPropertyChangeListener (pcl);

        FileObject a1 = test.createData("org-openide-actions-PropertiesAction.instance");

        pcl.assertEvent (1, "actions");

        Action [] res = node.getActions(false);

        assertEquals("There should be exactly one action.", 1, res.length);

        a1.delete();

        pcl.assertEvent (2, "actions");

        assertEquals("No actions after deleting", 0, node.getActions(false).length);

        obj.getLoader ().removePropertyChangeListener (pcl);

    }

    /**

     * An attempt to create a simple stress test. Just calls

     * the <code>testCreateAndDeleteAction</code> 100 times.

     */

    public void testRepetitiveDeleting() throws Exception {

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

            testCreateAndDeleteAction();

        }

    }

    /**

     * This test should test behaviour of the getActions method when

     * there is some alien object specified in the configuration folder.

     * The testing object is of type Integer (instead of javax.swing.Action).

     */

    public void testWrongActionObjectInConfig() throws Exception {

        assertEquals("No actions at the start", 0, node.getActions(false).length);

        FileObject test = root;

        FileObject a1 = test.createData("java-lang-String.instance");

        Action [] res = node.getActions(false);

        assertEquals("There should be zero actions.", 0, res.length);        

    }

    /**

     * This test checks whether the JSeparator added from the configuration

     * file is reflected in the resulting popup.

     * The tests performs following steps:

     * <OL><LI> Create an instance of ExtensibleNode with folder set to "test"

     *     <LI> No actions should be returned by getActions since the "test" folder

     *          is not there

     *     <LI> Create two actions in the testing folder separated by JSeparator

     *     <LI> getActions should return 3 elements - null element for the separator

     *     <LI> Popup is created from the actions array - the null element

     *              should be replaced by a JSeparator again

     * </OL>

     */

    public void testAddingSeparators() throws Exception {

        org.openide.nodes.Node en1 = node;

        assertEquals("No actions at the start", 0, en1.getActions(false).length);

        FileObject test = root;

        FileObject a1 = test.createData("1[org-openide-actions-PropertiesAction].instance");

        FileObject sep = test.createData("2[javax-swing-JSeparator].instance");

        FileObject a2 = test.createData("3[org-openide-actions-CutAction].instance");

        javax.swing.Action[] actions = en1.getActions(false);

        assertEquals("Actions array should contain 3 elements", 3, actions.length);

        assertNull("separator should create null element in the array", actions[1]);

        javax.swing.JPopupMenu jp = org.openide.util.Utilities.actionsToPopup(actions, org.openide.util.lookup.Lookups.singleton(en1));

        assertEquals("Popup should contain 3 components", 3, jp.getComponentCount());

        assertTrue("Separator should be second", jp.getComponent(1) instanceof javax.swing.JSeparator);

    }

    /** Test to see whether a compatibility behaviour is still kept. E.g.

     * if one adds actions using DataLoader.setActions they really will be 

     * there.

     */

    public void testCompatibilityIsPropagatedToDisk () throws Exception {

        assertEquals("No actions at the start", 0, node.getActions(false).length);

        FileObject test = root;

        PCL pcl = new PCL ();

        obj.getLoader ().addPropertyChangeListener (pcl);

        obj.getLoader ().setActions (new org.openide.util.actions.SystemAction[] {

                org.openide.util.actions.SystemAction.get (org.openide.actions.PropertiesAction.class)

        });

        pcl.assertEvent (1, "actions");

        Action [] res = node.getActions(false);

        assertEquals("There should be exactly one action.", 1, res.length);

        assertEquals("One file created", 1, test.getChildren ().length);

        obj.getLoader ().setActions (new org.openide.util.actions.SystemAction[0]);

        pcl.assertEvent (2, "actions");

        assertEquals("No actions after deleting", 0, node.getActions(false).length);

        assertEquals("file disappeared", 0, test.getChildren ().length);

        obj.getLoader ().removePropertyChangeListener (pcl);

    }

    /** Test to check that the deserialization of actions is completely ignored.

     */

    public void testNoDeserializationOfActions () throws Exception {

        assertEquals("No actions at the start", 0, node.getActions(false).length);

        FileObject test = root;

        PCL pcl = new PCL ();

        obj.getLoader ().addPropertyChangeListener (pcl);

        obj.getLoader ().setActions (new org.openide.util.actions.SystemAction[] {

                org.openide.util.actions.SystemAction.get (org.openide.actions.PropertiesAction.class)

        });

        pcl.assertEvent (1, "actions");

        Action [] res = node.getActions(false);

        assertEquals("There should be exactly one action.", 1, res.length);

        assertEquals("One file created", 1, test.getChildren ().length);

        NbMarshalledObject m = new NbMarshalledObject (obj.getLoader ());

        obj.getLoader ().setActions (new org.openide.util.actions.SystemAction[0]);

        pcl.assertEvent (2, "actions");

        assertEquals("No actions after deleting", 0, node.getActions(false).length);

        assertEquals("file disappeared", 0, test.getChildren ().length);

        assertEquals ("Loader deserialized", obj.getLoader (), m.get ());

        assertEquals("Still no actions", 0, node.getActions(false).length);

        obj.getLoader ().removePropertyChangeListener (pcl);

    }

    public void testDefaultActionsUsedWhenCreatedForTheFirstTime () throws Exception {

        SndDL loader = (SndDL)SndDL.getLoader (SndDL.class);

        org.openide.util.actions.SystemAction[] arr = loader.getActions ();

        assertEquals (

            "Arrays of actions are the same", 

            java.util.Arrays.asList (loader.defaultActions ()),

            java.util.Arrays.asList (arr)

        );

    }

    private static class MyDL extends UniFileLoader {

        public MyDL () {

            super ("org.openide.loaders.DataObject");

            getExtensions ().addExtension ("txt");

        }

        /** Returns the name of the folder to read the actions from

         */

        protected String actionsContext () {

            return "test";

        }

        protected org.openide.loaders.MultiDataObject createMultiObject (FileObject primaryFile) throws org.openide.loaders.DataObjectExistsException, IOException {

            return new MultiDataObject (primaryFile, this);

        }

        protected org.openide.util.actions.SystemAction[] defaultActions () {

            return new org.openide.util.actions.SystemAction[0];

        }

    } // end of MyDL

    //

    // Our fake lookup

    //

    public static final class Lkp extends org.openide.util.lookup.AbstractLookup {

        public Lkp () throws Exception {

            this (new org.openide.util.lookup.InstanceContent ());

        }

        private Lkp (org.openide.util.lookup.InstanceContent ic) throws Exception {

            super (ic);

            TestUtilHid.destroyLocalFileSystem (Lkp.class.getName ());

            ic.add (new Repository (TestUtilHid.createLocalFileSystem (Lkp.class.getName (), new String[0])));

            ic.add (new Pool ());

//            ic.add (new EM ());

        }

    }

    private static final class Pool extends DataLoaderPool {

        protected java.util.Enumeration loaders () {

            return new org.openide.util.enum.SingletonEnumeration (

                DataLoader.getLoader(MyDL.class)

            );

        }

    } // end of Pool

    private final class PCL 

    implements java.beans.PropertyChangeListener {

        int cnt;

        String name;

        public void propertyChange (java.beans.PropertyChangeEvent ev) {

            name = ev.getPropertyName();

            cnt++;

        }

        public void assertEvent (int cnt, String name) {

            obj.getLoader ().waitForActions ();

            if (cnt > this.cnt) {

                fail ("Excepted more changes then we got: expected: " + cnt + " we got: " + this.cnt);

            }

            assertEquals ("same name", name, this.name);

        }

    } // end of PCL

    public static final class SndDL extends MyDL {

        public SndDL () {

            getExtensions ().addExtension ("bla");

        }

        protected org.openide.util.actions.SystemAction[] defaultActions () {

            return new org.openide.util.actions.SystemAction[] {

                org.openide.util.actions.SystemAction.get (org.openide.actions.CutAction.class),

                null,

                org.openide.util.actions.SystemAction.get (org.openide.actions.CopyAction.class),

                null,

                org.openide.util.actions.SystemAction.get (org.openide.actions.DeleteAction.class),

            };

        }

        protected String actionsContext () {

            return "2ndtestdir";

        }

    }

}

    public void testTheProblemWithI18NOptions () throws Exception {

        I18NLikeOption s = (I18NLikeOption)I18NLikeOption.findObject (I18NLikeOption.class, true);

        assertFalse ("Not set by default", s.isAdvancedWizard ());

        s.setAdvancedWizard (true);

        assertTrue ("Changes to true", s.isAdvancedWizard ());

        s.reset ();

        assertFalse ("Is cleared", s.isAdvancedWizard ());

        s.setAdvancedWizard (true);

        assertTrue ("yes again", s.isAdvancedWizard ());

        s.setAdvancedWizard (false);

        assertFalse ("no again", s.isAdvancedWizard ());

        s.reset ();

        assertFalse ("still no", s.isAdvancedWizard ());

    }

    <folder name="Loaders">

        <folder name="folder">

            <folder name="any">

                <folder name="Actions">

                    <file name="NewTemplateAction.instance_hidden" />

                    <file name="NewProjectFile.instance">

                        <attr name="instanceClass" stringvalue="org.netbeans.modules.project.ui.actions.Actions$SystemNewFile" />

                    </file>

                    <attr boolvalue="true" name="NewProjectFile.instance/FileSystemAction.instance" />

                </folder>

            </folder>

        </folder>

    </folder>

  <folder name="Loaders">

    <folder name="text">

        <folder name="x-java">

            <folder name="Actions">

              <attr boolvalue="true" name="DeleteAction.instance/SaveAsTemplateAction.instance" />

              <attr boolvalue="true" name="SaveAsTemplateAction.instance/RefactoringWhereUsed.instance" />

              <attr boolvalue="true" name="Separator4.instance/RefactoringWhereUsed.instance" />

              <file name="RefactoringWhereUsed.instance">

                <attr name="instanceClass" stringvalue="org.netbeans.modules.refactoring.ui.WhereUsedAction" />

              </file>

              <attr boolvalue="true" name="RefactoringWhereUsed.instance/RefactoringAll.instance" />

              <file name="RefactoringAll.instance">

                <attr name="instanceClass" stringvalue="org.netbeans.modules.refactoring.ui.RSMJavaDOAction" />

              </file>

              <attr boolvalue="true" name="RefactoringAll.instance/RefactoringSeparator-1.instance" />

              <file name="RefactoringSeparator-1.instance">

                <attr name="instanceClass" stringvalue="javax.swing.JSeparator" />

              </file>

              <attr boolvalue="true" name="RefactoringSeparator-1.instance/ToolsAction.instance" />

              <file name="RenameAction.instance_hidden" />

            </folder>

        </folder>

    </folder>

    <folder name="folder">

        <folder name="any">

            <folder name="Actions">

              <attr boolvalue="true" name="DeleteAction.instance/RefactoringAll.instance" />

              <file name="RefactoringAll.instance">

                <attr name="instanceClass" stringvalue="org.netbeans.modules.refactoring.ui.RSMJavaDOAction" />

              </file>

              <attr boolvalue="true" name="RefactoringAll.instance//Separator3.instance" />

              <file name="RenameAction.instance_hidden" />

            </folder>

        </folder>

    </folder>

  </folder>