Author: dick
Date: 2007-01-11 08:31:42 -0500 (Thu, 11 Jan 2007)
New Revision: 70854

Modified:
   trunk/mcs/class/System/Test/System.Net.Sockets/ChangeLog
   trunk/mcs/class/System/Test/System.Net.Sockets/SocketTest.cs
   trunk/mcs/class/System/Test/System.Net.Sockets/UdpClientTest.cs
Log:

2007-01-11  Dick Porter  <[EMAIL PROTECTED]>

        * SocketTest.cs: 
        * UdpClientTest.cs: Test 2.0 additions




Modified: trunk/mcs/class/System/Test/System.Net.Sockets/ChangeLog
===================================================================
--- trunk/mcs/class/System/Test/System.Net.Sockets/ChangeLog    2007-01-11 
13:30:28 UTC (rev 70853)
+++ trunk/mcs/class/System/Test/System.Net.Sockets/ChangeLog    2007-01-11 
13:31:42 UTC (rev 70854)
@@ -1,3 +1,8 @@
+2007-01-11  Dick Porter  <[EMAIL PROTECTED]>
+
+       * SocketTest.cs: 
+       * UdpClientTest.cs: Test 2.0 additions
+
 2006-11-24  Dick Porter  <[EMAIL PROTECTED]>
 
        * SocketTest.cs: Add a test for async non blocking connects that

Modified: trunk/mcs/class/System/Test/System.Net.Sockets/SocketTest.cs
===================================================================
--- trunk/mcs/class/System/Test/System.Net.Sockets/SocketTest.cs        
2007-01-11 13:30:28 UTC (rev 70853)
+++ trunk/mcs/class/System/Test/System.Net.Sockets/SocketTest.cs        
2007-01-11 13:31:42 UTC (rev 70854)
@@ -501,6 +501,2015 @@
 
                        s.Shutdown (0);
                }
