Commits

Shlomi Fish  committed 58b7bab

Remove trailing whitespace in Test-Run-CmdLine.

  • Participants
  • Parent commits 5298f5a

Comments (0)

Files changed (25)

File modules/Test-Run-CmdLine/Build.PL

     build_requires =>
     {
         "Test::Trap" => 0,
-        'Test::More' => 0,        
+        'Test::More' => 0,
     },
-    requires => 
+    requires =>
     {
         'Moose' => 0,
         'MooseX::Getopt' => 0.26,

File modules/Test-Run-CmdLine/Changes

 Revision history for Test-Run-CmdLine
 
+    - Get rid of trailing space with a test - t/style-trailing-space.t .
+
 0.0125     Wed  5 Sep 20:12:26 IDT 2012
     - Moved away tag-release.pl under scripts to it won't be installed
     by default.
     build-systems under examples/.
 
 0.0106      Sat Jun 23 13:22:16 IDT 2007
-    * Placed the runprove trapping functionality in 
+    * Placed the runprove trapping functionality in
     lib/Test/Run/CmdLine/Trap/Prove.pm for easy re-use by the
     plugins.
     * Added lib/Test/Run/CmdLine/Prove/App.pm as a standalone -M command
-    line module implementing the "runprove" functionality. 
+    line module implementing the "runprove" functionality.
         - Also useful for testing - see below.
         - converted runprove to use it.
     * Added lib/Test/Run/CmdLine/Trap/ProveApp.pm for testing
     * Converted t/04-t-r-cl-iface.t to Test::Trap.
     * Refactored the get_backend_env_args() method of Test::Run::CmdLine.
     * Extracted a method.
-    * Extended the environment variables handling in 
-    Test::Run::CmdLine with types. 
-    * Replaced "back_end" with "backend" in an identifier for better 
-    consistency. 
-    * Added the yamldata backend environment variable type, and 
-    converted the "alternate interpreters" plugin to use it. 
+    * Extended the environment variables handling in
+    Test::Run::CmdLine with types.
+    * Replaced "back_end" with "backend" in an identifier for better
+    consistency.
+    * Added the yamldata backend environment variable type, and
+    converted the "alternate interpreters" plugin to use it.
     * Added the "varmap" type to Test::Run::CmdLine.
-    * Converted to use Build.PL and Test::Run::Builder. 
-    * Refactored the tests of t/03-prove.t into Test::Run::Trap::Obj. 
-    * Converted the Test::Run::CmdLine get_backend_env_args to 
+    * Converted to use Build.PL and Test::Run::Builder.
+    * Refactored the tests of t/03-prove.t into Test::Run::Trap::Obj.
+    * Converted the Test::Run::CmdLine get_backend_env_args to
     private_backend_args (using accum_array) instead of NEXT::.
-    * Converted the indirect_env_mapping routines to using 
-    accum_array instead of NEXT::. 
+    * Converted the indirect_env_mapping routines to using
+    accum_array instead of NEXT::.
 
 0.0104      Mon Mar 19 15:40:20 IST 2007
     * Fixed running runprove with no arguments.
     * Added UNIVERSAL::require to the pre-requisites.
 
 0.0001_03   Thu Oct  5 13:52:55 IST 2006
-    * Fixed the tests in Test-Run-CmdLine so they'll pass even if plugins 
+    * Fixed the tests in Test-Run-CmdLine so they'll pass even if plugins
     are specified by deafult (or any other $ENV{HARNESS_.*}) shenanigan.
     * Adapted to the new ($self, $args) instead of ($self, %args) interface
     of Test::Run.
       itself and adapted it for runprove.
     * Added pod to Test::Run::CmdLine.
     * Added many tests.
-    
+
 0.0001_01   Tue Nov 29 22:57:02 IST 2005
     * Initial CPAN.pm version. Works sort of and has a functional "runprove"
     utility.

File modules/Test-Run-CmdLine/MANIFEST

 t/sample-tests/with-lib/t/mytest.t
 t/sample-tests/with-myhello
 t/sample-tests/with-myhello-and-myfoo
+t/style-trailing-space.t
 t/test-libs/lib1/MyHello.pm
 t/test-libs/lib2/MyFoo.pm
 META.json

File modules/Test-Run-CmdLine/Old/refactor1.pl

-#!/usr/bin/perl 
+#!/usr/bin/perl
 
 use strict;
 use warnings;
         {
             my ($ws, $cl) = ($1, $2);
             my $tab = " " x 4;
-            print "${ws}my \$got = TestRunCmdLineTrapper->new(\n" 
+            print "${ws}my \$got = TestRunCmdLineTrapper->new(\n"
                 . "${ws}${tab}\{\n"
                 . "${ws}${tab}${tab}runprove => \$runprove,\n"
                 . "${ws}${tab}${tab}cmdline => qq{${cl}},\n"

File modules/Test-Run-CmdLine/README

 Test-Run-CmdLine
 
-This module allows one to run TAP tests and analyze them from the command 
+This module allows one to run TAP tests and analyze them from the command
 line using the Test::Run module.
 
-It provides runprove, as well as other command line facilities similar to 
+It provides runprove, as well as other command line facilities similar to
 Test::Harness' default behaviour only using its Test::Run spin-off.
 
 INSTALLATION

File modules/Test-Run-CmdLine/bin/runprove

 of C<Test::Run>.  With no arguments, it will run all tests in the
 current directory.
 
-Shell metacharacters may be used with command lines options and will be exanded 
+Shell metacharacters may be used with command lines options and will be exanded
 via C<glob>.
 
 =head1 RUNPROVE VS. "MAKE TEST"
 C<make test>.  That's fine for module distributions, but it's
 suboptimal for a test/code/debug development cycle.
 
-=item * F<runprove> is granular 
+=item * F<runprove> is granular
 
 F<runprove> let your run only the files you want to check.
 Running C<runprove t/live/ t/master.t> checks every F<*.t> in F<t/live>,
 
 Copyright 2005 by Andy Lester C<< <andy@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>.

File modules/Test-Run-CmdLine/docs/Namespace-Planning.txt

 
 1. A Test::Run::CmdLine front-end initialises a Test::Run::Obj back-end.
 
-2. A command-line interface class instantiates a 
+2. A command-line interface class instantiates a
 Test::Run::CmdLine derivative plus Plugins class and in turn lets it run.
 
 3. This front-end class instantiates a back-end class possibly adding plug-ins
 
 The Test::Run::CmdLine interface will be called Test::Run::CmdLine::Iface.
 
-T::R::CL::I will initialise $ENV{'HARNESS_DRIVER'} (or $args{'driver_class'}), 
-and load it with the extra plugins $ENV{'HARNESS_PLUGINS'} 
-(or $args{'driver_plugins'}). Then it will push Test::Run::CmdLine to the end 
+T::R::CL::I will initialise $ENV{'HARNESS_DRIVER'} (or $args{'driver_class'}),
+and load it with the extra plugins $ENV{'HARNESS_PLUGINS'}
+(or $args{'driver_plugins'}). Then it will push Test::Run::CmdLine to the end
 of its @ISA.
 
 Test::Run::CmdLine will initialise the class that the plug-ins tell it to
-(or to Test::Run::Iface by default), load it with all the extra plug-ins, and 
+(or to Test::Run::Iface by default), load it with all the extra plug-ins, and
 finally push Test::Run::Obj to its @ISA. Then it will let it run.
 
-A plugin always resides under Test::Run::Plugin::. 
+A plugin always resides under Test::Run::Plugin::.
 

File modules/Test-Run-CmdLine/examples/Module-Build/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

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

 
     sub 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|;

File modules/Test-Run-CmdLine/examples/eumm-and-test-manifest/MyModule/testlib/Test/Run/CmdLine/WithTestManifest.pm

 {
     my ($test_verbose, $inst_lib, $inst_archlib, $test_level) = @_;
     local @INC = @INC;
-    unshift @INC, map { File::Spec->rel2abs($_) } ($inst_lib, $inst_archlib); 
-    
+    unshift @INC, map { File::Spec->rel2abs($_) } ($inst_lib, $inst_archlib);
+
     my $test_iface = Test::Run::CmdLine::Iface->new({
             test_files => [Test::Manifest::get_t_files()]
         }
     );
-    
+
     return $test_iface->run();
 }
 

File modules/Test-Run-CmdLine/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/**

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

     default => "Test::Run::Iface"
 );
 has 'backend_params' => (is => "rw", isa => "HashRef");
-has 'backend_plugins' => (is => "rw", isa => "ArrayRef", 
+has 'backend_plugins' => (is => "rw", isa => "ArrayRef",
     default => sub { [] },
 );
 has 'backend_env_args' => (is => "rw", isa => "ArrayRef",
 sub BUILD
 {
     my $self = shift;
-    
+
     $self->_collect_backend_plugins();
- 
+
     return;
 }
 
 This is the backend class that will be instantiated and used to perform
 the processing. Defaults to L<Test::Run::Obj>.
 
-=back 
+=back
 
 =head2 $tester->run()
 
 
 =head1 Environment Variables
 
-The following environment variables (C<%ENV>) affect the behaviour of 
+The following environment variables (C<%ENV>) affect the behaviour of
 Test::Run::CmdLine:
 
 =over 4
 =item HARNESS_COLUMNS
 
 This determines the width of the terminal (sets C<'Columns'>) in
-L<Test::Run::Obj>). If not specified, it will be determined according 
+L<Test::Run::Obj>). If not specified, it will be determined according
 to the C<COLUMNS> environment variable, that is normally specified by
 the terminal.
 
 
 This variable points to a directory that will be monitored. After each
 test file, the module will check if new files appeared in the direcotry
-and report them. 
-    
+and report them.
+
 It is advisable to give an absolute path here. If it is relative, it would
 be relative to the current working directory when C<$tester-E<gt>run()> was
 called.
 
 =item HARNESS_NOTTY
 
-Triggers the C<'NoTty'> option in Test::Run::Obj. Meaning, it causes 
+Triggers the C<'NoTty'> option in Test::Run::Obj. Meaning, it causes
 Test::Run::CmdLine not to treat STDOUT as if it were a console. In this
-case, it will not emit more frequent progress reports using carriage 
+case, it will not emit more frequent progress reports using carriage
 returns (C<"\r">s).
 
 =item HARNESS_PERL
 =item HARNESS_PERL_SWITCHES
 
 Specifies the C<'Switches'> variable of L<Test::Run::Obj>. This allows
-specifying more switches to the Perl interpreter. 
+specifying more switches to the Perl interpreter.
 
 =item HARNESS_TIMER
 
 
 =item HARNESS_VERBOSE
 
-Triggers the C<'Verbose'> option in Test::Run::Obj. Meaning, it emits 
+Triggers the C<'Verbose'> option in Test::Run::Obj. Meaning, it emits
 the standard output of the test files while they are processed.
 
 =back
     my $self = shift;
 
     $self->get_backend_env_args();
-   
+
     my $init_args = $self->get_backend_init_args();
 
     return [@{$self->backend_env_args()}, @$init_args];
 {
     my $self = shift;
 
-    return 
+    return
     [
         (map { +{ type => "direct", %$_ } } @{$self->_get_direct_backend_env_mapping()}),
         @{$self->_get_non_direct_backend_env_mapping()},
     my ($self, $mapping_string) = @_;
 
     my @assignments = split(/\s*;\s*/, $mapping_string);
-    return 
+    return
     +{
-        map { /\A([^=]*)=(.*)\z/ms ? ($1 => $2) : () } 
+        map { /\A([^=]*)=(.*)\z/ms ? ($1 => $2) : () }
             @assignments
     };
 }
 sub _calc_plugins_for_ISA
 {
     my $self = shift;
-    return 
-        [ 
-            map { $self->_calc_single_plugin_for_ISA($_) } 
-            @{$self->backend_plugins()} 
+    return
+        [
+            map { $self->_calc_single_plugin_for_ISA($_) }
+            @{$self->backend_plugins()}
         ];
 }
 

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

 =cut
 
 has 'driver_class' => (is => "rw", isa => "Str", init_arg => undef,);
-has 'driver_plugins' => (is => "rw", isa => "ArrayRef", 
+has 'driver_plugins' => (is => "rw", isa => "ArrayRef",
     default => sub { [] }, init_arg => undef,);
 has '_driver_class_arg' => (is => "ro", isa => "Str", init_arg => "driver_class");
 has '_driver_plugins_arg' => (is => "ro", isa => "Maybe[ArrayRef]", init_arg => "driver_plugins");
             }
         );
     }
