[utils] /

/*
 * Copyright 2005 the original author or authors.
 * 
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *      http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.wamblee.io;

import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;

import junit.framework.Assert;

/**
 * TestData provides a convenient interface for managing test output files.
 * 
 * @author Erik Brakkee
 */
public final class TestData {

        private Object _testcase;
        private File _root;

        /**
         * Test data to be constructed in the setUp of a test. {@link #clean()} must
         * be called to make sure that this directory is empty before executing a
         * test.
         */
        public TestData(Object aTestcase) {
                _testcase = aTestcase;
                _root = getTestRootDir(aTestcase);
                FileSystemUtils.createDir(_root);
        }

        /**
         * Obtain root directory of JUnit tests.
         * 
         * @return Directory name.
         */
        private static File getTestRootDir(Object aTestcase) {
                return FileSystemUtils.getTestOutputDir(aTestcase.getClass());
        }

        public void createFile(String aRelative, String aFile, InputStream aContents) {
                FileSystemUtils
                                .createFile(new File(_root, aRelative), aFile, aContents);
        }

        public void createFile(String aFile, String aContents) {
                createFile(".", aFile, aContents);
        }

        public void createFile(String aRelative, String aFile, String aContents) {
                InputStream is = new ByteArrayInputStream(aContents.getBytes());
                FileSystemUtils.createFile(new File(_root, aRelative), aFile, is);
        }
        
        public void deleteFile(String aFile) {
                deleteFile(".", aFile);
        }

        public void deleteFile(String aRelative, String aFile) {
                FileSystemUtils.delete(new File(_root, aFile));
        }

        /**
         * Returns a temporary directory.
         * 
         * @return Temporary directory.
         */
        public File getTmpDir() {
                return new File(_root, "tmpdir");
        }

        /**
         * Cleans up the test output directory.
         */
        public void clean() {
                FileSystemUtils.deleteDirRecursively(_root);
                FileSystemUtils.createDir(_root);
        }

        /**
         * Recursively copy a directory contents to the test output directory.
         * 
         * @param sSrc
         *            Source directory to copy.
         */
        public void copyDir(File aSrc) {
                FileSystemUtils.copyDir(aSrc, _root);
        }

        /**
         * Copies a classpath resource to a relative path in the test output
         * directory.
         * 
         * @param aResource
         *            Resource to copy.
         * @param aRelativePath
         *            Relative path.
         */
        public void copyResource(String aResource, String aRelativePath) {
                try {
                        InputStream is = new ClassPathResource(aResource).getInputStream();
                        FileOutputStream fos = new FileOutputStream(new File(_root,
                                        aRelativePath));
                        FileSystemUtils.copyStream(is, fos);
                } catch (IOException e) {
                        e.printStackTrace();
                        Assert.fail(e.getMessage());
                }
        }

        /**
         * Copies a resource to the root directory of the test output.
         * 
         * @param aResource
         *            Resource.
         */
        public void copyResource(String aResource) {
                String basename = new File(aResource).getName();
                copyResource(aResource, basename);
        }

        public void createDir(String aRelative) {
                FileSystemUtils.createDir(new File(_root, aRelative));
        }

        /**
         * Deletes a file or directory relative to the test output root.
         * 
         * @param aRelative
         *            Relative path. The testcase will fail if the file or directory
         *            cannot be removed.
         */
        public void delete(String aRelative) {
                FileSystemUtils.delete(new File(_root, aRelative));
        }

        /**
         * Deletes a directory including its contents.
         * 
         * @param aRelative
         *            Relative path.
         */
        public void deleteDir(String aRelative) {
                FileSystemUtils.deleteDir(new File(_root, aRelative));
        }

        /**
         * Deletes a directory recursively.
         * 
         * @param aRelative
         *            Relative path.
         */
        public void deleteDirRecursively(String aRelative) {
                FileSystemUtils.deleteDir(new File(_root, aRelative));
        }

        /**
         * Gets the root of the test output directory.
         * 
         * @return Root of the test output.
         */
        public File getRoot() {
                return _root;
        }

        /**
         * Gets a file object for a relative path.
         */
        public File getFile(String aRelative) {
                return new File(_root, aRelative);
        }
}