Add support for compressed handles

src/main/java/org/scijava/io/handle/BZip2Handle.java

@@ -0,0 +1,64 @@
+/*
+ * #%L
+ * SciJava Common shared library for SciJava software.
+ * %%
+ * Copyright (C) 2009 - 2017 Board of Regents of the University of
+ * Wisconsin-Madison, Broad Institute of MIT and Harvard, and Max Planck
+ * Institute of Molecular Cell Biology and Genetics.
+ * %%
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ * #L%
+ */
+
+package org.scijava.io.handle;
+
+import java.io.IOException;
+
+import org.scijava.io.handle.bzip2.CBZip2InputStream;
+import org.scijava.io.location.AbstractCompressedHandle;
+import org.scijava.io.location.BZip2Location;
+import org.scijava.plugin.Plugin;
+
+/**
+ * {@link DataHandle} for a {@link BZip2Location}.
+ *
+ * @author Gabriel Einsdorf
+ */
+@Plugin(type = DataHandle.class)
+public class BZip2Handle extends AbstractCompressedHandle<BZip2Location> {
+
+	@Override
+	protected void initInputStream() throws IOException {
+
+		int skipped = 0;
+		// ensure 2 bytes are skipped
+		while (skipped < 2) {
+			skipped += raw().skip(2l - skipped);
+		}
+		inputStream = new CBZip2InputStream(raw(), log());
+	}
+
+	@Override
+	public Class<BZip2Location> getType() {
+		return BZip2Location.class;
+	}
+}

src/main/java/org/scijava/io/handle/BufferedStreamHandle.java

@@ -0,0 +1,45 @@
+/*
+ * #%L
+ * SciJava Common shared library for SciJava software.
+ * %%
+ * Copyright (C) 2009 - 2017 Board of Regents of the University of
+ * Wisconsin-Madison, Broad Institute of MIT and Harvard, and Max Planck
+ * Institute of Molecular Cell Biology and Genetics.
+ * %%
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ * #L%
+ */
+
+package org.scijava.io.handle;
+
+import org.scijava.io.location.Location;
+
+/**
+ * A buffered {@link StreamHandle}.
+ * 
+ * @author Gabriel Einsdorf
+ */
+public interface BufferedStreamHandle<L extends Location> extends
+	SeekableStreamHandle<L>
+{
+
+}

src/main/java/org/scijava/io/handle/DefaultBufferedStreamHandle.java

