Attachment #16876 for bug #43189

This Bugzilla instance is a read-only archive of historic NetBeans bug reports. To report a bug in NetBeans please follow the project's instructions for reporting issues.

View | Details | Raw Unified | Return to bug 43189
Collapse All | Expand All




import java.io.File;
import java.lang.ref.*;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.*;
import javax.swing.Action;
import javax.swing.UIManager;

import org.openide.filesystems.*;
import org.openide.util.HelpCtx;
import org.openide.nodes.*;
import org.openide.options.SystemOption;
import org.openide.util.Lookup;
import org.openide.util.NbBundle;
import org.openide.util.RequestProcessor;
import org.openide.util.SharedClassObject;

/** A folder containing data objects.
* Is actually itself a data object, whose primary (and only) file object

            throw new IllegalArgumentException ("Not folder: " + fo); // NOI18N
        }
        list = reassignList (fo, attach);
        
        // if this is not DefaultFS then start listening on IDESettings
        try {
            if (!isDefaultFS()) {
                initGlobalSorting();
                if (ideSettings != null && getSortingMethod != null) {
                    ideSettings.addPropertyChangeListener(new PropertyChangeListener() {
                            public void propertyChange(PropertyChangeEvent evt) {
                                if ("sorting".equals(evt.getPropertyName())) { //NOI18N
                                    list.changeComparator();
                                    firePropertyChange (PROP_SORT_MODE, null, null);
                                }
                            }
                        });
                }
            }
        } catch (IOException e) {
            ErrorManager.getDefault().log(ErrorManager.WARNING, e.toString());
            // OK, no sorting
        }
        
    }
    
    /** Attaches a listener to the folder list, removes any previous one if registered.

    * @exception IOException if the mode cannot be set
    */
    public synchronized final void setSortMode (SortMode mode) throws IOException {
        if (!isDefaultFS()) {
            throw new IOException("Order can be set only on DefaultFileSystem DataFolders."); // NOI18N
        }
        SortMode old = getOrder ().getSortMode ();
        getOrder ().setSortMode (mode);
        firePropertyChange (PROP_SORT_MODE, old, getOrder ().getSortMode ());

    *
    */
    public synchronized final void setOrder (DataObject[] arr) throws IOException {
        if (!isDefaultFS()) {
            throw new IOException("Order can be set only on DefaultFileSystem DataFolders."); // NOI18N
        }
        getOrder ().setOrder (arr);
        firePropertyChange (PROP_ORDER, null, null);
    }
    
    private boolean isDefaultFS() throws IOException {
        return getPrimaryFile().getFileSystem().equals(Repository.getDefault().getDefaultFileSystem());
    }
    
    // XXX: find IDESettings and read the global sort mode.
    // Ugly, but there is no other way. Should be resolved once
    // we have Settings API.
    static SortMode getGlobalSorting() {
        try {
            if (ideSettings != null && getSortingMethod != null) {
                return (SortMode)getSortingMethod.invoke(ideSettings, new Object[0]);
            }
        } catch (Exception e) {
            // ignore, default sorting will be used
            ErrorManager.getDefault().log(ErrorManager.WARNING, e.toString());
        }
        return SortMode.FOLDER_NAMES;
    }
    
    // XXX: find IDESettings and read the global sort mode.
    // Ugly, but there is no other way. Should be resolved once
    // we have Settings API.
    static synchronized void initGlobalSorting() {
        try {
            if (!globalSortingInitialized) {
                globalSortingInitialized = true;
                ClassLoader l = (ClassLoader) Lookup.getDefault().lookup(ClassLoader.class);
                Class clazz = l.loadClass("org.netbeans.core.IDESettings"); // NOI18N
                ideSettings = (SystemOption)SharedClassObject.findObject(clazz, true);
                if (ideSettings != null) {
                    getSortingMethod = clazz.getMethod("getSorting", null); // NOI18N
                    assert getSortingMethod != null;
                }
            }
        } catch (Exception e) {
            ErrorManager.getDefault().notify(e);
        }
    }

    // IDESettings instance
    private static SystemOption ideSettings;
    
    // IDESettings.getSortingMethod() method
    private static Method getSortingMethod;
    
    // was IDESettings already initialized?
    private static boolean globalSortingInitialized = false;
    
    /** Getter for order object.
    * @return order of children
    */

        */
        protected Sheet createSheet () {
            Sheet s = super.createSheet ();
            try {
                if (!DataFolder.this.isDefaultFS()) {
                    return s;
                }
            } catch (IOException ex) {
                // something wrong: disable sorting
                return s;
            }

            Sheet.Set ss = new Sheet.Set ();
            ss.setName (SET_SORTING);

Lines 34-42 Link Here

(-)loaders/src/org/openide/loaders/DataShadow.java (-3 / +30 lines)
34	import org.openide.util.MutexException;	34	import org.openide.util.MutexException;
35		35
36	/** Default implementation of a shortcut to another data object.	36	/** Default implementation of a shortcut to another data object.
37	* Since 1.13 it extends MultiDataObject.	37	* Since 1.13 it extends MultiDataObject.
38	* @author Jan Jancura, Jaroslav Tulach	38	* <p><strong>Usage deprecation:</strong> usage of DataShadow on
39	*/	39	* non-DefaultFileSystem is deprecated. Also a DataShadow on DefaultFileSystem
		40	* can point only to file/folder on DefaultFileSystem. The main usage of
		41	* DataShadow on client filesystems was in old project system which is now
		42	* replaced by buildsystem. If there is somebody who still need this
		43	* functionality they should think about Datasystems independent solution,
		44	* because #1) Datasystems are planned for redesign and #2) after Settings
		45	* API is implemented the DataShadow will be fully deprecated.
		46	* @author Jan Jancura, Jaroslav Tulach
		47	*/
40	public class DataShadow extends MultiDataObject implements DataObject.Container {	48	public class DataShadow extends MultiDataObject implements DataObject.Container {
41	/** generated Serialized Version UID */	49	/** generated Serialized Version UID */
42	static final long serialVersionUID = 6305590675982925167L;	50	static final long serialVersionUID = 6305590675982925167L;
Lines 238-243 Link Here
238	private void init(DataObject original) {	246	private void init(DataObject original) {
239	if (original == null)	247	if (original == null)
240	throw new IllegalArgumentException();	248	throw new IllegalArgumentException();
		249	try {
		250	if (!original.getPrimaryFile().getFileSystem().equals(
		251	Repository.getDefault().getDefaultFileSystem())) {
		252	ErrorManager.getDefault().log(ErrorManager.WARNING, "Usage of " +
		253	"DataShadow on non-DefaultFileSystem was deprecated. Found: "+this); // NOI18N
		254	}
		255	} catch (FileStateInvalidException e) {
		256	ErrorManager.getDefault().log(ErrorManager.WARNING, e.toString());
		257	}
241	setOriginal (original);	258	setOriginal (original);
242	enqueueDataShadow(this);	259	enqueueDataShadow(this);
243	}	260	}
Lines 391-396 Link Here
391	*/	408	*/
392	protected static DataObject deserialize (FileObject fileObject) throws java.io.IOException {	409	protected static DataObject deserialize (FileObject fileObject) throws java.io.IOException {
393	URL url = readURL(fileObject);	410	URL url = readURL(fileObject);
		411	checkDeprecatedUsage(fileObject, url);
394	FileObject fo = URLMapper.findFileObject(url);	412	FileObject fo = URLMapper.findFileObject(url);
395	if (fo == null) {	413	if (fo == null) {
396	throw new java.io.FileNotFoundException (url.toExternalForm());	414	throw new java.io.FileNotFoundException (url.toExternalForm());
Lines 398-403 Link Here
398	return DataObject.find (fo);	416	return DataObject.find (fo);
399	}	417	}
400		418
		419	private static void checkDeprecatedUsage(FileObject fo, URL u) {
		420	if (u != null && (!u.getProtocol().startsWith("nbfs"))) {
		421	ErrorManager.getDefault().log(ErrorManager.WARNING, "Found " + // NOI18N
		422	"DataShadow which points to a non-DefaultFileSystem file. " + // NOI18N
		423	"Such a usage was deprecated. It is "+fo+" and it points to "+u); // NOI18N
		424	}
		425	}
		426
401	static URL readURL(final FileObject f) throws IOException {	427	static URL readURL(final FileObject f) throws IOException {
402	if ( f.getSize() == 0 ) {	428	if ( f.getSize() == 0 ) {
403	Object fileName = f.getAttribute ("originalFile"); // NOI18N	429	Object fileName = f.getAttribute ("originalFile"); // NOI18N
Lines 562-567 Link Here
562		588
563	private void tryUpdate() throws IOException {	589	private void tryUpdate() throws IOException {
564	URL url = readURL(getPrimaryFile ());	590	URL url = readURL(getPrimaryFile ());
		591	checkDeprecatedUsage(getPrimaryFile(), url);
565	if (url.equals(original.getPrimaryFile().getURL())) {	592	if (url.equals(original.getPrimaryFile().getURL())) {
566	return;	593	return;
567	}	594	}

Lines 13-18 Link Here

(-)loaders/src/org/openide/loaders/FolderComparator.java (-1 / +18 lines)
13		13
14	package org.openide.loaders;	14	package org.openide.loaders;
15		15
		16	import java.io.InvalidObjectException;
		17	import java.io.ObjectStreamException;
		18	import java.io.Serializable;
16	import java.util.*;	19	import java.util.*;
17	import org.openide.filesystems.FileObject;	20	import org.openide.filesystems.FileObject;
18		21
Lines 23-29 Link Here
23	* Compares objects in a folder.	26	* Compares objects in a folder.
24	* @author Jaroslav Tulach, Jesse Glick	27	* @author Jaroslav Tulach, Jesse Glick
25	*/	28	*/
26	class FolderComparator extends DataFolder.SortMode implements Comparator {	29	class FolderComparator extends DataFolder.SortMode implements Comparator, Serializable {
27	/** modes */	30	/** modes */
28	public static final int NONE = 0;	31	public static final int NONE = 0;
29	public static final int NAMES = 1;	32	public static final int NAMES = 1;
Lines 37-42 Link Here
37	/** by folders, then size */	40	/** by folders, then size */
38	public static final int SIZE = 5;	41	public static final int SIZE = 5;
39		42
		43	private static final long serialVersionUID = 3328227315468795461L;
40		44
41	/** mode to use */	45	/** mode to use */
42	private int mode;	46	private int mode;
Lines 211-214 Link Here
211	}	215	}
212	}	216	}
213		217
		218	private Object readResolve() throws ObjectStreamException {
		219	switch (mode) {
		220	case NONE: return DataFolder.SortMode.NONE;
		221	case NAMES: return DataFolder.SortMode.NAMES;
		222	case CLASS: return DataFolder.SortMode.CLASS;
		223	case FOLDER_NAMES: return DataFolder.SortMode.FOLDER_NAMES;
		224	case LAST_MODIFIED: return DataFolder.SortMode.LAST_MODIFIED;
		225	case SIZE: return DataFolder.SortMode.SIZE;
		226	default:
		227	throw new InvalidObjectException("Cannot deserialize FolderComparator for mode "+mode); // NOI18N
		228	}
		229	}
		230
214	}	231	}

Lines 262-268 Link Here

(-)loaders/src/org/openide/loaders/FolderList.java (-2 / +2 lines)
262		262
263	/** Setter for sort mode.	263	/** Setter for sort mode.
264	*/	264	*/
265	private synchronized void changeComparator () {	265	synchronized void changeComparator () {
266	final boolean LOG = err.isLoggable(ErrorManager.INFORMATIONAL);	266	final boolean LOG = err.isLoggable(ErrorManager.INFORMATIONAL);
267	if (LOG) err.log ("changeComparator on " + folder);	267	if (LOG) err.log ("changeComparator on " + folder);
268	final RequestProcessor.Task previous = comparatorTask;	268	final RequestProcessor.Task previous = comparatorTask;
Lines 813-819 Link Here
813	*/	813	*/
814	private void fireChildrenChange (Collection add, Collection removed) {	814	private void fireChildrenChange (Collection add, Collection removed) {
815	if (pcs != null) {	815	if (pcs != null) {
816	if (!add.isEmpty() \|\| !removed.isEmpty()) {	816	if ((!add.isEmpty() \|\| !removed.isEmpty()) && !add.equals(removed)) {
817	pcs.firePropertyChange (PROP_CHILDREN, null, null);	817	pcs.firePropertyChange (PROP_CHILDREN, null, null);
818	}	818	}
819	}	819	}





import java.io.IOException;
import java.util.*;
import org.openide.ErrorManager;

import org.openide.filesystems.*;
import org.openide.loaders.DataFolder.SortMode;

 *
 * @author  Jaroslav Tulach
 */
class FolderOrder extends Object implements Comparator {
    /** Separator of names of two files. The first file should be before
     * the second one in partial ordering
     */


    /** Stores the order to files.
    */
    private void write () throws IOException {
        // Let it throw the IOException:
        //if (folder.getFileSystem ().isReadOnly ()) return; // cannot write to read-only FS
        if (order == null) {

    * @return the order
    */
    public static FolderOrder findFor (FileObject folder) {
        try {
            if (!folder.getFileSystem().equals(Repository.getDefault().getDefaultFileSystem())) {
                return getGlobalOrdering();
            }
        } catch (FileStateInvalidException ex) {
            // something wrong, return global order
            ErrorManager.getDefault().log(ErrorManager.WARNING, ex.toString());
            return getGlobalOrdering();
        }
        FolderOrder order = null;
        synchronized (map) {
            Reference ref = (Reference)map.get (folder);

            return order;            
        }        
    }

    private static FolderOrder globalFolderOrder;
    
    private static synchronized FolderOrder getGlobalOrdering() {
        if (globalFolderOrder == null) {
            globalFolderOrder = new GlobalFolderOrder();
        }
        return globalFolderOrder;
    }
    
    private static class GlobalFolderOrder extends FolderOrder {
        
        private GlobalFolderOrder() {
            super(null);
            DataFolder.initGlobalSorting();
        }
        
        public void setSortMode(SortMode mode) throws IOException {
            // ignore
        }
        
        public SortMode getSortMode() {
            return DataFolder.getGlobalSorting();
        }
        
        public void setOrder(DataObject[] arr) throws IOException {
            // ignore
        }
        
        public Map getOrderingConstraints(Collection objects) {
            // ignore
            return null;
        }
        
    }
    
}




        <testset dir="unit/src">
            <patternset>
                <!-- Add your own code tests -->
                <include name="org/openide/loaders/InstanceDataObjectTest.class/testFiringEventWhenDeleted"/>
                <!-- Don't worry about these, cannot be fixed currently: -->
                <exclude name="org/openide/loaders/DataFolderTest.class/testSortMode"/> <!-- failing in cont. test -->
                <exclude name="org/openide/loaders/DataFolderTest.class/testMove"/> <!-- failing in cont. test -->
                <exclude name="org/openide/loaders/DataFolderTest.class/testPropChildrenFiredAfterInvalidation"/> <!-- failing in cont. test -->
                <exclude name="org/openide/loaders/DataFolderTest.class/testOrderWhenMultiFileSystemSetDelegatesIsCalled" /> <!-- failing in cont. test -->
                <!-- following was disabled because of issue #20179 -->
                <exclude name="org/openide/loaders/DataFolderMoveTest.class"/>
                <!-- does not work an nobody knows why -->
                <exclude name="org/openide/loaders/FolderInstanceTest.class/testFolderInstanceNeverPassesInvObjects"/>
                <exclude name="org/openide/loaders/FolderInstanceTest.class/testChangeOfOrder"/>
                <exclude name="org/openide/loaders/FolderInstanceTest.class/testListenersCountWithCookie"/>
                <exclude name="org/openide/loaders/FolderInstanceTest.class/testChangeCookie"/>
            </patternset>
        </testset>
    </testbag>




import org.openide.filesystems.*;

import java.beans.*;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import junit.framework.AssertionFailedError;

import org.netbeans.junit.*;
import org.openide.modules.ModuleInfo;
import org.openide.util.Lookup;

/** Does a change in order on folder fire the right properties?
 *
 * @author  Jaroslav Tulach
 */
public class DataFolderSetOrderTest extends NbTestCase {
implements PropertyChangeListener {
    private DataFolder aa;
    private DataFolder bb;
    private ArrayList events = new ArrayList ();

        super (name);
    }

    public static void main (String[] args) throws Exception {
        junit.textui.TestRunner.run(new NbTestSuite (DataFolderSetOrderTest.class));
    }

    /** If execution fails we wrap the exception with 
     * new log message.
     */
    protected void runTest () throws Throwable {
        ErrManager.messages.append ("Starting test ");
        ErrManager.messages.append (getName ());
        ErrManager.messages.append ('\n');
        
        try {
            super.runTest ();
        } catch (AssertionFailedError ex) {
            AssertionFailedError ne = new AssertionFailedError (ex.getMessage () + " Log:\n" + ErrManager.messages);
            ne.setStackTrace (ex.getStackTrace ());
            throw ne;
        }
    }
    
    protected void setUp () throws Exception {
        System.setProperty("org.openide.util.Lookup", "org.openide.loaders.DataFolderSetOrderTest$Lkp");
        assertNotNull ("ErrManager has to be in lookup", org.openide.util.Lookup.getDefault ().lookup (ErrManager.class));
        
        if (previous != null) {
            previous.waitFinished ();
        }
        clearWorkDir();

        AddLoaderManuallyHid.addRemoveLoader(DataLoader.getLoader(DataObjectInvalidationTest.SlowDataLoader.class), true);
        
        TestUtils.initDefaultFS(this);
        String fsstruct [] = new String [] {
            "AA/X.txt",
            "AA/Y.txt",
            "BB/X.slow",
        };
        TestUtils.createFilesOnDefaultFS(fsstruct);
        
        FileSystem lfs = Repository.getDefault().getDefaultFileSystem();
        aa = DataFolder.findFolder (lfs.getRoot().getFileObject("AA"));
        bb = DataFolder.findFolder (lfs.getRoot().getFileObject("BB"));    
        aa.addPropertyChangeListener (new PropertyChangeListener() {
                public void propertyChange(PropertyChangeEvent evt) {
                    events.add(evt.getPropertyName());
                }

            });
        bb = DataFolder.findFolder (lfs.findResource ("BB"));    
        
        aa.addPropertyChangeListener (this);
    }
    
    protected void tearDown () throws Exception {
        AddLoaderManuallyHid.addRemoveLoader(DataLoader.getLoader(DataObjectInvalidationTest.SlowDataLoader.class), false);
        
        aa.removePropertyChangeListener (this);
    }
    
    private void makeFolderRecognizerBusy () throws Exception {
        if (getName().indexOf ("Busy") < 0) {
            return;
        }
        
        final DataLoader l = DataLoader.getLoader(DataObjectInvalidationTest.SlowDataLoader.class);
        synchronized (l) {
            // this will trigger bb.getChildren

        // now the folder recognizer is blocked at least for 2s
    }

    private void doTest(boolean slow) throws Exception {
        DataObject[] arr = aa.getChildren ();
        assertEquals ("Two objects", 2, arr.length);
        ArrayList l = new ArrayList (Arrays.asList (arr));
        java.util.Collections.reverse (l);
        
        assertEquals ("No changes yet "+events, 0, events.size ());
        if (slow) {
            makeFolderRecognizerBusy();
        }
        aa.setOrder ((DataObject[])l.toArray (new DataObject[0]));
        
        DataObject[] narr = aa.getChildren ();

    }
    
    public void testReorderWithoutChecksWhenFolderReconizerIsBusy () throws Exception {
        doTest(true);
    }

    
    public void testReorderWithoutChecks () throws Exception {
        doTest(false);
    }
    
    public void propertyChange (PropertyChangeEvent evt) {
        events.add (evt.getPropertyName ());
    }

    //
    // Our fake lookup
    //
    public static final class Lkp extends org.openide.util.lookup.AbstractLookup {
        public Lkp () {
            this (new org.openide.util.lookup.InstanceContent ());
        }
        
        private Lkp (org.openide.util.lookup.InstanceContent ic) {
            super (ic);
            ic.add (new ErrManager ());
            ic.add (new Pool ());
        }
    }
    //
    // Logging support
    //
    public static final class ErrManager extends org.openide.ErrorManager {
        public static final StringBuffer messages = new StringBuffer ();
        
        private String prefix;
        
        public ErrManager () {
            this (null);
        }
        public ErrManager (String prefix) {
            this.prefix = prefix;
        }
        
        public Throwable annotate (Throwable t, int severity, String message, String localizedMessage, Throwable stackTrace, java.util.Date date) {
            return t;
        }
        
        public Throwable attachAnnotations (Throwable t, org.openide.ErrorManager.Annotation[] arr) {
            return t;
        }
        
        public org.openide.ErrorManager.Annotation[] findAnnotations (Throwable t) {
            return null;
        }
        
        public org.openide.ErrorManager getInstance (String name) {
            if (
                name.startsWith ("org.openide.loaders.FolderList")
//              || name.startsWith ("org.openide.loaders.FolderInstance")
            ) {
                return new ErrManager ('[' + name + ']');
            } else {
                // either new non-logging or myself if I am non-logging
                return new ErrManager ();
            }
        }
        
        public void log (int severity, String s) {
            if (prefix != null) {
                messages.append (prefix);
                messages.append (s);
                messages.append ('\n');
            }
        }
        
        public void notify (int severity, Throwable t) {
            log (severity, t.getMessage ());
        }
        
        public boolean isNotifiable (int severity) {
            return prefix != null;
        }
        
        public boolean isLoggable (int severity) {
            return prefix != null;
        }
        
    } // end of ErrManager
    
    private static final class Pool extends DataLoaderPool {
        
        protected java.util.Enumeration loaders () {
            return new org.openide.util.enum.SingletonEnumeration (
                DataLoader.getLoader(DataObjectInvalidationTest.SlowDataLoader.class)
            );
        }
        
    } // end of Pool
}




    /** Tests whether children are updated immediatelly.
     */
    public void testOrderInAtomicAction () throws Exception {
        clearWorkDir();
        TestUtils.initDefaultFS(this);
        String fsstruct [] = new String [] {
            "AA/",
        };
        TestUtils.createFilesOnDefaultFS(fsstruct);
        
        DataFolder df = DataFolder.findFolder (Repository.getDefault().getDefaultFileSystem().getRoot().getFileObject("AA"));
        FileSystem lfs = TestUtilHid.createLocalFileSystem (getName (), fsstruct);

        
        DataFolder df = DataFolder.findFolder (lfs.findResource ("AA"));

        int expected = 0;
        int count = 5;

     * layers on system filesystem.
     */
    public void testOrderWhenAttributeIsChanged () throws Exception {
        clearWorkDir();
        TestUtils.initDefaultFS(this);
        
        String fsstruct [] = new String [] {
            "AA/AAA/",
            "AA/BBB/",
            "AA/CCC/"
        };
        TestUtils.createFilesOnDefaultFS(fsstruct);
        DataFolder df = DataFolder.findFolder (Repository.getDefault().getDefaultFileSystem().getRoot().getFileObject("AA"));
        
        TestUtilHid.destroyLocalFileSystem (getName());
        FileSystem lfs = TestUtilHid.createLocalFileSystem (getName (), fsstruct);

        
        DataFolder df = DataFolder.findFolder (lfs.findResource ("AA"));
        DataObject[] arr = df.getChildren ();

        String append = "";

    }
    
    public void testOrderWhenSet () throws Exception {
        clearWorkDir();
        TestUtils.initDefaultFS(this);
        String fsstruct [] = new String [] {
            "AA/AAA/",
            "AA/BBB/",
            "AA/CCC/"
        };
        TestUtils.createFilesOnDefaultFS(fsstruct);
        DataFolder df = DataFolder.findFolder (Repository.getDefault().getDefaultFileSystem().getRoot().getFileObject("AA"));
        
        TestUtilHid.destroyLocalFileSystem (getName());
        FileSystem lfs = TestUtilHid.createLocalFileSystem (getName (), fsstruct);

        
        DataFolder df = DataFolder.findFolder (lfs.findResource ("AA"));
        DataObject[] arr = df.getChildren ();
        DataObject[] rev = new DataObject [arr.length];
        

        assertChildrenArrays ("", arr, df.getChildren (), false);
    }

    // XXX: rewrite this test somehow. only DefaultFS can be ordered now
    /*
    public void testOrderWhenMultiFileSystemSetDelegatesIsCalled () throws Exception {
        clearWorkDir();
        String fsstruct [] = new String [] {
            "AA/AAA/",
            "AA/BBB/",

        assertTrue(l.gotSomething());
        //System.out.println("df " + df.getPrimaryFile ().getAttribute (DataFolder.EA_ORDER));
        assertChildrenArrays ("", arr, df.getChildren (), false);
    }*/
    
    // #13820:
    public void testOrderWhenFileRenamed() throws Exception {
        clearWorkDir();
        TestUtils.initDefaultFS(this);
        String fsstruct [] = new String [] {
            "folder/a1/",
            "folder/b2/",
            "folder/c3/",
        };
        TestUtils.createFilesOnDefaultFS(fsstruct);
        DataFolder folder = DataFolder.findFolder (Repository.getDefault().getDefaultFileSystem().getRoot().getFileObject("folder"));
        
        assertEquals("initial order is alphabetical", "a1/b2/c3", childrenOrder(folder));
        OrderListener l = new OrderListener();
        folder.addPropertyChangeListener(l);
        DataObject.find(Repository.getDefault().getDefaultFileSystem().getRoot().getFileObject("folder/b2")).rename("d4");
        assertTrue("Renaming a file fires PROP_CHILDREN on folder", l.gotSomething());
        assertEquals("order after rename is still alphabetical", "a1/c3/d4", childrenOrder(folder));
    }
    
    public void testSortMode() throws Exception {
        clearWorkDir();
        TestUtils.initDefaultFS(this);
        String fsstruct [] = new String [] {
            "folder2/a/",
            "folder2/b.xml",
            "folder2/c/",
            "folder2/e.xml",
            "folder2/d.instance",
        };
        TestUtils.createFilesOnDefaultFS(fsstruct);
        DataFolder folder = DataFolder.findFolder (Repository.getDefault().getDefaultFileSystem().getRoot().getFileObject("folder2"));
        assertTrue(fs.findResource("folder/e.xml").isData());
        assertTrue(fs.findResource("folder/d.instance").isData());
        DataFolder folder = DataFolder.findFolder(fs.findResource("folder"));
        assertEquals("initial order is alphabetical, folders first", "a/c/b.xml/d.instance/e.xml", childrenOrder(folder));
        folder.setSortMode(DataFolder.SortMode.NAMES);
        assertEquals("next order is alphabetical", "a/b.xml/c/d.instance/e.xml", childrenOrder(folder));




import java.util.Enumeration;
import org.openide.nodes.Node;
import org.openide.cookies.InstanceCookie;
import org.openide.filesystems.Repository;
import org.netbeans.junit.*;
import org.openide.filesystems.*;


    }
    
    protected void setUp() throws Exception {
        TestUtils.initDefaultFS(this);
//        TestUtilHid.destroyLocalFileSystem(getName());
        String[] fsstruct = {
            "shadows/",
            "brokenshadows",
            "folder/original.txt",
            "folder/orig.txt",
            "modify/"
        };
      TestUtils.createFilesOnDefaultFS(fsstruct);
        lfs = Repository.getDefault().getDefaultFileSystem();
//      Repository.getDefault ().addFileSystem (lfs);
        
        int count = getNumber ().intValue ();
        

    protected void tearDown() throws Exception {
        long now = System.currentTimeMillis ();
        
//        Repository.getDefault ().removeFileSystem (lfs);
//        TestUtilHid.destroyLocalFileSystem(getName());
//        TestUtils.destroyDefaultFS(this);
        lfs.findResource("shadows").delete();
        lfs.getRoot().createFolder("shadows");
        
        times.put (getNumber (), new Long (now - time));
                




import java.util.Enumeration;
import org.openide.nodes.Node;
import org.openide.cookies.InstanceCookie;
import org.openide.filesystems.Repository;
import org.netbeans.junit.*;
import org.openide.filesystems.*;


    }
    
    protected void setUp() throws Exception {
        TestUtils.initDefaultFS(this);
        String[] fsstruct = {
            "shadows/",
            "brokenshadows",
            "folder/original.txt",
            "folder/orig.txt",
            "modify/"
        };
        TestUtils.createFilesOnDefaultFS(fsstruct);
        lfs = Repository.getDefault().getDefaultFileSystem();
//        Repository.getDefault ().addFileSystem (lfs);
        
        int count = getNumber ().intValue ();
        

    protected void tearDown() throws Exception {
        long now = System.currentTimeMillis ();
        
//        Repository.getDefault ().removeFileSystem (lfs);
//        TestUtilHid.destroyLocalFileSystem(getName());
        lfs.findResource("shadows").delete();
        lfs.getRoot().createFolder("shadows");
        
        times.put (getNumber (), new Long (now - time));
                

Lines 46-53 Link Here

(-)test/unit/src/org/openide/loaders/DataShadowTest.java (-5 / +10 lines)
46	}	46	}
47		47
48	protected void setUp() throws Exception {	48	protected void setUp() throws Exception {
49	lfs = Repository.getDefault ().getDefaultFileSystem ();	49	TestUtils.initDefaultFS(this);
50	FileObject fo = FileUtil.createData (lfs.getRoot (), getName () + "/folder/original.txt");	50	String[] fsstruct = {
		51	"folder/original.txt",
		52	"folder/orig.txt",
		53	"modify/"
		54	};
		55	TestUtils.createFilesOnDefaultFS(fsstruct);
		56	lfs = Repository.getDefault().getDefaultFileSystem();
		57	FileObject fo = lfs.findResource("folder/original.txt");
51	assertNotNull(fo);	58	assertNotNull(fo);
52	original = DataObject.find (fo);	59	original = DataObject.find (fo);
53	assertFalse ("Just to be sure that this is not shadow", original instanceof DataShadow);	60	assertFalse ("Just to be sure that this is not shadow", original instanceof DataShadow);
Lines 56-63 Link Here
56	assertNotNull(fo);	63	assertNotNull(fo);
57	assertTrue (fo.isFolder ());	64	assertTrue (fo.isFolder ());
58	folder = DataFolder.findFolder (fo);	65	folder = DataFolder.findFolder (fo);
59
60	Repository.getDefault ().addFileSystem (lfs);
61	}	66	}
62		67
63	protected void tearDown() throws Exception {	68	protected void tearDown() throws Exception {
Lines 153-159 Link Here
153	shade = null;	158	shade = null;
154	assertGC ("Shadow can disappear", ref);	159	assertGC ("Shadow can disappear", ref);
155		160
156	original.rename ("newname");	161	original.rename ("newname2.txt");
157		162
158		163
159	DataObject obj = DataObject.find (primary);	164	DataObject obj = DataObject.find (primary);

Lines 129-135 Link Here

(-)test/unit/src/org/openide/loaders/InstanceDataObjectTest.java (-1 / +1 lines)
129	try {	129	try {
130	final FileObject primary = ido.getPrimaryFile();	130	final FileObject primary = ido.getPrimaryFile();
131	System.err.println("Deleting file=" + primary);	131	System.err.println("Deleting file=" + primary);
132	primary.delete(primary.lock());	132	primary.delete();
133		133
134	// XXX Testing the case event is fired.	134	// XXX Testing the case event is fired.
135	// l.propertyChange(new PropertyChangeEvent(	135	// l.propertyChange(new PropertyChangeEvent(




/*
 *                 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 org.netbeans.junit.NbTestCase;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.FileUtil;
import org.openide.filesystems.Repository;
import org.openide.modules.ModuleInfo;
import org.openide.util.Lookup;

/** Misc utilities for easier testing.
 * @author David Konecny
 */
public final class TestUtils {
    
    private TestUtils() {}
    
    public static void initDefaultFS(NbTestCase test) throws Exception {
        System.setProperty("netbeans.user", test.getWorkDir().getAbsolutePath());
//        System.out.println(">>>>>"+test.getWorkDir().getAbsolutePath());
        Lookup.getDefault().lookup(ModuleInfo.class);
    }
    
    public static void createFilesOnDefaultFS(String[] files) throws Exception {
        FileObject folder = Repository.getDefault().getDefaultFileSystem().getRoot();
        for (int i=0; i<files.length; i++) {
            if (files[i].endsWith("/")) {
                FileUtil.createFolder(folder, files[i].substring(0, files[i].length()-1));
            } else {
                FileUtil.createData(folder, files[i]);
            }
        }
    }
    
    public static void destroyDefaultFS(NbTestCase test) throws Exception {
        test.getWorkDir().delete();
    }
    
}

Return to bug 43189

Lines 21-26 Link Here

(-)loaders/src/org/openide/loaders/DataFolder.java (+86 lines)
21	import java.io.File;	21	import java.io.File;
22	import java.lang.ref.*;	22	import java.lang.ref.*;
23	import java.lang.reflect.InvocationTargetException;	23	import java.lang.reflect.InvocationTargetException;
		24	import java.lang.reflect.Method;
24	import java.util.*;	25	import java.util.*;
25	import javax.swing.Action;	26	import javax.swing.Action;
26	import javax.swing.UIManager;	27	import javax.swing.UIManager;
Lines 34-42 Link Here
34	import org.openide.filesystems.*;	35	import org.openide.filesystems.*;
35	import org.openide.util.HelpCtx;	36	import org.openide.util.HelpCtx;
36	import org.openide.nodes.*;	37	import org.openide.nodes.*;
		38	import org.openide.options.SystemOption;
37	import org.openide.util.Lookup;	39	import org.openide.util.Lookup;
38	import org.openide.util.NbBundle;	40	import org.openide.util.NbBundle;
39	import org.openide.util.RequestProcessor;	41	import org.openide.util.RequestProcessor;
		42	import org.openide.util.SharedClassObject;
40		43
41	/** A folder containing data objects.	44	/** A folder containing data objects.
42	* Is actually itself a data object, whose primary (and only) file object	45	* Is actually itself a data object, whose primary (and only) file object
Lines 147-152 Link Here
147	throw new IllegalArgumentException ("Not folder: " + fo); // NOI18N	150	throw new IllegalArgumentException ("Not folder: " + fo); // NOI18N
148	}	151	}
149	list = reassignList (fo, attach);	152	list = reassignList (fo, attach);
		153
		154	// if this is not DefaultFS then start listening on IDESettings
		155	try {
		156	if (!isDefaultFS()) {
		157	initGlobalSorting();
		158	if (ideSettings != null && getSortingMethod != null) {
		159	ideSettings.addPropertyChangeListener(new PropertyChangeListener() {
		160	public void propertyChange(PropertyChangeEvent evt) {
		161	if ("sorting".equals(evt.getPropertyName())) { //NOI18N
		162	list.changeComparator();
		163	firePropertyChange (PROP_SORT_MODE, null, null);
		164	}
		165	}
		166	});
		167	}
		168	}
		169	} catch (IOException e) {
		170	ErrorManager.getDefault().log(ErrorManager.WARNING, e.toString());
		171	// OK, no sorting
		172	}
		173
150	}	174	}
151		175
152	/** Attaches a listener to the folder list, removes any previous one if registered.	176	/** Attaches a listener to the folder list, removes any previous one if registered.
Lines 191-196 Link Here
191	* @exception IOException if the mode cannot be set	215	* @exception IOException if the mode cannot be set
192	*/	216	*/
193	public synchronized final void setSortMode (SortMode mode) throws IOException {	217	public synchronized final void setSortMode (SortMode mode) throws IOException {
		218	if (!isDefaultFS()) {
		219	throw new IOException("Order can be set only on DefaultFileSystem DataFolders."); // NOI18N
		220	}
194	SortMode old = getOrder ().getSortMode ();	221	SortMode old = getOrder ().getSortMode ();
195	getOrder ().setSortMode (mode);	222	getOrder ().setSortMode (mode);
196	firePropertyChange (PROP_SORT_MODE, old, getOrder ().getSortMode ());	223	firePropertyChange (PROP_SORT_MODE, old, getOrder ().getSortMode ());
Lines 218-227 Link Here
218	*	245	*
219	*/	246	*/
220	public synchronized final void setOrder (DataObject[] arr) throws IOException {	247	public synchronized final void setOrder (DataObject[] arr) throws IOException {
		248	if (!isDefaultFS()) {
		249	throw new IOException("Order can be set only on DefaultFileSystem DataFolders."); // NOI18N
		250	}
221	getOrder ().setOrder (arr);	251	getOrder ().setOrder (arr);
222	firePropertyChange (PROP_ORDER, null, null);	252	firePropertyChange (PROP_ORDER, null, null);
223	}	253	}
		254
		255	private boolean isDefaultFS() throws IOException {
		256	return getPrimaryFile().getFileSystem().equals(Repository.getDefault().getDefaultFileSystem());
		257	}
		258
		259	// XXX: find IDESettings and read the global sort mode.
		260	// Ugly, but there is no other way. Should be resolved once
		261	// we have Settings API.
		262	static SortMode getGlobalSorting() {
		263	try {
		264	if (ideSettings != null && getSortingMethod != null) {
		265	return (SortMode)getSortingMethod.invoke(ideSettings, new Object[0]);
		266	}
		267	} catch (Exception e) {
		268	// ignore, default sorting will be used
		269	ErrorManager.getDefault().log(ErrorManager.WARNING, e.toString());
		270	}
		271	return SortMode.FOLDER_NAMES;
		272	}
		273
		274	// XXX: find IDESettings and read the global sort mode.
		275	// Ugly, but there is no other way. Should be resolved once
		276	// we have Settings API.
		277	static synchronized void initGlobalSorting() {
		278	try {
		279	if (!globalSortingInitialized) {
		280	globalSortingInitialized = true;
		281	ClassLoader l = (ClassLoader) Lookup.getDefault().lookup(ClassLoader.class);
		282	Class clazz = l.loadClass("org.netbeans.core.IDESettings"); // NOI18N
		283	ideSettings = (SystemOption)SharedClassObject.findObject(clazz, true);
		284	if (ideSettings != null) {
		285	getSortingMethod = clazz.getMethod("getSorting", null); // NOI18N
		286	assert getSortingMethod != null;
		287	}
		288	}
		289	} catch (Exception e) {
		290	ErrorManager.getDefault().notify(e);
		291	}
		292	}
224		293
		294	// IDESettings instance
		295	private static SystemOption ideSettings;
		296
		297	// IDESettings.getSortingMethod() method
		298	private static Method getSortingMethod;
		299
		300	// was IDESettings already initialized?
		301	private static boolean globalSortingInitialized = false;
		302
225	/** Getter for order object.	303	/** Getter for order object.
226	* @return order of children	304	* @return order of children
227	*/	305	*/
Lines 1128-1133 Link Here
1128	*/	1206	*/
1129	protected Sheet createSheet () {	1207	protected Sheet createSheet () {
1130	Sheet s = super.createSheet ();	1208	Sheet s = super.createSheet ();
		1209	try {
		1210	if (!DataFolder.this.isDefaultFS()) {
		1211	return s;
		1212	}
		1213	} catch (IOException ex) {
		1214	// something wrong: disable sorting
		1215	return s;
		1216	}
1131		1217
1132	Sheet.Set ss = new Sheet.Set ();	1218	Sheet.Set ss = new Sheet.Set ();
1133	ss.setName (SET_SORTING);	1219	ss.setName (SET_SORTING);

Lines 18-23 Link Here

(-)loaders/src/org/openide/loaders/FolderOrder.java (-3 / +46 lines)
18		18
19	import java.io.IOException;	19	import java.io.IOException;
20	import java.util.*;	20	import java.util.*;
		21	import org.openide.ErrorManager;
21		22
22	import org.openide.filesystems.*;	23	import org.openide.filesystems.*;
23	import org.openide.loaders.DataFolder.SortMode;	24	import org.openide.loaders.DataFolder.SortMode;
Lines 27-33 Link Here
27	*	28	*
28	* @author Jaroslav Tulach	29	* @author Jaroslav Tulach
29	*/	30	*/
30	final class FolderOrder extends Object implements Comparator {	31	class FolderOrder extends Object implements Comparator {
31	/** Separator of names of two files. The first file should be before	32	/** Separator of names of two files. The first file should be before
32	* the second one in partial ordering	33	* the second one in partial ordering
33	*/	34	*/
Lines 207-213 Link Here
207		208
208	/** Stores the order to files.	209	/** Stores the order to files.
209	*/	210	*/
210	public void write () throws IOException {	211	private void write () throws IOException {
211	// Let it throw the IOException:	212	// Let it throw the IOException:
212	//if (folder.getFileSystem ().isReadOnly ()) return; // cannot write to read-only FS	213	//if (folder.getFileSystem ().isReadOnly ()) return; // cannot write to read-only FS
213	if (order == null) {	214	if (order == null) {
Lines 393-398 Link Here
393	* @return the order	394	* @return the order
394	*/	395	*/
395	public static FolderOrder findFor (FileObject folder) {	396	public static FolderOrder findFor (FileObject folder) {
		397	try {
		398	if (!folder.getFileSystem().equals(Repository.getDefault().getDefaultFileSystem())) {
		399	return getGlobalOrdering();
		400	}
		401	} catch (FileStateInvalidException ex) {
		402	// something wrong, return global order
		403	ErrorManager.getDefault().log(ErrorManager.WARNING, ex.toString());
		404	return getGlobalOrdering();
		405	}
396	FolderOrder order = null;	406	FolderOrder order = null;
397	synchronized (map) {	407	synchronized (map) {
398	Reference ref = (Reference)map.get (folder);	408	Reference ref = (Reference)map.get (folder);
Lines 411-417 Link Here
411	return order;	421	return order;
412	}	422	}
413	}	423	}
		424
		425	private static FolderOrder globalFolderOrder;
		426
		427	private static synchronized FolderOrder getGlobalOrdering() {
		428	if (globalFolderOrder == null) {
		429	globalFolderOrder = new GlobalFolderOrder();
		430	}
		431	return globalFolderOrder;
		432	}
		433
		434	private static class GlobalFolderOrder extends FolderOrder {
		435
		436	private GlobalFolderOrder() {
		437	super(null);
		438	DataFolder.initGlobalSorting();
		439	}
		440
		441	public void setSortMode(SortMode mode) throws IOException {
		442	// ignore
		443	}
		444
		445	public SortMode getSortMode() {
		446	return DataFolder.getGlobalSorting();
		447	}
		448
		449	public void setOrder(DataObject[] arr) throws IOException {
		450	// ignore
		451	}
414		452
415		453	public Map getOrderingConstraints(Collection objects) {
		454	// ignore
		455	return null;
		456	}
		457
		458	}
416		459
417	}	460	}

Lines 208-213 Link Here

(-)test/cfg-unit.xml (+13 lines)
208	<testset dir="unit/src">	208	<testset dir="unit/src">
209	<patternset>	209	<patternset>
210	<!-- Add your own code tests -->	210	<!-- Add your own code tests -->
		211	<include name="org/openide/loaders/InstanceDataObjectTest.class/testFiringEventWhenDeleted"/>
		212	<!-- Don't worry about these, cannot be fixed currently: -->
		213	<exclude name="org/openide/loaders/DataFolderTest.class/testSortMode"/> <!-- failing in cont. test -->
		214	<exclude name="org/openide/loaders/DataFolderTest.class/testMove"/> <!-- failing in cont. test -->
		215	<exclude name="org/openide/loaders/DataFolderTest.class/testPropChildrenFiredAfterInvalidation"/> <!-- failing in cont. test -->
		216	<exclude name="org/openide/loaders/DataFolderTest.class/testOrderWhenMultiFileSystemSetDelegatesIsCalled" /> <!-- failing in cont. test -->
		217	<!-- following was disabled because of issue #20179 -->
		218	<exclude name="org/openide/loaders/DataFolderMoveTest.class"/>
		219	<!-- does not work an nobody knows why -->
		220	<exclude name="org/openide/loaders/FolderInstanceTest.class/testFolderInstanceNeverPassesInvObjects"/>
		221	<exclude name="org/openide/loaders/FolderInstanceTest.class/testChangeOfOrder"/>
		222	<exclude name="org/openide/loaders/FolderInstanceTest.class/testListenersCountWithCookie"/>
		223	<exclude name="org/openide/loaders/FolderInstanceTest.class/testChangeCookie"/>
211	</patternset>	224	</patternset>
212	</testset>	225	</testset>
213	</testbag>	226	</testbag>

Lines 171-185 Link Here

(-)test/unit/src/org/openide/loaders/DataFolderTest.java (-38 / +35 lines)
171	/** Tests whether children are updated immediatelly.	171	/** Tests whether children are updated immediatelly.
172	*/	172	*/
173	public void testOrderInAtomicAction () throws Exception {	173	public void testOrderInAtomicAction () throws Exception {
		174	clearWorkDir();
		175	TestUtils.initDefaultFS(this);
174	String fsstruct [] = new String [] {	176	String fsstruct [] = new String [] {
175	"AA/",	177	"AA/",
176	};	178	};
		179	TestUtils.createFilesOnDefaultFS(fsstruct);
177		180
178	TestUtilHid.destroyLocalFileSystem (getName());	181	DataFolder df = DataFolder.findFolder (Repository.getDefault().getDefaultFileSystem().getRoot().getFileObject("AA"));
179	FileSystem lfs = TestUtilHid.createLocalFileSystem (getName (), fsstruct);
180
181
182	DataFolder df = DataFolder.findFolder (lfs.findResource ("AA"));
183		182
184	int expected = 0;	183	int expected = 0;
185	int count = 5;	184	int count = 5;
Lines 243-262 Link Here
243	* layers on system filesystem.	242	* layers on system filesystem.
244	*/	243	*/
245	public void testOrderWhenAttributeIsChanged () throws Exception {	244	public void testOrderWhenAttributeIsChanged () throws Exception {
246	// if (System.getProperty("netbeans.user") == null)	245	clearWorkDir();
247	// fail("Test can't run in this environment, use -Dxtest.mode=ide");	246	TestUtils.initDefaultFS(this);
248
249	String fsstruct [] = new String [] {	247	String fsstruct [] = new String [] {
250	"AA/AAA/",	248	"AA/AAA/",
251	"AA/BBB/",	249	"AA/BBB/",
252	"AA/CCC/"	250	"AA/CCC/"
253	};	251	};
		252	TestUtils.createFilesOnDefaultFS(fsstruct);
		253	DataFolder df = DataFolder.findFolder (Repository.getDefault().getDefaultFileSystem().getRoot().getFileObject("AA"));
254		254
255	TestUtilHid.destroyLocalFileSystem (getName());
256	FileSystem lfs = TestUtilHid.createLocalFileSystem (getName (), fsstruct);
257
258
259	DataFolder df = DataFolder.findFolder (lfs.findResource ("AA"));
260	DataObject[] arr = df.getChildren ();	255	DataObject[] arr = df.getChildren ();
261		256
262	String append = "";	257	String append = "";
Lines 294-310 Link Here
294	}	289	}
295		290
296	public void testOrderWhenSet () throws Exception {	291	public void testOrderWhenSet () throws Exception {
		292	clearWorkDir();
		293	TestUtils.initDefaultFS(this);
297	String fsstruct [] = new String [] {	294	String fsstruct [] = new String [] {
298	"AA/AAA/",	295	"AA/AAA/",
299	"AA/BBB/",	296	"AA/BBB/",
300	"AA/CCC/"	297	"AA/CCC/"
301	};	298	};
		299	TestUtils.createFilesOnDefaultFS(fsstruct);
		300	DataFolder df = DataFolder.findFolder (Repository.getDefault().getDefaultFileSystem().getRoot().getFileObject("AA"));
302		301
303	TestUtilHid.destroyLocalFileSystem (getName());
304	FileSystem lfs = TestUtilHid.createLocalFileSystem (getName (), fsstruct);
305
306
307	DataFolder df = DataFolder.findFolder (lfs.findResource ("AA"));
308	DataObject[] arr = df.getChildren ();	302	DataObject[] arr = df.getChildren ();
309	DataObject[] rev = new DataObject [arr.length];	303	DataObject[] rev = new DataObject [arr.length];
310		304
Lines 323-329 Link Here
323	assertChildrenArrays ("", arr, df.getChildren (), false);	317	assertChildrenArrays ("", arr, df.getChildren (), false);
324	}	318	}
325		319
		320	// XXX: rewrite this test somehow. only DefaultFS can be ordered now
		321	/*
326	public void testOrderWhenMultiFileSystemSetDelegatesIsCalled () throws Exception {	322	public void testOrderWhenMultiFileSystemSetDelegatesIsCalled () throws Exception {
		323	clearWorkDir();
327	String fsstruct [] = new String [] {	324	String fsstruct [] = new String [] {
328	"AA/AAA/",	325	"AA/AAA/",
329	"AA/BBB/",	326	"AA/BBB/",
Lines 371-410 Link Here
371	assertTrue(l.gotSomething());	368	assertTrue(l.gotSomething());
372	//System.out.println("df " + df.getPrimaryFile ().getAttribute (DataFolder.EA_ORDER));	369	//System.out.println("df " + df.getPrimaryFile ().getAttribute (DataFolder.EA_ORDER));
373	assertChildrenArrays ("", arr, df.getChildren (), false);	370	assertChildrenArrays ("", arr, df.getChildren (), false);
374	}	371	}*/
375		372
376	// #13820:	373	// #13820:
377	public void testOrderWhenFileRenamed() throws Exception {	374	public void testOrderWhenFileRenamed() throws Exception {
378	TestUtilHid.destroyLocalFileSystem(getName());	375	clearWorkDir();
379	FileSystem fs = TestUtilHid.createLocalFileSystem(getName(), new String[] {	376	TestUtils.initDefaultFS(this);
		377	String fsstruct [] = new String [] {
380	"folder/a1/",	378	"folder/a1/",
381	"folder/b2/",	379	"folder/b2/",
382	"folder/c3/",	380	"folder/c3/",
383	});	381	};
384	DataFolder folder = DataFolder.findFolder(fs.findResource("folder"));	382	TestUtils.createFilesOnDefaultFS(fsstruct);
		383	DataFolder folder = DataFolder.findFolder (Repository.getDefault().getDefaultFileSystem().getRoot().getFileObject("folder"));
		384
385	assertEquals("initial order is alphabetical", "a1/b2/c3", childrenOrder(folder));	385	assertEquals("initial order is alphabetical", "a1/b2/c3", childrenOrder(folder));
386	OrderListener l = new OrderListener();	386	OrderListener l = new OrderListener();
387	folder.addPropertyChangeListener(l);	387	folder.addPropertyChangeListener(l);
388	DataObject.find(fs.findResource("folder/b2")).rename("d4");	388	DataObject.find(Repository.getDefault().getDefaultFileSystem().getRoot().getFileObject("folder/b2")).rename("d4");
389	assertTrue("Renaming a file fires PROP_CHILDREN on folder", l.gotSomething());	389	assertTrue("Renaming a file fires PROP_CHILDREN on folder", l.gotSomething());
390	assertEquals("order after rename is still alphabetical", "a1/c3/d4", childrenOrder(folder));	390	assertEquals("order after rename is still alphabetical", "a1/c3/d4", childrenOrder(folder));
391	}	391	}
392		392
393	public void testSortMode() throws Exception {	393	public void testSortMode() throws Exception {
394	TestUtilHid.destroyLocalFileSystem(getName());	394	clearWorkDir();
395	FileSystem fs = TestUtilHid.createLocalFileSystem(getName(), new String[] {	395	TestUtils.initDefaultFS(this);
396	"folder/a/",	396	String fsstruct [] = new String [] {
397	"folder/b.xml",	397	"folder2/a/",
398	"folder/c/",	398	"folder2/b.xml",
399	"folder/e.xml",	399	"folder2/c/",
400	"folder/d.instance",	400	"folder2/e.xml",
401	});	401	"folder2/d.instance",
402	assertTrue(fs.findResource("folder/a").isFolder());	402	};
403	assertTrue(fs.findResource("folder/b.xml").isData());	403	TestUtils.createFilesOnDefaultFS(fsstruct);
404	assertTrue(fs.findResource("folder/c").isFolder());	404	DataFolder folder = DataFolder.findFolder (Repository.getDefault().getDefaultFileSystem().getRoot().getFileObject("folder2"));
405	assertTrue(fs.findResource("folder/e.xml").isData());
406	assertTrue(fs.findResource("folder/d.instance").isData());
407	DataFolder folder = DataFolder.findFolder(fs.findResource("folder"));
408	assertEquals("initial order is alphabetical, folders first", "a/c/b.xml/d.instance/e.xml", childrenOrder(folder));	405	assertEquals("initial order is alphabetical, folders first", "a/c/b.xml/d.instance/e.xml", childrenOrder(folder));
409	folder.setSortMode(DataFolder.SortMode.NAMES);	406	folder.setSortMode(DataFolder.SortMode.NAMES);
410	assertEquals("next order is alphabetical", "a/b.xml/c/d.instance/e.xml", childrenOrder(folder));	407	assertEquals("next order is alphabetical", "a/b.xml/c/d.instance/e.xml", childrenOrder(folder));

Lines 20-26 Link Here

(-)test/unit/src/org/openide/loaders/DataShadowBrokenSlownessTest.java (-7 / +12 lines)
20	import java.util.Enumeration;	20	import java.util.Enumeration;
21	import org.openide.nodes.Node;	21	import org.openide.nodes.Node;
22	import org.openide.cookies.InstanceCookie;	22	import org.openide.cookies.InstanceCookie;
23	import org.openide.filesystems.Repository;
24	import org.netbeans.junit.*;	23	import org.netbeans.junit.*;
25	import org.openide.filesystems.*;	24	import org.openide.filesystems.*;
26		25
Lines 51-65 Link Here
51	}	50	}
52		51
53	protected void setUp() throws Exception {	52	protected void setUp() throws Exception {
54	TestUtilHid.destroyLocalFileSystem(getName());	53	TestUtils.initDefaultFS(this);
55	lfs = TestUtilHid.createLocalFileSystem(getName(), new String[] {	54	// TestUtilHid.destroyLocalFileSystem(getName());
		55	String[] fsstruct = {
56	"shadows/",	56	"shadows/",
57	"brokenshadows",	57	"brokenshadows",
58	"folder/original.txt",	58	"folder/original.txt",
59	"folder/orig.txt",	59	"folder/orig.txt",
60	"modify/"	60	"modify/"
61	});	61	};
62	Repository.getDefault ().addFileSystem (lfs);	62	TestUtils.createFilesOnDefaultFS(fsstruct);
		63	lfs = Repository.getDefault().getDefaultFileSystem();
		64	// Repository.getDefault ().addFileSystem (lfs);
63		65
64	int count = getNumber ().intValue ();	66	int count = getNumber ().intValue ();
65		67
Lines 125-132 Link Here
125	protected void tearDown() throws Exception {	127	protected void tearDown() throws Exception {
126	long now = System.currentTimeMillis ();	128	long now = System.currentTimeMillis ();
127		129
128	Repository.getDefault ().removeFileSystem (lfs);	130	// Repository.getDefault ().removeFileSystem (lfs);
129	TestUtilHid.destroyLocalFileSystem(getName());	131	// TestUtilHid.destroyLocalFileSystem(getName());
		132	// TestUtils.destroyDefaultFS(this);
		133	lfs.findResource("shadows").delete();
		134	lfs.getRoot().createFolder("shadows");
130		135
131	times.put (getNumber (), new Long (now - time));	136	times.put (getNumber (), new Long (now - time));
132		137

Added Link Here

(-)test/unit/src/org/openide/loaders/TestUtils.java (+51 lines)
1	/*
2	* Sun Public License Notice
3	*
4	* The contents of this file are subject to the Sun Public License
5	* Version 1.0 (the "License"). You may not use this file except in
6	* compliance with the License. A copy of the License is available at
7	* http://www.sun.com/
8	*
9	* The Original Code is NetBeans. The Initial Developer of the Original
10	* Code is Sun Microsystems, Inc. Portions Copyright 1997-2001 Sun
11	* Microsystems, Inc. All Rights Reserved.
12	*/
13
14	package org.openide.loaders;
15
16	import org.netbeans.junit.NbTestCase;
17	import org.openide.filesystems.FileObject;
18	import org.openide.filesystems.FileUtil;
19	import org.openide.filesystems.Repository;
20	import org.openide.modules.ModuleInfo;
21	import org.openide.util.Lookup;
22
23	/** Misc utilities for easier testing.
24	* @author David Konecny
25	*/
26	public final class TestUtils {
27
28	private TestUtils() {}
29
30	public static void initDefaultFS(NbTestCase test) throws Exception {
31	System.setProperty("netbeans.user", test.getWorkDir().getAbsolutePath());
32	// System.out.println(">>>>>"+test.getWorkDir().getAbsolutePath());
33	Lookup.getDefault().lookup(ModuleInfo.class);
34	}
35
36	public static void createFilesOnDefaultFS(String[] files) throws Exception {
37	FileObject folder = Repository.getDefault().getDefaultFileSystem().getRoot();
38	for (int i=0; i<files.length; i++) {
39	if (files[i].endsWith("/")) {
40	FileUtil.createFolder(folder, files[i].substring(0, files[i].length()-1));
41	} else {
42	FileUtil.createData(folder, files[i]);
43	}
44	}
45	}
46
47	public static void destroyDefaultFS(NbTestCase test) throws Exception {
48	test.getWorkDir().delete();
49	}
50
51	}