PageRenderTime 31ms CodeModel.GetById 45ms RepoModel.GetById 0ms app.codeStats 1ms

/opensource.apple.com/source/apache_mod_php/apache_mod_php-44.2/php/run-tests.php

#
PHP | 2189 lines | 1817 code | 282 blank | 90 comment | 274 complexity | 0c55f18be7a95b0349f892b2525e52c9 MD5 | raw file
Possible License(s): MPL-2.0-no-copyleft-exception, GPL-2.0, BSD-3-Clause, GPL-3.0, MPL-2.0, LGPL-2.0, LGPL-2.1, CC-BY-SA-3.0, IPL-1.0, ISC, AGPL-1.0, AGPL-3.0, JSON, Apache-2.0, 0BSD

Large files files are truncated, but you can click here to view the full file

    

  1. <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
    2. 

  2.     "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
    3. 

  3. <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
    4. 

  4. <head>
    5. 

  5. <title>run-tests.php</title>
    6. 

  6. <style type="text/css">
    7. 

  7. .enscript-comment { font-style: italic; color: rgb(178,34,34); }
    8. 

  8. .enscript-function-name { font-weight: bold; color: rgb(0,0,255); }
    9. 

  9. .enscript-variable-name { font-weight: bold; color: rgb(184,134,11); }
    10. 

  10. .enscript-keyword { font-weight: bold; color: rgb(160,32,240); }
    11. 

  11. .enscript-reference { font-weight: bold; color: rgb(95,158,160); }
    12. 

  12. .enscript-string { font-weight: bold; color: rgb(188,143,143); }
    13. 

  13. .enscript-builtin { font-weight: bold; color: rgb(218,112,214); }
    14. 

  14. .enscript-type { font-weight: bold; color: rgb(34,139,34); }
    15. 

  15. .enscript-highlight { text-decoration: underline; color: 0; }
    16. 

  16. </style>
    17. 

  17. </head>
    18. 

  18. <body id="top">
    19. 

  19. <h1 style="margin:8px;" id="f1">run-tests.php&nbsp;&nbsp;&nbsp;<span style="font-weight: normal; font-size: 0.5em;">[<a href="?txt">plain text</a>]</span></h1>
    20. 

  20. <hr/>
    21. 

  21. <div></div>
    22. 

  22. <pre>
    23. 

  23. #!/usr/bin/php
    24. 

  24. &lt;?php
    25. 

  25. /*
    26. 

  26.    +----------------------------------------------------------------------+
    27. 

  27.    | PHP Version 5, 6                                                     |
    28. 

  28.    +----------------------------------------------------------------------+
    29. 

  29.    | Copyright (c) 1997-2008 The PHP Group                                |
    30. 

  30.    +----------------------------------------------------------------------+
    31. 

  31.    | This source file is subject to version 3.01 of the PHP license,      |
    32. 

  32.    | that is bundled with this package in the file LICENSE, and is        |
    33. 

  33.    | available through the world-wide-web at the following url:           |
    34. 

  34.    | <a href="http://www.php.net/license/3_01.txt">http://www.php.net/license/3_01.txt</a>                                  |
    35. 

  35.    | If you did not receive a copy of the PHP license and are unable to   |
    36. 

  36.    | obtain it through the world-wide-web, please send a note to          |
    37. 

  37.    | <a href="mailto:license@php.net">license@php.net</a> so we can mail you a copy immediately.               |
    38. 

  38.    +----------------------------------------------------------------------+
    39. 

  39.    | Authors: Ilia Alshanetsky &lt;<a href="mailto:iliaa@php.net">iliaa@php.net</a>&gt;                            |
    40. 

  40.    |          Preston L. Bannister &lt;<a href="mailto:pbannister@php.net">pbannister@php.net</a>&gt;                   |
    41. 

  41.    |          Marcus Boerger &lt;<a href="mailto:helly@php.net">helly@php.net</a>&gt;                              |
    42. 

  42.    |          Derick Rethans &lt;<a href="mailto:derick@php.net">derick@php.net</a>&gt;                             |
    43. 

  43.    |          Sander Roobol &lt;<a href="mailto:sander@php.net">sander@php.net</a>&gt;                              |
    44. 

  44.    | (based on version by: Stig Bakken &lt;<a href="mailto:ssb@php.net">ssb@php.net</a>&gt;)                     |
    45. 

  45.    | (based on the PHP 3 test framework by Rasmus Lerdorf)                |
    46. 

  46.    +----------------------------------------------------------------------+
    47. 

  47.  */
    48. 

  48. 

  49. /* $Id: run-tests.php,v 1.226.2.37.2.51 2008/12/03 14:27:43 robinf Exp $ */
    50. 

  50. 

  51. /* Sanity check to ensure that pcre extension needed by this script is available.
    52. 

  52.  * In the event it is not, print a nice error message indicating that this script will
    53. 

  53.  * not run without it.
    54. 

  54.  */
    55. 

  55. 

  56. if (!extension_loaded('pcre')) {
    57. 

  57. 	echo &lt;&lt;&lt;NO_PCRE_ERROR
    58. 

  58. 

  59. +-----------------------------------------------------------+
    60. 

  60. |                       ! ERROR !                           |
    61. 

  61. | The test-suite requires that you have pcre extension      |
    62. 

  62. | enabled. To enable this extension either compile your PHP |
    63. 

  63. | with --with-pcre-regex or if you've compiled pcre as a    |
    64. 

  64. | shared module load it via php.ini.                        |
    65. 

  65. +-----------------------------------------------------------+
    66. 

  66. 

  67. NO_PCRE_ERROR;
    68. 

  68. exit;
    69. 

  69. }
    70. 

  70. 

  71. if (!function_exists('proc_open')) {
    72. 

  72. 	echo &lt;&lt;&lt;NO_PROC_OPEN_ERROR
    73. 

  73. 

  74. +-----------------------------------------------------------+
    75. 

  75. |                       ! ERROR !                           |
    76. 

  76. | The test-suite requires that proc_open() is available.    |
    77. 

  77. | Please check if you disabled it in php.ini.               |
    78. 

  78. +-----------------------------------------------------------+
    79. 

  79. 

  80. NO_PROC_OPEN_ERROR;
    81. 

  81. exit;
    82. 

  82. }
    83. 

  83. 

  84. // If timezone is not set, use UTC.
    85. 

  85. if (ini_get('date.timezone') == '') {
    86. 

  86. 	date_default_timezone_set('UTC');
    87. 

  87. }
    88. 

  88. 

  89. // store current directory
    90. 

  90. $CUR_DIR = getcwd();
    91. 

  91. 

  92. // change into the PHP source directory.
    93. 

  93. 

  94. if (getenv('TEST_PHP_SRCDIR')) {
    95. 

  95. 	@chdir(getenv('TEST_PHP_SRCDIR'));
    96. 

  96. }
    97. 

  97. 

  98. // Delete some security related environment variables
    99. 

  99. putenv('SSH_CLIENT=deleted');
    100. 

  100. putenv('SSH_AUTH_SOCK=deleted');
    101. 

  101. putenv('SSH_TTY=deleted');
    102. 

  102. putenv('SSH_CONNECTION=deleted');
    103. 

  103. 

  104. $cwd = getcwd();
    105. 

  105. set_time_limit(0);
    106. 

  106. 

  107. ini_set('pcre.backtrack_limit', PHP_INT_MAX);
    108. 

  108. 

  109. $valgrind_version = 0;
    110. 

  110. $valgrind_header = '';
    111. 

  111. 

  112. // delete as much output buffers as possible
    113. 

  113. while(@ob_end_clean());
    114. 

  114. if (ob_get_level()) echo &quot;Not all buffers were deleted.\n&quot;;
    115. 

  115. 

  116. error_reporting(E_ALL);
    117. 

  117. if (PHP_MAJOR_VERSION &lt; 6) {
    118. 

  118. 	ini_set('magic_quotes_runtime',0); // this would break tests by modifying EXPECT sections
    119. 

  119. 	if (ini_get('safe_mode')) {
    120. 

  120. 		echo &lt;&lt;&lt; SAFE_MODE_WARNING
    121. 

  121. 

  122. +-----------------------------------------------------------+
    123. 

  123. |                       ! WARNING !                         |
    124. 

  124. | You are running the test-suite with &quot;safe_mode&quot; ENABLED ! |
    125. 

  125. |                                                           |
    126. 

  126. | Chances are high that no test will work at all,           |
    127. 

  127. | depending on how you configured &quot;safe_mode&quot; !             |
    128. 

  128. +-----------------------------------------------------------+
    129. 

  129. 

  130. 

  131. SAFE_MODE_WARNING;
    132. 

  132. 	}
    133. 

  133. }
    134. 

  134. 

  135. $environment = isset($_ENV) ? $_ENV : array();
    136. 

  136. 

  137. // Don't ever guess at the PHP executable location.
    138. 

  138. // Require the explicit specification.
    139. 

  139. // Otherwise we could end up testing the wrong file!
    140. 

  140. 

  141. $php = null;
    142. 

  142. $php_cgi = null;
    143. 

  143. 

  144. if (getenv('TEST_PHP_EXECUTABLE')) {
    145. 

  145. 	$php = getenv('TEST_PHP_EXECUTABLE');
    146. 

  146. 

  147. 	if ($php=='auto') {
    148. 

  148. 		$php = $cwd . '/sapi/cli/php';
    149. 

  149. 		putenv(&quot;TEST_PHP_EXECUTABLE=$php&quot;);
    150. 

  150. 

  151. 		if (!getenv('TEST_PHP_CGI_EXECUTABLE')) {
    152. 

  152. 			$php_cgi = $cwd . '/sapi/cgi/php-cgi';
    153. 

  153. 

  154. 			if (file_exists($php_cgi)) {
    155. 

  155. 				putenv(&quot;TEST_PHP_CGI_EXECUTABLE=$php_cgi&quot;);
    156. 

  156. 			} else {
    157. 

  157. 				$php_cgi = null;
    158. 

  158. 			}
    159. 

  159. 		}
    160. 

  160. 	}
    161. 

  161. 	$environment['TEST_PHP_EXECUTABLE'] = $php;
    162. 

  162. }
    163. 

  163. 

  164. if (getenv('TEST_PHP_CGI_EXECUTABLE')) {
    165. 

  165. 	$php_cgi = getenv('TEST_PHP_CGI_EXECUTABLE');
    166. 

  166. 

  167. 	if ($php_cgi=='auto') {
    168. 

  168. 		$php_cgi = $cwd . '/sapi/cgi/php-cgi';
    169. 

  169. 		putenv(&quot;TEST_PHP_CGI_EXECUTABLE=$php_cgi&quot;);
    170. 

  170. 	}
    171. 

  171. 

  172. 	$environment['TEST_PHP_CGI_EXECUTABLE'] = $php_cgi;
    173. 

  173. }
    174. 

  174. 

  175. function verify_config()
    176. 

  176. {
    177. 

  177. 	global $php;
    178. 

  178. 

  179. 	if (empty($php) || !file_exists($php)) {
    180. 

  180. 		error('environment variable TEST_PHP_EXECUTABLE must be set to specify PHP executable!');
    181. 

  181. 	}
    182. 

  182. 

  183. 	if (function_exists('is_executable') &amp;&amp; !is_executable($php)) {
    184. 

  184. 		error(&quot;invalid PHP executable specified by TEST_PHP_EXECUTABLE  = $php&quot;);
    185. 

  185. 	}
    186. 

  186. }
    187. 

  187. 

  188. if (getenv('TEST_PHP_LOG_FORMAT')) {
    189. 

  189. 	$log_format = strtoupper(getenv('TEST_PHP_LOG_FORMAT'));
    190. 

  190. } else {
    191. 

  191. 	$log_format = 'LEOD';
    192. 

  192. }
    193. 

  193. 

  194. // Check whether a detailed log is wanted.
    195. 

  195. if (getenv('TEST_PHP_DETAILED')) {
    196. 

  196. 	$DETAILED = getenv('TEST_PHP_DETAILED');
    197. 

  197. } else {
    198. 

  198. 	$DETAILED = 0;
    199. 

  199. }
    200. 

  200. 

  201. // Check whether user test dirs are requested.
    202. 

  202. if (getenv('TEST_PHP_USER')) {
    203. 

  203. 	$user_tests = explode (',', getenv('TEST_PHP_USER'));
    204. 

  204. } else {
    205. 

  205. 	$user_tests = array();
    206. 

  206. }
    207. 

  207. 

  208. $exts_to_test = array();
    209. 

  209. $ini_overwrites = array(
    210. 

  210. 		'output_handler=',
    211. 

  211. 		'open_basedir=',
    212. 

  212. 		'safe_mode=0',
    213. 

  213. 		'disable_functions=',
    214. 

  214. 		'output_buffering=Off',
    215. 

  215. 		'error_reporting=' . (E_ALL | E_STRICT),
    216. 

  216. 		'display_errors=1',
    217. 

  217. 		'display_startup_errors=1',
    218. 

  218. 		'log_errors=0',
    219. 

  219. 		'html_errors=0',
    220. 

  220. 		'track_errors=1',
    221. 

  221. 		'report_memleaks=1',
    222. 

  222. 		'report_zend_debug=0',
    223. 

  223. 		'docref_root=',
    224. 

  224. 		'docref_ext=.html',
    225. 

  225. 		'error_prepend_string=',
    226. 

  226. 		'error_append_string=',
    227. 

  227. 		'auto_prepend_file=',
    228. 

  228. 		'auto_append_file=',
    229. 

  229. 		'magic_quotes_runtime=0',
    230. 

  230. 		'ignore_repeated_errors=0',
    231. 

  231. 		'unicode.runtime_encoding=ISO-8859-1',
    232. 

  232. 		'unicode.script_encoding=UTF-8',
    233. 

  233. 		'unicode.output_encoding=UTF-8',
    234. 

  234. 		'unicode.from_error_mode=U_INVALID_SUBSTITUTE',
    235. 

  235. 	);
    236. 

  236. 

  237. function write_information($show_html)
    238. 

  238. {
    239. 

  239. 	global $cwd, $php, $php_cgi, $php_info, $user_tests, $ini_overwrites, $pass_options, $exts_to_test, $leak_check, $valgrind_header;
    240. 

  240. 

  241. 	// Get info from php
    242. 

  242. 	$info_file = realpath(dirname(__FILE__)) . '/run-test-info.php';
    243. 

  243. 	@unlink($info_file);
    244. 

  244. 	$php_info = '&lt;?php echo &quot;
    245. 

  245. PHP_SAPI    : &quot; , PHP_SAPI , &quot;
    246. 

  246. PHP_VERSION : &quot; , phpversion() , &quot;
    247. 

  247. ZEND_VERSION: &quot; , zend_version() , &quot;
    248. 

  248. PHP_OS      : &quot; , PHP_OS , &quot; - &quot; , php_uname() , &quot;
    249. 

  249. INI actual  : &quot; , realpath(get_cfg_var(&quot;cfg_file_path&quot;)) , &quot;
    250. 

  250. More .INIs  : &quot; , (function_exists(\'php_ini_scanned_files\') ? str_replace(&quot;\n&quot;,&quot;&quot;, php_ini_scanned_files()) : &quot;** not determined **&quot;); ?&gt;';
    251. 

  251. 	save_text($info_file, $php_info);
    252. 

  252. 	$info_params = array();
    253. 

  253. 	settings2array($ini_overwrites, $info_params);
    254. 

  254. 	settings2params($info_params);
    255. 

  255. 	$php_info = `$php $pass_options $info_params &quot;$info_file&quot;`;
    256. 

  256. 	define('TESTED_PHP_VERSION', `$php -n -r &quot;echo PHP_VERSION;&quot;`);
    257. 

  257. 

  258. 	if ($php_cgi &amp;&amp; $php != $php_cgi) {
    259. 

  259. 		$php_info_cgi = `$php_cgi $pass_options $info_params -q &quot;$info_file&quot;`;
    260. 

  260. 		$php_info_sep = &quot;\n---------------------------------------------------------------------&quot;;
    261. 

  261. 		$php_cgi_info = &quot;$php_info_sep\nPHP         : $php_cgi $php_info_cgi$php_info_sep&quot;;
    262. 

  262. 	} else {
    263. 

  263. 		$php_cgi_info = '';
    264. 

  264. 	}
    265. 

  265. 

  266. 	@unlink($info_file);
    267. 

  267. 

  268. 	// load list of enabled extensions
    269. 

  269. 	save_text($info_file, '&lt;?php echo join(&quot;,&quot;, get_loaded_extensions()); ?&gt;');
    270. 

  270. 	$exts_to_test = explode(',',`$php $pass_options $info_params &quot;$info_file&quot;`);
    271. 

  271. 	// check for extensions that need special handling and regenerate
    272. 

  272. 	$info_params_ex = array(
    273. 

  273. 		'session' =&gt; array('session.auto_start=0'),
    274. 

  274. 		'tidy' =&gt; array('tidy.clean_output=0'),
    275. 

  275. 		'zlib' =&gt; array('zlib.output_compression=Off'),
    276. 

  276. 		'xdebug' =&gt; array('xdebug.default_enable=0'),
    277. 

  277. 		'mbstring' =&gt; array('mbstring.func_overload=0'),
    278. 

  278. 	);
    279. 

  279. 

  280. 	foreach($info_params_ex as $ext =&gt; $ini_overwrites_ex) {
    281. 

  281. 		if (in_array($ext, $exts_to_test)) {
    282. 

  282. 			$ini_overwrites = array_merge($ini_overwrites, $ini_overwrites_ex);
    283. 

  283. 		}
    284. 

  284. 	}
    285. 

  285. 

  286. 	@unlink($info_file);
    287. 

  287. 

  288. 	// Write test context information.
    289. 

  289. 	echo &quot;
    290. 

  290. =====================================================================
    291. 

  291. PHP         : $php $php_info $php_cgi_info
    292. 

  292. CWD         : $cwd
    293. 

  293. Extra dirs  : &quot;;
    294. 

  294. 	foreach ($user_tests as $test_dir) {
    295. 

  295. 		echo &quot;{$test_dir}\n              &quot;;
    296. 

  296. 	}
    297. 

  297. 	echo &quot;
    298. 

  298. VALGRIND    : &quot; . ($leak_check ? $valgrind_header : 'Not used') . &quot;
    299. 

  299. =====================================================================
    300. 

  300. &quot;;
    301. 

  301. }
    302. 

  302. 

  303. define('PHP_QA_EMAIL', '<a href="mailto:qa-reports@lists.php.net">qa-reports@lists.php.net</a>');
    304. 

  304. define('QA_SUBMISSION_PAGE', '<a href="http://qa.php.net/buildtest-process.php">http://qa.php.net/buildtest-process.php</a>');
    305. 

  305. 

  306. function save_or_mail_results()
    307. 

  307. {
    308. 

  308. 	global $sum_results, $just_save_results, $failed_test_summary,
    309. 

  309. 	       $PHP_FAILED_TESTS, $CUR_DIR, $php, $output_file, $compression;
    310. 

  310. 

  311. 	/* We got failed Tests, offer the user to send an e-mail to QA team, unless NO_INTERACTION is set */
    312. 

  312. 	if (!getenv('NO_INTERACTION')) {
    313. 

  313. 		$fp = fopen(&quot;php://stdin&quot;, &quot;r+&quot;);
    314. 

  314. 		if ($sum_results['FAILED'] || $sum_results['BORKED'] || $sum_results['WARNED'] || $sum_results['LEAKED'] || $sum_results['XFAILED']) {
    315. 

  315. 			echo &quot;\nYou may have found a problem in PHP.&quot;;
    316. 

  316. 		}
    317. 

  317. 		echo &quot;\nWe would like to send this report automatically to the\n&quot;;
    318. 

  318. 		echo &quot;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&quot;;
    319. 

  319. 		echo &quot;immediately, you can choose \&quot;s\&quot; to save the report to\na file that you can send us later.\n&quot;;
    320. 

  320. 		echo &quot;Do you want to send this report now? [Yns]: &quot;;
    321. 

  321. 		flush();
    322. 

  322. 

  323. 		$user_input = fgets($fp, 10);
    324. 

  324. 		$just_save_results = (strtolower($user_input[0]) == 's');
    325. 

  325. 	}
    326. 

  326. 

  327. 	if ($just_save_results || !getenv('NO_INTERACTION')) {
    328. 

  328. 		if ($just_save_results || strlen(trim($user_input)) == 0 || strtolower($user_input[0]) == 'y') {
    329. 

  329. 			/*
    330. 

  330. 			 * Collect information about the host system for our report
    331. 

  331. 			 * Fetch phpinfo() output so that we can see the PHP enviroment
    332. 

  332. 			 * Make an archive of all the failed tests
    333. 

  333. 			 * Send an email
    334. 

  334. 			 */
    335. 

  335. 			if ($just_save_results) {
    336. 

  336. 				$user_input = 's';
    337. 

  337. 			}
    338. 

  338. 

  339. 			/* Ask the user to provide an email address, so that QA team can contact the user */
    340. 

  340. 			if (!strncasecmp($user_input, 'y', 1) || strlen(trim($user_input)) == 0) {
    341. 

  341. 				echo &quot;\nPlease enter your email address.\n(Your address will be mangled so that it will not go out on any\nmailinglist in plain text): &quot;;
    342. 

  342. 				flush();
    343. 

  343. 				$user_email = trim(fgets($fp, 1024));
    344. 

  344. 				$user_email = str_replace(&quot;@&quot;, &quot; at &quot;, str_replace(&quot;.&quot;, &quot; dot &quot;, $user_email));
    345. 

  345. 			}
    346. 

  346. 

  347. 			$failed_tests_data = '';
    348. 

  348. 			$sep = &quot;\n&quot; . str_repeat('=', 80) . &quot;\n&quot;;
    349. 

  349. 			$failed_tests_data .= $failed_test_summary . &quot;\n&quot;;
    350. 

  350. 			$failed_tests_data .= get_summary(true, false) . &quot;\n&quot;;
    351. 

  351. 

  352. 			if ($sum_results['FAILED']) {
    353. 

  353. 				foreach ($PHP_FAILED_TESTS['FAILED'] as $test_info) {
    354. 

  354. 					$failed_tests_data .= $sep . $test_info['name'] . $test_info['info'];
    355. 

  355. 					$failed_tests_data .= $sep . file_get_contents(realpath($test_info['output']));
    356. 

  356. 					$failed_tests_data .= $sep . file_get_contents(realpath($test_info['diff']));
    357. 

  357. 					$failed_tests_data .= $sep . &quot;\n\n&quot;;
    358. 

  358. 				}
    359. 

  359. 				$status = &quot;failed&quot;;
    360. 

  360. 			} else {
    361. 

  361. 				$status = &quot;success&quot;;
    362. 

  362. 			}
    363. 

  363. 

  364. 			$failed_tests_data .= &quot;\n&quot; . $sep . 'BUILD ENVIRONMENT' . $sep;
    365. 

  365. 			$failed_tests_data .= &quot;OS:\n&quot; . PHP_OS . &quot; - &quot; . php_uname() . &quot;\n\n&quot;;
    366. 

  366. 			$ldd = $autoconf = $sys_libtool = $libtool = $compiler = 'N/A';
    367. 

  367. 

  368. 			if (substr(PHP_OS, 0, 3) != &quot;WIN&quot;) {
    369. 

  369. 				/* If PHP_AUTOCONF is set, use it; otherwise, use 'autoconf'. */
    370. 

  370. 				if (getenv('PHP_AUTOCONF')) {
    371. 

  371. 					$autoconf = shell_exec(getenv('PHP_AUTOCONF') . ' --version');
    372. 

  372. 				} else {
    373. 

  373. 					$autoconf = shell_exec('autoconf --version');
    374. 

  374. 				}
    375. 

  375. 

  376. 				/* Always use the generated libtool - Mac OSX uses 'glibtool' */
    377. 

  377. 				$libtool = shell_exec($CUR_DIR . '/libtool --version');
    378. 

  378. 

  379. 				/* Use shtool to find out if there is glibtool present (MacOSX) */
    380. 

  380. 				$sys_libtool_path = shell_exec(realpath(dirname(__FILE__)) . '/build/shtool path glibtool libtool');
    381. 

  381. 

  382. 				if ($sys_libtool_path) {
    383. 

  383. 					$sys_libtool = shell_exec(str_replace(&quot;\n&quot;, &quot;&quot;, $sys_libtool_path) . ' --version');
    384. 

  384. 				}
    385. 

  385. 

  386. 				/* Try the most common flags for 'version' */
    387. 

  387. 				$flags = array('-v', '-V', '--version');
    388. 

  388. 				$cc_status = 0;
    389. 

  389. 

  390. 				foreach($flags AS $flag) {
    391. 

  391. 					system(getenv('CC') . &quot; $flag &gt;/dev/null 2&gt;&amp;1&quot;, $cc_status);
    392. 

  392. 					if ($cc_status == 0) {
    393. 

  393. 						$compiler = shell_exec(getenv('CC') . &quot; $flag 2&gt;&amp;1&quot;);
    394. 

  394. 						break;
    395. 

  395. 					}
    396. 

  396. 				}
    397. 

  397. 

  398. 				$ldd = shell_exec(&quot;ldd $php 2&gt;/dev/null&quot;);
    399. 

  399. 			}
    400. 

  400. 

  401. 			$failed_tests_data .= &quot;Autoconf:\n$autoconf\n&quot;;
    402. 

  402. 			$failed_tests_data .= &quot;Bundled Libtool:\n$libtool\n&quot;;
    403. 

  403. 			$failed_tests_data .= &quot;System Libtool:\n$sys_libtool\n&quot;;
    404. 

  404. 			$failed_tests_data .= &quot;Compiler:\n$compiler\n&quot;;
    405. 

  405. 			$failed_tests_data .= &quot;Bison:\n&quot;. shell_exec('bison --version 2&gt;/dev/null') . &quot;\n&quot;;
    406. 

  406. 			$failed_tests_data .= &quot;Libraries:\n$ldd\n&quot;;
    407. 

  407. 			$failed_tests_data .= &quot;\n&quot;;
    408. 

  408. 

  409. 			if (isset($user_email)) {
    410. 

  410. 				$failed_tests_data .= &quot;User's E-mail: &quot; . $user_email . &quot;\n\n&quot;;
    411. 

  411. 			}
    412. 

  412. 

  413. 			$failed_tests_data .= $sep . &quot;PHPINFO&quot; . $sep;
    414. 

  414. 			$failed_tests_data .= shell_exec($php . ' -ddisplay_errors=stderr -dhtml_errors=0 -i 2&gt; /dev/null');
    415. 

  415. 

  416. 			if ($just_save_results || !mail_qa_team($failed_tests_data, $compression, $status)) {
    417. 

  417. 				file_put_contents($output_file, $failed_tests_data);
    418. 

  418. 

  419. 				if (!$just_save_results) {
    420. 

  420. 					echo &quot;\nThe test script was unable to automatically send the report to PHP's QA Team\n&quot;;
    421. 

  421. 				}
    422. 

  422. 

  423. 				echo &quot;Please send &quot; . $output_file . &quot; to &quot; . PHP_QA_EMAIL . &quot; manually, thank you.\n&quot;;
    424. 

  424. 			} else {
    425. 

  425. 				fwrite($fp, &quot;\nThank you for helping to make PHP better.\n&quot;);
    426. 

  426. 				fclose($fp);
    427. 

  427. 			}
    428. 

  428. 		}
    429. 

  429. 	}
    430. 

  430. }
    431. 

  431. 

  432. // Determine the tests to be run.
    433. 

  433. 

  434. $test_files = array();
    435. 

  435. $redir_tests = array();
    436. 

  436. $test_results = array();
    437. 

  437. $PHP_FAILED_TESTS = array('BORKED' =&gt; array(), 'FAILED' =&gt; array(), 'WARNED' =&gt; array(), 'LEAKED' =&gt; array(), 'XFAILED' =&gt; array());
    438. 

  438. 

  439. // If parameters given assume they represent selected tests to run.
    440. 

  440. $failed_tests_file= false;
    441. 

  441. $pass_option_n = false;
    442. 

  442. $pass_options = '';
    443. 

  443. 

  444. $compression = 0;
    445. 

  445. $output_file = $CUR_DIR . '/php_test_results_' . date('Ymd_Hi') . '.txt';
    446. 

  446. 

  447. if ($compression) {
    448. 

  448. 	$output_file = 'compress.zlib://' . $output_file . '.gz';
    449. 

  449. }
    450. 

  450. 

  451. $just_save_results = false;
    452. 

  452. $leak_check = false;
    453. 

  453. $html_output = false;
    454. 

  454. $html_file = null;
    455. 

  455. $temp_source = null;
    456. 

  456. $temp_target = null;
    457. 

  457. $temp_urlbase = null;
    458. 

  458. $conf_passed = null;
    459. 

  459. $no_clean = false;
    460. 

  460. 

  461. $cfgtypes = array('show', 'keep');
    462. 

  462. $cfgfiles = array('skip', 'php', 'clean', 'out', 'diff', 'exp');
    463. 

  463. $cfg = array();
    464. 

  464. 

  465. foreach($cfgtypes as $type) {
    466. 

  466. 	$cfg[$type] = array();
    467. 

  467. 

  468. 	foreach($cfgfiles as $file) {
    469. 

  469. 		$cfg[$type][$file] = false;
    470. 

  470. 	}
    471. 

  471. }
    472. 

  472. 

  473. if (getenv('TEST_PHP_ARGS')) {
    474. 

  474. 

  475. 	if (!isset($argc) || !$argc || !isset($argv)) {
    476. 

  476. 		$argv = array(__FILE__);
    477. 

  477. 	}
    478. 

  478. 

  479. 	$argv = array_merge($argv, split(' ', getenv('TEST_PHP_ARGS')));
    480. 

  480. 	$argc = count($argv);
    481. 

  481. }
    482. 

  482. 

  483. if (isset($argc) &amp;&amp; $argc &gt; 1) {
    484. 

  484. 

  485. 	for ($i=1; $i&lt;$argc; $i++) {
    486. 

  486. 		$is_switch = false;
    487. 

  487. 		$switch = substr($argv[$i],1,1);
    488. 

  488. 		$repeat = substr($argv[$i],0,1) == '-';
    489. 

  489. 

  490. 		while ($repeat) {
    491. 

  491. 

  492. 			if (!$is_switch) {
    493. 

  493. 				$switch = substr($argv[$i],1,1);
    494. 

  494. 			}
    495. 

  495. 

  496. 			$is_switch = true;
    497. 

  497. 

  498. 			if ($repeat) {
    499. 

  499. 				foreach($cfgtypes as $type) {
    500. 

  500. 					if (strpos($switch, '--' . $type) === 0) {
    501. 

  501. 						foreach($cfgfiles as $file) {
    502. 

  502. 							if ($switch == '--' . $type . '-' . $file) {
    503. 

  503. 								$cfg[$type][$file] = true;
    504. 

  504. 								$is_switch = false;
    505. 

  505. 								break;
    506. 

  506. 							}
    507. 

  507. 						}
    508. 

  508. 					}
    509. 

  509. 				}
    510. 

  510. 			}
    511. 

  511. 

  512. 			if (!$is_switch) {
    513. 

  513. 				$is_switch = true;
    514. 

  514. 				break;
    515. 

  515. 			}
    516. 

  516. 

  517. 			$repeat = false;
    518. 

  518. 

  519. 			switch($switch) {
    520. 

  520. 				case 'r':
    521. 

  521. 				case 'l':
    522. 

  522. 					$test_list = file($argv[++$i]);
    523. 

  523. 					if ($test_list) {
    524. 

  524. 						foreach($test_list as $test) {
    525. 

  525. 							$matches = array();
    526. 

  526. 							if (preg_match('/^#.*\[(.*)\]\:\s+(.*)$/', $test, $matches)) {
    527. 

  527. 								$redir_tests[] = array($matches[1], $matches[2]);
    528. 

  528. 							} else if (strlen($test)) {
    529. 

  529. 								$test_files[] = trim($test);
    530. 

  530. 							}
    531. 

  531. 						}
    532. 

  532. 					}
    533. 

  533. 					if ($switch != 'l') {
    534. 

  534. 						break;
    535. 

  535. 					}
    536. 

  536. 					$i--;
    537. 

  537. 					// break left intentionally
    538. 

  538. 				case 'w':
    539. 

  539. 					$failed_tests_file = fopen($argv[++$i], 'w+t');
    540. 

  540. 					break;
    541. 

  541. 				case 'a':
    542. 

  542. 					$failed_tests_file = fopen($argv[++$i], 'a+t');
    543. 

  543. 					break;
    544. 

  544. 				case 'c':
    545. 

  545. 					$conf_passed = $argv[++$i];
    546. 

  546. 					break;
    547. 

  547. 				case 'd':
    548. 

  548. 					$ini_overwrites[] = $argv[++$i];
    549. 

  549. 					break;
    550. 

  550. 				//case 'h'
    551. 

  551. 				case '--keep-all':
    552. 

  552. 					foreach($cfgfiles as $file) {
    553. 

  553. 						$cfg['keep'][$file] = true;
    554. 

  554. 					}
    555. 

  555. 					break;
    556. 

  556. 				//case 'l'
    557. 

  557. 				case 'm':
    558. 

  558. 					$leak_check = true;
    559. 

  559. 					$valgrind_cmd = &quot;valgrind --version&quot;;
    560. 

  560. 					$valgrind_header = system_with_timeout($valgrind_cmd);
    561. 

  561. 					$replace_count = 0;
    562. 

  562. 					if (!$valgrind_header) {
    563. 

  563. 						error(&quot;Valgrind returned no version info, cannot proceed.\nPlease check if Valgrind is installed.&quot;);
    564. 

  564. 					} else {
    565. 

  565. 						$valgrind_version = preg_replace(&quot;/valgrind-([0-9])\.([0-9])\.([0-9]+)([.-]\w+)?(\s+)/&quot;, '$1$2$3', $valgrind_header, 1, $replace_count);
    566. 

  566. 						if ($replace_count != 1 || !is_numeric($valgrind_version)) {
    567. 

  567. 							error(&quot;Valgrind returned invalid version info (\&quot;$valgrind_header\&quot;), cannot proceed.&quot;);
    568. 

  568. 						}
    569. 

  569. 						$valgrind_header = trim($valgrind_header);
    570. 

  570. 					}
    571. 

  571. 					break;
    572. 

  572. 				case 'n':
    573. 

  573. 					if (!$pass_option_n) {
    574. 

  574. 						$pass_options .= ' -n';
    575. 

  575. 					}
    576. 

  576. 					$pass_option_n = true;
    577. 

  577. 					break;
    578. 

  578. 				case '--no-clean':
    579. 

  579. 					$no_clean = true;
    580. 

  580. 					break;
    581. 

  581. 				case 'p':
    582. 

  582. 					$php = $argv[++$i];
    583. 

  583. 					putenv(&quot;TEST_PHP_EXECUTABLE=$php&quot;);
    584. 

  584. 					break;
    585. 

  585. 				case 'q':
    586. 

  586. 					putenv('NO_INTERACTION=1');
    587. 

  587. 					break;
    588. 

  588. 				//case 'r'
    589. 

  589. 				case 's':
    590. 

  590. 					$output_file = $argv[++$i];
    591. 

  591. 					$just_save_results = true;
    592. 

  592. 					break;
    593. 

  593. 				case '--set-timeout':
    594. 

  594. 					$environment['TEST_TIMEOUT'] = $argv[++$i];
    595. 

  595. 					break;
    596. 

  596. 				case '--show-all':
    597. 

  597. 					foreach($cfgfiles as $file) {
    598. 

  598. 						$cfg['show'][$file] = true;
    599. 

  599. 					}
    600. 

  600. 					break;
    601. 

  601. 				case '--temp-source':
    602. 

  602. 					$temp_source = $argv[++$i];
    603. 

  603. 					break;
    604. 

  604. 				case '--temp-target':
    605. 

  605. 					$temp_target = $argv[++$i];
    606. 

  606. 					if ($temp_urlbase) {
    607. 

  607. 						$temp_urlbase = $temp_target;
    608. 

  608. 					}
    609. 

  609. 					break;
    610. 

  610. 				case '--temp-urlbase':
    611. 

  611. 					$temp_urlbase = $argv[++$i];
    612. 

  612. 					break;
    613. 

  613. 				case 'v':
    614. 

  614. 				case '--verbose':
    615. 

  615. 					$DETAILED = true;
    616. 

  616. 					break;
    617. 

  617. 				case 'x':
    618. 

  618. 					$environment['SKIP_SLOW_TESTS'] = 1;
    619. 

  619. 					break;
    620. 

  620. 				//case 'w'
    621. 

  621. 				case '-':
    622. 

  622. 					// repeat check with full switch
    623. 

  623. 					$switch = $argv[$i];
    624. 

  624. 					if ($switch != '-') {
    625. 

  625. 						$repeat = true;
    626. 

  626. 					}
    627. 

  627. 					break;
    628. 

  628. 				case '--html':
    629. 

  629. 					$html_file = fopen($argv[++$i], 'wt');
    630. 

  630. 					$html_output = is_resource($html_file);
    631. 

  631. 					break;
    632. 

  632. 				case '--version':
    633. 

  633. 					echo '$Revision: 1.226.2.37.2.51 $' . &quot;\n&quot;;
    634. 

  634. 					exit(1);
    635. 

  635. 

  636. 				default:
    637. 

  637. 					echo &quot;Illegal switch '$switch' specified!\n&quot;;
    638. 

  638. 				case 'h':
    639. 

  639. 				case '-help':
    640. 

  640. 				case '--help':
    641. 

  641. 					echo &lt;&lt;&lt;HELP
    642. 

  642. Synopsis:
    643. 

  643.     php run-tests.php [options] [files] [directories]
    644. 

  644. 

  645. Options:
    646. 

  646.     -l &lt;file&gt;   Read the testfiles to be executed from &lt;file&gt;. After the test
    647. 

  647.                 has finished all failed tests are written to the same &lt;file&gt;.
    648. 

  648.                 If the list is empty and no further test is specified then
    649. 

  649.                 all tests are executed (same as: -r &lt;file&gt; -w &lt;file&gt;).
    650. 

  650. 

  651.     -r &lt;file&gt;   Read the testfiles to be executed from &lt;file&gt;.
    652. 

  652. 

  653.     -w &lt;file&gt;   Write a list of all failed tests to &lt;file&gt;.
    654. 

  654. 

  655.     -a &lt;file&gt;   Same as -w but append rather then truncating &lt;file&gt;.
    656. 

  656. 

  657.     -c &lt;file&gt;   Look for php.ini in directory &lt;file&gt; or use &lt;file&gt; as ini.
    658. 

  658. 

  659.     -n          Pass -n option to the php binary (Do not use a php.ini).
    660. 

  660. 

  661.     -d foo=bar  Pass -d option to the php binary (Define INI entry foo
    662. 

  662.                 with value 'bar').
    663. 

  663. 

  664.     -m          Test for memory leaks with Valgrind.
    665. 

  665. 

  666.     -p &lt;php&gt;    Specify PHP executable to run.
    667. 

  667. 

  668.     -q          Quiet, no user interaction (same as environment NO_INTERACTION).
    669. 

  669. 

  670.     -s &lt;file&gt;   Write output to &lt;file&gt;.
    671. 

  671. 

  672.     -x          Sets 'SKIP_SLOW_TESTS' environmental variable.
    673. 

  673. 

  674.     --verbose
    675. 

  675.     -v          Verbose mode.
    676. 

  676. 

  677.     --help
    678. 

  678.     -h          This Help.
    679. 

  679. 

  680.     --html &lt;file&gt; Generate HTML output.
    681. 

  681. 

  682.     --temp-source &lt;sdir&gt;  --temp-target &lt;tdir&gt; [--temp-urlbase &lt;url&gt;]
    683. 

  683.                 Write temporary files to &lt;tdir&gt; by replacing &lt;sdir&gt; from the
    684. 

  684.                 filenames to generate with &lt;tdir&gt;. If --html is being used and
    685. 

  685.                 &lt;url&gt; given then the generated links are relative and prefixed
    686. 

  686.                 with the given url. In general you want to make &lt;sdir&gt; the path
    687. 

  687.                 to your source files and &lt;tdir&gt; some pach in your web page
    688. 

  688.                 hierarchy with &lt;url&gt; pointing to &lt;tdir&gt;.
    689. 

  689. 

  690.     --keep-[all|php|skip|clean]
    691. 

  691.                 Do not delete 'all' files, 'php' test file, 'skip' or 'clean'
    692. 

  692.                 file.
    693. 

  693. 

  694.     --set-timeout [n]
    695. 

  695.                 Set timeout for individual tests, where [n] is the number of
    696. 

  696.                 seconds. The default value is 60 seconds, or 300 seconds when
    697. 

  697.                 testing for memory leaks.
    698. 

  698. 

  699.     --show-[all|php|skip|clean|exp|diff|out]
    700. 

  700.                 Show 'all' files, 'php' test file, 'skip' or 'clean' file. You
    701. 

  701.                 can also use this to show the output 'out', the expected result
    702. 

  702.                 'exp' or the difference between them 'diff'. The result types
    703. 

  703.                 get written independent of the log format, however 'diff' only
    704. 

  704.                 exists when a test fails.
    705. 

  705. 

  706.     --no-clean  Do not execute clean section if any.
    707. 

  707. 

  708. HELP;
    709. 

  709. 					exit(1);
    710. 

  710. 			}
    711. 

  711. 		}
    712. 

  712. 

  713. 		if (!$is_switch) {
    714. 

  714. 			$testfile = realpath($argv[$i]);
    715. 

  715. 

  716. 			if (!$testfile &amp;&amp; strpos($argv[$i], '*') !== false &amp;&amp; function_exists('glob')) {
    717. 

  717. 

  718. 				if (preg_match(&quot;/\.phpt$/&quot;, $argv[$i])) {
    719. 

  719. 					$pattern_match = glob($argv[$i]);
    720. 

  720. 				} else if (preg_match(&quot;/\*$/&quot;, $argv[$i])) {
    721. 

  721. 					$pattern_match = glob($argv[$i] . '.phpt');
    722. 

  722. 				} else {
    723. 

  723. 					die(&quot;bogus test name &quot; . $argv[$i] . &quot;\n&quot;);
    724. 

  724. 				}
    725. 

  725. 

  726. 				if (is_array($pattern_match)) {
    727. 

  727. 					$test_files = array_merge($test_files, $pattern_match);
    728. 

  728. 				}
    729. 

  729. 

  730. 			} else if (is_dir($testfile)) {
    731. 

  731. 				find_files($testfile);
    732. 

  732. 			} else if (preg_match(&quot;/\.phpt$/&quot;, $testfile)) {
    733. 

  733. 				$test_files[] = $testfile;
    734. 

  734. 			} else {
    735. 

  735. 				die(&quot;bogus test name &quot; . $argv[$i] . &quot;\n&quot;);
    736. 

  736. 			}
    737. 

  737. 		}
    738. 

  738. 	}
    739. 

  739. 

  740. 	if (strlen($conf_passed)) {
    741. 

  741. 		if (substr(PHP_OS, 0, 3) == &quot;WIN&quot;) {
    742. 

  742. 			$pass_options .= &quot; -c &quot; . escapeshellarg($conf_passed);
    743. 

  743. 		} else {
    744. 

  744. 			$pass_options .= &quot; -c '$conf_passed'&quot;;
    745. 

  745. 		}
    746. 

  746. 	}
    747. 

  747. 

  748. 	$test_files = array_unique($test_files);
    749. 

  749. 	$test_files = array_merge($test_files, $redir_tests);
    750. 

  750. 

  751. 	// Run selected tests.
    752. 

  752. 	$test_cnt = count($test_files);
    753. 

  753. 

  754. 	if ($test_cnt) {
    755. 

  755. 		putenv('NO_INTERACTION=1');
    756. 

  756. 		verify_config();
    757. 

  757. 		write_information($html_output);
    758. 

  758. 		usort($test_files, &quot;test_sort&quot;);
    759. 

  759. 		$start_time = time();
    760. 

  760. 

  761. 		if (!$html_output) {
    762. 

  762. 			echo &quot;Running selected tests.\n&quot;;
    763. 

  763. 		} else {
    764. 

  764. 			show_start($start_time);
    765. 

  765. 		}
    766. 

  766. 

  767. 		$test_idx = 0;
    768. 

  768. 		run_all_tests($test_files, $environment);
    769. 

  769. 		$end_time = time();
    770. 

  770. 

  771. 		if ($html_output) {
    772. 

  772. 			show_end($end_time);
    773. 

  773. 		}
    774. 

  774. 

  775. 		if ($failed_tests_file) {
    776. 

  776. 			fclose($failed_tests_file);
    777. 

  777. 		}
    778. 

  778. 

  779. 		if (count($test_files) || count($test_results)) {
    780. 

  780. 			compute_summary();
    781. 

  781. 			if ($html_output) {
    782. 

  782. 				fwrite($html_file, &quot;&lt;hr/&gt;\n&quot; . get_summary(false, true));
    783. 

  783. 			}
    784. 

  784. 			echo &quot;=====================================================================&quot;;
    785. 

  785. 			echo get_summary(false, false);
    786. 

  786. 		}
    787. 

  787. 

  788. 		if ($html_output) {
    789. 

  789. 			fclose($html_file);
    790. 

  790. 		}
    791. 

  791. 

  792. 		if ($output_file != '' &amp;&amp; $just_save_results) {
    793. 

  793. 			save_or_mail_results();
    794. 

  794. 		}
    795. 

  795. 

  796. 		if (getenv('REPORT_EXIT_STATUS') == 1 and preg_match('/FAILED(?: |$)/', implode(' ', $test_results))) {
    797. 

  797. 			exit(1);
    798. 

  798. 		}
    799. 

  799. 

  800. 		exit(0);
    801. 

  801. 	}
    802. 

  802. }
    803. 

  803. 

  804. verify_config();
    805. 

  805. write_information($html_output);
    806. 

  806. 

  807. // Compile a list of all test files (*.phpt).
    808. 

  808. $test_files = array();
    809. 

  809. $exts_tested = count($exts_to_test);
    810. 

  810. $exts_skipped = 0;
    811. 

  811. $ignored_by_ext = 0;
    812. 

  812. sort($exts_to_test);
    813. 

  813. $test_dirs = array();
    814. 

  814. $optionals = array('tests', 'ext', 'Zend', 'ZendEngine2', 'sapi/cli', 'sapi/cgi');
    815. 

  815. 

  816. foreach($optionals as $dir) {
    817. 

  817. 	if (@filetype($dir) == 'dir') {
    818. 

  818. 		$test_dirs[] = $dir;
    819. 

  819. 	}
    820. 

  820. }
    821. 

  821. 

  822. // Convert extension names to lowercase
    823. 

  823. foreach ($exts_to_test as $key =&gt; $val) {
    824. 

  824. 	$exts_to_test[$key] = strtolower($val);
    825. 

  825. }
    826. 

  826. 

  827. foreach ($test_dirs as $dir) {
    828. 

  828. 	find_files(&quot;{$cwd}/{$dir}&quot;, ($dir == 'ext'));
    829. 

  829. }
    830. 

  830. 

  831. foreach ($user_tests as $dir) {
    832. 

  832. 	find_files($dir, ($dir == 'ext'));
    833. 

  833. }
    834. 

  834. 

  835. function find_files($dir, $is_ext_dir = false, $ignore = false)
    836. 

  836. {
    837. 

  837. 	global $test_files, $exts_to_test, $ignored_by_ext, $exts_skipped, $exts_tested;
    838. 

  838. 

  839. 	$o = opendir($dir) or error(&quot;cannot open directory: $dir&quot;);
    840. 

  840. 

  841. 	while (($name = readdir($o)) !== false) {
    842. 

  842. 

  843. 		if (is_dir(&quot;{$dir}/{$name}&quot;) &amp;&amp; !in_array($name, array('.', '..', 'CVS'))) {
    844. 

  844. 			$skip_ext = ($is_ext_dir &amp;&amp; !in_array(strtolower($name), $exts_to_test));
    845. 

  845. 			if ($skip_ext) {
    846. 

  846. 				$exts_skipped++;
    847. 

  847. 			}
    848. 

  848. 			find_files(&quot;{$dir}/{$name}&quot;, false, $ignore || $skip_ext);
    849. 

  849. 		}
    850. 

  850. 

  851. 		// Cleanup any left-over tmp files from last run.
    852. 

  852. 		if (substr($name, -4) == '.tmp') {
    853. 

  853. 			@unlink(&quot;$dir/$name&quot;);
    854. 

  854. 			continue;
    855. 

  855. 		}
    856. 

  856. 

  857. 		// Otherwise we're only interested in *.phpt files.
    858. 

  858. 		if (substr($name, -5) == '.phpt') {
    859. 

  859. 			if ($ignore) {
    860. 

  860. 				$ignored_by_ext++;
    861. 

  861. 			} else {
    862. 

  862. 				$testfile = realpath(&quot;{$dir}/{$name}&quot;);
    863. 

  863. 				$test_files[] = $testfile;
    864. 

  864. 			}
    865. 

  865. 		}
    866. 

  866. 	}
    867. 

  867. 

  868. 	closedir($o);
    869. 

  869. }
    870. 

  870. 

  871. function test_name($name)
    872. 

  872. {
    873. 

  873. 	if (is_array($name)) {
    874. 

  874. 		return $name[0] . ':' . $name[1];
    875. 

  875. 	} else {
    876. 

  876. 		return $name;
    877. 

  877. 	}
    878. 

  878. }
    879. 

  879. 

  880. function test_sort($a, $b)
    881. 

  881. {
    882. 

  882. 	global $cwd;
    883. 

  883. 

  884. 	$a = test_name($a);
    885. 

  885. 	$b = test_name($b);
    886. 

  886. 

  887. 	$ta = strpos($a, &quot;{$cwd}/tests&quot;) === 0 ? 1 + (strpos($a, &quot;{$cwd}/tests/run-test&quot;) === 0 ? 1 : 0) : 0;
    888. 

  888. 	$tb = strpos($b, &quot;{$cwd}/tests&quot;) === 0 ? 1 + (strpos($b, &quot;{$cwd}/tests/run-test&quot;) === 0 ? 1 : 0) : 0;
    889. 

  889. 

  890. 	if ($ta == $tb) {
    891. 

  891. 		return strcmp($a, $b);
    892. 

  892. 	} else {
    893. 

  893. 		return $tb - $ta;
    894. 

  894. 	}
    895. 

  895. }
    896. 

  896. 

  897. $test_files = array_unique($test_files);
    898. 

  898. usort($test_files, &quot;test_sort&quot;);
    899. 

  899. 

  900. $start_time = time();
    901. 

  901. show_start($start_time);
    902. 

  902. 

  903. $test_cnt = count($test_files);
    904. 

  904. $test_idx = 0;
    905. 

  905. run_all_tests($test_files, $environment);
    906. 

  906. $end_time = time();
    907. 

  907. 

  908. if ($failed_tests_file) {
    909. 

  909. 	fclose($failed_tests_file);
    910. 

  910. }
    911. 

  911. 

  912. // Summarize results
    913. 

  913. 

  914. if (0 == count($test_results)) {
    915. 

  915. 	echo &quot;No tests were run.\n&quot;;
    916. 

  916. 	return;
    917. 

  917. }
    918. 

  918. 

  919. compute_summary();
    920. 

  920. 

  921. show_end($end_time);
    922. 

  922. show_summary();
    923. 

  923. 

  924. if ($html_output) {
    925. 

  925. 	fclose($html_file);
    926. 

  926. }
    927. 

  927. 

  928. save_or_mail_results();
    929. 

  929.  
    930. 

  930. if (getenv('REPORT_EXIT_STATUS') == 1 and $sum_results['FAILED']) {
    931. 

  931. 	exit(1);
    932. 

  932. }
    933. 

  933. exit(0);
    934. 

  934. 

  935. //
    936. 

  936. // Send Email to QA Team
    937. 

  937. //
    938. 

  938. 

  939. function mail_qa_team($data, $compression, $status = false)
    940. 

  940. {
    941. 

  941. 	$url_bits = parse_url(QA_SUBMISSION_PAGE);
    942. 

  942. 

  943. 	if (empty($url_bits['port'])) {
    944. 

  944. 		$url_bits['port'] = 80;
    945. 

  945. 	}
    946. 

  946. 

  947. 	$data = &quot;php_test_data=&quot; . urlencode(base64_encode(str_replace(&quot;\00&quot;, '[0x0]', $data)));
    948. 

  948. 	$data_length = strlen($data);
    949. 

  949. 

  950. 	$fs = fsockopen($url_bits['host'], $url_bits['port'], $errno, $errstr, 10);
    951. 

  951. 

  952. 	if (!$fs) {
    953. 

  953. 		return false;
    954. 

  954. 	}
    955. 

  955. 

  956. 	$php_version = urlencode(TESTED_PHP_VERSION);
    957. 

  957. 

  958. 	echo &quot;\nPosting to {$url_bits['host']} {$url_bits['path']}\n&quot;;
    959. 

  959. 	fwrite($fs, &quot;POST &quot; . $url_bits['path'] . &quot;?status=$status&amp;version=$php_version HTTP/1.1\r\n&quot;);
    960. 

  960. 	fwrite($fs, &quot;Host: &quot; . $url_bits['host'] . &quot;\r\n&quot;);
    961. 

  961. 	fwrite($fs, &quot;User-Agent: QA Browser 0.1\r\n&quot;);
    962. 

  962. 	fwrite($fs, &quot;Content-Type: application/x-www-form-urlencoded\r\n&quot;);
    963. 

  963. 	fwrite($fs, &quot;Content-Length: &quot; . $data_length . &quot;\r\n\r\n&quot;);
    964. 

  964. 	fwrite($fs, $data);
    965. 

  965. 	fwrite($fs, &quot;\r\n\r\n&quot;);
    966. 

  966. 	fclose($fs);
    967. 

  967. 

  968. 	return 1;
    969. 

  969. } 
    970. 

  970. 

  971. 

  972. //
    973. 

  973. //  Write the given text to a temporary file, and return the filename.
    974. 

  974. //
    975. 

  975. 

  976. function save_text($filename, $text, $filename_copy = null)
    977. 

  977. {
    978. 

  978. 	global $DETAILED;
    979. 

  979. 

  980. 	if ($filename_copy &amp;&amp; $filename_copy != $filename) {
    981. 

  981. 		if (file_put_contents($filename_copy, (binary) $text, FILE_BINARY) === false) {
    982. 

  982. 			error(&quot;Cannot open file '&quot; . $filename_copy . &quot;' (save_text)&quot;);
    983. 

  983. 		}
    984. 

  984. 	}
    985. 

  985. 

  986. 	if (file_put_contents($filename, (binary) $text, FILE_BINARY) === false) {
    987. 

  987. 		error(&quot;Cannot open file '&quot; . $filename . &quot;' (save_text)&quot;);
    988. 

  988. 	}
    989. 

  989. 

  990. 	if (1 &lt; $DETAILED) echo &quot;
    991. 

  991. FILE $filename {{{
    992. 

  992. $text
    993. 

  993. }}} 
    994. 

  994. &quot;;
    995. 

  995. }
    996. 

  996. 

  997. //
    998. 

  998. //  Write an error in a format recognizable to Emacs or MSVC.
    999. 

  999. //
    1000. 

  1000. 

  1001. function error_report($testname, $logname, $tested) 
    1002. 

  1002. {
    1003. 

  1003. 	$testname = realpath($testname);
    1004. 

  1004. 	$logname  = realpath($logname);
    1005. 

  1005. 

  1006. 	switch (strtoupper(getenv('TEST_PHP_ERROR_STYLE'))) {
    1007. 

  1007. 		case 'MSVC':
    1008. 

  1008. 			echo $testname . &quot;(1) : $tested\n&quot;;
    1009. 

  1009. 			echo $logname . &quot;(1) :  $tested\n&quot;;
    1010. 

  1010. 			break;
    1011. 

  1011. 		case 'EMACS':
    1012. 

  1012. 			echo $testname . &quot;:1: $tested\n&quot;;
    1013. 

  1013. 			echo $logname . &quot;:1:  $tested\n&quot;;
    1014. 

  1014. 			break;
    1015. 

  1015. 	}
    1016. 

  1016. }
    1017. 

  1017. 

  1018. function system_with_timeout($commandline, $env = null, $stdin = null)
    1019. 

  1019. {
    1020. 

  1020. 	global $leak_check;
    1021. 

  1021. 

  1022. 	$data = '';
    1023. 

  1023. 

  1024. 	$proc = proc_open($commandline, array(
    1025. 

  1025. 		0 =&gt; array('pipe', 'r'),
    1026. 

  1026. 		1 =&gt; array('pipe', 'w'),
    1027. 

  1027. 		2 =&gt; array('pipe', 'w')
    1028. 

  1028. 		), $pipes, null, $env, array('suppress_errors' =&gt; true, 'binary_pipes' =&gt; true));
    1029. 

  1029. 

  1030. 	if (!$proc) {
    1031. 

  1031. 		return false;
    1032. 

  1032. 	}
    1033. 

  1033. 

  1034. 	if (!is_null($stdin)) {
    1035. 

  1035. 		fwrite($pipes[0], (binary) $stdin);
    1036. 

  1036. 	}
    1037. 

  1037. 	fclose($pipes[0]);
    1038. 

  1038. 	
    1039. 

  1039. 	$timeout = $leak_check ? 300 : (isset($env['TEST_TIMEOUT']) ? $env['TEST_TIMEOUT'] : 60);
    1040. 

  1040. 

  1041. 	while (true) {
    1042. 

  1042. 		/* hide errors from interrupted syscalls */
    1043. 

  1043. 		$r = $pipes;
    1044. 

  1044. 		$w = null;
    1045. 

  1045. 		$e = null;
    1046. 

  1046. 

  1047. 		$n = @stream_select($r, $w, $e, $timeout);
    1048. 

  1048. 

  1049. 		if ($n === false) {
    1050. 

  1050. 			break;
    1051. 

  1051. 		} else if ($n === 0) {
    1052. 

  1052. 			/* timed out */
    1053. 

  1053. 			$data .= &quot;\n ** ERROR: process timed out **\n&quot;;
    1054. 

  1054. 			proc_terminate($proc);
    1055. 

  1055. 			return $data;
    1056. 

  1056. 		} else if ($n &gt; 0) {
    1057. 

  1057. 			$line = fread($pipes[1], 8192);
    1058. 

  1058. 			if (strlen($line) == 0) {
    1059. 

  1059. 				/* EOF */
    1060. 

  1060. 				break;
    1061. 

  1061. 			}
    1062. 

  1062. 			$data .= (binary) $line;
    1063. 

  1063. 		}
    1064. 

  1064. 	}
    1065. 

  1065. 

  1066. 	$stat = proc_get_status($proc);
    1067. 

  1067. 

  1068. 	if ($stat['signaled']) {
    1069. 

  1069. 		$data .= &quot;\nTermsig=&quot; . $stat['stopsig'];
    1070. 

  1070. 	}
    1071. 

  1071. 

  1072. 	$code = proc_close($proc);
    1073. 

  1073. 	return $data;
    1074. 

  1074. }
    1075. 

  1075. 

  1076. function run_all_tests($test_files, $env, $redir_tested = null)
    1077. 

  1077. {
    1078. 

  1078. 	global $test_results, $failed_tests_file, $php, $test_cnt, $test_idx;
    1079. 

  1079. 

  1080. 	foreach($test_files as $name) {
    1081. 

  1081. 

  1082. 		if (is_array($name)) {
    1083. 

  1083. 			$index = &quot;# $name[1]: $name[0]&quot;;
    1084. 

  1084. 

  1085. 			if ($redir_tested) {
    1086. 

  1086. 				$name = $name[0];
    1087. 

  1087. 			}
    1088. 

  1088. 		} else if ($redir_tested) {
    1089. 

  1089. 			$index = &quot;# $redir_tested: $name&quot;;
    1090. 

  1090. 		} else {
    1091. 

  1091. 			$index = $name;
    1092. 

  1092. 		}
    1093. 

  1093. 		$test_idx++;
    1094. 

  1094. 		$result = run_test($php, $name, $env);
    1095. 

  1095. 

  1096. 		if (!is_array($name) &amp;&amp; $result != 'REDIR') {
    1097. 

  1097. 			$test_results[$index] = $result;
    1098. 

  1098. 			if ($failed_tests_file &amp;&amp; ($result == 'XFAILED' || $result == 'FAILED' || $result == 'WARNED' || $result == 'LEAKED')) {
    1099. 

  1099. 				fwrite($failed_tests_file, &quot;$index\n&quot;);
    1100. 

  1100. 			}
    1101. 

  1101. 		}
    1102. 

  1102. 	}
    1103. 

  1103. }
    1104. 

  1104. 

  1105. //
    1106. 

  1106. //  Show file or result block
    1107. 

  1107. //
    1108. 

  1108. function show_file_block($file, $block, $section = null)
    1109. 

  1109. {
    1110. 

  1110. 	global $cfg;
    1111. 

  1111. 

  1112. 	if ($cfg['show'][$file]) {
    1113. 

  1113. 

  1114. 		if (is_null($section)) {
    1115. 

  1115. 			$section = strtoupper($file);
    1116. 

  1116. 		}
    1117. 

  1117. 

  1118. 		echo &quot;\n========&quot; . $section . &quot;========\n&quot;;
    1119. 

  1119. 		echo rtrim($block);
    1120. 

  1120. 		echo &quot;\n========DONE========\n&quot;;
    1121. 

  1121. 	}
    1122. 

  1122. }
    1123. 

  1123. 

  1124. //
    1125. 

  1125. //  Run an individual test case.
    1126. 

  1126. //
    1127. 

  1127. function run_test($php, $file, $env)
    1128. 

  1128. {
    1129. 

  1129. 	global $log_format, $info_params, $ini_overwrites, $cwd, $PHP_FAILED_TESTS;
    1130. 

  1130. 	global $pass_options, $DETAILED, $IN_REDIRECT, $test_cnt, $test_idx;
    1131. 

  1131. 	global $leak_check, $temp_source, $temp_target, $cfg, $environment;
    1132. 

  1132. 	global $no_clean;
    1133. 

  1133. 	global $valgrind_version;
    1134. 

  1134. 

  1135. 	$temp_filenames = null;
    1136. 

  1136. 	$org_file = $file;
    1137. 

  1137. 

  1138. 	if (isset($env['TEST_PHP_CGI_EXECUTABLE'])) {
    1139. 

  1139. 		$php_cgi = $env['TEST_PHP_CGI_EXECUTABLE'];
    1140. 

  1140. 	}
    1141. 

  1141. 

  1142. 	if (is_array($file)) {
    1143. 

  1143. 		$file = $file[0];
    1144. 

  1144. 	}
    1145. 

  1145. 

  1146. 	if ($DETAILED) echo &quot;
    1147. 

  1147. =================
    1148. 

  1148. TEST $file
    1149. 

  1149. &quot;;
    1150. 

  1150. 

  1151. 	// Load the sections of the test file.
    1152. 

  1152. 	$section_text = array('TEST' =&gt; '');
    1153. 

  1153. 

  1154. 	$fp = fopen($file, &quot;rt&quot;) or error(&quot;Cannot open test file: $file&quot;);
    1155. 

  1155. 

  1156. 	$borked = false;
    1157. 

  1157. 	$bork_info = '';
    1158. 

  1158. 

  1159. 	if (!feof($fp)) {
    1160. 

  1160. 		$line = fgets($fp);
    1161. 

  1161. 

  1162. 		if ($line === false) {
    1163. 

  1163. 			$bork_info = &quot;cannot read test&quot;;
    1164. 

  1164. 			$borked = true;
    1165. 

  1165. 		}
    1166. 

  1166. 	} else {
    1167. 

  1167. 		$bork_info = &quot;empty test [$file]&quot;;
    1168. 

  1168. 		$borked = true;
    1169. 

  1169. 	}
    1170. 

  1170. 	if (!$borked &amp;&amp; strncmp('--TEST--', $line, 8)) {
    1171. 

  1171. 		$bork_info = &quot;tests must start with --TEST-- [$file]&quot;;
    1172. 

  1172. 		$borked = true;
    1173. 

  1173. 	}
    1174. 

  1174. 

  1175. 	$section = 'TEST';
    1176. 

  1176. 	$secfile = false;
    1177. 

  1177. 	$secdone = false;
    1178. 

  1178. 

  1179. 	while (!feof($fp)) {
    1180. 

  1180. 		$line = fgets($fp);
    1181. 

  1181. 

  1182. 		// Match the beginning of a section.
    1183. 

  1183. 		if (preg_match('/^--([_A-Z]+)--/', $line, $r)) {
    1184. 

  1184. 			$section = $r[1];
    1185. 

  1185. 

  1186. 			if (isset($section_text[$section])) {
    1187. 

  1187. 				$bork_info = &quot;duplicated $section section&quot;;
    1188. 

  1188. 				$borked    = true;
    1189. 

  1189. 			}
    1190. 

  1190. 

  1191. 			$section_text[$section] = '';
    1192. 

  1192. 			$secfile = $section == 'FILE' || $section == 'FILEEOF' || $section == 'FILE_EXTERNAL';
    1193. 

  1193. 			$secdone = false;
    1194. 

  1194. 			continue;
    1195. 

  1195. 		}
    1196. 

  1196. 

  1197. 		// Add to the section text.
    1198. 

  1198. 		if (!$secdone) {
    1199. 

  1199. 			$section_text[$section] .= $line;
    1200. 

  1200. 		}
    1201. 

  1201. 

  1202. 		// End of actual test?
    1203. 

  1203. 		if ($secfile &amp;&amp; preg_match('/^===DONE===\s*$/', $line)) {
    1204. 

  1204. 			$secdone = true;
    1205. 

  1205. 		}
    1206. 

  1206. 	}
    1207. 

  1207. 

  1208. 	// the redirect section allows a set of tests to be reused outside of
    1209. 

  1209. 	// a given test dir
    1210. 

  1210. 	if (!$borked) {
    1211. 

  1211. 		if (@count($section_text['REDIRECTTEST']) == 1) {
    1212. 

  1212. 

  1213. 			if ($IN_REDIRECT) {
    1214. 

  1214. 				$borked = true;
    1215. 

  1215. 				$bork_info = &quot;Can't redirect a test from within a redirected test&quot;;
    1216. 

  1216. 			} else {
    1217. 

  1217. 				$borked = false;
    1218. 

  1218. 			}
    1219. 

  1219. 

  1220. 		} else {
    1221. 

  1221. 

  1222. 			if (@count($section_text['FILE']) + @count($section_text['FILEEOF']) + @count($section_text['FILE_EXTERNAL']) != 1) {
    1223. 

  1223. 				$bork_info = &quot;missing section --FILE--&quot;;
    1224. 

  1224. 				$borked = true;
    1225. 

  1225. 			}
    1226. 

  1226. 

  1227. 			if (@count($section_text['FILEEOF']) == 1) {
    1228. 

  1228. 				$section_text['FILE'] = preg_replace(&quot;/[\r\n]+$/&quot;, '', $section_text['FILEEOF']);
    1229. 

  1229. 				unset($section_text['FILEEOF']);
    1230. 

  1230. 			}
    1231. 

  1231. 

  1232. 			if (@count($section_text['FILE_EXTERNAL']) == 1) {
    1233. 

  1233. 				// don't allow tests to retrieve files from anywhere but this subdirectory
    1234. 

  1234. 				$section_text['FILE_EXTERNAL'] = dirname($file) . '/' . trim(str_replace('..', '', $section_text['FILE_EXTERNAL']));
    1235. 

  1235. 

  1236. 				if (file_exists($section_text['FILE_EXTERNAL'])) {
    1237. 

  1237. 					$section_text['FILE'] = file_get_contents($section_text['FILE_EXTERNAL']);
    1238. 

  1238. 					unset($section_text['FILE_EXTERNAL']);
    1239. 

  1239. 				} else {
    1240. 

  1240. 					$bork_info = &quot;could not load --FILE_EXTERNAL-- &quot; . dirname($file) . '/' . trim($section_text['FILE_EXTERNAL']);
    1241. 

  1241. 					$borked = true;
    1242. 

  1242. 				}
    1243. 

  1243. 			}
    1244. 

  1244. 

  1245. 			if ((@count($section_text['EXPECT']) + @count($section_text['EXPECTF']) + @count($section_text['EXPECTREGEX'])) != 1) {
    1246. 

  1246. 				$bork_info = &quot;missing section --EXPECT--, --EXPECTF-- or --EXPECTREGEX--&quot;;
    1247. 

  1247. 				$borked = true;
    1248. 

  1248. 			}
    1249. 

  1249. 		}
    1250. 

  1250. 	}
    1251. 

  1251. 	fclose($fp);
    1252. 

  1252. 

  1253. 	$shortname = str_replace($cwd . '/', '', $file);
    1254. 

  1254. 	$tested_file = $shortname;
    1255. 

  1255. 

  1256. 	if ($borked) {
    1257. 

  1257. 		show_result(&quot;BORK&quot;, $bork_info, $tested_file);
    1258. 

  1258. 		$PHP_FAILED_TESTS['BORKED'][] = array (
    1259. 

  1259. 								'name'      =&gt; $file,
    1260. 

  1260. 								'test_name' =&gt; '',
    1261. 

  1261. 								'output'    =&gt; '',
    1262. 

  1262. 								'diff'      =&gt; '',
    1263. 

  1263. 								'info'      =&gt; &quot;$bork_info [$file]&quot;,
    1264. 

  1264. 		);
    1265. 

  1265. 		return 'BORKED';
    1266. 

  1266. 	}
    1267. 

  1267. 

  1268. 	$tested = trim($section_text['TEST']);
    1269. 

  1269. 

  1270. 	/* For GET/POST tests, check if cgi sapi is available and if it is, use it. */
    1271. 

  1271. 	if (!empty($section_text['GET']) || !empty($section_text['POST']) || !empty($section_text['POST_RAW']) || !empty($section_text['COOKIE']) || !empty($section_text['EXPECTHEADERS'])) {
    1272. 

  1272. 		if (isset($php_cgi)) {
    1273. 

  1273. 			$old_php = $php;
    1274. 

  1274. 			$php = $php_cgi . ' -C ';
    1275. 

  1275. 		} else if (!strncasecmp(PHP_OS, &quot;win&quot;, 3) &amp;&amp; file_exists(dirname($php) . &quot;/php-cgi.exe&quot;)) {
    1276. 

  1276. 			$old_php = $php;
    1277. 

  1277. 			$php = realpath(dirname($php) . &quot;/php-cgi.exe&quot;) . ' -C ';
    1278. 

  1278. 		} else {
    1279. 

  1279. 			if (file_exists(dirname($php) . &quot;/../../sapi/cgi/php-cgi&quot;)) {
    1280. 

  1280. 				$old_php = $php;
    1281. 

  1281. 				$php = realpath(dirname($php) . &quot;/../../sapi/cgi/php-cgi&quot;) . ' -C ';
    1282. 

  1282. 			} else if (file_exists(&quot;./sapi/cgi/php-cgi&quot;)) {
    1283. 

  1283. 				$old_php = $php;
    1284. 

  1284. 				$php = realpath(&quot;./sapi/cgi/php-cgi&quot;) . ' -C ';
    1285. 

  1285. 			} else {
    1286. 

  1286. 				show_result('SKIP', $tested, $tested_file, &quot;reason: CGI not available&quot;);
    1287. 

  1287. 				return 'SKIPPED';
    1288. 

  1288. 			}
    1289. 

  1289. 		}
    1290. 

  1290. 	}
    1291. 

  1291. 

  1292. 	show_test($test_idx, $shortname);
    1293. 

  1293. 

  1294. 	if (is_array($IN_REDIRECT)) {
    1295. 

  1295. 		$temp_dir = $test_dir = $IN_REDIRECT['dir'];
    1296. 

  1296. 	} else {
    1297. 

  1297. 		$temp_dir = $test_dir = realpath(dirname($file));
    1298. 

  1298. 	}
    1299. 

  1299. 

  1300. 	if ($temp_source &amp;&amp; $temp_target) {
    1301. 

  1301. 		$temp_dir = str_replace($temp_source, $temp_target, $temp_dir);
    1302. 

  1302. 	}
    1303. 

  1303. 

  1304. 	$main_file_name = basename($file,'phpt');
    1305. 

  1305. 

  1306. 	$diff_filename     = $temp_dir . DIRECTORY_SEPARATOR . $main_file_name . 'diff';
    1307. 

  1307. 	$log_filename      = $temp_dir . DIRECTORY_SEPARATOR . $main_file_name . 'log';
    1308. 

  1308. 	$exp_filename      = $temp_dir . DIRECTORY_SEPARATOR . $main_file_name . 'exp';
    1309. 

  1309. 	$output_filename   = $temp_dir . DIRECTORY_SEPARATOR . $main_file_name . 'out';
    1310. 

  1310. 	$memcheck_filename = $temp_dir . DIRECTORY_SEPARATOR . $main_file_name . 'mem';
    1311. 

  1311. 	$temp_file         = $temp_dir . DIRECTORY_SEPARATOR . $main_file_name . 'php';
    1312. 

  1312. 	$test_file         = $test_dir . DIRECTORY_SEPARATOR . $main_file_name . 'php';
    1313. 

  1313. 	$temp_skipif       = $temp_dir . DIRECTORY_SEPARATOR . $main_file_name . 'skip.php';
    1314. 

  1314. 	$test_skipif       = $test_dir . DIRECTORY_SEPARATOR . $main_file_name . 'skip.php';
    1315. 

  1315. 	$temp_clean        = $temp_dir . DIRECTORY_SEPARATOR . $main_file_name . 'clean.php';
    1316. 

  1316. 	$test_clean        = $test_dir . DIRECTORY_SEPARATOR . $main_file_name . 'clean.php';
    1317. 

  1317. 	$tmp_post          = $temp_dir . DIRECTORY_SEPARATOR . uniqid('/phpt.');
    1318. 

  1318. 	$tmp_relative_file = str_replace(realpath(dirname(__FILE__)) . DIRECTORY_SEPARATOR, '', $test_file) . 't';
    1319. 

  1319. 

  1320. 	if ($temp_source &amp;&amp; $temp_target) {
    1321. 

  1321. 		$temp_skipif  .= 's';
    1322. 

  1322. 		$temp_file    .= 's';
    1323. 

  1323. 		$temp_clean   .= 's';
    1324. 

  1324. 		$copy_file     = $temp_dir . DIRECTORY_SEPARATOR . basename(is_array($file) ? $file[1] : $file) . '.phps';
    1325. 

  1325. 

  1326. 		if (!is_dir(dirname($copy_file))) {
    1327. 

  1327. 			mkdir(dirname($copy_file), 0777, true) or error(&quot;Cannot create output directory - &quot; . dirname($copy_file));
    1328. 

  1328. 		}
    1329. 

  1329. 

  1330. 		if (isset($section_text['FILE'])) {
    1331. 

  1331. 			save_text($copy_file, $section_text['FILE']);
    1332. 

  1332. 		}
    1333. 

  1333. 

  1334. 		$temp_filenames = array(
    1335. 

  1335. 			'file' =&gt; $copy_file,
    1336. 

  1336. 			'diff' =&gt; $diff_filename,
    1337. 

  1337. 			'log'  =&gt; $log_filename,
    1338. 

  1338. 			'exp'  =&gt; $exp_filename,
    1339. 

  1339. 			'out'  =&gt; $output_filename,
    1340. 

  1340. 			'mem'  =&gt; $memcheck_filename,
    1341. 

  1341. 			'php'  =&gt; $temp_file,
    1342. 

  1342. 			'skip' =&gt; $temp_skipif,
    1343. 

  1343. 			'clean'=&gt; $temp_clean);
    1344. 

  1344. 	}
    1345. 

  1345. 

  1346. 	if (is_array($IN_REDIRECT)) {
    1347. 

  1347. 		$tested = $IN_REDIRECT['prefix'] . ' ' . trim($section_text['TEST']);
    1348. 

  1348. 		$tested_file = $tmp_relative_file;
    1349. 

  1349. 		$section_text['FILE'] = &quot;# original source file: $shortname\n&quot; . $section_text['FILE'];
    1350. 

  1350. 	}
    1351. 

  1351. 

  1352. 	// unlink old test results
    1353. 

  1353. 	@unlink($diff_filename);
    1354. 

  1354. 	@unlink($log_filename);
    1355. 

  1355. 	@unlink($exp_filename);
    1356. 

  1356. 	@unlink($output_filename);
    1357. 

  1357. 	@unlink($memcheck_filename);
    1358. 

  1358. 	@unlink($temp_file);
    1359. 

  1359. 	@unlink($test_file);
    1360. 

  1360. 	@unlink($temp_skipif);
    1361. 

  1361. 	@unlink($test_skipif);
    1362. 

  1362. 	@unlink($tmp_post);
    1363. 

  1363. 	@unlink($temp_clean);
    1364. 

  1364. 	@unlink($test_clean);
    1365. 

  1365. 

  1366. 	// Reset environment from any previous test.
    1367. 

  1367. 	$env['REDIRECT_STATUS'] = '';
    1368. 

  1368. 	$env['QUERY_STRING']    = '';
    1369. 

  1369. 	$env['PATH_TRANSLATED'] = '';
    1370. 

  1370. 	$env['SCRIPT_FILENAME'] = '';
    1371. 

  1371. 	$env['REQUEST_METHOD']  = '';
    1372. 

  1372. 	$env['CONTENT_TYPE']    = '';
    1373. 

  1373. 	$env['CONTENT_LENGTH']  = '';
    1374. 

  1374. 

  1375. 	if (!empty($section_text['ENV'])) {
    1376. 

  1376. 

  1377. 		foreach(explode(&quot;\n&quot;, trim($section_text['ENV'])) as $e) {
    1378. 

  1378. 			$e = explode('=', trim($e), 2);
    1379. 

  1379. 

  1380. 			if (!empty($e[0]) &amp;&amp; isset($e[1])) {
    1381. 

  1381. 				$env[$e[0]] = $e[1];
    1382. 

  1382. 			}
    1383. 

  1383. 		}
    1384. 

  1384. 	}
    1385. 

  1385. 

  1386. 	// Default ini settings
    1387. 

  1387. 	$ini_settings = array();
    1388. 

  1388. 	// additional ini overwrites
    1389. 

  1389. 	//$ini_overwrites[] = 'setting=value';
    1390. 

  1390. 	settings2array($ini_overwrites, $ini_settings);
    1391. 

  1391. 

  1392. 	// Any special ini settings
    1393. 

  1393. 	// these may overwrite the test defaults...
    1394. 

  1394. 	if (array_key_exists('INI', $section_text)) {
    1395. 

  1395. 		if (strpos($section_text['INI'], '{PWD}') !== false) {
    1396. 

  1396. 			$section_text['INI'] = str_replace('{PWD}', dirname($file), $section_text['INI']);
    1397. 

  1397. 		}
    1398. 

  1398. 		settings2array(preg_split( &quot;/[\n\r]+/&quot;, $section_text['INI']), $ini_settings);
    1399. 

  1399. 	}
    1400. 

  1400. 

  1401. 	settings2params($ini_settings);
    1402. 

  1402. 

  1403. 	// Check if test should be skipped.
    1404. 

  1404. 	$info = '';
    1405. 

  1405. 	$warn = false;
    1406. 

  1406. 

  1407. 	if (array_key_exists('SKIPIF', $section_text)) {
    1408. 

  1408. 

  1409. 		if (trim($section_text['SKIPIF'])) {
    1410. 

  1410. 			show_file_block('skip', $section_text['SKIPIF']);
    1411. 

  1411. 			save_text($test_skipif, $section_text['SKIPIF'], $temp_skipif);
    1412. 

  1412. 			$extra = substr(PHP_OS, 0, 3) !== &quot;WIN&quot; ?
    1413. 

  1413. 				&quot;unset REQUEST_METHOD; unset QUERY_STRING; unset PATH_TRANSLATED; unset SCRIPT_FILENAME; unset REQUEST_METHOD;&quot;: &quot;&quot;;
    1414. 

  1414. 

  1415. 			if ($leak_check) {
    1416. 

  1416. 				$env['USE_ZEND_ALLOC'] = '0';
    1417. 

  1417. 			} else {
    1418. 

  1418. 				$env['USE_ZEND_ALLOC'] = '1';
    1419. 

  1419. 			}
    1420. 

  1420. 

  1421. 			$output = system_with_timeout(&quot;$extra $php $pass_options -q $ini_settings $test_skipif&quot;, $env);
    1422. 

  1422. 

  1423. 			if (!$cfg['keep']['skip']) {
    1424. 

  1424. 				@unlink($test_skipif);
    1425. 

  1425. 			}
    1426. 

  1426. 

  1427. 			if (!strncasecmp('skip', ltrim($output), 4)) {
    1428. 

  1428. 

  1429. 				if (preg_match('/^\s*skip\s*(.+)\s*/i', $output, $m)) {
    1430. 

  1430. 					show_result('SKIP', $tested, $tested_file, &quot;reason: $m[1]&quot;, $temp_filenames);
    1431. 

  1431. 				} else {
    1432. 

  1432. 					show_result('SKIP', $tested, $tested_file, '', $temp_filenames);
    1433. 

  1433. 				}
    1434. 

  1434. 

  1435. 				if (isset($old_php)) {
    1436. 

  1436. 					$php = $old_php;
    1437. 

  1437. 				}
    1438. 

  1438. 

  1439. 				if (!$cfg['keep']['skip']) {
    1440. 

  1440. 					@unlink($test_skipif);
    1441. 

  1441. 				}
    1442. 

  1442. 

  1443. 				return 'SKIPPED';
    1444. 

  1444. 			}
    1445. 

  1445. 

  1446. 			if (!strncasecmp('info', ltrim($output), 4)) {
    1447. 

  1447. 				if (preg_match('/^\s*info\s*(.+)\s*/i', $output, $m)) {
    1448. 

  1448. 					$info = &quot; (info: $m[1])&quot;;
    1449. 

  1449. 				}
    1450. 

  1450. 			}
    1451. 

  1451. 

  1452. 			if (!strncasecmp('warn', ltrim($output), 4)) {
    1453. 

  1453. 				if (preg_match('/^\s*warn\s*(.+)\s*/i', $output, $m)) {
    1454. 

  1454. 					$warn = true; /* only if there is a reason */
    1455. 

  1455. 					$info = &quot; (warn: $m[1])&quot;;
    1456. 

  1456. 				}
    1457. 

  1457. 			}
    1458. 

  1458. 		}
    1459. 

  1459. 	}
    1460. 

  1460. 

  1461. 	if (@count($section_text['REDIRECTTEST']) == 1) {
    1462. 

  1462. 		$test_files = array();
    1463. 

  1463. 

  1464. 		$IN_REDIRECT = eval($section_text['REDIRECTTEST']);
    1465. 

  1465. 		$IN_REDIRECT['via'] = &quot;via [$shortname]\n\t&quot;;
    1466. 

  1466. 		$IN_REDIRECT['dir'] = realpath(dirname($file));
    1467. 

  1467. 		$IN_REDIRECT['prefix'] = trim($section_text['TEST']);
    1468. 

  1468. 

  1469. 		if (count($IN_REDIRECT['TESTS']) == 1) {
    1470. 

  1470. 

  1471. 			if (is_array($org_file)) {
    1472. 

  1472. 				$test_files[] = $org_file[1];
    1473. 

  1473. 			} else {
    1474. 

  1474. 				$GLOBALS['test_files'] = $test_files;
    1475. 

  1475. 				find_files($IN_REDIRECT['TESTS']);
    1476. 

  1476. 

  1477. 				foreach($GLOBALS['test_files'] as $f) {
    1478. 

  1478. 					$test_files[] = array($f, $file);
    1479. 

  1479. 				}
    1480. 

  1480. 			}
    1481. 

  1481. 			$test_cnt += @count($test_files) - 1;
    1482. 

  1482. 			$test_idx--;
    1483. 

  1483. 

  1484. 			show_redirect_start($IN_REDIRECT['TESTS'], $tested, $tested_file);
    1485. 

  1485. 

  1486. 			// set up environment
    1487. 

  1487. 			$redirenv = array_merge($environment, $IN_REDIRECT['ENV']);
    1488. 

  1488. 			$redirenv['REDIR_TEST_DIR'] = realpath($IN_REDIRECT['TESTS']) . DIRECTORY_SEPARATOR;
    1489. 

  1489. 

  1490. 			usort($test_files, &quot;test_sort&quot;);
    1491. 

  1491. 			run_all_tests($test_files, $redirenv, $tested);
    1492. 

  1492. 

  1493. 			show_redirect_ends($IN_REDIRECT['TESTS'], $tested, $tested_file);
    1494. 

  1494. 

  1495. 			// a redirected test never fails
    1496. 

  1496. 			$IN_REDIRECT = false;
    1497. 

  1497. 			return 'REDIR';
    1498. 

  1498. 

  1499. 		} else {
    1500. 

  1500. 

  1501. 			$bork_info = &quot;Redirect info must contain exactly one TEST string to be used as redirect directory.&quot;;
    1502. 

  1502. 			show_result(&quot;BORK&quot;, $bork_info, '', $temp_filenames);
    1503. 

  1503. 			$PHP_FAILED_TESTS['BORKED'][] = array (
    1504. 

  1504. 									'name' =&gt; $file,
    1505. 

  1505. 									'test_name' =&gt; '',
    1506. 

  1506. 									'output' =&gt; '',
    1507. 

  1507. 									'diff'   =&gt; '',
    1508. 

  1508. 									'info'   =&gt; &quot;$bork_info [$file]&quot;,
    1509. 

  1509. 			);
    1510. 

  1510. 		}
    1511. 

  1511. 	}
    1512. 

  1512. 

  1513. 	if (is_array($org_file) || @count($section_text['REDIRECTTEST']) == 1) {
    1514. 

  1514. 

  1515. 		if (is_array($org_file)) {
    1516. 

  1516. 			$file = $org_file[0];
    1517. 

  1517. 		}
    1518. 

  1518. 

  1519. 		$bork_info = &quot;Redirected test did not contain redirection info&quot;;
    1520. 

  1520. 		show_result(&quot;BORK&quot;, $bork_info, '', $temp_filenames);
    1521. 

  1521. 		$PHP_FAILED_TESTS['BORKED'][] = array (
    1522. 

  1522. 								'name' =&gt; $file,
    1523. 

  1523. 								'test_name' =&gt; '',
    1524. 

  1524. 								'output' =&gt; '',
    1525. 

  1525. 								'diff'   =&gt; '',
    1526. 

  1526. 								'info'   =&gt; &quot;$bork_info [$file]&quot;,
    1527. 

  1527. 		);
    1528. 

  1528. 		return 'BORKED';
    1529. 

  1529. 	}
    1530. 

  1530. 

  1531. 	// We've satisfied the preconditions - run the test!
    1532. 

  1532. 	show_file_block('php', $section_text['FILE'], 'TEST');
    1533. 

  1533. 	save_text($test_file, $section_text['FILE'], $temp_file);
    1534. 

  1534. 

  1535. 	if (array_key_exists('GET', $section_text)) {
    1536. 

  1536. 		$query_string = trim($section_text['GET']);
    1537. 

  1537. 	} else {
    1538. 

  1538. 		$query_string = '';
    1539. 

  1539. 	}
    1540. 

  1540. 

  1541. 	$env['REDIRECT_STATUS'] = '1';
    1542. 

  1542. 	$env['QUERY_STRING']    = $query_string;
    1543. 

  1543. 	$env['PATH_TRANSLATED'] = $test_file;
    1544. 

  1544. 	$env['SCRIPT_FILENAME'] = $test_file;
    1545. 

  1545. 

  1546. 	if (array_key_exists('COOKIE', $section_text)) {
    1547. 

  1547. 		$env['HTTP_COOKIE'] = trim($section_text['COOKIE']);
    1548. 

  1548. 	} else {
    1549. 

  1549. 		$env['HTTP_COOKIE'] = '';
    1550. 

  1550. 	}
    1551. 

  1551. 

  1552. 	$args = isset($section_text['ARGS']) ? ' -- ' . $section_text['ARGS'] : '';
    1553. 

  1553. 

  1554. 	if (array_key_exists('POST_RAW', $section_text) &amp;&amp; !empty($section_text['POST_RAW'])) {
    1555. 

  1555. 

  1556. 		$post = trim($section_text['POST_RAW']);
    1557. 

  1557. 		$raw_lines = explode(&quot;\n&quot;, $post);
    1558. 

  1558. 

  1559. 		$request = '';
    1560. 

  1560. 		$started = false;
    1561. 

  1561. 

  1562. 		foreach ($raw_lines as $line) {
    1563. 

  1563. 

  1564. 			if (empty($env['CONTENT_TYPE']) &amp;&amp; preg_match('/^Content-Type:(.*)/i', $line, $res)) {
    1565. 

  1565. 				$env['CONTENT_TYPE'] = trim(str_replace(&quot;\r&quot;, '', $res[1]));
    1566. 

  1566. 				continue;
    1567. 

  1567. 			}
    1568. 

  1568. 

  1569. 			if ($started) {
    1570. 

  1570. 				$request .= &quot;\n&quot;;
    1571. 

  1571. 			}
    1572. 

  1572. 

  1573. 			$started = true;
    1574. 

  1574. 			$request .= $line;
    1575. 

  1575. 		}
    1576. 

  1576. 

  1577. 		$env['CONTENT_LENGTH'] = strlen($request);
    1578. 

  1578. 		$env['REQUEST_METHOD'] = 'POST';
    1579. 

  1579. 

  1580. 		if (empty($request)) {
    1581. 

  1581. 			return 'BORKED';
    1582. 

  1582. 		}
    1583. 

  1583. 

  1584. 		save_text($tmp_post, $request);
    1585. 

  1585. 		$cmd = &quot;$php $pass_options $ini_settings -f \&quot;$test_file\&quot; 2&gt;&amp;1 &lt; $tmp_post&quot;;
    1586. 

  1586. 

  1587. 	} else if (array_key_exists('POST', $section_text) &amp;&amp; !empty($section_text['POST'])) {
    1588. 

  1588. 

  1589. 		$post = trim($section_text['POST']);
    1590. 

  1590. 

  1591. 		if (array_key_exists('GZIP_POST', $section_text) &amp;&amp; function_exists('gzencode')) {
    1592. 

  1592. 			$post = gzencode($post, 9, FORCE_GZIP);
    1593. 

  1593. 			$env['HTTP_CONTENT_ENCODING'] = 'gzip';
    1594. 

  1594. 		} else if (array_key_exists('DEFLATE_POST', $section_text) &amp;&amp; function_exists('gzcompress')) {
    1595. 

  1595. 			$post = gzcompress($post, 9);
    1596. 

  1596. 			$env['HTTP_CONTENT_ENCODING'] = 'deflate';
    1597. 

  1597. 		}
    1598. 

  1598. 

  1599. 		save_text($tmp_post, $post);
    1600. 

  1600. 		$content_length = strlen($post);
    1601. 

  1601. 

  1602. 		$env['REQUEST_METHOD'] = 'POST';
    1603. 

  1603. 		$env['CONTENT_TYPE']   = 'application/x-www-form-urlencoded';
    1604. 

  1604. 		$env['CONTENT_LENGTH'] = $content_length;
    1605. 

  1605. 

  1606. 		$cmd = &quot;$php $pass_options $ini_settings -f \&quot;$test_file\&quot; 2&gt;&amp;1 &lt; $tmp_post&quot;;
    1607. 

  1607. 

  1608. 	} else {
    1609. 

  1609. 

  1610. 		$env['REQUEST_METHOD'] = 'GET';
    1611. 

  1611. 		$env['CONTENT_TYPE']   = '';
    1612. 

  1612. 		$env['CONTENT_LENGTH'] = '';
    1613. 

  1613. 

  1614. 		$cmd = &quot;$php $pass_options $ini_settings -f \&quot;$test_file\&quot; $args 2&gt;&amp;1&quot;;
    1615. 

  1615. 	}
    1616. 

  1616. 

  1617. 	if ($leak_check) {
    1618. 

  1618. 		$env['USE_ZEND_ALLOC'] = '0';
    1619. 

  1619. 

  1620. 		if ($valgrind_version &gt;= 330) {
    1621. 

  1621. 			/* valgrind 3.3.0+ doesn't have --log-file-exactly option */
    1622. 

  1622. 			$cmd = &quot;valgrind -q --tool=memcheck --trace-children=yes --log-file=$memcheck_filename $cmd&quot;;
    1623. 

  1623. 		} else {
    1624. 

  1624. 			$cmd = &quot;valgrind -q --tool=memcheck --trace-children=yes --log-file-exactly=$memcheck_filename $cmd&quot;;
    1625. 

  1625. 		}
    1626. 

  1626. 

  1627. 	} else {
    1628. 

  1628. 		$env['USE_ZEND_ALLOC'] = '1';
    1629. 

  1629. 	}
    1630. 

  1630. 

  1631. 	if ($DETAILED) echo &quot;
    1632. 

  1632. CONTENT_LENGTH  = &quot; . $env['CONTENT_LENGTH'] . &quot;
    1633. 

  1633. CONTENT_TYPE    = &quot; . $env['CONTENT_TYPE'] . &quot;
    1634. 

  1634. PATH_TRANSLATED = &quot; . $env['PATH_TRANSLATED'] . &quot;
    1635. 

  1635. QUERY_STRING    = &quot; . $env['QUERY_STRING'] . &quot;
    1636. 

  1636. REDIRECT_STATUS = &quot; . $env['REDIRECT_STATUS'] . &quot;
    1637. 

  1637. REQUEST_METHOD  = &quot; . $env['REQUEST_METHOD'] . &quot;
    1638. 

  1638. SCRIPT_FILENAME = &quot; . $env['SCRIPT_FILENAME'] . &quot;
    1639. 

  1639. HTTP_COOKIE     = &quot; . $env['HTTP_COOKIE'] . &quot;
    1640. 

  1640. COMMAND $cmd
    1641. 

  1641. &quot;;
    1642. 

  1642. 

  1643. 	$out = system_with_timeout($cmd, $env, isset($section_text['STDIN']) ?…
    1644.

Large files files are truncated, but you can click here to view the full file