1 /* 2 * Licensed to the Apache Software Foundation (ASF) under one or more 3 * contributor license agreements. See the NOTICE file distributed with 4 * this work for additional information regarding copyright ownership. 5 * The ASF licenses this file to You under the Apache License, Version 2.0 6 * (the "License"); you may not use this file except in compliance with 7 * the License. You may obtain a copy of the License at 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 */ 17 18 package org.apache.harmony.tests.java.util.zip; 19 20 import java.io.InputStream; 21 import java.io.UnsupportedEncodingException; 22 import java.util.zip.Adler32; 23 import java.util.zip.DataFormatException; 24 import java.util.zip.Deflater; 25 import java.util.zip.Inflater; 26 import libcore.junit.junit3.TestCaseWithRules; 27 import libcore.junit.util.ResourceLeakageDetector; 28 import org.junit.Rule; 29 import org.junit.rules.TestRule; 30 import tests.support.resource.Support_Resources; 31 32 public class DeflaterTest extends TestCaseWithRules { 33 @Rule 34 public TestRule guardRule = ResourceLeakageDetector.getRule(); 35 36 class MyDeflater extends Deflater { MyDeflater()37 MyDeflater() { 38 super(); 39 } 40 MyDeflater(int lvl)41 MyDeflater(int lvl) { 42 super(lvl); 43 } 44 getDefCompression()45 int getDefCompression() { 46 return DEFAULT_COMPRESSION; 47 } 48 getDefStrategy()49 int getDefStrategy() { 50 return DEFAULT_STRATEGY; 51 } 52 getHuffman()53 int getHuffman() { 54 return HUFFMAN_ONLY; 55 } 56 getFiltered()57 int getFiltered() { 58 return FILTERED; 59 } 60 } 61 62 /** 63 * java.util.zip.Deflater#deflate(byte[]) 64 */ test_deflate$B()65 public void test_deflate$B() { 66 byte outPutBuf[] = new byte[50]; 67 byte byteArray[] = { 1, 3, 4, 7, 8 }; 68 byte outPutInf[] = new byte[50]; 69 int x = 0; 70 71 Deflater defl = new Deflater(); 72 defl.setInput(byteArray); 73 defl.finish(); 74 while (!defl.finished()) { 75 x += defl.deflate(outPutBuf); 76 } 77 assertEquals("Deflater at end of stream, should return 0", 0, defl 78 .deflate(outPutBuf)); 79 int totalOut = defl.getTotalOut(); 80 int totalIn = defl.getTotalIn(); 81 assertEquals(x, totalOut); 82 assertEquals(byteArray.length, totalIn); 83 defl.end(); 84 85 Inflater infl = new Inflater(); 86 try { 87 infl.setInput(outPutBuf); 88 while (!infl.finished()) { 89 infl.inflate(outPutInf); 90 } 91 } catch (DataFormatException e) { 92 fail("Invalid input to be decompressed"); 93 } 94 assertEquals(totalIn, infl.getTotalOut()); 95 assertEquals(totalOut, infl.getTotalIn()); 96 for (int i = 0; i < byteArray.length; i++) { 97 assertEquals(byteArray[i], outPutInf[i]); 98 } 99 assertEquals("Final decompressed data contained more bytes than original", 100 0, outPutInf[byteArray.length]); 101 infl.end(); 102 } 103 104 /** 105 * java.util.zip.Deflater#deflate(byte[], int, int) 106 */ test_deflate$BII()107 public void test_deflate$BII() { 108 byte outPutBuf[] = new byte[50]; 109 byte byteArray[] = { 5, 2, 3, 7, 8 }; 110 byte outPutInf[] = new byte[50]; 111 int offSet = 1; 112 int length = outPutBuf.length - 1; 113 int x = 0; 114 115 Deflater defl = new Deflater(); 116 defl.setInput(byteArray); 117 defl.finish(); 118 while (!defl.finished()) { 119 x += defl.deflate(outPutBuf, offSet, length); 120 } 121 assertEquals("Deflater at end of stream, should return 0", 0, defl.deflate( 122 outPutBuf, offSet, length)); 123 int totalOut = defl.getTotalOut(); 124 int totalIn = defl.getTotalIn(); 125 assertEquals(x, totalOut); 126 assertEquals(byteArray.length, totalIn); 127 defl.end(); 128 129 Inflater infl = new Inflater(); 130 try { 131 infl.setInput(outPutBuf, offSet, length); 132 while (!infl.finished()) { 133 infl.inflate(outPutInf); 134 } 135 } catch (DataFormatException e) { 136 fail("Invalid input to be decompressed"); 137 } 138 assertEquals(totalIn, infl.getTotalOut()); 139 assertEquals(totalOut, infl.getTotalIn()); 140 for (int i = 0; i < byteArray.length; i++) { 141 assertEquals(byteArray[i], outPutInf[i]); 142 } 143 assertEquals("Final decompressed data contained more bytes than original", 144 0, outPutInf[byteArray.length]); 145 infl.end(); 146 147 // Set of tests testing the boundaries of the offSet/length 148 defl = new Deflater(); 149 outPutBuf = new byte[100]; 150 defl.setInput(byteArray); 151 for (int i = 0; i < 2; i++) { 152 if (i == 0) { 153 offSet = outPutBuf.length + 1; 154 length = outPutBuf.length; 155 } else { 156 offSet = 0; 157 length = outPutBuf.length + 1; 158 } 159 try { 160 defl.deflate(outPutBuf, offSet, length); 161 fail("Test " + i 162 + ": ArrayIndexOutOfBoundsException not thrown"); 163 } catch (ArrayIndexOutOfBoundsException e) { 164 } 165 } 166 defl.end(); 167 } 168 169 /** 170 * java.util.zip.Deflater#end() 171 */ test_end()172 public void test_end() { 173 byte byteArray[] = { 5, 2, 3, 7, 8 }; 174 byte outPutBuf[] = new byte[100]; 175 176 Deflater defl = new Deflater(); 177 defl.setInput(byteArray); 178 defl.finish(); 179 while (!defl.finished()) { 180 defl.deflate(outPutBuf); 181 } 182 defl.end(); 183 helper_end_test(defl, "end"); 184 } 185 186 /** 187 * java.util.zip.Deflater#finish() 188 */ test_finish()189 public void test_finish() throws Exception { 190 // This test already here, its the same as test_deflate() 191 byte byteArray[] = { 5, 2, 3, 7, 8 }; 192 byte outPutBuf[] = new byte[100]; 193 byte outPutInf[] = new byte[100]; 194 int x = 0; 195 Deflater defl = new Deflater(); 196 defl.setInput(byteArray); 197 defl.finish(); 198 199 // needsInput should never return true after finish() is called 200 if (System.getProperty("java.vendor").startsWith("IBM")) { 201 assertFalse("needsInput() should return false after finish() is called", defl 202 .needsInput()); 203 } 204 205 while (!defl.finished()) { 206 x += defl.deflate(outPutBuf); 207 } 208 int totalOut = defl.getTotalOut(); 209 int totalIn = defl.getTotalIn(); 210 assertEquals(x, totalOut); 211 assertEquals(byteArray.length, totalIn); 212 defl.end(); 213 214 Inflater infl = new Inflater(); 215 infl.setInput(outPutBuf); 216 while (!infl.finished()) { 217 infl.inflate(outPutInf); 218 } 219 assertEquals(totalIn, infl.getTotalOut()); 220 assertEquals(totalOut, infl.getTotalIn()); 221 for (int i = 0; i < byteArray.length; i++) { 222 assertEquals(byteArray[i], outPutInf[i]); 223 } 224 assertEquals("Final decompressed data contained more bytes than original", 225 0, outPutInf[byteArray.length]); 226 infl.end(); 227 } 228 229 /** 230 * java.util.zip.Deflater#finished() 231 */ test_finished()232 public void test_finished() { 233 byte byteArray[] = { 5, 2, 3, 7, 8 }; 234 byte outPutBuf[] = new byte[100]; 235 Deflater defl = new Deflater(); 236 assertTrue("Test 1: Deflater should not be finished.", !defl.finished()); 237 defl.setInput(byteArray); 238 assertTrue("Test 2: Deflater should not be finished.", !defl.finished()); 239 defl.finish(); 240 assertTrue("Test 3: Deflater should not be finished.", !defl.finished()); 241 while (!defl.finished()) { 242 defl.deflate(outPutBuf); 243 } 244 assertTrue("Test 4: Deflater should be finished.", defl.finished()); 245 defl.end(); 246 assertTrue("Test 5: Deflater should be finished.", defl.finished()); 247 } 248 249 /** 250 * java.util.zip.Deflater#getAdler() 251 */ test_getAdler()252 public void test_getAdler() { 253 byte byteArray[] = { 'a', 'b', 'c', 1, 2, 3 }; 254 byte outPutBuf[] = new byte[100]; 255 Deflater defl = new Deflater(); 256 257 // getting the checkSum value using the Adler 258 defl.setInput(byteArray); 259 defl.finish(); 260 while (!defl.finished()) { 261 defl.deflate(outPutBuf); 262 } 263 long checkSumD = defl.getAdler(); 264 defl.end(); 265 266 // getting the checkSum value through the Adler32 class 267 Adler32 adl = new Adler32(); 268 adl.update(byteArray); 269 long checkSumR = adl.getValue(); 270 assertEquals( 271 "The checksum value returned by getAdler() is not the same as the checksum returned by creating the adler32 instance", 272 checkSumD, checkSumR); 273 } 274 275 /** 276 * java.util.zip.Deflater#getTotalIn() 277 */ test_getTotalIn()278 public void test_getTotalIn() { 279 byte outPutBuf[] = new byte[5]; 280 byte byteArray[] = { 1, 3, 4, 7, 8 }; 281 282 Deflater defl = new Deflater(); 283 defl.setInput(byteArray); 284 defl.finish(); 285 while (!defl.finished()) { 286 defl.deflate(outPutBuf); 287 } 288 assertEquals(byteArray.length, defl.getTotalIn()); 289 defl.end(); 290 291 defl = new Deflater(); 292 int offSet = 2; 293 int length = 3; 294 outPutBuf = new byte[5]; 295 defl.setInput(byteArray, offSet, length); 296 defl.finish(); 297 while (!defl.finished()) { 298 defl.deflate(outPutBuf); 299 } 300 assertEquals(length, defl.getTotalIn()); 301 defl.end(); 302 } 303 304 /** 305 * java.util.zip.Deflater#getTotalOut() 306 */ test_getTotalOut()307 public void test_getTotalOut() { 308 // the getTotalOut should equal the sum of value returned by deflate() 309 byte outPutBuf[] = new byte[5]; 310 byte byteArray[] = { 5, 2, 3, 7, 8 }; 311 int x = 0; 312 Deflater defl = new Deflater(); 313 defl.setInput(byteArray); 314 defl.finish(); 315 while (!defl.finished()) { 316 x += defl.deflate(outPutBuf); 317 } 318 assertEquals(x, defl.getTotalOut()); 319 defl.end(); 320 321 x = 0; 322 int offSet = 2; 323 int length = 3; 324 defl = new Deflater(); 325 outPutBuf = new byte[5]; 326 defl.setInput(byteArray, offSet, length); 327 defl.finish(); 328 while (!defl.finished()) { 329 x += defl.deflate(outPutBuf); 330 } 331 assertEquals(x, defl.getTotalOut()); 332 defl.end(); 333 } 334 335 /** 336 * java.util.zip.Deflater#needsInput() 337 */ test_needsInput()338 public void test_needsInput() { 339 Deflater defl = new Deflater(); 340 assertTrue( 341 "needsInput give the wrong boolean value as a result of no input buffer", 342 defl.needsInput()); 343 byte byteArray[] = { 1, 2, 3 }; 344 defl.setInput(byteArray); 345 assertFalse( 346 "needsInput give wrong boolean value as a result of a full input buffer", 347 defl.needsInput()); 348 byte[] outPutBuf = new byte[50]; 349 while (!defl.needsInput()) { 350 defl.deflate(outPutBuf); 351 } 352 byte emptyByteArray[] = new byte[0]; 353 defl.setInput(emptyByteArray); 354 assertTrue( 355 "needsInput give wrong boolean value as a result of an empty input buffer", 356 defl.needsInput()); 357 defl.setInput(byteArray); 358 defl.finish(); 359 while (!defl.finished()) { 360 defl.deflate(outPutBuf); 361 } 362 // needsInput should NOT return true after finish() has been 363 // called. 364 if (System.getProperty("java.vendor").startsWith("IBM")) { 365 assertFalse( 366 "needsInput gave wrong boolean value as a result of finish() being called", 367 defl.needsInput()); 368 } 369 defl.end(); 370 } 371 372 /** 373 * java.util.zip.Deflater#reset() 374 */ test_reset()375 public void test_reset() { 376 byte outPutBuf[] = new byte[100]; 377 byte outPutInf[] = new byte[100]; 378 byte curArray[] = new byte[5]; 379 byte byteArray[] = { 1, 3, 4, 7, 8 }; 380 byte byteArray2[] = { 8, 7, 4, 3, 1 }; 381 int x = 0; 382 int orgValue = 0; 383 Deflater defl = new Deflater(); 384 385 for (int i = 0; i < 3; i++) { 386 if (i == 0) { 387 curArray = byteArray; 388 } else if (i == 1) { 389 curArray = byteArray2; 390 } else { 391 defl.reset(); 392 } 393 394 defl.setInput(curArray); 395 defl.finish(); 396 while (!defl.finished()) { 397 x += defl.deflate(outPutBuf); 398 } 399 400 if (i == 0) { 401 assertEquals(x, defl.getTotalOut()); 402 } else if (i == 1) { 403 assertEquals(x, orgValue); 404 } else { 405 assertEquals(x, orgValue * 2); 406 } 407 408 if (i == 0) { 409 orgValue = x; 410 } 411 412 try { 413 Inflater infl = new Inflater(); 414 infl.setInput(outPutBuf); 415 while (!infl.finished()) { 416 infl.inflate(outPutInf); 417 } 418 infl.end(); 419 } catch (DataFormatException e) { 420 fail("Test " + i + ": Invalid input to be decompressed"); 421 } 422 423 if (i == 1) { 424 curArray = byteArray; 425 } 426 427 for (int j = 0; j < curArray.length; j++) { 428 assertEquals(curArray[j], outPutInf[j]); 429 } 430 assertEquals(0, outPutInf[curArray.length]); 431 } 432 defl.end(); 433 } 434 435 /** 436 * java.util.zip.Deflater#setDictionary(byte[]) 437 */ test_setDictionary$B()438 public void test_setDictionary$B() { 439 // This test is very close to getAdler() 440 byte dictionaryArray[] = { 'e', 'r', 't', 'a', 'b', 2, 3 }; 441 byte byteArray[] = { 4, 5, 3, 2, 'a', 'b', 6, 7, 8, 9, 0, 's', '3', 442 'w', 'r' }; 443 byte outPutBuf[] = new byte[100]; 444 445 Deflater defl = new Deflater(); 446 long deflAdler = defl.getAdler(); 447 assertEquals("No dictionary set, no data deflated, getAdler should return 1", 448 1, deflAdler); 449 defl.setDictionary(dictionaryArray); 450 deflAdler = defl.getAdler(); 451 452 // getting the checkSum value through the Adler32 class 453 Adler32 adl = new Adler32(); 454 adl.update(dictionaryArray); 455 long realAdler = adl.getValue(); 456 assertEquals(deflAdler, realAdler); 457 458 defl.setInput(byteArray); 459 defl.finish(); 460 while (!defl.finished()) { 461 defl.deflate(outPutBuf); 462 } 463 deflAdler = defl.getAdler(); 464 adl = new Adler32(); 465 adl.update(byteArray); 466 realAdler = adl.getValue(); 467 // Deflate is finished and there were bytes deflated that did not occur 468 // in the dictionaryArray, therefore a new dictionary was automatically 469 // set. 470 assertEquals(realAdler, deflAdler); 471 defl.end(); 472 } 473 474 /** 475 * java.util.zip.Deflater#setDictionary(byte[], int, int) 476 */ test_setDictionary$BII()477 public void test_setDictionary$BII() { 478 // This test is very close to getAdler() 479 byte dictionaryArray[] = { 'e', 'r', 't', 'a', 'b', 2, 3, 'o', 't' }; 480 byte byteArray[] = { 4, 5, 3, 2, 'a', 'b', 6, 7, 8, 9, 0, 's', '3', 481 'w', 'r', 't', 'u', 'i', 'o', 4, 5, 6, 7 }; 482 byte outPutBuf[] = new byte[500]; 483 484 int offSet = 4; 485 int length = 5; 486 487 Deflater defl = new Deflater(); 488 long deflAdler = defl.getAdler(); 489 assertEquals("No dictionary set, no data deflated, getAdler should return 1", 490 1, deflAdler); 491 defl.setDictionary(dictionaryArray, offSet, length); 492 deflAdler = defl.getAdler(); 493 494 // getting the checkSum value through the Adler32 class 495 Adler32 adl = new Adler32(); 496 adl.update(dictionaryArray, offSet, length); 497 long realAdler = adl.getValue(); 498 assertEquals(deflAdler, realAdler); 499 500 defl.setInput(byteArray); 501 while (!defl.needsInput()) { 502 defl.deflate(outPutBuf); 503 } 504 deflAdler = defl.getAdler(); 505 adl = new Adler32(); 506 adl.update(byteArray); 507 realAdler = adl.getValue(); 508 // Deflate is finished and there were bytes deflated that did not occur 509 // in the dictionaryArray, therefore a new dictionary was automatically 510 // set. 511 assertEquals(realAdler, deflAdler); 512 defl.end(); 513 514 // boundary check 515 defl = new Deflater(); 516 for (int i = 0; i < 2; i++) { 517 if (i == 0) { 518 offSet = 0; 519 length = dictionaryArray.length + 1; 520 } else { 521 offSet = dictionaryArray.length + 1; 522 length = 1; 523 } 524 try { 525 defl.setDictionary(dictionaryArray, offSet, length); 526 fail( 527 "Test " 528 + i 529 + ": boundary check for setDictionary failed for offset " 530 + offSet + " and length " + length); 531 } catch (ArrayIndexOutOfBoundsException e) { 532 } 533 } 534 defl.end(); 535 } 536 537 /** 538 * java.util.zip.Deflater#setInput(byte[]) 539 */ test_setInput$B()540 public void test_setInput$B() { 541 byte[] byteArray = { 1, 2, 3 }; 542 byte[] outPutBuf = new byte[50]; 543 byte[] outPutInf = new byte[50]; 544 545 Deflater defl = new Deflater(); 546 defl.setInput(byteArray); 547 assertTrue("the array buffer in setInput() is empty", !defl 548 .needsInput()); 549 // The second setInput() should be ignored since needsInput() return 550 // false 551 defl.setInput(byteArray); 552 defl.finish(); 553 while (!defl.finished()) { 554 defl.deflate(outPutBuf); 555 } 556 defl.end(); 557 558 Inflater infl = new Inflater(); 559 try { 560 infl.setInput(outPutBuf); 561 while (!infl.finished()) { 562 infl.inflate(outPutInf); 563 } 564 } catch (DataFormatException e) { 565 fail("Invalid input to be decompressed"); 566 } 567 for (int i = 0; i < byteArray.length; i++) { 568 assertEquals(byteArray[i], outPutInf[i]); 569 } 570 assertEquals(byteArray.length, infl.getTotalOut()); 571 infl.end(); 572 } 573 574 /** 575 * java.util.zip.Deflater#setInput(byte[], int, int) 576 */ test_setInput$BII()577 public void test_setInput$BII() throws Exception { 578 byte[] byteArray = { 1, 2, 3, 4, 5 }; 579 byte[] outPutBuf = new byte[50]; 580 byte[] outPutInf = new byte[50]; 581 int offSet = 1; 582 int length = 3; 583 584 Deflater defl = new Deflater(); 585 defl.setInput(byteArray, offSet, length); 586 assertFalse("the array buffer in setInput() is empty", defl.needsInput()); 587 // The second setInput() should be ignored since needsInput() return 588 // false 589 defl.setInput(byteArray, offSet, length); 590 defl.finish(); 591 while (!defl.finished()) { 592 defl.deflate(outPutBuf); 593 } 594 defl.end(); 595 596 Inflater infl = new Inflater(); 597 infl.setInput(outPutBuf); 598 while (!infl.finished()) { 599 infl.inflate(outPutInf); 600 } 601 for (int i = 0; i < length; i++) { 602 assertEquals(byteArray[i + offSet], outPutInf[i]); 603 } 604 assertEquals(length, infl.getTotalOut()); 605 infl.end(); 606 607 // boundary check 608 defl = new Deflater(); 609 for (int i = 0; i < 2; i++) { 610 if (i == 0) { 611 offSet = 0; 612 length = byteArray.length + 1; 613 } else { 614 offSet = byteArray.length + 1; 615 length = 1; 616 } 617 try { 618 defl.setInput(byteArray, offSet, length); 619 fail("Test " + i 620 + ": boundary check for setInput failed for offset " 621 + offSet + " and length " + length); 622 } catch (ArrayIndexOutOfBoundsException e) { 623 } 624 } 625 defl.end(); 626 } 627 628 /** 629 * java.util.zip.Deflater#setLevel(int) 630 */ test_setLevelI()631 public void test_setLevelI() throws Exception { 632 // Very similar to test_Constructor(int) 633 byte[] byteArray = new byte[100]; 634 InputStream inFile = Support_Resources.getStream("hyts_checkInput.txt"); 635 inFile.read(byteArray); 636 inFile.close(); 637 638 byte[] outPutBuf; 639 int totalOut; 640 for (int i = 0; i < 10; i++) { 641 Deflater defl = new Deflater(); 642 defl.setLevel(i); 643 outPutBuf = new byte[500]; 644 defl.setInput(byteArray); 645 while (!defl.needsInput()) { 646 defl.deflate(outPutBuf); 647 } 648 defl.finish(); 649 while (!defl.finished()) { 650 defl.deflate(outPutBuf); 651 } 652 totalOut = defl.getTotalOut(); 653 defl.end(); 654 655 outPutBuf = new byte[500]; 656 defl = new Deflater(i); 657 defl.setInput(byteArray); 658 while (!defl.needsInput()) { 659 defl.deflate(outPutBuf); 660 } 661 defl.finish(); 662 while (!defl.finished()) { 663 defl.deflate(outPutBuf); 664 } 665 assertEquals(totalOut, defl.getTotalOut()); 666 defl.end(); 667 } 668 669 // testing boundaries 670 Deflater boundDefl = new Deflater(); 671 try { 672 // Level must be between 0-9 673 boundDefl.setLevel(-2); 674 fail( 675 "IllegalArgumentException not thrown when setting level to a number < 0."); 676 } catch (IllegalArgumentException e) { 677 } 678 try { 679 boundDefl.setLevel(10); 680 fail( 681 "IllegalArgumentException not thrown when setting level to a number > 9."); 682 } catch (IllegalArgumentException e) { 683 } 684 boundDefl.end(); 685 } 686 687 /** 688 * java.util.zip.Deflater#setStrategy(int) 689 */ test_setStrategyI()690 public void test_setStrategyI() throws Exception { 691 byte[] byteArray = new byte[100]; 692 InputStream inFile = Support_Resources.getStream("hyts_checkInput.txt"); 693 inFile.read(byteArray); 694 inFile.close(); 695 696 for (int i = 0; i < 3; i++) { 697 byte outPutBuf[] = new byte[500]; 698 MyDeflater mdefl = new MyDeflater(); 699 700 if (i == 0) { 701 mdefl.setStrategy(mdefl.getDefStrategy()); 702 } else if (i == 1) { 703 mdefl.setStrategy(mdefl.getHuffman()); 704 } else { 705 mdefl.setStrategy(mdefl.getFiltered()); 706 } 707 708 mdefl.setInput(byteArray); 709 while (!mdefl.needsInput()) { 710 mdefl.deflate(outPutBuf); 711 } 712 mdefl.finish(); 713 while (!mdefl.finished()) { 714 mdefl.deflate(outPutBuf); 715 } 716 717 if (i == 0) { 718 // System.out.println(mdefl.getTotalOut()); 719 // ran JDK and found that getTotalOut() = 86 for this particular 720 // file 721 assertEquals("getTotalOut() for the default strategy did not correspond with JDK", 722 86, mdefl.getTotalOut()); 723 } else if (i == 1) { 724 // System.out.println(mdefl.getTotalOut()); 725 // ran JDK and found that getTotalOut() = 100 for this 726 // particular file 727 assertEquals("getTotalOut() for the Huffman strategy did not correspond with JDK", 728 100, mdefl.getTotalOut()); 729 } else { 730 // System.out.println(mdefl.getTotalOut()); 731 // ran JDK and found that totalOut = 93 for this particular file 732 assertEquals("Total Out for the Filtered strategy did not correspond with JDK", 733 93, mdefl.getTotalOut()); 734 } 735 mdefl.end(); 736 } 737 738 // Attempting to setStrategy to an invalid value 739 Deflater defl = new Deflater(); 740 try { 741 defl.setStrategy(-412); 742 fail("IllegalArgumentException not thrown when setting strategy to an invalid value."); 743 } catch (IllegalArgumentException e) { 744 } 745 defl.end(); 746 } 747 748 /** 749 * java.util.zip.Deflater#Deflater() 750 */ test_Constructor()751 public void test_Constructor() throws Exception { 752 byte[] byteArray = new byte[100]; 753 InputStream inFile = Support_Resources.getStream("hyts_checkInput.txt"); 754 inFile.read(byteArray); 755 inFile.close(); 756 757 Deflater defl = new Deflater(); 758 byte[] outPutBuf = new byte[500]; 759 defl.setInput(byteArray); 760 while (!defl.needsInput()) { 761 defl.deflate(outPutBuf); 762 } 763 defl.finish(); 764 while (!defl.finished()) { 765 defl.deflate(outPutBuf); 766 } 767 int totalOut = defl.getTotalOut(); 768 defl.end(); 769 770 // creating a Deflater using the DEFAULT_COMPRESSION as the int 771 MyDeflater mdefl = new MyDeflater(); 772 mdefl.end(); 773 774 mdefl = new MyDeflater(mdefl.getDefCompression()); 775 outPutBuf = new byte[500]; 776 mdefl.setInput(byteArray); 777 while (!mdefl.needsInput()) { 778 mdefl.deflate(outPutBuf); 779 } 780 mdefl.finish(); 781 while (!mdefl.finished()) { 782 mdefl.deflate(outPutBuf); 783 } 784 assertEquals(totalOut, mdefl.getTotalOut()); 785 mdefl.end(); 786 } 787 788 /** 789 * java.util.zip.Deflater#Deflater(int, boolean) 790 */ test_ConstructorIZ()791 public void test_ConstructorIZ() throws Exception { 792 byte byteArray[] = { 4, 5, 3, 2, 'a', 'b', 6, 7, 8, 9, 0, 's', '3', 793 'w', 'r' }; 794 795 Deflater defl = new Deflater(); 796 byte outPutBuf[] = new byte[500]; 797 defl.setLevel(2); 798 defl.setInput(byteArray); 799 while (!defl.needsInput()) { 800 defl.deflate(outPutBuf); 801 } 802 defl.finish(); 803 while (!defl.finished()) { 804 defl.deflate(outPutBuf); 805 } 806 int totalOut = defl.getTotalOut(); 807 defl.end(); 808 809 outPutBuf = new byte[500]; 810 defl = new Deflater(2, false); 811 defl.setInput(byteArray); 812 while (!defl.needsInput()) { 813 defl.deflate(outPutBuf); 814 } 815 defl.finish(); 816 while (!defl.finished()) { 817 defl.deflate(outPutBuf); 818 } 819 assertEquals(totalOut, defl.getTotalOut()); 820 defl.end(); 821 822 outPutBuf = new byte[500]; 823 defl = new Deflater(2, true); 824 defl.setInput(byteArray); 825 while (!defl.needsInput()) { 826 defl.deflate(outPutBuf); 827 } 828 defl.finish(); 829 while (!defl.finished()) { 830 defl.deflate(outPutBuf); 831 } 832 assertTrue( 833 "getTotalOut() should not be equal comparing two Deflaters with different header options.", 834 defl.getTotalOut() != totalOut); 835 defl.end(); 836 837 byte outPutInf[] = new byte[500]; 838 Inflater infl = new Inflater(true); 839 while (!infl.finished()) { 840 if (infl.needsInput()) { 841 infl.setInput(outPutBuf); 842 } 843 infl.inflate(outPutInf); 844 } 845 for (int i = 0; i < byteArray.length; i++) { 846 assertEquals(byteArray[i], outPutInf[i]); 847 } 848 assertEquals("final decompressed data contained more bytes than original - constructorIZ", 849 0, outPutInf[byteArray.length]); 850 infl.end(); 851 852 infl = new Inflater(false); 853 outPutInf = new byte[500]; 854 int r = 0; 855 try { 856 while (!infl.finished()) { 857 if (infl.needsInput()) { 858 infl.setInput(outPutBuf); 859 } 860 infl.inflate(outPutInf); 861 } 862 } catch (DataFormatException e) { 863 r = 1; 864 } 865 infl.end(); 866 assertEquals("header option did not correspond", 1, r); 867 868 // testing boundaries 869 Deflater boundDefl = new Deflater(); 870 try { 871 // Level must be between 0-9 872 boundDefl.setLevel(-2); 873 fail("IllegalArgumentException not thrown when setting level to a number < 0."); 874 } catch (IllegalArgumentException e) { 875 } 876 try { 877 boundDefl.setLevel(10); 878 fail("IllegalArgumentException not thrown when setting level to a number > 9."); 879 } catch (IllegalArgumentException e) { 880 } 881 boundDefl.end(); 882 try { 883 new Deflater(-2, true).end(); 884 fail("IllegalArgumentException not thrown when passing level to a number < 0."); 885 } catch (IllegalArgumentException e) { 886 } 887 888 try { 889 new Deflater(10, true).end(); 890 fail("IllegalArgumentException not thrown when passing level to a number > 9."); 891 } catch (IllegalArgumentException e) { 892 } 893 } 894 895 /** 896 * java.util.zip.Deflater#Deflater(int) 897 */ test_ConstructorI()898 public void test_ConstructorI() throws Exception { 899 byte[] byteArray = new byte[100]; 900 InputStream inFile = Support_Resources.getStream("hyts_checkInput.txt"); 901 inFile.read(byteArray); 902 inFile.close(); 903 904 byte outPutBuf[] = new byte[500]; 905 Deflater defl = new Deflater(3); 906 defl.setInput(byteArray); 907 while (!defl.needsInput()) { 908 defl.deflate(outPutBuf); 909 } 910 defl.finish(); 911 while (!defl.finished()) { 912 defl.deflate(outPutBuf); 913 } 914 int totalOut = defl.getTotalOut(); 915 defl.end(); 916 917 // test to see if the compression ratio is the same as setting the level 918 // on a deflater 919 outPutBuf = new byte[500]; 920 defl = new Deflater(); 921 defl.setLevel(3); 922 defl.setInput(byteArray); 923 while (!defl.needsInput()) { 924 defl.deflate(outPutBuf); 925 } 926 defl.finish(); 927 while (!defl.finished()) { 928 defl.deflate(outPutBuf); 929 } 930 assertEquals(totalOut, defl.getTotalOut()); 931 defl.end(); 932 933 // testing boundaries 934 Deflater boundDefl = new Deflater(); 935 try { 936 // Level must be between 0-9 937 boundDefl.setLevel(-2); 938 fail("IllegalArgumentException not thrown when setting level to a number < 0."); 939 } catch (IllegalArgumentException e) { 940 } 941 try { 942 boundDefl.setLevel(10); 943 fail("IllegalArgumentException not thrown when setting level to a number > 9."); 944 } catch (IllegalArgumentException e) { 945 } 946 boundDefl.end(); 947 } 948 helper_end_test(Deflater defl, String desc)949 private void helper_end_test(Deflater defl, String desc) { 950 // Help tests for test_end() and test_reset(). 951 byte byteArray[] = { 5, 2, 3, 7, 8 }; 952 953 // Methods where we expect IllegalStateException or NullPointerException 954 // to be thrown 955 try { 956 defl.getTotalOut(); 957 fail("defl.getTotalOut() can still be used after " + desc 958 + " is called in test_" + desc); 959 } catch (IllegalStateException e) { 960 } catch (NullPointerException e) { 961 } 962 try { 963 defl.getTotalIn(); 964 fail("defl.getTotalIn() can still be used after " + desc 965 + " is called in test_" + desc); 966 } catch (IllegalStateException e) { 967 } catch (NullPointerException e) { 968 } 969 try { 970 defl.getAdler(); 971 fail("defl.getAdler() can still be used after " + desc 972 + " is called in test_" + desc); 973 } catch (IllegalStateException e) { 974 } catch (NullPointerException e) { 975 } 976 try { 977 byte[] dict = { 'a', 'b', 'c' }; 978 defl.setDictionary(dict); 979 fail("defl.setDictionary() can still be used after " + desc 980 + " is called in test_" + desc); 981 } catch (IllegalStateException e) { 982 } catch (NullPointerException e) { 983 } 984 try { 985 defl.getTotalIn(); 986 fail("defl.getTotalIn() can still be used after " + desc 987 + " is called in test_" + desc); 988 } catch (IllegalStateException e) { 989 } catch (NullPointerException e) { 990 } 991 try { 992 defl.getTotalIn(); 993 fail("defl.getTotalIn() can still be used after " + desc 994 + " is called in test_" + desc); 995 } catch (IllegalStateException e) { 996 } catch (NullPointerException e) { 997 } 998 try { 999 defl.deflate(byteArray); 1000 fail("defl.deflate() can still be used after " + desc 1001 + " is called in test_" + desc); 1002 } catch (IllegalStateException e) { 1003 } catch (NullPointerException e) { 1004 } 1005 1006 // Methods where we expect NullPointerException to be thrown 1007 try { 1008 defl.reset(); 1009 fail("defl.reset() can still be used after " + desc 1010 + " is called in test_" + desc); 1011 } catch (NullPointerException expected) { 1012 } catch (IllegalStateException expected) { 1013 } 1014 1015 // Methods where we expect NullPointerException to be thrown 1016 try { 1017 defl.getBytesRead(); 1018 fail("defl.reset() can still be used after " + desc 1019 + " is called in test_" + desc); 1020 } catch (NullPointerException expected) { 1021 } catch (IllegalStateException expected) { 1022 } 1023 1024 // Methods where we expect NullPointerException to be thrown 1025 try { 1026 defl.getBytesWritten(); 1027 fail("defl.getBytesWritten() can still be used after " + desc 1028 + " is called in test_" + desc); 1029 } catch (NullPointerException expected) { 1030 } catch (IllegalStateException expected) { 1031 } 1032 1033 // Methods that should be allowed to be called after end() is called 1034 defl.needsInput(); 1035 defl.setStrategy(1); 1036 defl.setLevel(1); 1037 defl.end(); 1038 1039 // Methods where exceptions should be thrown 1040 String vendor = System.getProperty("java.vendor"); 1041 if (vendor.indexOf("IBM") != -1) { 1042 try { 1043 defl.setInput(byteArray); 1044 fail("defl.setInput() can still be used after " + desc 1045 + " is called in test_" + desc); 1046 } catch (IllegalStateException e) { 1047 } 1048 } 1049 } 1050 1051 /** 1052 * java.util.zip.Deflater() 1053 */ test_needsDictionary()1054 public void test_needsDictionary() { 1055 Deflater inf = new Deflater(); 1056 assertEquals(0, inf.getTotalIn()); 1057 assertEquals(0, inf.getTotalOut()); 1058 assertEquals(0, inf.getBytesRead()); 1059 assertEquals(0, inf.getBytesWritten()); 1060 inf.end(); 1061 } 1062 1063 /** 1064 * @throws DataFormatException 1065 * @throws UnsupportedEncodingException 1066 * java.util.zip.Deflater#getBytesRead() 1067 */ test_getBytesRead()1068 public void test_getBytesRead() throws DataFormatException, 1069 UnsupportedEncodingException { 1070 // Regression test for HARMONY-158 1071 Deflater def = new Deflater(); 1072 assertEquals(0, def.getTotalIn()); 1073 assertEquals(0, def.getTotalOut()); 1074 assertEquals(0, def.getBytesRead()); 1075 // Encode a String into bytes 1076 String inputString = "blahblahblah??"; 1077 byte[] input = inputString.getBytes("UTF-8"); 1078 1079 // Compress the bytes 1080 byte[] output = new byte[100]; 1081 def.setInput(input); 1082 def.finish(); 1083 int compressedDataLength = def.deflate(output); 1084 assertEquals(14, def.getTotalIn()); 1085 assertEquals(compressedDataLength, def.getTotalOut()); 1086 assertEquals(14, def.getBytesRead()); 1087 def.end(); 1088 } 1089 1090 /** 1091 * @throws DataFormatException 1092 * @throws UnsupportedEncodingException 1093 * java.util.zip.Deflater#getBytesRead() 1094 */ test_getBytesWritten()1095 public void test_getBytesWritten() throws DataFormatException, 1096 UnsupportedEncodingException { 1097 // Regression test for HARMONY-158 1098 Deflater def = new Deflater(); 1099 assertEquals(0, def.getTotalIn()); 1100 assertEquals(0, def.getTotalOut()); 1101 assertEquals(0, def.getBytesWritten()); 1102 // Encode a String into bytes 1103 String inputString = "blahblahblah??"; 1104 byte[] input = inputString.getBytes("UTF-8"); 1105 1106 // Compress the bytes 1107 byte[] output = new byte[100]; 1108 def.setInput(input); 1109 def.finish(); 1110 int compressedDataLength = def.deflate(output); 1111 assertEquals(14, def.getTotalIn()); 1112 assertEquals(compressedDataLength, def.getTotalOut()); 1113 assertEquals(compressedDataLength, def.getBytesWritten()); 1114 def.end(); 1115 } 1116 1117 //Regression Test for HARMONY-2481 test_deflate_beforeSetInput()1118 public void test_deflate_beforeSetInput() throws Exception { 1119 Deflater deflater = new Deflater(); 1120 deflater.finish(); 1121 byte[] buffer = new byte[1024]; 1122 assertEquals(8, deflater.deflate(buffer)); 1123 byte[] expectedBytes = { 120, -100, 3, 0, 0, 0, 0, 1 }; 1124 for (int i = 0; i < expectedBytes.length; i++) { 1125 assertEquals(expectedBytes[i], buffer[i]); 1126 } 1127 deflater.end(); 1128 } 1129 } 1130