<?php

class LanguageTest extends LanguageClassesTestCase {
	/**
	 * @covers Language::convertDoubleWidth
	 * @covers Language::normalizeForSearch
	 */
	public function testLanguageConvertDoubleWidthToSingleWidth() {
		$this->assertEquals(
			"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
			$this->getLang()->normalizeForSearch(
				"０１２３４５６７８９ＡＢＣＤＥＦＧＨＩＪＫＬＭＮＯＰＱＲＳＴＵＶＷＸＹＺａｂｃｄｅｆｇｈｉｊｋｌｍｎｏｐｑｒｓｔｕｖｗｘｙｚ"
			),
			'convertDoubleWidth() with the full alphabet and digits'
		);
	}

	/**
	 * @dataProvider provideFormattableTimes
	 * @covers Language::formatTimePeriod
	 */
	public function testFormatTimePeriod( $seconds, $format, $expected, $desc ) {
		$this->assertEquals( $expected, $this->getLang()->formatTimePeriod( $seconds, $format ), $desc );
	}

	public static function provideFormattableTimes() {
		return array(
			array(
				9.45,
				array(),
				'9.5 s',
				'formatTimePeriod() rounding (<10s)'
			),
			array(
				9.45,
				array( 'noabbrevs' => true ),
				'9.5 seconds',
				'formatTimePeriod() rounding (<10s)'
			),
			array(
				9.95,
				array(),
				'10 s',
				'formatTimePeriod() rounding (<10s)'
			),
			array(
				9.95,
				array( 'noabbrevs' => true ),
				'10 seconds',
				'formatTimePeriod() rounding (<10s)'
			),
			array(
				59.55,
				array(),
				'1 min 0 s',
				'formatTimePeriod() rounding (<60s)'
			),
			array(
				59.55,
				array( 'noabbrevs' => true ),
				'1 minute 0 seconds',
				'formatTimePeriod() rounding (<60s)'
			),
			array(
				119.55,
				array(),
				'2 min 0 s',
				'formatTimePeriod() rounding (<1h)'
			),
			array(
				119.55,
				array( 'noabbrevs' => true ),
				'2 minutes 0 seconds',
				'formatTimePeriod() rounding (<1h)'
			),
			array(
				3599.55,
				array(),
				'1 h 0 min 0 s',
				'formatTimePeriod() rounding (<1h)'
			),
			array(
				3599.55,
				array( 'noabbrevs' => true ),
				'1 hour 0 minutes 0 seconds',
				'formatTimePeriod() rounding (<1h)'
			),
			array(
				7199.55,
				array(),
				'2 h 0 min 0 s',
				'formatTimePeriod() rounding (>=1h)'
			),
			array(
				7199.55,
				array( 'noabbrevs' => true ),
				'2 hours 0 minutes 0 seconds',
				'formatTimePeriod() rounding (>=1h)'
			),
			array(
				7199.55,
				'avoidseconds',
				'2 h 0 min',
				'formatTimePeriod() rounding (>=1h), avoidseconds'
			),
			array(
				7199.55,
				array( 'avoid' => 'avoidseconds', 'noabbrevs' => true ),
				'2 hours 0 minutes',
				'formatTimePeriod() rounding (>=1h), avoidseconds'
			),
			array(
				7199.55,
				'avoidminutes',
				'2 h 0 min',
				'formatTimePeriod() rounding (>=1h), avoidminutes'
			),
			array(
				7199.55,
				array( 'avoid' => 'avoidminutes', 'noabbrevs' => true ),
				'2 hours 0 minutes',
				'formatTimePeriod() rounding (>=1h), avoidminutes'
			),
			array(
				172799.55,
				'avoidseconds',
				'48 h 0 min',
				'formatTimePeriod() rounding (=48h), avoidseconds'
			),
			array(
				172799.55,
				array( 'avoid' => 'avoidseconds', 'noabbrevs' => true ),
				'48 hours 0 minutes',
				'formatTimePeriod() rounding (=48h), avoidseconds'
			),
			array(
				259199.55,
				'avoidminutes',
				'3 d 0 h',
				'formatTimePeriod() rounding (>48h), avoidminutes'
			),
			array(
				259199.55,
				array( 'avoid' => 'avoidminutes', 'noabbrevs' => true ),
				'3 days 0 hours',
				'formatTimePeriod() rounding (>48h), avoidminutes'
			),
			array(
				176399.55,
				'avoidseconds',
				'2 d 1 h 0 min',
				'formatTimePeriod() rounding (>48h), avoidseconds'
			),
			array(
				176399.55,
				array( 'avoid' => 'avoidseconds', 'noabbrevs' => true ),
				'2 days 1 hour 0 minutes',
				'formatTimePeriod() rounding (>48h), avoidseconds'
			),
			array(
				176399.55,
				'avoidminutes',
				'2 d 1 h',
				'formatTimePeriod() rounding (>48h), avoidminutes'
			),
			array(
				176399.55,
				array( 'avoid' => 'avoidminutes', 'noabbrevs' => true ),
				'2 days 1 hour',
				'formatTimePeriod() rounding (>48h), avoidminutes'
			),
			array(
				259199.55,
				'avoidseconds',
				'3 d 0 h 0 min',
				'formatTimePeriod() rounding (>48h), avoidseconds'
			),
			array(
				259199.55,
				array( 'avoid' => 'avoidseconds', 'noabbrevs' => true ),
				'3 days 0 hours 0 minutes',
				'formatTimePeriod() rounding (>48h), avoidseconds'
			),
			array(
				172801.55,
				'avoidseconds',
				'2 d 0 h 0 min',
				'formatTimePeriod() rounding, (>48h), avoidseconds'
			),
			array(
				172801.55,
				array( 'avoid' => 'avoidseconds', 'noabbrevs' => true ),
				'2 days 0 hours 0 minutes',
				'formatTimePeriod() rounding, (>48h), avoidseconds'
			),
			array(
				176460.55,
				array(),
				'2 d 1 h 1 min 1 s',
				'formatTimePeriod() rounding, recursion, (>48h)'
			),
			array(
				176460.55,
				array( 'noabbrevs' => true ),
				'2 days 1 hour 1 minute 1 second',
				'formatTimePeriod() rounding, recursion, (>48h)'
			),
		);
	}

