commons-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From bode...@apache.org
Subject [03/28] commons-compress git commit: COMPRESS-380 change package name
Date Tue, 09 Jan 2018 17:40:56 GMT
COMPRESS-380 change package name


Project: http://git-wip-us.apache.org/repos/asf/commons-compress/repo
Commit: http://git-wip-us.apache.org/repos/asf/commons-compress/commit/2042aa00
Tree: http://git-wip-us.apache.org/repos/asf/commons-compress/tree/2042aa00
Diff: http://git-wip-us.apache.org/repos/asf/commons-compress/diff/2042aa00

Branch: refs/heads/master
Commit: 2042aa001474179a031a368f9d6ec73c2c686965
Parents: 3e9b0e8
Author: Stefan Bodewig <bodewig@apache.org>
Authored: Wed Jan 3 15:20:33 2018 +0100
Committer: Stefan Bodewig <bodewig@apache.org>
Committed: Wed Jan 3 15:20:33 2018 +0100

----------------------------------------------------------------------
 .../commons/compress/archivers/zip/ZipFile.java |   2 +-
 .../deflate64/Deflate64InputStream.java         |  88 ++++
 .../compressors/deflate64/HuffmanDecoder.java   | 462 +++++++++++++++++++
 .../compressors/deflate64/HuffmanState.java     |  25 +
 .../compressors/zip/Deflate64InputStream.java   |  88 ----
 .../compressors/zip/HuffmanDecoder.java         | 462 -------------------
 .../compress/compressors/zip/HuffmanState.java  |  25 -
 .../deflate64/Deflate64InputStreamTest.java     | 128 +++++
 .../deflate64/HuffmanDecoderTest.java           | 222 +++++++++
 .../zip/Deflate64InputStreamTest.java           | 128 -----
 .../compressors/zip/HuffmanDecoderTest.java     | 222 ---------
 11 files changed, 926 insertions(+), 926 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/commons-compress/blob/2042aa00/src/main/java/org/apache/commons/compress/archivers/zip/ZipFile.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/compress/archivers/zip/ZipFile.java b/src/main/java/org/apache/commons/compress/archivers/zip/ZipFile.java
index b7a41a3..c10fc1a 100644
--- a/src/main/java/org/apache/commons/compress/archivers/zip/ZipFile.java
+++ b/src/main/java/org/apache/commons/compress/archivers/zip/ZipFile.java
@@ -42,7 +42,7 @@ import java.util.zip.InflaterInputStream;
 import java.util.zip.ZipException;
 
 import org.apache.commons.compress.compressors.bzip2.BZip2CompressorInputStream;
-import org.apache.commons.compress.compressors.zip.Deflate64InputStream;
+import org.apache.commons.compress.compressors.deflate64.Deflate64InputStream;
 import org.apache.commons.compress.utils.IOUtils;
 
 import static org.apache.commons.compress.archivers.zip.ZipConstants.DWORD;

