4 @INC = ("../lib", "lib");
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') ;
35 my $len = length $hello ;
37 # Check zlib_version and ZLIB_VERSION are the same.
38 is Compress::Zlib::zlib_version, ZLIB_VERSION,
39 "ZLIB_VERSION matches Compress::Zlib::zlib_version" ;
44 my $name = "test.gz" ;
47 ok my $fil = gzopen($name, "wb") ;
49 is $gzerrno, 0, 'gzerrno is 0';
50 is $fil->gzerror(), 0, "gzerror() returned 0";
52 is $fil->gztell(), 0, "gztell returned 0";
53 is $gzerrno, 0, 'gzerrno is 0';
55 is $fil->gzwrite($hello), $len ;
56 is $gzerrno, 0, 'gzerrno is 0';
58 is $fil->gztell(), $len, "gztell returned $len";
59 is $gzerrno, 0, 'gzerrno is 0';
63 ok $fil = gzopen($name, "rb") ;
66 is $gzerrno, 0, 'gzerrno is 0';
69 is $fil->gzread($uncomp), $len;
71 is $fil->gztell(), $len;
76 1 while unlink $name ;
78 ok $hello eq $uncomp ;
80 # check that a number can be gzipped
84 ok $fil = gzopen($name, "wb") ;
88 is $fil->gzwrite($number), $num_len, "gzwrite returned $num_len" ;
89 is $gzerrno, 0, 'gzerrno is 0';
90 ok $fil->gzflush(Z_FINISH) ;
92 is $gzerrno, 0, 'gzerrno is 0';
96 cmp_ok $gzerrno, '==', 0;
98 ok $fil = gzopen($name, "rb") ;
100 ok (($x = $fil->gzread($uncomp)) == $num_len) ;
102 ok $fil->gzerror() == 0 || $fil->gzerror() == Z_STREAM_END;
103 ok $gzerrno == 0 || $gzerrno == Z_STREAM_END;
110 or print "# gzerrno is $gzerrno\n" ;
112 1 while unlink $name ;
114 ok $number == $uncomp ;
115 ok $number eq $uncomp ;
118 # now a bigger gzip test
121 my $file = "$text.gz" ;
123 ok my $f = gzopen($file, "wb") ;
125 # generate a long random string
128 { $contents .= chr int rand 256 }
130 $len = length $contents ;
132 ok $f->gzwrite($contents) == $len ;
136 ok $f = gzopen($file, "rb") ;
141 is $f->gzread($uncompressed, $len), $len ;
143 ok $contents eq $uncompressed
145 or print "# Length orig $len" .
146 ", Length uncompressed " . length($uncompressed) . "\n" ;
151 1 while unlink($file) ;
153 # gzip - readline tests
154 # ======================
156 # first create a small gzipped text file
158 my @text = (<<EOM, <<EOM, <<EOM, <<EOM) ;
163 the line after the previous line
168 $text = join("", @text) ;
170 ok $fil = gzopen($name, "wb") ;
171 ok $fil->gzwrite($text) == length $text ;
174 # now try to read it back in
175 ok $fil = gzopen($name, "rb") ;
178 for my $i (0 .. @text -2)
180 ok $fil->gzreadline($line) > 0;
181 is $line, $text[$i] ;
185 # now read the last line
186 ok $fil->gzreadline($line) > 0;
187 is $line, $text[-1] ;
191 is $fil->gzreadline($line), 0;
196 1 while unlink($name) ;
198 # a text file with a very long line (bigger than the internal buffer)
199 my $line1 = ("abcdefghijklmnopq" x 2000) . "\n" ;
200 my $line2 = "second line\n" ;
201 $text = $line1 . $line2 ;
202 ok $fil = gzopen($name, "wb") ;
203 ok $fil->gzwrite($text) == length $text ;
206 # now try to read it back in
207 ok $fil = gzopen($name, "rb") ;
211 while ($fil->gzreadline($line) > 0) {
223 1 while unlink $name ;
225 # a text file which is not termined by an EOL
227 $line1 = "hello hello, I'm back again\n" ;
228 $line2 = "there is no end in sight" ;
230 $text = $line1 . $line2 ;
231 ok $fil = gzopen($name, "wb") ;
232 ok $fil->gzwrite($text) == length $text ;
235 # now try to read it back in
236 ok $fil = gzopen($name, "rb") ;
238 while ($fil->gzreadline($line) > 0) {
249 1 while unlink $name ;
253 title 'mix gzread and gzreadline';
255 # case 1: read a line, then a block. The block is
256 # smaller than the internal block used by
258 my $lex = new LexFile my $name ;
259 $line1 = "hello hello, I'm back again\n" ;
260 $line2 = "abc" x 200 ;
261 my $line3 = "def" x 200 ;
263 $text = $line1 . $line2 . $line3 ;
265 ok $fil = gzopen($name, "wb"), ' gzopen for write ok' ;
266 is $fil->gzwrite($text), length $text, ' gzwrite ok' ;
267 is $fil->gztell(), length $text, ' gztell ok' ;
268 ok ! $fil->gzclose, ' gzclose ok' ;
270 # now try to read it back in
271 ok $fil = gzopen($name, "rb"), ' gzopen for read ok' ;
272 ok ! $fil->gzeof(), ' !gzeof' ;
273 cmp_ok $fil->gzreadline($line), '>', 0, ' gzreadline' ;
274 is $fil->gztell(), length $line1, ' gztell ok' ;
275 ok ! $fil->gzeof(), ' !gzeof' ;
276 is $line, $line1, ' got expected line' ;
277 cmp_ok $fil->gzread($line, length $line2), '>', 0, ' gzread ok' ;
278 is $fil->gztell(), length($line1)+length($line2), ' gztell ok' ;
279 ok ! $fil->gzeof(), ' !gzeof' ;
280 is $line, $line2, ' read expected block' ;
281 cmp_ok $fil->gzread($line, length $line3), '>', 0, ' gzread ok' ;
282 is $fil->gztell(), length($text), ' gztell ok' ;
283 ok $fil->gzeof(), ' !gzeof' ;
284 is $line, $line3, ' read expected block' ;
285 ok ! $fil->gzclose, ' gzclose' ;
289 title "Pass gzopen a filehandle - use IO::File" ;
291 my $lex = new LexFile my $name ;
293 my $hello = "hello" ;
294 my $len = length $hello ;
296 my $f = new IO::File ">$name" ;
300 ok $fil = gzopen($f, "wb") ;
302 ok $fil->gzwrite($hello) == $len ;
306 $f = new IO::File "<$name" ;
307 ok $fil = gzopen($name, "rb") ;
310 ok (($x = $fil->gzread($uncomp)) == $len)
311 or print "# length $x, expected $len\n" ;
318 is $uncomp, $hello, "got expected output" ;
325 title "Pass gzopen a filehandle - use open" ;
327 my $lex = new LexFile my $name ;
329 my $hello = "hello" ;
330 my $len = length $hello ;
335 ok $fil = gzopen(*F, "wb") ;
337 is $fil->gzwrite($hello), $len ;
342 ok $fil = gzopen(*F, "rb") ;
345 $x = $fil->gzread($uncomp);
357 foreach my $stdio ( ['-', '-'], [*STDIN, *STDOUT])
359 my $stdin = $stdio->[0];
360 my $stdout = $stdio->[1];
362 title "Pass gzopen a filehandle - use $stdin" ;
364 my $lex = new LexFile my $name ;
366 my $hello = "hello" ;
367 my $len = length $hello ;
369 ok open(SAVEOUT, ">&STDOUT"), " save STDOUT";
370 my $dummy = fileno SAVEOUT;
371 ok open(STDOUT, ">$name"), " redirect STDOUT" ;
375 my $fil = gzopen($stdout, "wb") ;
378 ($fil->gzwrite($hello) == $len) &&
379 ($fil->gzclose == 0) ;
381 open(STDOUT, ">&SAVEOUT");
383 ok $status, " wrote to stdout";
385 open(SAVEIN, "<&STDIN");
386 ok open(STDIN, "<$name"), " redirect STDIN";
387 $dummy = fileno SAVEIN;
389 ok $fil = gzopen($stdin, "rb") ;
392 ok (($x = $fil->gzread($uncomp)) == $len)
393 or print "# length $x, expected $len\n" ;
399 open(STDIN, "<&SAVEIN");
407 title 'test parameters for gzopen';
408 my $lex = new LexFile my $name ;
413 eval ' $fil = gzopen() ' ;
414 like $@, mkEvalErr('Not enough arguments for Compress::Zlib::gzopen'),
415 ' gzopen with missing mode fails' ;
418 $fil = gzopen($name, "xy") ;
419 ok ! defined $fil, ' gzopen with unknown mode fails' ;
421 $fil = gzopen($name, "ab") ;
422 ok $fil, ' gzopen with mode "ab" is ok' ;
424 $fil = gzopen($name, "wb6") ;
425 ok $fil, ' gzopen with mode "wb6" is ok' ;
427 $fil = gzopen($name, "wbf") ;
428 ok $fil, ' gzopen with mode "wbf" is ok' ;
430 $fil = gzopen($name, "wbh") ;
431 ok $fil, ' gzopen with mode "wbh" is ok' ;
435 title 'Read operations when opened for writing';
437 my $lex = new LexFile my $name ;
439 ok $fil = gzopen($name, "wb"), ' gzopen for writing' ;
440 ok !$fil->gzeof(), ' !eof'; ;
441 is $fil->gzread(), Z_STREAM_ERROR, " gzread returns Z_STREAM_ERROR" ;
442 ok ! $fil->gzclose, " gzclose ok" ;
446 title 'write operations when opened for reading';
448 my $lex = new LexFile my $name ;
451 ok $fil = gzopen($name, "wb"), " gzopen for writing" ;
452 is $fil->gzwrite($text), length $text, " gzwrite ok" ;
453 ok ! $fil->gzclose, " gzclose ok" ;
455 ok $fil = gzopen($name, "rb"), " gzopen for reading" ;
456 is $fil->gzwrite(), Z_STREAM_ERROR, " gzwrite returns Z_STREAM_ERROR" ;
460 title 'read/write a non-readable/writable file';
464 my $lex = new LexFile my $name ;
465 writeFile($name, "abc");
468 skip "Cannot create non-writable file", 3
471 ok ! -w $name, " input file not writable";
473 my $fil = gzopen($name, "wb") ;
474 ok !$fil, " gzopen returns undef" ;
475 ok $gzerrno, " gzerrno ok" or
476 diag " gzerrno $gzerrno\n";
483 my $lex = new LexFile my $name ;
484 writeFile($name, "abc");
487 skip "Cannot create non-readable file", 3
490 ok ! -r $name, " input file not readable";
492 $fil = gzopen($name, "rb") ;
493 ok !$fil, " gzopen returns undef" ;
494 ok $gzerrno, " gzerrno ok";
504 my $lex = new LexFile my $name ;
506 my $first = "beginning" ;
507 my $last = "the end" ;
508 my $iow = gzopen($name, "w");
509 $iow->gzwrite($first) ;
510 ok $iow->gzseek(5, SEEK_CUR) ;
511 is $iow->gztell(), length($first)+5;
512 ok $iow->gzseek(0, SEEK_CUR) ;
513 is $iow->gztell(), length($first)+5;
514 ok $iow->gzseek(length($first)+10, SEEK_SET) ;
515 is $iow->gztell(), length($first)+10;
517 $iow->gzwrite($last) ;
520 ok GZreadFile($name) eq $first . "\x00" x 10 . $last ;
522 my $io = gzopen($name, "r");
523 ok $io->gzseek(length($first), SEEK_CUR) ;
525 is $io->gztell(), length($first);
527 ok $io->gzread($buff, 5) ;
528 is $buff, "\x00" x 5 ;
529 is $io->gztell(), length($first) + 5;
531 is $io->gzread($buff, 0), 0 ;
532 #is $buff, "\x00" x 5 ;
533 is $io->gztell(), length($first) + 5;
535 ok $io->gzseek(0, SEEK_CUR) ;
536 my $here = $io->gztell() ;
537 is $here, length($first)+5;
539 ok $io->gzseek($here+5, SEEK_SET) ;
540 is $io->gztell(), $here+5 ;
541 ok $io->gzread($buff, 100) ;
548 my $lex = new LexFile my $name ;
550 my $a = gzopen($name, "w");
553 or print "# gzerrno is $Compress::Zlib::gzerrno \n" ;
554 eval { $a->gzseek(-1, 10) ; };
555 like $@, mkErr("gzseek: unknown value, 10, for whence parameter");
557 eval { $a->gzseek(-1, SEEK_END) ; };
558 like $@, mkErr("gzseek: cannot seek backwards");
564 my $u = gzopen($name, "r");
566 eval { $u->gzseek(-1, 10) ; };
567 like $@, mkErr("gzseek: unknown value, 10, for whence parameter");
569 eval { $u->gzseek(-1, SEEK_END) ; };
570 like $@, mkErr("gzseek: SEEK_END not allowed");
572 eval { $u->gzseek(-1, SEEK_CUR) ; };
573 like $@, mkErr("gzseek: cannot seek backwards");