	/**
	 * @covers Language::truncate
	 */
	public function testTruncate() {
		$this->assertEquals(
			"XXX",
			$this->getLang()->truncate( "1234567890", 0, 'XXX' ),
			'truncate prefix, len 0, small ellipsis'
		);

		$this->assertEquals(
			"12345XXX",
			$this->getLang()->truncate( "1234567890", 8, 'XXX' ),
			'truncate prefix, small ellipsis'
		);

		$this->assertEquals(
			"123456789",
			$this->getLang()->truncate( "123456789", 5, 'XXXXXXXXXXXXXXX' ),
			'truncate prefix, large ellipsis'
		);

		$this->assertEquals(
			"XXX67890",
			$this->getLang()->truncate( "1234567890", -8, 'XXX' ),
			'truncate suffix, small ellipsis'
		);

		$this->assertEquals(
			"123456789",
			$this->getLang()->truncate( "123456789", -5, 'XXXXXXXXXXXXXXX' ),
			'truncate suffix, large ellipsis'
		);
		$this->assertEquals(
			"123XXX",
			$this->getLang()->truncate( "123                ", 9, 'XXX' ),
			'truncate prefix, with spaces'
		);
		$this->assertEquals(
			"12345XXX",
			$this->getLang()->truncate( "12345            8", 11, 'XXX' ),
			'truncate prefix, with spaces and non-space ending'
		);
		$this->assertEquals(
			"XXX234",
			$this->getLang()->truncate( "1              234", -8, 'XXX' ),
			'truncate suffix, with spaces'
		);
		$this->assertEquals(
			"12345XXX",
			$this->getLang()->truncate( "1234567890", 5, 'XXX', false ),
			'truncate without adjustment'
		);
	}

	/**
	 * @dataProvider provideHTMLTruncateData
	 * @covers Language::truncateHTML
	 */
	public function testTruncateHtml( $len, $ellipsis, $input, $expected ) {
		// Actual HTML...
		$this->assertEquals(
			$expected,
			$this->getLang()->truncateHTML( $input, $len, $ellipsis )
		);
	}

	/**
	 * @return array Format is ($len, $ellipsis, $input, $expected)
	 */
	public static function provideHTMLTruncateData() {
		return array(
			array( 0, 'XXX', "1234567890", "XXX" ),
			array( 8, 'XXX', "1234567890", "12345XXX" ),
			array( 5, 'XXXXXXXXXXXXXXX', '1234567890', "1234567890" ),
			array( 2, '***',
				'<p><span style="font-weight:bold;"></span></p>',
				'<p><span style="font-weight:bold;"></span></p>',
			),
			array( 2, '***',
				'<p><span style="font-weight:bold;">123456789</span></p>',
				'<p><span style="font-weight:bold;">***</span></p>',
			),
			array( 2, '***',
				'<p><span style="font-weight:bold;">&nbsp;23456789</span></p>',
				'<p><span style="font-weight:bold;">***</span></p>',
			),
			array( 3, '***',
				'<p><span style="font-weight:bold;">123456789</span></p>',
				'<p><span style="font-weight:bold;">***</span></p>',
			),
			array( 4, '***',
				'<p><span style="font-weight:bold;">123456789</span></p>',
				'<p><span style="font-weight:bold;">1***</span></p>',
			),
			array( 5, '***',
				'<tt><span style="font-weight:bold;">123456789</span></tt>',
				'<tt><span style="font-weight:bold;">12***</span></tt>',
			),
			array( 6, '***',
				'<p><a href="www.mediawiki.org">123456789</a></p>',
				'<p><a href="www.mediawiki.org">123***</a></p>',
			),
			array( 6, '***',
				'<p><a href="www.mediawiki.org">12&nbsp;456789</a></p>',
				'<p><a href="www.mediawiki.org">12&nbsp;***</a></p>',
			),
			array( 7, '***',
				'<small><span style="font-weight:bold;">123<p id="#moo">456</p>789</span></small>',
				'<small><span style="font-weight:bold;">123<p id="#moo">4***</p></span></small>',
			),
			array( 8, '***',
				'<div><span style="font-weight:bold;">123<span>4</span>56789</span></div>',
				'<div><span style="font-weight:bold;">123<span>4</span>5***</span></div>',
			),
			array( 9, '***',
				'<p><table style="font-weight:bold;"><tr><td>123456789</td></tr></table></p>',
				'<p><table style="font-weight:bold;"><tr><td>123456789</td></tr></table></p>',
			),
			array( 10, '***',
				'<p><font style="font-weight:bold;">123456789</font></p>',
				'<p><font style="font-weight:bold;">123456789</font></p>',
			),
		);
	}

	/**
	 * Test Language::isWellFormedLanguageTag()
	 * @dataProvider provideWellFormedLanguageTags
	 * @covers Language::isWellFormedLanguageTag
	 */
	public function testWellFormedLanguageTag( $code, $message = '' ) {
		$this->assertTrue(
			Language::isWellFormedLanguageTag( $code ),
			"validating code $code $message"
		);
	}

	/**
	 * The test cases are based on the tests in the GaBuZoMeu parser
	 * written by Stéphane Bortzmeyer <bortzmeyer@nic.fr>
	 * and distributed as free software, under the GNU General Public Licence.
	 * http://www.bortzmeyer.org/gabuzomeu-parsing-language-tags.html
	 */
	public static function provideWellFormedLanguageTags() {
		return array(
			array( 'fr', 'two-letter code' ),
			array( 'fr-latn', 'two-letter code with lower case script code' ),
			array( 'fr-Latn-FR', 'two-letter code with title case script code and uppercase country code' ),
			array( 'fr-Latn-419', 'two-letter code with title case script code and region number' ),
			array( 'fr-FR', 'two-letter code with uppercase' ),
			array( 'ax-TZ', 'Not in the registry, but well-formed' ),
			array( 'fr-shadok', 'two-letter code with variant' ),
			array( 'fr-y-myext-myext2', 'non-x singleton' ),
			array( 'fra-Latn', 'ISO 639 can be 3-letters' ),
			array( 'fra', 'three-letter language code' ),
			array( 'fra-FX', 'three-letter language code with country code' ),
			array( 'i-klingon', 'grandfathered with singleton' ),
			array( 'I-kLINgon', 'tags are case-insensitive...' ),
			array( 'no-bok', 'grandfathered without singleton' ),
			array( 'i-enochian', 'Grandfathered' ),
			array( 'x-fr-CH', 'private use' ),
			array( 'es-419', 'two-letter code with region number' ),
			array( 'en-Latn-GB-boont-r-extended-sequence-x-private', 'weird, but well-formed' ),
			array( 'ab-x-abc-x-abc', 'anything goes after x' ),
			array( 'ab-x-abc-a-a', 'anything goes after x, including several non-x singletons' ),
			array( 'i-default', 'grandfathered' ),
			array( 'abcd-Latn', 'Language of 4 chars reserved for future use' ),
			array( 'AaBbCcDd-x-y-any-x', 'Language of 5-8 chars, registered' ),
			array( 'de-CH-1901', 'with country and year' ),
			array( 'en-US-x-twain', 'with country and singleton' ),
			array( 'zh-cmn', 'three-letter variant' ),
			array( 'zh-cmn-Hant', 'three-letter variant and script' ),
			array( 'zh-cmn-Hant-HK', 'three-letter variant, script and country' ),
			array( 'xr-p-lze', 'Extension' ),
		);
	}

