Thijs/wiki.techinc.nl
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Split up testHelpers.inc, break off fuzz testing

Browse source 
* Split up testHelpers.inc into one class per file, with the file named
  after the class per the usual convention. Put them in tests/parser
  since they are all parser-related, even though a couple are reused by
  other unit tests.
* Also rename parserTest.inc and parserTestsParserHook.php to follow the
  usual convention, and split off ParserTestResultNormalizer
* Move fuzz testing out to its own maintenance script. It's really not
  helpful to have fuzz testing, which is designed to run forever,
  exposed as a PHPUnit test.
* Increased fuzz test memory limit, and increased the memory headroom for
  getMemoryBreakdown(), since HHVM's ReflectionClass has an internal
  cache which uses quite a lot of memory.
* Temporarily switched a couple of ParserTest methods from private to
  public to support fuzz testing from a separate class -- I plan on
  replacing this interface in a subsequent commit.

Change-Id: Ib1a07e109ec1005bff2751b78eb4de35f2dfc472
This commit is contained in:
Tim Starling 2016-08-30 08:27:54 +10:00
parent 5445611062
commit a387fee397
17 changed files with 1368 additions and 1301 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

30
tests/TestsAutoLoader.php
View file

@ -26,18 +26,6 @@ $testDir = __DIR__;
$wgAutoloadClasses += [
# tests
'DbTestPreviewer' => "$testDir/testHelpers.inc",
'DbTestRecorder' => "$testDir/testHelpers.inc",
'DelayedParserTest' => "$testDir/testHelpers.inc",
'ParserTestResult' => "$testDir/parser/ParserTestResult.php",
'TestFileIterator' => "$testDir/testHelpers.inc",
'TestFileDataProvider' => "$testDir/testHelpers.inc",
'TestRecorder' => "$testDir/testHelpers.inc",
'ITestRecorder' => "$testDir/testHelpers.inc",
'DjVuSupport' => "$testDir/testHelpers.inc",
'TidySupport' => "$testDir/testHelpers.inc",
# tests/phpunit
'MediaWikiTestCase' => "$testDir/phpunit/MediaWikiTestCase.php",
'MediaWikiPHPUnitTestListener' => "$testDir/phpunit/MediaWikiPHPUnitTestListener.php",
@ -142,11 +130,21 @@ $wgAutoloadClasses += [
'DummySessionProvider' => "$testDir/phpunit/mocks/session/DummySessionProvider.php",
# tests/parser
'NewParserTest' => "$testDir/phpunit/includes/parser/NewParserTest.php",
'DbTestPreviewer' => "$testDir/parser/DbTestPreviewer.php",
'DbTestRecorder' => "$testDir/parser/DbTestRecorder.php",
'DelayedParserTest' => "$testDir/parser/DelayedParserTest.php",
'DjVuSupport' => "$testDir/parser/DjVuSupport.php",
'ITestRecorder' => "$testDir/parser/ITestRecorder.php",
'MediaWikiParserTest' => "$testDir/phpunit/includes/parser/MediaWikiParserTest.php",
'ParserTest' => "$testDir/parser/parserTest.inc",
'ParserTestResultNormalizer' => "$testDir/parser/parserTest.inc",
'ParserTestParserHook' => "$testDir/parser/parserTestsParserHook.php",
'NewParserTest' => "$testDir/phpunit/includes/parser/NewParserTest.php",
'ParserTest' => "$testDir/parser/ParserTest.php",
'ParserTestParserHook' => "$testDir/parser/ParserTestParserHook.php",
'ParserTestResult' => "$testDir/parser/ParserTestResult.php",
'ParserTestResultNormalizer' => "$testDir/parser/ParserTestResultNormalizer.php",
'TestFileDataProvider' => "$testDir/parser/TestFileDataProvider.php",
'TestFileIterator' => "$testDir/parser/TestFileIterator.php",
'TestRecorder' => "$testDir/parser/TestRecorder.php",
'TidySupport' => "$testDir/parser/TidySupport.php",
# tests/phpunit/includes/site
'SiteTest' => "$testDir/phpunit/includes/site/SiteTest.php",

228
tests/parser/DbTestPreviewer.php Normal file
View file

@ -0,0 +1,228 @@
<?php
/**
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
* http://www.gnu.org/copyleft/gpl.html
*
* @file
* @ingroup Testing
*/
class DbTestPreviewer extends TestRecorder {
protected $lb; // /< Database load balancer
protected $db; // /< Database connection to the main DB
protected $curRun; // /< run ID number for the current run
protected $prevRun; // /< run ID number for the previous run, if any
protected $results; // /< Result array
/**
* This should be called before the table prefix is changed
* @param TestRecorder $parent
*/
function __construct( $parent ) {
parent::__construct( $parent );
$this->lb = wfGetLBFactory()->newMainLB();
// This connection will have the wiki's table prefix, not parsertest_
$this->db = $this->lb->getConnection( DB_MASTER );
}
/**
* Set up result recording; insert a record for the run with the date
* and all that fun stuff
*/
function start() {
parent::start();
if ( !$this->db->tableExists( 'testrun', __METHOD__ )
|| !$this->db->tableExists( 'testitem', __METHOD__ )
) {
print "WARNING> `testrun` table not found in database.\n";
$this->prevRun = false;
} else {
// We'll make comparisons against the previous run later...
$this->prevRun = $this->db->selectField( 'testrun', 'MAX(tr_id)' );
}
$this->results = [];
}
function getName( $test, $subtest ) {
if ( $subtest ) {
return "$test subtest #$subtest";
} else {
return $test;
}
}
function record( $test, $subtest, $result ) {
parent::record( $test, $subtest, $result );
$this->results[ $this->getName( $test, $subtest ) ] = $result;
}
function report() {
if ( $this->prevRun ) {
// f = fail, p = pass, n = nonexistent
// codes show before then after
$table = [
'fp' => 'previously failing test(s) now PASSING! :)',
'pn' => 'previously PASSING test(s) removed o_O',
'np' => 'new PASSING test(s) :)',
'pf' => 'previously passing test(s) now FAILING! :(',
'fn' => 'previously FAILING test(s) removed O_o',
'nf' => 'new FAILING test(s) :(',
'ff' => 'still FAILING test(s) :(',
];
$prevResults = [];
$res = $this->db->select( 'testitem', [ 'ti_name', 'ti_success' ],
[ 'ti_run' => $this->prevRun ], __METHOD__ );
foreach ( $res as $row ) {
if ( !$this->parent->regex
|| preg_match( "/{$this->parent->regex}/i", $row->ti_name )
) {
$prevResults[$row->ti_name] = $row->ti_success;
}
}
$combined = array_keys( $this->results + $prevResults );
# Determine breakdown by change type
$breakdown = [];
foreach ( $combined as $test ) {
if ( !isset( $prevResults[$test] ) ) {
$before = 'n';
} elseif ( $prevResults[$test] == 1 ) {
$before = 'p';
} else /* if ( $prevResults[$test] == 0 )*/ {
$before = 'f';
}
if ( !isset( $this->results[$test] ) ) {
$after = 'n';
} elseif ( $this->results[$test] == 1 ) {
$after = 'p';
} else /*if ( $this->results[$test] == 0 ) */ {
$after = 'f';
}
$code = $before . $after;
if ( isset( $table[$code] ) ) {
$breakdown[$code][$test] = $this->getTestStatusInfo( $test, $after );
}
}
# Write out results
foreach ( $table as $code => $label ) {
if ( !empty( $breakdown[$code] ) ) {
$count = count( $breakdown[$code] );
printf( "\n%4d %s\n", $count, $label );
foreach ( $breakdown[$code] as $differing_test_name => $statusInfo ) {
print " * $differing_test_name [$statusInfo]\n";
}
}
}
} else {
print "No previous test runs to compare against.\n";
}
print "\n";
parent::report();
}
/**
* Returns a string giving information about when a test last had a status change.
* Could help to track down when regressions were introduced, as distinct from tests
* which have never passed (which are more change requests than regressions).
* @param string $testname
* @param string $after
* @return string
*/
private function getTestStatusInfo( $testname, $after ) {
// If we're looking at a test that has just been removed, then say when it first appeared.
if ( $after == 'n' ) {
$changedRun = $this->db->selectField( 'testitem',
'MIN(ti_run)',
[ 'ti_name' => $testname ],
__METHOD__ );
$appear = $this->db->selectRow( 'testrun',
[ 'tr_date', 'tr_mw_version' ],
[ 'tr_id' => $changedRun ],
__METHOD__ );
return "First recorded appearance: "
. date( "d-M-Y H:i:s", strtotime( $appear->tr_date ) )
. ", " . $appear->tr_mw_version;
}
// Otherwise, this test has previous recorded results.
// See when this test last had a different result to what we're seeing now.
$conds = [
'ti_name' => $testname,
'ti_success' => ( $after == 'f' ? "1" : "0" ) ];
if ( $this->curRun ) {
$conds[] = "ti_run != " . $this->db->addQuotes( $this->curRun );
}
$changedRun = $this->db->selectField( 'testitem', 'MAX(ti_run)', $conds, __METHOD__ );
// If no record of ever having had a different result.
if ( is_null( $changedRun ) ) {
if ( $after == "f" ) {
return "Has never passed";
} else {
return "Has never failed";
}
}
// Otherwise, we're looking at a test whose status has changed.
// (i.e. it used to work, but now doesn't; or used to fail, but is now fixed.)
// In this situation, give as much info as we can as to when it changed status.
$pre = $this->db->selectRow( 'testrun',
[ 'tr_date', 'tr_mw_version' ],
[ 'tr_id' => $changedRun ],
__METHOD__ );
$post = $this->db->selectRow( 'testrun',
[ 'tr_date', 'tr_mw_version' ],
[ "tr_id > " . $this->db->addQuotes( $changedRun ) ],
__METHOD__,
[ "LIMIT" => 1, "ORDER BY" => 'tr_id' ]
);
if ( $post ) {
$postDate = date( "d-M-Y H:i:s", strtotime( $post->tr_date ) ) . ", {$post->tr_mw_version}";
} else {
$postDate = 'now';
}
return ( $after == "f" ? "Introduced" : "Fixed" ) . " between "
. date( "d-M-Y H:i:s", strtotime( $pre->tr_date ) ) . ", " . $pre->tr_mw_version
. " and $postDate";
}
/**
* Close the DB connection
*/
function end() {
$this->lb->closeAll();
parent::end();
}
}

84
tests/parser/DbTestRecorder.php Normal file
View file

@ -0,0 +1,84 @@
<?php
/**
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
* http://www.gnu.org/copyleft/gpl.html
*
* @file
* @ingroup Testing
*/
class DbTestRecorder extends DbTestPreviewer {
public $version;
/**
* Set up result recording; insert a record for the run with the date
* and all that fun stuff
*/
function start() {
$this->db->begin( __METHOD__ );
if ( !$this->db->tableExists( 'testrun' )
|| !$this->db->tableExists( 'testitem' )
) {
print "WARNING> `testrun` table not found in database. Trying to create table.\n";
$this->db->sourceFile( $this->db->patchPath( 'patch-testrun.sql' ) );
echo "OK, resuming.\n";
}
parent::start();
$this->db->insert( 'testrun',
[
'tr_date' => $this->db->timestamp(),
'tr_mw_version' => $this->version,
'tr_php_version' => PHP_VERSION,
'tr_db_version' => $this->db->getServerVersion(),
'tr_uname' => php_uname()
],
__METHOD__ );
if ( $this->db->getType() === 'postgres' ) {
$this->curRun = $this->db->currentSequenceValue( 'testrun_id_seq' );
} else {
$this->curRun = $this->db->insertId();
}
}
/**
* Record an individual test item's success or failure to the db
*
* @param string $test
* @param bool $result
*/
function record( $test, $subtest, $result ) {
parent::record( $test, $subtest, $result );
$this->db->insert( 'testitem',
[
'ti_run' => $this->curRun,
'ti_name' => $this->getName( $test, $subtest ),
'ti_success' => $result ? 1 : 0,
],
__METHOD__ );
}
/**
* Commit transaction and clean up for result recording
*/
function end() {
$this->db->commit( __METHOD__ );
parent::end();
}
}

116
tests/parser/DelayedParserTest.php Normal file
View file

@ -0,0 +1,116 @@
<?php
/**
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
* http://www.gnu.org/copyleft/gpl.html
*
* @file
* @ingroup Testing
*/
/**
* A class to delay execution of a parser test hooks.
*/
class DelayedParserTest {
/** Initialized on construction */
private $hooks;
private $fnHooks;
private $transparentHooks;
public function __construct() {
$this->reset();
}
/**
* Init/reset or forgot about the current delayed test.
* Call to this will erase any hooks function that were pending.
*/
public function reset() {
$this->hooks = [];
$this->fnHooks = [];
$this->transparentHooks = [];
}
/**
* Called whenever we actually want to run the hook.
* Should be the case if we found the parserTest is not disabled
* @param ParserTest|NewParserTest $parserTest
* @return bool
* @throws MWException
*/
public function unleash( &$parserTest ) {
if ( !( $parserTest instanceof ParserTest || $parserTest instanceof NewParserTest ) ) {
throw new MWException( __METHOD__ . " must be passed an instance of ParserTest or "
. "NewParserTest classes\n" );
}
# Trigger delayed hooks. Any failure will make us abort
foreach ( $this->hooks as $hook ) {
$ret = $parserTest->requireHook( $hook );
if ( !$ret ) {
return false;
}
}
# Trigger delayed function hooks. Any failure will make us abort
foreach ( $this->fnHooks as $fnHook ) {
$ret = $parserTest->requireFunctionHook( $fnHook );
if ( !$ret ) {
return false;
}
}
# Trigger delayed transparent hooks. Any failure will make us abort
foreach ( $this->transparentHooks as $hook ) {
$ret = $parserTest->requireTransparentHook( $hook );
if ( !$ret ) {
return false;
}
}
# Delayed execution was successful.
return true;
}
/**
* Similar to ParserTest object but does not run anything
* Use unleash() to really execute the hook
* @param string $hook
*/
public function requireHook( $hook ) {
$this->hooks[] = $hook;
}
/**
* Similar to ParserTest object but does not run anything
* Use unleash() to really execute the hook function
* @param string $fnHook
*/
public function requireFunctionHook( $fnHook ) {
$this->fnHooks[] = $fnHook;
}
/**
* Similar to ParserTest object but does not run anything
* Use unleash() to really execute the hook function
* @param string $hook
*/
public function requireTransparentHook( $hook ) {
$this->transparentHooks[] = $hook;
}
}

58
tests/parser/DjVuSupport.php Normal file
View file

@ -0,0 +1,58 @@
<?php
/**
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
* http://www.gnu.org/copyleft/gpl.html
*
* @file
* @ingroup Testing
*/
/**
* Initialize and detect the DjVu files support
*/
class DjVuSupport {
/**
* Initialises DjVu tools global with default values
*/
public function __construct() {
global $wgDjvuRenderer, $wgDjvuDump, $wgDjvuToXML, $wgFileExtensions, $wgDjvuTxt;
$wgDjvuRenderer = $wgDjvuRenderer ? $wgDjvuRenderer : '/usr/bin/ddjvu';
$wgDjvuDump = $wgDjvuDump ? $wgDjvuDump : '/usr/bin/djvudump';
$wgDjvuToXML = $wgDjvuToXML ? $wgDjvuToXML : '/usr/bin/djvutoxml';
$wgDjvuTxt = $wgDjvuTxt ? $wgDjvuTxt : '/usr/bin/djvutxt';
if ( !in_array( 'djvu', $wgFileExtensions ) ) {
$wgFileExtensions[] = 'djvu';
}
}
/**
* Returns true if the DjVu tools are usable
*
* @return bool
*/
public function isEnabled() {
global $wgDjvuRenderer, $wgDjvuDump, $wgDjvuToXML, $wgDjvuTxt;
return is_executable( $wgDjvuRenderer )
&& is_executable( $wgDjvuDump )
&& is_executable( $wgDjvuToXML )
&& is_executable( $wgDjvuTxt );
}
}

61
tests/parser/ITestRecorder.php Normal file
View file

@ -0,0 +1,61 @@
<?php
/**
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
* http://www.gnu.org/copyleft/gpl.html
*
* @file
* @ingroup Testing
*/
/**
* Interface to record parser test results.
*
* The ITestRecorder is a very simple interface to record the result of
* MediaWiki parser tests. One should call start() before running the
* full parser tests and end() once all the tests have been finished.
* After each test, you should use record() to keep track of your tests
* results. Finally, report() is used to generate a summary of your
* test run, one could dump it to the console for human consumption or
* register the result in a database for tracking purposes.
*
* @since 1.22
*/
interface ITestRecorder {
/**
* Called at beginning of the parser test run
*/
public function start();
/**
* Called after each test
* @param string $test
* @param integer $subtest
* @param bool $result
*/
public function record( $test, $subtest, $result );
/**
* Called before finishing the test run
*/
public function report();
/**
* Called at the end of the parser test run
*/
public function end();
}

228
tests/parser/parserTest.inc → tests/parser/ParserTest.php
View file

@ -80,9 +80,6 @@ class ParserTest {
*/
private $recorder;
private $maxFuzzTestLength = 300;
private $fuzzSeed = 0;
private $memoryLimit = 50;
private $uploadDir = null;
public $regex = "";
@ -161,10 +158,6 @@ class ParserTest {
$this->uploadDir = wfTempDir() . "/mwParser-" . mt_rand() . "-images";
}
if ( isset( $options['seed'] ) ) {
$this->fuzzSeed = intval( $options['seed'] ) - 1;
}
$this->runDisabled = isset( $options['run-disabled'] );
$this->runParsoid = isset( $options['run-parsoid'] );
@ -388,142 +381,6 @@ class ParserTest {
}
}
/**
* Run a fuzz test series
* Draw input from a set of test files
* @param array $filenames
*/
function fuzzTest( $filenames ) {
$GLOBALS['wgContLang'] = Language::factory( 'en' );
$dict = $this->getFuzzInput( $filenames );
$dictSize = strlen( $dict );
$logMaxLength = log( $this->maxFuzzTestLength );
$this->setupDatabase();
ini_set( 'memory_limit', $this->memoryLimit * 1048576 );
$numTotal = 0;
$numSuccess = 0;
$user = new User;
$opts = ParserOptions::newFromUser( $user );
$title = Title::makeTitle( NS_MAIN, 'Parser_test' );
while ( true ) {
// Generate test input
mt_srand( ++$this->fuzzSeed );
$totalLength = mt_rand( 1, $this->maxFuzzTestLength );
$input = '';
while ( strlen( $input ) < $totalLength ) {
$logHairLength = mt_rand( 0, 1000000 ) / 1000000 * $logMaxLength;
$hairLength = min( intval( exp( $logHairLength ) ), $dictSize );
$offset = mt_rand( 0, $dictSize - $hairLength );
$input .= substr( $dict, $offset, $hairLength );
}
$this->setupGlobals();
$parser = $this->getParser();
// Run the test
try {
$parser->parse( $input, $title, $opts );
$fail = false;
} catch ( Exception $exception ) {
$fail = true;
}
if ( $fail ) {
echo "Test failed with seed {$this->fuzzSeed}\n";
echo "Input:\n";
printf( "string(%d) \"%s\"\n\n", strlen( $input ), $input );
echo "$exception\n";
} else {
$numSuccess++;
}
$numTotal++;
$this->teardownGlobals();
$parser->__destruct();
if ( $numTotal % 100 == 0 ) {
$usage = intval( memory_get_usage( true ) / $this->memoryLimit / 1048576 * 100 );
echo "{$this->fuzzSeed}: $numSuccess/$numTotal (mem: $usage%)\n";
if ( $usage > 90 ) {
echo "Out of memory:\n";
$memStats = $this->getMemoryBreakdown();
foreach ( $memStats as $name => $usage ) {
echo "$name: $usage\n";
}
$this->abort();
}
}
}
}
/**
* Get an input dictionary from a set of parser test files
* @param array $filenames
* @return string
*/
function getFuzzInput( $filenames ) {
$dict = '';
foreach ( $filenames as $filename ) {
$contents = file_get_contents( $filename );
preg_match_all(
'/!!\s*(input|wikitext)\n(.*?)\n!!\s*(result|html|html\/\*|html\/php)/s',
$contents,
$matches
);
foreach ( $matches[1] as $match ) {
$dict .= $match . "\n";
}
}
return $dict;
}
/**
* Get a memory usage breakdown
* @return array
*/
function getMemoryBreakdown() {
$memStats = [];
foreach ( $GLOBALS as $name => $value ) {
$memStats['$' . $name] = strlen( serialize( $value ) );
}
$classes = get_declared_classes();
foreach ( $classes as $class ) {
$rc = new ReflectionClass( $class );
$props = $rc->getStaticProperties();
$memStats[$class] = strlen( serialize( $props ) );
$methods = $rc->getMethods();
foreach ( $methods as $method ) {
$memStats[$class] += strlen( serialize( $method->getStaticVariables() ) );
}
}
$functions = get_defined_functions();
foreach ( $functions['user'] as $function ) {
$rf = new ReflectionFunction( $function );
$memStats["$function()"] = strlen( serialize( $rf->getStaticVariables() ) );
}
asort( $memStats );
return $memStats;
}
function abort() {
$this->abort();
}
/**
* Run a series of tests listed in the given text files.
* Each test consists of a brief description, wikitext input,
@ -854,7 +711,7 @@ class ParserTest {
* @param string $config
* @return RequestContext
*/
private function setupGlobals( $opts = '', $config = '' ) {
public function setupGlobals( $opts = '', $config = '' ) {
# Find out values for some special options.
$lang =
self::getOptionValue( 'language', $opts, 'en' );
@ -1290,7 +1147,7 @@ class ParserTest {
* Restore default values and perform any necessary clean-up
* after each test runs.
*/
private function teardownGlobals() {
public function teardownGlobals() {
RepoGroup::destroySingleton();
FileBackendGroup::destroySingleton();
LockManagerGroup::destroySingletons();
@ -1732,84 +1589,3 @@ class ParserTest {
return true;
}
}
class ParserTestResultNormalizer {
protected $doc, $xpath, $invalid;
public static function normalize( $text, $funcs ) {
$norm = new self( $text );
if ( $norm->invalid ) {
return $text;
}
foreach ( $funcs as $func ) {
$norm->$func();
}
return $norm->serialize();
}
protected function __construct( $text ) {
$this->doc = new DOMDocument( '1.0', 'utf-8' );
// Note: parsing a supposedly XHTML document with an XML parser is not
// guaranteed to give accurate results. For example, it may introduce
// differences in the number of line breaks in <pre> tags.
MediaWiki\suppressWarnings();
if ( !$this->doc->loadXML( '<html><body>' . $text . '</body></html>' ) ) {
$this->invalid = true;
}
MediaWiki\restoreWarnings();
$this->xpath = new DOMXPath( $this->doc );
$this->body = $this->xpath->query( '//body' )->item( 0 );
}
protected function removeTbody() {
foreach ( $this->xpath->query( '//tbody' ) as $tbody ) {
while ( $tbody->firstChild ) {
$child = $tbody->firstChild;
$tbody->removeChild( $child );
$tbody->parentNode->insertBefore( $child, $tbody );
}
$tbody->parentNode->removeChild( $tbody );
}
}
/**
* The point of this function is to produce a normalized DOM in which
* Tidy's output matches the output of html5depurate. Tidy both trims
* and pretty-prints, so this requires fairly aggressive treatment.
*
* In particular, note that Tidy converts <pre>x</pre> to <pre>\nx\n</pre>,
* which theoretically affects display since the second line break is not
* ignored by compliant HTML parsers.
*
* This function also removes empty elements, as does Tidy.
*/
protected function trimWhitespace() {
foreach ( $this->xpath->query( '//text()' ) as $child ) {
if ( strtolower( $child->parentNode->nodeName ) === 'pre' ) {
// Just trim one line break from the start and end
if ( substr_compare( $child->data, "\n", 0 ) === 0 ) {
$child->data = substr( $child->data, 1 );
}
if ( substr_compare( $child->data, "\n", -1 ) === 0 ) {
$child->data = substr( $child->data, 0, -1 );
}
} else {
// Trim all whitespace
$child->data = trim( $child->data );
}
if ( $child->data === '' ) {
$child->parentNode->removeChild( $child );
}
}
}
/**
* Serialize the XML DOM for comparison purposes. This does not generate HTML.
*/
protected function serialize() {
return strtr( $this->doc->saveXML( $this->body ),
[ '<body>' => '', '</body>' => '' ] );
}
}

0
tests/parser/parserTestsParserHook.php → tests/parser/ParserTestParserHook.php
View file

87
tests/parser/ParserTestResultNormalizer.php Normal file
View file

@ -0,0 +1,87 @@
<?php
/**
* @file
* @ingroup Testing
*/
class ParserTestResultNormalizer {
protected $doc, $xpath, $invalid;
public static function normalize( $text, $funcs ) {
$norm = new self( $text );
if ( $norm->invalid ) {
return $text;
}
foreach ( $funcs as $func ) {
$norm->$func();
}
return $norm->serialize();
}
protected function __construct( $text ) {
$this->doc = new DOMDocument( '1.0', 'utf-8' );
// Note: parsing a supposedly XHTML document with an XML parser is not
// guaranteed to give accurate results. For example, it may introduce
// differences in the number of line breaks in <pre> tags.
MediaWiki\suppressWarnings();
if ( !$this->doc->loadXML( '<html><body>' . $text . '</body></html>' ) ) {
$this->invalid = true;
}
MediaWiki\restoreWarnings();
$this->xpath = new DOMXPath( $this->doc );
$this->body = $this->xpath->query( '//body' )->item( 0 );
}
protected function removeTbody() {
foreach ( $this->xpath->query( '//tbody' ) as $tbody ) {
while ( $tbody->firstChild ) {
$child = $tbody->firstChild;
$tbody->removeChild( $child );
$tbody->parentNode->insertBefore( $child, $tbody );
}
$tbody->parentNode->removeChild( $tbody );
}
}
/**
* The point of this function is to produce a normalized DOM in which
* Tidy's output matches the output of html5depurate. Tidy both trims
* and pretty-prints, so this requires fairly aggressive treatment.
*
* In particular, note that Tidy converts <pre>x</pre> to <pre>\nx\n</pre>,
* which theoretically affects display since the second line break is not
* ignored by compliant HTML parsers.
*
* This function also removes empty elements, as does Tidy.
*/
protected function trimWhitespace() {
foreach ( $this->xpath->query( '//text()' ) as $child ) {
if ( strtolower( $child->parentNode->nodeName ) === 'pre' ) {
// Just trim one line break from the start and end
if ( substr_compare( $child->data, "\n", 0 ) === 0 ) {
$child->data = substr( $child->data, 1 );
}
if ( substr_compare( $child->data, "\n", -1 ) === 0 ) {
$child->data = substr( $child->data, 0, -1 );
}
} else {
// Trim all whitespace
$child->data = trim( $child->data );
}
if ( $child->data === '' ) {
$child->parentNode->removeChild( $child );
}
}
}
/**
* Serialize the XML DOM for comparison purposes. This does not generate HTML.
*/
protected function serialize() {
return strtr( $this->doc->saveXML( $this->body ),
[ '<body>' => '', '</body>' => '' ] );
}
}

42
tests/parser/TestFileDataProvider.php Normal file
View file

@ -0,0 +1,42 @@
<?php
/**
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
* http://www.gnu.org/copyleft/gpl.html
*
* @file
* @ingroup Testing
*/
/**
* An iterator for use as a phpunit data provider. Provides the test arguments
* in the order expected by NewParserTest::testParserTest().
*/
class TestFileDataProvider extends TestFileIterator {
function current() {
$test = parent::current();
if ( $test ) {
return [
$test['test'],
$test['input'],
$test['result'],
$test['options'],
$test['config'],
];
} else {
return $test;
}
}
}

324
tests/parser/TestFileIterator.php Normal file
View file

@ -0,0 +1,324 @@
<?php
/**
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
* http://www.gnu.org/copyleft/gpl.html
*
* @file
* @ingroup Testing
*/
class TestFileIterator implements Iterator {
private $file;
private $fh;
/**
* @var ParserTest|MediaWikiParserTest An instance of ParserTest (parserTests.php)
* or MediaWikiParserTest (phpunit)
*/
private $parserTest;
private $index = 0;
private $test;
private $section = null;
/** String|null: current test section being analyzed */
private $sectionData = [];
private $lineNum;
private $eof;
# Create a fake parser tests which never run anything unless
# asked to do so. This will avoid running hooks for a disabled test
private $delayedParserTest;
private $nextSubTest = 0;
function __construct( $file, $parserTest ) {
$this->file = $file;
$this->fh = fopen( $this->file, "rt" );
if ( !$this->fh ) {
throw new MWException( "Couldn't open file '$file'\n" );
}
$this->parserTest = $parserTest;
$this->delayedParserTest = new DelayedParserTest();
$this->lineNum = $this->index = 0;
}
function rewind() {
if ( fseek( $this->fh, 0 ) ) {
throw new MWException( "Couldn't fseek to the start of '$this->file'\n" );
}
$this->index = -1;
$this->lineNum = 0;
$this->eof = false;
$this->next();
return true;
}
function current() {
return $this->test;
}
function key() {
return $this->index;
}
function next() {
if ( $this->readNextTest() ) {
$this->index++;
return true;
} else {
$this->eof = true;
}
}
function valid() {
return $this->eof != true;
}
function setupCurrentTest() {
// "input" and "result" are old section names allowed
// for backwards-compatibility.
$input = $this->checkSection( [ 'wikitext', 'input' ], false );
$result = $this->checkSection( [ 'html/php', 'html/*', 'html', 'result' ], false );
// some tests have "with tidy" and "without tidy" variants
$tidy = $this->checkSection( [ 'html/php+tidy', 'html+tidy' ], false );
if ( $tidy != false ) {
if ( $this->nextSubTest == 0 ) {
if ( $result != false ) {
$this->nextSubTest = 1; // rerun non-tidy variant later
}
$result = $tidy;
} else {
$this->nextSubTest = 0; // go on to next test after this
$tidy = false;
}
}
if ( !isset( $this->sectionData['options'] ) ) {
$this->sectionData['options'] = '';
}
if ( !isset( $this->sectionData['config'] ) ) {
$this->sectionData['config'] = '';
}
$isDisabled = preg_match( '/\\bdisabled\\b/i', $this->sectionData['options'] ) &&
!$this->parserTest->runDisabled;
$isParsoidOnly = preg_match( '/\\bparsoid\\b/i', $this->sectionData['options'] ) &&
$result == 'html' &&
!$this->parserTest->runParsoid;
$isFiltered = !preg_match( "/" . $this->parserTest->regex . "/i", $this->sectionData['test'] );
if ( $input == false || $result == false || $isDisabled || $isParsoidOnly || $isFiltered ) {
# disabled test
return false;
}
# We are really going to run the test, run pending hooks and hooks function
wfDebug( __METHOD__ . " unleashing delayed test for: {$this->sectionData['test']}" );
$hooksResult = $this->delayedParserTest->unleash( $this->parserTest );
if ( !$hooksResult ) {
# Some hook reported an issue. Abort.
throw new MWException( "Problem running requested parser hook from the test file" );
}
$this->test = [
'test' => ParserTest::chomp( $this->sectionData['test'] ),
'subtest' => $this->nextSubTest,
'input' => ParserTest::chomp( $this->sectionData[$input] ),
'result' => ParserTest::chomp( $this->sectionData[$result] ),
'options' => ParserTest::chomp( $this->sectionData['options'] ),
'config' => ParserTest::chomp( $this->sectionData['config'] ),
];
if ( $tidy != false ) {
$this->test['options'] .= " tidy";
}
return true;
}
function readNextTest() {
# Run additional subtests of previous test
while ( $this->nextSubTest > 0 ) {
if ( $this->setupCurrentTest() ) {
return true;
}
}
$this->clearSection();
# Reset hooks for the delayed test object
$this->delayedParserTest->reset();
while ( false !== ( $line = fgets( $this->fh ) ) ) {
$this->lineNum++;
$matches = [];
if ( preg_match( '/^!!\s*(\S+)/', $line, $matches ) ) {
$this->section = strtolower( $matches[1] );
if ( $this->section == 'endarticle' ) {
$this->checkSection( 'text' );
$this->checkSection( 'article' );
$this->parserTest->addArticle(
ParserTest::chomp( $this->sectionData['article'] ),
$this->sectionData['text'], $this->lineNum );
$this->clearSection();
continue;
}
if ( $this->section == 'endhooks' ) {
$this->checkSection( 'hooks' );
foreach ( explode( "\n", $this->sectionData['hooks'] ) as $line ) {
$line = trim( $line );
if ( $line ) {
$this->delayedParserTest->requireHook( $line );
}
}
$this->clearSection();
continue;
}
if ( $this->section == 'endfunctionhooks' ) {
$this->checkSection( 'functionhooks' );
foreach ( explode( "\n", $this->sectionData['functionhooks'] ) as $line ) {
$line = trim( $line );
if ( $line ) {
$this->delayedParserTest->requireFunctionHook( $line );
}
}
$this->clearSection();
continue;
}
if ( $this->section == 'endtransparenthooks' ) {
$this->checkSection( 'transparenthooks' );
foreach ( explode( "\n", $this->sectionData['transparenthooks'] ) as $line ) {
$line = trim( $line );
if ( $line ) {
$this->delayedParserTest->requireTransparentHook( $line );
}
}
$this->clearSection();
continue;
}
if ( $this->section == 'end' ) {
$this->checkSection( 'test' );
do {
if ( $this->setupCurrentTest() ) {
return true;
}
} while ( $this->nextSubTest > 0 );
# go on to next test (since this was disabled)
$this->clearSection();
$this->delayedParserTest->reset();
continue;
}
if ( isset( $this->sectionData[$this->section] ) ) {
throw new MWException( "duplicate section '$this->section' "
. "at line {$this->lineNum} of $this->file\n" );
}
$this->sectionData[$this->section] = '';
continue;
}
if ( $this->section ) {
$this->sectionData[$this->section] .= $line;
}
}
return false;
}
/**
* Clear section name and its data
*/
private function clearSection() {
$this->sectionData = [];
$this->section = null;
}
/**
* Verify the current section data has some value for the given token
* name(s) (first parameter).
* Throw an exception if it is not set, referencing current section
* and adding the current file name and line number
*
* @param string|array $tokens Expected token(s) that should have been
* mentioned before closing this section
* @param bool $fatal True iff an exception should be thrown if
* the section is not found.
* @return bool|string
* @throws MWException
*/
private function checkSection( $tokens, $fatal = true ) {
if ( is_null( $this->section ) ) {
throw new MWException( __METHOD__ . " can not verify a null section!\n" );
}
if ( !is_array( $tokens ) ) {
$tokens = [ $tokens ];
}
if ( count( $tokens ) == 0 ) {
throw new MWException( __METHOD__ . " can not verify zero sections!\n" );
}
$data = $this->sectionData;
$tokens = array_filter( $tokens, function ( $token ) use ( $data ) {
return isset( $data[$token] );
} );
if ( count( $tokens ) == 0 ) {
if ( !$fatal ) {
return false;
}
throw new MWException( sprintf(
"'%s' without '%s' at line %s of %s\n",
$this->section,
implode( ',', $tokens ),
$this->lineNum,
$this->file
) );
}
if ( count( $tokens ) > 1 ) {
throw new MWException( sprintf(
"'%s' with unexpected tokens '%s' at line %s of %s\n",
$this->section,
implode( ',', $tokens ),
$this->lineNum,
$this->file
) );
}
return array_values( $tokens )[0];
}
}

69
tests/parser/TestRecorder.php Normal file
View file

@ -0,0 +1,69 @@
<?php
/**
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
* http://www.gnu.org/copyleft/gpl.html
*
* @file
* @ingroup Testing
*/
class TestRecorder implements ITestRecorder {
public $parent;
public $term;
function __construct( $parent ) {
$this->parent = $parent;
$this->term = $parent->term;
}
function start() {
$this->total = 0;
$this->success = 0;
}
function record( $test, $subtest, $result ) {
$this->total++;
$this->success += ( $result ? 1 : 0 );
}
function end() {
// dummy
}
function report() {
if ( $this->total > 0 ) {
$this->reportPercentage( $this->success, $this->total );
} else {
throw new MWException( "No tests found.\n" );
}
}
function reportPercentage( $success, $total ) {
$ratio = wfPercent( 100 * $success / $total );
print $this->term->color( 1 ) . "Passed $success of $total tests ($ratio)... ";
if ( $success == $total ) {
print $this->term->color( 32 ) . "ALL TESTS PASSED!";
} else {
$failed = $total - $success;
print $this->term->color( 31 ) . "$failed tests failed!";
}
print $this->term->reset() . "\n";
return ( $success == $total );
}
}

95
tests/parser/TidySupport.php Normal file
View file

@ -0,0 +1,95 @@
<?php
/**
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
* http://www.gnu.org/copyleft/gpl.html
*
* @file
* @ingroup Testing
*/
/**
* Initialize and detect the tidy support
*/
class TidySupport {
private $enabled;
private $config;
/**
* Determine if there is a usable tidy.
*/
public function __construct( $useConfiguration = false ) {
global $IP, $wgUseTidy, $wgTidyBin, $wgTidyInternal, $wgTidyConfig,
$wgTidyConf, $wgTidyOpts;
$this->enabled = true;
if ( $useConfiguration ) {
if ( $wgTidyConfig !== null ) {
$this->config = $wgTidyConfig;
} elseif ( $wgUseTidy ) {
$this->config = [
'tidyConfigFile' => $wgTidyConf,
'debugComment' => false,
'tidyBin' => $wgTidyBin,
'tidyCommandLine' => $wgTidyOpts
];
if ( $wgTidyInternal ) {
$this->config['driver'] = wfIsHHVM() ? 'RaggettInternalHHVM' : 'RaggettInternalPHP';
} else {
$this->config['driver'] = 'RaggettExternal';
}
} else {
$this->enabled = false;
}
} else {
$this->config = [
'tidyConfigFile' => "$IP/includes/tidy/tidy.conf",
'tidyCommandLine' => '',
];
if ( extension_loaded( 'tidy' ) && class_exists( 'tidy' ) ) {
$this->config['driver'] = wfIsHHVM() ? 'RaggettInternalHHVM' : 'RaggettInternalPHP';
} else {
if ( is_executable( $wgTidyBin ) ) {
$this->config['driver'] = 'RaggettExternal';
$this->config['tidyBin'] = $wgTidyBin;
} else {
$path = Installer::locateExecutableInDefaultPaths( $wgTidyBin );
if ( $path !== false ) {
$this->config['driver'] = 'RaggettExternal';
$this->config['tidyBin'] = $wgTidyBin;
} else {
$this->enabled = false;
}
}
}
}
if ( !$this->enabled ) {
$this->config = [ 'driver' => 'disabled' ];
}
}
/**
* Returns true if tidy is usable
*
* @return bool
*/
public function isEnabled() {
return $this->enabled;
}
public function getConfig() {
return $this->config;
}
}

186
tests/parser/fuzzTest.php Normal file
View file

@ -0,0 +1,186 @@
<?php
require __DIR__ . '/../../maintenance/Maintenance.php';
// Make RequestContext::resetMain() happy
define( 'MW_PARSER_TEST', 1 );
class ParserFuzzTest extends Maintenance {
private $parserTest;
private $maxFuzzTestLength = 300;
private $memoryLimit = 100;
private $seed;
function __construct() {
parent::__construct();
$this->addDescription( 'Run a fuzz test on the parser, until it segfaults ' .
'or throws an exception' );
$this->addOption( 'file', 'Use the specified file as a dictionary, ' .
' or leave blank to use parserTests.txt', false, true, true );
$this->addOption( 'seed', 'Start the fuzz test from the specified seed', false, true );
}
function finalSetup() {
require_once __DIR__ . '/../TestsAutoLoader.php';
}
function execute() {
$files = $this->getOption( 'file', [ __DIR__ . '/parserTests.txt' ] );
$this->seed = intval( $this->getOption( 'seed', 1 ) ) - 1;
$this->parserTest = new ParserTest;
$this->fuzzTest( $files );
}
/**
* Run a fuzz test series
* Draw input from a set of test files
* @param array $filenames
*/
function fuzzTest( $filenames ) {
$GLOBALS['wgContLang'] = Language::factory( 'en' );
$dict = $this->getFuzzInput( $filenames );
$dictSize = strlen( $dict );
$logMaxLength = log( $this->maxFuzzTestLength );
$this->parserTest->setupDatabase();
ini_set( 'memory_limit', $this->memoryLimit * 1048576 * 2 );
$numTotal = 0;
$numSuccess = 0;
$user = new User;
$opts = ParserOptions::newFromUser( $user );
$title = Title::makeTitle( NS_MAIN, 'Parser_test' );
while ( true ) {
// Generate test input
mt_srand( ++$this->seed );
$totalLength = mt_rand( 1, $this->maxFuzzTestLength );
$input = '';
while ( strlen( $input ) < $totalLength ) {
$logHairLength = mt_rand( 0, 1000000 ) / 1000000 * $logMaxLength;
$hairLength = min( intval( exp( $logHairLength ) ), $dictSize );
$offset = mt_rand( 0, $dictSize - $hairLength );
$input .= substr( $dict, $offset, $hairLength );
}
$this->parserTest->setupGlobals();
$parser = $this->parserTest->getParser();
// Run the test
try {
$parser->parse( $input, $title, $opts );
$fail = false;
} catch ( Exception $exception ) {
$fail = true;
}
if ( $fail ) {
echo "Test failed with seed {$this->seed}\n";
echo "Input:\n";
printf( "string(%d) \"%s\"\n\n", strlen( $input ), $input );
echo "$exception\n";
} else {
$numSuccess++;
}
$numTotal++;
$this->parserTest->teardownGlobals();
$parser->__destruct();
if ( $numTotal % 100 == 0 ) {
$usage = intval( memory_get_usage( true ) / $this->memoryLimit / 1048576 * 100 );
echo "{$this->seed}: $numSuccess/$numTotal (mem: $usage%)\n";
if ( $usage >= 100 ) {
echo "Out of memory:\n";
$memStats = $this->getMemoryBreakdown();
foreach ( $memStats as $name => $usage ) {
echo "$name: $usage\n";
}
if ( function_exists( 'hphpd_break' ) ) {
hphpd_break();
}
return;
}
}
}
}
/**
* Get a memory usage breakdown
* @return array
*/
function getMemoryBreakdown() {
$memStats = [];
foreach ( $GLOBALS as $name => $value ) {
$memStats['$' . $name] = $this->guessVarSize( $value );
}
$classes = get_declared_classes();
foreach ( $classes as $class ) {
$rc = new ReflectionClass( $class );
$props = $rc->getStaticProperties();
$memStats[$class] = $this->guessVarSize( $props );
$methods = $rc->getMethods();
foreach ( $methods as $method ) {
$memStats[$class] += $this->guessVarSize( $method->getStaticVariables() );
}
}
$functions = get_defined_functions();
foreach ( $functions['user'] as $function ) {
$rf = new ReflectionFunction( $function );
$memStats["$function()"] = $this->guessVarSize( $rf->getStaticVariables() );
}
asort( $memStats );
return $memStats;
}
/**
* Estimate the size of the input variable
*/
function guessVarSize( $var ) {
$length = 0;
try {
MediaWiki\suppressWarnings();
$length = strlen( serialize( $var ) );
MediaWiki\restoreWarnings();
} catch ( Exception $e ) {
}
return $length;
}
/**
* Get an input dictionary from a set of parser test files
* @param array $filenames
* @return string
*/
function getFuzzInput( $filenames ) {
$dict = '';
foreach ( $filenames as $filename ) {
$contents = file_get_contents( $filename );
preg_match_all(
'/!!\s*(input|wikitext)\n(.*?)\n!!\s*(result|html|html\/\*|html\/php)/s',
$contents,
$matches
);
foreach ( $matches[1] as $match ) {
$dict .= $match . "\n";
}
}
return $dict;
}
}
$maintClass = 'ParserFuzzTest';
require RUN_MAINTENANCE_IF_MAIN;

10
tests/parserTests.php
View file

@ -52,8 +52,6 @@ Options:
--setversion When using --record, set the version string to use (useful
with git-svn so that you can get the exact revision)
--keep-uploads Re-use the same upload directory for each test, don't delete it
--fuzz Do a fuzz test instead of a normal test
--seed <n> Start the fuzz test from the specified seed
--run-disabled run disabled tests
--run-parsoid run parsoid tests (normally disabled)
--dwdiff Use dwdiff to display diff output
@ -94,9 +92,5 @@ if ( isset( $options['file'] ) ) {
$version = SpecialVersion::getVersion( 'nodb' );
echo "This is MediaWiki version {$version}.\n\n";
if ( isset( $options['fuzz'] ) ) {
$tester->fuzzTest( $files );
} else {
$ok = $tester->runTestsFromFiles( $files );
exit( $ok ? 0 : 1 );
}
$ok = $tester->runTestsFromFiles( $files );
exit( $ok ? 0 : 1 );

143
tests/phpunit/includes/parser/NewParserTest.php
View file

@ -29,11 +29,6 @@ class NewParserTest extends MediaWikiTestCase {
public $functionHooks = [];
public $transparentHooks = [];
// Fuzz test
public $maxFuzzTestLength = 300;
public $fuzzSeed = 0;
public $memoryLimit = 50;
/**
* @var DjVuSupport
*/
@ -837,144 +832,6 @@ class NewParserTest extends MediaWikiTestCase {
$this->assertEquals( $result, $out, $desc );
}
/**
* Run a fuzz test series
* Draw input from a set of test files
*
* @todo fixme Needs some work to not eat memory until the world explodes
*
* @group ParserFuzz
*/
public function testFuzzTests() {
global $wgParserTestFiles;
$files = $wgParserTestFiles;
if ( $this->getCliArg( 'file' ) ) {
$files = [ $this->getCliArg( 'file' ) ];
}
$dict = $this->getFuzzInput( $files );
$dictSize = strlen( $dict );
$logMaxLength = log( $this->maxFuzzTestLength );
ini_set( 'memory_limit', $this->memoryLimit * 1048576 );
$user = new User;
$opts = ParserOptions::newFromUser( $user );
$title = Title::makeTitle( NS_MAIN, 'Parser_test' );
$id = 1;
while ( true ) {
// Generate test input
mt_srand( ++$this->fuzzSeed );
$totalLength = mt_rand( 1, $this->maxFuzzTestLength );
$input = '';
while ( strlen( $input ) < $totalLength ) {
$logHairLength = mt_rand( 0, 1000000 ) / 1000000 * $logMaxLength;
$hairLength = min( intval( exp( $logHairLength ) ), $dictSize );
$offset = mt_rand( 0, $dictSize - $hairLength );
$input .= substr( $dict, $offset, $hairLength );
}
$this->setupGlobals();
$parser = $this->getParser();
// Run the test
try {
$parser->parse( $input, $title, $opts );
$this->assertTrue( true, "Test $id, fuzz seed {$this->fuzzSeed}" );
} catch ( Exception $exception ) {
$input_dump = sprintf( "string(%d) \"%s\"\n", strlen( $input ), $input );
$this->assertTrue( false, "Test $id, fuzz seed {$this->fuzzSeed}. \n\n" .
"Input: $input_dump\n\nError: {$exception->getMessage()}\n\n" .
"Backtrace: {$exception->getTraceAsString()}" );
}
$this->teardownGlobals();
$parser->__destruct();
if ( $id % 100 == 0 ) {
$usage = intval( memory_get_usage( true ) / $this->memoryLimit / 1048576 * 100 );
// echo "{$this->fuzzSeed}: $numSuccess/$numTotal (mem: $usage%)\n";
if ( $usage > 90 ) {
$ret = "Out of memory:\n";
$memStats = $this->getMemoryBreakdown();
foreach ( $memStats as $name => $usage ) {
$ret .= "$name: $usage\n";
}
throw new MWException( $ret );
}
}
$id++;
}
}
// Various getter functions
/**
* Get an input dictionary from a set of parser test files
* @param array $filenames
* @return string
*/
function getFuzzInput( $filenames ) {
$dict = '';
foreach ( $filenames as $filename ) {
$contents = file_get_contents( $filename );
preg_match_all( '/!!\s*input\n(.*?)\n!!\s*result/s', $contents, $matches );
foreach ( $matches[1] as $match ) {
$dict .= $match . "\n";
}
}
return $dict;
}
/**
* Get a memory usage breakdown
* @return array
*/
function getMemoryBreakdown() {
$memStats = [];
foreach ( $GLOBALS as $name => $value ) {
$memStats['$' . $name] = strlen( serialize( $value ) );
}
$classes = get_declared_classes();
foreach ( $classes as $class ) {
$rc = new ReflectionClass( $class );
$props = $rc->getStaticProperties();
$memStats[$class] = strlen( serialize( $props ) );
$methods = $rc->getMethods();
foreach ( $methods as $method ) {
$memStats[$class] += strlen( serialize( $method->getStaticVariables() ) );
}
}
$functions = get_defined_functions();
foreach ( $functions['user'] as $function ) {
$rf = new ReflectionFunction( $function );
$memStats["$function()"] = strlen( serialize( $rf->getStaticVariables() ) );
}
asort( $memStats );
return $memStats;
}
/**
* Get a Parser object
* @param Preprocessor $preprocessor

908
tests/testHelpers.inc
View file

@ -1,908 +0,0 @@
<?php
/**
* Recording for passing/failing tests.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
* http://www.gnu.org/copyleft/gpl.html
*
* @file
* @ingroup Testing
*/
/**
* Interface to record parser test results.
*
* The ITestRecorder is a very simple interface to record the result of
* MediaWiki parser tests. One should call start() before running the
* full parser tests and end() once all the tests have been finished.
* After each test, you should use record() to keep track of your tests
* results. Finally, report() is used to generate a summary of your
* test run, one could dump it to the console for human consumption or
* register the result in a database for tracking purposes.
*
* @since 1.22
*/
interface ITestRecorder {
/**
* Called at beginning of the parser test run
*/
public function start();
/**
* Called after each test
* @param string $test
* @param integer $subtest
* @param bool $result
*/
public function record( $test, $subtest, $result );
/**
* Called before finishing the test run
*/
public function report();
/**
* Called at the end of the parser test run
*/
public function end();
}
class TestRecorder implements ITestRecorder {
public $parent;
public $term;
function __construct( $parent ) {
$this->parent = $parent;
$this->term = $parent->term;
}
function start() {
$this->total = 0;
$this->success = 0;
}
function record( $test, $subtest, $result ) {
$this->total++;
$this->success += ( $result ? 1 : 0 );
}
function end() {
// dummy
}
function report() {
if ( $this->total > 0 ) {
$this->reportPercentage( $this->success, $this->total );
} else {
throw new MWException( "No tests found.\n" );
}
}
function reportPercentage( $success, $total ) {
$ratio = wfPercent( 100 * $success / $total );
print $this->term->color( 1 ) . "Passed $success of $total tests ($ratio)... ";
if ( $success == $total ) {
print $this->term->color( 32 ) . "ALL TESTS PASSED!";
} else {
$failed = $total - $success;
print $this->term->color( 31 ) . "$failed tests failed!";
}
print $this->term->reset() . "\n";
return ( $success == $total );
}
}
class DbTestPreviewer extends TestRecorder {
protected $lb; // /< Database load balancer
protected $db; // /< Database connection to the main DB
protected $curRun; // /< run ID number for the current run
protected $prevRun; // /< run ID number for the previous run, if any
protected $results; // /< Result array
/**
* This should be called before the table prefix is changed
* @param TestRecorder $parent
*/
function __construct( $parent ) {
parent::__construct( $parent );
$this->lb = wfGetLBFactory()->newMainLB();
// This connection will have the wiki's table prefix, not parsertest_
$this->db = $this->lb->getConnection( DB_MASTER );
}
/**
* Set up result recording; insert a record for the run with the date
* and all that fun stuff
*/
function start() {
parent::start();
if ( !$this->db->tableExists( 'testrun', __METHOD__ )
|| !$this->db->tableExists( 'testitem', __METHOD__ )
) {
print "WARNING> `testrun` table not found in database.\n";
$this->prevRun = false;
} else {
// We'll make comparisons against the previous run later...
$this->prevRun = $this->db->selectField( 'testrun', 'MAX(tr_id)' );
}
$this->results = [];
}
function getName( $test, $subtest ) {
if ( $subtest ) {
return "$test subtest #$subtest";
} else {
return $test;
}
}
function record( $test, $subtest, $result ) {
parent::record( $test, $subtest, $result );
$this->results[ $this->getName( $test, $subtest ) ] = $result;
}
function report() {
if ( $this->prevRun ) {
// f = fail, p = pass, n = nonexistent
// codes show before then after
$table = [
'fp' => 'previously failing test(s) now PASSING! :)',
'pn' => 'previously PASSING test(s) removed o_O',
'np' => 'new PASSING test(s) :)',
'pf' => 'previously passing test(s) now FAILING! :(',
'fn' => 'previously FAILING test(s) removed O_o',
'nf' => 'new FAILING test(s) :(',
'ff' => 'still FAILING test(s) :(',
];
$prevResults = [];
$res = $this->db->select( 'testitem', [ 'ti_name', 'ti_success' ],
[ 'ti_run' => $this->prevRun ], __METHOD__ );
foreach ( $res as $row ) {
if ( !$this->parent->regex
|| preg_match( "/{$this->parent->regex}/i", $row->ti_name )
) {
$prevResults[$row->ti_name] = $row->ti_success;
}
}
$combined = array_keys( $this->results + $prevResults );
# Determine breakdown by change type
$breakdown = [];
foreach ( $combined as $test ) {
if ( !isset( $prevResults[$test] ) ) {
$before = 'n';
} elseif ( $prevResults[$test] == 1 ) {
$before = 'p';
} else /* if ( $prevResults[$test] == 0 )*/ {
$before = 'f';
}
if ( !isset( $this->results[$test] ) ) {
$after = 'n';
} elseif ( $this->results[$test] == 1 ) {
$after = 'p';
} else /*if ( $this->results[$test] == 0 ) */ {
$after = 'f';
}
$code = $before . $after;
if ( isset( $table[$code] ) ) {
$breakdown[$code][$test] = $this->getTestStatusInfo( $test, $after );
}
}
# Write out results
foreach ( $table as $code => $label ) {
if ( !empty( $breakdown[$code] ) ) {
$count = count( $breakdown[$code] );
printf( "\n%4d %s\n", $count, $label );
foreach ( $breakdown[$code] as $differing_test_name => $statusInfo ) {
print " * $differing_test_name [$statusInfo]\n";
}
}
}
} else {
print "No previous test runs to compare against.\n";
}
print "\n";
parent::report();
}
/**
* Returns a string giving information about when a test last had a status change.
* Could help to track down when regressions were introduced, as distinct from tests
* which have never passed (which are more change requests than regressions).
* @param string $testname
* @param string $after
* @return string
*/
private function getTestStatusInfo( $testname, $after ) {
// If we're looking at a test that has just been removed, then say when it first appeared.
if ( $after == 'n' ) {
$changedRun = $this->db->selectField( 'testitem',
'MIN(ti_run)',
[ 'ti_name' => $testname ],
__METHOD__ );
$appear = $this->db->selectRow( 'testrun',
[ 'tr_date', 'tr_mw_version' ],
[ 'tr_id' => $changedRun ],
__METHOD__ );
return "First recorded appearance: "
. date( "d-M-Y H:i:s", strtotime( $appear->tr_date ) )
. ", " . $appear->tr_mw_version;
}
// Otherwise, this test has previous recorded results.
// See when this test last had a different result to what we're seeing now.
$conds = [
'ti_name' => $testname,
'ti_success' => ( $after == 'f' ? "1" : "0" ) ];
if ( $this->curRun ) {
$conds[] = "ti_run != " . $this->db->addQuotes( $this->curRun );
}
$changedRun = $this->db->selectField( 'testitem', 'MAX(ti_run)', $conds, __METHOD__ );
// If no record of ever having had a different result.
if ( is_null( $changedRun ) ) {
if ( $after == "f" ) {
return "Has never passed";
} else {
return "Has never failed";
}
}
// Otherwise, we're looking at a test whose status has changed.
// (i.e. it used to work, but now doesn't; or used to fail, but is now fixed.)
// In this situation, give as much info as we can as to when it changed status.
$pre = $this->db->selectRow( 'testrun',
[ 'tr_date', 'tr_mw_version' ],
[ 'tr_id' => $changedRun ],
__METHOD__ );
$post = $this->db->selectRow( 'testrun',
[ 'tr_date', 'tr_mw_version' ],
[ "tr_id > " . $this->db->addQuotes( $changedRun ) ],
__METHOD__,
[ "LIMIT" => 1, "ORDER BY" => 'tr_id' ]
);
if ( $post ) {
$postDate = date( "d-M-Y H:i:s", strtotime( $post->tr_date ) ) . ", {$post->tr_mw_version}";
} else {
$postDate = 'now';
}
return ( $after == "f" ? "Introduced" : "Fixed" ) . " between "
. date( "d-M-Y H:i:s", strtotime( $pre->tr_date ) ) . ", " . $pre->tr_mw_version
. " and $postDate";
}
/**
* Close the DB connection
*/
function end() {
$this->lb->closeAll();
parent::end();
}
}
class DbTestRecorder extends DbTestPreviewer {
public $version;
/**
* Set up result recording; insert a record for the run with the date
* and all that fun stuff
*/
function start() {
$this->db->begin( __METHOD__ );
if ( !$this->db->tableExists( 'testrun' )
|| !$this->db->tableExists( 'testitem' )
) {
print "WARNING> `testrun` table not found in database. Trying to create table.\n";
$this->db->sourceFile( $this->db->patchPath( 'patch-testrun.sql' ) );
echo "OK, resuming.\n";
}
parent::start();
$this->db->insert( 'testrun',
[
'tr_date' => $this->db->timestamp(),
'tr_mw_version' => $this->version,
'tr_php_version' => PHP_VERSION,
'tr_db_version' => $this->db->getServerVersion(),
'tr_uname' => php_uname()
],
__METHOD__ );
if ( $this->db->getType() === 'postgres' ) {
$this->curRun = $this->db->currentSequenceValue( 'testrun_id_seq' );
} else {
$this->curRun = $this->db->insertId();
}
}
/**
* Record an individual test item's success or failure to the db
*
* @param string $test
* @param bool $result
*/
function record( $test, $subtest, $result ) {
parent::record( $test, $subtest, $result );
$this->db->insert( 'testitem',
[
'ti_run' => $this->curRun,
'ti_name' => $this->getName( $test, $subtest ),
'ti_success' => $result ? 1 : 0,
],
__METHOD__ );
}
/**
* Commit transaction and clean up for result recording
*/
function end() {
$this->db->commit( __METHOD__ );
parent::end();
}
}
class TestFileIterator implements Iterator {
private $file;
private $fh;
/**
* @var ParserTest|MediaWikiParserTest An instance of ParserTest (parserTests.php)
* or MediaWikiParserTest (phpunit)
*/
private $parserTest;
private $index = 0;
private $test;
private $section = null;
/** String|null: current test section being analyzed */
private $sectionData = [];
private $lineNum;
private $eof;
# Create a fake parser tests which never run anything unless
# asked to do so. This will avoid running hooks for a disabled test
private $delayedParserTest;
private $nextSubTest = 0;
function __construct( $file, $parserTest ) {
$this->file = $file;
$this->fh = fopen( $this->file, "rt" );
if ( !$this->fh ) {
throw new MWException( "Couldn't open file '$file'\n" );
}
$this->parserTest = $parserTest;
$this->delayedParserTest = new DelayedParserTest();
$this->lineNum = $this->index = 0;
}
function rewind() {
if ( fseek( $this->fh, 0 ) ) {
throw new MWException( "Couldn't fseek to the start of '$this->file'\n" );
}
$this->index = -1;
$this->lineNum = 0;
$this->eof = false;
$this->next();
return true;
}
function current() {
return $this->test;
}
function key() {
return $this->index;
}
function next() {
if ( $this->readNextTest() ) {
$this->index++;
return true;
} else {
$this->eof = true;
}
}
function valid() {
return $this->eof != true;
}
function setupCurrentTest() {
// "input" and "result" are old section names allowed
// for backwards-compatibility.
$input = $this->checkSection( [ 'wikitext', 'input' ], false );
$result = $this->checkSection( [ 'html/php', 'html/*', 'html', 'result' ], false );
// some tests have "with tidy" and "without tidy" variants
$tidy = $this->checkSection( [ 'html/php+tidy', 'html+tidy' ], false );
if ( $tidy != false ) {
if ( $this->nextSubTest == 0 ) {
if ( $result != false ) {
$this->nextSubTest = 1; // rerun non-tidy variant later
}
$result = $tidy;
} else {
$this->nextSubTest = 0; // go on to next test after this
$tidy = false;
}
}
if ( !isset( $this->sectionData['options'] ) ) {
$this->sectionData['options'] = '';
}
if ( !isset( $this->sectionData['config'] ) ) {
$this->sectionData['config'] = '';
}
$isDisabled = preg_match( '/\\bdisabled\\b/i', $this->sectionData['options'] ) &&
!$this->parserTest->runDisabled;
$isParsoidOnly = preg_match( '/\\bparsoid\\b/i', $this->sectionData['options'] ) &&
$result == 'html' &&
!$this->parserTest->runParsoid;
$isFiltered = !preg_match( "/" . $this->parserTest->regex . "/i", $this->sectionData['test'] );
if ( $input == false || $result == false || $isDisabled || $isParsoidOnly || $isFiltered ) {
# disabled test
return false;
}
# We are really going to run the test, run pending hooks and hooks function
wfDebug( __METHOD__ . " unleashing delayed test for: {$this->sectionData['test']}" );
$hooksResult = $this->delayedParserTest->unleash( $this->parserTest );
if ( !$hooksResult ) {
# Some hook reported an issue. Abort.
throw new MWException( "Problem running requested parser hook from the test file" );
}
$this->test = [
'test' => ParserTest::chomp( $this->sectionData['test'] ),
'subtest' => $this->nextSubTest,
'input' => ParserTest::chomp( $this->sectionData[$input] ),
'result' => ParserTest::chomp( $this->sectionData[$result] ),
'options' => ParserTest::chomp( $this->sectionData['options'] ),
'config' => ParserTest::chomp( $this->sectionData['config'] ),
];
if ( $tidy != false ) {
$this->test['options'] .= " tidy";
}
return true;
}
function readNextTest() {
# Run additional subtests of previous test
while ( $this->nextSubTest > 0 ) {
if ( $this->setupCurrentTest() ) {
return true;
}
}
$this->clearSection();
# Reset hooks for the delayed test object
$this->delayedParserTest->reset();
while ( false !== ( $line = fgets( $this->fh ) ) ) {
$this->lineNum++;
$matches = [];
if ( preg_match( '/^!!\s*(\S+)/', $line, $matches ) ) {
$this->section = strtolower( $matches[1] );
if ( $this->section == 'endarticle' ) {
$this->checkSection( 'text' );
$this->checkSection( 'article' );
$this->parserTest->addArticle(
ParserTest::chomp( $this->sectionData['article'] ),
$this->sectionData['text'], $this->lineNum );
$this->clearSection();
continue;
}
if ( $this->section == 'endhooks' ) {
$this->checkSection( 'hooks' );
foreach ( explode( "\n", $this->sectionData['hooks'] ) as $line ) {
$line = trim( $line );
if ( $line ) {
$this->delayedParserTest->requireHook( $line );
}
}
$this->clearSection();
continue;
}
if ( $this->section == 'endfunctionhooks' ) {
$this->checkSection( 'functionhooks' );
foreach ( explode( "\n", $this->sectionData['functionhooks'] ) as $line ) {
$line = trim( $line );
if ( $line ) {
$this->delayedParserTest->requireFunctionHook( $line );
}
}
$this->clearSection();
continue;
}
if ( $this->section == 'endtransparenthooks' ) {
$this->checkSection( 'transparenthooks' );
foreach ( explode( "\n", $this->sectionData['transparenthooks'] ) as $line ) {
$line = trim( $line );
if ( $line ) {
$this->delayedParserTest->requireTransparentHook( $line );
}
}
$this->clearSection();
continue;
}
if ( $this->section == 'end' ) {
$this->checkSection( 'test' );
do {
if ( $this->setupCurrentTest() ) {
return true;
}
} while ( $this->nextSubTest > 0 );
# go on to next test (since this was disabled)
$this->clearSection();
$this->delayedParserTest->reset();
continue;
}
if ( isset( $this->sectionData[$this->section] ) ) {
throw new MWException( "duplicate section '$this->section' "
. "at line {$this->lineNum} of $this->file\n" );
}
$this->sectionData[$this->section] = '';
continue;
}
if ( $this->section ) {
$this->sectionData[$this->section] .= $line;
}
}
return false;
}
/**
* Clear section name and its data
*/
private function clearSection() {
$this->sectionData = [];
$this->section = null;
}
/**
* Verify the current section data has some value for the given token
* name(s) (first parameter).
* Throw an exception if it is not set, referencing current section
* and adding the current file name and line number
*
* @param string|array $tokens Expected token(s) that should have been
* mentioned before closing this section
* @param bool $fatal True iff an exception should be thrown if
* the section is not found.
* @return bool|string
* @throws MWException
*/
private function checkSection( $tokens, $fatal = true ) {
if ( is_null( $this->section ) ) {
throw new MWException( __METHOD__ . " can not verify a null section!\n" );
}
if ( !is_array( $tokens ) ) {
$tokens = [ $tokens ];
}
if ( count( $tokens ) == 0 ) {
throw new MWException( __METHOD__ . " can not verify zero sections!\n" );
}
$data = $this->sectionData;
$tokens = array_filter( $tokens, function ( $token ) use ( $data ) {
return isset( $data[$token] );
} );
if ( count( $tokens ) == 0 ) {
if ( !$fatal ) {
return false;
}
throw new MWException( sprintf(
"'%s' without '%s' at line %s of %s\n",
$this->section,
implode( ',', $tokens ),
$this->lineNum,
$this->file
) );
}
if ( count( $tokens ) > 1 ) {
throw new MWException( sprintf(
"'%s' with unexpected tokens '%s' at line %s of %s\n",
$this->section,
implode( ',', $tokens ),
$this->lineNum,
$this->file
) );
}
return array_values( $tokens )[0];
}
}
/**
* An iterator for use as a phpunit data provider. Provides the test arguments
* in the order expected by NewParserTest::testParserTest().
*/
class TestFileDataProvider extends TestFileIterator {
function current() {
$test = parent::current();
if ( $test ) {
return [
$test['test'],
$test['input'],
$test['result'],
$test['options'],
$test['config'],
];
} else {
return $test;
}
}
}
/**
* A class to delay execution of a parser test hooks.
*/
class DelayedParserTest {
/** Initialized on construction */
private $hooks;
private $fnHooks;
private $transparentHooks;
public function __construct() {
$this->reset();
}
/**
* Init/reset or forgot about the current delayed test.
* Call to this will erase any hooks function that were pending.
*/
public function reset() {
$this->hooks = [];
$this->fnHooks = [];
$this->transparentHooks = [];
}
/**
* Called whenever we actually want to run the hook.
* Should be the case if we found the parserTest is not disabled
* @param ParserTest|NewParserTest $parserTest
* @return bool
* @throws MWException
*/
public function unleash( &$parserTest ) {
if ( !( $parserTest instanceof ParserTest || $parserTest instanceof NewParserTest ) ) {
throw new MWException( __METHOD__ . " must be passed an instance of ParserTest or "
. "NewParserTest classes\n" );
}
# Trigger delayed hooks. Any failure will make us abort
foreach ( $this->hooks as $hook ) {
$ret = $parserTest->requireHook( $hook );
if ( !$ret ) {
return false;
}
}
# Trigger delayed function hooks. Any failure will make us abort
foreach ( $this->fnHooks as $fnHook ) {
$ret = $parserTest->requireFunctionHook( $fnHook );
if ( !$ret ) {
return false;
}
}
# Trigger delayed transparent hooks. Any failure will make us abort
foreach ( $this->transparentHooks as $hook ) {
$ret = $parserTest->requireTransparentHook( $hook );
if ( !$ret ) {
return false;
}
}
# Delayed execution was successful.
return true;
}
/**
* Similar to ParserTest object but does not run anything
* Use unleash() to really execute the hook
* @param string $hook
*/
public function requireHook( $hook ) {
$this->hooks[] = $hook;
}
/**
* Similar to ParserTest object but does not run anything
* Use unleash() to really execute the hook function
* @param string $fnHook
*/
public function requireFunctionHook( $fnHook ) {
$this->fnHooks[] = $fnHook;
}
/**
* Similar to ParserTest object but does not run anything
* Use unleash() to really execute the hook function
* @param string $hook
*/
public function requireTransparentHook( $hook ) {
$this->transparentHooks[] = $hook;
}
}
/**
* Initialize and detect the DjVu files support
*/
class DjVuSupport {
/**
* Initialises DjVu tools global with default values
*/
public function __construct() {
global $wgDjvuRenderer, $wgDjvuDump, $wgDjvuToXML, $wgFileExtensions, $wgDjvuTxt;
$wgDjvuRenderer = $wgDjvuRenderer ? $wgDjvuRenderer : '/usr/bin/ddjvu';
$wgDjvuDump = $wgDjvuDump ? $wgDjvuDump : '/usr/bin/djvudump';
$wgDjvuToXML = $wgDjvuToXML ? $wgDjvuToXML : '/usr/bin/djvutoxml';
$wgDjvuTxt = $wgDjvuTxt ? $wgDjvuTxt : '/usr/bin/djvutxt';
if ( !in_array( 'djvu', $wgFileExtensions ) ) {
$wgFileExtensions[] = 'djvu';
}
}
/**
* Returns true if the DjVu tools are usable
*
* @return bool
*/
public function isEnabled() {
global $wgDjvuRenderer, $wgDjvuDump, $wgDjvuToXML, $wgDjvuTxt;
return is_executable( $wgDjvuRenderer )
&& is_executable( $wgDjvuDump )
&& is_executable( $wgDjvuToXML )
&& is_executable( $wgDjvuTxt );
}
}
/**
* Initialize and detect the tidy support
*/
class TidySupport {
private $enabled;
private $config;
/**
* Determine if there is a usable tidy.
*/
public function __construct( $useConfiguration = false ) {
global $IP, $wgUseTidy, $wgTidyBin, $wgTidyInternal, $wgTidyConfig,
$wgTidyConf, $wgTidyOpts;
$this->enabled = true;
if ( $useConfiguration ) {
if ( $wgTidyConfig !== null ) {
$this->config = $wgTidyConfig;
} elseif ( $wgUseTidy ) {
$this->config = [
'tidyConfigFile' => $wgTidyConf,
'debugComment' => false,
'tidyBin' => $wgTidyBin,
'tidyCommandLine' => $wgTidyOpts
];
if ( $wgTidyInternal ) {
$this->config['driver'] = wfIsHHVM() ? 'RaggettInternalHHVM' : 'RaggettInternalPHP';
} else {
$this->config['driver'] = 'RaggettExternal';
}
} else {
$this->enabled = false;
}
} else {
$this->config = [
'tidyConfigFile' => "$IP/includes/tidy/tidy.conf",
'tidyCommandLine' => '',
];
if ( extension_loaded( 'tidy' ) && class_exists( 'tidy' ) ) {
$this->config['driver'] = wfIsHHVM() ? 'RaggettInternalHHVM' : 'RaggettInternalPHP';
} else {
if ( is_executable( $wgTidyBin ) ) {
$this->config['driver'] = 'RaggettExternal';
$this->config['tidyBin'] = $wgTidyBin;
} else {
$path = Installer::locateExecutableInDefaultPaths( $wgTidyBin );
if ( $path !== false ) {
$this->config['driver'] = 'RaggettExternal';
$this->config['tidyBin'] = $wgTidyBin;
} else {
$this->enabled = false;
}
}
}
}
if ( !$this->enabled ) {
$this->config = [ 'driver' => 'disabled' ];
}
}
/**
* Returns true if tidy is usable
*
* @return bool
*/
public function isEnabled() {
return $this->enabled;
}
public function getConfig() {
return $this->config;
}
}