KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > netbeans > modules > masterfs > filebasedfs > fileobjects > FolderObjTest


1 /*
2  * The contents of this file are subject to the terms of the Common Development
3  * and Distribution License (the License). You may not use this file except in
4  * compliance with the License.
5  *
6  * You can obtain a copy of the License at http://www.netbeans.org/cddl.html
7  * or http://www.netbeans.org/cddl.txt.
8  *
9  * When distributing Covered Code, include this CDDL Header Notice in each file
10  * and include the License file at http://www.netbeans.org/cddl.txt.
11  * If applicable, add the following below the CDDL Header, with the fields
12  * enclosed by brackets [] replaced by your own identifying information:
13  * "Portions Copyrighted [year] [name of copyright owner]"
14  *
15  * The Original Software is NetBeans. The Initial Developer of the Original
16  * Software is Sun Microsystems, Inc. Portions Copyright 1997-2006 Sun
17  * Microsystems, Inc. All Rights Reserved.
18  */

19
20 package org.netbeans.modules.masterfs.filebasedfs.fileobjects;
21
22 import java.io.File JavaDoc;
23 import java.io.FileNotFoundException JavaDoc;
24 import java.io.IOException JavaDoc;
25 import java.io.InputStream JavaDoc;
26 import java.io.OutputStream JavaDoc;
27 import java.lang.ref.Reference JavaDoc;
28 import java.lang.ref.WeakReference JavaDoc;
29 import java.util.ArrayList JavaDoc;
30 import java.util.Arrays JavaDoc;
31 import java.util.Collections JavaDoc;
32 import java.util.Enumeration JavaDoc;
33 import java.util.Iterator JavaDoc;
34 import java.util.List JavaDoc;
35 import java.util.logging.Handler JavaDoc;
36 import java.util.logging.Level JavaDoc;
37 import java.util.logging.LogRecord JavaDoc;
38 import java.util.logging.Logger JavaDoc;
39 import org.netbeans.junit.NbTestCase;
40 import org.netbeans.modules.masterfs.filebasedfs.Statistics;
41 import org.netbeans.modules.masterfs.filebasedfs.FileBasedFileSystem;
42 import org.netbeans.modules.masterfs.filebasedfs.naming.NamingFactory;
43 import org.openide.filesystems.FileObject;
44 import org.openide.filesystems.FileSystem;
45 import org.openide.filesystems.FileUtil;
46 import org.netbeans.modules.masterfs.filebasedfs.utils.FileInfo;
47 import org.netbeans.modules.masterfs.providers.ProvidedExtensions;
48 import org.netbeans.modules.masterfs.providers.ProvidedExtensionsTest;
49 import org.openide.filesystems.FileChangeAdapter;
50 import org.openide.filesystems.FileChangeListener;
51 import org.openide.filesystems.FileEvent;
52 import org.openide.filesystems.FileLock;
53 import org.openide.filesystems.FileRenameEvent;
54 import org.openide.filesystems.URLMapper;
55 import org.openide.util.Utilities;
56
57 /**
58  * FolderObjTest.java
59  * @author Radek Matous
60  */

