MediaWiki  1.29.1
MWNamespaceTest.php
Go to the documentation of this file.
1 <?php
14  protected function setUp() {
15  parent::setUp();
16 
17  $this->setMwGlobals( [
18  'wgContentNamespaces' => [ NS_MAIN ],
19  'wgNamespacesWithSubpages' => [
20  NS_TALK => true,
21  NS_USER => true,
22  NS_USER_TALK => true,
23  ],
24  'wgCapitalLinks' => true,
25  'wgCapitalLinkOverrides' => [],
26  'wgNonincludableNamespaces' => [],
27  ] );
28  }
29 
30 # ### START OF TESTS #########################################################
31 
36  public function testIsMovable() {
37  $this->assertFalse( MWNamespace::isMovable( NS_SPECIAL ) );
38  # @todo FIXME: Write more tests!!
39  }
40 
45  public function testIsSubject() {
46  // Special namespaces
47  $this->assertIsSubject( NS_MEDIA );
48  $this->assertIsSubject( NS_SPECIAL );
49 
50  // Subject pages
51  $this->assertIsSubject( NS_MAIN );
52  $this->assertIsSubject( NS_USER );
53  $this->assertIsSubject( 100 ); # user defined
54 
55  // Talk pages
56  $this->assertIsNotSubject( NS_TALK );
57  $this->assertIsNotSubject( NS_USER_TALK );
58  $this->assertIsNotSubject( 101 ); # user defined
59  }
60 
66  public function testIsTalk() {
67  // Special namespaces
68  $this->assertIsNotTalk( NS_MEDIA );
69  $this->assertIsNotTalk( NS_SPECIAL );
70 
71  // Subject pages
72  $this->assertIsNotTalk( NS_MAIN );
73  $this->assertIsNotTalk( NS_USER );
74  $this->assertIsNotTalk( 100 ); # user defined
75 
76  // Talk pages
77  $this->assertIsTalk( NS_TALK );
78  $this->assertIsTalk( NS_USER_TALK );
79  $this->assertIsTalk( 101 ); # user defined
80  }
81 
85  public function testGetSubject() {
86  // Special namespaces are their own subjects
87  $this->assertEquals( NS_MEDIA, MWNamespace::getSubject( NS_MEDIA ) );
88  $this->assertEquals( NS_SPECIAL, MWNamespace::getSubject( NS_SPECIAL ) );
89 
90  $this->assertEquals( NS_MAIN, MWNamespace::getSubject( NS_TALK ) );
91  $this->assertEquals( NS_USER, MWNamespace::getSubject( NS_USER_TALK ) );
92  }
93 
100  public function testGetTalk() {
101  $this->assertEquals( NS_TALK, MWNamespace::getTalk( NS_MAIN ) );
102  $this->assertEquals( NS_TALK, MWNamespace::getTalk( NS_TALK ) );
103  $this->assertEquals( NS_USER_TALK, MWNamespace::getTalk( NS_USER ) );
104  $this->assertEquals( NS_USER_TALK, MWNamespace::getTalk( NS_USER_TALK ) );
105  }
106 
114  $this->assertNull( MWNamespace::getTalk( NS_MEDIA ) );
115  }
116 
124  $this->assertNull( MWNamespace::getTalk( NS_SPECIAL ) );
125  }
126 
133  public function testGetAssociated() {
134  $this->assertEquals( NS_TALK, MWNamespace::getAssociated( NS_MAIN ) );
135  $this->assertEquals( NS_MAIN, MWNamespace::getAssociated( NS_TALK ) );
136  }
137 
138  # ## Exceptions with getAssociated()
139  # ##┬áNS_MEDIA and NS_SPECIAL do not have talk pages. MediaWiki raises
140  # ## an exception for them.
141 
146  $this->assertNull( MWNamespace::getAssociated( NS_MEDIA ) );
147  }
148 
154  $this->assertNull( MWNamespace::getAssociated( NS_SPECIAL ) );
155  }
156 
160  /*
161  public function testExists() {
162  // Remove the following lines when you implement this test.
163  $this->markTestIncomplete(
164  'This test has not been implemented yet. Rely on $wgCanonicalNamespaces.'
165  );
166  }
167  */
168 
176  public function testEquals() {
177  $this->assertTrue( MWNamespace::equals( NS_MAIN, NS_MAIN ) );
178  $this->assertTrue( MWNamespace::equals( NS_MAIN, 0 ) ); // In case we make NS_MAIN 'MAIN'
179  $this->assertTrue( MWNamespace::equals( NS_USER, NS_USER ) );
180  $this->assertTrue( MWNamespace::equals( NS_USER, 2 ) );
181  $this->assertTrue( MWNamespace::equals( NS_USER_TALK, NS_USER_TALK ) );
182  $this->assertTrue( MWNamespace::equals( NS_SPECIAL, NS_SPECIAL ) );
183  $this->assertFalse( MWNamespace::equals( NS_MAIN, NS_TALK ) );
184  $this->assertFalse( MWNamespace::equals( NS_USER, NS_USER_TALK ) );
185  $this->assertFalse( MWNamespace::equals( NS_PROJECT, NS_TEMPLATE ) );
186  }
187 
191  public function testSubjectEquals() {
192  $this->assertSameSubject( NS_MAIN, NS_MAIN );
193  $this->assertSameSubject( NS_MAIN, 0 ); // In case we make NS_MAIN 'MAIN'
194  $this->assertSameSubject( NS_USER, NS_USER );
195  $this->assertSameSubject( NS_USER, 2 );
198  $this->assertSameSubject( NS_MAIN, NS_TALK );
200 
203  }
204 
209  $this->assertDifferentSubject(
211  "NS_MEDIA and NS_SPECIAL are different subject namespaces"
212  );
213  $this->assertDifferentSubject(
215  "NS_SPECIAL and NS_MEDIA are different subject namespaces"
216  );
217  }
218 
222  /*
223  public function testGetCanonicalNamespaces() {
224  // Remove the following lines when you implement this test.
225  $this->markTestIncomplete(
226  'This test has not been implemented yet. Rely on $wgCanonicalNamespaces.'
227  );
228  }
229  */
233  /*
234  public function testGetCanonicalName() {
235  // Remove the following lines when you implement this test.
236  $this->markTestIncomplete(
237  'This test has not been implemented yet. Rely on $wgCanonicalNamespaces.'
238  );
239  }
240  */
244  /*
245  public function testGetCanonicalIndex() {
246  // Remove the following lines when you implement this test.
247  $this->markTestIncomplete(
248  'This test has not been implemented yet. Rely on $wgCanonicalNamespaces.'
249  );
250  }
251  */
252 
256  /*
257  public function testGetValidNamespaces() {
258  // Remove the following lines when you implement this test.
259  $this->markTestIncomplete(
260  'This test has not been implemented yet. Rely on $wgCanonicalNamespaces.'
261  );
262  }
263  */
264 
268  public function testCanTalk() {
269  $this->assertCanNotTalk( NS_MEDIA );
270  $this->assertCanNotTalk( NS_SPECIAL );
271 
272  $this->assertCanTalk( NS_MAIN );
273  $this->assertCanTalk( NS_TALK );
274  $this->assertCanTalk( NS_USER );
275  $this->assertCanTalk( NS_USER_TALK );
276 
277  // User defined namespaces
278  $this->assertCanTalk( 100 );
279  $this->assertCanTalk( 101 );
280  }
281 
285  public function testIsContent() {
286  // NS_MAIN is a content namespace per DefaultSettings.php
287  // and per function definition.
288 
289  $this->assertIsContent( NS_MAIN );
290 
291  // Other namespaces which are not expected to be content
292 
293  $this->assertIsNotContent( NS_MEDIA );
294  $this->assertIsNotContent( NS_SPECIAL );
295  $this->assertIsNotContent( NS_TALK );
296  $this->assertIsNotContent( NS_USER );
297  $this->assertIsNotContent( NS_CATEGORY );
298  $this->assertIsNotContent( 100 );
299  }
300 
306  public function testIsContentAdvanced() {
307  global $wgContentNamespaces;
308 
309  // Test that user defined namespace #252 is not content
310  $this->assertIsNotContent( 252 );
311 
312  // Bless namespace # 252 as a content namespace
313  $wgContentNamespaces[] = 252;
314 
315  $this->assertIsContent( 252 );
316 
317  // Makes sure NS_MAIN was not impacted
318  $this->assertIsContent( NS_MAIN );
319  }
320 
324  public function testIsWatchable() {
325  // Specials namespaces are not watchable
326  $this->assertIsNotWatchable( NS_MEDIA );
327  $this->assertIsNotWatchable( NS_SPECIAL );
328 
329  // Core defined namespaces are watchables
330  $this->assertIsWatchable( NS_MAIN );
331  $this->assertIsWatchable( NS_TALK );
332 
333  // Additional, user defined namespaces are watchables
334  $this->assertIsWatchable( 100 );
335  $this->assertIsWatchable( 101 );
336  }
337 
341  public function testHasSubpages() {
342  global $wgNamespacesWithSubpages;
343 
344  // Special namespaces:
345  $this->assertHasNotSubpages( NS_MEDIA );
346  $this->assertHasNotSubpages( NS_SPECIAL );
347 
348  // Namespaces without subpages
349  $this->assertHasNotSubpages( NS_MAIN );
350 
351  $wgNamespacesWithSubpages[NS_MAIN] = true;
352  $this->assertHasSubpages( NS_MAIN );
353 
354  $wgNamespacesWithSubpages[NS_MAIN] = false;
355  $this->assertHasNotSubpages( NS_MAIN );
356 
357  // Some namespaces with subpages
358  $this->assertHasSubpages( NS_TALK );
359  $this->assertHasSubpages( NS_USER );
360  $this->assertHasSubpages( NS_USER_TALK );
361  }
362 
366  public function testGetContentNamespaces() {
367  global $wgContentNamespaces;
368 
369  $this->assertEquals(
370  [ NS_MAIN ],
372  '$wgContentNamespaces is an array with only NS_MAIN by default'
373  );
374 
375  # test !is_array( $wgcontentNamespaces )
376  $wgContentNamespaces = '';
377  $this->assertEquals( [ NS_MAIN ], MWNamespace::getContentNamespaces() );
378 
379  $wgContentNamespaces = false;
380  $this->assertEquals( [ NS_MAIN ], MWNamespace::getContentNamespaces() );
381 
382  $wgContentNamespaces = null;
383  $this->assertEquals( [ NS_MAIN ], MWNamespace::getContentNamespaces() );
384 
385  $wgContentNamespaces = 5;
386  $this->assertEquals( [ NS_MAIN ], MWNamespace::getContentNamespaces() );
387 
388  # test $wgContentNamespaces === []
389  $wgContentNamespaces = [];
390  $this->assertEquals( [ NS_MAIN ], MWNamespace::getContentNamespaces() );
391 
392  # test !in_array( NS_MAIN, $wgContentNamespaces )
393  $wgContentNamespaces = [ NS_USER, NS_CATEGORY ];
394  $this->assertEquals(
397  'NS_MAIN is forced in $wgContentNamespaces even if unwanted'
398  );
399 
400  # test other cases, return $wgcontentNamespaces as is
401  $wgContentNamespaces = [ NS_MAIN ];
402  $this->assertEquals(
403  [ NS_MAIN ],
405  );
406 
407  $wgContentNamespaces = [ NS_MAIN, NS_USER, NS_CATEGORY ];
408  $this->assertEquals(
411  );
412  }
413 
417  public function testGetSubjectNamespaces() {
418  $subjectsNS = MWNamespace::getSubjectNamespaces();
419  $this->assertContains( NS_MAIN, $subjectsNS,
420  "Talk namespaces should have NS_MAIN" );
421  $this->assertNotContains( NS_TALK, $subjectsNS,
422  "Talk namespaces should have NS_TALK" );
423 
424  $this->assertNotContains( NS_MEDIA, $subjectsNS,
425  "Talk namespaces should not have NS_MEDIA" );
426  $this->assertNotContains( NS_SPECIAL, $subjectsNS,
427  "Talk namespaces should not have NS_SPECIAL" );
428  }
429 
433  public function testGetTalkNamespaces() {
434  $talkNS = MWNamespace::getTalkNamespaces();
435  $this->assertContains( NS_TALK, $talkNS,
436  "Subject namespaces should have NS_TALK" );
437  $this->assertNotContains( NS_MAIN, $talkNS,
438  "Subject namespaces should not have NS_MAIN" );
439 
440  $this->assertNotContains( NS_MEDIA, $talkNS,
441  "Subject namespaces should not have NS_MEDIA" );
442  $this->assertNotContains( NS_SPECIAL, $talkNS,
443  "Subject namespaces should not have NS_SPECIAL" );
444  }
445 
452  // NS_MEDIA and NS_FILE are treated the same
453  $this->assertEquals(
456  'NS_MEDIA and NS_FILE have same capitalization rendering'
457  );
458 
459  // Boths are capitalized by default
460  $this->assertIsCapitalized( NS_MEDIA );
461  $this->assertIsCapitalized( NS_FILE );
462 
463  // Always capitalized namespaces
464  // @see MWNamespace::$alwaysCapitalizedNamespaces
465  $this->assertIsCapitalized( NS_SPECIAL );
466  $this->assertIsCapitalized( NS_USER );
467  $this->assertIsCapitalized( NS_MEDIAWIKI );
468  }
469 
484  global $wgCapitalLinks;
485 
486  $this->assertIsCapitalized( NS_PROJECT );
487  $this->assertIsCapitalized( NS_PROJECT_TALK );
488 
489  $wgCapitalLinks = false;
490 
491  // hardcoded namespaces (see above function) are still capitalized:
492  $this->assertIsCapitalized( NS_SPECIAL );
493  $this->assertIsCapitalized( NS_USER );
494  $this->assertIsCapitalized( NS_MEDIAWIKI );
495 
496  // setting is correctly applied
497  $this->assertIsNotCapitalized( NS_PROJECT );
498  $this->assertIsNotCapitalized( NS_PROJECT_TALK );
499  }
500 
509  global $wgCapitalLinkOverrides;
510 
511  // Test default settings
512  $this->assertIsCapitalized( NS_PROJECT );
513  $this->assertIsCapitalized( NS_PROJECT_TALK );
514 
515  // hardcoded namespaces (see above function) are capitalized:
516  $this->assertIsCapitalized( NS_SPECIAL );
517  $this->assertIsCapitalized( NS_USER );
518  $this->assertIsCapitalized( NS_MEDIAWIKI );
519 
520  // Hardcoded namespaces remains capitalized
521  $wgCapitalLinkOverrides[NS_SPECIAL] = false;
522  $wgCapitalLinkOverrides[NS_USER] = false;
523  $wgCapitalLinkOverrides[NS_MEDIAWIKI] = false;
524 
525  $this->assertIsCapitalized( NS_SPECIAL );
526  $this->assertIsCapitalized( NS_USER );
527  $this->assertIsCapitalized( NS_MEDIAWIKI );
528 
529  $wgCapitalLinkOverrides[NS_PROJECT] = false;
530  $this->assertIsNotCapitalized( NS_PROJECT );
531 
532  $wgCapitalLinkOverrides[NS_PROJECT] = true;
533  $this->assertIsCapitalized( NS_PROJECT );
534 
535  unset( $wgCapitalLinkOverrides[NS_PROJECT] );
536  $this->assertIsCapitalized( NS_PROJECT );
537  }
538 
542  public function testHasGenderDistinction() {
543  // Namespaces with gender distinctions
544  $this->assertTrue( MWNamespace::hasGenderDistinction( NS_USER ) );
545  $this->assertTrue( MWNamespace::hasGenderDistinction( NS_USER_TALK ) );
546 
547  // Other ones, "genderless"
548  $this->assertFalse( MWNamespace::hasGenderDistinction( NS_MEDIA ) );
549  $this->assertFalse( MWNamespace::hasGenderDistinction( NS_SPECIAL ) );
550  $this->assertFalse( MWNamespace::hasGenderDistinction( NS_MAIN ) );
551  $this->assertFalse( MWNamespace::hasGenderDistinction( NS_TALK ) );
552  }
553 
557  public function testIsNonincludable() {
558  global $wgNonincludableNamespaces;
559 
560  $wgNonincludableNamespaces = [ NS_USER ];
561 
562  $this->assertTrue( MWNamespace::isNonincludable( NS_USER ) );
563  $this->assertFalse( MWNamespace::isNonincludable( NS_TEMPLATE ) );
564  }
565 
566  # ###### HELPERS ###########################################################
567  function __call( $method, $args ) {
568  // Call the real method if it exists
569  if ( method_exists( $this, $method ) ) {
570  return $this->$method( $args );
571  }
572 
573  if ( preg_match(
574  '/^assert(Has|Is|Can)(Not|)(Subject|Talk|Watchable|Content|Subpages|Capitalized)$/',
575  $method,
576  $m
577  ) ) {
578  # Interprets arguments:
579  $ns = $args[0];
580  $msg = isset( $args[1] ) ? $args[1] : " dummy message";
581 
582  # Forge the namespace constant name:
583  if ( $ns === 0 ) {
584  $ns_name = "NS_MAIN";
585  } else {
586  $ns_name = "NS_" . strtoupper( MWNamespace::getCanonicalName( $ns ) );
587  }
588  # ... and the MWNamespace method name
589  $nsMethod = strtolower( $m[1] ) . $m[3];
590 
591  $expect = ( $m[2] === '' );
592  $expect_name = $expect ? 'TRUE' : 'FALSE';
593 
594  return $this->assertEquals( $expect,
595  MWNamespace::$nsMethod( $ns, $msg ),
596  "MWNamespace::$nsMethod( $ns_name ) should returns $expect_name"
597  );
598  }
599 
600  throw new Exception( __METHOD__ . " could not find a method named $method\n" );
601  }
602 
603  function assertSameSubject( $ns1, $ns2, $msg = '' ) {
604  $this->assertTrue( MWNamespace::subjectEquals( $ns1, $ns2, $msg ) );
605  }
606 
607  function assertDifferentSubject( $ns1, $ns2, $msg = '' ) {
608  $this->assertFalse( MWNamespace::subjectEquals( $ns1, $ns2, $msg ) );
609  }
610 }
MWNamespaceTest\testIsContentAdvanced
testIsContentAdvanced()
Similar to testIsContent() but alters the $wgContentNamespaces global variable.
Definition: MWNamespaceTest.php:306
MWNamespaceTest\testSubjectEquals
testSubjectEquals()
MWNamespace::subjectEquals.
Definition: MWNamespaceTest.php:191
MWNamespace\subjectEquals
static subjectEquals( $ns1, $ns2)
Returns whether the specified namespaces share the same subject.
Definition: MWNamespace.php:194
MWNamespace\isNonincludable
static isNonincludable( $index)
It is not possible to use pages from this namespace as template?
Definition: MWNamespace.php:422
MWNamespaceTest\assertDifferentSubject
assertDifferentSubject( $ns1, $ns2, $msg='')
Definition: MWNamespaceTest.php:607
MWNamespace\hasGenderDistinction
static hasGenderDistinction( $index)
Does the namespace (potentially) have different aliases for different genders.
Definition: MWNamespace.php:411
MWNamespace\getTalkNamespaces
static getTalkNamespaces()
List all namespace indices which are considered talks, aka not a subject or special namespace.
Definition: MWNamespace.php:370
MWNamespaceTest\setUp
setUp()
Definition: MWNamespaceTest.php:14
MWNamespaceTest\testGetSubjectNamespaces
testGetSubjectNamespaces()
MWNamespace::getSubjectNamespaces.
Definition: MWNamespaceTest.php:417
MWNamespaceTest\testGetAssociated
testGetAssociated()
Regular getAssociated() calls Namespaces without an associated page (NS_MEDIA, NS_SPECIAL) are tested...
Definition: MWNamespaceTest.php:133
MWNamespaceTest\__call
__call( $method, $args)
Definition: MWNamespaceTest.php:567
MWNamespaceTest\testGetContentNamespaces
testGetContentNamespaces()
MWNamespace::getContentNamespaces.
Definition: MWNamespaceTest.php:366
MWNamespaceTest\testIsNonincludable
testIsNonincludable()
MWNamespace::isNonincludable.
Definition: MWNamespaceTest.php:557
MWNamespaceTest\testIsSubject
testIsSubject()
Please make sure to change testIsTalk() if you change the assertions below MWNamespace::isSubject.
Definition: MWNamespaceTest.php:45
NS_FILE
const NS_FILE
Definition: Defines.php:68
NS_TEMPLATE
const NS_TEMPLATE
Definition: Defines.php:72
MWNamespaceTest\testGetSubject
testGetSubject()
MWNamespace::getSubject.
Definition: MWNamespaceTest.php:85
MWNamespaceTest\testIsCapitalizedWithWgCapitalLinks
testIsCapitalizedWithWgCapitalLinks()
Follows up for testIsCapitalizedHardcodedAssertions() but alter the global $wgCapitalLink setting to ...
Definition: MWNamespaceTest.php:483
MWNamespace\getSubjectNamespaces
static getSubjectNamespaces()
List all namespace indices which are considered subject, aka not a talk or special namespace.
Definition: MWNamespace.php:357
MWNamespaceTest\testSpecialAndMediaAreDifferentSubjects
testSpecialAndMediaAreDifferentSubjects()
MWNamespace::subjectEquals.
Definition: MWNamespaceTest.php:208
MWNamespace\getContentNamespaces
static getContentNamespaces()
Get a list of all namespace indices which are considered to contain content.
Definition: MWNamespace.php:339
php
injection txt This is an overview of how MediaWiki makes use of dependency injection The design described here grew from the discussion of RFC T384 The term dependency this means that anything an object needs to operate should be injected from the the object itself should only know narrow no concrete implementation of the logic it relies on The requirement to inject everything typically results in an architecture that based on two main types of and essentially stateless service objects that use other service objects to operate on the value objects As of the beginning MediaWiki is only starting to use the DI approach Much of the code still relies on global state or direct resulting in a highly cyclical dependency which acts as the top level factory for services in MediaWiki which can be used to gain access to default instances of various services MediaWikiServices however also allows new services to be defined and default services to be redefined Services are defined or redefined by providing a callback the instantiator that will return a new instance of the service When it will create an instance of MediaWikiServices and populate it with the services defined in the files listed by thereby bootstrapping the DI framework Per $wgServiceWiringFiles lists includes ServiceWiring php
Definition: injection.txt:35
NS_MAIN
const NS_MAIN
Definition: Defines.php:62
NS_SPECIAL
const NS_SPECIAL
Definition: Defines.php:51
NS_PROJECT
const NS_PROJECT
Definition: Defines.php:66
user
This document is intended to provide useful advice for parties seeking to redistribute MediaWiki to end users It s targeted particularly at maintainers for Linux since it s been observed that distribution packages of MediaWiki often break We ve consistently had to recommend that users seeking support use official tarballs instead of their distribution s and this often solves whatever problem the user is having It would be nice if this could such and we might be restricted by PHP settings such as safe mode or open_basedir We cannot assume that the software even has read access anywhere useful Many shared hosts run all users web applications under the same user
Definition: distributors.txt:9
MWNamespaceTest
Test class for MWNamespace.
Definition: MWNamespaceTest.php:13
MediaWikiTestCase\setMwGlobals
setMwGlobals( $pairs, $value=null)
Definition: MediaWikiTestCase.php:658
MediaWikiTestCase
Definition: MediaWikiTestCase.php:13
MWNamespaceTest\testIsTalk
testIsTalk()
Reverse of testIsSubject().
Definition: MWNamespaceTest.php:66
MWNamespaceTest\testCanTalk
testCanTalk()
MWNamespace::canTalk.
Definition: MWNamespaceTest.php:268
MWNamespaceTest\testGetTalkNamespaces
testGetTalkNamespaces()
MWNamespace::getTalkNamespaces.
Definition: MWNamespaceTest.php:433
MWNamespaceTest\testIsWatchable
testIsWatchable()
MWNamespace::isWatchable.
Definition: MWNamespaceTest.php:324
MWNamespace\isMovable
static isMovable( $index)
Can pages in the given namespace be moved?
Definition: MWNamespace.php:66
global
when a variable name is used in a it is silently declared as a new masking the global
Definition: design.txt:93
NS_CATEGORY
const NS_CATEGORY
Definition: Defines.php:76
MWNamespaceTest\assertSameSubject
assertSameSubject( $ns1, $ns2, $msg='')
Definition: MWNamespaceTest.php:603
MWNamespaceTest\testIsMovable
testIsMovable()
Definition: MWNamespaceTest.php:36
MWNamespaceTest\testEquals
testEquals()
Test MWNamespace::equals Note if we add a namespace registration system with keys like 'MAIN' we shou...
Definition: MWNamespaceTest.php:176
NS_USER_TALK
const NS_USER_TALK
Definition: Defines.php:65
MWNamespaceTest\testGetAssociatedExceptionsForNsMedia
testGetAssociatedExceptionsForNsMedia()
MWException MWNamespace::getAssociated.
Definition: MWNamespaceTest.php:145
NS_MEDIA
const NS_MEDIA
Definition: Defines.php:50
MWNamespaceTest\testIsCapitalizedHardcodedAssertions
testIsCapitalizedHardcodedAssertions()
Some namespaces are always capitalized per code definition in MWNamespace::$alwaysCapitalizedNamespac...
Definition: MWNamespaceTest.php:451
NS_PROJECT_TALK
const NS_PROJECT_TALK
Definition: Defines.php:67
MWNamespaceTest\testGetTalkExceptionsForNsMedia
testGetTalkExceptionsForNsMedia()
Exceptions with getTalk() NS_MEDIA does not have talk pages.
Definition: MWNamespaceTest.php:113
$args
if( $line===false) $args
Definition: cdb.php:63
MWNamespaceTest\testIsCapitalizedWithWgCapitalLinkOverrides
testIsCapitalizedWithWgCapitalLinkOverrides()
Counter part for MWNamespace::testIsCapitalizedWithWgCapitalLinks() now testing the $wgCapitalLinkOve...
Definition: MWNamespaceTest.php:508
MWNamespaceTest\testGetTalkExceptionsForNsSpecial
testGetTalkExceptionsForNsSpecial()
Exceptions with getTalk() NS_SPECIAL does not have talk pages.
Definition: MWNamespaceTest.php:123
MWNamespace\equals
static equals( $ns1, $ns2)
Returns whether the specified namespaces are the same namespace.
Definition: MWNamespace.php:179
MWNamespace\isCapitalized
static isCapitalized( $index)
Is the namespace first-letter capitalized?
Definition: MWNamespace.php:383
NS_USER
const NS_USER
Definition: Defines.php:64
MWNamespaceTest\testHasSubpages
testHasSubpages()
MWNamespace::hasSubpages.
Definition: MWNamespaceTest.php:341
NS_TALK
const NS_TALK
Definition: Defines.php:63
NS_MEDIAWIKI
const NS_MEDIAWIKI
Definition: Defines.php:70
MWNamespace\getTalk
static getTalk( $index)
Get the talk namespace index for a given namespace.
Definition: MWNamespace.php:107
MWNamespaceTest\testGetTalk
testGetTalk()
Regular getTalk() calls Namespaces without a talk page (NS_MEDIA, NS_SPECIAL) are tested in the funct...
Definition: MWNamespaceTest.php:100
MWNamespace\getSubject
static getSubject( $index)
Get the subject namespace index for a given namespace Special namespaces (NS_MEDIA,...
Definition: MWNamespace.php:121
MWNamespaceTest\testGetAssociatedExceptionsForNsSpecial
testGetAssociatedExceptionsForNsSpecial()
MWException MWNamespace::getAssociated.
Definition: MWNamespaceTest.php:153
MWNamespaceTest\testIsContent
testIsContent()
MWNamespace::isContent.
Definition: MWNamespaceTest.php:285
MWNamespace\getAssociated
static getAssociated( $index)
Get the associated namespace.
Definition: MWNamespace.php:140
MWNamespace\getCanonicalName
static getCanonicalName( $index)
Returns the canonical (English) name for a given index.
Definition: MWNamespace.php:228
MWNamespaceTest\testHasGenderDistinction
testHasGenderDistinction()
MWNamespace::hasGenderDistinction.
Definition: MWNamespaceTest.php:542