+ [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;
+
+ // Bug #5503
+ // UDP port 0 doesn't seem to be valid.
+ client = new MyUdpClient ("127.0.0.1", 53);
+ 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 ("127.0.0.1", 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");
+ }
+ }
+