+
+#if NET_2_0
+               [Test]
+               public void SocketInformationCtor ()
+               {
+               }
+               
+               [Test]
+               public void DontFragmentDefaultTcp ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Stream,
+                                                 ProtocolType.Tcp);
+                       
+                       Assertion.AssertEquals ("DontFragmentDefaultTcp",
+                                               false, sock.DontFragment);
+
+                       sock.Close ();
+               }
+
+               [Test]
+               public void DontFragmentChangeTcp ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Stream,
+                                                 ProtocolType.Tcp);
+                       
+                       sock.DontFragment = true;
+                       
+                       Assertion.AssertEquals ("DontFragmentChangeTcp",
+                                               true, sock.DontFragment);
+
+                       sock.Close ();
+               }
+               
+               [Test]
+               public void DontFragmentDefaultUdp ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Dgram,
+                                                 ProtocolType.Udp);
+                       
+                       Assertion.AssertEquals ("DontFragmentDefaultUdp",
+                                               false, sock.DontFragment);
+
+                       sock.Close ();
+               }
+
+               [Test]
+               public void DontFragmentChangeUdp ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Dgram,
+                                                 ProtocolType.Udp);
+                       
+                       sock.DontFragment = true;
+                       
+                       Assertion.AssertEquals ("DontFragmentChangeUdp",
+                                               true, sock.DontFragment);
+
+                       sock.Close ();
+               }
+
+               [Test]
+               [ExpectedException (typeof(ObjectDisposedException))]
+               public void DontFragmentClosed ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Stream,
+                                                 ProtocolType.Tcp);
+                       
+                       sock.Close ();
+                       
+                       bool val = sock.DontFragment;
+               }
+               
+               [Test]
+               [Category ("NotWorking")] // Need to pick a non-IP 
AddressFamily that "works" on both mono and ms, this one only works on ms
+               public void DontFragment ()
+               {
+                       Socket sock = new Socket (AddressFamily.NetBios,
+                                                 SocketType.Seqpacket,
+                                                 ProtocolType.Unspecified);
+                       
+                       try {
+                               sock.DontFragment = true;
+                               Assert.Fail ("DontFragment #1");
+                       } catch (NotSupportedException) {
+                       } catch {
+                               Assert.Fail ("DontFragment #2");
+                       } finally {
+                               sock.Close ();
+                       }
+               }
+               
+               [Test]
+               public void EnableBroadcastDefaultTcp ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Stream,
+                                                 ProtocolType.Tcp);
+                       
+                       try {
+                               bool value = sock.EnableBroadcast;
+                               Assert.Fail ("EnableBroadcastDefaultTcp #1");
+                       } catch (SocketException ex) {
+                               Assert.AreEqual (10042, ex.ErrorCode, 
"EnableBroadcastDefaultTcp #2");
+                       } catch {
+                               Assert.Fail ("EnableBroadcastDefaultTcp #2");
+                       } finally {
+                               sock.Close ();
+                       }
+               }
+
+               [Test]
+               public void EnableBroadcastDefaultUdp ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Dgram,
+                                                 ProtocolType.Udp);
+                       
+                       Assertion.AssertEquals ("EnableBroadcastDefaultUdp",
+                                               false, sock.EnableBroadcast);
+
+                       sock.Close ();
+               }
+               
+               [Test]
+               public void EnableBroadcastChangeTcp ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Stream,
+                                                 ProtocolType.Tcp);
+                       
+                       try {
+                               sock.EnableBroadcast = true;
+                               Assert.Fail ("EnableBroadcastChangeTcp #1");
+                       } catch (SocketException ex) {
+                               Assert.AreEqual (10042, ex.ErrorCode, 
"EnableBroadcastChangeTcp #2");
+                       } catch {
+                               Assert.Fail ("EnableBroadcastChangeTcp #2");
+                       } finally {
+                               sock.Close ();
+                       }
+               }
+               
+               [Test]
+               public void EnableBroadcastChangeUdp ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Dgram,
+                                                 ProtocolType.Udp);
+                       
+                       sock.EnableBroadcast = true;
+                       
+                       Assertion.AssertEquals ("EnableBroadcastChangeUdp",
+                                               true, sock.EnableBroadcast);
+
+                       sock.Close ();
+               }
+
+               [Test]
+               [ExpectedException (typeof(ObjectDisposedException))]
+               public void EnableBroadcastClosed ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Dgram,
+                                                 ProtocolType.Udp);
+                       
+                       sock.Close ();
+                       
+                       bool val = sock.EnableBroadcast;
+               }
+
+               /* Can't test the default for ExclusiveAddressUse as
+                * it's different on different versions and service
+                * packs of windows
+                */
+               [Test]
+               [Category ("NotWorking")] // Not supported on Linux
+               public void ExclusiveAddressUseUnbound ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Stream,
+                                                 ProtocolType.Tcp);
+                       
+                       sock.ExclusiveAddressUse = true;
+                       
+                       Assertion.AssertEquals ("ExclusiveAddressUseUnbound",
+                                               true,
+                                               sock.ExclusiveAddressUse);
+                       
+                       sock.Close ();
+               }
+
+               [Test]
+               [ExpectedException (typeof(InvalidOperationException))]
+               [Category ("NotWorking")] // Not supported on Linux
+               public void ExclusiveAddressUseBound ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Stream,
+                                                 ProtocolType.Tcp);
+                       
+                       sock.Bind (new IPEndPoint (IPAddress.Any, 1235));
+                       sock.ExclusiveAddressUse = true;
+                       sock.Close ();
+               }
+
+               [Test]
+               [ExpectedException (typeof(ObjectDisposedException))]
+               public void ExclusiveAddressUseClosed ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Stream,
+                                                 ProtocolType.Tcp);
+                       
+                       sock.Close ();
+                       
+                       bool val = sock.ExclusiveAddressUse;
+               }
+               
+               [Test]
+               public void IsBoundTcp ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Stream,
+                                                 ProtocolType.Tcp);
+                       IPEndPoint ep = new IPEndPoint (IPAddress.Loopback,
+                                                       BogusPort);
+                       
+                       Assertion.AssertEquals ("IsBoundTcp #1", false,
+                                               sock.IsBound);
+                       
+                       sock.Bind (ep);
+                       Assertion.AssertEquals ("IsBoundTcp #2", true,
+                                               sock.IsBound);
+
+                       sock.Listen (1);
+                       
+                       Socket sock2 = new Socket (AddressFamily.InterNetwork,
+                                                  SocketType.Stream,
+                                                  ProtocolType.Tcp);
+                       
+                       Assertion.AssertEquals ("IsBoundTcp #3", false,
+                                               sock2.IsBound);
+                       
+                       sock2.Connect (ep);
+                       Assertion.AssertEquals ("IsBoundTcp #4", true,
+                                               sock2.IsBound);
+                       
+                       sock2.Close ();
+                       Assertion.AssertEquals ("IsBoundTcp #5", true,
+                                               sock2.IsBound);
+
+                       sock.Close ();
+                       Assertion.AssertEquals ("IsBoundTcp #6", true,
+                                               sock.IsBound);
+               }
+
+               [Test]
+               public void IsBoundUdp ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Dgram,
+                                                 ProtocolType.Udp);
+                       IPEndPoint ep = new IPEndPoint (IPAddress.Loopback,
+                                                       BogusPort);
+                       
+                       Assertion.AssertEquals ("IsBoundUdp #1", false,
+                                               sock.IsBound);
+                       
+                       sock.Bind (ep);
+                       Assertion.AssertEquals ("IsBoundUdp #2", true,
+                                               sock.IsBound);
+                       
+                       sock.Close ();
+                       Assertion.AssertEquals ("IsBoundUdp #3", true,
+                                               sock.IsBound);
+                       
+
+                       sock = new Socket (AddressFamily.InterNetwork,
+                                          SocketType.Dgram,
+                                          ProtocolType.Udp);
+                       
+                       Assertion.AssertEquals ("IsBoundUdp #4", false,
+                                               sock.IsBound);
+                       
+                       sock.Connect (ep);
+                       Assertion.AssertEquals ("IsBoundUdp #5", true,
+                                               sock.IsBound);
+                       
+                       sock.Close ();
+                       Assertion.AssertEquals ("IsBoundUdp #6", true,
+                                               sock.IsBound);
+               }
+
+               [Test]
+               /* Should not throw an exception */
+               public void IsBoundClosed ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Stream,
+                                                 ProtocolType.Tcp);
+                       
+                       sock.Close ();
+                       
+                       bool val = sock.IsBound;
+               }
+               
+               /* Nothing much to test for LingerState */
+               
+               [Test]
+               public void MulticastLoopbackDefaultTcp ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Stream,
+                                                 ProtocolType.Tcp);
+                       
+                       try {
+                               bool value = sock.MulticastLoopback;
+                               Assert.Fail ("MulticastLoopbackDefaultTcp #1");
+                       } catch (SocketException ex) {
+                               Assert.AreEqual (10042, ex.ErrorCode, 
"MulticastLoopbackDefaultTcp #2");
+                       } catch {
+                               Assert.Fail ("MulticastLoopbackDefaultTcp #2");
+                       } finally {
+                               sock.Close ();
+                       }
+               }
+
+               [Test]
+               public void MulticastLoopbackChangeTcp ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Stream,
+                                                 ProtocolType.Tcp);
+                       
+                       try {
+                               sock.MulticastLoopback = false;
+                               Assert.Fail ("MulticastLoopbackChangeTcp #1");
+                       } catch (SocketException ex) {
+                               Assert.AreEqual (10042, ex.ErrorCode, 
"MulticastLoopbackChangeTcp #2");
+                       } catch {
+                               Assert.Fail ("MulticastLoopbackChangeTcp #2");
+                       } finally {
+                               sock.Close ();
+                       }
+               }
+               
+               [Test]
+               public void MulticastLoopbackDefaultUdp ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Dgram,
+                                                 ProtocolType.Udp);
+                       
+                       Assertion.AssertEquals ("MulticastLoopbackDefaultUdp",
+                                               true, sock.MulticastLoopback);
+                       
+                       sock.Close ();
+               }
+               
+               [Test]
+               public void MulticastLoopbackChangeUdp ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Dgram,
+                                                 ProtocolType.Udp);
+                       
+                       sock.MulticastLoopback = false;
+                       
+                       Assertion.AssertEquals ("MulticastLoopbackChangeUdp",
+                                               false, sock.MulticastLoopback);
+                       
+                       sock.Close ();
+               }
+
+               [Test]
+               [ExpectedException (typeof(ObjectDisposedException))]
+               public void MulticastLoopbackClosed ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Stream,
+                                                 ProtocolType.Tcp);
+                       
+                       sock.Close ();
+                       
+                       bool val = sock.MulticastLoopback;
+               }
+               
+               /* OSSupportsIPv6 depends on the environment */
+               
+               [Test]
+               public void ReceiveBufferSizeDefault ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Stream,
+                                                 ProtocolType.Tcp);
+                       
+                       Assertion.AssertEquals ("ReceiveBufferSizeDefault",
+                                               8192, sock.ReceiveBufferSize);
+                       
+                       sock.Close ();
+               }
+               
+               [Test]
+               public void ReceiveBufferSizeDefaultUdp ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Dgram,
+                                                 ProtocolType.Udp);
+                       
+                       Assertion.AssertEquals ("ReceiveBufferSizeDefaultUdp",
+                                               8192, sock.ReceiveBufferSize);
+                       
+                       sock.Close ();
+               }
+
+               [Test]
+               public void ReceiveBufferSizeChange ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Stream,
+                                                 ProtocolType.Tcp);
+                       
+                       sock.ReceiveBufferSize = 16384;
+                       
+                       Assertion.AssertEquals ("ReceiveBufferSizeChange",
+                                               16384, sock.ReceiveBufferSize);
+                       
+                       sock.Close ();
+               }
+
+               [Test]
+               [ExpectedException (typeof(ObjectDisposedException))]
+               public void ReceiveBufferSizeClosed ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Stream,
+                                                 ProtocolType.Tcp);
+                       
+                       sock.Close ();
+                       
+                       int val = sock.ReceiveBufferSize;
+               }
+               
+               [Test]
+               public void SendBufferSizeDefault ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Stream,
+                                                 ProtocolType.Tcp);
+                       
+                       Assertion.AssertEquals ("SendBufferSizeDefault",
+                                               8192, sock.SendBufferSize);
+                       
+                       sock.Close ();
+               }
+               
+               [Test]
+               public void SendBufferSizeDefaultUdp ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Dgram,
+                                                 ProtocolType.Udp);
+                       
+                       Assertion.AssertEquals ("SendBufferSizeDefaultUdp",
+                                               8192, sock.SendBufferSize);
+                       
+                       sock.Close ();
+               }
+
+               [Test]
+               public void SendBufferSizeChange ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Stream,
+                                                 ProtocolType.Tcp);
+                       
+                       sock.SendBufferSize = 16384;
+                       
+                       Assertion.AssertEquals ("SendBufferSizeChange",
+                                               16384, sock.SendBufferSize);
+                       
+                       sock.Close ();
+               }
+
+               [Test]
+               [ExpectedException (typeof(ObjectDisposedException))]
+               public void SendBufferSizeClosed ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Stream,
+                                                 ProtocolType.Tcp);
+                       
+                       sock.Close ();
+                       
+                       int val = sock.SendBufferSize;
+               }
+               
+               /* No test for TTL default as it's platform dependent */
+               [Test]
+               public void TtlChange ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Stream,
+                                                 ProtocolType.Tcp);
+                       
+                       sock.Ttl = 255;
+                       
+                       Assertion.AssertEquals ("TtlChange", 255, sock.Ttl);
+                       
+                       sock.Close ();
+               }
+
+               [Test]
+               public void TtlChangeOverflow ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Stream,
+                                                 ProtocolType.Tcp);
+                       
+                       try {
+                               sock.Ttl = 256;
+                               Assert.Fail ("TtlChangeOverflow #1");
+                       } catch (SocketException ex) {
+                               Assert.AreEqual (10022, ex.ErrorCode,
+                                                "TtlChangeOverflow #2");
+                       } catch {
+                               Assert.Fail ("TtlChangeoverflow #3");
+                       } finally {
+                               sock.Close ();
+                       }
+               }
+               
+/* Apparently you can set TTL=0 on the ms runtime!!
+                       try {
+                               sock.Ttl = 0;
+                               Assert.Fail ("TtlChangeOverflow #4");
+                       } catch (SocketException ex) {
+                               Assert.AreEqual (10022, ex.ErrorCode,
+                                                "TtlChangeOverflow #5");
+                       } catch {
+                               Assert.Fail ("TtlChangeOverflow #6");
+                       } finally {
+                               sock.Close ();
+                       }
+*/
+
+               [Test]
+               [ExpectedException (typeof(ObjectDisposedException))]
+               public void TtlClosed ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Stream,
+                                                 ProtocolType.Tcp);
+                       
+                       sock.Close ();
+                       
+                       int val = sock.Ttl;
+               }
+               
+               [Test]
+               public void UseOnlyOverlappedIODefault ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Stream,
+                                                 ProtocolType.Tcp);
+                       
+                       Assertion.AssertEquals ("UseOnlyOverlappedIODefault",
+                                               false,
+                                               sock.UseOnlyOverlappedIO);
+                       
+                       sock.Close ();
+               }
+
+               [Test]
+               public void UseOnlyOverlappedIOChange ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Stream,
+                                                 ProtocolType.Tcp);
+                       
+                       sock.UseOnlyOverlappedIO = true;
+                       
+                       Assertion.AssertEquals ("UseOnlyOverlappedIOChange",
+                                               true,
+                                               sock.UseOnlyOverlappedIO);
+                       
+                       sock.Close ();
+               }
+
+               [Test]
+               /* Should not throw an exception */
+               public void UseOnlyOverlappedIOClosed ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Stream,
+                                                 ProtocolType.Tcp);
+                       
+                       sock.Close ();
+                       
+                       bool val = sock.UseOnlyOverlappedIO;
+               }
+               
+               [Test]
+               public void SendTimeoutDefault ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Stream,
+                                                 ProtocolType.Tcp);
+                       
+                       Assertion.AssertEquals ("SendTimeoutDefault",
+                                               0, sock.SendTimeout);
+                       
+                       sock.Close ();
+               }
+
+               [Test]
+               public void SendTimeoutChange ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Stream,
+                                                 ProtocolType.Tcp);
+                       
+                       /* Should be rounded up to 500, according to
+                        * the MSDN docs, but the MS runtime doesn't
+                        */
+                       sock.SendTimeout = 50;
+                       Assertion.AssertEquals ("SendTimeoutChange #1",
+                                               50, sock.SendTimeout);
+                       
+                       sock.SendTimeout = 2000;
+                       Assertion.AssertEquals ("SendTimeoutChange #2",
+                                               2000, sock.SendTimeout);
+                       
+                       sock.SendTimeout = 0;
+                       Assertion.AssertEquals ("SendTimeoutChange #3",
+                                               0, sock.SendTimeout);
+                       
+                       /* Should be the same as setting 0 */
+                       sock.SendTimeout = -1;
+                       Assertion.AssertEquals ("SendTimeoutChange #4",
+                                               0, sock.SendTimeout);
+
+                       sock.SendTimeout = 65536;
+                       Assertion.AssertEquals ("SendTimeoutChange #5",
+                                               65536, sock.SendTimeout);
+                       
+                       try {
+                               sock.SendTimeout = -2;
+                               Assert.Fail ("SendTimeoutChange #8");
+                       } catch (ArgumentOutOfRangeException) {
+                       } catch {
+                               Assert.Fail ("SendTimeoutChange #9");
+                       } finally {
+                               sock.Close ();
+                       }
+               }
+
+               [Test]
+               [ExpectedException (typeof(ObjectDisposedException))]
+               public void SendTimeoutClosed ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Stream,
+                                                 ProtocolType.Tcp);
+                       
+                       sock.Close ();
+                       
+                       int val = sock.SendTimeout;
+               }
+               
+               [Test]
+               public void ReceiveTimeoutDefault ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Stream,
+                                                 ProtocolType.Tcp);
+                       
+                       Assertion.AssertEquals ("ReceiveTimeoutDefault",
+                                               0, sock.ReceiveTimeout);
+                       
+                       sock.Close ();
+               }
+
+               [Test]
+               public void ReceiveTimeoutChange ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Stream,
+                                                 ProtocolType.Tcp);
+                       
+                       sock.ReceiveTimeout = 50;
+                       Assertion.AssertEquals ("ReceiveTimeoutChange #1",
+                                               50, sock.ReceiveTimeout);
+                       
+                       sock.ReceiveTimeout = 2000;
+                       Assertion.AssertEquals ("ReceiveTimeoutChange #2",
+                                               2000, sock.ReceiveTimeout);
+                       
+                       sock.ReceiveTimeout = 0;
+                       Assertion.AssertEquals ("ReceiveTimeoutChange #3",
+                                               0, sock.ReceiveTimeout);
+                       
+                       /* Should be the same as setting 0 */
+                       sock.ReceiveTimeout = -1;
+                       Assertion.AssertEquals ("ReceiveTimeoutChange #4",
+                                               0, sock.ReceiveTimeout);
+
+                       sock.ReceiveTimeout = 65536;
+                       Assertion.AssertEquals ("ReceiveTimeoutChange #5",
+                                               65536, sock.ReceiveTimeout);
+                       
+                       try {
+                               sock.ReceiveTimeout = -2;
+                               Assert.Fail ("ReceiveTimeoutChange #8");
+                       } catch (ArgumentOutOfRangeException) {
+                       } catch {
+                               Assert.Fail ("ReceiveTimeoutChange #9");
+                       } finally {
+                               sock.Close ();
+                       }
+               }
+
+               [Test]
+               [ExpectedException (typeof(ObjectDisposedException))]
+               public void ReceiveTimeoutClosed ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Stream,
+                                                 ProtocolType.Tcp);
+                       
+                       sock.Close ();
+                       
+                       int val = sock.ReceiveTimeout;
+               }
+               
+               [Test]
+               public void NoDelayDefaultTcp ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Stream,
+                                                 ProtocolType.Tcp);
+                       
+                       Assertion.AssertEquals ("NoDelayDefaultTcp", false,
+                                               sock.NoDelay);
+                       
+                       sock.Close ();
+               }
+
+               [Test]
+               public void NoDelayChangeTcp ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Stream,
+                                                 ProtocolType.Tcp);
+                       
+                       sock.NoDelay = true;
+                       
+                       Assertion.AssertEquals ("NoDelayChangeTcp", true,
+                                               sock.NoDelay);
+                       
+                       sock.Close ();
+               }
+               
+               [Test]
+               public void NoDelayDefaultUdp ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Dgram,
+                                                 ProtocolType.Udp);
+                       
+                       try {
+                               bool val = sock.NoDelay;
+                               Assert.Fail ("NoDelayDefaultUdp #1");
+                       } catch (SocketException ex) {
+                               Assert.AreEqual (10042, ex.ErrorCode,
+                                                "NoDelayDefaultUdp #2");
+                       } catch {
+                               Assert.Fail ("NoDelayDefaultUdp #3");
+                       } finally {
+                               sock.Close ();
+                       }
+               }
+
+               [Test]
+               public void NoDelayChangeUdp ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Dgram,
+                                                 ProtocolType.Udp);
+                       
+                       try {
+                               sock.NoDelay = true;
+                               Assert.Fail ("NoDelayChangeUdp #1");
+                       } catch (SocketException ex) {
+                               Assert.AreEqual (10042, ex.ErrorCode,
+                                                "NoDelayChangeUdp #2");
+                       } catch {
+                               Assert.Fail ("NoDelayChangeUdp #3");
+                       } finally {
+                               sock.Close ();
+                       }
+               }
+               
+               [Test]
+               [ExpectedException (typeof(ObjectDisposedException))]
+               public void NoDelayClosed ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Stream,
+                                                 ProtocolType.Tcp);
+                       
+                       sock.Close ();
+                       
+                       bool val = sock.NoDelay;
+               }
+
+               static bool BAAccepted = false;
+               static Socket BASocket = null;
+               static ManualResetEvent BACalledBack = new ManualResetEvent 
(false);
+               
+               private static void BACallback (IAsyncResult asyncResult)
+               {
+                       Socket sock = (Socket)asyncResult.AsyncState;
+                       
+                       BASocket = sock.EndAccept (asyncResult);
+                       
+                       BAAccepted = true;
+                       BACalledBack.Set ();
+               }
+               
+               [Test]
+               [ExpectedException (typeof(InvalidOperationException))]
+               public void BeginAcceptNotBound ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Stream,
+                                                 ProtocolType.Tcp);
+
+                       sock.BeginAccept (BACallback, sock);
+                       
+                       sock.Close ();
+               }
+               
+               [Test]
+               [ExpectedException (typeof(InvalidOperationException))]
+               public void BeginAcceptNotListening ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Stream,
+                                                 ProtocolType.Tcp);
+
+                       sock.Bind (new IPEndPoint (IPAddress.Any, 1236));
+                       
+                       sock.BeginAccept (BACallback, sock);
+                       
+                       sock.Close ();
+               }
+
+               [Test]
+               public void BeginAccept ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Stream,
+                                                 ProtocolType.Tcp);
+                       IPEndPoint ep = new IPEndPoint (IPAddress.Loopback,
+                                                       1237);
+                       
+                       sock.Bind (ep);
+                       sock.Listen (1);
+                       
+                       BACalledBack.Reset ();
+                       
+                       sock.BeginAccept (BACallback, sock);
+
+                       Socket conn = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Stream,
+                                                 ProtocolType.Tcp);
+                       
+                       conn.Connect (ep);
+
+                       if (BACalledBack.WaitOne (2000, false) == false) {
+                               Assert.Fail ("BeginAccept wait timed out");
+                       }
+                       
+                       Assertion.AssertEquals ("BeginAccept #1", true,
+                                               BAAccepted);
+                       Assertion.AssertEquals ("BeginAccept #2", true,
+                                               BASocket.Connected);
+                       Assertion.AssertEquals ("BeginAccept #3", false,
+                                               sock.Connected);
+                       Assertion.AssertEquals ("BeginAccept #4", true,
+                                               conn.Connected);
+
+                       BASocket.Close ();
+                       conn.Close ();
+                       sock.Close ();
+               }
+
+               [Test]
+               [ExpectedException (typeof(ObjectDisposedException))]
+               public void BeginAcceptClosed ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Stream,
+                                                 ProtocolType.Tcp);
+                       
+                       sock.Close ();
+                       
+                       sock.BeginAccept (BACallback, sock);
+               }
+
+               static bool BADAccepted = false;
+               static Socket BADSocket = null;
+               static byte[] BADBytes;
+               static int BADByteCount;
+               static ManualResetEvent BADCalledBack = new ManualResetEvent 
(false);
+               
+               private static void BADCallback (IAsyncResult asyncResult)
+               {
+                       Socket sock = (Socket)asyncResult.AsyncState;
+                       
+                       BADSocket = sock.EndAccept (out BADBytes,
+                                                   out BADByteCount,
+                                                   asyncResult);
+                       
+                       BADAccepted = true;
+                       BADCalledBack.Set ();
+               }
+
+               [Test]
+               public void BeginAcceptData ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Stream,
+                                                 ProtocolType.Tcp);
+                       IPEndPoint ep = new IPEndPoint (IPAddress.Loopback,
+                                                       1238);
+                       
+                       sock.Bind (ep);
+                       sock.Listen (1);
+                       
+                       BADCalledBack.Reset ();
+                       
+                       sock.BeginAccept (256, BADCallback, sock);
+
+                       Socket conn = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Stream,
+                                                 ProtocolType.Tcp);
+                       byte[] send_bytes = new byte[] {10, 11, 12, 13};
+                       
+                       conn.Connect (ep);
+                       conn.Send (send_bytes);
+
+                       if (BADCalledBack.WaitOne (2000, false) == false) {
+                               Assert.Fail ("BeginAcceptData wait timed out");
+                       }
+                       
+                       Assertion.AssertEquals ("BeginAcceptData #1", true,
+                                               BADAccepted);
+                       Assertion.AssertEquals ("BeginAcceptData #2", true,
+                                               BADSocket.Connected);
+                       Assertion.AssertEquals ("BeginAcceptData #3", false,
+                                               sock.Connected);
+                       Assertion.AssertEquals ("BeginAcceptData #4", true,
+                                               conn.Connected);
+                       Assertion.AssertEquals ("BeginAcceptData #5",
+                                               send_bytes.Length,
+                                               BADByteCount);
+                       
+                       /* The MS runtime gives the returned data in a
+                        * much bigger array.  TODO: investigate
+                        * whether it the size correlates to the first
+                        * parameter in BeginAccept()
+                        */
+                       Assert.IsFalse (BADBytes.Length == send_bytes.Length,
+                                       "BeginAcceptData #6");
+
+                       for(int i = 0; i < send_bytes.Length; i++) {
+                               Assertion.AssertEquals ("BeginAcceptData #" + 
(i+7).ToString (), send_bytes[i], BADBytes[i]);
+                       }
+
+                       BADSocket.Close ();
+                       conn.Close ();
+                       sock.Close ();
+               }
+
+               [Test]
+               [ExpectedException (typeof(ObjectDisposedException))]
+               public void BeginAcceptDataClosed ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Stream,
+                                                 ProtocolType.Tcp);
+                       
+                       sock.Close ();
+                       
+                       sock.BeginAccept (256, BADCallback, sock);
+               }
+
+               [Test]
+               public void BeginAcceptSocketUdp ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Stream,
+                                                 ProtocolType.Tcp);
+                       Socket acc = new Socket (AddressFamily.InterNetwork,
+                                                SocketType.Dgram,
+                                                ProtocolType.Udp);
+                       
+                       IPEndPoint ep = new IPEndPoint (IPAddress.Loopback,
+                                                       1239);
+                       
+                       sock.Bind (ep);
+                       sock.Listen (1);
+                       
+                       try {
+                               sock.BeginAccept (acc, 256, BADCallback, sock);
+                               Assert.Fail ("BeginAcceptSocketUdp #1");
+                       } catch (SocketException ex) {
+                               Assertion.AssertEquals ("BeginAcceptSocketUdp 
#2", 10022, ex.ErrorCode);
+                       } catch {
+                               Assert.Fail ("BeginAcceptSocketUdp #3");
+                       } finally {
+                               acc.Close ();
+                               sock.Close ();
+                       }
+               }
+               
+               [Test]
+               public void BeginAcceptSocketBound ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Stream,
+                                                 ProtocolType.Tcp);
+                       Socket acc = new Socket (AddressFamily.InterNetwork,
+                                                SocketType.Stream,
+                                                ProtocolType.Tcp);
+                       
+                       IPEndPoint ep1 = new IPEndPoint (IPAddress.Loopback,
+                                                        1240);
+                       
+                       IPEndPoint ep2 = new IPEndPoint (IPAddress.Loopback,
+                                                        1241);
+                       
+                       sock.Bind (ep1);
+                       sock.Listen (1);
+
+                       acc.Bind (ep2);
+                       
+                       try {
+                               sock.BeginAccept (acc, 256, BADCallback, sock);
+                               Assert.Fail ("BeginAcceptSocketBound #1");
+                       } catch (InvalidOperationException) {
+                       } catch {
+                               Assert.Fail ("BeginAcceptSocketBound #2");
+                       } finally {
+                               acc.Close ();
+                               sock.Close ();
+                       }
+               }
+               
+               [Test]
+               public void BeginAcceptSocket ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Stream,
+                                                 ProtocolType.Tcp);
+                       Socket acc = new Socket (AddressFamily.InterNetwork,
+                                                SocketType.Stream,
+                                                ProtocolType.Tcp);
+                       
+                       IPEndPoint ep = new IPEndPoint (IPAddress.Loopback,
+                                                       1242);
+                       
+                       sock.Bind (ep);
+                       sock.Listen (1);
+                       
+                       BADCalledBack.Reset ();
+                       
+                       sock.BeginAccept (acc, 256, BADCallback, sock);
+
+                       Socket conn = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Stream,
+                                                 ProtocolType.Tcp);
+                       byte[] send_bytes = new byte[] {10, 11, 12, 13};
+                       
+                       conn.Connect (ep);
+                       conn.Send (send_bytes);
+
+                       if (BADCalledBack.WaitOne (2000, false) == false) {
+                               Assert.Fail ("BeginAcceptSocket wait timed 
out");
+                       }
+                       
+                       Assertion.AssertEquals ("BeginAcceptSocket #1", true,
+                                               BADAccepted);
+                       Assertion.AssertEquals ("BeginAcceptSocket #2", true,
+                                               BADSocket.Connected);
+                       Assertion.AssertEquals ("BeginAcceptSocket #3", false,
+                                               sock.Connected);
+                       Assertion.AssertEquals ("BeginAcceptSocket #4", true,
+                                               conn.Connected);
+                       Assertion.AssertEquals ("BeginAcceptSocket #5",
+                                               send_bytes.Length,
+                                               BADByteCount);
+                       Assertion.AssertEquals ("BeginAcceptSocket #6",
+                                               AddressFamily.InterNetwork,
+                                               acc.AddressFamily);
+                       Assertion.AssertEquals ("BeginAcceptSocket #7",
+                                               SocketType.Stream,
+                                               acc.SocketType);
+                       Assertion.AssertEquals ("BeginAcceptSocket #8",
+                                               ProtocolType.Tcp,
+                                               acc.ProtocolType);
+                       Assertion.AssertEquals ("BeginAcceptSocket #9",
+                                               conn.LocalEndPoint,
+                                               acc.RemoteEndPoint);
+                       
+                       /* The MS runtime gives the returned data in a
+                        * much bigger array.  TODO: investigate
+                        * whether it the size correlates to the first
+                        * parameter in BeginAccept()
+                        */
+                       Assert.IsFalse (BADBytes.Length == send_bytes.Length,
+                                       "BeginAcceptSocket #10");
+
+                       for(int i = 0; i < send_bytes.Length; i++) {
+                               Assertion.AssertEquals ("BeginAcceptSocket #" + 
(i+11).ToString (), send_bytes[i], BADBytes[i]);
+                       }
+
+                       BADSocket.Close ();
+                       conn.Close ();
+                       acc.Close ();
+                       sock.Close ();
+               }
+
+               [Test]
+               public void BeginAcceptSocketClosed ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Stream,
+                                                 ProtocolType.Tcp);
+                       Socket acc = new Socket (AddressFamily.InterNetwork,
+                                                SocketType.Stream,
+                                                ProtocolType.Tcp);
+                       
+                       sock.Close ();
+                       
+                       try {
+                               sock.BeginAccept (acc, 256, BADCallback, null);
+                               Assert.Fail ("BeginAcceptSocketClosed #1");
+                       } catch (ObjectDisposedException) {
+                       } catch {
+                               Assert.Fail ("BeginAcceptSocketClosed #2");
+                       } finally {
+                               acc.Close ();
+                       }
+               }
+
+               [Test]
+               public void BeginAcceptSocketAccClosed ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Stream,
+                                                 ProtocolType.Tcp);
+                       Socket acc = new Socket (AddressFamily.InterNetwork,
+                                                SocketType.Stream,
+                                                ProtocolType.Tcp);
+                       IPEndPoint ep = new IPEndPoint (IPAddress.Loopback,
+                                                       1243);
+
+                       sock.Bind (ep);
+                       sock.Listen (1);
+                       
+                       acc.Close ();
+                       
+                       BADCalledBack.Reset ();
+                       
+                       try {
+                               sock.BeginAccept (acc, 256, BADCallback, null);
+                               Assert.Fail ("BeginAcceptSocketAccClosed #1");
+                       } catch (ObjectDisposedException) {
+                       } catch {
+                               Assert.Fail ("BeginAcceptSocketAccClosed #2");
+                       } finally {
+                               sock.Close ();
+                       }
+               }
+               
+               static bool BCConnected = false;
+               static ManualResetEvent BCCalledBack = new ManualResetEvent 
(false);
+               
+               private static void BCCallback (IAsyncResult asyncResult)
+               {
+                       Socket sock = (Socket)asyncResult.AsyncState;
+                       
+                       sock.EndConnect (asyncResult);
+                       BCConnected = true;
+                       
+                       BCCalledBack.Set ();
+               }
+               
+               [Test]
+               public void BeginConnectAddressPort ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Stream,
+                                                 ProtocolType.Tcp);
+                       Socket listen = new Socket (AddressFamily.InterNetwork,
+                                                   SocketType.Stream,
+                                                   ProtocolType.Tcp);
+                       IPAddress ip = IPAddress.Loopback;
+                       IPEndPoint ep = new IPEndPoint (ip, 1244);
+
+                       listen.Bind (ep);
+                       listen.Listen (1);
+                       
+                       BCCalledBack.Reset ();
+                       
+                       BCConnected = false;
+                       
+                       sock.BeginConnect (ip, 1244, BCCallback, sock);
+
+                       if (BCCalledBack.WaitOne (2000, false) == false) {
+                               Assert.Fail ("BeginConnectAddressPort wait 
timed out");
+                       }
+                       
+                       Assertion.AssertEquals ("BeginConnectAddressPort #1",
+                                               true, BCConnected);
+                       
+                       sock.Close ();
+                       listen.Close ();
+               }
+
+               [Test]
+               public void BeginConnectAddressPortNull ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Stream,
+                                                 ProtocolType.Tcp);
+                       IPAddress ip = null;
+
+                       try {
+                               sock.BeginConnect (ip, 1244, BCCallback,
+                                                  sock);
+                               Assert.Fail ("BeginConnectAddressPortNull #1");
+                       } catch (ArgumentNullException) {
+                       } catch {
+                               Assert.Fail ("BeginConnectAddressPortNull #2");
+                       } finally {
+                               sock.Close ();
+                       }
+               }
+
+               [Test]
+               public void BeginConnectAddressPortListen ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Stream,
+                                                 ProtocolType.Tcp);
+                       IPAddress ip = IPAddress.Loopback;
+                       IPEndPoint ep = new IPEndPoint (ip, 1245);
+
+                       sock.Bind (ep);
+                       sock.Listen (1);
+                       
+                       try {
+                               sock.BeginConnect (ip, 1245, BCCallback, sock);
+                               Assert.Fail ("BeginConnectAddressPortListen 
#1");
+                       } catch (InvalidOperationException) {
+                       } catch {
+                               Assert.Fail ("BeginConnectAddressPortListen 
#2");
+                       } finally {
+                               sock.Close ();
+                       }
+               }
+               
+               [Test]
+               [ExpectedException (typeof(ObjectDisposedException))]
+               public void BeginConnectAddressPortClosed ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Stream,
+                                                 ProtocolType.Tcp);
+                       IPAddress ip = IPAddress.Loopback;
+                       
+                       sock.Close ();
+                       
+                       sock.BeginConnect (ip, 1244, BCCallback, sock);
+               }
+               
+               [Test]
+               public void BeginConnectMultiple ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Stream,
+                                                 ProtocolType.Tcp);
+                       Socket listen = new Socket (AddressFamily.InterNetwork,
+                                                   SocketType.Stream,
+                                                   ProtocolType.Tcp);
+                       IPEndPoint ep = new IPEndPoint (IPAddress.Loopback,
+                                                       1246);
+                       IPAddress[] ips = new IPAddress[4];
+                       
+                       ips[0] = IPAddress.Parse ("127.0.0.4");
+                       ips[1] = IPAddress.Parse ("127.0.0.3");
+                       ips[2] = IPAddress.Parse ("127.0.0.2");
+                       ips[3] = IPAddress.Parse ("127.0.0.1");
+
+                       listen.Bind (ep);
+                       listen.Listen (1);
+                       
+                       BCCalledBack.Reset ();
+                       
+                       BCConnected = false;
+                       
+                       sock.BeginConnect (ips, 1246, BCCallback, sock);
+                       
+                       /* Longer wait here, because the ms runtime
+                        * takes a lot longer to not connect
+                        */
+                       if (BCCalledBack.WaitOne (10000, false) == false) {
+                               Assert.Fail ("BeginConnectMultiple wait 
failed");
+                       }
+                       
+                       Assertion.AssertEquals ("BeginConnectMultiple #1",
+                                               true, BCConnected);
+                       Assertion.AssertEquals ("BeginConnectMultiple #2",
+                                               AddressFamily.InterNetwork,
+                                               
sock.RemoteEndPoint.AddressFamily);
+                       IPEndPoint remep = (IPEndPoint)sock.RemoteEndPoint;
+                       
+                       Assertion.AssertEquals ("BeginConnectMultiple #2",
+                                               IPAddress.Loopback,
+                                               remep.Address);
+                       
+                       sock.Close ();
+                       listen.Close ();
+               }
+
+               [Test]
+               public void BeginConnectMultipleNull ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Stream,
+                                                 ProtocolType.Tcp);
+                       IPAddress[] ips = null;
+                       
+                       try {
+                               sock.BeginConnect (ips, 1246, BCCallback,
+                                                  sock);
+                               Assert.Fail ("BeginConnectMultipleNull #1");
+                       } catch (ArgumentNullException) {
+                       } catch {
+                               Assert.Fail ("BeginConnectMultipleNull #2");
+                       } finally {
+                               sock.Close ();
+                       }
+               }
+
+               [Test]
+               public void BeginConnectMultipleListen ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Stream,
+                                                 ProtocolType.Tcp);
+                       IPAddress[] ips = new IPAddress[4];
+                       IPEndPoint ep = new IPEndPoint (IPAddress.Loopback,
+                                                       1247);
+                       
+                       ips[0] = IPAddress.Parse ("127.0.0.4");
+                       ips[1] = IPAddress.Parse ("127.0.0.3");
+                       ips[2] = IPAddress.Parse ("127.0.0.2");
+                       ips[3] = IPAddress.Parse ("127.0.0.1");
+                       
+                       sock.Bind (ep);
+                       sock.Listen (1);
+                       
+                       try {
+                               sock.BeginConnect (ips, 1247, BCCallback,
+                                                  sock);
+                               Assert.Fail ("BeginConnectMultipleListen #1");
+                       } catch (InvalidOperationException) {
+                       } catch {
+                               Assert.Fail ("BeginConnectMultipleListen #2");
+                       } finally {
+                               sock.Close ();
+                       }
+               }
+               
+               [Test]
+               [ExpectedException (typeof(ObjectDisposedException))]
+               public void BeginConnectMultipleClosed ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Stream,
+                                                 ProtocolType.Tcp);
+                       IPAddress[] ips = new IPAddress[4];
+                       
+                       ips[0] = IPAddress.Parse ("127.0.0.4");
+                       ips[1] = IPAddress.Parse ("127.0.0.3");
+                       ips[2] = IPAddress.Parse ("127.0.0.2");
+                       ips[3] = IPAddress.Parse ("127.0.0.1");
+                       
+                       sock.Close ();
+                       
+                       sock.BeginConnect (ips, 1247, BCCallback, sock);
+               }
+               
+               [Test]
+               public void BeginConnectHostPortNull ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Stream,
+                                                 ProtocolType.Tcp);
+                       
+                       try {
+                               sock.BeginConnect ((string)null, 0,
+                                                  BCCallback, sock);
+                               Assert.Fail ("BeginConnectHostPort #1");
+                       } catch (ArgumentNullException) {
+                       } catch {
+                               Assert.Fail ("BeginConnectHostPort #2");
+                       } finally {
+                               sock.Close ();
+                       }
+               }
+
+               [Test]
+               public void BeginConnectHostPortListen ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Stream,
+                                                 ProtocolType.Tcp);
+                       IPAddress ip = IPAddress.Loopback;
+                       IPEndPoint ep = new IPEndPoint (ip, 1248);
+                       
+                       sock.Bind (ep);
+                       sock.Listen (1);
+                       
+                       try {
+                               sock.BeginConnect ("localhost", 1248,
+                                                  BCCallback, sock);
+                               Assert.Fail ("BeginConnectHostPortListen #1");
+                       } catch (InvalidOperationException) {
+                       } catch {
+                               Assert.Fail ("BeginConnectHostPortListen #2");
+                       } finally {
+                               sock.Close ();
+                       }
+               }
+
+               [Test]
+               [Category ("NotWorking")] // Need to pick a non-IP 
AddressFamily that "works" on both mono and ms, this one only works on ms
+               public void BeginConnectHostPortNotIP ()
+               {
+                       Socket sock = new Socket (AddressFamily.NetBios,
+                                                 SocketType.Seqpacket,
+                                                 ProtocolType.Unspecified);
+                       
+                       try {
+                               sock.BeginConnect ("localhost", 0, BCCallback,
+                                                  sock);
+                               Assert.Fail ("BeginConnectHostPortNotIP #1");
+                       } catch (NotSupportedException) {
+                       } catch {
+                               Assert.Fail ("BeginConnectHostPortNotIP #2");
+                       } finally {
+                               sock.Close ();
+                       }
+               }
+
+               [Test]
+               [ExpectedException (typeof(ObjectDisposedException))]
+               public void BeginConnectHostPortClosed ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Stream,
+                                                 ProtocolType.Tcp);
+                       
+                       sock.Close ();
+                       
+                       sock.BeginConnect ("localhost", 0, BCCallback, sock);
+               }
+               
+               static bool BDDisconnected = false;
+               static ManualResetEvent BDCalledBack = new ManualResetEvent 
(false);
+               
+               private static void BDCallback (IAsyncResult asyncResult)
+               {
+                       Socket sock = (Socket)asyncResult.AsyncState;
+                       
+                       sock.EndDisconnect (asyncResult);
+                       BDDisconnected = true;
+                       
+                       BDCalledBack.Set ();
+               }
+               
+               [Test]
+               [Category ("NotDotNet")] // "Needs XP or later"
+               public void BeginDisconnect ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Stream,
+                                                 ProtocolType.Tcp);
+                       Socket listen = new Socket (AddressFamily.InterNetwork,
+                                                   SocketType.Stream,
+                                                   ProtocolType.Tcp);
+                       IPAddress ip = IPAddress.Loopback;
+                       IPEndPoint ep = new IPEndPoint (ip, 1254);
+                       
+                       listen.Bind (ep);
+                       listen.Listen (1);
+                       
+                       sock.Connect (ip, 1254);
+                       
+                       Assertion.AssertEquals ("BeginDisconnect #1", true,
+                                               sock.Connected);
+                       
+                       sock.Shutdown (SocketShutdown.Both);
+
+                       BDCalledBack.Reset ();
+                       BDDisconnected = false;
+                       
+                       sock.BeginDisconnect (false, BDCallback, sock);
+               
+                       if (BDCalledBack.WaitOne (2000, false) == false) {
+                               Assert.Fail ("BeginDisconnect wait timed out");
+                       }
+                       
+                       Assertion.AssertEquals ("BeginDisconnect #2", true,
+                                               BDDisconnected);
+                       Assertion.AssertEquals ("BeginDisconnect #3", false,
+                                               sock.Connected);
+                       
+                       sock.Close ();
+                       listen.Close ();
+               }
+               
+               [Test]
+               public void BeginReceiveSocketError ()
+               {
+               }
+               
+               [Test]
+               public void BeginReceiveGeneric ()
+               {
+               }
+               
+               [Test]
+               public void BeginReceiveGenericSocketError ()
+               {
+               }
+               
+               private static void BSCallback (IAsyncResult asyncResult)
+               {
+                       Socket sock = (Socket)asyncResult.AsyncState;
+                       
+                       sock.EndSend (asyncResult);
+               }
+               
+               [Test]
+               public void BeginSendNotConnected ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Stream,
+                                                 ProtocolType.Tcp);
+                       
+                       byte[] send_bytes = new byte[] {10, 11, 12, 13};
+                       
+                       try {
+                               sock.BeginSend (send_bytes, 0,
+                                               send_bytes.Length,
+                                               SocketFlags.None, BSCallback,
+                                               sock);
+                               Assert.Fail ("BeginSendNotConnected #1");
+                       } catch (SocketException ex) {
+                               Assertion.AssertEquals ("BeginSendNotConnected 
#2", 10057, ex.ErrorCode);
+                       } catch {
+                               Assert.Fail ("BeginSendNotConnected #3");
+                       } finally {
+                               sock.Close ();
+                       }
+               }
+               
+               [Test]
+               public void BeginSendSocketError ()
+               {
+               }
+               
+               [Test]
+               public void BeginSendGeneric ()
+               {
+               }
+               
+               [Test]
+               public void BeginSendGenericSocketError ()
+               {
+               }
+               
+               [Test]
+               public void BindTwice ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Stream,
+                                                 ProtocolType.Tcp);
+                       IPEndPoint ep1 = new IPEndPoint (IPAddress.Loopback,
+                                                       1256);
+                       IPEndPoint ep2 = new IPEndPoint (IPAddress.Loopback,
+                                                        1257);
+                       
+                       sock.Bind (ep1);
+                       
+                       try {
+                               sock.Bind (ep2);
+                               Assert.Fail ("BindTwice #1");
+                       } catch (SocketException ex) {
+                               Assertion.AssertEquals ("BindTwice #2",
+                                                       10022, ex.ErrorCode);
+                       } catch {
+                               Assert.Fail ("BindTwice #3");
+                       } finally {
+                               sock.Close ();
+                       }
+               }
+               
+               [Test]
+               public void Close ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Stream,
+                                                 ProtocolType.Tcp);
+                       Socket listen = new Socket (AddressFamily.InterNetwork,
+                                                   SocketType.Stream,
+                                                   ProtocolType.Tcp);
+                       IPEndPoint ep = new IPEndPoint (IPAddress.Loopback,
+                                                       1258);
+                       
+                       listen.Bind (ep);
+                       listen.Listen (1);
+                       
+                       sock.Connect (ep);
+
+                       Assertion.AssertEquals ("Close #1", true,
+                                               sock.Connected);
+                       
+                       sock.Close (2);
+                       
+                       Thread.Sleep (3000);
+                       
+                       Assertion.AssertEquals ("Close #2", false,
+                                               sock.Connected);
+                       
+                       listen.Close ();
+               }
+               
+               [Test]
+               public void ConnectAddressPort ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Stream,
+                                                 ProtocolType.Tcp);
+                       Socket listen = new Socket (AddressFamily.InterNetwork,
+                                                   SocketType.Stream,
+                                                   ProtocolType.Tcp);
+                       IPAddress ip = IPAddress.Loopback;
+                       IPEndPoint ep = new IPEndPoint (ip, 1249);
+
+                       listen.Bind (ep);
+                       listen.Listen (1);
+                       
+                       sock.Connect (ip, 1249);
+                       
+                       Assertion.AssertEquals ("ConnectAddressPort #1",
+                                               true, sock.Connected);
+                       
+                       sock.Close ();
+                       listen.Close ();
+               }
+
+               [Test]
+               public void ConnectAddressPortNull ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Stream,
+                                                 ProtocolType.Tcp);
+                       IPAddress ip = null;
+
+                       try {
+                               sock.Connect (ip, 1249);
+                               Assert.Fail ("ConnectAddressPortNull #1");
+                       } catch (ArgumentNullException) {
+                       } catch {
+                               Assert.Fail ("ConnectAddressPortNull #2");
+                       } finally {
+                               sock.Close ();
+                       }
+               }
+
+               [Test]
+               public void ConnectAddressPortListen ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Stream,
+                                                 ProtocolType.Tcp);
+                       IPAddress ip = IPAddress.Loopback;
+                       IPEndPoint ep = new IPEndPoint (ip, 1250);
+
+                       sock.Bind (ep);
+                       sock.Listen (1);
+                       
+                       try {
+                               sock.Connect (ip, 1250);
+                               Assert.Fail ("ConnectAddressPortListen #1");
+                       } catch (InvalidOperationException) {
+                       } catch {
+                               Assert.Fail ("ConnectAddressPortListen #2");
+                       } finally {
+                               sock.Close ();
+                       }
+               }
+               
+               [Test]
+               [ExpectedException (typeof(ObjectDisposedException))]
+               public void ConnectAddressPortClosed ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Stream,
+                                                 ProtocolType.Tcp);
+                       IPAddress ip = IPAddress.Loopback;
+                       
+                       sock.Close ();
+                       
+                       sock.Connect (ip, 1250);
+               }
+               
+               [Test]
+               public void ConnectMultiple ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Stream,
+                                                 ProtocolType.Tcp);
+                       Socket listen = new Socket (AddressFamily.InterNetwork,
+                                                   SocketType.Stream,
+                                                   ProtocolType.Tcp);
+                       IPEndPoint ep = new IPEndPoint (IPAddress.Loopback,
+                                                       1251);
+                       IPAddress[] ips = new IPAddress[4];
+                       
+                       ips[0] = IPAddress.Parse ("127.0.0.4");
+                       ips[1] = IPAddress.Parse ("127.0.0.3");
+                       ips[2] = IPAddress.Parse ("127.0.0.2");
+                       ips[3] = IPAddress.Parse ("127.0.0.1");
+
+                       listen.Bind (ep);
+                       listen.Listen (1);
+                       
+                       sock.Connect (ips, 1251);
+                       
+                       Assertion.AssertEquals ("ConnectMultiple #1",
+                                               true, sock.Connected);
+                       Assertion.AssertEquals ("ConnectMultiple #2",
+                                               AddressFamily.InterNetwork,
+                                               
sock.RemoteEndPoint.AddressFamily);
+                       IPEndPoint remep = (IPEndPoint)sock.RemoteEndPoint;
+                       
+                       Assertion.AssertEquals ("ConnectMultiple #2",
+                                               IPAddress.Loopback,
+                                               remep.Address);
+                       
+                       sock.Close ();
+                       listen.Close ();
+               }
+
+               [Test]
+               public void ConnectMultipleNull ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Stream,
+                                                 ProtocolType.Tcp);
+                       IPAddress[] ips = null;
+                       
+                       try {
+                               sock.Connect (ips, 1251);
+                               Assert.Fail ("ConnectMultipleNull #1");
+                       } catch (ArgumentNullException) {
+                       } catch {
+                               Assert.Fail ("ConnectMultipleNull #2");
+                       } finally {
+                               sock.Close ();
+                       }
+               }
+
+               [Test]
+               public void ConnectMultipleListen ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Stream,
+                                                 ProtocolType.Tcp);
+                       IPAddress[] ips = new IPAddress[4];
+                       IPEndPoint ep = new IPEndPoint (IPAddress.Loopback,
+                                                       1252);
+                       
+                       ips[0] = IPAddress.Parse ("127.0.0.4");
+                       ips[1] = IPAddress.Parse ("127.0.0.3");
+                       ips[2] = IPAddress.Parse ("127.0.0.2");
+                       ips[3] = IPAddress.Parse ("127.0.0.1");
+                       
+                       sock.Bind (ep);
+                       sock.Listen (1);
+                       
+                       try {
+                               sock.Connect (ips, 1252);
+                               Assert.Fail ("ConnectMultipleListen #1");
+                       } catch (InvalidOperationException) {
+                       } catch {
+                               Assert.Fail ("ConnectMultipleListen #2");
+                       } finally {
+                               sock.Close ();
+                       }
+               }
+               
+               [Test]
+               [ExpectedException (typeof(ObjectDisposedException))]
+               public void ConnectMultipleClosed ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Stream,
+                                                 ProtocolType.Tcp);
+                       IPAddress[] ips = new IPAddress[4];
+                       
+                       ips[0] = IPAddress.Parse ("127.0.0.4");
+                       ips[1] = IPAddress.Parse ("127.0.0.3");
+                       ips[2] = IPAddress.Parse ("127.0.0.2");
+                       ips[3] = IPAddress.Parse ("127.0.0.1");
+                       
+                       sock.Close ();
+                       
+                       sock.Connect (ips, 1252);
+               }
+               
+               [Test]
+               public void ConnectHostPortNull ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Stream,
+                                                 ProtocolType.Tcp);
+                       
+                       try {
+                               sock.Connect ((string)null, 0);
+                               Assert.Fail ("ConnectHostPort #1");
+                       } catch (ArgumentNullException) {
+                       } catch {
+                               Assert.Fail ("ConnectHostPort #2");
+                       } finally {
+                               sock.Close ();
+                       }
+               }
+
+               [Test]
+               public void ConnectHostPortListen ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Stream,
+                                                 ProtocolType.Tcp);
+                       IPAddress ip = IPAddress.Loopback;
+                       IPEndPoint ep = new IPEndPoint (ip, 1253);
+                       
+                       sock.Bind (ep);
+                       sock.Listen (1);
+                       
+                       try {
+                               sock.Connect ("localhost", 1253);
+                               Assert.Fail ("ConnectHostPortListen #1");
+                       } catch (InvalidOperationException) {
+                       } catch {
+                               Assert.Fail ("ConnectHostPortListen #2");
+                       } finally {
+                               sock.Close ();
+                       }
+               }
+
+               [Test]
+               [Category ("NotWorking")] // Need to pick a non-IP 
AddressFamily that "works" on both mono and ms, this one only works on ms
+               public void ConnectHostPortNotIP ()
+               {
+                       Socket sock = new Socket (AddressFamily.NetBios,
+                                                 SocketType.Seqpacket,
+                                                 ProtocolType.Unspecified);
+                       
+                       try {
+                               sock.Connect ("localhost", 0);
+                               Assert.Fail ("ConnectHostPortNotIP #1");
+                       } catch (NotSupportedException) {
+                       } catch {
+                               Assert.Fail ("ConnectHostPortNotIP #2");
+                       } finally {
+                               sock.Close ();
+                       }
+               }
+
+               [Test]
+               [ExpectedException (typeof(ObjectDisposedException))]
+               public void ConnectHostPortClosed ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Stream,
+                                                 ProtocolType.Tcp);
+                       
+                       sock.Close ();
+                       
+                       sock.Connect ("localhost", 0);
+               }
+               
+               [Test]
+               [Category ("NotDotNet")] // "Needs XP or later"
+               public void Disconnect ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Stream,
+                                                 ProtocolType.Tcp);
+                       Socket listen = new Socket (AddressFamily.InterNetwork,
+                                                   SocketType.Stream,
+                                                   ProtocolType.Tcp);
+                       IPAddress ip = IPAddress.Loopback;
+                       IPEndPoint ep = new IPEndPoint (ip, 1255);
+                       
+                       listen.Bind (ep);
+                       listen.Listen (1);
+                       
+                       sock.Connect (ip, 1255);
+                       
+                       Assertion.AssertEquals ("Disconnect #1", true,
+                                               sock.Connected);
+                       
+                       sock.Shutdown (SocketShutdown.Both);
+
+                       sock.Disconnect (false);
+
+                       Assertion.AssertEquals ("BeginDisconnect #3", false,
+                                               sock.Connected);
+                       
+                       sock.Close ();
+                       listen.Close ();
+               }
+               
+               [Test]
+               public void DuplicateAndClose ()
+               {
+               }
+               
+               [Test]
+               public void IOControl ()
+               {
+               }
+               
+               [Test]
+               public void ReceiveGeneric ()
+               {
+               }
+               
+               [Test]
+               public void ReceiveGenericSocketFlags ()
+               {
+               }
+               
+               [Test]
+               public void ReceiveGenericSocketFlagsSocketError ()
+               {
+               }
+               
+               [Test]
+               public void SendGeneric ()
+               {
+               }
+               
+               [Test]
+               public void SendGenericSocketFlags ()
+               {
+               }
+               
+               [Test]
+               public void SendGenericSocketFlagsSocketError ()
+               {
+               }
+
+               [Test]
+               public void ListenNotBound ()
+               {
+                       Socket sock = new Socket (AddressFamily.InterNetwork,
+                                                 SocketType.Stream,
+                                                 ProtocolType.Tcp);
+                       
+                       try {
+                               sock.Listen (1);
+                               Assert.Fail ("ListenNotBound #1");
+                       } catch (SocketException ex) {
+                               Assertion.AssertEquals ("ListenNotBound #2",
+                                                       10022, ex.ErrorCode);
+                       } catch {
+                               Assert.Fail ("ListenNotBound #3");
+                       } finally {
+                               sock.Close ();
+                       }
+               }
+#endif
        }
 }
 

