MediaWiki REL1_30
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.
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() {
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 );
199 $this->assertSameSubject( NS_USER, NS_USER_TALK );
200
203 }
204
211 "NS_MEDIA and NS_SPECIAL are different subject namespaces"
212 );
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
265 public function provideHasTalkNamespace() {
266 return [
267 [ NS_MEDIA, false ],
268 [ NS_SPECIAL, false ],
269
270 [ NS_MAIN, true ],
271 [ NS_TALK, true ],
272 [ NS_USER, true ],
273 [ NS_USER_TALK, true ],
274
275 [ 100, true ],
276 [ 101, true ],
277 ];
278 }
279
287 public function testHasTalkNamespace( $index, $expected ) {
288 $actual = MWNamespace::hasTalkNamespace( $index );
289 $this->assertSame( $actual, $expected, "NS $index" );
290 }
291
299 public function testCanTalk( $index, $expected ) {
300 $actual = MWNamespace::canTalk( $index );
301 $this->assertSame( $actual, $expected, "NS $index" );
302 }
303
307 public function testIsContent() {
308 // NS_MAIN is a content namespace per DefaultSettings.php
309 // and per function definition.
310
311 $this->assertIsContent( NS_MAIN );
312
313 // Other namespaces which are not expected to be content
314
315 $this->assertIsNotContent( NS_MEDIA );
316 $this->assertIsNotContent( NS_SPECIAL );
317 $this->assertIsNotContent( NS_TALK );
318 $this->assertIsNotContent( NS_USER );
319 $this->assertIsNotContent( NS_CATEGORY );
320 $this->assertIsNotContent( 100 );
321 }
322
328 public function testIsContentAdvanced() {
330
331 // Test that user defined namespace #252 is not content
332 $this->assertIsNotContent( 252 );
333
334 // Bless namespace # 252 as a content namespace
335 $wgContentNamespaces[] = 252;
336
337 $this->assertIsContent( 252 );
338
339 // Makes sure NS_MAIN was not impacted
340 $this->assertIsContent( NS_MAIN );
341 }
342
346 public function testIsWatchable() {
347 // Specials namespaces are not watchable
348 $this->assertIsNotWatchable( NS_MEDIA );
349 $this->assertIsNotWatchable( NS_SPECIAL );
350
351 // Core defined namespaces are watchables
352 $this->assertIsWatchable( NS_MAIN );
353 $this->assertIsWatchable( NS_TALK );
354
355 // Additional, user defined namespaces are watchables
356 $this->assertIsWatchable( 100 );
357 $this->assertIsWatchable( 101 );
358 }
359
363 public function testHasSubpages() {
365
366 // Special namespaces:
367 $this->assertHasNotSubpages( NS_MEDIA );
368 $this->assertHasNotSubpages( NS_SPECIAL );
369
370 // Namespaces without subpages
371 $this->assertHasNotSubpages( NS_MAIN );
372
374 $this->assertHasSubpages( NS_MAIN );
375
377 $this->assertHasNotSubpages( NS_MAIN );
378
379 // Some namespaces with subpages
380 $this->assertHasSubpages( NS_TALK );
381 $this->assertHasSubpages( NS_USER );
382 $this->assertHasSubpages( NS_USER_TALK );
383 }
384
388 public function testGetContentNamespaces() {
390
391 $this->assertEquals(
392 [ NS_MAIN ],
393 MWNamespace::getContentNamespaces(),
394 '$wgContentNamespaces is an array with only NS_MAIN by default'
395 );
396
397 # test !is_array( $wgcontentNamespaces )
399 $this->assertEquals( [ NS_MAIN ], MWNamespace::getContentNamespaces() );
400
401 $wgContentNamespaces = false;
402 $this->assertEquals( [ NS_MAIN ], MWNamespace::getContentNamespaces() );
403
405 $this->assertEquals( [ NS_MAIN ], MWNamespace::getContentNamespaces() );
406
408 $this->assertEquals( [ NS_MAIN ], MWNamespace::getContentNamespaces() );
409
410 # test $wgContentNamespaces === []
412 $this->assertEquals( [ NS_MAIN ], MWNamespace::getContentNamespaces() );
413
414 # test !in_array( NS_MAIN, $wgContentNamespaces )
416 $this->assertEquals(
417 [ NS_MAIN, NS_USER, NS_CATEGORY ],
418 MWNamespace::getContentNamespaces(),
419 'NS_MAIN is forced in $wgContentNamespaces even if unwanted'
420 );
421
422 # test other cases, return $wgcontentNamespaces as is
424 $this->assertEquals(
425 [ NS_MAIN ],
426 MWNamespace::getContentNamespaces()
427 );
428
430 $this->assertEquals(
431 [ NS_MAIN, NS_USER, NS_CATEGORY ],
432 MWNamespace::getContentNamespaces()
433 );
434 }
435
439 public function testGetSubjectNamespaces() {
440 $subjectsNS = MWNamespace::getSubjectNamespaces();
441 $this->assertContains( NS_MAIN, $subjectsNS,
442 "Talk namespaces should have NS_MAIN" );
443 $this->assertNotContains( NS_TALK, $subjectsNS,
444 "Talk namespaces should have NS_TALK" );
445
446 $this->assertNotContains( NS_MEDIA, $subjectsNS,
447 "Talk namespaces should not have NS_MEDIA" );
448 $this->assertNotContains( NS_SPECIAL, $subjectsNS,
449 "Talk namespaces should not have NS_SPECIAL" );
450 }
451
455 public function testGetTalkNamespaces() {
456 $talkNS = MWNamespace::getTalkNamespaces();
457 $this->assertContains( NS_TALK, $talkNS,
458 "Subject namespaces should have NS_TALK" );
459 $this->assertNotContains( NS_MAIN, $talkNS,
460 "Subject namespaces should not have NS_MAIN" );
461
462 $this->assertNotContains( NS_MEDIA, $talkNS,
463 "Subject namespaces should not have NS_MEDIA" );
464 $this->assertNotContains( NS_SPECIAL, $talkNS,
465 "Subject namespaces should not have NS_SPECIAL" );
466 }
467
474 // NS_MEDIA and NS_FILE are treated the same
475 $this->assertEquals(
476 MWNamespace::isCapitalized( NS_MEDIA ),
477 MWNamespace::isCapitalized( NS_FILE ),
478 'NS_MEDIA and NS_FILE have same capitalization rendering'
479 );
480
481 // Boths are capitalized by default
482 $this->assertIsCapitalized( NS_MEDIA );
483 $this->assertIsCapitalized( NS_FILE );
484
485 // Always capitalized namespaces
486 // @see MWNamespace::$alwaysCapitalizedNamespaces
487 $this->assertIsCapitalized( NS_SPECIAL );
488 $this->assertIsCapitalized( NS_USER );
489 $this->assertIsCapitalized( NS_MEDIAWIKI );
490 }
491
506 global $wgCapitalLinks;
507
508 $this->assertIsCapitalized( NS_PROJECT );
509 $this->assertIsCapitalized( NS_PROJECT_TALK );
510
511 $wgCapitalLinks = false;
512
513 // hardcoded namespaces (see above function) are still capitalized:
514 $this->assertIsCapitalized( NS_SPECIAL );
515 $this->assertIsCapitalized( NS_USER );
516 $this->assertIsCapitalized( NS_MEDIAWIKI );
517
518 // setting is correctly applied
519 $this->assertIsNotCapitalized( NS_PROJECT );
520 $this->assertIsNotCapitalized( NS_PROJECT_TALK );
521 }
522
532
533 // Test default settings
534 $this->assertIsCapitalized( NS_PROJECT );
535 $this->assertIsCapitalized( NS_PROJECT_TALK );
536
537 // hardcoded namespaces (see above function) are capitalized:
538 $this->assertIsCapitalized( NS_SPECIAL );
539 $this->assertIsCapitalized( NS_USER );
540 $this->assertIsCapitalized( NS_MEDIAWIKI );
541
542 // Hardcoded namespaces remains capitalized
546
547 $this->assertIsCapitalized( NS_SPECIAL );
548 $this->assertIsCapitalized( NS_USER );
549 $this->assertIsCapitalized( NS_MEDIAWIKI );
550
552 $this->assertIsNotCapitalized( NS_PROJECT );
553
555 $this->assertIsCapitalized( NS_PROJECT );
556
558 $this->assertIsCapitalized( NS_PROJECT );
559 }
560
564 public function testHasGenderDistinction() {
565 // Namespaces with gender distinctions
566 $this->assertTrue( MWNamespace::hasGenderDistinction( NS_USER ) );
567 $this->assertTrue( MWNamespace::hasGenderDistinction( NS_USER_TALK ) );
568
569 // Other ones, "genderless"
570 $this->assertFalse( MWNamespace::hasGenderDistinction( NS_MEDIA ) );
571 $this->assertFalse( MWNamespace::hasGenderDistinction( NS_SPECIAL ) );
572 $this->assertFalse( MWNamespace::hasGenderDistinction( NS_MAIN ) );
573 $this->assertFalse( MWNamespace::hasGenderDistinction( NS_TALK ) );
574 }
575
579 public function testIsNonincludable() {
581
583
584 $this->assertTrue( MWNamespace::isNonincludable( NS_USER ) );
585 $this->assertFalse( MWNamespace::isNonincludable( NS_TEMPLATE ) );
586 }
587
588 # ###### HELPERS ###########################################################
589 function __call( $method, $args ) {
590 // Call the real method if it exists
591 if ( method_exists( $this, $method ) ) {
592 return $this->$method( $args );
593 }
594
595 if ( preg_match(
596 '/^assert(Has|Is|Can)(Not|)(Subject|Talk|Watchable|Content|Subpages|Capitalized)$/',
597 $method,
598 $m
599 ) ) {
600 # Interprets arguments:
601 $ns = $args[0];
602 $msg = isset( $args[1] ) ? $args[1] : " dummy message";
603
604 # Forge the namespace constant name:
605 if ( $ns === 0 ) {
606 $ns_name = "NS_MAIN";
607 } else {
608 $ns_name = "NS_" . strtoupper( MWNamespace::getCanonicalName( $ns ) );
609 }
610 # ... and the MWNamespace method name
611 $nsMethod = strtolower( $m[1] ) . $m[3];
612
613 $expect = ( $m[2] === '' );
614 $expect_name = $expect ? 'TRUE' : 'FALSE';
615
616 return $this->assertEquals( $expect,
617 MWNamespace::$nsMethod( $ns, $msg ),
618 "MWNamespace::$nsMethod( $ns_name ) should returns $expect_name"
619 );
620 }
621
622 throw new Exception( __METHOD__ . " could not find a method named $method\n" );
623 }
624
625 function assertSameSubject( $ns1, $ns2, $msg = '' ) {
626 $this->assertTrue( MWNamespace::subjectEquals( $ns1, $ns2, $msg ) );
627 }
628
629 function assertDifferentSubject( $ns1, $ns2, $msg = '' ) {
630 $this->assertFalse( MWNamespace::subjectEquals( $ns1, $ns2, $msg ) );
631 }
632}
$wgNamespacesWithSubpages
Which namespaces should support subpages? See Language.php for a list of namespaces.
$wgCapitalLinks
Set this to false to avoid forcing the first letter of links to capitals.
$wgNonincludableNamespaces
Pages in namespaces in this array can not be used as templates.
$wgContentNamespaces
Array of namespaces which can be deemed to contain valid "content", as far as the site statistics are...
$wgCapitalLinkOverrides
if( $line===false) $args
Definition cdb.php:63
Test class for MWNamespace.
testHasGenderDistinction()
MWNamespace::hasGenderDistinction.
testGetTalkNamespaces()
MWNamespace::getTalkNamespaces.
assertDifferentSubject( $ns1, $ns2, $msg='')
testGetAssociatedExceptionsForNsSpecial()
MWException MWNamespace::getAssociated.
testSubjectEquals()
MWNamespace::subjectEquals.
testGetTalk()
Regular getTalk() calls Namespaces without a talk page (NS_MEDIA, NS_SPECIAL) are tested in the funct...
testHasSubpages()
MWNamespace::hasSubpages.
testHasTalkNamespace( $index, $expected)
provideHasTalkNamespace MWNamespace::hasTalkNamespace
testIsWatchable()
MWNamespace::isWatchable.
testIsContentAdvanced()
Similar to testIsContent() but alters the $wgContentNamespaces global variable.
testGetContentNamespaces()
MWNamespace::getContentNamespaces.
testGetAssociated()
Regular getAssociated() calls Namespaces without an associated page (NS_MEDIA, NS_SPECIAL) are tested...
testIsCapitalizedWithWgCapitalLinks()
Follows up for testIsCapitalizedHardcodedAssertions() but alter the global $wgCapitalLink setting to ...
testGetTalkExceptionsForNsSpecial()
Exceptions with getTalk() NS_SPECIAL does not have talk pages.
testGetSubject()
MWNamespace::getSubject.
testIsCapitalizedHardcodedAssertions()
Some namespaces are always capitalized per code definition in MWNamespace::$alwaysCapitalizedNamespac...
__call( $method, $args)
testGetAssociatedExceptionsForNsMedia()
MWException MWNamespace::getAssociated.
testEquals()
Test MWNamespace::equals Note if we add a namespace registration system with keys like 'MAIN' we shou...
testIsNonincludable()
MWNamespace::isNonincludable.
testGetSubjectNamespaces()
MWNamespace::getSubjectNamespaces.
testIsCapitalizedWithWgCapitalLinkOverrides()
Counter part for MWNamespace::testIsCapitalizedWithWgCapitalLinks() now testing the $wgCapitalLinkOve...
assertSameSubject( $ns1, $ns2, $msg='')
testIsTalk()
Reverse of testIsSubject().
testSpecialAndMediaAreDifferentSubjects()
MWNamespace::subjectEquals.
testCanTalk( $index, $expected)
provideHasTalkNamespace MWNamespace::canTalk
testGetTalkExceptionsForNsMedia()
Exceptions with getTalk() NS_MEDIA does not have talk pages.
testIsContent()
MWNamespace::isContent.
testIsSubject()
Please make sure to change testIsTalk() if you change the assertions below MWNamespace::isSubject.
setMwGlobals( $pairs, $value=null)
Sets a global, maintaining a stashed version of the previous global to be restored in tearDown.
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:1976
processing should stop and the error should be shown to the user * false
Definition hooks.txt:187
const NS_USER
Definition Defines.php:67
const NS_FILE
Definition Defines.php:71
const NS_MAIN
Definition Defines.php:65
const NS_PROJECT_TALK
Definition Defines.php:70
const NS_MEDIAWIKI
Definition Defines.php:73
const NS_TEMPLATE
Definition Defines.php:75
const NS_SPECIAL
Definition Defines.php:54
const NS_MEDIA
Definition Defines.php:53
const NS_TALK
Definition Defines.php:66
const NS_USER_TALK
Definition Defines.php:68
const NS_PROJECT
Definition Defines.php:69
const NS_CATEGORY
Definition Defines.php:79