util/zip/DeflaterTest.java

/*
 * 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.harmony.archive.tests.java.util.zip;

import dalvik.annotation.TestTargetClass;
import dalvik.annotation.TestTargets;
import dalvik.annotation.TestLevel;
import dalvik.annotation.TestTargetNew;

import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.util.zip.Adler32;

import java.util.zip.DataFormatException;
import java.util.zip.Deflater;
import java.util.zip.Inflater;

import junit.framework.TestCase;
import tests.support.resource.Support_Resources;

@TestTargetClass(Deflater.class)
public class DeflaterTest extends TestCase {

    class MyDeflater extends Deflater {
        MyDeflater() {
            super();
        }

        MyDeflater(int lvl) {
            super(lvl);
        }

        MyDeflater(int lvl, boolean noHeader) {
            super(lvl, noHeader);
        }

        void myFinalize() {
            finalize();
        }

        int getDefCompression() {
            return DEFAULT_COMPRESSION;
        }

        int getDefStrategy() {
            return DEFAULT_STRATEGY;
        }

        int getHuffman() {
            return HUFFMAN_ONLY;
        }

        int getFiltered() {
            return FILTERED;
        }
    }

    /**
     * @tests java.util.zip.Deflater#deflate(byte[])
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "deflate",
        args = {byte[].class}
    )
    public void test_deflate$B() {
        byte outPutBuf[] = new byte[50];
        byte byteArray[] = {1, 3, 4, 7, 8};
        byte outPutInf[] = new byte[50];
        int x = 0;

        Deflater defl = new Deflater();
        defl.setInput(byteArray);
        defl.finish();
        while (!defl.finished()) {
            x += defl.deflate(outPutBuf);
        }
        assertEquals("Deflater at end of stream, should return 0", 0, defl
                .deflate(outPutBuf));
        int totalOut = defl.getTotalOut();
        int totalIn = defl.getTotalIn();
        assertEquals(x, totalOut);
        assertEquals(byteArray.length, totalIn);
        defl.end();

        Inflater infl = new Inflater();
        try {
            infl.setInput(outPutBuf);
            while (!infl.finished()) {
                infl.inflate(outPutInf);
            }
        } catch (DataFormatException e) {
            fail("Invalid input to be decompressed");
        }
        assertEquals(totalIn, infl.getTotalOut());
        assertEquals(totalOut, infl.getTotalIn());
        for (int i = 0; i < byteArray.length; i++) {
            assertEquals(byteArray[i], outPutInf[i]);
        }
        assertEquals(
                "Final decompressed data contained more bytes than original",
                0, outPutInf[byteArray.length]);
        infl.end();
    }

    /**
     * @tests java.util.zip.Deflater#deflate(byte[], int, int)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "deflate",
        args = {byte[].class, int.class, int.class}
    )
    public void test_deflate$BII() {
        byte outPutBuf[] = new byte[50];
        byte byteArray[] = {5, 2, 3, 7, 8};
        byte outPutInf[] = new byte[50];
        int offSet = 1;
        int length = outPutBuf.length - 1;
        int x = 0;

        Deflater defl = new Deflater();
        defl.setInput(byteArray);
        defl.finish();
        while (!defl.finished()) {
            x += defl.deflate(outPutBuf, offSet, length);
        }
        assertEquals("Deflater at end of stream, should return 0", 0, defl
                .deflate(outPutBuf, offSet, length));
        int totalOut = defl.getTotalOut();
        int totalIn = defl.getTotalIn();
        assertEquals(x, totalOut);
        assertEquals(byteArray.length, totalIn);
        defl.end();

        Inflater infl = new Inflater();
        try {
            infl.setInput(outPutBuf, offSet, length);
            while (!infl.finished()) {
                infl.inflate(outPutInf);
            }
        } catch (DataFormatException e) {
            fail("Invalid input to be decompressed");
        }
        assertEquals(totalIn, infl.getTotalOut());
        assertEquals(totalOut, infl.getTotalIn());
        for (int i = 0; i < byteArray.length; i++) {
            assertEquals(byteArray[i], outPutInf[i]);
        }
        assertEquals(
                "Final decompressed data contained more bytes than original",
                0, outPutInf[byteArray.length]);
        infl.end();

        // Set of tests testing the boundaries of the offSet/length
        defl = new Deflater();
        outPutBuf = new byte[100];
        defl.setInput(byteArray);
        for (int i = 0; i < 2; i++) {
            if (i == 0) {
                offSet = outPutBuf.length + 1;
                length = outPutBuf.length;
            } else {
                offSet = 0;
                length = outPutBuf.length + 1;
            }
            try {
                defl.deflate(outPutBuf, offSet, length);
                fail("Test " + i
                        + ": ArrayIndexOutOfBoundsException not thrown");
            } catch (ArrayIndexOutOfBoundsException e) {
            }
        }
        defl.end();
    }

    /**
     * @tests java.util.zip.Deflater#end()
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "end",
        args = {}
    )
    public void test_end() {
        byte byteArray[] = {5, 2, 3, 7, 8};
        byte outPutBuf[] = new byte[100];

        Deflater defl = new Deflater();
        defl.setInput(byteArray);
        defl.finish();
        while (!defl.finished()) {
            defl.deflate(outPutBuf);
        }
        defl.end();
        helper_end_test(defl, "end");
    }

    /**
     * @tests java.util.zip.Deflater#finalize()
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "finalize",
        args = {}
    )
    public void test_finalize() {
        MyDeflater mdefl = new MyDeflater();
        mdefl.myFinalize();
        System.gc();
        helper_end_test(mdefl, "finalize");
    }

    /**
     * @tests java.util.zip.Deflater#finish()
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "finish",
        args = {}
    )
    public void test_finish() throws Exception {
        // This test already here, its the same as test_deflate()
        byte byteArray[] = {5, 2, 3, 7, 8};
        byte outPutBuf[] = new byte[100];
        byte outPutInf[] = new byte[100];
        int x = 0;
        Deflater defl = new Deflater();
        defl.setInput(byteArray);
        defl.finish();

        // needsInput should never return true after finish() is called
        if (System.getProperty("java.vendor").startsWith("IBM")) {
            assertFalse(
                    "needsInput() should return false after finish() is called",
                    defl.needsInput());
        }

        while (!defl.finished()) {
            x += defl.deflate(outPutBuf);
        }
        int totalOut = defl.getTotalOut();
        int totalIn = defl.getTotalIn();
        assertEquals(x, totalOut);
        assertEquals(byteArray.length, totalIn);
        defl.end();

        Inflater infl = new Inflater();
        infl.setInput(outPutBuf);
        while (!infl.finished()) {
            infl.inflate(outPutInf);
        }
        assertEquals(totalIn, infl.getTotalOut());
        assertEquals(totalOut, infl.getTotalIn());
        for (int i = 0; i < byteArray.length; i++) {
            assertEquals(byteArray[i], outPutInf[i]);
        }
        assertEquals(
                "Final decompressed data contained more bytes than original",
                0, outPutInf[byteArray.length]);
        infl.end();
    }

    /**
     * @tests java.util.zip.Deflater#finished()
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "finished",
        args = {}
    )
    public void test_finished() {
        byte byteArray[] = {5, 2, 3, 7, 8};
        byte outPutBuf[] = new byte[100];
        Deflater defl = new Deflater();
        assertTrue("Test 1: Deflater should not be finished.", !defl.finished());
        defl.setInput(byteArray);
        assertTrue("Test 2: Deflater should not be finished.", !defl.finished());
        defl.finish();
        assertTrue("Test 3: Deflater should not be finished.", !defl.finished());
        while (!defl.finished()) {
            defl.deflate(outPutBuf);
        }
        assertTrue("Test 4: Deflater should be finished.", defl.finished());
        defl.end();
        assertTrue("Test 5: Deflater should be finished.", defl.finished());
    }

    /**
     * @tests java.util.zip.Deflater#getAdler()
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "getAdler",
        args = {}
    )
    public void test_getAdler() {
        byte byteArray[] = {'a', 'b', 'c', 1, 2, 3};
        byte outPutBuf[] = new byte[100];
        Deflater defl = new Deflater();

        // getting the checkSum value using the Adler
        defl.setInput(byteArray);
        defl.finish();
        while (!defl.finished()) {
            defl.deflate(outPutBuf);
        }
        long checkSumD = defl.getAdler();
        defl.end();

        // getting the checkSum value through the Adler32 class
        Adler32 adl = new Adler32();
        adl.update(byteArray);
        long checkSumR = adl.getValue();
        assertEquals(
                "The checksum value returned by getAdler() is not the same as the checksum returned by creating the adler32 instance",
                checkSumD, checkSumR);
    }

    /**
     * @tests java.util.zip.Deflater#getTotalIn()
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "getTotalIn",
        args = {}
    )
    public void test_getTotalIn() {
        byte outPutBuf[] = new byte[5];
        byte byteArray[] = {1, 3, 4, 7, 8};

        Deflater defl = new Deflater();
        defl.setInput(byteArray);
        defl.finish();
        while (!defl.finished()) {
            defl.deflate(outPutBuf);
        }
        assertEquals(byteArray.length, defl.getTotalIn());
        defl.end();

        defl = new Deflater();
        int offSet = 2;
        int length = 3;
        outPutBuf = new byte[5];
        defl.setInput(byteArray, offSet, length);
        defl.finish();
        while (!defl.finished()) {
            defl.deflate(outPutBuf);
        }
        assertEquals(length, defl.getTotalIn());
        defl.end();
    }

    /**
     * @tests java.util.zip.Deflater#getTotalOut()
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "getTotalOut",
        args = {}
    )
    public void test_getTotalOut() {
        // the getTotalOut should equal the sum of value returned by deflate()
        byte outPutBuf[] = new byte[5];
        byte byteArray[] = {5, 2, 3, 7, 8};
        int x = 0;
        Deflater defl = new Deflater();
        defl.setInput(byteArray);
        defl.finish();
        while (!defl.finished()) {
            x += defl.deflate(outPutBuf);
        }
        assertEquals(x, defl.getTotalOut());
        defl.end();

        x = 0;
        int offSet = 2;
        int length = 3;
        defl = new Deflater();
        outPutBuf = new byte[5];
        defl.setInput(byteArray, offSet, length);
        defl.finish();
        while (!defl.finished()) {
            x += defl.deflate(outPutBuf);
        }
        assertEquals(x, defl.getTotalOut());
    }

    /**
     * @tests java.util.zip.Deflater#needsInput()
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "needsInput",
        args = {}
    )
    public void test_needsInput() {
        Deflater defl = new Deflater();
        assertTrue(
                "needsInput give the wrong boolean value as a result of no input buffer",
                defl.needsInput());
        byte byteArray[] = {1, 2, 3};
        defl.setInput(byteArray);
        assertFalse(
                "needsInput give wrong boolean value as a result of a full input buffer",
                defl.needsInput());
        byte[] outPutBuf = new byte[50];
        while (!defl.needsInput()) {
            defl.deflate(outPutBuf);
        }
        byte emptyByteArray[] = new byte[0];
        defl.setInput(emptyByteArray);
        assertTrue(
                "needsInput give wrong boolean value as a result of an empty input buffer",
                defl.needsInput());
        defl.setInput(byteArray);
        defl.finish();
        while (!defl.finished()) {
            defl.deflate(outPutBuf);
        }
        // needsInput should NOT return true after finish() has been
        // called.
        if (System.getProperty("java.vendor").startsWith("IBM")) {
            assertFalse(
                    "needsInput gave wrong boolean value as a result of finish() being called",
                    defl.needsInput());
        }
        defl.end();
    }

    /**
     * @tests java.util.zip.Deflater#reset()
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "reset",
        args = {}
    )
    public void test_reset() {
        byte outPutBuf[] = new byte[100];
        byte outPutInf[] = new byte[100];
        byte curArray[] = new byte[5];
        byte byteArray[] = {1, 3, 4, 7, 8};
        byte byteArray2[] = {8, 7, 4, 3, 1};
        int x = 0;
        int orgValue = 0;
        Deflater defl = new Deflater();

        for (int i = 0; i < 3; i++) {
            if (i == 0) {
                curArray = byteArray;
            } else if (i == 1) {
                curArray = byteArray2;
            } else {
                defl.reset();
            }

            defl.setInput(curArray);
            defl.finish();
            while (!defl.finished()) {
                x += defl.deflate(outPutBuf);
            }

            if (i == 0) {
                assertEquals(x, defl.getTotalOut());
            } else if (i == 1) {
                assertEquals(x, orgValue);
            } else {
                assertEquals(x, orgValue * 2);
            }

            if (i == 0) {
                orgValue = x;
            }

            try {
                Inflater infl = new Inflater();
                infl.setInput(outPutBuf);
                while (!infl.finished()) {
                    infl.inflate(outPutInf);
                }
                infl.end();
            } catch (DataFormatException e) {
                fail("Test " + i + ": Invalid input to be decompressed");
            }

            if (i == 1) {
                curArray = byteArray;
            }

            for (int j = 0; j < curArray.length; j++) {
                assertEquals(curArray[j], outPutInf[j]);
            }
            assertEquals(0, outPutInf[curArray.length]);
        }
    }

    /**
     * @tests java.util.zip.Deflater#setDictionary(byte[])
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "setDictionary",
        args = {byte[].class}
    )
    public void test_setDictionary$B() {
        // This test is very close to getAdler()
        byte dictionaryArray[] = {'e', 'r', 't', 'a', 'b', 2, 3};
        byte byteArray[] = {
                4, 5, 3, 2, 'a', 'b', 6, 7, 8, 9, 0, 's', '3', 'w', 'r'};
        byte outPutBuf[] = new byte[100];

        Deflater defl = new Deflater();
        long deflAdler = defl.getAdler();
        assertEquals(
                "No dictionary set, no data deflated, getAdler should return 1",
                1, deflAdler);
        defl.setDictionary(dictionaryArray);
        deflAdler = defl.getAdler();

        // getting the checkSum value through the Adler32 class
        Adler32 adl = new Adler32();
        adl.update(dictionaryArray);
        long realAdler = adl.getValue();
        assertEquals(deflAdler, realAdler);

        defl.setInput(byteArray);
        defl.finish();
        while (!defl.finished()) {
            defl.deflate(outPutBuf);
        }
        deflAdler = defl.getAdler();
        adl = new Adler32();
        adl.update(byteArray);
        realAdler = adl.getValue();
        // Deflate is finished and there were bytes deflated that did not occur
        // in the dictionaryArray, therefore a new dictionary was automatically
        // set.
        assertEquals(realAdler, deflAdler);
        defl.end();
    }

    /**
     * @tests java.util.zip.Deflater#setDictionary(byte[], int, int)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "setDictionary",
        args = {byte[].class, int.class, int.class}
    )
    public void test_setDictionary$BII() {
        // This test is very close to getAdler()
        byte dictionaryArray[] = {'e', 'r', 't', 'a', 'b', 2, 3, 'o', 't'};
        byte byteArray[] = {
                4, 5, 3, 2, 'a', 'b', 6, 7, 8, 9, 0, 's', '3', 'w', 'r', 't',
                'u', 'i', 'o', 4, 5, 6, 7};
        byte outPutBuf[] = new byte[500];

        int offSet = 4;
        int length = 5;

        Deflater defl = new Deflater();
        long deflAdler = defl.getAdler();
        assertEquals(
                "No dictionary set, no data deflated, getAdler should return 1",
                1, deflAdler);
        defl.setDictionary(dictionaryArray, offSet, length);
        deflAdler = defl.getAdler();

        // getting the checkSum value through the Adler32 class
        Adler32 adl = new Adler32();
        adl.update(dictionaryArray, offSet, length);
        long realAdler = adl.getValue();
        assertEquals(deflAdler, realAdler);

        defl.setInput(byteArray);
        while (!defl.needsInput()) {
            defl.deflate(outPutBuf);
        }
        deflAdler = defl.getAdler();
        adl = new Adler32();
        adl.update(byteArray);
        realAdler = adl.getValue();
        // Deflate is finished and there were bytes deflated that did not occur
        // in the dictionaryArray, therefore a new dictionary was automatically
        // set.
        assertEquals(realAdler, deflAdler);
        defl.end();

        // boundary check
        defl = new Deflater();
        for (int i = 0; i < 2; i++) {
            if (i == 0) {
                offSet = 0;
                length = dictionaryArray.length + 1;
            } else {
                offSet = dictionaryArray.length + 1;
                length = 1;
            }
            try {
                defl.setDictionary(dictionaryArray, offSet, length);
                fail("Test "
                        + i
                        + ": boundary check for setDictionary failed for offset "
                        + offSet + " and length " + length);
            } catch (ArrayIndexOutOfBoundsException e) {
            }
        }
    }

    /**
     * @tests java.util.zip.Deflater#setInput(byte[])
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "setInput",
        args = {byte[].class}
    )
    public void test_setInput$B() {
        byte[] byteArray = {1, 2, 3};
        byte[] outPutBuf = new byte[50];
        byte[] outPutInf = new byte[50];

        Deflater defl = new Deflater();
        defl.setInput(byteArray);
        assertTrue("the array buffer in setInput() is empty", !defl
                .needsInput());
        // The second setInput() should be ignored since needsInput() return
        // false
        defl.setInput(byteArray);
        defl.finish();
        while (!defl.finished()) {
            defl.deflate(outPutBuf);
        }
        defl.end();

        Inflater infl = new Inflater();
        try {
            infl.setInput(outPutBuf);
            while (!infl.finished()) {
                infl.inflate(outPutInf);
            }
        } catch (DataFormatException e) {
            fail("Invalid input to be decompressed");
        }
        for (int i = 0; i < byteArray.length; i++) {
            assertEquals(byteArray[i], outPutInf[i]);
        }
        assertEquals(byteArray.length, infl.getTotalOut());
        infl.end();
    }

    /**
     * @tests java.util.zip.Deflater#setInput(byte[], int, int)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "setInput",
        args = {byte[].class, int.class, int.class}
    )
    public void test_setInput$BII() throws Exception {
        byte[] byteArray = {1, 2, 3, 4, 5};
        byte[] outPutBuf = new byte[50];
        byte[] outPutInf = new byte[50];
        int offSet = 1;
        int length = 3;

        Deflater defl = new Deflater();
        defl.setInput(byteArray, offSet, length);
        assertFalse("the array buffer in setInput() is empty", defl
                .needsInput());
        // The second setInput() should be ignored since needsInput() return
        // false
        defl.setInput(byteArray, offSet, length);
        defl.finish();
        while (!defl.finished()) {
            defl.deflate(outPutBuf);
        }
        defl.end();

        Inflater infl = new Inflater();
        infl.setInput(outPutBuf);
        while (!infl.finished()) {
            infl.inflate(outPutInf);
        }
        for (int i = 0; i < length; i++) {
            assertEquals(byteArray[i + offSet], outPutInf[i]);
        }
        assertEquals(length, infl.getTotalOut());
        infl.end();

        // boundary check
        defl = new Deflater();
        for (int i = 0; i < 2; i++) {
            if (i == 0) {
                offSet = 0;
                length = byteArray.length + 1;
            } else {
                offSet = byteArray.length + 1;
                length = 1;
            }
            try {
                defl.setInput(byteArray, offSet, length);
                fail("Test " + i
                        + ": boundary check for setInput failed for offset "
                        + offSet + " and length " + length);
            } catch (ArrayIndexOutOfBoundsException e) {
            }
        }
    }

    /**
     * @tests java.util.zip.Deflater#setLevel(int)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "setLevel",
        args = {int.class}
    )
    public void test_setLevelI() throws Exception {
        // Very similar to test_Constructor(int)
        byte[] byteArray = new byte[100];
        InputStream inFile = Support_Resources.getStream("hyts_checkInput.txt");
        inFile.read(byteArray);
        inFile.close();

        byte[] outPutBuf;
        int totalOut;
        for (int i = 0; i < 10; i++) {
            Deflater defl = new Deflater();
            defl.setLevel(i);
            outPutBuf = new byte[500];
            defl.setInput(byteArray);
            while (!defl.needsInput()) {
                defl.deflate(outPutBuf);
            }
            defl.finish();
            while (!defl.finished()) {
                defl.deflate(outPutBuf);
            }
            totalOut = defl.getTotalOut();
            defl.end();

            outPutBuf = new byte[500];
            defl = new Deflater(i);
            defl.setInput(byteArray);
            while (!defl.needsInput()) {
                defl.deflate(outPutBuf);
            }
            defl.finish();
            while (!defl.finished()) {
                defl.deflate(outPutBuf);
            }
            assertEquals(totalOut, defl.getTotalOut());
            defl.end();
        }

        // testing boundaries
        try {
            Deflater boundDefl = new Deflater();
            // Level must be between 0-9
            boundDefl.setLevel(-2);
            fail("IllegalArgumentException not thrown when setting level to a number < 0.");
        } catch (IllegalArgumentException e) {
        }
        try {
            Deflater boundDefl = new Deflater();
            boundDefl.setLevel(10);
            fail("IllegalArgumentException not thrown when setting level to a number > 9.");
        } catch (IllegalArgumentException e) {
        }
    }

    /**
     * @tests java.util.zip.Deflater#setStrategy(int)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "setStrategy",
        args = {int.class}
    )
    public void test_setStrategyI() throws Exception {
        byte[] byteArray = new byte[100];
        InputStream inFile = Support_Resources.getStream("hyts_checkInput.txt");
        inFile.read(byteArray);
        inFile.close();

        for (int i = 0; i < 3; i++) {
            byte outPutBuf[] = new byte[500];
            MyDeflater mdefl = new MyDeflater();

            if (i == 0) {
                mdefl.setStrategy(mdefl.getDefStrategy());
            } else if (i == 1) {
                mdefl.setStrategy(mdefl.getHuffman());
            } else {
                mdefl.setStrategy(mdefl.getFiltered());
            }

            mdefl.setInput(byteArray);
            while (!mdefl.needsInput()) {
                mdefl.deflate(outPutBuf);
            }
            mdefl.finish();
            while (!mdefl.finished()) {
                mdefl.deflate(outPutBuf);
            }

            if (i == 0) {
                // System.out.println(mdefl.getTotalOut());
                // ran JDK and found that getTotalOut() = 86 for this particular
                // file
                assertEquals(
                        "getTotalOut() for the default strategy did not correspond with JDK",
                        86, mdefl.getTotalOut());
            } else if (i == 1) {
                // System.out.println(mdefl.getTotalOut());
                // ran JDK and found that getTotalOut() = 100 for this
                // particular file
                assertEquals(
                        "getTotalOut() for the Huffman strategy did not correspond with JDK",
                        100, mdefl.getTotalOut());
            } else {
                // System.out.println(mdefl.getTotalOut());
                // ran JDK and found that totalOut = 93 for this particular file
                assertEquals(
                        "Total Out for the Filtered strategy did not correspond with JDK",
                        93, mdefl.getTotalOut());
            }
            mdefl.end();
        }

        // Attempting to setStrategy to an invalid value
        try {
            Deflater defl = new Deflater();
            defl.setStrategy(-412);
            fail("IllegalArgumentException not thrown when setting strategy to an invalid value.");
        } catch (IllegalArgumentException e) {
        }
    }

    /**
     * @tests java.util.zip.Deflater#Deflater()
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "Deflater",
        args = {}
    )
    public void test_Constructor() throws Exception {
        byte[] byteArray = new byte[100];
        InputStream inFile = Support_Resources.getStream("hyts_checkInput.txt");
        inFile.read(byteArray);
        inFile.close();

        Deflater defl = new Deflater();
        byte[] outPutBuf = new byte[500];
        defl.setInput(byteArray);
        while (!defl.needsInput()) {
            defl.deflate(outPutBuf);
        }
        defl.finish();
        while (!defl.finished()) {
            defl.deflate(outPutBuf);
        }
        int totalOut = defl.getTotalOut();
        defl.end();

        // creating a Deflater using the DEFAULT_COMPRESSION as the int
        MyDeflater mdefl = new MyDeflater();
        mdefl = new MyDeflater(mdefl.getDefCompression());
        outPutBuf = new byte[500];
        mdefl.setInput(byteArray);
        while (!mdefl.needsInput()) {
            mdefl.deflate(outPutBuf);
        }
        mdefl.finish();
        while (!mdefl.finished()) {
            mdefl.deflate(outPutBuf);
        }
        assertEquals(totalOut, mdefl.getTotalOut());
        mdefl.end();
    }

    /**
     * @tests java.util.zip.Deflater#Deflater(int, boolean)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "Deflater",
        args = {int.class, boolean.class}
    )
    public void test_ConstructorIZ() throws Exception {
        byte byteArray[] = {
                4, 5, 3, 2, 'a', 'b', 6, 7, 8, 9, 0, 's', '3', 'w', 'r'};

        Deflater defl = new Deflater();
        byte outPutBuf[] = new byte[500];
        defl.setLevel(2);
        defl.setInput(byteArray);
        while (!defl.needsInput()) {
            defl.deflate(outPutBuf);
        }
        defl.finish();
        while (!defl.finished()) {
            defl.deflate(outPutBuf);
        }
        int totalOut = defl.getTotalOut();
        defl.end();

        outPutBuf = new byte[500];
        defl = new Deflater(2, false);
        defl.setInput(byteArray);
        while (!defl.needsInput()) {
            defl.deflate(outPutBuf);
        }
        defl.finish();
        while (!defl.finished()) {
            defl.deflate(outPutBuf);
        }
        assertEquals(totalOut, defl.getTotalOut());
        defl.end();

        outPutBuf = new byte[500];
        defl = new Deflater(2, true);
        defl.setInput(byteArray);
        while (!defl.needsInput()) {
            defl.deflate(outPutBuf);
        }
        defl.finish();
        while (!defl.finished()) {
            defl.deflate(outPutBuf);
        }
        assertTrue(
                "getTotalOut() should not be equal comparing two Deflaters with different header options.",
                defl.getTotalOut() != totalOut);
        defl.end();

        byte outPutInf[] = new byte[500];
        Inflater infl = new Inflater(true);
        while (!infl.finished()) {
            if (infl.needsInput()) {
                infl.setInput(outPutBuf);
            }
            infl.inflate(outPutInf);
        }
        for (int i = 0; i < byteArray.length; i++) {
            assertEquals(byteArray[i], outPutInf[i]);
        }
        assertEquals(
                "final decompressed data contained more bytes than original - constructorIZ",
                0, outPutInf[byteArray.length]);
        infl.end();

        infl = new Inflater(false);
        outPutInf = new byte[500];
        int r = 0;
        try {
            while (!infl.finished()) {
                if (infl.needsInput()) {
                    infl.setInput(outPutBuf);
                }
                infl.inflate(outPutInf);
            }
        } catch (DataFormatException e) {
            r = 1;
        }
        assertEquals("header option did not correspond", 1, r);

        // testing boundaries
        try {
            Deflater boundDefl = new Deflater();
            // Level must be between 0-9
            boundDefl.setLevel(-2);
            fail("IllegalArgumentException not thrown when setting level to a number < 0.");
        } catch (IllegalArgumentException e) {
        }
        try {
            Deflater boundDefl = new Deflater();
            boundDefl.setLevel(10);
            fail("IllegalArgumentException not thrown when setting level to a number > 9.");
        } catch (IllegalArgumentException e) {
        }
    }

    /**
     * @tests java.util.zip.Deflater#Deflater(int)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "Deflater",
        args = {int.class}
    )
    public void test_ConstructorI() throws Exception {
        byte[] byteArray = new byte[100];
        InputStream inFile = Support_Resources.getStream("hyts_checkInput.txt");
        inFile.read(byteArray);
        inFile.close();

        byte outPutBuf[] = new byte[500];
        Deflater defl = new Deflater(3);
        defl.setInput(byteArray);
        while (!defl.needsInput()) {
            defl.deflate(outPutBuf);
        }
        defl.finish();
        while (!defl.finished()) {
            defl.deflate(outPutBuf);
        }
        int totalOut = defl.getTotalOut();
        defl.end();

        // test to see if the compression ratio is the same as setting the level
        // on a deflater
        outPutBuf = new byte[500];
        defl = new Deflater();
        defl.setLevel(3);
        defl.setInput(byteArray);
        while (!defl.needsInput()) {
            defl.deflate(outPutBuf);
        }
        defl.finish();
        while (!defl.finished()) {
            defl.deflate(outPutBuf);
        }
        assertEquals(totalOut, defl.getTotalOut());
        defl.end();

        // testing boundaries
        try {
            Deflater boundDefl = new Deflater();
            // Level must be between 0-9
            boundDefl.setLevel(-2);
            fail("IllegalArgumentException not thrown when setting level to a number < 0.");
        } catch (IllegalArgumentException e) {
        }
        try {
            Deflater boundDefl = new Deflater();
            boundDefl.setLevel(10);
            fail("IllegalArgumentException not thrown when setting level to a number > 9.");
        } catch (IllegalArgumentException e) {
        }
    }

    private void helper_end_test(Deflater defl, String desc) {
        // Help tests for test_end() and test_reset().
        byte byteArray[] = {5, 2, 3, 7, 8};

        // Methods where we expect IllegalStateException or NullPointerException
        // to be thrown
        try {
            defl.getTotalOut();
            fail("defl.getTotalOut() can still be used after " + desc
                    + " is called in test_" + desc);
        } catch (IllegalStateException e) {
        } catch (NullPointerException e) {
        }
        try {
            defl.getTotalIn();
            fail("defl.getTotalIn() can still be used after " + desc
                    + " is called in test_" + desc);
        } catch (IllegalStateException e) {
        } catch (NullPointerException e) {
        }
        try {
            defl.getAdler();
            fail("defl.getAdler() can still be used after " + desc
                    + " is called in test_" + desc);
        } catch (IllegalStateException e) {
        } catch (NullPointerException e) {
        }
        try {
            byte[] dict = {'a', 'b', 'c'};
            defl.setDictionary(dict);
            fail("defl.setDictionary() can still be used after " + desc
                    + " is called in test_" + desc);
        } catch (IllegalStateException e) {
        } catch (NullPointerException e) {
        }
        try {
            defl.getTotalIn();
            fail("defl.getTotalIn() can still be used after " + desc
                    + " is called in test_" + desc);
        } catch (IllegalStateException e) {
        } catch (NullPointerException e) {
        }
        try {
            defl.getTotalIn();
            fail("defl.getTotalIn() can still be used after " + desc
                    + " is called in test_" + desc);
        } catch (IllegalStateException e) {
        } catch (NullPointerException e) {
        }
        try {
            defl.deflate(byteArray);
            fail("defl.deflate() can still be used after " + desc
                    + " is called in test_" + desc);
        } catch (IllegalStateException e) {
        } catch (NullPointerException e) {
        }

        // Methods where we expect NullPointerException to be thrown
        try {
            defl.reset();
            fail("defl.reset() can still be used after " + desc
                    + " is called in test_" + desc);
        } catch (NullPointerException e) {
        }

        // Methods that should be allowed to be called after end() is called
        defl.needsInput();
        defl.setStrategy(1);
        defl.setLevel(1);
        defl.end();

        // Methods where exceptions should be thrown
        String vendor = System.getProperty("java.vendor");
        if (vendor.indexOf("IBM") != -1) {
            try {
                defl.setInput(byteArray);
                fail("defl.setInput() can still be used after " + desc
                        + " is called in test_" + desc);
            } catch (IllegalStateException e) {
            }
        }
    }

    /**
     * @throws DataFormatException
     * @throws UnsupportedEncodingException
     * @tests java.util.zip.Deflater#getBytesRead()
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "getBytesRead",
        args = {}
    )
    public void test_getBytesRead() throws DataFormatException,
            UnsupportedEncodingException {
        // Regression test for HARMONY-158
        Deflater def = new Deflater();
        assertEquals(0, def.getTotalIn());
        assertEquals(0, def.getTotalOut());
        assertEquals(0, def.getBytesRead());
        // Encode a String into bytes
        String inputString = "blahblahblah??";
        byte[] input = inputString.getBytes("UTF-8");

        // Compress the bytes
        byte[] output = new byte[100];
        def.setInput(input);
        def.finish();
        int compressedDataLength = def.deflate(output);
        assertEquals(14, def.getTotalIn());
        assertEquals(compressedDataLength, def.getTotalOut());
        assertEquals(14, def.getBytesRead());
    }

    /**
     * @throws DataFormatException
     * @throws UnsupportedEncodingException
     * @tests java.util.zip.Deflater#getBytesRead()
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "getBytesWritten",
        args = {}
    )
    public void test_getBytesWritten() throws DataFormatException,
            UnsupportedEncodingException {
        // Regression test for HARMONY-158
        Deflater def = new Deflater();
        assertEquals(0, def.getTotalIn());
        assertEquals(0, def.getTotalOut());
        assertEquals(0, def.getBytesWritten());
        // Encode a String into bytes
        String inputString = "blahblahblah??";
        byte[] input = inputString.getBytes("UTF-8");

        // Compress the bytes
        byte[] output = new byte[100];
        def.setInput(input);
        def.finish();
        int compressedDataLength = def.deflate(output);
        assertEquals(14, def.getTotalIn());
        assertEquals(compressedDataLength, def.getTotalOut());
        assertEquals(compressedDataLength, def.getBytesWritten());
    }

    // BEGIN android-removed
    // We use different default settings for deflating, so our output won't be
    // the
    // same.
    // //Regression Test for HARMONY-2481
    // public void test_deflate_beforeSetInput() throws Exception {
    // Deflater deflater = new Deflater();
    // deflater.finish();
    // byte[] buffer = new byte[1024];
    // assertEquals(8, deflater.deflate(buffer));
    // byte[] expectedBytes = { 120, -100, 3, 0, 0, 0, 0, 1 };
    // for (int i = 0; i < expectedBytes.length; i++) {
    // assertEquals(expectedBytes[i], buffer[i]);
    // }
    // }
    // END android-removed
}