1
0
mirror of https://github.com/moparisthebest/curl synced 2024-10-31 15:45:12 -04:00
curl/tests/runtests.pl

1716 lines
44 KiB
Perl
Raw Normal View History

2002-02-25 09:08:51 -05:00
#!/usr/bin/env perl
2004-01-13 03:57:01 -05:00
#***************************************************************************
# _ _ ____ _
# Project ___| | | | _ \| |
# / __| | | | |_) | |
# | (__| |_| | _ <| |___
2004-01-13 02:37:29 -05:00
# \___|\___/|_| \_\_____|
#
# Copyright (C) 1998 - 2004, Daniel Stenberg, <daniel@haxx.se>, et al.
#
2004-01-13 03:57:01 -05:00
# 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 http://curl.haxx.se/docs/copyright.html.
2000-11-13 11:06:16 -05:00
#
2004-01-13 02:37:29 -05:00
# 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
2004-01-13 03:57:01 -05:00
# furnished to do so, under the terms of the COPYING file.
2000-11-13 11:06:16 -05:00
#
2004-01-13 02:37:29 -05:00
# This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
# KIND, either express or implied.
#
# $Id$
2004-01-13 03:57:01 -05:00
###########################################################################
2000-11-13 11:06:16 -05:00
# These should be the only variables that might be needed to get edited:
use strict;
#use warnings;
2000-11-15 02:09:37 -05:00
@INC=(@INC, $ENV{'srcdir'}, ".");
2001-05-23 11:02:58 -04:00
require "getpart.pm"; # array functions
2001-04-24 17:09:53 -04:00
my $srcdir = $ENV{'srcdir'} || '.';
2000-11-15 02:09:37 -05:00
my $HOSTIP="127.0.0.1";
my $HOSTPORT=8999; # bad name, but this is the HTTP server port
2001-04-24 17:09:53 -04:00
my $HTTPSPORT=8433; # this is the HTTPS server port
my $FTPPORT=8921; # this is the FTP server port
2001-04-24 17:09:53 -04:00
my $FTPSPORT=8821; # this is the FTPS server port
my $CURL="../src/curl"; # what curl executable to run on the tests
my $DBGCURL=$CURL; #"../src/.libs/curl"; # alternative for debugging
2000-11-15 02:09:37 -05:00
my $LOGDIR="log";
my $TESTDIR="$srcdir/data";
my $LIBDIR="./libtest";
my $SERVERIN="$LOGDIR/server.input"; # what curl sent the server
my $CURLLOG="$LOGDIR/curl.log"; # all command lines run
2000-11-27 07:53:50 -05:00
my $FTPDCMD="$LOGDIR/ftpserver.cmd"; # copy ftp server instructions here
2000-11-13 11:06:16 -05:00
# Normally, all test cases should be run, but at times it is handy to
# simply run a particular one:
2000-11-15 02:09:37 -05:00
my $TESTCASES="all";
2000-11-13 11:06:16 -05:00
# To run specific test cases, set them like:
# $TESTCASES="1 2 3 7 8";
#######################################################################
# No variables below this point should need to be modified
#
my $HTTPPIDFILE=".http.pid";
2001-04-24 17:09:53 -04:00
my $HTTPSPIDFILE=".https.pid";
my $FTPPIDFILE=".ftp.pid";
my $FTPSPIDFILE=".ftps.pid";
2000-11-15 02:09:37 -05:00
# invoke perl like this:
my $perl="perl -I$srcdir";
# this gets set if curl is compiled with debugging:
my $curl_debug=0;
# name of the file that the memory debugging creates:
my $memdump="memdump";
# the path to the script that analyzes the memory debug output file:
my $memanalyze="./memanalyze.pl";
my $stunnel = checkcmd("stunnel");
my $valgrind = checkcmd("valgrind");
my $gdb = checkcmd("gdb");
2001-04-24 17:09:53 -04:00
my $ssl_version; # set if libcurl is built with SSL support
my $large_file; # set if libcurl is built with large file support
my $has_idn; # set if libcurl is built with IDN support
my $skipped=0; # number of tests skipped; reported in main loop
my %skipped; # skipped{reason}=counter, reasons for skip
my @teststat; # teststat[testnum]=reason, reasons for skip
2000-11-15 02:09:37 -05:00
#######################################################################
# variables the command line options may set
#
my $short;
my $verbose;
my $debugprotocol;
2000-11-17 10:15:48 -05:00
my $anyway;
my $gdbthis; # run test case with gdb debugger
my $keepoutfiles; # keep stdout and stderr files after tests
2002-01-04 08:20:17 -05:00
my $listonly; # only list the tests
my $postmortem; # display detailed info about failed tests
2002-01-04 08:20:17 -05:00
my $pwd; # current working directory
2003-04-01 03:41:49 -05:00
my %run; # running server
# torture test variables
my $torture;
my $tortnum;
my $tortalloc;
chomp($pwd = `pwd`);
2000-11-13 11:06:16 -05:00
# enable memory debugging if curl is compiled with it
$ENV{'CURL_MEMDEBUG'} = 1;
$ENV{'HOME'}=$pwd;
##########################################################################
# Clear all possible '*_proxy' environment variables for various protocols
# to prevent them to interfere with our testing!
my $protocol;
foreach $protocol (('ftp', 'http', 'ftps', 'https', 'gopher', 'no')) {
my $proxy = "${protocol}_proxy";
# clear lowercase version
$ENV{$proxy}=undef;
# clear uppercase version
$ENV{uc($proxy)}=undef;
}
#######################################################################
# Check for a command in the PATH.
#
sub checkcmd {
my ($cmd)=@_;
my @paths=("/usr/sbin", "/usr/local/sbin", "/sbin", "/usr/bin",
"/usr/local/bin", split(":", $ENV{'PATH'}));
for(@paths) {
if( -x "$_/$cmd") {
return "$_/$cmd";
}
}
}
#######################################################################
# Return the pid of the server as found in the given pid file
#
sub serverpid {
my $PIDFILE = $_[0];
open(PFILE, "<$PIDFILE");
my $PID=0+<PFILE>;
close(PFILE);
return $PID;
}
#######################################################################
# Memory allocation test and failure torture testing.
#
sub torture {
my $testcmd = shift;
my $gdbline = shift;
# 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
system($testcmd);
print " 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(/^Allocations: (\d+)/) {
$count = $1;
last;
}
}
if(!$count) {
print " found no allocs to make fail\n";
return 0;
}
2003-10-24 09:00:19 -04:00
print " $count allocations to make fail\n";
2003-10-24 09:00:19 -04:00
for ( 1 .. $count ) {
my $limit = $_;
my $fail;
my $dumped_core;
if($tortalloc && ($tortalloc != $limit)) {
next;
}
2003-10-24 09:00:19 -04:00
print "Fail alloc no: $limit\r" if($verbose);
# 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);
print "**> Alloc number $limit is now set to fail <**\n" if($gdbthis);
my $ret;
if($gdbthis) {
system($gdbline)
}
else {
$ret = system($testcmd);
}
# Now clear the variable again
$ENV{'CURL_MEMLIMIT'} = undef;
if(-r "core") {
# there's core file present now!
print " core dumped!\n";
$dumped_core = 1;
$fail = 2;
}
# verify that it returns a proper error code, doesn't leak memory
# and doesn't core dump
if($ret & 255) {
print " 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) {
print "** MEMORY FAILURE\n";
print @memdata;
print `$memanalyze -l $memdump`;
$fail = 1;
}
}
if($fail) {
print " Failed on alloc number $limit in test.\n",
" invoke with -t$limit to repeat this single case.\n";
stopservers();
exit 1;
}
}
print "torture OK\n";
return 0;
#stopservers();
#exit; # for now, we stop after these tests
}
#######################################################################
# stop the given test server
#
2000-11-13 11:06:16 -05:00
sub stopserver {
my $pid = $_[0];
2000-11-13 11:06:16 -05:00
# check for pidfile
if ( -f $pid ) {
my $PIDFILE = $pid;
$pid = serverpid($PIDFILE);
2000-11-13 11:06:16 -05:00
unlink $PIDFILE; # server is killed
}
elsif($pid <= 0) {
return; # this is not a good pid
}
my $res = kill (9, $pid); # die!
if($res && $verbose) {
print "RUN: Test server pid $pid signalled to die\n";
}
elsif($verbose) {
print "RUN: Test server pid $pid didn't exist\n";
2000-11-13 11:06:16 -05:00
}
}
#######################################################################
2001-04-24 17:09:53 -04:00
# check the given test server if it is still alive
#
2001-04-24 17:09:53 -04:00
sub checkserver {
my ($pidfile)=@_;
my $pid=0;
2001-04-24 17:09:53 -04:00
2000-11-13 11:06:16 -05:00
# check for pidfile
2001-04-24 17:09:53 -04:00
if ( -f $pidfile ) {
$pid=serverpid($pidfile);
if ($pid ne "" && kill(0, $pid)) {
return $pid;
2000-11-13 11:06:16 -05:00
}
else {
return -$pid; # negative means dead process
2000-11-13 11:06:16 -05:00
}
}
return 0;
2001-04-24 17:09:53 -04:00
}
#######################################################################
# start the http server, or if it already runs, verify that it is our
# test server on the test-port!
#
sub runhttpserver {
my $verbose = $_[0];
my $RUNNING;
my $pid;
2001-04-24 17:09:53 -04:00
$pid = checkserver ($HTTPPIDFILE);
# verify if our/any server is running on this port
my $cmd = "$CURL -o log/verifiedserver http://$HOSTIP:$HOSTPORT/verifiedserver 2>/dev/null";
2003-03-15 12:26:59 -05:00
print "CMD; $cmd\n" if ($verbose);
my $res = system($cmd);
2000-11-13 11:06:16 -05:00
$res >>= 8; # rotate the result
my $data;
2002-02-22 10:40:17 -05:00
print "RUN: curl command returned $res\n" if ($verbose);
2002-02-22 10:40:17 -05:00
open(FILE, "<log/verifiedserver");
my @file=<FILE>;
close(FILE);
$data=$file[0]; # first line
if ( $data =~ /WE ROOLZ: (\d+)/ ) {
$pid = 0+$1;
2000-11-13 11:06:16 -05:00
}
elsif($data || ($res != 7)) {
print "RUN: Unknown HTTP server is running on port $HOSTPORT\n";
return -2;
}
2000-11-13 11:06:16 -05:00
if($pid > 0) {
my $res = kill (9, $pid); # die!
if(!$res) {
print "RUN: Failed to kill test HTTP server, do it manually and",
" restart the tests.\n";
2000-11-13 11:06:16 -05:00
exit;
}
sleep(1);
}
2000-11-13 11:06:16 -05:00
my $flag=$debugprotocol?"-v ":"";
my $dir=$ENV{'srcdir'};
if($dir) {
$flag .= "-d \"$dir\" ";
}
$cmd="$perl $srcdir/httpserver.pl $flag $HOSTPORT &";
system($cmd);
if($verbose) {
print "CMD: $cmd\n";
2000-11-13 11:06:16 -05:00
}
my $verified;
for(1 .. 10) {
# verify that our server is up and running:
my $data=`$CURL --silent $HOSTIP:$HOSTPORT/verifiedserver 2>/dev/null`;
if ( $data =~ /WE ROOLZ: (\d+)/ ) {
$pid = 0+$1;
$verified = 1;
last;
}
else {
if($verbose) {
print STDERR "RUN: Retrying HTTP server existence in 3 sec\n";
}
sleep(3);
next;
}
}
if(!$verified) {
print STDERR "RUN: failed to start our HTTP server\n";
return -1;
}
if($verbose) {
print "RUN: HTTP server is now verified to be our server\n";
}
return $pid;
2000-11-13 11:06:16 -05:00
}
2001-04-24 17:09:53 -04:00
#######################################################################
# start the https server (or rather, tunnel) if needed
#
sub runhttpsserver {
my $verbose = $_[0];
my $STATUS;
my $RUNNING;
2001-04-24 17:09:53 -04:00
if(!$stunnel) {
return 0;
}
my $pid=checkserver($HTTPSPIDFILE );
if($pid > 0) {
2001-04-24 17:09:53 -04:00
# kill previous stunnel!
if($verbose) {
print "RUN: kills off running stunnel at $pid\n";
}
2001-04-24 17:09:53 -04:00
stopserver($HTTPSPIDFILE);
}
2001-04-24 17:09:53 -04:00
my $flag=$debugprotocol?"-v ":"";
my $cmd="$perl $srcdir/httpsserver.pl $flag -s \"$stunnel\" -d $srcdir -r $HOSTPORT $HTTPSPORT &";
system($cmd);
2001-04-24 17:09:53 -04:00
if($verbose) {
print "CMD: $cmd\n";
}
sleep(1);
for(1 .. 10) {
$pid=checkserver($HTTPSPIDFILE);
if($pid <= 0) {
if($verbose) {
print STDERR "RUN: waiting 3 sec for HTTPS server\n";
}
sleep(3);
}
else {
last;
}
}
return $pid;
2001-04-24 17:09:53 -04:00
}
#######################################################################
# start the ftp server if needed
#
sub runftpserver {
my $verbose = $_[0];
my $STATUS;
my $RUNNING;
# check for pidfile
my $pid = checkserver ($FTPPIDFILE );
2001-04-24 17:09:53 -04:00
if ($pid <= 0) {
print "RUN: Check port $FTPPORT for our own FTP server\n"
if ($verbose);
my $time=time();
# check if this is our server running on this port:
my @data=`$CURL -m4 --silent ftp://$HOSTIP:$FTPPORT/verifiedserver 2>/dev/null`;
my $line;
# if this took more than 2 secs, we assume it "hung" on a weird server
my $took = time()-$time;
foreach $line (@data) {
if ( $line =~ /WE ROOLZ: (\d+)/ ) {
# this is our test server with a known pid!
$pid = 0+$1;
}
2001-04-24 17:09:53 -04:00
}
if(!$pid && $data[0]) {
# this is not a known server
print "RUN: Unknown server on our favourite FTP port: $FTPPORT\n";
return -1;
}
}
if($pid > 0) {
print "RUN: Killing a previous server using pid $pid\n" if($verbose);
my $res = kill (9, $pid); # die!
if(!$res) {
print "RUN: Failed to kill our FTP test server, do it manually and",
" restart the tests.\n";
return -1;
2001-04-24 17:09:53 -04:00
}
sleep(1);
}
# now (re-)start our server:
my $flag=$debugprotocol?"-v ":"";
$flag .= "-s \"$srcdir\"";
my $cmd="$perl $srcdir/ftpserver.pl $flag $FTPPORT &";
if($verbose) {
print "CMD: $cmd\n";
}
system($cmd);
my $verified;
$pid = 0;
for(1 .. 10) {
# verify that our server is up and running:
my $line;
my $cmd="$CURL --silent ftp://$HOSTIP:$FTPPORT/verifiedserver 2>/dev/null";
print "$cmd\n" if($verbose);
my @data = `$cmd`;
foreach $line (@data) {
if ( $line =~ /WE ROOLZ: (\d+)/ ) {
$pid = 0+$1;
$verified = 1;
last;
}
}
if(!$pid) {
2003-04-01 03:41:49 -05:00
if($verbose) {
print STDERR "RUN: Retrying FTP server existence in 3 sec\n";
2003-04-01 03:41:49 -05:00
}
sleep(3);
next;
}
else {
last;
}
2001-04-24 17:09:53 -04:00
}
if(!$verified) {
warn "RUN: failed to start our FTP server\n";
return -2;
}
if($verbose) {
print "RUN: FTP server is now verified to be our server\n";
}
return $pid;
2001-04-24 17:09:53 -04:00
}
#######################################################################
# start the ftps server (or rather, tunnel) if needed
#
sub runftpsserver {
my $verbose = $_[0];
my $STATUS;
my $RUNNING;
if(!$stunnel) {
return 0;
}
my $pid=checkserver($FTPSPIDFILE );
if($pid > 0) {
2001-04-24 17:09:53 -04:00
# kill previous stunnel!
if($verbose) {
print "kills off running stunnel at $pid\n";
2001-04-24 17:09:53 -04:00
}
stopserver($FTPSPIDFILE);
}
my $flag=$debugprotocol?"-v ":"";
my $cmd="$perl $srcdir/ftpsserver.pl $flag -s \"$stunnel\" -d $srcdir -r $FTPPORT $FTPSPORT &";
2001-04-24 17:09:53 -04:00
system($cmd);
if($verbose) {
print "CMD: $cmd\n";
}
sleep(1);
for(1 .. 10) {
$pid=checkserver($FTPSPIDFILE );
if($pid <= 0) {
if($verbose) {
print STDERR "RUN: waiting 3 sec for FTPS server\n";
}
sleep(3);
}
else {
last;
}
}
return $pid;
}
#######################################################################
# Remove all files in the specified directory
#
sub cleardir {
my $dir = $_[0];
my $count;
2000-11-15 02:09:37 -05:00
my $file;
# Get all files
opendir(DIR, $dir) ||
return 0; # can't open dir
while($file = readdir(DIR)) {
if($file !~ /^\./) {
unlink("$dir/$file");
$count++;
}
}
closedir DIR;
return $count;
}
#######################################################################
# filter out the specified pattern from the given input file and store the
# results in the given output file
#
2000-11-13 11:06:16 -05:00
sub filteroff {
my $infile=$_[0];
my $filter=$_[1];
my $ofile=$_[2];
open(IN, "<$infile")
|| return 1;
open(OUT, ">$ofile")
|| return 1;
# print "FILTER: off $filter from $infile to $ofile\n";
while(<IN>) {
$_ =~ s/$filter//;
print OUT $_;
}
close(IN);
close(OUT);
2000-11-13 11:06:16 -05:00
return 0;
}
#######################################################################
# compare test results with the expected output, we might filter off
# some pattern that is allowed to differ, output test results
#
2000-11-13 11:06:16 -05:00
sub compare {
# filter off patterns _before_ this comparison!
my ($subject, $firstref, $secondref)=@_;
2000-11-13 11:06:16 -05:00
2001-05-23 11:02:58 -04:00
my $result = compareparts($firstref, $secondref);
2000-11-13 11:06:16 -05:00
if($result) {
if(!$short) {
print "\n $subject FAILED:\n";
print showdiff($firstref, $secondref);
}
else {
print "FAILED\n";
}
2000-11-17 10:15:48 -05:00
}
2001-05-23 11:02:58 -04:00
return $result;
2000-11-13 11:06:16 -05:00
}
#######################################################################
# display information about curl and the host the test suite runs on
#
sub checkcurl {
unlink($memdump); # remove this if there was one left
my $curl;
my $libcurl;
my @version=`$CURL --version 2>/dev/null`;
for(@version) {
chomp;
if($_ =~ /^curl/) {
$curl = $_;
$curl =~ s/^(.*)(libcurl.*)/$1/g;
$libcurl = $2;
if($curl =~ /mingw32/) {
# This is a windows minw32 build, we need to translate the
# given path to the "actual" windows path.
my @m = `mount`;
my $matchlen;
my $bestmatch;
my $mount;
# example mount output:
# C:\DOCUME~1\Temp on /tmp type user (binmode,noumount)
# c:\ActiveState\perl on /perl type user (binmode)
# C:\msys\1.0\bin on /usr/bin type user (binmode,cygexec,noumount)
# C:\msys\1.0\bin on /bin type user (binmode,cygexec,noumount)
foreach $mount (@m) {
if( $mount =~ /(.*) on ([^ ]*) type /) {
my ($mingw, $real)=($2, $1);
if($pwd =~ /^$mingw/) {
# the path we got from pwd starts with the path
# we found on this line in the mount output
my $len = length($real);
if($len > $matchlen) {
# we remember the match that is the longest
$matchlen = $len;
$bestmatch = $real;
}
}
}
}
if(!$matchlen) {
print "Serious error, can't find our \"real\" path!\n";
}
else {
# now prepend the prefix from the mount command to build
# our "actual path"
$pwd = "$bestmatch$pwd";
}
$pwd =~ s#\\#/#g;
}
elsif ($curl =~ /win32/)
{
# Native Windows builds don't understand the
# output of cygwin's pwd. It will be
# something like /cygdrive/c/<some path>.
#
# Use the cygpath utility to convert the
# working directory to a Windows friendly
# path. The -m option converts to use drive
# letter:, but it uses / instead \. Forward
# slashes (/) are easier for us. We don't
# have to escape them to get them to curl
# through a shell.
chomp($pwd = `cygpath -m $pwd`);
}
}
elsif($_ =~ /^Protocols: (.*)/i) {
# these are the supported protocols, we don't use this knowledge
# at this point
}
elsif($_ =~ /^Features: (.*)/i) {
my $feat = $1;
if($feat =~ /debug/i) {
# debug is a listed "feature", use that knowledge
$curl_debug = 1;
# set the NETRC debug env
$ENV{'CURL_DEBUG_NETRC'} = 'log/netrc';
}
if($feat =~ /SSL/i) {
# ssl enabled
$ssl_version=1;
}
if($feat =~ /Largefile/i) {
# large file support
$large_file=1;
}
if($feat =~ /IDN/i) {
# IDN support
$has_idn=1;
}
}
}
if(!$curl) {
die "couldn't run '$CURL'"
}
2000-11-13 11:06:16 -05:00
my $hostname=`hostname`;
my $hosttype=`uname -a`;
2001-04-24 17:09:53 -04:00
print "********* System characteristics ******** \n",
"* $curl\n",
"* $libcurl\n",
2000-11-17 10:15:48 -05:00
"* Host: $hostname",
"* System: $hosttype";
printf("* Server SSL: %s\n", $stunnel?"ON":"OFF");
printf("* libcurl SSL: %s\n", $ssl_version?"ON":"OFF");
printf("* libcurl debug: %s\n", $curl_debug?"ON":"OFF");
printf("* valgrind: %s\n", $valgrind?"ON":"OFF");
2001-04-24 17:09:53 -04:00
print "***************************************** \n";
2000-11-13 11:06:16 -05:00
}
#######################################################################
# substitute the variable stuff into either a joined up file or
# a command, in either case passed by reference
#
sub subVariables {
my ($thing) = @_;
$$thing =~ s/%HOSTIP/$HOSTIP/g;
$$thing =~ s/%HOSTPORT/$HOSTPORT/g;
2004-02-20 02:14:58 -05:00
$$thing =~ s/%HTTPPORT/$HOSTPORT/g;
$$thing =~ s/%HTTPSPORT/$HTTPSPORT/g;
$$thing =~ s/%FTPPORT/$FTPPORT/g;
$$thing =~ s/%FTPSPORT/$FTPSPORT/g;
$$thing =~ s/%SRCDIR/$srcdir/g;
$$thing =~ s/%PWD/$pwd/g;
}
#######################################################################
# Run a single specified test case
#
2000-11-13 11:06:16 -05:00
sub singletest {
2001-05-23 11:02:58 -04:00
my $testnum=$_[0];
my @what;
my $why;
my $serverproblem;
2001-05-23 11:02:58 -04:00
# load the test case file definition
if(loadtest("${TESTDIR}/test${testnum}")) {
if($verbose) {
# this is not a test
print "RUN: $testnum doesn't look like a test case!\n";
2001-05-23 11:02:58 -04:00
}
$serverproblem = 100;
}
else {
@what = getpart("client", "features");
2001-05-23 11:02:58 -04:00
}
2000-11-13 11:06:16 -05:00
printf("test %03d...", $testnum);
for(@what) {
my $f = $_;
$f =~ s/\s//g;
if($f eq "SSL") {
if($ssl_version) {
next;
}
}
elsif($f eq "netrc_debug") {
if($curl_debug) {
next;
}
}
elsif($f eq "large_file") {
if($large_file) {
next;
}
}
elsif($f eq "idn") {
if($has_idn) {
next;
}
}
$why = "curl lacks $f support";
$serverproblem = 15; # set it here
last;
}
if(!$serverproblem) {
$serverproblem = serverfortest($testnum);
}
if($serverproblem) {
# there's a problem with the server, don't run
# this particular server, but count it as "skipped"
if($serverproblem == 2) {
$why = "server problems";
}
elsif($serverproblem == 100) {
$why = "no test";
}
elsif($serverproblem == 99) {
$why = "bad test";
}
elsif($serverproblem == 15) {
# set above, a lacking prereq
}
elsif($serverproblem == 1) {
$why = "no HTTPS server";
}
elsif($serverproblem == 3) {
$why = "no FTPS server";
}
else {
$why = "unfulfilled requirements";
}
$skipped++;
$skipped{$why}++;
$teststat[$testnum]=$why; # store reason for this test case
print "SKIPPED\n";
if(!$short) {
print "* Test $testnum: $why\n";
}
return -1;
}
2001-05-23 11:02:58 -04:00
# extract the reply data
my @reply = getpart("reply", "data");
my @replycheck = getpart("reply", "datacheck");
if (@replycheck) {
2000-11-13 11:06:16 -05:00
# we use this file instead to check the final output against
2002-06-11 11:11:41 -04:00
my %hash = getpartattr("reply", "datacheck");
if($hash{'nonewline'}) {
# Yes, we must cut off the final newline from the final line
# of the datacheck
chomp($replycheck[$#replycheck]);
}
2001-05-23 11:02:58 -04:00
@reply=@replycheck;
2000-11-13 11:06:16 -05:00
}
# curl command to run
2001-05-23 11:02:58 -04:00
my @curlcmd= getpart("client", "command");
2000-11-13 11:06:16 -05:00
2001-05-23 11:02:58 -04:00
# this is the valid protocol blurb curl should generate
my @protocol= getpart("verify", "protocol");
2000-11-13 11:06:16 -05:00
2001-05-23 11:02:58 -04:00
# redirected stdout/stderr to these files
$STDOUT="$LOGDIR/stdout$testnum";
$STDERR="$LOGDIR/stderr$testnum";
2001-05-23 11:02:58 -04:00
# if this section exists, we verify that the stdout contained this:
my @validstdout = getpart("verify", "stdout");
2001-05-23 11:02:58 -04:00
# if this section exists, we verify upload
my @upload = getpart("verify", "upload");
2001-05-23 11:02:58 -04:00
# if this section exists, it is FTP server instructions:
my @ftpservercmd = getpart("server", "instruction");
2000-11-27 07:53:50 -05:00
2001-05-23 11:02:58 -04:00
my $CURLOUT="$LOGDIR/curl$testnum.out"; # curl output if not stdout
2000-11-13 11:06:16 -05:00
# name of the test
2001-05-23 11:02:58 -04:00
my @testname= getpart("client", "name");
2000-11-13 11:06:16 -05:00
if(!$short) {
2001-05-23 11:02:58 -04:00
my $name = $testname[0];
$name =~ s/\n//g;
print "[$name]\n";
}
2000-11-13 11:06:16 -05:00
2002-01-04 08:20:17 -05:00
if($listonly) {
return 0; # look successful
}
my @codepieces = getpart("client", "tool");
my $tool="";
if(@codepieces) {
$tool = $codepieces[0];
chomp $tool;
}
2002-01-04 08:20:17 -05:00
# remove previous server output logfile
unlink($SERVERIN);
if(@ftpservercmd) {
# write the instructions to file
writearray($FTPDCMD, \@ftpservercmd);
}
my (@setenv)= getpart("client", "setenv");
my @envs;
my $s;
for $s (@setenv) {
chomp $s; # cut off the newline
subVariables \$s;
if($s =~ /([^=]*)=(.*)/) {
my ($var, $content)=($1, $2);
$ENV{$var}=$content;
# remember which, so that we can clear them afterwards!
push @envs, $var;
}
}
2000-11-13 11:06:16 -05:00
# get the command line options to use
2001-05-23 11:02:58 -04:00
my ($cmd, @blaha)= getpart("client", "command");
2000-11-13 11:06:16 -05:00
# make some nice replace operations
2001-05-23 11:02:58 -04:00
$cmd =~ s/\n//g; # no newlines please
2003-08-06 19:10:36 -04:00
# substitute variables in the command line
subVariables \$cmd;
if($curl_debug) {
unlink($memdump);
}
my @inputfile=getpart("client", "file");
if(@inputfile) {
# we need to generate a file before this test is invoked
my %hash = getpartattr("client", "file");
my $filename=$hash{'name'};
if(!$filename) {
print "ERROR: section client=>file has no name attribute!\n";
exit;
}
my $fileContent = join('', @inputfile);
subVariables \$fileContent;
# print "DEBUG: writing file " . $filename . "\n";
open OUTFILE, ">$filename";
binmode OUTFILE; # for crapage systems, use binary
print OUTFILE $fileContent;
close OUTFILE;
}
my %cmdhash = getpartattr("client", "command");
my $out="";
2003-08-06 19:10:36 -04:00
if($cmdhash{'option'} !~ /no-output/) {
#We may slap on --output!
if (!@validstdout) {
$out=" --output $CURLOUT ";
}
}
my $cmdargs;
if(!$tool) {
# run curl, add -v for debug information output
2002-12-13 11:24:57 -05:00
$cmdargs ="$out --include -v $cmd";
}
else {
$cmdargs = " $cmd"; # $cmd is the command line for the test file
$CURLOUT = $STDOUT; # sends received data to stdout
}
my @stdintest = getpart("client", "stdin");
2001-05-23 11:02:58 -04:00
if(@stdintest) {
my $stdinfile="$LOGDIR/stdin-for-$testnum";
writearray($stdinfile, \@stdintest);
$cmdargs .= " <$stdinfile";
}
my $CMDLINE;
2000-11-13 11:06:16 -05:00
if(!$tool) {
$CMDLINE="$CURL";
2000-11-13 11:06:16 -05:00
}
else {
$CMDLINE="$LIBDIR/$tool";
$DBGCURL=$CMDLINE;
}
if($valgrind) {
$CMDLINE = "valgrind --leak-check=yes --logfile=log/valgrind$testnum -q $CMDLINE";
}
2003-08-06 19:10:36 -04:00
$CMDLINE .= "$cmdargs >>$STDOUT 2>>$STDERR";
if($verbose) {
print "$CMDLINE\n";
}
2000-11-13 11:06:16 -05:00
print CMDLOG "$CMDLINE\n";
unlink("core");
my $dumped_core;
my $cmdres;
if($gdbthis) {
open(GDBCMD, ">log/gdbcmd");
print GDBCMD "set args $cmdargs\n";
print GDBCMD "show args\n";
close(GDBCMD);
}
# run the command line we built
if ($torture) {
return torture($CMDLINE,
"gdb --directory libtest $DBGCURL -x log/gdbcmd");
}
elsif($gdbthis) {
system("gdb --directory libtest $DBGCURL -x log/gdbcmd");
$cmdres=0; # makes it always continue after a debugged run
}
else {
$cmdres = system("$CMDLINE");
my $signal_num = $cmdres & 127;
$dumped_core = $cmdres & 128;
if(!$anyway && ($signal_num || $dumped_core)) {
$cmdres = 1000;
}
else {
$cmdres /= 256;
}
}
if(!$dumped_core) {
if(-r "core") {
# there's core file present now!
$dumped_core = 1;
}
}
if($dumped_core) {
print "core dumped!\n";
2004-05-05 16:12:59 -04:00
if(0 && $gdb) {
print "running gdb for post-mortem analysis:\n";
open(GDBCMD, ">log/gdbcmd2");
print GDBCMD "bt\n";
close(GDBCMD);
system("gdb --directory libtest -x log/gdbcmd2 -batch $DBGCURL core ");
# unlink("log/gdbcmd2");
}
}
2000-11-13 11:06:16 -05:00
# remove the special FTP command file after each test!
unlink($FTPDCMD);
my $e;
for $e (@envs) {
$ENV{$e}=""; # clean up
}
2001-05-23 11:02:58 -04:00
my @err = getpart("verify", "errorcode");
my $errorcode = $err[0];
my $res;
2001-05-23 11:02:58 -04:00
if (@validstdout) {
# verify redirected stdout
my @actual = loadarray($STDOUT);
$res = compare("stdout", \@actual, \@validstdout);
2001-05-23 11:02:58 -04:00
if($res) {
return 1;
}
2001-05-23 11:02:58 -04:00
if(!$short) {
print " stdout OK";
}
2000-11-13 11:06:16 -05:00
}
2001-05-23 11:02:58 -04:00
my %replyattr = getpartattr("reply", "data");
if(!$replyattr{'nocheck'} && @reply) {
2001-05-23 11:02:58 -04:00
# verify the received data
my @out = loadarray($CURLOUT);
$res = compare("data", \@out, \@reply);
2001-05-23 11:02:58 -04:00
if ($res) {
return 1;
}
2001-05-23 11:02:58 -04:00
if(!$short) {
print " data OK";
}
2001-05-23 11:02:58 -04:00
}
2001-05-23 11:02:58 -04:00
if(@upload) {
# verify uploaded data
my @out = loadarray("$LOGDIR/upload.$testnum");
$res = compare("upload", \@out, \@upload);
2001-05-23 11:02:58 -04:00
if ($res) {
return 1;
}
2001-05-23 11:02:58 -04:00
if(!$short) {
print " upload OK";
2000-11-13 11:06:16 -05:00
}
2001-05-23 11:02:58 -04:00
}
2000-11-13 11:06:16 -05:00
2001-05-23 11:02:58 -04:00
if(@protocol) {
# verify the sent request
my @out = loadarray($SERVERIN);
2001-05-23 11:02:58 -04:00
# what to cut off from the live protocol sent by curl
my @strip = getpart("verify", "strip");
2000-11-13 11:06:16 -05:00
2001-06-27 18:01:08 -04:00
my @protstrip=@protocol;
# check if there's any attributes on the verify/protocol section
my %hash = getpartattr("verify", "protocol");
if($hash{'nonewline'}) {
# Yes, we must cut off the final newline from the final line
# of the protocol data
chomp($protstrip[$#protstrip]);
}
2001-06-27 18:01:08 -04:00
for(@strip) {
# strip off all lines that match the patterns from both arrays
2004-04-29 09:31:57 -04:00
chomp $_;
2001-06-27 18:01:08 -04:00
@out = striparray( $_, \@out);
@protstrip= striparray( $_, \@protstrip);
}
$res = compare("protocol", \@out, \@protstrip);
2001-05-23 11:02:58 -04:00
if($res) {
return 1;
}
if(!$short) {
print " protocol OK";
2000-11-13 11:06:16 -05:00
}
}
2000-11-27 07:53:50 -05:00
my @outfile=getpart("verify", "file");
if(@outfile) {
# we're supposed to verify a dynamicly generated file!
my %hash = getpartattr("verify", "file");
my $filename=$hash{'name'};
if(!$filename) {
print "ERROR: section verify=>file has no name attribute!\n";
exit;
}
my @generated=loadarray($filename);
$res = compare("output", \@generated, \@outfile);
if($res) {
return 1;
}
if(!$short) {
print " output OK";
}
}
if($errorcode == $cmdres) {
$errorcode =~ s/\n//;
if($verbose) {
print " received exitcode $errorcode OK";
}
elsif(!$short) {
print " exit OK";
}
}
else {
if(!$short) {
print "curl returned $cmdres, ".(0+$errorcode)." was expected\n";
}
print " exit FAILED\n";
return 1;
}
# the test succeeded, remove all log files
if(!$keepoutfiles) {
cleardir($LOGDIR);
}
2000-11-27 07:53:50 -05:00
unlink($FTPDCMD); # remove the instructions for this test
@what = getpart("client", "killserver");
2003-04-01 03:41:49 -05:00
for(@what) {
my $serv = $_;
chomp $serv;
if($run{$serv}) {
stopserver($run{$serv}); # the pid file is in the hash table
$run{$serv}=0; # clear pid
2003-04-01 03:41:49 -05:00
}
else {
print STDERR "RUN: The $serv server is not running\n";
}
}
if($curl_debug) {
if(! -f $memdump) {
print "\n** ALERT! memory debuggin without any output file?\n";
}
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) {
print "\n** MEMORY FAILURE\n";
print @memdata;
return 1;
}
else {
if(!$short) {
print " memory OK";
}
}
}
}
if($valgrind) {
opendir(DIR, "log") ||
return 0; # can't open log dir
my @files = readdir(DIR);
closedir DIR;
my $f;
my $l;
foreach $f (@files) {
if($f =~ /^valgrind$testnum/) {
$l = $f;
last;
}
}
my $leak;
open(VAL, "<$l");
while(<VAL>) {
if($_ =~ /definitely lost: (\d*) bytes/) {
$leak = $1;
last;
}
}
close(VAL);
if($leak) {
print " valgrind ERROR ";
}
elsif(!$short) {
print " valgrind OK";
}
2000-11-13 11:06:16 -05:00
}
2000-11-17 10:15:48 -05:00
if($short) {
print "OK";
}
print "\n";
2000-11-13 11:06:16 -05:00
return 0;
}
#######################################################################
# Stop all running test servers
sub stopservers {
2003-10-24 09:00:19 -04:00
print "Shutting down test suite servers:\n" if ($verbose);
for(keys %run) {
2003-10-24 09:00:19 -04:00
printf ("* kill pid for %-5s => %-5d\n", $_, $run{$_}) if($verbose);
stopserver($run{$_}); # the pid file is in the hash table
2001-04-24 17:09:53 -04:00
}
}
#######################################################################
# startservers() starts all the named servers
#
sub startservers {
my @what = @_;
my $pid;
for(@what) {
my $what = lc($_);
$what =~ s/[^a-z]//g;
if($what eq "ftp") {
if(!$run{'ftp'}) {
$pid = runftpserver($verbose);
if($pid <= 0) {
return 2; # error starting it
}
2003-10-24 09:00:19 -04:00
printf ("* pid ftp => %-5d\n", $pid) if($verbose);
$run{'ftp'}=$pid;
}
}
elsif($what eq "http") {
if(!$run{'http'}) {
$pid = runhttpserver($verbose);
if($pid <= 0) {
return 2; # error starting
}
2003-10-24 09:00:19 -04:00
printf ("* pid http => %-5d\n", $pid) if($verbose);
$run{'http'}=$pid;
}
}
elsif($what eq "ftps") {
if(!$stunnel || !$ssl_version) {
# we can't run ftps tests without stunnel
# or if libcurl is SSL-less
return 3;
}
if(!$run{'ftp'}) {
$pid = runftpserver($verbose);
if($pid <= 0) {
return 2; # error starting it
}
printf ("* pid ftp => %-5d\n", $pid) if($verbose);
$run{'ftp'}=$pid;
}
if(!$run{'ftps'}) {
return 2;
$pid = runftpsserver($verbose);
if($pid <= 0) {
return 2;
}
2003-10-24 09:00:19 -04:00
printf ("* pid ftps => %-5d\n", $pid) if($verbose);
$run{'ftps'}=$pid;
}
2001-04-24 17:09:53 -04:00
}
elsif($what eq "file") {
# we support it but have no server!
}
elsif($what eq "https") {
if(!$stunnel || !$ssl_version) {
# we can't run https tests without stunnel
# or if libcurl is SSL-less
return 1;
}
if(!$run{'http'}) {
$pid = runhttpserver($verbose);
if($pid <= 0) {
return 2; # problems starting server
}
printf ("* pid http => %-5d\n", $pid) if($verbose);
$run{'http'}=$pid;
}
if(!$run{'https'}) {
$pid = runhttpsserver($verbose);
if($pid <= 0) {
return 2;
}
2003-10-24 09:00:19 -04:00
printf ("* pid https => %-5d\n", $pid) if($verbose);
$run{'https'}=$pid;
}
2001-04-24 17:09:53 -04:00
}
2003-03-15 12:11:13 -05:00
elsif($what eq "none") {
print "* starts no server\n" if ($verbose);
2003-03-15 12:11:13 -05:00
}
else {
warn "we don't support a server for $what";
2001-04-24 17:09:53 -04:00
}
}
return 0;
}
##############################################################################
# This function makes sure the right set of server is running for the
# specified test case. This is a useful design when we run single tests as not
# all servers need to run then!
#
# Returns:
# 100 if this is not a test case
# 99 if this test case has no servers specified
# 3 if this test is skipped due to no FTPS server
# 2 if one of the required servers couldn't be started
# 1 if this test is skipped due to no HTTPS server
sub serverfortest {
my ($testnum)=@_;
# load the test case file definition
if(loadtest("${TESTDIR}/test${testnum}")) {
if($verbose) {
# this is not a test
print "$testnum doesn't look like a test case!\n";
}
return 100;
}
my @what = getpart("client", "server");
if(!$what[0]) {
warn "Test case $testnum has no server(s) specified!";
return 99;
}
return &startservers(@what);
2001-04-24 17:09:53 -04:00
}
2000-11-13 11:06:16 -05:00
#######################################################################
# Check options to this test program
#
my $number=0;
my $fromnum=-1;
my @testthis;
do {
if ($ARGV[0] eq "-v") {
# verbose output
$verbose=1;
}
elsif ($ARGV[0] eq "-c") {
# use this path to curl instead of default
$CURL=$ARGV[1];
shift @ARGV;
}
elsif ($ARGV[0] eq "-d") {
# have the servers display protocol output
$debugprotocol=1;
}
elsif ($ARGV[0] eq "-g") {
# run this test with gdb
$gdbthis=1;
}
elsif($ARGV[0] eq "-s") {
# short output
$short=1;
}
2003-11-13 05:05:44 -05:00
elsif($ARGV[0] eq "-n") {
# no valgrind
undef $valgrind;
}
elsif($ARGV[0] =~ /^-t(.*)/) {
# torture
$torture=1;
my $xtra = $1;
2003-10-24 09:00:19 -04:00
if($xtra =~ s/(\d+)$//) {
$tortalloc = $1;
}
# we undef valgrind to make this fly in comparison
undef $valgrind;
}
2000-11-17 10:15:48 -05:00
elsif($ARGV[0] eq "-a") {
# continue anyway, even if a test fail
$anyway=1;
}
elsif($ARGV[0] eq "-p") {
$postmortem=1;
}
2002-01-04 08:20:17 -05:00
elsif($ARGV[0] eq "-l") {
# lists the test case names only
$listonly=1;
}
elsif($ARGV[0] eq "-k") {
# keep stdout and stderr files after tests
$keepoutfiles=1;
}
2000-11-14 05:28:25 -05:00
elsif($ARGV[0] eq "-h") {
# show help text
print <<EOHELP
2001-04-24 17:09:53 -04:00
Usage: runtests.pl [options]
2000-11-17 10:15:48 -05:00
-a continue even if a test fails
-d display server debug info
-g run the test case with gdb
2000-11-14 05:28:25 -05:00
-h this help text
-k keep stdout and stderr files present after tests
2002-01-04 08:20:17 -05:00
-l list all test case names/descriptions
2003-11-13 05:05:44 -05:00
-n No valgrind
-p Print log file contents when a test fails
2000-11-14 05:28:25 -05:00
-s short output
-t torture
2000-11-14 05:28:25 -05:00
-v verbose output
2001-04-24 17:09:53 -04:00
[num] like "5 6 9" or " 5 to 22 " to run those tests only
2000-11-14 05:28:25 -05:00
EOHELP
;
exit;
}
elsif($ARGV[0] =~ /^(\d+)/) {
$number = $1;
if($fromnum >= 0) {
for($fromnum .. $number) {
push @testthis, $_;
}
$fromnum = -1;
}
else {
push @testthis, $1;
}
}
elsif($ARGV[0] =~ /^to$/i) {
$fromnum = $number+1;
}
} while(shift @ARGV);
2000-11-13 11:06:16 -05:00
if($testthis[0] ne "") {
$TESTCASES=join(" ", @testthis);
}
2003-11-13 05:05:44 -05:00
if($valgrind) {
# we have found valgrind on the host, use it
# verify that we can invoke it fine
my $code = system("valgrind >/dev/null 2>&1");
if(($code>>8) != 1) {
#print "Valgrind failure, disable it\n";
undef $valgrind;
}
}
2000-11-13 11:06:16 -05:00
#######################################################################
# Output curl version and host info being tested
#
if(!$listonly) {
checkcurl();
}
2000-11-13 11:06:16 -05:00
#######################################################################
# clear and create logging directory:
2000-11-13 11:06:16 -05:00
#
cleardir($LOGDIR);
mkdir($LOGDIR, 0777);
2000-11-13 11:06:16 -05:00
#######################################################################
# If 'all' tests are requested, find out all test numbers
2000-11-13 11:06:16 -05:00
#
if ( $TESTCASES eq "all") {
# Get all commands and find out their test numbers
opendir(DIR, $TESTDIR) || die "can't opendir $TESTDIR: $!";
2001-05-23 11:02:58 -04:00
my @cmds = grep { /^test([0-9]+)$/ && -f "$TESTDIR/$_" } readdir(DIR);
closedir DIR;
$TESTCASES=""; # start with no test cases
# cut off everything but the digits
for(@cmds) {
$_ =~ s/[a-z\/\.]*//g;
}
# the the numbers from low to high
for(sort { $a <=> $b } @cmds) {
$TESTCASES .= " $_";
}
2000-11-13 11:06:16 -05:00
}
#######################################################################
# Start the command line log
#
open(CMDLOG, ">$CURLLOG") ||
print "can't log command lines to $CURLLOG\n";
#######################################################################
sub displaylogcontent {
my ($file)=@_;
open(SINGLE, "<$file");
while(<SINGLE>) {
print " $_";
}
close(SINGLE);
}
sub displaylogs {
my ($testnum)=@_;
opendir(DIR, "$LOGDIR") ||
die "can't open dir: $!";
my @logs = readdir(DIR);
closedir DIR;
my $log;
print "== Contents of files in the log/ dir after test $testnum\n";
foreach $log (sort @logs) {
# the log file is not "." or ".." and contains more than zero bytes
if(($log !~ /\.(\.|)$/) && -s "$LOGDIR/$log") {
print "== Start of file $log\n";
displaylogcontent("$LOGDIR/$log");
print "== End of file $log\n";
}
}
}
#######################################################################
# The main test-loop
#
my $failed;
2000-11-15 02:09:37 -05:00
my $testnum;
my $ok=0;
my $total=0;
my $lasttest;
2001-04-24 17:09:53 -04:00
2000-11-13 11:06:16 -05:00
foreach $testnum (split(" ", $TESTCASES)) {
$lasttest = $testnum if($testnum > $lasttest);
my $error = singletest($testnum);
if($error < 0) {
# not a test we can run
2001-04-24 17:09:53 -04:00
next;
}
$total++; # number of tests we've run
if($error>0) {
2001-05-23 11:02:58 -04:00
$failed.= "$testnum ";
if($postmortem) {
# display all files in log/ in a nice way
displaylogs($testnum);
}
if(!$anyway) {
# a test failed, abort
print "\n - abort tests\n";
last;
}
}
elsif(!$error) {
$ok++; # successful test counter
}
2000-11-13 11:06:16 -05:00
# loop for next test
}
#######################################################################
# Close command log
#
close(CMDLOG);
2000-11-13 11:06:16 -05:00
# Tests done, stop the servers
stopservers();
my $all = $total + $skipped;
if($total) {
printf("TESTDONE: $ok tests out of $total reported OK: %d%%\n",
$ok/$total*100);
if($ok != $total) {
print "TESTFAIL: These test cases failed: $failed\n";
}
}
else {
print "TESTFAIL: No tests were performed!\n";
}
if($all) {
print "TESTDONE: $all tests were considered.\n";
}
2001-04-24 17:09:53 -04:00
if($skipped) {
my $s=0;
print "TESTINFO: $skipped tests were skipped due to these restraints:\n";
for(keys %skipped) {
my $r = $_;
printf "TESTINFO: \"%s\" %d times (", $r, $skipped{$_};
# now show all test case numbers that had this reason for being
# skipped
my $c=0;
for(0 .. $lasttest) {
my $t = $_;
if($teststat[$_] eq $r) {
print ", " if($c);
print $_;
$c++;
}
}
print ")\n";
}
}
if($total && ($ok != $total)) {
exit 1;
}