Update to MediaWiki 1.24.2

15 files changed, 2031 insertions, 0 deletions

diff --git a/tests/phpunit/includes/GlobalFunctions/GlobalTest.php b/tests/phpunit/includes/GlobalFunctions/GlobalTest.php
new file mode 100644
index 00000000..3acc48e2
--- /dev/null
+++ b/tests/phpunit/includes/GlobalFunctions/GlobalTest.php
@@ -0,0 +1,745 @@
+<?php
+
+/**
+ * @group GlobalFunctions
+ */
+class GlobalTest extends MediaWikiTestCase {
+	protected function setUp() {
+		parent::setUp();
+
+		$readOnlyFile = tempnam( wfTempDir(), "mwtest_readonly" );
+		unlink( $readOnlyFile );
+
+		$this->setMwGlobals( array(
+			'wgReadOnlyFile' => $readOnlyFile,
+			'wgUrlProtocols' => array(
+				'http://',
+				'https://',
+				'mailto:',
+				'//',
+				'file://', # Non-default
+			),
+		) );
+	}
+
+	protected function tearDown() {
+		global $wgReadOnlyFile;
+
+		if ( file_exists( $wgReadOnlyFile ) ) {
+			unlink( $wgReadOnlyFile );
+		}
+
+		parent::tearDown();
+	}
+
+	/**
+	 * @dataProvider provideForWfArrayDiff2
+	 * @covers ::wfArrayDiff2
+	 */
+	public function testWfArrayDiff2( $a, $b, $expected ) {
+		$this->assertEquals(
+			wfArrayDiff2( $a, $b ), $expected
+		);
+	}
+
+	// @todo Provide more tests
+	public static function provideForWfArrayDiff2() {
+		// $a $b $expected
+		return array(
+			array(
+				array( 'a', 'b' ),
+				array( 'a', 'b' ),
+				array(),
+			),
+			array(
+				array( array( 'a' ), array( 'a', 'b', 'c' ) ),
+				array( array( 'a' ), array( 'a', 'b' ) ),
+				array( 1 => array( 'a', 'b', 'c' ) ),
+			),
+		);
+	}
+
+	/*
+	 * Test cases for random functions could hypothetically fail,
+	 * even though they shouldn't.
+	 */
+
+	/**
+	 * @covers ::wfRandom
+	 */
+	public function testRandom() {
+		$this->assertFalse(
+			wfRandom() == wfRandom()
+		);
+	}
+
+	/**
+	 * @covers ::wfRandomString
+	 */
+	public function testRandomString() {
+		$this->assertFalse(
+			wfRandomString() == wfRandomString()
+		);
+		$this->assertEquals(
+			strlen( wfRandomString( 10 ) ), 10
+		);
+		$this->assertTrue(
+			preg_match( '/^[0-9a-f]+$/i', wfRandomString() ) === 1
+		);
+	}
+
+	/**
+	 * @covers ::wfUrlencode
+	 */
+	public function testUrlencode() {
+		$this->assertEquals(
+			"%E7%89%B9%E5%88%A5:Contributions/Foobar",
+			wfUrlencode( "\xE7\x89\xB9\xE5\x88\xA5:Contributions/Foobar" ) );
+	}
+
+	/**
+	 * @covers ::wfExpandIRI
+	 */
+	public function testExpandIRI() {
+		$this->assertEquals(
+			"https://te.wikibooks.org/wiki/ఉబుంటు_వాడుకరి_మార్గదర్శని",
+			wfExpandIRI( "https://te.wikibooks.org/wiki/"
+				. "%E0%B0%89%E0%B0%AC%E0%B1%81%E0%B0%82%E0%B0%9F%E0%B1%81_"
+				. "%E0%B0%B5%E0%B0%BE%E0%B0%A1%E0%B1%81%E0%B0%95%E0%B0%B0%E0%B0%BF_"
+				. "%E0%B0%AE%E0%B0%BE%E0%B0%B0%E0%B1%8D%E0%B0%97%E0%B0%A6%E0%B0%B0"
+				. "%E0%B1%8D%E0%B0%B6%E0%B0%A8%E0%B0%BF" ) );
+	}
+
+	/**
+	 * @covers ::wfReadOnly
+	 */
+	public function testReadOnlyEmpty() {
+		global $wgReadOnly;
+		$wgReadOnly = null;
+
+		$this->assertFalse( wfReadOnly() );
+		$this->assertFalse( wfReadOnly() );
+	}
+
+	/**
+	 * @covers ::wfReadOnly
+	 */
+	public function testReadOnlySet() {
+		global $wgReadOnly, $wgReadOnlyFile;
+
+		$f = fopen( $wgReadOnlyFile, "wt" );
+		fwrite( $f, 'Message' );
+		fclose( $f );
+		$wgReadOnly = null; # Check on $wgReadOnlyFile
+
+		$this->assertTrue( wfReadOnly() );
+		$this->assertTrue( wfReadOnly() ); # Check cached
+
+		unlink( $wgReadOnlyFile );
+		$wgReadOnly = null; # Clean cache
+
+		$this->assertFalse( wfReadOnly() );
+		$this->assertFalse( wfReadOnly() );
+	}
+
+	public static function provideArrayToCGI() {
+		return array(
+			array( array(), '' ), // empty
+			array( array( 'foo' => 'bar' ), 'foo=bar' ), // string test
+			array( array( 'foo' => '' ), 'foo=' ), // empty string test
+			array( array( 'foo' => 1 ), 'foo=1' ), // number test
+			array( array( 'foo' => true ), 'foo=1' ), // true test
+			array( array( 'foo' => false ), '' ), // false test
+			array( array( 'foo' => null ), '' ), // null test
+			array( array( 'foo' => 'A&B=5+6@!"\'' ), 'foo=A%26B%3D5%2B6%40%21%22%27' ), // urlencoding test
+			array(
+				array( 'foo' => 'bar', 'baz' => 'is', 'asdf' => 'qwerty' ),
+				'foo=bar&baz=is&asdf=qwerty'
+			), // multi-item test
+			array( array( 'foo' => array( 'bar' => 'baz' ) ), 'foo%5Bbar%5D=baz' ),
+			array(
+				array( 'foo' => array( 'bar' => 'baz', 'qwerty' => 'asdf' ) ),
+				'foo%5Bbar%5D=baz&foo%5Bqwerty%5D=asdf'
+			),
+			array( array( 'foo' => array( 'bar', 'baz' ) ), 'foo%5B0%5D=bar&foo%5B1%5D=baz' ),
+			array(
+				array( 'foo' => array( 'bar' => array( 'bar' => 'baz' ) ) ),
+				'foo%5Bbar%5D%5Bbar%5D=baz'
+			),
+		);
+	}
+
+	/**
+	 * @dataProvider provideArrayToCGI
+	 * @covers ::wfArrayToCgi
+	 */
+	public function testArrayToCGI( $array, $result ) {
+		$this->assertEquals( $result, wfArrayToCgi( $array ) );
+	}
+
+	/**
+	 * @covers ::wfArrayToCgi
+	 */
+	public function testArrayToCGI2() {
+		$this->assertEquals(
+			"baz=bar&foo=bar",
+			wfArrayToCgi(
+				array( 'baz' => 'bar' ),
+				array( 'foo' => 'bar', 'baz' => 'overridden value' ) ) );
+	}
+
+	public static function provideCgiToArray() {
+		return array(
+			array( '', array() ), // empty
+			array( 'foo=bar', array( 'foo' => 'bar' ) ), // string
+			array( 'foo=', array( 'foo' => '' ) ), // empty string
+			array( 'foo', array( 'foo' => '' ) ), // missing =
+			array( 'foo=bar&qwerty=asdf', array( 'foo' => 'bar', 'qwerty' => 'asdf' ) ), // multiple value
+			array( 'foo=A%26B%3D5%2B6%40%21%22%27', array( 'foo' => 'A&B=5+6@!"\'' ) ), // urldecoding test
+			array( 'foo%5Bbar%5D=baz', array( 'foo' => array( 'bar' => 'baz' ) ) ),
+			array(
+				'foo%5Bbar%5D=baz&foo%5Bqwerty%5D=asdf',
+				array( 'foo' => array( 'bar' => 'baz', 'qwerty' => 'asdf' ) )
+			),
+			array( 'foo%5B0%5D=bar&foo%5B1%5D=baz', array( 'foo' => array( 0 => 'bar', 1 => 'baz' ) ) ),
+			array(
+				'foo%5Bbar%5D%5Bbar%5D=baz',
+				array( 'foo' => array( 'bar' => array( 'bar' => 'baz' ) ) )
+			),
+		);
+	}
+
+	/**
+	 * @dataProvider provideCgiToArray
+	 * @covers ::wfCgiToArray
+	 */
+	public function testCgiToArray( $cgi, $result ) {
+		$this->assertEquals( $result, wfCgiToArray( $cgi ) );
+	}
+
+	public static function provideCgiRoundTrip() {
+		return array(
+			array( '' ),
+			array( 'foo=bar' ),
+			array( 'foo=' ),
+			array( 'foo=bar&baz=biz' ),
+			array( 'foo=A%26B%3D5%2B6%40%21%22%27' ),
+			array( 'foo%5Bbar%5D=baz' ),
+			array( 'foo%5B0%5D=bar&foo%5B1%5D=baz' ),
+			array( 'foo%5Bbar%5D%5Bbar%5D=baz' ),
+		);
+	}
+
+	/**
+	 * @dataProvider provideCgiRoundTrip
+	 * @covers ::wfArrayToCgi
+	 */
+	public function testCgiRoundTrip( $cgi ) {
+		$this->assertEquals( $cgi, wfArrayToCgi( wfCgiToArray( $cgi ) ) );
+	}
+
+	/**
+	 * @covers ::mimeTypeMatch
+	 */
+	public function testMimeTypeMatch() {
+		$this->assertEquals(
+			'text/html',
+			mimeTypeMatch( 'text/html',
+				array( 'application/xhtml+xml' => 1.0,
+					'text/html' => 0.7,
+					'text/plain' => 0.3 ) ) );
+		$this->assertEquals(
+			'text/*',
+			mimeTypeMatch( 'text/html',
+				array( 'image/*' => 1.0,
+					'text/*' => 0.5 ) ) );
+		$this->assertEquals(
+			'*/*',
+			mimeTypeMatch( 'text/html',
+				array( '*/*' => 1.0 ) ) );
+		$this->assertNull(
+			mimeTypeMatch( 'text/html',
+				array( 'image/png' => 1.0,
+					'image/svg+xml' => 0.5 ) ) );
+	}
+
+	/**
+	 * @covers ::wfNegotiateType
+	 */
+	public function testNegotiateType() {
+		$this->assertEquals(
+			'text/html',
+			wfNegotiateType(
+				array( 'application/xhtml+xml' => 1.0,
+					'text/html' => 0.7,
+					'text/plain' => 0.5,
+					'text/*' => 0.2 ),
+				array( 'text/html' => 1.0 ) ) );
+		$this->assertEquals(
+			'application/xhtml+xml',
+			wfNegotiateType(
+				array( 'application/xhtml+xml' => 1.0,
+					'text/html' => 0.7,
+					'text/plain' => 0.5,
+					'text/*' => 0.2 ),
+				array( 'application/xhtml+xml' => 1.0,
+					'text/html' => 0.5 ) ) );
+		$this->assertEquals(
+			'text/html',
+			wfNegotiateType(
+				array( 'text/html' => 1.0,
+					'text/plain' => 0.5,
+					'text/*' => 0.5,
+					'application/xhtml+xml' => 0.2 ),
+				array( 'application/xhtml+xml' => 1.0,
+					'text/html' => 0.5 ) ) );
+		$this->assertEquals(
+			'text/html',
+			wfNegotiateType(
+				array( 'text/*' => 1.0,
+					'image/*' => 0.7,
+					'*/*' => 0.3 ),
+				array( 'application/xhtml+xml' => 1.0,
+					'text/html' => 0.5 ) ) );
+		$this->assertNull(
+			wfNegotiateType(
+				array( 'text/*' => 1.0 ),
+				array( 'application/xhtml+xml' => 1.0 ) ) );
+	}
+
+	/**
+	 * @covers ::wfDebug
+	 * @covers ::wfDebugMem
+	 */
+	public function testDebugFunctionTest() {
+
+		global $wgDebugLogFile, $wgDebugTimestamps;
+
+		$old_log_file = $wgDebugLogFile;
+		$wgDebugLogFile = tempnam( wfTempDir(), 'mw-' );
+		# @todo FIXME: $wgDebugTimestamps should be tested
+		$old_wgDebugTimestamps = $wgDebugTimestamps;
+		$wgDebugTimestamps = false;
+
+		wfDebug( "This is a normal string" );
+		$this->assertEquals( "This is a normal string", file_get_contents( $wgDebugLogFile ) );
+		unlink( $wgDebugLogFile );
+
+		wfDebug( "This is nöt an ASCII string" );
+		$this->assertEquals( "This is nöt an ASCII string", file_get_contents( $wgDebugLogFile ) );
+		unlink( $wgDebugLogFile );
+
+		wfDebug( "\00305This has böth UTF and control chars\003" );
+		$this->assertEquals(
+			" 05This has böth UTF and control chars ",
+			file_get_contents( $wgDebugLogFile )
+		);
+		unlink( $wgDebugLogFile );
+
+		wfDebugMem();
+		$this->assertGreaterThan(
+			1000,
+			preg_replace( '/\D/', '', file_get_contents( $wgDebugLogFile ) )
+		);
+		unlink( $wgDebugLogFile );
+
+		wfDebugMem( true );
+		$this->assertGreaterThan(
+			1000000,
+			preg_replace( '/\D/', '', file_get_contents( $wgDebugLogFile ) )
+		);
+		unlink( $wgDebugLogFile );
+
+		$wgDebugLogFile = $old_log_file;
+		$wgDebugTimestamps = $old_wgDebugTimestamps;
+	}
+
+	/**
+	 * @covers ::wfClientAcceptsGzip
+	 */
+	public function testClientAcceptsGzipTest() {
+
+		$settings = array(
+			'gzip' => true,
+			'bzip' => false,
+			'*' => false,
+			'compress, gzip' => true,
+			'gzip;q=1.0' => true,
+			'foozip' => false,
+			'foo*zip' => false,
+			'gzip;q=abcde' => true, //is this REALLY valid?
+			'gzip;q=12345678.9' => true,
+			' gzip' => true,
+		);
+
+		if ( isset( $_SERVER['HTTP_ACCEPT_ENCODING'] ) ) {
+			$old_server_setting = $_SERVER['HTTP_ACCEPT_ENCODING'];
+		}
+
+		foreach ( $settings as $encoding => $expect ) {
+			$_SERVER['HTTP_ACCEPT_ENCODING'] = $encoding;
+
+			$this->assertEquals( $expect, wfClientAcceptsGzip( true ),
+				"'$encoding' => " . wfBoolToStr( $expect ) );
+		}
+
+		if ( isset( $old_server_setting ) ) {
+			$_SERVER['HTTP_ACCEPT_ENCODING'] = $old_server_setting;
+		}
+	}
+
+	/**
+	 * @covers ::swap
+	 */
+	public function testSwapVarsTest() {
+		$this->hideDeprecated( 'swap' );
+
+		$var1 = 1;
+		$var2 = 2;
+
+		$this->assertEquals( $var1, 1, 'var1 is set originally' );
+		$this->assertEquals( $var2, 2, 'var1 is set originally' );
+
+		swap( $var1, $var2 );
+
+		$this->assertEquals( $var1, 2, 'var1 is swapped' );
+		$this->assertEquals( $var2, 1, 'var2 is swapped' );
+	}
+
+	/**
+	 * @covers ::wfPercent
+	 */
+	public function testWfPercentTest() {
+
+		$pcts = array(
+			array( 6 / 7, '0.86%', 2, false ),
+			array( 3 / 3, '1%' ),
+			array( 22 / 7, '3.14286%', 5 ),
+			array( 3 / 6, '0.5%' ),
+			array( 1 / 3, '0%', 0 ),
+			array( 10 / 3, '0%', -1 ),
+			array( 3 / 4 / 5, '0.1%', 1 ),
+			array( 6 / 7 * 8, '6.8571428571%', 10 ),
+		);
+
+		foreach ( $pcts as $pct ) {
+			if ( !isset( $pct[2] ) ) {
+				$pct[2] = 2;
+			}
+			if ( !isset( $pct[3] ) ) {
+				$pct[3] = true;
+			}
+
+			$this->assertEquals( wfPercent( $pct[0], $pct[2], $pct[3] ), $pct[1], $pct[1] );
+		}
+	}
+
+	/**
+	 * test @see wfShorthandToInteger()
+	 * @dataProvider provideShorthand
+	 * @covers ::wfShorthandToInteger
+	 */
+	public function testWfShorthandToInteger( $shorthand, $expected ) {
+		$this->assertEquals( $expected,
+			wfShorthandToInteger( $shorthand )
+		);
+	}
+
+	/** array( shorthand, expected integer ) */
+	public static function provideShorthand() {
+		return array(
+			# Null, empty ...
+			array( '', -1 ),
+			array( '  ', -1 ),
+			array( null, -1 ),
+
+			# Failures returns 0 :(
+			array( 'ABCDEFG', 0 ),
+			array( 'Ak', 0 ),
+
+			# Int, strings with spaces
+			array( 1, 1 ),
+			array( ' 1 ', 1 ),
+			array( 1023, 1023 ),
+			array( ' 1023 ', 1023 ),
+
+			# kilo, Mega, Giga
+			array( '1k', 1024 ),
+			array( '1K', 1024 ),
+			array( '1m', 1024 * 1024 ),
+			array( '1M', 1024 * 1024 ),
+			array( '1g', 1024 * 1024 * 1024 ),
+			array( '1G', 1024 * 1024 * 1024 ),
+
+			# Negatives
+			array( -1, -1 ),
+			array( -500, -500 ),
+			array( '-500', -500 ),
+			array( '-1k', -1024 ),
+
+			# Zeroes
+			array( '0', 0 ),
+			array( '0k', 0 ),
+			array( '0M', 0 ),
+			array( '0G', 0 ),
+			array( '-0', 0 ),
+			array( '-0k', 0 ),
+			array( '-0M', 0 ),
+			array( '-0G', 0 ),
+		);
+	}
+
+	/**
+	 * @param string $old Text as it was in the database
+	 * @param string $mine Text submitted while user was editing
+	 * @param string $yours Text submitted by the user
+	 * @param bool $expectedMergeResult Whether the merge should be a success
+	 * @param string $expectedText Text after merge has been completed
+	 *
+	 * @dataProvider provideMerge()
+	 * @group medium
+	 * @covers ::wfMerge
+	 */
+	public function testMerge( $old, $mine, $yours, $expectedMergeResult, $expectedText ) {
+		$this->checkHasDiff3();
+
+		$mergedText = null;
+		$isMerged = wfMerge( $old, $mine, $yours, $mergedText );
+
+		$msg = 'Merge should be a ';
+		$msg .= $expectedMergeResult ? 'success' : 'failure';
+		$this->assertEquals( $expectedMergeResult, $isMerged, $msg );
+
+		if ( $isMerged ) {
+			// Verify the merged text
+			$this->assertEquals( $expectedText, $mergedText,
+				'is merged text as expected?' );
+		}
+	}
+
+	public static function provideMerge() {
+		$EXPECT_MERGE_SUCCESS = true;
+		$EXPECT_MERGE_FAILURE = false;
+
+		return array(
+			// #0: clean merge
+			array(
+				// old:
+				"one one one\n" . // trimmed
+					"\n" .
+					"two two two",
+
+				// mine:
+				"one one one ONE ONE\n" .
+					"\n" .
+					"two two two\n", // with tailing whitespace
+
+				// yours:
+				"one one one\n" .
+					"\n" .
+					"two two TWO TWO", // trimmed
+
+				// ok:
+				$EXPECT_MERGE_SUCCESS,
+
+				// result:
+				"one one one ONE ONE\n" .
+					"\n" .
+					"two two TWO TWO\n", // note: will always end in a newline
+			),
+
+			// #1: conflict, fail
+			array(
+				// old:
+				"one one one", // trimmed
+
+				// mine:
+				"one one one ONE ONE\n" .
+					"\n" .
+					"bla bla\n" .
+					"\n", // with tailing whitespace
+
+				// yours:
+				"one one one\n" .
+					"\n" .
+					"two two", // trimmed
+
+				$EXPECT_MERGE_FAILURE,
+
+				// result:
+				null,
+			),
+		);
+	}
+
+	/**
+	 * @dataProvider provideMakeUrlIndexes()
+	 * @covers ::wfMakeUrlIndexes
+	 */
+	public function testMakeUrlIndexes( $url, $expected ) {
+		$index = wfMakeUrlIndexes( $url );
+		$this->assertEquals( $expected, $index, "wfMakeUrlIndexes(\"$url\")" );
+	}
+
+	public static function provideMakeUrlIndexes() {
+		return array(
+			array(
+				// just a regular :)
+				'https://bugzilla.wikimedia.org/show_bug.cgi?id=28627',
+				array( 'https://org.wikimedia.bugzilla./show_bug.cgi?id=28627' )
+			),
+			array(
+				// mailtos are handled special
+				// is this really right though? that final . probably belongs earlier?
+				'mailto:wiki@wikimedia.org',
+				array( 'mailto:org.wikimedia@wiki.' )
+			),
+
+			// file URL cases per bug 28627...
+			array(
+				// three slashes: local filesystem path Unix-style
+				'file:///whatever/you/like.txt',
+				array( 'file://./whatever/you/like.txt' )
+			),
+			array(
+				// three slashes: local filesystem path Windows-style
+				'file:///c:/whatever/you/like.txt',
+				array( 'file://./c:/whatever/you/like.txt' )
+			),
+			array(
+				// two slashes: UNC filesystem path Windows-style
+				'file://intranet/whatever/you/like.txt',
+				array( 'file://intranet./whatever/you/like.txt' )
+			),
+			// Multiple-slash cases that can sorta work on Mozilla
+			// if you hack it just right are kinda pathological,
+			// and unreliable cross-platform or on IE which means they're
+			// unlikely to appear on intranets.
+			//
+			// Those will survive the algorithm but with results that
+			// are less consistent.
+
+			// protocol-relative URL cases per bug 29854...
+			array(
+				'//bugzilla.wikimedia.org/show_bug.cgi?id=28627',
+				array(
+					'http://org.wikimedia.bugzilla./show_bug.cgi?id=28627',
+					'https://org.wikimedia.bugzilla./show_bug.cgi?id=28627'
+				)
+			),
+		);
+	}
+
+	/**
+	 * @dataProvider provideWfMatchesDomainList
+	 * @covers ::wfMatchesDomainList
+	 */
+	public function testWfMatchesDomainList( $url, $domains, $expected, $description ) {
+		$actual = wfMatchesDomainList( $url, $domains );
+		$this->assertEquals( $expected, $actual, $description );
+	}
+
+	public static function provideWfMatchesDomainList() {
+		$a = array();
+		$protocols = array( 'HTTP' => 'http:', 'HTTPS' => 'https:', 'protocol-relative' => '' );
+		foreach ( $protocols as $pDesc => $p ) {
+			$a = array_merge( $a, array(
+				array(
+					"$p//www.example.com",
+					array(),
+					false,
+					"No matches for empty domains array, $pDesc URL"
+				),
+				array(
+					"$p//www.example.com",
+					array( 'www.example.com' ),
+					true,
+					"Exact match in domains array, $pDesc URL"
+				),
+				array(
+					"$p//www.example.com",
+					array( 'example.com' ),
+					true,
+					"Match without subdomain in domains array, $pDesc URL"
+				),
+				array(
+					"$p//www.example2.com",
+					array( 'www.example.com', 'www.example2.com', 'www.example3.com' ),
+					true,
+					"Exact match with other domains in array, $pDesc URL"
+				),
+				array(
+					"$p//www.example2.com",
+					array( 'example.com', 'example2.com', 'example3,com' ),
+					true,
+					"Match without subdomain with other domains in array, $pDesc URL"
+				),
+				array(
+					"$p//www.example4.com",
+					array( 'example.com', 'example2.com', 'example3,com' ),
+					false,
+					"Domain not in array, $pDesc URL"
+				),
+				array(
+					"$p//nds-nl.wikipedia.org",
+					array( 'nl.wikipedia.org' ),
+					false,
+					"Non-matching substring of domain, $pDesc URL"
+				),
+			) );
+		}
+
+		return $a;
+	}
+
+	/**
+	 * @covers ::wfMkdirParents
+	 */
+	public function testWfMkdirParents() {
+		// Should not return true if file exists instead of directory
+		$fname = $this->getNewTempFile();
+		wfSuppressWarnings();
+		$ok = wfMkdirParents( $fname );
+		wfRestoreWarnings();
+		$this->assertFalse( $ok );
+	}
+
+	/**
+	 * @dataProvider provideWfShellMaintenanceCmdList
+	 * @covers ::wfShellMaintenanceCmd
+	 */
+	public function testWfShellMaintenanceCmd( $script, $parameters, $options,
+		$expected, $description
+	) {
+		if ( wfIsWindows() ) {
+			// Approximation that's good enough for our purposes just now
+			$expected = str_replace( "'", '"', $expected );
+		}
+		$actual = wfShellMaintenanceCmd( $script, $parameters, $options );
+		$this->assertEquals( $expected, $actual, $description );
+	}
+
+	public static function provideWfShellMaintenanceCmdList() {
+		global $wgPhpCli;
+
+		return array(
+			array( 'eval.php', array( '--help', '--test' ), array(),
+				"'$wgPhpCli' 'eval.php' '--help' '--test'",
+				"Called eval.php --help --test" ),
+			array( 'eval.php', array( '--help', '--test space' ), array( 'php' => 'php5' ),
+				"'php5' 'eval.php' '--help' '--test space'",
+				"Called eval.php --help --test with php option" ),
+			array( 'eval.php', array( '--help', '--test', 'X' ), array( 'wrapper' => 'MWScript.php' ),
+				"'$wgPhpCli' 'MWScript.php' 'eval.php' '--help' '--test' 'X'",
+				"Called eval.php --help --test with wrapper option" ),
+			array(
+				'eval.php',
+				array( '--help', '--test', 'y' ),
+				array( 'php' => 'php5', 'wrapper' => 'MWScript.php' ),
+				"'php5' 'MWScript.php' 'eval.php' '--help' '--test' 'y'",
+				"Called eval.php --help --test with wrapper and php option"
+			),
+		);
+	}
+	/* @todo many more! */
+}
diff --git a/tests/phpunit/includes/GlobalFunctions/GlobalWithDBTest.php b/tests/phpunit/includes/GlobalFunctions/GlobalWithDBTest.php
new file mode 100644
index 00000000..9588ffdc
--- /dev/null
+++ b/tests/phpunit/includes/GlobalFunctions/GlobalWithDBTest.php
@@ -0,0 +1,32 @@
+<?php
+
+/**
+ * @group GlobalFunctions
+ * @group Database
+ */
+class GlobalWithDBTest extends MediaWikiTestCase {
+	/**
+	 * @dataProvider provideWfIsBadImageList
+	 * @covers ::wfIsBadImage
+	 */
+	public function testWfIsBadImage( $name, $title, $blacklist, $expected, $desc ) {
+		$this->assertEquals( $expected, wfIsBadImage( $name, $title, $blacklist ), $desc );
+	}
+
+	public static function provideWfIsBadImageList() {
+		$blacklist = '* [[File:Bad.jpg]] except [[Nasty page]]';
+
+		return array(
+			array( 'Bad.jpg', false, $blacklist, true,
+				'Called on a bad image' ),
+			array( 'Bad.jpg', Title::makeTitle( NS_MAIN, 'A page' ), $blacklist, true,
+				'Called on a bad image' ),
+			array( 'NotBad.jpg', false, $blacklist, false,
+				'Called on a non-bad image' ),
+			array( 'Bad.jpg', Title::makeTitle( NS_MAIN, 'Nasty page' ), $blacklist, false,
+				'Called on a bad image but is on a whitelisted page' ),
+			array( 'File:Bad.jpg', false, $blacklist, false,
+				'Called on a bad image with File:' ),
+		);
+	}
+}
diff --git a/tests/phpunit/includes/GlobalFunctions/README b/tests/phpunit/includes/GlobalFunctions/README
new file mode 100644
index 00000000..0042bdac
--- /dev/null
+++ b/tests/phpunit/includes/GlobalFunctions/README
@@ -0,0 +1,2 @@
+This directory hold tests for includes/GlobalFunctions.php file
+which is a pile of functions.
diff --git a/tests/phpunit/includes/GlobalFunctions/wfAssembleUrlTest.php b/tests/phpunit/includes/GlobalFunctions/wfAssembleUrlTest.php
new file mode 100644
index 00000000..13f49f79
--- /dev/null
+++ b/tests/phpunit/includes/GlobalFunctions/wfAssembleUrlTest.php
@@ -0,0 +1,112 @@
+<?php
+/**
+ * @group GlobalFunctions
+ * @covers ::wfAssembleUrl
+ */
+class WfAssembleUrlTest extends MediaWikiTestCase {
+	/**
+	 * @dataProvider provideURLParts
+	 */
+	public function testWfAssembleUrl( $parts, $output ) {
+		$partsDump = print_r( $parts, true );
+		$this->assertEquals(
+			$output,
+			wfAssembleUrl( $parts ),
+			"Testing $partsDump assembles to $output"
+		);
+	}
+
+	/**
+	 * Provider of URL parts for testing wfAssembleUrl()
+	 *
+	 * @return array
+	 */
+	public static function provideURLParts() {
+		$schemes = array(
+			'' => array(),
+			'//' => array(
+				'delimiter' => '//',
+			),
+			'http://' => array(
+				'scheme' => 'http',
+				'delimiter' => '://',
+			),
+		);
+
+		$hosts = array(
+			'' => array(),
+			'example.com' => array(
+				'host' => 'example.com',
+			),
+			'example.com:123' => array(
+				'host' => 'example.com',
+				'port' => 123,
+			),
+			'id@example.com' => array(
+				'user' => 'id',
+				'host' => 'example.com',
+			),
+			'id@example.com:123' => array(
+				'user' => 'id',
+				'host' => 'example.com',
+				'port' => 123,
+			),
+			'id:key@example.com' => array(
+				'user' => 'id',
+				'pass' => 'key',
+				'host' => 'example.com',
+			),
+			'id:key@example.com:123' => array(
+				'user' => 'id',
+				'pass' => 'key',
+				'host' => 'example.com',
+				'port' => 123,
+			),
+		);
+
+		$cases = array();
+		foreach ( $schemes as $scheme => $schemeParts ) {
+			foreach ( $hosts as $host => $hostParts ) {
+				foreach ( array( '', '/path' ) as $path ) {
+					foreach ( array( '', 'query' ) as $query ) {
+						foreach ( array( '', 'fragment' ) as $fragment ) {
+							$parts = array_merge(
+								$schemeParts,
+								$hostParts
+							);
+							$url = $scheme .
+								$host .
+								$path;
+
+							if ( $path ) {
+								$parts['path'] = $path;
+							}
+							if ( $query ) {
+								$parts['query'] = $query;
+								$url .= '?' . $query;
+							}
+							if ( $fragment ) {
+								$parts['fragment'] = $fragment;
+								$url .= '#' . $fragment;
+							}
+
+							$cases[] = array(
+								$parts,
+								$url,
+							);
+						}
+					}
+				}
+			}
+		}
+
+		$complexURL = 'http://id:key@example.org:321' .
+			'/over/there?name=ferret&foo=bar#nose';
+		$cases[] = array(
+			wfParseUrl( $complexURL ),
+			$complexURL,
+		);
+
+		return $cases;
+	}
+}
diff --git a/tests/phpunit/includes/GlobalFunctions/wfBCP47Test.php b/tests/phpunit/includes/GlobalFunctions/wfBCP47Test.php
new file mode 100644
index 00000000..166d641f
--- /dev/null
+++ b/tests/phpunit/includes/GlobalFunctions/wfBCP47Test.php
@@ -0,0 +1,121 @@
+<?php
+/**
+ * @group GlobalFunctions
+ * @covers ::wfBCP47
+ */
+class WfBCP47Test extends MediaWikiTestCase {
+	/**
+	 * test @see wfBCP47().
+	 * Please note the BCP explicitly state that language codes are case
+	 * insensitive, there are some exceptions to the rule :)
+	 * This test is used to verify our formatting against all lower and
+	 * all upper cases language code.
+	 *
+	 * @see http://tools.ietf.org/html/bcp47
+	 * @dataProvider provideLanguageCodes()
+	 */
+	public function testBCP47( $code, $expected ) {
+		$code = strtolower( $code );
+		$this->assertEquals( $expected, wfBCP47( $code ),
+			"Applying BCP47 standard to lower case '$code'"
+		);
+
+		$code = strtoupper( $code );
+		$this->assertEquals( $expected, wfBCP47( $code ),
+			"Applying BCP47 standard to upper case '$code'"
+		);
+	}
+
+	/**
+	 * Array format is ($code, $expected)
+	 */
+	public static function provideLanguageCodes() {
+		return array(
+			// Extracted from BCP47 (list not exhaustive)
+			# 2.1.1
+			array( 'en-ca-x-ca', 'en-CA-x-ca' ),
+			array( 'sgn-be-fr', 'sgn-BE-FR' ),
+			array( 'az-latn-x-latn', 'az-Latn-x-latn' ),
+			# 2.2
+			array( 'sr-Latn-RS', 'sr-Latn-RS' ),
+			array( 'az-arab-ir', 'az-Arab-IR' ),
+
+			# 2.2.5
+			array( 'sl-nedis', 'sl-nedis' ),
+			array( 'de-ch-1996', 'de-CH-1996' ),
+
+			# 2.2.6
+			array(
+				'en-latn-gb-boont-r-extended-sequence-x-private',
+				'en-Latn-GB-boont-r-extended-sequence-x-private'
+			),
+
+			// Examples from BCP47 Appendix A
+			# Simple language subtag:
+			array( 'DE', 'de' ),
+			array( 'fR', 'fr' ),
+			array( 'ja', 'ja' ),
+
+			# Language subtag plus script subtag:
+			array( 'zh-hans', 'zh-Hans' ),
+			array( 'sr-cyrl', 'sr-Cyrl' ),
+			array( 'sr-latn', 'sr-Latn' ),
+
+			# Extended language subtags and their primary language subtag
+			# counterparts:
+			array( 'zh-cmn-hans-cn', 'zh-cmn-Hans-CN' ),
+			array( 'cmn-hans-cn', 'cmn-Hans-CN' ),
+			array( 'zh-yue-hk', 'zh-yue-HK' ),
+			array( 'yue-hk', 'yue-HK' ),
+
+			# Language-Script-Region:
+			array( 'zh-hans-cn', 'zh-Hans-CN' ),
+			array( 'sr-latn-RS', 'sr-Latn-RS' ),
+
+			# Language-Variant:
+			array( 'sl-rozaj', 'sl-rozaj' ),
+			array( 'sl-rozaj-biske', 'sl-rozaj-biske' ),
+			array( 'sl-nedis', 'sl-nedis' ),
+
+			# Language-Region-Variant:
+			array( 'de-ch-1901', 'de-CH-1901' ),
+			array( 'sl-it-nedis', 'sl-IT-nedis' ),
+
+			# Language-Script-Region-Variant:
+			array( 'hy-latn-it-arevela', 'hy-Latn-IT-arevela' ),
+
+			# Language-Region:
+			array( 'de-de', 'de-DE' ),
+			array( 'en-us', 'en-US' ),
+			array( 'es-419', 'es-419' ),
+
+			# Private use subtags:
+			array( 'de-ch-x-phonebk', 'de-CH-x-phonebk' ),
+			array( 'az-arab-x-aze-derbend', 'az-Arab-x-aze-derbend' ),
+			/**
+			 * Previous test does not reflect the BCP which states:
+			 *  az-Arab-x-AZE-derbend
+			 * AZE being private, it should be lower case, hence the test above
+			 * should probably be:
+			 *  array( 'az-arab-x-aze-derbend', 'az-Arab-x-AZE-derbend' ),
+			 */
+
+			# Private use registry values:
+			array( 'x-whatever', 'x-whatever' ),
+			array( 'qaa-qaaa-qm-x-southern', 'qaa-Qaaa-QM-x-southern' ),
+			array( 'de-qaaa', 'de-Qaaa' ),
+			array( 'sr-latn-qm', 'sr-Latn-QM' ),
+			array( 'sr-qaaa-rs', 'sr-Qaaa-RS' ),
+
+			# Tags that use extensions
+			array( 'en-us-u-islamcal', 'en-US-u-islamcal' ),
+			array( 'zh-cn-a-myext-x-private', 'zh-CN-a-myext-x-private' ),
+			array( 'en-a-myext-b-another', 'en-a-myext-b-another' ),
+
+			# Invalid:
+			// de-419-DE
+			// a-DE
+			// ar-a-aaa-b-bbb-a-ccc
+		);
+	}
+}
diff --git a/tests/phpunit/includes/GlobalFunctions/wfBaseConvertTest.php b/tests/phpunit/includes/GlobalFunctions/wfBaseConvertTest.php
new file mode 100644
index 00000000..9d55e85c
--- /dev/null
+++ b/tests/phpunit/includes/GlobalFunctions/wfBaseConvertTest.php
@@ -0,0 +1,195 @@
+<?php
+/**
+ * @group GlobalFunctions
+ * @covers ::wfBaseConvert
+ */
+class WfBaseConvertTest extends MediaWikiTestCase {
+	public static function provideSingleDigitConversions() {
+		return array(
+			//      2    3    5    8   10   16   36
+			array( '0', '0', '0', '0', '0', '0', '0' ),
+			array( '1', '1', '1', '1', '1', '1', '1' ),
+			array( '10', '2', '2', '2', '2', '2', '2' ),
+			array( '11', '10', '3', '3', '3', '3', '3' ),
+			array( '100', '11', '4', '4', '4', '4', '4' ),
+			array( '101', '12', '10', '5', '5', '5', '5' ),
+			array( '110', '20', '11', '6', '6', '6', '6' ),
+			array( '111', '21', '12', '7', '7', '7', '7' ),
+			array( '1000', '22', '13', '10', '8', '8', '8' ),
+			array( '1001', '100', '14', '11', '9', '9', '9' ),
+			array( '1010', '101', '20', '12', '10', 'a', 'a' ),
+			array( '1011', '102', '21', '13', '11', 'b', 'b' ),
+			array( '1100', '110', '22', '14', '12', 'c', 'c' ),
+			array( '1101', '111', '23', '15', '13', 'd', 'd' ),
+			array( '1110', '112', '24', '16', '14', 'e', 'e' ),
+			array( '1111', '120', '30', '17', '15', 'f', 'f' ),
+			array( '10000', '121', '31', '20', '16', '10', 'g' ),
+			array( '10001', '122', '32', '21', '17', '11', 'h' ),
+			array( '10010', '200', '33', '22', '18', '12', 'i' ),
+			array( '10011', '201', '34', '23', '19', '13', 'j' ),
+			array( '10100', '202', '40', '24', '20', '14', 'k' ),
+			array( '10101', '210', '41', '25', '21', '15', 'l' ),
+			array( '10110', '211', '42', '26', '22', '16', 'm' ),
+			array( '10111', '212', '43', '27', '23', '17', 'n' ),
+			array( '11000', '220', '44', '30', '24', '18', 'o' ),
+			array( '11001', '221', '100', '31', '25', '19', 'p' ),
+			array( '11010', '222', '101', '32', '26', '1a', 'q' ),
+			array( '11011', '1000', '102', '33', '27', '1b', 'r' ),
+			array( '11100', '1001', '103', '34', '28', '1c', 's' ),
+			array( '11101', '1002', '104', '35', '29', '1d', 't' ),
+			array( '11110', '1010', '110', '36', '30', '1e', 'u' ),
+			array( '11111', '1011', '111', '37', '31', '1f', 'v' ),
+			array( '100000', '1012', '112', '40', '32', '20', 'w' ),
+			array( '100001', '1020', '113', '41', '33', '21', 'x' ),
+			array( '100010', '1021', '114', '42', '34', '22', 'y' ),
+			array( '100011', '1022', '120', '43', '35', '23', 'z' )
+		);
+	}
+
+	/**
+	 * @dataProvider provideSingleDigitConversions
+	 */
+	public function testDigitToBase2( $base2, $base3, $base5, $base8, $base10, $base16, $base36 ) {
+		$this->assertSame( $base2, wfBaseConvert( $base3, '3', '2' ) );
+		$this->assertSame( $base2, wfBaseConvert( $base5, '5', '2' ) );
+		$this->assertSame( $base2, wfBaseConvert( $base8, '8', '2' ) );
+		$this->assertSame( $base2, wfBaseConvert( $base10, '10', '2' ) );
+		$this->assertSame( $base2, wfBaseConvert( $base16, '16', '2' ) );
+		$this->assertSame( $base2, wfBaseConvert( $base36, '36', '2' ) );
+	}
+
+	/**
+	 * @dataProvider provideSingleDigitConversions
+	 */
+	public function testDigitToBase3( $base2, $base3, $base5, $base8, $base10, $base16, $base36 ) {
+		$this->assertSame( $base3, wfBaseConvert( $base2, '2', '3' ) );
+		$this->assertSame( $base3, wfBaseConvert( $base5, '5', '3' ) );
+		$this->assertSame( $base3, wfBaseConvert( $base8, '8', '3' ) );
+		$this->assertSame( $base3, wfBaseConvert( $base10, '10', '3' ) );
+		$this->assertSame( $base3, wfBaseConvert( $base16, '16', '3' ) );
+		$this->assertSame( $base3, wfBaseConvert( $base36, '36', '3' ) );
+	}
+
+	/**
+	 * @dataProvider provideSingleDigitConversions
+	 */
+	public function testDigitToBase5( $base2, $base3, $base5, $base8, $base10, $base16, $base36 ) {
+		$this->assertSame( $base5, wfBaseConvert( $base2, '2', '5' ) );
+		$this->assertSame( $base5, wfBaseConvert( $base3, '3', '5' ) );
+		$this->assertSame( $base5, wfBaseConvert( $base8, '8', '5' ) );
+		$this->assertSame( $base5, wfBaseConvert( $base10, '10', '5' ) );
+		$this->assertSame( $base5, wfBaseConvert( $base16, '16', '5' ) );
+		$this->assertSame( $base5, wfBaseConvert( $base36, '36', '5' ) );
+	}
+
+	/**
+	 * @dataProvider provideSingleDigitConversions
+	 */
+	public function testDigitToBase8( $base2, $base3, $base5, $base8, $base10, $base16, $base36 ) {
+		$this->assertSame( $base8, wfBaseConvert( $base2, '2', '8' ) );
+		$this->assertSame( $base8, wfBaseConvert( $base3, '3', '8' ) );
+		$this->assertSame( $base8, wfBaseConvert( $base5, '5', '8' ) );
+		$this->assertSame( $base8, wfBaseConvert( $base10, '10', '8' ) );
+		$this->assertSame( $base8, wfBaseConvert( $base16, '16', '8' ) );
+		$this->assertSame( $base8, wfBaseConvert( $base36, '36', '8' ) );
+	}
+
+	/**
+	 * @dataProvider provideSingleDigitConversions
+	 */
+	public function testDigitToBase10( $base2, $base3, $base5, $base8, $base10, $base16, $base36 ) {
+		$this->assertSame( $base10, wfBaseConvert( $base2, '2', '10' ) );
+		$this->assertSame( $base10, wfBaseConvert( $base3, '3', '10' ) );
+		$this->assertSame( $base10, wfBaseConvert( $base5, '5', '10' ) );
+		$this->assertSame( $base10, wfBaseConvert( $base8, '8', '10' ) );
+		$this->assertSame( $base10, wfBaseConvert( $base16, '16', '10' ) );
+		$this->assertSame( $base10, wfBaseConvert( $base36, '36', '10' ) );
+	}
+
+	/**
+	 * @dataProvider provideSingleDigitConversions
+	 */
+	public function testDigitToBase16( $base2, $base3, $base5, $base8, $base10, $base16, $base36 ) {
+		$this->assertSame( $base16, wfBaseConvert( $base2, '2', '16' ) );
+		$this->assertSame( $base16, wfBaseConvert( $base3, '3', '16' ) );
+		$this->assertSame( $base16, wfBaseConvert( $base5, '5', '16' ) );
+		$this->assertSame( $base16, wfBaseConvert( $base8, '8', '16' ) );
+		$this->assertSame( $base16, wfBaseConvert( $base10, '10', '16' ) );
+		$this->assertSame( $base16, wfBaseConvert( $base36, '36', '16' ) );
+	}
+
+	/**
+	 * @dataProvider provideSingleDigitConversions
+	 */
+	public function testDigitToBase36( $base2, $base3, $base5, $base8, $base10, $base16, $base36 ) {
+		$this->assertSame( $base36, wfBaseConvert( $base2, '2', '36' ) );
+		$this->assertSame( $base36, wfBaseConvert( $base3, '3', '36' ) );
+		$this->assertSame( $base36, wfBaseConvert( $base5, '5', '36' ) );
+		$this->assertSame( $base36, wfBaseConvert( $base8, '8', '36' ) );
+		$this->assertSame( $base36, wfBaseConvert( $base10, '10', '36' ) );
+		$this->assertSame( $base36, wfBaseConvert( $base16, '16', '36' ) );
+	}
+
+	public function testLargeNumber() {
+		$this->assertSame( '1100110001111010000000101110100', wfBaseConvert( 'sd89ys', 36, 2 ) );
+		$this->assertSame( '11102112120221201101', wfBaseConvert( 'sd89ys', 36, 3 ) );
+		$this->assertSame( '12003102232400', wfBaseConvert( 'sd89ys', 36, 5 ) );
+		$this->assertSame( '14617200564', wfBaseConvert( 'sd89ys', 36, 8 ) );
+		$this->assertSame( '1715274100', wfBaseConvert( 'sd89ys', 36, 10 ) );
+		$this->assertSame( '663d0174', wfBaseConvert( 'sd89ys', 36, 16 ) );
+	}
+
+	public static function provideNumbers() {
+		$x = array();
+		$chars = '0123456789abcdefghijklmnopqrstuvwxyz';
+		for ( $i = 0; $i < 50; $i++ ) {
+			$base = mt_rand( 2, 36 );
+			$len = mt_rand( 10, 100 );
+
+			$str = '';
+			for ( $j = 0; $j < $len; $j++ ) {
+				$str .= $chars[mt_rand( 0, $base - 1 )];
+			}
+
+			$x[] = array( $base, $str );
+		}
+
+		return $x;
+	}
+
+	/**
+	 * @dataProvider provideNumbers
+	 */
+	public function testIdentity( $base, $number ) {
+		$this->assertSame( $number, wfBaseConvert( $number, $base, $base, strlen( $number ) ) );
+	}
+
+	public function testInvalid() {
+		$this->assertFalse( wfBaseConvert( '101', 1, 15 ) );
+		$this->assertFalse( wfBaseConvert( '101', 15, 1 ) );
+		$this->assertFalse( wfBaseConvert( '101', 37, 15 ) );
+		$this->assertFalse( wfBaseConvert( '101', 15, 37 ) );
+		$this->assertFalse( wfBaseConvert( 'abcde', 10, 11 ) );
+		$this->assertFalse( wfBaseConvert( '12930', 2, 10 ) );
+		$this->assertFalse( wfBaseConvert( '101', 'abc', 15 ) );
+		$this->assertFalse( wfBaseConvert( '101', 15, 'abc' ) );
+	}
+
+	public function testPadding() {
+		$number = "10101010101";
+		$this->assertSame(
+			strlen( $number ) + 5,
+			strlen( wfBaseConvert( $number, 2, 2, strlen( $number ) + 5 ) )
+		);
+		$this->assertSame(
+			strlen( $number ),
+			strlen( wfBaseConvert( $number, 2, 2, strlen( $number ) - 5 ) )
+		);
+	}
+
+	public function testLeadingZero() {
+		$this->assertSame( '24', wfBaseConvert( '010', 36, 16 ) );
+		$this->assertSame( '37d4', wfBaseConvert( '0b10', 36, 16 ) );
+		$this->assertSame( 'a734', wfBaseConvert( '0x10', 36, 16 ) );
+	}
+}
diff --git a/tests/phpunit/includes/GlobalFunctions/wfBaseNameTest.php b/tests/phpunit/includes/GlobalFunctions/wfBaseNameTest.php
new file mode 100644
index 00000000..705730a7
--- /dev/null
+++ b/tests/phpunit/includes/GlobalFunctions/wfBaseNameTest.php
@@ -0,0 +1,40 @@
+<?php
+/**
+ * @group GlobalFunctions
+ * @covers ::wfBaseName
+ */
+class WfBaseNameTest extends MediaWikiTestCase {
+	/**
+	 * @dataProvider providePaths
+	 */
+	public function testBaseName( $fullpath, $basename ) {
+		$this->assertEquals( $basename, wfBaseName( $fullpath ),
+			"wfBaseName('$fullpath') => '$basename'" );
+	}
+
+	public static function providePaths() {
+		return array(
+			array( '', '' ),
+			array( '/', '' ),
+			array( '\\', '' ),
+			array( '//', '' ),
+			array( '\\\\', '' ),
+			array( 'a', 'a' ),
+			array( 'aaaa', 'aaaa' ),
+			array( '/a', 'a' ),
+			array( '\\a', 'a' ),
+			array( '/aaaa', 'aaaa' ),
+			array( '\\aaaa', 'aaaa' ),
+			array( '/aaaa/', 'aaaa' ),
+			array( '\\aaaa\\', 'aaaa' ),
+			array( '\\aaaa\\', 'aaaa' ),
+			array(
+				'/mnt/upload3/wikipedia/en/thumb/8/8b/'
+					. 'Zork_Grand_Inquisitor_box_cover.jpg/93px-Zork_Grand_Inquisitor_box_cover.jpg',
+				'93px-Zork_Grand_Inquisitor_box_cover.jpg'
+			),
+			array( 'C:\\Progra~1\\Wikime~1\\Wikipe~1\\VIEWER.EXE', 'VIEWER.EXE' ),
+			array( 'Östergötland_coat_of_arms.png', 'Östergötland_coat_of_arms.png' ),
+		);
+	}
+}
diff --git a/tests/phpunit/includes/GlobalFunctions/wfExpandUrlTest.php b/tests/phpunit/includes/GlobalFunctions/wfExpandUrlTest.php
new file mode 100644
index 00000000..a69defb3
--- /dev/null
+++ b/tests/phpunit/includes/GlobalFunctions/wfExpandUrlTest.php
@@ -0,0 +1,117 @@
+<?php
+/**
+ * @group GlobalFunctions
+ * @covers ::wfExpandUrl
+ */
+class WfExpandUrlTest extends MediaWikiTestCase {
+	/**
+	 * @dataProvider provideExpandableUrls
+	 */
+	public function testWfExpandUrl( $fullUrl, $shortUrl, $defaultProto,
+		$server, $canServer, $httpsMode, $message
+	) {
+		// Fake $wgServer, $wgCanonicalServer and $wgRequest->getProtocol()
+		$this->setMwGlobals( array(
+			'wgServer' => $server,
+			'wgCanonicalServer' => $canServer,
+			'wgRequest' => new FauxRequest( array(), false, null, $httpsMode ? 'https' : 'http' )
+		) );
+
+		$this->assertEquals( $fullUrl, wfExpandUrl( $shortUrl, $defaultProto ), $message );
+	}
+
+	/**
+	 * Provider of URL examples for testing wfExpandUrl()
+	 *
+	 * @return array
+	 */
+	public static function provideExpandableUrls() {
+		$modes = array( 'http', 'https' );
+		$servers = array(
+			'http' => 'http://example.com',
+			'https' => 'https://example.com',
+			'protocol-relative' => '//example.com'
+		);
+		$defaultProtos = array(
+			'http' => PROTO_HTTP,
+			'https' => PROTO_HTTPS,
+			'protocol-relative' => PROTO_RELATIVE,
+			'current' => PROTO_CURRENT,
+			'canonical' => PROTO_CANONICAL
+		);
+
+		$retval = array();
+		foreach ( $modes as $mode ) {
+			$httpsMode = $mode == 'https';
+			foreach ( $servers as $serverDesc => $server ) {
+				foreach ( $modes as $canServerMode ) {
+					$canServer = "$canServerMode://example2.com";
+					foreach ( $defaultProtos as $protoDesc => $defaultProto ) {
+						$retval[] = array(
+							'http://example.com', 'http://example.com',
+							$defaultProto, $server, $canServer, $httpsMode,
+							"Testing fully qualified http URLs (no need to expand) "
+								. "(defaultProto: $protoDesc , wgServer: $server, "
+								. "wgCanonicalServer: $canServer, current request protocol: $mode )"
+						);
+						$retval[] = array(
+							'https://example.com', 'https://example.com',
+							$defaultProto, $server, $canServer, $httpsMode,
+							"Testing fully qualified https URLs (no need to expand) "
+								. "(defaultProto: $protoDesc , wgServer: $server, "
+								. "wgCanonicalServer: $canServer, current request protocol: $mode )"
+						);
+						# Would be nice to support this, see fixme on wfExpandUrl()
+						$retval[] = array(
+							"wiki/FooBar", 'wiki/FooBar',
+							$defaultProto, $server, $canServer, $httpsMode,
+							"Test non-expandable relative URLs (defaultProto: $protoDesc, "
+								. "wgServer: $server, wgCanonicalServer: $canServer, "
+								. "current request protocol: $mode )"
+						);
+
+						// Determine expected protocol
+						if ( $protoDesc == 'protocol-relative' ) {
+							$p = '';
+						} elseif ( $protoDesc == 'current' ) {
+							$p = "$mode:";
+						} elseif ( $protoDesc == 'canonical' ) {
+							$p = "$canServerMode:";
+						} else {
+							$p = $protoDesc . ':';
+						}
+						// Determine expected server name
+						if ( $protoDesc == 'canonical' ) {
+							$srv = $canServer;
+						} elseif ( $serverDesc == 'protocol-relative' ) {
+							$srv = $p . $server;
+						} else {
+							$srv = $server;
+						}
+
+						$retval[] = array(
+							"$p//wikipedia.org", '//wikipedia.org',
+							$defaultProto, $server, $canServer, $httpsMode,
+							"Test protocol-relative URL (defaultProto: $protoDesc, "
+								. "wgServer: $server, wgCanonicalServer: $canServer, "
+								. "current request protocol: $mode )"
+						);
+						$retval[] = array(
+							"$srv/wiki/FooBar",
+							'/wiki/FooBar',
+							$defaultProto,
+							$server,
+							$canServer,
+							$httpsMode,
+							"Testing expanding URL beginning with / (defaultProto: $protoDesc, "
+								. "wgServer: $server, wgCanonicalServer: $canServer, "
+								. "current request protocol: $mode )"
+						);
+					}
+				}
+			}
+		}
+
+		return $retval;
+	}
+}
diff --git a/tests/phpunit/includes/GlobalFunctions/wfGetCallerTest.php b/tests/phpunit/includes/GlobalFunctions/wfGetCallerTest.php
new file mode 100644
index 00000000..bb2b33fe
--- /dev/null
+++ b/tests/phpunit/includes/GlobalFunctions/wfGetCallerTest.php
@@ -0,0 +1,46 @@
+<?php
+
+/**
+ * @group GlobalFunctions
+ * @covers ::wfGetCaller
+ */
+class WfGetCallerTest extends MediaWikiTestCase {
+	public function testZero() {
+		$this->assertEquals( __METHOD__, wfGetCaller( 1 ) );
+	}
+
+	function callerOne() {
+		return wfGetCaller();
+	}
+
+	public function testOne() {
+		$this->assertEquals( 'WfGetCallerTest::testOne', self::callerOne() );
+	}
+
+	function intermediateFunction( $level = 2, $n = 0 ) {
+		if ( $n > 0 ) {
+			return self::intermediateFunction( $level, $n - 1 );
+		}
+
+		return wfGetCaller( $level );
+	}
+
+	public function testTwo() {
+		$this->assertEquals( 'WfGetCallerTest::testTwo', self::intermediateFunction() );
+	}
+
+	public function testN() {
+		$this->assertEquals( 'WfGetCallerTest::testN', self::intermediateFunction( 2, 0 ) );
+		$this->assertEquals(
+			'WfGetCallerTest::intermediateFunction',
+			self::intermediateFunction( 1, 0 )
+		);
+
+		for ( $i = 0; $i < 10; $i++ ) {
+			$this->assertEquals(
+				'WfGetCallerTest::intermediateFunction',
+				self::intermediateFunction( $i + 1, $i )
+			);
+		}
+	}
+}
diff --git a/tests/phpunit/includes/GlobalFunctions/wfParseUrlTest.php b/tests/phpunit/includes/GlobalFunctions/wfParseUrlTest.php
new file mode 100644
index 00000000..232fa922
--- /dev/null
+++ b/tests/phpunit/includes/GlobalFunctions/wfParseUrlTest.php
@@ -0,0 +1,157 @@
+<?php
+/**
+ * Copyright © 2013 Alexandre Emsenhuber
+ *
+ * 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
+ */
+
+/**
+ * @group GlobalFunctions
+ * @covers ::wfParseUrl
+ */
+class WfParseUrlTest extends MediaWikiTestCase {
+	protected function setUp() {
+		parent::setUp();
+
+		$this->setMwGlobals( 'wgUrlProtocols', array(
+			'//',
+			'http://',
+			'https://',
+			'file://',
+			'mailto:',
+		) );
+	}
+
+	/**
+	 * @dataProvider provideURLs
+	 */
+	public function testWfParseUrl( $url, $parts ) {
+		$this->assertEquals(
+			$parts,
+			wfParseUrl( $url )
+		);
+	}
+
+	/**
+	 * Provider of URLs for testing wfParseUrl()
+	 *
+	 * @return array
+	 */
+	public static function provideURLs() {
+		return array(
+			array(
+				'//example.org',
+				array(
+					'scheme' => '',
+					'delimiter' => '//',
+					'host' => 'example.org',
+				)
+			),
+			array(
+				'http://example.org',
+				array(
+					'scheme' => 'http',
+					'delimiter' => '://',
+					'host' => 'example.org',
+				)
+			),
+			array(
+				'https://example.org',
+				array(
+					'scheme' => 'https',
+					'delimiter' => '://',
+					'host' => 'example.org',
+				)
+			),
+			array(
+				'http://id:key@example.org:123/path?foo=bar#baz',
+				array(
+					'scheme' => 'http',
+					'delimiter' => '://',
+					'user' => 'id',
+					'pass' => 'key',
+					'host' => 'example.org',
+					'port' => 123,
+					'path' => '/path',
+					'query' => 'foo=bar',
+					'fragment' => 'baz',
+				)
+			),
+			array(
+				'file://example.org/etc/php.ini',
+				array(
+					'scheme' => 'file',
+					'delimiter' => '://',
+					'host' => 'example.org',
+					'path' => '/etc/php.ini',
+				)
+			),
+			array(
+				'file:///etc/php.ini',
+				array(
+					'scheme' => 'file',
+					'delimiter' => '://',
+					'host' => '',
+					'path' => '/etc/php.ini',
+				)
+			),
+			array(
+				'file:///c:/',
+				array(
+					'scheme' => 'file',
+					'delimiter' => '://',
+					'host' => '',
+					'path' => '/c:/',
+				)
+			),
+			array(
+				'mailto:id@example.org',
+				array(
+					'scheme' => 'mailto',
+					'delimiter' => ':',
+					'host' => 'id@example.org',
+					'path' => '',
+				)
+			),
+			array(
+				'mailto:id@example.org?subject=Foo',
+				array(
+					'scheme' => 'mailto',
+					'delimiter' => ':',
+					'host' => 'id@example.org',
+					'path' => '',
+					'query' => 'subject=Foo',
+				)
+			),
+			array(
+				'mailto:?subject=Foo',
+				array(
+					'scheme' => 'mailto',
+					'delimiter' => ':',
+					'host' => '',
+					'path' => '',
+					'query' => 'subject=Foo',
+				)
+			),
+			array(
+				'invalid://test/',
+				false
+			),
+		);
+	}
+}
diff --git a/tests/phpunit/includes/GlobalFunctions/wfRemoveDotSegmentsTest.php b/tests/phpunit/includes/GlobalFunctions/wfRemoveDotSegmentsTest.php
new file mode 100644
index 00000000..1faad52a
--- /dev/null
+++ b/tests/phpunit/includes/GlobalFunctions/wfRemoveDotSegmentsTest.php
@@ -0,0 +1,93 @@
+<?php
+
+/**
+ * @group GlobalFunctions
+ * @covers ::wfRemoveDotSegments
+ */
+class WfRemoveDotSegmentsTest extends MediaWikiTestCase {
+	/**
+	 * @dataProvider providePaths
+	 */
+	public function testWfRemoveDotSegments( $inputPath, $outputPath ) {
+		$this->assertEquals(
+			$outputPath,
+			wfRemoveDotSegments( $inputPath ),
+			"Testing $inputPath expands to $outputPath"
+		);
+	}
+
+	/**
+	 * Provider of URL paths for testing wfRemoveDotSegments()
+	 *
+	 * @return array
+	 */
+	public static function providePaths() {
+		return array(
+			array( '/a/b/c/./../../g', '/a/g' ),
+			array( 'mid/content=5/../6', 'mid/6' ),
+			array( '/a//../b', '/a/b' ),
+			array( '/.../a', '/.../a' ),
+			array( '.../a', '.../a' ),
+			array( '', '' ),
+			array( '/', '/' ),
+			array( '//', '//' ),
+			array( '.', '' ),
+			array( '..', '' ),
+			array( '...', '...' ),
+			array( '/.', '/' ),
+			array( '/..', '/' ),
+			array( './', '' ),
+			array( '../', '' ),
+			array( './a', 'a' ),
+			array( '../a', 'a' ),
+			array( '../../a', 'a' ),
+			array( '.././a', 'a' ),
+			array( './../a', 'a' ),
+			array( '././a', 'a' ),
+			array( '../../', '' ),
+			array( '.././', '' ),
+			array( './../', '' ),
+			array( '././', '' ),
+			array( '../..', '' ),
+			array( '../.', '' ),
+			array( './..', '' ),
+			array( './.', '' ),
+			array( '/../../a', '/a' ),
+			array( '/.././a', '/a' ),
+			array( '/./../a', '/a' ),
+			array( '/././a', '/a' ),
+			array( '/../../', '/' ),
+			array( '/.././', '/' ),
+			array( '/./../', '/' ),
+			array( '/././', '/' ),
+			array( '/../..', '/' ),
+			array( '/../.', '/' ),
+			array( '/./..', '/' ),
+			array( '/./.', '/' ),
+			array( 'b/../../a', '/a' ),
+			array( 'b/.././a', '/a' ),
+			array( 'b/./../a', '/a' ),
+			array( 'b/././a', 'b/a' ),
+			array( 'b/../../', '/' ),
+			array( 'b/.././', '/' ),
+			array( 'b/./../', '/' ),
+			array( 'b/././', 'b/' ),
+			array( 'b/../..', '/' ),
+			array( 'b/../.', '/' ),
+			array( 'b/./..', '/' ),
+			array( 'b/./.', 'b/' ),
+			array( '/b/../../a', '/a' ),
+			array( '/b/.././a', '/a' ),
+			array( '/b/./../a', '/a' ),
+			array( '/b/././a', '/b/a' ),
+			array( '/b/../../', '/' ),
+			array( '/b/.././', '/' ),
+			array( '/b/./../', '/' ),
+			array( '/b/././', '/b/' ),
+			array( '/b/../..', '/' ),
+			array( '/b/../.', '/' ),
+			array( '/b/./..', '/' ),
+			array( '/b/./.', '/b/' ),
+		);
+	}
+}
diff --git a/tests/phpunit/includes/GlobalFunctions/wfShellExecTest.php b/tests/phpunit/includes/GlobalFunctions/wfShellExecTest.php
new file mode 100644
index 00000000..fcd26f54
--- /dev/null
+++ b/tests/phpunit/includes/GlobalFunctions/wfShellExecTest.php
@@ -0,0 +1,20 @@
+<?php
+
+/**
+ * @group GlobalFunctions
+ * @covers ::wfShellExec
+ */
+class WfShellExecTest extends MediaWikiTestCase {
+	public function testBug67870() {
+		$command = wfIsWindows()
+			// 333 = 331 + CRLF
+			? ( 'for /l %i in (1, 1, 1001) do @echo ' . str_repeat( '*', 331 ) )
+			: 'printf "%-333333s" "*"';
+
+		// Test several times because it involves a race condition that may randomly succeed or fail
+		for ( $i = 0; $i < 10; $i++ ) {
+			$output = wfShellExec( $command );
+			$this->assertEquals( 333333, strlen( $output ) );
+		}
+	}
+}
diff --git a/tests/phpunit/includes/GlobalFunctions/wfShorthandToIntegerTest.php b/tests/phpunit/includes/GlobalFunctions/wfShorthandToIntegerTest.php
new file mode 100644
index 00000000..67284d27
--- /dev/null
+++ b/tests/phpunit/includes/GlobalFunctions/wfShorthandToIntegerTest.php
@@ -0,0 +1,31 @@
+<?php
+
+/**
+ * @group GlobalFunctions
+ * @covers ::wfShorthandToInteger
+ */
+class WfShorthandToIntegerTest extends MediaWikiTestCase {
+	/**
+	 * @dataProvider provideABunchOfShorthands
+	 */
+	public function testWfShorthandToInteger( $input, $output, $description ) {
+		$this->assertEquals(
+			wfShorthandToInteger( $input ),
+			$output,
+			$description
+		);
+	}
+
+	public static function provideABunchOfShorthands() {
+		return array(
+			array( '', -1, 'Empty string' ),
+			array( '     ', -1, 'String of spaces' ),
+			array( '1G', 1024 * 1024 * 1024, 'One gig uppercased' ),
+			array( '1g', 1024 * 1024 * 1024, 'One gig lowercased' ),
+			array( '1M', 1024 * 1024, 'One meg uppercased' ),
+			array( '1m', 1024 * 1024, 'One meg lowercased' ),
+			array( '1K', 1024, 'One kb uppercased' ),
+			array( '1k', 1024, 'One kb lowercased' ),
+		);
+	}
+}
diff --git a/tests/phpunit/includes/GlobalFunctions/wfTimestampTest.php b/tests/phpunit/includes/GlobalFunctions/wfTimestampTest.php
new file mode 100644
index 00000000..bea496c4
--- /dev/null
+++ b/tests/phpunit/includes/GlobalFunctions/wfTimestampTest.php
@@ -0,0 +1,196 @@
+<?php
+
+/**
+ * @group GlobalFunctions
+ * @covers ::wfTimestamp
+ */
+class WfTimestampTest extends MediaWikiTestCase {
+	/**
+	 * @dataProvider provideNormalTimestamps
+	 */
+	public function testNormalTimestamps( $input, $format, $output, $desc ) {
+		$this->assertEquals( $output, wfTimestamp( $format, $input ), $desc );
+	}
+
+	public static function provideNormalTimestamps() {
+		$t = gmmktime( 12, 34, 56, 1, 15, 2001 );
+
+		return array(
+			// TS_UNIX
+			array( $t, TS_MW, '20010115123456', 'TS_UNIX to TS_MW' ),
+			array( -30281104, TS_MW, '19690115123456', 'Negative TS_UNIX to TS_MW' ),
+			array( $t, TS_UNIX, 979562096, 'TS_UNIX to TS_UNIX' ),
+			array( $t, TS_DB, '2001-01-15 12:34:56', 'TS_UNIX to TS_DB' ),
+
+			array( $t, TS_ISO_8601_BASIC, '20010115T123456Z', 'TS_ISO_8601_BASIC to TS_DB' ),
+
+			// TS_MW
+			array( '20010115123456', TS_MW, '20010115123456', 'TS_MW to TS_MW' ),
+			array( '20010115123456', TS_UNIX, 979562096, 'TS_MW to TS_UNIX' ),
+			array( '20010115123456', TS_DB, '2001-01-15 12:34:56', 'TS_MW to TS_DB' ),
+			array( '20010115123456', TS_ISO_8601_BASIC, '20010115T123456Z', 'TS_MW to TS_ISO_8601_BASIC' ),
+
+			// TS_DB
+			array( '2001-01-15 12:34:56', TS_MW, '20010115123456', 'TS_DB to TS_MW' ),
+			array( '2001-01-15 12:34:56', TS_UNIX, 979562096, 'TS_DB to TS_UNIX' ),
+			array( '2001-01-15 12:34:56', TS_DB, '2001-01-15 12:34:56', 'TS_DB to TS_DB' ),
+			array(
+				'2001-01-15 12:34:56',
+				TS_ISO_8601_BASIC,
+				'20010115T123456Z',
+				'TS_DB to TS_ISO_8601_BASIC'
+			),
+
+			# rfc2822 section 3.3
+			array( '20010115123456', TS_RFC2822, 'Mon, 15 Jan 2001 12:34:56 GMT', 'TS_MW to TS_RFC2822' ),
+			array( 'Mon, 15 Jan 2001 12:34:56 GMT', TS_MW, '20010115123456', 'TS_RFC2822 to TS_MW' ),
+			array(
+				' Mon, 15 Jan 2001 12:34:56 GMT',
+				TS_MW,
+				'20010115123456',
+				'TS_RFC2822 with leading space to TS_MW'
+			),
+			array(
+				'15 Jan 2001 12:34:56 GMT',
+				TS_MW,
+				'20010115123456',
+				'TS_RFC2822 without optional day-of-week to TS_MW'
+			),
+
+			# FWS = ([*WSP CRLF] 1*WSP) / obs-FWS ; Folding white space
+			# obs-FWS = 1*WSP *(CRLF 1*WSP) ; Section 4.2
+			array( 'Mon, 15         Jan 2001 12:34:56 GMT', TS_MW, '20010115123456', 'TS_RFC2822 to TS_MW' ),
+
+			# WSP = SP / HTAB ; rfc2234
+			array(
+				"Mon, 15 Jan\x092001 12:34:56 GMT",
+				TS_MW,
+				'20010115123456',
+				'TS_RFC2822 with HTAB to TS_MW'
+			),
+			array(
+				"Mon, 15 Jan\x09 \x09  2001 12:34:56 GMT",
+				TS_MW,
+				'20010115123456',
+				'TS_RFC2822 with HTAB and SP to TS_MW'
+			),
+			array(
+				'Sun, 6 Nov 94 08:49:37 GMT',
+				TS_MW,
+				'19941106084937',
+				'TS_RFC2822 with obsolete year to TS_MW'
+			),
+		);
+	}
+
+	/**
+	 * This test checks wfTimestamp() with values outside.
+	 * It needs PHP 64 bits or PHP > 5.1.
+	 * See r74778 and bug 25451
+	 * @dataProvider provideOldTimestamps
+	 */
+	public function testOldTimestamps( $input, $outputType, $output, $message ) {
+		$timestamp = wfTimestamp( $outputType, $input );
+		if ( substr( $output, 0, 1 ) === '/' ) {
+			// Bug 64946: Day of the week calculations for very old
+			// timestamps varies from system to system.
+			$this->assertRegExp( $output, $timestamp, $message );
+		} else {
+			$this->assertEquals( $output, $timestamp, $message );
+		}
+	}
+
+	public static function provideOldTimestamps() {
+		return array(
+			array(
+				'19011213204554',
+				TS_RFC2822,
+				'Fri, 13 Dec 1901 20:45:54 GMT',
+				'Earliest time according to PHP documentation'
+			),
+			array( '20380119031407', TS_RFC2822, 'Tue, 19 Jan 2038 03:14:07 GMT', 'Latest 32 bit time' ),
+			array( '19011213204552', TS_UNIX, '-2147483648', 'Earliest 32 bit unix time' ),
+			array( '20380119031407', TS_UNIX, '2147483647', 'Latest 32 bit unix time' ),
+			array( '19011213204552', TS_RFC2822, 'Fri, 13 Dec 1901 20:45:52 GMT', 'Earliest 32 bit time' ),
+			array(
+				'19011213204551',
+				TS_RFC2822,
+				'Fri, 13 Dec 1901 20:45:51 GMT', 'Earliest 32 bit time - 1'
+			),
+			array( '20380119031408', TS_RFC2822, 'Tue, 19 Jan 2038 03:14:08 GMT', 'Latest 32 bit time + 1' ),
+			array( '19011212000000', TS_MW, '19011212000000', 'Convert to itself r74778#c10645' ),
+			array( '19011213204551', TS_UNIX, '-2147483649', 'Earliest 32 bit unix time - 1' ),
+			array( '20380119031408', TS_UNIX, '2147483648', 'Latest 32 bit unix time + 1' ),
+			array( '-2147483649', TS_MW, '19011213204551', '1901 negative unix time to MediaWiki' ),
+			array( '-5331871504', TS_MW, '18010115123456', '1801 negative unix time to MediaWiki' ),
+			array(
+				'0117-08-09 12:34:56',
+				TS_RFC2822,
+				'/, 09 Aug 0117 12:34:56 GMT$/',
+				'Death of Roman Emperor [[Trajan]]'
+			),
+
+			/* @todo FIXME: 00 to 101 years are taken as being in [1970-2069] */
+			array( '-58979923200', TS_RFC2822, '/, 01 Jan 0101 00:00:00 GMT$/', '1/1/101' ),
+			array( '-62135596800', TS_RFC2822, 'Mon, 01 Jan 0001 00:00:00 GMT', 'Year 1' ),
+
+			/* It is not clear if we should generate a year 0 or not
+			 * We are completely off RFC2822 requirement of year being
+			 * 1900 or later.
+			 */
+			array(
+				'-62142076800',
+				TS_RFC2822,
+				'Wed, 18 Oct 0000 00:00:00 GMT',
+				'ISO 8601:2004 [[year 0]], also called [[1 BC]]'
+			),
+		);
+	}
+
+	/**
+	 * The Resource Loader uses wfTimestamp() to convert timestamps
+	 * from If-Modified-Since header. Thus it must be able to parse all
+	 * rfc2616 date formats
+	 * @see http://www.w3.org/Protocols/rfc2616/rfc2616-sec3.html#sec3.3.1
+	 * @dataProvider provideHttpDates
+	 */
+	public function testHttpDate( $input, $output, $desc ) {
+		$this->assertEquals( $output, wfTimestamp( TS_MW, $input ), $desc );
+	}
+
+	public static function provideHttpDates() {
+		return array(
+			array( 'Sun, 06 Nov 1994 08:49:37 GMT', '19941106084937', 'RFC 822 date' ),
+			array( 'Sunday, 06-Nov-94 08:49:37 GMT', '19941106084937', 'RFC 850 date' ),
+			array( 'Sun Nov  6 08:49:37 1994', '19941106084937', "ANSI C's asctime() format" ),
+			// See http://www.squid-cache.org/mail-archive/squid-users/200307/0122.html and r77171
+			array(
+				'Mon, 22 Nov 2010 14:12:42 GMT; length=52626',
+				'20101122141242',
+				'Netscape extension to HTTP/1.0'
+			),
+		);
+	}
+
+	/**
+	 * There are a number of assumptions in our codebase where wfTimestamp()
+	 * should give the current date but it is not given a 0 there. See r71751 CR
+	 */
+	public function testTimestampParameter() {
+		$now = wfTimestamp( TS_UNIX );
+		// We check that wfTimestamp doesn't return false (error) and use a LessThan assert
+		// for the cases where the test is run in a second boundary.
+
+		$zero = wfTimestamp( TS_UNIX, 0 );
+		$this->assertNotEquals( false, $zero );
+		$this->assertLessThan( 5, $zero - $now );
+
+		$empty = wfTimestamp( TS_UNIX, '' );
+		$this->assertNotEquals( false, $empty );
+		$this->assertLessThan( 5, $empty - $now );
+
+		$null = wfTimestamp( TS_UNIX, null );
+		$this->assertNotEquals( false, $null );
+		$this->assertLessThan( 5, $null - $now );
+	}
+}
diff --git a/tests/phpunit/includes/GlobalFunctions/wfUrlencodeTest.php b/tests/phpunit/includes/GlobalFunctions/wfUrlencodeTest.php
new file mode 100644
index 00000000..d11668b7
--- /dev/null
+++ b/tests/phpunit/includes/GlobalFunctions/wfUrlencodeTest.php
@@ -0,0 +1,124 @@
+<?php
+
+/**
+ * The function only need a string parameter and might react to IIS7.0
+ *
+ * @group GlobalFunctions
+ * @covers ::wfUrlencode
+ */
+class WfUrlencodeTest extends MediaWikiTestCase {
+	#### TESTS ##############################################################
+
+	/**
+	 * @dataProvider provideURLS
+	 */
+	public function testEncodingUrlWith( $input, $expected ) {
+		$this->verifyEncodingFor( 'Apache', $input, $expected );
+	}
+
+	/**
+	 * @dataProvider provideURLS
+	 */
+	public function testEncodingUrlWithMicrosoftIis7( $input, $expected ) {
+		$this->verifyEncodingFor( 'Microsoft-IIS/7', $input, $expected );
+	}
+
+	#### HELPERS #############################################################
+
+	/**
+	 * Internal helper that actually run the test.
+	 * Called by the public methods testEncodingUrlWith...()
+	 *
+	 */
+	private function verifyEncodingFor( $server, $input, $expectations ) {
+		$expected = $this->extractExpect( $server, $expectations );
+
+		// save up global
+		$old = isset( $_SERVER['SERVER_SOFTWARE'] )
+			? $_SERVER['SERVER_SOFTWARE']
+			: null;
+		$_SERVER['SERVER_SOFTWARE'] = $server;
+		wfUrlencode( null );
+
+		// do the requested test
+		$this->assertEquals(
+			$expected,
+			wfUrlencode( $input ),
+			"Encoding '$input' for server '$server' should be '$expected'"
+		);
+
+		// restore global
+		if ( $old === null ) {
+			unset( $_SERVER['SERVER_SOFTWARE'] );
+		} else {
+			$_SERVER['SERVER_SOFTWARE'] = $old;
+		}
+		wfUrlencode( null );
+	}
+
+	/**
+	 * Interprets the provider array. Return expected value depending
+	 * the HTTP server name.
+	 */
+	private function extractExpect( $server, $expectations ) {
+		if ( is_string( $expectations ) ) {
+			return $expectations;
+		} elseif ( is_array( $expectations ) ) {
+			if ( !array_key_exists( $server, $expectations ) ) {
+				throw new MWException( __METHOD__ . " expectation does not have any "
+					. "value for server name $server. Check the provider array.\n" );
+			} else {
+				return $expectations[$server];
+			}
+		} else {
+			throw new MWException( __METHOD__ . " given invalid expectation for "
+				. "'$server'. Should be a string or an array( <http server name> => <string> ).\n" );
+		}
+	}
+
+	#### PROVIDERS ###########################################################
+
+	/**
+	 * Format is either:
+	 *   array( 'input', 'expected' );
+	 * Or:
+	 *   array( 'input',
+	 *       array( 'Apache', 'expected' ),
+	 *       array( 'Microsoft-IIS/7', 'expected' ),
+	 *    ),
+	 * If you want to add other HTTP server name, you will have to add a new
+	 * testing method much like the testEncodingUrlWith() method above.
+	 */
+	public static function provideURLS() {
+		return array(
+			### RFC 1738 chars
+			// + is not safe
+			array( '+', '%2B' ),
+			// & and = not safe in queries
+			array( '&', '%26' ),
+			array( '=', '%3D' ),
+
+			array( ':', array(
+				'Apache' => ':',
+				'Microsoft-IIS/7' => '%3A',
+			) ),
+
+			// remaining chars do not need encoding
+			array(
+				';@$-_.!*',
+				';@$-_.!*',
+			),
+
+			### Other tests
+			// slash remain unchanged. %2F seems to break things
+			array( '/', '/' ),
+
+			// Other 'funnies' chars
+			array( '[]', '%5B%5D' ),
+			array( '<>', '%3C%3E' ),
+
+			// Apostrophe is encoded
+			array( '\'', '%27' ),
+		);
+	}
+}