3 * Tests for IP validity functions.
5 * Ported from /t/inc/IP.t by avar.
8 * @todo Test methods in this call should be split into a method and a
12 class IPTest
extends PHPUnit_Framework_TestCase
{
14 * @covers IP::isIPAddress
15 * @dataProvider provideInvalidIPs
17 public function isNotIPAddress( $val, $desc ) {
18 $this->assertFalse( IP
::isIPAddress( $val ), $desc );
22 * Provide a list of things that aren't IP addresses
24 public function provideInvalidIPs() {
26 array( false, 'Boolean false is not an IP' ),
27 array( true, 'Boolean true is not an IP' ),
28 array( '', 'Empty string is not an IP' ),
29 array( 'abc', 'Garbage IP string' ),
30 array( ':', 'Single ":" is not an IP' ),
31 array( '2001:0DB8::A:1::1', 'IPv6 with a double :: occurrence' ),
32 array( '2001:0DB8::A:1::', 'IPv6 with a double :: occurrence, last at end' ),
33 array( '::2001:0DB8::5:1', 'IPv6 with a double :: occurrence, firt at beginning' ),
34 array( '124.24.52', 'IPv4 not enough quads' ),
35 array( '24.324.52.13', 'IPv4 out of range' ),
36 array( '.24.52.13', 'IPv4 starts with period' ),
37 array( 'fc:100:300', 'IPv6 with only 3 words' ),
42 * @covers IP::isIPAddress
44 public function testisIPAddress() {
45 $this->assertTrue( IP
::isIPAddress( '::' ), 'RFC 4291 IPv6 Unspecified Address' );
46 $this->assertTrue( IP
::isIPAddress( '::1' ), 'RFC 4291 IPv6 Loopback Address' );
47 $this->assertTrue( IP
::isIPAddress( '74.24.52.13/20', 'IPv4 range' ) );
48 $this->assertTrue( IP
::isIPAddress( 'fc:100:a:d:1:e:ac:0/24' ), 'IPv6 range' );
49 $this->assertTrue( IP
::isIPAddress( 'fc::100:a:d:1:e:ac/96' ), 'IPv6 range with "::"' );
51 $validIPs = array( 'fc:100::', 'fc:100:a:d:1:e:ac::', 'fc::100', '::fc:100:a:d:1:e:ac',
52 '::fc', 'fc::100:a:d:1:e:ac', 'fc:100:a:d:1:e:ac:0', '124.24.52.13', '1.24.52.13' );
53 foreach ( $validIPs as $ip ) {
54 $this->assertTrue( IP
::isIPAddress( $ip ), "$ip is a valid IP address" );
61 public function testisIPv6() {
62 $this->assertFalse( IP
::isIPv6( ':fc:100::' ), 'IPv6 starting with lone ":"' );
63 $this->assertFalse( IP
::isIPv6( 'fc:100:::' ), 'IPv6 ending with a ":::"' );
64 $this->assertFalse( IP
::isIPv6( 'fc:300' ), 'IPv6 with only 2 words' );
65 $this->assertFalse( IP
::isIPv6( 'fc:100:300' ), 'IPv6 with only 3 words' );
67 $this->assertTrue( IP
::isIPv6( 'fc:100::' ) );
68 $this->assertTrue( IP
::isIPv6( 'fc:100:a::' ) );
69 $this->assertTrue( IP
::isIPv6( 'fc:100:a:d::' ) );
70 $this->assertTrue( IP
::isIPv6( 'fc:100:a:d:1::' ) );
71 $this->assertTrue( IP
::isIPv6( 'fc:100:a:d:1:e::' ) );
72 $this->assertTrue( IP
::isIPv6( 'fc:100:a:d:1:e:ac::' ) );
74 $this->assertFalse( IP
::isIPv6( 'fc:100:a:d:1:e:ac:0::' ), 'IPv6 with 8 words ending with "::"' );
76 IP
::isIPv6( 'fc:100:a:d:1:e:ac:0:1::' ),
77 'IPv6 with 9 words ending with "::"'
80 $this->assertFalse( IP
::isIPv6( ':::' ) );
81 $this->assertFalse( IP
::isIPv6( '::0:' ), 'IPv6 ending in a lone ":"' );
83 $this->assertTrue( IP
::isIPv6( '::' ), 'IPv6 zero address' );
84 $this->assertTrue( IP
::isIPv6( '::0' ) );
85 $this->assertTrue( IP
::isIPv6( '::fc' ) );
86 $this->assertTrue( IP
::isIPv6( '::fc:100' ) );
87 $this->assertTrue( IP
::isIPv6( '::fc:100:a' ) );
88 $this->assertTrue( IP
::isIPv6( '::fc:100:a:d' ) );
89 $this->assertTrue( IP
::isIPv6( '::fc:100:a:d:1' ) );
90 $this->assertTrue( IP
::isIPv6( '::fc:100:a:d:1:e' ) );
91 $this->assertTrue( IP
::isIPv6( '::fc:100:a:d:1:e:ac' ) );
93 $this->assertFalse( IP
::isIPv6( '::fc:100:a:d:1:e:ac:0' ), 'IPv6 with "::" and 8 words' );
94 $this->assertFalse( IP
::isIPv6( '::fc:100:a:d:1:e:ac:0:1' ), 'IPv6 with 9 words' );
96 $this->assertFalse( IP
::isIPv6( ':fc::100' ), 'IPv6 starting with lone ":"' );
97 $this->assertFalse( IP
::isIPv6( 'fc::100:' ), 'IPv6 ending with lone ":"' );
98 $this->assertFalse( IP
::isIPv6( 'fc:::100' ), 'IPv6 with ":::" in the middle' );
100 $this->assertTrue( IP
::isIPv6( 'fc::100' ), 'IPv6 with "::" and 2 words' );
101 $this->assertTrue( IP
::isIPv6( 'fc::100:a' ), 'IPv6 with "::" and 3 words' );
102 $this->assertTrue( IP
::isIPv6( 'fc::100:a:d', 'IPv6 with "::" and 4 words' ) );
103 $this->assertTrue( IP
::isIPv6( 'fc::100:a:d:1' ), 'IPv6 with "::" and 5 words' );
104 $this->assertTrue( IP
::isIPv6( 'fc::100:a:d:1:e' ), 'IPv6 with "::" and 6 words' );
105 $this->assertTrue( IP
::isIPv6( 'fc::100:a:d:1:e:ac' ), 'IPv6 with "::" and 7 words' );
106 $this->assertTrue( IP
::isIPv6( '2001::df' ), 'IPv6 with "::" and 2 words' );
107 $this->assertTrue( IP
::isIPv6( '2001:5c0:1400:a::df' ), 'IPv6 with "::" and 5 words' );
108 $this->assertTrue( IP
::isIPv6( '2001:5c0:1400:a::df:2' ), 'IPv6 with "::" and 6 words' );
110 $this->assertFalse( IP
::isIPv6( 'fc::100:a:d:1:e:ac:0' ), 'IPv6 with "::" and 8 words' );
111 $this->assertFalse( IP
::isIPv6( 'fc::100:a:d:1:e:ac:0:1' ), 'IPv6 with 9 words' );
113 $this->assertTrue( IP
::isIPv6( 'fc:100:a:d:1:e:ac:0' ) );
118 * @dataProvider provideInvalidIPv4Addresses
120 public function testisNotIPv4( $bogusIP, $desc ) {
121 $this->assertFalse( IP
::isIPv4( $bogusIP ), $desc );
124 public function provideInvalidIPv4Addresses() {
126 array( false, 'Boolean false is not an IP' ),
127 array( true, 'Boolean true is not an IP' ),
128 array( '', 'Empty string is not an IP' ),
129 array( 'abc', 'Letters are not an IP' ),
130 array( ':', 'A colon is not an IP' ),
131 array( '124.24.52', 'IPv4 not enough quads' ),
132 array( '24.324.52.13', 'IPv4 out of range' ),
133 array( '.24.52.13', 'IPv4 starts with period' ),
139 * @dataProvider provideValidIPv4Address
141 public function testIsIPv4( $ip, $desc ) {
142 $this->assertTrue( IP
::isIPv4( $ip ), $desc );
146 * Provide some IPv4 addresses and ranges
148 public function provideValidIPv4Address() {
150 array( '124.24.52.13', 'Valid IPv4 address' ),
151 array( '1.24.52.13', 'Another valid IPv4 address' ),
152 array( '74.24.52.13/20', 'An IPv4 range' ),
157 * @covers IP::isValid
159 public function testValidIPs() {
160 foreach ( range( 0, 255 ) as $i ) {
161 $a = sprintf( "%03d", $i );
162 $b = sprintf( "%02d", $i );
163 $c = sprintf( "%01d", $i );
164 foreach ( array_unique( array( $a, $b, $c ) ) as $f ) {
166 $this->assertTrue( IP
::isValid( $ip ), "$ip is a valid IPv4 address" );
169 foreach ( range( 0x0, 0xFFFF, 0xF ) as $i ) {
170 $a = sprintf( "%04x", $i );
171 $b = sprintf( "%03x", $i );
172 $c = sprintf( "%02x", $i );
173 foreach ( array_unique( array( $a, $b, $c ) ) as $f ) {
174 $ip = "$f:$f:$f:$f:$f:$f:$f:$f";
175 $this->assertTrue( IP
::isValid( $ip ), "$ip is a valid IPv6 address" );
178 // test with some abbreviations
179 $this->assertFalse( IP
::isValid( ':fc:100::' ), 'IPv6 starting with lone ":"' );
180 $this->assertFalse( IP
::isValid( 'fc:100:::' ), 'IPv6 ending with a ":::"' );
181 $this->assertFalse( IP
::isValid( 'fc:300' ), 'IPv6 with only 2 words' );
182 $this->assertFalse( IP
::isValid( 'fc:100:300' ), 'IPv6 with only 3 words' );
184 $this->assertTrue( IP
::isValid( 'fc:100::' ) );
185 $this->assertTrue( IP
::isValid( 'fc:100:a:d:1:e::' ) );
186 $this->assertTrue( IP
::isValid( 'fc:100:a:d:1:e:ac::' ) );
188 $this->assertTrue( IP
::isValid( 'fc::100' ), 'IPv6 with "::" and 2 words' );
189 $this->assertTrue( IP
::isValid( 'fc::100:a' ), 'IPv6 with "::" and 3 words' );
190 $this->assertTrue( IP
::isValid( '2001::df' ), 'IPv6 with "::" and 2 words' );
191 $this->assertTrue( IP
::isValid( '2001:5c0:1400:a::df' ), 'IPv6 with "::" and 5 words' );
192 $this->assertTrue( IP
::isValid( '2001:5c0:1400:a::df:2' ), 'IPv6 with "::" and 6 words' );
193 $this->assertTrue( IP
::isValid( 'fc::100:a:d:1' ), 'IPv6 with "::" and 5 words' );
194 $this->assertTrue( IP
::isValid( 'fc::100:a:d:1:e:ac' ), 'IPv6 with "::" and 7 words' );
197 IP
::isValid( 'fc:100:a:d:1:e:ac:0::' ),
198 'IPv6 with 8 words ending with "::"'
201 IP
::isValid( 'fc:100:a:d:1:e:ac:0:1::' ),
202 'IPv6 with 9 words ending with "::"'
207 * @covers IP::isValid
209 public function testInvalidIPs() {
211 foreach ( range( 256, 999 ) as $i ) {
212 $a = sprintf( "%03d", $i );
213 $b = sprintf( "%02d", $i );
214 $c = sprintf( "%01d", $i );
215 foreach ( array_unique( array( $a, $b, $c ) ) as $f ) {
217 $this->assertFalse( IP
::isValid( $ip ), "$ip is not a valid IPv4 address" );
220 foreach ( range( 'g', 'z' ) as $i ) {
221 $a = sprintf( "%04s", $i );
222 $b = sprintf( "%03s", $i );
223 $c = sprintf( "%02s", $i );
224 foreach ( array_unique( array( $a, $b, $c ) ) as $f ) {
225 $ip = "$f:$f:$f:$f:$f:$f:$f:$f";
226 $this->assertFalse( IP
::isValid( $ip ), "$ip is not a valid IPv6 address" );
236 'c:ff:12:1:ea:d:321:5/120',
238 foreach ( $ipCIDRs as $i ) {
239 $this->assertFalse( IP
::isValid( $i ),
240 "$i is an invalid IP address because it is a block" );
242 // Incomplete/garbage
244 'www.xn--var-xla.net',
251 foreach ( $invalid as $i ) {
252 $this->assertFalse( IP
::isValid( $i ), "$i is an invalid IP address" );
257 * Provide some valid IP blocks
259 public function provideValidBlocks() {
261 array( '116.17.184.5/32' ),
262 array( '0.17.184.5/30' ),
263 array( '16.17.184.1/24' ),
264 array( '30.242.52.14/1' ),
265 array( '10.232.52.13/8' ),
266 array( '30.242.52.14/0' ),
267 array( '::e:f:2001/96' ),
268 array( '::c:f:2001/128' ),
269 array( '::10:f:2001/70' ),
270 array( '::fe:f:2001/1' ),
271 array( '::6d:f:2001/8' ),
272 array( '::fe:f:2001/0' ),
277 * @covers IP::isValidBlock
278 * @dataProvider provideValidBlocks
280 public function testValidBlocks( $block ) {
281 $this->assertTrue( IP
::isValidBlock( $block ), "$block is a valid IP block" );
285 * @covers IP::isValidBlock
286 * @dataProvider provideInvalidBlocks
288 public function testInvalidBlocks( $invalid ) {
289 $this->assertFalse( IP
::isValidBlock( $invalid ), "$invalid is not a valid IP block" );
292 public function provideInvalidBlocks() {
294 array( '116.17.184.5/33' ),
295 array( '0.17.184.5/130' ),
296 array( '16.17.184.1/-1' ),
297 array( '10.232.52.13/*' ),
298 array( '7.232.52.13/ab' ),
299 array( '11.232.52.13/' ),
300 array( '::e:f:2001/129' ),
301 array( '::c:f:2001/228' ),
302 array( '::10:f:2001/-1' ),
303 array( '::6d:f:2001/*' ),
304 array( '::86:f:2001/ab' ),
305 array( '::23:f:2001/' ),
310 * Improve IP::sanitizeIP() code coverage
311 * @todo Most probably incomplete
313 public function testSanitizeIP() {
314 $this->assertNull( IP
::sanitizeIP( '' ) );
315 $this->assertNull( IP
::sanitizeIP( ' ' ) );
320 * @dataProvider provideToHex
322 public function testToHex( $expected, $input ) {
323 $result = IP
::toHex( $input );
324 $this->assertTrue( $result === false ||
is_string( $result ) );
325 $this->assertEquals( $expected, $result );
329 * Provider for IP::testToHex()
331 public static function provideToHex() {
333 array( '00000001', '0.0.0.1' ),
334 array( '01020304', '1.2.3.4' ),
335 array( '7F000001', '127.0.0.1' ),
336 array( '80000000', '128.0.0.0' ),
337 array( 'DEADCAFE', '222.173.202.254' ),
338 array( 'FFFFFFFF', '255.255.255.255' ),
339 array( false, 'IN.VA.LI.D' ),
340 array( 'v6-00000000000000000000000000000001', '::1' ),
341 array( 'v6-20010DB885A3000000008A2E03707334', '2001:0db8:85a3:0000:0000:8a2e:0370:7334' ),
342 array( 'v6-20010DB885A3000000008A2E03707334', '2001:db8:85a3::8a2e:0370:7334' ),
343 array( false, 'IN:VA::LI:D' ),
344 array( false, ':::1' )
349 * @covers IP::isPublic
351 public function testPrivateIPs() {
352 $private = array( 'fc00::3', 'fc00::ff', '::1', '10.0.0.1', '172.16.0.1', '192.168.0.1' );
353 foreach ( $private as $p ) {
354 $this->assertFalse( IP
::isPublic( $p ), "$p is not a public IP address" );
356 $public = array( '2001:5c0:1000:a::133', 'fc::3', '00FC::' );
357 foreach ( $public as $p ) {
358 $this->assertTrue( IP
::isPublic( $p ), "$p is a public IP address" );
362 // Private wrapper used to test CIDR Parsing.
363 private function assertFalseCIDR( $CIDR, $msg = '' ) {
364 $ff = array( false, false );
365 $this->assertEquals( $ff, IP
::parseCIDR( $CIDR ), $msg );
368 // Private wrapper to test network shifting using only dot notation
369 private function assertNet( $expected, $CIDR ) {
370 $parse = IP
::parseCIDR( $CIDR );
371 $this->assertEquals( $expected, long2ip( $parse[0] ), "network shifting $CIDR" );
375 * @covers IP::hexToQuad
376 * @dataProvider provideIPsAndHexes
378 public function testHexToQuad( $ip, $hex ) {
379 $this->assertEquals( $ip, IP
::hexToQuad( $hex ) );
383 * Provide some IP addresses and their equivalent hex representations
385 public function provideIPsandHexes() {
387 array( '0.0.0.1', '00000001' ),
388 array( '255.0.0.0', 'FF000000' ),
389 array( '255.255.255.255', 'FFFFFFFF' ),
390 array( '10.188.222.255', '0ABCDEFF' ),
391 // hex not left-padded...
392 array( '0.0.0.0', '0' ),
393 array( '0.0.0.1', '1' ),
394 array( '0.0.0.255', 'FF' ),
395 array( '0.0.255.0', 'FF00' ),
400 * @covers IP::hexToOctet
401 * @dataProvider provideOctetsAndHexes
403 public function testHexToOctet( $octet, $hex ) {
404 $this->assertEquals( $octet, IP
::hexToOctet( $hex ) );
408 * Provide some hex and octet representations of the same IPs
410 public function provideOctetsAndHexes() {
412 array( '0:0:0:0:0:0:0:1', '00000000000000000000000000000001' ),
413 array( '0:0:0:0:0:0:FF:3', '00000000000000000000000000FF0003' ),
414 array( '0:0:0:0:0:0:FF00:6', '000000000000000000000000FF000006' ),
415 array( '0:0:0:0:0:0:FCCF:FAFF', '000000000000000000000000FCCFFAFF' ),
416 array( 'FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF', 'FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF' ),
417 // hex not left-padded...
418 array( '0:0:0:0:0:0:0:0', '0' ),
419 array( '0:0:0:0:0:0:0:1', '1' ),
420 array( '0:0:0:0:0:0:0:FF', 'FF' ),
421 array( '0:0:0:0:0:0:0:FFD0', 'FFD0' ),
422 array( '0:0:0:0:0:0:FA00:0', 'FA000000' ),
423 array( '0:0:0:0:0:0:FCCF:FAFF', 'FCCFFAFF' ),
428 * IP::parseCIDR() returns an array containing a signed IP address
429 * representing the network mask and the bit mask.
430 * @covers IP::parseCIDR
432 public function testCIDRParsing() {
433 $this->assertFalseCIDR( '192.0.2.0', "missing mask" );
434 $this->assertFalseCIDR( '192.0.2.0/', "missing bitmask" );
436 // Verify if statement
437 $this->assertFalseCIDR( '256.0.0.0/32', "invalid net" );
438 $this->assertFalseCIDR( '192.0.2.0/AA', "mask not numeric" );
439 $this->assertFalseCIDR( '192.0.2.0/-1', "mask < 0" );
440 $this->assertFalseCIDR( '192.0.2.0/33', "mask > 32" );
442 // Check internal logic
443 # 0 mask always result in array(0,0)
444 $this->assertEquals( array( 0, 0 ), IP
::parseCIDR( '192.0.0.2/0' ) );
445 $this->assertEquals( array( 0, 0 ), IP
::parseCIDR( '0.0.0.0/0' ) );
446 $this->assertEquals( array( 0, 0 ), IP
::parseCIDR( '255.255.255.255/0' ) );
448 // @todo FIXME: Add more tests.
450 # This part test network shifting
451 $this->assertNet( '192.0.0.0', '192.0.0.2/24' );
452 $this->assertNet( '192.168.5.0', '192.168.5.13/24' );
453 $this->assertNet( '10.0.0.160', '10.0.0.161/28' );
454 $this->assertNet( '10.0.0.0', '10.0.0.3/28' );
455 $this->assertNet( '10.0.0.0', '10.0.0.3/30' );
456 $this->assertNet( '10.0.0.4', '10.0.0.4/30' );
457 $this->assertNet( '172.17.32.0', '172.17.35.48/21' );
458 $this->assertNet( '10.128.0.0', '10.135.0.0/9' );
459 $this->assertNet( '134.0.0.0', '134.0.5.1/8' );
463 * @covers IP::canonicalize
465 public function testIPCanonicalizeOnValidIp() {
466 $this->assertEquals( '192.0.2.152', IP
::canonicalize( '192.0.2.152' ),
467 'Canonicalization of a valid IP returns it unchanged' );
471 * @covers IP::canonicalize
473 public function testIPCanonicalizeMappedAddress() {
476 IP
::canonicalize( '::ffff:192.0.2.152' )
480 IP
::canonicalize( '::192.0.2.152' )
485 * Issues there are most probably from IP::toHex() or IP::parseRange()
486 * @covers IP::isInRange
487 * @dataProvider provideIPsAndRanges
489 public function testIPIsInRange( $expected, $addr, $range, $message = '' ) {
492 IP
::isInRange( $addr, $range ),
497 /** Provider for testIPIsInRange() */
498 public static function provideIPsAndRanges() {
499 # Format: (expected boolean, address, range, optional message)
502 array( true, '192.0.2.0', '192.0.2.0/24', 'Network address' ),
503 array( true, '192.0.2.77', '192.0.2.0/24', 'Simple address' ),
504 array( true, '192.0.2.255', '192.0.2.0/24', 'Broadcast address' ),
506 array( false, '0.0.0.0', '192.0.2.0/24' ),
507 array( false, '255.255.255', '192.0.2.0/24' ),
510 array( false, '::1', '2001:DB8::/32' ),
511 array( false, '::', '2001:DB8::/32' ),
512 array( false, 'FE80::1', '2001:DB8::/32' ),
514 array( true, '2001:DB8::', '2001:DB8::/32' ),
515 array( true, '2001:0DB8::', '2001:DB8::/32' ),
516 array( true, '2001:DB8::1', '2001:DB8::/32' ),
517 array( true, '2001:0DB8::1', '2001:DB8::/32' ),
518 array( true, '2001:0DB8:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF',
521 array( false, '2001:0DB8:F::', '2001:DB8::/96' ),
526 * Test for IP::splitHostAndPort().
527 * @dataProvider provideSplitHostAndPort
529 public function testSplitHostAndPort( $expected, $input, $description ) {
530 $this->assertEquals( $expected, IP
::splitHostAndPort( $input ), $description );
534 * Provider for IP::splitHostAndPort()
536 public static function provideSplitHostAndPort() {
538 array( false, '[', 'Unclosed square bracket' ),
539 array( false, '[::', 'Unclosed square bracket 2' ),
540 array( array( '::', false ), '::', 'Bare IPv6 0' ),
541 array( array( '::1', false ), '::1', 'Bare IPv6 1' ),
542 array( array( '::', false ), '[::]', 'Bracketed IPv6 0' ),
543 array( array( '::1', false ), '[::1]', 'Bracketed IPv6 1' ),
544 array( array( '::1', 80 ), '[::1]:80', 'Bracketed IPv6 with port' ),
545 array( false, '::x', 'Double colon but no IPv6' ),
546 array( array( 'x', 80 ), 'x:80', 'Hostname and port' ),
547 array( false, 'x:x', 'Hostname and invalid port' ),
548 array( array( 'x', false ), 'x', 'Plain hostname' )
553 * Test for IP::combineHostAndPort()
554 * @dataProvider provideCombineHostAndPort
556 public function testCombineHostAndPort( $expected, $input, $description ) {
557 list( $host, $port, $defaultPort ) = $input;
560 IP
::combineHostAndPort( $host, $port, $defaultPort ),
565 * Provider for IP::combineHostAndPort()
567 public static function provideCombineHostAndPort() {
569 array( '[::1]', array( '::1', 2, 2 ), 'IPv6 default port' ),
570 array( '[::1]:2', array( '::1', 2, 3 ), 'IPv6 non-default port' ),
571 array( 'x', array( 'x', 2, 2 ), 'Normal default port' ),
572 array( 'x:2', array( 'x', 2, 3 ), 'Normal non-default port' ),
577 * Test for IP::sanitizeRange()
578 * @dataProvider provideIPCIDRs
580 public function testSanitizeRange( $input, $expected, $description ) {
581 $this->assertEquals( $expected, IP
::sanitizeRange( $input ), $description );
585 * Provider for IP::testSanitizeRange()
587 public static function provideIPCIDRs() {
589 array( '35.56.31.252/16', '35.56.0.0/16', 'IPv4 range' ),
590 array( '135.16.21.252/24', '135.16.21.0/24', 'IPv4 range' ),
591 array( '5.36.71.252/32', '5.36.71.252/32', 'IPv4 silly range' ),
592 array( '5.36.71.252', '5.36.71.252', 'IPv4 non-range' ),
593 array( '0:1:2:3:4:c5:f6:7/96', '0:1:2:3:4:C5:0:0/96', 'IPv6 range' ),
594 array( '0:1:2:3:4:5:6:7/120', '0:1:2:3:4:5:6:0/120', 'IPv6 range' ),
595 array( '0:e1:2:3:4:5:e6:7/128', '0:E1:2:3:4:5:E6:7/128', 'IPv6 silly range' ),
596 array( '0:c1:A2:3:4:5:c6:7', '0:C1:A2:3:4:5:C6:7', 'IPv6 non range' ),
601 * Test for IP::prettifyIP()
602 * @dataProvider provideIPsToPrettify
604 public function testPrettifyIP( $ip, $prettified ) {
605 $this->assertEquals( $prettified, IP
::prettifyIP( $ip ), "Prettify of $ip" );
609 * Provider for IP::testPrettifyIP()
611 public static function provideIPsToPrettify() {
613 array( '0:0:0:0:0:0:0:0', '::' ),
614 array( '0:0:0::0:0:0', '::' ),
615 array( '0:0:0:1:0:0:0:0', '0:0:0:1::' ),
616 array( '0:0::f', '::f' ),
617 array( '0::0:0:0:33:fef:b', '::33:fef:b' ),
618 array( '3f:535:0:0:0:0:e:fbb', '3f:535::e:fbb' ),
619 array( '0:0:fef:0:0:0:e:fbb', '0:0:fef::e:fbb' ),
620 array( 'abbc:2004::0:0:0:0', 'abbc:2004::' ),
621 array( 'cebc:2004:f:0:0:0:0:0', 'cebc:2004:f::' ),
622 array( '0:0:0:0:0:0:0:0/16', '::/16' ),
623 array( '0:0:0::0:0:0/64', '::/64' ),
624 array( '0:0::f/52', '::f/52' ),
625 array( '::0:0:33:fef:b/52', '::33:fef:b/52' ),
626 array( '3f:535:0:0:0:0:e:fbb/48', '3f:535::e:fbb/48' ),
627 array( '0:0:fef:0:0:0:e:fbb/96', '0:0:fef::e:fbb/96' ),
628 array( 'abbc:2004:0:0::0:0/40', 'abbc:2004::/40' ),
629 array( 'aebc:2004:f:0:0:0:0:0/80', 'aebc:2004:f::/80' ),