diff options
author | Anas Nashif <anas.nashif@intel.com> | 2012-12-27 19:00:44 -0800 |
---|---|---|
committer | Anas Nashif <anas.nashif@intel.com> | 2012-12-27 19:00:44 -0800 |
commit | 7a160a887342dbe0525b9a33c1a772ecf614edb8 (patch) | |
tree | 1ad6ed7be84d7167b90bb780e22b3448ff424fda | |
download | perl-Test-Pod-Coverage-7a160a887342dbe0525b9a33c1a772ecf614edb8.tar.gz perl-Test-Pod-Coverage-7a160a887342dbe0525b9a33c1a772ecf614edb8.tar.bz2 perl-Test-Pod-Coverage-7a160a887342dbe0525b9a33c1a772ecf614edb8.zip |
Imported Upstream version 1.08upstream/1.08
-rw-r--r-- | Changes | 60 | ||||
-rw-r--r-- | Coverage.pm | 305 | ||||
-rw-r--r-- | MANIFEST | 22 | ||||
-rw-r--r-- | META.yml | 13 | ||||
-rw-r--r-- | Makefile.PL | 16 | ||||
-rw-r--r-- | t/00.load.t | 7 | ||||
-rw-r--r-- | t/Nopod.pm | 9 | ||||
-rw-r--r-- | t/Nosymbols.pm | 13 | ||||
-rw-r--r-- | t/PC_Inherited.pm | 15 | ||||
-rw-r--r-- | t/PC_Inherits.pm | 13 | ||||
-rw-r--r-- | t/Privates.pm | 33 | ||||
-rw-r--r-- | t/Simple.pm | 31 | ||||
-rw-r--r-- | t/all_modules.t | 18 | ||||
-rw-r--r-- | t/all_pod_coverage_ok.t | 6 | ||||
-rw-r--r-- | t/alt_class.t | 21 | ||||
-rw-r--r-- | t/nopod.t | 16 | ||||
-rw-r--r-- | t/nosymbols.t | 24 | ||||
-rw-r--r-- | t/parms.t | 16 | ||||
-rw-r--r-- | t/pod.t | 6 | ||||
-rw-r--r-- | t/privates.t | 37 | ||||
-rw-r--r-- | t/self.t | 7 | ||||
-rw-r--r-- | t/simple.t | 21 |
22 files changed, 709 insertions, 0 deletions
@@ -0,0 +1,60 @@ +Revision history for Test::Pod::Coverage + +1.08 Wed Jan 25 21:59:49 CST 2006 + [FIXES] + * File and directory names may now contain periods and hyphens. + * Now exports all_modules(). + +1.07_01 Wed Dec 28 23:10:31 CST 2005 + [ENHANCEMENTS] + * Can now use an alternate class that implements the Pod::Coverage + interface. This is mostly useful for avoiding the necessity to + redocument or itemize overriden methods in a subclass by using + Pod::Coverage::CountParents. Thanks to Ricardo Signes. + +1.06 Tue Jun 22 16:51:42 CDT 2004 + [ENHANCEMENTS] + * Looks in blib/ if there is one, otherwise looks in lib/ + * Doesn't report "no public symbols" unless verbose mode is on. + * Thanks to David Wheeler and Shawn Sorichetti for nudging. + This behavior will be in Test::Pod soon, too. + +1.04 Sat May 1 00:06:14 CDT 2004 + [FIXES] + * Now it runs taint-safe. I was not untainting the filename. + +1.02 Fri Apr 30 23:27:23 CDT 2004 + [FIXES] + * Fixed a warning in all_modules() under 5.8.3 + +1.00 Wed Apr 28 23:50:19 CDT 2004 + [ENHANCEMENTS] + * Now runs taint-safe. + * No longer uses File::Find. + +0.08 Fri Feb 13 23:13:21 CST 2004 + [ENHANCEMENTS] + * Added all_pod_coverage_ok(), and all_modules() for support. + +0.06 Jan 27 2004 + [ENHANCEMENTS] + * Files with all pod and no symbols is no longer an error. + * Enhanced some of the error messages. + +0.04 Sun Jan 18 21:51:59 CST 2004 + [ENHANCEMENTS] + * Now lists the naked subroutines in the error message. + + +0.03 Sat Jan 17 11:14:56 CST 2004 + [ENHANCEMENTS] + * Now says what module has a problem if it can't find any + POD. Thanks, Barbie. + + [INTERNALS] + * Added a couple more tests to bring my test coverage up + to 100%, according to Devel::Cover. Whoo! + +0.02 + First version with the new reasonable API on pod_coverage_ok(). + If you got in on 0.01, switch now. diff --git a/Coverage.pm b/Coverage.pm new file mode 100644 index 0000000..fee0eb4 --- /dev/null +++ b/Coverage.pm @@ -0,0 +1,305 @@ +package Test::Pod::Coverage; + +=head1 NAME + +Test::Pod::Coverage - Check for pod coverage in your distribution. + +=head1 VERSION + +Version 1.08 + +=cut + +our $VERSION = "1.08"; + +=head1 SYNOPSIS + +Checks for POD coverage in files for your distribution. + + use Test::Pod::Coverage tests=>1; + pod_coverage_ok( "Foo::Bar", "Foo::Bar is covered" ); + +Can also be called with L<Pod::Coverage> parms. + + use Test::Pod::Coverage tests=>1; + pod_coverage_ok( + "Foo::Bar", + { also_private => [ qr/^[A-Z_]+$/ ], }, + "Foo::Bar, with all-caps functions as privates", + ); + +The L<Pod::Coverage> parms are also useful for subclasses that don't +re-document the parent class's methods. Here's an example from +L<Mail::SRS>. + + pod_coverage_ok( "Mail::SRS" ); # No exceptions + + # Define the three overridden methods. + my $trustme = { trustme => [qr/^(new|parse|compile)$/] }; + pod_coverage_ok( "Mail::SRS::DB", $trustme ); + pod_coverage_ok( "Mail::SRS::Guarded", $trustme ); + pod_coverage_ok( "Mail::SRS::Reversable", $trustme ); + pod_coverage_ok( "Mail::SRS::Shortcut", $trustme ); + +Alternately, you could use L<Pod::Coverage::CountParents>, which always allows +a subclass to reimplement its parents' methods without redocumenting them. For +example: + + my $trustparents = { coverage_class => 'Pod::Coverage::CountParents' }; + pod_coverage_ok( "IO::Handle::Frayed", $trustparents ); + +(The C<coverage_class> parameter is not passed to the coverage class with other +parameters.) + +If you want POD coverage for your module, but don't want to make +Test::Pod::Coverage a prerequisite for installing, create the following +as your F<t/pod-coverage.t> file: + + use Test::More; + eval "use Test::Pod::Coverage"; + plan skip_all => "Test::Pod::Coverage required for testing pod coverage" if $@; + + plan tests => 1; + pod_coverage_ok( "Pod::Master::Html"); + +Finally, Module authors can include the following in a F<t/pod-coverage.t> +file and have C<Test::Pod::Coverage> automatically find and check all +modules in the module distribution: + + use Test::More; + eval "use Test::Pod::Coverage 1.00"; + plan skip_all => "Test::Pod::Coverage 1.00 required for testing POD coverage" if $@; + all_pod_coverage_ok(); + +=cut + +use strict; +use warnings; + +use Pod::Coverage; +use Test::Builder; + +my $Test = Test::Builder->new; + +sub import { + my $self = shift; + my $caller = caller; + no strict 'refs'; + *{$caller.'::pod_coverage_ok'} = \&pod_coverage_ok; + *{$caller.'::all_pod_coverage_ok'} = \&all_pod_coverage_ok; + *{$caller.'::all_modules'} = \&all_modules; + + $Test->exported_to($caller); + $Test->plan(@_); +} + +=head1 FUNCTIONS + +All functions listed below are exported to the calling namespace. + +=head2 all_pod_coverage_ok( [$parms, ] $msg ) + +Checks that the POD code in all modules in the distro have proper POD +coverage. + +If the I<$parms> hashref if passed in, they're passed into the +C<Pod::Coverage> object that the function uses. Check the +L<Pod::Coverage> manual for what those can be. + +The exception is the C<coverage_class> parameter, which specifies a class to +use for coverage testing. It defaults to C<Pod::Coverage>. + +=cut + +sub all_pod_coverage_ok { + my $parms = (@_ && (ref $_[0] eq "HASH")) ? shift : {}; + my $msg = shift; + + my $ok = 1; + my @modules = all_modules(); + if ( @modules ) { + $Test->plan( tests => scalar @modules ); + + for my $module ( @modules ) { + my $thismsg = defined $msg ? $msg : "Pod coverage on $module"; + + my $thisok = pod_coverage_ok( $module, $parms, $thismsg ); + $ok = 0 unless $thisok; + } + } + else { + $Test->plan( tests => 1 ); + $Test->ok( 1, "No modules found." ); + } + + return $ok; +} + + +=head2 pod_coverage_ok( $module, [$parms, ] $msg ) + +Checks that the POD code in I<$module> has proper POD coverage. + +If the I<$parms> hashref if passed in, they're passed into the +C<Pod::Coverage> object that the function uses. Check the +L<Pod::Coverage> manual for what those can be. + +The exception is the C<coverage_class> parameter, which specifies a class to +use for coverage testing. It defaults to C<Pod::Coverage>. + +=cut + +sub pod_coverage_ok { + my $module = shift; + my %parms = (@_ && (ref $_[0] eq "HASH")) ? %{(shift)} : (); + my $msg = @_ ? shift : "Pod coverage on $module"; + + my $pc_class = (delete $parms{coverage_class}) || 'Pod::Coverage'; + eval "require $pc_class" or die $@; + + my $pc = $pc_class->new( package => $module, %parms ); + + my $rating = $pc->coverage; + my $ok; + if ( defined $rating ) { + $ok = ($rating == 1); + $Test->ok( $ok, $msg ); + if ( !$ok ) { + my @nakies = sort $pc->naked; + my $s = @nakies == 1 ? "" : "s"; + $Test->diag( + sprintf( "Coverage for %s is %3.1f%%, with %d naked subroutine$s:", + $module, $rating*100, scalar @nakies ) ); + $Test->diag( "\t$_" ) for @nakies; + } + } + else { # No symbols + my $why = $pc->why_unrated; + my $nopublics = ( $why =~ "no public symbols defined" ); + my $verbose = $ENV{HARNESS_VERBOSE} || 0; + $ok = $nopublics; + $Test->ok( $ok, $msg ); + $Test->diag( "$module: $why" ) unless ( $nopublics && !$verbose ); + } + + return $ok; +} + +=head2 all_modules( [@dirs] ) + +Returns a list of all modules in I<$dir> and in directories below. If +no directories are passed, it defaults to F<blib> if F<blib> exists, +or F<lib> if not. + +Note that the modules are as "Foo::Bar", not "Foo/Bar.pm". + +The order of the files returned is machine-dependent. If you want them +sorted, you'll have to sort them yourself. + +=cut + +sub all_modules { + my @starters = @_ ? @_ : _starting_points(); + my %starters = map {$_,1} @starters; + + my @queue = @starters; + + my @modules; + while ( @queue ) { + my $file = shift @queue; + if ( -d $file ) { + local *DH; + opendir DH, $file or next; + my @newfiles = readdir DH; + closedir DH; + + @newfiles = File::Spec->no_upwards( @newfiles ); + @newfiles = grep { $_ ne "CVS" && $_ ne ".svn" } @newfiles; + + push @queue, map "$file/$_", @newfiles; + } + if ( -f $file ) { + next unless $file =~ /\.pm$/; + + my @parts = File::Spec->splitdir( $file ); + shift @parts if @parts && exists $starters{$parts[0]}; + shift @parts if @parts && $parts[0] eq "lib"; + $parts[-1] =~ s/\.pm$// if @parts; + + # Untaint the parts + for ( @parts ) { + if ( /^([a-zA-Z0-9_\.\-]+)$/ && ($_ eq $1) ) { + $_ = $1; # Untaint the original + } + else { + die qq{Invalid and untaintable filename "$file"!}; + } + } + my $module = join( "::", @parts ); + push( @modules, $module ); + } + } # while + + return @modules; +} + +sub _starting_points { + return 'blib' if -e 'blib'; + return 'lib'; +} + +=head1 BUGS + +Please report any bugs or feature requests to +C<bug-test-pod-coverage at rt.cpan.org>, or through the web interface at +L<http://rt.cpan.org/NoAuth/ReportBug.html?Queue=Test-Pod-Coverage>. +I will be notified, and then you'll automatically be notified of progress on +your bug as I make changes. + +=head1 SUPPORT + +You can find documentation for this module with the perldoc command. + + perldoc Test::Pod::Coverage + +You can also look for information at: + +=over 4 + +=item * AnnoCPAN: Annotated CPAN documentation + +L<http://annocpan.org/dist/Test-Pod-Coverage> + +=item * CPAN Ratings + +L<http://cpanratings.perl.org/d/Test-Pod-Coverage> + +=item * RT: CPAN's request tracker + +L<http://rt.cpan.org/NoAuth/Bugs.html?Dist=Test-Pod-Coverage> + +=item * Search CPAN + +L<http://search.cpan.org/dist/Test-Pod-Coverage> + +=back + +=head1 AUTHOR + +Written by Andy Lester, C<< <andy at petdance.com> >>. + +=head1 ACKNOWLEDGEMENTS + +Thanks to Ricardo Signes for patches, and Richard Clamp for +writing Pod::Coverage. + +=head1 COPYRIGHT & LICENSE + +Copyright 2006, Andy Lester, All Rights Reserved. + +You may use, modify, and distribute this package under the +same terms as Perl itself. + +=cut + +1; diff --git a/MANIFEST b/MANIFEST new file mode 100644 index 0000000..d5eb182 --- /dev/null +++ b/MANIFEST @@ -0,0 +1,22 @@ +Changes +Coverage.pm +MANIFEST +META.yml +Makefile.PL +t/00.load.t +t/all_pod_coverage_ok.t +t/alt_class.t +t/PC_Inherited.pm +t/PC_Inherits.pm +t/Nopod.pm +t/Nosymbols.pm +t/Privates.pm +t/Simple.pm +t/all_modules.t +t/nopod.t +t/nosymbols.t +t/parms.t +t/pod.t +t/privates.t +t/self.t +t/simple.t diff --git a/META.yml b/META.yml new file mode 100644 index 0000000..0644c72 --- /dev/null +++ b/META.yml @@ -0,0 +1,13 @@ +# http://module-build.sourceforge.net/META-spec.html +#XXXXXXX This is a prototype!!! It will change in the future!!! XXXXX# +name: Test-Pod-Coverage +version: 1.08 +version_from: Coverage.pm +installdirs: site +requires: + Pod::Coverage: 0 + Test::Builder::Tester: 0 + Test::More: 0 + +distribution_type: module +generated_by: ExtUtils::MakeMaker version 6.30 diff --git a/Makefile.PL b/Makefile.PL new file mode 100644 index 0000000..d10eabb --- /dev/null +++ b/Makefile.PL @@ -0,0 +1,16 @@ +use strict; +use warnings; +use ExtUtils::MakeMaker; + +WriteMakefile( + NAME => 'Test::Pod::Coverage', + VERSION_FROM => 'Coverage.pm', + ABSTRACT => "Check for pod coverage in your distribution", + PREREQ_PM => { + 'Pod::Coverage' => 0, + 'Test::More' => 0, + 'Test::Builder::Tester' => 0, + }, + dist => { COMPRESS => 'gzip -9f', SUFFIX => 'gz', }, + clean => { FILES => 'Test-Pod-Coverage-*' }, +); diff --git a/t/00.load.t b/t/00.load.t new file mode 100644 index 0000000..37beeb6 --- /dev/null +++ b/t/00.load.t @@ -0,0 +1,7 @@ +#!perl -T + +use Test::More tests => 1; + +use_ok( 'Test::Pod::Coverage' ); + +diag( "Testing Test::Pod::Coverage $Test::Pod::Coverage::VERSION" ); diff --git a/t/Nopod.pm b/t/Nopod.pm new file mode 100644 index 0000000..e8700ab --- /dev/null +++ b/t/Nopod.pm @@ -0,0 +1,9 @@ +package Nopod; + +# Documentation is for wimps! +# +sub foo {} +sub bar {} +sub baz {} + +1; diff --git a/t/Nosymbols.pm b/t/Nosymbols.pm new file mode 100644 index 0000000..8db35cc --- /dev/null +++ b/t/Nosymbols.pm @@ -0,0 +1,13 @@ +package Nosymbols; + +=head1 NAME + +This is a dummy module with all POD, no symbols. + +=head1 DESCRIPTION + +This is a pod file without errors. + +=cut + +1; diff --git a/t/PC_Inherited.pm b/t/PC_Inherited.pm new file mode 100644 index 0000000..26e545b --- /dev/null +++ b/t/PC_Inherited.pm @@ -0,0 +1,15 @@ +package PC_Inherited; + +=head1 NAME + +PC_Inherited - we write docs so you don't have to! + +=head2 C< new > + + ... + +=cut + +sub new { } + +1; diff --git a/t/PC_Inherits.pm b/t/PC_Inherits.pm new file mode 100644 index 0000000..fa3f108 --- /dev/null +++ b/t/PC_Inherits.pm @@ -0,0 +1,13 @@ +package PC_Inherits; +use base qw(PC_Inherited); + +=head1 NAME + +PC_Inherit - inherits and doesn't document parent things! + +=cut + +# documented in parent; stupid to document here, too! +sub new { } + +1; diff --git a/t/Privates.pm b/t/Privates.pm new file mode 100644 index 0000000..e690563 --- /dev/null +++ b/t/Privates.pm @@ -0,0 +1,33 @@ +package Privates; + +sub foo {} +sub bar {} +sub baz {} +sub INTERNAL_THING {} +sub INTERNAL_DOODAD {} + +1; +__END__ + +# test module - three subs, one without, one with an item, one with a head2 + +=head2 Methods + +=over + +=item foo + +this is foo + +=back + +=head2 bar + +The bar is just a throwaway. + +=head2 baz + +baz is very important + +=cut + diff --git a/t/Simple.pm b/t/Simple.pm new file mode 100644 index 0000000..6d6b6c6 --- /dev/null +++ b/t/Simple.pm @@ -0,0 +1,31 @@ +package Simple; + +sub foo {} +sub bar {} +sub baz {} + +1; +__END__ + +# test module - three subs, one without, one with an item, one with a head2 + +=head2 Methods + +=over + +=item foo + +this is foo + +=back + +=head2 bar + +The bar is just a throwaway. + +=head2 baz + +baz is very important + +=cut + diff --git a/t/all_modules.t b/t/all_modules.t new file mode 100644 index 0000000..ae3432b --- /dev/null +++ b/t/all_modules.t @@ -0,0 +1,18 @@ +#!perl -T + +use strict; + +use Test::More tests => 2; + +BEGIN { + use_ok( "Test::Pod::Coverage" ); +} + +my @files = Test::Pod::Coverage::all_modules( "blib" ); + +# The expected files have slashes, not File::Spec separators, because +# that's how File::Find does it. +my @expected = qw( Test::Pod::Coverage ); +@files = sort @files; +@expected = sort @expected; +is_deeply( \@files, \@expected, "Got all the distro files" ); diff --git a/t/all_pod_coverage_ok.t b/t/all_pod_coverage_ok.t new file mode 100644 index 0000000..9c3d88c --- /dev/null +++ b/t/all_pod_coverage_ok.t @@ -0,0 +1,6 @@ +#!perl -T + +# This is the most basic form that most people will use. + +use Test::Pod::Coverage; +all_pod_coverage_ok(); diff --git a/t/alt_class.t b/t/alt_class.t new file mode 100644 index 0000000..83801b0 --- /dev/null +++ b/t/alt_class.t @@ -0,0 +1,21 @@ +#!perl -T + +use strict; +use lib "t"; +use Test::More tests=>2; +use Test::Builder::Tester; + +BEGIN { use_ok( 'Test::Pod::Coverage' ); } + +# the follow test checks that PC_Inherits.pm is fully covered, which it is not +# -- unless you count the documentation of its parent, PC_Inherited; we do this +# with the Pod::Coverage::CountParents subclass of Pod::Coverage -- so, if this +# test passes, it means the subclass was, in fact, used +test_out( "ok 1 - Checking PC_Inherits" ); +pod_coverage_ok( + "PC_Inherits", + { coverage_class => 'Pod::Coverage::CountParents' }, + "Checking PC_Inherits", +); + +test_test( "allows alternate Pod::Coverage class" ); diff --git a/t/nopod.t b/t/nopod.t new file mode 100644 index 0000000..d5bebe8 --- /dev/null +++ b/t/nopod.t @@ -0,0 +1,16 @@ +#!perl -T + +use strict; +use lib "t"; +use Test::More tests=>2; +use Test::Builder::Tester; + +BEGIN { + use_ok( 'Test::Pod::Coverage' ); +} + +test_out( "not ok 1 - Checking Nopod" ); +test_fail(+2); +test_diag( "Nopod: couldn't find pod" ); +pod_coverage_ok( "Nopod", "Checking Nopod" ); +test_test( "Handles files with no pod at all" ); diff --git a/t/nosymbols.t b/t/nosymbols.t new file mode 100644 index 0000000..02d2c41 --- /dev/null +++ b/t/nosymbols.t @@ -0,0 +1,24 @@ +#!perl -T + +use strict; +use lib "t"; +use Test::More tests => 3; +use Test::Builder::Tester; + +BEGIN { + use_ok( 'Test::Pod::Coverage' ); +} + +NO_VERBOSE: { + test_out( "ok 1 - Checking Nosymbols" ); + pod_coverage_ok( "Nosymbols", "Checking Nosymbols" ); + test_test( "Handles files with no symbols" ); +} + +VERBOSE: { + local $ENV{HARNESS_VERBOSE} = 1; + test_out( "ok 1 - Checking Nosymbols" ); + test_diag( "Nosymbols: no public symbols defined" ); + pod_coverage_ok( "Nosymbols", "Checking Nosymbols" ); + test_test( "Handles files with no symbols" ); +} diff --git a/t/parms.t b/t/parms.t new file mode 100644 index 0000000..5076516 --- /dev/null +++ b/t/parms.t @@ -0,0 +1,16 @@ +#!perl -T + +use lib "t"; +use strict; +use Test::More tests=>2; +use Test::Builder::Tester; + +BEGIN { + use_ok( 'Test::Pod::Coverage' ); +} + +OPTIONAL_MESSAGE: { + test_out( "ok 1 - Pod coverage on Simple" ); + pod_coverage_ok( "Simple" ); + test_test( "Simple runs under T:B:T" ); +} @@ -0,0 +1,6 @@ +#!perl -T + +use Test::More; +eval "use Test::Pod 1.14"; +plan skip_all => "Test::Pod 1.14 required for testing POD" if $@; +all_pod_files_ok(); diff --git a/t/privates.t b/t/privates.t new file mode 100644 index 0000000..d8fa2cc --- /dev/null +++ b/t/privates.t @@ -0,0 +1,37 @@ +#!perl -T + +use strict; +use lib "t"; +use Test::More tests=>4; +use Test::Builder::Tester; + +BEGIN { + use_ok( 'Test::Pod::Coverage' ); +} + +MISSING_FUNCS: { + test_out( "not ok 1 - Privates fails" ); + test_fail(+4); + test_diag( "Coverage for Privates is 60.0%, with 2 naked subroutines:" ); + test_diag( "\tINTERNAL_DOODAD" ); + test_diag( "\tINTERNAL_THING" ); + pod_coverage_ok( "Privates", "Privates fails" ); + test_test( "Should fail at 60%" ); +} + +SPECIFIED_PRIVATES: { + test_out( "ok 1 - Privates works w/a custom PC object" ); + pod_coverage_ok( + "Privates", + { also_private => [ qr/^[A-Z_]+$/ ], }, + "Privates works w/a custom PC object" + ); + test_test( "Trying to pass PC object" ); +} + +SPECIFIED_PRIVATES_NAKED: { + pod_coverage_ok( + "Privates", + { also_private => [ qr/^[A-Z_]+$/ ], }, + ); +} diff --git a/t/self.t b/t/self.t new file mode 100644 index 0000000..1d09722 --- /dev/null +++ b/t/self.t @@ -0,0 +1,7 @@ +#!perl -T + +use lib "t"; +use strict; +use Test::Pod::Coverage tests=>1; + +pod_coverage_ok( "Test::Pod::Coverage", "T:P:C itself is OK" ); diff --git a/t/simple.t b/t/simple.t new file mode 100644 index 0000000..ed01aed --- /dev/null +++ b/t/simple.t @@ -0,0 +1,21 @@ +#!perl -T + +use lib "t"; +use strict; +use Test::More tests=>4; +use Test::Builder::Tester; + +BEGIN { + use_ok( 'Test::Pod::Coverage' ); +} + +pod_coverage_ok( "Simple", "Simple is OK" ); + +# Now try it under T:B:T +test_out( "ok 1 - Simple is still OK" ); +pod_coverage_ok( "Simple", "Simple is still OK" ); +test_test( "Simple runs under T:B:T" ); + +test_out( "ok 1 - Pod coverage on Simple" ); +pod_coverage_ok( "Simple" ); +test_test( "Simple runs under T:B:T" ); |