02zlib.t

source of perl for linux application,

BEGIN {
    if ($ENV{PERL_CORE}) {
	chdir 't' if -d 't';
	@INC = ("../lib", "lib/compress");
    }
}

use lib qw(t t/compress);
use strict;
use warnings;
use bytes;

use Test::More  ;
use CompTestUtils;


BEGIN 
{ 
    # use Test::NoWarnings, if available
    my $extra = 0 ;
    $extra = 1
        if eval { require Test::NoWarnings ;  import Test::NoWarnings; 1 };


    my $count = 0 ;
    if ($] < 5.005) {
        $count = 189 ;
    }
    elsif ($] >= 5.006) {
        $count = 243 ;
    }
    else {
        $count = 201 ;
    }

    plan tests => $count + $extra;

    use_ok('Compress::Raw::Zlib', 2) ;
}


my $hello = <<EOM ;
hello world
this is a test
EOM

my $len   = length $hello ;

# Check zlib_version and ZLIB_VERSION are the same.
is Compress::Raw::Zlib::zlib_version, ZLIB_VERSION, 
    "ZLIB_VERSION matches Compress::Raw::Zlib::zlib_version" ;

{
    title "Error Cases" ;

    eval { new Compress::Raw::Zlib::Deflate(-Level) };
    like $@,  mkErr("^Compress::Raw::Zlib::Deflate::new: Expected even number of parameters, got 1") ;

    eval { new Compress::Raw::Zlib::Inflate(-Level) };
    like $@, mkErr("^Compress::Raw::Zlib::Inflate::new: Expected even number of parameters, got 1");

    eval { new Compress::Raw::Zlib::Deflate(-Joe => 1) };
    like $@, mkErr('^Compress::Raw::Zlib::Deflate::new: unknown key value\(s\) Joe');

    eval { new Compress::Raw::Zlib::Inflate(-Joe => 1) };
    like $@, mkErr('^Compress::Raw::Zlib::Inflate::new: unknown key value\(s\) Joe');

    eval { new Compress::Raw::Zlib::Deflate(-Bufsize => 0) };
    like $@, mkErr("^Compress::Raw::Zlib::Deflate::new: Bufsize must be >= 1, you specified 0");

    eval { new Compress::Raw::Zlib::Inflate(-Bufsize => 0) };
    like $@, mkErr("^Compress::Raw::Zlib::Inflate::new: Bufsize must be >= 1, you specified 0");

    eval { new Compress::Raw::Zlib::Deflate(-Bufsize => -1) };
    like $@, mkErr("^Compress::Raw::Zlib::Deflate::new: Parameter 'Bufsize' must be an unsigned int, got '-1'");

    eval { new Compress::Raw::Zlib::Inflate(-Bufsize => -1) };
    like $@, mkErr("^Compress::Raw::Zlib::Inflate::new: Parameter 'Bufsize' must be an unsigned int, got '-1'");

    eval { new Compress::Raw::Zlib::Deflate(-Bufsize => "xxx") };
    like $@, mkErr("^Compress::Raw::Zlib::Deflate::new: Parameter 'Bufsize' must be an unsigned int, got 'xxx'");

    eval { new Compress::Raw::Zlib::Inflate(-Bufsize => "xxx") };
    like $@, mkErr("^Compress::Raw::Zlib::Inflate::new: Parameter 'Bufsize' must be an unsigned int, got 'xxx'");

    eval { new Compress::Raw::Zlib::Inflate(-Bufsize => 1, 2) };
    like $@, mkErr("^Compress::Raw::Zlib::Inflate::new: Expected even number of parameters, got 3");

    eval { new Compress::Raw::Zlib::Deflate(-Bufsize => 1, 2) };
    like $@, mkErr("^Compress::Raw::Zlib::Deflate::new: Expected even number of parameters, got 3");

}

