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