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