| /* |
| * 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.BufferedInputStream; |
| import java.io.FileNotFoundException; |
| import java.io.IOException; |
| import java.util.Arrays; |
| import java.util.zip.Adler32; |
| import java.io.UnsupportedEncodingException; |
| import java.util.zip.DataFormatException; |
| import java.util.zip.Deflater; |
| import java.util.zip.Inflater; |
| import java.util.zip.ZipException; |
| |
| import tests.support.resource.Support_Resources; |
| |
| public class InflaterTest extends junit.framework.TestCase { |
| byte outPutBuff1[] = new byte[500]; |
| |
| byte outPutDiction[] = new byte[500]; |
| |
| /** |
| * @tests java.util.zip.Inflater#end() |
| */ |
| public void test_end() { |
| // test method of java.util.zip.inflater.end() |
| byte byteArray[] = { 5, 2, 3, 7, 8 }; |
| |
| int r = 0; |
| Inflater inflate = new Inflater(); |
| inflate.setInput(byteArray); |
| inflate.end(); |
| try { |
| inflate.reset(); |
| inflate.setInput(byteArray); |
| } catch (NullPointerException e) { |
| r = 1; |
| } |
| assertEquals("inflate can still be used after end is called", 1, r); |
| |
| Inflater i = new Inflater(); |
| i.end(); |
| // check for exception |
| i.end(); |
| } |
| |
| /** |
| * @tests java.util.zip.Inflater#finished() |
| */ |
| public void test_finished() { |
| // test method of java.util.zip.inflater.finished() |
| byte byteArray[] = { 1, 3, 4, 7, 8, 'e', 'r', 't', 'y', '5' }; |
| Inflater inflate = new Inflater(false); |
| byte outPutInf[] = new byte[500]; |
| try { |
| while (!(inflate.finished())) { |
| if (inflate.needsInput()) { |
| inflate.setInput(outPutBuff1); |
| } |
| |
| inflate.inflate(outPutInf); |
| } |
| assertTrue( |
| "the method finished() returned false when no more data needs to be decompressed", |
| inflate.finished()); |
| } catch (DataFormatException e) { |
| fail("Invalid input to be decompressed"); |
| } |
| for (int i = 0; i < byteArray.length; i++) { |
| assertTrue( |
| "Final decompressed data does not equal the original data", |
| byteArray[i] == outPutInf[i]); |
| } |
| assertEquals("final decompressed data contained more bytes than original - finished()", |
| 0, outPutInf[byteArray.length]); |
| } |
| |
| /** |
| * @tests java.util.zip.Inflater#getAdler() |
| */ |
| public void test_getAdler() { |
| // test method of java.util.zip.inflater.getAdler() |
| byte dictionaryArray[] = { 'e', 'r', 't', 'a', 'b', 2, 3 }; |
| |
| Inflater inflateDiction = new Inflater(); |
| inflateDiction.setInput(outPutDiction); |
| if (inflateDiction.needsDictionary() == true) { |
| // getting the checkSum value through the Adler32 class |
| Adler32 adl = new Adler32(); |
| adl.update(dictionaryArray); |
| long checkSumR = adl.getValue(); |
| assertTrue( |
| "the checksum value returned by getAdler() is not the same as the checksum returned by creating the adler32 instance", |
| checkSumR == inflateDiction.getAdler()); |
| } |
| } |
| |
| /** |
| * @tests java.util.zip.Inflater#getRemaining() |
| */ |
| public void test_getRemaining() { |
| // test method of java.util.zip.inflater.getRemaining() |
| byte byteArray[] = { 1, 3, 5, 6, 7 }; |
| Inflater inflate = new Inflater(); |
| assertEquals("upon creating an instance of inflate, getRemaining returned a non zero value", |
| 0, inflate.getRemaining()); |
| inflate.setInput(byteArray); |
| assertTrue( |
| "getRemaining returned zero when there is input in the input buffer", |
| inflate.getRemaining() != 0); |
| } |
| |
| /** |
| * @tests java.util.zip.Inflater#getTotalIn() |
| */ |
| public void test_getTotalIn() { |
| // test method of java.util.zip.inflater.getTotalIn() |
| // creating the decompressed data |
| byte outPutBuf[] = new byte[500]; |
| byte byteArray[] = { 1, 3, 4, 7, 8 }; |
| byte outPutInf[] = new byte[500]; |
| int x = 0; |
| Deflater deflate = new Deflater(1); |
| deflate.setInput(byteArray); |
| while (!(deflate.needsInput())) { |
| x += deflate.deflate(outPutBuf, x, outPutBuf.length - x); |
| } |
| deflate.finish(); |
| while (!(deflate.finished())) { |
| x = x + deflate.deflate(outPutBuf, x, outPutBuf.length - x); |
| } |
| |
| Inflater inflate = new Inflater(); |
| try { |
| while (!(inflate.finished())) { |
| if (inflate.needsInput()) { |
| inflate.setInput(outPutBuf); |
| } |
| |
| inflate.inflate(outPutInf); |
| } |
| } catch (DataFormatException e) { |
| fail("Input to inflate is invalid or corrupted - getTotalIn"); |
| } |
| // System.out.print(deflate.getTotalOut() + " " + inflate.getTotalIn()); |
| assertTrue( |
| "the total byte in outPutBuf did not equal the byte returned in getTotalIn", |
| inflate.getTotalIn() == deflate.getTotalOut()); |
| |
| Inflater inflate2 = new Inflater(); |
| int offSet = 0;// seems only can start as 0 |
| int length = 4; |
| try { |
| // seems no while loops allowed |
| if (inflate2.needsInput()) { |
| inflate2.setInput(outPutBuff1, offSet, length); |
| } |
| |
| inflate2.inflate(outPutInf); |
| |
| } catch (DataFormatException e) { |
| fail("Input to inflate is invalid or corrupted - getTotalIn"); |
| } |
| // System.out.print(inflate2.getTotalIn() + " " + length); |
| assertTrue( |
| "total byte dictated by length did not equal byte returned in getTotalIn", |
| inflate2.getTotalIn() == length); |
| } |
| |
| /** |
| * @tests java.util.zip.Inflater#getTotalOut() |
| */ |
| public void test_getTotalOut() { |
| // test method of java.util.zip.inflater.Inflater() |
| // creating the decompressed data |
| byte outPutBuf[] = new byte[500]; |
| byte byteArray[] = { 1, 3, 4, 7, 8 }; |
| int y = 0; |
| int x = 0; |
| Deflater deflate = new Deflater(1); |
| deflate.setInput(byteArray); |
| while (!(deflate.needsInput())) { |
| x += deflate.deflate(outPutBuf, x, outPutBuf.length - x); |
| } |
| deflate.finish(); |
| while (!(deflate.finished())) { |
| x = x + deflate.deflate(outPutBuf, x, outPutBuf.length - x); |
| } |
| |
| Inflater inflate = new Inflater(); |
| byte outPutInf[] = new byte[500]; |
| try { |
| while (!(inflate.finished())) { |
| if (inflate.needsInput()) { |
| inflate.setInput(outPutBuf); |
| } |
| |
| y += inflate.inflate(outPutInf); |
| } |
| } catch (DataFormatException e) { |
| fail("Input to inflate is invalid or corrupted - getTotalIn"); |
| } |
| |
| assertTrue( |
| "the sum of the bytes returned from inflate does not equal the bytes of getTotalOut()", |
| y == inflate.getTotalOut()); |
| assertTrue( |
| "the total number of bytes to be compressed does not equal the total bytes decompressed", |
| inflate.getTotalOut() == deflate.getTotalIn()); |
| |
| // testing inflate(byte,int,int) |
| inflate.reset(); |
| y = 0; |
| int offSet = 0;// seems only can start as 0 |
| int length = 4; |
| try { |
| while (!(inflate.finished())) { |
| if (inflate.needsInput()) { |
| inflate.setInput(outPutBuf); |
| } |
| |
| y += inflate.inflate(outPutInf, offSet, length); |
| } |
| } catch (DataFormatException e) { |
| System.out |
| .println("Input to inflate is invalid or corrupted - getTotalIn"); |
| } |
| assertTrue( |
| "the sum of the bytes returned from inflate does not equal the bytes of getTotalOut()", |
| y == inflate.getTotalOut()); |
| assertTrue( |
| "the total number of bytes to be compressed does not equal the total bytes decompressed", |
| inflate.getTotalOut() == deflate.getTotalIn()); |
| } |
| |
| /** |
| * @tests java.util.zip.Inflater#inflate(byte[]) |
| */ |
| public void test_inflate$B() { |
| // test method of java.util.zip.inflater.inflate(byte) |
| |
| byte byteArray[] = { 1, 3, 4, 7, 8, 'e', 'r', 't', 'y', '5' }; |
| byte outPutInf[] = new byte[500]; |
| Inflater inflate = new Inflater(); |
| try { |
| while (!(inflate.finished())) { |
| if (inflate.needsInput()) { |
| inflate.setInput(outPutBuff1); |
| } |
| inflate.inflate(outPutInf); |
| } |
| } catch (DataFormatException e) { |
| fail("Invalid input to be decompressed"); |
| } |
| for (int i = 0; i < byteArray.length; i++) { |
| assertTrue( |
| "Final decompressed data does not equal the original data", |
| byteArray[i] == outPutInf[i]); |
| } |
| assertEquals("final decompressed data contained more bytes than original - inflateB", |
| 0, outPutInf[byteArray.length]); |
| // testing for an empty input array |
| byte outPutBuf[] = new byte[500]; |
| byte emptyArray[] = new byte[11]; |
| int x = 0; |
| Deflater defEmpty = new Deflater(3); |
| defEmpty.setInput(emptyArray); |
| while (!(defEmpty.needsInput())) { |
| x += defEmpty.deflate(outPutBuf, x, outPutBuf.length - x); |
| } |
| defEmpty.finish(); |
| while (!(defEmpty.finished())) { |
| x += defEmpty.deflate(outPutBuf, x, outPutBuf.length - x); |
| } |
| assertTrue( |
| "the total number of byte from deflate did not equal getTotalOut - inflate(byte)", |
| x == defEmpty.getTotalOut()); |
| assertTrue( |
| "the number of input byte from the array did not correspond with getTotalIn - inflate(byte)", |
| defEmpty.getTotalIn() == emptyArray.length); |
| Inflater infEmpty = new Inflater(); |
| try { |
| while (!(infEmpty.finished())) { |
| if (infEmpty.needsInput()) { |
| infEmpty.setInput(outPutBuf); |
| } |
| infEmpty.inflate(outPutInf); |
| } |
| } catch (DataFormatException e) { |
| fail("Invalid input to be decompressed"); |
| } |
| for (int i = 0; i < emptyArray.length; i++) { |
| assertTrue( |
| "Final decompressed data does not equal the original data", |
| emptyArray[i] == outPutInf[i]); |
| assertEquals("Final decompressed data does not equal zero", |
| 0, outPutInf[i]); |
| } |
| assertEquals("Final decompressed data contains more element than original data", |
| 0, outPutInf[emptyArray.length]); |
| } |
| |
| public void test_inflate$B1() { |
| byte codedData[] = { |
| 120, -38, 75, -54, 73, -52, 80, 40, 46, 41, -54, -52, 75, 87, |
| 72, -50, -49, 43, 73, -52, -52, 43, 86, 72, 2, 10, 34, 99, |
| -123, -60, -68, 20, -80, 32, 0, -101, -69, 17, 84}; |
| String codedString = "blah string contains blahblahblahblah and blah"; |
| |
| Inflater infl1 = new Inflater(); |
| Inflater infl2 = new Inflater(); |
| |
| byte[] result = new byte[100]; |
| int decLen = 0; |
| |
| infl1.setInput(codedData, 0, codedData.length); |
| try { |
| decLen = infl1.inflate(result); |
| } catch (DataFormatException e) { |
| fail("Unexpected DataFormatException"); |
| } |
| |
| infl1.end(); |
| assertEquals(codedString, new String(result, 0, decLen)); |
| codedData[5] = 0; |
| |
| infl2.setInput(codedData, 0, codedData.length); |
| try { |
| decLen = infl2.inflate(result); |
| fail("Expected DataFormatException"); |
| } catch (DataFormatException e) { |
| // expected |
| } |
| |
| infl2.end(); |
| } |
| |
| /** |
| * @tests java.util.zip.Inflater#inflate(byte[], int, int) |
| */ |
| public void test_inflate$BII() { |
| // test method of java.util.zip.inflater.inflate(byte,int,int) |
| |
| byte byteArray[] = { 1, 3, 4, 7, 8, 'e', 'r', 't', 'y', '5' }; |
| byte outPutInf[] = new byte[100]; |
| int y = 0; |
| Inflater inflate = new Inflater(); |
| try { |
| while (!(inflate.finished())) { |
| if (inflate.needsInput()) { |
| inflate.setInput(outPutBuff1); |
| } |
| y += inflate.inflate(outPutInf, y, outPutInf.length - y); |
| } |
| } catch (DataFormatException e) { |
| fail("Invalid input to be decompressed"); |
| } |
| for (int i = 0; i < byteArray.length; i++) { |
| assertTrue( |
| "Final decompressed data does not equal the original data", |
| byteArray[i] == outPutInf[i]); |
| } |
| assertEquals("final decompressed data contained more bytes than original - inflateB", |
| 0, outPutInf[byteArray.length]); |
| |
| // test boundary checks |
| inflate.reset(); |
| int r = 0; |
| int offSet = 0; |
| int lengthError = 101; |
| try { |
| if (inflate.needsInput()) { |
| inflate.setInput(outPutBuff1); |
| } |
| inflate.inflate(outPutInf, offSet, lengthError); |
| |
| } catch (DataFormatException e) { |
| fail("Invalid input to be decompressed"); |
| } catch (ArrayIndexOutOfBoundsException e) { |
| r = 1; |
| } |
| assertEquals("out of bounds error did not get caught", 1, r); |
| } |
| |
| public void test_inflate$BII1() { |
| byte codedData[] = { |
| 120, -38, 75, -54, 73, -52, 80, 40, 46, 41, -54, -52, 75, 87, |
| 72, -50, -49, 43, 73, -52, -52, 43, 86, 72, 2, 10, 34, 99, |
| -123, -60, -68, 20, -80, 32, 0, -101, -69, 17, 84}; |
| String codedString = "blah string"; |
| |
| Inflater infl1 = new Inflater(); |
| Inflater infl2 = new Inflater(); |
| |
| byte[] result = new byte[100]; |
| int decLen = 0; |
| |
| infl1.setInput(codedData, 0, codedData.length); |
| try { |
| decLen = infl1.inflate(result, 10, 11); |
| } catch (DataFormatException e) { |
| fail("Unexpected DataFormatException"); |
| } |
| |
| infl1.end(); |
| assertEquals(codedString, new String(result, 10, decLen)); |
| codedData[5] = 0; |
| |
| infl2.setInput(codedData, 0, codedData.length); |
| try { |
| decLen = infl2.inflate(result, 10, 11); |
| fail("Expected DataFormatException"); |
| } catch (DataFormatException e) { |
| // expected |
| } |
| |
| infl2.end(); |
| } |
| |
| /** |
| * @tests java.util.zip.Inflater#Inflater() |
| */ |
| public void test_Constructor() { |
| // test method of java.util.zip.inflater.Inflater() |
| Inflater inflate = new Inflater(); |
| assertNotNull("failed to create the instance of inflater", |
| inflate); |
| } |
| |
| /** |
| * @tests java.util.zip.Inflater#Inflater(boolean) |
| */ |
| public void test_ConstructorZ() { |
| // test method of java.util.zip.inflater.Inflater(boolean) |
| // note does not throw exception if deflater has a header, but inflater |
| // doesn't or vice versa. |
| byte byteArray[] = { 1, 3, 4, 7, 8, 'e', 'r', 't', 'y', '5' }; |
| Inflater inflate = new Inflater(true); |
| assertNotNull("failed to create the instance of inflater", inflate); |
| byte outPutInf[] = new byte[500]; |
| int r = 0; |
| try { |
| while (!(inflate.finished())) { |
| if (inflate.needsInput()) { |
| inflate.setInput(outPutBuff1); |
| } |
| |
| inflate.inflate(outPutInf); |
| } |
| for (int i = 0; i < byteArray.length; i++) { |
| assertEquals("the output array from inflate should contain 0 because the header of inflate and deflate did not match, but this failed", |
| 0, outPutBuff1[i]); |
| } |
| } catch (DataFormatException e) { |
| r = 1; |
| } |
| assertEquals("Error: exception should be thrown because of header inconsistency", |
| 1, r); |
| |
| } |
| |
| /** |
| * @tests java.util.zip.Inflater#needsDictionary() |
| */ |
| public void test_needsDictionary() { |
| // test method of java.util.zip.inflater.needsDictionary() |
| // note: this flag is set after inflate is called |
| byte outPutInf[] = new byte[500]; |
| |
| // testing with dictionary set. |
| Inflater inflateDiction = new Inflater(); |
| if (inflateDiction.needsInput()) { |
| inflateDiction.setInput(outPutDiction); |
| } |
| try { |
| assertEquals("should return 0 because needs dictionary", |
| 0, inflateDiction.inflate(outPutInf)); |
| } catch (DataFormatException e) { |
| fail("Should not cause exception"); |
| } |
| assertTrue( |
| "method needsDictionary returned false when dictionary was used in deflater", |
| inflateDiction.needsDictionary()); |
| |
| // testing without dictionary |
| Inflater inflate = new Inflater(); |
| try { |
| inflate.setInput(outPutBuff1); |
| inflate.inflate(outPutInf); |
| assertFalse( |
| "method needsDictionary returned true when dictionary was not used in deflater", |
| inflate.needsDictionary()); |
| } catch (DataFormatException e) { |
| fail( |
| "Input to inflate is invalid or corrupted - needsDictionary"); |
| } |
| |
| // Regression test for HARMONY-86 |
| Inflater inf = new Inflater(); |
| assertFalse(inf.needsDictionary()); |
| assertEquals(0,inf.getTotalIn()); |
| assertEquals(0,inf.getTotalOut()); |
| assertEquals(0,inf.getBytesRead()); |
| assertEquals(0,inf.getBytesWritten()); |
| } |
| |
| /** |
| * @tests java.util.zip.Inflater#needsInput() |
| */ |
| public void test_needsInput() { |
| // test method of java.util.zip.inflater.needsInput() |
| Inflater inflate = new Inflater(); |
| assertTrue( |
| "needsInput give the wrong boolean value as a result of no input buffer", |
| inflate.needsInput()); |
| |
| byte byteArray[] = { 2, 3, 4, 't', 'y', 'u', 'e', 'w', 7, 6, 5, 9 }; |
| inflate.setInput(byteArray); |
| assertFalse( |
| "methodNeedsInput returned true when the input buffer is full", |
| inflate.needsInput()); |
| |
| inflate.reset(); |
| byte byteArrayEmpty[] = new byte[0]; |
| inflate.setInput(byteArrayEmpty); |
| assertTrue( |
| "needsInput give wrong boolean value as a result of an empty input buffer", |
| inflate.needsInput()); |
| } |
| |
| /** |
| * @tests java.util.zip.Inflater#reset() |
| */ |
| public void test_reset() { |
| // test method of java.util.zip.inflater.reset() |
| byte byteArray[] = { 1, 3, 4, 7, 8, 'e', 'r', 't', 'y', '5' }; |
| byte outPutInf[] = new byte[100]; |
| int y = 0; |
| Inflater inflate = new Inflater(); |
| try { |
| while (!(inflate.finished())) { |
| if (inflate.needsInput()) { |
| inflate.setInput(outPutBuff1); |
| } |
| y += inflate.inflate(outPutInf, y, outPutInf.length - y); |
| } |
| } catch (DataFormatException e) { |
| fail("Invalid input to be decompressed"); |
| } |
| for (int i = 0; i < byteArray.length; i++) { |
| assertTrue( |
| "Final decompressed data does not equal the original data", |
| byteArray[i] == outPutInf[i]); |
| } |
| assertEquals("final decompressed data contained more bytes than original - reset", |
| 0, outPutInf[byteArray.length]); |
| |
| // testing that resetting the inflater will also return the correct |
| // decompressed data |
| |
| inflate.reset(); |
| try { |
| while (!(inflate.finished())) { |
| if (inflate.needsInput()) { |
| inflate.setInput(outPutBuff1); |
| } |
| inflate.inflate(outPutInf); |
| } |
| } catch (DataFormatException e) { |
| fail("Invalid input to be decompressed"); |
| } |
| for (int i = 0; i < byteArray.length; i++) { |
| assertTrue( |
| "Final decompressed data does not equal the original data", |
| byteArray[i] == outPutInf[i]); |
| } |
| assertEquals("final decompressed data contained more bytes than original - reset", |
| 0, outPutInf[byteArray.length]); |
| |
| } |
| |
| /** |
| * @tests java.util.zip.Inflater#setDictionary(byte[]) |
| */ |
| public void test_setDictionary$B() { |
| //FIXME This test doesn't pass in Harmony classlib or Sun 5.0_7 RI |
| /* |
| // test method of java.util.zip.inflater.setDictionary(byte) |
| 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 outPutInf[] = new byte[100]; |
| |
| // trying to inflate without setting a dictionary |
| |
| Inflater inflateWO = new Inflater(); |
| byte outPutInf2[] = new byte[100]; |
| int r = 0; |
| try { |
| while (!(inflateWO.finished())) { |
| if (inflateWO.needsInput()) { |
| inflateWO.setInput(outPutDiction); |
| } |
| inflateWO.inflate(outPutInf2); |
| } |
| } catch (DataFormatException e) { |
| r = 1; |
| } |
| assertEquals("invalid input to be decompressed due to dictionary not set", |
| 1, r); |
| // now setting the dictionary in inflater |
| Inflater inflate = new Inflater(); |
| try { |
| while (!(inflate.finished())) { |
| if (inflate.needsInput()) { |
| inflate.setInput(outPutDiction); |
| } |
| if (inflate.needsDictionary()) { |
| inflate.setDictionary(dictionaryArray); |
| } |
| inflate.inflate(outPutInf); |
| } |
| } catch (DataFormatException e) { |
| fail("Invalid input to be decompressed"); |
| } |
| for (int i = 0; i < byteArray.length; i++) { |
| assertTrue( |
| "Final decompressed data does not equal the original data", |
| byteArray[i] == outPutInf[i]); |
| } |
| assertEquals("final decompressed data contained more bytes than original - deflateB", |
| 0, outPutInf[byteArray.length]); |
| */ |
| } |
| |
| /** |
| * @tests java.util.zip.Inflater#setInput(byte[]) |
| */ |
| public void test_setInput$B() { |
| // test method of java.util.zip.inflater.setInput(byte) |
| byte byteArray[] = { 2, 3, 4, 't', 'y', 'u', 'e', 'w', 7, 6, 5, 9 }; |
| Inflater inflate = new Inflater(); |
| inflate.setInput(byteArray); |
| assertTrue("setInputB did not deliver any byte to the input buffer", |
| inflate.getRemaining() != 0); |
| } |
| |
| /** |
| * @tests java.util.zip.Inflater#setInput(byte[], int, int) |
| */ |
| public void test_setInput$BII() { |
| // test method of java.util.zip.inflater.setInput(byte,int,int) |
| byte byteArray[] = { 2, 3, 4, 't', 'y', 'u', 'e', 'w', 7, 6, 5, 9 }; |
| int offSet = 6; |
| int length = 6; |
| Inflater inflate = new Inflater(); |
| inflate.setInput(byteArray, offSet, length); |
| assertTrue( |
| "setInputBII did not deliver the right number of bytes to the input buffer", |
| inflate.getRemaining() == length); |
| // boundary check |
| inflate.reset(); |
| int r = 0; |
| try { |
| inflate.setInput(byteArray, 100, 100); |
| } catch (ArrayIndexOutOfBoundsException e) { |
| r = 1; |
| } |
| assertEquals("boundary check is not present for setInput", 1, r); |
| } |
| |
| @Override |
| protected void setUp() { |
| try { |
| java.io.InputStream infile = Support_Resources |
| .getStream("hyts_compressD.txt"); |
| BufferedInputStream inflatIP = new BufferedInputStream(infile); |
| inflatIP.read(outPutBuff1, 0, outPutBuff1.length); |
| inflatIP.close(); |
| |
| java.io.InputStream infile2 = Support_Resources |
| .getStream("hyts_compDiction.txt"); |
| BufferedInputStream inflatIP2 = new BufferedInputStream(infile2); |
| inflatIP2.read(outPutDiction, 0, outPutDiction.length); |
| inflatIP2.close(); |
| |
| } catch (FileNotFoundException e) { |
| fail( |
| "input file to test InflaterInputStream constructor is not found"); |
| } catch (ZipException e) { |
| fail( |
| "read() threw an zip exception while testing constructor"); |
| } catch (IOException e) { |
| fail("read() threw an exception while testing constructor"); |
| } |
| } |
| |
| @Override |
| protected void tearDown() { |
| } |
| |
| /** |
| * @tests java.util.zip.Deflater#getBytesRead() |
| */ |
| public void test_getBytesRead() throws DataFormatException, |
| UnsupportedEncodingException { |
| // Regression test for HARMONY-158 |
| Deflater def = new Deflater(); |
| Inflater inf = new Inflater(); |
| 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(); |
| def.deflate(output); |
| inf.setInput(output); |
| int compressedDataLength =inf.inflate(input); |
| assertEquals(16, inf.getTotalIn()); |
| assertEquals(compressedDataLength, inf.getTotalOut()); |
| assertEquals(16, inf.getBytesRead()); |
| } |
| |
| /** |
| * @tests java.util.zip.Deflater#getBytesRead() |
| */ |
| public void test_getBytesWritten() throws DataFormatException, UnsupportedEncodingException { |
| // Regression test for HARMONY-158 |
| Deflater def = new Deflater(); |
| Inflater inf = new Inflater(); |
| 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(); |
| def.deflate(output); |
| inf.setInput(output); |
| int compressedDataLength =inf.inflate(input); |
| assertEquals(16, inf.getTotalIn()); |
| assertEquals(compressedDataLength, inf.getTotalOut()); |
| assertEquals(14, inf.getBytesWritten()); |
| } |
| |
| /** |
| * @tests java.util.zip.Deflater#inflate(byte[], int, int) |
| */ |
| public void testInflate() throws Exception { |
| // Regression for HARMONY-81 |
| Inflater inf = new Inflater(); |
| int res = inf.inflate(new byte[0], 0, 0); |
| |
| assertEquals(0, res); |
| |
| // Regression for HARMONY-2508 |
| Inflater inflater = new Inflater(); |
| byte[] b = new byte[1024]; |
| assertEquals(0, inflater.inflate(b)); |
| inflater.end(); |
| |
| // Regression for HARMONY-2510 |
| inflater = new Inflater(); |
| inflater.setInput(new byte[] { -1 }); |
| try { |
| inflater.inflate(b); |
| |
| // The RI detects malformed data on the malformed input { -1 }. Both |
| // this implementation and the native zlib API return "need input" |
| // on that data. This is an error if the stream is exhausted, but |
| // not one that results in an exception in the Inflater API. |
| assertTrue(inflater.needsInput()); |
| } catch (DataFormatException e) { |
| // expected |
| } |
| |
| inflater = new Inflater(); |
| inflater.setInput(new byte[] { -1, -1, -1 }); |
| try { |
| inflater.inflate(b); |
| } catch (DataFormatException e) { |
| // expected |
| } |
| } |
| |
| public void testSetDictionary$B() throws Exception { |
| int i = 0; |
| String inputString = "blah string contains blahblahblahblah and blah"; |
| String dictionary1 = "blah"; |
| String dictionary2 = "1234"; |
| |
| byte[] outputNo = new byte[100]; |
| byte[] output1 = new byte[100]; |
| byte[] output2 = new byte[100]; |
| Deflater defDictNo = new Deflater(9); |
| Deflater defDict1 = new Deflater(9); |
| Deflater defDict2 = new Deflater(9); |
| |
| defDict1.setDictionary(dictionary1.getBytes()); |
| defDict2.setDictionary(dictionary2.getBytes()); |
| |
| defDictNo.setInput(inputString.getBytes()); |
| defDict1.setInput(inputString.getBytes()); |
| defDict2.setInput(inputString.getBytes()); |
| |
| defDictNo.finish(); |
| defDict1.finish(); |
| defDict2.finish(); |
| |
| int dataLenNo = defDictNo.deflate(outputNo); |
| int dataLen1 = defDict1.deflate(output1); |
| int dataLen2 = defDict2.deflate(output2); |
| |
| boolean passNo1 = false; |
| boolean passNo2 = false; |
| boolean pass12 = false; |
| |
| for (i = 0; i < (dataLenNo < dataLen1 ? dataLenNo : dataLen1); i++) { |
| if (outputNo[i] != output1[i]) { |
| passNo1 = true; |
| break; |
| } |
| } |
| for (i = 0; i < (dataLenNo < dataLen1 ? dataLenNo : dataLen2); i++) { |
| if (outputNo[i] != output2[i]) { |
| passNo2 = true; |
| break; |
| } |
| } |
| for (i = 0; i < (dataLen1 < dataLen2 ? dataLen1 : dataLen2); i++) { |
| if (output1[i] != output2[i]) { |
| pass12 = true; |
| break; |
| } |
| } |
| |
| assertTrue( |
| "Compressed data the same for stream with dictionary and without it.", |
| passNo1); |
| assertTrue( |
| "Compressed data the same for stream with dictionary and without it.", |
| passNo2); |
| assertTrue( |
| "Compressed data the same for stream with different dictionaries.", |
| pass12); |
| |
| Inflater inflNo = new Inflater(); |
| Inflater infl1 = new Inflater(); |
| Inflater infl2 = new Inflater(); |
| |
| byte[] result = new byte[100]; |
| int decLen; |
| |
| inflNo.setInput(outputNo, 0, dataLenNo); |
| decLen = inflNo.inflate(result); |
| |
| assertFalse(inflNo.needsDictionary()); |
| inflNo.end(); |
| assertEquals(inputString, new String(result, 0, decLen)); |
| |
| infl1.setInput(output1, 0, dataLen1); |
| decLen = infl1.inflate(result); |
| |
| assertTrue(infl1.needsDictionary()); |
| infl1.setDictionary(dictionary1.getBytes()); |
| decLen = infl1.inflate(result); |
| infl1.end(); |
| assertEquals(inputString, new String(result, 0, decLen)); |
| |
| infl2.setInput(output2, 0, dataLen2); |
| decLen = infl2.inflate(result); |
| |
| assertTrue(infl2.needsDictionary()); |
| infl2.setDictionary(dictionary2.getBytes()); |
| decLen = infl2.inflate(result); |
| infl2.end(); |
| assertEquals(inputString, new String(result, 0, decLen)); |
| |
| |
| inflNo = new Inflater(); |
| infl1 = new Inflater(); |
| inflNo.setInput(outputNo, 0, dataLenNo); |
| try { |
| infl1.setDictionary(dictionary1.getBytes()); |
| fail("IllegalArgumentException expected."); |
| } catch (IllegalArgumentException ee) { |
| // expected. |
| } |
| inflNo.end(); |
| |
| infl1.setInput(output1, 0, dataLen1); |
| decLen = infl1.inflate(result); |
| |
| assertTrue(infl1.needsDictionary()); |
| try { |
| infl1.setDictionary(dictionary2.getBytes()); |
| fail("IllegalArgumentException expected."); |
| } catch (IllegalArgumentException ee) { |
| // expected. |
| } |
| infl1.end(); |
| } |
| |
| public void testSetDictionary$BII() throws Exception { |
| int i = 0; |
| String inputString = "blah string contains blahblahblahblah and blah"; |
| String dictionary1 = "blah"; |
| String dictionary2 = "blahblahblah"; |
| |
| byte[] output1 = new byte[100]; |
| byte[] output2 = new byte[100]; |
| byte[] output3 = new byte[100]; |
| |
| Deflater defDict1 = new Deflater(9); |
| Deflater defDict2 = new Deflater(9); |
| Deflater defDict3 = new Deflater(9); |
| |
| defDict1.setDictionary(dictionary1.getBytes()); |
| defDict2.setDictionary(dictionary2.getBytes()); |
| defDict3.setDictionary(dictionary2.getBytes(), 4, 4); |
| |
| defDict1.setInput(inputString.getBytes()); |
| defDict2.setInput(inputString.getBytes()); |
| defDict3.setInput(inputString.getBytes()); |
| |
| defDict1.finish(); |
| defDict2.finish(); |
| defDict3.finish(); |
| |
| int dataLen1 = defDict1.deflate(output1); |
| int dataLen2 = defDict2.deflate(output2); |
| int dataLen3 = defDict3.deflate(output3); |
| |
| boolean pass12 = false; |
| boolean pass23 = false; |
| boolean pass13 = true; |
| |
| for (i = 0; i < (dataLen1 < dataLen2 ? dataLen1 : dataLen2); i++) { |
| if (output1[i] != output2[i]) { |
| pass12 = true; |
| break; |
| } |
| } |
| for (i = 0; i < (dataLen2 < dataLen3 ? dataLen2 : dataLen3); i++) { |
| if (output2[i] != output3[i]) { |
| pass23 = true; |
| break; |
| } |
| } |
| for (i = 0; i < (dataLen1 < dataLen3 ? dataLen1 : dataLen3); i++) { |
| if (output1[i] != output3[i]) { |
| pass13 = false; |
| break; |
| } |
| } |
| |
| assertTrue( |
| "Compressed data the same for stream with different dictionaries.", |
| pass12); |
| assertTrue( |
| "Compressed data the same for stream with different dictionaries.", |
| pass23); |
| assertTrue( |
| "Compressed data the differs for stream with the same dictionaries.", |
| pass13); |
| |
| Inflater infl1 = new Inflater(); |
| Inflater infl2 = new Inflater(); |
| Inflater infl3 = new Inflater(); |
| |
| byte[] result = new byte[100]; |
| int decLen; |
| |
| infl1.setInput(output1, 0, dataLen1); |
| decLen = infl1.inflate(result); |
| |
| assertTrue(infl1.needsDictionary()); |
| infl1.setDictionary(dictionary2.getBytes(), 4, 4); |
| decLen = infl1.inflate(result); |
| infl1.end(); |
| assertEquals(inputString, new String(result, 0, decLen)); |
| |
| infl2.setInput(output2, 0, dataLen2); |
| decLen = infl2.inflate(result); |
| |
| assertTrue(infl2.needsDictionary()); |
| try { |
| infl2.setDictionary(dictionary1.getBytes()); |
| fail("IllegalArgumentException expected."); |
| } catch (IllegalArgumentException ee) { |
| // expected |
| } |
| infl2.end(); |
| |
| infl3.setInput(output3, 0, dataLen3); |
| decLen = infl3.inflate(result); |
| |
| assertTrue(infl3.needsDictionary()); |
| infl3.setDictionary(dictionary1.getBytes()); |
| decLen = infl3.inflate(result); |
| infl3.end(); |
| assertEquals(inputString, new String(result, 0, decLen)); |
| |
| } |
| |
| } |
