1 33 34 package edu.rice.cs.util; 35 36 import junit.framework.*; 37 import java.io.*; 38 39 import java.util.Arrays ; 40 import java.util.ArrayList ; 41 import java.util.LinkedList ; 42 import java.util.List ; 43 import java.util.Set ; 44 import java.util.TreeSet ; 45 46 import edu.rice.cs.drjava.config.FileOption; 47 import edu.rice.cs.drjava.DrJavaTestCase; 48 import edu.rice.cs.util.newjvm.ExecJVM; 49 import edu.rice.cs.util.FileOps; 50 51 54 @SuppressWarnings ("deprecation") public class FileOpsTest extends DrJavaTestCase { 55 private static final Log _log = new Log("FileOpsTest.txt", false); 56 public static final String TEXT = "hi, dude."; 57 public static final String PREFIX = "prefix"; 58 public static final String SUFFIX = ".suffix"; 59 60 public void testCreateTempDirectory() throws IOException { 61 File dir = FileOps.createTempDirectory(PREFIX); 62 try { 63 assertTrue("createTempDirectory result is a directory", dir.isDirectory()); 64 assertTrue("temp directory has correct prefix", dir.getName().startsWith(PREFIX)); 65 } 66 finally { assertTrue("delete directory", dir.delete()); } 67 } 68 69 public void testReadAndWriteTempFile() throws IOException { 70 File file = FileOps.writeStringToNewTempFile(PREFIX, SUFFIX, TEXT); 71 try { 72 assertTrue("temp file has correct prefix", 73 file.getName().startsWith(PREFIX)); 74 assertTrue("temp file has correct suffix", 75 file.getName().endsWith(SUFFIX)); 76 77 String read = FileOps.readFileAsString(file); 78 assertEquals("contents after read", TEXT, read); 79 } 80 finally { 81 assertTrue("delete file", file.delete()); 82 } 83 } 84 85 public void testRecursiveDirectoryDelete() throws IOException { 86 final File baseDir = FileOps.createTempDirectory(PREFIX); 87 88 File parentDir = baseDir; 89 boolean ret; 90 91 for (int i = 0; i < 5; i++) { 93 File subdir = new File(parentDir, "subdir" + i); 94 ret = subdir.mkdir(); 95 assertTrue("create directory " + subdir, ret); 96 97 for (int j = 0; j < 2; j++) { 98 File file = new File(parentDir, "file" + i + "-" + j); 99 FileOps.writeStringToFile(file, 100 "Some text for file "+file.getAbsolutePath()); 101 assertTrue(file + " exists", file.exists()); 102 } 103 104 parentDir = subdir; 105 } 106 107 ret = FileOps.deleteDirectory(baseDir); 109 assertTrue("delete directory result", ret); 110 assertEquals("directory exists after deleting it", false, baseDir.exists()); 111 } 112 113 114 119 public void testSaveFile() throws IOException { 120 File writeTo = File.createTempFile("fileops", ".test").getCanonicalFile(); 121 writeTo.deleteOnExit(); 122 File backup = new File(writeTo.getPath() + "~"); 123 124 FileOps.saveFile(new FileOps.DefaultFileSaver(writeTo) { 125 public void saveTo(OutputStream os) throws IOException { 126 String output = "version 1"; 127 os.write(output.getBytes()); 128 } 129 public boolean shouldBackup() { 130 return false; 131 } 132 }); 133 assertEquals("save w/o backup", "version 1", FileOps.readFileAsString(writeTo)); 134 assertEquals("save w/o backup did not backup", false, backup.exists()); 135 136 FileOps.saveFile(new FileOps.DefaultFileSaver(writeTo) { 137 public void saveTo(OutputStream os) throws IOException { 138 String output = "version 2"; 139 os.write(output.getBytes()); 140 } 141 }); 142 assertEquals("save2 w backup", "version 2", FileOps.readFileAsString(writeTo)); 143 assertEquals("save2 w backup did backup", "version 1", 144 FileOps.readFileAsString(backup)); 145 146 FileOps.saveFile(new FileOps.DefaultFileSaver(writeTo) { 147 public void saveTo(OutputStream os) throws IOException { 148 String output = "version 3"; 149 os.write(output.getBytes()); 150 } 151 }); 152 assertEquals("save3 w backup on", "version 3", FileOps.readFileAsString(writeTo)); 153 assertEquals("save3 w backup on did not backup", "version 1", 154 FileOps.readFileAsString(backup)); 155 156 157 158 try { 159 FileOps.saveFile(new FileOps.DefaultFileSaver(writeTo) { 160 public void saveTo(OutputStream os) throws IOException { 161 String output = "version 4"; 162 os.write(output.getBytes()); 163 throw new IOException(); 164 } 165 }); 166 fail("IOException not propagated"); 167 } 168 catch (IOException ioe){ } assertEquals("failed save4 w/o backup", "version 3", 170 FileOps.readFileAsString(writeTo)); 171 assertEquals("failed save4 w/o backup check original backup", "version 1", 172 FileOps.readFileAsString(backup)); 173 174 175 try { 176 FileOps.saveFile(new FileOps.DefaultFileSaver(writeTo) { 177 public boolean shouldBackup () { 178 return true; 179 } 180 public void saveTo(OutputStream os) throws IOException { 181 String output = "version 5"; 182 os.write(output.getBytes()); 183 throw new IOException(); 184 } 185 }); 186 fail("IOException not propagated spot 2"); 187 } 188 catch(IOException ioe){ } assertEquals("failed save5 w backup", "version 3", 190 FileOps.readFileAsString(writeTo)); 191 192 try { 194 FileOps.readFileAsString(backup); 195 fail("The backup file should no longer exist."); 196 } 197 catch(FileNotFoundException e) { } 199 writeTo.setReadOnly(); 201 try { 202 FileOps.saveFile(new FileOps.DefaultFileSaver(writeTo) { 203 public boolean shouldBackup () { return true; } 204 public void saveTo(OutputStream os) throws IOException { 205 String output = "version 6"; 206 os.write(output.getBytes()); 207 } 208 }); 209 fail("The file to be saved was read-only!"); 210 } 211 catch(IOException ioe){ } assertEquals("failed save6 w backup", "version 3", 213 FileOps.readFileAsString(writeTo)); 214 215 try { 218 FileOps.readFileAsString(backup); 219 fail("The backup file should no longer exist."); 220 } 221 catch(FileNotFoundException e) { } } 223 224 228 public void testPackageExplore() throws IOException { 229 File rootDir = FileOps.createTempDirectory("fileOpsTest"); 230 File subDir0 = new File(rootDir, "sub0"); 231 subDir0.mkdir(); 232 File subDir1 = new File(rootDir, "sub1"); 233 subDir1.mkdir(); 234 File subsubDir0 = new File(subDir0, "subsub0"); 235 subsubDir0.mkdir(); 236 File javasubsub = new File(subsubDir0, "aclass.java"); 237 FileOps.writeStringToFile(javasubsub, "contents of this file are unimportant"); 238 File javasub1 = new File(subDir1, "myclass.java"); 239 FileOps.writeStringToFile(javasub1, "this file is pretty much empty"); 240 File javaroot = new File(rootDir, "someclass.java"); 241 FileOps.writeStringToFile(javaroot, "i can write anything i want here"); 242 243 LinkedList packages = FileOps.packageExplore("hello", rootDir); 244 assertEquals("package count a", 3, packages.size()); 245 assertTrue("packages contents a0", packages.contains("hello.sub0.subsub0")); 246 assertTrue("packages contents a1", packages.contains("hello.sub1")); 247 assertTrue("packages contents a2", packages.contains("hello")); 248 249 packages = FileOps.packageExplore("", rootDir); 252 assertEquals("package count b", 2, packages.size()); 253 assertTrue("packages contents b0", packages.contains("sub0.subsub0")); 254 assertTrue("packages contents b1", packages.contains("sub1")); 255 256 257 assertTrue("deleting temp directory", FileOps.deleteDirectory(rootDir)); 258 } 259 260 261 public void xtestDeleteDirectoryOnExit() throws IOException, InterruptedException { 262 263 File tempDir = FileOps.createTempDirectory("DrJavaTestTempDir"); 264 assertTrue("tempDir exists", tempDir.exists()); 265 File dir1 = new File(tempDir, "dir1"); 266 dir1.mkdir(); 267 assertTrue("dir1 exists", dir1.exists()); 268 assertTrue("dir1 is directory", dir1.isDirectory()); 269 File file1 = new File(dir1, "file1"); 270 file1.createNewFile(); assertTrue("file1 exists", file1.exists()); 272 File dir2 = new File(dir1, "dir2"); 273 dir2.mkdir(); 274 assertTrue("dir2 exists", dir2.exists()); 275 assertTrue("dir2 is directory", dir1.isDirectory()); 276 File file2 = new File(dir2, "file2"); 277 file2.createNewFile(); 278 assertTrue("file2 exists", file2.exists()); 279 280 String className = "edu.rice.cs.util.FileOpsTest"; 281 String [] args = new String [] {dir1.getAbsolutePath() }; 283 Process process = ExecJVM.runJVMPropagateClassPath(className, args, FileOption.NULL_FILE); 284 int status = process.waitFor(); 285 assertEquals("Delete on exit test exited with an error!", 0, status); 286 287 assertTrue("dir1 should be deleted", ! dir1.exists()); 288 assertTrue("file1 should be deleted", ! file1.exists()); 289 assertTrue("dir2 should be deleted", ! dir2.exists()); 290 assertTrue("file2 should be deleted", ! file2.exists()); 291 292 } 293 294 public void testSplitFile() { 295 String [] parts = new String []{"","home","username","dir"}; 296 String path1 = ""; 297 for (String s : parts) { 298 path1 += s + File.separator; 299 } 300 301 File f = new File(path1); 302 String [] res = FileOps.splitFile(f); 303 304 assertTrue( "Inconsitent results. Expected " + 305 java.util.Arrays.asList(parts).toString() + ", but found " + 306 java.util.Arrays.asList(res).toString(), 307 java.util.Arrays.equals(parts,res)); 308 } 309 310 private String fixPathFormat(String s){ 311 return s.replace('\\', '/'); 312 } 313 314 public void testMakeRelativeTo() throws IOException, SecurityException { 315 File base, abs; 316 317 base = new File("src/test1/test2/file.txt"); 318 abs = new File("built/test1/test2/file.txt"); 319 assertEquals("Wrong Relative Path 1", "../../../built/test1/test2/file.txt", 320 fixPathFormat(FileOps.makeRelativeTo(abs,base).getPath())); 321 base = new File("file.txt"); 322 abs = new File("built/test1/test2/file.txt"); 323 assertEquals("Wrong Relative Path 2", "built/test1/test2/file.txt", 324 fixPathFormat(FileOps.makeRelativeTo(abs,base).getPath())); 325 base = new File("built/test1/test2test/file.txt"); 326 abs = new File("built/test1/test2/file.txt"); 327 assertEquals("Wrong Relative Path 3", "../test2/file.txt", 328 fixPathFormat(FileOps.makeRelativeTo(abs,base).getPath())); 329 base = new File("file.txt"); 330 abs = new File("test.txt"); 331 assertEquals("Wrong Relative Path 4", "test.txt", 332 fixPathFormat(FileOps.makeRelativeTo(abs,base).getPath())); 333 } 334 335 339 public static void main(String [] args) { 340 if (args.length != 1) System.exit(1); 341 342 File dir = new File(args[0]); 343 if (! dir.exists()) System.exit(2); 344 FileOps.deleteDirectoryOnExit(dir); 345 346 System.exit(0); 348 } 349 350 public void testConvertToAbsolutePathEntries() { 351 String ud = System.getProperty("user.dir"); 352 String f = System.getProperty("file.separator"); 353 String p = System.getProperty("path.separator"); 354 String expected, actual, input; 355 356 input = "."+p+"drjava"+p+p+f+"home"+f+"foo"+f+"junit.jar"; 357 expected = ud+f+"."+p+ud+f+"drjava"+p+ud+p+(new File(f+"home"+f+"foo"+f+"junit.jar")).getAbsolutePath(); 358 actual = FileOps.convertToAbsolutePathEntries(input); 359 assertEquals("testConvertToAbsolutePathEntries for several paths failed, input = '" + input + "', expected = '" + 360 expected + "', actual = '" + actual + "'", expected, actual); 361 input = ""; 362 expected = ud; 363 actual = FileOps.convertToAbsolutePathEntries(input); 364 assertEquals("testConvertToAbsolutePathEntries for empty path failed, input = '" + input + "', expected = '" + 365 expected + "', actual = '" + actual + "'", expected, actual); 366 input = p + p + p + "."; 367 expected = ud + p + ud + p + ud + p + ud + f + "."; 368 actual = FileOps.convertToAbsolutePathEntries(input); 369 assertEquals("testConvertToAbsolutePathEntries for several empty paths failed, input = '" + input + 370 "', expected = '" +expected+"', actual = '" + actual + "'", expected, actual); 371 input = p + p; 372 expected = ud + p + ud + p + ud; 373 actual = FileOps.convertToAbsolutePathEntries(input); 374 assertEquals("testConvertToAbsolutePathEntries for trailing empty paths failed, input = '" + input + 375 "', expected = '" + expected + "', actual = '" + actual + "'", expected, actual); 376 } 377 378 379 public void testGetFiles() throws IOException { 380 File dir1 = FileOps.createTempDirectory("DrJavaTestTempDir"); 381 assertTrue("dir1 exists", dir1.exists()); 382 File file1a = File.createTempFile("DrJavaTest-", ".temp", dir1).getCanonicalFile(); 383 assertTrue("file1a exists", file1a.exists()); 384 File file1b = File.createTempFile("DrJava-", ".temp", dir1).getCanonicalFile(); 385 assertTrue("file1b exists", file1b.exists()); 386 File dir2 = FileOps.createTempDirectory("DrJavaTestDir-", dir1).getCanonicalFile(); 387 assertTrue("dir2 exists", dir2.exists()); 388 File file2 = File.createTempFile("DrJavaTest-", ".temp", dir2).getCanonicalFile(); 389 assertTrue("file2 exists", file2.exists()); 390 391 FileFilter ff = new FileFilter() { 392 public boolean accept(File f) { 393 if (f.isDirectory()) return true; 394 String name = f.getName(); 395 return name.startsWith("DrJavaTest"); 396 } 397 }; 398 399 Set <File> res1 = new TreeSet <File>(Arrays.asList(new File[] {file1a})); 400 Set <File> res2 = new TreeSet <File>(Arrays.asList(new File[] {file1a, file2})); 401 402 Set <File> nrfiles = new TreeSet <File>(); 403 for(File f : FileOps.getFilesInDir(dir1, false, ff)) { 404 nrfiles.add(f.getCanonicalFile()); 405 } 406 407 Set <File> rfiles = new TreeSet <File>(); 408 for(File f : FileOps.getFilesInDir(dir1, true, ff)) { 409 rfiles.add(f.getCanonicalFile()); 410 } 411 412 assertEquals("non-recursive FilesInDir test", res1, nrfiles); 413 assertEquals("recursive FileInDir test", res2, rfiles); 414 } 415 } 416 | Popular Tags |