View Javadoc

1   /*
2    * $Id: FileUtilsTestCase.java 19191 2010-08-25 21:05:23Z tcarlson $
3    * --------------------------------------------------------------------------------------
4    * Copyright (c) MuleSoft, Inc.  All rights reserved.  http://www.mulesoft.com
5    *
6    * The software in this package is published under the terms of the CPAL v1.0
7    * license, a copy of which has been included with this distribution in the
8    * LICENSE.txt file.
9    */
10  
11  package org.mule.util;
12  
13  import org.mule.tck.AbstractMuleTestCase;
14  
15  import java.io.File;
16  import java.io.IOException;
17  
18  import junit.framework.TestCase;
19  
20  public class FileUtilsTestCase extends AbstractMuleTestCase
21  {
22      private final String TEST_FILE = "testFile.txt";
23      private final String TEST_DIRECTORY = "target" + File.separator + "testDirectory";
24      private final File toDir = FileUtils.newFile(TEST_DIRECTORY);
25  
26      protected void doSetUp() throws Exception
27      {
28          super.doSetUp();
29          if (!toDir.exists())
30          {
31              toDir.mkdirs();
32          }
33      }
34  
35      protected void doTearDown() throws Exception
36      {
37          super.doTearDown();
38          toDir.delete();
39      }
40  
41      public void testFileTools() throws Exception
42      {
43          File file = null;
44          try
45          {
46              file = FileUtils.stringToFile(TEST_FILE, "this is a test file");
47              assertNotNull(file);
48              assertTrue(file.exists());
49  
50              file = FileUtils.stringToFile(TEST_FILE, " and this is appended content", true);
51  
52              String content = FileUtils.readFileToString(FileUtils.newFile(TEST_FILE), null);
53  
54              assertNotNull(content);
55              assertTrue(content.indexOf("this is a test file") > -1);
56              assertTrue(content.indexOf(" and this is appended content") > -1);
57  
58              file = FileUtils.newFile(TEST_FILE);
59              assertNotNull(file);
60              assertTrue(file.exists());
61  
62              file = FileUtils.createFile(TEST_FILE);
63              assertNotNull(file);
64              assertTrue(file.exists());
65  
66              file = FileUtils.createFile(TEST_FILE + "2");
67              assertNotNull(file);
68              assertTrue(file.exists());
69              assertTrue(file.canRead());
70              file.delete();
71  
72              file = FileUtils.newFile(TEST_FILE);
73              file.delete();
74  
75              File dir = FileUtils.openDirectory("src");
76              assertNotNull(dir);
77              assertTrue(dir.exists());
78              assertTrue(dir.canRead());
79              assertTrue(dir.isDirectory());
80  
81              dir = FileUtils.openDirectory("doesNotExist");
82              assertNotNull(dir);
83              assertTrue(dir.exists());
84              assertTrue(dir.canRead());
85              assertTrue(dir.isDirectory());
86              dir.delete();
87  
88          }
89          finally
90          {
91              if (file != null)
92              {
93                  file.delete();
94              }
95          }
96      }
97  
98      public void testFileNameTools() throws Exception
99      {
100         String filename = "Blah<Blah>.txt";
101         String result = FileUtils.prepareWinFilename(filename);
102         assertEquals("Blah(Blah).txt", result);
103 
104         filename = "Bla]h<Blah:a;b|c?d=e_f*g>.txt";
105         result = FileUtils.prepareWinFilename(filename);
106         assertEquals("Bla-h(Blah-a-b-c-d=e_f-g).txt", result);
107 
108         filename = "B\"la-h<Blah:a;b|c?d=e_f*g>.txt";
109         result = FileUtils.prepareWinFilename(filename);
110         assertEquals("B-la-h(Blah-a-b-c-d=e_f-g).txt", result);
111     }
112 
113     public void testDirectoryTools() throws Exception
114     {
115         File dir = FileUtils.openDirectory("src");
116         assertNotNull(dir);
117         assertTrue(dir.exists());
118         assertTrue(dir.canRead());
119         assertTrue(dir.isDirectory());
120 
121         dir = FileUtils.openDirectory("doesNotExist");
122         assertNotNull(dir);
123         assertTrue(dir.exists());
124         assertTrue(dir.canRead());
125         assertTrue(dir.isDirectory());
126         FileUtils.deleteTree(dir);
127     }
128 
129     public void testExtractResource() throws Exception
130     {
131         String testDir = TEST_DIRECTORY + File.separator + "Test-1";
132         File outputDir = FileUtils.newFile(testDir);
133         if (!outputDir.exists())
134         {
135             assertTrue("Failed to create output dirs.", outputDir.mkdirs());
136         }
137         String res = "META-INF/MANIFEST.MF";
138         FileUtils.extractResources(res, TestCase.class, outputDir, true);
139         File result = FileUtils.newFile(testDir, res);
140         assertNotNull(result);
141         assertTrue(result.exists());
142         assertTrue(result.canRead());
143         assertTrue(result.isFile());
144         assertTrue(result.length() > 0);
145         FileUtils.deleteTree(outputDir);
146     }
147 
148     public void testExtractResources() throws Exception
149     {
150         String testDir = TEST_DIRECTORY + File.separator + "Test-2";
151         File outputDir = FileUtils.newFile(testDir);
152         if (!outputDir.exists())
153         {
154             outputDir.mkdirs();
155         }
156         String res = "META-INF/";
157         FileUtils.extractResources(res, TestCase.class, outputDir, true);
158         File result = FileUtils.newFile(testDir, res);
159         assertNotNull(result);
160         assertTrue(result.exists());
161         assertTrue(result.canRead());
162         assertTrue(result.isDirectory());
163         FileUtils.deleteTree(outputDir);
164     }
165 
166     public void testExtractFileResource() throws Exception
167     {
168         String testDir = TEST_DIRECTORY + File.separator + "Test-3";
169         File outputDir = FileUtils.newFile(testDir);
170         if (!outputDir.exists())
171         {
172             outputDir.mkdirs();
173         }
174         String res = "org/mule/util/FileUtils.class";
175         FileUtils.extractResources(res, FileUtils.class, outputDir, true);
176         File result = FileUtils.newFile(testDir, res);
177         assertNotNull(result);
178         assertTrue(result.exists());
179         assertTrue(result.canRead());
180         assertTrue(result.isFile());
181         assertTrue(result.length() > 0);
182         FileUtils.deleteTree(outputDir);
183     }
184 
185     public void testExtractFileResources() throws Exception
186     {
187         String testDir = TEST_DIRECTORY + File.separator + "Test-4";
188         File outputDir = FileUtils.newFile(testDir);
189         if (!outputDir.exists())
190         {
191             outputDir.mkdirs();
192         }
193         String res = "org/mule/util/";
194         FileUtils.extractResources(res, FileUtils.class, outputDir, true);
195         File result = FileUtils.newFile(testDir, res);
196         assertNotNull(result);
197         assertTrue(result.exists());
198         assertTrue(result.canRead());
199         assertTrue(result.isDirectory());
200         FileUtils.deleteTree(outputDir);
201     }
202 
203     public void testExtractResourceWithoutKeepingDirStructure() throws Exception
204     {
205         String testDir = TEST_DIRECTORY + File.separator + "Test-5";
206         File outputDir = FileUtils.newFile(testDir);
207         if (!outputDir.exists())
208         {
209             outputDir.mkdirs();
210         }
211         String fileName = "MANIFEST.MF";
212         String res = "META-INF/" + fileName;
213         FileUtils.extractResources(res, TestCase.class, outputDir, false);
214         File result = FileUtils.newFile(testDir, fileName);
215         assertNotNull(result);
216         assertTrue(result.exists());
217         assertTrue(result.canRead());
218         assertTrue(result.isFile());
219         assertTrue(result.length() > 0);
220         FileUtils.deleteTree(outputDir);
221     }
222 
223     public void testExtractResourcesWithoutKeepingDirStructure() throws Exception
224     {
225         String testDir = TEST_DIRECTORY + File.separator + "Test-6";
226         File outputDir = FileUtils.newFile(testDir);
227         if (!outputDir.exists())
228         {
229             outputDir.mkdirs();
230         }
231         String fileName = "util/FileUtilsTestCase.class";
232         String res = "org/mule/";
233         FileUtils.extractResources(res, FileUtilsTestCase.class, outputDir, false);
234         File result = FileUtils.newFile(testDir, fileName);
235         assertNotNull(result);
236         assertTrue(result.exists());
237         assertTrue(result.canRead());
238         assertTrue(result.isFile());
239         assertTrue(result.length() > 0);
240         FileUtils.deleteTree(outputDir);
241     }
242 
243     public void testExtractFileResourceWithoutKeepingDirStructure() throws Exception
244     {
245         String testDir = TEST_DIRECTORY + File.separator + "Test-7";
246         File outputDir = FileUtils.newFile(testDir);
247         if (!outputDir.exists())
248         {
249             outputDir.mkdirs();
250         }
251         String fileName = "FileUtils.class";
252         String res = "org/mule/util/" + fileName;
253         FileUtils.extractResources(res, FileUtils.class, outputDir, false);
254         File result = FileUtils.newFile(testDir, fileName);
255         assertNotNull(result);
256         assertTrue(result.exists());
257         assertTrue(result.canRead());
258         assertTrue(result.isFile());
259         assertTrue(result.length() > 0);
260         FileUtils.deleteTree(outputDir);
261     }
262 
263     public void testExtractFileResourcesWithoutKeepingDirStructure() throws Exception
264     {
265         String testDir = TEST_DIRECTORY + File.separator + "Test-8";
266         File outputDir = FileUtils.newFile(testDir);
267         if (!outputDir.exists())
268         {
269             outputDir.mkdirs();
270         }
271         String fileName = "util/FileUtilsTestCase.class";
272         String res = "org/mule/";
273         FileUtils.extractResources(res, FileUtilsTestCase.class, outputDir, false);
274         File result = FileUtils.newFile(testDir, fileName);
275         assertNotNull(result);
276         assertTrue(result.exists());
277         assertTrue(result.canRead());
278         assertTrue(result.isFile());
279         assertTrue(result.length() > 0);
280         FileUtils.deleteTree(outputDir);
281     }
282 
283     public void testDeleteTreeWithIgnoredDirectories() throws Exception
284     {
285         final String testDir = TEST_DIRECTORY + File.separator + "Test-deleting";
286         File outputDir = FileUtils.newFile(testDir);
287         if (!outputDir.exists())
288         {
289             outputDir.mkdirs();
290         }
291 
292         File toBeDeleted1 = FileUtils.newFile(outputDir, "toBeDeleted1/");
293         toBeDeleted1.mkdirs();
294         File toBeDeleted2 = FileUtils.newFile(outputDir, "toBeDeleted2/");
295         toBeDeleted2.mkdirs();
296 
297         File keepMeIntact = FileUtils.newFile(outputDir, "keepMeIntact/");
298         keepMeIntact.mkdirs();
299 
300         FileUtils.deleteTree(outputDir, new String[] {"keepMeIntact"});
301 
302         assertTrue("Shouldn't have been deleted.", keepMeIntact.exists());
303 
304         FileUtils.deleteTree(outputDir);
305     }
306     
307     public void testRenameFile()
308     {
309         try
310         {
311             File sourceFile = createTestFile("source");
312             File destFile = createTestFile("dest");
313     
314             assertTrue(destFile.delete());
315             assertTrue(FileUtils.renameFile(sourceFile, destFile));
316             assertTrue(destFile.exists());
317             assertTrue(destFile.delete());
318         }
319         catch (Exception e)
320         {
321             fail(e.getMessage());
322         }
323     }
324 
325     public void testRenameFileAcrossFolders()
326     {
327         try
328         {
329             File dir = createTestDir("test");
330             File sourceFile = createTestFile("source");
331             File destFile = new File(dir, "dest");
332     
333             assertTrue(FileUtils.renameFile(sourceFile, destFile));
334             assertTrue(destFile.exists());
335             assertTrue(destFile.delete());
336             assertTrue(dir.delete());
337         }
338         catch (Exception e)
339         {
340             fail(e.getMessage());
341         }
342     }
343 
344     private File createTestFile(String filePath) throws IOException
345     {
346         return File.createTempFile(filePath, ".junit");
347     }
348     
349     private File createTestDir(String dirPath) throws IOException
350     {
351         File file = createTestFile(dirPath);
352         file.delete();
353         file.mkdir();
354         return file;
355     }
356 }