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