@@ -0,0 +1,239 @@
+/*
+ * #%L
+ * SciJava Common shared library for SciJava software.
+ * %%
+ * Copyright (C) 2009 - 2017 Board of Regents of the University of
+ * Wisconsin-Madison, Broad Institute of MIT and Harvard, and Max Planck
+ * Institute of Molecular Cell Biology and Genetics.
+ * %%
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ * #L%
+ */
+
+package org.scijava.io.handle;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+
+import org.scijava.io.ByteArrayByteBank;
+import org.scijava.io.ByteBank;
+import org.scijava.io.location.Location;
+
+/**
+ * A {@link BufferedStreamHandle} backed by a {@link ByteBank}.
+ * 
+ * @author Gabriel Einsdorf
+ */
+public class DefaultBufferedStreamHandle<L extends Location> extends
+	AbstractStreamHandle<L> implements BufferedStreamHandle<L>
+{
+
+	private static final int CHUNK_SIZE = 8192;
+
+	private final StreamHandle<L> handle;
+	private ByteBank buffer;
+
+	private InputStream inStreamProxy;
+	private OutputStream outStreamProxy;
+
+	private boolean closed;
+
+	/**
+	 * Wraps around StreamHandle in a buffer
+	 *
+	 * @param handle
+	 */
+	public DefaultBufferedStreamHandle(final StreamHandle<L> handle) {
+		this.handle = handle;
+	}
+
+	@Override
+	public byte readByte() throws IOException {
+
+		// reached end of the buffer
+		if (offset() == handle.length()) {
+			return -1;
+		}
+
+		// check if we need to refill the buffer
+		if (offset() > maxBuf() || maxBuf() == -1) {
+			// buffer more bytes
+			final int filled = fill();
+			if (filled <= 0) {
+				// no more bytes in input handle
+				return -1;
+			}
+		}
+
+		byte b = getBufferIfOpen().getByte(offset());
+		advance(1);
+		return b;
+	}
+
+	@Override
+	public void seek(final long pos) throws IOException {
+		final long off = offset();
+		if (off == pos) return;
+		if (pos > off) {
+			// ensure target is buffered
+			while (pos > maxBuf()) {
+				fill();
+			}
+		}
+		// values in the range (pos < off) are already buffered
+		setOffset(pos);
+	}
+
+	private long maxBuf() throws IOException {
+		return getBufferIfOpen().size() - 1;
+	}
+
+	@Override
+	public long skip(final long n) throws IOException {
+		seek(offset() + n);
+		return handle().skip(n);
+	}
+
+	@Override
+	public int read(final byte[] b, final int off, final int len)
+		throws IOException
+	{
+
+		while (maxBuf() < offset() + len) {
+			final int filled = fill();
+			if (filled <= 0) {
+				// no more bytes available
+				break;
+			}
+		}
+
+		// read all available bytes
+		int available = (int) available(len);
+		getBufferIfOpen().getBytes(offset(), b, off, available);
+		setOffset(offset() + available);
+		return available;
+	}
+
+	/**
+	 * Fills the buffer with XX more bytes
+	 *
+	 * @throws IOException
+	 */
+	private int fill() throws IOException {
+		final byte[] buf = new byte[CHUNK_SIZE];
+		final int read = handle().read(buf);
+		if (read <= 0) {
+			return -1;
+		}
+		getBufferIfOpen().appendBytes(buf, read);
+		return read;
+	}
+
+	@Override
+	public InputStream in() {
+		if (inStreamProxy == null) {
+			inStreamProxy = new DataHandleInputStream<>(this);
+		}
+		return inStreamProxy;
+	}
+
+	@Override
+	public OutputStream out() {
+		if (outStreamProxy == null) {
+			outStreamProxy = new DataHandleOutputStream<>(this);
+		}
+		return outStreamProxy;
+	}
+
+	@Override
+	public long length() throws IOException {
+		return handle().length();
+	}
+
+	private StreamHandle<L> handle() throws IOException {
+		if (closed) {
+			throw new IOException("Handle is closed!");
+		}
+		return handle;
+	}
+
+	@Override
+	public void setLength(final long length) throws IOException {
+		handle().setLength(length);
+	}
+
+	@Override
+	public boolean isReadable() {
+		return !closed && handle.isReadable();
+	}
+
+	@Override
+	public boolean isWritable() {
+		return !closed && handle.isWritable();
+	}
+
+	@Override
+	public boolean exists() throws IOException {
+		return handle.exists();
+	}
+
+	@Override
+	public Class<L> getType() {
+		return handle.getType();
+	}
+
+	@Override
+	public void resetStream() throws IOException {
+		getBufferIfOpen();
+		if (handle() instanceof ResettableStreamHandle) {
+			((ResettableStreamHandle<L>) handle()).resetStream();
+		}
+		else {
+			throw new IOException("Handle can not be reset!");
+		}
+	}
+
+	@Override
+	public void close() throws IOException {
+		if (!closed) {
+			closed = true;
+			handle().close();
+			getBufferIfOpen().clear();
+			buffer = null;
+		}
+	}
+
+	/**
+	 * @return the buffer used in this handle
+	 * @throws IOException if this handle has been closed
+	 */
+	private ByteBank getBufferIfOpen() throws IOException {
+		if (closed) {
+			throw new IOException("Handle is closed");
+		}
+		if (buffer == null) {
+			buffer = new ByteArrayByteBank();
+		}
+		return buffer;
+	}
+}

src/main/java/org/scijava/io/handle/GZipHandle.java

@@ -0,0 +1,68 @@
+/*
+ * #%L
+ * SCIFIO library for reading and converting scientific file formats.
+ * %%
+ * Copyright (C) 2011 - 2016 Board of Regents of the University of
+ * Wisconsin-Madison
+ * %%
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ * #L%
+ */
+
+package org.scijava.io.handle;
+
+import java.io.IOException;
+import java.util.zip.GZIPInputStream;
+
+import org.scijava.io.location.AbstractCompressedHandle;
+import org.scijava.io.location.GZipLocation;
+import org.scijava.plugin.Plugin;
+
+/**
+ * StreamHandle implementation for reading from gzip-compressed files or byte
+ * arrays. Instances of GZipHandle are read-only.
+ *
+ * @author Melissa Linkert
+ * @author Gabriel Einsdorf
+ */
+@Plugin(type = DataHandle.class)
+public class GZipHandle extends AbstractCompressedHandle<GZipLocation> {
+
+	@Override
+	public Class<GZipLocation> getType() {
+		return GZipLocation.class;
+	}
+
+	@Override
+	protected void initInputStream() throws IOException {
+		inputStream = new GZIPInputStream(new DataHandleInputStream<>(raw()));
+	}
+
+//	@Override
+//	public boolean isConstructable(final String file) throws IOException {
+//		final byte[] b = new byte[2];
+//		s.read(b);
+//		s.close();
+//		return Bytes.toInt(b, true) == GZIPInputStream.GZIP_MAGIC;
+//	}
+
+}

src/main/java/org/scijava/io/handle/ZipHandle.java