{

    title  "deflate/inflate - small buffer";
    # ==============================

    my $hello = "I am a HAL 9000 computer" ;
    my @hello = split('', $hello) ;
    my ($err, $x, $X, $status); 
 
    ok( ($x, $err) = new Compress::Raw::Zlib::Deflate ( -Bufsize => 1 ), "Create deflate object" );
    ok $x, "Compress::Raw::Zlib::Deflate ok" ;
    cmp_ok $err, '==', Z_OK, "status is Z_OK" ;
 
    ok ! defined $x->msg() ;
    is $x->total_in(), 0, "total_in() == 0" ;
    is $x->total_out(), 0, "total_out() == 0" ;

    $X = "" ;
    my $Answer = '';
    foreach (@hello)
    {
        $status = $x->deflate($_, $X) ;
        last unless $status == Z_OK ;
    
        $Answer .= $X ;
    }
     
    cmp_ok $status, '==', Z_OK, "deflate returned Z_OK" ;
    
    cmp_ok  $x->flush($X), '==', Z_OK, "flush returned Z_OK" ;
    $Answer .= $X ;
     
    ok ! defined $x->msg()  ;
    is $x->total_in(), length $hello, "total_in ok" ;
    is $x->total_out(), length $Answer, "total_out ok" ;
     
    my @Answer = split('', $Answer) ;
     
    my $k;
    ok(($k, $err) = new Compress::Raw::Zlib::Inflate( {-Bufsize => 1}) );
    ok $k, "Compress::Raw::Zlib::Inflate ok" ;
    cmp_ok $err, '==', Z_OK, "status is Z_OK" ;
 
    ok ! defined $k->msg(), "No error messages" ;
    is $k->total_in(), 0, "total_in() == 0" ;
    is $k->total_out(), 0, "total_out() == 0" ;
    my $GOT = '';
    my $Z;
    $Z = 1 ;#x 2000 ;
    foreach (@Answer)
    {
        $status = $k->inflate($_, $Z) ;
        $GOT .= $Z ;
        last if $status == Z_STREAM_END or $status != Z_OK ;
     
    }
     
    cmp_ok $status, '==', Z_STREAM_END, "Got Z_STREAM_END" ;
    is $GOT, $hello, "uncompressed data matches ok" ;
    ok ! defined $k->msg(), "No error messages" ;
    is $k->total_in(), length $Answer, "total_in ok" ;
    is $k->total_out(), length $hello , "total_out ok";

}


{
    # deflate/inflate - small buffer with a number
    # ==============================

    my $hello = 6529 ;
 
    ok  my ($x, $err) = new Compress::Raw::Zlib::Deflate ( -Bufsize => 1, -AppendOutput => 1 ) ;
    ok $x ;
    cmp_ok $err, '==', Z_OK ;
 
    my $status;
    my $Answer = '';
     
    cmp_ok $x->deflate($hello, $Answer), '==', Z_OK ;
    
    cmp_ok $x->flush($Answer), '==', Z_OK ;
     
    my @Answer = split('', $Answer) ;
     
    my $k;
    ok(($k, $err) = new Compress::Raw::Zlib::Inflate( {-Bufsize => 1, -AppendOutput =>1}) );
    ok $k ;
    cmp_ok $err, '==', Z_OK ;
     
    #my $GOT = '';
    my $GOT ;
    foreach (@Answer)
    {
        $status = $k->inflate($_, $GOT) ;
        last if $status == Z_STREAM_END or $status != Z_OK ;
     
    }
     
    cmp_ok $status, '==', Z_STREAM_END ;
    is $GOT, $hello ;

}

{

# deflate/inflate options - AppendOutput
# ================================

    # AppendOutput
    # CRC

    my $hello = "I am a HAL 9000 computer" ;
    my @hello = split('', $hello) ;
     
    ok  my ($x, $err) = new Compress::Raw::Zlib::Deflate ( {-Bufsize => 1, -AppendOutput =>1} ) ;
    ok $x ;
    cmp_ok $err, '==', Z_OK ;
     
    my $status;
    my $X;
    foreach (@hello)
    {
        $status = $x->deflate($_, $X) ;
        last unless $status == Z_OK ;
    }
     
    cmp_ok $status, '==', Z_OK ;
     
    cmp_ok $x->flush($X), '==', Z_OK ;
     
     
    my @Answer = split('', $X) ;
     
    my $k;
    ok(($k, $err) = new Compress::Raw::Zlib::Inflate( {-Bufsize => 1, -AppendOutput =>1}));
    ok $k ;
    cmp_ok $err, '==', Z_OK ;
     
    my $Z;
    foreach (@Answer)
    {
        $status = $k->inflate($_, $Z) ;
        last if $status == Z_STREAM_END or $status != Z_OK ;
     
    }
     
    cmp_ok $status, '==', Z_STREAM_END ;
    is $Z, $hello ;
}

 
{

    title "deflate/inflate - larger buffer";
    # ==============================

    # generate a long random string
    my $contents = '' ;
    foreach (1 .. 50000)
      { $contents .= chr int rand 255 }
    
    
    ok my ($x, $err) = new Compress::Raw::Zlib::Deflate() ;
    ok $x ;
    cmp_ok $err, '==', Z_OK ;
     
    my (%X, $Y, %Z, $X, $Z);
    #cmp_ok $x->deflate($contents, $X{key}), '==', Z_OK ;
    cmp_ok $x->deflate($contents, $X), '==', Z_OK ;
    
    #$Y = $X{key} ;
    $Y = $X ;
     
     
    #cmp_ok $x->flush($X{key}), '==', Z_OK ;
    #$Y .= $X{key} ;
    cmp_ok $x->flush($X), '==', Z_OK ;
    $Y .= $X ;
     
     
 
    my $keep = $Y ;

    my $k;
    ok(($k, $err) = new Compress::Raw::Zlib::Inflate() );
    ok $k ;
    cmp_ok $err, '==', Z_OK ;
     
    #cmp_ok $k->inflate($Y, $Z{key}), '==', Z_STREAM_END ;
    #ok $contents eq $Z{key} ;
    cmp_ok $k->inflate($Y, $Z), '==', Z_STREAM_END ;
    ok $contents eq $Z ;

    # redo deflate with AppendOutput

    ok (($k, $err) = new Compress::Raw::Zlib::Inflate(-AppendOutput => 1)) ;
    ok $k ;
    cmp_ok $err, '==', Z_OK ;
    
    my $s ; 
    my $out ;
    my @bits = split('', $keep) ;
    foreach my $bit (@bits) {
        $s = $k->inflate($bit, $out) ;
    }
    
    cmp_ok $s, '==', Z_STREAM_END ;
     
    ok $contents eq $out ;


}