-    
+
     return;
 }
 
 =item driver_plugins
 
 This is a list of plugin classes to be used by the driver class. Each plugin
-is a module and a corresponding class, that is prefixed by 
+is a module and a corresponding class, that is prefixed by
 C<Test::Run::CmdLine::Plugin::> - a prefix which should not be included in
 them.
 
 For Moose.
 
 TODO : Write more.
- 
+
 =cut
 
 sub _real_prepare_driver_class
 sub _calc_plugins_for_ISA
 {
     my $self = shift;
-    return 
-        [ 
-            map { $self->_calc_single_plugin_for_ISA($_) } 
-            @{$self->driver_plugins()} 
+    return
+        [
+            map { $self->_calc_single_plugin_for_ISA($_) }
+            @{$self->driver_plugins()}
         ];
 }
 

File modules/Test-Run-CmdLine/lib/Test/Run/CmdLine/Prove.pm

 with 'MooseX::Getopt::Basic';
 
 has 'dry' => (
-    traits => ['Getopt'], is => "rw", 
+    traits => ['Getopt'], is => "rw",
     isa => "Bool", cmd_aliases => [qw(D)],
 );
 
 has '_ext_regex' => (accessor => "ext_regex", is => "rw", isa => "RegexpRef");
-has '_ext_regex_string' => 
+has '_ext_regex_string' =>
     (accessor => "ext_regex_string", is => "rw", isa => "Str")
     ;
-has 'recurse' => (traits => ['Getopt'], is => "rw", 
+has 'recurse' => (traits => ['Getopt'], is => "rw",
     isa => "Bool", cmd_aliases => [qw(r)],
 );
 has 'shuffle' => (
-    traits => ['Getopt'], is => "rw", 
+    traits => ['Getopt'], is => "rw",
     isa => "Bool", cmd_aliases => [qw(s)],
 );
 has 'Verbose' => (
         # Temporary workaround for MooseX::Getopt;
         local @ARGV = @argv;
         $self = $class->new_with_options(
-            argv => \@argv, 
+            argv => \@argv,
             "no_ignore_case" => 1,
             "bundling" => 1,
         );
     $self->Switches(\@switches);
 
     $self->_set_ext([ @{$self->ext()} ]);
-    
+
     return 0;
 }
 
     my $self = shift;
     my $arg = shift;
     my $ret = "-I$arg";
-    if (($arg =~ /\s/) && 
-        (! (($arg =~ /^"/) && ($arg =~ /"$/)) ) 
+    if (($arg =~ /\s/) &&
+        (! (($arg =~ /^"/) && ($arg =~ /"$/)) )
        )
     {
         return "\"$ret\"";
 =head2 $prove = Test::Run::CmdLine::Prove->create({'args' => [@ARGV], 'env_switches' => $env_switches});
 
 Initializes a new object. C<'args'> is a keyed parameter that gives the
-command line for the prove utility (as an array ref of strings). 
+command line for the prove utility (as an array ref of strings).
 
-C<'env_switches'> is a keyed parameter that gives a string containing more 
+C<'env_switches'> is a keyed parameter that gives a string containing more
 arguments, or undef if not wanted.
 
 =head2 $prove->run()
 
     Pod::Usage::pod2usage(
         {
-            '-verbose' => $verbosity, 
+            '-verbose' => $verbosity,
             '-exitval' => 0,
         }
     );
     my $self = shift;
     my $ext = $self->_default_ext(shift);
 
-    $self->ext_regex_string('\.(?:' . 
-        join("|", map { quotemeta($_) } 
+    $self->ext_regex_string('\.(?:' .
+        join("|", map { quotemeta($_) }
             @{$self->_normalize_extensions($ext)}
-        ) 
+        )
         . ')$'
     );
     $self->_set_ext_re();
 sub _get_test_files
 {
     my $self = shift;
-    return 
+    return
         $self->_post_process_test_files_list(
-            [ 
-                map 
-                { $self->_get_test_files_from_arg($_) } 
-                @{$self->_get_arguments()} 
+            [
+                map
+                { $self->_get_test_files_from_arg($_) }
+                @{$self->_get_arguments()}
             ]
         );
 }
     {
         my @files = sort readdir($dir);
         closedir($dir);
-        return 
+        return
             (map { $self->_get_test_files_from_dir_entry($path, $_) } @files);
     }
     else
     {
         warn "$path: $!\n";
         return ();
-    }    
+    }
 }
 
 sub _should_ignore_dir_entry
     my ($self, $dir, $file) = @_;
     return
         (
-            ($file eq File::Spec->updir()) || 
+            ($file eq File::Spec->updir()) ||
             ($file eq File::Spec->curdir()) ||
             ($file eq ".svn") ||
             ($file eq "CVS")

File modules/Test-Run-CmdLine/lib/Test/Run/CmdLine/Trap/Prove.pm

 
     trap { $system_ret = system("$runprove $cmdline"); };
 
-    return $class->new({ 
-        ( map { $_ => $trap->$_() } 
+    return $class->new({
+        ( map { $_ => $trap->$_() }
         (qw(stdout stderr die leaveby exit return warn wantarray))),
         system_ret => $system_ret,
     });

File modules/Test-Run-CmdLine/lib/Test/Run/CmdLine/Trap/ProveApp.pm

 
     my $cmdline = $args->{cmdline};
 
-    trap { 
+    trap {
         system(
-            $^X, "-MTest::Run::CmdLine::Prove::App", "-e", "run()", "--", 
+            $^X, "-MTest::Run::CmdLine::Prove::App", "-e", "run()", "--",
             @$cmdline,
         );
     };
 
-    return $class->new({ 
-        ( map { $_ => $trap->$_() } 
+    return $class->new({
+        ( map { $_ => $trap->$_() }
         (qw(stdout stderr die leaveby exit return warn wantarray)))
     });
 }
 
 =head1 DESCRIPTION
 
-Testing class to trap the output of a 
+Testing class to trap the output of a
 C<perl -MTest::Run::CmdLine::Prove::App ...> run.
 
 =head1 METHODS
 
 =head2 Test::Run::CmdLine::Trap::Prove->trap_run({cmdline => [@ARGS]})
 
-Traps the output of the application with the command line args of C<@ARGS>. 
+Traps the output of the application with the command line args of C<@ARGS>.
 Returns the object. To be used as a constructor.
 
 =head1 AUTHORS

File modules/Test-Run-CmdLine/t/01-class-name.t

     # TEST
     ok($obj->_is_class_name("hello::world"), "Class name ok");
     # TEST
-    ok((! $obj->_is_class_name(qq(Test::Run::Hello"; print "Hello\n";))), 
+    ok((! $obj->_is_class_name(qq(Test::Run::Hello"; print "Hello\n";))),
         "Prevent injected code");
     # TEST
-    ok($obj->_is_class_name("_Hello_Test_::Run_tests"), 
+    ok($obj->_is_class_name("_Hello_Test_::Run_tests"),
         "Underscores");
 }
 1;

File modules/Test-Run-CmdLine/t/02-run.t

         my $iface = Test::Run::CmdLine::Iface->new();
 
         # TEST
-        is ($iface->driver_class(), "Test::Run::CmdLine::Drivers::Default", 
+        is ($iface->driver_class(), "Test::Run::CmdLine::Drivers::Default",
             "Right default driver_class");
-            
+
     }
- 
+
     {
         local $ENV{HARNESS_DRIVER} = "Foo::Bar";
         my $iface = Test::Run::CmdLine::Iface->new();
 
         # TEST
-        is ($iface->driver_class(), "Foo::Bar", 
+        is ($iface->driver_class(), "Foo::Bar",
             "Right driver_class set from ENV");
     }
-    
+
     {
         local @Test::Run::CmdLine::Drivers::CmdLineTest::ISA;
         local @Test::Run::Drivers::CmdLineTest::ISA;
             }
         );
         # TEST
-        is ($iface->driver_class(), "Test::Run::CmdLine::Drivers::CmdLineTest", 
+        is ($iface->driver_class(), "Test::Run::CmdLine::Drivers::CmdLineTest",
             "Right driver_class set from ENV");
 
         my $got = $iface->run();
 
         my $got = $iface->run();
         # TEST
-        is_deeply($got, 
-            +{'tested' => [qw(one.t TWO tHREE)], 
+        is_deeply($got,
+            +{'tested' => [qw(one.t TWO tHREE)],
               'foo' => "myfoo",
               'bar' => "habar sheli",
             },

File modules/Test-Run-CmdLine/t/03-prove.t

 
 {
     local %ENV = %ENV;
-    
+
     local $ENV{'PERL5LIB'} = $abs_lib.$Config{'path_sep'}.$ENV{'PERL5LIB'};
     delete($ENV{'HARNESS_FILELEAK_IN_DIR'});
     delete($ENV{'HARNESS_VERBOSE'});
                 cmdline => qq{$test_file},
             }
         );
-        
+
         # TEST
-        $got->field_like("stdout", qr/All tests successful\./, 
+        $got->field_like("stdout", qr/All tests successful\./,
             "Good results from runprove");
 
         # TEST
-        $got->field_is("system_ret", 0, 
+        $got->field_is("system_ret", 0,
             "runprove returns a zero exit code upon success."
         );
     }
                 cmdline => qq{--help},
             }
         );
-        
+
         # TEST
-        $got->field_like("stdout", qr/\Qrunprove [options]\E/, 
+        $got->field_like("stdout", qr/\Qrunprove [options]\E/,
             "Good results from runprove --help ");
 
         # TEST
-        $got->field_is("system_ret", 0, 
+        $got->field_is("system_ret", 0,
             "runprove --help returns a zero exit code upon success."
         );
     }
                 cmdline => $test_file,
             }
         );
-        
+
         # TEST
         $got->field_like ("stdout" , qr/^ok 1/m,
             "Testing is 'Verbose' if HARNESS_VERBOSE is 1.");
                 cmdline => qq{-v $test_file},
             }
         );
-        
+
         # TEST
         $got->field_like("stdout", qr/^ok 1/m,
             "Testing is 'Verbose' with the '-v' flag."
                 cmdline => $test_file,
             }
         );
-        
+
         # TEST
         $got->field_like ("stdout" , qr/# Running:/,
             "Testing is 'Debug' if HARNESS_DEBUG is 1.");
                 cmdline => qq{-d $test_file},
             }
         );
-        
+
         # TEST
         $got->field_like("stdout", qr/# Running:/,
             "Testing is 'Debug' is the '-d' flag was specified."
                 cmdline => "$test_file $several_oks_file",
             }
         );
-        
+
         # TEST
         $got->field_like ("stdout" , qr/ok\s+\d+(?:\.\d+)?s\n?$/m,
             "Displays the time if HARNESS_TIMER is 1.");
                 cmdline => "--timer $test_file $several_oks_file",
             }
         );
-        
+
         # TEST
         $got->field_like ("stdout" , qr/ok\s+\d+(?:\.\d+)?s\n?$/m,
             "Displays the time if --timer was set.");
                 cmdline => "$test_file $several_oks_file",
             }
         );
-        
+
         # TEST
         $got->field_like ("stdout" , qr/ok\n?$/m,
             "Timer control experiment");
                 cmdline => "$test_file $several_oks_file",
             }
         );
-        
+
         # TEST
-        $got->field_like ("stdout" , qr/All tests successful\./, 
+        $got->field_like ("stdout" , qr/All tests successful\./,
             "Good results from HARNESS_NOTTY");
     }
     {
                 cmdline => "$no_t_flags_file",
             }
         );
-        
+
         # TEST
-        $got->field_like ("stdout", qr/All tests successful\./, 
+        $got->field_like ("stdout", qr/All tests successful\./,
             "Good results for the absence of the -t flag");
     }
     {
                 cmdline => "-t $lowercase_t_flag_file",
             }
         );
-        
+
         # TEST
-        $got->field_like ("stdout", qr/All tests successful\./, 
+        $got->field_like ("stdout", qr/All tests successful\./,
             "Good results for the presence of the -t flag");
     }
     {
                 cmdline => "-T $uppercase_t_flag_file",
             }
         );
-        
+
         # TEST
-        $got->field_like ("stdout", qr/All tests successful\./, 
+        $got->field_like ("stdout", qr/All tests successful\./,
             "Good results for the presence of the -T flag");
     }
     {
                 cmdline => "-T $no_t_flags_file",
             }
         );
-        
+
         # TEST
-        $got->field_like ("stdout", qr/FAILED test/, 
+        $got->field_like ("stdout", qr/FAILED test/,
             "Test that requires no taint fails if -T is specified");
     }
     {
                 cmdline => "$uppercase_t_flag_file",
             }
         );
-        
+
         # TEST
         $got->field_like ("stdout", qr/FAILED test/,
             "Good results for the presence of the -T flag");
                 cmdline => "--blib " . File::Spec->catfile(File::Spec->curdir(), "t", "mytest.t"),
             }
         );
