view release on metacpan or search on metacpan
t/03-dazzname.t view on Meta::CPAN
like( $result->stdout, qr{dazzname}, 'descriptions' );
$result = test_app( 'App::Dazz' => [qw(dazzname)] );
like( $result->error, qr{need .+input file}, 'need infile' );
$result = test_app( 'App::Dazz' => [qw(dazzname t/not_exists)] );
like( $result->error, qr{doesn't exist}, 'infile not exists' );
$result = test_app( 'App::Dazz' => [qw(dazzname t/1_4.anchor.fasta --prefix B-A:D -o stdout)] );
like( $result->error, qr{Can't accept}, 'bad names' );
view release on metacpan or search on metacpan
lib/App/Dependencio.pm view on Meta::CPAN
use List::MoreUtils qw(uniq);
use Module::Extract::Use;
our $VERSION = '0.09';
my @mods_list = ();
my @mods_not_found = ();
sub opt_spec {
return (
[ "testdirs|t", "Exclude dir named t (tests)" ],
[ "verbose|v", "Verbose output"],
lib/App/Dependencio.pm view on Meta::CPAN
push (@dirs,$cwd);
print STDOUT colored ['bright_blue'], "Searching modules dependencies recursively from $cwd \n";
find(\&_openFiles, @dirs);
#p(@mods_not_found);
foreach my $mod_not_found (uniq(@mods_not_found)){
print STDOUT colored ['bright_red'], "module $mod_not_found not found\n";
system "cpanm $mod_not_found" if $opts->{cpanm};
}
exit -1 if @mods_not_found or print STDOUT colored ['bright_green'], "success! all dependencies met...\n";
}
sub _openFiles{
lib/App/Dependencio.pm view on Meta::CPAN
my $path = $module. ".pm";
$path =~ s{::}{/}g;
eval {require $path } or
do {
my $error = $@;
push( @mods_not_found, $module) unless grep{$_ eq $module} @mods_not_found;
}
}
}
}
view release on metacpan or search on metacpan
lib/App/Deps/Verify.pm view on Meta::CPAN
sub _find_exes
{
my ( $self, $args ) = @_;
my @not_found;
foreach my $line ( map { @$_ } @{ $args->{inputs} } )
{
my $cmd = $line->{exe};
if (
not(
lib/App/Deps/Verify.pm view on Meta::CPAN
? ( -e $cmd )
: ( defined( scalar( which($cmd) ) ) )
)
)
{
push @not_found, $line;
}
}
if (@not_found)
{
print "The following commands could not be found:\n\n";
foreach my $cmd ( sort { $a->{exe} cmp $b->{exe} } @not_found )
{
print "$cmd->{exe}\t$cmd->{url}\n";
}
exit(-1);
}
lib/App/Deps/Verify.pm view on Meta::CPAN
sub _find_perl5_modules
{
my ( $self, $args ) = @_;
my @not_found;
foreach my $required_modules ( @{ $args->{inputs} } )
{
foreach my $m ( sort { $a cmp $b } keys(%$required_modules) )
{
lib/App/Deps/Verify.pm view on Meta::CPAN
my $verdict = eval( "use $m " . ( $v || '' ) . ' ();' );
my $Err = $@;
if ($Err)
{
push @not_found, $m;
}
}
}
if (@not_found)
{
print "The following modules could not be found:\n\n";
foreach my $module (@not_found)
{
print "$module\n";
}
exit(-1);
}
lib/App/Deps/Verify.pm view on Meta::CPAN
}
sub list_missing_python3_modules
{
my ( $self, $args ) = @_;
my %not_found;
foreach my $mods ( @{ $args->{inputs} } )
{
use Data::Dumper;
# die Dumper($mods);
lib/App/Deps/Verify.pm view on Meta::CPAN
{
if ( $module !~ m#\A[a-zA-Z0-9_\.]+\z# )
{
die "invalid python3 module id - $module !";
}
if ( exists $not_found{$module} )
{
next REQUIRED;
}
if ( system( 'python3', '-c', "import $module" ) != 0 )
{
$not_found{$module} = 0;
}
}
}
return { missing_python3_modules =>
[ map { +{ module => $_, }, } sort keys(%not_found) ] };
}
sub _find_python3_modules
{
my ( $self, $args ) = @_;
my @not_found =
map { $_->{module} }
@{ $self->list_missing_python3_modules($args)->{missing_python3_modules}
};
if (@not_found)
{
print "The following python3 modules could not be found:\n\n";
foreach my $module (@not_found)
{
print "$module\n";
}
exit(-1);
}
lib/App/Deps/Verify.pm view on Meta::CPAN
sub _find_required_files
{
my ( $self, $args ) = @_;
my @not_found;
foreach my $required_files ( @{ $args->{inputs} } )
{
foreach my $path (@$required_files)
{
lib/App/Deps/Verify.pm view on Meta::CPAN
{
die "Invalid path $p!";
}
if ( !-e ( $p =~ s#\A~/#$ENV{HOME}/#r ) )
{
push @not_found, $path;
}
}
}
if (@not_found)
{
print "The following required files could not be found.\n";
print "Please set them up:\n";
print "\n";
foreach my $path (@not_found)
{
print "$path->{path}\n$path->{desc}\n";
}
exit(-1);
}
view release on metacpan or search on metacpan
stdout_is( sub { App::Dest->watches }, '', 'watches (no results)' );
ok( lives { App::Dest->add('actions') }, 'add actions' ) or note $@;
stderr_is( sub {
try {
App::Dest->add('not_exists');
}
catch ($e) {
warn $e;
}
}, "Directory specified does not exist\n", 'no add not exists' );
view release on metacpan or search on metacpan
t/boilerplate.t view on Meta::CPAN
use strict;
use warnings;
use Test::More;
use Test::Warnings;
sub not_in_file_ok {
my ($filename, %regex) = @_;
open( my $fh, '<', $filename )
or die "couldn't open $filename for reading: $!";
my %violated;
t/boilerplate.t view on Meta::CPAN
}
sub module_boilerplate_ok {
my ($module) = @_;
subtest $module => sub {
not_in_file_ok($module =>
'the great new $MODULENAME' => qr/ - The great new /,
'boilerplate description' => qr/Quick summary of what the module/,
'stub function definition' => qr/function[12]/,
'module description' => qr/One-line description of module/,
'description' => qr/A full description of the module/,
t/boilerplate.t view on Meta::CPAN
);
};
}
subtest 'README' => sub {
not_in_file_ok((-f 'README' ? 'README' : 'README.pod') =>
"The README is used..." => qr/The README is used/,
"'version information here'" => qr/to provide version information/,
);
};
subtest 'Changes' => sub {
not_in_file_ok(Changes =>
"placeholder date/time" => qr(Date/time)
);
};
module_boilerplate_ok('bin/devmode2');
view release on metacpan or search on metacpan
lib/App/DocKnot/Spin/Pointer.pm view on Meta::CPAN
}
if ($data_ref->{style}) {
$style = $self->{style_url} . $data_ref->{style} . '.css';
}
my %vars = (
docknot_url => $URL,
html => decode('utf-8', $html),
links => $links,
modified => strftime('%Y-%m-%d', gmtime($source->stat()->[9])),
navbar => $navbar,
now => strftime('%Y-%m-%d', gmtime()),
view release on metacpan or search on metacpan
lib/App/Dochazka/CLI/Commands/Employee.pm view on Meta::CPAN
return undef unless ref( $emp ) eq 'App::Dochazka::REST::Model::Employee';
return undef unless $emp->eid and $emp->nick;
# GET priv/eid/:eid
my $status = send_req( 'GET', 'priv/eid/' . $emp->eid );
if ( $status->not_ok ) {
$log->error( "Could not determine priv level of employee -> " . $emp->nick .
"<- because: " . $status->text );
return undef;
}
return $status->payload->{'priv'};
view release on metacpan or search on metacpan
config/sql/dbinit_Config.pm view on Meta::CPAN
$$ LANGUAGE plpgsql/,
q/COMMENT ON FUNCTION overlaps(tstzrange, tstzrange) IS
'Tests two tstzranges whether they overlap'/,
q/CREATE OR REPLACE FUNCTION not_before_1892(timestamptz)
RETURNS TIMESTAMPTZ AS $IMM$
BEGIN
IF $1 < '1892-01-01'::timestamptz THEN
RAISE EXCEPTION 'No dates earlier than 1892-01-01 please';
END IF;
RETURN $1;
END;
$IMM$ LANGUAGE plpgsql/,
q/COMMENT ON FUNCTION not_before_1892(timestamptz) IS 'We enforce dates 1892-01-01 or later'/,
q#CREATE OR REPLACE FUNCTION valid_intvl() RETURNS trigger AS $$
BEGIN
IF ( NEW.intvl IS NULL ) OR
( isempty(NEW.intvl) ) OR
config/sql/dbinit_Config.pm view on Meta::CPAN
( upper_inc(NEW.intvl) ) OR
( lower_inf(NEW.intvl) ) OR
( upper_inf(NEW.intvl) ) THEN
RAISE EXCEPTION 'illegal attendance interval %s', NEW.intvl;
END IF;
PERFORM not_before_1892(upper(NEW.intvl));
PERFORM not_before_1892(lower(NEW.intvl));
IF ( upper(NEW.intvl) != round_time(upper(NEW.intvl)) ) OR
( lower(NEW.intvl) != round_time(lower(NEW.intvl)) ) THEN
RAISE EXCEPTION 'upper and lower bounds of interval must be evenly divisible by 5 minutes';
END IF;
RETURN NEW;
config/sql/dbinit_Config.pm view on Meta::CPAN
END;
$$ LANGUAGE plpgsql IMMUTABLE/,
q/CREATE OR REPLACE FUNCTION sane_timestamp() RETURNS trigger AS $$
BEGIN
PERFORM not_before_1892(NEW.effective);
RETURN NEW;
END;
$$ LANGUAGE plpgsql IMMUTABLE/,
q/CREATE TRIGGER round_effective BEFORE INSERT OR UPDATE ON schedhistory
config/sql/dbinit_Config.pm view on Meta::CPAN
END;
$$ LANGUAGE plpgsql IMMUTABLE/,
q/-- trigger function for use in sanity checks on attendance and lock intervals
-- vets an interval to ensure it does not extend too far into the future
CREATE OR REPLACE FUNCTION not_too_future() RETURNS trigger AS $$
DECLARE
limit_ts timestamptz;
BEGIN
--
-- does the interval extend too far into the future?
config/sql/dbinit_Config.pm view on Meta::CPAN
FOR EACH ROW EXECUTE PROCEDURE priv_policy()/,
q/CREATE TRIGGER a1_interval_valid_intvl BEFORE INSERT OR UPDATE ON intervals
FOR EACH ROW EXECUTE PROCEDURE valid_intvl()/,
q/CREATE TRIGGER a2_interval_not_too_future BEFORE INSERT OR UPDATE ON intervals
FOR EACH ROW EXECUTE PROCEDURE not_too_future()/,
q/CREATE TRIGGER a3_no_iid_update BEFORE UPDATE ON intervals
FOR EACH ROW EXECUTE PROCEDURE iid_immutable()/,
# the 'locks' table
config/sql/dbinit_Config.pm view on Meta::CPAN
$IMM$ LANGUAGE plpgsql/,
q/CREATE TRIGGER a1_lock_valid_intvl BEFORE INSERT OR UPDATE ON locks
FOR EACH ROW EXECUTE PROCEDURE valid_intvl()/,
q/CREATE TRIGGER a2_lock_not_too_future BEFORE INSERT OR UPDATE ON locks
FOR EACH ROW EXECUTE PROCEDURE not_too_future()/,
q/-- trigger the trigger
CREATE TRIGGER a3_no_lid_update BEFORE UPDATE ON locks
FOR EACH ROW EXECUTE PROCEDURE lid_immutable()/,
config/sql/dbinit_Config.pm view on Meta::CPAN
END IF;
END;
$IMM$ LANGUAGE plpgsql/,
q/CREATE TRIGGER intvl_not_locked BEFORE INSERT OR UPDATE OR DELETE ON intervals
FOR EACH ROW EXECUTE PROCEDURE no_lock_conflict()/,
# the 'tempintvls' table and associated plumbing
q/CREATE SEQUENCE temp_intvl_seq/,
config/sql/dbinit_Config.pm view on Meta::CPAN
int_id serial PRIMARY KEY,
tiid integer NOT NULL,
intvl tstzrange NOT NULL
)/,
q/CREATE TRIGGER a2_interval_not_too_future BEFORE INSERT OR UPDATE ON tempintvls
FOR EACH ROW EXECUTE PROCEDURE not_too_future()/,
# create 'root' and 'demo' employees
q/-- insert root employee into employees table and grant admin
-- privilege to the resulting EID
view release on metacpan or search on metacpan
lib/App/Docker/Client/Exception.pm view on Meta::CPAN
my $self = {@_};
bless $self, $class;
return $self;
}
=head2 is_not_fround
=cut
sub is_not_fround { $_[0]->{code} == 404 ? 1 : 0 }
=head2 is_confict
=cut
view release on metacpan or search on metacpan
bin/dual-lived view on Meta::CPAN
'CPAN::Distribution',
'CPAN::Distroprefs',
'CPAN::Distrostatus',
'CPAN::Exception::RecursiveDependency',
'CPAN::Exception::blocked_urllist',
'CPAN::Exception::yaml_not_installed',
'CPAN::FTP',
'CPAN::FTP::netrc',
'CPAN::FirstTime',
'CPAN::HandleConfig',
'CPAN::Index',
view release on metacpan or search on metacpan
t/template/templates.yml view on Meta::CPAN
input: share/text/README
output: t/out/share/text/<:$ia_id:>/docs/README
no_input:
label: File with non-existent input
input: share/text/does_not_exist.txt
output: t/out/share/text/<:$ia_id:>.txt
no_write_perm:
label: Output directory is not writeable
input: share/text/README
t/template/templates.yml view on Meta::CPAN
subdir_support_specified:
description: Template which will not work if IAs are created inside a subdirectory
required: [ pm ]
subdir_support: false
subdir_support_not_defined:
description: Template which will work if IAs are created inside a subdirectory
required: [ pm ]
...
view release on metacpan or search on metacpan
lib/App/ENumberUtils.pm view on Meta::CPAN
=item * B<description.min> => I<str>
Only return records where the 'description' field is greater than or equal to specified value.
=item * B<description.not_contains> => I<str>
Only return records where the 'description' field does not contain specified text.
=item * B<description.not_in> => I<array[str]>
Only return records where the 'description' field is not in the specified values.
=item * B<description.not_matches> => I<str>
Only return records where the 'description' field does not match specified regular expression.
=item * B<description.xmax> => I<str>
lib/App/ENumberUtils.pm view on Meta::CPAN
=item * B<range.min> => I<str>
Only return records where the 'range' field is greater than or equal to specified value.
=item * B<range.not_contains> => I<str>
Only return records where the 'range' field does not contain specified text.
=item * B<range.not_in> => I<array[str]>
Only return records where the 'range' field is not in the specified values.
=item * B<range.not_matches> => I<str>
Only return records where the 'range' field does not match specified regular expression.
=item * B<range.xmax> => I<str>
lib/App/ENumberUtils.pm view on Meta::CPAN
=item * B<subrange.min> => I<str>
Only return records where the 'subrange' field is greater than or equal to specified value.
=item * B<subrange.not_contains> => I<str>
Only return records where the 'subrange' field does not contain specified text.
=item * B<subrange.not_in> => I<array[str]>
Only return records where the 'subrange' field is not in the specified values.
=item * B<subrange.not_matches> => I<str>
Only return records where the 'subrange' field does not match specified regular expression.
=item * B<subrange.xmax> => I<str>
lib/App/ENumberUtils.pm view on Meta::CPAN
=item * B<code.min> => I<str>
Only return records where the 'code' field is greater than or equal to specified value.
=item * B<code.not_contains> => I<str>
Only return records where the 'code' field does not contain specified text.
=item * B<code.not_in> => I<array[str]>
Only return records where the 'code' field is not in the specified values.
=item * B<code.not_matches> => I<str>
Only return records where the 'code' field does not match specified regular expression.
=item * B<code.xmax> => I<str>
lib/App/ENumberUtils.pm view on Meta::CPAN
=item * B<color_index.min> => I<int>
Only return records where the 'color_index' field is greater than or equal to specified value.
=item * B<color_index.not_in> => I<array[int]>
Only return records where the 'color_index' field is not in the specified values.
=item * B<color_index.xmax> => I<int>
lib/App/ENumberUtils.pm view on Meta::CPAN
=item * B<colour.min> => I<str>
Only return records where the 'colour' field is greater than or equal to specified value.
=item * B<colour.not_contains> => I<str>
Only return records where the 'colour' field does not contain specified text.
=item * B<colour.not_in> => I<array[str]>
Only return records where the 'colour' field is not in the specified values.
=item * B<colour.not_matches> => I<str>
Only return records where the 'colour' field does not match specified regular expression.
=item * B<colour.xmax> => I<str>
lib/App/ENumberUtils.pm view on Meta::CPAN
=item * B<names.min> => I<str>
Only return records where the 'names' field is greater than or equal to specified value.
=item * B<names.not_contains> => I<str>
Only return records where the 'names' field does not contain specified text.
=item * B<names.not_in> => I<array[str]>
Only return records where the 'names' field is not in the specified values.
=item * B<names.not_matches> => I<str>
Only return records where the 'names' field does not match specified regular expression.
=item * B<names.xmax> => I<str>
lib/App/ENumberUtils.pm view on Meta::CPAN
=item * B<purpose.min> => I<str>
Only return records where the 'purpose' field is greater than or equal to specified value.
=item * B<purpose.not_contains> => I<str>
Only return records where the 'purpose' field does not contain specified text.
=item * B<purpose.not_in> => I<array[str]>
Only return records where the 'purpose' field is not in the specified values.
=item * B<purpose.not_matches> => I<str>
Only return records where the 'purpose' field does not match specified regular expression.
=item * B<purpose.xmax> => I<str>
lib/App/ENumberUtils.pm view on Meta::CPAN
=item * B<status.min> => I<str>
Only return records where the 'status' field is greater than or equal to specified value.
=item * B<status.not_contains> => I<str>
Only return records where the 'status' field does not contain specified text.
=item * B<status.not_in> => I<array[str]>
Only return records where the 'status' field is not in the specified values.
=item * B<status.not_matches> => I<str>
Only return records where the 'status' field does not match specified regular expression.
=item * B<status.xmax> => I<str>
view release on metacpan or search on metacpan
t/03-exactmatch.t view on Meta::CPAN
like( $result->stdout, qr{exactmatch}, 'descriptions' );
$result = test_app( 'App::Egaz' => [qw(exactmatch)] );
like( $result->error, qr{need .+input file}, 'need infile' );
$result = test_app( 'App::Egaz' => [qw(exactmatch t/not_exists t/not_exists)] );
like( $result->error, qr{doesn't exist}, 'infile not exists' );
$result = test_app( 'App::Egaz' => [qw(exactmatch t/not_exists t/pseudopig.fa)] );
like( $result->error, qr{doesn't exist}, 'infile not exists' );
SKIP: {
skip "mummer or sparsemem not installed", 3
unless IPC::Cmd::can_run('mummer')
view release on metacpan or search on metacpan
scripts/es-apply-settings.pl view on Meta::CPAN
#------------------------------------------------------------------------#
# Figure out the skipped aliases
my %SKIP = map { $_ => 1 } (
qw( .hold .do_not_erase ),
$opt{'skip-alias'} ? ( @{ $opt{'skip-alias'} } ) : (),
);
# Read JSON Settings
my $RawJSON = '';
scripts/es-apply-settings.pl view on Meta::CPAN
es-apply-settings.pl --older --days 30 --pattern logstash-*
=item B<skip-alias>
Protected aliases, which if present will cause the application of settings to
be skipped for a particular index. The aliases C<.hold> and C<.do_not_erase>
will always be skipped.
=item B<no-skip>
Apply settings to all matching indexes, regardless of the protected aliases.
view release on metacpan or search on metacpan
README.mkdn view on Meta::CPAN
Delete the cache entry for the given application. If `Site` is not
specified, the site is determined as specified in ["Site Specific
Contexts"](#site-specific-contexts).
It is currently _not_ possible to use this interface to
explicitly uncache multi-application environments if they have not
been given a unique cache id. It is possible using **App::Env**
objects.
The available options are:
README.mkdn view on Meta::CPAN
Clone an existing environment. The available options are `CacheID`,
`Cache`, `SysFatal` (see the documentation for the **import** function).
The cloned environment is by default not cached. If caching is
requested and a cache id is not provided, a unique id is created --
it will _not_ be the same as that of the original environment.
This generated cache id is not based on a signature of the
environment, so this environment will effectively not be automatically
reused when a similar environment is requested via the **new**
constructor (see ["Environment Caching"](#environment-caching)).
view release on metacpan or search on metacpan
t/02-exceptions.t view on Meta::CPAN
use Test::More tests => 3;
use Test::Fatal;
use App::Environ;
use App::Environ::Config;
t_module_class_not_specified();
t_event_name_not_specified();
t_config_not_initialized();
sub t_module_class_not_specified {
like(
exception {
App::Environ->register;
},
qr/Module class must be specified/,
t/02-exceptions.t view on Meta::CPAN
);
return;
}
sub t_event_name_not_specified {
like(
exception {
App::Environ->send_event;
},
qr/Event name must be specified/,
t/02-exceptions.t view on Meta::CPAN
return;
}
sub t_config_not_initialized {
like(
exception {
App::Environ::Config->instance;
},
qr/must be initialized first/,
view release on metacpan or search on metacpan
bin/station-mgr.pl view on Meta::CPAN
run_stop($loop);
} else {
# Set status
$self->{device_control}{$loop->{id}}{timestamp} = time;
$self->{status}{$loop->{id}}{running} = 0;
$self->{status}{$loop->{id}}{status} = "file_not_found";
$self->{status}{$loop->{id}}{state} = "hard";
$self->{status}{$loop->{id}}{name} = "standby loop";
post_config();
}
}
bin/station-mgr.pl view on Meta::CPAN
$self->{device_control}{$device->{id}}{runcount}++;
# Set device status
$self->{status}{$device->{id}}{type} = $device->{type};
$self->{status}{$device->{id}}{timestamp} = time;
$self->{status}{$device->{id}}{running} = 0;
$self->{status}{$device->{id}}{status} = "not_writeable";
$self->{status}{$device->{id}}{state} = "hard";
post_config();
return;
}
bin/station-mgr.pl view on Meta::CPAN
} else {
# set status
$self->{status}{$device->{id}}{type} = $device->{type};
$self->{status}{$device->{id}}{timestamp} = time;
$self->{status}{$device->{id}}{running} = 0;
$self->{status}{$device->{id}}{status} = "not_configured";
$self->{status}{$device->{id}}{state} = "hard";
}
return;
}
view release on metacpan or search on metacpan
lib/App/Fasops/Command/refine.pm view on Meta::CPAN
my $head_set = AlignDB::IntSpan->new;
$head_set->add_pair( 1, $chop_length );
my $head_indel_set = $indel_set->find_islands($head_set);
# head indels
if ( $head_indel_set->is_not_empty ) {
for ( 1 .. $head_indel_set->max ) {
for my $info ( @{$info_ary} ) {
my $base = substr( $info->{seq}, 0, 1, '' );
if ( $base ne '-' ) {
if ( $info->{strand} eq "+" ) {
lib/App/Fasops/Command/refine.pm view on Meta::CPAN
my $tail_set = AlignDB::IntSpan->new;
$tail_set->add_range( $align_length - $chop_length + 1, $align_length );
my $tail_indel_set = $indel_set->find_islands($tail_set);
# tail indels
if ( $tail_indel_set->is_not_empty ) {
for ( $tail_indel_set->min .. $align_length ) {
for my $info ( @{$info_ary} ) {
my $base = substr( $info->{seq}, -1, 1, '' );
if ( $base ne '-' ) {
if ( $info->{strand} eq "+" ) {
view release on metacpan or search on metacpan
lib/Test/Fetchware.pm view on Meta::CPAN
our %EXPORT_TAGS = (
TESTING => [qw(
eval_ok
print_ok
fork_ok
fork_not_ok
skip_all_unless_release_testing
make_clean
make_test_dist
md5sum_file
expected_filename_listing
lib/Test/Fetchware.pm view on Meta::CPAN
return $?;
}
sub fork_not_ok {
my $coderef = shift;
my $test_name = shift;
my $kid = fork;
lib/Test/Fetchware.pm view on Meta::CPAN
lack of support for forking may be fixed in Test::Builder 1.5 or perhaps 2.0,
but those are still in development.
=back
=head2 fork_not_ok()
fork_not_ok(&code_fork_should_do, $test_name);
The exact same thing as fork_ok() except it expects failure and reports true
when the provided coderef returns failure. If the provided coderef returns true,
then it reports failure to the test suite.
The same warnings and problems associated with fork_ok() apply to fork_not_ok().
=head2 skip_all_unless_release_testing()
subtest 'some subtest that tests fetchware' => sub {
skip_all_unless_release_testing();
view release on metacpan or search on metacpan
lib/App/FileCleanerByDiskUage.pm view on Meta::CPAN
# get the stats for all the files
my @files_info;
foreach my $file (@files) {
my %file_info;
my $not_used;
(
$not_used, $not_used, $not_used, $not_used, $not_used,
$not_used, $not_used, $not_used, $not_used, $file_info{mtime},
$not_used, $not_used, $not_used
) = stat($file);
$file_info{name} = $file;
push( @files_info, \%file_info );
} ## end foreach my $file (@files)
view release on metacpan or search on metacpan
xt/boilerplate.t view on Meta::CPAN
use warnings;
use Test::More;
plan tests => 3;
sub not_in_file_ok {
my ($filename, %regex) = @_;
open( my $fh, '<', $filename )
or die "couldn't open $filename for reading: $!";
my %violated;
xt/boilerplate.t view on Meta::CPAN
}
}
sub module_boilerplate_ok {
my ($module) = @_;
not_in_file_ok($module =>
'the great new $MODULENAME' => qr/ - The great new /,
'boilerplate description' => qr/Quick summary of what the module/,
'stub function definition' => qr/function[12]/,
);
}
TODO: {
local $TODO = "Need to replace the boilerplate text";
not_in_file_ok(README =>
"The README is used..." => qr/The README is used/,
"'version information here'" => qr/to provide version information/,
);
not_in_file_ok(Changes =>
"placeholder date/time" => qr(Date/time)
);
module_boilerplate_ok('lib/App/FileComposer.pm');
view release on metacpan or search on metacpan
script/dir-not-empty view on Meta::CPAN
our $AUTHORITY = 'cpan:PERLANCAR'; # AUTHORITY
our $DATE = '2023-11-30'; # DATE
our $DIST = 'App-FileTestUtils'; # DIST
our $VERSION = '0.005'; # VERSION
App::FileTestUtils::do_script("dir_not_empty");
# ABSTRACT: Test that a directory is not empty
# PODNAME: dir-not-empty
__END__
script/dir-not-empty view on Meta::CPAN
if you specify C<-v> or C<--invert-match>).
=head1 DESCRIPTION
This is CLI for L<File::Util::Test>'s
L<dir_not_empty|File::Util::Test/dir_not_empty>.
=head1 HOMEPAGE
Please visit the project's homepage at L<https://metacpan.org/release/App-FileTestUtils>.
view release on metacpan or search on metacpan
t/boilerplate.t view on Meta::CPAN
use strict;
use warnings;
use Test::More tests => 3;
sub not_in_file_ok {
my ($filename, %regex) = @_;
open( my $fh, '<', $filename )
or die "couldn't open $filename for reading: $!";
my %violated;
t/boilerplate.t view on Meta::CPAN
}
}
sub module_boilerplate_ok {
my ($module) = @_;
not_in_file_ok($module =>
'the great new $MODULENAME' => qr/ - The great new /,
'boilerplate description' => qr/Quick summary of what the module/,
'stub function definition' => qr/function[12]/,
);
}
TODO: {
local $TODO = "Need to replace the boilerplate text";
not_in_file_ok(README =>
"The README is used..." => qr/The README is used/,
"'version information here'" => qr/to provide version information/,
);
not_in_file_ok(Changes =>
"placeholder date/time" => qr(Date/time)
);
module_boilerplate_ok('lib/App/Foca/Server.pm');
view release on metacpan or search on metacpan
lib/App/FoodColorUtils.pm view on Meta::CPAN
=item * B<code.min> => I<str>
Only return records where the 'code' field is greater than or equal to specified value.
=item * B<code.not_contains> => I<str>
Only return records where the 'code' field does not contain specified text.
=item * B<code.not_in> => I<array[str]>
Only return records where the 'code' field is not in the specified values.
=item * B<code.xmax> => I<str>
lib/App/FoodColorUtils.pm view on Meta::CPAN
=item * B<color.min> => I<str>
Only return records where the 'color' field is greater than or equal to specified value.
=item * B<color.not_contains> => I<str>
Only return records where the 'color' field does not contain specified text.
=item * B<color.not_in> => I<array[str]>
Only return records where the 'color' field is not in the specified values.
=item * B<color.xmax> => I<str>
lib/App/FoodColorUtils.pm view on Meta::CPAN
=item * B<name.min> => I<str>
Only return records where the 'name' field is greater than or equal to specified value.
=item * B<name.not_contains> => I<str>
Only return records where the 'name' field does not contain specified text.
=item * B<name.not_in> => I<array[str]>
Only return records where the 'name' field is not in the specified values.
=item * B<name.xmax> => I<str>
view release on metacpan or search on metacpan
t/00-boilerplate.t view on Meta::CPAN
use strict;
use warnings;
use Test::More tests => 3;
sub not_in_file_ok {
my ($filename, %regex) = @_;
open( my $fh, '<', $filename )
or fail("couldn't open $filename for reading: $!") ;
my %violated;
t/00-boilerplate.t view on Meta::CPAN
}
}
sub module_boilerplate_ok {
my ($module) = @_;
not_in_file_ok($module =>
'the great new $MODULENAME' => qr/ - The great new /,
'boilerplate description' => qr/Quick summary of what the module/,
'stub function definition' => qr/function[12]/,
);
}
not_in_file_ok(README =>
"The README is used..." => qr/The README is used/,
"'version information here'" => qr/to provide version information/,
);
not_in_file_ok(Changes =>
"placeholder date/time" => qr(Date/time)
);
module_boilerplate_ok('lib/App/Framework/Lite.pm');
view release on metacpan or search on metacpan
t/00-boilerplate.t view on Meta::CPAN
use strict;
use warnings;
use Test::More tests => 3;
sub not_in_file_ok {
my ($filename, %regex) = @_;
open( my $fh, '<', $filename )
or fail("couldn't open $filename for reading: $!") ;
my %violated;
t/00-boilerplate.t view on Meta::CPAN
}
}
sub module_boilerplate_ok {
my ($module) = @_;
not_in_file_ok($module =>
'the great new $MODULENAME' => qr/ - The great new /,
'boilerplate description' => qr/Quick summary of what the module/,
'stub function definition' => qr/function[12]/,
);
}
not_in_file_ok(README =>
"The README is used..." => qr/The README is used/,
"'version information here'" => qr/to provide version information/,
);
not_in_file_ok(Changes =>
"placeholder date/time" => qr(Date/time)
);
module_boilerplate_ok('lib/App/Framework.pm');
view release on metacpan or search on metacpan
lib/App/FromUnixtime.pm view on Meta::CPAN
if ( ! IO::Interactive::Tiny::is_interactive(*STDIN) ) {
while ( my $line = <STDIN> ) {
chomp $line;
if ( my $match = _may_replace($line, $config) ) {
if ( ! _may_not_replace($line, $config) ) {
_replace_unixtime($match => \$line, $config);
}
}
print "$line\n";
}
lib/App/FromUnixtime.pm view on Meta::CPAN
) {
return $1;
}
}
sub _may_not_replace {
my ($line, $config) = @_;
return unless $config->{'no-re'};
for my $no_re (@{$config->{'no-re'}}) {
view release on metacpan or search on metacpan
script/_genpass-id view on Meta::CPAN
#@plural{@no_change} = @no_change;
#
#
#
#
#my @not_plural = (qw/
#Aries
#Charles
#Gonzales
#Hades
#Hercules
script/_genpass-id view on Meta::CPAN
#yes
#nucleus
#synchronous
#/);
#
#my %not_plural;
#
#@not_plural{@not_plural} = (1) x @not_plural;
#
#
#
#
#
script/_genpass-id view on Meta::CPAN
#
#sub to_singular
#{
# my ($word) = @_;
# my $singular = $word;
# if (! $not_plural{$word}) {
# if ($plural{$word}) {
# $singular = $plural{$word};
# }
# elsif ($word =~ /s$/) {
# if ($word =~ /'s$/) {
view release on metacpan or search on metacpan
script/_genpass-wordlist view on Meta::CPAN
#@plural{@no_change} = @no_change;
#
#
#
#
#my @not_plural = (qw/
#Aries
#Charles
#Gonzales
#Hades
#Hercules
script/_genpass-wordlist view on Meta::CPAN
#yes
#nucleus
#synchronous
#/);
#
#my %not_plural;
#
#@not_plural{@not_plural} = (1) x @not_plural;
#
#
#
#
#
script/_genpass-wordlist view on Meta::CPAN
#
#sub to_singular
#{
# my ($word) = @_;
# my $singular = $word;
# if (! $not_plural{$word}) {
# if ($plural{$word}) {
# $singular = $plural{$word};
# }
# elsif ($word =~ /s$/) {
# if ($word =~ /'s$/) {
view release on metacpan or search on metacpan
script/getopt-long-sample-implicit-dest-hash-storage view on Meta::CPAN
my %opts;
GetOptions(
\%opts,
'foo=s',
'bar=s' => \$opts{not_bar},
'baz=s',
'help|h' => sub {
print <<'_';
Usage:
getopt-long-sample-implicit-dest [[--foo=s] [--bar=s] [--baz=s]] | [--help|-h]