61 public class FolderObjTest extends NbTestCase {
62     File JavaDoc testFile;
63     
64     public FolderObjTest(String JavaDoc testName) {
65         super(testName);
66     }
67             
68     protected void setUp() throws Exception JavaDoc {
69         clearWorkDir();
70         testFile = getWorkDir();
71     }
72
73     protected Level JavaDoc logLevel() {
74         String JavaDoc[] testsWithEnabledLogger = new String JavaDoc[] {
75             "testCreateFolder72617",
76             "testCreateData72617"
77         };
78         return (Arrays.asList(testsWithEnabledLogger).contains(getName())) ?
79             Level.FINEST : Level.OFF;
80     }
81
82     static abstract class IntrusiveLogHandler extends Handler JavaDoc {
83         private String JavaDoc message;
84         IntrusiveLogHandler(final String JavaDoc message) {
85             this.message = message;
86         }
87         public final void publish(LogRecord JavaDoc record) {
88             String JavaDoc recordMsg = record.getMessage();
89             if (recordMsg != null && recordMsg.indexOf(this.message) != -1) {
90                 processLogRecord(record);
91             }
92         }
93
94         abstract protected void processLogRecord(final LogRecord JavaDoc record);
95         public void flush() {}
96         public void close() { flush(); }
97     }
98
99     public void testMove85336() throws Exception JavaDoc {
100         final FileObject workDirFo = FileBasedFileSystem.getFileObject(getWorkDir());
101         FolderObj to = (FolderObj)FileUtil.createFolder(workDirFo, "a/b/c");
102         FolderObj from = (FolderObj)FileUtil.createFolder(workDirFo, "aa/b/c");
103         assertNotNull(to);
104         assertNotNull(from);
105         BaseFileObj what = (BaseFileObj)FileUtil.createData(from, "hello.txt");
106         assertNotNull(what);
107         FileLock lck = what.lock();
108         ProvidedExtensions.IOHandler io = new ProvidedExtensionsTest.ProvidedExtensionsImpl().
109                 getMoveHandler(what.getFileName().getFile(), new File JavaDoc(to.getFileName().getFile(),what.getNameExt()));
110         to.getChildren();
111         try {
112             what.move(lck, to, what.getName(), what.getExt(), io);
113         } finally {
114             lck.releaseLock();
115         }
116     }
117     
118     public void testCreateFolder72617() throws IOException JavaDoc {
119         Handler JavaDoc handler = new IntrusiveLogHandler("FolderCreated:") {//NOI18N
120
protected void processLogRecord(final LogRecord JavaDoc record) {
121                 Object JavaDoc[] params = record.getParameters();
122                 if (params != null && params.length > 0 && params[0] instanceof File JavaDoc) {
123                     File JavaDoc f = (File JavaDoc)params[0];
124                     assertTrue(f.exists());
125                     assertTrue(f.delete());
126                 }
127             }
128         };
129         Logger.getLogger("org.netbeans.modules.masterfs.filebasedfs.fileobjects.FolderObj").addHandler(handler);
130         try {
131             File JavaDoc f = testFile;
132             FileSystem fs = FileBasedFileSystem.getInstance(f);
133             assertNotNull(fs);
134
135             FileObject fo = fs.findResource(TestUtils.getFileObjectPath(testFile));
136             assertNotNull(fo);
137             File JavaDoc f2 = new File JavaDoc (testFile, "newfoldercreated");
138             try {
139                 fo.createFolder (f2.getName());
140                 fail();
141             } catch(IOException JavaDoc iex) {}
142         } finally {
143           Logger.getLogger("org.netbeans.modules.masterfs.filebasedfs.fileobjects.FolderObj").removeHandler(handler);
144         }
145     }
146     
147     public void testCreateData72617() throws IOException JavaDoc {
148         Handler JavaDoc handler = new IntrusiveLogHandler("DataCreated:") {//NOI18N
149
protected void processLogRecord(final LogRecord JavaDoc record) {
150                 Object JavaDoc[] params = record.getParameters();
151                 if (params != null && params.length > 0 && params[0] instanceof File JavaDoc) {
152                     File JavaDoc f = (File JavaDoc)params[0];
153                     assertTrue(f.exists());
154                     assertTrue(f.delete());
155                 }
156             }
157         };
158         Logger.getLogger("org.netbeans.modules.masterfs.filebasedfs.fileobjects.FolderObj").addHandler(handler);
159         try {
160             File JavaDoc f = testFile;
161             FileSystem fs = FileBasedFileSystem.getInstance(f);
162             assertNotNull(fs);
163
164             FileObject fo = fs.findResource(TestUtils.getFileObjectPath(testFile));
165             assertNotNull(fo);
166             File JavaDoc f2 = new File JavaDoc (testFile, "newdatacreated");
167             try {
168                 fo.createData (f2.getName());
169                 fail();
170             } catch(IOException JavaDoc iex) {}
171         } finally {
172           Logger.getLogger("org.netbeans.modules.masterfs.filebasedfs.fileobjects.FolderObj").removeHandler(handler);
173         }
174     }
175     
176
177    public void testFileObjectDistributionWorksAccuratelyAccordingToChildrenCache() throws IOException JavaDoc {
178         final FileObject workDirFo = FileBasedFileSystem.getFileObject(getWorkDir());
179         assertNotNull(workDirFo);
180         File JavaDoc fold = new File JavaDoc(getWorkDir(),"fold");//NOI18N
181
assertNull(FileUtil.toFileObject(fold));
182         FileObject foldFo = workDirFo.createFolder(fold.getName());
183         assertNotNull(foldFo);
184         
185         foldFo.delete();
186         assertNull(((FileBasedFileSystem)workDirFo.getFileSystem()).findFileObject(fold));
187         assertNull(FileBasedFileSystem.getFileObject(fold));
188         assertNull((workDirFo.getFileSystem()).findResource(fold.getAbsolutePath()));
189         assertNull(workDirFo.getFileObject(fold.getName()));
190         assertFalse(existsChild(workDirFo, fold.getName()));
191         fold.mkdir();
192         assertNull(((FileBasedFileSystem)workDirFo.getFileSystem()).findFileObject(fold));
193         assertNull(FileBasedFileSystem.getFileObject(fold));
194         assertNull((workDirFo.getFileSystem()).findResource(fold.getAbsolutePath()));
195         assertNull(workDirFo.getFileObject(fold.getName()));
196         assertFalse(existsChild(workDirFo, fold.getName()));
197         workDirFo.refresh();
198         assertNotNull(((FileBasedFileSystem)workDirFo.getFileSystem()).findFileObject(fold));
199         assertNotNull(FileBasedFileSystem.getFileObject(fold));
200         assertNotNull((workDirFo.getFileSystem()).findResource(fold.getAbsolutePath()));
201         assertNotNull(workDirFo.getFileObject(fold.getName()));
202         assertTrue(existsChild(workDirFo, fold.getName()));
203         fold.delete();
204         assertNotNull(((FileBasedFileSystem)workDirFo.getFileSystem()).findFileObject(fold));
205         assertNotNull(FileBasedFileSystem.getFileObject(fold));
206         assertNotNull((workDirFo.getFileSystem()).findResource(fold.getAbsolutePath()));
207         assertNotNull(workDirFo.getFileObject(fold.getName()));
208         assertTrue(existsChild(workDirFo, fold.getName()));
209         workDirFo.refresh();
210         assertNull(((FileBasedFileSystem)workDirFo.getFileSystem()).findFileObject(fold));
211         assertNull(FileBasedFileSystem.getFileObject(fold));
212         assertNull((workDirFo.getFileSystem()).findResource(fold.getAbsolutePath()));
213         assertNull(workDirFo.getFileObject(fold.getName()));
214         assertFalse(existsChild(workDirFo, fold.getName()));
215         fold.mkdir();
216         assertNull(((FileBasedFileSystem)workDirFo.getFileSystem()).findFileObject(fold));
217         assertNull(FileBasedFileSystem.getFileObject(fold));
218         assertNull((workDirFo.getFileSystem()).findResource(fold.getAbsolutePath()));
219         assertNull(workDirFo.getFileObject(fold.getName()));
220         assertFalse(existsChild(workDirFo, fold.getName()));
221         workDirFo.getFileSystem().refresh(false);
222         assertNotNull(((FileBasedFileSystem)workDirFo.getFileSystem()).findFileObject(fold));
223         assertNotNull(FileBasedFileSystem.getFileObject(fold));
224         assertNotNull((workDirFo.getFileSystem()).findResource(fold.getAbsolutePath()));
225         assertNotNull(workDirFo.getFileObject(fold.getName()));
226         assertTrue(existsChild(workDirFo, fold.getName()));
227         foldFo.delete();
228         assertNull(((FileBasedFileSystem)workDirFo.getFileSystem()).findFileObject(fold));
229         assertNull(FileBasedFileSystem.getFileObject(fold));
230         assertNull((workDirFo.getFileSystem()).findResource(fold.getAbsolutePath()));
231         assertNull(workDirFo.getFileObject(fold.getName()));
232         assertFalse(existsChild(workDirFo, fold.getName()));
233         fold.mkdir();
234         assertNull(((FileBasedFileSystem)workDirFo.getFileSystem()).findFileObject(fold));
235         assertNull(FileBasedFileSystem.getFileObject(fold));
236         assertNull((workDirFo.getFileSystem()).findResource(fold.getAbsolutePath()));
237         assertNull(workDirFo.getFileObject(fold.getName()));
238         assertFalse(existsChild(workDirFo, fold.getName()));
239         workDirFo.getFileSystem().refresh(false);
240         assertNotNull(((FileBasedFileSystem)workDirFo.getFileSystem()).findFileObject(fold));
241         assertNotNull(FileBasedFileSystem.getFileObject(fold));
242         assertNotNull((workDirFo.getFileSystem()).findResource(fold.getAbsolutePath()));
243         assertNotNull(workDirFo.getFileObject(fold.getName()));
244         assertTrue(existsChild(workDirFo, fold.getName()));
245         fold.delete();
246         assertNotNull(((FileBasedFileSystem)workDirFo.getFileSystem()).findFileObject(fold));
247         assertNotNull(FileBasedFileSystem.getFileObject(fold));
248         assertNotNull((workDirFo.getFileSystem()).findResource(fold.getAbsolutePath()));
249         assertNotNull(workDirFo.getFileObject(fold.getName()));
250         assertTrue(existsChild(workDirFo, fold.getName()));
251         workDirFo.getFileSystem().refresh(false);
252         assertNull(((FileBasedFileSystem)workDirFo.getFileSystem()).findFileObject(fold));
253         assertNull(FileBasedFileSystem.getFileObject(fold));
254         assertNull((workDirFo.getFileSystem()).findResource(fold.getAbsolutePath()));
255         assertNull(workDirFo.getFileObject(fold.getName()));
256         assertFalse(existsChild(workDirFo, fold.getName()));
257     }
258    
259    private static boolean existsChild(final FileObject folder, final String JavaDoc childName) {
260        FileObject[] childs = folder.getChildren();
261        for (int i = 0; i < childs.length; i++) {
262            if (childs[i].getNameExt().equals(childName)) {
263                return true;
264            }
265        }
266        return false;
267    }
268         
269     public void testChildren() throws Exception JavaDoc {
270         final FolderObj testRoot = (FolderObj)FileBasedFileSystem.getFileObject(getWorkDir());
271         assertNotNull(testRoot);
272         for (int i = 0; i < 5; i++) {
273             assertTrue(new File JavaDoc (getWorkDir(), "file"+String.valueOf(i)).createNewFile());
274         }
275         assertEquals(5,testRoot.getChildren().length);
276     }
277     
278     public void testSize() throws Exception JavaDoc {
279         final FolderObj testRoot = (FolderObj)FileBasedFileSystem.getFileObject(getWorkDir());
280         assertNotNull(testRoot);
281         FileObj bfo = (FileObj)testRoot.createData(getName());
282
283         assertSize("",Collections.singleton(bfo),32 ,new Object JavaDoc[] {bfo.getFileName()});
284         assertSize("",Collections.singleton(testRoot),32 ,new Object JavaDoc[] {testRoot.getFileName(),
285         testRoot.getChildrenCache()});
286     }
287     
288     public void testCreateNbAttrs() throws IOException JavaDoc {
289         final FileObject testRoot = FileBasedFileSystem.getFileObject(getWorkDir());
290         assertNotNull(testRoot);
291         try {
292             testRoot.createData(".nbattrs");
293             fail();
294         } catch (IOException JavaDoc ex) {}
295     }
296     
297     public void testCreateWriteLock() throws IOException JavaDoc {
298         final FileObject testRoot = FileBasedFileSystem.getFileObject(getWorkDir());
299         assertNotNull(testRoot);
300         File JavaDoc file2lock = new File JavaDoc(getWorkDir(),"aa.txt");
301         File JavaDoc associatedLock = WriteLockUtils.getAssociatedLockFile(file2lock);//NOI18N
302

303         try {
304             testRoot.createData(associatedLock.getName());
305             fail();
306         } catch (IOException JavaDoc ex) {}
307     }
308     
309     
310     public void testCaseInsensitivity() throws Exception JavaDoc {
311         if (!Utilities.isWindows()) return;
312         final FileObject testRoot = FileBasedFileSystem.getFileObject(getWorkDir());
313         assertNotNull(testRoot);
314         
315         File JavaDoc testa = new File JavaDoc(getWorkDir(), "a");
316         File JavaDoc testA = new File JavaDoc(getWorkDir(), "A");
317         
318         if (testA.exists()) {
319             assertTrue(testA.delete());
320         }
321         if (!testa.exists()) {
322             assertTrue(testa.createNewFile());
323         }
324
325         //FileBasedFileSystem's case sensitivity depends on platform. This is different behaviour
326
// than originally provided by AbstractFileSystem.
327
FileObject A = testRoot.getFileObject("A");
328         assertNotNull(A);
329         assertNotNull(testRoot.getFileObject("a"));
330         assertSame(testRoot.getFileObject("A"), testRoot.getFileObject("a"));
331         assertSame(URLMapper.findFileObject(testa.toURI().toURL()),
332                 URLMapper.findFileObject(testA.toURI().toURL()));
333         
334         //but
335
testRoot.getChildren();
336         assertEquals("A",testRoot.getFileObject("A").getName());
337         assertEquals("A",testRoot.getFileObject("a").getName());
338         BaseFileObj bobj = (BaseFileObj)testRoot.getFileObject("a");
339         NamingFactory.checkCaseSensitivity(bobj.getFileName(),testa);
340         assertEquals("a",testRoot.getFileObject("a").getName());
341         assertEquals("a",testRoot.getFileObject("A").getName());
342     }
343     
344     private class TestListener extends FileChangeAdapter {
345         private List JavaDoc fileObjects;
346         TestListener(List JavaDoc fileObjects) {
347             this.fileObjects = fileObjects;
348         }
349         public void fileFolderCreated(FileEvent fe) {
350             assertTrue(fileObjects.remove(fe.getFile()));
351         }
352
353         public void fileDeleted(FileEvent fe) {
354             assertTrue(fileObjects.remove(fe.getFile()));
355         }
356
357         public void fileDataCreated(FileEvent fe) {
358             assertTrue(fileObjects.remove(fe.getFile()));
359         }
360     }
361     
362     public void testSimulatesRefactoringRename() throws Exception JavaDoc {
363         if (!Utilities.isWindows()) return;
364         FileBasedFileSystem fs = FileBasedFileSystem.getInstance(getWorkDir());
365         assertNotNull(fs);
366         final FileObject root = fs.findFileObject(getWorkDir());
367         assertNotNull(root);
368         FileObject main = root.createData("Main.java");
369         FileUtil.createData(root,"subpackage/newclass.java");
370         final List JavaDoc fileObjects = new ArrayList JavaDoc() {
371             public boolean add(Object JavaDoc o) {
372                 assertNotNull(o);
373                 return super.add(o);
374             }
375             
376         };
377         final TestListener tl = new TestListener(fileObjects);
378         fs.addFileChangeListener(tl);
379         try {
380             fs.runAtomicAction(new FileSystem.AtomicAction(){
381                 public void run() throws IOException JavaDoc {
382                     FileObject subpackage = root.getFileObject("subpackage");
383                     FileObject newclass = subpackage.getFileObject("newclass.java");
384                     FileObject subpackage1 = root.createFolder("subpackage1");
385                     fileObjects.add(subpackage1);
386                     FileObject newclass1 = subpackage1.createData("newclass.java");
387                     fileObjects.add(newclass1);
388                     subpackage.delete();
389                     fileObjects.add(subpackage);
390                     fileObjects.add(newclass);
391                 }
392             });
393         } finally {
394             fs.removeFileChangeListener(tl);
395         }
396         assertTrue(fileObjects.toString(),fileObjects.isEmpty());
397         assertNotNull(root.getFileObject("Main.java"));
398         assertNotNull(root.getFileObject("subpackage1"));
399         assertNotNull(root.getFileObject("subpackage1/newclass.java"));
400         assertNull(root.getFileObject("subpackage"));
401         fs.addFileChangeListener(tl);
402         try {
403             fs.runAtomicAction(new FileSystem.AtomicAction(){
404                 public void run() throws IOException JavaDoc {
405                     FileObject subpackage1 = root.getFileObject("subpackage1");
406                     FileObject newclass = root.getFileObject("subpackage1/newclass.java");
407                     FileObject Subpackage = root.createFolder("Subpackage");
408                     fileObjects.add(Subpackage);
409                     FileObject newclass1 = Subpackage.createData("newclass.java");
410                     fileObjects.add(newclass1);
411                     subpackage1.delete();
412                     fileObjects.add(subpackage1);
413                     fileObjects.add(newclass);
414                 }
415             });
416         } finally {
417             fs.removeFileChangeListener(tl);
418         }
419         assertTrue(fileObjects.toString(), fileObjects.isEmpty());
420         assertNotNull(root.getFileObject("Main.java"));
421         assertNotNull(root.getFileObject("Subpackage/newclass.java"));
422         assertNull(root.getFileObject("subpackage1"));
423     }
424     
425     public void testRename() throws Exception JavaDoc {
426         File JavaDoc f = testFile;
427         FileSystem fs = FileBasedFileSystem.getInstance(f);
428         assertNotNull(fs);
429
430         final List JavaDoc l = new ArrayList JavaDoc ();
431         FileChangeListener fcl = new FileChangeAdapter () {
432              public void fileRenamed(FileRenameEvent fe) {
433                  FileObject fold = (FileObject)fe.getFile();
434                  assertTrue(fold.getChildren().length > 0);
435                  l.add(fe);
436              }
437         };
438         
439         FileObject fo = fs.findResource(f.getAbsolutePath().replace('\\','/'));
440         assertNotNull(fo);
441         FileObject folder =fo.createFolder("testRename");
442         assertNotNull(folder);
443         
444         FileObject file =folder.createData("test.txt");
445         assertNotNull(file);
446         folder.addFileChangeListener(fcl);
447         assertTrue(folder.getChildren().length > 0);
448         FileLock lock = folder.lock();
449         try {
450             folder.rename(lock,"renfolder","");
451             assertTrue(folder.getChildren().length > 0);
452             assertTrue(!l.isEmpty());
453             
454             l.clear();
455             
456             folder.rename(lock,"testRename","");
457             assertTrue(folder.getChildren().length > 0);
458             assertTrue(!l.isEmpty());
459             
460         } finally {
461             lock.releaseLock();
462         }
463         
464         
465      }
466
467      public void testRename2 () throws Exception JavaDoc {
468         File JavaDoc test = new File JavaDoc (getWorkDir(), "testrename.txt");
469         if (!test.exists()) {
470             assertTrue(test.createNewFile());
471         }
472         
473         FileBasedFileSystem fs = FileBasedFileSystem.getInstance(test);
474         assertNotNull(fs);
475         
476         FileObject testFo = fs.findFileObject(test);
477         assertNotNull (testFo);
478
479         FileLock lock = testFo.lock();
480         assertNotNull (lock);
481         try {
482          testFo.rename(lock, "TESTRENAME", "TXT");
483         } finally {
484             lock.releaseLock();
485         }
486     }
487
488     /**
489      * Test of getChildren method, of class org.netbeans.modules.masterfs.filebasedfs.fileobjects.FolderObj.
490      */

491     public void testGetChildren() throws Exception JavaDoc {
492         File JavaDoc f = testFile;
493         FileSystem fs = FileBasedFileSystem.getInstance(f);
494         assertNotNull(fs);
495         assertNotNull(f.getAbsolutePath(),fs.findResource(f.getAbsolutePath()));
496         
497         while (f != null) {
498             if (new FileInfo (f).isWindowsFloppy()) continue;
499             FileObject fo0 = fs.findResource(f.getAbsolutePath());
500             assertNotNull(f.getAbsolutePath(),fo0);
501             
502             FileObject fo = fs.getRoot().getFileObject(f.getAbsolutePath().replace('\\','/'));
503             assertNotNull(f.getAbsolutePath(),fo);
504             if (fo0 != fo) {
505                 fs.getRoot().getFileObject(f.getAbsolutePath().replace('\\','/'));
506             }
507             assertSame(fo.toString(), fo0, fo);
508             
509             if (f.getParentFile() != null) {
510                 FileObject parent = fo.getParent();
511                 assertNotNull(parent);
512                 String JavaDoc nameExt = fo.getNameExt();
513                 FileObject fo2 = parent.getFileObject(nameExt);
514                 assertNotNull(fo2);
515                 assertSame(fo, fo2);
516                 FileObject[] fos = parent.getChildren();
517                 List JavaDoc list = Arrays.asList(fos);
518                 assertTrue((fo.toString()+ " " + System.identityHashCode(fo)),list.contains(fo));
519
520                
521                 WeakReference JavaDoc ref = new WeakReference JavaDoc (fo);
522                 String JavaDoc msg = fo.toString();
523                 fo = null; fo0 = null; fo2 = null; parent = null;fos = null; list = null;
524                 assertGC(msg, ref);
525             } else {
526                 //dsik roots are kept by hard reference
527
WeakReference JavaDoc ref = new WeakReference JavaDoc (fo);
528                 String JavaDoc msg = fo.toString();
529                 fo = null; fo0 = null;
530                 assertNotNull(msg, ref.get());
531             }
532             
533             f = f.getParentFile();
534         }
535     }
536     
537     public void testGetChildrenStackOwerflow() throws Exception JavaDoc {
538         File JavaDoc f = testFile;
539         assertTrue(f.exists());
540         assertTrue(f.isDirectory());
541         FileSystem fs = FileBasedFileSystem.getInstance(f);
542         assertNotNull(fs);
543         final FileObject fo = fs.findResource(f.getAbsolutePath());
544         assertNotNull(f.getAbsolutePath(),fo);
545         assertTrue(fo.isFolder());
546         assertEquals(0,fo.getChildren().length);
547         assertTrue(new File JavaDoc(f,"child1").createNewFile());
548         assertTrue(new File JavaDoc(f,"child2").createNewFile());
549         final File JavaDoc child3 = new File JavaDoc(f,"child3");
550         assertTrue(child3.createNewFile());
551         final List JavaDoc keepThem = new ArrayList JavaDoc();
552         fo.addFileChangeListener(new FileChangeAdapter(){
553             public void fileDeleted(FileEvent fe) {
554                 for (Iterator JavaDoc it = keepThem.iterator(); it.hasNext();) {
555                     FileObject fodel = (FileObject) it.next();
556                     FileObject[] all = fo.getChildren();
557                     for (int i = 0; i < all.length; i++) {
558                         all[i].refresh();
559                     }
560                     
561                 }
562             }
563             
564             public void fileDataCreated(FileEvent fe) {
565                 FileObject ffoo = fe.getFile();
566                 keepThem.add(ffoo);
567                 ((BaseFileObj)ffoo).getFileName().getFile().delete();
568                 ffoo.refresh();
569             }
570         } );
571
572         fo.refresh();
573         assertEquals(0,fo.getChildren().length);
574     }
575     
576     /**
577      * Test of isData method, of class org.netbeans.modules.masterfs.filebasedfs.fileobjects.FolderObj.
578      */

579     public void testIsData() {
580         File JavaDoc f = testFile;
581         FileSystem fs = FileBasedFileSystem.getInstance(f);
582         assertNotNull(fs);
583         
584         while (f != null) {
585             FileObject fo = fs.findResource(f.getAbsolutePath());
586             assertNotNull(f.getAbsolutePath(),fo);
587             assertEquals(f.isFile(), fo.isData());
588             if (fo.isData ()) {
589                 assertTrue(fo instanceof FileObj);
590             }
591             
592             f = f.getParentFile();
593         }
594     }
595     
596     /**
597      * Test of isFolder method, of class org.netbeans.modules.masterfs.filebasedfs.fileobjects.FolderObj.
598      */

599     public void testIsFolder() {
600         File JavaDoc f = testFile;
601         FileSystem fs = FileBasedFileSystem.getInstance(f);
602         assertNotNull(fs);
603         
604         while (f != null) {
605             FileObject fo = fs.findResource(f.getAbsolutePath());
606             assertNotNull(f.getAbsolutePath(),fo);
607             if (fo.isFolder() && !fo.isRoot()) {
608                 assertTrue(fo instanceof FolderObj);
609             }
610            
611             f = f.getParentFile();
612         }
613     }
614     
615     /**
616      * Test of isRoot method, of class org.netbeans.modules.masterfs.filebasedfs.fileobjects.FolderObj.
617      */

618     public void testIsRoot() {
619         File JavaDoc f = testFile;
620         FileSystem fs = FileBasedFileSystem.getInstance(f);
621         assertNotNull(fs);
622         FileObject fo = null;
623         while (f != null) {
624             fo = fs.findResource(f.getAbsolutePath());
625             assertNotNull(f.getAbsolutePath(),fo);
626             f = f.getParentFile();
627         }
628         assertNotNull(fo.toString(), fo);
629         FileObject root = fo.getParent ();
630         
631         assertNotNull(root.toString(), root);
632         assertTrue(root.isRoot());
633         assertTrue(root instanceof RootObj);
634         assertSame(root, fs.getRoot());
635         assertSame(fo, root.getFileObject(fo.getNameExt()));
636     }
637     
638     /**
639      * Test of getFileObject method, of class org.netbeans.modules.masterfs.filebasedfs.fileobjects.FolderObj.
640      */

641     public void testGetFileObject() {
642         File JavaDoc f = testFile;
643         FileSystem fs = FileBasedFileSystem.getInstance(f);
644         assertNotNull(fs);
645         
646         while (f != null) {
647             FileObject fo = fs.findResource(f.getAbsolutePath());
648             assertNotNull(f.getAbsolutePath(),fo);
649             FileObject parent = fo.getParent();
650             while (parent != null && parent != fo) {
651                 assertNotNull(parent);
652                 String JavaDoc relativePath = FileUtil.getRelativePath(parent, fo);
653                 assertNotNull(relativePath);
654                 FileObject fo2 = parent.getFileObject(relativePath);
655                 assertNotNull((relativePath + " not found in " + parent.toString()), fo2);
656                 assertSame (fo, fo2);
657                 parent = parent.getParent();
658             }
659
660             assertNotNull(fs.getRoot().getFileObject(TestUtils.getFileObjectPath(((BaseFileObj)fo).getFileName().getFile ())));
661             f = f.getParentFile();
662         }
663     }
664     
665     
666     /**
667      * Test of createFolder method, of class org.netbeans.modules.masterfs.filebasedfs.fileobjects.FolderObj.
668      */

669     public void testCreateFolder() throws Exception JavaDoc {
670         File JavaDoc f = testFile;
671         FileSystem fs = FileBasedFileSystem.getInstance(f);
672         assertNotNull(fs);
673
674         FileObject fo = fs.findResource(TestUtils.getFileObjectPath(testFile));
675         
676         File JavaDoc f2 = new File JavaDoc (testFile, "newfoldercreated");
677         FileObject nfo = fo.createFolder (f2.getName());
678         assertNotNull(nfo);
679         assertTrue(nfo.isFolder());
680         File JavaDoc nfile = ((BaseFileObj)nfo).getFileName().getFile ();
681         assertSame(nfo, fs.findResource(TestUtils.getFileObjectPath(nfile)));
682         assertSame(fo, nfo.getParent());
683         
684         try {
685             FileObject nfo2 = fo.createFolder (f2.getName());
686             fail ();
687         } catch (IOException JavaDoc iox) {
688             
689         }
690         
691     }
692
693     /**
694      * Test of createData method, of class org.netbeans.modules.masterfs.filebasedfs.fileobjects.FolderObj.
695      */

696     public void testCreateData() throws Exception JavaDoc {
697         File JavaDoc f = testFile;
698         FileSystem fs = FileBasedFileSystem.getInstance(f);
699         assertNotNull(fs);
700
701         final FileObject fo = fs.findResource(TestUtils.getFileObjectPath(testFile));
702         
703         File JavaDoc f2 = new File JavaDoc (testFile, "newdatacreated.txt");
704         final FileObject nfo = fo.createData (f2.getName());
705         assertNotNull(nfo);
706         assertTrue(nfo.isData());
707         File JavaDoc nfile = ((BaseFileObj)nfo).getFileName().getFile ();
708         assertEquals(nfo.getClass(), fs.findResource(TestUtils.getFileObjectPath(nfile)).getClass());
709         assertSame(nfo, fs.findResource(TestUtils.getFileObjectPath(nfile)));
710         /*if (nfo.getParent() != fo) {
711             nfo.getParent();
712         }*/

713         System.gc();System.gc();System.gc();System.gc();System.gc();System.gc();
714         FileObject pp = nfo.getParent();
715         assertEquals(((BaseFileObj)pp).getFileName().getFile(), ((BaseFileObj)fo).getFileName().getFile());
716         assertEquals(((BaseFileObj)pp).getFileName().getId(), ((BaseFileObj)fo).getFileName().getId());
717         
718         assertSame(((BaseFileObj)fo).getFileName().getId() + " | " + ((BaseFileObj)nfo.getParent()).getFileName().getId(), fo, pp);
719         
720         try {
721             FileObject nfo2 = fo.createData (f2.getName());
722             fail ();
723         } catch (IOException JavaDoc iox) {
724             
725         }
726     }
727
728     
729     /**
730      * Test of delete method, of class org.netbeans.modules.masterfs.filebasedfs.fileobjects.FolderObj.
731      */

732     public void testDelete() throws IOException JavaDoc {
733         File JavaDoc f = testFile;
734         FileBasedFileSystem fs = FileBasedFileSystem.getInstance(f);
735         
736         FileObject testFo = fs.findFileObject(testFile);
737         assertNotNull(testFo);
738         
739         final List JavaDoc l = new ArrayList JavaDoc ();
740         FileChangeListener fcl = new FileChangeAdapter () {
741             public void fileDeleted(FileEvent fe) {
742                 l.add(fe);
743             }
744         };
745         FileObject fo = FileUtil.createData(testFo, "delete/the/whole/structure/in/depth/todelete.txt");
746         fo.addFileChangeListener(fcl);
747         
748         FileObject toDelete = testFo.getFileObject("delete");
749         assertNotNull(toDelete);
750         toDelete.addFileChangeListener(fcl);
751
752         FileObject toGC = testFo.getFileObject("delete/the/whole/structure");
753         assertNotNull(toGC);
754         Reference JavaDoc toGCRef = new WeakReference JavaDoc (toGC);
755         toGC.addFileChangeListener(fcl);
756         toGC = null;
757         
758         assertGC("", toGCRef);
759         toDelete.delete();
760         assertEquals(0,testFo.getChildren().length);
761         toDelete = testFo.getFileObject("delete");
762         assertNull(toDelete);
763         assertEquals(2, l.size());
764     }
765
766     public void testDelete2() throws IOException JavaDoc {
767         File JavaDoc f = testFile;
768         FileBasedFileSystem fs = FileBasedFileSystem.getInstance(f);
769         
770         FileObject testFo = fs.findFileObject(testFile);
771         assertNotNull(testFo);
772         assertEquals(0,testFo.getChildren().length);
773         
774         FileObject newFolder = testFo.createFolder("testDelete2");
775         assertNotNull(newFolder);
776         assertEquals(1,testFo.getChildren().length);
777         
778         newFolder.delete();
779         assertFalse(newFolder.isValid());
780         assertEquals(0,testFo.getChildren().length);
781         assertNull(testFo.getFileObject(newFolder.getNameExt()));
782     }
783     
784     public void testExternalDelete2() throws IOException JavaDoc {
785         File JavaDoc f = new File JavaDoc(testFile, "testDelete2/testForExternalRefresh/");
786         assert !f.exists() : f.getAbsolutePath();
787         assert f.mkdirs() : f.getAbsolutePath();
788         assert f.exists() : f.getAbsolutePath();
789         
790         FileBasedFileSystem fs = FileBasedFileSystem.getInstance(f);
791         
792         FileObject testFo = fs.findFileObject(f);
793         assertNotNull(testFo);
794         assertTrue(testFo.isFolder());
795
796         final List JavaDoc l = new ArrayList JavaDoc ();
797         FileChangeListener fcl = new FileChangeAdapter () {
798             public void fileDeleted(FileEvent fe) {
799                 l.add(fe);
800                 fe.getFile().refresh();
801             }
802             public void fileChanged(FileEvent fe) {
803                 fail();
804             }
805             
806         };
807
808         testFo.addFileChangeListener(fcl);
809         assertEquals(0, l.size());
810         
811         f.delete();
812         testFo.refresh();
813         assertEquals(1, l.size());
814     }
815
816     public void testExternalDelete2_1() throws IOException JavaDoc {
817         File JavaDoc f = new File JavaDoc(testFile, "testDelete2/testForExternalRefresh/");
818         assert !f.exists() : f.getAbsolutePath();
819         assert f.mkdirs() : f.getAbsolutePath();
820         assert f.exists() : f.getAbsolutePath();
821         
822         FileBasedFileSystem fs = FileBasedFileSystem.getInstance(f);
823         
824         final FileObject testFo = fs.findFileObject(f);
825         assertNotNull(testFo);
826         assertTrue(testFo.isFolder());
827
828         final List JavaDoc l = new ArrayList JavaDoc ();
829         FileChangeListener fcl = new FileChangeAdapter () {
830             public void fileDeleted(FileEvent fe) {
831                 if (fe.getFile().equals(testFo)) {
832                     l.add(fe);
833                 }
834                 fe.getFile().refresh();
835             }
836             public void fileChanged(FileEvent fe) {
837                 fail();
838             }
839             
840         };
841
842         testFo.getFileSystem().addFileChangeListener(fcl);
843         assertEquals(0, l.size());
844         
845         f.delete();
846         testFo.getFileSystem().refresh(true);
847         assertEquals(1, l.size());
848         testFo.getFileSystem().removeFileChangeListener(fcl);
849     }
850
851     public void testExternalDelete2_2() throws IOException JavaDoc {
852         File JavaDoc f = new File JavaDoc(testFile, "testDelete2/testForExternalRefresh/");
853         assert !f.exists() : f.getAbsolutePath();
854         assert f.mkdirs() : f.getAbsolutePath();
855         assert f.exists() : f.getAbsolutePath();
856         
857         FileBasedFileSystem fs = FileBasedFileSystem.getInstance(f);
858         
859         FileObject testFo = fs.findFileObject(f);
860         assertNotNull(testFo);
861         assertTrue(testFo.isFolder());
862
863         final List JavaDoc l = new ArrayList JavaDoc ();
864         FileChangeListener fcl = new FileChangeAdapter () {
865             public void fileDeleted(FileEvent fe) {
866                 l.add(fe);
867                 fe.getFile().refresh();
868             }
869             public void fileChanged(FileEvent fe) {
870                 fail();
871             }
872         };
873
874         testFo.addFileChangeListener(fcl);
875         assertEquals(0, l.size());
876         
877         f.delete();
878         testFo.getFileSystem().refresh(true);
879         assertEquals(1, l.size());
880     }
881     
882     public void testExternalDelete3() throws IOException JavaDoc {
883         File JavaDoc f = new File JavaDoc(testFile, "testDelete2/testForExternalRefresh3/");
884         assert !f.exists() : f.getAbsolutePath();
885         assert f.mkdirs() : f.getAbsolutePath();
886         assert f.exists() : f.getAbsolutePath();
887         f = new File JavaDoc(f, "f.txt");
888         assert !f.exists() : f.getAbsolutePath();
889         assert f.createNewFile() : f.getAbsolutePath();
890         assert f.exists() : f.getAbsolutePath();
891         
892         
893         FileBasedFileSystem fs = FileBasedFileSystem.getInstance(f);
894         
895         FileObject testFo = fs.findFileObject(f);
896         assertNotNull(testFo);
897         assertTrue(testFo.isData());
898
899         final List JavaDoc l = new ArrayList JavaDoc ();
900         FileChangeListener fcl = new FileChangeAdapter () {
901             public void fileDeleted(FileEvent fe) {
902                 l.add(fe);
903                 fe.getFile().refresh();
904             }
905
906             public void fileChanged(FileEvent fe) {
907                 fail();
908             }
909             
910         };
911
912         testFo.addFileChangeListener(fcl);
913         assertEquals(0, l.size());
914         
915         f.delete();
916
917         //testFo.lastModified();
918
//testFo.refresh();
919
testFo.refresh();
920         
921         assertEquals(1, l.size());
922     }
923
924     public void testExternalDelete3_1() throws IOException JavaDoc {
925         File JavaDoc f = new File JavaDoc(testFile, "testDelete2/testForExternalRefresh3/");
926         assert !f.exists() : f.getAbsolutePath();
927         assert f.mkdirs() : f.getAbsolutePath();
928         assert f.exists() : f.getAbsolutePath();
929         f = new File JavaDoc(f, "f.txt");
930         assert !f.exists() : f.getAbsolutePath();
931         assert f.createNewFile() : f.getAbsolutePath();
932         assert f.exists() : f.getAbsolutePath();
933         
934         
935         FileBasedFileSystem fs = FileBasedFileSystem.getInstance(f);
936         
937         FileObject testFo = fs.findFileObject(f);
938         assertNotNull(testFo);
939         assertTrue(testFo.isData());
940
941         final List JavaDoc l = new ArrayList JavaDoc ();
942         FileChangeListener fcl = new FileChangeAdapter () {
943             public void fileDeleted(FileEvent fe) {
944                 l.add(fe);
945                 fe.getFile().refresh();
946             }
947             public void fileChanged(FileEvent fe) {
948                 fail();
949             }
950             
951         };
952
953         testFo.getFileSystem().addFileChangeListener(fcl);
954         assertEquals(0, l.size());
955         
956         f.delete();
957         testFo.getFileSystem().refresh(true);
958         assertEquals(1, l.size());
959         testFo.getFileSystem().removeFileChangeListener(fcl);
960
961     }
962     
963     public void testExternalDelete3_2() throws IOException JavaDoc {
964         File JavaDoc f = new File JavaDoc(testFile, "testDelete2/testForExternalRefresh3/");
965         assert !f.exists() : f.getAbsolutePath();
966         assert f.mkdirs() : f.getAbsolutePath();
967         assert f.exists() : f.getAbsolutePath();
968         f = new File JavaDoc(f, "f.txt");
969         assert !f.exists() : f.getAbsolutePath();
970         assert f.createNewFile() : f.getAbsolutePath();
971         assert f.exists() : f.getAbsolutePath();
972         
973         
974         FileBasedFileSystem fs = FileBasedFileSystem.getInstance(f);
975         
976         FileObject testFo = fs.findFileObject(f);
977         assertNotNull(testFo);
978         assertTrue(testFo.isData());
979
980         final List JavaDoc l = new ArrayList JavaDoc ();
981         FileChangeListener fcl = new FileChangeAdapter () {
982             public void fileDeleted(FileEvent fe) {
983                 l.add(fe);
984                 fe.getFile().refresh();
985             }
986             public void fileChanged(FileEvent fe) {
987                 fail();
988             }
989             
990         };
991
992         testFo.addFileChangeListener(fcl);
993         assertEquals(0, l.size());
994         
995         f.delete();
996         testFo.getFileSystem().refresh(true);
997         assertEquals(1, l.size());
998     }
999     
1000    
1001    public void testExternalDelete4() throws IOException JavaDoc {
1002        File JavaDoc f = new File JavaDoc(testFile, "testDelete2/testForExternalRefresh3/");
1003        assert !f.exists() : f.getAbsolutePath();
1004        assert f.mkdirs() : f.getAbsolutePath();
1005        assert f.exists() : f.getAbsolutePath();
1006
1007        FileBasedFileSystem fs = FileBasedFileSystem.getInstance(f);
1008        FileObject testFolder = fs.findFileObject(f);
1009        assertNotNull(testFolder);
1010        assertTrue(testFolder.isFolder());
1011        
1012        f = new File JavaDoc(f, "f.txt");
1013        assert !f.exists() : f.getAbsolutePath();
1014        assert f.createNewFile() : f.getAbsolutePath();
1015        assert f.exists() : f.getAbsolutePath();
1016
1017        FileObject testFile = testFolder.getFileObject(f.getName());
1018        assertNotNull(testFile);
1019        assertTrue(testFile.isData());
1020                        
1021
1022        final List JavaDoc l = new ArrayList JavaDoc ();
1023        FileChangeListener fcl = new FileChangeAdapter () {
1024            public void fileDeleted(FileEvent fe) {
1025                l.add(fe);
1026                fe.getFile().refresh();
1027            }
1028            public void fileChanged(FileEvent fe) {
1029                fail();
1030            }
1031            
1032        };
1033
1034        testFolder.addFileChangeListener(fcl);
1035        assertEquals(0, l.size());
1036        
1037        assertTrue(f.delete());
1038        testFolder.refresh();
1039        assertEquals(1, l.size());
1040    }
1041
1042    public void testExternalDelete4_1() throws IOException JavaDoc {
1043        File JavaDoc f = new File JavaDoc(testFile, "testDelete2/testForExternalRefresh3/");
1044        assert !f.exists() : f.getAbsolutePath();
1045        assert f.mkdirs() : f.getAbsolutePath();
1046        assert f.exists() : f.getAbsolutePath();
1047
1048        FileBasedFileSystem fs = FileBasedFileSystem.getInstance(f);
1049        FileObject testFolder = fs.findFileObject(f);
1050        assertNotNull(testFolder);
1051        assertTrue(testFolder.isFolder());
1052        
1053        f = new File JavaDoc(f, "f.txt");
1054        assert !f.exists() : f.getAbsolutePath();
1055        assert f.createNewFile() : f.getAbsolutePath();
1056        assert f.exists() : f.getAbsolutePath();
1057
1058        FileObject testFile = testFolder.getFileObject(f.getName());
1059        assertNotNull(testFile);
1060        assertTrue(testFile.isData());
1061                        
1062
1063        final List JavaDoc l = new ArrayList JavaDoc ();
1064        FileChangeListener fcl = new FileChangeAdapter () {
1065            public void fileDeleted(FileEvent fe) {
1066                l.add(fe);
1067                fe.getFile().refresh();
1068            }
1069            public void fileChanged(FileEvent fe) {
1070                fail();
1071            }
1072            
1073        };
1074
1075        testFolder.getFileSystem().addFileChangeListener(fcl);
1076        assertEquals(0, l.size());
1077        
1078        f.delete();
1079        testFolder.getFileSystem().refresh(true);
1080       testFolder.getFileSystem().removeFileChangeListener(fcl);
1081        assertEquals(1, l.size());
1082
1083    }
1084
1085    public void testExternalDelete4_1_1() throws IOException JavaDoc {
1086        File JavaDoc f = new File JavaDoc(testFile, "testDelete2/testForExternalRefresh3/");
1087        assert !f.exists() : f.getAbsolutePath();
1088        assert f.mkdirs() : f.getAbsolutePath();
1089        assert f.exists() : f.getAbsolutePath();
1090
1091        FileBasedFileSystem fs = FileBasedFileSystem.getInstance(f);
1092        FileObject testFolder = fs.findFileObject(f);
1093        assertNotNull(testFolder);
1094        assertTrue(testFolder.isFolder());
1095        
1096        f = new File JavaDoc(f, "f.txt");
1097        assert !f.exists() : f.getAbsolutePath();
1098        assert f.createNewFile() : f.getAbsolutePath();
1099        assert f.exists() : f.getAbsolutePath();
1100
1101        FileObject testFile = fs.findFileObject(f);//!!!!!!
1102
assertNotNull(testFile);
1103        assertTrue(testFile.isData());
1104                        
1105
1106        final List JavaDoc l = new ArrayList JavaDoc ();
1107        FileChangeListener fcl = new FileChangeAdapter () {
1108            public void fileDeleted(FileEvent fe) {
1109                l.add(fe);
1110                fe.getFile().refresh();
1111            }
1112            public void fileChanged(FileEvent fe) {
1113                fail();
1114            }
1115            
1116        };
1117
1118        testFolder.getFileSystem().addFileChangeListener(fcl);
1119        assertEquals(0, l.size());
1120        
1121        f.delete();
1122        testFolder.getFileSystem().refresh(true);
1123       testFolder.getFileSystem().removeFileChangeListener(fcl);
1124        assertEquals(1, l.size());
1125
1126    }
1127    
1128    public void testExternalDelete4_2() throws IOException JavaDoc {
1129        File JavaDoc f = new File JavaDoc(testFile, "testDelete2/testForExternalRefresh3/");
1130        assert !f.exists() : f.getAbsolutePath();
1131        assert f.mkdirs() : f.getAbsolutePath();
1132        assert f.exists() : f.getAbsolutePath();
1133
1134        FileBasedFileSystem fs = FileBasedFileSystem.getInstance(f);
1135        FileObject testFolder = fs.findFileObject(f);
1136        assertNotNull(testFolder);
1137        assertTrue(testFolder.isFolder());
1138        
1139        f = new File JavaDoc(f, "f.txt");
1140        assert !f.exists() : f.getAbsolutePath();
1141        assert f.createNewFile() : f.getAbsolutePath();
1142        assert f.exists() : f.getAbsolutePath();
1143
1144        FileObject testFile = testFolder.getFileObject(f.getName());
1145        assertNotNull(testFile);
1146        assertTrue(testFile.isData());
1147                        
1148
1149        final List JavaDoc l = new ArrayList JavaDoc ();
1150        FileChangeListener fcl = new FileChangeAdapter () {
1151            public void fileDeleted(FileEvent fe) {
1152                l.add(fe);
1153                fe.getFile().refresh();
1154            }
1155            public void fileChanged(FileEvent fe) {
1156                fail();
1157            }
1158            
1159        };
1160
1161        testFolder.getFileSystem().addFileChangeListener(fcl);
1162        assertEquals(0, l.size());
1163        
1164        f.delete();
1165        testFolder.refresh(true);
1166        assertEquals(1, l.size());
1167        testFolder.getFileSystem().removeFileChangeListener(fcl);
1168
1169    }
1170    
1171    
1172    /**
1173     * Test of getInputStream method, of class org.netbeans.modules.masterfs.filebasedfs.fileobjects.FolderObj.
1174     */

1175    public void testGetInputStream() {
1176        File JavaDoc f = testFile;
1177        FileSystem fs = FileBasedFileSystem.getInstance(f);
1178        
1179        FileObject root = fs.getRoot();
1180        assertNotNull(root);
1181        
1182        Enumeration JavaDoc en = root.getFolders(true);
1183        for (int i = 0; i < 10 && en.hasMoreElements(); i++) {
1184            FileObject fo = (FileObject) en.nextElement();
1185            assertTrue(fo.isFolder());
1186            assertFalse(fo.isData());
1187            try {
1188                fo.getInputStream();
1189                fail ();
1190            } catch (FileNotFoundException JavaDoc e) {
1191                
1192            }
1193
1194        }
1195    }
1196
1197    /*public void testRefresh () throws Exception {
1198        File f = testFile;
1199        FileSystem fs = FileBasedFileSystem.getInstance(f);
1200        FileObject testFo = fs.findResource(f.getAbsolutePath().replace('\\', '/'));
1201        assertNotNull(testFo);
1202        assertTrue(testFo.isFolder());
1203        
1204        //testFo.getChildren();
1205        String childName = "testRefresh";
1206        File fooClassF = new File (testFile, childName);
1207        OutputStream os = new FileOutputStream(fooClassF);
1208        os.write(69); // force Mac OS X to update timestamp
1209        os.close();
1210
1211        fs.refresh(true);
1212        final FileObject childFo = testFo.getFileObject(childName);
1213        childFo.lastModified();
1214        assertNotNull(childFo);
1215        Reference ref = new WeakReference (testFo);
1216        testFo = null;
1217        assertGC("", ref) ;
1218        
1219        final List l = new ArrayList ();
1220        fs.addFileChangeListener(new FileChangeAdapter () {
1221            public void fileChanged(FileEvent fe) {
1222                if (fe.getFile().equals(childFo)) {
1223                    l.add(childFo);
1224                }
1225            }
1226        });
1227        Thread.sleep(2000);
1228        os = new FileOutputStream(fooClassF);
1229        os.write(69); // force Mac OS X to update timestamp
1230        os.close();
1231        
1232        fs.refresh(true);
1233        assertTrue(!l.isEmpty());
1234    }*/

1235
1236    //see issue: #43231 and #56285
1237
public void testRefresh43231() throws Exception JavaDoc {
1238        File JavaDoc thisTest = new File JavaDoc(getWorkDir(),getName());
1239        thisTest.createNewFile();
1240        FileObject testf = FileBasedFileSystem.getFileObject(thisTest);
1241        final List JavaDoc l = new ArrayList JavaDoc();
1242        testf.addFileChangeListener(new FileChangeAdapter(){
1243            public void fileChanged(FileEvent fe) {
1244                if (l.isEmpty()) {
1245                    fail();
1246                }
1247                l.clear();
1248            }
1249        });
1250        //first refresh after initialization compares
1251
//lastModified with oldLastModified this way:
1252
//if (lastModified > oldLastModified) the fileChange
1253
thisTest.setLastModified(1000000);
1254        testf.refresh();
1255        assertTrue(l.isEmpty());
1256
1257        //every next refresh compares
1258
//lastModified with oldLastModified this way:
1259
//if (lastModified != oldLastModified) the fileChange
1260
l.add("not empty");
1261        thisTest.setLastModified(10000);
1262        testf.refresh();
1263        assertTrue(l.isEmpty());
1264    }
1265    
1266    public void testRefresh69744() throws Exception JavaDoc {
1267        File JavaDoc thisTest = new File JavaDoc(getWorkDir(),"thisTest");
1268        thisTest.createNewFile();
1269        FileObject testf = FileBasedFileSystem.getFileObject(thisTest);
1270        assertNotNull(testf);
1271        assertGC("",new WeakReference JavaDoc(testf.getParent()));
1272        modifyFileObject(testf, "abc");
1273        FileSystem fs = testf.getFileSystem();
1274        final List JavaDoc l = new ArrayList JavaDoc();
1275        FileChangeListener fcl = new FileChangeAdapter() {
1276            public void fileChanged(FileEvent fe) {
1277                l.add(fe);
1278            }
1279        };
1280        Thread.sleep(1500);
1281        fs.addFileChangeListener(fcl);
1282        try {
1283            modifyFileObject(testf, "def");
1284            assertFalse(l.isEmpty());
1285        } finally {
1286            fs.removeFileChangeListener(fcl);
1287        }
1288    }
1289
1290    private void modifyFileObject(final FileObject testf, String JavaDoc content) throws IOException JavaDoc {
1291        FileLock lock = null;
1292        OutputStream JavaDoc os = null;
1293        try {
1294            lock = testf.lock();
1295            os = testf.getOutputStream(lock);
1296            os.write(content.getBytes());
1297        } finally {
1298            if (os != null) os.close();
1299            if (lock != null) lock.releaseLock();
1300        }
1301    }
1302    
1303    public void testFileTypeChanged() throws Exception JavaDoc {
1304        String JavaDoc newFileName = "test";
1305        File JavaDoc f = new File JavaDoc(testFile, "testFileTypeNotRemembered/");
1306        assert !f.exists() : f.getAbsolutePath();
1307        assert f.mkdirs() : f.getAbsolutePath();
1308        assert f.exists() : f.getAbsolutePath();
1309        
1310        FileBasedFileSystem fs = FileBasedFileSystem.getInstance(testFile);
1311        FileObject parent = fs.findFileObject(testFile);
1312        
1313        assertNotNull(parent);
1314        assertTrue(parent.isFolder());
1315        FileObject fo = parent.getFileObject("testFileTypeNotRemembered");
1316        assertTrue(fo.isFolder());
1317        
1318        fo.delete();
1319        FileObject fo2 = parent.createFolder("testFileTypeNotRemembered");
1320        assertNotNull(fo);
1321        assertTrue(fo != fo2);
1322        
1323        fo2 = fs.findFileObject(f);
1324        assertNotNull(fo);
1325        assertTrue(fo != fo2);
1326    }
1327    
1328    public void testRefresh2 () throws Exception JavaDoc {
1329        String JavaDoc childName = "refreshtest.txt";
1330        FileSystem fs = FileBasedFileSystem.getInstance(testFile);
1331        final File JavaDoc file = new File JavaDoc (testFile, childName);
1332        FileObject parent = fs.findResource(testFile.getAbsolutePath().replace('\\', '/'));
1333        assertNotNull(parent);
1334
1335        file.createNewFile();
1336        parent.getFileObject(childName);
1337        parent.getChildren();
1338        fs.refresh(true);
1339
1340        final ArrayList JavaDoc deleted = new ArrayList JavaDoc ();
1341        final ArrayList JavaDoc created = new ArrayList JavaDoc ();
1342        
1343        FileChangeListener fcl = new FileChangeAdapter () {
1344            public void fileDeleted(FileEvent fe) {
1345                BaseFileObj fo = (BaseFileObj)fe.getFile();
1346                if (file.equals(fo.getFileName().getFile())) {
1347                    String JavaDoc p = fo.toString();
1348                    deleted.add(fo);
1349                }
1350            }
1351
1352            public void fileDataCreated(FileEvent fe) {
1353                BaseFileObj fo = (BaseFileObj)fe.getFile();
1354                if (file.equals(fo.getFileName().getFile())) {
1355                    String JavaDoc p = fo.toString();
1356                    created.add(fo);
1357                }
1358            }
1359            
1360        };
1361        fs.addFileChangeListener(fcl);
1362        int stepsCount = 10;
1363        for (int i = 0; i < stepsCount; i++) {
1364            assertTrue(file.delete());
1365            fs.refresh(true);
1366            
1367            assertTrue(file.createNewFile());
1368            fs.refresh(true);
1369        }
1370        
1371        fs.removeFileChangeListener(fcl);
1372        assertEquals(stepsCount,deleted.size());
1373        assertEquals(stepsCount,created.size());
1374        
1375    }
1376
1377    public void testRefresh3 () throws Exception JavaDoc {
1378        String JavaDoc childName = "refreshtest2.txt";
1379        FileBasedFileSystem fs = FileBasedFileSystem.getInstance(testFile);
1380        final File JavaDoc file = new File JavaDoc (testFile, childName);
1381        FileObject parent = fs.findResource(testFile.getAbsolutePath().replace('\\', '/'));
1382        assertNotNull(parent);
1383
1384
1385        final ArrayList JavaDoc events = new ArrayList JavaDoc ();
1386
1387        final ArrayList JavaDoc deletedIncrement = new ArrayList JavaDoc ();
1388        final ArrayList JavaDoc createdIncrement = new ArrayList JavaDoc ();
1389        
1390        final ArrayList JavaDoc hardRef = new ArrayList JavaDoc ();
1391        final FileChangeListener fcl = new FileChangeAdapter () {
1392            public void fileDeleted(FileEvent fe) {
1393                BaseFileObj fo = (BaseFileObj)fe.getFile();
1394                if (file.equals(fo.getFileName().getFile()))
1395                {
1396                    String JavaDoc p = fo.toString();
1397                    assertEquals(0, events.size());
1398                    assertTrue(!fo.isValid());
1399                    events.add("fo");
1400                    deletedIncrement.add("fo");
1401                    fo.removeFileChangeListener(this);
1402                    fo.getParent().addFileChangeListener(this);
1403                    hardRef.clear();
1404                    hardRef.add(fo.getParent());
1405                    fo.getParent().getChildren ();
1406                }
1407            }
1408
1409
1410            public void fileDataCreated(FileEvent fe) {
1411                BaseFileObj fo = (BaseFileObj)fe.getFile();
1412                if (file.equals(fo.getFileName().getFile()))
1413                {
1414                    String JavaDoc p = fo.toString();
1415                    assertEquals(1,events.size());
1416                    assertTrue(fo.isValid());
1417                    assertTrue(events.remove("fo"));
1418                    createdIncrement.add("fo");
1419                    fo.getParent().removeFileChangeListener(this);
1420                    fo.addFileChangeListener(this);
1421                    hardRef.clear();
1422                    hardRef.add(fo);
1423                    
1424                }
1425            }
1426
1427            
1428        };
1429        fs.refresh(true);
1430        file.createNewFile();
1431        hardRef.add(parent.getFileObject(childName));
1432        parent.getFileObject(childName).addFileChangeListener(fcl);
1433        parent = null;
1434        int stepsCount = 10;
1435        Reference JavaDoc ref2 = new WeakReference JavaDoc (fs.findFileObject(file.getParentFile()));
1436        assertGC("", ref2);
1437        
1438        for (int i = 0; i < stepsCount; i++) {
1439            assertTrue(file.delete());
1440            fs.refresh(true);
1441            Reference JavaDoc ref = new WeakReference JavaDoc (fs.findFileObject(file));
1442            assertGC("", ref);
1443            
1444            
1445            assertTrue(file.createNewFile());
1446            fs.refresh(true);
1447                        
1448            ref = new WeakReference JavaDoc (fs.findFileObject(file.getParentFile()));
1449            assertGC(file.getParentFile().getAbsolutePath(), ref);
1450        }
1451        
1452        fs.removeFileChangeListener(fcl);
1453        assertEquals(0,events.size());
1454        assertEquals(stepsCount,createdIncrement.size());
1455        assertEquals(stepsCount,deletedIncrement.size());
1456        
1457    }
1458    
1459    public void testRefreshDoesNotMultiplyFileObjects_89059 () throws Exception JavaDoc {
1460        FileObject fo = FileBasedFileSystem.getFileObject(testFile);
1461        fo.getChildren();
1462        FileSystem fs = fo.getFileSystem();
1463        FileChangeListener fcl = new FileChangeAdapter();
1464        OutputStream JavaDoc os = null;
1465        fs.addFileChangeListener(fcl);
1466        fo.addFileChangeListener(fcl);
1467        try {
1468            //no change
1469
int foInstancesInCache = Statistics.fileObjects();
1470            fs.refresh(false);
1471            assertTrue(foInstancesInCache >= Statistics.fileObjects());
1472
1473            //internal change
1474
File JavaDoc ff = new File JavaDoc(testFile,"a/b/c/d/aa.txt");//NOI18N
1475
FileUtil.createData(ff);
1476            foInstancesInCache = Statistics.fileObjects();
1477            fs.refresh(false);
1478            assertTrue(foInstancesInCache >= Statistics.fileObjects());
1479
1480            //external change
1481
FileObject ffObject = FileBasedFileSystem.getFileObject(ff);
1482            foInstancesInCache = Statistics.fileObjects();
1483            os = new java.io.FileOutputStream JavaDoc(ff);
1484            os.write("dsdopsdsd".getBytes());//NOI18N
1485
os.close();
1486            fs.refresh(false);
1487            assertTrue(foInstancesInCache >= Statistics.fileObjects());
1488
1489            assertTrue(new File JavaDoc(testFile,"nfile").createNewFile());//NOI18N
1490
fs.refresh(false);
1491            fo.refresh(false);
1492            assertTrue(foInstancesInCache+1 >= Statistics.fileObjects());
1493
1494            foInstancesInCache = Statistics.fileObjects();
1495            assertTrue(new File JavaDoc(testFile,"aa/bb/cc").mkdirs());//NOI18N
1496
fs.refresh(false);
1497            fo.refresh(false);
1498            assertTrue(foInstancesInCache+3 >= Statistics.fileObjects());
1499        } finally {
1500            if (os != null) {
1501                os.close();
1502            }
1503            fs.removeFileChangeListener(fcl);
1504            fo.removeFileChangeListener(fcl);
1505        }
1506    }
1507    
1508    /**
1509     * Test of getOutputStream method, of class org.netbeans.modules.masterfs.filebasedfs.fileobjects.FolderObj.
1510     */

1511    public void testGetOutputStream() {
1512        File JavaDoc f = testFile;
1513        FileSystem fs = FileBasedFileSystem.getInstance(f);
1514        
1515        FileObject root = fs.getRoot();
1516        assertNotNull(root);
1517        
1518        Enumeration JavaDoc en = root.getFolders(true);
1519        for (int i = 0; i < 10 && en.hasMoreElements(); i++) {
1520            FileObject fo = (FileObject) en.nextElement();
1521            assertTrue(fo.isFolder());
1522            assertFalse(fo.isData());
1523            try {
1524                fo.getOutputStream(fo.lock());
1525                fail ();
1526            } catch (IOException JavaDoc e) {
1527                
1528            } finally {
1529                
1530            }
1531
1532        }
1533    }
1534    
1535    public void testReadWrite ( ) throws Exception JavaDoc{
1536        String JavaDoc content = "content of data file";
1537        File JavaDoc f = testFile;
1538        FileSystem fs = FileBasedFileSystem.getInstance(f);
1539        
1540        BaseFileObj fo = (BaseFileObj)fs.findResource(testFile.getAbsolutePath().replace('\\','/'));
1541        assertNotNull(fo);
1542        File JavaDoc dFile = new File JavaDoc (fo.getFileName().getFile(),"newreadwrite.txt");
1543        BaseFileObj data = (BaseFileObj)fo.createData(dFile.getName());
1544                
1545        FileLock lock = data.lock();
1546        try {
1547            OutputStream JavaDoc os = data.getOutputStream(lock);
1548            os.write(content.getBytes());
1549            os.close();
1550        } finally {
1551            lock.releaseLock();
1552        }
1553        
1554        InputStream JavaDoc is = data.getInputStream();
1555        byte[] b = new byte [content.length()];
1556        assertEquals(content.length(), is.read(b));
1557        assertEquals(new String JavaDoc (b),new String JavaDoc (b), content);
1558    }
1559
1560    public void testIsLightWeightLockRequiredRequired() throws Exception JavaDoc {
1561        File JavaDoc f = getWorkDir();
1562        FileSystem fs = FileBasedFileSystem.getInstance(f);
1563        assertNotNull(fs);
1564        FolderObj fo = (FolderObj)fs.findResource(f.getAbsolutePath());
1565        assertNotNull(fo);
1566        
1567        assertFalse(fo.isLightWeightLockRequired());
1568        FileLock fakeLock = (FileLock)fo.getAttribute(FolderObj.LIGHTWEIGHT_LOCK_SET);
1569        assertNotNull(fakeLock);
1570        assertTrue(fo.isLightWeightLockRequired());
1571        fakeLock.releaseLock();
1572        assertFalse(fo.isLightWeightLockRequired());
1573        fakeLock = (FileLock)fo.getAttribute(FolderObj.LIGHTWEIGHT_LOCK_SET);
1574        assertNotNull(fakeLock); assertTrue(fo.isLightWeightLockRequired());
1575        fakeLock.releaseLock();
1576        assertFalse(fo.isLightWeightLockRequired());
1577    }
1578    
1579    public void testLightWeigtLock() throws Exception JavaDoc {
1580        File JavaDoc f = new File JavaDoc(getWorkDir(), "testFile.txt");
1581        if (!f.exists()) {
1582            assertTrue(f.createNewFile());
1583        }
1584        File JavaDoc lckFile = WriteLockUtils.getAssociatedLockFile(f);
1585        
1586        FileSystem fs = FileBasedFileSystem.getInstance(f);
1587        assertNotNull(fs);
1588        FileObject foChild = fs.findResource(f.getAbsolutePath());
1589        assertNotNull(foChild);
1590        
1591        FileObject folder = foChild.getParent();
1592        assertNotNull(folder);
1593        
1594        FileLock lock = foChild.lock();
1595        assertTrue(lckFile.exists());
1596        lock.releaseLock();
1597
1598        FileLock fakeLock = (FileLock)folder.getAttribute(FolderObj.LIGHTWEIGHT_LOCK_SET);
1599        assertNotNull(fakeLock);
1600        lock = foChild.lock();
1601        assertFalse(lckFile.exists());
1602        lock.releaseLock();
1603
1604        fakeLock.releaseLock();
1605        lock = foChild.lock();
1606        assertTrue(lckFile.exists());
1607        lock.releaseLock();
1608    }
1609    
1610    
1611    public File JavaDoc getWorkDir() throws IOException JavaDoc {
1612        return super.getWorkDir();
1613    }
1614}
1615
Popular Tags