	/**
	 * Negative test for Language::isWellFormedLanguageTag()
	 * @dataProvider provideMalformedLanguageTags
	 * @covers Language::isWellFormedLanguageTag
	 */
	public function testMalformedLanguageTag( $code, $message = '' ) {
		$this->assertFalse(
			Language::isWellFormedLanguageTag( $code ),
			"validating that code $code is a malformed language tag - $message"
		);
	}

	/**
	 * The test cases are based on the tests in the GaBuZoMeu parser
	 * written by Stéphane Bortzmeyer <bortzmeyer@nic.fr>
	 * and distributed as free software, under the GNU General Public Licence.
	 * http://www.bortzmeyer.org/gabuzomeu-parsing-language-tags.html
	 */
	public static function provideMalformedLanguageTags() {
		return array(
			array( 'f', 'language too short' ),
			array( 'f-Latn', 'language too short with script' ),
			array( 'xr-lxs-qut', 'variants too short' ), # extlangS
			array( 'fr-Latn-F', 'region too short' ),
			array( 'a-value', 'language too short with region' ),
			array( 'tlh-a-b-foo', 'valid three-letter with wrong variant' ),
			array(
				'i-notexist',
				'grandfathered but not registered: invalid, even if we only test well-formedness'
			),
			array( 'abcdefghi-012345678', 'numbers too long' ),
			array( 'ab-abc-abc-abc-abc', 'invalid extensions' ),
			array( 'ab-abcd-abc', 'invalid extensions' ),
			array( 'ab-ab-abc', 'invalid extensions' ),
			array( 'ab-123-abc', 'invalid extensions' ),
			array( 'a-Hant-ZH', 'short language with valid extensions' ),
			array( 'a1-Hant-ZH', 'invalid character in language' ),
			array( 'ab-abcde-abc', 'invalid extensions' ),
			array( 'ab-1abc-abc', 'invalid characters in extensions' ),
			array( 'ab-ab-abcd', 'invalid order of extensions' ),
			array( 'ab-123-abcd', 'invalid order of extensions' ),
			array( 'ab-abcde-abcd', 'invalid extensions' ),
			array( 'ab-1abc-abcd', 'invalid characters in extensions' ),
			array( 'ab-a-b', 'extensions too short' ),
			array( 'ab-a-x', 'extensions too short, even with singleton' ),
			array( 'ab--ab', 'two separators' ),
			array( 'ab-abc-', 'separator in the end' ),
			array( '-ab-abc', 'separator in the beginning' ),
			array( 'abcd-efg', 'language too long' ),
			array( 'aabbccddE', 'tag too long' ),
			array( 'pa_guru', 'A tag with underscore is invalid in strict mode' ),
			array( 'de-f', 'subtag too short' ),
		);
	}

	/**
	 * Negative test for Language::isWellFormedLanguageTag()
	 * @covers Language::isWellFormedLanguageTag
	 */
	public function testLenientLanguageTag() {
		$this->assertTrue(
			Language::isWellFormedLanguageTag( 'pa_guru', true ),
			'pa_guru is a well-formed language tag in lenient mode'
		);
	}

	/**
	 * Test Language::isValidBuiltInCode()
	 * @dataProvider provideLanguageCodes
	 * @covers Language::isValidBuiltInCode
	 */
	public function testBuiltInCodeValidation( $code, $expected, $message = '' ) {
		$this->assertEquals( $expected,
			(bool)Language::isValidBuiltInCode( $code ),
			"validating code $code $message"
		);
	}

	public static function provideLanguageCodes() {
		return array(
			array( 'fr', true, 'Two letters, minor case' ),
			array( 'EN', false, 'Two letters, upper case' ),
			array( 'tyv', true, 'Three letters' ),
			array( 'tokipona', true, 'long language code' ),
			array( 'be-tarask', true, 'With dash' ),
			array( 'be-x-old', true, 'With extension (two dashes)' ),
			array( 'be_tarask', false, 'Reject underscores' ),
		);
	}

	/**
	 * Test Language::isKnownLanguageTag()
	 * @dataProvider provideKnownLanguageTags
	 * @covers Language::isKnownLanguageTag
	 */
	public function testKnownLanguageTag( $code, $message = '' ) {
		$this->assertTrue(
			(bool)Language::isKnownLanguageTag( $code ),
			"validating code $code - $message"
		);
	}

	public static function provideKnownLanguageTags() {
		return array(
			array( 'fr', 'simple code' ),
			array( 'bat-smg', 'an MW legacy tag' ),
			array( 'sgs', 'an internal standard MW name, for which a legacy tag is used externally' ),
		);
	}

	/**
	 * @covers Language::isKnownLanguageTag
	 */
	public function testKnownCldrLanguageTag() {
		if ( !class_exists( 'LanguageNames' ) ) {
			$this->markTestSkipped( 'The LanguageNames class is not available. '
				. 'The CLDR extension is probably not installed.' );
		}

		$this->assertTrue(
			(bool)Language::isKnownLanguageTag( 'pal' ),
			'validating code "pal" an ancient language, which probably will '
				. 'not appear in Names.php, but appears in CLDR in English'
		);
	}

	/**
	 * Negative tests for Language::isKnownLanguageTag()
	 * @dataProvider provideUnKnownLanguageTags
	 * @covers Language::isKnownLanguageTag
	 */
	public function testUnknownLanguageTag( $code, $message = '' ) {
		$this->assertFalse(
			(bool)Language::isKnownLanguageTag( $code ),
			"checking that code $code is invalid - $message"
		);
	}

