mirrors/php-src
0
0
Fork 0
mirror of https://github.com/php/php-src.git synced 2024-12-26 10:19:53 +08:00
Code Issues Packages Projects Releases Wiki Activity
8dec06ea2a
php-src/server-tests.php
Sebastian Bergmann 9ba1e81665 sed -i "s#1997-2009#1997-2010#g" **/*.c **/*.h **/*.php
2010-01-03 09:23:27 +00:00

1569 lines
50 KiB
PHP
Executable File
Raw Blame History

<?php
/*
+----------------------------------------------------------------------+
| PHP Version 5 |
+----------------------------------------------------------------------+
| Copyright (c) 1997-2010 The PHP Group |
+----------------------------------------------------------------------+
| This source file is subject to version 3.01 of the PHP license, |
| that is bundled with this package in the file LICENSE, and is |
| available through the world-wide-web at the following url: |
| http://www.php.net/license/3_01.txt |
| If you did not receive a copy of the PHP license and are unable to |
| obtain it through the world-wide-web, please send a note to |
| license@php.net so we can mail you a copy immediately. |
+----------------------------------------------------------------------+
| Authors: Ilia Alshanetsky <ilia@php.net> |
| Preston L. Bannister <pbannister@php.net> |
| Marcus Boerger <helly@php.net> |
| Shane Caraveo <shane@php.net> |
| Derick Rethans <derick@php.net> |
| Sander Roobol <sander@php.net> |
| (based on version by: Stig Bakken <ssb@php.net>) |
| (based on the PHP 3 test framework by Rasmus Lerdorf) |
+----------------------------------------------------------------------+
*/
set_time_limit(0);
while(@ob_end_clean());
if (ob_get_level()) echo "Not all buffers were deleted.\n";
error_reporting(E_ALL);
/**********************************************************************
* QA configuration
*/
define('PHP_QA_EMAIL', 'qa-reports@lists.php.net');
define('QA_SUBMISSION_PAGE', 'http://qa.php.net/buildtest-process.php');
/**********************************************************************
* error messages
*/
define('PCRE_MISSING_ERROR',
'+-----------------------------------------------------------+
| ! ERROR ! |
| The test-suite requires that you have pcre extension |
| enabled. To enable this extension either compile your PHP |
| with --with-pcre-regex or if you have compiled pcre as a |
| shared module load it via php.ini. |
+-----------------------------------------------------------+');
define('SAFE_MODE_WARNING',
'+-----------------------------------------------------------+
| ! WARNING ! |
| You are running the test-suite with "safe_mode" ENABLED ! |
| |
| Chances are high that no test will work at all, |
| depending on how you configured "safe_mode" ! |
+-----------------------------------------------------------+');
define('TMP_MISSING',
'+-----------------------------------------------------------+
| ! ERROR ! |
| You must create /tmp for session tests to work! |
| |
+-----------------------------------------------------------+');
define('PROC_OPEN_MISSING',
'+-----------------------------------------------------------+
| ! ERROR ! |
| The test-suite requires that proc_open() is available. |
| Please check if you disabled it in php.ini. |
+-----------------------------------------------------------+');
define('REQ_PHP_VERSION',
'+-----------------------------------------------------------+
| ! ERROR ! |
| The test-suite must be run with PHP 5 or later. |
| You can still test older extecutables by setting |
| TEST_PHP_EXECUTABLE and running this script with PHP 5. |
+-----------------------------------------------------------+');
/**********************************************************************
* information scripts
*/
define('PHP_INFO_SCRIPT','<?php echo "
PHP_SAPI=" . PHP_SAPI . "
PHP_VERSION=" . phpversion() . "
ZEND_VERSION=" . zend_version() . "
PHP_OS=" . PHP_OS . "
INCLUDE_PATH=" . get_cfg_var("include_path") . "
INI=" . realpath(get_cfg_var("cfg_file_path")) . "
SCANNED_INI=" . (function_exists(\'php_ini_scanned_files\') ?
str_replace("\n","", php_ini_scanned_files()) :
"** not determined **") . "
SERVER_SOFTWARE=" . (isset($_ENV[\'SERVER_SOFTWARE\']) ? $_ENV[\'SERVER_SOFTWARE\'] : \'UNKNOWN\');
?>');
define('PHP_EXTENSIONS_SCRIPT','<?php print join(get_loaded_extensions(),":"); ?>');
define('PHP_INI_SETTINGS_SCRIPT','<?php echo serialize(ini_get_all()); ?>');
/**********************************************************************
* various utility functions
*/
function settings2array($settings, &$ini_settings)
{
foreach($settings as $setting) {
if (strpos($setting, '=')!==false) {
$setting = explode("=", $setting, 2);
$name = trim($setting[0]);
$value = trim($setting[1]);
$ini_settings[$name] = $value;
}
}
}
function settings2params(&$ini_settings)
{
$settings = '';
if (count($ini_settings)) {
foreach($ini_settings as $name => $value) {
$value = addslashes($value);
$settings .= " -d \"".strtolower($name)."=$value\"";
}
}
return $settings;
}
function generate_diff($wanted,$output)
{
$w = explode("\n", $wanted);
$o = explode("\n", $output);
$w1 = array_diff_assoc($w,$o);
$o1 = array_diff_assoc($o,$w);
$w2 = array();
$o2 = array();
foreach($w1 as $idx => $val) $w2[sprintf("%03d<",$idx)] = sprintf("%03d- ", $idx+1).$val;
foreach($o1 as $idx => $val) $o2[sprintf("%03d>",$idx)] = sprintf("%03d+ ", $idx+1).$val;
$diff = array_merge($w2, $o2);
ksort($diff);
return implode("\r\n", $diff);
}
function mkpath($path,$mode = 0777) {
$dirs = split('[\\/]',$path);
$path = $dirs[0];
for($i = 1;$i < count($dirs);$i++) {
$path .= '/'.$dirs[$i];
@mkdir($path,$mode);
}
}
function copyfiles($src,$new) {
$d = dir($src);
while (($entry = $d->read())) {
if (is_file("$src/$entry")) {
copy("$src/$entry", "$new/$entry");
}
}
$d->close();
}
function post_result_data($query,$data)
{
$url = QA_SUBMISSION_PAGE.'?'.$query;
$post = "php_test_data=" . urlencode(base64_encode(preg_replace("/[\\x00]/", "[0x0]", $data)));
$r = new HTTPRequest($url,NULL,NULL,$post);
return $this->response_headers['Status']=='200';
}
function execute($command, $args=NULL, $input=NULL, $cwd=NULL, $env=NULL)
{
$data = "";
if (gettype($args)=='array') {
$args = join($args,' ');
}
$commandline = "$command $args";
$proc = proc_open($commandline, array(
0 => array('pipe', 'r'),
1 => array('pipe', 'w')),
$pipes, $cwd, $env);
if (!$proc)
return false;
if ($input) {
$out = fwrite($pipes[0],$input);
if ($out != strlen($input)) {
return NULL;
}
}
fclose($pipes[0]);
while (true) {
/* hide errors from interrupted syscalls */
$r = $pipes;
$w = null;
$e = null;
$n = @stream_select($r, $w, $e, 60);
if ($n === 0) {
/* timed out */
$data .= "\n ** ERROR: process timed out **\n";
proc_terminate($proc);
return $data;
} else if ($n) {
$line = fread($pipes[1], 8192);
if (strlen($line) == 0) {
/* EOF */
break;
}
$data .= $line;
}
}
$code = proc_close($proc);
return $data;
}
function executeCode($php, $ini_overwrites, $code, $remove_headers=true, $cwd=NULL, $env=NULL)
{
$params = NULL;
if ($ini_overwrites) {
$info_params = array();
settings2array($ini_overwrites,$info_params);
$params = settings2params($info_params);
}
$out = execute($php, $params, $code, $cwd, $env);
// kill the headers
if ($remove_headers && preg_match("/^(.*?)\r?\n\r?\n(.*)/s", $out, $match)) {
$out = $match[2];
}
return $out;
}
/**********************************************************************
* a simple request class that lets us handle http based tests
*/
class HTTPRequest
{
public $headers = array();
public $timeout = 4;
public $urlparts = NULL;
public $url = '';
public $userAgent = 'PHP-Test-Harness';
public $options = array();
public $postdata = NULL;
public $errmsg = '';
public $errno = 0;
public $response;
public $response_headers;
public $outgoing_payload;
public $incoming_payload = '';
/*
URL is the full url
headers is assoc array of outgoing http headers
options may include
timeout
proxy_host
proxy_port
proxy_user
proxy_pass
method (GET|POST)
post data is, well, post data. It is not processed so
multipart stuff must be prepared before calling this
(or add it to class)
*/
function HTTPRequest($URL, $headers=array(), $options=array(), $postdata=NULL)
{
$this->urlparts = @parse_url($URL);
$this->url = $URL;
$this->options = $options;
$this->headers = $headers;
$this->postdata = &$postdata;
$this->doRequest();
}
function doRequest()
{
if (!$this->_validateUrl()) return;
if (isset($this->options['timeout']))
$this->timeout = (int)$this->options['timeout'];
$this->_sendHTTP();
}
function _validateUrl()
{
if ( ! is_array($this->urlparts) ) {
return FALSE;
}
if (!isset($this->urlparts['host'])) {
$this->urlparts['host']='127.0.0.1';
}
if (!isset($this->urlparts['port'])) {
$this->urlparts['port'] = 80;
}
if (!isset($this->urlparts['path']) || !$this->urlparts['path'])
$this->urlparts['path'] = '/';
return TRUE;
}
function _parseResponse()
{
if (preg_match("/^(.*?)\r?\n\r?\n(.*)/s", $this->incoming_payload, $match)) {
$this->response = $match[2];
if (preg_match("/^HTTP\/1\.. (\d+).*/s",$match[1],$status) && !$status[1]) {
$this->errmsg = "HTTP Response $status[1] Not Found";
return FALSE;
}
$rh = preg_split("/[\n\r]+/",$match[1]);
$this->response_headers = array();
foreach ($rh as $line) {
if (strpos($line, ':')!==false) {
$line = explode(":", $line, 2);
$this->response_headers[trim($line[0])] = trim($line[1]);
}
}
$this->response_headers['Status']=$status[1];
// if no content, return false
if(strlen($this->response) > 0) return TRUE;
}
$this->errmsg = 'Invalid HTTP Response';
return FALSE;
}
function &_getRequest()
{
$fullpath = $this->urlparts['path'].
(isset($this->urlparts['query'])?'?'.$this->urlparts['query']:'').
(isset($this->urlparts['fragment'])?'#'.$this->urlparts['fragment']:'');
if (isset($this->options['proxy_host'])) {
$fullpath = 'http://'.$this->urlparts['host'].':'.$this->urlparts['port'].$fullpath;
}
if (isset($this->options['proxy_user'])) {
$headers['Proxy-Authorization'] = 'Basic ' . base64_encode($this->options['proxy_user'].":".$this->options['proxy_pass']);
}
$headers['User-Agent'] = $this->userAgent;
$headers['Host'] = $this->urlparts['host'];
$headers['Content-Length'] = strlen($this->postdata);
$headers['Content-Type'] = 'application/x-www-form-urlencoded';
if (isset($this->headers)) {
$headers = array_merge($headers, $this->headers);
}
$headertext = '';
foreach ($headers as $k => $v) {
$headertext .= "$k: $v\r\n";
}
$method = trim($this->options['method'])?strtoupper(trim($this->options['method'])):'GET';
$this->outgoing_payload =
"$method $fullpath HTTP/1.0\r\n".
$headertext."\r\n".
$this->postdata;
return $this->outgoing_payload;
}
function &_sendHTTP()
{
$this->_getRequest();
$host = $this->urlparts['host'];
$port = $this->urlparts['port'];
if (isset($this->options['proxy_host'])) {
$host = $this->options['proxy_host'];
$port = isset($this->options['proxy_port'])?$this->options['proxy_port']:8080;
}
// send
if ($this->timeout > 0) {
$fp = fsockopen($host, $port, $this->errno, $this->errmsg, $this->timeout);
} else {
$fp = fsockopen($host, $port, $this->errno, $this->errmsg);
}
if (!$fp) {
$this->errmsg = "Connect Error to $host:$port";
return NULL;
}
if ($this->timeout > 0) {
// some builds of php do not support this, silence
// the warning
@socket_set_timeout($fp, $this->timeout);
}
if (!fputs($fp, $this->outgoing_payload, strlen($this->outgoing_payload))) {
$this->errmsg = "Error Sending Request Data to $host";
return NULL;
}
while ($data = fread($fp, 32768)) {
$this->incoming_payload .= $data;
}
fclose($fp);
$this->_parseResponse();
}
# a simple test case
#$r = new HTTPRequest('http://localhost:81/info.php/path/info');
#print_r($r->response_headers);
#print $r->response;
} // end HTTPRequest
/**********************************************************************
* main test harness
*/
class testHarness {
public $cwd;
public $xargs = array(
#arg env var value default description
'c' => array('' ,'file' ,NULL ,'configuration file, see server-tests-config.php for example'),
'd' => array('TEST_PATHS' ,'paths' ,NULL ,'colon seperate path list'),
'e' => array('TEST_PHP_ERROR_STYLE','EMACS|MSVC' ,'EMACS' ,'editor error style'),
'h' => array('' ,'' ,NULL ,'this help'),
'i' => array('PHPRC' ,'path|file' ,NULL ,'ini file to use for tests (sets PHPRC)'),
'l' => array('TEST_PHP_LOG_FORMAT' ,'string' ,'LEODC' ,'any combination of CDELO'),
'm' => array('TEST_BASE_PATH' ,'path' ,NULL ,'copy tests to this path before testing'),
'n' => array('NO_PHPTEST_SUMMARY' ,'' ,0 ,'do not print test summary'),
'p' => array('TEST_PHP_EXECUTABLE' ,'path' ,NULL ,'php executable to be tested'),
'q' => array('NO_INTERACTION' ,'' ,0 ,'no console interaction (ie dont contact QA)'),
'r' => array('REPORT_EXIT_STATUS' ,'' ,0 ,'exit with status at end of execution'),
's' => array('TEST_PHP_SRCDIR' ,'path' ,NULL ,'path to php source code'),
't' => array('TEST_PHP_DETAILED' ,'number' ,0 ,'level of detail output to dump'),
'u' => array('TEST_WEB_BASE_URL' ,'url' ,'' ,'base url for http testing'),
'v' => array('TEST_CONTEXT_INFO' ,'' ,0 ,'view text executable context info'),
'w' => array('TEST_WEB' ,'' ,0 ,'run tests via http'),
'x' => array('TEST_WEB_EXT' ,'file ext' ,'php' ,'http file extension to use')
);
public $conf = array();
public $test_to_run = array();
public $test_files = array();
public $test_results = array();
public $failed_tests = array();
public $exts_to_test;
public $exts_tested = 0;
public $exts_skipped = 0;
public $ignored_by_ext = 0;
public $test_dirs = array('tests', 'pear', 'ext', 'sapi');
public $start_time;
public $end_time;
public $exec_info;
public $test_executable_iscgi = false;
public $inisettings; // the test executables settings, used for web tests
public $iswin32 = false;
public $ddash = "=====================================================================";
public $sdash = "---------------------------------------------------------------------";
// Default ini settings
public $ini_overwrites = array(
'output_handler'=>'',
'zlib.output_compression'=>'Off',
'open_basedir'=>'',
'safe_mode'=>'0',
'disable_functions'=>'',
'output_buffering'=>'Off',
'error_reporting'=>'4095',
'display_errors'=>'1',
'log_errors'=>'0',
'html_errors'=>'0',
'track_errors'=>'1',
'report_memleaks'=>'1',
'report_zend_debug'=>'0',
'docref_root'=>'/phpmanual/',
'docref_ext'=>'.html',
'error_prepend_string'=>'',
'error_append_string'=>'',
'auto_prepend_file'=>'',
'auto_append_file'=>'',
'magic_quotes_runtime'=>'0',
);
public $env = array();
public $info_params = array();
function testHarness() {
$this->iswin32 = substr(PHP_OS, 0, 3) == "WIN";
$this->checkRequirements();
$this->env = $_ENV;
$this->removeSensitiveEnvVars();
$this->initializeConfiguration();
$this->parseArgs();
$this->setTestPaths();
# change to working directory
if ($this->conf['TEST_PHP_SRCDIR']) {
@chdir($this->conf['TEST_PHP_SRCDIR']);
}
$this->cwd = getcwd();
if (!$this->conf['TEST_PHP_SRCDIR'])
$this->conf['TEST_PHP_SRCDIR'] = $this->cwd;
if (!$this->conf['TEST_BASE_PATH'] && $this->conf['TEST_PHP_SRCDIR'])
$this->conf['TEST_BASE_PATH'] = $this->conf['TEST_PHP_SRCDIR'];
if ($this->iswin32) {
$this->conf['TEST_PHP_SRCDIR'] = str_replace('/','\\',$this->conf['TEST_PHP_SRCDIR']);
$this->conf['TEST_BASE_PATH'] = str_replace('/','\\',$this->conf['TEST_BASE_PATH']);
}
if (!$this->conf['TEST_WEB'] && !is_executable($this->conf['TEST_PHP_EXECUTABLE'])) {
$this->error("invalid PHP executable specified by TEST_PHP_EXECUTABLE = " .
$this->conf['TEST_PHP_EXECUTABLE']);
return false;
}
$this->getInstalledExtensions();
$this->getExecutableInfo();
$this->getExecutableIniSettings();
$this->test_executable_iscgi = strncmp($this->exec_info['PHP_SAPI'],'cgi',3)==0;
$this->calculateDocumentRoot();
// add TEST_PHP_SRCDIR to the include path, this facilitates
// tests including files from src/tests
//$this->ini_overwrites['include_path'] = $this->cwd.($this->iswin32?';.;':':.:').$this->exec_info['INCLUDE_PATH'];
$params = array();
settings2array($this->ini_overwrites,$params);
$this->info_params = settings2params($params);
$this->contextHeader();
if ($this->conf['TEST_CONTEXT_INFO']) return;
$this->loadFileList();
$this->moveTestFiles();
$this->run();
$this->summarizeResults();
}
function getExecutableIniSettings()
{
$out = $this->runscript(PHP_INI_SETTINGS_SCRIPT,true);
$this->inisettings = unserialize($out);
}
function getExecutableInfo()
{
$out = $this->runscript(PHP_INFO_SCRIPT,true);
$out = preg_split("/[\n\r]+/",$out);
$info = array();
foreach ($out as $line) {
if (strpos($line, '=')!==false) {
$line = explode("=", $line, 2);
$name = trim($line[0]);
$value = trim($line[1]);
$info[$name] = $value;
}
}
$this->exec_info = $info;
}
function getInstalledExtensions()
{
// get the list of installed extensions
$out = $this->runscript(PHP_EXTENSIONS_SCRIPT,true);
$this->exts_to_test = split(":",$out);
sort($this->exts_to_test);
$this->exts_tested = count($this->exts_to_test);
}
// if running local, calls executeCode,
// otherwise does an http request
function runscript($script,$removeheaders=false,$cwd=NULL)
{
if ($this->conf['TEST_WEB']) {
$pi = '/testscript.' . $this->conf['TEST_WEB_EXT'];
if (!$cwd) $cwd = $this->conf['TEST_BASE_PATH'];
$tmp_file = "$cwd$pi";
$pi = substr($cwd,strlen($this->conf['TEST_BASE_PATH'])) . $pi;
$url = $this->conf['TEST_WEB_BASE_URL'] . $pi;
file_put_contents($tmp_file,$script);
$fd = fopen($url, "rb");
$out = '';
if ($fd) {
while (!feof($fd))
$out .= fread($fd, 8192);
fclose($fd);
}
unlink($tmp_file);
if (0 && $removeheaders &&
preg_match("/^(.*?)\r?\n\r?\n(.*)/s", $out, $match)) {
return $match[2];
}
return $out;
} else {
return executeCode($this->conf['TEST_PHP_EXECUTABLE'],$this->ini_overwrites, $script,$removeheaders,$cwd,$this->env);
}
}
// Use this function to do any displaying of text, so that
// things can be over-written as necessary.
function writemsg($msg) {
echo $msg;
}
// Another wrapper function, this one should be used any time
// a particular test passes or fails
function showstatus($item, $status, $reason = '') {
switch($status) {
case 'PASSED':
$this->writemsg("PASSED: $item ($reason)\n");
break;
case 'FAILED':
$this->writemsg("FAILED: $item ($reason)\n");
break;
case 'SKIPPED':
$this->writemsg("SKIPPED: $item ($reason)\n");
break;
}
}
function help()
{
$usage = "usage: php run-tests.php [options]\n";
foreach ($this->xargs as $arg=>$arg_info) {
$usage .= sprintf(" -%s %-12s %s\n",$arg,$arg_info[1],$arg_info[3]);
}
return $usage;
}
function parseArgs() {
global $argc;
global $argv;
global $_SERVER;
if (!isset($argv)) {
$argv = $_SERVER['argv'];
$argc = $_SERVER['argc'];
}
$conf = NULL;
for ($i=1; $i<$argc;) {
if ($argv[$i][0] != '-') continue;
$opt = $argv[$i++][1];
if (isset($value)) unset($value);
if (@$argv[$i][0] != '-') {
@$value = $argv[$i++];
}
switch($opt) {
case 'c':
/* TODO: Implement configuraiton file */
include($value);
if (!isset($conf)) {
$this->writemsg("Invalid configuration file\n");
exit(1);
}
$this->conf = array_merge($this->conf,$conf);
break;
case 'e':
$this->conf['TEST_PHP_ERROR_STYLE'] = strtoupper($value);
break;
case 'h':
print $this->help();
exit(0);
default:
if ($this->xargs[$opt][1] && isset($value))
$this->conf[$this->xargs[$opt][0]] = $value;
else if (!$this->xargs[$opt][1])
$this->conf[$this->xargs[$opt][0]] = isset($value)?$value:1;
else
$this->error("Invalid argument setting for argument $opt, should be [{$this->xargs[$opt][1]}]\n");
break;
}
}
// set config into environment, this allows
// executed tests to find out about the test
// configurations. config file or args overwrite
// env var config settings
$this->env = array_merge($this->env,$this->conf);
if (!$this->conf['TEST_WEB'] && !$this->conf['TEST_PHP_EXECUTABLE']) {
$this->writemsg($this->help());
exit(0);
}
}
function removeSensitiveEnvVars()
{
# delete sensitive env vars
$this->env['SSH_CLIENT']='deleted';
$this->env['SSH_AUTH_SOCK']='deleted';
$this->env['SSH_TTY']='deleted';
}
function setEnvConfigVar($name)
{
if (isset($this->env[$name])) {
$this->conf[$name] = $this->env[$name];
}
}
function initializeConfiguration()
{
foreach ($this->xargs as $arg=>$arg_info) {
if ($arg_info[0]) {
# initialize the default setting
$this->conf[$arg_info[0]]=$arg_info[2];
# get config from environment
$this->setEnvConfigVar($arg_info[0]);
}
}
}
function setTestPaths()
{
// configure test paths from config file or command line
if (@$this->conf['TEST_PATHS']) {
$this->test_dirs = array();
if ($this->iswin32) {
$paths = split(';',$this->conf['TEST_PATHS']);
} else {
$paths = split(':|;',$this->conf['TEST_PATHS']);
}
foreach($paths as $path) {
$this->test_dirs[] = realpath($path);
}
}
}
function test_sort($a, $b) {
$ta = strpos($a, "{$this->cwd}/tests")===0 ? 1 + (strpos($a, "{$this->cwd}/tests/run-test")===0 ? 1 : 0) : 0;
$tb = strpos($b, "{$this->cwd}/tests")===0 ? 1 + (strpos($b, "{$this->cwd}/tests/run-test")===0 ? 1 : 0) : 0;
if ($ta == $tb) {
return strcmp($a, $b);
} else {
return $tb - $ta;
}
}
function checkRequirements() {
if (version_compare(phpversion(), "5.0") < 0) {
$this->writemsg(REQ_PHP_VERSION);
exit;
}
// We might want to check another server so we won't see that server's /tmp
// if (!file_exists("/tmp")) {
// $this->writemsg(TMP_MISSING);
// exit;
// }
if (!function_exists("proc_open")) {
$this->writemsg(PROC_OPEN_MISSING);
exit;
}
if (!extension_loaded("pcre")) {
$this->writemsg(PCRE_MISSING_ERROR);
exit;
}
if (ini_get('safe_mode')) {
$this->writemsg(SAFE_MODE_WARNING);
}
}
//
// Write test context information.
//
function contextHeader()
{
$info = '';
foreach ($this->exec_info as $k=>$v) {
$info .= sprintf("%-20.s: %s\n",$k,$v);
}
$exts = '';
foreach ($this->exts_to_test as $ext) {
$exts .="$ext\n ";
}
$dirs = '';
foreach ($this->test_dirs as $test_dir) {
$dirs .= "$test_dir\n ";
}
$conf = '';
foreach ($this->conf as $k=>$v) {
$conf .= sprintf("%-20.s: %s\n",$k,$v);
}
$exeinfo = '';
if (!$this->conf['TEST_WEB'])
$exeinfo = "CWD : {$this->cwd}\n".
"PHP : {$this->conf['TEST_PHP_EXECUTABLE']}\n";
$this->writemsg("\n$this->ddash\n".
"$exeinfo$info\n".
"Test Harness Configuration:\n$conf\n".
"Extensions : $exts\n".
"Test Dirs : $dirs\n".
"$this->ddash\n");
}
function loadFileList()
{
foreach ($this->test_dirs as $dir) {
if (is_dir($dir)) {
$this->findFilesInDir($dir, ($dir == 'ext'));
} else {
$this->test_files[] = $dir;
}
}
usort($this->test_files,array($this,"test_sort"));
$this->writemsg("found ".count($this->test_files)." files\n");
}
function moveTestFiles()
{
if (!$this->conf['TEST_BASE_PATH'] ||
$this->conf['TEST_BASE_PATH'] == $this->conf['TEST_PHP_SRCDIR']) return;
$this->writemsg("moving files from {$this->conf['TEST_PHP_SRCDIR']} to {$this->conf['TEST_BASE_PATH']}\n");
$l = strlen($this->conf['TEST_PHP_SRCDIR']);
$files = array();
$dirs = array();
foreach ($this->test_files as $file) {
if (strpos($file,$this->conf['TEST_PHP_SRCDIR'])==0) {
$newlocation = $this->conf['TEST_BASE_PATH'].substr($file,$l);
$files[] = $newlocation;
$dirs[dirname($file)] = dirname($newlocation);
} else {
// XXX what to do with test files outside the
// php source directory? Need to map them into
// the new directory somehow.
}
}
foreach ($dirs as $src=>$new) {
mkpath($new);
copyfiles($src,$new);
}
$this->test_files = $files;
}
function findFilesInDir($dir,$is_ext_dir=FALSE,$ignore=FALSE)
{
$skip = array('.', '..', 'CVS');
$o = opendir($dir) or $this->error("cannot open directory: $dir");
while (($name = readdir($o)) !== FALSE) {
if (in_array($name, $skip)) continue;
if (is_dir("$dir/$name")) {
$skip_ext = ($is_ext_dir && !in_array($name, $this->exts_to_test));
if ($skip_ext) {
$this->exts_skipped++;
}
$this->findFilesInDir("$dir/$name", FALSE, $ignore || $skip_ext);
}
// Cleanup any left-over tmp files from last run.
if (substr($name, -4) == '.tmp') {
@unlink("$dir/$name");
continue;
}
// Otherwise we're only interested in *.phpt files.
if (substr($name, -5) == '.phpt') {
if ($ignore) {
$this->ignored_by_ext++;
} else {
$testfile = realpath("$dir/$name");
$this->test_files[] = $testfile;
}
}
}
closedir($o);
}
function runHeader()
{
$this->writemsg("TIME START " . date('Y-m-d H:i:s', $this->start_time) . "\n".$this->ddash."\n");
if (count($this->test_to_run)) {
$this->writemsg("Running selected tests.\n");
} else {
$this->writemsg("Running all test files.\n");
}
}
function run()
{
$this->start_time = time();
$this->runHeader();
// Run selected tests.
if (count($this->test_to_run)) {
foreach($this->test_to_run as $name=>$runnable) {
if(!preg_match("/\.phpt$/", $name))
continue;
if ($runnable) {
$this->test_results[$name] = $this->run_test($name);
}
}
} else {
foreach ($this->test_files as $name) {
$this->test_results[$name] = $this->run_test($name);
}
}
$this->end_time = time();
}
function summarizeResults()
{
if (count($this->test_results) == 0) {
$this->writemsg("No tests were run.\n");
return;
}
$n_total = count($this->test_results);
$n_total += $this->ignored_by_ext;
$sum_results = array('PASSED'=>0, 'SKIPPED'=>0, 'FAILED'=>0);
foreach ($this->test_results as $v) {
$sum_results[$v]++;
}
$sum_results['SKIPPED'] += $this->ignored_by_ext;
$percent_results = array();
while (list($v,$n) = each($sum_results)) {
$percent_results[$v] = (100.0 * $n) / $n_total;
}
$this->writemsg("\n".$this->ddash."\n".
"TIME END " . date('Y-m-d H:i:s', $this->end_time) . "\n".
$this->ddash."\n".
"TEST RESULT SUMMARY\n".
$this->sdash."\n".
"Exts skipped : " . sprintf("%4d",$this->exts_skipped) . "\n".
"Exts tested : " . sprintf("%4d",$this->exts_tested) . "\n".
$this->sdash."\n".
"Number of tests : " . sprintf("%4d",$n_total) . "\n".
"Tests skipped : " . sprintf("%4d (%2.1f%%)",$sum_results['SKIPPED'],$percent_results['SKIPPED']) . "\n".
"Tests failed : " . sprintf("%4d (%2.1f%%)",$sum_results['FAILED'],$percent_results['FAILED']) . "\n".
"Tests passed : " . sprintf("%4d (%2.1f%%)",$sum_results['PASSED'],$percent_results['PASSED']) . "\n".
$this->sdash."\n".
"Time taken : " . sprintf("%4d seconds", $this->end_time - $this->start_time) . "\n".
$this->ddash."\n");
$failed_test_summary = '';
if ($this->failed_tests) {
$failed_test_summary .= "\n".$this->ddash."\n".
"FAILED TEST SUMMARY\n".$this->sdash."\n";
foreach ($this->failed_tests as $failed_test_data) {
$failed_test_summary .= $failed_test_data['test_name'] . "\n";
}
$failed_test_summary .= $this->ddash."\n";
}
if ($failed_test_summary && !$this->conf['NO_PHPTEST_SUMMARY']) {
$this->writemsg($failed_test_summary);
}
/* We got failed Tests, offer the user to send and e-mail to QA team, unless NO_INTERACTION is set */
if ($sum_results['FAILED'] && !$this->conf['NO_INTERACTION']) {
$fp = fopen("php://stdin", "r+");
$this->writemsg("\nPlease allow this report to be send to the PHP QA\nteam. This will give us a better understanding in how\n");
$this->writemsg("PHP's test cases are doing.\n");
$this->writemsg("(choose \"s\" to just save the results to a file)? [Yns]: ");
flush();
$user_input = fgets($fp, 10);
$just_save_results = (strtolower($user_input[0]) == 's');
if ($just_save_results || strlen(trim($user_input)) == 0 || strtolower($user_input[0]) == 'y') {
/*
* Collect information about the host system for our report
* Fetch phpinfo() output so that we can see the PHP enviroment
* Make an archive of all the failed tests
* Send an email
*/
/* Ask the user to provide an email address, so that QA team can contact the user */
if (!strncasecmp($user_input, 'y', 1) || strlen(trim($user_input)) == 0) {
echo "\nPlease enter your email address.\n(Your address will be mangled so that it will not go out on any\nmailinglist in plain text): ";
flush();
$fp = fopen("php://stdin", "r+");
$user_email = trim(fgets($fp, 1024));
$user_email = str_replace("@", " at ", str_replace(".", " dot ", $user_email));
}
$failed_tests_data = '';
$sep = "\n" . str_repeat('=', 80) . "\n";
$failed_tests_data .= $failed_test_summary . "\n";
if (array_sum($this->failed_tests)) {
foreach ($this->failed_tests as $test_info) {
$failed_tests_data .= $sep . $test_info['name'];
$failed_tests_data .= $sep . file_get_contents(realpath($test_info['output']));
$failed_tests_data .= $sep . file_get_contents(realpath($test_info['diff']));
$failed_tests_data .= $sep . "\n\n";
}
$status = "failed";
} else {
$status = "success";
}
$failed_tests_data .= "\n" . $sep . 'BUILD ENVIRONMENT' . $sep;
$failed_tests_data .= "OS:\n". PHP_OS. "\n\n";
$automake = $autoconf = $libtool = $compiler = 'N/A';
if (!$this->iswin32) {
$automake = shell_exec('automake --version');
$autoconf = shell_exec('autoconf --version');
/* Always use the generated libtool - Mac OSX uses 'glibtool' */
$libtool = shell_exec('./libtool --version');
/* Try the most common flags for 'version' */
$flags = array('-v', '-V', '--version');
$cc_status=0;
foreach($flags AS $flag) {
system($this->env['CC']." $flag >/dev/null 2>&1", $cc_status);
if($cc_status == 0) {
$compiler = shell_exec($this->env['CC']." $flag 2>&1");
break;
}
}
}
$failed_tests_data .= "Automake:\n$automake\n";
$failed_tests_data .= "Autoconf:\n$autoconf\n";
$failed_tests_data .= "Libtool:\n$libtool\n";
$failed_tests_data .= "Compiler:\n$compiler\n";
$failed_tests_data .= "Bison:\n". @shell_exec('bison --version'). "\n";
$failed_tests_data .= "\n\n";
if (isset($user_email)) {
$failed_tests_data .= "User's E-mail: ".$user_email."\n\n";
}
$failed_tests_data .= $sep . "PHPINFO" . $sep;
$failed_tests_data .= shell_exec($this->conf['TEST_PHP_EXECUTABLE'].' -dhtml_errors=0 -i');
$compression = 0;
if ($just_save_results ||
!post_result_data("status=$status&version=".urlencode(TESTED_PHP_VERSION),$failed_tests_data)) {
$output_file = 'php_test_results_' . date('Ymd_Hi') . ( $compression ? '.txt.gz' : '.txt' );
$fp = fopen($output_file, "w");
fwrite($fp, $failed_tests_data);
fclose($fp);
if (!$just_save_results)
echo "\nThe test script was unable to automatically send the report to PHP's QA Team\n";
echo "Please send ".$output_file." to ".PHP_QA_EMAIL." manually, thank you.\n";
} else {
fwrite($fp, "\nThank you for helping to make PHP better.\n");
fclose($fp);
}
}
}
if($this->conf['REPORT_EXIT_STATUS'] and $sum_results['FAILED']) {
exit(1);
}
}
function getINISettings(&$section_text)
{
$ini_settings = $this->ini_overwrites;
// Any special ini settings
// these may overwrite the test defaults...
if (array_key_exists('INI', $section_text)) {
settings2array(preg_split( "/[\n\r]+/", $section_text['INI']), $ini_settings);
}
return $ini_settings;
}
function getINIParams(&$section_text)
{
if (!$section_text) return '';
// XXX php5 current has a problem doing this in one line
// it fails with Only variables can be passed by reference
// on test ext\calendar\tests\jdtojewish.phpt
// return settings2params($this->getINISettings($section_text));
$ini = $this->getINISettings($section_text);
return settings2params($ini);
}
function calculateDocumentRoot()
{
if ($this->conf['TEST_WEB'] || $this->test_executable_iscgi) {
// configure DOCUMENT_ROOT for web tests
// this assumes that directories from the base url
// matches directory depth from the base path
$parts = parse_url($this->conf['TEST_WEB_BASE_URL']);
$depth = substr_count($parts['path'],'/');
$docroot = $this->conf['TEST_BASE_PATH'];
for ($i=0 ; $i < $depth; $i++) $docroot = dirname($docroot);
$this->conf['TEST_DOCUMENT_ROOT']=$docroot;
$this->conf['TEST_BASE_SCRIPT_NAME']=$parts['path'];
$this->conf['TEST_SERVER_URL']=substr($this->conf['TEST_WEB_BASE_URL'],0,strlen($this->conf['TEST_WEB_BASE_URL'])-strlen($parts['path']));
} else {
$this->conf['TEST_DOCUMENT_ROOT']='';
$this->conf['TEST_BASE_SCRIPT_NAME']='';
$this->conf['TEST_SERVER_URL']='';
}
}
function evalSettings($filename,$data) {
// we eval the section so we can allow dynamic env vars
// for cgi testing
$filename = str_replace('\\','/',$filename);
$cwd = str_replace('\\','/',$this->cwd);
$filepath = dirname($filename);
$scriptname = substr($filename,strlen($this->conf['TEST_DOCUMENT_ROOT']));
// eval fails if no newline
return eval("$data\n");
}
function getENVSettings(&$section_text,$testfile)
{
$env = $this->env;
// Any special environment settings
// these may overwrite the test defaults...
if (array_key_exists('ENV', $section_text)) {
$sect = $this->evalSettings($testfile,$section_text['ENV']);
//print "data evaled:\n$sect\n";
settings2array(preg_split( "/[\n\r]+/", $sect), $env);
}
return $env;
}
function getEvalTestSettings($section_text,$testfile)
{
$rq = array();
// Any special environment settings
// these may overwrite the test defaults...
if ($section_text) {
$sect = $this->evalSettings($testfile,$section_text);
//print "data evaled:\n$sect\n";
settings2array(preg_split( "/[\n\r]+/", $sect), $rq);
}
return $rq;
}
//
// Load the sections of the test file.
//
function getSectionText($file)
{
// Load the sections of the test file.
$section_text = array(
'TEST' => '(unnamed test)',
'SKIPIF' => '',
'GET' => '',
'ARGS' => '',
'_FILE' => $file,
'_DIR' => realpath(dirname($file)),
);
$fp = @fopen($file, "r")
or $this->error("Cannot open test file: $file");
$section = '';
while (!feof($fp)) {
$line = fgets($fp);
// Match the beginning of a section.
if (ereg('^--([A-Z]+)--',$line,$r)) {
$section = $r[1];
$section_text[$section] = '';
continue;
}
// Add to the section text.
$section_text[$section] .= $line;
}
fclose($fp);
foreach ($section_text as $k=>$v) {
// for POST data ,we only want to trim the last new line!
if ($k == 'POST' && preg_match('/^(.*?)\r?\n$/Ds',$v,$matches)) {
$section_text[$k]=$matches[1];
} else {
$section_text[$k]=trim($v);
}
}
return $section_text;
}
//
// Check if test should be skipped.
//
function getSkipReason($file,&$section_text,$docgi=false)
{
// if the test uses POST or GET, and it's not the cgi
// executable, skip
if ($docgi && !$this->conf['TEST_WEB'] && !$this->test_executable_iscgi) {
$this->showstatus($section_text['TEST'], 'SKIPPED', 'CGI Test needs CGI Binary');
return "SKIPPED";
}
// if we're doing web testing, then we wont be able to set
// ini setting on the command line. be sure the executables
// ini settings are compatible with the test, or skip
if (($docgi || $this->conf['TEST_WEB']) &&
isset($section_text['INI']) && $section_text['INI']) {
$settings = $this->getINISettings($section_text);
foreach ($settings as $k=>$v) {
if (strcasecmp($v,'off')==0 || !$v) $v='';
$haveval = isset($this->inisettings[$k]['local_value']);
if ($k == 'include_path') {
// we only want to know that src directory
// is in the include path
if (strpos($this->inisettings[$k]['local_value'],$this->cwd))
continue;
}
if (($haveval && $this->inisettings[$k]['local_value'] != $v) || (!$haveval && $v)) {
$this->showstatus($section_text['TEST'], 'SKIPPED', "Test requires ini setting $k=[$v], not [".($haveval?$this->inisettings[$k]['local_value']:'')."]");
return "SKIPPED";
}
}
}
// now handle a SKIPIF section
if ($section_text['SKIPIF']) {
$output = trim($this->runscript($section_text['SKIPIF'],$this->test_executable_iscgi,realpath(dirname($file))),true);
if (!$output) return NULL;
if ($this->conf['TEST_PHP_DETAILED'] > 2)
print "SKIPIF: [$output]\n";
if (eregi("^skip", $output)){
$reason = (ereg("^skip[[:space:]]*(.+)\$", $output)) ? ereg_replace("^skip[[:space:]]*(.+)\$", "\\1", $output) : FALSE;
$this->showstatus($section_text['TEST'], 'SKIPPED', $reason);
return 'SKIPPED';
}
if (eregi("^info", $output)) {
$reason = (ereg("^info[[:space:]]*(.+)\$", $output)) ? ereg_replace("^info[[:space:]]*(.+)\$", "\\1", $output) : FALSE;
if ($reason) {
$tested .= " (info: $reason)";
}
}
}
return NULL;
}
//
// Run an individual test case.
//
function run_test($file)
{
if ($this->conf['TEST_PHP_DETAILED'])
$this->writemsg("\n=================\nTEST $file\n");
$section_text = $this->getSectionText($file);
if ($this->iswin32)
$shortname = str_replace($this->conf['TEST_BASE_PATH'].'\\', '', $file);
else
$shortname = str_replace($this->conf['TEST_BASE_PATH'].'/', '', $file);
$tested = $section_text['TEST']." [$shortname]";
if ($this->conf['TEST_WEB']) {
$tmp_file = ereg_replace('\.phpt$','.'.$this->conf['TEST_WEB_EXT'],$file);
$uri = $this->conf['TEST_BASE_SCRIPT_NAME'].str_replace($this->conf['TEST_BASE_PATH'], '', $tmp_file);
$uri = str_replace('\\', '/', $uri);
} else {
$tmp_file = ereg_replace('\.phpt$','.php',$file);
}
@unlink($tmp_file);
// unlink old test results
@unlink(ereg_replace('\.phpt$','.diff',$file));
@unlink(ereg_replace('\.phpt$','.log',$file));
@unlink(ereg_replace('\.phpt$','.exp',$file));
@unlink(ereg_replace('\.phpt$','.out',$file));
if (!$this->conf['TEST_WEB']) {
// Reset environment from any previous test.
$env = $this->getENVSettings($section_text,$tmp_file);
$ini_overwrites = $this->getINIParams($section_text);
}
// if this is a cgi test, prepare for it
$query_string = '';
$havepost = array_key_exists('POST', $section_text) && !empty($section_text['POST']);
// allow empty query_string requests
$haveget = array_key_exists('GET', $section_text) && !empty($section_text['GET']);
$do_cgi = array_key_exists('CGI', $section_text) || $haveget || $havepost;
$skipreason = $this->getSkipReason($file,$section_text,$do_cgi);
if ($skipreason == 'SKIPPED') {
return $skipreason;
}
// We've satisfied the preconditions - run the test!
file_put_contents($tmp_file,$section_text['FILE']);
$post = NULL;
$args = "";
$headers = array();
if ($this->conf['TEST_WEB']) {
$request = $this->getEvalTestSettings(@$section_text['REQUEST'],$tmp_file);
$headers = $this->getEvalTestSettings(@$section_text['HEADERS'],$tmp_file);
$method = isset($request['method'])?$request['method']:$havepost?'POST':'GET';
$query_string = $haveget?$section_text['GET']:'';
$options = array();
$options['method']=$method;
if (isset($this->conf['timeout'])) $options['timeout'] = $this->conf['timeout'];
if (isset($this->conf['proxy_host'])) $options['proxy_host'] = $this->conf['proxy_host'];
if (isset($this->conf['proxy_port'])) $options['proxy_port'] = $this->conf['proxy_port'];
if (isset($this->conf['proxy_user'])) $options['proxy_user'] = $this->conf['proxy_user'];
if (isset($this->conf['proxy_pass'])) $options['proxy_pass'] = $this->conf['proxy_pass'];
$post = $havepost?$section_text['POST']:NULL;
$url = $this->conf['TEST_SERVER_URL'];
if (isset($request['SCRIPT_NAME']))
$url .= $request['SCRIPT_NAME'];
else
$url .= $uri;
if (isset($request['PATH_INFO']))
$url .= $request['PATH_INFO'];
if (isset($request['FRAGMENT']))
$url .= '#'.$request['FRAGMENT'];
if (isset($request['QUERY_STRING']))
$query_string = $request['QUERY_STRING'];
if ($query_string)
$url .= '?'.$query_string;
if ($this->conf['TEST_PHP_DETAILED'])
$this->writemsg("\nURL = $url\n");
} else if ($do_cgi) {
$query_string = $haveget?$section_text['GET']:'';
if (!array_key_exists('GATEWAY_INTERFACE', $env))
$env['GATEWAY_INTERFACE']='CGI/1.1';
if (!array_key_exists('SERVER_SOFTWARE', $env))
$env['SERVER_SOFTWARE']='PHP Test Harness';
if (!array_key_exists('SERVER_SOFTWARE', $env))
$env['SERVER_NAME']='127.0.0.1';
if (!array_key_exists('REDIRECT_STATUS', $env))
$env['REDIRECT_STATUS']='200';
if (!array_key_exists('SERVER_NAME', $env))
$env['QUERY_STRING']=$query_string;
if (!array_key_exists('PATH_TRANSLATED', $env) &&
!array_key_exists('SCRIPT_FILENAME', $env)) {
$env['PATH_TRANSLATED']=$tmp_file;
$env['SCRIPT_FILENAME']=$tmp_file;
}
if (!array_key_exists('PATH_TRANSLATED', $env))
$env['PATH_TRANSLATED']='';
if (!array_key_exists('PATH_INFO', $env))
$env['PATH_INFO']='';
if (!array_key_exists('SCRIPT_NAME', $env))
$env['SCRIPT_NAME']='';
if (!array_key_exists('SCRIPT_FILENAME', $env))
$env['SCRIPT_FILENAME']='';
if (array_key_exists('POST', $section_text) && (!$haveget || !empty($section_text['POST']))) {
$post = $section_text['POST'];
$content_length = strlen($post);
if (!array_key_exists('REQUEST_METHOD', $env))
$env['REQUEST_METHOD']='POST';
if (!array_key_exists('CONTENT_TYPE', $env))
$env['CONTENT_TYPE']='application/x-www-form-urlencoded';
if (!array_key_exists('CONTENT_LENGTH', $env))
$env['CONTENT_LENGTH']=$content_length;
} else {
if (!array_key_exists('REQUEST_METHOD', $env))
$env['REQUEST_METHOD']='GET';
if (!array_key_exists('CONTENT_TYPE', $env))
$env['CONTENT_TYPE']='';
if (!array_key_exists('CONTENT_LENGTH', $env))
$env['CONTENT_LENGTH']='';
}
if ($this->conf['TEST_PHP_DETAILED'] > 1)
$this->writemsg("\nCONTENT_LENGTH = " . $env['CONTENT_LENGTH'] .
"\nCONTENT_TYPE = " . $env['CONTENT_TYPE'] .
"\nPATH_TRANSLATED = " . $env['PATH_TRANSLATED'] .
"\nPATH_INFO = " . $env['PATH_INFO'] .
"\nQUERY_STRING = " . $env['QUERY_STRING'] .
"\nREDIRECT_STATUS = " . $env['REDIRECT_STATUS'] .
"\nREQUEST_METHOD = " . $env['REQUEST_METHOD'] .
"\nSCRIPT_NAME = " . $env['SCRIPT_NAME'] .
"\nSCRIPT_FILENAME = " . $env['SCRIPT_FILENAME'] . "\n");
/* not cgi spec to put query string on command line,
but used by a couple tests to catch a security hole
in older php versions. At least IIS can be configured
to do this. */
$args = $env['QUERY_STRING'];
$args = "$ini_overwrites $tmp_file \"$args\" 2>&1";
} else {
$args = $section_text['ARGS'] ? $section_text['ARGS'] : '';
$args = "$ini_overwrites $tmp_file $args 2>&1";
}
if ($this->conf['TEST_WEB']) {
// we want headers also, so fopen
$r = new HTTPRequest($url,$headers,$options,$post);
//$out = preg_replace("/\r\n/","\n",$r->response);
$out = $r->response;
$headers = $r->response_headers;
//print $r->outgoing_payload."\n";
//print $r->incoming_payload."\n";
} else {
$out = execute($this->conf['TEST_PHP_EXECUTABLE'],$args,$post,$this->cwd,$env);
// if this is a cgi, remove the headers first
if ($this->test_executable_iscgi
&& preg_match("/^(.*?)\r?\n\r?\n(.*)/s", $out, $match)) {
$out = $match[2];
$rh = preg_split("/[\n\r]+/",$match[1]);
$headers = array();
foreach ($rh as $line) {
if (strpos($line, ':')!==false) {
$line = explode(":", $line, 2);
$headers[trim($line[0])] = trim($line[1]);
}
}
}
}
if ($this->conf['TEST_PHP_DETAILED'] > 2) {
echo "HEADERS: ";
print_r($headers);
echo "OUTPUT: \n$out\n";
}
// Does the output match what is expected?
$output = trim($out);
$output = preg_replace('/\r\n/',"\n",$output);
$failed = FALSE;
if (isset($section_text['EXPECTF']) || isset($section_text['EXPECTREGEX'])) {
if (isset($section_text['EXPECTF'])) {
$wanted = $section_text['EXPECTF'];
} else {
$wanted = $section_text['EXPECTREGEX'];
}
$wanted_re = preg_replace('/\r\n/',"\n",$wanted);
if (isset($section_text['EXPECTF'])) {
$wanted_re = preg_quote($wanted_re, '/');
// Stick to basics
$wanted_re = str_replace("%s", ".+?", $wanted_re); //not greedy
$wanted_re = str_replace("%i", "[+\-]?[0-9]+", $wanted_re);
$wanted_re = str_replace("%d", "[0-9]+", $wanted_re);
$wanted_re = str_replace("%x", "[0-9a-fA-F]+", $wanted_re);
$wanted_re = str_replace("%f", "[+\-]?\.?[0-9]+\.?[0-9]*(E-?[0-9]+)?", $wanted_re);
$wanted_re = str_replace("%c", ".", $wanted_re);
// %f allows two points "-.0.0" but that is the best *simple* expression
}
/* DEBUG YOUR REGEX HERE
var_dump($wanted_re);
print(str_repeat('=', 80) . "\n");
var_dump($output);
*/
$failed = !preg_match("/^$wanted_re\$/s", $output);
}
$skipexpect = false;
if (!$failed && $this->conf['TEST_WEB'] && isset($section_text['EXPECTHEADERS'])) {
$want = array();
$lines = preg_split("/[\n\r]+/",$section_text['EXPECTHEADERS']);
$wanted='';
foreach ($lines as $line) {
if (strpos($line, ':')!==false) {
$line = explode(":", $line, 2);
$want[trim($line[0])] = trim($line[1]);
$wanted .= trim($line[0]).': '.trim($line[1])."\n";
}
}
$output='';
foreach ($want as $k=>$v) {
$output .= "$k: {$headers[$k]}\n";
if (!isset($headers[$k]) || $headers[$k] != $v) {
$failed = TRUE;
}
}
// different servers may do different things on non-200 results
// for instance, IIS will deliver it's own error pages, so we
// cannot expect to match up the EXPECT section. We may however,
// want to match EXPECT on more than 200 results, so this may
// need to change later.
$skipexpect = isset($headers['Status']) && $headers['Status'] != 200;
}
if (!$failed && !$skipexpect && isset($section_text['EXPECT'])) {
$wanted = $section_text['EXPECT'];
$wanted = preg_replace('/\r\n/',"\n",$wanted);
$failed = (0 != strcmp($output,$wanted));
}
if (!$failed) {
@unlink($tmp_file);
$this->showstatus($tested, 'PASSED');
return 'PASSED';
}
// Test failed so we need to report details.
$this->showstatus($tested, 'FAILED');
$this->failed_tests[] = array(
'name' => $file,
'test_name' => $tested,
'output' => ereg_replace('\.phpt$','.log', $file),
'diff' => ereg_replace('\.phpt$','.diff', $file)
);
if ($this->conf['TEST_PHP_DETAILED'])
$this->writemsg(generate_diff($wanted,$output)."\n");
// write .exp
if (strpos($this->conf['TEST_PHP_LOG_FORMAT'],'E') !== FALSE) {
$logname = ereg_replace('\.phpt$','.exp',$file);
file_put_contents($logname,$wanted);
}
// write .out
if (strpos($this->conf['TEST_PHP_LOG_FORMAT'],'O') !== FALSE) {
$logname = ereg_replace('\.phpt$','.out',$file);
file_put_contents($logname,$output);
}
// write .diff
if (strpos($this->conf['TEST_PHP_LOG_FORMAT'],'D') !== FALSE) {
$logname = ereg_replace('\.phpt$','.diff',$file);
file_put_contents($logname,generate_diff($wanted,$output));
}
// write .log
if (strpos($this->conf['TEST_PHP_LOG_FORMAT'],'L') !== FALSE) {
$logname = ereg_replace('\.phpt$','.log',$file);
file_put_contents($logname,
"\n---- EXPECTED OUTPUT\n$wanted\n".
"---- ACTUAL OUTPUT\n$output\n".
"---- FAILED\n");
// display emacs/msvc error output
if (strpos($this->conf['TEST_PHP_LOG_FORMAT'],'C') !== FALSE) {
$this->error_report($file,$logname,$tested);
}
}
return 'FAILED';
}
//
// Write an error in a format recognizable to Emacs or MSVC.
//
function error_report($testname,$logname,$tested)
{
$testname = realpath($testname);
$logname = realpath($logname);
switch ($this->conf['TEST_PHP_ERROR_STYLE']) {
default:
case 'MSVC':
$this->writemsg($testname . "(1) : $tested\n");
$this->writemsg($logname . "(1) : $tested\n");
break;
case 'EMACS':
$this->writemsg($testname . ":1: $tested\n");
$this->writemsg($logname . ":1: $tested\n");
break;
}
}
function error($message)
{
$this->writemsg("ERROR: {$message}\n");
exit(1);
}
}
$test = new testHarness();
/*
* Local variables:
* tab-width: 4
* c-basic-offset: 4
* End:
* vim600: fdm=marker
* vim: noet sw=4 ts=4
*/
?>
Reference in New Issue View Git Blame Copy Permalink