mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-17 11:21:39 -10:00
Refactor tests to use system-assigned ports whenever possible, so that we
avoid the potential race condition in NetworkHelpers.FindFreePort.
This should make it much less probable to run into spurious "Address already
in use" exceptions.
In some cases I kept the call to NetworkHelpers.FindFreePort:
* When the test is not binding/listening on a port, but instead trying to
connect to an inexistent port (for tests that verifies error handling /
exceptions). In this case there is still a race condition (if a test tries
to verify that a connection fails, it may unexpectedly succeed instead).
* Sometimes the test doesn't actually use the port (the test is verifying
something very different, for instance a ArgumentNullExceptions, which are
thrown before the port is used).
* Some API doesn't allow for requesting a system assigned port:
* HttpListener: in this case I elected to re-try a few times in case of
"Address already in use" exceptions.
* The 'UdpClient (string, port)' constructor (other constructors work
fine): these turned out a bit complicated to work around (or would
modify the test more than would be reasonable), so for these we still
have to hope for the best.
Hopefully fixes https://github.com/xamarin/maccore/issues/604.
478 lines
14 KiB
C#
478 lines
14 KiB
C#
//
|
|
// WebRequestTest.cs - NUnit Test Cases for System.Net.WebRequest
|
|
//
|
|
// Authors:
|
|
// Lawrence Pit ([email protected])
|
|
// Martin Willemoes Hansen ([email protected])
|
|
// Sebastien Pouliot <[email protected]>
|
|
//
|
|
// (C) 2003 Martin Willemoes Hansen
|
|
// Copyright (C) 2005 Novell, Inc (http://www.novell.com)
|
|
//
|
|
|
|
using NUnit.Framework;
|
|
using MonoTests.Helpers;
|
|
using System;
|
|
using System.Net;
|
|
using System.Threading;
|
|
using System.Collections;
|
|
using System.Runtime.Serialization;
|
|
using Socks = System.Net.Sockets;
|
|
|
|
|
|
namespace MonoTests.System.Net {
|
|
|
|
// WebRequest is abstract
|
|
|
|
public class NonAbstractWebRequest : WebRequest
|
|
{
|
|
|
|
public NonAbstractWebRequest ()
|
|
{
|
|
}
|
|
|
|
public NonAbstractWebRequest (SerializationInfo si, StreamingContext sc)
|
|
: base (si, sc)
|
|
{
|
|
}
|
|
}
|
|
|
|
[TestFixture]
|
|
public class WebRequestTest {
|
|
|
|
private void Callback (IAsyncResult ar)
|
|
{
|
|
Assert.Fail ("Callback");
|
|
}
|
|
|
|
[Test]
|
|
public void SerializationConstructor ()
|
|
{
|
|
NonAbstractWebRequest w = new NonAbstractWebRequest (null, new StreamingContext ());
|
|
Assert.IsNotNull (w);
|
|
}
|
|
|
|
// properties (only test 'get'ter)
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (NotImplementedException))]
|
|
public void ConnectionGroupName ()
|
|
{
|
|
NonAbstractWebRequest w = new NonAbstractWebRequest ();
|
|
Assert.IsNull (w.ConnectionGroupName);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (NotImplementedException))]
|
|
public void ContentLength ()
|
|
{
|
|
NonAbstractWebRequest w = new NonAbstractWebRequest ();
|
|
Assert.IsNull (w.ContentLength);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (NotImplementedException))]
|
|
public void ContentType ()
|
|
{
|
|
NonAbstractWebRequest w = new NonAbstractWebRequest ();
|
|
Assert.IsNull (w.ContentType);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (NotImplementedException))]
|
|
public void Credentials ()
|
|
{
|
|
NonAbstractWebRequest w = new NonAbstractWebRequest ();
|
|
Assert.IsNull (w.Credentials);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (NotImplementedException))]
|
|
public void Headers ()
|
|
{
|
|
NonAbstractWebRequest w = new NonAbstractWebRequest ();
|
|
Assert.IsNull (w.Headers);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (NotImplementedException))]
|
|
public void Method ()
|
|
{
|
|
NonAbstractWebRequest w = new NonAbstractWebRequest ();
|
|
Assert.IsNull (w.Method);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (NotImplementedException))]
|
|
public void PreAuthenticate ()
|
|
{
|
|
NonAbstractWebRequest w = new NonAbstractWebRequest ();
|
|
Assert.IsTrue (w.PreAuthenticate);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (NotImplementedException))]
|
|
public void Proxy ()
|
|
{
|
|
NonAbstractWebRequest w = new NonAbstractWebRequest ();
|
|
Assert.IsNull (w.Proxy);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (NotImplementedException))]
|
|
public void RequestUri ()
|
|
{
|
|
NonAbstractWebRequest w = new NonAbstractWebRequest ();
|
|
Assert.IsNull (w.RequestUri);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (NotImplementedException))]
|
|
public void Timeout ()
|
|
{
|
|
NonAbstractWebRequest w = new NonAbstractWebRequest ();
|
|
Assert.IsNull (w.Timeout);
|
|
}
|
|
|
|
// methods
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (NotImplementedException))]
|
|
public void Abort ()
|
|
{
|
|
NonAbstractWebRequest w = new NonAbstractWebRequest ();
|
|
w.Abort ();
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (NotImplementedException))]
|
|
public void BeginGetRequestStream ()
|
|
{
|
|
NonAbstractWebRequest w = new NonAbstractWebRequest ();
|
|
IAsyncResult r = w.BeginGetRequestStream (new AsyncCallback (Callback), w);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (NotImplementedException))]
|
|
public void BeginGetResponse ()
|
|
{
|
|
NonAbstractWebRequest w = new NonAbstractWebRequest ();
|
|
IAsyncResult r = w.BeginGetResponse (new AsyncCallback (Callback), w);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (NotImplementedException))]
|
|
public void EndGetRequestStream ()
|
|
{
|
|
NonAbstractWebRequest w = new NonAbstractWebRequest ();
|
|
w.EndGetRequestStream (null);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (NotImplementedException))]
|
|
public void EndGetResponse ()
|
|
{
|
|
NonAbstractWebRequest w = new NonAbstractWebRequest ();
|
|
w.EndGetResponse (null);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (NotImplementedException))]
|
|
public void GetRequestStream ()
|
|
{
|
|
NonAbstractWebRequest w = new NonAbstractWebRequest ();
|
|
w.GetRequestStream ();
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (NotImplementedException))]
|
|
public void GetResponse ()
|
|
{
|
|
NonAbstractWebRequest w = new NonAbstractWebRequest ();
|
|
w.GetResponse ();
|
|
}
|
|
|
|
[Test]
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#endif
|
|
public void All ()
|
|
{
|
|
WebRequest req = WebRequest.Create ("http://www.contoso.com");
|
|
Assert.IsTrue (req is HttpWebRequest, "#1");
|
|
req = WebRequest.Create ("https://www.contoso.com");
|
|
Assert.IsTrue (req is HttpWebRequest, "#2");
|
|
req = WebRequest.Create ("file://www.contoso.com");
|
|
Assert.IsTrue (req is FileWebRequest, "#3");
|
|
req = WebRequest.Create ("ftp://www.contoso.com");
|
|
Assert.IsTrue (req is FtpWebRequest, "#4");
|
|
WebRequest.RegisterPrefix ("http://www.contoso.com", new TestWebRequestCreator ());
|
|
bool ret = WebRequest.RegisterPrefix ("http://WWW.contoso.com", new TestWebRequestCreator ());
|
|
Assert.AreEqual (false, ret, "#5a");
|
|
ret = WebRequest.RegisterPrefix ("http://www.contoso.com/foo/bar", new TestWebRequestCreator2 ());
|
|
Assert.AreEqual (true, ret, "#5b");
|
|
ret = WebRequest.RegisterPrefix ("http://www", new TestWebRequestCreator3 ());
|
|
Assert.AreEqual (true, ret, "#5c");
|
|
|
|
req = WebRequest.Create ("http://WWW.contoso.com");
|
|
Assert.IsTrue (req is TestWebRequest, "#6");
|
|
|
|
req = WebRequest.Create ("http://WWW.contoso.com/foo/bar/index.html");
|
|
Assert.IsTrue (req is TestWebRequest2, "#7");
|
|
|
|
req = WebRequest.Create ("http://WWW.x.com");
|
|
Assert.IsTrue (req is TestWebRequest3, "#8");
|
|
|
|
req = WebRequest.Create ("http://WWW.c");
|
|
Assert.IsTrue (req is TestWebRequest3, "#9");
|
|
|
|
req = WebRequest.CreateDefault (new Uri("http://WWW.contoso.com"));
|
|
Assert.IsTrue (req is HttpWebRequest, "#10");
|
|
|
|
try {
|
|
req = WebRequest.Create ("tcp://www.contoso.com");
|
|
Assert.Fail ("#11 should have failed with NotSupportedException");
|
|
} catch (NotSupportedException) {
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void Create_RequestUriString_Null ()
|
|
{
|
|
try {
|
|
WebRequest.Create ((string) 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.IsNotNull (ex.ParamName, "#5");
|
|
Assert.AreEqual ("requestUriString", ex.ParamName, "#6");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void CreateDefault_RequestUri_Null ()
|
|
{
|
|
try {
|
|
WebRequest.CreateDefault ((Uri) 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.IsNotNull (ex.ParamName, "#5");
|
|
Assert.AreEqual ("requestUri", ex.ParamName, "#6");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#endif
|
|
public void DefaultWebProxy ()
|
|
{
|
|
WebProxy proxy = new WebProxy ("proxy.intern.com", 83);
|
|
|
|
WebRequest.DefaultWebProxy = proxy;
|
|
Assert.IsNotNull (WebRequest.DefaultWebProxy, "#A1");
|
|
Assert.AreSame (proxy, WebRequest.DefaultWebProxy, "#A2");
|
|
|
|
HttpWebRequest req = (HttpWebRequest) WebRequest.CreateDefault (
|
|
new Uri ("http://www.mono-project.com"));
|
|
Assert.IsNotNull (req.Proxy, "#B1");
|
|
Assert.AreSame (proxy, req.Proxy, "#B2");
|
|
|
|
WebRequest.DefaultWebProxy = null;
|
|
Assert.IsNull (WebRequest.DefaultWebProxy, "#C1");
|
|
Assert.IsNotNull (req.Proxy, "#C2");
|
|
Assert.AreSame (proxy, req.Proxy, "#C3");
|
|
|
|
req = (HttpWebRequest) WebRequest.CreateDefault (
|
|
new Uri ("http://www.mono-project.com"));
|
|
Assert.IsNull (req.Proxy, "#D");
|
|
}
|
|
|
|
[Test]
|
|
public void RegisterPrefix_Creator_Null ()
|
|
{
|
|
try {
|
|
WebRequest.RegisterPrefix ("http://www.mono-project.com", (IWebRequestCreate) 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.IsNotNull (ex.ParamName, "#5");
|
|
Assert.AreEqual ("creator", ex.ParamName, "#6");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void RegisterPrefix_Prefix_Null ()
|
|
{
|
|
try {
|
|
WebRequest.RegisterPrefix ((string) null, new TestWebRequestCreator ());
|
|
Assert.Fail ("#1");
|
|
} catch (ArgumentNullException ex) {
|
|
Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
|
|
Assert.IsNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.IsNotNull (ex.ParamName, "#5");
|
|
Assert.AreEqual ("prefix", ex.ParamName, "#6");
|
|
}
|
|
}
|
|
|
|
[Test] //BNC#323452
|
|
// Throws exception with Status == Timeout. The same code behaves as the test expects when run from a regular app.
|
|
// Might be an issue with the test suite. To investigate.
|
|
[Category("AndroidNotWorking")]
|
|
public void TestFailedConnection ()
|
|
{
|
|
try {
|
|
WebRequest.Create ("http://127.0.0.1:0/non-existant.txt").GetResponse ();
|
|
Assert.Fail ("Should have raised an exception");
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
} catch (PlatformNotSupportedException) {
|
|
// Expected
|
|
#endif
|
|
} catch (Exception e) {
|
|
Assert.IsTrue (e is WebException, "Got " + e.GetType ().Name + ": " + e.Message);
|
|
//#if NET_2_0 e.Message == "Unable to connect to the remote server"
|
|
//#if NET_1_1 e.Message == "The underlying connection was closed: Unable to connect to the remote server."
|
|
|
|
Assert.AreEqual (WebExceptionStatus.ConnectFailure, ((WebException)e).Status);
|
|
|
|
//#if !NET_1_1 (this is not true in .NET 1.x)
|
|
Assert.IsNotNull (e.InnerException);
|
|
Assert.IsTrue (e.InnerException is Socks.SocketException, "InnerException should be SocketException");
|
|
//e.Message == "The requested address is not valid in its context 127.0.0.1:0"
|
|
//#endif
|
|
}
|
|
}
|
|
|
|
[Test] //BNC#323452
|
|
[Category ("AndroidNotWorking")] // Fails when ran as part of the entire BCL test suite. Works when only this fixture is ran
|
|
public void TestFailedResolution ()
|
|
{
|
|
try {
|
|
var req = WebRequest.Create ("http://thisdomaindoesnotexist.monotestcase.x/non-existant.txt").GetResponse ();
|
|
/*
|
|
* Work around broken t-online.de DNS Server.
|
|
*
|
|
* T-Online's DNS Server for DSL Customers resolves
|
|
* non-exisitng domain names to
|
|
* http://navigationshilfe1.t-online.de/dnserror?url=....
|
|
* instead of reporting an error.
|
|
*/
|
|
if (req.ResponseUri.DnsSafeHost.Equals ("navigationshilfe1.t-online.de"))
|
|
Assert.Ignore ("Misbehaving DNS server.");
|
|
|
|
Assert.Fail ("Should have raised an exception");
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
} catch (PlatformNotSupportedException) {
|
|
// Expected
|
|
#endif
|
|
} catch (Exception e) {
|
|
Assert.IsTrue (e is WebException);
|
|
//#if NET_2_0 e.Message == "The underlying connection was closed: The remote name could not be resolved."
|
|
//#if NET_1_1 e.Message == "The remote name could not be resolved: 'thisdomaindoesnotexist.monotestcase.x'"
|
|
Assert.AreEqual (((WebException)e).Status, WebExceptionStatus.NameResolutionFailure);
|
|
Assert.IsNull (e.InnerException);
|
|
}
|
|
}
|
|
|
|
internal class TestWebRequestCreator : IWebRequestCreate
|
|
{
|
|
internal TestWebRequestCreator () { }
|
|
|
|
public WebRequest Create (Uri uri)
|
|
{
|
|
return new TestWebRequest ();
|
|
}
|
|
}
|
|
|
|
internal class TestWebRequest : WebRequest
|
|
{
|
|
internal TestWebRequest () { }
|
|
}
|
|
|
|
internal class TestWebRequestCreator2 : IWebRequestCreate
|
|
{
|
|
internal TestWebRequestCreator2 () { }
|
|
|
|
public WebRequest Create (Uri uri)
|
|
{
|
|
return new TestWebRequest2 ();
|
|
}
|
|
}
|
|
|
|
internal class TestWebRequest2 : WebRequest
|
|
{
|
|
internal TestWebRequest2 () { }
|
|
}
|
|
|
|
internal class TestWebRequestCreator3 : IWebRequestCreate
|
|
{
|
|
internal TestWebRequestCreator3 () { }
|
|
|
|
public WebRequest Create (Uri uri)
|
|
{
|
|
return new TestWebRequest3 ();
|
|
}
|
|
}
|
|
|
|
internal class TestWebRequest3 : WebRequest
|
|
{
|
|
internal TestWebRequest3 () { }
|
|
}
|
|
|
|
[Test] // Covers #41477
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#endif
|
|
public void TestReceiveCancelation ()
|
|
{
|
|
HttpListener listener = NetworkHelpers.CreateAndStartHttpListener ("http://localhost:", out var port, "/", out var uri);
|
|
|
|
try {
|
|
for (var i = 0; i < 10; i++) {
|
|
var request = WebRequest.CreateHttp (uri);
|
|
request.Method = "GET";
|
|
|
|
var tokenSource = new CancellationTokenSource ();
|
|
tokenSource.Token.Register(() => request.Abort ());
|
|
|
|
var responseTask = request.GetResponseAsync ();
|
|
|
|
var context = listener.GetContext ();
|
|
byte[] outBuffer = new byte[8 * 1024];
|
|
context.Response.OutputStream.WriteAsync (outBuffer, 0, outBuffer.Length);
|
|
|
|
Assert.IsTrue (responseTask.Wait (1000), "Timeout #1");
|
|
|
|
WebResponse response = responseTask.Result;
|
|
var stream = response.GetResponseStream ();
|
|
|
|
byte[] buffer = new byte[8 * 1024];
|
|
var taskRead = stream.ReadAsync (buffer, 0, buffer.Length, tokenSource.Token);
|
|
|
|
tokenSource.Cancel ();
|
|
|
|
Assert.IsTrue (taskRead.Wait (1000), "Timeout #2");
|
|
|
|
var byteRead = taskRead.Result;
|
|
}
|
|
} catch (AggregateException ex) {
|
|
var webEx = ex.InnerException as WebException;
|
|
Assert.IsNotNull(webEx, "Inner exception is not a WebException");
|
|
Assert.AreEqual (webEx.Status, WebExceptionStatus.RequestCanceled);
|
|
}
|
|
|
|
listener.Close ();
|
|
}
|
|
}
|
|
|
|
}
|
|
|