#
# t/test.pl - from CORE
sub _where {
my @caller = caller($Level);
return "at $caller[1] line $caller[2]";
}
# runperl - Runs a separate perl interpreter.
# Arguments :
# switches => [ command-line switches ]
# nolib => 1 # don't use -I../lib (included by default)
# prog => one-liner (avoid quotes)
# progs => [ multi-liner (avoid quotes) ]
# progfile => perl script
# stdin => string to feed the stdin
# stderr => redirect stderr to stdout
# args => [ command-line arguments to the perl program ]
# verbose => print the command line
my $is_mswin = $^O eq 'MSWin32';
my $is_netware = $^O eq 'NetWare';
my $is_macos = $^O eq 'MacOS';
my $is_vms = $^O eq 'VMS';
my $is_cygwin = $^O eq 'cygwin';
sub _quote_args {
my ($runperl, $args) = @_;
foreach (@$args) {
# In VMS protect with doublequotes because otherwise
# DCL will lowercase -- unless already doublequoted.
$_ = q(").$_.q(") if $is_vms && !/^\"/ && length($_) > 0;
$$runperl .= ' ' . $_;
}
}
sub _create_runperl { # Create the string to qx in runperl().
my %args = @_;
my $runperl = $^X =~ m/\s/ ? qq{"$^X"} : $^X;
#- this allows, for example, to set PERL_RUNPERL_DEBUG=/usr/bin/valgrind
if ($ENV{PERL_RUNPERL_DEBUG}) {
$runperl = "$ENV{PERL_RUNPERL_DEBUG} $runperl";
}
unless ($args{nolib}) {
if ($is_macos) {
$runperl .= ' -I::lib';
# Use UNIX style error messages instead of MPW style.
$runperl .= ' -MMac::err=unix' if $args{stderr};
}
else {
$runperl .= ' "-I../lib"'; # doublequotes because of VMS
}
}
if ($args{switches}) {
local $Level = 2;
die "test.pl:runperl(): 'switches' must be an ARRAYREF " . _where()
unless ref $args{switches} eq "ARRAY";
_quote_args(\$runperl, $args{switches});
}
if (defined $args{prog}) {
die "test.pl:runperl(): both 'prog' and 'progs' cannot be used " . _where()
if defined $args{progs};
$args{progs} = [$args{prog}]
}
if (defined $args{progs}) {
die "test.pl:runperl(): 'progs' must be an ARRAYREF " . _where()
unless ref $args{progs} eq "ARRAY";
foreach my $prog (@{$args{progs}}) {
if ($is_mswin || $is_netware || $is_vms) {
$runperl .= qq ( -e "$prog" );
}
else {
$runperl .= qq ( -e '$prog' );
}
}
} elsif (defined $args{progfile}) {
$runperl .= qq( "$args{progfile}");
} else {
# You probaby didn't want to be sucking in from the upstream stdin
die "test.pl:runperl(): none of prog, progs, progfile, args, "
. " switches or stdin specified"
unless defined $args{args} or defined $args{switches}
or defined $args{stdin};
}
if (defined $args{stdin}) {
# so we don't try to put literal newlines and crs onto the
# command line.
$args{stdin} =~ s/\n/\\n/g;
$args{stdin} =~ s/\r/\\r/g;
if ($is_mswin || $is_netware || $is_vms) {
$runperl = qq{$^X -e "print qq(} .
$args{stdin} . q{)" | } . $runperl;
}
elsif ($is_macos) {
# MacOS can only do two processes under MPW at once;
# the test itself is one; we can't do two more, so
# write to temp file
my $stdin = qq{$^X -e 'print qq(} . $args{stdin} . qq{)' > teststdin; };
if ($args{verbose}) {
my $stdindisplay = $stdin;
$stdindisplay =~ s/\n/\n\#/g;
print STDERR "# $stdindisplay\n";
}
`$stdin`;
$runperl .= q{ < teststdin };
}
else {
$runperl = qq{$^X -e 'print qq(} .
$args{stdin} . q{)' | } . $runperl;
}
}
if (defined $args{args}) {
_quote_args(\$runperl, $args{args});
}
$runperl .= ' 2>&1' if $args{stderr} && !$is_mswin && !$is_macos;
$runperl .= " \xB3 Dev:Null" if !$args{stderr} && $is_macos;
if ($args{verbose}) {
my $runperldisplay = $runperl;
$runperldisplay =~ s/\n/\n\#/g;
print STDERR "# $runperldisplay\n";
}
return $runperl;
}
sub runperl {
die "test.pl:runperl() does not take a hashref"
if ref $_[0] and ref $_[0] eq 'HASH';
my $runperl = &_create_runperl;
# ${^TAINT} is invalid in perl5.00505
my $tainted;
eval '$tainted = ${^TAINT};' if $] >= 5.006;
my %args = @_;
exists $args{switches} && grep m/^-T$/, @{$args{switches}} and $tainted = $tainted + 1;
if ($tainted) {
# We will assume that if you're running under -T, you really mean to
# run a fresh perl, so we'll brute force launder everything for you
my $sep;
eval "require Config; Config->import";
if ($@) {
warn "test.pl had problems loading Config: $@";
$sep = ':';
} else {
$sep = $Config{path_sep};
}
my @keys = grep {exists $ENV{$_}} qw(CDPATH IFS ENV BASH_ENV);
local @ENV{@keys} = ();
# Untaint, plus take out . and empty string:
local $ENV{'DCL$PATH'} = $1 if $is_vms && ($ENV{'DCL$PATH'} =~ /(.*)/s);
$ENV{PATH} =~ /(.*)/s;
local $ENV{PATH} =
join $sep, grep { $_ ne "" and $_ ne "." and -d $_ and
($is_mswin or $is_vms or !(stat && (stat _)[2]&0022)) }
split quotemeta ($sep), $1;
$ENV{PATH} .= "$sep/bin" if $is_cygwin; # Must have /bin under Cygwin
$runperl =~ /(.*)/s;
$runperl = $1;
my ($err,$result,$stderr) = run_cmd($runperl, $args{timeout});
$result =~ s/\n\n/\n/ if $is_vms; # XXX pipes sometimes double these
return $result;
} else {
my ($err,$result,$stderr) = run_cmd($runperl, $args{timeout});
$result =~ s/\n\n/\n/ if $is_vms; # XXX pipes sometimes double these
return $result;
}
}
*run_perl = \&runperl; # Nice alias.
sub DIE {
print STDERR "# @_\n";
exit 1;
}
# A somewhat safer version of the sometimes wrong $^X.
my $Perl;
sub which_perl {
unless (defined $Perl) {
$Perl = $^X;
# VMS should have 'perl' aliased properly
return $Perl if $^O eq 'VMS';
my $exe;
eval "require Config; Config->import";
if ($@) {
warn "test.pl had problems loading Config: $@";
$exe = '';
} else {
$exe = $Config{exe_ext};
}
$exe = '' unless defined $exe;
# This doesn't absolutize the path: beware of future chdirs().
# We could do File::Spec->abs2rel() but that does getcwd()s,
# which is a bit heavyweight to do here.
if ($Perl =~ /^perl\Q$exe\E$/i) {
my $perl = "perl$exe";
eval "require File::Spec";
if ($@) {
warn "test.pl had problems loading File::Spec: $@";
$Perl = "./$perl";
} else {
$Perl = File::Spec->catfile(File::Spec->curdir(), $perl);
}
}
# Build up the name of the executable file from the name of
# the command.
if ($Perl !~ /\Q$exe\E$/i) {
$Perl .= $exe;
}
warn "which_perl: cannot find $Perl from $^X" unless -f $Perl;
# For subcommands to use.
$ENV{PERLEXE} = $Perl;
}
return $Perl;
}
sub unlink_all {
foreach my $file (@_) {
1 while unlink $file;
print STDERR "# Couldn't unlink '$file': $!\n" if -f $file;
}
}
my $tmpfile = "misctmp000";
1 while -f ++$tmpfile;
END { unlink_all $tmpfile }
#
# _fresh_perl
#
# The $resolve must be a subref that tests the first argument
# for success, or returns the definition of success (e.g. the
# expected scalar) if given no arguments.
#
sub _fresh_perl {
my($prog, $resolve, $runperl_args, $name) = @_;
$runperl_args ||= {};
$runperl_args->{progfile} = $tmpfile;
$runperl_args->{stderr} = 1;
open TEST, ">$tmpfile" or die "Cannot open $tmpfile: $!";
# VMS adjustments
if( $^O eq 'VMS' ) {
$prog =~ s#/dev/null#NL:#;
# VMS file locking
$prog =~ s{if \(-e _ and -f _ and -r _\)}
{if (-e _ and -f _)}
}
print TEST $prog;
close TEST or die "Cannot close $tmpfile: $!";
my $results = runperl(%$runperl_args);
my $status = $?;
# Clean up the results into something a bit more predictable.
$results =~ s/\n+$//;
$results =~ s/at\s+misctmp\d+\s+line/at - line/g;
$results =~ s/of\s+misctmp\d+\s+aborted/of - aborted/g;
# bison says 'parse error' instead of 'syntax error',
# various yaccs may or may not capitalize 'syntax'.
$results =~ s/^(syntax|parse) error/syntax error/mig;
if ($^O eq 'VMS') {
# some tests will trigger VMS messages that won't be expected
$results =~ s/\n?%[A-Z]+-[SIWEF]-[A-Z]+,.*//;
# pipes double these sometimes
$results =~ s/\n\n/\n/g;
}
my $pass = $resolve->($results);
unless ($pass) {
print STDERR "# PROG: \n$prog\n";
print STDERR "# EXPECTED:\n", $resolve->(), "\n";
print STDERR "# GOT:\n$results\n";
print STDERR "# STATUS: $status\n";
}
# Use the first line of the program as a name if none was given
unless( $name ) {
($first_line, $name) = $prog =~ /^((.{1,50}).*)/;
$name .= '...' if length $first_line > length $name;
}
ok($pass, "fresh_perl - $name");
}
#
# fresh_perl_is
#
# Combination of run_perl() and is().
#
sub fresh_perl_is {
my($prog, $expected, $runperl_args, $name) = @_;
local $Level = 2;
_fresh_perl($prog,
sub { @_ ? $_[0] eq $expected : $expected },
$runperl_args, $name);
}
#
# fresh_perl_like
#
# Combination of run_perl() and like().
#
sub fresh_perl_like {
my($prog, $expected, $runperl_args, $name) = @_;
local $Level = 2;
_fresh_perl($prog,
sub { @_ ?
$_[0] =~ (ref $expected ? $expected : /$expected/) :
$expected },
$runperl_args, $name);
}
1;
# Local Variables:
# mode: cperl
# cperl-indent-level: 4
# fill-column: 78
# End:
# vim: expandtab shiftwidth=4: