Attachment #33368 for bug #81527

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 81527
Collapse All | Expand All




import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.WeakHashMap;
import java.util.jar.JarEntry;

    private FileUtil() {
    }
    /**
     * Returns FileObject for a folder.
     * If such a folder does not exist then it is created, including any necessary but nonexistent parent
     * folders. Note that if this operation fails it may have succeeded in creating some of the necessary
     * parent folders.
     * @param folder folder to be created
     * @return FileObject for a folder
     * @throws java.io.IOException if the creation fails
     * @since 7.0
     */
    public static FileObject createFolder (final File folder) throws IOException {
        FileObject retval = null;
        File root = getRoot(folder);
        if (!root.exists()) {
            throw new IOException(folder.getAbsolutePath());
        }
        FileObject rootFo = FileUtil.toFileObject(root);
        assert rootFo != null : root.getAbsolutePath();
        final String relativePath = getRelativePath(root, folder);
        try {
            retval = FileUtil.createFolder(rootFo,relativePath);
        } catch (IOException ex) {
            //thus retval = null;
        }
        //if refresh needed because of external changes
        if (retval == null || !retval.isValid()) {
            rootFo.getFileSystem().refresh(false);
            retval = FileUtil.createFolder(rootFo,relativePath);
        }
        assert retval != null;
        return retval;
    }

    /**Returns FileObject for a data file.
     * If such a data file does not exist then it is created, including any necessary but nonexistent parent
     * folders. Note that if this operation fails it may have succeeded in creating some of the necessary
     * parent folders.
     * @param data data file to be created
     * @return FileObject for a data file
     * @throws java.io.IOException if the creation fails
     * @since 7.0
     */
    public static FileObject createData (final File data) throws IOException {
        FileObject retval = null;
        File root = getRoot(data);
        if (!root.exists()) {
            throw new IOException(data.getAbsolutePath());
        }
        FileObject rootFo = FileUtil.toFileObject(root);
        assert rootFo != null : root.getAbsolutePath();
        final String relativePath = getRelativePath(root, data);
        try {
            retval = FileUtil.createData(rootFo,relativePath);
        } catch (IOException ex) {
            //thus retval = null;
        }
        //if refresh needed because of external changes
        if (retval == null || !retval.isValid()) {
            rootFo.getFileSystem().refresh(false);
            retval = FileUtil.createData(rootFo,relativePath);
        }
        assert retval != null;
        return retval;
    }

    private static File getRoot(final File dir) {
        File retval = dir;
        for (; retval.getParentFile() != null; retval = retval.getParentFile());
        assert retval != null;
        return retval;
    }

    private static String getRelativePath(final File dir, final File file) {
        Stack stack = new Stack ();
        File tempFile = file;
        while(tempFile != null && !tempFile.equals(dir)) {
            stack.push (tempFile.getName());
            tempFile = tempFile.getParentFile();
        }
        assert tempFile != null : file.getAbsolutePath() + "not found in " + dir.getAbsolutePath();//NOI18N
        StringBuilder retval = new StringBuilder();
        while (!stack.isEmpty()) {
            retval.append((String)stack.pop());
            if (!stack.isEmpty()) {
                retval.append("/");//NOI18N
            }
        }
        return retval.toString();
    }

    /** Copies stream of files.
    * <P>
    * Please be aware, that this method doesn't close any of passed streams.




        };
    }
    public void  testCreateNotExistingFolderOrDataFile() throws IOException {
        final File wDir = getWorkDir();
        final File fold = new File(wDir,"a/b/c");
        final File data = new File(fold,"c.data");
        implCreateFolderOrDataFile(wDir, fold, data);
    }

    public void  testCreateExistingFolderOrDataFile() throws IOException {
        final File wDir = getWorkDir();
        final File fold = new File(wDir,"a/b/c");
        final File data = new File(fold,"c.data");

        assertTrue(fold.mkdirs());
        assertTrue(data.createNewFile());

        implCreateFolderOrDataFile(wDir, fold, data);
    }

    public void  testCreateFolderOrDataFileExternalChange() throws IOException {
        final File wDir = getWorkDir();
        final File fold = new File(wDir,"a/b/c");
        final File data = new File(fold,"c.data");
        createFiles(data, fold);

        implCreateFolderOrDataFile(wDir, fold, data);

        FileObject foldFo = FileUtil.toFileObject(fold);
        FileObject dataFo = FileUtil.toFileObject(data);
        assertNotNull(foldFo);
        assertNotNull(dataFo);
        deleteFiles(data, wDir);

        implCreateFolderOrDataFile(wDir, fold, data);

        deleteFiles(data, wDir);
        foldFo.getFileSystem().refresh(false);
        foldFo = FileUtil.toFileObject(fold);
        dataFo = FileUtil.toFileObject(data);
        assertNull(foldFo);
        assertNull(dataFo);
        createFiles(data, fold);

        implCreateFolderOrDataFile(wDir, fold, data);
    }

    public void  testCreateFolderOrDataFileWithNotExistingRoot() throws Exception {
        File wDir = null;
        for (char d = 'A'; d < 'Z'; d++ ) {
            wDir = new File(String.valueOf(d)+":/");
            if (!wDir.exists()) {
                break;
            }
        }
        final File fold = new File(wDir,"a/b/c");
        final File data = new File(fold,"c.data");
        try {
            implCreateFolderOrDataFile(wDir, fold, data);
            fail();
        } catch (IOException ex) {
        }
    }

    //just for JDK 1.6
    /*public void  testCreateFolderOrDataFile_ReadOnly() throws Exception {
        final File wDir = getWorkDir();
        final File fold = new File(wDir,"a/b/c");
        final File data = new File(fold,"a/b/c.data");
        assertTrue(getWorkDir().setReadOnly());
        try {
            implCreateFolderOrDataFile(wDir, fold, data);
            fail();
        } catch (IOException ex) {
        } finally {
            assertTrue(getWorkDir().setWritable(true));
        }
    }*/

    private static void createFiles(final File data, final File fold) throws IOException {
        assertTrue(fold.mkdirs());
        assertTrue(data.createNewFile());
    }

    private static void deleteFiles(final File data, final File wDir) {
        File tmp = data;
        while(!tmp.equals(wDir)) {
            assertTrue(tmp.delete());
            tmp = tmp.getParentFile();
        }
    }

    private void implCreateFolderOrDataFile(final File wDir, final File fold, final File data) throws IOException {
        FileObject foldFo = FileUtil.createFolder(fold);
        assertNotNull(foldFo);
        assertTrue(foldFo.isValid());
        assertNotNull(FileUtil.toFile(foldFo));
        assertEquals(FileUtil.toFile(foldFo),fold);
        assertTrue(foldFo.isFolder());

        FileObject dataFo = FileUtil.createData(data);
        assertNotNull(dataFo);
        assertTrue(dataFo.isValid());
        assertNotNull(FileUtil.toFile(dataFo));
        assertEquals(FileUtil.toFile(dataFo),data);
        assertTrue(dataFo.isData());
    }

    public void  testGetNameExt2() throws IOException {
        FileObject fold1 = FileUtil.createFolder(
                FileBasedFileSystem.getFileObject(getWorkDir()),getName());

Return to bug 81527

Lines 39-44 Link Here

(-)fs/src/org/openide/filesystems/FileUtil.java (+91 lines)
39	import java.util.Iterator;	39	import java.util.Iterator;
40	import java.util.Map;	40	import java.util.Map;
41	import java.util.Set;	41	import java.util.Set;
		42	import java.util.Stack;
42	import java.util.StringTokenizer;	43	import java.util.StringTokenizer;
43	import java.util.WeakHashMap;	44	import java.util.WeakHashMap;
44	import java.util.jar.JarEntry;	45	import java.util.jar.JarEntry;
Lines 99-104 Link Here
99	private FileUtil() {	100	private FileUtil() {
100	}	101	}
		102	/**
		103	* Returns FileObject for a folder.
		104	* If such a folder does not exist then it is created, including any necessary but nonexistent parent
		105	* folders. Note that if this operation fails it may have succeeded in creating some of the necessary
		106	* parent folders.
		107	* @param folder folder to be created
		108	* @return FileObject for a folder
		109	* @throws java.io.IOException if the creation fails
		110	* @since 7.0
		111	*/
		112	public static FileObject createFolder (final File folder) throws IOException {
		113	FileObject retval = null;
		114	File root = getRoot(folder);
		115	if (!root.exists()) {
		116	throw new IOException(folder.getAbsolutePath());
		117	}
		118	FileObject rootFo = FileUtil.toFileObject(root);
		119	assert rootFo != null : root.getAbsolutePath();
		120	final String relativePath = getRelativePath(root, folder);
		121	try {
		122	retval = FileUtil.createFolder(rootFo,relativePath);
		123	} catch (IOException ex) {
		124	//thus retval = null;
		125	}
		126	//if refresh needed because of external changes
		127	if (retval == null \|\| !retval.isValid()) {
		128	rootFo.getFileSystem().refresh(false);
		129	retval = FileUtil.createFolder(rootFo,relativePath);
		130	}
		131	assert retval != null;
		132	return retval;
		133	}
		134
		135	/**Returns FileObject for a data file.
		136	* If such a data file does not exist then it is created, including any necessary but nonexistent parent
		137	* folders. Note that if this operation fails it may have succeeded in creating some of the necessary
		138	* parent folders.
		139	* @param data data file to be created
		140	* @return FileObject for a data file
		141	* @throws java.io.IOException if the creation fails
		142	* @since 7.0
		143	*/
		144	public static FileObject createData (final File data) throws IOException {
		145	FileObject retval = null;
		146	File root = getRoot(data);
		147	if (!root.exists()) {
		148	throw new IOException(data.getAbsolutePath());
		149	}
		150	FileObject rootFo = FileUtil.toFileObject(root);
		151	assert rootFo != null : root.getAbsolutePath();
		152	final String relativePath = getRelativePath(root, data);
		153	try {
		154	retval = FileUtil.createData(rootFo,relativePath);
		155	} catch (IOException ex) {
		156	//thus retval = null;
		157	}
		158	//if refresh needed because of external changes
		159	if (retval == null \|\| !retval.isValid()) {
		160	rootFo.getFileSystem().refresh(false);
		161	retval = FileUtil.createData(rootFo,relativePath);
		162	}
		163	assert retval != null;
		164	return retval;
		165	}
166
167	private static File getRoot(final File dir) {
168	File retval = dir;
169	for (; retval.getParentFile() != null; retval = retval.getParentFile());
170	assert retval != null;
171	return retval;
172	}
173
174	private static String getRelativePath(final File dir, final File file) {
175	Stack stack = new Stack ();
176	File tempFile = file;
177	while(tempFile != null && !tempFile.equals(dir)) {
178	stack.push (tempFile.getName());
179	tempFile = tempFile.getParentFile();
180	}
181	assert tempFile != null : file.getAbsolutePath() + "not found in " + dir.getAbsolutePath();//NOI18N
182	StringBuilder retval = new StringBuilder();
183	while (!stack.isEmpty()) {
184	retval.append((String)stack.pop());
185	if (!stack.isEmpty()) {
186	retval.append("/");//NOI18N
187	}
188	}
189	return retval.toString();
190	}
191
101	/** Copies stream of files.	192	/** Copies stream of files.
102	* <P>	193	* <P>
103	* Please be aware, that this method doesn't close any of passed streams.	194	* Please be aware, that this method doesn't close any of passed streams.

Lines 67-72 Link Here

(-)masterfs/test/unit/src/org/netbeans/modules/masterfs/MasterFileObjectTestHid.java (+106 lines)
67	};	67	};
68	}	68	}
		69	public void testCreateNotExistingFolderOrDataFile() throws IOException {
		70	final File wDir = getWorkDir();
		71	final File fold = new File(wDir,"a/b/c");
		72	final File data = new File(fold,"c.data");
		73	implCreateFolderOrDataFile(wDir, fold, data);
		74	}
		75
		76	public void testCreateExistingFolderOrDataFile() throws IOException {
		77	final File wDir = getWorkDir();
		78	final File fold = new File(wDir,"a/b/c");
		79	final File data = new File(fold,"c.data");
		80
		81	assertTrue(fold.mkdirs());
		82	assertTrue(data.createNewFile());
		83
		84	implCreateFolderOrDataFile(wDir, fold, data);
		85	}
		86
		87	public void testCreateFolderOrDataFileExternalChange() throws IOException {
		88	final File wDir = getWorkDir();
		89	final File fold = new File(wDir,"a/b/c");
		90	final File data = new File(fold,"c.data");
		91	createFiles(data, fold);
		92
		93	implCreateFolderOrDataFile(wDir, fold, data);
		94
		95	FileObject foldFo = FileUtil.toFileObject(fold);
		96	FileObject dataFo = FileUtil.toFileObject(data);
		97	assertNotNull(foldFo);
		98	assertNotNull(dataFo);
		99	deleteFiles(data, wDir);
		100
		101	implCreateFolderOrDataFile(wDir, fold, data);
		102
		103	deleteFiles(data, wDir);
		104	foldFo.getFileSystem().refresh(false);
		105	foldFo = FileUtil.toFileObject(fold);
		106	dataFo = FileUtil.toFileObject(data);
		107	assertNull(foldFo);
		108	assertNull(dataFo);
		109	createFiles(data, fold);
		110
		111	implCreateFolderOrDataFile(wDir, fold, data);
		112	}
		113
		114	public void testCreateFolderOrDataFileWithNotExistingRoot() throws Exception {
		115	File wDir = null;
		116	for (char d = 'A'; d < 'Z'; d++ ) {
		117	wDir = new File(String.valueOf(d)+":/");
		118	if (!wDir.exists()) {
		119	break;
		120	}
		121	}
		122	final File fold = new File(wDir,"a/b/c");
		123	final File data = new File(fold,"c.data");
		124	try {
		125	implCreateFolderOrDataFile(wDir, fold, data);
		126	fail();
		127	} catch (IOException ex) {
		128	}
		129	}
		130
		131	//just for JDK 1.6
		132	/*public void testCreateFolderOrDataFile_ReadOnly() throws Exception {
133	final File wDir = getWorkDir();
134	final File fold = new File(wDir,"a/b/c");
135	final File data = new File(fold,"a/b/c.data");
136	assertTrue(getWorkDir().setReadOnly());
137	try {
138	implCreateFolderOrDataFile(wDir, fold, data);
139	fail();
140	} catch (IOException ex) {
141	} finally {
142	assertTrue(getWorkDir().setWritable(true));
143	}
144	}*/
145
146	private static void createFiles(final File data, final File fold) throws IOException {
147	assertTrue(fold.mkdirs());
148	assertTrue(data.createNewFile());
149	}
150
151	private static void deleteFiles(final File data, final File wDir) {
152	File tmp = data;
153	while(!tmp.equals(wDir)) {
154	assertTrue(tmp.delete());
155	tmp = tmp.getParentFile();
156	}
157	}
158
159	private void implCreateFolderOrDataFile(final File wDir, final File fold, final File data) throws IOException {
160	FileObject foldFo = FileUtil.createFolder(fold);
161	assertNotNull(foldFo);
162	assertTrue(foldFo.isValid());
163	assertNotNull(FileUtil.toFile(foldFo));
164	assertEquals(FileUtil.toFile(foldFo),fold);
165	assertTrue(foldFo.isFolder());
166
167	FileObject dataFo = FileUtil.createData(data);
168	assertNotNull(dataFo);
169	assertTrue(dataFo.isValid());
170	assertNotNull(FileUtil.toFile(dataFo));
171	assertEquals(FileUtil.toFile(dataFo),data);
172	assertTrue(dataFo.isData());
173	}
174
69	public void testGetNameExt2() throws IOException {	175	public void testGetNameExt2() throws IOException {
70	FileObject fold1 = FileUtil.createFolder(	176	FileObject fold1 = FileUtil.createFolder(
71	FileBasedFileSystem.getFileObject(getWorkDir()),getName());	177	FileBasedFileSystem.getFileObject(getWorkDir()),getName());