KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > netbeans > modules > masterfs > filebasedfs > children > ChildrenSupportTest


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.children;
21
22 import org.netbeans.junit.NbTestCase;
23 import org.netbeans.modules.masterfs.filebasedfs.naming.FileNaming;
24 import org.netbeans.modules.masterfs.filebasedfs.naming.NamingFactory;
25
26 import java.io.File JavaDoc;
27 import java.util.*;
28 import org.netbeans.modules.masterfs.filebasedfs.FileBasedFileSystem;
29 import org.netbeans.modules.masterfs.filebasedfs.fileobjects.FolderObj;
30
31 /**
32  *
33  * @author Radek Matous
34  */

35 public class ChildrenSupportTest extends NbTestCase {
36     ChildrenSupport folderItem;
37     File JavaDoc testFile;
38
39     /*Just for testRefresh*/
40     private File JavaDoc fbase;
41     private File JavaDoc removed1;
42     private File JavaDoc removed2;
43     private File JavaDoc added1;
44     private File JavaDoc added2;
45     private FileNaming folderName;
46
47     public ChildrenSupportTest(String JavaDoc testName) {
48         super(testName);
49     }
50
51     protected void setUp() throws java.lang.Exception JavaDoc {
52         super.setUp();
53         clearWorkDir();
54         testFile = getWorkDir().getParentFile();
55         folderName = NamingFactory.fromFile(testFile);
56         folderItem = new ChildrenSupport ();
57         
58         if (getName().startsWith("testRefresh")) {
59             fbase = new File JavaDoc (testFile, "testrefresh");
60             removed1 = new File JavaDoc (fbase, "removed1/");
61             removed2 = new File JavaDoc (fbase, "removed2/");
62             added1 = new File JavaDoc (fbase, "added1/");
63             added2 = new File JavaDoc (fbase, "added2/");
64             
65             assertTrue (testFile.exists());
66             assertTrue(testFile.isDirectory());
67             if (!fbase.exists()) assertTrue (fbase.getAbsoluteFile().mkdirs());
68             if (!removed1.exists())assertTrue (removed1.mkdir());
69             if (!removed2.exists())assertTrue (removed2.mkdir());
70             if (added1.exists()) assertTrue (added1.delete());
71             if (added2.exists()) assertTrue (added2.delete());
72         }
73     }
74
75     public void testGetChild() throws Exception JavaDoc {
76         File JavaDoc wDir = getWorkDir();
77         File JavaDoc file = new File JavaDoc(wDir, getName());
78         FolderObj fo = (FolderObj)FileBasedFileSystem.getFileObject(wDir);
79         assertNotNull(fo);
80         assertEquals(fo.getFileName(),NamingFactory.fromFile(wDir));
81         ChildrenCache chCache = fo.getChildrenCache();
82         assertNotNull(chCache);
83         ChildrenSupport childrenSupport = ((FolderObj.FolderChildrenCache)chCache).ch;
84         
85         assertFalse(file.exists());
86         assertTrue(childrenSupport.isStatus(ChildrenSupport.NO_CHILDREN_CACHED));
87         assertNull(chCache.getChild(file.getName(), false));
88         assertTrue(childrenSupport.isStatus(ChildrenSupport.SOME_CHILDREN_CACHED));
89         
90         assertTrue(file.createNewFile());
91         assertNull(chCache.getChild(file.getName(), false));
92         assertNotNull(chCache.getChild(file.getName(),true));
93         assertTrue(childrenSupport.isStatus(ChildrenSupport.SOME_CHILDREN_CACHED));
94         
95         assertTrue(file.delete());
96         assertNotNull(chCache.getChild(file.getName(),false));
97         assertNull(chCache.getChild(file.getName(),true));
98         assertTrue(childrenSupport.isStatus(ChildrenSupport.SOME_CHILDREN_CACHED));
99         
100         assertTrue(file.createNewFile());
101         assertNull(chCache.getChild(file.getName(),false));
102         assertNotNull(chCache.getChild(file.getName(),true));
103         assertTrue(childrenSupport.isStatus(ChildrenSupport.SOME_CHILDREN_CACHED));
104     }
105     
106     public void testRefreshChild() throws Exception JavaDoc {
107         File JavaDoc wDir = getWorkDir();
108         File JavaDoc file = new File JavaDoc(wDir, getName());
109         FolderObj fo = (FolderObj)FileBasedFileSystem.getFileObject(wDir);
110         assertNotNull(fo);
111         assertEquals(fo.getFileName(),NamingFactory.fromFile(wDir));
112         ChildrenCache chCache = fo.getChildrenCache();
113         assertNotNull(chCache);
114         ChildrenSupport childrenSupport = ((FolderObj.FolderChildrenCache)chCache).ch;
115         
116         assertFalse(file.exists());
117         assertTrue(childrenSupport.isStatus(ChildrenSupport.NO_CHILDREN_CACHED));
118         assertNull(chCache.getChild(file.getName(),false));
119         assertTrue(childrenSupport.isStatus(ChildrenSupport.SOME_CHILDREN_CACHED));
120         
121         assertTrue(file.createNewFile());
122         assertNull(chCache.getChild(file.getName(),false));
123         Map m = chCache.refresh();
124         assertEquals(1, m.keySet().size());
125         assertEquals(m.keySet().toArray()[0],NamingFactory.fromFile(file));
126         assertEquals(m.values().toArray()[0],ChildrenCache.ADDED_CHILD);
127         assertNotNull(chCache.getChild(file.getName(),false));
128         assertTrue(childrenSupport.isStatus(ChildrenSupport.SOME_CHILDREN_CACHED));
129         
130         assertTrue(file.delete());
131         assertNotNull(chCache.getChild(file.getName(),false));
132         m = chCache.refresh();
133         assertEquals(1, m.keySet().size());
134         assertEquals(m.keySet().toArray()[0],NamingFactory.fromFile(file));
135         assertEquals(m.values().toArray()[0],ChildrenCache.REMOVED_CHILD);
136         assertNull(chCache.getChild(file.getName(),false));
137         assertTrue(childrenSupport.isStatus(ChildrenSupport.SOME_CHILDREN_CACHED));
138         
139         assertTrue(file.createNewFile());
140         assertNull(chCache.getChild(file.getName(),false));
141         m = chCache.refresh();
142         assertEquals(1, m.keySet().size());
143         assertEquals(m.keySet().toArray()[0],NamingFactory.fromFile(file));
144         assertEquals(m.values().toArray()[0],ChildrenCache.ADDED_CHILD);
145         assertNotNull(chCache.getChild(file.getName(),false));
146         assertTrue(childrenSupport.isStatus(ChildrenSupport.SOME_CHILDREN_CACHED));
147     }
148
149     public void testGetChildren() throws Exception JavaDoc {
150         File JavaDoc wDir = getWorkDir();
151         File JavaDoc file = new File JavaDoc(wDir, getName());
152         FolderObj fo = (FolderObj)FileBasedFileSystem.getFileObject(wDir);
153         assertNotNull(fo);
154         assertEquals(fo.getFileName(),NamingFactory.fromFile(wDir));
155         ChildrenCache chCache = fo.getChildrenCache();
156         assertNotNull(chCache);
157         ChildrenSupport childrenSupport = ((FolderObj.FolderChildrenCache)chCache).ch;
158         
159         assertFalse(file.exists());
160         assertTrue(childrenSupport.isStatus(ChildrenSupport.NO_CHILDREN_CACHED));
161         assertTrue(chCache.getChildren(false).isEmpty());
162         assertTrue(childrenSupport.isStatus(ChildrenSupport.ALL_CHILDREN_CACHED));
163         
164         assertTrue(file.createNewFile());
165         assertNull(chCache.getChild(file.getName(),false));
166         assertTrue(chCache.getChildren(false).isEmpty());
167         assertFalse(chCache.getChildren(true).isEmpty());
168         assertFalse(chCache.getChildren(false).isEmpty());
169         assertNotNull(chCache.getChild(file.getName(),false));
170         assertEquals(chCache.getChild(file.getName(),false),
171                 chCache.getChildren(false).toArray()[0]);
172         assertTrue(childrenSupport.isStatus(ChildrenSupport.ALL_CHILDREN_CACHED));
173         
174         assertTrue(file.delete());
175         assertNotNull(chCache.getChild(file.getName(),false));
176         assertFalse(chCache.getChildren(false).isEmpty());
177         assertTrue(chCache.getChildren(true).isEmpty());
178         assertTrue(chCache.getChildren(false).isEmpty());
179         assertNull(chCache.getChild(file.getName(), false));
180         assertTrue(chCache.getChildren(false).isEmpty());
181         assertTrue(childrenSupport.isStatus(ChildrenSupport.ALL_CHILDREN_CACHED));
182         
183         assertTrue(file.createNewFile());
184         assertNull(chCache.getChild(file.getName(), false));
185         assertTrue(chCache.getChildren(false).isEmpty());
186         assertFalse(chCache.getChildren(true).isEmpty());
187         assertFalse(chCache.getChildren(false).isEmpty());
188         assertNotNull(chCache.getChild(file.getName(), false));
189         assertEquals(chCache.getChild(file.getName(), false),
190                 chCache.getChildren(false).toArray()[0]);
191         assertTrue(childrenSupport.isStatus(ChildrenSupport.ALL_CHILDREN_CACHED));
192     }
193     
194     public void testRefreshChildren() throws Exception JavaDoc {
195         File JavaDoc wDir = getWorkDir();
196         File JavaDoc file = new File JavaDoc(wDir, getName());
197         FolderObj fo = (FolderObj)FileBasedFileSystem.getFileObject(wDir);
198         assertNotNull(fo);
199         assertEquals(fo.getFileName(),NamingFactory.fromFile(wDir));
200         ChildrenCache chCache = fo.getChildrenCache();
201         assertNotNull(chCache);
202         ChildrenSupport childrenSupport = ((FolderObj.FolderChildrenCache)chCache).ch;
203         
204         assertFalse(file.exists());
205         assertTrue(childrenSupport.isStatus(ChildrenSupport.NO_CHILDREN_CACHED));
206         assertTrue(chCache.getChildren(false).isEmpty());
207         assertTrue(childrenSupport.isStatus(ChildrenSupport.ALL_CHILDREN_CACHED));
208         
209         assertTrue(file.createNewFile());
210         assertNull(chCache.getChild(file.getName(),false));
211         assertTrue(chCache.getChildren(false).isEmpty());
212         Map m = chCache.refresh();
213         assertEquals(1, m.keySet().size());
214         assertEquals(m.keySet().toArray()[0],NamingFactory.fromFile(file));
215         assertEquals(m.values().toArray()[0],ChildrenCache.ADDED_CHILD);
216         assertFalse(chCache.getChildren(false).isEmpty());
217         assertNotNull(chCache.getChild(file.getName(),false));
218         assertEquals(chCache.getChild(file.getName(),false),
219                 chCache.getChildren(false).toArray()[0]);
220         assertTrue(childrenSupport.isStatus(ChildrenSupport.ALL_CHILDREN_CACHED));
221         
222         assertTrue(file.delete());
223         assertNotNull(chCache.getChild(file.getName(),false));
224         assertFalse(chCache.getChildren(false).isEmpty());
225         m = chCache.refresh();
226         assertEquals(1, m.keySet().size());
227         assertEquals(m.keySet().toArray()[0],NamingFactory.fromFile(file));
228         assertEquals(m.values().toArray()[0],ChildrenCache.REMOVED_CHILD);
229         assertTrue(chCache.getChildren(false).isEmpty());
230         assertNull(chCache.getChild(file.getName(),false));
231         assertTrue(chCache.getChildren(false).isEmpty());
232         assertTrue(childrenSupport.isStatus(ChildrenSupport.ALL_CHILDREN_CACHED));
233         
234         assertTrue(file.createNewFile());
235         assertNull(chCache.getChild(file.getName(),false));
236         assertTrue(chCache.getChildren(false).isEmpty());
237         m = childrenSupport.refresh(NamingFactory.fromFile(wDir));
238         assertEquals(1, m.keySet().size());
239         assertEquals(m.keySet().toArray()[0],NamingFactory.fromFile(file));
240         assertEquals(m.values().toArray()[0],ChildrenCache.ADDED_CHILD);
241         assertFalse(chCache.getChildren(false).isEmpty());
242         assertNotNull(chCache.getChild(file.getName(),false));
243         assertEquals(chCache.getChild(file.getName(),false),
244                 chCache.getChildren(false).toArray()[0]);
245         assertTrue(childrenSupport.isStatus(ChildrenSupport.ALL_CHILDREN_CACHED));
246     }
247     
248     
249     
250     /**
251      * Test of getFolderName method, of class org.netbeans.modules.masterfs.children.FolderPathItems.
252      */

253     public void testGetFolderItem() throws Exception JavaDoc {
254         assertEquals(testFile, folderName.getFile());
255     }
256
257
258     /**
259      * Test of getChildren method, of class org.netbeans.modules.masterfs.children.FolderPathItems.
260      */

261     public void testGetChildrenPathItems() throws Exception JavaDoc{
262         Set childItems = folderItem.getChildren(folderName, true);
263         List lst = Arrays.asList(testFile.listFiles());
264         Iterator it = childItems.iterator();
265         while (it.hasNext()) {
266             FileNaming pi = (FileNaming)it.next();
267             File JavaDoc f = pi.getFile();
268             assertTrue (lst.contains(f));
269         }
270     }
271
272     /**
273      * Test of getFileName method, of class org.netbeans.modules.masterfs.children.FolderPathItems.
274      */

275     public void testGetChildItem() throws Exception JavaDoc{
276         folderItem.getChildren(folderName, true);
277         List lst = Arrays.asList(testFile.listFiles());
278         Iterator it = lst.iterator();
279         while (it.hasNext()) {
280             File JavaDoc f = (File JavaDoc)it.next();
281             FileNaming item = folderItem.getChild(f.getName(), folderName,false);
282             assertNotNull(item);
283             assertTrue (item.getFile().equals(f));
284         }
285     }
286
287     public void testRefresh () throws Exception JavaDoc {
288         FileNaming fpiName = NamingFactory.fromFile(fbase);
289         ChildrenSupport fpi = new ChildrenSupport();
290         fpi.getChildren(fpiName, true);
291         assertTrue (removed1.delete());
292         assertTrue (removed2.delete());
293         assertTrue (added1.mkdirs());
294         assertTrue (added2.mkdirs());
295
296         List added = Arrays.asList(new String JavaDoc[] {"added1", "added2"});
297         List removed = Arrays.asList(new String JavaDoc[] {"removed1", "removed2"});
298         
299         Map changes = fpi.refresh(fpiName);
300         Iterator it = changes.entrySet().iterator();
301         while (it.hasNext()) {
302             Map.Entry entry = (Map.Entry) it.next();
303             FileNaming pItem = (FileNaming)entry.getKey();
304             Integer JavaDoc type = (Integer JavaDoc)entry.getValue();
305             if (type == ChildrenCache.ADDED_CHILD) {
306                 assertTrue (added.contains(pItem.getName()));
307             }
308             if (type == ChildrenCache.REMOVED_CHILD) {
309                 assertTrue (removed.contains(pItem.getName()));
310             }
311         }
312         assertTrue (changes.size() == 4);
313     }
314     
315     public void testRefresh2 () throws Exception JavaDoc {
316         FileNaming fpiName = NamingFactory.fromFile(fbase);
317         ChildrenSupport fpi = new ChildrenSupport();
318         fpi.getChild("removed1", fpiName, false);
319         assertTrue (removed1.delete());
320         assertTrue (removed2.delete());
321         assertTrue (added1.mkdirs());
322         assertTrue (added2.mkdirs());
323         
324         Map changes = fpi.refresh(fpiName);
325         Iterator it = changes.entrySet().iterator();
326         while (it.hasNext()) {
327             Map.Entry entry = (Map.Entry) it.next();
328             FileNaming pItem = (FileNaming)entry.getKey();
329             Integer JavaDoc type = (Integer JavaDoc)entry.getValue();
330             assertEquals("removed1", pItem.getName());
331         }
332         assertTrue (changes.size() == 1);
333     }
334     
335 }
336
Popular Tags