	public static function provideUnknownLanguageTags() {
		return array(
			array( 'mw', 'non-existent two-letter code' ),
			array( 'foo"<bar', 'very invalid language code' ),
		);
	}

	/**
	 * Test too short timestamp
	 * @expectedException MWException
	 * @covers Language::sprintfDate
	 */
	public function testSprintfDateTooShortTimestamp() {
		$this->getLang()->sprintfDate( 'xiY', '1234567890123' );
	}

	/**
	 * Test too long timestamp
	 * @expectedException MWException
	 * @covers Language::sprintfDate
	 */
	public function testSprintfDateTooLongTimestamp() {
		$this->getLang()->sprintfDate( 'xiY', '123456789012345' );
	}

	/**
	 * Test too short timestamp
	 * @expectedException MWException
	 * @covers Language::sprintfDate
	 */
	public function testSprintfDateNotAllDigitTimestamp() {
		$this->getLang()->sprintfDate( 'xiY', '-1234567890123' );
	}

	/**
	 * @dataProvider provideSprintfDateSamples
	 * @covers Language::sprintfDate
	 */
	public function testSprintfDate( $format, $ts, $expected, $msg ) {
		$ttl = null;
		$this->assertEquals(
			$expected,
			$this->getLang()->sprintfDate( $format, $ts, null, $ttl ),
			"sprintfDate('$format', '$ts'): $msg"
		);
		if ( $ttl ) {
			$dt = new DateTime( $ts );
			$lastValidTS = $dt->add( new DateInterval( 'PT' . ( $ttl - 1 ) . 'S' ) )->format( 'YmdHis' );
			$this->assertEquals(
				$expected,
				$this->getLang()->sprintfDate( $format, $lastValidTS, null ),
				"sprintfDate('$format', '$ts'): TTL $ttl too high (output was different at $lastValidTS)"
			);
		} else {
			// advance the time enough to make all of the possible outputs different (except possibly L)
			$dt = new DateTime( $ts );
			$newTS = $dt->add( new DateInterval( 'P1Y1M8DT13H1M1S' ) )->format( 'YmdHis' );
			$this->assertEquals(
				$expected,
				$this->getLang()->sprintfDate( $format, $newTS, null ),
				"sprintfDate('$format', '$ts'): Missing TTL (output was different at $newTS)"
			);
		}
	}

	/**
	 * sprintfDate should always use UTC when no zone is given.
	 * @dataProvider provideSprintfDateSamples
	 * @covers Language::sprintfDate
	 */
	public function testSprintfDateNoZone( $format, $ts, $expected, $ignore, $msg ) {
		$oldTZ = date_default_timezone_get();
		$res = date_default_timezone_set( 'Asia/Seoul' );
		if ( !$res ) {
			$this->markTestSkipped( "Error setting Timezone" );
		}

		$this->assertEquals(
			$expected,
			$this->getLang()->sprintfDate( $format, $ts ),
			"sprintfDate('$format', '$ts'): $msg"
		);

		date_default_timezone_set( $oldTZ );
	}

	/**
	 * sprintfDate should use passed timezone
	 * @dataProvider provideSprintfDateSamples
	 * @covers Language::sprintfDate
	 */
	public function testSprintfDateTZ( $format, $ts, $ignore, $expected, $msg ) {
		$tz = new DateTimeZone( 'Asia/Seoul' );
		if ( !$tz ) {
			$this->markTestSkipped( "Error getting Timezone" );
		}

		$this->assertEquals(
			$expected,
			$this->getLang()->sprintfDate( $format, $ts, $tz ),
			"sprintfDate('$format', '$ts', 'Asia/Seoul'): $msg"
		);
	}