Modified: trunk/mcs/class/System/Test/System.Net.Sockets/UdpClientTest.cs
===================================================================
--- trunk/mcs/class/System/Test/System.Net.Sockets/UdpClientTest.cs     
2007-01-11 13:30:28 UTC (rev 70853)
+++ trunk/mcs/class/System/Test/System.Net.Sockets/UdpClientTest.cs     
2007-01-11 13:31:42 UTC (rev 70854)
@@ -8,6 +8,7 @@
 using System;
 using System.Net;
 using System.Net.Sockets;
+using System.Threading;
 using NUnit.Framework;
 
 namespace MonoTests.System.Net.Sockets {
@@ -26,6 +27,232 @@
                                exThrown = true;
                        }
                        Assert.IsFalse(exThrown, "UdpClient Broadcast #1");
+
+                       client.Close ();
                }
+
+#if NET_2_0
+               [Test]
+               public void JoinMulticastGroup ()
+               {
+                       UdpClient client = new UdpClient ();
+                       IPAddress mcast_addr = IPAddress.Parse ("224.0.0.23");
+                       IPAddress local_addr = Dns.GetHostEntry 
("").AddressList[0];
+                       bool exThrown = false;
+                       
+                       /* So much for the documented note "You cannot
+                        * call JoinMulticastGroup on a UdpClient
+                        * constructed without a specific local port
+                        * (that is, using the UdpClient or
+                        * UdpClient(AddressFamily) constructor).
+                        */
+                       try {
+                               client.JoinMulticastGroup (mcast_addr,
+                                                          local_addr);
+                       } catch (Exception) {
+                               exThrown = true;
+                       } finally {
+                               client.Close ();
+                       }
+                       
+                       Assert.IsFalse (exThrown,
+                                       "UdpClient JoinMulticastGroup #1");
+               }
+               
+               [Test]
+               [ExpectedException (typeof(ArgumentNullException))]
+               public void BeginSendNull ()
+               {
+                       UdpClient client = new UdpClient ();
+                       
+                       client.BeginSend (null, 0, null, null);
+
+                       client.Close ();
+               }
+               
+               static bool BSSent = false;
+               static int BSBytes;
+               static ManualResetEvent BSCalledBack = new ManualResetEvent 
(false);
+               
+               private static void BSCallback (IAsyncResult asyncResult)
+               {
+                       UdpClient client = (UdpClient)asyncResult.AsyncState;
+                       
+                       BSBytes = client.EndSend (asyncResult);
+                       
+                       BSSent = true;
+                       BSCalledBack.Set ();
+               }
+               
+               [Test]
+               public void BeginSend ()
+               {
+                       UdpClient client = new UdpClient ();
+                       byte[] bytes = new byte[] {10, 11, 12, 13};
+
+                       try {
+                               client.BeginSend (bytes, bytes.Length, new 
AsyncCallback (BSCallback), client);
+                               Assert.Fail ("BeginSend #1");
+                       } catch (SocketException ex) {
+                               Assert.AreEqual (10057, ex.ErrorCode,
+                                                "BeginSend #2");
+                       }
+                       
+                       try {
+                               client.BeginSend (bytes, bytes.Length, null, 
new AsyncCallback (BSCallback), client);
+                               Assert.Fail ("BeginSend #3");
+                       } catch (SocketException ex) {
+                               Assert.AreEqual (10057, ex.ErrorCode,
+                                                "BeginSend #4");
+                       }
+
+                       IPEndPoint ep = new IPEndPoint (Dns.GetHostEntry 
("").AddressList[0], 1236);
+                       
+                       BSCalledBack.Reset ();
+                       
+                       client.BeginSend (bytes, bytes.Length, ep,
+                                         new AsyncCallback (BSCallback),
+                                         client);
+                       if (BSCalledBack.WaitOne (2000, false) == false) {
+                               Assert.Fail ("BeginSend wait timed out");
+                       }
+                       
+                       Assertion.AssertEquals ("BeginSend #5", true, BSSent);
+                       Assertion.AssertEquals ("BeginSend #6", 4, BSBytes);
+
+                       client.Close ();
+               }
+               
+               static bool BRReceived = false;
+               static byte[] BRBytes;
+               static IPEndPoint BRFrom;
+               static ManualResetEvent BRCalledBack = new ManualResetEvent 
(false);
+               
+               private static void BRCallback (IAsyncResult asyncResult)
+               {
+                       UdpClient client = (UdpClient)asyncResult.AsyncState;
+                       
+                       BRBytes = client.EndReceive (asyncResult, ref BRFrom);
+                       
+                       BRReceived = true;
+                       BRCalledBack.Set ();
+               }
+               
+               [Test]
+               public void BeginReceive ()
+               {
+                       UdpClient client = new UdpClient (1237);
+                       
+                       BRCalledBack.Reset ();
+                       
+                       client.BeginReceive (BRCallback, client);
+
+                       IPEndPoint ep = new IPEndPoint (Dns.GetHostEntry 
("").AddressList[0], 1237);
+                       byte[] send_bytes = new byte[] {10, 11, 12, 13};
+                       client.Send (send_bytes, send_bytes.Length, ep);
+
+                       if (BRCalledBack.WaitOne (2000, false) == false) {
+                               Assert.Fail ("BeginReceive wait timed out");
+                       }
+                       
+                       Assertion.AssertEquals ("BeginReceive #1", true,
+                                               BRReceived);
+                       Assertion.AssertEquals ("BeginReceive #2", 4,
+                                               BRBytes.Length);
+                       Assertion.AssertEquals ("BeginReceive #3", ep. Port,
+                                               BRFrom.Port);
+                       Assertion.AssertEquals ("BeginReceive #4", ep.Address,
+                                               BRFrom.Address);
+
+                       client.Close ();
+               }
+               
+               [Test]
+               public void Available ()
+               {
+                       UdpClient client = new UdpClient (1238);
+                       IPEndPoint ep = new IPEndPoint (Dns.GetHostEntry 
("").AddressList[0], 1238);
+                       byte[] bytes = new byte[] {10, 11, 12, 13};
+                       
+                       client.Send (bytes, bytes.Length, ep);
+                       int avail = client.Available;
+                       
+                       Assertion.AssertEquals ("Available #1", bytes.Length,
+                                               avail);
+
+                       client.Close ();
+               }
+               
+               [Test]
+               [Category ("NotWorking")]  // Using PMTU settings workaround on 
Linux, default true
+               public void DontFragmentDefault ()
+               {
+                       UdpClient client = new UdpClient ();
+                       
+                       /* Ignore the docs, testing shows the default
+                        * here is in fact false
+                        */
+                       Assertion.AssertEquals ("DontFragmentDefault", false,
+                                               client.DontFragment);
+
+                       client.Close ();
+               }
+               
+               [Test]
+               public void EnableBroadcastDefault ()
+               {
+                       UdpClient client = new UdpClient ();
+                       
+                       Assertion.AssertEquals ("EnableBroadcastDefault",
+                                               false, client.EnableBroadcast);
+
+                       client.Close ();
+               }
+               
+               /* Can't test the default for ExclusiveAddressUse as
+                * it's different on different versions and service
+                * packs of windows
+                */
+               [Test]
+               [Category ("NotWorking")] // Not supported on Linux
+               public void ExclusiveAddressUseUnbound ()
+               {
+                       UdpClient client = new UdpClient ();
+
+                       client.ExclusiveAddressUse = true;
+
+                       Assertion.AssertEquals ("ExclusiveAddressUseUnbound",
+                                               true,
+                                               client.ExclusiveAddressUse);
+
+                       client.Close ();
+               }
+               
+               [Test]
+               [ExpectedException (typeof(InvalidOperationException))]
+               [Category ("NotWorking")] // Not supported on Linux
+               public void ExclusiveAddressUseBound ()
+               {
+                       UdpClient client = new UdpClient (1239);
+
+                       client.ExclusiveAddressUse = true;
+
+                       client.Close ();
+               }
+               
+               [Test]
+               public void MulticastLoopbackDefault ()
+               {
+                       UdpClient client = new UdpClient ();
+                       
+                       Assertion.AssertEquals ("MulticastLoopbackDefault",
+                                               true,
+                                               client.MulticastLoopback);
+
+                       client.Close ();
+               }
+               
+               /* No test for Ttl default as it is platform dependent */
+#endif
        }
 }

_______________________________________________
Mono-patches maillist  -  [email protected]
http://lists.ximian.com/mailman/listinfo/mono-patches

Reply via email to