* System_test.dll.sources: Added IPv6MulticastOptionTest.cs and

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

mcs/class/System/ChangeLog

@@ -1,3 +1,8 @@
+2009-06-28  Gert Driesen  <[email protected]>
+
+	* System_test.dll.sources: Added IPv6MulticastOptionTest.cs and
+	MulticastOptionTest.cs.
+
 2009-05-14  Jonathan Pryor <[email protected]>
 
 	* Makefile: Distribute Test/test-config-file-net-2.0.

mcs/class/System/System.Net.Sockets/ChangeLog

@@ -1,3 +1,24 @@
+2009-06-28  Gert Driesen  <[email protected]>
+
+	* 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 <[email protected]>
 
 	* Socket.cs: turn WSAEINVAL into ArgumentException.

mcs/class/System/System.Net.Sockets/IPv6MulticastOption.cs

@@ -47,28 +47,37 @@ namespace System.Net.Sockets
 		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

mcs/class/System/System.Net.Sockets/MulticastOption.cs

@@ -46,28 +46,33 @@ namespace System.Net.Sockets
 		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 {
@@ -77,13 +82,23 @@ namespace System.Net.Sockets
 
 		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
 	}

mcs/class/System/System.Net.Sockets/Socket.cs

@@ -2177,6 +2177,10 @@ namespace System.Net.Sockets
 			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,
@@ -3031,7 +3035,8 @@ namespace System.Net.Sockets
 
 			// 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;
 			
@@ -3051,32 +3056,47 @@ namespace System.Net.Sockets
 			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);

mcs/class/System/System.Net.Sockets/UdpClient.cs

@@ -53,7 +53,11 @@ namespace System.Net.Sockets
 		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);
@@ -84,23 +88,30 @@ namespace System.Net.Sockets
 #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)
@@ -245,6 +256,13 @@ namespace System.Net.Sockets
 		{
 			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));
@@ -261,24 +279,25 @@ namespace System.Net.Sockets
 		{
 			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);
@@ -295,16 +314,15 @@ namespace System.Net.Sockets
 		{
 			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 ();

mcs/class/System/System_test.dll.sources

@@ -224,6 +224,8 @@ System.Net/WebClientTest.cs
 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

mcs/class/System/Test/System.Net.Sockets/ChangeLog

@@ -1,3 +1,12 @@
+2009-06-28  Gert Driesen  <[email protected]>
+
+	* 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 <[email protected]>
 
 	* SocketTest.cs: tests for DontLinger.

mcs/class/System/Test/System.Net.Sockets/IPv6MulticastOptionTest.cs

@@ -0,0 +1,229 @@
+// System.Net.Sockets.IPv6MulticastOptionTest.cs
+//
+// Authors:
+//	Gert Driesen ([email protected])
+//
+// 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");
+		}
+	}
+}

mcs/class/System/Test/System.Net.Sockets/MulticastOptionTest.cs

@@ -0,0 +1,364 @@
+// System.Net.Sockets.MulticastOptionTest.cs
+//
+// Authors:
+//	Gert Driesen ([email protected])
+//
+// 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
+		}
+	}
+}

mcs/class/System/Test/System.Net.Sockets/SocketTest.cs

@@ -285,36 +285,6 @@ namespace MonoTests.System.Net.Sockets
 			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 ()
@@ -370,7 +340,6 @@ namespace MonoTests.System.Net.Sockets
 		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);
@@ -444,7 +413,6 @@ namespace MonoTests.System.Net.Sockets
 		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);
@@ -499,7 +467,6 @@ namespace MonoTests.System.Net.Sockets
 		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);
@@ -545,7 +512,7 @@ namespace MonoTests.System.Net.Sockets
 		}
 
 		[Test]
-		public void SocketError ()
+		public void SocketErrorTest ()
 		{
 			Socket sock = new Socket (AddressFamily.InterNetwork,
 						  SocketType.Stream,
@@ -2749,35 +2716,652 @@ namespace MonoTests.System.Net.Sockets
 			}
 		}
 #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");
 			}
 		}
 	}
 }
-