mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-17 11:21:39 -10:00
* BeginConnect complete to early when not using callback. The following commit, https://github.com/mono/mono/commit/068e8fe0424806753d7ab72a7b9bf0e54b58408b#diff-33b28a9dc0b8032650ed77213481a99f changed the way we do DNS resolve in BeginConnect using host name. Instead of doing a blocking DNS resolve, it switched to an async DNS resolve, followed by an async connect. The returned IAsyncResult was just representing the completion of the DNS resolve task and not the underlying connect. It also turns out that part of doing EndConnect, we did some validation of the used IAsyncResult making sure it was an instance of SocketAsyncResult, meaning that if EndConnect was called on the returned IAsyncResult from BeginConnect, EndConnect would throw and exception. NOTE, this only happens if you use pattern like this: var result = sock.BeginConnect (hostName, port, null, null); result.AsyncWaitHandle.WaitOne (2000); sock.EndConnect (result); It did not happened if you used callbacks, since then EndConnect would be called as part of callback and that IAsyncResult was of correct type, or if you did a BeginConnect with an EndPoint or IPAddress[] since that won't trigger the DNS resolve. Fix is to make sure we hand out the SocketAsyncResult instance that will be used in our internal connect calls from BeginConnect. We also make sure, we chain the DNS resolve task together with a task doing the async connect (using the same SocketAsyncResult instance). This will make sure the IAsyncResult returned from BeginConnect is the same one as used in internal connect call, so it will only complete when the connect call completes. * Adding test for BeginConnect using host name. * Bump API snapshot submodule
4801 lines
138 KiB
C#
Executable File
4801 lines
138 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.Diagnostics;
|
|
using System.Linq;
|
|
using System.Collections;
|
|
using System.Threading;
|
|
using System.Reflection;
|
|
using System.Text.RegularExpressions;
|
|
using System.Threading.Tasks;
|
|
using System.Net;
|
|
using System.Net.Sockets;
|
|
using NUnit.Framework;
|
|
using System.IO;
|
|
|
|
using System.Collections.Generic;
|
|
|
|
using MonoTests.Helpers;
|
|
|
|
namespace MonoTests.System.Net.Sockets
|
|
{
|
|
[TestFixture]
|
|
[Category("NotWasm")]
|
|
public class SocketTest
|
|
{
|
|
public const string BogusAddress = "192.168.244.244";
|
|
|
|
[Test]
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#endif
|
|
public void ConnectIPAddressAny ()
|
|
{
|
|
IPEndPoint ep = new IPEndPoint (IPAddress.Any, NetworkHelpers.FindFreePort ());
|
|
|
|
/* UDP sockets use Any to disconnect
|
|
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");
|
|
}
|
|
*/
|
|
|
|
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")] // Looks like MS fails after the .ctor, when you try to use the socket
|
|
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) {
|
|
// address incompatible with protocol
|
|
int expectedError = 10047;
|
|
Assert.AreEqual (expectedError, ex.ErrorCode,
|
|
"#2");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
[Category ("NotWorking")]
|
|
[Category ("InetAccess")]
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#endif
|
|
public void BogusEndConnect ()
|
|
{
|
|
IPAddress ipOne = IPAddress.Parse (BogusAddress);
|
|
IPEndPoint ipEP = new IPEndPoint (ipOne, NetworkHelpers.FindFreePort ());
|
|
Socket sock = new Socket (ipEP.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
|
|
IAsyncResult ar = sock.BeginConnect (ipEP, null, null);
|
|
|
|
try {
|
|
// should raise an exception because connect was bogus
|
|
sock.EndConnect (ar);
|
|
Assert.Fail ("#1");
|
|
} catch (SocketException ex) {
|
|
// Actual error code depends on network configuration.
|
|
var error = (SocketError) ex.ErrorCode;
|
|
Assert.That (error == SocketError.TimedOut ||
|
|
error == SocketError.ConnectionRefused ||
|
|
error == SocketError.NetworkUnreachable ||
|
|
error == SocketError.HostUnreachable, "#2");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentNullException))]
|
|
public void SelectEmpty ()
|
|
{
|
|
ArrayList list = new ArrayList ();
|
|
Socket.Select (list, list, list, 1000);
|
|
}
|
|
|
|
private bool BlockingConnect (bool block, ref int port)
|
|
{
|
|
IPEndPoint ep = new IPEndPoint(IPAddress.Loopback, port);
|
|
Socket server = new Socket(AddressFamily.InterNetwork,
|
|
SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
server.Bind(ep);
|
|
server.Blocking=block;
|
|
ep = (IPEndPoint) server.LocalEndPoint;
|
|
port = ep.Port;
|
|
|
|
server.Listen(0);
|
|
|
|
Socket conn = new Socket (AddressFamily.InterNetwork,
|
|
SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
conn.Connect (ep);
|
|
|
|
Socket client = null;
|
|
var sw = Stopwatch.StartNew ();
|
|
while (sw.ElapsedMilliseconds < 100)
|
|
{
|
|
try {
|
|
client = server.Accept();
|
|
break;
|
|
}
|
|
catch (SocketException ex) {
|
|
if (ex.SocketErrorCode == SocketError.WouldBlock)
|
|
continue;
|
|
throw;
|
|
}
|
|
}
|
|
Assert.IsNotNull (client, "Couldn't accept a client connection within 100ms.");
|
|
bool client_block = client.Blocking;
|
|
|
|
client.Close();
|
|
conn.Close();
|
|
server.Close();
|
|
|
|
return(client_block);
|
|
}
|
|
|
|
[Test]
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#endif
|
|
[Ignore ("https://github.com/mono/mono/issues/6513")] // frequently fails on ARM
|
|
public void AcceptBlockingStatus()
|
|
{
|
|
bool block;
|
|
int port = 0;
|
|
|
|
block = BlockingConnect(true, ref port);
|
|
Assert.AreEqual (block, true, "BlockingStatus01");
|
|
|
|
block = BlockingConnect(false, ref port);
|
|
Assert.AreEqual (block, false, "BlockingStatus02");
|
|
}
|
|
|
|
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] // Connect (IPEndPoint)
|
|
public void Connect1_RemoteEP_Null ()
|
|
{
|
|
Socket s = new Socket (AddressFamily.InterNetwork,
|
|
SocketType.Stream, ProtocolType.Tcp);
|
|
try {
|
|
s.Connect ((IPEndPoint) null);
|
|
Assert.Fail ("#1");
|
|
} catch (ArgumentNullException ex) {
|
|
Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
|
|
Assert.IsNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.AreEqual ("remoteEP", ex.ParamName, "#5");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#endif
|
|
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,
|
|
NetworkHelpers.FindFreePort ()),
|
|
new AsyncCallback (CFACallback),
|
|
sock);
|
|
CFACalledBack.WaitOne ();
|
|
|
|
Assert.AreEqual (CFAConnected, false, "ConnectFail");
|
|
}
|
|
|
|
[Test]
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#endif
|
|
public void SetSocketOptionBoolean ()
|
|
{
|
|
IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 0);
|
|
Socket sock = new Socket (ep.Address.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
|
|
try {
|
|
sock.SetSocketOption (SocketOptionLevel.Socket, SocketOptionName.KeepAlive, true);
|
|
} finally {
|
|
sock.Close ();
|
|
}
|
|
}
|
|
[Test]
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#endif
|
|
public void TestSelect1 ()
|
|
{
|
|
Socket srv = CreateServer (0);
|
|
ClientSocket clnt = new ClientSocket (srv.LocalEndPoint);
|
|
Socket acc = null;
|
|
try {
|
|
clnt.Connect ();
|
|
clnt.Write ();
|
|
acc = srv.Accept ();
|
|
ArrayList list = new ArrayList ();
|
|
ArrayList empty = new ArrayList ();
|
|
list.Add (acc);
|
|
Socket.Select (list, empty, empty, 1000);
|
|
Assert.AreEqual (0, empty.Count, "#01");
|
|
Assert.AreEqual (1, list.Count, "#02");
|
|
Socket.Select (empty, list, empty, 1000);
|
|
Assert.AreEqual (0, empty.Count, "#03");
|
|
Assert.AreEqual (1, list.Count, "#04");
|
|
Socket.Select (list, empty, empty, -1);
|
|
Assert.AreEqual (0, empty.Count, "#05");
|
|
Assert.AreEqual (1, list.Count, "#06");
|
|
// Need to read the 10 bytes from the client to avoid a RST
|
|
byte [] bytes = new byte [10];
|
|
acc.Receive (bytes);
|
|
} finally {
|
|
if (acc != null)
|
|
acc.Close ();
|
|
srv.Close ();
|
|
clnt.Close ();
|
|
}
|
|
}
|
|
|
|
static Socket CreateServer (int port)
|
|
{
|
|
Socket sock = new Socket (AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
|
|
sock.Bind (new IPEndPoint (IPAddress.Loopback, port));
|
|
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 Connect ()
|
|
{
|
|
sock.Connect (ep);
|
|
}
|
|
|
|
public void Close ()
|
|
{
|
|
sock.Close ();
|
|
}
|
|
|
|
public void Write ()
|
|
{
|
|
byte [] b = new byte [10];
|
|
sock.Send (b);
|
|
}
|
|
}
|
|
|
|
byte[] buf = new byte[100];
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ObjectDisposedException))]
|
|
public void Disposed2 ()
|
|
{
|
|
Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
|
|
s.Close();
|
|
|
|
s.Blocking = true;
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ObjectDisposedException))]
|
|
public void Disposed6 ()
|
|
{
|
|
Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
|
|
s.Close();
|
|
|
|
s.Listen (5);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ObjectDisposedException))]
|
|
public void Disposed7 ()
|
|
{
|
|
Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
|
|
s.Close();
|
|
|
|
s.Poll (100, 0);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ObjectDisposedException))]
|
|
public void Disposed15 ()
|
|
{
|
|
Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
|
|
s.Close();
|
|
|
|
s.Send (buf);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ObjectDisposedException))]
|
|
public void Disposed16 ()
|
|
{
|
|
Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
|
|
s.Close();
|
|
|
|
s.Send (buf, 0);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ObjectDisposedException))]
|
|
public void Disposed17 ()
|
|
{
|
|
Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
|
|
s.Close();
|
|
|
|
s.Send (buf, 10, 0);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ObjectDisposedException))]
|
|
public void Disposed18 ()
|
|
{
|
|
Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
|
|
s.Close();
|
|
|
|
s.Send (buf, 0, 10, 0);
|
|
}
|
|
|
|
[Test]
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#else
|
|
[ExpectedException (typeof (ObjectDisposedException))]
|
|
#endif
|
|
public void Disposed19 ()
|
|
{
|
|
Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
|
|
EndPoint ep = new IPEndPoint (IPAddress.Any, NetworkHelpers.FindFreePort ());
|
|
s.Close();
|
|
|
|
s.SendTo (buf, 0, ep);
|
|
}
|
|
|
|
[Test]
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#else
|
|
[ExpectedException (typeof (ObjectDisposedException))]
|
|
#endif
|
|
public void Disposed20 ()
|
|
{
|
|
Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
|
|
EndPoint ep = new IPEndPoint (IPAddress.Any, NetworkHelpers.FindFreePort ());
|
|
s.Close();
|
|
|
|
s.SendTo (buf, 10, 0, ep);
|
|
}
|
|
|
|
[Test]
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#else
|
|
[ExpectedException (typeof (ObjectDisposedException))]
|
|
#endif
|
|
public void Disposed21 ()
|
|
{
|
|
Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
|
|
EndPoint ep = new IPEndPoint (IPAddress.Any, NetworkHelpers.FindFreePort ());
|
|
s.Close();
|
|
|
|
s.SendTo (buf, 0, 10, 0, ep);
|
|
}
|
|
|
|
[Test]
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#else
|
|
[ExpectedException (typeof (ObjectDisposedException))]
|
|
#endif
|
|
public void Disposed22 ()
|
|
{
|
|
Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
|
|
EndPoint ep = new IPEndPoint (IPAddress.Any, NetworkHelpers.FindFreePort ());
|
|
s.Close();
|
|
|
|
s.SendTo (buf, ep);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ObjectDisposedException))]
|
|
public void Disposed23 ()
|
|
{
|
|
Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
|
|
s.Close();
|
|
|
|
s.Shutdown (0);
|
|
}
|
|
|
|
[Test]
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#endif
|
|
public void GetHashCodeTest ()
|
|
{
|
|
Socket server = new Socket (AddressFamily.InterNetwork,
|
|
SocketType.Stream, ProtocolType.Tcp);
|
|
server.Bind (IPAddress.Loopback, out IPEndPoint ep);
|
|
server.Listen (1);
|
|
|
|
Socket client = new Socket (AddressFamily.InterNetwork,
|
|
SocketType.Stream, ProtocolType.Tcp);
|
|
int hashcodeA = client.GetHashCode ();
|
|
client.Connect (ep);
|
|
int hashcodeB = client.GetHashCode ();
|
|
Assert.AreEqual (hashcodeA, hashcodeB, "#1");
|
|
client.Close ();
|
|
int hashcodeC = client.GetHashCode ();
|
|
Assert.AreEqual (hashcodeB, hashcodeC, "#2");
|
|
server.Close ();
|
|
}
|
|
|
|
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]
|
|
[Category ("RequiresBSDSockets")] // This verifies particular error codes, which we don't care about when nothing's working anyway.
|
|
public void SocketErrorTest ()
|
|
{
|
|
Socket sock = new Socket (AddressFamily.InterNetwork,
|
|
SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
IPEndPoint ep = NetworkHelpers.LocalEphemeralEndPoint ();
|
|
|
|
SocketError_event.Reset ();
|
|
|
|
sock.Blocking = false;
|
|
sock.BeginConnect (ep, new AsyncCallback(SocketError_callback),
|
|
sock);
|
|
|
|
if (SocketError_event.WaitOne (5000, false) == false) {
|
|
Assert.Fail ("SocketError wait timed out");
|
|
}
|
|
|
|
Assert.AreEqual (false, sock.Connected, "SocketError #1");
|
|
|
|
int error;
|
|
|
|
error = (int)sock.GetSocketOption (SocketOptionLevel.Socket, SocketOptionName.Error);
|
|
Assert.AreEqual (10061, error, "SocketError #2");
|
|
|
|
error = (int)sock.GetSocketOption (SocketOptionLevel.Socket, SocketOptionName.Error);
|
|
Assert.AreEqual (10061, error, "SocketError #3");
|
|
|
|
sock.Close ();
|
|
}
|
|
|
|
|
|
[Test]
|
|
public void SocketInformationCtor ()
|
|
{
|
|
}
|
|
|
|
[Test]
|
|
public void DontFragmentDefaultTcp ()
|
|
{
|
|
Socket sock = new Socket (AddressFamily.InterNetwork,
|
|
SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
|
|
Assert.AreEqual (false, sock.DontFragment, "DontFragmentDefaultTcp");
|
|
|
|
sock.Close ();
|
|
}
|
|
|
|
[Test]
|
|
[Category ("NotWorking")] // DontFragment doesn't work
|
|
public void DontFragmentChangeTcp ()
|
|
{
|
|
Socket sock = new Socket (AddressFamily.InterNetwork,
|
|
SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
|
|
sock.DontFragment = true;
|
|
|
|
Assert.AreEqual (true, sock.DontFragment, "DontFragmentChangeTcp");
|
|
|
|
sock.Close ();
|
|
}
|
|
|
|
[Test]
|
|
public void DontFragmentDefaultUdp ()
|
|
{
|
|
Socket sock = new Socket (AddressFamily.InterNetwork,
|
|
SocketType.Dgram,
|
|
ProtocolType.Udp);
|
|
|
|
Assert.AreEqual (false, sock.DontFragment, "DontFragmentDefaultUdp");
|
|
|
|
sock.Close ();
|
|
}
|
|
|
|
[Test]
|
|
[Category ("NotWorking")] // DontFragment doesn't work
|
|
public void DontFragmentChangeUdp ()
|
|
{
|
|
Socket sock = new Socket (AddressFamily.InterNetwork,
|
|
SocketType.Dgram,
|
|
ProtocolType.Udp);
|
|
|
|
sock.DontFragment = true;
|
|
|
|
Assert.AreEqual (true, sock.DontFragment, "DontFragmentChangeUdp");
|
|
|
|
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) {
|
|
} 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");
|
|
} finally {
|
|
sock.Close ();
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void EnableBroadcastDefaultUdp ()
|
|
{
|
|
Socket sock = new Socket (AddressFamily.InterNetwork,
|
|
SocketType.Dgram,
|
|
ProtocolType.Udp);
|
|
|
|
Assert.AreEqual (false, sock.EnableBroadcast, "EnableBroadcastDefaultUdp");
|
|
|
|
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");
|
|
} finally {
|
|
sock.Close ();
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void EnableBroadcastChangeUdp ()
|
|
{
|
|
Socket sock = new Socket (AddressFamily.InterNetwork,
|
|
SocketType.Dgram,
|
|
ProtocolType.Udp);
|
|
|
|
sock.EnableBroadcast = true;
|
|
|
|
Assert.AreEqual (true, sock.EnableBroadcast, "EnableBroadcastChangeUdp");
|
|
|
|
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;
|
|
|
|
Assert.AreEqual (true, sock.ExclusiveAddressUse, "ExclusiveAddressUseUnbound");
|
|
|
|
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, NetworkHelpers.FindFreePort ()));
|
|
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]
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#endif
|
|
public void IsBoundTcp ()
|
|
{
|
|
Socket sock = new Socket (AddressFamily.InterNetwork,
|
|
SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
|
|
Assert.AreEqual (false, sock.IsBound, "IsBoundTcp #1");
|
|
|
|
sock.Bind (IPAddress.Loopback, out IPEndPoint ep);
|
|
Assert.AreEqual (true, sock.IsBound, "IsBoundTcp #2");
|
|
|
|
sock.Listen (1);
|
|
|
|
Socket sock2 = new Socket (AddressFamily.InterNetwork,
|
|
SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
|
|
Assert.AreEqual (false, sock2.IsBound, "IsBoundTcp #3");
|
|
|
|
sock2.Connect (ep);
|
|
Assert.AreEqual (true, sock2.IsBound, "IsBoundTcp #4");
|
|
|
|
sock2.Close ();
|
|
Assert.AreEqual (true, sock2.IsBound, "IsBoundTcp #5");
|
|
|
|
sock.Close ();
|
|
Assert.AreEqual (true, sock.IsBound, "IsBoundTcp #6");
|
|
}
|
|
|
|
[Test]
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#endif
|
|
public void IsBoundUdp ()
|
|
{
|
|
Socket sock = new Socket (AddressFamily.InterNetwork,
|
|
SocketType.Dgram,
|
|
ProtocolType.Udp);
|
|
|
|
Assert.AreEqual (false, sock.IsBound, "IsBoundUdp #1");
|
|
|
|
sock.Bind (IPAddress.Loopback, out IPEndPoint ep);
|
|
|
|
Assert.AreEqual (true, sock.IsBound, "IsBoundUdp #2");
|
|
|
|
sock.Close ();
|
|
Assert.AreEqual (true, sock.IsBound, "IsBoundUdp #3");
|
|
|
|
|
|
sock = new Socket (AddressFamily.InterNetwork,
|
|
SocketType.Dgram,
|
|
ProtocolType.Udp);
|
|
|
|
Assert.AreEqual (false, sock.IsBound, "IsBoundUdp #4");
|
|
|
|
sock.Connect (ep);
|
|
Assert.AreEqual (true, sock.IsBound, "IsBoundUdp #5");
|
|
|
|
sock.Close ();
|
|
Assert.AreEqual (true, sock.IsBound, "IsBoundUdp #6");
|
|
}
|
|
|
|
[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");
|
|
} 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");
|
|
} finally {
|
|
sock.Close ();
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void MulticastLoopbackDefaultUdp ()
|
|
{
|
|
Socket sock = new Socket (AddressFamily.InterNetwork,
|
|
SocketType.Dgram,
|
|
ProtocolType.Udp);
|
|
|
|
Assert.AreEqual (true, sock.MulticastLoopback, "MulticastLoopbackDefaultUdp");
|
|
|
|
sock.Close ();
|
|
}
|
|
|
|
[Test]
|
|
public void MulticastLoopbackChangeUdp ()
|
|
{
|
|
Socket sock = new Socket (AddressFamily.InterNetwork,
|
|
SocketType.Dgram,
|
|
ProtocolType.Udp);
|
|
|
|
sock.MulticastLoopback = false;
|
|
|
|
Assert.AreEqual (false, sock.MulticastLoopback, "MulticastLoopbackChangeUdp");
|
|
|
|
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]
|
|
[Category("NotWorking")] // We have different defaults for perf reasons
|
|
public void ReceiveBufferSizeDefault ()
|
|
{
|
|
Socket sock = new Socket (AddressFamily.InterNetwork,
|
|
SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
|
|
Assert.AreEqual (8192, sock.ReceiveBufferSize, "ReceiveBufferSizeDefault");
|
|
|
|
sock.Close ();
|
|
}
|
|
|
|
[Test]
|
|
[Category("NotWorking")] // We have different defaults for perf reasons
|
|
public void ReceiveBufferSizeDefaultUdp ()
|
|
{
|
|
Socket sock = new Socket (AddressFamily.InterNetwork,
|
|
SocketType.Dgram,
|
|
ProtocolType.Udp);
|
|
|
|
Assert.AreEqual (8192, sock.ReceiveBufferSize, "ReceiveBufferSizeDefaultUdp");
|
|
|
|
sock.Close ();
|
|
}
|
|
|
|
[Test]
|
|
public void ReceiveBufferSizeChange ()
|
|
{
|
|
Socket sock = new Socket (AddressFamily.InterNetwork,
|
|
SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
|
|
sock.ReceiveBufferSize = 16384;
|
|
|
|
Assert.AreEqual (16384, sock.ReceiveBufferSize, "ReceiveBufferSizeChange");
|
|
|
|
sock.Close ();
|
|
}
|
|
|
|
[Test]
|
|
[Category("NotWorking")] // We cannot totally remove buffers (minimum is set to 256
|
|
public void BuffersCheck_None ()
|
|
{
|
|
using (Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)) {
|
|
int original = s.ReceiveBufferSize;
|
|
s.ReceiveBufferSize = 0;
|
|
Assert.AreEqual (0, s.ReceiveBufferSize, "ReceiveBufferSize " + original.ToString ());
|
|
|
|
original = s.SendBufferSize;
|
|
s.SendBufferSize = 0;
|
|
Assert.AreEqual (0, s.SendBufferSize, "SendBufferSize " + original.ToString ());
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof(ObjectDisposedException))]
|
|
public void ReceiveBufferSizeClosed ()
|
|
{
|
|
Socket sock = new Socket (AddressFamily.InterNetwork,
|
|
SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
|
|
sock.Close ();
|
|
|
|
int val = sock.ReceiveBufferSize;
|
|
}
|
|
|
|
[Test]
|
|
[Category("NotWorking")] // We have different defaults for perf reasons
|
|
public void SendBufferSizeDefault ()
|
|
{
|
|
Socket sock = new Socket (AddressFamily.InterNetwork,
|
|
SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
|
|
Assert.AreEqual (8192, sock.SendBufferSize, "SendBufferSizeDefault");
|
|
|
|
sock.Close ();
|
|
}
|
|
|
|
[Test]
|
|
[Category("NotWorking")] // We have different defaults for perf reasons
|
|
public void SendBufferSizeDefaultUdp ()
|
|
{
|
|
Socket sock = new Socket (AddressFamily.InterNetwork,
|
|
SocketType.Dgram,
|
|
ProtocolType.Udp);
|
|
|
|
Assert.AreEqual (8192, sock.SendBufferSize, "SendBufferSizeDefaultUdp");
|
|
|
|
sock.Close ();
|
|
}
|
|
|
|
[Test]
|
|
public void SendBufferSizeChange ()
|
|
{
|
|
Socket sock = new Socket (AddressFamily.InterNetwork,
|
|
SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
|
|
sock.SendBufferSize = 16384;
|
|
|
|
Assert.AreEqual (16384, sock.SendBufferSize, "SendBufferSizeChange");
|
|
|
|
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;
|
|
|
|
Assert.AreEqual (255, sock.Ttl, "TtlChange");
|
|
|
|
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 (ArgumentOutOfRangeException ex) {
|
|
Assert.AreEqual ("value", ex.ParamName,
|
|
"TtlChangeOverflow #2");
|
|
} 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");
|
|
} 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);
|
|
|
|
Assert.AreEqual (false, sock.UseOnlyOverlappedIO, "UseOnlyOverlappedIODefault");
|
|
|
|
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]
|
|
public void UseOnlyOverlappedIOChange ()
|
|
{
|
|
Socket sock = new Socket (AddressFamily.InterNetwork,
|
|
SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
|
|
sock.UseOnlyOverlappedIO = true;
|
|
|
|
Assert.AreEqual (true, sock.UseOnlyOverlappedIO, "UseOnlyOverlappedIOChange");
|
|
|
|
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);
|
|
|
|
Assert.AreEqual (0, sock.SendTimeout, "SendTimeoutDefault");
|
|
|
|
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;
|
|
Assert.AreEqual (50, Approximate (50, sock.SendTimeout), "SendTimeoutChange #1");
|
|
|
|
sock.SendTimeout = 2000;
|
|
Assert.AreEqual (2000, Approximate (2000, sock.SendTimeout), "SendTimeoutChange #2");
|
|
|
|
sock.SendTimeout = 0;
|
|
Assert.AreEqual (0, Approximate (0, sock.SendTimeout), "SendTimeoutChange #3");
|
|
|
|
/* Should be the same as setting 0 */
|
|
sock.SendTimeout = -1;
|
|
Assert.AreEqual (0, sock.SendTimeout, "SendTimeoutChange #4");
|
|
|
|
sock.SendTimeout = 65536;
|
|
Assert.AreEqual (65536, Approximate (65536, sock.SendTimeout), "SendTimeoutChange #5");
|
|
|
|
try {
|
|
sock.SendTimeout = -2;
|
|
Assert.Fail ("SendTimeoutChange #8");
|
|
} catch (ArgumentOutOfRangeException) {
|
|
} 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);
|
|
|
|
Assert.AreEqual (0, sock.ReceiveTimeout, "ReceiveTimeoutDefault");
|
|
|
|
sock.Close ();
|
|
}
|
|
|
|
[Test]
|
|
public void ReceiveTimeoutChange ()
|
|
{
|
|
Socket sock = new Socket (AddressFamily.InterNetwork,
|
|
SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
|
|
sock.ReceiveTimeout = 50;
|
|
Assert.AreEqual (50, Approximate (50, sock.ReceiveTimeout), "ReceiveTimeoutChange #1");
|
|
|
|
sock.ReceiveTimeout = 2000;
|
|
Assert.AreEqual (2000, Approximate (2000, sock.ReceiveTimeout), "ReceiveTimeoutChange #2");
|
|
|
|
sock.ReceiveTimeout = 0;
|
|
Assert.AreEqual (0, sock.ReceiveTimeout, "ReceiveTimeoutChange #3");
|
|
|
|
/* Should be the same as setting 0 */
|
|
sock.ReceiveTimeout = -1;
|
|
Assert.AreEqual (0, sock.ReceiveTimeout, "ReceiveTimeoutChange #4");
|
|
|
|
sock.ReceiveTimeout = 65536;
|
|
Assert.AreEqual (65536, Approximate (65536, sock.ReceiveTimeout), "ReceiveTimeoutChange #5");
|
|
|
|
try {
|
|
sock.ReceiveTimeout = -2;
|
|
Assert.Fail ("ReceiveTimeoutChange #8");
|
|
} catch (ArgumentOutOfRangeException) {
|
|
} 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);
|
|
|
|
Assert.AreEqual (false, sock.NoDelay, "NoDelayDefaultTcp");
|
|
|
|
sock.Close ();
|
|
}
|
|
|
|
[Test]
|
|
public void NoDelayChangeTcp ()
|
|
{
|
|
Socket sock = new Socket (AddressFamily.InterNetwork,
|
|
SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
|
|
sock.NoDelay = true;
|
|
|
|
Assert.AreEqual (true, sock.NoDelay, "NoDelayChangeTcp");
|
|
|
|
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");
|
|
} 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");
|
|
} 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]
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#else
|
|
[ExpectedException (typeof(InvalidOperationException))]
|
|
#endif
|
|
public void BeginAcceptNotListening ()
|
|
{
|
|
Socket sock = new Socket (AddressFamily.InterNetwork,
|
|
SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
|
|
sock.Bind (new IPEndPoint (IPAddress.Any, 0));
|
|
|
|
sock.BeginAccept (BACallback, sock);
|
|
|
|
sock.Close ();
|
|
}
|
|
|
|
[Test]
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#endif
|
|
public void BeginAccept ()
|
|
{
|
|
Socket sock = new Socket (AddressFamily.InterNetwork,
|
|
SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
|
|
sock.Bind (IPAddress.Loopback, out IPEndPoint 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");
|
|
}
|
|
|
|
Assert.AreEqual (true, BAAccepted, "BeginAccept #1");
|
|
Assert.AreEqual (true, BASocket.Connected, "BeginAccept #2");
|
|
Assert.AreEqual (false, sock.Connected, "BeginAccept #3");
|
|
Assert.AreEqual (true, conn.Connected, "BeginAccept #4");
|
|
|
|
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]
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#endif
|
|
public void BeginAcceptData ()
|
|
{
|
|
Socket sock = new Socket (AddressFamily.InterNetwork,
|
|
SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
|
|
sock.Bind (IPAddress.Loopback, out IPEndPoint 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");
|
|
}
|
|
|
|
Assert.AreEqual (true, BADAccepted, "BeginAcceptData #1");
|
|
Assert.AreEqual (true, BADSocket.Connected, "BeginAcceptData #2");
|
|
Assert.AreEqual (false, sock.Connected, "BeginAcceptData #3");
|
|
Assert.AreEqual (true, conn.Connected, "BeginAcceptData #4");
|
|
Assert.AreEqual (send_bytes.Length, BADByteCount, "BeginAcceptData #5");
|
|
|
|
/* 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++) {
|
|
Assert.AreEqual (send_bytes[i], BADBytes[i], "BeginAcceptData #" + (i+7).ToString ());
|
|
}
|
|
|
|
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]
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#endif
|
|
public void BeginAcceptSocketUdp ()
|
|
{
|
|
Socket sock = new Socket (AddressFamily.InterNetwork,
|
|
SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
Socket acc = new Socket (AddressFamily.InterNetwork,
|
|
SocketType.Dgram,
|
|
ProtocolType.Udp);
|
|
|
|
sock.Bind (IPAddress.Loopback, out int _);
|
|
sock.Listen (1);
|
|
|
|
try {
|
|
sock.BeginAccept (acc, 256, BADCallback, sock);
|
|
Assert.Fail ("BeginAcceptSocketUdp #1");
|
|
} catch (SocketException ex) {
|
|
Assert.AreEqual (10022, ex.ErrorCode, "BeginAcceptSocketUdp #2");
|
|
} finally {
|
|
acc.Close ();
|
|
sock.Close ();
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#endif
|
|
public void BeginAcceptSocketBound ()
|
|
{
|
|
Socket sock = new Socket (AddressFamily.InterNetwork,
|
|
SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
Socket acc = new Socket (AddressFamily.InterNetwork,
|
|
SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
|
|
sock.Bind (IPAddress.Loopback, out IPEndPoint ep1);
|
|
sock.Listen (1);
|
|
|
|
acc.Bind (IPAddress.Loopback, out IPEndPoint ep2);
|
|
|
|
try {
|
|
sock.BeginAccept (acc, 256, BADCallback, sock);
|
|
Assert.Fail ("BeginAcceptSocketBound #1");
|
|
} catch (InvalidOperationException) {
|
|
} finally {
|
|
acc.Close ();
|
|
sock.Close ();
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#endif
|
|
public void BeginAcceptSocket ()
|
|
{
|
|
Socket sock = new Socket (AddressFamily.InterNetwork,
|
|
SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
Socket acc = new Socket (AddressFamily.InterNetwork,
|
|
SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
|
|
sock.Bind (IPAddress.Loopback, out IPEndPoint 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");
|
|
}
|
|
|
|
Assert.AreEqual (true, BADAccepted, "BeginAcceptSocket #1");
|
|
Assert.AreEqual (true, BADSocket.Connected, "BeginAcceptSocket #2");
|
|
Assert.AreEqual (false, sock.Connected, "BeginAcceptSocket #3");
|
|
Assert.AreEqual (true, conn.Connected, "BeginAcceptSocket #4");
|
|
Assert.AreEqual (send_bytes.Length, BADByteCount, "BeginAcceptSocket #5");
|
|
Assert.AreEqual (AddressFamily.InterNetwork, acc.AddressFamily, "BeginAcceptSocket #6");
|
|
Assert.AreEqual (SocketType.Stream, acc.SocketType, "BeginAcceptSocket #7");
|
|
Assert.AreEqual (ProtocolType.Tcp, acc.ProtocolType, "BeginAcceptSocket #8");
|
|
Assert.AreEqual (conn.LocalEndPoint, acc.RemoteEndPoint, "BeginAcceptSocket #9");
|
|
|
|
/* 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++) {
|
|
Assert.AreEqual (send_bytes[i], BADBytes[i], "BeginAcceptSocket #" + (i+11).ToString ());
|
|
}
|
|
|
|
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) {
|
|
} finally {
|
|
acc.Close ();
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#endif
|
|
public void BeginAcceptSocketAccClosed ()
|
|
{
|
|
Socket sock = new Socket (AddressFamily.InterNetwork,
|
|
SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
Socket acc = new Socket (AddressFamily.InterNetwork,
|
|
SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
|
|
sock.Bind (IPAddress.Loopback, out int _);
|
|
sock.Listen (1);
|
|
|
|
acc.Close ();
|
|
|
|
BADCalledBack.Reset ();
|
|
|
|
try {
|
|
sock.BeginAccept (acc, 256, BADCallback, null);
|
|
Assert.Fail ("BeginAcceptSocketAccClosed #1");
|
|
} catch (ObjectDisposedException) {
|
|
} finally {
|
|
sock.Close ();
|
|
}
|
|
}
|
|
|
|
static bool BCConnected = false;
|
|
static ManualResetEvent BCCalledBack = new ManualResetEvent (false);
|
|
|
|
private static void BCCallback (IAsyncResult asyncResult)
|
|
{
|
|
Socket sock = (Socket)asyncResult.AsyncState;
|
|
|
|
try {
|
|
sock.EndConnect (asyncResult);
|
|
} catch (Exception e) {
|
|
Console.WriteLine ("BCCallback exception:");
|
|
Console.WriteLine (e);
|
|
|
|
throw;
|
|
}
|
|
|
|
BCConnected = true;
|
|
|
|
BCCalledBack.Set ();
|
|
}
|
|
|
|
[Test]
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#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;
|
|
|
|
listen.Bind (ip, out IPEndPoint ep);
|
|
listen.Listen (1);
|
|
|
|
BCCalledBack.Reset ();
|
|
|
|
BCConnected = false;
|
|
|
|
sock.BeginConnect (ip, ep.Port, BCCallback, sock);
|
|
|
|
if (BCCalledBack.WaitOne (2000, false) == false) {
|
|
Assert.Fail ("BeginConnectAddressPort wait timed out");
|
|
}
|
|
|
|
Assert.AreEqual (true, BCConnected, "BeginConnectAddressPort #1");
|
|
|
|
sock.Close ();
|
|
listen.Close ();
|
|
}
|
|
|
|
[Test]
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#endif
|
|
public void BeginConnectHostNamePortWithoutCallback ()
|
|
{
|
|
Socket sock = new Socket (AddressFamily.InterNetwork,
|
|
SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
Socket listen = new Socket (AddressFamily.InterNetwork,
|
|
SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
|
|
listen.Bind (IPAddress.Loopback, out IPEndPoint ep);
|
|
listen.Listen (1);
|
|
|
|
IAsyncResult result = sock.BeginConnect (IPAddress.Loopback.ToString (), ep.Port, null, null);
|
|
|
|
if (result.AsyncWaitHandle.WaitOne (2000, false) == false) {
|
|
Assert.Fail ("BeginConnectHostNamePortWithoutCallback wait timed out");
|
|
}
|
|
|
|
Assert.AreEqual (true, result.IsCompleted, "BeginConnectHostNamePortWithoutCallback #1");
|
|
|
|
sock.EndConnect (result);
|
|
|
|
sock.Close ();
|
|
listen.Close ();
|
|
}
|
|
|
|
[Test]
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#endif
|
|
public void BeginConnectHostNamePortWithCallback ()
|
|
{
|
|
Socket sock = new Socket (AddressFamily.InterNetwork,
|
|
SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
Socket listen = new Socket (AddressFamily.InterNetwork,
|
|
SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
|
|
listen.Bind (IPAddress.Loopback, out IPEndPoint ep);
|
|
listen.Listen (1);
|
|
|
|
BCCalledBack.Reset ();
|
|
|
|
BCConnected = false;
|
|
|
|
IAsyncResult result = sock.BeginConnect (IPAddress.Loopback.ToString (), ep.Port, BCCallback, sock);
|
|
|
|
if (BCCalledBack.WaitOne (2000, false) == false) {
|
|
Assert.Fail ("BeginConnectHostNamePortWithCallback wait timed out");
|
|
}
|
|
|
|
Assert.AreEqual (true, BCConnected, "BeginConnectHostNamePortWithCallback #1");
|
|
|
|
sock.Close ();
|
|
listen.Close ();
|
|
}
|
|
|
|
[Test]
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#endif
|
|
public void BeginConnectAddressPortNull ()
|
|
{
|
|
var port = NetworkHelpers.FindFreePort ();
|
|
Socket sock = new Socket (AddressFamily.InterNetwork,
|
|
SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
IPAddress ip = null;
|
|
|
|
try {
|
|
sock.BeginConnect (ip, port, BCCallback,
|
|
sock);
|
|
Assert.Fail ("BeginConnectAddressPortNull #1");
|
|
} catch (ArgumentNullException) {
|
|
} finally {
|
|
sock.Close ();
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#endif
|
|
public void BeginConnectAddressPortListen ()
|
|
{
|
|
Socket sock = new Socket (AddressFamily.InterNetwork,
|
|
SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
IPAddress ip = IPAddress.Loopback;
|
|
|
|
sock.Bind (ip, out IPEndPoint ep);
|
|
sock.Listen (1);
|
|
|
|
try {
|
|
sock.BeginConnect (ip, ep.Port, BCCallback, sock);
|
|
Assert.Fail ("BeginConnectAddressPortListen #1");
|
|
} catch (InvalidOperationException) {
|
|
} finally {
|
|
sock.Close ();
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#else
|
|
[ExpectedException (typeof(ObjectDisposedException))]
|
|
#endif
|
|
public void BeginConnectAddressPortClosed ()
|
|
{
|
|
var port = NetworkHelpers.FindFreePort ();
|
|
Socket sock = new Socket (AddressFamily.InterNetwork,
|
|
SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
IPAddress ip = IPAddress.Loopback;
|
|
|
|
sock.Close ();
|
|
|
|
sock.BeginConnect (ip, port, BCCallback, sock);
|
|
}
|
|
|
|
[Test]
|
|
[Category ("NotOnMac")]
|
|
/*
|
|
* This is not a Mono bug.
|
|
*
|
|
* By default, only 127.0.0.1 is enabled and you must explicitly
|
|
* enable additional addresses using 'sudo ifconfig lo0 alias 127.0.0.1'.
|
|
*
|
|
* I tested this on Mac OS 10.7.4; a 'ping 127.0.0.2' does not work
|
|
* until I add that alias.
|
|
*
|
|
*/
|
|
public void BeginConnectMultiple ()
|
|
{
|
|
Socket sock = new Socket (AddressFamily.InterNetwork,
|
|
SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
Socket listen = 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");
|
|
|
|
listen.Bind (IPAddress.Loopback, out IPEndPoint ep);
|
|
listen.Listen (1);
|
|
|
|
BCCalledBack.Reset ();
|
|
|
|
BCConnected = false;
|
|
|
|
sock.BeginConnect (ips, ep.Port, BCCallback, sock);
|
|
|
|
/* Longer wait here, because the ms runtime
|
|
* takes a lot longer to not connect
|
|
*/
|
|
/*
|
|
if (BCCalledBack.WaitOne (30000, false) == false) {
|
|
Assert.Fail ("BeginConnectMultiple wait failed");
|
|
}
|
|
*/
|
|
|
|
Assert.IsTrue (BCCalledBack.WaitOne (30000), "#0");
|
|
|
|
Assert.AreEqual (true, BCConnected, "BeginConnectMultiple #1");
|
|
Assert.AreEqual (AddressFamily.InterNetwork, sock.RemoteEndPoint.AddressFamily, "BeginConnectMultiple #2");
|
|
IPEndPoint remep = (IPEndPoint)sock.RemoteEndPoint;
|
|
|
|
Assert.AreEqual (IPAddress.Loopback, remep.Address, "BeginConnectMultiple #2");
|
|
|
|
sock.Close ();
|
|
listen.Close ();
|
|
}
|
|
|
|
[Test]
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#endif
|
|
public void BeginConnectMultiple2 ()
|
|
{
|
|
Socket sock = new Socket (AddressFamily.InterNetwork,
|
|
SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
Socket listen = new Socket (AddressFamily.InterNetwork,
|
|
SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
|
|
// Need at least two addresses.
|
|
var ips = Dns.GetHostAddresses ("localhost");
|
|
if (ips.Length < 1)
|
|
Assert.Ignore ("This test needs at least two IP addresses.");
|
|
|
|
var allIps = new IPAddress [ips.Length + 1];
|
|
allIps [0] = IPAddress.Loopback;
|
|
ips.CopyTo (allIps, 1);
|
|
|
|
/*
|
|
* Only bind to the loopback interface, so all the non-loopback
|
|
* IP addresses will fail. BeginConnect()/EndConnect() should
|
|
* succeed it it can connect to at least one of the requested
|
|
* addresses.
|
|
*/
|
|
listen.Bind (IPAddress.Loopback, out IPEndPoint ep);
|
|
listen.Listen (1);
|
|
|
|
BCCalledBack.Reset ();
|
|
|
|
BCConnected = false;
|
|
|
|
sock.BeginConnect (allIps, ep.Port, BCCallback, sock);
|
|
|
|
/* Longer wait here, because the ms runtime
|
|
* takes a lot longer to not connect
|
|
*/
|
|
if (BCCalledBack.WaitOne (10000, false) == false) {
|
|
Assert.Fail ("BeginConnectMultiple2 wait failed");
|
|
}
|
|
|
|
Assert.AreEqual (true, BCConnected, "BeginConnectMultiple2 #1");
|
|
Assert.AreEqual (AddressFamily.InterNetwork, sock.RemoteEndPoint.AddressFamily, "BeginConnectMultiple2 #2");
|
|
IPEndPoint remep = (IPEndPoint)sock.RemoteEndPoint;
|
|
|
|
Assert.AreEqual (IPAddress.Loopback, remep.Address, "BeginConnectMultiple2 #2");
|
|
|
|
sock.Close ();
|
|
listen.Close ();
|
|
}
|
|
|
|
|
|
[Test]
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#endif
|
|
public void BeginConnectMultipleNull ()
|
|
{
|
|
var port = NetworkHelpers.FindFreePort ();
|
|
Socket sock = new Socket (AddressFamily.InterNetwork,
|
|
SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
IPAddress[] ips = null;
|
|
|
|
try {
|
|
sock.BeginConnect (ips, port, BCCallback,
|
|
sock);
|
|
Assert.Fail ("BeginConnectMultipleNull #1");
|
|
} catch (ArgumentNullException) {
|
|
} finally {
|
|
sock.Close ();
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#endif
|
|
public void BeginConnectMultipleListen ()
|
|
{
|
|
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.Bind (IPAddress.Loopback, out IPEndPoint ep);
|
|
sock.Listen (1);
|
|
|
|
try {
|
|
sock.BeginConnect (ips, ep.Port, BCCallback,
|
|
sock);
|
|
Assert.Fail ("BeginConnectMultipleListen #1");
|
|
} catch (InvalidOperationException) {
|
|
} finally {
|
|
sock.Close ();
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#else
|
|
[ExpectedException (typeof(ObjectDisposedException))]
|
|
#endif
|
|
public void BeginConnectMultipleClosed ()
|
|
{
|
|
var port = NetworkHelpers.FindFreePort ();
|
|
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, port, 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) {
|
|
} finally {
|
|
sock.Close ();
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#endif
|
|
public void BeginConnectHostPortListen ()
|
|
{
|
|
Socket sock = new Socket (AddressFamily.InterNetwork,
|
|
SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
IPAddress ip = IPAddress.Loopback;
|
|
|
|
sock.Bind (ip, out IPEndPoint ep);
|
|
sock.Listen (1);
|
|
|
|
try {
|
|
sock.BeginConnect ("localhost", ep.Port,
|
|
BCCallback, sock);
|
|
Assert.Fail ("BeginConnectHostPortListen #1");
|
|
} catch (InvalidOperationException) {
|
|
} 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) {
|
|
} 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"
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#endif
|
|
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;
|
|
|
|
listen.Bind (ip, out IPEndPoint ep);
|
|
listen.Listen (1);
|
|
|
|
sock.Connect (ip, ep.Port);
|
|
|
|
Assert.AreEqual (true, sock.Connected, "BeginDisconnect #1");
|
|
|
|
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");
|
|
}
|
|
|
|
Assert.AreEqual (true, BDDisconnected, "BeginDisconnect #2");
|
|
Assert.AreEqual (false, sock.Connected, "BeginDisconnect #3");
|
|
|
|
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) {
|
|
Assert.AreEqual (10057, ex.ErrorCode, "BeginSendNotConnected #2");
|
|
} finally {
|
|
sock.Close ();
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void BeginSendSocketError ()
|
|
{
|
|
}
|
|
|
|
[Test]
|
|
public void BeginSendGeneric ()
|
|
{
|
|
}
|
|
|
|
[Test]
|
|
public void BeginSendGenericSocketError ()
|
|
{
|
|
}
|
|
|
|
[Test]
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#endif
|
|
public void BindTwice ()
|
|
{
|
|
Socket sock = new Socket (AddressFamily.InterNetwork,
|
|
SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
|
|
sock.Bind (IPAddress.Loopback, out IPEndPoint ep1);
|
|
|
|
try {
|
|
sock.Bind (IPAddress.Loopback, out IPEndPoint ep2);
|
|
Assert.Fail ("BindTwice #1");
|
|
} catch (SocketException ex) {
|
|
Assert.AreEqual (10022, ex.ErrorCode, "BindTwice #2");
|
|
} finally {
|
|
sock.Close ();
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#endif
|
|
public void Close ()
|
|
{
|
|
Socket sock = new Socket (AddressFamily.InterNetwork,
|
|
SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
Socket listen = new Socket (AddressFamily.InterNetwork,
|
|
SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
|
|
listen.Bind (IPAddress.Loopback, out IPEndPoint ep);
|
|
listen.Listen (1);
|
|
|
|
sock.Connect (ep);
|
|
|
|
Assert.AreEqual (true, sock.Connected, "Close #1");
|
|
|
|
sock.Close (2);
|
|
|
|
Thread.Sleep (3000);
|
|
|
|
Assert.AreEqual (false, sock.Connected, "Close #2");
|
|
|
|
listen.Close ();
|
|
}
|
|
|
|
[Test]
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#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;
|
|
|
|
listen.Bind (ip, out IPEndPoint ep);
|
|
listen.Listen (1);
|
|
|
|
sock.Connect (ip, ep.Port);
|
|
|
|
Assert.AreEqual (true, sock.Connected, "ConnectAddressPort #1");
|
|
|
|
sock.Close ();
|
|
listen.Close ();
|
|
}
|
|
|
|
[Test]
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#endif
|
|
public void ConnectAddressPortNull ()
|
|
{
|
|
var port = NetworkHelpers.FindFreePort ();
|
|
Socket sock = new Socket (AddressFamily.InterNetwork,
|
|
SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
IPAddress ip = null;
|
|
|
|
try {
|
|
sock.Connect (ip, port);
|
|
Assert.Fail ("ConnectAddressPortNull #1");
|
|
} catch (ArgumentNullException) {
|
|
} finally {
|
|
sock.Close ();
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#endif
|
|
public void ConnectAddressPortListen ()
|
|
{
|
|
Socket sock = new Socket (AddressFamily.InterNetwork,
|
|
SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
IPAddress ip = IPAddress.Loopback;
|
|
|
|
sock.Bind (ip, out IPEndPoint ep);
|
|
sock.Listen (1);
|
|
|
|
try {
|
|
sock.Connect (ip, ep.Port);
|
|
Assert.Fail ("ConnectAddressPortListen #1");
|
|
} catch (InvalidOperationException) {
|
|
} finally {
|
|
sock.Close ();
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#else
|
|
[ExpectedException (typeof(ObjectDisposedException))]
|
|
#endif
|
|
public void ConnectAddressPortClosed ()
|
|
{
|
|
var port = NetworkHelpers.FindFreePort ();
|
|
Socket sock = new Socket (AddressFamily.InterNetwork,
|
|
SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
IPAddress ip = IPAddress.Loopback;
|
|
|
|
sock.Close ();
|
|
|
|
sock.Connect (ip, port);
|
|
}
|
|
|
|
[Test]
|
|
[Category ("NotOnMac")] // MacOSX trashes the fd after the failed connect attempt to 127.0.0.4
|
|
/*
|
|
* This is not a Mono bug.
|
|
*
|
|
* By default, only 127.0.0.1 is enabled and you must explicitly
|
|
* enable additional addresses using 'sudo ifconfig lo0 alias 127.0.0.1'.
|
|
*
|
|
* I tested this on Mac OS 10.7.4; a 'ping 127.0.0.2' does not work
|
|
* until I add that alias.
|
|
*
|
|
* However, after doing so, Mac OS treats these as separate addresses, ie. attempting
|
|
* to connect to 127.0.0.4 yields a connection refused.
|
|
*
|
|
* When using Connect(), the .NET runtime also throws an exception if connecting to
|
|
* any of the IP addresses fails. This is different with BeginConnect()/EndConnect()
|
|
* which succeeds when it can connect to at least one of the addresses.
|
|
*
|
|
*/
|
|
public void ConnectMultiple ()
|
|
{
|
|
Socket sock = new Socket (AddressFamily.InterNetwork,
|
|
SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
Socket listen = 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");
|
|
|
|
listen.Bind (IPAddress.Loopback, out IPEndPoint ep);
|
|
listen.Listen (1);
|
|
|
|
sock.Connect (ips, ep.Port);
|
|
|
|
Assert.AreEqual (true, sock.Connected, "ConnectMultiple #1");
|
|
Assert.AreEqual (AddressFamily.InterNetwork, sock.RemoteEndPoint.AddressFamily, "ConnectMultiple #2");
|
|
IPEndPoint remep = (IPEndPoint)sock.RemoteEndPoint;
|
|
|
|
Assert.AreEqual (IPAddress.Loopback, remep.Address, "ConnectMultiple #2");
|
|
|
|
sock.Close ();
|
|
listen.Close ();
|
|
}
|
|
|
|
[Test]
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#endif
|
|
public void ConnectMultiple2 ()
|
|
{
|
|
Socket sock = new Socket (AddressFamily.InterNetwork,
|
|
SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
Socket listen = new Socket (AddressFamily.InterNetwork,
|
|
SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
|
|
// Need at least two addresses.
|
|
var ips = Dns.GetHostAddresses ("localhost");
|
|
if (ips.Length < 1)
|
|
Assert.Ignore ("This test needs at least two IP addresses.");
|
|
|
|
var allIps = new IPAddress [ips.Length + 1];
|
|
allIps [0] = IPAddress.Loopback;
|
|
ips.CopyTo (allIps, 1);
|
|
|
|
/*
|
|
* Bind to IPAddress.Any; Connect() will fail unless it can
|
|
* connect to all the addresses in allIps.
|
|
*/
|
|
|
|
listen.Bind (IPAddress.Any, out IPEndPoint ep);
|
|
listen.Listen (1);
|
|
|
|
sock.Connect (allIps, ep.Port);
|
|
|
|
Assert.AreEqual (true, sock.Connected, "ConnectMultiple2 #1");
|
|
Assert.AreEqual (AddressFamily.InterNetwork, sock.RemoteEndPoint.AddressFamily, "ConnectMultiple2 #2");
|
|
IPEndPoint remep = (IPEndPoint)sock.RemoteEndPoint;
|
|
|
|
Assert.AreEqual (IPAddress.Loopback, remep.Address, "ConnectMultiple2 #3");
|
|
|
|
sock.Close ();
|
|
listen.Close ();
|
|
}
|
|
|
|
[Test]
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#endif
|
|
public void ConnectMultipleNull ()
|
|
{
|
|
var port = NetworkHelpers.FindFreePort ();
|
|
Socket sock = new Socket (AddressFamily.InterNetwork,
|
|
SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
IPAddress[] ips = null;
|
|
|
|
try {
|
|
sock.Connect (ips, port);
|
|
Assert.Fail ("ConnectMultipleNull #1");
|
|
} catch (ArgumentNullException) {
|
|
} finally {
|
|
sock.Close ();
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#endif
|
|
public void ConnectMultipleListen ()
|
|
{
|
|
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.Bind (IPAddress.Loopback, out IPEndPoint ep);
|
|
sock.Listen (1);
|
|
|
|
try {
|
|
sock.Connect (ips, ep.Port);
|
|
Assert.Fail ("ConnectMultipleListen #1");
|
|
} catch (InvalidOperationException) {
|
|
} finally {
|
|
sock.Close ();
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#else
|
|
[ExpectedException (typeof(ObjectDisposedException))]
|
|
#endif
|
|
public void ConnectMultipleClosed ()
|
|
{
|
|
var port = NetworkHelpers.FindFreePort ();
|
|
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, port);
|
|
}
|
|
|
|
[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) {
|
|
} finally {
|
|
sock.Close ();
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#endif
|
|
public void ConnectHostPortListen ()
|
|
{
|
|
Socket sock = new Socket (AddressFamily.InterNetwork,
|
|
SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
IPAddress ip = IPAddress.Loopback;
|
|
|
|
sock.Bind (ip, out IPEndPoint ep);
|
|
sock.Listen (1);
|
|
|
|
try {
|
|
sock.Connect ("localhost", ep.Port);
|
|
Assert.Fail ("ConnectHostPortListen #1");
|
|
} catch (InvalidOperationException) {
|
|
} 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) {
|
|
} finally {
|
|
sock.Close ();
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#else
|
|
[ExpectedException (typeof(ObjectDisposedException))]
|
|
#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 FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#endif
|
|
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;
|
|
|
|
listen.Bind (ip, out IPEndPoint ep);
|
|
listen.Listen (1);
|
|
|
|
sock.Connect (ip, ep.Port);
|
|
|
|
Assert.AreEqual (true, sock.Connected, "Disconnect #1");
|
|
|
|
sock.Shutdown (SocketShutdown.Both);
|
|
|
|
sock.Disconnect (false);
|
|
|
|
Assert.AreEqual (false, sock.Connected, "BeginDisconnect #3");
|
|
|
|
sock.Close ();
|
|
listen.Close ();
|
|
}
|
|
|
|
[Test]
|
|
public void DuplicateAndClose ()
|
|
{
|
|
}
|
|
|
|
[Test]
|
|
public void IOControl ()
|
|
{
|
|
}
|
|
|
|
[Test]
|
|
public void TestDefaultsDualMode ()
|
|
{
|
|
using (var socket = new Socket (AddressFamily.InterNetworkV6, SocketType.Stream, ProtocolType.Tcp)){
|
|
Assert.IsTrue (socket.DualMode, "In Mono, DualMode must be true when constructing InterNetworkV6 sockets");
|
|
}
|
|
|
|
using (var socket = new Socket (SocketType.Stream, ProtocolType.Tcp)){
|
|
Assert.AreEqual (AddressFamily.InterNetworkV6, socket.AddressFamily, "When creating sockets of type stream/tcp, the address family should be InterNetworkV6");
|
|
Assert.IsTrue (socket.DualMode, "In Mono, DualMode must be true when constructing InterNetworkV6 sockets");
|
|
|
|
socket.DualMode = false;
|
|
|
|
Assert.IsFalse (socket.DualMode, "Setting of DualSocket should turn DualSockets off");
|
|
}
|
|
|
|
}
|
|
|
|
[Test]
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#endif
|
|
public void ReceiveGeneric ()
|
|
{
|
|
int i;
|
|
|
|
Socket listensock = new Socket (AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
|
|
listensock.Bind (IPAddress.Loopback, out IPEndPoint endpoint);
|
|
listensock.Listen(1);
|
|
|
|
Socket sendsock = new Socket (AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
|
|
sendsock.Connect(endpoint);
|
|
|
|
Socket clientsock = listensock.Accept();
|
|
|
|
byte[] sendbuf = new byte[256];
|
|
|
|
for(i = 0; i < 256; i++) {
|
|
sendbuf[i] = (byte)i;
|
|
}
|
|
for (i = 4; i < 6; i++) {
|
|
Assert.AreEqual (sendbuf[i], (byte)i,
|
|
"#1/" + i.ToString());
|
|
}
|
|
|
|
SocketError err;
|
|
sendsock.Send (sendbuf, 0, 256, SocketFlags.None,
|
|
out err);
|
|
|
|
|
|
byte[] recvbuf = new byte[256];
|
|
List<ArraySegment<byte>> recvbuflist = new List<ArraySegment<byte>>(2);
|
|
recvbuflist.Add(new ArraySegment<byte>(recvbuf, 4, 2));
|
|
recvbuflist.Add(new ArraySegment<byte>(recvbuf, 20, 230));
|
|
|
|
clientsock.Receive (recvbuflist);
|
|
|
|
/* recvbuf should now hold the first 2 bytes
|
|
* of sendbuf from pos 4, and the next 230
|
|
* bytes of sendbuf from pos 20
|
|
*/
|
|
|
|
for (i = 0; i < 2; i++) {
|
|
Assert.AreEqual (sendbuf[i], recvbuf[i + 4],
|
|
"#2/" + i.ToString());
|
|
}
|
|
for (i = 2; i < 232; i++) {
|
|
Assert.AreEqual (sendbuf[i], recvbuf[i + 18],
|
|
"#2/" + i.ToString());
|
|
}
|
|
|
|
sendsock.Close ();
|
|
clientsock.Close ();
|
|
listensock.Close ();
|
|
}
|
|
|
|
[Test]
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#endif
|
|
public void SendGeneric ()
|
|
{
|
|
int i;
|
|
|
|
Socket listensock = new Socket (AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
|
|
listensock.Bind (IPAddress.Loopback, out IPEndPoint endpoint);
|
|
listensock.Listen(1);
|
|
|
|
Socket sendsock = new Socket (AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
|
|
sendsock.Connect(endpoint);
|
|
|
|
Socket clientsock = listensock.Accept();
|
|
|
|
byte[] sendbuf = new byte[256];
|
|
List<ArraySegment<byte>> sendbuflist = new List<ArraySegment<byte>>(2);
|
|
|
|
sendbuflist.Add(new ArraySegment<byte>(sendbuf, 4, 2));
|
|
sendbuflist.Add(new ArraySegment<byte>(sendbuf, 20, 230));
|
|
|
|
for(i = 0; i < 256; i++) {
|
|
sendbuf[i] = (byte)i;
|
|
}
|
|
for (i = 4; i < 6; i++) {
|
|
Assert.AreEqual (sendbuf[i], (byte)i,
|
|
"#1/" + i.ToString());
|
|
}
|
|
|
|
SocketError err;
|
|
sendsock.Send (sendbuflist, SocketFlags.None, out err);
|
|
|
|
|
|
byte[] recvbuf = new byte[256];
|
|
|
|
clientsock.Receive (recvbuf);
|
|
|
|
/* The first 2 bytes of recvbuf should now
|
|
* hold 2 bytes of sendbuf from pos 4, and the
|
|
* next 230 bytes of recvbuf should be sendbuf
|
|
* from pos 20
|
|
*/
|
|
|
|
for (i = 0; i < 2; i++) {
|
|
Assert.AreEqual (recvbuf[i], sendbuf[i + 4],
|
|
"#2/" + i.ToString());
|
|
}
|
|
for (i = 2; i < 232; i++) {
|
|
Assert.AreEqual (recvbuf[i], sendbuf[i + 18],
|
|
"#2/" + i.ToString());
|
|
}
|
|
|
|
sendsock.Close ();
|
|
clientsock.Close ();
|
|
listensock.Close ();
|
|
}
|
|
|
|
[Test]
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (AggregateException))] // Something catches the PlatformNotSupportedException and re-throws an AggregateException
|
|
#endif
|
|
public void ConcurrentExceedSocketLimit ()
|
|
{
|
|
var tasks = new Task[4];
|
|
for (int i = 0; i < 4; i++) {
|
|
tasks[i] = Task.Factory.StartNew (() => SendGenericExceedBuffer ());
|
|
}
|
|
Task.WaitAll (tasks);
|
|
}
|
|
|
|
[Test]
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#endif
|
|
public void SendGenericExceedBuffer ()
|
|
{
|
|
// Create a buffer larger than the default max.
|
|
const int BUFFER_SIZE = 65 * 1024;
|
|
int i;
|
|
|
|
Socket listensock = new Socket (AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
|
|
listensock.Bind (IPAddress.Loopback, out IPEndPoint endpoint);
|
|
listensock.Listen (1);
|
|
|
|
Socket sendsock = new Socket (AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
|
|
sendsock.Connect (endpoint);
|
|
|
|
Socket clientsock = listensock.Accept ();
|
|
|
|
byte[] sendbuf = new byte[BUFFER_SIZE];
|
|
|
|
for (i = 0; i < BUFFER_SIZE; i++) {
|
|
sendbuf[i] = (byte)i;
|
|
}
|
|
|
|
Task sendTask = Task.Factory.StartNew(() => {
|
|
int sent = sendsock.Send (sendbuf);
|
|
|
|
Assert.AreEqual (BUFFER_SIZE, sent, "#1");
|
|
});
|
|
|
|
byte[] recvbuf = new byte[BUFFER_SIZE];
|
|
|
|
Task recvTask = Task.Factory.StartNew(() => {
|
|
int totalReceived = 0;
|
|
byte[] buffer = new byte[256];
|
|
while (totalReceived < sendbuf.Length) {
|
|
int recvd = clientsock.Receive (buffer, 0, buffer.Length, SocketFlags.None);
|
|
Array.Copy (buffer, 0, recvbuf, totalReceived, recvd);
|
|
totalReceived += recvd;
|
|
}
|
|
|
|
Assert.AreEqual (BUFFER_SIZE, totalReceived, "#2");
|
|
});
|
|
|
|
Assert.IsTrue (Task.WaitAll (new []{sendTask, recvTask}, 20 * 1000), "#2a");
|
|
|
|
for (i = 0; i < BUFFER_SIZE; i++) {
|
|
Assert.AreEqual (recvbuf[i], sendbuf[i],
|
|
"#3/" + i.ToString());
|
|
}
|
|
|
|
sendsock.Close ();
|
|
clientsock.Close ();
|
|
listensock.Close ();
|
|
}
|
|
|
|
[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) {
|
|
Assert.AreEqual (10022, ex.ErrorCode, "ListenNotBound #2");
|
|
} finally {
|
|
sock.Close ();
|
|
}
|
|
}
|
|
|
|
static Socket CWRSocket;
|
|
static bool CWRReceiving = true;
|
|
static ManualResetEvent CWRReady = new ManualResetEvent (false);
|
|
|
|
private static void CWRReceiveThread ()
|
|
{
|
|
byte[] buf = new byte[256];
|
|
|
|
try {
|
|
CWRSocket.Receive (buf);
|
|
} catch (SocketException) {
|
|
CWRReceiving = false;
|
|
}
|
|
|
|
CWRReady.Set ();
|
|
}
|
|
|
|
[Test]
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#endif
|
|
public void CloseWhileReceiving ()
|
|
{
|
|
CWRSocket = new Socket (AddressFamily.InterNetwork,
|
|
SocketType.Dgram,
|
|
ProtocolType.Udp);
|
|
CWRSocket.Bind (IPAddress.Loopback, out int _);
|
|
|
|
Thread recv_thread = new Thread (new ThreadStart (CWRReceiveThread));
|
|
CWRReady.Reset ();
|
|
recv_thread.Start ();
|
|
Thread.Sleep (250); /* Wait for the thread to be already receiving */
|
|
|
|
CWRSocket.Close ();
|
|
if (CWRReady.WaitOne (1000, false) == false) {
|
|
Assert.Fail ("CloseWhileReceiving wait timed out");
|
|
}
|
|
|
|
Assert.IsFalse (CWRReceiving);
|
|
}
|
|
|
|
static bool RRCLastRead = false;
|
|
static ManualResetEvent RRCReady = new ManualResetEvent (false);
|
|
|
|
private static void RRCClientThread (int port)
|
|
{
|
|
byte[] bytes = new byte[8];
|
|
int readbyte;
|
|
|
|
Socket sock = new Socket (AddressFamily.InterNetwork,
|
|
SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
sock.Connect (new IPEndPoint (IPAddress.Loopback,
|
|
port));
|
|
|
|
NetworkStream stream = new NetworkStream (sock);
|
|
|
|
readbyte = stream.ReadByte ();
|
|
Assert.AreEqual (0, readbyte, "ReceiveRemoteClosed #1");
|
|
|
|
stream.Read (bytes, 0, 0);
|
|
|
|
readbyte = stream.ReadByte ();
|
|
Assert.AreEqual (0, readbyte, "ReceiveRemoteClosed #2");
|
|
|
|
stream.Read (bytes, 0, 0);
|
|
|
|
readbyte = stream.ReadByte ();
|
|
Assert.AreEqual (-1, readbyte, "ReceiveRemoteClosed #3");
|
|
|
|
sock.Close ();
|
|
|
|
RRCLastRead = true;
|
|
RRCReady.Set ();
|
|
}
|
|
|
|
[Test] // Receive (Byte [])
|
|
public void Receive1_Buffer_Null ()
|
|
{
|
|
Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
|
|
try {
|
|
s.Receive ((byte []) null);
|
|
Assert.Fail ("#1");
|
|
} catch (ArgumentNullException ex) {
|
|
Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
|
|
Assert.IsNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.AreEqual ("buffer", ex.ParamName, "#5");
|
|
} finally {
|
|
s.Close ();
|
|
}
|
|
}
|
|
|
|
[Test] // Receive (Byte [])
|
|
public void Receive1_Socket_Closed ()
|
|
{
|
|
Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
s.Close ();
|
|
|
|
try {
|
|
s.Receive ((byte []) null);
|
|
Assert.Fail ("#1");
|
|
} catch (ObjectDisposedException ex) {
|
|
// Cannot access a disposed object
|
|
Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#2");
|
|
Assert.IsNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.AreEqual (typeof (Socket).FullName, ex.ObjectName, "#5");
|
|
}
|
|
}
|
|
|
|
[Test] // Receive (Byte [], SocketFlags)
|
|
public void Receive2_Buffer_Null ()
|
|
{
|
|
Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
|
|
try {
|
|
s.Receive ((byte []) null, (SocketFlags) 666);
|
|
Assert.Fail ("#1");
|
|
} catch (ArgumentNullException ex) {
|
|
Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
|
|
Assert.IsNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.AreEqual ("buffer", ex.ParamName, "#5");
|
|
} finally {
|
|
s.Close ();
|
|
}
|
|
}
|
|
|
|
[Test] // Receive (Byte [], SocketFlags)
|
|
public void Receive2_Socket_Closed ()
|
|
{
|
|
Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
s.Close ();
|
|
|
|
try {
|
|
s.Receive ((byte []) null, (SocketFlags) 666);
|
|
Assert.Fail ("#1");
|
|
} catch (ObjectDisposedException ex) {
|
|
// Cannot access a disposed object
|
|
Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#2");
|
|
Assert.IsNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.AreEqual (typeof (Socket).FullName, ex.ObjectName, "#5");
|
|
}
|
|
}
|
|
|
|
[Test] // Receive (Byte [], Int32, SocketFlags)
|
|
public void Receive3_Buffer_Null ()
|
|
{
|
|
Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
|
|
try {
|
|
s.Receive ((byte []) null, 0, (SocketFlags) 666);
|
|
Assert.Fail ("#1");
|
|
} catch (ArgumentNullException ex) {
|
|
Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
|
|
Assert.IsNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.AreEqual ("buffer", ex.ParamName, "#5");
|
|
} finally {
|
|
s.Close ();
|
|
}
|
|
}
|
|
|
|
[Test] // Receive (Byte [], Int32, SocketFlags)
|
|
public void Receive3_Socket_Closed ()
|
|
{
|
|
Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
s.Close ();
|
|
|
|
try {
|
|
s.Receive ((byte []) null, 0, (SocketFlags) 666);
|
|
Assert.Fail ("#1");
|
|
} catch (ObjectDisposedException ex) {
|
|
// Cannot access a disposed object
|
|
Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#2");
|
|
Assert.IsNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.AreEqual (typeof (Socket).FullName, ex.ObjectName, "#5");
|
|
}
|
|
}
|
|
|
|
[Test] // Receive (Byte [], Int32, Int32, SocketFlags)
|
|
public void Receive4_Buffer_Null ()
|
|
{
|
|
Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
|
|
try {
|
|
s.Receive ((byte []) null, 0, 0, (SocketFlags) 666);
|
|
Assert.Fail ("#1");
|
|
} catch (ArgumentNullException ex) {
|
|
Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
|
|
Assert.IsNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.AreEqual ("buffer", ex.ParamName, "#5");
|
|
} finally {
|
|
s.Close ();
|
|
}
|
|
}
|
|
|
|
[Test] // Receive (Byte [], Int32, Int32, SocketFlags)
|
|
public void Receive4_Socket_Closed ()
|
|
{
|
|
Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
s.Close ();
|
|
|
|
try {
|
|
s.Receive ((byte []) null, 0, 0, (SocketFlags) 666);
|
|
Assert.Fail ("#1");
|
|
} catch (ObjectDisposedException ex) {
|
|
// Cannot access a disposed object
|
|
Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#2");
|
|
Assert.IsNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.AreEqual (typeof (Socket).FullName, ex.ObjectName, "#5");
|
|
}
|
|
}
|
|
|
|
[Test] // Receive (Byte [], Int32, Int32, SocketFlags, out SocketError)
|
|
public void Receive5_Buffer_Null ()
|
|
{
|
|
Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
|
|
SocketError error;
|
|
try {
|
|
s.Receive ((byte []) null, 0, 0, SocketFlags.None, out error);
|
|
Assert.Fail ("#1");
|
|
} catch (ArgumentNullException ex) {
|
|
Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
|
|
Assert.IsNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.AreEqual ("buffer", ex.ParamName, "#5");
|
|
} finally {
|
|
s.Close ();
|
|
}
|
|
}
|
|
|
|
[Test] // Receive (Byte [], Int32, Int32, SocketFlags, out SocketError)
|
|
public void Receive5_Socket_Closed ()
|
|
{
|
|
Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
s.Close ();
|
|
|
|
SocketError error;
|
|
try {
|
|
s.Receive ((byte []) null, 0, 0, SocketFlags.None, out error);
|
|
Assert.Fail ("#1");
|
|
} catch (ObjectDisposedException ex) {
|
|
// Cannot access a disposed object
|
|
Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#2");
|
|
Assert.IsNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.AreEqual (typeof (Socket).FullName, ex.ObjectName, "#5");
|
|
}
|
|
}
|
|
|
|
[Test] // Receive (IList<ArraySegment<Byte>>)
|
|
public void Receive6_Buffers_Null ()
|
|
{
|
|
Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
|
|
try {
|
|
s.Receive ((IList<ArraySegment<byte>>) null);
|
|
Assert.Fail ("#1");
|
|
} catch (ArgumentNullException ex) {
|
|
Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
|
|
Assert.IsNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.AreEqual ("buffers", ex.ParamName, "#5");
|
|
} finally {
|
|
s.Close ();
|
|
}
|
|
}
|
|
|
|
[Test] // Receive (IList<ArraySegment<Byte>>)
|
|
public void Receive6_Socket_Closed ()
|
|
{
|
|
Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
s.Close ();
|
|
|
|
try {
|
|
s.Receive ((IList<ArraySegment<byte>>) null);
|
|
Assert.Fail ("#1");
|
|
} catch (ObjectDisposedException ex) {
|
|
// Cannot access a disposed object
|
|
Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#2");
|
|
Assert.IsNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.AreEqual (typeof (Socket).FullName, ex.ObjectName, "#5");
|
|
}
|
|
}
|
|
|
|
[Test] // Receive (IList<ArraySegment<Byte>>, SocketFlags)
|
|
public void Receive7_Buffers_Null ()
|
|
{
|
|
Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
|
|
try {
|
|
s.Receive ((IList<ArraySegment<byte>>) null, (SocketFlags) 666);
|
|
Assert.Fail ("#1");
|
|
} catch (ArgumentNullException ex) {
|
|
Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
|
|
Assert.IsNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.AreEqual ("buffers", ex.ParamName, "#5");
|
|
} finally {
|
|
s.Close ();
|
|
}
|
|
}
|
|
|
|
[Test] // Receive (IList<ArraySegment<Byte>>, SocketFlags)
|
|
public void Receive7_Socket_Closed ()
|
|
{
|
|
Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
s.Close ();
|
|
|
|
try {
|
|
s.Receive ((IList<ArraySegment<byte>>) null, (SocketFlags) 666);
|
|
Assert.Fail ("#1");
|
|
} catch (ObjectDisposedException ex) {
|
|
// Cannot access a disposed object
|
|
Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#2");
|
|
Assert.IsNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.AreEqual (typeof (Socket).FullName, ex.ObjectName, "#5");
|
|
}
|
|
}
|
|
|
|
[Test] // Receive (IList<ArraySegment<Byte>>, SocketFlags, out SocketError)
|
|
public void Receive8_Buffers_Null ()
|
|
{
|
|
Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
|
|
SocketError error;
|
|
try {
|
|
s.Receive ((IList<ArraySegment<byte>>) null, (SocketFlags) 666,
|
|
out error);
|
|
Assert.Fail ("#1");
|
|
} catch (ArgumentNullException ex) {
|
|
Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
|
|
Assert.IsNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.AreEqual ("buffers", ex.ParamName, "#5");
|
|
} finally {
|
|
s.Close ();
|
|
}
|
|
}
|
|
|
|
[Test] // Receive (IList<ArraySegment<Byte>>, SocketFlags, out SocketError)
|
|
public void Receive8_Socket_Closed ()
|
|
{
|
|
Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
s.Close ();
|
|
|
|
SocketError error;
|
|
try {
|
|
s.Receive ((IList<ArraySegment<byte>>) null, (SocketFlags) 666,
|
|
out error);
|
|
Assert.Fail ("#1");
|
|
} catch (ObjectDisposedException ex) {
|
|
// Cannot access a disposed object
|
|
Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#2");
|
|
Assert.IsNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.AreEqual (typeof (Socket).FullName, ex.ObjectName, "#5");
|
|
} finally {
|
|
s.Close ();
|
|
}
|
|
}
|
|
|
|
[Test] // ReceiveFrom (Byte [], ref EndPoint)
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#endif
|
|
public void ReceiveFrom1_Buffer_Null ()
|
|
{
|
|
Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
|
|
EndPoint remoteEP = new IPEndPoint (IPAddress.Loopback, NetworkHelpers.FindFreePort ());
|
|
try {
|
|
s.ReceiveFrom ((Byte []) null, ref remoteEP);
|
|
Assert.Fail ("#1");
|
|
} catch (ArgumentNullException ex) {
|
|
Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
|
|
Assert.IsNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.AreEqual ("buffer", ex.ParamName, "#5");
|
|
} finally {
|
|
s.Close ();
|
|
}
|
|
}
|
|
|
|
[Test] // ReceiveFrom (Byte [], ref EndPoint)
|
|
public void ReceiveFrom1_RemoteEP_Null ()
|
|
{
|
|
Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
|
|
byte [] buffer = new byte [0];
|
|
EndPoint remoteEP = null;
|
|
try {
|
|
s.ReceiveFrom (buffer, ref remoteEP);
|
|
Assert.Fail ("#1");
|
|
} catch (ArgumentNullException ex) {
|
|
Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
|
|
Assert.IsNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.AreEqual ("remoteEP", ex.ParamName, "#5");
|
|
} finally {
|
|
s.Close ();
|
|
}
|
|
}
|
|
|
|
[Test] // ReceiveFrom (Byte [], ref EndPoint)
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#endif
|
|
public void ReceiveFrom1_Socket_Closed ()
|
|
{
|
|
Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
s.Close ();
|
|
|
|
EndPoint remoteEP = new IPEndPoint (IPAddress.Loopback, NetworkHelpers.FindFreePort ());
|
|
try {
|
|
s.ReceiveFrom ((Byte []) null, ref remoteEP);
|
|
Assert.Fail ("#1");
|
|
} catch (ObjectDisposedException ex) {
|
|
// Cannot access a disposed object
|
|
Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#2");
|
|
Assert.IsNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.AreEqual (typeof (Socket).FullName, ex.ObjectName, "#5");
|
|
}
|
|
}
|
|
|
|
[Test] // ReceiveFrom (Byte [], SocketFlags, ref EndPoint)
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#endif
|
|
public void ReceiveFrom2_Buffer_Null ()
|
|
{
|
|
Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
|
|
EndPoint remoteEP = new IPEndPoint (IPAddress.Loopback, NetworkHelpers.FindFreePort ());
|
|
try {
|
|
s.ReceiveFrom ((Byte []) null, (SocketFlags) 666, ref remoteEP);
|
|
Assert.Fail ("#1");
|
|
} catch (ArgumentNullException ex) {
|
|
Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
|
|
Assert.IsNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.AreEqual ("buffer", ex.ParamName, "#5");
|
|
} finally {
|
|
s.Close ();
|
|
}
|
|
}
|
|
|
|
[Test] // ReceiveFrom (Byte [], SocketFlags, ref EndPoint)
|
|
public void ReceiveFrom2_RemoteEP_Null ()
|
|
{
|
|
Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
|
|
byte [] buffer = new byte [5];
|
|
EndPoint remoteEP = null;
|
|
try {
|
|
s.ReceiveFrom (buffer, (SocketFlags) 666, ref remoteEP);
|
|
Assert.Fail ("#1");
|
|
} catch (ArgumentNullException ex) {
|
|
Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
|
|
Assert.IsNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.AreEqual ("remoteEP", ex.ParamName, "#5");
|
|
} finally {
|
|
s.Close ();
|
|
}
|
|
}
|
|
|
|
[Test] // ReceiveFrom (Byte [], SocketFlags, ref EndPoint)
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#endif
|
|
public void ReceiveFrom2_Socket_Closed ()
|
|
{
|
|
Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
s.Close ();
|
|
|
|
EndPoint remoteEP = new IPEndPoint (IPAddress.Loopback, NetworkHelpers.FindFreePort ());
|
|
try {
|
|
s.ReceiveFrom ((Byte []) null, (SocketFlags) 666, ref remoteEP);
|
|
Assert.Fail ("#1");
|
|
} catch (ObjectDisposedException ex) {
|
|
// Cannot access a disposed object
|
|
Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#2");
|
|
Assert.IsNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.AreEqual (typeof (Socket).FullName, ex.ObjectName, "#5");
|
|
}
|
|
}
|
|
|
|
[Test] // ReceiveFrom (Byte [], Int32, SocketFlags, ref EndPoint)
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#endif
|
|
public void ReceiveFrom3_Buffer_Null ()
|
|
{
|
|
Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
|
|
EndPoint remoteEP = new IPEndPoint (IPAddress.Loopback, NetworkHelpers.FindFreePort ());
|
|
try {
|
|
s.ReceiveFrom ((Byte []) null, 0, (SocketFlags) 666,
|
|
ref remoteEP);
|
|
Assert.Fail ("#1");
|
|
} catch (ArgumentNullException ex) {
|
|
Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
|
|
Assert.IsNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.AreEqual ("buffer", ex.ParamName, "#5");
|
|
} finally {
|
|
s.Close ();
|
|
}
|
|
}
|
|
|
|
[Test] // ReceiveFrom (Byte [], Int32, SocketFlags, ref EndPoint)
|
|
public void ReceiveFrom3_RemoteEP_Null ()
|
|
{
|
|
Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
|
|
byte [] buffer = new byte [5];
|
|
EndPoint remoteEP = null;
|
|
try {
|
|
s.ReceiveFrom (buffer, buffer.Length, (SocketFlags) 666, ref remoteEP);
|
|
Assert.Fail ("#1");
|
|
} catch (ArgumentNullException ex) {
|
|
Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
|
|
Assert.IsNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.AreEqual ("remoteEP", ex.ParamName, "#5");
|
|
} finally {
|
|
s.Close ();
|
|
}
|
|
}
|
|
|
|
[Test] // ReceiveFrom (Byte [], Int32, SocketFlags, ref EndPoint)
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#endif
|
|
public void ReceiveFrom3_Size_OutOfRange ()
|
|
{
|
|
Socket s;
|
|
byte [] buffer = new byte [5];
|
|
EndPoint remoteEP = new IPEndPoint (IPAddress.Loopback, NetworkHelpers.FindFreePort ());
|
|
|
|
// size negative
|
|
s = new Socket (AddressFamily.InterNetwork, SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
try {
|
|
s.ReceiveFrom (buffer, -1, (SocketFlags) 666, ref remoteEP);
|
|
Assert.Fail ("#A1");
|
|
} catch (ArgumentOutOfRangeException ex) {
|
|
// Specified argument was out of the range of valid values
|
|
Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2");
|
|
Assert.IsNull (ex.InnerException, "#A3");
|
|
Assert.IsNotNull (ex.Message, "#A4");
|
|
Assert.AreEqual ("size", ex.ParamName, "#A5");
|
|
} finally {
|
|
s.Close ();
|
|
}
|
|
|
|
// size > buffer length
|
|
s = new Socket (AddressFamily.InterNetwork, SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
try {
|
|
s.ReceiveFrom (buffer, (buffer.Length + 1), (SocketFlags) 666,
|
|
ref remoteEP);
|
|
Assert.Fail ("#B1");
|
|
} catch (ArgumentOutOfRangeException ex) {
|
|
// Specified argument was out of the range of valid values
|
|
Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2");
|
|
Assert.IsNull (ex.InnerException, "#B3");
|
|
Assert.IsNotNull (ex.Message, "#B4");
|
|
Assert.AreEqual ("size", ex.ParamName, "#B5");
|
|
} finally {
|
|
s.Close ();
|
|
}
|
|
}
|
|
|
|
[Test] // ReceiveFrom (Byte [], Int32, SocketFlags, ref EndPoint)
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#endif
|
|
public void ReceiveFrom3_Socket_Closed ()
|
|
{
|
|
Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
s.Close ();
|
|
|
|
EndPoint remoteEP = new IPEndPoint (IPAddress.Loopback, NetworkHelpers.FindFreePort ());
|
|
try {
|
|
s.ReceiveFrom ((Byte []) null, -1, (SocketFlags) 666,
|
|
ref remoteEP);
|
|
Assert.Fail ("#1");
|
|
} catch (ObjectDisposedException ex) {
|
|
// Cannot access a disposed object
|
|
Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#2");
|
|
Assert.IsNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.AreEqual (typeof (Socket).FullName, ex.ObjectName, "#5");
|
|
}
|
|
}
|
|
|
|
[Test] // ReceiveFrom (Byte [], Int32, Int32, SocketFlags, EndPoint)
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#endif
|
|
public void ReceiveFrom4_Buffer_Null ()
|
|
{
|
|
Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
EndPoint remoteEP = new IPEndPoint (IPAddress.Loopback, NetworkHelpers.FindFreePort ());
|
|
|
|
try {
|
|
s.ReceiveFrom ((Byte []) null, -1, -1, (SocketFlags) 666,
|
|
ref remoteEP);
|
|
Assert.Fail ("#1");
|
|
} catch (ArgumentNullException ex) {
|
|
Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
|
|
Assert.IsNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.AreEqual ("buffer", ex.ParamName, "#5");
|
|
}
|
|
}
|
|
|
|
[Test] // ReceiveFrom (Byte [], Int32, Int32, SocketFlags, EndPoint)
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#endif
|
|
public void ReceiveFrom4_Offset_OutOfRange ()
|
|
{
|
|
Socket s;
|
|
byte [] buffer = new byte [5];
|
|
EndPoint remoteEP = new IPEndPoint (IPAddress.Loopback, NetworkHelpers.FindFreePort ());
|
|
|
|
// offset negative
|
|
s = new Socket (AddressFamily.InterNetwork, SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
try {
|
|
s.ReceiveFrom (buffer, -1, 0, (SocketFlags) 666,
|
|
ref remoteEP);
|
|
Assert.Fail ("#A1");
|
|
} catch (ArgumentOutOfRangeException ex) {
|
|
// Specified argument was out of the range of valid values
|
|
Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2");
|
|
Assert.IsNull (ex.InnerException, "#A3");
|
|
Assert.IsNotNull (ex.Message, "#A4");
|
|
Assert.AreEqual ("offset", ex.ParamName, "#A5");
|
|
} finally {
|
|
s.Close ();
|
|
}
|
|
|
|
// offset > buffer length
|
|
s = new Socket (AddressFamily.InterNetwork, SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
try {
|
|
s.ReceiveFrom (buffer, (buffer.Length + 1), 0, (SocketFlags) 666,
|
|
ref remoteEP);
|
|
Assert.Fail ("#B1");
|
|
} catch (ArgumentOutOfRangeException ex) {
|
|
// Specified argument was out of the range of valid values
|
|
Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2");
|
|
Assert.IsNull (ex.InnerException, "#B3");
|
|
Assert.IsNotNull (ex.Message, "#B4");
|
|
Assert.AreEqual ("offset", ex.ParamName, "#B5");
|
|
} finally {
|
|
s.Close ();
|
|
}
|
|
}
|
|
|
|
[Test] // ReceiveFrom (Byte [], Int32, Int32, SocketFlags, ref IPEndPoint)
|
|
public void ReceiveFrom4_RemoteEP_Null ()
|
|
{
|
|
Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
byte [] buffer = new byte [5];
|
|
EndPoint remoteEP = null;
|
|
|
|
try {
|
|
s.ReceiveFrom (buffer, 0, buffer.Length, (SocketFlags) 666, ref remoteEP);
|
|
Assert.Fail ("#1");
|
|
} catch (ArgumentNullException ex) {
|
|
Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
|
|
Assert.IsNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.AreEqual ("remoteEP", ex.ParamName, "#5");
|
|
} finally {
|
|
s.Close ();
|
|
}
|
|
}
|
|
|
|
[Test] // ReceiveFrom (Byte [], Int32, Int32, SocketFlags, EndPoint)
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#endif
|
|
public void ReceiveFrom4_Size_OutOfRange ()
|
|
{
|
|
Socket s;
|
|
byte [] buffer = new byte [5];
|
|
EndPoint remoteEP = new IPEndPoint (IPAddress.Loopback, NetworkHelpers.FindFreePort ());
|
|
|
|
// size negative
|
|
s = new Socket (AddressFamily.InterNetwork, SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
try {
|
|
s.ReceiveFrom (buffer, 0, -1, (SocketFlags) 666,
|
|
ref remoteEP);
|
|
Assert.Fail ("#A1");
|
|
} catch (ArgumentOutOfRangeException ex) {
|
|
// Specified argument was out of the range of valid values
|
|
Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2");
|
|
Assert.IsNull (ex.InnerException, "#A3");
|
|
Assert.IsNotNull (ex.Message, "#A4");
|
|
Assert.AreEqual ("size", ex.ParamName, "#A5");
|
|
} finally {
|
|
s.Close ();
|
|
}
|
|
|
|
// size > buffer length
|
|
s = new Socket (AddressFamily.InterNetwork, SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
try {
|
|
s.ReceiveFrom (buffer, 0, (buffer.Length + 1), (SocketFlags) 666,
|
|
ref remoteEP);
|
|
Assert.Fail ("#B1");
|
|
} catch (ArgumentOutOfRangeException ex) {
|
|
// Specified argument was out of the range of valid values
|
|
Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2");
|
|
Assert.IsNull (ex.InnerException, "#B3");
|
|
Assert.IsNotNull (ex.Message, "#B4");
|
|
Assert.AreEqual ("size", ex.ParamName, "#B5");
|
|
} finally {
|
|
s.Close ();
|
|
}
|
|
|
|
// offset + size > buffer length
|
|
s = new Socket (AddressFamily.InterNetwork, SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
try {
|
|
s.ReceiveFrom (buffer, 2, 4, (SocketFlags) 666, ref remoteEP);
|
|
Assert.Fail ("#C1");
|
|
} catch (ArgumentOutOfRangeException ex) {
|
|
// Specified argument was out of the range of valid values
|
|
Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#C2");
|
|
Assert.IsNull (ex.InnerException, "#C3");
|
|
Assert.IsNotNull (ex.Message, "#C4");
|
|
Assert.AreEqual ("size", ex.ParamName, "#C5");
|
|
} finally {
|
|
s.Close ();
|
|
}
|
|
}
|
|
|
|
[Test] // ReceiveFrom (Byte [], Int32, Int32, SocketFlags, ref EndPoint)
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#endif
|
|
public void ReceiveFrom4_Socket_Closed ()
|
|
{
|
|
Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
s.Close ();
|
|
|
|
byte [] buffer = new byte [5];
|
|
EndPoint remoteEP = new IPEndPoint (IPAddress.Loopback, NetworkHelpers.FindFreePort ());
|
|
try {
|
|
s.ReceiveFrom (buffer, -1, -1, (SocketFlags) 666,
|
|
ref remoteEP);
|
|
Assert.Fail ("#1");
|
|
} catch (ObjectDisposedException ex) {
|
|
// Cannot access a disposed object
|
|
Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#2");
|
|
Assert.IsNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.AreEqual (typeof (Socket).FullName, ex.ObjectName, "#5");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#endif
|
|
public void ReceiveRemoteClosed ()
|
|
{
|
|
Socket sock = new Socket (AddressFamily.InterNetwork,
|
|
SocketType.Stream,
|
|
ProtocolType.Tcp);
|
|
sock.Bind (IPAddress.Loopback, out int port);
|
|
sock.Listen (1);
|
|
|
|
RRCReady.Reset ();
|
|
Thread client_thread = new Thread (() => RRCClientThread (port));
|
|
client_thread.Start ();
|
|
|
|
Socket client = sock.Accept ();
|
|
NetworkStream stream = new NetworkStream (client);
|
|
stream.WriteByte (0x00);
|
|
stream.WriteByte (0x00);
|
|
client.Close ();
|
|
sock.Close ();
|
|
|
|
RRCReady.WaitOne (1000, false);
|
|
Assert.IsTrue (RRCLastRead);
|
|
}
|
|
|
|
//
|
|
// Test case for bug #471580
|
|
[Test]
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#endif
|
|
public void UdpDoubleBind ()
|
|
{
|
|
using (Socket s = new Socket (AddressFamily.InterNetwork,
|
|
SocketType.Dgram, ProtocolType.Udp))
|
|
using (Socket ss = new Socket (AddressFamily.InterNetwork,
|
|
SocketType.Dgram, ProtocolType.Udp)) {
|
|
var supportsReuseAddress = true;
|
|
try {
|
|
s.SetSocketOption (SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
|
|
} catch (SocketException e) {
|
|
// Exception is thrown when ReuseAddress is not supported
|
|
Assert.AreEqual ((int) SocketError.OperationNotSupported, e.NativeErrorCode,
|
|
"Expected SocketError.OperationNotSupported");
|
|
supportsReuseAddress = false;
|
|
}
|
|
|
|
s.Bind (IPAddress.Any, out IPEndPoint ep);
|
|
|
|
if (supportsReuseAddress)
|
|
ss.SetSocketOption (SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
|
|
|
|
try {
|
|
ss.Bind (new IPEndPoint (IPAddress.Any, ep.Port));
|
|
if (!supportsReuseAddress)
|
|
Assert.Fail ("Reusing address is not supported, exception was expected on second bind.");
|
|
} catch (SocketException e) {
|
|
}
|
|
}
|
|
}
|
|
|
|
// Test case for bug #31557
|
|
[Test]
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#endif
|
|
public void TcpDoubleBind ()
|
|
{
|
|
using (Socket s = new Socket (AddressFamily.InterNetwork,
|
|
SocketType.Stream, ProtocolType.Tcp))
|
|
using (Socket ss = new Socket (AddressFamily.InterNetwork,
|
|
SocketType.Stream, ProtocolType.Tcp)) {
|
|
var supportsReuseAddress = true;
|
|
try {
|
|
s.SetSocketOption (SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
|
|
} catch (SocketException e) {
|
|
// Exception is thrown when ReuseAddress is not supported
|
|
Assert.AreEqual ((int) SocketError.OperationNotSupported, e.NativeErrorCode,
|
|
"Expected SocketError.OperationNotSupported");
|
|
supportsReuseAddress = false;
|
|
}
|
|
|
|
s.Bind (IPAddress.Any, out IPEndPoint ep);
|
|
s.Listen(1);
|
|
|
|
if (supportsReuseAddress)
|
|
ss.SetSocketOption (SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
|
|
|
|
try {
|
|
ss.Bind (new IPEndPoint (IPAddress.Any, ep.Port));
|
|
ss.Listen(1);
|
|
if (!supportsReuseAddress)
|
|
Assert.Fail ("Reusing address is not supported, exception was expected on second bind.");
|
|
} catch (SocketException e) {
|
|
}
|
|
}
|
|
}
|
|
|
|
// Test case for https://bugzilla.novell.com/show_bug.cgi?id=443346
|
|
// See also https://bugzilla.xamarin.com/show_bug.cgi?id=52157
|
|
[Test]
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#endif
|
|
public void ConnectedProperty ()
|
|
{
|
|
var listener = NetworkHelpers.CreateAndStartTcpListener (out int port);
|
|
|
|
var client = new Socket (AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
|
|
client.Connect (IPAddress.Loopback, port);
|
|
var server = listener.AcceptSocket ();
|
|
|
|
const int blobSize = 2048;
|
|
|
|
// Small send/recv buffers so that our send operation will fill them
|
|
server.ReceiveBufferSize = server.SendBufferSize = 256;
|
|
client.ReceiveBufferSize = client.SendBufferSize = 256;
|
|
|
|
// Setting this linger state causes shutdown to be a hard close (RST if send data is pending)
|
|
server.LingerState = client.LingerState = new LingerOption (true, 0);
|
|
|
|
// KeepAlive being set introduces another opportunity for a RST according to some documentation
|
|
server.SetSocketOption (SocketOptionLevel.Socket, SocketOptionName.KeepAlive, true);
|
|
client.SetSocketOption (SocketOptionLevel.Socket, SocketOptionName.KeepAlive, true);
|
|
|
|
try
|
|
{
|
|
// Fill the send buffer
|
|
client.Send (new byte[blobSize]);
|
|
// Now shut down the socket. Because of the linger state this will hard close and send RST.
|
|
client.Shutdown (SocketShutdown.Both);
|
|
client.Close ();
|
|
|
|
Assert.IsFalse (client.Connected);
|
|
Assert.IsTrue (server.Connected);
|
|
|
|
var isDead = false;
|
|
|
|
try
|
|
{
|
|
// On Windows this BeginSend succeeds... it really shouldn't and a sync send fails.
|
|
// On Linux this fails with a ConnectionReset.
|
|
var ar = server.BeginSend (new byte[blobSize], 0, blobSize, SocketFlags.None, null, null);
|
|
// On Mac we get an erroneous WSAESHUTDOWN (10058) here
|
|
server.EndSend (ar);
|
|
}
|
|
catch (SocketException se)
|
|
{
|
|
isDead = true;
|
|
|
|
if (
|
|
(se.SocketErrorCode != SocketError.ConnectionReset) &&
|
|
(se.SocketErrorCode != SocketError.Shutdown)
|
|
)
|
|
throw;
|
|
}
|
|
|
|
if (!isDead)
|
|
{
|
|
try
|
|
{
|
|
// On Windows this second send operation will fail with a ConnectionReset.
|
|
var ar = server.BeginSend (new byte[blobSize], 0, blobSize, SocketFlags.None, null, null);
|
|
server.EndSend (ar);
|
|
}
|
|
catch (SocketException se)
|
|
{
|
|
if (se.SocketErrorCode != SocketError.ConnectionReset)
|
|
throw;
|
|
}
|
|
}
|
|
|
|
Assert.IsFalse (client.Connected);
|
|
Assert.IsFalse (server.Connected);
|
|
}
|
|
finally
|
|
{
|
|
listener.Stop ();
|
|
client.Close ();
|
|
server.Close ();
|
|
}
|
|
}
|
|
|
|
[Test] // GetSocketOption (SocketOptionLevel, SocketOptionName)
|
|
public void GetSocketOption1_Socket_Closed ()
|
|
{
|
|
Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
|
|
s.Close ();
|
|
try {
|
|
s.GetSocketOption (0, 0);
|
|
Assert.Fail ("#1");
|
|
} catch (ObjectDisposedException ex) {
|
|
// Cannot access a disposed object
|
|
Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#2");
|
|
Assert.IsNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.AreEqual (typeof (Socket).FullName, ex.ObjectName, "#5");
|
|
}
|
|
}
|
|
|
|
[Test] // GetSocketOption (SocketOptionLevel, SocketOptionName, Byte [])
|
|
public void GetSocketOption2_OptionValue_Null ()
|
|
{
|
|
Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
|
|
try {
|
|
s.GetSocketOption (SocketOptionLevel.Socket, SocketOptionName.Linger,
|
|
(byte []) null);
|
|
Assert.Fail ("#1");
|
|
} catch (SocketException ex) {
|
|
// The system detected an invalid pointer address in attempting
|
|
// to use a pointer argument in a call
|
|
Assert.AreEqual (typeof (SocketException), ex.GetType (), "#2");
|
|
Assert.AreEqual (10014, ex.ErrorCode, "#3");
|
|
Assert.IsNull (ex.InnerException, "#4");
|
|
Assert.IsNotNull (ex.Message, "#5");
|
|
Assert.AreEqual (10014, ex.NativeErrorCode, "#6");
|
|
Assert.AreEqual (SocketError.Fault, ex.SocketErrorCode, "#7");
|
|
}
|
|
}
|
|
|
|
[Test] // GetSocketOption (SocketOptionLevel, SocketOptionName, Byte [])
|
|
public void GetSocketOption2_Socket_Closed ()
|
|
{
|
|
Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
|
|
s.Close ();
|
|
try {
|
|
s.GetSocketOption (0, 0, (byte []) null);
|
|
Assert.Fail ("#1");
|
|
} catch (ObjectDisposedException ex) {
|
|
// Cannot access a disposed object
|
|
Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#2");
|
|
Assert.IsNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.AreEqual (typeof (Socket).FullName, ex.ObjectName, "#5");
|
|
}
|
|
}
|
|
|
|
[Test] // GetSocketOption (SocketOptionLevel, SocketOptionName, Int32)
|
|
public void GetSocketOption3_Socket_Closed ()
|
|
{
|
|
Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
|
|
s.Close ();
|
|
try {
|
|
s.GetSocketOption (0, 0, 0);
|
|
Assert.Fail ("#1");
|
|
} catch (ObjectDisposedException ex) {
|
|
// Cannot access a disposed object
|
|
Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#2");
|
|
Assert.IsNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.AreEqual (typeof (Socket).FullName, ex.ObjectName, "#5");
|
|
}
|
|
}
|
|
|
|
[Test] // SetSocketOption (SocketOptionLevel, SocketOptionName, Byte [])
|
|
public void SetSocketOption1_DontLinger ()
|
|
{
|
|
using (Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)) {
|
|
s.SetSocketOption (SocketOptionLevel.Socket, SocketOptionName.DontLinger,
|
|
new byte [] { 0x00 });
|
|
s.SetSocketOption (SocketOptionLevel.Socket, SocketOptionName.DontLinger,
|
|
new byte [] { 0x01 });
|
|
}
|
|
}
|
|
|
|
[Test] // SetSocketOption (SocketOptionLevel, SocketOptionName, Byte [])
|
|
public void SetSocketOption1_DontLinger_Null ()
|
|
{
|
|
using (Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)) {
|
|
try {
|
|
s.SetSocketOption (SocketOptionLevel.Socket,
|
|
SocketOptionName.DontLinger, (byte []) null);
|
|
Assert.Fail ("#1");
|
|
} catch (SocketException ex) {
|
|
// The system detected an invalid pointer address in attempting
|
|
// to use a pointer argument in a call
|
|
Assert.AreEqual (typeof (SocketException), ex.GetType (), "#2");
|
|
Assert.AreEqual (10014, ex.ErrorCode, "#3");
|
|
Assert.IsNull (ex.InnerException, "#4");
|
|
Assert.IsNotNull (ex.Message, "#5");
|
|
Assert.AreEqual (10014, ex.NativeErrorCode, "#6");
|
|
Assert.AreEqual (SocketError.Fault, ex.SocketErrorCode, "#7");
|
|
}
|
|
}
|
|
}
|
|
|
|
[Test] // SetSocketOption (SocketOptionLevel, SocketOptionName, Byte [])
|
|
public void SetSocketOption1_Linger_Null ()
|
|
{
|
|
using (Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)) {
|
|
try {
|
|
s.SetSocketOption (SocketOptionLevel.Socket,
|
|
SocketOptionName.DontLinger, (byte []) null);
|
|
Assert.Fail ("#1");
|
|
} catch (SocketException ex) {
|
|
// The system detected an invalid pointer address in attempting
|
|
// to use a pointer argument in a call
|
|
Assert.AreEqual (typeof (SocketException), ex.GetType (), "#2");
|
|
Assert.AreEqual (10014, ex.ErrorCode, "#3");
|
|
Assert.IsNull (ex.InnerException, "#4");
|
|
Assert.IsNotNull (ex.Message, "#5");
|
|
Assert.AreEqual (10014, ex.NativeErrorCode, "#6");
|
|
Assert.AreEqual (SocketError.Fault, ex.SocketErrorCode, "#7");
|
|
}
|
|
}
|
|
}
|
|
|
|
[Test] // SetSocketOption (SocketOptionLevel, SocketOptionName, Byte [])
|
|
public void SetSocketOption1_Socket_Close ()
|
|
{
|
|
Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
|
|
s.Close ();
|
|
try {
|
|
s.SetSocketOption (SocketOptionLevel.Socket, SocketOptionName.DontLinger,
|
|
new byte [] { 0x00 });
|
|
Assert.Fail ("#1");
|
|
} catch (ObjectDisposedException ex) {
|
|
Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#2");
|
|
Assert.IsNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.AreEqual (typeof (Socket).FullName, ex.ObjectName, "#5");
|
|
}
|
|
}
|
|
|
|
[Test] // SetSocketOption (SocketOptionLevel, SocketOptionName, Int32)
|
|
public void SetSocketOption2_DontLinger ()
|
|
{
|
|
using (Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)) {
|
|
s.SetSocketOption (SocketOptionLevel.Socket, SocketOptionName.DontLinger, 0);
|
|
s.SetSocketOption (SocketOptionLevel.Socket, SocketOptionName.DontLinger, 5);
|
|
}
|
|
}
|
|
|
|
[Test] // SetSocketOption (SocketOptionLevel, SocketOptionName, Int32)
|
|
[Category ("NotWorking")]
|
|
public void SetSocketOption2_Linger ()
|
|
{
|
|
using (Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)) {
|
|
s.SetSocketOption (SocketOptionLevel.Socket, SocketOptionName.Linger, 0);
|
|
s.SetSocketOption (SocketOptionLevel.Socket, SocketOptionName.Linger, 5);
|
|
}
|
|
}
|
|
|
|
[Test] // SetSocketOption (SocketOptionLevel, SocketOptionName, Int32)
|
|
public void SetSocketOption2_Socket_Closed ()
|
|
{
|
|
Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
|
|
s.Close ();
|
|
try {
|
|
s.SetSocketOption (SocketOptionLevel.Socket, SocketOptionName.DontLinger, 0);
|
|
Assert.Fail ("#1");
|
|
} catch (ObjectDisposedException ex) {
|
|
// Cannot access a disposed object
|
|
Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#2");
|
|
Assert.IsNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.AreEqual (typeof (Socket).FullName, ex.ObjectName, "#5");
|
|
}
|
|
}
|
|
|
|
[Test] // SetSocketOption (SocketOptionLevel, SocketOptionName, Object)
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#endif
|
|
public void SetSocketOption3_AddMembershipIPv4_IPv6MulticastOption ()
|
|
{
|
|
IPAddress mcast_addr = IPAddress.Parse ("239.255.255.250");
|
|
|
|
using (Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp)) {
|
|
s.Bind (new IPEndPoint (IPAddress.Any, 0));
|
|
try {
|
|
s.SetSocketOption (SocketOptionLevel.IP, SocketOptionName.AddMembership,
|
|
new IPv6MulticastOption (mcast_addr));
|
|
Assert.Fail ("#1");
|
|
} catch (ArgumentException ex) {
|
|
Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
|
|
Assert.IsNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
// The specified value is not a valid 'MulticastOption'
|
|
Assert.IsTrue (ex.Message.IndexOf ("'MulticastOption'") != -1, "#5:" + ex.Message);
|
|
Assert.AreEqual ("optionValue", ex.ParamName, "#6");
|
|
}
|
|
}
|
|
}
|
|
|
|
[Test] // SetSocketOption (SocketOptionLevel, SocketOptionName, Object)
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#endif
|
|
public void SetSocketOption3_AddMembershipIPv4_MulticastOption ()
|
|
{
|
|
IPAddress mcast_addr = IPAddress.Parse ("239.255.255.250");
|
|
|
|
using (Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp)) {
|
|
s.Bind (new IPEndPoint (IPAddress.Any, 0));
|
|
s.SetSocketOption (SocketOptionLevel.IP, SocketOptionName.AddMembership,
|
|
new MulticastOption (mcast_addr));
|
|
}
|
|
}
|
|
|
|
[Test] // SetSocketOption (SocketOptionLevel, SocketOptionName, Object)
|
|
[Category ("NotWorking")]
|
|
public void SetSocketOption3_AddMembershipIPv4_Socket_NotBound ()
|
|
{
|
|
IPAddress mcast_addr = IPAddress.Parse ("239.255.255.250");
|
|
|
|
Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
|
|
try {
|
|
s.SetSocketOption (SocketOptionLevel.IP, SocketOptionName.AddMembership,
|
|
new MulticastOption (mcast_addr));
|
|
Assert.Fail ("#1");
|
|
} catch (SocketException ex) {
|
|
// An invalid argument was supplied
|
|
Assert.AreEqual (typeof (SocketException), ex.GetType (), "#2");
|
|
Assert.AreEqual (10022, ex.ErrorCode, "#3");
|
|
Assert.IsNull (ex.InnerException, "#4");
|
|
Assert.IsNotNull (ex.Message, "#5");
|
|
Assert.AreEqual (10022, ex.NativeErrorCode, "#6");
|
|
Assert.AreEqual (SocketError.InvalidArgument, ex.SocketErrorCode, "#7");
|
|
} finally {
|
|
s.Close ();
|
|
}
|
|
}
|
|
|
|
[Test] // SetSocketOption (SocketOptionLevel, SocketOptionName, Object)
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#endif
|
|
public void SetSocketOption3_AddMembershipIPv6_IPv6MulticastOption ()
|
|
{
|
|
if (!Socket.OSSupportsIPv6)
|
|
Assert.Ignore ("IPv6 not enabled.");
|
|
|
|
IPAddress mcast_addr = IPAddress.Parse ("ff02::1");
|
|
|
|
using (Socket s = new Socket (AddressFamily.InterNetworkV6, SocketType.Dgram, ProtocolType.Udp)) {
|
|
s.Bind (new IPEndPoint (IPAddress.IPv6Any, 0));
|
|
s.SetSocketOption (SocketOptionLevel.IPv6, SocketOptionName.AddMembership,
|
|
new IPv6MulticastOption (mcast_addr));
|
|
}
|
|
}
|
|
|
|
[Test] // SetSocketOption (SocketOptionLevel, SocketOptionName, Object)
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#endif
|
|
public void SetSocketOption3_AddMembershipIPv6_MulticastOption ()
|
|
{
|
|
if (!Socket.OSSupportsIPv6)
|
|
Assert.Ignore ("IPv6 not enabled.");
|
|
|
|
IPAddress mcast_addr = IPAddress.Parse ("ff02::1");
|
|
|
|
using (Socket s = new Socket (AddressFamily.InterNetworkV6, SocketType.Dgram, ProtocolType.Udp)) {
|
|
s.Bind (new IPEndPoint (IPAddress.IPv6Any, 0));
|
|
try {
|
|
s.SetSocketOption (SocketOptionLevel.IPv6, SocketOptionName.AddMembership,
|
|
new MulticastOption (mcast_addr));
|
|
Assert.Fail ("#1");
|
|
} catch (ArgumentException ex) {
|
|
Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
|
|
Assert.IsNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
// The specified value is not a valid 'IPv6MulticastOption'
|
|
Assert.IsTrue (ex.Message.IndexOf ("'IPv6MulticastOption'") != -1, "#5:" + ex.Message);
|
|
Assert.AreEqual ("optionValue", ex.ParamName, "#6");
|
|
}
|
|
}
|
|
}
|
|
|
|
[Test] // SetSocketOption (SocketOptionLevel, SocketOptionName, Object)
|
|
[Category ("NotWorking")]
|
|
public void SetSocketOption3_AddMembershipIPv6_Socket_NotBound ()
|
|
{
|
|
IPAddress mcast_addr = IPAddress.Parse ("ff02::1");
|
|
|
|
Socket s = new Socket (AddressFamily.InterNetworkV6, SocketType.Dgram, ProtocolType.Udp);
|
|
try {
|
|
s.SetSocketOption (SocketOptionLevel.IPv6, SocketOptionName.AddMembership,
|
|
new IPv6MulticastOption (mcast_addr));
|
|
Assert.Fail ("#1");
|
|
} catch (SocketException ex) {
|
|
// An invalid argument was supplied
|
|
Assert.AreEqual (typeof (SocketException), ex.GetType (), "#2");
|
|
Assert.AreEqual (10022, ex.ErrorCode, "#3");
|
|
Assert.IsNull (ex.InnerException, "#4");
|
|
Assert.IsNotNull (ex.Message, "#5");
|
|
Assert.AreEqual (10022, ex.NativeErrorCode, "#6");
|
|
Assert.AreEqual (SocketError.InvalidArgument, ex.SocketErrorCode, "#7");
|
|
} finally {
|
|
s.Close ();
|
|
}
|
|
}
|
|
|
|
[Test] // SetSocketOption (SocketOptionLevel, SocketOptionName, Object)
|
|
public void SetSocketOption3_DontLinger_Boolean ()
|
|
{
|
|
using (Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)) {
|
|
try {
|
|
s.SetSocketOption (SocketOptionLevel.Socket,
|
|
SocketOptionName.DontLinger, (object) false);
|
|
Assert.Fail ("#1");
|
|
} catch (ArgumentException ex) {
|
|
// The specified value is not valid
|
|
Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
|
|
Assert.IsNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.AreEqual ("optionValue", ex.ParamName, "#5");
|
|
}
|
|
}
|
|
}
|
|
|
|
[Test] // SetSocketOption (SocketOptionLevel, SocketOptionName, Object)
|
|
public void SetSocketOption3_DontLinger_Int32 ()
|
|
{
|
|
using (Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)) {
|
|
try {
|
|
s.SetSocketOption (SocketOptionLevel.Socket,
|
|
SocketOptionName.DontLinger, (object) 0);
|
|
Assert.Fail ("#1");
|
|
} catch (ArgumentException ex) {
|
|
// The specified value is not valid
|
|
Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
|
|
Assert.IsNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.AreEqual ("optionValue", ex.ParamName, "#5");
|
|
}
|
|
}
|
|
}
|
|
|
|
[Test] // SetSocketOption (SocketOptionLevel, SocketOptionName, Object)
|
|
public void SetSocketOption3_DontLinger_LingerOption ()
|
|
{
|
|
using (Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)) {
|
|
try {
|
|
s.SetSocketOption (SocketOptionLevel.Socket,
|
|
SocketOptionName.DontLinger, new LingerOption (true, 1000));
|
|
Assert.Fail ("#1");
|
|
} catch (ArgumentException ex) {
|
|
Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
|
|
Assert.IsNull (ex.InnerException, "#3");
|
|
// The specified value is not valid
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.AreEqual ("optionValue", ex.ParamName, "#5");
|
|
}
|
|
}
|
|
}
|
|
|
|
[Test] // SetSocketOption (SocketOptionLevel, SocketOptionName, Object)
|
|
public void SetSocketOption3_Linger_Boolean ()
|
|
{
|
|
using (Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)) {
|
|
try {
|
|
s.SetSocketOption (SocketOptionLevel.Socket,
|
|
SocketOptionName.Linger, (object) false);
|
|
Assert.Fail ("#1");
|
|
} catch (ArgumentException ex) {
|
|
Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
|
|
Assert.IsNull (ex.InnerException, "#3");
|
|
// The specified value is not valid
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.AreEqual ("optionValue", ex.ParamName, "#5");
|
|
}
|
|
}
|
|
}
|
|
|
|
[Test] // SetSocketOption (SocketOptionLevel, SocketOptionName, Object)
|
|
public void SetSocketOption3_Linger_Int32 ()
|
|
{
|
|
using (Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)) {
|
|
try {
|
|
s.SetSocketOption (SocketOptionLevel.Socket,
|
|
SocketOptionName.Linger, (object) 0);
|
|
Assert.Fail ("#1");
|
|
} catch (ArgumentException ex) {
|
|
Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
|
|
Assert.IsNull (ex.InnerException, "#3");
|
|
// The specified value is not valid
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.AreEqual ("optionValue", ex.ParamName, "#5");
|
|
}
|
|
}
|
|
}
|
|
|
|
[Test] // SetSocketOption (SocketOptionLevel, SocketOptionName, Object)
|
|
public void SetSocketOption3_Linger_LingerOption ()
|
|
{
|
|
using (Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)) {
|
|
s.SetSocketOption (SocketOptionLevel.Socket, SocketOptionName.Linger,
|
|
new LingerOption (false, 0));
|
|
s.SetSocketOption (SocketOptionLevel.Socket, SocketOptionName.Linger,
|
|
new LingerOption (true, 0));
|
|
s.SetSocketOption (SocketOptionLevel.Socket, SocketOptionName.Linger,
|
|
new LingerOption (false, 1000));
|
|
s.SetSocketOption (SocketOptionLevel.Socket, SocketOptionName.Linger,
|
|
new LingerOption (true, 1000));
|
|
}
|
|
}
|
|
|
|
[Test] // SetSocketOption (SocketOptionLevel, SocketOptionName, Object)
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#endif
|
|
public void SetSocketOption3_DropMembershipIPv4_IPv6MulticastOption ()
|
|
{
|
|
IPAddress mcast_addr = IPAddress.Parse ("239.255.255.250");
|
|
|
|
using (Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp)) {
|
|
s.Bind (new IPEndPoint (IPAddress.Any, 0));
|
|
s.SetSocketOption (SocketOptionLevel.IP, SocketOptionName.AddMembership,
|
|
new MulticastOption (mcast_addr));
|
|
try {
|
|
s.SetSocketOption (SocketOptionLevel.IP, SocketOptionName.DropMembership,
|
|
new IPv6MulticastOption (mcast_addr));
|
|
Assert.Fail ("#1");
|
|
} catch (ArgumentException ex) {
|
|
Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
|
|
Assert.IsNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
// The specified value is not a valid 'MulticastOption'
|
|
Assert.IsTrue (ex.Message.IndexOf ("'MulticastOption'") != -1, "#5:" + ex.Message);
|
|
Assert.AreEqual ("optionValue", ex.ParamName, "#6");
|
|
}
|
|
}
|
|
}
|
|
|
|
[Test] // SetSocketOption (SocketOptionLevel, SocketOptionName, Object)
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#endif
|
|
public void SetSocketOption3_DropMembershipIPv4_MulticastOption ()
|
|
{
|
|
IPAddress mcast_addr = IPAddress.Parse ("239.255.255.250");
|
|
|
|
using (Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp)) {
|
|
MulticastOption option = new MulticastOption (mcast_addr);
|
|
|
|
s.Bind (new IPEndPoint (IPAddress.Any, 0));
|
|
s.SetSocketOption (SocketOptionLevel.IP, SocketOptionName.AddMembership,
|
|
option);
|
|
s.SetSocketOption (SocketOptionLevel.IP, SocketOptionName.DropMembership,
|
|
option);
|
|
}
|
|
}
|
|
|
|
[Test] // SetSocketOption (SocketOptionLevel, SocketOptionName, Object)
|
|
[Category ("NotWorking")]
|
|
public void SetSocketOption3_DropMembershipIPv4_Socket_NotBound ()
|
|
{
|
|
IPAddress mcast_addr = IPAddress.Parse ("239.255.255.250");
|
|
|
|
Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
|
|
try {
|
|
s.SetSocketOption (SocketOptionLevel.IP, SocketOptionName.DropMembership,
|
|
new MulticastOption (mcast_addr));
|
|
Assert.Fail ("#1");
|
|
} catch (SocketException ex) {
|
|
// An invalid argument was supplied
|
|
Assert.AreEqual (typeof (SocketException), ex.GetType (), "#2");
|
|
Assert.AreEqual (10022, ex.ErrorCode, "#3");
|
|
Assert.IsNull (ex.InnerException, "#4");
|
|
Assert.IsNotNull (ex.Message, "#5");
|
|
Assert.AreEqual (10022, ex.NativeErrorCode, "#6");
|
|
Assert.AreEqual (SocketError.InvalidArgument, ex.SocketErrorCode, "#7");
|
|
} finally {
|
|
s.Close ();
|
|
}
|
|
}
|
|
|
|
[Test] // SetSocketOption (SocketOptionLevel, SocketOptionName, Object)
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#endif
|
|
public void SetSocketOption3_DropMembershipIPv6_IPv6MulticastOption ()
|
|
{
|
|
if (!Socket.OSSupportsIPv6)
|
|
Assert.Ignore ("IPv6 not enabled.");
|
|
|
|
using (Socket s = new Socket (AddressFamily.InterNetworkV6, SocketType.Dgram, ProtocolType.Udp)) {
|
|
IPv6MulticastOption option = new IPv6MulticastOption (
|
|
IPAddress.Parse ("ff02::1"));
|
|
|
|
s.Bind (new IPEndPoint (IPAddress.IPv6Any, 0));
|
|
s.SetSocketOption (SocketOptionLevel.IPv6, SocketOptionName.AddMembership,
|
|
option);
|
|
s.SetSocketOption (SocketOptionLevel.IPv6, SocketOptionName.DropMembership,
|
|
option);
|
|
}
|
|
}
|
|
|
|
[Test] // SetSocketOption (SocketOptionLevel, SocketOptionName, Object)
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#endif
|
|
public void SetSocketOption3_DropMembershipIPv6_MulticastOption ()
|
|
{
|
|
if (!Socket.OSSupportsIPv6)
|
|
Assert.Ignore ("IPv6 not enabled.");
|
|
|
|
IPAddress mcast_addr = IPAddress.Parse ("ff02::1");
|
|
|
|
using (Socket s = new Socket (AddressFamily.InterNetworkV6, SocketType.Dgram, ProtocolType.Udp)) {
|
|
s.Bind (new IPEndPoint (IPAddress.IPv6Any, 0));
|
|
s.SetSocketOption (SocketOptionLevel.IPv6, SocketOptionName.AddMembership,
|
|
new IPv6MulticastOption (mcast_addr));
|
|
try {
|
|
s.SetSocketOption (SocketOptionLevel.IPv6, SocketOptionName.DropMembership,
|
|
new MulticastOption (mcast_addr));
|
|
Assert.Fail ("#1");
|
|
} catch (ArgumentException ex) {
|
|
Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
|
|
Assert.IsNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
// The specified value is not a valid 'IPv6MulticastOption'
|
|
Assert.IsTrue (ex.Message.IndexOf ("'IPv6MulticastOption'") != -1, "#5:" + ex.Message);
|
|
Assert.AreEqual ("optionValue", ex.ParamName, "#6");
|
|
}
|
|
}
|
|
}
|
|
|
|
[Test] // SetSocketOption (SocketOptionLevel, SocketOptionName, Object)
|
|
[Category ("NotWorking")]
|
|
public void SetSocketOption3_DropMembershipIPv6_Socket_NotBound ()
|
|
{
|
|
IPAddress mcast_addr = IPAddress.Parse ("ff02::1");
|
|
|
|
Socket s = new Socket (AddressFamily.InterNetworkV6, SocketType.Dgram, ProtocolType.Udp);
|
|
try {
|
|
s.SetSocketOption (SocketOptionLevel.IPv6, SocketOptionName.DropMembership,
|
|
new IPv6MulticastOption (mcast_addr));
|
|
Assert.Fail ("#1");
|
|
} catch (SocketException ex) {
|
|
// An invalid argument was supplied
|
|
Assert.AreEqual (typeof (SocketException), ex.GetType (), "#2");
|
|
Assert.AreEqual (10022, ex.ErrorCode, "#3");
|
|
Assert.IsNull (ex.InnerException, "#4");
|
|
Assert.IsNotNull (ex.Message, "#5");
|
|
Assert.AreEqual (10022, ex.NativeErrorCode, "#6");
|
|
Assert.AreEqual (SocketError.InvalidArgument, ex.SocketErrorCode, "#7");
|
|
} finally {
|
|
s.Close ();
|
|
}
|
|
}
|
|
|
|
[Test] // SetSocketOption (SocketOptionLevel, SocketOptionName, Object)
|
|
public void SetSocketOption3_OptionValue_Null ()
|
|
{
|
|
using (Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)) {
|
|
try {
|
|
s.SetSocketOption (SocketOptionLevel.Socket,
|
|
SocketOptionName.Linger, (object) null);
|
|
Assert.Fail ("#1");
|
|
} catch (ArgumentNullException ex) {
|
|
Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
|
|
Assert.IsNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.AreEqual ("optionValue", ex.ParamName, "#5");
|
|
}
|
|
}
|
|
}
|
|
|
|
[Test] // SetSocketOption (SocketOptionLevel, SocketOptionName, Object)
|
|
public void SetSocketOption3_Socket_Closed ()
|
|
{
|
|
Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
|
|
s.Close ();
|
|
try {
|
|
s.SetSocketOption (SocketOptionLevel.Socket, SocketOptionName.Linger,
|
|
new LingerOption (false, 0));
|
|
Assert.Fail ("#1");
|
|
} catch (ObjectDisposedException ex) {
|
|
// Cannot access a disposed object
|
|
Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#2");
|
|
Assert.IsNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.AreEqual (typeof (Socket).FullName, ex.ObjectName, "#5");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
[Category ("RequiresBSDSockets")] // on watchOS device this happens: System.Net.Sockets.SocketException : The requested address is not valid in this context. This situation is too complex to detect and throw a PlatformNotSupportedException, so just ignore it.
|
|
public void SetSocketOption_MulticastInterfaceIndex_Any ()
|
|
{
|
|
IPAddress ip = IPAddress.Parse ("239.255.255.250");
|
|
int index = 0;
|
|
using (Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp))
|
|
{
|
|
s.SetSocketOption(SocketOptionLevel.IP, SocketOptionName.MulticastInterface, IPAddress.HostToNetworkOrder(index));
|
|
s.SetSocketOption(SocketOptionLevel.IP, SocketOptionName.AddMembership, new MulticastOption(ip, index));
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
[Category ("RequiresBSDSockets")] // on watchOS device this happens: System.Net.Sockets.SocketException : The requested address is not valid in this context. This situation is too complex to detect and throw a PlatformNotSupportedException, so just ignore it.
|
|
public void SetSocketOption_MulticastInterfaceIndex_Loopback ()
|
|
{
|
|
IPAddress ip = IPAddress.Parse ("239.255.255.250");
|
|
int index = 1;
|
|
using (Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp))
|
|
{
|
|
s.SetSocketOption(SocketOptionLevel.IP, SocketOptionName.MulticastInterface, IPAddress.HostToNetworkOrder(index));
|
|
s.SetSocketOption(SocketOptionLevel.IP, SocketOptionName.AddMembership, new MulticastOption(ip, index));
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void SetSocketOption_MulticastInterfaceIndex_Invalid ()
|
|
{
|
|
IPAddress ip = IPAddress.Parse ("239.255.255.250");
|
|
int index = 31415;
|
|
using (Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp))
|
|
{
|
|
try
|
|
{
|
|
s.SetSocketOption(SocketOptionLevel.IP, SocketOptionName.MulticastInterface, IPAddress.HostToNetworkOrder(index));
|
|
Assert.Fail ("#1");
|
|
}
|
|
catch
|
|
{}
|
|
try
|
|
{
|
|
s.SetSocketOption(SocketOptionLevel.IP, SocketOptionName.AddMembership, new MulticastOption(ip, index));
|
|
Assert.Fail ("#2");
|
|
}
|
|
catch
|
|
{}
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#endif
|
|
public void Shutdown_NoConnect ()
|
|
{
|
|
Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
|
|
s.Bind (new IPEndPoint (IPAddress.Loopback, 0));
|
|
s.Listen (1);
|
|
try {
|
|
s.Shutdown (SocketShutdown.Both);
|
|
Assert.Fail ("#1");
|
|
} catch (SocketException exc) {
|
|
Assert.AreEqual (10057, exc.ErrorCode, "#2");
|
|
} finally {
|
|
s.Close ();
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (NullReferenceException))]
|
|
public void ReceiveAsync_Null ()
|
|
{
|
|
using (Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)) {
|
|
s.ReceiveAsync (null);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (NullReferenceException))]
|
|
public void ReceiveAsync_Default ()
|
|
{
|
|
using (Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)) {
|
|
SocketAsyncEventArgs saea = new SocketAsyncEventArgs ();
|
|
s.ReceiveAsync (saea);
|
|
}
|
|
}
|
|
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (NullReferenceException))]
|
|
public void ReceiveAsync_NullBuffer ()
|
|
{
|
|
using (Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)) {
|
|
SocketAsyncEventArgs saea = new SocketAsyncEventArgs ();
|
|
saea.SetBuffer (null, 0, 0);
|
|
s.ReceiveAsync (null);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ObjectDisposedException))]
|
|
public void ReceiveAsync_ClosedSocket ()
|
|
{
|
|
Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
|
|
s.Close ();
|
|
s.ReceiveAsync (null);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (NullReferenceException))]
|
|
public void SendAsync_Null ()
|
|
{
|
|
using (Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)) {
|
|
s.SendAsync (null);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (NullReferenceException))]
|
|
public void SendAsync_Default ()
|
|
{
|
|
using (Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)) {
|
|
SocketAsyncEventArgs saea = new SocketAsyncEventArgs ();
|
|
s.SendAsync (saea);
|
|
}
|
|
}
|
|
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (NullReferenceException))]
|
|
public void SendAsync_NullBuffer ()
|
|
{
|
|
using (Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)) {
|
|
SocketAsyncEventArgs saea = new SocketAsyncEventArgs ();
|
|
saea.SetBuffer (null, 0, 0);
|
|
s.SendAsync (null);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ObjectDisposedException))]
|
|
public void SendAsync_ClosedSocket ()
|
|
{
|
|
Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
|
|
s.Close ();
|
|
s.SendAsync (null);
|
|
}
|
|
|
|
[Test]
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#endif
|
|
[Ignore ("https://bugzilla.xamarin.com/show_bug.cgi?id=43172")]
|
|
public void SendAsyncFile ()
|
|
{
|
|
Socket serverSocket = new Socket (AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
|
|
|
|
serverSocket.Bind (new IPEndPoint (IPAddress.Loopback, 0));
|
|
serverSocket.Listen (1);
|
|
|
|
var mReceived = new ManualResetEvent (false);
|
|
|
|
serverSocket.BeginAccept (AsyncCall => {
|
|
byte[] bytes = new byte [1024];
|
|
|
|
Socket listener = (Socket)AsyncCall.AsyncState;
|
|
Socket client = listener.EndAccept (AsyncCall);
|
|
client.Receive (bytes, bytes.Length, 0);
|
|
client.Close ();
|
|
mReceived.Set ();
|
|
}, serverSocket);
|
|
|
|
Socket clientSocket = new Socket (AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
|
|
clientSocket.Connect (serverSocket.LocalEndPoint);
|
|
clientSocket.NoDelay = true;
|
|
|
|
// Initialize buffer used to create testing file
|
|
var buffer = new byte [1024];
|
|
for (int i = 0; i < 1024; ++i)
|
|
buffer [i] = (byte) (i % 256);
|
|
|
|
string temp = Path.GetTempFileName ();
|
|
try {
|
|
// Testing file creation
|
|
using (StreamWriter sw = new StreamWriter (temp)) {
|
|
sw.Write (buffer);
|
|
}
|
|
|
|
var mSent = new ManualResetEvent (false);
|
|
|
|
// Async Send File to server
|
|
clientSocket.BeginSendFile(temp, (ar) => {
|
|
Socket client = (Socket) ar.AsyncState;
|
|
client.EndSendFile (ar);
|
|
mSent.Set ();
|
|
}, clientSocket);
|
|
|
|
Assert.IsTrue (mSent.WaitOne (5000), "#1");
|
|
Assert.IsTrue (mReceived.WaitOne (5000), "#2");
|
|
} finally {
|
|
if (File.Exists (temp))
|
|
File.Delete (temp);
|
|
|
|
clientSocket.Close ();
|
|
serverSocket.Close ();
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#endif
|
|
public void ConnectToIPV4EndPointUsingDualModelSocket () {
|
|
/*
|
|
* IPv6 DualMode sockets are defaults in Mono. Explicitly specify that
|
|
* anyways in this test to make it more interoparable with .NET where
|
|
* IPv6 and DualMode needs to be specified.
|
|
*/
|
|
using (var server = new Socket (AddressFamily.InterNetworkV6, SocketType.Stream, ProtocolType.Tcp)) {
|
|
|
|
server.DualMode = true;
|
|
server.Bind (IPAddress.Loopback, out int _);
|
|
/*
|
|
* Nothing to Accept the connect - we need a backlog to make sure we don't get
|
|
Connection refused.
|
|
*/
|
|
server.Listen (3);
|
|
|
|
var ep = server.LocalEndPoint as IPEndPoint;
|
|
var client = new Socket (AddressFamily.InterNetworkV6, SocketType.Stream, ProtocolType.Tcp);
|
|
client.DualMode = true;
|
|
client.Connect (ep);
|
|
client.Disconnect (false);
|
|
client.Close ();
|
|
|
|
client = new Socket (AddressFamily.InterNetworkV6, SocketType.Stream, ProtocolType.Tcp);
|
|
client.DualMode = true;
|
|
client.Connect (IPAddress.Loopback, ep.Port);
|
|
client.Disconnect (false);
|
|
client.Close ();
|
|
|
|
client = new Socket (AddressFamily.InterNetworkV6, SocketType.Stream, ProtocolType.Tcp);
|
|
client.DualMode = true;
|
|
client.Connect (new [] { IPAddress.Loopback }, ep.Port);
|
|
client.Disconnect (false);
|
|
client.Close ();
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#endif
|
|
public void BeginConnectToIPV4EndPointUsingDualModelSocket () {
|
|
/*
|
|
* IPv6 DualMode sockets are defaults in Mono. Explicitly specify that
|
|
* anyways in this test to make it more interoparable with .NET where
|
|
* IPv6 and DualMode needs to be specified.
|
|
*/
|
|
using (var server = new Socket (AddressFamily.InterNetworkV6, SocketType.Stream, ProtocolType.Tcp))
|
|
{
|
|
server.DualMode = true;
|
|
server.Bind (IPAddress.Loopback, out int _);
|
|
server.Listen (10);
|
|
|
|
var ep = server.LocalEndPoint as IPEndPoint;
|
|
|
|
BCCalledBack.Reset ();
|
|
var client = new Socket (AddressFamily.InterNetworkV6, SocketType.Stream, ProtocolType.Tcp);
|
|
client.DualMode = true;
|
|
var ar1 = client.BeginConnect (ep, BCCallback, client);
|
|
Assert.IsTrue (BCCalledBack.WaitOne (10000), "#1");
|
|
Assert.AreEqual(server.AddressFamily, client.RemoteEndPoint.AddressFamily, "#2");
|
|
Assert.AreEqual(server.AddressFamily, client.LocalEndPoint.AddressFamily, "#3");
|
|
client.Disconnect (false);
|
|
client.Close ();
|
|
|
|
BCCalledBack.Reset ();
|
|
client = new Socket (AddressFamily.InterNetworkV6, SocketType.Stream, ProtocolType.Tcp);
|
|
client.DualMode = true;
|
|
var ar2 = client.BeginConnect (IPAddress.Loopback, ep.Port, BCCallback, client);
|
|
Assert.IsTrue (BCCalledBack.WaitOne (10000), "#4");
|
|
Assert.AreEqual(server.AddressFamily, client.RemoteEndPoint.AddressFamily, "#5");
|
|
Assert.AreEqual(server.AddressFamily, client.LocalEndPoint.AddressFamily, "#6");
|
|
client.Disconnect (false);
|
|
client.Close ();
|
|
|
|
BCCalledBack.Reset ();
|
|
client = new Socket (AddressFamily.InterNetworkV6, SocketType.Stream, ProtocolType.Tcp);
|
|
client.DualMode = true;
|
|
var ar3 = client.BeginConnect (new [] {IPAddress.Loopback}, ep.Port, BCCallback, client);
|
|
Assert.IsTrue (BCCalledBack.WaitOne (10000), "#7");
|
|
Assert.AreEqual(server.AddressFamily, client.RemoteEndPoint.AddressFamily, "#8");
|
|
Assert.AreEqual(server.AddressFamily, client.LocalEndPoint.AddressFamily, "#9");
|
|
client.Disconnect (false);
|
|
client.Close();
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#endif
|
|
public void UdpMulticasTimeToLive ()
|
|
{
|
|
/* see https://bugzilla.xamarin.com/show_bug.cgi?id=36941 */
|
|
|
|
using (Socket socket = new Socket (AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp)) {
|
|
socket.SetSocketOption (SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, 1);
|
|
socket.Bind (IPAddress.Any, out int _);
|
|
socket.SetSocketOption (SocketOptionLevel.IP, SocketOptionName.MulticastTimeToLive, 19);
|
|
}
|
|
}
|
|
|
|
[Test] // Covers 41616
|
|
public void ConnectAsyncUnhandledEx ()
|
|
{
|
|
var mre = new ManualResetEvent (false);
|
|
|
|
var endPoint = new IPEndPoint(0,0);
|
|
var socket = new Socket(endPoint.AddressFamily, SocketType.Stream, ProtocolType.Unspecified);
|
|
|
|
var socketArgs = new SocketAsyncEventArgs();
|
|
socketArgs.RemoteEndPoint = endPoint;
|
|
socketArgs.Completed += (sender, e) => mre.Set ();
|
|
|
|
if (socket.ConnectAsync (socketArgs))
|
|
Assert.IsTrue (mre.WaitOne (1000), "ConnectedAsync timeout");
|
|
|
|
Assert.AreNotEqual (SocketError.Success, socketArgs.SocketError);
|
|
}
|
|
|
|
[Test] // Covers https://bugzilla.xamarin.com/show_bug.cgi?id=52549
|
|
public void SocketMismatchProtocol ()
|
|
{
|
|
try {
|
|
using (Socket socket = new Socket (AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Tcp));
|
|
Assert.Fail ("#1");
|
|
} catch (SocketException e) {
|
|
// Only work on OSX
|
|
// Assert.AreEqual(SocketError.ProtocolType, e.SocketErrorCode, "#2");
|
|
}
|
|
|
|
try {
|
|
using (Socket socket = new Socket (AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Udp));
|
|
Assert.Fail ("#3");
|
|
} catch (SocketException e) {
|
|
// Only work on OSX
|
|
// Assert.AreEqual(SocketError.ProtocolType, e.SocketErrorCode, "#4");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|