4 @INC = ("../lib", "lib/compress");
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" ;
317 is $uncomp, $hello, "got expected output" ;
322 title "Pass gzopen a filehandle - use open" ;
324 my $lex = new LexFile my $name ;
326 my $hello = "hello" ;
327 my $len = length $hello ;
332 ok $fil = gzopen(*F, "wb") ;
334 is $fil->gzwrite($hello), $len ;
339 ok $fil = gzopen(*F, "rb") ;
342 $x = $fil->gzread($uncomp);
354 foreach my $stdio ( ['-', '-'], [*STDIN, *STDOUT])
356 my $stdin = $stdio->[0];
357 my $stdout = $stdio->[1];
359 title "Pass gzopen a filehandle - use $stdin" ;
361 my $lex = new LexFile my $name ;
363 my $hello = "hello" ;
364 my $len = length $hello ;
366 ok open(SAVEOUT, ">&STDOUT"), " save STDOUT";
367 my $dummy = fileno SAVEOUT;
368 ok open(STDOUT, ">$name"), " redirect STDOUT" ;
372 my $fil = gzopen($stdout, "wb") ;
375 ($fil->gzwrite($hello) == $len) &&
376 ($fil->gzclose == 0) ;
378 open(STDOUT, ">&SAVEOUT");
380 ok $status, " wrote to stdout";
382 open(SAVEIN, "<&STDIN");
383 ok open(STDIN, "<$name"), " redirect STDIN";
384 $dummy = fileno SAVEIN;
386 ok $fil = gzopen($stdin, "rb") ;
389 ok (($x = $fil->gzread($uncomp)) == $len)
390 or print "# length $x, expected $len\n" ;
396 open(STDIN, "<&SAVEIN");
404 title 'test parameters for gzopen';
405 my $lex = new LexFile my $name ;
410 eval ' $fil = gzopen() ' ;
411 like $@, mkEvalErr('Not enough arguments for Compress::Zlib::gzopen'),
412 ' gzopen with missing mode fails' ;
415 $fil = gzopen($name, "xy") ;
416 ok ! defined $fil, ' gzopen with unknown mode fails' ;
418 $fil = gzopen($name, "ab") ;
419 ok $fil, ' gzopen with mode "ab" is ok' ;
421 $fil = gzopen($name, "wb6") ;
422 ok $fil, ' gzopen with mode "wb6" is ok' ;
424 $fil = gzopen($name, "wbf") ;
425 ok $fil, ' gzopen with mode "wbf" is ok' ;
427 $fil = gzopen($name, "wbh") ;
428 ok $fil, ' gzopen with mode "wbh" is ok' ;
432 title 'Read operations when opened for writing';
434 my $lex = new LexFile my $name ;
436 ok $fil = gzopen($name, "wb"), ' gzopen for writing' ;
437 ok !$fil->gzeof(), ' !eof'; ;
438 is $fil->gzread(), Z_STREAM_ERROR, " gzread returns Z_STREAM_ERROR" ;
439 ok ! $fil->gzclose, " gzclose ok" ;
443 title 'write operations when opened for reading';
445 my $lex = new LexFile my $name ;
448 ok $fil = gzopen($name, "wb"), " gzopen for writing" ;
449 is $fil->gzwrite($text), length $text, " gzwrite ok" ;
450 ok ! $fil->gzclose, " gzclose ok" ;
452 ok $fil = gzopen($name, "rb"), " gzopen for reading" ;
453 is $fil->gzwrite(), Z_STREAM_ERROR, " gzwrite returns Z_STREAM_ERROR" ;
457 title 'read/write a non-readable/writable file';
461 my $lex = new LexFile my $name ;
462 writeFile($name, "abc");
465 skip "Cannot create non-writable file", 3
468 ok ! -w $name, " input file not writable";
470 my $fil = gzopen($name, "wb") ;
471 ok !$fil, " gzopen returns undef" ;
472 ok $gzerrno, " gzerrno ok" or
473 diag " gzerrno $gzerrno\n";
480 my $lex = new LexFile my $name ;
481 writeFile($name, "abc");
484 skip "Cannot create non-readable file", 3
487 ok ! -r $name, " input file not readable";
489 $fil = gzopen($name, "rb") ;
490 ok !$fil, " gzopen returns undef" ;
491 ok $gzerrno, " gzerrno ok";
501 my $lex = new LexFile my $name ;
503 my $first = "beginning" ;
504 my $last = "the end" ;
505 my $iow = gzopen($name, "w");
506 $iow->gzwrite($first) ;
507 ok $iow->gzseek(5, SEEK_CUR) ;
508 is $iow->gztell(), length($first)+5;
509 ok $iow->gzseek(0, SEEK_CUR) ;
510 is $iow->gztell(), length($first)+5;
511 ok $iow->gzseek(length($first)+10, SEEK_SET) ;
512 is $iow->gztell(), length($first)+10;
514 $iow->gzwrite($last) ;
517 ok GZreadFile($name) eq $first . "\x00" x 10 . $last ;
519 my $io = gzopen($name, "r");
520 ok $io->gzseek(length($first), SEEK_CUR) ;
522 is $io->gztell(), length($first);
524 ok $io->gzread($buff, 5) ;
525 is $buff, "\x00" x 5 ;
526 is $io->gztell(), length($first) + 5;
528 is $io->gzread($buff, 0), 0 ;
529 #is $buff, "\x00" x 5 ;
530 is $io->gztell(), length($first) + 5;
532 ok $io->gzseek(0, SEEK_CUR) ;
533 my $here = $io->gztell() ;
534 is $here, length($first)+5;
536 ok $io->gzseek($here+5, SEEK_SET) ;
537 is $io->gztell(), $here+5 ;
538 ok $io->gzread($buff, 100) ;
545 my $lex = new LexFile my $name ;
547 my $a = gzopen($name, "w");
550 or print "# gzerrno is $Compress::Zlib::gzerrno \n" ;
551 eval { $a->gzseek(-1, 10) ; };
552 like $@, mkErr("gzseek: unknown value, 10, for whence parameter");
554 eval { $a->gzseek(-1, SEEK_END) ; };
555 like $@, mkErr("gzseek: cannot seek backwards");
561 my $u = gzopen($name, "r");
563 eval { $u->gzseek(-1, 10) ; };
564 like $@, mkErr("gzseek: unknown value, 10, for whence parameter");
566 eval { $u->gzseek(-1, SEEK_END) ; };
567 like $@, mkErr("gzseek: SEEK_END not allowed");
569 eval { $u->gzseek(-1, SEEK_CUR) ; };
570 like $@, mkErr("gzseek: cannot seek backwards");