{

    title "deflate/inflate - preset dictionary";
    # ===================================

    my $dictionary = "hello" ;
    ok my $x = new Compress::Raw::Zlib::Deflate({-Level => Z_BEST_COMPRESSION,
			     -Dictionary => $dictionary}) ;
 
    my $dictID = $x->dict_adler() ;

    my ($X, $Y, $Z);
    cmp_ok $x->deflate($hello, $X), '==', Z_OK;
    cmp_ok $x->flush($Y), '==', Z_OK;
    $X .= $Y ;
 
    ok my $k = new Compress::Raw::Zlib::Inflate(-Dictionary => $dictionary) ;
 
    cmp_ok $k->inflate($X, $Z), '==', Z_STREAM_END;
    is $k->dict_adler(), $dictID;
    is $hello, $Z ;

}

title 'inflate - check remaining buffer after Z_STREAM_END';
#           and that ConsumeInput works.
# ===================================================
 
for my $consume ( 0 .. 1)
{
    ok my $x = new Compress::Raw::Zlib::Deflate(-Level => Z_BEST_COMPRESSION ) ;
 
    my ($X, $Y, $Z);
    cmp_ok $x->deflate($hello, $X), '==', Z_OK;
    cmp_ok $x->flush($Y), '==', Z_OK;
    $X .= $Y ;
 
    ok my $k = new Compress::Raw::Zlib::Inflate( -ConsumeInput => $consume) ;
 
    my $first = substr($X, 0, 2) ;
    my $remember_first = $first ;
    my $last  = substr($X, 2) ;
    cmp_ok $k->inflate($first, $Z), '==', Z_OK;
    if ($consume) {
        ok $first eq "" ;
    }
    else {
        ok $first eq $remember_first ;
    }

    my $T ;
    $last .= "appendage" ;
    my $remember_last = $last ;
    cmp_ok $k->inflate($last, $T),  '==', Z_STREAM_END;
    is $hello, $Z . $T  ;
    if ($consume) {
        is $last, "appendage" ;
    }
    else {
        is $last, $remember_last ;
    }

}



{

    title 'Check - MAX_WBITS';
    # =================
    
    my $hello = "Test test test test test";
    my @hello = split('', $hello) ;
     
    ok  my ($x, $err) = 
       new Compress::Raw::Zlib::Deflate ( -Bufsize => 1, 
                                     -WindowBits => -MAX_WBITS(),
                                     -AppendOutput => 1 ) ;
    ok $x ;
    cmp_ok $err, '==', Z_OK ;

    my $Answer = '';
    my $status;
    foreach (@hello)
    {
        $status = $x->deflate($_, $Answer) ;
        last unless $status == Z_OK ;
    }
     
    cmp_ok $status, '==', Z_OK ;
    
    cmp_ok $x->flush($Answer), '==', Z_OK ;
     
    my @Answer = split('', $Answer) ;
    # Undocumented corner -- extra byte needed to get inflate to return 
    # Z_STREAM_END when done.  
    push @Answer, " " ; 
     
    my $k;
    ok(($k, $err) = new Compress::Raw::Zlib::Inflate( 
			{-Bufsize => 1, 
			-AppendOutput =>1,
			-WindowBits => -MAX_WBITS()})) ;
    ok $k ;
    cmp_ok $err, '==', Z_OK ;
     
    my $GOT = '';