src/test/java/org/apache/commons/compress/AbstractTestCase.java - commons-compress - Git at Google

 /*
  * 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 static org.junit.Assert.*;
 import java.io.BufferedInputStream;
 import java.io.Closeable;
 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.net.URI;
 import java.net.URL;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 import java.util.Locale;

 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;
 import org.junit.After;
 import org.junit.Before;

 public abstract class AbstractTestCase {

     protected File dir;
     protected File resultDir;

     private File archive; // used to delete the archive in tearDown
     protected List<String> archiveList; // Lists the content of the archive as originally created

     protected ArchiveStreamFactory factory = new ArchiveStreamFactory();

     @Before
     public void setUp() throws Exception {
         dir = mkdir("dir");
         resultDir = mkdir("dir-result");
         archive = null;
     }

     public static File mkdir(final String name) throws IOException {
         final File f = File.createTempFile(name, "");
         f.delete();
         f.mkdir();
         return f;
     }

     public static File getFile(final String path) throws IOException {
         final URL url = AbstractTestCase.class.getClassLoader().getResource(path);
         if (url == null) {
             throw new FileNotFoundException("couldn't find " + path);
         }
         URI uri = null;
         try {
             uri = url.toURI();
         } catch (final java.net.URISyntaxException ex) {
             throw new IOException(ex);
         }
         return new File(uri);
     }

     @After
     public void tearDown() throws Exception {
         rmdir(dir);
         rmdir(resultDir);
         dir = resultDir = null;
         if (!tryHardToDelete(archive)) {
             // Note: this exception won't be shown if the test has already failed
             throw new Exception("Could not delete "+archive.getPath());
         }
     }

     public static void rmdir(final File f) {
         final String[] s = f.list();
         if (s != null) {
             for (final String element : s) {
                 final File file = new File(f, element);
                 if (file.isDirectory()){
                     rmdir(file);
                 }
                 final boolean ok = tryHardToDelete(file);
                 if (!ok && file.exists()){
                     System.out.println("Failed to delete "+element+" in "+f.getPath());
                 }
             }
         }
         tryHardToDelete(f); // safer to delete and check
         if (f.exists()){
             throw new Error("Failed to delete "+f.getPath());
         }
     }

     private static final boolean ON_WINDOWS =
             System.getProperty("os.name").toLowerCase(Locale.ENGLISH).contains("windows");

     /**
      * Accommodate Windows bug encountered in both Sun and IBM JDKs.
      * Others possible. If the delete does not work, call System.gc(),
      * wait a little and try again.
      *
      * @return whether deletion was successful
      * @since Stolen from FileUtils in Ant 1.8.0
      */
     public static boolean tryHardToDelete(final File f) {
         if (f != null && f.exists() && !f.delete()) {
             if (ON_WINDOWS) {
                 System.gc();
             }
             try {
                 Thread.sleep(10);
             } catch (final InterruptedException ex) {
                 // Ignore Exception
             }
             return f.delete();
         }
         return true;
     }

     /**
      * 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(final String archivename) throws Exception {
         ArchiveOutputStream out = null;
         OutputStream stream = null;
         try {
             archive = File.createTempFile("test", "." + archivename);
             archive.deleteOnExit();
             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(final ArchiveOutputStream out, final String filename, final File infile)
             throws IOException, FileNotFoundException {
         final 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(final String archivename) throws Exception {
         ArchiveOutputStream out = null;
         OutputStream stream = null;
         archiveList = new ArrayList<>();
         try {
             archive = File.createTempFile("empty", "." + archivename);
             archive.deleteOnExit();
             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(final String archivename) throws Exception {
         ArchiveOutputStream out = null;
         OutputStream stream = null;
         archiveList = new ArrayList<>();
         try {
             archive = File.createTempFile("empty", "." + archivename);
             archive.deleteOnExit();
             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(final File archive, final List<String> expected)
             throws Exception {
         try (InputStream is = new FileInputStream(archive)) {
             final BufferedInputStream buf = new BufferedInputStream(is);
             final ArchiveInputStream in = factory.createArchiveInputStream(buf);
             this.checkArchiveContent(in, expected);
         }
     }

     /**
      * 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} if no check of names desired
      * @throws Exception
      */
     protected void checkArchiveContent(final ArchiveInputStream in, final List<String> 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} 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(final ArchiveInputStream in, final List<String> expected, final boolean cleanUp)
             throws Exception {
         final File result = mkdir("dir-result");
         result.deleteOnExit();

         try {
             ArchiveEntry entry = null;
             while ((entry = in.getNextEntry()) != null) {
                 final File outfile = new File(result.getCanonicalPath() + "/result/"
                         + entry.getName());
                 long copied=0;
                 if (entry.isDirectory()){
                     outfile.mkdirs();
                 } else {
                     outfile.getParentFile().mkdirs();
                     try (OutputStream out = new FileOutputStream(outfile)) {
                         copied = IOUtils.copy(in, out);
                     }
                 }
                 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) {
                 fail(expected.size() + " missing entries: " + Arrays.toString(expected.toArray()));
             }
             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(final 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 {
         final File tmpDir = createTempDir();
         final File tmpFile = File.createTempFile("testfile", "", tmpDir);
         tmpFile.deleteOnExit();
         try (FileOutputStream fos = new FileOutputStream(tmpFile)) {
             fos.write(new byte[] { 'f', 'o', 'o' });
             return new File[] { tmpDir, tmpFile };
         }
     }

     protected File createTempDir() throws IOException {
         final File tmpDir = mkdir("testdir");
         tmpDir.deleteOnExit();
         return tmpDir;
     }

     protected void closeQuietly(final Closeable closeable){
         if (closeable != null) {
             try {
                 closeable.close();
             } catch (final IOException ignored) {
                 // ignored
             }
         }
     }

     protected static interface StreamWrapper<I extends InputStream> {
         I wrap(InputStream in) throws Exception;
     }
 }
	/*
	* 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 static org.junit.Assert.*;
	import java.io.BufferedInputStream;
	import java.io.Closeable;
	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.net.URI;
	import java.net.URL;
	import java.util.ArrayList;
	import java.util.Arrays;
	import java.util.List;
	import java.util.Locale;

	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;
	import org.junit.After;
	import org.junit.Before;

	public abstract class AbstractTestCase {

	protected File dir;
	protected File resultDir;

	private File archive; // used to delete the archive in tearDown
	protected List<String> archiveList; // Lists the content of the archive as originally created

	protected ArchiveStreamFactory factory = new ArchiveStreamFactory();

	@Before
	public void setUp() throws Exception {
	dir = mkdir("dir");
	resultDir = mkdir("dir-result");
	archive = null;
	}

	public static File mkdir(final String name) throws IOException {
	final File f = File.createTempFile(name, "");
	f.delete();
	f.mkdir();
	return f;
	}

	public static File getFile(final String path) throws IOException {
	final URL url = AbstractTestCase.class.getClassLoader().getResource(path);
	if (url == null) {
	throw new FileNotFoundException("couldn't find " + path);
	}
	URI uri = null;
	try {
	uri = url.toURI();
	} catch (final java.net.URISyntaxException ex) {
	throw new IOException(ex);
	}
	return new File(uri);
	}

	@After
	public void tearDown() throws Exception {
	rmdir(dir);
	rmdir(resultDir);
	dir = resultDir = null;
	if (!tryHardToDelete(archive)) {
	// Note: this exception won't be shown if the test has already failed
	throw new Exception("Could not delete "+archive.getPath());
	}
	}

	public static void rmdir(final File f) {
	final String[] s = f.list();
	if (s != null) {
	for (final String element : s) {
	final File file = new File(f, element);
	if (file.isDirectory()){
	rmdir(file);
	}
	final boolean ok = tryHardToDelete(file);
	if (!ok && file.exists()){
	System.out.println("Failed to delete "+element+" in "+f.getPath());
	}
	}
	}
	tryHardToDelete(f); // safer to delete and check
	if (f.exists()){
	throw new Error("Failed to delete "+f.getPath());
	}
	}

	private static final boolean ON_WINDOWS =
	System.getProperty("os.name").toLowerCase(Locale.ENGLISH).contains("windows");

	/**
	* Accommodate Windows bug encountered in both Sun and IBM JDKs.
	* Others possible. If the delete does not work, call System.gc(),
	* wait a little and try again.
	*
	* @return whether deletion was successful
	* @since Stolen from FileUtils in Ant 1.8.0
	*/
	public static boolean tryHardToDelete(final File f) {
	if (f != null && f.exists() && !f.delete()) {
	if (ON_WINDOWS) {
	System.gc();
	}
	try {
	Thread.sleep(10);
	} catch (final InterruptedException ex) {
	// Ignore Exception
	}
	return f.delete();
	}
	return true;
	}

	/**
	* 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(final String archivename) throws Exception {
	ArchiveOutputStream out = null;
	OutputStream stream = null;
	try {
	archive = File.createTempFile("test", "." + archivename);
	archive.deleteOnExit();
	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(final ArchiveOutputStream out, final String filename, final File infile)
	throws IOException, FileNotFoundException {
	final 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(final String archivename) throws Exception {
	ArchiveOutputStream out = null;
	OutputStream stream = null;
	archiveList = new ArrayList<>();
	try {
	archive = File.createTempFile("empty", "." + archivename);
	archive.deleteOnExit();
	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(final String archivename) throws Exception {
	ArchiveOutputStream out = null;
	OutputStream stream = null;
	archiveList = new ArrayList<>();
	try {
	archive = File.createTempFile("empty", "." + archivename);
	archive.deleteOnExit();
	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(final File archive, final List<String> expected)
	throws Exception {
	try (InputStream is = new FileInputStream(archive)) {
	final BufferedInputStream buf = new BufferedInputStream(is);
	final ArchiveInputStream in = factory.createArchiveInputStream(buf);
	this.checkArchiveContent(in, expected);
	}
	}

	/**
	* 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} if no check of names desired
	* @throws Exception
	*/
	protected void checkArchiveContent(final ArchiveInputStream in, final List<String> 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} 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(final ArchiveInputStream in, final List<String> expected, final boolean cleanUp)
	throws Exception {
	final File result = mkdir("dir-result");
	result.deleteOnExit();

	try {
	ArchiveEntry entry = null;
	while ((entry = in.getNextEntry()) != null) {
	final File outfile = new File(result.getCanonicalPath() + "/result/"
	+ entry.getName());
	long copied=0;
	if (entry.isDirectory()){
	outfile.mkdirs();
	} else {
	outfile.getParentFile().mkdirs();
	try (OutputStream out = new FileOutputStream(outfile)) {
	copied = IOUtils.copy(in, out);
	}
	}
	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) {
	fail(expected.size() + " missing entries: " + Arrays.toString(expected.toArray()));
	}
	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(final 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 {
	final File tmpDir = createTempDir();
	final File tmpFile = File.createTempFile("testfile", "", tmpDir);
	tmpFile.deleteOnExit();
	try (FileOutputStream fos = new FileOutputStream(tmpFile)) {
	fos.write(new byte[] { 'f', 'o', 'o' });
	return new File[] { tmpDir, tmpFile };
	}
	}

	protected File createTempDir() throws IOException {
	final File tmpDir = mkdir("testdir");
	tmpDir.deleteOnExit();
	return tmpDir;
	}

	protected void closeQuietly(final Closeable closeable){
	if (closeable != null) {
	try {
	closeable.close();
	} catch (final IOException ignored) {
	// ignored
	}
	}
	}

	protected static interface StreamWrapper<I extends InputStream> {
	I wrap(InputStream in) throws Exception;
	}
	}