18 # use Test::NoWarnings, if available
21 if eval { require Test::NoWarnings ; import Test::NoWarnings; 1 };
23 plan tests => 208 + $extra ;
25 use_ok('Compress::Zlib', 2) ;
26 use_ok('Compress::Gzip::Constants') ;
28 use_ok('IO::Compress::Gzip', qw($GzipError)) ;
37 my $len = length $hello ;
39 # Check zlib_version and ZLIB_VERSION are the same.
40 is Compress::Zlib::zlib_version, ZLIB_VERSION,
41 "ZLIB_VERSION matches Compress::Zlib::zlib_version" ;
46 my $name = "test.gz" ;
49 ok my $fil = gzopen($name, "wb") ;
51 is $gzerrno, 0, 'gzerrno is 0';
52 is $fil->gzerror(), 0, "gzerror() returned 0";
54 is $fil->gztell(), 0, "gztell returned 0";
55 is $gzerrno, 0, 'gzerrno is 0';
57 is $fil->gzwrite($hello), $len ;
58 is $gzerrno, 0, 'gzerrno is 0';
60 is $fil->gztell(), $len, "gztell returned $len";
61 is $gzerrno, 0, 'gzerrno is 0';
65 ok $fil = gzopen($name, "rb") ;
68 is $gzerrno, 0, 'gzerrno is 0';
71 is $fil->gzread($uncomp), $len;
73 is $fil->gztell(), $len;
80 ok $hello eq $uncomp ;
82 # check that a number can be gzipped
86 ok $fil = gzopen($name, "wb") ;
90 is $fil->gzwrite($number), $num_len, "gzwrite returned $num_len" ;
91 is $gzerrno, 0, 'gzerrno is 0';
92 ok $fil->gzflush(Z_FINISH) ;
94 is $gzerrno, 0, 'gzerrno is 0';
98 cmp_ok $gzerrno, '==', 0;
100 ok $fil = gzopen($name, "rb") ;
102 ok (($x = $fil->gzread($uncomp)) == $num_len) ;
104 ok $fil->gzerror() == 0 || $fil->gzerror() == Z_STREAM_END;
105 ok $gzerrno == 0 || $gzerrno == Z_STREAM_END;
112 or print "# gzerrno is $gzerrno\n" ;
116 ok $number == $uncomp ;
117 ok $number eq $uncomp ;
120 # now a bigger gzip test
123 my $file = "$text.gz" ;
125 ok my $f = gzopen($file, "wb") ;
127 # generate a long random string
130 { $contents .= chr int rand 256 }
132 $len = length $contents ;
134 ok $f->gzwrite($contents) == $len ;
138 ok $f = gzopen($file, "rb") ;
143 is $f->gzread($uncompressed, $len), $len ;
145 ok $contents eq $uncompressed
147 or print "# Length orig $len" .
148 ", Length uncompressed " . length($uncompressed) . "\n" ;
155 # gzip - readline tests
156 # ======================
158 # first create a small gzipped text file
160 my @text = (<<EOM, <<EOM, <<EOM, <<EOM) ;
165 the line after the previous line
170 $text = join("", @text) ;
172 ok $fil = gzopen($name, "wb") ;
173 ok $fil->gzwrite($text) == length $text ;
176 # now try to read it back in
177 ok $fil = gzopen($name, "rb") ;
180 for my $i (0 .. @text -2)
182 ok $fil->gzreadline($line) > 0;
183 ok $line eq $text[$i] ;
187 # now read the last line
188 ok $fil->gzreadline($line) > 0;
189 ok $line eq $text[-1] ;
193 is $fil->gzreadline($line), 0;
200 # a text file with a very long line (bigger than the internal buffer)
201 my $line1 = ("abcdefghijklmnopq" x 2000) . "\n" ;
202 my $line2 = "second line\n" ;
203 $text = $line1 . $line2 ;
204 ok $fil = gzopen($name, "wb") ;
205 ok $fil->gzwrite($text) == length $text ;
208 # now try to read it back in
209 ok $fil = gzopen($name, "rb") ;
213 while ($fil->gzreadline($line) > 0) {
218 ok $got[0] eq $line1 ;
219 ok $got[1] eq $line2 ;
227 # a text file which is not termined by an EOL
229 $line1 = "hello hello, I'm back again\n" ;
230 $line2 = "there is no end in sight" ;
232 $text = $line1 . $line2 ;
233 ok $fil = gzopen($name, "wb") ;
234 ok $fil->gzwrite($text) == length $text ;
237 # now try to read it back in
238 ok $fil = gzopen($name, "rb") ;
240 while ($fil->gzreadline($line) > 0) {
245 ok $got[0] eq $line1 ;
246 ok $got[1] eq $line2 ;
255 title 'mix gzread and gzreadline';
257 # case 1: read a line, then a block. The block is
258 # smaller than the internal block used by
260 my $name = "test.gz" ;
261 my $lex = new LexFile $name ;
262 $line1 = "hello hello, I'm back again\n" ;
263 $line2 = "abc" x 200 ;
264 my $line3 = "def" x 200 ;
266 $text = $line1 . $line2 . $line3 ;
267 ok $fil = gzopen($name, "wb"), ' gzopen for write ok' ;
268 is $fil->gzwrite($text), length $text, ' gzwrite ok' ;
269 is $fil->gztell(), length $text, ' gztell ok' ;
270 ok ! $fil->gzclose, ' gzclose ok' ;
272 # now try to read it back in
273 ok $fil = gzopen($name, "rb"), ' gzopen for read ok' ;
274 ok ! $fil->gzeof(), ' !gzeof' ;
275 cmp_ok $fil->gzreadline($line), '>', 0, ' gzreadline' ;
276 is $fil->gztell(), length $line1, ' gztell ok' ;
277 ok ! $fil->gzeof(), ' !gzeof' ;
278 is $line, $line1, ' got expected line' ;
279 cmp_ok $fil->gzread($line, length $line2), '>', 0, ' gzread ok' ;
280 is $fil->gztell(), length($line1)+length($line2), ' gztell ok' ;
281 ok ! $fil->gzeof(), ' !gzeof' ;
282 is $line, $line2, ' read expected block' ;
283 cmp_ok $fil->gzread($line, length $line3), '>', 0, ' gzread ok' ;
284 is $fil->gztell(), length($text), ' gztell ok' ;
285 ok $fil->gzeof(), ' !gzeof' ;
286 is $line, $line3, ' read expected block' ;
287 ok ! $fil->gzclose, ' gzclose' ;
291 title "Pass gzopen a filehandle - use IO::File" ;
293 my $name = "test.gz" ;
294 my $lex = new LexFile $name ;
296 my $hello = "hello" ;
297 my $len = length $hello ;
301 my $f = new IO::File ">$name" ;
304 ok my $fil = gzopen($f, "wb") ;
306 ok $fil->gzwrite($hello) == $len ;
310 $f = new IO::File "<$name" ;
311 ok $fil = gzopen($name, "rb") ;
314 ok (($x = $fil->gzread($uncomp)) == $len)
315 or print "# length $x, expected $len\n" ;
323 ok $hello eq $uncomp ;
330 title "Pass gzopen a filehandle - use open" ;
332 my $name = "test.gz" ;
333 my $lex = new LexFile $name ;
335 my $hello = "hello" ;
336 my $len = length $hello ;
342 ok my $fil = gzopen(*F, "wb") ;
344 is $fil->gzwrite($hello), $len ;
349 ok $fil = gzopen(*F, "rb") ;
352 $x = $fil->gzread($uncomp);
361 ok $hello eq $uncomp ;
366 foreach my $stdio ( ['-', '-'], [*STDIN, *STDOUT])
368 my $stdin = $stdio->[0];
369 my $stdout = $stdio->[1];
371 title "Pass gzopen a filehandle - use $stdin" ;
373 my $name = "test.gz" ;
374 my $lex = new LexFile $name ;
376 my $hello = "hello" ;
377 my $len = length $hello ;
381 ok open(SAVEOUT, ">&STDOUT"), " save STDOUT";
382 my $dummy = fileno SAVEOUT;
383 ok open(STDOUT, ">$name"), " redirect STDOUT" ;
387 my $fil = gzopen($stdout, "wb") ;
390 ($fil->gzwrite($hello) == $len) &&
391 ($fil->gzclose == 0) ;
393 open(STDOUT, ">&SAVEOUT");
395 ok $status, " wrote to stdout";
397 open(SAVEIN, "<&STDIN");
398 ok open(STDIN, "<$name"), " redirect STDIN";
399 $dummy = fileno SAVEIN;
401 ok $fil = gzopen($stdin, "rb") ;
404 ok (($x = $fil->gzread($uncomp)) == $len)
405 or print "# length $x, expected $len\n" ;
411 open(STDIN, "<&SAVEIN");
415 ok $hello eq $uncomp ;
421 title 'test parameters for gzopen';
422 my $name = "test.gz" ;
423 my $lex = new LexFile $name ;
430 eval ' $fil = gzopen() ' ;
431 like $@, mkEvalErr('Not enough arguments for Compress::Zlib::gzopen'),
432 ' gzopen with missing mode fails' ;
435 $fil = gzopen($name, "xy") ;
436 ok ! defined $fil, ' gzopen with unknown mode fails' ;
438 $fil = gzopen($name, "ab") ;
439 ok $fil, ' gzopen with mode "ab" is ok' ;
441 $fil = gzopen($name, "wb6") ;
442 ok $fil, ' gzopen with mode "wb6" is ok' ;
444 $fil = gzopen($name, "wbf") ;
445 ok $fil, ' gzopen with mode "wbf" is ok' ;
447 $fil = gzopen($name, "wbh") ;
448 ok $fil, ' gzopen with mode "wbh" is ok' ;
452 title 'Read operations when opened for writing';
454 my $name = "test.gz" ;
455 my $lex = new LexFile $name ;
456 ok $fil = gzopen($name, "wb"), ' gzopen for writing' ;
457 ok !$fil->gzeof(), ' !eof'; ;
458 is $fil->gzread(), Z_STREAM_ERROR, " gzread returns Z_STREAM_ERROR" ;
462 title 'write operations when opened for reading';
464 my $name = "test.gz" ;
465 my $lex = new LexFile $name ;
467 ok $fil = gzopen($name, "wb"), " gzopen for writing" ;
468 is $fil->gzwrite($text), length $text, " gzwrite ok" ;
469 ok ! $fil->gzclose, " gzclose ok" ;
471 ok $fil = gzopen($name, "rb"), " gzopen for reading" ;
472 is $fil->gzwrite(), Z_STREAM_ERROR, " gzwrite returns Z_STREAM_ERROR" ;
476 title 'read/write a non-readable/writable file';
481 my $lex = new LexFile $name ;
482 writeFile($name, "abc");
485 skip "Cannot create non-writable file", 3
488 ok ! -w $name, " input file not writable";
490 my $fil = gzopen($name, "wb") ;
491 ok !$fil, " gzopen returns undef" ;
492 ok $gzerrno, " gzerrno ok" or
493 diag " gzerrno $gzerrno\n";
501 my $lex = new LexFile $name ;
502 writeFile($name, "abc");
505 skip "Cannot create non-readable file", 3
508 ok ! -r $name, " input file not readable";
510 $fil = gzopen($name, "rb") ;
511 ok !$fil, " gzopen returns undef" ;
512 ok $gzerrno, " gzerrno ok";
522 my $name ;#= "test.gz" ;
523 my $lex = new LexFile $name ;
525 my $first = "beginning" ;
526 my $last = "the end" ;
527 my $iow = gzopen($name, "w");
528 $iow->gzwrite($first) ;
529 ok $iow->gzseek(5, SEEK_CUR) ;
530 is $iow->gztell(), length($first)+5;
531 ok $iow->gzseek(0, SEEK_CUR) ;
532 is $iow->gztell(), length($first)+5;
533 ok $iow->gzseek(length($first)+10, SEEK_SET) ;
534 is $iow->gztell(), length($first)+10;
536 $iow->gzwrite($last) ;
539 ok GZreadFile($name) eq $first . "\x00" x 10 . $last ;
541 my $io = gzopen($name, "r");
542 ok $io->gzseek(length($first), SEEK_CUR) ;
544 is $io->gztell(), length($first);
546 ok $io->gzread($buff, 5) ;
547 is $buff, "\x00" x 5 ;
548 is $io->gztell(), length($first) + 5;
550 is $io->gzread($buff, 0), 0 ;
551 #is $buff, "\x00" x 5 ;
552 is $io->gztell(), length($first) + 5;
554 ok $io->gzseek(0, SEEK_CUR) ;
555 my $here = $io->gztell() ;
556 is $here, length($first)+5;
558 ok $io->gzseek($here+5, SEEK_SET) ;
559 is $io->gztell(), $here+5 ;
560 ok $io->gzread($buff, 100) ;
567 my $name = "test.gz" ;
568 my $lex = new LexFile $name ;
570 my $a = gzopen($name, "w");
573 or print "# gzerrno is $Compress::Zlib::gzerrno \n" ;
574 eval { $a->gzseek(-1, 10) ; };
575 like $@, mkErr("gzseek: unknown value, 10, for whence parameter");
577 eval { $a->gzseek(-1, SEEK_END) ; };
578 like $@, mkErr("gzseek: cannot seek backwards");
584 my $u = gzopen($name, "r");
586 eval { $u->gzseek(-1, 10) ; };
587 like $@, mkErr("gzseek: unknown value, 10, for whence parameter");
589 eval { $u->gzseek(-1, SEEK_END) ; };
590 like $@, mkErr("gzseek: SEEK_END not allowed");
592 eval { $u->gzseek(-1, SEEK_CUR) ; };
593 like $@, mkErr("gzseek: cannot seek backwards");