+../../test-helpers/NetworkHelpers.cs
System.Net.Http/DelegatingHandlerTest.cs
System.Net.Http/ByteArrayContentTest.cs
System.Net.Http/FormUrlEncodedContentTest.cs
using System.Linq;
using System.IO;
+using MonoTests.Helpers;
+
namespace MonoTests.System.Net.Http
{
[TestFixture]
const int WaitTimeout = 5000;
- string TestHost, LocalServer;
- int port;
-
- [SetUp]
- public void SetupFixture ()
- {
- if (Environment.OSVersion.Platform == PlatformID.Win32NT) {
- port = 810;
- } else {
- port = 8810;
- }
-
- TestHost = "localhost:" + port;
- LocalServer = string.Format ("http://{0}/", TestHost);
- }
-
[Test]
public void Ctor_Default ()
{
public void Send_Complete_Default ()
{
bool? failed = null;
+ var port = NetworkHelpers.FindFreePort ();
var listener = CreateListener (l => {
try {
var request = l.Request;
Assert.IsNull (request.ContentType, "#3");
Assert.AreEqual (0, request.Cookies.Count, "#4");
Assert.IsFalse (request.HasEntityBody, "#5");
- Assert.AreEqual (TestHost, request.Headers["Host"], "#6b");
+ Assert.AreEqual ($"localhost:{port}", request.Headers["Host"], "#6b");
Assert.AreEqual ("GET", request.HttpMethod, "#7");
Assert.IsFalse (request.IsAuthenticated, "#8");
Assert.IsTrue (request.IsLocal, "#9");
} catch {
failed = true;
}
- });
+ }, port);
try {
var client = new HttpClient ();
- var request = new HttpRequestMessage (HttpMethod.Get, LocalServer);
+ var request = new HttpRequestMessage (HttpMethod.Get, $"http://localhost:{port}/");
var response = client.SendAsync (request, HttpCompletionOption.ResponseHeadersRead).Result;
Assert.AreEqual ("", response.Content.ReadAsStringAsync ().Result, "#100");
{
bool? failed = null;
+ var port = NetworkHelpers.FindFreePort ();
var listener = CreateListener (l => {
try {
var request = l.Request;
Assert.AreEqual (0, request.Cookies.Count, "#4");
Assert.IsFalse (request.HasEntityBody, "#5");
Assert.AreEqual (1, request.Headers.Count, "#6");
- Assert.AreEqual (TestHost, request.Headers["Host"], "#6a");
+ Assert.AreEqual ($"localhost:{port}", request.Headers["Host"], "#6a");
Assert.AreEqual ("GET", request.HttpMethod, "#7");
Assert.IsFalse (request.IsAuthenticated, "#8");
Assert.IsTrue (request.IsLocal, "#9");
} catch {
failed = true;
}
- });
+ }, port);
try {
var client = new HttpClient ();
- var request = new HttpRequestMessage (HttpMethod.Get, LocalServer);
+ var request = new HttpRequestMessage (HttpMethod.Get, $"http://localhost:{port}/");
request.Version = HttpVersion.Version10;
var response = client.SendAsync (request, HttpCompletionOption.ResponseHeadersRead).Result;
{
bool? failed = null;
+ var port = NetworkHelpers.FindFreePort ();
var listener = CreateListener (l => {
var request = l.Request;
Assert.AreEqual (new Cookie ("mycookie", "vv"), request.Cookies[0], "#4a");
Assert.IsFalse (request.HasEntityBody, "#5");
Assert.AreEqual (4, request.Headers.Count, "#6");
- Assert.AreEqual (TestHost, request.Headers["Host"], "#6a");
+ Assert.AreEqual ($"localhost:{port}", request.Headers["Host"], "#6a");
Assert.AreEqual ("gzip", request.Headers["Accept-Encoding"], "#6b");
Assert.AreEqual ("mycookie=vv", request.Headers["Cookie"], "#6c");
Assert.AreEqual ("GET", request.HttpMethod, "#7");
} catch {
failed = true;
}
- });
+ }, port);
try {
var chandler = new HttpClientHandler ();
chandler.MaxAutomaticRedirections = 33;
chandler.MaxRequestContentBufferSize = 5555;
chandler.PreAuthenticate = true;
- chandler.CookieContainer.Add (new Uri (LocalServer), new Cookie ( "mycookie", "vv"));
+ chandler.CookieContainer.Add (new Uri ($"http://localhost:{port}/"), new Cookie ( "mycookie", "vv"));
chandler.UseCookies = true;
chandler.UseDefaultCredentials = true;
chandler.Proxy = new WebProxy ("ee");
chandler.UseProxy = true;
var client = new HttpClient (chandler);
- var request = new HttpRequestMessage (HttpMethod.Get, LocalServer);
+ var request = new HttpRequestMessage (HttpMethod.Get, $"http://localhost:{port}/");
request.Version = HttpVersion.Version10;
request.Headers.Add ("Keep-Alive", "false");
var response = client.SendAsync (request, HttpCompletionOption.ResponseHeadersRead).Result;
{
bool? failed = null;
+ var port = NetworkHelpers.FindFreePort ();
var listener = CreateListener (l => {
var request = l.Request;
try {
} catch {
failed = true;
}
- });
+ }, port);
try {
var client = new HttpClient ();
- var request = new HttpRequestMessage (HttpMethod.Get, LocalServer);
+ var request = new HttpRequestMessage (HttpMethod.Get, $"http://localhost:{port}/");
Assert.IsTrue (request.Headers.TryAddWithoutValidation ("aa", "vv"), "#0");
var response = client.SendAsync (request, HttpCompletionOption.ResponseHeadersRead).Result;
{
bool? failed = null;
+ var port = NetworkHelpers.FindFreePort ();
var listener = CreateListener (l => {
var request = l.Request;
} catch {
failed = true;
}
- });
+ }, port);
try {
var client = new HttpClient ();
client.DefaultRequestHeaders.Add("User-Agent", "MLK Android Phone 1.1.9");
- var request = new HttpRequestMessage (HttpMethod.Get, LocalServer);
+ var request = new HttpRequestMessage (HttpMethod.Get, $"http://localhost:{port}/");
var response = client.SendAsync (request, HttpCompletionOption.ResponseHeadersRead).Result;
public void Send_Complete_CustomHeaders_Host ()
{
bool? failed = null;
+ var port = NetworkHelpers.FindFreePort ();
var listener = CreateListener (l => {
var request = l.Request;
} catch {
failed = true;
}
- });
+ }, port);
try {
var client = new HttpClient ();
client.DefaultRequestHeaders.Add("Host", "customhost");
- var request = new HttpRequestMessage (HttpMethod.Get, LocalServer);
+ var request = new HttpRequestMessage (HttpMethod.Get, $"http://localhost:{port}/");
var response = client.SendAsync (request, HttpCompletionOption.ResponseHeadersRead).Result;
{
bool? failed = null;
+ var port = NetworkHelpers.FindFreePort ();
var listener = CreateListener (l => {
var request = l.Request;
try {
- Assert.AreEqual (1, request.Headers.Count, "#1");
+ Assert.AreEqual (2, request.Headers.Count, "#1");
+ Assert.AreEqual ("keep-alive", request.Headers ["Connection"], "#2");
failed = false;
- } catch {
+ } catch (Exception ex){
+ Console.WriteLine (ex);
+ Console.WriteLine (String.Join ("#", l.Request.Headers.AllKeys));
failed = true;
}
- });
+ }, port);
try {
var client = new HttpClient ();
client.DefaultRequestHeaders.TransferEncodingChunked = true;
- client.GetAsync (LocalServer).Wait ();
+ client.GetAsync ($"http://localhost:{port}/").Wait ();
Assert.AreEqual (false, failed, "#102");
} finally {
{
bool? failed = null;
+ var port = NetworkHelpers.FindFreePort ();
var listener = CreateListener (l => {
failed = true;
- });
+ }, port);
try {
var client = new HttpClient ();
client.DefaultRequestHeaders.TransferEncoding.Add (new TransferCodingHeaderValue ("chunked2"));
- var request = new HttpRequestMessage (HttpMethod.Get, LocalServer);
+ var request = new HttpRequestMessage (HttpMethod.Get, $"http://localhost:{port}/");
try {
client.SendAsync (request, HttpCompletionOption.ResponseHeadersRead).Wait ();
#endif
public void Send_Complete_Content ()
{
+ var port = NetworkHelpers.FindFreePort ();
var listener = CreateListener (l => {
var request = l.Request;
l.Response.OutputStream.WriteByte (55);
l.Response.OutputStream.WriteByte (75);
- });
+ }, port);
try {
var client = new HttpClient ();
- var request = new HttpRequestMessage (HttpMethod.Get, LocalServer);
+ var request = new HttpRequestMessage (HttpMethod.Get, $"http://localhost:{port}/");
Assert.IsTrue (request.Headers.TryAddWithoutValidation ("aa", "vv"), "#0");
var response = client.SendAsync (request, HttpCompletionOption.ResponseHeadersRead).Result;
#endif
public void Send_Complete_Content_MaxResponseContentBufferSize ()
{
+ var port = NetworkHelpers.FindFreePort ();
var listener = CreateListener (l => {
var request = l.Request;
var b = new byte[4000];
l.Response.OutputStream.Write (b, 0, b.Length);
- });
+ }, port);
try {
var client = new HttpClient ();
client.MaxResponseContentBufferSize = 1000;
- var request = new HttpRequestMessage (HttpMethod.Get, LocalServer);
+ var request = new HttpRequestMessage (HttpMethod.Get, $"http://localhost:{port}/");
var response = client.SendAsync (request, HttpCompletionOption.ResponseHeadersRead).Result;
Assert.AreEqual (4000, response.Content.ReadAsStringAsync ().Result.Length, "#100");
#endif
public void Send_Complete_Content_MaxResponseContentBufferSize_Error ()
{
+ var port = NetworkHelpers.FindFreePort ();
var listener = CreateListener (l => {
var request = l.Request;
var b = new byte[4000];
l.Response.OutputStream.Write (b, 0, b.Length);
- });
+ }, port);
try {
var client = new HttpClient ();
client.MaxResponseContentBufferSize = 1000;
- var request = new HttpRequestMessage (HttpMethod.Get, LocalServer);
+ var request = new HttpRequestMessage (HttpMethod.Get, $"http://localhost:{port}/");
try {
client.SendAsync (request, HttpCompletionOption.ResponseContentRead).Wait (WaitTimeout);
#if FEATURE_NO_BSD_SOCKETS
[ExpectedException (typeof (PlatformNotSupportedException))]
#endif
- public void Send_Complete_NoContent ()
+ public void Send_Complete_NoContent_Post ()
+ {
+ Send_Complete_NoContent (HttpMethod.Post);
+ }
+
+ [Test]
+#if FEATURE_NO_BSD_SOCKETS
+ [ExpectedException (typeof (PlatformNotSupportedException))]
+#endif
+ public void Send_Complete_NoContent_Put ()
{
- foreach (var method in new HttpMethod[] { HttpMethod.Post, HttpMethod.Put, HttpMethod.Delete }) {
- bool? failed = null;
- var listener = CreateListener (l => {
- try {
- var request = l.Request;
-
- Assert.AreEqual (2, request.Headers.Count, "#1");
- Assert.AreEqual ("0", request.Headers ["Content-Length"], "#1b");
- Assert.AreEqual (method.Method, request.HttpMethod, "#2");
- failed = false;
- } catch {
- failed = true;
- }
- });
+ Send_Complete_NoContent (HttpMethod.Put);
+ }
+
+ [Test]
+#if FEATURE_NO_BSD_SOCKETS
+ [ExpectedException (typeof (PlatformNotSupportedException))]
+#endif
+ public void Send_Complete_NoContent_Delete ()
+ {
+ Send_Complete_NoContent (HttpMethod.Delete);
+ }
+ void Send_Complete_NoContent (HttpMethod method)
+ {
+ bool? failed = null;
+ var port = NetworkHelpers.FindFreePort ();
+ var listener = CreateListener (l => {
try {
- var client = new HttpClient ();
- var request = new HttpRequestMessage (method, LocalServer);
- var response = client.SendAsync (request, HttpCompletionOption.ResponseHeadersRead).Result;
+ var request = l.Request;
- Assert.AreEqual ("", response.Content.ReadAsStringAsync ().Result, "#100");
- Assert.AreEqual (HttpStatusCode.OK, response.StatusCode, "#101");
- Assert.AreEqual (false, failed, "#102");
- } finally {
- listener.Close ();
+ Assert.AreEqual (3, request.Headers.Count, "#1");
+ Assert.AreEqual ("0", request.Headers ["Content-Length"], "#1b");
+ Assert.AreEqual ("keep-alive", request.Headers ["Connection"], "#1c");
+ Assert.AreEqual (method.Method, request.HttpMethod, "#2");
+ failed = false;
+ } catch (Exception ex){
+ Console.WriteLine (ex);
+ Console.WriteLine (String.Join ("#", l.Request.Headers.AllKeys));
+
+ failed = true;
}
+ }, port);
+
+ try {
+ var client = new HttpClient ();
+ var request = new HttpRequestMessage (method, $"http://localhost:{port}/");
+ var response = client.SendAsync (request, HttpCompletionOption.ResponseHeadersRead).Result;
+
+ Assert.AreEqual ("", response.Content.ReadAsStringAsync ().Result, "#100");
+ Assert.AreEqual (HttpStatusCode.OK, response.StatusCode, "#101");
+ Assert.AreEqual (false, failed, "#102");
+ } finally {
+ listener.Close ();
}
}
#endif
public void Send_Complete_Error ()
{
+ var port = NetworkHelpers.FindFreePort ();
var listener = CreateListener (l => {
var response = l.Response;
response.StatusCode = 500;
- });
+ }, port);
try {
var client = new HttpClient ();
- var request = new HttpRequestMessage (HttpMethod.Get, LocalServer);
+ var request = new HttpRequestMessage (HttpMethod.Get, $"http://localhost:{port}/");
var response = client.SendAsync (request, HttpCompletionOption.ResponseHeadersRead).Result;
Assert.AreEqual ("", response.Content.ReadAsStringAsync ().Result, "#100");
#endif
public void Send_Content_Get ()
{
+ var port = NetworkHelpers.FindFreePort ();
var listener = CreateListener (l => {
var request = l.Request;
l.Response.OutputStream.WriteByte (72);
- });
+ }, port);
try {
var client = new HttpClient ();
- var r = new HttpRequestMessage (HttpMethod.Get, LocalServer);
+ var r = new HttpRequestMessage (HttpMethod.Get, $"http://localhost:{port}/");
var response = client.SendAsync (r).Result;
Assert.AreEqual ("H", response.Content.ReadAsStringAsync ().Result);
#endif
public void Send_Content_BomEncoding ()
{
+ var port = NetworkHelpers.FindFreePort ();
var listener = CreateListener (l => {
var request = l.Request;
str.WriteByte (0xBB);
str.WriteByte (0xBF);
str.WriteByte (71);
- });
+ }, port);
try {
var client = new HttpClient ();
- var r = new HttpRequestMessage (HttpMethod.Get, LocalServer);
+ var r = new HttpRequestMessage (HttpMethod.Get, $"http://localhost:{port}/");
var response = client.SendAsync (r).Result;
Assert.AreEqual ("G", response.Content.ReadAsStringAsync ().Result);
public void Send_Content_Put ()
{
bool passed = false;
+ var port = NetworkHelpers.FindFreePort ();
var listener = CreateListener (l => {
var request = l.Request;
passed = 7 == request.ContentLength64;
passed &= request.ContentType == "text/plain; charset=utf-8";
passed &= request.InputStream.ReadByte () == 'm';
- });
+ }, port);
try {
var client = new HttpClient ();
- var r = new HttpRequestMessage (HttpMethod.Put, LocalServer);
+ var r = new HttpRequestMessage (HttpMethod.Put, $"http://localhost:{port}/");
r.Content = new StringContent ("my text");
var response = client.SendAsync (r).Result;
public void Send_Content_Put_CustomStream ()
{
bool passed = false;
+ var port = NetworkHelpers.FindFreePort ();
var listener = CreateListener (l => {
var request = l.Request;
passed = 44 == request.ContentLength64;
passed &= request.ContentType == null;
- });
+ }, port);
try {
var client = new HttpClient ();
- var r = new HttpRequestMessage (HttpMethod.Put, LocalServer);
+ var r = new HttpRequestMessage (HttpMethod.Put, $"http://localhost:{port}/");
r.Content = new StreamContent (new CustomStream ());
var response = client.SendAsync (r).Result;
public void Post_TransferEncodingChunked ()
{
bool? failed = null;
+ var port = NetworkHelpers.FindFreePort ();
var listener = CreateListener (l => {
try {
var request = l.Request;
Assert.IsNull (request.ContentType, "#3");
Assert.AreEqual (0, request.Cookies.Count, "#4");
Assert.IsTrue (request.HasEntityBody, "#5");
- Assert.AreEqual (TestHost, request.Headers ["Host"], "#6b");
+ Assert.AreEqual ($"localhost:{port}", request.Headers ["Host"], "#6b");
Assert.AreEqual ("POST", request.HttpMethod, "#7");
Assert.IsFalse (request.IsAuthenticated, "#8");
Assert.IsTrue (request.IsLocal, "#9");
failed = true;
Console.WriteLine (e);
}
- });
+ }, port);
try {
var client = new HttpClient ();
var imageContent = new StreamContent (new MemoryStream ());
- var response = client.PostAsync (LocalServer, imageContent).Result;
+ var response = client.PostAsync ($"http://localhost:{port}/", imageContent).Result;
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode, "#101");
Assert.AreEqual(false, failed, "#102");
public void Post_StreamCaching ()
{
bool? failed = null;
+ var port = NetworkHelpers.FindFreePort ();
var listener = CreateListener (l => {
try {
var request = l.Request;
Assert.IsNull (request.ContentType, "#3");
Assert.AreEqual (0, request.Cookies.Count, "#4");
Assert.IsFalse (request.HasEntityBody, "#5");
- Assert.AreEqual (TestHost, request.Headers ["Host"], "#6b");
+ Assert.AreEqual ($"localhost:{port}", request.Headers ["Host"], "#6b");
Assert.AreEqual ("POST", request.HttpMethod, "#7");
Assert.IsFalse (request.IsAuthenticated, "#8");
Assert.IsTrue (request.IsLocal, "#9");
failed = true;
Console.WriteLine (e);
}
- });
+ }, port);
try {
var client = new HttpClient ();
var imageContent = new StreamContent (new MemoryStream ());
- var response = client.PostAsync (LocalServer, imageContent).Result;
+ var response = client.PostAsync ($"http://localhost:{port}/", imageContent).Result;
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode, "#101");
Assert.AreEqual(false, failed, "#102");
response.OutputStream.WriteByte (0x6f);
};
- var listener = CreateListener (context); // creates a default request handler
+ var port = NetworkHelpers.FindFreePort ();
+ var listener = CreateListener (context, port); // creates a default request handler
AddListenerContext (listener, context); // add another request handler for the second request
try {
var client = new HttpClient ();
- var t1 = client.GetStringAsync (LocalServer);
- var t2 = client.GetStringAsync (LocalServer);
+ var t1 = client.GetStringAsync ($"http://localhost:{port}/");
+ var t2 = client.GetStringAsync ($"http://localhost:{port}/");
Assert.IsTrue (Task.WaitAll (new [] { t1, t2 }, WaitTimeout));
Assert.AreEqual ("hello", t1.Result, "#1");
Assert.AreEqual ("hello", t2.Result, "#2");
#endif
public void GetByteArray_ServerError ()
{
+ var port = NetworkHelpers.FindFreePort ();
var listener = CreateListener (l => {
var response = l.Response;
response.StatusCode = 500;
l.Response.OutputStream.WriteByte (72);
- });
+ }, port);
try {
var client = new HttpClient ();
try {
- client.GetByteArrayAsync (LocalServer).Wait (WaitTimeout);
+ client.GetByteArrayAsync ($"http://localhost:{port}/").Wait (WaitTimeout);
Assert.Fail ("#1");
} catch (AggregateException e) {
Assert.IsTrue (e.InnerException is HttpRequestException , "#2");
#endif
public void DisallowAutoRedirect ()
{
+ var port = NetworkHelpers.FindFreePort ();
var listener = CreateListener (l => {
var request = l.Request;
var response = l.Response;
response.StatusCode = (int)HttpStatusCode.Moved;
response.RedirectLocation = "http://xamarin.com/";
- });
+ }, port);
try {
var chandler = new HttpClientHandler ();
var client = new HttpClient (chandler);
try {
- client.GetStringAsync (LocalServer).Wait (WaitTimeout);
+ client.GetStringAsync ($"http://localhost:{port}/").Wait (WaitTimeout);
Assert.Fail ("#1");
} catch (AggregateException e) {
Assert.IsTrue (e.InnerException is HttpRequestException, "#2");
#endif
public void RequestUriAfterRedirect ()
{
+ var port = NetworkHelpers.FindFreePort ();
+ var redirectPort = NetworkHelpers.FindFreePort ();
+
var listener = CreateListener (l => {
var request = l.Request;
var response = l.Response;
response.StatusCode = (int)HttpStatusCode.Moved;
- response.RedirectLocation = "http://localhost:8811/";
- });
+ response.RedirectLocation = $"http://localhost:{redirectPort}/";
+ }, port);
var listener2 = CreateListener (l => {
var response = l.Response;
response.OutputStream.WriteByte (0x6c);
response.OutputStream.WriteByte (0x6c);
response.OutputStream.WriteByte (0x6f);
- }, 8811);
+ }, redirectPort);
try {
var chandler = new HttpClientHandler ();
chandler.AllowAutoRedirect = true;
var client = new HttpClient (chandler);
- var r = client.GetAsync (LocalServer);
+ var r = client.GetAsync ($"http://localhost:{port}/");
Assert.IsTrue (r.Wait (WaitTimeout), "#1");
var resp = r.Result;
- Assert.AreEqual ("http://localhost:8811/", resp.RequestMessage.RequestUri.AbsoluteUri, "#2");
+ Assert.AreEqual ($"http://localhost:{redirectPort}/", resp.RequestMessage.RequestUri.AbsoluteUri, "#2");
Assert.AreEqual ("hello", resp.Content.ReadAsStringAsync ().Result, "#3");
} finally {
listener.Abort ();
chandler.AllowAutoRedirect = true;
var client = new HttpClient (chandler, true);
+ var port = NetworkHelpers.FindFreePort ();
var listener = CreateListener (l => {
var response = l.Response;
response.StatusCode = 200;
response.OutputStream.WriteByte (55);
- });
+ }, port);
try {
- client.GetStringAsync (LocalServer).Wait (WaitTimeout);
+ client.GetStringAsync ($"http://localhost:{port}/").Wait (WaitTimeout);
try {
chandler.AllowAutoRedirect = false;
Assert.Fail ("#1");
ch.AllowAutoRedirect = false;
}
- HttpListener CreateListener (Action<HttpListenerContext> contextAssert)
- {
- return CreateListener (contextAssert, port);
- }
-
HttpListener CreateListener (Action<HttpListenerContext> contextAssert, int port)
{
var l = new HttpListener ();
../../test-helpers/NunitHelpers.cs
+../../test-helpers/NetworkHelpers.cs
System.Runtime.Remoting.Channels.Tcp/TcpChannelTest.cs
ServerObject.cs
ContextsTest.cs
using System.Runtime.Remoting.Channels.Http;
using NUnit.Framework;
+using MonoTests.Helpers;
+
namespace MonoTests.Remoting
{
[TestFixture]
AppDomain domain = BaseCallTest.CreateDomain ("testdomain_activation");
server = (ActivationServer) domain.CreateInstanceAndUnwrap(GetType().Assembly.FullName,"MonoTests.Remoting.ActivationServer");
- RemotingConfiguration.RegisterActivatedClientType (typeof(CaObject1), "tcp://localhost:9433");
- RemotingConfiguration.RegisterActivatedClientType (typeof(CaObject2), "http://localhost:9434");
- RemotingConfiguration.RegisterWellKnownClientType (typeof(WkObjectSinglecall1), "tcp://localhost:9433/wkoSingleCall1");
- RemotingConfiguration.RegisterWellKnownClientType (typeof(WkObjectSingleton1), "tcp://localhost:9433/wkoSingleton1");
- RemotingConfiguration.RegisterWellKnownClientType (typeof(WkObjectSinglecall2), "http://localhost:9434/wkoSingleCall2");
- RemotingConfiguration.RegisterWellKnownClientType (typeof(WkObjectSingleton2), "http://localhost:9434/wkoSingleton2");
+ var tcpUrlPrefix = $"tcp://localhost:{server.TcpPort}";
+ var httpUrlPrefix = $"http://localhost:{server.HttpPort}";
+ RemotingConfiguration.RegisterActivatedClientType (typeof(CaObject1), tcpUrlPrefix);
+ RemotingConfiguration.RegisterActivatedClientType (typeof(CaObject2), httpUrlPrefix);
+ RemotingConfiguration.RegisterWellKnownClientType (typeof(WkObjectSinglecall1), tcpUrlPrefix + "/wkoSingleCall1");
+ RemotingConfiguration.RegisterWellKnownClientType (typeof(WkObjectSingleton1), tcpUrlPrefix + "/wkoSingleton1");
+ RemotingConfiguration.RegisterWellKnownClientType (typeof(WkObjectSinglecall2), httpUrlPrefix + "/wkoSingleCall2");
+ RemotingConfiguration.RegisterWellKnownClientType (typeof(WkObjectSingleton2), httpUrlPrefix + "/wkoSingleton2");
}
catch (Exception ex)
{
public ActivationServer ()
{
- tcp = new TcpChannel (9433);
- http = new HttpChannel (9434);
+ TcpPort = NetworkHelpers.FindFreePort ();
+ HttpPort = NetworkHelpers.FindFreePort ();
+ tcp = new TcpChannel (TcpPort);
+ http = new HttpChannel (HttpPort);
ChannelServices.RegisterChannel (tcp);
ChannelServices.RegisterChannel (http);
ChannelServices.UnregisterChannel (tcp);
ChannelServices.UnregisterChannel (http);
}
+
+ public int TcpPort { get; private set; }
+ public int HttpPort { get; private set; }
}
public class BaseObject: MarshalByRefObject
using System.Threading;
using NUnit.Framework;
+using MonoTests.Helpers;
+
namespace MonoTests.Remoting
{
public interface INested
[Test]
public void TestTcpChannel ()
{
+ var port = NetworkHelpers.FindFreePort ();
IDictionary props = new Hashtable ();
props ["name"] = Guid.NewGuid ().ToString("N");
- props ["port"] = 18191;
+ props ["port"] = port;
TcpChannel chan = new TcpChannel (props, null, null);
ChannelServices.RegisterChannel (chan);
try {
Register <Server<object>> ("gentcptest.rem");
- RunTests (Connect <Server<object>> ("tcp://localhost:18191/gentcptest.rem"));
+ RunTests (Connect <Server<object>> ($"tcp://localhost:{port}/gentcptest.rem"));
} finally {
ChannelServices.UnregisterChannel (chan);
}
using System.Runtime.Remoting.Channels.Http;
using NUnit.Framework;
+using MonoTests.Helpers;
+
namespace MonoTests.Remoting.Http
{
//Test for Bug 324362 - SoapFormatter cannot deserialize the same MBR twice
[Test]
public void Main ()
{
- channel = new HttpChannel (3344);
+ var port = NetworkHelpers.FindFreePort ();
+ channel = new HttpChannel (port);
ChannelServices.RegisterChannel (channel);
RemotingConfiguration.RegisterWellKnownServiceType
(typeof (Bug321420),"Server.soap", WellKnownObjectMode.Singleton);
Bug321420 s = (Bug321420) Activator.GetObject (typeof
- (Bug321420), "http://localhost:3344/Server.soap");
+ (Bug321420), $"http://localhost:{port}/Server.soap");
// this works: s.Method ("a", "b");
s.Method ("a", "a");
public void Main ()
{
Foo foo = (Foo) Activator.GetObject (typeof (Foo),
- "http://localhost:4321/Test");
+ $"http://localhost:{server.HttpPort}/Test");
Bar bar = foo.Login ();
if (bar != null)
public void Start ()
{
- c = new HttpChannel (4321);
+ HttpPort = NetworkHelpers.FindFreePort ();
+ c = new HttpChannel (HttpPort);
ChannelServices.RegisterChannel (c);
Type t = typeof(Foo);
c.StopListening (null);
ChannelServices.UnregisterChannel (c);
}
+
+ public int HttpPort { get; private set; }
}
}
ChannelServices.RegisterChannel (channel);
MarshalByRefObject obj = (MarshalByRefObject) RemotingServices.Connect (
typeof (IFactorial),
- "http://localhost:60000/MyEndPoint");
+ $"http://localhost:{server.HttpPort}/MyEndPoint");
IFactorial cal = (IFactorial) obj;
Assert.AreEqual (cal.CalculateFactorial (4), 24);
}
public void Start ()
{
- c = new HttpChannel (60000);
+ HttpPort = NetworkHelpers.FindFreePort ();
+ c = new HttpChannel (HttpPort);
ChannelServices.RegisterChannel (c);
Type t = typeof(Calculator);
c.StopListening (null);
ChannelServices.UnregisterChannel (c);
}
+
+ public int HttpPort { get; private set; }
}
public class Calculator : MarshalByRefObject, IFactorial
using System.Runtime.Remoting.Channels;\r
using System.Runtime.Remoting.Channels.Tcp;\r
\r
+using MonoTests.Helpers;\r
+\r
namespace MonoTests.System.Runtime.Remoting.RemotingServicesInternal\r
{\r
// We need our own proxy to intercept messages to remote object\r
[Test]\r
public void Connect ()\r
{\r
+ var port = NetworkHelpers.FindFreePort ();\r
MarshalObject objMarshal = NewMarshalObject ();\r
\r
IDictionary props = new Hashtable ();\r
props ["name"] = objMarshal.Uri;\r
- props ["port"] = 1236;\r
+ props ["port"] = port;\r
TcpChannel chn = new TcpChannel (props, null, null);\r
ChannelServices.RegisterChannel (chn);\r
\r
try {\r
RemotingServices.Marshal (objMarshal, objMarshal.Uri);\r
- MarshalObject objRem = (MarshalObject) RemotingServices.Connect (typeof (MarshalObject), "tcp://localhost:1236/" + objMarshal.Uri);\r
+ MarshalObject objRem = (MarshalObject) RemotingServices.Connect (typeof (MarshalObject), $"tcp://localhost:{port}/" + objMarshal.Uri);\r
Assert.IsTrue (RemotingServices.IsTransparentProxy (objRem), "#A08");\r
} finally {\r
ChannelServices.UnregisterChannel (chn);\r
[Test]\r
public void MarshalThrowException ()\r
{\r
+ var port = NetworkHelpers.FindFreePort ();\r
MarshalObject objMarshal = NewMarshalObject ();\r
\r
IDictionary props = new Hashtable ();\r
props ["name"] = objMarshal.Uri;\r
- props ["port"] = 1237;\r
+ props ["port"] = port;\r
TcpChannel chn = new TcpChannel (props, null, null);\r
ChannelServices.RegisterChannel (chn);\r
\r
try {\r
RemotingServices.Marshal (objMarshal, objMarshal.Uri);\r
- MarshalObject objRem = (MarshalObject) RemotingServices.Connect (typeof (MarshalObject), "tcp://localhost:1237/" + objMarshal.Uri);\r
+ MarshalObject objRem = (MarshalObject) RemotingServices.Connect (typeof (MarshalObject), $"tcp://localhost:{port}/" + objMarshal.Uri);\r
// This line should throw a RemotingException\r
// It is forbidden to export an object which is not\r
// a real object\r
[Test]\r
public void ExecuteMessage ()\r
{\r
- TcpChannel chn = new TcpChannel (1235);\r
+ var port = NetworkHelpers.FindFreePort ();\r
+ TcpChannel chn = new TcpChannel (port);\r
ChannelServices.RegisterChannel (chn);\r
try {\r
MarshalObject objMarshal = NewMarshalObject ();\r
RemotingConfiguration.RegisterWellKnownServiceType (typeof (MarshalObject), objMarshal.Uri, WellKnownObjectMode.SingleCall);\r
\r
// use a proxy to catch the Message\r
- MyProxy proxy = new MyProxy (typeof (MarshalObject), (MarshalObject) Activator.GetObject (typeof (MarshalObject), "tcp://localhost:1235/" + objMarshal.Uri));\r
+ MyProxy proxy = new MyProxy (typeof (MarshalObject), (MarshalObject) Activator.GetObject (typeof (MarshalObject), $"tcp://localhost:{port}/" + objMarshal.Uri));\r
\r
MarshalObject objRem = (MarshalObject) proxy.GetTransparentProxy ();\r
\r
[Test]\r
public void IsOneWay ()\r
{\r
- TcpChannel chn = new TcpChannel (1238);\r
+ var port = NetworkHelpers.FindFreePort ();\r
+ TcpChannel chn = new TcpChannel (port);\r
ChannelServices.RegisterChannel (chn);\r
try {\r
RemotingConfiguration.RegisterWellKnownServiceType (typeof (MarshalObject), "MarshalObject.rem", WellKnownObjectMode.Singleton);\r
\r
- MarshalObject objRem = (MarshalObject) Activator.GetObject (typeof (MarshalObject), "tcp://localhost:1238/MarshalObject.rem");\r
+ MarshalObject objRem = (MarshalObject) Activator.GetObject (typeof (MarshalObject), $"tcp://localhost:{port}/MarshalObject.rem");\r
\r
Assert.IsTrue (RemotingServices.IsTransparentProxy (objRem), "#A10.1");\r
\r
[Test]\r
public void GetObjRefForProxy ()\r
{\r
- TcpChannel chn = new TcpChannel (1239);\r
+ var port = NetworkHelpers.FindFreePort ();\r
+ TcpChannel chn = new TcpChannel (port);\r
ChannelServices.RegisterChannel (chn);\r
try {\r
// Register le factory as a SAO\r
RemotingConfiguration.RegisterWellKnownServiceType (typeof (MarshalObjectFactory), "MonoTests.System.Runtime.Remoting.RemotingServicesTest.Factory.soap", WellKnownObjectMode.Singleton);\r
\r
- MarshalObjectFactory objFactory = (MarshalObjectFactory) Activator.GetObject (typeof (MarshalObjectFactory), "tcp://localhost:1239/MonoTests.System.Runtime.Remoting.RemotingServicesTest.Factory.soap");\r
+ MarshalObjectFactory objFactory = (MarshalObjectFactory) Activator.GetObject (typeof (MarshalObjectFactory), $"tcp://localhost:{port}/MonoTests.System.Runtime.Remoting.RemotingServicesTest.Factory.soap");\r
\r
// Get a new "CAO"\r
MarshalObject objRem = objFactory.GetNewMarshalObject ();\r
[Test]\r
public void GetRealProxy ()\r
{\r
- TcpChannel chn = new TcpChannel (1241);\r
+ var port = NetworkHelpers.FindFreePort ();\r
+ TcpChannel chn = new TcpChannel (port);\r
ChannelServices.RegisterChannel (chn);\r
try {\r
RemotingConfiguration.RegisterWellKnownServiceType (typeof (MarshalObject), "MonoTests.System.Runtime.Remoting.RemotingServicesTest.MarshalObject.soap", WellKnownObjectMode.Singleton);\r
\r
- MyProxy proxy = new MyProxy (typeof (MarshalObject), (MarshalByRefObject) Activator.GetObject (typeof (MarshalObject), "tcp://localhost:1241/MonoTests.System.Runtime.Remoting.RemotingServicesTest.MarshalObject.soap"));\r
+ MyProxy proxy = new MyProxy (typeof (MarshalObject), (MarshalByRefObject) Activator.GetObject (typeof (MarshalObject), $"tcp://localhost:{port}/MonoTests.System.Runtime.Remoting.RemotingServicesTest.MarshalObject.soap"));\r
MarshalObject objRem = (MarshalObject) proxy.GetTransparentProxy ();\r
\r
RealProxy rp = RemotingServices.GetRealProxy (objRem);\r
[Test]\r
public void SetObjectUriForMarshal ()\r
{\r
- TcpChannel chn = new TcpChannel (1242);\r
+ var port = NetworkHelpers.FindFreePort ();\r
+ TcpChannel chn = new TcpChannel (port);\r
ChannelServices.RegisterChannel (chn);\r
try {\r
MarshalObject objRem = NewMarshalObject ();\r
RemotingServices.SetObjectUriForMarshal (objRem, objRem.Uri);\r
RemotingServices.Marshal (objRem);\r
\r
- objRem = (MarshalObject) Activator.GetObject (typeof (MarshalObject), "tcp://localhost:1242/" + objRem.Uri);\r
+ objRem = (MarshalObject) Activator.GetObject (typeof (MarshalObject), $"tcp://localhost:{port}/" + objRem.Uri);\r
Assert.IsNotNull (objRem, "#A14");\r
} finally {\r
ChannelServices.UnregisterChannel (chn);\r
[Test]\r
public void GetServeurTypeForUri ()\r
{\r
- TcpChannel chn = new TcpChannel (1243);\r
+ var port = NetworkHelpers.FindFreePort ();\r
+ TcpChannel chn = new TcpChannel (port);\r
Type type = typeof (MarshalObject);\r
ChannelServices.RegisterChannel (chn);\r
try {\r
[Category ("NotWorking")]\r
public void IsObjectOutOf ()\r
{\r
- TcpChannel chn = new TcpChannel (1245);\r
+ var port = NetworkHelpers.FindFreePort ();\r
+ TcpChannel chn = new TcpChannel (port);\r
ChannelServices.RegisterChannel (chn);\r
try {\r
RemotingConfiguration.RegisterWellKnownServiceType (typeof (MarshalObject), "MarshalObject2.rem", WellKnownObjectMode.Singleton);\r
\r
- MarshalObject objRem = (MarshalObject) Activator.GetObject (typeof (MarshalObject), "tcp://localhost:1245/MarshalObject2.rem");\r
+ MarshalObject objRem = (MarshalObject) Activator.GetObject (typeof (MarshalObject), $"tcp://localhost:{port}/MarshalObject2.rem");\r
\r
Assert.IsTrue (RemotingServices.IsObjectOutOfAppDomain (objRem), "#A16");\r
Assert.IsTrue (RemotingServices.IsObjectOutOfContext (objRem), "#A17");\r
[Test]\r
public void ApplicationNameTest ()\r
{\r
+ var port = NetworkHelpers.FindFreePort ();\r
RemotingConfiguration.ApplicationName = "app";\r
- TcpChannel chn = new TcpChannel (1246);\r
+ TcpChannel chn = new TcpChannel (port);\r
ChannelServices.RegisterChannel (chn);\r
try {\r
RemotingConfiguration.RegisterWellKnownServiceType (typeof (MarshalObject), "obj3.rem", WellKnownObjectMode.Singleton);\r
\r
- MarshalObject objRem = (MarshalObject) Activator.GetObject (typeof (MarshalObject), "tcp://localhost:1246/app/obj3.rem");\r
- MarshalObject objRem2 = (MarshalObject) Activator.GetObject (typeof (MarshalObject), "tcp://localhost:1246/obj3.rem");\r
+ MarshalObject objRem = (MarshalObject) Activator.GetObject (typeof (MarshalObject), $"tcp://localhost:{port}/app/obj3.rem");\r
+ MarshalObject objRem2 = (MarshalObject) Activator.GetObject (typeof (MarshalObject), $"tcp://localhost:{port}/obj3.rem");\r
\r
Assert.IsTrue (RemotingServices.IsTransparentProxy (objRem), "#AN1");\r
Assert.IsTrue (RemotingServices.IsTransparentProxy (objRem2), "#AN2");\r
[Test]\r
public void GetObjectWithChannelDataTest ()\r
{\r
- TcpChannel chn = new TcpChannel (1247);\r
+ var port = NetworkHelpers.FindFreePort ();\r
+ TcpChannel chn = new TcpChannel (port);\r
ChannelServices.RegisterChannel (chn);\r
try {\r
RemotingConfiguration.RegisterWellKnownServiceType (typeof (MarshalObject), "getobjectwithchanneldata.rem", WellKnownObjectMode.Singleton);\r
\r
string channelData = "test";\r
- Assert.IsNotNull (Activator.GetObject (typeof (MarshalObject), "tcp://localhost:1247/getobjectwithchanneldata.rem", channelData), "#01");\r
+ Assert.IsNotNull (Activator.GetObject (typeof (MarshalObject), $"tcp://localhost:{port}/getobjectwithchanneldata.rem", channelData), "#01");\r
} finally {\r
ChannelServices.UnregisterChannel (chn);\r
}\r
[Ignore ("We cannot test RemotingConfiguration.Configure() because it keeps channels registered. If we really need to test it, do it as a standalone case")]\r
public void ConnectProxyCast ()\r
{\r
+ var port = NetworkHelpers.FindFreePort ();\r
object o;\r
RemotingConfiguration.Configure (null);\r
\r
- o = RemotingServices.Connect (typeof (MarshalByRefObject), "tcp://localhost:3434/ff1.rem");\r
+ o = RemotingServices.Connect (typeof (MarshalByRefObject), $"tcp://localhost:{port}/ff1.rem");\r
Assert.IsInstanceOfType (typeof (DD), o, "#m1");\r
Assert.IsInstanceOfType (typeof (A), o, "#m2");\r
Assert.IsInstanceOfType (typeof (B), o, "#m3");\r
AssertHelper.IsNotInstanceOfType (typeof (CC), !(o is CC), "#m4");\r
\r
- o = RemotingServices.Connect (typeof (A), "tcp://localhost:3434/ff3.rem");\r
+ o = RemotingServices.Connect (typeof (A), $"tcp://localhost:{port}/ff3.rem");\r
Assert.IsInstanceOfType (typeof (DD), o, "#a1");\r
Assert.IsInstanceOfType (typeof (A), o, "#a2");\r
Assert.IsInstanceOfType (typeof (B), o, "#a3");\r
AssertHelper.IsNotInstanceOfType (typeof (CC), o, "#a4");\r
\r
- o = RemotingServices.Connect (typeof (DD), "tcp://localhost:3434/ff4.rem");\r
+ o = RemotingServices.Connect (typeof (DD), $"tcp://localhost:{port}/ff4.rem");\r
Assert.IsInstanceOfType (typeof (DD), o, "#d1");\r
Assert.IsInstanceOfType (typeof (A), o, "#d2");\r
Assert.IsInstanceOfType (typeof (B), o, "#d3");\r
AssertHelper.IsNotInstanceOfType (typeof (CC), o, "#d4");\r
\r
- o = RemotingServices.Connect (typeof (CC), "tcp://localhost:3434/ff5.rem");\r
+ o = RemotingServices.Connect (typeof (CC), $"tcp://localhost:{port}/ff5.rem");\r
AssertHelper.IsNotInstanceOfType (typeof (DD), o, "#c1");\r
Assert.IsInstanceOfType (typeof (A), o, "#c2");\r
Assert.IsInstanceOfType (typeof (B), o, "#c3");\r
using NUnit.Framework;
+using MonoTests.Helpers;
+
namespace MonoTests.Remoting
{
[TestFixture]
MarshalObject marshal = new MarshalObject ();
+ var port = NetworkHelpers.FindFreePort ();
IDictionary props = new Hashtable ();
props ["name"] = "marshal channel";
- props ["port"] = 1236;
+ props ["port"] = port;
props ["bindTo"] = IPAddress.Loopback.ToString ();
chn = new TcpChannel (props, null, null);
urls = chn.GetUrlsForUri (SERVICE_URI);
Assert.IsNotNull (urls, "#A2");
Assert.AreEqual (1, urls.Length, "#A3");
- Assert.AreEqual ("tcp://" + IPAddress.Loopback.ToString () + ":1236/" + SERVICE_URI, urls [0], "#A6");
+ Assert.AreEqual ($"tcp://{IPAddress.Loopback.ToString ()}:{port}/{SERVICE_URI}", urls [0], "#A6");
ds = chn.ChannelData as ChannelDataStore;
Assert.IsNotNull (ds, "#A4");
Assert.AreEqual (1, ds.ChannelUris.Length, "#A5");
- Assert.AreEqual ("tcp://" + IPAddress.Loopback.ToString () + ":1236", ds.ChannelUris [0], "#A6");
+ Assert.AreEqual ($"tcp://{IPAddress.Loopback.ToString ()}:{port}", ds.ChannelUris [0], "#A6");
ChannelServices.UnregisterChannel (chn);
using System.ServiceModel.Web;
using NUnit.Framework;
+using MonoTests.Helpers;
+
namespace MonoTests.System.ServiceModel.Activation
{
class MyHostFactory : WebScriptServiceHostFactory
[Test]
public void CreateServiceHost ()
{
+ var port = NetworkHelpers.FindFreePort ();
var f = new MyHostFactory ();
- var host = f.DoCreateServiceHost (typeof (TestService), new Uri [] {new Uri ("http://localhost:37564")});
+ var host = f.DoCreateServiceHost (typeof (TestService), new Uri [] {new Uri ($"http://localhost:{port}")});
Assert.IsFalse (host is WebServiceHost, "#1");
host.Open ();
host.Close ();
[ExpectedException (typeof (NotSupportedException))]
public void ResponseWrappedIsInvalid ()
{
+ var port = NetworkHelpers.FindFreePort ();
var f = new MyHostFactory ();
- var host = f.DoCreateServiceHost (typeof (TestService2), new Uri [] {new Uri ("http://localhost:37564")});
+ var host = f.DoCreateServiceHost (typeof (TestService2), new Uri [] {new Uri ($"http://localhost:{port}")});
host.Open (); // should raise an error here.
}
[ExpectedException (typeof (InvalidOperationException))]
public void MultipleContract ()
{
+ var port = NetworkHelpers.FindFreePort ();
var f = new MyHostFactory ();
- var host = f.DoCreateServiceHost (typeof (TestServiceMultiple), new Uri [] {new Uri ("http://localhost:37564")});
+ var host = f.DoCreateServiceHost (typeof (TestServiceMultiple), new Uri [] {new Uri ($"http://localhost:{port}")});
host.Open ();
}
public class CustomPeerResolverService : IPeerResolverContract
{
static ServiceHost localhost;
+ static int port;
static void SetupCustomPeerResolverServiceHost ()
{
+ string customPort = Environment.GetEnvironmentVariable ("MONO_CUSTOMPEERRESOLVERSERVICE_PORT");
+ if (customPort == null || !int.TryParse (customPort, out port))
+ port = 8931;
+
// launch peer resolver service locally only when it does not seem to be running ...
- var t = new TcpListener (8931);
+ var t = new TcpListener (port);
try {
t.Start ();
t.Stop ();
Console.WriteLine ("WARNING: it is running peer resolver service locally. This means, the node registration is valid only within this application domain...");
var host = new ServiceHost (new LocalPeerResolverService (TextWriter.Null));
host.Description.Behaviors.Find<ServiceBehaviorAttribute> ().InstanceContextMode = InstanceContextMode.Single;
- host.AddServiceEndpoint (typeof (ICustomPeerResolverContract), new BasicHttpBinding (), "http://localhost:8931");
+ host.AddServiceEndpoint (typeof (ICustomPeerResolverContract), new BasicHttpBinding (), $"http://localhost:{port}");
localhost = host;
host.Open ();
}
public CustomPeerResolverService ()
{
- client = ChannelFactory<ICustomPeerResolverClient>.CreateChannel (new BasicHttpBinding (), new EndpointAddress ("http://localhost:8931"));
+ client = ChannelFactory<ICustomPeerResolverClient>.CreateChannel (new BasicHttpBinding (), new EndpointAddress ($"http://localhost:{port}"));
refresh_interval = new TimeSpan (0, 10, 0);
cleanup_interval = new TimeSpan (0, 1, 0);
using System.ServiceModel.Dispatcher;
using System.Collections.ObjectModel;
+using MonoTests.Helpers;
+
namespace MonoTests.Features
{
public class Configuration
{
static Configuration() {
+ var port = NetworkHelpers.FindFreePort ();
onlyServers = Boolean.Parse (ConfigurationManager.AppSettings ["onlyServers"] ?? "false");
onlyClients = Boolean.Parse (ConfigurationManager.AppSettings ["onlyClients"] ?? "false");
- endpointBase = ConfigurationManager.AppSettings ["endpointBase"] ?? "http://localhost:9999/";
+ endpointBase = ConfigurationManager.AppSettings ["endpointBase"] ?? $"http://localhost:{port}/";
if (!endpointBase.EndsWith ("/"))
endpointBase = endpointBase + '/';
logMessages = Boolean.Parse (ConfigurationManager.AppSettings ["logMessages"] ?? "false");
using NUnit.Framework;
+using MonoTests.Helpers;
+
namespace MonoTests.System.ServiceModel.PeerResolvers
{
[TestFixture]
[SetUp]
protected void SetUp ()
{
+ var port = NetworkHelpers.FindFreePort ();
+ Environment.SetEnvironmentVariable ("MONO_CUSTOMPEERRESOLVERSERVICE_PORT", port.ToString ());
cprs = new CustomPeerResolverService ();
}
[TestFixture]
public class SocketTest
{
- // note: also used in SocketCas tests
public const string BogusAddress = "192.168.244.244";
- public const int BogusPort = 23483;
[Test]
#if FEATURE_NO_BSD_SOCKETS
public void BogusEndConnect ()
{
IPAddress ipOne = IPAddress.Parse (BogusAddress);
- IPEndPoint ipEP = new IPEndPoint (ipOne, BogusPort);
+ IPEndPoint ipEP = new IPEndPoint (ipOne, NetworkHelpers.FindFreePort ());
Socket sock = new Socket (ipEP.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
IAsyncResult ar = sock.BeginConnect (ipEP, null, null);
Socket sock = new Socket (AddressFamily.InterNetwork,
SocketType.Stream,
ProtocolType.Tcp);
- IPEndPoint ep = new IPEndPoint (IPAddress.Loopback,
- BogusPort);
+ IPEndPoint ep = NetworkHelpers.LocalEphemeralEndPoint ();
SocketError_event.Reset ();
Socket sock = new Socket (AddressFamily.InterNetwork,
SocketType.Stream,
ProtocolType.Tcp);
- IPEndPoint ep = new IPEndPoint (IPAddress.Loopback,
- BogusPort);
+ IPEndPoint ep = NetworkHelpers.LocalEphemeralEndPoint ();
Assert.AreEqual (false, sock.IsBound, "IsBoundTcp #1");
Socket sock = new Socket (AddressFamily.InterNetwork,
SocketType.Dgram,
ProtocolType.Udp);
- IPEndPoint ep = new IPEndPoint (IPAddress.Loopback,
- BogusPort);
+ IPEndPoint ep = NetworkHelpers.LocalEphemeralEndPoint ();
Assert.AreEqual (false, sock.IsBound, "IsBoundUdp #1");
[Test]
public void BeginConnectAddressPortNull ()
{
+ var port = NetworkHelpers.FindFreePort ();
Socket sock = new Socket (AddressFamily.InterNetwork,
SocketType.Stream,
ProtocolType.Tcp);
IPAddress ip = null;
try {
- sock.BeginConnect (ip, 1244, BCCallback,
+ sock.BeginConnect (ip, port, BCCallback,
sock);
Assert.Fail ("BeginConnectAddressPortNull #1");
} catch (ArgumentNullException) {
[ExpectedException (typeof(ObjectDisposedException))]
public void BeginConnectAddressPortClosed ()
{
+ var port = NetworkHelpers.FindFreePort ();
Socket sock = new Socket (AddressFamily.InterNetwork,
SocketType.Stream,
ProtocolType.Tcp);
sock.Close ();
- sock.BeginConnect (ip, 1244, BCCallback, sock);
+ sock.BeginConnect (ip, port, BCCallback, sock);
}
[Test]
[Test]
public void BeginConnectMultipleNull ()
{
+ var port = NetworkHelpers.FindFreePort ();
Socket sock = new Socket (AddressFamily.InterNetwork,
SocketType.Stream,
ProtocolType.Tcp);
IPAddress[] ips = null;
try {
- sock.BeginConnect (ips, 1246, BCCallback,
+ sock.BeginConnect (ips, port, BCCallback,
sock);
Assert.Fail ("BeginConnectMultipleNull #1");
} catch (ArgumentNullException) {
[ExpectedException (typeof(ObjectDisposedException))]
public void BeginConnectMultipleClosed ()
{
+ var port = NetworkHelpers.FindFreePort ();
Socket sock = new Socket (AddressFamily.InterNetwork,
SocketType.Stream,
ProtocolType.Tcp);
sock.Close ();
- sock.BeginConnect (ips, 1247, BCCallback, sock);
+ sock.BeginConnect (ips, port, BCCallback, sock);
}
[Test]
[Test]
public void ConnectAddressPortNull ()
{
+ var port = NetworkHelpers.FindFreePort ();
Socket sock = new Socket (AddressFamily.InterNetwork,
SocketType.Stream,
ProtocolType.Tcp);
IPAddress ip = null;
try {
- sock.Connect (ip, 1249);
+ sock.Connect (ip, port);
Assert.Fail ("ConnectAddressPortNull #1");
} catch (ArgumentNullException) {
} finally {
[ExpectedException (typeof(ObjectDisposedException))]
public void ConnectAddressPortClosed ()
{
+ var port = NetworkHelpers.FindFreePort ();
Socket sock = new Socket (AddressFamily.InterNetwork,
SocketType.Stream,
ProtocolType.Tcp);
sock.Close ();
- sock.Connect (ip, 1250);
+ sock.Connect (ip, port);
}
[Test]
[Test]
public void ConnectMultipleNull ()
{
+ var port = NetworkHelpers.FindFreePort ();
Socket sock = new Socket (AddressFamily.InterNetwork,
SocketType.Stream,
ProtocolType.Tcp);
IPAddress[] ips = null;
try {
- sock.Connect (ips, 1251);
+ sock.Connect (ips, port);
Assert.Fail ("ConnectMultipleNull #1");
} catch (ArgumentNullException) {
} finally {
[ExpectedException (typeof(ObjectDisposedException))]
public void ConnectMultipleClosed ()
{
+ var port = NetworkHelpers.FindFreePort ();
Socket sock = new Socket (AddressFamily.InterNetwork,
SocketType.Stream,
ProtocolType.Tcp);
sock.Close ();
- sock.Connect (ips, 1252);
+ sock.Connect (ips, port);
}
[Test]
IPv6MulticastOption option = new IPv6MulticastOption (
IPAddress.Parse ("ff02::1"));
- s.Bind (new IPEndPoint (IPAddress.IPv6Any, 1902));
+ s.Bind (new IPEndPoint (IPAddress.IPv6Any, 0));
s.SetSocketOption (SocketOptionLevel.IPv6, SocketOptionName.AddMembership,
option);
s.SetSocketOption (SocketOptionLevel.IPv6, SocketOptionName.DropMembership,
TcpClient client = new TcpClient ();
IPAddress[] ipAddresses = null;
- client.Connect (ipAddresses, 1234);
+ client.Connect (ipAddresses, NetworkHelpers.FindFreePort ());
}
[Test]
ipAddresses[0] = IPAddress.Any;
try {
- client.Connect (ipAddresses, 1234);
+ client.Connect (ipAddresses, NetworkHelpers.FindFreePort ());
Assert.Fail ("ConnectMultiAny #1");
} catch (SocketException ex) {
Assert.AreEqual (10049, ex.ErrorCode, "ConnectMultiAny #2");
ipAddresses[0] = IPAddress.Loopback;
try {
- client.Connect (ipAddresses, 1234);
+ client.Connect (ipAddresses, NetworkHelpers.FindFreePort ());
Assert.Fail ("ConnectMultiRefused #1");
} catch (SocketException ex) {
Assert.AreEqual (10061, ex.ErrorCode, "ConnectMultiRefused #2");
using NUnit.Framework;
+using MonoTests.Helpers;
+
namespace MonoTests.System.Net.Sockets {
[TestFixture]
public class UdpClientTest {
IPEndPoint localEP;
IPEndPoint clientEP;
- clientEP = new IPEndPoint (IPAddress.Loopback, 8001);
+ clientEP = new IPEndPoint (IPAddress.Loopback, NetworkHelpers.FindFreePort ());
using (MyUdpClient client = new MyUdpClient (clientEP))
{
s = client.Client;
Socket s;
IPEndPoint localEP;
- // Bug #5503
- // UDP port 0 doesn't seem to be valid.
- using (MyUdpClient client = new MyUdpClient ("127.0.0.1", 53))
+ using (MyUdpClient client = new MyUdpClient ("127.0.0.1", NetworkHelpers.FindFreePort ()))
{
s = client.Client;
Assert.IsNotNull (s, "#A:Client");
byte[] bytes = new byte[] {10, 11, 12, 13};
try {
- client.Send (bytes, bytes.Length, new IPEndPoint (IPAddress.Broadcast, 1235));
+ client.Send (bytes, bytes.Length, new IPEndPoint (IPAddress.Broadcast, NetworkHelpers.FindFreePort ()));
} finally {
client.Close ();
}
{
IPAddress mcast_addr = IPAddress.Parse ("224.0.0.23");
- using (UdpClient client = new UdpClient (new IPEndPoint (IPAddress.Any, 1234))) {
+ using (UdpClient client = new UdpClient (new IPEndPoint (IPAddress.Any, 0))) {
client.JoinMulticastGroup (mcast_addr);
}
}
IPAddress mcast_addr = IPAddress.Parse ("ff02::1");
- using (UdpClient client = new UdpClient (new IPEndPoint (IPAddress.IPv6Any, 1234))) {
+ using (UdpClient client = new UdpClient (new IPEndPoint (IPAddress.IPv6Any, 0))) {
client.JoinMulticastGroup (mcast_addr);
}
}
#endif
public void JoinMulticastGroup1_MulticastAddr_Null ()
{
- using (UdpClient client = new UdpClient (new IPEndPoint (IPAddress.Loopback, 1234))) {
+ using (UdpClient client = new UdpClient (new IPEndPoint (IPAddress.Loopback, 0))) {
try {
client.JoinMulticastGroup ((IPAddress) null);
Assert.Fail ("#1");
{
IPAddress mcast_addr = null;
- UdpClient client = new UdpClient (new IPEndPoint (IPAddress.Loopback, 1234));
+ UdpClient client = new UdpClient (new IPEndPoint (IPAddress.Loopback, 0));
client.Close ();
try {
client.JoinMulticastGroup (mcast_addr);
{
IPAddress mcast_addr = IPAddress.Parse ("224.0.0.23");
- using (UdpClient client = new UdpClient (new IPEndPoint (IPAddress.Any, 1234))) {
+ using (UdpClient client = new UdpClient (new IPEndPoint (IPAddress.Any, 0))) {
try {
client.JoinMulticastGroup (0, mcast_addr);
Assert.Fail ("#1");
IPAddress mcast_addr = IPAddress.Parse ("ff02::1");
- using (UdpClient client = new UdpClient (new IPEndPoint (IPAddress.IPv6Any, 1234))) {
+ using (UdpClient client = new UdpClient (new IPEndPoint (IPAddress.IPv6Any, 0))) {
client.JoinMulticastGroup (0, mcast_addr);
}
}
#endif
public void JoinMulticastGroup2_MulticastAddr_Null ()
{
- using (UdpClient client = new UdpClient (new IPEndPoint (IPAddress.Loopback, 1234))) {
+ using (UdpClient client = new UdpClient (new IPEndPoint (IPAddress.Loopback, 0))) {
try {
client.JoinMulticastGroup (0, (IPAddress) null);
Assert.Fail ("#1");
IPAddress mcast_addr = null;
- UdpClient client = new UdpClient (new IPEndPoint (IPAddress.IPv6Any, 1234));
+ UdpClient client = new UdpClient (new IPEndPoint (IPAddress.IPv6Any, 0));
client.Close ();
try {
client.JoinMulticastGroup (0, mcast_addr);
{
IPAddress mcast_addr = IPAddress.Parse ("224.0.0.23");
- using (UdpClient client = new UdpClient (new IPEndPoint (IPAddress.Any, 1234))) {
+ using (UdpClient client = new UdpClient (new IPEndPoint (IPAddress.Any, 0))) {
client.JoinMulticastGroup (mcast_addr, 0);
}
- using (UdpClient client = new UdpClient (new IPEndPoint (IPAddress.Any, 1234))) {
+ using (UdpClient client = new UdpClient (new IPEndPoint (IPAddress.Any, 0))) {
client.JoinMulticastGroup (mcast_addr, 255);
}
}
IPAddress mcast_addr = IPAddress.Parse ("ff02::1");
- using (UdpClient client = new UdpClient (new IPEndPoint (IPAddress.IPv6Any, 1234))) {
+ using (UdpClient client = new UdpClient (new IPEndPoint (IPAddress.IPv6Any, 0))) {
client.JoinMulticastGroup (mcast_addr, 0);
}
- using (UdpClient client = new UdpClient (new IPEndPoint (IPAddress.IPv6Any, 1234))) {
+ using (UdpClient client = new UdpClient (new IPEndPoint (IPAddress.IPv6Any, 0))) {
client.JoinMulticastGroup (mcast_addr, 255);
}
}
#endif
public void JoinMulticastGroup3_MulticastAddr_Null ()
{
- using (UdpClient client = new UdpClient (new IPEndPoint (IPAddress.Loopback, 1234))) {
+ using (UdpClient client = new UdpClient (new IPEndPoint (IPAddress.Loopback, 0))) {
try {
client.JoinMulticastGroup ((IPAddress) null, int.MaxValue);
Assert.Fail ("#1");
{
IPAddress mcast_addr = null;
- UdpClient client = new UdpClient (new IPEndPoint (IPAddress.Any, 1234));
+ UdpClient client = new UdpClient (new IPEndPoint (IPAddress.Any, 0));
client.Close ();
try {
client.JoinMulticastGroup (mcast_addr, 0);
IPAddress mcast_addr = IPAddress.Parse ("224.0.0.23");
IPAddress local_addr = IPAddress.Any;
- using (UdpClient client = new UdpClient (new IPEndPoint (IPAddress.Any, 1234))) {
+ using (UdpClient client = new UdpClient (new IPEndPoint (IPAddress.Any, 0))) {
client.JoinMulticastGroup (mcast_addr, local_addr);
}
}
IPAddress mcast_addr = IPAddress.Parse ("ff02::1");
IPAddress local_addr = IPAddress.IPv6Any;
- using (UdpClient client = new UdpClient (new IPEndPoint (IPAddress.IPv6Any, 1234))) {
+ using (UdpClient client = new UdpClient (new IPEndPoint (IPAddress.IPv6Any, 0))) {
try {
client.JoinMulticastGroup (mcast_addr, local_addr);
Assert.Fail ("#1");
{
IPAddress mcast_addr = IPAddress.Parse ("224.0.0.23");
- using (UdpClient client = new UdpClient (new IPEndPoint (IPAddress.Loopback, 1234))) {
+ using (UdpClient client = new UdpClient (new IPEndPoint (IPAddress.Loopback, 0))) {
try {
client.JoinMulticastGroup (mcast_addr, (IPAddress) null);
Assert.Fail ("#1");
#endif
public void JoinMulticastGroup4_MulticastAddr_Null ()
{
- using (UdpClient client = new UdpClient (new IPEndPoint (IPAddress.Loopback, 1234))) {
+ using (UdpClient client = new UdpClient (new IPEndPoint (IPAddress.Loopback, 0))) {
try {
client.JoinMulticastGroup ((IPAddress) null, IPAddress.Loopback);
Assert.Fail ("#1");
IPAddress mcast_addr = null;
IPAddress local_addr = null;
- UdpClient client = new UdpClient (new IPEndPoint (IPAddress.Any, 1234));
+ UdpClient client = new UdpClient (new IPEndPoint (IPAddress.Any, 0));
client.Close ();
try {
client.JoinMulticastGroup (mcast_addr, local_addr);
#endif
public void CloseInReceive ()
{
- UdpClient client = null;
- var rnd = new Random ();
- for (int i = 0, max = 5; i < max; i++) {
- int port = rnd.Next (1025, 65534);
- try {
- client = new UdpClient (port);
- break;
- } catch (Exception) {
- if (i == max - 1)
- throw;
- }
- }
+ UdpClient client = new UdpClient (NetworkHelpers.FindFreePort ());
ManualResetEvent ready = new ManualResetEvent (false);
bool got_exc = false;
#endif
public void JoinMulticastGroupWithLocal ()
{
- UdpClient client = new UdpClient (9001);
+ UdpClient client = new UdpClient (0);
IPAddress mcast_addr = IPAddress.Parse ("224.0.0.24");
IPAddress local_addr = IPAddress.Any;
IPEndPoint ep = null;
foreach (IPAddress a in addresses) {
if (a.AddressFamily == AddressFamily.InterNetwork) {
- ep = new IPEndPoint (a, 1236);
+ ep = new IPEndPoint (a, NetworkHelpers.FindFreePort ());
break;
}
}
#endif
public void BeginReceive ()
{
- UdpClient client = new UdpClient (1237);
+ var port = NetworkHelpers.FindFreePort ();
+ UdpClient client = new UdpClient (port);
BRCalledBack.Reset ();
client.BeginReceive (BRCallback, client);
- IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 1237);
+ IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, port);
byte[] send_bytes = new byte[] {10, 11, 12, 13};
client.Send (send_bytes, send_bytes.Length, ep);
#endif
public void Available ()
{
- using (UdpClient client = new UdpClient (1238)) {
- IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 1238);
+ var port = NetworkHelpers.FindFreePort ();
+ using (UdpClient client = new UdpClient (port)) {
+ IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, port);
byte[] bytes = new byte[] {10, 11, 12, 13};
int res = client.Send (bytes, bytes.Length, ep);
[Category ("NotWorking")] // Not supported on Linux
public void ExclusiveAddressUseBound ()
{
- UdpClient client = new UdpClient (1239);
+ UdpClient client = new UdpClient (0);
client.ExclusiveAddressUse = true;
if (!Socket.OSSupportsIPv6)
Assert.Ignore ("IPv6 not enabled.");
- int PORT = 9997;
- using(var udpClient = new UdpClient (PORT, AddressFamily.InterNetworkV6))
- using(var udpClient2 = new UdpClient (PORT+1, AddressFamily.InterNetworkV6))
+ int port1 = NetworkHelpers.FindFreePort ();
+ int port2 = NetworkHelpers.FindFreePort ();
+ using(var udpClient = new UdpClient (port1, AddressFamily.InterNetworkV6))
+ using(var udpClient2 = new UdpClient (port2, AddressFamily.InterNetworkV6))
{
var dataSent = new byte [] {1,2,3};
- udpClient2.SendAsync (dataSent, dataSent.Length, "::1", PORT);
+ udpClient2.SendAsync (dataSent, dataSent.Length, "::1", port1);
IPEndPoint endPoint = new IPEndPoint (IPAddress.IPv6Any, 0);
var data = udpClient.Receive (ref endPoint);
using NUnit.Framework;
using HLPC=System.Net.HttpListenerPrefixCollection;
+using MonoTests.Helpers;
+
namespace MonoTests.System.Net {
[TestFixture]
public class HttpListenerPrefixCollectionTest {
#endif
public void AddOne ()
{
+ var port = NetworkHelpers.FindFreePort ();
HttpListener listener = new HttpListener ();
HLPC coll = listener.Prefixes;
listener.Start ();
- coll.Add ("http://127.0.0.1:8181/");
+ coll.Add ($"http://127.0.0.1:{port}/");
Assert.AreEqual (1, coll.Count, "Count");
Assert.IsFalse (coll.IsReadOnly, "IsReadOnly");
Assert.IsFalse (coll.IsSynchronized, "IsSynchronized");
#endif
public void Duplicate ()
{
+ var port = NetworkHelpers.FindFreePort ();
HttpListener listener = new HttpListener ();
HLPC coll = listener.Prefixes;
- coll.Add ("http://127.0.0.1:8181/");
- coll.Add ("http://127.0.0.1:8181/");
+ coll.Add ($"http://127.0.0.1:{port}/");
+ coll.Add ($"http://127.0.0.1:{port}/");
listener.Start ();
Assert.AreEqual (1, coll.Count, "Count");
Assert.IsFalse (coll.IsReadOnly, "IsReadOnly");
+++ /dev/null
-//
-// System.Runtime.Remoting.RemotingServices NUnit V2.0 test class
-//
-// Author Jean-Marc ANDRE (jean-marc.andre@polymtl.ca)
-//
-// ToDo: I didn't write test functions for the method not yep
-// implemented by Mono
-
-using System;
-using System.Collections;
-using NUnit.Framework;
-using System.Reflection;
-using System.Runtime.Remoting;
-using System.Threading;
-using System.Runtime.Remoting.Activation;
-using System.Runtime.Remoting.Messaging;
-using System.Runtime.Remoting.Proxies;
-using System.Runtime.Remoting.Channels;
-using System.Runtime.Remoting.Channels.Tcp;
-
-namespace MonoTests.System.Runtime.Remoting.RemotingServicesInternal
-{
- // We need our own proxy to intercept messages to remote object
- // and forward them using RemotingServices.ExecuteMessage
- public class MyProxy: RealProxy
- {
- MarshalByRefObject target;
- IMessageSink _sink;
- MethodBase _mthBase;
- bool methodOverloaded = false;
-
- public MethodBase MthBase
- {
- get{ return _mthBase;}
- }
-
- public bool IsMethodOverloaded
- {
- get{return methodOverloaded;}
- }
-
- public MyProxy(Type serverType, MarshalByRefObject target): base(serverType)
- {
- this.target = target;
-
- IChannel[] registeredChannels = ChannelServices.RegisteredChannels;
- string ObjectURI;
-
- // A new IMessageSink chain has to be created
- // since the RemotingServices.GetEnvoyChainForProxy() is not yet
- // implemented.
- foreach(IChannel channel in registeredChannels)
- {
- IChannelSender channelSender = channel as IChannelSender;
- if(channelSender != null)
- {
- _sink = (IMessageSink) channelSender.CreateMessageSink(RemotingServices.GetObjectUri(target), null, out ObjectURI);
- }
- }
-
- }
-
- // Messages will be intercepted here and redirected
- // to another object.
- public override IMessage Invoke(IMessage msg)
- {
- if(msg is IConstructionCallMessage)
- {
- IActivator remActivator = (IActivator) RemotingServices.Connect(typeof(IActivator), "tcp://localhost:1234/RemoteActivationService.rem");
- IConstructionReturnMessage crm = remActivator.Activate((IConstructionCallMessage)msg);
- return crm;
- }
- else
- {
- methodOverloaded = RemotingServices.IsMethodOverloaded((IMethodMessage)msg);
-
- _mthBase = RemotingServices.GetMethodBaseFromMethodMessage((IMethodMessage)msg);
- MethodCallMessageWrapper mcm = new MethodCallMessageWrapper((IMethodCallMessage) msg);
- mcm.Uri = RemotingServices.GetObjectUri((MarshalByRefObject)target);
- MarshalByRefObject objRem = (MarshalByRefObject)Activator.CreateInstance(GetProxiedType());
- RemotingServices.ExecuteMessage((MarshalByRefObject)objRem, (IMethodCallMessage)msg);
- IMessage rtnMsg = null;
-
- try
- {
- rtnMsg = _sink.SyncProcessMessage(msg);
- }
- catch(Exception e)
- {
- Console.WriteLine(e.Message);
- }
-
- return rtnMsg;
- }
- }
- } // end MyProxy
-
- // This class is used to create "CAO"
- public class MarshalObjectFactory: MarshalByRefObject
- {
- public MarshalObject GetNewMarshalObject()
- {
- return new MarshalObject();
- }
- }
-
- // A class used by the tests
- public class MarshalObject: ContextBoundObject
- {
- public MarshalObject()
- {
-
- }
-
- public MarshalObject(int id, string uri)
- {
- this.id = id;
- this.uri = uri;
- }
- public int Id
- {
- get{return id;}
- set{id = value;}
- }
- public string Uri
- {
- get{return uri;}
- }
-
- public void Method1()
- {
- _called++;
- methodOneWay = RemotingServices.IsOneWay(MethodBase.GetCurrentMethod());
- }
-
- public void Method2()
- {
- methodOneWay = RemotingServices.IsOneWay(MethodBase.GetCurrentMethod());
- }
-
- public void Method2(int i)
- {
- methodOneWay = RemotingServices.IsOneWay(MethodBase.GetCurrentMethod());
-
- }
-
- [OneWay()]
- public void Method3()
- {
- methodOneWay = RemotingServices.IsOneWay(MethodBase.GetCurrentMethod());
-
- }
-
- public static int Called
- {
- get{return _called;}
- }
-
- public static bool IsMethodOneWay
- {
- get{return methodOneWay;}
- }
-
-
- private static int _called;
- private int id = 0;
- private string uri;
- private static bool methodOneWay = false;
- }
-
- // Another class used by the tests
- public class DerivedMarshalObject: MarshalObject
- {
- public DerivedMarshalObject(){}
-
- public DerivedMarshalObject(int id, string uri): base(id, uri) {}
- }
-} // namespace MonoTests.System.Runtime.Remoting.RemotingServicesInternal
-
-namespace MonoTests.System.Runtime.Remoting
-{
- using MonoTests.System.Runtime.Remoting.RemotingServicesInternal;
-
- // The main test class
- [TestFixture]
- public class RemotingServicesTest
- {
- private static int MarshalObjectId = 0;
-
- public RemotingServicesTest()
- {
- MarshalObjectId = 0;
- }
-
- // Helper function that create a new
- // MarshalObject with an unique ID
- private static MarshalObject NewMarshalObject()
- {
- string uri = "MonoTests.System.Runtime.Remoting.RemotingServicesTest.MarshalObject" + MarshalObjectId.ToString();
- MarshalObject objMarshal = new MarshalObject(MarshalObjectId, uri);
-
- MarshalObjectId++;
-
- return objMarshal;
- }
-
- // Another helper function
- private DerivedMarshalObject NewDerivedMarshalObject()
- {
- string uri = "MonoTests.System.Runtime.Remoting.RemotingServicesTest.DerivedMarshalObject" + MarshalObjectId.ToString();
- DerivedMarshalObject objMarshal = new DerivedMarshalObject(MarshalObjectId, uri);
-
- MarshalObjectId++;
-
- return objMarshal;
- }
-
- // The two folling method test RemotingServices.Marshal()
- [Test]
- public void Marshal1()
- {
-
- MarshalObject objMarshal = NewMarshalObject();
- ObjRef objRef = RemotingServices.Marshal(objMarshal);
-
- Assert.IsTrue(objRef.URI != null, "#A01");
-
- MarshalObject objRem = (MarshalObject) RemotingServices.Unmarshal(objRef);
- Assert.AreEqual(objMarshal.Id, objRem.Id, "#A02");
-
- objRem.Id = 2;
- Assert.AreEqual(objMarshal.Id, objRem.Id, "#A03");
-
- // TODO: uncomment when RemotingServices.Disconnect is implemented
- //RemotingServices.Disconnect(objMarshal);
-
- objMarshal = NewMarshalObject();
-
- objRef = RemotingServices.Marshal(objMarshal, objMarshal.Uri);
-
- Assert.IsTrue(objRef.URI.EndsWith(objMarshal.Uri), "#A04");
- // TODO: uncomment when RemotingServices.Disconnect is implemented
- //RemotingServices.Disconnect(objMarshal);
- }
-
- [Test]
- public void Marshal2()
- {
- DerivedMarshalObject derivedObjMarshal = NewDerivedMarshalObject();
-
- ObjRef objRef = RemotingServices.Marshal(derivedObjMarshal, derivedObjMarshal.Uri, typeof(MarshalObject));
-
- // Check that the type of the marshaled object is MarshalObject
- Assert.IsTrue(objRef.TypeInfo.TypeName.StartsWith((typeof(MarshalObject)).ToString()), "#A05");
-
- // TODO: uncomment when RemotingServices.Disconnect is implemented
- //RemotingServices.Disconnect(derivedObjMarshal);
- }
-
- // Tests RemotingServices.GetObjectUri()
- [Test]
- public void GetObjectUri()
- {
- MarshalObject objMarshal = NewMarshalObject();
-
- Assert.IsTrue(RemotingServices.GetObjectUri(objMarshal) == null, "#A06");
-
- ObjRef objRef = RemotingServices.Marshal(objMarshal);
-
- Assert.IsTrue(RemotingServices.GetObjectUri(objMarshal) != null, "#A07");
- // TODO: uncomment when RemotingServices.Disconnect is implemented
- //RemotingServices.Disconnect(objMarshal);
- }
-
- // Tests RemotingServices.Connect
- [Test]
- public void Connect()
- {
- MarshalObject objMarshal = NewMarshalObject();
-
- IDictionary props = new Hashtable();
- props["name"] = objMarshal.Uri;
- props["port"] = 1236;
- TcpChannel chn = new TcpChannel(props, null, null);
- ChannelServices.RegisterChannel(chn);
-
- RemotingServices.Marshal(objMarshal,objMarshal.Uri);
-
- MarshalObject objRem = (MarshalObject) RemotingServices.Connect(typeof(MarshalObject), "tcp://localhost:1236/" + objMarshal.Uri);
-
- Assert.IsTrue(RemotingServices.IsTransparentProxy(objRem), "#A08");
-
- ChannelServices.UnregisterChannel(chn);
-
- // TODO: uncomment when RemotingServices.Disconnect is implemented
- //RemotingServices.Disconnect(objMarshal);
- }
-
- // Tests RemotingServices.Marshal()
- [Test]
- [ExpectedException(typeof(RemotingException))]
- public void MarshalThrowException()
- {
- MarshalObject objMarshal = NewMarshalObject();
-
- IDictionary props = new Hashtable();
- props["name"] = objMarshal.Uri;
- props["port"] = 1237;
- TcpChannel chn = new TcpChannel(props, null, null);
- ChannelServices.RegisterChannel(chn);
-
- RemotingServices.Marshal(objMarshal,objMarshal.Uri);
-
- MarshalObject objRem = (MarshalObject) RemotingServices.Connect(typeof(MarshalObject), "tcp://localhost:1237/" + objMarshal.Uri);
- // This line sould throw a RemotingException
- // It is forbidden to export an object which is not
- // a real object
- try
- {
- RemotingServices.Marshal(objRem, objMarshal.Uri);
- }
- catch(Exception e)
- {
- ChannelServices.UnregisterChannel(chn);
-
- // TODO: uncomment when RemotingServices.Disconnect is implemented
- //RemotingServices.Disconnect(objMarshal);
-
- throw e;
- }
- }
-
- // Tests RemotingServices.ExecuteMessage()
- // also tests GetMethodBaseFromMessage()
- // IsMethodOverloaded()
- [Test]
- public void ExecuteMessage()
- {
- TcpChannel chn = null;
- try
- {
- chn = new TcpChannel(1235);
- ChannelServices.RegisterChannel(chn);
-
- MarshalObject objMarshal = NewMarshalObject();
- RemotingConfiguration.RegisterWellKnownServiceType(typeof(MarshalObject), objMarshal.Uri, WellKnownObjectMode.SingleCall);
-
- // use a proxy to catch the Message
- MyProxy proxy = new MyProxy(typeof(MarshalObject), (MarshalObject) Activator.GetObject(typeof(MarshalObject), "tcp://localhost:1235/" + objMarshal.Uri));
-
- MarshalObject objRem = (MarshalObject) proxy.GetTransparentProxy();
-
- objRem.Method1();
-
- // Tests RemotingServices.GetMethodBaseFromMethodMessage()
- AssertEquals("#A09","Method1",proxy.MthBase.Name);
- Assert.IsTrue(!proxy.IsMethodOverloaded, "#A09.1");
-
- objRem.Method2();
- Assert.IsTrue(proxy.IsMethodOverloaded, "#A09.2");
-
- // Tests RemotingServices.ExecuteMessage();
- // If ExecuteMessage does it job well, Method1 should be called 2 times
- Assert.AreEqual(2, MarshalObject.Called, "#A10");
- }
- finally
- {
- if(chn != null) ChannelServices.UnregisterChannel(chn);
- }
- }
-
- // Tests the IsOneWay method
- [Test]
- public void IsOneWay()
- {
- TcpChannel chn = null;
- try
- {
- chn = new TcpChannel(1238);
- ChannelServices.RegisterChannel(chn);
- RemotingConfiguration.RegisterWellKnownServiceType(typeof(MarshalObject), "MarshalObject.rem", WellKnownObjectMode.Singleton);
-
- MarshalObject objRem = (MarshalObject) Activator.GetObject(typeof(MarshalObject), "tcp://localhost:1238/MarshalObject.rem");
-
- Assert.IsTrue(RemotingServices.IsTransparentProxy(objRem), "#A10.1");
-
- objRem.Method1();
- Thread.Sleep(20);
- Assert.IsTrue(!MarshalObject.IsMethodOneWay, "#A10.2");
- objRem.Method3();
- Thread.Sleep(20);
- Assert.IsTrue(MarshalObject.IsMethodOneWay, "#A10.2");
- }
- finally
- {
- if(chn != null) ChannelServices.UnregisterChannel(chn);
- }
- }
-
- [Test]
- public void GetObjRefForProxy()
- {
- TcpChannel chn = null;
- try
- {
- chn = new TcpChannel(1239);
- ChannelServices.RegisterChannel(chn);
-
- // Register le factory as a SAO
- RemotingConfiguration.RegisterWellKnownServiceType(typeof(MarshalObjectFactory), "MonoTests.System.Runtime.Remoting.RemotingServicesTest.Factory.soap", WellKnownObjectMode.Singleton);
-
- MarshalObjectFactory objFactory = (MarshalObjectFactory) Activator.GetObject(typeof(MarshalObjectFactory), "tcp://localhost:1239/MonoTests.System.Runtime.Remoting.RemotingServicesTest.Factory.soap");
-
- // Get a new "CAO"
- MarshalObject objRem = objFactory.GetNewMarshalObject();
-
- ObjRef objRefRem = RemotingServices.GetObjRefForProxy((MarshalByRefObject)objRem);
-
- Assert.IsTrue(objRefRem != null, "#A11");
- }
- finally
- {
- if(chn != null) ChannelServices.UnregisterChannel(chn);
- }
- }
-
- // Tests GetRealProxy
- [Test]
- public void GetRealProxy()
- {
- TcpChannel chn = null;
- try
- {
- chn = new TcpChannel(1241);
- ChannelServices.RegisterChannel(chn);
-
- RemotingConfiguration.RegisterWellKnownServiceType(typeof(MarshalObject), "MonoTests.System.Runtime.Remoting.RemotingServicesTest.MarshalObject.soap", WellKnownObjectMode.Singleton);
-
- MyProxy proxy = new MyProxy(typeof(MarshalObject), (MarshalByRefObject)Activator.GetObject(typeof(MarshalObject), "tcp://localhost:1241/MonoTests.System.Runtime.Remoting.RemotingServicesTest.MarshalObject.soap"));
- MarshalObject objRem = (MarshalObject) proxy.GetTransparentProxy();
-
- RealProxy rp = RemotingServices.GetRealProxy(objRem);
-
- Assert.IsTrue(rp != null, "#A12");
- Assert.AreEqual("MonoTests.System.Runtime.Remoting.RemotingServicesInternal.MyProxy", rp.GetType().ToString(), "#A13");
- }
- finally
- {
- if(chn != null) ChannelServices.UnregisterChannel(chn);
- }
- }
-
- // Tests SetObjectUriForMarshal()
- [Test]
- public void SetObjectUriForMarshal()
- {
- TcpChannel chn = null;
- try
- {
- chn = new TcpChannel(1242);
- ChannelServices.RegisterChannel(chn);
-
- MarshalObject objRem = NewMarshalObject();
- RemotingServices.SetObjectUriForMarshal(objRem, objRem.Uri);
- RemotingServices.Marshal(objRem);
-
- objRem = (MarshalObject) Activator.GetObject(typeof(MarshalObject), "tcp://localhost:1242/"+objRem.Uri);
- Assert.IsTrue(objRem != null, "#A14");
- }
- finally
- {
- if(chn != null) ChannelServices.UnregisterChannel(chn);
- }
-
- }
-
- // Tests GetServeurTypeForUri()
- [Test]
- public void GetServeurTypeForUri()
- {
- TcpChannel chn = null;
- Type type = typeof(MarshalObject);
- try
- {
- chn = new TcpChannel(1243);
- ChannelServices.RegisterChannel(chn);
-
- MarshalObject objRem = NewMarshalObject();
- RemotingServices.SetObjectUriForMarshal(objRem, objRem.Uri);
- RemotingServices.Marshal(objRem);
-
- Type typeRem = RemotingServices.GetServerTypeForUri(RemotingServices.GetObjectUri(objRem));
- Assert.AreEqual(type, typeRem, "#A15");
- }
- finally
- {
- if(chn != null) ChannelServices.UnregisterChannel(chn);
- }
- }
-
- // Tests IsObjectOutOfDomain
- // Tests IsObjectOutOfContext
- [Test]
- public void IsObjectOutOf()
- {
- TcpChannel chn = null;
- try
- {
- chn = new TcpChannel(1245);
- ChannelServices.RegisterChannel(chn);
-
- RemotingConfiguration.RegisterWellKnownServiceType(typeof(MarshalObject), "MarshalObject.rem", WellKnownObjectMode.Singleton);
-
- MarshalObject objRem = (MarshalObject) Activator.GetObject(typeof(MarshalObject), "tcp://localhost:1245/MarshalObject.rem");
-
- Assert.IsTrue(RemotingServices.IsObjectOutOfAppDomain(objRem), "#A16");
- Assert.IsTrue(RemotingServices.IsObjectOutOfContext(objRem), "#A17");
-
- MarshalObject objMarshal = new MarshalObject();
- Assert.IsTrue(!RemotingServices.IsObjectOutOfAppDomain(objMarshal), "#A18");
- Assert.IsTrue(!RemotingServices.IsObjectOutOfContext(objMarshal), "#A19");
- }
- finally
- {
- ChannelServices.UnregisterChannel(chn);
- }
- }
- } // end class RemotingServicesTest
-} // end of namespace MonoTests.System.Runtime.Remoting.RemotingServicesTest
System.Reflection.Emit/SaveTest.cs
System.Runtime.Remoting/ContextTest.cs
System.Runtime.Remoting/RemotingConfigurationTest.cs
-System.Runtime.Remoting/RemotingServicesTest.cs
System.Runtime.Remoting/SoapServicesTest.cs
System.Runtime.Remoting/SynchronizationAttributeTest.cs
System.Runtime.Remoting.Channels/ChannelServicesTest.cs
{
while (true) {
var ep = new IPEndPoint (IPAddress.Loopback, rndPort.Next (10000, 60000));
- var socket = new Socket (ep.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
try {
- socket.Bind (ep);
- socket.Close ();
+ using (var socket = new Socket (ep.AddressFamily, SocketType.Stream, ProtocolType.Tcp)) {
+ socket.Bind (ep);
+ socket.Close ();
+ }
return ep;
} catch (SocketException) { }
}
projects / mono.git / commitdiff