Update to MediaWiki 1.24.2

7 files changed, 2183 insertions, 0 deletions

diff --git a/tests/phpunit/includes/content/ContentHandlerTest.php b/tests/phpunit/includes/content/ContentHandlerTest.php
new file mode 100644
index 00000000..f7449734
--- /dev/null
+++ b/tests/phpunit/includes/content/ContentHandlerTest.php
@@ -0,0 +1,525 @@
+<?php
+
+/**
+ * @group ContentHandler
+ * @group Database
+ *
+ * @note Declare that we are using the database, because otherwise we'll fail in
+ * the "databaseless" test run. This is because the LinkHolderArray used by the
+ * parser needs database access.
+ */
+class ContentHandlerTest extends MediaWikiTestCase {
+
+	protected function setUp() {
+		global $wgContLang;
+		parent::setUp();
+
+		$this->setMwGlobals( array(
+			'wgExtraNamespaces' => array(
+				12312 => 'Dummy',
+				12313 => 'Dummy_talk',
+			),
+			// The below tests assume that namespaces not mentioned here (Help, User, MediaWiki, ..)
+			// default to CONTENT_MODEL_WIKITEXT.
+			'wgNamespaceContentModels' => array(
+				12312 => 'testing',
+			),
+			'wgContentHandlers' => array(
+				CONTENT_MODEL_WIKITEXT => 'WikitextContentHandler',
+				CONTENT_MODEL_JAVASCRIPT => 'JavaScriptContentHandler',
+				CONTENT_MODEL_CSS => 'CssContentHandler',
+				CONTENT_MODEL_TEXT => 'TextContentHandler',
+				'testing' => 'DummyContentHandlerForTesting',
+			),
+		) );
+
+		// Reset namespace cache
+		MWNamespace::getCanonicalNamespaces( true );
+		$wgContLang->resetNamespaces();
+	}
+
+	protected function tearDown() {
+		global $wgContLang;
+
+		// Reset namespace cache
+		MWNamespace::getCanonicalNamespaces( true );
+		$wgContLang->resetNamespaces();
+
+		parent::tearDown();
+	}
+
+	public static function dataGetDefaultModelFor() {
+		return array(
+			array( 'Help:Foo', CONTENT_MODEL_WIKITEXT ),
+			array( 'Help:Foo.js', CONTENT_MODEL_WIKITEXT ),
+			array( 'Help:Foo/bar.js', CONTENT_MODEL_WIKITEXT ),
+			array( 'User:Foo', CONTENT_MODEL_WIKITEXT ),
+			array( 'User:Foo.js', CONTENT_MODEL_WIKITEXT ),
+			array( 'User:Foo/bar.js', CONTENT_MODEL_JAVASCRIPT ),
+			array( 'User:Foo/bar.css', CONTENT_MODEL_CSS ),
+			array( 'User talk:Foo/bar.css', CONTENT_MODEL_WIKITEXT ),
+			array( 'User:Foo/bar.js.xxx', CONTENT_MODEL_WIKITEXT ),
+			array( 'User:Foo/bar.xxx', CONTENT_MODEL_WIKITEXT ),
+			array( 'MediaWiki:Foo.js', CONTENT_MODEL_JAVASCRIPT ),
+			array( 'MediaWiki:Foo.css', CONTENT_MODEL_CSS ),
+			array( 'MediaWiki:Foo.JS', CONTENT_MODEL_WIKITEXT ),
+			array( 'MediaWiki:Foo.CSS', CONTENT_MODEL_WIKITEXT ),
+			array( 'MediaWiki:Foo.css.xxx', CONTENT_MODEL_WIKITEXT ),
+		);
+	}
+
+	/**
+	 * @dataProvider dataGetDefaultModelFor
+	 * @covers ContentHandler::getDefaultModelFor
+	 */
+	public function testGetDefaultModelFor( $title, $expectedModelId ) {
+		$title = Title::newFromText( $title );
+		$this->assertEquals( $expectedModelId, ContentHandler::getDefaultModelFor( $title ) );
+	}
+
+	/**
+	 * @dataProvider dataGetDefaultModelFor
+	 * @covers ContentHandler::getForTitle
+	 */
+	public function testGetForTitle( $title, $expectedContentModel ) {
+		$title = Title::newFromText( $title );
+		$handler = ContentHandler::getForTitle( $title );
+		$this->assertEquals( $expectedContentModel, $handler->getModelID() );
+	}
+
+	public static function dataGetLocalizedName() {
+		return array(
+			array( null, null ),
+			array( "xyzzy", null ),
+
+			// XXX: depends on content language
+			array( CONTENT_MODEL_JAVASCRIPT, '/javascript/i' ),
+		);
+	}
+
+	/**
+	 * @dataProvider dataGetLocalizedName
+	 * @covers ContentHandler::getLocalizedName
+	 */
+	public function testGetLocalizedName( $id, $expected ) {
+		$name = ContentHandler::getLocalizedName( $id );
+
+		if ( $expected ) {
+			$this->assertNotNull( $name, "no name found for content model $id" );
+			$this->assertTrue( preg_match( $expected, $name ) > 0,
+				"content model name for #$id did not match pattern $expected"
+			);
+		} else {
+			$this->assertEquals( $id, $name, "localization of unknown model $id should have "
+				. "fallen back to use the model id directly."
+			);
+		}
+	}
+
+	public static function dataGetPageLanguage() {
+		global $wgLanguageCode;
+
+		return array(
+			array( "Main", $wgLanguageCode ),
+			array( "Dummy:Foo", $wgLanguageCode ),
+			array( "MediaWiki:common.js", 'en' ),
+			array( "User:Foo/common.js", 'en' ),
+			array( "MediaWiki:common.css", 'en' ),
+			array( "User:Foo/common.css", 'en' ),
+			array( "User:Foo", $wgLanguageCode ),
+
+			array( CONTENT_MODEL_JAVASCRIPT, 'javascript' ),
+		);
+	}
+
+	/**
+	 * @dataProvider dataGetPageLanguage
+	 * @covers ContentHandler::getPageLanguage
+	 */
+	public function testGetPageLanguage( $title, $expected ) {
+		if ( is_string( $title ) ) {
+			$title = Title::newFromText( $title );
+		}
+
+		$expected = wfGetLangObj( $expected );
+
+		$handler = ContentHandler::getForTitle( $title );
+		$lang = $handler->getPageLanguage( $title );
+
+		$this->assertEquals( $expected->getCode(), $lang->getCode() );
+	}
+
+	public static function dataGetContentText_Null() {
+		return array(
+			array( 'fail' ),
+			array( 'serialize' ),
+			array( 'ignore' ),
+		);
+	}
+
+	/**
+	 * @dataProvider dataGetContentText_Null
+	 * @covers ContentHandler::getContentText
+	 */
+	public function testGetContentText_Null( $contentHandlerTextFallback ) {
+		$this->setMwGlobals( 'wgContentHandlerTextFallback', $contentHandlerTextFallback );
+
+		$content = null;
+
+		$text = ContentHandler::getContentText( $content );
+		$this->assertEquals( '', $text );
+	}
+
+	public static function dataGetContentText_TextContent() {
+		return array(
+			array( 'fail' ),
+			array( 'serialize' ),
+			array( 'ignore' ),
+		);
+	}
+
+	/**
+	 * @dataProvider dataGetContentText_TextContent
+	 * @covers ContentHandler::getContentText
+	 */
+	public function testGetContentText_TextContent( $contentHandlerTextFallback ) {
+		$this->setMwGlobals( 'wgContentHandlerTextFallback', $contentHandlerTextFallback );
+
+		$content = new WikitextContent( "hello world" );
+
+		$text = ContentHandler::getContentText( $content );
+		$this->assertEquals( $content->getNativeData(), $text );
+	}
+
+	/**
+	 * ContentHandler::getContentText should have thrown an exception for non-text Content object
+	 * @expectedException MWException
+	 * @covers ContentHandler::getContentText
+	 */
+	public function testGetContentText_NonTextContent_fail() {
+		$this->setMwGlobals( 'wgContentHandlerTextFallback', 'fail' );
+
+		$content = new DummyContentForTesting( "hello world" );
+
+		ContentHandler::getContentText( $content );
+	}
+
+	/**
+	 * @covers ContentHandler::getContentText
+	 */
+	public function testGetContentText_NonTextContent_serialize() {
+		$this->setMwGlobals( 'wgContentHandlerTextFallback', 'serialize' );
+
+		$content = new DummyContentForTesting( "hello world" );
+
+		$text = ContentHandler::getContentText( $content );
+		$this->assertEquals( $content->serialize(), $text );
+	}
+
+	/**
+	 * @covers ContentHandler::getContentText
+	 */
+	public function testGetContentText_NonTextContent_ignore() {
+		$this->setMwGlobals( 'wgContentHandlerTextFallback', 'ignore' );
+
+		$content = new DummyContentForTesting( "hello world" );
+
+		$text = ContentHandler::getContentText( $content );
+		$this->assertNull( $text );
+	}
+
+	/*
+	public static function makeContent( $text, Title $title, $modelId = null, $format = null ) {}
+	*/
+
+	public static function dataMakeContent() {
+		return array(
+			array( 'hallo', 'Help:Test', null, null, CONTENT_MODEL_WIKITEXT, 'hallo', false ),
+			array( 'hallo', 'MediaWiki:Test.js', null, null, CONTENT_MODEL_JAVASCRIPT, 'hallo', false ),
+			array( serialize( 'hallo' ), 'Dummy:Test', null, null, "testing", 'hallo', false ),
+
+			array(
+				'hallo',
+				'Help:Test',
+				null,
+				CONTENT_FORMAT_WIKITEXT,
+				CONTENT_MODEL_WIKITEXT,
+				'hallo',
+				false
+			),
+			array(
+				'hallo',
+				'MediaWiki:Test.js',
+				null,
+				CONTENT_FORMAT_JAVASCRIPT,
+				CONTENT_MODEL_JAVASCRIPT,
+				'hallo',
+				false
+			),
+			array( serialize( 'hallo' ), 'Dummy:Test', null, "testing", "testing", 'hallo', false ),
+
+			array( 'hallo', 'Help:Test', CONTENT_MODEL_CSS, null, CONTENT_MODEL_CSS, 'hallo', false ),
+			array(
+				'hallo',
+				'MediaWiki:Test.js',
+				CONTENT_MODEL_CSS,
+				null,
+				CONTENT_MODEL_CSS,
+				'hallo',
+				false
+			),
+			array(
+				serialize( 'hallo' ),
+				'Dummy:Test',
+				CONTENT_MODEL_CSS,
+				null,
+				CONTENT_MODEL_CSS,
+				serialize( 'hallo' ),
+				false
+			),
+
+			array( 'hallo', 'Help:Test', CONTENT_MODEL_WIKITEXT, "testing", null, null, true ),
+			array( 'hallo', 'MediaWiki:Test.js', CONTENT_MODEL_CSS, "testing", null, null, true ),
+			array( 'hallo', 'Dummy:Test', CONTENT_MODEL_JAVASCRIPT, "testing", null, null, true ),
+		);
+	}
+
+	/**
+	 * @dataProvider dataMakeContent
+	 * @covers ContentHandler::makeContent
+	 */
+	public function testMakeContent( $data, $title, $modelId, $format,
+		$expectedModelId, $expectedNativeData, $shouldFail
+	) {
+		$title = Title::newFromText( $title );
+
+		try {
+			$content = ContentHandler::makeContent( $data, $title, $modelId, $format );
+
+			if ( $shouldFail ) {
+				$this->fail( "ContentHandler::makeContent should have failed!" );
+			}
+
+			$this->assertEquals( $expectedModelId, $content->getModel(), 'bad model id' );
+			$this->assertEquals( $expectedNativeData, $content->getNativeData(), 'bads native data' );
+		} catch ( MWException $ex ) {
+			if ( !$shouldFail ) {
+				$this->fail( "ContentHandler::makeContent failed unexpectedly: " . $ex->getMessage() );
+			} else {
+				// dummy, so we don't get the "test did not perform any assertions" message.
+				$this->assertTrue( true );
+			}
+		}
+	}
+
+	/*
+	 * Test if we become a "Created blank page" summary from getAutoSummary if no Content added to
+	 * page.
+	 */
+	public function testGetAutosummary() {
+		$content = new DummyContentHandlerForTesting( CONTENT_MODEL_WIKITEXT );
+		$title = Title::newFromText( 'Help:Test' );
+		// Create a new content object with no content
+		$newContent = ContentHandler::makeContent( '', $title, null, null, CONTENT_MODEL_WIKITEXT );
+		// first check, if we become a blank page created summary with the right bitmask
+		$autoSummary = $content->getAutosummary( null, $newContent, 97 );
+		$this->assertEquals( $autoSummary, 'Created blank page' );
+		// now check, what we become with another bitmask
+		$autoSummary = $content->getAutosummary( null, $newContent, 92 );
+		$this->assertEquals( $autoSummary, '' );
+	}
+
+	/*
+	public function testSupportsSections() {
+		$this->markTestIncomplete( "not yet implemented" );
+	}
+	*/
+
+	/**
+	 * @covers ContentHandler::runLegacyHooks
+	 */
+	public function testRunLegacyHooks() {
+		Hooks::register( 'testRunLegacyHooks', __CLASS__ . '::dummyHookHandler' );
+
+		$content = new WikitextContent( 'test text' );
+		$ok = ContentHandler::runLegacyHooks(
+			'testRunLegacyHooks',
+			array( 'foo', &$content, 'bar' ),
+			false
+		);
+
+		$this->assertTrue( $ok, "runLegacyHooks should have returned true" );
+		$this->assertEquals( "TEST TEXT", $content->getNativeData() );
+	}
+
+	public static function dummyHookHandler( $foo, &$text, $bar ) {
+		if ( $text === null || $text === false ) {
+			return false;
+		}
+
+		$text = strtoupper( $text );
+
+		return true;
+	}
+}
+
+class DummyContentHandlerForTesting extends ContentHandler {
+
+	public function __construct( $dataModel ) {
+		parent::__construct( $dataModel, array( "testing" ) );
+	}
+
+	/**
+	 * @see ContentHandler::serializeContent
+	 *
+	 * @param Content $content
+	 * @param string $format
+	 *
+	 * @return string
+	 */
+	public function serializeContent( Content $content, $format = null ) {
+		return $content->serialize();
+	}
+
+	/**
+	 * @see ContentHandler::unserializeContent
+	 *
+	 * @param string $blob
+	 * @param string $format Unused.
+	 *
+	 * @return Content
+	 */
+	public function unserializeContent( $blob, $format = null ) {
+		$d = unserialize( $blob );
+
+		return new DummyContentForTesting( $d );
+	}
+
+	/**
+	 * Creates an empty Content object of the type supported by this ContentHandler.
+	 *
+	 */
+	public function makeEmptyContent() {
+		return new DummyContentForTesting( '' );
+	}
+}
+
+class DummyContentForTesting extends AbstractContent {
+
+	public function __construct( $data ) {
+		parent::__construct( "testing" );
+
+		$this->data = $data;
+	}
+
+	public function serialize( $format = null ) {
+		return serialize( $this->data );
+	}
+
+	/**
+	 * @return string A string representing the content in a way useful for
+	 *   building a full text search index. If no useful representation exists,
+	 *   this method returns an empty string.
+	 */
+	public function getTextForSearchIndex() {
+		return '';
+	}
+
+	/**
+	 * @return string|bool The wikitext to include when another page includes this  content,
+	 *  or false if the content is not includable in a wikitext page.
+	 */
+	public function getWikitextForTransclusion() {
+		return false;
+	}
+
+	/**
+	 * Returns a textual representation of the content suitable for use in edit
+	 * summaries and log messages.
+	 *
+	 * @param int $maxlength Maximum length of the summary text.
+	 * @return string The summary text.
+	 */
+	public function getTextForSummary( $maxlength = 250 ) {
+		return '';
+	}
+
+	/**
+	 * Returns native represenation of the data. Interpretation depends on the data model used,
+	 * as given by getDataModel().
+	 *
+	 * @return mixed The native representation of the content. Could be a string, a nested array
+	 *  structure, an object, a binary blob... anything, really.
+	 */
+	public function getNativeData() {
+		return $this->data;
+	}
+
+	/**
+	 * returns the content's nominal size in bogo-bytes.
+	 *
+	 * @return int
+	 */
+	public function getSize() {
+		return strlen( $this->data );
+	}
+
+	/**
+	 * Return a copy of this Content object. The following must be true for the object returned
+	 * if $copy = $original->copy()
+	 *
+	 * * get_class($original) === get_class($copy)
+	 * * $original->getModel() === $copy->getModel()
+	 * * $original->equals( $copy )
+	 *
+	 * If and only if the Content object is imutable, the copy() method can and should
+	 * return $this. That is,  $copy === $original may be true, but only for imutable content
+	 * objects.
+	 *
+	 * @return Content A copy of this object
+	 */
+	public function copy() {
+		return $this;
+	}
+
+	/**
+	 * Returns true if this content is countable as a "real" wiki page, provided
+	 * that it's also in a countable location (e.g. a current revision in the main namespace).
+	 *
+	 * @param bool $hasLinks If it is known whether this content contains links,
+	 * provide this information here, to avoid redundant parsing to find out.
+	 * @return bool
+	 */
+	public function isCountable( $hasLinks = null ) {
+		return false;
+	}
+
+	/**
+	 * @param Title $title
+	 * @param int $revId Unused.
+	 * @param null|ParserOptions $options
+	 * @param bool $generateHtml Whether to generate Html (default: true). If false, the result
+	 *  of calling getText() on the ParserOutput object returned by this method is undefined.
+	 *
+	 * @return ParserOutput
+	 */
+	public function getParserOutput( Title $title, $revId = null,
+		ParserOptions $options = null, $generateHtml = true
+	) {
+		return new ParserOutput( $this->getNativeData() );
+	}
+
+	/**
+	 * @see AbstractContent::fillParserOutput()
+	 *
+	 * @param Title $title Context title for parsing
+	 * @param int|null $revId Revision ID (for {{REVISIONID}})
+	 * @param ParserOptions $options Parser options
+	 * @param bool $generateHtml Whether or not to generate HTML
+	 * @param ParserOutput &$output The output object to fill (reference).
+	 */
+	protected function fillParserOutput( Title $title, $revId,
+			ParserOptions $options, $generateHtml, ParserOutput &$output ) {
+		$output = new ParserOutput( $this->getNativeData() );
+	}
+}
diff --git a/tests/phpunit/includes/content/CssContentTest.php b/tests/phpunit/includes/content/CssContentTest.php
new file mode 100644
index 00000000..40484d3a
--- /dev/null
+++ b/tests/phpunit/includes/content/CssContentTest.php
@@ -0,0 +1,87 @@
+<?php
+
+/**
+ * @group ContentHandler
+ * @group Database
+ *        ^--- needed, because we do need the database to test link updates
+ */
+class CssContentTest extends JavaScriptContentTest {
+
+	protected function setUp() {
+		parent::setUp();
+
+		// Anon user
+		$user = new User();
+		$user->setName( '127.0.0.1' );
+
+		$this->setMwGlobals( array(
+			'wgUser' => $user,
+			'wgTextModelsToParse' => array(
+				CONTENT_MODEL_CSS,
+			)
+		) );
+	}
+
+	public function newContent( $text ) {
+		return new CssContent( $text );
+	}
+
+	public static function dataGetParserOutput() {
+		return array(
+			array(
+				'MediaWiki:Test.css',
+				null,
+				"hello <world>\n",
+				"<pre class=\"mw-code mw-css\" dir=\"ltr\">\nhello &lt;world&gt;\n\n</pre>"
+			),
+			array(
+				'MediaWiki:Test.css',
+				null,
+				"/* hello [[world]] */\n",
+				"<pre class=\"mw-code mw-css\" dir=\"ltr\">\n/* hello [[world]] */\n\n</pre>",
+				array(
+					'Links' => array(
+						array( 'World' => 0 )
+					)
+				)
+			),
+
+			// TODO: more...?
+		);
+	}
+
+	/**
+	 * @covers CssContent::getModel
+	 */
+	public function testGetModel() {
+		$content = $this->newContent( 'hello world.' );
+
+		$this->assertEquals( CONTENT_MODEL_CSS, $content->getModel() );
+	}
+
+	/**
+	 * @covers CssContent::getContentHandler
+	 */
+	public function testGetContentHandler() {
+		$content = $this->newContent( 'hello world.' );
+
+		$this->assertEquals( CONTENT_MODEL_CSS, $content->getContentHandler()->getModelID() );
+	}
+
+	public static function dataEquals() {
+		return array(
+			array( new CssContent( 'hallo' ), null, false ),
+			array( new CssContent( 'hallo' ), new CssContent( 'hallo' ), true ),
+			array( new CssContent( 'hallo' ), new WikitextContent( 'hallo' ), false ),
+			array( new CssContent( 'hallo' ), new CssContent( 'HALLO' ), false ),
+		);
+	}
+
+	/**
+	 * @dataProvider dataEquals
+	 * @covers CssContent::equals
+	 */
+	public function testEquals( Content $a, Content $b = null, $equal = false ) {
+		$this->assertEquals( $equal, $a->equals( $b ) );
+	}
+}
diff --git a/tests/phpunit/includes/content/JavaScriptContentTest.php b/tests/phpunit/includes/content/JavaScriptContentTest.php
new file mode 100644
index 00000000..7193ec9f
--- /dev/null
+++ b/tests/phpunit/includes/content/JavaScriptContentTest.php
@@ -0,0 +1,293 @@
+<?php
+
+/**
+ * @group ContentHandler
+ * @group Database
+ *        ^--- needed, because we do need the database to test link updates
+ */
+class JavaScriptContentTest extends TextContentTest {
+
+	public function newContent( $text ) {
+		return new JavaScriptContent( $text );
+	}
+
+	public static function dataGetParserOutput() {
+		return array(
+			array(
+				'MediaWiki:Test.js',
+				null,
+				"hello <world>\n",
+				"<pre class=\"mw-code mw-js\" dir=\"ltr\">\nhello &lt;world&gt;\n\n</pre>"
+			),
+			array(
+				'MediaWiki:Test.js',
+				null,
+				"hello(); // [[world]]\n",
+				"<pre class=\"mw-code mw-js\" dir=\"ltr\">\nhello(); // [[world]]\n\n</pre>",
+				array(
+					'Links' => array(
+						array( 'World' => 0 )
+					)
+				)
+			),
+
+			// TODO: more...?
+		);
+	}
+
+	// XXX: Unused function
+	public static function dataGetSection() {
+		return array(
+			array( WikitextContentTest::$sections,
+				'0',
+				null
+			),
+			array( WikitextContentTest::$sections,
+				'2',
+				null
+			),
+			array( WikitextContentTest::$sections,
+				'8',
+				null
+			),
+		);
+	}
+
+	// XXX: Unused function
+	public static function dataReplaceSection() {
+		return array(
+			array( WikitextContentTest::$sections,
+				'0',
+				'No more',
+				null,
+				null
+			),
+			array( WikitextContentTest::$sections,
+				'',
+				'No more',
+				null,
+				null
+			),
+			array( WikitextContentTest::$sections,
+				'2',
+				"== TEST ==\nmore fun",
+				null,
+				null
+			),
+			array( WikitextContentTest::$sections,
+				'8',
+				'No more',
+				null,
+				null
+			),
+			array( WikitextContentTest::$sections,
+				'new',
+				'No more',
+				'New',
+				null
+			),
+		);
+	}
+
+	/**
+	 * @covers JavaScriptContent::addSectionHeader
+	 */
+	public function testAddSectionHeader() {
+		$content = $this->newContent( 'hello world' );
+		$c = $content->addSectionHeader( 'test' );
+
+		$this->assertTrue( $content->equals( $c ) );
+	}
+
+	// XXX: currently, preSaveTransform is applied to scripts. this may change or become optional.
+	public static function dataPreSaveTransform() {
+		return array(
+			array( 'hello this is ~~~',
+				"hello this is [[Special:Contributions/127.0.0.1|127.0.0.1]]",
+			),
+			array( 'hello \'\'this\'\' is <nowiki>~~~</nowiki>',
+				'hello \'\'this\'\' is <nowiki>~~~</nowiki>',
+			),
+			array( " Foo \n ",
+				" Foo",
+			),
+		);
+	}
+
+	public static function dataPreloadTransform() {
+		return array(
+			array( 'hello this is ~~~',
+				'hello this is ~~~',
+			),
+			array( 'hello \'\'this\'\' is <noinclude>foo</noinclude><includeonly>bar</includeonly>',
+				'hello \'\'this\'\' is <noinclude>foo</noinclude><includeonly>bar</includeonly>',
+			),
+		);
+	}
+
+	public static function dataGetRedirectTarget() {
+		return array(
+			array( '#REDIRECT [[Test]]',
+				null,
+			),
+			array( '#REDIRECT Test',
+				null,
+			),
+			array( '* #REDIRECT [[Test]]',
+				null,
+			),
+		);
+	}
+
+	/**
+	 * @todo Test needs database!
+	 */
+	/*
+	public function getRedirectChain() {
+		$text = $this->getNativeData();
+		return Title::newFromRedirectArray( $text );
+	}
+	*/
+
+	/**
+	 * @todo Test needs database!
+	 */
+	/*
+	public function getUltimateRedirectTarget() {
+		$text = $this->getNativeData();
+		return Title::newFromRedirectRecurse( $text );
+	}
+	*/
+
+	public static function dataIsCountable() {
+		return array(
+			array( '',
+				null,
+				'any',
+				true
+			),
+			array( 'Foo',
+				null,
+				'any',
+				true
+			),
+			array( 'Foo',
+				null,
+				'comma',
+				false
+			),
+			array( 'Foo, bar',
+				null,
+				'comma',
+				false
+			),
+			array( 'Foo',
+				null,
+				'link',
+				false
+			),
+			array( 'Foo [[bar]]',
+				null,
+				'link',
+				false
+			),
+			array( 'Foo',
+				true,
+				'link',
+				false
+			),
+			array( 'Foo [[bar]]',
+				false,
+				'link',
+				false
+			),
+			array( '#REDIRECT [[bar]]',
+				true,
+				'any',
+				true
+			),
+			array( '#REDIRECT [[bar]]',
+				true,
+				'comma',
+				false
+			),
+			array( '#REDIRECT [[bar]]',
+				true,
+				'link',
+				false
+			),
+		);
+	}
+
+	public static function dataGetTextForSummary() {
+		return array(
+			array( "hello\nworld.",
+				16,
+				'hello world.',
+			),
+			array( 'hello world.',
+				8,
+				'hello...',
+			),
+			array( '[[hello world]].',
+				8,
+				'[[hel...',
+			),
+		);
+	}
+
+	/**
+	 * @covers JavaScriptContent::matchMagicWord
+	 */
+	public function testMatchMagicWord() {
+		$mw = MagicWord::get( "staticredirect" );
+
+		$content = $this->newContent( "#REDIRECT [[FOO]]\n__STATICREDIRECT__" );
+		$this->assertFalse(
+			$content->matchMagicWord( $mw ),
+			"should not have matched magic word, since it's not wikitext"
+		);
+	}
+
+	/**
+	 * @covers JavaScriptContent::updateRedirect
+	 */
+	public function testUpdateRedirect() {
+		$target = Title::newFromText( "testUpdateRedirect_target" );
+
+		$content = $this->newContent( "#REDIRECT [[Someplace]]" );
+		$newContent = $content->updateRedirect( $target );
+
+		$this->assertTrue(
+			$content->equals( $newContent ),
+			"content should be unchanged since it's not wikitext"
+		);
+	}
+
+	/**
+	 * @covers JavaScriptContent::getModel
+	 */
+	public function testGetModel() {
+		$content = $this->newContent( "hello world." );
+
+		$this->assertEquals( CONTENT_MODEL_JAVASCRIPT, $content->getModel() );
+	}
+
+	/**
+	 * @covers JavaScriptContent::getContentHandler
+	 */
+	public function testGetContentHandler() {
+		$content = $this->newContent( "hello world." );
+
+		$this->assertEquals( CONTENT_MODEL_JAVASCRIPT, $content->getContentHandler()->getModelID() );
+	}
+
+	public static function dataEquals() {
+		return array(
+			array( new JavaScriptContent( "hallo" ), null, false ),
+			array( new JavaScriptContent( "hallo" ), new JavaScriptContent( "hallo" ), true ),
+			array( new JavaScriptContent( "hallo" ), new CssContent( "hallo" ), false ),
+			array( new JavaScriptContent( "hallo" ), new JavaScriptContent( "HALLO" ), false ),
+		);
+	}
+}
diff --git a/tests/phpunit/includes/content/JsonContentTest.php b/tests/phpunit/includes/content/JsonContentTest.php
new file mode 100644
index 00000000..77b542f4
--- /dev/null
+++ b/tests/phpunit/includes/content/JsonContentTest.php
@@ -0,0 +1,114 @@
+<?php
+
+/**
+ * @author Adam Shorland
+ * @covers JsonContent
+ */
+class JsonContentTest extends MediaWikiLangTestCase {
+
+	/**
+	 * @dataProvider provideValidConstruction
+	 */
+	public function testValidConstruct( $text, $modelId, $isValid, $expected ) {
+		$obj = new JsonContent( $text, $modelId );
+		$this->assertEquals( $isValid, $obj->isValid() );
+		$this->assertEquals( $expected, $obj->getJsonData() );
+	}
+
+	public static function provideValidConstruction() {
+		return array(
+			array( 'foo', CONTENT_MODEL_JSON, false, null ),
+			array( FormatJson::encode( array() ), CONTENT_MODEL_JSON, true, array() ),
+			array( FormatJson::encode( array( 'foo' ) ), CONTENT_MODEL_JSON, true, array( 'foo' ) ),
+		);
+	}
+
+	/**
+	 * @dataProvider provideDataToEncode
+	 */
+	public function testBeautifyUsesFormatJson( $data ) {
+		$obj = new JsonContent( FormatJson::encode( $data ) );
+		$this->assertEquals( FormatJson::encode( $data, true ), $obj->beautifyJSON() );
+	}
+
+	public static function provideDataToEncode() {
+		return array(
+			array( array() ),
+			array( array( 'foo' ) ),
+			array( array( 'foo', 'bar' ) ),
+			array( array( 'baz' => 'foo', 'bar' ) ),
+			array( array( 'baz' => 1000, 'bar' ) ),
+		);
+	}
+
+	/**
+	 * @dataProvider provideDataToEncode
+	 */
+	public function testPreSaveTransform( $data ) {
+		$obj = new JsonContent( FormatJson::encode( $data ) );
+		$newObj = $obj->preSaveTransform( $this->getMockTitle(), $this->getMockUser(), $this->getMockParserOptions() );
+		$this->assertTrue( $newObj->equals( new JsonContent( FormatJson::encode( $data, true ) ) ) );
+	}
+
+	private function getMockTitle() {
+		return $this->getMockBuilder( 'Title' )
+			->disableOriginalConstructor()
+			->getMock();
+	}
+
+	private function getMockUser() {
+		return $this->getMockBuilder( 'User' )
+			->disableOriginalConstructor()
+			->getMock();
+	}
+	private function getMockParserOptions() {
+		return $this->getMockBuilder( 'ParserOptions' )
+			->disableOriginalConstructor()
+			->getMock();
+	}
+
+	/**
+	 * @dataProvider provideDataAndParserText
+	 */
+	public function testFillParserOutput( $data, $expected ) {
+		$obj = new JsonContent( FormatJson::encode( $data ) );
+		$parserOutput = $obj->getParserOutput( $this->getMockTitle(), null, null, true );
+		$this->assertInstanceOf( 'ParserOutput', $parserOutput );
+		$this->assertEquals( $expected, $parserOutput->getText() );
+	}
+
+	public static function provideDataAndParserText() {
+		return array(
+			array(
+				array(),
+				'<table class="mw-json"><tbody></tbody></table>'
+			),
+			array(
+				array( 'foo' ),
+				'<table class="mw-json"><tbody><tr><th>0</th><td class="value">&quot;foo&quot;</td></tr></tbody></table>'
+			),
+			array(
+				array( 'foo', 'bar' ),
+				'<table class="mw-json"><tbody><tr><th>0</th><td class="value">&quot;foo&quot;</td></tr>' .
+				"\n" .
+				'<tr><th>1</th><td class="value">&quot;bar&quot;</td></tr></tbody></table>'
+			),
+			array(
+				array( 'baz' => 'foo', 'bar' ),
+				'<table class="mw-json"><tbody><tr><th>baz</th><td class="value">&quot;foo&quot;</td></tr>' .
+				"\n" .
+				'<tr><th>0</th><td class="value">&quot;bar&quot;</td></tr></tbody></table>'
+			),
+			array(
+				array( 'baz' => 1000, 'bar' ),
+				'<table class="mw-json"><tbody><tr><th>baz</th><td class="value">1000</td></tr>' .
+				"\n" .
+				'<tr><th>0</th><td class="value">&quot;bar&quot;</td></tr></tbody></table>'
+			),
+			array(
+				array( '<script>alert("evil!")</script>'),
+				'<table class="mw-json"><tbody><tr><th>0</th><td class="value">&quot;&lt;script&gt;alert(&quot;evil!&quot;)&lt;/script&gt;&quot;</td></tr></tbody></table>',
+			),
+		);
+	}
+}
diff --git a/tests/phpunit/includes/content/TextContentTest.php b/tests/phpunit/includes/content/TextContentTest.php
new file mode 100644
index 00000000..2f811094
--- /dev/null
+++ b/tests/phpunit/includes/content/TextContentTest.php
@@ -0,0 +1,490 @@
+<?php
+
+/**
+ * @group ContentHandler
+ * @group Database
+ *        ^--- needed, because we do need the database to test link updates
+ */
+class TextContentTest extends MediaWikiLangTestCase {
+	protected $context;
+	protected $savedContentGetParserOutput;
+
+	protected function setUp() {
+		global $wgHooks;
+
+		parent::setUp();
+
+		// Anon user
+		$user = new User();
+		$user->setName( '127.0.0.1' );
+
+		$this->context = new RequestContext( new FauxRequest() );
+		$this->context->setTitle( Title::newFromText( 'Test' ) );
+		$this->context->setUser( $user );
+
+		$this->setMwGlobals( array(
+			'wgUser' => $user,
+			'wgTextModelsToParse' => array(
+				CONTENT_MODEL_WIKITEXT,
+				CONTENT_MODEL_CSS,
+				CONTENT_MODEL_JAVASCRIPT,
+			),
+			'wgUseTidy' => false,
+			'wgAlwaysUseTidy' => false,
+			'wgCapitalLinks' => true,
+		) );
+
+		// bypass hooks that force custom rendering
+		if ( isset( $wgHooks['ContentGetParserOutput'] )  ) {
+			$this->savedContentGetParserOutput = $wgHooks['ContentGetParserOutput'];
+			unset( $wgHooks['ContentGetParserOutput'] );
+		}
+	}
+
+	public function teardown() {
+		global $wgHooks;
+
+		// restore hooks that force custom rendering
+		if ( $this->savedContentGetParserOutput !== null ) {
+			$wgHooks['ContentGetParserOutput'] = $this->savedContentGetParserOutput;
+		}
+
+		parent::teardown();
+	}
+
+	public function newContent( $text ) {
+		return new TextContent( $text );
+	}
+
+	public static function dataGetParserOutput() {
+		return array(
+			array(
+				'TextContentTest_testGetParserOutput',
+				CONTENT_MODEL_TEXT,
+				"hello ''world'' & [[stuff]]\n", "hello ''world'' &amp; [[stuff]]",
+				array(
+					'Links' => array()
+				)
+			),
+			// TODO: more...?
+		);
+	}
+
+	/**
+	 * @dataProvider dataGetParserOutput
+	 * @covers TextContent::getParserOutput
+	 */
+	public function testGetParserOutput( $title, $model, $text, $expectedHtml,
+		$expectedFields = null
+	) {
+		$title = Title::newFromText( $title );
+		$content = ContentHandler::makeContent( $text, $title, $model );
+
+		$po = $content->getParserOutput( $title );
+
+		$html = $po->getText();
+		$html = preg_replace( '#<!--.*?-->#sm', '', $html ); // strip comments
+
+		$this->assertEquals( $expectedHtml, trim( $html ) );
+
+		if ( $expectedFields ) {
+			foreach ( $expectedFields as $field => $exp ) {
+				$f = 'get' . ucfirst( $field );
+				$v = call_user_func( array( $po, $f ) );
+
+				if ( is_array( $exp ) ) {
+					$this->assertArrayEquals( $exp, $v );
+				} else {
+					$this->assertEquals( $exp, $v );
+				}
+			}
+		}
+
+		// TODO: assert more properties
+	}
+
+	public static function dataPreSaveTransform() {
+		return array(
+			array(
+				#0: no signature resolution
+				'hello this is ~~~',
+				'hello this is ~~~',
+			),
+			array(
+				#1: rtrim
+				" Foo \n ",
+				' Foo',
+			),
+		);
+	}
+
+	/**
+	 * @dataProvider dataPreSaveTransform
+	 * @covers TextContent::preSaveTransform
+	 */
+	public function testPreSaveTransform( $text, $expected ) {
+		global $wgContLang;
+
+		$options = ParserOptions::newFromUserAndLang( $this->context->getUser(), $wgContLang );
+
+		$content = $this->newContent( $text );
+		$content = $content->preSaveTransform(
+			$this->context->getTitle(),
+			$this->context->getUser(),
+			$options
+		);
+
+		$this->assertEquals( $expected, $content->getNativeData() );
+	}
+
+	public static function dataPreloadTransform() {
+		return array(
+			array(
+				'hello this is ~~~',
+				'hello this is ~~~',
+			),
+		);
+	}
+
+	/**
+	 * @dataProvider dataPreloadTransform
+	 * @covers TextContent::preloadTransform
+	 */
+	public function testPreloadTransform( $text, $expected ) {
+		global $wgContLang;
+		$options = ParserOptions::newFromUserAndLang( $this->context->getUser(), $wgContLang );
+
+		$content = $this->newContent( $text );
+		$content = $content->preloadTransform( $this->context->getTitle(), $options );
+
+		$this->assertEquals( $expected, $content->getNativeData() );
+	}
+
+	public static function dataGetRedirectTarget() {
+		return array(
+			array( '#REDIRECT [[Test]]',
+				null,
+			),
+		);
+	}
+
+	/**
+	 * @dataProvider dataGetRedirectTarget
+	 * @covers TextContent::getRedirectTarget
+	 */
+	public function testGetRedirectTarget( $text, $expected ) {
+		$content = $this->newContent( $text );
+		$t = $content->getRedirectTarget();
+
+		if ( is_null( $expected ) ) {
+			$this->assertNull( $t, "text should not have generated a redirect target: $text" );
+		} else {
+			$this->assertEquals( $expected, $t->getPrefixedText() );
+		}
+	}
+
+	/**
+	 * @dataProvider dataGetRedirectTarget
+	 * @covers TextContent::isRedirect
+	 */
+	public function testIsRedirect( $text, $expected ) {
+		$content = $this->newContent( $text );
+
+		$this->assertEquals( !is_null( $expected ), $content->isRedirect() );
+	}
+
+	/**
+	 * @todo Test needs database! Should be done by a test class in the Database group.
+	 */
+	/*
+	public function getRedirectChain() {
+		$text = $this->getNativeData();
+		return Title::newFromRedirectArray( $text );
+	}
+	*/
+
+	/**
+	 * @todo Test needs database! Should be done by a test class in the Database group.
+	 */
+	/*
+	public function getUltimateRedirectTarget() {
+		$text = $this->getNativeData();
+		return Title::newFromRedirectRecurse( $text );
+	}
+	*/
+
+	public static function dataIsCountable() {
+		return array(
+			array( '',
+				null,
+				'any',
+				true
+			),
+			array( 'Foo',
+				null,
+				'any',
+				true
+			),
+			array( 'Foo',
+				null,
+				'comma',
+				false
+			),
+			array( 'Foo, bar',
+				null,
+				'comma',
+				false
+			),
+		);
+	}
+
+	/**
+	 * @dataProvider dataIsCountable
+	 * @group Database
+	 * @covers TextContent::isCountable
+	 */
+	public function testIsCountable( $text, $hasLinks, $mode, $expected ) {
+		$this->setMwGlobals( 'wgArticleCountMethod', $mode );
+
+		$content = $this->newContent( $text );
+
+		$v = $content->isCountable( $hasLinks, $this->context->getTitle() );
+
+		$this->assertEquals(
+			$expected,
+			$v,
+			'isCountable() returned unexpected value ' . var_export( $v, true )
+				. ' instead of ' . var_export( $expected, true )
+				. " in mode `$mode` for text \"$text\""
+		);
+	}
+
+	public static function dataGetTextForSummary() {
+		return array(
+			array( "hello\nworld.",
+				16,
+				'hello world.',
+			),
+			array( 'hello world.',
+				8,
+				'hello...',
+			),
+			array( '[[hello world]].',
+				8,
+				'[[hel...',
+			),
+		);
+	}
+
+	/**
+	 * @dataProvider dataGetTextForSummary
+	 * @covers TextContent::getTextForSummary
+	 */
+	public function testGetTextForSummary( $text, $maxlength, $expected ) {
+		$content = $this->newContent( $text );
+
+		$this->assertEquals( $expected, $content->getTextForSummary( $maxlength ) );
+	}
+
+	/**
+	 * @covers TextContent::getTextForSearchIndex
+	 */
+	public function testGetTextForSearchIndex() {
+		$content = $this->newContent( 'hello world.' );
+
+		$this->assertEquals( 'hello world.', $content->getTextForSearchIndex() );
+	}
+
+	/**
+	 * @covers TextContent::copy
+	 */
+	public function testCopy() {
+		$content = $this->newContent( 'hello world.' );
+		$copy = $content->copy();
+
+		$this->assertTrue( $content->equals( $copy ), 'copy must be equal to original' );
+		$this->assertEquals( 'hello world.', $copy->getNativeData() );
+	}
+
+	/**
+	 * @covers TextContent::getSize
+	 */
+	public function testGetSize() {
+		$content = $this->newContent( 'hello world.' );
+
+		$this->assertEquals( 12, $content->getSize() );
+	}
+
+	/**
+	 * @covers TextContent::getNativeData
+	 */
+	public function testGetNativeData() {
+		$content = $this->newContent( 'hello world.' );
+
+		$this->assertEquals( 'hello world.', $content->getNativeData() );
+	}
+
+	/**
+	 * @covers TextContent::getWikitextForTransclusion
+	 */
+	public function testGetWikitextForTransclusion() {
+		$content = $this->newContent( 'hello world.' );
+
+		$this->assertEquals( 'hello world.', $content->getWikitextForTransclusion() );
+	}
+
+	/**
+	 * @covers TextContent::getModel
+	 */
+	public function testGetModel() {
+		$content = $this->newContent( "hello world." );
+
+		$this->assertEquals( CONTENT_MODEL_TEXT, $content->getModel() );
+	}
+
+	/**
+	 * @covers TextContent::getContentHandler
+	 */
+	public function testGetContentHandler() {
+		$content = $this->newContent( "hello world." );
+
+		$this->assertEquals( CONTENT_MODEL_TEXT, $content->getContentHandler()->getModelID() );
+	}
+
+	public static function dataIsEmpty() {
+		return array(
+			array( '', true ),
+			array( '  ', false ),
+			array( '0', false ),
+			array( 'hallo welt.', false ),
+		);
+	}
+
+	/**
+	 * @dataProvider dataIsEmpty
+	 * @covers TextContent::isEmpty
+	 */
+	public function testIsEmpty( $text, $empty ) {
+		$content = $this->newContent( $text );
+
+		$this->assertEquals( $empty, $content->isEmpty() );
+	}
+
+	public static function dataEquals() {
+		return array(
+			array( new TextContent( "hallo" ), null, false ),
+			array( new TextContent( "hallo" ), new TextContent( "hallo" ), true ),
+			array( new TextContent( "hallo" ), new JavaScriptContent( "hallo" ), false ),
+			array( new TextContent( "hallo" ), new WikitextContent( "hallo" ), false ),
+			array( new TextContent( "hallo" ), new TextContent( "HALLO" ), false ),
+		);
+	}
+
+	/**
+	 * @dataProvider dataEquals
+	 * @covers TextContent::equals
+	 */
+	public function testEquals( Content $a, Content $b = null, $equal = false ) {
+		$this->assertEquals( $equal, $a->equals( $b ) );
+	}
+
+	public static function dataGetDeletionUpdates() {
+		return array(
+			array( "TextContentTest_testGetSecondaryDataUpdates_1",
+				CONTENT_MODEL_TEXT, "hello ''world''\n",
+				array()
+			),
+			array( "TextContentTest_testGetSecondaryDataUpdates_2",
+				CONTENT_MODEL_TEXT, "hello [[world test 21344]]\n",
+				array()
+			),
+			// TODO: more...?
+		);
+	}
+
+	/**
+	 * @dataProvider dataGetDeletionUpdates
+	 * @covers TextContent::getDeletionUpdates
+	 */
+	public function testDeletionUpdates( $title, $model, $text, $expectedStuff ) {
+		$ns = $this->getDefaultWikitextNS();
+		$title = Title::newFromText( $title, $ns );
+
+		$content = ContentHandler::makeContent( $text, $title, $model );
+
+		$page = WikiPage::factory( $title );
+		$page->doEditContent( $content, '' );
+
+		$updates = $content->getDeletionUpdates( $page );
+
+		// make updates accessible by class name
+		foreach ( $updates as $update ) {
+			$class = get_class( $update );
+			$updates[$class] = $update;
+		}
+
+		if ( !$expectedStuff ) {
+			$this->assertTrue( true ); // make phpunit happy
+			return;
+		}
+
+		foreach ( $expectedStuff as $class => $fieldValues ) {
+			$this->assertArrayHasKey( $class, $updates, "missing an update of type $class" );
+
+			$update = $updates[$class];
+
+			foreach ( $fieldValues as $field => $value ) {
+				$v = $update->$field; #if the field doesn't exist, just crash and burn
+				$this->assertEquals( $value, $v, "unexpected value for field $field in instance of $class" );
+			}
+		}
+
+		$page->doDeleteArticle( '' );
+	}
+
+	public static function provideConvert() {
+		return array(
+			array( // #0
+				'Hallo Welt',
+				CONTENT_MODEL_WIKITEXT,
+				'lossless',
+				'Hallo Welt'
+			),
+			array( // #1
+				'Hallo Welt',
+				CONTENT_MODEL_WIKITEXT,
+				'lossless',
+				'Hallo Welt'
+			),
+			array( // #1
+				'Hallo Welt',
+				CONTENT_MODEL_CSS,
+				'lossless',
+				'Hallo Welt'
+			),
+			array( // #1
+				'Hallo Welt',
+				CONTENT_MODEL_JAVASCRIPT,
+				'lossless',
+				'Hallo Welt'
+			),
+		);
+	}
+
+	/**
+	 * @dataProvider provideConvert
+	 * @covers TextContent::convert
+	 */
+	public function testConvert( $text, $model, $lossy, $expectedNative ) {
+		$content = $this->newContent( $text );
+
+		$converted = $content->convert( $model, $lossy );
+
+		if ( $expectedNative === false ) {
+			$this->assertFalse( $converted, "conversion to $model was expected to fail!" );
+		} else {
+			$this->assertInstanceOf( 'Content', $converted );
+			$this->assertEquals( $expectedNative, $converted->getNativeData() );
+		}
+	}
+}
diff --git a/tests/phpunit/includes/content/WikitextContentHandlerTest.php b/tests/phpunit/includes/content/WikitextContentHandlerTest.php
new file mode 100644
index 00000000..38fb5733
--- /dev/null
+++ b/tests/phpunit/includes/content/WikitextContentHandlerTest.php
@@ -0,0 +1,241 @@
+<?php
+
+/**
+ * @group ContentHandler
+ */
+class WikitextContentHandlerTest extends MediaWikiLangTestCase {
+	/**
+	 * @var ContentHandler
+	 */
+	private $handler;
+
+	protected function setUp() {
+		parent::setUp();
+
+		$this->handler = ContentHandler::getForModelID( CONTENT_MODEL_WIKITEXT );
+	}
+
+	/**
+	 * @covers WikitextContentHandler::serializeContent
+	 */
+	public function testSerializeContent() {
+		$content = new WikitextContent( 'hello world' );
+
+		$this->assertEquals( 'hello world', $this->handler->serializeContent( $content ) );
+		$this->assertEquals(
+			'hello world',
+			$this->handler->serializeContent( $content, CONTENT_FORMAT_WIKITEXT )
+		);
+
+		try {
+			$this->handler->serializeContent( $content, 'dummy/foo' );
+			$this->fail( "serializeContent() should have failed on unknown format" );
+		} catch ( MWException $e ) {
+			// ok, as expected
+		}
+	}
+
+	/**
+	 * @covers WikitextContentHandler::unserializeContent
+	 */
+	public function testUnserializeContent() {
+		$content = $this->handler->unserializeContent( 'hello world' );
+		$this->assertEquals( 'hello world', $content->getNativeData() );
+
+		$content = $this->handler->unserializeContent( 'hello world', CONTENT_FORMAT_WIKITEXT );
+		$this->assertEquals( 'hello world', $content->getNativeData() );
+
+		try {
+			$this->handler->unserializeContent( 'hello world', 'dummy/foo' );
+			$this->fail( "unserializeContent() should have failed on unknown format" );
+		} catch ( MWException $e ) {
+			// ok, as expected
+		}
+	}
+
+	/**
+	 * @covers WikitextContentHandler::makeEmptyContent
+	 */
+	public function testMakeEmptyContent() {
+		$content = $this->handler->makeEmptyContent();
+
+		$this->assertTrue( $content->isEmpty() );
+		$this->assertEquals( '', $content->getNativeData() );
+	}
+
+	public static function dataIsSupportedFormat() {
+		return array(
+			array( null, true ),
+			array( CONTENT_FORMAT_WIKITEXT, true ),
+			array( 99887766, false ),
+		);
+	}
+
+	/**
+	 * @dataProvider provideMakeRedirectContent
+	 * @param Title|string $title Title object or string for Title::newFromText()
+	 * @param string $expected Serialized form of the content object built
+	 * @covers WikitextContentHandler::makeRedirectContent
+	 */
+	public function testMakeRedirectContent( $title, $expected ) {
+		global $wgContLang;
+		$wgContLang->resetNamespaces();
+
+		MagicWord::clearCache();
+
+		if ( is_string( $title ) ) {
+			$title = Title::newFromText( $title );
+		}
+		$content = $this->handler->makeRedirectContent( $title );
+		$this->assertEquals( $expected, $content->serialize() );
+	}
+
+	public static function provideMakeRedirectContent() {
+		return array(
+			array( 'Hello', '#REDIRECT [[Hello]]' ),
+			array( 'Template:Hello', '#REDIRECT [[Template:Hello]]' ),
+			array( 'Hello#section', '#REDIRECT [[Hello#section]]' ),
+			array( 'user:john_doe#section', '#REDIRECT [[User:John doe#section]]' ),
+			array( 'MEDIAWIKI:FOOBAR', '#REDIRECT [[MediaWiki:FOOBAR]]' ),
+			array( 'Category:Foo', '#REDIRECT [[:Category:Foo]]' ),
+			array( Title::makeTitle( NS_MAIN, 'en:Foo' ), '#REDIRECT [[en:Foo]]' ),
+			array( Title::makeTitle( NS_MAIN, 'Foo', '', 'en' ), '#REDIRECT [[:en:Foo]]' ),
+			array(
+				Title::makeTitle( NS_MAIN, 'Bar', 'fragment', 'google' ),
+				'#REDIRECT [[google:Bar#fragment]]'
+			),
+		);
+	}
+
+	/**
+	 * @dataProvider dataIsSupportedFormat
+	 * @covers WikitextContentHandler::isSupportedFormat
+	 */
+	public function testIsSupportedFormat( $format, $supported ) {
+		$this->assertEquals( $supported, $this->handler->isSupportedFormat( $format ) );
+	}
+
+	public static function dataMerge3() {
+		return array(
+			array(
+				"first paragraph
+
+					second paragraph\n",
+
+				"FIRST paragraph
+
+					second paragraph\n",
+
+				"first paragraph
+
+					SECOND paragraph\n",
+
+				"FIRST paragraph
+
+					SECOND paragraph\n",
+			),
+
+			array( "first paragraph
+					second paragraph\n",
+
+				"Bla bla\n",
+
+				"Blubberdibla\n",
+
+				false,
+			),
+		);
+	}
+
+	/**
+	 * @dataProvider dataMerge3
+	 * @covers WikitextContentHandler::merge3
+	 */
+	public function testMerge3( $old, $mine, $yours, $expected ) {
+		$this->checkHasDiff3();
+
+		// test merge
+		$oldContent = new WikitextContent( $old );
+		$myContent = new WikitextContent( $mine );
+		$yourContent = new WikitextContent( $yours );
+
+		$merged = $this->handler->merge3( $oldContent, $myContent, $yourContent );
+
+		$this->assertEquals( $expected, $merged ? $merged->getNativeData() : $merged );
+	}
+
+	public static function dataGetAutosummary() {
+		return array(
+			array(
+				'Hello there, world!',
+				'#REDIRECT [[Foo]]',
+				0,
+				'/^Redirected page .*Foo/'
+			),
+
+			array(
+				null,
+				'Hello world!',
+				EDIT_NEW,
+				'/^Created page .*Hello/'
+			),
+
+			array(
+				'Hello there, world!',
+				'',
+				0,
+				'/^Blanked/'
+			),
+
+			array(
+				'Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy
+				eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam
+				voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet
+				clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet.',
+				'Hello world!',
+				0,
+				'/^Replaced .*Hello/'
+			),
+
+			array(
+				'foo',
+				'bar',
+				0,
+				'/^$/'
+			),
+		);
+	}
+
+	/**
+	 * @dataProvider dataGetAutosummary
+	 * @covers WikitextContentHandler::getAutosummary
+	 */
+	public function testGetAutosummary( $old, $new, $flags, $expected ) {
+		$oldContent = is_null( $old ) ? null : new WikitextContent( $old );
+		$newContent = is_null( $new ) ? null : new WikitextContent( $new );
+
+		$summary = $this->handler->getAutosummary( $oldContent, $newContent, $flags );
+
+		$this->assertTrue(
+			(bool)preg_match( $expected, $summary ),
+			"Autosummary didn't match expected pattern $expected: $summary"
+		);
+	}
+
+	/**
+	 * @todo Text case requires database, should be done by a test class in the Database group
+	 */
+	/*
+	public function testGetAutoDeleteReason( Title $title, &$hasHistory ) {}
+	*/
+
+	/**
+	 * @todo Text case requires database, should be done by a test class in the Database group
+	 */
+	/*
+	public function testGetUndoContent( Revision $current, Revision $undo,
+		Revision $undoafter = null
+	) {
+	}
+	*/
+}
diff --git a/tests/phpunit/includes/content/WikitextContentTest.php b/tests/phpunit/includes/content/WikitextContentTest.php
new file mode 100644
index 00000000..7becd6f4
--- /dev/null
+++ b/tests/phpunit/includes/content/WikitextContentTest.php
@@ -0,0 +1,433 @@
+<?php
+
+/**
+ * @group ContentHandler
+ *
+ * @group Database
+ *        ^--- needed, because we do need the database to test link updates
+ */
+class WikitextContentTest extends TextContentTest {
+	public static $sections = "Intro
+
+== stuff ==
+hello world
+
+== test ==
+just a test
+
+== foo ==
+more stuff
+";
+
+	public function newContent( $text ) {
+		return new WikitextContent( $text );
+	}
+
+	public static function dataGetParserOutput() {
+		return array(
+			array(
+				"WikitextContentTest_testGetParserOutput",
+				CONTENT_MODEL_WIKITEXT,
+				"hello ''world''\n",
+				"<p>hello <i>world</i>\n</p>"
+			),
+			// TODO: more...?
+		);
+	}
+
+	public static function dataGetSecondaryDataUpdates() {
+		return array(
+			array( "WikitextContentTest_testGetSecondaryDataUpdates_1",
+				CONTENT_MODEL_WIKITEXT, "hello ''world''\n",
+				array(
+					'LinksUpdate' => array(
+						'mRecursive' => true,
+						'mLinks' => array()
+					)
+				)
+			),
+			array( "WikitextContentTest_testGetSecondaryDataUpdates_2",
+				CONTENT_MODEL_WIKITEXT, "hello [[world test 21344]]\n",
+				array(
+					'LinksUpdate' => array(
+						'mRecursive' => true,
+						'mLinks' => array(
+							array( 'World_test_21344' => 0 )
+						)
+					)
+				)
+			),
+			// TODO: more...?
+		);
+	}
+
+	/**
+	 * @dataProvider dataGetSecondaryDataUpdates
+	 * @group Database
+	 * @covers WikitextContent::getSecondaryDataUpdates
+	 */
+	public function testGetSecondaryDataUpdates( $title, $model, $text, $expectedStuff ) {
+		$ns = $this->getDefaultWikitextNS();
+		$title = Title::newFromText( $title, $ns );
+
+		$content = ContentHandler::makeContent( $text, $title, $model );
+
+		$page = WikiPage::factory( $title );
+		$page->doEditContent( $content, '' );
+
+		$updates = $content->getSecondaryDataUpdates( $title );
+
+		// make updates accessible by class name
+		foreach ( $updates as $update ) {
+			$class = get_class( $update );
+			$updates[$class] = $update;
+		}
+
+		foreach ( $expectedStuff as $class => $fieldValues ) {
+			$this->assertArrayHasKey( $class, $updates, "missing an update of type $class" );
+
+			$update = $updates[$class];
+
+			foreach ( $fieldValues as $field => $value ) {
+				$v = $update->$field; #if the field doesn't exist, just crash and burn
+				$this->assertEquals( $value, $v, "unexpected value for field $field in instance of $class" );
+			}
+		}
+
+		$page->doDeleteArticle( '' );
+	}
+
+	public static function dataGetSection() {
+		return array(
+			array( WikitextContentTest::$sections,
+				"0",
+				"Intro"
+			),
+			array( WikitextContentTest::$sections,
+				"2",
+				"== test ==
+just a test"
+			),
+			array( WikitextContentTest::$sections,
+				"8",
+				false
+			),
+		);
+	}
+
+	/**
+	 * @dataProvider dataGetSection
+	 * @covers WikitextContent::getSection
+	 */
+	public function testGetSection( $text, $sectionId, $expectedText ) {
+		$content = $this->newContent( $text );
+
+		$sectionContent = $content->getSection( $sectionId );
+		if ( is_object( $sectionContent ) ) {
+			$sectionText = $sectionContent->getNativeData();
+		} else {
+			$sectionText = $sectionContent;
+		}
+
+		$this->assertEquals( $expectedText, $sectionText );
+	}
+
+	public static function dataReplaceSection() {
+		return array(
+			array( WikitextContentTest::$sections,
+				"0",
+				"No more",
+				null,
+				trim( preg_replace( '/^Intro/sm', 'No more', WikitextContentTest::$sections ) )
+			),
+			array( WikitextContentTest::$sections,
+				"",
+				"No more",
+				null,
+				"No more"
+			),
+			array( WikitextContentTest::$sections,
+				"2",
+				"== TEST ==\nmore fun",
+				null,
+				trim( preg_replace(
+					'/^== test ==.*== foo ==/sm', "== TEST ==\nmore fun\n\n== foo ==",
+					WikitextContentTest::$sections
+				) )
+			),
+			array( WikitextContentTest::$sections,
+				"8",
+				"No more",
+				null,
+				WikitextContentTest::$sections
+			),
+			array( WikitextContentTest::$sections,
+				"new",
+				"No more",
+				"New",
+				trim( WikitextContentTest::$sections ) . "\n\n\n== New ==\n\nNo more"
+			),
+		);
+	}
+
+	/**
+	 * @dataProvider dataReplaceSection
+	 * @covers WikitextContent::replaceSection
+	 */
+	public function testReplaceSection( $text, $section, $with, $sectionTitle, $expected ) {
+		$content = $this->newContent( $text );
+		$c = $content->replaceSection( $section, $this->newContent( $with ), $sectionTitle );
+
+		$this->assertEquals( $expected, is_null( $c ) ? null : $c->getNativeData() );
+	}
+
+	/**
+	 * @covers WikitextContent::addSectionHeader
+	 */
+	public function testAddSectionHeader() {
+		$content = $this->newContent( 'hello world' );
+		$content = $content->addSectionHeader( 'test' );
+
+		$this->assertEquals( "== test ==\n\nhello world", $content->getNativeData() );
+	}
+
+	public static function dataPreSaveTransform() {
+		return array(
+			array( 'hello this is ~~~',
+				"hello this is [[Special:Contributions/127.0.0.1|127.0.0.1]]",
+			),
+			array( 'hello \'\'this\'\' is <nowiki>~~~</nowiki>',
+				'hello \'\'this\'\' is <nowiki>~~~</nowiki>',
+			),
+			array( // rtrim
+				" Foo \n ",
+				" Foo",
+			),
+		);
+	}
+
+	public static function dataPreloadTransform() {
+		return array(
+			array( 'hello this is ~~~',
+				"hello this is ~~~",
+			),
+			array( 'hello \'\'this\'\' is <noinclude>foo</noinclude><includeonly>bar</includeonly>',
+				'hello \'\'this\'\' is bar',
+			),
+		);
+	}
+
+	public static function dataGetRedirectTarget() {
+		return array(
+			array( '#REDIRECT [[Test]]',
+				'Test',
+			),
+			array( '#REDIRECT Test',
+				null,
+			),
+			array( '* #REDIRECT [[Test]]',
+				null,
+			),
+		);
+	}
+
+	public static function dataGetTextForSummary() {
+		return array(
+			array( "hello\nworld.",
+				16,
+				'hello world.',
+			),
+			array( 'hello world.',
+				8,
+				'hello...',
+			),
+			array( '[[hello world]].',
+				8,
+				'hel...',
+			),
+		);
+	}
+
+	public static function dataIsCountable() {
+		return array(
+			array( '',
+				null,
+				'any',
+				true
+			),
+			array( 'Foo',
+				null,
+				'any',
+				true
+			),
+			array( 'Foo',
+				null,
+				'comma',
+				false
+			),
+			array( 'Foo, bar',
+				null,
+				'comma',
+				true
+			),
+			array( 'Foo',
+				null,
+				'link',
+				false
+			),
+			array( 'Foo [[bar]]',
+				null,
+				'link',
+				true
+			),
+			array( 'Foo',
+				true,
+				'link',
+				true
+			),
+			array( 'Foo [[bar]]',
+				false,
+				'link',
+				false
+			),
+			array( '#REDIRECT [[bar]]',
+				true,
+				'any',
+				false
+			),
+			array( '#REDIRECT [[bar]]',
+				true,
+				'comma',
+				false
+			),
+			array( '#REDIRECT [[bar]]',
+				true,
+				'link',
+				false
+			),
+		);
+	}
+
+	/**
+	 * @covers WikitextContent::matchMagicWord
+	 */
+	public function testMatchMagicWord() {
+		$mw = MagicWord::get( "staticredirect" );
+
+		$content = $this->newContent( "#REDIRECT [[FOO]]\n__STATICREDIRECT__" );
+		$this->assertTrue( $content->matchMagicWord( $mw ), "should have matched magic word" );
+
+		$content = $this->newContent( "#REDIRECT [[FOO]]" );
+		$this->assertFalse( $content->matchMagicWord( $mw ), "should not have matched magic word" );
+	}
+
+	/**
+	 * @covers WikitextContent::updateRedirect
+	 */
+	public function testUpdateRedirect() {
+		$target = Title::newFromText( "testUpdateRedirect_target" );
+
+		// test with non-redirect page
+		$content = $this->newContent( "hello world." );
+		$newContent = $content->updateRedirect( $target );
+
+		$this->assertTrue( $content->equals( $newContent ), "content should be unchanged" );
+
+		// test with actual redirect
+		$content = $this->newContent( "#REDIRECT [[Someplace]]" );
+		$newContent = $content->updateRedirect( $target );
+
+		$this->assertFalse( $content->equals( $newContent ), "content should have changed" );
+		$this->assertTrue( $newContent->isRedirect(), "new content should be a redirect" );
+
+		$this->assertEquals( $target->getFullText(), $newContent->getRedirectTarget()->getFullText() );
+	}
+
+	/**
+	 * @covers WikitextContent::getModel
+	 */
+	public function testGetModel() {
+		$content = $this->newContent( "hello world." );
+
+		$this->assertEquals( CONTENT_MODEL_WIKITEXT, $content->getModel() );
+	}
+
+	/**
+	 * @covers WikitextContent::getContentHandler
+	 */
+	public function testGetContentHandler() {
+		$content = $this->newContent( "hello world." );
+
+		$this->assertEquals( CONTENT_MODEL_WIKITEXT, $content->getContentHandler()->getModelID() );
+	}
+
+	public function testRedirectParserOption() {
+		$title = Title::newFromText( 'testRedirectParserOption' );
+
+		// Set up hook and its reporting variables
+		$wikitext = null;
+		$redirectTarget = null;
+		$this->mergeMwGlobalArrayValue( 'wgHooks', array(
+			'InternalParseBeforeLinks' => array(
+				function ( &$parser, &$text, &$stripState ) use ( &$wikitext, &$redirectTarget ) {
+					$wikitext = $text;
+					$redirectTarget = $parser->getOptions()->getRedirectTarget();
+				}
+			)
+		) );
+
+		// Test with non-redirect page
+		$wikitext = false;
+		$redirectTarget = false;
+		$content = $this->newContent( 'hello world.' );
+		$options = $content->getContentHandler()->makeParserOptions( 'canonical' );
+		$options->setRedirectTarget( $title );
+		$content->getParserOutput( $title, null, $options );
+		$this->assertEquals( 'hello world.', $wikitext,
+			'Wikitext passed to hook was not as expected'
+		);
+		$this->assertEquals( null, $redirectTarget, 'Redirect seen in hook was not null' );
+		$this->assertEquals( $title, $options->getRedirectTarget(),
+			'ParserOptions\' redirectTarget was changed'
+		);
+
+		// Test with a redirect page
+		$wikitext = false;
+		$redirectTarget = false;
+		$content = $this->newContent( "#REDIRECT [[TestRedirectParserOption/redir]]\nhello redirect." );
+		$options = $content->getContentHandler()->makeParserOptions( 'canonical' );
+		$content->getParserOutput( $title, null, $options );
+		$this->assertEquals( 'hello redirect.', $wikitext, 'Wikitext passed to hook was not as expected' );
+		$this->assertNotEquals( null, $redirectTarget, 'Redirect seen in hook was null' );
+		$this->assertEquals( 'TestRedirectParserOption/redir', $redirectTarget->getFullText(),
+			'Redirect seen in hook was not the expected title'
+		);
+		$this->assertEquals( null, $options->getRedirectTarget(),
+			'ParserOptions\' redirectTarget was changed'
+		);
+	}
+
+	public static function dataEquals() {
+		return array(
+			array( new WikitextContent( "hallo" ), null, false ),
+			array( new WikitextContent( "hallo" ), new WikitextContent( "hallo" ), true ),
+			array( new WikitextContent( "hallo" ), new JavaScriptContent( "hallo" ), false ),
+			array( new WikitextContent( "hallo" ), new TextContent( "hallo" ), false ),
+			array( new WikitextContent( "hallo" ), new WikitextContent( "HALLO" ), false ),
+		);
+	}
+
+	public static function dataGetDeletionUpdates() {
+		return array(
+			array( "WikitextContentTest_testGetSecondaryDataUpdates_1",
+				CONTENT_MODEL_WIKITEXT, "hello ''world''\n",
+				array( 'LinksDeletionUpdate' => array() )
+			),
+			array( "WikitextContentTest_testGetSecondaryDataUpdates_2",
+				CONTENT_MODEL_WIKITEXT, "hello [[world test 21344]]\n",
+				array( 'LinksDeletionUpdate' => array() )
+			),
+			// @todo more...?
+		);
+	}
+}