diff --git a/Changes b/Changes
new file mode 100644
index 0000000..46b4448
--- /dev/null
+++ b/Changes
@@ -0,0 +1,88 @@
+Revision history for Perl module Test::Pod::Coverage
+
+1.10 2014-07-17 NEILB
+    - Changed license to Artistic 2.0, at PETDANCE's request.
+    - Added README
+    - Moved Coverage.pm to lib/Test/Pod/Coverage.pm
+    - Min perl version now set to 5.006 in both code and dist metadata.
+      Addresses RT#21564 from ANDK++
+    - Added DESCRIPTION section to pod (RT#28715 JEREMIAH++),
+      and changed to a minimal SYNOPSIS, with everything else moved
+      to the DESCRIPTION.
+    - The "no verbose" tests in t/nosymbols.t weren't ensuring that the
+      tests were running with HARNESS_VERBOSE set to false. You could set
+      that true in your environment and break the test.
+      RT#53947 - thanks to Pete Armstrong.
+    - Makefile.PL: Ensured all prereqs listed in PREREQ_PM,
+      and TEST_REQUIRES set if a recent enough ExtUtils::MakeMaker.
+    - Added github repo to pod and dist metadata
+    - Deleted the old META.yml, so new MYMETA.{yml,json} will be generated.
+    - Reformatted as per CPAN::Changes::Spec
+
+1.09_01 2014-07-08 NEILB
+    - Specified license as 'Perl' in metadata, to match doc.
+    - All of the changes in 1.10 were first done in this developer release,
+      apart from the change to Artistic License 2.0.
+
+1.08 2006-01-26 PETDANCE
+    [FIXES]
+    - File and directory names may now contain periods and hyphens.
+    - Now exports all_modules().
+
+1.07_01 2005-12-29 PETDANCE
+    [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 2004-06-22 PETDANCE
+    [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 2004-05-01 PETDANCE
+    [FIXES]
+    - Now it runs taint-safe.  I was not untainting the filename.
+
+1.02 2004-05-01 PETDANCE
+    [FIXES]
+    - Fixed a warning in all_modules() under 5.8.3
+
+1.00 2004-04-29 PETDANCE
+    [ENHANCEMENTS]
+    - Now runs taint-safe.
+    - No longer uses File::Find.
+
+0.08 2004-02-14 PETDANCE
+    [ENHANCEMENTS]
+    - Added all_pod_coverage_ok(), and all_modules() for support.
+
+0.06 2004-01-27 PETDANCE
+    [ENHANCEMENTS]
+    - Files with all pod and no symbols is no longer an error.
+    - Enhanced some of the error messages.
+
+0.04 2004-01-19 PETDANCE
+    [ENHANCEMENTS]
+    - Now lists the naked subroutines in the error message.
+
+
+0.03 2004-01-17 PETDANCE (not released)
+    [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 2004-01-05 PETDANCE
+    - First version with the new reasonable API on pod_coverage_ok().
+      If you got in on 0.01, switch now.
+
+0.01 2004-01-04 PETDANCE
+    - First release to CPAN
+
diff --git a/MANIFEST b/MANIFEST
new file mode 100644
index 0000000..ce68162
--- /dev/null
+++ b/MANIFEST
@@ -0,0 +1,24 @@
+Changes
+lib/Test/Pod/Coverage.pm
+MANIFEST
+README
+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
+META.yml                                 Module YAML meta-data (added by MakeMaker)
+META.json                                Module JSON meta-data (added by MakeMaker)
diff --git a/META.json b/META.json
new file mode 100644
index 0000000..03bb46c
--- /dev/null
+++ b/META.json
@@ -0,0 +1,59 @@
+{
+   "abstract" : "Check for pod coverage in your distribution",
+   "author" : [
+      "unknown"
+   ],
+   "dynamic_config" : 1,
+   "generated_by" : "ExtUtils::MakeMaker version 6.98, CPAN::Meta::Converter version 2.141170",
+   "license" : [
+      "artistic_2"
+   ],
+   "meta-spec" : {
+      "url" : "http://search.cpan.org/perldoc?CPAN::Meta::Spec",
+      "version" : "2"
+   },
+   "name" : "Test-Pod-Coverage",
+   "no_index" : {
+      "directory" : [
+         "t",
+         "inc"
+      ]
+   },
+   "prereqs" : {
+      "build" : {
+         "requires" : {
+            "ExtUtils::MakeMaker" : "0"
+         }
+      },
+      "configure" : {
+         "requires" : {
+            "ExtUtils::MakeMaker" : "0"
+         }
+      },
+      "runtime" : {
+         "requires" : {
+            "Pod::Coverage" : "0",
+            "Test::Builder" : "0",
+            "perl" : "5.006",
+            "strict" : "0",
+            "warnings" : "0"
+         }
+      },
+      "test" : {
+         "requires" : {
+            "Test::Builder::Tester" : "0",
+            "Test::More" : "0",
+            "lib" : "0"
+         }
+      }
+   },
+   "release_status" : "stable",
+   "resources" : {
+      "repository" : {
+         "type" : "git",
+         "url" : "git://github.com/neilbowers/Test-Pod-Coverage.git",
+         "web" : "https://github.com/neilbowers/Test-Pod-Coverage"
+      }
+   },
+   "version" : "1.10"
+}
diff --git a/META.yml b/META.yml
new file mode 100644
index 0000000..d73ad4c
--- /dev/null
+++ b/META.yml
@@ -0,0 +1,31 @@
+---
+abstract: 'Check for pod coverage in your distribution'
+author:
+  - unknown
+build_requires:
+  ExtUtils::MakeMaker: '0'
+  Test::Builder::Tester: '0'
+  Test::More: '0'
+  lib: '0'
+configure_requires:
+  ExtUtils::MakeMaker: '0'
+dynamic_config: 1
+generated_by: 'ExtUtils::MakeMaker version 6.98, CPAN::Meta::Converter version 2.141170'
+license: artistic_2
+meta-spec:
+  url: http://module-build.sourceforge.net/META-spec-v1.4.html
+  version: '1.4'
+name: Test-Pod-Coverage
+no_index:
+  directory:
+    - t
+    - inc
+requires:
+  Pod::Coverage: '0'
+  Test::Builder: '0'
+  perl: '5.006'
+  strict: '0'
+  warnings: '0'
+resources:
+  repository: git://github.com/neilbowers/Test-Pod-Coverage.git
+version: '1.10'
diff --git a/Makefile.PL b/Makefile.PL
new file mode 100644
index 0000000..fa93ea9
--- /dev/null
+++ b/Makefile.PL
@@ -0,0 +1,57 @@
+use strict;
+use warnings;
+use ExtUtils::MakeMaker;
+
+my $mm_ver = $ExtUtils::MakeMaker::VERSION;
+if ($mm_ver =~ /_/) {
+    $mm_ver = eval $mm_ver;
+    die $@ if $@;
+}
+
+my @REQUIRES = (
+    'strict'        => 0,
+    'warnings'      => 0,
+    'Pod::Coverage' => 0,
+    'Test::Builder' => 0,
+);
+
+my @TEST_REQUIRES = (
+    'Test::Builder::Tester' => 0,
+    'Test::More'            => 0,
+    'lib'                   => 0,
+);
+
+push(@REQUIRES, @TEST_REQUIRES) if $mm_ver < 6.64;
+
+WriteMakefile(
+    NAME                => 'Test::Pod::Coverage',
+    VERSION_FROM        => 'lib/Test/Pod/Coverage.pm',
+    ABSTRACT            => "Check for pod coverage in your distribution",
+    PREREQ_PM           => { @REQUIRES },
+
+    ($mm_ver >= 6.64
+        ? (TEST_REQUIRES => { @TEST_REQUIRES })
+        : ()
+    ),
+
+    ($mm_ver >= 6.48
+        ? (MIN_PERL_VERSION => 5.006)
+        : ()
+    ),
+
+    ($mm_ver >= 6.31 ? (LICENSE => 'artistic_2') : ()),
+
+    ($mm_ver <= 6.45 ? () : (META_MERGE => {
+        'meta-spec' => { version => 2 },
+        resources => {
+            repository  => {
+                type => 'git',
+                web  => 'https://github.com/neilbowers/Test-Pod-Coverage',
+                url  => 'git://github.com/neilbowers/Test-Pod-Coverage.git',
+            },
+        },
+    })),
+
+    dist                => { COMPRESS => 'gzip -9f', SUFFIX => 'gz', },
+    clean               => { FILES => 'Test-Pod-Coverage-*' },
+);
diff --git a/README b/README
new file mode 100644
index 0000000..e963fea
--- /dev/null
+++ b/README
@@ -0,0 +1,17 @@
+
+    README for Perl module Test::Pod::Coverage
+
+This module is used to add a test to your Perl distribution,
+which checks for pod coverage of all appropriate files.
+
+You can read a nicely formatted version of the documentation for
+this module online:
+
+    https://metacpan.org/pod/Test::Pod::Coverage
+
+You should be able to install this using your usual method for installing
+modules from CPAN. If you don't have one let, have a look at:
+
+    http://www.cpan.org/modules/INSTALL.html
+
+This module was written by Andy Lester, <petdance@cpan.org>
diff --git a/lib/Test/Pod/Coverage.pm b/lib/Test/Pod/Coverage.pm
new file mode 100644
index 0000000..f803b93
--- /dev/null
+++ b/lib/Test/Pod/Coverage.pm
@@ -0,0 +1,318 @@
+package Test::Pod::Coverage;
+
+=head1 NAME
+
+Test::Pod::Coverage - Check for pod coverage in your distribution.
+
+=head1 VERSION
+
+Version 1.10
+
+=cut
+
+our $VERSION = "1.10";
+
+=head1 SYNOPSIS
+
+In one of your dist's test files (eg C<t/pod-coverage.t>):
+
+    use Test::Pod::Coverage tests=>1;
+    pod_coverage_ok( "Foo::Bar", "Foo::Bar is covered" );
+
+=head1 DESCRIPTION
+
+Test::Pod::Coverage is used to create a test for your distribution,
+to ensure that all relevant files in your distribution are appropriately
+documented in pod.
+
+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 5.006;
+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 REPOSITORY
+
+L<https://github.com/neilbowers/Test-Pod-Coverage>
+
+=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.
+
+This program is free software; you can redistribute it and/or modify it
+under the terms of the Artistic License version 2.0.
+
+See http://dev.perl.org/licenses/ for more information
+
+=cut
+
+1;
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..af892f1
--- /dev/null
+++ b/t/nosymbols.t
@@ -0,0 +1,25 @@
+#!perl -T
+
+use strict;
+use lib "t";
+use Test::More tests => 3;
+use Test::Builder::Tester;
+
+BEGIN {
+    use_ok( 'Test::Pod::Coverage' );
+}
+
+NO_VERBOSE: {
+    local $ENV{HARNESS_VERBOSE} = 0;
+    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" );
+}
diff --git a/t/pod.t b/t/pod.t
new file mode 100644
index 0000000..976d7cd
--- /dev/null
+++ b/t/pod.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" );