QPID-1268 : Added additional deleteDirectory method that behaves like rmdir, modified delete to behave like rm. Added further tests for copy and delete. Encorporated review feedback from ASkinner.

git-svn-id: https://svn.apache.org/repos/asf/incubator/qpid/trunk/qpid@701329 13f79535-47bb-0310-9956-ffa450edef68

2 files changed, 457 insertions, 32 deletions

diff --git a/java/common/src/main/java/org/apache/qpid/util/FileUtils.java b/java/common/src/main/java/org/apache/qpid/util/FileUtils.java
index 814d6e73c9..883373ba35 100644
--- a/java/common/src/main/java/org/apache/qpid/util/FileUtils.java
+++ b/java/common/src/main/java/org/apache/qpid/util/FileUtils.java
@@ -196,31 +196,107 @@ public class FileUtils
     /*
      * Deletes a given file
      */
-     public static void deleteFile(String filePath) throws IOException
+     public static boolean deleteFile(String filePath)
      {
-         delete(new File(filePath), false);
+         return delete(new File(filePath), false);
+     }
+
+    /*
+     * Deletes a given empty directory 
+     */
+     public static boolean deleteDirectory(String directoryPath)
+     {
+         File directory = new File(directoryPath);
+
+         if (directory.isDirectory())
+         {
+           if (directory.listFiles().length == 0)
+           {
+               return delete(directory, true);
+           }
+         }
+
+         return false;
      }
 
      /**
-      * Delete a given file, if a directory is specified and recursive set then delete the whole tree
-      * @param filePath the File object to start at
+      * Delete a given file/directory,
+      * A directory will always require the recursive flag to be set.
+      * if a directory is specified and recursive set then delete the whole tree
+      * @param file the File object to start at
       * @param recursive boolean to recurse if a directory is specified.
-      * @throws IOException
+      * @return <code>true</code> if and only if the file or directory is
+      *          successfully deleted; <code>false</code> otherwise
       */
-     public static void delete(File filePath, boolean recursive) throws IOException
+     public static boolean delete(File file, boolean recursive)
      {
-         if (filePath.isDirectory())
+         boolean success=true;
+
+         if (file.isDirectory())
          {
              if (recursive)
              {
-                 for (File subFile : filePath.listFiles())
-                 {
-                     delete(subFile, true);
+                 for (File subFile : file.listFiles())
+                 {                                     
+                     success = delete(subFile, true) & success ;
                  }
+
+                 return file.delete();
              }
+
+             return false;
          }
 
-         filePath.delete();
+         return success && file.delete();
      }
-    
+
+
+    public static class UnableToCopyException extends Exception
+    {
+        UnableToCopyException(String msg)
+        {
+            super(msg);
+        }
+    }
+
+    public static void copyRecursive(File source, File dst) throws FileNotFoundException, UnableToCopyException
+    {
+
+        if (!source.exists())
+        {
+            throw new FileNotFoundException("Unable to copy '" + source.toString() + "' as it does not exist.");
+        }
+
+        if (dst.exists() && !dst.isDirectory())
+        {
+            throw new IllegalArgumentException("Unable to copy '" + source.toString() + "' to '" + dst + "' a file with same name exists.");
+        }
+
+
+        if (source.isFile())
+        {
+            copy(source, dst);
+        }
+
+        //else we have a source directory
+        if (!dst.isDirectory() && !dst.mkdir())
+        {
+             throw new UnableToCopyException("Unable to create destination directory");
+        }
+
+
+        for (File file : source.listFiles())
+        {
+           if (file.isFile())
+           {
+               copy(file, new File(dst.toString() + File.separator + file.getName()));
+           }
+           else
+           {
+               copyRecursive(file, new File(dst + File.separator + file.getName()));
+           }
+        }
+
+
+    }
 }