http://git-wip-us.apache.org/repos/asf/commons-compress/blob/2042aa00/src/main/java/org/apache/commons/compress/compressors/deflate64/Deflate64InputStream.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/compress/compressors/deflate64/Deflate64InputStream.java b/src/main/java/org/apache/commons/compress/compressors/deflate64/Deflate64InputStream.java
new file mode 100644
index 0000000..e45f87f
--- /dev/null
+++ b/src/main/java/org/apache/commons/compress/compressors/deflate64/Deflate64InputStream.java
@@ -0,0 +1,88 @@
+/*
+ *  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.compressors.deflate64;
+
+import java.io.IOException;
+import java.io.InputStream;
+
+import static org.apache.commons.compress.utils.IOUtils.closeQuietly;
+
+public class Deflate64InputStream extends InputStream {
+    private HuffmanDecoder decoder;
+    private long uncompressedSize;
+    private long totalRead = 0;
+
+    public Deflate64InputStream(InputStream in, long uncompressedSize) {
+        this(new HuffmanDecoder(in), uncompressedSize);
+    }
+
+    Deflate64InputStream(HuffmanDecoder decoder, long uncompressedSize) {
+        this.uncompressedSize = uncompressedSize;
+        this.decoder = decoder;
+    }
+
+    @Override
+    public int read() throws IOException {
+        byte[] b = new byte[1];
+        while (true) {
+            int r = read(b);
+            switch (r) {
+                case 1:
+                    return b[0] & 0xFF;
+                case -1:
+                    return -1;
+                case 0:
+                    continue;
+                default:
+                    throw new IllegalStateException("Invalid return value from read: " + r);
+            }
+        }
+    }
+
+    @Override
+    public int read(byte[] b, int off, int len) throws IOException {
+        int read = -1;
+        if (decoder != null) {
+            read = decoder.decode(b, off, len);
+            if (read == -1) {
+                close();
+            } else {
+                totalRead += read;
+            }
+        }
+        return read;
+    }
+
+    @Override
+    public int available() throws IOException {
+        long available = 0;
+        if (decoder != null) {
+            available = uncompressedSize - totalRead;
+            if (Long.compare(available, Integer.MAX_VALUE) > 0) {
+                available = Integer.MAX_VALUE;
+            }
+        }
+        return (int) available;
+    }
+
+    @Override
+    public void close() throws IOException {
+        closeQuietly(decoder);
+        decoder = null;
+    }
+}

http://git-wip-us.apache.org/repos/asf/commons-compress/blob/2042aa00/src/main/java/org/apache/commons/compress/compressors/deflate64/HuffmanDecoder.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/compress/compressors/deflate64/HuffmanDecoder.java b/src/main/java/org/apache/commons/compress/compressors/deflate64/HuffmanDecoder.java
new file mode 100644
index 0000000..bf1c4ad
--- /dev/null
+++ b/src/main/java/org/apache/commons/compress/compressors/deflate64/HuffmanDecoder.java
@@ -0,0 +1,462 @@
+/*
+ *  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.compressors.deflate64;
+
+import org.apache.commons.compress.utils.BitInputStream;
+
+import java.io.Closeable;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.ByteOrder;
+import java.util.Arrays;
+
+import static org.apache.commons.compress.compressors.deflate64.HuffmanState.*;
+import static org.apache.commons.compress.utils.IOUtils.closeQuietly;
+
+public class HuffmanDecoder implements Closeable {
+    /**
+     * --------------------------------------------------------------------
+     * idx  xtra  base     idx  xtra  base     idx  xtra  base
+     * --------------------------------------------------------------------
+     * 257   0     3       267   1   15,16     277   4   67-82
+     * 258   0     4       268   1   17,18     278   4   83-98
+     * 259   0     5       269   2   19-22     279   4   99-114
+     * 260   0     6       270   2   23-26     280   4   115-130
+     * 261   0     7       271   2   27-30     281   5   131-162
+     * 262   0     8       272   2   31-34     282   5   163-194
+     * 263   0     9       273   3   35-42     283   5   195-226
+     * 264   0     10      274   3   43-50     284   5   227-257
+     * 265   1     11,12   275   3   51-58     285   96  3
+     * 266   1     13,14   276   3   59-66
+     * --------------------------------------------------------------------
+     * value = (base of run length) << 5 | (number of extra bits to read)
+     */
+    private static final short[] RUN_LENGTH_TABLE = {
+            96, 128, 160, 192, 224, 256, 288, 320, 353, 417, 481, 545, 610, 738, 866,
+            994, 1123, 1379, 1635, 1891, 2148, 2660, 3172, 3684, 4197, 5221, 6245, 7269, 112
+    };
+
+    /**
+     * --------------------------------------------------------------------
+     * idx  xtra  dist     idx  xtra  dist       idx  xtra  dist
+     * --------------------------------------------------------------------
+     * 0    0     1        10   4     33-48      20    9   1025-1536
+     * 1    0     2        11   4     49-64      21    9   1537-2048
+     * 2    0     3        12   5     65-96      22   10   2049-3072
+     * 3    0     4        13   5     97-128     23   10   3073-4096
+     * 4    1     5,6      14   6     129-192    24   11   4097-6144
+     * 5    1     7,8      15   6     193-256    25   11   6145-8192
+     * 6    2     9-12     16   7     257-384    26   12   8193-12288
+     * 7    2     13-16    17   7     385-512    27   12   12289-16384
+     * 8    3     17-24    18   8     513-768    28   13   16385-24576
+     * 9    3     25-32    19   8     769-1024   29   13   24577-32768
+     * 30   14   32769-49152
+     * 31   14   49153-65536
+     * --------------------------------------------------------------------
+     * value = (base of distance) << 4 | (number of extra bits to read)
+     */
+    private static final int[] DISTANCE_TABLE = {
+            16, 32, 48, 64, 81, 113, 146, 210, 275, 403,  // 0-9
+            532, 788, 1045, 1557, 2070, 3094, 4119, 6167, 8216, 12312, // 10-19
+            16409, 24601, 32794, 49178, 65563, 98331, 131100, 196636, 262173, 393245, // 20-29
+            524318, 786462 // 30-31
+    };
+
+    /**
+     * When using dynamic huffman codes the order in which the values are stored
+     * follows the positioning below
+     */
+    private static final int[] CODE_LENGTHS_ORDER =
+            {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
+
+    /**
+     * Huffman Fixed Literal / Distance tables for mode 1
+     */
+    private static final int[] FIXED_LITERALS;
+    private static final int[] FIXED_DISTANCE;
+
+    static {
+        FIXED_LITERALS = new int[288];
+        Arrays.fill(FIXED_LITERALS, 0, 144, 8);
+        Arrays.fill(FIXED_LITERALS, 144, 256, 9);
+        Arrays.fill(FIXED_LITERALS, 256, 280, 7);
+        Arrays.fill(FIXED_LITERALS, 280, 288, 8);
+
+        FIXED_DISTANCE = new int[32];
+        Arrays.fill(FIXED_DISTANCE, 5);
+    }
+
+    private boolean finalBlock = false;
+    private DecoderState state;
+    private BitInputStream reader;
+
+    private final DecodingMemory memory = new DecodingMemory();
+
+    HuffmanDecoder(InputStream in) {
+        this(new BitInputStream(in, ByteOrder.LITTLE_ENDIAN));
+    }
+
+    private HuffmanDecoder(BitInputStream reader) {
+        this.reader = reader;
+        state = new InitialState();
+    }
+
+    @Override
+    public void close() {
+        closeQuietly(reader);
+        reader = null;
+    }
+
+    public int decode(byte[] b) throws IOException {
+        return decode(b, 0, b.length);
+    }
+
+    public int decode(byte[] b, int off, int len) throws IOException {
+        while (!finalBlock || state.hasData()) {
+            switch (state.state()) {
+                case INITIAL:
+                    finalBlock = reader.readBits(1) == 1;
+                    int mode = (int) reader.readBits(2);
+                    switch (mode) {
+                        case 0:
+                            reader.readBits(Byte.SIZE - 3);
+                            long bLen = reader.readBits(16);
+                            long bNLen = reader.readBits(16);
+                            if (((bLen ^ 0xFFFF) & 0xFFFF) != bNLen) {
+                                //noinspection DuplicateStringLiteralInspection
+                                throw new IllegalStateException("Illegal LEN / NLEN values");
+                            }
+                            state = new UncompressedState((int) bLen);
+                            break;
+                        case 1:
+                            state = new HuffmanCodes(FIXED_CODES, FIXED_LITERALS, FIXED_DISTANCE);
+                            break;
+                        case 2:
+                            int literals = (int) (reader.readBits(5) + 257);
+                            int[] literalTable = new int[literals];
+
+                            int distances = (int) (reader.readBits(5) + 1);
+                            int[] distanceTable = new int[distances];
+
+                            populateDynamicTables(reader, literalTable, distanceTable);
+
+                            state = new HuffmanCodes(DYNAMIC_CODES, literalTable, distanceTable);
+                            break;
+                        default:
+                            throw new IllegalStateException("Unsupported compression: " + mode);
+                    }
+                    break;
+                default:
+                    return state.read(b, off, len);
+            }
+        }
+        return -1;
+    }
+
+
+    private static abstract class DecoderState {
+        abstract HuffmanState state();
+
+        abstract int read(byte[] b, int off, int len) throws IOException;
+
+        abstract boolean hasData();
+    }
+
+    private class UncompressedState extends DecoderState {
+        private final int blockLength;
+        private int read;
+
+        private UncompressedState(int blockLength) {
+            this.blockLength = blockLength;
+        }
+
+        @Override
+        HuffmanState state() {
+            return read < blockLength ? STORED : INITIAL;
+        }
+
+        @Override
+        int read(byte[] b, int off, int len) throws IOException {
+            int max = Math.min(blockLength - read, len);
+            for (int i = 0; i < max; i++) {
+                byte next = (byte) (reader.readBits(Byte.SIZE) & 0xFF);
+                b[off + i] = memory.add(next);
+                read++;
+            }
+            return max;
+        }
+
+        @Override
+        boolean hasData() {
+            return read < blockLength;
+        }
+    }
+
+    private class InitialState extends DecoderState {
+        @Override
+        HuffmanState state() {
+            return INITIAL;
+        }
+
+        @Override
+        int read(byte[] b, int off, int len) throws IOException {
+            throw new IllegalStateException("Cannot read in this state");
+        }
+
+        @Override
+        boolean hasData() {
+            return false;
+        }
+    }
+
+    private class HuffmanCodes extends DecoderState {
+        private boolean endOfBlock = false;
+        private final HuffmanState state;
+        private final BinaryTreeNode lengthTree;
+        private final BinaryTreeNode distanceTree;
+
+        private int runBufferPos = 0;
+        private byte[] runBuffer = new byte[0];
+
+        HuffmanCodes(HuffmanState state, int[] lengths, int[] distance) {
+            this.state = state;
+            lengthTree = buildTree(lengths);
+            distanceTree = buildTree(distance);
+        }
+
+        @Override
+        HuffmanState state() {
+            return endOfBlock ? INITIAL : state;
+        }
+
+        @Override
+        int read(byte[] b, int off, int len) throws IOException {
+            return decodeNext(b, off, len);
+        }
+
+        private int decodeNext(byte[] b, int off, int len) throws IOException {
+            if (endOfBlock) {
+                return -1;
+            }
+            int result = copyFromRunBuffer(b, off, len);
+
+            while (result < len) {
+                int symbol = nextSymbol(reader, lengthTree);
+                if (symbol < 256) {
+                    b[off + result++] = memory.add((byte) (symbol & 0xFF));
+                } else if (symbol > 256) {
+                    int runMask = RUN_LENGTH_TABLE[symbol - 257];
+                    int run = runMask >>> 5;
+                    int runXtra = runMask & 0x1F;
+                    run += reader.readBits(runXtra);
+
+                    int distSym = nextSymbol(reader, distanceTree);
+
+                    int distMask = DISTANCE_TABLE[distSym];
+                    int dist = distMask >>> 4;
+                    int distXtra = distMask & 0xF;
+                    dist += reader.readBits(distXtra);
+
+                    runBuffer = new byte[run];
+                    runBufferPos = 0;
+                    memory.recordToBuffer(dist, run, runBuffer);
+
+                    result += copyFromRunBuffer(b, off + result, len - result);
+                } else {
+                    endOfBlock = true;
+                    return result;
+                }
+            }
+
+            return result;
+        }
+
+        private int copyFromRunBuffer(byte[] b, int off, int len) {
+            int bytesInBuffer = runBuffer.length - runBufferPos;
+            int copiedBytes = 0;
+            if (bytesInBuffer > 0) {
+                copiedBytes = Math.min(len, bytesInBuffer);
+                System.arraycopy(runBuffer, runBufferPos, b, off, copiedBytes);
+                runBufferPos += copiedBytes;
+            }
+            return copiedBytes;
+        }
+
+        @Override
+        boolean hasData() {
+            return !endOfBlock;
+        }
+    }
+
+    private static int nextSymbol(BitInputStream reader, BinaryTreeNode tree) throws IOException {
+        BinaryTreeNode node = tree;
+        while (node != null && node.literal == -1) {
+            long bit = reader.readBits(1);
+            node = bit == 0 ? node.left : node.right;
+        }
+        return node != null ? node.literal : -1;
+    }
+
+    private static void populateDynamicTables(BitInputStream reader, int[] literals, int[] distances) throws IOException {
+        int codeLengths = (int) (reader.readBits(4) + 4);
+
+        int[] codeLengthValues = new int[19];
+        for (int cLen = 0; cLen < codeLengths; cLen++) {
+            codeLengthValues[CODE_LENGTHS_ORDER[cLen]] = (int) reader.readBits(3);
+        }
+
+        BinaryTreeNode codeLengthTree = buildTree(codeLengthValues);
+
+        int[] auxBuffer = new int[literals.length + distances.length];
+
+        int value = -1, length = 0;
+        for (int i = 0; i < auxBuffer.length; ) {
+            if (length > 0) {
+                auxBuffer[i++] = value;
+                length--;
+            } else {
+                int symbol = nextSymbol(reader, codeLengthTree);
+                if (symbol < 16) {
+                    value = symbol;
+                    auxBuffer[i++] = value;
+                } else if (symbol == 16) {
+                    length = (int) (reader.readBits(2) + 3);
+                } else if (symbol == 17) {
+                    value = 0;
+                    length = (int) (reader.readBits(3) + 3);
+                } else if (symbol == 18) {
+                    value = 0;
+                    length = (int) (reader.readBits(7) + 11);
+                }
+            }
+        }
+
+        System.arraycopy(auxBuffer, 0, literals, 0, literals.length);
+        System.arraycopy(auxBuffer, literals.length, distances, 0, distances.length);
+    }
+
+    private static class BinaryTreeNode {
+        private final int bits;
+        int literal = -1;
+        BinaryTreeNode left, right;
+
+        private BinaryTreeNode(int bits) {
+            this.bits = bits;
+        }
+
+        void leaf(int symbol) {
+            literal = symbol;
+            left = null;
+            right = null;
+        }
+
+        BinaryTreeNode left() {
+            if (left == null && literal == -1) {
+                left = new BinaryTreeNode(bits + 1);
+            }
+            return left;
+        }
+
+        BinaryTreeNode right() {
+            if (right == null && literal == -1) {
+                right = new BinaryTreeNode(bits + 1);
+            }
+            return right;
+        }
+    }
+
+    private static BinaryTreeNode buildTree(int[] litTable) {
+        int[] literalCodes = getCodes(litTable);
+
+        BinaryTreeNode root = new BinaryTreeNode(0);
+
+        for (int i = 0; i < litTable.length; i++) {
+            int len = litTable[i];
+            if (len != 0) {
+                BinaryTreeNode node = root;
+                int lit = literalCodes[len - 1];
+                for (int p = len - 1; p >= 0; p--) {
+                    int bit = lit & (1 << p);
+                    node = bit == 0 ? node.left() : node.right();
+                }
+                node.leaf(i);
+                literalCodes[len - 1]++;
+            }
+        }
+        return root;
+    }
+
+    private static int[] getCodes(int[] litTable) {
+        int max = 0;
+        int[] blCount = new int[65];
+
+        for (int aLitTable : litTable) {
+            max = Math.max(max, aLitTable);
+            blCount[aLitTable]++;
+        }
+        blCount = Arrays.copyOf(blCount, max + 1);
+
+        int code = 0;
+        int[] nextCode = new int[max + 1];
+        for (int i = 0; i <= max; i++) {
+            code = (code + blCount[i]) << 1;
+            nextCode[i] = code;
+        }
+
+        return nextCode;
+    }
+
+    private static class DecodingMemory {
+        private final byte[] memory;
+        private final int mask;
+        private int wHead;
+
+        private DecodingMemory() {
+            this(16);
+        }
+
+        private DecodingMemory(int bits) {
+            memory = new byte[1 << bits];
+            Arrays.fill(memory, (byte) -1);
+            mask = memory.length - 1;
+        }
+
+        byte add(byte b) {
+            memory[wHead] = b;
+            wHead = incCounter(wHead);
+            return b;
+        }
+
+        void recordToBuffer(int distance, int length, byte[] buff) {
+            if (distance > memory.length) {
+                throw new IllegalStateException("Illegal distance parameter: " + distance);
+            }
+            int start = (wHead - distance) & mask;
+            if (memory[start] == -1) {
+                throw new IllegalStateException("Attempt to read beyond memory: dist=" + distance);
+            }
+            for (int i = 0, pos = start; i < length; i++, pos = incCounter(pos)) {
+                buff[i] = add(memory[pos]);
+            }
+        }
+
+        private int incCounter(int counter) {
+            return (counter + 1) & mask;
+        }
+    }
+}