-        
+
         # TEST
         $got->field_like ("stdout", qr/All tests successful\./,
             "Good results for the presence of the --blib flag");
                 cmdline => "" . File::Spec->catfile(File::Spec->curdir(), "t", "mytest.t"),
             }
         );
-        
+
         # TEST
         $got->field_like ("stdout", qr/DIED. FAILED test 1/,
             "File fails if it doesn't have --blib where there is a required module");
                 cmdline => "--lib " . File::Spec->catfile(File::Spec->curdir(), "t", "mytest.t"),
             }
         );
-        
+
         # TEST
         $got->field_like ("stdout", qr/All tests successful\./,
             "Good results for the presence of the --lib flag");
                 cmdline => "" . File::Spec->catfile(File::Spec->curdir(), "t", "mytest.t"),
             }
         );
-        
+
         # TEST
         $got->field_like ("stdout", qr/DIED. FAILED test 1/,
             "File fails if it doesn't have --lib where there is a required module");
                 cmdline => qq{--dry $test_file $with_myhello_file},
             }
         );
-        
+
         # TEST
         $got->field_is("stdout", "$test_file\n$with_myhello_file\n",
             "Testing dry run"
                 cmdline => "" . File::Spec->catfile(File::Spec->curdir(), "t", "mytest.t"),
             }
         );
