Commits

Shlomi Fish committed 5298f5a

Remove trailing space from Test-Run.

  • Participants
  • Parent commits 9940cc1

Comments (0)

Files changed (56)

modules/Test-Run/Build.PL

     {
         "Test::Trap" => 0,
     },
-    requires => 
+    requires =>
     {
         'File::Spec' => 0.6,
         'IPC::System::Simple' => '1.21',

modules/Test-Run/Changes

+    * Remove trailing space with a test - t/style-trailing-space.t .
+
 0.0126
     * Fix the tests on windows by using IPC::System::Simple instead of
     list-form of open "-|".
 
 0.0118    Mon May  4 20:33:10 IDT 2009
     * Increased the test coverage.
-    * Converted the use of the old and deprecated NEXT.pm to 
+    * Converted the use of the old and deprecated NEXT.pm to
     MRO::Compat / mro.pm .
 
 0.0117    Mon Aug 18 19:53:38 IDT 2008
     accept a hash ref instead of ($name, $format).
 
 0.0116    Fri Apr 11 20:20:50 IDT 2008
-    * Wrote a fix to the test failures that Test-Run-0.0115 experienced on 
+    * Wrote a fix to the test failures that Test-Run-0.0115 experienced on
     BSD systems due to a test-script path over 256 bytes.
         - bug in the test script, not the code.
         - http://cpantesters.perl.org/show/Test-Run.html#Test-Run-0.0115
 
 0.0113    Tue Feb 19 20:05:29 IST 2008
     * Converted more functionality from Test::Run::Core_GplArt into
-    a BSD-licensed code. Now there's nothing in Core_GplArt except 
+    a BSD-licensed code. Now there's nothing in Core_GplArt except
     (out-of-date) documentation.
-    * Moved Test::Run::Straps Test::Run::Straps_GplArt and made 
+    * Moved Test::Run::Straps Test::Run::Straps_GplArt and made
     Test::Run::Straps a BSD-licensed class that inherits from it. Started
     moving functionality and documentation there.
     * Moved Test::Trap from the requires to the build_requires.
     * More refactoring - methods extractions, etc.
     * Added "use strict" and "use warnings" to all the .pm files.
-    * Added a link to the MIT X11 license to many modules and some POD to one 
-    of the modules. This way finding which modules are MIT X11 will be easier 
+    * Added a link to the MIT X11 license to many modules and some POD to one
+    of the modules. This way finding which modules are MIT X11 will be easier
     using grep -rL or grep -rl.
     * Added the _run_sequence method to Test::Run::Base to run a sequence
     of methods one after the other.
-    * Added the Test::Run::Straps::EventWrapper class to wrap a 
+    * Added the Test::Run::Straps::EventWrapper class to wrap a
     TAP::Parser::Result and derived objects, and to delegate methods to it.
     * Implemented the delegate_methods() method in Test::Run::Base to
     delegate methods to an accessor.
         - Added the t-r-base-delegate.t test file.
-    * Added the Test::Run module which will serve as the front-page for 
+    * Added the Test::Run module which will serve as the front-page for
     the Test::Run suite on search.cpan.org and other resources.
 
 0.0112    Sun Jun 24 19:23:42 IDT 2007
     test file.
 
 0.0111    Sat Jun 23 11:56:31 IDT 2007
-    * Added Test::Run::Base::Plugger for managing classes with plug-ins and 
+    * Added Test::Run::Base::Plugger for managing classes with plug-ins and
     made the helper classes into pluggable classes.
     * Converted more functionality from Test::Run::Core_GplArt into
     a BSD-licensed code.
 
 0.0110     Mon Jun 11 14:13:58 IDT 2007
-    * Converted several helper modules to the MIT X11 licence, while 
+    * Converted several helper modules to the MIT X11 licence, while
     refactoring them in the process.
         - every module specifically mentions its licence.
     * Converted several functions to use Text::Sprintf::Named.
-    * Added dependence on Text::Sprintf::Named 0.02, in order to better 
-    refactor the code. Added the T::R::Sprintf::Named::FromAccessors module 
-    to retrieve values from the accessors. Started refactoring some of the 
+    * Added dependence on Text::Sprintf::Named 0.02, in order to better
+    refactor the code. Added the T::R::Sprintf::Named::FromAccessors module
+    to retrieve values from the accessors. Started refactoring some of the
     code to use it.
-    * Added the Test::Run::Trap::Obj class for managing trapping with 
+    * Added the Test::Run::Trap::Obj class for managing trapping with
     verbose debug information.
         - base on Test::Trap
         - Converted most of the tests to use it.
-    * Fixed the Test-Run-Plugin-ColorFileVerdicts module, as it was 
+    * Fixed the Test-Run-Plugin-ColorFileVerdicts module, as it was
     broken due to the refactorings and moving of methods to ::CanonFailedObj.
     * Added the class hierarchy calculation routines.
         - Added the feature to accumulate directly on the class.
         - concept borrowed from (but does not share code with) Class::Std.
 
 0.0109    Mon Mar 19 15:22:35 IST 2007
-    * Refactored some code to make it more easily extensible and 
+    * Refactored some code to make it more easily extensible and
     over-ridable. Used in some plugins.
     * Added an ACTION_tags to Test::Run::Builder.
     * Converted the tests to use Test::Trap.
     changes to the tests and code to get over several regressions.
 
 0.0104    Fri Feb 23 14:25:29 IST 2007
-    * Added an empty PL_FILES key to the Makefile.PL to please old 
+    * Added an empty PL_FILES key to the Makefile.PL to please old
       ExtUtils::MakeMaker's that try to invoke "Build.PL Build".
-    * Fixed the skip to skip 7 tests instead of 8 - it broke the build 
+    * Fixed the skip to skip 7 tests instead of 8 - it broke the build
       in perl-5.6.2.
 
 0.0103    Fri Feb 16 23:09:24 IST 2007
     * Made part of the Straps code clearer.
     * Extracted out the _init_strap method. This will be used by future
     plugins.
-    * Fixed a bug where the modified Test_Interperter was used to query the 
+    * Fixed a bug where the modified Test_Interperter was used to query the
     Perl paths.
-    * Fixed a bug with the percent being possibly undefined in output. 
+    * Fixed a bug with the percent being possibly undefined in output.
     Added a regression test.
 
 0.0102    Wed Nov 15 22:18:10 IST 2006
     * Bumped the version number.
 
 0.0101    Wed Nov  1 21:43:36 IST 2006
-    * Fixed the error indicator in the call to 
+    * Fixed the error indicator in the call to
     _handle_test_file_closing_error() - $! instead of $1.
     * Added more POD for web resources of the module.
-    * Added an example for integrating Test::Run into an EU::MM and 
+    * Added an example for integrating Test::Run into an EU::MM and
     Test::Manifest setup.
     * Updated the TODO.
     * First non-Developer release!
     wrong) for better debugability.
     * A lot of refactoring of Test::Run::Straps.
     * Added several tests for the output of tests' outcomes.