@@ -0,0 +1,201 @@
+/*
+ * #%L
+ * SCIFIO library for reading and converting scientific file formats.
+ * %%
+ * Copyright (C) 2011 - 2016 Board of Regents of the University of
+ * Wisconsin-Madison
+ * %%
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ * #L%
+ */
+
+package org.scijava.io.handle;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipInputStream;
+
+import org.scijava.io.location.AbstractCompressedHandle;
+import org.scijava.io.location.Location;
+import org.scijava.io.location.ZipLocation;
+import org.scijava.plugin.Plugin;
+
+/**
+ * StreamHandle implementation for reading from Zip-compressed files or byte
+ * arrays. Instances of ZipHandle are read-only.
+ *
+ * @see StreamHandle
+ * @author Melissa Linkert
+ * @author Gabriel Einsdorf
+ */
+@Plugin(type = DataHandle.class)
+public class ZipHandle extends AbstractCompressedHandle<ZipLocation> {
+
+	// -- Fields --
+
+	private DataHandle<Location> in;
+
+	private String entryName;
+
+	private ZipEntry entry;
+
+	private long entryLength = -1l;
+
+	// -- ZipHandle API methods --
+
+	/** Get the name of the backing Zip entry. */
+	public String getEntryName() {
+		return entryName;
+	}
+
+	@Override
+	public void resetStream() throws IOException {
+
+		if (raw() instanceof ResettableStreamHandle<?>) {
+			((ResettableStreamHandle<?>) raw()).resetStream();
+		}
+		else {
+			raw().seek(0l);
+		}
+
+		inputStream = new ZipInputStream(new DataHandleInputStream<>(raw()));
+		// FIXME add Buffering
+
+		seekToEntry();
+
+	}
+
+	// -- IRandomAccess API methods --
+
+	@Override
+	public void close() throws IOException {
+		inputStream = null;
+		entryName = null;
+		entryLength = -1;
+		if (in != null) in.close();
+		in = null;
+	}
+
+	// -- Helper methods --
+
+	/**
+	 * Seeks to the relevant ZIP entry, populating the stream length accordingly.
+	 */
+	private void seekToEntry() throws IOException {
+
+		while (true) {
+			final ZipEntry e = ((ZipInputStream) inputStream).getNextEntry();
+			if (entryName == null) {
+				entry = e;
+				entryName = e.getName();
+			}
+			if (entryName.equals(e.getName())) {
+				// found the matching entry name (or first entry if the name is
+				// null)
+				if (entryLength < 0) {
+					final boolean resetNeeded = populateLength(e.getSize());
+					if (resetNeeded) {
+						// stream length was calculated by force, need to reset
+						resetStream();
+					}
+				}
+				break;
+			}
+		}
+	}
+
+	/**
+	 * Sets the stream length, computing it by force if necessary.
+	 *
+	 * @return if the Stream needs to be reset
+	 */
+	private boolean populateLength(final long size) throws IOException {
+		if (size >= 0) {
+			entryLength = size;
+			return false;
+		}
+		// size is unknown, so we must read the stream manually
+		long length = 0;
+		final DataHandle<Location> stream = raw();
+		while (true) {
+			final long skipped = stream.skip(Long.MAX_VALUE);
+			if (skipped == 0) {
+				// NB: End of stream, we hope. Technically there is no contract
+				// for when skip(long) returns 0, but in practice it seems to be
+				// when end of stream is reached.
+				break;
+			}
+			length += skipped;
+		}
+
+		entryLength = length;
+		return true;
+	}
+
+	@Override
+	public Class<ZipLocation> getType() {
+		return ZipLocation.class;
+	}
+
+	@Override
+	protected void initInputStream() throws IOException {
+		inputStream = new ZipInputStream(new DataHandleInputStream<>(raw()));
+
+		entry = get().getEntry();
+		if (entry == null) {
+			// strip off .zip extension and directory prefix
+			final String n = raw().get().getName();
+			String name = n.substring(0, n.length() - 4);
+
+			int slash = name.lastIndexOf(File.separator);
+			if (slash < 0) slash = name.lastIndexOf("/");
+			if (slash >= 0) name = name.substring(slash + 1);
+
+			// look for Zip entry with same prefix as the Zip file itself
+			boolean matchFound = false;
+			ZipEntry ze;
+			while ((ze = ((ZipInputStream) inputStream).getNextEntry()) != null) {
+				if (entryName == null) entryName = ze.getName();
+				if (!matchFound && ze.getName().startsWith(name)) {
+					// found entry with matching name
+					entryName = ze.getName();
+					entry = ze;
+					matchFound = true;
+				}
+			}
+			resetStream();
+		}
+	}
+
+	@Override
+	public long length() throws IOException {
+		if (entry == null) {
+			return -1;
+		}
+		return entry.getSize();
+	}
+
+	public long getEntryLength() {
+		return entryLength;
+	}
+}

src/main/java/org/scijava/io/handle/bzip2/CRC.java

