//

    // Support for running really atomic actions

    //

    public synchronized void runAtomicAction (FileSystem fs, FileSystem.AtomicAction action) 

    throws java.io.IOException {

        fs.runAtomicAction(action);

    }

/*

 *                 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 org.openide.filesystems.*;

import org.openide.loaders.*;

import java.beans.*;

import java.io.IOException;

import junit.textui.TestRunner;

import org.netbeans.junit.*;

/* 

 * Checks whether a during a modify operation (copy, move) some

 * other thread can get a grip on unfinished and uncostructed 

 * content on filesystem.

 *

 * @author Jaroslav Tulach

 */

public class SeparationOfThreadsTest extends NbTestCase {

    private DataFolder root;

    private DataFolder to;

    private DataObject a;

    private DataObject b;

    private DataObject res;

    /** Creates the test */

    public SeparationOfThreadsTest(String name) {

        super(name);

    }

    // For each test setup a FileSystem and DataObjects

    protected void setUp() throws Exception {

        String fsstruct [] = new String [] {

            "A.attr", 

            "B.attr",

            "dir/"

        };

        TestUtilHid.destroyLocalFileSystem (getName());

        FileSystem fs = TestUtilHid.createLocalFileSystem (getName(), fsstruct);

        root = DataFolder.findFolder (fs.getRoot ());

        AddLoaderManuallyHid.addRemoveLoader (ALoader.getLoader (ALoader.class), true);

        AddLoaderManuallyHid.addRemoveLoader (BLoader.getLoader (BLoader.class), true);

        to = DataFolder.findFolder (fs.findResource (fsstruct[2]));

        fs.findResource (fsstruct[0]).setAttribute ("A", Boolean.TRUE);

        a = DataObject.find (fs.findResource (fsstruct[0]));

        b = DataObject.find (fs.findResource (fsstruct[1]));

        ALoader loaderA = (ALoader)ALoader.getLoader (ALoader.class);

        assertEquals ("A is loaded by ALoader", loaderA, a.getLoader());

        assertEquals ("B is loaded by BLoader", ALoader.getLoader (BLoader.class), b.getLoader());

        synchronized (loaderA) {

            new Thread ((Runnable)loaderA).start ();

            loaderA.wait ();

        }

    }

    //Clear all stuff when the test finish

    protected void tearDown() throws Exception {

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

        synchronized (loader) {

            try {

                while (!loader.finished) {

                    loader.wait ();

                }

                assertNotNull (res);

                assertEquals ("The right loader synchronously", loader, res.getLoader ());

                if (loader.asyncError != null) {

                    throw loader.asyncError;

                }

                assertNotNull (loader.asyncRes);

                assertEquals ("It is the right loader asynchronously", loader, loader.asyncRes.getLoader());

            } finally {

                loader.asyncError = null;

                loader.currentThread = null;

                loader.current = null;

                loader.asyncRes = null;

                loader.finished = false;

                // clears any such flag

                Thread.interrupted();

                TestUtilHid.destroyLocalFileSystem (getName());

                AddLoaderManuallyHid.addRemoveLoader (ALoader.getLoader (ALoader.class), false);

                AddLoaderManuallyHid.addRemoveLoader (BLoader.getLoader (BLoader.class), false);

                // end of test

                loader.notify ();

            }            

        }

    }

    public static void main (String[] args) throws Exception {

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

    }    

    public void testCopy () throws Exception {

        res = a.copy (to);

    }

    public void testCreateFromTemplate () throws Exception {

        res = a.createFromTemplate (to);

    }

    public void testMove () throws Exception {

        a.move (to);

        res = a;

    }

    public void testRename () throws Exception {

        a.rename ("AnyThing");

        res = a;

    }

    //

    // Inner classes

    //

    public static final class ALoader extends UniFileLoader implements Runnable {

        DataObject asyncRes;

        Exception asyncError;

        FileObject current;

        Thread currentThread;

        boolean finished;

        public ALoader() {

            super(DataObject.class.getName());

        }

        protected void initialize() {

            super.initialize();

            getExtensions().addExtension("attr");

        }