-    * Moved all the ->output()'s outputs to a separate plugin 
+    * Moved all the ->output()'s outputs to a separate plugin
     (Test::Run::Plugin::CmdLine::Output), and moved the rest of the core
     functionality to Test::Run::Core.
     * Converted the strap handlers to be methods of Test::Run::Core, and
     the callback to be a closure that calls its method.
 
 0.0100_09 Sat May 13 11:56:41 IDT 2006
-    * Extracted the _get_fail_test_scripts_string() and 
-    _get_fail_tests_good_percent_string() methods out of 
+    * Extracted the _get_fail_test_scripts_string() and
+    _get_fail_tests_good_percent_string() methods out of
     _get_fail_other_exception_text() methods for easy overriding, and
     implementing the error line customization plugins.
 
 0.0100_08 Sat Apr  8 18:39:28 IDT 2006
-    * A refactoring of _handle_runtests_error(), which would allow an 
+    * A refactoring of _handle_runtests_error(), which would allow an
     easier coding of Plugin::ColorSummary.
     * Added Scalar::Util to the Makefile.PL's "PREREQ_PM" and removed a
     redundant statement.
 0.0100_06 Tue Nov 29 22:40:08 IST 2005
     * Fixed the bug where "All tests successful." was displayed as
     "All tests successful0.". Added an appropriate test.
-    * Eliminated the unnecessary warning on the Pod::Usage in the 
+    * Eliminated the unnecessary warning on the Pod::Usage in the
     Makefile.PL of Test::Run. Now it just doesn't install prove.
     * Moved two test scripts that are depenedent on prove (or exit on its
     non-installation), to a temporary location to be restored when
     Test::Run::CmdLine is in better shape.
     * Some refactorings.
-        - Added the Test::Run::Obj::Error module for throwing errors. Moved 
-        one FAILED report to it, and change Run::Obj to be compatible with 
+        - Added the Test::Run::Obj::Error module for throwing errors. Moved
+        one FAILED report to it, and change Run::Obj to be compatible with
         some refactoring in the way.
     * Added a TODO File.
     * Fix a problem with a missing comma in the output of Test::Run when
     there are skipped subtests.
-    
+
 0.0100_05 Sat Nov 09 21:00:00 IST 2005
     * Renamed to Test::Run
 
 
     There are also some minor bug fixes in Test::Harness itself, listed
     below in the 2.31_* notes.
-     
+
 
 2.31_05     Thu Nov  6 14:56:22 CST 2003
     [FIXES]
     - If a MacPerl script had a shebang with -T, the -T wouldn't get
       passed as a switch.
-    - Removed the -T on three *.t files, which didn't need them, and 
+    - Removed the -T on three *.t files, which didn't need them, and
       which were causing problems.
     - Conditionally installs bin/prove, depending on whether Pod::Usage
       is available, which prove needs.
     - Ilya noticed the per test skip reason was accumlating between tests.
 
 2.26  Wed Jun 19 16:58:02 EDT 2002
-    - Workaround for MacPerl's lack of a working putenv.  It will never 
+    - Workaround for MacPerl's lack of a working putenv.  It will never
       see the PERL5LIB environment variable (perl@16942).
 
 2.25  Sun Jun 16 03:00:33 EDT 2002
       die, not return false, when any tests fail.  This is silly, but
       historically necessary for 'make test'.  Docs corrected.
     - MacPerl test fixes from Pudge. (mutation of bleadperl@16989)
-    - Undef warning introduced in 2.24 on skipped tests with no reasons 
+    - Undef warning introduced in 2.24 on skipped tests with no reasons
       fixed.
     * Test::Harness now depends on File::Spec
 
 2.02  Thu Mar 14 18:06:04 EST 2002
     * Ken Williams fixed the long standing $^X bug.
     * Added HARNESS_VERBOSE
-    * Fixed a bug where Test::Harness::Straps was considering a test that 
+    * Fixed a bug where Test::Harness::Straps was considering a test that
       is ok but died as passing.
-    - Added the exit and wait codes of the test to the 
+    - Added the exit and wait codes of the test to the
       analyze_file() results.
 
 2.01  Thu Dec 27 18:54:36 EST 2001
       but Test::Harness still doesn't.
 
 2.00_05 Mon Dec 17 22:08:02 EST 2001
-    * Wasn't filtering @INC properly when a test is run with -T, caused the 
+    * Wasn't filtering @INC properly when a test is run with -T, caused the
       command line to be too long on VMS.  VMS should be 100% now.
     - Little bug in the skip 'various reasons' logic.
     - Minor POD nit in 5.004_04

modules/Test-Run/MANIFEST

 t/sample-tests/with_comments
 t/sample-tests/with-myhello
 t/sample-tests/with-myhello-and-myfoo
+t/style-trailing-space.t
 t/switches.t
 t/test-failure-report.t
 t/test-harness.t

modules/Test-Run/README

 in turn derived from the code of t/TEST in the Perl distribution which dates
 back to Perl 1. It is licensed under the same terms as Perl itself.
 
