This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
Update to include latest Test::Builder alpha
authorChad Granum <chad.granum@dreamhost.com>
Fri, 15 Aug 2014 15:40:10 +0000 (08:40 -0700)
committerJames E Keenan <jkeenan@cpan.org>
Sat, 16 Aug 2014 21:19:29 +0000 (23:19 +0200)
Also updated some tests that the new builder broke

122 files changed:
MANIFEST
Makefile.SH
cpan/Test-Simple/lib/Test/Builder.pm
cpan/Test-Simple/lib/Test/Builder/ExitMagic.pm [new file with mode: 0644]
cpan/Test-Simple/lib/Test/Builder/Fork.pm [new file with mode: 0644]
cpan/Test-Simple/lib/Test/Builder/Formatter.pm [new file with mode: 0644]
cpan/Test-Simple/lib/Test/Builder/Formatter/LegacyResults.pm [new file with mode: 0644]
cpan/Test-Simple/lib/Test/Builder/Formatter/TAP.pm [new file with mode: 0644]
cpan/Test-Simple/lib/Test/Builder/Module.pm
cpan/Test-Simple/lib/Test/Builder/Provider.pm [new file with mode: 0644]
cpan/Test-Simple/lib/Test/Builder/Result.pm [new file with mode: 0644]
cpan/Test-Simple/lib/Test/Builder/Result/Bail.pm [new file with mode: 0644]
cpan/Test-Simple/lib/Test/Builder/Result/Child.pm [new file with mode: 0644]
cpan/Test-Simple/lib/Test/Builder/Result/Diag.pm [new file with mode: 0644]
cpan/Test-Simple/lib/Test/Builder/Result/Finish.pm [new file with mode: 0644]
cpan/Test-Simple/lib/Test/Builder/Result/Note.pm [new file with mode: 0644]
cpan/Test-Simple/lib/Test/Builder/Result/Ok.pm [new file with mode: 0644]
cpan/Test-Simple/lib/Test/Builder/Result/Plan.pm [new file with mode: 0644]
cpan/Test-Simple/lib/Test/Builder/Stream.pm [new file with mode: 0644]
cpan/Test-Simple/lib/Test/Builder/Tester.pm
cpan/Test-Simple/lib/Test/Builder/Tester/Color.pm
cpan/Test-Simple/lib/Test/Builder/Threads.pm [new file with mode: 0644]
cpan/Test-Simple/lib/Test/Builder/Trace.pm [new file with mode: 0644]
cpan/Test-Simple/lib/Test/Builder/Trace/Frame.pm [new file with mode: 0644]
cpan/Test-Simple/lib/Test/Builder/Util.pm [new file with mode: 0644]
cpan/Test-Simple/lib/Test/FAQ.pod [new file with mode: 0644]
cpan/Test-Simple/lib/Test/More.pm
cpan/Test-Simple/lib/Test/Simple.pm
cpan/Test-Simple/lib/Test/Tester.pm [new file with mode: 0644]
cpan/Test-Simple/lib/Test/Tester/Capture.pm [new file with mode: 0644]
cpan/Test-Simple/lib/Test/Tester/CaptureRunner.pm [new file with mode: 0644]
cpan/Test-Simple/lib/Test/Tester/Delegate.pm [new file with mode: 0644]
cpan/Test-Simple/lib/Test/Tester2.pm [new file with mode: 0644]
cpan/Test-Simple/lib/Test/Tutorial.pod
cpan/Test-Simple/lib/Test/use/ok.pm [new file with mode: 0644]
cpan/Test-Simple/lib/ok.pm [new file with mode: 0644]
cpan/Test-Simple/t/00test_harness_check.t
cpan/Test-Simple/t/Builder/carp.t
cpan/Test-Simple/t/Builder/done_testing_with_plan.t
cpan/Test-Simple/t/Builder/fork_with_new_stdout.t
cpan/Test-Simple/t/Builder/is_fh.t
cpan/Test-Simple/t/Builder/maybe_regex.t
cpan/Test-Simple/t/Builder/reset.t
cpan/Test-Simple/t/Builder/reset_outputs.t [new file with mode: 0644]
cpan/Test-Simple/t/Modern/Builder.t [new file with mode: 0644]
cpan/Test-Simple/t/Modern/Builder_Fork.t [new file with mode: 0644]
cpan/Test-Simple/t/Modern/Builder_Formatter.t [new file with mode: 0644]
cpan/Test-Simple/t/Modern/Builder_Formatter_TAP.t [new file with mode: 0644]
cpan/Test-Simple/t/Modern/Builder_Module.t [new file with mode: 0644]
cpan/Test-Simple/t/Modern/Builder_Provider.t [new file with mode: 0644]
cpan/Test-Simple/t/Modern/Builder_Result.t [new file with mode: 0644]
cpan/Test-Simple/t/Modern/Builder_Result_Child.t [new file with mode: 0644]
cpan/Test-Simple/t/Modern/Builder_Result_Diag.t [new file with mode: 0644]
cpan/Test-Simple/t/Modern/Builder_Result_Finish.t [new file with mode: 0644]
cpan/Test-Simple/t/Modern/Builder_Result_Note.t [new file with mode: 0644]
cpan/Test-Simple/t/Modern/Builder_Result_Ok.t [new file with mode: 0644]
cpan/Test-Simple/t/Modern/Builder_Result_Plan.t [new file with mode: 0644]
cpan/Test-Simple/t/Modern/Builder_Stream.t [new file with mode: 0644]
cpan/Test-Simple/t/Modern/Builder_Tester.t [new file with mode: 0644]
cpan/Test-Simple/t/Modern/Builder_Trace.t [new file with mode: 0644]
cpan/Test-Simple/t/Modern/Builder_Trace_Frame.t [new file with mode: 0644]
cpan/Test-Simple/t/Modern/Builder_Util.t [new file with mode: 0644]
cpan/Test-Simple/t/Modern/More.t [new file with mode: 0644]
cpan/Test-Simple/t/Modern/NotTB15.t [new file with mode: 0644]
cpan/Test-Simple/t/Modern/Simple.t [new file with mode: 0644]
cpan/Test-Simple/t/Modern/Tester2.t [new file with mode: 0644]
cpan/Test-Simple/t/Modern/Tester2_subtest.t [new file with mode: 0644]
cpan/Test-Simple/t/Modern/encoding_test.t [new file with mode: 0644]
cpan/Test-Simple/t/Modern/tracing.t [new file with mode: 0644]
cpan/Test-Simple/t/More.t
cpan/Test-Simple/t/PerlIO.t [new file with mode: 0644]
cpan/Test-Simple/t/TTLegacy/auto.t [new file with mode: 0644]
cpan/Test-Simple/t/TTLegacy/capture.t [new file with mode: 0644]
cpan/Test-Simple/t/TTLegacy/check_tests.t [new file with mode: 0644]
cpan/Test-Simple/t/TTLegacy/depth.t [new file with mode: 0644]
cpan/Test-Simple/t/TTLegacy/run_test.t [new file with mode: 0644]
cpan/Test-Simple/t/Tester/tbt_01basic.t
cpan/Test-Simple/t/Tester/tbt_02fhrestore.t
cpan/Test-Simple/t/Tester/tbt_06errormess.t
cpan/Test-Simple/t/Tester/tbt_07args.t
cpan/Test-Simple/t/Tester/tbt_is_bug.t [new file with mode: 0644]
cpan/Test-Simple/t/circular_data.t
cpan/Test-Simple/t/cmp_ok.t
cpan/Test-Simple/t/died.t
cpan/Test-Simple/t/dont_overwrite_die_handler.t
cpan/Test-Simple/t/eq_set.t
cpan/Test-Simple/t/exit.t
cpan/Test-Simple/t/fail-like.t
cpan/Test-Simple/t/fork.t
cpan/Test-Simple/t/harness_active.t
cpan/Test-Simple/t/is_deeply_fail.t
cpan/Test-Simple/t/is_deeply_with_threads.t
cpan/Test-Simple/t/lib/MyTest.pm [new file with mode: 0644]
cpan/Test-Simple/t/lib/SmallTest.pm [new file with mode: 0644]
cpan/Test-Simple/t/lib/Test/Builder/NoOutput.pm
cpan/Test-Simple/t/no_tests.t
cpan/Test-Simple/t/overload.t
cpan/Test-Simple/t/plan_no_plan.t
cpan/Test-Simple/t/pod-coverage.t [new file with mode: 0644]
cpan/Test-Simple/t/pod.t [new file with mode: 0644]
cpan/Test-Simple/t/ribasushi_diag.t [new file with mode: 0644]
cpan/Test-Simple/t/ribasushi_threads.t [new file with mode: 0644]
cpan/Test-Simple/t/skip.t
cpan/Test-Simple/t/skipall.t
cpan/Test-Simple/t/strays.t [new file with mode: 0644]
cpan/Test-Simple/t/subtest/args.t
cpan/Test-Simple/t/subtest/bail_out.t
cpan/Test-Simple/t/subtest/basic.t
cpan/Test-Simple/t/subtest/fork.t
cpan/Test-Simple/t/subtest/line_numbers.t
cpan/Test-Simple/t/subtest/predicate.t
cpan/Test-Simple/t/subtest/threads.t
cpan/Test-Simple/t/subtest/todo.t
cpan/Test-Simple/t/test_use_ok.t [new file with mode: 0644]
cpan/Test-Simple/t/threads.t
cpan/Test-Simple/t/todo.t
cpan/Test-Simple/t/undef.t
cpan/Test-Simple/t/utf8.t
cpan/Test-Simple/t/versions.t
dist/Carp/t/Carp.t
ext/DynaLoader/t/DynaLoader.t
lib/.gitignore

index 8479f03..4ef6fda 100644 (file)
--- a/MANIFEST
+++ b/MANIFEST
@@ -2233,146 +2233,214 @@ cpan/Test-Harness/t/yamlish-output.t                  Test::Harness test
 cpan/Test-Harness/t/yamlish.t                          Test::Harness test
 cpan/Test-Harness/t/yamlish-writer.t                   Test::Harness test
 cpan/Test/lib/Test.pm          A simple framework for writing test scripts
 cpan/Test-Harness/t/yamlish.t                          Test::Harness test
 cpan/Test-Harness/t/yamlish-writer.t                   Test::Harness test
 cpan/Test/lib/Test.pm          A simple framework for writing test scripts
-cpan/Test-Simple/lib/Test/Builder/Module.pm            Base class for test modules
-cpan/Test-Simple/lib/Test/Builder.pm                   For writing new test libraries
-cpan/Test-Simple/lib/Test/Builder/Tester/Color.pm      Turn on color in Test::Builder::Tester
-cpan/Test-Simple/lib/Test/Builder/Tester.pm            For testing Test::Builder based classes
-cpan/Test-Simple/lib/Test/More.pm                      More utilities for writing tests
-cpan/Test-Simple/lib/Test/Simple.pm                    Basic utility for writing tests
-cpan/Test-Simple/lib/Test/Tutorial.pod                 A tutorial on writing tests
-cpan/Test-Simple/t/00test_harness_check.t              Test::Simple test
-cpan/Test-Simple/t/bad_plan.t                          Test::Builder plan() test
-cpan/Test-Simple/t/bail_out.t                          Test::Builder BAIL_OUT test
-cpan/Test-Simple/t/BEGIN_require_ok.t                  Test::More require_ok() testing
-cpan/Test-Simple/t/BEGIN_use_ok.t                      Test::More use_ok() testing
-cpan/Test-Simple/t/buffer.t                            Test::Builder buffering test
-cpan/Test-Simple/t/Builder/Builder.t                   Test::Builder tests
-cpan/Test-Simple/t/Builder/carp.t                      Test::Builder test
-cpan/Test-Simple/t/Builder/create.t                    Test::Builder test
-cpan/Test-Simple/t/Builder/current_test.t              Test::Builder tests
-cpan/Test-Simple/t/Builder/current_test_without_plan.t Test::Builder tests
-cpan/Test-Simple/t/Builder/details.t                   Test::Builder tests
-cpan/Test-Simple/t/Builder/done_testing_double.t               Test::Builder tests
-cpan/Test-Simple/t/Builder/done_testing_plan_mismatch.t        Test::Builder tests
-cpan/Test-Simple/t/Builder/done_testing.t              Test::Builder tests
-cpan/Test-Simple/t/Builder/done_testing_with_no_plan.t Test::Builder tests
-cpan/Test-Simple/t/Builder/done_testing_with_number.t  Test::Builder tests
-cpan/Test-Simple/t/Builder/done_testing_with_plan.t    Test::Builder tests
-cpan/Test-Simple/t/Builder/fork_with_new_stdout.t      Test::Builder tests
-cpan/Test-Simple/t/Builder/has_plan2.t                 Test::Builder tests
-cpan/Test-Simple/t/Builder/has_plan.t                  Test::Builder tests
-cpan/Test-Simple/t/Builder/is_fh.t                     Test::Builder tests
-cpan/Test-Simple/t/Builder/is_passing.t                        Test::Builder tests
-cpan/Test-Simple/t/Builder/maybe_regex.t               Test::Builder tests
-cpan/Test-Simple/t/Builder/no_diag.t                   Test::Builder tests
-cpan/Test-Simple/t/Builder/no_ending.t                 Test::Builder tests
-cpan/Test-Simple/t/Builder/no_header.t                 Test::Builder tests
-cpan/Test-Simple/t/Builder/no_plan_at_all.t            Test::Builder tests
-cpan/Test-Simple/t/Builder/ok_obj.t                    Test::Builder tests
-cpan/Test-Simple/t/Builder/output.t                    Test::Builder tests
-cpan/Test-Simple/t/Builder/reset.t                     Test::Builder tests
-cpan/Test-Simple/t/Builder/try.t                       Test::Builder tests
-cpan/Test-Simple/t/c_flag.t                            Test::Simple test
-cpan/Test-Simple/t/circular_data.t                     Test::Simple test
-cpan/Test-Simple/t/cmp_ok.t                            Test::More test
-cpan/Test-Simple/t/dependents.t                                Test::More test
-cpan/Test-Simple/t/diag.t                              Test::More diag() test
-cpan/Test-Simple/t/died.t                              Test::Simple test
-cpan/Test-Simple/t/dont_overwrite_die_handler.t                Test::More tests
-cpan/Test-Simple/t/eq_set.t                            Test::Simple test
-cpan/Test-Simple/t/exit.t                              Test::Simple test, exit codes
-cpan/Test-Simple/t/explain.t                           Test::Simple test
-cpan/Test-Simple/t/extra_one.t                         Test::Simple test
-cpan/Test-Simple/t/extra.t                             Test::Simple test
-cpan/Test-Simple/t/fail-like.t                         Test::More test, like() failures
-cpan/Test-Simple/t/fail-more.t                         Test::More test, tests failing
-cpan/Test-Simple/t/fail_one.t                          Test::Simple test
-cpan/Test-Simple/t/fail.t                              Test::Simple test, test failures
-cpan/Test-Simple/t/filehandles.t                       Test::Simple test, STDOUT can be played with
-cpan/Test-Simple/t/fork.t                              Test::More fork tests
-cpan/Test-Simple/t/harness_active.t                    Test::Simple test
-cpan/Test-Simple/t/import.t                            Test::More test, importing functions
-cpan/Test-Simple/t/is_deeply_dne_bug.t                 Test::More test
-cpan/Test-Simple/t/is_deeply_fail.t                    Test::More test, is_deeply()
-cpan/Test-Simple/t/is_deeply_with_threads.t            Test::More test
-cpan/Test-Simple/t/lib/Dev/Null.pm                     Test::More test module
-cpan/Test-Simple/t/lib/Dummy.pm                                Test::More test module
-cpan/Test-Simple/t/lib/MyOverload.pm                   Test::More test module
-cpan/Test-Simple/t/lib/NoExporter.pm                   Test::Simple test module
-cpan/Test-Simple/t/lib/SigDie.pm                       Test module for Test::More
-cpan/Test-Simple/t/lib/Test/Builder/NoOutput.pm                Utility module for testing Test::Builder
-cpan/Test-Simple/t/lib/Test/Simple/Catch.pm            Utility module for testing Test::Simple
-cpan/Test-Simple/t/lib/Test/Simple/sample_tests/death_in_eval.plx      for exit.t
-cpan/Test-Simple/t/lib/Test/Simple/sample_tests/death.plx              for exit.t
-cpan/Test-Simple/t/lib/Test/Simple/sample_tests/death_with_handler.plx for exit.t
-cpan/Test-Simple/t/lib/Test/Simple/sample_tests/exit.plx                       for exit.t
-cpan/Test-Simple/t/lib/Test/Simple/sample_tests/extras.plx             for exit.t
-cpan/Test-Simple/t/lib/Test/Simple/sample_tests/five_fail.plx          for exit.t
-cpan/Test-Simple/t/lib/Test/Simple/sample_tests/last_minute_death.plx  for exit.t
-cpan/Test-Simple/t/lib/Test/Simple/sample_tests/missing_done_testing.plx       for exit.t
-cpan/Test-Simple/t/lib/Test/Simple/sample_tests/one_fail.plx           for exit.t
-cpan/Test-Simple/t/lib/Test/Simple/sample_tests/one_fail_without_plan.plx      for exit.t
-cpan/Test-Simple/t/lib/Test/Simple/sample_tests/pre_plan_death.plx     for exit.t
-cpan/Test-Simple/t/lib/Test/Simple/sample_tests/require.plx            for exit.t
-cpan/Test-Simple/t/lib/Test/Simple/sample_tests/success.plx            for exit.t
-cpan/Test-Simple/t/lib/Test/Simple/sample_tests/too_few_fail.plx               for exit.t
-cpan/Test-Simple/t/lib/Test/Simple/sample_tests/too_few.plx            for exit.t
-cpan/Test-Simple/t/lib/Test/Simple/sample_tests/two_fail.plx           for exit.t
-cpan/Test-Simple/t/lib/TieOut.pm                       Testing library to capture prints
-cpan/Test-Simple/t/missing.t                           Test::Simple test, missing tests
-cpan/Test-Simple/t/More.t                              Test::More test, basic stuff
-cpan/Test-Simple/t/new_ok.t                            Test::More test
-cpan/Test-Simple/t/no_plan.t                           Test::Simple test, forgot the plan
-cpan/Test-Simple/t/no_tests.t                          Test::More test
-cpan/Test-Simple/t/note.t                              Test::More test
-cpan/Test-Simple/t/overload.t                          Test::Simple test
-cpan/Test-Simple/t/overload_threads.t                  Test::Simple test
-cpan/Test-Simple/t/plan_bad.t                          Test::Simple test
-cpan/Test-Simple/t/plan_is_noplan.t                    Test::Simple test, no_plan
-cpan/Test-Simple/t/plan_no_plan.t                      Test::More test, plan() w/no_plan
-cpan/Test-Simple/t/plan_shouldnt_import.t              Test::Simple test
-cpan/Test-Simple/t/plan_skip_all.t                     Test::More test, plan() w/skip_all
-cpan/Test-Simple/t/plan.t                              Test::More test, plan()
-cpan/Test-Simple/t/require_ok.t                                Test::Simple test
-cpan/Test-Simple/t/Simple/load.t                       Test::Builder tests
-cpan/Test-Simple/t/simple.t                            Test::Simple test, basic stuff
-cpan/Test-Simple/t/skipall.t                           Test::More test, skip all tests
-cpan/Test-Simple/t/skip.t                              Test::More test, SKIP tests
-cpan/Test-Simple/t/subtest/args.t                      Test::More test
-cpan/Test-Simple/t/subtest/bail_out.t                  Test::More test
-cpan/Test-Simple/t/subtest/basic.t                     Test::More test
-cpan/Test-Simple/t/subtest/die.t                       Test::More test
-cpan/Test-Simple/t/subtest/do.t                                Test::More test
-cpan/Test-Simple/t/subtest/exceptions.t                        Test::More test
-cpan/Test-Simple/t/subtest/for_do_t.test               Test::More test
-cpan/Test-Simple/t/subtest/fork.t                      Test::Builder tests
-cpan/Test-Simple/t/subtest/implicit_done.t                     Test::Builder tests
-cpan/Test-Simple/t/subtest/line_numbers.t                      Test::Builder tests
-cpan/Test-Simple/t/subtest/plan.t                      Test::Builder tests
-cpan/Test-Simple/t/subtest/predicate.t                 Test::Builder tests
-cpan/Test-Simple/t/subtest/singleton.t                 Test::More test
-cpan/Test-Simple/t/subtest/threads.t                   Test::More test
-cpan/Test-Simple/t/subtest/todo.t                      Test::Builder tests
-cpan/Test-Simple/t/subtest/wstat.t                     Test::More test
-cpan/Test-Simple/t/tbm_doesnt_set_exported_to.t                Test::Builder::Module test
+cpan/Test-Simple/lib/ok.pm                     Tool for testing module loading
+cpan/Test-Simple/lib/Test/Builder/ExitMagic.pm                 Handle $? when tests exit
+cpan/Test-Simple/lib/Test/Builder/Fork.pm                      Forking support for Test::Builder
+cpan/Test-Simple/lib/Test/Builder/Formatter/LegacyResults.pm                   Legacy support
+cpan/Test-Simple/lib/Test/Builder/Formatter.pm                 Base class for formatters
+cpan/Test-Simple/lib/Test/Builder/Formatter/TAP.pm                     TAP formatter
+cpan/Test-Simple/lib/Test/Builder/Module.pm                    Deprecated tester base class
+cpan/Test-Simple/lib/Test/Builder.pm                   The meat of Test::Builder
+cpan/Test-Simple/lib/Test/Builder/Provider.pm                  Tool for building testers
+cpan/Test-Simple/lib/Test/Builder/Result/Bail.pm                       Bail result
+cpan/Test-Simple/lib/Test/Builder/Result/Child.pm                      Child result
+cpan/Test-Simple/lib/Test/Builder/Result/Diag.pm                       Diag result
+cpan/Test-Simple/lib/Test/Builder/Result/Finish.pm                     Finish result
+cpan/Test-Simple/lib/Test/Builder/Result/Note.pm                       Note result
+cpan/Test-Simple/lib/Test/Builder/Result/Ok.pm                 Ok result
+cpan/Test-Simple/lib/Test/Builder/Result/Plan.pm                       Plan result
+cpan/Test-Simple/lib/Test/Builder/Result.pm                    Result base class
+cpan/Test-Simple/lib/Test/Builder/Stream.pm                    The test stream
+cpan/Test-Simple/lib/Test/Builder/Tester/Color.pm                      Part of Test::Tester
+cpan/Test-Simple/lib/Test/Builder/Tester.pm                    Tool for validating testers
+cpan/Test-Simple/lib/Test/Builder/Threads.pm                   Thread utisl for Test::Builder
+cpan/Test-Simple/lib/Test/Builder/Trace/Frame.pm                       Frame in a stack trace
+cpan/Test-Simple/lib/Test/Builder/Trace.pm                     Tool for building and analyzing stack traces
+cpan/Test-Simple/lib/Test/Builder/Util.pm                      Common utils used throughout Test::Builder
+cpan/Test-Simple/lib/Test/FAQ.pod                      Frequently Asked Questions
+cpan/Test-Simple/lib/Test/More.pm                      More tools for testing
+cpan/Test-Simple/lib/Test/Simple.pm                    tools for testing
+cpan/Test-Simple/lib/Test/Tester2.pm                   Tool for testing testers
+cpan/Test-Simple/lib/Test/Tester/Capture.pm                    Part of Test::Tester
+cpan/Test-Simple/lib/Test/Tester/CaptureRunner.pm                      Part of Test::Tester
+cpan/Test-Simple/lib/Test/Tester/Delegate.pm                   Part of Test::Tester
+cpan/Test-Simple/lib/Test/Tester.pm                    Tool for testing testers
+cpan/Test-Simple/lib/Test/Tutorial.pod                 Testing Tutorial
+cpan/Test-Simple/lib/Test/use/ok.pm                    Tool for testing module loading
+cpan/Test-Simple/t/00test_harness_check.t                      Test::Builder legacy test
+cpan/Test-Simple/t/bad_plan.t                  Test::Builder legacy test
+cpan/Test-Simple/t/bail_out.t                  Test::Builder legacy test
+cpan/Test-Simple/t/BEGIN_require_ok.t                  Test::Builder legacy test
+cpan/Test-Simple/t/BEGIN_use_ok.t                      Test::Builder legacy test
+cpan/Test-Simple/t/buffer.t                    Test::Builder legacy test
+cpan/Test-Simple/t/Builder/Builder.t                   Test::Builder legacy test
+cpan/Test-Simple/t/Builder/carp.t                      Test::Builder legacy test
+cpan/Test-Simple/t/Builder/create.t                    Test::Builder legacy test
+cpan/Test-Simple/t/Builder/current_test.t                      Test::Builder legacy test
+cpan/Test-Simple/t/Builder/current_test_without_plan.t                 Test::Builder legacy test
+cpan/Test-Simple/t/Builder/details.t                   Test::Builder legacy test
+cpan/Test-Simple/t/Builder/done_testing_double.t                       Test::Builder legacy test
+cpan/Test-Simple/t/Builder/done_testing_plan_mismatch.t                        Test::Builder legacy test
+cpan/Test-Simple/t/Builder/done_testing.t                      Test::Builder legacy test
+cpan/Test-Simple/t/Builder/done_testing_with_no_plan.t                 Test::Builder legacy test
+cpan/Test-Simple/t/Builder/done_testing_with_number.t                  Test::Builder legacy test
+cpan/Test-Simple/t/Builder/done_testing_with_plan.t                    Test::Builder legacy test
+cpan/Test-Simple/t/Builder/fork_with_new_stdout.t                      Test::Builder legacy test
+cpan/Test-Simple/t/Builder/has_plan2.t                 Test::Builder legacy test
+cpan/Test-Simple/t/Builder/has_plan.t                  Test::Builder legacy test
+cpan/Test-Simple/t/Builder/is_fh.t                     Test::Builder legacy test
+cpan/Test-Simple/t/Builder/is_passing.t                        Test::Builder legacy test
+cpan/Test-Simple/t/Builder/maybe_regex.t                       Test::Builder legacy test
+cpan/Test-Simple/t/Builder/no_diag.t                   Test::Builder legacy test
+cpan/Test-Simple/t/Builder/no_ending.t                 Test::Builder legacy test
+cpan/Test-Simple/t/Builder/no_header.t                 Test::Builder legacy test
+cpan/Test-Simple/t/Builder/no_plan_at_all.t                    Test::Builder legacy test
+cpan/Test-Simple/t/Builder/ok_obj.t                    Test::Builder legacy test
+cpan/Test-Simple/t/Builder/output.t                    Test::Builder legacy test
+cpan/Test-Simple/t/Builder/reset_outputs.t                     Test::Builder legacy test
+cpan/Test-Simple/t/Builder/reset.t                     Test::Builder legacy test
+cpan/Test-Simple/t/Builder/try.t                       Test::Builder legacy test
+cpan/Test-Simple/t/c_flag.t                    Test::Builder legacy test
+cpan/Test-Simple/t/circular_data.t                     Test::Builder legacy test
+cpan/Test-Simple/t/cmp_ok.t                    Test::Builder legacy test
+cpan/Test-Simple/t/dependents.t                        Test::Builder legacy test
+cpan/Test-Simple/t/diag.t                      Test::Builder legacy test
+cpan/Test-Simple/t/died.t                      Test::Builder legacy test
+cpan/Test-Simple/t/dont_overwrite_die_handler.t                        Test::Builder legacy test
+cpan/Test-Simple/t/eq_set.t                    Test::Builder legacy test
+cpan/Test-Simple/t/exit.t                      Test::Builder legacy test
+cpan/Test-Simple/t/explain.t                   Test::Builder legacy test
+cpan/Test-Simple/t/extra_one.t                 Test::Builder legacy test
+cpan/Test-Simple/t/extra.t                     Test::Builder legacy test
+cpan/Test-Simple/t/fail-like.t                 Test::Builder legacy test
+cpan/Test-Simple/t/fail-more.t                 Test::Builder legacy test
+cpan/Test-Simple/t/fail_one.t                  Test::Builder legacy test
+cpan/Test-Simple/t/fail.t                      Test::Builder legacy test
+cpan/Test-Simple/t/filehandles.t                       Test::Builder legacy test
+cpan/Test-Simple/t/fork.t                      Test::Builder legacy test
+cpan/Test-Simple/t/harness_active.t                    Test::Builder legacy test
+cpan/Test-Simple/t/import.t                    Test::Builder legacy test
+cpan/Test-Simple/t/is_deeply_dne_bug.t                 Test::Builder legacy test
+cpan/Test-Simple/t/is_deeply_fail.t                    Test::Builder legacy test
+cpan/Test-Simple/t/is_deeply_with_threads.t                    Test::Builder legacy test
+cpan/Test-Simple/t/lib/Dev/Null.pm                     Test helper module
+cpan/Test-Simple/t/lib/Dummy.pm                        Test helper module
+cpan/Test-Simple/t/lib/MyOverload.pm                   Test helper module
+cpan/Test-Simple/t/lib/MyTest.pm                       Test helper module
+cpan/Test-Simple/t/lib/NoExporter.pm                   Test helper module
+cpan/Test-Simple/t/lib/SigDie.pm                       Test helper module
+cpan/Test-Simple/t/lib/SmallTest.pm                    Test helper module
+cpan/Test-Simple/t/lib/Test/Builder/NoOutput.pm                        Test helper module
+cpan/Test-Simple/t/lib/Test/Simple/Catch.pm                    Test helper module
+cpan/Test-Simple/t/lib/Test/Simple/sample_tests/death_in_eval.plx                      Sample test used in tests
+cpan/Test-Simple/t/lib/Test/Simple/sample_tests/death.plx                      Sample test used in tests
+cpan/Test-Simple/t/lib/Test/Simple/sample_tests/death_with_handler.plx                 Sample test used in tests
+cpan/Test-Simple/t/lib/Test/Simple/sample_tests/exit.plx                       Sample test used in tests
+cpan/Test-Simple/t/lib/Test/Simple/sample_tests/extras.plx                     Sample test used in tests
+cpan/Test-Simple/t/lib/Test/Simple/sample_tests/five_fail.plx                  Sample test used in tests
+cpan/Test-Simple/t/lib/Test/Simple/sample_tests/last_minute_death.plx                  Sample test used in tests
+cpan/Test-Simple/t/lib/Test/Simple/sample_tests/missing_done_testing.plx                       Sample test used in tests
+cpan/Test-Simple/t/lib/Test/Simple/sample_tests/one_fail.plx                   Sample test used in tests
+cpan/Test-Simple/t/lib/Test/Simple/sample_tests/one_fail_without_plan.plx                      Sample test used in tests
+cpan/Test-Simple/t/lib/Test/Simple/sample_tests/pre_plan_death.plx                     Sample test used in tests
+cpan/Test-Simple/t/lib/Test/Simple/sample_tests/require.plx                    Sample test used in tests
+cpan/Test-Simple/t/lib/Test/Simple/sample_tests/success.plx                    Sample test used in tests
+cpan/Test-Simple/t/lib/Test/Simple/sample_tests/too_few_fail.plx                       Sample test used in tests
+cpan/Test-Simple/t/lib/Test/Simple/sample_tests/too_few.plx                    Sample test used in tests
+cpan/Test-Simple/t/lib/Test/Simple/sample_tests/two_fail.plx                   Sample test used in tests
+cpan/Test-Simple/t/lib/TieOut.pm                       Test helper module
+cpan/Test-Simple/t/missing.t                   Test::Builder legacy test
+cpan/Test-Simple/t/Modern/Builder_Fork.t                       Test for modern Test::Builder features
+cpan/Test-Simple/t/Modern/Builder_Formatter.t                  Test for modern Test::Builder features
+cpan/Test-Simple/t/Modern/Builder_Formatter_TAP.t                      Test for modern Test::Builder features
+cpan/Test-Simple/t/Modern/Builder_Module.t                     Test for modern Test::Builder features
+cpan/Test-Simple/t/Modern/Builder_Provider.t                   Test for modern Test::Builder features
+cpan/Test-Simple/t/Modern/Builder_Result_Child.t                       Test for modern Test::Builder features
+cpan/Test-Simple/t/Modern/Builder_Result_Diag.t                        Test for modern Test::Builder features
+cpan/Test-Simple/t/Modern/Builder_Result_Finish.t                      Test for modern Test::Builder features
+cpan/Test-Simple/t/Modern/Builder_Result_Note.t                        Test for modern Test::Builder features
+cpan/Test-Simple/t/Modern/Builder_Result_Ok.t                  Test for modern Test::Builder features
+cpan/Test-Simple/t/Modern/Builder_Result_Plan.t                        Test for modern Test::Builder features
+cpan/Test-Simple/t/Modern/Builder_Result.t                     Test for modern Test::Builder features
+cpan/Test-Simple/t/Modern/Builder_Stream.t                     Test for modern Test::Builder features
+cpan/Test-Simple/t/Modern/Builder.t                    Test for modern Test::Builder features
+cpan/Test-Simple/t/Modern/Builder_Tester.t                     Test for modern Test::Builder features
+cpan/Test-Simple/t/Modern/Builder_Trace_Frame.t                        Test for modern Test::Builder features
+cpan/Test-Simple/t/Modern/Builder_Trace.t                      Test for modern Test::Builder features
+cpan/Test-Simple/t/Modern/Builder_Util.t                       Test for modern Test::Builder features
+cpan/Test-Simple/t/Modern/encoding_test.t                      Test for modern Test::Builder features
+cpan/Test-Simple/t/Modern/More.t                       Test for modern Test::Builder features
+cpan/Test-Simple/t/Modern/NotTB15.t                    Test for modern Test::Builder features
+cpan/Test-Simple/t/Modern/Simple.t                     Test for modern Test::Builder features
+cpan/Test-Simple/t/Modern/Tester2_subtest.t                    Test for modern Test::Builder features
+cpan/Test-Simple/t/Modern/Tester2.t                    Test for modern Test::Builder features
+cpan/Test-Simple/t/Modern/tracing.t                    Test for modern Test::Builder features
+cpan/Test-Simple/t/More.t                      Legacy test for Test::Builder
+cpan/Test-Simple/t/new_ok.t                    Legacy test for Test::Builder
+cpan/Test-Simple/t/no_plan.t                   Legacy test for Test::Builder
+cpan/Test-Simple/t/no_tests.t                  Legacy test for Test::Builder
+cpan/Test-Simple/t/note.t                      Legacy test for Test::Builder
+cpan/Test-Simple/t/overload.t                  Legacy test for Test::Builder
+cpan/Test-Simple/t/overload_threads.t                  Legacy test for Test::Builder
+cpan/Test-Simple/t/PerlIO.t                    Legacy test for Test::Builder
+cpan/Test-Simple/t/plan_bad.t                  Legacy test for Test::Builder
+cpan/Test-Simple/t/plan_is_noplan.t                    Legacy test for Test::Builder
+cpan/Test-Simple/t/plan_no_plan.t                      Legacy test for Test::Builder
+cpan/Test-Simple/t/plan_shouldnt_import.t                      Legacy test for Test::Builder
+cpan/Test-Simple/t/plan_skip_all.t                     Legacy test for Test::Builder
+cpan/Test-Simple/t/plan.t                      Legacy test for Test::Builder
+cpan/Test-Simple/t/pod-coverage.t                      Legacy test for Test::Builder
+cpan/Test-Simple/t/pod.t                       Legacy test for Test::Builder
+cpan/Test-Simple/t/require_ok.t                        Legacy test for Test::Builder
+cpan/Test-Simple/t/ribasushi_diag.t                    Legacy test for Test::Builder
+cpan/Test-Simple/t/ribasushi_threads.t                 Legacy test for Test::Builder
+cpan/Test-Simple/t/Simple/load.t                       Legacy test for Test::Builder
+cpan/Test-Simple/t/simple.t                    Legacy test for Test::Builder
+cpan/Test-Simple/t/skipall.t                   Legacy test for Test::Builder
+cpan/Test-Simple/t/skip.t                      Legacy test for Test::Builder
+cpan/Test-Simple/t/strays.t                    Legacy test for Test::Builder
+cpan/Test-Simple/t/subtest/args.t                      Legacy subtest test
+cpan/Test-Simple/t/subtest/bail_out.t                  Legacy subtest test
+cpan/Test-Simple/t/subtest/basic.t                     Legacy subtest test
+cpan/Test-Simple/t/subtest/die.t                       Legacy subtest test
+cpan/Test-Simple/t/subtest/do.t                        Legacy subtest test
+cpan/Test-Simple/t/subtest/exceptions.t                        Legacy subtest test
+cpan/Test-Simple/t/subtest/for_do_t.test                       Legacy subtest test
+cpan/Test-Simple/t/subtest/fork.t                      Legacy subtest test
+cpan/Test-Simple/t/subtest/implicit_done.t                     Legacy subtest test
+cpan/Test-Simple/t/subtest/line_numbers.t                      Legacy subtest test
+cpan/Test-Simple/t/subtest/plan.t                      Legacy subtest test
+cpan/Test-Simple/t/subtest/predicate.t                 Legacy subtest test
+cpan/Test-Simple/t/subtest/singleton.t                 Legacy subtest test
+cpan/Test-Simple/t/subtest/threads.t                   Legacy subtest test
+cpan/Test-Simple/t/subtest/todo.t                      Legacy subtest test
+cpan/Test-Simple/t/subtest/wstat.t                     Legacy subtest test
+cpan/Test-Simple/t/tbm_doesnt_set_exported_to.t                        Legacy test
 cpan/Test-Simple/t/Tester/tbt_01basic.t                        Test::Builder::Tester test
 cpan/Test-Simple/t/Tester/tbt_01basic.t                        Test::Builder::Tester test
