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