mcs/class/System/Test/System.Net.Sockets/UdpClientTest.cs

   1 // System.Net.Sockets.UdpClientTest.cs
   2 //
   3 // Authors:
   4 //      Chris Bacon <chris.bacon@docobo.co.uk>
   5 //      Gert Driesen <drieseng@users.sourceforge.net>
   6 //
   7
   8 using System;
   9 using System.Net;
  10 using System.Net.Sockets;
  11 using System.Threading;
  12 using System.Threading.Tasks;
  13
  14 using NUnit.Framework;
  15
  16 namespace MonoTests.System.Net.Sockets {
  17         [TestFixture]
  18         public class UdpClientTest {
  19                 [Test] // .ctor ()
  20 #if FEATURE_NO_BSD_SOCKETS
  21                 [ExpectedException (typeof (PlatformNotSupportedException))]
  22 #endif
  23                 public void Constructor1 ()
  24                 {
  25                         MyUdpClient client;
  26                         Socket s;
  27
  28                         client = new MyUdpClient ();
  29                         s = client.Client;
  30                         Assert.IsNotNull (s, "Client");
  31                         Assert.AreEqual (AddressFamily.InterNetwork, s.AddressFamily, "Client:AddressFamily");
  32                         Assert.IsFalse (s.Connected, "Client:Connected");
  33                         Assert.IsFalse (s.IsBound, "#A:Client:IsBound");
  34                         Assert.IsNull (s.LocalEndPoint, "Client:LocalEndPoint");
  35                         Assert.AreEqual (ProtocolType.Udp, s.ProtocolType, "Client:ProtocolType");
  36                         Assert.IsNull (s.RemoteEndPoint, "Client:RemoteEndPoint");
  37                         Assert.AreEqual (SocketType.Dgram, s.SocketType, "Client:SocketType");
  38                         Assert.IsFalse (client.Active, "Active");
  39                         Assert.IsFalse (client.DontFragment, "DontFragment");
  40                         Assert.IsFalse (client.EnableBroadcast, "EnableBroadcast");
  41                         //Assert.IsFalse (client.ExclusiveAddressUse, "ExclusiveAddressUse");
  42                         Assert.IsTrue (client.MulticastLoopback, "MulticastLoopback");
  43                         //Assert.AreEqual (32, client.Ttl, "Ttl");
  44                         client.Close ();
  45                 }
  46
  47                 [Test] // .ctor (AddressFamily)
  48 #if FEATURE_NO_BSD_SOCKETS
  49                 [ExpectedException (typeof (PlatformNotSupportedException))]
  50 #endif
  51                 public void Constructor2 ()
  52                 {
  53                         MyUdpClient client;
  54                         Socket s;
  55
  56                         client = new MyUdpClient (AddressFamily.InterNetwork);
  57                         s = client.Client;
  58                         Assert.IsNotNull (s, "#A:Client");
  59                         Assert.AreEqual (AddressFamily.InterNetwork, s.AddressFamily, "#A:Client:AddressFamily");
  60                         Assert.IsFalse (s.Connected, "#A:Client:Connected");
  61                         Assert.IsFalse (s.IsBound, "#A:Client:IsBound");
  62                         Assert.IsNull (s.LocalEndPoint, "#A:Client:LocalEndPoint");
  63                         Assert.AreEqual (ProtocolType.Udp, s.ProtocolType, "#A:Client:ProtocolType");
  64                         Assert.IsNull (s.RemoteEndPoint, "#A:Client:RemoteEndPoint");
  65                         Assert.AreEqual (SocketType.Dgram, s.SocketType, "#A:Client:SocketType");
  66                         Assert.IsFalse (client.Active, "#A:Active");
  67                         //Assert.IsFalse (client.DontFragment, "#A:DontFragment");
  68                         Assert.IsFalse (client.EnableBroadcast, "#A:EnableBroadcast");
  69                         //Assert.IsFalse (client.ExclusiveAddressUse, "#A:ExclusiveAddressUse");
  70                         Assert.IsTrue (client.MulticastLoopback, "#A:MulticastLoopback");
  71                         //Assert.AreEqual (32, client.Ttl, "#A:Ttl");
  72
  73                         if (!Socket.OSSupportsIPv6)
  74                                 Assert.Ignore ("IPv6 not enabled.");
  75
  76                         client = new MyUdpClient (AddressFamily.InterNetworkV6);
  77                         s = client.Client;
  78                         Assert.IsNotNull (s, "#B:Client");
  79                         Assert.AreEqual (AddressFamily.InterNetworkV6, s.AddressFamily, "#B:Client:AddressFamily");
  80                         Assert.IsFalse (s.Connected, "#B:Client:Connected");
  81                         Assert.IsFalse (s.IsBound, "#A:Client:IsBound");
  82                         Assert.IsNull (s.LocalEndPoint, "#B:Client:LocalEndPoint");
  83                         Assert.AreEqual (ProtocolType.Udp, s.ProtocolType, "#B:Client:ProtocolType");
  84                         Assert.IsNull (s.RemoteEndPoint, "#B:Client:RemoteEndPoint");
  85                         Assert.AreEqual (SocketType.Dgram, s.SocketType, "#B:Client:SocketType");
  86                         Assert.IsFalse (client.Active, "#B:Active");
  87                         //Assert.IsFalse (client.DontFragment, "#B:DontFragment");
  88                         Assert.IsFalse (client.EnableBroadcast, "#B:EnableBroadcast");
  89                         //Assert.IsFalse (client.ExclusiveAddressUse, "#B:ExclusiveAddressUse");
  90                         Assert.IsTrue (client.MulticastLoopback, "#B:MulticastLoopback");
  91                         //Assert.AreEqual (32, client.Ttl, "#B:Ttl");
  92                         client.Close ();
  93                 }
  94
  95                 [Test] // .ctor (AddressFamily)
  96 #if FEATURE_NO_BSD_SOCKETS
  97                 [ExpectedException (typeof (PlatformNotSupportedException))]
  98 #endif
  99                 public void Constructor2_Family_Invalid ()
 100                 {
 101                         try {
 102                                 new UdpClient (AddressFamily.NetBios);
 103                                 Assert.Fail ("#A1");
 104                         } catch (ArgumentException ex) {
 105                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
 106                                 Assert.IsNull (ex.InnerException, "#A3");
 107                                 // 'UDP' Client can only accept InterNetwork or InterNetworkV6
 108                                 // addresses
 109                                 Assert.IsNotNull (ex.Message, "#A4");
 110                                 Assert.AreEqual ("family", ex.ParamName, "#A5");
 111                         }
 112
 113                         try {
 114                                 new UdpClient ((AddressFamily) 666);
 115                                 Assert.Fail ("#B1");
 116                         } catch (ArgumentException ex) {
 117                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
 118                                 Assert.IsNull (ex.InnerException, "#B3");
 119                                 Assert.IsNotNull (ex.Message, "#B4");
 120                                 Assert.AreEqual ("family", ex.ParamName, "#B5");
 121                         }
 122                 }
 123
 124                 [Test] // .ctor (Int32)
 125 #if FEATURE_NO_BSD_SOCKETS
 126                 [ExpectedException (typeof (PlatformNotSupportedException))]
 127 #endif
 128                 public void Constructor3 ()
 129                 {
 130                         Socket s;
 131                         IPEndPoint localEP;
 132
 133                         using (MyUdpClient client = new MyUdpClient (IPEndPoint.MinPort))
 134                         {
 135                                 s = client.Client;
 136                                 Assert.IsNotNull (s, "#A:Client");
 137                                 Assert.AreEqual (AddressFamily.InterNetwork, s.AddressFamily, "#A:Client:AddressFamily");
 138                                 Assert.IsFalse (s.Connected, "#A:Client:Connected");
 139                                 Assert.IsTrue (s.IsBound, "#A:Client:IsBound");
 140                                 Assert.AreEqual (ProtocolType.Udp, s.ProtocolType, "#A:Client:ProtocolType");
 141                                 Assert.AreEqual (SocketType.Dgram, s.SocketType, "#A:Client:SocketType");
 142                                 Assert.IsFalse (client.Active, "#A:Active");
 143                                 Assert.IsFalse (client.DontFragment, "#A:DontFragment");
 144                                 Assert.IsFalse (client.EnableBroadcast, "#A:EnableBroadcast");
 145                                 //Assert.IsFalse (client.ExclusiveAddressUse, "#A:ExclusiveAddressUse");
 146                                 Assert.IsTrue (client.MulticastLoopback, "#A:MulticastLoopback");
 147                                 //Assert.AreEqual (32, client.Ttl, "#A:Ttl");
 148                                 localEP = s.LocalEndPoint as IPEndPoint;
 149                                 Assert.IsNotNull (localEP, "#A:Client:LocalEndpoint");
 150                                 Assert.AreEqual (IPAddress.Any, localEP.Address, "#A:Client:LocalEndPoint/Address");
 151                                 Assert.AreEqual (AddressFamily.InterNetwork, localEP.AddressFamily, "#A:Client:LocalEndPoint/AddressFamily");
 152                         }
 153                         using (MyUdpClient client = new MyUdpClient (IPEndPoint.MaxPort))
 154                         {
 155                                 s = client.Client;
 156                                 Assert.IsNotNull (s, "#B:Client");
 157                                 Assert.AreEqual (AddressFamily.InterNetwork, s.AddressFamily, "#B:Client:AddressFamily");
 158                                 Assert.IsFalse (s.Connected, "#B:Client:Connected");
 159                                 Assert.IsTrue (s.IsBound, "#B:Client:IsBound");
 160                                 Assert.AreEqual (ProtocolType.Udp, s.ProtocolType, "#B:Client:ProtocolType");
 161                                 Assert.AreEqual (SocketType.Dgram, s.SocketType, "#B:Client:SocketType");
 162                                 Assert.IsFalse (client.Active, "#B:Active");
 163                                 Assert.IsFalse (client.DontFragment, "#B:DontFragment");
 164                                 Assert.IsFalse (client.EnableBroadcast, "#B:EnableBroadcast");
 165                                 //Assert.IsFalse (client.ExclusiveAddressUse, "#B:ExclusiveAddressUse");
 166                                 Assert.IsTrue (client.MulticastLoopback, "#B:MulticastLoopback");
 167                                 //Assert.AreEqual (32, client.Ttl, "#B:Ttl");
 168                                 localEP = s.LocalEndPoint as IPEndPoint;
 169                                 Assert.IsNotNull (localEP, "#B:Client:LocalEndpoint");
 170                                 Assert.AreEqual (IPAddress.Any, localEP.Address, "#B:Client:LocalEndPoint/Address");
 171                                 Assert.AreEqual (AddressFamily.InterNetwork, localEP.AddressFamily, "#B:Client:LocalEndPoint/AddressFamily");
 172                                 Assert.AreEqual (IPEndPoint.MaxPort, localEP.Port, "#B:Client:LocalEndPoint/Port");
 173                         }
 174                 }
 175
 176                 [Test] // .ctor (Int32)
 177 #if FEATURE_NO_BSD_SOCKETS
 178                 [ExpectedException (typeof (PlatformNotSupportedException))]
 179 #endif
 180                 public void Constructor3_Port_OutOfRange ()
 181                 {
 182                         try {
 183                                 new UdpClient (IPEndPoint.MaxPort + 1);
 184                                 Assert.Fail ("#A1");
 185                         } catch (ArgumentOutOfRangeException ex) {
 186                                 // Specified argument was out of the range of valid values
 187                                 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2");
 188                                 Assert.IsNull (ex.InnerException, "#A3");
 189                                 Assert.IsNotNull (ex.Message, "#A4");
 190                                 Assert.AreEqual ("port", ex.ParamName, "#A5");
 191                         }
 192
 193                         try {
 194                                 new UdpClient (IPEndPoint.MinPort - 1);
 195                                 Assert.Fail ("#A1");
 196                         } catch (ArgumentOutOfRangeException ex) {
 197                                 // Specified argument was out of the range of valid values
 198                                 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2");
 199                                 Assert.IsNull (ex.InnerException, "#A3");
 200                                 Assert.IsNotNull (ex.Message, "#A4");
 201                                 Assert.AreEqual ("port", ex.ParamName, "#A5");
 202                         }
 203                 }
 204
 205                 [Test] // .ctor (IPEndPoint)
 206 #if FEATURE_NO_BSD_SOCKETS
 207                 [ExpectedException (typeof (PlatformNotSupportedException))]
 208 #endif
 209                 public void Constructor4 ()
 210                 {
 211                         Socket s;
 212                         IPEndPoint localEP;
 213                         IPEndPoint clientEP;
 214
 215                         clientEP = new IPEndPoint (IPAddress.Loopback, 8001);
 216                         using (MyUdpClient client = new MyUdpClient (clientEP))
 217                         {
 218                                 s = client.Client;
 219                                 Assert.IsNotNull (s, "#A:Client");
 220                                 Assert.AreEqual (AddressFamily.InterNetwork, s.AddressFamily, "#A:Client:AddressFamily");
 221                                 Assert.IsFalse (s.Connected, "#A:Client:Connected");
 222                                 Assert.IsTrue (s.IsBound, "#A:Client:IsBound");
 223                                 Assert.AreEqual (ProtocolType.Udp, s.ProtocolType, "#A:Client:ProtocolType");
 224                                 Assert.AreEqual (SocketType.Dgram, s.SocketType, "#A:Client:SocketType");
 225                                 Assert.IsFalse (client.Active, "#A:Active");
 226                                 Assert.IsFalse (client.DontFragment, "#A:DontFragment");
 227                                 Assert.IsFalse (client.EnableBroadcast, "#A:EnableBroadcast");
 228                                 //Assert.IsFalse (client.ExclusiveAddressUse, "#A:ExclusiveAddressUse");
 229                                 Assert.IsTrue (client.MulticastLoopback, "#A:MulticastLoopback");
 230                                 //Assert.AreEqual (32, client.Ttl, "#A:Ttl");
 231                                 localEP = s.LocalEndPoint as IPEndPoint;
 232                                 Assert.IsNotNull (localEP, "#A:Client:LocalEndpoint");
 233                                 Assert.IsFalse (object.ReferenceEquals (clientEP, localEP), "#A:Client:LocalEndPoint/ReferenceEquality");
 234                                 Assert.AreEqual (clientEP.Address, localEP.Address, "#A:Client:LocalEndPoint/Address");
 235                                 Assert.AreEqual (clientEP.AddressFamily, localEP.AddressFamily, "#A:Client:LocalEndPoint/AddressFamily");
 236                                 Assert.AreEqual (clientEP.Port, localEP.Port, "#A:Client:LocalEndPoint/Port");
 237                         }
 238                 }
 239
 240                 [Test] // .ctor (IPEndPoint)
 241 #if FEATURE_NO_BSD_SOCKETS
 242                 [ExpectedException (typeof (PlatformNotSupportedException))]
 243 #endif
 244                 public void Constructor4_LocalEP_Null ()
 245                 {
 246                         try {
 247                                 new UdpClient ((IPEndPoint) null);
 248                                 Assert.Fail ("#1");
 249                         } catch (ArgumentNullException ex) {
 250                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 251                                 Assert.IsNull (ex.InnerException, "#3");
 252                                 Assert.IsNotNull (ex.Message, "#4");
 253                                 Assert.AreEqual ("localEP", ex.ParamName, "#5");
 254                         }
 255                 }
 256
 257                 [Test] // .ctor (Int32, AddressFamily)
 258 #if FEATURE_NO_BSD_SOCKETS
 259                 [ExpectedException (typeof (PlatformNotSupportedException))]
 260 #endif
 261                 public void Constructor5 ()
 262                 {
 263                         Socket s;
 264                         IPEndPoint localEP;
 265
 266                         using (MyUdpClient client = new MyUdpClient (IPEndPoint.MinPort, AddressFamily.InterNetwork))
 267                         {
 268                                 s = client.Client;
 269                                 Assert.IsNotNull (s, "#A:Client");
 270                                 Assert.AreEqual (AddressFamily.InterNetwork, s.AddressFamily, "#A:Client:AddressFamily");
 271                                 Assert.IsFalse (s.Connected, "#A:Client:Connected");
 272                                 Assert.IsTrue (s.IsBound, "#A:Client:IsBound");
 273                                 Assert.AreEqual (ProtocolType.Udp, s.ProtocolType, "#A:Client:ProtocolType");
 274                                 Assert.AreEqual (SocketType.Dgram, s.SocketType, "#A:Client:SocketType");
 275                                 Assert.IsFalse (client.Active, "#A:Active");
 276                                 //Assert.IsFalse (client.DontFragment, "#A:DontFragment");
 277                                 Assert.IsFalse (client.EnableBroadcast, "#A:EnableBroadcast");
 278                                 //Assert.IsFalse (client.ExclusiveAddressUse, "#A:ExclusiveAddressUse");
 279                                 Assert.IsTrue (client.MulticastLoopback, "#A:MulticastLoopback");
 280                                 //Assert.AreEqual (32, client.Ttl, "#A:Ttl");
 281                                 localEP = s.LocalEndPoint as IPEndPoint;
 282                                 Assert.IsNotNull (localEP, "#A:Client:LocalEndpoint");
 283                                 Assert.AreEqual (IPAddress.Any, localEP.Address, "#A:Client:LocalEndPoint/Address");
 284                                 Assert.AreEqual (AddressFamily.InterNetwork, localEP.AddressFamily, "#A:Client:LocalEndPoint/AddressFamily");
 285                         }
 286
 287                         if (!Socket.OSSupportsIPv6)
 288                                 Assert.Ignore ("IPv6 not enabled.");
 289
 290                         using (MyUdpClient client = new MyUdpClient (IPEndPoint.MaxPort, AddressFamily.InterNetworkV6))
 291                         {
 292                                 s = client.Client;
 293                                 Assert.IsNotNull (s, "#B:Client");
 294                                 Assert.AreEqual (AddressFamily.InterNetworkV6, s.AddressFamily, "#B:Client:AddressFamily");
 295                                 Assert.IsFalse (s.Connected, "#B:Client:Connected");
 296                                 Assert.IsTrue (s.IsBound, "#B:Client:IsBound");
 297                                 Assert.AreEqual (ProtocolType.Udp, s.ProtocolType, "#B:Client:ProtocolType");
 298                                 Assert.AreEqual (SocketType.Dgram, s.SocketType, "#B:Client:SocketType");
 299                                 Assert.IsFalse (client.Active, "#B:Active");
 300                                 //Assert.IsFalse (client.DontFragment, "#B:DontFragment");
 301                                 Assert.IsFalse (client.EnableBroadcast, "#B:EnableBroadcast");
 302                                 //Assert.IsFalse (client.ExclusiveAddressUse, "#B:ExclusiveAddressUse");
 303                                 Assert.IsTrue (client.MulticastLoopback, "#B:MulticastLoopback");
 304                                 //Assert.AreEqual (32, client.Ttl, "#B:Ttl");
 305                                 localEP = s.LocalEndPoint as IPEndPoint;
 306                                 Assert.IsNotNull (localEP, "#B:Client:LocalEndpoint");
 307                                 Assert.AreEqual (IPAddress.IPv6Any, localEP.Address, "#B:Client:LocalEndPoint/Address");
 308                                 Assert.AreEqual (AddressFamily.InterNetworkV6, localEP.AddressFamily, "#B:Client:LocalEndPoint/AddressFamily");
 309                                 Assert.AreEqual (IPEndPoint.MaxPort, localEP.Port, "#B:Client:LocalEndPoint/Port");
 310                         }
 311                 }
 312
 313                 [Test] // .ctor (Int32, AddressFamily)
 314 #if FEATURE_NO_BSD_SOCKETS
 315                 [ExpectedException (typeof (PlatformNotSupportedException))]
 316 #endif
 317                 public void Constructor5_Family_Invalid ()
 318                 {
 319                         try {
 320                                 new UdpClient (80, AddressFamily.NetBios);
 321                                 Assert.Fail ("#A1");
 322                         } catch (ArgumentException ex) {
 323                                 // family
 324                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
 325                                 Assert.IsNull (ex.InnerException, "#A3");
 326                                 // 'UDP' Client can only accept InterNetwork or InterNetworkV6
 327                                 // addresses
 328                                 Assert.IsNotNull (ex.Message, "#A4");
 329                                 Assert.AreEqual ("family", ex.ParamName, "#A5");
 330                         }
 331
 332                         try {
 333                                 new UdpClient (80, (AddressFamily) 666);
 334                                 Assert.Fail ("#B1");
 335                         } catch (ArgumentException ex) {
 336                                 // family
 337                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
 338                                 Assert.IsNull (ex.InnerException, "#B3");
 339                                 // 'UDP' Client can only accept InterNetwork or InterNetworkV6
 340                                 // addresses
 341                                 Assert.IsNotNull (ex.Message, "#B4");
 342                                 Assert.AreEqual ("family", ex.ParamName, "#B5");
 343                         }
 344                 }
 345
 346                 [Test] // .ctor (Int32, AddressFamily)
 347 #if FEATURE_NO_BSD_SOCKETS
 348                 [ExpectedException (typeof (PlatformNotSupportedException))]
 349 #endif
 350                 public void Constructor5_Port_OutOfRange ()
 351                 {
 352                         try {
 353                                 new UdpClient (IPEndPoint.MaxPort + 1, AddressFamily.InterNetwork);
 354                                 Assert.Fail ("#A1");
 355                         } catch (ArgumentOutOfRangeException ex) {
 356                                 // Specified argument was out of the range of valid values
 357                                 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2");
 358                                 Assert.IsNull (ex.InnerException, "#A3");
 359                                 Assert.IsNotNull (ex.Message, "#A4");
 360                                 Assert.AreEqual ("port", ex.ParamName, "#A5");
 361                         }
 362
 363                         try {
 364                                 new UdpClient (IPEndPoint.MinPort - 1, AddressFamily.InterNetwork);
 365                                 Assert.Fail ("#A1");
 366                         } catch (ArgumentOutOfRangeException ex) {
 367                                 // Specified argument was out of the range of valid values
 368                                 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2");
 369                                 Assert.IsNull (ex.InnerException, "#A3");
 370                                 Assert.IsNotNull (ex.Message, "#A4");
 371                                 Assert.AreEqual ("port", ex.ParamName, "#A5");
 372                         }
 373                 }
 374
 375                 [Test] // .ctor (String, Int32)
 376 #if FEATURE_NO_BSD_SOCKETS
 377                 [ExpectedException (typeof (PlatformNotSupportedException))]
 378 #endif
 379                 public void Constructor6 ()
 380                 {
 381                         Socket s;
 382                         IPEndPoint localEP;
 383
 384                         // Bug #5503
 385                         // UDP port 0 doesn't seem to be valid.
 386                         using (MyUdpClient client = new MyUdpClient ("127.0.0.1", 53))
 387                         {
 388                                 s = client.Client;
 389                                 Assert.IsNotNull (s, "#A:Client");
 390                                 Assert.AreEqual (AddressFamily.InterNetwork, s.AddressFamily, "#A:Client:AddressFamily");
 391                                 Assert.IsTrue (s.Connected, "#A:Client:Connected");
 392                                 Assert.IsTrue (s.IsBound, "#A:Client:IsBound");
 393                                 Assert.AreEqual (ProtocolType.Udp, s.ProtocolType, "#A:Client:ProtocolType");
 394                                 Assert.AreEqual (SocketType.Dgram, s.SocketType, "#A:Client:SocketType");
 395                                 Assert.IsTrue (client.Active, "#A:Active");
 396                                 Assert.IsFalse (client.DontFragment, "#A:DontFragment");
 397                                 Assert.IsFalse (client.EnableBroadcast, "#A:EnableBroadcast");
 398                                 //Assert.IsFalse (client.ExclusiveAddressUse, "#A:ExclusiveAddressUse");
 399                                 //Assert.IsFalse (client.MulticastLoopback, "#A:MulticastLoopback");
 400                                 //Assert.AreEqual (32, client.Ttl, "#A:Ttl");
 401                                 localEP = s.LocalEndPoint as IPEndPoint;
 402                                 Assert.IsNotNull (localEP, "#A:Client:LocalEndpoint");
 403                                 Assert.AreEqual (IPAddress.Loopback, localEP.Address, "#A:Client:LocalEndPoint/Address");
 404                                 Assert.AreEqual (AddressFamily.InterNetwork, localEP.AddressFamily, "#A:Client:LocalEndPoint/AddressFamily");
 405                         }
 406                         using (MyUdpClient client = new MyUdpClient ("127.0.0.1", IPEndPoint.MaxPort))
 407                         {
 408                                 s = client.Client;
 409                                 Assert.IsNotNull (s, "#B:Client");
 410                                 Assert.AreEqual (AddressFamily.InterNetwork, s.AddressFamily, "#B:Client:AddressFamily");
 411                                 Assert.IsTrue (s.Connected, "#B:Client:Connected");
 412                                 Assert.IsTrue (s.IsBound, "#B:Client:IsBound");
 413                                 Assert.AreEqual (ProtocolType.Udp, s.ProtocolType, "#B:Client:ProtocolType");
 414                                 Assert.AreEqual (SocketType.Dgram, s.SocketType, "#B:Client:SocketType");
 415                                 Assert.IsTrue (client.Active, "#B:Active");
 416                                 Assert.IsFalse (client.DontFragment, "#B:DontFragment");
 417                                 Assert.IsFalse (client.EnableBroadcast, "#B:EnableBroadcast");
 418                                 //Assert.IsFalse (client.ExclusiveAddressUse, "#B:ExclusiveAddressUse");
 419                                 //Assert.IsFalse (client.MulticastLoopback, "#B:MulticastLoopback");
 420                                 //Assert.AreEqual (32, client.Ttl, "#B:Ttl");
 421                                 localEP = s.LocalEndPoint as IPEndPoint;
 422                                 Assert.IsNotNull (localEP, "#B:Client:LocalEndpoint");
 423                                 Assert.AreEqual (IPAddress.Loopback, localEP.Address, "#B:Client:LocalEndPoint/Address");
 424                                 Assert.AreEqual (AddressFamily.InterNetwork, localEP.AddressFamily, "#B:Client:LocalEndPoint/AddressFamily");
 425                         }
 426                 }
 427
 428                 [Test] // .ctor (String, Int32)
 429 #if FEATURE_NO_BSD_SOCKETS
 430                 [ExpectedException (typeof (PlatformNotSupportedException))]
 431 #endif
 432                 public void Constructor6_HostName_Null ()
 433                 {
 434                         try {
 435                                 new UdpClient ((string) null, int.MaxValue);
 436                                 Assert.Fail ("#1");
 437                         } catch (ArgumentNullException ex) {
 438                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 439                                 Assert.IsNull (ex.InnerException, "#3");
 440                                 Assert.IsNotNull (ex.Message, "#4");
 441                                 Assert.AreEqual ("hostname", ex.ParamName, "#5");
 442                         }
 443                 }
 444
 445                 [Test] // .ctor (String, Int32)
 446 #if FEATURE_NO_BSD_SOCKETS
 447                 [ExpectedException (typeof (PlatformNotSupportedException))]
 448 #endif
 449                 public void Constructor6_Port_OutOfRange ()
 450                 {
 451                         try {
 452                                 new UdpClient ("local", IPEndPoint.MaxPort + 1);
 453                                 Assert.Fail ("#A1");
 454                         } catch (ArgumentOutOfRangeException ex) {
 455                                 // Specified argument was out of the range of valid values
 456                                 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2");
 457                                 Assert.IsNull (ex.InnerException, "#A3");
 458                                 Assert.IsNotNull (ex.Message, "#A4");
 459                                 Assert.AreEqual ("port", ex.ParamName, "#A5");
 460                         }
 461
 462                         try {
 463                                 new UdpClient ("local", IPEndPoint.MinPort - 1);
 464                                 Assert.Fail ("#A1");
 465                         } catch (ArgumentOutOfRangeException ex) {
 466                                 // Specified argument was out of the range of valid values
 467                                 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2");
 468                                 Assert.IsNull (ex.InnerException, "#A3");
 469                                 Assert.IsNotNull (ex.Message, "#A4");
 470                                 Assert.AreEqual ("port", ex.ParamName, "#A5");
 471                         }
 472                 }
 473
 474                 [Test]
 475 #if FEATURE_NO_BSD_SOCKETS
 476                 [ExpectedException (typeof (PlatformNotSupportedException))]
 477 #endif
 478                 public void UdpClientBroadcastTest ()
 479                 {
 480                         UdpClient client = new UdpClient ();
 481                         byte[] bytes = new byte[] {10, 11, 12, 13};
 482
 483                         try {
 484                                 client.Send (bytes, bytes.Length, new IPEndPoint (IPAddress.Broadcast, 1235));
 485                         } finally {
 486                                 client.Close ();
 487                         }
 488                 }
 489
 490                 [Test] // JoinMulticastGroup (IPAddress)
 491 #if FEATURE_NO_BSD_SOCKETS
 492                 [ExpectedException (typeof (PlatformNotSupportedException))]
 493 #endif
 494                 public void JoinMulticastGroup1_IPv4 ()
 495                 {
 496                         IPAddress mcast_addr = IPAddress.Parse ("224.0.0.23");
 497
 498                         using (UdpClient client = new UdpClient (new IPEndPoint (IPAddress.Any, 1234))) {
 499                                 client.JoinMulticastGroup (mcast_addr);
 500                         }
 501                 }
 502
 503                 [Test] // JoinMulticastGroup (IPAddress)
 504 #if FEATURE_NO_BSD_SOCKETS
 505                 [ExpectedException (typeof (PlatformNotSupportedException))]
 506 #endif
 507                 public void JoinMulticastGroup1_IPv6 ()
 508                 {
 509                         if (!Socket.OSSupportsIPv6)
 510                                 Assert.Ignore ("IPv6 not enabled.");
 511
 512                         IPAddress mcast_addr = IPAddress.Parse ("ff02::1");
 513
 514                         using (UdpClient client = new UdpClient (new IPEndPoint (IPAddress.IPv6Any, 1234))) {
 515                                 client.JoinMulticastGroup (mcast_addr);
 516                         }
 517                 }
 518
 519                 [Test] // JoinMulticastGroup (IPAddress)
 520 #if FEATURE_NO_BSD_SOCKETS
 521                 [ExpectedException (typeof (PlatformNotSupportedException))]
 522 #endif
 523                 public void JoinMulticastGroup1_MulticastAddr_Null ()
 524                 {
 525                         using (UdpClient client = new UdpClient (new IPEndPoint (IPAddress.Loopback, 1234))) {
 526                                 try {
 527                                         client.JoinMulticastGroup ((IPAddress) null);
 528                                         Assert.Fail ("#1");
 529                                 } catch (ArgumentNullException ex) {
 530                                         Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 531                                         Assert.IsNull (ex.InnerException, "#3");
 532                                         Assert.IsNotNull (ex.Message, "#4");
 533                                         Assert.AreEqual ("multicastAddr", ex.ParamName, "#5");
 534                                 }
 535                         }
 536                 }
 537
 538                 [Test] // JoinMulticastGroup (IPAddress)
 539 #if FEATURE_NO_BSD_SOCKETS
 540                 [ExpectedException (typeof (PlatformNotSupportedException))]
 541 #endif
 542                 public void JoinMulticastGroup1_Socket_Closed ()
 543                 {
 544                         IPAddress mcast_addr = null;
 545
 546                         UdpClient client = new UdpClient (new IPEndPoint (IPAddress.Loopback, 1234));
 547                         client.Close ();
 548                         try {
 549                                 client.JoinMulticastGroup (mcast_addr);
 550                                 Assert.Fail ("#1");
 551                         } catch (ObjectDisposedException ex) {
 552                                 // Cannot access a disposed object
 553                                 Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#2");
 554                                 Assert.IsNull (ex.InnerException, "#3");
 555                                 Assert.IsNotNull (ex.Message, "#4");
 556                                 Assert.AreEqual (typeof (UdpClient).FullName, ex.ObjectName, "#5");
 557                         }
 558                 }
 559
 560                 [Test] // JoinMulticastGroup (IPAddress)
 561 #if FEATURE_NO_BSD_SOCKETS
 562                 [ExpectedException (typeof (PlatformNotSupportedException))]
 563 #endif
 564                 public void JoinMulticastGroup1_Socket_NotBound ()
 565                 {
 566                         IPAddress mcast_addr = IPAddress.Parse ("224.0.0.23");
 567
 568                         using (UdpClient client = new UdpClient (AddressFamily.InterNetwork)) {
 569                                 client.JoinMulticastGroup (mcast_addr);
 570                         }
 571                 }
 572
 573                 [Test] // JoinMulticastGroup (In32, IPAddress)
 574 #if FEATURE_NO_BSD_SOCKETS
 575                 [ExpectedException (typeof (PlatformNotSupportedException))]
 576 #endif
 577                 public void JoinMulticastGroup2_IPv4 ()
 578                 {
 579                         IPAddress mcast_addr = IPAddress.Parse ("224.0.0.23");
 580
 581                         using (UdpClient client = new UdpClient (new IPEndPoint (IPAddress.Any, 1234))) {
 582                                 try {
 583                                         client.JoinMulticastGroup (0, mcast_addr);
 584                                         Assert.Fail ("#1");
 585                                 } catch (SocketException ex) {
 586                                         // The attempted operation is not supported for the type of
 587                                         // object referenced
 588                                         Assert.AreEqual (typeof (SocketException), ex.GetType (), "#2");
 589                                         Assert.AreEqual (10045, ex.ErrorCode, "#3");
 590                                         Assert.IsNull (ex.InnerException, "#4");
 591                                         Assert.IsNotNull (ex.Message, "#5");
 592                                         Assert.AreEqual (10045, ex.NativeErrorCode, "#6");
 593                                         Assert.AreEqual (SocketError.OperationNotSupported, ex.SocketErrorCode, "#7");
 594                                 }
 595                         }
 596                 }
 597
 598                 [Test] // JoinMulticastGroup (In32, IPAddress)
 599 #if FEATURE_NO_BSD_SOCKETS
 600                 [ExpectedException (typeof (PlatformNotSupportedException))]
 601 #endif
 602                 public void JoinMulticastGroup2_IPv6 ()
 603                 {
 604                         if (!Socket.OSSupportsIPv6)
 605                                 Assert.Ignore ("IPv6 not enabled.");
 606
 607                         IPAddress mcast_addr = IPAddress.Parse ("ff02::1");
 608
 609                         using (UdpClient client = new UdpClient (new IPEndPoint (IPAddress.IPv6Any, 1234))) {
 610                                 client.JoinMulticastGroup (0, mcast_addr);
 611                         }
 612                 }
 613
 614                 [Test] // JoinMulticastGroup (Int32, IPAddress)
 615 #if FEATURE_NO_BSD_SOCKETS
 616                 [ExpectedException (typeof (PlatformNotSupportedException))]
 617 #endif
 618                 public void JoinMulticastGroup2_MulticastAddr_Null ()
 619                 {
 620                         using (UdpClient client = new UdpClient (new IPEndPoint (IPAddress.Loopback, 1234))) {
 621                                 try {
 622                                         client.JoinMulticastGroup (0, (IPAddress) null);
 623                                         Assert.Fail ("#1");
 624                                 } catch (ArgumentNullException ex) {
 625                                         Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 626                                         Assert.IsNull (ex.InnerException, "#3");
 627                                         Assert.IsNotNull (ex.Message, "#4");
 628                                         Assert.AreEqual ("multicastAddr", ex.ParamName, "#5");
 629                                 }
 630                         }
 631                 }
 632
 633                 [Test] // JoinMulticastGroup (Int32, IPAddress)
 634 #if FEATURE_NO_BSD_SOCKETS
 635                 [ExpectedException (typeof (PlatformNotSupportedException))]
 636 #endif
 637                 public void JoinMulticastGroup2_Socket_Closed ()
 638                 {
 639                         if (!Socket.OSSupportsIPv6)
 640                                 Assert.Ignore ("IPv6 not enabled.");
 641
 642                         IPAddress mcast_addr = null;
 643
 644                         UdpClient client = new UdpClient (new IPEndPoint (IPAddress.IPv6Any, 1234));
 645                         client.Close ();
 646                         try {
 647                                 client.JoinMulticastGroup (0, mcast_addr);
 648                                 Assert.Fail ("#1");
 649                         } catch (ObjectDisposedException ex) {
 650                                 // Cannot access a disposed object
 651                                 Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#2");
 652                                 Assert.IsNull (ex.InnerException, "#3");
 653                                 Assert.IsNotNull (ex.Message, "#4");
 654                                 Assert.AreEqual (typeof (UdpClient).FullName, ex.ObjectName, "#5");
 655                         }
 656                 }
 657
 658                 [Test] // JoinMulticastGroup (Int32, IPAddress)
 659 #if FEATURE_NO_BSD_SOCKETS
 660                 [ExpectedException (typeof (PlatformNotSupportedException))]
 661 #endif
 662                 public void JoinMulticastGroup2_Socket_NotBound ()
 663                 {
 664                         IPAddress mcast_addr = IPAddress.Parse ("ff02::1");
 665
 666                         using (UdpClient client = new UdpClient (AddressFamily.InterNetworkV6)) {
 667                                 client.JoinMulticastGroup (0, mcast_addr);
 668                         }
 669                 }
 670
 671                 [Test] // JoinMulticastGroup (IPAddress, Int32)
 672 #if FEATURE_NO_BSD_SOCKETS
 673                 [ExpectedException (typeof (PlatformNotSupportedException))]
 674 #endif
 675                 public void JoinMulticastGroup3_IPv4 ()
 676                 {
 677                         IPAddress mcast_addr = IPAddress.Parse ("224.0.0.23");
 678
 679                         using (UdpClient client = new UdpClient (new IPEndPoint (IPAddress.Any, 1234))) {
 680                                 client.JoinMulticastGroup (mcast_addr, 0);
 681                         }
 682
 683                         using (UdpClient client = new UdpClient (new IPEndPoint (IPAddress.Any, 1234))) {
 684                                 client.JoinMulticastGroup (mcast_addr, 255);
 685                         }
 686                 }
 687
 688                 [Test] // JoinMulticastGroup (IPAddress, Int32)
 689 #if FEATURE_NO_BSD_SOCKETS
 690                 [ExpectedException (typeof (PlatformNotSupportedException))]
 691 #endif
 692                 public void JoinMulticastGroup3_IPv6 ()
 693                 {
 694                         if (!Socket.OSSupportsIPv6)
 695                                 Assert.Ignore ("IPv6 not enabled.");
 696
 697                         IPAddress mcast_addr = IPAddress.Parse ("ff02::1");
 698
 699                         using (UdpClient client = new UdpClient (new IPEndPoint (IPAddress.IPv6Any, 1234))) {
 700                                 client.JoinMulticastGroup (mcast_addr, 0);
 701                         }
 702
 703                         using (UdpClient client = new UdpClient (new IPEndPoint (IPAddress.IPv6Any, 1234))) {
 704                                 client.JoinMulticastGroup (mcast_addr, 255);
 705                         }
 706                 }
 707
 708                 [Test] // JoinMulticastGroup (IPAddress, Int32)
 709 #if FEATURE_NO_BSD_SOCKETS
 710                 [ExpectedException (typeof (PlatformNotSupportedException))]
 711 #endif
 712                 public void JoinMulticastGroup3_MulticastAddr_Null ()
 713                 {
 714                         using (UdpClient client = new UdpClient (new IPEndPoint (IPAddress.Loopback, 1234))) {
 715                                 try {
 716                                         client.JoinMulticastGroup ((IPAddress) null, int.MaxValue);
 717                                         Assert.Fail ("#1");
 718                                 } catch (ArgumentNullException ex) {
 719                                         Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 720                                         Assert.IsNull (ex.InnerException, "#3");
 721                                         Assert.IsNotNull (ex.Message, "#4");
 722                                         Assert.AreEqual ("multicastAddr", ex.ParamName, "#5");
 723                                 }
 724                         }
 725                 }
 726
 727                 [Test] // JoinMulticastGroup (IPAddress, Int32)
 728 #if FEATURE_NO_BSD_SOCKETS
 729                 [ExpectedException (typeof (PlatformNotSupportedException))]
 730 #endif
 731                 public void JoinMulticastGroup3_Socket_Closed ()
 732                 {
 733                         IPAddress mcast_addr = null;
 734
 735                         UdpClient client = new UdpClient (new IPEndPoint (IPAddress.Any, 1234));
 736                         client.Close ();
 737                         try {
 738                                 client.JoinMulticastGroup (mcast_addr, 0);
 739                                 Assert.Fail ("#1");
 740                         } catch (ObjectDisposedException ex) {
 741                                 // Cannot access a disposed object
 742                                 Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#2");
 743                                 Assert.IsNull (ex.InnerException, "#3");
 744                                 Assert.IsNotNull (ex.Message, "#4");
 745                                 Assert.AreEqual (typeof (UdpClient).FullName, ex.ObjectName, "#5");
 746                         }
 747                 }
 748
 749                 [Test] // JoinMulticastGroup (IPAddress, Int32)
 750 #if FEATURE_NO_BSD_SOCKETS
 751                 [ExpectedException (typeof (PlatformNotSupportedException))]
 752 #endif
 753                 public void JoinMulticastGroup3_Socket_NotBound ()
 754                 {
 755                         IPAddress mcast_addr = IPAddress.Parse ("224.0.0.23");
 756
 757                         using (UdpClient client = new UdpClient (AddressFamily.InterNetwork)) {
 758                                 client.JoinMulticastGroup (mcast_addr, 5);
 759                         }
 760                 }
 761
 762                 [Test] // JoinMulticastGroup (IPAddress, IPAddress)
 763 #if FEATURE_NO_BSD_SOCKETS
 764                 [ExpectedException (typeof (PlatformNotSupportedException))]
 765 #endif
 766                 public void JoinMulticastGroup4_IPv4 ()
 767                 {
 768                         IPAddress mcast_addr = IPAddress.Parse ("224.0.0.23");
 769                         IPAddress local_addr = IPAddress.Any;
 770
 771                         using (UdpClient client = new UdpClient (new IPEndPoint (IPAddress.Any, 1234))) {
 772                                 client.JoinMulticastGroup (mcast_addr, local_addr);
 773                         }
 774                 }
 775
 776                 [Test] // JoinMulticastGroup (IPAddress, IPAddress)
 777 #if FEATURE_NO_BSD_SOCKETS
 778                 [ExpectedException (typeof (PlatformNotSupportedException))]
 779 #endif
 780                 public void JoinMulticastGroup4_IPv6 ()
 781                 {
 782                         if (!Socket.OSSupportsIPv6)
 783                                 Assert.Ignore ("IPv6 not enabled.");
 784
 785                         IPAddress mcast_addr = IPAddress.Parse ("ff02::1");
 786                         IPAddress local_addr = IPAddress.IPv6Any;
 787
 788                         using (UdpClient client = new UdpClient (new IPEndPoint (IPAddress.IPv6Any, 1234))) {
 789                                 try {
 790                                         client.JoinMulticastGroup (mcast_addr, local_addr);
 791                                         Assert.Fail ("#1");
 792                                 } catch (SocketException ex) {
 793                                         // The attempted operation is not supported for the type of
 794                                         // object referenced
 795                                         Assert.AreEqual (typeof (SocketException), ex.GetType (), "#2");
 796                                         Assert.AreEqual (10045, ex.ErrorCode, "#3");
 797                                         Assert.IsNull (ex.InnerException, "#4");
 798                                         Assert.IsNotNull (ex.Message, "#5");
 799                                         Assert.AreEqual (10045, ex.NativeErrorCode, "#6");
 800                                         Assert.AreEqual (SocketError.OperationNotSupported, ex.SocketErrorCode, "#7");
 801                                 }
 802                         }
 803                 }
 804
 805                 [Test] // JoinMulticastGroup (IPAddress, IPAddress)
 806 #if FEATURE_NO_BSD_SOCKETS
 807                 [ExpectedException (typeof (PlatformNotSupportedException))]
 808 #endif
 809                 public void JoinMulticastGroup4_LocalAddress_Null ()
 810                 {
 811                         IPAddress mcast_addr = IPAddress.Parse ("224.0.0.23");
 812
 813                         using (UdpClient client = new UdpClient (new IPEndPoint (IPAddress.Loopback, 1234))) {
 814                                 try {
 815                                         client.JoinMulticastGroup (mcast_addr, (IPAddress) null);
 816                                         Assert.Fail ("#1");
 817                                 } catch (ArgumentNullException ex) {
 818                                         Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 819                                         Assert.IsNull (ex.InnerException, "#3");
 820                                         Assert.IsNotNull (ex.Message, "#4");
 821                                         Assert.AreEqual ("mcint", ex.ParamName, "#5");
 822                                 }
 823                         }
 824                 }
 825
 826                 [Test] // JoinMulticastGroup (IPAddress, IPAddress)
 827 #if FEATURE_NO_BSD_SOCKETS
 828                 [ExpectedException (typeof (PlatformNotSupportedException))]
 829 #endif
 830                 public void JoinMulticastGroup4_MulticastAddr_Null ()
 831                 {
 832                         using (UdpClient client = new UdpClient (new IPEndPoint (IPAddress.Loopback, 1234))) {
 833                                 try {
 834                                         client.JoinMulticastGroup ((IPAddress) null, IPAddress.Loopback);
 835                                         Assert.Fail ("#1");
 836                                 } catch (ArgumentNullException ex) {
 837                                         Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 838                                         Assert.IsNull (ex.InnerException, "#3");
 839                                         Assert.IsNotNull (ex.Message, "#4");
 840                                         Assert.AreEqual ("group", ex.ParamName, "#5");
 841                                 }
 842                         }
 843                 }
 844
 845                 [Test] // JoinMulticastGroup (IPAddress, IPAddress)
 846 #if FEATURE_NO_BSD_SOCKETS
 847                 [ExpectedException (typeof (PlatformNotSupportedException))]
 848 #endif
 849                 public void JoinMulticastGroup4_Socket_Closed ()
 850                 {
 851                         IPAddress mcast_addr = null;
 852                         IPAddress local_addr = null;
 853
 854                         UdpClient client = new UdpClient (new IPEndPoint (IPAddress.Any, 1234));
 855                         client.Close ();
 856                         try {
 857                                 client.JoinMulticastGroup (mcast_addr, local_addr);
 858                                 Assert.Fail ("#1");
 859                         } catch (ObjectDisposedException ex) {
 860                                 // Cannot access a disposed object
 861                                 Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#2");
 862                                 Assert.IsNull (ex.InnerException, "#3");
 863                                 Assert.IsNotNull (ex.Message, "#4");
 864                                 Assert.AreEqual (typeof (UdpClient).FullName, ex.ObjectName, "#5");
 865                         }
 866                 }
 867
 868                 [Test] // JoinMulticastGroup (IPAddress, IPAddress)
 869 #if FEATURE_NO_BSD_SOCKETS
 870                 [ExpectedException (typeof (PlatformNotSupportedException))]
 871 #endif
 872                 public void JoinMulticastGroup4_Socket_NotBound ()
 873                 {
 874                         IPAddress mcast_addr = IPAddress.Parse ("224.0.0.23");
 875                         IPAddress local_addr = Dns.GetHostEntry (string.Empty).AddressList [0];
 876
 877                         using (UdpClient client = new UdpClient (AddressFamily.InterNetwork)) {
 878                                 client.JoinMulticastGroup (mcast_addr, local_addr);
 879                         }
 880                 }
 881
 882                 [Test]
 883 #if FEATURE_NO_BSD_SOCKETS
 884                 [ExpectedException (typeof (PlatformNotSupportedException))]
 885 #endif
 886                 public void CloseInReceive ()
 887                 {
 888                         UdpClient client = null;
 889                         var rnd = new Random ();
 890                         for (int i = 0, max = 5; i < max; i++) {
 891                                 int port = rnd.Next (1025, 65534);
 892                                 try {
 893                                         client = new UdpClient (port);
 894                                         break;
 895                                 } catch (Exception) {
 896                                         if (i == max - 1)
 897                                                 throw;
 898                                 }
 899                         }
 900
 901                         ManualResetEvent ready = new ManualResetEvent (false);
 902                         bool got_exc = false;
 903
 904                         Task receive_task = Task.Factory.StartNew (() => {
 905                                 IPEndPoint ep = new IPEndPoint (IPAddress.Any, 0);
 906                                 try {
 907                                         ready.Set ();
 908                                         client.Receive(ref ep);
 909                                 } catch (SocketException) {
 910                                         got_exc = true;
 911                                 } finally {
 912                                         client.Close ();
 913                                 }
 914                         });
 915
 916                         ready.WaitOne (2000);
 917                         Thread.Sleep (20);
 918                         client.Close();
 919
 920                         Assert.IsTrue (receive_task.Wait (1000));
 921                         Assert.IsTrue (got_exc);
 922                 }
 923
 924                 // Test for bug 324033
 925                 [Test]
 926 #if FEATURE_NO_BSD_SOCKETS
 927                 [ExpectedException (typeof (PlatformNotSupportedException))]
 928 #endif
 929                 public void JoinMulticastGroupWithLocal ()
 930                 {
 931                         UdpClient client = new UdpClient (9001);
 932                         IPAddress mcast_addr = IPAddress.Parse ("224.0.0.24");
 933                         IPAddress local_addr = IPAddress.Any;
 934
 935                         try {
 936                                 client.JoinMulticastGroup (mcast_addr, local_addr);
 937                         } finally {
 938                                 client.Close ();
 939                         }
 940                 }
 941
 942                 [Test]
 943 #if FEATURE_NO_BSD_SOCKETS
 944                 [ExpectedException (typeof (PlatformNotSupportedException))]
 945 #else
 946                 [ExpectedException (typeof(ArgumentNullException))]
 947 #endif
 948                 public void BeginSendNull ()
 949                 {
 950                         UdpClient client = new UdpClient ();
 951                         client.BeginSend (null, 0, null, null);
 952                         client.Close ();
 953                 }
 954
 955                 static bool BSSent = false;
 956                 static int BSBytes;
 957                 static ManualResetEvent BSCalledBack = new ManualResetEvent (false);
 958
 959                 private static void BSCallback (IAsyncResult asyncResult)
 960                 {
 961                         UdpClient client = (UdpClient)asyncResult.AsyncState;
 962
 963                         BSBytes = client.EndSend (asyncResult);
 964
 965                         BSSent = true;
 966                         BSCalledBack.Set ();
 967                 }
 968
 969                 [Test]
 970 #if FEATURE_NO_BSD_SOCKETS
 971                 [ExpectedException (typeof (PlatformNotSupportedException))]
 972 #endif
 973                 public void BeginSend ()
 974                 {
 975                         UdpClient client = new UdpClient ();
 976                         byte[] bytes = new byte[] {10, 11, 12, 13};
 977
 978                         try {
 979                                 client.BeginSend (bytes, bytes.Length, new AsyncCallback (BSCallback), client);
 980                                 Assert.Fail ("BeginSend #1");
 981                         } catch (SocketException ex) {
 982                                 Assert.AreEqual (10057, ex.ErrorCode,
 983                                                  "BeginSend #2");
 984                         }
 985
 986                         try {
 987                                 client.BeginSend (bytes, bytes.Length, null, new AsyncCallback (BSCallback), client);
 988                                 Assert.Fail ("BeginSend #3");
 989                         } catch (SocketException ex) {
 990                                 Assert.AreEqual (10057, ex.ErrorCode,
 991                                                  "BeginSend #4");
 992                         }
 993
 994                         IPAddress[] addresses = Dns.GetHostEntry (string.Empty).AddressList;
 995                         IPEndPoint ep = null;
 996                         foreach (IPAddress a in addresses) {
 997                                 if (a.AddressFamily == AddressFamily.InterNetwork) {
 998                                         ep = new IPEndPoint (a, 1236);
 999                                         break;
1000                                 }
1001                         }
1002                         BSCalledBack.Reset ();
1003
1004                         client.BeginSend (bytes, bytes.Length, ep,
1005                                           new AsyncCallback (BSCallback),
1006                                           client);
1007                         if (BSCalledBack.WaitOne (2000, false) == false) {
1008                                 Assert.Fail ("BeginSend wait timed out");
1009                         }
1010
1011                         Assert.AreEqual (true, BSSent, "BeginSend #5");
1012                         Assert.AreEqual (4, BSBytes, "BeginSend #6");
1013
1014                         client.Close ();
1015                 }
1016
1017                 static bool BRReceived = false;
1018                 static byte[] BRBytes;
1019                 static IPEndPoint BRFrom;
1020                 static ManualResetEvent BRCalledBack = new ManualResetEvent (false);
1021
1022                 private static void BRCallback (IAsyncResult asyncResult)
1023                 {
1024                         UdpClient client = (UdpClient)asyncResult.AsyncState;
1025
1026                         BRBytes = client.EndReceive (asyncResult, ref BRFrom);
1027
1028                         BRReceived = true;
1029                         BRCalledBack.Set ();
1030                 }
1031
1032                 [Test]
1033 #if FEATURE_NO_BSD_SOCKETS
1034                 [ExpectedException (typeof (PlatformNotSupportedException))]
1035 #endif
1036                 public void BeginReceive ()
1037                 {
1038                         UdpClient client = new UdpClient (1237);
1039
1040                         BRCalledBack.Reset ();
1041
1042                         client.BeginReceive (BRCallback, client);
1043
1044                         IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 1237);
1045                         byte[] send_bytes = new byte[] {10, 11, 12, 13};
1046                         client.Send (send_bytes, send_bytes.Length, ep);
1047
1048                         if (BRCalledBack.WaitOne (2000, false) == false) {
1049                                 Assert.Fail ("BeginReceive wait timed out");
1050                         }
1051
1052                         Assert.AreEqual (true, BRReceived, "BeginReceive #1");
1053                         Assert.AreEqual (4, BRBytes.Length, "BeginReceive #2");
1054                         Assert.AreEqual (ep. Port, BRFrom.Port, "BeginReceive #3");
1055                         Assert.AreEqual (ep.Address, BRFrom.Address, "BeginReceive #4");
1056
1057                         client.Close ();
1058                 }
1059
1060                 [Test]
1061 #if FEATURE_NO_BSD_SOCKETS
1062                 [ExpectedException (typeof (PlatformNotSupportedException))]
1063 #endif
1064                 public void Available ()
1065                 {
1066                         using (UdpClient client = new UdpClient (1238)) {
1067                                 IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 1238);
1068                                 byte[] bytes = new byte[] {10, 11, 12, 13};
1069
1070                                 int res = client.Send (bytes, bytes.Length, ep);
1071                                 Assert.AreEqual (bytes.Length, res, "Send");
1072
1073                                 // that might happen too quickly, data sent and not yet received/available
1074                                 Thread.Sleep (100);
1075                                 int avail = client.Available;
1076
1077                                 Assert.AreEqual (bytes.Length, avail, "Available #1");
1078
1079                                 client.Close ();
1080                         }
1081                 }
1082
1083                 [Test]
1084                 [Category ("NotWorking")]  // Using PMTU settings workaround on Linux, default true
1085                 public void DontFragmentDefault ()
1086                 {
1087                         UdpClient client = new UdpClient ();
1088
1089                         /* Ignore the docs, testing shows the default
1090                          * here is in fact false
1091                          */
1092                         Assert.AreEqual (false, client.DontFragment, "DontFragmentDefault");
1093
1094                         client.Close ();
1095                 }
1096
1097                 [Test]
1098 #if FEATURE_NO_BSD_SOCKETS
1099                 [ExpectedException (typeof (PlatformNotSupportedException))]
1100 #endif
1101                 public void EnableBroadcastDefault ()
1102                 {
1103                         UdpClient client = new UdpClient ();
1104
1105                         Assert.AreEqual (false, client.EnableBroadcast, "EnableBroadcastDefault");
1106
1107                         client.Close ();
1108                 }
1109
1110                 /* Can't test the default for ExclusiveAddressUse as
1111                  * it's different on different versions and service
1112                  * packs of windows
1113                  */
1114                 [Test]
1115                 [Category ("NotWorking")] // Not supported on Linux
1116                 public void ExclusiveAddressUseUnbound ()
1117                 {
1118                         UdpClient client = new UdpClient ();
1119
1120                         client.ExclusiveAddressUse = true;
1121
1122                         Assert.AreEqual (true, client.ExclusiveAddressUse, "ExclusiveAddressUseUnbound");
1123
1124                         client.Close ();
1125                 }
1126
1127                 [Test]
1128                 [ExpectedException (typeof(InvalidOperationException))]
1129                 [Category ("NotWorking")] // Not supported on Linux
1130                 public void ExclusiveAddressUseBound ()
1131                 {
1132                         UdpClient client = new UdpClient (1239);
1133
1134                         client.ExclusiveAddressUse = true;
1135
1136                         client.Close ();
1137                 }
1138
1139                 [Test]
1140 #if FEATURE_NO_BSD_SOCKETS
1141                 [ExpectedException (typeof (PlatformNotSupportedException))]
1142 #endif
1143                 public void MulticastLoopbackDefault ()
1144                 {
1145                         UdpClient client = new UdpClient ();
1146
1147                         Assert.AreEqual (true, client.MulticastLoopback, "MulticastLoopbackDefault");
1148
1149                         client.Close ();
1150                 }
1151
1152                 [Test] // #6057
1153 #if FEATURE_NO_BSD_SOCKETS
1154                 [ExpectedException (typeof (PlatformNotSupportedException))]
1155 #endif
1156                 public void ReceiveIPv6 ()
1157                 {
1158                         if (!Socket.OSSupportsIPv6)
1159                                 Assert.Ignore ("IPv6 not enabled.");
1160
1161                         int PORT = 9997;
1162                         using(var udpClient = new UdpClient (PORT, AddressFamily.InterNetworkV6))
1163                         using(var udpClient2 = new UdpClient (PORT+1, AddressFamily.InterNetworkV6))
1164                         {
1165                                 var dataSent = new byte [] {1,2,3};
1166                                 udpClient2.SendAsync (dataSent, dataSent.Length, "::1", PORT);
1167
1168                                 IPEndPoint endPoint = new IPEndPoint (IPAddress.IPv6Any, 0);
1169                                 var data = udpClient.Receive (ref endPoint);
1170
1171                                 Assert.AreEqual (dataSent.Length, data.Length);
1172                         }
1173                 }
1174
1175                 /* No test for Ttl default as it is platform dependent */
1176
1177                 class MyUdpClient : UdpClient
1178                 {
1179                         public MyUdpClient ()
1180                         {
1181                         }
1182
1183                         public MyUdpClient (AddressFamily family)
1184                                 : base (family)
1185                         {
1186                         }
1187
1188                         public MyUdpClient (Int32 port)
1189                                 : base (port)
1190                         {
1191                         }
1192
1193
1194                         public MyUdpClient (IPEndPoint localEP)
1195                                 : base (localEP)
1196                         {
1197                         }
1198
1199                         public MyUdpClient (int port, AddressFamily family)
1200                                 : base (port, family)
1201                         {
1202                         }
1203
1204                         public MyUdpClient (string hostname, int port)
1205                                 : base (hostname, port)
1206                         {
1207                         }
1208
1209                         public new bool Active {
1210                                 get { return base.Active; }
1211                                 set { base.Active = value; }
1212                         }
1213
1214                 }
1215         }
1216 }