@@ -0,0 +1,141 @@
+/*
+ * #%L
+ * SCIFIO library for reading and converting scientific file formats.
+ * %%
+ * Copyright (C) 2011 - 2016 Board of Regents of the University of
+ * Wisconsin-Madison
+ * %%
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ * #L%
+ */
+
+/*
+ * Copyright  2001-2002,2004 The Apache Software Foundation
+ *
+ * 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.
+ */
+
+/*
+ * This package is based on the work done by Keiron Liddle, Aftex Software
+ * <keiron@aftexsw.com> to whom the Ant project is very grateful for his
+ * great code.
+ */
+
+package org.scijava.io.handle.bzip2;
+
+/** Holds and calculates a CRC for verifying data integrity. */
+public class CRC {
+
+	// -- Constants --
+
+	public static final int[] CRC_32_TABLE = { 0x00000000, 0x04c11db7, 0x09823b6e,
+		0x0d4326d9, 0x130476dc, 0x17c56b6b, 0x1a864db2, 0x1e475005, 0x2608edb8,
+		0x22c9f00f, 0x2f8ad6d6, 0x2b4bcb61, 0x350c9b64, 0x31cd86d3, 0x3c8ea00a,
+		0x384fbdbd, 0x4c11db70, 0x48d0c6c7, 0x4593e01e, 0x4152fda9, 0x5f15adac,
+		0x5bd4b01b, 0x569796c2, 0x52568b75, 0x6a1936c8, 0x6ed82b7f, 0x639b0da6,
+		0x675a1011, 0x791d4014, 0x7ddc5da3, 0x709f7b7a, 0x745e66cd, 0x9823b6e0,
+		0x9ce2ab57, 0x91a18d8e, 0x95609039, 0x8b27c03c, 0x8fe6dd8b, 0x82a5fb52,
+		0x8664e6e5, 0xbe2b5b58, 0xbaea46ef, 0xb7a96036, 0xb3687d81, 0xad2f2d84,
+		0xa9ee3033, 0xa4ad16ea, 0xa06c0b5d, 0xd4326d90, 0xd0f37027, 0xddb056fe,
+		0xd9714b49, 0xc7361b4c, 0xc3f706fb, 0xceb42022, 0xca753d95, 0xf23a8028,
+		0xf6fb9d9f, 0xfbb8bb46, 0xff79a6f1, 0xe13ef6f4, 0xe5ffeb43, 0xe8bccd9a,
+		0xec7dd02d, 0x34867077, 0x30476dc0, 0x3d044b19, 0x39c556ae, 0x278206ab,
+		0x23431b1c, 0x2e003dc5, 0x2ac12072, 0x128e9dcf, 0x164f8078, 0x1b0ca6a1,
+		0x1fcdbb16, 0x018aeb13, 0x054bf6a4, 0x0808d07d, 0x0cc9cdca, 0x7897ab07,
+		0x7c56b6b0, 0x71159069, 0x75d48dde, 0x6b93dddb, 0x6f52c06c, 0x6211e6b5,
+		0x66d0fb02, 0x5e9f46bf, 0x5a5e5b08, 0x571d7dd1, 0x53dc6066, 0x4d9b3063,
+		0x495a2dd4, 0x44190b0d, 0x40d816ba, 0xaca5c697, 0xa864db20, 0xa527fdf9,
+		0xa1e6e04e, 0xbfa1b04b, 0xbb60adfc, 0xb6238b25, 0xb2e29692, 0x8aad2b2f,
+		0x8e6c3698, 0x832f1041, 0x87ee0df6, 0x99a95df3, 0x9d684044, 0x902b669d,
+		0x94ea7b2a, 0xe0b41de7, 0xe4750050, 0xe9362689, 0xedf73b3e, 0xf3b06b3b,
+		0xf771768c, 0xfa325055, 0xfef34de2, 0xc6bcf05f, 0xc27dede8, 0xcf3ecb31,
+		0xcbffd686, 0xd5b88683, 0xd1799b34, 0xdc3abded, 0xd8fba05a, 0x690ce0ee,
+		0x6dcdfd59, 0x608edb80, 0x644fc637, 0x7a089632, 0x7ec98b85, 0x738aad5c,
+		0x774bb0eb, 0x4f040d56, 0x4bc510e1, 0x46863638, 0x42472b8f, 0x5c007b8a,
+		0x58c1663d, 0x558240e4, 0x51435d53, 0x251d3b9e, 0x21dc2629, 0x2c9f00f0,
+		0x285e1d47, 0x36194d42, 0x32d850f5, 0x3f9b762c, 0x3b5a6b9b, 0x0315d626,
+		0x07d4cb91, 0x0a97ed48, 0x0e56f0ff, 0x1011a0fa, 0x14d0bd4d, 0x19939b94,
+		0x1d528623, 0xf12f560e, 0xf5ee4bb9, 0xf8ad6d60, 0xfc6c70d7, 0xe22b20d2,
+		0xe6ea3d65, 0xeba91bbc, 0xef68060b, 0xd727bbb6, 0xd3e6a601, 0xdea580d8,
+		0xda649d6f, 0xc423cd6a, 0xc0e2d0dd, 0xcda1f604, 0xc960ebb3, 0xbd3e8d7e,
+		0xb9ff90c9, 0xb4bcb610, 0xb07daba7, 0xae3afba2, 0xaafbe615, 0xa7b8c0cc,
+		0xa379dd7b, 0x9b3660c6, 0x9ff77d71, 0x92b45ba8, 0x9675461f, 0x8832161a,
+		0x8cf30bad, 0x81b02d74, 0x857130c3, 0x5d8a9099, 0x594b8d2e, 0x5408abf7,
+		0x50c9b640, 0x4e8ee645, 0x4a4ffbf2, 0x470cdd2b, 0x43cdc09c, 0x7b827d21,
+		0x7f436096, 0x7200464f, 0x76c15bf8, 0x68860bfd, 0x6c47164a, 0x61043093,
+		0x65c52d24, 0x119b4be9, 0x155a565e, 0x18197087, 0x1cd86d30, 0x029f3d35,
+		0x065e2082, 0x0b1d065b, 0x0fdc1bec, 0x3793a651, 0x3352bbe6, 0x3e119d3f,
+		0x3ad08088, 0x2497d08d, 0x2056cd3a, 0x2d15ebe3, 0x29d4f654, 0xc5a92679,
+		0xc1683bce, 0xcc2b1d17, 0xc8ea00a0, 0xd6ad50a5, 0xd26c4d12, 0xdf2f6bcb,
+		0xdbee767c, 0xe3a1cbc1, 0xe760d676, 0xea23f0af, 0xeee2ed18, 0xf0a5bd1d,
+		0xf464a0aa, 0xf9278673, 0xfde69bc4, 0x89b8fd09, 0x8d79e0be, 0x803ac667,
+		0x84fbdbd0, 0x9abc8bd5, 0x9e7d9662, 0x933eb0bb, 0x97ffad0c, 0xafb010b1,
+		0xab710d06, 0xa6322bdf, 0xa2f33668, 0xbcb4666d, 0xb8757bda, 0xb5365d03,
+		0xb1f740b4 };
+
+	// -- Fields --
+
+	private int globalCrc;
+
+	// -- Constructor --
+
+	public CRC() {
+		initialiseCRC();
+	}
+
+	// -- CRC API methods --
+
+	public void initialiseCRC() {
+		globalCrc = 0xffffffff;
+	}
+
+	public int getFinalCRC() {
+		return ~globalCrc;
+	}
+
+	public int getGlobalCRC() {
+		return globalCrc;
+	}
+
+	public void setGlobalCRC(final int newCrc) {
+		globalCrc = newCrc;
+	}
+
+	public void updateCRC(final int inCh) {
+		int temp = (globalCrc >> 24) ^ inCh;
+		if (temp < 0) {
+			temp = 256 + temp;
+		}
+		globalCrc = (globalCrc << 8) ^ CRC.CRC_32_TABLE[temp];
+	}
+
+}

