| 1 | #!/usr/bin/php |
|---|
| 2 | <?php |
|---|
| 3 | /* |
|---|
| 4 | +----------------------------------------------------------------------+ |
|---|
| 5 | | PHP Version 5, 6 | |
|---|
| 6 | +----------------------------------------------------------------------+ |
|---|
| 7 | | Copyright (c) 1997-2009 The PHP Group | |
|---|
| 8 | +----------------------------------------------------------------------+ |
|---|
| 9 | | This source file is subject to version 3.01 of the PHP license, | |
|---|
| 10 | | that is bundled with this package in the file LICENSE, and is | |
|---|
| 11 | | available through the world-wide-web at the following url: | |
|---|
| 12 | | http://www.php.net/license/3_01.txt | |
|---|
| 13 | | If you did not receive a copy of the PHP license and are unable to | |
|---|
| 14 | | obtain it through the world-wide-web, please send a note to | |
|---|
| 15 | | license@php.net so we can mail you a copy immediately. | |
|---|
| 16 | +----------------------------------------------------------------------+ |
|---|
| 17 | | Authors: Ilia Alshanetsky <iliaa@php.net> | |
|---|
| 18 | | Preston L. Bannister <pbannister@php.net> | |
|---|
| 19 | | Marcus Boerger <helly@php.net> | |
|---|
| 20 | | Derick Rethans <derick@php.net> | |
|---|
| 21 | | Sander Roobol <sander@php.net> | |
|---|
| 22 | | (based on version by: Stig Bakken <ssb@php.net>) | |
|---|
| 23 | | (based on the PHP 3 test framework by Rasmus Lerdorf) | |
|---|
| 24 | +----------------------------------------------------------------------+ |
|---|
| 25 | */ |
|---|
| 26 | |
|---|
| 27 | /* $Id: run-tests.php,v 1.226.2.37.2.57 2008/12/31 17:37:21 zoe Exp $ */ |
|---|
| 28 | |
|---|
| 29 | /* Sanity check to ensure that pcre extension needed by this script is available. |
|---|
| 30 | * In the event it is not, print a nice error message indicating that this script will |
|---|
| 31 | * not run without it. |
|---|
| 32 | */ |
|---|
| 33 | |
|---|
| 34 | if (!extension_loaded('pcre')) { |
|---|
| 35 | echo <<<NO_PCRE_ERROR |
|---|
| 36 | |
|---|
| 37 | +-----------------------------------------------------------+ |
|---|
| 38 | | ! ERROR ! | |
|---|
| 39 | | The test-suite requires that you have pcre extension | |
|---|
| 40 | | enabled. To enable this extension either compile your PHP | |
|---|
| 41 | | with --with-pcre-regex or if you've compiled pcre as a | |
|---|
| 42 | | shared module load it via php.ini. | |
|---|
| 43 | +-----------------------------------------------------------+ |
|---|
| 44 | |
|---|
| 45 | NO_PCRE_ERROR; |
|---|
| 46 | exit; |
|---|
| 47 | } |
|---|
| 48 | |
|---|
| 49 | if (!function_exists('proc_open')) { |
|---|
| 50 | echo <<<NO_PROC_OPEN_ERROR |
|---|
| 51 | |
|---|
| 52 | +-----------------------------------------------------------+ |
|---|
| 53 | | ! ERROR ! | |
|---|
| 54 | | The test-suite requires that proc_open() is available. | |
|---|
| 55 | | Please check if you disabled it in php.ini. | |
|---|
| 56 | +-----------------------------------------------------------+ |
|---|
| 57 | |
|---|
| 58 | NO_PROC_OPEN_ERROR; |
|---|
| 59 | exit; |
|---|
| 60 | } |
|---|
| 61 | |
|---|
| 62 | // __DIR__ is available from 5.3.0 |
|---|
| 63 | if (PHP_VERSION_ID < 50300) { |
|---|
| 64 | define('__DIR__', realpath(dirname(__FILE__))); |
|---|
| 65 | } |
|---|
| 66 | |
|---|
| 67 | // If timezone is not set, use UTC. |
|---|
| 68 | if (ini_get('date.timezone') == '') { |
|---|
| 69 | date_default_timezone_set('UTC'); |
|---|
| 70 | } |
|---|
| 71 | |
|---|
| 72 | // store current directory |
|---|
| 73 | $CUR_DIR = getcwd(); |
|---|
| 74 | |
|---|
| 75 | // change into the PHP source directory. |
|---|
| 76 | |
|---|
| 77 | if (getenv('TEST_PHP_SRCDIR')) { |
|---|
| 78 | @chdir(getenv('TEST_PHP_SRCDIR')); |
|---|
| 79 | } |
|---|
| 80 | |
|---|
| 81 | // Delete some security related environment variables |
|---|
| 82 | putenv('SSH_CLIENT=deleted'); |
|---|
| 83 | putenv('SSH_AUTH_SOCK=deleted'); |
|---|
| 84 | putenv('SSH_TTY=deleted'); |
|---|
| 85 | putenv('SSH_CONNECTION=deleted'); |
|---|
| 86 | |
|---|
| 87 | $cwd = getcwd(); |
|---|
| 88 | set_time_limit(0); |
|---|
| 89 | |
|---|
| 90 | ini_set('pcre.backtrack_limit', PHP_INT_MAX); |
|---|
| 91 | |
|---|
| 92 | $valgrind_version = 0; |
|---|
| 93 | $valgrind_header = ''; |
|---|
| 94 | |
|---|
| 95 | // delete as much output buffers as possible |
|---|
| 96 | while(@ob_end_clean()); |
|---|
| 97 | if (ob_get_level()) echo "Not all buffers were deleted.\n"; |
|---|
| 98 | |
|---|
| 99 | error_reporting(E_ALL); |
|---|
| 100 | if (PHP_MAJOR_VERSION < 6) { |
|---|
| 101 | ini_set('magic_quotes_runtime',0); // this would break tests by modifying EXPECT sections |
|---|
| 102 | if (ini_get('safe_mode')) { |
|---|
| 103 | echo <<< SAFE_MODE_WARNING |
|---|
| 104 | |
|---|
| 105 | +-----------------------------------------------------------+ |
|---|
| 106 | | ! WARNING ! | |
|---|
| 107 | | You are running the test-suite with "safe_mode" ENABLED ! | |
|---|
| 108 | | | |
|---|
| 109 | | Chances are high that no test will work at all, | |
|---|
| 110 | | depending on how you configured "safe_mode" ! | |
|---|
| 111 | +-----------------------------------------------------------+ |
|---|
| 112 | |
|---|
| 113 | |
|---|
| 114 | SAFE_MODE_WARNING; |
|---|
| 115 | } |
|---|
| 116 | } |
|---|
| 117 | |
|---|
| 118 | $environment = isset($_ENV) ? $_ENV : array(); |
|---|
| 119 | if ((substr(PHP_OS, 0, 3) == "WIN") && empty($environment["SystemRoot"])) { |
|---|
| 120 | $environment["SystemRoot"] = getenv("SystemRoot"); |
|---|
| 121 | } |
|---|
| 122 | |
|---|
| 123 | // Don't ever guess at the PHP executable location. |
|---|
| 124 | // Require the explicit specification. |
|---|
| 125 | // Otherwise we could end up testing the wrong file! |
|---|
| 126 | |
|---|
| 127 | $php = null; |
|---|
| 128 | $php_cgi = null; |
|---|
| 129 | |
|---|
| 130 | if (getenv('TEST_PHP_EXECUTABLE')) { |
|---|
| 131 | $php = getenv('TEST_PHP_EXECUTABLE'); |
|---|
| 132 | |
|---|
| 133 | if ($php=='auto') { |
|---|
| 134 | $php = $cwd . '/sapi/cli/php'; |
|---|
| 135 | putenv("TEST_PHP_EXECUTABLE=$php"); |
|---|
| 136 | |
|---|
| 137 | if (!getenv('TEST_PHP_CGI_EXECUTABLE')) { |
|---|
| 138 | $php_cgi = $cwd . '/sapi/cgi/php-cgi'; |
|---|
| 139 | |
|---|
| 140 | if (file_exists($php_cgi)) { |
|---|
| 141 | putenv("TEST_PHP_CGI_EXECUTABLE=$php_cgi"); |
|---|
| 142 | } else { |
|---|
| 143 | $php_cgi = null; |
|---|
| 144 | } |
|---|
| 145 | } |
|---|
| 146 | } |
|---|
| 147 | $environment['TEST_PHP_EXECUTABLE'] = $php; |
|---|
| 148 | } |
|---|
| 149 | |
|---|
| 150 | if (getenv('TEST_PHP_CGI_EXECUTABLE')) { |
|---|
| 151 | $php_cgi = getenv('TEST_PHP_CGI_EXECUTABLE'); |
|---|
| 152 | |
|---|
| 153 | if ($php_cgi=='auto') { |
|---|
| 154 | $php_cgi = $cwd . '/sapi/cgi/php-cgi'; |
|---|
| 155 | putenv("TEST_PHP_CGI_EXECUTABLE=$php_cgi"); |
|---|
| 156 | } |
|---|
| 157 | |
|---|
| 158 | $environment['TEST_PHP_CGI_EXECUTABLE'] = $php_cgi; |
|---|
| 159 | } |
|---|
| 160 | |
|---|
| 161 | function verify_config() |
|---|
| 162 | { |
|---|
| 163 | global $php; |
|---|
| 164 | |
|---|
| 165 | if (empty($php) || !file_exists($php)) { |
|---|
| 166 | error('environment variable TEST_PHP_EXECUTABLE must be set to specify PHP executable!'); |
|---|
| 167 | } |
|---|
| 168 | |
|---|
| 169 | if (function_exists('is_executable') && !is_executable($php)) { |
|---|
| 170 | error("invalid PHP executable specified by TEST_PHP_EXECUTABLE = $php"); |
|---|
| 171 | } |
|---|
| 172 | } |
|---|
| 173 | |
|---|
| 174 | if (getenv('TEST_PHP_LOG_FORMAT')) { |
|---|
| 175 | $log_format = strtoupper(getenv('TEST_PHP_LOG_FORMAT')); |
|---|
| 176 | } else { |
|---|
| 177 | $log_format = 'LEOD'; |
|---|
| 178 | } |
|---|
| 179 | |
|---|
| 180 | // Check whether a detailed log is wanted. |
|---|
| 181 | if (getenv('TEST_PHP_DETAILED')) { |
|---|
| 182 | $DETAILED = getenv('TEST_PHP_DETAILED'); |
|---|
| 183 | } else { |
|---|
| 184 | $DETAILED = 0; |
|---|
| 185 | } |
|---|
| 186 | |
|---|
| 187 | // Check whether user test dirs are requested. |
|---|
| 188 | if (getenv('TEST_PHP_USER')) { |
|---|
| 189 | $user_tests = explode (',', getenv('TEST_PHP_USER')); |
|---|
| 190 | } else { |
|---|
| 191 | $user_tests = array(); |
|---|
| 192 | } |
|---|
| 193 | |
|---|
| 194 | $exts_to_test = array(); |
|---|
| 195 | $ini_overwrites = array( |
|---|
| 196 | 'output_handler=', |
|---|
| 197 | 'open_basedir=', |
|---|
| 198 | 'safe_mode=0', |
|---|
| 199 | 'disable_functions=', |
|---|
| 200 | 'output_buffering=Off', |
|---|
| 201 | 'error_reporting=' . (E_ALL | E_STRICT), |
|---|
| 202 | 'display_errors=1', |
|---|
| 203 | 'display_startup_errors=1', |
|---|
| 204 | 'log_errors=0', |
|---|
| 205 | 'html_errors=0', |
|---|
| 206 | 'track_errors=1', |
|---|
| 207 | 'report_memleaks=1', |
|---|
| 208 | 'report_zend_debug=0', |
|---|
| 209 | 'docref_root=', |
|---|
| 210 | 'docref_ext=.html', |
|---|
| 211 | 'error_prepend_string=', |
|---|
| 212 | 'error_append_string=', |
|---|
| 213 | 'auto_prepend_file=', |
|---|
| 214 | 'auto_append_file=', |
|---|
| 215 | 'magic_quotes_runtime=0', |
|---|
| 216 | 'ignore_repeated_errors=0', |
|---|
| 217 | 'unicode.runtime_encoding=ISO-8859-1', |
|---|
| 218 | 'unicode.script_encoding=UTF-8', |
|---|
| 219 | 'unicode.output_encoding=UTF-8', |
|---|
| 220 | 'unicode.from_error_mode=U_INVALID_SUBSTITUTE', |
|---|
| 221 | ); |
|---|
| 222 | |
|---|
| 223 | function write_information($show_html) |
|---|
| 224 | { |
|---|
| 225 | global $cwd, $php, $php_cgi, $php_info, $user_tests, $ini_overwrites, $pass_options, $exts_to_test, $leak_check, $valgrind_header; |
|---|
| 226 | |
|---|
| 227 | // Get info from php |
|---|
| 228 | $info_file = __DIR__ . '/run-test-info.php'; |
|---|
| 229 | @unlink($info_file); |
|---|
| 230 | $php_info = '<?php echo " |
|---|
| 231 | PHP_SAPI : " , PHP_SAPI , " |
|---|
| 232 | PHP_VERSION : " , phpversion() , " |
|---|
| 233 | ZEND_VERSION: " , zend_version() , " |
|---|
| 234 | PHP_OS : " , PHP_OS , " - " , php_uname() , " |
|---|
| 235 | INI actual : " , realpath(get_cfg_var("cfg_file_path")) , " |
|---|
| 236 | More .INIs : " , (function_exists(\'php_ini_scanned_files\') ? str_replace("\n","", php_ini_scanned_files()) : "** not determined **"); ?>'; |
|---|
| 237 | save_text($info_file, $php_info); |
|---|
| 238 | $info_params = array(); |
|---|
| 239 | settings2array($ini_overwrites, $info_params); |
|---|
| 240 | settings2params($info_params); |
|---|
| 241 | $php_info = `$php $pass_options $info_params "$info_file"`; |
|---|
| 242 | define('TESTED_PHP_VERSION', `$php -n -r "echo PHP_VERSION;"`); |
|---|
| 243 | |
|---|
| 244 | if ($php_cgi && $php != $php_cgi) { |
|---|
| 245 | $php_info_cgi = `$php_cgi $pass_options $info_params -q "$info_file"`; |
|---|
| 246 | $php_info_sep = "\n---------------------------------------------------------------------"; |
|---|
| 247 | $php_cgi_info = "$php_info_sep\nPHP : $php_cgi $php_info_cgi$php_info_sep"; |
|---|
| 248 | } else { |
|---|
| 249 | $php_cgi_info = ''; |
|---|
| 250 | } |
|---|
| 251 | |
|---|
| 252 | @unlink($info_file); |
|---|
| 253 | |
|---|
| 254 | // load list of enabled extensions |
|---|
| 255 | save_text($info_file, '<?php echo join(",", get_loaded_extensions()); ?>'); |
|---|
| 256 | $exts_to_test = explode(',',`$php $pass_options $info_params "$info_file"`); |
|---|
| 257 | // check for extensions that need special handling and regenerate |
|---|
| 258 | $info_params_ex = array( |
|---|
| 259 | 'session' => array('session.auto_start=0'), |
|---|
| 260 | 'tidy' => array('tidy.clean_output=0'), |
|---|
| 261 | 'zlib' => array('zlib.output_compression=Off'), |
|---|
| 262 | 'xdebug' => array('xdebug.default_enable=0'), |
|---|
| 263 | 'mbstring' => array('mbstring.func_overload=0'), |
|---|
| 264 | ); |
|---|
| 265 | |
|---|
| 266 | foreach($info_params_ex as $ext => $ini_overwrites_ex) { |
|---|
| 267 | if (in_array($ext, $exts_to_test)) { |
|---|
| 268 | $ini_overwrites = array_merge($ini_overwrites, $ini_overwrites_ex); |
|---|
| 269 | } |
|---|
| 270 | } |
|---|
| 271 | |
|---|
| 272 | @unlink($info_file); |
|---|
| 273 | |
|---|
| 274 | // Write test context information. |
|---|
| 275 | echo " |
|---|
| 276 | ===================================================================== |
|---|
| 277 | PHP : $php $php_info $php_cgi_info |
|---|
| 278 | CWD : $cwd |
|---|
| 279 | Extra dirs : "; |
|---|
| 280 | foreach ($user_tests as $test_dir) { |
|---|
| 281 | echo "{$test_dir}\n "; |
|---|
| 282 | } |
|---|
| 283 | echo " |
|---|
| 284 | VALGRIND : " . ($leak_check ? $valgrind_header : 'Not used') . " |
|---|
| 285 | ===================================================================== |
|---|
| 286 | "; |
|---|
| 287 | } |
|---|
| 288 | |
|---|
| 289 | define('PHP_QA_EMAIL', 'qa-reports@lists.php.net'); |
|---|
| 290 | define('QA_SUBMISSION_PAGE', 'http://qa.php.net/buildtest-process.php'); |
|---|
| 291 | |
|---|
| 292 | function save_or_mail_results() |
|---|
| 293 | { |
|---|
| 294 | global $sum_results, $just_save_results, $failed_test_summary, |
|---|
| 295 | $PHP_FAILED_TESTS, $CUR_DIR, $php, $output_file, $compression; |
|---|
| 296 | |
|---|
| 297 | /* We got failed Tests, offer the user to send an e-mail to QA team, unless NO_INTERACTION is set */ |
|---|
| 298 | if (!getenv('NO_INTERACTION')) { |
|---|
| 299 | $fp = fopen("php://stdin", "r+"); |
|---|
| 300 | if ($sum_results['FAILED'] || $sum_results['BORKED'] || $sum_results['WARNED'] || $sum_results['LEAKED'] || $sum_results['XFAILED']) { |
|---|
| 301 | echo "\nYou may have found a problem in PHP."; |
|---|
| 302 | } |
|---|
| 303 | echo "\nWe would like to send this report automatically to the\n"; |
|---|
| 304 | echo "PHP QA team, to give us a better understanding of how\nthe test cases are doing. If you don't want to send it\n"; |
|---|
| 305 | echo "immediately, you can choose \"s\" to save the report to\na file that you can send us later.\n"; |
|---|
| 306 | echo "Do you want to send this report now? [Yns]: "; |
|---|
| 307 | flush(); |
|---|
| 308 | |
|---|
| 309 | $user_input = fgets($fp, 10); |
|---|
| 310 | $just_save_results = (strtolower($user_input[0]) == 's'); |
|---|
| 311 | } |
|---|
| 312 | |
|---|
| 313 | if ($just_save_results || !getenv('NO_INTERACTION')) { |
|---|
| 314 | if ($just_save_results || strlen(trim($user_input)) == 0 || strtolower($user_input[0]) == 'y') { |
|---|
| 315 | /* |
|---|
| 316 | * Collect information about the host system for our report |
|---|
| 317 | * Fetch phpinfo() output so that we can see the PHP enviroment |
|---|
| 318 | * Make an archive of all the failed tests |
|---|
| 319 | * Send an email |
|---|
| 320 | */ |
|---|
| 321 | if ($just_save_results) { |
|---|
| 322 | $user_input = 's'; |
|---|
| 323 | } |
|---|
| 324 | |
|---|
| 325 | /* Ask the user to provide an email address, so that QA team can contact the user */ |
|---|
| 326 | if (!strncasecmp($user_input, 'y', 1) || strlen(trim($user_input)) == 0) { |
|---|
| 327 | 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): "; |
|---|
| 328 | flush(); |
|---|
| 329 | $user_email = trim(fgets($fp, 1024)); |
|---|
| 330 | $user_email = str_replace("@", " at ", str_replace(".", " dot ", $user_email)); |
|---|
| 331 | } |
|---|
| 332 | |
|---|
| 333 | $failed_tests_data = ''; |
|---|
| 334 | $sep = "\n" . str_repeat('=', 80) . "\n"; |
|---|
| 335 | $failed_tests_data .= $failed_test_summary . "\n"; |
|---|
| 336 | $failed_tests_data .= get_summary(true, false) . "\n"; |
|---|
| 337 | |
|---|
| 338 | if ($sum_results['FAILED']) { |
|---|
| 339 | foreach ($PHP_FAILED_TESTS['FAILED'] as $test_info) { |
|---|
| 340 | $failed_tests_data .= $sep . $test_info['name'] . $test_info['info']; |
|---|
| 341 | $failed_tests_data .= $sep . file_get_contents(realpath($test_info['output'])); |
|---|
| 342 | $failed_tests_data .= $sep . file_get_contents(realpath($test_info['diff'])); |
|---|
| 343 | $failed_tests_data .= $sep . "\n\n"; |
|---|
| 344 | } |
|---|
| 345 | $status = "failed"; |
|---|
| 346 | } else { |
|---|
| 347 | $status = "success"; |
|---|
| 348 | } |
|---|
| 349 | |
|---|
| 350 | $failed_tests_data .= "\n" . $sep . 'BUILD ENVIRONMENT' . $sep; |
|---|
| 351 | $failed_tests_data .= "OS:\n" . PHP_OS . " - " . php_uname() . "\n\n"; |
|---|
| 352 | $ldd = $autoconf = $sys_libtool = $libtool = $compiler = 'N/A'; |
|---|
| 353 | |
|---|
| 354 | if (substr(PHP_OS, 0, 3) != "WIN") { |
|---|
| 355 | /* If PHP_AUTOCONF is set, use it; otherwise, use 'autoconf'. */ |
|---|
| 356 | if (getenv('PHP_AUTOCONF')) { |
|---|
| 357 | $autoconf = shell_exec(getenv('PHP_AUTOCONF') . ' --version'); |
|---|
| 358 | } else { |
|---|
| 359 | $autoconf = shell_exec('autoconf --version'); |
|---|
| 360 | } |
|---|
| 361 | |
|---|
| 362 | /* Always use the generated libtool - Mac OSX uses 'glibtool' */ |
|---|
| 363 | $libtool = shell_exec($CUR_DIR . '/libtool --version'); |
|---|
| 364 | |
|---|
| 365 | /* Use shtool to find out if there is glibtool present (MacOSX) */ |
|---|
| 366 | $sys_libtool_path = shell_exec(__DIR__ . '/build/shtool path glibtool libtool'); |
|---|
| 367 | |
|---|
| 368 | if ($sys_libtool_path) { |
|---|
| 369 | $sys_libtool = shell_exec(str_replace("\n", "", $sys_libtool_path) . ' --version'); |
|---|
| 370 | } |
|---|
| 371 | |
|---|
| 372 | /* Try the most common flags for 'version' */ |
|---|
| 373 | $flags = array('-v', '-V', '--version'); |
|---|
| 374 | $cc_status = 0; |
|---|
| 375 | |
|---|
| 376 | foreach($flags AS $flag) { |
|---|
| 377 | system(getenv('CC') . " $flag >/dev/null 2>&1", $cc_status); |
|---|
| 378 | if ($cc_status == 0) { |
|---|
| 379 | $compiler = shell_exec(getenv('CC') . " $flag 2>&1"); |
|---|
| 380 | break; |
|---|
| 381 | } |
|---|
| 382 | } |
|---|
| 383 | |
|---|
| 384 | $ldd = shell_exec("ldd $php 2>/dev/null"); |
|---|
| 385 | } |
|---|
| 386 | |
|---|
| 387 | $failed_tests_data .= "Autoconf:\n$autoconf\n"; |
|---|
| 388 | $failed_tests_data .= "Bundled Libtool:\n$libtool\n"; |
|---|
| 389 | $failed_tests_data .= "System Libtool:\n$sys_libtool\n"; |
|---|
| 390 | $failed_tests_data .= "Compiler:\n$compiler\n"; |
|---|
| 391 | $failed_tests_data .= "Bison:\n". shell_exec('bison --version 2>/dev/null') . "\n"; |
|---|
| 392 | $failed_tests_data .= "Libraries:\n$ldd\n"; |
|---|
| 393 | $failed_tests_data .= "\n"; |
|---|
| 394 | |
|---|
| 395 | if (isset($user_email)) { |
|---|
| 396 | $failed_tests_data .= "User's E-mail: " . $user_email . "\n\n"; |
|---|
| 397 | } |
|---|
| 398 | |
|---|
| 399 | $failed_tests_data .= $sep . "PHPINFO" . $sep; |
|---|
| 400 | $failed_tests_data .= shell_exec($php . ' -ddisplay_errors=stderr -dhtml_errors=0 -i 2> /dev/null'); |
|---|
| 401 | |
|---|
| 402 | if ($just_save_results || !mail_qa_team($failed_tests_data, $compression, $status)) { |
|---|
| 403 | file_put_contents($output_file, $failed_tests_data); |
|---|
| 404 | |
|---|
| 405 | if (!$just_save_results) { |
|---|
| 406 | echo "\nThe test script was unable to automatically send the report to PHP's QA Team\n"; |
|---|
| 407 | } |
|---|
| 408 | |
|---|
| 409 | echo "Please send " . $output_file . " to " . PHP_QA_EMAIL . " manually, thank you.\n"; |
|---|
| 410 | } else { |
|---|
| 411 | fwrite($fp, "\nThank you for helping to make PHP better.\n"); |
|---|
| 412 | fclose($fp); |
|---|
| 413 | } |
|---|
| 414 | } |
|---|
| 415 | } |
|---|
| 416 | } |
|---|
| 417 | |
|---|
| 418 | // Determine the tests to be run. |
|---|
| 419 | |
|---|
| 420 | $test_files = array(); |
|---|
| 421 | $redir_tests = array(); |
|---|
| 422 | $test_results = array(); |
|---|
| 423 | $PHP_FAILED_TESTS = array('BORKED' => array(), 'FAILED' => array(), 'WARNED' => array(), 'LEAKED' => array(), 'XFAILED' => array()); |
|---|
| 424 | |
|---|
| 425 | // If parameters given assume they represent selected tests to run. |
|---|
| 426 | $failed_tests_file= false; |
|---|
| 427 | $pass_option_n = false; |
|---|
| 428 | $pass_options = ''; |
|---|
| 429 | |
|---|
| 430 | $compression = 0; |
|---|
| 431 | $output_file = $CUR_DIR . '/php_test_results_' . date('Ymd_Hi') . '.txt'; |
|---|
| 432 | |
|---|
| 433 | if ($compression) { |
|---|
| 434 | $output_file = 'compress.zlib://' . $output_file . '.gz'; |
|---|
| 435 | } |
|---|
| 436 | |
|---|
| 437 | $just_save_results = false; |
|---|
| 438 | $leak_check = false; |
|---|
| 439 | $html_output = false; |
|---|
| 440 | $html_file = null; |
|---|
| 441 | $temp_source = null; |
|---|
| 442 | $temp_target = null; |
|---|
| 443 | $temp_urlbase = null; |
|---|
| 444 | $conf_passed = null; |
|---|
| 445 | $no_clean = false; |
|---|
| 446 | |
|---|
| 447 | $cfgtypes = array('show', 'keep'); |
|---|
| 448 | $cfgfiles = array('skip', 'php', 'clean', 'out', 'diff', 'exp'); |
|---|
| 449 | $cfg = array(); |
|---|
| 450 | |
|---|
| 451 | foreach($cfgtypes as $type) { |
|---|
| 452 | $cfg[$type] = array(); |
|---|
| 453 | |
|---|
| 454 | foreach($cfgfiles as $file) { |
|---|
| 455 | $cfg[$type][$file] = false; |
|---|
| 456 | } |
|---|
| 457 | } |
|---|
| 458 | |
|---|
| 459 | if (getenv('TEST_PHP_ARGS')) { |
|---|
| 460 | |
|---|
| 461 | if (!isset($argc) || !$argc || !isset($argv)) { |
|---|
| 462 | $argv = array(__FILE__); |
|---|
| 463 | } |
|---|
| 464 | |
|---|
| 465 | $argv = array_merge($argv, split(' ', getenv('TEST_PHP_ARGS'))); |
|---|
| 466 | $argc = count($argv); |
|---|
| 467 | } |
|---|
| 468 | |
|---|
| 469 | if (isset($argc) && $argc > 1) { |
|---|
| 470 | |
|---|
| 471 | for ($i=1; $i<$argc; $i++) { |
|---|
| 472 | $is_switch = false; |
|---|
| 473 | $switch = substr($argv[$i],1,1); |
|---|
| 474 | $repeat = substr($argv[$i],0,1) == '-'; |
|---|
| 475 | |
|---|
| 476 | while ($repeat) { |
|---|
| 477 | |
|---|
| 478 | if (!$is_switch) { |
|---|
| 479 | $switch = substr($argv[$i],1,1); |
|---|
| 480 | } |
|---|
| 481 | |
|---|
| 482 | $is_switch = true; |
|---|
| 483 | |
|---|
| 484 | if ($repeat) { |
|---|
| 485 | foreach($cfgtypes as $type) { |
|---|
| 486 | if (strpos($switch, '--' . $type) === 0) { |
|---|
| 487 | foreach($cfgfiles as $file) { |
|---|
| 488 | if ($switch == '--' . $type . '-' . $file) { |
|---|
| 489 | $cfg[$type][$file] = true; |
|---|
| 490 | $is_switch = false; |
|---|
| 491 | break; |
|---|
| 492 | } |
|---|
| 493 | } |
|---|
| 494 | } |
|---|
| 495 | } |
|---|
| 496 | } |
|---|
| 497 | |
|---|
| 498 | if (!$is_switch) { |
|---|
| 499 | $is_switch = true; |
|---|
| 500 | break; |
|---|
| 501 | } |
|---|
| 502 | |
|---|
| 503 | $repeat = false; |
|---|
| 504 | |
|---|
| 505 | switch($switch) { |
|---|
| 506 | case 'r': |
|---|
| 507 | case 'l': |
|---|
| 508 | $test_list = file($argv[++$i]); |
|---|
| 509 | if ($test_list) { |
|---|
| 510 | foreach($test_list as $test) { |
|---|
| 511 | $matches = array(); |
|---|
| 512 | if (preg_match('/^#.*\[(.*)\]\:\s+(.*)$/', $test, $matches)) { |
|---|
| 513 | $redir_tests[] = array($matches[1], $matches[2]); |
|---|
| 514 | } else if (strlen($test)) { |
|---|
| 515 | $test_files[] = trim($test); |
|---|
| 516 | } |
|---|
| 517 | } |
|---|
| 518 | } |
|---|
| 519 | if ($switch != 'l') { |
|---|
| 520 | break; |
|---|
| 521 | } |
|---|
| 522 | $i--; |
|---|
| 523 | // break left intentionally |
|---|
| 524 | case 'w': |
|---|
| 525 | $failed_tests_file = fopen($argv[++$i], 'w+t'); |
|---|
| 526 | break; |
|---|
| 527 | case 'a': |
|---|
| 528 | $failed_tests_file = fopen($argv[++$i], 'a+t'); |
|---|
| 529 | break; |
|---|
| 530 | case 'c': |
|---|
| 531 | $conf_passed = $argv[++$i]; |
|---|
| 532 | break; |
|---|
| 533 | case 'd': |
|---|
| 534 | $ini_overwrites[] = $argv[++$i]; |
|---|
| 535 | break; |
|---|
| 536 | //case 'h' |
|---|
| 537 | case '--keep-all': |
|---|
| 538 | foreach($cfgfiles as $file) { |
|---|
| 539 | $cfg['keep'][$file] = true; |
|---|
| 540 | } |
|---|
| 541 | break; |
|---|
| 542 | //case 'l' |
|---|
| 543 | case 'm': |
|---|
| 544 | $leak_check = true; |
|---|
| 545 | $valgrind_cmd = "valgrind --version"; |
|---|
| 546 | $valgrind_header = system_with_timeout($valgrind_cmd); |
|---|
| 547 | $replace_count = 0; |
|---|
| 548 | if (!$valgrind_header) { |
|---|
| 549 | error("Valgrind returned no version info, cannot proceed.\nPlease check if Valgrind is installed."); |
|---|
| 550 | } else { |
|---|
| 551 | $valgrind_version = preg_replace("/valgrind-([0-9])\.([0-9])\.([0-9]+)([.-]\w+)?(\s+)/", '$1$2$3', $valgrind_header, 1, $replace_count); |
|---|
| 552 | if ($replace_count != 1 || !is_numeric($valgrind_version)) { |
|---|
| 553 | error("Valgrind returned invalid version info (\"$valgrind_header\"), cannot proceed."); |
|---|
| 554 | } |
|---|
| 555 | $valgrind_header = trim($valgrind_header); |
|---|
| 556 | } |
|---|
| 557 | break; |
|---|
| 558 | case 'n': |
|---|
| 559 | if (!$pass_option_n) { |
|---|
| 560 | $pass_options .= ' -n'; |
|---|
| 561 | } |
|---|
| 562 | $pass_option_n = true; |
|---|
| 563 | break; |
|---|
| 564 | case '--no-clean': |
|---|
| 565 | $no_clean = true; |
|---|
| 566 | break; |
|---|
| 567 | case 'p': |
|---|
| 568 | $php = $argv[++$i]; |
|---|
| 569 | putenv("TEST_PHP_EXECUTABLE=$php"); |
|---|
| 570 | $environment['TEST_PHP_EXECUTABLE'] = $php; |
|---|
| 571 | break; |
|---|
| 572 | case 'q': |
|---|
| 573 | putenv('NO_INTERACTION=1'); |
|---|
| 574 | break; |
|---|
| 575 | //case 'r' |
|---|
| 576 | case 's': |
|---|
| 577 | $output_file = $argv[++$i]; |
|---|
| 578 | $just_save_results = true; |
|---|
| 579 | break; |
|---|
| 580 | case '--set-timeout': |
|---|
| 581 | $environment['TEST_TIMEOUT'] = $argv[++$i]; |
|---|
| 582 | break; |
|---|
| 583 | case '--show-all': |
|---|
| 584 | foreach($cfgfiles as $file) { |
|---|
| 585 | $cfg['show'][$file] = true; |
|---|
| 586 | } |
|---|
| 587 | break; |
|---|
| 588 | case '--temp-source': |
|---|
| 589 | $temp_source = $argv[++$i]; |
|---|
| 590 | break; |
|---|
| 591 | case '--temp-target': |
|---|
| 592 | $temp_target = $argv[++$i]; |
|---|
| 593 | if ($temp_urlbase) { |
|---|
| 594 | $temp_urlbase = $temp_target; |
|---|
| 595 | } |
|---|
| 596 | break; |
|---|
| 597 | case '--temp-urlbase': |
|---|
| 598 | $temp_urlbase = $argv[++$i]; |
|---|
| 599 | break; |
|---|
| 600 | case 'v': |
|---|
| 601 | case '--verbose': |
|---|
| 602 | $DETAILED = true; |
|---|
| 603 | break; |
|---|
| 604 | case 'x': |
|---|
| 605 | $environment['SKIP_SLOW_TESTS'] = 1; |
|---|
| 606 | break; |
|---|
| 607 | //case 'w' |
|---|
| 608 | case '-': |
|---|
| 609 | // repeat check with full switch |
|---|
| 610 | $switch = $argv[$i]; |
|---|
| 611 | if ($switch != '-') { |
|---|
| 612 | $repeat = true; |
|---|
| 613 | } |
|---|
| 614 | break; |
|---|
| 615 | case '--html': |
|---|
| 616 | $html_file = fopen($argv[++$i], 'wt'); |
|---|
| 617 | $html_output = is_resource($html_file); |
|---|
| 618 | break; |
|---|
| 619 | case '--version': |
|---|
| 620 | echo '$Revision: 1.226.2.37.2.57 $' . "\n"; |
|---|
| 621 | exit(1); |
|---|
| 622 | |
|---|
| 623 | default: |
|---|
| 624 | echo "Illegal switch '$switch' specified!\n"; |
|---|
| 625 | case 'h': |
|---|
| 626 | case '-help': |
|---|
| 627 | case '--help': |
|---|
| 628 | echo <<<HELP |
|---|
| 629 | Synopsis: |
|---|
| 630 | php run-tests.php [options] [files] [directories] |
|---|
| 631 | |
|---|
| 632 | Options: |
|---|
| 633 | -l <file> Read the testfiles to be executed from <file>. After the test |
|---|
| 634 | has finished all failed tests are written to the same <file>. |
|---|
| 635 | If the list is empty and no further test is specified then |
|---|
| 636 | all tests are executed (same as: -r <file> -w <file>). |
|---|
| 637 | |
|---|
| 638 | -r <file> Read the testfiles to be executed from <file>. |
|---|
| 639 | |
|---|
| 640 | -w <file> Write a list of all failed tests to <file>. |
|---|
| 641 | |
|---|
| 642 | -a <file> Same as -w but append rather then truncating <file>. |
|---|
| 643 | |
|---|
| 644 | -c <file> Look for php.ini in directory <file> or use <file> as ini. |
|---|
| 645 | |
|---|
| 646 | -n Pass -n option to the php binary (Do not use a php.ini). |
|---|
| 647 | |
|---|
| 648 | -d foo=bar Pass -d option to the php binary (Define INI entry foo |
|---|
| 649 | with value 'bar'). |
|---|
| 650 | |
|---|
| 651 | -m Test for memory leaks with Valgrind. |
|---|
| 652 | |
|---|
| 653 | -p <php> Specify PHP executable to run. |
|---|
| 654 | |
|---|
| 655 | -q Quiet, no user interaction (same as environment NO_INTERACTION). |
|---|
| 656 | |
|---|
| 657 | -s <file> Write output to <file>. |
|---|
| 658 | |
|---|
| 659 | -x Sets 'SKIP_SLOW_TESTS' environmental variable. |
|---|
| 660 | |
|---|
| 661 | --verbose |
|---|
| 662 | -v Verbose mode. |
|---|
| 663 | |
|---|
| 664 | --help |
|---|
| 665 | -h This Help. |
|---|
| 666 | |
|---|
| 667 | --html <file> Generate HTML output. |
|---|
| 668 | |
|---|
| 669 | --temp-source <sdir> --temp-target <tdir> [--temp-urlbase <url>] |
|---|
| 670 | Write temporary files to <tdir> by replacing <sdir> from the |
|---|
| 671 | filenames to generate with <tdir>. If --html is being used and |
|---|
| 672 | <url> given then the generated links are relative and prefixed |
|---|
| 673 | with the given url. In general you want to make <sdir> the path |
|---|
| 674 | to your source files and <tdir> some pach in your web page |
|---|
| 675 | hierarchy with <url> pointing to <tdir>. |
|---|
| 676 | |
|---|
| 677 | --keep-[all|php|skip|clean] |
|---|
| 678 | Do not delete 'all' files, 'php' test file, 'skip' or 'clean' |
|---|
| 679 | file. |
|---|
| 680 | |
|---|
| 681 | --set-timeout [n] |
|---|
| 682 | Set timeout for individual tests, where [n] is the number of |
|---|
| 683 | seconds. The default value is 60 seconds, or 300 seconds when |
|---|
| 684 | testing for memory leaks. |
|---|
| 685 | |
|---|
| 686 | --show-[all|php|skip|clean|exp|diff|out] |
|---|
| 687 | Show 'all' files, 'php' test file, 'skip' or 'clean' file. You |
|---|
| 688 | can also use this to show the output 'out', the expected result |
|---|
| 689 | 'exp' or the difference between them 'diff'. The result types |
|---|
| 690 | get written independent of the log format, however 'diff' only |
|---|
| 691 | exists when a test fails. |
|---|
| 692 | |
|---|
| 693 | --no-clean Do not execute clean section if any. |
|---|
| 694 | |
|---|
| 695 | HELP; |
|---|
| 696 | exit(1); |
|---|
| 697 | } |
|---|
| 698 | } |
|---|
| 699 | |
|---|
| 700 | if (!$is_switch) { |
|---|
| 701 | $testfile = realpath($argv[$i]); |
|---|
| 702 | |
|---|
| 703 | if (!$testfile && strpos($argv[$i], '*') !== false && function_exists('glob')) { |
|---|
| 704 | |
|---|
| 705 | if (preg_match("/\.phpt$/", $argv[$i])) { |
|---|
| 706 | $pattern_match = glob($argv[$i]); |
|---|
| 707 | } else if (preg_match("/\*$/", $argv[$i])) { |
|---|
| 708 | $pattern_match = glob($argv[$i] . '.phpt'); |
|---|
| 709 | } else { |
|---|
| 710 | die("bogus test name " . $argv[$i] . "\n"); |
|---|
| 711 | } |
|---|
| 712 | |
|---|
| 713 | if (is_array($pattern_match)) { |
|---|
| 714 | $test_files = array_merge($test_files, $pattern_match); |
|---|
| 715 | } |
|---|
| 716 | |
|---|
| 717 | } else if (is_dir($testfile)) { |
|---|
| 718 | find_files($testfile); |
|---|
| 719 | } else if (preg_match("/\.phpt$/", $testfile)) { |
|---|
| 720 | $test_files[] = $testfile; |
|---|
| 721 | } else { |
|---|
| 722 | die("bogus test name " . $argv[$i] . "\n"); |
|---|
| 723 | } |
|---|
| 724 | } |
|---|
| 725 | } |
|---|
| 726 | |
|---|
| 727 | if (strlen($conf_passed)) { |
|---|
| 728 | if (substr(PHP_OS, 0, 3) == "WIN") { |
|---|
| 729 | $pass_options .= " -c " . escapeshellarg($conf_passed); |
|---|
| 730 | } else { |
|---|
| 731 | $pass_options .= " -c '$conf_passed'"; |
|---|
| 732 | } |
|---|
| 733 | } |
|---|
| 734 | |
|---|
| 735 | $test_files = array_unique($test_files); |
|---|
| 736 | $test_files = array_merge($test_files, $redir_tests); |
|---|
| 737 | |
|---|
| 738 | // Run selected tests. |
|---|
| 739 | $test_cnt = count($test_files); |
|---|
| 740 | |
|---|
| 741 | if ($test_cnt) { |
|---|
| 742 | putenv('NO_INTERACTION=1'); |
|---|
| 743 | verify_config(); |
|---|
| 744 | write_information($html_output); |
|---|
| 745 | usort($test_files, "test_sort"); |
|---|
| 746 | $start_time = time(); |
|---|
| 747 | |
|---|
| 748 | if (!$html_output) { |
|---|
| 749 | echo "Running selected tests.\n"; |
|---|
| 750 | } else { |
|---|
| 751 | show_start($start_time); |
|---|
| 752 | } |
|---|
| 753 | |
|---|
| 754 | $test_idx = 0; |
|---|
| 755 | run_all_tests($test_files, $environment); |
|---|
| 756 | $end_time = time(); |
|---|
| 757 | |
|---|
| 758 | if ($html_output) { |
|---|
| 759 | show_end($end_time); |
|---|
| 760 | } |
|---|
| 761 | |
|---|
| 762 | if ($failed_tests_file) { |
|---|
| 763 | fclose($failed_tests_file); |
|---|
| 764 | } |
|---|
| 765 | |
|---|
| 766 | if (count($test_files) || count($test_results)) { |
|---|
| 767 | compute_summary(); |
|---|
| 768 | if ($html_output) { |
|---|
| 769 | fwrite($html_file, "<hr/>\n" . get_summary(false, true)); |
|---|
| 770 | } |
|---|
| 771 | echo "====================================================================="; |
|---|
| 772 | echo get_summary(false, false); |
|---|
| 773 | } |
|---|
| 774 | |
|---|
| 775 | if ($html_output) { |
|---|
| 776 | fclose($html_file); |
|---|
| 777 | } |
|---|
| 778 | |
|---|
| 779 | if ($output_file != '' && $just_save_results) { |
|---|
| 780 | save_or_mail_results(); |
|---|
| 781 | } |
|---|
| 782 | |
|---|
| 783 | if (getenv('REPORT_EXIT_STATUS') == 1 and preg_match('/FAILED(?: |$)/', implode(' ', $test_results))) { |
|---|
| 784 | exit(1); |
|---|
| 785 | } |
|---|
| 786 | |
|---|
| 787 | exit(0); |
|---|
| 788 | } |
|---|
| 789 | } |
|---|
| 790 | |
|---|
| 791 | verify_config(); |
|---|
| 792 | write_information($html_output); |
|---|
| 793 | |
|---|
| 794 | // Compile a list of all test files (*.phpt). |
|---|
| 795 | $test_files = array(); |
|---|
| 796 | $exts_tested = count($exts_to_test); |
|---|
| 797 | $exts_skipped = 0; |
|---|
| 798 | $ignored_by_ext = 0; |
|---|
| 799 | sort($exts_to_test); |
|---|
| 800 | $test_dirs = array(); |
|---|
| 801 | $optionals = array('tests', 'ext', 'Zend', 'ZendEngine2', 'sapi/cli', 'sapi/cgi'); |
|---|
| 802 | |
|---|
| 803 | foreach($optionals as $dir) { |
|---|
| 804 | if (@filetype($dir) == 'dir') { |
|---|
| 805 | $test_dirs[] = $dir; |
|---|
| 806 | } |
|---|
| 807 | } |
|---|
| 808 | |
|---|
| 809 | // Convert extension names to lowercase |
|---|
| 810 | foreach ($exts_to_test as $key => $val) { |
|---|
| 811 | $exts_to_test[$key] = strtolower($val); |
|---|
| 812 | } |
|---|
| 813 | |
|---|
| 814 | foreach ($test_dirs as $dir) { |
|---|
| 815 | find_files("{$cwd}/{$dir}", ($dir == 'ext')); |
|---|
| 816 | } |
|---|
| 817 | |
|---|
| 818 | foreach ($user_tests as $dir) { |
|---|
| 819 | find_files($dir, ($dir == 'ext')); |
|---|
| 820 | } |
|---|
| 821 | |
|---|
| 822 | function find_files($dir, $is_ext_dir = false, $ignore = false) |
|---|
| 823 | { |
|---|
| 824 | global $test_files, $exts_to_test, $ignored_by_ext, $exts_skipped, $exts_tested; |
|---|
| 825 | |
|---|
| 826 | $o = opendir($dir) or error("cannot open directory: $dir"); |
|---|
| 827 | |
|---|
| 828 | while (($name = readdir($o)) !== false) { |
|---|
| 829 | |
|---|
| 830 | if (is_dir("{$dir}/{$name}") && !in_array($name, array('.', '..', 'CVS'))) { |
|---|
| 831 | $skip_ext = ($is_ext_dir && !in_array(strtolower($name), $exts_to_test)); |
|---|
| 832 | if ($skip_ext) { |
|---|
| 833 | $exts_skipped++; |
|---|
| 834 | } |
|---|
| 835 | find_files("{$dir}/{$name}", false, $ignore || $skip_ext); |
|---|
| 836 | } |
|---|
| 837 | |
|---|
| 838 | // Cleanup any left-over tmp files from last run. |
|---|
| 839 | if (substr($name, -4) == '.tmp') { |
|---|
| 840 | @unlink("$dir/$name"); |
|---|
| 841 | continue; |
|---|
| 842 | } |
|---|
| 843 | |
|---|
| 844 | // Otherwise we're only interested in *.phpt files. |
|---|
| 845 | if (substr($name, -5) == '.phpt') { |
|---|
| 846 | if ($ignore) { |
|---|
| 847 | $ignored_by_ext++; |
|---|
| 848 | } else { |
|---|
| 849 | $testfile = realpath("{$dir}/{$name}"); |
|---|
| 850 | $test_files[] = $testfile; |
|---|
| 851 | } |
|---|
| 852 | } |
|---|
| 853 | } |
|---|
| 854 | |
|---|
| 855 | closedir($o); |
|---|
| 856 | } |
|---|
| 857 | |
|---|
| 858 | function test_name($name) |
|---|
| 859 | { |
|---|
| 860 | if (is_array($name)) { |
|---|
| 861 | return $name[0] . ':' . $name[1]; |
|---|
| 862 | } else { |
|---|
| 863 | return $name; |
|---|
| 864 | } |
|---|
| 865 | } |
|---|
| 866 | |
|---|
| 867 | function test_sort($a, $b) |
|---|
| 868 | { |
|---|
| 869 | global $cwd; |
|---|
| 870 | |
|---|
| 871 | $a = test_name($a); |
|---|
| 872 | $b = test_name($b); |
|---|
| 873 | |
|---|
| 874 | $ta = strpos($a, "{$cwd}/tests") === 0 ? 1 + (strpos($a, "{$cwd}/tests/run-test") === 0 ? 1 : 0) : 0; |
|---|
| 875 | $tb = strpos($b, "{$cwd}/tests") === 0 ? 1 + (strpos($b, "{$cwd}/tests/run-test") === 0 ? 1 : 0) : 0; |
|---|
| 876 | |
|---|
| 877 | if ($ta == $tb) { |
|---|
| 878 | return strcmp($a, $b); |
|---|
| 879 | } else { |
|---|
| 880 | return $tb - $ta; |
|---|
| 881 | } |
|---|
| 882 | } |
|---|
| 883 | |
|---|
| 884 | $test_files = array_unique($test_files); |
|---|
| 885 | usort($test_files, "test_sort"); |
|---|
| 886 | |
|---|
| 887 | $start_time = time(); |
|---|
| 888 | show_start($start_time); |
|---|
| 889 | |
|---|
| 890 | $test_cnt = count($test_files); |
|---|
| 891 | $test_idx = 0; |
|---|
| 892 | run_all_tests($test_files, $environment); |
|---|
| 893 | $end_time = time(); |
|---|
| 894 | |
|---|
| 895 | if ($failed_tests_file) { |
|---|
| 896 | fclose($failed_tests_file); |
|---|
| 897 | } |
|---|
| 898 | |
|---|
| 899 | // Summarize results |
|---|
| 900 | |
|---|
| 901 | if (0 == count($test_results)) { |
|---|
| 902 | echo "No tests were run.\n"; |
|---|
| 903 | return; |
|---|
| 904 | } |
|---|
| 905 | |
|---|
| 906 | compute_summary(); |
|---|
| 907 | |
|---|
| 908 | show_end($end_time); |
|---|
| 909 | show_summary(); |
|---|
| 910 | |
|---|
| 911 | if ($html_output) { |
|---|
| 912 | fclose($html_file); |
|---|
| 913 | } |
|---|
| 914 | |
|---|
| 915 | save_or_mail_results(); |
|---|
| 916 | |
|---|
| 917 | if (getenv('REPORT_EXIT_STATUS') == 1 and $sum_results['FAILED']) { |
|---|
| 918 | exit(1); |
|---|
| 919 | } |
|---|
| 920 | exit(0); |
|---|
| 921 | |
|---|
| 922 | // |
|---|
| 923 | // Send Email to QA Team |
|---|
| 924 | // |
|---|
| 925 | |
|---|
| 926 | function mail_qa_team($data, $compression, $status = false) |
|---|
| 927 | { |
|---|
| 928 | $url_bits = parse_url(QA_SUBMISSION_PAGE); |
|---|
| 929 | |
|---|
| 930 | if (empty($url_bits['port'])) { |
|---|
| 931 | $url_bits['port'] = 80; |
|---|
| 932 | } |
|---|
| 933 | |
|---|
| 934 | $data = "php_test_data=" . urlencode(base64_encode(str_replace("\00", '[0x0]', $data))); |
|---|
| 935 | $data_length = strlen($data); |
|---|
| 936 | |
|---|
| 937 | $fs = fsockopen($url_bits['host'], $url_bits['port'], $errno, $errstr, 10); |
|---|
| 938 | |
|---|
| 939 | if (!$fs) { |
|---|
| 940 | return false; |
|---|
| 941 | } |
|---|
| 942 | |
|---|
| 943 | $php_version = urlencode(TESTED_PHP_VERSION); |
|---|
| 944 | |
|---|
| 945 | echo "\nPosting to {$url_bits['host']} {$url_bits['path']}\n"; |
|---|
| 946 | fwrite($fs, "POST " . $url_bits['path'] . "?status=$status&version=$php_version HTTP/1.1\r\n"); |
|---|
| 947 | fwrite($fs, "Host: " . $url_bits['host'] . "\r\n"); |
|---|
| 948 | fwrite($fs, "User-Agent: QA Browser 0.1\r\n"); |
|---|
| 949 | fwrite($fs, "Content-Type: application/x-www-form-urlencoded\r\n"); |
|---|
| 950 | fwrite($fs, "Content-Length: " . $data_length . "\r\n\r\n"); |
|---|
| 951 | fwrite($fs, $data); |
|---|
| 952 | fwrite($fs, "\r\n\r\n"); |
|---|
| 953 | fclose($fs); |
|---|
| 954 | |
|---|
| 955 | return 1; |
|---|
| 956 | } |
|---|
| 957 | |
|---|
| 958 | |
|---|
| 959 | // |
|---|
| 960 | // Write the given text to a temporary file, and return the filename. |
|---|
| 961 | // |
|---|
| 962 | |
|---|
| 963 | function save_text($filename, $text, $filename_copy = null) |
|---|
| 964 | { |
|---|
| 965 | global $DETAILED; |
|---|
| 966 | |
|---|
| 967 | if ($filename_copy && $filename_copy != $filename) { |
|---|
| 968 | if (file_put_contents($filename_copy, (binary) $text, FILE_BINARY) === false) { |
|---|
| 969 | error("Cannot open file '" . $filename_copy . "' (save_text)"); |
|---|
| 970 | } |
|---|
| 971 | } |
|---|
| 972 | |
|---|
| 973 | if (file_put_contents($filename, (binary) $text, FILE_BINARY) === false) { |
|---|
| 974 | error("Cannot open file '" . $filename . "' (save_text)"); |
|---|
| 975 | } |
|---|
| 976 | |
|---|
| 977 | if (1 < $DETAILED) echo " |
|---|
| 978 | FILE $filename {{{ |
|---|
| 979 | $text |
|---|
| 980 | }}} |
|---|
| 981 | "; |
|---|
| 982 | } |
|---|
| 983 | |
|---|
| 984 | // |
|---|
| 985 | // Write an error in a format recognizable to Emacs or MSVC. |
|---|
| 986 | // |
|---|
| 987 | |
|---|
| 988 | function error_report($testname, $logname, $tested) |
|---|
| 989 | { |
|---|
| 990 | $testname = realpath($testname); |
|---|
| 991 | $logname = realpath($logname); |
|---|
| 992 | |
|---|
| 993 | switch (strtoupper(getenv('TEST_PHP_ERROR_STYLE'))) { |
|---|
| 994 | case 'MSVC': |
|---|
| 995 | echo $testname . "(1) : $tested\n"; |
|---|
| 996 | echo $logname . "(1) : $tested\n"; |
|---|
| 997 | break; |
|---|
| 998 | case 'EMACS': |
|---|
| 999 | echo $testname . ":1: $tested\n"; |
|---|
| 1000 | echo $logname . ":1: $tested\n"; |
|---|
| 1001 | break; |
|---|
| 1002 | } |
|---|
| 1003 | } |
|---|
| 1004 | |
|---|
| 1005 | function system_with_timeout($commandline, $env = null, $stdin = null) |
|---|
| 1006 | { |
|---|
| 1007 | global $leak_check, $cwd; |
|---|
| 1008 | |
|---|
| 1009 | $data = ''; |
|---|
| 1010 | |
|---|
| 1011 | $bin_env = array(); |
|---|
| 1012 | foreach((array)$env as $key => $value) { |
|---|
| 1013 | $bin_env[(binary)$key] = (binary)$value; |
|---|
| 1014 | } |
|---|
| 1015 | |
|---|
| 1016 | $proc = proc_open($commandline, array( |
|---|
| 1017 | 0 => array('pipe', 'r'), |
|---|
| 1018 | 1 => array('pipe', 'w'), |
|---|
| 1019 | 2 => array('pipe', 'w') |
|---|
| 1020 | ), $pipes, $cwd, $bin_env, array('suppress_errors' => true, 'binary_pipes' => true)); |
|---|
| 1021 | |
|---|
| 1022 | if (!$proc) { |
|---|
| 1023 | return false; |
|---|
| 1024 | } |
|---|
| 1025 | |
|---|
| 1026 | if (!is_null($stdin)) { |
|---|
| 1027 | fwrite($pipes[0], (binary) $stdin); |
|---|
| 1028 | } |
|---|
| 1029 | fclose($pipes[0]); |
|---|
| 1030 | |
|---|
| 1031 | $timeout = $leak_check ? 300 : (isset($env['TEST_TIMEOUT']) ? $env['TEST_TIMEOUT'] : 60); |
|---|
| 1032 | |
|---|
| 1033 | while (true) { |
|---|
| 1034 | /* hide errors from interrupted syscalls */ |
|---|
| 1035 | $r = $pipes; |
|---|
| 1036 | $w = null; |
|---|
| 1037 | $e = null; |
|---|
| 1038 | |
|---|
| 1039 | $n = @stream_select($r, $w, $e, $timeout); |
|---|
| 1040 | |
|---|
| 1041 | if ($n === false) { |
|---|
| 1042 | break; |
|---|
| 1043 | } else if ($n === 0) { |
|---|
| 1044 | /* timed out */ |
|---|
| 1045 | $data .= "\n ** ERROR: process timed out **\n"; |
|---|
| 1046 | proc_terminate($proc); |
|---|
| 1047 | return $data; |
|---|
| 1048 | } else if ($n > 0) { |
|---|
| 1049 | $line = fread($pipes[1], 8192); |
|---|
| 1050 | if (strlen($line) == 0) { |
|---|
| 1051 | /* EOF */ |
|---|
| 1052 | break; |
|---|
| 1053 | } |
|---|
| 1054 | $data .= (binary) $line; |
|---|
| 1055 | } |
|---|
| 1056 | } |
|---|
| 1057 | |
|---|
| 1058 | $stat = proc_get_status($proc); |
|---|
| 1059 | |
|---|
| 1060 | if ($stat['signaled']) { |
|---|
| 1061 | $data .= "\nTermsig=" . $stat['stopsig']; |
|---|
| 1062 | } |
|---|
| 1063 | |
|---|
| 1064 | $code = proc_close($proc); |
|---|
| 1065 | return $data; |
|---|
| 1066 | } |
|---|
| 1067 | |
|---|
| 1068 | function run_all_tests($test_files, $env, $redir_tested = null) |
|---|
| 1069 | { |
|---|
| 1070 | global $test_results, $failed_tests_file, $php, $test_cnt, $test_idx; |
|---|
| 1071 | |
|---|
| 1072 | foreach($test_files as $name) { |
|---|
| 1073 | |
|---|
| 1074 | if (is_array($name)) { |
|---|
| 1075 | $index = "# $name[1]: $name[0]"; |
|---|
| 1076 | |
|---|
| 1077 | if ($redir_tested) { |
|---|
| 1078 | $name = $name[0]; |
|---|
| 1079 | } |
|---|
| 1080 | } else if ($redir_tested) { |
|---|
| 1081 | $index = "# $redir_tested: $name"; |
|---|
| 1082 | } else { |
|---|
| 1083 | $index = $name; |
|---|
| 1084 | } |
|---|
| 1085 | $test_idx++; |
|---|
| 1086 | $result = run_test($php, $name, $env); |
|---|
| 1087 | |
|---|
| 1088 | if (!is_array($name) && $result != 'REDIR') { |
|---|
| 1089 | $test_results[$index] = $result; |
|---|
| 1090 | if ($failed_tests_file && ($result == 'XFAILED' || $result == 'FAILED' || $result == 'WARNED' || $result == 'LEAKED')) { |
|---|
| 1091 | fwrite($failed_tests_file, "$index\n"); |
|---|
| 1092 | } |
|---|
| 1093 | } |
|---|
| 1094 | } |
|---|
| 1095 | } |
|---|
| 1096 | |
|---|
| 1097 | // |
|---|
| 1098 | // Show file or result block |
|---|
| 1099 | // |
|---|
| 1100 | function show_file_block($file, $block, $section = null) |
|---|
| 1101 | { |
|---|
| 1102 | global $cfg; |
|---|
| 1103 | |
|---|
| 1104 | if ($cfg['show'][$file]) { |
|---|
| 1105 | |
|---|
| 1106 | if (is_null($section)) { |
|---|
| 1107 | $section = strtoupper($file); |
|---|
| 1108 | } |
|---|
| 1109 | |
|---|
| 1110 | echo "\n========" . $section . "========\n"; |
|---|
| 1111 | echo rtrim($block); |
|---|
| 1112 | echo "\n========DONE========\n"; |
|---|
| 1113 | } |
|---|
| 1114 | } |
|---|
| 1115 | |
|---|
| 1116 | // |
|---|
| 1117 | // Run an individual test case. |
|---|
| 1118 | // |
|---|
| 1119 | function run_test($php, $file, $env) |
|---|
| 1120 | { |
|---|
| 1121 | global $log_format, $info_params, $ini_overwrites, $cwd, $PHP_FAILED_TESTS; |
|---|
| 1122 | global $pass_options, $DETAILED, $IN_REDIRECT, $test_cnt, $test_idx; |
|---|
| 1123 | global $leak_check, $temp_source, $temp_target, $cfg, $environment; |
|---|
| 1124 | global $no_clean; |
|---|
| 1125 | global $valgrind_version; |
|---|
| 1126 | |
|---|
| 1127 | $temp_filenames = null; |
|---|
| 1128 | $org_file = $file; |
|---|
| 1129 | |
|---|
| 1130 | if (isset($env['TEST_PHP_CGI_EXECUTABLE'])) { |
|---|
| 1131 | $php_cgi = $env['TEST_PHP_CGI_EXECUTABLE']; |
|---|
| 1132 | } |
|---|
| 1133 | |
|---|
| 1134 | if (is_array($file)) { |
|---|
| 1135 | $file = $file[0]; |
|---|
| 1136 | } |
|---|
| 1137 | |
|---|
| 1138 | if ($DETAILED) echo " |
|---|
| 1139 | ================= |
|---|
| 1140 | TEST $file |
|---|
| 1141 | "; |
|---|
| 1142 | |
|---|
| 1143 | // Load the sections of the test file. |
|---|
| 1144 | $section_text = array('TEST' => ''); |
|---|
| 1145 | |
|---|
| 1146 | $fp = fopen($file, "rt") or error("Cannot open test file: $file"); |
|---|
| 1147 | |
|---|
| 1148 | $borked = false; |
|---|
| 1149 | $bork_info = ''; |
|---|
| 1150 | |
|---|
| 1151 | if (!feof($fp)) { |
|---|
| 1152 | $line = fgets($fp); |
|---|
| 1153 | |
|---|
| 1154 | if ($line === false) { |
|---|
| 1155 | $bork_info = "cannot read test"; |
|---|
| 1156 | $borked = true; |
|---|
| 1157 | } |
|---|
| 1158 | } else { |
|---|
| 1159 | $bork_info = "empty test [$file]"; |
|---|
| 1160 | $borked = true; |
|---|
| 1161 | } |
|---|
| 1162 | if (!$borked && strncmp('--TEST--', $line, 8)) { |
|---|
| 1163 | $bork_info = "tests must start with --TEST-- [$file]"; |
|---|
| 1164 | $borked = true; |
|---|
| 1165 | } |
|---|
| 1166 | |
|---|
| 1167 | $section = 'TEST'; |
|---|
| 1168 | $secfile = false; |
|---|
| 1169 | $secdone = false; |
|---|
| 1170 | |
|---|
| 1171 | while (!feof($fp)) { |
|---|
| 1172 | $line = fgets($fp); |
|---|
| 1173 | |
|---|
| 1174 | // Match the beginning of a section. |
|---|
| 1175 | if (preg_match('/^--([_A-Z]+)--/', $line, $r)) { |
|---|
| 1176 | $section = $r[1]; |
|---|
| 1177 | |
|---|
| 1178 | if (isset($section_text[$section])) { |
|---|
| 1179 | $bork_info = "duplicated $section section"; |
|---|
| 1180 | $borked = true; |
|---|
| 1181 | } |
|---|
| 1182 | |
|---|
| 1183 | $section_text[$section] = ''; |
|---|
| 1184 | $secfile = $section == 'FILE' || $section == 'FILEEOF' || $section == 'FILE_EXTERNAL'; |
|---|
| 1185 | $secdone = false; |
|---|
| 1186 | continue; |
|---|
| 1187 | } |
|---|
| 1188 | |
|---|
| 1189 | // Add to the section text. |
|---|
| 1190 | if (!$secdone) { |
|---|
| 1191 | $section_text[$section] .= $line; |
|---|
| 1192 | } |
|---|
| 1193 | |
|---|
| 1194 | // End of actual test? |
|---|
| 1195 | if ($secfile && preg_match('/^===DONE===\s*$/', $line)) { |
|---|
| 1196 | $secdone = true; |
|---|
| 1197 | } |
|---|
| 1198 | } |
|---|
| 1199 | |
|---|
| 1200 | // the redirect section allows a set of tests to be reused outside of |
|---|
| 1201 | // a given test dir |
|---|
| 1202 | if (!$borked) { |
|---|
| 1203 | if (@count($section_text['REDIRECTTEST']) == 1) { |
|---|
| 1204 | |
|---|
| 1205 | if ($IN_REDIRECT) { |
|---|
| 1206 | $borked = true; |
|---|
| 1207 | $bork_info = "Can't redirect a test from within a redirected test"; |
|---|
| 1208 | } else { |
|---|
| 1209 | $borked = false; |
|---|
| 1210 | } |
|---|
| 1211 | |
|---|
| 1212 | } else { |
|---|
| 1213 | |
|---|
| 1214 | if (@count($section_text['FILE']) + @count($section_text['FILEEOF']) + @count($section_text['FILE_EXTERNAL']) != 1) { |
|---|
| 1215 | $bork_info = "missing section --FILE--"; |
|---|
| 1216 | $borked = true; |
|---|
| 1217 | } |
|---|
| 1218 | |
|---|
| 1219 | if (@count($section_text['FILEEOF']) == 1) { |
|---|
| 1220 | $section_text['FILE'] = preg_replace("/[\r\n]+$/", '', $section_text['FILEEOF']); |
|---|
| 1221 | unset($section_text['FILEEOF']); |
|---|
| 1222 | } |
|---|
| 1223 | |
|---|
| 1224 | if (@count($section_text['FILE_EXTERNAL']) == 1) { |
|---|
| 1225 | // don't allow tests to retrieve files from anywhere but this subdirectory |
|---|
| 1226 | $section_text['FILE_EXTERNAL'] = dirname($file) . '/' . trim(str_replace('..', '', $section_text['FILE_EXTERNAL'])); |
|---|
| 1227 | |
|---|
| 1228 | if (file_exists($section_text['FILE_EXTERNAL'])) { |
|---|
| 1229 | $section_text['FILE'] = file_get_contents($section_text['FILE_EXTERNAL']); |
|---|
| 1230 | unset($section_text['FILE_EXTERNAL']); |
|---|
| 1231 | } else { |
|---|
| 1232 | $bork_info = "could not load --FILE_EXTERNAL-- " . dirname($file) . '/' . trim($section_text['FILE_EXTERNAL']); |
|---|
| 1233 | $borked = true; |
|---|
| 1234 | } |
|---|
| 1235 | } |
|---|
| 1236 | |
|---|
| 1237 | if ((@count($section_text['EXPECT']) + @count($section_text['EXPECTF']) + @count($section_text['EXPECTREGEX'])) != 1) { |
|---|
| 1238 | $bork_info = "missing section --EXPECT--, --EXPECTF-- or --EXPECTREGEX--"; |
|---|
| 1239 | $borked = true; |
|---|
| 1240 | } |
|---|
| 1241 | } |
|---|
| 1242 | } |
|---|
| 1243 | fclose($fp); |
|---|
| 1244 | |
|---|
| 1245 | $shortname = str_replace($cwd . '/', '', $file); |
|---|
| 1246 | $tested_file = $shortname; |
|---|
| 1247 | |
|---|
| 1248 | if ($borked) { |
|---|
| 1249 | show_result("BORK", $bork_info, $tested_file); |
|---|
| 1250 | $PHP_FAILED_TESTS['BORKED'][] = array ( |
|---|
| 1251 | 'name' => $file, |
|---|
| 1252 | 'test_name' => '', |
|---|
| 1253 | 'output' => '', |
|---|
| 1254 | 'diff' => '', |
|---|
| 1255 | 'info' => "$bork_info [$file]", |
|---|
| 1256 | ); |
|---|
| 1257 | return 'BORKED'; |
|---|
| 1258 | } |
|---|
| 1259 | |
|---|
| 1260 | $tested = trim($section_text['TEST']); |
|---|
| 1261 | |
|---|
| 1262 | /* For GET/POST tests, check if cgi sapi is available and if it is, use it. */ |
|---|
| 1263 | if (!empty($section_text['GET']) || !empty($section_text['POST']) || !empty($section_text['POST_RAW']) || !empty($section_text['COOKIE']) || !empty($section_text['EXPECTHEADERS'])) { |
|---|
| 1264 | if (isset($php_cgi)) { |
|---|
| 1265 | $old_php = $php; |
|---|
| 1266 | $php = $php_cgi . ' -C '; |
|---|
| 1267 | } else if (!strncasecmp(PHP_OS, "win", 3) && file_exists(dirname($php) . "/php-cgi.exe")) { |
|---|
| 1268 | $old_php = $php; |
|---|
| 1269 | $php = realpath(dirname($php) . "/php-cgi.exe") . ' -C '; |
|---|
| 1270 | } else { |
|---|
| 1271 | if (file_exists(dirname($php) . "/../../sapi/cgi/php-cgi")) { |
|---|
| 1272 | $old_php = $php; |
|---|
| 1273 | $php = realpath(dirname($php) . "/../../sapi/cgi/php-cgi") . ' -C '; |
|---|
| 1274 | } else if (file_exists("./sapi/cgi/php-cgi")) { |
|---|
| 1275 | $old_php = $php; |
|---|
| 1276 | $php = realpath("./sapi/cgi/php-cgi") . ' -C '; |
|---|
| 1277 | } else { |
|---|
| 1278 | show_result('SKIP', $tested, $tested_file, "reason: CGI not available"); |
|---|
| 1279 | return 'SKIPPED'; |
|---|
| 1280 | } |
|---|
| 1281 | } |
|---|
| 1282 | } |
|---|
| 1283 | |
|---|
| 1284 | show_test($test_idx, $shortname); |
|---|
| 1285 | |
|---|
| 1286 | if (is_array($IN_REDIRECT)) { |
|---|
| 1287 | $temp_dir = $test_dir = $IN_REDIRECT['dir']; |
|---|
| 1288 | } else { |
|---|
| 1289 | $temp_dir = $test_dir = realpath(dirname($file)); |
|---|
| 1290 | } |
|---|
| 1291 | |
|---|
| 1292 | if ($temp_source && $temp_target) { |
|---|
| 1293 | $temp_dir = str_replace($temp_source, $temp_target, $temp_dir); |
|---|
| 1294 | } |
|---|
| 1295 | |
|---|
| 1296 | $main_file_name = basename($file,'phpt'); |
|---|
| 1297 | |
|---|
| 1298 | $diff_filename = $temp_dir . DIRECTORY_SEPARATOR . $main_file_name . 'diff'; |
|---|
| 1299 | $log_filename = $temp_dir . DIRECTORY_SEPARATOR . $main_file_name . 'log'; |
|---|
| 1300 | $exp_filename = $temp_dir . DIRECTORY_SEPARATOR . $main_file_name . 'exp'; |
|---|
| 1301 | $output_filename = $temp_dir . DIRECTORY_SEPARATOR . $main_file_name . 'out'; |
|---|
| 1302 | $memcheck_filename = $temp_dir . DIRECTORY_SEPARATOR . $main_file_name . 'mem'; |
|---|
| 1303 | $temp_file = $temp_dir . DIRECTORY_SEPARATOR . $main_file_name . 'php'; |
|---|
| 1304 | $test_file = $test_dir . DIRECTORY_SEPARATOR . $main_file_name . 'php'; |
|---|
| 1305 | $temp_skipif = $temp_dir . DIRECTORY_SEPARATOR . $main_file_name . 'skip.php'; |
|---|
| 1306 | $test_skipif = $test_dir . DIRECTORY_SEPARATOR . $main_file_name . 'skip.php'; |
|---|
| 1307 | $temp_clean = $temp_dir . DIRECTORY_SEPARATOR . $main_file_name . 'clean.php'; |
|---|
| 1308 | $test_clean = $test_dir . DIRECTORY_SEPARATOR . $main_file_name . 'clean.php'; |
|---|
| 1309 | $tmp_post = $temp_dir . DIRECTORY_SEPARATOR . uniqid('/phpt.'); |
|---|
| 1310 | $tmp_relative_file = str_replace(__DIR__ . DIRECTORY_SEPARATOR, '', $test_file) . 't'; |
|---|
| 1311 | |
|---|
| 1312 | if ($temp_source && $temp_target) { |
|---|
| 1313 | $temp_skipif .= 's'; |
|---|
| 1314 | $temp_file .= 's'; |
|---|
| 1315 | $temp_clean .= 's'; |
|---|
| 1316 | $copy_file = $temp_dir . DIRECTORY_SEPARATOR . basename(is_array($file) ? $file[1] : $file) . '.phps'; |
|---|
| 1317 | |
|---|
| 1318 | if (!is_dir(dirname($copy_file))) { |
|---|
| 1319 | mkdir(dirname($copy_file), 0777, true) or error("Cannot create output directory - " . dirname($copy_file)); |
|---|
| 1320 | } |
|---|
| 1321 | |
|---|
| 1322 | if (isset($section_text['FILE'])) { |
|---|
| 1323 | save_text($copy_file, $section_text['FILE']); |
|---|
| 1324 | } |
|---|
| 1325 | |
|---|
| 1326 | $temp_filenames = array( |
|---|
| 1327 | 'file' => $copy_file, |
|---|
| 1328 | 'diff' => $diff_filename, |
|---|
| 1329 | 'log' => $log_filename, |
|---|
| 1330 | 'exp' => $exp_filename, |
|---|
| 1331 | 'out' => $output_filename, |
|---|
| 1332 | 'mem' => $memcheck_filename, |
|---|
| 1333 | 'php' => $temp_file, |
|---|
| 1334 | 'skip' => $temp_skipif, |
|---|
| 1335 | 'clean'=> $temp_clean); |
|---|
| 1336 | } |
|---|
| 1337 | |
|---|
| 1338 | if (is_array($IN_REDIRECT)) { |
|---|
| 1339 | $tested = $IN_REDIRECT['prefix'] . ' ' . trim($section_text['TEST']); |
|---|
| 1340 | $tested_file = $tmp_relative_file; |
|---|
| 1341 | $section_text['FILE'] = "# original source file: $shortname\n" . $section_text['FILE']; |
|---|
| 1342 | } |
|---|
| 1343 | |
|---|
| 1344 | // unlink old test results |
|---|
| 1345 | @unlink($diff_filename); |
|---|
| 1346 | @unlink($log_filename); |
|---|
| 1347 | @unlink($exp_filename); |
|---|
| 1348 | @unlink($output_filename); |
|---|
| 1349 | @unlink($memcheck_filename); |
|---|
| 1350 | @unlink($temp_file); |
|---|
| 1351 | @unlink($test_file); |
|---|
| 1352 | @unlink($temp_skipif); |
|---|
| 1353 | @unlink($test_skipif); |
|---|
| 1354 | @unlink($tmp_post); |
|---|
| 1355 | @unlink($temp_clean); |
|---|
| 1356 | @unlink($test_clean); |
|---|
| 1357 | |
|---|
| 1358 | // Reset environment from any previous test. |
|---|
| 1359 | $env['REDIRECT_STATUS'] = ''; |
|---|
| 1360 | $env['QUERY_STRING'] = ''; |
|---|
| 1361 | $env['PATH_TRANSLATED'] = ''; |
|---|
| 1362 | $env['SCRIPT_FILENAME'] = ''; |
|---|
| 1363 | $env['REQUEST_METHOD'] = ''; |
|---|
| 1364 | $env['CONTENT_TYPE'] = ''; |
|---|
| 1365 | $env['CONTENT_LENGTH'] = ''; |
|---|
| 1366 | |
|---|
| 1367 | if (!empty($section_text['ENV'])) { |
|---|
| 1368 | |
|---|
| 1369 | foreach(explode("\n", trim($section_text['ENV'])) as $e) { |
|---|
| 1370 | $e = explode('=', trim($e), 2); |
|---|
| 1371 | |
|---|
| 1372 | if (!empty($e[0]) && isset($e[1])) { |
|---|
| 1373 | $env[$e[0]] = $e[1]; |
|---|
| 1374 | } |
|---|
| 1375 | } |
|---|
| 1376 | } |
|---|
| 1377 | |
|---|
| 1378 | // Default ini settings |
|---|
| 1379 | $ini_settings = array(); |
|---|
| 1380 | // additional ini overwrites |
|---|
| 1381 | //$ini_overwrites[] = 'setting=value'; |
|---|
| 1382 | settings2array($ini_overwrites, $ini_settings); |
|---|
| 1383 | |
|---|
| 1384 | // Any special ini settings |
|---|
| 1385 | // these may overwrite the test defaults... |
|---|
| 1386 | if (array_key_exists('INI', $section_text)) { |
|---|
| 1387 | if (strpos($section_text['INI'], '{PWD}') !== false) { |
|---|
| 1388 | $section_text['INI'] = str_replace('{PWD}', dirname($file), $section_text['INI']); |
|---|
| 1389 | } |
|---|
| 1390 | settings2array(preg_split( "/[\n\r]+/", $section_text['INI']), $ini_settings); |
|---|
| 1391 | } |
|---|
| 1392 | |
|---|
| 1393 | settings2params($ini_settings); |
|---|
| 1394 | |
|---|
| 1395 | // Check if test should be skipped. |
|---|
| 1396 | $info = ''; |
|---|
| 1397 | $warn = false; |
|---|
| 1398 | |
|---|
| 1399 | if (array_key_exists('SKIPIF', $section_text)) { |
|---|
| 1400 | |
|---|
| 1401 | if (trim($section_text['SKIPIF'])) { |
|---|
| 1402 | show_file_block('skip', $section_text['SKIPIF']); |
|---|
| 1403 | save_text($test_skipif, $section_text['SKIPIF'], $temp_skipif); |
|---|
| 1404 | $extra = substr(PHP_OS, 0, 3) !== "WIN" ? |
|---|
| 1405 | "unset REQUEST_METHOD; unset QUERY_STRING; unset PATH_TRANSLATED; unset SCRIPT_FILENAME; unset REQUEST_METHOD;": ""; |
|---|
| 1406 | |
|---|
| 1407 | if ($leak_check) { |
|---|
| 1408 | $env['USE_ZEND_ALLOC'] = '0'; |
|---|
| 1409 | } else { |
|---|
| 1410 | $env['USE_ZEND_ALLOC'] = '1'; |
|---|
| 1411 | } |
|---|
| 1412 | |
|---|
| 1413 | $output = system_with_timeout("$extra $php $pass_options -q $ini_settings $test_skipif", $env); |
|---|
| 1414 | |
|---|
| 1415 | if (!$cfg['keep']['skip']) { |
|---|
| 1416 | @unlink($test_skipif); |
|---|
| 1417 | } |
|---|
| 1418 | |
|---|
| 1419 | if (!strncasecmp('skip', ltrim($output), 4)) { |
|---|
| 1420 | |
|---|
| 1421 | if (preg_match('/^\s*skip\s*(.+)\s*/i', $output, $m)) { |
|---|
| 1422 | show_result('SKIP', $tested, $tested_file, "reason: $m[1]", $temp_filenames); |
|---|
| 1423 | } else { |
|---|
| 1424 | show_result('SKIP', $tested, $tested_file, '', $temp_filenames); |
|---|
| 1425 | } |
|---|
| 1426 | |
|---|
| 1427 | if (isset($old_php)) { |
|---|
| 1428 | $php = $old_php; |
|---|
| 1429 | } |
|---|
| 1430 | |
|---|
| 1431 | if (!$cfg['keep']['skip']) { |
|---|
| 1432 | @unlink($test_skipif); |
|---|
| 1433 | } |
|---|
| 1434 | |
|---|
| 1435 | return 'SKIPPED'; |
|---|
| 1436 | } |
|---|
| 1437 | |
|---|
| 1438 | if (!strncasecmp('info', ltrim($output), 4)) { |
|---|
| 1439 | if (preg_match('/^\s*info\s*(.+)\s*/i', $output, $m)) { |
|---|
| 1440 | $info = " (info: $m[1])"; |
|---|
| 1441 | } |
|---|
| 1442 | } |
|---|
| 1443 | |
|---|
| 1444 | if (!strncasecmp('warn', ltrim($output), 4)) { |
|---|
| 1445 | if (preg_match('/^\s*warn\s*(.+)\s*/i', $output, $m)) { |
|---|
| 1446 | $warn = true; /* only if there is a reason */ |
|---|
| 1447 | $info = " (warn: $m[1])"; |
|---|
| 1448 | } |
|---|
| 1449 | } |
|---|
| 1450 | } |
|---|
| 1451 | } |
|---|
| 1452 | |
|---|
| 1453 | if (@count($section_text['REDIRECTTEST']) == 1) { |
|---|
| 1454 | $test_files = array(); |
|---|
| 1455 | |
|---|
| 1456 | $IN_REDIRECT = eval($section_text['REDIRECTTEST']); |
|---|
| 1457 | $IN_REDIRECT['via'] = "via [$shortname]\n\t"; |
|---|
| 1458 | $IN_REDIRECT['dir'] = realpath(dirname($file)); |
|---|
| 1459 | $IN_REDIRECT['prefix'] = trim($section_text['TEST']); |
|---|
| 1460 | |
|---|
| 1461 | if (count($IN_REDIRECT['TESTS']) == 1) { |
|---|
| 1462 | |
|---|
| 1463 | if (is_array($org_file)) { |
|---|
| 1464 | $test_files[] = $org_file[1]; |
|---|
| 1465 | } else { |
|---|
| 1466 | $GLOBALS['test_files'] = $test_files; |
|---|
| 1467 | find_files($IN_REDIRECT['TESTS']); |
|---|
| 1468 | |
|---|
| 1469 | foreach($GLOBALS['test_files'] as $f) { |
|---|
| 1470 | $test_files[] = array($f, $file); |
|---|
| 1471 | } |
|---|
| 1472 | } |
|---|
| 1473 | $test_cnt += @count($test_files) - 1; |
|---|
| 1474 | $test_idx--; |
|---|
| 1475 | |
|---|
| 1476 | show_redirect_start($IN_REDIRECT['TESTS'], $tested, $tested_file); |
|---|
| 1477 | |
|---|
| 1478 | // set up environment |
|---|
| 1479 | $redirenv = array_merge($environment, $IN_REDIRECT['ENV']); |
|---|
| 1480 | $redirenv['REDIR_TEST_DIR'] = realpath($IN_REDIRECT['TESTS']) . DIRECTORY_SEPARATOR; |
|---|
| 1481 | |
|---|
| 1482 | usort($test_files, "test_sort"); |
|---|
| 1483 | run_all_tests($test_files, $redirenv, $tested); |
|---|
| 1484 | |
|---|
| 1485 | show_redirect_ends($IN_REDIRECT['TESTS'], $tested, $tested_file); |
|---|
| 1486 | |
|---|
| 1487 | // a redirected test never fails |
|---|
| 1488 | $IN_REDIRECT = false; |
|---|
| 1489 | return 'REDIR'; |
|---|
| 1490 | |
|---|
| 1491 | } else { |
|---|
| 1492 | |
|---|
| 1493 | $bork_info = "Redirect info must contain exactly one TEST string to be used as redirect directory."; |
|---|
| 1494 | show_result("BORK", $bork_info, '', $temp_filenames); |
|---|
| 1495 | $PHP_FAILED_TESTS['BORKED'][] = array ( |
|---|
| 1496 | 'name' => $file, |
|---|
| 1497 | 'test_name' => '', |
|---|
| 1498 | 'output' => '', |
|---|
| 1499 | 'diff' => '', |
|---|
| 1500 | 'info' => "$bork_info [$file]", |
|---|
| 1501 | ); |
|---|
| 1502 | } |
|---|
| 1503 | } |
|---|
| 1504 | |
|---|
| 1505 | if (is_array($org_file) || @count($section_text['REDIRECTTEST']) == 1) { |
|---|
| 1506 | |
|---|
| 1507 | if (is_array($org_file)) { |
|---|
| 1508 | $file = $org_file[0]; |
|---|
| 1509 | } |
|---|
| 1510 | |
|---|
| 1511 | $bork_info = "Redirected test did not contain redirection info"; |
|---|
| 1512 | show_result("BORK", $bork_info, '', $temp_filenames); |
|---|
| 1513 | $PHP_FAILED_TESTS['BORKED'][] = array ( |
|---|
| 1514 | 'name' => $file, |
|---|
| 1515 | 'test_name' => '', |
|---|
| 1516 | 'output' => '', |
|---|
| 1517 | 'diff' => '', |
|---|
| 1518 | 'info' => "$bork_info [$file]", |
|---|
| 1519 | ); |
|---|
| 1520 | return 'BORKED'; |
|---|
| 1521 | } |
|---|
| 1522 | |
|---|
| 1523 | // We've satisfied the preconditions - run the test! |
|---|
| 1524 | show_file_block('php', $section_text['FILE'], 'TEST'); |
|---|
| 1525 | save_text($test_file, $section_text['FILE'], $temp_file); |
|---|
| 1526 | |
|---|
| 1527 | if (array_key_exists('GET', $section_text)) { |
|---|
| 1528 | $query_string = trim($section_text['GET']); |
|---|
| 1529 | } else { |
|---|
| 1530 | $query_string = ''; |
|---|
| 1531 | } |
|---|
| 1532 | |
|---|
| 1533 | $env['REDIRECT_STATUS'] = '1'; |
|---|
| 1534 | $env['QUERY_STRING'] = $query_string; |
|---|
| 1535 | $env['PATH_TRANSLATED'] = $test_file; |
|---|
| 1536 | $env['SCRIPT_FILENAME'] = $test_file; |
|---|
| 1537 | |
|---|
| 1538 | if (array_key_exists('COOKIE', $section_text)) { |
|---|
| 1539 | $env['HTTP_COOKIE'] = trim($section_text['COOKIE']); |
|---|
| 1540 | } else { |
|---|
| 1541 | $env['HTTP_COOKIE'] = ''; |
|---|
| 1542 | } |
|---|
| 1543 | |
|---|
| 1544 | $args = isset($section_text['ARGS']) ? ' -- ' . $section_text['ARGS'] : ''; |
|---|
| 1545 | |
|---|
| 1546 | if (array_key_exists('POST_RAW', $section_text) && !empty($section_text['POST_RAW'])) { |
|---|
| 1547 | |
|---|
| 1548 | $post = trim($section_text['POST_RAW']); |
|---|
| 1549 | $raw_lines = explode("\n", $post); |
|---|
| 1550 | |
|---|
| 1551 | $request = ''; |
|---|
| 1552 | $started = false; |
|---|
| 1553 | |
|---|
| 1554 | foreach ($raw_lines as $line) { |
|---|
| 1555 | |
|---|
| 1556 | if (empty($env['CONTENT_TYPE']) && preg_match('/^Content-Type:(.*)/i', $line, $res)) { |
|---|
| 1557 | $env['CONTENT_TYPE'] = trim(str_replace("\r", '', $res[1])); |
|---|
| 1558 | continue; |
|---|
| 1559 | } |
|---|
| 1560 | |
|---|
| 1561 | if ($started) { |
|---|
| 1562 | $request .= "\n"; |
|---|
| 1563 | } |
|---|
| 1564 | |
|---|
| 1565 | $started = true; |
|---|
| 1566 | $request .= $line; |
|---|
| 1567 | } |
|---|
| 1568 | |
|---|
| 1569 | $env['CONTENT_LENGTH'] = strlen($request); |
|---|
| 1570 | $env['REQUEST_METHOD'] = 'POST'; |
|---|
| 1571 | |
|---|
| 1572 | if (empty($request)) { |
|---|
| 1573 | return 'BORKED'; |
|---|
| 1574 | } |
|---|
| 1575 | |
|---|
| 1576 | save_text($tmp_post, $request); |
|---|
| 1577 | $cmd = "$php $pass_options $ini_settings -f \"$test_file\" 2>&1 < $tmp_post"; |
|---|
| 1578 | |
|---|
| 1579 | } else if (array_key_exists('POST', $section_text) && !empty($section_text['POST'])) { |
|---|
| 1580 | |
|---|
| 1581 | $post = trim($section_text['POST']); |
|---|
| 1582 | |
|---|
| 1583 | if (array_key_exists('GZIP_POST', $section_text) && function_exists('gzencode')) { |
|---|
| 1584 | $post = gzencode($post, 9, FORCE_GZIP); |
|---|
| 1585 | $env['HTTP_CONTENT_ENCODING'] = 'gzip'; |
|---|
| 1586 | } else if (array_key_exists('DEFLATE_POST', $section_text) && function_exists('gzcompress')) { |
|---|
| 1587 | $post = gzcompress($post, 9); |
|---|
| 1588 | $env['HTTP_CONTENT_ENCODING'] = 'deflate'; |
|---|
| 1589 | } |
|---|
| 1590 | |
|---|
| 1591 | save_text($tmp_post, $post); |
|---|
| 1592 | $content_length = strlen($post); |
|---|
| 1593 | |
|---|
| 1594 | $env['REQUEST_METHOD'] = 'POST'; |
|---|
| 1595 | $env['CONTENT_TYPE'] = 'application/x-www-form-urlencoded'; |
|---|
| 1596 | $env['CONTENT_LENGTH'] = $content_length; |
|---|
| 1597 | |
|---|
| 1598 | $cmd = "$php $pass_options $ini_settings -f \"$test_file\" 2>&1 < $tmp_post"; |
|---|
| 1599 | |
|---|
| 1600 | } else { |
|---|
| 1601 | |
|---|
| 1602 | $env['REQUEST_METHOD'] = 'GET'; |
|---|
| 1603 | $env['CONTENT_TYPE'] = ''; |
|---|
| 1604 | $env['CONTENT_LENGTH'] = ''; |
|---|
| 1605 | |
|---|
| 1606 | $cmd = "$php $pass_options $ini_settings -f \"$test_file\" $args 2>&1"; |
|---|
| 1607 | } |
|---|
| 1608 | |
|---|
| 1609 | if ($leak_check) { |
|---|
| 1610 | $env['USE_ZEND_ALLOC'] = '0'; |
|---|
| 1611 | |
|---|
| 1612 | if ($valgrind_version >= 330) { |
|---|
| 1613 | /* valgrind 3.3.0+ doesn't have --log-file-exactly option */ |
|---|
| 1614 | $cmd = "valgrind -q --tool=memcheck --trace-children=yes --log-file=$memcheck_filename $cmd"; |
|---|
| 1615 | } else { |
|---|
| 1616 | $cmd = "valgrind -q --tool=memcheck --trace-children=yes --log-file-exactly=$memcheck_filename $cmd"; |
|---|
| 1617 | } |
|---|
| 1618 | |
|---|
| 1619 | } else { |
|---|
| 1620 | $env['USE_ZEND_ALLOC'] = '1'; |
|---|
| 1621 | } |
|---|
| 1622 | |
|---|
| 1623 | if ($DETAILED) echo " |
|---|
| 1624 | CONTENT_LENGTH = " . $env['CONTENT_LENGTH'] . " |
|---|
| 1625 | CONTENT_TYPE = " . $env['CONTENT_TYPE'] . " |
|---|
| 1626 | PATH_TRANSLATED = " . $env['PATH_TRANSLATED'] . " |
|---|
| 1627 | QUERY_STRING = " . $env['QUERY_STRING'] . " |
|---|
| 1628 | REDIRECT_STATUS = " . $env['REDIRECT_STATUS'] . " |
|---|
| 1629 | REQUEST_METHOD = " . $env['REQUEST_METHOD'] . " |
|---|
| 1630 | SCRIPT_FILENAME = " . $env['SCRIPT_FILENAME'] . " |
|---|
| 1631 | HTTP_COOKIE = " . $env['HTTP_COOKIE'] . " |
|---|
| 1632 | COMMAND $cmd |
|---|
| 1633 | "; |
|---|
| 1634 | |
|---|
| 1635 | $out = system_with_timeout($cmd, $env, isset($section_text['STDIN']) ? $section_text['STDIN'] : null); |
|---|
| 1636 | |
|---|
| 1637 | if (array_key_exists('CLEAN', $section_text) && (!$no_clean || $cfg['keep']['clean'])) { |
|---|
| 1638 | |
|---|
| 1639 | if (trim($section_text['CLEAN'])) { |
|---|
| 1640 | show_file_block('clean', $section_text['CLEAN']); |
|---|
| 1641 | save_text($test_clean, trim($section_text['CLEAN']), $temp_clean); |
|---|
| 1642 | |
|---|
| 1643 | if (!$no_clean) { |
|---|
| 1644 | $clean_params = array(); |
|---|
| 1645 | settings2array($ini_overwrites, $clean_params); |
|---|
| 1646 | settings2params($clean_params); |
|---|
| 1647 | $extra = substr(PHP_OS, 0, 3) !== "WIN" ? |
|---|
| 1648 | "unset REQUEST_METHOD; unset QUERY_STRING; unset PATH_TRANSLATED; unset SCRIPT_FILENAME; unset REQUEST_METHOD;": ""; |
|---|
| 1649 | system_with_timeout("$extra $php $pass_options -q $clean_params $test_clean", $env); |
|---|
| 1650 | } |
|---|
| 1651 | |
|---|
| 1652 | if (!$cfg['keep']['clean']) { |
|---|
| 1653 | @unlink($test_clean); |
|---|
| 1654 | } |
|---|
| 1655 | } |
|---|
| 1656 | } |
|---|
| 1657 | |
|---|
| 1658 | @unlink($tmp_post); |
|---|
| 1659 | |
|---|
| 1660 | $leaked = false; |
|---|
| 1661 | $passed = false; |
|---|
| 1662 | |
|---|
| 1663 | if ($leak_check) { // leak check |
|---|
| 1664 | $leaked = filesize($memcheck_filename) > 0; |
|---|
| 1665 | |
|---|
| 1666 | if (!$leaked) { |
|---|
| 1667 | @unlink($memcheck_filename); |
|---|
| 1668 | } |
|---|
| 1669 | } |
|---|
| 1670 | |
|---|
| 1671 | // Does the output match what is expected? |
|---|
| 1672 | $output = preg_replace("/\r\n/", "\n", trim($out)); |
|---|
| 1673 | |
|---|
| 1674 | /* when using CGI, strip the headers from the output */ |
|---|
| 1675 | $headers = ""; |
|---|
| 1676 | |
|---|
| 1677 | if (isset($old_php) && preg_match("/^(.*?)\r?\n\r?\n(.*)/s", $out, $match)) { |
|---|
| 1678 | $output = trim($match[2]); |
|---|
| 1679 | $rh = preg_split("/[\n\r]+/", $match[1]); |
|---|
| 1680 | $headers = array(); |
|---|
| 1681 | |
|---|
| 1682 | foreach ($rh as $line) { |
|---|
| 1683 | if (strpos($line, ':') !== false) { |
|---|
| 1684 | $line = explode(':', $line, 2); |
|---|
| 1685 | $headers[trim($line[0])] = trim($line[1]); |
|---|
| 1686 | } |
|---|
| 1687 | } |
|---|
| 1688 | } |
|---|
| 1689 | |
|---|
| 1690 | $failed_headers = false; |
|---|
| 1691 | |
|---|
| 1692 | if (isset($section_text['EXPECTHEADERS'])) { |
|---|
| 1693 | $want = array(); |
|---|
| 1694 | $wanted_headers = array(); |
|---|
| 1695 | $lines = preg_split("/[\n\r]+/", $section_text['EXPECTHEADERS']); |
|---|
| 1696 | |
|---|
| 1697 | foreach($lines as $line) { |
|---|
| 1698 | if (strpos($line, ':') !== false) { |
|---|
| 1699 | $line = explode(':', $line, 2); |
|---|
| 1700 | $want[trim($line[0])] = trim($line[1]); |
|---|
| 1701 | $wanted_headers[] = trim($line[0]) . ': ' . trim($line[1]); |
|---|
| 1702 | } |
|---|
| 1703 | } |
|---|
| 1704 | |
|---|
| 1705 | $org_headers = $headers; |
|---|
| 1706 | $headers = array(); |
|---|
| 1707 | $output_headers = array(); |
|---|
| 1708 | |
|---|
| 1709 | foreach($want as $k => $v) { |
|---|
| 1710 | |
|---|
| 1711 | if (isset($org_headers[$k])) { |
|---|
| 1712 | $headers = $org_headers[$k]; |
|---|
| 1713 | $output_headers[] = $k . ': ' . $org_headers[$k]; |
|---|
| 1714 | } |
|---|
| 1715 | |
|---|
| 1716 | if (!isset($org_headers[$k]) || $org_headers[$k] != $v) { |
|---|
| 1717 | $failed_headers = true; |
|---|
| 1718 | } |
|---|
| 1719 | } |
|---|
| 1720 | |
|---|
| 1721 | ksort($wanted_headers); |
|---|
| 1722 | $wanted_headers = join("\n", $wanted_headers); |
|---|
| 1723 | ksort($output_headers); |
|---|
| 1724 | $output_headers = join("\n", $output_headers); |
|---|
| 1725 | } |
|---|
| 1726 | |
|---|
| 1727 | show_file_block('out', $output); |
|---|
| 1728 | |
|---|
| 1729 | if (isset($section_text['EXPECTF']) || isset($section_text['EXPECTREGEX'])) { |
|---|
| 1730 | |
|---|
| 1731 | if (isset($section_text['EXPECTF'])) { |
|---|
| 1732 | $wanted = trim($section_text['EXPECTF']); |
|---|
| 1733 | } else { |
|---|
| 1734 | $wanted = trim($section_text['EXPECTREGEX']); |
|---|
| 1735 | } |
|---|
| 1736 | |
|---|
| 1737 | show_file_block('exp', $wanted); |
|---|
| 1738 | $wanted_re = preg_replace('/\r\n/', "\n", $wanted); |
|---|
| 1739 | |
|---|
| 1740 | if (isset($section_text['EXPECTF'])) { |
|---|
| 1741 | $wanted_re = preg_quote($wanted_re, '/'); |
|---|
| 1742 | $wanted_re = str_replace( |
|---|
| 1743 | array('%binary_string_optional%'), |
|---|
| 1744 | version_compare(PHP_VERSION, '6.0.0-dev') == -1 ? 'string' : 'binary string', |
|---|
| 1745 | $wanted_re |
|---|
| 1746 | ); |
|---|
| 1747 | $wanted_re = str_replace( |
|---|
| 1748 | array('%unicode_string_optional%'), |
|---|
| 1749 | version_compare(PHP_VERSION, '6.0.0-dev') == -1 ? 'string' : 'Unicode string', |
|---|
| 1750 | $wanted_re |
|---|
| 1751 | ); |
|---|
| 1752 | $wanted_re = str_replace( |
|---|
| 1753 | array('%unicode\|string%', '%string\|unicode%'), |
|---|
| 1754 | version_compare(PHP_VERSION, '6.0.0-dev') == -1 ? 'string' : 'unicode', |
|---|
| 1755 | $wanted_re |
|---|
| 1756 | ); |
|---|
| 1757 | $wanted_re = str_replace( |
|---|
| 1758 | array('%u\|b%', '%b\|u%'), |
|---|
| 1759 | version_compare(PHP_VERSION, '6.0.0-dev') == -1 ? '' : 'u', |
|---|
| 1760 | $wanted_re |
|---|
| 1761 | ); |
|---|
| 1762 | // Stick to basics |
|---|
| 1763 | $wanted_re = str_replace('%e', '\\' . DIRECTORY_SEPARATOR, $wanted_re); |
|---|
| 1764 | $wanted_re = str_replace('%s', '[^\r\n]+', $wanted_re); |
|---|
| 1765 | $wanted_re = str_replace('%S', '[^\r\n]*', $wanted_re); |
|---|
| 1766 | $wanted_re = str_replace('%a', '.+', $wanted_re); |
|---|
| 1767 | $wanted_re = str_replace('%A', '.*', $wanted_re); |
|---|
| 1768 | $wanted_re = str_replace('%w', '\s*', $wanted_re); |
|---|
| 1769 | $wanted_re = str_replace('%i', '[+-]?\d+', $wanted_re); |
|---|
| 1770 | $wanted_re = str_replace('%d', '\d+', $wanted_re); |
|---|
| 1771 | $wanted_re = str_replace('%x', '[0-9a-fA-F]+', $wanted_re); |
|---|
| 1772 | $wanted_re = str_replace('%f', '[+-]?\.?\d+\.?\d*(?:[Ee][+-]?\d+)?', $wanted_re); |
|---|
| 1773 | $wanted_re = str_replace('%c', '.', $wanted_re); |
|---|
| 1774 | // %f allows two points "-.0.0" but that is the best *simple* expression |
|---|
| 1775 | } |
|---|
| 1776 | /* DEBUG YOUR REGEX HERE |
|---|
| 1777 | var_dump($wanted_re); |
|---|
| 1778 | print(str_repeat('=', 80) . "\n"); |
|---|
| 1779 | var_dump($output); |
|---|
| 1780 | */ |
|---|
| 1781 | if (preg_match((binary) "/^$wanted_re\$/s", $output)) { |
|---|
| 1782 | $passed = true; |
|---|
| 1783 | if (!$cfg['keep']['php']) { |
|---|
| 1784 | @unlink($test_file); |
|---|
| 1785 | } |
|---|
| 1786 | if (isset($old_php)) { |
|---|
| 1787 | $php = $old_php; |
|---|
| 1788 | } |
|---|
| 1789 | |
|---|
| 1790 | if (!$leaked && !$failed_headers) { |
|---|
| 1791 | if (isset($section_text['XFAIL'] )) { |
|---|
| 1792 | $warn = true; |
|---|
| 1793 | $info = " (warn: XFAIL section but test passes)"; |
|---|
| 1794 | }else { |
|---|
| 1795 | show_result("PASS", $tested, $tested_file, '', $temp_filenames); |
|---|
| 1796 | return 'PASSED'; |
|---|
| 1797 | } |
|---|
| 1798 | } |
|---|
| 1799 | } |
|---|
| 1800 | |
|---|
| 1801 | } else { |
|---|
| 1802 | |
|---|
| 1803 | $wanted = trim($section_text['EXPECT']); |
|---|
| 1804 | $wanted = preg_replace('/\r\n/',"\n", $wanted); |
|---|
| 1805 | show_file_block('exp', $wanted); |
|---|
| 1806 | |
|---|
| 1807 | // compare and leave on success |
|---|
| 1808 | if (!strcmp($output, $wanted)) { |
|---|
| 1809 | $passed = true; |
|---|
| 1810 | |
|---|
| 1811 | if (!$cfg['keep']['php']) { |
|---|
| 1812 | @unlink($test_file); |
|---|
| 1813 | } |
|---|
| 1814 | |
|---|
| 1815 | if (isset($old_php)) { |
|---|
| 1816 | $php = $old_php; |
|---|
| 1817 | } |
|---|
| 1818 | |
|---|
| 1819 | if (!$leaked && !$failed_headers) { |
|---|
| 1820 | if (isset($section_text['XFAIL'] )) { |
|---|
| 1821 | $warn = true; |
|---|
| 1822 | $info = " (warn: XFAIL section but test passes)"; |
|---|
| 1823 | }else { |
|---|
| 1824 | show_result("PASS", $tested, $tested_file, '', $temp_filenames); |
|---|
| 1825 | return 'PASSED'; |
|---|
| 1826 | } |
|---|
| 1827 | } |
|---|
| 1828 | } |
|---|
| 1829 | |
|---|
| 1830 | $wanted_re = null; |
|---|
| 1831 | } |
|---|
| 1832 | |
|---|
| 1833 | // Test failed so we need to report details. |
|---|
| 1834 | if ($failed_headers) { |
|---|
| 1835 | $passed = false; |
|---|
| 1836 | $wanted = $wanted_headers . "\n--HEADERS--\n" . $wanted; |
|---|
| 1837 | $output = $output_headers . "\n--HEADERS--\n" . $output; |
|---|
| 1838 | |
|---|
| 1839 | if (isset($wanted_re)) { |
|---|
| 1840 | $wanted_re = preg_quote($wanted_headers . "\n--HEADERS--\n", '/') . $wanted_re; |
|---|
| 1841 | } |
|---|
| 1842 | } |
|---|
| 1843 | |
|---|
| 1844 | if ($leaked) { |
|---|
| 1845 | $restype[] = 'LEAK'; |
|---|
| 1846 | } |
|---|
| 1847 | |
|---|
| 1848 | if ($warn) { |
|---|
| 1849 | $restype[] = 'WARN'; |
|---|
| 1850 | } |
|---|
| 1851 | |
|---|
| 1852 | if (!$passed) { |
|---|
| 1853 | if (isset($section_text['XFAIL'])) { |
|---|
| 1854 | $restype[] = 'XFAIL'; |
|---|
| 1855 | } else { |
|---|
| 1856 | $restype[] = 'FAIL'; |
|---|
| 1857 | } |
|---|
| 1858 | } |
|---|
| 1859 | |
|---|
| 1860 | if (!$passed) { |
|---|
| 1861 | |
|---|
| 1862 | // write .exp |
|---|
| 1863 | if (strpos($log_format, 'E') !== false && file_put_contents($exp_filename, (binary) $wanted, FILE_BINARY) === false) { |
|---|
| 1864 | error("Cannot create expected test output - $exp_filename"); |
|---|
| 1865 | } |
|---|
| 1866 | |
|---|
| 1867 | // write .out |
|---|
| 1868 | if (strpos($log_format, 'O') !== false && file_put_contents($output_filename, (binary) $output, FILE_BINARY) === false) { |
|---|
| 1869 | error("Cannot create test output - $output_filename"); |
|---|
| 1870 | } |
|---|
| 1871 | |
|---|
| 1872 | // write .diff |
|---|
| 1873 | $diff = generate_diff($wanted, $wanted_re, $output); |
|---|
| 1874 | show_file_block('diff', $diff); |
|---|
| 1875 | if (strpos($log_format, 'D') !== false && file_put_contents($diff_filename, (binary) $diff, FILE_BINARY) === false) { |
|---|
| 1876 | error("Cannot create test diff - $diff_filename"); |
|---|
| 1877 | } |
|---|
| 1878 | |
|---|
| 1879 | // write .log |
|---|
| 1880 | if (strpos($log_format, 'L') !== false && file_put_contents($log_filename, b" |
|---|
| 1881 | ---- EXPECTED OUTPUT |
|---|
| 1882 | $wanted |
|---|
| 1883 | ---- ACTUAL OUTPUT |
|---|
| 1884 | $output |
|---|
| 1885 | ---- FAILED |
|---|
| 1886 | ", FILE_BINARY) === false) { |
|---|
| 1887 | error("Cannot create test log - $log_filename"); |
|---|
| 1888 | error_report($file, $log_filename, $tested); |
|---|
| 1889 | } |
|---|
| 1890 | } |
|---|
| 1891 | |
|---|
| 1892 | show_result(implode('&', $restype), $tested, $tested_file, $info, $temp_filenames); |
|---|
| 1893 | |
|---|
| 1894 | foreach ($restype as $type) { |
|---|
| 1895 | $PHP_FAILED_TESTS[$type.'ED'][] = array ( |
|---|
| 1896 | 'name' => $file, |
|---|
| 1897 | 'test_name' => (is_array($IN_REDIRECT) ? $IN_REDIRECT['via'] : '') . $tested . " [$tested_file]", |
|---|
| 1898 | 'output' => $output_filename, |
|---|
| 1899 | 'diff' => $diff_filename, |
|---|
| 1900 | 'info' => $info, |
|---|
| 1901 | ); |
|---|
| 1902 | } |
|---|
| 1903 | |
|---|
| 1904 | if (isset($old_php)) { |
|---|
| 1905 | $php = $old_php; |
|---|
| 1906 | } |
|---|
| 1907 | |
|---|
| 1908 | return $restype[0] . 'ED'; |
|---|
| 1909 | } |
|---|
| 1910 | |
|---|
| 1911 | function comp_line($l1, $l2, $is_reg) |
|---|
| 1912 | { |
|---|
| 1913 | if ($is_reg) { |
|---|
| 1914 | return preg_match((binary) "/^$l1$/s", (binary) $l2); |
|---|
| 1915 | } else { |
|---|
| 1916 | return !strcmp((binary) $l1, (binary) $l2); |
|---|
| 1917 | } |
|---|
| 1918 | } |
|---|
| 1919 | |
|---|
| 1920 | function count_array_diff($ar1, $ar2, $is_reg, $w, $idx1, $idx2, $cnt1, $cnt2, $steps) |
|---|
| 1921 | { |
|---|
| 1922 | $equal = 0; |
|---|
| 1923 | |
|---|
| 1924 | while ($idx1 < $cnt1 && $idx2 < $cnt2 && comp_line($ar1[$idx1], $ar2[$idx2], $is_reg)) { |
|---|
| 1925 | $idx1++; |
|---|
| 1926 | $idx2++; |
|---|
| 1927 | $equal++; |
|---|
| 1928 | $steps--; |
|---|
| 1929 | } |
|---|
| 1930 | if (--$steps > 0) { |
|---|
| 1931 | $eq1 = 0; |
|---|
| 1932 | $st = $steps / 2; |
|---|
| 1933 | |
|---|
| 1934 | for ($ofs1 = $idx1 + 1; $ofs1 < $cnt1 && $st-- > 0; $ofs1++) { |
|---|
| 1935 | $eq = @count_array_diff($ar1, $ar2, $is_reg, $w, $ofs1, $idx2, $cnt1, $cnt2, $st); |
|---|
| 1936 | |
|---|
| 1937 | if ($eq > $eq1) { |
|---|
| 1938 | $eq1 = $eq; |
|---|
| 1939 | } |
|---|
| 1940 | } |
|---|
| 1941 | |
|---|
| 1942 | $eq2 = 0; |
|---|
| 1943 | $st = $steps; |
|---|
| 1944 | |
|---|
| 1945 | for ($ofs2 = $idx2 + 1; $ofs2 < $cnt2 && $st-- > 0; $ofs2++) { |
|---|
| 1946 | $eq = @count_array_diff($ar1, $ar2, $is_reg, $w, $idx1, $ofs2, $cnt1, $cnt2, $st); |
|---|
| 1947 | if ($eq > $eq2) { |
|---|
| 1948 | $eq2 = $eq; |
|---|
| 1949 | } |
|---|
| 1950 | } |
|---|
| 1951 | |
|---|
| 1952 | if ($eq1 > $eq2) { |
|---|
| 1953 | $equal += $eq1; |
|---|
| 1954 | } else if ($eq2 > 0) { |
|---|
| 1955 | $equal += $eq2; |
|---|
| 1956 | } |
|---|
| 1957 | } |
|---|
| 1958 | |
|---|
| 1959 | return $equal; |
|---|
| 1960 | } |
|---|
| 1961 | |
|---|
| 1962 | function generate_array_diff($ar1, $ar2, $is_reg, $w) |
|---|
| 1963 | { |
|---|
| 1964 | $idx1 = 0; $ofs1 = 0; $cnt1 = @count($ar1); |
|---|
| 1965 | $idx2 = 0; $ofs2 = 0; $cnt2 = @count($ar2); |
|---|
| 1966 | $diff = array(); |
|---|
| 1967 | $old1 = array(); |
|---|
| 1968 | $old2 = array(); |
|---|
| 1969 | |
|---|
| 1970 | while ($idx1 < $cnt1 && $idx2 < $cnt2) { |
|---|
| 1971 | |
|---|
| 1972 | if (comp_line($ar1[$idx1], $ar2[$idx2], $is_reg)) { |
|---|
| 1973 | $idx1++; |
|---|
| 1974 | $idx2++; |
|---|
| 1975 | continue; |
|---|
| 1976 | } else { |
|---|
| 1977 | |
|---|
| 1978 | $c1 = @count_array_diff($ar1, $ar2, $is_reg, $w, $idx1+1, $idx2, $cnt1, $cnt2, 10); |
|---|
| 1979 | $c2 = @count_array_diff($ar1, $ar2, $is_reg, $w, $idx1, $idx2+1, $cnt1, $cnt2, 10); |
|---|
| 1980 | |
|---|
| 1981 | if ($c1 > $c2) { |
|---|
| 1982 | $old1[$idx1] = (binary) sprintf("%03d- ", $idx1+1) . $w[$idx1++]; |
|---|
| 1983 | $last = 1; |
|---|
| 1984 | } else if ($c2 > 0) { |
|---|
| 1985 | $old2[$idx2] = (binary) sprintf("%03d+ ", $idx2+1) . $ar2[$idx2++]; |
|---|
| 1986 | $last = 2; |
|---|
| 1987 | } else { |
|---|
| 1988 | $old1[$idx1] = (binary) sprintf("%03d- ", $idx1+1) . $w[$idx1++]; |
|---|
| 1989 | $old2[$idx2] = (binary) sprintf("%03d+ ", $idx2+1) . $ar2[$idx2++]; |
|---|
| 1990 | } |
|---|
| 1991 | } |
|---|
| 1992 | } |
|---|
| 1993 | |
|---|
| 1994 | reset($old1); $k1 = key($old1); $l1 = -2; |
|---|
| 1995 | reset($old2); $k2 = key($old2); $l2 = -2; |
|---|
| 1996 | |
|---|
| 1997 | while ($k1 !== null || $k2 !== null) { |
|---|
| 1998 | |
|---|
| 1999 | if ($k1 == $l1 + 1 || $k2 === null) { |
|---|
| 2000 | $l1 = $k1; |
|---|
| 2001 | $diff[] = current($old1); |
|---|
| 2002 | $k1 = next($old1) ? key($old1) : null; |
|---|
| 2003 | } else if ($k2 == $l2 + 1 || $k1 === null) { |
|---|
| 2004 | $l2 = $k2; |
|---|
| 2005 | $diff[] = current($old2); |
|---|
| 2006 | $k2 = next($old2) ? key($old2) : null; |
|---|
| 2007 | } else if ($k1 < $k2) { |
|---|
| 2008 | $l1 = $k1; |
|---|
| 2009 | $diff[] = current($old1); |
|---|
| 2010 | $k1 = next($old1) ? key($old1) : null; |
|---|
| 2011 | } else { |
|---|
| 2012 | $l2 = $k2; |
|---|
| 2013 | $diff[] = current($old2); |
|---|
| 2014 | $k2 = next($old2) ? key($old2) : null; |
|---|
| 2015 | } |
|---|
| 2016 | } |
|---|
| 2017 | |
|---|
| 2018 | while ($idx1 < $cnt1) { |
|---|
| 2019 | $diff[] = (binary) sprintf("%03d- ", $idx1 + 1) . $w[$idx1++]; |
|---|
| 2020 | } |
|---|
| 2021 | |
|---|
| 2022 | while ($idx2 < $cnt2) { |
|---|
| 2023 | $diff[] = (binary) sprintf("%03d+ ", $idx2 + 1) . $ar2[$idx2++]; |
|---|
| 2024 | } |
|---|
| 2025 | |
|---|
| 2026 | return $diff; |
|---|
| 2027 | } |
|---|
| 2028 | |
|---|
| 2029 | function generate_diff($wanted, $wanted_re, $output) |
|---|
| 2030 | { |
|---|
| 2031 | $w = explode(b"\n", $wanted); |
|---|
| 2032 | $o = explode(b"\n", $output); |
|---|
| 2033 | $r = is_null($wanted_re) ? $w : explode(b"\n", $wanted_re); |
|---|
| 2034 | $diff = generate_array_diff($r, $o, !is_null($wanted_re), $w); |
|---|
| 2035 | |
|---|
| 2036 | return implode(b"\r\n", $diff); |
|---|
| 2037 | } |
|---|
| 2038 | |
|---|
| 2039 | function error($message) |
|---|
| 2040 | { |
|---|
| 2041 | echo "ERROR: {$message}\n"; |
|---|
| 2042 | exit(1); |
|---|
| 2043 | } |
|---|
| 2044 | |
|---|
| 2045 | function settings2array($settings, &$ini_settings) |
|---|
| 2046 | { |
|---|
| 2047 | foreach($settings as $setting) { |
|---|
| 2048 | |
|---|
| 2049 | if (strpos($setting, '=') !== false) { |
|---|
| 2050 | $setting = explode("=", $setting, 2); |
|---|
| 2051 | $name = trim(strtolower($setting[0])); |
|---|
| 2052 | $value = trim($setting[1]); |
|---|
| 2053 | |
|---|
| 2054 | if ($name == 'extension') { |
|---|
| 2055 | |
|---|
| 2056 | if (!isset($ini_settings[$name])) { |
|---|
| 2057 | $ini_settings[$name] = array(); |
|---|
| 2058 | } |
|---|
| 2059 | |
|---|
| 2060 | $ini_settings[$name][] = $value; |
|---|
| 2061 | |
|---|
| 2062 | } else { |
|---|
| 2063 | $ini_settings[$name] = $value; |
|---|
| 2064 | } |
|---|
| 2065 | } |
|---|
| 2066 | } |
|---|
| 2067 | } |
|---|
| 2068 | |
|---|
| 2069 | function settings2params(&$ini_settings) |
|---|
| 2070 | { |
|---|
| 2071 | $settings = ''; |
|---|
| 2072 | |
|---|
| 2073 | foreach($ini_settings as $name => $value) { |
|---|
| 2074 | |
|---|
| 2075 | if (is_array($value)) { |
|---|
| 2076 | foreach($value as $val) { |
|---|
| 2077 | $val = addslashes($val); |
|---|
| 2078 | $settings .= " -d \"$name=$val\""; |
|---|
| 2079 | } |
|---|
| 2080 | } else { |
|---|
| 2081 | $value = addslashes($value); |
|---|
| 2082 | $settings .= " -d \"$name=$value\""; |
|---|
| 2083 | } |
|---|
| 2084 | } |
|---|
| 2085 | |
|---|
| 2086 | $ini_settings = $settings; |
|---|
| 2087 | } |
|---|
| 2088 | |
|---|
| 2089 | function compute_summary() |
|---|
| 2090 | { |
|---|
| 2091 | global $n_total, $test_results, $ignored_by_ext, $sum_results, $percent_results; |
|---|
| 2092 | |
|---|
| 2093 | $n_total = count($test_results); |
|---|
| 2094 | $n_total += $ignored_by_ext; |
|---|
| 2095 | $sum_results = array( |
|---|
| 2096 | 'PASSED' => 0, |
|---|
| 2097 | 'WARNED' => 0, |
|---|
| 2098 | 'SKIPPED' => 0, |
|---|
| 2099 | 'FAILED' => 0, |
|---|
| 2100 | 'BORKED' => 0, |
|---|
| 2101 | 'LEAKED' => 0, |
|---|
| 2102 | 'XFAILED' => 0 |
|---|
| 2103 | ); |
|---|
| 2104 | |
|---|
| 2105 | foreach ($test_results as $v) { |
|---|
| 2106 | $sum_results[$v]++; |
|---|
| 2107 | } |
|---|
| 2108 | |
|---|
| 2109 | $sum_results['SKIPPED'] += $ignored_by_ext; |
|---|
| 2110 | $percent_results = array(); |
|---|
| 2111 | |
|---|
| 2112 | while (list($v, $n) = each($sum_results)) { |
|---|
| 2113 | $percent_results[$v] = (100.0 * $n) / $n_total; |
|---|
| 2114 | } |
|---|
| 2115 | } |
|---|
| 2116 | |
|---|
| 2117 | function get_summary($show_ext_summary, $show_html) |
|---|
| 2118 | { |
|---|
| 2119 | global $exts_skipped, $exts_tested, $n_total, $sum_results, $percent_results, $end_time, $start_time, $failed_test_summary, $PHP_FAILED_TESTS, $leak_check; |
|---|
| 2120 | |
|---|
| 2121 | $x_total = $n_total - $sum_results['SKIPPED'] - $sum_results['BORKED']; |
|---|
| 2122 | |
|---|
| 2123 | if ($x_total) { |
|---|
| 2124 | $x_warned = (100.0 * $sum_results['WARNED']) / $x_total; |
|---|
| 2125 | $x_failed = (100.0 * $sum_results['FAILED']) / $x_total; |
|---|
| 2126 | $x_xfailed = (100.0 * $sum_results['XFAILED']) / $x_total; |
|---|
| 2127 | $x_leaked = (100.0 * $sum_results['LEAKED']) / $x_total; |
|---|
| 2128 | $x_passed = (100.0 * $sum_results['PASSED']) / $x_total; |
|---|
| 2129 | } else { |
|---|
| 2130 | $x_warned = $x_failed = $x_passed = $x_leaked = $x_xfailed = 0; |
|---|
| 2131 | } |
|---|
| 2132 | |
|---|
| 2133 | $summary = ''; |
|---|
| 2134 | |
|---|
| 2135 | if ($show_html) { |
|---|
| 2136 | $summary .= "<pre>\n"; |
|---|
| 2137 | } |
|---|
| 2138 | |
|---|
| 2139 | if ($show_ext_summary) { |
|---|
| 2140 | $summary .= ' |
|---|
| 2141 | ===================================================================== |
|---|
| 2142 | TEST RESULT SUMMARY |
|---|
| 2143 | --------------------------------------------------------------------- |
|---|
| 2144 | Exts skipped : ' . sprintf('%4d', $exts_skipped) . ' |
|---|
| 2145 | Exts tested : ' . sprintf('%4d', $exts_tested) . ' |
|---|
| 2146 | --------------------------------------------------------------------- |
|---|
| 2147 | '; |
|---|
| 2148 | } |
|---|
| 2149 | |
|---|
| 2150 | $summary .= ' |
|---|
| 2151 | Number of tests : ' . sprintf('%4d', $n_total) . ' ' . sprintf('%8d', $x_total); |
|---|
| 2152 | |
|---|
| 2153 | if ($sum_results['BORKED']) { |
|---|
| 2154 | $summary .= ' |
|---|
| 2155 | Tests borked : ' . sprintf('%4d (%5.1f%%)', $sum_results['BORKED'], $percent_results['BORKED']) . ' --------'; |
|---|
| 2156 | } |
|---|
| 2157 | |
|---|
| 2158 | $summary .= ' |
|---|
| 2159 | Tests skipped : ' . sprintf('%4d (%5.1f%%)', $sum_results['SKIPPED'], $percent_results['SKIPPED']) . ' -------- |
|---|
| 2160 | Tests warned : ' . sprintf('%4d (%5.1f%%)', $sum_results['WARNED'], $percent_results['WARNED']) . ' ' . sprintf('(%5.1f%%)', $x_warned) . ' |
|---|
| 2161 | Tests failed : ' . sprintf('%4d (%5.1f%%)', $sum_results['FAILED'], $percent_results['FAILED']) . ' ' . sprintf('(%5.1f%%)', $x_failed) . ' |
|---|
| 2162 | Expected fail : ' . sprintf('%4d (%5.1f%%)', $sum_results['XFAILED'], $percent_results['XFAILED']) . ' ' . sprintf('(%5.1f%%)', $x_xfailed); |
|---|
| 2163 | |
|---|
| 2164 | if ($leak_check) { |
|---|
| 2165 | $summary .= ' |
|---|
| 2166 | Tests leaked : ' . sprintf('%4d (%5.1f%%)', $sum_results['LEAKED'], $percent_results['LEAKED']) . ' ' . sprintf('(%5.1f%%)', $x_leaked); |
|---|
| 2167 | } |
|---|
| 2168 | |
|---|
| 2169 | $summary .= ' |
|---|
| 2170 | Tests passed : ' . sprintf('%4d (%5.1f%%)', $sum_results['PASSED'], $percent_results['PASSED']) . ' ' . sprintf('(%5.1f%%)', $x_passed) . ' |
|---|
| 2171 | --------------------------------------------------------------------- |
|---|
| 2172 | Time taken : ' . sprintf('%4d seconds', $end_time - $start_time) . ' |
|---|
| 2173 | ===================================================================== |
|---|
| 2174 | '; |
|---|
| 2175 | $failed_test_summary = ''; |
|---|
| 2176 | |
|---|
| 2177 | if (count($PHP_FAILED_TESTS['BORKED'])) { |
|---|
| 2178 | $failed_test_summary .= ' |
|---|
| 2179 | ===================================================================== |
|---|
| 2180 | BORKED TEST SUMMARY |
|---|
| 2181 | --------------------------------------------------------------------- |
|---|
| 2182 | '; |
|---|
| 2183 | foreach ($PHP_FAILED_TESTS['BORKED'] as $failed_test_data) { |
|---|
| 2184 | $failed_test_summary .= $failed_test_data['info'] . "\n"; |
|---|
| 2185 | } |
|---|
| 2186 | |
|---|
| 2187 | $failed_test_summary .= "=====================================================================\n"; |
|---|
| 2188 | } |
|---|
| 2189 | |
|---|
| 2190 | if (count($PHP_FAILED_TESTS['FAILED'])) { |
|---|
| 2191 | $failed_test_summary .= ' |
|---|
| 2192 | ===================================================================== |
|---|
| 2193 | FAILED TEST SUMMARY |
|---|
| 2194 | --------------------------------------------------------------------- |
|---|
| 2195 | '; |
|---|
| 2196 | foreach ($PHP_FAILED_TESTS['FAILED'] as $failed_test_data) { |
|---|
| 2197 | $failed_test_summary .= $failed_test_data['test_name'] . $failed_test_data['info'] . "\n"; |
|---|
| 2198 | } |
|---|
| 2199 | $failed_test_summary .= "=====================================================================\n"; |
|---|
| 2200 | } |
|---|
| 2201 | if (count($PHP_FAILED_TESTS['XFAILED'])) { |
|---|
| 2202 | $failed_test_summary .= ' |
|---|
| 2203 | ===================================================================== |
|---|
| 2204 | EXPECTED FAILED TEST SUMMARY |
|---|
| 2205 | --------------------------------------------------------------------- |
|---|
| 2206 | '; |
|---|
| 2207 | foreach ($PHP_FAILED_TESTS['XFAILED'] as $failed_test_data) { |
|---|
| 2208 | $failed_test_summary .= $failed_test_data['test_name'] . $failed_test_data['info'] . "\n"; |
|---|
| 2209 | } |
|---|
| 2210 | $failed_test_summary .= "=====================================================================\n"; |
|---|
| 2211 | } |
|---|
| 2212 | |
|---|
| 2213 | if (count($PHP_FAILED_TESTS['LEAKED'])) { |
|---|
| 2214 | $failed_test_summary .= ' |
|---|
| 2215 | ===================================================================== |
|---|
| 2216 | LEAKED TEST SUMMARY |
|---|
| 2217 | --------------------------------------------------------------------- |
|---|
| 2218 | '; |
|---|
| 2219 | foreach ($PHP_FAILED_TESTS['LEAKED'] as $failed_test_data) { |
|---|
| 2220 | $failed_test_summary .= $failed_test_data['test_name'] . $failed_test_data['info'] . "\n"; |
|---|
| 2221 | } |
|---|
| 2222 | |
|---|
| 2223 | $failed_test_summary .= "=====================================================================\n"; |
|---|
| 2224 | } |
|---|
| 2225 | |
|---|
| 2226 | if ($failed_test_summary && !getenv('NO_PHPTEST_SUMMARY')) { |
|---|
| 2227 | $summary .= $failed_test_summary; |
|---|
| 2228 | } |
|---|
| 2229 | |
|---|
| 2230 | if ($show_html) { |
|---|
| 2231 | $summary .= "</pre>"; |
|---|
| 2232 | } |
|---|
| 2233 | |
|---|
| 2234 | return $summary; |
|---|
| 2235 | } |
|---|
| 2236 | |
|---|
| 2237 | function show_start($start_time) |
|---|
| 2238 | { |
|---|
| 2239 | global $html_output, $html_file; |
|---|
| 2240 | |
|---|
| 2241 | if ($html_output) { |
|---|
| 2242 | fwrite($html_file, "<h2>Time Start: " . date('Y-m-d H:i:s', $start_time) . "</h2>\n"); |
|---|
| 2243 | fwrite($html_file, "<table>\n"); |
|---|
| 2244 | } |
|---|
| 2245 | |
|---|
| 2246 | echo "TIME START " . date('Y-m-d H:i:s', $start_time) . "\n=====================================================================\n"; |
|---|
| 2247 | } |
|---|
| 2248 | |
|---|
| 2249 | function show_end($end_time) |
|---|
| 2250 | { |
|---|
| 2251 | global $html_output, $html_file; |
|---|
| 2252 | |
|---|
| 2253 | if ($html_output) { |
|---|
| 2254 | fwrite($html_file, "</table>\n"); |
|---|
| 2255 | fwrite($html_file, "<h2>Time End: " . date('Y-m-d H:i:s', $end_time) . "</h2>\n"); |
|---|
| 2256 | } |
|---|
| 2257 | |
|---|
| 2258 | echo "=====================================================================\nTIME END " . date('Y-m-d H:i:s', $end_time) . "\n"; |
|---|
| 2259 | } |
|---|
| 2260 | |
|---|
| 2261 | function show_summary() |
|---|
| 2262 | { |
|---|
| 2263 | global $html_output, $html_file; |
|---|
| 2264 | |
|---|
| 2265 | if ($html_output) { |
|---|
| 2266 | fwrite($html_file, "<hr/>\n" . get_summary(true, true)); |
|---|
| 2267 | } |
|---|
| 2268 | |
|---|
| 2269 | echo get_summary(true, false); |
|---|
| 2270 | } |
|---|
| 2271 | |
|---|
| 2272 | function show_redirect_start($tests, $tested, $tested_file) |
|---|
| 2273 | { |
|---|
| 2274 | global $html_output, $html_file; |
|---|
| 2275 | |
|---|
| 2276 | if ($html_output) { |
|---|
| 2277 | fwrite($html_file, "<tr><td colspan='3'>---> $tests ($tested [$tested_file]) begin</td></tr>\n"); |
|---|
| 2278 | } |
|---|
| 2279 | |
|---|
| 2280 | echo "---> $tests ($tested [$tested_file]) begin\n"; |
|---|
| 2281 | } |
|---|
| 2282 | |
|---|
| 2283 | function show_redirect_ends($tests, $tested, $tested_file) |
|---|
| 2284 | { |
|---|
| 2285 | global $html_output, $html_file; |
|---|
| 2286 | |
|---|
| 2287 | if ($html_output) { |
|---|
| 2288 | fwrite($html_file, "<tr><td colspan='3'>---> $tests ($tested [$tested_file]) done</td></tr>\n"); |
|---|
| 2289 | } |
|---|
| 2290 | |
|---|
| 2291 | echo "---> $tests ($tested [$tested_file]) done\n"; |
|---|
| 2292 | } |
|---|
| 2293 | |
|---|
| 2294 | function show_test($test_idx, $shortname) |
|---|
| 2295 | { |
|---|
| 2296 | global $test_cnt; |
|---|
| 2297 | |
|---|
| 2298 | echo "TEST $test_idx/$test_cnt [$shortname]\r"; |
|---|
| 2299 | flush(); |
|---|
| 2300 | } |
|---|
| 2301 | |
|---|
| 2302 | function show_result($result, $tested, $tested_file, $extra = '', $temp_filenames = null) |
|---|
| 2303 | { |
|---|
| 2304 | global $html_output, $html_file, $temp_target, $temp_urlbase; |
|---|
| 2305 | |
|---|
| 2306 | echo "$result $tested [$tested_file] $extra\n"; |
|---|
| 2307 | |
|---|
| 2308 | if ($html_output) { |
|---|
| 2309 | |
|---|
| 2310 | if (isset($temp_filenames['file']) && file_exists($temp_filenames['file'])) { |
|---|
| 2311 | $url = str_replace($temp_target, $temp_urlbase, $temp_filenames['file']); |
|---|
| 2312 | $tested = "<a href='$url'>$tested</a>"; |
|---|
| 2313 | } |
|---|
| 2314 | |
|---|
| 2315 | if (isset($temp_filenames['skip']) && file_exists($temp_filenames['skip'])) { |
|---|
| 2316 | |
|---|
| 2317 | if (empty($extra)) { |
|---|
| 2318 | $extra = "skipif"; |
|---|
| 2319 | } |
|---|
| 2320 | |
|---|
| 2321 | $url = str_replace($temp_target, $temp_urlbase, $temp_filenames['skip']); |
|---|
| 2322 | $extra = "<a href='$url'>$extra</a>"; |
|---|
| 2323 | |
|---|
| 2324 | } else if (empty($extra)) { |
|---|
| 2325 | $extra = " "; |
|---|
| 2326 | } |
|---|
| 2327 | |
|---|
| 2328 | if (isset($temp_filenames['diff']) && file_exists($temp_filenames['diff'])) { |
|---|
| 2329 | $url = str_replace($temp_target, $temp_urlbase, $temp_filenames['diff']); |
|---|
| 2330 | $diff = "<a href='$url'>diff</a>"; |
|---|
| 2331 | } else { |
|---|
| 2332 | $diff = " "; |
|---|
| 2333 | } |
|---|
| 2334 | |
|---|
| 2335 | if (isset($temp_filenames['mem']) && file_exists($temp_filenames['mem'])) { |
|---|
| 2336 | $url = str_replace($temp_target, $temp_urlbase, $temp_filenames['mem']); |
|---|
| 2337 | $mem = "<a href='$url'>leaks</a>"; |
|---|
| 2338 | } else { |
|---|
| 2339 | $mem = " "; |
|---|
| 2340 | } |
|---|
| 2341 | |
|---|
| 2342 | fwrite($html_file, |
|---|
| 2343 | "<tr>" . |
|---|
| 2344 | "<td>$result</td>" . |
|---|
| 2345 | "<td>$tested</td>" . |
|---|
| 2346 | "<td>$extra</td>" . |
|---|
| 2347 | "<td>$diff</td>" . |
|---|
| 2348 | "<td>$mem</td>" . |
|---|
| 2349 | "</tr>\n"); |
|---|
| 2350 | } |
|---|
| 2351 | } |
|---|
| 2352 | |
|---|
| 2353 | /* |
|---|
| 2354 | * Local variables: |
|---|
| 2355 | * tab-width: 4 |
|---|
| 2356 | * c-basic-offset: 4 |
|---|
| 2357 | * End: |
|---|
| 2358 | * vim: noet sw=4 ts=4 |
|---|
| 2359 | */ |
|---|
| 2360 | ?> |
|---|
