wamblee.org Git - utils/blob

   1 /*
   2  * Copyright 2006 the original author or authors.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package org.wamblee.io;
  17
  18 import java.io.File;
  19 import java.io.IOException;
  20 import java.io.InputStream;
  21 import java.io.UnsupportedEncodingException;
  22 import java.net.URL;
  23 import java.net.URLDecoder;
  24 import java.security.CodeSource;
  25
  26 import junit.framework.TestCase;
  27
  28 import org.apache.commons.logging.Log;
  29 import org.apache.commons.logging.LogFactory;
  30
  31 /**
  32  * File system utilities.
  33  */
  34 public final class FileSystemUtils {
  35
  36     private static final Log LOG = LogFactory.getLog(FileSystemUtils.class);
  37
  38     /**
  39      * Test output directory relative to the sub project.
  40      */
  41     private static final String TEST_OUTPUT_DIR = "resources/testoutput";
  42
  43     /**
  44      * Test input directory relative to the sub project.
  45      */
  46     private static final String TEST_INPUT_DIR = "../resources/test";
  47
  48     /*
  49      * Disabled.
  50      *
  51      */
  52     private FileSystemUtils() {
  53         // Empty
  54     }
  55
  56     /**
  57      * Deletes a directory recursively. The test case will fail if the directory
  58      * does not exist or if deletion fails.
  59      *
  60      * @param aDir
  61      *            Directory to delete.
  62      */
  63     public static void deleteDirRecursively(String aDir) {
  64         deleteDirRecursively(new File(aDir));
  65     }
  66
  67     /**
  68      * Deletes a directory recursively. See {@link #deleteDirRecursively}.
  69      *
  70      * @param aDir
  71      *            Directory.
  72      */
  73     public static void deleteDirRecursively(File aDir) {
  74         TestCase.assertTrue(aDir.isDirectory());
  75
  76         for (File file : aDir.listFiles()) {
  77             if (file.isDirectory()) {
  78                 deleteDirRecursively(file);
  79             } else {
  80                 delete(file);
  81             }
  82         }
  83
  84         delete(aDir);
  85     }
  86
  87     /**
  88      * Deletes a file or directory. The test case will fail if the file or
  89      * directory does not exist or if deletion fails. Deletion of a non-empty
  90      * directory will always fail.
  91      *
  92      * @param aFile
  93      *            File or directory to delete.
  94      */
  95     public static void delete(File aFile) {
  96         TestCase.assertTrue(aFile.delete());
  97     }
  98
  99     /**
 100      * Gets a path relative to a sub project. This utility should be used to
 101      * easily access file paths within a subproject without requiring any
 102      * specific Eclipse configuration.
 103      *
 104      * @param aRelativePath
 105      *            Relative path.
 106      * @param aTestClass
 107      *            Test class.
 108      */
 109     public static File getPath(String aRelativePath, Class aTestClass) {
 110         CodeSource source = aTestClass.getProtectionDomain().getCodeSource();
 111         if (source == null) {
 112             LOG.warn("Could not obtain path for '" + aRelativePath
 113                     + "' for class " + aTestClass
 114                     + ", using relative path as is");
 115             return new File(aRelativePath);
 116         }
 117         URL location = source.getLocation();
 118         String protocol = location.getProtocol();
 119         if (!protocol.equals("file")) {
 120             LOG.warn("protocol is not 'file': " + location);
 121             return new File(aRelativePath);
 122         }
 123
 124         String path = location.getPath();
 125         try {
 126             path = URLDecoder.decode(location.getPath(), "UTF-8");
 127         } catch (UnsupportedEncodingException e) {
 128             // ignore it.. just don't decode
 129             LOG.warn("Decoding path failed: '" + location.getPath() + "'", e );
 130         }
 131
 132         return new File(new File(path).getParentFile(), aRelativePath);
 133     }
 134
 135     /**
 136      * Ensures that a directory hierarchy exists (recursively if needed). If it
 137      * is not possible to create the directory, then the test case will fail.
 138      *
 139      * @param aDir
 140      *            Directory to create.
 141      */
 142     public static void createDir(File aDir) {
 143         if (aDir.exists() && !aDir.isDirectory()) {
 144             TestCase.fail("'" + aDir
 145                     + "' already exists and is not a directory");
 146         }
 147         if (aDir.exists()) {
 148             return;
 149         }
 150         createDir(aDir.getParentFile());
 151         TestCase.assertTrue("Could not create '" + aDir + "'", aDir.mkdir());
 152     }
 153
 154     /**
 155      * Gets the test output directory for a specific test class.
 156      *
 157      * @param aTestClass
 158      *            Test class.
 159      * @return Test output directory.
 160      */
 161     public static File getTestOutputDir(Class aTestClass) {
 162         File file = getPath(TEST_OUTPUT_DIR, aTestClass);
 163         String packageName = aTestClass.getPackage().getName();
 164         String packagePath = packageName.replaceAll("\\.", "/");
 165         return new File(file, packagePath);
 166     }
 167
 168     /**
 169      * Gets the test input directory for a specific test class.
 170      *
 171      * @param aTestClass
 172      *            Test class.
 173      * @return Test input directory.
 174      */
 175     public static File getTestInputDir(Class aTestClass) {
 176         File file = getPath(TEST_INPUT_DIR, aTestClass);
 177         String packageName = aTestClass.getPackage().getName();
 178         String packagePath = packageName.replaceAll("\\.", "/");
 179         return new File(file, packagePath);
 180     }
 181
 182     /**
 183      * Creates a directory hierarchy for the output directory of a test class if
 184      * needed.
 185      *
 186      * @param aTestClass
 187      *            Test class
 188      * @return Test directory.
 189      */
 190     public static File createTestOutputDir(Class aTestClass) {
 191         File file = getTestOutputDir(aTestClass);
 192         createDir(file);
 193         return file;
 194     }
 195
 196     /**
 197      * Gets a test output file name. This returns a File object representing the
 198      * output file and ensures that the directory where the file will be created
 199      * already exists.
 200      *
 201      * @param aName
 202      *            Name of the file.
 203      * @param aTestClass
 204      *            Test class.
 205      * @return File.
 206      */
 207     public static File getTestOutputFile(String aName, Class aTestClass) {
 208         File file = new File(getTestOutputDir(aTestClass), aName);
 209         createDir(file.getParentFile());
 210         return file;
 211     }
 212
 213     public static String read(InputStream aIs) throws IOException {
 214         try {
 215             StringBuffer buffer = new StringBuffer();
 216             int c;
 217             while ((c = aIs.read()) != -1) {
 218                 buffer.append((char)c);
 219             }
 220             return buffer.toString();
 221         } finally {
 222             aIs.close();
 223         }
 224     }
 225 }