MulticastOptionTest.cs.
* Socket.cs: In GetSocketOption, throw SocketException when (byte [])
option value is null. Use SocketError fields instead of using "magic"
number. In SetSocketOption (SocketOptionLevel, SocketOptionName, object)
only accept Linger, AddMembership, DropMembership and verify option
value.
* MulticastOption.cs: Added argument checks. Save interfaceIndex that is
passed to .ctor, and removed MonoTODO. Renamed arguments to match MS.
Reset InterfaceIndex when LocalAddress is modified, and reset
LocalAddress when InterfaceIndex is modified.
* UdpClient.cs: Modified exception to more closely match MS. Fixed
(int, AddressFamily) .ctor to construct IPv6 endpoint when family is
InterNetworkV6. Added null check for multicastAddr to (IPAddress)
JoinMulticastGroup overload. In (int, IPAddress) and (IPAddress,
IPAddress) overloads of JoinMulticastGroup throw SocketException when
client is IPv4. Added null check for multicastAddr to (IPAddress, int),
overload, and moved JoinMulticastGroup call after argument checks.
* IPv6MulticastOption.cs: Renamed argument names to match MS. Added
null check to set_Group. Added range check to set_InterfaceIndex.
* IPv6MulticastOptionTest.cs: Added .ctor and property tests.
* MulticastOptionTest.cs: Added .ctor and property tests.
* SocketTest.cs: Fixed compiler warnings. Improved tests for
closed socket. Added tests fr GetSocketOption, and SetSocketOption
overloads (for Linger, DontLinger, AddMembership and DropMembership).
* UdpClientTest.cs: Added .ctor and JoinMulticastGroup tests.
svn path=/trunk/mcs/; revision=137048
+2009-06-28 Gert Driesen <drieseng@users.sourceforge.net>
+
+ * System_test.dll.sources: Added IPv6MulticastOptionTest.cs and
+ MulticastOptionTest.cs.
+
2009-05-14 Jonathan Pryor <jpryor@novell.com>
* Makefile: Distribute Test/test-config-file-net-2.0.
+2009-06-28 Gert Driesen <drieseng@users.sourceforge.net>
+
+ * Socket.cs: In GetSocketOption, throw SocketException when (byte [])
+ option value is null. Use SocketError fields instead of using "magic"
+ number. In SetSocketOption (SocketOptionLevel, SocketOptionName, object)
+ only accept Linger, AddMembership, DropMembership and verify option
+ value.
+ * MulticastOption.cs: Added argument checks. Save interfaceIndex that is
+ passed to .ctor, and removed MonoTODO. Renamed arguments to match MS.
+ Reset InterfaceIndex when LocalAddress is modified, and reset
+ LocalAddress when InterfaceIndex is modified.
+ * UdpClient.cs: Modified exception to more closely match MS. Fixed
+ (int, AddressFamily) .ctor to construct IPv6 endpoint when family is
+ InterNetworkV6. Added null check for multicastAddr to (IPAddress)
+ JoinMulticastGroup overload. In (int, IPAddress) and (IPAddress,
+ IPAddress) overloads of JoinMulticastGroup throw SocketException when
+ client is IPv4. Added null check for multicastAddr to (IPAddress, int),
+ overload, and moved JoinMulticastGroup call after argument checks.
+ * IPv6MulticastOption.cs: Renamed argument names to match MS. Added
+ null check to set_Group. Added range check to set_InterfaceIndex.
+
2009-06-27 Gonzalo Paniagua Javier <gonzalo@novell.com>
* Socket.cs: turn WSAEINVAL into ArgumentException.
public IPv6MulticastOption (IPAddress group)
: this (group, 0)
{
-
}
- public IPv6MulticastOption (IPAddress group, long ifIndex)
+ public IPv6MulticastOption (IPAddress group, long ifindex)
{
if (group == null)
- throw new ArgumentNullException ("grp");
+ throw new ArgumentNullException ("group");
+ if (ifindex < 0 || ifindex > 0xffffffff)
+ throw new ArgumentOutOfRangeException ("ifindex");
this.group = group;
- this.ifIndex = ifIndex;
+ this.ifIndex = ifindex;
}
public IPAddress Group
{
get { return group; }
- set { group = value; }
+ set {
+ if (value == null)
+ throw new ArgumentNullException ("value");
+ group = value;
+ }
}
public long InterfaceIndex
{
get { return ifIndex; }
- set { ifIndex = value; }
+ set {
+ if (value < 0 || value > 0xffffffff)
+ throw new ArgumentOutOfRangeException ("value");
+ ifIndex = value;
+ }
}
}
#endif
int iface_index;
#endif
- public MulticastOption (IPAddress grp)
- : this (grp, IPAddress.Any)
+ public MulticastOption (IPAddress group)
+ : this (group, IPAddress.Any)
{
- group = grp;
}
+
#if NET_2_0
- [MonoTODO ("Get interface IP from interface index")]
public MulticastOption (IPAddress group, int interfaceIndex)
{
+ if (group == null)
+ throw new ArgumentNullException ("group");
+ if (interfaceIndex < 0 || interfaceIndex > 0xffffff)
+ throw new ArgumentOutOfRangeException ("interfaceIndex");
+
this.group = group;
+ this.iface_index = interfaceIndex;
}
#endif
- public MulticastOption (IPAddress grp, IPAddress addr)
- {
- if (grp == null)
- throw new ArgumentNullException ("grp");
- if (addr == null)
- throw new ArgumentNullException ("addr");
+ public MulticastOption (IPAddress group, IPAddress mcint)
+ {
+ if (group == null)
+ throw new ArgumentNullException ("group");
+ if (mcint == null)
+ throw new ArgumentNullException ("mcint");
- group = grp;
- local = addr;
+ this.group = group;
+ this.local = mcint;
}
public IPAddress Group {
public IPAddress LocalAddress {
get { return local; }
- set { local = value; }
+ set {
+ local = value;
+#if NET_2_0
+ iface_index = 0;
+#endif
+ }
}
#if NET_2_0
public int InterfaceIndex {
get { return iface_index; }
- set { iface_index = value; }
+ set {
+ if (value < 0 || value > 0xffffff)
+ throw new ArgumentOutOfRangeException ("value");
+ iface_index = value;
+ local = null;
+ }
}
#endif
}
if (disposed && closed)
throw new ObjectDisposedException (GetType ().ToString ());
+ if (opt_value == null)
+ throw new SocketException ((int) SocketError.Fault,
+ "Error trying to dereference an invalid pointer");
+
int error;
GetSocketOption_arr_internal(socket, level, name, ref opt_value,
// I'd throw an ArgumentNullException, but this is what MS does.
if (opt_value == null)
- throw new SocketException (10014, "Error trying to dereference an invalid pointer");
+ throw new SocketException ((int) SocketError.Fault,
+ "Error trying to dereference an invalid pointer");
int error;
if (disposed && closed)
throw new ObjectDisposedException (GetType ().ToString ());
- // NOTE: if a null is passed, the byte[] overload is used instead...
if (opt_value == null)
- throw new ArgumentNullException("opt_value");
+ throw new ArgumentNullException("optionValue");
int error;
- /* From MS documentation on SetSocketOption: "For an
- * option with a Boolean data type, specify a nonzero
- * value to enable the option, and a zero value to
- * disable the option."
- * Booleans are only handled in 2.0
- */
- if (opt_value is System.Boolean) {
+ if (level == SocketOptionLevel.Socket && name == SocketOptionName.Linger) {
+ LingerOption linger = opt_value as LingerOption;
+ if (linger == null)
#if NET_2_0
- bool bool_val = (bool) opt_value;
- int int_val = (bool_val) ? 1 : 0;
-
- SetSocketOption_internal (socket, level, name, null, null, int_val, out error);
+ throw new ArgumentException ("A 'LingerOption' value must be specified.", "optionValue");
#else
- throw new ArgumentException ("Use an integer 1 (true) or 0 (false) instead of a boolean.", "opt_value");
+ throw new ArgumentException ("optionValue");
#endif
+ SetSocketOption_internal (socket, level, name, linger, null, 0, out error);
+ } else if (level == SocketOptionLevel.IP && (name == SocketOptionName.AddMembership || name == SocketOptionName.DropMembership)) {
+ MulticastOption multicast = opt_value as MulticastOption;
+ if (multicast == null)
+#if NET_2_0
+ throw new ArgumentException ("A 'MulticastOption' value must be specified.", "optionValue");
+#else
+ throw new ArgumentException ("optionValue");
+#endif
+ SetSocketOption_internal (socket, level, name, multicast, null, 0, out error);
+ } else if (level == SocketOptionLevel.IPv6 && (name == SocketOptionName.AddMembership || name == SocketOptionName.DropMembership)) {
+ IPv6MulticastOption multicast = opt_value as IPv6MulticastOption;
+ if (multicast == null)
+#if NET_2_0
+ throw new ArgumentException ("A 'IPv6MulticastOption' value must be specified.", "optionValue");
+#else
+ throw new ArgumentException ("optionValue");
+#endif
+ SetSocketOption_internal (socket, level, name, multicast, null, 0, out error);
} else {
- SetSocketOption_internal (socket, level, name, opt_value, null, 0, out error);
+#if NET_2_0
+ throw new ArgumentException ("Invalid value specified.", "optionValue");
+#else
+ throw new ArgumentException ("optionValue");
+#endif
}
- if (error != 0) {
+ if (error != 0)
if (error == 10022) // WSAEINVAL
throw new ArgumentException ();
throw new SocketException (error);
public UdpClient(AddressFamily family)
{
if(family != AddressFamily.InterNetwork && family != AddressFamily.InterNetworkV6)
- throw new ArgumentException("Family must be InterNetwork or InterNetworkV6", "family");
+#if NET_2_0
+ throw new ArgumentException ("Family must be InterNetwork or InterNetworkV6", "family");
+#else
+ throw new ArgumentException ("family");
+#endif
this.family = family;
InitSocket (null);
#if NET_1_1
public UdpClient (int port, AddressFamily family)
{
- if (family != AddressFamily.InterNetwork &&
- family != AddressFamily.InterNetworkV6) {
+ if (family != AddressFamily.InterNetwork && family != AddressFamily.InterNetworkV6)
+#if NET_2_0
throw new ArgumentException ("Family must be InterNetwork or InterNetworkV6", "family");
- }
-
+#else
+ throw new ArgumentException ("family");
+#endif
+
if (port < IPEndPoint.MinPort ||
port > IPEndPoint.MaxPort) {
throw new ArgumentOutOfRangeException ("port");
}
-
+
this.family = family;
- IPEndPoint localEP = new IPEndPoint (IPAddress.Any, port);
+ IPEndPoint localEP;
+
+ if (family == AddressFamily.InterNetwork)
+ localEP = new IPEndPoint (IPAddress.Any, port);
+ else
+ localEP = new IPEndPoint (IPAddress.IPv6Any, port);
InitSocket (localEP);
}
#endif
-
+
public UdpClient (string hostname, int port)
{
if (hostname == null)
{
CheckDisposed ();
+ if (multicastAddr == null)
+#if NET_2_0
+ throw new ArgumentNullException ("multicastAddr");
+#else
+ throw new NullReferenceException ();
+#endif
+
if(family == AddressFamily.InterNetwork)
socket.SetSocketOption (SocketOptionLevel.IP, SocketOptionName.AddMembership,
new MulticastOption (multicastAddr));
{
CheckDisposed ();
- /* Does this overload only apply to IPv6?
- * Only the IPv6MulticastOption has an
- * ifindex-using constructor. The MS docs
- * don't say.
- */
- if (family == AddressFamily.InterNetworkV6) {
+ if (multicastAddr == null)
+ throw new ArgumentNullException ("multicastAddr");
+
+ if (family == AddressFamily.InterNetworkV6)
socket.SetSocketOption (SocketOptionLevel.IPv6, SocketOptionName.AddMembership, new IPv6MulticastOption (multicastAddr, ifindex));
- }
+ else
+ throw new SocketException ((int) SocketError.OperationNotSupported);
}
#endif
-
+
public void JoinMulticastGroup (IPAddress multicastAddr, int timeToLive)
{
CheckDisposed ();
- JoinMulticastGroup (multicastAddr);
+ if (multicastAddr == null)
+ throw new ArgumentNullException ("multicastAddr");
if (timeToLive < 0 || timeToLive > 255)
throw new ArgumentOutOfRangeException ("timeToLive");
+ JoinMulticastGroup (multicastAddr);
if(family == AddressFamily.InterNetwork)
socket.SetSocketOption (SocketOptionLevel.IP, SocketOptionName.MulticastTimeToLive,
timeToLive);
{
CheckDisposed ();
- if (family == AddressFamily.InterNetwork) {
+ if (family == AddressFamily.InterNetwork)
socket.SetSocketOption (SocketOptionLevel.IP, SocketOptionName.AddMembership, new MulticastOption (multicastAddr, localAddress));
- } else if (family == AddressFamily.InterNetworkV6) {
- socket.SetSocketOption (SocketOptionLevel.IPv6, SocketOptionName.AddMembership, new MulticastOption (multicastAddr, localAddress));
- }
+ else
+ throw new SocketException ((int) SocketError.OperationNotSupported);
}
#endif
-
+
#endregion
-#region Data I/O
+ #region Data I/O
public byte [] Receive (ref IPEndPoint remoteEP)
{
CheckDisposed ();
System.Net.Configuration/ConnectionManagementSectionTest.cs
System.Net.Configuration/HttpWebRequestElementTest.cs
System.Net.Configuration/WebRequestModulesSectionTest.cs
+System.Net.Sockets/IPv6MulticastOptionTest.cs
+System.Net.Sockets/MulticastOptionTest.cs
System.Net.Sockets/NetworkStreamTest.cs
System.Net.Sockets/TcpClientTest.cs
System.Net.Sockets/TcpListenerTest.cs
+2009-06-28 Gert Driesen <drieseng@users.sourceforge.net>
+
+ * IPv6MulticastOptionTest.cs: Added .ctor and property tests.
+ * MulticastOptionTest.cs: Added .ctor and property tests.
+ * SocketTest.cs: Fixed compiler warnings. Improved tests for
+ closed socket. Added tests fr GetSocketOption, and SetSocketOption
+ overloads (for Linger, DontLinger, AddMembership and DropMembership).
+ * UdpClientTest.cs: Added .ctor and JoinMulticastGroup tests.
+
2009-06-26 Gonzalo Paniagua Javier <gonzalo@novell.com>
* SocketTest.cs: tests for DontLinger.
--- /dev/null
+// System.Net.Sockets.IPv6MulticastOptionTest.cs
+//
+// Authors:
+// Gert Driesen (drieseng@users.sourceforge.net)
+//
+// Copyright (c) 2009 Gert Driesen
+//
+
+using System;
+using System.Net;
+using System.Net.Sockets;
+
+using NUnit.Framework;
+
+namespace MonoTests.System.Net.Sockets
+{
+ [TestFixture]
+ public class IPv6MulticastOptionTest
+ {
+ [Test] // .ctor (IPAddress)
+ public void Constructor1 ()
+ {
+ IPv6MulticastOption option;
+ IPAddress group;
+
+ group = IPAddress.Parse ("ff02::1");
+ option = new IPv6MulticastOption (group);
+ Assert.AreSame (group, option.Group, "#A:Group");
+ Assert.AreEqual (0, option.InterfaceIndex, "#A:InterfaceIndex");
+
+ group = IPAddress.Parse ("224.0.0.23");
+ option = new IPv6MulticastOption (group);
+ Assert.AreSame (group, option.Group, "#B:Group");
+ Assert.AreEqual (0, option.InterfaceIndex, "#B:InterfaceIndex");
+ }
+
+ [Test] // .ctor (IPAddress)
+ public void Constructor1_Group_Null ()
+ {
+ try {
+ new IPv6MulticastOption ((IPAddress) 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 ("group", ex.ParamName, "#5");
+ }
+ }
+
+ [Test] // .ctor (IPAddress, Int64)
+ public void Constructor2 ()
+ {
+ IPv6MulticastOption option;
+ IPAddress group;
+ long interfaceIndex;
+
+ group = IPAddress.Parse ("239.255.255.250");
+ interfaceIndex = 0;
+ option = new IPv6MulticastOption (group, interfaceIndex);
+ Assert.AreSame (group, option.Group, "#A:Group");
+ Assert.AreEqual (interfaceIndex, option.InterfaceIndex, "#A:InterfaceIndex");
+
+ group = IPAddress.Parse ("ff02::1");
+ interfaceIndex = 0;
+ option = new IPv6MulticastOption (group, interfaceIndex);
+ Assert.AreSame (group, option.Group, "#B:Group");
+ Assert.AreEqual (interfaceIndex, option.InterfaceIndex, "#B:InterfaceIndex");
+
+ group = IPAddress.Parse ("239.255.255.250");
+ interfaceIndex = 124;
+ option = new IPv6MulticastOption (group, interfaceIndex);
+ Assert.AreSame (group, option.Group, "#C:Group");
+ Assert.AreEqual (interfaceIndex, option.InterfaceIndex, "#C:InterfaceIndex");
+
+ group = IPAddress.Parse ("ff02::1");
+ interfaceIndex = 124;
+ option = new IPv6MulticastOption (group, interfaceIndex);
+ Assert.AreSame (group, option.Group, "#D:Group");
+ Assert.AreEqual (interfaceIndex, option.InterfaceIndex, "#D:InterfaceIndex");
+
+ group = IPAddress.Parse ("239.255.255.250");
+ interfaceIndex = 0xFFFFFFFF;
+ option = new IPv6MulticastOption (group, interfaceIndex);
+ Assert.AreSame (group, option.Group, "#E:Group");
+ Assert.AreEqual (interfaceIndex, option.InterfaceIndex, "#E:InterfaceIndex");
+
+ group = IPAddress.Parse ("ff02::1");
+ interfaceIndex = 0xFFFFFFFF;
+ option = new IPv6MulticastOption (group, interfaceIndex);
+ Assert.AreSame (group, option.Group, "#F:Group");
+ Assert.AreEqual (interfaceIndex, option.InterfaceIndex, "#F:InterfaceIndex");
+ }
+
+ [Test] // .ctor (IPAddress, Int64)
+ public void Constructor2_Group_Null ()
+ {
+ IPAddress group = null;
+
+ try {
+ new IPv6MulticastOption (group, 0);
+ 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 ("group", ex.ParamName, "#5");
+ }
+ }
+
+ [Test] // .ctor (IPAddress, Int64)
+ public void Constructor2_Ifindex_OutOfRange ()
+ {
+ IPAddress group = IPAddress.Parse ("ff02::1");
+
+ try {
+ new IPv6MulticastOption (group, -1);
+ 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 ("ifindex", ex.ParamName, "#A5");
+ }
+
+ try {
+ new IPv6MulticastOption (group, 0x100000000);
+ 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 ("ifindex", ex.ParamName, "#B5");
+ }
+ }
+
+ [Test]
+ public void Group ()
+ {
+ IPAddress group;
+ IPv6MulticastOption option;
+
+ group = IPAddress.Parse ("239.255.255.250");
+ option = new IPv6MulticastOption (group, 5L);
+ group = IPAddress.Parse ("224.0.0.23");
+ option.Group = group;
+ Assert.AreSame (group, option.Group, "#A1");
+ Assert.AreEqual (5L, option.InterfaceIndex, "#A2");
+ group = IPAddress.Parse ("239.255.255.250");
+ option.Group = group;
+ Assert.AreSame (group, option.Group, "#B1");
+ Assert.AreEqual (5L, option.InterfaceIndex, "#B2");
+ group = IPAddress.Parse ("ff02::1");
+ option.Group = group;
+ Assert.AreSame (group, option.Group, "#C1");
+ Assert.AreEqual (5L, option.InterfaceIndex, "#C2");
+ }
+
+ [Test]
+ public void Group_Value_Null ()
+ {
+ IPAddress group = IPAddress.Parse ("239.255.255.250");
+ IPv6MulticastOption option = new IPv6MulticastOption (group, 10);
+
+ try {
+ option.Group = 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 ("value", ex.ParamName, "#5");
+ }
+ }
+
+ [Test]
+ public void InterfaceIndex ()
+ {
+ IPAddress group;
+ IPv6MulticastOption option;
+
+ group = IPAddress.Parse ("239.255.255.250");
+ option = new IPv6MulticastOption (group, 10);
+ option.InterfaceIndex = 0;
+ Assert.AreSame (group, option.Group, "#A1");
+ Assert.AreEqual (0, option.InterfaceIndex, "#A2");
+ option.InterfaceIndex = 124;
+ Assert.AreSame (group, option.Group, "#B1");
+ Assert.AreEqual (124, option.InterfaceIndex, "#B2");
+ option.InterfaceIndex = 0xFFFFFFFF;
+ Assert.AreSame (group, option.Group, "#C1");
+ Assert.AreEqual (0xFFFFFFFF, option.InterfaceIndex, "#C3");
+ }
+
+ [Test]
+ public void InterfaceIndex_Value_OutOfRange ()
+ {
+ IPAddress group = IPAddress.Parse ("239.255.255.250");
+ IPv6MulticastOption option = new IPv6MulticastOption (group, 10);
+
+ try {
+ option.InterfaceIndex = -1;
+ 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 ("value", ex.ParamName, "#A5");
+ }
+
+ try {
+ option.InterfaceIndex = 0x100000000;
+ 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 ("value", ex.ParamName, "#B5");
+ }
+
+ // ensure original value was retained
+ Assert.AreEqual (10, option.InterfaceIndex, "#C");
+ }
+ }
+}
--- /dev/null
+// System.Net.Sockets.MulticastOptionTest.cs
+//
+// Authors:
+// Gert Driesen (drieseng@users.sourceforge.net)
+//
+// Copyright (c) 2009 Gert Driesen
+//
+
+using System;
+using System.Net;
+using System.Net.Sockets;
+
+using NUnit.Framework;
+
+namespace MonoTests.System.Net.Sockets
+{
+ [TestFixture]
+ public class MulticastOptionTest
+ {
+ [Test] // .ctor (IPAddress)
+ public void Constructor1 ()
+ {
+ MulticastOption option;
+ IPAddress group;
+
+ group = IPAddress.Parse ("239.255.255.250");
+ option = new MulticastOption (group);
+ Assert.AreSame (group, option.Group, "#A:Group");
+#if NET_2_0
+ Assert.AreEqual (0, option.InterfaceIndex, "#A:InterfaceIndex");
+#endif
+ Assert.AreEqual (IPAddress.Any, option.LocalAddress, "#A:LocalAddress");
+
+ group = IPAddress.Parse ("ff02::1");
+ option = new MulticastOption (group);
+ Assert.AreSame (group, option.Group, "#B:Group");
+#if NET_2_0
+ Assert.AreEqual (0, option.InterfaceIndex, "#B:InterfaceIndex");
+#endif
+ Assert.AreEqual (IPAddress.Any, option.LocalAddress, "#B:LocalAddress");
+ }
+
+ [Test] // .ctor (IPAddress)
+ public void Constructor1_Group_Null ()
+ {
+ try {
+ new MulticastOption ((IPAddress) 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 ("group", ex.ParamName, "#5");
+ }
+ }
+
+ [Test] // .ctor (IPAddress, IPAddress)
+ public void Constructor2 ()
+ {
+ MulticastOption option;
+ IPAddress group;
+ IPAddress mcint;
+
+ group = IPAddress.Parse ("239.255.255.250");
+ mcint = IPAddress.Any;
+ option = new MulticastOption (group, mcint);
+ Assert.AreSame (group, option.Group, "#A:Group");
+#if NET_2_0
+ Assert.AreEqual (0, option.InterfaceIndex, "#A:InterfaceIndex");
+#endif
+ Assert.AreEqual (mcint, option.LocalAddress, "#A:LocalAddress");
+
+ group = IPAddress.Parse ("ff02::1");
+ mcint = IPAddress.IPv6Any;
+ option = new MulticastOption (group, mcint);
+ Assert.AreSame (group, option.Group, "#B:Group");
+#if NET_2_0
+ Assert.AreEqual (0, option.InterfaceIndex, "#B:InterfaceIndex");
+#endif
+ Assert.AreEqual (mcint, option.LocalAddress, "#B:LocalAddress");
+ }
+
+ [Test] // .ctor (IPAddress, IPAddress)
+ public void Constructor2_Group_Null ()
+ {
+ IPAddress group = null;
+ IPAddress mcint = IPAddress.Any;
+
+ try {
+ new MulticastOption (group, mcint);
+ 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 ("group", ex.ParamName, "#5");
+ }
+ }
+
+ [Test] // .ctor (IPAddress, IPAddress)
+ public void Constructor2_Mcint_Null ()
+ {
+ IPAddress group = IPAddress.Parse ("239.255.255.250");
+ IPAddress mcint = null;
+
+ try {
+ new MulticastOption (group, mcint);
+ 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 ("mcint", ex.ParamName, "#5");
+ }
+ }
+
+#if NET_2_0
+ [Test] // .ctor (IPAddress, Int32)
+ public void Constructor3 ()
+ {
+ MulticastOption option;
+ IPAddress group;
+ int interfaceIndex;
+
+ group = IPAddress.Parse ("239.255.255.250");
+ interfaceIndex = 0;
+ option = new MulticastOption (group, interfaceIndex);
+ Assert.AreSame (group, option.Group, "#A:Group");
+ Assert.AreEqual (interfaceIndex, option.InterfaceIndex, "#A:InterfaceIndex");
+ Assert.AreEqual (null, option.LocalAddress, "#A:LocalAddress");
+
+ group = IPAddress.Parse ("ff02::1");
+ interfaceIndex = 0;
+ option = new MulticastOption (group, interfaceIndex);
+ Assert.AreSame (group, option.Group, "#B:Group");
+ Assert.AreEqual (interfaceIndex, option.InterfaceIndex, "#B:InterfaceIndex");
+ Assert.AreEqual (null, option.LocalAddress, "#B:LocalAddress");
+
+ group = IPAddress.Parse ("239.255.255.250");
+ interfaceIndex = 124;
+ option = new MulticastOption (group, interfaceIndex);
+ Assert.AreSame (group, option.Group, "#C:Group");
+ Assert.AreEqual (interfaceIndex, option.InterfaceIndex, "#C:InterfaceIndex");
+ Assert.AreEqual (null, option.LocalAddress, "#C:LocalAddress");
+
+ group = IPAddress.Parse ("ff02::1");
+ interfaceIndex = 124;
+ option = new MulticastOption (group, interfaceIndex);
+ Assert.AreSame (group, option.Group, "#D:Group");
+ Assert.AreEqual (interfaceIndex, option.InterfaceIndex, "#D:InterfaceIndex");
+ Assert.AreEqual (null, option.LocalAddress, "#D:LocalAddress");
+
+ group = IPAddress.Parse ("239.255.255.250");
+ interfaceIndex = 0xFFFFFF;
+ option = new MulticastOption (group, interfaceIndex);
+ Assert.AreSame (group, option.Group, "#E:Group");
+ Assert.AreEqual (interfaceIndex, option.InterfaceIndex, "#E:InterfaceIndex");
+ Assert.AreEqual (null, option.LocalAddress, "#E:LocalAddress");
+
+ group = IPAddress.Parse ("ff02::1");
+ interfaceIndex = 0xFFFFFF;
+ option = new MulticastOption (group, interfaceIndex);
+ Assert.AreSame (group, option.Group, "#F:Group");
+ Assert.AreEqual (interfaceIndex, option.InterfaceIndex, "#F:InterfaceIndex");
+ Assert.AreEqual (null, option.LocalAddress, "#F:LocalAddress");
+ }
+
+ [Test] // .ctor (IPAddress, Int32)
+ public void Constructor3_Group_Null ()
+ {
+ IPAddress group = null;
+
+ try {
+ new MulticastOption (group, int.MaxValue);
+ 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 ("group", ex.ParamName, "#5");
+ }
+ }
+
+ [Test] // .ctor (IPAddress, Int32)
+ public void Constructor3_InterfaceIndex_OutOfRange ()
+ {
+ IPAddress group = IPAddress.Parse ("239.255.255.250");
+
+ try {
+ new MulticastOption (group, -1);
+ 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 ("interfaceIndex", ex.ParamName, "#A5");
+ }
+
+ try {
+ new MulticastOption (group, 0x1000000);
+ 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 ("interfaceIndex", ex.ParamName, "#B5");
+ }
+ }
+#endif
+
+ [Test]
+ public void Group ()
+ {
+ IPAddress group;
+ IPAddress local;
+ MulticastOption option;
+
+#if NET_2_0
+ local = Dns.GetHostEntry (string.Empty).AddressList [0];
+#else
+ local = IPAddress.Loopback;
+#endif
+ group = IPAddress.Parse ("239.255.255.250");
+ option = new MulticastOption (group, local);
+ group = IPAddress.Parse ("224.0.0.23");
+ option.Group = group;
+ Assert.AreSame (group, option.Group, "#A1");
+ Assert.AreSame (local, option.LocalAddress, "#A2");
+ group = IPAddress.Parse ("239.255.255.250");
+ option.Group = group;
+ Assert.AreSame (group, option.Group, "#B1");
+ Assert.AreSame (local, option.LocalAddress, "#B2");
+ group = IPAddress.Parse ("ff02::1");
+ option.Group = group;
+ Assert.AreSame (group, option.Group, "#C1");
+ Assert.AreSame (local, option.LocalAddress, "#C2");
+ option.Group = null;
+ Assert.IsNull (option.Group, "#D1");
+ Assert.AreSame (local, option.LocalAddress, "#D2");
+#if NET_2_0
+ option = new MulticastOption (group, 5);
+ group = IPAddress.Parse ("224.0.0.23");
+ option.Group = group;
+ Assert.AreSame (group, option.Group, "#E1");
+ Assert.AreEqual (5, option.InterfaceIndex, "#E2");
+ Assert.IsNull (option.LocalAddress, "#E3");
+#endif
+ }
+
+#if NET_2_0
+ [Test]
+ public void InterfaceIndex ()
+ {
+ IPAddress group;
+ IPAddress local;
+ MulticastOption option;
+
+ group = IPAddress.Parse ("239.255.255.250");
+ option = new MulticastOption (group, 10);
+ option.InterfaceIndex = 0;
+ Assert.AreSame (group, option.Group, "#A1");
+ Assert.AreEqual (0, option.InterfaceIndex, "#A2");
+ Assert.IsNull (option.LocalAddress, "#A3");
+ option.InterfaceIndex = 124;
+ Assert.AreSame (group, option.Group, "#B1");
+ Assert.AreEqual (124, option.InterfaceIndex, "#B2");
+ Assert.IsNull (option.LocalAddress, "#B3");
+ option.InterfaceIndex = 0xFFFFFF;
+ Assert.AreSame (group, option.Group, "#C1");
+ Assert.AreEqual (0xFFFFFF, option.InterfaceIndex, "#C2");
+ Assert.IsNull (option.LocalAddress, "#C3");
+
+ local = Dns.GetHostEntry (string.Empty).AddressList [0];
+ option = new MulticastOption (group, local);
+ option.InterfaceIndex = 10;
+ Assert.AreSame (group, option.Group, "#D1");
+ Assert.AreEqual (10, option.InterfaceIndex, "#D2");
+ Assert.IsNull (option.LocalAddress, "#D3");
+ }
+
+ [Test]
+ public void InterfaceIndex_Value_OutOfRange ()
+ {
+ IPAddress group = IPAddress.Parse ("239.255.255.250");
+ MulticastOption option = new MulticastOption (group, 10);
+
+ try {
+ option.InterfaceIndex = -1;
+ 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 ("value", ex.ParamName, "#A5");
+ }
+
+ try {
+ option.InterfaceIndex = 0x1000000;
+ 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 ("value", ex.ParamName, "#B5");
+ }
+
+ // ensure original value was retained
+ Assert.AreEqual (10, option.InterfaceIndex, "#C");
+ }
+#endif
+
+ [Test]
+ public void LocalAddress ()
+ {
+ IPAddress group;
+ IPAddress local;
+ MulticastOption option;
+
+#if NET_2_0
+ local = Dns.GetHostEntry (string.Empty).AddressList [0];
+#else
+ local = IPAddress.Loopback;
+#endif
+ group = IPAddress.Parse ("239.255.255.250");
+ option = new MulticastOption (group, local);
+ local = IPAddress.Loopback;
+ option.LocalAddress = local;
+ Assert.AreSame (group, option.Group, "#A1");
+#if NET_2_0
+ Assert.AreEqual (0, option.InterfaceIndex, "#A2");
+#endif
+ Assert.AreSame (local, option.LocalAddress, "#A3");
+#if NET_2_0
+ local = Dns.GetHostEntry (string.Empty).AddressList [0];
+#else
+ local = IPAddress.Loopback;
+#endif
+ option.LocalAddress = local;
+ Assert.AreSame (group, option.Group, "#B1");
+#if NET_2_0
+ Assert.AreEqual (0, option.InterfaceIndex, "#B2");
+#endif
+ Assert.AreSame (local, option.LocalAddress, "#B3");
+ option.LocalAddress = null;
+ Assert.AreSame (group, option.Group, "#C1");
+#if NET_2_0
+ Assert.AreEqual (0, option.InterfaceIndex, "#C2");
+#endif
+ Assert.IsNull (option.LocalAddress, "#C3");
+#if NET_2_0
+ option = new MulticastOption (group, 5);
+ local = IPAddress.Loopback;
+ option.LocalAddress = local;
+ Assert.AreSame (group, option.Group, "#D1");
+ Assert.AreEqual (0, option.InterfaceIndex, "#D2");
+ Assert.AreSame (local, option.LocalAddress, "#D3");
+#endif
+ }
+ }
+}
s.Blocking = true;
}
- [Test]
- [ExpectedException (typeof (ObjectDisposedException))]
- public void Disposed3 ()
- {
- Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
- s.Close();
-
- s.GetSocketOption (0, 0);
- }
-
- [Test]
- [ExpectedException (typeof (ObjectDisposedException))]
- public void Disposed4 ()
- {
- Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
- s.Close();
-
- s.GetSocketOption (0, 0, null);
- }
-
- [Test]
- [ExpectedException (typeof (ObjectDisposedException))]
- public void Disposed5 ()
- {
- Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
- s.Close();
-
- s.GetSocketOption (0, 0, 0);
- }
-
[Test]
[ExpectedException (typeof (ObjectDisposedException))]
public void Disposed6 ()
public void Disposed11 ()
{
Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
- EndPoint ep = new IPEndPoint (IPAddress.Any, 31337);
s.Close();
s.Receive (buf, 0, 10, 0);
public void Disposed18 ()
{
Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
- EndPoint ep = new IPEndPoint (IPAddress.Any, 31337);
s.Close();
s.Send (buf, 0, 10, 0);
public void Disposed23 ()
{
Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
- EndPoint ep = new IPEndPoint (IPAddress.Any, 31337);
s.Close();
s.Shutdown (0);
}
[Test]
- public void SocketError ()
+ public void SocketErrorTest ()
{
Socket sock = new Socket (AddressFamily.InterNetwork,
SocketType.Stream,
}
}
#endif
- [Test]
- public void SetSocketOption_DontLinger ()
+
+ [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");
+#if NET_2_0
+ Assert.AreEqual (SocketError.Fault, ex.SocketErrorCode, "#7");
+#endif
+ }
+ }
+
+ [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");
#if NET_2_0
- s.SetSocketOption (SocketOptionLevel.Socket, SocketOptionName.DontLinger, false);
+ Assert.AreEqual (SocketError.Fault, ex.SocketErrorCode, "#7");
#endif
+ }
+ }
+ }
+
+ [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");
+#if NET_2_0
+ Assert.AreEqual (SocketError.Fault, ex.SocketErrorCode, "#7");
+#endif
+ }
+ }
+ }
+
+ [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]
- [ExpectedException (typeof (SocketException))]
- public void SetSocketOption_Null_DontLinger ()
+ [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.DontLinger, null);
+ s.SetSocketOption (SocketOptionLevel.Socket, SocketOptionName.Linger, 0);
+ s.SetSocketOption (SocketOptionLevel.Socket, SocketOptionName.Linger, 5);
}
}
- [Test]
- [ExpectedException (typeof (ArgumentException))]
- public void SetSocketOption_LingerOption_DontLinger ()
+ [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)
+ 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, 1901));
+ 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");
+#if NET_2_0
+ // The specified value is not a valid 'MulticastOption'
+ Assert.IsTrue (ex.Message.IndexOf ("'MulticastOption'") != -1, "#5:" + ex.Message);
+ Assert.AreEqual ("optionValue", ex.ParamName, "#6");
+#else
+ Assert.AreEqual ("optionValue", ex.Message, "#5");
+ Assert.IsNull (ex.ParamName, "#6");
+#endif
+ }
+ }
+ }
+
+ [Test] // SetSocketOption (SocketOptionLevel, SocketOptionName, Object)
+ 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, 1901));
+ 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");
+#if NET_2_0
+ Assert.AreEqual (SocketError.InvalidArgument, ex.SocketErrorCode, "#7");
+#endif
+ } finally {
+ s.Close ();
+ }
+ }
+
+ [Test] // SetSocketOption (SocketOptionLevel, SocketOptionName, Object)
+ public void SetSocketOption3_AddMembershipIPv6_IPv6MulticastOption ()
+ {
+#if NET_2_0
+ if (!Socket.OSSupportsIPv6)
+#else
+ if (!Socket.SupportsIPv6)
+#endif
+ 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, 1902));
+ s.SetSocketOption (SocketOptionLevel.IPv6, SocketOptionName.AddMembership,
+ new IPv6MulticastOption (mcast_addr));
+ }
+ }
+
+ [Test] // SetSocketOption (SocketOptionLevel, SocketOptionName, Object)
+ public void SetSocketOption3_AddMembershipIPv6_MulticastOption ()
+ {
+#if NET_2_0
+ if (!Socket.OSSupportsIPv6)
+#else
+ if (!Socket.SupportsIPv6)
+#endif
+ 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, 1902));
+ 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");
+#if NET_2_0
+ // The specified value is not a valid 'IPv6MulticastOption'
+ Assert.IsTrue (ex.Message.IndexOf ("'IPv6MulticastOption'") != -1, "#5:" + ex.Message);
+ Assert.AreEqual ("optionValue", ex.ParamName, "#6");
+#else
+ Assert.AreEqual ("optionValue", ex.Message, "#5");
+ Assert.IsNull (ex.ParamName, "#6");
+#endif
+ }
+ }
+ }
+
+ [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");
+#if NET_2_0
+ Assert.AreEqual (SocketError.InvalidArgument, ex.SocketErrorCode, "#7");
+#endif
+ } 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");
+#if NET_2_0
+ Assert.IsNotNull (ex.Message, "#4");
+ Assert.AreEqual ("optionValue", ex.ParamName, "#5");
+#else
+ Assert.AreEqual ("optionValue", ex.Message, "#4");
+ Assert.IsNull (ex.ParamName, "#5");
+#endif
+ }
+ }
+ }
+
+ [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");
+#if NET_2_0
+ Assert.IsNotNull (ex.Message, "#4");
+ Assert.AreEqual ("optionValue", ex.ParamName, "#5");
+#else
+ Assert.AreEqual ("optionValue", ex.Message, "#4");
+ Assert.IsNull (ex.ParamName, "#5");
+#endif
+ }
+ }
+ }
+
+ [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");
+#if NET_2_0
+ // The specified value is not valid
+ Assert.IsNotNull (ex.Message, "#4");
+ Assert.AreEqual ("optionValue", ex.ParamName, "#5");
+#else
+ Assert.AreEqual ("optionValue", ex.Message, "#4");
+ Assert.IsNull (ex.ParamName, "#5");
+#endif
+ }
+ }
+ }
+
+ [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");
+#if NET_2_0
+ // The specified value is not valid
+ Assert.IsNotNull (ex.Message, "#4");
+ Assert.AreEqual ("optionValue", ex.ParamName, "#5");
+#else
+ Assert.AreEqual ("optionValue", ex.Message, "#4");
+ Assert.IsNull (ex.ParamName, "#5");
+#endif
+ }
+ }
+ }
+
+ [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");
+#if NET_2_0
+ // The specified value is not valid
+ Assert.IsNotNull (ex.Message, "#4");
+ Assert.AreEqual ("optionValue", ex.ParamName, "#5");
+#else
+ Assert.AreEqual ("optionValue", ex.Message, "#4");
+ Assert.IsNull (ex.ParamName, "#5");
+#endif
+ }
+ }
+ }
+
+ [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)
+ 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, 1901));
+ 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");
+#if NET_2_0
+ // The specified value is not a valid 'MulticastOption'
+ Assert.IsTrue (ex.Message.IndexOf ("'MulticastOption'") != -1, "#5:" + ex.Message);
+ Assert.AreEqual ("optionValue", ex.ParamName, "#6");
+#else
+ Assert.AreEqual ("optionValue", ex.Message, "#5");
+ Assert.IsNull (ex.ParamName, "#6");
+#endif
+ }
+ }
+ }
+
+ [Test] // SetSocketOption (SocketOptionLevel, SocketOptionName, Object)
+ 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, 1901));
+ 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");
+#if NET_2_0
+ Assert.AreEqual (SocketError.InvalidArgument, ex.SocketErrorCode, "#7");
+#endif
+ } finally {
+ s.Close ();
+ }
+ }
+
+ [Test] // SetSocketOption (SocketOptionLevel, SocketOptionName, Object)
+ public void SetSocketOption3_DropMembershipIPv6_IPv6MulticastOption ()
+ {
+#if NET_2_0
+ if (!Socket.OSSupportsIPv6)
+#else
+ if (!Socket.SupportsIPv6)
+#endif
+ 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, 1902));
+ s.SetSocketOption (SocketOptionLevel.IPv6, SocketOptionName.AddMembership,
+ option);
+ s.SetSocketOption (SocketOptionLevel.IPv6, SocketOptionName.DropMembership,
+ option);
+ }
+ }
+
+ [Test] // SetSocketOption (SocketOptionLevel, SocketOptionName, Object)
+ public void SetSocketOption3_DropMembershipIPv6_MulticastOption ()
+ {
+#if NET_2_0
+ if (!Socket.OSSupportsIPv6)
+#else
+ if (!Socket.SupportsIPv6)
+#endif
+ 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, 1902));
+ 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");
+#if NET_2_0
+ // The specified value is not a valid 'IPv6MulticastOption'
+ Assert.IsTrue (ex.Message.IndexOf ("'IPv6MulticastOption'") != -1, "#5:" + ex.Message);
+ Assert.AreEqual ("optionValue", ex.ParamName, "#6");
+#else
+ Assert.AreEqual ("optionValue", ex.Message, "#5");
+ Assert.IsNull (ex.ParamName, "#6");
+#endif
+ }
+ }
+ }
+
+ [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");
+#if NET_2_0
+ Assert.AreEqual (SocketError.InvalidArgument, ex.SocketErrorCode, "#7");
+#endif
+ } finally {
+ s.Close ();
+ }
+ }
+
+ [Test] // SetSocketOption (SocketOptionLevel, SocketOptionName, Object)
+ public void SetSocketOption3_OptionValue_Null ()
{
using (Socket s = new Socket (AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)) {
- s.SetSocketOption (SocketOptionLevel.Socket, SocketOptionName.DontLinger, new LingerOption (true, 1000));
+ 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");
}
}
}
}
-
//
// Authors:
// Chris Bacon <chris.bacon@docobo.co.uk>
+// Gert Driesen <drieseng@users.sourceforge.net>
//
-
using System;
using System.Net;
using System.Net.Sockets;
using System.Threading;
+
using NUnit.Framework;
namespace MonoTests.System.Net.Sockets {
#if TARGET_JVM
- [Ignore("UdpClient is not supported - since UDP sockets are not supported")]
+ [Ignore("UdpClient is not supported - since UDP sockets are not supported")]
#endif
- [TestFixture]
+ [TestFixture]
public class UdpClientTest {
+ [Test] // .ctor ()
+ public void Constructor1 ()
+ {
+ MyUdpClient client;
+ Socket s;
+
+ client = new MyUdpClient ();
+ s = client.Client;
+ Assert.IsNotNull (s, "Client");
+ Assert.AreEqual (AddressFamily.InterNetwork, s.AddressFamily, "Client:AddressFamily");
+ Assert.IsFalse (s.Connected, "Client:Connected");
+#if NET_2_0
+ Assert.IsFalse (s.IsBound, "#A:Client:IsBound");
+#endif
+ Assert.IsNull (s.LocalEndPoint, "Client:LocalEndPoint");
+ Assert.AreEqual (ProtocolType.Udp, s.ProtocolType, "Client:ProtocolType");
+ Assert.IsNull (s.RemoteEndPoint, "Client:RemoteEndPoint");
+ Assert.AreEqual (SocketType.Dgram, s.SocketType, "Client:SocketType");
+ Assert.IsFalse (client.Active, "Active");
+#if NET_2_0
+ Assert.IsFalse (client.DontFragment, "DontFragment");
+ Assert.IsFalse (client.EnableBroadcast, "EnableBroadcast");
+ //Assert.IsFalse (client.ExclusiveAddressUse, "ExclusiveAddressUse");
+ Assert.IsTrue (client.MulticastLoopback, "MulticastLoopback");
+ //Assert.AreEqual (32, client.Ttl, "Ttl");
+#endif
+ }
+
+ [Test] // .ctor (AddressFamily)
+ public void Constructor2 ()
+ {
+ MyUdpClient client;
+ Socket s;
+
+ client = new MyUdpClient (AddressFamily.InterNetwork);
+ s = client.Client;
+ Assert.IsNotNull (s, "#A:Client");
+ Assert.AreEqual (AddressFamily.InterNetwork, s.AddressFamily, "#A:Client:AddressFamily");
+ Assert.IsFalse (s.Connected, "#A:Client:Connected");
+#if NET_2_0
+ Assert.IsFalse (s.IsBound, "#A:Client:IsBound");
+#endif
+ Assert.IsNull (s.LocalEndPoint, "#A:Client:LocalEndPoint");
+ Assert.AreEqual (ProtocolType.Udp, s.ProtocolType, "#A:Client:ProtocolType");
+ Assert.IsNull (s.RemoteEndPoint, "#A:Client:RemoteEndPoint");
+ Assert.AreEqual (SocketType.Dgram, s.SocketType, "#A:Client:SocketType");
+ Assert.IsFalse (client.Active, "#A:Active");
+#if NET_2_0
+ //Assert.IsFalse (client.DontFragment, "#A:DontFragment");
+ Assert.IsFalse (client.EnableBroadcast, "#A:EnableBroadcast");
+ //Assert.IsFalse (client.ExclusiveAddressUse, "#A:ExclusiveAddressUse");
+ Assert.IsTrue (client.MulticastLoopback, "#A:MulticastLoopback");
+ //Assert.AreEqual (32, client.Ttl, "#A:Ttl");
+#endif
+
+ client = new MyUdpClient (AddressFamily.InterNetworkV6);
+ s = client.Client;
+ Assert.IsNotNull (s, "#B:Client");
+ Assert.AreEqual (AddressFamily.InterNetworkV6, s.AddressFamily, "#B:Client:AddressFamily");
+ Assert.IsFalse (s.Connected, "#B:Client:Connected");
+#if NET_2_0
+ Assert.IsFalse (s.IsBound, "#A:Client:IsBound");
+#endif
+ Assert.IsNull (s.LocalEndPoint, "#B:Client:LocalEndPoint");
+ Assert.AreEqual (ProtocolType.Udp, s.ProtocolType, "#B:Client:ProtocolType");
+ Assert.IsNull (s.RemoteEndPoint, "#B:Client:RemoteEndPoint");
+ Assert.AreEqual (SocketType.Dgram, s.SocketType, "#B:Client:SocketType");
+ Assert.IsFalse (client.Active, "#B:Active");
+#if NET_2_0
+ //Assert.IsFalse (client.DontFragment, "#B:DontFragment");
+ Assert.IsFalse (client.EnableBroadcast, "#B:EnableBroadcast");
+ //Assert.IsFalse (client.ExclusiveAddressUse, "#B:ExclusiveAddressUse");
+ Assert.IsTrue (client.MulticastLoopback, "#B:MulticastLoopback");
+ //Assert.AreEqual (32, client.Ttl, "#B:Ttl");
+#endif
+ }
+
+ [Test] // .ctor (AddressFamily)
+ public void Constructor2_Family_Invalid ()
+ {
+ try {
+ new UdpClient (AddressFamily.NetBios);
+ Assert.Fail ("#A1");
+ } catch (ArgumentException ex) {
+ Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
+ Assert.IsNull (ex.InnerException, "#A3");
+#if NET_2_0
+ // 'UDP' Client can only accept InterNetwork or InterNetworkV6
+ // addresses
+ Assert.IsNotNull (ex.Message, "#A4");
+ Assert.AreEqual ("family", ex.ParamName, "#A5");
+#else
+ Assert.AreEqual ("family", ex.Message, "#A4");
+ Assert.IsNull (ex.ParamName, "#A5");
+#endif
+ }
+
+ try {
+ new UdpClient ((AddressFamily) 666);
+ Assert.Fail ("#B1");
+ } catch (ArgumentException ex) {
+ Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
+ Assert.IsNull (ex.InnerException, "#B3");
+#if NET_2_0
+ Assert.IsNotNull (ex.Message, "#B4");
+ Assert.AreEqual ("family", ex.ParamName, "#B5");
+#else
+ Assert.AreEqual ("family", ex.Message, "#B4");
+ Assert.IsNull (ex.ParamName, "#B5");
+#endif
+ }
+ }
+
+ [Test] // .ctor (Int32)
+ public void Constructor3 ()
+ {
+ MyUdpClient client;
+ Socket s;
+ IPEndPoint localEP;
+
+ client = new MyUdpClient (IPEndPoint.MinPort);
+ s = client.Client;
+ Assert.IsNotNull (s, "#A:Client");
+ Assert.AreEqual (AddressFamily.InterNetwork, s.AddressFamily, "#A:Client:AddressFamily");
+ Assert.IsFalse (s.Connected, "#A:Client:Connected");
+#if NET_2_0
+ Assert.IsTrue (s.IsBound, "#A:Client:IsBound");
+#endif
+ Assert.AreEqual (ProtocolType.Udp, s.ProtocolType, "#A:Client:ProtocolType");
+ Assert.AreEqual (SocketType.Dgram, s.SocketType, "#A:Client:SocketType");
+ Assert.IsFalse (client.Active, "#A:Active");
+#if NET_2_0
+ Assert.IsFalse (client.DontFragment, "#A:DontFragment");
+ Assert.IsFalse (client.EnableBroadcast, "#A:EnableBroadcast");
+ //Assert.IsFalse (client.ExclusiveAddressUse, "#A:ExclusiveAddressUse");
+ Assert.IsTrue (client.MulticastLoopback, "#A:MulticastLoopback");
+ //Assert.AreEqual (32, client.Ttl, "#A:Ttl");
+#endif
+ localEP = s.LocalEndPoint as IPEndPoint;
+ Assert.IsNotNull (localEP, "#A:Client:LocalEndpoint");
+ Assert.AreEqual (IPAddress.Any, localEP.Address, "#A:Client:LocalEndPoint/Address");
+ Assert.AreEqual (AddressFamily.InterNetwork, localEP.AddressFamily, "#A:Client:LocalEndPoint/AddressFamily");
+
+ client = new MyUdpClient (IPEndPoint.MaxPort);
+ s = client.Client;
+ Assert.IsNotNull (s, "#B:Client");
+ Assert.AreEqual (AddressFamily.InterNetwork, s.AddressFamily, "#B:Client:AddressFamily");
+ Assert.IsFalse (s.Connected, "#B:Client:Connected");
+#if NET_2_0
+ Assert.IsTrue (s.IsBound, "#B:Client:IsBound");
+#endif
+ Assert.AreEqual (ProtocolType.Udp, s.ProtocolType, "#B:Client:ProtocolType");
+ Assert.AreEqual (SocketType.Dgram, s.SocketType, "#B:Client:SocketType");
+ Assert.IsFalse (client.Active, "#B:Active");
+#if NET_2_0
+ Assert.IsFalse (client.DontFragment, "#B:DontFragment");
+ Assert.IsFalse (client.EnableBroadcast, "#B:EnableBroadcast");
+ //Assert.IsFalse (client.ExclusiveAddressUse, "#B:ExclusiveAddressUse");
+ Assert.IsTrue (client.MulticastLoopback, "#B:MulticastLoopback");
+ //Assert.AreEqual (32, client.Ttl, "#B:Ttl");
+#endif
+ localEP = s.LocalEndPoint as IPEndPoint;
+ Assert.IsNotNull (localEP, "#B:Client:LocalEndpoint");
+ Assert.AreEqual (IPAddress.Any, localEP.Address, "#B:Client:LocalEndPoint/Address");
+ Assert.AreEqual (AddressFamily.InterNetwork, localEP.AddressFamily, "#B:Client:LocalEndPoint/AddressFamily");
+ Assert.AreEqual (IPEndPoint.MaxPort, localEP.Port, "#B:Client:LocalEndPoint/Port");
+ }
+
+ [Test] // .ctor (Int32)
+ public void Constructor3_Port_OutOfRange ()
+ {
+ try {
+ new UdpClient (IPEndPoint.MaxPort + 1);
+ 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 ("port", ex.ParamName, "#A5");
+ }
+
+ try {
+ new UdpClient (IPEndPoint.MinPort - 1);
+ 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 ("port", ex.ParamName, "#A5");
+ }
+ }
+
+ [Test] // .ctor (IPEndPoint)
+ public void Constructor4 ()
+ {
+ MyUdpClient client;
+ Socket s;
+ IPEndPoint localEP;
+ IPEndPoint clientEP;
+
+ clientEP = new IPEndPoint (IPAddress.Loopback, 8001);
+ client = new MyUdpClient (clientEP);
+ s = client.Client;
+ Assert.IsNotNull (s, "#A:Client");
+ Assert.AreEqual (AddressFamily.InterNetwork, s.AddressFamily, "#A:Client:AddressFamily");
+ Assert.IsFalse (s.Connected, "#A:Client:Connected");
+#if NET_2_0
+ Assert.IsTrue (s.IsBound, "#A:Client:IsBound");
+#endif
+ Assert.AreEqual (ProtocolType.Udp, s.ProtocolType, "#A:Client:ProtocolType");
+ Assert.AreEqual (SocketType.Dgram, s.SocketType, "#A:Client:SocketType");
+ Assert.IsFalse (client.Active, "#A:Active");
+#if NET_2_0
+ Assert.IsFalse (client.DontFragment, "#A:DontFragment");
+ Assert.IsFalse (client.EnableBroadcast, "#A:EnableBroadcast");
+ //Assert.IsFalse (client.ExclusiveAddressUse, "#A:ExclusiveAddressUse");
+ Assert.IsTrue (client.MulticastLoopback, "#A:MulticastLoopback");
+ //Assert.AreEqual (32, client.Ttl, "#A:Ttl");
+#endif
+ localEP = s.LocalEndPoint as IPEndPoint;
+ Assert.IsNotNull (localEP, "#A:Client:LocalEndpoint");
+ Assert.IsFalse (object.ReferenceEquals (clientEP, localEP), "#A:Client:LocalEndPoint/ReferenceEquality");
+ Assert.AreEqual (clientEP.Address, localEP.Address, "#A:Client:LocalEndPoint/Address");
+ Assert.AreEqual (clientEP.AddressFamily, localEP.AddressFamily, "#A:Client:LocalEndPoint/AddressFamily");
+ Assert.AreEqual (clientEP.Port, localEP.Port, "#A:Client:LocalEndPoint/Port");
+ }
+
+ [Test] // .ctor (IPEndPoint)
+ public void Constructor4_LocalEP_Null ()
+ {
+ try {
+ new UdpClient ((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 ("localEP", ex.ParamName, "#5");
+ }
+ }
+
+ [Test] // .ctor (Int32, AddressFamily)
+ public void Constructor5 ()
+ {
+ MyUdpClient client;
+ Socket s;
+ IPEndPoint localEP;
+
+ client = new MyUdpClient (IPEndPoint.MinPort, AddressFamily.InterNetwork);
+ s = client.Client;
+ Assert.IsNotNull (s, "#A:Client");
+ Assert.AreEqual (AddressFamily.InterNetwork, s.AddressFamily, "#A:Client:AddressFamily");
+ Assert.IsFalse (s.Connected, "#A:Client:Connected");
+#if NET_2_0
+ Assert.IsTrue (s.IsBound, "#A:Client:IsBound");
+#endif
+ Assert.AreEqual (ProtocolType.Udp, s.ProtocolType, "#A:Client:ProtocolType");
+ Assert.AreEqual (SocketType.Dgram, s.SocketType, "#A:Client:SocketType");
+ Assert.IsFalse (client.Active, "#A:Active");
+#if NET_2_0
+ //Assert.IsFalse (client.DontFragment, "#A:DontFragment");
+ Assert.IsFalse (client.EnableBroadcast, "#A:EnableBroadcast");
+ //Assert.IsFalse (client.ExclusiveAddressUse, "#A:ExclusiveAddressUse");
+ Assert.IsTrue (client.MulticastLoopback, "#A:MulticastLoopback");
+ //Assert.AreEqual (32, client.Ttl, "#A:Ttl");
+#endif
+ localEP = s.LocalEndPoint as IPEndPoint;
+ Assert.IsNotNull (localEP, "#A:Client:LocalEndpoint");
+ Assert.AreEqual (IPAddress.Any, localEP.Address, "#A:Client:LocalEndPoint/Address");
+ Assert.AreEqual (AddressFamily.InterNetwork, localEP.AddressFamily, "#A:Client:LocalEndPoint/AddressFamily");
+
+ client = new MyUdpClient (IPEndPoint.MaxPort, AddressFamily.InterNetworkV6);
+ s = client.Client;
+ Assert.IsNotNull (s, "#B:Client");
+ Assert.AreEqual (AddressFamily.InterNetworkV6, s.AddressFamily, "#B:Client:AddressFamily");
+ Assert.IsFalse (s.Connected, "#B:Client:Connected");
+#if NET_2_0
+ Assert.IsTrue (s.IsBound, "#B:Client:IsBound");
+#endif
+ Assert.AreEqual (ProtocolType.Udp, s.ProtocolType, "#B:Client:ProtocolType");
+ Assert.AreEqual (SocketType.Dgram, s.SocketType, "#B:Client:SocketType");
+ Assert.IsFalse (client.Active, "#B:Active");
+#if NET_2_0
+ //Assert.IsFalse (client.DontFragment, "#B:DontFragment");
+ Assert.IsFalse (client.EnableBroadcast, "#B:EnableBroadcast");
+ //Assert.IsFalse (client.ExclusiveAddressUse, "#B:ExclusiveAddressUse");
+ Assert.IsTrue (client.MulticastLoopback, "#B:MulticastLoopback");
+ //Assert.AreEqual (32, client.Ttl, "#B:Ttl");
+#endif
+ localEP = s.LocalEndPoint as IPEndPoint;
+ Assert.IsNotNull (localEP, "#B:Client:LocalEndpoint");
+ Assert.AreEqual (IPAddress.IPv6Any, localEP.Address, "#B:Client:LocalEndPoint/Address");
+ Assert.AreEqual (AddressFamily.InterNetworkV6, localEP.AddressFamily, "#B:Client:LocalEndPoint/AddressFamily");
+ Assert.AreEqual (IPEndPoint.MaxPort, localEP.Port, "#B:Client:LocalEndPoint/Port");
+ }
+
+ [Test] // .ctor (Int32, AddressFamily)
+ public void Constructor5_Family_Invalid ()
+ {
+ try {
+ new UdpClient (80, AddressFamily.NetBios);
+ Assert.Fail ("#A1");
+ } catch (ArgumentException ex) {
+ // family
+ Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
+ Assert.IsNull (ex.InnerException, "#A3");
+#if NET_2_0
+ // 'UDP' Client can only accept InterNetwork or InterNetworkV6
+ // addresses
+ Assert.IsNotNull (ex.Message, "#A4");
+ Assert.AreEqual ("family", ex.ParamName, "#A5");
+#else
+ Assert.AreEqual ("family", ex.Message, "#A4");
+ Assert.IsNull (ex.ParamName, "#A5");
+#endif
+ }
+
+ try {
+ new UdpClient (80, (AddressFamily) 666);
+ Assert.Fail ("#B1");
+ } catch (ArgumentException ex) {
+ // family
+ Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
+ Assert.IsNull (ex.InnerException, "#B3");
+#if NET_2_0
+ // 'UDP' Client can only accept InterNetwork or InterNetworkV6
+ // addresses
+ Assert.IsNotNull (ex.Message, "#B4");
+ Assert.AreEqual ("family", ex.ParamName, "#B5");
+#else
+ Assert.AreEqual ("family", ex.Message, "#B4");
+ Assert.IsNull (ex.ParamName, "#B5");
+#endif
+ }
+ }
+
+ [Test] // .ctor (Int32, AddressFamily)
+ public void Constructor5_Port_OutOfRange ()
+ {
+ try {
+ new UdpClient (IPEndPoint.MaxPort + 1, AddressFamily.InterNetwork);
+ 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 ("port", ex.ParamName, "#A5");
+ }
+
+ try {
+ new UdpClient (IPEndPoint.MinPort - 1, AddressFamily.InterNetwork);
+ 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 ("port", ex.ParamName, "#A5");
+ }
+ }
+
+ [Test] // .ctor (String, Int32)
+ public void Constructor6 ()
+ {
+ MyUdpClient client;
+ Socket s;
+ IPEndPoint localEP;
+
+ client = new MyUdpClient ("localhost", IPEndPoint.MinPort);
+ s = client.Client;
+ Assert.IsNotNull (s, "#A:Client");
+ Assert.AreEqual (AddressFamily.InterNetwork, s.AddressFamily, "#A:Client:AddressFamily");
+ Assert.IsTrue (s.Connected, "#A:Client:Connected");
+#if NET_2_0
+ Assert.IsTrue (s.IsBound, "#A:Client:IsBound");
+#endif
+ Assert.AreEqual (ProtocolType.Udp, s.ProtocolType, "#A:Client:ProtocolType");
+ Assert.AreEqual (SocketType.Dgram, s.SocketType, "#A:Client:SocketType");
+ Assert.IsTrue (client.Active, "#A:Active");
+#if NET_2_0
+ Assert.IsFalse (client.DontFragment, "#A:DontFragment");
+ Assert.IsFalse (client.EnableBroadcast, "#A:EnableBroadcast");
+ //Assert.IsFalse (client.ExclusiveAddressUse, "#A:ExclusiveAddressUse");
+ //Assert.IsFalse (client.MulticastLoopback, "#A:MulticastLoopback");
+ //Assert.AreEqual (32, client.Ttl, "#A:Ttl");
+#endif
+ localEP = s.LocalEndPoint as IPEndPoint;
+ Assert.IsNotNull (localEP, "#A:Client:LocalEndpoint");
+ Assert.AreEqual (IPAddress.Loopback, localEP.Address, "#A:Client:LocalEndPoint/Address");
+ Assert.AreEqual (AddressFamily.InterNetwork, localEP.AddressFamily, "#A:Client:LocalEndPoint/AddressFamily");
+
+ client = new MyUdpClient ("localhost", IPEndPoint.MaxPort);
+ s = client.Client;
+ Assert.IsNotNull (s, "#B:Client");
+ Assert.AreEqual (AddressFamily.InterNetwork, s.AddressFamily, "#B:Client:AddressFamily");
+ Assert.IsTrue (s.Connected, "#B:Client:Connected");
+#if NET_2_0
+ Assert.IsTrue (s.IsBound, "#B:Client:IsBound");
+#endif
+ Assert.AreEqual (ProtocolType.Udp, s.ProtocolType, "#B:Client:ProtocolType");
+ Assert.AreEqual (SocketType.Dgram, s.SocketType, "#B:Client:SocketType");
+ Assert.IsTrue (client.Active, "#B:Active");
+#if NET_2_0
+ Assert.IsFalse (client.DontFragment, "#B:DontFragment");
+ Assert.IsFalse (client.EnableBroadcast, "#B:EnableBroadcast");
+ //Assert.IsFalse (client.ExclusiveAddressUse, "#B:ExclusiveAddressUse");
+ //Assert.IsFalse (client.MulticastLoopback, "#B:MulticastLoopback");
+ //Assert.AreEqual (32, client.Ttl, "#B:Ttl");
+#endif
+ localEP = s.LocalEndPoint as IPEndPoint;
+ Assert.IsNotNull (localEP, "#B:Client:LocalEndpoint");
+ Assert.AreEqual (IPAddress.Loopback, localEP.Address, "#B:Client:LocalEndPoint/Address");
+ Assert.AreEqual (AddressFamily.InterNetwork, localEP.AddressFamily, "#B:Client:LocalEndPoint/AddressFamily");
+ }
+
+ [Test] // .ctor (String, Int32)
+ public void Constructor6_HostName_Null ()
+ {
+ try {
+ new UdpClient ((string) null, int.MaxValue);
+ 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 ("hostname", ex.ParamName, "#5");
+ }
+ }
+
+ [Test] // .ctor (String, Int32)
+ public void Constructor6_Port_OutOfRange ()
+ {
+ try {
+ new UdpClient ("local", IPEndPoint.MaxPort + 1);
+ 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 ("port", ex.ParamName, "#A5");
+ }
+
+ try {
+ new UdpClient ("local", IPEndPoint.MinPort - 1);
+ 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 ("port", ex.ParamName, "#A5");
+ }
+ }
+
[Test]
public void UdpClientBroadcastTest ()
{
- bool exThrown = false;
UdpClient client = new UdpClient (new IPEndPoint (IPAddress.Loopback, 1234));
byte[] bytes = new byte[] {10, 11, 12, 13};
try {
client.Send (bytes, bytes.Length, new IPEndPoint (IPAddress.Broadcast, 1235));
- } catch (SocketException) {
- exThrown = true;
+ } finally {
+ client.Close ();
}
- Assert.IsFalse(exThrown, "UdpClient Broadcast #1");
+ }
+ [Test] // JoinMulticastGroup (IPAddress)
+ public void JoinMulticastGroup1_IPv4 ()
+ {
+ IPAddress mcast_addr = IPAddress.Parse ("224.0.0.23");
+
+ using (UdpClient client = new UdpClient (new IPEndPoint (IPAddress.Any, 1234))) {
+ client.JoinMulticastGroup (mcast_addr);
+ }
+ }
+
+ [Test] // JoinMulticastGroup (IPAddress)
+ public void JoinMulticastGroup1_IPv6 ()
+ {
+#if NET_2_0
+ if (!Socket.OSSupportsIPv6)
+#else
+ if (!Socket.SupportsIPv6)
+#endif
+ Assert.Ignore ("IPv6 not enabled.");
+
+ IPAddress mcast_addr = IPAddress.Parse ("ff02::1");
+
+ using (UdpClient client = new UdpClient (new IPEndPoint (IPAddress.IPv6Any, 1234))) {
+ client.JoinMulticastGroup (mcast_addr);
+ }
+ }
+
+ [Test] // JoinMulticastGroup (IPAddress)
+ public void JoinMulticastGroup1_MulticastAddr_Null ()
+ {
+ using (UdpClient client = new UdpClient (new IPEndPoint (IPAddress.Loopback, 1234))) {
+ try {
+ client.JoinMulticastGroup ((IPAddress) null);
+ Assert.Fail ("#1");
+#if NET_2_0
+ } catch (ArgumentNullException ex) {
+ Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
+ Assert.IsNull (ex.InnerException, "#3");
+ Assert.IsNotNull (ex.Message, "#4");
+ Assert.AreEqual ("multicastAddr", ex.ParamName, "#5");
+ }
+#else
+ } catch (NullReferenceException ex) {
+ Assert.AreEqual (typeof (NullReferenceException), ex.GetType (), "#2");
+ Assert.IsNull (ex.InnerException, "#3");
+ Assert.IsNotNull (ex.Message, "#4");
+ }
+#endif
+ }
+ }
+
+ [Test] // JoinMulticastGroup (IPAddress)
+ public void JoinMulticastGroup1_Socket_Closed ()
+ {
+ IPAddress mcast_addr = null;
+
+ UdpClient client = new UdpClient (new IPEndPoint (IPAddress.Loopback, 1234));
client.Close ();
+ try {
+ client.JoinMulticastGroup (mcast_addr);
+ 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 (UdpClient).FullName, ex.ObjectName, "#5");
+ }
}
+ [Test] // JoinMulticastGroup (IPAddress)
+ [Category ("NotWorking")]
+ public void JoinMulticastGroup1_Socket_NotBound ()
+ {
+ IPAddress mcast_addr = IPAddress.Parse ("224.0.0.23");
+
+ UdpClient client = new UdpClient (AddressFamily.InterNetwork);
+ try {
+ client.JoinMulticastGroup (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");
#if NET_2_0
+ Assert.AreEqual (SocketError.InvalidArgument, ex.SocketErrorCode, "#7");
+#endif
+ } finally {
+ client.Close ();
+ }
+ }
+
+ [Test] // JoinMulticastGroup (In32, IPAddress)
+ public void JoinMulticastGroup2_IPv4 ()
+ {
+ IPAddress mcast_addr = IPAddress.Parse ("224.0.0.23");
+
+ using (UdpClient client = new UdpClient (new IPEndPoint (IPAddress.Any, 1234))) {
+ try {
+ client.JoinMulticastGroup (0, mcast_addr);
+ Assert.Fail ("#1");
+ } catch (SocketException ex) {
+ // The attempted operation is not supported for the type of
+ // object referenced
+ Assert.AreEqual (typeof (SocketException), ex.GetType (), "#2");
+ Assert.AreEqual (10045, ex.ErrorCode, "#3");
+ Assert.IsNull (ex.InnerException, "#4");
+ Assert.IsNotNull (ex.Message, "#5");
+ Assert.AreEqual (10045, ex.NativeErrorCode, "#6");
+#if NET_2_0
+ Assert.AreEqual (SocketError.OperationNotSupported, ex.SocketErrorCode, "#7");
+#endif
+ }
+ }
+ }
+
+ [Test] // JoinMulticastGroup (In32, IPAddress)
+ public void JoinMulticastGroup2_IPv6 ()
+ {
+#if NET_2_0
+ if (!Socket.OSSupportsIPv6)
+#else
+ if (!Socket.SupportsIPv6)
+#endif
+ Assert.Ignore ("IPv6 not enabled.");
+
+ IPAddress mcast_addr = IPAddress.Parse ("ff02::1");
+
+ using (UdpClient client = new UdpClient (new IPEndPoint (IPAddress.IPv6Any, 1234))) {
+ client.JoinMulticastGroup (0, mcast_addr);
+ }
+ }
+
+ [Test] // JoinMulticastGroup (Int32, IPAddress)
+ public void JoinMulticastGroup2_MulticastAddr_Null ()
+ {
+ using (UdpClient client = new UdpClient (new IPEndPoint (IPAddress.Loopback, 1234))) {
+ try {
+ client.JoinMulticastGroup (0, (IPAddress) 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 ("multicastAddr", ex.ParamName, "#5");
+ }
+ }
+ }
+
+ [Test] // JoinMulticastGroup (Int32, IPAddress)
+ public void JoinMulticastGroup2_Socket_Closed ()
+ {
+ IPAddress mcast_addr = null;
+
+ UdpClient client = new UdpClient (new IPEndPoint (IPAddress.IPv6Any, 1234));
+ client.Close ();
+ try {
+ client.JoinMulticastGroup (0, mcast_addr);
+ 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 (UdpClient).FullName, ex.ObjectName, "#5");
+ }
+ }
+
+ [Test] // JoinMulticastGroup (Int32, IPAddress)
+ [Category ("NotWorking")]
+ public void JoinMulticastGroup2_Socket_NotBound ()
+ {
+ IPAddress mcast_addr = IPAddress.Parse ("ff02::1");
+
+ UdpClient client = new UdpClient (AddressFamily.InterNetworkV6);
+ try {
+ client.JoinMulticastGroup (0, 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");
+#if NET_2_0
+ Assert.AreEqual (SocketError.InvalidArgument, ex.SocketErrorCode, "#7");
+#endif
+ } finally {
+ client.Close ();
+ }
+ }
+
+ [Test] // JoinMulticastGroup (IPAddress, Int32)
+ public void JoinMulticastGroup3_IPv4 ()
+ {
+ IPAddress mcast_addr = IPAddress.Parse ("224.0.0.23");
+
+ using (UdpClient client = new UdpClient (new IPEndPoint (IPAddress.Any, 1234))) {
+ client.JoinMulticastGroup (mcast_addr, 0);
+ }
+
+ using (UdpClient client = new UdpClient (new IPEndPoint (IPAddress.Any, 1234))) {
+ client.JoinMulticastGroup (mcast_addr, 255);
+ }
+ }
+
+ [Test] // JoinMulticastGroup (IPAddress, Int32)
+ public void JoinMulticastGroup3_IPv6 ()
+ {
+#if NET_2_0
+ if (!Socket.OSSupportsIPv6)
+#else
+ if (!Socket.SupportsIPv6)
+#endif
+ Assert.Ignore ("IPv6 not enabled.");
+
+ IPAddress mcast_addr = IPAddress.Parse ("ff02::1");
+
+ using (UdpClient client = new UdpClient (new IPEndPoint (IPAddress.IPv6Any, 1234))) {
+ client.JoinMulticastGroup (mcast_addr, 0);
+ }
+
+ using (UdpClient client = new UdpClient (new IPEndPoint (IPAddress.IPv6Any, 1234))) {
+ client.JoinMulticastGroup (mcast_addr, 255);
+ }
+ }
+
+ [Test] // JoinMulticastGroup (IPAddress, Int32)
+ public void JoinMulticastGroup3_MulticastAddr_Null ()
+ {
+ using (UdpClient client = new UdpClient (new IPEndPoint (IPAddress.Loopback, 1234))) {
+ try {
+ client.JoinMulticastGroup ((IPAddress) null, int.MaxValue);
+ 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 ("multicastAddr", ex.ParamName, "#5");
+ }
+ }
+ }
+
+ [Test] // JoinMulticastGroup (IPAddress, Int32)
+ public void JoinMulticastGroup3_Socket_Closed ()
+ {
+ IPAddress mcast_addr = null;
+
+ UdpClient client = new UdpClient (new IPEndPoint (IPAddress.Any, 1234));
+ client.Close ();
+ try {
+ client.JoinMulticastGroup (mcast_addr, 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 (UdpClient).FullName, ex.ObjectName, "#5");
+ }
+ }
+
+ [Test] // JoinMulticastGroup (IPAddress, Int32)
+ [Category ("NotWorking")]
+ public void JoinMulticastGroup3_Socket_NotBound ()
+ {
+ IPAddress mcast_addr = IPAddress.Parse ("224.0.0.23");
+
+ UdpClient client = new UdpClient (AddressFamily.InterNetwork);
+ try {
+ client.JoinMulticastGroup (mcast_addr, 5);
+ 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");
+#if NET_2_0
+ Assert.AreEqual (SocketError.InvalidArgument, ex.SocketErrorCode, "#7");
+#endif
+ } finally {
+ client.Close ();
+ }
+ }
+
+#if NET_2_0
+ [Test] // JoinMulticastGroup (IPAddress, IPAddress)
+ public void JoinMulticastGroup4_IPv4 ()
+ {
+ IPAddress mcast_addr = IPAddress.Parse ("224.0.0.23");
+ IPAddress local_addr = IPAddress.Any;
+
+ using (UdpClient client = new UdpClient (new IPEndPoint (IPAddress.Any, 1234))) {
+ client.JoinMulticastGroup (mcast_addr, local_addr);
+ }
+ }
+
+ [Test] // JoinMulticastGroup (IPAddress, IPAddress)
+ public void JoinMulticastGroup4_IPv6 ()
+ {
+ if (!Socket.OSSupportsIPv6)
+ Assert.Ignore ("IPv6 not enabled.");
+
+ IPAddress mcast_addr = IPAddress.Parse ("ff02::1");
+ IPAddress local_addr = IPAddress.IPv6Any;
+
+ using (UdpClient client = new UdpClient (new IPEndPoint (IPAddress.IPv6Any, 1234))) {
+ try {
+ client.JoinMulticastGroup (mcast_addr, local_addr);
+ Assert.Fail ("#1");
+ } catch (SocketException ex) {
+ // The attempted operation is not supported for the type of
+ // object referenced
+ Assert.AreEqual (typeof (SocketException), ex.GetType (), "#2");
+ Assert.AreEqual (10045, ex.ErrorCode, "#3");
+ Assert.IsNull (ex.InnerException, "#4");
+ Assert.IsNotNull (ex.Message, "#5");
+ Assert.AreEqual (10045, ex.NativeErrorCode, "#6");
+ Assert.AreEqual (SocketError.OperationNotSupported, ex.SocketErrorCode, "#7");
+ }
+ }
+ }
+
+ [Test] // JoinMulticastGroup (IPAddress, IPAddress)
+ public void JoinMulticastGroup4_LocalAddress_Null ()
+ {
+ IPAddress mcast_addr = IPAddress.Parse ("224.0.0.23");
+
+ using (UdpClient client = new UdpClient (new IPEndPoint (IPAddress.Loopback, 1234))) {
+ try {
+ client.JoinMulticastGroup (mcast_addr, (IPAddress) 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 ("mcint", ex.ParamName, "#5");
+ }
+ }
+ }
+
+ [Test] // JoinMulticastGroup (IPAddress, IPAddress)
+ public void JoinMulticastGroup4_MulticastAddr_Null ()
+ {
+ using (UdpClient client = new UdpClient (new IPEndPoint (IPAddress.Loopback, 1234))) {
+ try {
+ client.JoinMulticastGroup ((IPAddress) null, IPAddress.Loopback);
+ 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 ("group", ex.ParamName, "#5");
+ }
+ }
+ }
+
+ [Test] // JoinMulticastGroup (IPAddress, IPAddress)
+ public void JoinMulticastGroup4_Socket_Closed ()
+ {
+ IPAddress mcast_addr = null;
+ IPAddress local_addr = null;
+
+ UdpClient client = new UdpClient (new IPEndPoint (IPAddress.Any, 1234));
+ client.Close ();
+ try {
+ client.JoinMulticastGroup (mcast_addr, local_addr);
+ 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 (UdpClient).FullName, ex.ObjectName, "#5");
+ }
+ }
+
+ [Test] // JoinMulticastGroup (IPAddress, IPAddress)
+ [Category ("NotWorking")]
+ public void JoinMulticastGroup4_Socket_NotBound ()
+ {
+ IPAddress mcast_addr = IPAddress.Parse ("224.0.0.23");
+ IPAddress local_addr = Dns.GetHostEntry (string.Empty).AddressList [0];
+
+ UdpClient client = new UdpClient (AddressFamily.InterNetwork);
+ try {
+ client.JoinMulticastGroup (mcast_addr, local_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 {
+ client.Close ();
+ }
+ }
+
[Test]
public void CloseInReceive ()
{
Assert.IsTrue (got_exc);
}
- [Test]
- public void JoinMulticastGroup ()
- {
- UdpClient client = new UdpClient ();
- IPAddress mcast_addr = IPAddress.Parse ("224.0.0.23");
- IPAddress local_addr = Dns.GetHostEntry ("").AddressList[0];
- bool exThrown = false;
-
- /* So much for the documented note "You cannot
- * call JoinMulticastGroup on a UdpClient
- * constructed without a specific local port
- * (that is, using the UdpClient or
- * UdpClient(AddressFamily) constructor).
- */
- try {
- client.JoinMulticastGroup (mcast_addr,
- local_addr);
- } catch (Exception) {
- exThrown = true;
- } finally {
- client.Close ();
- }
-
- Assert.IsFalse (exThrown,
- "UdpClient JoinMulticastGroup #1");
- }
-
// Test for bug 324033
[Test]
public void JoinMulticastGroupWithLocal ()
UdpClient client = new UdpClient (9001);
IPAddress mcast_addr = IPAddress.Parse ("224.0.0.24");
IPAddress local_addr = IPAddress.Any;
-
- bool exThrown = false;
-
+
try {
- client.JoinMulticastGroup (mcast_addr,
- local_addr);
- } catch (Exception) {
- exThrown = true;
+ client.JoinMulticastGroup (mcast_addr, local_addr);
} finally {
client.Close ();
}
-
- Assert.IsFalse (exThrown, "UdpClient JoinMulticastGroupWithLocal #1");
}
[Test]
public void BeginSendNull ()
{
UdpClient client = new UdpClient ();
-
client.BeginSend (null, 0, null, null);
-
client.Close ();
}
"BeginSend #4");
}
- IPEndPoint ep = new IPEndPoint (Dns.GetHostEntry ("").AddressList[0], 1236);
+ IPEndPoint ep = new IPEndPoint (Dns.GetHostEntry (string.Empty).AddressList[0], 1236);
BSCalledBack.Reset ();
client.BeginReceive (BRCallback, client);
- IPEndPoint ep = new IPEndPoint (Dns.GetHostEntry ("").AddressList[0], 1237);
+ IPEndPoint ep = new IPEndPoint (Dns.GetHostEntry (string.Empty).AddressList[0], 1237);
byte[] send_bytes = new byte[] {10, 11, 12, 13};
client.Send (send_bytes, send_bytes.Length, ep);
public void Available ()
{
UdpClient client = new UdpClient (1238);
- IPEndPoint ep = new IPEndPoint (Dns.GetHostEntry ("").AddressList[0], 1238);
+ IPEndPoint ep = new IPEndPoint (Dns.GetHostEntry (string.Empty).AddressList[0], 1238);
byte[] bytes = new byte[] {10, 11, 12, 13};
client.Send (bytes, bytes.Length, ep);
/* No test for Ttl default as it is platform dependent */
#endif
+
+ class MyUdpClient : UdpClient
+ {
+ public MyUdpClient ()
+ {
+ }
+
+ public MyUdpClient (AddressFamily family)
+ : base (family)
+ {
+ }
+
+ public MyUdpClient (Int32 port)
+ : base (port)
+ {
+ }
+
+
+ public MyUdpClient (IPEndPoint localEP)
+ : base (localEP)
+ {
+ }
+
+ public MyUdpClient (int port, AddressFamily family)
+ : base (port, family)
+ {
+ }
+
+ public MyUdpClient (string hostname, int port)
+ : base (hostname, port)
+ {
+ }
+
+ public new bool Active {
+ get { return base.Active; }
+ set { base.Active = value; }
+ }
+
+#if ONLY_1_1
+ public new Socket Client {
+ get { return base.Client; }
+ set { base.Client = value; }
+ }
+#endif
+ }
}
}
projects / mono.git / commitdiff