	public static function provideSprintfDateSamples() {
		return array(
			array(
				'xiY',
				'20111212000000',
				'1390', // note because we're testing English locale we get Latin-standard digits
				'1390',
				'Iranian calendar full year'
			),
			array(
				'xiy',
				'20111212000000',
				'90',
				'90',
				'Iranian calendar short year'
			),
			array(
				'o',
				'20120101235000',
				'2011',
				'2011',
				'ISO 8601 (week) year'
			),
			array(
				'W',
				'20120101235000',
				'52',
				'52',
				'Week number'
			),
			array(
				'W',
				'20120102235000',
				'1',
				'1',
				'Week number'
			),
			array(
				'o-\\WW-N',
				'20091231235000',
				'2009-W53-4',
				'2009-W53-4',
				'leap week'
			),
			// What follows is mostly copied from
			// https://www.mediawiki.org/wiki/Help:Extension:ParserFunctions#.23time
			array(
				'Y',
				'20120102090705',
				'2012',
				'2012',
				'Full year'
			),
			array(
				'y',
				'20120102090705',
				'12',
				'12',
				'2 digit year'
			),
			array(
				'L',
				'20120102090705',
				'1',
				'1',
				'Leap year'
			),
			array(
				'n',
				'20120102090705',
				'1',
				'1',
				'Month index, not zero pad'
			),
			array(
				'N',
				'20120102090705',
				'01',
				'01',
				'Month index. Zero pad'
			),
			array(
				'M',
				'20120102090705',
				'Jan',
				'Jan',
				'Month abbrev'
			),
			array(
				'F',
				'20120102090705',
				'January',
				'January',
				'Full month'
			),
			array(
				'xg',
				'20120102090705',
				'January',
				'January',
				'Genitive month name (same in EN)'
			),
			array(
				'j',
				'20120102090705',
				'2',
				'2',
				'Day of month (not zero pad)'
			),
			array(
				'd',
				'20120102090705',
				'02',
				'02',
				'Day of month (zero-pad)'
			),
			array(
				'z',
				'20120102090705',
				'1',
				'1',
				'Day of year (zero-indexed)'
			),
			array(
				'D',
				'20120102090705',
				'Mon',
				'Mon',
				'Day of week (abbrev)'
			),
			array(
				'l',
				'20120102090705',
				'Monday',
				'Monday',
				'Full day of week'
			),
			array(
				'N',
				'20120101090705',
				'7',
				'7',
				'Day of week (Mon=1, Sun=7)'
			),
			array(
				'w',
				'20120101090705',
				'0',
				'0',
				'Day of week (Sun=0, Sat=6)'
			),
			array(
				'N',
				'20120102090705',
				'1',
				'1',
				'Day of week'
			),
			array(
				'a',
				'20120102090705',
				'am',
				'am',
				'am vs pm'
			),
			array(
				'A',
				'20120102120000',
				'PM',
				'PM',
				'AM vs PM'
			),
			array(
				'a',
				'20120102000000',
				'am',
				'am',
				'AM vs PM'
			),
			array(
				'g',
				'20120102090705',
				'9',
				'9',
				'12 hour, not Zero'
			),
			array(
				'h',
				'20120102090705',
				'09',
				'09',
				'12 hour, zero padded'
			),
			array(
				'G',
				'20120102090705',
				'9',
				'9',
				'24 hour, not zero'
			),
			array(
				'H',
				'20120102090705',
				'09',
				'09',
				'24 hour, zero'
			),
			array(
				'H',
				'20120102110705',
				'11',
				'11',
				'24 hour, zero'
			),
			array(
				'i',
				'20120102090705',
				'07',
				'07',
				'Minutes'
			),
			array(
				's',
				'20120102090705',
				'05',
				'05',
				'seconds'
			),
			array(
				'U',
				'20120102090705',
				'1325495225',
				'1325462825',
				'unix time'
			),
			array(
				't',
				'20120102090705',
				'31',
				'31',
				'Days in current month'
			),
			array(
				'c',
				'20120102090705',
				'2012-01-02T09:07:05+00:00',
				'2012-01-02T09:07:05+09:00',
				'ISO 8601 timestamp'
			),
			array(
				'r',
				'20120102090705',
				'Mon, 02 Jan 2012 09:07:05 +0000',
				'Mon, 02 Jan 2012 09:07:05 +0900',
				'RFC 5322'
			),
			array(
				'e',
				'20120102090705',
				'UTC',
				'Asia/Seoul',
				'Timezone identifier'
			),
			array(
				'I',
				'19880602090705',
				'0',
				'1',
				'DST indicator'
			),
			array(
				'O',
				'20120102090705',
				'+0000',
				'+0900',
				'Timezone offset'
			),
			array(
				'P',
				'20120102090705',
				'+00:00',
				'+09:00',
				'Timezone offset with colon'
			),
			array(
				'T',
				'20120102090705',
				'UTC',
				'KST',
				'Timezone abbreviation'
			),
			array(
				'Z',
				'20120102090705',
				'0',
				'32400',
				'Timezone offset in seconds'
			),
			array(
				'xmj xmF xmn xmY',
				'20120102090705',
				'7 Safar 2 1433',
				'7 Safar 2 1433',
				'Islamic'
			),
			array(
				'xij xiF xin xiY',
				'20120102090705',
				'12 Dey 10 1390',
				'12 Dey 10 1390',
				'Iranian'
			),
			array(
				'xjj xjF xjn xjY',
				'20120102090705',
				'7 Tevet 4 5772',
				'7 Tevet 4 5772',
				'Hebrew'
			),
			array(
				'xjt',
				'20120102090705',
				'29',
				'29',
				'Hebrew number of days in month'
			),
			array(
				'xjx',
				'20120102090705',
				'Tevet',
				'Tevet',
				'Hebrew genitive month name (No difference in EN)'
			),
			array(
				'xkY',
				'20120102090705',
				'2555',
				'2555',
				'Thai year'
			),
			array(
				'xoY',
				'20120102090705',
				'101',
				'101',
				'Minguo'
			),
			array(
				'xtY',
				'20120102090705',
				'平成24',
				'平成24',
				'nengo'
			),
			array(
				'xrxkYY',
				'20120102090705',
				'MMDLV2012',
				'MMDLV2012',
				'Roman numerals'
			),
			array(
				'xhxjYY',
				'20120102090705',
				'ה\'תשע"ב2012',
				'ה\'תשע"ב2012',
				'Hebrew numberals'
			),
			array(
				'xnY',
				'20120102090705',
				'2012',
				'2012',
				'Raw numerals (doesn\'t mean much in EN)'
			),
			array(
				'[[Y "(yea"\\r)]] \\"xx\\"',
				'20120102090705',
				'[[2012 (year)]] "x"',
				'[[2012 (year)]] "x"',
				'Various escaping'
			),

		);
	}

	/**
	 * @dataProvider provideFormatSizes
	 * @covers Language::formatSize
	 */
	public function testFormatSize( $size, $expected, $msg ) {
		$this->assertEquals(
			$expected,
			$this->getLang()->formatSize( $size ),
			"formatSize('$size'): $msg"
		);
	}

	public static function provideFormatSizes() {
		return array(
			array(
				0,
				"0 B",
				"Zero bytes"
			),
			array(
				1024,
				"1 KB",
				"1 kilobyte"
			),
			array(
				1024 * 1024,
				"1 MB",
				"1,024 megabytes"
			),
			array(
				1024 * 1024 * 1024,
				"1 GB",
				"1 gigabytes"
			),
			array(
				pow( 1024, 4 ),
				"1 TB",
				"1 terabyte"
			),
			array(
				pow( 1024, 5 ),
				"1 PB",
				"1 petabyte"
			),
			array(
				pow( 1024, 6 ),
				"1 EB",
				"1,024 exabyte"
			),
			array(
				pow( 1024, 7 ),
				"1 ZB",
				"1 zetabyte"
			),
			array(
				pow( 1024, 8 ),
				"1 YB",
				"1 yottabyte"
			),
			// How big!? THIS BIG!
		);
	}

	/**
	 * @dataProvider provideFormatBitrate
	 * @covers Language::formatBitrate
	 */
	public function testFormatBitrate( $bps, $expected, $msg ) {
		$this->assertEquals(
			$expected,
			$this->getLang()->formatBitrate( $bps ),
			"formatBitrate('$bps'): $msg"
		);
	}

	public static function provideFormatBitrate() {
		return array(
			array(
				0,
				"0 bps",
				"0 bits per second"
			),
			array(
				999,
				"999 bps",
				"999 bits per second"
			),
			array(
				1000,
				"1 kbps",
				"1 kilobit per second"
			),
			array(
				1000 * 1000,
				"1 Mbps",
				"1 megabit per second"
			),
			array(
				pow( 10, 9 ),
				"1 Gbps",
				"1 gigabit per second"
			),
			array(
				pow( 10, 12 ),
				"1 Tbps",
				"1 terabit per second"
			),
			array(
				pow( 10, 15 ),
				"1 Pbps",
				"1 petabit per second"
			),
			array(
				pow( 10, 18 ),
				"1 Ebps",
				"1 exabit per second"
			),
			array(
				pow( 10, 21 ),
				"1 Zbps",
				"1 zetabit per second"
			),
			array(
				pow( 10, 24 ),
				"1 Ybps",
				"1 yottabit per second"
			),
			array(
				pow( 10, 27 ),
				"1,000 Ybps",
				"1,000 yottabits per second"
			),
		);
	}