src/main/java/org/scijava/io/location/AbstractCompressedHandle.java

@@ -0,0 +1,133 @@
+/*
+ * #%L
+ * SciJava Common shared library for SciJava software.
+ * %%
+ * Copyright (C) 2009 - 2017 Board of Regents of the University of
+ * Wisconsin-Madison, Broad Institute of MIT and Harvard, and Max Planck
+ * Institute of Molecular Cell Biology and Genetics.
+ * %%
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ * #L%
+ */
+
+package org.scijava.io.location;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+
+import org.scijava.io.handle.AbstractStreamHandle;
+import org.scijava.io.handle.DataHandle;
+import org.scijava.io.handle.DataHandleService;
+import org.scijava.io.handle.ResettableStreamHandle;
+import org.scijava.plugin.Parameter;
+
+/**
+ * Abstract superclass for {@link DataHandle}s that operate on compressed data.
+ *
+ * @author Gabriel Einsdorf
+ */
+public abstract class AbstractCompressedHandle<L extends AbstractHigherOrderLocation>
+	extends AbstractStreamHandle<L> implements ResettableStreamHandle<L>
+{
+
+	private DataHandle<Location> rawHandle;
+	protected InputStream inputStream;
+
+	@Parameter
+	private DataHandleService dataHandleService;
+
+	public AbstractCompressedHandle() {
+		super();
+	}
+
+	@Override
+	public void resetStream() throws IOException {
+
+		if (raw() instanceof ResettableStreamHandle<?>) {
+			((ResettableStreamHandle<Location>) rawHandle).resetStream();
+		}
+		else {
+			rawHandle.seek(0);
+		}
+		initInputStream();
+	}
+
+	@Override
+	public InputStream in() throws IOException {
+		if (inputStream == null) {
+			initInputStream();
+		}
+		return inputStream;
+	}
+
+	@Override
+	public long skip(long n) throws IOException {
+		long skipped = in().skip(n);
+		setOffset(offset() + skipped);
+		return skipped; 
+	}
+
+	protected abstract void initInputStream() throws IOException;
+
+	@Override
+	public OutputStream out() throws IOException {
+		return null;
+	}
+
+	@Override
+	public boolean isWritable() {
+		return false;
+	}
+
+	@Override
+	public boolean isReadable() {
+		return true;
+	}
+
+	@Override
+	public long length() throws IOException {
+		return raw().length();
+	}
+
+	@Override
+	public boolean exists() throws IOException {
+		return raw().exists();
+	}
+
+	@Override
+	public void setLength(long length) throws IOException {
+		throw new IOException("This handle " + this.getClass().getSimpleName() +
+			" is read-only!");
+	}
+
+	/**
+	 * @return the raw underlying DataHandle (not decompressed)
+	 */
+	protected DataHandle<Location> raw() {
+		if (rawHandle == null) {
+			rawHandle = dataHandleService.create(get().getBaseLocation());
+		}
+		return rawHandle;
+	}
+
+}