-        
+
         # TEST
         $got->field_like ("stdout", qr/All tests successful\./,
             "Good results for the presence of the --lib flag in ENV{PROVE_SWITCHES}");
                 cmdline => "",
             }
         );
-        
+
         # TEST
         $got->field_is("stdout", "",
             "Empty file list does not croak with weird errors (STDOUT)"

File modules/Test-Run-CmdLine/t/04-t-r-cl-iface.t

 # Default behaviour
 {
     local %ENV = %ENV;
-    
+
     delete($ENV{'HARNESS_FILELEAK_IN_DIR'});
     delete($ENV{'HARNESS_VERBOSE'});
     delete($ENV{'HARNESS_DEBUG'});
     delete($ENV{'HARNESS_DRIVER'});
     delete($ENV{'HARNESS_PLUGINS'});
     delete($ENV{'PROVE_SWITCHES'});
-    
+
     my $got = Test::Run::Trap::Obj->trap_run(
         {
             class => "Test::Run::CmdLine::Iface",

File modules/Test-Run-CmdLine/t/05-prove-cl-process.t

 # TEST
 is (mytest ([qw{--ext=cgi t}]), '\.(?:cgi)$', "Testing for single extension");
 # TEST
-is (mytest (['--ext=cgi,pl', 't']), '\.(?:cgi|pl)$', 
+is (mytest (['--ext=cgi,pl', 't']), '\.(?:cgi|pl)$',
     "Testing for extensions separated with commas");
 # TEST
-is (mytest (['--ext=cgi,.pl', '--ext=.hello,perl', 't']), 
+is (mytest (['--ext=cgi,.pl', '--ext=.hello,perl', 't']),
     '\.(?:cgi|pl|hello|perl)$',
     "Testing for several extension args along with periods"
 );
 
 # TEST
 is_deeply (
-    get_test_files ([$test_file]), 
+    get_test_files ([$test_file]),
     [$test_file],
     "Testing one file"
 );
 
 # TEST
 is_deeply (
-    get_test_files ([$test_file, $with_myhello_file]), 
+    get_test_files ([$test_file, $with_myhello_file]),
     [$test_file, $with_myhello_file],
     "Testing two files (one without a proper extension)"
 );

File modules/Test-Run-CmdLine/t/06-prove-cl-shuffle.t

 
 @rand_values = (
     # (1,2,3,4,5)
-    3, 
+    3,
     # (1,2,3,5|4)
     0,
     # (5,2,3|1,4)
 
 @rand_values = (
     # (1,2,3,4,5)
-    3, 
+    3,
     # (1,2,3,5|4)
     0,
     # (5,2,3|1,4)

File modules/Test-Run-CmdLine/t/07-trap-prove-app.t

 
 {
     local %ENV = %ENV;
-    
+
     local $ENV{'PERL5LIB'} = $abs_lib.$Config{'path_sep'}.$ENV{'PERL5LIB'};
     delete($ENV{'HARNESS_FILELEAK_IN_DIR'});
     delete($ENV{'HARNESS_VERBOSE'});
                 cmdline => [$test_file, $several_oks_file],
             }
         );
-        
+
         # TEST
-        $got->field_like("stdout", qr/All tests successful\./, 
+        $got->field_like("stdout", qr/All tests successful\./,
             "Good results from runprove");
     }
 }

File modules/Test-Run-CmdLine/t/sample-tests/no-t-flags.t

 
 use Test::More tests => 1;
 
-sub is_tainted 
+sub is_tainted
 {
     return ! eval { eval("#" . substr(join("", @_), 0, 0)); 1 };
 }

File modules/Test-Run-CmdLine/t/style-trailing-space.t

+#!/usr/bin/perl
+
+use strict;
+use warnings;
+
+use Test::More;
+
+eval "use Test::TrailingSpace";
+if ($@)
+{
+    plan skip_all => "Test::TrailingSpace required for trailing space test.";
+}
+else
+{
+    plan tests => 1;
+}
+
+my $finder = Test::TrailingSpace->new(
+    {
+        root => '.',
+        filename_regex => qr/(?:(?:\.(?:t|pm|pl|PL|yml|json|arc|vim|c|xs))|README|Changes|LICENSE)\z/,
+    },
+);
+
+# TEST
+$finder->no_trailing_space(
+    "No trailing space was found."
+);
+