	/**
	 * @dataProvider provideFormatDuration
	 * @covers Language::formatDuration
	 */
	public function testFormatDuration( $duration, $expected, $intervals = array() ) {
		$this->assertEquals(
			$expected,
			$this->getLang()->formatDuration( $duration, $intervals ),
			"formatDuration('$duration'): $expected"
		);
	}

	public static function provideFormatDuration() {
		return array(
			array(
				0,
				'0 seconds',
			),
			array(
				1,
				'1 second',
			),
			array(
				2,
				'2 seconds',
			),
			array(
				60,
				'1 minute',
			),
			array(
				2 * 60,
				'2 minutes',
			),
			array(
				3600,
				'1 hour',
			),
			array(
				2 * 3600,
				'2 hours',
			),
			array(
				24 * 3600,
				'1 day',
			),
			array(
				2 * 86400,
				'2 days',
			),
			array(
				// ( 365 + ( 24 * 3 + 25 ) / 400 ) * 86400 = 31556952
				( 365 + ( 24 * 3 + 25 ) / 400.0 ) * 86400,
				'1 year',
			),
			array(
				2 * 31556952,
				'2 years',
			),
			array(
				10 * 31556952,
				'1 decade',
			),
			array(
				20 * 31556952,
				'2 decades',
			),
			array(
				100 * 31556952,
				'1 century',
			),
			array(
				200 * 31556952,
				'2 centuries',
			),
			array(
				1000 * 31556952,
				'1 millennium',
			),
			array(
				2000 * 31556952,
				'2 millennia',
			),
			array(
				9001,
				'2 hours, 30 minutes and 1 second'
			),
			array(
				3601,
				'1 hour and 1 second'
			),
			array(
				31556952 + 2 * 86400 + 9000,
				'1 year, 2 days, 2 hours and 30 minutes'
			),
			array(
				42 * 1000 * 31556952 + 42,
				'42 millennia and 42 seconds'
			),
			array(
				60,
				'60 seconds',
				array( 'seconds' ),
			),
			array(
				61,
				'61 seconds',
				array( 'seconds' ),
			),
			array(
				1,
				'1 second',
				array( 'seconds' ),
			),
			array(
				31556952 + 2 * 86400 + 9000,
				'1 year, 2 days and 150 minutes',
				array( 'years', 'days', 'minutes' ),
			),
			array(
				42,
				'0 days',
				array( 'years', 'days' ),
			),
			array(
				31556952 + 2 * 86400 + 9000,
				'1 year, 2 days and 150 minutes',
				array( 'minutes', 'days', 'years' ),
			),
			array(
				42,
				'0 days',
				array( 'days', 'years' ),
			),
		);
	}

	/**
	 * @dataProvider provideCheckTitleEncodingData
	 * @covers Language::checkTitleEncoding
	 */
	public function testCheckTitleEncoding( $s ) {
		$this->assertEquals(
			$s,
			$this->getLang()->checkTitleEncoding( $s ),
			"checkTitleEncoding('$s')"
		);
	}

	public static function provideCheckTitleEncodingData() {
		// @codingStandardsIgnoreStart Ignore Generic.Files.LineLength.TooLong
		return array(
			array( "" ),
			array( "United States of America" ), // 7bit ASCII
			array( rawurldecode( "S%C3%A9rie%20t%C3%A9l%C3%A9vis%C3%A9e" ) ),
			array(
				rawurldecode(
					"Acteur%7CAlbert%20Robbins%7CAnglais%7CAnn%20Donahue%7CAnthony%20E.%20Zuiker%7CCarol%20Mendelsohn"
				)
			),
			// The following two data sets come from bug 36839. They fail if checkTitleEncoding uses a regexp to test for
			// valid UTF-8 encoding and the pcre.recursion_limit is low (like, say, 1024). They succeed if checkTitleEncoding
			// uses mb_check_encoding for its test.
			array(
				rawurldecode(
					"Acteur%7CAlbert%20Robbins%7CAnglais%7CAnn%20Donahue%7CAnthony%20E.%20Zuiker%7CCarol%20Mendelsohn%7C"
						. "Catherine%20Willows%7CDavid%20Hodges%7CDavid%20Phillips%7CGil%20Grissom%7CGreg%20Sanders%7CHodges%7C"
						. "Internet%20Movie%20Database%7CJim%20Brass%7CLady%20Heather%7C"
						. "Les%20Experts%20(s%C3%A9rie%20t%C3%A9l%C3%A9vis%C3%A9e)%7CLes%20Experts%20:%20Manhattan%7C"
						. "Les%20Experts%20:%20Miami%7CListe%20des%20personnages%20des%20Experts%7C"
						. "Liste%20des%20%C3%A9pisodes%20des%20Experts%7CMod%C3%A8le%20discussion:Palette%20Les%20Experts%7C"
						. "Nick%20Stokes%7CPersonnage%20de%20fiction%7CPersonnage%20fictif%7CPersonnage%20de%20fiction%7C"
						. "Personnages%20r%C3%A9currents%20dans%20Les%20Experts%7CRaymond%20Langston%7CRiley%20Adams%7C"
						. "Saison%201%20des%20Experts%7CSaison%2010%20des%20Experts%7CSaison%2011%20des%20Experts%7C"
						. "Saison%2012%20des%20Experts%7CSaison%202%20des%20Experts%7CSaison%203%20des%20Experts%7C"
						. "Saison%204%20des%20Experts%7CSaison%205%20des%20Experts%7CSaison%206%20des%20Experts%7C"
						. "Saison%207%20des%20Experts%7CSaison%208%20des%20Experts%7CSaison%209%20des%20Experts%7C"
						. "Sara%20Sidle%7CSofia%20Curtis%7CS%C3%A9rie%20t%C3%A9l%C3%A9vis%C3%A9e%7CWallace%20Langham%7C"
						. "Warrick%20Brown%7CWendy%20Simms%7C%C3%89tats-Unis"
				),
			),
			array(
				rawurldecode(
					"Mod%C3%A8le%3AArrondissements%20homonymes%7CMod%C3%A8le%3ABandeau%20standard%20pour%20page%20d'homonymie%7C"
						. "Mod%C3%A8le%3ABatailles%20homonymes%7CMod%C3%A8le%3ACantons%20homonymes%7C"
						. "Mod%C3%A8le%3ACommunes%20fran%C3%A7aises%20homonymes%7CMod%C3%A8le%3AFilms%20homonymes%7C"
						. "Mod%C3%A8le%3AGouvernements%20homonymes%7CMod%C3%A8le%3AGuerres%20homonymes%7CMod%C3%A8le%3AHomonymie%7C"
						. "Mod%C3%A8le%3AHomonymie%20bateau%7CMod%C3%A8le%3AHomonymie%20d'%C3%A9tablissements%20scolaires%20ou"
						. "%20universitaires%7CMod%C3%A8le%3AHomonymie%20d'%C3%AEles%7CMod%C3%A8le%3AHomonymie%20de%20clubs%20sportifs%7C"
						. "Mod%C3%A8le%3AHomonymie%20de%20comt%C3%A9s%7CMod%C3%A8le%3AHomonymie%20de%20monument%7C"
						. "Mod%C3%A8le%3AHomonymie%20de%20nom%20romain%7CMod%C3%A8le%3AHomonymie%20de%20parti%20politique%7C"
						. "Mod%C3%A8le%3AHomonymie%20de%20route%7CMod%C3%A8le%3AHomonymie%20dynastique%7C"
						. "Mod%C3%A8le%3AHomonymie%20vid%C3%A9oludique%7CMod%C3%A8le%3AHomonymie%20%C3%A9difice%20religieux%7C"
						. "Mod%C3%A8le%3AInternationalisation%7CMod%C3%A8le%3AIsom%C3%A9rie%7CMod%C3%A8le%3AParonymie%7C"
						. "Mod%C3%A8le%3APatronyme%7CMod%C3%A8le%3APatronyme%20basque%7CMod%C3%A8le%3APatronyme%20italien%7C"
						. "Mod%C3%A8le%3APatronymie%7CMod%C3%A8le%3APersonnes%20homonymes%7CMod%C3%A8le%3ASaints%20homonymes%7C"
						. "Mod%C3%A8le%3ATitres%20homonymes%7CMod%C3%A8le%3AToponymie%7CMod%C3%A8le%3AUnit%C3%A9s%20homonymes%7C"
						. "Mod%C3%A8le%3AVilles%20homonymes%7CMod%C3%A8le%3A%C3%89difices%20religieux%20homonymes"
				)
			)
		);
		// @codingStandardsIgnoreEnd
	}

