wamblee.org Git - utils/blob - support/test/org/wamblee/test/TestSupport.java

   1 /*
   2  * Copyright 2005 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.test;
  17
  18 import java.io.File;
  19 import java.io.FileInputStream;
  20 import java.io.FileOutputStream;
  21 import java.io.IOException;
  22 import java.nio.MappedByteBuffer;
  23 import java.nio.channels.FileChannel;
  24
  25 import junit.framework.Assert;
  26
  27 /**
  28  * @author Erik Test support utility.
  29  */
  30 public final class TestSupport {
  31
  32     /**
  33      * Disabled constructor.
  34      *
  35      */
  36     private TestSupport() {
  37         // Empty
  38     }
  39
  40     /**
  41      * Obtain root directory of JUnit tests.
  42      *
  43      * @return Directory name.
  44      */
  45     public static File getTestRootDir() {
  46         return new File("testdata");
  47     }
  48
  49     /**
  50      * Returns a temporary directory.
  51      *
  52      * @return Temporary directory.
  53      */
  54     public static File getTmpDir() {
  55         return new File(getTestRootDir(), "tmpdir");
  56     }
  57
  58     /**
  59      * Recursively remove a directory.
  60      *
  61      * @param aSrc
  62      *            Directoryto remove.
  63      */
  64     public static void removeDir(File aSrc) {
  65         if (!aSrc.exists()) {
  66             return;
  67         }
  68         Assert.assertTrue(aSrc.getPath(), aSrc.isDirectory());
  69         File[] files = aSrc.listFiles();
  70         for (int i = 0; i < files.length; i++) {
  71             File file = files[i];
  72             if (file.isDirectory()) {
  73                 removeDir(file);
  74             } else {
  75                 Assert.assertTrue(file.getPath(), file.delete());
  76             }
  77         }
  78         Assert.assertTrue(aSrc.getPath(), aSrc.delete());
  79     }
  80
  81     /**
  82      * Recursively copy a directory.
  83      *
  84      * @param aSrc
  85      *            Source directory
  86      * @param aTarget
  87      *            Target directory.
  88      */
  89     public static void copyDir(File aSrc, File aTarget) {
  90         Assert.assertTrue(aSrc.isDirectory());
  91         Assert.assertTrue(!aTarget.exists());
  92
  93         aTarget.mkdirs();
  94
  95         File[] files = aSrc.listFiles();
  96         for (int i = 0; i < files.length; i++) {
  97             File file = files[i];
  98             if (file.isDirectory()) {
  99                 if (!file.getName().equals(".svn")) {
 100                     copyDir(new File(aSrc, file.getName()), new File(aTarget,
 101                             file.getName()));
 102                 }
 103             } else {
 104                 copyFile(file, new File(aTarget, file.getName()));
 105             }
 106         }
 107     }
 108
 109     /**
 110      * Copy a file. If copying fails then the testcase will fail.
 111      *
 112      * @param aSrc
 113      *            Source file.
 114      * @param aTarget
 115      *            Target file.
 116      */
 117     public static void copyFile(File aSrc, File aTarget) {
 118
 119         try {
 120             FileInputStream fis = new FileInputStream(aSrc);
 121             FileOutputStream fos = new FileOutputStream(aTarget);
 122             FileChannel fcin = fis.getChannel();
 123             FileChannel fcout = fos.getChannel();
 124
 125             // map input file
 126
 127             MappedByteBuffer mbb = fcin.map(FileChannel.MapMode.READ_ONLY, 0,
 128                     fcin.size());
 129
 130             // do the file copy
 131             fcout.write(mbb);
 132
 133             // finish up
 134
 135             fcin.close();
 136             fcout.close();
 137             fis.close();
 138             fos.close();
 139         } catch (IOException e) {
 140             Assert.assertTrue("Copying file " + aSrc.getPath() + " to "
 141                     + aTarget.getPath() + " failed.", false);
 142         }
 143     }
 144
 145     /**
 146      * Remove a file or directory. The test case will fail if this does not
 147      * succeed.
 148      *
 149      * @param aFile
 150      *            entry to remove.
 151      */
 152     public static void delete(File aFile) {
 153         Assert
 154                 .assertTrue("Could not delete " + aFile.getPath(), aFile
 155                         .delete());
 156     }
 157
 158     /**
 159      * Remove all files within a given directory including the directory itself.
 160      * This only attempts to remove regular files and not directories within the
 161      * directory. If the directory contains a nested directory, the deletion
 162      * will fail. The test case will fail if this fails.
 163      *
 164      * @param aDir
 165      *            Directory to remove.
 166      */
 167     public static void deleteDir(File aDir) {
 168         cleanDir(aDir);
 169         delete(aDir);
 170     }
 171
 172     /**
 173      * Remove all regular files within a given directory.
 174      *
 175      * @param outputDirName
 176      */
 177     public static void cleanDir(File aDir) {
 178         if (!aDir.exists()) {
 179             return; // nothing to do.
 180         }
 181         File[] entries = aDir.listFiles();
 182         for (int i = 0; i < entries.length; i++) {
 183             File file = entries[i];
 184             if (file.isFile()) {
 185                 Assert.assertTrue("Could not delete " + entries[i].getPath(),
 186                         entries[i].delete());
 187             }
 188         }
 189     }
 190
 191     /**
 192      * Creates directory if it does not already exist. The test case will fail
 193      * if the directory cannot be created.
 194      *
 195      * @param aDir
 196      *            Directory to create.
 197      */
 198     public static void createDir(File aDir) {
 199         if (aDir.isDirectory()) {
 200             return; // nothing to do.
 201         }
 202         Assert.assertTrue("Could not create directory " + aDir.getPath(), aDir
 203                 .mkdirs());
 204     }
 205 }