src/main/java/org/scijava/io/location/AbstractHigherOrderLocation.java

@@ -0,0 +1,52 @@
+/*
+ * #%L
+ * SciJava Common shared library for SciJava software.
+ * %%
+ * Copyright (C) 2009 - 2017 Board of Regents of the University of
+ * Wisconsin-Madison, Broad Institute of MIT and Harvard, Max Planck
+ * Institute of Molecular Cell Biology and Genetics, University of
+ * Konstanz, and KNIME GmbH.
+ * %%
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ * #L%
+ */
+
+package org.scijava.io.location;
+
+/**
+ * Abstract superclass for {@link Location} implementations that wrap other
+ * locations.
+ * 
+ * @author Gabriel Einsdorf
+ */
+public abstract class AbstractHigherOrderLocation implements Location {
+
+	private final Location baseLocation;
+
+	public AbstractHigherOrderLocation(final Location location) {
+		this.baseLocation = location;
+	}
+
+	public Location getBaseLocation() {
+		return baseLocation;
+	}
+}

src/main/java/org/scijava/io/location/BZip2Location.java

@@ -0,0 +1,24 @@
+
+package org.scijava.io.location;
+
+import org.scijava.io.handle.BZip2Handle;
+import org.scijava.io.handle.DataHandle;
+
+/**
+ * {@link Location} backed by a {@link DataHandle} that is BZip2 compressed.
+ * 
+ * @author Gabriel Einsdorf
+ * @see BZip2Handle
+ */
+public class BZip2Location extends AbstractHigherOrderLocation {
+
+	/**
+	 * Creates a {@link BZip2Location} wrapping the given location
+	 *
+	 * @param location the location to operate on
+	 */
+	public BZip2Location(final Location location) {
+		super(location);
+	}
+
+}

src/main/java/org/scijava/io/location/GZipLocation.java

@@ -0,0 +1,20 @@
+
+package org.scijava.io.location;
+
+import org.scijava.io.handle.DataHandle;
+import org.scijava.io.handle.GZipHandle;
+
+/**
+ * {@link Location} backed by a {@link DataHandle} that is <code>gzip</code>
+ * compressed.
+ * 
+ * @author Gabriel Einsdorf
+ * @see GZipHandle
+ */
+public class GZipLocation extends AbstractHigherOrderLocation {
+
+	public GZipLocation(Location location) {
+		super(location);
+	}
+
+}

src/main/java/org/scijava/io/location/ZipLocation.java

@@ -0,0 +1,86 @@
+/*
+ * #%L
+ * SciJava Common shared library for SciJava software.
+ * %%
+ * Copyright (C) 2009 - 2017 Board of Regents of the University of
+ * Wisconsin-Madison, Broad Institute of MIT and Harvard, and Max Planck
+ * Institute of Molecular Cell Biology and Genetics.
+ * %%
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ * #L%
+ */
+
+package org.scijava.io.location;
+
+import java.util.zip.ZipEntry;
+
+import org.scijava.io.handle.DataHandle;
+import org.scijava.io.handle.ZipHandle;
+import org.scijava.plugin.Plugin;
+
+/**
+ * {@link Location} backed by a {@link DataHandle} that is <code>zip</code>
+ * compressed.
+ * 
+ * @author Gabriel Einsdorf
+ * @see ZipHandle
+ */
+@Plugin(type = DataHandle.class)
+public class ZipLocation extends AbstractHigherOrderLocation {
+
+	private ZipEntry entry;
+
+	public ZipLocation(Location location) {
+		super(location);
+	}
+
+	public ZipLocation(Location location, ZipEntry entry) {
+		super(location);
+		this.entry = entry;
+	}
+
+	public ZipEntry getEntry() {
+		return entry;
+	}
+
+	@Override
+	public int hashCode() {
+		final int prime = 31;
+		int result = super.hashCode();
+		result = prime * result + ((entry == null) ? 0 : entry.hashCode());
+		return result;
+	}
+
+	@Override
+	public boolean equals(Object obj) {
+		if (this == obj) return true;
+		if (!super.equals(obj)) return false;
+		if (getClass() != obj.getClass()) return false;
+		ZipLocation other = (ZipLocation) obj;
+		if (entry == null) {
+			if (other.entry != null) return false;
+		}
+		else if (!entry.equals(other.entry)) return false;
+		return true;
+	}
+
+}

src/test/java/org/scijava/io/handle/BZip2HandleTest.java