        protected String displayName() {

            return getClass().getName ();

        }

        protected MultiDataObject createMultiObject(FileObject pf) throws IOException {

            return new MultiDataObject(pf, this);

        }

        protected org.openide.loaders.MultiDataObject.Entry createPrimaryEntry(org.openide.loaders.MultiDataObject multiDataObject, org.openide.filesystems.FileObject fileObject) {

            return new SlowEntry (multiDataObject, fileObject);

        }

        // 

        // Notification that the copy is in middle

        // 

        public void notifyCopied (FileObject current) {

            synchronized (this) {

                this.current = current;

                this.currentThread = Thread.currentThread ();

                this.notify ();

            }

            try {

                Thread.sleep (500);

            } catch (InterruptedException ex) {

                // is interrupted to be wake up sooner

            }

        }

        //

        // The second thread that waits for the copy operation

        //

        public void run () {

            DataLoader loader = this;

            synchronized (loader) {

                // continue execution in setUp

                loader.notify ();

                // wait for being notify about copying

                try {

                    loader.wait ();

                } catch (InterruptedException ex) {

                    asyncError = ex;

                }

                try {

                    asyncRes = DataObject.find (current);

                    currentThread.interrupt();

                } catch (IOException ex) {

                    asyncError = ex;

                }

                // notify that we have computed everything

                finished = true;

                loader.notify ();

                while (asyncRes != null && asyncError != null) {

                    try {

                        loader.wait ();

                    } catch (InterruptedException ex) {

                    }

                }

            }

        }

    }

    public static final class BLoader extends UniFileLoader {

        public BLoader() {

            super(DataObject.class.getName());

        }

        protected void initialize() {

            super.initialize();

            getExtensions().addExtension("attr");

        }

        protected String displayName() {

            return getClass ().getName ();

        }

        protected org.openide.filesystems.FileObject findPrimaryFile(org.openide.filesystems.FileObject fileObject) {

            if (Boolean.TRUE.equals (fileObject.getAttribute ("A"))) {

                return null;

            }

            org.openide.filesystems.FileObject retValue;

            retValue = super.findPrimaryFile(fileObject);

            return retValue;

        }        

        protected MultiDataObject createMultiObject(FileObject pf) throws IOException {

            return new MultiDataObject(pf, this);

        }

    }

    private static final class SlowEntry extends MultiDataObject.Entry {

        public SlowEntry (MultiDataObject obj, FileObject fo) {

            obj.super (fo);

        }

        private void notifyCopied (FileObject fo) {

            ALoader l = (ALoader)ALoader.getLoader(ALoader.class);

            l.notifyCopied (fo);

        }

        public org.openide.filesystems.FileObject copy(org.openide.filesystems.FileObject fileObject, String str) throws java.io.IOException {

            FileObject ret = fileObject.createData ("copy", "attr");

            notifyCopied (ret);

            ret.setAttribute ("A", Boolean.TRUE);

            return ret;

        }

        public org.openide.filesystems.FileObject createFromTemplate(org.openide.filesystems.FileObject fileObject, String str) throws java.io.IOException {

            FileObject ret = fileObject.createData ("createFromTemplate", "attr");

            notifyCopied (ret);

            ret.setAttribute ("A", Boolean.TRUE);

            return ret;

        }

        public void delete() throws java.io.IOException {

            throw new IOException ("Not implemented");

        }

        public org.openide.filesystems.FileObject move(org.openide.filesystems.FileObject fileObject, String str) throws java.io.IOException {

            FileObject ret = fileObject.createData ("move", "attr");

            notifyCopied (ret);

            ret.setAttribute ("A", Boolean.TRUE);

            super.getFile ().delete ();

            return ret;

        }

        public org.openide.filesystems.FileObject rename(String str) throws java.io.IOException {

            FileObject ret = getFile ().getParent ().createData ("rename", "attr");

            notifyCopied (ret);

            ret.setAttribute ("A", Boolean.TRUE);

            super.getFile ().delete ();

            return ret;

        }

    }

}