4 @INC = ("../lib", "lib/compress");
8 use lib qw(t t/compress);
19 # use Test::NoWarnings, if available
22 if eval { require Test::NoWarnings ; import Test::NoWarnings; 1 };
36 plan tests => $count + $extra;
38 use_ok('Compress::Raw::Zlib', 2) ;
47 my $len = length $hello ;
49 # Check zlib_version and ZLIB_VERSION are the same.
50 is Compress::Raw::Zlib::zlib_version, ZLIB_VERSION,
51 "ZLIB_VERSION matches Compress::Raw::Zlib::zlib_version" ;
56 eval { new Compress::Raw::Zlib::Deflate(-Level) };
57 like $@, mkErr("^Compress::Raw::Zlib::Deflate::new: Expected even number of parameters, got 1") ;
59 eval { new Compress::Raw::Zlib::Inflate(-Level) };
60 like $@, mkErr("^Compress::Raw::Zlib::Inflate::new: Expected even number of parameters, got 1");
62 eval { new Compress::Raw::Zlib::Deflate(-Joe => 1) };
63 like $@, mkErr('^Compress::Raw::Zlib::Deflate::new: unknown key value\(s\) Joe');
65 eval { new Compress::Raw::Zlib::Inflate(-Joe => 1) };
66 like $@, mkErr('^Compress::Raw::Zlib::Inflate::new: unknown key value\(s\) Joe');
68 eval { new Compress::Raw::Zlib::Deflate(-Bufsize => 0) };
69 like $@, mkErr("^Compress::Raw::Zlib::Deflate::new: Bufsize must be >= 1, you specified 0");
71 eval { new Compress::Raw::Zlib::Inflate(-Bufsize => 0) };
72 like $@, mkErr("^Compress::Raw::Zlib::Inflate::new: Bufsize must be >= 1, you specified 0");
74 eval { new Compress::Raw::Zlib::Deflate(-Bufsize => -1) };
75 like $@, mkErr("^Compress::Raw::Zlib::Deflate::new: Parameter 'Bufsize' must be an unsigned int, got '-1'");
77 eval { new Compress::Raw::Zlib::Inflate(-Bufsize => -1) };
78 like $@, mkErr("^Compress::Raw::Zlib::Inflate::new: Parameter 'Bufsize' must be an unsigned int, got '-1'");
80 eval { new Compress::Raw::Zlib::Deflate(-Bufsize => "xxx") };
81 like $@, mkErr("^Compress::Raw::Zlib::Deflate::new: Parameter 'Bufsize' must be an unsigned int, got 'xxx'");
83 eval { new Compress::Raw::Zlib::Inflate(-Bufsize => "xxx") };
84 like $@, mkErr("^Compress::Raw::Zlib::Inflate::new: Parameter 'Bufsize' must be an unsigned int, got 'xxx'");
86 eval { new Compress::Raw::Zlib::Inflate(-Bufsize => 1, 2) };
87 like $@, mkErr("^Compress::Raw::Zlib::Inflate::new: Expected even number of parameters, got 3");
89 eval { new Compress::Raw::Zlib::Deflate(-Bufsize => 1, 2) };
90 like $@, mkErr("^Compress::Raw::Zlib::Deflate::new: Expected even number of parameters, got 3");
96 title "deflate/inflate - small buffer";
97 # ==============================
99 my $hello = "I am a HAL 9000 computer" ;
100 my @hello = split('', $hello) ;
101 my ($err, $x, $X, $status);
103 ok( ($x, $err) = new Compress::Raw::Zlib::Deflate ( -Bufsize => 1 ), "Create deflate object" );
104 ok $x, "Compress::Raw::Zlib::Deflate ok" ;
105 cmp_ok $err, '==', Z_OK, "status is Z_OK" ;
107 ok ! defined $x->msg() ;
108 is $x->total_in(), 0, "total_in() == 0" ;
109 is $x->total_out(), 0, "total_out() == 0" ;
115 $status = $x->deflate($_, $X) ;
116 last unless $status == Z_OK ;
121 cmp_ok $status, '==', Z_OK, "deflate returned Z_OK" ;
123 cmp_ok $x->flush($X), '==', Z_OK, "flush returned Z_OK" ;
126 ok ! defined $x->msg() ;
127 is $x->total_in(), length $hello, "total_in ok" ;
128 is $x->total_out(), length $Answer, "total_out ok" ;
130 my @Answer = split('', $Answer) ;
133 ok(($k, $err) = new Compress::Raw::Zlib::Inflate( {-Bufsize => 1}) );
134 ok $k, "Compress::Raw::Zlib::Inflate ok" ;
135 cmp_ok $err, '==', Z_OK, "status is Z_OK" ;
137 ok ! defined $k->msg(), "No error messages" ;
138 is $k->total_in(), 0, "total_in() == 0" ;
139 is $k->total_out(), 0, "total_out() == 0" ;
145 $status = $k->inflate($_, $Z) ;
147 last if $status == Z_STREAM_END or $status != Z_OK ;
151 cmp_ok $status, '==', Z_STREAM_END, "Got Z_STREAM_END" ;
152 is $GOT, $hello, "uncompressed data matches ok" ;
153 ok ! defined $k->msg(), "No error messages" ;
154 is $k->total_in(), length $Answer, "total_in ok" ;
155 is $k->total_out(), length $hello , "total_out ok";
161 # deflate/inflate - small buffer with a number
162 # ==============================
166 ok my ($x, $err) = new Compress::Raw::Zlib::Deflate ( -Bufsize => 1, -AppendOutput => 1 ) ;
168 cmp_ok $err, '==', Z_OK ;
173 cmp_ok $x->deflate($hello, $Answer), '==', Z_OK ;
175 cmp_ok $x->flush($Answer), '==', Z_OK ;
177 my @Answer = split('', $Answer) ;
180 ok(($k, $err) = new Compress::Raw::Zlib::Inflate( {-Bufsize => 1, -AppendOutput =>1}) );
182 cmp_ok $err, '==', Z_OK ;
188 $status = $k->inflate($_, $GOT) ;
189 last if $status == Z_STREAM_END or $status != Z_OK ;
193 cmp_ok $status, '==', Z_STREAM_END ;
200 # deflate/inflate options - AppendOutput
201 # ================================
206 my $hello = "I am a HAL 9000 computer" ;
207 my @hello = split('', $hello) ;
209 ok my ($x, $err) = new Compress::Raw::Zlib::Deflate ( {-Bufsize => 1, -AppendOutput =>1} ) ;
211 cmp_ok $err, '==', Z_OK ;
217 $status = $x->deflate($_, $X) ;
218 last unless $status == Z_OK ;
221 cmp_ok $status, '==', Z_OK ;
223 cmp_ok $x->flush($X), '==', Z_OK ;
226 my @Answer = split('', $X) ;
229 ok(($k, $err) = new Compress::Raw::Zlib::Inflate( {-Bufsize => 1, -AppendOutput =>1}));
231 cmp_ok $err, '==', Z_OK ;
236 $status = $k->inflate($_, $Z) ;
237 last if $status == Z_STREAM_END or $status != Z_OK ;
241 cmp_ok $status, '==', Z_STREAM_END ;
248 title "deflate/inflate - larger buffer";
249 # ==============================
251 # generate a long random string
254 { $contents .= chr int rand 255 }
257 ok my ($x, $err) = new Compress::Raw::Zlib::Deflate() ;
259 cmp_ok $err, '==', Z_OK ;
261 my (%X, $Y, %Z, $X, $Z);
262 #cmp_ok $x->deflate($contents, $X{key}), '==', Z_OK ;
263 cmp_ok $x->deflate($contents, $X), '==', Z_OK ;
269 #cmp_ok $x->flush($X{key}), '==', Z_OK ;
271 cmp_ok $x->flush($X), '==', Z_OK ;
279 ok(($k, $err) = new Compress::Raw::Zlib::Inflate() );
281 cmp_ok $err, '==', Z_OK ;
283 #cmp_ok $k->inflate($Y, $Z{key}), '==', Z_STREAM_END ;
284 #ok $contents eq $Z{key} ;
285 cmp_ok $k->inflate($Y, $Z), '==', Z_STREAM_END ;
288 # redo deflate with AppendOutput
290 ok (($k, $err) = new Compress::Raw::Zlib::Inflate(-AppendOutput => 1)) ;
292 cmp_ok $err, '==', Z_OK ;
296 my @bits = split('', $keep) ;
297 foreach my $bit (@bits) {
298 $s = $k->inflate($bit, $out) ;
301 cmp_ok $s, '==', Z_STREAM_END ;
303 ok $contents eq $out ;
310 title "deflate/inflate - preset dictionary";
311 # ===================================
313 my $dictionary = "hello" ;
314 ok my $x = new Compress::Raw::Zlib::Deflate({-Level => Z_BEST_COMPRESSION,
315 -Dictionary => $dictionary}) ;
317 my $dictID = $x->dict_adler() ;
320 cmp_ok $x->deflate($hello, $X), '==', Z_OK;
321 cmp_ok $x->flush($Y), '==', Z_OK;
324 ok my $k = new Compress::Raw::Zlib::Inflate(-Dictionary => $dictionary) ;
326 cmp_ok $k->inflate($X, $Z), '==', Z_STREAM_END;
327 is $k->dict_adler(), $dictID;
332 title 'inflate - check remaining buffer after Z_STREAM_END';
333 # and that ConsumeInput works.
334 # ===================================================
336 for my $consume ( 0 .. 1)
338 ok my $x = new Compress::Raw::Zlib::Deflate(-Level => Z_BEST_COMPRESSION ) ;
341 cmp_ok $x->deflate($hello, $X), '==', Z_OK;
342 cmp_ok $x->flush($Y), '==', Z_OK;
345 ok my $k = new Compress::Raw::Zlib::Inflate( -ConsumeInput => $consume) ;
347 my $first = substr($X, 0, 2) ;
348 my $remember_first = $first ;
349 my $last = substr($X, 2) ;
350 cmp_ok $k->inflate($first, $Z), '==', Z_OK;
355 ok $first eq $remember_first ;
359 $last .= "appendage" ;
360 my $remember_last = $last ;
361 cmp_ok $k->inflate($last, $T), '==', Z_STREAM_END;
364 is $last, "appendage" ;
367 is $last, $remember_last ;
376 title 'Check - MAX_WBITS';
379 my $hello = "Test test test test test";
380 my @hello = split('', $hello) ;
383 new Compress::Raw::Zlib::Deflate ( -Bufsize => 1,
384 -WindowBits => -MAX_WBITS(),
385 -AppendOutput => 1 ) ;
387 cmp_ok $err, '==', Z_OK ;
393 $status = $x->deflate($_, $Answer) ;
394 last unless $status == Z_OK ;
397 cmp_ok $status, '==', Z_OK ;
399 cmp_ok $x->flush($Answer), '==', Z_OK ;
401 my @Answer = split('', $Answer) ;
402 # Undocumented corner -- extra byte needed to get inflate to return
403 # Z_STREAM_END when done.
407 ok(($k, $err) = new Compress::Raw::Zlib::Inflate(
410 -WindowBits => -MAX_WBITS()})) ;
412 cmp_ok $err, '==', Z_OK ;
417 $status = $k->inflate($_, $GOT) ;
418 last if $status == Z_STREAM_END or $status != Z_OK ;
422 cmp_ok $status, '==', Z_STREAM_END ;
430 # create a deflate stream with flush points
432 my $hello = "I am a HAL 9000 computer" x 2001 ;
433 my $goodbye = "Will I dream?" x 2010;
434 my ($x, $err, $answer, $X, $Z, $status);
438 ok(($x, $err) = new Compress::Raw::Zlib::Deflate(AppendOutput => 1)) ;
440 cmp_ok $err, '==', Z_OK ;
442 cmp_ok $x->deflate($hello, $Answer), '==', Z_OK;
444 # create a flush point
445 cmp_ok $x->flush($Answer, Z_FULL_FLUSH), '==', Z_OK ;
447 my $len1 = length $Answer;
449 cmp_ok $x->deflate($goodbye, $Answer), '==', Z_OK;
451 cmp_ok $x->flush($Answer), '==', Z_OK ;
452 my $len2 = length($Answer) - $len1 ;
454 my ($first, @Answer) = split('', $Answer) ;
457 ok(($k, $err) = new Compress::Raw::Zlib::Inflate()) ;
459 cmp_ok $err, '==', Z_OK ;
461 cmp_ok $k->inflate($first, $Z), '==', Z_OK;
463 # skip to the first flush point.
466 my $byte = shift @Answer;
467 $status = $k->inflateSync($byte) ;
468 last unless $status == Z_DATA_ERROR;
471 cmp_ok $status, '==', Z_OK;
477 $status = $k->inflate($_, $Z) ;
478 $GOT .= $Z if defined $Z ;
479 # print "x $status\n";
480 last if $status == Z_STREAM_END or $status != Z_OK ;
483 cmp_ok $status, '==', Z_DATA_ERROR ;
487 # Check inflateSync leaves good data in buffer
493 ok(($k, $err) = new Compress::Raw::Zlib::Inflate(ConsumeInput => 0)) ;
495 cmp_ok $err, '==', Z_OK ;
497 cmp_ok $k->inflate($initial, $Z), '==', Z_OK;
499 # Skip to the flush point
500 $status = $k->inflateSync($rest);
501 cmp_ok $status, '==', Z_OK
502 or diag "status '$status'\nlength rest is " . length($rest) . "\n" ;
504 is length($rest), $len2, "expected compressed output";
507 cmp_ok $k->inflate($rest, $GOT), '==', Z_DATA_ERROR, "inflate returns Z_DATA_ERROR";
512 title 'deflateParams';
514 my $hello = "I am a HAL 9000 computer" x 2001 ;
515 my $goodbye = "Will I dream?" x 2010;
516 my ($x, $input, $err, $answer, $X, $status, $Answer);
518 ok(($x, $err) = new Compress::Raw::Zlib::Deflate(
520 -Level => Z_DEFAULT_COMPRESSION,
521 -Strategy => Z_DEFAULT_STRATEGY)) ;
523 cmp_ok $err, '==', Z_OK ;
525 ok $x->get_Level() == Z_DEFAULT_COMPRESSION;
526 ok $x->get_Strategy() == Z_DEFAULT_STRATEGY;
528 $status = $x->deflate($hello, $Answer) ;
529 cmp_ok $status, '==', Z_OK ;
533 eval { $x->deflateParams() };
534 like $@, mkErr('^Compress::Raw::Zlib::deflateParams needs Level and\/or Strategy');
536 eval { $x->deflateParams(-Bufsize => 0) };
537 like $@, mkErr('^Compress::Raw::Zlib::Inflate::deflateParams: Bufsize must be >= 1, you specified 0');
539 eval { $x->deflateParams(-Joe => 3) };
540 like $@, mkErr('^Compress::Raw::Zlib::deflateStream::deflateParams: unknown key value\(s\) Joe');
542 is $x->get_Level(), Z_DEFAULT_COMPRESSION;
543 is $x->get_Strategy(), Z_DEFAULT_STRATEGY;
545 # change both Level & Strategy
546 $status = $x->deflateParams(-Level => Z_BEST_SPEED, -Strategy => Z_HUFFMAN_ONLY, -Bufsize => 1234) ;
547 cmp_ok $status, '==', Z_OK ;
549 is $x->get_Level(), Z_BEST_SPEED;
550 is $x->get_Strategy(), Z_HUFFMAN_ONLY;
552 $status = $x->deflate($goodbye, $Answer) ;
553 cmp_ok $status, '==', Z_OK ;
557 $status = $x->deflateParams(-Level => Z_NO_COMPRESSION) ;
558 cmp_ok $status, '==', Z_OK ;
560 is $x->get_Level(), Z_NO_COMPRESSION;
561 is $x->get_Strategy(), Z_HUFFMAN_ONLY;
563 $status = $x->deflate($goodbye, $Answer) ;
564 cmp_ok $status, '==', Z_OK ;
567 # change only Strategy
568 $status = $x->deflateParams(-Strategy => Z_FILTERED) ;
569 cmp_ok $status, '==', Z_OK ;
571 is $x->get_Level(), Z_NO_COMPRESSION;
572 is $x->get_Strategy(), Z_FILTERED;
574 $status = $x->deflate($goodbye, $Answer) ;
575 cmp_ok $status, '==', Z_OK ;
578 cmp_ok $x->flush($Answer), '==', Z_OK ;
581 ok(($k, $err) = new Compress::Raw::Zlib::Inflate()) ;
583 cmp_ok $err, '==', Z_OK ;
586 $status = $k->inflate($Answer, $Z) ;
588 cmp_ok $status, '==', Z_STREAM_END ;
594 title "ConsumeInput and a read-only buffer trapped" ;
596 ok my $k = new Compress::Raw::Zlib::Inflate(-ConsumeInput => 1) ;
599 eval { $k->inflate("abc", $Z) ; };
600 like $@, mkErr("Compress::Raw::Zlib::Inflate::inflate input parameter cannot be read-only when ConsumeInput is specified");
608 title 'test inflate/deflate with a substr';
612 { $contents .= chr int rand 255 }
613 ok my $x = new Compress::Raw::Zlib::Deflate(-AppendOutput => 1) ;
616 my $status = $x->deflate(substr($contents,0), $X);
617 cmp_ok $status, '==', Z_OK ;
619 cmp_ok $x->flush($X), '==', Z_OK ;
621 my $append = "Appended" ;
624 ok my $k = new Compress::Raw::Zlib::Inflate(-AppendOutput => 1) ;
628 $status = $k->inflate(substr($X, 0), $Z) ;
630 cmp_ok $status, '==', Z_STREAM_END ;
631 #print "status $status X [$X]\n" ;
634 #is length($X), length($append);
636 #is length($X), length($keep);
639 title 'Looping Append test - checks that deRef_l resets the output buffer';
643 my $hello = "I am a HAL 9000 computer" ;
644 my @hello = split('', $hello) ;
645 my ($err, $x, $X, $status);
647 ok( ($x, $err) = new Compress::Raw::Zlib::Deflate ( -Bufsize => 1 ) );
649 cmp_ok $err, '==', Z_OK ;
655 $status = $x->deflate($_, $X) ;
656 last unless $status == Z_OK ;
661 cmp_ok $status, '==', Z_OK ;
663 cmp_ok $x->flush($X), '==', Z_OK ;
666 my @Answer = split('', $Answer) ;
669 ok(($k, $err) = new Compress::Raw::Zlib::Inflate(-AppendOutput => 1) );
671 cmp_ok $err, '==', Z_OK ;
678 $status = $k->inflate($_, $GOT) ;
679 last if $status == Z_STREAM_END or $status != Z_OK ;
682 cmp_ok $status, '==', Z_STREAM_END ;
689 title 'test inflate input parameter via substr';
691 my $hello = "I am a HAL 9000 computer" ;
696 ok my $x = new Compress::Raw::Zlib::Deflate ( -AppendOutput => 1 );
698 cmp_ok $x->deflate($data, $X), '==', Z_OK ;
700 cmp_ok $x->flush($X), '==', Z_OK ;
702 my $append = "Appended" ;
706 ok my $k = new Compress::Raw::Zlib::Inflate ( -AppendOutput => 1,
707 -ConsumeInput => 1 ) ;
709 cmp_ok $k->inflate(substr($X, 0, -1), $Z), '==', Z_STREAM_END ; ;
716 ok $k = new Compress::Raw::Zlib::Inflate ( -AppendOutput => 1,
717 -ConsumeInput => 0 ) ;
719 cmp_ok $k->inflate(substr($X, 0, -1), $Z), '==', Z_STREAM_END ; ;
720 #cmp_ok $k->inflate(substr($X, 0), $Z), '==', Z_STREAM_END ; ;
728 # regression - check that resetLastBlockByte can cope with a NULL
730 Compress::Raw::Zlib::InflateScan->new->resetLastBlockByte(undef);
731 ok 1, "resetLastBlockByte(undef) is ok" ;
739 my $hello = "I am a HAL 9000 computer" ;
740 my @hello = split('', $hello) ;
741 my ($err, $x, $X, $status);
743 ok( ($x, $err) = new Compress::Raw::Zlib::Deflate (
744 WindowBits => WANT_GZIP ,
746 ), "Create deflate object" );
747 ok $x, "Compress::Raw::Zlib::Deflate ok" ;
748 cmp_ok $err, '==', Z_OK, "status is Z_OK" ;
750 $status = $x->deflate($hello, $X) ;
751 cmp_ok $status, '==', Z_OK, "deflate returned Z_OK" ;
753 cmp_ok $x->flush($X), '==', Z_OK, "flush returned Z_OK" ;
756 ($k, $err) = new Compress::Raw::Zlib::Inflate(
757 WindowBits => WANT_GZIP ,
760 ok $k, "Compress::Raw::Zlib::Inflate WANT_GZIP ok" ;
761 cmp_ok $err, '==', Z_OK, "status is Z_OK" ;
763 $status = $k->inflate($X, $GOT) ;
764 cmp_ok $status, '==', Z_STREAM_END, "Got Z_STREAM_END" ;
765 is $GOT, $hello, "uncompressed data matches ok" ;
768 ($k, $err) = new Compress::Raw::Zlib::Inflate(
769 WindowBits => WANT_GZIP_OR_ZLIB ,
771 ok $k, "Compress::Raw::Zlib::Inflate WANT_GZIP_OR_ZLIB ok" ;
772 cmp_ok $err, '==', Z_OK, "status is Z_OK" ;
774 $status = $k->inflate($X, $GOT) ;
775 cmp_ok $status, '==', Z_STREAM_END, "Got Z_STREAM_END" ;
776 is $GOT, $hello, "uncompressed data matches ok" ;
781 title "gzip error mode";
783 # read with no special windowbits setting - this will fail
784 # then read with WANT_GZIP_OR_ZLIB - thi swill work
787 my $hello = "I am a HAL 9000 computer" ;
788 my ($err, $x, $X, $status);
790 ok( ($x, $err) = new Compress::Raw::Zlib::Deflate (
791 WindowBits => WANT_GZIP ,
793 ), "Create deflate object" );
794 ok $x, "Compress::Raw::Zlib::Deflate ok" ;
795 cmp_ok $err, '==', Z_OK, "status is Z_OK" ;
797 $status = $x->deflate($hello, $X) ;
798 cmp_ok $status, '==', Z_OK, "deflate returned Z_OK" ;
800 cmp_ok $x->flush($X), '==', Z_OK, "flush returned Z_OK" ;
803 ($k, $err) = new Compress::Raw::Zlib::Inflate(
804 WindowBits => MAX_WBITS ,
807 ok $k, "Compress::Raw::Zlib::Inflate WANT_GZIP ok" ;
808 cmp_ok $err, '==', Z_OK, "status is Z_OK" ;
810 $status = $k->inflate($X, $GOT) ;
811 cmp_ok $status, '==', Z_DATA_ERROR, "Got Z_DATA_ERROR" ;
814 ($k, $err) = new Compress::Raw::Zlib::Inflate(
815 WindowBits => WANT_GZIP_OR_ZLIB ,
817 ok $k, "Compress::Raw::Zlib::Inflate WANT_GZIP_OR_ZLIB ok" ;
818 cmp_ok $err, '==', Z_OK, "status is Z_OK" ;
820 $status = $k->inflate($X, $GOT) ;
821 cmp_ok $status, '==', Z_STREAM_END, "Got Z_STREAM_END" ;
822 is $GOT, $hello, "uncompressed data matches ok" ;
827 title "gzip/zlib error mode";
829 # read with no WANT_GZIP windowbits setting - this will fail
830 # then read with WANT_GZIP_OR_ZLIB - thi swill work
833 my $hello = "I am a HAL 9000 computer" ;
834 my ($err, $x, $X, $status);
836 ok( ($x, $err) = new Compress::Raw::Zlib::Deflate (
838 ), "Create deflate object" );
839 ok $x, "Compress::Raw::Zlib::Deflate ok" ;
840 cmp_ok $err, '==', Z_OK, "status is Z_OK" ;
842 $status = $x->deflate($hello, $X) ;
843 cmp_ok $status, '==', Z_OK, "deflate returned Z_OK" ;
845 cmp_ok $x->flush($X), '==', Z_OK, "flush returned Z_OK" ;
848 ($k, $err) = new Compress::Raw::Zlib::Inflate(
849 WindowBits => WANT_GZIP ,
852 ok $k, "Compress::Raw::Zlib::Inflate WANT_GZIP ok" ;
853 cmp_ok $err, '==', Z_OK, "status is Z_OK" ;
855 $status = $k->inflate($X, $GOT) ;
856 cmp_ok $status, '==', Z_DATA_ERROR, "Got Z_DATA_ERROR" ;
859 ($k, $err) = new Compress::Raw::Zlib::Inflate(
860 WindowBits => WANT_GZIP_OR_ZLIB ,
862 ok $k, "Compress::Raw::Zlib::Inflate WANT_GZIP_OR_ZLIB ok" ;
863 cmp_ok $err, '==', Z_OK, "status is Z_OK" ;
865 $status = $k->inflate($X, $GOT) ;
866 cmp_ok $status, '==', Z_STREAM_END, "Got Z_STREAM_END" ;
867 is $GOT, $hello, "uncompressed data matches ok" ;
872 title 'Looping Append test with substr output - substr the end of the string';
876 my $hello = "I am a HAL 9000 computer" ;
877 my @hello = split('', $hello) ;
878 my ($err, $x, $X, $status);
880 ok( ($x, $err) = new Compress::Raw::Zlib::Deflate ( -Bufsize => 1,
881 -AppendOutput => 1 ) );
883 cmp_ok $err, '==', Z_OK ;
889 $status = $x->deflate($_, substr($Answer, length($Answer))) ;
890 last unless $status == Z_OK ;
894 cmp_ok $status, '==', Z_OK ;
896 cmp_ok $x->flush(substr($Answer, length($Answer))), '==', Z_OK ;
898 #cmp_ok length $Answer, ">", 0 ;
900 my @Answer = split('', $Answer) ;
904 ok(($k, $err) = new Compress::Raw::Zlib::Inflate(-AppendOutput => 1) );
906 cmp_ok $err, '==', Z_OK ;
913 $status = $k->inflate($_, substr($GOT, length($GOT))) ;
914 last if $status == Z_STREAM_END or $status != Z_OK ;
917 cmp_ok $status, '==', Z_STREAM_END ;
922 title 'Looping Append test with substr output - substr the complete string';
926 my $hello = "I am a HAL 9000 computer" ;
927 my @hello = split('', $hello) ;
928 my ($err, $x, $X, $status);
930 ok( ($x, $err) = new Compress::Raw::Zlib::Deflate ( -Bufsize => 1,
931 -AppendOutput => 1 ) );
933 cmp_ok $err, '==', Z_OK ;
939 $status = $x->deflate($_, substr($Answer, 0)) ;
940 last unless $status == Z_OK ;
944 cmp_ok $status, '==', Z_OK ;
946 cmp_ok $x->flush(substr($Answer, 0)), '==', Z_OK ;
948 my @Answer = split('', $Answer) ;
951 ok(($k, $err) = new Compress::Raw::Zlib::Inflate(-AppendOutput => 1) );
953 cmp_ok $err, '==', Z_OK ;
960 $status = $k->inflate($_, substr($GOT, 0)) ;
961 last if $status == Z_STREAM_END or $status != Z_OK ;
964 cmp_ok $status, '==', Z_STREAM_END ;