From b8a2040150d386de90994afd87f9d01bd861104a Mon Sep 17 00:00:00 2001 From: Nicholas Clark Date: Fri, 2 Oct 2009 15:57:26 +0100 Subject: Move Test::Harness from ext/ to cpan/ --- cpan/Test-Harness/Changes | 682 ++++ cpan/Test-Harness/bin/prove | 305 ++ cpan/Test-Harness/lib/App/Prove.pm | 774 +++++ cpan/Test-Harness/lib/App/Prove/State.pm | 517 ++++ cpan/Test-Harness/lib/App/Prove/State/Result.pm | 233 ++ .../lib/App/Prove/State/Result/Test.pm | 153 + cpan/Test-Harness/lib/TAP/Base.pm | 129 + cpan/Test-Harness/lib/TAP/Formatter/Base.pm | 449 +++ cpan/Test-Harness/lib/TAP/Formatter/Color.pm | 148 + cpan/Test-Harness/lib/TAP/Formatter/Console.pm | 91 + .../lib/TAP/Formatter/Console/ParallelSession.pm | 202 ++ .../lib/TAP/Formatter/Console/Session.pm | 219 ++ cpan/Test-Harness/lib/TAP/Formatter/File.pm | 58 + .../Test-Harness/lib/TAP/Formatter/File/Session.pm | 110 + cpan/Test-Harness/lib/TAP/Formatter/Session.pm | 183 ++ cpan/Test-Harness/lib/TAP/Harness.pm | 830 +++++ cpan/Test-Harness/lib/TAP/Object.pm | 139 + cpan/Test-Harness/lib/TAP/Parser.pm | 1873 +++++++++++ cpan/Test-Harness/lib/TAP/Parser/Aggregator.pm | 416 +++ cpan/Test-Harness/lib/TAP/Parser/Grammar.pm | 580 ++++ cpan/Test-Harness/lib/TAP/Parser/Iterator.pm | 165 + cpan/Test-Harness/lib/TAP/Parser/Iterator/Array.pm | 106 + .../lib/TAP/Parser/Iterator/Process.pm | 377 +++ .../Test-Harness/lib/TAP/Parser/Iterator/Stream.pm | 112 + .../Test-Harness/lib/TAP/Parser/IteratorFactory.pm | 171 + cpan/Test-Harness/lib/TAP/Parser/Multiplexer.pm | 195 ++ cpan/Test-Harness/lib/TAP/Parser/Result.pm | 300 ++ cpan/Test-Harness/lib/TAP/Parser/Result/Bailout.pm | 63 + cpan/Test-Harness/lib/TAP/Parser/Result/Comment.pm | 61 + cpan/Test-Harness/lib/TAP/Parser/Result/Plan.pm | 120 + cpan/Test-Harness/lib/TAP/Parser/Result/Pragma.pm | 63 + cpan/Test-Harness/lib/TAP/Parser/Result/Test.pm | 274 ++ cpan/Test-Harness/lib/TAP/Parser/Result/Unknown.pm | 51 + cpan/Test-Harness/lib/TAP/Parser/Result/Version.pm | 63 + cpan/Test-Harness/lib/TAP/Parser/Result/YAML.pm | 62 + cpan/Test-Harness/lib/TAP/Parser/ResultFactory.pm | 189 ++ cpan/Test-Harness/lib/TAP/Parser/Scheduler.pm | 312 ++ cpan/Test-Harness/lib/TAP/Parser/Scheduler/Job.pm | 107 + .../lib/TAP/Parser/Scheduler/Spinner.pm | 53 + cpan/Test-Harness/lib/TAP/Parser/Source.pm | 173 ++ cpan/Test-Harness/lib/TAP/Parser/Source/Perl.pm | 326 ++ cpan/Test-Harness/lib/TAP/Parser/Utils.pm | 72 + cpan/Test-Harness/lib/TAP/Parser/YAMLish/Reader.pm | 333 ++ cpan/Test-Harness/lib/TAP/Parser/YAMLish/Writer.pm | 255 ++ cpan/Test-Harness/lib/Test/Harness.pm | 585 ++++ cpan/Test-Harness/t/000-load.t | 61 + cpan/Test-Harness/t/aggregator.t | 305 ++ cpan/Test-Harness/t/bailout.t | 114 + cpan/Test-Harness/t/base.t | 173 ++ cpan/Test-Harness/t/callbacks.t | 116 + cpan/Test-Harness/t/compat/env.t | 39 + cpan/Test-Harness/t/compat/failure.t | 56 + cpan/Test-Harness/t/compat/inc-propagation.t | 57 + cpan/Test-Harness/t/compat/inc_taint.t | 33 + cpan/Test-Harness/t/compat/nonumbers.t | 14 + cpan/Test-Harness/t/compat/regression.t | 19 + cpan/Test-Harness/t/compat/switches.t | 17 + cpan/Test-Harness/t/compat/test-harness-compat.t | 851 +++++ cpan/Test-Harness/t/compat/version.t | 11 + cpan/Test-Harness/t/console.t | 47 + cpan/Test-Harness/t/data/catme.1 | 2 + cpan/Test-Harness/t/data/proverc | 7 + cpan/Test-Harness/t/data/sample.yml | 29 + cpan/Test-Harness/t/errors.t | 183 ++ cpan/Test-Harness/t/file.t | 475 +++ cpan/Test-Harness/t/glob-to-regexp.t | 44 + cpan/Test-Harness/t/grammar.t | 455 +++ cpan/Test-Harness/t/harness-bailout.t | 54 + cpan/Test-Harness/t/harness-subclass.t | 65 + cpan/Test-Harness/t/harness.t | 982 ++++++ cpan/Test-Harness/t/iterators.t | 215 ++ cpan/Test-Harness/t/lib/App/Prove/Plugin/Dummy.pm | 9 + cpan/Test-Harness/t/lib/App/Prove/Plugin/Dummy2.pm | 13 + cpan/Test-Harness/t/lib/Dev/Null.pm | 18 + cpan/Test-Harness/t/lib/EmptyParser.pm | 30 + cpan/Test-Harness/t/lib/IO/c55Capture.pm | 120 + cpan/Test-Harness/t/lib/MyCustom.pm | 12 + cpan/Test-Harness/t/lib/MyGrammar.pm | 21 + cpan/Test-Harness/t/lib/MyIterator.pm | 26 + cpan/Test-Harness/t/lib/MyIteratorFactory.pm | 19 + cpan/Test-Harness/t/lib/MyPerlSource.pm | 27 + cpan/Test-Harness/t/lib/MyResult.pm | 21 + cpan/Test-Harness/t/lib/MyResultFactory.pm | 23 + cpan/Test-Harness/t/lib/MySource.pm | 34 + cpan/Test-Harness/t/lib/NOP.pm | 7 + cpan/Test-Harness/t/lib/NoFork.pm | 21 + cpan/Test-Harness/t/lib/TAP/Parser/SubclassTest.pm | 39 + cpan/Test-Harness/t/multiplexer.t | 170 + cpan/Test-Harness/t/nofork-mux.t | 10 + cpan/Test-Harness/t/nofork.t | 59 + cpan/Test-Harness/t/object.t | 37 + cpan/Test-Harness/t/parse.t | 1058 +++++++ cpan/Test-Harness/t/parser-config.t | 39 + cpan/Test-Harness/t/parser-subclass.t | 80 + cpan/Test-Harness/t/perl5lib.t | 51 + cpan/Test-Harness/t/premature-bailout.t | 125 + cpan/Test-Harness/t/process.t | 53 + cpan/Test-Harness/t/prove.t | 1525 +++++++++ cpan/Test-Harness/t/proveenv.t | 17 + cpan/Test-Harness/t/proverc.t | 23 + cpan/Test-Harness/t/proverc/emptyexec | 2 + cpan/Test-Harness/t/proverun.t | 176 ++ cpan/Test-Harness/t/regression.t | 3264 ++++++++++++++++++++ cpan/Test-Harness/t/results.t | 295 ++ cpan/Test-Harness/t/sample-tests/bailout | 11 + cpan/Test-Harness/t/sample-tests/bignum | 7 + cpan/Test-Harness/t/sample-tests/bignum_many | 14 + cpan/Test-Harness/t/sample-tests/combined | 13 + cpan/Test-Harness/t/sample-tests/combined_compat | 13 + cpan/Test-Harness/t/sample-tests/delayed | 26 + cpan/Test-Harness/t/sample-tests/descriptive | 8 + .../t/sample-tests/descriptive_trailing | 8 + cpan/Test-Harness/t/sample-tests/die | 2 + cpan/Test-Harness/t/sample-tests/die_head_end | 9 + cpan/Test-Harness/t/sample-tests/die_last_minute | 10 + cpan/Test-Harness/t/sample-tests/die_unfinished | 9 + cpan/Test-Harness/t/sample-tests/duplicates | 14 + cpan/Test-Harness/t/sample-tests/echo | 2 + cpan/Test-Harness/t/sample-tests/empty | 2 + cpan/Test-Harness/t/sample-tests/escape_eol | 5 + cpan/Test-Harness/t/sample-tests/escape_hash | 6 + cpan/Test-Harness/t/sample-tests/head_end | 11 + cpan/Test-Harness/t/sample-tests/head_fail | 11 + cpan/Test-Harness/t/sample-tests/inc_taint | 6 + cpan/Test-Harness/t/sample-tests/junk_before_plan | 6 + cpan/Test-Harness/t/sample-tests/lone_not_bug | 9 + cpan/Test-Harness/t/sample-tests/no_nums | 8 + cpan/Test-Harness/t/sample-tests/no_output | 3 + cpan/Test-Harness/t/sample-tests/out_err_mix | 13 + cpan/Test-Harness/t/sample-tests/out_of_order | 22 + cpan/Test-Harness/t/sample-tests/schwern | 3 + .../Test-Harness/t/sample-tests/schwern-todo-quiet | 13 + cpan/Test-Harness/t/sample-tests/segfault | 5 + cpan/Test-Harness/t/sample-tests/sequence_misparse | 14 + cpan/Test-Harness/t/sample-tests/shbang_misparse | 12 + cpan/Test-Harness/t/sample-tests/simple | 8 + cpan/Test-Harness/t/sample-tests/simple_fail | 8 + cpan/Test-Harness/t/sample-tests/simple_yaml | 27 + cpan/Test-Harness/t/sample-tests/skip | 8 + cpan/Test-Harness/t/sample-tests/skip_nomsg | 4 + cpan/Test-Harness/t/sample-tests/skipall | 3 + cpan/Test-Harness/t/sample-tests/skipall_nomsg | 2 + cpan/Test-Harness/t/sample-tests/skipall_v13 | 4 + cpan/Test-Harness/t/sample-tests/space_after_plan | 3 + cpan/Test-Harness/t/sample-tests/stdout_stderr | 9 + cpan/Test-Harness/t/sample-tests/strict | 9 + cpan/Test-Harness/t/sample-tests/switches | 2 + cpan/Test-Harness/t/sample-tests/taint | 7 + cpan/Test-Harness/t/sample-tests/taint_warn | 11 + cpan/Test-Harness/t/sample-tests/todo | 8 + cpan/Test-Harness/t/sample-tests/todo_inline | 6 + cpan/Test-Harness/t/sample-tests/todo_misparse | 5 + cpan/Test-Harness/t/sample-tests/too_many | 14 + cpan/Test-Harness/t/sample-tests/version_good | 9 + cpan/Test-Harness/t/sample-tests/version_late | 9 + cpan/Test-Harness/t/sample-tests/version_old | 9 + cpan/Test-Harness/t/sample-tests/vms_nit | 6 + cpan/Test-Harness/t/sample-tests/with_comments | 14 + cpan/Test-Harness/t/sample-tests/zero_valid | 8 + cpan/Test-Harness/t/scheduler.t | 225 ++ cpan/Test-Harness/t/source.t | 93 + cpan/Test-Harness/t/source_tests/harness | 6 + cpan/Test-Harness/t/source_tests/harness_badtap | 8 + cpan/Test-Harness/t/source_tests/harness_complain | 7 + .../Test-Harness/t/source_tests/harness_directives | 8 + cpan/Test-Harness/t/source_tests/harness_failure | 11 + cpan/Test-Harness/t/source_tests/source | 14 + cpan/Test-Harness/t/spool.t | 139 + cpan/Test-Harness/t/state.t | 251 ++ cpan/Test-Harness/t/state_results.t | 148 + cpan/Test-Harness/t/streams.t | 171 + cpan/Test-Harness/t/subclass_tests/non_perl_source | 3 + cpan/Test-Harness/t/subclass_tests/perl_source | 6 + cpan/Test-Harness/t/taint.t | 49 + cpan/Test-Harness/t/testargs.t | 128 + cpan/Test-Harness/t/unicode.t | 125 + cpan/Test-Harness/t/utils.t | 61 + cpan/Test-Harness/t/yamlish-output.t | 100 + cpan/Test-Harness/t/yamlish-writer.t | 274 ++ cpan/Test-Harness/t/yamlish.t | 529 ++++ 180 files changed, 27371 insertions(+) create mode 100644 cpan/Test-Harness/Changes create mode 100644 cpan/Test-Harness/bin/prove create mode 100644 cpan/Test-Harness/lib/App/Prove.pm create mode 100644 cpan/Test-Harness/lib/App/Prove/State.pm create mode 100644 cpan/Test-Harness/lib/App/Prove/State/Result.pm create mode 100644 cpan/Test-Harness/lib/App/Prove/State/Result/Test.pm create mode 100644 cpan/Test-Harness/lib/TAP/Base.pm create mode 100644 cpan/Test-Harness/lib/TAP/Formatter/Base.pm create mode 100644 cpan/Test-Harness/lib/TAP/Formatter/Color.pm create mode 100644 cpan/Test-Harness/lib/TAP/Formatter/Console.pm create mode 100644 cpan/Test-Harness/lib/TAP/Formatter/Console/ParallelSession.pm create mode 100644 cpan/Test-Harness/lib/TAP/Formatter/Console/Session.pm create mode 100644 cpan/Test-Harness/lib/TAP/Formatter/File.pm create mode 100644 cpan/Test-Harness/lib/TAP/Formatter/File/Session.pm create mode 100644 cpan/Test-Harness/lib/TAP/Formatter/Session.pm create mode 100644 cpan/Test-Harness/lib/TAP/Harness.pm create mode 100644 cpan/Test-Harness/lib/TAP/Object.pm create mode 100644 cpan/Test-Harness/lib/TAP/Parser.pm create mode 100644 cpan/Test-Harness/lib/TAP/Parser/Aggregator.pm create mode 100644 cpan/Test-Harness/lib/TAP/Parser/Grammar.pm create mode 100644 cpan/Test-Harness/lib/TAP/Parser/Iterator.pm create mode 100644 cpan/Test-Harness/lib/TAP/Parser/Iterator/Array.pm create mode 100644 cpan/Test-Harness/lib/TAP/Parser/Iterator/Process.pm create mode 100644 cpan/Test-Harness/lib/TAP/Parser/Iterator/Stream.pm create mode 100644 cpan/Test-Harness/lib/TAP/Parser/IteratorFactory.pm create mode 100644 cpan/Test-Harness/lib/TAP/Parser/Multiplexer.pm create mode 100644 cpan/Test-Harness/lib/TAP/Parser/Result.pm create mode 100644 cpan/Test-Harness/lib/TAP/Parser/Result/Bailout.pm create mode 100644 cpan/Test-Harness/lib/TAP/Parser/Result/Comment.pm create mode 100644 cpan/Test-Harness/lib/TAP/Parser/Result/Plan.pm create mode 100644 cpan/Test-Harness/lib/TAP/Parser/Result/Pragma.pm create mode 100644 cpan/Test-Harness/lib/TAP/Parser/Result/Test.pm create mode 100644 cpan/Test-Harness/lib/TAP/Parser/Result/Unknown.pm create mode 100644 cpan/Test-Harness/lib/TAP/Parser/Result/Version.pm create mode 100644 cpan/Test-Harness/lib/TAP/Parser/Result/YAML.pm create mode 100644 cpan/Test-Harness/lib/TAP/Parser/ResultFactory.pm create mode 100644 cpan/Test-Harness/lib/TAP/Parser/Scheduler.pm create mode 100644 cpan/Test-Harness/lib/TAP/Parser/Scheduler/Job.pm create mode 100644 cpan/Test-Harness/lib/TAP/Parser/Scheduler/Spinner.pm create mode 100644 cpan/Test-Harness/lib/TAP/Parser/Source.pm create mode 100644 cpan/Test-Harness/lib/TAP/Parser/Source/Perl.pm create mode 100644 cpan/Test-Harness/lib/TAP/Parser/Utils.pm create mode 100644 cpan/Test-Harness/lib/TAP/Parser/YAMLish/Reader.pm create mode 100644 cpan/Test-Harness/lib/TAP/Parser/YAMLish/Writer.pm create mode 100644 cpan/Test-Harness/lib/Test/Harness.pm create mode 100644 cpan/Test-Harness/t/000-load.t create mode 100644 cpan/Test-Harness/t/aggregator.t create mode 100644 cpan/Test-Harness/t/bailout.t create mode 100644 cpan/Test-Harness/t/base.t create mode 100644 cpan/Test-Harness/t/callbacks.t create mode 100644 cpan/Test-Harness/t/compat/env.t create mode 100644 cpan/Test-Harness/t/compat/failure.t create mode 100644 cpan/Test-Harness/t/compat/inc-propagation.t create mode 100644 cpan/Test-Harness/t/compat/inc_taint.t create mode 100644 cpan/Test-Harness/t/compat/nonumbers.t create mode 100644 cpan/Test-Harness/t/compat/regression.t create mode 100644 cpan/Test-Harness/t/compat/switches.t create mode 100644 cpan/Test-Harness/t/compat/test-harness-compat.t create mode 100644 cpan/Test-Harness/t/compat/version.t create mode 100644 cpan/Test-Harness/t/console.t create mode 100644 cpan/Test-Harness/t/data/catme.1 create mode 100644 cpan/Test-Harness/t/data/proverc create mode 100644 cpan/Test-Harness/t/data/sample.yml create mode 100644 cpan/Test-Harness/t/errors.t create mode 100644 cpan/Test-Harness/t/file.t create mode 100644 cpan/Test-Harness/t/glob-to-regexp.t create mode 100644 cpan/Test-Harness/t/grammar.t create mode 100644 cpan/Test-Harness/t/harness-bailout.t create mode 100644 cpan/Test-Harness/t/harness-subclass.t create mode 100644 cpan/Test-Harness/t/harness.t create mode 100644 cpan/Test-Harness/t/iterators.t create mode 100644 cpan/Test-Harness/t/lib/App/Prove/Plugin/Dummy.pm create mode 100644 cpan/Test-Harness/t/lib/App/Prove/Plugin/Dummy2.pm create mode 100644 cpan/Test-Harness/t/lib/Dev/Null.pm create mode 100644 cpan/Test-Harness/t/lib/EmptyParser.pm create mode 100644 cpan/Test-Harness/t/lib/IO/c55Capture.pm create mode 100644 cpan/Test-Harness/t/lib/MyCustom.pm create mode 100644 cpan/Test-Harness/t/lib/MyGrammar.pm create mode 100644 cpan/Test-Harness/t/lib/MyIterator.pm create mode 100644 cpan/Test-Harness/t/lib/MyIteratorFactory.pm create mode 100644 cpan/Test-Harness/t/lib/MyPerlSource.pm create mode 100644 cpan/Test-Harness/t/lib/MyResult.pm create mode 100644 cpan/Test-Harness/t/lib/MyResultFactory.pm create mode 100644 cpan/Test-Harness/t/lib/MySource.pm create mode 100644 cpan/Test-Harness/t/lib/NOP.pm create mode 100644 cpan/Test-Harness/t/lib/NoFork.pm create mode 100644 cpan/Test-Harness/t/lib/TAP/Parser/SubclassTest.pm create mode 100644 cpan/Test-Harness/t/multiplexer.t create mode 100644 cpan/Test-Harness/t/nofork-mux.t create mode 100644 cpan/Test-Harness/t/nofork.t create mode 100644 cpan/Test-Harness/t/object.t create mode 100644 cpan/Test-Harness/t/parse.t create mode 100644 cpan/Test-Harness/t/parser-config.t create mode 100644 cpan/Test-Harness/t/parser-subclass.t create mode 100644 cpan/Test-Harness/t/perl5lib.t create mode 100644 cpan/Test-Harness/t/premature-bailout.t create mode 100644 cpan/Test-Harness/t/process.t create mode 100644 cpan/Test-Harness/t/prove.t create mode 100644 cpan/Test-Harness/t/proveenv.t create mode 100644 cpan/Test-Harness/t/proverc.t create mode 100644 cpan/Test-Harness/t/proverc/emptyexec create mode 100644 cpan/Test-Harness/t/proverun.t create mode 100644 cpan/Test-Harness/t/regression.t create mode 100644 cpan/Test-Harness/t/results.t create mode 100644 cpan/Test-Harness/t/sample-tests/bailout create mode 100644 cpan/Test-Harness/t/sample-tests/bignum create mode 100644 cpan/Test-Harness/t/sample-tests/bignum_many create mode 100644 cpan/Test-Harness/t/sample-tests/combined create mode 100644 cpan/Test-Harness/t/sample-tests/combined_compat create mode 100644 cpan/Test-Harness/t/sample-tests/delayed create mode 100644 cpan/Test-Harness/t/sample-tests/descriptive create mode 100644 cpan/Test-Harness/t/sample-tests/descriptive_trailing create mode 100644 cpan/Test-Harness/t/sample-tests/die create mode 100644 cpan/Test-Harness/t/sample-tests/die_head_end create mode 100644 cpan/Test-Harness/t/sample-tests/die_last_minute create mode 100644 cpan/Test-Harness/t/sample-tests/die_unfinished create mode 100644 cpan/Test-Harness/t/sample-tests/duplicates create mode 100644 cpan/Test-Harness/t/sample-tests/echo create mode 100644 cpan/Test-Harness/t/sample-tests/empty create mode 100644 cpan/Test-Harness/t/sample-tests/escape_eol create mode 100644 cpan/Test-Harness/t/sample-tests/escape_hash create mode 100644 cpan/Test-Harness/t/sample-tests/head_end create mode 100644 cpan/Test-Harness/t/sample-tests/head_fail create mode 100644 cpan/Test-Harness/t/sample-tests/inc_taint create mode 100644 cpan/Test-Harness/t/sample-tests/junk_before_plan create mode 100644 cpan/Test-Harness/t/sample-tests/lone_not_bug create mode 100644 cpan/Test-Harness/t/sample-tests/no_nums create mode 100644 cpan/Test-Harness/t/sample-tests/no_output create mode 100644 cpan/Test-Harness/t/sample-tests/out_err_mix create mode 100644 cpan/Test-Harness/t/sample-tests/out_of_order create mode 100644 cpan/Test-Harness/t/sample-tests/schwern create mode 100644 cpan/Test-Harness/t/sample-tests/schwern-todo-quiet create mode 100644 cpan/Test-Harness/t/sample-tests/segfault create mode 100644 cpan/Test-Harness/t/sample-tests/sequence_misparse create mode 100644 cpan/Test-Harness/t/sample-tests/shbang_misparse create mode 100644 cpan/Test-Harness/t/sample-tests/simple create mode 100644 cpan/Test-Harness/t/sample-tests/simple_fail create mode 100644 cpan/Test-Harness/t/sample-tests/simple_yaml create mode 100644 cpan/Test-Harness/t/sample-tests/skip create mode 100644 cpan/Test-Harness/t/sample-tests/skip_nomsg create mode 100644 cpan/Test-Harness/t/sample-tests/skipall create mode 100644 cpan/Test-Harness/t/sample-tests/skipall_nomsg create mode 100644 cpan/Test-Harness/t/sample-tests/skipall_v13 create mode 100644 cpan/Test-Harness/t/sample-tests/space_after_plan create mode 100644 cpan/Test-Harness/t/sample-tests/stdout_stderr create mode 100644 cpan/Test-Harness/t/sample-tests/strict create mode 100644 cpan/Test-Harness/t/sample-tests/switches create mode 100644 cpan/Test-Harness/t/sample-tests/taint create mode 100644 cpan/Test-Harness/t/sample-tests/taint_warn create mode 100644 cpan/Test-Harness/t/sample-tests/todo create mode 100644 cpan/Test-Harness/t/sample-tests/todo_inline create mode 100644 cpan/Test-Harness/t/sample-tests/todo_misparse create mode 100644 cpan/Test-Harness/t/sample-tests/too_many create mode 100644 cpan/Test-Harness/t/sample-tests/version_good create mode 100644 cpan/Test-Harness/t/sample-tests/version_late create mode 100644 cpan/Test-Harness/t/sample-tests/version_old create mode 100644 cpan/Test-Harness/t/sample-tests/vms_nit create mode 100644 cpan/Test-Harness/t/sample-tests/with_comments create mode 100644 cpan/Test-Harness/t/sample-tests/zero_valid create mode 100644 cpan/Test-Harness/t/scheduler.t create mode 100644 cpan/Test-Harness/t/source.t create mode 100644 cpan/Test-Harness/t/source_tests/harness create mode 100644 cpan/Test-Harness/t/source_tests/harness_badtap create mode 100644 cpan/Test-Harness/t/source_tests/harness_complain create mode 100644 cpan/Test-Harness/t/source_tests/harness_directives create mode 100644 cpan/Test-Harness/t/source_tests/harness_failure create mode 100644 cpan/Test-Harness/t/source_tests/source create mode 100644 cpan/Test-Harness/t/spool.t create mode 100644 cpan/Test-Harness/t/state.t create mode 100644 cpan/Test-Harness/t/state_results.t create mode 100644 cpan/Test-Harness/t/streams.t create mode 100644 cpan/Test-Harness/t/subclass_tests/non_perl_source create mode 100644 cpan/Test-Harness/t/subclass_tests/perl_source create mode 100644 cpan/Test-Harness/t/taint.t create mode 100644 cpan/Test-Harness/t/testargs.t create mode 100644 cpan/Test-Harness/t/unicode.t create mode 100644 cpan/Test-Harness/t/utils.t create mode 100644 cpan/Test-Harness/t/yamlish-output.t create mode 100644 cpan/Test-Harness/t/yamlish-writer.t create mode 100644 cpan/Test-Harness/t/yamlish.t (limited to 'cpan/Test-Harness') diff --git a/cpan/Test-Harness/Changes b/cpan/Test-Harness/Changes new file mode 100644 index 0000000000..6141f78f36 --- /dev/null +++ b/cpan/Test-Harness/Changes @@ -0,0 +1,682 @@ +Revision history for Test-Harness + +3.17 2009-05-05 + - Changed the 'failures' so that it is overridden by verbosity rather + than the other way around. + - Added the 'comments' option, most useful when used in conjunction + with the 'failures' option. + - Deprecated support for Perls earlier than 5.6.0. + - Allow '-I lib' as well as '-Ilib' in $Test::Harness::Switches + (regression). + - Restore old skip parsing semantics for TAP < v13. Refs #39031. + - Numerous small documentation fixes. + - Remove support for fork-based parallel testing. Multiplexed + parallel testing remains. + +3.16 2009-02-19 + - Fix path splicing on platforms where the path separator + is not ':'. + - Fixes/skips for failing Win32 tests. + - Don't break with older CPAN::Reporter versions. + +3.15 2009-02-17 + - Refactor getter/setter generation into TAP::Object. + - The App::Prove::State::Result::Test now stores the parser object. + - After discussion with Andy, agreed to clean up the test output + somewhat. t/foo.....ok becomes t/foo.t ... ok + - Make Bail out! die instead of exiting. Dies with the same + message as 2.64 for (belated) backwards compatibility. + - Alex Vaniver's patch to refactor TAP::Formatter::Console into + a new class, TAP::Formatter::File and a common base class: + TAP::Formatter::Base. + - Fix a bug where PERL5LIB might be put in the wrong spot in @INC. + #40257 + - Steve Purkis implemented a plugin mechanism for App::Prove. + +3.14 2008-09-13 + - Created a proper (ha!) API for prove state results and tests. + - Added --count and --nocount options to prove to control X/Y display + while running tests. + - Added 'fresh' state option to run test scripts that have been + touched since the test run. + - fixed bug where PERL5OPT was not properly split + - fixed regex in _filtered_inc. Fixes #39248. Thanks Slaven. + +3.13 2008-07-27 + - fixed various closure related leaks + - made prove honour HARNESS_TIMER + - Applied patches supplied by Alex Vandiver + - add 'rules' switch to prove: allows parallel execution rules + to be specified on the command line. + - allow '**' (any path) wildcard in parallel rules + - fix bug report address + - make tprove_gtk example work again. + +3.12 2008-06-22 + - applied Steve Purkis' huge refactoring patch which adds + configurable factories for most of the major internal classes. + - applied David Wheeler's patch to allow exec to be a code + reference. + - made tests more robust in the presence of -MFoo in PERL5OPT. + +3.11 2008-06-09 + - applied Jim Keenan's patch that makes App::Prove::run return a + rather than exit (#33609) + - prove -r now recurses cwd rather than 't' by default (#33007) + - restored --ext switch to prove (#33848) + - added ignore_exit option to TAP::Parser and corresponding + interfaces to TAP::Harness and Test::Harness. Requested for + Parrot. + - Implemented rule based parallel scheduler. + - Moved filename -> display name mapping out of formatter. This + prevents the formatter's strip-extensions logic from stripping + extensions from supplied descriptions. + - Only strip extensions from test names if all tests have the + same extension. Previously we stripped extensions if all names + had /any/ extension making it impossible to distinguish tests + whose name differed only in the extension. + - Removed privacy test that made it impossible to subclass + TAP::Parser. + - Delayed initialisation of grammar making it easier to replace + the TAP::Parser stream after instantiation. + - Make it possible to supply import parameters to a replacement + harness with prove. + - Make it possible to replace either _grammar /or/ _stream + before reading from a TAP::Parser. + +3.10 2008-02-26 + - fix undefined value warnings with bleadperl. + - added pragma support. + - fault unknown TAP tokens under strict pragma. + +3.09 2008-02-10 + - support for HARNESS_PERL_SWITCHES containing things like + '-e "system(shift)"'. + - set HARNESS_IS_VERBOSE during verbose testing. + - documentation fixes. + +3.08 2008-02-08 + - added support for 'out' option to + Test::Harness::execute_tests. See #32476. Thanks RENEEB. + - Fixed YAMLish handling of non-alphanumeric hash keys. + - Added --dry option to prove for 2.64 compatibility. + +3.07 2008-01-13 + - prove now supports HARNESS_PERL_SWITCHES. + - restored TEST_VERBOSE to prove. + +3.06 2008-01-01 + - Skip t/unicode.t if PERL_UNICODE set. Fixes #31731. + Thanks Lukas. + - App::Prove::State no longer complains about tests that + are deleted. + - --state=new and --state=old now consider the modification time + of test scripts. + - Made test suite core-compatible. + +3.05 2007-12-09 + - Skip unicode.t if Encode unavailable + - Support for .proverc files. + - Clarified prove documentation. + +3.04 2007-12-02 + - Fixed output leakage with really_quiet set. + - Progress reports for tests without plans now show + "143/?" instead of "143/0". + - Made TAP::Harness::runtests support aliases for test names. + - Made it possible to pass command line args to test programs + from prove, TAP::Harness, TAP::Parser. + - Added --state switch to prove. + +3.03 2007-11-17 + - Fixed some little bugs-waiting-to-happen inside + TAP::Parser::Grammar. + - Added parser_args callback to TAP::Harness. + - Made @INC propagation even more compatible with 2.64 so that + parrot still works *and* #30796 is fixed. + +3.02 2007-11-15 + - Process I/O now unbuffered, uses sysread, plays better with + select. Fixes #30740. + - Made Test::Harness @INC propagation more compatible with 2.64. + Was breaking Parrot's test suite. + - Added HARNESS_OPTIONS (#30676) + +3.01 2007-11-12 + - Fix for RHEL incpush.patch related failure. + - Output real time of test completion with --timer + - prove -b adds blib/auto to @INC + - made SKIP plan parsing even more liberal for pre-v13 TAP + +3.00 2007-11-06 + - Non-dev release. No changes since 2.99_09. + +2.99_09 2007-11-05 + - Implemented TODO-in-PLAN syntax for TAP version 12 and earlier. + +2.99_08 2007-11-04 + - Tiny changes. New version pushed to get some smoke coverage. + +2.99_07 2007-11-01 + - Fix for #21938: Unable to handle circular links + - Fix for #24926: prove -b and -l should use absolute paths + - Fixed prove switches. Big oops. How the hell did we miss that? + - Consolidated quiet, really_quiet, verbose into verbosity. + - Various VMS related fixes to tests + +2.99_06 2007-10-30 + - Added skip_all method to TAP::Parser. + - Display reason for skipped tests. + - make test now self tests. + +2.99_05 2007-10-30 + - Fix for occasional rogue -1 exit code on Windows. + - Fix for @INC handling under CPANPLUS. + - Added real time to prove --timer output + - Improved prove error message in case where 't' not found and + no tests named. + +2.99_04 2007-10-11 + - Fixed bug where 'All tests successful' would not be printed if bonus + tests are seen. + - Fixed bug where 'Result: FAIL' would be printed at the end of a test + run if there were unexpectedly succeeding tests. + - Added -M, -P switches to allow arbitrary modules to be loaded + by prove. We haven't yet defined what they'll do once they + load but it's a start... + - Added testing under simulated non-forking platforms. + +2.99_03 2007-10-06 + - Refactored all display specific code out of TAP::Harness. + - Relaxed strict parsing of skip plan for pre v13 TAP. + - Elapsed hi-res time is now displayed in integer milliseconds + instead of fractional seconds. + - prove stops running if any command-line switches are invalid. + - prove -v would try to print an undef. + - Added support for multiplexed and forked parallel tests. Use + prove -j 9 to run tests in parallel and prove -j 9 --fork to + fork. These features are experimental and currently + unavailable on Windows. + - Rationalized the management of the environment that we give to + test scripts (PERL5LIB, PERL5OPT, switches). + - Fixed handling of STDIN (we no longer close it) for test + scripts. + - Performance enhancements. Parser is now 30% - 40% faster. + +2.99_02 2007-09-07 + - Ensure prove (and App::Prove) sort any recursively + discovered tests + - It is now possible to register multiple callback handlers for + a particular event. + - Added before_runtests, after_runtests callbacks to + TAP::Harness. + - Moved logic of prove program into App::Prove. + - Added simple machine readable summary. + - Performance improvement: The processing pipeline within + TAP::Parser is now a closure which speeds up access to the + various attribtes it needs. + - Performance improvement: Test count spinner now updates + exponentially less frequently as the count increases which + saves a lot of I/O on big tests. + - More improvements in test coverage from Leif. + - Fixes to TAP spooling - now captures YAML blocks correctly. + - Fix YAMLish handling of empty arrays, hashes. + - Renamed TAP::Harness::Compatible to Test::Harness, + runtests to prove. + - Fixes to @INC handling. We didn't always pass the correct path + to subprocesses. + - We now observe any switches in HARNESS_PERL_SWITCHES. + - Changes to output formatting for greater compatibility with + Test::Harness 2.64. + - Added unicode test coverage and fixed a couple of + unicode issues. + - Additions to documentation. + - Added support for non-forking Perls. If forking isn't + available we fall back to open and disable stream merging. + - Added support for simulating non-forking Perls to improve our + test coverage. + +======================================================================== +Version numbers below this point relate to TAP::Parser - which was the +name of this version of Test::Harness during its development. +======================================================================== + +0.54 + - Optimized I/O for common case of 'runtests -l' + - Croak if supplied an empty (0 lines) Perl script. + - Made T::P::Result::YAML return literal input YAML correctly. + - Merged speed-ups from speedy branch. + +0.53 18 August 2007 + - Fixed a few docs nits. + - Added -V (--version) switch to runtests. Suggested by markjugg on + Perlmonks. + - Fixed failing t/030-grammer.t under 5.9.5. Exact cause still + unknown; something to do with localisation of $1 et all I think. + - Fixed use of three arg open in t/compat/test-harness-compat; was + failing on 5.6.2. + - Fixed runtests --exec option. T::H wasn't passing the exec option + to T::P. + - Merged Leif Eriksen's coverage enhancing changes to + t/080-aggregator.t, t/030-grammar.t + - Made various changes so that we test cleanly on 5.0.5. + - Many more coverage enhancements by Leif. + - Applied Michael Peters' patch to add an EOF callback to + TAP::Parser. + - Added --reverse option to runtests to run tests in reverse order. + - Made runtests exit with non-zero status if the test run had + problems. + - Stopped TAP::Parser::Iterator::Process from trampling on STDIN. + +0.52 14 July 2007 + - Incorporate Schwern's investigations into TAP versions. + Unversioned TAP is now TAP v12. The lowest explicit version number + that can be specified is 13. + - Renumbered tests to eliminate gaps. + - Killed execrc. The '--exec' switch to runtests handles all of this for + us. + - Refactored T::P::Iterator into + T::P::Iterator::(Array|Process|Stream) so that we have a + process specific iterator with which to experiment with + STDOUT/STDERR merging. + - Removed vestigial exit status handling from T::P::I::Stream. + - Removed unused pid interface from T::P::I::Process. + - Fixed infinite recursion in T::P::I::Stream and added regression + coverage for same. + - Added tests for T::P::I::Process. + - TAP::Harness now displays the first five TAP syntax errors and + explains how to pass the -p flag to runtests to see them all. + - Added merge option to TAP::Parser::Iterator::Process, + TAP::Parser::Source, TAP::Parser and TAP::Harness. + - Added --merge option to runtests to enable STDOUT/STDERR merging. + This behaviour used to be the default. + - Made T::P::I::Process use open3 for both merged and non-merged + streams so that it works on Windows. + - Implemented Eric Wilhelm's IO::Select based multiple stream + handler so that STDERR is piped to us even if stream merging is + turned off. This tends to reduce the temporal skew between the + two streams so that error messages appear closer to their + correct location. + - Altered the T::P::Grammar interface so that it gets a stream + rather than the next line from the stream in preparation for + making it handle YAML diagnostics. + - Implemented YAML syntax. Currently YAML may only follow a + test result. The first line of YAML is '---' and the last + line is '...'. + - Made grammar version-aware. Different grammars may now be selected + depending on the TAP version being parsed. + - Added formatter delegate mechanism for test results. + - Added prototype stream based YAML(ish) parser. + - Added more tests for T::P::YAMLish + - Altered T::P::Grammar to use T::P::YAMLish + - Removed T::P::YAML + - Added raw source capture to T::P::YAMLish + - Added support for double quoted hash keys + - Added TAP::Parser::YAMLish::Writer and renamed T::P::YAMLish as + T::P::YAMLish::Reader. + - Added extra TAP::Parser::YAMLish::Writer output options + - Inline YAML documents must now be indented by at least one space + - Fixed broken dependencies in bin/prove + - Make library paths absolute before running tests in case tests + chdir before loading modules. + - Added libs and switches handling to T::H::Compatible. This and the + previous change fix [24926] + - Added PERLLIB to libraries stripped in _default_inc [12030] + - Our version of prove now handles directories containing circular + links correctly [21938] + - Set TAP_VERSION env var in Parser [11595] + - Added setup, teardown hooks to T::P::I::Process to facilitate the + setup and cleanup of the test script's environment + - Any additional libs added to the command line are also added to + PERL5LIB for the duration of a test run so that any Perl children + of the test script inherit the same library paths. + - Fixed handling of single quoted hash keys in T::P::Y::Reader + - Made runtests return the TAP::Parser::Aggregator + - Fixed t/120-harness.t has failures if TAP::Harness::Color cannot + load optional modules [27125] - thanks DROLSKY + - Fixed parsing of \# in test description +0.51 12 March 2007 + - 'execrc' file now allows 'regex' matches for tests. + - rename 'TAPx' --> 'TAP' + - Reimplemented the parse logic of TAP::Parser as a state machine. + - Removed various ad-hoc state variables from TAP::Parser and moved + their logic into the state machine. + - Removed now-unused is_first / is_last methods from Iterator and + simplified remaining logic to suit. + - Removed now-redundant t/140-varsource.t. + - Implemented TAP version syntax. + - Tidied TAP::Harness::Compatible documentation + - Removed redundant modules below TAP::Harness::Compatible + - Removed unused compatibility tests + +0.50_07 5 March 2007 + - Fixed bug where we erroneously checked the test number instead of number + of tests run to determine if we've run more tests than we planned. + - Add a --directives switch to 'runtests' which only shows test results + with directives (such as 'TODO' or 'SKIP'). + - Removed some dead code from TAPx::Parser. + - Added color support for Windows using Win32::Console. + - Made Color::failure_output reset colors before printing + the trailing newline. + - Corrected some issues with the 'runtests' docs and removed some + performance notes which no longer seem accurate. + - Fixed bug whereby if tests without file extensions were included then + the spacing of the result leaders would be off. + - execrc file is now a YAML file. + - Removed white background on the test failures. It was too garish for + me. Just more proof that we need better ways of overriding color + support. + - Started work on TAPx::Harness::Compatible. Right now it's mainly just + a direct lift of Test::Harness to make sure the tests work. + - Commented out use Data::Dumper::Simple in T::Harness.pm - it's not + a core module. + - Added next_raw to TAPx::Parser::Iterator which skips any fixes for + quirky TAP that are implemented by next. Used to support + TAPx::Harness::Compatible::Iterator + - Applied our version number to all T::H::Compatible modules + - Removed T::H::C::Assert. It's documented as being private to + Test::Harness and we're not going to need it. + - Refactored runtests to call aggregate_tests to expose the + interface we need for the compatibility layer. + - Make it possible to pass an end time to summary so that it needn't + be called immediately after the tests complete. + - Moved callback handling into TAPx::Base and altered TAPx::Parser + to use it. + - Made TAPx::Harness into a subclass of TAPx::Base and implemented + made_parser callback. + - Moved the dispatch of callbacks out of run and into next so that + they're called when TAPx::Harness iterates through the results. + - Implemented PERL_TEST_HARNESS_DUMP_TAP which names a directory + into which the raw TAP of any tests run via TAPx::Harness will + be written. + - Rewrote the TAPx::Grammar->tokenize method to return a + TAPx::Parser::Result object. Code is much cleaner now. + - Moved the official grammar from TAPx::Parser to TAPx::Parser::Grammar, + provided a link and updated the grammar. + - Fixed bug where a properly escaped '# TODO' line in a test description + would still be reported as a TODO test. + - Added patches/ExtUtils-MakeMaker-6.31.patch - a patch against EUMM + that makes test_harness use TAPx::Harness instead of Test::Harness + if PERL_EUMM_USE_TAPX is true and TAPx::Harness is installed. In + other words cause 'make test' for EUMM based models to use + TAPx::Harness. + - Added support for timer option to TAPx::Harness which causes the + elapsed time for each test to be displayed. + - Setup tapx-dev@hexten.net mailing list. + - Fixed accumulating @$exec bug in TAPx::Harness. + - Made runtests pass '--exec' option as an array. + - (#24679) TAPx::Harness now reports failure for tests that die + after completing all subtests. + - Added in_todo attribute on TAPx::Parser which is true while the + most recently seen test was a TODO. + - (#24728) TAPx::Harness now supresses diagnostics from failed + TODOs. Not sure if the semantics of this are correct yet. + +0.50_06 18 January 2007 + - Fixed doc typo in examples/README [rt.cpan.org #24409] + - Colored test output is now the default for 'runtests' unless + you're running under windows or -t STDOUT is false. + [rt.cpan.org #24310] + - Removed the .t extension from t/source_tests/*.t since those are + 'test tests' which caused false negatives when running recursive + tests. [Adrian Howard] + - Somewhere along the way, the exit status started working again. + Go figure. + - Factored color output so that disabling it under Windows is + cleaner. + - Added explicit switch to :crlf layer after open3 under Windows. + open3 defaults to raw mode resulting in spurious \r characters input + parsed input. + - Made Iterator do an explicit wait for subprocess termination. + Needed to get process status correctly on Windows. + - Fixed bug which didn't allow t/010-regression.t to be run directly + via Perl unless you specified Perl's full path. + - Removed SIG{CHLD} handler (which we shouldn't need I think because + we explicitly waitpid) and made binmode ':crlf' conditional on + IS_WIN32. On Mac OS these two things combined to expose a problem + which meant that output from test scripts was sometimes lost. + - Made t/110-source.t use File::Spec->catfile to build path to + test script. + - Made Iterator::FH init is_first, is_last to 0 rather than undef + for consistency with array iterator. + - Added t/120-varsource.t to test is_first and is_last semantics + over files with small numbers of lines. + - Added check for valid callback keys. + - Added t/130-results.t for Result classes. + +0.50_05 15 January 2007 + - Removed debugging code accidentally left in bin/runtests. + - Removed 'local $/ = ...' from the iterator. Hopefully that will fix the + line ending bug, but I don't know about the wstat problem. + +0.50_04 14 January 2007 + - BACKWARDS IMCOMPATIBLE: Renamed all '::Results' classes to '::Result' + because they represent a single result. + - Fixed bug where piping would break verbose output. + - IPC::Open3::open3 now takes a @command list rather than a $command + string. This should make it work under Windows. + - Added 'stdout_sterr' sample test back to regression tests. IPC::Open3 + appears to make it work. + - Bug fix: don't print 'All tests successful' if no tests are run. + - Refactored 'runtests' to make it a bit easier to follow. + - Bug fix: Junk and comments now allowed before a leading plan. + - HARNESS_ACTIVE and HARNESS_VERSION environment variables now set. + - Renamed 'problems' in TAPx::Parser and TAPx::Aggregator to + 'has_problems'. + +0.50_03 08 January 2007 + + - Fixed bug where '-q' or '-Q' with colored tests weren't suppressing all + information. + - Fixed an annoying MANIFEST nit. + - Made '-h' for runtests now report help. Using a new harness requires + the full --harness switch. + - Added 'problems' method to TAPx::Parser and TAPx::Parser::Aggregator. + - Deprecatd 'todo_failed' in favor of 'todo_passed' + - Add -I switch to runtests. + - Fixed runtests doc nit (smylers) + - Removed TAPx::Parser::Builder. + - A few more POD nits taken care of. + - Completely removed all traces of C<--merge> as IPC::Open3 seems to be + working. + - Moved the tprove* examples to examples/bin in hopes of them no longer + showing up in CPAN's docs. + - Made the 'unexpectedly succeeded' message clearer (Adam Kennedy) + +0.50_02 06 January 2007 + - Added some files I left out of the manifest (reported by Florian + Ragwitz). + - Added strict to Makefile.PL and changed @PROGRAM to @program (reported + Florian Ragwitz). + +0.50_01 06 January 2007 + - Added a new example which shows to how test Perl, Ruby, and URLs all at + the same time using 'execrc' files. + - Fixed the diagnostic format mangling bug. + - We no longer override Test::Builder to merge streams. Instead, we go + ahead and use IPC::Open3. It remains to be seen whether or not this is + a good idea. + - Fixed vms nit: for failing tests, vms often has the 'not' on a line by + itself. + - Fixed bugs where unplanned tests were not reporting as a failure (test + number greater than tests planned). + - TAPx::Parser constructor can now take an 'exec' option to tell it what + to execute to create the stream (huge performance boost). + - Added TAPx::Parser::Source. This allows us to run tests in just about + any programming language. + - Renamed the filename() method to source() in TAPx::Parser::Source::Perl. + - We now cache the @INC values found for TAPx::Parser::Source::Perl. + - Added two test harnesses, TAPx::Harness and TAPx::Harness::Color. + - Removed references to manual stream construction from TAPx::Parser + documentation. Users should not (usually) need to worry about streams. + - Added bin/runtests utility. This is very similar to 'prove'. + - Renumbered tests to make it easier to add new ones. + - Corrected some minor documentation nits. + - Makefile.PL is no longer auto-generated (it's built by hand). + - Fixed regression test bug where driving tests through the harness I'm + testing caused things to break. + - BUG: exit() values are now broken. I don't know how to capture them + with IPC::Open3. However, since no one appears to be using them, this + might not be an issue. + +0.41 12 December 2006 + - Fixed (?) 10-regression.t test which failed on Windows. Removed the + segfault test as it has no meaning on Windows. Reported by PSINNOTT + and fix recommended by Schwern based on his + Test::Harness experience. + http://rt.cpan.org/Ticket/Display.html?id=21624 + +0.40 05 December 2006 + - Removed TAPx::Parser::Streamed and folded its functionality into + TAPx::Parser. + - Fixed bug where sometimes is_good_plan() would return a false positive + (exposed by refactoring). + - A number of tiny performance enhancements. + +0.33 22 September 2006 + - OK, I'm getting ticked off by some of the comments on Perl-QA so I + rushed this out the door and broke it :( I'm backing out one test and + slowing down a bit. + +0.32 22 September 2006 + - Applied patch from Schwern which fixed the Builder package name (TAPx:: + instead of TAPX:: -- stupid case-insensitive package names!). + [rt.cpan.org #21605] + +0.31 21 September 2006 + - Fixed bug where Carp::croak without parens could cause Perl to fail to + compile on some platforms. [Andreas J. Koenig] + - Eliminated the non-portable redirect of STDERR to STDOUT (2>&1) and + fixed the synchronization issue. This involves overridding + Test::Builder::failure_output() in a very sneaky way. I may have to + back this out. + - Renamed boolean methods to begin with 'is_'. The methods they replace + are documented, deprecated, and will not be removed prior to version + 1.00. + +0.30 17 September 2006 + - Fixed bug where no output would still claim to have a good plan. + - Fixed bug where no output would cause parser to die. + - Fixed bug where failing to specify a plan would be two parse errors + instead of one. + - Fixed bug where a correct plan count in an incorrect place would still + report as a 'good_plan'. + - Fixed bug where comments could accidently be misparsed as directives. + - Eliminated testing of internal structure of result objects. The other + tests cover this. + - Allow hash marks in descriptions. This was causing a problem because + many test suites (Regexp::Common and Perl core) allowed them to exist. + - Added support for SKIP directives in plans. + - Did some work simplifying &TAPx::Parser::_initialize. It's not great, + but it's better than it was. + - TODO tests now always pass, regardless of actual_passed status. + - Removed 'use warnings' and now use -w + - 'switches' may now be passed to the TAPx::Parser constructor. + - Added 'exit' status. + - Added 'wait' status. + - Eliminated 'use base'. This is part of the plan to make TAPx::Parser + compatible with older versions of Perl. + - Added 'source' key to the TAPx::Parser constructor. Making new parsers + is now much easier. + - Renamed iterator first() and last() methods to is_first() and is_last(). + Credit: Aristotle. + - Planned tests != tests run is now a parse error. It was really stupid + of me not to do that in the first place. + - Added massive regression test suite in t/100-regression.t + - Updated the grammar to show that comments are allowed. + - Comments are now permitted after an ending plan. + +0.22 13 September 2006 + - Removed buggy support for multi-line chunks from streams. If your + streams or iterators return anything but single lines, this is a bug. + - Fixed bug whereby blank lines in TAP would confuse the parser. Reported + by Torsten Schoenfeld. + - Added first() and last() methods to the iterator. + - TAPx::Parser::Source::Perl now has a 'switches' method which allows + switches to be passed to the perl executable running the test file. + This allows tprove to accept a '-l' argument to force lib/ to be + included in Perl's @INC. + +0.21 8 September 2006 + - Included experimental GTK interface written by Torsten Schoenfeld. + - Fixed bad docs in examples/tprove_color + - Applied patch from Shlomi Fish fixing bug where runs from one stream + could leak into another when bailing out. [rt.cpan.org #21379] + - Fixed some typos in the POD. + - Corrected the grammar to allow for a plan of "1..0" (infinite stream). + - Started to add proper acknowledgements. + +0.20 2 September 2006 + - Fixed bug reported by GEOFFR. When no tap output was found, an + "Unitialized value" warning occurred. [rt.cpan.org #21205] + - Updated tprove to now report a test failure when no tap output found. + - Removed examples/tprove_color2 as tprove_color now works. + - Vastly improved callback system and updated the docs for how to use + them. + - Changed TAPx::Parser::Source::Perl to use Symbol::gensym() instead of a + hard-to-guess filehandle name. + +0.12 30 July 2006 + - Added a test colorization script + - Callback support added. + - Added TAPx::Parser::Source::Perl. + - Added TAPx::Parser::Aggregator. + - Added version numbers to all classes. + - Added 'todo_failed' test result and parser. + - 00-load.t now loads all classes instead of having individual tests load + their supporting classes. + - Changed $parser->results to $parser->next + +0.11 25 July, 2006 + - Renamed is_skip and is_todo to has_skip and has_todo. Much less + confusing since a result responding true to those also responded true to + is_test. + - Added simplistic bin/tprove to run tests. Much harder than I thought + and much code stolen from Test::Harness. + - Modified stolen iterator to fix a bug with stream handling when extra + newlines were encountered. + - Added TAPx::Parser::Iterator (stolen from Test::Harness::Iterator) + - Normalized internal structure of result objects. + - All tokens now have a 'type' key. This greatly simplifies internals. + - Copied much result POD info into the main docs. + - Corrected the bug report URLs. + - Minor updates to the grammar listed in the POD. + +0.10 23 July, 2006 + - Oh my Larry, we gots docs! + - _parse and _tap are now private methods. + - Stream support has been added. + - Moved the grammar into its own class. + - Pulled remaining parser functionality out of lexer. + - Added type() method to Results(). + - Parse errors no longer croak(). Instead, they are available through the + parse_errors() method. + - Added good_plan() method. + - tests_planned != tests_run is no longer a parse error. + - Renamed test_count() to tests_run(). + - Renamed num_tests() to tests_planned(). + +0.03 17 July, 2006 + - 'Bail out!' is now handled. + - The parser is now data driven, thus skipping a huge if/else chain + - We now track all TODOs, SKIPs, passes and fails by test number. + - Removed all non-core modules. + - Store original line for each TAP line. Available through + $result->raw(). + - Renamed test is_ok() to passed() and added actual_passed(). The former + method takes into account TODO tests and the latter returns the actual + pass/fail status. + - Fixed a bug where SKIP tests would not be identified correctly. + +0.02 8 July, 2006 + - Moved some lexer responsibility to the parser. This will allow us to + eventually parse streams. + - Properly track passed/failed tests, even accounting for TODO. + - Added support for comments and unknown lines. + - Allow explicit and inferred test numbers to be mixed. + - Allow escaped hashes in the test description. + - Renamed to TAPx::Parser. Will probably rename it again. + +0.01 Date/time + - First version, unreleased on an unsuspecting world. + - No, you'll never know when ... diff --git a/cpan/Test-Harness/bin/prove b/cpan/Test-Harness/bin/prove new file mode 100644 index 0000000000..a592a80f0d --- /dev/null +++ b/cpan/Test-Harness/bin/prove @@ -0,0 +1,305 @@ +#!/usr/bin/perl -w + +use strict; +use App::Prove; + +my $app = App::Prove->new; +$app->process_args(@ARGV); +exit( $app->run ? 0 : 1 ); + +__END__ + +=head1 NAME + +prove - Run tests through a TAP harness. + +=head1 USAGE + + prove [options] [files or directories] + +=head1 OPTIONS + +Boolean options: + + -v, --verbose Print all test lines. + -l, --lib Add 'lib' to the path for your tests (-Ilib). + -b, --blib Add 'blib/lib' and 'blib/arch' to the path for your tests + -s, --shuffle Run the tests in random order. + -c, --color Colored test output (default). + --nocolor Do not color test output. + --count Show the X/Y test count when not verbose (default) + --nocount Disable the X/Y test count. + -D --dry Dry run. Show test that would have run. + --ext Set the extension for tests (default '.t') + -f, --failures Show failed tests. + -o, --comments Show comments. + --fork Fork to run harness in multiple processes. + --ignore-exit Ignore exit status from test scripts. + -m, --merge Merge test scripts' STDERR with their STDOUT. + -r, --recurse Recursively descend into directories. + --reverse Run the tests in reverse order. + -q, --quiet Suppress some test output while running tests. + -Q, --QUIET Only print summary results. + -p, --parse Show full list of TAP parse errors, if any. + --directives Only show results with TODO or SKIP directives. + --timer Print elapsed time after each test. + --normalize Normalize TAP output in verbose output + -T Enable tainting checks. + -t Enable tainting warnings. + -W Enable fatal warnings. + -w Enable warnings. + -h, --help Display this help + -?, Display this help + -H, --man Longer manpage for prove + --norc Don't process default .proverc + +Options that take arguments: + + -I Library paths to include. + -P Load plugin (searches App::Prove::Plugin::*.) + -M Load a module. + -e, --exec Interpreter to run the tests ('' for compiled tests.) + --harness Define test harness to use. See TAP::Harness. + --formatter Result formatter to use. See TAP::Harness. + -a, --archive Store the resulting TAP in an archive file. + -j, --jobs N Run N test jobs in parallel (try 9.) + --state=opts Control prove's persistent state. + --rc=rcfile Process options from rcfile + +=head1 NOTES + +=head2 .proverc + +If F<~/.proverc> or F<./.proverc> exist they will be read and any +options they contain processed before the command line options. Options +in F<.proverc> are specified in the same way as command line options: + + # .proverc + --state=hot,fast,save + -j9 --fork + +Additional option files may be specified with the C<--rc> option. +Default option file processing is disabled by the C<--norc> option. + +Under Windows and VMS the option file is named F<_proverc> rather than +F<.proverc> and is sought only in the current directory. + +=head2 Reading from C + +If you have a list of tests (or URLs, or anything else you want to test) in a +file, you can add them to your tests by using a '-': + + prove - < my_list_of_things_to_test.txt + +See the C in the C directory of this distribution. + +=head2 Default Test Directory + +If no files or directories are supplied, C looks for all files +matching the pattern C. + +=head2 Colored Test Output + +Colored test output is the default, but if output is not to a +terminal, color is disabled. You can override this by adding the +C<--color> switch. + +Color support requires L on Unix-like platforms and +L windows. If the necessary module is not installed +colored output will not be available. + +=head2 Exit Code + +If the tests fail C will exit with non-zero status. + +=head2 Arguments to Tests + +It is possible to supply arguments to tests. To do so separate them from +prove's own arguments with the arisdottle, '::'. For example + + prove -v t/mytest.t :: --url http://example.com + +would run F with the options '--url http://example.com'. +When running multiple tests they will each receive the same arguments. + +=head2 C<--exec> + +Normally you can just pass a list of Perl tests and the harness will know how +to execute them. However, if your tests are not written in Perl or if you +want all tests invoked exactly the same way, use the C<-e>, or C<--exec> +switch: + + prove --exec '/usr/bin/ruby -w' t/ + prove --exec '/usr/bin/perl -Tw -mstrict -Ilib' t/ + prove --exec '/path/to/my/customer/exec' + +=head2 C<--merge> + +If you need to make sure your diagnostics are displayed in the correct +order relative to test results you can use the C<--merge> option to +merge the test scripts' STDERR into their STDOUT. + +This guarantees that STDOUT (where the test results appear) and STDOUT +(where the diagnostics appear) will stay in sync. The harness will +display any diagnostics your tests emit on STDERR. + +Caveat: this is a bit of a kludge. In particular note that if anything +that appears on STDERR looks like a test result the test harness will +get confused. Use this option only if you understand the consequences +and can live with the risk. + +=head2 C<--state> + +You can ask C to remember the state of previous test runs and +select and/or order the tests to be run based on that saved state. + +The C<--state> switch requires an argument which must be a comma +separated list of one or more of the following options. + +=over + +=item C + +Run the same tests as the last time the state was saved. This makes it +possible, for example, to recreate the ordering of a shuffled test. + + # Run all tests in random order + $ prove -b --state=save --shuffle + + # Run them again in the same order + $ prove -b --state=last + +=item C + +Run only the tests that failed on the last run. + + # Run all tests + $ prove -b --state=save + + # Run failures + $ prove -b --state=failed + +If you also specify the C option newly passing tests will be +excluded from subsequent runs. + + # Repeat until no more failures + $ prove -b --state=failed,save + +=item C + +Run only the passed tests from last time. Useful to make sure that no +new problems have been introduced. + +=item C + +Run all tests in normal order. Multple options may be specified, so to +run all tests with the failures from last time first: + + $ prove -b --state=failed,all,save + +=item C + +Run the tests that most recently failed first. The last failure time of +each test is stored. The C option causes tests to be run in most-recent- +failure order. + + $ prove -b --state=hot,save + +Tests that have never failed will not be selected. To run all tests with +the most recently failed first use + + $ prove -b --state=hot,all,save + +This combination of options may also be specified thus + + $ prove -b --state=adrian + +=item C + +Run any tests with todos. + +=item C + +Run the tests in slowest to fastest order. This is useful in conjunction +with the C<-j> parallel testing switch to ensure that your slowest tests +start running first. + + $ prove -b --state=slow -j9 + +=item C + +Run test tests in fastest to slowest order. + +=item C + +Run the tests in newest to oldest order based on the modification times +of the test scripts. + +=item C + +Run the tests in oldest to newest order. + +=item C + +Run those test scripts that have been modified since the last test run. + +=item C + +Save the state on exit. The state is stored in a file called F<.prove> +(F<_prove> on Windows and VMS) in the current directory. + +=back + +The C<--state> switch may be used more than once. + + $ prove -b --state=hot --state=all,save + +=head2 @INC + +prove introduces a separation between "options passed to the perl which +runs prove" and "options passed to the perl which runs tests"; this +distinction is by design. Thus the perl which is running a test starts +with the default C<@INC>. Additional library directories can be added +via the C environment variable, via -Ifoo in C or +via the C<-Ilib> option to F. + +=head2 Taint Mode + +Normally when a Perl program is run in taint mode the contents of the +C environment variable do not appear in C<@INC>. + +Because C is often used during testing to add build directories +to C<@INC> prove (actually L) passes the +names of any directories found in C as -I switches. The net +effect of this is that C is honoured even when prove is run in +taint mode. + +=head1 PLUGINS + +Plugins can be loaded using the C<< -PI >> syntax, eg: + + prove -PMyPlugin + +This will search for a module named C, or failing +that, C. If the plugin can't be found, C will complain & exit. + +You can pass arguments to your plugin by appending C<=arg1,arg2,etc> to the +plugin name: + + prove -PMyPlugin=fou,du,fafa + +Please check individual plugin documentation for more details. + +=head2 Available Plugins + +For an up-to-date list of plugins available, please check CPAN: + +L + +=head2 Writing Plugins + +Please see L. + +=cut + +# vim:ts=4:sw=4:et:sta diff --git a/cpan/Test-Harness/lib/App/Prove.pm b/cpan/Test-Harness/lib/App/Prove.pm new file mode 100644 index 0000000000..fd431ed2f0 --- /dev/null +++ b/cpan/Test-Harness/lib/App/Prove.pm @@ -0,0 +1,774 @@ +package App::Prove; + +use strict; +use vars qw($VERSION @ISA); + +use TAP::Object (); +use TAP::Harness; +use TAP::Parser::Utils qw( split_shell ); +use File::Spec; +use Getopt::Long; +use App::Prove::State; +use Carp; + +=head1 NAME + +App::Prove - Implements the C command. + +=head1 VERSION + +Version 3.17 + +=cut + +$VERSION = '3.17'; + +=head1 DESCRIPTION + +L provides a command, C, which runs a TAP based +test suite and prints a report. The C command is a minimal +wrapper around an instance of this module. + +=head1 SYNOPSIS + + use App::Prove; + + my $app = App::Prove->new; + $app->process_args(@ARGV); + $app->run; + +=cut + +use constant IS_WIN32 => ( $^O =~ /^(MS)?Win32$/ ); +use constant IS_VMS => $^O eq 'VMS'; +use constant IS_UNIXY => !( IS_VMS || IS_WIN32 ); + +use constant STATE_FILE => IS_UNIXY ? '.prove' : '_prove'; +use constant RC_FILE => IS_UNIXY ? '.proverc' : '_proverc'; + +use constant PLUGINS => 'App::Prove::Plugin'; + +my @ATTR; + +BEGIN { + @ISA = qw(TAP::Object); + + @ATTR = qw( + archive argv blib show_count color directives exec failures comments + formatter harness includes modules plugins jobs lib merge parse quiet + really_quiet recurse backwards shuffle taint_fail taint_warn timer + verbose warnings_fail warnings_warn show_help show_man show_version + state_class test_args state dry extension ignore_exit rules state_manager + normalize + ); + __PACKAGE__->mk_methods(@ATTR); +} + +=head1 METHODS + +=head2 Class Methods + +=head3 C + +Create a new C. Optionally a hash ref of attribute +initializers may be passed. + +=cut + +# new() implementation supplied by TAP::Object + +sub _initialize { + my $self = shift; + my $args = shift || {}; + + # setup defaults: + for my $key (qw( argv rc_opts includes modules state plugins rules )) { + $self->{$key} = []; + } + $self->{harness_class} = 'TAP::Harness'; + + for my $attr (@ATTR) { + if ( exists $args->{$attr} ) { + + # TODO: Some validation here + $self->{$attr} = $args->{$attr}; + } + } + + my %env_provides_default = ( + HARNESS_TIMER => 'timer', + ); + + while ( my ( $env, $attr ) = each %env_provides_default ) { + $self->{$attr} = 1 if $ENV{$env}; + } + $self->state_class('App::Prove::State'); + return $self; +} + +=head3 C + +Getter/setter for the name of the class used for maintaining state. This +class should either subclass from C or provide an identical +interface. + +=head3 C + +Getter/setter for the instance of the C. + +=cut + +=head3 C + + $prove->add_rc_file('myproj/.proverc'); + +Called before C to prepend the contents of an rc file to +the options. + +=cut + +sub add_rc_file { + my ( $self, $rc_file ) = @_; + + local *RC; + open RC, "<$rc_file" or croak "Can't read $rc_file ($!)"; + while ( defined( my $line = ) ) { + push @{ $self->{rc_opts} }, + grep { defined and not /^#/ } + $line =~ m{ ' ([^']*) ' | " ([^"]*) " | (\#.*) | (\S+) }xg; + } + close RC; +} + +=head3 C + + $prove->process_args(@args); + +Processes the command-line arguments. Attributes will be set +appropriately. Any filenames may be found in the C attribute. + +Dies on invalid arguments. + +=cut + +sub process_args { + my $self = shift; + + my @rc = RC_FILE; + unshift @rc, glob '~/' . RC_FILE if IS_UNIXY; + + # Preprocess meta-args. + my @args; + while ( defined( my $arg = shift ) ) { + if ( $arg eq '--norc' ) { + @rc = (); + } + elsif ( $arg eq '--rc' ) { + defined( my $rc = shift ) + or croak "Missing argument to --rc"; + push @rc, $rc; + } + elsif ( $arg =~ m{^--rc=(.+)$} ) { + push @rc, $1; + } + else { + push @args, $arg; + } + } + + # Everything after the arisdottle '::' gets passed as args to + # test programs. + if ( defined( my $stop_at = _first_pos( '::', @args ) ) ) { + my @test_args = splice @args, $stop_at; + shift @test_args; + $self->{test_args} = \@test_args; + } + + # Grab options from RC files + $self->add_rc_file($_) for grep -f, @rc; + unshift @args, @{ $self->{rc_opts} }; + + if ( my @bad = map {"-$_"} grep {/^-(man|help)$/} @args ) { + die "Long options should be written with two dashes: ", + join( ', ', @bad ), "\n"; + } + + # And finally... + + { + local @ARGV = @args; + Getopt::Long::Configure( 'no_ignore_case', 'bundling' ); + + # Don't add coderefs to GetOptions + GetOptions( + 'v|verbose' => \$self->{verbose}, + 'f|failures' => \$self->{failures}, + 'o|comments' => \$self->{comments}, + 'l|lib' => \$self->{lib}, + 'b|blib' => \$self->{blib}, + 's|shuffle' => \$self->{shuffle}, + 'color!' => \$self->{color}, + 'colour!' => \$self->{color}, + 'count!' => \$self->{show_count}, + 'c' => \$self->{color}, + 'D|dry' => \$self->{dry}, + 'ext=s' => \$self->{extension}, + 'harness=s' => \$self->{harness}, + 'ignore-exit' => \$self->{ignore_exit}, + 'formatter=s' => \$self->{formatter}, + 'r|recurse' => \$self->{recurse}, + 'reverse' => \$self->{backwards}, + 'p|parse' => \$self->{parse}, + 'q|quiet' => \$self->{quiet}, + 'Q|QUIET' => \$self->{really_quiet}, + 'e|exec=s' => \$self->{exec}, + 'm|merge' => \$self->{merge}, + 'I=s@' => $self->{includes}, + 'M=s@' => $self->{modules}, + 'P=s@' => $self->{plugins}, + 'state=s@' => $self->{state}, + 'directives' => \$self->{directives}, + 'h|help|?' => \$self->{show_help}, + 'H|man' => \$self->{show_man}, + 'V|version' => \$self->{show_version}, + 'a|archive=s' => \$self->{archive}, + 'j|jobs=i' => \$self->{jobs}, + 'timer' => \$self->{timer}, + 'T' => \$self->{taint_fail}, + 't' => \$self->{taint_warn}, + 'W' => \$self->{warnings_fail}, + 'w' => \$self->{warnings_warn}, + 'normalize' => \$self->{normalize}, + 'rules=s@' => $self->{rules}, + ) or croak('Unable to continue'); + + # Stash the remainder of argv for later + $self->{argv} = [@ARGV]; + } + + return; +} + +sub _first_pos { + my $want = shift; + for ( 0 .. $#_ ) { + return $_ if $_[$_] eq $want; + } + return; +} + +sub _help { + my ( $self, $verbosity ) = @_; + + eval('use Pod::Usage 1.12 ()'); + if ( my $err = $@ ) { + die 'Please install Pod::Usage for the --help option ' + . '(or try `perldoc prove`.)' + . "\n ($@)"; + } + + Pod::Usage::pod2usage( { -verbose => $verbosity } ); + + return; +} + +sub _color_default { + my $self = shift; + + return -t STDOUT && !$ENV{HARNESS_NOTTY} && !IS_WIN32; +} + +sub _get_args { + my $self = shift; + + my %args; + + if ( defined $self->color ? $self->color : $self->_color_default ) { + $args{color} = 1; + } + if ( !defined $self->show_count ) { + $args{show_count} = 1; + } + else { + $args{show_count} = $self->show_count; + } + + if ( $self->archive ) { + $self->require_harness( archive => 'TAP::Harness::Archive' ); + $args{archive} = $self->archive; + } + + if ( my $jobs = $self->jobs ) { + $args{jobs} = $jobs; + } + + if ( my $harness_opt = $self->harness ) { + $self->require_harness( harness => $harness_opt ); + } + + if ( my $formatter = $self->formatter ) { + $args{formatter_class} = $formatter; + } + + if ( $self->ignore_exit ) { + $args{ignore_exit} = 1; + } + + if ( $self->taint_fail && $self->taint_warn ) { + die '-t and -T are mutually exclusive'; + } + + if ( $self->warnings_fail && $self->warnings_warn ) { + die '-w and -W are mutually exclusive'; + } + + for my $a (qw( lib switches )) { + my $method = "_get_$a"; + my $val = $self->$method(); + $args{$a} = $val if defined $val; + } + + # Handle verbose, quiet, really_quiet flags + my %verb_map = ( verbose => 1, quiet => -1, really_quiet => -2, ); + + my @verb_adj = grep {$_} map { $self->$_() ? $verb_map{$_} : 0 } + keys %verb_map; + + die "Only one of verbose, quiet or really_quiet should be specified\n" + if @verb_adj > 1; + + $args{verbosity} = shift @verb_adj || 0; + + for my $a (qw( merge failures comments timer directives normalize )) { + $args{$a} = 1 if $self->$a(); + } + + $args{errors} = 1 if $self->parse; + + # defined but zero-length exec runs test files as binaries + $args{exec} = [ split( /\s+/, $self->exec ) ] + if ( defined( $self->exec ) ); + + if ( defined( my $test_args = $self->test_args ) ) { + $args{test_args} = $test_args; + } + + if ( @{ $self->rules } ) { + my @rules; + for ( @{ $self->rules } ) { + if (/^par=(.*)/) { + push @rules, $1; + } + elsif (/^seq=(.*)/) { + push @rules, { seq => $1 }; + } + } + $args{rules} = { par => [@rules] }; + } + + return ( \%args, $self->{harness_class} ); +} + +sub _find_module { + my ( $self, $class, @search ) = @_; + + croak "Bad module name $class" + unless $class =~ /^ \w+ (?: :: \w+ ) *$/x; + + for my $pfx (@search) { + my $name = join( '::', $pfx, $class ); + eval "require $name"; + return $name unless $@; + } + + eval "require $class"; + return $class unless $@; + return; +} + +sub _load_extension { + my ( $self, $name, @search ) = @_; + + my @args = (); + if ( $name =~ /^(.*?)=(.*)/ ) { + $name = $1; + @args = split( /,/, $2 ); + } + + if ( my $class = $self->_find_module( $name, @search ) ) { + $class->import(@args); + if ( $class->can('load') ) { + $class->load( { app_prove => $self, args => [@args] } ); + } + } + else { + croak "Can't load module $name"; + } +} + +sub _load_extensions { + my ( $self, $ext, @search ) = @_; + $self->_load_extension( $_, @search ) for @$ext; +} + +=head3 C + +Perform whatever actions the command line args specified. The C +command line tool consists of the following code: + + use App::Prove; + + my $app = App::Prove->new; + $app->process_args(@ARGV); + exit( $app->run ? 0 : 1 ); # if you need the exit code + +=cut + +sub run { + my $self = shift; + + unless ( $self->state_manager ) { + $self->state_manager( + $self->state_class->new( { store => STATE_FILE } ) ); + } + + if ( $self->show_help ) { + $self->_help(1); + } + elsif ( $self->show_man ) { + $self->_help(2); + } + elsif ( $self->show_version ) { + $self->print_version; + } + elsif ( $self->dry ) { + print "$_\n" for $self->_get_tests; + } + else { + + $self->_load_extensions( $self->modules ); + $self->_load_extensions( $self->plugins, PLUGINS ); + + local $ENV{TEST_VERBOSE} = 1 if $self->verbose; + + return $self->_runtests( $self->_get_args, $self->_get_tests ); + } + + return 1; +} + +sub _get_tests { + my $self = shift; + + my $state = $self->state_manager; + my $ext = $self->extension; + $state->extension($ext) if defined $ext; + if ( defined( my $state_switch = $self->state ) ) { + $state->apply_switch(@$state_switch); + } + + my @tests = $state->get_tests( $self->recurse, @{ $self->argv } ); + + $self->_shuffle(@tests) if $self->shuffle; + @tests = reverse @tests if $self->backwards; + + return @tests; +} + +sub _runtests { + my ( $self, $args, $harness_class, @tests ) = @_; + my $harness = $harness_class->new($args); + + my $state = $self->state_manager; + + $harness->callback( + after_test => sub { + $state->observe_test(@_); + } + ); + + $harness->callback( + after_runtests => sub { + $state->commit(@_); + } + ); + + my $aggregator = $harness->runtests(@tests); + + return !$aggregator->has_errors; +} + +sub _get_switches { + my $self = shift; + my @switches; + + # notes that -T or -t must be at the front of the switches! + if ( $self->taint_fail ) { + push @switches, '-T'; + } + elsif ( $self->taint_warn ) { + push @switches, '-t'; + } + if ( $self->warnings_fail ) { + push @switches, '-W'; + } + elsif ( $self->warnings_warn ) { + push @switches, '-w'; + } + + push @switches, split_shell( $ENV{HARNESS_PERL_SWITCHES} ); + + return @switches ? \@switches : (); +} + +sub _get_lib { + my $self = shift; + my @libs; + if ( $self->lib ) { + push @libs, 'lib'; + } + if ( $self->blib ) { + push @libs, 'blib/lib', 'blib/arch'; + } + if ( @{ $self->includes } ) { + push @libs, @{ $self->includes }; + } + + #24926 + @libs = map { File::Spec->rel2abs($_) } @libs; + + # Huh? + return @libs ? \@libs : (); +} + +sub _shuffle { + my $self = shift; + + # Fisher-Yates shuffle + my $i = @_; + while ($i) { + my $j = rand $i--; + @_[ $i, $j ] = @_[ $j, $i ]; + } + return; +} + +=head3 C + +Load a harness replacement class. + + $prove->require_harness($for => $class_name); + +=cut + +sub require_harness { + my ( $self, $for, $class ) = @_; + + my ($class_name) = $class =~ /^(\w+(?:::\w+)*)/; + + # Emulate Perl's -MModule=arg1,arg2 behaviour + $class =~ s!^(\w+(?:::\w+)*)=(.*)$!$1 split(/,/,q{$2})!; + + eval("use $class;"); + die "$class_name is required to use the --$for feature: $@" if $@; + + $self->{harness_class} = $class_name; + + return; +} + +=head3 C + +Display the version numbers of the loaded L and the +current Perl. + +=cut + +sub print_version { + my $self = shift; + printf( + "TAP::Harness v%s and Perl v%vd\n", + $TAP::Harness::VERSION, $^V + ); + + return; +} + +1; + +# vim:ts=4:sw=4:et:sta + +__END__ + +=head2 Attributes + +After command line parsing the following attributes reflect the values +of the corresponding command line switches. They may be altered before +calling C. + +=over + +=item C + +=item C + +=item C + +=item C + +=item C + +=item C + +=item C + +=item C + +=item C + +=item C + +=item C + +=item C + +=item C + +=item C + +=item C + +=item C + +=item C + +=item C + +=item C + +=item C + +=item C + +=item C + +=item C + +=item C + +=item C + +=item C + +=item C + +=item C + +=item C + +=item C + +=item C + +=item C + +=item C + +=item C + +=item C + +=item C + +=item C + +=item C + +=item C + +=back + +=head1 PLUGINS + +C provides support for 3rd-party plugins. These are currently +loaded at run-time, I arguments have been parsed (so you can not +change the way arguments are processed, sorry), typically with the +C<< -PI >> switch, eg: + + prove -PMyPlugin + +This will search for a module named C, or failing +that, C. If the plugin can't be found, C will complain & exit. + +You can pass an argument to your plugin by appending an C<=> after the plugin +name, eg C<-PMyPlugin=foo>. You can pass multiple arguments using commas: + + prove -PMyPlugin=foo,bar,baz + +These are passed in to your plugin's C class method (if it has one), +along with a reference to the C object that is invoking your plugin: + + sub load { + my ($class, $p) = @_; + + my @args = @{ $p->{args} }; + # @args will contain ( 'foo', 'bar', 'baz' ) + $p->{app_prove}->do_something; + ... + } + +Note that the user's arguments are also passed to your plugin's C +function as a list, eg: + + sub import { + my ($class, @args) = @_; + # @args will contain ( 'foo', 'bar', 'baz' ) + ... + } + +This is for backwards compatibility, and may be deprecated in the future. + +=head2 Sample Plugin + +Here's a sample plugin, for your reference: + + package App::Prove::Plugin::Foo; + + # Sample plugin, try running with: + # prove -PFoo=bar -r -j3 + # prove -PFoo -Q + # prove -PFoo=bar,My::Formatter + + use strict; + use warnings; + + sub load { + my ($class, $p) = @_; + my @args = @{ $p->{args} }; + my $app = $p->{app_prove}; + + print "loading plugin: $class, args: ", join(', ', @args ), "\n"; + + # turn on verbosity + $app->verbose( 1 ); + + # set the formatter? + $app->formatter( $args[1] ) if @args > 1; + + # print some of App::Prove's state: + for my $attr (qw( jobs quiet really_quiet recurse verbose )) { + my $val = $app->$attr; + $val = 'undef' unless defined( $val ); + print "$attr: $val\n"; + } + + return 1; + } + + 1; + +=head1 SEE ALSO + +L, L + +=cut diff --git a/cpan/Test-Harness/lib/App/Prove/State.pm b/cpan/Test-Harness/lib/App/Prove/State.pm new file mode 100644 index 0000000000..202f7aadd3 --- /dev/null +++ b/cpan/Test-Harness/lib/App/Prove/State.pm @@ -0,0 +1,517 @@ +package App::Prove::State; + +use strict; +use vars qw($VERSION @ISA); + +use File::Find; +use File::Spec; +use Carp; + +use App::Prove::State::Result; +use TAP::Parser::YAMLish::Reader (); +use TAP::Parser::YAMLish::Writer (); +use TAP::Base; + +BEGIN { + @ISA = qw( TAP::Base ); + __PACKAGE__->mk_methods('result_class'); +} + +use constant IS_WIN32 => ( $^O =~ /^(MS)?Win32$/ ); +use constant NEED_GLOB => IS_WIN32; + +=head1 NAME + +App::Prove::State - State storage for the C command. + +=head1 VERSION + +Version 3.17 + +=cut + +$VERSION = '3.17'; + +=head1 DESCRIPTION + +The C command supports a C<--state> option that instructs it to +store persistent state across runs. This module implements that state +and the operations that may be performed on it. + +=head1 SYNOPSIS + + # Re-run failed tests + $ prove --state=fail,save -rbv + +=cut + +=head1 METHODS + +=head2 Class Methods + +=head3 C + +Accepts a hashref with the following key/value pairs: + +=over 4 + +=item * C + +The filename of the data store holding the data that App::Prove::State reads. + +=item * C (optional) + +The test name extension. Defaults to C<.t>. + +=item * C (optional) + +The name of the C. Defaults to C. + +=back + +=cut + +# override TAP::Base::new: +sub new { + my $class = shift; + my %args = %{ shift || {} }; + + my $self = bless { + select => [], + seq => 1, + store => delete $args{store}, + extension => ( delete $args{extension} || '.t' ), + result_class => + ( delete $args{result_class} || 'App::Prove::State::Result' ), + }, $class; + + $self->{_} = $self->result_class->new( + { tests => {}, + generation => 1, + } + ); + my $store = $self->{store}; + $self->load($store) + if defined $store && -f $store; + + return $self; +} + +=head2 C + +Getter/setter for the name of the class used for tracking test results. This +class should either subclass from C or provide an +identical interface. + +=cut + +=head2 C + +Get or set the extension files must have in order to be considered +tests. Defaults to '.t'. + +=cut + +sub extension { + my $self = shift; + $self->{extension} = shift if @_; + return $self->{extension}; +} + +=head2 C + +Get the results of the last test run. Returns a C instance. + +=cut + +sub results { + my $self = shift; + $self->{_} || $self->result_class->new; +} + +=head2 C + +Save the test results. Should be called after all tests have run. + +=cut + +sub commit { + my $self = shift; + if ( $self->{should_save} ) { + $self->save; + } +} + +=head2 Instance Methods + +=head3 C + + $self->apply_switch('failed,save'); + +Apply a list of switch options to the state, updating the internal +object state as a result. Nothing is returned. + +Diagnostics: + - "Illegal state option: %s" + +=over + +=item C + +Run in the same order as last time + +=item C + +Run only the failed tests from last time + +=item C + +Run only the passed tests from last time + +=item C + +Run all tests in normal order + +=item C + +Run the tests that most recently failed first + +=item C + +Run the tests ordered by number of todos. + +=item C + +Run the tests in slowest to fastest order. + +=item C + +Run test tests in fastest to slowest order. + +=item C + +Run the tests in newest to oldest order. + +=item C + +Run the tests in oldest to newest order. + +=item C + +Save the state on exit. + +=back + +=cut + +sub apply_switch { + my $self = shift; + my @opts = @_; + + my $last_gen = $self->results->generation - 1; + my $last_run_time = $self->results->last_run_time; + my $now = $self->get_time; + + my @switches = map { split /,/ } @opts; + + my %handler = ( + last => sub { + $self->_select( + where => sub { $_->generation >= $last_gen }, + order => sub { $_->sequence } + ); + }, + failed => sub { + $self->_select( + where => sub { $_->result != 0 }, + order => sub { -$_->result } + ); + }, + passed => sub { + $self->_select( where => sub { $_->result == 0 } ); + }, + all => sub { + $self->_select(); + }, + todo => sub { + $self->_select( + where => sub { $_->num_todo != 0 }, + order => sub { -$_->num_todo; } + ); + }, + hot => sub { + $self->_select( + where => sub { defined $_->last_fail_time }, + order => sub { $now - $_->last_fail_time } + ); + }, + slow => sub { + $self->_select( order => sub { -$_->elapsed } ); + }, + fast => sub { + $self->_select( order => sub { $_->elapsed } ); + }, + new => sub { + $self->_select( order => sub { -$_->mtime } ); + }, + old => sub { + $self->_select( order => sub { $_->mtime } ); + }, + fresh => sub { + $self->_select( where => sub { $_->mtime >= $last_run_time } ); + }, + save => sub { + $self->{should_save}++; + }, + adrian => sub { + unshift @switches, qw( hot all save ); + }, + ); + + while ( defined( my $ele = shift @switches ) ) { + my ( $opt, $arg ) + = ( $ele =~ /^([^:]+):(.*)/ ) + ? ( $1, $2 ) + : ( $ele, undef ); + my $code = $handler{$opt} + || croak "Illegal state option: $opt"; + $code->($arg); + } + return; +} + +sub _select { + my ( $self, %spec ) = @_; + push @{ $self->{select} }, \%spec; +} + +=head3 C + +Given a list of args get the names of tests that should run + +=cut + +sub get_tests { + my $self = shift; + my $recurse = shift; + my @argv = @_; + my %seen; + + my @selected = $self->_query; + + unless ( @argv || @{ $self->{select} } ) { + @argv = $recurse ? '.' : 't'; + croak qq{No tests named and '@argv' directory not found} + unless -d $argv[0]; + } + + push @selected, $self->_get_raw_tests( $recurse, @argv ) if @argv; + return grep { !$seen{$_}++ } @selected; +} + +sub _query { + my $self = shift; + if ( my @sel = @{ $self->{select} } ) { + warn "No saved state, selection will be empty\n" + unless $self->results->num_tests; + return map { $self->_query_clause($_) } @sel; + } + return; +} + +sub _query_clause { + my ( $self, $clause ) = @_; + my @got; + my $results = $self->results; + my $where = $clause->{where} || sub {1}; + + # Select + for my $name ( $results->test_names ) { + next unless -f $name; + local $_ = $results->test($name); + push @got, $name if $where->(); + } + + # Sort + if ( my $order = $clause->{order} ) { + @got = map { $_->[0] } + sort { + ( defined $b->[1] <=> defined $a->[1] ) + || ( ( $a->[1] || 0 ) <=> ( $b->[1] || 0 ) ) + } map { + [ $_, + do { local $_ = $results->test($_); $order->() } + ] + } @got; + } + + return @got; +} + +sub _get_raw_tests { + my $self = shift; + my $recurse = shift; + my @argv = @_; + my @tests; + + # Do globbing on Win32. + @argv = map { glob "$_" } @argv if NEED_GLOB; + my $extension = $self->{extension}; + + for my $arg (@argv) { + if ( '-' eq $arg ) { + push @argv => ; + chomp(@argv); + next; + } + + push @tests, + sort -d $arg + ? $recurse + ? $self->_expand_dir_recursive( $arg, $extension ) + : glob( File::Spec->catfile( $arg, "*$extension" ) ) + : $arg; + } + return @tests; +} + +sub _expand_dir_recursive { + my ( $self, $dir, $extension ) = @_; + + my @tests; + find( + { follow => 1, #21938 + follow_skip => 2, + wanted => sub { + -f + && /\Q$extension\E$/ + && push @tests => $File::Find::name; + } + }, + $dir + ); + return @tests; +} + +=head3 C + +Store the results of a test. + +=cut + +# Store: +# last fail time +# last pass time +# last run time +# most recent result +# most recent todos +# total failures +# total passes +# state generation +# parser + +sub observe_test { + + my ( $self, $test_info, $parser ) = @_; + my $name = $test_info->[0]; + my $fail = scalar( $parser->failed ) + ( $parser->has_problems ? 1 : 0 ); + my $todo = scalar( $parser->todo ); + my $start_time = $parser->start_time; + my $end_time = $parser->end_time, + + my $test = $self->results->test($name); + + $test->sequence( $self->{seq}++ ); + $test->generation( $self->results->generation ); + + $test->run_time($end_time); + $test->result($fail); + $test->num_todo($todo); + $test->elapsed( $end_time - $start_time ); + + $test->parser($parser); + + if ($fail) { + $test->total_failures( $test->total_failures + 1 ); + $test->last_fail_time($end_time); + } + else { + $test->total_passes( $test->total_passes + 1 ); + $test->last_pass_time($end_time); + } +} + +=head3 C + +Write the state to a file. + +=cut + +sub save { + my ($self) = @_; + + my $store = $self->{store} or return; + $self->results->last_run_time( $self->get_time ); + + my $writer = TAP::Parser::YAMLish::Writer->new; + local *FH; + open FH, ">$store" or croak "Can't write $store ($!)"; + $writer->write( $self->results->raw, \*FH ); + close FH; +} + +=head3 C + +Load the state from a file + +=cut + +sub load { + my ( $self, $name ) = @_; + my $reader = TAP::Parser::YAMLish::Reader->new; + local *FH; + open FH, "<$name" or croak "Can't read $name ($!)"; + + # XXX this is temporary + $self->{_} = $self->result_class->new( + $reader->read( + sub { + my $line = ; + defined $line && chomp $line; + return $line; + } + ) + ); + + # $writer->write( $self->{tests} || {}, \*FH ); + close FH; + $self->_regen_seq; + $self->_prune_and_stamp; + $self->results->generation( $self->results->generation + 1 ); +} + +sub _prune_and_stamp { + my $self = shift; + + my $results = $self->results; + my @tests = $self->results->tests; + for my $test (@tests) { + my $name = $test->name; + if ( my @stat = stat $name ) { + $test->mtime( $stat[9] ); + } + else { + $results->remove($name); + } + } +} + +sub _regen_seq { + my $self = shift; + for my $test ( $self->results->tests ) { + $self->{seq} = $test->sequence + 1 + if defined $test->sequence && $test->sequence >= $self->{seq}; + } +} + +1; diff --git a/cpan/Test-Harness/lib/App/Prove/State/Result.pm b/cpan/Test-Harness/lib/App/Prove/State/Result.pm new file mode 100644 index 0000000000..274676a62f --- /dev/null +++ b/cpan/Test-Harness/lib/App/Prove/State/Result.pm @@ -0,0 +1,233 @@ +package App::Prove::State::Result; + +use strict; +use Carp 'croak'; + +use App::Prove::State::Result::Test; +use vars qw($VERSION); + +use constant STATE_VERSION => 1; + +=head1 NAME + +App::Prove::State::Result - Individual test suite results. + +=head1 VERSION + +Version 3.17 + +=cut + +$VERSION = '3.17'; + +=head1 DESCRIPTION + +The C command supports a C<--state> option that instructs it to +store persistent state across runs. This module encapsulates the results for a +single test suite run. + +=head1 SYNOPSIS + + # Re-run failed tests + $ prove --state=fail,save -rbv + +=cut + +=head1 METHODS + +=head2 Class Methods + +=head3 C + + my $result = App::Prove::State::Result->new({ + generation => $generation, + tests => \%tests, + }); + +Returns a new C instance. + +=cut + +sub new { + my ( $class, $arg_for ) = @_; + $arg_for ||= {}; + my %instance_data = %$arg_for; # shallow copy + $instance_data{version} = $class->state_version; + my $tests = delete $instance_data{tests} || {}; + my $self = bless \%instance_data => $class; + $self->_initialize($tests); + return $self; +} + +sub _initialize { + my ( $self, $tests ) = @_; + my %tests; + while ( my ( $name, $test ) = each %$tests ) { + $tests{$name} = $self->test_class->new( + { %$test, + name => $name + } + ); + } + $self->tests( \%tests ); + return $self; +} + +=head2 C + +Returns the current version of state storage. + +=cut + +sub state_version {STATE_VERSION} + +=head2 C + +Returns the name of the class used for tracking individual tests. This class +should either subclass from C or provide an +identical interface. + +=cut + +sub test_class { + return 'App::Prove::State::Result::Test'; +} + +my %methods = ( + generation => { method => 'generation', default => 0 }, + last_run_time => { method => 'last_run_time', default => undef }, +); + +while ( my ( $key, $description ) = each %methods ) { + my $default = $description->{default}; + no strict 'refs'; + *{ $description->{method} } = sub { + my $self = shift; + if (@_) { + $self->{$key} = shift; + return $self; + } + return $self->{$key} || $default; + }; +} + +=head3 C + +Getter/setter for the "generation" of the test suite run. The first +generation is 1 (one) and subsequent generations are 2, 3, etc. + +=head3 C + +Getter/setter for the time of the test suite run. + +=head3 C + +Returns the tests for a given generation. This is a hashref or a hash, +depending on context called. The keys to the hash are the individual +test names and the value is a hashref with various interesting values. +Each k/v pair might resemble something like this: + + 't/foo.t' => { + elapsed => '0.0428488254547119', + gen => '7', + last_pass_time => '1219328376.07815', + last_result => '0', + last_run_time => '1219328376.07815', + last_todo => '0', + mtime => '1191708862', + seq => '192', + total_passes => '6', + } + +=cut + +sub tests { + my $self = shift; + if (@_) { + $self->{tests} = shift; + return $self; + } + my %tests = %{ $self->{tests} }; + my @tests = sort { $a->sequence <=> $b->sequence } values %tests; + return wantarray ? @tests : \@tests; +} + +=head3 C + + my $test = $result->test('t/customer/create.t'); + +Returns an individual C instance for the +given test name (usually the filename). Will return a new +C instance if the name is not found. + +=cut + +sub test { + my ( $self, $name ) = @_; + croak("test() requires a test name") unless defined $name; + + my $tests = $self->{tests} ||= {}; + if ( my $test = $tests->{$name} ) { + return $test; + } + else { + my $test = $self->test_class->new( { name => $name } ); + $self->{tests}->{$name} = $test; + return $test; + } +} + +=head3 C + +Returns an list of test names, sorted by run order. + +=cut + +sub test_names { + my $self = shift; + return map { $_->name } $self->tests; +} + +=head3 C + + $result->remove($test_name); # remove the test + my $test = $result->test($test_name); # fatal error + +Removes a given test from results. This is a no-op if the test name is not +found. + +=cut + +sub remove { + my ( $self, $name ) = @_; + delete $self->{tests}->{$name}; + return $self; +} + +=head3 C + +Returns the number of tests for a given test suite result. + +=cut + +sub num_tests { keys %{ shift->{tests} } } + +=head3 C + +Returns a hashref of raw results, suitable for serialization by YAML. + +=cut + +sub raw { + my $self = shift; + my %raw = %$self; + + my %tests; + foreach my $test ( $self->tests ) { + $tests{ $test->name } = $test->raw; + } + $raw{tests} = \%tests; + return \%raw; +} + +1; diff --git a/cpan/Test-Harness/lib/App/Prove/State/Result/Test.pm b/cpan/Test-Harness/lib/App/Prove/State/Result/Test.pm new file mode 100644 index 0000000000..231f78919e --- /dev/null +++ b/cpan/Test-Harness/lib/App/Prove/State/Result/Test.pm @@ -0,0 +1,153 @@ +package App::Prove::State::Result::Test; + +use strict; + +use vars qw($VERSION); + +=head1 NAME + +App::Prove::State::Result::Test - Individual test results. + +=head1 VERSION + +Version 3.17 + +=cut + +$VERSION = '3.17'; + +=head1 DESCRIPTION + +The C command supports a C<--state> option that instructs it to +store persistent state across runs. This module encapsulates the results for a +single test. + +=head1 SYNOPSIS + + # Re-run failed tests + $ prove --state=fail,save -rbv + +=cut + +my %methods = ( + name => { method => 'name' }, + elapsed => { method => 'elapsed', default => 0 }, + gen => { method => 'generation', default => 1 }, + last_pass_time => { method => 'last_pass_time', default => undef }, + last_fail_time => { method => 'last_fail_time', default => undef }, + last_result => { method => 'result', default => 0 }, + last_run_time => { method => 'run_time', default => undef }, + last_todo => { method => 'num_todo', default => 0 }, + mtime => { method => 'mtime', default => undef }, + seq => { method => 'sequence', default => 1 }, + total_passes => { method => 'total_passes', default => 0 }, + total_failures => { method => 'total_failures', default => 0 }, + parser => { method => 'parser' }, +); + +while ( my ( $key, $description ) = each %methods ) { + my $default = $description->{default}; + no strict 'refs'; + *{ $description->{method} } = sub { + my $self = shift; + if (@_) { + $self->{$key} = shift; + return $self; + } + return $self->{$key} || $default; + }; +} + +=head1 METHODS + +=head2 Class Methods + +=head3 C + +=cut + +sub new { + my ( $class, $arg_for ) = @_; + $arg_for ||= {}; + bless $arg_for => $class; +} + +=head2 Instance Methods + +=head3 C + +The name of the test. Usually a filename. + +=head3 C + +The total elapsed times the test took to run, in seconds from the epoch.. + +=head3 C + +The number for the "generation" of the test run. The first generation is 1 +(one) and subsequent generations are 2, 3, etc. + +=head3 C + +The last time the test program passed, in seconds from the epoch. + +Returns C if the program has never passed. + +=head3 C + +The last time the test suite failed, in seconds from the epoch. + +Returns C if the program has never failed. + +=head3 C + +Returns the mtime of the test, in seconds from the epoch. + +=head3 C + +Returns a hashref of raw test data, suitable for serialization by YAML. + +=head3 C + +Currently, whether or not the test suite passed with no 'problems' (such as +TODO passed). + +=head3 C + +The total time it took for the test to run, in seconds. If C is +available, it will have finer granularity. + +=head3 C + +The number of tests with TODO directives. + +=head3 C + +The order in which this test was run for the given test suite result. + +=head3 C + +The number of times the test has passed. + +=head3 C + +The number of times the test has failed. + +=head3 C + +The underlying parser object. This is useful if you need the full +information for the test program. + +=cut + +sub raw { + my $self = shift; + my %raw = %$self; + + # this is backwards-compatibility hack and is not guaranteed. + delete $raw{name}; + delete $raw{parser}; + return \%raw; +} + +1; diff --git a/cpan/Test-Harness/lib/TAP/Base.pm b/cpan/Test-Harness/lib/TAP/Base.pm new file mode 100644 index 0000000000..f88ad11134 --- /dev/null +++ b/cpan/Test-Harness/lib/TAP/Base.pm @@ -0,0 +1,129 @@ +package TAP::Base; + +use strict; +use vars qw($VERSION @ISA); + +use TAP::Object; + +@ISA = qw(TAP::Object); + +=head1 NAME + +TAP::Base - Base class that provides common functionality to L +and L + +=head1 VERSION + +Version 3.17 + +=cut + +$VERSION = '3.17'; + +use constant GOT_TIME_HIRES => do { + eval 'use Time::HiRes qw(time);'; + $@ ? 0 : 1; +}; + +=head1 SYNOPSIS + + package TAP::Whatever; + + use TAP::Base; + + use vars qw($VERSION @ISA); + @ISA = qw(TAP::Base); + + # ... later ... + + my $thing = TAP::Whatever->new(); + + $thing->callback( event => sub { + # do something interesting + } ); + +=head1 DESCRIPTION + +C provides callback management. + +=head1 METHODS + +=head2 Class Methods + +=cut + +sub _initialize { + my ( $self, $arg_for, $ok_callback ) = @_; + + my %ok_map = map { $_ => 1 } @$ok_callback; + + $self->{ok_callbacks} = \%ok_map; + + if ( my $cb = delete $arg_for->{callbacks} ) { + while ( my ( $event, $callback ) = each %$cb ) { + $self->callback( $event, $callback ); + } + } + + return $self; +} + +=head3 C + +Install a callback for a named event. + +=cut + +sub callback { + my ( $self, $event, $callback ) = @_; + + my %ok_map = %{ $self->{ok_callbacks} }; + + $self->_croak('No callbacks may be installed') + unless %ok_map; + + $self->_croak( "Callback $event is not supported. Valid callbacks are " + . join( ', ', sort keys %ok_map ) ) + unless exists $ok_map{$event}; + + push @{ $self->{code_for}{$event} }, $callback; + + return; +} + +sub _has_callbacks { + my $self = shift; + return keys %{ $self->{code_for} } != 0; +} + +sub _callback_for { + my ( $self, $event ) = @_; + return $self->{code_for}{$event}; +} + +sub _make_callback { + my $self = shift; + my $event = shift; + + my $cb = $self->_callback_for($event); + return unless defined $cb; + return map { $_->(@_) } @$cb; +} + +=head3 C + +Return the current time using Time::HiRes if available. + +=cut + +sub get_time { return time() } + +=head3 C + +Return true if the time returned by get_time is high resolution (i.e. if Time::HiRes is available). + +=cut + +sub time_is_hires { return GOT_TIME_HIRES } + +1; diff --git a/cpan/Test-Harness/lib/TAP/Formatter/Base.pm b/cpan/Test-Harness/lib/TAP/Formatter/Base.pm new file mode 100644 index 0000000000..f2b54a9ba3 --- /dev/null +++ b/cpan/Test-Harness/lib/TAP/Formatter/Base.pm @@ -0,0 +1,449 @@ +package TAP::Formatter::Base; + +use strict; +use TAP::Base (); +use POSIX qw(strftime); + +use vars qw($VERSION @ISA); + +my $MAX_ERRORS = 5; +my %VALIDATION_FOR; + +BEGIN { + @ISA = qw(TAP::Base); + + %VALIDATION_FOR = ( + directives => sub { shift; shift }, + verbosity => sub { shift; shift }, + normalize => sub { shift; shift }, + timer => sub { shift; shift }, + failures => sub { shift; shift }, + comments => sub { shift; shift }, + errors => sub { shift; shift }, + color => sub { shift; shift }, + jobs => sub { shift; shift }, + show_count => sub { shift; shift }, + stdout => sub { + my ( $self, $ref ) = @_; + $self->_croak("option 'stdout' needs a filehandle") + unless ( ref $ref || '' ) eq 'GLOB' + or eval { $ref->can('print') }; + return $ref; + }, + ); + + my @getter_setters = qw( + _longest + _printed_summary_header + _colorizer + ); + + __PACKAGE__->mk_methods( @getter_setters, keys %VALIDATION_FOR ); +} + +=head1 NAME + +TAP::Formatter::Console - Harness output delegate for default console output + +=head1 VERSION + +Version 3.17 + +=cut + +$VERSION = '3.17'; + +=head1 DESCRIPTION + +This provides console orientated output formatting for TAP::Harness. + +=head1 SYNOPSIS + + use TAP::Formatter::Console; + my $harness = TAP::Formatter::Console->new( \%args ); + +=cut + +sub _initialize { + my ( $self, $arg_for ) = @_; + $arg_for ||= {}; + + $self->SUPER::_initialize($arg_for); + my %arg_for = %$arg_for; # force a shallow copy + + $self->verbosity(0); + + for my $name ( keys %VALIDATION_FOR ) { + my $property = delete $arg_for{$name}; + if ( defined $property ) { + my $validate = $VALIDATION_FOR{$name}; + $self->$name( $self->$validate($property) ); + } + } + + if ( my @props = keys %arg_for ) { + $self->_croak( + "Unknown arguments to " . __PACKAGE__ . "::new (@props)" ); + } + + $self->stdout( \*STDOUT ) unless $self->stdout; + + if ( $self->color ) { + require TAP::Formatter::Color; + $self->_colorizer( TAP::Formatter::Color->new ); + } + + return $self; +} + +sub verbose { shift->verbosity >= 1 } +sub quiet { shift->verbosity <= -1 } +sub really_quiet { shift->verbosity <= -2 } +sub silent { shift->verbosity <= -3 } + +=head1 METHODS + +=head2 Class Methods + +=head3 C + + my %args = ( + verbose => 1, + ) + my $harness = TAP::Formatter::Console->new( \%args ); + +The constructor returns a new C object. If +a L is created with no C a +C is automatically created. If any of the +following options were given to TAP::Harness->new they well be passed to +this constructor which accepts an optional hashref whose allowed keys are: + +=over 4 + +=item * C + +Set the verbosity level. + +=item * C + +Printing individual test results to STDOUT. + +=item * C + +Append run time for each test to output. Uses L if available. + +=item * C + +Show test failures (this is a no-op if C is selected). + +=item * C + +Show test comments (this is a no-op if C is selected). + +=item * C + +Suppressing some test output (mostly failures while tests are running). + +=item * C + +Suppressing everything but the tests summary. + +=item * C + +Suppressing all output. + +=item * C + +If parse errors are found in the TAP output, a note of this will be made +in the summary report. To see all of the parse errors, set this argument to +true: + + errors => 1 + +=item * C + +If set to a true value, only test results with directives will be displayed. +This overrides other settings such as C, C, or C. + +=item * C + +A filehandle for catching standard output. + +=item * C + +If defined specifies whether color output is desired. If C is not +defined it will default to color output if color support is available on +the current platform and output is not being redirected. + +=item * C + +The number of concurrent jobs this formatter will handle. + +=item * C + +Boolean value. If false, disables the C test count which shows up while +tests are running. + +=back + +Any keys for which the value is C will be ignored. + +=cut + +# new supplied by TAP::Base + +=head3 C + +Called by Test::Harness before any test output is generated. + +This is an advisory and may not be called in the case where tests are +being supplied to Test::Harness by an iterator. + +=cut + +sub prepare { + my ( $self, @tests ) = @_; + + my $longest = 0; + + foreach my $test (@tests) { + $longest = length $test if length $test > $longest; + } + + $self->_longest($longest); +} + +sub _format_now { strftime "[%H:%M:%S]", localtime } + +sub _format_name { + my ( $self, $test ) = @_; + my $name = $test; + my $periods = '.' x ( $self->_longest + 2 - length $test ); + $periods = " $periods "; + + if ( $self->timer ) { + my $stamp = $self->_format_now(); + return "$stamp $name$periods"; + } + else { + return "$name$periods"; + } + +} + +=head3 C + +Called to create a new test session. A test session looks like this: + + my $session = $formatter->open_test( $test, $parser ); + while ( defined( my $result = $parser->next ) ) { + $session->result($result); + exit 1 if $result->is_bailout; + } + $session->close_test; + +=cut + +sub open_test { + die "Unimplemented."; +} + +sub _output_success { + my ( $self, $msg ) = @_; + $self->_output($msg); +} + +=head3 C + + $harness->summary( $aggregate ); + +C prints the summary report after all tests are run. The argument is +an aggregate. + +=cut + +sub summary { + my ( $self, $aggregate ) = @_; + + return if $self->silent; + + my @t = $aggregate->descriptions; + my $tests = \@t; + + my $runtime = $aggregate->elapsed_timestr; + + my $total = $aggregate->total; + my $passed = $aggregate->passed; + + if ( $self->timer ) { + $self->_output( $self->_format_now(), "\n" ); + } + + # TODO: Check this condition still works when all subtests pass but + # the exit status is nonzero + + if ( $aggregate->all_passed ) { + $self->_output_success("All tests successful.\n"); + } + + # ~TODO option where $aggregate->skipped generates reports + if ( $total != $passed or $aggregate->has_problems ) { + $self->_output("\nTest Summary Report"); + $self->_output("\n-------------------\n"); + foreach my $test (@$tests) { + $self->_printed_summary_header(0); + my ($parser) = $aggregate->parsers($test); + $self->_output_summary_failure( + 'failed', + [ ' Failed test: ', ' Failed tests: ' ], + $test, $parser + ); + $self->_output_summary_failure( + 'todo_passed', + " TODO passed: ", $test, $parser + ); + + # ~TODO this cannot be the default + #$self->_output_summary_failure( 'skipped', " Tests skipped: " ); + + if ( my $exit = $parser->exit ) { + $self->_summary_test_header( $test, $parser ); + $self->_failure_output(" Non-zero exit status: $exit\n"); + } + elsif ( my $wait = $parser->wait ) { + $self->_summary_test_header( $test, $parser ); + $self->_failure_output(" Non-zero wait status: $wait\n"); + } + + if ( my @errors = $parser->parse_errors ) { + my $explain; + if ( @errors > $MAX_ERRORS && !$self->errors ) { + $explain + = "Displayed the first $MAX_ERRORS of " + . scalar(@errors) + . " TAP syntax errors.\n" + . "Re-run prove with the -p option to see them all.\n"; + splice @errors, $MAX_ERRORS; + } + $self->_summary_test_header( $test, $parser ); + $self->_failure_output( + sprintf " Parse errors: %s\n", + shift @errors + ); + foreach my $error (@errors) { + my $spaces = ' ' x 16; + $self->_failure_output("$spaces$error\n"); + } + $self->_failure_output($explain) if $explain; + } + } + } + my $files = @$tests; + $self->_output("Files=$files, Tests=$total, $runtime\n"); + my $status = $aggregate->get_status; + $self->_output("Result: $status\n"); +} + +sub _output_summary_failure { + my ( $self, $method, $name, $test, $parser ) = @_; + + # ugly hack. Must rethink this :( + my $output = $method eq 'failed' ? '_failure_output' : '_output'; + + if ( my @r = $parser->$method() ) { + $self->_summary_test_header( $test, $parser ); + my ( $singular, $plural ) + = 'ARRAY' eq ref $name ? @$name : ( $name, $name ); + $self->$output( @r == 1 ? $singular : $plural ); + my @results = $self->_balanced_range( 40, @r ); + $self->$output( sprintf "%s\n" => shift @results ); + my $spaces = ' ' x 16; + while (@results) { + $self->$output( sprintf "$spaces%s\n" => shift @results ); + } + } +} + +sub _summary_test_header { + my ( $self, $test, $parser ) = @_; + return if $self->_printed_summary_header; + my $spaces = ' ' x ( $self->_longest - length $test ); + $spaces = ' ' unless $spaces; + my $output = $self->_get_output_method($parser); + $self->$output( + sprintf "$test$spaces(Wstat: %d Tests: %d Failed: %d)\n", + $parser->wait, $parser->tests_run, scalar $parser->failed + ); + $self->_printed_summary_header(1); +} + +sub _output { + my $self = shift; + + print { $self->stdout } @_; +} + +sub _failure_output { + my $self = shift; + + $self->_output(@_); +} + +sub _balanced_range { + my ( $self, $limit, @range ) = @_; + @range = $self->_range(@range); + my $line = ""; + my @lines; + my $curr = 0; + while (@range) { + if ( $curr < $limit ) { + my $range = ( shift @range ) . ", "; + $line .= $range; + $curr += length $range; + } + elsif (@range) { + $line =~ s/, $//; + push @lines => $line; + $line = ''; + $curr = 0; + } + } + if ($line) { + $line =~ s/, $//; + push @lines => $line; + } + return @lines; +} + +sub _range { + my ( $self, @numbers ) = @_; + + # shouldn't be needed, but subclasses might call this + @numbers = sort { $a <=> $b } @numbers; + my ( $min, @range ); + + foreach my $i ( 0 .. $#numbers ) { + my $num = $numbers[$i]; + my $next = $numbers[ $i + 1 ]; + if ( defined $next && $next == $num + 1 ) { + if ( !defined $min ) { + $min = $num; + } + } + elsif ( defined $min ) { + push @range => "$min-$num"; + undef $min; + } + else { + push @range => $num; + } + } + return @range; +} + +sub _get_output_method { + my ( $self, $parser ) = @_; + return $parser->has_problems ? '_failure_output' : '_output'; +} + +1; diff --git a/cpan/Test-Harness/lib/TAP/Formatter/Color.pm b/cpan/Test-Harness/lib/TAP/Formatter/Color.pm new file mode 100644 index 0000000000..349d3b84bf --- /dev/null +++ b/cpan/Test-Harness/lib/TAP/Formatter/Color.pm @@ -0,0 +1,148 @@ +package TAP::Formatter::Color; + +use strict; +use vars qw($VERSION @ISA); + +use constant IS_WIN32 => ( $^O =~ /^(MS)?Win32$/ ); + +@ISA = qw(TAP::Object); + +my $NO_COLOR; + +BEGIN { + $NO_COLOR = 0; + + if (IS_WIN32) { + eval 'use Win32::Console'; + if ($@) { + $NO_COLOR = $@; + } + else { + my $console = Win32::Console->new( STD_OUTPUT_HANDLE() ); + + # eval here because we might not know about these variables + my $fg = eval '$FG_LIGHTGRAY'; + my $bg = eval '$BG_BLACK'; + + *set_color = sub { + my ( $self, $output, $color ) = @_; + + my $var; + if ( $color eq 'reset' ) { + $fg = eval '$FG_LIGHTGRAY'; + $bg = eval '$BG_BLACK'; + } + elsif ( $color =~ /^on_(.+)$/ ) { + $bg = eval '$BG_' . uc($1); + } + else { + $fg = eval '$FG_' . uc($color); + } + + # In case of colors that aren't defined + $self->set_color('reset') + unless defined $bg && defined $fg; + + $console->Attr( $bg | $fg ); + }; + } + } + else { + eval 'use Term::ANSIColor'; + if ($@) { + $NO_COLOR = $@; + } + else { + *set_color = sub { + my ( $self, $output, $color ) = @_; + $output->( color($color) ); + }; + } + } + + if ($NO_COLOR) { + *set_color = sub { }; + } +} + +=head1 NAME + +TAP::Formatter::Color - Run Perl test scripts with color + +=head1 VERSION + +Version 3.17 + +=cut + +$VERSION = '3.17'; + +=head1 DESCRIPTION + +Note that this harness is I. You may not like the colors I've +chosen and I haven't yet provided an easy way to override them. + +This test harness is the same as L, but test results are output +in color. Passing tests are printed in green. Failing tests are in red. +Skipped tests are blue on a white background and TODO tests are printed in +white. + +If L cannot be found (or L if running +under Windows) tests will be run without color. + +=head1 SYNOPSIS + + use TAP::Formatter::Color; + my $harness = TAP::Formatter::Color->new( \%args ); + $harness->runtests(@tests); + +=head1 METHODS + +=head2 Class Methods + +=head3 C + +The constructor returns a new C object. If +L is not installed, returns undef. + +=cut + +# new() implementation supplied by TAP::Object + +sub _initialize { + my $self = shift; + + if ($NO_COLOR) { + + # shorten that message a bit + ( my $error = $NO_COLOR ) =~ s/ in \@INC .*//s; + warn "Note: Cannot run tests in color: $error\n"; + return; # abort object construction + } + + return $self; +} + +############################################################################## + +=head3 C + + Test::Formatter::Color->can_color() + +Returns a boolean indicating whether or not this module can actually +generate colored output. This will be false if it could not load the +modules needed for the current platform. + +=cut + +sub can_color { + return !$NO_COLOR; +} + +=head3 C + +Set the output color. + +=cut + +1; diff --git a/cpan/Test-Harness/lib/TAP/Formatter/Console.pm b/cpan/Test-Harness/lib/TAP/Formatter/Console.pm new file mode 100644 index 0000000000..aeca2f2b0d --- /dev/null +++ b/cpan/Test-Harness/lib/TAP/Formatter/Console.pm @@ -0,0 +1,91 @@ +package TAP::Formatter::Console; + +use strict; +use TAP::Formatter::Base (); +use POSIX qw(strftime); + +use vars qw($VERSION @ISA); + +@ISA = qw(TAP::Formatter::Base); + +=head1 NAME + +TAP::Formatter::Console - Harness output delegate for default console output + +=head1 VERSION + +Version 3.17 + +=cut + +$VERSION = '3.17'; + +=head1 DESCRIPTION + +This provides console orientated output formatting for TAP::Harness. + +=head1 SYNOPSIS + + use TAP::Formatter::Console; + my $harness = TAP::Formatter::Console->new( \%args ); + +=head2 C<< open_test >> + +See L + +=cut + +sub open_test { + my ( $self, $test, $parser ) = @_; + + my $class + = $self->jobs > 1 + ? 'TAP::Formatter::Console::ParallelSession' + : 'TAP::Formatter::Console::Session'; + + eval "require $class"; + $self->_croak($@) if $@; + + my $session = $class->new( + { name => $test, + formatter => $self, + parser => $parser, + show_count => $self->show_count, + } + ); + + $session->header; + + return $session; +} + +# Use _colorizer delegate to set output color. NOP if we have no delegate +sub _set_colors { + my ( $self, @colors ) = @_; + if ( my $colorizer = $self->_colorizer ) { + my $output_func = $self->{_output_func} ||= sub { + $self->_output(@_); + }; + $colorizer->set_color( $output_func, $_ ) for @colors; + } +} + +sub _output_success { + my ( $self, $msg ) = @_; + $self->_set_colors('green'); + $self->_output($msg); + $self->_set_colors('reset'); +} + +sub _failure_output { + my $self = shift; + $self->_set_colors('red'); + my $out = join '', @_; + my $has_newline = chomp $out; + $self->_output($out); + $self->_set_colors('reset'); + $self->_output($/) + if $has_newline; +} + +1; diff --git a/cpan/Test-Harness/lib/TAP/Formatter/Console/ParallelSession.pm b/cpan/Test-Harness/lib/TAP/Formatter/Console/ParallelSession.pm new file mode 100644 index 0000000000..b6b5134cda --- /dev/null +++ b/cpan/Test-Harness/lib/TAP/Formatter/Console/ParallelSession.pm @@ -0,0 +1,202 @@ +package TAP::Formatter::Console::ParallelSession; + +use strict; +use File::Spec; +use File::Path; +use TAP::Formatter::Console::Session; +use Carp; + +use constant WIDTH => 72; # Because Eric says +use vars qw($VERSION @ISA); + +@ISA = qw(TAP::Formatter::Console::Session); + +my %shared; + +sub _initialize { + my ( $self, $arg_for ) = @_; + + $self->SUPER::_initialize($arg_for); + my $formatter = $self->formatter; + + # Horrid bodge. This creates our shared context per harness. Maybe + # TAP::Harness should give us this? + my $context = $shared{$formatter} ||= $self->_create_shared_context; + push @{ $context->{active} }, $self; + + return $self; +} + +sub _create_shared_context { + my $self = shift; + return { + active => [], + tests => 0, + fails => 0, + }; +} + +=head1 NAME + +TAP::Formatter::Console::ParallelSession - Harness output delegate for parallel console output + +=head1 VERSION + +Version 3.17 + +=cut + +$VERSION = '3.17'; + +=head1 DESCRIPTION + +This provides console orientated output formatting for L +when run with multiple L. + +=head1 SYNOPSIS + +=cut + +=head1 METHODS + +=head2 Class Methods + +=head3 C
+ +Output test preamble + +=cut + +sub header { +} + +sub _clear_ruler { + my $self = shift; + $self->formatter->_output( "\r" . ( ' ' x WIDTH ) . "\r" ); +} + +my $now = 0; +my $start; + +my $trailer = '... )==='; +my $chop_length = WIDTH - length $trailer; + +sub _output_ruler { + my ( $self, $refresh ) = @_; + my $new_now = time; + return if $new_now == $now and !$refresh; + $now = $new_now; + $start ||= $now; + my $formatter = $self->formatter; + return if $formatter->really_quiet; + + my $context = $shared{$formatter}; + + my $ruler = sprintf '===( %7d;%d ', $context->{tests}, $now - $start; + + foreach my $active ( @{ $context->{active} } ) { + my $parser = $active->parser; + my $tests = $parser->tests_run; + my $planned = $parser->tests_planned || '?'; + + $ruler .= sprintf '%' . length($planned) . "d/$planned ", $tests; + } + chop $ruler; # Remove a trailing space + $ruler .= ')==='; + + if ( length $ruler > WIDTH ) { + $ruler =~ s/(.{$chop_length}).*/$1$trailer/o; + } + else { + $ruler .= '=' x ( WIDTH - length($ruler) ); + } + $formatter->_output("\r$ruler"); +} + +=head3 C + + Called by the harness for each line of TAP it receives . + +=cut + +sub result { + my ( $self, $result ) = @_; + my $formatter = $self->formatter; + + # my $really_quiet = $formatter->really_quiet; + # my $show_count = $self->_should_show_count; + + if ( $result->is_test ) { + my $context = $shared{$formatter}; + $context->{tests}++; + + my $active = $context->{active}; + if ( @$active == 1 ) { + + # There is only one test, so use the serial output format. + return $self->SUPER::result($result); + } + + $self->_output_ruler( $self->parser->tests_run == 1 ); + } + elsif ( $result->is_bailout ) { + $formatter->_failure_output( + "Bailout called. Further testing stopped: " + . $result->explanation + . "\n" ); + } +} + +=head3 C + +=cut + +sub clear_for_close { + my $self = shift; + my $formatter = $self->formatter; + return if $formatter->really_quiet; + my $context = $shared{$formatter}; + if ( @{ $context->{active} } == 1 ) { + $self->SUPER::clear_for_close; + } + else { + $self->_clear_ruler; + } +} + +=head3 C + +=cut + +sub close_test { + my $self = shift; + my $name = $self->name; + my $parser = $self->parser; + my $formatter = $self->formatter; + my $context = $shared{$formatter}; + + $self->SUPER::close_test; + + my $active = $context->{active}; + + my @pos = grep { $active->[$_]->name eq $name } 0 .. $#$active; + + die "Can't find myself" unless @pos; + splice @$active, $pos[0], 1; + + if ( @$active > 1 ) { + $self->_output_ruler(1); + } + elsif ( @$active == 1 ) { + + # Print out "test/name.t ...." + $active->[0]->SUPER::header; + } + else { + + # $self->formatter->_output("\n"); + delete $shared{$formatter}; + } +} + +1; diff --git a/cpan/Test-Harness/lib/TAP/Formatter/Console/Session.pm b/cpan/Test-Harness/lib/TAP/Formatter/Console/Session.pm new file mode 100644 index 0000000000..675512c71d --- /dev/null +++ b/cpan/Test-Harness/lib/TAP/Formatter/Console/Session.pm @@ -0,0 +1,219 @@ +package TAP::Formatter::Console::Session; + +use strict; +use TAP::Formatter::Session; + +use vars qw($VERSION @ISA); + +@ISA = qw(TAP::Formatter::Session); + +my @ACCESSOR; + +BEGIN { + my @CLOSURE_BINDING = qw( header result clear_for_close close_test ); + + for my $method (@CLOSURE_BINDING) { + no strict 'refs'; + *$method = sub { + my $self = shift; + return ( $self->{_closures} ||= $self->_closures )->{$method} + ->(@_); + }; + } +} + +=head1 NAME + +TAP::Formatter::Console::Session - Harness output delegate for default console output + +=head1 VERSION + +Version 3.17 + +=cut + +$VERSION = '3.17'; + +=head1 DESCRIPTION + +This provides console orientated output formatting for TAP::Harness. + +=cut + +sub _get_output_result { + my $self = shift; + + my @color_map = ( + { test => sub { $_->is_test && !$_->is_ok }, + colors => ['red'], + }, + { test => sub { $_->is_test && $_->has_skip }, + colors => [ + 'white', + 'on_blue' + ], + }, + { test => sub { $_->is_test && $_->has_todo }, + colors => ['yellow'], + }, + ); + + my $formatter = $self->formatter; + my $parser = $self->parser; + + return $formatter->_colorizer + ? sub { + my $result = shift; + for my $col (@color_map) { + local $_ = $result; + if ( $col->{test}->() ) { + $formatter->_set_colors( @{ $col->{colors} } ); + last; + } + } + $formatter->_output( $self->_format_for_output($result) ); + $formatter->_set_colors('reset'); + } + : sub { + $formatter->_output( $self->_format_for_output(shift) ); + }; +} + +sub _closures { + my $self = shift; + + my $parser = $self->parser; + my $formatter = $self->formatter; + my $pretty = $formatter->_format_name( $self->name ); + my $show_count = $self->show_count; + + my $really_quiet = $formatter->really_quiet; + my $quiet = $formatter->quiet; + my $verbose = $formatter->verbose; + my $directives = $formatter->directives; + my $failures = $formatter->failures; + my $comments = $formatter->comments; + + my $output_result = $self->_get_output_result; + + my $output = '_output'; + my $plan = ''; + my $newline_printed = 0; + + my $last_status_printed = 0; + + return { + header => sub { + $formatter->_output($pretty) + unless $really_quiet; + }, + + result => sub { + my $result = shift; + + if ( $result->is_bailout ) { + $formatter->_failure_output( + "Bailout called. Further testing stopped: " + . $result->explanation + . "\n" ); + } + + return if $really_quiet; + + my $is_test = $result->is_test; + + # These are used in close_test - but only if $really_quiet + # is false - so it's safe to only set them here unless that + # relationship changes. + + if ( !$plan ) { + my $planned = $parser->tests_planned || '?'; + $plan = "/$planned "; + } + $output = $formatter->_get_output_method($parser); + + if ( $show_count and $is_test ) { + my $number = $result->number; + my $now = CORE::time; + + # Print status roughly once per second. + # We will always get the first number as a side effect of + # $last_status_printed starting with the value 0, which $now + # will never be. (Unless someone sets their clock to 1970) + if ( $last_status_printed != $now ) { + $formatter->$output("\r$pretty$number$plan"); + $last_status_printed = $now; + } + } + + if (!$quiet + && ( $verbose + || ( $is_test && $failures && !$result->is_ok ) + || ( $comments && $result->is_comment ) + || ( $directives && $result->has_directive ) ) + ) + { + unless ($newline_printed) { + $formatter->_output("\n"); + $newline_printed = 1; + } + $output_result->($result); + $formatter->_output("\n"); + } + }, + + clear_for_close => sub { + my $spaces + = ' ' x length( '.' . $pretty . $plan . $parser->tests_run ); + $formatter->$output("\r$spaces"); + }, + + close_test => sub { + if ( $show_count && !$really_quiet ) { + $self->clear_for_close; + $formatter->$output("\r$pretty"); + } + + # Avoid circular references + $self->parser(undef); + $self->{_closures} = {}; + + return if $really_quiet; + + if ( my $skip_all = $parser->skip_all ) { + $formatter->_output("skipped: $skip_all\n"); + } + elsif ( $parser->has_problems ) { + $self->_output_test_failure($parser); + } + else { + my $time_report = ''; + if ( $formatter->timer ) { + my $start_time = $parser->start_time; + my $end_time = $parser->end_time; + if ( defined $start_time and defined $end_time ) { + my $elapsed = $end_time - $start_time; + $time_report + = $self->time_is_hires + ? sprintf( ' %8d ms', $elapsed * 1000 ) + : sprintf( ' %8s s', $elapsed || '<1' ); + } + } + + $formatter->_output("ok$time_report\n"); + } + }, + }; +} + +=head2 C<< clear_for_close >> + +=head2 C<< close_test >> + +=head2 C<< header >> + +=head2 C<< result >> + +=cut + +1; diff --git a/cpan/Test-Harness/lib/TAP/Formatter/File.pm b/cpan/Test-Harness/lib/TAP/Formatter/File.pm new file mode 100644 index 0000000000..8514bc068b --- /dev/null +++ b/cpan/Test-Harness/lib/TAP/Formatter/File.pm @@ -0,0 +1,58 @@ +package TAP::Formatter::File; + +use strict; +use TAP::Formatter::Base (); +use TAP::Formatter::File::Session; +use POSIX qw(strftime); + +use vars qw($VERSION @ISA); + +@ISA = qw(TAP::Formatter::Base); + +=head1 NAME + +TAP::Formatter::File - Harness output delegate for file output + +=head1 VERSION + +Version 3.17 + +=cut + +$VERSION = '3.17'; + +=head1 DESCRIPTION + +This provides file orientated output formatting for TAP::Harness. + +=head1 SYNOPSIS + + use TAP::Formatter::File; + my $harness = TAP::Formatter::File->new( \%args ); + +=head2 C<< open_test >> + +See L + +=cut + +sub open_test { + my ( $self, $test, $parser ) = @_; + + my $session = TAP::Formatter::File::Session->new( + { name => $test, + formatter => $self, + parser => $parser, + } + ); + + $session->header; + + return $session; +} + +sub _should_show_count { + return 0; +} + +1; diff --git a/cpan/Test-Harness/lib/TAP/Formatter/File/Session.pm b/cpan/Test-Harness/lib/TAP/Formatter/File/Session.pm new file mode 100644 index 0000000000..c6abfd63bc --- /dev/null +++ b/cpan/Test-Harness/lib/TAP/Formatter/File/Session.pm @@ -0,0 +1,110 @@ +package TAP::Formatter::File::Session; + +use strict; +use TAP::Formatter::Session; + +use vars qw($VERSION @ISA); + +@ISA = qw(TAP::Formatter::Session); + +=head1 NAME + +TAP::Formatter::File::Session - Harness output delegate for file output + +=head1 VERSION + +Version 3.17 + +=cut + +$VERSION = '3.17'; + +=head1 DESCRIPTION + +This provides file orientated output formatting for L. +It is particularly important when running with parallel tests, as it +ensures that test results are not interleaved, even when run +verbosely. + +=cut + +=head1 METHODS + +=head2 result + +Stores results for later output, all together. + +=cut + +sub result { + my $self = shift; + my $result = shift; + + my $parser = $self->parser; + my $formatter = $self->formatter; + + if ( $result->is_bailout ) { + $formatter->_failure_output( + "Bailout called. Further testing stopped: " + . $result->explanation + . "\n" ); + return; + } + + if (!$formatter->quiet + && ( $formatter->verbose + || ( $result->is_test && $formatter->failures && !$result->is_ok ) + || ( $formatter->comments && $result->is_comment ) + || ( $result->has_directive && $formatter->directives ) ) + ) + { + $self->{results} .= $self->_format_for_output($result) . "\n"; + } +} + +=head2 close_test + +When the test file finishes, outputs the summary, together. + +=cut + +sub close_test { + my $self = shift; + + # Avoid circular references + $self->parser(undef); + + my $parser = $self->parser; + my $formatter = $self->formatter; + my $pretty = $formatter->_format_name( $self->name ); + + return if $formatter->really_quiet; + if ( my $skip_all = $parser->skip_all ) { + $formatter->_output( $pretty . "skipped: $skip_all\n" ); + } + elsif ( $parser->has_problems ) { + $formatter->_output( + $pretty . ( $self->{results} ? "\n" . $self->{results} : "\n" ) ); + $self->_output_test_failure($parser); + } + else { + my $time_report = ''; + if ( $formatter->timer ) { + my $start_time = $parser->start_time; + my $end_time = $parser->end_time; + if ( defined $start_time and defined $end_time ) { + my $elapsed = $end_time - $start_time; + $time_report + = $self->time_is_hires + ? sprintf( ' %8d ms', $elapsed * 1000 ) + : sprintf( ' %8s s', $elapsed || '<1' ); + } + } + + $formatter->_output( $pretty + . ( $self->{results} ? "\n" . $self->{results} : "" ) + . "ok$time_report\n" ); + } +} + +1; diff --git a/cpan/Test-Harness/lib/TAP/Formatter/Session.pm b/cpan/Test-Harness/lib/TAP/Formatter/Session.pm new file mode 100644 index 0000000000..21767e5eba --- /dev/null +++ b/cpan/Test-Harness/lib/TAP/Formatter/Session.pm @@ -0,0 +1,183 @@ +package TAP::Formatter::Session; + +use strict; +use TAP::Base; + +use vars qw($VERSION @ISA); + +@ISA = qw(TAP::Base); + +my @ACCESSOR; + +BEGIN { + + @ACCESSOR = qw( name formatter parser show_count ); + + for my $method (@ACCESSOR) { + no strict 'refs'; + *$method = sub { shift->{$method} }; + } +} + +=head1 NAME + +TAP::Formatter::Session - Abstract base class for harness output delegate + +=head1 VERSION + +Version 3.17 + +=cut + +$VERSION = '3.17'; + +=head1 METHODS + +=head2 Class Methods + +=head3 C + + my %args = ( + formatter => $self, + ) + my $harness = TAP::Formatter::Console::Session->new( \%args ); + +The constructor returns a new C object. + +=over 4 + +=item * C + +=item * C + +=item * C + +=item * C + +=back + +=cut + +sub _initialize { + my ( $self, $arg_for ) = @_; + $arg_for ||= {}; + + $self->SUPER::_initialize($arg_for); + my %arg_for = %$arg_for; # force a shallow copy + + for my $name (@ACCESSOR) { + $self->{$name} = delete $arg_for{$name}; + } + + if ( !defined $self->show_count ) { + $self->{show_count} = 1; # defaults to true + } + if ( $self->show_count ) { # but may be a damned lie! + $self->{show_count} = $self->_should_show_count; + } + + if ( my @props = sort keys %arg_for ) { + $self->_croak( + "Unknown arguments to " . __PACKAGE__ . "::new (@props)" ); + } + + return $self; +} + +=head3 C
+ +Output test preamble + +=head3 C + +Called by the harness for each line of TAP it receives. + +=head3 C + +Called to close a test session. + +=head3 C + +Called by C to clear the line showing test progress, or the parallel +test ruler, prior to printing the final test result. + +=cut + +sub header { } + +sub result { } + +sub close_test { } + +sub clear_for_close { } + +sub _should_show_count { + my $self = shift; + return + !$self->formatter->verbose + && -t $self->formatter->stdout + && !$ENV{HARNESS_NOTTY}; +} + +sub _format_for_output { + my ( $self, $result ) = @_; + return $self->formatter->normalize ? $result->as_string : $result->raw; +} + +sub _output_test_failure { + my ( $self, $parser ) = @_; + my $formatter = $self->formatter; + return if $formatter->really_quiet; + + my $tests_run = $parser->tests_run; + my $tests_planned = $parser->tests_planned; + + my $total + = defined $tests_planned + ? $tests_planned + : $tests_run; + + my $passed = $parser->passed; + + # The total number of fails includes any tests that were planned but + # didn't run + my $failed = $parser->failed + $total - $tests_run; + my $exit = $parser->exit; + + if ( my $exit = $parser->exit ) { + my $wstat = $parser->wait; + my $status = sprintf( "%d (wstat %d, 0x%x)", $exit, $wstat, $wstat ); + $formatter->_failure_output("Dubious, test returned $status\n"); + } + + if ( $failed == 0 ) { + $formatter->_failure_output( + $total + ? "All $total subtests passed " + : 'No subtests run ' + ); + } + else { + $formatter->_failure_output("Failed $failed/$total subtests "); + if ( !$total ) { + $formatter->_failure_output("\nNo tests run!"); + } + } + + if ( my $skipped = $parser->skipped ) { + $passed -= $skipped; + my $test = 'subtest' . ( $skipped != 1 ? 's' : '' ); + $formatter->_output( + "\n\t(less $skipped skipped $test: $passed okay)"); + } + + if ( my $failed = $parser->todo_passed ) { + my $test = $failed > 1 ? 'tests' : 'test'; + $formatter->_output( + "\n\t($failed TODO $test unexpectedly succeeded)"); + } + + $formatter->_output("\n"); +} + +1; diff --git a/cpan/Test-Harness/lib/TAP/Harness.pm b/cpan/Test-Harness/lib/TAP/Harness.pm new file mode 100644 index 0000000000..749e7af416 --- /dev/null +++ b/cpan/Test-Harness/lib/TAP/Harness.pm @@ -0,0 +1,830 @@ +package TAP::Harness; + +use strict; +use Carp; + +use File::Spec; +use File::Path; +use IO::Handle; + +use TAP::Base; + +use vars qw($VERSION @ISA); + +@ISA = qw(TAP::Base); + +=head1 NAME + +TAP::Harness - Run test scripts with statistics + +=head1 VERSION + +Version 3.17 + +=cut + +$VERSION = '3.17'; + +$ENV{HARNESS_ACTIVE} = 1; +$ENV{HARNESS_VERSION} = $VERSION; + +END { + + # For VMS. + delete $ENV{HARNESS_ACTIVE}; + delete $ENV{HARNESS_VERSION}; +} + +=head1 DESCRIPTION + +This is a simple test harness which allows tests to be run and results +automatically aggregated and output to STDOUT. + +=head1 SYNOPSIS + + use TAP::Harness; + my $harness = TAP::Harness->new( \%args ); + $harness->runtests(@tests); + +=cut + +my %VALIDATION_FOR; +my @FORMATTER_ARGS; + +sub _error { + my $self = shift; + return $self->{error} unless @_; + $self->{error} = shift; +} + +BEGIN { + + @FORMATTER_ARGS = qw( + directives verbosity timer failures comments errors stdout color + show_count normalize + ); + + %VALIDATION_FOR = ( + lib => sub { + my ( $self, $libs ) = @_; + $libs = [$libs] unless 'ARRAY' eq ref $libs; + + return [ map {"-I$_"} @$libs ]; + }, + switches => sub { shift; shift }, + exec => sub { shift; shift }, + merge => sub { shift; shift }, + aggregator_class => sub { shift; shift }, + formatter_class => sub { shift; shift }, + multiplexer_class => sub { shift; shift }, + parser_class => sub { shift; shift }, + scheduler_class => sub { shift; shift }, + formatter => sub { shift; shift }, + jobs => sub { shift; shift }, + test_args => sub { shift; shift }, + ignore_exit => sub { shift; shift }, + rules => sub { shift; shift }, + ); + + for my $method ( sort keys %VALIDATION_FOR ) { + no strict 'refs'; + if ( $method eq 'lib' || $method eq 'switches' ) { + *{$method} = sub { + my $self = shift; + unless (@_) { + $self->{$method} ||= []; + return wantarray + ? @{ $self->{$method} } + : $self->{$method}; + } + $self->_croak("Too many arguments to method '$method'") + if @_ > 1; + my $args = shift; + $args = [$args] unless ref $args; + $self->{$method} = $args; + return $self; + }; + } + else { + *{$method} = sub { + my $self = shift; + return $self->{$method} unless @_; + $self->{$method} = shift; + }; + } + } + + for my $method (@FORMATTER_ARGS) { + no strict 'refs'; + *{$method} = sub { + my $self = shift; + return $self->formatter->$method(@_); + }; + } +} + +############################################################################## + +=head1 METHODS + +=head2 Class Methods + +=head3 C + + my %args = ( + verbosity => 1, + lib => [ 'lib', 'blib/lib', 'blib/arch' ], + ) + my $harness = TAP::Harness->new( \%args ); + +The constructor returns a new C object. It accepts an +optional hashref whose allowed keys are: + +=over 4 + +=item * C + +Set the verbosity level: + + 1 verbose Print individual test results to STDOUT. + 0 normal + -1 quiet Suppress some test output (mostly failures + while tests are running). + -2 really quiet Suppress everything but the tests summary. + -3 silent Suppress everything. + +=item * C + +Append run time for each test to output. Uses L if +available. + +=item * C + +Show test failures (this is a no-op if C is selected). + +=item * C + +Show test comments (this is a no-op if C is selected). + +=item * C + +Update the running test count during testing. + +=item * C + +Set to a true value to normalize the TAP that is emitted in verbose modes. + +=item * C + +Accepts a scalar value or array ref of scalar values indicating which +paths to allowed libraries should be included if Perl tests are +executed. Naturally, this only makes sense in the context of tests +written in Perl. + +=item * C + +Accepts a scalar value or array ref of scalar values indicating which +switches should be included if Perl tests are executed. Naturally, this +only makes sense in the context of tests written in Perl. + +=item * C + +A reference to an C<@INC> style array of arguments to be passed to each +test program. + +=item * C + +Attempt to produce color output. + +=item * C + +Typically, Perl tests are run through this. However, anything which +spits out TAP is fine. You can use this argument to specify the name of +the program (and optional switches) to run your tests with: + + exec => ['/usr/bin/ruby', '-w'] + +You can also pass a subroutine reference in order to determine and +return the proper program to run based on a given test script. The +subroutine reference should expect the TAP::Harness object itself as the +first argument, and the file name as the second argument. It should +return an array reference containing the command to be run and including +the test file name. It can also simply return C, in which case +TAP::Harness will fall back on executing the test script in Perl: + + exec => sub { + my ( $harness, $test_file ) = @_; + + # Let Perl tests run. + return undef if $test_file =~ /[.]t$/; + return [ qw( /usr/bin/ruby -w ), $test_file ] + if $test_file =~ /[.]rb$/; + } + +If the subroutine returns a scalar with a newline or a filehandle, it +will be interpreted as raw TAP or as a TAP stream, respectively. + +=item * C + +If C is true the harness will create parsers that merge STDOUT +and STDERR together for any processes they start. + +=item * C + +The name of the class to use to aggregate test results. The default is +L. + +=item * C + +The name of the class to use to format output. The default is +L, or L if the output +isn't a TTY. + +=item * C + +The name of the class to use to multiplex tests during parallel testing. +The default is L. + +=item * C + +The name of the class to use to parse TAP. The default is +L. + +=item * C + +The name of the class to use to schedule test execution. The default is +L. + +=item * C + +If set C must be an object that is capable of formatting the +TAP output. See L for an example. + +=item * C + +If parse errors are found in the TAP output, a note of this will be +made in the summary report. To see all of the parse errors, set this +argument to true: + + errors => 1 + +=item * C + +If set to a true value, only test results with directives will be +displayed. This overrides other settings such as C or +C. + +=item * C + +If set to a true value instruct C to ignore exit and wait +status from test scripts. + +=item * C + +The maximum number of parallel tests to run at any time. Which tests +can be run in parallel is controlled by C. The default is to +run only one test at a time. + +=item * C + +A reference to a hash of rules that control which tests may be +executed in parallel. This is an experimental feature and the +interface may change. + + $harness->rules( + { par => [ + { seq => '../ext/DB_File/t/*' }, + { seq => '../ext/IO_Compress_Zlib/t/*' }, + { seq => '../lib/CPANPLUS/*' }, + { seq => '../lib/ExtUtils/t/*' }, + '*' + ] + } + ); + +=item * C + +A filehandle for catching standard output. + +=back + +Any keys for which the value is C will be ignored. + +=cut + +# new supplied by TAP::Base + +{ + my @legal_callback = qw( + parser_args + made_parser + before_runtests + after_runtests + after_test + ); + + my %default_class = ( + aggregator_class => 'TAP::Parser::Aggregator', + formatter_class => 'TAP::Formatter::Console', + multiplexer_class => 'TAP::Parser::Multiplexer', + parser_class => 'TAP::Parser', + scheduler_class => 'TAP::Parser::Scheduler', + ); + + sub _initialize { + my ( $self, $arg_for ) = @_; + $arg_for ||= {}; + + $self->SUPER::_initialize( $arg_for, \@legal_callback ); + my %arg_for = %$arg_for; # force a shallow copy + + for my $name ( sort keys %VALIDATION_FOR ) { + my $property = delete $arg_for{$name}; + if ( defined $property ) { + my $validate = $VALIDATION_FOR{$name}; + + my $value = $self->$validate($property); + if ( $self->_error ) { + $self->_croak; + } + $self->$name($value); + } + } + + $self->jobs(1) unless defined $self->jobs; + + local $default_class{formatter_class} = 'TAP::Formatter::File' + unless -t ( $arg_for{stdout} || \*STDOUT ) && !$ENV{HARNESS_NOTTY}; + + while ( my ( $attr, $class ) = each %default_class ) { + $self->$attr( $self->$attr() || $class ); + } + + unless ( $self->formatter ) { + + # This is a little bodge to preserve legacy behaviour. It's + # pretty horrible that we know which args are destined for + # the formatter. + my %formatter_args = ( jobs => $self->jobs ); + for my $name (@FORMATTER_ARGS) { + if ( defined( my $property = delete $arg_for{$name} ) ) { + $formatter_args{$name} = $property; + } + } + + $self->formatter( + $self->_construct( $self->formatter_class, \%formatter_args ) + ); + } + + if ( my @props = sort keys %arg_for ) { + $self->_croak("Unknown arguments to TAP::Harness::new (@props)"); + } + + return $self; + } +} + +############################################################################## + +=head2 Instance Methods + +=head3 C + + $harness->runtests(@tests); + +Accepts and array of C<@tests> to be run. This should generally be the +names of test files, but this is not required. Each element in C<@tests> +will be passed to C as a C. See +L for more information. + +It is possible to provide aliases that will be displayed in place of the +test name by supplying the test as a reference to an array containing +C<< [ $test, $alias ] >>: + + $harness->runtests( [ 't/foo.t', 'Foo Once' ], + [ 't/foo.t', 'Foo Twice' ] ); + +Normally it is an error to attempt to run the same test twice. Aliases +allow you to overcome this limitation by giving each run of the test a +unique name. + +Tests will be run in the order found. + +If the environment variable C is defined it +should name a directory into which a copy of the raw TAP for each test +will be written. TAP is written to files named for each test. +Subdirectories will be created as needed. + +Returns a L containing the test results. + +=cut + +sub runtests { + my ( $self, @tests ) = @_; + + my $aggregate = $self->_construct( $self->aggregator_class ); + + $self->_make_callback( 'before_runtests', $aggregate ); + $aggregate->start; + $self->aggregate_tests( $aggregate, @tests ); + $aggregate->stop; + $self->summary($aggregate); + $self->_make_callback( 'after_runtests', $aggregate ); + + return $aggregate; +} + +=head3 C + +Output the summary for a TAP::Parser::Aggregator. + +=cut + +sub summary { + my ( $self, $aggregate ) = @_; + $self->formatter->summary($aggregate); +} + +sub _after_test { + my ( $self, $aggregate, $job, $parser ) = @_; + + $self->_make_callback( 'after_test', $job->as_array_ref, $parser ); + $aggregate->add( $job->description, $parser ); +} + +sub _bailout { + my ( $self, $result ) = @_; + my $explanation = $result->explanation; + die "FAILED--Further testing stopped" + . ( $explanation ? ": $explanation\n" : ".\n" ); +} + +sub _aggregate_parallel { + my ( $self, $aggregate, $scheduler ) = @_; + + my $jobs = $self->jobs; + my $mux = $self->_construct( $self->multiplexer_class ); + + RESULT: { + + # Keep multiplexer topped up + FILL: + while ( $mux->parsers < $jobs ) { + my $job = $scheduler->get_job; + + # If we hit a spinner stop filling and start running. + last FILL if !defined $job || $job->is_spinner; + + my ( $parser, $session ) = $self->make_parser($job); + $mux->add( $parser, [ $session, $job ] ); + } + + if ( my ( $parser, $stash, $result ) = $mux->next ) { + my ( $session, $job ) = @$stash; + if ( defined $result ) { + $session->result($result); + $self->_bailout($result) if $result->is_bailout; + } + else { + + # End of parser. Automatically removed from the mux. + $self->finish_parser( $parser, $session ); + $self->_after_test( $aggregate, $job, $parser ); + $job->finish; + } + redo RESULT; + } + } + + return; +} + +sub _aggregate_single { + my ( $self, $aggregate, $scheduler ) = @_; + + JOB: + while ( my $job = $scheduler->get_job ) { + next JOB if $job->is_spinner; + + my ( $parser, $session ) = $self->make_parser($job); + + while ( defined( my $result = $parser->next ) ) { + $session->result($result); + if ( $result->is_bailout ) { + + # Keep reading until input is exhausted in the hope + # of allowing any pending diagnostics to show up. + 1 while $parser->next; + $self->_bailout($result); + } + } + + $self->finish_parser( $parser, $session ); + $self->_after_test( $aggregate, $job, $parser ); + $job->finish; + } + + return; +} + +=head3 C + + $harness->aggregate_tests( $aggregate, @tests ); + +Run the named tests and display a summary of result. Tests will be run +in the order found. + +Test results will be added to the supplied L. +C may be called multiple times to run several sets of +tests. Multiple C instances may be used to pass results +to a single aggregator so that different parts of a complex test suite +may be run using different C settings. This is useful, for +example, in the case where some tests should run in parallel but others +are unsuitable for parallel execution. + + my $formatter = TAP::Formatter::Console->new; + my $ser_harness = TAP::Harness->new( { formatter => $formatter } ); + my $par_harness = TAP::Harness->new( + { formatter => $formatter, + jobs => 9 + } + ); + my $aggregator = TAP::Parser::Aggregator->new; + + $aggregator->start(); + $ser_harness->aggregate_tests( $aggregator, @ser_tests ); + $par_harness->aggregate_tests( $aggregator, @par_tests ); + $aggregator->stop(); + $formatter->summary($aggregator); + +Note that for simpler testing requirements it will often be possible to +replace the above code with a single call to C. + +Each elements of the @tests array is either + +=over + +=item * the file name of a test script to run + +=item * a reference to a [ file name, display name ] array + +=back + +When you supply a separate display name it becomes possible to run a +test more than once; the display name is effectively the alias by which +the test is known inside the harness. The harness doesn't care if it +runs the same script more than once when each invocation uses a +different name. + +=cut + +sub aggregate_tests { + my ( $self, $aggregate, @tests ) = @_; + + my $jobs = $self->jobs; + my $scheduler = $self->make_scheduler(@tests); + + # #12458 + local $ENV{HARNESS_IS_VERBOSE} = 1 + if $self->formatter->verbosity > 0; + + # Formatter gets only names. + $self->formatter->prepare( map { $_->description } $scheduler->get_all ); + + if ( $self->jobs > 1 ) { + $self->_aggregate_parallel( $aggregate, $scheduler ); + } + else { + $self->_aggregate_single( $aggregate, $scheduler ); + } + + return; +} + +sub _add_descriptions { + my $self = shift; + + # Turn unwrapped scalars into anonymous arrays and copy the name as + # the description for tests that have only a name. + return map { @$_ == 1 ? [ $_->[0], $_->[0] ] : $_ } + map { 'ARRAY' eq ref $_ ? $_ : [$_] } @_; +} + +=head3 C + +Called by the harness when it needs to create a +L. Override in a subclass to provide an +alternative scheduler. C is passed the list of tests +that was passed to C. + +=cut + +sub make_scheduler { + my ( $self, @tests ) = @_; + return $self->_construct( + $self->scheduler_class, + tests => [ $self->_add_descriptions(@tests) ], + rules => $self->rules + ); +} + +=head3 C + +Gets or sets the number of concurrent test runs the harness is +handling. By default, this value is 1 -- for parallel testing, this +should be set higher. + +=cut + +############################################################################## + +=head1 SUBCLASSING + +C is designed to be (mostly) easy to subclass. If you +don't like how a particular feature functions, just override the +desired methods. + +=head2 Methods + +TODO: This is out of date + +The following methods are ones you may wish to override if you want to +subclass C. + +=head3 C + + $harness->summary( \%args ); + +C prints the summary report after all tests are run. The +argument is a hashref with the following keys: + +=over 4 + +=item * C + +This is created with C<< Benchmark->new >> and it the time the tests +started. You can print a useful summary time, if desired, with: + + $self->output( + timestr( timediff( Benchmark->new, $start_time ), 'nop' ) ); + +=item * C + +This is an array reference of all test names. To get the L +object for individual tests: + + my $aggregate = $args->{aggregate}; + my $tests = $args->{tests}; + + for my $name ( @$tests ) { + my ($parser) = $aggregate->parsers($test); + ... do something with $parser + } + +This is a bit clunky and will be cleaned up in a later release. + +=back + +=cut + +sub _get_parser_args { + my ( $self, $job ) = @_; + my $test_prog = $job->filename; + my %args = (); + my @switches; + @switches = $self->lib if $self->lib; + push @switches => $self->switches if $self->switches; + $args{switches} = \@switches; + $args{spool} = $self->_open_spool($test_prog); + $args{merge} = $self->merge; + $args{ignore_exit} = $self->ignore_exit; + + if ( my $exec = $self->exec ) { + $args{exec} + = ref $exec eq 'CODE' + ? $exec->( $self, $test_prog ) + : [ @$exec, $test_prog ]; + if ( not defined $args{exec} ) { + $args{source} = $test_prog; + } + elsif ( ( ref( $args{exec} ) || "" ) ne "ARRAY" ) { + $args{source} = delete $args{exec}; + } + } + else { + $args{source} = $test_prog; + } + + if ( defined( my $test_args = $self->test_args ) ) { + $args{test_args} = $test_args; + } + + return \%args; +} + +=head3 C + +Make a new parser and display formatter session. Typically used and/or +overridden in subclasses. + + my ( $parser, $session ) = $harness->make_parser; + +=cut + +sub make_parser { + my ( $self, $job ) = @_; + + my $args = $self->_get_parser_args($job); + $self->_make_callback( 'parser_args', $args, $job->as_array_ref ); + my $parser = $self->_construct( $self->parser_class, $args ); + + $self->_make_callback( 'made_parser', $parser, $job->as_array_ref ); + my $session = $self->formatter->open_test( $job->description, $parser ); + + return ( $parser, $session ); +} + +=head3 C + +Terminate use of a parser. Typically used and/or overridden in +subclasses. The parser isn't destroyed as a result of this. + +=cut + +sub finish_parser { + my ( $self, $parser, $session ) = @_; + + $session->close_test; + $self->_close_spool($parser); + + return $parser; +} + +sub _open_spool { + my $self = shift; + my $test = shift; + + if ( my $spool_dir = $ENV{PERL_TEST_HARNESS_DUMP_TAP} ) { + + my $spool = File::Spec->catfile( $spool_dir, $test ); + + # Make the directory + my ( $vol, $dir, undef ) = File::Spec->splitpath($spool); + my $path = File::Spec->catpath( $vol, $dir, '' ); + eval { mkpath($path) }; + $self->_croak($@) if $@; + + my $spool_handle = IO::Handle->new; + open( $spool_handle, ">$spool" ) + or $self->_croak(" Can't write $spool ( $! ) "); + + return $spool_handle; + } + + return; +} + +sub _close_spool { + my $self = shift; + my ($parser) = @_; + + if ( my $spool_handle = $parser->delete_spool ) { + close($spool_handle) + or $self->_croak(" Error closing TAP spool file( $! ) \n "); + } + + return; +} + +sub _croak { + my ( $self, $message ) = @_; + unless ($message) { + $message = $self->_error; + } + $self->SUPER::_croak($message); + + return; +} + +=head1 REPLACING + +If you like the C utility and L but you want your +own harness, all you need to do is write one and provide C and +C methods. Then you can use the C utility like so: + + prove --harness My::Test::Harness + +Note that while C accepts a list of tests (or things to be +tested), C has a fairly rich set of arguments. You'll probably want +to read over this code carefully to see how all of them are being used. + +=head1 SEE ALSO + +L + +=cut + +1; + +# vim:ts=4:sw=4:et:sta diff --git a/cpan/Test-Harness/lib/TAP/Object.pm b/cpan/Test-Harness/lib/TAP/Object.pm new file mode 100644 index 0000000000..498bb805c9 --- /dev/null +++ b/cpan/Test-Harness/lib/TAP/Object.pm @@ -0,0 +1,139 @@ +package TAP::Object; + +use strict; +use vars qw($VERSION); + +=head1 NAME + +TAP::Object - Base class that provides common functionality to all C modules + +=head1 VERSION + +Version 3.17 + +=cut + +$VERSION = '3.17'; + +=head1 SYNOPSIS + + package TAP::Whatever; + + use strict; + use vars qw(@ISA); + + use TAP::Object; + + @ISA = qw(TAP::Object); + + # new() implementation by TAP::Object + sub _initialize { + my ( $self, @args) = @_; + # initialize your object + return $self; + } + + # ... later ... + my $obj = TAP::Whatever->new(@args); + +=head1 DESCRIPTION + +C provides a default constructor and exception model for all +C classes. Exceptions are raised using L. + +=head1 METHODS + +=head2 Class Methods + +=head3 C + +Create a new object. Any arguments passed to C will be passed on to the +L method. Returns a new object. + +=cut + +sub new { + my $class = shift; + my $self = bless {}, $class; + return $self->_initialize(@_); +} + +=head2 Instance Methods + +=head3 C<_initialize> + +Initializes a new object. This method is a stub by default, you should override +it as appropriate. + +I L expects you to return C<$self> or raise an exception. See +L, and L. + +=cut + +sub _initialize { + return $_[0]; +} + +=head3 C<_croak> + +Raise an exception using C from L, eg: + + $self->_croak( 'why me?', 'aaarrgh!' ); + +May also be called as a I method. + + $class->_croak( 'this works too' ); + +=cut + +sub _croak { + my $proto = shift; + require Carp; + Carp::croak(@_); + return; +} + +=head3 C<_construct> + +Create a new instance of the specified class. + +=cut + +sub _construct { + my ( $self, $class, @args ) = @_; + + $self->_croak("Bad module name $class") + unless $class =~ /^ \w+ (?: :: \w+ ) *$/x; + + unless ( $class->can('new') ) { + local $@; + eval "require $class"; + $self->_croak("Can't load $class") if $@; + } + + return $class->new(@args); +} + +=head3 C + +Create simple getter/setters. + + __PACKAGE__->mk_methods(@method_names); + +=cut + +sub mk_methods { + my ( $class, @methods ) = @_; + foreach my $method_name (@methods) { + my $method = "${class}::$method_name"; + no strict 'refs'; + *$method = sub { + my $self = shift; + $self->{$method_name} = shift if @_; + return $self->{$method_name}; + }; + } +} + +1; + diff --git a/cpan/Test-Harness/lib/TAP/Parser.pm b/cpan/Test-Harness/lib/TAP/Parser.pm new file mode 100644 index 0000000000..ea3acd907f --- /dev/null +++ b/cpan/Test-Harness/lib/TAP/Parser.pm @@ -0,0 +1,1873 @@ +package TAP::Parser; + +use strict; +use vars qw($VERSION @ISA); + +use TAP::Base (); +use TAP::Parser::Grammar (); +use TAP::Parser::Result (); +use TAP::Parser::ResultFactory (); +use TAP::Parser::Source (); +use TAP::Parser::Source::Perl (); +use TAP::Parser::Iterator (); +use TAP::Parser::IteratorFactory (); + +use Carp qw( confess ); + +=head1 NAME + +TAP::Parser - Parse L output + +=head1 VERSION + +Version 3.17 + +=cut + +$VERSION = '3.17'; + +my $DEFAULT_TAP_VERSION = 12; +my $MAX_TAP_VERSION = 13; + +$ENV{TAP_VERSION} = $MAX_TAP_VERSION; + +END { + + # For VMS. + delete $ENV{TAP_VERSION}; +} + +BEGIN { # making accessors + @ISA = qw(TAP::Base); + + __PACKAGE__->mk_methods( + qw( + _stream + _spool + exec + exit + is_good_plan + plan + tests_planned + tests_run + wait + version + in_todo + start_time + end_time + skip_all + source_class + perl_source_class + grammar_class + iterator_factory_class + result_factory_class + ) + ); +} # done making accessors + +=head1 SYNOPSIS + + use TAP::Parser; + + my $parser = TAP::Parser->new( { source => $source } ); + + while ( my $result = $parser->next ) { + print $result->as_string; + } + +=head1 DESCRIPTION + +C is designed to produce a proper parse of TAP output. For +an example of how to run tests through this module, see the simple +harnesses C. + +There's a wiki dedicated to the Test Anything Protocol: + +L + +It includes the TAP::Parser Cookbook: + +L + +=head1 METHODS + +=head2 Class Methods + +=head3 C + + my $parser = TAP::Parser->new(\%args); + +Returns a new C object. + +The arguments should be a hashref with I of the following keys: + +=over 4 + +=item * C + +This is the preferred method of passing arguments to the constructor. To +determine how to handle the source, the following steps are taken. + +If the source contains a newline, it's assumed to be a string of raw TAP +output. + +If the source is a reference, it's assumed to be something to pass to +the L constructor. This is used +internally and you should not use it. + +Otherwise, the parser does a C<-e> check to see if the source exists. If so, +it attempts to execute the source and read the output as a stream. This is by +far the preferred method of using the parser. + + foreach my $file ( @test_files ) { + my $parser = TAP::Parser->new( { source => $file } ); + # do stuff with the parser + } + +=item * C + +The value should be the complete TAP output. + +=item * C + +If passed an array reference, will attempt to create the iterator by +passing a L object to +L, using the array reference strings as +the command arguments to L: + + exec => [ '/usr/bin/ruby', 't/my_test.rb' ] + +Note that C and C are mutually exclusive. + +=back + +The following keys are optional. + +=over 4 + +=item * C + +If present, each callback corresponding to a given result type will be called +with the result as the argument if the C method is used: + + my %callbacks = ( + test => \&test_callback, + plan => \&plan_callback, + comment => \&comment_callback, + bailout => \&bailout_callback, + unknown => \&unknown_callback, + ); + + my $aggregator = TAP::Parser::Aggregator->new; + foreach my $file ( @test_files ) { + my $parser = TAP::Parser->new( + { + source => $file, + callbacks => \%callbacks, + } + ); + $parser->run; + $aggregator->add( $file, $parser ); + } + +=item * C + +If using a Perl file as a source, optional switches may be passed which will +be used when invoking the perl executable. + + my $parser = TAP::Parser->new( { + source => $test_file, + switches => '-Ilib', + } ); + +=item * C + +Used in conjunction with the C option to supply a reference to +an C<@ARGV> style array of arguments to pass to the test program. + +=item * C + +If passed a filehandle will write a copy of all parsed TAP to that handle. + +=item * C + +If false, STDERR is not captured (though it is 'relayed' to keep it +somewhat synchronized with STDOUT.) + +If true, STDERR and STDOUT are the same filehandle. This may cause +breakage if STDERR contains anything resembling TAP format, but does +allow exact synchronization. + +Subtleties of this behavior may be platform-dependent and may change in +the future. + +=item * C + +This option was introduced to let you easily customize which I class +the parser should use. It defaults to L. + +See also L. + +=item * C + +This option was introduced to let you easily customize which I +class the parser should use. It defaults to L. + +See also L. + +=item * C + +This option was introduced to let you easily customize which I class +the parser should use. It defaults to L. + +See also L. + +=item * C + +This option was introduced to let you easily customize which I +factory class the parser should use. It defaults to +L. + +See also L. + +=item * C + +This option was introduced to let you easily customize which I +factory class the parser should use. It defaults to +L. + +See also L. + +=back + +=cut + +# new() implementation supplied by TAP::Base + +# This should make overriding behaviour of the Parser in subclasses easier: +sub _default_source_class {'TAP::Parser::Source'} +sub _default_perl_source_class {'TAP::Parser::Source::Perl'} +sub _default_grammar_class {'TAP::Parser::Grammar'} +sub _default_iterator_factory_class {'TAP::Parser::IteratorFactory'} +sub _default_result_factory_class {'TAP::Parser::ResultFactory'} + +############################################################################## + +=head2 Instance Methods + +=head3 C + + my $parser = TAP::Parser->new( { source => $file } ); + while ( my $result = $parser->next ) { + print $result->as_string, "\n"; + } + +This method returns the results of the parsing, one result at a time. Note +that it is destructive. You can't rewind and examine previous results. + +If callbacks are used, they will be issued before this call returns. + +Each result returned is a subclass of L. See that +module and related classes for more information on how to use them. + +=cut + +sub next { + my $self = shift; + return ( $self->{_iter} ||= $self->_iter )->(); +} + +############################################################################## + +=head3 C + + $parser->run; + +This method merely runs the parser and parses all of the TAP. + +=cut + +sub run { + my $self = shift; + while ( defined( my $result = $self->next ) ) { + + # do nothing + } +} + +############################################################################## + +=head3 C + +Make a new L object and return it. Passes through any +arguments given. + +The C can be customized, as described in L. + +=head3 C + +Make a new L object and return it. Passes through +any arguments given. + +The C can be customized, as described in L. + +=head3 C + +Make a new L object and return it. Passes through any +arguments given. + +The C can be customized, as described in L. + +=head3 C + +Make a new L object using the parser's +L, and return it. Passes through any arguments +given. + +The C can be customized, as described in L. + +=head3 C + +Make a new L object using the parser's +L, and return it. Passes through any arguments +given. + +The C can be customized, as described in L. + +=cut + +# This should make overriding behaviour of the Parser in subclasses easier: +sub make_source { shift->source_class->new(@_); } +sub make_perl_source { shift->perl_source_class->new(@_); } +sub make_grammar { shift->grammar_class->new(@_); } +sub make_iterator { shift->iterator_factory_class->make_iterator(@_); } +sub make_result { shift->result_factory_class->make_result(@_); } + +sub _iterator_for_source { + my ( $self, $source ) = @_; + + # If the source has a get_stream method then use it. This makes it + # possible to pass a pre-existing source object to the parser's + # constructor. + if ( UNIVERSAL::can( $source, 'can' ) && $source->can('get_stream') ) { + return $source->get_stream($self); + } + else { + return $self->iterator_factory_class->make_iterator($source); + } +} + +{ + + # of the following, anything beginning with an underscore is strictly + # internal and should not be exposed. + my %initialize = ( + version => $DEFAULT_TAP_VERSION, + plan => '', # the test plan (e.g., 1..3) + tap => '', # the TAP + tests_run => 0, # actual current test numbers + results => [], # TAP parser results + skipped => [], # + todo => [], # + passed => [], # + failed => [], # + actual_failed => [], # how many tests really failed + actual_passed => [], # how many tests really passed + todo_passed => [], # tests which unexpectedly succeed + parse_errors => [], # perfect TAP should have none + ); + + # We seem to have this list hanging around all over the place. We could + # probably get it from somewhere else to avoid the repetition. + my @legal_callback = qw( + test + version + plan + comment + bailout + unknown + yaml + ALL + ELSE + EOF + ); + + my @class_overrides = qw( + source_class + perl_source_class + grammar_class + iterator_factory_class + result_factory_class + ); + + sub _initialize { + my ( $self, $arg_for ) = @_; + + # everything here is basically designed to convert any TAP source to a + # stream. + + # Shallow copy + my %args = %{ $arg_for || {} }; + + $self->SUPER::_initialize( \%args, \@legal_callback ); + + # get any class overrides out first: + for my $key (@class_overrides) { + my $default_method = "_default_$key"; + my $val = delete $args{$key} || $self->$default_method(); + $self->$key($val); + } + + my $stream = delete $args{stream}; + my $tap = delete $args{tap}; + my $source = delete $args{source}; + my $exec = delete $args{exec}; + my $merge = delete $args{merge}; + my $spool = delete $args{spool}; + my $switches = delete $args{switches}; + my $ignore_exit = delete $args{ignore_exit}; + my @test_args = @{ delete $args{test_args} || [] }; + + if ( 1 < grep {defined} $stream, $tap, $source, $exec ) { + $self->_croak( + "You may only choose one of 'exec', 'stream', 'tap' or 'source'" + ); + } + + if ( my @excess = sort keys %args ) { + $self->_croak("Unknown options: @excess"); + } + + if ($tap) { + $stream = $self->_iterator_for_source( [ split "\n" => $tap ] ); + } + elsif ($exec) { + my $source = $self->make_source; + $source->source( [ @$exec, @test_args ] ); + $source->merge($merge); # XXX should just be arguments? + $stream = $source->get_stream($self); + } + elsif ($source) { + if ( $source =~ /\n/ ) { + $stream + = $self->_iterator_for_source( [ split "\n" => $source ] ); + } + elsif ( ref $source ) { + $stream = $self->_iterator_for_source($source); + } + elsif ( -e $source ) { + my $perl = $self->make_perl_source; + + $perl->switches($switches) + if $switches; + + $perl->merge($merge); # XXX args to new()? + $perl->source( [ $source, @test_args ] ); + $stream = $perl->get_stream($self); + } + else { + $self->_croak("Cannot determine source for $source"); + } + } + + unless ($stream) { + $self->_croak('PANIC: could not determine stream'); + } + + while ( my ( $k, $v ) = each %initialize ) { + $self->{$k} = 'ARRAY' eq ref $v ? [] : $v; + } + + $self->_stream($stream); + $self->_spool($spool); + $self->ignore_exit($ignore_exit); + + return $self; + } +} + +=head1 INDIVIDUAL RESULTS + +If you've read this far in the docs, you've seen this: + + while ( my $result = $parser->next ) { + print $result->as_string; + } + +Each result returned is a L subclass, referred to as +I. + +=head2 Result types + +Basically, you fetch individual results from the TAP. The six types, with +examples of each, are as follows: + +=over 4 + +=item * Version + + TAP version 12 + +=item * Plan + + 1..42 + +=item * Pragma + + pragma +strict + +=item * Test + + ok 3 - We should start with some foobar! + +=item * Comment + + # Hope we don't use up the foobar. + +=item * Bailout + + Bail out! We ran out of foobar! + +=item * Unknown + + ... yo, this ain't TAP! ... + +=back + +Each result fetched is a result object of a different type. There are common +methods to each result object and different types may have methods unique to +their type. Sometimes a type method may be overridden in a subclass, but its +use is guaranteed to be identical. + +=head2 Common type methods + +=head3 C + +Returns the type of result, such as C or C. + +=head3 C + +Prints a string representation of the token. This might not be the exact +output, however. Tests will have test numbers added if not present, TODO and +SKIP directives will be capitalized and, in general, things will be cleaned +up. If you need the original text for the token, see the C method. + +=head3 C + +Returns the original line of text which was parsed. + +=head3 C + +Indicates whether or not this is the test plan line. + +=head3 C + +Indicates whether or not this is a test line. + +=head3 C + +Indicates whether or not this is a comment. Comments will generally only +appear in the TAP stream if STDERR is merged to STDOUT. See the +C option. + +=head3 C + +Indicates whether or not this is bailout line. + +=head3 C + +Indicates whether or not the current item is a YAML block. + +=head3 C + +Indicates whether or not the current line could be parsed. + +=head3 C + + if ( $result->is_ok ) { ... } + +Reports whether or not a given result has passed. Anything which is B a +test result returns true. This is merely provided as a convenient shortcut +which allows you to do this: + + my $parser = TAP::Parser->new( { source => $source } ); + while ( my $result = $parser->next ) { + # only print failing results + print $result->as_string unless $result->is_ok; + } + +=head2 C methods + + if ( $result->is_plan ) { ... } + +If the above evaluates as true, the following methods will be available on the +C<$result> object. + +=head3 C + + if ( $result->is_plan ) { + print $result->plan; + } + +This is merely a synonym for C. + +=head3 C + + my $directive = $result->directive; + +If a SKIP directive is included with the plan, this method will return it. + + 1..0 # SKIP: why bother? + +=head3 C + + my $explanation = $result->explanation; + +If a SKIP directive was included with the plan, this method will return the +explanation, if any. + +=head2 C methods + + if ( $result->is_pragma ) { ... } + +If the above evaluates as true, the following methods will be available on the +C<$result> object. + +=head3 C + +Returns a list of pragmas each of which is a + or - followed by the +pragma name. + +=head2 C methods + + if ( $result->is_comment ) { ... } + +If the above evaluates as true, the following methods will be available on the +C<$result> object. + +=head3 C + + if ( $result->is_comment ) { + my $comment = $result->comment; + print "I have something to say: $comment"; + } + +=head2 C methods + + if ( $result->is_bailout ) { ... } + +If the above evaluates as true, the following methods will be available on the +C<$result> object. + +=head3 C + + if ( $result->is_bailout ) { + my $explanation = $result->explanation; + print "We bailed out because ($explanation)"; + } + +If, and only if, a token is a bailout token, you can get an "explanation" via +this method. The explanation is the text after the mystical "Bail out!" words +which appear in the tap output. + +=head2 C methods + + if ( $result->is_unknown ) { ... } + +There are no unique methods for unknown results. + +=head2 C methods + + if ( $result->is_test ) { ... } + +If the above evaluates as true, the following methods will be available on the +C<$result> object. + +=head3 C + + my $ok = $result->ok; + +Returns the literal text of the C or C status. + +=head3 C + + my $test_number = $result->number; + +Returns the number of the test, even if the original TAP output did not supply +that number. + +=head3 C + + my $description = $result->description; + +Returns the description of the test, if any. This is the portion after the +test number but before the directive. + +=head3 C + + my $directive = $result->directive; + +Returns either C or C if either directive was present for a test +line. + +=head3 C + + my $explanation = $result->explanation; + +If a test had either a C or C directive, this method will return +the accompanying explantion, if present. + + not ok 17 - 'Pigs can fly' # TODO not enough acid + +For the above line, the explanation is I. + +=head3 C + + if ( $result->is_ok ) { ... } + +Returns a boolean value indicating whether or not the test passed. Remember +that for TODO tests, the test always passes. + +B this was formerly C. The latter method is deprecated and +will issue a warning. + +=head3 C + + if ( $result->is_actual_ok ) { ... } + +Returns a boolean value indicating whether or not the test passed, regardless +of its TODO status. + +B this was formerly C. The latter method is deprecated +and will issue a warning. + +=head3 C + + if ( $test->is_unplanned ) { ... } + +If a test number is greater than the number of planned tests, this method will +return true. Unplanned tests will I return false for C, +regardless of whether or not the test C (see +L for more information about this). + +=head3 C + + if ( $result->has_skip ) { ... } + +Returns a boolean value indicating whether or not this test had a SKIP +directive. + +=head3 C + + if ( $result->has_todo ) { ... } + +Returns a boolean value indicating whether or not this test had a TODO +directive. + +Note that TODO tests I pass. If you need to know whether or not +they really passed, check the C method. + +=head3 C + + if ( $parser->in_todo ) { ... } + +True while the most recent result was a TODO. Becomes true before the +TODO result is returned and stays true until just before the next non- +TODO test is returned. + +=head1 TOTAL RESULTS + +After parsing the TAP, there are many methods available to let you dig through +the results and determine what is meaningful to you. + +=head2 Individual Results + +These results refer to individual tests which are run. + +=head3 C + + my @passed = $parser->passed; # the test numbers which passed + my $passed = $parser->passed; # the number of tests which passed + +This method lets you know which (or how many) tests passed. If a test failed +but had a TODO directive, it will be counted as a passed test. + +=cut + +sub passed { @{ shift->{passed} } } + +=head3 C + + my @failed = $parser->failed; # the test numbers which failed + my $failed = $parser->failed; # the number of tests which failed + +This method lets you know which (or how many) tests failed. If a test passed +but had a TODO directive, it will B be counted as a failed test. + +=cut + +sub failed { @{ shift->{failed} } } + +=head3 C + + # the test numbers which actually passed + my @actual_passed = $parser->actual_passed; + + # the number of tests which actually passed + my $actual_passed = $parser->actual_passed; + +This method lets you know which (or how many) tests actually passed, +regardless of whether or not a TODO directive was found. + +=cut + +sub actual_passed { @{ shift->{actual_passed} } } +*actual_ok = \&actual_passed; + +=head3 C + +This method is a synonym for C. + +=head3 C + + # the test numbers which actually failed + my @actual_failed = $parser->actual_failed; + + # the number of tests which actually failed + my $actual_failed = $parser->actual_failed; + +This method lets you know which (or how many) tests actually failed, +regardless of whether or not a TODO directive was found. + +=cut + +sub actual_failed { @{ shift->{actual_failed} } } + +############################################################################## + +=head3 C + + my @todo = $parser->todo; # the test numbers with todo directives + my $todo = $parser->todo; # the number of tests with todo directives + +This method lets you know which (or how many) tests had TODO directives. + +=cut + +sub todo { @{ shift->{todo} } } + +=head3 C + + # the test numbers which unexpectedly succeeded + my @todo_passed = $parser->todo_passed; + + # the number of tests which unexpectedly succeeded + my $todo_passed = $parser->todo_passed; + +This method lets you know which (or how many) tests actually passed but were +declared as "TODO" tests. + +=cut + +sub todo_passed { @{ shift->{todo_passed} } } + +############################################################################## + +=head3 C + + # deprecated in favor of 'todo_passed'. This method was horribly misnamed. + +This was a badly misnamed method. It indicates which TODO tests unexpectedly +succeeded. Will now issue a warning and call C. + +=cut + +sub todo_failed { + warn + '"todo_failed" is deprecated. Please use "todo_passed". See the docs.'; + goto &todo_passed; +} + +=head3 C + + my @skipped = $parser->skipped; # the test numbers with SKIP directives + my $skipped = $parser->skipped; # the number of tests with SKIP directives + +This method lets you know which (or how many) tests had SKIP directives. + +=cut + +sub skipped { @{ shift->{skipped} } } + +=head2 Pragmas + +=head3 C + +Get or set a pragma. To get the state of a pragma: + + if ( $p->pragma('strict') ) { + # be strict + } + +To set the state of a pragma: + + $p->pragma('strict', 1); # enable strict mode + +=cut + +sub pragma { + my ( $self, $pragma ) = splice @_, 0, 2; + + return $self->{pragma}->{$pragma} unless @_; + + if ( my $state = shift ) { + $self->{pragma}->{$pragma} = 1; + } + else { + delete $self->{pragma}->{$pragma}; + } + + return; +} + +=head3 C + +Get a list of all the currently enabled pragmas: + + my @pragmas_enabled = $p->pragmas; + +=cut + +sub pragmas { sort keys %{ shift->{pragma} || {} } } + +=head2 Summary Results + +These results are "meta" information about the total results of an individual +test program. + +=head3 C + + my $plan = $parser->plan; + +Returns the test plan, if found. + +=head3 C + +Deprecated. Use C instead. + +=cut + +sub good_plan { + warn 'good_plan() is deprecated. Please use "is_good_plan()"'; + goto &is_good_plan; +} + +############################################################################## + +=head3 C + + if ( $parser->is_good_plan ) { ... } + +Returns a boolean value indicating whether or not the number of tests planned +matches the number of tests run. + +B this was formerly C. The latter method is deprecated and +will issue a warning. + +And since we're on that subject ... + +=head3 C + + print $parser->tests_planned; + +Returns the number of tests planned, according to the plan. For example, a +plan of '1..17' will mean that 17 tests were planned. + +=head3 C + + print $parser->tests_run; + +Returns the number of tests which actually were run. Hopefully this will +match the number of C<< $parser->tests_planned >>. + +=head3 C + +Returns a true value (actually the reason for skipping) if all tests +were skipped. + +=head3 C + +Returns the time when the Parser was created. + +=head3 C + +Returns the time when the end of TAP input was seen. + +=head3 C + + if ( $parser->has_problems ) { + ... + } + +This is a 'catch-all' method which returns true if any tests have currently +failed, any TODO tests unexpectedly succeeded, or any parse errors occurred. + +=cut + +sub has_problems { + my $self = shift; + return + $self->failed + || $self->parse_errors + || ( !$self->ignore_exit && ( $self->wait || $self->exit ) ); +} + +=head3 C + + $parser->version; + +Once the parser is done, this will return the version number for the +parsed TAP. Version numbers were introduced with TAP version 13 so if no +version number is found version 12 is assumed. + +=head3 C + + $parser->exit; + +Once the parser is done, this will return the exit status. If the parser ran +an executable, it returns the exit status of the executable. + +=head3 C + + $parser->wait; + +Once the parser is done, this will return the wait status. If the parser ran +an executable, it returns the wait status of the executable. Otherwise, this +mererely returns the C status. + +=head2 C + + $parser->ignore_exit(1); + +Tell the parser to ignore the exit status from the test when determining +whether the test passed. Normally tests with non-zero exit status are +considered to have failed even if all individual tests passed. In cases +where it is not possible to control the exit value of the test script +use this option to ignore it. + +=cut + +sub ignore_exit { shift->pragma( 'ignore_exit', @_ ) } + +=head3 C + + my @errors = $parser->parse_errors; # the parser errors + my $errors = $parser->parse_errors; # the number of parser_errors + +Fortunately, all TAP output is perfect. In the event that it is not, this +method will return parser errors. Note that a junk line which the parser does +not recognize is C an error. This allows this parser to handle future +versions of TAP. The following are all TAP errors reported by the parser: + +=over 4 + +=item * Misplaced plan + +The plan (for example, '1..5'), must only come at the beginning or end of the +TAP output. + +=item * No plan + +Gotta have a plan! + +=item * More than one plan + + 1..3 + ok 1 - input file opened + not ok 2 - first line of the input valid # todo some data + ok 3 read the rest of the file + 1..3 + +Right. Very funny. Don't do that. + +=item * Test numbers out of sequence + + 1..3 + ok 1 - input file opened + not ok 2 - first line of the input valid # todo some data + ok 2 read the rest of the file + +That last test line above should have the number '3' instead of '2'. + +Note that it's perfectly acceptable for some lines to have test numbers and +others to not have them. However, when a test number is found, it must be in +sequence. The following is also an error: + + 1..3 + ok 1 - input file opened + not ok - first line of the input valid # todo some data + ok 2 read the rest of the file + +But this is not: + + 1..3 + ok - input file opened + not ok - first line of the input valid # todo some data + ok 3 read the rest of the file + +=back + +=cut + +sub parse_errors { @{ shift->{parse_errors} } } + +sub _add_error { + my ( $self, $error ) = @_; + push @{ $self->{parse_errors} } => $error; + return $self; +} + +sub _make_state_table { + my $self = shift; + my %states; + my %planned_todo = (); + + # These transitions are defaults for all states + my %state_globals = ( + comment => {}, + bailout => {}, + yaml => {}, + version => { + act => sub { + $self->_add_error( + 'If TAP version is present it must be the first line of output' + ); + }, + }, + unknown => { + act => sub { + my $unk = shift; + if ( $self->pragma('strict') ) { + $self->_add_error( + 'Unknown TAP token: "' . $unk->raw . '"' ); + } + }, + }, + pragma => { + act => sub { + my ($pragma) = @_; + for my $pr ( $pragma->pragmas ) { + if ( $pr =~ /^ ([-+])(\w+) $/x ) { + $self->pragma( $2, $1 eq '+' ); + } + } + }, + }, + ); + + # Provides default elements for transitions + my %state_defaults = ( + plan => { + act => sub { + my ($plan) = @_; + $self->tests_planned( $plan->tests_planned ); + $self->plan( $plan->plan ); + if ( $plan->has_skip ) { + $self->skip_all( $plan->explanation + || '(no reason given)' ); + } + + $planned_todo{$_}++ for @{ $plan->todo_list }; + }, + }, + test => { + act => sub { + my ($test) = @_; + + my ( $number, $tests_run ) + = ( $test->number, ++$self->{tests_run} ); + + # Fake TODO state + if ( defined $number && delete $planned_todo{$number} ) { + $test->set_directive('TODO'); + } + + my $has_todo = $test->has_todo; + + $self->in_todo($has_todo); + if ( defined( my $tests_planned = $self->tests_planned ) ) { + if ( $tests_run > $tests_planned ) { + $test->is_unplanned(1); + } + } + + if ( defined $number ) { + if ( $number != $tests_run ) { + my $count = $tests_run; + $self->_add_error( "Tests out of sequence. Found " + . "($number) but expected ($count)" ); + } + } + else { + $test->_number( $number = $tests_run ); + } + + push @{ $self->{todo} } => $number if $has_todo; + push @{ $self->{todo_passed} } => $number + if $test->todo_passed; + push @{ $self->{skipped} } => $number + if $test->has_skip; + + push @{ $self->{ $test->is_ok ? 'passed' : 'failed' } } => + $number; + push @{ + $self->{ + $test->is_actual_ok + ? 'actual_passed' + : 'actual_failed' + } + } => $number; + }, + }, + yaml => { act => sub { }, }, + ); + + # Each state contains a hash the keys of which match a token type. For + # each token + # type there may be: + # act A coderef to run + # goto The new state to move to. Stay in this state if + # missing + # continue Goto the new state and run the new state for the + # current token + %states = ( + INIT => { + version => { + act => sub { + my ($version) = @_; + my $ver_num = $version->version; + if ( $ver_num <= $DEFAULT_TAP_VERSION ) { + my $ver_min = $DEFAULT_TAP_VERSION + 1; + $self->_add_error( + "Explicit TAP version must be at least " + . "$ver_min. Got version $ver_num" ); + $ver_num = $DEFAULT_TAP_VERSION; + } + if ( $ver_num > $MAX_TAP_VERSION ) { + $self->_add_error( + "TAP specified version $ver_num but " + . "we don't know about versions later " + . "than $MAX_TAP_VERSION" ); + $ver_num = $MAX_TAP_VERSION; + } + $self->version($ver_num); + $self->_grammar->set_version($ver_num); + }, + goto => 'PLAN' + }, + plan => { goto => 'PLANNED' }, + test => { goto => 'UNPLANNED' }, + }, + PLAN => { + plan => { goto => 'PLANNED' }, + test => { goto => 'UNPLANNED' }, + }, + PLANNED => { + test => { goto => 'PLANNED_AFTER_TEST' }, + plan => { + act => sub { + my ($version) = @_; + $self->_add_error( + 'More than one plan found in TAP output'); + }, + }, + }, + PLANNED_AFTER_TEST => { + test => { goto => 'PLANNED_AFTER_TEST' }, + plan => { act => sub { }, continue => 'PLANNED' }, + yaml => { goto => 'PLANNED' }, + }, + GOT_PLAN => { + test => { + act => sub { + my ($plan) = @_; + my $line = $self->plan; + $self->_add_error( + "Plan ($line) must be at the beginning " + . "or end of the TAP output" ); + $self->is_good_plan(0); + }, + continue => 'PLANNED' + }, + plan => { continue => 'PLANNED' }, + }, + UNPLANNED => { + test => { goto => 'UNPLANNED_AFTER_TEST' }, + plan => { goto => 'GOT_PLAN' }, + }, + UNPLANNED_AFTER_TEST => { + test => { act => sub { }, continue => 'UNPLANNED' }, + plan => { act => sub { }, continue => 'UNPLANNED' }, + yaml => { goto => 'PLANNED' }, + }, + ); + + # Apply globals and defaults to state table + for my $name ( keys %states ) { + + # Merge with globals + my $st = { %state_globals, %{ $states{$name} } }; + + # Add defaults + for my $next ( sort keys %{$st} ) { + if ( my $default = $state_defaults{$next} ) { + for my $def ( sort keys %{$default} ) { + $st->{$next}->{$def} ||= $default->{$def}; + } + } + } + + # Stuff back in table + $states{$name} = $st; + } + + return \%states; +} + +=head3 C + +Get an a list of file handles which can be passed to C