File Coverage

inc/Test/Base.pm
Criterion Covered Total %
statement 213 364 58.5
branch 49 178 27.5
condition 16 74 21.6
subroutine 38 60 63.3
pod 0 26 0.0
total 316 702 45.0


line stmt bran cond sub pod time code
1             #line 1
2             # TODO:
3             #
4 6     6   3734 package Test::Base;
  6         22  
  6         370  
5 6     6   3480 use 5.006001;
  6         161  
  6         40  
6 6     6   53 use Spiffy 0.30 -Base;
  6     6   11  
  6     6   178  
  6         37  
  6         15  
  6         163  
  6         28  
  6         11  
  6         28  
7             use Spiffy ':XXX';
8             our $VERSION = '0.53';
9              
10             my @test_more_exports;
11 6     6   188 BEGIN {
12             @test_more_exports = qw(
13             ok isnt like unlike is_deeply cmp_ok
14             skip todo_skip pass fail
15             eq_array eq_hash eq_set
16             plan can_ok isa_ok diag
17             use_ok
18             $TODO
19             );
20             }
21 6     6   4072  
  6         20  
  6         62  
22 6     6   45 use Test::More import => \@test_more_exports;
  6         13  
  6         2939  
23             use Carp;
24              
25             our @EXPORT = (@test_more_exports, qw(
26             is no_diff
27              
28             blocks next_block first_block
29             delimiters spec_file spec_string
30             filters filters_delay filter_arguments
31             run run_compare run_is run_is_deeply run_like run_unlike
32             WWW XXX YYY ZZZ
33             tie_output no_diag_on_only
34              
35             find_my_self default_object
36              
37             croak carp cluck confess
38             ));
39              
40             field '_spec_file';
41             field '_spec_string';
42             field _filters => [qw(norm trim)];
43             field _filters_map => {};
44             field spec =>
45             -init => '$self->_spec_init';
46             field block_list =>
47             -init => '$self->_block_list_init';
48             field _next_list => [];
49             field block_delim =>
50             -init => '$self->block_delim_default';
51             field data_delim =>
52             -init => '$self->data_delim_default';
53             field _filters_delay => 0;
54             field _no_diag_on_only => 0;
55              
56             field block_delim_default => '===';
57             field data_delim_default => '---';
58              
59             my $default_class;
60             my $default_object;
61             my $reserved_section_names = {};
62 4     4 0 8  
63 4   66     43 sub default_object {
64 4         10 $default_object ||= $default_class->new;
65             return $default_object;
66             }
67              
68             my $import_called = 0;
69 6     6   60 sub import() {
70 6 50       226 $import_called = 1;
71             my $class = (grep /^-base$/i, @_)
72             ? scalar(caller)
73 6 50       24 : $_[0];
74 6         11 if (not defined $default_class) {
75             $default_class = $class;
76             }
77             # else {
78             # croak "Can't use $class after using $default_class"
79             # unless $default_class->isa($class);
80             # }
81 6 50       30  
82 6         10 unless (grep /^-base$/i, @_) {
83 6         30 my @args;
84 0 0       0 for (my $ii = 1; $ii <= $#_; ++$ii) {
85 0         0 if ($_[$ii] eq '-package') {
86             ++$ii;
87 0         0 } else {
88             push @args, $_[$ii];
89             }
90 6 50       24 }
91             Test::More->import(import => \@test_more_exports, @args)
92             if @args;
93             }
94 6         24
95 6         133 _strict_warnings();
96             goto &Spiffy::import;
97             }
98              
99             # Wrap Test::Builder::plan
100             my $plan_code = \&Test::Builder::plan;
101             my $Have_Plan = 0;
102 6     6   37 {
  6         9  
  6         1999517  
103             no warnings 'redefine';
104 8     8   21 *Test::Builder::plan = sub {
105 8         57 $Have_Plan = 1;
106             goto &$plan_code;
107             };
108             }
109              
110             my $DIED = 0;
111             $SIG{__DIE__} = sub { $DIED = 1; die @_ };
112 2     2 0 4  
  2         9  
113 12     12 0 18 sub block_class { $self->find_class('Block') }
  12         29  