	/**
	 * @dataProvider provideRomanNumeralsData
	 * @covers Language::romanNumeral
	 */
	public function testRomanNumerals( $num, $numerals ) {
		$this->assertEquals(
			$numerals,
			Language::romanNumeral( $num ),
			"romanNumeral('$num')"
		);
	}

	public static function provideRomanNumeralsData() {
		return array(
			array( 1, 'I' ),
			array( 2, 'II' ),
			array( 3, 'III' ),
			array( 4, 'IV' ),
			array( 5, 'V' ),
			array( 6, 'VI' ),
			array( 7, 'VII' ),
			array( 8, 'VIII' ),
			array( 9, 'IX' ),
			array( 10, 'X' ),
			array( 20, 'XX' ),
			array( 30, 'XXX' ),
			array( 40, 'XL' ),
			array( 49, 'XLIX' ),
			array( 50, 'L' ),
			array( 60, 'LX' ),
			array( 70, 'LXX' ),
			array( 80, 'LXXX' ),
			array( 90, 'XC' ),
			array( 99, 'XCIX' ),
			array( 100, 'C' ),
			array( 200, 'CC' ),
			array( 300, 'CCC' ),
			array( 400, 'CD' ),
			array( 500, 'D' ),
			array( 600, 'DC' ),
			array( 700, 'DCC' ),
			array( 800, 'DCCC' ),
			array( 900, 'CM' ),
			array( 999, 'CMXCIX' ),
			array( 1000, 'M' ),
			array( 1989, 'MCMLXXXIX' ),
			array( 2000, 'MM' ),
			array( 3000, 'MMM' ),
			array( 4000, 'MMMM' ),
			array( 5000, 'MMMMM' ),
			array( 6000, 'MMMMMM' ),
			array( 7000, 'MMMMMMM' ),
			array( 8000, 'MMMMMMMM' ),
			array( 9000, 'MMMMMMMMM' ),
			array( 9999, 'MMMMMMMMMCMXCIX' ),
			array( 10000, 'MMMMMMMMMM' ),
		);
	}

	/**
	 * @dataProvider providePluralData
	 * @covers Language::convertPlural
	 */
	public function testConvertPlural( $expected, $number, $forms ) {
		$chosen = $this->getLang()->convertPlural( $number, $forms );
		$this->assertEquals( $expected, $chosen );
	}

	public static function providePluralData() {
		// Params are: [expected text, number given, [the plural forms]]
		return array(
			array( 'plural', 0, array(
				'singular', 'plural'
			) ),
			array( 'explicit zero', 0, array(
				'0=explicit zero', 'singular', 'plural'
			) ),
			array( 'explicit one', 1, array(
				'singular', 'plural', '1=explicit one',
			) ),
			array( 'singular', 1, array(
				'singular', 'plural', '0=explicit zero',
			) ),
			array( 'plural', 3, array(
				'0=explicit zero', '1=explicit one', 'singular', 'plural'
			) ),
			array( 'explicit eleven', 11, array(
				'singular', 'plural', '11=explicit eleven',
			) ),
			array( 'plural', 12, array(
				'singular', 'plural', '11=explicit twelve',
			) ),
			array( 'plural', 12, array(
				'singular', 'plural', '=explicit form',
			) ),
			array( 'other', 2, array(
				'kissa=kala', '1=2=3', 'other',
			) ),
			array( '', 2, array(
				'0=explicit zero', '1=explicit one',
			) ),
		);
	}

	/**
	 * @covers Language::translateBlockExpiry()
	 * @dataProvider provideTranslateBlockExpiry
	 */
	public function testTranslateBlockExpiry( $expectedData, $str, $desc ) {
		$lang = $this->getLang();
		if ( is_array( $expectedData ) ) {
			list( $func, $arg ) = $expectedData;
			$expected = $lang->$func( $arg );
		} else {
			$expected = $expectedData;
		}
		$this->assertEquals( $expected, $lang->translateBlockExpiry( $str ), $desc );
	}

