public void testNotADumpArchive() throws Exception {

        FileInputStream is = new FileInputStream(getFile("bla.zip"));

        try {

            new DumpArchiveInputStream(is);

            fail("expected an exception");

        } catch (ArchiveException ex) {

            // expected

            assertTrue(ex.getCause() instanceof ShortFileException);

        } finally {

            is.close();

        }

    }

    private byte[] readBuf = new byte[DumpArchiveConstants.TP_SIZE];

    private Map names = new HashMap();

    private Map pending = new HashMap();

    public DumpArchiveInputStream(InputStream is) throws ArchiveException {

        this.raw = new TapeInputStream(is);

        this.hasHitEOF = false;

        } catch (IOException ex) {

            throw new ArchiveException(ex.getMessage(), ex);

    private byte[] blockBuffer = new byte[DumpArchiveConstants.TP_SIZE];

    private int currBlkIdx = -1;

    private int blockSize = DumpArchiveConstants.TP_SIZE;

    private int recordSize = DumpArchiveConstants.TP_SIZE;

    private int readOffset = DumpArchiveConstants.TP_SIZE;

    private boolean isCompressed = false;

    private long bytesRead = 0;

        super(in);

    }

        if ((len % recordSize) != 0) {

        int bytes = 0;

        while (bytes < len) {

        byte[] result = new byte[recordSize];

        boolean success = true;

        if (in == null) {

        if (!isCompressed || (currBlkIdx == -1)) {

        int count = 0;

        while (count < len) {

            int n = in.read(b, off + count, len - count);

            if (n == -1) {

                throw new ShortFileException();

            count += n;

        }

        super(message);

        this.initCause(cause);

    }

        super("unexpected EOF");

    }

        super(msg);

    }

public class ArchiveStreamFactory {

public abstract class ArchiveInputStream extends InputStream {

    private byte[] SINGLE = new byte[1];

    private long bytesRead = 0;