test::eol(3) [centos man page]

Test::EOL(3)						User Contributed Perl Documentation					      Test::EOL(3)

NAME

       Test::EOL - Check the correct line endings in your project

SYNOPSIS

       "Test::EOL" lets you check for the presence of trailing whitespace and/or windows line endings in your perl code. It reports its results in
       standard "Test::Simple" fashion:

	 use Test::EOL tests => 1;
	 eol_unix_ok( 'lib/Module.pm', 'Module is ^M free');

       and to add checks for trailing whitespace:

	 use Test::EOL tests => 1;
	 eol_unix_ok( 'lib/Module.pm', 'Module is ^M and trailing whitespace free', { trailing_whitespace => 1 });

       Module authors can include the following in a t/eol.t and have "Test::EOL" automatically find and check all perl files in a module
       distribution:

	 use Test::EOL;
	 all_perl_files_ok();

       or

	 use Test::EOL;
	 all_perl_files_ok( @mydirs );

       and if authors would like to check for trailing whitespace:

	 use Test::EOL;
	 all_perl_files_ok({ trailing_whitespace => 1 });

       or

	 use Test::EOL;
	 all_perl_files_ok({ trailing_whitespace => 1 }, @mydirs );

DESCRIPTION

       This module scans your project/distribution for any perl files (scripts, modules, etc) for the presence of windows line endings.

FUNCTIONS

   all_perl_files_ok
	 all_perl_files_ok( [ \%options ], [ @directories ] )

       Applies "eol_unix_ok()" to all perl files found in @directories (and sub directories). If no <@directories> is given, the starting point is
       one level above the current running script, that should cover all the files of a typical CPAN distribution. A perl file is *.pl or *.pm or
       *.t or a file starting with "#!...perl"

       Valid "\%options" currently are:

       o   trailing_whitespace

	   By default Test::EOL only looks for Windows (CR/LF) line-endings. Set this to true to raise errors if any kind of trailing whitespace
	   is present in the file.

       o   all_reasons

	   Normally Test::EOL reports only the first error in every file (given that a text file originated on Windows will fail every single
	   line). Set this a true value to register a test failure for every line with an error.

       If the test plan is defined:

	 use Test::EOL tests => 3;
	 all_perl_files_ok();

       the total number of files tested must be specified.

   eol_unix_ok
	 eol_unix_ok ( $file [, $text] [, \%options ] )

       Run a unix EOL check on $file. For a module, the path (lib/My/Module.pm) or the name (My::Module) can be both used. $text is the diagnostic
       label emited after the "ok"/"not ok" TAP output. "\%options" takes the same values as described in "all_perl_files_ok".

EXPORT

       A list of functions that can be exported.  You can delete this section if you don't export anything, such as for a purely object-oriented
       module.

ACKNOWLEDGEMENTS

       Shamelessly ripped off from Test::NoTabs.

SEE ALSO

       Test::More, Test::Pod. Test::Distribution, <Test:NoWarnings>, Test::NoTabs, Module::Install::AuthorTests.

AUTHORS

       o   Arthur Axel 'fREW' Schmidt <frioux@gmail.com>

       o   Florian Ragwitz <rafl@debian.org>

       o   Kent Fredric <kentfredric@gmail.com>

       o   Peter Rabbitson <ribasushi@cpan.org>

       o   Tomas Doran <bobtfish@bobtfish.net>

COPYRIGHT AND LICENSE

       This software is copyright (c) 2012 by Tomas Doran.

       This is free software; you can redistribute it and/or modify it under the same terms as the Perl 5 programming language system itself.

perl v5.16.3							    2012-06-15							      Test::EOL(3)

Check Out this Related Man Page

Test::Builder::Module(3)				User Contributed Perl Documentation				  Test::Builder::Module(3)

NAME

       Test::Builder::Module - Base class for test modules

SYNOPSIS

	 # Emulates Test::Simple
	 package Your::Module;

	 my $CLASS = __PACKAGE__;

	 use base 'Test::Builder::Module';
	 @EXPORT = qw(ok);

	 sub ok ($;$) {
	     my $tb = $CLASS->builder;
	     return $tb->ok(@_);
	 }

	 1;

DESCRIPTION

       This is a superclass for Test::Builder-based modules.  It provides a handful of common functionality and a method of getting at the
       underlying Test::Builder object.

   Importing
       Test::Builder::Module is a subclass of Exporter which means your module is also a subclass of Exporter.	@EXPORT, @EXPORT_OK, etc...  all
       act normally.

       A few methods are provided to do the "use Your::Module tests =" 23> part for you.

       import

       Test::Builder::Module provides an import() method which acts in the same basic way as Test::More's, setting the plan and controlling
       exporting of functions and variables.  This allows your module to set the plan independent of Test::More.

       All arguments passed to import() are passed onto "Your::Module->builder->plan()" with the exception of "import =>[qw(things to import)]".

	   use Your::Module import => [qw(this that)], tests => 23;

       says to import the functions this() and that() as well as set the plan to be 23 tests.

       import() also sets the exported_to() attribute of your builder to be the caller of the import() function.

       Additional behaviors can be added to your import() method by overriding import_extra().

       import_extra

	   Your::Module->import_extra(@import_args);

       import_extra() is called by import().  It provides an opportunity for you to add behaviors to your module based on its import list.

       Any extra arguments which shouldn't be passed on to plan() should be stripped off by this method.

       See Test::More for an example of its use.

       NOTE This mechanism is VERY ALPHA AND LIKELY TO CHANGE as it feels like a bit of an ugly hack in its current form.

   Builder
       Test::Builder::Module provides some methods of getting at the underlying Test::Builder object.

       builder

	 my $builder = Your::Class->builder;

       This method returns the Test::Builder object associated with Your::Class.  It is not a constructor so you can call it as often as you like.

       This is the preferred way to get the Test::Builder object.  You should not get it via "Test::Builder->new" as was previously recommended.

       The object returned by builder() may change at runtime so you should call builder() inside each function rather than store it in a global.

	 sub ok {
	     my $builder = Your::Class->builder;

	     return $builder->ok(@_);
	 }

perl v5.16.3							    2011-02-23						  Test::Builder::Module(3)

Linux and UNIX Man Pages

test::eol(3) [centos man page]

Check Out this Related Man Page