tests/phpunit/includes/GlobalFunctions/GlobalTest.php

   1 <?php
   2
   3 /**
   4  * @group Database
   5  * @group GlobalFunctions
   6  */
   7 class GlobalTest extends MediaWikiTestCase {
   8         protected function setUp() {
   9                 parent::setUp();
  10
  11                 $readOnlyFile = $this->getNewTempFile();
  12                 unlink( $readOnlyFile );
  13
  14                 $this->setMwGlobals( [
  15                         'wgReadOnlyFile' => $readOnlyFile,
  16                         'wgUrlProtocols' => [
  17                                 'http://',
  18                                 'https://',
  19                                 'mailto:',
  20                                 '//',
  21                                 'file://', # Non-default
  22                         ],
  23                 ] );
  24         }
  25
  26         /**
  27          * @dataProvider provideForWfArrayDiff2
  28          * @covers ::wfArrayDiff2
  29          */
  30         public function testWfArrayDiff2( $a, $b, $expected ) {
  31                 $this->assertEquals(
  32                         wfArrayDiff2( $a, $b ), $expected
  33                 );
  34         }
  35
  36         // @todo Provide more tests
  37         public static function provideForWfArrayDiff2() {
  38                 // $a $b $expected
  39                 return [
  40                         [
  41                                 [ 'a', 'b' ],
  42                                 [ 'a', 'b' ],
  43                                 [],
  44                         ],
  45                         [
  46                                 [ [ 'a' ], [ 'a', 'b', 'c' ] ],
  47                                 [ [ 'a' ], [ 'a', 'b' ] ],
  48                                 [ 1 => [ 'a', 'b', 'c' ] ],
  49                         ],
  50                 ];
  51         }
  52
  53         /*
  54          * Test cases for random functions could hypothetically fail,
  55          * even though they shouldn't.
  56          */
  57
  58         /**
  59          * @covers ::wfRandom
  60          */
  61         public function testRandom() {
  62                 $this->assertFalse(
  63                         wfRandom() == wfRandom()
  64                 );
  65         }
  66
  67         /**
  68          * @covers ::wfRandomString
  69          */
  70         public function testRandomString() {
  71                 $this->assertFalse(
  72                         wfRandomString() == wfRandomString()
  73                 );
  74                 $this->assertEquals(
  75                         strlen( wfRandomString( 10 ) ), 10
  76                 );
  77                 $this->assertTrue(
  78                         preg_match( '/^[0-9a-f]+$/i', wfRandomString() ) === 1
  79                 );
  80         }
  81
  82         /**
  83          * @covers ::wfUrlencode
  84          */
  85         public function testUrlencode() {
  86                 $this->assertEquals(
  87                         "%E7%89%B9%E5%88%A5:Contributions/Foobar",
  88                         wfUrlencode( "\xE7\x89\xB9\xE5\x88\xA5:Contributions/Foobar" ) );
  89         }
  90
  91         /**
  92          * @covers ::wfExpandIRI
  93          */
  94         public function testExpandIRI() {
  95                 $this->assertEquals(
  96                         "https://te.wikibooks.org/wiki/ఉబుంటు_వాడుకరి_మార్గదర్శని",
  97                         wfExpandIRI( "https://te.wikibooks.org/wiki/"
  98                                 . "%E0%B0%89%E0%B0%AC%E0%B1%81%E0%B0%82%E0%B0%9F%E0%B1%81_"
  99                                 . "%E0%B0%B5%E0%B0%BE%E0%B0%A1%E0%B1%81%E0%B0%95%E0%B0%B0%E0%B0%BF_"
 100                                 . "%E0%B0%AE%E0%B0%BE%E0%B0%B0%E0%B1%8D%E0%B0%97%E0%B0%A6%E0%B0%B0"
 101                                 . "%E0%B1%8D%E0%B0%B6%E0%B0%A8%E0%B0%BF" ) );
 102         }
 103
 104         /**
 105          * Intended to cover the relevant bits of ServiceWiring.php, as well as GlobalFunctions.php
 106          * @covers ::wfReadOnly
 107          */
 108         public function testReadOnlyEmpty() {
 109                 global $wgReadOnly;
 110                 $wgReadOnly = null;
 111
 112                 MediaWiki\MediaWikiServices::getInstance()->getReadOnlyMode()->clearCache();
 113                 $this->assertFalse( wfReadOnly() );
 114                 $this->assertFalse( wfReadOnly() );
 115         }
 116
 117         /**
 118          * Intended to cover the relevant bits of ServiceWiring.php, as well as GlobalFunctions.php
 119          * @covers ::wfReadOnly
 120          */
 121         public function testReadOnlySet() {
 122                 global $wgReadOnly, $wgReadOnlyFile;
 123
 124                 $readOnlyMode = MediaWiki\MediaWikiServices::getInstance()->getReadOnlyMode();
 125                 $readOnlyMode->clearCache();
 126
 127                 $f = fopen( $wgReadOnlyFile, "wt" );
 128                 fwrite( $f, 'Message' );
 129                 fclose( $f );
 130                 $wgReadOnly = null; # Check on $wgReadOnlyFile
 131
 132                 $this->assertTrue( wfReadOnly() );
 133                 $this->assertTrue( wfReadOnly() ); # Check cached
 134
 135                 unlink( $wgReadOnlyFile );
 136                 $readOnlyMode->clearCache();
 137                 $this->assertFalse( wfReadOnly() );
 138                 $this->assertFalse( wfReadOnly() );
 139         }
 140
 141         /**
 142          * This behaviour could probably be deprecated. Several extensions rely on it as of 1.29.
 143          * @covers ::wfReadOnlyReason
 144          */
 145         public function testReadOnlyGlobalChange() {
 146                 $this->assertFalse( wfReadOnlyReason() );
 147                 $this->setMwGlobals( [
 148                         'wgReadOnly' => 'reason'
 149                 ] );
 150                 $this->assertSame( 'reason', wfReadOnlyReason() );
 151         }
 152
 153         public static function provideArrayToCGI() {
 154                 return [
 155                         [ [], '' ], // empty
 156                         [ [ 'foo' => 'bar' ], 'foo=bar' ], // string test
 157                         [ [ 'foo' => '' ], 'foo=' ], // empty string test
 158                         [ [ 'foo' => 1 ], 'foo=1' ], // number test
 159                         [ [ 'foo' => true ], 'foo=1' ], // true test
 160                         [ [ 'foo' => false ], '' ], // false test
 161                         [ [ 'foo' => null ], '' ], // null test
 162                         [ [ 'foo' => 'A&B=5+6@!"\'' ], 'foo=A%26B%3D5%2B6%40%21%22%27' ], // urlencoding test
 163                         [
 164                                 [ 'foo' => 'bar', 'baz' => 'is', 'asdf' => 'qwerty' ],
 165                                 'foo=bar&baz=is&asdf=qwerty'
 166                         ], // multi-item test
 167                         [ [ 'foo' => [ 'bar' => 'baz' ] ], 'foo%5Bbar%5D=baz' ],
 168                         [
 169                                 [ 'foo' => [ 'bar' => 'baz', 'qwerty' => 'asdf' ] ],
 170                                 'foo%5Bbar%5D=baz&foo%5Bqwerty%5D=asdf'
 171                         ],
 172                         [ [ 'foo' => [ 'bar', 'baz' ] ], 'foo%5B0%5D=bar&foo%5B1%5D=baz' ],
 173                         [
 174                                 [ 'foo' => [ 'bar' => [ 'bar' => 'baz' ] ] ],
 175                                 'foo%5Bbar%5D%5Bbar%5D=baz'
 176                         ],
 177                 ];
 178         }
 179
 180         /**
 181          * @dataProvider provideArrayToCGI
 182          * @covers ::wfArrayToCgi
 183          */
 184         public function testArrayToCGI( $array, $result ) {
 185                 $this->assertEquals( $result, wfArrayToCgi( $array ) );
 186         }
 187
 188         /**
 189          * @covers ::wfArrayToCgi
 190          */
 191         public function testArrayToCGI2() {
 192                 $this->assertEquals(
 193                         "baz=bar&foo=bar",
 194                         wfArrayToCgi(
 195                                 [ 'baz' => 'bar' ],
 196                                 [ 'foo' => 'bar', 'baz' => 'overridden value' ] ) );
 197         }
 198
 199         public static function provideCgiToArray() {
 200                 return [
 201                         [ '', [] ], // empty
 202                         [ 'foo=bar', [ 'foo' => 'bar' ] ], // string
 203                         [ 'foo=', [ 'foo' => '' ] ], // empty string
 204                         [ 'foo', [ 'foo' => '' ] ], // missing =
 205                         [ 'foo=bar&qwerty=asdf', [ 'foo' => 'bar', 'qwerty' => 'asdf' ] ], // multiple value
 206                         [ 'foo=A%26B%3D5%2B6%40%21%22%27', [ 'foo' => 'A&B=5+6@!"\'' ] ], // urldecoding test
 207                         [ 'foo%5Bbar%5D=baz', [ 'foo' => [ 'bar' => 'baz' ] ] ],
 208                         [
 209                                 'foo%5Bbar%5D=baz&foo%5Bqwerty%5D=asdf',
 210                                 [ 'foo' => [ 'bar' => 'baz', 'qwerty' => 'asdf' ] ]
 211                         ],
 212                         [ 'foo%5B0%5D=bar&foo%5B1%5D=baz', [ 'foo' => [ 0 => 'bar', 1 => 'baz' ] ] ],
 213                         [
 214                                 'foo%5Bbar%5D%5Bbar%5D=baz',
 215                                 [ 'foo' => [ 'bar' => [ 'bar' => 'baz' ] ] ]
 216                         ],
 217                 ];
 218         }
 219
 220         /**
 221          * @dataProvider provideCgiToArray
 222          * @covers ::wfCgiToArray
 223          */
 224         public function testCgiToArray( $cgi, $result ) {
 225                 $this->assertEquals( $result, wfCgiToArray( $cgi ) );
 226         }
 227
 228         public static function provideCgiRoundTrip() {
 229                 return [
 230                         [ '' ],
 231                         [ 'foo=bar' ],
 232                         [ 'foo=' ],
 233                         [ 'foo=bar&baz=biz' ],
 234                         [ 'foo=A%26B%3D5%2B6%40%21%22%27' ],
 235                         [ 'foo%5Bbar%5D=baz' ],
 236                         [ 'foo%5B0%5D=bar&foo%5B1%5D=baz' ],
 237                         [ 'foo%5Bbar%5D%5Bbar%5D=baz' ],
 238                 ];
 239         }
 240
 241         /**
 242          * @dataProvider provideCgiRoundTrip
 243          * @covers ::wfArrayToCgi
 244          */
 245         public function testCgiRoundTrip( $cgi ) {
 246                 $this->assertEquals( $cgi, wfArrayToCgi( wfCgiToArray( $cgi ) ) );
 247         }
 248
 249         /**
 250          * @covers ::mimeTypeMatch
 251          */
 252         public function testMimeTypeMatch() {
 253                 $this->assertEquals(
 254                         'text/html',
 255                         mimeTypeMatch( 'text/html',
 256                                 [ 'application/xhtml+xml' => 1.0,
 257                                         'text/html' => 0.7,
 258                                         'text/plain' => 0.3 ] ) );
 259                 $this->assertEquals(
 260                         'text/*',
 261                         mimeTypeMatch( 'text/html',
 262                                 [ 'image/*' => 1.0,
 263                                         'text/*' => 0.5 ] ) );
 264                 $this->assertEquals(
 265                         '*/*',
 266                         mimeTypeMatch( 'text/html',
 267                                 [ '*/*' => 1.0 ] ) );
 268                 $this->assertNull(
 269                         mimeTypeMatch( 'text/html',
 270                                 [ 'image/png' => 1.0,
 271                                         'image/svg+xml' => 0.5 ] ) );
 272         }
 273
 274         /**
 275          * @covers ::wfNegotiateType
 276          */
 277         public function testNegotiateType() {
 278                 $this->assertEquals(
 279                         'text/html',
 280                         wfNegotiateType(
 281                                 [ 'application/xhtml+xml' => 1.0,
 282                                         'text/html' => 0.7,
 283                                         'text/plain' => 0.5,
 284                                         'text/*' => 0.2 ],
 285                                 [ 'text/html' => 1.0 ] ) );
 286                 $this->assertEquals(
 287                         'application/xhtml+xml',
 288                         wfNegotiateType(
 289                                 [ 'application/xhtml+xml' => 1.0,
 290                                         'text/html' => 0.7,
 291                                         'text/plain' => 0.5,
 292                                         'text/*' => 0.2 ],
 293                                 [ 'application/xhtml+xml' => 1.0,
 294                                         'text/html' => 0.5 ] ) );
 295                 $this->assertEquals(
 296                         'text/html',
 297                         wfNegotiateType(
 298                                 [ 'text/html' => 1.0,
 299                                         'text/plain' => 0.5,
 300                                         'text/*' => 0.5,
 301                                         'application/xhtml+xml' => 0.2 ],
 302                                 [ 'application/xhtml+xml' => 1.0,
 303                                         'text/html' => 0.5 ] ) );
 304                 $this->assertEquals(
 305                         'text/html',
 306                         wfNegotiateType(
 307                                 [ 'text/*' => 1.0,
 308                                         'image/*' => 0.7,
 309                                         '*/*' => 0.3 ],
 310                                 [ 'application/xhtml+xml' => 1.0,
 311                                         'text/html' => 0.5 ] ) );
 312                 $this->assertNull(
 313                         wfNegotiateType(
 314                                 [ 'text/*' => 1.0 ],
 315                                 [ 'application/xhtml+xml' => 1.0 ] ) );
 316         }
 317
 318         /**
 319          * @covers ::wfDebug
 320          * @covers ::wfDebugMem
 321          */
 322         public function testDebugFunctionTest() {
 323                 $debugLogFile = $this->getNewTempFile();
 324
 325                 $this->setMwGlobals( [
 326                         'wgDebugLogFile' => $debugLogFile,
 327                         #  @todo FIXME: $wgDebugTimestamps should be tested
 328                         'wgDebugTimestamps' => false
 329                 ] );
 330
 331                 wfDebug( "This is a normal string" );
 332                 $this->assertEquals( "This is a normal string\n", file_get_contents( $debugLogFile ) );
 333                 unlink( $debugLogFile );
 334
 335                 wfDebug( "This is nöt an ASCII string" );
 336                 $this->assertEquals( "This is nöt an ASCII string\n", file_get_contents( $debugLogFile ) );
 337                 unlink( $debugLogFile );
 338
 339                 wfDebug( "\00305This has böth UTF and control chars\003" );
 340                 $this->assertEquals(
 341                         " 05This has böth UTF and control chars \n",
 342                         file_get_contents( $debugLogFile )
 343                 );
 344                 unlink( $debugLogFile );
 345
 346                 wfDebugMem();
 347                 $this->assertGreaterThan(
 348                         1000,
 349                         preg_replace( '/\D/', '', file_get_contents( $debugLogFile ) )
 350                 );
 351                 unlink( $debugLogFile );
 352
 353                 wfDebugMem( true );
 354                 $this->assertGreaterThan(
 355                         1000000,
 356                         preg_replace( '/\D/', '', file_get_contents( $debugLogFile ) )
 357                 );
 358                 unlink( $debugLogFile );
 359         }
 360
 361         /**
 362          * @covers ::wfClientAcceptsGzip
 363          */
 364         public function testClientAcceptsGzipTest() {
 365                 $settings = [
 366                         'gzip' => true,
 367                         'bzip' => false,
 368                         '*' => false,
 369                         'compress, gzip' => true,
 370                         'gzip;q=1.0' => true,
 371                         'foozip' => false,
 372                         'foo*zip' => false,
 373                         'gzip;q=abcde' => true, // is this REALLY valid?
 374                         'gzip;q=12345678.9' => true,
 375                         ' gzip' => true,
 376                 ];
 377
 378                 if ( isset( $_SERVER['HTTP_ACCEPT_ENCODING'] ) ) {
 379                         $old_server_setting = $_SERVER['HTTP_ACCEPT_ENCODING'];
 380                 }
 381
 382                 foreach ( $settings as $encoding => $expect ) {
 383                         $_SERVER['HTTP_ACCEPT_ENCODING'] = $encoding;
 384
 385                         $this->assertEquals( $expect, wfClientAcceptsGzip( true ),
 386                                 "'$encoding' => " . wfBoolToStr( $expect ) );
 387                 }
 388
 389                 if ( isset( $old_server_setting ) ) {
 390                         $_SERVER['HTTP_ACCEPT_ENCODING'] = $old_server_setting;
 391                 }
 392         }
 393
 394         /**
 395          * @covers ::wfPercent
 396          */
 397         public function testWfPercentTest() {
 398                 $pcts = [
 399                         [ 6 / 7, '0.86%', 2, false ],
 400                         [ 3 / 3, '1%' ],
 401                         [ 22 / 7, '3.14286%', 5 ],
 402                         [ 3 / 6, '0.5%' ],
 403                         [ 1 / 3, '0%', 0 ],
 404                         [ 10 / 3, '0%', -1 ],
 405                         [ 3 / 4 / 5, '0.1%', 1 ],
 406                         [ 6 / 7 * 8, '6.8571428571%', 10 ],
 407                 ];
 408
 409                 foreach ( $pcts as $pct ) {
 410                         if ( !isset( $pct[2] ) ) {
 411                                 $pct[2] = 2;
 412                         }
 413                         if ( !isset( $pct[3] ) ) {
 414                                 $pct[3] = true;
 415                         }
 416
 417                         $this->assertEquals( wfPercent( $pct[0], $pct[2], $pct[3] ), $pct[1], $pct[1] );
 418                 }
 419         }
 420
 421         /**
 422          * test @see wfShorthandToInteger()
 423          * @dataProvider provideShorthand
 424          * @covers ::wfShorthandToInteger
 425          */
 426         public function testWfShorthandToInteger( $shorthand, $expected ) {
 427                 $this->assertEquals( $expected,
 428                         wfShorthandToInteger( $shorthand )
 429                 );
 430         }
 431
 432         public static function provideShorthand() {
 433                 // Syntax: [ shorthand, expected integer ]
 434                 return [
 435                         # Null, empty ...
 436                         [ '', -1 ],
 437                         [ '  ', -1 ],
 438                         [ null, -1 ],
 439
 440                         # Failures returns 0 :(
 441                         [ 'ABCDEFG', 0 ],
 442                         [ 'Ak', 0 ],
 443
 444                         # Int, strings with spaces
 445                         [ 1, 1 ],
 446                         [ ' 1 ', 1 ],
 447                         [ 1023, 1023 ],
 448                         [ ' 1023 ', 1023 ],
 449
 450                         # kilo, Mega, Giga
 451                         [ '1k', 1024 ],
 452                         [ '1K', 1024 ],
 453                         [ '1m', 1024 * 1024 ],
 454                         [ '1M', 1024 * 1024 ],
 455                         [ '1g', 1024 * 1024 * 1024 ],
 456                         [ '1G', 1024 * 1024 * 1024 ],
 457
 458                         # Negatives
 459                         [ -1, -1 ],
 460                         [ -500, -500 ],
 461                         [ '-500', -500 ],
 462                         [ '-1k', -1024 ],
 463
 464                         # Zeroes
 465                         [ '0', 0 ],
 466                         [ '0k', 0 ],
 467                         [ '0M', 0 ],
 468                         [ '0G', 0 ],
 469                         [ '-0', 0 ],
 470                         [ '-0k', 0 ],
 471                         [ '-0M', 0 ],
 472                         [ '-0G', 0 ],
 473                 ];
 474         }
 475
 476         /**
 477          * @param string $old Text as it was in the database
 478          * @param string $mine Text submitted while user was editing
 479          * @param string $yours Text submitted by the user
 480          * @param bool $expectedMergeResult Whether the merge should be a success
 481          * @param string $expectedText Text after merge has been completed
 482          *
 483          * @dataProvider provideMerge()
 484          * @group medium
 485          * @covers ::wfMerge
 486          */
 487         public function testMerge( $old, $mine, $yours, $expectedMergeResult, $expectedText ) {
 488                 $this->markTestSkippedIfNoDiff3();
 489
 490                 $mergedText = null;
 491                 $isMerged = wfMerge( $old, $mine, $yours, $mergedText );
 492
 493                 $msg = 'Merge should be a ';
 494                 $msg .= $expectedMergeResult ? 'success' : 'failure';
 495                 $this->assertEquals( $expectedMergeResult, $isMerged, $msg );
 496
 497                 if ( $isMerged ) {
 498                         // Verify the merged text
 499                         $this->assertEquals( $expectedText, $mergedText,
 500                                 'is merged text as expected?' );
 501                 }
 502         }
 503
 504         public static function provideMerge() {
 505                 $EXPECT_MERGE_SUCCESS = true;
 506                 $EXPECT_MERGE_FAILURE = false;
 507
 508                 return [
 509                         // #0: clean merge
 510                         [
 511                                 // old:
 512                                 "one one one\n" . // trimmed
 513                                         "\n" .
 514                                         "two two two",
 515
 516                                 // mine:
 517                                 "one one one ONE ONE\n" .
 518                                         "\n" .
 519                                         "two two two\n", // with tailing whitespace
 520
 521                                 // yours:
 522                                 "one one one\n" .
 523                                         "\n" .
 524                                         "two two TWO TWO", // trimmed
 525
 526                                 // ok:
 527                                 $EXPECT_MERGE_SUCCESS,
 528
 529                                 // result:
 530                                 "one one one ONE ONE\n" .
 531                                         "\n" .
 532                                         "two two TWO TWO\n", // note: will always end in a newline
 533                         ],
 534
 535                         // #1: conflict, fail
 536                         [
 537                                 // old:
 538                                 "one one one", // trimmed
 539
 540                                 // mine:
 541                                 "one one one ONE ONE\n" .
 542                                         "\n" .
 543                                         "bla bla\n" .
 544                                         "\n", // with tailing whitespace
 545
 546                                 // yours:
 547                                 "one one one\n" .
 548                                         "\n" .
 549                                         "two two", // trimmed
 550
 551                                 $EXPECT_MERGE_FAILURE,
 552
 553                                 // result:
 554                                 null,
 555                         ],
 556                 ];
 557         }
 558
 559         /**
 560          * @dataProvider provideMakeUrlIndexes()
 561          * @covers ::wfMakeUrlIndexes
 562          */
 563         public function testMakeUrlIndexes( $url, $expected ) {
 564                 $index = wfMakeUrlIndexes( $url );
 565                 $this->assertEquals( $expected, $index, "wfMakeUrlIndexes(\"$url\")" );
 566         }
 567
 568         public static function provideMakeUrlIndexes() {
 569                 return [
 570                         // Testcase for T30627
 571                         [
 572                                 'https://example.org/test.cgi?id=12345',
 573                                 [ 'https://org.example./test.cgi?id=12345' ]
 574                         ],
 575                         [
 576                                 // mailtos are handled special
 577                                 // is this really right though? that final . probably belongs earlier?
 578                                 'mailto:wiki@wikimedia.org',
 579                                 [ 'mailto:org.wikimedia@wiki.' ]
 580                         ],
 581
 582                         // file URL cases per T30627...
 583                         [
 584                                 // three slashes: local filesystem path Unix-style
 585                                 'file:///whatever/you/like.txt',
 586                                 [ 'file://./whatever/you/like.txt' ]
 587                         ],
 588                         [
 589                                 // three slashes: local filesystem path Windows-style
 590                                 'file:///c:/whatever/you/like.txt',
 591                                 [ 'file://./c:/whatever/you/like.txt' ]
 592                         ],
 593                         [
 594                                 // two slashes: UNC filesystem path Windows-style
 595                                 'file://intranet/whatever/you/like.txt',
 596                                 [ 'file://intranet./whatever/you/like.txt' ]
 597                         ],
 598                         // Multiple-slash cases that can sorta work on Mozilla
 599                         // if you hack it just right are kinda pathological,
 600                         // and unreliable cross-platform or on IE which means they're
 601                         // unlikely to appear on intranets.
 602                         // Those will survive the algorithm but with results that
 603                         // are less consistent.
 604
 605                         // protocol-relative URL cases per T31854...
 606                         [
 607                                 '//example.org/test.cgi?id=12345',
 608                                 [
 609                                         'http://org.example./test.cgi?id=12345',
 610                                         'https://org.example./test.cgi?id=12345'
 611                                 ]
 612                         ],
 613                 ];
 614         }
 615
 616         /**
 617          * @dataProvider provideWfMatchesDomainList
 618          * @covers ::wfMatchesDomainList
 619          */
 620         public function testWfMatchesDomainList( $url, $domains, $expected, $description ) {
 621                 $actual = wfMatchesDomainList( $url, $domains );
 622                 $this->assertEquals( $expected, $actual, $description );
 623         }
 624
 625         public static function provideWfMatchesDomainList() {
 626                 $a = [];
 627                 $protocols = [ 'HTTP' => 'http:', 'HTTPS' => 'https:', 'protocol-relative' => '' ];
 628                 foreach ( $protocols as $pDesc => $p ) {
 629                         $a = array_merge( $a, [
 630                                 [
 631                                         "$p//www.example.com",
 632                                         [],
 633                                         false,
 634                                         "No matches for empty domains array, $pDesc URL"
 635                                 ],
 636                                 [
 637                                         "$p//www.example.com",
 638                                         [ 'www.example.com' ],
 639                                         true,
 640                                         "Exact match in domains array, $pDesc URL"
 641                                 ],
 642                                 [
 643                                         "$p//www.example.com",
 644                                         [ 'example.com' ],
 645                                         true,
 646                                         "Match without subdomain in domains array, $pDesc URL"
 647                                 ],
 648                                 [
 649                                         "$p//www.example2.com",
 650                                         [ 'www.example.com', 'www.example2.com', 'www.example3.com' ],
 651                                         true,
 652                                         "Exact match with other domains in array, $pDesc URL"
 653                                 ],
 654                                 [
 655                                         "$p//www.example2.com",
 656                                         [ 'example.com', 'example2.com', 'example3,com' ],
 657                                         true,
 658                                         "Match without subdomain with other domains in array, $pDesc URL"
 659                                 ],
 660                                 [
 661                                         "$p//www.example4.com",
 662                                         [ 'example.com', 'example2.com', 'example3,com' ],
 663                                         false,
 664                                         "Domain not in array, $pDesc URL"
 665                                 ],
 666                                 [
 667                                         "$p//nds-nl.wikipedia.org",
 668                                         [ 'nl.wikipedia.org' ],
 669                                         false,
 670                                         "Non-matching substring of domain, $pDesc URL"
 671                                 ],
 672                         ] );
 673                 }
 674
 675                 return $a;
 676         }
 677
 678         /**
 679          * @covers ::wfMkdirParents
 680          */
 681         public function testWfMkdirParents() {
 682                 // Should not return true if file exists instead of directory
 683                 $fname = $this->getNewTempFile();
 684                 MediaWiki\suppressWarnings();
 685                 $ok = wfMkdirParents( $fname );
 686                 MediaWiki\restoreWarnings();
 687                 $this->assertFalse( $ok );
 688         }
 689
 690         /**
 691          * @dataProvider provideWfShellWikiCmdList
 692          * @covers ::wfShellWikiCmd
 693          */
 694         public function testWfShellWikiCmd( $script, $parameters, $options,
 695                 $expected, $description
 696         ) {
 697                 if ( wfIsWindows() ) {
 698                         // Approximation that's good enough for our purposes just now
 699                         $expected = str_replace( "'", '"', $expected );
 700                 }
 701                 $actual = wfShellWikiCmd( $script, $parameters, $options );
 702                 $this->assertEquals( $expected, $actual, $description );
 703         }
 704
 705         public function wfWikiID() {
 706                 $this->setMwGlobals( [
 707                         'wgDBname' => 'example',
 708                         'wgDBprefix' => '',
 709                 ] );
 710                 $this->assertEquals(
 711                         wfWikiID(),
 712                         'example'
 713                 );
 714
 715                 $this->setMwGlobals( [
 716                         'wgDBname' => 'example',
 717                         'wgDBprefix' => 'mw_',
 718                 ] );
 719                 $this->assertEquals(
 720                         wfWikiID(),
 721                         'example-mw_'
 722                 );
 723         }
 724
 725         public function testWfMemcKey() {
 726                 $cache = ObjectCache::getLocalClusterInstance();
 727                 $this->assertEquals(
 728                         $cache->makeKey( 'foo', 123, 'bar' ),
 729                         wfMemcKey( 'foo', 123, 'bar' )
 730                 );
 731         }
 732
 733         public function testWfForeignMemcKey() {
 734                 $cache = ObjectCache::getLocalClusterInstance();
 735                 $keyspace = $this->readAttribute( $cache, 'keyspace' );
 736                 $this->assertEquals(
 737                         wfForeignMemcKey( $keyspace, '', 'foo', 'bar' ),
 738                         $cache->makeKey( 'foo', 'bar' )
 739                 );
 740         }
 741
 742         public function testWfGlobalCacheKey() {
 743                 $cache = ObjectCache::getLocalClusterInstance();
 744                 $this->assertEquals(
 745                         $cache->makeGlobalKey( 'foo', 123, 'bar' ),
 746                         wfGlobalCacheKey( 'foo', 123, 'bar' )
 747                 );
 748         }
 749
 750         public static function provideWfShellWikiCmdList() {
 751                 global $wgPhpCli;
 752
 753                 return [
 754                         [ 'eval.php', [ '--help', '--test' ], [],
 755                                 "'$wgPhpCli' 'eval.php' '--help' '--test'",
 756                                 "Called eval.php --help --test" ],
 757                         [ 'eval.php', [ '--help', '--test space' ], [ 'php' => 'php5' ],
 758                                 "'php5' 'eval.php' '--help' '--test space'",
 759                                 "Called eval.php --help --test with php option" ],
 760                         [ 'eval.php', [ '--help', '--test', 'X' ], [ 'wrapper' => 'MWScript.php' ],
 761                                 "'$wgPhpCli' 'MWScript.php' 'eval.php' '--help' '--test' 'X'",
 762                                 "Called eval.php --help --test with wrapper option" ],
 763                         [
 764                                 'eval.php',
 765                                 [ '--help', '--test', 'y' ],
 766                                 [ 'php' => 'php5', 'wrapper' => 'MWScript.php' ],
 767                                 "'php5' 'MWScript.php' 'eval.php' '--help' '--test' 'y'",
 768                                 "Called eval.php --help --test with wrapper and php option"
 769                         ],
 770                 ];
 771         }
 772         /* @todo many more! */
 773 }