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
