MediaWiki  REL1_31
MWNamespaceTest.php
Go to the documentation of this file.
1 <?php
9 
10  protected function setUp() {
11  parent::setUp();
12 
13  $this->setMwGlobals( [
14  'wgContentNamespaces' => [ NS_MAIN ],
15  'wgNamespacesWithSubpages' => [
16  NS_TALK => true,
17  NS_USER => true,
18  NS_USER_TALK => true,
19  ],
20  'wgCapitalLinks' => true,
21  'wgCapitalLinkOverrides' => [],
22  'wgNonincludableNamespaces' => [],
23  ] );
24  }
25 
30  public function testIsMovable() {
31  $this->assertFalse( MWNamespace::isMovable( NS_SPECIAL ) );
32  }
33 
34  private function assertIsSubject( $ns ) {
35  $this->assertTrue( MWNamespace::isSubject( $ns ) );
36  }
37 
38  private function assertIsNotSubject( $ns ) {
39  $this->assertFalse( MWNamespace::isSubject( $ns ) );
40  }
41 
46  public function testIsSubject() {
47  // Special namespaces
48  $this->assertIsSubject( NS_MEDIA );
49  $this->assertIsSubject( NS_SPECIAL );
50 
51  // Subject pages
52  $this->assertIsSubject( NS_MAIN );
53  $this->assertIsSubject( NS_USER );
54  $this->assertIsSubject( 100 ); # user defined
55 
56  // Talk pages
57  $this->assertIsNotSubject( NS_TALK );
59  $this->assertIsNotSubject( 101 ); # user defined
60  }
61 
62  private function assertIsTalk( $ns ) {
63  $this->assertTrue( MWNamespace::isTalk( $ns ) );
64  }
65 
66  private function assertIsNotTalk( $ns ) {
67  $this->assertFalse( MWNamespace::isTalk( $ns ) );
68  }
69 
75  public function testIsTalk() {
76  // Special namespaces
77  $this->assertIsNotTalk( NS_MEDIA );
78  $this->assertIsNotTalk( NS_SPECIAL );
79 
80  // Subject pages
81  $this->assertIsNotTalk( NS_MAIN );
82  $this->assertIsNotTalk( NS_USER );
83  $this->assertIsNotTalk( 100 ); # user defined
84 
85  // Talk pages
86  $this->assertIsTalk( NS_TALK );
87  $this->assertIsTalk( NS_USER_TALK );
88  $this->assertIsTalk( 101 ); # user defined
89  }
90 
94  public function testGetSubject() {
95  // Special namespaces are their own subjects
96  $this->assertEquals( NS_MEDIA, MWNamespace::getSubject( NS_MEDIA ) );
97  $this->assertEquals( NS_SPECIAL, MWNamespace::getSubject( NS_SPECIAL ) );
98 
99  $this->assertEquals( NS_MAIN, MWNamespace::getSubject( NS_TALK ) );
100  $this->assertEquals( NS_USER, MWNamespace::getSubject( NS_USER_TALK ) );
101  }
102 
109  public function testGetTalk() {
110  $this->assertEquals( NS_TALK, MWNamespace::getTalk( NS_MAIN ) );
111  $this->assertEquals( NS_TALK, MWNamespace::getTalk( NS_TALK ) );
112  $this->assertEquals( NS_USER_TALK, MWNamespace::getTalk( NS_USER ) );
113  $this->assertEquals( NS_USER_TALK, MWNamespace::getTalk( NS_USER_TALK ) );
114  }
115 
123  $this->assertNull( MWNamespace::getTalk( NS_MEDIA ) );
124  }
125 
133  $this->assertNull( MWNamespace::getTalk( NS_SPECIAL ) );
134  }
135 
142  public function testGetAssociated() {
143  $this->assertEquals( NS_TALK, MWNamespace::getAssociated( NS_MAIN ) );
144  $this->assertEquals( NS_MAIN, MWNamespace::getAssociated( NS_TALK ) );
145  }
146 
147  # ## Exceptions with getAssociated()
148  # ##┬áNS_MEDIA and NS_SPECIAL do not have talk pages. MediaWiki raises
149  # ## an exception for them.
150 
155  $this->assertNull( MWNamespace::getAssociated( NS_MEDIA ) );
156  }
157 
163  $this->assertNull( MWNamespace::getAssociated( NS_SPECIAL ) );
164  }
165 
173  public function testEquals() {
174  $this->assertTrue( MWNamespace::equals( NS_MAIN, NS_MAIN ) );
175  $this->assertTrue( MWNamespace::equals( NS_MAIN, 0 ) ); // In case we make NS_MAIN 'MAIN'
176  $this->assertTrue( MWNamespace::equals( NS_USER, NS_USER ) );
177  $this->assertTrue( MWNamespace::equals( NS_USER, 2 ) );
178  $this->assertTrue( MWNamespace::equals( NS_USER_TALK, NS_USER_TALK ) );
179  $this->assertTrue( MWNamespace::equals( NS_SPECIAL, NS_SPECIAL ) );
180  $this->assertFalse( MWNamespace::equals( NS_MAIN, NS_TALK ) );
181  $this->assertFalse( MWNamespace::equals( NS_USER, NS_USER_TALK ) );
182  $this->assertFalse( MWNamespace::equals( NS_PROJECT, NS_TEMPLATE ) );
183  }
184 
188  public function testSubjectEquals() {
189  $this->assertSameSubject( NS_MAIN, NS_MAIN );
190  $this->assertSameSubject( NS_MAIN, 0 ); // In case we make NS_MAIN 'MAIN'
191  $this->assertSameSubject( NS_USER, NS_USER );
192  $this->assertSameSubject( NS_USER, 2 );
195  $this->assertSameSubject( NS_MAIN, NS_TALK );
197 
200  }
201 
206  $this->assertDifferentSubject(
208  "NS_MEDIA and NS_SPECIAL are different subject namespaces"
209  );
210  $this->assertDifferentSubject(
212  "NS_SPECIAL and NS_MEDIA are different subject namespaces"
213  );
214  }
215 
216  public function provideHasTalkNamespace() {
217  return [
218  [ NS_MEDIA, false ],
219  [ NS_SPECIAL, false ],
220 
221  [ NS_MAIN, true ],
222  [ NS_TALK, true ],
223  [ NS_USER, true ],
224  [ NS_USER_TALK, true ],
225 
226  [ 100, true ],
227  [ 101, true ],
228  ];
229  }
230 
238  public function testHasTalkNamespace( $index, $expected ) {
239  $actual = MWNamespace::hasTalkNamespace( $index );
240  $this->assertSame( $actual, $expected, "NS $index" );
241  }
242 
250  public function testCanTalk( $index, $expected ) {
251  $actual = MWNamespace::canTalk( $index );
252  $this->assertSame( $actual, $expected, "NS $index" );
253  }
254 
255  private function assertIsContent( $ns ) {
256  $this->assertTrue( MWNamespace::isContent( $ns ) );
257  }
258 
259  private function assertIsNotContent( $ns ) {
260  $this->assertFalse( MWNamespace::isContent( $ns ) );
261  }
262 
266  public function testIsContent() {
267  // NS_MAIN is a content namespace per DefaultSettings.php
268  // and per function definition.
269 
270  $this->assertIsContent( NS_MAIN );
271 
272  // Other namespaces which are not expected to be content
273 
274  $this->assertIsNotContent( NS_MEDIA );
275  $this->assertIsNotContent( NS_SPECIAL );
276  $this->assertIsNotContent( NS_TALK );
277  $this->assertIsNotContent( NS_USER );
279  $this->assertIsNotContent( 100 );
280  }
281 
287  public function testIsContentAdvanced() {
289 
290  // Test that user defined namespace #252 is not content
291  $this->assertIsNotContent( 252 );
292 
293  // Bless namespace # 252 as a content namespace
294  $wgContentNamespaces[] = 252;
295 
296  $this->assertIsContent( 252 );
297 
298  // Makes sure NS_MAIN was not impacted
299  $this->assertIsContent( NS_MAIN );
300  }
301 
302  private function assertIsWatchable( $ns ) {
303  $this->assertTrue( MWNamespace::isWatchable( $ns ) );
304  }
305 
306  private function assertIsNotWatchable( $ns ) {
307  $this->assertFalse( MWNamespace::isWatchable( $ns ) );
308  }
309 
313  public function testIsWatchable() {
314  // Specials namespaces are not watchable
315  $this->assertIsNotWatchable( NS_MEDIA );
317 
318  // Core defined namespaces are watchables
319  $this->assertIsWatchable( NS_MAIN );
320  $this->assertIsWatchable( NS_TALK );
321 
322  // Additional, user defined namespaces are watchables
323  $this->assertIsWatchable( 100 );
324  $this->assertIsWatchable( 101 );
325  }
326 
327  private function assertHasSubpages( $ns ) {
328  $this->assertTrue( MWNamespace::hasSubpages( $ns ) );
329  }
330 
331  private function assertHasNotSubpages( $ns ) {
332  $this->assertFalse( MWNamespace::hasSubpages( $ns ) );
333  }
334 
338  public function testHasSubpages() {
340 
341  // Special namespaces:
342  $this->assertHasNotSubpages( NS_MEDIA );
344 
345  // Namespaces without subpages
346  $this->assertHasNotSubpages( NS_MAIN );
347 
348  $wgNamespacesWithSubpages[NS_MAIN] = true;
349  $this->assertHasSubpages( NS_MAIN );
350 
351  $wgNamespacesWithSubpages[NS_MAIN] = false;
352  $this->assertHasNotSubpages( NS_MAIN );
353 
354  // Some namespaces with subpages
355  $this->assertHasSubpages( NS_TALK );
356  $this->assertHasSubpages( NS_USER );
358  }
359 
363  public function testGetContentNamespaces() {
365 
366  $this->assertEquals(
367  [ NS_MAIN ],
369  '$wgContentNamespaces is an array with only NS_MAIN by default'
370  );
371 
372  # test !is_array( $wgcontentNamespaces )
374  $this->assertEquals( [ NS_MAIN ], MWNamespace::getContentNamespaces() );
375 
376  $wgContentNamespaces = false;
377  $this->assertEquals( [ NS_MAIN ], MWNamespace::getContentNamespaces() );
378 
379  $wgContentNamespaces = null;
380  $this->assertEquals( [ NS_MAIN ], MWNamespace::getContentNamespaces() );
381 
383  $this->assertEquals( [ NS_MAIN ], MWNamespace::getContentNamespaces() );
384 
385  # test $wgContentNamespaces === []
387  $this->assertEquals( [ NS_MAIN ], MWNamespace::getContentNamespaces() );
388 
389  # test !in_array( NS_MAIN, $wgContentNamespaces )
391  $this->assertEquals(
394  'NS_MAIN is forced in $wgContentNamespaces even if unwanted'
395  );
396 
397  # test other cases, return $wgcontentNamespaces as is
399  $this->assertEquals(
400  [ NS_MAIN ],
402  );
403 
405  $this->assertEquals(
408  );
409  }
410 
414  public function testGetSubjectNamespaces() {
415  $subjectsNS = MWNamespace::getSubjectNamespaces();
416  $this->assertContains( NS_MAIN, $subjectsNS,
417  "Talk namespaces should have NS_MAIN" );
418  $this->assertNotContains( NS_TALK, $subjectsNS,
419  "Talk namespaces should have NS_TALK" );
420 
421  $this->assertNotContains( NS_MEDIA, $subjectsNS,
422  "Talk namespaces should not have NS_MEDIA" );
423  $this->assertNotContains( NS_SPECIAL, $subjectsNS,
424  "Talk namespaces should not have NS_SPECIAL" );
425  }
426 
430  public function testGetTalkNamespaces() {
431  $talkNS = MWNamespace::getTalkNamespaces();
432  $this->assertContains( NS_TALK, $talkNS,
433  "Subject namespaces should have NS_TALK" );
434  $this->assertNotContains( NS_MAIN, $talkNS,
435  "Subject namespaces should not have NS_MAIN" );
436 
437  $this->assertNotContains( NS_MEDIA, $talkNS,
438  "Subject namespaces should not have NS_MEDIA" );
439  $this->assertNotContains( NS_SPECIAL, $talkNS,
440  "Subject namespaces should not have NS_SPECIAL" );
441  }
442 
443  private function assertIsCapitalized( $ns ) {
444  $this->assertTrue( MWNamespace::isCapitalized( $ns ) );
445  }
446 
447  private function assertIsNotCapitalized( $ns ) {
448  $this->assertFalse( MWNamespace::isCapitalized( $ns ) );
449  }
450 
457  // NS_MEDIA and NS_FILE are treated the same
458  $this->assertEquals(
461  'NS_MEDIA and NS_FILE have same capitalization rendering'
462  );
463 
464  // Boths are capitalized by default
465  $this->assertIsCapitalized( NS_MEDIA );
466  $this->assertIsCapitalized( NS_FILE );
467 
468  // Always capitalized namespaces
469  // @see MWNamespace::$alwaysCapitalizedNamespaces
471  $this->assertIsCapitalized( NS_USER );
473  }
474 
490 
493 
494  $wgCapitalLinks = false;
495 
496  // hardcoded namespaces (see above function) are still capitalized:
498  $this->assertIsCapitalized( NS_USER );
500 
501  // setting is correctly applied
504  }
505 
515 
516  // Test default settings
519 
520  // hardcoded namespaces (see above function) are capitalized:
522  $this->assertIsCapitalized( NS_USER );
524 
525  // Hardcoded namespaces remains capitalized
526  $wgCapitalLinkOverrides[NS_SPECIAL] = false;
529 
531  $this->assertIsCapitalized( NS_USER );
533 
534  $wgCapitalLinkOverrides[NS_PROJECT] = false;
536 
537  $wgCapitalLinkOverrides[NS_PROJECT] = true;
539 
541  $this->assertIsCapitalized( NS_PROJECT );
542  }
543 
547  public function testHasGenderDistinction() {
548  // Namespaces with gender distinctions
549  $this->assertTrue( MWNamespace::hasGenderDistinction( NS_USER ) );
550  $this->assertTrue( MWNamespace::hasGenderDistinction( NS_USER_TALK ) );
551 
552  // Other ones, "genderless"
553  $this->assertFalse( MWNamespace::hasGenderDistinction( NS_MEDIA ) );
554  $this->assertFalse( MWNamespace::hasGenderDistinction( NS_SPECIAL ) );
555  $this->assertFalse( MWNamespace::hasGenderDistinction( NS_MAIN ) );
556  $this->assertFalse( MWNamespace::hasGenderDistinction( NS_TALK ) );
557  }
558 
562  public function testIsNonincludable() {
564 
566 
567  $this->assertTrue( MWNamespace::isNonincludable( NS_USER ) );
568  $this->assertFalse( MWNamespace::isNonincludable( NS_TEMPLATE ) );
569  }
570 
571  private function assertSameSubject( $ns1, $ns2, $msg = '' ) {
572  $this->assertTrue( MWNamespace::subjectEquals( $ns1, $ns2 ), $msg );
573  }
574 
575  private function assertDifferentSubject( $ns1, $ns2, $msg = '' ) {
576  $this->assertFalse( MWNamespace::subjectEquals( $ns1, $ns2 ), $msg );
577  }
578 }
$wgNonincludableNamespaces
$wgNonincludableNamespaces
Pages in namespaces in this array can not be used as templates.
Definition: DefaultSettings.php:5364
MWNamespaceTest\testIsContentAdvanced
testIsContentAdvanced()
Similar to testIsContent() but alters the $wgContentNamespaces global variable.
Definition: MWNamespaceTest.php:287
MWNamespaceTest\testSubjectEquals
testSubjectEquals()
MWNamespace::subjectEquals.
Definition: MWNamespaceTest.php:188
MWNamespace\subjectEquals
static subjectEquals( $ns1, $ns2)
Returns whether the specified namespaces share the same subject.
Definition: MWNamespace.php:216
MWNamespace\isNonincludable
static isNonincludable( $index)
It is not possible to use pages from this namespace as template?
Definition: MWNamespace.php:460
MWNamespaceTest\assertIsNotWatchable
assertIsNotWatchable( $ns)
Definition: MWNamespaceTest.php:306
MWNamespaceTest\assertDifferentSubject
assertDifferentSubject( $ns1, $ns2, $msg='')
Definition: MWNamespaceTest.php:575
MWNamespace\hasGenderDistinction
static hasGenderDistinction( $index)
Does the namespace (potentially) have different aliases for different genders.
Definition: MWNamespace.php:449
MWNamespace\isTalk
static isTalk( $index)
Is the given namespace a talk namespace?
Definition: MWNamespace.php:118
MWNamespace\getTalkNamespaces
static getTalkNamespaces()
List all namespace indices which are considered talks, aka not a subject or special namespace.
Definition: MWNamespace.php:408
MWNamespaceTest\setUp
setUp()
Definition: MWNamespaceTest.php:10
MWNamespaceTest\testGetSubjectNamespaces
testGetSubjectNamespaces()
MWNamespace::getSubjectNamespaces.
Definition: MWNamespaceTest.php:414
MWNamespaceTest\testGetAssociated
testGetAssociated()
Regular getAssociated() calls Namespaces without an associated page (NS_MEDIA, NS_SPECIAL) are tested...
Definition: MWNamespaceTest.php:142
MWNamespaceTest\testGetContentNamespaces
testGetContentNamespaces()
MWNamespace::getContentNamespaces.
Definition: MWNamespaceTest.php:363
MWNamespaceTest\testHasTalkNamespace
testHasTalkNamespace( $index, $expected)
provideHasTalkNamespace MWNamespace::hasTalkNamespace
Definition: MWNamespaceTest.php:238
MWNamespaceTest\testIsNonincludable
testIsNonincludable()
MWNamespace::isNonincludable.
Definition: MWNamespaceTest.php:562
MWNamespaceTest\testIsSubject
testIsSubject()
Please make sure to change testIsTalk() if you change the assertions below MWNamespace::isSubject.
Definition: MWNamespaceTest.php:46
NS_FILE
const NS_FILE
Definition: Defines.php:80
MWNamespaceTest\assertIsNotTalk
assertIsNotTalk( $ns)
Definition: MWNamespaceTest.php:66
NS_TEMPLATE
const NS_TEMPLATE
Definition: Defines.php:84
MWNamespaceTest\provideHasTalkNamespace
provideHasTalkNamespace()
Definition: MWNamespaceTest.php:216
MWNamespaceTest\assertIsNotCapitalized
assertIsNotCapitalized( $ns)
Definition: MWNamespaceTest.php:447
MWNamespaceTest\testGetSubject
testGetSubject()
MWNamespace::getSubject.
Definition: MWNamespaceTest.php:94
MWNamespaceTest\testIsCapitalizedWithWgCapitalLinks
testIsCapitalizedWithWgCapitalLinks()
Follows up for testIsCapitalizedHardcodedAssertions() but alter the global $wgCapitalLink setting to ...
Definition: MWNamespaceTest.php:488
MWNamespace\getSubjectNamespaces
static getSubjectNamespaces()
List all namespace indices which are considered subject, aka not a talk or special namespace.
Definition: MWNamespace.php:395
MWNamespaceTest\assertHasSubpages
assertHasSubpages( $ns)
Definition: MWNamespaceTest.php:327
MWNamespaceTest\testSpecialAndMediaAreDifferentSubjects
testSpecialAndMediaAreDifferentSubjects()
MWNamespace::subjectEquals.
Definition: MWNamespaceTest.php:205
MWNamespace\getContentNamespaces
static getContentNamespaces()
Get a list of all namespace indices which are considered to contain content.
Definition: MWNamespace.php:377
true
null means default in associative array with keys and values unescaped Should be merged with default with a value of false meaning to suppress the attribute in associative array with keys and values unescaped noclasses just before the function returns a value If you return true
Definition: hooks.txt:2006
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:37
NS_MAIN
const NS_MAIN
Definition: Defines.php:74
NS_SPECIAL
const NS_SPECIAL
Definition: Defines.php:63
MWNamespaceTest\testCanTalk
testCanTalk( $index, $expected)
provideHasTalkNamespace MWNamespace::canTalk
Definition: MWNamespaceTest.php:250
NS_PROJECT
const NS_PROJECT
Definition: Defines.php:78
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
Wikitext formatted, in the key only.
Definition: distributors.txt:25
MWNamespaceTest\assertIsContent
assertIsContent( $ns)
Definition: MWNamespaceTest.php:255
MWNamespaceTest
Definition: MWNamespaceTest.php:8
MWNamespaceTest\assertIsNotSubject
assertIsNotSubject( $ns)
Definition: MWNamespaceTest.php:38
MWNamespaceTest\assertHasNotSubpages
assertHasNotSubpages( $ns)
Definition: MWNamespaceTest.php:331
MediaWikiTestCase\setMwGlobals
setMwGlobals( $pairs, $value=null)
Sets a global, maintaining a stashed version of the previous global to be restored in tearDown.
Definition: MediaWikiTestCase.php:678
MediaWikiTestCase
Definition: MediaWikiTestCase.php:17
MWNamespace\canTalk
static canTalk( $index)
Does this namespace ever have a talk namespace?
Definition: MWNamespace.php:312
MWNamespaceTest\testIsTalk
testIsTalk()
Reverse of testIsSubject().
Definition: MWNamespaceTest.php:75
MWNamespace\isContent
static isContent( $index)
Does this namespace contain content, for the purposes of calculating statistics, etc?
Definition: MWNamespace.php:335
MWNamespace\hasTalkNamespace
static hasTalkNamespace( $index)
Does this namespace ever have a talk namespace?
Definition: MWNamespace.php:324
MWNamespace\hasSubpages
static hasSubpages( $index)
Does the namespace allow subpages?
Definition: MWNamespace.php:368
MWNamespaceTest\testGetTalkNamespaces
testGetTalkNamespaces()
MWNamespace::getTalkNamespaces.
Definition: MWNamespaceTest.php:430
MWNamespaceTest\testIsWatchable
testIsWatchable()
MWNamespace::isWatchable.
Definition: MWNamespaceTest.php:313
MWNamespace\isMovable
static isMovable( $index)
Can pages in the given namespace be moved?
Definition: MWNamespace.php:88
global
when a variable name is used in a it is silently declared as a new masking the global
Definition: design.txt:95
NS_CATEGORY
const NS_CATEGORY
Definition: Defines.php:88
MWNamespaceTest\assertSameSubject
assertSameSubject( $ns1, $ns2, $msg='')
Definition: MWNamespaceTest.php:571
MWNamespaceTest\testIsMovable
testIsMovable()
Definition: MWNamespaceTest.php:30
MWNamespace\isSubject
static isSubject( $index)
Is the given namespace is a subject (non-talk) namespace?
Definition: MWNamespace.php:108
MWNamespaceTest\assertIsNotContent
assertIsNotContent( $ns)
Definition: MWNamespaceTest.php:259
MWNamespaceTest\testEquals
testEquals()
Test MWNamespace::equals Note if we add a namespace registration system with keys like 'MAIN' we shou...
Definition: MWNamespaceTest.php:173
MWNamespaceTest\assertIsWatchable
assertIsWatchable( $ns)
Definition: MWNamespaceTest.php:302
NS_USER_TALK
const NS_USER_TALK
Definition: Defines.php:77
MWNamespaceTest\testGetAssociatedExceptionsForNsMedia
testGetAssociatedExceptionsForNsMedia()
MWException MWNamespace::getAssociated.
Definition: MWNamespaceTest.php:154
NS_MEDIA
const NS_MEDIA
Definition: Defines.php:62
MWNamespaceTest\testIsCapitalizedHardcodedAssertions
testIsCapitalizedHardcodedAssertions()
Some namespaces are always capitalized per code definition in MWNamespace::$alwaysCapitalizedNamespac...
Definition: MWNamespaceTest.php:456
MWNamespaceTest\assertIsSubject
assertIsSubject( $ns)
Definition: MWNamespaceTest.php:34
NS_PROJECT_TALK
const NS_PROJECT_TALK
Definition: Defines.php:79
MWNamespaceTest\testGetTalkExceptionsForNsMedia
testGetTalkExceptionsForNsMedia()
Exceptions with getTalk() NS_MEDIA does not have talk pages.
Definition: MWNamespaceTest.php:122
$wgContentNamespaces
$wgContentNamespaces
Array of namespaces which can be deemed to contain valid "content", as far as the site statistics are...
Definition: DefaultSettings.php:4103
MWNamespaceTest\testIsCapitalizedWithWgCapitalLinkOverrides
testIsCapitalizedWithWgCapitalLinkOverrides()
Counter part for MWNamespace::testIsCapitalizedWithWgCapitalLinks() now testing the $wgCapitalLinkOve...
Definition: MWNamespaceTest.php:513
MWNamespaceTest\testGetTalkExceptionsForNsSpecial
testGetTalkExceptionsForNsSpecial()
Exceptions with getTalk() NS_SPECIAL does not have talk pages.
Definition: MWNamespaceTest.php:132
$wgCapitalLinks
$wgCapitalLinks
Set this to false to avoid forcing the first letter of links to capitals.
Definition: DefaultSettings.php:4042
MWNamespace\equals
static equals( $ns1, $ns2)
Returns whether the specified namespaces are the same namespace.
Definition: MWNamespace.php:201
$wgCapitalLinkOverrides
$wgCapitalLinkOverrides
Definition: DefaultSettings.php:4058
MWNamespace\isCapitalized
static isCapitalized( $index)
Is the namespace first-letter capitalized?
Definition: MWNamespace.php:421
NS_USER
const NS_USER
Definition: Defines.php:76
MWNamespaceTest\testHasSubpages
testHasSubpages()
MWNamespace::hasSubpages.
Definition: MWNamespaceTest.php:338
MWNamespaceTest\assertIsCapitalized
assertIsCapitalized( $ns)
Definition: MWNamespaceTest.php:443
NS_TALK
const NS_TALK
Definition: Defines.php:75
MWNamespaceTest\assertIsTalk
assertIsTalk( $ns)
Definition: MWNamespaceTest.php:62
NS_MEDIAWIKI
const NS_MEDIAWIKI
Definition: Defines.php:82
MWNamespace\isWatchable
static isWatchable( $index)
Can pages in a namespace be watched?
Definition: MWNamespace.php:358
MWNamespace\getTalk
static getTalk( $index)
Get the talk namespace index for a given namespace.
Definition: MWNamespace.php:129
MWNamespaceTest\testGetTalk
testGetTalk()
Regular getTalk() calls Namespaces without a talk page (NS_MEDIA, NS_SPECIAL) are tested in the funct...
Definition: MWNamespaceTest.php:109
MWNamespace\getSubject
static getSubject( $index)
Get the subject namespace index for a given namespace Special namespaces (NS_MEDIA,...
Definition: MWNamespace.php:143
$wgNamespacesWithSubpages
$wgNamespacesWithSubpages
Which namespaces should support subpages? See Language.php for a list of namespaces.
Definition: DefaultSettings.php:4064
MWNamespaceTest\testGetAssociatedExceptionsForNsSpecial
testGetAssociatedExceptionsForNsSpecial()
MWException MWNamespace::getAssociated.
Definition: MWNamespaceTest.php:162
MWNamespaceTest\testIsContent
testIsContent()
MWNamespace::isContent.
Definition: MWNamespaceTest.php:266
MWNamespace\getAssociated
static getAssociated( $index)
Get the associated namespace.
Definition: MWNamespace.php:162
false
processing should stop and the error should be shown to the user * false
Definition: hooks.txt:187
MWNamespaceTest\testHasGenderDistinction
testHasGenderDistinction()
MWNamespace::hasGenderDistinction.
Definition: MWNamespaceTest.php:547