This is code that is directly responsible for running a single test.
This will eventually run in a separate process as part of the parallel
testing project.
Ref: #10818
processhelp.pm ftpserver.pl getpart.pm globalconfig.pm http-server.pl http2-server.pl \
http3-server.pl manpage-scan.pl manpage-syntax.pl markdown-uppercase.pl mem-include-scan.pl \
memanalyze.pl negtelnetserver.py nroff-scan.pl option-check.pl options-scan.pl \
- pathhelp.pm README.md rtspserver.pl runtests.1 runtests.pl secureserver.pl \
+ pathhelp.pm README.md rtspserver.pl runner.pm runtests.1 runtests.pl secureserver.pl \
serverhelp.pm servers.pm smbserver.py sshhelp.pm sshserver.pl stunnel.pem symbol-scan.pl \
testcurl.1 testcurl.pl tftpserver.pl util.py valgrind.pm valgrind.supp version-scan.pl
our @EXPORT = qw(
$CURL
$FTPDCMD
+ $LIBDIR
$LOGDIR
$perl
$PIDDIR
+ $SERVERIN
+ $SERVER2IN
+ $PROXYIN
+ $TESTDIR
+ $memdump
$proxy_address
+ $listonly
+ $run_event_based
$srcdir
$torture
$VCURL
$verbose
+ $memanalyze
@protocols
+ $anyway
+ %feature
+ $has_shared
+ %timesrvrini
+ %timesrvrend
+ %timetoolini
+ %timetoolend
+ %timesrvrlog
+ %timevrfyend
+ $valgrind
+ %keywords
+ $automakestyle
);
}
use pathhelp qw(exe_ext);
#
# config variables overridden by command-line options
-our $verbose; # 1 to show verbose test output
-our $torture; # 1 to enable torture testing
-our $proxy_address; # external HTTP proxy address
+our $verbose; # 1 to show verbose test output
+our $torture; # 1 to enable torture testing
+our $proxy_address; # external HTTP proxy address
+our $listonly; # only list the tests
+our $run_event_based; # run curl with --test-event to test the event API
+our $automakestyle; # use automake-like test status output format
+our $anyway; # continue anyway, even if a test fail
# paths
our $srcdir = $ENV{'srcdir'} || '.'; # root of the test source code
our $perl="perl -I$srcdir"; # invoke perl like this
our $LOGDIR="log"; # root of the log directory
+# TODO: $LOGDIR could eventually change later on, so must regenerate all the
+# paths depending on it after $LOGDIR itself changes.
our $PIDDIR = "$LOGDIR/server"; # root of the server directory with PID files
-our $FTPDCMD="$LOGDIR/ftpserver.cmd"; # copy server instructions here
+# TODO: change this to use server_inputfilename()
+our $SERVERIN="$LOGDIR/server.input"; # what curl sent the server
+our $SERVER2IN="$LOGDIR/server2.input"; # what curl sent the second server
+our $PROXYIN="$LOGDIR/proxy.input"; # what curl sent the proxy
+our $memdump="$LOGDIR/memdump"; # file that the memory debugging creates
+our $FTPDCMD="$LOGDIR/ftpserver.cmd"; # copy server instructions here
+our $LIBDIR="./libtest";
+our $TESTDIR="$srcdir/data";
our $CURL="../src/curl".exe_ext('TOOL'); # what curl binary to run on the tests
our $VCURL=$CURL; # what curl binary to use to verify the servers with
# VCURL is handy to set to the system one when the one you
# just built hangs or crashes and thus prevent verification
+# the path to the script that analyzes the memory debug output file
+our $memanalyze="$perl $srcdir/memanalyze.pl";
+our $valgrind; # path to valgrind, or empty if disabled
# other config variables
-our @protocols; # array of lowercase supported protocol servers
+our @protocols; # array of lowercase supported protocol servers
+our %feature; # hash of enabled features
+our $has_shared; # built as a shared library
+our %keywords; # hash of keywords from the test spec
+our %timesrvrini; # timestamp for each test required servers verification start
+our %timesrvrend; # timestamp for each test required servers verification end
+our %timetoolini; # timestamp for each test command run starting
+our %timetoolend; # timestamp for each test command run stopping
+our %timesrvrlog; # timestamp for each test server logs lock removal
+our %timevrfyend; # timestamp for each test result verification end
1;
--- /dev/null
+#***************************************************************************
+# _ _ ____ _
+# Project ___| | | | _ \| |
+# / __| | | | |_) | |
+# | (__| |_| | _ <| |___
+# \___|\___/|_| \_\_____|
+#
+# Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
+#
+# This software is licensed as described in the file COPYING, which
+# you should have received as part of this distribution. The terms
+# are also available at https://curl.se/docs/copyright.html.
+#
+# You may opt to use, copy, modify, merge, publish, distribute and/or sell
+# copies of the Software, and permit persons to whom the Software is
+# furnished to do so, under the terms of the COPYING file.
+#
+# This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+# KIND, either express or implied.
+#
+# SPDX-License-Identifier: curl
+#
+###########################################################################
+
+# This module contains entry points to run a single test
+
+package runner;
+
+use strict;
+use warnings;
+
+BEGIN {
+ use base qw(Exporter);
+
+ our @EXPORT = qw(
+ restore_test_env
+ runner_test_preprocess
+ runner_test_run
+ use_valgrind
+ checktestcmd
+ $DBGCURL
+ $gdbthis
+ $gdbxwin
+ $shallow
+ $tortalloc
+ $valgrind_logfile
+ $valgrind_tool
+ $gdb
+ );
+}
+
+use pathhelp qw(
+ exe_ext
+ );
+use processhelp qw(
+ portable_sleep
+ );
+
+use servers;
+use getpart;
+use globalconfig;
+
+
+#######################################################################
+# Global variables set elsewhere but used only by this package
+our $DBGCURL=$CURL; #"../src/.libs/curl"; # alternative for debugging
+our $valgrind_logfile="--logfile"; # the option name for valgrind 2.X
+our $valgrind_tool;
+our $gdb = checktestcmd("gdb");
+our $gdbthis; # run test case with gdb debugger
+our $gdbxwin; # use windowed gdb when using gdb
+
+# torture test variables
+our $shallow;
+our $tortalloc;
+
+# local variables
+my %oldenv; # environment variables before test is started
+my $UNITDIR="./unit";
+my $CURLLOG="$LOGDIR/commands.log"; # all command lines run
+my $SERVERLOGS_LOCK="$LOGDIR/serverlogs.lock"; # server logs advisor read lock
+my $defserverlogslocktimeout = 2; # timeout to await server logs lock removal
+my $defpostcommanddelay = 0; # delay between command and postcheck sections
+
+
+#######################################################################
+# Log an informational message
+# This just calls main's logmsg for now.
+sub logmsg {
+ return main::logmsg(@_);
+}
+
+#######################################################################
+# Call main's displaylogs
+# TODO: this will eventually stop being called in this package
+sub displaylogs{
+ return main::displaylogs(@_);
+}
+
+#######################################################################
+# Call main's prepro
+# TODO: figure out where this should live; since it needs to know
+# things in main:: only, maybe the test file should be preprocessed there
+sub prepro {
+ return main::prepro(@_);
+}
+
+#######################################################################
+# Call main's timestampskippedevents
+# TODO: figure out where this should live
+sub timestampskippedevents {
+ return main::timestampskippedevents(@_);
+}
+
+#######################################################################
+# Call main's runclient
+# TODO: move this into a helper package
+sub runclient {
+ return main::runclient(@_);
+}
+
+#######################################################################
+# Check for a command in the PATH of the machine running curl.
+#
+sub checktestcmd {
+ my ($cmd)=@_;
+ my @testpaths=("$LIBDIR/.libs", "$LIBDIR");
+ return checkcmd($cmd, @testpaths);
+}
+
+# See if Valgrind should actually be used
+sub use_valgrind {
+ if($valgrind) {
+ my @valgrindoption = getpart("verify", "valgrind");
+ if((!@valgrindoption) || ($valgrindoption[0] !~ /disable/)) {
+ return 1;
+ }
+ }
+ return 0;
+}
+
+# Massage the command result code into a useful form
+sub normalize_cmdres {
+ my $cmdres = $_[0];
+ my $signal_num = $cmdres & 127;
+ my $dumped_core = $cmdres & 128;
+
+ if(!$anyway && ($signal_num || $dumped_core)) {
+ $cmdres = 1000;
+ }
+ else {
+ $cmdres >>= 8;
+ $cmdres = (2000 + $signal_num) if($signal_num && !$cmdres);
+ }
+ return ($cmdres, $dumped_core);
+}
+
+#######################################################################
+# Memory allocation test and failure torture testing.
+#
+sub torture {
+ my ($testcmd, $testnum, $gdbline) = @_;
+
+ # remove memdump first to be sure we get a new nice and clean one
+ unlink($memdump);
+
+ # First get URL from test server, ignore the output/result
+ runclient($testcmd);
+
+ logmsg " CMD: $testcmd\n" if($verbose);
+
+ # memanalyze -v is our friend, get the number of allocations made
+ my $count=0;
+ my @out = `$memanalyze -v $memdump`;
+ for(@out) {
+ if(/^Operations: (\d+)/) {
+ $count = $1;
+ last;
+ }
+ }
+ if(!$count) {
+ logmsg " found no functions to make fail\n";
+ return 0;
+ }
+
+ my @ttests = (1 .. $count);
+ if($shallow && ($shallow < $count)) {
+ my $discard = scalar(@ttests) - $shallow;
+ my $percent = sprintf("%.2f%%", $shallow * 100 / scalar(@ttests));
+ logmsg " $count functions found, but only fail $shallow ($percent)\n";
+ while($discard) {
+ my $rm;
+ do {
+ # find a test to discard
+ $rm = rand(scalar(@ttests));
+ } while(!$ttests[$rm]);
+ $ttests[$rm] = undef;
+ $discard--;
+ }
+ }
+ else {
+ logmsg " $count functions to make fail\n";
+ }
+
+ for (@ttests) {
+ my $limit = $_;
+ my $fail;
+ my $dumped_core;
+
+ if(!defined($limit)) {
+ # --shallow can undefine them
+ next;
+ }
+ if($tortalloc && ($tortalloc != $limit)) {
+ next;
+ }
+
+ if($verbose) {
+ my ($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) =
+ localtime(time());
+ my $now = sprintf("%02d:%02d:%02d ", $hour, $min, $sec);
+ logmsg "Fail function no: $limit at $now\r";
+ }
+
+ # make the memory allocation function number $limit return failure
+ $ENV{'CURL_MEMLIMIT'} = $limit;
+
+ # remove memdump first to be sure we get a new nice and clean one
+ unlink($memdump);
+
+ my $cmd = $testcmd;
+ if($valgrind && !$gdbthis) {
+ my @valgrindoption = getpart("verify", "valgrind");
+ if((!@valgrindoption) || ($valgrindoption[0] !~ /disable/)) {
+ my $valgrindcmd = "$valgrind ";
+ $valgrindcmd .= "$valgrind_tool " if($valgrind_tool);
+ $valgrindcmd .= "--quiet --leak-check=yes ";
+ $valgrindcmd .= "--suppressions=$srcdir/valgrind.supp ";
+ # $valgrindcmd .= "--gen-suppressions=all ";
+ $valgrindcmd .= "--num-callers=16 ";
+ $valgrindcmd .= "${valgrind_logfile}=$LOGDIR/valgrind$testnum";
+ $cmd = "$valgrindcmd $testcmd";
+ }
+ }
+ logmsg "*** Function number $limit is now set to fail ***\n" if($gdbthis);
+
+ my $ret = 0;
+ if($gdbthis) {
+ runclient($gdbline);
+ }
+ else {
+ $ret = runclient($cmd);
+ }
+ #logmsg "$_ Returned " . ($ret >> 8) . "\n";
+
+ # Now clear the variable again
+ delete $ENV{'CURL_MEMLIMIT'} if($ENV{'CURL_MEMLIMIT'});
+
+ if(-r "core") {
+ # there's core file present now!
+ logmsg " core dumped\n";
+ $dumped_core = 1;
+ $fail = 2;
+ }
+
+ if($valgrind) {
+ my @e = valgrindparse("$LOGDIR/valgrind$testnum");
+ if(@e && $e[0]) {
+ if($automakestyle) {
+ logmsg "FAIL: torture $testnum - valgrind\n";
+ }
+ else {
+ logmsg " valgrind ERROR ";
+ logmsg @e;
+ }
+ $fail = 1;
+ }
+ }
+
+ # verify that it returns a proper error code, doesn't leak memory
+ # and doesn't core dump
+ if(($ret & 255) || ($ret >> 8) >= 128) {
+ logmsg " system() returned $ret\n";
+ $fail=1;
+ }
+ else {
+ my @memdata=`$memanalyze $memdump`;
+ my $leak=0;
+ for(@memdata) {
+ if($_ ne "") {
+ # well it could be other memory problems as well, but
+ # we call it leak for short here
+ $leak=1;
+ }
+ }
+ if($leak) {
+ logmsg "** MEMORY FAILURE\n";
+ logmsg @memdata;
+ logmsg `$memanalyze -l $memdump`;
+ $fail = 1;
+ }
+ }
+ if($fail) {
+ logmsg " Failed on function number $limit in test.\n",
+ " invoke with \"-t$limit\" to repeat this single case.\n";
+ stopservers($verbose);
+ return 1;
+ }
+ }
+
+ logmsg "torture OK\n";
+ return 0;
+}
+
+
+# restore environment variables that were modified in test
+sub restore_test_env {
+ my $deleteoldenv = $_[0]; # 1 to delete the saved contents after restore
+ foreach my $var (keys %oldenv) {
+ if($oldenv{$var} eq 'notset') {
+ delete $ENV{$var} if($ENV{$var});
+ }
+ else {
+ $ENV{$var} = $oldenv{$var};
+ }
+ if($deleteoldenv) {
+ delete $oldenv{$var};
+ }
+ }
+}
+
+
+#######################################################################
+# Start the servers needed to run this test case
+sub singletest_startservers {
+ my ($testnum) = @_;
+
+ # remove test server commands file before servers are started/verified
+ unlink($FTPDCMD) if(-f $FTPDCMD);
+
+ # timestamp required servers verification start
+ $timesrvrini{$testnum} = Time::HiRes::time();
+
+ my $why;
+ if (!$listonly) {
+ my @what = getpart("client", "server");
+ if(!$what[0]) {
+ warn "Test case $testnum has no server(s) specified";
+ $why = "no server specified";
+ } else {
+ my $err;
+ ($why, $err) = serverfortest(@what);
+ if($err == 1) {
+ # Error indicates an actual problem starting the server, so
+ # display the server logs
+ displaylogs($testnum);
+ }
+ }
+ }
+
+ # timestamp required servers verification end
+ $timesrvrend{$testnum} = Time::HiRes::time();
+
+ # remove server output logfile after servers are started/verified
+ unlink($SERVERIN);
+ unlink($SERVER2IN);
+ unlink($PROXYIN);
+
+ return $why;
+}
+
+
+#######################################################################
+# Generate preprocessed test file
+sub singletest_preprocess {
+ my $testnum = $_[0];
+
+ # Save a preprocessed version of the entire test file. This allows more
+ # "basic" test case readers to enjoy variable replacements.
+ my @entiretest = fulltest();
+ my $otest = "$LOGDIR/test$testnum";
+
+ @entiretest = prepro($testnum, @entiretest);
+
+ # save the new version
+ open(my $fulltesth, ">", "$otest") || die "Failure writing test file";
+ foreach my $bytes (@entiretest) {
+ print $fulltesth pack('a*', $bytes) or die "Failed to print '$bytes': $!";
+ }
+ close($fulltesth) || die "Failure writing test file";
+
+ # in case the process changed the file, reload it
+ loadtest("$LOGDIR/test${testnum}");
+}
+
+
+#######################################################################
+# Set up the test environment to run this test case
+sub singletest_setenv {
+ my @setenv = getpart("client", "setenv");
+ foreach my $s (@setenv) {
+ chomp $s;
+ if($s =~ /([^=]*)=(.*)/) {
+ my ($var, $content) = ($1, $2);
+ # remember current setting, to restore it once test runs
+ $oldenv{$var} = ($ENV{$var})?"$ENV{$var}":'notset';
+ # set new value
+ if(!$content) {
+ delete $ENV{$var} if($ENV{$var});
+ }
+ else {
+ if($var =~ /^LD_PRELOAD/) {
+ if(exe_ext('TOOL') && (exe_ext('TOOL') eq '.exe')) {
+ # print "Skipping LD_PRELOAD due to lack of OS support\n";
+ next;
+ }
+ if($feature{"debug"} || !$has_shared) {
+ # print "Skipping LD_PRELOAD due to no release shared build\n";
+ next;
+ }
+ }
+ $ENV{$var} = "$content";
+ print "setenv $var = $content\n" if($verbose);
+ }
+ }
+ }
+ if($proxy_address) {
+ $ENV{http_proxy} = $proxy_address;
+ $ENV{HTTPS_PROXY} = $proxy_address;
+ }
+}
+
+
+#######################################################################
+# Check that test environment is fine to run this test case
+sub singletest_precheck {
+ my $testnum = $_[0];
+ my $why;
+ my @precheck = getpart("client", "precheck");
+ if(@precheck) {
+ my $cmd = $precheck[0];
+ chomp $cmd;
+ if($cmd) {
+ my @p = split(/ /, $cmd);
+ if($p[0] !~ /\//) {
+ # the first word, the command, does not contain a slash so
+ # we will scan the "improved" PATH to find the command to
+ # be able to run it
+ my $fullp = checktestcmd($p[0]);
+
+ if($fullp) {
+ $p[0] = $fullp;
+ }
+ $cmd = join(" ", @p);
+ }
+
+ my @o = `$cmd 2> $LOGDIR/precheck-$testnum`;
+ if($o[0]) {
+ $why = $o[0];
+ $why =~ s/[\r\n]//g;
+ }
+ elsif($?) {
+ $why = "precheck command error";
+ }
+ logmsg "prechecked $cmd\n" if($verbose);
+ }
+ }
+ return $why;
+}
+
+
+#######################################################################
+# Prepare the test environment to run this test case
+sub singletest_prepare {
+ my ($testnum) = @_;
+
+ if($feature{"TrackMemory"}) {
+ unlink($memdump);
+ }
+ unlink("core");
+
+ # if this section exists, it might be FTP server instructions:
+ my @ftpservercmd = getpart("reply", "servercmd");
+ push @ftpservercmd, "Testnum $testnum\n";
+ # write the instructions to file
+ writearray($FTPDCMD, \@ftpservercmd);
+
+ # create (possibly-empty) files before starting the test
+ for my $partsuffix (('', '1', '2', '3', '4')) {
+ my @inputfile=getpart("client", "file".$partsuffix);
+ my %fileattr = getpartattr("client", "file".$partsuffix);
+ my $filename=$fileattr{'name'};
+ if(@inputfile || $filename) {
+ if(!$filename) {
+ logmsg "ERROR: section client=>file has no name attribute\n";
+ timestampskippedevents($testnum);
+ return -1;
+ }
+ my $fileContent = join('', @inputfile);
+
+ # make directories if needed
+ my $path = $filename;
+ # cut off the file name part
+ $path =~ s/^(.*)\/[^\/]*/$1/;
+ my @parts = split(/\//, $path);
+ if($parts[0] eq $LOGDIR) {
+ # the file is in $LOGDIR/
+ my $d = shift @parts;
+ for(@parts) {
+ $d .= "/$_";
+ mkdir $d; # 0777
+ }
+ }
+ if (open(my $outfile, ">", "$filename")) {
+ binmode $outfile; # for crapage systems, use binary
+ if($fileattr{'nonewline'}) {
+ # cut off the final newline
+ chomp($fileContent);
+ }
+ print $outfile $fileContent;
+ close($outfile);
+ } else {
+ logmsg "ERROR: cannot write $filename\n";
+ }
+ }
+ }
+ return 0;
+}
+
+
+#######################################################################
+# Run the test command
+sub singletest_run {
+ my $testnum = $_[0];
+
+ # get the command line options to use
+ my ($cmd, @blaha)= getpart("client", "command");
+ if($cmd) {
+ # make some nice replace operations
+ $cmd =~ s/\n//g; # no newlines please
+ # substitute variables in the command line
+ }
+ else {
+ # there was no command given, use something silly
+ $cmd="-";
+ }
+
+ my $CURLOUT="$LOGDIR/curl$testnum.out"; # curl output if not stdout
+
+ # if stdout section exists, we verify that the stdout contained this:
+ my $out="";
+ my %cmdhash = getpartattr("client", "command");
+ if((!$cmdhash{'option'}) || ($cmdhash{'option'} !~ /no-output/)) {
+ #We may slap on --output!
+ if (!partexists("verify", "stdout") ||
+ ($cmdhash{'option'} && $cmdhash{'option'} =~ /force-output/)) {
+ $out=" --output $CURLOUT ";
+ }
+ }
+
+ # redirected stdout/stderr to these files
+ $STDOUT="$LOGDIR/stdout$testnum";
+ $STDERR="$LOGDIR/stderr$testnum";
+
+ my @codepieces = getpart("client", "tool");
+ my $tool="";
+ if(@codepieces) {
+ $tool = $codepieces[0];
+ chomp $tool;
+ $tool .= exe_ext('TOOL');
+ }
+
+ my $disablevalgrind;
+ my $CMDLINE;
+ my $cmdargs;
+ my $cmdtype = $cmdhash{'type'} || "default";
+ my $fail_due_event_based = $run_event_based;
+ if($cmdtype eq "perl") {
+ # run the command line prepended with "perl"
+ $cmdargs ="$cmd";
+ $CMDLINE = "$perl ";
+ $tool=$CMDLINE;
+ $disablevalgrind=1;
+ }
+ elsif($cmdtype eq "shell") {
+ # run the command line prepended with "/bin/sh"
+ $cmdargs ="$cmd";
+ $CMDLINE = "/bin/sh ";
+ $tool=$CMDLINE;
+ $disablevalgrind=1;
+ }
+ elsif(!$tool && !$keywords{"unittest"}) {
+ # run curl, add suitable command line options
+ my $inc="";
+ if((!$cmdhash{'option'}) || ($cmdhash{'option'} !~ /no-include/)) {
+ $inc = " --include";
+ }
+ $cmdargs = "$out$inc ";
+
+ if($cmdhash{'option'} && ($cmdhash{'option'} =~ /binary-trace/)) {
+ $cmdargs .= "--trace $LOGDIR/trace$testnum ";
+ }
+ else {
+ $cmdargs .= "--trace-ascii $LOGDIR/trace$testnum ";
+ }
+ $cmdargs .= "--trace-time ";
+ if($run_event_based) {
+ $cmdargs .= "--test-event ";
+ $fail_due_event_based--;
+ }
+ $cmdargs .= $cmd;
+ if ($proxy_address) {
+ $cmdargs .= " --proxy $proxy_address ";
+ }
+ }
+ else {
+ $cmdargs = " $cmd"; # $cmd is the command line for the test file
+ $CURLOUT = $STDOUT; # sends received data to stdout
+
+ # Default the tool to a unit test with the same name as the test spec
+ if($keywords{"unittest"} && !$tool) {
+ $tool="unit$testnum";
+ }
+
+ if($tool =~ /^lib/) {
+ $CMDLINE="$LIBDIR/$tool";
+ }
+ elsif($tool =~ /^unit/) {
+ $CMDLINE="$UNITDIR/$tool";
+ }
+
+ if(! -f $CMDLINE) {
+ logmsg "The tool set in the test case for this: '$tool' does not exist\n";
+ timestampskippedevents($testnum);
+ return (-1, 0, 0, "", "", 0);
+ }
+ $DBGCURL=$CMDLINE;
+ }
+
+ if($fail_due_event_based) {
+ logmsg "This test cannot run event based\n";
+ timestampskippedevents($testnum);
+ return (-1, 0, 0, "", "", 0);
+ }
+
+ if($gdbthis) {
+ # gdb is incompatible with valgrind, so disable it when debugging
+ # Perhaps a better approach would be to run it under valgrind anyway
+ # with --db-attach=yes or --vgdb=yes.
+ $disablevalgrind=1;
+ }
+
+ my @stdintest = getpart("client", "stdin");
+
+ if(@stdintest) {
+ my $stdinfile="$LOGDIR/stdin-for-$testnum";
+
+ my %hash = getpartattr("client", "stdin");
+ if($hash{'nonewline'}) {
+ # cut off the final newline from the final line of the stdin data
+ chomp($stdintest[-1]);
+ }
+
+ writearray($stdinfile, \@stdintest);
+
+ $cmdargs .= " <$stdinfile";
+ }
+
+ if(!$tool) {
+ $CMDLINE="$CURL";
+ }
+
+ if(use_valgrind() && !$disablevalgrind) {
+ my $valgrindcmd = "$valgrind ";
+ $valgrindcmd .= "$valgrind_tool " if($valgrind_tool);
+ $valgrindcmd .= "--quiet --leak-check=yes ";
+ $valgrindcmd .= "--suppressions=$srcdir/valgrind.supp ";
+ # $valgrindcmd .= "--gen-suppressions=all ";
+ $valgrindcmd .= "--num-callers=16 ";
+ $valgrindcmd .= "${valgrind_logfile}=$LOGDIR/valgrind$testnum";
+ $CMDLINE = "$valgrindcmd $CMDLINE";
+ }
+
+ $CMDLINE .= "$cmdargs >$STDOUT 2>$STDERR";
+
+ if($verbose) {
+ logmsg "$CMDLINE\n";
+ }
+
+ open(my $cmdlog, ">", $CURLLOG) || die "Failure writing log file";
+ print $cmdlog "$CMDLINE\n";
+ close($cmdlog) || die "Failure writing log file";
+
+ my $dumped_core;
+ my $cmdres;
+
+ if($gdbthis) {
+ my $gdbinit = "$TESTDIR/gdbinit$testnum";
+ open(my $gdbcmd, ">", "$LOGDIR/gdbcmd") || die "Failure writing gdb file";
+ print $gdbcmd "set args $cmdargs\n";
+ print $gdbcmd "show args\n";
+ print $gdbcmd "source $gdbinit\n" if -e $gdbinit;
+ close($gdbcmd) || die "Failure writing gdb file";
+ }
+
+ # Flush output.
+ $| = 1;
+
+ # timestamp starting of test command
+ $timetoolini{$testnum} = Time::HiRes::time();
+
+ # run the command line we built
+ if ($torture) {
+ $cmdres = torture($CMDLINE,
+ $testnum,
+ "$gdb --directory $LIBDIR $DBGCURL -x $LOGDIR/gdbcmd");
+ }
+ elsif($gdbthis) {
+ my $GDBW = ($gdbxwin) ? "-w" : "";
+ runclient("$gdb --directory $LIBDIR $DBGCURL $GDBW -x $LOGDIR/gdbcmd");
+ $cmdres=0; # makes it always continue after a debugged run
+ }
+ else {
+ # Convert the raw result code into a more useful one
+ ($cmdres, $dumped_core) = normalize_cmdres(runclient("$CMDLINE"));
+ }
+
+ # timestamp finishing of test command
+ $timetoolend{$testnum} = Time::HiRes::time();
+
+ return (0, $cmdres, $dumped_core, $CURLOUT, $tool, $disablevalgrind);
+}
+
+
+#######################################################################
+# Clean up after test command
+sub singletest_clean {
+ my ($testnum, $dumped_core)=@_;
+
+ if(!$dumped_core) {
+ if(-r "core") {
+ # there's core file present now!
+ $dumped_core = 1;
+ }
+ }
+
+ if($dumped_core) {
+ logmsg "core dumped\n";
+ if(0 && $gdb) {
+ logmsg "running gdb for post-mortem analysis:\n";
+ open(my $gdbcmd, ">", "$LOGDIR/gdbcmd2") || die "Failure writing gdb file";
+ print $gdbcmd "bt\n";
+ close($gdbcmd) || die "Failure writing gdb file";
+ runclient("$gdb --directory libtest -x $LOGDIR/gdbcmd2 -batch $DBGCURL core ");
+ # unlink("$LOGDIR/gdbcmd2");
+ }
+ }
+
+ # If a server logs advisor read lock file exists, it is an indication
+ # that the server has not yet finished writing out all its log files,
+ # including server request log files used for protocol verification.
+ # So, if the lock file exists the script waits here a certain amount
+ # of time until the server removes it, or the given time expires.
+ my $serverlogslocktimeout = $defserverlogslocktimeout;
+ my %cmdhash = getpartattr("client", "command");
+ if($cmdhash{'timeout'}) {
+ # test is allowed to override default server logs lock timeout
+ if($cmdhash{'timeout'} =~ /(\d+)/) {
+ $serverlogslocktimeout = $1 if($1 >= 0);
+ }
+ }
+ if($serverlogslocktimeout) {
+ my $lockretry = $serverlogslocktimeout * 20;
+ while((-f $SERVERLOGS_LOCK) && $lockretry--) {
+ portable_sleep(0.05);
+ }
+ if(($lockretry < 0) &&
+ ($serverlogslocktimeout >= $defserverlogslocktimeout)) {
+ logmsg "Warning: server logs lock timeout ",
+ "($serverlogslocktimeout seconds) expired\n";
+ }
+ }
+
+ # Test harness ssh server does not have this synchronization mechanism,
+ # this implies that some ssh server based tests might need a small delay
+ # once that the client command has run to avoid false test failures.
+ #
+ # gnutls-serv also lacks this synchronization mechanism, so gnutls-serv
+ # based tests might need a small delay once that the client command has
+ # run to avoid false test failures.
+ my $postcommanddelay = $defpostcommanddelay;
+ if($cmdhash{'delay'}) {
+ # test is allowed to specify a delay after command is executed
+ if($cmdhash{'delay'} =~ /(\d+)/) {
+ $postcommanddelay = $1 if($1 > 0);
+ }
+ }
+
+ portable_sleep($postcommanddelay) if($postcommanddelay);
+
+ # timestamp removal of server logs advisor read lock
+ $timesrvrlog{$testnum} = Time::HiRes::time();
+
+ # test definition might instruct to stop some servers
+ # stop also all servers relative to the given one
+
+ my @killtestservers = getpart("client", "killserver");
+ if(@killtestservers) {
+ foreach my $server (@killtestservers) {
+ chomp $server;
+ if(stopserver($server)) {
+ return 1; # normal error if asked to fail on unexpected alive
+ }
+ }
+ }
+ return 0;
+}
+
+#######################################################################
+# Verify that the postcheck succeeded
+sub singletest_postcheck {
+ my ($testnum)=@_;
+
+ # run the postcheck command
+ my @postcheck= getpart("client", "postcheck");
+ if(@postcheck) {
+ my $cmd = join("", @postcheck);
+ chomp $cmd;
+ if($cmd) {
+ logmsg "postcheck $cmd\n" if($verbose);
+ my $rc = runclient("$cmd");
+ # Must run the postcheck command in torture mode in order
+ # to clean up, but the result can't be relied upon.
+ if($rc != 0 && !$torture) {
+ logmsg " postcheck FAILED\n";
+ # timestamp test result verification end
+ $timevrfyend{$testnum} = Time::HiRes::time();
+ return -1;
+ }
+ }
+ }
+ return 0;
+}
+
+
+
+###################################################################
+# Get ready to run a single test case
+sub runner_test_preprocess {
+ my ($testnum)=@_;
+
+ ###################################################################
+ # Start the servers needed to run this test case
+ my $why = singletest_startservers($testnum);
+
+ if(!$why) {
+
+ ###############################################################
+ # Generate preprocessed test file
+ singletest_preprocess($testnum);
+
+
+ ###############################################################
+ # Set up the test environment to run this test case
+ singletest_setenv();
+
+
+ ###############################################################
+ # Check that the test environment is fine to run this test case
+ if (!$listonly) {
+ $why = singletest_precheck($testnum);
+ }
+ }
+ return $why;
+}
+
+
+###################################################################
+# Run a single test case with an environment that already been prepared
+# Returns 0=success, -1=skippable failure, -2=permanent error,
+# 1=unskippable test failure, as first integer, plus more return
+# values when error is 0
+sub runner_test_run {
+ my ($testnum)=@_;
+
+ #######################################################################
+ # Prepare the test environment to run this test case
+ my $error = singletest_prepare($testnum);
+ if($error) {
+ return -2;
+ }
+
+ #######################################################################
+ # Run the test command
+ my $cmdres;
+ my $dumped_core;
+ my $CURLOUT;
+ my $tool;
+ my $disablevalgrind;
+ ($error, $cmdres, $dumped_core, $CURLOUT, $tool, $disablevalgrind) = singletest_run($testnum);
+ if($error) {
+ return -2;
+ }
+
+ #######################################################################
+ # Clean up after test command
+ $error = singletest_clean($testnum, $dumped_core);
+ if($error) {
+ return $error;
+ }
+
+ #######################################################################
+ # Verify that the postcheck succeeded
+ $error = singletest_postcheck($testnum);
+ if($error) {
+ return $error;
+ }
+
+ #######################################################################
+ # restore environment variables that were modified
+ restore_test_env(0);
+
+ return (0, $cmdres, $CURLOUT, $tool, $disablevalgrind);
+}
+
+1;
use servers;
use valgrind; # valgrind report parser
use globalconfig;
+use runner;
my $CLIENTIP="127.0.0.1"; # address which curl uses for incoming connections
my $CLIENT6IP="[::1]"; # address which curl uses for incoming connections
my $ACURL=$VCURL; # what curl binary to use to talk to APIs (relevant for CI)
# ACURL is handy to set to the system one for reliability
-my $DBGCURL=$CURL; #"../src/.libs/curl"; # alternative for debugging
-my $TESTDIR="$srcdir/data";
-my $LIBDIR="./libtest";
-my $UNITDIR="./unit";
-# TODO: $LOGDIR could eventually change later on, so must regenerate all the
-# paths depending on it after $LOGDIR itself changes.
-# TODO: change this to use server_inputfilename()
-my $SERVERIN="$LOGDIR/server.input"; # what curl sent the server
-my $SERVER2IN="$LOGDIR/server2.input"; # what curl sent the second server
-my $PROXYIN="$LOGDIR/proxy.input"; # what curl sent the proxy
-my $CURLLOG="$LOGDIR/commands.log"; # all command lines run
-my $SERVERLOGS_LOCK="$LOGDIR/serverlogs.lock"; # server logs advisor read lock
my $CURLCONFIG="../curl-config"; # curl-config from current build
# Normally, all test cases should be run, but at times it is handy to
my $libtool;
my $repeat = 0;
-# name of the file that the memory debugging creates:
-my $memdump="$LOGDIR/memdump";
-
-# the path to the script that analyzes the memory debug output file:
-my $memanalyze="$perl $srcdir/memanalyze.pl";
-
my $pwd = getcwd(); # current working directory
my $posix_pwd = $pwd;
my $start; # time at which testing started
-my $valgrind = checktestcmd("valgrind");
-my $valgrind_logfile="--logfile"; # the option name for valgrind 2.X
-my $valgrind_tool;
-my $gdb = checktestcmd("gdb");
my $uname_release = `uname -r`;
my $is_wsl = $uname_release =~ /Microsoft$/;
# this version is decided by the particular nghttp2 library that is being used
my $h2cver = "h2c";
-my $has_shared; # built as a shared library
-
my $resolver; # name of the resolver backend (for human presentation)
my $has_textaware; # set if running on a system that has a text mode concept
my %disabled; # disabled test cases
my %ignored; # ignored results of test cases
-my $defserverlogslocktimeout = 2; # timeout to await server logs lock removal
-my $defpostcommanddelay = 0; # delay between command and postcheck sections
-
my $timestats; # time stamping and stats generation
my $fullstats; # show time stats for every single test
my %timeprepini; # timestamp for each test preparation start
-my %timesrvrini; # timestamp for each test required servers verification start
-my %timesrvrend; # timestamp for each test required servers verification end
-my %timetoolini; # timestamp for each test command run starting
-my %timetoolend; # timestamp for each test command run stopping
-my %timesrvrlog; # timestamp for each test server logs lock removal
-my %timevrfyend; # timestamp for each test result verification end
-
-my %oldenv; # environment variables before test is started
-my %feature; # array of enabled features
-my %keywords; # array of keywords from the test spec
#######################################################################
# variables that command line options may set
#
my $short;
-my $automakestyle;
my $no_debuginfod;
-my $anyway;
-my $gdbthis; # run test case with gdb debugger
-my $gdbxwin; # use windowed gdb when using gdb
my $keepoutfiles; # keep stdout and stderr files after tests
my $clearlocks; # force removal of files by killing locking processes
-my $listonly; # only list the tests
my $postmortem; # display detailed info about failed tests
-my $run_event_based; # run curl with --test-event to test the event API
my $run_disabled; # run the specific tests even if listed in DISABLED
my $scrambleorder;
-
-# torture test variables
-my $tortalloc;
-my $shallow;
my $randseed = 0;
# Azure Pipelines specific variables
close($dh);
}
-#######################################################################
-# Check for a command in the PATH of the machine running curl.
-#
-sub checktestcmd {
- my ($cmd)=@_;
- my @testpaths=("$LIBDIR/.libs", "$LIBDIR");
- return checkcmd($cmd, @testpaths);
-}
-
#######################################################################
# Run the application under test and return its return code
#
# return @out;
}
-#######################################################################
-# Memory allocation test and failure torture testing.
-#
-sub torture {
- my ($testcmd, $testnum, $gdbline) = @_;
-
- # remove memdump first to be sure we get a new nice and clean one
- unlink($memdump);
-
- # First get URL from test server, ignore the output/result
- runclient($testcmd);
-
- logmsg " CMD: $testcmd\n" if($verbose);
-
- # memanalyze -v is our friend, get the number of allocations made
- my $count=0;
- my @out = `$memanalyze -v $memdump`;
- for(@out) {
- if(/^Operations: (\d+)/) {
- $count = $1;
- last;
- }
- }
- if(!$count) {
- logmsg " found no functions to make fail\n";
- return 0;
- }
-
- my @ttests = (1 .. $count);
- if($shallow && ($shallow < $count)) {
- my $discard = scalar(@ttests) - $shallow;
- my $percent = sprintf("%.2f%%", $shallow * 100 / scalar(@ttests));
- logmsg " $count functions found, but only fail $shallow ($percent)\n";
- while($discard) {
- my $rm;
- do {
- # find a test to discard
- $rm = rand(scalar(@ttests));
- } while(!$ttests[$rm]);
- $ttests[$rm] = undef;
- $discard--;
- }
- }
- else {
- logmsg " $count functions to make fail\n";
- }
-
- for (@ttests) {
- my $limit = $_;
- my $fail;
- my $dumped_core;
-
- if(!defined($limit)) {
- # --shallow can undefine them
- next;
- }
- if($tortalloc && ($tortalloc != $limit)) {
- next;
- }
-
- if($verbose) {
- my ($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) =
- localtime(time());
- my $now = sprintf("%02d:%02d:%02d ", $hour, $min, $sec);
- logmsg "Fail function no: $limit at $now\r";
- }
-
- # make the memory allocation function number $limit return failure
- $ENV{'CURL_MEMLIMIT'} = $limit;
-
- # remove memdump first to be sure we get a new nice and clean one
- unlink($memdump);
-
- my $cmd = $testcmd;
- if($valgrind && !$gdbthis) {
- my @valgrindoption = getpart("verify", "valgrind");
- if((!@valgrindoption) || ($valgrindoption[0] !~ /disable/)) {
- my $valgrindcmd = "$valgrind ";
- $valgrindcmd .= "$valgrind_tool " if($valgrind_tool);
- $valgrindcmd .= "--quiet --leak-check=yes ";
- $valgrindcmd .= "--suppressions=$srcdir/valgrind.supp ";
- # $valgrindcmd .= "--gen-suppressions=all ";
- $valgrindcmd .= "--num-callers=16 ";
- $valgrindcmd .= "${valgrind_logfile}=$LOGDIR/valgrind$testnum";
- $cmd = "$valgrindcmd $testcmd";
- }
- }
- logmsg "*** Function number $limit is now set to fail ***\n" if($gdbthis);
-
- my $ret = 0;
- if($gdbthis) {
- runclient($gdbline);
- }
- else {
- $ret = runclient($cmd);
- }
- #logmsg "$_ Returned " . ($ret >> 8) . "\n";
-
- # Now clear the variable again
- delete $ENV{'CURL_MEMLIMIT'} if($ENV{'CURL_MEMLIMIT'});
-
- if(-r "core") {
- # there's core file present now!
- logmsg " core dumped\n";
- $dumped_core = 1;
- $fail = 2;
- }
-
- if($valgrind) {
- my @e = valgrindparse("$LOGDIR/valgrind$testnum");
- if(@e && $e[0]) {
- if($automakestyle) {
- logmsg "FAIL: torture $testnum - valgrind\n";
- }
- else {
- logmsg " valgrind ERROR ";
- logmsg @e;
- }
- $fail = 1;
- }
- }
-
- # verify that it returns a proper error code, doesn't leak memory
- # and doesn't core dump
- if(($ret & 255) || ($ret >> 8) >= 128) {
- logmsg " system() returned $ret\n";
- $fail=1;
- }
- else {
- my @memdata=`$memanalyze $memdump`;
- my $leak=0;
- for(@memdata) {
- if($_ ne "") {
- # well it could be other memory problems as well, but
- # we call it leak for short here
- $leak=1;
- }
- }
- if($leak) {
- logmsg "** MEMORY FAILURE\n";
- logmsg @memdata;
- logmsg `$memanalyze -l $memdump`;
- $fail = 1;
- }
- }
- if($fail) {
- logmsg " Failed on function number $limit in test.\n",
- " invoke with \"-t$limit\" to repeat this single case.\n";
- stopservers($verbose);
- return 1;
- }
- }
-
- logmsg "torture OK\n";
- return 0;
-}
#######################################################################
return @out;
}
-# Massage the command result code into a useful form
-sub normalize_cmdres {
- my $cmdres = $_[0];
- my $signal_num = $cmdres & 127;
- my $dumped_core = $cmdres & 128;
-
- if(!$anyway && ($signal_num || $dumped_core)) {
- $cmdres = 1000;
- }
- else {
- $cmdres >>= 8;
- $cmdres = (2000 + $signal_num) if($signal_num && !$cmdres);
- }
- return ($cmdres, $dumped_core);
-}
-
-# See if Valgrind should actually be used
-sub use_valgrind {
- if($valgrind) {
- my @valgrindoption = getpart("verify", "valgrind");
- if((!@valgrindoption) || ($valgrindoption[0] !~ /disable/)) {
- return 1;
- }
- }
- return 0;
-}
-
-
-# restore environment variables that were modified in test
-sub restore_test_env {
- my $deleteoldenv = $_[0]; # 1 to delete the saved contents after restore
- foreach my $var (keys %oldenv) {
- if($oldenv{$var} eq 'notset') {
- delete $ENV{$var} if($ENV{$var});
- }
- else {
- $ENV{$var} = $oldenv{$var};
- }
- if($deleteoldenv) {
- delete $oldenv{$var};
- }
- }
-}
-
-
# Setup CI Test Run
sub citest_starttestrun {
if(azure_check_environment()) {
}
-#######################################################################
-# Start the servers needed to run this test case
-sub singletest_startservers {
- my ($testnum) = @_;
-
- # remove test server commands file before servers are started/verified
- unlink($FTPDCMD) if(-f $FTPDCMD);
-
- # timestamp required servers verification start
- $timesrvrini{$testnum} = Time::HiRes::time();
-
- my $why;
- if (!$listonly) {
- my @what = getpart("client", "server");
- if(!$what[0]) {
- warn "Test case $testnum has no server(s) specified";
- $why = "no server specified";
- } else {
- my $err;
- ($why, $err) = serverfortest(@what);
- if($err == 1) {
- # Error indicates an actual problem starting the server, so
- # display the server logs
- displaylogs($testnum);
- }
- }
- }
-
- # timestamp required servers verification end
- $timesrvrend{$testnum} = Time::HiRes::time();
-
- # remove server output logfile after servers are started/verified
- unlink($SERVERIN);
- unlink($SERVER2IN);
- unlink($PROXYIN);
-
- return $why;
-}
-
-
-#######################################################################
-# Generate preprocessed test file
-sub singletest_preprocess {
- my $testnum = $_[0];
-
- # Save a preprocessed version of the entire test file. This allows more
- # "basic" test case readers to enjoy variable replacements.
- my @entiretest = fulltest();
- my $otest = "$LOGDIR/test$testnum";
-
- @entiretest = prepro($testnum, @entiretest);
-
- # save the new version
- open(my $fulltesth, ">", "$otest") || die "Failure writing test file";
- foreach my $bytes (@entiretest) {
- print $fulltesth pack('a*', $bytes) or die "Failed to print '$bytes': $!";
- }
- close($fulltesth) || die "Failure writing test file";
-
- # in case the process changed the file, reload it
- loadtest("$LOGDIR/test${testnum}");
-}
-
-
-#######################################################################
-# Set up the test environment to run this test case
-sub singletest_setenv {
- my @setenv = getpart("client", "setenv");
- foreach my $s (@setenv) {
- chomp $s;
- if($s =~ /([^=]*)=(.*)/) {
- my ($var, $content) = ($1, $2);
- # remember current setting, to restore it once test runs
- $oldenv{$var} = ($ENV{$var})?"$ENV{$var}":'notset';
- # set new value
- if(!$content) {
- delete $ENV{$var} if($ENV{$var});
- }
- else {
- if($var =~ /^LD_PRELOAD/) {
- if(exe_ext('TOOL') && (exe_ext('TOOL') eq '.exe')) {
- # print "Skipping LD_PRELOAD due to lack of OS support\n";
- next;
- }
- if($feature{"debug"} || !$has_shared) {
- # print "Skipping LD_PRELOAD due to no release shared build\n";
- next;
- }
- }
- $ENV{$var} = "$content";
- print "setenv $var = $content\n" if($verbose);
- }
- }
- }
- if($proxy_address) {
- $ENV{http_proxy} = $proxy_address;
- $ENV{HTTPS_PROXY} = $proxy_address;
- }
-}
-
-
-#######################################################################
-# Check that test environment is fine to run this test case
-sub singletest_precheck {
- my $testnum = $_[0];
- my $why;
- my @precheck = getpart("client", "precheck");
- if(@precheck) {
- my $cmd = $precheck[0];
- chomp $cmd;
- if($cmd) {
- my @p = split(/ /, $cmd);
- if($p[0] !~ /\//) {
- # the first word, the command, does not contain a slash so
- # we will scan the "improved" PATH to find the command to
- # be able to run it
- my $fullp = checktestcmd($p[0]);
-
- if($fullp) {
- $p[0] = $fullp;
- }
- $cmd = join(" ", @p);
- }
-
- my @o = `$cmd 2> $LOGDIR/precheck-$testnum`;
- if($o[0]) {
- $why = $o[0];
- $why =~ s/[\r\n]//g;
- }
- elsif($?) {
- $why = "precheck command error";
- }
- logmsg "prechecked $cmd\n" if($verbose);
- }
- }
- return $why;
-}
-
-
#######################################################################
# Print the test name and count tests
sub singletest_count {
}
-#######################################################################
-# Prepare the test environment to run this test case
-sub singletest_prepare {
- my ($testnum) = @_;
-
- if($feature{"TrackMemory"}) {
- unlink($memdump);
- }
- unlink("core");
-
- # if this section exists, it might be FTP server instructions:
- my @ftpservercmd = getpart("reply", "servercmd");
- push @ftpservercmd, "Testnum $testnum\n";
- # write the instructions to file
- writearray($FTPDCMD, \@ftpservercmd);
-
- # create (possibly-empty) files before starting the test
- for my $partsuffix (('', '1', '2', '3', '4')) {
- my @inputfile=getpart("client", "file".$partsuffix);
- my %fileattr = getpartattr("client", "file".$partsuffix);
- my $filename=$fileattr{'name'};
- if(@inputfile || $filename) {
- if(!$filename) {
- logmsg "ERROR: section client=>file has no name attribute\n";
- timestampskippedevents($testnum);
- return -1;
- }
- my $fileContent = join('', @inputfile);
-
- # make directories if needed
- my $path = $filename;
- # cut off the file name part
- $path =~ s/^(.*)\/[^\/]*/$1/;
- my @parts = split(/\//, $path);
- if($parts[0] eq $LOGDIR) {
- # the file is in $LOGDIR/
- my $d = shift @parts;
- for(@parts) {
- $d .= "/$_";
- mkdir $d; # 0777
- }
- }
- if (open(my $outfile, ">", "$filename")) {
- binmode $outfile; # for crapage systems, use binary
- if($fileattr{'nonewline'}) {
- # cut off the final newline
- chomp($fileContent);
- }
- print $outfile $fileContent;
- close($outfile);
- } else {
- logmsg "ERROR: cannot write $filename\n";
- }
- }
- }
- return 0;
-}
-
-
-#######################################################################
-# Run the test command
-sub singletest_run {
- my $testnum = $_[0];
-
- # get the command line options to use
- my ($cmd, @blaha)= getpart("client", "command");
- if($cmd) {
- # make some nice replace operations
- $cmd =~ s/\n//g; # no newlines please
- # substitute variables in the command line
- }
- else {
- # there was no command given, use something silly
- $cmd="-";
- }
-
- my $CURLOUT="$LOGDIR/curl$testnum.out"; # curl output if not stdout
-
- # if stdout section exists, we verify that the stdout contained this:
- my $out="";
- my %cmdhash = getpartattr("client", "command");
- if((!$cmdhash{'option'}) || ($cmdhash{'option'} !~ /no-output/)) {
- #We may slap on --output!
- if (!partexists("verify", "stdout") ||
- ($cmdhash{'option'} && $cmdhash{'option'} =~ /force-output/)) {
- $out=" --output $CURLOUT ";
- }
- }
-
- # redirected stdout/stderr to these files
- $STDOUT="$LOGDIR/stdout$testnum";
- $STDERR="$LOGDIR/stderr$testnum";
-
- my @codepieces = getpart("client", "tool");
- my $tool="";
- if(@codepieces) {
- $tool = $codepieces[0];
- chomp $tool;
- $tool .= exe_ext('TOOL');
- }
-
- my $disablevalgrind;
- my $CMDLINE;
- my $cmdargs;
- my $cmdtype = $cmdhash{'type'} || "default";
- my $fail_due_event_based = $run_event_based;
- if($cmdtype eq "perl") {
- # run the command line prepended with "perl"
- $cmdargs ="$cmd";
- $CMDLINE = "$perl ";
- $tool=$CMDLINE;
- $disablevalgrind=1;
- }
- elsif($cmdtype eq "shell") {
- # run the command line prepended with "/bin/sh"
- $cmdargs ="$cmd";
- $CMDLINE = "/bin/sh ";
- $tool=$CMDLINE;
- $disablevalgrind=1;
- }
- elsif(!$tool && !$keywords{"unittest"}) {
- # run curl, add suitable command line options
- my $inc="";
- if((!$cmdhash{'option'}) || ($cmdhash{'option'} !~ /no-include/)) {
- $inc = " --include";
- }
- $cmdargs = "$out$inc ";
-
- if($cmdhash{'option'} && ($cmdhash{'option'} =~ /binary-trace/)) {
- $cmdargs .= "--trace $LOGDIR/trace$testnum ";
- }
- else {
- $cmdargs .= "--trace-ascii $LOGDIR/trace$testnum ";
- }
- $cmdargs .= "--trace-time ";
- if($run_event_based) {
- $cmdargs .= "--test-event ";
- $fail_due_event_based--;
- }
- $cmdargs .= $cmd;
- if ($proxy_address) {
- $cmdargs .= " --proxy $proxy_address ";
- }
- }
- else {
- $cmdargs = " $cmd"; # $cmd is the command line for the test file
- $CURLOUT = $STDOUT; # sends received data to stdout
-
- # Default the tool to a unit test with the same name as the test spec
- if($keywords{"unittest"} && !$tool) {
- $tool="unit$testnum";
- }
-
- if($tool =~ /^lib/) {
- $CMDLINE="$LIBDIR/$tool";
- }
- elsif($tool =~ /^unit/) {
- $CMDLINE="$UNITDIR/$tool";
- }
-
- if(! -f $CMDLINE) {
- logmsg "The tool set in the test case for this: '$tool' does not exist\n";
- timestampskippedevents($testnum);
- return (-1, 0, 0, "", "", 0);
- }
- $DBGCURL=$CMDLINE;
- }
-
- if($fail_due_event_based) {
- logmsg "This test cannot run event based\n";
- timestampskippedevents($testnum);
- return (-1, 0, 0, "", "", 0);
- }
-
- if($gdbthis) {
- # gdb is incompatible with valgrind, so disable it when debugging
- # Perhaps a better approach would be to run it under valgrind anyway
- # with --db-attach=yes or --vgdb=yes.
- $disablevalgrind=1;
- }
-
- my @stdintest = getpart("client", "stdin");
-
- if(@stdintest) {
- my $stdinfile="$LOGDIR/stdin-for-$testnum";
-
- my %hash = getpartattr("client", "stdin");
- if($hash{'nonewline'}) {
- # cut off the final newline from the final line of the stdin data
- chomp($stdintest[-1]);
- }
-
- writearray($stdinfile, \@stdintest);
-
- $cmdargs .= " <$stdinfile";
- }
-
- if(!$tool) {
- $CMDLINE="$CURL";
- }
-
- if(use_valgrind() && !$disablevalgrind) {
- my $valgrindcmd = "$valgrind ";
- $valgrindcmd .= "$valgrind_tool " if($valgrind_tool);
- $valgrindcmd .= "--quiet --leak-check=yes ";
- $valgrindcmd .= "--suppressions=$srcdir/valgrind.supp ";
- # $valgrindcmd .= "--gen-suppressions=all ";
- $valgrindcmd .= "--num-callers=16 ";
- $valgrindcmd .= "${valgrind_logfile}=$LOGDIR/valgrind$testnum";
- $CMDLINE = "$valgrindcmd $CMDLINE";
- }
-
- $CMDLINE .= "$cmdargs >$STDOUT 2>$STDERR";
-
- if($verbose) {
- logmsg "$CMDLINE\n";
- }
-
- open(my $cmdlog, ">", $CURLLOG) || die "Failure writing log file";
- print $cmdlog "$CMDLINE\n";
- close($cmdlog) || die "Failure writing log file";
-
- my $dumped_core;
- my $cmdres;
-
- if($gdbthis) {
- my $gdbinit = "$TESTDIR/gdbinit$testnum";
- open(my $gdbcmd, ">", "$LOGDIR/gdbcmd") || die "Failure writing gdb file";
- print $gdbcmd "set args $cmdargs\n";
- print $gdbcmd "show args\n";
- print $gdbcmd "source $gdbinit\n" if -e $gdbinit;
- close($gdbcmd) || die "Failure writing gdb file";
- }
-
- # Flush output.
- $| = 1;
-
- # timestamp starting of test command
- $timetoolini{$testnum} = Time::HiRes::time();
-
- # run the command line we built
- if ($torture) {
- $cmdres = torture($CMDLINE,
- $testnum,
- "$gdb --directory $LIBDIR $DBGCURL -x $LOGDIR/gdbcmd");
- }
- elsif($gdbthis) {
- my $GDBW = ($gdbxwin) ? "-w" : "";
- runclient("$gdb --directory $LIBDIR $DBGCURL $GDBW -x $LOGDIR/gdbcmd");
- $cmdres=0; # makes it always continue after a debugged run
- }
- else {
- # Convert the raw result code into a more useful one
- ($cmdres, $dumped_core) = normalize_cmdres(runclient("$CMDLINE"));
- }
-
- # timestamp finishing of test command
- $timetoolend{$testnum} = Time::HiRes::time();
-
- return (0, $cmdres, $dumped_core, $CURLOUT, $tool, $disablevalgrind);
-}
-
-
-#######################################################################
-# Clean up after test command
-sub singletest_clean {
- my ($testnum, $dumped_core)=@_;
-
- if(!$dumped_core) {
- if(-r "core") {
- # there's core file present now!
- $dumped_core = 1;
- }
- }
-
- if($dumped_core) {
- logmsg "core dumped\n";
- if(0 && $gdb) {
- logmsg "running gdb for post-mortem analysis:\n";
- open(my $gdbcmd, ">", "$LOGDIR/gdbcmd2") || die "Failure writing gdb file";
- print $gdbcmd "bt\n";
- close($gdbcmd) || die "Failure writing gdb file";
- runclient("$gdb --directory libtest -x $LOGDIR/gdbcmd2 -batch $DBGCURL core ");
- # unlink("$LOGDIR/gdbcmd2");
- }
- }
-
- # If a server logs advisor read lock file exists, it is an indication
- # that the server has not yet finished writing out all its log files,
- # including server request log files used for protocol verification.
- # So, if the lock file exists the script waits here a certain amount
- # of time until the server removes it, or the given time expires.
- my $serverlogslocktimeout = $defserverlogslocktimeout;
- my %cmdhash = getpartattr("client", "command");
- if($cmdhash{'timeout'}) {
- # test is allowed to override default server logs lock timeout
- if($cmdhash{'timeout'} =~ /(\d+)/) {
- $serverlogslocktimeout = $1 if($1 >= 0);
- }
- }
- if($serverlogslocktimeout) {
- my $lockretry = $serverlogslocktimeout * 20;
- while((-f $SERVERLOGS_LOCK) && $lockretry--) {
- portable_sleep(0.05);
- }
- if(($lockretry < 0) &&
- ($serverlogslocktimeout >= $defserverlogslocktimeout)) {
- logmsg "Warning: server logs lock timeout ",
- "($serverlogslocktimeout seconds) expired\n";
- }
- }
-
- # Test harness ssh server does not have this synchronization mechanism,
- # this implies that some ssh server based tests might need a small delay
- # once that the client command has run to avoid false test failures.
- #
- # gnutls-serv also lacks this synchronization mechanism, so gnutls-serv
- # based tests might need a small delay once that the client command has
- # run to avoid false test failures.
- my $postcommanddelay = $defpostcommanddelay;
- if($cmdhash{'delay'}) {
- # test is allowed to specify a delay after command is executed
- if($cmdhash{'delay'} =~ /(\d+)/) {
- $postcommanddelay = $1 if($1 > 0);
- }
- }
-
- portable_sleep($postcommanddelay) if($postcommanddelay);
-
- # timestamp removal of server logs advisor read lock
- $timesrvrlog{$testnum} = Time::HiRes::time();
-
- # test definition might instruct to stop some servers
- # stop also all servers relative to the given one
-
- my @killtestservers = getpart("client", "killserver");
- if(@killtestservers) {
- foreach my $server (@killtestservers) {
- chomp $server;
- if(stopserver($server)) {
- return 1; # normal error if asked to fail on unexpected alive
- }
- }
- }
- return 0;
-}
-
-#######################################################################
-# Verify that the postcheck succeeded
-sub singletest_postcheck {
- my ($testnum)=@_;
-
- # run the postcheck command
- my @postcheck= getpart("client", "postcheck");
- if(@postcheck) {
- my $cmd = join("", @postcheck);
- chomp $cmd;
- if($cmd) {
- logmsg "postcheck $cmd\n" if($verbose);
- my $rc = runclient("$cmd");
- # Must run the postcheck command in torture mode in order
- # to clean up, but the result can't be relied upon.
- if($rc != 0 && !$torture) {
- logmsg " postcheck FAILED\n";
- # timestamp test result verification end
- $timevrfyend{$testnum} = Time::HiRes::time();
- return -1;
- }
- }
- }
- return 0;
-}
-
#######################################################################
# Verify test succeeded
sub singletest_check {
# servers or CI registration.
restore_test_env(1);
-
#######################################################################
# Register the test case with the CI environment
citest_starttest($testnum);
if(!$why) {
-
- ###################################################################
- # Start the servers needed to run this test case
- $why = singletest_startservers($testnum);
-
- if(!$why) {
-
- ###############################################################
- # Generate preprocessed test file
- singletest_preprocess($testnum);
-
-
- ###############################################################
- # Set up the test environment to run this test case
- singletest_setenv();
-
-
- ###############################################################
- # Check that the test environment is fine to run this test case
- if (!$listonly) {
- $why = singletest_precheck($testnum);
- }
- }
+ $why = runner_test_preprocess($testnum);
} else {
# set zero servers verification time when they aren't started
$timesrvrini{$testnum} = $timesrvrend{$testnum} = Time::HiRes::time();
}
-
#######################################################################
# Print the test name and count tests
my $error;
return $error;
}
-
#######################################################################
- # Prepare the test environment to run this test case
- $error = singletest_prepare($testnum);
- if($error) {
- return $error;
- }
-
-
- #######################################################################
- # Run the test command
+ # Execute this test number
my $cmdres;
- my $dumped_core;
my $CURLOUT;
my $tool;
my $disablevalgrind;
- ($error, $cmdres, $dumped_core, $CURLOUT, $tool, $disablevalgrind) = singletest_run($testnum);
- if($error) {
- return $error;
- }
-
-
- #######################################################################
- # Clean up after test command
- $error = singletest_clean($testnum, $dumped_core);
- if($error) {
- return $error;
- }
-
- #######################################################################
- # Verify that the postcheck succeeded
- $error = singletest_postcheck($testnum);
+ ($error, $cmdres, $CURLOUT, $tool, $disablevalgrind) = runner_test_run($testnum);
if($error == -1) {
# return a test failure, either to be reported or to be ignored
return $errorreturncode;
}
-
-
- #######################################################################
- # restore environment variables that were modified
- restore_test_env(0);
-
+ elsif($error == -2) {
+ return $error;
+ }
+ elsif($error > 0) {
+ return $error;
+ }
#######################################################################
# Verify that the test succeeded
push(@ARGV, split(' ', $ENV{'TFLAGS'})) if defined($ENV{'TFLAGS'});
}
+$valgrind = checktestcmd("valgrind");
my $number=0;
my $fromnum=-1;
my @testthis;
projects / thirdparty / curl.git / commitdiff