http://git-wip-us.apache.org/repos/asf/commons-compress/blob/2042aa00/src/main/java/org/apache/commons/compress/compressors/deflate64/HuffmanState.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/compress/compressors/deflate64/HuffmanState.java b/src/main/java/org/apache/commons/compress/compressors/deflate64/HuffmanState.java
new file mode 100644
index 0000000..b34bb7e
--- /dev/null
+++ b/src/main/java/org/apache/commons/compress/compressors/deflate64/HuffmanState.java
@@ -0,0 +1,25 @@
+/*
+ *  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.compressors.deflate64;
+
+enum HuffmanState {
+    INITIAL,
+    STORED,
+    DYNAMIC_CODES,
+    FIXED_CODES
+}

http://git-wip-us.apache.org/repos/asf/commons-compress/blob/2042aa00/src/main/java/org/apache/commons/compress/compressors/zip/Deflate64InputStream.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/compress/compressors/zip/Deflate64InputStream.java b/src/main/java/org/apache/commons/compress/compressors/zip/Deflate64InputStream.java
deleted file mode 100644
index 98bf792..0000000
--- a/src/main/java/org/apache/commons/compress/compressors/zip/Deflate64InputStream.java
+++ /dev/null
@@ -1,88 +0,0 @@
-/*
- *  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.compressors.zip;
-
-import java.io.IOException;
-import java.io.InputStream;
-
-import static org.apache.commons.compress.utils.IOUtils.closeQuietly;
-
-public class Deflate64InputStream extends InputStream {
-    private HuffmanDecoder decoder;
-    private long uncompressedSize;
-    private long totalRead = 0;
-
-    public Deflate64InputStream(InputStream in, long uncompressedSize) {
-        this(new HuffmanDecoder(in), uncompressedSize);
-    }
-
-    Deflate64InputStream(HuffmanDecoder decoder, long uncompressedSize) {
-        this.uncompressedSize = uncompressedSize;
-        this.decoder = decoder;
-    }
-
-    @Override
-    public int read() throws IOException {
-        byte[] b = new byte[1];
-        while (true) {
-            int r = read(b);
-            switch (r) {
-                case 1:
-                    return b[0] & 0xFF;
-                case -1:
-                    return -1;
-                case 0:
-                    continue;
-                default:
-                    throw new IllegalStateException("Invalid return value from read: " + r);
-            }
-        }
-    }
-
-    @Override
-    public int read(byte[] b, int off, int len) throws IOException {
-        int read = -1;
-        if (decoder != null) {
-            read = decoder.decode(b, off, len);
-            if (read == -1) {
-                close();
-            } else {
-                totalRead += read;
-            }
-        }
-        return read;
-    }
-
-    @Override
-    public int available() throws IOException {
-        long available = 0;
-        if (decoder != null) {
-            available = uncompressedSize - totalRead;
-            if (Long.compare(available, Integer.MAX_VALUE) > 0) {
-                available = Integer.MAX_VALUE;
-            }
-        }
-        return (int) available;
-    }
-
-    @Override
-    public void close() throws IOException {
-        closeQuietly(decoder);
-        decoder = null;
-    }
-}

http://git-wip-us.apache.org/repos/asf/commons-compress/blob/2042aa00/src/main/java/org/apache/commons/compress/compressors/zip/HuffmanDecoder.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/compress/compressors/zip/HuffmanDecoder.java b/src/main/java/org/apache/commons/compress/compressors/zip/HuffmanDecoder.java
deleted file mode 100644
index 0b6b173..0000000
--- a/src/main/java/org/apache/commons/compress/compressors/zip/HuffmanDecoder.java
+++ /dev/null
@@ -1,462 +0,0 @@
-/*
- *  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.compressors.zip;
-
-import org.apache.commons.compress.utils.BitInputStream;
-
-import java.io.Closeable;
-import java.io.IOException;
-import java.io.InputStream;
-import java.nio.ByteOrder;
-import java.util.Arrays;
-
-import static org.apache.commons.compress.compressors.zip.HuffmanState.*;
-import static org.apache.commons.compress.utils.IOUtils.closeQuietly;
-
-public class HuffmanDecoder implements Closeable {
-    /**
-     * --------------------------------------------------------------------
-     * idx  xtra  base     idx  xtra  base     idx  xtra  base
-     * --------------------------------------------------------------------
-     * 257   0     3       267   1   15,16     277   4   67-82
-     * 258   0     4       268   1   17,18     278   4   83-98
-     * 259   0     5       269   2   19-22     279   4   99-114
-     * 260   0     6       270   2   23-26     280   4   115-130
-     * 261   0     7       271   2   27-30     281   5   131-162
-     * 262   0     8       272   2   31-34     282   5   163-194
-     * 263   0     9       273   3   35-42     283   5   195-226
-     * 264   0     10      274   3   43-50     284   5   227-257
-     * 265   1     11,12   275   3   51-58     285   96  3
-     * 266   1     13,14   276   3   59-66
-     * --------------------------------------------------------------------
-     * value = (base of run length) << 5 | (number of extra bits to read)
-     */
-    private static final short[] RUN_LENGTH_TABLE = {
-            96, 128, 160, 192, 224, 256, 288, 320, 353, 417, 481, 545, 610, 738, 866,
-            994, 1123, 1379, 1635, 1891, 2148, 2660, 3172, 3684, 4197, 5221, 6245, 7269, 112
-    };
-
-    /**
-     * --------------------------------------------------------------------
-     * idx  xtra  dist     idx  xtra  dist       idx  xtra  dist
-     * --------------------------------------------------------------------
-     * 0    0     1        10   4     33-48      20    9   1025-1536
-     * 1    0     2        11   4     49-64      21    9   1537-2048
-     * 2    0     3        12   5     65-96      22   10   2049-3072
-     * 3    0     4        13   5     97-128     23   10   3073-4096
-     * 4    1     5,6      14   6     129-192    24   11   4097-6144
-     * 5    1     7,8      15   6     193-256    25   11   6145-8192
-     * 6    2     9-12     16   7     257-384    26   12   8193-12288
-     * 7    2     13-16    17   7     385-512    27   12   12289-16384
-     * 8    3     17-24    18   8     513-768    28   13   16385-24576
-     * 9    3     25-32    19   8     769-1024   29   13   24577-32768
-     * 30   14   32769-49152
-     * 31   14   49153-65536
-     * --------------------------------------------------------------------
-     * value = (base of distance) << 4 | (number of extra bits to read)
-     */
-    private static final int[] DISTANCE_TABLE = {
-            16, 32, 48, 64, 81, 113, 146, 210, 275, 403,  // 0-9
-            532, 788, 1045, 1557, 2070, 3094, 4119, 6167, 8216, 12312, // 10-19
-            16409, 24601, 32794, 49178, 65563, 98331, 131100, 196636, 262173, 393245, // 20-29
-            524318, 786462 // 30-31
-    };
-
-    /**
-     * When using dynamic huffman codes the order in which the values are stored
-     * follows the positioning below
-     */
-    private static final int[] CODE_LENGTHS_ORDER =
-            {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
-
-    /**
-     * Huffman Fixed Literal / Distance tables for mode 1
-     */
-    private static final int[] FIXED_LITERALS;
-    private static final int[] FIXED_DISTANCE;
-
-    static {
-        FIXED_LITERALS = new int[288];
-        Arrays.fill(FIXED_LITERALS, 0, 144, 8);
-        Arrays.fill(FIXED_LITERALS, 144, 256, 9);
-        Arrays.fill(FIXED_LITERALS, 256, 280, 7);
-        Arrays.fill(FIXED_LITERALS, 280, 288, 8);
-
-        FIXED_DISTANCE = new int[32];
-        Arrays.fill(FIXED_DISTANCE, 5);
-    }
-
-    private boolean finalBlock = false;
-    private DecoderState state;
-    private BitInputStream reader;
-
-    private final DecodingMemory memory = new DecodingMemory();
-
-    HuffmanDecoder(InputStream in) {
-        this(new BitInputStream(in, ByteOrder.LITTLE_ENDIAN));
-    }
-
-    private HuffmanDecoder(BitInputStream reader) {
-        this.reader = reader;
-        state = new InitialState();
-    }
-
-    @Override
-    public void close() {
-        closeQuietly(reader);
-        reader = null;
-    }
-
-    public int decode(byte[] b) throws IOException {
-        return decode(b, 0, b.length);
-    }
-
-    public int decode(byte[] b, int off, int len) throws IOException {
-        while (!finalBlock || state.hasData()) {
-            switch (state.state()) {
-                case INITIAL:
-                    finalBlock = reader.readBits(1) == 1;
-                    int mode = (int) reader.readBits(2);
-                    switch (mode) {
-                        case 0:
-                            reader.readBits(Byte.SIZE - 3);
-                            long bLen = reader.readBits(16);
-                            long bNLen = reader.readBits(16);
-                            if (((bLen ^ 0xFFFF) & 0xFFFF) != bNLen) {
-                                //noinspection DuplicateStringLiteralInspection
-                                throw new IllegalStateException("Illegal LEN / NLEN values");
-                            }
-                            state = new UncompressedState((int) bLen);
-                            break;
-                        case 1:
-                            state = new HuffmanCodes(FIXED_CODES, FIXED_LITERALS, FIXED_DISTANCE);
-                            break;
-                        case 2:
-                            int literals = (int) (reader.readBits(5) + 257);
-                            int[] literalTable = new int[literals];
-
-                            int distances = (int) (reader.readBits(5) + 1);
-                            int[] distanceTable = new int[distances];
-
-                            populateDynamicTables(reader, literalTable, distanceTable);
-
-                            state = new HuffmanCodes(DYNAMIC_CODES, literalTable, distanceTable);
-                            break;
-                        default:
-                            throw new IllegalStateException("Unsupported compression: " + mode);
-                    }
-                    break;
-                default:
-                    return state.read(b, off, len);
-            }
-        }
-        return -1;
-    }
-
-
-    private static abstract class DecoderState {
-        abstract HuffmanState state();
-
-        abstract int read(byte[] b, int off, int len) throws IOException;
-
-        abstract boolean hasData();
-    }
-
-    private class UncompressedState extends DecoderState {
-        private final int blockLength;
-        private int read;
-
-        private UncompressedState(int blockLength) {
-            this.blockLength = blockLength;
-        }
-
-        @Override
-        HuffmanState state() {
-            return read < blockLength ? STORED : INITIAL;
-        }
-
-        @Override
-        int read(byte[] b, int off, int len) throws IOException {
-            int max = Math.min(blockLength - read, len);
-            for (int i = 0; i < max; i++) {
-                byte next = (byte) (reader.readBits(Byte.SIZE) & 0xFF);
-                b[off + i] = memory.add(next);
-                read++;
-            }
-            return max;
-        }
-
-        @Override
-        boolean hasData() {
-            return read < blockLength;
-        }
-    }
-
-    private class InitialState extends DecoderState {
-        @Override
-        HuffmanState state() {
-            return INITIAL;
-        }
-
-        @Override
-        int read(byte[] b, int off, int len) throws IOException {
-            throw new IllegalStateException("Cannot read in this state");
-        }
-
-        @Override
-        boolean hasData() {
-            return false;
-        }
-    }
-
-    private class HuffmanCodes extends DecoderState {
-        private boolean endOfBlock = false;
-        private final HuffmanState state;
-        private final BinaryTreeNode lengthTree;
-        private final BinaryTreeNode distanceTree;
-
-        private int runBufferPos = 0;
-        private byte[] runBuffer = new byte[0];
-
-        HuffmanCodes(HuffmanState state, int[] lengths, int[] distance) {
-            this.state = state;
-            lengthTree = buildTree(lengths);
-            distanceTree = buildTree(distance);
-        }
-
-        @Override
-        HuffmanState state() {
-            return endOfBlock ? INITIAL : state;
-        }
-
-        @Override
-        int read(byte[] b, int off, int len) throws IOException {
-            return decodeNext(b, off, len);
-        }
-
-        private int decodeNext(byte[] b, int off, int len) throws IOException {
-            if (endOfBlock) {
-                return -1;
-            }
-            int result = copyFromRunBuffer(b, off, len);
-
-            while (result < len) {
-                int symbol = nextSymbol(reader, lengthTree);
-                if (symbol < 256) {
-                    b[off + result++] = memory.add((byte) (symbol & 0xFF));
-                } else if (symbol > 256) {
-                    int runMask = RUN_LENGTH_TABLE[symbol - 257];
-                    int run = runMask >>> 5;
-                    int runXtra = runMask & 0x1F;
-                    run += reader.readBits(runXtra);
-
-                    int distSym = nextSymbol(reader, distanceTree);
-
-                    int distMask = DISTANCE_TABLE[distSym];
-                    int dist = distMask >>> 4;
-                    int distXtra = distMask & 0xF;
-                    dist += reader.readBits(distXtra);
-
-                    runBuffer = new byte[run];
-                    runBufferPos = 0;
-                    memory.recordToBuffer(dist, run, runBuffer);
-
-                    result += copyFromRunBuffer(b, off + result, len - result);
-                } else {
-                    endOfBlock = true;
-                    return result;
-                }
-            }
-
-            return result;
-        }
-
-        private int copyFromRunBuffer(byte[] b, int off, int len) {
-            int bytesInBuffer = runBuffer.length - runBufferPos;
-            int copiedBytes = 0;
-            if (bytesInBuffer > 0) {
-                copiedBytes = Math.min(len, bytesInBuffer);
-                System.arraycopy(runBuffer, runBufferPos, b, off, copiedBytes);
-                runBufferPos += copiedBytes;
-            }
-            return copiedBytes;
-        }
-
-        @Override
-        boolean hasData() {
-            return !endOfBlock;
-        }
-    }
-
-    private static int nextSymbol(BitInputStream reader, BinaryTreeNode tree) throws IOException {
-        BinaryTreeNode node = tree;
-        while (node != null && node.literal == -1) {
-            long bit = reader.readBits(1);
-            node = bit == 0 ? node.left : node.right;
-        }
-        return node != null ? node.literal : -1;
-    }
-
-    private static void populateDynamicTables(BitInputStream reader, int[] literals, int[] distances) throws IOException {
-        int codeLengths = (int) (reader.readBits(4) + 4);
-
-        int[] codeLengthValues = new int[19];
-        for (int cLen = 0; cLen < codeLengths; cLen++) {
-            codeLengthValues[CODE_LENGTHS_ORDER[cLen]] = (int) reader.readBits(3);
-        }
-
-        BinaryTreeNode codeLengthTree = buildTree(codeLengthValues);
-
-        int[] auxBuffer = new int[literals.length + distances.length];
-
-        int value = -1, length = 0;
-        for (int i = 0; i < auxBuffer.length; ) {
-            if (length > 0) {
-                auxBuffer[i++] = value;
-                length--;
-            } else {
-                int symbol = nextSymbol(reader, codeLengthTree);
-                if (symbol < 16) {
-                    value = symbol;
-                    auxBuffer[i++] = value;
-                } else if (symbol == 16) {
-                    length = (int) (reader.readBits(2) + 3);
-                } else if (symbol == 17) {
-                    value = 0;
-                    length = (int) (reader.readBits(3) + 3);
-                } else if (symbol == 18) {
-                    value = 0;
-                    length = (int) (reader.readBits(7) + 11);
-                }
-            }
-        }
-
-        System.arraycopy(auxBuffer, 0, literals, 0, literals.length);
-        System.arraycopy(auxBuffer, literals.length, distances, 0, distances.length);
-    }
-
-    private static class BinaryTreeNode {
-        private final int bits;
-        int literal = -1;
-        BinaryTreeNode left, right;
-
-        private BinaryTreeNode(int bits) {
-            this.bits = bits;
-        }
-
-        void leaf(int symbol) {
-            literal = symbol;
-            left = null;
-            right = null;
-        }
-
-        BinaryTreeNode left() {
-            if (left == null && literal == -1) {
-                left = new BinaryTreeNode(bits + 1);
-            }
-            return left;
-        }
-
-        BinaryTreeNode right() {
-            if (right == null && literal == -1) {
-                right = new BinaryTreeNode(bits + 1);
-            }
-            return right;
-        }
-    }
-
-    private static BinaryTreeNode buildTree(int[] litTable) {
-        int[] literalCodes = getCodes(litTable);
-
-        BinaryTreeNode root = new BinaryTreeNode(0);
-
-        for (int i = 0; i < litTable.length; i++) {
-            int len = litTable[i];
-            if (len != 0) {
-                BinaryTreeNode node = root;
-                int lit = literalCodes[len - 1];
-                for (int p = len - 1; p >= 0; p--) {
-                    int bit = lit & (1 << p);
-                    node = bit == 0 ? node.left() : node.right();
-                }
-                node.leaf(i);
-                literalCodes[len - 1]++;
-            }
-        }
-        return root;
-    }
-
-    private static int[] getCodes(int[] litTable) {
-        int max = 0;
-        int[] blCount = new int[65];
-
-        for (int aLitTable : litTable) {
-            max = Math.max(max, aLitTable);
-            blCount[aLitTable]++;
-        }
-        blCount = Arrays.copyOf(blCount, max + 1);
-
-        int code = 0;
-        int[] nextCode = new int[max + 1];
-        for (int i = 0; i <= max; i++) {
-            code = (code + blCount[i]) << 1;
-            nextCode[i] = code;
-        }
-
-        return nextCode;
-    }
-
-    private static class DecodingMemory {
-        private final byte[] memory;
-        private final int mask;
-        private int wHead;
-
-        private DecodingMemory() {
-            this(16);
-        }
-
-        private DecodingMemory(int bits) {
-            memory = new byte[1 << bits];
-            Arrays.fill(memory, (byte) -1);
-            mask = memory.length - 1;
-        }
-
-        byte add(byte b) {
-            memory[wHead] = b;
-            wHead = incCounter(wHead);
-            return b;
-        }
-
-        void recordToBuffer(int distance, int length, byte[] buff) {
-            if (distance > memory.length) {
-                throw new IllegalStateException("Illegal distance parameter: " + distance);
-            }
-            int start = (wHead - distance) & mask;
-            if (memory[start] == -1) {
-                throw new IllegalStateException("Attempt to read beyond memory: dist=" + distance);
-            }
-            for (int i = 0, pos = start; i < length; i++, pos = incCounter(pos)) {
-                buff[i] = add(memory[pos]);
-            }
-        }
-
-        private int incCounter(int counter) {
-            return (counter + 1) & mask;
-        }
-    }
-}