-cpan/Test-Simple/t/Tester/tbt_02fhrestore.t            Test::Builder::Tester test
+cpan/Test-Simple/t/Tester/tbt_02fhrestore.t                    Test::Builder::Tester test
 cpan/Test-Simple/t/Tester/tbt_03die.t                  Test::Builder::Tester test
 cpan/Test-Simple/t/Tester/tbt_03die.t                  Test::Builder::Tester test
-cpan/Test-Simple/t/Tester/tbt_04line_num.t             Test::Builder::Tester test
-cpan/Test-Simple/t/Tester/tbt_05faildiag.t             Test::Builder::Tester test
-cpan/Test-Simple/t/Tester/tbt_06errormess.t            Test::Builder::Tester test
+cpan/Test-Simple/t/Tester/tbt_04line_num.t                     Test::Builder::Tester test
+cpan/Test-Simple/t/Tester/tbt_05faildiag.t                     Test::Builder::Tester test
+cpan/Test-Simple/t/Tester/tbt_06errormess.t                    Test::Builder::Tester test
 cpan/Test-Simple/t/Tester/tbt_07args.t                 Test::Builder::Tester test
 cpan/Test-Simple/t/Tester/tbt_07args.t                 Test::Builder::Tester test
-cpan/Test-Simple/t/Tester/tbt_08subtest.t              Test::Builder::Tester test
-cpan/Test-Simple/t/Tester/tbt_09do_script.pl           Test::Builder::Tester test
+cpan/Test-Simple/t/Tester/tbt_08subtest.t                      Test::Builder::Tester test
+cpan/Test-Simple/t/Tester/tbt_09do_script.pl                   Test::Builder::Tester test
 cpan/Test-Simple/t/Tester/tbt_09do.t                   Test::Builder::Tester test
 cpan/Test-Simple/t/Tester/tbt_09do.t                   Test::Builder::Tester test
-cpan/Test-Simple/t/threads.t                           Test::Builder thread-safe checks
-cpan/Test-Simple/t/thread_taint.t                      Test::Simple test
-cpan/Test-Simple/t/todo.t                              Test::More test, TODO tests
-cpan/Test-Simple/t/undef.t                             Test::More test, undefs don't cause warnings
-cpan/Test-Simple/t/useing.t                            Test::More test, compile test
-cpan/Test-Simple/t/use_ok.t                            Test::More test, use_ok()
-cpan/Test-Simple/t/utf8.t                              Test::More test
-cpan/Test-Simple/t/versions.t                          Test::More test
+cpan/Test-Simple/t/Tester/tbt_is_bug.t                 Test::Builder::Tester test
+cpan/Test-Simple/t/test_use_ok.t                       Legacy Test::Builder::Test
+cpan/Test-Simple/t/threads.t                   Legacy Test::Builder::Test
+cpan/Test-Simple/t/thread_taint.t                      Legacy Test::Builder::Test
+cpan/Test-Simple/t/todo.t                      Legacy Test::Builder::Test
+cpan/Test-Simple/t/TTLegacy/auto.t                     Test for old Test::Tester
+cpan/Test-Simple/t/TTLegacy/capture.t                  Test for old Test::Tester
+cpan/Test-Simple/t/TTLegacy/check_tests.t                      Test for old Test::Tester
+cpan/Test-Simple/t/TTLegacy/depth.t                    Test for old Test::Tester
+cpan/Test-Simple/t/TTLegacy/run_test.t                 Test for old Test::Tester
+cpan/Test-Simple/t/undef.t                     Legacy Test::Builder test
+cpan/Test-Simple/t/useing.t                    Legacy Test::Builder test
+cpan/Test-Simple/t/use_ok.t                    Legacy Test::Builder test
+cpan/Test-Simple/t/utf8.t                      Legacy Test::Builder test
+cpan/Test-Simple/t/versions.t                  Test for Test::Builder version numbers
 cpan/Test/t/05_about_verbose.t See if Test works
 cpan/Test/t/fail.t             See if Test works
 cpan/Test/t/mix.t              See if Test works
 cpan/Test/t/05_about_verbose.t See if Test works
 cpan/Test/t/fail.t             See if Test works
 cpan/Test/t/mix.t              See if Test works
index 85fd312..f5e83ba 100755 (executable)
@@ -1297,7 +1297,9 @@ _cleaner2:
        -rmdir lib/autodie/Scope lib/autodie lib/XS lib/Win32API lib/VMS
        -rmdir lib/Unicode/Collate/Locale lib/Unicode/Collate/CJK
        -rmdir lib/Unicode/Collate lib/Tie/Hash lib/Thread lib/Text
        -rmdir lib/autodie/Scope lib/autodie lib/XS lib/Win32API lib/VMS
        -rmdir lib/Unicode/Collate/Locale lib/Unicode/Collate/CJK
        -rmdir lib/Unicode/Collate lib/Tie/Hash lib/Thread lib/Text
-       -rmdir lib/Test/Builder/Tester lib/Test/Builder lib/Test lib/Term
+       -rmdir lib/Test/use lib/Test/Tester lib/Test/Builder/Trace
+       -rmdir lib/Test/Builder/Tester lib/Test/Builder/Result
+       -rmdir lib/Test/Builder/Formatter lib/Test/Builder lib/Test lib/Term
        -rmdir lib/TAP/Parser/YAMLish lib/TAP/Parser/SourceHandler
        -rmdir lib/TAP/Parser/Scheduler lib/TAP/Parser/Result
        -rmdir lib/TAP/Parser/Iterator lib/TAP/Parser lib/TAP/Harness
        -rmdir lib/TAP/Parser/YAMLish lib/TAP/Parser/SourceHandler
        -rmdir lib/TAP/Parser/Scheduler lib/TAP/Parser/Result
        -rmdir lib/TAP/Parser/Iterator lib/TAP/Parser lib/TAP/Harness
index 00a3ec5..bc88477 100644 (file)
 package Test::Builder;
 
 package Test::Builder;
 
-use 5.006;
+use 5.008001;
 use strict;
 use warnings;
 
 use strict;
 use warnings;
 
-our $VERSION = '1.001003';
+use Test::Builder::Util qw/try protect/;
+use Scalar::Util();
+use Test::Builder::Stream;
+use Test::Builder::Result;
+use Test::Builder::Result::Ok;
+use Test::Builder::Result::Diag;
+use Test::Builder::Result::Note;
+use Test::Builder::Result::Plan;
+use Test::Builder::Result::Bail;
+use Test::Builder::Result::Child;
+use Test::Builder::Trace;
+
+our $VERSION = '1.301001_034';
 $VERSION = eval $VERSION;    ## no critic (BuiltinFunctions::ProhibitStringyEval)
 
 $VERSION = eval $VERSION;    ## no critic (BuiltinFunctions::ProhibitStringyEval)
 
-BEGIN {
-    if( $] < 5.008 ) {
-        require Test::Builder::IO::Scalar;
-    }
-}
-
-
-# Make Test::Builder thread-safe for ithreads.
-BEGIN {
-    use Config;
-    # Load threads::shared when threads are turned on.
-    # 5.8.0's threads are so busted we no longer support them.
-    if( $] >= 5.008001 && $Config{useithreads} && $INC{'threads.pm'} ) {
-        require threads::shared;
-
-        # Hack around YET ANOTHER threads::shared bug.  It would
-        # occasionally forget the contents of the variable when sharing it.
-        # So we first copy the data, then share, then put our copy back.
-        *share = sub (\[$@%]) {
-            my $type = ref $_[0];
-            my $data;
-
-            if( $type eq 'HASH' ) {
-                %$data = %{ $_[0] };
-            }
-            elsif( $type eq 'ARRAY' ) {
-                @$data = @{ $_[0] };
-            }
-            elsif( $type eq 'SCALAR' ) {
-                $$data = ${ $_[0] };
-            }
-            else {
-                die( "Unknown type: " . $type );
-            }
+# The mostly-singleton, and other package vars.
+our $Test  = Test::Builder->new;
+our $Level = 1;
+our $BLevel = 1;
 
 
-            $_[0] = &threads::shared::share( $_[0] );
-
-            if( $type eq 'HASH' ) {
-                %{ $_[0] } = %$data;
-            }
-            elsif( $type eq 'ARRAY' ) {
-                @{ $_[0] } = @$data;
-            }
-            elsif( $type eq 'SCALAR' ) {
-                ${ $_[0] } = $$data;
-            }
-            else {
-                die( "Unknown type: " . $type );
-            }
+####################
+# {{{ MAGIC things #
+####################
 
 
-            return $_[0];
-        };
-    }
-    # 5.8.0's threads::shared is busted when threads are off
-    # and earlier Perls just don't have that module at all.
-    else {
-        *share = sub { return $_[0] };
-        *lock  = sub { 0 };
+sub DESTROY {
+    my $self = shift;
+    if ( $self->parent and $$ == $self->{Original_Pid} ) {
+        my $name = $self->name;
+        $self->parent->{In_Destroy} = 1;
+        $self->parent->ok(0, $name, "Child ($name) exited without calling finalize()\n");
     }
 }
 
     }
 }
 
-=head1 NAME
-
-Test::Builder - Backend for building test libraries
-
-=head1 SYNOPSIS
-
-  package My::Test::Module;
-  use base 'Test::Builder::Module';
-
-  my $CLASS = __PACKAGE__;
-
-  sub ok {
-      my($test, $name) = @_;
-      my $tb = $CLASS->builder;
-
-      $tb->ok($test, $name);
-  }
-
-
-=head1 DESCRIPTION
-
-Test::Simple and Test::More have proven to be popular testing modules,
-but they're not always flexible enough.  Test::Builder provides a
-building block upon which to write your own test libraries I<which can
-work together>.
-
-=head2 Construction
-
-=over 4
-
-=item B<new>
-
-  my $Test = Test::Builder->new;
-
-Returns a Test::Builder object representing the current state of the
-test.
-
-Since you only run one test per program C<new> always returns the same
-Test::Builder object.  No matter how many times you call C<new()>, you're
-getting the same object.  This is called a singleton.  This is done so that
-multiple modules share such global information as the test counter and
-where test output is going.
-
-If you want a completely new Test::Builder object different from the
-singleton, use C<create>.
+require Test::Builder::ExitMagic;
+my $final = Test::Builder::ExitMagic->new(
+    tb => Test::Builder->create(shared_stream => 1),
+);
+END { $final->do_magic() }
 
 
-=cut
+####################
+# }}} MAGIC things #
+####################
 
 
-our $Test = Test::Builder->new;
+####################
+# {{{ Constructors #
+####################
 
 sub new {
 
 sub new {
-    my($class) = shift;
-    $Test ||= $class->create;
+    my $class = shift;
+    my %params = @_;
+    $Test ||= $class->create(shared_stream => 1);
+
     return $Test;
 }
 
     return $Test;
 }
 
-=item B<create>
-
-  my $Test = Test::Builder->create;
-
-Ok, so there can be more than one Test::Builder object and this is how
-you get it.  You might use this instead of C<new()> if you're testing
-a Test::Builder based module, but otherwise you probably want C<new>.
-
-B<NOTE>: the implementation is not complete.  C<level>, for example, is
-still shared amongst B<all> Test::Builder objects, even ones created using
-this method.  Also, the method name may change in the future.
-
-=cut
-
 sub create {
     my $class = shift;
 sub create {
     my $class = shift;
+    my %params = @_;
 
     my $self = bless {}, $class;
 
     my $self = bless {}, $class;
-    $self->reset;
+    $self->reset(%params);
 
     return $self;
 }
 
 
     return $self;
 }
 
-
 # Copy an object, currently a shallow.
 # This does *not* bless the destination.  This keeps the destructor from
 # firing when we're just storing a copy of the object to restore later.
 # Copy an object, currently a shallow.
 # This does *not* bless the destination.  This keeps the destructor from
 # firing when we're just storing a copy of the object to restore later.
@@ -155,114 +76,154 @@ sub _copy {
     my($src, $dest) = @_;
 
     %$dest = %$src;
     my($src, $dest) = @_;
 
     %$dest = %$src;
-    _share_keys($dest);
+    #_share_keys($dest); # Not sure the implications here.
 
     return;
 }
 
 
     return;
 }
 
