t/lib/compress/oneshot.pl

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