tests/phpunit/includes/GlobalTest.php

   1 <?php
   2
   3 class GlobalTest extends MediaWikiTestCase {
   4         function setUp() {
   5                 global $wgReadOnlyFile, $wgContLang, $wgLang;
   6                 $this->originals['wgReadOnlyFile'] = $wgReadOnlyFile;
   7                 $wgReadOnlyFile = tempnam( wfTempDir(), "mwtest_readonly" );
   8                 unlink( $wgReadOnlyFile );
   9                 $wgContLang = $wgLang = Language::factory( 'en' );
  10         }
  11
  12         function tearDown() {
  13                 global $wgReadOnlyFile;
  14                 if ( file_exists( $wgReadOnlyFile ) ) {
  15                         unlink( $wgReadOnlyFile );
  16                 }
  17                 $wgReadOnlyFile = $this->originals['wgReadOnlyFile'];
  18         }
  19
  20         function testRandom() {
  21                 # This could hypothetically fail, but it shouldn't ;)
  22                 $this->assertFalse(
  23                         wfRandom() == wfRandom() );
  24         }
  25
  26         function testUrlencode() {
  27                 $this->assertEquals(
  28                         "%E7%89%B9%E5%88%A5:Contributions/Foobar",
  29                         wfUrlencode( "\xE7\x89\xB9\xE5\x88\xA5:Contributions/Foobar" ) );
  30         }
  31
  32         function testReadOnlyEmpty() {
  33                 global $wgReadOnly;
  34                 $wgReadOnly = null;
  35
  36                 $this->assertFalse( wfReadOnly() );
  37                 $this->assertFalse( wfReadOnly() );
  38         }
  39
  40         function testReadOnlySet() {
  41                 global $wgReadOnly, $wgReadOnlyFile;
  42
  43                 $f = fopen( $wgReadOnlyFile, "wt" );
  44                 fwrite( $f, 'Message' );
  45                 fclose( $f );
  46                 $wgReadOnly = null; # Check on $wgReadOnlyFile
  47
  48                 $this->assertTrue( wfReadOnly() );
  49                 $this->assertTrue( wfReadOnly() ); # Check cached
  50
  51                 unlink( $wgReadOnlyFile );
  52                 $wgReadOnly = null; # Clean cache
  53
  54                 $this->assertFalse( wfReadOnly() );
  55                 $this->assertFalse( wfReadOnly() );
  56         }
  57
  58         function testQuotedPrintable() {
  59                 $this->assertEquals(
  60                         "=?UTF-8?Q?=C4=88u=20legebla=3F?=",
  61                         UserMailer::quotedPrintable( "\xc4\x88u legebla?", "UTF-8" ) );
  62         }
  63
  64         function testTime() {
  65                 $start = wfTime();
  66                 $this->assertInternalType( 'float', $start );
  67                 $end = wfTime();
  68                 $this->assertTrue( $end > $start, "Time is running backwards!" );
  69         }
  70
  71         function testArrayToCGI() {
  72                 $this->assertEquals(
  73                         "baz=AT%26T&foo=bar",
  74                         wfArrayToCGI(
  75                                 array( 'baz' => 'AT&T', 'ignore' => '' ),
  76                                 array( 'foo' => 'bar', 'baz' => 'overridden value' ) ) );
  77         }
  78
  79         function testMimeTypeMatch() {
  80                 $this->assertEquals(
  81                         'text/html',
  82                         mimeTypeMatch( 'text/html',
  83                                 array( 'application/xhtml+xml' => 1.0,
  84                                        'text/html'             => 0.7,
  85                                        'text/plain'            => 0.3 ) ) );
  86                 $this->assertEquals(
  87                         'text/*',
  88                         mimeTypeMatch( 'text/html',
  89                                 array( 'image/*' => 1.0,
  90                                        'text/*'  => 0.5 ) ) );
  91                 $this->assertEquals(
  92                         '*/*',
  93                         mimeTypeMatch( 'text/html',
  94                                 array( '*/*' => 1.0 ) ) );
  95                 $this->assertNull(
  96                         mimeTypeMatch( 'text/html',
  97                                 array( 'image/png'     => 1.0,
  98                                        'image/svg+xml' => 0.5 ) ) );
  99         }
 100
 101         function testNegotiateType() {
 102                 $this->assertEquals(
 103                         'text/html',
 104                         wfNegotiateType(
 105                                 array( 'application/xhtml+xml' => 1.0,
 106                                        'text/html'             => 0.7,
 107                                        'text/plain'            => 0.5,
 108                                        'text/*'                => 0.2 ),
 109                                 array( 'text/html'             => 1.0 ) ) );
 110                 $this->assertEquals(
 111                         'application/xhtml+xml',
 112                         wfNegotiateType(
 113                                 array( 'application/xhtml+xml' => 1.0,
 114                                        'text/html'             => 0.7,
 115                                        'text/plain'            => 0.5,
 116                                        'text/*'                => 0.2 ),
 117                                 array( 'application/xhtml+xml' => 1.0,
 118                                        'text/html'             => 0.5 ) ) );
 119                 $this->assertEquals(
 120                         'text/html',
 121                         wfNegotiateType(
 122                                 array( 'text/html'             => 1.0,
 123                                        'text/plain'            => 0.5,
 124                                        'text/*'                => 0.5,
 125                                        'application/xhtml+xml' => 0.2 ),
 126                                 array( 'application/xhtml+xml' => 1.0,
 127                                        'text/html'             => 0.5 ) ) );
 128                 $this->assertEquals(
 129                         'text/html',
 130                         wfNegotiateType(
 131                                 array( 'text/*'                => 1.0,
 132                                        'image/*'               => 0.7,
 133                                        '*/*'                   => 0.3 ),
 134                                 array( 'application/xhtml+xml' => 1.0,
 135                                        'text/html'             => 0.5 ) ) );
 136                 $this->assertNull(
 137                         wfNegotiateType(
 138                                 array( 'text/*'                => 1.0 ),
 139                                 array( 'application/xhtml+xml' => 1.0 ) ) );
 140         }
 141
 142         function testTimestamp() {
 143                 $t = gmmktime( 12, 34, 56, 1, 15, 2001 );
 144                 $this->assertEquals(
 145                         '20010115123456',
 146                         wfTimestamp( TS_MW, $t ),
 147                         'TS_UNIX to TS_MW' );
 148                 $this->assertEquals(
 149                         '19690115123456',
 150                         wfTimestamp( TS_MW, -30281104 ),
 151                         'Negative TS_UNIX to TS_MW' );
 152                 $this->assertEquals(
 153                         979562096,
 154                         wfTimestamp( TS_UNIX, $t ),
 155                         'TS_UNIX to TS_UNIX' );
 156                 $this->assertEquals(
 157                         '2001-01-15 12:34:56',
 158                         wfTimestamp( TS_DB, $t ),
 159                         'TS_UNIX to TS_DB' );
 160                 $this->assertEquals(
 161                         '20010115T123456Z',
 162                         wfTimestamp( TS_ISO_8601_BASIC, $t ),
 163                         'TS_ISO_8601_BASIC to TS_DB' );
 164
 165                 $this->assertEquals(
 166                         '20010115123456',
 167                         wfTimestamp( TS_MW, '20010115123456' ),
 168                         'TS_MW to TS_MW' );
 169                 $this->assertEquals(
 170                         979562096,
 171                         wfTimestamp( TS_UNIX, '20010115123456' ),
 172                         'TS_MW to TS_UNIX' );
 173                 $this->assertEquals(
 174                         '2001-01-15 12:34:56',
 175                         wfTimestamp( TS_DB, '20010115123456' ),
 176                         'TS_MW to TS_DB' );
 177                 $this->assertEquals(
 178                         '20010115T123456Z',
 179                         wfTimestamp( TS_ISO_8601_BASIC, '20010115123456' ),
 180                         'TS_MW to TS_ISO_8601_BASIC' );
 181
 182                 $this->assertEquals(
 183                         '20010115123456',
 184                         wfTimestamp( TS_MW, '2001-01-15 12:34:56' ),
 185                         'TS_DB to TS_MW' );
 186                 $this->assertEquals(
 187                         979562096,
 188                         wfTimestamp( TS_UNIX, '2001-01-15 12:34:56' ),
 189                         'TS_DB to TS_UNIX' );
 190                 $this->assertEquals(
 191                         '2001-01-15 12:34:56',
 192                         wfTimestamp( TS_DB, '2001-01-15 12:34:56' ),
 193                         'TS_DB to TS_DB' );
 194                 $this->assertEquals(
 195                         '20010115T123456Z',
 196                         wfTimestamp( TS_ISO_8601_BASIC, '2001-01-15 12:34:56' ),
 197                         'TS_DB to TS_ISO_8601_BASIC' );
 198
 199                 # rfc2822 section 3.3
 200
 201                 $this->assertEquals(
 202                         'Mon, 15 Jan 2001 12:34:56 GMT',
 203                         wfTimestamp( TS_RFC2822, '20010115123456' ),
 204                         'TS_MW to TS_RFC2822' );
 205
 206                 $this->assertEquals(
 207                         '20010115123456',
 208                         wfTimestamp( TS_MW, 'Mon, 15 Jan 2001 12:34:56 GMT' ),
 209                         'TS_RFC2822 to TS_MW' );
 210
 211                 $this->assertEquals(
 212                         '20010115123456',
 213                         wfTimestamp( TS_MW, ' Mon, 15 Jan 2001 12:34:56 GMT' ),
 214                         'TS_RFC2822 with leading space to TS_MW' );
 215
 216                 $this->assertEquals(
 217                         '20010115123456',
 218                         wfTimestamp( TS_MW, '15 Jan 2001 12:34:56 GMT' ),
 219                         'TS_RFC2822 without optional day-of-week to TS_MW' );
 220
 221                 # FWS = ([*WSP CRLF] 1*WSP) / obs-FWS ; Folding white space
 222                 # obs-FWS = 1*WSP *(CRLF 1*WSP) ; Section 4.2
 223                 $this->assertEquals(
 224                         '20010115123456',
 225                         wfTimestamp( TS_MW, 'Mon, 15         Jan 2001 12:34:56 GMT' ),
 226                         'TS_RFC2822 to TS_MW' );
 227
 228                 # WSP = SP / HTAB ; rfc2234
 229                 $this->assertEquals(
 230                         '20010115123456',
 231                         wfTimestamp( TS_MW, "Mon, 15 Jan\x092001 12:34:56 GMT" ),
 232                         'TS_RFC2822 with HTAB to TS_MW' );
 233
 234                 $this->assertEquals(
 235                         '20010115123456',
 236                         wfTimestamp( TS_MW, "Mon, 15 Jan\x09 \x09  2001 12:34:56 GMT" ),
 237                         'TS_RFC2822 with HTAB and SP to TS_MW' );
 238
 239                 $this->assertEquals(
 240                         '19941106084937',
 241                         wfTimestamp( TS_MW, "Sun, 6 Nov 94 08:49:37 GMT" ),
 242                         'TS_RFC2822 with obsolete year to TS_MW' );
 243         }
 244
 245         /**
 246          * This test checks wfTimestamp() with values outside.
 247          * It needs PHP 64 bits or PHP > 5.1.
 248          * See r74778 and bug 25451
 249          */
 250         function testOldTimestamps() {
 251                 $this->assertEquals( 'Fri, 13 Dec 1901 20:45:54 GMT',
 252                         wfTimestamp( TS_RFC2822, '19011213204554' ),
 253                         'Earliest time according to php documentation' );
 254
 255                 $this->assertEquals( 'Tue, 19 Jan 2038 03:14:07 GMT',
 256                         wfTimestamp( TS_RFC2822, '20380119031407' ),
 257                         'Latest 32 bit time' );
 258
 259                 $this->assertEquals( '-2147483648',
 260                         wfTimestamp( TS_UNIX, '19011213204552' ),
 261                         'Earliest 32 bit unix time' );
 262
 263                 $this->assertEquals( '2147483647',
 264                         wfTimestamp( TS_UNIX, '20380119031407' ),
 265                         'Latest 32 bit unix time' );
 266
 267                 $this->assertEquals( 'Fri, 13 Dec 1901 20:45:52 GMT',
 268                         wfTimestamp( TS_RFC2822, '19011213204552' ),
 269                         'Earliest 32 bit time' );
 270
 271                 $this->assertEquals( 'Fri, 13 Dec 1901 20:45:51 GMT',
 272                         wfTimestamp( TS_RFC2822, '19011213204551' ),
 273                         'Earliest 32 bit time - 1' );
 274
 275                 $this->assertEquals( 'Tue, 19 Jan 2038 03:14:08 GMT',
 276                         wfTimestamp( TS_RFC2822, '20380119031408' ),
 277                         'Latest 32 bit time + 1' );
 278
 279                 $this->assertEquals( '19011212000000',
 280                         wfTimestamp(TS_MW, '19011212000000'),
 281                         'Convert to itself r74778#c10645' );
 282
 283                 $this->assertEquals( '-2147483649',
 284                         wfTimestamp( TS_UNIX, '19011213204551' ),
 285                         'Earliest 32 bit unix time - 1' );
 286
 287                 $this->assertEquals( '2147483648',
 288                         wfTimestamp( TS_UNIX, '20380119031408' ),
 289                         'Latest 32 bit unix time + 1' );
 290
 291                 $this->assertEquals( '19011213204551',
 292                         wfTimestamp( TS_MW, '-2147483649' ),
 293                         '1901 negative unix time to MediaWiki' );
 294
 295                 $this->assertEquals( '18010115123456',
 296                         wfTimestamp( TS_MW, '-5331871504' ),
 297                         '1801 negative unix time to MediaWiki' );
 298
 299                 $this->assertEquals( 'Tue, 09 Aug 0117 12:34:56 GMT',
 300                         wfTimestamp( TS_RFC2822, '0117-08-09 12:34:56'),
 301                         'Death of Roman Emperor [[Trajan]]');
 302
 303                 /* FIXME: 00 to 101 years are taken as being in [1970-2069] */
 304
 305                 $this->assertEquals( 'Sun, 01 Jan 0101 00:00:00 GMT',
 306                         wfTimestamp( TS_RFC2822, '-58979923200'),
 307                         '1/1/101');
 308
 309                 $this->assertEquals( 'Mon, 01 Jan 0001 00:00:00 GMT',
 310                         wfTimestamp( TS_RFC2822, '-62135596800'),
 311                         'Year 1');
 312
 313                 /* It is not clear if we should generate a year 0 or not
 314                  * We are completely off RFC2822 requirement of year being
 315                  * 1900 or later.
 316                  */
 317                 $this->assertEquals( 'Wed, 18 Oct 0000 00:00:00 GMT',
 318                         wfTimestamp( TS_RFC2822, '-62142076800'),
 319                         'ISO 8601:2004 [[year 0]], also called [[1 BC]]');
 320         }
 321
 322         function testHttpDate() {
 323                 # The Resource Loader uses wfTimestamp() to convert timestamps
 324                 # from If-Modified-Since header.
 325                 # Thus it must be able to parse all rfc2616 date formats
 326                 # http://www.w3.org/Protocols/rfc2616/rfc2616-sec3.html#sec3.3.1
 327
 328                 $this->assertEquals(
 329                         '19941106084937',
 330                         wfTimestamp( TS_MW, 'Sun, 06 Nov 1994 08:49:37 GMT' ),
 331                         'RFC 822 date' );
 332
 333                 $this->assertEquals(
 334                         '19941106084937',
 335                         wfTimestamp( TS_MW, 'Sunday, 06-Nov-94 08:49:37 GMT' ),
 336                         'RFC 850 date' );
 337
 338                 $this->assertEquals(
 339                         '19941106084937',
 340                         wfTimestamp( TS_MW, 'Sun Nov  6 08:49:37 1994' ),
 341                         "ANSI C's asctime() format" );
 342
 343                 // See http://www.squid-cache.org/mail-archive/squid-users/200307/0122.html and r77171
 344                 $this->assertEquals(
 345                         '20101122141242',
 346                         wfTimestamp( TS_MW, 'Mon, 22 Nov 2010 14:12:42 GMT; length=52626' ),
 347                         "Netscape extension to HTTP/1.0" );
 348
 349         }
 350
 351         function testTimestampParameter() {
 352                 // There are a number of assumptions in our codebase where wfTimestamp() should give
 353                 // the current date but it is not given a 0 there. See r71751 CR
 354
 355                 $now = wfTimestamp( TS_UNIX );
 356                 // We check that wfTimestamp doesn't return false (error) and use a LessThan assert
 357                 // for the cases where the test is run in a second boundary.
 358
 359                 $zero = wfTimestamp( TS_UNIX, 0 );
 360                 $this->assertNotEquals( false, $zero );
 361                 $this->assertLessThan( 5, $zero - $now );
 362
 363                 $empty = wfTimestamp( TS_UNIX, '' );
 364                 $this->assertNotEquals( false, $empty );
 365                 $this->assertLessThan( 5, $empty - $now );
 366
 367                 $null = wfTimestamp( TS_UNIX, null );
 368                 $this->assertNotEquals( false, $null );
 369                 $this->assertLessThan( 5, $null - $now );
 370         }
 371
 372         function testBasename() {
 373                 $sets = array(
 374                         '' => '',
 375                         '/' => '',
 376                         '\\' => '',
 377                         '//' => '',
 378                         '\\\\' => '',
 379                         'a' => 'a',
 380                         'aaaa' => 'aaaa',
 381                         '/a' => 'a',
 382                         '\\a' => 'a',
 383                         '/aaaa' => 'aaaa',
 384                         '\\aaaa' => 'aaaa',
 385                         '/aaaa/' => 'aaaa',
 386                         '\\aaaa\\' => 'aaaa',
 387                         '\\aaaa\\' => 'aaaa',
 388                         '/mnt/upload3/wikipedia/en/thumb/8/8b/Zork_Grand_Inquisitor_box_cover.jpg/93px-Zork_Grand_Inquisitor_box_cover.jpg' => '93px-Zork_Grand_Inquisitor_box_cover.jpg',
 389                         'C:\\Progra~1\\Wikime~1\\Wikipe~1\\VIEWER.EXE' => 'VIEWER.EXE',
 390                         'Östergötland_coat_of_arms.png' => 'Östergötland_coat_of_arms.png',
 391                         );
 392                 foreach ( $sets as $from => $to ) {
 393                         $this->assertEquals( $to, wfBaseName( $from ),
 394                                 "wfBaseName('$from') => '$to'" );
 395                 }
 396         }
 397
 398         /* TODO: many more! */
 399 }
 400
 401