projects / p5sagit/p5-mst-13.2.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | history | HEAD
Fix Compress::Zlib test boilerplate
[p5sagit/p5-mst-13.2.git] / ext / Compress / Zlib / t / 16oneshot.t
CommitLineData
16816334 1BEGIN {
d695c1a1 2 if ($ENV{PERL_CORE}) {
16816334 3 chdir 't' if -d 't';
4 @INC = '../lib';
5 }
6}
642e522c 7
8use lib 't';
9use strict;
10use warnings;
11use bytes;
12
13use Test::More ;
14use ZlibTestUtils;
15
16BEGIN {
17 plan(skip_all => "oneshot needs Perl 5.005 or better - you have Perl $]" )
18 if $] < 5.005 ;
19
20
21 # use Test::NoWarnings, if available
22 my $extra = 0 ;
23 $extra = 1
24 if eval { require Test::NoWarnings ; import Test::NoWarnings; 1 };
25
26 plan tests => 2526 + $extra ;
27
28 use_ok('Compress::Zlib', 2) ;
29
30 use_ok('IO::Compress::Gzip', qw(gzip $GzipError)) ;
31 use_ok('IO::Uncompress::Gunzip', qw(gunzip $GunzipError)) ;
32
33 use_ok('IO::Compress::Deflate', qw(deflate $DeflateError)) ;
34 use_ok('IO::Uncompress::Inflate', qw(inflate $InflateError)) ;
35
36 use_ok('IO::Compress::RawDeflate', qw(rawdeflate $RawDeflateError)) ;
37 use_ok('IO::Uncompress::RawInflate', qw(rawinflate $RawInflateError)) ;
38
39 use_ok('IO::Uncompress::AnyInflate', qw(anyinflate $AnyInflateError)) ;
40
41}
42
43
44# Check zlib_version and ZLIB_VERSION are the same.
45is Compress::Zlib::zlib_version, ZLIB_VERSION,
46 "ZLIB_VERSION matches Compress::Zlib::zlib_version" ;
47
48
49
50foreach my $bit ('IO::Compress::Gzip',
51 'IO::Uncompress::Gunzip',
52 'IO::Compress::Deflate',
53 'IO::Uncompress::Inflate',
54 'IO::Compress::RawDeflate',
55 'IO::Uncompress::RawInflate',
56 'IO::Uncompress::AnyInflate',
57 )
58{
59 my $Error = getErrorRef($bit);
60 my $Func = getTopFuncRef($bit);
61 my $TopType = getTopFuncName($bit);
62
63 title "Testing $TopType Error Cases";
64
65 my $a;
66 my $x ;
67
68 eval { $a = $Func->(\$a => \$x, Fred => 1) ;} ;
69 like $@, mkErr("^$TopType: unknown key value\\(s\\) Fred"), ' Illegal Parameters';
70
71 eval { $a = $Func->() ;} ;
72 like $@, mkErr("^$TopType: expected at least 1 parameters"), ' No Parameters';
73
74 eval { $a = $Func->(\$x, \1) ;} ;
75 like $@, mkErr("^$TopType: output buffer is read-only"), ' Output is read-only' ;
76
77 my $in ;
78 eval { $a = $Func->($in, \$x) ;} ;
79 like $@, mkErr("^$TopType: input filename is undef or null string"),
80 ' Input filename undef' ;
81
82 $in = '';
83 eval { $a = $Func->($in, \$x) ;} ;
84 like $@, mkErr("^$TopType: input filename is undef or null string"),
85 ' Input filename empty' ;
86
87 $in = 'abc';
88 my $lex1 = new LexFile($in) ;
89 writeFile($in, "abc");
90 my $out = $in ;
91 eval { $a = $Func->($in, $out) ;} ;
92 like $@, mkErr("^$TopType: input and output filename are identical"),
93 ' Input and Output filename are the same';
94
95 eval { $a = $Func->(\$in, \$in) ;} ;
96 like $@, mkErr("^$TopType: input and output buffer are identical"),
97 ' Input and Output buffer are the same';
98
99 my $out_file = "abcde.out";
100 my $lex = new LexFile($out_file) ;
101 open OUT, ">$out_file" ;
102 eval { $a = $Func->(\*OUT, \*OUT) ;} ;
103 like $@, mkErr("^$TopType: input and output handle are identical"),
104 ' Input and Output handle are the same';
105
106 close OUT;
107 is -s $out_file, 0, " File zero length" ;
108 {
109 my %x = () ;
110 my $object = bless \%x, "someClass" ;
111
112 # Buffer not a scalar reference
113 #eval { $a = $Func->(\$x, \%x) ;} ;
114 eval { $a = $Func->(\$x, $object) ;} ;
115 like $@, mkErr("^$TopType: illegal output parameter"),
116 ' Bad Output Param';
117
118
119 #eval { $a = $Func->(\%x, \$x) ;} ;
120 eval { $a = $Func->($object, \$x) ;} ;
121 like $@, mkErr("^$TopType: illegal input parameter"),
122 ' Bad Input Param';
123 }
124
125 my $filename = 'abc.def';
126 ok ! -e $filename, " input file '$filename' does not exist";
127 $a = $Func->($filename, \$x) ;
128 is $a, undef, " $TopType returned undef";
129 like $$Error, "/^input file '$filename' does not exist\$/", " input File '$filename' does not exist";
130
131 $filename = '/tmp/abd/abc.def';
132 ok ! -e $filename, " output File '$filename' does not exist";
133 $a = $Func->(\$x, $filename) ;
134 is $a, undef, " $TopType returned undef";
135 like $$Error, ("/^(cannot open file '$filename'|input file '$filename' does not exist):/"), " output File '$filename' does not exist";
136
137 $a = $Func->(\$x, '<abc>') ;
138 is $a, undef, " $TopType returned undef";
139 like $$Error, "/Need input fileglob for outout fileglob/",
140 ' Output fileglob with no input fileglob';
141
142 $a = $Func->('<abc)>', '<abc>') ;
143 is $a, undef, " $TopType returned undef";
144 like $$Error, "/Unmatched \\) in input fileglob/",
145 " Unmatched ) in input fileglob";
146}
147
148foreach my $bit ('IO::Uncompress::Gunzip',
149 'IO::Uncompress::Inflate',
150 'IO::Uncompress::RawInflate',
151 'IO::Uncompress::AnyInflate',
152 )
153{
154 my $Error = getErrorRef($bit);
155 my $Func = getTopFuncRef($bit);
156 my $TopType = getTopFuncName($bit);
157
158 my $data = "mary had a little lamb" ;
159 my $keep = $data ;
160
161 for my $trans ( 0, 1)
162 {
163 title "Non-compressed data with $TopType, Transparent => $trans ";
164 my $a;
165 my $x ;
166 my $out = '' ;
167
168 $a = $Func->(\$data, \$out, Transparent => $trans) ;
169
170 is $data, $keep, " Input buffer not changed" ;
171
172 if ($trans)
173 {
174 ok $a, " $TopType returned true" ;
175 is $out, $data, " got expected output" ;
176 ok ! $$Error, " no error [$$Error]" ;
177 }
178 else
179 {
180 ok ! $a, " $TopType returned false" ;
181 #like $$Error, '/xxx/', " error" ;
182 ok $$Error, " error is '$$Error'" ;
183 }
184 }
185}
186
187foreach my $bit ('IO::Compress::Gzip',
188 'IO::Compress::Deflate',
189 'IO::Compress::RawDeflate',
190 )
191{
192 my $Error = getErrorRef($bit);
193 my $Func = getTopFuncRef($bit);
194 my $TopType = getTopFuncName($bit);
195 my $TopTypeInverse = getInverse($bit);
196 my $FuncInverse = getTopFuncRef($TopTypeInverse);
197 my $ErrorInverse = getErrorRef($TopTypeInverse);
198
199 title "$TopTypeInverse - corrupt data";
200
201 my $data = "abcd" x 100 ;
202 my $out;
203
204 ok $Func->(\$data, \$out), " $TopType ok";
205
206 # corrupt the compressed data
207 substr($out, -10, 10) = "x" x 10 ;
208
209 my $result;
210 ok ! $FuncInverse->(\$out => \$result, Transparent => 0), " $TopTypeInverse ok";
211 ok $$ErrorInverse, " Got error '$$ErrorInverse'" ;
212
213 #is $result, $data, " data ok";
214
215 ok ! anyinflate(\$out => \$result, Transparent => 0), " anyinflate ok";
216 ok $AnyInflateError, " Got error '$AnyInflateError'" ;
217}
218
219
220foreach my $bit ('IO::Compress::Gzip',
221 'IO::Compress::Deflate',
222 'IO::Compress::RawDeflate',
223 )
224{
225 my $Error = getErrorRef($bit);
226 my $Func = getTopFuncRef($bit);
227 my $TopType = getTopFuncName($bit);
228 my $TopTypeInverse = getInverse($bit);
229 my $FuncInverse = getTopFuncRef($TopTypeInverse);
230
231 for my $append ( 1, 0 )
232 {
233 my $already = '';
234 $already = 'abcde' if $append ;
235
236 for my $buffer ( undef, '', "abcde" )
237 {
238
239 my $disp_content = defined $buffer ? $buffer : '<undef>' ;
240
241 my $keep = $buffer;
242 my $out_file = "abcde.out";
243 my $in_file = "abcde.in";
244
245 {
246 title "$TopType - From Buff to Buff content '$disp_content' Append $append" ;
247
248 my $output = $already;
249 ok &$Func(\$buffer, \$output, Append => $append), ' Compressed ok' ;
250
251 is $keep, $buffer, " Input buffer not changed" ;
252 my $got = anyUncompress(\$output, $already);
253 $got = undef if ! defined $buffer && $got eq '' ;
254 is $got, $buffer, " Uncompressed matches original";
255
256 }
257
258 {
259 title "$TopType - From Buff to Array Ref content '$disp_content' Append $append" ;
260
261 my @output = ('first') ;
262 ok &$Func(\$buffer, \@output, Append => $append), ' Compressed ok' ;
263
264 is $output[0], 'first', " Array[0] unchanged";
265 is $keep, $buffer, " Input buffer not changed" ;
266 my $got = anyUncompress($output[1]);
267 $got = undef if ! defined $buffer && $got eq '' ;
268 is $got, $buffer, " Uncompressed matches original";
269 }
270
271 {
272 title "$TopType - From Array Ref to Array Ref content '$disp_content' Append $append" ;
273
274 my @output = ('first') ;
275 my @input = ( \$buffer);
276 ok &$Func(\@input, \@output, Append => $append), ' Compressed ok' ;
277
278 is $output[0], 'first', " Array[0] unchanged";
279 is $keep, $buffer, " Input buffer not changed" ;
280 my $got = anyUncompress($output[1]);
281 $got = undef if ! defined $buffer && $got eq '' ;
282 is $got, $buffer, " Uncompressed matches original";
283
284 }
285
286 {
287 title "$TopType - From Buff to Filename content '$disp_content' Append $append" ;
288
289 my $lex = new LexFile($out_file) ;
290 ok ! -e $out_file, " Output file does not exist";
291 writeFile($out_file, $already);
292
293 ok &$Func(\$buffer, $out_file, Append => $append), ' Compressed ok' ;
294
295 ok -e $out_file, " Created output file";
296 my $got = anyUncompress($out_file, $already);
297 $got = undef if ! defined $buffer && $got eq '' ;
298 is $got, $buffer, " Uncompressed matches original";
299 }
300
301 {
302 title "$TopType - From Buff to Handle content '$disp_content' Append $append" ;
303
304 my $lex = new LexFile($out_file) ;
305
306 ok ! -e $out_file, " Output file does not exist";
307 writeFile($out_file, $already);
308 my $of = new IO::File ">>$out_file" ;
309 ok $of, " Created output filehandle" ;
310
311 ok &$Func(\$buffer, $of, AutoClose => 1, Append => $append), ' Compressed ok' ;
312
313 ok -e $out_file, " Created output file";
314 my $got = anyUncompress($out_file, $already);
315 $got = undef if ! defined $buffer && $got eq '' ;
316 is $got, $buffer, " Uncompressed matches original";
317 }
318
319
320 {
321 title "$TopType - From Filename to Filename content '$disp_content' Append $append" ;
322
323 my $lex = new LexFile($in_file, $out_file) ;
324 writeFile($in_file, $buffer);
325
326 ok ! -e $out_file, " Output file does not exist";
327 writeFile($out_file, $already);
328
329 ok &$Func($in_file => $out_file, Append => $append), ' Compressed ok' ;
330
331 ok -e $out_file, " Created output file";
332 my $got = anyUncompress($out_file, $already);
333 $got = undef if ! defined $buffer && $got eq '' ;
334 is $got, $buffer, " Uncompressed matches original";
335
336 }
337
338 {
339 title "$TopType - From Filename to Handle content '$disp_content' Append $append" ;
340
341 my $lex = new LexFile($in_file, $out_file) ;
342 writeFile($in_file, $buffer);
343
344 ok ! -e $out_file, " Output file does not exist";
345 writeFile($out_file, $already);
346 my $out = new IO::File ">>$out_file" ;
347
348 ok &$Func($in_file, $out, AutoClose => 1, Append => $append), ' Compressed ok' ;
349
350 ok -e $out_file, " Created output file";
351 my $got = anyUncompress($out_file, $already);
352 $got = undef if ! defined $buffer && $got eq '' ;
353 is $got, $buffer, " Uncompressed matches original";
354
355 }
356
357 {
358 title "$TopType - From Filename to Buffer content '$disp_content' Append $append" ;
359
360 my $lex = new LexFile($in_file, $out_file) ;
361 writeFile($in_file, $buffer);
362
363 my $out = $already;
364
365 ok &$Func($in_file => \$out, Append => $append), ' Compressed ok' ;
366
367 my $got = anyUncompress(\$out, $already);
368 $got = undef if ! defined $buffer && $got eq '' ;
369 is $got, $buffer, " Uncompressed matches original";
370
371 }
372
373 {
374 title "$TopType - From Handle to Filename content '$disp_content' Append $append" ;
375
376 my $lex = new LexFile($in_file, $out_file) ;
377 writeFile($in_file, $buffer);
378 my $in = new IO::File "<$in_file" ;
379
380 ok ! -e $out_file, " Output file does not exist";
381 writeFile($out_file, $already);
382
383 ok &$Func($in, $out_file, Append => $append), ' Compressed ok'
384 or diag "error is $GzipError" ;
385
386 ok -e $out_file, " Created output file";
387 my $got = anyUncompress($out_file, $already);
388 $got = undef if ! defined $buffer && $got eq '' ;
389 is $buffer, $got, " Uncompressed matches original";
390
391 }
392
393 {
394 title "$TopType - From Handle to Handle content '$disp_content' Append $append" ;
395
396 my $lex = new LexFile($in_file, $out_file) ;
397 writeFile($in_file, $buffer);
398 my $in = new IO::File "<$in_file" ;
399
400 ok ! -e $out_file, " Output file does not exist";
401 writeFile($out_file, $already);
402 my $out = new IO::File ">>$out_file" ;
403
404 ok &$Func($in, $out, AutoClose => 1, Append => $append), ' Compressed ok' ;
405
406 ok -e $out_file, " Created output file";
407 my $got = anyUncompress($out_file, $already);
408 $got = undef if ! defined $buffer && $got eq '' ;
409 is $buffer, $got, " Uncompressed matches original";
410
411 }
412
413 {
414 title "$TopType - From Handle to Buffer content '$disp_content' Append $append" ;
415
416 my $lex = new LexFile($in_file, $out_file) ;
417 writeFile($in_file, $buffer);
418 my $in = new IO::File "<$in_file" ;
419
420 my $out = $already ;
421
422 ok &$Func($in, \$out, Append => $append), ' Compressed ok' ;
423
424 my $got = anyUncompress(\$out, $already);
425 $got = undef if ! defined $buffer && $got eq '' ;
426 is $buffer, $got, " Uncompressed matches original";
427
428 }
429
430 {
431 title "$TopType - From stdin (via '-') to Buffer content '$disp_content' Append $append" ;
432
433 my $lex = new LexFile($in_file, $out_file) ;
434 writeFile($in_file, $buffer);
435
436 open(SAVEIN, "<&STDIN");
437 my $dummy = fileno SAVEIN ;
438 ok open(STDIN, "<$in_file"), " redirect STDIN";
439
440 my $out = $already;
441
442 ok &$Func('-', \$out, Append => $append), ' Compressed ok'
443 or diag $$Error ;
444
445 open(STDIN, "<&SAVEIN");
446
447 my $got = anyUncompress(\$out, $already);
448 $got = undef if ! defined $buffer && $got eq '' ;
449 is $buffer, $got, " Uncompressed matches original";
450
451 }
452
453 }
454 }
455}
456
457foreach my $bit ('IO::Compress::Gzip',
458 'IO::Compress::Deflate',
459 'IO::Compress::RawDeflate',
460 )
461{
462 my $Error = getErrorRef($bit);
463 my $Func = getTopFuncRef($bit);
464 my $TopType = getTopFuncName($bit);
465
466 my $TopTypeInverse = getInverse($bit);
467 my $FuncInverse = getTopFuncRef($TopTypeInverse);
468
469 my ($file1, $file2) = ("file1", "file2");
470 my $lex = new LexFile($file1, $file2) ;
471
472 writeFile($file1, "data1");
473 writeFile($file2, "data2");
474 my $of = new IO::File "<$file1" ;
475 ok $of, " Created output filehandle" ;
476
477 my @input = ( undef, "", $file2, \undef, \'', \"abcde", $of) ;
478 my @expected = ("", "", $file2, "", "", "abcde", "data1");
479 my @uexpected = ("", "", "data2", "", "", "abcde", "data1");
480
481 my @keep = @input ;
482
483 {
484 title "$TopType - From Array Ref to Array Ref" ;
485
486 my @output = ('first') ;
487 ok &$Func(\@input, \@output, AutoClose => 0), ' Compressed ok' ;
488
489 is $output[0], 'first', " Array[0] unchanged";
490
491 is_deeply \@input, \@keep, " Input array not changed" ;
492 my @got = shift @output;
493 foreach (@output) { push @got, anyUncompress($_) }
494
495 is_deeply \@got, ['first', @expected], " Got Expected uncompressed data";
496
497 }
498
499 {
500 title "$TopType - From Array Ref to Buffer" ;
501
502 # rewind the filehandle
503 $of->open("<$file1") ;
504
505 my $output ;
506 ok &$Func(\@input, \$output, AutoClose => 0), ' Compressed ok' ;
507
508 my $got = anyUncompress(\$output);
509
510 is $got, join('', @expected), " Got Expected uncompressed data";
511 }
512
513 {
514 title "$TopType - From Array Ref to Filename" ;
515
516 my ($file3) = ("file3");
517 my $lex = new LexFile($file3) ;
518
519 # rewind the filehandle
520 $of->open("<$file1") ;
521
522 my $output ;
523 ok &$Func(\@input, $file3, AutoClose => 0), ' Compressed ok' ;
524
525 my $got = anyUncompress($file3);
526
527 is $got, join('', @expected), " Got Expected uncompressed data";
528 }
529
530 {
531 title "$TopType - From Array Ref to Filehandle" ;
532
533 my ($file3) = ("file3");
534 my $lex = new LexFile($file3) ;
535
536 my $fh3 = new IO::File ">$file3";
537
538 # rewind the filehandle
539 $of->open("<$file1") ;
540
541 my $output ;
542 ok &$Func(\@input, $fh3, AutoClose => 0), ' Compressed ok' ;
543
544 $fh3->close();
545
546 my $got = anyUncompress($file3);
547
548 is $got, join('', @expected), " Got Expected uncompressed data";
549 }
550}
551
552foreach my $bit ('IO::Compress::Gzip',
553 'IO::Compress::Deflate',
554 'IO::Compress::RawDeflate',
555 )
556{
557 my $Error = getErrorRef($bit);
558 my $Func = getTopFuncRef($bit);
559 my $TopType = getTopFuncName($bit);
560
561 my $TopTypeInverse = getInverse($bit);
562 my $FuncInverse = getTopFuncRef($TopTypeInverse);
563
564 my @inFiles = map { "in$_.tmp" } 1..4;
565 my @outFiles = map { "out$_.tmp" } 1..4;
566 my $lex = new LexFile(@inFiles, @outFiles);
567
568 writeFile($_, "data $_") foreach @inFiles ;
569
570 {
571 title "$TopType - Hash Ref: to filename" ;
572
573 my $output ;
574 ok &$Func( { $inFiles[0] => $outFiles[0],
575 $inFiles[1] => $outFiles[1],
576 $inFiles[2] => $outFiles[2] } ), ' Compressed ok' ;
577
578 foreach (0 .. 2)
579 {
580 my $got = anyUncompress($outFiles[$_]);
581 is $got, "data $inFiles[$_]", " Uncompressed $_ matches original";
582 }
583 }
584
585 {
586 title "$TopType - Hash Ref: to buffer" ;
587
588 my @buffer ;
589 ok &$Func( { $inFiles[0] => \$buffer[0],
590 $inFiles[1] => \$buffer[1],
591 $inFiles[2] => \$buffer[2] } ), ' Compressed ok' ;
592
593 foreach (0 .. 2)
594 {
595 my $got = anyUncompress(\$buffer[$_]);
596 is $got, "data $inFiles[$_]", " Uncompressed $_ matches original";
597 }
598 }
599
600 {
601 title "$TopType - Hash Ref: to undef" ;
602
603 my @buffer ;
604 my %hash = ( $inFiles[0] => undef,
605 $inFiles[1] => undef,
606 $inFiles[2] => undef,
607 );
608
609 ok &$Func( \%hash ), ' Compressed ok' ;
610
611 foreach (keys %hash)
612 {
613 my $got = anyUncompress(\$hash{$_});
614 is $got, "data $_", " Uncompressed $_ matches original";
615 }
616 }
617
618 {
619 title "$TopType - Filename to Hash Ref" ;
620
621 my %output ;
622 ok &$Func( $inFiles[0] => \%output), ' Compressed ok' ;
623
624 is keys %output, 1, " one pair in hash" ;
625 my ($k, $v) = each %output;
626 is $k, $inFiles[0], " key is '$inFiles[0]'";
627 my $got = anyUncompress($v);
628 is $got, "data $inFiles[0]", " Uncompressed matches original";
629 }
630
631 {
632 title "$TopType - File Glob to Hash Ref" ;
633
634 my %output ;
635 ok &$Func( '<in*.tmp>' => \%output), ' Compressed ok' ;
636
637 is keys %output, 4, " four pairs in hash" ;
638 foreach my $fil (@inFiles)
639 {
640 ok exists $output{$fil}, " key '$fil' exists" ;
641 my $got = anyUncompress($output{$fil});
642 is $got, "data $fil", " Uncompressed matches original";
643 }
644 }
645
646
647# if (0)
648# {
649# title "$TopType - Hash Ref to Array Ref" ;
650#
651# my @output = ('first') ;
652# ok &$Func( { \@input, \@output } , AutoClose => 0), ' Compressed ok' ;
653#
654# is $output[0], 'first', " Array[0] unchanged";
655#
656# is_deeply \@input, \@keep, " Input array not changed" ;
657# my @got = shift @output;
658# foreach (@output) { push @got, anyUncompress($_) }
659#
660# is_deeply \@got, ['first', @expected], " Got Expected uncompressed data";
661#
662# }
663#
664# if (0)
665# {
666# title "$TopType - From Array Ref to Buffer" ;
667#
668# # rewind the filehandle
669# $of->open("<$file1") ;
670#
671# my $output ;
672# ok &$Func(\@input, \$output, AutoClose => 0), ' Compressed ok' ;
673#
674# my $got = anyUncompress(\$output);
675#
676# is $got, join('', @expected), " Got Expected uncompressed data";
677# }
678#
679# if (0)
680# {
681# title "$TopType - From Array Ref to Filename" ;
682#
683# my ($file3) = ("file3");
684# my $lex = new LexFile($file3) ;
685#
686# # rewind the filehandle
687# $of->open("<$file1") ;
688#
689# my $output ;
690# ok &$Func(\@input, $file3, AutoClose => 0), ' Compressed ok' ;
691#
692# my $got = anyUncompress($file3);
693#
694# is $got, join('', @expected), " Got Expected uncompressed data";
695# }
696#
697# if (0)
698# {
699# title "$TopType - From Array Ref to Filehandle" ;
700#
701# my ($file3) = ("file3");
702# my $lex = new LexFile($file3) ;
703#
704# my $fh3 = new IO::File ">$file3";
705#
706# # rewind the filehandle
707# $of->open("<$file1") ;
708#
709# my $output ;
710# ok &$Func(\@input, $fh3, AutoClose => 0), ' Compressed ok' ;
711#
712# $fh3->close();
713#
714# my $got = anyUncompress($file3);
715#
716# is $got, join('', @expected), " Got Expected uncompressed data";
717# }
718}
719
720foreach my $bit ('IO::Compress::Gzip',
721 'IO::Compress::Deflate',
722 'IO::Compress::RawDeflate',
723 )
724{
725 my $Error = getErrorRef($bit);
726 my $Func = getTopFuncRef($bit);
727 my $TopType = getTopFuncName($bit);
728
729 for my $files ( [qw(a1)], [qw(a1 a2 a3)] )
730 {
731
732 my $tmpDir1 = 'tmpdir1';
733 my $tmpDir2 = 'tmpdir2';
734 my $lex = new LexDir($tmpDir1, $tmpDir2) ;
735
736 mkdir $tmpDir1, 0777;
737 mkdir $tmpDir2, 0777;
738
739 ok -d $tmpDir1, " Temp Directory $tmpDir1 exists";
740 #ok ! -d $tmpDir2, " Temp Directory $tmpDir2 does not exist";
741
742 my @files = map { "$tmpDir1/$_.tmp" } @$files ;
743 foreach (@files) { writeFile($_, "abc $_") }
744
745 my @expected = map { "abc $_" } @files ;
746 my @outFiles = map { s/$tmpDir1/$tmpDir2/; $_ } @files ;
747
748 {
749 title "$TopType - From FileGlob to FileGlob files [@$files]" ;
750
751 ok &$Func("<$tmpDir1/a*.tmp>" => "<$tmpDir2/a#1.tmp>"), ' Compressed ok'
752 or diag $$Error ;
753
754 my @copy = @expected;
755 for my $file (@outFiles)
756 {
757 is anyUncompress($file), shift @copy, " got expected from $file" ;
758 }
759
760 is @copy, 0, " got all files";
761 }
762
763 {
764 title "$TopType - From FileGlob to Array files [@$files]" ;
765
766 my @buffer = ('first') ;
767 ok &$Func("<$tmpDir1/a*.tmp>" => \@buffer), ' Compressed ok'
768 or diag $$Error ;
769
770 is shift @buffer, 'first';
771
772 my @copy = @expected;
773 for my $buffer (@buffer)
774 {
775 is anyUncompress($buffer), shift @copy, " got expected " ;
776 }
777
778 is @copy, 0, " got all files";
779 }
780
781 {
782 title "$TopType - From FileGlob to Buffer files [@$files]" ;
783
784 my $buffer ;
785 ok &$Func("<$tmpDir1/a*.tmp>" => \$buffer), ' Compressed ok'
786 or diag $$Error ;
787
788 #hexDump(\$buffer);
789
790 my $got = anyUncompress([ \$buffer, MultiStream => 1 ]);
791
792 is $got, join("", @expected), " got expected" ;
793 }
794
795 {
796 title "$TopType - From FileGlob to Filename files [@$files]" ;
797
798 my $filename = "abcde";
799 my $lex = new LexFile($filename) ;
800
801 ok &$Func("<$tmpDir1/a*.tmp>" => $filename), ' Compressed ok'
802 or diag $$Error ;
803
804 #hexDump(\$buffer);
805
806 my $got = anyUncompress([$filename, MultiStream => 1]);
807
808 is $got, join("", @expected), " got expected" ;
809 }
810
811 {
812 title "$TopType - From FileGlob to Filehandle files [@$files]" ;
813
814 my $filename = "abcde";
815 my $lex = new LexFile($filename) ;
816 my $fh = new IO::File ">$filename";
817
818 ok &$Func("<$tmpDir1/a*.tmp>" => $fh, AutoClose => 1), ' Compressed ok'
819 or diag $$Error ;
820
821 #hexDump(\$buffer);
822
823 my $got = anyUncompress([$filename, MultiStream => 1]);
824
825 is $got, join("", @expected), " got expected" ;
826 }
827 }
828
829}
830
831foreach my $bit ('IO::Uncompress::Gunzip',
832 'IO::Uncompress::Inflate',
833 'IO::Uncompress::RawInflate',
834 'IO::Uncompress::AnyInflate',
835 )
836{
837 my $Error = getErrorRef($bit);
838 my $Func = getTopFuncRef($bit);
839 my $TopType = getTopFuncName($bit);
840
841 my $buffer = "abcde" ;
842 my $buffer2 = "ABCDE" ;
843 my $keep_orig = $buffer;
844
845 my $comp = compressBuffer($TopType, $buffer) ;
846 my $comp2 = compressBuffer($TopType, $buffer2) ;
847 my $keep_comp = $comp;
848
849 my $incumbent = "incumbent data" ;
850
851 for my $append (0, 1)
852 {
853 my $expected = $buffer ;
854 $expected = $incumbent . $buffer if $append ;
855
856 {
857 title "$TopType - From Buff to Buff, Append($append)" ;
858
859 my $output ;
860 $output = $incumbent if $append ;
861 ok &$Func(\$comp, \$output, Append => $append), ' Uncompressed ok' ;
862
863 is $keep_comp, $comp, " Input buffer not changed" ;
864 is $output, $expected, " Uncompressed matches original";
865 }
866
867 {
868 title "$TopType - From Buff to Array, Append($append)" ;
869
870 my @output = ('first');
871 #$output = $incumbent if $append ;
872 ok &$Func(\$comp, \@output, Append => $append), ' Uncompressed ok' ;
873
874 is $keep_comp, $comp, " Input buffer not changed" ;
875 is $output[0], 'first', " Uncompressed matches original";
876 is ${ $output[1] }, $buffer, " Uncompressed matches original"
877 or diag $output[1] ;
878 is @output, 2, " only 2 elements in the array" ;
879 }
880
881 {
882 title "$TopType - From Buff to Filename, Append($append)" ;
883
884 my $out_file = "abcde";
885 my $lex = new LexFile($out_file) ;
886 if ($append)
887 { writeFile($out_file, $incumbent) }
888 else
889 { ok ! -e $out_file, " Output file does not exist" }
890
891 ok &$Func(\$comp, $out_file, Append => $append), ' Uncompressed ok' ;
892
893 ok -e $out_file, " Created output file";
894 my $content = readFile($out_file) ;
895
896 is $keep_comp, $comp, " Input buffer not changed" ;
897 is $content, $expected, " Uncompressed matches original";
898 }
899
900 {
901 title "$TopType - From Buff to Handle, Append($append)" ;
902
903 my $out_file = "abcde";
904 my $lex = new LexFile($out_file) ;
905 my $of ;
906 if ($append) {
907 writeFile($out_file, $incumbent) ;
908 $of = new IO::File "+< $out_file" ;
909 }
910 else {
911 ok ! -e $out_file, " Output file does not exist" ;
912 $of = new IO::File "> $out_file" ;
913 }
914 isa_ok $of, 'IO::File', ' $of' ;
915
916 ok &$Func(\$comp, $of, Append => $append, AutoClose => 1), ' Uncompressed ok' ;
917
918 ok -e $out_file, " Created output file";
919 my $content = readFile($out_file) ;
920
921 is $keep_comp, $comp, " Input buffer not changed" ;
922 is $content, $expected, " Uncompressed matches original";
923 }
924
925 {
926 title "$TopType - From Filename to Filename, Append($append)" ;
927
928 my $out_file = "abcde.out";
929 my $in_file = "abcde.in";
930 my $lex = new LexFile($in_file, $out_file) ;
931 if ($append)
932 { writeFile($out_file, $incumbent) }
933 else
934 { ok ! -e $out_file, " Output file does not exist" }
935
936 writeFile($in_file, $comp);
937
938 ok &$Func($in_file, $out_file, Append => $append), ' Uncompressed ok' ;
939
940 ok -e $out_file, " Created output file";
941 my $content = readFile($out_file) ;
942
943 is $keep_comp, $comp, " Input buffer not changed" ;
944 is $content, $expected, " Uncompressed matches original";
945 }
946
947 {
948 title "$TopType - From Filename to Handle, Append($append)" ;
949
950 my $out_file = "abcde.out";
951 my $in_file = "abcde.in";
952 my $lex = new LexFile($in_file, $out_file) ;
953 my $out ;
954 if ($append) {
955 writeFile($out_file, $incumbent) ;
956 $out = new IO::File "+< $out_file" ;
957 }
958 else {
959 ok ! -e $out_file, " Output file does not exist" ;
960 $out = new IO::File "> $out_file" ;
961 }
962 isa_ok $out, 'IO::File', ' $out' ;
963
964 writeFile($in_file, $comp);
965
966 ok &$Func($in_file, $out, Append => $append, AutoClose => 1), ' Uncompressed ok' ;
967
968 ok -e $out_file, " Created output file";
969 my $content = readFile($out_file) ;
970
971 is $keep_comp, $comp, " Input buffer not changed" ;
972 is $content, $expected, " Uncompressed matches original";
973 }
974
975 {
976 title "$TopType - From Filename to Buffer, Append($append)" ;
977
978 my $in_file = "abcde.in";
979 my $lex = new LexFile($in_file) ;
980 writeFile($in_file, $comp);
981
982 my $output ;
983 $output = $incumbent if $append ;
984
985 ok &$Func($in_file, \$output, Append => $append), ' Uncompressed ok' ;
986
987 is $keep_comp, $comp, " Input buffer not changed" ;
988 is $output, $expected, " Uncompressed matches original";
989 }
990
991 {
992 title "$TopType - From Handle to Filename, Append($append)" ;
993
994 my $out_file = "abcde.out";
995 my $in_file = "abcde.in";
996 my $lex = new LexFile($in_file, $out_file) ;
997 if ($append)
998 { writeFile($out_file, $incumbent) }
999 else
1000 { ok ! -e $out_file, " Output file does not exist" }
1001
1002 writeFile($in_file, $comp);
1003 my $in = new IO::File "<$in_file" ;
1004
1005 ok &$Func($in, $out_file, Append => $append), ' Uncompressed ok' ;
1006
1007 ok -e $out_file, " Created output file";
1008 my $content = readFile($out_file) ;
1009
1010 is $keep_comp, $comp, " Input buffer not changed" ;
1011 is $content, $expected, " Uncompressed matches original";
1012 }
1013
1014 {
1015 title "$TopType - From Handle to Handle, Append($append)" ;
1016
1017 my $out_file = "abcde.out";
1018 my $in_file = "abcde.in";
1019 my $lex = new LexFile($in_file, $out_file) ;
1020 my $out ;
1021 if ($append) {
1022 writeFile($out_file, $incumbent) ;
1023 $out = new IO::File "+< $out_file" ;
1024 }
1025 else {
1026 ok ! -e $out_file, " Output file does not exist" ;
1027 $out = new IO::File "> $out_file" ;
1028 }
1029 isa_ok $out, 'IO::File', ' $out' ;
1030
1031 writeFile($in_file, $comp);
1032 my $in = new IO::File "<$in_file" ;
1033
1034 ok &$Func($in, $out, Append => $append, AutoClose => 1), ' Uncompressed ok' ;
1035
1036 ok -e $out_file, " Created output file";
1037 my $content = readFile($out_file) ;
1038
1039 is $keep_comp, $comp, " Input buffer not changed" ;
1040 is $content, $expected, " Uncompressed matches original";
1041 }
1042
1043 {
1044 title "$TopType - From Filename to Buffer, Append($append)" ;
1045
1046 my $in_file = "abcde.in";
1047 my $lex = new LexFile($in_file) ;
1048 writeFile($in_file, $comp);
1049 my $in = new IO::File "<$in_file" ;
1050
1051 my $output ;
1052 $output = $incumbent if $append ;
1053
1054 ok &$Func($in, \$output, Append => $append), ' Uncompressed ok' ;
1055
1056 is $keep_comp, $comp, " Input buffer not changed" ;
1057 is $output, $expected, " Uncompressed matches original";
1058 }
1059
1060 {
1061 title "$TopType - From stdin (via '-') to Buffer content, Append($append) " ;
1062
1063 my $in_file = "abcde.in";
1064 my $lex = new LexFile($in_file) ;
1065 writeFile($in_file, $comp);
1066
1067 ok open(SAVEIN, "<&STDIN"), " save STDIN";
1068 my $dummy = fileno SAVEIN ;
1069 ok open(STDIN, "<$in_file"), " redirect STDIN";
1070
1071 my $output ;
1072 $output = $incumbent if $append ;
1073
1074 ok &$Func('-', \$output, Append => $append), ' Uncompressed ok'
1075 or diag $$Error ;
1076
1077 ok open(STDIN, "<&SAVEIN"), " put STDIN back";
1078
1079 is $keep_comp, $comp, " Input buffer not changed" ;
1080 is $output, $expected, " Uncompressed matches original";
1081 }
1082 }
1083
1084 {
1085 title "$TopType - From Handle to Buffer, InputLength" ;
1086
1087 my $out_file = "abcde.out";
1088 my $in_file = "abcde.in";
1089 my $lex = new LexFile($in_file, $out_file) ;
1090 my $out ;
1091
1092 my $expected = $buffer ;
1093 my $appended = 'appended';
1094 my $len_appended = length $appended;
1095 writeFile($in_file, $comp . $appended . $comp . $appended) ;
1096 my $in = new IO::File "<$in_file" ;
1097
1098 ok &$Func($in, \$out, Transparent => 0, InputLength => length $comp), ' Uncompressed ok' ;
1099
1100 is $out, $expected, " Uncompressed matches original";
1101
1102 my $buff;
1103 is $in->read($buff, $len_appended), $len_appended, " Length of Appended data ok";
1104 is $buff, $appended, " Appended data ok";
1105
1106 $out = '';
1107 ok &$Func($in, \$out, Transparent => 0, InputLength => length $comp), ' Uncompressed ok' ;
1108
1109 is $out, $expected, " Uncompressed matches original";
1110
1111 $buff = '';
1112 is $in->read($buff, $len_appended), $len_appended, " Length of Appended data ok";
1113 is $buff, $appended, " Appended data ok";
1114 }
1115
1116 for my $stdin ('-', *STDIN) # , \*STDIN)
1117 {
1118 title "$TopType - From stdin (via $stdin) to Buffer content, InputLength" ;
1119
1120 my $in_file = "abcde.in";
1121 my $lex = new LexFile($in_file) ;
1122 my $expected = $buffer ;
1123 my $appended = 'appended';
1124 my $len_appended = length $appended;
1125 writeFile($in_file, $comp . $appended . $comp . $appended) ;
1126
1127 ok open(SAVEIN, "<&STDIN"), " save STDIN";
1128 my $dummy = fileno SAVEIN ;
1129 ok open(STDIN, "<$in_file"), " redirect STDIN";
1130
1131 my $output ;
1132
1133 ok &$Func($stdin, \$output, Transparent => 0, InputLength => length $comp), ' Uncompressed ok'
1134 or diag $$Error ;
1135
1136 my $buff ;
1137 is read(STDIN, $buff, $len_appended), $len_appended, " Length of Appended data ok";
1138
1139 is $output, $expected, " Uncompressed matches original";
1140 is $buff, $appended, " Appended data ok";
1141
1142 $output = '';
1143 ok &$Func($stdin, \$output, Transparent => 0, InputLength => length $comp), ' Uncompressed ok'
1144 or diag $$Error ;
1145
1146 $buff = '';
1147 is read(STDIN, $buff, $len_appended), $len_appended, " Length of Appended data ok"
1148 or diag "read failed $!";
1149
1150 is $output, $expected, " Uncompressed matches original";
1151 is $buff, $appended, " Appended data ok";
1152
1153 ok open(STDIN, "<&SAVEIN"), " put STDIN back";
1154 }
1155}
1156
1157foreach my $bit ('IO::Uncompress::Gunzip',
1158 'IO::Uncompress::Inflate',
1159 'IO::Uncompress::RawInflate',
1160 'IO::Uncompress::AnyInflate',
1161 )
1162{
1163 # TODO -- Add Append mode tests
1164
1165 my $Error = getErrorRef($bit);
1166 my $Func = getTopFuncRef($bit);
1167 my $TopType = getTopFuncName($bit);
1168
1169 my $buffer = "abcde" ;
1170 my $keep_orig = $buffer;
1171
1172
1173 my $null = compressBuffer($TopType, "") ;
1174 my $undef = compressBuffer($TopType, undef) ;
1175 my $comp = compressBuffer($TopType, $buffer) ;
1176 my $keep_comp = $comp;
1177
1178 my $incumbent = "incumbent data" ;
1179
1180 my ($file1, $file2) = ("file1", "file2");
1181 my $lex = new LexFile($file1, $file2) ;
1182
1183 writeFile($file1, compressBuffer($TopType,"data1"));
1184 writeFile($file2, compressBuffer($TopType,"data2"));
1185
1186 my $of = new IO::File "<$file1" ;
1187 ok $of, " Created output filehandle" ;
1188
1189 my @input = ($file2, \$undef, \$null, \$comp, $of) ;
1190 my @expected = ('data2', '', '', 'abcde', 'data1');
1191
1192 my @keep = @input ;
1193
1194 {
1195 title "$TopType - From ArrayRef to Buffer" ;
1196
1197 my $output ;
1198 ok &$Func(\@input, \$output, AutoClose => 0), ' UnCompressed ok' ;
1199
1200 is $output, join('', @expected)
1201 }
1202
1203 {
1204 title "$TopType - From ArrayRef to Filename" ;
1205
1206 my $output = 'abc';
1207 my $lex = new LexFile $output;
1208 $of->open("<$file1") ;
1209
1210 ok &$Func(\@input, $output, AutoClose => 0), ' UnCompressed ok' ;
1211
1212 is readFile($output), join('', @expected)
1213 }
1214
1215 {
1216 title "$TopType - From ArrayRef to Filehandle" ;
1217
1218 my $output = 'abc';
1219 my $lex = new LexFile $output;
1220 my $fh = new IO::File ">$output" ;
1221 $of->open("<$file1") ;
1222
1223 ok &$Func(\@input, $fh, AutoClose => 0), ' UnCompressed ok' ;
1224 $fh->close;
1225
1226 is readFile($output), join('', @expected)
1227 }
1228
1229 {
1230 title "$TopType - From Array Ref to Array Ref" ;
1231
1232 my @output = (\'first') ;
1233 $of->open("<$file1") ;
1234 ok &$Func(\@input, \@output, AutoClose => 0), ' UnCompressed ok' ;
1235
1236 is_deeply \@input, \@keep, " Input array not changed" ;
1237 is_deeply [map { defined $$_ ? $$_ : "" } @output],
1238 ['first', @expected],
1239 " Got Expected uncompressed data";
1240
1241 }
1242}
1243
1244foreach my $bit ('IO::Uncompress::Gunzip',
1245 'IO::Uncompress::Inflate',
1246 'IO::Uncompress::RawInflate',
1247 'IO::Uncompress::AnyInflate',
1248 )
1249{
1250 # TODO -- Add Append mode tests
1251
1252 my $Error = getErrorRef($bit);
1253 my $Func = getTopFuncRef($bit);
1254 my $TopType = getTopFuncName($bit);
1255
1256 my $tmpDir1 = 'tmpdir1';
1257 my $tmpDir2 = 'tmpdir2';
1258 my $lex = new LexDir($tmpDir1, $tmpDir2) ;
1259
1260 mkdir $tmpDir1, 0777;
1261 mkdir $tmpDir2, 0777;
1262
1263 ok -d $tmpDir1, " Temp Directory $tmpDir1 exists";
1264 #ok ! -d $tmpDir2, " Temp Directory $tmpDir2 does not exist";
1265
1266 my @files = map { "$tmpDir1/$_.tmp" } qw( a1 a2 a3) ;
1267 foreach (@files) { writeFile($_, compressBuffer($TopType, "abc $_")) }
1268
1269 my @expected = map { "abc $_" } @files ;
1270 my @outFiles = map { s/$tmpDir1/$tmpDir2/; $_ } @files ;
1271
1272 {
1273 title "$TopType - From FileGlob to FileGlob" ;
1274
1275 ok &$Func("<$tmpDir1/a*.tmp>" => "<$tmpDir2/a#1.tmp>"), ' UnCompressed ok'
1276 or diag $$Error ;
1277
1278 my @copy = @expected;
1279 for my $file (@outFiles)
1280 {
1281 is readFile($file), shift @copy, " got expected from $file" ;
1282 }
1283
1284 is @copy, 0, " got all files";
1285 }
1286
1287 {
1288 title "$TopType - From FileGlob to Arrayref" ;
1289
1290 my @output = (\'first');
1291 ok &$Func("<$tmpDir1/a*.tmp>" => \@output), ' UnCompressed ok'
1292 or diag $$Error ;
1293
1294 my @copy = ('first', @expected);
1295 for my $data (@output)
1296 {
1297 is $$data, shift @copy, " got expected data" ;
1298 }
1299
1300 is @copy, 0, " got all files";
1301 }
1302
1303 {
1304 title "$TopType - From FileGlob to Buffer" ;
1305
1306 my $output ;
1307 ok &$Func("<$tmpDir1/a*.tmp>" => \$output), ' UnCompressed ok'
1308 or diag $$Error ;
1309
1310 is $output, join('', @expected), " got expected uncompressed data";
1311 }
1312
1313 {
1314 title "$TopType - From FileGlob to Filename" ;
1315
1316 my $output = 'abc' ;
1317 my $lex = new LexFile $output ;
1318 ok ! -e $output, " $output does not exist" ;
1319 ok &$Func("<$tmpDir1/a*.tmp>" => $output), ' UnCompressed ok'
1320 or diag $$Error ;
1321
1322 ok -e $output, " $output does exist" ;
1323 is readFile($output), join('', @expected), " got expected uncompressed data";
1324 }
1325
1326 {
1327 title "$TopType - From FileGlob to Filehandle" ;
1328
1329 my $output = 'abc' ;
1330 my $lex = new LexFile $output ;
1331 my $fh = new IO::File ">$output" ;
1332 ok &$Func("<$tmpDir1/a*.tmp>" => $fh, AutoClose => 1), ' UnCompressed ok'
1333 or diag $$Error ;
1334
1335 ok -e $output, " $output does exist" ;
1336 is readFile($output), join('', @expected), " got expected uncompressed data";
1337 }
1338
1339}
1340
1341foreach my $TopType ('IO::Compress::Gzip::gzip',
1342 'IO::Compress::Deflate',
1343 'IO::Compress::RawDeflate',
1344 # TODO -- add the inflate classes
1345 )
1346{
1347 my $Error = getErrorRef($TopType);
1348 my $Func = getTopFuncRef($TopType);
1349 my $Name = getTopFuncName($TopType);
1350
1351 title "More write tests" ;
1352
1353 my $file1 = "file1" ;
1354 my $file2 = "file2" ;
1355 my $file3 = "file3" ;
1356 my $lex = new LexFile $file1, $file2, $file3 ;
1357
1358 writeFile($file1, "F1");
1359 writeFile($file2, "F2");
1360 writeFile($file3, "F3");
1361
1362 my @data = (
1363 [ '[]', "" ],
1364 [ '[\""]', "" ],
1365 [ '[\undef]', "" ],
1366 [ '[\"abcd"]', "abcd" ],
1367 [ '[\"ab", \"cd"]', "abcd" ],
1368
1369 [ '$fh2', "F2" ],
1370 [ '[\"a", $fh1, \"bc"]', "aF1bc"],
1371 ) ;
1372
1373
1374 foreach my $data (@data)
1375 {
1376 my ($send, $get) = @$data ;
1377
1378 my $fh1 = new IO::File "< $file1" ;
1379 my $fh2 = new IO::File "< $file2" ;
1380 my $fh3 = new IO::File "< $file3" ;
1381
1382 title "$send";
1383 my $copy;
1384 eval "\$copy = $send";
1385 my $Answer ;
1386 ok &$Func($copy, \$Answer), " $Name ok";
1387
1388 my $got = anyUncompress(\$Answer);
1389 is $got, $get, " got expected output" ;
1390 cmp_ok $$Error, '==', 0, " no error";
1391
1392
1393 }
1394
1395 title "Array Input Error tests" ;
1396
1397 @data = (
1398 '[[]]',
1399 '[[[]]]',
1400 '[[\"ab"], [\"cd"]]',
1401 ) ;
1402
1403
1404 foreach my $send (@data)
1405 {
1406 my $fh1 = new IO::File "< $file1" ;
1407 my $fh2 = new IO::File "< $file2" ;
1408 my $fh3 = new IO::File "< $file3" ;
1409
1410 title "$send";
1411 my $copy;
1412 eval "\$copy = $send";
1413 my $Answer ;
1414 ok ! &$Func($copy, \$Answer), " $Name fails";
1415
1416 is $$Error, "unknown input parameter", " got error message";
1417
1418 }
1419}
1420
1421sub gzipGetHeader
1422{
1423 my $in = shift;
1424 my $content = shift ;
1425 my %opts = @_ ;
1426
1427 my $out ;
1428 my $got ;
1429
1430 ok IO::Compress::Gzip::gzip($in, \$out, %opts), " gzip ok" ;
1431 ok IO::Uncompress::Gunzip::gunzip(\$out, \$got), " gunzip ok"
1432 or diag $GunzipError ;
1433 is $got, $content, " got expected content" ;
1434
1435 my $gunz = new IO::Uncompress::Gunzip \$out, Strict => 0
1436 or diag "GunzipError is $IO::Uncompress::Gunzip::GunzipError" ;
1437 ok $gunz, " Created IO::Uncompress::Gunzip object";
1438 my $hdr = $gunz->getHeaderInfo();
1439 ok $hdr, " got Header info";
1440 my $uncomp ;
1441 ok $gunz->read($uncomp), " read ok" ;
1442 is $uncomp, $content, " got expected content";
1443 ok $gunz->close, " closed ok" ;
1444
1445 return $hdr ;
1446
1447}
1448
1449{
1450 title "Check gzip header default NAME & MTIME settings" ;
1451
1452 my $file1 = "file1" ;
1453 my $lex = new LexFile $file1;
1454
1455 my $content = "hello ";
1456 my $hdr ;
1457 my $mtime ;
1458
1459 writeFile($file1, $content);
1460 $mtime = (stat($file1))[8];
1461 # make sure that the gzip file isn't created in the same
1462 # second as the input file
1463 sleep 3 ;
1464 $hdr = gzipGetHeader($file1, $content);
1465
1466 is $hdr->{Name}, $file1, " Name is '$file1'";
1467 is $hdr->{Time}, $mtime, " Time is ok";
1468
1469 title "Override Name" ;
1470
1471 writeFile($file1, $content);
1472 $mtime = (stat($file1))[8];
1473 sleep 3 ;
1474 $hdr = gzipGetHeader($file1, $content, Name => "abcde");
1475
1476 is $hdr->{Name}, "abcde", " Name is 'abcde'" ;
1477 is $hdr->{Time}, $mtime, " Time is ok";
1478
1479 title "Override Time" ;
1480
1481 writeFile($file1, $content);
1482 $hdr = gzipGetHeader($file1, $content, Time => 1234);
1483
1484 is $hdr->{Name}, $file1, " Name is '$file1'" ;
1485 is $hdr->{Time}, 1234, " Time is 1234";
1486
1487 title "Override Name and Time" ;
1488
1489 writeFile($file1, $content);
1490 $hdr = gzipGetHeader($file1, $content, Time => 4321, Name => "abcde");
1491
1492 is $hdr->{Name}, "abcde", " Name is 'abcde'" ;
1493 is $hdr->{Time}, 4321, " Time is 4321";
1494
1495 title "Filehandle doesn't have default Name or Time" ;
1496 my $fh = new IO::File "< $file1"
1497 or diag "Cannot open '$file1': $!\n" ;
1498 sleep 3 ;
1499 my $before = time ;
1500 $hdr = gzipGetHeader($fh, $content);
1501 my $after = time ;
1502
1503 ok ! defined $hdr->{Name}, " Name is undef";
1504 cmp_ok $hdr->{Time}, '>=', $before, " Time is ok";
1505 cmp_ok $hdr->{Time}, '<=', $after, " Time is ok";
1506
1507 $fh->close;
1508
1509 title "Buffer doesn't have default Name or Time" ;
1510 my $buffer = $content;
1511 $before = time ;
1512 $hdr = gzipGetHeader(\$buffer, $content);
1513 $after = time ;
1514
1515 ok ! defined $hdr->{Name}, " Name is undef";
1516 cmp_ok $hdr->{Time}, '>=', $before, " Time is ok";
1517 cmp_ok $hdr->{Time}, '<=', $after, " Time is ok";
1518}
1519
1520# TODO add more error cases
1521
Unnamed repository; edit this file to name it for gitweb.