perl
view release on metacpan or search on metacpan
cpan/Encode/t/decode.t view on Meta::CPAN
#
# $Id: decode.t,v 1.5 2019/01/31 04:26:40 dankogai Exp $
#
use strict;
use Encode qw(decode_utf8 FB_CROAK find_encoding decode);
use Test::More tests => 17;
use Test::Builder;
sub croak_ok(&) {
local $Test::Builder::Level = $Test::Builder::Level + 1;
my $code = shift;
eval { $code->() };
like $@, qr/does not map/;
}
my $bytes = "L\x{e9}on";
my $pad = "\x{30C9}";
my $orig = $bytes;
cpan/ExtUtils-MakeMaker/t/lib/MakeMaker/Test/Utils.pm view on Meta::CPAN
created with L<File::Temp> and then automatically deleted after. It ends
by C<chdir>ing back to where it started.
If the given code throws an exception, it will be re-thrown after the
re-C<chdir>.
Returns the return value of the given code.
=cut
sub in_dir(&;$) {
my $code = shift;
require File::Temp;
my $dir = shift || File::Temp::tempdir(TMPDIR => 1, CLEANUP => 1);
# chdir to the new directory
my $orig_dir = getcwd();
chdir $dir or die "Can't chdir to $dir: $!";
# Run the code, but trap the error so we can chdir back
my $return;
my $ok = eval { $return = $code->(); 1; };
my $err = $@;
cpan/Module-Metadata/t/taint.t view on Meta::CPAN
use strict;
use warnings;
use Config;
use Test::More $Config{ccflags} =~ /-DSILENT_NO_TAINT_SUPPORT/
? ( skip_all => 'No taint support' ) : ( tests => 2 );
use Module::Metadata;
use Carp 'croak';
# stolen liberally from Class-Tiny/t/lib/TestUtils.pm - thanks xdg!
sub exception(&) {
my $code = shift;
my $success = eval { $code->(); 1 };
my $err = $@;
return undef if $success; # original returned ''
croak "Execution died, but the error was lost" unless $@;
return $@;
}
my $taint_on = ! eval { no warnings; join('',values %ENV), kill 0; 1; };
ok($taint_on, 'taint flag is set');
cpan/Scalar-List-Utils/lib/Scalar/Util.pm view on Meta::CPAN
sub export_fail {
if (grep { /^isvstring$/ } @_ ) {
require Carp;
Carp::croak("Vstrings are not implemented in this version of perl");
}
@_;
}
# set_prototype has been moved to Sub::Util with a different interface
sub set_prototype(&$)
{
my ( $code, $proto ) = @_;
return Sub::Util::set_prototype( $proto, $code );
}
1;
__END__
=head1 NAME
cpan/Term-Table/lib/Term/Table/Util.pm view on Meta::CPAN
use base 'Exporter';
our @EXPORT_OK = qw/term_size USE_GCS USE_TERM_READKEY USE_TERM_SIZE_ANY uni_length/;
sub DEFAULT_SIZE() { 80 }
my $IO;
BEGIN {
open($IO, '>&', *STDOUT) or die "Could not clone STDOUT";
}
sub try(&) {
my $code = shift;
local ($@, $?, $!);
my $ok = eval { $code->(); 1 };
my $err = $@;
return ($ok, $err);
}
my ($tsa) = try { require Term::Size::Any; Term::Size::Any->import('chars') };
my ($trk) = try { require Term::ReadKey };
$trk &&= Term::ReadKey->can('GetTerminalSize');
cpan/Term-Table/t/HashBase.t view on Meta::CPAN
use strict;
use warnings;
use Test::More;
sub warnings(&) {
my $code = shift;
my @warnings;
local $SIG{__WARN__} = sub { push @warnings => @_ };
$code->();
return \@warnings;
}
sub exception(&) {
my $code = shift;
local ($@, $!, $SIG{__DIE__});
my $ok = eval { $code->(); 1 };
my $error = $@ || 'SQUASHED ERROR';
return $ok ? undef : $error;
}
BEGIN {
$INC{'Object/HashBase/Test/HBase.pm'} = __FILE__;
cpan/Test-Simple/lib/Test2/API.pm view on Meta::CPAN
# Private, for use in Test2::API::Context
sub _contexts_ref { $INST->contexts }
sub _context_acquire_callbacks_ref { $INST->context_acquire_callbacks }
sub _context_init_callbacks_ref { $INST->context_init_callbacks }
sub _context_release_callbacks_ref { $INST->context_release_callbacks }
sub _add_uuid_via_ref { \($INST->{Test2::API::Instance::ADD_UUID_VIA()}) }
# Private, for use in Test2::IPC
sub _set_ipc { $INST->set_ipc(@_) }
sub context_do(&;@) {
my $code = shift;
my @args = @_;
my $ctx = context(level => 1);
my $want = wantarray;
my @out;
my $ok = eval {
$want ? @out = $code->($ctx, @args) :
cpan/Test-Simple/lib/Test2/API.pm view on Meta::CPAN
$ctx->release;
die $err unless $ok;
return @out if $want;
return $out[0] if defined $want;
return;
}
sub no_context(&;$) {
my ($code, $hid) = @_;
$hid ||= $STACK->top->hid;
my $ctx = $CONTEXTS->{$hid};
delete $CONTEXTS->{$hid};
my $ok = eval { $code->(); 1 };
my $err = $@;
$CONTEXTS->{$hid} = $ctx;
weaken($CONTEXTS->{$hid});
cpan/Test-Simple/lib/Test2/API.pm view on Meta::CPAN
Removing the old context and creating a new one...
EOT
}
sub release($;$) {
$_[0]->release;
return $_[1];
}
sub intercept(&) {
my $code = shift;
my $ctx = context();
my $events = _intercept($code, deep => 0);
$ctx->release;
return $events;
}
sub intercept_deep(&) {
my $code = shift;
my $ctx = context();
my $events = _intercept($code, deep => 1);
$ctx->release;
return $events;
}
cpan/Test-Simple/lib/Test2/Tools/Tiny.pm view on Meta::CPAN
$ctx->plan($max);
$ctx->release;
}
sub done_testing {
my $ctx = context();
$ctx->done_testing;
$ctx->release;
}
sub warnings(&) {
my $code = shift;
my @warnings;
local $SIG{__WARN__} = sub { push @warnings => @_ };
$code->();
return \@warnings;
}
sub exception(&) {
my $code = shift;
local ($@, $!, $SIG{__DIE__});
my $ok = eval { $code->(); 1 };
my $error = $@ || 'SQUASHED ERROR';
return $ok ? undef : $error;
}
sub tests {
my ($name, $code) = @_;
my $ctx = context();
cpan/Test-Simple/lib/Test2/Tools/Tiny.pm view on Meta::CPAN
$be->($name) if $be;
my $bool = run_subtest($name, $code, 1);
$ctx->release;
return $bool;
}
sub capture(&) {
my $code = shift;
my ($err, $out) = ("", "");
my $handles = test2_stack->top->format->handles;
my ($ok, $e);
{
my ($out_fh, $err_fh);
($ok, $e) = try {
cpan/Test-Simple/lib/Test2/Util.pm view on Meta::CPAN
my $can_really_fork;
sub CAN_REALLY_FORK () {
return $can_really_fork
if defined $can_really_fork;
$can_really_fork = !!$Config{d_fork};
no warnings 'redefine';
*CAN_REALLY_FORK = $can_really_fork ? sub() { 1 } : sub() { 0 };
$can_really_fork;
}
sub _manual_try(&;@) {
my $code = shift;
my $args = \@_;
my $err;
my $die = delete $SIG{__DIE__};
eval { $code->(@$args); 1 } or $err = $@ || "Error was squashed!\n";
$die ? $SIG{__DIE__} = $die : delete $SIG{__DIE__};
return (!defined($err), $err);
}
sub _local_try(&;@) {
my $code = shift;
my $args = \@_;
my $err;
no warnings;
local $SIG{__DIE__};
eval { $code->(@$args); 1 } or $err = $@ || "Error was squashed!\n";
return (!defined($err), $err);
}
cpan/Test-Simple/lib/Test2/Util.pm view on Meta::CPAN
return (0, "$!");
};
*do_unlink = sub {
my ($file) = @_;
return (1) if unlink($file);
return (0, "$!");
};
}
}
sub try_sig_mask(&) {
my $code = shift;
my ($old, $blocked);
unless(IS_WIN32) {
my $to_block = POSIX::SigSet->new(
POSIX::SIGINT(),
POSIX::SIGALRM(),
POSIX::SIGHUP(),
POSIX::SIGTERM(),
POSIX::SIGUSR1(),
cpan/Test-Simple/t/HashBase.t view on Meta::CPAN
use strict;
use warnings;
use Test::More;
sub warnings(&) {
my $code = shift;
my @warnings;
local $SIG{__WARN__} = sub { push @warnings => @_ };
$code->();
return \@warnings;
}
sub exception(&) {
my $code = shift;
local ($@, $!, $SIG{__DIE__});
my $ok = eval { $code->(); 1 };
my $error = $@ || 'SQUASHED ERROR';
return $ok ? undef : $error;
}
BEGIN {
$INC{'Object/HashBase/Test/HBase.pm'} = __FILE__;
cpan/Test-Simple/t/Legacy/Regression/736_use_ok.t view on Meta::CPAN
BEGIN {
$INC{'MyWarner.pm'} = 1;
package MyWarner;
sub import {
warnings::warnif('deprecated', "Deprecated! run for your lives!");
}
}
sub capture(&) {
my $warn;
local $SIG{__WARN__} = sub { $warn = shift };
$_[0]->();
return $warn || "";
}
{
local $TODO = "known to fail on $]" if $] le "5.006002";
my $file = __FILE__;
my $line = __LINE__ + 4;
cpan/Test-Simple/t/Test2/modules/API/Context.t view on Meta::CPAN
test2_add_callback_context_init
test2_add_callback_context_release
};
my $error = exception { context(); 1 };
my $exception = "context() called, but return value is ignored at " . __FILE__ . ' line ' . (__LINE__ - 1);
like($error, qr/^\Q$exception\E/, "Got the exception" );
my $ref;
my $frame;
sub wrap(&) {
my $ctx = context();
my ($pkg, $file, $line, $sub) = caller(0);
$frame = [$pkg, $file, $line, $sub];
$_[0]->($ctx);
$ref = "$ctx";
$ctx->release;
}
cpan/Test-Simple/t/Test2/modules/IPC/Driver/Files.t view on Meta::CPAN
use File::Spec;
use List::Util qw/shuffle/;
use strict;
use warnings;
if ($] lt "5.008") {
print "1..0 # SKIP Test cannot run on perls below 5.8.0\n";
exit 0;
}
sub simple_capture(&) {
my $code = shift;
my ($err, $out) = ("", "");
my ($ok, $e);
{
local *STDOUT;
local *STDERR;
($ok, $e) = try {
cpan/Test2-Suite/lib/Test2/Tools/Compare.pm view on Meta::CPAN
}
else {
$ctx->ok(0, $name, ["Comparison matched (it should not).", @diag]);
$ctx->$_autodump($got);
}
$ctx->release;
return $delta ? 1 : 0;
}
sub meta(&) { build('Test2::Compare::Meta', @_) }
sub meta_check(&) { build('Test2::Compare::Meta', @_) }
sub hash(&) { build('Test2::Compare::Hash', @_) }
sub array(&) { build('Test2::Compare::Array', @_) }
sub bag(&) { build('Test2::Compare::Bag', @_) }
sub object(&) { build('Test2::Compare::Object', @_) }
sub subset(&) { build('Test2::Compare::OrderedSubset', @_) }
sub U() {
my @caller = caller;
Test2::Compare::Custom->new(
code => sub { defined $_ ? 0 : 1 }, name => 'UNDEFINED', operator => '!DEFINED()',
file => $caller[1],
lines => [$caller[2]],
);
}
cpan/Test2-Suite/lib/Test2/Tools/Compare.pm view on Meta::CPAN
my ($class_name, @args) = @_;
my @caller = caller;
return Test2::Compare::Isa->new(
file => $caller[1],
lines => [$caller[2]],
input => $class_name,
@args,
);
}
sub filter_items(&) {
defined( my $build = get_build() ) or croak "No current build!";
croak "'$build' does not support filters"
unless $build->can('add_filter');
croak "'filter_items' should only ever be called in void context"
if defined wantarray;
$build->add_filter(@_);
}
cpan/Test2-Suite/lib/Test2/Tools/Exception.pm view on Meta::CPAN
use warnings;
our $VERSION = '0.000162';
use Carp qw/carp/;
use Test2::API qw/context/;
our @EXPORT = qw/dies lives try_ok/;
use base 'Exporter';
sub dies(&) {
my $code = shift;
defined wantarray or carp "Useless use of dies() in void context";
local ($@, $!, $?);
my $ok = eval { $code->(); 1 };
my $err = $@;
return undef if $ok;
unless ($err) {
my $ctx = context();
$ctx->alert("Got exception as expected, but exception is falsy (undef, '', or 0)...");
$ctx->release;
}
return $err;
}
sub lives(&) {
my $code = shift;
defined wantarray or carp "Useless use of lives() in void context";
my $err;
{
local ($@, $!, $?);
eval { $code->(); 1 } and return 1;
$err = $@;
}
# If the eval failed we want to set $@ to the error.
$@ = $err;
return 0;
}
sub try_ok(&;$) {
my ($code, $name) = @_;
my $ok = &lives($code);
my $err = $@;
# Context should be obtained AFTER code is run so that events inside the
# codeblock report inside the codeblock itself. This will also preserve $@
# as thrown inside the codeblock.
my $ctx = context();
chomp(my $diag = "Exception: $err");
cpan/Test2-Suite/lib/Test2/Tools/Warnings.pm view on Meta::CPAN
use strict;
use warnings;
our $VERSION = '0.000162';
use Test2::API qw/context/;
our @EXPORT = qw/warns warning warnings no_warnings/;
use base 'Exporter';
sub warns(&) {
my $code = shift;
my $warnings = 0;
local $SIG{__WARN__} = sub { $warnings++ };
$code->();
return $warnings;
}
sub no_warnings(&) { return !&warns(@_) }
sub warning(&) {
my $code = shift;
my @warnings;
{
local $SIG{__WARN__} = sub { push @warnings => @_ };
$code->();
return unless @warnings;
}
if (@warnings > 1) {
my $ctx = context();
$ctx->alert("Extra warnings in warning { ... }");
$ctx->note($_) for @warnings;
$ctx->release;
}
return $warnings[0];
}
sub warnings(&) {
my $code = shift;
my @warnings;
local $SIG{__WARN__} = sub { push @warnings => @_ };
$code->();
return \@warnings;
}
1;
cpan/Test2-Suite/t/modules/Plugin/SRand.t view on Meta::CPAN
use Test2::Tools::Basic;
use Test2::API qw/intercept test2_stack context/;
use Test2::Tools::Compare qw/array event end is like/;
use Test2::Tools::Target 'Test2::Plugin::SRand';
use Test2::Tools::Warnings qw/warning/;
test2_stack->top;
my ($root) = test2_stack->all;
sub intercept_2(&) {
my $code = shift;
# This is to force loading to happen
my $ctx = context();
my @events;
my $l = $root->listen(sub {
my ($h, $e) = @_;
push @events => $e;
cpan/Test2-Suite/t/modules/Tools/Defer.t view on Meta::CPAN
def is => (1, 1, "1 is 1");
def is => ({}, {}, "hash is hash");
def ok => (0, 'lies');
def is => (0, 1, "1 is not 0");
def is => ({}, [], "a hash is not an array");
}
use Test2::Bundle::Extended -target => 'Test2::Tools::Defer';
sub capture(&) {
my $code = shift;
my ($err, $out) = ("", "");
my ($ok, $e);
{
local *STDOUT;
local *STDERR;
($ok, $e) = Test2::Util::try(sub {
ext/XS-APItest/t/arrayexpr.t view on Meta::CPAN
use warnings;
use strict;
use Test::More tests => 2*10;
BEGIN { $^H |= 0x20000; }
my @t;
sub mymap(&@) { my $sub = shift; return map { $sub->($_) } @_; }
sub myneg(@) { return map { -$_ } @_; }
package AA { sub listmeth { shift; return map { -$_ } @_; } }
@t = ();
eval q{
use XS::APItest qw(arrayfullexpr);
no warnings "void";
push @t, arrayfullexpr 1+2;
push @t, arrayfullexpr 0 || 2;
push @t, arrayfullexpr 1 || 2;
t/op/die_keeperr.t view on Meta::CPAN
BEGIN {
chdir 't' if -d 't';
require './test.pl';
}
plan(24);
sub End::DESTROY { $_[0]->() }
sub end(&) {
my($c) = @_;
return bless(sub { $c->() }, "End");
}
foreach my $inx ("", "aabbcc\n", [qw(aa bb cc)]) {
foreach my $outx ("", "xxyyzz\n", [qw(xx yy zz)]) {
my $warn = "";
local $SIG{__WARN__} = sub { $warn .= $_[0] };
{
$@ = $outx;
( run in 0.937 second using v1.01-cache-2.11-cpan-49f99fa48dc )