@@ -0,0 +1,97 @@
+/*
+ * #%L
+ * SciJava Common shared library for SciJava software.
+ * %%
+ * Copyright (C) 2009 - 2017 Board of Regents of the University of
+ * Wisconsin-Madison, Broad Institute of MIT and Harvard, and Max Planck
+ * Institute of Molecular Cell Biology and Genetics.
+ * %%
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ * #L%
+ */
+
+package org.scijava.io.handle;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+
+import org.junit.Ignore;
+import org.junit.Test;
+import org.scijava.io.handle.DataHandle;
+import org.scijava.io.location.BZip2Location;
+import org.scijava.io.location.FileLocation;
+import org.scijava.io.location.Location;
+
+/**
+ * Tests {@link BZip2Handle}.
+ *
+ * @author Gabriel Einsdorf
+ */
+public class BZip2HandleTest extends DataHandleTest {
+
+	@Override
+	public Class<? extends DataHandle<?>> getExpectedHandleType() {
+		return BZip2Handle.class;
+	}
+
+	@Override
+	public Location createLocation() throws IOException {
+		// create and populate a temp file
+		final File tmpFile = File.createTempFile("FileHandleTest", "test-file");
+		tmpFile.deleteOnExit();
+
+		try (FileOutputStream out = new FileOutputStream(tmpFile)) {
+			populateData(out);
+		}
+
+		final Runtime rt = Runtime.getRuntime();
+		final Process p = rt.exec(new String[] { "bzip2", tmpFile
+			.getAbsolutePath() });
+		try {
+			p.waitFor();
+		}
+		catch (final InterruptedException e) {
+			throw new RuntimeException(e);
+		}
+		final File bzip2File = new File(tmpFile.getAbsolutePath() + ".bz2");
+		bzip2File.deleteOnExit();
+
+		return new BZip2Location(new FileLocation(bzip2File));
+	}
+
+	@Test
+	@Override
+	public void testWriting() throws IOException {
+		// no Op
+	}
+
+	@Override
+	@Test
+	public void testReading() throws IOException {
+		try (final DataHandle<? extends Location> handle = createHandle()) {
+			checkBasicReadMethods(handle, false);
+			checkEndiannessReading(handle);
+		}
+	}
+
+}

src/test/java/org/scijava/io/handle/GZipHandleTest.java

@@ -0,0 +1,87 @@
+/*
+ * #%L
+ * SciJava Common shared library for SciJava software.
+ * %%
+ * Copyright (C) 2009 - 2017 Board of Regents of the University of
+ * Wisconsin-Madison, Broad Institute of MIT and Harvard, and Max Planck
+ * Institute of Molecular Cell Biology and Genetics.
+ * %%
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ * #L%
+ */
+
+package org.scijava.io.handle;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.util.zip.GZIPOutputStream;
+
+import org.junit.Ignore;
+import org.junit.Test;
+import org.scijava.io.location.FileLocation;
+import org.scijava.io.location.GZipLocation;
+import org.scijava.io.location.Location;
+
+/**
+ * Tests {@link GZipHandle}.
+ *
+ * @author Gabriel Einsdorf
+ */
+public class GZipHandleTest extends DataHandleTest {
+
+	@Override
+	public Class<? extends DataHandle<?>> getExpectedHandleType() {
+		return GZipHandle.class;
+	}
+
+	@Override
+	public Location createLocation() throws IOException {
+		// create and populate a temp file
+		final File tmpFile = File.createTempFile("FileHandleTest",
+			"test-file.gzip");
+		tmpFile.deleteOnExit();
+
+		try (GZIPOutputStream out = new GZIPOutputStream(new FileOutputStream(
+			tmpFile)))
+		{
+			populateData(out);
+		}
+
+		return new GZipLocation(new FileLocation(tmpFile));
+	}
+
+	@Test
+	@Override
+	public void testWriting() throws IOException {
+		// no Op
+	}
+
+	@Override
+	@Test
+	public void testReading() throws IOException {
+		try (final DataHandle<? extends Location> handle = createHandle()) {
+			checkBasicReadMethods(handle, false);
+			checkEndiannessReading(handle);
+		}
+	}
+}

src/test/java/org/scijava/io/handle/ZipHandleTest.java

