wamblee.org Git - utils/blob - support/src/test/java/org/wamblee/io/TestData.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.io;
  17
  18 import java.io.File;
  19 import java.io.FileInputStream;
  20 import java.io.FileOutputStream;
  21 import java.io.IOException;
  22 import java.io.InputStream;
  23 import java.io.OutputStream;
  24 import java.nio.MappedByteBuffer;
  25 import java.nio.channels.FileChannel;
  26
  27 import junit.framework.Assert;
  28
  29 /**
  30  * TestData provides a convenient interface for managing test output files.
  31  *
  32  * @author Erik Brakkee
  33  */
  34 public final class TestData {
  35
  36         private Object _testcase;
  37         private File _root;
  38
  39         /**
  40          * Test data to be constructed in the setUp of a test.
  41          * {@link #clean()} must be called to make sure that this
  42          * directory is empty before executing a test.
  43          */
  44         public TestData(Object aTestcase) {
  45                 _testcase = aTestcase;
  46                 _root = getTestRootDir(aTestcase);
  47         }
  48
  49         /**
  50          * Obtain root directory of JUnit tests.
  51          *
  52          * @return Directory name.
  53          */
  54         private static File getTestRootDir(Object aTestcase) {
  55                 return FileSystemUtils.getTestOutputDir(aTestcase.getClass());
  56         }
  57
  58         /**
  59          * Returns a temporary directory.
  60          *
  61          * @return Temporary directory.
  62          */
  63         public File getTmpDir() {
  64                 return new File(_root, "tmpdir");
  65         }
  66
  67         /**
  68          * Cleans up the test output directory.
  69          */
  70         public void clean() {
  71                 FileSystemUtils.deleteDirRecursively(_root);
  72         }
  73
  74         /**
  75          * Recursively copy a directory contents to the test output directory.
  76          *
  77          * @param sSrc
  78          *            Source directory to copy.
  79          */
  80         public void copyDir(File aSrc) {
  81                 FileSystemUtils.copyDir(aSrc, _root);
  82         }
  83
  84         /**
  85          * Copies a classpath resource to a relative path in the test output
  86          * directory.
  87          *
  88          * @param aResource
  89          *            Resource to copy.
  90          * @param aRelativePath
  91          *            Relative path.
  92          */
  93         public void copyResource(String aResource, String aRelativePath) {
  94                 try {
  95                         InputStream is = new ClassPathResource(aResource).getInputStream();
  96                         FileOutputStream fos = new FileOutputStream(new File(_root,
  97                                         aRelativePath));
  98                         FileSystemUtils.copyStream(is, fos);
  99                 } catch (IOException e) {
 100                         e.printStackTrace();
 101                         Assert.fail(e.getMessage());
 102                 }
 103         }
 104
 105         /**
 106          * Copies a resource to the root directory of the test output.
 107          * @param aResource Resource.
 108          */
 109         public void copyResource(String aResource) {
 110                 String basename = new File(aResource).getName();
 111                 copyResource(aResource, basename);
 112         }
 113
 114         /**
 115          * Deletes a file or directory relative to the test output root.
 116          *
 117          * @param aRelative
 118          *            Relative path. The testcase will fail if the file or directory
 119          *            cannot be removed.
 120          */
 121         public void delete(String aRelative) {
 122                 FileSystemUtils.delete(new File(_root, aRelative));
 123         }
 124
 125         /**
 126          * Deletes a directory including its contents.
 127          * @param aRelative Relative path.
 128          */
 129         public void deleteDir(String aRelative) {
 130                 FileSystemUtils.deleteDir(new File(_root, aRelative));
 131         }
 132
 133         /**
 134          * Deletes a directory recursively.
 135          * @param aRelative Relative path.
 136          */
 137         public void deleteDirRecursively(String aRelative) {
 138                 FileSystemUtils.deleteDir(new File(_root, aRelative));
 139         }
 140
 141         /**
 142          * Gets a file object for a relative path.
 143          */
 144         public File getFile(String aRelative) {
 145                 return new File(_root, aRelative);
 146         }
 147 }