ignore new temp dirs
[perl.git] / cpan / Compress-Raw-Zlib / t / 02zlib.t
1 BEGIN {
2     if ($ENV{PERL_CORE}) {
3         chdir 't' if -d 't';
4         @INC = ("../lib", "lib/compress");
5     }
6 }
7
8 use lib qw(t t/compress);
9 use strict;
10 use warnings;
11 use bytes;
12
13 use Test::More  ;
14 use CompTestUtils;
15
16
17 BEGIN 
18
19     # use Test::NoWarnings, if available
20     my $extra = 0 ;
21     $extra = 1
22         if eval { require Test::NoWarnings ;  import Test::NoWarnings; 1 };
23
24
25     my $count = 0 ;
26     if ($] < 5.005) {
27         $count = 237 ;
28     }
29     elsif ($] >= 5.006) {
30         $count = 325 ;
31     }
32     else {
33         $count = 280 ;
34     }
35
36     plan tests => $count + $extra;
37
38     use_ok('Compress::Raw::Zlib', 2) ;
39 }
40
41
42 my $Zlib_ver = Compress::Raw::Zlib::zlib_version ;
43
44 my $hello = <<EOM ;
45 hello world
46 this is a test
47 EOM
48
49 my $len   = length $hello ;
50
51 # Check zlib_version and ZLIB_VERSION are the same.
52 SKIP: {
53     skip "TEST_SKIP_VERSION_CHECK is set", 1 
54         if $ENV{TEST_SKIP_VERSION_CHECK};
55     is Compress::Raw::Zlib::zlib_version, ZLIB_VERSION,
56         "ZLIB_VERSION matches Compress::Raw::Zlib::zlib_version" ;
57 }
58
59 {
60     title "Error Cases" ;
61
62     eval { new Compress::Raw::Zlib::Deflate(-Level) };
63     like $@,  mkErr("^Compress::Raw::Zlib::Deflate::new: Expected even number of parameters, got 1") ;
64
65     eval { new Compress::Raw::Zlib::Inflate(-Level) };
66     like $@, mkErr("^Compress::Raw::Zlib::Inflate::new: Expected even number of parameters, got 1");
67
68     eval { new Compress::Raw::Zlib::Deflate(-Joe => 1) };
69     like $@, mkErr('^Compress::Raw::Zlib::Deflate::new: unknown key value\(s\) Joe');
70
71     eval { new Compress::Raw::Zlib::Inflate(-Joe => 1) };
72     like $@, mkErr('^Compress::Raw::Zlib::Inflate::new: unknown key value\(s\) Joe');
73
74     eval { new Compress::Raw::Zlib::Deflate(-Bufsize => 0) };
75     like $@, mkErr("^Compress::Raw::Zlib::Deflate::new: Bufsize must be >= 1, you specified 0");
76
77     eval { new Compress::Raw::Zlib::Inflate(-Bufsize => 0) };
78     like $@, mkErr("^Compress::Raw::Zlib::Inflate::new: Bufsize must be >= 1, you specified 0");
79
80     eval { new Compress::Raw::Zlib::Deflate(-Bufsize => -1) };
81     like $@, mkErr("^Compress::Raw::Zlib::Deflate::new: Parameter 'Bufsize' must be an unsigned int, got '-1'");
82
83     eval { new Compress::Raw::Zlib::Inflate(-Bufsize => -1) };
84     like $@, mkErr("^Compress::Raw::Zlib::Inflate::new: Parameter 'Bufsize' must be an unsigned int, got '-1'");
85
86     eval { new Compress::Raw::Zlib::Deflate(-Bufsize => "xxx") };
87     like $@, mkErr("^Compress::Raw::Zlib::Deflate::new: Parameter 'Bufsize' must be an unsigned int, got 'xxx'");
88
89     eval { new Compress::Raw::Zlib::Inflate(-Bufsize => "xxx") };
90     like $@, mkErr("^Compress::Raw::Zlib::Inflate::new: Parameter 'Bufsize' must be an unsigned int, got 'xxx'");
91
92     eval { new Compress::Raw::Zlib::Inflate(-Bufsize => 1, 2) };
93     like $@, mkErr("^Compress::Raw::Zlib::Inflate::new: Expected even number of parameters, got 3");
94
95     eval { new Compress::Raw::Zlib::Deflate(-Bufsize => 1, 2) };
96     like $@, mkErr("^Compress::Raw::Zlib::Deflate::new: Expected even number of parameters, got 3");
97
98 }
99
100 {
101
102     title  "deflate/inflate - small buffer";
103     # ==============================
104
105     my $hello = "I am a HAL 9000 computer" ;
106     my @hello = split('', $hello) ;
107     my ($err, $x, $X, $status); 
108  
109     ok( ($x, $err) = new Compress::Raw::Zlib::Deflate ( -Bufsize => 1 ), "Create deflate object" );
110     ok $x, "Compress::Raw::Zlib::Deflate ok" ;
111     cmp_ok $err, '==', Z_OK, "status is Z_OK" ;
112  
113     ok ! defined $x->msg() ;
114     is $x->total_in(), 0, "total_in() == 0" ;
115     is $x->total_out(), 0, "total_out() == 0" ;
116
117     $X = "" ;
118     my $Answer = '';
119     foreach (@hello)
120     {
121         $status = $x->deflate($_, $X) ;
122         last unless $status == Z_OK ;
123     
124         $Answer .= $X ;
125     }
126      
127     cmp_ok $status, '==', Z_OK, "deflate returned Z_OK" ;
128     
129     cmp_ok  $x->flush($X), '==', Z_OK, "flush returned Z_OK" ;
130     $Answer .= $X ;
131      
132     ok ! defined $x->msg()  ;
133     is $x->total_in(), length $hello, "total_in ok" ;
134     is $x->total_out(), length $Answer, "total_out ok" ;
135      
136     my @Answer = split('', $Answer) ;
137      
138     my $k;
139     ok(($k, $err) = new Compress::Raw::Zlib::Inflate( {-Bufsize => 1}) );
140     ok $k, "Compress::Raw::Zlib::Inflate ok" ;
141     cmp_ok $err, '==', Z_OK, "status is Z_OK" ;
142  
143     ok ! defined $k->msg(), "No error messages" ;
144     is $k->total_in(), 0, "total_in() == 0" ;
145     is $k->total_out(), 0, "total_out() == 0" ;
146     my $GOT = '';
147     my $Z;
148     $Z = 1 ;#x 2000 ;
149     foreach (@Answer)
150     {
151         $status = $k->inflate($_, $Z) ;
152         $GOT .= $Z ;
153         last if $status == Z_STREAM_END or $status != Z_OK ;
154      
155     }
156      
157     cmp_ok $status, '==', Z_STREAM_END, "Got Z_STREAM_END" ;
158     is $GOT, $hello, "uncompressed data matches ok" ;
159     ok ! defined $k->msg(), "No error messages" ;
160     is $k->total_in(), length $Answer, "total_in ok" ;
161     is $k->total_out(), length $hello , "total_out ok";
162
163 }
164
165
166 {
167     # deflate/inflate - small buffer with a number
168     # ==============================
169
170     my $hello = 6529 ;
171  
172     ok  my ($x, $err) = new Compress::Raw::Zlib::Deflate ( -Bufsize => 1, -AppendOutput => 1 ) ;
173     ok $x ;
174     cmp_ok $err, '==', Z_OK ;
175  
176     my $status;
177     my $Answer = '';
178      
179     cmp_ok $x->deflate($hello, $Answer), '==', Z_OK ;
180     
181     cmp_ok $x->flush($Answer), '==', Z_OK ;
182      
183     my @Answer = split('', $Answer) ;
184      
185     my $k;
186     ok(($k, $err) = new Compress::Raw::Zlib::Inflate( {-Bufsize => 1, -AppendOutput =>1}) );
187     ok $k ;
188     cmp_ok $err, '==', Z_OK ;
189      
190     #my $GOT = '';
191     my $GOT ;
192     foreach (@Answer)
193     {
194         $status = $k->inflate($_, $GOT) ;
195         last if $status == Z_STREAM_END or $status != Z_OK ;
196      
197     }
198      
199     cmp_ok $status, '==', Z_STREAM_END ;
200     is $GOT, $hello ;
201
202 }
203
204 {
205
206 # deflate/inflate options - AppendOutput
207 # ================================
208
209     # AppendOutput
210     # CRC
211
212     my $hello = "I am a HAL 9000 computer" ;
213     my @hello = split('', $hello) ;
214      
215     ok  my ($x, $err) = new Compress::Raw::Zlib::Deflate ( {-Bufsize => 1, -AppendOutput =>1} ) ;
216     ok $x ;
217     cmp_ok $err, '==', Z_OK ;
218      
219     my $status;
220     my $X;
221     foreach (@hello)
222     {
223         $status = $x->deflate($_, $X) ;
224         last unless $status == Z_OK ;
225     }
226      
227     cmp_ok $status, '==', Z_OK ;
228      
229     cmp_ok $x->flush($X), '==', Z_OK ;
230      
231      
232     my @Answer = split('', $X) ;
233      
234     my $k;
235     ok(($k, $err) = new Compress::Raw::Zlib::Inflate( {-Bufsize => 1, -AppendOutput =>1}));
236     ok $k ;
237     cmp_ok $err, '==', Z_OK ;
238      
239     my $Z;
240     foreach (@Answer)
241     {
242         $status = $k->inflate($_, $Z) ;
243         last if $status == Z_STREAM_END or $status != Z_OK ;
244      
245     }
246      
247     cmp_ok $status, '==', Z_STREAM_END ;
248     is $Z, $hello ;
249 }
250
251  
252 {
253
254     title "deflate/inflate - larger buffer";
255     # ==============================
256
257     # generate a long random string
258     my $contents = '' ;
259     foreach (1 .. 50000)
260       { $contents .= chr int rand 255 }
261     
262     
263     ok my ($x, $err) = new Compress::Raw::Zlib::Deflate() ;
264     ok $x ;
265     cmp_ok $err, '==', Z_OK ;
266      
267     my (%X, $Y, %Z, $X, $Z);
268     #cmp_ok $x->deflate($contents, $X{key}), '==', Z_OK ;
269     cmp_ok $x->deflate($contents, $X), '==', Z_OK ;
270     
271     #$Y = $X{key} ;
272     $Y = $X ;
273      
274      
275     #cmp_ok $x->flush($X{key}), '==', Z_OK ;
276     #$Y .= $X{key} ;
277     cmp_ok $x->flush($X), '==', Z_OK ;
278     $Y .= $X ;
279      
280      
281  
282     my $keep = $Y ;
283
284     my $k;
285     ok(($k, $err) = new Compress::Raw::Zlib::Inflate() );
286     ok $k ;
287     cmp_ok $err, '==', Z_OK ;
288      
289     #cmp_ok $k->inflate($Y, $Z{key}), '==', Z_STREAM_END ;
290     #ok $contents eq $Z{key} ;
291     cmp_ok $k->inflate($Y, $Z), '==', Z_STREAM_END ;
292     ok $contents eq $Z ;
293
294     # redo deflate with AppendOutput
295
296     ok (($k, $err) = new Compress::Raw::Zlib::Inflate(-AppendOutput => 1)) ;
297     ok $k ;
298     cmp_ok $err, '==', Z_OK ;
299     
300     my $s ; 
301     my $out ;
302     my @bits = split('', $keep) ;
303     foreach my $bit (@bits) {
304         $s = $k->inflate($bit, $out) ;
305     }
306     
307     cmp_ok $s, '==', Z_STREAM_END ;
308      
309     ok $contents eq $out ;
310
311
312 }
313
314 {
315
316     title "deflate/inflate - preset dictionary";
317     # ===================================
318
319     my $dictionary = "hello" ;
320     ok my $x = new Compress::Raw::Zlib::Deflate({-Level => Z_BEST_COMPRESSION,
321                              -Dictionary => $dictionary}) ;
322  
323     my $dictID = $x->dict_adler() ;
324
325     my ($X, $Y, $Z);
326     cmp_ok $x->deflate($hello, $X), '==', Z_OK;
327     cmp_ok $x->flush($Y), '==', Z_OK;
328     $X .= $Y ;
329  
330     ok my $k = new Compress::Raw::Zlib::Inflate(-Dictionary => $dictionary) ;
331  
332     cmp_ok $k->inflate($X, $Z), '==', Z_STREAM_END;
333     is $k->dict_adler(), $dictID;
334     is $hello, $Z ;
335
336 }
337
338 title 'inflate - check remaining buffer after Z_STREAM_END';
339 #           and that ConsumeInput works.
340 # ===================================================
341  
342 for my $consume ( 0 .. 1)
343 {
344     ok my $x = new Compress::Raw::Zlib::Deflate(-Level => Z_BEST_COMPRESSION ) ;
345  
346     my ($X, $Y, $Z);
347     cmp_ok $x->deflate($hello, $X), '==', Z_OK;
348     cmp_ok $x->flush($Y), '==', Z_OK;
349     $X .= $Y ;
350  
351     ok my $k = new Compress::Raw::Zlib::Inflate( -ConsumeInput => $consume) ;
352  
353     my $first = substr($X, 0, 2) ;
354     my $remember_first = $first ;
355     my $last  = substr($X, 2) ;
356     cmp_ok $k->inflate($first, $Z), '==', Z_OK;
357     if ($consume) {
358         ok $first eq "" ;
359     }
360     else {
361         ok $first eq $remember_first ;
362     }
363
364     my $T ;
365     $last .= "appendage" ;
366     my $remember_last = $last ;
367     cmp_ok $k->inflate($last, $T),  '==', Z_STREAM_END;
368     is $hello, $Z . $T  ;
369     if ($consume) {
370         is $last, "appendage" ;
371     }
372     else {
373         is $last, $remember_last ;
374     }
375
376 }
377
378
379
380 {
381
382     title 'Check - MAX_WBITS';
383     # =================
384     
385     my $hello = "Test test test test test";
386     my @hello = split('', $hello) ;
387      
388     ok  my ($x, $err) = 
389        new Compress::Raw::Zlib::Deflate ( -Bufsize => 1, 
390                                      -WindowBits => -MAX_WBITS(),
391                                      -AppendOutput => 1 ) ;
392     ok $x ;
393     cmp_ok $err, '==', Z_OK ;
394
395     my $Answer = '';
396     my $status;
397     foreach (@hello)
398     {
399         $status = $x->deflate($_, $Answer) ;
400         last unless $status == Z_OK ;
401     }
402      
403     cmp_ok $status, '==', Z_OK ;
404     
405     cmp_ok $x->flush($Answer), '==', Z_OK ;
406      
407     my @Answer = split('', $Answer) ;
408     # Undocumented corner -- extra byte needed to get inflate to return 
409     # Z_STREAM_END when done.  
410     push @Answer, " " ; 
411      
412     my $k;
413     ok(($k, $err) = new Compress::Raw::Zlib::Inflate( 
414                         {-Bufsize => 1, 
415                         -AppendOutput =>1,
416                         -WindowBits => -MAX_WBITS()})) ;
417     ok $k ;
418     cmp_ok $err, '==', Z_OK ;
419      
420     my $GOT = '';
421     foreach (@Answer)
422     {
423         $status = $k->inflate($_, $GOT) ;
424         last if $status == Z_STREAM_END or $status != Z_OK ;
425      
426     }
427      
428     cmp_ok $status, '==', Z_STREAM_END ;
429     is $GOT, $hello ;
430     
431 }
432
433 SKIP:
434 {
435     title 'inflateSync';
436
437     skip "inflateSync needs zlib 1.2.1 or better, you have $Zlib_ver", 22 
438         if ZLIB_VERNUM() < 0x1210 ;
439
440     # create a deflate stream with flush points
441
442     my $hello = "I am a HAL 9000 computer" x 2001 ;
443     my $goodbye = "Will I dream?" x 2010;
444     my ($x, $err, $answer, $X, $Z, $status);
445     my $Answer ;
446      
447     #use Devel::Peek ;
448     ok(($x, $err) = new Compress::Raw::Zlib::Deflate(AppendOutput => 1)) ;
449     ok $x ;
450     cmp_ok $err, '==', Z_OK ;
451      
452     cmp_ok $x->deflate($hello, $Answer), '==', Z_OK;
453     
454     # create a flush point
455     cmp_ok $x->flush($Answer, Z_FULL_FLUSH), '==', Z_OK ;
456     
457     my $len1 = length $Answer;
458      
459     cmp_ok $x->deflate($goodbye, $Answer), '==', Z_OK;
460     
461     cmp_ok $x->flush($Answer), '==', Z_OK ;
462     my $len2 = length($Answer) - $len1 ;
463      
464     my ($first, @Answer) = split('', $Answer) ;
465      
466     my $k;
467     ok(($k, $err) = new Compress::Raw::Zlib::Inflate()) ;
468     ok $k ;
469     cmp_ok $err, '==', Z_OK ;
470      
471     cmp_ok  $k->inflate($first, $Z), '==', Z_OK;
472
473     # skip to the first flush point.
474     while (@Answer)
475     {
476         my $byte = shift @Answer;
477         $status = $k->inflateSync($byte) ;
478         last unless $status == Z_DATA_ERROR;
479     }
480
481     cmp_ok $status, '==', Z_OK;
482      
483     my $GOT = '';
484     foreach (@Answer)
485     {
486         my $Z = '';
487         $status = $k->inflate($_, $Z) ;
488         $GOT .= $Z if defined $Z ;
489         # print "x $status\n";
490         last if $status == Z_STREAM_END or $status != Z_OK ;
491     }
492      
493     cmp_ok $status, '==', Z_DATA_ERROR ;
494     is $GOT, $goodbye ;
495
496
497     # Check inflateSync leaves good data in buffer
498     my $rest = $Answer ;
499     $rest =~ s/^(.)//;
500     my $initial = $1 ;
501
502     
503     ok(($k, $err) = new Compress::Raw::Zlib::Inflate(ConsumeInput => 0)) ;
504     ok $k ;
505     cmp_ok $err, '==', Z_OK ;
506      
507     cmp_ok $k->inflate($initial, $Z), '==', Z_OK;
508
509     # Skip to the flush point
510     $status = $k->inflateSync($rest);
511     cmp_ok $status, '==', Z_OK
512      or diag "status '$status'\nlength rest is " . length($rest) . "\n" ;
513      
514     is length($rest), $len2, "expected compressed output";
515     
516     $GOT = ''; 
517     cmp_ok $k->inflate($rest, $GOT), '==', Z_DATA_ERROR, "inflate returns Z_DATA_ERROR";
518     is $GOT, $goodbye ;
519 }
520
521 {
522     title 'deflateParams';
523
524     my $hello = "I am a HAL 9000 computer" x 2001 ;
525     my $goodbye = "Will I dream?" x 2010;
526     my ($x, $input, $err, $answer, $X, $status, $Answer);
527      
528     ok(($x, $err) = new Compress::Raw::Zlib::Deflate(
529                        -AppendOutput   => 1,
530                        -Level    => Z_DEFAULT_COMPRESSION,
531                        -Strategy => Z_DEFAULT_STRATEGY)) ;
532     ok $x ;
533     cmp_ok $err, '==', Z_OK ;
534
535     ok $x->get_Level()    == Z_DEFAULT_COMPRESSION;
536     ok $x->get_Strategy() == Z_DEFAULT_STRATEGY;
537      
538     $status = $x->deflate($hello, $Answer) ;
539     cmp_ok $status, '==', Z_OK ;
540     $input .= $hello;
541     
542     # error cases
543     eval { $x->deflateParams() };
544     like $@, mkErr('^Compress::Raw::Zlib::deflateParams needs Level and\/or Strategy');
545
546     eval { $x->deflateParams(-Bufsize => 0) };
547     like $@, mkErr('^Compress::Raw::Zlib::Inflate::deflateParams: Bufsize must be >= 1, you specified 0');
548
549     eval { $x->deflateParams(-Joe => 3) };
550     like $@, mkErr('^Compress::Raw::Zlib::deflateStream::deflateParams: unknown key value\(s\) Joe');
551
552     is $x->get_Level(),    Z_DEFAULT_COMPRESSION;
553     is $x->get_Strategy(), Z_DEFAULT_STRATEGY;
554      
555     # change both Level & Strategy
556     $status = $x->deflateParams(-Level => Z_BEST_SPEED, -Strategy => Z_HUFFMAN_ONLY, -Bufsize => 1234) ;
557     cmp_ok $status, '==', Z_OK ;
558     
559     is $x->get_Level(),    Z_BEST_SPEED;
560     is $x->get_Strategy(), Z_HUFFMAN_ONLY;
561      
562     # change both Level & Strategy again without any calls to deflate 
563     $status = $x->deflateParams(-Level => Z_DEFAULT_COMPRESSION, -Strategy => Z_DEFAULT_STRATEGY, -Bufsize => 1234) ;
564     cmp_ok $status, '==', Z_OK ;
565     
566     is $x->get_Level(),    Z_DEFAULT_COMPRESSION;
567     is $x->get_Strategy(), Z_DEFAULT_STRATEGY;
568      
569     $status = $x->deflate($goodbye, $Answer) ;
570     cmp_ok $status, '==', Z_OK ;
571     $input .= $goodbye;
572     
573     # change only Level 
574     $status = $x->deflateParams(-Level => Z_NO_COMPRESSION) ;
575     cmp_ok $status, '==', Z_OK ;
576     
577     is $x->get_Level(),    Z_NO_COMPRESSION;
578     is $x->get_Strategy(), Z_DEFAULT_STRATEGY;
579      
580     $status = $x->deflate($goodbye, $Answer) ;
581     cmp_ok $status, '==', Z_OK ;
582     $input .= $goodbye;
583     
584     # change only Strategy
585     $status = $x->deflateParams(-Strategy => Z_FILTERED) ;
586     cmp_ok $status, '==', Z_OK ;
587     
588     is $x->get_Level(),    Z_NO_COMPRESSION;
589     is $x->get_Strategy(), Z_FILTERED;
590      
591     $status = $x->deflate($goodbye, $Answer) ;
592     cmp_ok $status, '==', Z_OK ;
593     $input .= $goodbye;
594     
595     cmp_ok $x->flush($Answer), '==', Z_OK ;
596      
597     my $k;
598     ok(($k, $err) = new Compress::Raw::Zlib::Inflate()) ;
599     ok $k ;
600     cmp_ok $err, '==', Z_OK ;
601      
602     my $Z;
603     $status = $k->inflate($Answer, $Z) ;
604
605     cmp_ok $status, '==', Z_STREAM_END ;
606     is $Z, $input ;
607 }
608
609
610 {
611     title "ConsumeInput and a read-only buffer trapped" ;
612
613     ok my $k = new Compress::Raw::Zlib::Inflate(-ConsumeInput => 1) ;
614      
615     my $Z; 
616     eval { $k->inflate("abc", $Z) ; };
617     like $@, mkErr("Compress::Raw::Zlib::Inflate::inflate input parameter cannot be read-only when ConsumeInput is specified");
618
619 }
620
621 foreach (1 .. 2)
622 {
623     next if $] < 5.005 ;
624
625     title 'test inflate/deflate with a substr';
626
627     my $contents = '' ;
628     foreach (1 .. 5000)
629       { $contents .= chr int rand 255 }
630     ok  my $x = new Compress::Raw::Zlib::Deflate(-AppendOutput => 1) ;
631      
632     my $X ;
633     my $status = $x->deflate(substr($contents,0), $X);
634     cmp_ok $status, '==', Z_OK ;
635     
636     cmp_ok $x->flush($X), '==', Z_OK  ;
637      
638     my $append = "Appended" ;
639     $X .= $append ;
640      
641     ok my $k = new Compress::Raw::Zlib::Inflate(-AppendOutput => 1) ;
642      
643     my $Z; 
644     my $keep = $X ;
645     $status = $k->inflate(substr($X, 0), $Z) ;
646      
647     cmp_ok $status, '==', Z_STREAM_END ;
648     #print "status $status X [$X]\n" ;
649     is $contents, $Z ;
650     ok $X eq $append;
651     #is length($X), length($append);
652     #ok $X eq $keep;
653     #is length($X), length($keep);
654 }
655
656 title 'Looping Append test - checks that deRef_l resets the output buffer';
657 foreach (1 .. 2)
658 {
659
660     my $hello = "I am a HAL 9000 computer" ;
661     my @hello = split('', $hello) ;
662     my ($err, $x, $X, $status); 
663  
664     ok( ($x, $err) = new Compress::Raw::Zlib::Deflate ( -Bufsize => 1 ) );
665     ok $x ;
666     cmp_ok $err, '==', Z_OK ;
667  
668     $X = "" ;
669     my $Answer = '';
670     foreach (@hello)
671     {
672         $status = $x->deflate($_, $X) ;
673         last unless $status == Z_OK ;
674     
675         $Answer .= $X ;
676     }
677      
678     cmp_ok $status, '==', Z_OK ;
679     
680     cmp_ok  $x->flush($X), '==', Z_OK ;
681     $Answer .= $X ;
682      
683     my @Answer = split('', $Answer) ;
684      
685     my $k;
686     ok(($k, $err) = new Compress::Raw::Zlib::Inflate(-AppendOutput => 1) );
687     ok $k ;
688     cmp_ok $err, '==', Z_OK ;
689  
690     my $GOT ;
691     my $Z;
692     $Z = 1 ;#x 2000 ;
693     foreach (@Answer)
694     {
695         $status = $k->inflate($_, $GOT) ;
696         last if $status == Z_STREAM_END or $status != Z_OK ;
697     }
698      
699     cmp_ok $status, '==', Z_STREAM_END ;
700     is $GOT, $hello ;
701
702 }
703
704 if ($] >= 5.005)
705 {
706     title 'test inflate input parameter via substr';
707
708     my $hello = "I am a HAL 9000 computer" ;
709     my $data = $hello ;
710
711     my($X, $Z);
712
713     ok my $x = new Compress::Raw::Zlib::Deflate ( -AppendOutput => 1 );
714
715     cmp_ok $x->deflate($data, $X), '==',  Z_OK ;
716
717     cmp_ok $x->flush($X), '==', Z_OK ;
718      
719     my $append = "Appended" ;
720     $X .= $append ;
721     my $keep = $X ;
722      
723     ok my $k = new Compress::Raw::Zlib::Inflate ( -AppendOutput => 1,
724                                              -ConsumeInput => 1 ) ;
725      
726     cmp_ok $k->inflate(substr($X, 0, -1), $Z), '==', Z_STREAM_END ; ;
727      
728     ok $hello eq $Z ;
729     is $X, $append;
730     
731     $X = $keep ;
732     $Z = '';
733     ok $k = new Compress::Raw::Zlib::Inflate ( -AppendOutput => 1,
734                                           -ConsumeInput => 0 ) ;
735      
736     cmp_ok $k->inflate(substr($X, 0, -1), $Z), '==', Z_STREAM_END ; ;
737     #cmp_ok $k->inflate(substr($X, 0), $Z), '==', Z_STREAM_END ; ;
738      
739     ok $hello eq $Z ;
740     is $X, $keep;
741     
742 }
743
744 SKIP:
745 {
746     skip "InflateScan needs zlib 1.2.1 or better, you have $Zlib_ver", 1 
747         if ZLIB_VERNUM() < 0x1210 ;
748
749     # regression - check that resetLastBlockByte can cope with a NULL
750     # pointer.
751     Compress::Raw::Zlib::InflateScan->new->resetLastBlockByte(undef);
752     ok 1, "resetLastBlockByte(undef) is ok" ;
753 }
754
755 SKIP:
756 {
757
758     title "gzip mode";
759     # ================
760
761     skip "gzip mode needs zlib 1.2.1 or better, you have $Zlib_ver", 13 
762         if ZLIB_VERNUM() < 0x1210 ;
763
764     my $hello = "I am a HAL 9000 computer" ;
765     my @hello = split('', $hello) ;
766     my ($err, $x, $X, $status); 
767  
768     ok( ($x, $err) = new Compress::Raw::Zlib::Deflate ( 
769             WindowBits => WANT_GZIP ,
770             AppendOutput => 1
771         ), "Create deflate object" );
772     ok $x, "Compress::Raw::Zlib::Deflate ok" ;
773     cmp_ok $err, '==', Z_OK, "status is Z_OK" ;
774  
775     $status = $x->deflate($hello, $X) ;
776     cmp_ok $status, '==', Z_OK, "deflate returned Z_OK" ;
777     
778     cmp_ok  $x->flush($X), '==', Z_OK, "flush returned Z_OK" ;
779      
780     my ($k, $GOT); 
781     ($k, $err) = new Compress::Raw::Zlib::Inflate( 
782             WindowBits => WANT_GZIP ,
783             ConsumeInput => 0 ,
784             AppendOutput => 1);
785     ok $k, "Compress::Raw::Zlib::Inflate WANT_GZIP ok" ;
786     cmp_ok $err, '==', Z_OK, "status is Z_OK" ;
787  
788     $status = $k->inflate($X, $GOT) ;
789     cmp_ok $status, '==', Z_STREAM_END, "Got Z_STREAM_END" ;
790     is $GOT, $hello, "uncompressed data matches ok" ;
791
792     $GOT = '';
793     ($k, $err) = new Compress::Raw::Zlib::Inflate( 
794             WindowBits => WANT_GZIP_OR_ZLIB ,
795             AppendOutput => 1);
796     ok $k, "Compress::Raw::Zlib::Inflate WANT_GZIP_OR_ZLIB ok" ;
797     cmp_ok $err, '==', Z_OK, "status is Z_OK" ;
798  
799     $status = $k->inflate($X, $GOT) ;
800     cmp_ok $status, '==', Z_STREAM_END, "Got Z_STREAM_END" ;
801     is $GOT, $hello, "uncompressed data matches ok" ;
802 }
803
804 SKIP:
805 {
806
807     title "gzip error mode";
808     # Create gzip -
809     # read with no special windowbits setting - this will fail
810     # then read with WANT_GZIP_OR_ZLIB - thi swill work
811     # ================
812
813     skip "gzip mode needs zlib 1.2.1 or better, you have $Zlib_ver", 12 
814         if ZLIB_VERNUM() < 0x1210 ;
815
816     my $hello = "I am a HAL 9000 computer" ;
817     my ($err, $x, $X, $status); 
818  
819     ok( ($x, $err) = new Compress::Raw::Zlib::Deflate ( 
820             WindowBits => WANT_GZIP ,
821             AppendOutput => 1
822         ), "Create deflate object" );
823     ok $x, "Compress::Raw::Zlib::Deflate ok" ;
824     cmp_ok $err, '==', Z_OK, "status is Z_OK" ;
825  
826     $status = $x->deflate($hello, $X) ;
827     cmp_ok $status, '==', Z_OK, "deflate returned Z_OK" ;
828     
829     cmp_ok  $x->flush($X), '==', Z_OK, "flush returned Z_OK" ;
830      
831     my ($k, $GOT); 
832     ($k, $err) = new Compress::Raw::Zlib::Inflate( 
833             WindowBits => MAX_WBITS ,
834             ConsumeInput => 0 ,
835             AppendOutput => 1);
836     ok $k, "Compress::Raw::Zlib::Inflate WANT_GZIP ok" ;
837     cmp_ok $err, '==', Z_OK, "status is Z_OK" ;
838  
839     $status = $k->inflate($X, $GOT) ;
840     cmp_ok $status, '==', Z_DATA_ERROR, "Got Z_DATA_ERROR" ;
841
842     $GOT = '';
843     ($k, $err) = new Compress::Raw::Zlib::Inflate( 
844             WindowBits => WANT_GZIP_OR_ZLIB ,
845             AppendOutput => 1);
846     ok $k, "Compress::Raw::Zlib::Inflate WANT_GZIP_OR_ZLIB ok" ;
847     cmp_ok $err, '==', Z_OK, "status is Z_OK" ;
848  
849     $status = $k->inflate($X, $GOT) ;
850     cmp_ok $status, '==', Z_STREAM_END, "Got Z_STREAM_END" ;
851     is $GOT, $hello, "uncompressed data matches ok" ;
852 }
853
854 SKIP:
855 {
856     title "gzip/zlib error mode";
857     # Create zlib -
858     # read with no WANT_GZIP windowbits setting - this will fail
859     # then read with WANT_GZIP_OR_ZLIB - thi swill work
860     # ================
861
862     skip "gzip mode needs zlib 1.2.1 or better, you have $Zlib_ver", 12 
863         if ZLIB_VERNUM() < 0x1210 ;
864
865     my $hello = "I am a HAL 9000 computer" ;
866     my ($err, $x, $X, $status); 
867  
868     ok( ($x, $err) = new Compress::Raw::Zlib::Deflate ( 
869             AppendOutput => 1
870         ), "Create deflate object" );
871     ok $x, "Compress::Raw::Zlib::Deflate ok" ;
872     cmp_ok $err, '==', Z_OK, "status is Z_OK" ;
873  
874     $status = $x->deflate($hello, $X) ;
875     cmp_ok $status, '==', Z_OK, "deflate returned Z_OK" ;
876     
877     cmp_ok  $x->flush($X), '==', Z_OK, "flush returned Z_OK" ;
878      
879     my ($k, $GOT); 
880     ($k, $err) = new Compress::Raw::Zlib::Inflate( 
881             WindowBits => WANT_GZIP ,
882             ConsumeInput => 0 ,
883             AppendOutput => 1);
884     ok $k, "Compress::Raw::Zlib::Inflate WANT_GZIP ok" ;
885     cmp_ok $err, '==', Z_OK, "status is Z_OK" ;
886  
887     $status = $k->inflate($X, $GOT) ;
888     cmp_ok $status, '==', Z_DATA_ERROR, "Got Z_DATA_ERROR" ;
889
890     $GOT = '';
891     ($k, $err) = new Compress::Raw::Zlib::Inflate( 
892             WindowBits => WANT_GZIP_OR_ZLIB ,
893             AppendOutput => 1);
894     ok $k, "Compress::Raw::Zlib::Inflate WANT_GZIP_OR_ZLIB ok" ;
895     cmp_ok $err, '==', Z_OK, "status is Z_OK" ;
896  
897     $status = $k->inflate($X, $GOT) ;
898     cmp_ok $status, '==', Z_STREAM_END, "Got Z_STREAM_END" ;
899     is $GOT, $hello, "uncompressed data matches ok" ;
900 }
901
902 {
903     title "zlibCompileFlags";
904
905     my $flags = Compress::Raw::Zlib::zlibCompileFlags;
906
907     if (ZLIB_VERNUM() < 0x1210)
908     {
909         is $flags, 0, "zlibCompileFlags == 0 if < 1.2.1";
910     }
911     else
912     {
913         ok $flags, "zlibCompileFlags != 0 if < 1.2.1";
914     }
915 }
916
917 {
918     title "repeated calls to flush after some compression";
919
920     my $hello = "I am a HAL 9000 computer" ;
921     my ($err, $x, $X, $status); 
922  
923     ok( ($x, $err) = new Compress::Raw::Zlib::Deflate ( ), "Create deflate object" );
924     isa_ok $x, "Compress::Raw::Zlib::deflateStream" ;
925     cmp_ok $err, '==', Z_OK, "status is Z_OK" ;
926  
927     $status = $x->deflate($hello, $X) ;
928     cmp_ok $status, '==', Z_OK, "deflate returned Z_OK" ;
929     
930     cmp_ok  $x->flush($X, Z_SYNC_FLUSH), '==', Z_OK, "flush returned Z_OK" ;    
931     cmp_ok  $x->flush($X, Z_SYNC_FLUSH), '==', Z_OK, "second flush returned Z_OK" ; 
932     is $X, "", "no output from second flush";
933 }
934
935 {
936     title "repeated calls to flush - no compression";
937
938     my $hello = "I am a HAL 9000 computer" ;
939     my ($err, $x, $X, $status); 
940  
941     ok( ($x, $err) = new Compress::Raw::Zlib::Deflate ( ), "Create deflate object" );
942     isa_ok $x, "Compress::Raw::Zlib::deflateStream" ;
943     cmp_ok $err, '==', Z_OK, "status is Z_OK" ;
944     
945     cmp_ok  $x->flush($X, Z_SYNC_FLUSH), '==', Z_OK, "flush returned Z_OK" ;    
946     cmp_ok  $x->flush($X, Z_SYNC_FLUSH), '==', Z_OK, "second flush returned Z_OK" ; 
947     is $X, "", "no output from second flush";
948 }
949
950 {
951     title "crc32";
952
953     is eval('Compress::Raw::Zlib::crc32("A" x 0x100, 0, 0x100); 0x1234'), 0x1234;
954     is $@,  '';
955
956     is eval('Compress::Raw::Zlib::crc32("A" x 0x100, 0, 0x101); 0x1234'), undef;
957     like $@,  mkErr("^Offset out of range in Compress::Raw::Zlib::crc32") ;
958
959 }
960
961 if (0)
962 {
963     title "RT #122695: sync flush appending extra empty uncompressed block";
964
965     my $hello = "I am a HAL 9000 computer" ;
966     my ($err, $x, $X, $status); 
967  
968     ok( ($x, $err) = new Compress::Raw::Zlib::Deflate ( ), "Create deflate object" );
969     isa_ok $x, "Compress::Raw::Zlib::deflateStream" ;
970     cmp_ok $err, '==', Z_OK, "status is Z_OK" ;
971     
972     cmp_ok  $x->flush($X, Z_SYNC_FLUSH), '==', Z_OK, "flush returned Z_OK" ;    
973     cmp_ok  $x->flush($X, Z_SYNC_FLUSH), '==', Z_OK, "second flush returned Z_OK" ; 
974     is $X, "", "no output from second flush";
975 }
976
977 exit if $] < 5.006 ;
978
979 title 'Looping Append test with substr output - substr the end of the string';
980 foreach (1 .. 2)
981 {
982
983     my $hello = "I am a HAL 9000 computer" ;
984     my @hello = split('', $hello) ;
985     my ($err, $x, $X, $status); 
986  
987     ok( ($x, $err) = new Compress::Raw::Zlib::Deflate ( -Bufsize => 1,
988                                             -AppendOutput => 1 ) );
989     ok $x ;
990     cmp_ok $err, '==', Z_OK ;
991  
992     $X = "" ;
993     my $Answer = '';
994     foreach (@hello)
995     {
996         $status = $x->deflate($_, substr($Answer, length($Answer))) ;
997         last unless $status == Z_OK ;
998     
999     }
1000      
1001     cmp_ok $status, '==', Z_OK ;
1002     
1003     cmp_ok  $x->flush(substr($Answer, length($Answer))), '==', Z_OK ;
1004      
1005     #cmp_ok length $Answer, ">", 0 ;
1006
1007     my @Answer = split('', $Answer) ;
1008     
1009      
1010     my $k;
1011     ok(($k, $err) = new Compress::Raw::Zlib::Inflate(-AppendOutput => 1) );
1012     ok $k ;
1013     cmp_ok $err, '==', Z_OK ;
1014  
1015     my $GOT = '';
1016     my $Z;
1017     $Z = 1 ;#x 2000 ;
1018     foreach (@Answer)
1019     {
1020         $status = $k->inflate($_, substr($GOT, length($GOT))) ;
1021         last if $status == Z_STREAM_END or $status != Z_OK ;
1022     }
1023      
1024     cmp_ok $status, '==', Z_STREAM_END ;
1025     is $GOT, $hello ;
1026
1027 }
1028
1029 title 'Looping Append test with substr output - substr the complete string';
1030 foreach (1 .. 2)
1031 {
1032
1033     my $hello = "I am a HAL 9000 computer" ;
1034     my @hello = split('', $hello) ;
1035     my ($err, $x, $X, $status); 
1036  
1037     ok( ($x, $err) = new Compress::Raw::Zlib::Deflate ( -Bufsize => 1,
1038                                             -AppendOutput => 1 ) );
1039     ok $x ;
1040     cmp_ok $err, '==', Z_OK ;
1041  
1042     $X = "" ;
1043     my $Answer = '';
1044     foreach (@hello)
1045     {
1046         $status = $x->deflate($_, substr($Answer, 0)) ;
1047         last unless $status == Z_OK ;
1048     
1049     }
1050      
1051     cmp_ok $status, '==', Z_OK ;
1052     
1053     cmp_ok  $x->flush(substr($Answer, 0)), '==', Z_OK ;
1054      
1055     my @Answer = split('', $Answer) ;
1056      
1057     my $k;
1058     ok(($k, $err) = new Compress::Raw::Zlib::Inflate(-AppendOutput => 1) );
1059     ok $k ;
1060     cmp_ok $err, '==', Z_OK ;
1061  
1062     my $GOT = '';
1063     my $Z;
1064     $Z = 1 ;#x 2000 ;
1065     foreach (@Answer)
1066     {
1067         $status = $k->inflate($_, substr($GOT, 0)) ;
1068         last if $status == Z_STREAM_END or $status != Z_OK ;
1069     }
1070      
1071     cmp_ok $status, '==', Z_STREAM_END ;
1072     is $GOT, $hello ;
1073 }
1074