+####################
+# }}} Constructors #
+####################
 
 
-=item B<child>
+##############################################
+# {{{ Simple accessors/generators/deligators #
+##############################################
 
 
-  my $child = $builder->child($name_of_child);
-  $child->plan( tests => 4 );
-  $child->ok(some_code());
-  ...
-  $child->finalize;
+sub listen     { shift->stream->listen(@_)     }
+sub munge      { shift->stream->munge(@_)      }
+sub tap        { shift->stream->tap            }
+sub lresults   { shift->stream->lresults       }
+sub is_passing { shift->stream->is_passing(@_) }
+sub use_fork   { shift->stream->use_fork       }
+sub no_fork    { shift->stream->no_fork        }
 
 
-Returns a new instance of C<Test::Builder>.  Any output from this child will
-be indented four spaces more than the parent's indentation.  When done, the
-C<finalize> method I<must> be called explicitly.
+BEGIN {
+    Test::Builder::Util::accessors(qw/Parent Name _old_level _bailed_out default_name/);
+    Test::Builder::Util::accessor(modern => sub {$ENV{TB_MODERN} || 0});
+    Test::Builder::Util::accessor(depth  => sub { 0 });
+}
 
 
-Trying to create a new child with a previous child still active (i.e.,
-C<finalize> not called) will C<croak>.
+##############################################
+# }}} Simple accessors/generators/deligators #
+##############################################
 
 
-Trying to run a test when you have an open child will also C<croak> and cause
-the test suite to fail.
+#########################
+# {{{ Stream Management #
+#########################
+
+sub stream {
+    my $self = shift;
+
+    ($self->{stream}) = @_ if @_;
 
 
-=cut
+    # If no stream is set use shared. We do not want to cache that we use
+    # shared cause shared is a stack, not a constant, and we always want the
+    # top.
+    return $self->{stream} || Test::Builder::Stream->shared;
+}
+
+sub intercept {
+    my $self = shift;
+    my ($code) = @_;
+
+    Carp::croak("argument to intercept must be a coderef, got: $code")
+        unless reftype $code eq 'CODE';
+
+    my $stream = Test::Builder::Stream->new(no_follow => 1) || die "Internal Error!";
+    $stream->exception_followup;
+
+    local $self->{stream} = $stream;
+
+    my @results;
+    $stream->listen(INTERCEPTOR => sub {
+        my ($item) = @_;
+        push @results => $item;
+    });
+    $code->($stream);
+
+    return \@results;
+}
+
+#########################
+# }}} Stream Management #
+#########################
+
+#############################
+# {{{ Children and subtests #
+#############################
 
 sub child {
 
 sub child {
-    my( $self, $name ) = @_;
+    my( $self, $name, $is_subtest ) = @_;
 
 
-    if( $self->{Child_Name} ) {
-        $self->croak("You already have a child named ($self->{Child_Name}) running");
-    }
+    $self->croak("You already have a child named ($self->{Child_Name}) running")
+        if $self->{Child_Name};
 
     my $parent_in_todo = $self->in_todo;
 
     # Clear $TODO for the child.
     my $orig_TODO = $self->find_TODO(undef, 1, undef);
 
 
     my $parent_in_todo = $self->in_todo;
 
     # Clear $TODO for the child.
     my $orig_TODO = $self->find_TODO(undef, 1, undef);
 
-    my $class = ref $self;
+    my $class = Scalar::Util::blessed($self);
     my $child = $class->create;
 
     my $child = $class->create;
 
-    # Add to our indentation
-    $child->_indent( $self->_indent . '    ' );
-
-    # Make the child use the same outputs as the parent
-    for my $method (qw(output failure_output todo_output)) {
-        $child->$method( $self->$method );
-    }
+    $child->{stream} = $self->stream->spawn;
 
     # Ensure the child understands if they're inside a TODO
 
     # Ensure the child understands if they're inside a TODO
-    if( $parent_in_todo ) {
-        $child->failure_output( $self->todo_output );
-    }
+    $child->tap->failure_output($self->tap->todo_output)
+        if $parent_in_todo && $self->tap;
 
     # This will be reset in finalize. We do this here lest one child failure
     # cause all children to fail.
     $child->{Child_Error} = $?;
     $?                    = 0;
 
     # This will be reset in finalize. We do this here lest one child failure
     # cause all children to fail.
     $child->{Child_Error} = $?;
     $?                    = 0;
+
     $child->{Parent}      = $self;
     $child->{Parent_TODO} = $orig_TODO;
     $child->{Name}        = $name || "Child of " . $self->name;
     $child->{Parent}      = $self;
     $child->{Parent_TODO} = $orig_TODO;
     $child->{Name}        = $name || "Child of " . $self->name;
-    $self->{Child_Name}   = $child->name;
-    return $child;
-}
 
 
+    $self->{Child_Name}   = $child->name;
 
 
-=item B<subtest>
-
-    $builder->subtest($name, \&subtests);
+    $child->depth($self->depth + 1);
 
 
-See documentation of C<subtest> in Test::More.
+    my $res = Test::Builder::Result::Child->new(
+        $self->context,
+        name    => $child->name,
+        action  => 'push',
+        in_todo => $self->in_todo || 0,
+        is_subtest => $is_subtest || 0,
+    );
+    $self->stream->send($res);
 
 
-=cut
+    return $child;
+}
 
 sub subtest {
     my $self = shift;
 
 sub subtest {
     my $self = shift;
-    my($name, $subtests) = @_;
+    my($name, $subtests, @args) = @_;
 
 
-    if ('CODE' ne ref $subtests) {
-        $self->croak("subtest()'s second argument must be a code ref");
-    }
+    $self->croak("subtest()'s second argument must be a code ref")
+        unless $subtests && 'CODE' eq Scalar::Util::reftype($subtests);
 
     # Turn the child into the parent so anyone who has stored a copy of
     # the Test::Builder singleton will get the child.
 
     # Turn the child into the parent so anyone who has stored a copy of
     # the Test::Builder singleton will get the child.
-    my $error;
-    my $child;
+    my ($success, $error, $child);
     my $parent = {};
     {
     my $parent = {};
     {
-        # child() calls reset() which sets $Level to 1, so we localize
-        # $Level first to limit the scope of the reset to the subtest.
-        local $Test::Builder::Level = $Test::Builder::Level + 1;
+        local $Level = $Level + 1; local $BLevel = $BLevel + 1;
 
         # Store the guts of $self as $parent and turn $child into $self.
 
         # Store the guts of $self as $parent and turn $child into $self.
-        $child  = $self->child($name);
+        $child  = $self->child($name, 1);
+
         _copy($self,  $parent);
         _copy($child, $self);
 
         my $run_the_subtests = sub {
         _copy($self,  $parent);
         _copy($child, $self);
 
         my $run_the_subtests = sub {
-            # Add subtest name for clarification of starting point
-            $self->note("Subtest: $name");
-            $subtests->();
-            $self->done_testing unless $self->_plan_handled;
+            $subtests->(@args);
+            $self->done_testing unless defined $self->stream->plan;
             1;
         };
 
             1;
         };
 
-        if( !eval { $run_the_subtests->() } ) {
-            $error = $@;
-        }
+        ($success, $error) = try { Test::Builder::Trace->nest($run_the_subtests) };
     }
 
     # Restore the parent and the copied child.
     }
 
     # Restore the parent and the copied child.
@@ -273,68 +234,19 @@ sub subtest {
     $self->find_TODO(undef, 1, $child->{Parent_TODO});
 
     # Die *after* we restore the parent.
     $self->find_TODO(undef, 1, $child->{Parent_TODO});
 
     # Die *after* we restore the parent.
-    die $error if $error and !eval { $error->isa('Test::Builder::Exception') };
+    die $error if $error && !(Scalar::Util::blessed($error) && $error->isa('Test::Builder::Exception'));
 
 
-    local $Test::Builder::Level = $Test::Builder::Level + 1;
-    my $finalize = $child->finalize;
+    local $Level = $Level + 1; local $BLevel = $BLevel + 1;
+    my $finalize = $child->finalize(1);
 
 
-    $self->BAIL_OUT($child->{Bailed_Out_Reason}) if $child->{Bailed_Out};
+    $self->BAIL_OUT($child->{Bailed_Out_Reason}) if $child->_bailed_out;
 
     return $finalize;
 }
 
 
     return $finalize;
 }
 
-=begin _private
-
-=item B<_plan_handled>
-
-    if ( $Test->_plan_handled ) { ... }
-
-Returns true if the developer has explicitly handled the plan via:
-
-=over 4
-
-=item * Explicitly setting the number of tests
-
-=item * Setting 'no_plan'
-
-=item * Set 'skip_all'.
-
-=back
-
-This is currently used in subtests when we implicitly call C<< $Test->done_testing >>
-if the developer has not set a plan.
-
-=end _private
-
-=cut
-
-sub _plan_handled {
-    my $self = shift;
-    return $self->{Have_Plan} || $self->{No_Plan} || $self->{Skip_All};
-}
-
-
-=item B<finalize>
-
-  my $ok = $child->finalize;
-
-When your child is done running tests, you must call C<finalize> to clean up
-and tell the parent your pass/fail status.
-
-Calling finalize on a child with open children will C<croak>.
-
-If the child falls out of scope before C<finalize> is called, a failure
-diagnostic will be issued and the child is considered to have failed.
-
-No attempt to call methods on a child after C<finalize> is called is
-guaranteed to succeed.
-
-Calling this on the root builder is a no-op.
-
-=cut
-
 sub finalize {
     my $self = shift;
 sub finalize {
     my $self = shift;
+    my ($is_subtest) = @_;
 
     return unless $self->parent;
     if( $self->{Child_Name} ) {
 
     return unless $self->parent;
     if( $self->{Child_Name} ) {
@@ -344,568 +256,720 @@ sub finalize {
     local $? = 0;     # don't fail if $subtests happened to set $? nonzero
     $self->_ending;
 
     local $? = 0;     # don't fail if $subtests happened to set $? nonzero
     $self->_ending;
 
-    # XXX This will only be necessary for TAP envelopes (we think)
-    #$self->_print( $self->is_passing ? "PASS\n" : "FAIL\n" );
-
-    local $Test::Builder::Level = $Test::Builder::Level + 1;
+    local $Level = $Level + 1; local $BLevel = $BLevel + 1;
     my $ok = 1;
     $self->parent->{Child_Name} = undef;
     my $ok = 1;
     $self->parent->{Child_Name} = undef;
-    unless ($self->{Bailed_Out}) {
+
+    unless ($self->_bailed_out) {
         if ( $self->{Skip_All} ) {
             $self->parent->skip($self->{Skip_All});
         }
         if ( $self->{Skip_All} ) {
             $self->parent->skip($self->{Skip_All});
         }
-        elsif ( not @{ $self->{Test_Results} } ) {
+        elsif ( ! $self->stream->tests_run ) {
             $self->parent->ok( 0, sprintf q[No tests run for subtest "%s"], $self->name );
         }
         else {
             $self->parent->ok( $self->is_passing, $self->name );
         }
     }
             $self->parent->ok( 0, sprintf q[No tests run for subtest "%s"], $self->name );
         }
         else {
             $self->parent->ok( $self->is_passing, $self->name );
         }
     }
+
     $? = $self->{Child_Error};
     $? = $self->{Child_Error};
-    delete $self->{Parent};
+    my $parent = delete $self->{Parent};
+
+    my $res = Test::Builder::Result::Child->new(
+        $self->context,
+        name    => $self->{Name} || undef,
+        action  => 'pop',
+        in_todo => $self->in_todo || 0,
+        is_subtest => $is_subtest || 0,
+    );
+    $parent->stream->send($res);
 
     return $self->is_passing;
 }
 
 
     return $self->is_passing;
 }
 
-sub _indent      {
-    my $self = shift;
+#############################
+# }}} Children and subtests #
+#############################
 
 
-    if( @_ ) {
-        $self->{Indent} = shift;
-    }
+#####################################
+# {{{ Finding Testers and Providers #
+#####################################
 
 
-    return $self->{Indent};
+sub trace_test {
+    my $out;
+    protect { $out = Test::Builder::Trace->new };
+    return $out;
 }
 
 }
 
-=item B<parent>
-
- if ( my $parent = $builder->parent ) {
-     ...
- }
+sub find_TODO {
+    my( $self, $pack, $set, $new_value ) = @_;
 
 
-Returns the parent C<Test::Builder> instance, if any.  Only used with child
-builders for nested TAP.
+    $pack ||= $self->trace_test->todo_package || $self->exported_to;
+    return unless $pack;
 
 
-=cut
+    no strict 'refs';    ## no critic
+    no warnings 'once';
+    my $old_value = ${ $pack . '::TODO' };
+    $set and ${ $pack . '::TODO' } = $new_value;
+    return $old_value;
+}
 
 
-sub parent { shift->{Parent} }
+#####################################
+# }}} Finding Testers and Providers #
+#####################################
 
 
-=item B<name>
+################
+# {{{ Planning #
+################
 
 
- diag $builder->name;
+my %PLAN_CMDS = (
+    no_plan  => 'no_plan',
+    skip_all => 'skip_all',
+    tests    => '_plan_tests',
+);
 
 
-Returns the name of the current builder.  Top level builders default to C<$0>
-(the name of the executable).  Child builders are named via the C<child>
-method.  If no name is supplied, will be named "Child of $parent->name".
+sub plan {
+    my( $self, $cmd, $arg ) = @_;
 
 
-=cut
+    return unless $cmd;
 
 
-sub name { shift->{Name} }
+    local $Level = $Level + 1; local $BLevel = $BLevel + 1;
 
 
-sub DESTROY {
-    my $self = shift;
-    if ( $self->parent and $$ == $self->{Original_Pid} ) {
-        my $name = $self->name;
-        $self->diag(<<"FAIL");
-Child ($name) exited without calling finalize()
-FAIL
-        $self->parent->{In_Destroy} = 1;
-        $self->parent->ok(0, $name);
+    if( my $method = $PLAN_CMDS{$cmd} ) {
+        local $Level = $Level + 1; local $BLevel = $BLevel + 1;
+        $self->$method($arg);
+    }
+    else {
+        my @args = grep { defined } ( $cmd, $arg );
+        $self->croak("plan() doesn't understand @args");
     }
     }
+
+    return 1;
 }
 
 }
 
-=item B<reset>
+sub skip_all {
+    my( $self, $reason ) = @_;
 
 
-  $Test->reset;
+    $self->{Skip_All} = $self->parent ? $reason : 1;
 
 
-Reinitializes the Test::Builder singleton to its original state.
-Mostly useful for tests run in persistent environments where the same
-test might be run multiple times in the same process.
+    die bless {} => 'Test::Builder::Exception' if $self->parent;
+    $self->_issue_plan(0, "SKIP", $reason);
+}
 
 
-=cut
+sub no_plan {
+    my($self, $arg) = @_;
 
 
-our $Level;
+    $self->carp("no_plan takes no arguments") if $arg;
 
 
-sub reset {    ## no critic (Subroutines::ProhibitBuiltinHomonyms)
-    my($self) = @_;
+    $self->_issue_plan(undef, "NO_PLAN");
 
 
-    # We leave this a global because it has to be localized and localizing
-    # hash keys is just asking for pain.  Also, it was documented.
-    $Level = 1;
+    return 1;
+}
 
 
-    $self->{Name}         = $0;
-    $self->is_passing(1);
-    $self->{Ending}       = 0;
-    $self->{Have_Plan}    = 0;
-    $self->{No_Plan}      = 0;
-    $self->{Have_Output_Plan} = 0;
-    $self->{Done_Testing} = 0;
+sub _plan_tests {
+    my($self, $arg) = @_;
 
 
-    $self->{Original_Pid} = $$;
-    $self->{Child_Name}   = undef;
-    $self->{Indent}     ||= '';
+    if($arg) {
+        $self->croak("Number of tests must be a positive integer.  You gave it '$arg'")
+            unless $arg =~ /^\+?\d+$/;
 
 
-    $self->{Curr_Test} = 0;
-    $self->{Test_Results} = &share( [] );
+        $self->_issue_plan($arg);
+    }
+    elsif( !defined $arg ) {
+        $self->croak("Got an undefined number of tests");
+    }
+    else {
+        $self->croak("You said to run 0 tests");
+    }
 
 
-    $self->{Exported_To}    = undef;
-    $self->{Expected_Tests} = 0;
+    return;
+}
 
 
-    $self->{Skip_All} = 0;
+sub _issue_plan {
+    my($self, $max, $directive, $reason) = @_;
 
 
-    $self->{Use_Nums} = 1;
+    if ($directive && $directive eq 'OVERRIDE') {
+        $directive = undef;
+    }
+    elsif ($self->stream->plan) {
+        $self->croak("You tried to plan twice");
+    }
 
 
-    $self->{No_Header} = 0;
-    $self->{No_Ending} = 0;
+    my $plan = Test::Builder::Result::Plan->new(
+        $self->context,
+        directive => $directive     || undef,
+        reason    => $reason        || undef,
+        in_todo   => $self->in_todo || 0,
 
 
-    $self->{Todo}       = undef;
-    $self->{Todo_Stack} = [];
-    $self->{Start_Todo} = 0;
-    $self->{Opened_Testhandles} = 0;
+        max => defined($max) ? $max : undef,
+    );
 
 
-    $self->_share_keys;
-    $self->_dup_stdhandles;
+    $self->stream->send($plan);
 
 
-    return;
+    return $plan;
 }
 
 }
 
+sub done_testing {
+    my($self, $num_tests) = @_;
 
 
-# Shared scalar values are lost when a hash is copied, so we have
-# a separate method to restore them.
-# Shared references are retained across copies.
-sub _share_keys {
-    my $self = shift;
+    my $expected = $self->stream->expected_tests;
+    my $total    = $self->stream->tests_run;
 
 
-    share( $self->{Curr_Test} );
+    # If done_testing() specified the number of tests, shut off no_plan.
+    if(defined $num_tests && !defined $expected) {
+        $self->_issue_plan($num_tests, 'OVERRIDE');
+        $expected = $num_tests;
+    }
 
 
-    return;
-}
+    if( $self->{Done_Testing} ) {
+        my($file, $line) = @{$self->{Done_Testing}}[1,2];
+        my $ok = Test::Builder::Result::Ok->new(
+            $self->context,
+            real_bool => 0,
+            name      => "done_testing() was already called at $file line $line",
+            bool      => $self->in_todo ? 1 : 0,
+            in_todo   => $self->in_todo || 0,
+            todo      => $self->in_todo ? $self->todo() || "" : "",
+        );
+        $self->stream->send($ok);
+        $self->is_passing(0) unless $self->in_todo;
 
 
+        return;
+    }
 
 
-=back
+    $self->{Done_Testing} = [caller];
 
 
-=head2 Setting up tests
+    if ($expected && defined($num_tests) && $num_tests != $expected) {
+        my $ok = Test::Builder::Result::Ok->new(
+            $self->context,
+            real_bool => 0,
+            name      => "planned to run $expected but done_testing() expects $num_tests",
+            bool      => $self->in_todo ? 1 : 0,
+            in_todo   => $self->in_todo || 0,
+            todo      => $self->in_todo ? $self->todo() || "" : "",
+        );
+        $self->stream->send($ok);
+        $self->is_passing(0) unless $self->in_todo;
+    }
 
 
-These methods are for setting up tests and declaring how many there
-are.  You usually only want to call one of these methods.
 
 
-=over 4
+    $self->_issue_plan($total) unless $expected;
 
 
-=item B<plan>
+    # The wrong number of tests were run
+    $self->is_passing(0) if defined $expected && $expected != $total;
 
 
-  $Test->plan('no_plan');
-  $Test->plan( skip_all => $reason );
-  $Test->plan( tests => $num_tests );
+    # No tests were run
+    $self->is_passing(0) unless $total;
 
 
-A convenient way to set up your tests.  Call this and Test::Builder
-will print the appropriate headers and take the appropriate actions.
+    return 1;
+}
 
 
-If you call C<plan()>, don't call any of the other methods below.
+################
+# }}} Planning #
+################
 
 
-If a child calls "skip_all" in the plan, a C<Test::Builder::Exception> is
-thrown.  Trap this error, call C<finalize()> and don't run any more tests on
-the child.
+#############################
+# {{{ Base Result Producers #
+#############################
 
 
- my $child = $Test->child('some child');
- eval { $child->plan( $condition ? ( skip_all => $reason ) : ( tests => 3 )  ) };
- if ( eval { $@->isa('Test::Builder::Exception') } ) {
-    $child->finalize;
-    return;
- }
- # run your tests
+sub _ok_obj {
+    my $self = shift;
+    my( $test, $name, @diag ) = @_;
 
 
-=cut
+    if ( $self->{Child_Name} and not $self->{In_Destroy} ) {
+        $name = 'unnamed test' unless defined $name;
+        $self->is_passing(0);
+        $self->croak("Cannot run test ($name) with active children");
+    }
 
 
-my %plan_cmds = (
-    no_plan     => \&no_plan,
-    skip_all    => \&skip_all,
-    tests       => \&_plan_tests,
-);
+    # $test might contain an object which we don't want to accidentally
+    # store, so we turn it into a boolean.
+    $test = $test ? 1 : 0;
 
 
-sub plan {
-    my( $self, $cmd, $arg ) = @_;
+    # In case $name is a string overloaded object, force it to stringify.
+    $self->_unoverload_str( \$name );
 
 
-    return unless $cmd;
+    # Capture the value of $TODO for the rest of this ok() call
+    # so it can more easily be found by other routines.
+    my $todo    = $self->todo();
+    my $in_todo = $self->in_todo;
+    local $self->{Todo} = $todo if $in_todo;
 
 
-    local $Level = $Level + 1;
+    $self->_unoverload_str( \$todo );
 
 
-    $self->croak("You tried to plan twice") if $self->{Have_Plan};
+    my $ok = Test::Builder::Result::Ok->new(
+        $self->context,
+        real_bool => $test,
+        bool      => $self->in_todo ? 1 : $test,
+        name      => $name          || $self->default_name || undef,
+        in_todo   => $self->in_todo || 0,
+        diag      => \@diag,
+    );
 
 
-    if( my $method = $plan_cmds{$cmd} ) {
-        local $Level = $Level + 1;
-        $self->$method($arg);
+    # # in a name can confuse Test::Harness.
+    $name =~ s|#|\\#|g if defined $name;
+
+    if( $self->in_todo ) {
+        $ok->todo($todo);
+        $ok->in_todo(1);
     }
     }
-    else {
-        my @args = grep { defined } ( $cmd, $arg );
-        $self->croak("plan() doesn't understand @args");
+
+    if (defined $name and $name =~ /^[\d\s]+$/) {
+        $ok->diag(<<"        ERR");
+    You named your test '$name'.  You shouldn't use numbers for your test names.
+    Very confusing.
+        ERR
     }
 
     }
 
-    return 1;
+    return $ok;
 }
 
 }
 
+sub ok {
+    my $self = shift;
+    my( $test, $name, @diag ) = @_;
 
 
-sub _plan_tests {
-    my($self, $arg) = @_;
+    my $ok = $self->_ok_obj($test, $name, @diag);
+    $self->_record_ok($ok);
 
 
-    if($arg) {
-        local $Level = $Level + 1;
-        return $self->expected_tests($arg);
-    }
-    elsif( !defined $arg ) {
-        $self->croak("Got an undefined number of tests");
-    }
-    else {
-        $self->croak("You said to run 0 tests");
-    }
-
-    return;
+    return $test ? 1 : 0;
 }
 
 }
 
-=item B<expected_tests>
-
-    my $max = $Test->expected_tests;
-    $Test->expected_tests($max);
+sub _record_ok {
+    my $self = shift;
+    my ($ok) = @_;
 
 
-Gets/sets the number of tests we expect this test to run and prints out
-the appropriate headers.
+    $self->stream->send($ok);
 
 
-=cut
+    $self->is_passing(0) unless $ok->real_bool || $self->in_todo;
 
 
-sub expected_tests {
-    my $self = shift;
-    my($max) = @_;
+    # Check that we haven't violated the plan
+    $self->_check_is_passing_plan();
+}
 
 
-    if(@_) {
-        $self->croak("Number of tests must be a positive integer.  You gave it '$max'")
-          unless $max =~ /^\+?\d+$/;
+sub BAIL_OUT {
+    my( $self, $reason ) = @_;
 
 
-        $self->{Expected_Tests} = $max;
-        $self->{Have_Plan}      = 1;
+    $self->_bailed_out(1);
 
 
-        $self->_output_plan($max) unless $self->no_header;
+    if ($self->parent) {
+        $self->{Bailed_Out_Reason} = $reason;
+        $self->no_ending(1);
+        die bless {} => 'Test::Builder::Exception';
     }
     }
-    return $self->{Expected_Tests};
+
+    my $bail = Test::Builder::Result::Bail->new(
+        $self->context,
+        reason  => $reason,
+        in_todo => $self->in_todo || 0,
+    );
+    $self->stream->send($bail);
 }
 
 }
 
-=item B<no_plan>
+sub skip {
+    my( $self, $why ) = @_;
+    $why ||= '';
+    $self->_unoverload_str( \$why );
 
 
-  $Test->no_plan;
+    my $ok = Test::Builder::Result::Ok->new(
+        $self->context,
+        real_bool => 1,
+        bool      => 1,
+        in_todo   => $self->in_todo || 0,
+        skip      => $why,
+    );
 
 
-Declares that this test will run an indeterminate number of tests.
+    $self->stream->send($ok);
+}
 
 
-=cut
+sub todo_skip {
+    my( $self, $why ) = @_;
+    $why ||= '';
 
 
-sub no_plan {
-    my($self, $arg) = @_;
+    my $ok = Test::Builder::Result::Ok->new(
+        $self->context,
+        real_bool => 0,
+        bool      => 1,
+        in_todo   => $self->in_todo || 0,
+        skip      => $why,
+        todo      => $why,
+    );
 
 
-    $self->carp("no_plan takes no arguments") if $arg;
+    $self->stream->send($ok);
+}
 
 
-    $self->{No_Plan}   = 1;
-    $self->{Have_Plan} = 1;
+sub diag {
+    my $self = shift;
 
 
-    return 1;
-}
+    my $msg = join '', map { defined($_) ? $_ : 'undef' } @_;
 
 
-=begin private
+    my $r = Test::Builder::Result::Diag->new(
+        $self->context,
+        in_todo => $self->in_todo || 0,
+        message => $msg,
+    );
+    $self->stream->send($r);
+}
 
 
-=item B<_output_plan>
+sub note {
+    my $self = shift;
 
 
-  $tb->_output_plan($max);
-  $tb->_output_plan($max, $directive);
-  $tb->_output_plan($max, $directive => $reason);
+    my $msg = join '', map { defined($_) ? $_ : 'undef' } @_;
 
 
-Handles displaying the test plan.
+    my $r = Test::Builder::Result::Note->new(
+        $self->context,
+        in_todo => $self->in_todo || 0,
+        message => $msg,
+    );
+    $self->stream->send($r);
+}
 
 
-If a C<$directive> and/or C<$reason> are given they will be output with the
-plan.  So here's what skipping all tests looks like:
+#############################
+# }}} Base Result Producers #
+#############################
 
 
-    $tb->_output_plan(0, "SKIP", "Because I said so");
+#################################
+# {{{ Advanced Result Producers #
+#################################
 
 
-It sets C<< $tb->{Have_Output_Plan} >> and will croak if the plan was already
-output.
+my %numeric_cmps = map { ( $_, 1 ) } ( "<", "<=", ">", ">=", "==", "!=", "<=>" );
 
 
-=end private
+# Bad, these are not comparison operators. Should we include more?
+my %cmp_ok_bl = map { ( $_, 1 ) } ( "=", "+=", ".=", "x=", "^=", "|=", "||=", "&&=", "...");
 
 
-=cut
+sub cmp_ok {
+    my( $self, $got, $type, $expect, $name ) = @_;
 
 
-sub _output_plan {
-    my($self, $max, $directive, $reason) = @_;
+    if ($cmp_ok_bl{$type}) {
+        $self->croak("$type is not a valid comparison operator in cmp_ok()");
+    }
 
 
-    $self->carp("The plan was already output") if $self->{Have_Output_Plan};
+    my $test;
+    my $error;
+    my @diag;
 
 
-    my $plan = "1..$max";
-    $plan .= " # $directive" if defined $directive;
-    $plan .= " $reason"      if defined $reason;
+    my($pack, $file, $line) = $self->trace_test->report->call;
 
 
-    $self->_print("$plan\n");
+    (undef, $error) = try {
+        # This is so that warnings come out at the caller's level
+        ## no critic (BuiltinFunctions::ProhibitStringyEval)
+        eval qq[
+#line $line "(eval in cmp_ok) $file"
+\$test = \$got $type \$expect;
+1;
+        ] || die $@;
+    };
 
 
-    $self->{Have_Output_Plan} = 1;
+    # Treat overloaded objects as numbers if we're asked to do a
+    # numeric comparison.
+    my $unoverload
+      = $numeric_cmps{$type}
+      ? '_unoverload_num'
+      : '_unoverload_str';
 
 
-    return;
-}
+    push @diag => <<"END" if $error;
+An error occurred while using $type:
+------------------------------------
+$error
+------------------------------------
+END
 
 
+    unless($test) {
+        $self->$unoverload( \$got, \$expect );
 
 
-=item B<done_testing>
+        if( $type =~ /^(eq|==)$/ ) {
+            push @diag => $self->_is_diag( $got, $type, $expect );
+        }
+        elsif( $type =~ /^(ne|!=)$/ ) {
+            push @diag => $self->_isnt_diag( $got, $type );
+        }
+        else {
+            push @diag => $self->_cmp_diag( $got, $type, $expect );
+        }
+    }
 
 
-  $Test->done_testing();
-  $Test->done_testing($num_tests);
+    local $Level = $Level + 1; local $BLevel = $BLevel + 1;
+    $self->ok($test, $name, @diag);
 
 
-Declares that you are done testing, no more tests will be run after this point.
+    return $test ? 1 : 0;
+}
 
 
-If a plan has not yet been output, it will do so.
 
 
-$num_tests is the number of tests you planned to run.  If a numbered
-plan was already declared, and if this contradicts, a failing test
-will be run to reflect the planning mistake.  If C<no_plan> was declared,
-this will override.
+sub is_eq {
+    my( $self, $got, $expect, $name ) = @_;
+    local $Level = $Level + 1; local $BLevel = $BLevel + 1;
 
 
-If C<done_testing()> is called twice, the second call will issue a
-failing test.
+    if( !defined $got || !defined $expect ) {
+        # undef only matches undef and nothing else
+        my $test = !defined $got && !defined $expect;
 
 
-If C<$num_tests> is omitted, the number of tests run will be used, like
-no_plan.
+        $self->ok($test, $name, $test ? () : $self->_is_diag( $got, 'eq', $expect ));
+        return $test;
+    }
 
 
-C<done_testing()> is, in effect, used when you'd want to use C<no_plan>, but
-safer. You'd use it like so:
+    return $self->cmp_ok( $got, 'eq', $expect, $name );
+}
 
 
-    $Test->ok($a == $b);
-    $Test->done_testing();
+sub is_num {
+    my( $self, $got, $expect, $name ) = @_;
+    local $Level = $Level + 1; local $BLevel = $BLevel + 1;
 
 
-Or to plan a variable number of tests:
+    if( !defined $got || !defined $expect ) {
+        # undef only matches undef and nothing else
+        my $test = !defined $got && !defined $expect;
 
 
-    for my $test (@tests) {
-        $Test->ok($test);
+        $self->ok($test, $name, $test ? () : $self->_is_diag( $got, '==', $expect ));
+        return $test;
     }
     }
-    $Test->done_testing(scalar @tests);
 
 
-=cut
+    return $self->cmp_ok( $got, '==', $expect, $name );
+}
 
 
-sub done_testing {
-    my($self, $num_tests) = @_;
+sub isnt_eq {
+    my( $self, $got, $dont_expect, $name ) = @_;
+    local $Level = $Level + 1; local $BLevel = $BLevel + 1;
 
 
-    # If done_testing() specified the number of tests, shut off no_plan.
-    if( defined $num_tests ) {
-        $self->{No_Plan} = 0;
-    }
-    else {
-        $num_tests = $self->current_test;
-    }
+    if( !defined $got || !defined $dont_expect ) {
+        # undef only matches undef and nothing else
+        my $test = defined $got || defined $dont_expect;
 
 
-    if( $self->{Done_Testing} ) {
-        my($file, $line) = @{$self->{Done_Testing}}[1,2];
-        $self->ok(0, "done_testing() was already called at $file line $line");
-        return;
+        $self->ok( $test, $name, $test ? () : $self->_isnt_diag( $got, 'ne' ));
+        return $test;
     }
 
     }
 
-    $self->{Done_Testing} = [caller];
+    return $self->cmp_ok( $got, 'ne', $dont_expect, $name );
+}
 
 
-    if( $self->expected_tests && $num_tests != $self->expected_tests ) {
-        $self->ok(0, "planned to run @{[ $self->expected_tests ]} ".
-                     "but done_testing() expects $num_tests");
-    }
-    else {
-        $self->{Expected_Tests} = $num_tests;
-    }
+sub isnt_num {
+    my( $self, $got, $dont_expect, $name ) = @_;
+    local $Level = $Level + 1; local $BLevel = $BLevel + 1;
 
 
-    $self->_output_plan($num_tests) unless $self->{Have_Output_Plan};
+    if( !defined $got || !defined $dont_expect ) {
+        # undef only matches undef and nothing else
+        my $test = defined $got || defined $dont_expect;
 
 
-    $self->{Have_Plan} = 1;
+        $self->ok( $test, $name, $test ? () : $self->_isnt_diag( $got, '!=' ));
+        return $test;
+    }
 
 
-    # The wrong number of tests were run
-    $self->is_passing(0) if $self->{Expected_Tests} != $self->{Curr_Test};
+    return $self->cmp_ok( $got, '!=', $dont_expect, $name );
+}
 
 
-    # No tests were run
-    $self->is_passing(0) if $self->{Curr_Test} == 0;
+sub like {
+    my( $self, $thing, $regex, $name ) = @_;
+    local $Level = $Level + 1; local $BLevel = $BLevel + 1;
 
 
-    return 1;
+    return $self->_regex_ok( $thing, $regex, '=~', $name );
 }
 
 }
 
+sub unlike {
+    my( $self, $thing, $regex, $name ) = @_;
+    local $Level = $Level + 1; local $BLevel = $BLevel + 1;
 
 
-=item B<has_plan>
+    return $self->_regex_ok( $thing, $regex, '!~', $name );
+}
 
 
-  $plan = $Test->has_plan
 
 
-Find out whether a plan has been defined. C<$plan> is either C<undef> (no plan
-has been set), C<no_plan> (indeterminate # of tests) or an integer (the number
-of expected tests).
 
 
-=cut
+#################################
+# }}} Advanced Result Producers #
+#################################
 
 
-sub has_plan {
-    my $self = shift;
+#######################
+# {{{ Public helpers #
+#######################
 
 
-    return( $self->{Expected_Tests} ) if $self->{Expected_Tests};
-    return('no_plan') if $self->{No_Plan};
-    return(undef);
-}
+sub explain {
+    my $self = shift;
 
 
-=item B<skip_all>
+    return map {
+        ref $_
+          ? do {
+            $self->_try(sub { require Data::Dumper }, die_on_fail => 1);
 
 
-  $Test->skip_all;
-  $Test->skip_all($reason);
+            my $dumper = Data::Dumper->new( [$_] );
+            $dumper->Indent(1)->Terse(1);
+            $dumper->Sortkeys(1) if $dumper->can("Sortkeys");
+            $dumper->Dump;
+          }
+          : $_
+    } @_;
+}
 
 
-Skips all the tests, using the given C<$reason>.  Exits immediately with 0.
+sub carp {
+    my $self = shift;
+    return warn $self->_message_at_caller(@_);
+}
 
 
-=cut
+sub croak {
+    my $self = shift;
+    return die $self->_message_at_caller(@_);
+}
 
 
-sub skip_all {
-    my( $self, $reason ) = @_;
+sub context {
+    my $self = shift;
 
 
-    $self->{Skip_All} = $self->parent ? $reason : 1;
+    my $trace = $self->trace_test;
 
 
-    $self->_output_plan(0, "SKIP", $reason) unless $self->no_header;
-    if ( $self->parent ) {
-        die bless {} => 'Test::Builder::Exception';
-    }
-    exit(0);
+    return (
+        depth  => $self->depth,
+        source => $self->name || "",
+        trace  => $trace,
+    );
 }
 
 }
 
-=item B<exported_to>
+sub has_plan {
+    my $self = shift;
 
 
-  my $pack = $Test->exported_to;
-  $Test->exported_to($pack);
+    return($self->stream->expected_tests) if $self->stream->expected_tests;
+    return('no_plan') if $self->stream->plan;
+    return(undef);
+}
 
 
-Tells Test::Builder what package you exported your functions to.
+sub reset {    ## no critic (Subroutines::ProhibitBuiltinHomonyms)
+    my $self = shift;
+    my %params;
 
 
-This method isn't terribly useful since modules which share the same
-Test::Builder object might get exported to different packages and only
-the last one will be honored.
+    if (@_) {
+        %params = @_;
+        $self->{reset_params} = \%params;
+    }
+    else {
+        %params = %{$self->{reset_params} || {}};
+    }
 
 
-=cut
+    my $modern = $params{modern} || $self->modern || 0;
+    $self->modern($modern);
 
 
-sub exported_to {
-    my( $self, $pack ) = @_;
+    # We leave this a global because it has to be localized and localizing
+    # hash keys is just asking for pain.  Also, it was documented.
+    $Level = 1;
+    $BLevel = 1;
 
 
-    if( defined $pack ) {
-        $self->{Exported_To} = $pack;
+    if ($params{new_stream} || !$params{shared_stream}) {
+        my $olds = $self->stream;
+        $self->{stream} = Test::Builder::Stream->new;
+        $self->{stream}->use_lresults if $olds->lresults;
     }
     }
-    return $self->{Exported_To};
-}
-
-=back
 
 
-=head2 Running tests
+    $final->pid($$) if $final;
 
 
-These actually run the tests, analogous to the functions in Test::More.
+    $self->stream->use_tap unless $params{no_tap} || $ENV{TB_NO_TAP};
 
 
-They all return true if the test passed, false if the test failed.
+    $self->stream->plan(undef) unless $params{no_reset_plan};
 
 
-C<$name> is always optional.
-
-=over 4
+    # Don't reset stream stuff when reseting/creating a modern TB object
+    unless ($modern) {
+        $self->stream->no_ending(0);
+        $self->tap->reset      if $self->tap;
+        $self->lresults->reset if $self->lresults;
+    }
 
 
-=item B<ok>
+    $self->{Name}  = $0;
 
 
-  $Test->ok($test, $name);
+    $self->{Have_Issued_Plan} = 0;
+    $self->{Done_Testing}     = 0;
+    $self->{Skip_All}         = 0;
 
 
-Your basic test.  Pass if C<$test> is true, fail if $test is false.  Just
-like Test::Simple's C<ok()>.
+    $self->{Original_Pid} = $$;
+    $self->{Child_Name}   = undef;
+    $self->{Indent}     ||= '';
+    $self->{Depth}        = 0;
 
 
-=cut
+    $self->{Exported_To}    = undef;
+    $self->{Expected_Tests} = 0;
 
 
-sub ok {
-    my( $self, $test, $name ) = @_;
+    $self->{Todo}       = undef;
+    $self->{Todo_Stack} = [];
+    $self->{Start_Todo} = 0;
+    $self->{Opened_Testhandles} = 0;
 
 
-    if ( $self->{Child_Name} and not $self->{In_Destroy} ) {
-        $name = 'unnamed test' unless defined $name;
-        $self->is_passing(0);
-        $self->croak("Cannot run test ($name) with active children");
-    }
-    # $test might contain an object which we don't want to accidentally
-    # store, so we turn it into a boolean.
-    $test = $test ? 1 : 0;
+    return;
+}
 
 
-    lock $self->{Curr_Test};
-    $self->{Curr_Test}++;
 
 
-    # In case $name is a string overloaded object, force it to stringify.
-    $self->_unoverload_str( \$name );
+#######################
+# }}} Public helpers #
+#######################
 
 
-    $self->diag(<<"ERR") if defined $name and $name =~ /^[\d\s]+$/;
-    You named your test '$name'.  You shouldn't use numbers for your test names.
-    Very confusing.
-ERR
+####################
+# {{{ TODO related #
+####################
 
 
-    # Capture the value of $TODO for the rest of this ok() call
-    # so it can more easily be found by other routines.
-    my $todo    = $self->todo();
-    my $in_todo = $self->in_todo;
-    local $self->{Todo} = $todo if $in_todo;
+sub todo {
+    my( $self, $pack ) = @_;
 
 
-    $self->_unoverload_str( \$todo );
+    return $self->{Todo} if defined $self->{Todo};
 
 
-    my $out;
-    my $result = &share( {} );
+    local $Level = $Level + 1; local $BLevel = $BLevel + 1;
+    my $todo = $self->find_TODO($pack);
+    return $todo if defined $todo;
 
 
-    unless($test) {
-        $out .= "not ";
-        @$result{ 'ok', 'actual_ok' } = ( ( $self->in_todo ? 1 : 0 ), 0 );
-    }
-    else {
-        @$result{ 'ok', 'actual_ok' } = ( 1, $test );
-    }
+    return '';
+}
 
 
-    $out .= "ok";
-    $out .= " $self->{Curr_Test}" if $self->use_numbers;
+sub in_todo {
+    my $self = shift;
 
 
-    if( defined $name ) {
-        $name =~ s|#|\\#|g;    # # in a name can confuse Test::Harness.
-        $out .= " - $name";
-        $result->{name} = $name;
-    }
-    else {
-        $result->{name} = '';
-    }
+    local $Level = $Level + 1; local $BLevel = $BLevel + 1;
+    return( defined $self->{Todo} || $self->find_TODO ) ? 1 : 0;
+}
+
+sub todo_start {
+    my $self = shift;
+    my $message = @_ ? shift : '';
 
 
+    $self->{Start_Todo}++;
     if( $self->in_todo ) {
     if( $self->in_todo ) {
-        $out .= " # TODO $todo";
-        $result->{reason} = $todo;
-        $result->{type}   = 'todo';
-    }
-    else {
-        $result->{reason} = '';
-        $result->{type}   = '';
+        push @{ $self->{Todo_Stack} } => $self->todo;
     }
     }
+    $self->{Todo} = $message;
 
 
-    $self->{Test_Results}[ $self->{Curr_Test} - 1 ] = $result;
-    $out .= "\n";
-
-    $self->_print($out);
+    return;
+}
 
 
-    unless($test) {
-        my $msg = $self->in_todo ? "Failed (TODO)" : "Failed";
-        $self->_print_to_fh( $self->_diag_fh, "\n" ) if $ENV{HARNESS_ACTIVE};
+sub todo_end {
+    my $self = shift;
 
 
-        my( undef, $file, $line ) = $self->caller;
-        if( defined $name ) {
-            $self->diag(qq[  $msg test '$name'\n]);
-            $self->diag(qq[  at $file line $line.\n]);
-        }
-        else {
-            $self->diag(qq[  $msg test at $file line $line.\n]);
-        }
+    if( !$self->{Start_Todo} ) {
+        $self->croak('todo_end() called without todo_start()');
     }
 
     }
 
-    $self->is_passing(0) unless $test || $self->in_todo;
+    $self->{Start_Todo}--;
 
 
-    # Check that we haven't violated the plan
-    $self->_check_is_passing_plan();
+    if( $self->{Start_Todo} && @{ $self->{Todo_Stack} } ) {
+        $self->{Todo} = pop @{ $self->{Todo_Stack} };
+    }
+    else {
+        delete $self->{Todo};
+    }
 
 
-    return $test ? 1 : 0;
+    return;
 }
 
 }
 
+####################
+# }}} TODO related #
+####################
+
+#######################
+# {{{ Private helpers #
+#######################
 
 # Check that we haven't yet violated the plan and set
 # is_passing() accordingly
 sub _check_is_passing_plan {
     my $self = shift;
 
 
 # Check that we haven't yet violated the plan and set
 # is_passing() accordingly
 sub _check_is_passing_plan {
     my $self = shift;
 
-    my $plan = $self->has_plan;
+    my $plan = $self->stream->expected_tests;
     return unless defined $plan;        # no plan yet defined
     return unless $plan !~ /\D/;        # no numeric plan
     return unless defined $plan;        # no plan yet defined
     return unless $plan !~ /\D/;        # no numeric plan
-    $self->is_passing(0) if $plan < $self->{Curr_Test};
+    $self->is_passing(0) if $plan < $self->stream->tests_run;
 }
 
 }
 
+sub _is_object {
+    my( $self, $thing ) = @_;
+
+    return $self->_try( sub { ref $thing && $thing->isa('UNIVERSAL') } ) ? 1 : 0;
+}
 
 sub _unoverload {
     my $self = shift;
 
 sub _unoverload {
     my $self = shift;
@@ -924,12 +988,6 @@ sub _unoverload {
     return;
 }
 
     return;
 }
 
-sub _is_object {
-    my( $self, $thing ) = @_;
-
-    return $self->_try( sub { ref $thing && $thing->isa('UNIVERSAL') } ) ? 1 : 0;
-}
-
 sub _unoverload_str {
     my $self = shift;
 
 sub _unoverload_str {
     my $self = shift;
 
@@ -961,58 +1019,6 @@ sub _is_dualvar {
     return ($numval != 0 and $numval ne $val ? 1 : 0);
 }
 
     return ($numval != 0 and $numval ne $val ? 1 : 0);
 }
 
-=item B<is_eq>
-
-  $Test->is_eq($got, $expected, $name);
-
-Like Test::More's C<is()>.  Checks if C<$got eq $expected>.  This is the
-string version.
-
-C<undef> only ever matches another C<undef>.
-
-=item B<is_num>
-
-  $Test->is_num($got, $expected, $name);
-
-Like Test::More's C<is()>.  Checks if C<$got == $expected>.  This is the
-numeric version.
-
-C<undef> only ever matches another C<undef>.
-
-=cut
-
-sub is_eq {
-    my( $self, $got, $expect, $name ) = @_;
-    local $Level = $Level + 1;
-
-    if( !defined $got || !defined $expect ) {
-        # undef only matches undef and nothing else
-        my $test = !defined $got && !defined $expect;
-
-        $self->ok( $test, $name );
-        $self->_is_diag( $got, 'eq', $expect ) unless $test;
-        return $test;
-    }
-
-    return $self->cmp_ok( $got, 'eq', $expect, $name );
-}
-
-sub is_num {
-    my( $self, $got, $expect, $name ) = @_;
-    local $Level = $Level + 1;
-
-    if( !defined $got || !defined $expect ) {
-        # undef only matches undef and nothing else
-        my $test = !defined $got && !defined $expect;
-
-        $self->ok( $test, $name );
-        $self->_is_diag( $got, '==', $expect ) unless $test;
-        return $test;
-    }
-
-    return $self->cmp_ok( $got, '==', $expect, $name );
-}
-
 sub _diag_fmt {
     my( $self, $type, $val ) = @_;
 
 sub _diag_fmt {
     my( $self, $type, $val ) = @_;
 
@@ -1035,178 +1041,28 @@ sub _diag_fmt {
 
 sub _is_diag {
     my( $self, $got, $type, $expect ) = @_;
 
 sub _is_diag {
     my( $self, $got, $type, $expect ) = @_;
+    local $Level = $Level + 1; local $BLevel = $BLevel + 1;
 
     $self->_diag_fmt( $type, $_ ) for \$got, \$expect;
 
 
     $self->_diag_fmt( $type, $_ ) for \$got, \$expect;
 
-    local $Level = $Level + 1;
-    return $self->diag(<<"DIAGNOSTIC");
+    return <<"DIAGNOSTIC";
          got: $got
     expected: $expect
 DIAGNOSTIC
          got: $got
     expected: $expect
 DIAGNOSTIC
-
 }
 
 sub _isnt_diag {
     my( $self, $got, $type ) = @_;
 }
 
 sub _isnt_diag {
     my( $self, $got, $type ) = @_;
+    local $Level = $Level + 1; local $BLevel = $BLevel + 1;
 
     $self->_diag_fmt( $type, \$got );
 
 
     $self->_diag_fmt( $type, \$got );
 
-    local $Level = $Level + 1;
-    return $self->diag(<<"DIAGNOSTIC");
+    return <<"DIAGNOSTIC";
          got: $got
     expected: anything else
 DIAGNOSTIC
 }
 
          got: $got
     expected: anything else
 DIAGNOSTIC
 }
 
-=item B<isnt_eq>
-
-  $Test->isnt_eq($got, $dont_expect, $name);
-
-Like Test::More's C<isnt()>.  Checks if C<$got ne $dont_expect>.  This is
-the string version.
-
-=item B<isnt_num>
-
-  $Test->isnt_num($got, $dont_expect, $name);
-
-Like Test::More's C<isnt()>.  Checks if C<$got ne $dont_expect>.  This is
-the numeric version.
-
-=cut
-
-sub isnt_eq {
-    my( $self, $got, $dont_expect, $name ) = @_;
-    local $Level = $Level + 1;
-
-    if( !defined $got || !defined $dont_expect ) {
-        # undef only matches undef and nothing else
-        my $test = defined $got || defined $dont_expect;
-
-        $self->ok( $test, $name );
-        $self->_isnt_diag( $got, 'ne' ) unless $test;
-        return $test;
-    }
-
-    return $self->cmp_ok( $got, 'ne', $dont_expect, $name );
-}
-
-sub isnt_num {
-    my( $self, $got, $dont_expect, $name ) = @_;
-    local $Level = $Level + 1;
-
-    if( !defined $got || !defined $dont_expect ) {
-        # undef only matches undef and nothing else
-        my $test = defined $got || defined $dont_expect;
-
-        $self->ok( $test, $name );
-        $self->_isnt_diag( $got, '!=' ) unless $test;
-        return $test;
-    }
-
-    return $self->cmp_ok( $got, '!=', $dont_expect, $name );
-}
-
-=item B<like>
-
-  $Test->like($thing, qr/$regex/, $name);
-  $Test->like($thing, '/$regex/', $name);
-
-Like Test::More's C<like()>.  Checks if $thing matches the given C<$regex>.
-
-=item B<unlike>
-
-  $Test->unlike($thing, qr/$regex/, $name);
-  $Test->unlike($thing, '/$regex/', $name);
-
-Like Test::More's C<unlike()>.  Checks if $thing B<does not match> the
-given C<$regex>.
-
-=cut
-
-sub like {
-    my( $self, $thing, $regex, $name ) = @_;
-
-    local $Level = $Level + 1;
-    return $self->_regex_ok( $thing, $regex, '=~', $name );
-}
-
-sub unlike {
-    my( $self, $thing, $regex, $name ) = @_;
-
-    local $Level = $Level + 1;
-    return $self->_regex_ok( $thing, $regex, '!~', $name );
-}
-
-=item B<cmp_ok>
-
-  $Test->cmp_ok($thing, $type, $that, $name);
-
-Works just like Test::More's C<cmp_ok()>.
-
-    $Test->cmp_ok($big_num, '!=', $other_big_num);
-
-=cut
-
-my %numeric_cmps = map { ( $_, 1 ) } ( "<", "<=", ">", ">=", "==", "!=", "<=>" );
-
-# Bad, these are not comparison operators. Should we include more?
-my %cmp_ok_bl = map { ( $_, 1 ) } ( "=", "+=", ".=", "x=", "^=", "|=", "||=", "&&=", "...");
-
-sub cmp_ok {
-    my( $self, $got, $type, $expect, $name ) = @_;
-
-    if ($cmp_ok_bl{$type}) {
-        $self->croak("$type is not a valid comparison operator in cmp_ok()");
-    }
-
-    my $test;
-    my $error;
-    {
-        ## no critic (BuiltinFunctions::ProhibitStringyEval)
-
-        local( $@, $!, $SIG{__DIE__} );    # isolate eval
-
-        my($pack, $file, $line) = $self->caller();
-
-        # This is so that warnings come out at the caller's level
-        $test = eval qq[
-#line $line "(eval in cmp_ok) $file"
-\$got $type \$expect;
-];
-        $error = $@;
-    }
-    local $Level = $Level + 1;
-    my $ok = $self->ok( $test, $name );
-
-    # Treat overloaded objects as numbers if we're asked to do a
-    # numeric comparison.
-    my $unoverload
-      = $numeric_cmps{$type}
-      ? '_unoverload_num'
-      : '_unoverload_str';
-
-    $self->diag(<<"END") if $error;
-An error occurred while using $type:
-------------------------------------
-$error
-------------------------------------
-END
-
-    unless($ok) {
-        $self->$unoverload( \$got, \$expect );
-
-        if( $type =~ /^(eq|==)$/ ) {
-            $self->_is_diag( $got, $type, $expect );
-        }
-        elsif( $type =~ /^(ne|!=)$/ ) {
-            $self->_isnt_diag( $got, $type );
-        }
-        else {
-            $self->_cmp_diag( $got, $type, $expect );
-        }
-    }
-    return $ok;
-}
 
 sub _cmp_diag {
     my( $self, $got, $type, $expect ) = @_;
 
 sub _cmp_diag {
     my( $self, $got, $type, $expect ) = @_;
@@ -1214,8 +1070,8 @@ sub _cmp_diag {
     $got    = defined $got    ? "'$got'"    : 'undef';
     $expect = defined $expect ? "'$expect'" : 'undef';
 
     $got    = defined $got    ? "'$got'"    : 'undef';
     $expect = defined $expect ? "'$expect'" : 'undef';
 
-    local $Level = $Level + 1;
-    return $self->diag(<<"DIAGNOSTIC");
+    local $Level = $Level + 1; local $BLevel = $BLevel + 1;
+    return <<"DIAGNOSTIC";
     $got
         $type
     $expect
     $got
         $type
     $expect
@@ -1225,7 +1081,7 @@ DIAGNOSTIC
 sub _caller_context {
     my $self = shift;
 
 sub _caller_context {
     my $self = shift;
 
-    my( $pack, $file, $line ) = $self->caller(1);
+    my($pack, $file, $line) = $self->trace_test->report->call;
 
     my $code = '';
     $code .= "#line $line $file\n" if defined $file and defined $line;
 
     my $code = '';
     $code .= "#line $line $file\n" if defined $file and defined $line;
@@ -1233,186 +1089,264 @@ sub _caller_context {
     return $code;
 }
 
     return $code;
 }
 
-=back
+sub _regex_ok {
+    my( $self, $thing, $regex, $cmp, $name ) = @_;
 
 
+    my $ok           = 0;
+    my $usable_regex = _is_qr($regex) ? $regex : $self->maybe_regex($regex);
+    unless( defined $usable_regex ) {
+        local $Level = $Level + 1; local $BLevel = $BLevel + 1;
+        $ok = $self->ok( 0, $name, "    '$regex' doesn't look much like a regex to me.");
+        return $ok;
+    }
 
 
-=head2 Other Testing Methods
+    my $test;
+    my $context = $self->_caller_context;
 
 
-These are methods which are used in the course of writing a test but are not themselves tests.
+    try {
+        # No point in issuing an uninit warning, they'll see it in the diagnostics
+        no warnings 'uninitialized';
+        ## no critic (BuiltinFunctions::ProhibitStringyEval)
+        $test = eval $context . q{$test = $thing =~ /$usable_regex/ ? 1 : 0};
+    };
 
 
-=over 4
+    $test = !$test if $cmp eq '!~';
 
 
-=item B<BAIL_OUT>
+    my @diag;
+    unless($test) {
+        $thing = defined $thing ? "'$thing'" : 'undef';
+        my $match = $cmp eq '=~' ? "doesn't match" : "matches";
 
 
-    $Test->BAIL_OUT($reason);
+        push @diag => sprintf( <<'DIAGNOSTIC', $thing, $match, $regex );
+                  %s
+    %13s '%s'
+DIAGNOSTIC
+    }
 
 
-Indicates to the Test::Harness that things are going so badly all
-testing should terminate.  This includes running any additional test
-scripts.
+    local $Level = $Level + 1; local $BLevel = $BLevel + 1;
+    $self->ok( $test, $name, @diag );
 
 
-It will exit with 255.
+    return $test;
+}
 
 
-=cut
+# I'm not ready to publish this.  It doesn't deal with array return
+# values from the code or context.
+sub _try {
+    my( $self, $code, %opts ) = @_;
 
 
-sub BAIL_OUT {
-    my( $self, $reason ) = @_;
+    my $result;
+    my ($ok, $error) = try { $result = $code->() };
+
+    die $error if $opts{die_on_fail} && !$ok;
+
+    return wantarray ? ( $result, $error ) : $result;
+}
+
+sub _message_at_caller {
+    my $self = shift;
+
+    local $Level = $Level + 1; local $BLevel = $BLevel + 1;
+    my $trace = $self->trace_test;
+    my( $pack, $file, $line ) = $trace->report->call;
+    return join( "", @_ ) . " at $file line $line.\n";
+}
+
+#'#
+sub _sanity_check {
+    my $self = shift;
+
+    $self->_whoa( $self->stream->tests_run < 0, 'Says here you ran a negative number of tests!' );
+
+    $self->lresults->sanity_check($self) if $self->lresults;
 
 
-    $self->{Bailed_Out} = 1;
+    return;
+}
 
 
-    if ($self->parent) {
-        $self->{Bailed_Out_Reason} = $reason;
-        $self->no_ending(1);
-        die bless {} => 'Test::Builder::Exception';
+sub _whoa {
+    my( $self, $check, $desc ) = @_;
+    if($check) {
+        local $Level = $Level + 1; local $BLevel = $BLevel + 1;
+        $self->croak(<<"WHOA");
+WHOA!  $desc
+This should never happen!  Please contact the author immediately!
+WHOA
     }
 
     }
 
-    $self->_print("Bail out!  $reason");
-    exit 255;
+    return;
 }
 
 }
 
-=for deprecated
-BAIL_OUT() used to be BAILOUT()
+sub _ending {
+    my $self = shift;
+    require Test::Builder::ExitMagic;
+    my $ending = Test::Builder::ExitMagic->new(tb => $self, stream => $self->stream);
+    $ending->do_magic;
+}
 
 
-=cut
+sub _is_qr {
+    my $regex = shift;
 
 
-{
-    no warnings 'once';
-    *BAILOUT = \&BAIL_OUT;
+    # is_regexp() checks for regexes in a robust manner, say if they're
+    # blessed.
+    return re::is_regexp($regex) if defined &re::is_regexp;
+    return ref $regex eq 'Regexp';
 }
 
 }
 
-=item B<skip>
+#######################
+# }}} Private helpers #
+#######################
 
 
-    $Test->skip;
-    $Test->skip($why);
+################################################
+# {{{ Everything below this line is deprecated #
+# But it must be maintained for legacy...      #
+################################################
 
 
-Skips the current test, reporting C<$why>.
+BEGIN {
+    my %generate = (
+        lresults => [qw/summary details/],
+        stream   => [qw/no_ending/],
+        tap => [qw/
+            no_header no_diag output failure_output todo_output reset_outputs
+            use_numbers _new_fh
+        /],
+    );
 
 
-=cut
+    for my $delegate (keys %generate) {
+        for my $method (@{$generate{$delegate}}) {
+            #print STDERR "Adding: $method ($delegate)\n";
+            my $code = sub {
+                my $self = shift;
 
 
-sub skip {
-    my( $self, $why ) = @_;
-    $why ||= '';
-    $self->_unoverload_str( \$why );
+                $self->carp("Use of \$TB->$method() is deprecated.") if $self->modern;
+                my $d = $self->$delegate || $self->croak("$method() method only applies when $delegate is in use");
 
 
-    lock( $self->{Curr_Test} );
-    $self->{Curr_Test}++;
+                $d->$method(@_);
+            };
 
 
-    $self->{Test_Results}[ $self->{Curr_Test} - 1 ] = &share(
-        {
-            'ok'      => 1,
-            actual_ok => 1,
-            name      => '',
-            type      => 'skip',
-            reason    => $why,
+            no strict 'refs';    ## no critic
+            *{$method} = $code;
         }
         }
-    );
-
-    my $out = "ok";
-    $out .= " $self->{Curr_Test}" if $self->use_numbers;
-    $out .= " # skip";
-    $out .= " $why"               if length $why;
-    $out .= "\n";
-
-    $self->_print($out);
+    }
+}
 
 
-    return 1;
+sub exported_to {
+    my($self, $pack) = @_;
+    $self->carp("exported_to() is deprecated") if $self->modern;
+    $self->{Exported_To} = $pack if defined $pack;
+    return $self->{Exported_To};
 }
 
 }
 
-=item B<todo_skip>
+sub _indent {
+    my $self = shift;
+    $self->carp("_indent() is deprecated") if $self->modern;
+    return '' unless $self->depth;
+    return '    ' x $self->depth
+}
 
 
-  $Test->todo_skip;
-  $Test->todo_skip($why);
+sub _output_plan {
+    my ($self) = @_;
+    $self->carp("_output_plan() is deprecated") if $self->modern;
+    goto &_issue_plan;
+}
 
 
-Like C<skip()>, only it will declare the test as failing and TODO.  Similar
-to
+sub _diag_fh {
+    my $self = shift;
 
 
-    print "not ok $tnum # TODO $why\n";
+    $self->carp("Use of \$TB->_diag_fh() is deprecated.") if $self->modern;
+    my $tap = $self->tap || $self->croak("_diag_fh() method only applies when TAP is in use");
 
 
-=cut
+    local $Level = $Level + 1; local $BLevel = $BLevel + 1;
+    return $tap->_diag_fh($self->in_todo)
+}
 
 
-sub todo_skip {
-    my( $self, $why ) = @_;
-    $why ||= '';
+sub _print {
+    my $self = shift;
 
 
-    lock( $self->{Curr_Test} );
-    $self->{Curr_Test}++;
+    $self->carp("Use of \$TB->_print() is deprecated.") if $self->modern;
+    my $tap = $self->tap || $self->croak("_print() method only applies when TAP is in use");
 
 
-    $self->{Test_Results}[ $self->{Curr_Test} - 1 ] = &share(
-        {
-            'ok'      => 1,
-            actual_ok => 0,
-            name      => '',
-            type      => 'todo_skip',
-            reason    => $why,
-        }
-    );
+    return $tap->_print($self->_indent, @_);
+}
 
 
-    my $out = "not ok";
-    $out .= " $self->{Curr_Test}" if $self->use_numbers;
-    $out .= " # TODO & SKIP $why\n";
+sub _print_to_fh {
+    my( $self, $fh, @msgs ) = @_;
 
 
-    $self->_print($out);
+    $self->carp("Use of \$TB->_print_to_fh() is deprecated.") if $self->modern;
+    my $tap = $self->tap || $self->croak("_print_to_fh() method only applies when TAP is in use");
 
 
-    return 1;
+    return $tap->_print_to_fh($fh, $self->_indent, @msgs);
 }
 
 }
 
-=begin _unimplemented
-
-=item B<skip_rest>
-
-  $Test->skip_rest;
-  $Test->skip_rest($reason);
+sub is_fh {
+    my $self = shift;
 
 
-Like C<skip()>, only it skips all the rest of the tests you plan to run
-and terminates the test.
+    $self->carp("Use of \$TB->is_fh() is deprecated.")
+        if Scalar::Util::blessed($self) && $self->modern;
 
 
-If you're running under C<no_plan>, it skips once and terminates the
-test.
+    require Test::Builder::Formatter::TAP;
+    return Test::Builder::Formatter::TAP->is_fh(@_);
+}
 
 
-=end _unimplemented
+sub current_test {
+    my $self = shift;
 
 
-=back
+    my $tap      = $self->tap;
+    my $lresults = $self->lresults;
 
 
+    if (@_) {
+        my ($num) = @_;
 
 
-=head2 Test building utility methods
+        $lresults->current_test($num) if $lresults;
+        $tap->current_test($num)      if $tap;
 
 
-These methods are useful when writing your own test methods.
+        $self->stream->tests_run(0 - $self->stream->tests_run + $num);
+    }
 
 
-=over 4
+    return $self->stream->tests_run;
+}
 
 
-=item B<maybe_regex>
+sub BAILOUT {
+    my ($self) = @_;
+    $self->carp("Use of \$TB->BAILOUT() is deprecated.") if $self->modern;
+    goto &BAIL_OUT;
+}
 
 
-  $Test->maybe_regex(qr/$regex/);
-  $Test->maybe_regex('/$regex/');
+sub expected_tests {
+    my $self = shift;
 
 
-This method used to be useful back when Test::Builder worked on Perls
-before 5.6 which didn't have qr//.  Now its pretty useless.
+    if(@_) {
+        my ($max) = @_;
+        $self->carp("Use of \$TB->expected_tests(\$max) is deprecated.") if $self->modern;
+        $self->_issue_plan($max);
+    }
 
 
-Convenience method for building testing functions that take regular
-expressions as arguments.
+    return $self->stream->expected_tests || 0;
+}
 
 
-Takes a quoted regular expression produced by C<qr//>, or a string
-representing a regular expression.
+sub caller {    ## no critic (Subroutines::ProhibitBuiltinHomonyms)
+    my $self = shift;
 
 
-Returns a Perl value which may be used instead of the corresponding
-regular expression, or C<undef> if its argument is not recognised.
+    Carp::confess("Use of Test::Builder->caller() is deprecated.\n") if $self->modern;
 
 
-For example, a version of C<like()>, sans the useful diagnostic messages,
-could be written as:
+    local $Level = $Level + 1; local $BLevel = $BLevel + 1;
+    my $trace = $self->trace_test;
+    return unless $trace && $trace->report;
+    my @call = $trace->report->call;
 
 
-  sub laconic_like {
-      my ($self, $thing, $regex, $name) = @_;
-      my $usable_regex = $self->maybe_regex($regex);
-      die "expecting regex, found '$regex'\n"
-          unless $usable_regex;
-      $self->ok($thing =~ m/$usable_regex/, $name);
-  }
+    return wantarray ? @call : $call[0];
+}
 
 
-=cut
+sub level {
+    my( $self, $level ) = @_;
+    $Level = $level if defined $level;
+    return $Level;
+}
 
 sub maybe_regex {
 
 sub maybe_regex {
-    my( $self, $regex ) = @_;
+    my ($self, $regex) = @_;
     my $usable_regex = undef;
 
     my $usable_regex = undef;
 
+    $self->carp("Use of \$TB->maybe_regex() is deprecated.") if $self->modern;
+
     return $usable_regex unless defined $regex;
 
     my( $re, $opts );
     return $usable_regex unless defined $regex;
 
     my( $re, $opts );
@@ -1432,687 +1366,671 @@ sub maybe_regex {
     return $usable_regex;
 }
 
     return $usable_regex;
 }
 
-sub _is_qr {
-    my $regex = shift;
 
 
-    # is_regexp() checks for regexes in a robust manner, say if they're
-    # blessed.
-    return re::is_regexp($regex) if defined &re::is_regexp;
-    return ref $regex eq 'Regexp';
+###################################
+# }}} End of deprecations section #
+###################################
+
+####################
+# {{{ TB1.5 stuff  #
+####################
+
+# This is just a list of method Test::Builder current does not have that Test::Builder 1.5 does.
+my %TB15_METHODS = map {$_ => 1} qw{
+    _file_and_line _join_message _make_default _my_exit _reset_todo_state
+    _result_to_hash _results _todo_state formatter history in_subtest in_test
+    no_change_exit_code post_event post_result set_formatter set_plan test_end
+    test_exit_code test_start test_state
+};
+
+our $AUTOLOAD;
+sub AUTOLOAD {
+    $AUTOLOAD =~ m/^(.*)::([^:]+)$/;
+    my ($package, $sub) = ($1, $2);
+
+    my @caller = CORE::caller();
+    my $msg = qq{Can't locate object method "$sub" via package "$package" at $caller[1] line $caller[2]\n};
+
+    $msg .= <<"    EOT" if $TB15_METHODS{$sub};
+
+    *************************************************************************
+    '$sub' is a Test::Builder 1.5 method. Test::Builder 1.5 is a dead branch.
+    You need to update your code so that it no longer treats Test::Builders
+    over a specific version number as anything special.
+
+    See: http://blogs.perl.org/users/chad_exodist_granum/2014/03/testmore---new-maintainer-also-stop-version-checking.html
+    *************************************************************************
+    EOT
+
+    die $msg;
 }
 
 }
 
-sub _regex_ok {
-    my( $self, $thing, $regex, $cmp, $name ) = @_;
+####################
+# }}} TB1.5 stuff  #
+####################
 
 
-    my $ok           = 0;
-    my $usable_regex = $self->maybe_regex($regex);
-    unless( defined $usable_regex ) {
-        local $Level = $Level + 1;
-        $ok = $self->ok( 0, $name );
-        $self->diag("    '$regex' doesn't look much like a regex to me.");
-        return $ok;
-    }
+1;
 
 
-    {
-        my $test;
-        my $context = $self->_caller_context;
+__END__
 
 
-        {
-            ## no critic (BuiltinFunctions::ProhibitStringyEval)
+=head1 NAME
 
 
-            local( $@, $!, $SIG{__DIE__} );    # isolate eval
+Test::Builder - Backend for building test libraries
 
 
-            # No point in issuing an uninit warning, they'll see it in the diagnostics
-            no warnings 'uninitialized';
+=head1 NOTE ON DEPRECATIONS
 
 
-            $test = eval $context . q{$test = $thing =~ /$usable_regex/ ? 1 : 0};
-        }
+With version 1.301001 many old methods and practices have been deprecated. What
+we mean when we say "deprecated" is that the practices or methods are not to be
+used in any new code. Old code that uses them will still continue to work,
+possibly forever, but new code should use the newer and better alternatives.
 
 
-        $test = !$test if $cmp eq '!~';
+In the future, if enough (read: pretty much everything) is updated and few if
+any modules still use these old items, they will be removed completely. This is
+not super likely to happen just because of the sheer number of modules that use
+Test::Builder.
 
 
-        local $Level = $Level + 1;
-        $ok = $self->ok( $test, $name );
-    }
+=head1 SYNOPSIS
 
 
-    unless($ok) {
-        $thing = defined $thing ? "'$thing'" : 'undef';
-        my $match = $cmp eq '=~' ? "doesn't match" : "matches";
+In general you probably do not want to use this module directly, but instead
+want to use L<Test::Builder::Provider> which will help you roll out a testing
+library.
 
 
-        local $Level = $Level + 1;
-        $self->diag( sprintf <<'DIAGNOSTIC', $thing, $match, $regex );
-                  %s
-    %13s '%s'
-DIAGNOSTIC
+    package My::Test::Module;
+    use Test::Builder::Provider;
 
 
-    }
+    # Export a test tool from an anonymous sub
+    provide ok => sub {
+        my ($test, $name) = @_;
+        builder()->ok($test, $name);
+    };
 
 
-    return $ok;
-}
+    # Export tools that are package subs
+    provides qw/is is_deeply/;
+    sub is { ... }
+    sub is_deeply { ... }
 
 
-# I'm not ready to publish this.  It doesn't deal with array return
-# values from the code or context.
+See L<Test::Builder::Provider> for more details.
+
+B<Note:> You MUST use 'provide', or 'provides' to export testing tools, this
+allows you to use the C<< builder()->trace_test >> tools to determine what
+file/line a failed test came from.
+
+=head2 LOW-LEVEL
 
 
-=begin private
+    use Test::Builder;
+    my $tb = Test::Builder->create(modern => 1, shared_stream => 1);
+    $tb->ok(1);
+    ....
 
 
-=item B<_try>
+=head2 DEPRECATED
 
 
-    my $return_from_code          = $Test->try(sub { code });
-    my($return_from_code, $error) = $Test->try(sub { code });
+    use Test::Builder;
+    my $tb = Test::Builder->new;
+    $tb->ok(1);
+    ...
 
 
-Works like eval BLOCK except it ensures it has no effect on the rest
-of the test (ie. C<$@> is not set) nor is effected by outside
-interference (ie. C<$SIG{__DIE__}>) and works around some quirks in older
-Perls.
+=head1 DESCRIPTION
 
 
-C<$error> is what would normally be in C<$@>.
+L<Test::Simple> and L<Test::More> have proven to be popular testing modules,
+but they're not always flexible enough.  Test::Builder provides a
+building block upon which to write your own test libraries I<which can
+work together>.
 
 
-It is suggested you use this in place of eval BLOCK.
+=head1 TEST COMPONENT MAP
 
 
-=cut
+  [Test Script] > [Test Tool] > [Test::Builder] > [Test::Bulder::Stream] > [Result Formatter]
+                                      ^
+                                 You are here
 
 
-sub _try {
-    my( $self, $code, %opts ) = @_;
+A test script uses a test tool such as L<Test::More>, which uses Test::Builder
+to produce results. The results are sent to L<Test::Builder::Stream> which then
+forwards them on to one or more formatters. The default formatter is
+L<Test::Builder::Fromatter::TAP> which produces TAP output.
 
 
-    my $error;
-    my $return;
-    {
-        local $!;               # eval can mess up $!
-        local $@;               # don't set $@ in the test
-        local $SIG{__DIE__};    # don't trip an outside DIE handler.
-        $return = eval { $code->() };
-        $error = $@;
-    }
+=head1 METHODS
 
 
-    die $error if $error and $opts{die_on_fail};
+=head2 CONSTRUCTION
 
 
-    return wantarray ? ( $return, $error ) : $return;
-}
+=over 4
 
 
-=end private
+=item $Test = Test::Builder->create(%params)
 
 
+Create a completely independant Test::Builder object.
 
 
-=item B<is_fh>
+    my $Test = Test::Builder->create;
 
 
-    my $is_fh = $Test->is_fh($thing);
+Create a Test::Builder object that sends results to the shared output stream
+(usually what you want).
 
 
-Determines if the given C<$thing> can be used as a filehandle.
+    my $Test = Test::Builder->create(shared_stream => 1);
 
 
-=cut
+Create a Test::Builder object that does not include any legacy cruft.
 
 
-sub is_fh {
-    my $self     = shift;
-    my $maybe_fh = shift;
-    return 0 unless defined $maybe_fh;
+    my $Test = Test::Builder->create(modern => 1);
 
 
-    return 1 if ref $maybe_fh  eq 'GLOB';    # its a glob ref
-    return 1 if ref \$maybe_fh eq 'GLOB';    # its a glob
+=item $Test = Test::Builder->new B<***DEPRECATED***>
 
 
-    return eval { $maybe_fh->isa("IO::Handle") } ||
-           eval { tied($maybe_fh)->can('TIEHANDLE') };
-}
+    my $Test = Test::Builder->new;
+
+B<This usage is DEPRECATED!>
+
+Returns the Test::Builder singleton object representing the current state of
+the test.
+
+Since you only run one test per program C<new> always returns the same
+Test::Builder object.  No matter how many times you call C<new()>, you're
+getting the same object.  This is called a singleton.  This is done so that
+multiple modules share such global information as the test counter and
+where test output is going. B<No longer necessary>
+
+If you want a completely new Test::Builder object different from the
+singleton, use C<create>.
+
+=back
+
+=head2 SIMPLE ACCESSORS AND SHORTCUTS
+
+=head3 READ/WRITE ATTRIBUTES
+
+=over 4
+
+=item $parent = $Test->parent
+
+Returns the parent C<Test::Builder> instance, if any.  Only used with child
+builders for nested TAP.
+
+=item $Test->name
+
+Defaults to $0, but subtests and child tests will set this.
+
+=item $Test->modern
+
+Defaults to $ENV{TB_MODERN}, or 0. True when the builder object was constructed
+with modern practices instead of deprecated ones.
+
+=item $Test->depth
+
+Get/Set the depth. This is usually set for Child tests.
+
+=item $Test->default_name
+
+Get/Set the default name for tests where no name was provided. Typically this
+should be set to undef, there are very few real-world use cases for this.
+B<Note:> This functionality was added specifically for L<Test::Exception>,
+which has one of the few real-world use cases.
 
 =back
 
 
 =back
 
+=head3 DELEGATES TO STREAM
 
 
-=head2 Test style
+Each of these is a shortcut to C<< $Test->stream->NAME >>
 
 
+See the L<Test::Builder::Stream> documentation for details.
 
 =over 4
 
 
 =over 4
 
-=item B<level>
+=item $Test->is_passing(...)
 
 
-    $Test->level($how_high);
+=item $Test->listen(...)
 
 
-How far up the call stack should C<$Test> look when reporting where the
-test failed.
+=item $Test->munge(...)
 
 
-Defaults to 1.
+=item $Test->tap
 
 
-Setting L<$Test::Builder::Level> overrides.  This is typically useful
-localized:
+=item $Test->lresults
 
 
-    sub my_ok {
-        my $test = shift;
+=item $Test->use_fork
 
 
-        local $Test::Builder::Level = $Test::Builder::Level + 1;
-        $TB->ok($test);
-    }
+=item $Test->no_fork
 
 
-To be polite to other functions wrapping your own you usually want to increment C<$Level> rather than set it to a constant.
+=back
 
 
-=cut
+=head2 CHILDREN AND SUBTESTS
 
 
-sub level {
-    my( $self, $level ) = @_;
+=over 4
 
 
-    if( defined $level ) {
-        $Level = $level;
-    }
-    return $Level;
-}
+=item $Test->subtest($name, \&subtests, @args)
 
 
-=item B<use_numbers>
+See documentation of C<subtest> in Test::More.
 
 
-    $Test->use_numbers($on_or_off);
+C<subtest> also, and optionally, accepts arguments which will be passed to the
+subtests reference.
 
 
-Whether or not the test should output numbers.  That is, this if true:
+=item $child = $Test->child($name)
 
 
-  ok 1
-  ok 2
-  ok 3
+  my $child = $builder->child($name_of_child);
+  $child->plan( tests => 4 );
+  $child->ok(some_code());
+  ...
+  $child->finalize;
 
 
-or this if false
+Returns a new instance of C<Test::Builder>.  Any output from this child will
+be indented four spaces more than the parent's indentation.  When done, the
+C<finalize> method I<must> be called explicitly.
 
 
-  ok
-  ok
-  ok
+Trying to create a new child with a previous child still active (i.e.,
+C<finalize> not called) will C<croak>.
 
 
-Most useful when you can't depend on the test output order, such as
-when threads or forking is involved.
+Trying to run a test when you have an open child will also C<croak> and cause
+the test suite to fail.
 
 
-Defaults to on.
+=item $ok = $Child->finalize
 
 
-=cut
+When your child is done running tests, you must call C<finalize> to clean up
+and tell the parent your pass/fail status.
 
 
-sub use_numbers {
-    my( $self, $use_nums ) = @_;
+Calling C<finalize> on a child with open children will C<croak>.
 
 
-    if( defined $use_nums ) {
-        $self->{Use_Nums} = $use_nums;
-    }
-    return $self->{Use_Nums};
-}
+If the child falls out of scope before C<finalize> is called, a failure
+diagnostic will be issued and the child is considered to have failed.
 
 
-=item B<no_diag>
+No attempt to call methods on a child after C<finalize> is called is
+guaranteed to succeed.
 
 
-    $Test->no_diag($no_diag);
+Calling this on the root builder is a no-op.
 
 
-If set true no diagnostics will be printed.  This includes calls to
-C<diag()>.
+=back
 
 
-=item B<no_ending>
+=head2 STREAM MANAGEMENT
 
 
-    $Test->no_ending($no_ending);
+=over 4
 
 
-Normally, Test::Builder does some extra diagnostics when the test
-ends.  It also changes the exit code as described below.
+=item $stream = $Test->stream
 
 
-If this is true, none of that will be done.
+=item $Test->stream($stream)
 
 
-=item B<no_header>
+=item $Test->stream(undef)
 
 
-    $Test->no_header($no_header);
+Get/Set the stream. When no stream is set, or is undef it will return the
+shared stream.
 
 
-If set to true, no "1..N" header will be printed.
+B<Note:> Do not set this to the shared stream yourself, set it to undef. This
+is because the shared stream is actually a stack, and this always returns the
+top of the stack.
 
 
-=cut
+=item $results = $Test->intercept(\&code)
 
 
-foreach my $attribute (qw(No_Header No_Ending No_Diag)) {
-    my $method = lc $attribute;
+Any tests run inside the codeblock will be intercepted and not sent to the
+normal stream. Instead they will be added to C<$results> which is an array of
+L<Test::Builder::Result> objects.
 
 
-    my $code = sub {
-        my( $self, $no ) = @_;
+B<Note:> This will also intercept BAIL_OUT and skipall.
 
 
-        if( defined $no ) {
-            $self->{$attribute} = $no;
-        }
-        return $self->{$attribute};
-    };
+B<Note:> This will only intercept results generated with the Test::Builder
+object on which C<intercept()> was called. Other builders will still send to
+the normal places.
 
 
-    no strict 'refs';    ## no critic
-    *{ __PACKAGE__ . '::' . $method } = $code;
-}
+See L<Test::Tester2> for a method of capturing results sent to the global
+stream.
+
+=back
+
+=head2 TRACING THE TEST/PROVIDER BOUNDRY
+
+When a test fails it will report the filename and line where the failure
+occured. In order to do this it needs to look at the stack and figure out where
+your tests stop, and the tools you are using begin. These methods help you find
+the desired caller frame.
+
+See the L<Test::Builder::Trace> module for more details.
 
 
-=back
+=over 4
 
 
-=head2 Output
+=item $trace = $Test->trace_test()
 
 
-Controlling where the test output goes.
+Returns an L<Test::Builder::Trace> object.
 
 
-It's ok for your test to change where STDOUT and STDERR point to,
-Test::Builder's default output settings will not be affected.
+=item $reason = $Test->find_TODO
 
 
-=over 4
+=item $reason = $Test->find_TODO($pack)
 
 
-=item B<diag>
+=item $old_reason = $Test->find_TODO($pack, 1, $new_reason);
 
 
-    $Test->diag(@msgs);
+Like C<todo()> but only returns the value of C<$TODO> ignoring
+C<todo_start()>.
 
 
-Prints out the given C<@msgs>.  Like C<print>, arguments are simply
-appended together.
+Can also be used to set C<$TODO> to a new value while returning the
+old value.
 
 
-Normally, it uses the C<failure_output()> handle, but if this is for a
-TODO test, the C<todo_output()> handle is used.
+=back
 
 
-Output will be indented and marked with a # so as not to interfere
-with test output.  A newline will be put on the end if there isn't one
-already.
+=head2 TEST PLAN
 
 
-We encourage using this rather than calling print directly.
+=over 4
 
 
-Returns false.  Why?  Because C<diag()> is often used in conjunction with
-a failing test (C<ok() || diag()>) it "passes through" the failure.
+=item $Test->plan('no_plan');
 
 
-    return ok(...) || diag(...);
+=item $Test->plan( skip_all => $reason );
 
 
-=for blame transfer
-Mark Fowler <mark@twoshortplanks.com>
+=item $Test->plan( tests => $num_tests );
 
 
-=cut
+A convenient way to set up your tests.  Call this and Test::Builder
+will print the appropriate headers and take the appropriate actions.
 
 
-sub diag {
-    my $self = shift;
+If you call C<plan()>, don't call any of the other methods below.
 
 
-    $self->_print_comment( $self->_diag_fh, @_ );
-}
+If a child calls "skip_all" in the plan, a C<Test::Builder::Exception> is
+thrown.  Trap this error, call C<finalize()> and don't run any more tests on
+the child.
 
 
-=item B<note>
+    my $child = $Test->child('some child');
+    eval { $child->plan( $condition ? ( skip_all => $reason ) : ( tests => 3 )  ) };
+    if ( eval { $@->isa('Test::Builder::Exception') } ) {
+       $child->finalize;
+       return;
+    }
+    # run your tests
 
 
-    $Test->note(@msgs);
+=item $Test->no_plan;
 
 
-Like C<diag()>, but it prints to the C<output()> handle so it will not
-normally be seen by the user except in verbose mode.
+Declares that this test will run an indeterminate number of tests.
 
 
-=cut
+=item $Test->skip_all
 
 
-sub note {
-    my $self = shift;
+=item $Test->skip_all($reason)
 
 
-    $self->_print_comment( $self->output, @_ );
-}
+Skips all the tests, using the given C<$reason>.  Exits immediately with 0.
 
 
-sub _diag_fh {
-    my $self = shift;
+=item $Test->done_testing
 
 
-    local $Level = $Level + 1;
-    return $self->in_todo ? $self->todo_output : $self->failure_output;
-}
+=item $Test->done_testing($count)
 
 
-sub _print_comment {
-    my( $self, $fh, @msgs ) = @_;
+Declares that you are done testing, no more tests will be run after this point.
 
 
-    return if $self->no_diag;
-    return unless @msgs;
+If a plan has not yet been output, it will do so.
 
 
-    # Prevent printing headers when compiling (i.e. -c)
-    return if $^C;
+$num_tests is the number of tests you planned to run.  If a numbered
+plan was already declared, and if this contradicts, a failing result
+will be run to reflect the planning mistake.  If C<no_plan> was declared,
+this will override.
 
 
-    # Smash args together like print does.
-    # Convert undef to 'undef' so its readable.
-    my $msg = join '', map { defined($_) ? $_ : 'undef' } @msgs;
+If C<done_testing()> is called twice, the second call will issue a
+failing result.
 
 
-    # Escape the beginning, _print will take care of the rest.
-    $msg =~ s/^/# /;
+If C<$num_tests> is omitted, the number of tests run will be used, like
+no_plan.
 
 
-    local $Level = $Level + 1;
-    $self->_print_to_fh( $fh, $msg );
+C<done_testing()> is, in effect, used when you'd want to use C<no_plan>, but
+safer. You'd use it like so:
 
 
-    return 0;
-}
+    $Test->ok($a == $b);
+    $Test->done_testing();
 
 
-=item B<explain>
+Or to plan a variable number of tests:
 
 
-    my @dump = $Test->explain(@msgs);
+    for my $test (@tests) {
+        $Test->ok($test);
+    }
+    $Test->done_testing(scalar @tests);
 
 
-Will dump the contents of any references in a human readable format.
-Handy for things like...
+=back
 
 
-    is_deeply($have, $want) || diag explain $have;
+=head2 SIMPLE RESULT PRODUCERS
 
 
-or
+Each of these produces 1 or more L<Test::Builder::Result> objects which are fed
+into the result stream.
 
 
-    is_deeply($have, $want) || note explain $have;
+=over 4
 
 
-=cut
+=item $Test->ok($test)
 
 
-sub explain {
-    my $self = shift;
+=item $Test->ok($test, $name)
 
 
-    return map {
-        ref $_
-          ? do {
-            $self->_try(sub { require Data::Dumper }, die_on_fail => 1);
+=item $Test->ok($test, $name, @diag)
 
 
-            my $dumper = Data::Dumper->new( [$_] );
-            $dumper->Indent(1)->Terse(1);
-            $dumper->Sortkeys(1) if $dumper->can("Sortkeys");
-            $dumper->Dump;
-          }
-          : $_
-    } @_;
-}
+Your basic test.  Pass if C<$test> is true, fail if $test is false.  Just
+like L<Test::Simple>'s C<ok()>.
 
 
-=begin _private
+You may also specify diagnostics messages in the form of simple strings, or
+complete <Test::Builder::Result> objects. Typically you would only do this in a
+failure, but you are allowed to add diags to passes as well.
 
 
-=item B<_print>
+=item $Test->BAIL_OUT($reason);
 
 
-    $Test->_print(@msgs);
+Indicates to the L<Test::Harness> that things are going so badly all
+testing should terminate.  This includes running any additional test
+scripts.
 
 
-Prints to the C<output()> filehandle.
+It will exit with 255.
 
 
-=end _private
+=item $Test->skip
 
 
-=cut
+=item $Test->skip($why)
 
 
-sub _print {
-    my $self = shift;
-    return $self->_print_to_fh( $self->output, @_ );
-}
+Skips the current test, reporting C<$why>.
 
 
-sub _print_to_fh {
-    my( $self, $fh, @msgs ) = @_;
+=item $Test->todo_skip
 
 
-    # Prevent printing headers when only compiling.  Mostly for when
-    # tests are deparsed with B::Deparse
-    return if $^C;
+=item $Test->todo_skip($why)
 
 
-    my $msg = join '', @msgs;
-    my $indent = $self->_indent;
+Like C<skip()>, only it will declare the test as failing and TODO.  Similar
+to
 
 
-    local( $\, $", $, ) = ( undef, ' ', '' );
+    print "not ok $tnum # TODO $why\n";
 
 
-    # Escape each line after the first with a # so we don't
-    # confuse Test::Harness.
-    $msg =~ s{\n(?!\z)}{\n$indent# }sg;
+=item $Test->diag(@msgs)
 
 
-    # Stick a newline on the end if it needs it.
-    $msg .= "\n" unless $msg =~ /\n\z/;
+Prints out the given C<@msgs>.  Like C<print>, arguments are simply
+appended together.
 
 
-    return print $fh $indent, $msg;
-}
+Normally, it uses the C<failure_output()> handle, but if this is for a
+TODO test, the C<todo_output()> handle is used.
 
 
-=item B<output>
+Output will be indented and marked with a # so as not to interfere
+with test output.  A newline will be put on the end if there isn't one
+already.
 
 
-=item B<failure_output>
+We encourage using this rather than calling print directly.
 
 
-=item B<todo_output>
+Returns false.  Why?  Because C<diag()> is often used in conjunction with
+a failing test (C<ok() || diag()>) it "passes through" the failure.
 
 
-    my $filehandle = $Test->output;
-    $Test->output($filehandle);
-    $Test->output($filename);
-    $Test->output(\$scalar);
+    return ok(...) || diag(...);
 
 
-These methods control where Test::Builder will print its output.
-They take either an open C<$filehandle>, a C<$filename> to open and write to
-or a C<$scalar> reference to append to.  It will always return a C<$filehandle>.
+=item $Test->note(@msgs)
 
 
-B<output> is where normal "ok/not ok" test output goes.
+Like C<diag()>, but it prints to the C<output()> handle so it will not
+normally be seen by the user except in verbose mode.
 
 
-Defaults to STDOUT.
+=back
 
 
-B<failure_output> is where diagnostic output on test failures and
-C<diag()> goes.  It is normally not read by Test::Harness and instead is
-displayed to the user.
+=head2 ADVANCED RESULT PRODUCERS
 
 
-Defaults to STDERR.
+=over 4
 
 
-C<todo_output> is used instead of C<failure_output()> for the
-diagnostics of a failing TODO test.  These will not be seen by the
-user.
+=item $Test->is_eq($got, $expected, $name)
 
 
-Defaults to STDOUT.
+Like Test::More's C<is()>.  Checks if C<$got eq $expected>.  This is the
+string version.
 
 
-=cut
+C<undef> only ever matches another C<undef>.
 
 
-sub output {
-    my( $self, $fh ) = @_;
+=item $Test->is_num($got, $expected, $name)
 
 
-    if( defined $fh ) {
-        $self->{Out_FH} = $self->_new_fh($fh);
-    }
-    return $self->{Out_FH};
-}
+Like Test::More's C<is()>.  Checks if C<$got == $expected>.  This is the
+numeric version.
 
 
-sub failure_output {
-    my( $self, $fh ) = @_;
+C<undef> only ever matches another C<undef>.
 
 
-    if( defined $fh ) {
-        $self->{Fail_FH} = $self->_new_fh($fh);
-    }
-    return $self->{Fail_FH};
-}
+=item $Test->isnt_eq($got, $dont_expect, $name)
 
 
-sub todo_output {
-    my( $self, $fh ) = @_;
+Like L<Test::More>'s C<isnt()>.  Checks if C<$got ne $dont_expect>.  This is
+the string version.
 
 
-    if( defined $fh ) {
-        $self->{Todo_FH} = $self->_new_fh($fh);
-    }
-    return $self->{Todo_FH};
-}
+=item $Test->isnt_num($got, $dont_expect, $name)
 
 
-sub _new_fh {
-    my $self = shift;
-    my($file_or_fh) = shift;
+Like L<Test::More>'s C<isnt()>.  Checks if C<$got ne $dont_expect>.  This is
+the numeric version.
 
 
-    my $fh;
-    if( $self->is_fh($file_or_fh) ) {
-        $fh = $file_or_fh;
-    }
-    elsif( ref $file_or_fh eq 'SCALAR' ) {
-        # Scalar refs as filehandles was added in 5.8.
-        if( $] >= 5.008 ) {
-            open $fh, ">>", $file_or_fh
-              or $self->croak("Can't open scalar ref $file_or_fh: $!");
-        }
-        # Emulate scalar ref filehandles with a tie.
-        else {
-            $fh = Test::Builder::IO::Scalar->new($file_or_fh)
-              or $self->croak("Can't tie scalar ref $file_or_fh");
-        }
-    }
-    else {
-        open $fh, ">", $file_or_fh
-          or $self->croak("Can't open test output log $file_or_fh: $!");
-        _autoflush($fh);
-    }
+=item $Test->like($thing, qr/$regex/, $name)
 
 
-    return $fh;
-}
+=item $Test->like($thing, '/$regex/', $name)
 
 
-sub _autoflush {
-    my($fh) = shift;
-    my $old_fh = select $fh;
-    $| = 1;
-    select $old_fh;
+Like L<Test::More>'s C<like()>.  Checks if $thing matches the given C<$regex>.
 
 
-    return;
-}
+=item $Test->unlike($thing, qr/$regex/, $name)
 
 
-my( $Testout, $Testerr );
+=item $Test->unlike($thing, '/$regex/', $name)
 
 
-sub _dup_stdhandles {
-    my $self = shift;
+Like L<Test::More>'s C<unlike()>.  Checks if $thing $Test->does not match the
+given C<$regex>.
 
 
-    $self->_open_testhandles;
+=item $Test->cmp_ok($thing, $type, $that, $name)
 
 
-    # Set everything to unbuffered else plain prints to STDOUT will
-    # come out in the wrong order from our own prints.
-    _autoflush($Testout);
-    _autoflush( \*STDOUT );
-    _autoflush($Testerr);
-    _autoflush( \*STDERR );
+Works just like L<Test::More>'s C<cmp_ok()>.
 
 
-    $self->reset_outputs;
+    $Test->cmp_ok($big_num, '!=', $other_big_num);
 
 
-    return;
-}
+=back
 
 
-sub _open_testhandles {
-    my $self = shift;
+=head2 PUBLIC HELPERS
 
 
-    return if $self->{Opened_Testhandles};
+=over 4
 
 
-    # We dup STDOUT and STDERR so people can change them in their
-    # test suites while still getting normal test output.
-    open( $Testout, ">&STDOUT" ) or die "Can't dup STDOUT:  $!";
-    open( $Testerr, ">&STDERR" ) or die "Can't dup STDERR:  $!";
+=item @dump = $Test->explain(@msgs)
 
 
-    $self->_copy_io_layers( \*STDOUT, $Testout );
-    $self->_copy_io_layers( \*STDERR, $Testerr );
+Will dump the contents of any references in a human readable format.
+Handy for things like...
 
 
-    $self->{Opened_Testhandles} = 1;
+    is_deeply($have, $want) || diag explain $have;
 
 
-    return;
-}
+or
 
 
-sub _copy_io_layers {
-    my( $self, $src, $dst ) = @_;
+    is_deeply($have, $want) || note explain $have;
 
 
-    $self->_try(
-        sub {
-            require PerlIO;
-            my @src_layers = PerlIO::get_layers($src);
+=item $tb->carp(@message)
 
 
-            _apply_layers($dst, @src_layers) if @src_layers;
-        }
-    );
+Warns with C<@message> but the message will appear to come from the
+point where the original test function was called (C<< $tb->caller >>).
 
 
-    return;
-}
+=item $tb->croak(@message)
 
 
-sub _apply_layers {
-    my ($fh, @layers) = @_;
-    my %seen;
-    my @unique = grep { $_ ne 'unix' and !$seen{$_}++ } @layers;
-    binmode($fh, join(":", "", "raw", @unique));
-}
+Dies with C<@message> but the message will appear to come from the
+point where the original test function was called (C<< $tb->caller >>).
 
 
+=item $plan = $Test->has_plan
 
 
-=item reset_outputs
+Find out whether a plan has been defined. C<$plan> is either C<undef> (no plan
+has been set), C<no_plan> (indeterminate # of tests) or an integer (the number
+of expected tests).
 
 
-  $tb->reset_outputs;
+=item $Test->reset
 
 
-Resets all the output filehandles back to their defaults.
+Reinitializes the Test::Builder singleton to its original state.
+Mostly useful for tests run in persistent environments where the same
+test might be run multiple times in the same process.
 
 
-=cut
+=item %context = $Test->context
 
 
-sub reset_outputs {
-    my $self = shift;
+Returns a hash of contextual info.
 
 
-    $self->output        ($Testout);
-    $self->failure_output($Testerr);
-    $self->todo_output   ($Testout);
+    (
+        depth  => DEPTH,
+        source => NAME,
+        trace  => TRACE,
+    )
 
 
-    return;
-}
+=back
 
 
-=item carp
+=head2 TODO MANAGEMENT
 
 
-  $tb->carp(@message);
+=over 4
 
 
-Warns with C<@message> but the message will appear to come from the
-point where the original test function was called (C<< $tb->caller >>).
+=item $todo_reason = $Test->todo
 
 
-=item croak
+=item $todo_reason = $Test->todo($pack)
 
 
-  $tb->croak(@message);
+If the current tests are considered "TODO" it will return the reason,
+if any.  This reason can come from a C<$TODO> variable or the last call
+to C<todo_start()>.
 
 
-Dies with C<@message> but the message will appear to come from the
-point where the original test function was called (C<< $tb->caller >>).
+Since a TODO test does not need a reason, this function can return an
+empty string even when inside a TODO block.  Use C<< $Test->in_todo >>
+to determine if you are currently inside a TODO block.
 
 
-=cut
+C<todo()> is about finding the right package to look for C<$TODO> in.  It's
+pretty good at guessing the right package to look at. It considers the stack
+trace, C<$Level>, and metadata associated with various packages.
 
 
-sub _message_at_caller {
-    my $self = shift;
+Sometimes there is some confusion about where C<todo()> should be looking
+for the C<$TODO> variable.  If you want to be sure, tell it explicitly
+what $pack to use.
 
 
-    local $Level = $Level + 1;
-    my( $pack, $file, $line ) = $self->caller;
-    return join( "", @_ ) . " at $file line $line.\n";
-}
+=item $in_todo = $Test->in_todo
 
 
-sub carp {
-    my $self = shift;
-    return warn $self->_message_at_caller(@_);
-}
+Returns true if the test is currently inside a TODO block.
 
 
-sub croak {
-    my $self = shift;
-    return die $self->_message_at_caller(@_);
-}
+=item $Test->todo_start()
 
 
+=item $Test->todo_start($message)
 
 
-=back
+This method allows you declare all subsequent tests as TODO tests, up until
+the C<todo_end> method has been called.
 
 
+The C<TODO:> and C<$TODO> syntax is generally pretty good about figuring out
+whether or not we're in a TODO test.  However, often we find that this is not
+possible to determine (such as when we want to use C<$TODO> but
+the tests are being executed in other packages which can't be inferred
+beforehand).
 
 
-=head2 Test Status and Info
+Note that you can use this to nest "todo" tests
 
 
-=over 4
+ $Test->todo_start('working on this');
+ # lots of code
+ $Test->todo_start('working on that');
+ # more code
+ $Test->todo_end;
+ $Test->todo_end;
 
 
-=item B<current_test>
+This is generally not recommended, but large testing systems often have weird
+internal needs.
 
 
-    my $curr_test = $Test->current_test;
-    $Test->current_test($num);
+We've tried to make this also work with the TODO: syntax, but it's not
+guaranteed and its use is also discouraged:
 
 
-Gets/sets the current test number we're on.  You usually shouldn't
-have to set this.
+ TODO: {
+     local $TODO = 'We have work to do!';
+     $Test->todo_start('working on this');
+     # lots of code
+     $Test->todo_start('working on that');
+     # more code
+     $Test->todo_end;
+     $Test->todo_end;
+ }
 
 
-If set forward, the details of the missing tests are filled in as 'unknown'.
-if set backward, the details of the intervening tests are deleted.  You
-can erase history if you really want to.
+Pick one style or another of "TODO" to be on the safe side.
 
 
-=cut
+=item $Test->todo_end
 
 
-sub current_test {
-    my( $self, $num ) = @_;
-
-    lock( $self->{Curr_Test} );
-    if( defined $num ) {
-        $self->{Curr_Test} = $num;
-
-        # If the test counter is being pushed forward fill in the details.
-        my $test_results = $self->{Test_Results};
-        if( $num > @$test_results ) {
-            my $start = @$test_results ? @$test_results : 0;
-            for( $start .. $num - 1 ) {
-                $test_results->[$_] = &share(
-                    {
-                        'ok'      => 1,
-                        actual_ok => undef,
-                        reason    => 'incrementing test number',
-                        type      => 'unknown',
-                        name      => undef
-                    }
-                );
-            }
-        }
-        # If backward, wipe history.  Its their funeral.
-        elsif( $num < @$test_results ) {
-            $#{$test_results} = $num - 1;
-        }
-    }
-    return $self->{Curr_Test};
-}
+Stops running tests as "TODO" tests.  This method is fatal if called without a
+preceding C<todo_start> method call.
 
 
-=item B<is_passing>
+=back
 
 
-   my $ok = $builder->is_passing;
+=head2 DEPRECATED/LEGACY
 
 
-Indicates if the test suite is currently passing.
+All of these will issue warnings if called on a modern Test::Builder object.
+That is any Test::Builder instance that was created with the 'modern' flag.
 
 
-More formally, it will be false if anything has happened which makes
-it impossible for the test suite to pass.  True otherwise.
+=over
 
 
-For example, if no tests have run C<is_passing()> will be true because
-even though a suite with no tests is a failure you can add a passing
-test to it and start passing.
+=item $self->no_ending
 
 
-Don't think about it too much.
+B<Deprecated:> Moved to the L<Test::Builder::Stream> object.
 
 
-=cut
+    $Test->no_ending($no_ending);
 
 
-sub is_passing {
-    my $self = shift;
+Normally, Test::Builder does some extra diagnostics when the test
+ends.  It also changes the exit code as described below.
 
 
-    if( @_ ) {
-        $self->{Is_Passing} = shift;
-    }
+If this is true, none of that will be done.
 
 
-    return $self->{Is_Passing};
-}
+=item $self->summary
 
 
+B<Deprecated:> Moved to the L<Test::Builder::Stream> object.
 
 
-=item B<summary>
+The style of result recording used here is deprecated. The functionality was
+moved to its own object to contain the legacy code.
 
     my @tests = $Test->summary;
 
 
     my @tests = $Test->summary;
 
@@ -2121,21 +2039,18 @@ This is a logical pass/fail, so todos are passes.
 
 Of course, test #1 is $tests[0], etc...
 
 
 Of course, test #1 is $tests[0], etc...
 
-=cut
+=item $self->details
 
 
-sub summary {
-    my($self) = shift;
+B<Deprecated:> Moved to the L<Test::Builder::Formatter::LegacyResults> object.
 
 
-    return map { $_->{'ok'} } @{ $self->{Test_Results} };
-}
-
-=item B<details>
+The style of result recording used here is deprecated. The functionality was
+moved to its own object to contain the legacy code.
 
     my @tests = $Test->details;
 
 Like C<summary()>, but with a lot more detail.
 
 
     my @tests = $Test->details;
 
 Like C<summary()>, but with a lot more detail.
 
-    $tests[$test_num - 1] = 
+    $tests[$test_num - 1] =
             { 'ok'       => is the test considered a pass?
               actual_ok  => did it literally say 'ok'?
               name       => name of the test (if any)
             { 'ok'       => is the test considered a pass?
               actual_ok  => did it literally say 'ok'?
               name       => name of the test (if any)
@@ -2176,180 +2091,133 @@ result in this structure:
         reason    => 'insufficient donuts'
       };
 
         reason    => 'insufficient donuts'
       };
 
-=cut
-
-sub details {
-    my $self = shift;
-    return @{ $self->{Test_Results} };
-}
+=item $self->no_header
 
 
-=item B<todo>
+B<Deprecated:> moved to the L<Test::Builder::Formatter::TAP> object.
 
 
-    my $todo_reason = $Test->todo;
-    my $todo_reason = $Test->todo($pack);
+    $Test->no_header($no_header);
 
 
-If the current tests are considered "TODO" it will return the reason,
-if any.  This reason can come from a C<$TODO> variable or the last call
-to C<todo_start()>.
+If set to true, no "1..N" header will be printed.
 
 
-Since a TODO test does not need a reason, this function can return an
-empty string even when inside a TODO block.  Use C<< $Test->in_todo >>
-to determine if you are currently inside a TODO block.
+=item $self->no_diag
 
 
-C<todo()> is about finding the right package to look for C<$TODO> in.  It's
-pretty good at guessing the right package to look at.  It first looks for
-the caller based on C<$Level + 1>, since C<todo()> is usually called inside
-a test function.  As a last resort it will use C<exported_to()>.
+B<Deprecated:> moved to the L<Test::Builder::Formatter::TAP> object.
 
 
-Sometimes there is some confusion about where todo() should be looking
-for the C<$TODO> variable.  If you want to be sure, tell it explicitly
-what $pack to use.
+If set true no diagnostics will be printed.  This includes calls to
+C<diag()>.
 
 
-=cut
+=item $self->output
 
 
-sub todo {
-    my( $self, $pack ) = @_;
+=item $self->failure_output
 
 
-    return $self->{Todo} if defined $self->{Todo};
+=item $self->todo_output
 
 
-    local $Level = $Level + 1;
-    my $todo = $self->find_TODO($pack);
-    return $todo if defined $todo;
+B<Deprecated:> moved to the L<Test::Builder::Formatter::TAP> object.
 
 
-    return '';
-}
+    my $filehandle = $Test->output;
+    $Test->output($filehandle);
+    $Test->output($filename);
+    $Test->output(\$scalar);
 
 
-=item B<find_TODO>
+These methods control where Test::Builder will print its output.
+They take either an open C<$filehandle>, a C<$filename> to open and write to
+or a C<$scalar> reference to append to.  It will always return a C<$filehandle>.
 
 
-    my $todo_reason = $Test->find_TODO();
-    my $todo_reason = $Test->find_TODO($pack);
+B<output> is where normal "ok/not ok" test output goes.
 
 
-Like C<todo()> but only returns the value of C<$TODO> ignoring
-C<todo_start()>.
+Defaults to STDOUT.
 
 
-Can also be used to set C<$TODO> to a new value while returning the
-old value:
+B<failure_output> is where diagnostic output on test failures and
+C<diag()> goes.  It is normally not read by Test::Harness and instead is
+displayed to the user.
 
 
-    my $old_reason = $Test->find_TODO($pack, 1, $new_reason);
+Defaults to STDERR.
 
 
-=cut
+C<todo_output> is used instead of C<failure_output()> for the
+diagnostics of a failing TODO test.  These will not be seen by the
+user.
 
 
-sub find_TODO {
-    my( $self, $pack, $set, $new_value ) = @_;
+Defaults to STDOUT.
 
 
-    $pack = $pack || $self->caller(1) || $self->exported_to;
-    return unless $pack;
+=item $self->reset_outputs
 
 
-    no strict 'refs';    ## no critic
-    my $old_value = ${ $pack . '::TODO' };
-    $set and ${ $pack . '::TODO' } = $new_value;
-    return $old_value;
-}
+B<Deprecated:> moved to the L<Test::Builder::Formatter::TAP> object.
 
 
-=item B<in_todo>
+    $tb->reset_outputs;
 
 
-    my $in_todo = $Test->in_todo;
+Resets all the output filehandles back to their defaults.
 
 
-Returns true if the test is currently inside a TODO block.
+=item $self->use_numbers
 
 
-=cut
+B<Deprecated:> moved to the L<Test::Builder::Formatter::TAP> object.
 
 
-sub in_todo {
-    my $self = shift;
+    $Test->use_numbers($on_or_off);
 
 
-    local $Level = $Level + 1;
-    return( defined $self->{Todo} || $self->find_TODO ) ? 1 : 0;
-}
+Whether or not the test should output numbers.  That is, this if true:
 
 
-=item B<todo_start>
+  ok 1
+  ok 2
+  ok 3
 
 
-    $Test->todo_start();
-    $Test->todo_start($message);
+or this if false
 
 
-This method allows you declare all subsequent tests as TODO tests, up until
-the C<todo_end> method has been called.
+  ok
+  ok
+  ok
 
 
-The C<TODO:> and C<$TODO> syntax is generally pretty good about figuring out
-whether or not we're in a TODO test.  However, often we find that this is not
-possible to determine (such as when we want to use C<$TODO> but
-the tests are being executed in other packages which can't be inferred
-beforehand).
+Most useful when you can't depend on the test output order, such as
+when threads or forking is involved.
 
 
-Note that you can use this to nest "todo" tests
+Defaults to on.
 
 
- $Test->todo_start('working on this');
- # lots of code
- $Test->todo_start('working on that');
- # more code
- $Test->todo_end;
- $Test->todo_end;
+=item $pack = $Test->exported_to
 
 
-This is generally not recommended, but large testing systems often have weird
-internal needs.
+=item $Test->exported_to($pack)
 
 
-We've tried to make this also work with the TODO: syntax, but it's not
-guaranteed and its use is also discouraged:
+B<Deprecated:> Use C<< Test::Builder::Trace->anoint($package) >> and
+C<< $Test->trace_anointed >> instead.
 
 
- TODO: {
-     local $TODO = 'We have work to do!';
-     $Test->todo_start('working on this');
-     # lots of code
-     $Test->todo_start('working on that');
-     # more code
-     $Test->todo_end;
-     $Test->todo_end;
- }
+Tells Test::Builder what package you exported your functions to.
 
 
-Pick one style or another of "TODO" to be on the safe side.
+This method isn't terribly useful since modules which share the same
+Test::Builder object might get exported to different packages and only
+the last one will be honored.
 
 
-=cut
+=item $is_fh = $Test->is_fh($thing);
 
 
-sub todo_start {
-    my $self = shift;
-    my $message = @_ ? shift : '';
+Determines if the given C<$thing> can be used as a filehandle.
 
 
-    $self->{Start_Todo}++;
-    if( $self->in_todo ) {
-        push @{ $self->{Todo_Stack} } => $self->todo;
-    }
-    $self->{Todo} = $message;
+=item $curr_test = $Test->current_test;
 
 
-    return;
-}
+=item $Test->current_test($num);
 
 
-=item C<todo_end>
+Gets/sets the current test number we're on.  You usually shouldn't
+have to set this.
 
 
- $Test->todo_end;
+If set forward, the details of the missing tests are filled in as 'unknown'.
+if set backward, the details of the intervening tests are deleted.  You
+can erase history if you really want to.
 
 
-Stops running tests as "TODO" tests.  This method is fatal if called without a
-preceding C<todo_start> method call.
+=item $Test->BAIL_OUT($reason);
 
 
-=cut
+Indicates to the L<Test::Harness> that things are going so badly all
+testing should terminate.  This includes running any additional test
+scripts.
 
 
-sub todo_end {
-    my $self = shift;
+It will exit with 255.
 
 
-    if( !$self->{Start_Todo} ) {
-        $self->croak('todo_end() called without todo_start()');
-    }
+=item $max = $Test->expected_tests
 
 
-    $self->{Start_Todo}--;
+=item $Test->expected_tests($max)
 
 
-    if( $self->{Start_Todo} && @{ $self->{Todo_Stack} } ) {
-        $self->{Todo} = pop @{ $self->{Todo_Stack} };
-    }
-    else {
-        delete $self->{Todo};
-    }
+Gets/sets the number of tests we expect this test to run and prints out
+the appropriate headers.
 
 
-    return;
-}
+=item $package = $Test->caller
 
 
-=item B<caller>
+=item ($pack, $file, $line) = $Test->caller
 
 
-    my $package = $Test->caller;
-    my($pack, $file, $line) = $Test->caller;
-    my($pack, $file, $line) = $Test->caller($height);
+=item ($pack, $file, $line) = $Test->caller($height)
 
 Like the normal C<caller()>, except it reports according to your C<level()>.
 
 
 Like the normal C<caller()>, except it reports according to your C<level()>.
 
@@ -2357,232 +2225,103 @@ C<$height> will be added to the C<level()>.
 
 If C<caller()> winds up off the top of the stack it report the highest context.
 
 
 If C<caller()> winds up off the top of the stack it report the highest context.
 
-=cut
-
-sub caller {    ## no critic (Subroutines::ProhibitBuiltinHomonyms)
-    my( $self, $height ) = @_;
-    $height ||= 0;
-
-    my $level = $self->level + $height + 1;
-    my @caller;
-    do {
-        @caller = CORE::caller( $level );
-        $level--;
-    } until @caller;
-    return wantarray ? @caller : $caller[0];
-}
-
-=back
-
-=cut
-
-=begin _private
-
-=over 4
-
-=item B<_sanity_check>
+=item $Test->level($how_high)
 
 
-  $self->_sanity_check();
+B<DEPRECATED> See deprecation notes at the top. The use of C<level()> is
+deprecated.
 
 
-Runs a bunch of end of test sanity checks to make sure reality came
-through ok.  If anything is wrong it will die with a fairly friendly
-error message.
-
-=cut
-
-#'#
-sub _sanity_check {
-    my $self = shift;
-
-    $self->_whoa( $self->{Curr_Test} < 0, 'Says here you ran a negative number of tests!' );
-    $self->_whoa( $self->{Curr_Test} != @{ $self->{Test_Results} },
-        'Somehow you got a different number of results than tests ran!' );
-
-    return;
-}
-
-=item B<_whoa>
+How far up the call stack should C<$Test> look when reporting where the
+test failed.
 
 
-  $self->_whoa($check, $description);
+Defaults to 1.
 
 
-A sanity check, similar to C<assert()>.  If the C<$check> is true, something
-has gone horribly wrong.  It will die with the given C<$description> and
-a note to contact the author.
+Setting L<$Test::Builder::Level> overrides.  This is typically useful
+localized:
 
 
-=cut
+    sub my_ok {
+        my $test = shift;
 
 
-sub _whoa {
-    my( $self, $check, $desc ) = @_;
-    if($check) {
-        local $Level = $Level + 1;
-        $self->croak(<<"WHOA");
-WHOA!  $desc
-This should never happen!  Please contact the author immediately!
-WHOA
+        local $Test::Builder::Level = $Test::Builder::Level + 1;
+        $TB->ok($test);
     }
 
     }
 
-    return;
-}
-
-=item B<_my_exit>
-
-  _my_exit($exit_num);
+To be polite to other functions wrapping your own you usually want to increment
+C<$Level> rather than set it to a constant.
 
 
-Perl seems to have some trouble with exiting inside an C<END> block.
-5.6.1 does some odd things.  Instead, this function edits C<$?>
-directly.  It should B<only> be called from inside an C<END> block.
-It doesn't actually exit, that's your job.
+=item $Test->maybe_regex(qr/$regex/)
 
 
-=cut
+=item $Test->maybe_regex('/$regex/')
 
 
-sub _my_exit {
-    $? = $_[0];    ## no critic (Variables::RequireLocalizedPunctuationVars)
-
-    return 1;
-}
+This method used to be useful back when Test::Builder worked on Perls
+before 5.6 which didn't have qr//.  Now its pretty useless.
 
 
-=back
+Convenience method for building testing functions that take regular
+expressions as arguments.
 
 
-=end _private
+Takes a quoted regular expression produced by C<qr//>, or a string
+representing a regular expression.
 
 
-=cut
+Returns a Perl value which may be used instead of the corresponding
+regular expression, or C<undef> if its argument is not recognised.
 
 
-sub _ending {
-    my $self = shift;
-    return if $self->no_ending;
-    return if $self->{Ending}++;
+For example, a version of C<like()>, sans the useful diagnostic messages,
+could be written as:
 
 
-    my $real_exit_code = $?;
+  sub laconic_like {
+      my ($self, $thing, $regex, $name) = @_;
+      my $usable_regex = $self->maybe_regex($regex);
+      die "expecting regex, found '$regex'\n"
+          unless $usable_regex;
+      $self->ok($thing =~ m/$usable_regex/, $name);
+  }
 
 
-    # Don't bother with an ending if this is a forked copy.  Only the parent
-    # should do the ending.
-    if( $self->{Original_Pid} != $$ ) {
-        return;
-    }
+=back
 
 
-    # Ran tests but never declared a plan or hit done_testing
-    if( !$self->{Have_Plan} and $self->{Curr_Test} ) {
-        $self->is_passing(0);
-        $self->diag("Tests were run but no plan was declared and done_testing() was not seen.");
-
-        if($real_exit_code) {
-            $self->diag(<<"FAIL");
-Looks like your test exited with $real_exit_code just after $self->{Curr_Test}.
-FAIL
-            $self->is_passing(0);
-            _my_exit($real_exit_code) && return;
-        }
+=head1 PACKAGE VARIABLES
 
 
-        # But if the tests ran, handle exit code.
-        my $test_results = $self->{Test_Results};
-        if(@$test_results) {
-            my $num_failed = grep !$_->{'ok'}, @{$test_results}[ 0 .. $self->{Curr_Test} - 1 ];
-            if ($num_failed > 0) {
+B<NOTE>: These are tied to the package, not the instance. Basically that means
+touching these can affect more things than you expect. Using these can lead to
+unexpected interactions at a distance.
 
 
-                my $exit_code = $num_failed <= 254 ? $num_failed : 254;
-                _my_exit($exit_code) && return;
-            }
-        }
-        _my_exit(254) && return;
-    }
+=over 4
 
 
-    # Exit if plan() was never called.  This is so "require Test::Simple"
-    # doesn't puke.
-    if( !$self->{Have_Plan} ) {
-        return;
-    }
+=item C<$Level>
 
 
-    # Don't do an ending if we bailed out.
-    if( $self->{Bailed_Out} ) {
-        $self->is_passing(0);
-        return;
-    }
-    # Figure out if we passed or failed and print helpful messages.
-    my $test_results = $self->{Test_Results};
-    if(@$test_results) {
-        # The plan?  We have no plan.
-        if( $self->{No_Plan} ) {
-            $self->_output_plan($self->{Curr_Test}) unless $self->no_header;
-            $self->{Expected_Tests} = $self->{Curr_Test};
-        }
+Originally this was the only way to tell Test::Builder where in the stack
+errors should be reported. Now the preferred method of finding where errors
+should be reported is using the L<Test::Builder::Trace> and
+L<Test::Builder::Provider> modules.
 
 
-        # Auto-extended arrays and elements which aren't explicitly
-        # filled in with a shared reference will puke under 5.8.0
-        # ithreads.  So we have to fill them in by hand. :(
-        my $empty_result = &share( {} );
-        for my $idx ( 0 .. $self->{Expected_Tests} - 1 ) {
-            $test_results->[$idx] = $empty_result
-              unless defined $test_results->[$idx];
-        }
+C<$Level> should be considered deprecated when possible, that said it will not
+be removed any time soon. There is too much legacy code that depends on
+C<$Level>. There are also a couple situations in which C<$Level> is necessary:
 
 
-        my $num_failed = grep !$_->{'ok'}, @{$test_results}[ 0 .. $self->{Curr_Test} - 1 ];
+=over 4
 
 
-        my $num_extra = $self->{Curr_Test} - $self->{Expected_Tests};
+=item Backwards compatibility
 
 
-        if( $num_extra != 0 ) {
-            my $s = $self->{Expected_Tests} == 1 ? '' : 's';
-            $self->diag(<<"FAIL");
-Looks like you planned $self->{Expected_Tests} test$s but ran $self->{Curr_Test}.
-FAIL
-            $self->is_passing(0);
-        }
+If code simply cannot depend on a recent version of Test::Builder, then $Level
+must be used as there is no alternative. See L<Test::Builder::Compat> for tools
+to help make test tools that work in old and new versions.
 
 
-        if($num_failed) {
-            my $num_tests = $self->{Curr_Test};
-            my $s = $num_failed == 1 ? '' : 's';
+=item Stack Management
 
 
-            my $qualifier = $num_extra == 0 ? '' : ' run';
+Using L<Test::Builder::Provider> is not practical for situations like in
+L<Test::Exception> where one needs to munge the call stack to hide frames.
 
 
-            $self->diag(<<"FAIL");
-Looks like you failed $num_failed test$s of $num_tests$qualifier.
-FAIL
-            $self->is_passing(0);
-        }
+=back
 
 
-        if($real_exit_code) {
-            $self->diag(<<"FAIL");
-Looks like your test exited with $real_exit_code just after $self->{Curr_Test}.
-FAIL
-            $self->is_passing(0);
-            _my_exit($real_exit_code) && return;
-        }
+=item C<$BLevel>
 
 
-        my $exit_code;
-        if($num_failed) {
-            $exit_code = $num_failed <= 254 ? $num_failed : 254;
-        }
-        elsif( $num_extra != 0 ) {
-            $exit_code = 255;
-        }
-        else {
-            $exit_code = 0;
-        }
+Used internally by the L<Test::Builder::Trace>, do not modify or rely on this
+in your own code. Documented for completeness.
 
 
-        _my_exit($exit_code) && return;
-    }
-    elsif( $self->{Skip_All} ) {
-        _my_exit(0) && return;
-    }
-    elsif($real_exit_code) {
-        $self->diag(<<"FAIL");
-Looks like your test exited with $real_exit_code before it could output anything.
-FAIL
-        $self->is_passing(0);
-        _my_exit($real_exit_code) && return;
-    }
-    else {
-        $self->diag("No tests run!\n");
-        $self->is_passing(0);
-        _my_exit(255) && return;
-    }
+=item C<$Test>
 
 
-    $self->is_passing(0);
-    $self->_whoa( 1, "We fell off the end of _ending()" );
-}
+The singleton returned by C<new()>, which is deprecated in favor of
+C<create()>.
 
 
-END {
-    $Test->_ending if defined $Test;
-}
+=back
 
 =head1 EXIT CODES
 
 
 =head1 EXIT CODES
 
@@ -2602,11 +2341,13 @@ So the exit codes are...
 
 If you fail more than 254 tests, it will be reported as 254.
 
 
 If you fail more than 254 tests, it will be reported as 254.
 
+B<Note:> The magic that accomplishes this has been moved to
+L<Test::Builder::ExitMagic>
+
 =head1 THREADS
 
 In perl 5.8.1 and later, Test::Builder is thread-safe.  The test
 =head1 THREADS
 
 In perl 5.8.1 and later, Test::Builder is thread-safe.  The test
-number is shared amongst all threads.  This means if one thread sets
-the test number using C<current_test()> they will all be effected.
+number is shared amongst all threads.
 
 While versions earlier than 5.8.1 had threads they contain too many
 bugs to support.
 
 While versions earlier than 5.8.1 had threads they contain too many
 bugs to support.
@@ -2616,7 +2357,11 @@ Test::Builder.
 
 =head1 MEMORY
 
 
 =head1 MEMORY
 
-An informative hash, accessible via C<<details()>>, is stored for each
+B<Note:> This only applies if you turn lresults on.
+
+    $Test->stream->no_lresults;
+
+An informative hash, accessible via C<details()>, is stored for each
 test you perform.  So memory usage will scale linearly with each test
 run. Although this is not a problem for most test suites, it can
 become an issue if you do large (hundred thousands to million)
 test you perform.  So memory usage will scale linearly with each test
 run. Although this is not a problem for most test suites, it can
 become an issue if you do large (hundred thousands to million)
@@ -2624,24 +2369,22 @@ combinatorics tests in the same run.
 
 In such cases, you are advised to either split the test file into smaller
 ones, or use a reverse approach, doing "normal" (code) compares and
 
 In such cases, you are advised to either split the test file into smaller
 ones, or use a reverse approach, doing "normal" (code) compares and
-triggering fail() should anything go unexpected.
-
-Future versions of Test::Builder will have a way to turn history off.
-
+triggering C<fail()> should anything go unexpected.
 
 =head1 EXAMPLES
 
 
 =head1 EXAMPLES
 
-CPAN can provide the best examples.  Test::Simple, Test::More,
-Test::Exception and Test::Differences all use Test::Builder.
+CPAN can provide the best examples.  L<Test::Simple>, L<Test::More>,
+L<Test::Exception> and L<Test::Differences> all use Test::Builder.
 
 =head1 SEE ALSO
 
 
 =head1 SEE ALSO
 
-Test::Simple, Test::More, Test::Harness
+L<Test::Simple>, L<Test::More>, L<Test::Harness>, L<Fennec>
 
 =head1 AUTHORS
 
 Original code by chromatic, maintained by Michael G Schwern
 
 =head1 AUTHORS
 
 Original code by chromatic, maintained by Michael G Schwern
-E<lt>schwern@pobox.comE<gt>
+E<lt>schwern@pobox.comE<gt> until 2014. Currently maintained by Chad Granum
+E<lt>exodist7@gmail.comE<gt>.
 
 =head1 MAINTAINERS
 
 
 =head1 MAINTAINERS
 
@@ -2653,15 +2396,12 @@ E<lt>schwern@pobox.comE<gt>
 
 =head1 COPYRIGHT
 
 
 =head1 COPYRIGHT
 
-Copyright 2002-2008 by chromatic E<lt>chromatic@wgz.orgE<gt> and
-                       Michael G Schwern E<lt>schwern@pobox.comE<gt>.
+Copyright 2002-2014 by chromatic E<lt>chromatic@wgz.orgE<gt> and
+                       Michael G Schwern E<lt>schwern@pobox.comE<gt> and
+                       Chad Granum E<lt>exodist7@gmail.comE<gt>
 
 This program is free software; you can redistribute it and/or
 modify it under the same terms as Perl itself.
 
 See F<http://www.perl.com/perl/misc/Artistic.html>
 
 
 This program is free software; you can redistribute it and/or
 modify it under the same terms as Perl itself.
 
 See F<http://www.perl.com/perl/misc/Artistic.html>
 
-=cut
-
-1;
-
diff --git a/cpan/Test-Simple/lib/Test/Builder/ExitMagic.pm b/cpan/Test-Simple/lib/Test/Builder/ExitMagic.pm
new file mode 100644 (file)
index 0000000..021cad9
--- /dev/null
@@ -0,0 +1,194 @@
+package Test::Builder::ExitMagic;
+use strict;
+use warnings;
+
+use Test::Builder::Util qw/new accessors/;
+require Test::Builder::Result::Finish;
+
+accessors qw/stream tb ended pid/;
+
+sub init {
+    my $self = shift;
+    $self->pid($$);
+}
+
+sub do_magic {
+    my $self = shift;
+
+    return if $self->ended; $self->ended(1);
+
+    # Don't bother with an ending if this is a forked copy.  Only the parent
+    # should do the ending.
+    return unless $self->pid == $$;
+
+    my $stream = $self->stream || (Test::Builder::Stream->root ? Test::Builder::Stream->shared : undef);
+    return unless $stream; # No stream? no point!
+    my $tb = $self->tb;
+
+    return if $stream->no_ending;
+
+    my $real_exit_code = $?;
+
+    my $plan  = $stream->plan;
+    my $total = $stream->tests_run;
+    my $fails = $stream->tests_failed;
+
+    $stream->send(
+        Test::Builder::Result::Finish->new(
+            tests_run    => $total,
+            tests_failed => $fails,
+            depth        => $tb->depth,
+            source       => $tb->name,
+        )
+    );
+
+    # Ran tests but never declared a plan or hit done_testing
+    return $self->no_plan_magic($stream, $tb, $total, $fails, $real_exit_code)
+        if $total && !$plan;
+
+    # Exit if plan() was never called.  This is so "require Test::Simple"
+    # doesn't puke.
+    return unless $plan;
+
+    # Don't do an ending if we bailed out.
+    if( $stream->bailed_out ) {
+        $stream->is_passing(0);
+        return;
+    }
+
+    # Figure out if we passed or failed and print helpful messages.
+    return $self->be_helpful_magic($stream, $tb, $total, $fails, $plan, $real_exit_code)
+        if $total && $plan;
+
+    if ($plan->directive && $plan->directive eq 'SKIP') {
+        $? = 0;
+        return;
+    }
+
+    if($real_exit_code) {
+        $tb->diag("Looks like your test exited with $real_exit_code before it could output anything.\n");
+        $stream->is_passing(0);
+        $? = $real_exit_code;
+        return;
+    }
+
+    unless ($total) {
+        $tb->diag("No tests run!\n");
+        $tb->is_passing(0);
+        $? = 255;
+        return;
+    }
+
+    $tb->is_passing(0);
+    $tb->_whoa( 1, "We fell off the end of _ending()" );
+
+    1;
+}
+
+sub no_plan_magic {
+    my $self = shift;
+    my ($stream, $tb, $total, $fails, $real_exit_code) = @_;
+
+    $stream->is_passing(0);
+    $tb->diag("Tests were run but no plan was declared and done_testing() was not seen.");
+
+    if($real_exit_code) {
+        $tb->diag("Looks like your test exited with $real_exit_code just after $total.\n");
+        $? = $real_exit_code;
+        return;
+    }
+
+    # But if the tests ran, handle exit code.
+    if ($total && $fails) {
+        my $exit_code = $fails <= 254 ? $fails : 254;
+        $? = $exit_code;
+        return;
+    }
+
+    $? = 254;
+    return;
+}
+
+sub be_helpful_magic {
+    my $self = shift;
+    my ($stream, $tb, $total, $fails, $plan, $real_exit_code) = @_;
+
+    my $planned   = $plan->max;
+    my $num_extra = $plan->directive && $plan->directive eq 'NO_PLAN' ? 0 : $total - $planned;
+
+    if ($num_extra != 0) {
+        my $s = $planned == 1 ? '' : 's';
+        $tb->diag("Looks like you planned $planned test$s but ran $total.\n");
+        $tb->is_passing(0);
+    }
+
+    if($fails) {
+        my $s = $fails == 1 ? '' : 's';
+        my $qualifier = $num_extra == 0 ? '' : ' run';
+        $tb->diag("Looks like you failed $fails test$s of ${total}${qualifier}.\n");
+        $tb->is_passing(0);
+    }
+
+    if($real_exit_code) {
+        $tb->diag("Looks like your test exited with $real_exit_code just after $total.\n");
+        $tb->is_passing(0);
+        $? = $real_exit_code;
+        return;
+    }
+
+    my $exit_code;
+    if($fails) {
+        $exit_code = $fails <= 254 ? $fails : 254;
+    }
+    elsif($num_extra != 0) {
+        $exit_code = 255;
+    }
+    else {
+        $exit_code = 0;
+    }
+
+    $? = $exit_code;
+    return;
+}
+
+1;
+
+__END__
+
+=head1 NAME
+
+Test::Builder::ExitMagic - Encapsulate the magic exit logic used by
+Test::Builder.
+
+=head1 DESCRIPTION
+
+It's magic! well kinda..
+
+=head1 SYNOPSYS
+
+Don't use this yourself, let L<Test::Builder> handle it.
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 SOURCE
+
+The source code repository for Test::More can be found at
+F<http://github.com/Test-More/test-more/>.
+
+=head1 COPYRIGHT
+
+Copyright 2014 Chad Granum E<lt>exodist7@gmail.comE<gt>.
+
+Most of this code was pulled out ot L<Test::Builder>, written by Schwern and
+others.
+
+This program is free software; you can redistribute it and/or
+modify it under the same terms as Perl itself.
+
+See F<http://www.perl.com/perl/misc/Artistic.html>
diff --git a/cpan/Test-Simple/lib/Test/Builder/Fork.pm b/cpan/Test-Simple/lib/Test/Builder/Fork.pm
new file mode 100644 (file)
index 0000000..c99253a
--- /dev/null
@@ -0,0 +1,171 @@
+package Test::Builder::Fork;
+use strict;
+use warnings;
+
+use Carp qw/confess/;
+use Scalar::Util qw/blessed/;
+use File::Temp();
+use Test::Builder::Util qw/try/;
+
+sub tmpdir { shift->{tmpdir} }
+sub pid    { shift->{pid}    }
+
+sub new {
+    my $class = shift;
+
+    my $dir = File::Temp::tempdir(CLEANUP => 0) || die "Could not get a temp dir";
+
+    my $self = bless { tmpdir => $dir, pid => $$ }, $class;
+
+    return $self;
+}
+
+my $id = 1;
+sub handle {
+    my $self = shift;
+    my ($item) = @_;
+
+    return if $item && blessed($item) && $item->isa('Test::Builder::Result::Finish');
+
+    confess "Did not get a valid Test::Builder::Result object! ($item)"
+        unless $item && blessed($item) && $item->isa('Test::Builder::Result');
+
+    my $stream = Test::Builder::Stream->shared;
+    return 0 if $$ == $stream->pid;
+
+    # First write the file, then rename it so that it is not read before it is ready.
+    my $name =  $self->tmpdir . "/$$-" . $id++;
+    require Storable;
+    Storable::store($item, $name);
+    rename($name, "$name.ready") || die "Could not rename file";
+
+    return 1;
+}
+
+sub cull {
+    my $self = shift;
+    my $dir = $self->tmpdir;
+
+    opendir(my $dh, $dir) || die "could not open temp dir!";
+    while(my $file = readdir($dh)) {
+        next if $file =~ m/^\.+$/;
+        next unless $file =~ m/\.ready$/;
+
+        require Storable;
+        my $obj = Storable::retrieve("$dir/$file");
+        die "Empty result object found" unless $obj;
+
+        Test::Builder::Stream->shared->send($obj);
+
+        if ($ENV{TEST_KEEP_TMP_DIR}) {
+            rename("$dir/$file", "$dir/$file.complete") || die "Could not rename file";
+        }
+        else {
+            unlink("$dir/$file") || die "Could not unlink file: $file";
+        }
+    }
+    closedir($dh);
+}
+
+sub DESTROY {
+    my $self = shift;
+
+    return unless $$ == $self->pid;
+
+    my $dir = $self->tmpdir;
+
+    if ($ENV{TEST_KEEP_TMP_DIR}) {
+        print STDERR "# Not removing temp dir: $dir\n";
+        return;
+    }
+
+    opendir(my $dh, $dir) || die "Could not open temp dir!";
+    while(my $file = readdir($dh)) {
+        next if $file =~ m/^\.+$/;
+        die "Unculled result! You ran tests in a child process, but never pulled them in!\n"
+            if $file !~ m/\.complete$/;
+        unlink("$dir/$file") || die "Could not unlink file: $file";
+    }
+    closedir($dh);
+    rmdir($dir);
+}
+
+1;
+
+__END__
+
+=head1 NAME
+
+Test::Builder::Fork - Fork support for Test::Builder
+
+=head1 DESCRIPTION
+
+This module is used by L<Test::Builder::Stream> to support forking.
+
+=head1 SYNOPSYS
+
+    use Test::Builder::Fork;
+
+    my $f = Test::Builder::Fork;
+
+    if ($pid = fork) {
+        waitpid($pid, 0);
+        $f->cull;
+    }
+    else {
+        $f->handle(Test::Builder::Result::Ok->new(bool => 1);
+    }
+
+    ...
+
+=head1 METHODS
+
+=over 4
+
+=item $f = $class->new
+
+Create a new instance
+
+=item $f->pid
+
+Original PID in which the fork object was created.
+
+=item $f->tmpdir
+
+Temp dir used to share results between procs
+
+=item $f->handle($result)
+
+Send a result object to the parent
+
+=item $f->cull
+
+Retrieve result objects and send them to the stream
+
+=back
+
+=head1 SEE ALSO
+
+L<Child> - Makes forking easier.
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 SOURCE
+
+The source code repository for Test::More can be found at
+F<http://github.com/Test-More/test-more/>.
+
+=head1 COPYRIGHT
+
+Copyright 2014 Chad Granum E<lt>exodist7@gmail.comE<gt>.
+
+This program is free software; you can redistribute it and/or
+modify it under the same terms as Perl itself.
+
+See F<http://www.perl.com/perl/misc/Artistic.html>
diff --git a/cpan/Test-Simple/lib/Test/Builder/Formatter.pm b/cpan/Test-Simple/lib/Test/Builder/Formatter.pm
new file mode 100644 (file)
index 0000000..44e6be4
--- /dev/null
@@ -0,0 +1,180 @@
+package Test::Builder::Formatter;
+use strict;
+use warnings;
+
+use Carp qw/confess/;
+use Scalar::Util qw/blessed/;
+
+use Test::Builder::Util qw/new package_sub/;
+
+sub handle {
+    my $self = shift;
+    my ($item) = @_;
+
+    confess "Handler did not get a valid Test::Builder::Result object! ($item)"
+        unless $item && blessed($item) && $item->isa('Test::Builder::Result');
+
+    my $method = $item->type;
+
+    # Not all formatters will handle all types.
+    return 0 unless $self->can($method);
+
+    $self->$method($item);
+
+    return 1;
+}
+
+sub to_handler {
+    my $self = shift;
+    return sub { $self->handle(@_) };
+}
+
+sub listen {
+    my $class = shift;
+    my %params = @_;
+    my $caller = caller;
+
+    my $tb = $params{tb};
+    $tb ||= package_sub($caller, 'TB_INSTANCE') ? $caller->TB_INSTANCE : undef;
+
+    my $stream = delete $params{stream} || ($tb ? $tb->stream : undef) || Test::Builder::Stream->shared;
+
+    my $id = delete $params{id};
+    ($id) = ($class =~ m/^.*::([^:]+)$/g) unless $id;
+
+    return $stream->listen($id => $class->new(%params));
+}
+
+1;
+
+__END__
+
+=head1 NAME
+
+Test::Builder::Formatter - Base class for formatters
+
+=head1 DESCRIPTION
+
+Results go to L<Test::Builder::Stream> which then forwards them on to one or
+more formatters. This module is a base class for formatters. You do not NEED to
+use this module to write a formatter, but it can help.
+
+=head1 TEST COMPONENT MAP
+
+  [Test Script] > [Test Tool] > [Test::Builder] > [Test::Bulder::Stream] > [Result Formatter]
+                                                                                   ^
+                                                                             You are here
+
+A test script uses a test tool such as L<Test::More>, which uses Test::Builder
+to produce results. The results are sent to L<Test::Builder::Stream> which then
+forwards them on to one or more formatters. The default formatter is
+L<Test::Builder::Fromatter::TAP> which produces TAP output.
+
+=head1 SYNOPSYS
+
+    package My::Formatter;
+    use base 'Test::Builder::Formatter';
+
+    sub ok {
+        my $self = shift;
+        my ($result) = @_;
+
+        ...
+    }
+
+    ...
+
+    1;
+
+=head2 TO USE IT
+
+    use Test::More;
+    use My::Formatter;
+
+    # Creates a new instance of your listener. Any params you pass in will be
+    # passed into the constructor. Exceptions: 'id', 'stream' and 'tb' which
+    # are used directly by 'listen' if present.
+    my $unlisten = My::Formatter->listen(...);
+
+    # To stop listening:
+    $unlisten->();
+
+=head1 METHODS
+
+=head2 PROVIDED
+
+=over 4
+
+=item $L = $class->new(%params)
+
+Create a new instance. Arguments must be key => value pairs where the key is a
+method name on the object.
+
+=item $unlisten = $class->listen(%params)
+
+=item $unlisten = $class->listen(id => 'foo', %params)
+
+=item $unlisten = $class->listen(stream => $STREAM, %params)
+
+=item $unlisten = $class->listen(tb => $BUILDER, %params)
+
+Construct an instance using %params, and add it as a listener on the stream.
+'id', 'stream', and 'tb' are special arguments that can be used to specify the
+id of the listener, the stream to which the instance will listen, or the
+L<Test::Builder> instance from which to find the stream.
+
+=item $L->handle($result)
+
+Forward the resutl on to the correct method.
+
+=item $subref = $L->to_handler()
+
+Returns an anonymous sub that accepts results as arguments and passes them into
+handle() on this instance.
+
+=back
+
+=head2 FOR YOU TO WRITE
+
+=over 4
+
+=item $self->ok($result)
+
+=item $self->note($result)
+
+=item $self->diag($result)
+
+=item $self->plan($result)
+
+=item $self->finish($result)
+
+=item $self->bail($result)
+
+=item $self->child($result)
+
+Any results given to the handle() method will be passed into the associated
+sub. If the sub is not defined then results of that type will be ignored.
+
+=back
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 SOURCE
+
+The source code repository for Test::More can be found at
+F<http://github.com/Test-More/test-more/>.
+
+=head1 COPYRIGHT
+
+Copyright 2014 Chad Granum E<lt>exodist7@gmail.comE<gt>.
+
+This program is free software; you can redistribute it and/or
+modify it under the same terms as Perl itself.
+
+See F<http://www.perl.com/perl/misc/Artistic.html>
diff --git a/cpan/Test-Simple/lib/Test/Builder/Formatter/LegacyResults.pm b/cpan/Test-Simple/lib/Test/Builder/Formatter/LegacyResults.pm
new file mode 100644 (file)
index 0000000..63960f7
--- /dev/null
@@ -0,0 +1,166 @@
+package Test::Builder::Formatter::LegacyResults;
+use strict;
+use warnings;
+
+use base 'Test::Builder::Formatter';
+
+use Test::Builder::Threads;
+
+sub init {
+    my $self = shift;
+    $self->reset;
+}
+
+sub reset {
+    my $self = shift;
+
+    $self->{Test_Results} = &share( [] );
+    $self->{Curr_Test}    = 0;
+
+    &share(\$self->{Curr_Test});
+
+    return;
+}
+
+sub summary {
+    my($self) = shift;
+    return map { $_->{'ok'} } @{ $self->{Test_Results} };
+}
+
+sub details {
+    my $self = shift;
+    return @{ $self->{Test_Results} };
+}
+
+sub current_test {
+    my ($self, $num) = @_;
+
+    lock( $self->{Curr_Test} );
+    if( defined $num ) {
+        my $delta = $num - $self->{Curr_Test};
+        $self->{Curr_Test} = $num;
+
+        # If the test counter is being pushed forward fill in the details.
+        my $test_results = $self->{Test_Results};
+        if( $num > @$test_results ) {
+            my $start = @$test_results ? @$test_results : 0;
+            for( $start .. $num - 1 ) {
+                $test_results->[$_] = &share(
+                    {
+                        'ok'      => 1,
+                        actual_ok => undef,
+                        reason    => 'incrementing test number',
+                        type      => 'unknown',
+                        name      => undef
+                    }
+                );
+            }
+        }
+        # If backward, wipe history.  Its their funeral.
+        elsif( $num < @$test_results ) {
+            $#{$test_results} = $num - 1;
+        }
+    }
+    return $self->{Curr_Test};
+}
+
+sub sanity_check {
+    my $self = shift;
+    my ($tb) = @_;
+
+    $tb->_whoa( $self->{Curr_Test} < 0, 'Says here you ran a negative number of tests!' );
+
+    $tb->_whoa(
+        $self->{Curr_Test} != @{ $self->{Test_Results} },
+        'Somehow you got a different number of results than tests ran!'
+    );
+
+    return;
+}
+
+sub ok {
+    my $self = shift;
+    my ($item) = @_;
+
+    my $result = &share( {} );
+
+    lock $self->{Curr_Test};
+    $self->{Curr_Test}++;
+
+    $result->{ok} = $item->bool;
+    $result->{actual_ok} = $item->real_bool;
+
+    my $name = $item->name;
+    if(defined $name) {
+        $name =~ s|#|\\#|g;    # # in a name can confuse Test::Harness.
+        $result->{name} = $name;
+    }
+    else {
+        $result->{name} = '';
+    }
+
+    if($item->skip && ($item->in_todo || $item->todo)) {
+        $result->{type} = 'todo_skip',
+        $result->{reason} = $item->skip || $item->todo;
+    }
+    elsif($item->in_todo || $item->todo) {
+        $result->{reason} = $item->todo;
+        $result->{type}   = 'todo';
+    }
+    elsif($item->skip) {
+        $result->{reason} = $item->skip;
+        $result->{type}   = 'skip';
+    }
+    else {
+        $result->{reason} = '';
+        $result->{type}   = '';
+    }
+
+    $self->{Test_Results}[ $self->{Curr_Test} - 1 ] = $result;
+}
+
+1;
+
+__END__
+
+=head1 NAME
+
+Test::Builder::Formatter::LegacyResults - Encapsulate some legacy stuff.
+
+=head1 DESCRIPTION
+
+Older versions kept track of test results using an array of hashes. This is now
+deprecated, but needs to still work for legacy code.
+
+=head1 TEST COMPONENT MAP
+
+  [Test Script] > [Test Tool] > [Test::Builder] > [Test::Bulder::Stream] > [Result Formatter]
+                                                                                   ^
+                                                                             You are here
+
+A test script uses a test tool such as L<Test::More>, which uses Test::Builder
+to produce results. The results are sent to L<Test::Builder::Stream> which then
+forwards them on to one or more formatters. The default formatter is
+L<Test::Builder::Fromatter::TAP> which produces TAP output.
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 SOURCE
+
+The source code repository for Test::More can be found at
+F<http://github.com/Test-More/test-more/>.
+
+=head1 COPYRIGHT
+
+Copyright 2014 Chad Granum E<lt>exodist7@gmail.comE<gt>.
+
+This program is free software; you can redistribute it and/or
+modify it under the same terms as Perl itself.
+
+See F<http://www.perl.com/perl/misc/Artistic.html>
diff --git a/cpan/Test-Simple/lib/Test/Builder/Formatter/TAP.pm b/cpan/Test-Simple/lib/Test/Builder/Formatter/TAP.pm
new file mode 100644 (file)
index 0000000..f1d2f57
--- /dev/null
@@ -0,0 +1,447 @@
+package Test::Builder::Formatter::TAP;
+use strict;
+use warnings;
+
+use Test::Builder::Threads;
+use Test::Builder::Util qw/accessors try protect new accessor/;
+use Carp qw/croak confess/;
+
+use base 'Test::Builder::Formatter';
+
+accessors qw/No_Header No_Diag Depth Use_Numbers _the_plan/;
+
+accessor io_sets => sub { {} };
+
+use constant OUT  => 0;
+use constant FAIL => 1;
+use constant TODO => 2;
+
+#######################
+# {{{ INITIALIZATION
+#######################
+
+sub init {
+    my $self = shift;
+
+    $self->no_header(0);
+    $self->use_numbers(1);
+
+    $self->{number} = 0;
+
+    $self->{lock} = 1;
+    share($self->{lock});
+
+    $self->init_legacy;
+
+    return $self;
+}
+
+#######################
+# }}} INITIALIZATION
+#######################
+
+#######################
+# {{{ RESULT METHODS
+#######################
+
+for my $handler (qw/bail nest/) {
+    my $sub = sub {
+        my $self = shift;
+        my ($item) = @_;
+        $self->_print_to_fh($self->result_handle($item, OUT), $item->indent || "", $item->to_tap);
+    };
+    no strict 'refs';
+    *$handler = $sub;
+}
+
+sub child {
+    my $self = shift;
+    my ($item) = @_;
+
+    return unless $item->action eq 'push' && $item->is_subtest;
+
+    my $name = $item->name;
+    $self->_print_to_fh($self->result_handle($item, OUT), $item->indent || "", "# Subtest: $name\n");
+}
+
+sub finish {
+    my $self = shift;
+    my ($item) = @_;
+
+    return if $self->no_header;
+    return unless $item->tests_run;
+
+    my $plan = $self->_the_plan;
+    return unless $plan;
+
+    if ($plan) {
+        return unless $plan->directive;
+        return unless $plan->directive eq 'NO_PLAN';
+    }
+
+    my $total = $item->tests_run;
+    $self->_print_to_fh($self->result_handle($item, OUT), $item->indent || '', "1..$total\n");
+}
+
+sub plan {
+    my $self = shift;
+    my ($item) = @_;
+
+    $self->_the_plan($item);
+
+    return if $self->no_header;
+
+    return if $item->directive && $item->directive eq 'NO_PLAN';
+
+    my $out = $item->to_tap;
+    return unless $out;
+
+    my $handle = $self->result_handle($item, OUT);
+    $self->_print_to_fh($handle, $item->indent || "", $out);
+}
+
+sub ok {
+    my $self = shift;
+    my ($item) = @_;
+
+    $self->atomic_result(sub {
+        my $num = $self->use_numbers ? ++($self->{number}) : undef;
+        $self->_print_to_fh($self->result_handle($item, OUT), $item->indent || "", $item->to_tap($num));
+    });
+}
+
+sub diag {
+    my $self = shift;
+    my ($item) = @_;
+
+    return if $self->no_diag;
+
+    # Prevent printing headers when compiling (i.e. -c)
+    return if $^C;
+
+    my $want_handle = $item->in_todo ? TODO : FAIL;
+    my $handle = $self->result_handle($item, $want_handle);
+
+    $self->_print_to_fh( $handle, $item->indent || "", $item->to_tap );
+}
+
+sub note {
+    my $self = shift;
+    my ($item) = @_;
+
+    return if $self->no_diag;
+
+    # Prevent printing headers when compiling (i.e. -c)
+    return if $^C;
+
+    $self->_print_to_fh( $self->result_handle($item, OUT), $item->indent || "", $item->to_tap );
+}
+
+#######################
+# }}} RESULT METHODS
+#######################
+
+##############################
+# {{{ IO accessors
+##############################
+
+sub io_set {
+    my $self = shift;
+    my ($name, @handles) = @_;
+
+    if (@handles) {
+        my ($out, $fail, $todo) = @handles;
+        $out = $self->_new_fh($out);
+
+        $fail = $fail ? $self->_new_fh($fail) : $out;
+        $todo = $todo ? $self->_new_fh($todo) : $out;
+
+        $self->io_sets->{$name} = [$out, $fail, $todo];
+    }
+
+    return $self->io_sets->{$name};
+}
+
+sub encoding_set {
+    my $self = shift;
+    my ($encoding) = @_;
+
+    $self->io_sets->{$encoding} ||= do {
+        my ($out, $fail) = $self->open_handles();
+        my $todo = $out;
+
+        binmode($out, ":encoding($encoding)");
+        binmode($fail, ":encoding($encoding)");
+
+        [$out, $fail, $todo];
+    };
+
+    return $self->io_sets->{$encoding};
+}
+
+sub result_handle {
+    my $self = shift;
+    my ($result, $index) = @_;
+
+    my $rencoding = $result ? $result->encoding : undef;
+
+    # Open handles in the encoding if one is set.
+    $self->encoding_set($rencoding) if $rencoding && $rencoding ne 'legacy';
+
+    for my $name ($rencoding, qw/utf8 legacy/) {
+        next unless $name;
+        my $handles = $self->io_set($name);
+        return $handles->[$index] if $handles;
+    }
+
+    confess "This should not happen";
+}
+
+##############################
+# }}} IO accessors
+##############################
+
+########################
+# {{{ Legacy Support
+########################
+
+my $LEGACY;
+
+sub full_reset { $LEGACY = undef }
+
+sub init_legacy {
+    my $self = shift;
+
+    unless ($LEGACY) {
+        my ($out, $err) = $self->open_handles();
+
+        _copy_io_layers(\*STDOUT, $out);
+        _copy_io_layers(\*STDERR, $err);
+
+        _autoflush($out);
+        _autoflush($err);
+
+        # LEGACY, BAH!
+        _autoflush(\*STDOUT);
+        _autoflush(\*STDERR);
+
+        $LEGACY = [$out, $err, $out];
+    }
+
+    $self->reset_outputs;
+}
+
+sub reset_outputs {
+    my $self = shift;
+    my ($out, $fail, $todo) = @$LEGACY;
+    $self->io_sets->{legacy} = [$out, $fail, $todo];
+}
+
+sub reset {
+    my $self = shift;
+    $self->reset_outputs;
+    $self->no_header(0);
+    $self->use_numbers(1);
+    lock $self->{lock};
+    $self->{number} = 0;
+    share( $self->{number} );
+
+    1;
+}
+
+sub output {
+    my $self = shift;
+    my $handles = $self->io_set('legacy');
+    ($handles->[OUT]) = $self->_new_fh($_[0]) if @_;
+    return $handles->[OUT];
+}
+
+sub failure_output {
+    my $self = shift;
+    my $handles = $self->io_set('legacy');
+    ($handles->[FAIL]) = $self->_new_fh($_[0]) if @_;
+    return $handles->[FAIL];
+}
+
+sub todo_output {
+    my $self = shift;
+    my $handles = $self->io_set('legacy');
+    ($handles->[TODO]) = $self->_new_fh($_[0]) if @_;
+    return $handles->[TODO];
+}
+
+sub _diag_fh {
+    my $self = shift;
+    my ($in_todo) = @_;
+
+    return $in_todo ? $self->todo_output : $self->failure_output;
+}
+
+sub _print {
+    my $self = shift;
+    my ($indent, @msgs) = @_;
+    return $self->_print_to_fh( $self->output, $indent, @msgs );
+}
+
+sub current_test {
+    my $self = shift;
+
+    if (@_) {
+        my ($new) = @_;
+        $self->atomic_result(sub { $self->{number} = $new });
+    }
+
+    return $self->{number};
+}
+
+########################
+# }}} Legacy Support
+########################
+
+###############
+# {{{ UTILS
+###############
+
+sub _print_to_fh {
+    my( $self, $fh, $indent, @msgs ) = @_;
+
+    # Prevent printing headers when only compiling.  Mostly for when
+    # tests are deparsed with B::Deparse
+    return if $^C;
+
+    my $msg = join '', @msgs;
+
+    local( $\, $", $, ) = ( undef, ' ', '' );
+
+    $msg =~ s/^/$indent/mg;
+
+    return print $fh $msg;
+}
+
+sub open_handles {
+    my $self = shift;
+
+    open( my $out, ">&STDOUT" ) or die "Can't dup STDOUT:  $!";
+    open( my $err, ">&STDERR" ) or die "Can't dup STDERR:  $!";
+
+    _autoflush($out);
+    _autoflush($err);
+
+    return ($out, $err);
+}
+
+sub atomic_result {
+    my $self = shift;
+    my ($code) = @_;
+    lock $self->{lock};
+    $code->();
+}
+
+sub _autoflush {
+    my($fh) = shift;
+    my $old_fh = select $fh;
+    $| = 1;
+    select $old_fh;
+
+    return;
+}
+
+sub _copy_io_layers {
+    my($src, $dst) = @_;
+
+    try {
+        require PerlIO;
+        my @src_layers = PerlIO::get_layers($src);
+        _apply_layers($dst, @src_layers) if @src_layers;
+    };
+
+    return;
+}
+
+sub _new_fh {
+    my $self = shift;
+    my($file_or_fh) = shift;
+
+    return $file_or_fh if $self->is_fh($file_or_fh);
+
+    my $fh;
+    if( ref $file_or_fh eq 'SCALAR' ) {
+        open $fh, ">>", $file_or_fh
+          or croak("Can't open scalar ref $file_or_fh: $!");
+    }
+    else {
+        open $fh, ">", $file_or_fh
+          or croak("Can't open test output log $file_or_fh: $!");
+        _autoflush($fh);
+    }
+
+    return $fh;
+}
+
+sub is_fh {
+    my $self     = shift;
+    my $maybe_fh = shift;
+    return 0 unless defined $maybe_fh;
+
+    return 1 if ref $maybe_fh  eq 'GLOB';    # its a glob ref
+    return 1 if ref \$maybe_fh eq 'GLOB';    # its a glob
+
+    my $out;
+    protect {
+        $out = eval { $maybe_fh->isa("IO::Handle") }
+            || eval { tied($maybe_fh)->can('TIEHANDLE') };
+    };
+
+    return $out;
+}
+
+
+###############
+# }}} UTILS
+###############
+
+1;
+
+__END__
+
+=head1 NAME
+
+Test::Builder::Formatter::TAP - TAP formatter.
+
+=head1 TEST COMPONENT MAP
+
+  [Test Script] > [Test Tool] > [Test::Builder] > [Test::Bulder::Stream] > [Result Formatter]
+                                                                                   ^
+                                                                             You are here
+
+A test script uses a test tool such as L<Test::More>, which uses Test::Builder
+to produce results. The results are sent to L<Test::Builder::Stream> which then
+forwards them on to one or more formatters. The default formatter is
+L<Test::Builder::Fromatter::TAP> which produces TAP output.
+
+=head1 DESCRIPTION
+
+This module is responsible for taking results from the stream and outputting
+TAP. You probably should not directly interact with this.
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 SOURCE
+
+The source code repository for Test::More can be found at
+F<http://github.com/Test-More/test-more/>.
+
+=head1 COPYRIGHT
+
+Copyright 2014 Chad Granum E<lt>exodist7@gmail.comE<gt>.
+
+This program is free software; you can redistribute it and/or
+modify it under the same terms as Perl itself.
+
+See F<http://www.perl.com/perl/misc/Artistic.html>
index a11033e..1a095ca 100644 (file)
@@ -7,13 +7,18 @@ use Test::Builder 0.99;
 require Exporter;
 our @ISA = qw(Exporter);
 
 require Exporter;
 our @ISA = qw(Exporter);
 
-our $VERSION = '1.001003';
+our $VERSION = '1.301001_034';
 $VERSION = eval $VERSION;      ## no critic (BuiltinFunctions::ProhibitStringyEval)
 
 
 =head1 NAME
 
 $VERSION = eval $VERSION;      ## no critic (BuiltinFunctions::ProhibitStringyEval)
 
 
 =head1 NAME
 
-Test::Builder::Module - Base class for test modules
+Test::Builder::Module - *DEPRECATED* Base class for test modules
+
+=head1 DEPRECATED
+
+B<This module is deprecated> See L<Test::Builder::Provider> for what you should
+use instead.
 
 =head1 SYNOPSIS
 
 
 =head1 SYNOPSIS
 
@@ -29,59 +34,61 @@ Test::Builder::Module - Base class for test modules
       my $tb = $CLASS->builder;
       return $tb->ok(@_);
   }
       my $tb = $CLASS->builder;
       return $tb->ok(@_);
   }
-  
+
   1;
 
 
 =head1 DESCRIPTION
 
   1;
 
 
 =head1 DESCRIPTION
 
-This is a superclass for Test::Builder-based modules.  It provides a
+This is a superclass for L<Test::Builder>-based modules.  It provides a
 handful of common functionality and a method of getting at the underlying
 handful of common functionality and a method of getting at the underlying
-Test::Builder object.
+L<Test::Builder> object.
 
 
 =head2 Importing
 
 
 
 =head2 Importing
 
-Test::Builder::Module is a subclass of Exporter which means your
+Test::Builder::Module is a subclass of L<Exporter> which means your
 module is also a subclass of Exporter.  @EXPORT, @EXPORT_OK, etc...
 all act normally.
 
 module is also a subclass of Exporter.  @EXPORT, @EXPORT_OK, etc...
 all act normally.
 
-A few methods are provided to do the C<use Your::Module tests => 23> part
+A few methods are provided to do the C<< use Your::Module tests => 23 >> part
 for you.
 
 =head3 import
 
 for you.
 
 =head3 import
 
-Test::Builder::Module provides an import() method which acts in the
-same basic way as Test::More's, setting the plan and controlling
+Test::Builder::Module provides an C<import()> method which acts in the
+same basic way as L<Test::More>'s, setting the plan and controlling
 exporting of functions and variables.  This allows your module to set
 exporting of functions and variables.  This allows your module to set
-the plan independent of Test::More.
+the plan independent of L<Test::More>.
 
 
-All arguments passed to import() are passed onto 
-C<< Your::Module->builder->plan() >> with the exception of 
+All arguments passed to C<import()> are passed onto
+C<< Your::Module->builder->plan() >> with the exception of
 C<< import =>[qw(things to import)] >>.
 
     use Your::Module import => [qw(this that)], tests => 23;
 
 C<< import =>[qw(things to import)] >>.
 
     use Your::Module import => [qw(this that)], tests => 23;
 
-says to import the functions this() and that() as well as set the plan
+says to import the functions C<this()> and C<that()> as well as set the plan
 to be 23 tests.
 
 to be 23 tests.
 
-import() also sets the exported_to() attribute of your builder to be
-the caller of the import() function.
+C<import()> also sets the C<exported_to()> attribute of your builder to be
+the caller of the C<import()> function.
 
 
-Additional behaviors can be added to your import() method by overriding
-import_extra().
+Additional behaviors can be added to your C<import()> method by overriding
+C<import_extra()>.
 
 =cut
 
 sub import {
     my($class) = shift;
 
 
 =cut
 
 sub import {
     my($class) = shift;
 
+    my $test = $class->builder;
+    my $caller = caller;
+
+    warn __PACKAGE__ . " is deprecated!\n" if $caller->can('TB_INSTANCE') && $caller->TB_INSTANCE->modern;
+
     # Don't run all this when loading ourself.
     return 1 if $class eq 'Test::Builder::Module';
 
     # Don't run all this when loading ourself.
     return 1 if $class eq 'Test::Builder::Module';
 
-    my $test = $class->builder;
-
-    my $caller = caller;
 
     $test->exported_to($caller);
 
 
     $test->exported_to($caller);
 
@@ -123,13 +130,13 @@ sub _strip_imports {
 
     Your::Module->import_extra(\@import_args);
 
 
     Your::Module->import_extra(\@import_args);
 
-import_extra() is called by import().  It provides an opportunity for you
+C<import_extra()> is called by C<import()>.  It provides an opportunity for you
 to add behaviors to your module based on its import list.
 
 to add behaviors to your module based on its import list.
 
-Any extra arguments which shouldn't be passed on to plan() should be 
+Any extra arguments which shouldn't be passed on to C<plan()> should be
 stripped off by this method.
 
 stripped off by this method.
 
-See Test::More for an example of its use.
+See L<Test::More> for an example of its use.
 
 B<NOTE> This mechanism is I<VERY ALPHA AND LIKELY TO CHANGE> as it
 feels like a bit of an ugly hack in its current form.
 
 B<NOTE> This mechanism is I<VERY ALPHA AND LIKELY TO CHANGE> as it
 feels like a bit of an ugly hack in its current form.
@@ -147,15 +154,15 @@ Test::Builder object.
 
   my $builder = Your::Class->builder;
 
 
   my $builder = Your::Class->builder;
 
-This method returns the Test::Builder object associated with Your::Class.
+This method returns the L<Test::Builder> object associated with Your::Class.
 It is not a constructor so you can call it as often as you like.
 
 It is not a constructor so you can call it as often as you like.
 
-This is the preferred way to get the Test::Builder object.  You should
+This is the preferred way to get the L<Test::Builder> object.  You should
 I<not> get it via C<< Test::Builder->new >> as was previously
 recommended.
 
 I<not> get it via C<< Test::Builder->new >> as was previously
 recommended.
 
-The object returned by builder() may change at runtime so you should
-call builder() inside each function rather than store it in a global.
+The object returned by C<builder()> may change at runtime so you should
+call C<builder()> inside each function rather than store it in a global.
 
   sub ok {
       my $builder = Your::Class->builder;
 
   sub ok {
       my $builder = Your::Class->builder;
diff --git a/cpan/Test-Simple/lib/Test/Builder/Provider.pm b/cpan/Test-Simple/lib/Test/Builder/Provider.pm
new file mode 100644 (file)
index 0000000..fbee3b5
--- /dev/null
@@ -0,0 +1,463 @@
+package Test::Builder::Provider;
+use strict;
+use warnings;
+
+use Test::Builder 1.301001;
+use Test::Builder::Util qw/package_sub is_tester is_provider find_builder/;
+use Test::Builder::Trace;
+use Carp qw/croak/;
+use Scalar::Util qw/reftype set_prototype/;
+use B();
+
+my %SIG_MAP = (
+    '$' => 'SCALAR',
+    '@' => 'ARRAY',
+    '%' => 'HASH',
+    '&' => 'CODE',
+);
+
+my $ID = 1;
+
+sub import {
+    my $class = shift;
+    my $caller = caller;
+
+    $class->export_into($caller, @_);
+}
+
+sub export_into {
+    my $class = shift;
+    my ($dest, @sym_list) = @_;
+
+    my %subs;
+
+    my $meta = $class->make_provider($dest);
+
+    $subs{TB}      = \&find_builder;
+    $subs{builder} = \&find_builder;
+    $subs{anoint}  = \&anoint;
+    $subs{import}  = \&provider_import;
+    $subs{nest}    = \&nest;
+    $subs{provide} = $class->_build_provide($dest, $meta);
+    $subs{export}  = $class->_build_export($dest, $meta);
+    $subs{modernize} = \&modernize;
+
+    $subs{gives}         = sub { $subs{provide}->($_,    undef, give => 1) for @_ };
+    $subs{give}          = sub { $subs{provide}->($_[0], $_[1], give => 1)        };
+    $subs{provides}      = sub { $subs{provide}->($_)                      for @_ };
+
+    @sym_list = keys %subs unless @sym_list;
+
+    my %seen;
+    for my $name (grep { !$seen{$_}++ } @sym_list) {
+        no strict 'refs';
+        my $ref = $subs{$name} || package_sub($class, $name);
+        croak "$class does not export '$name'" unless $ref;
+        *{"$dest\::$name"} = $ref ;
+    }
+
+    1;
+}
+
+sub nest(&) {
+    return Test::Builder::Trace->nest(@_);
+}
+
+sub make_provider {
+    my $class = shift;
+    my ($dest) = @_;
+
+    my $meta = is_provider($dest);
+
+    unless ($meta) {
+        $meta = {refs => {}, attrs => {}, export => []};
+        no strict 'refs';
+        *{"$dest\::TB_PROVIDER_META"} = sub { $meta };
+    }
+
+    return $meta;
+}
+
+sub _build_provide {
+    my $class = shift;
+    my ($dest, $meta) = @_;
+
+    $meta->{provide} ||= sub {
+        my ($name, $ref, %params) = @_;
+
+        croak "$dest already provides or gives '$name'"
+            if $meta->{attrs}->{$name};
+
+        croak "The second argument to provide() must be a ref, got: $ref"
+            if $ref && !ref $ref;
+
+        $ref ||= package_sub($dest, $name);
+        croak "$dest has no sub named '$name', and no ref was given"
+            unless $ref;
+
+        my $attrs = {%params, package => $dest, name => $name};
+        $meta->{attrs}->{$name} = $attrs;
+
+        push @{$meta->{export}} => $name;
+
+        # If this is just giving, or not a coderef
+        return $meta->{refs}->{$name} = $ref if $params{give} || reftype $ref ne 'CODE';
+
+        my $o_name = B::svref_2object($ref)->GV->NAME;
+        if ($o_name && $o_name ne '__ANON__') { #sub has a name
+            $meta->{refs}->{$name} = $ref;
+            $attrs->{named} = 1;
+        }
+        else {
+            $attrs->{named} = 0;
+            # Voodoo....
+            # Insert an anonymous sub, and use a trick to make caller() think its
+            # name is this string, which tells us how to find the thing that was
+            # actually called.
+            my $globname = __PACKAGE__ . '::__ANON' . ($ID++) . '__';
+
+            my $code = sub {
+                no warnings 'once';
+                local *__ANON__ = $globname; # Name the sub so we can find it for real.
+                $ref->(@_);
+            };
+
+            # The prototype on set_prototype blocks this usage, even though it
+            # is valid. This is why we use the old-school &func() call.
+            # Oh the irony.
+            my $proto = prototype($ref);
+            &set_prototype($code, $proto) if $proto;
+
+            $meta->{refs}->{$name} = $code;
+
+            no strict 'refs';
+            *$globname = $code;
+            *$globname = $attrs;
+        }
+    };
+
+    return $meta->{provide};
+}
+
+sub _build_export {
+    my $class = shift;
+    my ($dest, $meta) = @_;
+
+    return sub {
+        my $class = shift;
+        my ($caller, @args) = @_;
+
+        my (%no, @list);
+        for my $thing (@args) {
+            if ($thing =~ m/^!(.*)$/) {
+                $no{$1}++;
+            }
+            else {
+                push @list => $thing;
+            }
+        }
+
+        unless(@list) {
+            my %seen;
+            @list = grep { !($no{$_} || $seen{$_}++) } @{$meta->{export}};
+        }
+
+        for my $name (@list) {
+            if ($name =~ m/^(\$|\@|\%)(.*)$/) {
+                my ($sig, $sym) = ($1, $2);
+
+                croak "$class does not export '$name'"
+                    unless ($meta->{refs}->{$sym} && reftype $meta->{refs}->{$sym} eq $SIG_MAP{$sig});
+
+                no strict 'refs';
+                *{"$caller\::$sym"} = $meta->{refs}->{$name} || *{"$class\::$sym"}{$SIG_MAP{$sig}}
+                    || croak "'$class' has no symbol named '$name'";
+            }
+            else {
+                croak "$class does not export '$name'"
+                    unless $meta->{refs}->{$name};
+
+                no strict 'refs';
+                *{"$caller\::$name"} = $meta->{refs}->{$name} || package_sub($class, $name)
+                    || croak "'$class' has no sub named '$name'";
+            }
+        }
+    };
+}
+
+sub provider_import {
+    my $class = shift;
+    my $caller = caller;
+
+    $class->anoint($caller);
+    $class->before_import(\@_, $caller) if $class->can('before_import');
+    $class->export($caller, @_);
+    $class->after_import(@_)   if $class->can('after_import');
+
+    1;
+}
+
+sub anoint { Test::Builder::Trace->anoint($_[1], $_[0]) };
+
+sub modernize {
+    my $target = shift;
+
+    if (package_sub($target, 'TB_INSTANCE')) {
+        my $tb = $target->TB_INSTANCE;
+        $tb->stream->use_fork;
+        $tb->modern(1);
+    }
+    else {
+        my $tb = Test::Builder->create(
+            modern        => 1,
+            shared_stream => 1,
+            no_reset_plan => 1,
+        );
+        $tb->stream->use_fork;
+        no strict 'refs';
+        *{"$target\::TB_INSTANCE"} = sub {$tb};
+    }
+}
+
+1;
+
+=head1 NAME
+
+Test::Builder::Provider - Helper for writing testing tools
+
+=head1 TEST COMPONENT MAP
+
+  [Test Script] > [Test Tool] > [Test::Builder] > [Test::Bulder::Stream] > [Result Formatter]
+                       ^
+                  You are here
+
+A test script uses a test tool such as L<Test::More>, which uses Test::Builder
+to produce results. The results are sent to L<Test::Builder::Stream> which then
+forwards them on to one or more formatters. The default formatter is
+L<Test::Builder::Fromatter::TAP> which produces TAP output.
+
+=head1 DESCRIPTION
+
+This package provides you with tools to write testing tools. It makes your job
+of integrating with L<Test::Builder> and other testing tools much easier.
+
+=head1 SYNOPSYS
+
+Instead of use L<Exporter> or other exporters, you can use convenience
+functions to define exports on the fly.
+
+    package My::Tester
+    use strict;
+    use warnings;
+
+    use Test::Builder::Provider;
+
+    sub before_import {
+        my $class = shift;
+        my ($import_args_ref) = @_;
+
+        ... Modify $import_args_ref ...
+        # $import_args_ref should contain only what you want to pass as
+        # arguments into export().
+    }
+
+    sub after_import {
+        my $class = shift;
+        my @args = @_;
+
+        ...
+    }
+
+    # Provide (export) an 'ok' function (the anonymous function is the export)
+    provide ok => sub { builder()->ok(@_) };
+
+    # Provide some of our package functions as test functions.
+    provides qw/is is_deeply/;
+    sub is { ... }
+    sub is_deeply { ... };
+
+    # Provide a 'subtests' function. Functions that accept a block like this
+    # that may run other tests should be use nest() to run the codeblocks they
+    # recieve to mark them as nested providers.
+    provide subtests => sub(&) {
+        my $code = shift;
+        nest { $code->() };       # OR: nest(\&$code)   OR: &nest($code);
+    };
+
+    # Provide a couple nested functions defined in our package
+    provide qw/subtests_alt subtests_xxx/;
+    sub subtests_alt(&) { ... }
+    sub subtests_xxx(&) { ... }
+
+    # Export a helper function that does not produce any results (regular
+    # export).
+    give echo => sub { print @_ };
+
+    # Same for multiple functions in our package:
+    gives qw/echo_stdout echo_stderr/;
+    sub echo_stdout { ... }
+    sub echo_stderr { ... }
+
+=head2 IN A TEST FILE
+
+    use Test::More;
+    use My::Tester;
+
+    ok(1, "blah");
+
+    is(1, 1, "got 1");
+
+    subtests {
+        ok(1, "a subtest");
+        ok(1, "another");
+    };
+
+=head2 USING EXTERNAL EXPORT LIBRARIES
+
+Maybe you like L<Exporter> or another export tool. In that case you still need
+the 'provides' and 'nest' functions from here to mark testing tools as such.
+
+This is also a quick way to update an old library, but you also need to remove
+any references to C<$Test::Builder::Level> which is now deprecated.
+
+    package My::Tester
+    use strict;
+    use warnings;
+
+    use base 'Exporter';
+    use Test::Builder::Provider qw/provides nest/;
+
+    our @EXPORT = qw{
+        ok is is_deeply
+        subtests subtests_alt subtests_xxx
+        echo echo_stderr echo stdout
+    };
+
+    # *mark* the testing tools
+    provides qw/ok is is_deeply/;
+    sub ok { builder()->ok(@_) }
+    sub is { ... }
+    sub is_deeply { ... };
+
+    # Remember to use nest()
+    provide qw/subtests subtests_alt subtests_xxx/;
+    sub subtests(&) { ... }
+    sub subtests_alt(&) { ... }
+    sub subtests_xxx(&) { ... }
+
+    # No special marking needed for these as they do not produce results.
+    sub echo { print @_ }
+    sub echo_stdout { ... }
+    sub echo_stderr { ... }
+
+=head2 SUPPORTING OLD VERSIONS
+
+See L<Test::Builder::Compat> which is a seperate dist that has no dependancies.
+You can use it to write providers that make use of the new Test::Builder, while
+also working fine on older versions of Test::Builder.
+
+=head1 META-DATA
+
+Importing this module will always mark your package as a test provider. It does
+this by injecting a method into your package called 'TB_PROVIDER_META'. This
+method simply returns the meta-data hash for your package.
+
+To avoid this you can use 'require' instead of 'use', or you can use () in your import:
+
+    # Load the module, but do not make this package a provider.
+    require Test::Builder::Provider;
+    use Test::Builder::Provider();
+
+=head1 EXPORTS
+
+All of these subs are injected into your package (unless you request a subset).
+
+=over 4
+
+=item my $tb = TB()
+
+=item my $tb = builder()
+
+Get the correct instance of L<Test::Builder>. Usually this is the instance used
+in the test file calling a tool in your package. If no such instance can be
+found the default Test::Builder instance will be used.
+
+=item $class->anoint($target)
+
+Used to mark the $target package as a test package that consumes your test
+package for tools. This is done automatically for you if you use the default
+'import' sub below.
+
+=item $class->import()
+
+=item $class->import(@list)
+
+An import() function that exports your tools to any consumers of your class.
+
+=item $class->export($dest)
+
+=item $class->export($dest, @list)
+
+Export the packages tools into the $dest package. @list me be specified to
+restrict what is exported. Prefix any item in the list with '!' to prevent
+exporting it.
+
+=item provide $name
+
+=item provide $name => sub { ... }
+
+Provide a testing tool that will produce results. If no coderef is given it
+will look for a coderef with $name in your package.
+
+You may also use this to export refs of any type.
+
+=item provides qw/sub1 sub2 .../
+
+Like provide except you can specify multiple subs to export.
+
+=item nest { ... }
+
+=item nest(\&$code)
+
+=item &nest($code)
+
+Used as a tracing barrier, any results generated inside the nest will trace to
+the nest as opposed to the call to your provided tool.
+
+=item give $name
+
+=item give $name => sub { ... }
+
+Export a helper function that does not produce results.
+
+=item gives qw/sub1 sub2 .../
+
+Export helper functions.
+
+=back
+
+=head1 HOW DO I TEST MY TEST TOOLS?
+
+See L<Test::Tester2>
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 SOURCE
+
+The source code repository for Test::More can be found at
+F<http://github.com/Test-More/test-more/>.
+
+=head1 COPYRIGHT
+
+Copyright 2014 Chad Granum E<lt>exodist7@gmail.comE<gt>.
+
+This program is free software; you can redistribute it and/or
+modify it under the same terms as Perl itself.
+
+See F<http://www.perl.com/perl/misc/Artistic.html>
diff --git a/cpan/Test-Simple/lib/Test/Builder/Result.pm b/cpan/Test-Simple/lib/Test/Builder/Result.pm
new file mode 100644 (file)
index 0000000..308a82f
--- /dev/null
@@ -0,0 +1,134 @@
+package Test::Builder::Result;
+use strict;
+use warnings;
+
+use Carp qw/confess/;
+use Scalar::Util qw/blessed/;
+
+use Test::Builder::Util qw/accessors new/;
+
+accessors(qw/trace pid depth in_todo source constructed/);
+
+sub init {
+    my $self = shift;
+    my %params = @_;
+
+    $self->constructed([caller(1)]);
+    $self->pid($$) unless $params{pid};
+}
+
+sub type {
+    my $self = shift;
+    my $class = blessed($self);
+    if ($class && $class =~ m/^.*::([^:]+)$/) {
+        return lc($1);
+    }
+
+    confess "Could not determine result type for $self";
+}
+
+sub indent {
+    my $self = shift;
+    return '' unless $self->depth;
+    return '    ' x $self->depth;
+}
+
+sub encoding {
+    my $self = shift;
+    return unless $self->trace;
+    return $self->trace->encoding;
+}
+
+1;
+
+__END__
+
+=head1 NAME
+
+Test::Builder::Result - Base class for results
+
+=head1 DESCRIPTION
+
+Base class for all result objects that get passed through
+L<Test::Builder::Stream>.
+
+=head1 METHODS
+
+=head2 CONSTRUCTORS
+
+=over 4
+
+=item $r = $class->new(...)
+
+Create a new instance
+
+=back
+
+=head2 SIMPLE READ/WRITE ACCESSORS
+
+=over 4
+
+=item $r->trace
+
+Get the test trace info, including where to report errors.
+
+=item $r->pid
+
+PID in which the result was created.
+
+=item $r->depth
+
+Builder depth of the result (0 for normal, 1 for subtest, 2 for nested, etc).
+
+=item $r->in_todo
+
+True if the result was generated inside a todo.
+
+=item $r->source
+
+Builder that created the result, usually $0, but the name of a subtest when
+inside a subtest.
+
+=item $r->constructed
+
+Package, File, and Line in which the result was built.
+
+=back
+
+=head2 INFORMATION
+
+=over 4
+
+=item $r->type
+
+Type of result. Usually this is the lowercased name from the end of the
+package. L<Test::Builder::Result::Ok> = 'ok'.
+
+=item $r->indent
+
+Returns the indentation that should be used to display the result ('    ' x
+depth).
+
+=back
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 SOURCE
+
+The source code repository for Test::More can be found at
+F<http://github.com/Test-More/test-more/>.
+
+=head1 COPYRIGHT
+
+Copyright 2014 Chad Granum E<lt>exodist7@gmail.comE<gt>.
+
+This program is free software; you can redistribute it and/or
+modify it under the same terms as Perl itself.
+
+See F<http://www.perl.com/perl/misc/Artistic.html>
diff --git a/cpan/Test-Simple/lib/Test/Builder/Result/Bail.pm b/cpan/Test-Simple/lib/Test/Builder/Result/Bail.pm
new file mode 100644 (file)
index 0000000..ff34db7
--- /dev/null
@@ -0,0 +1,116 @@
+package Test::Builder::Result::Bail;
+use strict;
+use warnings;
+
+use base 'Test::Builder::Result';
+
+use Test::Builder::Util qw/accessors/;
+accessors qw/reason/;
+
+sub to_tap {
+    my $self = shift;
+    return "Bail out!  " . $self->reason . "\n";
+}
+
+1;
+
+__END__
+
+=head1 NAME
+
+Test::Builder::Result::Bail - Bailout!
+
+=head1 DESCRIPTION
+
+Sent when the test needs to bail out.
+
+=head1 METHODS
+
+See L<Test::Builder::Result> which is the base class for this module.
+
+=head2 CONSTRUCTORS
+
+=over 4
+
+=item $r = $class->new(...)
+
+Create a new instance
+
+=back
+
+=head2 SIMPLE READ/WRITE ACCESSORS
+
+=over 4
+
+=item $r->reason
+
+Reason for the bailout.
+
+=item $r->trace
+
+Get the test trace info, including where to report errors.
+
+=item $r->pid
+
+PID in which the result was created.
+
+=item $r->depth
+
+Builder depth of the result (0 for normal, 1 for subtest, 2 for nested, etc).
+
+=item $r->in_todo
+
+True if the result was generated inside a todo.
+
+=item $r->source
+
+Builder that created the result, usually $0, but the name of a subtest when
+inside a subtest.
+
+=item $r->constructed
+
+Package, File, and Line in which the result was built.
+
+=back
+
+=head2 INFORMATION
+
+=over 4
+
+=item $r->to_tap
+
+Returns the TAP string for the plan (not indented).
+
+=item $r->type
+
+Type of result. Usually this is the lowercased name from the end of the
+package. L<Test::Builder::Result::Ok> = 'ok'.
+
+=item $r->indent
+
+Returns the indentation that should be used to display the result ('    ' x
+depth).
+
+=back
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 SOURCE
+
+The source code repository for Test::More can be found at
+F<http://github.com/Test-More/test-more/>.
+
+=head1 COPYRIGHT
+
+Copyright 2014 Chad Granum E<lt>exodist7@gmail.comE<gt>.
+
+This program is free software; you can redistribute it and/or
+modify it under the same terms as Perl itself.
+
+See F<http://www.perl.com/perl/misc/Artistic.html>
diff --git a/cpan/Test-Simple/lib/Test/Builder/Result/Child.pm b/cpan/Test-Simple/lib/Test/Builder/Result/Child.pm
new file mode 100644 (file)
index 0000000..c5fd881
--- /dev/null
@@ -0,0 +1,146 @@
+package Test::Builder::Result::Child;
+use strict;
+use warnings;
+
+use base 'Test::Builder::Result';
+
+use Carp qw/confess/;
+
+use Test::Builder::Util qw/accessors/;
+accessors qw/name is_subtest/;
+
+sub action {
+    my $self = shift;
+    if (@_) {
+        my ($action) = @_;
+        confess "action must be one of 'push' or 'pop'"
+            unless $action =~ m/^(push|pop)$/;
+
+        $self->{action} = $action;
+    }
+
+    confess "action was never set!"
+        unless $self->{action};
+
+    return $self->{action};
+}
+
+sub to_tap { }
+
+1;
+
+__END__
+
+=head1 NAME
+
+Test::Builder::Result::Child - Child result type
+
+=head1 DESCRIPTION
+
+Sent when a child Builder is spawned, such as a subtest.
+
+=head1 METHODS
+
+See L<Test::Builder::Result> which is the base class for this module.
+
+=head2 CONSTRUCTORS
+
+=over 4
+
+=item $r = $class->new(...)
+
+Create a new instance
+
+=back
+
+=head2 ATTRIBUTES
+
+=over 4
+
+=item $r->action
+
+Either 'push' or 'pop'. When a child is created a push is sent, when a child
+exits a pop is sent.
+
+=back
+
+=head2 SIMPLE READ/WRITE ACCESSORS
+
+=over 4
+
+=item $r->name
+
+Name of the child
+
+=item $r->is_subtest
+
+True if the child was spawned for a subtest.
+
+=item $r->trace
+
+Get the test trace info, including where to report errors.
+
+=item $r->pid
+
+PID in which the result was created.
+
+=item $r->depth
+
+Builder depth of the result (0 for normal, 1 for subtest, 2 for nested, etc).
+
+=item $r->in_todo
+
+True if the result was generated inside a todo.
+
+=item $r->source
+
+Builder that created the result, usually $0, but the name of a subtest when
+inside a subtest.
+
+=item $r->constructed
+
+Package, File, and Line in which the result was built.
+
+=back
+
+=head2 INFORMATION
+
+=over 4
+
+=item $r->to_tap
+
+no-op, return nothing.
+
+=item $r->type
+
+Type of result. Usually this is the lowercased name from the end of the
+package. L<Test::Builder::Result::Ok> = 'ok'.
+
+=item $r->indent
+
+Returns the indentation that should be used to display the result ('    ' x
+depth).
+
+=back
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 SOURCE
+
+The source code repository for Test::More can be found at
+F<http://github.com/Test-More/test-more/>.
+
+=head1 COPYRIGHT
+
+Copyright 2014 Chad Granum E<lt>exodist7@gmail.comE<gt>.
+
+This program is free software; you can redistribute it and/or
+modify it under the same terms as Perl itself.
+
+See F<http://www.perl.com/perl/misc/Artistic.html>
diff --git a/cpan/Test-Simple/lib/Test/Builder/Result/Diag.pm b/cpan/Test-Simple/lib/Test/Builder/Result/Diag.pm
new file mode 100644 (file)
index 0000000..f865332
--- /dev/null
@@ -0,0 +1,156 @@
+package Test::Builder::Result::Diag;
+use strict;
+use warnings;
+
+use base 'Test::Builder::Result';
+
+use Scalar::Util();
+use Test::Builder::Util qw/accessors try/;
+use Encode();
+accessors qw/message/;
+
+my $NORMALIZE = try { require Unicode::Normalize; 1 };
+
+sub to_tap {
+    my $self = shift;
+
+    chomp(my $msg = $self->message);
+
+    if ($self->trace && $self->trace->report) {
+        my $encoding = $self->trace->encoding;
+        if ($encoding && $encoding ne 'legacy') {
+            my $file = $self->trace->report->file;
+            my $decoded;
+            try { $decoded = Encode::decode($encoding, "$file", Encode::FB_CROAK) };
+            if ($decoded) {
+                $decoded = Unicode::Normalize::NFKC($decoded) if $NORMALIZE;
+                $msg =~ s/$file/$decoded/g;
+            }
+        }
+    }
+
+    $msg = "# $msg" unless $msg =~ m/^\n/;
+    $msg =~ s/\n/\n# /g;
+    return "$msg\n";
+}
+
+sub linked {
+    my $self = shift;
+
+    if (@_) {
+        ($self->{linked}) = @_;
+        Scalar::Util::weaken($self->{linked}) if defined $self->{linked};
+    }
+
+    return $self->{linked};
+}
+
+1;
+
+__END__
+
+=head1 NAME
+
+Test::Builder::Result::Diag - Diag result type
+
+=head1 DESCRIPTION
+
+The diag result type.
+
+=head1 METHODS
+
+See L<Test::Builder::Result> which is the base class for this module.
+
+=head2 CONSTRUCTORS
+
+=over 4
+
+=item $r = $class->new(...)
+
+Create a new instance
+
+=back
+
+=head2 SIMPLE READ/WRITE ACCESSORS
+
+=over 4
+
+=item $r->message
+
+The message in the note.
+
+=item $r->trace
+
+Get the test trace info, including where to report errors.
+
+=item $r->pid
+
+PID in which the result was created.
+
+=item $r->depth
+
+Builder depth of the result (0 for normal, 1 for subtest, 2 for nested, etc).
+
+=item $r->in_todo
+
+True if the result was generated inside a todo.
+
+=item $r->source
+
+Builder that created the result, usually $0, but the name of a subtest when
+inside a subtest.
+
+=item $r->constructed
+
+Package, File, and Line in which the result was built.
+
+=item $r->linked
+
+If this diag is linked to a specific L<Test::Builder::Result::Ok> object, this
+will be set to the object. Note this is automatically turned into a weak
+reference as it is assumed that the Ok will also link to this object. This is
+to avoid cycled and memory leaks.
+
+=back
+
+=head2 INFORMATION
+
+=over 4
+
+=item $r->to_tap
+
+Returns the TAP string for the plan (not indented).
+
+=item $r->type
+
+Type of result. Usually this is the lowercased name from the end of the
+package. L<Test::Builder::Result::Ok> = 'ok'.
+
+=item $r->indent
+
+Returns the indentation that should be used to display the result ('    ' x
+depth).
+
+=back
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 SOURCE
+
+The source code repository for Test::More can be found at
+F<http://github.com/Test-More/test-more/>.
+
+=head1 COPYRIGHT
+
+Copyright 2014 Chad Granum E<lt>exodist7@gmail.comE<gt>.
+
+This program is free software; you can redistribute it and/or
+modify it under the same terms as Perl itself.
+
+See F<http://www.perl.com/perl/misc/Artistic.html>
diff --git a/cpan/Test-Simple/lib/Test/Builder/Result/Finish.pm b/cpan/Test-Simple/lib/Test/Builder/Result/Finish.pm
new file mode 100644 (file)
index 0000000..9dd7532
--- /dev/null
@@ -0,0 +1,111 @@
+package Test::Builder::Result::Finish;
+use strict;
+use warnings;
+
+use base 'Test::Builder::Result';
+
+use Test::Builder::Util qw/accessors/;
+accessors qw/tests_run tests_failed/;
+
+1;
+
+__END__
+
+=head1 NAME
+
+Test::Builder::Result::Finish - The finish result type
+
+=head1 DESCRIPTION
+
+Sent after testing is finished.
+
+=head1 METHODS
+
+See L<Test::Builder::Result> which is the base class for this module.
+
+=head2 CONSTRUCTORS
+
+=over 4
+
+=item $r = $class->new(...)
+
+Create a new instance
+
+=back
+
+=head2 SIMPLE READ/WRITE ACCESSORS
+
+=over 4
+
+=item $r->tests_run
+
+How many tests were run.
+
+=item $r->tests_failed
+
+How many tests failed.
+
+=item $r->trace
+
+Get the test trace info, including where to report errors.
+
+=item $r->pid
+
+PID in which the result was created.
+
+=item $r->depth
+
+Builder depth of the result (0 for normal, 1 for subtest, 2 for nested, etc).
+
+=item $r->in_todo
+
+True if the result was generated inside a todo.
+
+=item $r->source
+
+Builder that created the result, usually $0, but the name of a subtest when
+inside a subtest.
+
+=item $r->constructed
+
+Package, File, and Line in which the result was built.
+
+=back
+
+=head2 INFORMATION
+
+=over 4
+
+=item $r->type
+
+Type of result. Usually this is the lowercased name from the end of the
+package. L<Test::Builder::Result::Ok> = 'ok'.
+
+=item $r->indent
+
+Returns the indentation that should be used to display the result ('    ' x
+depth).
+
+=back
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 SOURCE
+
+The source code repository for Test::More can be found at
+F<http://github.com/Test-More/test-more/>.
+
+=head1 COPYRIGHT
+
+Copyright 2014 Chad Granum E<lt>exodist7@gmail.comE<gt>.
+
+This program is free software; you can redistribute it and/or
+modify it under the same terms as Perl itself.
+
+See F<http://www.perl.com/perl/misc/Artistic.html>
diff --git a/cpan/Test-Simple/lib/Test/Builder/Result/Note.pm b/cpan/Test-Simple/lib/Test/Builder/Result/Note.pm
new file mode 100644 (file)
index 0000000..ff6dd8e
--- /dev/null
@@ -0,0 +1,120 @@
+package Test::Builder::Result::Note;
+use strict;
+use warnings;
+
+use base 'Test::Builder::Result';
+
+use Test::Builder::Util qw/accessors/;
+accessors qw/message/;
+
+sub to_tap {
+    my $self = shift;
+
+    chomp(my $msg = $self->message);
+    $msg = "# $msg" unless $msg =~ m/^\n/;
+    $msg =~ s/\n/\n# /g;
+    return "$msg\n";
+}
+
+1;
+
+__END__
+
+=head1 NAME
+
+Test::Builder::Result::Note - Note result type
+
+=head1 DESCRIPTION
+
+Notes in tests
+
+=head1 METHODS
+
+See L<Test::Builder::Result> which is the base class for this module.
+
+=head2 CONSTRUCTORS
+
+=over 4
+
+=item $r = $class->new(...)
+
+Create a new instance
+
+=back
+
+=head2 SIMPLE READ/WRITE ACCESSORS
+
+=over 4
+
+=item $r->message
+
+The message in the note.
+
+=item $r->trace
+
+Get the test trace info, including where to report errors.
+
+=item $r->pid
+
+PID in which the result was created.
+
+=item $r->depth
+
+Builder depth of the result (0 for normal, 1 for subtest, 2 for nested, etc).
+
+=item $r->in_todo
+
+True if the result was generated inside a todo.
+
+=item $r->source
+
+Builder that created the result, usually $0, but the name of a subtest when
+inside a subtest.
+
+=item $r->constructed
+
+Package, File, and Line in which the result was built.
+
+=back
+
+=head2 INFORMATION
+
+=over 4
+
+=item $r->to_tap
+
+Returns the TAP string for the plan (not indented).
+
+=item $r->type
+
+Type of result. Usually this is the lowercased name from the end of the
+package. L<Test::Builder::Result::Ok> = 'ok'.
+
+=item $r->indent
+
+Returns the indentation that should be used to display the result ('    ' x
+depth).
+
+=back
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 SOURCE
+
+The source code repository for Test::More can be found at
+F<http://github.com/Test-More/test-more/>.
+
+=head1 COPYRIGHT
+
+Copyright 2014 Chad Granum E<lt>exodist7@gmail.comE<gt>.
+
+This program is free software; you can redistribute it and/or
+modify it under the same terms as Perl itself.
+
+See F<http://www.perl.com/perl/misc/Artistic.html>
diff --git a/cpan/Test-Simple/lib/Test/Builder/Result/Ok.pm b/cpan/Test-Simple/lib/Test/Builder/Result/Ok.pm
new file mode 100644 (file)
index 0000000..ac22149
--- /dev/null
@@ -0,0 +1,268 @@
+package Test::Builder::Result::Ok;
+use strict;
+use warnings;
+
+use base 'Test::Builder::Result';
+
+use Carp qw/confess/;
+use Scalar::Util qw/blessed reftype/;
+use Test::Builder::Util qw/accessors/;
+
+accessors qw/bool real_bool name todo skip/;
+
+sub init_order {
+    my $self = shift;
+    my @attrs = @_;
+
+    my @out;
+    my $diag;
+    for my $i (@attrs) {
+        if ($i eq 'diag') {
+            $diag++;
+            next;
+        }
+
+        push @out => $i;
+    }
+
+    push @out => 'diag' if $diag;
+
+    return @out;
+}
+
+sub pre_init {
+    my $self = shift;
+    my ($params) = @_;
+
+    return if $params->{real_bool} || ($params->{skip} && $params->{todo});
+
+    my $msg    = $params->{in_todo}   ? "Failed (TODO)" : "Failed";
+    my $prefix = $ENV{HARNESS_ACTIVE} ? "\n"            : "";
+
+    my ($pkg, $file, $line) = $params->{trace}->report->call;
+
+    if (defined $params->{name}) {
+        my $name = $params->{name};
+        $msg = qq[$prefix  $msg test '$name'\n  at $file line $line.\n];
+    }
+    else {
+        $msg = qq[$prefix  $msg test at $file line $line.\n];
+    }
+
+    $params->{diag} ||= [];
+    unshift @{$params->{diag}} => $msg;
+}
+
+sub to_tap {
+    my $self = shift;
+    my ($num) = @_;
+
+    my $out = "";
+    $out .= "not " unless $self->real_bool;
+    $out .= "ok";
+    $out .= " $num" if defined $num;
+
+    if (defined $self->name) {
+        my $name = $self->name;
+        $name =~ s|#|\\#|g;    # # in a name can confuse Test::Harness.
+        $out .= " - " . $name;
+    }
+
+    if (defined $self->skip && defined $self->todo) {
+        my $why = $self->skip;
+
+        unless ($why eq $self->todo) {
+            require Data::Dumper;
+            confess "2 different reasons to skip/todo: " . Data::Dumper::Dumper($self);
+        }
+
+        $out .= " # TODO & SKIP $why";
+    }
+    elsif (defined $self->skip) {
+        $out .= " # skip";
+        $out .= " " . $self->skip if length $self->skip;
+    }
+    elsif($self->in_todo) {
+        $out .= " # TODO " . $self->todo if $self->in_todo;
+    }
+
+    $out =~ s/\n/\n# /g;
+
+    $out .= "\n";
+
+    return $out;
+}
+
+sub clear_diag {
+    my $self = shift;
+    my @out = @{delete $self->{diag} || []};
+    $_->linked(undef) for @out;
+    return @out;
+}
+
+sub diag {
+    my $self = shift;
+
+    for my $i (@_) {
+        next unless $i;
+        my $type = reftype $i || "";
+
+        my $array = $type eq 'ARRAY' ? $i : [$i];
+        for my $d (@$array) {
+            if (ref $d) {
+                confess "Only Diag objects can be linked to results."
+                    unless blessed($d) && $d->isa('Test::Builder::Result::Diag');
+
+                confess "Diag argument '$d' is already linked to a result."
+                    if $d->linked;
+            }
+            else {
+                $d = Test::Builder::Result::Diag->new( message => $d );
+            }
+
+            for (qw/trace pid depth in_todo source/) {
+                $d->$_($self->$_) unless $d->$_;
+            }
+
+            $d->linked($self);
+            push @{$self->{diag}} => $d;
+        }
+    }
+
+    return $self->{diag};
+}
+
+1;
+
+__END__
+
+=head1 NAME
+
+Test::Builder::Result::Ok - Ok result type
+
+=head1 DESCRIPTION
+
+The ok result type.
+
+=head1 METHODS
+
+See L<Test::Builder::Result> which is the base class for this module.
+
+=head2 CONSTRUCTORS
+
+=over 4
+
+=item $r = $class->new(...)
+
+Create a new instance
+
+=back
+
+=head2 SIMPLE READ/WRITE ACCESSORS
+
+=over 4
+
+=item $r->bool
+
+True if the test passed, or if we are in a todo/skip
+
+=item $r->real_bool
+
+True if the test passed, false otherwise, even in todo.
+
+=item $r->name
+
+Name of the test.
+
+=item $r->todo
+
+Reason for todo (may be empty, even in a todo, check in_todo().
+
+=item $r->skip
+
+Reason for skip
+
+=item $r->trace
+
+Get the test trace info, including where to report errors.
+
+=item $r->pid
+
+PID in which the result was created.
+
+=item $r->depth
+
+Builder depth of the result (0 for normal, 1 for subtest, 2 for nested, etc).
+
+=item $r->in_todo
+
+True if the result was generated inside a todo.
+
+=item $r->source
+
+Builder that created the result, usually $0, but the name of a subtest when
+inside a subtest.
+
+=item $r->constructed
+
+Package, File, and Line in which the result was built.
+
+=item $r->diag
+
+Either undef, or an arrayref of L<Test::Builder::Result::Diag> objects. These
+objects will be linked to this Ok result. Calling C<< $diag->linked >> on them
+will return this Ok object. References here are strong references, references
+to this object from the linked Diag objects are weakened to avoid cycles.
+
+You can push diag objects into the arrayref by using them as arguments to this
+method. Objects will be validated to ensure that they are Diag objects, and not
+already linked to a result. As well C<linked> will be set on them.
+
+=item $r->clear_diag
+
+Remove all linked Diag objects, also removes the link within the Diags. Returns
+a list of the objects.
+
+=back
+
+=head2 INFORMATION
+
+=over 4
+
+=item $r->to_tap
+
+Returns the TAP string for the plan (not indented).
+
+=item $r->type
+
+Type of result. Usually this is the lowercased name from the end of the
+package. L<Test::Builder::Result::Ok> = 'ok'.
+
+=item $r->indent
+
+Returns the indentation that should be used to display the result ('    ' x
+depth).
+
+=back
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 SOURCE
+
+The source code repository for Test::More can be found at
+F<http://github.com/Test-More/test-more/>.
+
+=head1 COPYRIGHT
+
+Copyright 2014 Chad Granum E<lt>exodist7@gmail.comE<gt>.
+
+This program is free software; you can redistribute it and/or
+modify it under the same terms as Perl itself.
+
+See F<http://www.perl.com/perl/misc/Artistic.html>
diff --git a/cpan/Test-Simple/lib/Test/Builder/Result/Plan.pm b/cpan/Test-Simple/lib/Test/Builder/Result/Plan.pm
new file mode 100644 (file)
index 0000000..63f0acd
--- /dev/null
@@ -0,0 +1,135 @@
+package Test::Builder::Result::Plan;
+use strict;
+use warnings;
+
+use base 'Test::Builder::Result';
+
+use Test::Builder::Util qw/accessors/;
+accessors qw/max directive reason/;
+
+sub to_tap {
+    my $self = shift;
+
+    my $max       = $self->max;
+    my $directive = $self->directive;
+    my $reason    = $self->reason;
+
+    return if $directive && $directive eq 'NO_PLAN';
+
+    my $plan = "1..$max";
+    $plan .= " # $directive" if defined $directive;
+    $plan .= " $reason"      if defined $reason;
+
+    return "$plan\n";
+}
+
+1;
+
+__END__
+
+=head1 NAME
+
+Test::Builder::Result::Plan - The result of a plan
+
+=head1 DESCRIPTION
+
+The plan result object.
+
+=head1 METHODS
+
+See L<Test::Builder::Result> which is the base class for this module.
+
+=head2 CONSTRUCTORS
+
+=over 4
+
+=item $r = $class->new(...)
+
+Create a new instance
+
+=back
+
+=head2 SIMPLE READ/WRITE ACCESSORS
+
+=over 4
+
+=item $r->max
+
+When the plan is specified as a number of tests, this is set to that number.
+
+=item $r->directive
+
+This will be set to 'skip_all' or 'no_plan' in some cases.
+
+=item $r->reason
+
+If there is a directive, this gives details.
+
+=item $r->trace
+
+Get the test trace info, including where to report errors.
+
+=item $r->pid
+
+PID in which the result was created.
+
+=item $r->depth
+
+Builder depth of the result (0 for normal, 1 for subtest, 2 for nested, etc).
+
+=item $r->in_todo
+
+True if the result was generated inside a todo.
+
+=item $r->source
+
+Builder that created the result, usually $0, but the name of a subtest when
+inside a subtest.
+
+=item $r->constructed
+
+Package, File, and Line in which the result was built.
+
+=back
+
+=head2 INFORMATION
+
+=over 4
+
+=item $r->to_tap
+
+Returns the TAP string for the plan (not indented).
+
+=item $r->type
+
+Type of result. Usually this is the lowercased name from the end of the
+package. L<Test::Builder::Result::Ok> = 'ok'.
+
+=item $r->indent
+
+Returns the indentation that should be used to display the result ('    ' x
+depth).
+
+=back
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 SOURCE
+
+The source code repository for Test::More can be found at
+F<http://github.com/Test-More/test-more/>.
+
+=head1 COPYRIGHT
+
+Copyright 2014 Chad Granum E<lt>exodist7@gmail.comE<gt>.
+
+This program is free software; you can redistribute it and/or
+modify it under the same terms as Perl itself.
+
+See F<http://www.perl.com/perl/misc/Artistic.html>
diff --git a/cpan/Test-Simple/lib/Test/Builder/Stream.pm b/cpan/Test-Simple/lib/Test/Builder/Stream.pm
new file mode 100644 (file)
index 0000000..d7e0720
--- /dev/null
@@ -0,0 +1,684 @@
+package Test::Builder::Stream;
+use strict;
+use warnings;
+
+use Carp qw/confess croak/;
+use Scalar::Util qw/reftype blessed/;
+use Test::Builder::Threads;
+use Test::Builder::Util qw/accessors accessor atomic_deltas try protect/;
+
+accessors qw/plan bailed_out/;
+atomic_deltas qw/tests_run tests_failed/;
+
+accessor no_ending    => sub { 0 };
+accessor is_passing   => sub { 1 };
+accessor _listeners   => sub {{ }};
+accessor _mungers     => sub {{ }};
+accessor _munge_order => sub {[ ]};
+accessor _follow_up   => sub {{ }};
+
+sub pid { shift->{pid} }
+
+{
+    my ($root, @shared);
+
+    sub root { $root };
+
+    sub shared {
+        $root ||= __PACKAGE__->new;
+        push @shared => $root unless @shared;
+        return $shared[-1];
+    };
+
+    sub clear { $root = undef; @shared = () }
+
+    sub intercept {
+        my $class = shift;
+        my ($code) = @_;
+
+        confess "argument to intercept must be a coderef, got: $code"
+            unless reftype $code eq 'CODE';
+
+        my $orig = $class->intercept_start();
+        my ($ok, $error) = try { $code->($shared[-1]) };
+
+        $class->intercept_stop($orig);
+        die $error unless $ok;
+        return $ok;
+    }
+
+    sub intercept_start {
+        my $class = shift;
+        my $new = $_[0] || $class->new(no_follow => 1) || die "Internal error!";
+        push @shared => $new;
+        return $new;
+    }
+
+    sub intercept_stop {
+        my $class = shift;
+        my ($orig) = @_;
+        confess "intercept nesting inconsistancy!"
+            unless $shared[-1] == $orig;
+        return pop @shared;
+    }
+}
+
+sub new {
+    my $class = shift;
+    my %params = @_;
+    my $self = bless { pid => $$ }, $class;
+
+    share($self->{tests_run});
+    share($self->{tests_failed});
+
+    $self->use_tap         if $params{use_tap};
+    $self->use_lresults    if $params{use_lresults};
+    $self->legacy_followup unless $params{no_follow};
+
+    return $self;
+}
+
+sub follow_up {
+    my $self = shift;
+    my ($type, @action) = @_;
+    croak "'$type' is not a result type"
+        unless $type && $type->isa('Test::Builder::Result');
+
+    if (@action) {
+        my ($sub) = @action;
+        croak "The second argument to follow_up() must be a coderef, got: $sub"
+            if $sub && !(ref $sub && reftype $sub eq 'CODE');
+
+        $self->_follow_up->{$type} = $sub;
+    }
+
+    return $self->_follow_up->{$type};
+}
+
+sub legacy_followup {
+    my $self = shift;
+    $self->_follow_up({
+        'Test::Builder::Result::Bail' => sub { exit 255 },
+        'Test::Builder::Result::Plan' => sub {
+            my ($plan) = @_;
+            return unless $plan->directive;
+            return unless $plan->directive eq 'SKIP';
+            exit 0;
+        },
+    });
+}
+
+sub exception_followup {
+    my $self = shift;
+
+    $self->_follow_up({
+        'Test::Builder::Result::Bail' => sub {die $_[0]},
+        'Test::Builder::Result::Plan' => sub {
+            my $plan = shift;
+            return unless $plan->directive;
+            return unless $plan->directive eq 'SKIP';
+            die $plan;
+        },
+    });
+}
+
+sub expected_tests {
+    my $self = shift;
+    my $plan = $self->plan;
+    return undef unless $plan;
+    return $plan->max;
+}
+
+sub listener {
+    my $self = shift;
+    my ($id) = @_;
+    confess("You must provide an ID for your listener") unless $id;
+
+    confess("Listener ID's may not start with 'LEGACY_', those are reserved")
+        if $id =~ m/^LEGACY_/ && caller ne __PACKAGE__;
+
+    return $self->_listeners->{$id};
+}
+
+sub listen {
+    my $self = shift;
+    my ($id, $listener) = @_;
+
+    confess("You must provide an ID for your listener") unless $id;
+
+    confess("Listener ID's may not start with 'LEGACY_', those are reserved")
+        if $id =~ m/^LEGACY_/ && caller ne __PACKAGE__;
+
+    confess("Listeners must be code refs, or objects that implement handle(), got: $listener")
+        unless $listener && (
+            (reftype $listener && reftype $listener eq 'CODE')
+            ||
+            (blessed $listener && $listener->can('handle'))
+        );
+
+    my $listeners = $self->_listeners;
+
+    confess("There is already a listener with ID: $id")
+        if $listeners->{$id};
+
+    $listeners->{$id} = $listener;
+    return sub { $self->unlisten($id) };
+}
+
+sub unlisten {
+    my $self = shift;
+    my ($id) = @_;
+
+    confess("You must provide an ID for your listener") unless $id;
+
+    confess("Listener ID's may not start with 'LEGACY_', those are reserved")
+        if $id =~ m/^LEGACY_/ && caller ne __PACKAGE__;
+
+    my $listeners = $self->_listeners;
+
+    confess("There is no listener with ID: $id")
+        unless $listeners->{$id};
+
+    delete $listeners->{$id};
+}
+
+sub munger {
+    my $self = shift;
+    my ($id) = @_;
+    confess("You must provide an ID for your munger") unless $id;
+    return $self->_mungers->{$id};
+}
+
+sub munge {
+    my $self = shift;
+    my ($id, $munger) = @_;
+
+    confess("You must provide an ID for your munger") unless $id;
+
+    confess("Mungers must be code refs, or objects that implement handle(), got: $munger")
+        unless $munger && (
+            (reftype $munger && reftype $munger eq 'CODE')
+            ||
+            (blessed $munger && $munger->can('handle'))
+        );
+
+    my $mungers = $self->_mungers;
+
+    confess("There is already a munger with ID: $id")
+        if $mungers->{$id};
+
+    push @{$self->_munge_order} => $id;
+    $mungers->{$id} = $munger;
+
+    return sub { $self->unmunge($id) };
+}
+
+sub unmunge {
+    my $self = shift;
+    my ($id) = @_;
+    my $mungers = $self->_mungers;
+
+    confess("You must provide an ID for your munger") unless $id;
+
+    confess("There is no munger with ID: $id")
+        unless $mungers->{$id};
+
+    $self->_munge_order([ grep { $_ ne $id } @{$self->_munge_order} ]);
+    delete $mungers->{$id};
+}
+
+sub send {
+    my $self = shift;
+    my ($item) = @_;
+
+    # The redirect will return true if it intends to redirect, we should then return.
+    # If it returns false that means we do not need to redirect and should act normally.
+    if (my $redirect = $self->fork) {
+        return if $redirect->handle(@_);
+    }
+
+    my $items = [$item];
+    for my $munger_id (@{$self->_munge_order}) {
+        my $new_items = [];
+        my $munger = $self->munger($munger_id) || next;
+
+        for my $item (@$items) {
+            push @$new_items => reftype $munger eq 'CODE' ? $munger->($item) : $munger->handle($item);
+        }
+
+        $items = $new_items;
+    }
+
+    for my $item (@$items) {
+        if ($item->isa('Test::Builder::Result::Plan')) {
+            $self->plan($item);
+        }
+
+        if ($item->isa('Test::Builder::Result::Bail')) {
+            $self->bailed_out($item);
+        }
+
+        if ($item->isa('Test::Builder::Result::Ok')) {
+            $self->tests_run(1);
+            $self->tests_failed(1) unless $item->bool;
+        }
+
+        for my $listener (values %{$self->_listeners}) {
+            protect {
+                if (reftype $listener eq 'CODE') {
+                    $listener->($item);
+                    if ($item->can('diag') && $item->diag) {
+                        $listener->($_) for grep {$_} @{$item->diag};
+                    }
+                }
+                else {
+                    $listener->handle($item);
+                    if ($item->can('diag') && $item->diag) {
+                        $listener->handle($_) for grep {$_} @{$item->diag};
+                    }
+                }
+            };
+        }
+    }
+
+    for my $item (@$items) {
+        my $type = blessed $item;
+        my $follow = $self->follow_up($type) || next;
+        $follow->($item);
+    }
+}
+
+sub tap { shift->listener('LEGACY_TAP') }
+
+sub use_tap {
+    my $self = shift;
+    return if $self->tap;
+    require Test::Builder::Formatter::TAP;
+    $self->listen(LEGACY_TAP => Test::Builder::Formatter::TAP->new());
+}
+
+sub no_tap {
+    my $self = shift;
+    $self->unlisten('LEGACY_TAP') if $self->tap;
+    return;
+}
+
+sub lresults { shift->listener('LEGACY_RESULTS') }
+
+sub use_lresults {
+    my $self = shift;
+    return if $self->lresults;
+    require Test::Builder::Formatter::LegacyResults;
+    $self->listen(LEGACY_RESULTS => Test::Builder::Formatter::LegacyResults->new());
+}
+
+sub no_lresults {
+    my $self = shift;
+    $self->unlisten('LEGACY_RESULTS') if $self->lresults;
+    return;
+}
+
+sub fork { shift->{'fork'} }
+
+sub use_fork {
+    my $self = shift;
+
+    return if $self->{fork};
+
+    require Test::Builder::Fork;
+    $self->{fork} = Test::Builder::Fork->new;
+}
+
+sub no_fork {
+    my $self = shift;
+
+    return unless $self->{fork};
+
+    delete $self->{fork}; # Turn it off.
+}
+
+sub spawn {
+    my $self = shift;
+    my (%params) = @_;
+
+    my $new = blessed($self)->new();
+
+    $new->{fork} = $self->{fork};
+
+    my $refs = {
+        listeners => $self->_listeners,
+        mungers   => $self->_mungers,
+    };
+
+    $new->_munge_order([@{$self->_munge_order}]);
+
+    for my $type (keys %$refs) {
+        for my $key (keys %{$refs->{$type}}) {
+            next if $key eq 'LEGACY_TAP';
+            next if $key eq 'LEGACY_RESULTS';
+            $new->{"_$type"}->{$key} = sub {
+                my $item = $refs->{$type}->{$key} || return;
+                return $item->(@_) if reftype $item eq 'CODE';
+                $item->handle(@_);
+            };
+        }
+    }
+
+    if ($self->tap && !$params{no_tap}) {
+        $new->use_tap;
+        $new->tap->io_sets({%{$self->tap->io_sets}});
+    }
+
+    $new->use_lresults if $self->lresults && !$params{no_lresults};
+
+    return $new;
+}
+
+1;
+
+__END__
+
+=head1 NAME
+
+Test::Bulder::Stream - The stream between Test::Builder and the formatters.
+
+=head1 TEST COMPONENT MAP
+
+  [Test Script] > [Test Tool] > [Test::Builder] > [Test::Bulder::Stream] > [Result Formatter]
+                                                             ^
+                                                       You are here
+
+A test script uses a test tool such as L<Test::More>, which uses Test::Builder
+to produce results. The results are sent to L<Test::Builder::Stream> which then
+forwards them on to one or more formatters. The default formatter is
+L<Test::Builder::Fromatter::TAP> which produces TAP output.
+
+=head1 DESCRIPTION
+
+This module is responsible for taking result object from L<Test::Builder> and
+forwarding them to the listeners/formatters. It also has facilities for
+intercepting the results and munging them. Examples of this are forking support
+and L<Test::Tester2>.
+
+=head1 METHODS
+
+=head2 CONSTRUCTION/FETCHING
+
+It is possible to construct an independant stream object using C<new()>. Most
+of the time however you do not want an independant stream, you want the shared
+stream. The shared stream is the stream to which all test output should be
+sent. The shared stream is actually a stack, and the topmost stream should
+always be used unless you I<really> know what you are doing.
+
+=over 4
+
+=item $stream = $class->new();
+
+=item $stream = $class->new(use_tap => 1);
+
+=item $stream = $class->new(use_lresults => 1);
+
+=item $stream = $class->new(no_follow => 1);
+
+Create a new/independant stream object. No listeners by default, but you can
+specify 'use_tap' and/or 'use_lresults' to add those listeners.
+
+no_follow will disable the legacy behavior of exiting on bailout, or when a
+skip_all plan is encountered.
+
+=item $stream = $class->shared()
+
+Get the topmost stream on the shared stream stack.
+
+=item $stream = $class->root()
+
+Get the bottom-most stream in the shared stack.
+
+=item $class->clear()
+
+Remove all streams from the shared stack.
+
+=item $stream->intercept(sub { ... })
+
+Push a new stream onto the stack, run the specified code, then pop the new stream off of the stack.
+
+=item $stream->intercept_start()
+
+=item $stream->intercept_start($stream)
+
+Push a new stream onto the top of the shared stack. Returns the $stream that
+was pushed. Optionally you can provide a stream to push instead of letting it
+make a new one for you.
+
+=item $stream->intercept_stop($stream)
+
+Pop the topmost stream. You B<must> pass in the stream you expect to be popped.
+If the stream you pass in does not match the one popped an exception will be
+thrown.
+
+=item $child = $stream->spawn()
+
+=item $child = $stream->spawn(no_tap => 1)
+
+=item $child = $stream->spawn(no_lresults => 1)
+
+Spawn a cloned stream. The clone will have all the same listeners and mungers
+as the parent. Removing a listener from the parent will be reflected in the
+child, but the reverse is not true.
+
+TAP and legacy results are special, so they are also cloned instead of carrying
+them over. Removing them from the parent will not remove them from the child.
+
+=back
+
+=head2 ACCESSORS
+
+=over 4
+
+=item $plan = $stream->plan()
+
+=item $stream->plan($plan)
+
+=item $stream->plan(undef)
+
+Get/Set the plan, usually done for you when a plan object is encountered.
+
+=item $pid = $stream->pid()
+
+Get the original PID in which the stream object was built.
+
+=item $num = $stream->tests_run()
+
+=item $stream->tests_run($delta)
+
+Get the number of tests run. Optionally you can provide a delta, the number of
+tests run will be adjusted by the delta.
+
+=item $stream->tests_failed($delta)
+
+Get the number of tests failed. Optionally you can provide a delta, the number of
+tests failed will be adjusted by the delta.
+
+=item $bool = $stream->is_passing()
+
+=item $stream->is_padding($bool)
+
+Check if tests are passing, optinally you can pass in a $bool to reset this.
+
+=back
+
+=head2 BEHAVIOR CONTROL
+
+=over 4
+
+=item $bool = $stream->no_ending()
+
+=item $stream->no_ending($bool)
+
+enable/disable endings. Defaults to false.
+
+=item $action = $stream->follow_up('Test::Builder::Result::...')
+
+=item $stream->follow_up('Test::Builder::Result::...' => sub { ($r) = @_; ... })
+
+Fetch or Specify a followup behavior to run after all listeners have gotten a
+result of the specified type.
+
+=item $stream->legacy_followup
+
+switch to legacy follow-up behavior. This means exiting for bailout or skip_all.
+
+=item $stream->exception_followup
+
+Switch to exception follow-up behavior. This means throwing an exception on
+bailout or skip_all. This is necessary for intercepting results.
+
+=item $fork_handler = $stream->fork
+
+Get the fork handler.
+
+=item $stream->use_fork
+
+Enable forking
+
+=item $stream->no_fork
+
+Disable forking.
+
+=back
+
+=head2 PLANNING
+
+=over 4
+
+=item $count = $stream->expected_tests
+
+Get the expected number of tests, if any.
+
+=back
+
+=head2 LISTENER CONTROL
+
+=head3 NORMAL LISTENERS
+
+=over 4
+
+=item $L = $stream->listener($id)
+
+Get the listener with the given ID.
+
+=item $unlisten = $stream->listen($id, $listener)
+
+Add a listener with the given ID. The listener can either be a coderef that
+takes a result object as an argument, or any object that implements a handle()
+method.
+
+This method returns a coderef that can be used to remove the listener. It is
+better to use this method over unlisten as it will remove the listener from the
+original stream object and any child stream objects.
+
+=item $stream->unlisten($id)
+
+Remove a listener by id.
+
+=back
+
+=head3 LEGACY TAP LISTENER
+
+=over 4
+
+=item $L = $stream->tap
+
+Get the tap listener object (if TAP is enabled)
+
+=item $stream->use_tap
+
+Enable the legacy tap listener.
+
+=item $stream->no_tap
+
+Disable the legacy tap listener.
+
+=back
+
+=head3 LEGACY RESULTS LISTENER
+
+=over 4
+
+=item $L = $stream->lresults
+
+Get the Legacy Result lsitener object.
+
+=item $stream->use_lresults
+
+Enable legacy results
+
+=item $stream->no_lresults
+
+Disable legacy results
+
+=back
+
+=head2 MUNGING RESULTS
+
+Mungers are expected to take a result object and return 1 or more result
+objects to replace the original. They are also allowed to simply modify the
+original, or return nothing to remove it.
+
+Mungers are run in the order they are added, it is possible that the first
+munger will remove a result in which case later mungers will never see it.
+Listeners get the product of running all the mungers on the original results.
+
+=over 4
+
+=item $M = $stream->munger($id)
+
+Get the munger with the specified ID.
+
+=item $unmunge = $stream->munge($id => $munger)
+
+Add a munger. The munger may be a coderef that takes a single result object as
+an argument, or it can be any object that implements a handle() method.
+
+This method returns a coderef that can be used to remove the munger. It is
+better to use this method over unmunge as it will remove the munger from the
+original stream object and any child stream objects.
+
+=item $stream->unmunge($id)
+
+Remove a munger by id.
+
+=back
+
+=head2 PROVIDING RESULTS
+
+=over 4
+
+=item $stream->send($result)
+
+Send a result to all listeners (also goes through munging and the form handler,
+etc.)
+
+=back
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 SOURCE
+
+The source code repository for Test::More can be found at
+F<http://github.com/Test-More/test-more/>.
+
+=head1 COPYRIGHT
+
+Copyright 2014 Chad Granum E<lt>exodist7@gmail.comE<gt>.
+
+This program is free software; you can redistribute it and/or
+modify it under the same terms as Perl itself.
+
+See F<http://www.perl.com/perl/misc/Artistic.html>
index 5128be9..68dac50 100644 (file)
@@ -1,17 +1,23 @@
 package Test::Builder::Tester;
 
 use strict;
 package Test::Builder::Tester;
 
 use strict;
-our $VERSION = "1.23_003";
+our $VERSION = '1.301001_034';
+$VERSION = eval $VERSION;    ## no critic (BuiltinFunctions::ProhibitStringyEval)
 
 
-use Test::Builder 0.98;
+use Test::Builder 1.301001;
 use Symbol;
 use Carp;
 
 =head1 NAME
 
 use Symbol;
 use Carp;
 
 =head1 NAME
 
-Test::Builder::Tester - test testsuites that have been built with
+Test::Builder::Tester - *DEPRECATED* test testsuites that have been built with
 Test::Builder
 
 Test::Builder
 
+=head1 DEPRECATED
+
+B<This module is deprecated.> Please see L<Test::Tester2> for a
+better alternative that does not involve dealing with TAP/string output.
+
 =head1 SYNOPSIS
 
     use Test::Builder::Tester tests => 1;
 =head1 SYNOPSIS
 
     use Test::Builder::Tester tests => 1;
@@ -25,20 +31,20 @@ Test::Builder
 =head1 DESCRIPTION
 
 A module that helps you test testing modules that are built with
 =head1 DESCRIPTION
 
 A module that helps you test testing modules that are built with
-B<Test::Builder>.
+L<Test::Builder>.
 
 The testing system is designed to be used by performing a three step
 process for each test you wish to test.  This process starts with using
 C<test_out> and C<test_err> in advance to declare what the testsuite you
 
 The testing system is designed to be used by performing a three step
 process for each test you wish to test.  This process starts with using
 C<test_out> and C<test_err> in advance to declare what the testsuite you
-are testing will output with B<Test::Builder> to stdout and stderr.
+are testing will output with L<Test::Builder> to stdout and stderr.
 
 You then can run the test(s) from your test suite that call
 
 You then can run the test(s) from your test suite that call
-B<Test::Builder>.  At this point the output of B<Test::Builder> is
-safely captured by B<Test::Builder::Tester> rather than being
+L<Test::Builder>.  At this point the output of L<Test::Builder> is
+safely captured by L<Test::Builder::Tester> rather than being
 interpreted as real test output.
 
 The final stage is to call C<test_test> that will simply compare what you
 interpreted as real test output.
 
 The final stage is to call C<test_test> that will simply compare what you
-predeclared to what B<Test::Builder> actually outputted, and report the
+predeclared to what L<Test::Builder> actually outputted, and report the
 results back with a "ok" or "not ok" (with debugging) to the normal
 output.
 
 results back with a "ok" or "not ok" (with debugging) to the normal
 output.
 
@@ -48,35 +54,36 @@ output.
 # set up testing
 ####
 
 # set up testing
 ####
 
-my $t = Test::Builder->new;
+#my $t = Test::Builder->new;
 
 ###
 # make us an exporter
 ###
 
 
 ###
 # make us an exporter
 ###
 
-use Exporter;
-our @ISA = qw(Exporter);
+use Test::Builder::Provider;
 
 
-our @EXPORT = qw(test_out test_err test_fail test_diag test_test line_num);
+provides qw(test_out test_err test_fail test_diag test_test line_num);
 
 
-sub import {
+sub before_import {
     my $class = shift;
     my $class = shift;
-    my(@plan) = @_;
+    my ($args) = @_;
 
     my $caller = caller;
 
 
     my $caller = caller;
 
-    $t->exported_to($caller);
-    $t->plan(@plan);
+    warn __PACKAGE__ . " is deprecated!\n" if builder()->modern;
+
+    builder()->exported_to($caller);
+    builder()->plan(@$args);
 
     my @imports = ();
 
     my @imports = ();
-    foreach my $idx ( 0 .. $#plan ) {
-        if( $plan[$idx] eq 'import' ) {
-            @imports = @{ $plan[ $idx + 1 ] };
+    foreach my $idx ( 0 .. @$args ) {
+        if( $args->[$idx] && $args->[$idx] eq 'import' ) {
+            @imports = @{ $args->[ $idx + 1 ] };
             last;
         }
     }
 
             last;
         }
     }
 
-    __PACKAGE__->export_to_level( 1, __PACKAGE__, @imports );
+    @$args = @imports;
 }
 
 ###
 }
 
 ###
@@ -100,6 +107,8 @@ my $testing = 0;
 my $testing_num;
 my $original_is_passing;
 
 my $testing_num;
 my $original_is_passing;
 
+my $original_stream;
+
 # remembering where the file handles were originally connected
 my $original_output_handle;
 my $original_failure_handle;
 # remembering where the file handles were originally connected
 my $original_output_handle;
 my $original_failure_handle;
@@ -115,14 +124,14 @@ sub _start_testing {
     $ENV{HARNESS_ACTIVE} = 0;
 
     # remember what the handles were set to
     $ENV{HARNESS_ACTIVE} = 0;
 
     # remember what the handles were set to
-    $original_output_handle  = $t->output();
-    $original_failure_handle = $t->failure_output();
-    $original_todo_handle    = $t->todo_output();
+    $original_output_handle  = builder()->output();
+    $original_failure_handle = builder()->failure_output();
+    $original_todo_handle    = builder()->todo_output();
 
     # switch out to our own handles
 
     # switch out to our own handles
-    $t->output($output_handle);
-    $t->failure_output($error_handle);
-    $t->todo_output($output_handle);
+    builder()->output($output_handle);
+    builder()->failure_output($error_handle);
+    builder()->todo_output($output_handle);
 
     # clear the expected list
     $out->reset();
 
     # clear the expected list
     $out->reset();
@@ -130,13 +139,13 @@ sub _start_testing {
 
     # remember that we're testing
     $testing     = 1;
 
     # remember that we're testing
     $testing     = 1;
-    $testing_num = $t->current_test;
-    $t->current_test(0);
-    $original_is_passing  = $t->is_passing;
-    $t->is_passing(1);
+    $testing_num = builder()->current_test;
+    builder()->current_test(0);
+    $original_is_passing  = builder()->is_passing;
+    builder()->is_passing(1);
 
     # look, we shouldn't do the ending stuff
 
     # look, we shouldn't do the ending stuff
-    $t->no_ending(1);
+    builder()->no_ending(1);
 }
 
 =head2 Functions
 }
 
 =head2 Functions
@@ -165,8 +174,8 @@ which is even the same as
    test_out("ok 2");
 
 Once C<test_out> or C<test_err> (or C<test_fail> or C<test_diag>) have
    test_out("ok 2");
 
 Once C<test_out> or C<test_err> (or C<test_fail> or C<test_diag>) have
-been called, all further output from B<Test::Builder> will be
-captured by B<Test::Builder::Tester>.  This means that you will not
+been called, all further output from L<Test::Builder> will be
+captured by L<Test::Builder::Tester>.  This means that you will not
 be able perform further tests to the normal output in the normal way
 until you call C<test_test> (well, unless you manually meddle with the
 output filehandles)
 be able perform further tests to the normal output in the normal way
 until you call C<test_test> (well, unless you manually meddle with the
 output filehandles)
@@ -189,7 +198,7 @@ sub test_err {
 
 =item test_fail
 
 
 =item test_fail
 
-Because the standard failure message that B<Test::Builder> produces
+Because the standard failure message that L<Test::Builder> produces
 whenever a test fails will be a common occurrence in your test error
 output, and because it has changed between Test::Builder versions, rather
 than forcing you to call C<test_err> with the string all the time like
 whenever a test fails will be a common occurrence in your test error
 output, and because it has changed between Test::Builder versions, rather
 than forcing you to call C<test_err> with the string all the time like
@@ -228,7 +237,7 @@ sub test_fail {
 =item test_diag
 
 As most of the remaining expected output to the error stream will be
 =item test_diag
 
 As most of the remaining expected output to the error stream will be
-created by Test::Builder's C<diag> function, B<Test::Builder::Tester>
+created by L<Test::Builder>'s C<diag> function, L<Test::Builder::Tester>
 provides a convenience function C<test_diag> that you can use instead of
 C<test_err>.
 
 provides a convenience function C<test_diag> that you can use instead of
 C<test_err>.
 
@@ -242,7 +251,7 @@ you can write
 
    test_diag("Couldn't open file");
 
 
    test_diag("Couldn't open file");
 
-Remember that B<Test::Builder>'s diag function will not add newlines to
+Remember that L<Test::Builder>'s diag function will not add newlines to
 the end of output and test_diag will. So to check
 
    Test::Builder->new->diag("foo\n","bar\n");
 the end of output and test_diag will. So to check
 
    Test::Builder->new->diag("foo\n","bar\n");
@@ -261,13 +270,13 @@ sub test_diag {
 
     # expect the same thing, but prepended with "#     "
     local $_;
 
     # expect the same thing, but prepended with "#     "
     local $_;
-    $err->expect( map { "# $_" } @_ );
+    $err->expect( map { m/\S/ ? "# $_" : "" } @_ );
 }
 
 =item test_test
 
 Actually performs the output check testing the tests, comparing the
 }
 
 =item test_test
 
 Actually performs the output check testing the tests, comparing the
-data (with C<eq>) that we have captured from B<Test::Builder> against
+data (with C<eq>) that we have captured from L<Test::Builder> against
 what was declared with C<test_out> and C<test_err>.
 
 This takes name/value pairs that effect how the test is run.
 what was declared with C<test_out> and C<test_err>.
 
 This takes name/value pairs that effect how the test is run.
@@ -297,9 +306,9 @@ As a convenience, if only one argument is passed then this argument
 is assumed to be the name of the test (as in the above examples.)
 
 Once C<test_test> has been run test output will be redirected back to
 is assumed to be the name of the test (as in the above examples.)
 
 Once C<test_test> has been run test output will be redirected back to
-the original filehandles that B<Test::Builder> was connected to
+the original filehandles that L<Test::Builder> was connected to
 (probably STDOUT and STDERR,) meaning any further tests you run
 (probably STDOUT and STDERR,) meaning any further tests you run
-will function normally and cause success/errors for B<Test::Harness>.
+will function normally and cause success/errors for L<Test::Harness>.
 
 =cut
 
 
 =cut
 
@@ -322,21 +331,21 @@ sub test_test {
       unless $testing;
 
     # okay, reconnect the test suite back to the saved handles
       unless $testing;
 
     # okay, reconnect the test suite back to the saved handles
-    $t->output($original_output_handle);
-    $t->failure_output($original_failure_handle);
-    $t->todo_output($original_todo_handle);
+    builder()->output($original_output_handle);
+    builder()->failure_output($original_failure_handle);
+    builder()->todo_output($original_todo_handle);
 
     # restore the test no, etc, back to the original point
 
     # restore the test no, etc, back to the original point
-    $t->current_test($testing_num);
+    builder()->current_test($testing_num);
     $testing = 0;
     $testing = 0;
-    $t->is_passing($original_is_passing);
+    builder()->is_passing($original_is_passing);
 
     # re-enable the original setting of the harness
     $ENV{HARNESS_ACTIVE} = $original_harness_env;
 
     # check the output we've stashed
 
     # re-enable the original setting of the harness
     $ENV{HARNESS_ACTIVE} = $original_harness_env;
 
     # check the output we've stashed
-    unless( $t->ok( ( $args{skip_out} || $out->check ) &&
-                    ( $args{skip_err} || $err->check ), $mess ) 
+    unless( builder()->ok( ( $args{skip_out} || $out->check ) &&
+                    ( $args{skip_err} || $err->check ), $mess )
     )
     {
         # print out the diagnostic information about why this
     )
     {
         # print out the diagnostic information about why this
@@ -344,10 +353,10 @@ sub test_test {
 
         local $_;
 
 
         local $_;
 
-        $t->diag( map { "$_\n" } $out->complaint )
+        builder()->diag( map { "$_\n" } $out->complaint )
           unless $args{skip_out} || $out->check;
 
           unless $args{skip_out} || $out->check;
 
-        $t->diag( map { "$_\n" } $err->complaint )
+        builder()->diag( map { "$_\n" } $err->complaint )
           unless $args{skip_err} || $err->check;
     }
 }
           unless $args{skip_err} || $err->check;
     }
 }
@@ -400,11 +409,11 @@ respectively, and the function called with no argument will return the
 current setting.
 
 To enable colouring from the command line, you can use the
 current setting.
 
 To enable colouring from the command line, you can use the
-B<Text::Builder::Tester::Color> module like so:
+L<Text::Builder::Tester::Color> module like so:
 
    perl -Mlib=Text::Builder::Tester::Color test.t
 
 
    perl -Mlib=Text::Builder::Tester::Color test.t
 
-Or by including the B<Test::Builder::Tester::Color> module directly in
+Or by including the L<Test::Builder::Tester::Color> module directly in
 the PERL5LIB.
 
 =cut
 the PERL5LIB.
 
 =cut
@@ -420,12 +429,12 @@ sub color {
 
 =head1 BUGS
 
 
 =head1 BUGS
 
-Calls C<<Test::Builder->no_ending>> turning off the ending tests.
+Calls C<< Test::Builder->no_ending >> turning off the ending tests.
 This is needed as otherwise it will trip out because we've run more
 tests than we strictly should have and it'll register any failures we
 had that we were testing for as real failures.
 
 This is needed as otherwise it will trip out because we've run more
 tests than we strictly should have and it'll register any failures we
 had that we were testing for as real failures.
 
-The color function doesn't work unless B<Term::ANSIColor> is
+The color function doesn't work unless L<Term::ANSIColor> is
 compatible with your terminal.
 
 Bugs (and requests for new features) can be reported to the author
 compatible with your terminal.
 
 Bugs (and requests for new features) can be reported to the author
@@ -436,7 +445,7 @@ L<http://rt.cpan.org/NoAuth/ReportBug.html?Queue=Test-Builder-Tester>
 
 Copyright Mark Fowler E<lt>mark@twoshortplanks.comE<gt> 2002, 2004.
 
 
 Copyright Mark Fowler E<lt>mark@twoshortplanks.comE<gt> 2002, 2004.
 
-Some code taken from B<Test::More> and B<Test::Catch>, written by
+Some code taken from L<Test::More> and L<Test::Catch>, written by
 Michael G Schwern E<lt>schwern@pobox.comE<gt>.  Hence, those parts
 Copyright Micheal G Schwern 2001.  Used and distributed with
 permission.
 Michael G Schwern E<lt>schwern@pobox.comE<gt>.  Hence, those parts
 Copyright Micheal G Schwern 2001.  Used and distributed with
 permission.
@@ -487,8 +496,9 @@ sub expect {
 sub _account_for_subtest {
     my( $self, $check ) = @_;
 
 sub _account_for_subtest {
     my( $self, $check ) = @_;
 
+    my $builder = Test::Builder::Tester->builder();
     # Since we ship with Test::Builder, calling a private method is safe...ish.
     # Since we ship with Test::Builder, calling a private method is safe...ish.
-    return ref($check) ? $check : $t->_indent . $check;
+    return ref($check) ? $check : ($builder->depth ? '    ' x $builder->depth : '') . $check;
 }
 
 sub _translate_Failed_check {
 }
 
 sub _translate_Failed_check {
index b269a27..16f54db 100644 (file)
@@ -1,7 +1,8 @@
 package Test::Builder::Tester::Color;
 
 use strict;
 package Test::Builder::Tester::Color;
 
 use strict;
-our $VERSION = "1.23_002";
+our $VERSION = '1.301001_034';
+$VERSION = eval $VERSION;    ## no critic (BuiltinFunctions::ProhibitStringyEval)
 
 require Test::Builder::Tester;
 
 
 require Test::Builder::Tester;
 
diff --git a/cpan/Test-Simple/lib/Test/Builder/Threads.pm b/cpan/Test-Simple/lib/Test/Builder/Threads.pm
new file mode 100644 (file)
index 0000000..93206ed
--- /dev/null
@@ -0,0 +1,107 @@
+package Test::Builder::Threads;
+use strict;
+use warnings;
+
+# Make Test::Builder thread-safe for ithreads.
+BEGIN {
+    use Config;
+    # Load threads::shared when threads are turned on.
+    if( $Config{useithreads} && $INC{'threads.pm'} ) {
+        require threads::shared;
+
+        # Hack around YET ANOTHER threads::shared bug.  It would
+        # occasionally forget the contents of the variable when sharing it.
+        # So we first copy the data, then share, then put our copy back.
+        *share = sub (\[$@%]) {
+            my $type = ref $_[0];
+            my $data;
+
+            if( $type eq 'HASH' ) {
+                %$data = %{ $_[0] };
+            }
+            elsif( $type eq 'ARRAY' ) {
+                @$data = @{ $_[0] };
+            }
+            elsif( $type eq 'SCALAR' ) {
+                $$data = ${ $_[0] };
+            }
+            else {
+                die( "Unknown type: " . $type );
+            }
+
+            $_[0] = &threads::shared::share( $_[0] );
+
+            if( $type eq 'HASH' ) {
+            }
+            elsif( $type eq 'ARRAY' ) {
+                @{ $_[0] } = @$data;
+            }
+            elsif( $type eq 'SCALAR' ) {
+                ${ $_[0] } = $$data;
+            }
+            else {
+                die( "Unknown type: " . $type );
+            }
+
+            return $_[0];
+        };
+    }
+    else {
+        *share = sub { return $_[0] };
+        *lock  = sub { 0 };
+    }
+}
+
+sub import {
+    my $class = shift;
+    my $caller = caller;
+
+    no strict 'refs';
+    *{"$caller\::share"} = $class->can('share') if $class->can('share');
+    *{"$caller\::lock"}  = $class->can('lock')  if $class->can('lock');
+}
+
+1;
+
+__END__
+
+=head1 NAME
+
+Test::Builder::Threads - Helper Test::Builder uses when threaded.
+
+=head1 DESCRIPTION
+
+Helper Test::Builder uses when threaded.
+
+=head1 SYNOPSYS
+
+    use threads;
+    use Test::Builder::Threads;
+
+    share(...);
+    lock(...);
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 SOURCE
+
+The source code repository for Test::More can be found at
+F<http://github.com/Test-More/test-more/>.
+
+=head1 COPYRIGHT
+
+Copyright 2014 Chad Granum E<lt>exodist7@gmail.comE<gt>.
+
+Most of this code was pulled out ot L<Test::Builder>, written by Schwern and
+others.
+
+This program is free software; you can redistribute it and/or
+modify it under the same terms as Perl itself.
+
+See F<http://www.perl.com/perl/misc/Artistic.html>
diff --git a/cpan/Test-Simple/lib/Test/Builder/Trace.pm b/cpan/Test-Simple/lib/Test/Builder/Trace.pm
new file mode 100644 (file)
index 0000000..09b76c9
--- /dev/null
@@ -0,0 +1,277 @@
+package Test::Builder::Trace;
+use strict;
+use warnings;
+
+use Test::Builder::Util qw/accessor accessors is_tester try/;
+use Test::Builder::Trace::Frame;
+use List::Util qw/first/;
+
+accessor anointed    => sub { [] };
+accessor full        => sub { [] };
+accessor level       => sub { [] };
+accessor tools       => sub { [] };
+accessor transitions => sub { [] };
+accessor stack       => sub { [] };
+accessor todo        => sub { [] };
+
+accessors qw/_report parent/;
+
+my $LEVEL_WARNED = 0;
+
+sub nest {
+    my $class = shift;
+    my ($code, @args) = @_;
+    $code->(@args);
+}
+
+sub new {
+    my $class = shift;
+    my $self = bless {}, $class;
+
+    my $stack_level = 0;
+    my $seek_level = do { no warnings 'once'; $Test::Builder::Level - $Test::Builder::BLevel };
+    my $notb_level = 0;