1899 lines
61 KiB
C#
1899 lines
61 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
|
|
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]
|
|
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);
|
|
}
|
|
|
|
#if NET_4_5
|
|
[Test]
|
|
[Category ("AndroidNotWorking")] // Fails when ran as part of the entire BCL test suite. Works when only this fixture is ran
|
|
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
|
|
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
|
|
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
|
|
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
|
|
public void UploadFileAsyncContentType ()
|
|
{
|
|
var serverUri = "http://localhost:13370/";
|
|
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 ();
|
|
}
|
|
#endif
|
|
|
|
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));
|
|
}
|
|
}
|
|
}
|
|
}
|