-* It is our intention to write new code an convert existing code to the MIT 
+* It is our intention to write new code an convert existing code to the MIT
 X11 license ( http://www.opensource.org/licenses/mit-license.php ), to allow
-for maximum flexibility of the codebase, and to relieve it of ownership hands. 
+for maximum flexibility of the codebase, and to relieve it of ownership hands.
 
 * One should consult the individual files for their copyrights' notices.
 
-* Note that the other CPAN Test::Run distributions (by "Shlomi Fish" and 
+* Note that the other CPAN Test::Run distributions (by "Shlomi Fish" and
 possibly others) were written from scratch and are fully licensed under the
 MIT X11 license.
 

modules/Test-Run/TODO

 * Speed up the performance of Test::Run. It's currently pretty slow.
 
-* Update the documentation - currently it's mostly updated only to 
+* Update the documentation - currently it's mostly updated only to
 Test::Harness.
 
 * Add an arbitrary number of leaked directories.

modules/Test-Run/examples/eumm-and-test-manifest/Makefile.PL

 
 sub ExtUtils::MM_Any::test_via_harness {
     my($self, $perl, $tests) = @_;
-    
+
     return qq|\t$perl "-MTest::Manifest" | .
       qq|"-e" "run_t_manifest(\$(TEST_VERBOSE), '\$(INST_LIB)', | .
         qq|'\$(INST_ARCHLIB)')"\n|;
 WriteMakefile(
               'NAME'         => 'XML::RSS',
               'VERSION_FROM' => 'lib/XML/RSS.pm', # finds $VERSION,
-              'PREREQ_PM'    => { 
+              'PREREQ_PM'    => {
                                  'Test::Manifest'   => '0.9',
                                  'Test::More'       => '0',
-                                 'XML::Parser'      => '2.23', 
-                                 'HTML::Entities'   => 0, 
+                                 'XML::Parser'      => '2.23',
+                                 'HTML::Entities'   => 0,
                                  'DateTime' => 0,
                                  'DateTime::Format::Mail' => 0,
                                  'DateTime::Format::W3CDTF' => 0,

modules/Test-Run/examples/mini_harness.plx

 #!/usr/bin/perl
 
-# This is an example of how to write your own harness using 
-# Test::Harness::Straps.  It duplicates most of the features of 
+# This is an example of how to write your own harness using
+# Test::Harness::Straps.  It duplicates most of the features of
 # Test::Harness.
 #
 # It uses an undocumented, experimental

modules/Test-Run/inc/Test/Run/Builder.pm

         Test::Run::CmdLine::Iface->new(
             {
                 'test_files' => [glob("t/*.t")],
-            }   
+            }
             # 'backend_params' => $self->_get_backend_params(),
         );
 
 
 sub ACTION_tags
 {
-    return 
+    return
         system(qw(
             ctags -f tags --recurse --totals
     		--exclude=blib/** --exclude=t/lib/**

modules/Test-Run/lib/Test/Run.pm

 
 =head1 ACKNOWLEDGEMENTS
 
-The (possibly ad-hoc) regex for matching the optional digits+symbols 
-parameters' prefix of the sprintf conversion was originally written by Bart 
+The (possibly ad-hoc) regex for matching the optional digits+symbols
+parameters' prefix of the sprintf conversion was originally written by Bart
 Lateur (BARTL on CPAN) for his L<String::Sprintf> module.
 
 =head1 COPYRIGHT & LICENSE

modules/Test-Run/lib/Test/Run/Assert.pm

     if (! $condition)
     {
         require Carp;
-        
-        my $msg = 
+
+        my $msg =
             sprintf("Assert failed - '%s'!", $name)
-            ; 
+            ;
 
         Carp::croak($msg);
     }

modules/Test-Run/lib/Test/Run/Base.pm

     return
         Test::Run::Sprintf::Named::FromAccessors->new(
             { fmt => $fmt, },
-        );    
+        );
 }
 
 sub _register_obj_formatter
 
 This is a more simplistic version of the :CUMULATIVE functionality
 in Class::Std. It was done to make sure that one can collect all the
-members of array refs out of methods defined in each class into one big 
+members of array refs out of methods defined in each class into one big
 array ref, that can later be used.
 
 =cut
 
     my $method_name = $args->{method};
 
-    # my $class = ((ref($self) eq "") ? $self : ref($self));   
+    # my $class = ((ref($self) eq "") ? $self : ref($self));
 
     my @results;
     foreach my $isa_class (
 
 =head2 $self->_run_sequence(\@params)
 
-Runs the sequence of commands specified using 
-C<_calc__${calling_sub}__callbacks> while passing @params to 
+Runs the sequence of commands specified using
+C<_calc__${calling_sub}__callbacks> while passing @params to
 each one. Generates a list of all the callbacks return values.
 
 =cut
 
     my $calc_cbs_sub = "_calc__${1}__callbacks";
 
-    return 
-    [ 
+    return
+    [
         map { my $cb = $_; $self->$cb(@$params); }
         @{$self->$calc_cbs_sub(@$params)}
     ];

modules/Test-Run/lib/Test/Run/Base/PlugHelpers.pm

 
 use Test::Run::Base::Plugger;
 
-has '_plug_helpers' => (is => "rw", isa => "HashRef", 
+has '_plug_helpers' => (is => "rw", isa => "HashRef",
     lazy => 1, default => sub { +{} },
 );
 
 
 The method from which to collect the plugins. It should be defined for every
 base class in the hierarchy of the main class (that instantiates the helpers)
-and is traversed there. 
+and is traversed there.
 
 =back
 
         $plug_helper_struct{$key} = $value;
     }
 
-    $self->_plug_helpers()->{$plug_helper_struct{'id'}} 
+    $self->_plug_helpers()->{$plug_helper_struct{'id'}}
         = \%plug_helper_struct;
 
     return;
         )
     );
 
-    return 
+    return
         $plugger->create_new(
             $args->{args},
         );

modules/Test-Run/lib/Test/Run/Base/Plugger.pm

     my $self = shift;
 
     $self->_update_ISA();
- 
+
     return;
 }
 
 sub _update_ISA
 {
     my $self = shift;
-    
+
     my $base_class = $self->_base();
     my $into_class = $self->_into();
 
             die $@;
         }
         push @$isa_ref, $plugin;
-    }    
+    }
 
     if (!$base_class->require())
     {

modules/Test-Run/lib/Test/Run/Base/Struct.pm

 sub BUILD
 {
     my $self = shift;
-    
+
 =begin debugging_code
 
     Carp::confess '$args not a hash' if (ref($args) ne "HASH");

modules/Test-Run/lib/Test/Run/Class/Hierarchy.pm

             {
                   $a->isa($b) ? -1
                 : $b->isa($a) ? +1
-                :               0 
+                :               0
             }
             @unique
         ];

modules/Test-Run/lib/Test/Run/Core.pm

 }
 
 has "_bonusmsg" => (is => "rw", isa => "Str");
-has "dir_files" => (is => "rw", isa => "ArrayRef", lazy => 1, 
+has "dir_files" => (is => "rw", isa => "ArrayRef", lazy => 1,
     default => sub { [] },
 );
 has "_new_dir_files" => (is => "rw", isa => "Maybe[ArrayRef]");
 has "list_len" => (is => "rw", isa => "Num", default => 0);
 has "max_namelen" => (is => "rw", isa => "Num");
 
-# I don't know for sure what output is. It is Test::Run::Output in 
+# I don't know for sure what output is. It is Test::Run::Output in
 # Test::Run::Plugin::CmdLine::Output but could be different elsewhere.
 has "output" => (is => "rw", isa => "Ref");
 has "_start_time" => (is => "rw", isa => "Num");
 has "Switches" => (is => "rw", isa => "Maybe[Str]", default => "-w",);
 has "Switches_Env" => (is => "rw", isa => "Maybe[Str]");
 has "test_files" => (is => "rw", isa => "ArrayRef");
-has "test_files_data" => (is => "rw", isa => "HashRef", 
+has "test_files_data" => (is => "rw", isa => "HashRef",
     default => sub { +{} },
 );
 has "Test_Interpreter" => (is => "rw", isa => "Maybe[Str]");
         }
     );
 
-Alternatively, before C<runtests()> is called, they can be set by passing a 
+Alternatively, before C<runtests()> is called, they can be set by passing a
 value to their accessor:
 
     $tester->Verbose(1);
 
 =item C<$self-E<gt>Verbose()>
 
-The object variable C<$self-E<gt>Verbose()> can be used to let C<runtests()> 
+The object variable C<$self-E<gt>Verbose()> can be used to let C<runtests()>
 display the standard output of the script without altering the behavior
 otherwise.  The F<runprove> utility's C<-v> flag will set this.
 
   LEAKED FILES: scr.tmp 0 my.db
 
 If relative, directory name is with respect to the current directory at
-the moment C<$tester-E<gt>runtests()> was called.  Putting the absolute path 
+the moment C<$tester-E<gt>runtests()> was called.  Putting the absolute path
 into C<Leaked_Dir> will give more predictable results.
 
-=item C<$self-E<gt>Debug()> 
+=item C<$self-E<gt>Debug()>
 
 If C<$self-E<gt>Debug()> is true, Test::Run will print debugging information
 about itself as it runs the tests.  This is different from
 each test.  For example, setting one of them to C<-W> will
 run all tests with all warnings enabled.
 
-The difference between them is that C<Switches_Env()> is expected to be 
+The difference between them is that C<Switches_Env()> is expected to be
 filled in by the environment and C<Switches()> from other sources (like the
 programmer).
 
 
 =over 4
 
-=item * test_struct 
+=item * test_struct
 
 The test struct as returned by straps.
 
 sub _calc_leaked_files_since_last_update
 {
     my $self = shift;
-   
+
     my %found;
 
     @found{@{$self->_new_dir_files()}} = (1) x @{$self->_new_dir_files()};
-    
+
     delete(@found{@{$self->dir_files()}});
 
     return [sort keys(%found)];
     my $self = shift;
 
     $self->_new_dir_files($self->_get_dir_files());
-    
+
     $self->_report_leaked_files(
-        { 
+        {
             leaked_files => $self->_calc_leaked_files_since_last_update()
         }
     );
 
 sub _calc_strap_callback_map
 {
-    return 
+    return
     {
         "tap_event"        => "_tap_event_strap_callback",
         "report_start_env" => "_report_script_start_environment",
 sub _strap_callback
 {
     my ($self, $args) = @_;
-    
+
     my $type = $args->{type};
     my $cb = $self->_calc_strap_callback_map()->{$type};
 
 
 =head2 $self->_calc_test_struct_ml($results)
 
-Calculates the ml(). (See L<Test::Run::Output>) for the test. 
+Calculates the ml(). (See L<Test::Run::Output>) for the test.
 
 =cut
 
     my $self = shift;
 
     my $results = $self->last_test_results;
-    
-    return 
+
+    return
     [
         (
-            map { $_ => $results->$_(), } 
+            map { $_ => $results->$_(), }
             (qw(bonus max ok skip_reason skip_all))
         ),
         skipped => $results->skip(),
     my $results = $self->last_test_results;
 
     $self->_tot_add_results($results);
-    
+
     return $self->last_test_obj(
         $self->_create_test_obj_instance(
             {
 
     return $self->_max_len(
         [ map { $self->$cb($self->_get_test_file_display_path($_)) }
-          @{$self->test_files()} 
+          @{$self->test_files()}
         ]
     );
 }
 
     return $self->_create_failed_obj_instance(
         {
-            (map 
-                { $_ => Test::Run::Obj::IntOrUnknown->create_unknown() } 
+            (map
+                { $_ => Test::Run::Obj::IntOrUnknown->create_unknown() }
                 qw(max failed)
             ),
             canon => "??",
 {
     my $self = shift;
     my $error = shift;
-    
-    return 
+
+    return
         ($self->_is_error_object($error)
             ? $error->stringify()
             : $error
         _time_single_test
         _calc_test_struct
         _process_test_file_results
-        _recheck_dir_files    
+        _recheck_dir_files
     )];
 }
 
 {
     my $self = shift;
 
-    return 
+    return
         $self->last_test_obj->list_tests_as_failures(
             $self->last_test_results->details()
         );
 {
     my ($self) = @_;
 
-    if ($self->_is_test_passing()) 
+    if ($self->_is_test_passing())
     {
         $self->_handle_passing_test();
     }
 {
     my ($self) = @_;
 
-    return 
+    return
         {
             @{$self->_get_common_FWRS_params()},
             @{$self->_get_FWRS_tests_existence_params()},
 {
     my $self = shift;
 
-    $self->failed_tests()->{$self->_get_last_test_filename()} = 
+    $self->failed_tests()->{$self->_get_last_test_filename()} =
         $self->_get_failed_struct();
 
     return;
 {
     my ($self, $field) = @_;
 
-    return $self->format_columns() 
+    return $self->format_columns()
          - $self->_get_fmt_mid_str_len()
          - $self->$field()
          ;
 
     if ($self->list_len() < $self->_get_fmt_list_str_len()) {
         $self->_calc_updated_lens();
-        if ($self->max_namelen() < $self->_get_format_failed_str_len()) 
+        if ($self->max_namelen() < $self->_get_format_failed_str_len())
         {
             $self->_calc_more_updated_lens();
         }
     my $self = shift;
 
     $self->_calc_initial_max_namelen();
-    
+
     $self->_calc_fmt_list_len();
 
     return;
 
 [This is a method that needs to be over-rided.]
 
-Reports the C<$event_handle> event to channel C<$channel>. This should be 
-overrided by derived classes to do alternate functionality besides calling 
+Reports the C<$event_handle> event to channel C<$channel>. This should be
+overrided by derived classes to do alternate functionality besides calling
 output()->print_message(), also different based on the channel.
 
 Currently available channels are:
 
 =back
 
-An event is a hash ref that should contain a 'type' property. Currently 
+An event is a hash ref that should contain a 'type' property. Currently
 supported types are:
 
 =over 4
 
 Shlomi Fish C<< <shlomif@iglu.org.il> >>
 
-Note: this file is a rewrite of the original Test::Run code in order to 
+Note: this file is a rewrite of the original Test::Run code in order to
 change to a more liberal license.
 
 =head1 BUGS

modules/Test-Run/lib/Test/Run/Core_GplArt.pm

 in TAP format.
 
 L<Test::Run::Obj> is an applicative derived class of Test::Run::Core
-that provides a programmer API for running and analyzing the output of TAP 
+that provides a programmer API for running and analyzing the output of TAP
 files. For calling from the command line, look at
 L<Test::Run::CmdLine>.
 
 directory.
 
 Please use the CPAN bug ticketing system at L<http://rt.cpan.org/>.
-You can also mail bugs, fixes and enhancements to 
+You can also mail bugs, fixes and enhancements to
 C<< <bug-test-harness >> at C<< rt.cpan.org> >>.
 
 
 by Michael G Schwern C<< <schwern at pobox.com> >>,
 Andy Lester C<< <andy at petdance.com> >>.
 
-This program is free software; you can redistribute it and/or 
+This program is free software; you can redistribute it and/or
 modify it under the same terms as Perl itself.
 
 See L<http://www.perl.com/perl/misc/Artistic.html>.

modules/Test-Run/lib/Test/Run/Iface.pm

 
 =head1 NAME
 
-Test::Run::Iface  
+Test::Run::Iface
 
 =head1 LICENSE
 

modules/Test-Run/lib/Test/Run/Obj/CanonFailedObj.pm

 use vars qw(@fields);
 
 has 'failed' => (is => "rw", isa => "ArrayRef");
-has '_more_results' => (is => "rw", isa => "ArrayRef", 
+has '_more_results' => (is => "rw", isa => "ArrayRef",
     lazy => 1, default => sub { [] },
 );
 
     my ($self, $test) = @_;
 
     return
-        $test->max() 
+        $test->max()
             ? sprintf("%.2f%% okay", 100*(1-$self->failed_num()/$test->max()))
             : "?% okay"
         ;
     my $failed_num = $self->failed_num();
 
     $self->_add_Failed_summary($test);
-    $self->_add_Failed_percent_okay($test);   
+    $self->_add_Failed_percent_okay($test);
 }
 
 =head2 $self->add_skipped($test)
 {
     my ($self, $test) = @_;
 
-    return 
+    return
         $test->max()
             ? sprintf("%.2f", 100*($self->good($test)/$test->max()))
             : "?"
 {
     my $self = shift;
 
-    return (@{$self->failed()} == 1) 
+    return (@{$self->failed()} == 1)
         ? [ @{$self->failed()} ]
         : $self->_get_canon_ranges()
        ;
 
     my $canon = $self->canon_list;
 
-    return 
+    return
         sprintf("FAILED %s %s",
             $self->_list_pluralize("test", $canon),
             join(", ", @$canon)

modules/Test-Run/lib/Test/Run/Obj/Error.pm

 This module provides an error class hieararchy for Test::Run. This is used
 for throwing exceptions that should be handled programatically.
 
-=head1 METHODS 
+=head1 METHODS
 =cut
 
 
     return $self->stringify(@_);
 }
 
-use overload 
+use overload
     '""' => \&_polymorphic_stringify,
     'fallback' => 1
     ;
 {
     my $self = shift;
     return "FAILED--Further testing stopped" .
-        ($self->bailout_reason() ? 
+        ($self->bailout_reason() ?
             (": " . $self->bailout_reason() . "\n") :
             ".\n"
         );

modules/Test-Run/lib/Test/Run/Obj/FailedObj.pm

 
 =head2 $self->_defined_percent()
 
-Returns a defined percentage. It returns the percentage or 0 if it is 
+Returns a defined percentage. It returns the percentage or 0 if it is
 undefined.
 
 =cut

modules/Test-Run/lib/Test/Run/Obj/IntOrUnknown.pm

 sub get_string_val
 {
     my $self = shift;
-    
+
     return ($self->_is_unknown() ? "??" : $self->_val());
 }
 

modules/Test-Run/lib/Test/Run/Obj/TestObj.pm

 {
     my $self = shift;
 
-    return 
+    return
         $self->max()
             ? ($self->all_succesful()
                 ? "_get_dubious_summary_all_subtests_successful"
 
     return
         [
-            max => ($self->max() 
+            max => ($self->max()
                 ? Test::Run::Obj::IntOrUnknown->create_int($self->max())
                 : Test::Run::Obj::IntOrUnknown->create_unknown()
             ),

modules/Test-Run/lib/Test/Run/Obj/TotObj.pm

 sub _good_percent
 {
     my $self = shift;
-    
+
     return $self->_percent("good", "tests");
 }
 
     my $self = shift;
 
     return $self->_normalize_cond(
-           ($self->bad() == 0) 
+           ($self->bad() == 0)
         && ($self->max() || $self->skipped())
     );
 }

modules/Test-Run/lib/Test/Run/Output.pm

 
 Generates the 't/foo........' leader for the given C<$test_file> as well
 as a similar version which will overwrite the current line (by use of
-\r and such).  C<$ml> may be empty if Test::Run doesn't think 
+\r and such).  C<$ml> may be empty if Test::Run doesn't think
 you're on TTY.
 
 The C<$width> is the width of the "yada/blah.." string.

modules/Test-Run/lib/Test/Run/Plugin/CmdLine/Output.pm

 
 =head1 MOTIVATION
 
-This class has gradually re-implemented all of the 
-L<Test::Run::Plugin::CmdLine::Output::GplArt> functionality to 
-avoid license complications. 
+This class has gradually re-implemented all of the
+L<Test::Run::Plugin::CmdLine::Output::GplArt> functionality to
+avoid license complications.
 
 =head1 METHODS
 
 sub _report_leaked_files
 {
     my ($self, $args) = @_;
-    
+
     $self->_print("LEAKED FILES: " . $self->_get_leaked_files_string($args));
 }
 
     my ($self) = @_;
     return
     [
-        @{$self->_get_skipped_msgs()}, 
+        @{$self->_get_skipped_msgs()},
         @{$self->_get_bonus_msgs()}
     ];
 }
 sub _output_print_leader
 {
     my ($self, $args) = @_;
-    
+
     $self->output()->print_leader(
         {
             filename => $self->_output__get_display_filename_param($args),
         test => $test,
         script => $script,
     };
-    
+
     $self->_fail_other_report_tests_print_summary($args_to_pass);
 
     $self->_fail_other_report_test_print_rest_of_canons($args_to_pass);
 
     my $message = $self->_bonusmsg() || "";
     $message =~ s{\A,\s*}{};
-    
+
     return $message ? "$message." : "";
 }
 
 
     $self->_named_printf(
         \("%(failed)-" . $self->max_namelen() . "s%(middle)s%(list)s") ,
-        { 
+        {
             failed => $self->_get_format_failed_str(),
             middle => $self->_get_format_middle_str(),
             list =>   $self->_get_format_list_str(),
         }
     );
-    
+
     $self->_print("-" x $self->format_columns());
 }
 

modules/Test-Run/lib/Test/Run/Sprintf/Named/FromAccessors.pm

     my $person2 = Person->new(name => "Rachel", age => 30);
 
     my $msg2 = $formatter->format({args => { obj => $person2 }});
-    
+
 =head1 DESCRIPTION
 
 This module is a sub-class of L<Text::Sprintf::Named> where the variables
 
 http://www.opensource.org/licenses/mit-license.php
 
-=head1 SEE ALSO 
+=head1 SEE ALSO
 
 L<Text::Sprintf::Named> , L<Test::Run>
 

modules/Test-Run/lib/Test/Run/Straps.pm

 has 'file' => (is => "rw", isa => "Str");
 has '_file_totals' =>
     (is => "rw", isa => "Test::Run::Straps::StrapsTotalsObj");
-has '_is_macos' => (is => "rw", isa => "Bool", 
+has '_is_macos' => (is => "rw", isa => "Bool",
     default => sub { return ($^O eq "MacOS"); },
 );
 has '_is_win32' => (is => "rw", isa => "Bool",
     default => sub { return ($^O =~ m{\A(?:MS)?Win32\z}); },
 );
-has '_is_vms' => (is => "rw", isa => "Bool", 
+has '_is_vms' => (is => "rw", isa => "Bool",
     default => sub { return ($^O eq "VMS"); },
 );
 has 'last_test_print' => (is => "rw", isa => "Bool");
 
     if (defined($event))
     {
-        return 
+        return
             Test::Run::Straps::EventWrapper->new(
                 {
                     event => $event,
     my $self = shift;
 
     warn "Enormous test number seen [test ", $self->_event->number(), "]\n";
-    warn "Can't detailize, too big.\n"; 
+    warn "Can't detailize, too big.\n";
 
     return;
 }
 =head2 $self->_handle_event()
 
 Handles the current event according to the list of types in the cascade. It
-checks each type and if matches calls the appropriate 
+checks each type and if matches calls the appropriate
 C<_handle_${type}_event> callback. Returns the type of the event that matched.
 
 =cut
     my $self = shift;
     my $switches = shift;
 
-    return 
-    [ 
+    return
+    [
         map
-        { my $s = $_; $s =~ s{\A"(.*)"\z}{$1}; $s } 
+        { my $s = $_; $s =~ s{\A"(.*)"\z}{$1}; $s }
         map
         { split(/\s+/, $_) }
         grep
 
 =head2 $strap->_restore_PERL5LIB()
 
-Restores the old value of PERL5LIB. This is necessary on VMS. Does not 
+Restores the old value of PERL5LIB. This is necessary on VMS. Does not
 do anything on other platforms.
 
 =cut
 {
     my $self = shift;
 
-    return $self->_clean_switches( 
+    return $self->_clean_switches(
         $self->_split_switches(
-            [$self->Switches(), $self->Switches_Env()] 
+            [$self->Switches(), $self->Switches_Env()]
         )
     );
 }

modules/Test-Run/lib/Test/Run/Straps/EventWrapper.pm

 
 extends('Test::Run::Base');
 
-has '_tp_result' => 
+has '_tp_result' =>
 (
     is => "rw",
     isa => "Maybe[TAP::Parser::Result]",
 
 =head1 DESCRIPTION
 
-L<TAP::Parser>'s C<next()> method returns a sub-class of 
+L<TAP::Parser>'s C<next()> method returns a sub-class of
 L<TAP::Parser::Result>. However, we need to define our own methods
 on such objects. Since we cannot inherit from all the sub-classes, we
 have created this class which holds an instance of the actual events,

modules/Test-Run/lib/Test/Run/Straps/StrapsTotalsObj.pm

 sub _is_skip_all
 {
     my $self = shift;
-    
+
     return (($self->max() == 0) && defined($self->skip_all()));
 }
 
 
     return
     {
-        map 
+        map
         { $_ => _def_or_blank($hash->{$_}) }
         keys(%$hash)
     };
 
     my $event = $self->_event;
 
-    return 
+    return
     {
         actual_ok => scalar($event->is_ok()),
         name => $event->description,

modules/Test-Run/lib/Test/Run/Straps_GplArt.pm

 
 =head1 WARNING
 
-This module contains nothing but old (and possibly out of date) documentation. 
-All the code-wise functionality was moved to the MIT X11-licensed 
+This module contains nothing but old (and possibly out of date) documentation.
+All the code-wise functionality was moved to the MIT X11-licensed
 L<Test::Run::Straps> and other modules.
 
 Don't use this module, but you may wish to consult its documentation for
 The C<%results> returned from C<analyze()> contain the following
 information:
 
-  passing           true if the whole test is considered a pass 
+  passing           true if the whole test is considered a pass
                     (or skipped), false if its a failure
 
   exit              the exit code of the test run, if from a file
 
   max               total tests which should have been run
   seen              total tests actually seen
-  skip_all          if the whole test was skipped, this will 
+  skip_all          if the whole test was skipped, this will
                       contain the reason.
 
-  ok                number of tests which passed 
+  ok                number of tests which passed
                       (including todo and skips)
 
   todo              number of todo tests seen
-  bonus             number of todo tests which 
+  bonus             number of todo tests which
                       unexpectedly passed
 
   skip              number of tests skipped
 
 There is one final item, the details.
 
-  details           an array ref reporting the result of 
+  details           an array ref reporting the result of
                     each test looks like this:
 
-    $results{details}[$test_num - 1] = 
+    $results{details}[$test_num - 1] =
             { ok          => is the test considered ok?
               actual_ok   => did it literally say 'ok'?
               name        => name of the test (if any)
 Michael G Schwern C<< <schwern@pobox.com> >>, later maintained by
 Andy Lester C<< <andy@petdance.com> >>.
 
-Converted to Test::Run::Straps by Shlomi Fish 
+Converted to Test::Run::Straps by Shlomi Fish
 C<< <shlomif@iglu.org.il> >>.
 
 =head1 LICENSE

modules/Test-Run/lib/Test/Run/Trap/Obj.pm

     $got->field_like("stdout", qr/All tests successful/,
         "Everything is OK."
     );
-    
+
 =head1 DESCRIPTION
 
 This class implements a wrapper around L<Test::Trap>. When an
 use Data::Dumper ();
 
 use Text::Sprintf::Named;
-    
+
 use Test::Trap qw( trap $trap :flow:stderr(systemsafe):stdout(systemsafe):warn );
 
 use Test::Run::Obj;
             map { "$_ ===\n{{{{{{\n%($_)s\n}}}}}}\n\n" }
             (@fields))
             }
-        )->format({args => { map { my $name = $_; 
+        )->format({args => { map { my $name = $_;
                         ($name => $self->_stringify_value($name)) }
                     @fields
                 }})
 
     trap { $tester->$run_func(); };
 
-    return $class->new({ 
-        ( map { $_ => $trap->$_() } 
+    return $class->new({
+        ( map { $_ => $trap->$_() }
         (qw(stdout stderr die leaveby exit return warn wantarray)))
     });
 }

modules/Test-Run/mytest.pl

 
 use Test::Run::Obj;
 
-my $tester = 
+my $tester =
     Test::Run::Obj->new(
         {
             'test_files' => ["t/sample-tests/head_fail"],

modules/Test-Run/t/01unit-event-wrapper.t

 
 {
     my $parser = TAP::Parser->new({source => $simple_file});
-    
+
     my $event = Test::Run::Straps::EventWrapper->new({event => $parser->next()});
-    
+
     # TEST
-    ok (scalar($event->is_pass()), 
+    ok (scalar($event->is_pass()),
         "is_pass returns true in scalar context for a plan event"
     );
 
     my @list = $event->is_pass();
 
     # TEST
-    is_deeply(\@list, [1], 
+    is_deeply(\@list, [1],
         "is_pass returns a list containing true in list context"
     );
 
     $event = Test::Run::Straps::EventWrapper->new({event => $parser->next()});
 
     # TEST
-    ok (scalar($event->is_pass()), 
+    ok (scalar($event->is_pass()),
         "is_pass returns true in scalar context for an ok event"
     );
 
     @list = $event->is_pass();
 
     # TEST
-    is_deeply(\@list, [1], 
+    is_deeply(\@list, [1],
         "is_pass returns a list containing true in list context"
     );
 }
 
 {
     my $parser = TAP::Parser->new({source => $simple_fail_file});
-    
+
     # Skip to the third event - the "not ok".
     $parser->next();
     $parser->next();
 
     my $event = Test::Run::Straps::EventWrapper->new({event => $parser->next()});
-    
+
     # TEST
-    ok (! scalar($event->is_pass()), 
+    ok (! scalar($event->is_pass()),
         "is_pass returns true in scalar context for an ok event"
     );
 
     my @list = $event->is_pass();
 
     # TEST
-    is_deeply(\@list, [0], 
+    is_deeply(\@list, [0],
         "is_pass returns a list containing 0 in list context"
     );
 }

modules/Test-Run/t/data/interpreters/wrong-mini-ok.pl

-#!/usr/bin/perl 
+#!/usr/bin/perl
 
 use strict;
 use warnings;
         if ($1+$2 == $3)
         {
             print "ok $num\n";
-            
         }
         else
         {

modules/Test-Run/t/hierarchy.t

 
 our @ISA = (qw(B));
 
-package D; 
+package D;
 
 our @ISA = (qw(B));
 

modules/Test-Run/t/leaked-dir.t

 
     my $got = Test::Run::Trap::Obj->trap_run({
             class => "MyTestRun::LeakedCheck",
-            args => 
+            args =>
             [
-                test_files => [$leak_test_file], 
+                test_files => [$leak_test_file],
                 Leaked_Dir => $leaked_files_dir,
             ]
         });

modules/Test-Run/t/lib/Test/Builder.pm

     }
 
     $Curr_Test++;
-    
+
     $self->diag(<<ERR) if defined $name and $name =~ /^[\d\s]+$/;
     You named your test '$name'.  You shouldn't use numbers for your test names.
     Very confusing.
     unless( $test ) {
         my $msg = $todo ? "Failed (TODO)" : "Failed";
         $self->diag("    $msg test ($file at line $line)\n");
-    } 
+    }
 
     return $test ? 1 : 0;
 }
     expected: %s
 DIAGNOSTIC
 
-}    
+}
 
 =item B<isnt_eq>
 
 
 sub _cmp_diag {
     my($self, $got, $type, $expect) = @_;
-    
+
     $got    = defined $got    ? "'$got'"    : 'undef';
     $expect = defined $expect ? "'$expect'" : 'undef';
     $self->diag(sprintf <<DIAGNOSTIC, $got, $type, $expect);
     my $fh;
     unless( UNIVERSAL::isa($file_or_fh, 'GLOB') ) {
         $fh = do { local *FH };
-        open $fh, ">$file_or_fh" or 
+        open $fh, ">$file_or_fh" or
             die "Can't open test output log $file_or_fh: $!";
     }
     else {
 
 Like summary(), but with a lot more detail.
 
-    $tests[$test_num - 1] = 
+    $tests[$test_num - 1] =
             { ok         => is the test considered ok?
               actual_ok  => did it literally say 'ok'?
               name       => name of the test (if any)
 sub caller {
     my($self, $height) = @_;
     $height ||= 0;
-    
+
     my @caller = CORE::caller($self->level + $height + 1);
     return wantarray ? @caller : $caller[0];
 }
 #'#
 sub _sanity_check {
     _whoa($Curr_Test < 0,  'Says here you ran a negative number of tests!');
-    _whoa(!$Have_Plan and $Curr_Test, 
+    _whoa(!$Have_Plan and $Curr_Test,
           'Somehow your tests ran without a plan!');
     _whoa($Curr_Test != @Test_Results,
           'Somehow you got a different number of results than tests ran!');
 Copyright 2001 by chromatic E<lt>chromatic@wgz.orgE<gt>,
                   Michael G Schwern E<lt>schwern@pobox.comE<gt>.
 
-This program is free software; you can redistribute it and/or 
+This program is free software; you can redistribute it and/or
 modify it under the same terms as Perl itself.
 
 See F<http://www.perl.com/perl/misc/Artistic.html>

modules/Test-Run/t/lib/Test/More.pm

 
 is almost exactly like saying:
 
-    ok( Foo->can('this') && 
-        Foo->can('that') && 
-        Foo->can('whatever') 
+    ok( Foo->can('this') &&
+        Foo->can('that') &&
+        Foo->can('whatever')
       );
 
 only without all the typing and with a better interface.  Handy for
     }
 
     my $name;
-    $name = @methods == 1 ? "$class->can('$methods[0]')" 
+    $name = @methods == 1 ? "$class->can('$methods[0]')"
                           : "$class->can(...)";
-    
+
     my $ok = $Test->ok( !@nok, $name );
 
     $Test->diag(map "    $class->can('$_') failed\n", @nok);
             $diag = "$obj_name isn't a '$class' it's a '$ref'";
         }
     }
-            
-      
+
+
 
     my $ok;
     if( $diag ) {
 
 Sometimes running a test under certain conditions will cause the
 test script to die.  A certain function or method isn't implemented
-(such as fork() on MacOS), some resource isn't available (like a 
+(such as fork() on MacOS), some resource isn't available (like a
 net connection) or a module isn't available.  In these cases it's
 necessary to skip tests, or declare that they are supposed to fail
 but will work in the future (a todo test).
     my $out = "Structures begin differing at:\n";
     foreach my $idx (0..$#vals) {
         my $val = $vals[$idx];
-        $vals[$idx] = !defined $val ? 'undef' : 
+        $vals[$idx] = !defined $val ? 'undef' :
                       $val eq $DNE  ? "Does not exist"
                                     : "'$val'";
     }
     my $eq;
     {
         # Quiet uninitialized value warnings when comparing undefs.
-        local $^W = 0; 
+        local $^W = 0;
 
         if( $e1 eq $e2 ) {
             $ok = 1;
 
 Copyright 2001 by Michael G Schwern E<lt>schwern@pobox.comE<gt>.
 
-This program is free software; you can redistribute it and/or 
+This program is free software; you can redistribute it and/or
 modify it under the same terms as Perl itself.
 
 See F<http://www.perl.com/perl/misc/Artistic.html>

modules/Test-Run/t/lib/Test/Simple.pm

 
 Copyright 2001 by Michael G Schwern E<lt>schwern@pobox.comE<gt>.
 
-This program is free software; you can redistribute it and/or 
+This program is free software; you can redistribute it and/or
 modify it under the same terms as Perl itself.
 
 See F<http://www.perl.com/perl/misc/Artistic.html>

modules/Test-Run/t/output.t

         });
 
     # TEST
-    $got->field_like("stdout", qr/All tests successful\./, 
+    $got->field_like("stdout", qr/All tests successful\./,
         "simple - 'All tests successful.' string as is"
     );
 
     # TEST
-    $got->field_like("stdout", 
+    $got->field_like("stdout",
         qr/^Files=\d+, Tests=\d+,  [^\n]*wallclock secs/m,
         "simple - Final Stats line matches format."
     );
     my $got = Test::Run::Trap::Obj->trap_run({
         args =>
         [
-            test_files =>         
+            test_files =>
             [
-                "t/sample-tests/simple", 
+                "t/sample-tests/simple",
                 "t/sample-tests/head_end",
                 "t/sample-tests/todo",
             ],
     });
 
     # TEST
-    $got->field_like("stdout", qr/All tests successful/, 
+    $got->field_like("stdout", qr/All tests successful/,
         "simple+head_end+todo - 'All tests successful' (without the period) string as is"
     );
 }
 {
     my $got = Test::Run::Trap::Obj->trap_run({args =>
         [
-            test_files => 
+            test_files =>
             [
-                "t/sample-tests/simple", 
+                "t/sample-tests/simple",
                 "t/sample-tests/skip",
             ],
         ]
 {
     my $got = Test::Run::Trap::Obj->trap_run({args =>
         [
-            test_files => 
+            test_files =>
             [
-                "t/sample-tests/simple", 
+                "t/sample-tests/simple",
                 "t/sample-tests/head_end",
                 "t/sample-tests/todo",
             ],
             Debug => 1,
         ]
     });
-    
+
     # TEST
-    $got->field_like("stdout", qr/All tests successful/, 
+    $got->field_like("stdout", qr/All tests successful/,
         "In debug - 'All tests successful' (without the period) string as is");
     # TEST
-    $got->field_like("stdout", qr/^# PERL5LIB=/m, 
+    $got->field_like("stdout", qr/^# PERL5LIB=/m,
         "In debug - Matched a Debug diagnostics");
 }
 
 {
     my $got = Test::Run::Trap::Obj->trap_run({args =>
         [
-            test_files => 
+            test_files =>
             [
-                "t/sample-tests/bailout", 
+                "t/sample-tests/bailout",
             ],
         ]
     });
-    
+
     my $match = 'FAILED--Further testing stopped: GERONIMMMOOOOOO!!!';
     # TEST
-    $got->field_like("die", ('/' . quotemeta($match) . '/'), 
+    $got->field_like("die", ('/' . quotemeta($match) . '/'),
         "Bailout - Matched the bailout error."
     );
 }
 {
     my $got = Test::Run::Trap::Obj->trap_run({args =>
         [
-            test_files => 
+            test_files =>
             [
-                "t/sample-tests/skip", 
+                "t/sample-tests/skip",
             ],
         ]
     });
-    
+
     # TEST
-    $got->field_like("stdout", 
+    $got->field_like("stdout",
         qr{t/sample-tests/skip \.+ ok\n {8}1/5 skipped: rain delay\n},
         "skip - Matching the skipped line."
     );
 {
     my $got = Test::Run::Trap::Obj->trap_run({args =>
         [
-            test_files => 
+            test_files =>
             [
-                "t/sample-tests/todo", 
+                "t/sample-tests/todo",
             ],
         ]
     });
-    
+
     # TEST
     $got->field_like("stdout",
         qr{t/sample-tests/todo \.+ ok\n {8}1/5 unexpectedly succeeded\n},
 {
     my $got = Test::Run::Trap::Obj->trap_run({args =>
         [
-            test_files => 
+            test_files =>
             [
-                "t/sample-tests/skip_and_todo", 
+                "t/sample-tests/skip_and_todo",
             ],
         ]
     });
-    
+
     # TEST
-    $got->field_like("stdout", 
+    $got->field_like("stdout",
         qr{t/sample-tests/skip_and_todo \.+ ok\n {8}1/6 skipped: rain delay, 1/6 unexpectedly succeeded\n},
         "skip_and_todo - Matching the bonus+skip line."
     );
 
     # TEST
-    $got->field_like("stdout", 
+    $got->field_like("stdout",
         qr{^\QAll tests successful (1 subtest UNEXPECTEDLY SUCCEEDED), 1 subtest skipped.\E\n}m,
         "skip_and_todo - Testing for a good summary line"
     );
 {
     my $got = Test::Run::Trap::Obj->trap_run({args =>
         [
-            test_files => 
+            test_files =>
             [
-                "t/sample-tests/skipall", 
+                "t/sample-tests/skipall",
             ],
         ]
     });
-    
+
     # TEST
     $got->field_like(
         "stdout",
 {
     my $got = Test::Run::Trap::Obj->trap_run({args =>
         [
-            test_files => 
+            test_files =>
             [
-                "t/sample-tests/simple_fail", 
+                "t/sample-tests/simple_fail",
             ],
         ]
     });
-    
+
     # TEST
     $got->field_like("stdout",
         qr{t/sample-tests/simple_fail \.+ FAILED tests 2, 5\n\tFailed 2/5 tests, 60.00% okay},
         "simple_fail - Matching the FAILED test report"
         );
     # TEST
-    $got->field_like("die", 
+    $got->field_like("die",
         qr{^Failed 1/1 test scripts, 0.00% okay\. 2/5 subtests failed, 60\.00% okay\.$}m,
         "simple_fail - Matching the Failed summary line."
     );
 {
     my $got = Test::Run::Trap::Obj->trap_run({args =>
         [
-            test_files => 
+            test_files =>
             [
-                "t/sample-tests/invalid-perl", 
+                "t/sample-tests/invalid-perl",
             ],
         ]
     });
-    
+
     # TEST
     $got->field_like("die",
         qr{FAILED--1 test script could be run, alas--no output ever seen},
 {
     my $got = Test::Run::Trap::Obj->trap_run({args =>
         [
-            test_files => 
+            test_files =>
             [
-                "t/sample-tests/head_fail", 
+                "t/sample-tests/head_fail",
             ],
         ]
     });
-    
+
     # TEST
     $got->field_is_deeply("warn", [],
         "Checking for no warnings on failure"
     my $path_lengthening_magic = "../t/";
     my $path_prefix = "t/";
     my $path = "";
-    
+
     # Construct the path itself.
     {
         $path .= $path_prefix;
-    
+
         $path .= $path_lengthening_magic x
-            (($max_path - length($test_file_path) - length($path_prefix)) 
-                / 
+            (($max_path - length($test_file_path) - length($path_prefix))
+                /
              length($path_lengthening_magic)
             );
 
         $path .= $test_file_path;
     }