diff --git a/java/common/src/test/java/org/apache/qpid/util/FileUtilsTest.java b/java/common/src/test/java/org/apache/qpid/util/FileUtilsTest.java
index 6681c1a5b6..966d040f41 100644
--- a/java/common/src/test/java/org/apache/qpid/util/FileUtilsTest.java
+++ b/java/common/src/test/java/org/apache/qpid/util/FileUtilsTest.java
@@ -24,12 +24,161 @@ import junit.framework.TestCase;
 
 import java.io.File;
 import java.io.IOException;
+import java.io.BufferedWriter;
+import java.io.FileWriter;
+import java.io.FileNotFoundException;
 
 public class FileUtilsTest extends TestCase
 {
-    public void testDelete()
+    private static final String COPY = "-Copy";
+    private static final String SUB = "-Sub";
+
+    /**
+     * Additional test for the copy method.
+     * Ensures that the directory count did increase by more than 1 after the copy.
+     */
+    public void testCopyFile()
     {
-        File test = new File("FileUtilsTest-testDelete");
+        final String TEST_DATA = "FileUtilsTest-testCopy-TestDataTestDataTestDataTestDataTestDataTestData";
+        String fileName = "FileUtilsTest-testCopy";
+        String fileNameCopy = fileName + COPY;
+
+        //Create initial file
+        File test = createTestFile(fileName, TEST_DATA);
+
+        //Check number of files before copy
+        File[] beforeCopyFileList = test.getAbsoluteFile().getParentFile().listFiles();
+        int beforeCopy = beforeCopyFileList.length;
+
+        //Perform Copy
+        FileUtils.copy(test, new File(fileNameCopy));
+
+        //Retrieve counts after copy
+        int afterCopy = new File(test.getAbsoluteFile().getParent()).listFiles().length;
+
+        int afterCopyFromCopy = new File(new File(fileNameCopy).getAbsoluteFile().getParent()).listFiles().length;
+
+        // Validate the copy counts
+        assertEquals("The file listing from the original and the copy differ in length.", afterCopy, afterCopyFromCopy);
+        assertEquals("The number of files did not increase.", beforeCopy + 1, afterCopy);
+        assertEquals("The number of files did not increase.", beforeCopy + 1, afterCopyFromCopy);
+
+        //Validate copy
+        // Load content
+        String copiedFileContent = FileUtils.readFileAsString(fileNameCopy);
+        assertEquals(TEST_DATA, copiedFileContent);
+
+        //Clean up
+        assertTrue("Unable to cleanup", FileUtils.deleteFile(fileNameCopy));
+
+        //Check file list after cleanup
+        File[] afterCleanup = new File(test.getAbsoluteFile().getParent()).listFiles();
+        checkFileLists(beforeCopyFileList, afterCleanup);
+
+        //Remove original file
+        assertTrue("Unable to cleanup", test.delete());
+    }
+
+    /**
+     * Create and Copy the following structure:
+     *
+     * testDirectory --+
+     * +-- testSubDirectory --+
+     * +-- testSubFile
+     * +-- File
+     *
+     * to testDirectory-Copy
+     *
+     * Validate that the file count in the copy is correct and contents of the copied files is correct.
+     */
+    public void testCopyRecursive()
+    {
+        final String TEST_DATA = "FileUtilsTest-testDirectoryCopy-TestDataTestDataTestDataTestDataTestDataTestData";
+        String fileName = "FileUtilsTest-testCopy";
+        String TEST_DIR = "testDirectoryCopy";
+
+        //Create Initial Structure
+        File testDir = new File(TEST_DIR);
+
+        //Check number of files before copy
+        File[] beforeCopyFileList = testDir.getAbsoluteFile().getParentFile().listFiles();
+
+        try
+        {
+            //Create Directories
+            assertTrue("Test directory already exists cannot test.", !testDir.exists());
+
+            if (!testDir.mkdir())
+            {
+                fail("Unable to make test Directory");
+            }
+
+            File testSubDir = new File(TEST_DIR + File.separator + TEST_DIR + SUB);
+            if (!testSubDir.mkdir())
+            {
+                fail("Unable to make test sub Directory");
+            }
+
+            //Create Files
+            createTestFile(testDir.toString() + File.separator + fileName, TEST_DATA);
+            createTestFile(testSubDir.toString() + File.separator + fileName + SUB, TEST_DATA);
+
+            //Perform Copy
+            File copyDir = new File(testDir.toString() + COPY);
+            try
+            {
+                FileUtils.copyRecursive(testDir, copyDir);
+            }
+            catch (FileNotFoundException e)
+            {
+                fail(e.getMessage());
+            }
+            catch (FileUtils.UnableToCopyException e)
+            {
+                fail(e.getMessage());
+            }
+
+            //Validate Copy
+            assertEquals("Copied directory should only have one file and one directory in it.", 2, copyDir.listFiles().length);
+
+            //Validate Copy File Contents
+            String copiedFileContent = FileUtils.readFileAsString(copyDir.toString() + File.separator + fileName);
+            assertEquals(TEST_DATA, copiedFileContent);
+
+            //Validate Name of Sub Directory
+            assertTrue("Expected subdirectory is not a directory", new File(copyDir.toString() + File.separator + TEST_DIR + SUB).isDirectory());
+
+            //Assert that it contains only one item
+            assertEquals("Copied sub directory should only have one directory in it.", 1, new File(copyDir.toString() + File.separator + TEST_DIR + SUB).listFiles().length);
+
+            //Validate content of Sub file
+            copiedFileContent = FileUtils.readFileAsString(copyDir.toString() + File.separator + TEST_DIR + SUB + File.separator + fileName + SUB);
+            assertEquals(TEST_DATA, copiedFileContent);
+        }
+        finally
+        {
+            //Clean up source and copy directory.
+            assertTrue("Unable to cleanup", FileUtils.delete(testDir, true));
+            assertTrue("Unable to cleanup", FileUtils.delete(new File(TEST_DIR + COPY), true));
+
+            //Check file list after cleanup
+            File[] afterCleanup = new File(testDir.getAbsoluteFile().getParent()).listFiles();
+            checkFileLists(beforeCopyFileList, afterCleanup);
+        }
+    }
+
+    /**
+     * Helper method to create a test file with a string content
+     *
+     * @param fileName  The fileName to use in the creation
+     * @param test_data The data to store in the file
+     *
+     * @return The File reference
+     */
+    private File createTestFile(String fileName, String test_data)
+    {
+        File test = new File(fileName);
+
         try
         {
             test.createNewFile();
@@ -39,64 +188,264 @@ public class FileUtilsTest extends TestCase
             fail(e.getMessage());
         }
 
-        assertTrue("File does not exists", test.exists());
-        assertTrue("File is not a file", test.isFile());
+        BufferedWriter writer = null;
+        try
+        {
+            writer = new BufferedWriter(new FileWriter(test));
+            try
+            {
+                writer.write(test_data);
+            }
+            catch (IOException e)
+            {
+                fail(e.getMessage());
+            }
+        }
+        catch (IOException e)
+        {
+            fail(e.getMessage());
+        }
+        finally
+        {
+            try
+            {
+                if (writer != null)
+                {
+                    writer.close();
+                }
+            }
+            catch (IOException e)
+            {
+                fail(e.getMessage());
+            }
+        }
+
+        return test;
+    }
+
+    /**
+     * Test that deleteFile only deletes the specified file
+     */
+    public void testDeleteFile()
+    {
+        File test = new File("FileUtilsTest-testDelete");
+        //Record file count in parent directory to check it is not changed by delete
+        String path = test.getAbsolutePath();
+        File[] filesBefore = new File(path.substring(0, path.lastIndexOf(File.separator))).listFiles();
+        int fileCountBefore = filesBefore.length;
 
         try
         {
-            FileUtils.deleteFile("FileUtilsTest-testDelete");
+            test.createNewFile();
         }
         catch (IOException e)
         {
             fail(e.getMessage());
         }
 
+        assertTrue("File does not exists", test.exists());
+        assertTrue("File is not a file", test.isFile());
+
+        //Check that file creation can be seen on disk
+        int fileCountCreated =new File(path.substring(0, path.lastIndexOf(File.separator))).listFiles().length;
+        assertEquals("File creation was no registered", fileCountBefore + 1, fileCountCreated);
+
+        //Perform Delete
+        assertTrue("Unable to cleanup", FileUtils.deleteFile("FileUtilsTest-testDelete"));
+
         assertTrue("File exists after delete", !test.exists());
+
+        //Check that after deletion the file count is now accurate
+        File[] filesAfter = new File(path.substring(0, path.lastIndexOf(File.separator))).listFiles();
+        int fileCountAfter = filesAfter.length;
+        assertEquals("File creation was no registered", fileCountBefore, fileCountAfter);
+
+        checkFileLists(filesBefore, filesAfter);
     }
 
-    public void testRecursiveDelete()
+    /**
+     * Given two lists of File arrays ensure they are the same length and all entries in Before are in After
+     * @param filesBefore File[]
+     * @param filesAfter File[] 
+     */
+    private void checkFileLists(File[] filesBefore, File[] filesAfter)
+    {
+        assertEquals("File lists are unequal", filesBefore.length, filesAfter.length);
+
+        for (File fileBefore : filesBefore)
+        {
+            boolean found = false;
+
+            for (File fileAfter : filesAfter)
+            {
+                if (fileBefore.getAbsolutePath().equals(fileAfter.getAbsolutePath()))
+                {
+                    found = true;
+                    break;
+                }
+            }
+
+            assertTrue("File'" + fileBefore.getName() + "' was not in directory afterwards", found);
+        }
+    }
+
+    public void testNonRecursiveNonEmptyDirectoryDeleteFails()
     {
         String directoryName = "FileUtilsTest-testRecursiveDelete";
         File test = new File(directoryName);
 
+        //Record file count in parent directory to check it is not changed by delete
+        String path = test.getAbsolutePath();
+        File[] filesBefore = new File(path.substring(0, path.lastIndexOf(File.separator))).listFiles();
+        int fileCountBefore = filesBefore.length;
+        
         assertTrue("Directory exists", !test.exists());
 
         test.mkdir();
 
-        createSubDir(directoryName, 2, 4);
-
+        //Create a file in the directory
+        String fileName = test.getAbsolutePath() + File.separatorChar + "testFile";
+        File subFile = new File(fileName);
         try
         {
-            FileUtils.deleteFile("FileUtilsTest-testDelete");
+            subFile.createNewFile();
         }
         catch (IOException e)
         {
             fail(e.getMessage());
         }
 
-        assertTrue("File does not exist after file delete", test.exists());
+        //Try and delete the non-empty directory
+        assertFalse("Non Empty Directory was successfully deleted.", FileUtils.deleteDirectory(directoryName));
+
+        //Check directory is still there
+        assertTrue("Directory was deleted.", test.exists());
+
+
+        // Clean up
+        assertTrue("Unable to cleanup", FileUtils.delete(test, true));
+
+        //Check that after deletion the file count is now accurate
+        File[] filesAfter = new File(path.substring(0, path.lastIndexOf(File.separator))).listFiles();
+        int fileCountAfter = filesAfter.length;
+        assertEquals("File creation was no registered", fileCountBefore, fileCountAfter);
+
+        checkFileLists(filesBefore, filesAfter);
+    }
+
+    /**
+     * Test that an empty directory can be deleted with deleteDirectory
+     */
+    public void testEmptyDirectoryDelete()
+    {
+        String directoryName = "FileUtilsTest-testRecursiveDelete";
+        File test = new File(directoryName);
+
+        //Record file count in parent directory to check it is not changed by delete
+        String path = test.getAbsolutePath();
+        File[] filesBefore = new File(path.substring(0, path.lastIndexOf(File.separator))).listFiles();
+        int fileCountBefore = filesBefore.length;
+
+        assertTrue("Directory exists", !test.exists());
+
+        test.mkdir();
+
+        //Try and delete the empty directory
+        assertTrue("Non Empty Directory was successfully deleted.", FileUtils.deleteDirectory(directoryName));
+
+        //Check directory is still there
+        assertTrue("Directory was deleted.", !test.exists());
+
+        //Check that after deletion the file count is now accurate
+        File[] filesAfter = new File(path.substring(0, path.lastIndexOf(File.separator))).listFiles();
+        int fileCountAfter = filesAfter.length;
+        assertEquals("File creation was no registered", fileCountBefore, fileCountAfter);
+
+        checkFileLists(filesBefore, filesAfter);
+
+    }
+
+    /**
+     * Test that deleteDirectory on a non empty directory to complete 
+     */
+    public void testNonEmptyDirectoryDelete()
+    {
+        String directoryName = "FileUtilsTest-testRecursiveDelete";
+        File test = new File(directoryName);
+
+        assertTrue("Directory exists", !test.exists());
 
+        //Record file count in parent directory to check it is not changed by delete
+        String path = test.getAbsolutePath();
+        File[] filesBefore = new File(path.substring(0, path.lastIndexOf(File.separator))).listFiles();
+        int fileCountBefore = filesBefore.length;
+
+        test.mkdir();
+
+        //Create a file in the directory
+        String fileName = test.getAbsolutePath() + File.separatorChar + "testFile";
+        File subFile = new File(fileName);
         try
         {
-            FileUtils.delete(test, false);
+            subFile.createNewFile();
         }
         catch (IOException e)
         {
             fail(e.getMessage());
         }
-        
+
+        //Try and delete the non-empty directory non-recursively
+        assertFalse("Non Empty Directory was successfully deleted.", FileUtils.delete(test, false));
+
+        //Check directory is still there
+        assertTrue("Directory was deleted.", test.exists());
+
+        // Clean up
+        assertTrue("Unable to cleanup", FileUtils.delete(test, true));
+
+        //Check that after deletion the file count is now accurate
+        File[] filesAfter = new File(path.substring(0, path.lastIndexOf(File.separator))).listFiles();
+        int fileCountAfter = filesAfter.length;
+        assertEquals("File creation was no registered", fileCountBefore, fileCountAfter);
+
+        checkFileLists(filesBefore, filesAfter);
+
+    }
+
+    /**
+     * Test that a recursive delete successeds
+     */
+    public void testRecursiveDelete()
+    {
+        String directoryName = "FileUtilsTest-testRecursiveDelete";
+        File test = new File(directoryName);
+
+        assertTrue("Directory exists", !test.exists());
+
+        //Record file count in parent directory to check it is not changed by delete
+        String path = test.getAbsolutePath();
+        File[] filesBefore = new File(path.substring(0, path.lastIndexOf(File.separator))).listFiles();
+        int fileCountBefore = filesBefore.length;
+
+        test.mkdir();
+
+        createSubDir(directoryName, 2, 4);
+
+        assertFalse("Non recursive delete was able to directory", FileUtils.delete(test, false));
+
         assertTrue("File does not exist after non recursive delete", test.exists());
 
-        try
-        {
-            FileUtils.delete(test, true);
-        }
-        catch (IOException e)
-        {
-            fail(e.getMessage());
-        }
+        assertTrue("Unable to cleanup", FileUtils.delete(test, true));
+
         assertTrue("File  exist after recursive delete", !test.exists());
 
+        //Check that after deletion the file count is now accurate
+        File[] filesAfter = new File(path.substring(0, path.lastIndexOf(File.separator))).listFiles();
+        int fileCountAfter = filesAfter.length;
+        assertEquals("File creation was no registered", fileCountBefore, fileCountAfter);
+
+        checkFileLists(filesBefore, filesAfter);
+
     }
 
     private void createSubDir(String path, int directories, int files)