/*
 * 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 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;

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[])
	 */
	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)
	 */
	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()
	 */
	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()
	 */
	public void test_finalize() {
		MyDeflater mdefl = new MyDeflater();
		mdefl.myFinalize();
		System.gc();
		helper_end_test(mdefl, "finalize");
	}

	/**
	 * @tests java.util.zip.Deflater#finish()
	 */
	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()
	 */
	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()
	 */
	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()
	 */
	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()
	 */
	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()
	 */
	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()
	 */
	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[])
	 */
	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)
	 */
	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[])
	 */
	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)
	 */
	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)
	 */
	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)
	 */
	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()
	 */
	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)
	 */
	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)
	 */
	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) {
			}
		}
	}

    /**
     * @tests java.util.zip.Deflater()
     */
    public void test_needsDictionary() {
        Deflater inf = new Deflater();
        assertEquals(0, inf.getTotalIn());
        assertEquals(0, inf.getTotalOut());
        assertEquals(0, inf.getBytesRead());
        assertEquals(0, inf.getBytesWritten());
    }

    /**
     * @throws DataFormatException
     * @throws UnsupportedEncodingException
     * @tests java.util.zip.Deflater#getBytesRead()
     */
    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()
     */
    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());
    }

    //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]);
        }
    }
}