@@ -0,0 +1,89 @@
+/*
+ * #%L
+ * SciJava Common shared library for SciJava software.
+ * %%
+ * Copyright (C) 2009 - 2017 Board of Regents of the University of
+ * Wisconsin-Madison, Broad Institute of MIT and Harvard, and Max Planck
+ * Institute of Molecular Cell Biology and Genetics.
+ * %%
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ * #L%
+ */
+
+package org.scijava.io.handle;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipOutputStream;
+
+import org.junit.Ignore;
+import org.junit.Test;
+import org.scijava.io.handle.DataHandle;
+import org.scijava.io.location.FileLocation;
+import org.scijava.io.location.Location;
+import org.scijava.io.location.ZipLocation;
+
+/**
+ * Tests {@link ZipHandle}.
+ *
+ * @author Gabriel Einsdorf
+ */
+public class ZipHandleTest extends DataHandleTest {
+
+	@Override
+	public Class<? extends DataHandle<?>> getExpectedHandleType() {
+		return ZipHandle.class;
+	}
+
+	@Override
+	public Location createLocation() throws IOException {
+		// create and populate a temp file
+		final File tmpFile = File.createTempFile("FileHandleTest", "test-file.zip");
+		tmpFile.deleteOnExit();
+
+		try (ZipOutputStream out = new ZipOutputStream(new FileOutputStream(
+			tmpFile)))
+		{
+			out.putNextEntry(new ZipEntry(tmpFile.getName()));
+			populateData(out);
+		}
+
+		return new ZipLocation(new FileLocation(tmpFile));
+	}
+
+	@Test
+	@Override
+	public void testWriting() throws IOException {
+		// no Op
+	}
+
+	@Override
+	@Test
+	public void testReading() throws IOException {
+		try (final DataHandle<? extends Location> handle = createHandle()) {
+			checkBasicReadMethods(handle, false);
+			checkEndiannessReading(handle);
+		}
+	}
+}

src/test/java/org/scijava/io/location/BZip2LocationTest.java

@@ -0,0 +1,63 @@
+/*
+ * #%L
+ * SciJava Common shared library for SciJava software.
+ * %%
+ * Copyright (C) 2009 - 2017 Board of Regents of the University of
+ * Wisconsin-Madison, Broad Institute of MIT and Harvard, and Max Planck
+ * Institute of Molecular Cell Biology and Genetics.
+ * %%
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ * #L%
+ */
+
+package org.scijava.io.location;
+
+import static org.junit.Assert.assertEquals;
+
+import java.io.IOException;
+
+import org.junit.Test;
+import org.scijava.io.location.FileLocation;
+import org.scijava.io.location.Location;
+
+/**
+ * Tests {@link BZip2Location}.
+ *
+ * @author Gabriel Einsdorf
+ */
+public class BZip2LocationTest {
+
+	/**
+	 * Tests {@link BZip2Location#BZip2Location(Location)}.
+	 *
+	 * @throws IOException
+	 */
+	@Test
+	public void testFile() throws IOException {
+		final String path = "/not/actually/a/real-file";
+		final FileLocation loc = new FileLocation(path);
+		BZip2Location zLoc = new BZip2Location(loc);
+
+		assertEquals(zLoc.getBaseLocation(), loc);
+	}
+
+}

src/test/java/org/scijava/io/location/GZipLocationTest.java

@@ -0,0 +1,63 @@
+/*
+ * #%L
+ * SciJava Common shared library for SciJava software.
+ * %%
+ * Copyright (C) 2009 - 2017 Board of Regents of the University of
+ * Wisconsin-Madison, Broad Institute of MIT and Harvard, and Max Planck
+ * Institute of Molecular Cell Biology and Genetics.
+ * %%
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ * #L%
+ */
+
+package org.scijava.io.location;
+
+import static org.junit.Assert.assertEquals;
+
+import java.io.IOException;
+
+import org.junit.Test;
+import org.scijava.io.location.FileLocation;
+import org.scijava.io.location.Location;
+
+/**
+ * Tests {@link GZipLocation}.
+ *
+ * @author Gabriel Einsdorf
+ */
+public class GZipLocationTest {
+
+	/**
+	 * Tests {@link GZipLocation#GZipLocation(Location)}.
+	 *
+	 * @throws IOException
+	 */
+	@Test
+	public void testFile() throws IOException {
+		final String path = "/not/actually/a/real-file";
+		final FileLocation loc = new FileLocation(path);
+		GZipLocation zLoc = new GZipLocation(loc);
+
+		assertEquals(zLoc.getBaseLocation(), loc);
+	}
+
+}

src/test/java/org/scijava/io/location/ZipLocationTest.java

@@ -0,0 +1,63 @@
+/*
+ * #%L
+ * SciJava Common shared library for SciJava software.
+ * %%
+ * Copyright (C) 2009 - 2017 Board of Regents of the University of
+ * Wisconsin-Madison, Broad Institute of MIT and Harvard, and Max Planck
+ * Institute of Molecular Cell Biology and Genetics.
+ * %%
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ * #L%
+ */
+
+package org.scijava.io.location;
+
+import static org.junit.Assert.assertEquals;
+
+import java.io.IOException;
+
+import org.junit.Test;
+import org.scijava.io.location.FileLocation;
+import org.scijava.io.location.Location;
+
+/**
+ * Tests {@link ZipLocation}.
+ *
+ * @author Gabriel Einsdorf
+ */
+public class ZipLocationTest {
+
+	/**
+	 * Tests {@link ZipLocation#ZipLocation(Location)}.
+	 *
+	 * @throws IOException
+	 */
+	@Test
+	public void testFile() throws IOException {
+		final String path = "/not/actually/a/real-file";
+		final FileLocation loc = new FileLocation(path);
+		ZipLocation zLoc = new ZipLocation(loc);
+
+		assertEquals(zLoc.getBaseLocation(), loc);
+	}
+
+}