	public static function provideTranslateBlockExpiry() {
		return array(
			array( '2 hours', '2 hours', 'simple data from ipboptions' ),
			array( 'indefinite', 'infinite', 'infinite from ipboptions' ),
			array( 'indefinite', 'infinity', 'alternative infinite from ipboptions' ),
			array( 'indefinite', 'indefinite', 'another alternative infinite from ipboptions' ),
			array( array( 'formatDuration', 1023 * 60 * 60 ), '1023 hours', 'relative' ),
			array( array( 'formatDuration', -1023 ), '-1023 seconds', 'negative relative' ),
			array( array( 'formatDuration', 0 ), 'now', 'now' ),
			array(
				array( 'timeanddate', '20120102070000' ),
				'2012-1-1 7:00 +1 day',
				'mixed, handled as absolute'
			),
			array( array( 'timeanddate', '19910203040506' ), '1991-2-3 4:05:06', 'absolute' ),
			array( array( 'timeanddate', '19700101000000' ), '1970-1-1 0:00:00', 'absolute at epoch' ),
			array( array( 'timeanddate', '19691231235959' ), '1969-12-31 23:59:59', 'time before epoch' ),
			array( 'dummy', 'dummy', 'return garbage as is' ),
		);
	}

	/**
	 * @dataProvider parseFormattedNumberProvider
	 */
	public function testParseFormattedNumber( $langCode, $number ) {
		$lang = Language::factory( $langCode );

		$localisedNum = $lang->formatNum( $number );
		$normalisedNum = $lang->parseFormattedNumber( $localisedNum );

		$this->assertEquals( $number, $normalisedNum );
	}

	public function parseFormattedNumberProvider() {
		return array(
			array( 'de', 377.01 ),
			array( 'fa', 334 ),
			array( 'fa', 382.772 ),
			array( 'ar', 1844 ),
			array( 'lzh', 3731 ),
			array( 'zh-classical', 7432 )
		);
	}

	/**
	 * @covers Language::commafy()
	 * @dataProvider provideCommafyData
	 */
	public function testCommafy( $number, $numbersWithCommas ) {
		$this->assertEquals(
			$numbersWithCommas,
			$this->getLang()->commafy( $number ),
			"commafy('$number')"
		);
	}

	public static function provideCommafyData() {
		return array(
			array( -1, '-1' ),
			array( 10, '10' ),
			array( 100, '100' ),
			array( 1000, '1,000' ),
			array( 10000, '10,000' ),
			array( 100000, '100,000' ),
			array( 1000000, '1,000,000' ),
			array( -1.0001, '-1.0001' ),
			array( 1.0001, '1.0001' ),
			array( 10.0001, '10.0001' ),
			array( 100.0001, '100.0001' ),
			array( 1000.0001, '1,000.0001' ),
			array( 10000.0001, '10,000.0001' ),
			array( 100000.0001, '100,000.0001' ),
			array( 1000000.0001, '1,000,000.0001' ),
			array( '200000000000000000000', '200,000,000,000,000,000,000' ),
			array( '-200000000000000000000', '-200,000,000,000,000,000,000' ),
		);
	}

	/**
	 * @covers Language::listToText
	 */
	public function testListToText() {
		$lang = $this->getLang();
		$and = $lang->getMessageFromDB( 'and' );
		$s = $lang->getMessageFromDB( 'word-separator' );
		$c = $lang->getMessageFromDB( 'comma-separator' );

		$this->assertEquals( '', $lang->listToText( array() ) );
		$this->assertEquals( 'a', $lang->listToText( array( 'a' ) ) );
		$this->assertEquals( "a{$and}{$s}b", $lang->listToText( array( 'a', 'b' ) ) );
		$this->assertEquals( "a{$c}b{$and}{$s}c", $lang->listToText( array( 'a', 'b', 'c' ) ) );
		$this->assertEquals( "a{$c}b{$c}c{$and}{$s}d", $lang->listToText( array( 'a', 'b', 'c', 'd' ) ) );
	}

	/**
	 * @dataProvider provideIsSupportedLanguage
	 * @covers Language::isSupportedLanguage
	 */
	public function testIsSupportedLanguage( $code, $expected, $comment ) {
		$this->assertEquals( $expected, Language::isSupportedLanguage( $code ), $comment );
	}

	public static function provideIsSupportedLanguage() {
		return array(
			array( 'en', true, 'is supported language' ),
			array( 'fi', true, 'is supported language' ),
			array( 'bunny', false, 'is not supported language' ),
			array( 'FI', false, 'is not supported language, input should be in lower case' ),
		);
	}

	/**
	 * @dataProvider provideGetParentLanguage
	 * @covers Language::getParentLanguage
	 */
	public function testGetParentLanguage( $code, $expected, $comment ) {
		$lang = Language::factory( $code );
		if ( is_null( $expected ) ) {
			$this->assertNull( $lang->getParentLanguage(), $comment );
		} else {
			$this->assertEquals( $expected, $lang->getParentLanguage()->getCode(), $comment );
		}
	}

	public static function provideGetParentLanguage() {
		return array(
			array( 'zh-cn', 'zh', 'zh is the parent language of zh-cn' ),
			array( 'zh', 'zh', 'zh is defined as the parent language of zh, '
				. 'because zh converter can convert zh-cn to zh' ),
			array( 'zh-invalid', null, 'do not be fooled by arbitrarily composed language codes' ),
			array( 'en-gb', null, 'en does not have converter' ),
			array( 'en', null, 'en does not have converter. Although FakeConverter '
					. 'handles en -> en conversion but it is useless' ),
		);
	}

	/**
	 * @dataProvider provideGetNamespaceAliases
	 * @covers Language::getNamespaceAliases
	 */
	public function testGetNamespaceAliases( $languageCode, $subset ) {
		$language = Language::factory( $languageCode );
		$aliases = $language->getNamespaceAliases();
		foreach ( $subset as $alias => $nsId ) {
			$this->assertEquals( $nsId, $aliases[$alias] );
		}
	}

	public static function provideGetNamespaceAliases() {
		// TODO: Add tests for NS_PROJECT_TALK and GenderNamespaces
		return array(
			array(
				'zh',
				array(
					'文件' => NS_FILE,
					'檔案' => NS_FILE,
				),
			),
		);
	}
}
