tests/phpunit/includes/IPTest.php

   1 <?php
   2 /**
   3  * Tests for IP validity functions. Ported from /t/inc/IP.t by avar.
   4  * @group IP
   5  */
   6
   7 class IPTest extends MediaWikiTestCase {
   8         /**
   9          *  not sure it should be tested with boolean false. hashar 20100924
  10          * @covers IP::isIPAddress
  11          */
  12         public function testisIPAddress() {
  13                 $this->assertFalse( IP::isIPAddress( false ), 'Boolean false is not an IP' );
  14                 $this->assertFalse( IP::isIPAddress( true ), 'Boolean true is not an IP' );
  15                 $this->assertFalse( IP::isIPAddress( "" ), 'Empty string is not an IP' );
  16                 $this->assertFalse( IP::isIPAddress( 'abc' ), 'Garbage IP string' );
  17                 $this->assertFalse( IP::isIPAddress( ':' ), 'Single ":" is not an IP' );
  18                 $this->assertFalse( IP::isIPAddress( '2001:0DB8::A:1::1' ), 'IPv6 with a double :: occurrence' );
  19                 $this->assertFalse( IP::isIPAddress( '2001:0DB8::A:1::' ), 'IPv6 with a double :: occurrence, last at end' );
  20                 $this->assertFalse( IP::isIPAddress( '::2001:0DB8::5:1' ), 'IPv6 with a double :: occurrence, firt at beginning' );
  21                 $this->assertFalse( IP::isIPAddress( '124.24.52' ), 'IPv4 not enough quads' );
  22                 $this->assertFalse( IP::isIPAddress( '24.324.52.13' ), 'IPv4 out of range' );
  23                 $this->assertFalse( IP::isIPAddress( '.24.52.13' ), 'IPv4 starts with period' );
  24                 $this->assertFalse( IP::isIPAddress( 'fc:100:300' ), 'IPv6 with only 3 words' );
  25
  26                 $this->assertTrue( IP::isIPAddress( '::' ), 'RFC 4291 IPv6 Unspecified Address' );
  27                 $this->assertTrue( IP::isIPAddress( '::1' ), 'RFC 4291 IPv6 Loopback Address' );
  28                 $this->assertTrue( IP::isIPAddress( '74.24.52.13/20', 'IPv4 range' ) );
  29                 $this->assertTrue( IP::isIPAddress( 'fc:100:a:d:1:e:ac:0/24' ), 'IPv6 range' );
  30                 $this->assertTrue( IP::isIPAddress( 'fc::100:a:d:1:e:ac/96' ), 'IPv6 range with "::"' );
  31
  32                 $validIPs = array( 'fc:100::', 'fc:100:a:d:1:e:ac::', 'fc::100', '::fc:100:a:d:1:e:ac',
  33                         '::fc', 'fc::100:a:d:1:e:ac', 'fc:100:a:d:1:e:ac:0', '124.24.52.13', '1.24.52.13' );
  34                 foreach ( $validIPs as $ip ) {
  35                         $this->assertTrue( IP::isIPAddress( $ip ), "$ip is a valid IP address" );
  36                 }
  37         }
  38
  39         /**
  40          * @covers IP::isIPv6
  41          */
  42         public function testisIPv6() {
  43                 $this->assertFalse( IP::isIPv6( ':fc:100::' ), 'IPv6 starting with lone ":"' );
  44                 $this->assertFalse( IP::isIPv6( 'fc:100:::' ), 'IPv6 ending with a ":::"' );
  45                 $this->assertFalse( IP::isIPv6( 'fc:300' ), 'IPv6 with only 2 words' );
  46                 $this->assertFalse( IP::isIPv6( 'fc:100:300' ), 'IPv6 with only 3 words' );
  47
  48                 $this->assertTrue( IP::isIPv6( 'fc:100::' ) );
  49                 $this->assertTrue( IP::isIPv6( 'fc:100:a::' ) );
  50                 $this->assertTrue( IP::isIPv6( 'fc:100:a:d::' ) );
  51                 $this->assertTrue( IP::isIPv6( 'fc:100:a:d:1::' ) );
  52                 $this->assertTrue( IP::isIPv6( 'fc:100:a:d:1:e::' ) );
  53                 $this->assertTrue( IP::isIPv6( 'fc:100:a:d:1:e:ac::' ) );
  54
  55                 $this->assertFalse( IP::isIPv6( 'fc:100:a:d:1:e:ac:0::' ), 'IPv6 with 8 words ending with "::"' );
  56                 $this->assertFalse( IP::isIPv6( 'fc:100:a:d:1:e:ac:0:1::' ), 'IPv6 with 9 words ending with "::"' );
  57
  58                 $this->assertFalse( IP::isIPv6( ':::' ) );
  59                 $this->assertFalse( IP::isIPv6( '::0:' ), 'IPv6 ending in a lone ":"' );
  60
  61                 $this->assertTrue( IP::isIPv6( '::' ), 'IPv6 zero address' );
  62                 $this->assertTrue( IP::isIPv6( '::0' ) );
  63                 $this->assertTrue( IP::isIPv6( '::fc' ) );
  64                 $this->assertTrue( IP::isIPv6( '::fc:100' ) );
  65                 $this->assertTrue( IP::isIPv6( '::fc:100:a' ) );
  66                 $this->assertTrue( IP::isIPv6( '::fc:100:a:d' ) );
  67                 $this->assertTrue( IP::isIPv6( '::fc:100:a:d:1' ) );
  68                 $this->assertTrue( IP::isIPv6( '::fc:100:a:d:1:e' ) );
  69                 $this->assertTrue( IP::isIPv6( '::fc:100:a:d:1:e:ac' ) );
  70
  71                 $this->assertFalse( IP::isIPv6( '::fc:100:a:d:1:e:ac:0' ), 'IPv6 with "::" and 8 words' );
  72                 $this->assertFalse( IP::isIPv6( '::fc:100:a:d:1:e:ac:0:1' ), 'IPv6 with 9 words' );
  73
  74                 $this->assertFalse( IP::isIPv6( ':fc::100' ), 'IPv6 starting with lone ":"' );
  75                 $this->assertFalse( IP::isIPv6( 'fc::100:' ), 'IPv6 ending with lone ":"' );
  76                 $this->assertFalse( IP::isIPv6( 'fc:::100' ), 'IPv6 with ":::" in the middle' );
  77
  78                 $this->assertTrue( IP::isIPv6( 'fc::100' ), 'IPv6 with "::" and 2 words' );
  79                 $this->assertTrue( IP::isIPv6( 'fc::100:a' ), 'IPv6 with "::" and 3 words' );
  80                 $this->assertTrue( IP::isIPv6( 'fc::100:a:d', 'IPv6 with "::" and 4 words' ) );
  81                 $this->assertTrue( IP::isIPv6( 'fc::100:a:d:1' ), 'IPv6 with "::" and 5 words' );
  82                 $this->assertTrue( IP::isIPv6( 'fc::100:a:d:1:e' ), 'IPv6 with "::" and 6 words' );
  83                 $this->assertTrue( IP::isIPv6( 'fc::100:a:d:1:e:ac' ), 'IPv6 with "::" and 7 words' );
  84                 $this->assertTrue( IP::isIPv6( '2001::df' ), 'IPv6 with "::" and 2 words' );
  85                 $this->assertTrue( IP::isIPv6( '2001:5c0:1400:a::df' ), 'IPv6 with "::" and 5 words' );
  86                 $this->assertTrue( IP::isIPv6( '2001:5c0:1400:a::df:2' ), 'IPv6 with "::" and 6 words' );
  87
  88                 $this->assertFalse( IP::isIPv6( 'fc::100:a:d:1:e:ac:0' ), 'IPv6 with "::" and 8 words' );
  89                 $this->assertFalse( IP::isIPv6( 'fc::100:a:d:1:e:ac:0:1' ), 'IPv6 with 9 words' );
  90
  91                 $this->assertTrue( IP::isIPv6( 'fc:100:a:d:1:e:ac:0' ) );
  92         }
  93
  94         /**
  95          * @covers IP::isIPv4
  96          */
  97         public function testisIPv4() {
  98                 $this->assertFalse( IP::isIPv4( false ), 'Boolean false is not an IP' );
  99                 $this->assertFalse( IP::isIPv4( true ), 'Boolean true is not an IP' );
 100                 $this->assertFalse( IP::isIPv4( "" ), 'Empty string is not an IP' );
 101                 $this->assertFalse( IP::isIPv4( 'abc' ) );
 102                 $this->assertFalse( IP::isIPv4( ':' ) );
 103                 $this->assertFalse( IP::isIPv4( '124.24.52' ), 'IPv4 not enough quads' );
 104                 $this->assertFalse( IP::isIPv4( '24.324.52.13' ), 'IPv4 out of range' );
 105                 $this->assertFalse( IP::isIPv4( '.24.52.13' ), 'IPv4 starts with period' );
 106
 107                 $this->assertTrue( IP::isIPv4( '124.24.52.13' ) );
 108                 $this->assertTrue( IP::isIPv4( '1.24.52.13' ) );
 109                 $this->assertTrue( IP::isIPv4( '74.24.52.13/20', 'IPv4 range' ) );
 110         }
 111
 112         /**
 113          * @covers IP::isValid
 114          */
 115         public function testValidIPs() {
 116                 foreach ( range( 0, 255 ) as $i ) {
 117                         $a = sprintf( "%03d", $i );
 118                         $b = sprintf( "%02d", $i );
 119                         $c = sprintf( "%01d", $i );
 120                         foreach ( array_unique( array( $a, $b, $c ) ) as $f ) {
 121                                 $ip = "$f.$f.$f.$f";
 122                                 $this->assertTrue( IP::isValid( $ip ), "$ip is a valid IPv4 address" );
 123                         }
 124                 }
 125                 foreach ( range( 0x0, 0xFFFF, 0xF ) as $i ) {
 126                         $a = sprintf( "%04x", $i );
 127                         $b = sprintf( "%03x", $i );
 128                         $c = sprintf( "%02x", $i );
 129                         foreach ( array_unique( array( $a, $b, $c ) ) as $f ) {
 130                                 $ip = "$f:$f:$f:$f:$f:$f:$f:$f";
 131                                 $this->assertTrue( IP::isValid( $ip ), "$ip is a valid IPv6 address" );
 132                         }
 133                 }
 134                 // test with some abbreviations
 135                 $this->assertFalse( IP::isValid( ':fc:100::' ), 'IPv6 starting with lone ":"' );
 136                 $this->assertFalse( IP::isValid( 'fc:100:::' ), 'IPv6 ending with a ":::"' );
 137                 $this->assertFalse( IP::isValid( 'fc:300' ), 'IPv6 with only 2 words' );
 138                 $this->assertFalse( IP::isValid( 'fc:100:300' ), 'IPv6 with only 3 words' );
 139
 140                 $this->assertTrue( IP::isValid( 'fc:100::' ) );
 141                 $this->assertTrue( IP::isValid( 'fc:100:a:d:1:e::' ) );
 142                 $this->assertTrue( IP::isValid( 'fc:100:a:d:1:e:ac::' ) );
 143
 144                 $this->assertTrue( IP::isValid( 'fc::100' ), 'IPv6 with "::" and 2 words' );
 145                 $this->assertTrue( IP::isValid( 'fc::100:a' ), 'IPv6 with "::" and 3 words' );
 146                 $this->assertTrue( IP::isValid( '2001::df' ), 'IPv6 with "::" and 2 words' );
 147                 $this->assertTrue( IP::isValid( '2001:5c0:1400:a::df' ), 'IPv6 with "::" and 5 words' );
 148                 $this->assertTrue( IP::isValid( '2001:5c0:1400:a::df:2' ), 'IPv6 with "::" and 6 words' );
 149                 $this->assertTrue( IP::isValid( 'fc::100:a:d:1' ), 'IPv6 with "::" and 5 words' );
 150                 $this->assertTrue( IP::isValid( 'fc::100:a:d:1:e:ac' ), 'IPv6 with "::" and 7 words' );
 151
 152                 $this->assertFalse( IP::isValid( 'fc:100:a:d:1:e:ac:0::' ), 'IPv6 with 8 words ending with "::"' );
 153                 $this->assertFalse( IP::isValid( 'fc:100:a:d:1:e:ac:0:1::' ), 'IPv6 with 9 words ending with "::"' );
 154         }
 155
 156         /**
 157          * @covers IP::isValid
 158          */
 159         public function testInvalidIPs() {
 160                 // Out of range...
 161                 foreach ( range( 256, 999 ) as $i ) {
 162                         $a = sprintf( "%03d", $i );
 163                         $b = sprintf( "%02d", $i );
 164                         $c = sprintf( "%01d", $i );
 165                         foreach ( array_unique( array( $a, $b, $c ) ) as $f ) {
 166                                 $ip = "$f.$f.$f.$f";
 167                                 $this->assertFalse( IP::isValid( $ip ), "$ip is not a valid IPv4 address" );
 168                         }
 169                 }
 170                 foreach ( range( 'g', 'z' ) as $i ) {
 171                         $a = sprintf( "%04s", $i );
 172                         $b = sprintf( "%03s", $i );
 173                         $c = sprintf( "%02s", $i );
 174                         foreach ( array_unique( array( $a, $b, $c ) ) as $f ) {
 175                                 $ip = "$f:$f:$f:$f:$f:$f:$f:$f";
 176                                 $this->assertFalse( IP::isValid( $ip ), "$ip is not a valid IPv6 address" );
 177                         }
 178                 }
 179                 // Have CIDR
 180                 $ipCIDRs = array(
 181                         '212.35.31.121/32',
 182                         '212.35.31.121/18',
 183                         '212.35.31.121/24',
 184                         '::ff:d:321:5/96',
 185                         'ff::d3:321:5/116',
 186                         'c:ff:12:1:ea:d:321:5/120',
 187                 );
 188                 foreach ( $ipCIDRs as $i ) {
 189                         $this->assertFalse( IP::isValid( $i ),
 190                                 "$i is an invalid IP address because it is a block" );
 191                 }
 192                 // Incomplete/garbage
 193                 $invalid = array(
 194                         'www.xn--var-xla.net',
 195                         '216.17.184.G',
 196                         '216.17.184.1.',
 197                         '216.17.184',
 198                         '216.17.184.',
 199                         '256.17.184.1'
 200                 );
 201                 foreach ( $invalid as $i ) {
 202                         $this->assertFalse( IP::isValid( $i ), "$i is an invalid IP address" );
 203                 }
 204         }
 205
 206         /**
 207          * @covers IP::isValidBlock
 208          */
 209         public function testValidBlocks() {
 210                 $valid = array(
 211                         '116.17.184.5/32',
 212                         '0.17.184.5/30',
 213                         '16.17.184.1/24',
 214                         '30.242.52.14/1',
 215                         '10.232.52.13/8',
 216                         '30.242.52.14/0',
 217                         '::e:f:2001/96',
 218                         '::c:f:2001/128',
 219                         '::10:f:2001/70',
 220                         '::fe:f:2001/1',
 221                         '::6d:f:2001/8',
 222                         '::fe:f:2001/0',
 223                 );
 224                 foreach ( $valid as $i ) {
 225                         $this->assertTrue( IP::isValidBlock( $i ), "$i is a valid IP block" );
 226                 }
 227         }
 228
 229         /**
 230          * @covers IP::isValidBlock
 231          */
 232         public function testInvalidBlocks() {
 233                 $invalid = array(
 234                         '116.17.184.5/33',
 235                         '0.17.184.5/130',
 236                         '16.17.184.1/-1',
 237                         '10.232.52.13/*',
 238                         '7.232.52.13/ab',
 239                         '11.232.52.13/',
 240                         '::e:f:2001/129',
 241                         '::c:f:2001/228',
 242                         '::10:f:2001/-1',
 243                         '::6d:f:2001/*',
 244                         '::86:f:2001/ab',
 245                         '::23:f:2001/',
 246                 );
 247                 foreach ( $invalid as $i ) {
 248                         $this->assertFalse( IP::isValidBlock( $i ), "$i is not a valid IP block" );
 249                 }
 250         }
 251
 252         /**
 253          * Improve IP::sanitizeIP() code coverage
 254          * @todo Most probably incomplete
 255          */
 256         public function testSanitizeIP() {
 257                 $this->assertNull( IP::sanitizeIP( '' ) );
 258                 $this->assertNull( IP::sanitizeIP( ' ' ) );
 259         }
 260
 261         /**
 262          * @covers IP::toUnsigned
 263          * @dataProvider provideToUnsigned
 264          */
 265         public function testToUnsigned( $expected, $input ) {
 266                 $result = IP::toUnsigned( $input );
 267                 $this->assertTrue( $result === false || is_string( $result ) || is_int( $result ) );
 268                 $this->assertEquals( $expected, $result );
 269         }
 270
 271         /**
 272          * Provider for IP::testToUnsigned()
 273          */
 274         public static function provideToUnsigned() {
 275                 return array(
 276                         array( 1, '0.0.0.1' ),
 277                         array( 16909060, '1.2.3.4' ),
 278                         array( 2130706433, '127.0.0.1' ),
 279                         array( '2147483648', '128.0.0.0' ),
 280                         array( '3735931646', '222.173.202.254' ),
 281                         array( pow( 2, 32 ) - 1, '255.255.255.255' ),
 282                         array( false, 'IN.VA.LI.D' ),
 283                         array( 1, '::1' ),
 284                         array( '42540766452641154071740215577757643572', '2001:0db8:85a3:0000:0000:8a2e:0370:7334' ),
 285                         array( '42540766452641154071740215577757643572', '2001:db8:85a3::8a2e:0370:7334' ),
 286                         array( false, 'IN:VA::LI:D' ),
 287                         array( false, ':::1' )
 288                 );
 289         }
 290
 291         /**
 292          * @covers IP::toHex
 293          * @dataProvider provideToHex
 294          */
 295         public function testToHex( $expected, $input ) {
 296                 $result = IP::toHex( $input );
 297                 $this->assertTrue( $result === false || is_string( $result ) );
 298                 $this->assertEquals( $expected, $result );
 299         }
 300
 301         /**
 302          * Provider for IP::testToHex()
 303          */
 304         public static function provideToHex() {
 305                 return array(
 306                         array( '00000001', '0.0.0.1' ),
 307                         array( '01020304', '1.2.3.4' ),
 308                         array( '7F000001', '127.0.0.1' ),
 309                         array( '80000000', '128.0.0.0' ),
 310                         array( 'DEADCAFE', '222.173.202.254' ),
 311                         array( 'FFFFFFFF', '255.255.255.255' ),
 312                         array( false, 'IN.VA.LI.D' ),
 313                         array( 'v6-00000000000000000000000000000001', '::1' ),
 314                         array( 'v6-20010DB885A3000000008A2E03707334', '2001:0db8:85a3:0000:0000:8a2e:0370:7334' ),
 315                         array( 'v6-20010DB885A3000000008A2E03707334', '2001:db8:85a3::8a2e:0370:7334' ),
 316                         array( false, 'IN:VA::LI:D' ),
 317                         array( false, ':::1' )
 318                 );
 319         }
 320
 321         /**
 322          * @covers IP::isPublic
 323          */
 324         public function testPrivateIPs() {
 325                 $private = array( 'fc00::3', 'fc00::ff', '::1', '10.0.0.1', '172.16.0.1', '192.168.0.1' );
 326                 foreach ( $private as $p ) {
 327                         $this->assertFalse( IP::isPublic( $p ), "$p is not a public IP address" );
 328                 }
 329                 $public = array( '2001:5c0:1000:a::133', 'fc::3', '00FC::' );
 330                 foreach ( $public as $p ) {
 331                         $this->assertTrue( IP::isPublic( $p ), "$p is a public IP address" );
 332                 }
 333         }
 334
 335         // Private wrapper used to test CIDR Parsing.
 336         private function assertFalseCIDR( $CIDR, $msg = '' ) {
 337                 $ff = array( false, false );
 338                 $this->assertEquals( $ff, IP::parseCIDR( $CIDR ), $msg );
 339         }
 340
 341         // Private wrapper to test network shifting using only dot notation
 342         private function assertNet( $expected, $CIDR ) {
 343                 $parse = IP::parseCIDR( $CIDR );
 344                 $this->assertEquals( $expected, long2ip( $parse[0] ), "network shifting $CIDR" );
 345         }
 346
 347         /**
 348          * @covers IP::hexToQuad
 349          */
 350         public function testHexToQuad() {
 351                 $this->assertEquals( '0.0.0.1', IP::hexToQuad( '00000001' ) );
 352                 $this->assertEquals( '255.0.0.0', IP::hexToQuad( 'FF000000' ) );
 353                 $this->assertEquals( '255.255.255.255', IP::hexToQuad( 'FFFFFFFF' ) );
 354                 $this->assertEquals( '10.188.222.255', IP::hexToQuad( '0ABCDEFF' ) );
 355                 // hex not left-padded...
 356                 $this->assertEquals( '0.0.0.0', IP::hexToQuad( '0' ) );
 357                 $this->assertEquals( '0.0.0.1', IP::hexToQuad( '1' ) );
 358                 $this->assertEquals( '0.0.0.255', IP::hexToQuad( 'FF' ) );
 359                 $this->assertEquals( '0.0.255.0', IP::hexToQuad( 'FF00' ) );
 360         }
 361
 362         /**
 363          * @covers IP::hexToOctet
 364          */
 365         public function testHexToOctet() {
 366                 $this->assertEquals( '0:0:0:0:0:0:0:1',
 367                         IP::hexToOctet( '00000000000000000000000000000001' ) );
 368                 $this->assertEquals( '0:0:0:0:0:0:FF:3',
 369                         IP::hexToOctet( '00000000000000000000000000FF0003' ) );
 370                 $this->assertEquals( '0:0:0:0:0:0:FF00:6',
 371                         IP::hexToOctet( '000000000000000000000000FF000006' ) );
 372                 $this->assertEquals( '0:0:0:0:0:0:FCCF:FAFF',
 373                         IP::hexToOctet( '000000000000000000000000FCCFFAFF' ) );
 374                 $this->assertEquals( 'FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF',
 375                         IP::hexToOctet( 'FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF' ) );
 376                 // hex not left-padded...
 377                 $this->assertEquals( '0:0:0:0:0:0:0:0', IP::hexToOctet( '0' ) );
 378                 $this->assertEquals( '0:0:0:0:0:0:0:1', IP::hexToOctet( '1' ) );
 379                 $this->assertEquals( '0:0:0:0:0:0:0:FF', IP::hexToOctet( 'FF' ) );
 380                 $this->assertEquals( '0:0:0:0:0:0:0:FFD0', IP::hexToOctet( 'FFD0' ) );
 381                 $this->assertEquals( '0:0:0:0:0:0:FA00:0', IP::hexToOctet( 'FA000000' ) );
 382                 $this->assertEquals( '0:0:0:0:0:0:FCCF:FAFF', IP::hexToOctet( 'FCCFFAFF' ) );
 383         }
 384
 385         /**
 386          * IP::parseCIDR() returns an array containing a signed IP address
 387          * representing the network mask and the bit mask.
 388          * @covers IP::parseCIDR
 389          */
 390         function testCIDRParsing() {
 391                 $this->assertFalseCIDR( '192.0.2.0', "missing mask" );
 392                 $this->assertFalseCIDR( '192.0.2.0/', "missing bitmask" );
 393
 394                 // Verify if statement
 395                 $this->assertFalseCIDR( '256.0.0.0/32', "invalid net" );
 396                 $this->assertFalseCIDR( '192.0.2.0/AA', "mask not numeric" );
 397                 $this->assertFalseCIDR( '192.0.2.0/-1', "mask < 0" );
 398                 $this->assertFalseCIDR( '192.0.2.0/33', "mask > 32" );
 399
 400                 // Check internal logic
 401                 # 0 mask always result in array(0,0)
 402                 $this->assertEquals( array( 0, 0 ), IP::parseCIDR( '192.0.0.2/0' ) );
 403                 $this->assertEquals( array( 0, 0 ), IP::parseCIDR( '0.0.0.0/0' ) );
 404                 $this->assertEquals( array( 0, 0 ), IP::parseCIDR( '255.255.255.255/0' ) );
 405
 406                 // @todo FIXME: Add more tests.
 407
 408                 # This part test network shifting
 409                 $this->assertNet( '192.0.0.0', '192.0.0.2/24' );
 410                 $this->assertNet( '192.168.5.0', '192.168.5.13/24' );
 411                 $this->assertNet( '10.0.0.160', '10.0.0.161/28' );
 412                 $this->assertNet( '10.0.0.0', '10.0.0.3/28' );
 413                 $this->assertNet( '10.0.0.0', '10.0.0.3/30' );
 414                 $this->assertNet( '10.0.0.4', '10.0.0.4/30' );
 415                 $this->assertNet( '172.17.32.0', '172.17.35.48/21' );
 416                 $this->assertNet( '10.128.0.0', '10.135.0.0/9' );
 417                 $this->assertNet( '134.0.0.0', '134.0.5.1/8' );
 418         }
 419
 420         /**
 421          * @covers IP::canonicalize
 422          */
 423         public function testIPCanonicalizeOnValidIp() {
 424                 $this->assertEquals( '192.0.2.152', IP::canonicalize( '192.0.2.152' ),
 425                         'Canonicalization of a valid IP returns it unchanged' );
 426         }
 427
 428         /**
 429          * @covers IP::canonicalize
 430          */
 431         public function testIPCanonicalizeMappedAddress() {
 432                 $this->assertEquals(
 433                         '192.0.2.152',
 434                         IP::canonicalize( '::ffff:192.0.2.152' )
 435                 );
 436                 $this->assertEquals(
 437                         '192.0.2.152',
 438                         IP::canonicalize( '::192.0.2.152' )
 439                 );
 440         }
 441
 442         /**
 443          * Issues there are most probably from IP::toHex() or IP::parseRange()
 444          * @covers IP::isInRange
 445          * @dataProvider provideIPsAndRanges
 446          */
 447         public function testIPIsInRange( $expected, $addr, $range, $message = '' ) {
 448                 $this->assertEquals(
 449                         $expected,
 450                         IP::isInRange( $addr, $range ),
 451                         $message
 452                 );
 453         }
 454
 455         /** Provider for testIPIsInRange() */
 456         public static function provideIPsAndRanges() {
 457                 # Format: (expected boolean, address, range, optional message)
 458                 return array(
 459                         # IPv4
 460                         array( true, '192.0.2.0', '192.0.2.0/24', 'Network address' ),
 461                         array( true, '192.0.2.77', '192.0.2.0/24', 'Simple address' ),
 462                         array( true, '192.0.2.255', '192.0.2.0/24', 'Broadcast address' ),
 463
 464                         array( false, '0.0.0.0', '192.0.2.0/24' ),
 465                         array( false, '255.255.255', '192.0.2.0/24' ),
 466
 467                         # IPv6
 468                         array( false, '::1', '2001:DB8::/32' ),
 469                         array( false, '::', '2001:DB8::/32' ),
 470                         array( false, 'FE80::1', '2001:DB8::/32' ),
 471
 472                         array( true, '2001:DB8::', '2001:DB8::/32' ),
 473                         array( true, '2001:0DB8::', '2001:DB8::/32' ),
 474                         array( true, '2001:DB8::1', '2001:DB8::/32' ),
 475                         array( true, '2001:0DB8::1', '2001:DB8::/32' ),
 476                         array( true, '2001:0DB8:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF',
 477                                 '2001:DB8::/32' ),
 478
 479                         array( false, '2001:0DB8:F::', '2001:DB8::/96' ),
 480                 );
 481         }
 482
 483         /**
 484          * Test for IP::splitHostAndPort().
 485          * @dataProvider provideSplitHostAndPort
 486          */
 487         function testSplitHostAndPort( $expected, $input, $description ) {
 488                 $this->assertEquals( $expected, IP::splitHostAndPort( $input ), $description );
 489         }
 490
 491         /**
 492          * Provider for IP::splitHostAndPort()
 493          */
 494         public static function provideSplitHostAndPort() {
 495                 return array(
 496                         array( false, '[', 'Unclosed square bracket' ),
 497                         array( false, '[::', 'Unclosed square bracket 2' ),
 498                         array( array( '::', false ), '::', 'Bare IPv6 0' ),
 499                         array( array( '::1', false ), '::1', 'Bare IPv6 1' ),
 500                         array( array( '::', false ), '[::]', 'Bracketed IPv6 0' ),
 501                         array( array( '::1', false ), '[::1]', 'Bracketed IPv6 1' ),
 502                         array( array( '::1', 80 ), '[::1]:80', 'Bracketed IPv6 with port' ),
 503                         array( false, '::x', 'Double colon but no IPv6' ),
 504                         array( array( 'x', 80 ), 'x:80', 'Hostname and port' ),
 505                         array( false, 'x:x', 'Hostname and invalid port' ),
 506                         array( array( 'x', false ), 'x', 'Plain hostname' )
 507                 );
 508         }
 509
 510         /**
 511          * Test for IP::combineHostAndPort()
 512          * @dataProvider provideCombineHostAndPort
 513          */
 514         function testCombineHostAndPort( $expected, $input, $description ) {
 515                 list( $host, $port, $defaultPort ) = $input;
 516                 $this->assertEquals(
 517                         $expected,
 518                         IP::combineHostAndPort( $host, $port, $defaultPort ),
 519                         $description );
 520         }
 521
 522         /**
 523          * Provider for IP::combineHostAndPort()
 524          */
 525         public static function provideCombineHostAndPort() {
 526                 return array(
 527                         array( '[::1]', array( '::1', 2, 2 ), 'IPv6 default port' ),
 528                         array( '[::1]:2', array( '::1', 2, 3 ), 'IPv6 non-default port' ),
 529                         array( 'x', array( 'x', 2, 2 ), 'Normal default port' ),
 530                         array( 'x:2', array( 'x', 2, 3 ), 'Normal non-default port' ),
 531                 );
 532         }
 533
 534         /**
 535          * Test for IP::sanitizeRange()
 536          * @dataProvider provideIPCIDRs
 537          */
 538         function testSanitizeRange( $input, $expected, $description ) {
 539                 $this->assertEquals( $expected, IP::sanitizeRange( $input ), $description );
 540         }
 541
 542         /**
 543          * Provider for IP::testSanitizeRange()
 544          */
 545         public static function provideIPCIDRs() {
 546                 return array(
 547                         array( '35.56.31.252/16', '35.56.0.0/16', 'IPv4 range' ),
 548                         array( '135.16.21.252/24', '135.16.21.0/24', 'IPv4 range' ),
 549                         array( '5.36.71.252/32', '5.36.71.252/32', 'IPv4 silly range' ),
 550                         array( '5.36.71.252', '5.36.71.252', 'IPv4 non-range' ),
 551                         array( '0:1:2:3:4:c5:f6:7/96', '0:1:2:3:4:C5:0:0/96', 'IPv6 range' ),
 552                         array( '0:1:2:3:4:5:6:7/120', '0:1:2:3:4:5:6:0/120', 'IPv6 range' ),
 553                         array( '0:e1:2:3:4:5:e6:7/128', '0:E1:2:3:4:5:E6:7/128', 'IPv6 silly range' ),
 554                         array( '0:c1:A2:3:4:5:c6:7', '0:C1:A2:3:4:5:C6:7', 'IPv6 non range' ),
 555                 );
 556         }
 557
 558         /**
 559          * Test for IP::prettifyIP()
 560          * @dataProvider provideIPsToPrettify
 561          */
 562         function testPrettifyIP( $ip, $prettified ) {
 563                 $this->assertEquals( $prettified, IP::prettifyIP( $ip ), "Prettify of $ip" );
 564         }
 565
 566         /**
 567          * Provider for IP::testPrettifyIP()
 568          */
 569         public static function provideIPsToPrettify() {
 570                 return array(
 571                         array( '0:0:0:0:0:0:0:0', '::' ),
 572                         array( '0:0:0::0:0:0', '::' ),
 573                         array( '0:0:0:1:0:0:0:0', '0:0:0:1::' ),
 574                         array( '0:0::f', '::f' ),
 575                         array( '0::0:0:0:33:fef:b', '::33:fef:b' ),
 576                         array( '3f:535:0:0:0:0:e:fbb', '3f:535::e:fbb' ),
 577                         array( '0:0:fef:0:0:0:e:fbb', '0:0:fef::e:fbb' ),
 578                         array( 'abbc:2004::0:0:0:0', 'abbc:2004::' ),
 579                         array( 'cebc:2004:f:0:0:0:0:0', 'cebc:2004:f::' ),
 580                         array( '0:0:0:0:0:0:0:0/16', '::/16' ),
 581                         array( '0:0:0::0:0:0/64', '::/64' ),
 582                         array( '0:0::f/52', '::f/52' ),
 583                         array( '::0:0:33:fef:b/52', '::33:fef:b/52' ),
 584                         array( '3f:535:0:0:0:0:e:fbb/48', '3f:535::e:fbb/48' ),
 585                         array( '0:0:fef:0:0:0:e:fbb/96', '0:0:fef::e:fbb/96' ),
 586                         array( 'abbc:2004:0:0::0:0/40', 'abbc:2004::/40' ),
 587                         array( 'aebc:2004:f:0:0:0:0:0/80', 'aebc:2004:f::/80' ),
 588                 );
 589         }
 590 }