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