/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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.apache.commons.compress;
import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import junit.framework.TestCase;
import org.apache.commons.compress.archivers.ArchiveEntry;
import org.apache.commons.compress.archivers.ArchiveInputStream;
import org.apache.commons.compress.archivers.ArchiveOutputStream;
import org.apache.commons.compress.archivers.ArchiveStreamFactory;
import org.apache.commons.compress.utils.IOUtils;
public abstract class AbstractTestCase extends TestCase {
protected File dir;
protected File resultDir;
private File archive; // used to delete the archive in tearDown
protected List archiveList; // Lists the content of the archive as originally created
protected ArchiveStreamFactory factory = new ArchiveStreamFactory();
public AbstractTestCase() {
super();
}
public AbstractTestCase(String name) {
super(name);
}
protected void setUp() throws Exception {
dir = mkdir("dir");
resultDir = mkdir("dir-result");
archive = null;
}
protected static File mkdir(String name) throws IOException {
File f = File.createTempFile(name, "");
f.delete();
f.mkdir();
return f;
}
protected File getFile(String path) {
return new File("src/test/resources", path);
}
protected void tearDown() throws Exception {
rmdir(dir);
rmdir(resultDir);
dir = resultDir = null;
if (archive != null && archive.exists()) {
if (!archive.delete()){
// Note: this exception won't be shown if the test has already failed
throw new Exception("Could not delete "+archive.getPath());
}
}
}
protected static void rmdir(File f) {
// Sometimes fails without a pause - perhaps file close is partially asynchronous?
try {
Thread.sleep(20);
} catch (InterruptedException e) {
}
String[] s = f.list();
if (s != null) {
for (int i = 0; i < s.length; i++) {
final File file = new File(f, s[i]);
if (file.isDirectory()){
rmdir(file);
}
boolean ok = file.delete();
if (!ok && file.exists()){
System.out.println("Failed to delete "+s[i]+" in "+f.getPath());
}
}
}
f.delete(); // safer to delete and check
if (f.exists()){
throw new Error("Failed to delete "+f.getPath());
}
}
/**
* Creates an archive of textbased files in several directories. The
* archivername is the factory identifier for the archiver, for example zip,
* tar, cpio, jar, ar. The archive is created as a temp file.
*
* The archive contains the following files:
* <ul>
* <li>testdata/test1.xml</li>
* <li>testdata/test2.xml</li>
* <li>test/test3.xml</li>
* <li>bla/test4.xml</li>
* <li>bla/test5.xml</li>
* <li>bla/blubber/test6.xml</li>
* <li>test.txt</li>
* <li>something/bla</li>
* <li>test with spaces.txt</li>
* </ul>
*
* @param archivename
* the identifier of this archive
* @return the newly created file
* @throws Exception
* in case something goes wrong
*/
protected File createArchive(String archivename) throws Exception {
ArchiveOutputStream out = null;
OutputStream stream = null;
try {
archive = File.createTempFile("test", "." + archivename);
archiveList = new ArrayList();
stream = new FileOutputStream(archive);
out = factory.createArchiveOutputStream(archivename, stream);
final File file1 = getFile("test1.xml");
final File file2 = getFile("test2.xml");
final File file3 = getFile("test3.xml");
final File file4 = getFile("test4.xml");
final File file5 = getFile("test.txt");
final File file6 = getFile("test with spaces.txt");
addArchiveEntry(out, "testdata/test1.xml", file1);
addArchiveEntry(out, "testdata/test2.xml", file2);
addArchiveEntry(out, "test/test3.xml", file3);
addArchiveEntry(out, "bla/test4.xml", file4);
addArchiveEntry(out, "bla/test5.xml", file4);
addArchiveEntry(out, "bla/blubber/test6.xml", file4);
addArchiveEntry(out, "test.txt", file5);
addArchiveEntry(out, "something/bla", file6);
addArchiveEntry(out, "test with spaces.txt", file6);
out.finish();
return archive;
} finally {
if (out != null) {
out.close();
} else if (stream != null) {
stream.close();
}
}
}
/**
* Add an entry to the archive, and keep track of the names in archiveList.
*
* @param out
* @param file1
* @throws IOException
* @throws FileNotFoundException
*/
private void addArchiveEntry(ArchiveOutputStream out, String filename, final File infile)
throws IOException, FileNotFoundException {
ArchiveEntry entry = out.createArchiveEntry(infile, filename);
out.putArchiveEntry(entry);
IOUtils.copy(new FileInputStream(infile), out);
out.closeArchiveEntry();
archiveList.add(filename);
}
/**
* Create an empty archive.
* @param archivename
* @return the archive File
* @throws Exception
*/
protected File createEmptyArchive(String archivename) throws Exception {
ArchiveOutputStream out = null;
OutputStream stream = null;
archiveList = new ArrayList();
try {
archive = File.createTempFile("empty", "." + archivename);
stream = new FileOutputStream(archive);
out = factory.createArchiveOutputStream(archivename, stream);
out.finish();
} finally {
if (out != null) {
out.close();
} else if (stream != null) {
stream.close();
}
}
return archive;
}
/**
* Create an archive with a single file "test1.xml".
*
* @param archivename
* @return the archive File
* @throws Exception
*/
protected File createSingleEntryArchive(String archivename) throws Exception {
ArchiveOutputStream out = null;
OutputStream stream = null;
archiveList = new ArrayList();
try {
archive = File.createTempFile("empty", "." + archivename);
stream = new FileOutputStream(archive);
out = factory.createArchiveOutputStream(archivename, stream);
// Use short file name so does not cause problems for ar
addArchiveEntry(out, "test1.xml", getFile("test1.xml"));
out.finish();
} finally {
if (out != null) {
out.close();
} else if (stream != null) {
stream.close();
}
}
return archive;
}
/**
* Checks if an archive contains all expected files.
*
* @param archive
* the archive to check
* @param expected
* a list with expected string filenames
* @throws Exception
*/
protected void checkArchiveContent(File archive, List expected)
throws Exception {
final InputStream is = new FileInputStream(archive);
try {
final BufferedInputStream buf = new BufferedInputStream(is);
final ArchiveInputStream in = factory.createArchiveInputStream(buf);
this.checkArchiveContent(in, expected);
} finally {
is.close();
}
}
/**
* Checks that an archive input stream can be read, and that the file data matches file sizes.
*
* @param in
* @param expected list of expected entries or <code>null</code> if no check of names desired
* @throws Exception
*/
protected void checkArchiveContent(ArchiveInputStream in, List expected)
throws Exception {
checkArchiveContent(in, expected, true);
}
/**
* Checks that an archive input stream can be read, and that the file data matches file sizes.
*
* @param in
* @param expected list of expected entries or <code>null</code> if no check of names desired
* @param cleanUp Cleans up resources if true
* @return returns the created result file if cleanUp = false, or null otherwise
* @throws Exception
*/
protected File checkArchiveContent(ArchiveInputStream in, List expected, boolean cleanUp)
throws Exception {
File result = File.createTempFile("dir-result", "");
result.delete();
result.mkdir();
try {
ArchiveEntry entry = null;
while ((entry = in.getNextEntry()) != null) {
File outfile = new File(result.getCanonicalPath() + "/result/"
+ entry.getName());
long copied=0;
if (entry.isDirectory()){
outfile.mkdirs();
} else {
outfile.getParentFile().mkdirs();
OutputStream out = new FileOutputStream(outfile);
try {
copied=IOUtils.copy(in, out);
} finally {
out.close();
}
}
final long size = entry.getSize();
if (size != ArchiveEntry.SIZE_UNKNOWN) {
assertEquals("Entry.size should equal bytes read.",size, copied);
}
if (!outfile.exists()) {
fail("extraction failed: " + entry.getName());
}
if (expected != null && !expected.remove(getExpectedString(entry))) {
fail("unexpected entry: " + getExpectedString(entry));
}
}
in.close();
if (expected != null && expected.size() > 0) {
for (Iterator iterator = expected.iterator(); iterator.hasNext();) {
String name = (String) iterator.next();
fail("Expected entry: " + name);
}
}
if (expected != null) {
assertEquals(0, expected.size());
}
} finally {
if (cleanUp) {
rmdir(result);
}
}
return result;
}
/**
* Override this method to change what is to be compared in the List.
* For example, size + name instead of just name.
*
* @param entry
* @return returns the entry name
*/
protected String getExpectedString(ArchiveEntry entry) {
return entry.getName();
}
/**
* Creates a temporary directory and a temporary file inside that
* directory, returns both of them (the directory is the first
* element of the two element array).
*/
protected File[] createTempDirAndFile() throws IOException {
File tmpDir = File.createTempFile("testdir", "");
tmpDir.delete();
tmpDir.mkdir();
tmpDir.deleteOnExit();
File tmpFile = File.createTempFile("testfile", "", tmpDir);
tmpFile.deleteOnExit();
FileOutputStream fos = new FileOutputStream(tmpFile);
try {
fos.write(new byte[] {'f', 'o', 'o'});
return new File[] {tmpDir, tmpFile};
} finally {
fos.close();
}
}
}