114             sub filter_class { $self->find_class('Filter') }
115 14     14 0 22  
116 14         17 sub find_class {
117 14         35 my $suffix = shift;
118 14 100       101 my $class = ref($self) . "::$suffix";
119 2         6 return $class if $class->can('new');
120 2 50       13 $class = __PACKAGE__ . "::$suffix";
121 2         155 return $class if $class->can('new');
122 2 50       28 eval "require $class";
123 0         0 return $class if $class->can('new');
124             die "Can't find a class for $suffix";
125             }
126 0     0 0 0  
127 0 0       0 sub check_late {
128 0         0 if ($self->{block_list}) {
129 0         0 my $caller = (caller(1))[3];
130 0         0 $caller =~ s/.*:://;
131             croak "Too late to call $caller()"
132             }
133             }
134              
135 4 50   4 0 26 sub find_my_self() {
136             my $self = ref($_[0]) eq $default_class
137             ? splice(@_, 0, 1)
138 4         17 : default_object();
139             return $self, @_;
140             }
141              
142 0     0 0 0 sub blocks() {
143             (my ($self), @_) = find_my_self(@_);
144 0 0       0  
145             croak "Invalid arguments passed to 'blocks'"
146 0 0 0     0 if @_ > 1;
147             croak sprintf("'%s' is invalid argument to blocks()", shift(@_))
148             if @_ && $_[0] !~ /^[a-zA-Z]\w*$/;
149 0         0  
150             my $blocks = $self->block_list;
151 0   0     0
152 0         0 my $section_name = shift || '';
153 0 0       0 my @blocks = $section_name
154             ? (grep { exists $_->{$section_name} } @$blocks)
155             : (@$blocks);
156 0 0       0  
157             return scalar(@blocks) unless wantarray;
158 0 0       0
159             return (@blocks) if $self->_filters_delay;
160 0         0  
161 0 0       0 for my $block (@blocks) {
162             $block->run_filters
163             unless $block->is_filtered;
164             }
165 0         0  
166             return (@blocks);
167             }
168              
169 0     0 0 0 sub next_block() {
170 0         0 (my ($self), @_) = find_my_self(@_);
171 0 0       0 my $list = $self->_next_list;
172 0         0 if (@$list == 0) {
  0         0  
173 0         0 $list = [@{$self->block_list}, undef];
174             $self->_next_list($list);
175 0         0 }
176 0 0 0     0 my $block = shift @$list;
177 0         0 if (defined $block and not $block->is_filtered) {
178             $block->run_filters;
179 0         0 }
180             return $block;
181             }
182              
183 0     0 0 0 sub first_block() {
184 0         0 (my ($self), @_) = find_my_self(@_);
185 0         0 $self->_next_list([]);
186             $self->next_block;
187             }
188              
189 0     0 0 0 sub filters_delay() {
190 0 0       0 (my ($self), @_) = find_my_self(@_);
191             $self->_filters_delay(defined $_[0] ? shift : 1);
192             }
193              
194 0     0 0 0 sub no_diag_on_only() {
195 0 0       0 (my ($self), @_) = find_my_self(@_);
196             $self->_no_diag_on_only(defined $_[0] ? shift : 1);
197             }
198              
199 0     0 0 0 sub delimiters() {
200 0         0 (my ($self), @_) = find_my_self(@_);
201 0         0 $self->check_late;
202 0   0     0 my ($block_delimiter, $data_delimiter) = @_;
203 0   0     0 $block_delimiter ||= $self->block_delim_default;
204 0         0 $data_delimiter ||= $self->data_delim_default;
205 0         0 $self->block_delim($block_delimiter);
206 0         0 $self->data_delim($data_delimiter);
207             return $self;
208             }
209              
210 0     0 0 0 sub spec_file() {
211 0         0 (my ($self), @_) = find_my_self(@_);
212 0         0 $self->check_late;
213 0         0 $self->_spec_file(shift);
214             return $self;
215             }
216              
217 0     0 0 0 sub spec_string() {
218 0         0 (my ($self), @_) = find_my_self(@_);
219 0         0 $self->check_late;
220 0         0 $self->_spec_string(shift);
221             return $self;
222             }
223              
224 0     0 0 0 sub filters() {
225 0 0       0 (my ($self), @_) = find_my_self(@_);
226 0         0 if (ref($_[0]) eq 'HASH') {
227             $self->_filters_map(shift);
228             }
229 0         0 else {
230 0         0 my $filters = $self->_filters;
231             push @$filters, @_;
232 0         0 }
233             return $self;
234             }
235              
236 0     0 0 0 sub filter_arguments() {
237             $Test::Base::Filter::arguments;
238             }
239 0     0 0 0  
240 0 0 0     0 sub have_text_diff {
  0         0  
  0         0  
241             eval { require Text::Diff; 1 } &&
242             $Text::Diff::VERSION >= 0.35 &&
243             $Algorithm::Diff::VERSION >= 1.15;
244             }
245              
246 2     2 0 12 sub is($$;$) {
247 2         7 (my ($self), @_) = find_my_self(@_);
248 2         7 my ($actual, $expected, $name) = @_;
249 2 50 33     43 local $Test::Builder::Level = $Test::Builder::Level + 1;
      33        
      33        
      33        
      33        
250             if ($ENV{TEST_SHOW_NO_DIFFS} or
251             not defined $actual or
252             not defined $expected or
253             $actual eq $expected or
254             not($self->have_text_diff) or
255             $expected !~ /\n./s
256 2         13 ) {
257             Test::More::is($actual, $expected, $name);
258             }
259 0 0       0 else {
260 0         0 $name = '' unless defined $name;
261             ok $actual eq $expected,
262             $name . "\n" . Text::Diff::diff(\$expected, \$actual);
263             }
264             }
265              
266 0     0 0 0 sub run(&;$) {
267 0         0 (my ($self), @_) = find_my_self(@_);
268 0         0 my $callback = shift;
  0         0  
269 0 0       0 for my $block (@{$self->block_list}) {
270 0         0 $block->run_filters unless $block->is_filtered;
  0         0  
271             &{$callback}($block);
272             }
273             }
274              
275 2     2   5 my $name_error = "Can't determine section names";
276 2 50       13 sub _section_names {
277 0 0       0 return @_ if @_ == 2;
278             my $block = $self->first_block
279 0         0 or croak $name_error;
280 0 0       0 my @names = grep {
281 0         0 $_ !~ /^(ONLY|LAST|SKIP)$/;
282 0 0       0 } @{$block->{_section_order}[0] || []};
283             croak "$name_error. Need two sections in first block"
284 0         0 unless @names == 2;
285             return @names;
286             }
287 2     2   5  
288 2 50       9 sub _assert_plan {
289             plan('no_plan') unless $Have_Plan;
290             }
291 6     6   18  
292 6 0 33     86 sub END {
      33        
293             run_compare() unless $Have_Plan or $DIED or not $import_called;
294             }
295              
296 0     0 0 0 sub run_compare() {
297 0         0 (my ($self), @_) = find_my_self(@_);
298 0         0 $self->_assert_plan;
299 0         0 my ($x, $y) = $self->_section_names(@_);
300 0         0 local $Test::Builder::Level = $Test::Builder::Level + 1;
  0         0  
301 0 0 0     0 for my $block (@{$self->block_list}) {
302 0 0       0 next unless exists($block->{$x}) and exists($block->{$y});
303 0 0       0 $block->run_filters unless $block->is_filtered;
    0          
304 0 0       0 if (ref $block->$x) {
305             is_deeply($block->$x, $block->$y,
306             $block->name ? $block->name : ());
307             }
308 0 0       0 elsif (ref $block->$y eq 'Regexp') {
309 0 0       0 my $regexp = ref $y ? $y : $block->$y;
310             like($block->$x, $regexp, $block->name ? $block->name : ());
311             }
312 0 0       0 else {
313             is($block->$x, $block->$y, $block->name ? $block->name : ());
314             }
315             }
316             }
317              
318 2     2 0 20 sub run_is() {
319 2         11 (my ($self), @_) = find_my_self(@_);
320 2         11 $self->_assert_plan;
321 2         6 my ($x, $y) = $self->_section_names(@_);
322 2         4 local $Test::Builder::Level = $Test::Builder::Level + 1;
  2         86  
323 2 50 33     16 for my $block (@{$self->block_list}) {
324 2 50       58 next unless exists($block->{$x}) and exists($block->{$y});
325 2 50       10 $block->run_filters unless $block->is_filtered;
326             is($block->$x, $block->$y,
327             $block->name ? $block->name : ()
328             );
329             }
330             }
331              
332 0     0 0 0 sub run_is_deeply() {
333 0         0 (my ($self), @_) = find_my_self(@_);
334 0         0 $self->_assert_plan;
335 0         0 my ($x, $y) = $self->_section_names(@_);
  0         0  
336 0 0 0     0 for my $block (@{$self->block_list}) {
337 0 0       0 next unless exists($block->{$x}) and exists($block->{$y});
338 0 0       0 $block->run_filters unless $block->is_filtered;
339             is_deeply($block->$x, $block->$y,
340             $block->name ? $block->name : ()
341             );
342             }
343             }
344              
345 0     0 0 0 sub run_like() {
346 0         0 (my ($self), @_) = find_my_self(@_);
347 0         0 $self->_assert_plan;
348 0         0 my ($x, $y) = $self->_section_names(@_);
  0         0  
349 0 0 0     0 for my $block (@{$self->block_list}) {
350 0 0       0 next unless exists($block->{$x}) and defined($y);
351 0 0       0 $block->run_filters unless $block->is_filtered;
352 0 0       0 my $regexp = ref $y ? $y : $block->$y;
353             like($block->$x, $regexp,
354             $block->name ? $block->name : ()
355             );
356             }
357             }
358              
359 0     0 0 0 sub run_unlike() {
360 0         0 (my ($self), @_) = find_my_self(@_);
361 0         0 $self->_assert_plan;
362 0         0 my ($x, $y) = $self->_section_names(@_);
  0         0  
363 0 0 0     0 for my $block (@{$self->block_list}) {
364 0 0       0 next unless exists($block->{$x}) and defined($y);
365 0 0       0 $block->run_filters unless $block->is_filtered;
366 0 0       0 my $regexp = ref $y ? $y : $block->$y;
367             unlike($block->$x, $regexp,
368             $block->name ? $block->name : ()
369             );
370             }
371             }
372 2     2   4  
373 2         6 sub _pre_eval {
374 2 50       15 my $spec = shift;
375             return $spec unless $spec =~
376 0         0 s/\A\s*<<<(.*?)>>>\s*$//sm;
377 0         0 my $eval_code = $1;
378 0 0       0 eval "package main; $eval_code";
379 0         0 croak $@ if $@;
380             return $spec;
381             }
382 2     2   5  
383 2         58 sub _block_list_init {
384 2         9 my $spec = $self->spec;
385 2         60 $spec = $self->_pre_eval($spec);
386 2         118 my $cd = $self->block_delim;
387 2         16 my @hunks = ($spec =~ /^(\Q${cd}\E.*?(?=^\Q${cd}\E|\z))/msg);
388 2         66 my $blocks = $self->_choose_blocks(@hunks);
389 2         3 $self->block_list($blocks); # Need to set early for possible filter use
390 2         6 my $seq = 1;
391 2         54 for my $block (@$blocks) {
392 2         53 $block->blocks_object($self);
393             $block->seq_num($seq++);
394 2         13 }
395             return $blocks;
396             }
397 2     2   4  
398 2         6 sub _choose_blocks {
399 2         9 my $blocks = [];
400 2         14 for my $hunk (@_) {
401 2 50       9 my $block = $self->_make_block($hunk);
402 0 0       0 if (exists $block->{ONLY}) {
403             diag "I found ONLY: maybe you're debugging?"
404 0         0 unless $self->_no_diag_on_only;
405             return [$block];
406 2 50       16 }
407 2         6 next if exists $block->{SKIP};
408 2 50       16 push @$blocks, $block;
409 0         0 if (exists $block->{LAST}) {
410             return $blocks;
411             }
412 2         7 }
413             return $blocks;
414             }
415 4     4   7  
416 4         7 sub _check_reserved {
417 4 50 33     39 my $id = shift;
418             croak "'$id' is a reserved name. Use something else.\n"
419             if $reserved_section_names->{$id} or
420             $id =~ /^_/;
421             }
422 2     2   5  
423 2         11 sub _make_block {
424 2         65 my $hunk = shift;
425 2         55 my $cd = $self->block_delim;
426 2         11 my $dd = $self->data_delim;
427 2 50       59 my $block = $self->block_class->new;
428 2         8 $hunk =~ s/\A\Q${cd}\E[ \t]*(.*)\s+// or die;
429 2         67 my $name = $1;
430 2         13 my @parts = split /^\Q${dd}\E +\(?(\w+)\)? *(.*)?\n/m, $hunk;
431 2   50     21 my $description = shift @parts;
432 2 50       10 $description ||= '';
433 2         5 unless ($description =~ /\S/) {
434             $description = $name;
435 2         14 }
436 2         11 $description =~ s/\s*\z//;
437             $block->set_value(description => $description);
438 2         4
439 2         6 my $section_map = {};
440 2         15 my $section_order = [];
441 4         13 while (@parts) {
442 4         15 my ($type, $filters, $value) = splice(@parts, 0, 3);
443 4 50       38 $self->_check_reserved($type);
444 4 50       11 $value = '' unless defined $value;
445 4 50       13 $filters = '' unless defined $filters;
446 0 0       0 if ($filters =~ /:(\s|\z)/) {
447             croak "Extra lines not allowed in '$type' section"
448 0         0 if $value =~ /\S/;
449 0 0       0 ($filters, $value) = split /\s*:(?:\s+|\z)/, $filters, 2;
450 0         0 $value = '' unless defined $value;
451             $value =~ s/^\s*(.*?)\s*$/$1/;
452 4         14 }
453             $section_map->{$type} = {
454             filters => $filters,
455 4         9 };
456 4         11 push @$section_order, $type;
457             $block->set_value($type, $value);
458 2         9 }
459 2         6 $block->set_value(name => $name);
460 2         14 $block->set_value(_section_map => $section_map);
461 2         8 $block->set_value(_section_order => $section_order);
462             return $block;
463             }
464 2     2   5  
465 2 50       60 sub _spec_init {
466             return $self->_spec_string
467 2         8 if $self->_spec_string;
468 2         4 local $/;
469 2 50       64 my $spec;
470 0 0       0 if (my $spec_file = $self->_spec_file) {
471 0         0 open FILE, $spec_file or die $!;
472 0         0 $spec = ;
473             close FILE;
474             }
475 2         5 else {
476             $spec = do {
477 6     6   65 package main;
  6         12  
  6         3208  
478 2         56 no warnings 'once';
479             ;
480             };
481 2         15 }
482             return $spec;
483             }
484              
485 6     6   42 sub _strict_warnings() {
486 6         13 require Filter::Util::Call;
487             my $done = 0;
488             Filter::Util::Call::filter_add(
489 10 100   10   8111 sub {
490 6         16 return 0 if $done;
491 6         55 my ($data, $end) = ('', '');
492 102 50       175 while (my $status = Filter::Util::Call::filter_read()) {
493 102 100       203 return $status if $status < 0;
494 2         3 if (/^__(?:END|DATA)__\r?$/) {
495 2         4 $end = $_;
496             last;
497 100         130 }
498 100         369 $data .= $_;
499             $_ = '';
500 6         34 }
501 6         172 $_ = "use strict;use warnings;$data$end";
502             $done = 1;
503 6         49 }
504             );
505             }
506              
507 0     0 0 0 sub tie_output() {
508 0 0       0 my $handle = shift;
509 0         0 die "No buffer to tie" unless @_;
510             tie $handle, 'Test::Base::Handle', $_[0];
511             }
512 0     0 0 0  
513 0         0 sub no_diff {
514             $ENV{TEST_SHOW_NO_DIFFS} = 1;
515             }
516              
517             package Test::Base::Handle;
518              
519 0     0   0 sub TIEHANDLE() {
520 0         0 my $class = shift;
521             bless \ $_[0], $class;
522             }
523 0     0   0  
524 0         0 sub PRINT {
525             $$self .= $_ for @_;
526             }
527              
528             #===============================================================================
529             # Test::Base::Block
530             #
531             # This is the default class for accessing a Test::Base block object.
532             #===============================================================================
533             package Test::Base::Block;
534             our @ISA = qw(Spiffy);
535              
536             our @EXPORT = qw(block_accessor);
537 0     0   0  
538 0         0 sub AUTOLOAD {
539             return;
540             }
541              
542 20     20   36 sub block_accessor() {
543 6     6   43 my $accessor = shift;
  6         15  
  6         1248  
544 20 50       90 no strict 'refs';
545             return if defined &$accessor;
546 16     16   30 *$accessor = sub {
547 16 50       36 my $self = shift;
548 0         0 if (@_) {
549             Carp::croak "Not allowed to set values for '$accessor'";
550 16 50       20 }
  16         61  
551             my @list = @{$self->{$accessor} || []};
552 16 100       79 return wantarray
553             ? (@list)
554 20         124 : $list[0];
555             };
556             }
557              
558             block_accessor 'name';
559             block_accessor 'description';
560             Spiffy::field 'seq_num';
561             Spiffy::field 'is_filtered';
562             Spiffy::field 'blocks_object';
563             Spiffy::field 'original_values' => {};
564 26     26   38  
565 6     6   32 sub set_value {
  6         13  
  6         1383  
566 26         43 no strict 'refs';
567 26 100       103 my $accessor = shift;
568             block_accessor $accessor
569 26         190 unless defined &$accessor;
570             $self->{$accessor} = [@_];
571             }
572 2     2   4  
573 2         8 sub run_filters {
574 2         6 my $map = $self->_section_map;
575 2 50       52 my $order = $self->_section_order;
576             Carp::croak "Attempt to filter a block twice"
577 2         7 if $self->is_filtered;
578 4         16 for my $type (@$order) {
579 4         16 my $filters = $map->{$type}{filters};
580 4         138 my @value = $self->$type;
581 4         21 $self->original_values->{$type} = $value[0];
582 14 50       42 for my $filter ($self->_get_filters($type, $filters)) {
583             $Test::Base::Filter::arguments =
584 14         25 $filter =~ s/=(.*)$// ? $1 : undef;
585 6     6   38 my $function = "main::$filter";
  6         14  
  6         3643  
586 14 100       75 no strict 'refs';
587 2         8 if (defined &$function) {
588 2         6 local $_ = join '', @value;
589 2         14 my $old = $_;
590 2 50 33     646 @value = &$function(@value);
      33        
591             if (not(@value) or
592             @value == 1 and $value[0] =~ /\A(\d+|)\z/
593 0 0 0     0 ) {
594 0         0 if ($value[0] && $_ eq $old) {
595             Test::Base::diag("Filters returning numbers are supposed to do munging \$_: your filter '$function' apparently doesn't.");
596 0         0 }
597             @value = ($_);
598             }
599             }
600 12         297 else {
601 12 50       44 my $filter_object = $self->blocks_object->filter_class->new;
602             die "Can't find a function or method for '$filter' filter\n"
603 12         316 unless $filter_object->can($filter);
604 12         48 $filter_object->current_block($self);
605             @value = $filter_object->$filter(@value);
606             }
607             # Set the value after each filter since other filters may be
608 14         55 # introspecting.
609             $self->set_value($type, @value);
610             }
611 2         55 }
612             $self->is_filtered(1);
613             }
614 4     4   10  
615 4         9 sub _get_filters {
616 4   50     19 my $type = shift;
617 4         21 my $string = shift || '';
618 4         10 $string =~ s/\s*(.*?)\s*/$1/;
619 4   50     104 my @filters = ();
620 4 50       17 my $map_filters = $self->blocks_object->_filters_map->{$type} || [];
621 4         9 $map_filters = [ $map_filters ] unless ref $map_filters;
622 4         9 my @append = ();
623 4         94 for (
624             @{$self->blocks_object->_filters},
625             @$map_filters,
626             split(/\s+/, $string),
627 14         25 ) {
628 14 50       29 my $filter = $_;
629 14 50       45 last unless length $filter;
    50          
630 0         0 if ($filter =~ s/^-//) {
  0         0  
631             @filters = grep { $_ ne $filter } @filters;
632             }
633 0         0 elsif ($filter =~ s/^\+//) {
634             push @append, $filter;
635             }
636 14         38 else {
637             push @filters, $filter;
638             }
639 4         19 }
640             return @filters, @append;
641             }
642              
643             {
644             %$reserved_section_names = map {
645             ($_, 1);
646             } keys(%Test::Base::Block::), qw( new DESTROY );
647             }
648              
649             __DATA__