Files
mono/mcs/class/System/Test/System.Net.Sockets/SocketTest.jvm.cs
T

2948 lines
73 KiB
C#
Executable File

// System.Net.Sockets.SocketTest.cs
//
// Authors:
// Brad Fitzpatrick ([email protected])
// Gonzalo Paniagua Javier ([email protected])
//
// (C) Copyright 2003 Brad Fitzpatrick
// Copyright (c) 2005 Novell, Inc. (http://www.novell.com)
//
using System;
using System.Collections;
using System.Threading;
using System.Net;
using System.Net.Sockets;
using NUnit.Framework;
namespace MonoTests.System.Net.Sockets
{
[TestFixture]
public class SocketTest
{
// note: also used in SocketCas tests
public const string BogusAddress = "192.168.244.244";
public const int BogusPort = 23483;
[Test]
public void ConnectIPAddressAny ()
{
IPEndPoint ep = new IPEndPoint (IPAddress.Any, 0);
#if !TARGET_JVM
//udp sockets are not supported
try {
using (Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp)) {
s.Connect (ep);
s.Close ();
}
Assert.Fail ("#1");
} catch (SocketException ex) {
Assert.AreEqual (10049, ex.ErrorCode, "#2");
}
#endif
try {
using (Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)) {
s.Connect (ep);
s.Close ();
}
Assert.Fail ("#3");
} catch (SocketException ex) {
Assert.AreEqual (10049, ex.ErrorCode, "#4");
}
}
[Test]
[Ignore ("Bug #75158")]
public void IncompatibleAddress ()
{
IPEndPoint epIPv6 = new IPEndPoint (IPAddress.IPv6Any,
0);
try {
using (Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.IP)) {
s.Connect (epIPv6);
s.Close ();
}
Assert.Fail ("#1");
} catch (SocketException ex) {
#if !NET_2_0
// invalid argument
int expectedError = 10022;
#else
// address incompatible with protocol
int expectedError = 10047;
#endif
Assert.AreEqual (expectedError, ex.ErrorCode,
"#2");
}
}
[Test]
[Category ("InetAccess")]
public void EndConnect ()
{
IPAddress ipOne = IPAddress.Parse (BogusAddress);
IPEndPoint ipEP = new IPEndPoint (ipOne, BogusPort);
Socket sock = new Socket (ipEP.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
IAsyncResult ar = sock.BeginConnect (ipEP, null, null);
bool gotException = false;
try {
sock.EndConnect (ar); // should raise an exception because connect was bogus
} catch {
gotException = true;
}
Assertion.AssertEquals ("A01", gotException, true);
}
[Test]
[ExpectedException (typeof (ArgumentNullException))]
public void SelectEmpty ()
{
ArrayList list = new ArrayList ();
Socket.Select (list, list, list, 1000);
}
private bool BlockingConnect (bool block)
{
IPEndPoint ep = new IPEndPoint(IPAddress.Loopback, 1234);
Socket server = new Socket(AddressFamily.InterNetwork,
SocketType.Stream,
ProtocolType.Tcp);
server.Bind(ep);
server.Blocking=block;
server.Listen(0);
Socket conn = new Socket (AddressFamily.InterNetwork,
SocketType.Stream,
ProtocolType.Tcp);
conn.Connect (ep);
Socket client = server.Accept();
bool client_block = client.Blocking;
client.Close();
conn.Close();
server.Close();
return(client_block);
}
[Test]
public void AcceptBlockingStatus()
{
bool block;
block = BlockingConnect(true);
Assertion.AssertEquals ("BlockingStatus01",
block, true);
block = BlockingConnect(false);
Assertion.AssertEquals ("BlockingStatus02",
block, false);
}
static bool CFAConnected = false;
static ManualResetEvent CFACalledBack;
private static void CFACallback (IAsyncResult asyncResult)
{
Socket sock = (Socket)asyncResult.AsyncState;
CFAConnected = sock.Connected;
if (sock.Connected) {
sock.EndConnect (asyncResult);
}
CFACalledBack.Set ();
}
[Test]
public void ConnectFailAsync ()
{
Socket sock = new Socket (AddressFamily.InterNetwork,
SocketType.Stream,
ProtocolType.Tcp);
sock.Blocking = false;
CFACalledBack = new ManualResetEvent (false);
CFACalledBack.Reset ();
/* Need a port that is not being used for
* anything...
*/
sock.BeginConnect (new IPEndPoint (IPAddress.Loopback,
114),
new AsyncCallback (CFACallback),
sock);
CFACalledBack.WaitOne ();
Assertion.AssertEquals ("ConnectFail", CFAConnected,
false);
}
#if !TARGET_JVM
[Test]
#if !NET_2_0
[ExpectedException (typeof (ArgumentException))]
#endif
public void SetSocketOptionBoolean ()
{
IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 1);
Socket sock = new Socket (ep.Address.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
try {
sock.SetSocketOption (SocketOptionLevel.Socket, SocketOptionName.KeepAlive, true);
} finally {
sock.Close ();
}
}
#endif
[Test]
#if TARGET_JVM
[Ignore ("NMA")]
#endif
public void TestSelect1 ()
{
Socket srv = CreateServer ();
ClientSocket clnt = new ClientSocket (srv.LocalEndPoint);
Thread th = new Thread (new ThreadStart (clnt.ConnectSleepClose));
Socket acc = null;
try {
th.Start ();
acc = srv.Accept ();
clnt.Write ();
ArrayList list = new ArrayList ();
ArrayList empty = new ArrayList ();
list.Add (acc);
Socket.Select (list, empty, empty, 100);
Assertion.AssertEquals ("#01", 0, empty.Count);
Assertion.AssertEquals ("#02", 1, list.Count);
Socket.Select (empty, list, empty, 100);
Assertion.AssertEquals ("#03", 0, empty.Count);
Assertion.AssertEquals ("#04", 1, list.Count);
Socket.Select (list, empty, empty, -1);
Assertion.AssertEquals ("#05", 0, empty.Count);
Assertion.AssertEquals ("#06", 1, list.Count);
} finally {
if (acc != null)
acc.Close ();
srv.Close ();
}
}
static Socket CreateServer ()
{
Socket sock = new Socket (AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
sock.Bind (new IPEndPoint (IPAddress.Loopback, 0));
sock.Listen (1);
return sock;
}
class ClientSocket {
Socket sock;
EndPoint ep;
public ClientSocket (EndPoint ep)
{
this.ep = ep;
sock = new Socket (AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
}
public void ConnectSleepClose ()
{
sock.Connect (ep);
Thread.Sleep (2000);
sock.Close ();
}
public void Write ()
{
byte [] b = new byte [10];
sock.Send (b);
}
}
byte[] buf = new byte[100];
[Test]
[ExpectedException (typeof (ObjectDisposedException))]
public void Disposed1 ()
{
#if TARGET_JVM
//UDP sockets are not supported in GH
Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
#else
Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
#endif
EndPoint ep = new IPEndPoint (IPAddress.Any, 31337);
s.Close();
s.ReceiveFrom (buf, ref ep);
}
[Test]
[ExpectedException (typeof (ObjectDisposedException))]
public void Disposed2 ()
{
#if TARGET_JVM
//UDP sockets are not supported in GH
Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
#else
Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
#endif
s.Close();
s.Blocking = true;
}
[Test]
[ExpectedException (typeof (ObjectDisposedException))]
public void Disposed3 ()
{
#if TARGET_JVM
//UDP sockets are not supported in GH
Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
#else
Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
#endif
s.Close();
s.GetSocketOption (0, 0);
}
[Test]
[ExpectedException (typeof (ObjectDisposedException))]
public void Disposed4 ()
{
#if TARGET_JVM
//UDP sockets are not supported in GH
Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
#else
Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
#endif
s.Close();
s.GetSocketOption (0, 0, null);
}
[Test]
[ExpectedException (typeof (ObjectDisposedException))]
public void Disposed5 ()
{
#if TARGET_JVM
//UDP sockets are not supported in GH
Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
#else
Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
#endif
s.Close();
s.GetSocketOption (0, 0, 0);
}
[Test]
[ExpectedException (typeof (ObjectDisposedException))]
public void Disposed6 ()
{
#if TARGET_JVM
//UDP sockets are not supported in GH
Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
#else
Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
#endif
s.Close();
s.Listen (5);
}
[Test]
[ExpectedException (typeof (ObjectDisposedException))]
public void Disposed7 ()
{
#if TARGET_JVM
//UDP sockets are not supported in GH
Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
#else
Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
#endif
s.Close();
s.Poll (100, 0);
}
[Test]
[ExpectedException (typeof (ObjectDisposedException))]
public void Disposed8 ()
{
#if TARGET_JVM
//UDP sockets are not supported in GH
Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
#else
Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
#endif
s.Close();
s.Receive (buf);
}
[Test]
[ExpectedException (typeof (ObjectDisposedException))]
public void Disposed9 ()
{
#if TARGET_JVM
//UDP sockets are not supported in GH
Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
#else
Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
#endif
s.Close();
s.Receive (buf, 0);
}
[Test]
[ExpectedException (typeof (ObjectDisposedException))]
public void Disposed10 ()
{
#if TARGET_JVM
//UDP sockets are not supported in GH
Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
#else
Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
#endif
s.Close();
s.Receive (buf, 10, 0);
}
[Test]
[ExpectedException (typeof (ObjectDisposedException))]
public void Disposed11 ()
{
#if TARGET_JVM
//UDP sockets are not supported in GH
Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
#else
Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
#endif
EndPoint ep = new IPEndPoint (IPAddress.Any, 31337);
s.Close();
s.Receive (buf, 0, 10, 0);
}
[Test]
[ExpectedException (typeof (ObjectDisposedException))]
public void Disposed12 ()
{
#if TARGET_JVM
//UDP sockets are not supported in GH
Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
#else
Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
#endif
EndPoint ep = new IPEndPoint (IPAddress.Any, 31337);
s.Close();
s.ReceiveFrom (buf, 0, ref ep);
}
[Test]
[ExpectedException (typeof (ObjectDisposedException))]
public void Disposed13 ()
{
#if TARGET_JVM
//UDP sockets are not supported in GH
Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
#else
Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
#endif
EndPoint ep = new IPEndPoint (IPAddress.Any, 31337);
s.Close();
s.ReceiveFrom (buf, 10, 0, ref ep);
}
[Test]
[ExpectedException (typeof (ObjectDisposedException))]
public void Disposed14 ()
{
#if TARGET_JVM
//UDP sockets are not supported in GH
Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
#else
Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
#endif
EndPoint ep = new IPEndPoint (IPAddress.Any, 31337);
s.Close();
s.ReceiveFrom (buf, 0, 10, 0, ref ep);
}
[Test]
[ExpectedException (typeof (ObjectDisposedException))]
public void Disposed15 ()
{
#if TARGET_JVM
//UDP sockets are not supported in GH
Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
#else
Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
#endif
s.Close();
s.Send (buf);
}
[Test]
[ExpectedException (typeof (ObjectDisposedException))]
public void Disposed16 ()
{
#if TARGET_JVM
//UDP sockets are not supported in GH
Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
#else
Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
#endif
s.Close();
s.Send (buf, 0);
}
[Test]
[ExpectedException (typeof (ObjectDisposedException))]
public void Disposed17 ()
{
#if TARGET_JVM
//UDP sockets are not supported in GH
Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
#else
Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
#endif
s.Close();
s.Send (buf, 10, 0);
}
[Test]
[ExpectedException (typeof (ObjectDisposedException))]
public void Disposed18 ()
{
#if TARGET_JVM
//UDP sockets are not supported in GH
Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
#else
Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
#endif
EndPoint ep = new IPEndPoint (IPAddress.Any, 31337);
s.Close();
s.Send (buf, 0, 10, 0);
}
[Test]
[ExpectedException (typeof (ObjectDisposedException))]
public void Disposed19 ()
{
#if TARGET_JVM
//UDP sockets are not supported in GH
Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
#else
Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
#endif
EndPoint ep = new IPEndPoint (IPAddress.Any, 31337);
s.Close();
s.SendTo (buf, 0, ep);
}
[Test]
[ExpectedException (typeof (ObjectDisposedException))]
public void Disposed20 ()
{
#if TARGET_JVM
//UDP sockets are not supported in GH
Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
#else
Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
#endif
EndPoint ep = new IPEndPoint (IPAddress.Any, 31337);
s.Close();
s.SendTo (buf, 10, 0, ep);
}
[Test]
[ExpectedException (typeof (ObjectDisposedException))]
public void Disposed21 ()
{
#if TARGET_JVM
//UDP sockets are not supported in GH
Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
#else
Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
#endif
EndPoint ep = new IPEndPoint(IPAddress.Any, 31337);
s.Close();
s.SendTo(buf, 0, 10, 0, ep);
}
[Test]
[ExpectedException (typeof (ObjectDisposedException))]
public void Disposed22 ()
{
#if TARGET_JVM
//UDP sockets are not supported in GH
Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
#else
Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
#endif
EndPoint ep = new IPEndPoint (IPAddress.Any, 31337);
s.Close();
s.SendTo (buf, ep);
}
[Test]
[ExpectedException (typeof (ObjectDisposedException))]
public void Disposed23 ()
{
#if TARGET_JVM
//UDP sockets are not supported in GH
Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
#else
Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
#endif
EndPoint ep = new IPEndPoint (IPAddress.Any, 31337);
s.Close();
s.Shutdown (0);
}
static ManualResetEvent SocketError_event = new ManualResetEvent (false);
private static void SocketError_callback (IAsyncResult ar)
{
Socket sock = (Socket)ar.AsyncState;
if(sock.Connected) {
sock.EndConnect (ar);
}
SocketError_event.Set ();
}
[Test]
#if TARGET_JVM
[Ignore ("NMA")]
#endif
public void SocketError ()
{
Socket sock = new Socket (AddressFamily.InterNetwork,
SocketType.Stream,
ProtocolType.Tcp);
IPEndPoint ep = new IPEndPoint (IPAddress.Loopback,
BogusPort);
SocketError_event.Reset ();
sock.Blocking = false;
sock.BeginConnect (ep, SocketError_callback,
sock);
if (SocketError_event.WaitOne (2000, false) == false) {
Assert.Fail ("SocketError wait timed out");
}
Assertion.AssertEquals ("SocketError #1", false,
sock.Connected);
int error;
error = (int)sock.GetSocketOption (SocketOptionLevel.Socket, SocketOptionName.Error);
Assertion.AssertEquals ("SocketError #2", 10061,
error);
error = (int)sock.GetSocketOption (SocketOptionLevel.Socket, SocketOptionName.Error);
Assertion.AssertEquals ("SocketError #3", 10061,
error);
sock.Close ();
}
#if NET_2_0
[Test]
public void SocketInformationCtor ()
{
}
[Test]
#if TARGET_JVM
[Ignore ("Socket.DontFragment property is not supported")]
#endif
public void DontFragmentDefaultTcp ()
{
Socket sock = new Socket (AddressFamily.InterNetwork,
SocketType.Stream,
ProtocolType.Tcp);
Assertion.AssertEquals ("DontFragmentDefaultTcp",
false, sock.DontFragment);
sock.Close ();
}
[Test]
#if TARGET_JVM
[Ignore("Socket.DontFragment property is not supported")]
#endif
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]
#if TARGET_JVM
[Ignore("Socket.DontFragment property is not supported")]
#endif
public void DontFragmentDefaultUdp ()
{
Socket sock = new Socket (AddressFamily.InterNetwork,
SocketType.Dgram,
ProtocolType.Udp);
Assertion.AssertEquals ("DontFragmentDefaultUdp",
false, sock.DontFragment);
sock.Close ();
}
[Test]
#if TARGET_JVM
[Ignore("Socket.DontFragment property is not supported")]
#endif
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))]
#if TARGET_JVM
[Ignore("Socket.DontFragment property is not supported")]
#endif
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]
#if TARGET_JVM
[Ignore("System.Net.Sockets.Socket.EnableBroadcast property is not supported")]
#endif
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]
#if TARGET_JVM
[Ignore("System.Net.Sockets.Socket.EnableBroadcast property is not supported")]
#endif
public void EnableBroadcastDefaultUdp ()
{
Socket sock = new Socket (AddressFamily.InterNetwork,
SocketType.Dgram,
ProtocolType.Udp);
Assertion.AssertEquals ("EnableBroadcastDefaultUdp",
false, sock.EnableBroadcast);
sock.Close ();
}
[Test]
#if TARGET_JVM
[Ignore ("System.Net.Sockets.Socket.EnableBroadcast property is not supported")]
#endif
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]
#if TARGET_JVM
[Ignore("System.Net.Sockets.Socket.EnableBroadcast property is not supported")]
#endif
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))]
#if TARGET_JVM
[Ignore("System.Net.Sockets.Socket.EnableBroadcast property is not supported")]
#endif
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))]
#if TARGET_JVM
[Ignore ("System.Net.Sockets.Socket.ExclusiveAddressUse is not supported")]
#endif
public void ExclusiveAddressUseClosed ()
{
Socket sock = new Socket (AddressFamily.InterNetwork,
SocketType.Stream,
ProtocolType.Tcp);
sock.Close ();
bool val = sock.ExclusiveAddressUse;
}
[Test]
#if TARGET_JVM
[Ignore ("System.Net.Sockets.Socket.IsBound property isn't supported")]
#endif
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]
#if TARGET_JVM
[Ignore("System.Net.Sockets.Socket.IsBound property isn't supported")]
#endif
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]
#if TARGET_JVM
[Ignore ("System.Net.Sockets.Socket.IsBound property is not supported")]
#endif
/* 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]
#if TARGET_JVM
[Ignore("System.Net.Sockets.Socket.MulticastLoopback property is not supported")]
#endif
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]
#if TARGET_JVM
[Ignore ("System.Net.Sockets.Socket.MulticastLoopback property is not supported")]
#endif
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]
#if TARGET_JVM
[Ignore ("Udp sockets are not supported")]
#endif
public void MulticastLoopbackDefaultUdp ()
{
Socket sock = new Socket (AddressFamily.InterNetwork,
SocketType.Dgram,
ProtocolType.Udp);
Assertion.AssertEquals ("MulticastLoopbackDefaultUdp",
true, sock.MulticastLoopback);
sock.Close ();
}
[Test]
#if TARGET_JVM
[Ignore ("Udp sockets are not supported")]
#endif
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))]
#if TARGET_JVM
[Ignore("System.Net.Sockets.Socket.MulticastLoopback property is not supported")]
#endif
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]
#if TARGET_JVM
[Ignore("System.Net.Sockets.Socket.ReseiveBufferSize property is not supported")]
#endif
public void ReceiveBufferSizeDefault ()
{
Socket sock = new Socket (AddressFamily.InterNetwork,
SocketType.Stream,
ProtocolType.Tcp);
Assertion.AssertEquals ("ReceiveBufferSizeDefault",
8192, sock.ReceiveBufferSize);
sock.Close ();
}
[Test]
#if TARGET_JVM
[Ignore("System.Net.Sockets.Socket.ReseiveBufferSize property is not supported")]
#endif
public void ReceiveBufferSizeDefaultUdp ()
{
Socket sock = new Socket (AddressFamily.InterNetwork,
SocketType.Dgram,
ProtocolType.Udp);
Assertion.AssertEquals ("ReceiveBufferSizeDefaultUdp",
8192, sock.ReceiveBufferSize);
sock.Close ();
}
[Test]
#if TARGET_JVM
[Ignore ("System.Net.Sockets.Socket.ReseiveBufferSize property is not supported")]
#endif
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))]
#if TARGET_JVM
[Ignore("System.Net.Sockets.Socket.ReseiveBufferSize property is not supported")]
#endif
public void ReceiveBufferSizeClosed ()
{
Socket sock = new Socket (AddressFamily.InterNetwork,
SocketType.Stream,
ProtocolType.Tcp);
sock.Close ();
int val = sock.ReceiveBufferSize;
}
[Test]
#if TARGET_JVM
[Ignore("System.Net.Sockets.Socket.SendBufferSize property is not supported")]
#endif
public void SendBufferSizeDefault ()
{
Socket sock = new Socket (AddressFamily.InterNetwork,
SocketType.Stream,
ProtocolType.Tcp);
Assertion.AssertEquals ("SendBufferSizeDefault",
8192, sock.SendBufferSize);
sock.Close ();
}
[Test]
#if TARGET_JVM
[Ignore("System.Net.Sockets.Socket.SendBufferSize property is not supported")]
#endif
public void SendBufferSizeDefaultUdp ()
{
Socket sock = new Socket (AddressFamily.InterNetwork,
SocketType.Dgram,
ProtocolType.Udp);
Assertion.AssertEquals ("SendBufferSizeDefaultUdp",
8192, sock.SendBufferSize);
sock.Close ();
}
[Test]
#if TARGET_JVM
[Ignore ("System.Net.Sockets.Socket.SendBufferSize property is not supported")]
#endif
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))]
#if TARGET_JVM
[Ignore("System.Net.Sockets.Socket.SendBufferSize property is not supported")]
#endif
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]
#if TARGET_JVM
[Ignore("System.Net.Sockets.Socket.Ttl property is not supported")]
#endif
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]
#if TARGET_JVM
[Ignore("System.Net.Sockets.Socket.Ttl property is not supported")]
#endif
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))]
#if TARGET_JVM
[Ignore("System.Net.Sockets.Socket.Ttl property is not supported")]
#endif
public void TtlClosed ()
{
Socket sock = new Socket (AddressFamily.InterNetwork,
SocketType.Stream,
ProtocolType.Tcp);
sock.Close ();
int val = sock.Ttl;
}
[Test]
#if TARGET_JVM
[Ignore("System.Net.Sockets.Socket.UseOnlyOverlappedIO property is not supported")]
#endif
public void UseOnlyOverlappedIODefault ()
{
Socket sock = new Socket (AddressFamily.InterNetwork,
SocketType.Stream,
ProtocolType.Tcp);
Assertion.AssertEquals ("UseOnlyOverlappedIODefault",
false,
sock.UseOnlyOverlappedIO);
sock.Close ();
}
//
// We need this because the Linux kernel in certain configurations
// will end up rounding up the values passed on to the kernel
// for socket send/receive timeouts.
//
int Approximate (int target, int value)
{
int epsilon = 10;
if (value > target-10 && value < target+10)
return target;
return value;
}
[Test]
#if TARGET_JVM
[Ignore("System.Net.Sockets.Socket.UseOnlyOverlappedIO property is not supported")]
#endif
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]
#if TARGET_JVM
[Ignore("System.Net.Sockets.Socket.UseOnlyOverlappedIO property is not supported")]
#endif
/* 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]
#if TARGET_JVM
[Ignore("System.Net.Sockets.Socket.SendTimeout property is not supported")]
#endif
public void SendTimeoutDefault ()
{
Socket sock = new Socket (AddressFamily.InterNetwork,
SocketType.Stream,
ProtocolType.Tcp);
Assertion.AssertEquals ("SendTimeoutDefault",
0, sock.SendTimeout);
sock.Close ();
}
[Test]
#if TARGET_JVM
[Ignore("System.Net.Sockets.Socket.SendTimeout property is not supported")]
#endif
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, Approximate (50, sock.SendTimeout));
sock.SendTimeout = 2000;
Assertion.AssertEquals ("SendTimeoutChange #2",
2000, Approximate (2000, sock.SendTimeout));
sock.SendTimeout = 0;
Assertion.AssertEquals ("SendTimeoutChange #3",
0, Approximate (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, Approximate (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))]
#if TARGET_JVM
[Ignore("System.Net.Sockets.Socket.SendTimeout property is not supported")]
#endif
public void SendTimeoutClosed ()
{
Socket sock = new Socket (AddressFamily.InterNetwork,
SocketType.Stream,
ProtocolType.Tcp);
sock.Close ();
int val = sock.SendTimeout;
}
[Test]
#if TARGET_JVM
[Ignore("System.Net.Sockets.Socket.ReceiveTimeout property is not supported")]
#endif
public void ReceiveTimeoutDefault ()
{
Socket sock = new Socket (AddressFamily.InterNetwork,
SocketType.Stream,
ProtocolType.Tcp);
Assertion.AssertEquals ("ReceiveTimeoutDefault",
0, sock.ReceiveTimeout);
sock.Close ();
}
[Test]
#if TARGET_JVM
[Ignore("System.Net.Sockets.Socket.ReceiveTimeout property is not supported")]
#endif
public void ReceiveTimeoutChange ()
{
Socket sock = new Socket (AddressFamily.InterNetwork,
SocketType.Stream,
ProtocolType.Tcp);
sock.ReceiveTimeout = 50;
Assertion.AssertEquals ("ReceiveTimeoutChange #1",
50, Approximate (50, sock.ReceiveTimeout));
sock.ReceiveTimeout = 2000;
Assertion.AssertEquals ("ReceiveTimeoutChange #2",
2000, Approximate (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, Approximate (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))]
#if TARGET_JVM
[Ignore("System.Net.Sockets.Socket.ReceiveTimeout property is not supported")]
#endif
public void ReceiveTimeoutClosed ()
{
Socket sock = new Socket (AddressFamily.InterNetwork,
SocketType.Stream,
ProtocolType.Tcp);
sock.Close ();
int val = sock.ReceiveTimeout;
}
[Test]
#if TARGET_JVM
[Ignore("System.Net.Sockets.Socket.NoDelay property is not supported")]
#endif
public void NoDelayDefaultTcp ()
{
Socket sock = new Socket (AddressFamily.InterNetwork,
SocketType.Stream,
ProtocolType.Tcp);
Assertion.AssertEquals ("NoDelayDefaultTcp", false,
sock.NoDelay);
sock.Close ();
}
[Test]
#if TARGET_JVM
[Ignore("System.Net.Sockets.Socket.NoDelay property is not supported")]
#endif
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]
#if TARGET_JVM
[Ignore("System.Net.Sockets.Socket.NoDelay property is not supported")]
#endif
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]
#if TARGET_JVM
[Ignore("System.Net.Sockets.Socket.NoDelay property is not supported")]
#endif
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))]
#if TARGET_JVM
[Ignore("System.Net.Sockets.Socket.NoDelay property is not supported")]
#endif
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]
#if TARGET_JVM
[Ignore ("NMA")]
#endif
[ExpectedException (typeof(InvalidOperationException))]
public void BeginAcceptNotBound ()
{
Socket sock = new Socket (AddressFamily.InterNetwork,
SocketType.Stream,
ProtocolType.Tcp);
sock.BeginAccept (BACallback, sock);
sock.Close ();
}
[Test]
#if TARGET_JVM
[Ignore ("NMA")]
#endif
[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)
{
#if !TARGET_JVM
Socket sock = (Socket)asyncResult.AsyncState;
BADSocket = sock.EndAccept (out BADBytes,
out BADByteCount,
asyncResult);
BADAccepted = true;
BADCalledBack.Set ();
#endif
}
[Test]
#if TARGET_JVM
[Ignore ("System.Net.Sockets.Socket.BeginAccept(int,AsyncCallback,object) is not supported")]
#endif
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))]
#if TARGET_JVM
[Ignore("System.Net.Sockets.Socket.BeginAccept(int,AsyncCallback,object) is not supported")]
#endif
public void BeginAcceptDataClosed ()
{
Socket sock = new Socket (AddressFamily.InterNetwork,
SocketType.Stream,
ProtocolType.Tcp);
sock.Close ();
sock.BeginAccept (256, BADCallback, sock);
}
[Test]
#if TARGET_JVM
[Ignore("System.Net.Sockets.Socket.BeginAccept(Socket,int,AsyncCallback,object) is not supported")]
#endif
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]
#if TARGET_JVM
[Ignore("System.Net.Sockets.Socket.BeginAccept(Socket,int,AsyncCallback,object) is not supported")]
#endif
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]
#if TARGET_JVM
[Ignore("System.Net.Sockets.Socket.BeginAccept(Socket,int,AsyncCallback,object) is not supported")]
#endif
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]
#if TARGET_JVM
[Ignore("System.Net.Sockets.Socket.BeginAccept(Socket,int,AsyncCallback,object) is not supported")]
#endif
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]
#if TARGET_JVM
[Ignore("System.Net.Sockets.Socket.BeginAccept(Socket,int,AsyncCallback,object) is not supported")]
#endif
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]
#if TARGET_JVM
[Ignore("System.Net.Sockets.Socket.BeginConnect(IPAddress,int,AsyncCallback,object) is not supported")]
#endif
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]
#if TARGET_JVM
[Ignore("System.Net.Sockets.Socket.BeginConnect(IPAddress,int,AsyncCallback,object) is not supported")]
#endif
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]
#if TARGET_JVM
[Ignore("System.Net.Sockets.Socket.BeginConnect(IPAddress,int,AsyncCallback,object) is not supported")]
#endif
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))]
#if TARGET_JVM
[Ignore("System.Net.Sockets.Socket.BeginConnect(IPAddress,int,AsyncCallback,object) is not supported")]
#endif
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]
#if TARGET_JVM
[Ignore("System.Net.Sockets.Socket.BeginConnect(IPAddress[],int,AsyncCallback,object) is not supported")]
#endif
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]
#if TARGET_JVM
[Ignore("System.Net.Sockets.Socket.BeginConnect(IPAddress[],int,AsyncCallback,object) is not supported")]
#endif
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]
#if TARGET_JVM
[Ignore("System.Net.Sockets.Socket.BeginConnect(IPAddress[],int,AsyncCallback,object) is not supported")]
#endif
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))]
#if TARGET_JVM
[Ignore("System.Net.Sockets.Socket.BeginConnect(IPAddress[],int,AsyncCallback,object) is not supported")]
#endif
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]
#if TARGET_JVM
[Ignore("System.Net.Sockets.Socket.BeginConnect(IPAddress,int,AsyncCallback,object) is not supported")]
#endif
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]
#if TARGET_JVM
[Ignore("System.Net.Sockets.Socket.BeginConnect(string,int,AsyncCallback,object) is not supported")]
#endif
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))]
#if TARGET_JVM
[Ignore("System.Net.Sockets.Socket.BeginConnect(string,int,AsyncCallback,object) is not supported")]
#endif
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)
{
#if !TARGET_JVM
Socket sock = (Socket)asyncResult.AsyncState;
sock.EndDisconnect (asyncResult);
BDDisconnected = true;
BDCalledBack.Set ();
#endif
}
[Test]
[Category ("NotDotNet")] // "Needs XP or later"
#if TARGET_JVM
[Ignore("System.Net.Sockets.Socket.BeginDisconnect method is not supported")]
#endif
public void BeginDisconnect ()
{
#if !TARGET_JVM
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 ();
#endif
}
[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]
#if TARGET_JVM
[Ignore ("System.Net.Sockets.Socket.BeginSend(byte[] ...) is not supported")]
#endif
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]
#if TARGET_JVM
[Ignore ("System.Net.Sockets.Socket.Close(int) method is not supported")]
#endif
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]
#if TARGET_JVM
[Ignore("System.Net.Sockets.Socket.Connect(IPAddress,int) is not supported")]
#endif
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]
#if TARGET_JVM
[Ignore("System.Net.Sockets.Socket.Connect(IPAddress,int) is not supported")]
#endif
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]
#if TARGET_JVM
[Ignore("System.Net.Sockets.Socket.Connect(IPAddress,int) is not supported")]
#endif
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))]
#if TARGET_JVM
[Ignore("System.Net.Sockets.Socket.Connect(IPAddress,int) is not supported")]
#endif
public void ConnectAddressPortClosed ()
{
Socket sock = new Socket (AddressFamily.InterNetwork,
SocketType.Stream,
ProtocolType.Tcp);
IPAddress ip = IPAddress.Loopback;
sock.Close ();
sock.Connect (ip, 1250);
}
[Test]
#if TARGET_JVM
[Ignore("System.Net.Sockets.Socket.Connect(IPAddress[],int) is not supported")]
#endif
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]
#if TARGET_JVM
[Ignore("System.Net.Sockets.Socket.Connect(IPAddress[],int) is not supported")]
#endif
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]
#if TARGET_JVM
[Ignore("System.Net.Sockets.Socket.Connect(IPAddress[],int) is not supported")]
#endif
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))]
#if TARGET_JVM
[Ignore("System.Net.Sockets.Socket.Connect(IPAddress[],int) is not supported")]
#endif
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]
#if TARGET_JVM
[Ignore("System.Net.Sockets.Socket.Connect(string,int) is not supported")]
#endif
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]
#if TARGET_JVM
[Ignore("System.Net.Sockets.Socket.Connect(string,int) is not supported")]
#endif
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))]
#if TARGET_JVM
[Ignore("System.Net.Sockets.Socket.Connect(string,int) is not supported")]
#endif
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"
#if TARGET_JVM
[Ignore ("System.Net.Sockets.Socket.Connect(IPAddress,int) is not supported")]
#endif
public void Disconnect ()
{
#if !TARGET_JVM
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 ();
#endif
}
[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
}
}