Result:
found more than 1006 distributions - search limited to the first 2001 files matching your query
( run in 1.605 )
Alt-FFI-libffi
view release on metacpan or search on metacpan
xt/author/pod_spelling_system.t view on Meta::CPAN
add_stopwords(@{ $config->{pod_spelling_system}->{stopwords} });
add_stopwords(qw(
Plicease
stdout
stderr
stdin
subref
loopback
username
os
Alt-IO-All-new
view release on metacpan or search on metacpan
inc/TestML/Library/Standard.pm view on Meta::CPAN
# $command = $command->value;
# chomp($command);
# my $sub = sub {
# system($command);
# };
# my ($stdout, $stderr) = Capture::Tiny::capture($sub);
# $self->runtime->function->setvar('_Stdout', $stdout);
# $self->runtime->function->setvar('_Stderr', $stderr);
# return str('');
# }
# sub RmPath {
# require File::Path;
Alt-Math-Prime-FastSieve-Inline
view release on metacpan or search on metacpan
inc/Capture/Tiny.pm view on Meta::CPAN
#--------------------------------------------------------------------------#
my %api = (
capture => [1,1,0,0],
capture_stdout => [1,0,0,0],
capture_stderr => [0,1,0,0],
capture_merged => [1,1,1,0],
tee => [1,1,0,1],
tee_stdout => [1,0,0,1],
tee_stderr => [0,1,0,1],
tee_merged => [1,1,1,1],
);
for my $sub ( keys %api ) {
my $args = join q{, }, @{$api{$sub}};
inc/Capture/Tiny.pm view on Meta::CPAN
}
$proxies{stdout} = \*STDOUT;
binmode(STDOUT, ':utf8') if $] >= 5.008;
}
if ( ! defined fileno STDERR ) {
$proxy_count{stderr}++;
if (defined $dup{stderr}) {
_open \*STDERR, ">&=" . fileno($dup{stderr});
# _debug( "# restored proxy STDERR as " . (defined fileno STDERR ? fileno STDERR : 'undef' ) . "\n" );
}
else {
_open \*STDERR, ">" . File::Spec->devnull;
# _debug( "# proxied STDERR as " . (defined fileno STDERR ? fileno STDERR : 'undef' ) . "\n" );
_open $dup{stderr} = IO::Handle->new, ">&=STDERR";
}
$proxies{stderr} = \*STDERR;
binmode(STDERR, ':utf8') if $] >= 5.008;
}
return %proxies;
}
inc/Capture/Tiny.pm view on Meta::CPAN
}
}
sub _copy_std {
my %handles;
for my $h ( qw/stdout stderr stdin/ ) {
next if $h eq 'stdin' && ! $IS_WIN32; # WIN32 hangs on tee without STDIN copied
my $redir = $h eq 'stdin' ? "<&" : ">&";
_open $handles{$h} = IO::Handle->new(), $redir . uc($h); # ">&STDOUT" or "<&STDIN"
}
return \%handles;
inc/Capture/Tiny.pm view on Meta::CPAN
# the output handles (setting up redirection)
sub _open_std {
my ($handles) = @_;
_open \*STDIN, "<&" . fileno $handles->{stdin} if defined $handles->{stdin};
_open \*STDOUT, ">&" . fileno $handles->{stdout} if defined $handles->{stdout};
_open \*STDERR, ">&" . fileno $handles->{stderr} if defined $handles->{stderr};
}
#--------------------------------------------------------------------------#
# private subs
#--------------------------------------------------------------------------#
sub _start_tee {
my ($which, $stash) = @_; # $which is "stdout" or "stderr"
# setup pipes
$stash->{$_}{$which} = IO::Handle->new for qw/tee reader/;
pipe $stash->{reader}{$which}, $stash->{tee}{$which};
# _debug( "# pipe for $which\: " . _name($stash->{tee}{$which}) . " " . fileno( $stash->{tee}{$which} ) . " => " . _name($stash->{reader}{$which}) . " " . fileno( $stash->{reader}{$which}) . "\n" );
select((select($stash->{tee}{$which}), $|=1)[0]); # autoflush
# setup desired redirection for parent and child
$stash->{new}{$which} = $stash->{tee}{$which};
$stash->{child}{$which} = {
stdin => $stash->{reader}{$which},
stdout => $stash->{old}{$which},
stderr => $stash->{capture}{$which},
};
# flag file is used to signal the child is ready
$stash->{flag_files}{$which} = scalar tmpnam();
# execute @cmd as a separate process
if ( $IS_WIN32 ) {
inc/Capture/Tiny.pm view on Meta::CPAN
_fork_exec( $which, $stash );
}
}
sub _fork_exec {
my ($which, $stash) = @_; # $which is "stdout" or "stderr"
my $pid = fork;
if ( not defined $pid ) {
Carp::confess "Couldn't fork(): $!";
}
elsif ($pid == 0) { # child
inc/Capture/Tiny.pm view on Meta::CPAN
# _capture_tee() -- generic main sub for capturing or teeing
#--------------------------------------------------------------------------#
sub _capture_tee {
# _debug( "# starting _capture_tee with (@_)...\n" );
my ($do_stdout, $do_stderr, $do_merge, $do_tee, $code, @opts) = @_;
my %do = ($do_stdout ? (stdout => 1) : (), $do_stderr ? (stderr => 1) : ());
Carp::confess("Custom capture options must be given as key/value pairs\n")
unless @opts % 2 == 0;
my $stash = { capture => { @opts } };
for ( keys %{$stash->{capture}} ) {
my $fh = $stash->{capture}{$_};
inc/Capture/Tiny.pm view on Meta::CPAN
local *CT_ORIG_STDERR = *STDERR;
# find initial layers
my %layers = (
stdin => [PerlIO::get_layers(\*STDIN) ],
stdout => [PerlIO::get_layers(\*STDOUT, output => 1)],
stderr => [PerlIO::get_layers(\*STDERR, output => 1)],
);
# _debug( "# existing layers for $_\: @{$layers{$_}}\n" ) for qw/stdin stdout stderr/;
# get layers from underlying glob of tied filehandles if we can
# (this only works for things that work like Tie::StdHandle)
$layers{stdout} = [PerlIO::get_layers(tied *STDOUT)]
if tied(*STDOUT) && (reftype tied *STDOUT eq 'GLOB');
$layers{stderr} = [PerlIO::get_layers(tied *STDERR)]
if tied(*STDERR) && (reftype tied *STDERR eq 'GLOB');
# _debug( "# tied object corrected layers for $_\: @{$layers{$_}}\n" ) for qw/stdin stdout stderr/;
# bypass scalar filehandles and tied handles
# localize scalar STDIN to get a proxy to pick up FD0, then restore later to CT_ORIG_STDIN
my %localize;
$localize{stdin}++, local(*STDIN)
if grep { $_ eq 'scalar' } @{$layers{stdin}};
$localize{stdout}++, local(*STDOUT)
if $do_stdout && grep { $_ eq 'scalar' } @{$layers{stdout}};
$localize{stderr}++, local(*STDERR)
if ($do_stderr || $do_merge) && grep { $_ eq 'scalar' } @{$layers{stderr}};
$localize{stdin}++, local(*STDIN), _open( \*STDIN, "<&=0")
if tied *STDIN && $] >= 5.008;
$localize{stdout}++, local(*STDOUT), _open( \*STDOUT, ">&=1")
if $do_stdout && tied *STDOUT && $] >= 5.008;
$localize{stderr}++, local(*STDERR), _open( \*STDERR, ">&=2")
if ($do_stderr || $do_merge) && tied *STDERR && $] >= 5.008;
# _debug( "# localized $_\n" ) for keys %localize;
# proxy any closed/localized handles so we don't use fds 0, 1 or 2
my %proxy_std = _proxy_std();
# _debug( "# proxy std: @{ [%proxy_std] }\n" );
# update layers after any proxying
$layers{stdout} = [PerlIO::get_layers(\*STDOUT, output => 1)] if $proxy_std{stdout};
$layers{stderr} = [PerlIO::get_layers(\*STDERR, output => 1)] if $proxy_std{stderr};
# _debug( "# post-proxy layers for $_\: @{$layers{$_}}\n" ) for qw/stdin stdout stderr/;
# store old handles and setup handles for capture
$stash->{old} = _copy_std();
$stash->{new} = { %{$stash->{old}} }; # default to originals
for ( keys %do ) {
$stash->{new}{$_} = ($stash->{capture}{$_} ||= File::Temp->new);
inc/Capture/Tiny.pm view on Meta::CPAN
# _debug("# will capture $_ on " . fileno($stash->{capture}{$_})."\n" );
_start_tee( $_ => $stash ) if $do_tee; # tees may change $stash->{new}
}
_wait_for_tees( $stash ) if $do_tee;
# finalize redirection
$stash->{new}{stderr} = $stash->{new}{stdout} if $do_merge;
# _debug( "# redirecting in parent ...\n" );
_open_std( $stash->{new} );
# execute user provided code
my ($exit_code, $inner_error, $outer_error, @result);
{
local *STDIN = *CT_ORIG_STDIN if $localize{stdin}; # get original, not proxy STDIN
# _debug( "# finalizing layers ...\n" );
_relayer(\*STDOUT, $layers{stdout}) if $do_stdout;
_relayer(\*STDERR, $layers{stderr}) if $do_stderr;
# _debug( "# running code $code ...\n" );
local $@;
eval { @result = $code->(); $inner_error = $@ };
$exit_code = $?; # save this for later
$outer_error = $@; # save this for later
inc/Capture/Tiny.pm view on Meta::CPAN
# _debug( "# restoring filehandles ...\n" );
_open_std( $stash->{old} );
_close( $_ ) for values %{$stash->{old}}; # don't leak fds
# shouldn't need relayering originals, but see rt.perl.org #114404
_relayer(\*STDOUT, $layers{stdout}) if $do_stdout;
_relayer(\*STDERR, $layers{stderr}) if $do_stderr;
_unproxy( %proxy_std );
# _debug( "# killing tee subprocesses ...\n" ) if $do_tee;
_kill_tees( $stash ) if $do_tee;
# return captured output, but shortcut in void context
# unless we have to echo output to tied/scalar handles;
inc/Capture/Tiny.pm view on Meta::CPAN
$got{$_} = _slurp($_, $stash);
# _debug("# slurped " . length($got{$_}) . " bytes from $_\n");
}
print CT_ORIG_STDOUT $got{stdout}
if $do_stdout && $do_tee && $localize{stdout};
print CT_ORIG_STDERR $got{stderr}
if $do_stderr && $do_tee && $localize{stderr};
}
$? = $exit_code;
$@ = $inner_error if $inner_error;
die $outer_error if $outer_error;
# _debug( "# ending _capture_tee with (@_)...\n" );
return unless defined wantarray;
my @return;
push @return, $got{stdout} if $do_stdout;
push @return, $got{stderr} if $do_stderr && ! $do_merge;
push @return, @result;
return wantarray ? @return : $return[0];
}
1;
Alt-NewRelic-Agent-FFI-Empty
view release on metacpan or search on metacpan
xt/author/pod_spelling_system.t view on Meta::CPAN
add_stopwords(@{ $config->{pod_spelling_system}->{stopwords} });
add_stopwords(qw(
Plicease
stdout
stderr
stdin
subref
loopback
username
os
Alt-Params-Util-PLICEASE
view release on metacpan or search on metacpan
xt/author/pod_spelling_system.t view on Meta::CPAN
add_stopwords($config->{pod_spelling_system}->{stopwords}->@*);
add_stopwords(qw(
Plicease
stdout
stderr
stdin
subref
loopback
username
os
Alt-Sub-Delete-NewPackageSeparator
view release on metacpan or search on metacpan
t/00-compile.t view on Meta::CPAN
my @warnings;
for my $lib (@module_files)
{
# see L<perlfaq8/How can I capture STDERR from an external command?>
my $stderr = IO::Handle->new;
diag('Running: ', join(', ', map { my $str = $_; $str =~ s/'/\\'/g; q{'} . $str . q{'} }
$^X, @switches, '-e', "require q[$lib]"))
if $ENV{PERL_COMPILE_TEST_DEBUG};
my $pid = open3($stdin, '>&STDERR', $stderr, $^X, @switches, '-e', "require q[$lib]");
binmode $stderr, ':crlf' if $^O eq 'MSWin32';
my @_warnings = <$stderr>;
waitpid($pid, 0);
is($?, 0, "$lib loaded ok");
shift @_warnings if @_warnings and $_warnings[0] =~ /^Using .*\bblib/
and not eval { +require blib; blib->VERSION('1.01') };
AltaVista-BabelFish
view release on metacpan or search on metacpan
BabelFish.pm view on Meta::CPAN
}
eval <<'REDIRECT_END';
use IO::Redirect;
$ior = IO::Redirect->new();
$ior->redirect_stdout_stderr(\$cpan);
REDIRECT_END
my $mod = CPAN::Shell->expand('Module', 'AltaVista::BabelFish');
if(defined $mod) {
if($VERSION eq $mod->cpan_version) {
if(ref $ior) {
$ior->un_redirect_stdout_stderr();
}
return 1;
}
else {
$errstr{ $ident } = "Installed Version: $VERSION\nLatest "
BabelFish.pm view on Meta::CPAN
if ref $ior;
$errstr{ $ident } = "Undefined CPAN Object." if !ref $ior;
}
if(ref $ior) {
$ior->un_redirect_stdout_stderr();
}
return;
}
Alter
view release on metacpan or search on metacpan
PerlIO_read||5.007003|
PerlIO_seek||5.007003|
PerlIO_set_cnt||5.007003|
PerlIO_set_ptrcnt||5.007003|
PerlIO_setlinebuf||5.007003|
PerlIO_stderr||5.007003|
PerlIO_stdin||5.007003|
PerlIO_stdout||5.007003|
PerlIO_tell||5.007003|
PerlIO_unread||5.007003|
PerlIO_write||5.007003|
warner|5.006000|5.004000|pv
warn|||v
watch|||
whichsig|||
write_no_mem|||
write_to_stderr|||
xmldump_all|||
xmldump_attr|||
xmldump_eval|||
xmldump_form|||
xmldump_indent|||v
Alvis-NLPPlatform
view release on metacpan or search on metacpan
- Correction in the TermTagging : language switch was well
taken into account
- Correction in the management of the ".proc_id" file
- correction in the computing of the xml rendering time
(the variable is set to zero ;-)
- stderr when NLP tools are called, is redirected in a log file
- addition of a variable DEBUG defining a debug mode (temporary
files are not removed)
- alvis-nlp-standalone can read a file given in argument or on
the STDIN stream
- Documentation of the modules and scripts are gathered at the
Alvis-Pipeline
view release on metacpan or search on metacpan
lib/Alvis/Logger.pm view on Meta::CPAN
# Create a new logger object. Options that may be specified include:
# level [default 0]: only emit messages with priority less than
# or equal to this (so that the default behaviour is to
# be silent except for priority-zero messages, which are
# really error messages).
# stream [stderr]: where to write messages
#
sub new {
my $class = shift();
#warn("new($class): \@_ = ", join(", ", map { "'$_'" } @_), "\n");
my %options = ( level => 0, stream => \*STDERR, @_ );
Alvis-QueryFilter
view release on metacpan or search on metacpan
bin/run_QF.pl view on Meta::CPAN
B<--testquery> Transform queries and return response without forwarding query to a real SRU server.
B<--verbose> Some additional trace data provided.
This is a simple SRU query filter built using HTTP::Daemon. All configuration data is read from the ALVIS configuration file at <AlvisDir>/alvis.cnf. Error messages and a simple URL trail go to stderr. The linguistic resources used by
Alvis::Query filter are located in <AlvisDir>/resources.
It is intended to be copied and modified for any application.
=head1 CONFIGURATION
Amazon-Dash-Button
view release on metacpan or search on metacpan
t/00-compile.t view on Meta::CPAN
my @warnings;
for my $lib (@module_files)
{
# see L<perlfaq8/How can I capture STDERR from an external command?>
my $stderr = IO::Handle->new;
diag('Running: ', join(', ', map { my $str = $_; $str =~ s/'/\\'/g; q{'} . $str . q{'} }
$^X, @switches, '-e', "require q[$lib]"))
if $ENV{PERL_COMPILE_TEST_DEBUG};
my $pid = open3($stdin, '>&STDERR', $stderr, $^X, @switches, '-e', "require q[$lib]");
binmode $stderr, ':crlf' if $^O eq 'MSWin32';
my @_warnings = <$stderr>;
waitpid($pid, 0);
is($?, 0, "$lib loaded ok");
shift @_warnings if @_warnings and $_warnings[0] =~ /^Using .*\bblib/
and not eval { require blib; blib->VERSION('1.01') };
Amazon-MWS
view release on metacpan or search on metacpan
lib/Amazon/MWS/Uploader.pm view on Meta::CPAN
{ success => 1 },
{
feed_id => $feed_id,
shop_id => $self->_unique_shop_id,
}));
# if we have a success, print the warnings on the stderr.
# if we have a failure, the warnings will just confuse us.
if ($type eq 'order_ack') {
# flip the confirmation bit
$self->_exe_query($self->sqla->update(amazon_mws_orders => { confirmed => 1 },
Amazon-S3-Thin
view release on metacpan or search on metacpan
lib/Amazon/S3/Thin.pm view on Meta::CPAN
=item * C<signature_version> - AWS signature version to use. Supported values
are 2 and 4. Default is 4.
=item * C<debug> - debug option. Default is 0 (false).
If set 1, contents of HTTP request and response are shown on stderr
=item * C<virtual_host> - whether to use virtual-hosted style request format. Default is 0 (path-style).
=back
Amazon-S3
view release on metacpan or search on metacpan
t/02-logger.t view on Meta::CPAN
sub test_all_levels {
########################################################################
my ($s3) = @_;
$s3->level('trace');
stderr_like( sub { test_levels($s3); },
qr/trace\n.*debug\n.*info\n.*warn\n.*error\n.*fatal\n/xsm, 'trace' );
$s3->level('debug');
stderr_like( sub { test_levels($s3); },
qr/debug\n.*info\n.*warn\n.*error\n.*fatal\n/xsm, 'debug' );
stderr_unlike( sub { test_levels($s3); },
qr/trace/, 'debug - not like trace' );
$s3->level('info');
stderr_like( sub { test_levels($s3); },
qr/info\n.*warn\n.*error\n.*fatal\n/xsm, 'info' );
stderr_unlike( sub { test_levels($s3); },
qr/trace|debug/, 'info - not like trace, debug' );
$s3->level('warn');
stderr_like( sub { test_levels($s3); },
qr/warn\n.*error\n.*fatal\n/xsm, 'warn' );
stderr_unlike( sub { test_levels($s3); },
qr/trace|debug|info/, 'warn - not like trace, debug, info' );
$s3->level('error');
stderr_like( sub { test_levels($s3); }, qr/error\n.*fatal\n/xsm, 'error' );
stderr_unlike( sub { test_levels($s3); },
qr/trace|debug|info|warn/, 'error - not like trace, debug, info, warn' );
$s3->level('fatal');
stderr_like( sub { test_levels($s3); }, qr/fatal\n/xsm, 'fatal' );
stderr_unlike(
sub { test_levels($s3); },
qr/trace|debug|info|warn|error/,
'fatal - not like trace, debug, info, warn, error'
);
Amazon-SQS-Client
view release on metacpan or search on metacpan
bin/QueueDaemon.pl view on Meta::CPAN
END_OF_LOGGER
Readonly::Scalar our $SCREEN_CONFIG => <<'END_OF_LOGGER';
log4perl.rootLogger=INFO, SCREEN
log4perl.appender.SCREEN=Log::Log4perl::Appender::Screen
log4perl.appender.SCREEN.stderr=%s
log4perl.appender.SCREEN.layout=PatternLayout
log4perl.appender.SCREEN.layout.ConversionPattern=%%d (%%r,%%R) (%%p/%%c) [%%P] [%%M:%%L] - %%m%%n
END_OF_LOGGER
our $KEEP_GOING = $TRUE;
bin/QueueDaemon.pl view on Meta::CPAN
my $service = $handler->get_service;
if ( $options{daemonize} ) {
my @dont_close_fh;
if ( $options{logfile} && $options{logfile} !~ /(?:stderr|stdout)/ixsm ) {
my $appender = Log::Log4perl->appender_by_name($APPENDER_NAME);
push @dont_close_fh, $appender->{fh};
}
push @dont_close_fh, 'STDERR';
bin/QueueDaemon.pl view on Meta::CPAN
warn => $WARN,
}->{ lc $loglevel };
$loglevel //= $INFO;
$logfile //= 'stderr';
my $log4perl_config;
if ( !$logfile || $logfile =~ /(?:stderr|stdout)/xsmi ) {
$log4perl_config = sprintf $SCREEN_CONFIG, $logfile eq 'stdout' ? 0 : 1;
$options->{logfile} = lc $logfile;
}
else {
$log4perl_config = sprintf $log4perl_config, $logfile;
bin/QueueDaemon.pl view on Meta::CPAN
my $config = Amazon::SQS::Config->new( file => $options->{config} );
$options->{loglevel} //= $config->get_log_level;
$options->{logfile} //= $config->get_log_file;
$options->{logfile} //= 'stderr';
$options->{'delete-when'} //= $config->get_error_delete;
$options->{'exit-when'} //= $config->get_error_exit;
Amon2-Plugin-LogDispatch
view release on metacpan or search on metacpan
lib/Amon2/Plugin/LogDispatch.pm view on Meta::CPAN
'Log::Dispatch' => {
outputs => [
[Screen::Color',
min_level => 'debug',
name => 'debug',
stderr => 1,
color => {
debug => {
text => 'green',
}
}
Amp-Client
view release on metacpan or search on metacpan
script/dash view on Meta::CPAN
"parents" => [],
"priority" => 0,
"queue" => "low",
"result" => {
"status" => "Completed successfully",
"stderr" => "",
"stdout" => "x is 1.\nGoodbye, World!\n"
},
"retried" => undef,
"retries" => 0,
"started" => "2021-05-03T14:45:33.66996Z",
Analizo
view release on metacpan or search on metacpan
t/features/step_definitions/analizo_steps.pl view on Meta::CPAN
use DBI;
use File::Spec;
our $exit_status;
our $stdout;
our $stderr;
use Env qw(@PATH $PWD);
push @PATH, "$PWD/blib/script", "$PWD/bin";
use IPC::Open3;
t/features/step_definitions/analizo_steps.pl view on Meta::CPAN
my $pid = open3($IN, $STDOUT, $STDERR, "$command 2>tmp.err");
waitpid $pid, 0;
$exit_status = $?;
local $/ = undef;
$stdout = <$STDOUT>;
$stderr = <$STDERR> . read_file('tmp.err');
};
When qr/^I run "([^\"]*)" on database "([^\"]*)"$/, sub {
my ($c) = @_;
my $statement = $1;
t/features/step_definitions/analizo_steps.pl view on Meta::CPAN
chdir $1;
};
Then qr/^analizo must emit a warning matching "([^\"]*)"$/, sub {
my ($c) = @_;
like($stderr, qr/$1|\Q$1\E/);
};
Then qr/^analizo must not emit a warning matching "([^\"]*)"$/, sub {
my ($c) = @_;
unlike($stderr, qr/$1|\Q$1\E/);
};
Then qr/^analizo must report that "([^\"]*)" is part of "([^\"]*)"$/, sub {
my ($c) = @_;
my ($func, $mod) = ($1, $2);
Anarres-Mud-Driver
view release on metacpan or search on metacpan
Compiler/lexer.c view on Meta::CPAN
#else
static void amd_yy_fatal_error( msg )
char msg[];
#endif
{
(void) fprintf( stderr, "%s\n", msg );
exit( YY_EXIT_FAILURE );
}
Compiler/lexer.c view on Meta::CPAN
void
amd_yywarnv(const char *fmt, va_list args)
{
char msg[BUFSIZ];
vsnprintf(msg, BUFSIZ, fmt, args);
fprintf(stderr, "%s", msg);
}
void
amd_yywarnf(const char *fmt, ...)
{
Compiler/lexer.c view on Meta::CPAN
SV **svp;
SV *sv;
SV **lvp;
#if 0
fprintf(stderr, "amd_yyidentifier: %s\n", amd_yytext);
fflush(stderr);
#endif
svp = hv_fetch(amd_kwtab, amd_yytext, amd_yyleng, FALSE);
if (svp) {
lvalp->number = 0;
Compiler/lexer.c view on Meta::CPAN
amd_yylex_verbose(AMD_YYSTYPE *amd_yylval, amd_parse_param_t *param)
{
int tok;
tok = amd_yylex(amd_yylval, param);
fprintf(stderr, "L: %d (%s) [%s]\n", tok, amd_yytokname(tok), amd_yytext);
return tok;
}
int
Ancient
view release on metacpan or search on metacpan
xs/const/ppport.h view on Meta::CPAN
PerlIOSelf|5.007001||Viu
PerlIO_set_cnt|5.007003|5.007003|
PerlIO_setlinebuf|5.007003|5.007003|
PerlIO_setpos|5.003007|5.003007|n
PerlIO_set_ptrcnt|5.007003|5.007003|
PerlIO_stderr|5.007003|5.007003|
PerlIO_stdin|5.007003|5.007003|
PerlIO_stdout|5.007003|5.007003|
PerlIO_stdoutf|5.006000|5.003007|
PERLIO_STDTEXT|5.007001||Viu
PerlIO_tell|5.007003|5.007003|
xs/const/ppport.h view on Meta::CPAN
PerlSIO_setbuf|5.007001||Viu
PerlSIO_set_cnt|5.007001||Viu
PerlSIO_setlinebuf|5.007001||Viu
PerlSIO_set_ptr|5.007001||Viu
PerlSIO_setvbuf|5.007001||Viu
PerlSIO_stderr|5.007001||Viu
PerlSIO_stdin|5.007001||Viu
PerlSIO_stdout|5.007001||Viu
PerlSIO_stdoutf|5.007001||Viu
PerlSIO_tmpfile|5.007001||Viu
PerlSIO_ungetc|5.007001||Viu
xs/const/ppport.h view on Meta::CPAN
PL_statgv|5.005000||Viu
PL_statname|5.005000||Viu
PL_statusvalue|5.005000||Viu
PL_statusvalue_posix|5.009003||Viu
PL_statusvalue_vms|5.005000||Viu
PL_stderrgv|5.006000||Viu
PL_stdingv|5.005000|5.003007|poVnu
PL_StdIO|5.006000||Viu
PL_strtab|5.005000||Viu
PL_strxfrm_is_behaved|5.025002||Viu
PL_strxfrm_max_cp|5.025002||Viu
xs/const/ppport.h view on Meta::CPAN
STATUS_NATIVE_CHILD_SET|5.009003||Viu
STATUS_UNIX|5.009003||Viu
STATUS_UNIX_EXIT_SET|5.009003||Viu
STATUS_UNIX_SET|5.009003||Viu
STDCHAR|5.003007|5.003007|Vn
stderr|5.003007||Viu
ST_DEV_SIGN|5.035004|5.035004|Vn
ST_DEV_SIZE|5.035004|5.035004|Vn
stdin|5.003007||Viu
STDIO_PTR_LVAL_SETS_CNT|5.007001|5.007001|Vn
STDIO_PTR_LVALUE|5.006000|5.006000|Vn
xs/const/ppport.h view on Meta::CPAN
with_tp_UTF8ness|5.033003||Viu
with_t_UTF8ness|5.035004||Viu
wrap_keyword_plugin|5.027006|5.027006|x
wrap_op_checker|5.015008|5.015008|
write|5.005000||Viu
write_to_stderr|5.008001||Viu
XCPT_CATCH|5.009002|5.003007|p
XCPT_RETHROW|5.009002|5.003007|p
XCPT_TRY_END|5.009002|5.003007|p
XCPT_TRY_START|5.009002|5.003007|p
XDIGIT_VALUE|5.019008||Viu
Android-ElectricSheep-Automator
view release on metacpan or search on metacpan
lib/Android/ElectricSheep/Automator.pm view on Meta::CPAN
}
@cmd = ('input', 'touchscreen', 'swipe', $x1, $y1, $x2, $y2, $dt);
}
# unfortunately Android::ADB uses IPC::Open2::open2() to run the adb shell command
# which does not capture STDERR, and so either they use open3 or we capture stderr thusly:
if( $verbosity > 0 ){ $log->info("${whoami} (via $parent), line ".__LINE__." : sending command to adb: @cmd") }
my $res = $self->adb->shell(@cmd);
if( ! defined $res ){ $log->error(join(" ", @cmd)."\n${whoami} (via $parent), line ".__LINE__." : error, above shell command has failed, got undefined result, most likely shell command did not run at all, this should not be happening."); return unde...
if( $res->[0] != 0 ){ $log->error(join(" ", @cmd)."\n${whoami} (via $parent), line ".__LINE__." : error, above shell command has failed, with:\nSTDOUT:\n".$res->[1]."\n\nSTDERR:\n".$res->[2]."\nEND."); return undef }
Android-Releases
view release on metacpan or search on metacpan
t/00-compile.t view on Meta::CPAN
my @warnings;
for my $lib (@module_files)
{
# see L<perlfaq8/How can I capture STDERR from an external command?>
my $stderr = IO::Handle->new;
diag('Running: ', join(', ', map { my $str = $_; $str =~ s/'/\\'/g; q{'} . $str . q{'} }
$^X, @switches, '-e', "require q[$lib]"))
if $ENV{PERL_COMPILE_TEST_DEBUG};
my $pid = open3($stdin, '>&STDERR', $stderr, $^X, @switches, '-e', "require q[$lib]");
binmode $stderr, ':crlf' if $^O eq 'MSWin32';
my @_warnings = <$stderr>;
waitpid($pid, 0);
is($?, 0, "$lib loaded ok");
shift @_warnings if @_warnings and $_warnings[0] =~ /^Using .*\bblib/
and not eval { require blib; blib->VERSION('1.01') };
Anego
view release on metacpan or search on metacpan
spew($config_file, $config);
subtest 'status subcommand' => sub {
$Anego::Config::CONFIG = undef;
my ($stdout, $stderr) = capture {
Anego::CLI::Status->run();
};
like $stdout, qr!RDBMS:\s+SQLite!;
like $stdout, qr!Database:\s+:memory:!;
subtest 'diff / migrate subcommand (latest)' => sub {
$Anego::Config::CONFIG = undef;
subtest 'diff (1)' => sub {
my ($stdout, $stderr) = capture {
Anego::CLI::Diff->run();
};
is $stdout, <<__DDL__;
COMMIT;
__DDL__
is $stderr, '';
};
subtest 'migrate (1)' => sub {
my ($stdout, $stderr) = capture {
Anego::CLI::Migrate->run();
};
is $stdout, "Migrated\n";
is $stderr, '';
};
subtest 'diff (2)' => sub {
my ($stdout, $stderr) = capture {
Anego::CLI::Diff->run();
};
is $stdout, '';
is $stderr, "target schema == database schema, should no differences\n";
};
subtest 'migrate (2)' => sub {
my ($stdout, $stderr) = capture {
Anego::CLI::Migrate->run();
};
is $stdout, '';
is $stderr, "target schema == database schema, should no differences\n";
};
};
subtest 'diff / migrate subcommand (revision)' => sub {
$Anego::Config::CONFIG = undef;
subtest 'diff (1)' => sub {
my ($stdout, $stderr) = capture {
Anego::CLI::Diff->run(qw/ revision HEAD^ /);
};
is $stdout, <<__DDL__;
COMMIT;
__DDL__
is $stderr, '';
};
subtest 'migrate (1)' => sub {
my ($stdout, $stderr) = capture {
Anego::CLI::Migrate->run(qw/ revision HEAD^ /);
};
is $stdout, "Migrated\n";
is $stderr, '';
};
subtest 'diff (2)' => sub {
my ($stdout, $stderr) = capture {
Anego::CLI::Diff->run(qw/ revision HEAD^ /);
};
is $stdout, '';
is $stderr, "target schema == database schema, should no differences\n";
};
subtest 'migrate (2)' => sub {
my ($stdout, $stderr) = capture {
Anego::CLI::Migrate->run(qw/ revision HEAD^ /);
};
is $stdout, '';
is $stderr, "target schema == database schema, should no differences\n";
};
};
sub spew {
my ($path, $content) = @_;
Anki-Import
view release on metacpan or search on metacpan
plan tests => $tests;
my $cmd = File::Spec->catfile('bin', 'anki_import');
$cmd =~ s/\\/\\\\/;
stderr_like { `$^X $cmd` } qr/usage: anki_import FILE/, 'dies without file';
$cmd = File::Spec->catfile('bin', 'anki_import');
$cmd =~ s/\\/\\\\/;
stderr_like { `$^X $cmd blasdfah` } qr/[FATAL].*does not exist/, 'dies with bad file';
$cmd = File::Spec->catfile('bin', 'anki_import');
$cmd =~ s/\\/\\\\/;
my $path = File::Spec->catfile('t', 'data' , 'source.anki');
lives_ok { `$^X $cmd $path` } 'can process good file';
Ansible-Util
view release on metacpan or search on metacpan
lib/Ansible/Util/Run.pm view on Meta::CPAN
version 0.001
=head1 SYNOPSIS
$run = Ansible::Util::Run->new;
( $stdout, $stderr, $exit ) = $run->ansiblePlaybook(playbook => $playbook);
$run = Ansible::Util::Run->new(
vaultPasswordFiles => ['secret1', 'secret2']
);
( $stdout, $stderr, $exit ) = $run->ansiblePlaybook(playbook => $playbook);
=head1 DESCRIPTION
A thin wrapper around the Ansible CLI tools.
lib/Ansible/Util/Run.pm view on Meta::CPAN
Invokes the ansible-playbook command with the specified args.
=head3 usage:
($stdout, $stderr, $exit) =
$run->ansiblePlaybook(playbook => $file,
[extraArgs => $aref],
[confessOnError => $bool],
[wantArrayRefs => $bool]);
=head3 returns:
An array containing the stdout, stderr, and exit status from the
ansible-playbook command.
=head3 args:
=over
lib/Ansible/Util/Run.pm view on Meta::CPAN
=over
=item confessOnError
If the command exits with an error, the call will simply confess with the
output from stderr.
=over
=item type: Bool
lib/Ansible/Util/Run.pm view on Meta::CPAN
=over
=item wantArrayRefs
The stdout and stderr are returned as array refs split across newlines.
=over
=item type: Bool
lib/Ansible/Util/Run.pm view on Meta::CPAN
push @cmd, @$extraArgs if $extraArgs;
push @cmd, $playbook if $playbook;
$self->Spawn->confessOnError($confessOnError);
my ( $stdout, $stderr, $exit ) =
$self->Spawn->capture( cmd => \@cmd, wantArrayRefs => $wantArrayRefs);
return ( $stdout, $stderr, $exit );
}
##############################################################################
# PRIVATE METHODS
##############################################################################
AntTweakBar
view release on metacpan or search on metacpan
src/ppport.h view on Meta::CPAN
PerlIO_read||5.007003|
PerlIO_seek||5.007003|
PerlIO_set_cnt||5.007003|
PerlIO_set_ptrcnt||5.007003|
PerlIO_setlinebuf||5.007003|
PerlIO_stderr||5.007003|
PerlIO_stdin||5.007003|
PerlIO_stdout||5.007003|
PerlIO_tell||5.007003|
PerlIO_unread||5.007003|
PerlIO_write||5.007003|
src/ppport.h view on Meta::CPAN
whichsig_sv||5.015004|
whichsig|||
win32_croak_not_implemented|||n
with_queued_errors|||
wrap_op_checker||5.015008|
write_to_stderr|||
xmldump_all_perl|||
xmldump_all|||
xmldump_attr|||
xmldump_eval|||
xmldump_form|||
Any-Daemon-HTTP
view release on metacpan or search on metacpan
lib/Any/Daemon/FCGI/ClientConn.pm view on Meta::CPAN
$request;
}
sub send_response($;$)
{ my ($self, $response, $stderr) = @_;
#XXX Net::Async::FastCGI::Request demonstrates how to catch stdout and
#XXX stderr via ties. We don't use that here: cleanly work with
#XXX HTTP::Message objects... errors are logged locally.
my $req_id = $response->request->request_id;
# Simply "Status: " in front of the Response header will make the whole
# message HTTP::Response into a valid CGI response.
$self->_reply_record(STDOUT => $req_id
, 'Status: '.$response->as_string(CRLF));
$self->_reply_record(STDOUT => $req_id, '');
if($stderr && length $$stderr)
{ $self->_reply_record(STDERR => $req_id, $$stderr);
$self->_reply_record(STDERR => $req_id, '');
}
$self->_fcgi_end_request(REQUEST_COMPLETE => $req_id);
Any-Moose
view release on metacpan or search on metacpan
xt/author/00-compile.t view on Meta::CPAN
my @warnings;
for my $lib (@module_files)
{
# see L<perlfaq8/How can I capture STDERR from an external command?>
my $stderr = IO::Handle->new;
diag('Running: ', join(', ', map { my $str = $_; $str =~ s/'/\\'/g; q{'} . $str . q{'} }
$^X, @switches, '-e', "require q[$lib]"))
if $ENV{PERL_COMPILE_TEST_DEBUG};
my $pid = open3($stdin, '>&STDERR', $stderr, $^X, @switches, '-e', "require q[$lib]");
binmode $stderr, ':crlf' if $^O eq 'MSWin32';
my @_warnings = <$stderr>;
waitpid($pid, 0);
is($?, 0, "$lib loaded ok");
shift @_warnings if @_warnings and $_warnings[0] =~ /^Using .*\bblib/
and not eval { require blib; blib->VERSION('1.01') };
AnyEvent
view release on metacpan or search on metacpan
lib/AnyEvent.pm view on Meta::CPAN
certain features.
=item C<PERL_ANYEVENT_LOG>
Accepts rather complex logging specifications. For example, you could log
all C<debug> messages of some module to stderr, warnings and above to
stderr, and errors and above to syslog, with:
PERL_ANYEVENT_LOG=Some::Module=debug,+log:filter=warn,+%syslog:%syslog=error,syslog
For the rather extensive details, see L<AnyEvent::Log>.
( run in 1.605 second using v1.01-cache-2.11-cpan-5c0b1e786e0 )