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.
1920 lines
62 KiB
C#
1920 lines
62 KiB
C#
//
|
|
// WebClientTest.cs - NUnit Test Cases for System.Net.WebClient
|
|
//
|
|
// Copyright (C) 2007 Novell, Inc (http://www.novell.com)
|
|
//
|
|
|
|
using System;
|
|
using System.Collections;
|
|
using System.Collections.Specialized;
|
|
using System.Globalization;
|
|
using System.IO;
|
|
using System.Net;
|
|
using System.Net.Sockets;
|
|
using System.Runtime.Serialization;
|
|
using System.Text;
|
|
using System.Threading;
|
|
using NUnit.Framework;
|
|
|
|
using MonoTests.Helpers;
|
|
|
|
namespace MonoTests.System.Net
|
|
{
|
|
[TestFixture]
|
|
public class WebClientTest
|
|
{
|
|
private string _tempFolder;
|
|
|
|
[SetUp]
|
|
public void SetUp ()
|
|
{
|
|
_tempFolder = Path.Combine (Path.GetTempPath (),
|
|
GetType ().FullName);
|
|
if (Directory.Exists (_tempFolder))
|
|
Directory.Delete (_tempFolder, true);
|
|
Directory.CreateDirectory (_tempFolder);
|
|
}
|
|
|
|
[TearDown]
|
|
public void TearDown ()
|
|
{
|
|
if (Directory.Exists (_tempFolder))
|
|
Directory.Delete (_tempFolder, true);
|
|
}
|
|
|
|
[Test]
|
|
[Category ("InetAccess")]
|
|
public void DownloadTwice ()
|
|
{
|
|
WebClient wc = new WebClient();
|
|
string filename = Path.GetTempFileName();
|
|
|
|
// A new, but empty file has been created. This is a test case
|
|
// for bug 81005
|
|
wc.DownloadFile("http://google.com/", filename);
|
|
|
|
// Now, remove the file and attempt to download again.
|
|
File.Delete(filename);
|
|
wc.DownloadFile("http://google.com/", filename);
|
|
}
|
|
|
|
[Test]
|
|
public void DownloadData1_Address_Null ()
|
|
{
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.DownloadData ((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 ("address", ex.ParamName, "#6");
|
|
}
|
|
}
|
|
|
|
[Test] // DownloadData (string)
|
|
public void DownloadData1_Address_SchemeNotSupported ()
|
|
{
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.DownloadData ("tp://scheme.notsupported");
|
|
Assert.Fail ("#1");
|
|
} catch (WebException ex) {
|
|
// An error occurred performing a WebClient request
|
|
Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
|
|
Assert.IsNotNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.IsNull (ex.Response, "#5");
|
|
Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
|
|
|
|
// The URI prefix is not recognized
|
|
Exception inner = ex.InnerException;
|
|
Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
|
|
Assert.IsNull (inner.InnerException, "#8");
|
|
Assert.IsNotNull (inner.Message, "#9");
|
|
}
|
|
}
|
|
|
|
[Test] // DownloadData (Uri)
|
|
public void DownloadData2_Address_Null ()
|
|
{
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.DownloadData ((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 ("address", ex.ParamName, "#6");
|
|
}
|
|
}
|
|
|
|
[Test] // DownloadData (Uri)
|
|
public void DownloadData2_Address_SchemeNotSupported ()
|
|
{
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.DownloadData (new Uri ("tp://scheme.notsupported"));
|
|
Assert.Fail ("#1");
|
|
} catch (WebException ex) {
|
|
// An error occurred performing a WebClient request
|
|
Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
|
|
Assert.IsNotNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.IsNull (ex.Response, "#5");
|
|
Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
|
|
|
|
// The URI prefix is not recognized
|
|
Exception inner = ex.InnerException;
|
|
Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
|
|
Assert.IsNull (inner.InnerException, "#8");
|
|
Assert.IsNotNull (inner.Message, "#9");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void DownloadFile1_Address_Null ()
|
|
{
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.DownloadFile ((string) null, "tmp.out");
|
|
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 ("address", ex.ParamName, "#6");
|
|
}
|
|
}
|
|
|
|
[Test] // DownloadFile (string, string)
|
|
public void DownloadFile1_Address_SchemeNotSupported ()
|
|
{
|
|
string file = Path.Combine (Path.GetTempPath (), "tmp.out");
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.DownloadFile ("tp://scheme.notsupported", file);
|
|
Assert.Fail ("#1");
|
|
} catch (WebException ex) {
|
|
// An error occurred performing a WebClient request
|
|
Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
|
|
Assert.IsNotNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.IsNull (ex.Response, "#5");
|
|
Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
|
|
|
|
// The URI prefix is not recognized
|
|
Exception inner = ex.InnerException;
|
|
Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
|
|
Assert.IsNull (inner.InnerException, "#8");
|
|
Assert.IsNotNull (inner.Message, "#9");
|
|
}
|
|
finally {
|
|
if (File.Exists (file))
|
|
File.Delete (file);
|
|
}
|
|
}
|
|
|
|
[Test] // DownloadFile (string, string)
|
|
public void DownloadFile1_FileName_Null ()
|
|
{
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.DownloadFile ("tp://scheme.notsupported",
|
|
(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 ("fileName", ex.ParamName, "#6");
|
|
}
|
|
}
|
|
|
|
[Test] // DownloadFile (Uri, string)
|
|
public void DownloadFile2_Address_Null ()
|
|
{
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.DownloadFile ((Uri) null, "tmp.out");
|
|
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 ("address", ex.ParamName, "#6");
|
|
}
|
|
}
|
|
|
|
[Test] // DownloadFile (Uri, string)
|
|
public void DownloadFile2_Address_SchemeNotSupported ()
|
|
{
|
|
string file = Path.Combine (Path.GetTempPath (), "tmp.out");
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.DownloadFile (new Uri ("tp://scheme.notsupported"), file);
|
|
Assert.Fail ("#1");
|
|
} catch (WebException ex) {
|
|
// An error occurred performing a WebClient request
|
|
Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
|
|
Assert.IsNotNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.IsNull (ex.Response, "#5");
|
|
Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
|
|
|
|
// The URI prefix is not recognized
|
|
Exception inner = ex.InnerException;
|
|
Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
|
|
Assert.IsNull (inner.InnerException, "#8");
|
|
Assert.IsNotNull (inner.Message, "#9");
|
|
}
|
|
finally {
|
|
if (File.Exists (file))
|
|
File.Delete (file);
|
|
}
|
|
}
|
|
|
|
[Test] // DownloadFile (Uri, string)
|
|
public void DownloadFile2_FileName_Null ()
|
|
{
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.DownloadFile (new Uri ("tp://scheme.notsupported"),
|
|
(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 ("fileName", ex.ParamName, "#6");
|
|
}
|
|
}
|
|
|
|
[Test] // DownloadString (string)
|
|
public void DownloadString1_Address_Null ()
|
|
{
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.DownloadString ((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 ("address", ex.ParamName, "#6");
|
|
}
|
|
}
|
|
|
|
[Test] // DownloadString (string)
|
|
public void DownloadString1_Address_SchemeNotSupported ()
|
|
{
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.DownloadString ("tp://scheme.notsupported");
|
|
Assert.Fail ("#1");
|
|
} catch (WebException ex) {
|
|
// An error occurred performing a WebClient request
|
|
Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
|
|
Assert.IsNotNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.IsNull (ex.Response, "#5");
|
|
Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
|
|
|
|
// The URI prefix is not recognized
|
|
Exception inner = ex.InnerException;
|
|
Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
|
|
Assert.IsNull (inner.InnerException, "#8");
|
|
Assert.IsNotNull (inner.Message, "#9");
|
|
}
|
|
}
|
|
|
|
[Test] // DownloadString (Uri)
|
|
public void DownloadString2_Address_Null ()
|
|
{
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.DownloadString ((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 ("address", ex.ParamName, "#6");
|
|
}
|
|
}
|
|
|
|
[Test] // DownloadString (Uri)
|
|
public void DownloadString2_Address_SchemeNotSupported ()
|
|
{
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.DownloadString (new Uri ("tp://scheme.notsupported"));
|
|
Assert.Fail ("#1");
|
|
} catch (WebException ex) {
|
|
// An error occurred performing a WebClient request
|
|
Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
|
|
Assert.IsNotNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.IsNull (ex.Response, "#5");
|
|
Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
|
|
|
|
// The URI prefix is not recognized
|
|
Exception inner = ex.InnerException;
|
|
Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
|
|
Assert.IsNull (inner.InnerException, "#8");
|
|
Assert.IsNotNull (inner.Message, "#9");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void EncodingTest ()
|
|
{
|
|
WebClient wc = new WebClient ();
|
|
Assert.AreSame (Encoding.Default, wc.Encoding, "#1");
|
|
wc.Encoding = Encoding.ASCII;
|
|
Assert.AreSame (Encoding.ASCII, wc.Encoding, "#2");
|
|
}
|
|
|
|
[Test]
|
|
public void Encoding_Value_Null ()
|
|
{
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.Encoding = null;
|
|
Assert.Fail ("#1");
|
|
} catch (ArgumentNullException ex) {
|
|
Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
|
|
Assert.IsNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.AreEqual ("Encoding", ex.ParamName, "#6");
|
|
}
|
|
}
|
|
|
|
[Test] // OpenRead (string)
|
|
public void OpenRead1_Address_Null ()
|
|
{
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.OpenRead ((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 ("address", ex.ParamName, "#6");
|
|
}
|
|
}
|
|
|
|
[Test] // OpenRead (string)
|
|
public void OpenRead1_Address_SchemeNotSupported ()
|
|
{
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.OpenRead ("tp://scheme.notsupported");
|
|
Assert.Fail ("#1");
|
|
} catch (WebException ex) {
|
|
// An error occurred performing a WebClient request
|
|
Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
|
|
Assert.IsNotNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.IsNull (ex.Response, "#5");
|
|
Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
|
|
|
|
// The URI prefix is not recognized
|
|
Exception inner = ex.InnerException;
|
|
Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
|
|
Assert.IsNull (inner.InnerException, "#8");
|
|
Assert.IsNotNull (inner.Message, "#9");
|
|
}
|
|
}
|
|
|
|
[Test] // OpenRead (Uri)
|
|
public void OpenRead2_Address_Null ()
|
|
{
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.OpenRead ((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 ("address", ex.ParamName, "#6");
|
|
}
|
|
}
|
|
|
|
[Test] // OpenRead (Uri)
|
|
public void OpenRead2_Address_SchemeNotSupported ()
|
|
{
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.OpenRead (new Uri ("tp://scheme.notsupported"));
|
|
Assert.Fail ("#1");
|
|
} catch (WebException ex) {
|
|
// An error occurred performing a WebClient request
|
|
Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
|
|
Assert.IsNotNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.IsNull (ex.Response, "#5");
|
|
Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
|
|
|
|
// The URI prefix is not recognized
|
|
Exception inner = ex.InnerException;
|
|
Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
|
|
Assert.IsNull (inner.InnerException, "#8");
|
|
Assert.IsNotNull (inner.Message, "#9");
|
|
}
|
|
}
|
|
|
|
[Test] // OpenWrite (string)
|
|
public void OpenWrite1_Address_Null ()
|
|
{
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.OpenWrite ((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 ("address", ex.ParamName, "#6");
|
|
}
|
|
}
|
|
|
|
[Test] // OpenWrite (string)
|
|
public void OpenWrite1_Address_SchemeNotSupported ()
|
|
{
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.OpenWrite ("tp://scheme.notsupported");
|
|
Assert.Fail ("#1");
|
|
} catch (WebException ex) {
|
|
// An error occurred performing a WebClient request
|
|
Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
|
|
Assert.IsNotNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.IsNull (ex.Response, "#5");
|
|
Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
|
|
|
|
// The URI prefix is not recognized
|
|
Exception inner = ex.InnerException;
|
|
Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
|
|
Assert.IsNull (inner.InnerException, "#8");
|
|
Assert.IsNotNull (inner.Message, "#9");
|
|
}
|
|
}
|
|
|
|
[Test] // OpenWrite (string, string)
|
|
public void OpenWrite2_Address_Null ()
|
|
{
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.OpenWrite ((string) null, "PUT");
|
|
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 ("address", ex.ParamName, "#6");
|
|
}
|
|
}
|
|
|
|
[Test] // OpenWrite (string, string)
|
|
public void OpenWrite2_Address_SchemeNotSupported ()
|
|
{
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.OpenWrite ("tp://scheme.notsupported", "PUT");
|
|
Assert.Fail ("#1");
|
|
} catch (WebException ex) {
|
|
// An error occurred performing a WebClient request
|
|
Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
|
|
Assert.IsNotNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.IsNull (ex.Response, "#5");
|
|
Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
|
|
|
|
// The URI prefix is not recognized
|
|
Exception inner = ex.InnerException;
|
|
Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
|
|
Assert.IsNull (inner.InnerException, "#8");
|
|
Assert.IsNotNull (inner.Message, "#9");
|
|
}
|
|
}
|
|
|
|
[Test] // OpenWrite (Uri)
|
|
public void OpenWrite3_Address_Null ()
|
|
{
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.OpenWrite ((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 ("address", ex.ParamName, "#6");
|
|
}
|
|
}
|
|
|
|
[Test] // OpenWrite (Uri)
|
|
public void OpenWrite3_Address_SchemeNotSupported ()
|
|
{
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.OpenWrite (new Uri ("tp://scheme.notsupported"));
|
|
Assert.Fail ("#1");
|
|
} catch (WebException ex) {
|
|
// An error occurred performing a WebClient request
|
|
Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
|
|
Assert.IsNotNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.IsNull (ex.Response, "#5");
|
|
Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
|
|
|
|
// The URI prefix is not recognized
|
|
Exception inner = ex.InnerException;
|
|
Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
|
|
Assert.IsNull (inner.InnerException, "#8");
|
|
Assert.IsNotNull (inner.Message, "#9");
|
|
}
|
|
}
|
|
|
|
[Test] // OpenWrite (Uri, string)
|
|
public void OpenWrite4_Address_Null ()
|
|
{
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.OpenWrite ((Uri) null, "POST");
|
|
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 ("address", ex.ParamName, "#6");
|
|
}
|
|
}
|
|
|
|
[Test] // OpenWrite (Uri, string)
|
|
public void OpenWrite4_Address_SchemeNotSupported ()
|
|
{
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.OpenWrite (new Uri ("tp://scheme.notsupported"),
|
|
"POST");
|
|
Assert.Fail ("#1");
|
|
} catch (WebException ex) {
|
|
// An error occurred performing a WebClient request
|
|
Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
|
|
Assert.IsNotNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.IsNull (ex.Response, "#5");
|
|
Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
|
|
|
|
// The URI prefix is not recognized
|
|
Exception inner = ex.InnerException;
|
|
Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
|
|
Assert.IsNull (inner.InnerException, "#8");
|
|
Assert.IsNotNull (inner.Message, "#9");
|
|
}
|
|
}
|
|
|
|
[Test] // UploadData (string, byte [])
|
|
public void UploadData1_Address_Null ()
|
|
{
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.UploadData ((string) null, new byte [] { 0x1a });
|
|
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 ("address", ex.ParamName, "#6");
|
|
}
|
|
}
|
|
|
|
[Test] // UploadData (string, byte [])
|
|
public void UploadData1_Address_SchemeNotSupported ()
|
|
{
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.UploadData ("tp://scheme.notsupported", new byte [] { 0x1a });
|
|
Assert.Fail ("#1");
|
|
} catch (WebException ex) {
|
|
// An error occurred performing a WebClient request
|
|
Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
|
|
Assert.IsNotNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.IsNull (ex.Response, "#5");
|
|
Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
|
|
|
|
// The URI prefix is not recognized
|
|
Exception inner = ex.InnerException;
|
|
Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
|
|
Assert.IsNull (inner.InnerException, "#8");
|
|
Assert.IsNotNull (inner.Message, "#9");
|
|
}
|
|
}
|
|
|
|
[Test] // UploadData (string, byte [])
|
|
public void UploadData1_Data_Null ()
|
|
{
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.UploadData ("http://www.mono-project.com",
|
|
(byte []) 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 ("data", ex.ParamName, "#6");
|
|
}
|
|
}
|
|
|
|
[Test] // UploadData (Uri, byte [])
|
|
public void UploadData2_Address_Null ()
|
|
{
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.UploadData ((Uri) null, new byte [] { 0x1a });
|
|
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 ("address", ex.ParamName, "#6");
|
|
}
|
|
}
|
|
|
|
[Test] // UploadData (Uri, byte [])
|
|
public void UploadData2_Address_SchemeNotSupported ()
|
|
{
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.UploadData (new Uri ("tp://scheme.notsupported"),
|
|
new byte [] { 0x1a });
|
|
Assert.Fail ("#1");
|
|
} catch (WebException ex) {
|
|
// An error occurred performing a WebClient request
|
|
Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
|
|
Assert.IsNotNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.IsNull (ex.Response, "#5");
|
|
Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
|
|
|
|
// The URI prefix is not recognized
|
|
Exception inner = ex.InnerException;
|
|
Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
|
|
Assert.IsNull (inner.InnerException, "#8");
|
|
Assert.IsNotNull (inner.Message, "#9");
|
|
}
|
|
}
|
|
|
|
[Test] // UploadData (Uri, byte [])
|
|
public void UploadData2_Data_Null ()
|
|
{
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.UploadData (new Uri ("http://www.mono-project.com"),
|
|
(byte []) 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 ("data", ex.ParamName, "#6");
|
|
}
|
|
}
|
|
|
|
[Test] // UploadData (string, string, byte [])
|
|
public void UploadData3_Address_Null ()
|
|
{
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.UploadData ((string) null, "POST",
|
|
new byte [] { 0x1a });
|
|
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 ("address", ex.ParamName, "#6");
|
|
}
|
|
}
|
|
|
|
[Test] // UploadData (string, string, byte [])
|
|
public void UploadData3_Address_SchemeNotSupported ()
|
|
{
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.UploadData ("tp://scheme.notsupported",
|
|
"POST", new byte [] { 0x1a });
|
|
Assert.Fail ("#1");
|
|
} catch (WebException ex) {
|
|
// An error occurred performing a WebClient request
|
|
Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
|
|
Assert.IsNotNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.IsNull (ex.Response, "#5");
|
|
Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
|
|
|
|
// The URI prefix is not recognized
|
|
Exception inner = ex.InnerException;
|
|
Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
|
|
Assert.IsNull (inner.InnerException, "#8");
|
|
Assert.IsNotNull (inner.Message, "#9");
|
|
}
|
|
}
|
|
|
|
[Test] // UploadData (string, string, byte [])
|
|
public void UploadData3_Data_Null ()
|
|
{
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.UploadData ("http://www.mono-project.com",
|
|
"POST", (byte []) 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 ("data", ex.ParamName, "#6");
|
|
}
|
|
}
|
|
|
|
[Test] // UploadData (Uri, string, byte [])
|
|
public void UploadData4_Address_Null ()
|
|
{
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.UploadData ((Uri) null, "POST", new byte [] { 0x1a });
|
|
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 ("address", ex.ParamName, "#6");
|
|
}
|
|
}
|
|
|
|
[Test] // UploadData (Uri, string, byte [])
|
|
public void UploadData4_Address_SchemeNotSupported ()
|
|
{
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.UploadData (new Uri ("tp://scheme.notsupported"),
|
|
"POST", new byte [] { 0x1a });
|
|
Assert.Fail ("#1");
|
|
} catch (WebException ex) {
|
|
// An error occurred performing a WebClient request
|
|
Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
|
|
Assert.IsNotNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.IsNull (ex.Response, "#5");
|
|
Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
|
|
|
|
// The URI prefix is not recognized
|
|
Exception inner = ex.InnerException;
|
|
Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
|
|
Assert.IsNull (inner.InnerException, "#8");
|
|
Assert.IsNotNull (inner.Message, "#9");
|
|
}
|
|
}
|
|
|
|
[Test] // UploadData (Uri, string, byte [])
|
|
public void UploadData4_Data_Null ()
|
|
{
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.UploadData (new Uri ("http://www.mono-project.com"),
|
|
"POST", (byte []) 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 ("data", ex.ParamName, "#6");
|
|
}
|
|
}
|
|
|
|
[Test] // UploadFile (string, string)
|
|
public void UploadFile1_Address_Null ()
|
|
{
|
|
string tempFile = Path.Combine (_tempFolder, "upload.tmp");
|
|
File.Create (tempFile).Close ();
|
|
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.UploadFile ((string) null, tempFile);
|
|
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 ("address", ex.ParamName, "#6");
|
|
}
|
|
}
|
|
|
|
[Test] // UploadFile (string, string)
|
|
public void UploadFile1_Address_SchemeNotSupported ()
|
|
{
|
|
string tempFile = Path.Combine (_tempFolder, "upload.tmp");
|
|
File.Create (tempFile).Close ();
|
|
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.UploadFile ("tp://scheme.notsupported",
|
|
tempFile);
|
|
Assert.Fail ("#1");
|
|
} catch (WebException ex) {
|
|
// An error occurred performing a WebClient request
|
|
Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
|
|
Assert.IsNotNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.IsNull (ex.Response, "#5");
|
|
Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
|
|
|
|
// The URI prefix is not recognized
|
|
Exception inner = ex.InnerException;
|
|
Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
|
|
Assert.IsNull (inner.InnerException, "#8");
|
|
Assert.IsNotNull (inner.Message, "#9");
|
|
}
|
|
}
|
|
|
|
[Test] // UploadFile (string, string)
|
|
public void UploadFile1_FileName_NotFound ()
|
|
{
|
|
string tempFile = Path.Combine (_tempFolder, "upload.tmp");
|
|
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.UploadFile ("tp://scheme.notsupported",
|
|
tempFile);
|
|
Assert.Fail ("#1");
|
|
} catch (WebException ex) {
|
|
// An error occurred performing a WebClient request
|
|
Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
|
|
Assert.IsNotNull (ex.Message, "#3");
|
|
Assert.IsNull (ex.Response, "#4");
|
|
Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#5");
|
|
|
|
// Could not find file "..."
|
|
FileNotFoundException inner = ex.InnerException
|
|
as FileNotFoundException;
|
|
Assert.IsNotNull (inner, "#6");
|
|
Assert.AreEqual (typeof (FileNotFoundException), inner.GetType (), "#7");
|
|
Assert.IsNotNull (inner.FileName, "#8");
|
|
Assert.AreEqual (tempFile, inner.FileName, "#9");
|
|
Assert.IsNull (inner.InnerException, "#10");
|
|
Assert.IsNotNull (inner.Message, "#11");
|
|
}
|
|
}
|
|
|
|
[Test] // UploadFile (string, string)
|
|
public void UploadFile1_FileName_Null ()
|
|
{
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.UploadFile ("tp://scheme.notsupported",
|
|
(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 ("fileName", ex.ParamName, "#6");
|
|
}
|
|
}
|
|
|
|
[Test] // UploadFile (Uri, string)
|
|
public void UploadFile2_Address_Null ()
|
|
{
|
|
string tempFile = Path.Combine (_tempFolder, "upload.tmp");
|
|
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.UploadFile ((Uri) null, tempFile);
|
|
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 ("address", ex.ParamName, "#6");
|
|
}
|
|
}
|
|
|
|
[Test] // UploadFile (Uri, string)
|
|
public void UploadFile2_Address_SchemeNotSupported ()
|
|
{
|
|
string tempFile = Path.Combine (_tempFolder, "upload.tmp");
|
|
File.Create (tempFile).Close ();
|
|
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.UploadFile (new Uri ("tp://scheme.notsupported"),
|
|
tempFile);
|
|
Assert.Fail ("#1");
|
|
} catch (WebException ex) {
|
|
// An error occurred performing a WebClient request
|
|
Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
|
|
Assert.IsNotNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.IsNull (ex.Response, "#5");
|
|
Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
|
|
|
|
// The URI prefix is not recognized
|
|
Exception inner = ex.InnerException;
|
|
Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
|
|
Assert.IsNull (inner.InnerException, "#8");
|
|
Assert.IsNotNull (inner.Message, "#9");
|
|
}
|
|
}
|
|
|
|
[Test] // UploadFile (Uri, string)
|
|
public void UploadFile2_FileName_NotFound ()
|
|
{
|
|
string tempFile = Path.Combine (_tempFolder, "upload.tmp");
|
|
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.UploadFile (new Uri ("tp://scheme.notsupported"),
|
|
tempFile);
|
|
Assert.Fail ("#1");
|
|
} catch (WebException ex) {
|
|
// An error occurred performing a WebClient request
|
|
Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
|
|
Assert.IsNotNull (ex.Message, "#3");
|
|
Assert.IsNull (ex.Response, "#4");
|
|
Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#5");
|
|
|
|
// Could not find file "..."
|
|
FileNotFoundException inner = ex.InnerException
|
|
as FileNotFoundException;
|
|
Assert.IsNotNull (inner, "#6");
|
|
Assert.AreEqual (typeof (FileNotFoundException), inner.GetType (), "#7");
|
|
Assert.IsNotNull (inner.FileName, "#8");
|
|
Assert.AreEqual (tempFile, inner.FileName, "#9");
|
|
Assert.IsNull (inner.InnerException, "#10");
|
|
Assert.IsNotNull (inner.Message, "#11");
|
|
}
|
|
}
|
|
|
|
[Test] // UploadFile (Uri, string)
|
|
public void UploadFile2_FileName_Null ()
|
|
{
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.UploadFile (new Uri ("tp://scheme.notsupported"),
|
|
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 ("fileName", ex.ParamName, "#6");
|
|
}
|
|
}
|
|
|
|
[Test] // UploadFile (string, string, string)
|
|
public void UploadFile3_Address_Null ()
|
|
{
|
|
string tempFile = Path.Combine (_tempFolder, "upload.tmp");
|
|
File.Create (tempFile).Close ();
|
|
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.UploadFile ((string) null, "POST", tempFile);
|
|
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 ("path", ex.ParamName, "#6");
|
|
}
|
|
}
|
|
|
|
[Test] // UploadFile (string, string, string)
|
|
public void UploadFile3_Address_SchemeNotSupported ()
|
|
{
|
|
string tempFile = Path.Combine (_tempFolder, "upload.tmp");
|
|
File.Create (tempFile).Close ();
|
|
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.UploadFile ("tp://scheme.notsupported",
|
|
"POST", tempFile);
|
|
Assert.Fail ("#1");
|
|
} catch (WebException ex) {
|
|
// An error occurred performing a WebClient request
|
|
Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
|
|
Assert.IsNotNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.IsNull (ex.Response, "#5");
|
|
Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
|
|
|
|
// The URI prefix is not recognized
|
|
Exception inner = ex.InnerException;
|
|
Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
|
|
Assert.IsNull (inner.InnerException, "#8");
|
|
Assert.IsNotNull (inner.Message, "#9");
|
|
}
|
|
}
|
|
|
|
[Test] // UploadFile (string, string, string)
|
|
public void UploadFile3_FileName_NotFound ()
|
|
{
|
|
string tempFile = Path.Combine (_tempFolder, "upload.tmp");
|
|
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.UploadFile ("tp://scheme.notsupported",
|
|
"POST", tempFile);
|
|
Assert.Fail ("#1");
|
|
} catch (WebException ex) {
|
|
// An error occurred performing a WebClient request
|
|
Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
|
|
Assert.IsNotNull (ex.Message, "#3");
|
|
Assert.IsNull (ex.Response, "#4");
|
|
Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#5");
|
|
|
|
// Could not find file "..."
|
|
FileNotFoundException inner = ex.InnerException
|
|
as FileNotFoundException;
|
|
Assert.IsNotNull (inner, "#6");
|
|
Assert.AreEqual (typeof (FileNotFoundException), inner.GetType (), "#7");
|
|
Assert.IsNotNull (inner.FileName, "#8");
|
|
Assert.AreEqual (tempFile, inner.FileName, "#9");
|
|
Assert.IsNull (inner.InnerException, "#10");
|
|
Assert.IsNotNull (inner.Message, "#11");
|
|
}
|
|
}
|
|
|
|
[Test] // UploadFile (string, string, string)
|
|
public void UploadFile3_FileName_Null ()
|
|
{
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.UploadFile ("tp://scheme.notsupported",
|
|
"POST", (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 ("fileName", ex.ParamName, "#6");
|
|
}
|
|
}
|
|
|
|
[Test] // UploadFile (Uri, string, string)
|
|
public void UploadFile4_Address_Null ()
|
|
{
|
|
string tempFile = Path.Combine (_tempFolder, "upload.tmp");
|
|
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.UploadFile ((Uri) null, "POST", tempFile);
|
|
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 ("address", ex.ParamName, "#6");
|
|
}
|
|
}
|
|
|
|
[Test] // UploadFile (Uri, string, string)
|
|
public void UploadFile4_Address_SchemeNotSupported ()
|
|
{
|
|
string tempFile = Path.Combine (_tempFolder, "upload.tmp");
|
|
File.Create (tempFile).Close ();
|
|
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.UploadFile (new Uri ("tp://scheme.notsupported"),
|
|
"POST", tempFile);
|
|
Assert.Fail ("#1");
|
|
} catch (WebException ex) {
|
|
// An error occurred performing a WebClient request
|
|
Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
|
|
Assert.IsNotNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.IsNull (ex.Response, "#5");
|
|
Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
|
|
|
|
// The URI prefix is not recognized
|
|
Exception inner = ex.InnerException;
|
|
Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
|
|
Assert.IsNull (inner.InnerException, "#8");
|
|
Assert.IsNotNull (inner.Message, "#9");
|
|
}
|
|
}
|
|
|
|
[Test] // UploadFile (Uri, string, string)
|
|
public void UploadFile4_FileName_NotFound ()
|
|
{
|
|
string tempFile = Path.Combine (_tempFolder, "upload.tmp");
|
|
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.UploadFile (new Uri ("tp://scheme.notsupported"),
|
|
"POST", tempFile);
|
|
Assert.Fail ("#1");
|
|
} catch (WebException ex) {
|
|
// An error occurred performing a WebClient request
|
|
Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
|
|
Assert.IsNotNull (ex.Message, "#3");
|
|
Assert.IsNull (ex.Response, "#4");
|
|
Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#5");
|
|
|
|
// Could not find file "..."
|
|
FileNotFoundException inner = ex.InnerException
|
|
as FileNotFoundException;
|
|
Assert.IsNotNull (inner, "#6");
|
|
Assert.AreEqual (typeof (FileNotFoundException), inner.GetType (), "#7");
|
|
Assert.IsNotNull (inner.FileName, "#8");
|
|
Assert.AreEqual (tempFile, inner.FileName, "#9");
|
|
Assert.IsNull (inner.InnerException, "#10");
|
|
Assert.IsNotNull (inner.Message, "#11");
|
|
}
|
|
}
|
|
|
|
[Test] // UploadFile (Uri, string, string)
|
|
public void UploadFile4_FileName_Null ()
|
|
{
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.UploadFile (new Uri ("tp://scheme.notsupported"),
|
|
"POST", (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 ("fileName", ex.ParamName, "#6");
|
|
}
|
|
}
|
|
|
|
[Test] // UploadString (string, string)
|
|
public void UploadString1_Address_Null ()
|
|
{
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.UploadString ((string) null, (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 ("address", ex.ParamName, "#6");
|
|
}
|
|
}
|
|
|
|
[Test] // UploadString (string, string)
|
|
public void UploadString1_Address_SchemeNotSupported ()
|
|
{
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.UploadString ("tp://scheme.notsupported", "abc");
|
|
Assert.Fail ("#1");
|
|
} catch (WebException ex) {
|
|
// An error occurred performing a WebClient request
|
|
Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
|
|
Assert.IsNotNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.IsNull (ex.Response, "#5");
|
|
Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
|
|
|
|
// The URI prefix is not recognized
|
|
Exception inner = ex.InnerException;
|
|
Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
|
|
Assert.IsNull (inner.InnerException, "#8");
|
|
Assert.IsNotNull (inner.Message, "#9");
|
|
}
|
|
}
|
|
|
|
[Test] // UploadString (string, string)
|
|
public void UploadString1_Data_Null ()
|
|
{
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.UploadString ("tp://scheme.notsupported", (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 ("data", ex.ParamName, "#6");
|
|
}
|
|
}
|
|
|
|
[Test] // UploadString (Uri, string)
|
|
public void UploadString2_Address_Null ()
|
|
{
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.UploadString ((Uri) null, (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 ("address", ex.ParamName, "#6");
|
|
}
|
|
}
|
|
|
|
[Test] // UploadString (Uri, string)
|
|
public void UploadString2_Address_SchemeNotSupported ()
|
|
{
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.UploadString (new Uri ("tp://scheme.notsupported"), "abc");
|
|
Assert.Fail ("#1");
|
|
} catch (WebException ex) {
|
|
// An error occurred performing a WebClient request
|
|
Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
|
|
Assert.IsNotNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.IsNull (ex.Response, "#5");
|
|
Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
|
|
|
|
// The URI prefix is not recognized
|
|
Exception inner = ex.InnerException;
|
|
Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
|
|
Assert.IsNull (inner.InnerException, "#8");
|
|
Assert.IsNotNull (inner.Message, "#9");
|
|
}
|
|
}
|
|
|
|
[Test] // UploadString (Uri, string)
|
|
public void UploadString2_Data_Null ()
|
|
{
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.UploadString (new Uri ("tp://scheme.notsupported"),
|
|
(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 ("data", ex.ParamName, "#6");
|
|
}
|
|
}
|
|
|
|
[Test] // UploadString (string, string, string)
|
|
public void UploadString3_Address_Null ()
|
|
{
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.UploadString ((string) null, (string) null,
|
|
(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 ("address", ex.ParamName, "#6");
|
|
}
|
|
}
|
|
|
|
[Test] // UploadString (string, string, string)
|
|
public void UploadString3_Address_SchemeNotSupported ()
|
|
{
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.UploadString ("tp://scheme.notsupported",
|
|
"POST", "abc");
|
|
Assert.Fail ("#1");
|
|
} catch (WebException ex) {
|
|
// An error occurred performing a WebClient request
|
|
Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
|
|
Assert.IsNotNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.IsNull (ex.Response, "#5");
|
|
Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
|
|
|
|
// The URI prefix is not recognized
|
|
Exception inner = ex.InnerException;
|
|
Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
|
|
Assert.IsNull (inner.InnerException, "#8");
|
|
Assert.IsNotNull (inner.Message, "#9");
|
|
}
|
|
}
|
|
|
|
[Test] // UploadString (string, string, string)
|
|
public void UploadString3_Data_Null ()
|
|
{
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.UploadString ("tp://scheme.notsupported",
|
|
"POST", (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 ("data", ex.ParamName, "#6");
|
|
}
|
|
}
|
|
|
|
[Test] // UploadString (Uri, string, string)
|
|
public void UploadString4_Address_Null ()
|
|
{
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.UploadString ((Uri) null, (string) null,
|
|
(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 ("address", ex.ParamName, "#6");
|
|
}
|
|
}
|
|
|
|
[Test] // UploadString (Uri, string, string)
|
|
public void UploadString4_Address_SchemeNotSupported ()
|
|
{
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.UploadString (new Uri ("tp://scheme.notsupported"),
|
|
"POST", "abc");
|
|
Assert.Fail ("#1");
|
|
} catch (WebException ex) {
|
|
// An error occurred performing a WebClient request
|
|
Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
|
|
Assert.IsNotNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.IsNull (ex.Response, "#5");
|
|
Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
|
|
|
|
// The URI prefix is not recognized
|
|
Exception inner = ex.InnerException;
|
|
Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
|
|
Assert.IsNull (inner.InnerException, "#8");
|
|
Assert.IsNotNull (inner.Message, "#9");
|
|
}
|
|
}
|
|
|
|
[Test] // UploadString (Uri, string, string)
|
|
public void UploadString4_Data_Null ()
|
|
{
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.UploadString (new Uri ("tp://scheme.notsupported"),
|
|
"POST", (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 ("data", ex.ParamName, "#6");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
[Category ("AndroidNotWorking")] // Fails when ran as part of the entire BCL test suite. Works when only this fixture is ran
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#endif
|
|
public void UploadValues1 ()
|
|
{
|
|
IPEndPoint ep = NetworkHelpers.LocalEphemeralEndPoint ();
|
|
string url = "http://" + ep.ToString () + "/test/";
|
|
|
|
using (SocketResponder responder = new SocketResponder (ep, s => EchoRequestHandler (s))) {
|
|
WebClient wc = new WebClient ();
|
|
wc.Encoding = Encoding.ASCII;
|
|
|
|
NameValueCollection nvc = new NameValueCollection ();
|
|
nvc.Add ("Name", "\u0041\u2262\u0391\u002E");
|
|
nvc.Add ("Address", "\u002E\u2262\u0041\u0391");
|
|
|
|
byte [] buffer = wc.UploadValues (url, nvc);
|
|
string response = Encoding.UTF8.GetString (buffer);
|
|
Assert.AreEqual ("Name=A%e2%89%a2%ce%91.&Address=.%e2%89%a2A%ce%91\r\n", response);
|
|
}
|
|
}
|
|
|
|
[Test] // UploadValues (string, NameValueCollection)
|
|
public void UploadValues1_Address_Null ()
|
|
{
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.UploadValues ((string) null, new NameValueCollection ());
|
|
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 ("address", ex.ParamName, "#6");
|
|
}
|
|
}
|
|
|
|
[Test] // UploadValues (string, NameValueCollection)
|
|
public void UploadValues1_Address_SchemeNotSupported ()
|
|
{
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.UploadValues ("tp://scheme.notsupported",
|
|
new NameValueCollection ());
|
|
Assert.Fail ("#1");
|
|
} catch (WebException ex) {
|
|
// An error occurred performing a WebClient request
|
|
Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
|
|
Assert.IsNotNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.IsNull (ex.Response, "#5");
|
|
Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
|
|
|
|
// The URI prefix is not recognized
|
|
Exception inner = ex.InnerException;
|
|
Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
|
|
Assert.IsNull (inner.InnerException, "#8");
|
|
Assert.IsNotNull (inner.Message, "#9");
|
|
}
|
|
}
|
|
|
|
[Test] // UploadValues (string, NameValueCollection)
|
|
public void UploadValues1_Data_Null ()
|
|
{
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.UploadValues ("http://www.mono-project.com",
|
|
(NameValueCollection) 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 ("data", ex.ParamName, "#6");
|
|
}
|
|
}
|
|
|
|
[Test] // UploadValues (Uri, NameValueCollection)
|
|
public void UploadValues2_Address_Null ()
|
|
{
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.UploadValues ((Uri) null, new NameValueCollection ());
|
|
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 ("address", ex.ParamName, "#6");
|
|
}
|
|
}
|
|
|
|
[Test] // UploadValues (Uri, NameValueCollection)
|
|
public void UploadValues2_Address_SchemeNotSupported ()
|
|
{
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.UploadValues (new Uri ("tp://scheme.notsupported"),
|
|
new NameValueCollection ());
|
|
Assert.Fail ("#1");
|
|
} catch (WebException ex) {
|
|
// An error occurred performing a WebClient request
|
|
Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
|
|
Assert.IsNotNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.IsNull (ex.Response, "#5");
|
|
Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
|
|
|
|
// The URI prefix is not recognized
|
|
Exception inner = ex.InnerException;
|
|
Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
|
|
Assert.IsNull (inner.InnerException, "#8");
|
|
Assert.IsNotNull (inner.Message, "#9");
|
|
}
|
|
}
|
|
|
|
[Test] // UploadValues (Uri, NameValueCollection)
|
|
public void UploadValues2_Data_Null ()
|
|
{
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.UploadValues (new Uri ("http://www.mono-project.com"),
|
|
(NameValueCollection) 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 ("data", ex.ParamName, "#6");
|
|
}
|
|
}
|
|
|
|
[Test] // UploadValues (string, string, NameValueCollection)
|
|
public void UploadValues3_Address_Null ()
|
|
{
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.UploadValues ((string) null, "POST",
|
|
new NameValueCollection ());
|
|
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 ("address", ex.ParamName, "#6");
|
|
}
|
|
}
|
|
|
|
[Test] // UploadValues (string, string, NameValueCollection)
|
|
public void UploadValues3_Address_SchemeNotSupported ()
|
|
{
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.UploadValues ("tp://scheme.notsupported",
|
|
"POST", new NameValueCollection ());
|
|
Assert.Fail ("#1");
|
|
} catch (WebException ex) {
|
|
// An error occurred performing a WebClient request
|
|
Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
|
|
Assert.IsNotNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.IsNull (ex.Response, "#5");
|
|
Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
|
|
|
|
// The URI prefix is not recognized
|
|
Exception inner = ex.InnerException;
|
|
Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
|
|
Assert.IsNull (inner.InnerException, "#8");
|
|
Assert.IsNotNull (inner.Message, "#9");
|
|
}
|
|
}
|
|
|
|
[Test] // UploadValues (string, string, NameValueCollection)
|
|
public void UploadValues3_Data_Null ()
|
|
{
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.UploadValues ("http://www.mono-project.com",
|
|
"POST", (NameValueCollection) 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 ("data", ex.ParamName, "#6");
|
|
}
|
|
}
|
|
|
|
[Test] // UploadValues (Uri, string, NameValueCollection)
|
|
public void UploadValues4_Address_Null ()
|
|
{
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.UploadValues ((Uri) null, "POST",
|
|
new NameValueCollection ());
|
|
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 ("address", ex.ParamName, "#6");
|
|
}
|
|
}
|
|
|
|
[Test] // UploadValues (Uri, string, NameValueCollection)
|
|
public void UploadValues4_Address_SchemeNotSupported ()
|
|
{
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.UploadValues (new Uri ("tp://scheme.notsupported"),
|
|
"POST", new NameValueCollection ());
|
|
Assert.Fail ("#1");
|
|
} catch (WebException ex) {
|
|
// An error occurred performing a WebClient request
|
|
Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
|
|
Assert.IsNotNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.IsNull (ex.Response, "#5");
|
|
Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
|
|
|
|
// The URI prefix is not recognized
|
|
Exception inner = ex.InnerException;
|
|
Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
|
|
Assert.IsNull (inner.InnerException, "#8");
|
|
Assert.IsNotNull (inner.Message, "#9");
|
|
}
|
|
}
|
|
|
|
[Test] // UploadValues (Uri, string, NameValueCollection)
|
|
public void UploadValues4_Data_Null ()
|
|
{
|
|
WebClient wc = new WebClient ();
|
|
try {
|
|
wc.UploadValues (new Uri ("http://www.mono-project.com"),
|
|
"POST", (NameValueCollection) 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 ("data", ex.ParamName, "#6");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
// We throw a PlatformNotSupportedException deeper, which is caught and re-thrown as WebException
|
|
[ExpectedException (typeof (WebException))]
|
|
#endif
|
|
public void GetWebRequestOverriding ()
|
|
{
|
|
GetWebRequestOverridingTestClass testObject = new GetWebRequestOverridingTestClass ();
|
|
testObject.DownloadData ("http://www.mono-project.com");
|
|
|
|
Assert.IsTrue (testObject.overridedCodeRan, "Overrided code wasn't called");
|
|
}
|
|
|
|
class GetWebRequestOverridingTestClass : WebClient
|
|
{
|
|
internal bool overridedCodeRan = false;
|
|
protected override WebRequest GetWebRequest(Uri address)
|
|
{
|
|
overridedCodeRan = true;
|
|
return base.GetWebRequest (address);
|
|
}
|
|
}
|
|
|
|
static byte [] EchoRequestHandler (Socket socket)
|
|
{
|
|
MemoryStream ms = new MemoryStream ();
|
|
byte [] buffer = new byte [4096];
|
|
int bytesReceived = socket.Receive (buffer);
|
|
while (bytesReceived > 0) {
|
|
ms.Write (buffer, 0, bytesReceived);
|
|
// We don't check for Content-Length or anything else here, so we give the client a little time to write
|
|
// after sending the headers
|
|
Thread.Sleep (200);
|
|
if (socket.Available > 0) {
|
|
bytesReceived = socket.Receive (buffer);
|
|
} else {
|
|
bytesReceived = 0;
|
|
}
|
|
}
|
|
ms.Flush ();
|
|
ms.Position = 0;
|
|
|
|
StringBuilder sb = new StringBuilder ();
|
|
|
|
string expect = null;
|
|
|
|
StreamReader sr = new StreamReader (ms, Encoding.UTF8);
|
|
string line = null;
|
|
byte state = 0;
|
|
while ((line = sr.ReadLine ()) != null) {
|
|
if (state > 0) {
|
|
state = 2;
|
|
sb.Append (line);
|
|
sb.Append ("\r\n");
|
|
} if (line.Length == 0) {
|
|
state = 1;
|
|
} else if (line.StartsWith ("Expect:")) {
|
|
expect = line.Substring (8);
|
|
}
|
|
}
|
|
|
|
StringWriter sw = new StringWriter ();
|
|
|
|
if (expect == "100-continue" && state != 2) {
|
|
sw.WriteLine ("HTTP/1.1 100 Continue");
|
|
sw.WriteLine ();
|
|
sw.Flush ();
|
|
|
|
socket.Send (Encoding.UTF8.GetBytes (sw.ToString ()));
|
|
|
|
// receive body
|
|
ms = new MemoryStream ();
|
|
buffer = new byte [4096];
|
|
bytesReceived = socket.Receive (buffer);
|
|
while (bytesReceived > 0) {
|
|
ms.Write (buffer, 0, bytesReceived);
|
|
Thread.Sleep (200);
|
|
if (socket.Available > 0) {
|
|
bytesReceived = socket.Receive (buffer);
|
|
} else {
|
|
bytesReceived = 0;
|
|
}
|
|
}
|
|
ms.Flush ();
|
|
ms.Position = 0;
|
|
|
|
sb = new StringBuilder ();
|
|
sr = new StreamReader (ms, Encoding.UTF8);
|
|
line = sr.ReadLine ();
|
|
while (line != null) {
|
|
sb.Append (line);
|
|
sb.Append ("\r\n");
|
|
line = sr.ReadLine ();
|
|
}
|
|
}
|
|
|
|
sw = new StringWriter ();
|
|
sw.WriteLine ("HTTP/1.1 200 OK");
|
|
sw.WriteLine ("Content-Type: text/xml");
|
|
sw.WriteLine ("Content-Length: " + sb.Length.ToString (CultureInfo.InvariantCulture));
|
|
sw.WriteLine ();
|
|
sw.Write (sb.ToString ());
|
|
sw.Flush ();
|
|
|
|
return Encoding.UTF8.GetBytes (sw.ToString ());
|
|
}
|
|
|
|
[Test]
|
|
public void DefaultProxy ()
|
|
{
|
|
WebClient wc = new WebClient ();
|
|
// this is never null on .net
|
|
Assert.IsNotNull (wc.Proxy);
|
|
// and return the same instance as WebRequest.DefaultWebProxy
|
|
Assert.AreSame (wc.Proxy, WebRequest.DefaultWebProxy);
|
|
}
|
|
|
|
[Test]
|
|
[Category ("AndroidNotWorking")] // Fails when ran as part of the entire BCL test suite. Works when only this fixture is ran
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#endif
|
|
public void UploadStringAsyncCancelEvent ()
|
|
{
|
|
UploadAsyncCancelEventTest (9301, (webClient, uri, cancelEvent) =>
|
|
{
|
|
|
|
webClient.UploadStringCompleted += (sender, args) =>
|
|
{
|
|
if (args.Cancelled)
|
|
cancelEvent.Set ();
|
|
};
|
|
|
|
webClient.UploadStringAsync (uri, "PUT", "text");
|
|
});
|
|
}
|
|
|
|
[Test]
|
|
[Category ("AndroidNotWorking")] // Fails when ran as part of the entire BCL test suite. Works when only this fixture is ran
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#endif
|
|
public void UploadDataAsyncCancelEvent ()
|
|
{
|
|
UploadAsyncCancelEventTest (9302, (webClient, uri, cancelEvent) =>
|
|
{
|
|
webClient.UploadDataCompleted += (sender, args) =>
|
|
{
|
|
if (args.Cancelled)
|
|
cancelEvent.Set ();
|
|
};
|
|
|
|
webClient.UploadDataAsync (uri, "PUT", new byte[] { });
|
|
});
|
|
}
|
|
|
|
[Test]
|
|
[Category ("AndroidNotWorking")] // Fails when ran as part of the entire BCL test suite. Works when only this fixture is ran
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#endif
|
|
public void UploadValuesAsyncCancelEvent ()
|
|
{
|
|
UploadAsyncCancelEventTest (9303, (webClient, uri, cancelEvent) =>
|
|
{
|
|
webClient.UploadValuesCompleted += (sender, args) =>
|
|
{
|
|
if (args.Cancelled)
|
|
cancelEvent.Set ();
|
|
};
|
|
|
|
webClient.UploadValuesAsync (uri, "PUT", new NameValueCollection ());
|
|
});
|
|
}
|
|
|
|
[Test]
|
|
[Category ("AndroidNotWorking")] // Fails when ran as part of the entire BCL test suite. Works when only this fixture is ran
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#endif
|
|
public void UploadFileAsyncCancelEvent ()
|
|
{
|
|
UploadAsyncCancelEventTest (9304,(webClient, uri, cancelEvent) =>
|
|
{
|
|
string tempFile = Path.Combine (_tempFolder, "upload.tmp");
|
|
File.Create (tempFile).Close ();
|
|
|
|
webClient.UploadFileCompleted += (sender, args) =>
|
|
{
|
|
if (args.Cancelled)
|
|
cancelEvent.Set ();
|
|
};
|
|
|
|
webClient.UploadFileAsync (uri, "PUT", tempFile);
|
|
});
|
|
}
|
|
|
|
[Test]
|
|
[Category ("AndroidNotWorking")] // Test suite hangs if the tests runs as part of the entire BCL suite. Works when only this fixture is ran
|
|
#if FEATURE_NO_BSD_SOCKETS
|
|
[ExpectedException (typeof (PlatformNotSupportedException))]
|
|
#endif
|
|
public void UploadFileAsyncContentType ()
|
|
{
|
|
var port = NetworkHelpers.FindFreePort ();
|
|
var serverUri = "http://localhost:" + port + "/";
|
|
var filename = Path.GetTempFileName ();
|
|
|
|
HttpListener listener = new HttpListener ();
|
|
listener.Prefixes.Add (serverUri);
|
|
listener.Start ();
|
|
|
|
using (var client = new WebClient ())
|
|
{
|
|
client.UploadFileTaskAsync (new Uri (serverUri), filename);
|
|
var request = listener.GetContext ().Request;
|
|
|
|
var expected = "multipart/form-data; boundary=---------------------";
|
|
Assert.AreEqual (expected.Length + 15, request.ContentType.Length);
|
|
Assert.AreEqual (expected, request.ContentType.Substring (0, expected.Length));
|
|
}
|
|
listener.Close ();
|
|
}
|
|
|
|
public void UploadAsyncCancelEventTest (int port, Action<WebClient, Uri, EventWaitHandle> uploadAction)
|
|
{
|
|
var ep = NetworkHelpers.LocalEphemeralEndPoint ();
|
|
string url = "http://" + ep.ToString() + "/test/";
|
|
|
|
using (var responder = new SocketResponder (ep, s => EchoRequestHandler (s)))
|
|
{
|
|
var webClient = new WebClient ();
|
|
|
|
var cancellationTokenSource = new CancellationTokenSource ();
|
|
cancellationTokenSource.Token.Register (webClient.CancelAsync);
|
|
|
|
var cancelEvent = new ManualResetEvent (false);
|
|
|
|
uploadAction.Invoke (webClient, new Uri (url), cancelEvent);
|
|
|
|
cancellationTokenSource.Cancel ();
|
|
|
|
Assert.IsTrue (cancelEvent.WaitOne (1000));
|
|
}
|
|
}
|
|
}
|
|
}
|