http://git-wip-us.apache.org/repos/asf/commons-compress/blob/2042aa00/src/main/java/org/apache/commons/compress/compressors/zip/HuffmanState.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/compress/compressors/zip/HuffmanState.java b/src/main/java/org/apache/commons/compress/compressors/zip/HuffmanState.java
deleted file mode 100644
index 473be6c..0000000
--- a/src/main/java/org/apache/commons/compress/compressors/zip/HuffmanState.java
+++ /dev/null
@@ -1,25 +0,0 @@
-/*
- *  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.compressors.zip;
-
-enum HuffmanState {
-    INITIAL,
-    STORED,
-    DYNAMIC_CODES,
-    FIXED_CODES
-}

http://git-wip-us.apache.org/repos/asf/commons-compress/blob/2042aa00/src/test/java/org/apache/commons/compress/compressors/deflate64/Deflate64InputStreamTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/compress/compressors/deflate64/Deflate64InputStreamTest.java b/src/test/java/org/apache/commons/compress/compressors/deflate64/Deflate64InputStreamTest.java
new file mode 100644
index 0000000..f9d1f3b
--- /dev/null
+++ b/src/test/java/org/apache/commons/compress/compressors/deflate64/Deflate64InputStreamTest.java
@@ -0,0 +1,128 @@
+/*
+ *  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.compressors.deflate64;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.runners.MockitoJUnitRunner;
+
+import java.io.BufferedReader;
+import java.io.ByteArrayInputStream;
+import java.io.InputStreamReader;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.times;
+
+@RunWith(MockitoJUnitRunner.class)
+public class Deflate64InputStreamTest
+{
+   private final HuffmanDecoder nullDecoder = null;
+
+   @Mock
+   private HuffmanDecoder decoder;
+
+   @Test
+   public void readWhenClosed() throws Exception
+   {
+      long size = Integer.MAX_VALUE - 1;
+      Deflate64InputStream input = new Deflate64InputStream(nullDecoder, size);
+      assertEquals(-1, input.read());
+      assertEquals(-1, input.read(new byte[1]));
+      assertEquals(-1, input.read(new byte[1], 0, 1));
+   }
+
+   @Test
+   public void properSizeWhenClosed() throws Exception
+   {
+      long size = Integer.MAX_VALUE - 1;
+      Deflate64InputStream input = new Deflate64InputStream(nullDecoder, size);
+      assertEquals(0, input.available());
+   }
+
+   @Test
+   public void properSizeWhenInRange() throws Exception
+   {
+      long size = Integer.MAX_VALUE - 1;
+      Deflate64InputStream input = new Deflate64InputStream(decoder, size);
+      assertEquals(size, input.available());
+   }
+
+   @Test
+   public void properSizeWhenOutOfRange() throws Exception
+   {
+      long size = Integer.MAX_VALUE + 1L;
+      Deflate64InputStream input = new Deflate64InputStream(decoder, size);
+      assertEquals(Integer.MAX_VALUE, input.available());
+   }
+
+   @Test
+   public void properSizeAfterReading() throws Exception
+   {
+      byte[] buf = new byte[4096];
+      int offset = 1000;
+      int length = 3096;
+
+      Mockito.when(decoder.decode(buf, offset, length)).thenReturn(2048);
+
+      long size = Integer.MAX_VALUE + 2047L;
+      Deflate64InputStream input = new Deflate64InputStream(decoder, size);
+      assertEquals(2048, input.read(buf, offset, length));
+      assertEquals(Integer.MAX_VALUE - 1, input.available());
+   }
+
+   @Test
+   public void closeCallsDecoder() throws Exception
+   {
+
+      Deflate64InputStream input = new Deflate64InputStream(decoder, 10);
+      input.close();
+
+      Mockito.verify(decoder, times(1)).close();
+   }
+
+   @Test
+   public void closeIsDelegatedJustOnce() throws Exception
+   {
+
+      Deflate64InputStream input = new Deflate64InputStream(decoder, 10);
+
+      input.close();
+      input.close();
+
+      Mockito.verify(decoder, times(1)).close();
+   }
+
+   @Test
+   public void uncompressedBlock() throws Exception
+   {
+      byte[] data = {
+         1, 11, 0, -12, -1,
+         'H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd'
+      };
+
+      try (Deflate64InputStream input = new Deflate64InputStream(new ByteArrayInputStream(data), 11);
+           BufferedReader br = new BufferedReader(new InputStreamReader(input)))
+      {
+         assertEquals("Hello World", br.readLine());
+         assertEquals(null, br.readLine());
+      }
+   }
+
+}

http://git-wip-us.apache.org/repos/asf/commons-compress/blob/2042aa00/src/test/java/org/apache/commons/compress/compressors/deflate64/HuffmanDecoderTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/compress/compressors/deflate64/HuffmanDecoderTest.java b/src/test/java/org/apache/commons/compress/compressors/deflate64/HuffmanDecoderTest.java
new file mode 100644
index 0000000..57249f0
--- /dev/null
+++ b/src/test/java/org/apache/commons/compress/compressors/deflate64/HuffmanDecoderTest.java
@@ -0,0 +1,222 @@
+/*
+ *  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.compressors.deflate64;
+
+import org.junit.Test;
+
+import java.io.ByteArrayInputStream;
+import java.util.Arrays;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
+public class HuffmanDecoderTest {
+    @Test
+    public void decodeUncompressedBlock() throws Exception {
+        byte[] data = {
+                0b1, // end of block + no compression mode
+                11, 0, -12, -1, // len & ~len
+                'H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd'
+        };
+
+        HuffmanDecoder decoder = new HuffmanDecoder(new ByteArrayInputStream(data));
+        byte[] result = new byte[100];
+        int len = decoder.decode(result);
+
+        assertEquals(11, len);
+        assertEquals("Hello World", new String(result, 0, len));
+    }
+
+    @Test
+    public void decodeUncompressedBlockWithInvalidLenNLenValue() throws Exception {
+        byte[] data = {
+                0b1, // end of block + no compression mode
+                11, 0, -12, -2, // len & ~len
+                'H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd'
+        };
+
+        HuffmanDecoder decoder = new HuffmanDecoder(new ByteArrayInputStream(data));
+        byte[] result = new byte[100];
+        try {
+            int len = decoder.decode(result);
+            fail("Should have failed but returned " + len + " entries: " + Arrays.toString(Arrays.copyOf(result, len)));
+        } catch (IllegalStateException e) {
+            assertEquals("Illegal LEN / NLEN values", e.getMessage());
+        }
+    }
+
+    @Test
+    public void decodeSimpleFixedHuffmanBlock() throws Exception {
+        byte[] data = {
+                //|--- binary filling ---|76543210
+                0b11111111111111111111111111110011, // final block + fixed huffman + H
+                0b00000000000000000000000001001000, // H + e
+                0b11111111111111111111111111001101, // e + l
+                0b11111111111111111111111111001001, // l + l
+                0b11111111111111111111111111001001, // l + o
+                0b00000000000000000000000001010111, // o + ' '
+                0b00000000000000000000000000001000, // ' ' + W
+                0b11111111111111111111111111001111, // W + o
+                0b00000000000000000000000000101111, // o + r
+                0b11111111111111111111111111001010, // r + l
+                0b00000000000000000000000001001001, // l + d
+                0b00000000000000000000000000000001, // d + end of block
+                0b11111111111111111111111111111100 // end of block (00) + garbage
+        };
+
+        HuffmanDecoder decoder = new HuffmanDecoder(new ByteArrayInputStream(data));
+        byte[] result = new byte[100];
+        int len = decoder.decode(result);
+
+        assertEquals(11, len);
+        assertEquals("Hello World", new String(result, 0, len));
+    }
+
+    @Test
+    public void decodeSimpleFixedHuffmanBlockToSmallBuffer() throws Exception {
+        byte[] data = {
+                //|--- binary filling ---|76543210
+                0b11111111111111111111111111110011, // final block + fixed huffman + H
+                0b00000000000000000000000001001000, // H + e
+                0b11111111111111111111111111001101, // e + l
+                0b11111111111111111111111111001001, // l + l
+                0b11111111111111111111111111001001, // l + o
+                0b00000000000000000000000001010111, // o + ' '
+                0b00000000000000000000000000001000, // ' ' + W
+                0b11111111111111111111111111001111, // W + o
+                0b00000000000000000000000000101111, // o + r
+                0b11111111111111111111111111001010, // r + l
+                0b00000000000000000000000001001001, // l + d
+                0b00000000000000000000000000000001, // d + end of block
+                0b11111111111111111111111111111100 // end of block (00) + garbage
+        };
+
+        HuffmanDecoder decoder = new HuffmanDecoder(new ByteArrayInputStream(data));
+        byte[] result = new byte[10];
+        int len;
+        len = decoder.decode(result);
+        assertEquals(10, len);
+        assertEquals("Hello Worl", new String(result, 0, len));
+        len = decoder.decode(result);
+        assertEquals(1, len);
+        assertEquals("d", new String(result, 0, len));
+    }
+
+
+    @Test
+    public void decodeFixedHuffmanBlockWithMemoryLookup() throws Exception {
+        byte[] data = {
+                //|--- binary filling ---|76543210
+                0b11111111111111111111111111110011, // final block + fixed huffman + H
+                0b00000000000000000000000001001000, // H + e
+                0b11111111111111111111111111001101, // e + l
+                0b11111111111111111111111111001001, // l + l
+                0b11111111111111111111111111001001, // l + o
+                0b00000000000000000000000001010111, // o + ' '
+                0b00000000000000000000000000001000, // ' ' + W
+                0b11111111111111111111111111001111, // W + o
+                0b00000000000000000000000000101111, // o + r
+                0b11111111111111111111111111001010, // r + l
+                0b00000000000000000000000001001001, // l + d
+                0b11111111111111111111111111100001, // d + '\n'
+                0b00000000000000000000000000100010, // '\n' + <len>
+                0b11111111111111111111111110000110, // <len> + offset <001> + dist6
+                0b00000000000000000000000000001101, // dist6 + offset <11> + end of block (000000)
+                0b11111111111111111111111111111000 // end of block (0000) + garbage
+        };
+
+        HuffmanDecoder decoder = new HuffmanDecoder(new ByteArrayInputStream(data));
+        byte[] result = new byte[100];
+        int len = decoder.decode(result);
+
+        assertEquals(48, len);
+        assertEquals("Hello World\nHello World\nHello World\nHello World\n", new String(result, 0, len));
+    }
+
+    @Test
+    public void decodeFixedHuffmanBlockWithMemoryLookupInSmallBuffer() throws Exception {
+        byte[] data = {
+                //|--- binary filling ---|76543210
+                0b11111111111111111111111111110011, // final block + fixed huffman + H
+                0b00000000000000000000000001001000, // H + e
+                0b11111111111111111111111111001101, // e + l
+                0b11111111111111111111111111001001, // l + l
+                0b11111111111111111111111111001001, // l + o
+                0b00000000000000000000000001010111, // o + ' '
+                0b00000000000000000000000000001000, // ' ' + W
+                0b11111111111111111111111111001111, // W + o
+                0b00000000000000000000000000101111, // o + r
+                0b11111111111111111111111111001010, // r + l
+                0b00000000000000000000000001001001, // l + d
+                0b11111111111111111111111111100001, // d + '\n'
+                0b00000000000000000000000000100010, // '\n' + <len>
+                0b11111111111111111111111110000110, // <len> + offset <001> + dist6
+                0b00000000000000000000000000001101, // dist6 + offset <11> + end of block (000000)
+                0b11111111111111111111111111111000 // end of block (0000) + garbage
+        };
+
+        HuffmanDecoder decoder = new HuffmanDecoder(new ByteArrayInputStream(data));
+        byte[] result = new byte[30];
+        int len;
+
+        len = decoder.decode(result);
+        assertEquals(30, len);
+        assertEquals("Hello World\nHello World\nHello ", new String(result, 0, len));
+
+        len = decoder.decode(result);
+        assertEquals(18, len);
+        assertEquals("World\nHello World\n", new String(result, 0, len));
+    }
+
+    @Test
+    public void decodeFixedHuffmanBlockWithMemoryLookupInExactBuffer() throws Exception {
+        byte[] data = {
+                //|--- binary filling ---|76543210
+                0b11111111111111111111111111110011, // final block + fixed huffman + H
+                0b00000000000000000000000001001000, // H + e
+                0b11111111111111111111111111001101, // e + l
+                0b11111111111111111111111111001001, // l + l
+                0b11111111111111111111111111001001, // l + o
+                0b00000000000000000000000001010111, // o + ' '
+                0b00000000000000000000000000001000, // ' ' + W
+                0b11111111111111111111111111001111, // W + o
+                0b00000000000000000000000000101111, // o + r
+                0b11111111111111111111111111001010, // r + l
+                0b00000000000000000000000001001001, // l + d
+                0b11111111111111111111111111100001, // d + '\n'
+                0b00000000000000000000000000100010, // '\n' + <len>
+                0b11111111111111111111111110000110, // <len> + offset <001> + dist6
+                0b00000000000000000000000000001101, // dist6 + offset <11> + end of block (000000)
+                0b11111111111111111111111111111000 // end of block (0000) + garbage
+        };
+
+        HuffmanDecoder decoder = new HuffmanDecoder(new ByteArrayInputStream(data));
+        byte[] result = new byte[48];
+        int len;
+
+        len = decoder.decode(result);
+        assertEquals(48, len);
+        assertEquals("Hello World\nHello World\nHello World\nHello World\n", new String(result, 0, len));
+
+        len = decoder.decode(result);
+        assertEquals(0, len);
+
+        len = decoder.decode(result);
+        assertEquals(-1, len);
+    }
+}

http://git-wip-us.apache.org/repos/asf/commons-compress/blob/2042aa00/src/test/java/org/apache/commons/compress/compressors/zip/Deflate64InputStreamTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/compress/compressors/zip/Deflate64InputStreamTest.java b/src/test/java/org/apache/commons/compress/compressors/zip/Deflate64InputStreamTest.java
deleted file mode 100644
index a96c319..0000000
--- a/src/test/java/org/apache/commons/compress/compressors/zip/Deflate64InputStreamTest.java
+++ /dev/null
@@ -1,128 +0,0 @@
-/*
- *  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.compressors.zip;
-
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.Mock;
-import org.mockito.Mockito;
-import org.mockito.runners.MockitoJUnitRunner;
-
-import java.io.BufferedReader;
-import java.io.ByteArrayInputStream;
-import java.io.InputStreamReader;
-
-import static org.junit.Assert.assertEquals;
-import static org.mockito.Mockito.times;
-
-@RunWith(MockitoJUnitRunner.class)
-public class Deflate64InputStreamTest
-{
-   private final HuffmanDecoder nullDecoder = null;
-
-   @Mock
-   private HuffmanDecoder decoder;
-
-   @Test
-   public void readWhenClosed() throws Exception
-   {
-      long size = Integer.MAX_VALUE - 1;
-      Deflate64InputStream input = new Deflate64InputStream(nullDecoder, size);
-      assertEquals(-1, input.read());
-      assertEquals(-1, input.read(new byte[1]));
-      assertEquals(-1, input.read(new byte[1], 0, 1));
-   }
-
-   @Test
-   public void properSizeWhenClosed() throws Exception
-   {
-      long size = Integer.MAX_VALUE - 1;
-      Deflate64InputStream input = new Deflate64InputStream(nullDecoder, size);
-      assertEquals(0, input.available());
-   }
-
-   @Test
-   public void properSizeWhenInRange() throws Exception
-   {
-      long size = Integer.MAX_VALUE - 1;
-      Deflate64InputStream input = new Deflate64InputStream(decoder, size);
-      assertEquals(size, input.available());
-   }
-
-   @Test
-   public void properSizeWhenOutOfRange() throws Exception
-   {
-      long size = Integer.MAX_VALUE + 1L;
-      Deflate64InputStream input = new Deflate64InputStream(decoder, size);
-      assertEquals(Integer.MAX_VALUE, input.available());
-   }
-
-   @Test
-   public void properSizeAfterReading() throws Exception
-   {
-      byte[] buf = new byte[4096];
-      int offset = 1000;
-      int length = 3096;
-
-      Mockito.when(decoder.decode(buf, offset, length)).thenReturn(2048);
-
-      long size = Integer.MAX_VALUE + 2047L;
-      Deflate64InputStream input = new Deflate64InputStream(decoder, size);
-      assertEquals(2048, input.read(buf, offset, length));
-      assertEquals(Integer.MAX_VALUE - 1, input.available());
-   }
-
-   @Test
-   public void closeCallsDecoder() throws Exception
-   {
-
-      Deflate64InputStream input = new Deflate64InputStream(decoder, 10);
-      input.close();
-
-      Mockito.verify(decoder, times(1)).close();
-   }
-
-   @Test
-   public void closeIsDelegatedJustOnce() throws Exception
-   {
-
-      Deflate64InputStream input = new Deflate64InputStream(decoder, 10);
-
-      input.close();
-      input.close();
-
-      Mockito.verify(decoder, times(1)).close();
-   }
-
-   @Test
-   public void uncompressedBlock() throws Exception
-   {
-      byte[] data = {
-         1, 11, 0, -12, -1,
-         'H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd'
-      };
-
-      try (Deflate64InputStream input = new Deflate64InputStream(new ByteArrayInputStream(data), 11);
-           BufferedReader br = new BufferedReader(new InputStreamReader(input)))
-      {
-         assertEquals("Hello World", br.readLine());
-         assertEquals(null, br.readLine());
-      }
-   }
-
-}

http://git-wip-us.apache.org/repos/asf/commons-compress/blob/2042aa00/src/test/java/org/apache/commons/compress/compressors/zip/HuffmanDecoderTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/compress/compressors/zip/HuffmanDecoderTest.java b/src/test/java/org/apache/commons/compress/compressors/zip/HuffmanDecoderTest.java
deleted file mode 100644
index b21756d..0000000
--- a/src/test/java/org/apache/commons/compress/compressors/zip/HuffmanDecoderTest.java
+++ /dev/null
@@ -1,222 +0,0 @@
-/*
- *  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.compressors.zip;
-
-import org.junit.Test;
-
-import java.io.ByteArrayInputStream;
-import java.util.Arrays;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.fail;
-
-public class HuffmanDecoderTest {
-    @Test
-    public void decodeUncompressedBlock() throws Exception {
-        byte[] data = {
-                0b1, // end of block + no compression mode
-                11, 0, -12, -1, // len & ~len
-                'H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd'
-        };
-
-        HuffmanDecoder decoder = new HuffmanDecoder(new ByteArrayInputStream(data));
-        byte[] result = new byte[100];
-        int len = decoder.decode(result);
-
-        assertEquals(11, len);
-        assertEquals("Hello World", new String(result, 0, len));
-    }
-
-    @Test
-    public void decodeUncompressedBlockWithInvalidLenNLenValue() throws Exception {
-        byte[] data = {
-                0b1, // end of block + no compression mode
-                11, 0, -12, -2, // len & ~len
-                'H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd'
-        };
-
-        HuffmanDecoder decoder = new HuffmanDecoder(new ByteArrayInputStream(data));
-        byte[] result = new byte[100];
-        try {
-            int len = decoder.decode(result);
-            fail("Should have failed but returned " + len + " entries: " + Arrays.toString(Arrays.copyOf(result, len)));
-        } catch (IllegalStateException e) {
-            assertEquals("Illegal LEN / NLEN values", e.getMessage());
-        }
-    }
-
-    @Test
-    public void decodeSimpleFixedHuffmanBlock() throws Exception {
-        byte[] data = {
-                //|--- binary filling ---|76543210
-                0b11111111111111111111111111110011, // final block + fixed huffman + H
-                0b00000000000000000000000001001000, // H + e
-                0b11111111111111111111111111001101, // e + l
-                0b11111111111111111111111111001001, // l + l
-                0b11111111111111111111111111001001, // l + o
-                0b00000000000000000000000001010111, // o + ' '
-                0b00000000000000000000000000001000, // ' ' + W
-                0b11111111111111111111111111001111, // W + o
-                0b00000000000000000000000000101111, // o + r
-                0b11111111111111111111111111001010, // r + l
-                0b00000000000000000000000001001001, // l + d
-                0b00000000000000000000000000000001, // d + end of block
-                0b11111111111111111111111111111100 // end of block (00) + garbage
-        };
-
-        HuffmanDecoder decoder = new HuffmanDecoder(new ByteArrayInputStream(data));
-        byte[] result = new byte[100];
-        int len = decoder.decode(result);
-
-        assertEquals(11, len);
-        assertEquals("Hello World", new String(result, 0, len));
-    }
-
-    @Test
-    public void decodeSimpleFixedHuffmanBlockToSmallBuffer() throws Exception {
-        byte[] data = {
-                //|--- binary filling ---|76543210
-                0b11111111111111111111111111110011, // final block + fixed huffman + H
-                0b00000000000000000000000001001000, // H + e
-                0b11111111111111111111111111001101, // e + l
-                0b11111111111111111111111111001001, // l + l
-                0b11111111111111111111111111001001, // l + o
-                0b00000000000000000000000001010111, // o + ' '
-                0b00000000000000000000000000001000, // ' ' + W
-                0b11111111111111111111111111001111, // W + o
-                0b00000000000000000000000000101111, // o + r
-                0b11111111111111111111111111001010, // r + l
-                0b00000000000000000000000001001001, // l + d
-                0b00000000000000000000000000000001, // d + end of block
-                0b11111111111111111111111111111100 // end of block (00) + garbage
-        };
-
-        HuffmanDecoder decoder = new HuffmanDecoder(new ByteArrayInputStream(data));
-        byte[] result = new byte[10];
-        int len;
-        len = decoder.decode(result);
-        assertEquals(10, len);
-        assertEquals("Hello Worl", new String(result, 0, len));
-        len = decoder.decode(result);
-        assertEquals(1, len);
-        assertEquals("d", new String(result, 0, len));
-    }
-
-
-    @Test
-    public void decodeFixedHuffmanBlockWithMemoryLookup() throws Exception {
-        byte[] data = {
-                //|--- binary filling ---|76543210
-                0b11111111111111111111111111110011, // final block + fixed huffman + H
-                0b00000000000000000000000001001000, // H + e
-                0b11111111111111111111111111001101, // e + l
-                0b11111111111111111111111111001001, // l + l
-                0b11111111111111111111111111001001, // l + o
-                0b00000000000000000000000001010111, // o + ' '
-                0b00000000000000000000000000001000, // ' ' + W
-                0b11111111111111111111111111001111, // W + o
-                0b00000000000000000000000000101111, // o + r
-                0b11111111111111111111111111001010, // r + l
-                0b00000000000000000000000001001001, // l + d
-                0b11111111111111111111111111100001, // d + '\n'
-                0b00000000000000000000000000100010, // '\n' + <len>
-                0b11111111111111111111111110000110, // <len> + offset <001> + dist6
-                0b00000000000000000000000000001101, // dist6 + offset <11> + end of block (000000)
-                0b11111111111111111111111111111000 // end of block (0000) + garbage
-        };
-
-        HuffmanDecoder decoder = new HuffmanDecoder(new ByteArrayInputStream(data));
-        byte[] result = new byte[100];
-        int len = decoder.decode(result);
-
-        assertEquals(48, len);
-        assertEquals("Hello World\nHello World\nHello World\nHello World\n", new String(result, 0, len));
-    }
-
-    @Test
-    public void decodeFixedHuffmanBlockWithMemoryLookupInSmallBuffer() throws Exception {
-        byte[] data = {
-                //|--- binary filling ---|76543210
-                0b11111111111111111111111111110011, // final block + fixed huffman + H
-                0b00000000000000000000000001001000, // H + e
-                0b11111111111111111111111111001101, // e + l
-                0b11111111111111111111111111001001, // l + l
-                0b11111111111111111111111111001001, // l + o
-                0b00000000000000000000000001010111, // o + ' '
-                0b00000000000000000000000000001000, // ' ' + W
-                0b11111111111111111111111111001111, // W + o
-                0b00000000000000000000000000101111, // o + r
-                0b11111111111111111111111111001010, // r + l
-                0b00000000000000000000000001001001, // l + d
-                0b11111111111111111111111111100001, // d + '\n'
-                0b00000000000000000000000000100010, // '\n' + <len>
-                0b11111111111111111111111110000110, // <len> + offset <001> + dist6
-                0b00000000000000000000000000001101, // dist6 + offset <11> + end of block (000000)
-                0b11111111111111111111111111111000 // end of block (0000) + garbage
-        };
-
-        HuffmanDecoder decoder = new HuffmanDecoder(new ByteArrayInputStream(data));
-        byte[] result = new byte[30];
-        int len;
-
-        len = decoder.decode(result);
-        assertEquals(30, len);
-        assertEquals("Hello World\nHello World\nHello ", new String(result, 0, len));
-
-        len = decoder.decode(result);
-        assertEquals(18, len);
-        assertEquals("World\nHello World\n", new String(result, 0, len));
-    }
-
-    @Test
-    public void decodeFixedHuffmanBlockWithMemoryLookupInExactBuffer() throws Exception {
-        byte[] data = {
-                //|--- binary filling ---|76543210
-                0b11111111111111111111111111110011, // final block + fixed huffman + H
-                0b00000000000000000000000001001000, // H + e
-                0b11111111111111111111111111001101, // e + l
-                0b11111111111111111111111111001001, // l + l
-                0b11111111111111111111111111001001, // l + o
-                0b00000000000000000000000001010111, // o + ' '
-                0b00000000000000000000000000001000, // ' ' + W
-                0b11111111111111111111111111001111, // W + o
-                0b00000000000000000000000000101111, // o + r
-                0b11111111111111111111111111001010, // r + l
-                0b00000000000000000000000001001001, // l + d
-                0b11111111111111111111111111100001, // d + '\n'
-                0b00000000000000000000000000100010, // '\n' + <len>
-                0b11111111111111111111111110000110, // <len> + offset <001> + dist6
-                0b00000000000000000000000000001101, // dist6 + offset <11> + end of block (000000)
-                0b11111111111111111111111111111000 // end of block (0000) + garbage
-        };
-
-        HuffmanDecoder decoder = new HuffmanDecoder(new ByteArrayInputStream(data));
-        byte[] result = new byte[48];
-        int len;
-
-        len = decoder.decode(result);
-        assertEquals(48, len);
-        assertEquals("Hello World\nHello World\nHello World\nHello World\n", new String(result, 0, len));
-
-        len = decoder.decode(result);
-        assertEquals(0, len);
-
-        len = decoder.decode(result);
-        assertEquals(-1, len);
-    }
-}


Mime
View raw message