mcs/class/System/Test/System.Net/IPAddressTest.cs

   1 //
   2 // IPAddressTest.cs - NUnit Test Cases for System.Net.IPAddress
   3 //
   4 // Authors:
   5 //   Gonzalo Paniagua Javier (gonzalo@ximian.com)
   6 //   Martin Willemoes Hansen (mwh@sysrq.dk)
   7 //
   8 // (C) Ximian, Inc. http://www.ximian.com
   9 // (C) 2003 Martin Willemoes Hansen
  10 // Copyright (C) 2005 Novell, Inc (http://www.novell.com)
  11 //
  12
  13 using NUnit.Framework;
  14 using System;
  15 using System.Net;
  16 using System.Net.Sockets;
  17 using System.Runtime.InteropServices;
  18
  19 namespace MonoTests.System.Net
  20 {
  21
  22 [TestFixture]
  23 public class IPAddressTest
  24 {
  25         static string[] ipv6AddressList = new string[] {
  26                    "::", "0:0:0:0:0:0:0:0",
  27                    "1::", "1:0:0:0:0:0:0:0",
  28                    "2:2::", "2:2:0:0:0:0:0:0",
  29                    "7:7:7:7:7:7:7:0", "7:7:7:7:7:7:7:0",
  30                    "::1", "0:0:0:0:0:0:0:1",
  31                    "0:7:7:7:7:7:7:7", "0:7:7:7:7:7:7:7",
  32                    "E::1", "E:0:0:0:0:0:0:1",
  33                    "E::2:2", "E:0:0:0:0:0:2:2",
  34                    "E:0:6:6:6:6:6:6", "E:0:6:6:6:6:6:6",
  35                    "E:E::1", "E:E:0:0:0:0:0:1",
  36                    "E:E::2:2", "E:E:0:0:0:0:2:2",
  37                    "E:E:0:5:5:5:5:5", "E:E:0:5:5:5:5:5",
  38                    "E:E:E::1", "E:E:E:0:0:0:0:1",
  39                    "E:E:E::2:2", "E:E:E:0:0:0:2:2",
  40                    "E:E:E:0:4:4:4:4", "E:E:E:0:4:4:4:4",
  41                    "E:E:E:E::1", "E:E:E:E:0:0:0:1",
  42                    "E:E:E:E::2:2", "E:E:E:E:0:0:2:2",
  43                    "E:E:E:E:0:3:3:3", "E:E:E:E:0:3:3:3",
  44                    "E:E:E:E:E::1", "E:E:E:E:E:0:0:1",
  45                    "E:E:E:E:E:0:2:2", "E:E:E:E:E:0:2:2",
  46                    "E:E:E:E:E:E:0:1", "E:E:E:E:E:E:0:1",
  47                    "::0.2.0.2", "0:0:0:0:0:0:2:2",
  48                    "::FFFF:192.168.0.1", "::FFFF:192.168.0.1",
  49                    "::FFFF:0.168.0.1", "::FFFF:0.168.0.1",
  50                    "::FFFF", "::0.0.255.255",
  51                    "::10.0.0.1", "::10.0.0.1",
  52                    "1234::1234:0:0", "1234:0:0:0:0:1234:0:0",
  53                    "1:0:1:0:1:0:1:0", "1:0:1:0:1:0:1:0",
  54                    "1:1:1::1:1:0", "1:1:1:0:0:1:1:0",
  55                    "::1234:0:0", "0:0:0:0:0:1234:0:0",
  56                    "3ffe:38e1::100:1:1", "3ffe:38e1::0100:1:0001",
  57                    "0:0:1:2::", "0:0:1:2:00:00:000:0000",
  58                    "100:0:1:2::abcd", "100:0:1:2:0:0:000:abcd",
  59                    "ffff::abcd", "ffff:0:0:0:0:0:00:abcd",
  60                    "ffff:0:0:2::abcd", "ffff:0:0:2:0:0:00:abcd",
  61                    "0:0:1:2::", "0:0:1:2:0:00:0000:0000",
  62                    "::1:0:0", "0000:0000::1:0000:0000",
  63                    "::111:234:5:6:789a:0", "0:0:111:234:5:6:789A:0",
  64                    "11:22:33:44:55:66:77:8", "11:22:33:44:55:66:77:8",
  65                    "0:0:7711:ab42:1230::", "::7711:ab42:1230:0:0:0",
  66                    "fec0:0:0:ffff::1%1",
  67         };
  68
  69         static string[] ipv4ParseOk = new string[] {
  70                 "192.168.1.1", "192.168.1.1",
  71                 "0xff.0x7f.0x20.0x01", "255.127.32.1",
  72                 "0xff.0x7f.0x20.0xf", "255.127.32.15",
  73                 "0.0.0.0", IPAddress.Any.ToString(),
  74                 "255.255.255.255", IPAddress.Broadcast.ToString(),
  75 #if ONLY_1_1
  76                 "12.1.1.3 ", "12.1.1.3",
  77                 "12.1 foo.1.2.3.4.5.bar", "12.0.0.1",
  78                 "12.1.4.6 foo.bar.test.test.bag", "12.1.4.6",
  79                 "12.6 foo.1.2.3.4.5.", "12.0.0.6",
  80                 "12.1.1.3 g", "12.1.1.3",
  81                 " ", "0.0.0.0",
  82                 "", "0.0.0.0",
  83 #endif
  84                 "12.1.1.3 abc", "12.1.1.3",
  85                 "12.1 .1.2", "12.0.0.1",
  86                 "12.1 .zzzz.2", "12.0.0.1",
  87                 "12.1.7", "12.1.0.7",
  88                 "12", "0.0.0.12",
  89                 "12.5.3 foo.67.test.test.7FFFFFFFFFfaFFF789FFFFFFFFFFFFFFF", "12.5.0.3",
  90                 "12.1 foo.bar.test.test.baf", "12.0.0.1",
  91                 "12.1.4.6 foo.bar.test.test.baf", "12.1.4.6",
  92                 "12.3 foo.bar.test.test.4", "12.0.0.3",
  93                 "12 foo.bar.test.test.baf", "0.0.0.12",
  94                 //"65536", "0.1.0.0",
  95                 //"65535", "0.0.255.255",
  96                 //"20.65535", "20.0.255.255"
  97         };
  98
  99         static string [] ipv4ParseWrong = new string [] {
 100                 " foo",
 101                 "12.. .",
 102                 "12.1.2. ",
 103                 "12.1.8. ",
 104                 ".1.1.6",
 105                 " 12.1.1.1",
 106                 "12.+1.1.4",
 107                 "12.1.-1.5",
 108                 "257.1.1.9",
 109 #if NET_2_0
 110                 "12.1.1.3 ",
 111                 "12.1 foo.1.2.3.4.5.bar",
 112                 "12.1 foo.1.2.3.4.5.",
 113                 "12.1.1.3 g",
 114                 " ",
 115                 "",
 116 #endif
 117                 "12.1.foo.1.2.3.4.5.bar",
 118                 "12.",
 119                 "12.1.2.",
 120                 "12...",
 121                 "  "
 122         };
 123
 124         [Test]
 125         public void PublicFields ()
 126         {
 127                 Assert.AreEqual ((long) 0, IPAddress.Any.Address, "#1");
 128                 Assert.AreEqual ((long) 0xFFFFFFFF, IPAddress.Broadcast.Address, "#2");
 129                 long loopback = IPAddress.HostToNetworkOrder (BitConverter.IsLittleEndian ?
 130                                                               0x7f000001 :
 131                                                               0x0100007f);
 132                 Assert.AreEqual (loopback, IPAddress.Loopback.Address, "#3");
 133                 Assert.AreEqual ((long) 0xFFFFFFFF, IPAddress.None.Address, "#4");
 134         }
 135
 136         [Test]
 137         public void ToStringV4 ()
 138         {
 139                 IPAddress ip = IPAddress.Parse ("192.168.1.1");
 140                 Assert.AreEqual ("192.168.1.1", ip.ToString (), "#1");
 141                 Assert.AreEqual ("0.0.0.0", IPAddress.Any.ToString (), "#2");
 142                 Assert.AreEqual ("255.255.255.255", IPAddress.Broadcast.ToString (), "#3");
 143                 Assert.AreEqual ("127.0.0.1", IPAddress.Loopback.ToString (), "#4");
 144                 Assert.AreEqual ("255.255.255.255", IPAddress.None.ToString (), "#5");
 145         }
 146
 147 #if NET_1_1
 148         [Test]
 149         public void ToStringV6 ()
 150         {
 151                 if (!Socket.SupportsIPv6)
 152                         Assert.Ignore ("IPv6 must be enabled in machine.config");
 153
 154                 for(int i=0; i<ipv6AddressList.Length/2; i++) {
 155                         string addr = IPAddress.Parse (ipv6AddressList[i*2+1]).ToString().ToLower();
 156                         Assert.AreEqual (ipv6AddressList[i*2].ToLower(), addr, "ToStringIPv6 #" + i);
 157                 }
 158         }
 159 #endif
 160
 161         [Test]
 162         public void IsLoopbackV4 ()
 163         {
 164                 IPAddress ip;
 165
 166                 ip = IPAddress.Parse ("127.0.0.1");
 167                 Assert.IsTrue (IPAddress.IsLoopback (ip), "#1");
 168                 ip = IPAddress.Any;
 169                 Assert.IsFalse (IPAddress.IsLoopback (ip), "#2");
 170                 ip = IPAddress.Loopback;
 171                 Assert.IsTrue (IPAddress.IsLoopback (ip), "#3");
 172                 ip = IPAddress.Parse ("::101");
 173                 Assert.IsFalse (IPAddress.IsLoopback (ip), "#4");
 174         }
 175
 176 #if NET_1_1
 177         [Test]
 178         public void IsLoopbackV6 ()
 179         {
 180                 if (!Socket.SupportsIPv6)
 181                         Assert.Ignore ("IPv6 must be enabled in machine.config");
 182
 183                 IPAddress ip = IPAddress.IPv6Loopback;
 184                 Assert.IsTrue (IPAddress.IsLoopback (ip), "#1");
 185
 186                 ip = IPAddress.IPv6None;
 187                 Assert.IsFalse (IPAddress.IsLoopback (ip), "#2");
 188         }
 189
 190         [Test]
 191         public void GetAddressBytesV4 ()
 192         {
 193                 byte[] dataIn   = { 10, 11, 12, 13 };
 194                 byte[] dataOut  = IPAddress.Parse ("10.11.12.13").GetAddressBytes ();
 195                 for (int i = 0; i < dataIn.Length; i++)
 196                         Assert.AreEqual (dataOut [i], dataIn [i], "GetAddressBytesV4");
 197         }
 198
 199         [Test]
 200         public void GetAddressBytesV6 ()
 201         {
 202                 if (!Socket.SupportsIPv6)
 203                         Assert.Ignore ("IPv6 must be enabled in machine.config");
 204
 205                 byte[] dataIn   = new byte[]{ 0x01, 0x23, 0x45, 0x67, 0x89, 0x98, 0x76, 0x54, 0x32, 0x10, 0x01, 0x23, 0x45, 0x67, 0x89, 0x98 };
 206                 byte[] dataOut  = IPAddress.Parse ("123:4567:8998:7654:3210:0123:4567:8998").GetAddressBytes ();
 207                 for (int i = 0; i < dataIn.Length; i++)
 208                         Assert.AreEqual (dataOut [i], dataIn [i], "GetAddressBytesV6 #1");
 209
 210                 dataIn  = new byte[]{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x7F, 0x00, 0x00, 0x01 };
 211                 dataOut = IPAddress.Parse ("::FFFF:127.0.0.1").GetAddressBytes ();
 212                 for (int i = 0; i < dataIn.Length; i++)
 213                         Assert.AreEqual (dataOut [i], dataIn [i], "GetAddressBytesV6 #2");
 214         }
 215 #endif
 216
 217         [Test]
 218         public void Address ()
 219         {
 220                 // hm, lame, anything is accepted by ms.net
 221                 /*
 222                 try {
 223                         IPAddress ip1 = new IPAddress (0x0000000100000000);
 224                         Assertion.Fail ("#1");
 225                 } catch (ArgumentOutOfRangeException) {}
 226                 IPAddress ip = IPAddress.Parse ("127.0.0.1");
 227                 ip.Address = 0;
 228                 ip.Address = 0xffffffff;
 229                 try {
 230                         ip.Address = -1;
 231                         Assertion.Fail ("#2");
 232                 } catch (ArgumentOutOfRangeException) {}
 233                 try {
 234                         ip.Address = 0x0000000100000000;
 235                         Assertion.Fail ("#3");
 236                 } catch (ArgumentOutOfRangeException) {}
 237                 */
 238         }
 239
 240         [Test]
 241         public void ParseOkV4 ()
 242         {
 243                 for (int i = 0; i < ipv4ParseOk.Length / 2; i++) {
 244                         IPAddress ip;
 245                         try {
 246                                 ip = IPAddress.Parse (ipv4ParseOk [i*2]);
 247                                 Assert.AreEqual (ipv4ParseOk [i * 2 + 1], ip.ToString (), "ParseOkV4:" + i);
 248                         } catch (FormatException) {
 249                                 Assert.Fail ("Cannot parse test i=" + i + ": '" + ipv4ParseOk [i*2] + "'");
 250                         }
 251                 }
 252         }
 253
 254 #if NET_1_1
 255         [Test]
 256         public void ParseOkV6 ()
 257         {
 258                 if (!Socket.SupportsIPv6)
 259                         Assert.Ignore ("IPv6 must be enabled in machine.config");
 260
 261                 for (int i = 0; i < ipv6AddressList.Length / 2; i++) {
 262                         string source = ipv6AddressList [i*2].ToLower();
 263
 264                         IPAddress ip = IPAddress.Parse (source);
 265                         Assert.IsTrue (ip.ToString ().ToLower () == source,
 266                                 string.Format("ParseIPv6 #{0}-1: {1} != {2}", i,
 267                                         ip.ToString ().ToLower (), source));
 268
 269                         ip = IPAddress.Parse (ipv6AddressList [i*2+1].ToLower ());
 270                         Assert.IsTrue (ip.ToString ().ToLower () == source,
 271                                 string.Format("ParseIPv6 #{0}-2: {1} != {2}", i,
 272                                         ip.ToString ().ToLower (), source));
 273                 }
 274         }
 275 #endif
 276
 277         [Test]
 278         public void ParseWrongV4 ()
 279         {
 280                 for (int i = 0; i < ipv4ParseWrong.Length; i++) {
 281                         string ipAddress = ipv4ParseWrong [i];
 282
 283                         try {
 284                                 IPAddress ip = IPAddress.Parse (ipAddress);
 285                                 Assert.Fail ("#1:" + i + " (" + ipAddress + ")");
 286                         } catch (FormatException ex) {
 287                                 Assert.AreEqual (typeof (FormatException), ex.GetType (), "#2:" + i);
 288                                 Assert.IsNull (ex.InnerException, "#3:" + i);
 289                                 Assert.IsNotNull (ex.Message, "#4:" + i);
 290                         }
 291                 }
 292         }
 293
 294         [Test]
 295         public void Parse_IpString_Null ()
 296         {
 297                 try {
 298                         IPAddress.Parse ((string) null);
 299                         Assert.Fail ("#1");
 300                 } catch (ArgumentNullException ex) {
 301                         Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 302                         Assert.IsNull (ex.InnerException, "#3");
 303                         Assert.IsNotNull (ex.Message, "#4");
 304                         Assert.AreEqual ("ipString", ex.ParamName, "#5");
 305                 }
 306         }
 307
 308         [Test]
 309         public void NetworkHost ()
 310         {
 311                 long [] tested = new long [] { 0, 1, 1, 1};
 312                 long [] expectedLE = new long [] {0, 256, 16777216, 72057594037927936 };
 313                 long [] expected;
 314
 315                 expected = BitConverter.IsLittleEndian ? expectedLE : tested;
 316
 317                 short short0 = IPAddress.NetworkToHostOrder ((short) tested [0]);
 318                 Assert.AreEqual ((short) expected [0], short0, "#A1");
 319                 short0 = IPAddress.HostToNetworkOrder (short0);
 320                 Assert.AreEqual ((short) tested [0], short0, "#A2");
 321
 322                 int int0 = IPAddress.NetworkToHostOrder ((int) tested [0]);
 323                 Assert.AreEqual ((int) expected [0], int0, "#B1");
 324                 int0 = IPAddress.HostToNetworkOrder (int0);
 325                 Assert.AreEqual ((int) tested [0], int0, "#B2");
 326
 327                 long long0 = IPAddress.NetworkToHostOrder (tested [0]);
 328                 Assert.AreEqual (expected [0], long0, "#C1");
 329                 long0 = IPAddress.HostToNetworkOrder (long0);
 330                 Assert.AreEqual (tested [0], long0, "#C2");
 331
 332                 short0 = IPAddress.NetworkToHostOrder ((short) tested [1]);
 333                 Assert.AreEqual ((short) expected [1], short0, "#D1");
 334                 short0 = IPAddress.HostToNetworkOrder (short0);
 335                 Assert.AreEqual ((short) tested [1], short0, "#D2");
 336
 337                 int0 = IPAddress.NetworkToHostOrder ((int) tested [2]);
 338                 Assert.AreEqual ((int) expected [2], int0, "#E1");
 339                 int0 = IPAddress.HostToNetworkOrder (int0);
 340                 Assert.AreEqual ((int) tested [2], int0, "#E2");
 341
 342                 long0 = IPAddress.NetworkToHostOrder (tested [3]);
 343                 Assert.AreEqual (expected [3], long0, "#F1");
 344                 long0 = IPAddress.HostToNetworkOrder (long0);
 345                 Assert.AreEqual (tested [3], long0, "#F2");
 346         }
 347
 348         [Test]
 349         public void LoopbackIPv6 ()
 350         {
 351                 Assert.IsTrue (new Uri("http://[0:0:0:0::127.0.0.1]/").IsLoopback, "#1");
 352                 Assert.IsFalse (new Uri ("http://[0:0:0:0::127.1.2.3]/").IsLoopback, "#2");
 353                 Assert.IsTrue (new Uri ("http://[0:0:0:0::0.0.0.1]/").IsLoopback, "#3");
 354         }
 355
 356         [Test] // bug #76792
 357         public void Constructor0_Address_4Byte ()
 358         {
 359                 byte[] bytes = new byte[4] { 192, 202, 112, 37 };
 360 #if NET_2_0
 361                 IPAddress i = new IPAddress (bytes);
 362                 Assert.AreEqual (bytes, i.GetAddressBytes (), "#1");
 363                 Assert.AreEqual ("192.202.112.37", i.ToString (), "#2");
 364 #else
 365                 try {
 366                         new IPAddress (bytes);
 367                         Assert.Fail ("#1");
 368                 } catch (ArgumentException ex) {
 369                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 370                         Assert.IsNotNull (ex.Message, "#3");
 371                         Assert.AreEqual ("address", ex.Message, "#4");
 372                         Assert.IsNull (ex.ParamName, "#5");
 373                         Assert.IsNull (ex.InnerException, "#6");
 374                 }
 375 #endif
 376         }
 377
 378         [Test]
 379 #if TARGET_JVM
 380         [Ignore ("TD BUG ID: 7213")]
 381 #endif
 382         public void Constructor0_Address_Invalid ()
 383         {
 384                 try {
 385                         new IPAddress (new byte [0]);
 386                         Assert.Fail ("#A1");
 387                 } catch (ArgumentException ex) {
 388                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
 389                         Assert.IsNull (ex.InnerException, "#A3");
 390                         Assert.IsNotNull (ex.Message, "#A4");
 391 #if NET_2_0
 392                         Assert.IsFalse (ex.Message == "address", ex.Message, "#A5");
 393                         Assert.IsNotNull (ex.ParamName, "#A6");
 394                         Assert.AreEqual ("address", ex.ParamName, "#A7");
 395 #else
 396                         Assert.AreEqual ("address", ex.Message, "#A5");
 397                         Assert.IsNull (ex.ParamName, "#A6");
 398 #endif
 399                 }
 400
 401                 try {
 402                         new IPAddress (new byte [3] { 192, 202, 112 });
 403                         Assert.Fail ("#B1");
 404                 } catch (ArgumentException ex) {
 405                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
 406                         Assert.IsNull (ex.InnerException, "#B3");
 407                         Assert.IsNotNull (ex.Message, "#B4");
 408 #if NET_2_0
 409                         Assert.IsFalse (ex.Message == "address", ex.Message, "#B5");
 410                         Assert.IsNotNull (ex.ParamName, "#B6");
 411                         Assert.AreEqual ("address", ex.ParamName, "#B7");
 412 #else
 413                         Assert.AreEqual ("address", ex.Message, "#B5");
 414                         Assert.IsNull (ex.ParamName, "#B6");
 415 #endif
 416                 }
 417
 418                 try {
 419                         new IPAddress (new byte [5] { 192, 202, 112, 142, 25 });
 420                         Assert.Fail ("#C1");
 421                 } catch (ArgumentException ex) {
 422                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
 423                         Assert.IsNull (ex.InnerException, "#C3");
 424                         Assert.IsNotNull (ex.Message, "#C4");
 425 #if NET_2_0
 426                         Assert.IsFalse (ex.Message == "address", "#C5");
 427                         Assert.IsNotNull (ex.ParamName, "#C6");
 428                         Assert.AreEqual ("address", ex.ParamName, "#C7");
 429 #else
 430                         Assert.AreEqual ("address", ex.Message, "#C5");
 431                         Assert.IsNull (ex.ParamName, "#C6");
 432 #endif
 433                 }
 434         }
 435
 436         [Test]
 437         public void Constructor0_Address_Null ()
 438         {
 439                 try {
 440                         new IPAddress ((byte []) null);
 441                         Assert.Fail ("#1");
 442                 } catch (ArgumentNullException ex) {
 443                         Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 444                         Assert.IsNull (ex.InnerException, "#3");
 445                         Assert.IsNotNull (ex.Message, "#4");
 446                         Assert.AreEqual ("address", ex.ParamName, "#5");
 447                 }
 448         }
 449
 450         [Test]
 451 #if TARGET_JVM
 452         [Ignore ("TD BUG ID: 7213")]
 453 #endif
 454         public void Constructor1_Address_4Byte ()
 455         {
 456                 byte [] bytes = new byte [4] { 192, 202, 112, 37 };
 457                 try {
 458                         new IPAddress (bytes, 0);
 459                         Assert.Fail ("#1");
 460                 } catch (ArgumentException ex) {
 461                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 462                         Assert.IsNull (ex.InnerException, "#3");
 463                         Assert.IsNotNull (ex.Message, "#4");
 464 #if NET_2_0
 465                         Assert.IsFalse (ex.Message == "address", "#5");
 466                         Assert.IsNotNull (ex.ParamName, "#6");
 467                         Assert.AreEqual ("address", ex.ParamName, "#7");
 468 #else
 469                         Assert.AreEqual ("address", ex.Message, "#5");
 470                         Assert.IsNull (ex.ParamName, "#6");
 471 #endif
 472                 }
 473         }
 474
 475         [Test]
 476         public void Constructor1_Address_Null ()
 477         {
 478                 try {
 479                         new IPAddress ((byte []) null, 5);
 480                         Assert.Fail ("#1");
 481                 } catch (ArgumentNullException ex) {
 482                         Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 483                         Assert.IsNull (ex.InnerException, "#3");
 484                         Assert.IsNotNull (ex.Message, "#4");
 485                         Assert.AreEqual ("address", ex.ParamName, "#5");
 486                 }
 487         }
 488
 489 #if NET_2_0
 490         [Test]
 491         public void TryParse_IpString_Null ()
 492         {
 493                 IPAddress i;
 494
 495                 try {
 496                         IPAddress.TryParse ((string) null, out i);
 497                         Assert.Fail ("#1");
 498                 } catch (ArgumentNullException ex) {
 499                         Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 500                         Assert.IsNull (ex.InnerException, "#3");
 501                         Assert.IsNotNull (ex.Message, "#4");
 502                         Assert.AreEqual ("ipString", ex.ParamName, "#5");
 503                 }
 504         }
 505
 506         [Test]
 507         public void TryParse ()
 508         {
 509                 IPAddress i;
 510                 Assert.IsTrue (IPAddress.TryParse ("0.0.0.0", out i), "#1");
 511                 Assert.IsTrue (IPAddress.TryParse ("127.0.0.1", out i), "#2");
 512                 Assert.IsFalse (IPAddress.TryParse ("www.mono-project.com", out i), "#3");
 513                 Assert.IsTrue (IPAddress.TryParse ("0001:0002:0003:0004:0005:0006:0007:0008", out i), "#4");
 514                 Assert.IsTrue (IPAddress.TryParse ("1:2:3:4:5:6:7:8", out i), "#5");
 515                 Assert.IsTrue (IPAddress.TryParse ("1::8", out i), "#6");
 516                 Assert.IsTrue (IPAddress.TryParse ("1::3:4:5:6:7:8", out i), "#7");
 517                 Assert.IsFalse (IPAddress.TryParse ("1::2:3:4:5::6:7:8", out i), "#8"); // :: ::
 518                 Assert.IsFalse (IPAddress.TryParse ("1::2:3:4:5:6:7:8", out i), "#9");
 519                 Assert.IsFalse (IPAddress.TryParse ("1;2:3:4:5:6:7:8", out i), "#10"); // ;
 520                 // FIXME:
 521                 // Assert.IsFalse (IPAddress.TryParse ("1:2:3:4:5:6:7:8/10", out i), "#11"); // subnet
 522         }
 523
 524         [Test]
 525         public void TryParseOkV4 ()
 526         {
 527                 for (int i = 0; i < ipv4ParseOk.Length / 2; i++) {
 528                         IPAddress ip;
 529                         Assert.IsTrue (IPAddress.TryParse (ipv4ParseOk [i * 2], out ip), "#1:" + i);
 530                         Assert.AreEqual (ipv4ParseOk [i * 2 + 1], ip.ToString (), "#2:" + i);
 531                 }
 532         }
 533
 534         [Test]
 535         public void TryParseWrongV4 ()
 536         {
 537                 for (int i = 0; i < ipv4ParseWrong.Length; i++) {
 538                         IPAddress ip;
 539                         string ipAddress = ipv4ParseWrong [i];
 540
 541                         Assert.IsFalse (IPAddress.TryParse (ipAddress, out ip), "#1:" + i);
 542                         Assert.IsNull (ip, "#2:" + i);
 543                 }
 544         }
 545
 546         [Test]
 547         public void IsIPv6LinkLocal ()
 548         {
 549                 Assert.IsTrue (IPAddress.Parse ("FE80::1").IsIPv6LinkLocal, "#1");
 550                 Assert.IsTrue (IPAddress.Parse ("FE81::1").IsIPv6LinkLocal, "#2");
 551                 Assert.IsFalse (IPAddress.Parse ("FD81::1").IsIPv6LinkLocal, "#3");
 552                 Assert.IsFalse (IPAddress.Parse ("FF80::1").IsIPv6LinkLocal, "#4");
 553                 Assert.IsTrue (IPAddress.Parse ("FE91::1").IsIPv6LinkLocal, "#5");
 554                 Assert.IsTrue (IPAddress.Parse ("FEA0::1").IsIPv6LinkLocal, "#6");
 555                 Assert.IsFalse (IPAddress.Parse ("FEC0::1").IsIPv6LinkLocal, "#7");
 556         }
 557
 558         [Test]
 559         public void IsIPv6SiteLocal ()
 560         {
 561                 Assert.IsTrue (IPAddress.Parse ("FEC0::1").IsIPv6SiteLocal, "#1");
 562                 Assert.IsTrue (IPAddress.Parse ("FEC1::1").IsIPv6SiteLocal, "#2");
 563                 Assert.IsFalse (IPAddress.Parse ("FE81::1").IsIPv6SiteLocal, "#3");
 564                 Assert.IsFalse (IPAddress.Parse ("FFC0::1").IsIPv6SiteLocal, "#4");
 565                 Assert.IsTrue (IPAddress.Parse ("FED1::1").IsIPv6SiteLocal, "#5");
 566                 Assert.IsTrue (IPAddress.Parse ("FEE1::1").IsIPv6SiteLocal, "#6");
 567         }
 568
 569         [Test]
 570         public void IsIPv6Multicast ()
 571         {
 572                 Assert.IsTrue (IPAddress.Parse ("FF00::1").IsIPv6Multicast, "#1");
 573                 Assert.IsTrue (IPAddress.Parse ("FF01::1").IsIPv6Multicast, "#2");
 574                 Assert.IsFalse (IPAddress.Parse ("FE00::1").IsIPv6Multicast, "#3");
 575         }
 576 #endif
 577 }
 578 }
 579