*/
public function testIsSubject() {
// Special namespaces
- $this->assertTrue( MWNamespace::isSubject( NS_MEDIA ) );
- $this->assertTrue( MWNamespace::isSubject( NS_SPECIAL ) );
+ $this->assertIsSubject( NS_MEDIA );
+ $this->assertIsSubject( NS_SPECIAL );
// Subject pages
- $this->assertTrue( MWNamespace::isSubject( NS_MAIN ) );
- $this->assertTrue( MWNamespace::isSubject( NS_USER ) );
- $this->assertTrue( MWNamespace::isSubject( 100 ) ); # user defined
+ $this->assertIsSubject( NS_MAIN );
+ $this->assertIsSubject( NS_USER );
+ $this->assertIsSubject( 100 ); # user defined
// Talk pages
- $this->assertFalse( MWNamespace::isSubject( NS_TALK ) );
- $this->assertFalse( MWNamespace::isSubject( NS_USER_TALK ) );
- $this->assertFalse( MWNamespace::isSubject( 101 ) ); # user defined
-
- // Back compat
- $this->assertTrue( MWNamespace::isMain( NS_MAIN ) == MWNamespace::isSubject( NS_MAIN ) );
- $this->assertTrue( MWNamespace::isMain( NS_USER_TALK ) == MWNamespace::isSubject( NS_USER_TALK ) );
+ $this->assertIsNotSubject( NS_TALK );
+ $this->assertIsNotSubject( NS_USER_TALK );
+ $this->assertIsNotSubject( 101 ); # user defined
}
/**
*/
public function testIsTalk() {
// Special namespaces
- $this->assertFalse( MWNamespace::isTalk( NS_MEDIA ) );
- $this->assertFalse( MWNamespace::isTalk( NS_SPECIAL ) );
+ $this->assertIsNotTalk( NS_MEDIA );
+ $this->assertIsNotTalk( NS_SPECIAL );
// Subject pages
- $this->assertFalse( MWNamespace::isTalk( NS_MAIN ) );
- $this->assertFalse( MWNamespace::isTalk( NS_USER ) );
- $this->assertFalse( MWNamespace::isTalk( 100 ) ); # user defined
+ $this->assertIsNotTalk( NS_MAIN );
+ $this->assertIsNotTalk( NS_USER );
+ $this->assertIsNotTalk( 100 ); # user defined
// Talk pages
- $this->assertTrue( MWNamespace::isTalk( NS_TALK ) );
- $this->assertTrue( MWNamespace::isTalk( NS_USER_TALK ) );
- $this->assertTrue( MWNamespace::isTalk( 101 ) ); # user defined
+ $this->assertIsTalk( NS_TALK );
+ $this->assertIsTalk( NS_USER_TALK );
+ $this->assertIsTalk( 101 ); # user defined
}
/**
$this->assertNull( MWNamespace::getTalk( NS_MEDIA ) );
}
- /**
+ /**
* Exceptions with getTalk()
* NS_SPECIAL does not have talk pages. MediaWiki raise an exception for them.
* @expectedException MWException
* Test MWNamespace::subjectEquals
*/
public function testSubjectEquals() {
- $this->assertTrue( MWNamespace::subjectEquals( NS_MAIN, NS_MAIN ) );
- $this->assertTrue( MWNamespace::subjectEquals( NS_MAIN, 0 ) ); // In case we make NS_MAIN 'MAIN'
- $this->assertTrue( MWNamespace::subjectEquals( NS_USER, NS_USER ) );
- $this->assertTrue( MWNamespace::subjectEquals( NS_USER, 2 ) );
- $this->assertTrue( MWNamespace::subjectEquals( NS_USER_TALK, NS_USER_TALK ) );
- $this->assertTrue( MWNamespace::subjectEquals( NS_SPECIAL, NS_SPECIAL ) );
- $this->assertTrue( MWNamespace::subjectEquals( NS_MAIN, NS_TALK ) );
- $this->assertTrue( MWNamespace::subjectEquals( NS_USER, NS_USER_TALK ) );
- $this->assertFalse( MWNamespace::subjectEquals( NS_PROJECT, NS_TEMPLATE ) );
+ $this->assertSameSubject( NS_MAIN, NS_MAIN );
+ $this->assertSameSubject( NS_MAIN, 0 ); // In case we make NS_MAIN 'MAIN'
+ $this->assertSameSubject( NS_USER, NS_USER );
+ $this->assertSameSubject( NS_USER, 2 );
+ $this->assertSameSubject( NS_USER_TALK, NS_USER_TALK );
+ $this->assertSameSubject( NS_SPECIAL, NS_SPECIAL );
+ $this->assertSameSubject( NS_MAIN, NS_TALK );
+ $this->assertSameSubject( NS_USER, NS_USER_TALK );
+
+ $this->assertDifferentSubject( NS_PROJECT, NS_TEMPLATE );
+ $this->assertDifferentSubject( NS_SPECIAL, NS_MAIN );
+ }
+
+ public function testSpecialAndMediaAreDifferentSubjects() {
+ $this->assertDifferentSubject(
+ NS_MEDIA, NS_SPECIAL,
+ "NS_MEDIA and NS_SPECIAL are different subject namespaces"
+ );
+ $this->assertDifferentSubject(
+ NS_SPECIAL, NS_MEDIA,
+ "NS_SPECIAL and NS_MEDIA are different subject namespaces"
+ );
+
}
/**
/**
*/
public function testCanTalk() {
- $this->assertFalse( MWNamespace::canTalk( NS_MEDIA ) );
- $this->assertFalse( MWNamespace::canTalk( NS_SPECIAL ) );
+ $this->assertCanNotTalk( NS_MEDIA );
+ $this->assertCanNotTalk( NS_SPECIAL );
- $this->assertTrue( MWNamespace::canTalk( NS_MAIN ) );
- $this->assertTrue( MWNamespace::canTalk( NS_TALK ) );
- $this->assertTrue( MWNamespace::canTalk( NS_USER ) );
- $this->assertTrue( MWNamespace::canTalk( NS_USER_TALK ) );
+ $this->assertCanTalk( NS_MAIN );
+ $this->assertCanTalk( NS_TALK );
+ $this->assertCanTalk( NS_USER );
+ $this->assertCanTalk( NS_USER_TALK );
// User defined namespaces
- $this->assertTrue( MWNamespace::canTalk( 100 ) );
- $this->assertTrue( MWNamespace::canTalk( 101 ) );
+ $this->assertCanTalk( 100 );
+ $this->assertCanTalk( 101 );
}
/**
public function testIsContent() {
// NS_MAIN is a content namespace per DefaultSettings.php
// and per function definition.
- $this->assertTrue( MWNamespace::isContent( NS_MAIN ) );
+ $this->assertIsContent( NS_MAIN );
global $wgContentNamespaces;
$saved = $wgContentNamespaces;
$wgContentNamespaces[] = NS_MAIN;
- $this->assertTrue( MWNamespace::isContent( NS_MAIN ) );
+ $this->assertIsContent( NS_MAIN );
// Other namespaces which are not expected to be content
if ( isset( $wgContentNamespaces[NS_MEDIA] ) ) {
unset( $wgContentNamespaces[NS_MEDIA] );
}
- $this->assertFalse( MWNamespace::isContent( NS_MEDIA ) );
+ $this->assertIsNotContent( NS_MEDIA );
if ( isset( $wgContentNamespaces[NS_SPECIAL] ) ) {
unset( $wgContentNamespaces[NS_SPECIAL] );
}
- $this->assertFalse( MWNamespace::isContent( NS_SPECIAL ) );
+ $this->assertIsNotContent( NS_SPECIAL );
if ( isset( $wgContentNamespaces[NS_TALK] ) ) {
unset( $wgContentNamespaces[NS_TALK] );
}
- $this->assertFalse( MWNamespace::isContent( NS_TALK ) );
+ $this->assertIsNotContent( NS_TALK );
if ( isset( $wgContentNamespaces[NS_USER] ) ) {
unset( $wgContentNamespaces[NS_USER] );
}
- $this->assertFalse( MWNamespace::isContent( NS_USER ) );
+ $this->assertIsNotContent( NS_USER );
if ( isset( $wgContentNamespaces[NS_CATEGORY] ) ) {
unset( $wgContentNamespaces[NS_CATEGORY] );
}
- $this->assertFalse( MWNamespace::isContent( NS_CATEGORY ) );
+ $this->assertIsNotContent( NS_CATEGORY );
if ( isset( $wgContentNamespaces[100] ) ) {
unset( $wgContentNamespaces[100] );
}
- $this->assertFalse( MWNamespace::isContent( 100 ) );
+ $this->assertIsNotContent( 100 );
$wgContentNamespaces = $saved;
}
public function testIsContentWithAdditionsInWgContentNamespaces() {
// NS_MAIN is a content namespace per DefaultSettings.php
// and per function definition.
- $this->assertTrue( MWNamespace::isContent( NS_MAIN ) );
+ $this->assertIsContent( NS_MAIN );
// Tests that user defined namespace #252 is not content:
- $this->assertFalse( MWNamespace::isContent( 252 ) );
+ $this->assertIsNotContent( 252 );
# @todo FIXME: Is global saving really required for PHPUnit?
// Bless namespace # 252 as a content namespace
global $wgContentNamespaces;
$savedGlobal = $wgContentNamespaces;
$wgContentNamespaces[] = 252;
- $this->assertTrue( MWNamespace::isContent( 252 ) );
+ $this->assertIsContent( 252 );
// Makes sure NS_MAIN was not impacted
- $this->assertTrue( MWNamespace::isContent( NS_MAIN ) );
+ $this->assertIsContent( NS_MAIN );
// Restore global
$wgContentNamespaces = $savedGlobal;
// Verify namespaces after global restauration
- $this->assertTrue( MWNamespace::isContent( NS_MAIN ) );
- $this->assertFalse( MWNamespace::isContent( 252 ) );
+ $this->assertIsContent( NS_MAIN );
+ $this->assertIsNotContent( 252 );
}
public function testIsWatchable() {
// Specials namespaces are not watchable
- $this->assertFalse( MWNamespace::isWatchable( NS_MEDIA ) );
- $this->assertFalse( MWNamespace::isWatchable( NS_SPECIAL ) );
+ $this->assertIsNotWatchable( NS_MEDIA );
+ $this->assertIsNotWatchable( NS_SPECIAL );
// Core defined namespaces are watchables
- $this->assertTrue( MWNamespace::isWatchable( NS_MAIN ) );
- $this->assertTrue( MWNamespace::isWatchable( NS_TALK ) );
+ $this->assertIsWatchable( NS_MAIN );
+ $this->assertIsWatchable( NS_TALK );
// Additional, user defined namespaces are watchables
- $this->assertTrue( MWNamespace::isWatchable( 100 ) );
- $this->assertTrue( MWNamespace::isWatchable( 101 ) );
+ $this->assertIsWatchable( 100 );
+ $this->assertIsWatchable( 101 );
}
public function testHasSubpages() {
// Special namespaces:
- $this->assertFalse( MWNamespace::hasSubpages( NS_MEDIA ) );
- $this->assertFalse( MWNamespace::hasSubpages( NS_SPECIAL ) );
+ $this->assertHasNotSubpages( NS_MEDIA );
+ $this->assertHasNotSubpages( NS_SPECIAL );
// namespaces without subpages
# save up global
unset( $wgNamespacesWithSubpages[NS_MAIN] );
}
- $this->assertFalse( MWNamespace::hasSubpages( NS_MAIN ) );
+ $this->assertHasNotSubpages( NS_MAIN );
$wgNamespacesWithSubpages[NS_MAIN] = true;
- $this->assertTrue( MWNamespace::hasSubpages( NS_MAIN ) );
+ $this->assertHasSubpages( NS_MAIN );
$wgNamespacesWithSubpages[NS_MAIN] = false;
- $this->assertFalse( MWNamespace::hasSubpages( NS_MAIN ) );
+ $this->assertHasNotSubpages( NS_MAIN );
# restore global
if( $saved !== null ) {
}
// Some namespaces with subpages
- $this->assertTrue( MWNamespace::hasSubpages( NS_TALK ) );
- $this->assertTrue( MWNamespace::hasSubpages( NS_USER ) );
- $this->assertTrue( MWNamespace::hasSubpages( NS_USER_TALK ) );
+ $this->assertHasSubpages( NS_TALK );
+ $this->assertHasSubpages( NS_USER );
+ $this->assertHasSubpages( NS_USER_TALK );
}
/**
$this->assertEquals(
array( NS_MAIN, NS_USER, NS_CATEGORY ),
MWNamespace::getcontentNamespaces(),
- 'NS_MAIN is forced in wgContentNamespaces even if unwanted'
+ 'NS_MAIN is forced in $wgContentNamespaces even if unwanted'
);
# test other cases, return $wgcontentNamespaces as is
);
// Boths are capitalized by default
- $this->assertTrue( MWNamespace::isCapitalized( NS_MEDIA ) );
- $this->assertTrue( MWNamespace::isCapitalized( NS_FILE ) );
+ $this->assertIsCapitalized( NS_MEDIA );
+ $this->assertIsCapitalized( NS_FILE );
// Always capitalized namespaces
// @see MWNamespace::$alwaysCapitalizedNamespaces
- $this->assertTrue( MWNamespace::isCapitalized( NS_SPECIAL ) );
- $this->assertTrue( MWNamespace::isCapitalized( NS_USER ) );
- $this->assertTrue( MWNamespace::isCapitalized( NS_MEDIAWIKI ) );
+ $this->assertIsCapitalized( NS_SPECIAL );
+ $this->assertIsCapitalized( NS_USER );
+ $this->assertIsCapitalized( NS_MEDIAWIKI );
}
/**
$savedGlobal = $wgCapitalLinks;
$wgCapitalLinks = true;
- $this->assertTrue( MWNamespace::isCapitalized( NS_PROJECT ) );
- $this->assertTrue( MWNamespace::isCapitalized( NS_PROJECT_TALK ) );
+ $this->assertIsCapitalized( NS_PROJECT );
+ $this->assertIsCapitalized( NS_PROJECT_TALK );
$wgCapitalLinks = false;
// hardcoded namespaces (see above function) are still capitalized:
- $this->assertTrue( MWNamespace::isCapitalized( NS_SPECIAL ) );
- $this->assertTrue( MWNamespace::isCapitalized( NS_USER ) );
- $this->assertTrue( MWNamespace::isCapitalized( NS_MEDIAWIKI ) );
+ $this->assertIsCapitalized( NS_SPECIAL );
+ $this->assertIsCapitalized( NS_USER );
+ $this->assertIsCapitalized( NS_MEDIAWIKI );
// setting is correctly applied
- $this->assertFalse( MWNamespace::isCapitalized( NS_PROJECT ) );
- $this->assertFalse( MWNamespace::isCapitalized( NS_PROJECT_TALK ) );
+ $this->assertIsNotCapitalized( NS_PROJECT );
+ $this->assertIsNotCapitalized( NS_PROJECT_TALK );
// reset global state:
$wgCapitalLinks = $savedGlobal;
$savedGlobal = $wgCapitalLinkOverrides;
// Test default settings
- $this->assertTrue( MWNamespace::isCapitalized( NS_PROJECT ) );
- $this->assertTrue( MWNamespace::isCapitalized( NS_PROJECT_TALK ) );
+ $this->assertIsCapitalized( NS_PROJECT );
+ $this->assertIsCapitalized( NS_PROJECT_TALK );
// hardcoded namespaces (see above function) are capitalized:
- $this->assertTrue( MWNamespace::isCapitalized( NS_SPECIAL ) );
- $this->assertTrue( MWNamespace::isCapitalized( NS_USER ) );
- $this->assertTrue( MWNamespace::isCapitalized( NS_MEDIAWIKI ) );
+ $this->assertIsCapitalized( NS_SPECIAL );
+ $this->assertIsCapitalized( NS_USER );
+ $this->assertIsCapitalized( NS_MEDIAWIKI );
// Hardcoded namespaces remains capitalized
$wgCapitalLinkOverrides[NS_SPECIAL] = false;
$wgCapitalLinkOverrides[NS_USER] = false;
$wgCapitalLinkOverrides[NS_MEDIAWIKI] = false;
- $this->assertTrue( MWNamespace::isCapitalized( NS_SPECIAL ) );
- $this->assertTrue( MWNamespace::isCapitalized( NS_USER ) );
- $this->assertTrue( MWNamespace::isCapitalized( NS_MEDIAWIKI ) );
+ $this->assertIsCapitalized( NS_SPECIAL );
+ $this->assertIsCapitalized( NS_USER );
+ $this->assertIsCapitalized( NS_MEDIAWIKI );
$wgCapitalLinkOverrides = $savedGlobal;
$wgCapitalLinkOverrides[NS_PROJECT] = false;
- $this->assertFalse( MWNamespace::isCapitalized( NS_PROJECT ) );
+ $this->assertIsNotCapitalized( NS_PROJECT );
$wgCapitalLinkOverrides[NS_PROJECT] = true ;
- $this->assertTrue( MWNamespace::isCapitalized( NS_PROJECT ) );
+ $this->assertIsCapitalized( NS_PROJECT );
unset( $wgCapitalLinkOverrides[NS_PROJECT] );
- $this->assertTrue( MWNamespace::isCapitalized( NS_PROJECT ) );
+ $this->assertIsCapitalized( NS_PROJECT );
// reset global state:
$wgCapitalLinkOverrides = $savedGlobal;
}
+ public function testIsNonincludable() {
+ global $wgNonincludableNamespaces;
+ $wgNonincludableNamespaces = array( NS_USER );
+
+ $this->assertTrue( MWNamespace::isNonincludable( NS_USER ) );
+
+ $this->assertFalse( MWNamespace::isNonincludable( NS_TEMPLATE ) );
+ }
+
####### HELPERS ###########################################################
function __call( $method, $args ) {
// Call the real method if it exists
return $this->$method( $args );
}
- if( preg_match( '/^assert(Has|Is)(Not|)(Subject|Talk)$/', $method, $m ) ) {
+ if( preg_match( '/^assert(Has|Is|Can)(Not|)(Subject|Talk|Watchable|Content|Subpages|Capitalized)$/', $method, $m ) ) {
# Interprets arguments:
$ns = $args[0];
$msg = isset($args[1]) ? $args[1] : " dummy message";
# Forge the namespace constant name:
- $ns_name = "NS_" . strtoupper( MWNamespace::getCanonicalName( $ns ) );
+ if( $ns === 0 ) {
+ $ns_name = "NS_MAIN";
+ } else {
+ $ns_name = "NS_" . strtoupper( MWNamespace::getCanonicalName( $ns ) );
+ }
# ... and the MWNamespace method name
$nsMethod = strtolower( $m[1] ) . $m[3];
throw new Exception( __METHOD__ . " could not find a method named $method\n" );
}
+ function assertSameSubject( $ns1, $ns2, $msg = '' ) {
+ $this->assertTrue( MWNamespace::subjectEquals( $ns1, $ns2, $msg ) );
+ }
+ function assertDifferentSubject( $ns1, $ns2, $msg = '' ) {
+ $this->assertFalse( MWNamespace::subjectEquals( $ns1, $ns2, $msg ) );
+ }
}