This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
Update Test-Simple to CPAN version 1.001002
[perl5.git] / cpan / Test-Simple / lib / Test / Builder / Module.pm
1 package Test::Builder::Module;
2
3 use strict;
4
5 use Test::Builder 0.99;
6
7 require Exporter;
8 our @ISA = qw(Exporter);
9
10 our $VERSION = '1.001002';
11 $VERSION = eval $VERSION;      ## no critic (BuiltinFunctions::ProhibitStringyEval)
12
13
14 =head1 NAME
15
16 Test::Builder::Module - Base class for test modules
17
18 =head1 SYNOPSIS
19
20   # Emulates Test::Simple
21   package Your::Module;
22
23   my $CLASS = __PACKAGE__;
24
25   use base 'Test::Builder::Module';
26   @EXPORT = qw(ok);
27
28   sub ok ($;$) {
29       my $tb = $CLASS->builder;
30       return $tb->ok(@_);
31   }
32   
33   1;
34
35
36 =head1 DESCRIPTION
37
38 This is a superclass for Test::Builder-based modules.  It provides a
39 handful of common functionality and a method of getting at the underlying
40 Test::Builder object.
41
42
43 =head2 Importing
44
45 Test::Builder::Module is a subclass of Exporter which means your
46 module is also a subclass of Exporter.  @EXPORT, @EXPORT_OK, etc...
47 all act normally.
48
49 A few methods are provided to do the C<use Your::Module tests => 23> part
50 for you.
51
52 =head3 import
53
54 Test::Builder::Module provides an import() method which acts in the
55 same basic way as Test::More's, setting the plan and controlling
56 exporting of functions and variables.  This allows your module to set
57 the plan independent of Test::More.
58
59 All arguments passed to import() are passed onto 
60 C<< Your::Module->builder->plan() >> with the exception of 
61 C<< import =>[qw(things to import)] >>.
62
63     use Your::Module import => [qw(this that)], tests => 23;
64
65 says to import the functions this() and that() as well as set the plan
66 to be 23 tests.
67
68 import() also sets the exported_to() attribute of your builder to be
69 the caller of the import() function.
70
71 Additional behaviors can be added to your import() method by overriding
72 import_extra().
73
74 =cut
75
76 sub import {
77     my($class) = shift;
78
79     # Don't run all this when loading ourself.
80     return 1 if $class eq 'Test::Builder::Module';
81
82     my $test = $class->builder;
83
84     my $caller = caller;
85
86     $test->exported_to($caller);
87
88     $class->import_extra( \@_ );
89     my(@imports) = $class->_strip_imports( \@_ );
90
91     $test->plan(@_);
92
93     $class->export_to_level( 1, $class, @imports );
94 }
95
96 sub _strip_imports {
97     my $class = shift;
98     my $list  = shift;
99
100     my @imports = ();
101     my @other   = ();
102     my $idx     = 0;
103     while( $idx <= $#{$list} ) {
104         my $item = $list->[$idx];
105
106         if( defined $item and $item eq 'import' ) {
107             push @imports, @{ $list->[ $idx + 1 ] };
108             $idx++;
109         }
110         else {
111             push @other, $item;
112         }
113
114         $idx++;
115     }
116
117     @$list = @other;
118
119     return @imports;
120 }
121
122 =head3 import_extra
123
124     Your::Module->import_extra(\@import_args);
125
126 import_extra() is called by import().  It provides an opportunity for you
127 to add behaviors to your module based on its import list.
128
129 Any extra arguments which shouldn't be passed on to plan() should be 
130 stripped off by this method.
131
132 See Test::More for an example of its use.
133
134 B<NOTE> This mechanism is I<VERY ALPHA AND LIKELY TO CHANGE> as it
135 feels like a bit of an ugly hack in its current form.
136
137 =cut
138
139 sub import_extra { }
140
141 =head2 Builder
142
143 Test::Builder::Module provides some methods of getting at the underlying
144 Test::Builder object.
145
146 =head3 builder
147
148   my $builder = Your::Class->builder;
149
150 This method returns the Test::Builder object associated with Your::Class.
151 It is not a constructor so you can call it as often as you like.
152
153 This is the preferred way to get the Test::Builder object.  You should
154 I<not> get it via C<< Test::Builder->new >> as was previously
155 recommended.
156
157 The object returned by builder() may change at runtime so you should
158 call builder() inside each function rather than store it in a global.
159
160   sub ok {
161       my $builder = Your::Class->builder;
162
163       return $builder->ok(@_);
164   }
165
166
167 =cut
168
169 sub builder {
170     return Test::Builder->new;
171 }
172
173 1;