mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-18 03:51:19 -10:00
* [System] Fix line endings for a few files.
Best reviewed by not showing whitespace changes (should be empty diff in that case).
* [System] Fix potential crash in CookieParserTests.
Socket.EndAccept can throw an exception, which will crash the process if it
happens on a threadpool. So handle any exceptions when calling
Socket.EndAccept, and propagate those exceptions out of any threadpool code.
* [System.Net.Http] Throw a PlatformNotSupported exception when using HttpClientHandler on watchOS.
* [System.Net.Http] Tweak tests after watchOS API change.
Unfortunately the [ExpectedException] attribute can't be put on an entire
class, so remove the [Category ("RequiresBSDSockets")] attribute on the class
and instead decorate each test with an [ExpectedException] attribute.
* [System] Extract the HttpListenerResponseHelper class to a separate file.
Extract the HttpListenerResponseHelper class to a separate file so that it's
easier to replace the HttpListenerResponse implementation by using a different
file.
* [System] Throw a PlatformNotSupported exception when using the networking stack on watchOS.
* [System] Tweak tests after watchOS API changes.
Unfortunately the [ExpectedException] attribute can't be put on an entire
class, so remove the [Category ("RequiresBSDSockets")] attribute on the class
and instead decorate each test with an [ExpectedException] attribute.
* [System] Fix potential crash in SocketAcceptAsyncTest.
Fix potential crash in SocketAcceptAsyncTest by catching any exceptions in
code executed on the threadpool so that we never end up with unhandled
exceptions (which may terminate the process).
* [System] Avoid logic in SetUp attributes in tests.
Any type of exception in [SetUp] attributes causes all tests to fail with that
exception.
This even happens for tests that do not need the logic in the [SetUp]
attribute.
So rewrite tests a bit to not use [SetUp] when we can reasonably avoid it, and
instead instantiate class-level variables on first use. This ensures that any
exceptions that occur when initializing those variables are attributed to the
corresponding test, and not all of them.
* [System] Make exception handler (for test) catch more exceptions to avoid unhandled exceptions causing process termination.
* [System] Remove Obsolete attribute on API that throws PNSE.
482 lines
14 KiB
C#
482 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 ()
|
|
{
|
|
var uri = "http://localhost:" + NetworkHelpers.FindFreePort () + "/";
|
|
|
|
HttpListener listener = new HttpListener ();
|
|
listener.Prefixes.Add (uri);
|
|
listener.Start ();
|
|
|
|
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 ();
|
|
}
|
|
}
|
|
|
|
}
|
|
|