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

   1 // DnsTest.cs - NUnit Test Cases for the System.Net.Dns class\r
   2 //\r
   3 // Authors: \r
   4 //   Mads Pultz (mpultz@diku.dk)\r
   5 //   Martin Willemoes Hansen (mwh@sysrq.dk)\r
   6 //\r
   7 // (C) 2001 Mads Pultz\r
   8 // (C) 2003 Martin Willemoes Hansen\r
   9 // \r
  10 \r
  11 using System;\r
  12 using System.Linq;\r
  13 using System.Net;\r
  14 using System.Net.Sockets;\r
  15 using System.Threading;\r
  16 \r
  17 using NUnit.Framework;\r
  18 \r
  19 namespace MonoTests.System.Net\r
  20 {\r
  21         [TestFixture]\r
  22         public class DnsTest\r
  23         {\r
  24                 private String site1Name = "google-public-dns-a.google.com",\r
  25                         site1Dot = "8.8.8.8",\r
  26                         site2Name = "google-public-dns-b.google.com",\r
  27                         site2Dot = "8.8.4.4",\r
  28                         noneExistingSite = "unlikely.xamarin.com";\r
  29                 private uint site1IP = 134744072, site2IP = 134743044; // Big-Endian\r
  30 \r
  31                 [Test]\r
  32 #if FEATURE_NO_BSD_SOCKETS\r
  33                 [ExpectedException (typeof (PlatformNotSupportedException))]\r
  34 #endif\r
  35                 public void AsyncGetHostByName ()\r
  36                 {\r
  37                         IAsyncResult async = Dns.BeginGetHostByName (site1Name, null, null);\r
  38                         IPHostEntry entry = Dns.EndGetHostByName (async);\r
  39                         SubTestValidIPHostEntry (entry);\r
  40                         Assert.AreEqual ("google-public-dns-a.google.com", entry.HostName, "#1");\r
  41                 }\r
  42 \r
  43                 [Test]\r
  44 #if FEATURE_NO_BSD_SOCKETS\r
  45                 [ExpectedException (typeof (PlatformNotSupportedException))]\r
  46 #endif\r
  47                 public void AsyncGetHostByNameCallback ()\r
  48                 {\r
  49                         var evt = new ManualResetEvent (false);\r
  50                         Exception ex = null;\r
  51                         Dns.BeginGetHostByName (site1Name, new AsyncCallback ((IAsyncResult ar) =>\r
  52                         {\r
  53                                 try {\r
  54                                         IPHostEntry h;\r
  55                                         h = Dns.EndGetHostByName (ar);\r
  56                                         SubTestValidIPHostEntry (h);\r
  57                                 } catch (Exception e) {\r
  58                                         ex = e;\r
  59                                 } finally {\r
  60                                         evt.Set ();\r
  61                                 }\r
  62                         }), null);\r
  63 \r
  64                         Assert.IsTrue (evt.WaitOne (TimeSpan.FromSeconds (60)), "Wait");\r
  65                         Assert.IsNull (ex, "Exception");\r
  66                 }\r
  67 \r
  68                 [Test]\r
  69 #if FEATURE_NO_BSD_SOCKETS\r
  70                 [ExpectedException (typeof (PlatformNotSupportedException))]\r
  71 #endif\r
  72                 public void AsyncResolve ()\r
  73                 {\r
  74                         IAsyncResult async = Dns.BeginResolve (site1Dot, null, null);\r
  75                         IPHostEntry entry = Dns.EndResolve (async);\r
  76                         SubTestValidIPHostEntry (entry);\r
  77                         var ip = GetIPv4Address (entry);\r
  78                         Assert.AreEqual (site1Dot, ip.ToString ());\r
  79                 }\r
  80 \r
  81                 [Test]\r
  82 #if FEATURE_NO_BSD_SOCKETS\r
  83                 [ExpectedException (typeof (PlatformNotSupportedException))]\r
  84 #endif\r
  85                 public void AsyncResolveCallback ()\r
  86                 {\r
  87                         var evt = new ManualResetEvent (false);\r
  88                         Exception ex = null;\r
  89                         Dns.BeginResolve (site1Name, new AsyncCallback ((IAsyncResult ar) =>\r
  90                         {\r
  91                                 try {\r
  92                                         IPHostEntry h = Dns.EndResolve (ar);\r
  93                                         SubTestValidIPHostEntry (h);\r
  94                                 } catch (Exception e) {\r
  95                                         ex = e;\r
  96                                 } finally {\r
  97                                         evt.Set ();\r
  98                                 }\r
  99                         }), null);\r
 100 \r
 101                         Assert.IsTrue (evt.WaitOne (TimeSpan.FromSeconds (60)), "Wait");\r
 102                         Assert.IsNull (ex, "Exception");\r
 103                 }\r
 104 \r
 105                 [Test]\r
 106                 public void BeginGetHostAddresses_HostNameOrAddress_Null ()\r
 107                 {\r
 108                         try {\r
 109                                 Dns.BeginGetHostAddresses (\r
 110                                         (string) null,\r
 111                                         new AsyncCallback (ShouldntBeCalled),\r
 112                                         null);\r
 113                                 Assert.Fail ("#1");\r
 114                         } catch (ArgumentNullException ex) {\r
 115                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");\r
 116                                 Assert.IsNull (ex.InnerException, "#3");\r
 117                                 Assert.IsNotNull (ex.Message, "#4");\r
 118                                 Assert.AreEqual ("hostName", ex.ParamName, "#5");\r
 119                         }\r
 120                 }\r
 121 \r
 122                 [Test]\r
 123                 public void BeginGetHostAddresses_HostNameOrAddress_UnspecifiedAddress ()\r
 124                 {\r
 125                         // IPv4\r
 126                         try {\r
 127                                 Dns.BeginGetHostAddresses (\r
 128                                         "0.0.0.0",\r
 129                                         new AsyncCallback (ShouldntBeCalled),\r
 130                                         null);\r
 131                                 Assert.Fail ("#A1");\r
 132                         } catch (ArgumentException ex) {\r
 133                                 // IPv4 address 0.0.0.0 and IPv6 address ::0 are\r
 134                                 // unspecified addresses that cannot be used as\r
 135                                 // a target address\r
 136                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");\r
 137                                 Assert.IsNull (ex.InnerException, "#A3");\r
 138                                 Assert.IsNotNull (ex.Message, "#A4");\r
 139                                 Assert.AreEqual ("hostNameOrAddress", ex.ParamName, "#A5");\r
 140                         }\r
 141 \r
 142                         // IPv6\r
 143                         try {\r
 144                                 Dns.BeginGetHostAddresses (\r
 145                                         "::0",\r
 146                                         new AsyncCallback (ShouldntBeCalled),\r
 147                                         null);\r
 148                                 Assert.Fail ("#B1");\r
 149                         } catch (ArgumentException ex) {\r
 150                                 // IPv4 address 0.0.0.0 and IPv6 address ::0 are\r
 151                                 // unspecified addresses that cannot be used as\r
 152                                 // a target address\r
 153                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");\r
 154                                 Assert.IsNull (ex.InnerException, "#B3");\r
 155                                 Assert.IsNotNull (ex.Message, "#B4");\r
 156                                 Assert.AreEqual ("hostNameOrAddress", ex.ParamName, "#B5");\r
 157                         }\r
 158                 }\r
 159 \r
 160                 void ShouldntBeCalled (IAsyncResult ar)\r
 161                 {\r
 162                         Assert.Fail ("Should not be called");\r
 163                 }\r
 164 \r
 165                 [Test]\r
 166                 public void GetHostAddresses_HostNameOrAddress_Null ()\r
 167                 {\r
 168                         try {\r
 169                                 Dns.GetHostAddresses ((string) null);\r
 170                                 Assert.Fail ("#1");\r
 171                         } catch (ArgumentNullException ex) {\r
 172                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");\r
 173                                 Assert.IsNull (ex.InnerException, "#3");\r
 174                                 Assert.IsNotNull (ex.Message, "#4");\r
 175                                 Assert.AreEqual ("hostNameOrAddress", ex.ParamName, "#5");\r
 176                         }\r
 177                 }\r
 178 \r
 179                 [Test]\r
 180                 public void GetHostAddresses_HostNameOrAddress_UnspecifiedAddress ()\r
 181                 {\r
 182                         // IPv4\r
 183                         try {\r
 184                                 Dns.GetHostAddresses ("0.0.0.0");\r
 185                                 Assert.Fail ("#A1");\r
 186                         } catch (ArgumentException ex) {\r
 187                                 // IPv4 address 0.0.0.0 and IPv6 address ::0 are\r
 188                                 // unspecified addresses that cannot be used as\r
 189                                 // a target address\r
 190                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");\r
 191                                 Assert.IsNull (ex.InnerException, "#A3");\r
 192                                 Assert.IsNotNull (ex.Message, "#A4");\r
 193                                 Assert.AreEqual ("hostNameOrAddress", ex.ParamName, "#A5");\r
 194                         }\r
 195 \r
 196                         // IPv6\r
 197                         try {\r
 198                                 Dns.GetHostAddresses ("::0");\r
 199                                 Assert.Fail ("#B1");\r
 200                         } catch (ArgumentException ex) {\r
 201                                 // IPv4 address 0.0.0.0 and IPv6 address ::0 are\r
 202                                 // unspecified addresses that cannot be used as\r
 203                                 // a target address\r
 204                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");\r
 205                                 Assert.IsNull (ex.InnerException, "#B3");\r
 206                                 Assert.IsNotNull (ex.Message, "#B4");\r
 207                                 Assert.AreEqual ("hostNameOrAddress", ex.ParamName, "#B5");\r
 208                         }\r
 209                 }\r
 210 \r
 211                 [Test]\r
 212                 public void GetHostName ()\r
 213                 {\r
 214                         string hostName = Dns.GetHostName ();\r
 215                         Assert.IsNotNull (hostName);\r
 216                 }\r
 217 \r
 218                 [Test]\r
 219 #if FEATURE_NO_BSD_SOCKETS\r
 220                 [ExpectedException (typeof (PlatformNotSupportedException))]\r
 221 #endif\r
 222                 [NUnit.Framework.Category ("AndroidNotWorking")] //Some Android devices like to return catch-all IPs for invalid host names.\r
 223                 public void GetHostByName ()\r
 224                 {\r
 225                         SubTestGetHostByName (site1Name, site1Dot);\r
 226                         SubTestGetHostByName (site2Name, site2Dot);\r
 227                         try {\r
 228                                 var entry = Dns.GetHostByName (noneExistingSite);\r
 229                                 Assert.Fail ("Should raise a SocketException (assuming that '" + noneExistingSite + "' does not exist)");\r
 230                         } catch (SocketException) {\r
 231                         }\r
 232                 }\r
 233 \r
 234                 static IPAddress GetIPv4Address (IPHostEntry h)\r
 235                 {\r
 236                         var al = h.AddressList.FirstOrDefault (x => x.AddressFamily == AddressFamily.InterNetwork);\r
 237                         if (al == null)\r
 238                                 Assert.Ignore ("Could not resolve an IPv4 address as required by this test case, e.g. running on an IPv6 only network");\r
 239                         return al;\r
 240                 }\r
 241 \r
 242                 void SubTestGetHostByName (string siteName, string siteDot)\r
 243                 {\r
 244                         IPHostEntry h = Dns.GetHostByName (siteName);\r
 245                         SubTestValidIPHostEntry (h);\r
 246                         Assert.AreEqual (siteName, h.HostName, "siteName");\r
 247                         var ip = GetIPv4Address (h);\r
 248                         Assert.AreEqual (siteDot, ip.ToString (), "siteDot");\r
 249                 }\r
 250 \r
 251                 [Test]\r
 252                 public void GetHostByName_HostName_Null ()\r
 253                 {\r
 254                         try {\r
 255                                 Dns.GetHostByName ((string) null);\r
 256                                 Assert.Fail ("#1");\r
 257                         } catch (ArgumentNullException ex) {\r
 258                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");\r
 259                                 Assert.IsNull (ex.InnerException, "#3");\r
 260                                 Assert.IsNotNull (ex.Message, "#4");\r
 261                                 Assert.AreEqual ("hostName", ex.ParamName, "#5");\r
 262                         }\r
 263                 }\r
 264 \r
 265                 [Test]\r
 266                 public void GetHostByAddressString_Address_Null ()\r
 267                 {\r
 268                         try {\r
 269                                 Dns.GetHostByAddress ((string) null);\r
 270                                 Assert.Fail ("#1");\r
 271                         } catch (ArgumentNullException ex) {\r
 272                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");\r
 273                                 Assert.IsNull (ex.InnerException, "#3");\r
 274                                 Assert.IsNotNull (ex.Message, "#4");\r
 275                                 Assert.AreEqual ("address", ex.ParamName, "#5");\r
 276                         }\r
 277                 }\r
 278 \r
 279                 [Test]\r
 280                 [ExpectedException (typeof (SocketException))]\r
 281                 public void GetHostByAddressString2 ()\r
 282                 {\r
 283                         Dns.GetHostByAddress ("123.255.23");\r
 284                 }\r
 285 \r
 286                 [Test]\r
 287                 [ExpectedException (typeof (FormatException))]\r
 288                 public void GetHostByAddressString3 ()\r
 289                 {\r
 290                         Dns.GetHostByAddress ("123.256.34.10");\r
 291                 }\r
 292 \r
 293                 [Test, ExpectedException (typeof (FormatException))]\r
 294                 public void GetHostByAddressString4 ()\r
 295                 {\r
 296                         Dns.GetHostByAddress ("not an IP address");\r
 297                 }\r
 298 \r
 299                 [Test]\r
 300                 public void GetHostByAddressString5 ()\r
 301                 {\r
 302                         Dns.GetHostByAddress (site1Dot);\r
 303                 }\r
 304 \r
 305                 [Test]\r
 306                 public void GetHostByAddressIPAddress_Address_Null ()\r
 307                 {\r
 308                         try {\r
 309                                 Dns.GetHostByAddress ((IPAddress) null);\r
 310                                 Assert.Fail ("#1");\r
 311                         } catch (ArgumentNullException ex) {\r
 312                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");\r
 313                                 Assert.IsNull (ex.InnerException, "#3");\r
 314                                 Assert.IsNotNull (ex.Message, "#4");\r
 315                                 Assert.AreEqual ("address", ex.ParamName, "#5");\r
 316                         }\r
 317                 }\r
 318 \r
 319                 [Test]\r
 320                 public void GetHostByAddressIPAddress2 ()\r
 321                 {\r
 322                         IPAddress addr = new IPAddress (IPAddress.NetworkToHostOrder ((int) site1IP));\r
 323                         IPHostEntry h = Dns.GetHostByAddress (addr);\r
 324                         SubTestValidIPHostEntry (h);\r
 325                         var ip = GetIPv4Address (h);\r
 326                         Assert.AreEqual (addr.ToString (), ip.ToString ());\r
 327                 }\r
 328 \r
 329                 [Test]\r
 330                 public void GetHostByAddressIPAddress3 ()\r
 331                 {\r
 332                         IPAddress addr = new IPAddress (IPAddress.NetworkToHostOrder ((int) site2IP));\r
 333                         IPHostEntry h = Dns.GetHostByAddress (addr);\r
 334                         SubTestValidIPHostEntry (h);\r
 335                         var ip = GetIPv4Address (h);\r
 336                         Assert.AreEqual (addr.ToString (), ip.ToString ());\r
 337                 }\r
 338 \r
 339                 [Test]\r
 340 #if FEATURE_NO_BSD_SOCKETS\r
 341                 [ExpectedException (typeof (PlatformNotSupportedException))]\r
 342 #endif\r
 343                 public void BeginResolve_HostName_Null ()\r
 344                 {\r
 345                         try {\r
 346                                 Dns.BeginResolve ((string) null,\r
 347                                         new AsyncCallback (ShouldntBeCalled),\r
 348                                         null);\r
 349                                 Assert.Fail ("#1");\r
 350                         } catch (ArgumentNullException ex) {\r
 351                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");\r
 352                                 Assert.IsNull (ex.InnerException, "#3");\r
 353                                 Assert.IsNotNull (ex.Message, "#4");\r
 354                                 Assert.AreEqual ("hostName", ex.ParamName, "#5");\r
 355                         }\r
 356                 }\r
 357 \r
 358                 [Test]\r
 359 #if FEATURE_NO_BSD_SOCKETS\r
 360                 [ExpectedException (typeof (PlatformNotSupportedException))]\r
 361 #endif\r
 362                 public void Resolve ()\r
 363                 {\r
 364                         SubTestResolve (site1Name);\r
 365                         SubTestResolve (site2Name);\r
 366                         SubTestResolve (site1Dot);\r
 367                         SubTestResolve (site2Dot);\r
 368                 }\r
 369 \r
 370                 void SubTestResolve (string addr)\r
 371                 {\r
 372                         IPHostEntry h = Dns.Resolve (addr);\r
 373                         SubTestValidIPHostEntry (h);\r
 374                 }\r
 375 \r
 376                 [Test]\r
 377 #if FEATURE_NO_BSD_SOCKETS\r
 378                 [ExpectedException (typeof (PlatformNotSupportedException))]\r
 379 #endif\r
 380                 public void Resolve_HostName_Null ()\r
 381                 {\r
 382                         try {\r
 383                                 Dns.Resolve ((string) null);\r
 384                                 Assert.Fail ("#1");\r
 385                         } catch (ArgumentNullException ex) {\r
 386                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");\r
 387                                 Assert.IsNull (ex.InnerException, "#3");\r
 388                                 Assert.IsNotNull (ex.Message, "#4");\r
 389                                 Assert.AreEqual ("hostName", ex.ParamName, "#5");\r
 390                         }\r
 391                 }\r
 392 \r
 393                 [Test] // BeginGetHostEntry (IPAddress, AsyncCallback, Object)\r
 394 #if FEATURE_NO_BSD_SOCKETS\r
 395                 [ExpectedException (typeof (PlatformNotSupportedException))]\r
 396 #endif\r
 397                 public void BeginGetHostEntry1_Address_Null ()\r
 398                 {\r
 399                         try {\r
 400                                 Dns.BeginGetHostEntry (\r
 401                                         (IPAddress) null,\r
 402                                         new AsyncCallback (ShouldntBeCalled),\r
 403                                         null);\r
 404                                 Assert.Fail ("#1");\r
 405                         } catch (ArgumentNullException ex) {\r
 406                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");\r
 407                                 Assert.IsNull (ex.InnerException, "#3");\r
 408                                 Assert.IsNotNull (ex.Message, "#4");\r
 409                                 Assert.AreEqual ("address", ex.ParamName, "#5");\r
 410                         }\r
 411                 }\r
 412 \r
 413                 [Test] // BeginGetHostEntry (String, AsyncCallback, Object)\r
 414 #if FEATURE_NO_BSD_SOCKETS\r
 415                 [ExpectedException (typeof (PlatformNotSupportedException))]\r
 416 #endif\r
 417                 public void BeginGetHostEntry2_HostNameOrAddress_Null ()\r
 418                 {\r
 419                         try {\r
 420                                 Dns.BeginGetHostEntry (\r
 421                                         (string) null,\r
 422                                         new AsyncCallback (ShouldntBeCalled),\r
 423                                         null);\r
 424                                 Assert.Fail ("#1");\r
 425                         } catch (ArgumentNullException ex) {\r
 426                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");\r
 427                                 Assert.IsNull (ex.InnerException, "#3");\r
 428                                 Assert.IsNotNull (ex.Message, "#4");\r
 429                                 Assert.AreEqual ("hostName", ex.ParamName, "#5");\r
 430                         }\r
 431                 }\r
 432 \r
 433                 [Test] // BeginGetHostEntry (String, AsyncCallback, Object)\r
 434 #if FEATURE_NO_BSD_SOCKETS\r
 435                 [ExpectedException (typeof (PlatformNotSupportedException))]\r
 436 #endif\r
 437                 public void BeginGetHostEntry2_HostNameOrAddress_UnspecifiedAddress ()\r
 438                 {\r
 439                         // IPv4\r
 440                         try {\r
 441                                 Dns.BeginGetHostEntry (\r
 442                                         "0.0.0.0",\r
 443                                         new AsyncCallback (GetHostEntryCallback),\r
 444                                         null);\r
 445                                 Assert.Fail ("#1");\r
 446                         } catch (ArgumentException ex) {\r
 447                                 // IPv4 address 0.0.0.0 and IPv6 address ::0 are\r
 448                                 // unspecified addresses that cannot be used as\r
 449                                 // a target address\r
 450                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");\r
 451                                 Assert.IsNull (ex.InnerException, "#3");\r
 452                                 Assert.IsNotNull (ex.Message, "#4");\r
 453                                 Assert.AreEqual ("hostNameOrAddress", ex.ParamName, "#5");\r
 454                         }\r
 455 \r
 456                         // IPv6\r
 457                         try {\r
 458                                 Dns.BeginGetHostEntry (\r
 459                                         "::0",\r
 460                                         new AsyncCallback (GetHostEntryCallback),\r
 461                                         null);\r
 462                                 Assert.Fail ("#1");\r
 463                         } catch (ArgumentException ex) {\r
 464                                 // IPv4 address 0.0.0.0 and IPv6 address ::0 are\r
 465                                 // unspecified addresses that cannot be used as\r
 466                                 // a target address\r
 467                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");\r
 468                                 Assert.IsNull (ex.InnerException, "#3");\r
 469                                 Assert.IsNotNull (ex.Message, "#4");\r
 470                                 Assert.AreEqual ("hostNameOrAddress", ex.ParamName, "#5");\r
 471                         }\r
 472                 }\r
 473 \r
 474                 void GetHostEntryCallback (IAsyncResult ar)\r
 475                 {\r
 476                         IPHostEntry hostEntry = Dns.EndGetHostEntry (ar);\r
 477                         Assert.IsNotNull (hostEntry);\r
 478                 }\r
 479 \r
 480                 [Test] // GetHostEntry (IPAddress)\r
 481                 public void GetHostEntry1_Address_Null ()\r
 482                 {\r
 483                         try {\r
 484                                 Dns.GetHostEntry ((IPAddress) null);\r
 485                                 Assert.Fail ("#1");\r
 486                         } catch (ArgumentNullException ex) {\r
 487                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");\r
 488                                 Assert.IsNull (ex.InnerException, "#3");\r
 489                                 Assert.IsNotNull (ex.Message, "#4");\r
 490                                 Assert.AreEqual ("address", ex.ParamName, "#5");\r
 491                         }\r
 492                 }\r
 493 \r
 494                 [Test] // GetHostEntry (String)\r
 495 #if FEATURE_NO_BSD_SOCKETS\r
 496                 [ExpectedException (typeof (PlatformNotSupportedException))]\r
 497 #endif\r
 498                 public void GetHostEntry2 ()\r
 499                 {\r
 500                         Dns.GetHostEntry (site1Name); // hostname\r
 501                         Dns.GetHostEntry (site1Dot); // IP address\r
 502                 }\r
 503 \r
 504                 [Test] // GetHostEntry (String)\r
 505                 public void GetHostEntry2_HostNameOrAddress_Null ()\r
 506                 {\r
 507                         try {\r
 508                                 Dns.GetHostEntry ((string) null);\r
 509                                 Assert.Fail ("#1");\r
 510                         } catch (ArgumentNullException ex) {\r
 511                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");\r
 512                                 Assert.IsNull (ex.InnerException, "#3");\r
 513                                 Assert.IsNotNull (ex.Message, "#4");\r
 514                                 Assert.AreEqual ("hostNameOrAddress", ex.ParamName, "#5");\r
 515                         }\r
 516                 }\r
 517 \r
 518                 [Test] // GetHostEntry (String)\r
 519                 public void GetHostEntry2_HostNameOrAddress_UnspecifiedAddress ()\r
 520                 {\r
 521                         // IPv4\r
 522                         try {\r
 523                                 Dns.GetHostEntry ("0.0.0.0");\r
 524                                 Assert.Fail ("#A1");\r
 525                         } catch (ArgumentException ex) {\r
 526                                 // IPv4 address 0.0.0.0 and IPv6 address ::0 are\r
 527                                 // unspecified addresses that cannot be used as\r
 528                                 // a target address\r
 529                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");\r
 530                                 Assert.IsNull (ex.InnerException, "#A3");\r
 531                                 Assert.IsNotNull (ex.Message, "#A4");\r
 532                                 Assert.AreEqual ("hostNameOrAddress", ex.ParamName, "#A5");\r
 533                         }\r
 534 \r
 535                         // IPv6\r
 536                         try {\r
 537                                 Dns.GetHostEntry ("::0");\r
 538                                 Assert.Fail ("#B1");\r
 539                         } catch (ArgumentException ex) {\r
 540                                 // IPv4 address 0.0.0.0 and IPv6 address ::0 are\r
 541                                 // unspecified addresses that cannot be used as\r
 542                                 // a target address\r
 543                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");\r
 544                                 Assert.IsNull (ex.InnerException, "#B3");\r
 545                                 Assert.IsNotNull (ex.Message, "#B4");\r
 546                                 Assert.AreEqual ("hostNameOrAddress", ex.ParamName, "#B5");\r
 547                         }\r
 548                 }\r
 549 \r
 550                 void SubTestValidIPHostEntry (IPHostEntry h)\r
 551                 {\r
 552                         Assert.IsNotNull (h.HostName, "HostName not null");\r
 553                         Assert.IsNotNull (h.AddressList, "AddressList not null");\r
 554                         Assert.IsTrue (h.AddressList.Length > 0, "AddressList.Length");\r
 555                 }\r
 556 \r
 557                 [Test]\r
 558                 public void GetHostEntry_StringEmpty ()\r
 559                 {\r
 560                         Dns.GetHostEntry (string.Empty);\r
 561                 }\r
 562 \r
 563                 /* This isn't used anymore, but could be useful for debugging\r
 564                 static void printIPHostEntry(IPHostEntry h)\r
 565                 {\r
 566                         Console.WriteLine("----------------------------------------------------");\r
 567                         Console.WriteLine("Host name:");\r
 568                         Console.WriteLine(h.HostName);\r
 569                         Console.WriteLine("IP addresses:");\r
 570                         IPAddress[] list = h.AddressList;\r
 571                         for(int i = 0; i < list.Length; ++i)\r
 572                                 Console.WriteLine(list[i]);\r
 573                         Console.WriteLine("Aliases:");\r
 574                         string[] aliases = h.Aliases;\r
 575                         for(int i = 0; i < aliases.Length; ++i)\r
 576                                 Console.WriteLine(aliases[i]);\r
 577                         Console.WriteLine("----------------------------------------------------");\r
 578                 }\r
 579                 */\r
 580         }\r
 581 }\r