mcs/class/System/Test/System.Net/WebClientTest.cs

   1 //
   2 // WebClientTest.cs - NUnit Test Cases for System.Net.WebClient
   3 //
   4 // Copyright (C) 2007 Novell, Inc (http://www.novell.com)
   5 //
   6
   7 using System;
   8 using System.Collections;
   9 using System.Collections.Specialized;
  10 using System.Globalization;
  11 using System.IO;
  12 using System.Net;
  13 using System.Net.Sockets;
  14 using System.Runtime.Serialization;
  15 using System.Text;
  16 using System.Threading;
  17 using NUnit.Framework;
  18
  19 using MonoTests.Helpers;
  20
  21 namespace MonoTests.System.Net
  22 {
  23         [TestFixture]
  24         public class WebClientTest
  25         {
  26                 private string _tempFolder;
  27
  28                 [SetUp]
  29                 public void SetUp ()
  30                 {
  31                         _tempFolder = Path.Combine (Path.GetTempPath (),
  32                                 GetType ().FullName);
  33                         if (Directory.Exists (_tempFolder))
  34                                 Directory.Delete (_tempFolder, true);
  35                         Directory.CreateDirectory (_tempFolder);
  36                 }
  37
  38                 [TearDown]
  39                 public void TearDown ()
  40                 {
  41                         if (Directory.Exists (_tempFolder))
  42                                 Directory.Delete (_tempFolder, true);
  43                 }
  44
  45                 [Test]
  46                 [Category ("InetAccess")]
  47                 public void DownloadTwice ()
  48                 {
  49                         WebClient wc = new WebClient();
  50                         string filename = Path.GetTempFileName();
  51
  52                         // A new, but empty file has been created. This is a test case
  53                         // for bug 81005
  54                         wc.DownloadFile("http://google.com/", filename);
  55
  56                         // Now, remove the file and attempt to download again.
  57                         File.Delete(filename);
  58                         wc.DownloadFile("http://google.com/", filename);
  59                 }
  60
  61                 [Test]
  62                 public void DownloadData1_Address_Null ()
  63                 {
  64                         WebClient wc = new WebClient ();
  65                         try {
  66                                 wc.DownloadData ((string) null);
  67                                 Assert.Fail ("#1");
  68                         } catch (ArgumentNullException ex) {
  69                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
  70                                 Assert.IsNull (ex.InnerException, "#3");
  71                                 Assert.IsNotNull (ex.Message, "#4");
  72                                 Assert.IsNotNull (ex.ParamName, "#5");
  73                                 Assert.AreEqual ("address", ex.ParamName, "#6");
  74                         }
  75                 }
  76
  77                 [Test] // DownloadData (string)
  78                 public void DownloadData1_Address_SchemeNotSupported ()
  79                 {
  80                         WebClient wc = new WebClient ();
  81                         try {
  82                                 wc.DownloadData ("tp://scheme.notsupported");
  83                                 Assert.Fail ("#1");
  84                         } catch (WebException ex) {
  85                                 // An error occurred performing a WebClient request
  86                                 Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
  87                                 Assert.IsNotNull (ex.InnerException, "#3");
  88                                 Assert.IsNotNull (ex.Message, "#4");
  89                                 Assert.IsNull (ex.Response, "#5");
  90                                 Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
  91
  92                                 // The URI prefix is not recognized
  93                                 Exception inner = ex.InnerException;
  94                                 Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
  95                                 Assert.IsNull (inner.InnerException, "#8");
  96                                 Assert.IsNotNull (inner.Message, "#9");
  97                         }
  98                 }
  99
 100                 [Test] // DownloadData (Uri)
 101                 public void DownloadData2_Address_Null ()
 102                 {
 103                         WebClient wc = new WebClient ();
 104                         try {
 105                                 wc.DownloadData ((Uri) null);
 106                                 Assert.Fail ("#1");
 107                         } catch (ArgumentNullException ex) {
 108                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 109                                 Assert.IsNull (ex.InnerException, "#3");
 110                                 Assert.IsNotNull (ex.Message, "#4");
 111                                 Assert.IsNotNull (ex.ParamName, "#5");
 112                                 Assert.AreEqual ("address", ex.ParamName, "#6");
 113                         }
 114                 }
 115
 116                 [Test] // DownloadData (Uri)
 117                 public void DownloadData2_Address_SchemeNotSupported ()
 118                 {
 119                         WebClient wc = new WebClient ();
 120                         try {
 121                                 wc.DownloadData (new Uri ("tp://scheme.notsupported"));
 122                                 Assert.Fail ("#1");
 123                         } catch (WebException ex) {
 124                                 // An error occurred performing a WebClient request
 125                                 Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
 126                                 Assert.IsNotNull (ex.InnerException, "#3");
 127                                 Assert.IsNotNull (ex.Message, "#4");
 128                                 Assert.IsNull (ex.Response, "#5");
 129                                 Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
 130
 131                                 // The URI prefix is not recognized
 132                                 Exception inner = ex.InnerException;
 133                                 Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
 134                                 Assert.IsNull (inner.InnerException, "#8");
 135                                 Assert.IsNotNull (inner.Message, "#9");
 136                         }
 137                 }
 138
 139                 [Test]
 140                 public void DownloadFile1_Address_Null ()
 141                 {
 142                         WebClient wc = new WebClient ();
 143                         try {
 144                                 wc.DownloadFile ((string) null, "tmp.out");
 145                                 Assert.Fail ("#1");
 146                         } catch (ArgumentNullException ex) {
 147                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 148                                 Assert.IsNull (ex.InnerException, "#3");
 149                                 Assert.IsNotNull (ex.Message, "#4");
 150                                 Assert.IsNotNull (ex.ParamName, "#5");
 151                                 Assert.AreEqual ("address", ex.ParamName, "#6");
 152                         }
 153                 }
 154
 155                 [Test] // DownloadFile (string, string)
 156                 public void DownloadFile1_Address_SchemeNotSupported ()
 157                 {
 158                         string file = Path.Combine (Path.GetTempPath (), "tmp.out");
 159                         WebClient wc = new WebClient ();
 160                         try {
 161                                 wc.DownloadFile ("tp://scheme.notsupported", file);
 162                                 Assert.Fail ("#1");
 163                         } catch (WebException ex) {
 164                                 // An error occurred performing a WebClient request
 165                                 Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
 166                                 Assert.IsNotNull (ex.InnerException, "#3");
 167                                 Assert.IsNotNull (ex.Message, "#4");
 168                                 Assert.IsNull (ex.Response, "#5");
 169                                 Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
 170
 171                                 // The URI prefix is not recognized
 172                                 Exception inner = ex.InnerException;
 173                                 Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
 174                                 Assert.IsNull (inner.InnerException, "#8");
 175                                 Assert.IsNotNull (inner.Message, "#9");
 176                         }
 177                         finally {
 178                                 if (File.Exists (file))
 179                                         File.Delete (file);
 180                         }
 181                 }
 182
 183                 [Test] // DownloadFile (string, string)
 184                 public void DownloadFile1_FileName_Null ()
 185                 {
 186                         WebClient wc = new WebClient ();
 187                         try {
 188                                 wc.DownloadFile ("tp://scheme.notsupported",
 189                                         (string) null);
 190                                 Assert.Fail ("#1");
 191                         } catch (ArgumentNullException ex) {
 192                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 193                                 Assert.IsNull (ex.InnerException, "#3");
 194                                 Assert.IsNotNull (ex.Message, "#4");
 195                                 Assert.IsNotNull (ex.ParamName, "#5");
 196                                 Assert.AreEqual ("fileName", ex.ParamName, "#6");
 197                         }
 198                 }
 199
 200                 [Test] // DownloadFile (Uri, string)
 201                 public void DownloadFile2_Address_Null ()
 202                 {
 203                         WebClient wc = new WebClient ();
 204                         try {
 205                                 wc.DownloadFile ((Uri) null, "tmp.out");
 206                                 Assert.Fail ("#1");
 207                         } catch (ArgumentNullException ex) {
 208                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 209                                 Assert.IsNull (ex.InnerException, "#3");
 210                                 Assert.IsNotNull (ex.Message, "#4");
 211                                 Assert.IsNotNull (ex.ParamName, "#5");
 212                                 Assert.AreEqual ("address", ex.ParamName, "#6");
 213                         }
 214                 }
 215
 216                 [Test] // DownloadFile (Uri, string)
 217                 public void DownloadFile2_Address_SchemeNotSupported ()
 218                 {
 219                         string file = Path.Combine (Path.GetTempPath (), "tmp.out");
 220                         WebClient wc = new WebClient ();
 221                         try {
 222                                 wc.DownloadFile (new Uri ("tp://scheme.notsupported"), file);
 223                                 Assert.Fail ("#1");
 224                         } catch (WebException ex) {
 225                                 // An error occurred performing a WebClient request
 226                                 Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
 227                                 Assert.IsNotNull (ex.InnerException, "#3");
 228                                 Assert.IsNotNull (ex.Message, "#4");
 229                                 Assert.IsNull (ex.Response, "#5");
 230                                 Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
 231
 232                                 // The URI prefix is not recognized
 233                                 Exception inner = ex.InnerException;
 234                                 Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
 235                                 Assert.IsNull (inner.InnerException, "#8");
 236                                 Assert.IsNotNull (inner.Message, "#9");
 237                         }
 238                         finally {
 239                                 if (File.Exists (file))
 240                                         File.Delete (file);
 241                         }
 242                 }
 243
 244                 [Test] // DownloadFile (Uri, string)
 245                 public void DownloadFile2_FileName_Null ()
 246                 {
 247                         WebClient wc = new WebClient ();
 248                         try {
 249                                 wc.DownloadFile (new Uri ("tp://scheme.notsupported"),
 250                                         (string) null);
 251                                 Assert.Fail ("#1");
 252                         } catch (ArgumentNullException ex) {
 253                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 254                                 Assert.IsNull (ex.InnerException, "#3");
 255                                 Assert.IsNotNull (ex.Message, "#4");
 256                                 Assert.IsNotNull (ex.ParamName, "#5");
 257                                 Assert.AreEqual ("fileName", ex.ParamName, "#6");
 258                         }
 259                 }
 260
 261                 [Test] // DownloadString (string)
 262                 public void DownloadString1_Address_Null ()
 263                 {
 264                         WebClient wc = new WebClient ();
 265                         try {
 266                                 wc.DownloadString ((string) null);
 267                                 Assert.Fail ("#1");
 268                         } catch (ArgumentNullException ex) {
 269                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 270                                 Assert.IsNull (ex.InnerException, "#3");
 271                                 Assert.IsNotNull (ex.Message, "#4");
 272                                 Assert.IsNotNull (ex.ParamName, "#5");
 273                                 Assert.AreEqual ("address", ex.ParamName, "#6");
 274                         }
 275                 }
 276
 277                 [Test] // DownloadString (string)
 278                 public void DownloadString1_Address_SchemeNotSupported ()
 279                 {
 280                         WebClient wc = new WebClient ();
 281                         try {
 282                                 wc.DownloadString ("tp://scheme.notsupported");
 283                                 Assert.Fail ("#1");
 284                         } catch (WebException ex) {
 285                                 // An error occurred performing a WebClient request
 286                                 Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
 287                                 Assert.IsNotNull (ex.InnerException, "#3");
 288                                 Assert.IsNotNull (ex.Message, "#4");
 289                                 Assert.IsNull (ex.Response, "#5");
 290                                 Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
 291
 292                                 // The URI prefix is not recognized
 293                                 Exception inner = ex.InnerException;
 294                                 Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
 295                                 Assert.IsNull (inner.InnerException, "#8");
 296                                 Assert.IsNotNull (inner.Message, "#9");
 297                         }
 298                 }
 299
 300                 [Test] // DownloadString (Uri)
 301                 public void DownloadString2_Address_Null ()
 302                 {
 303                         WebClient wc = new WebClient ();
 304                         try {
 305                                 wc.DownloadString ((Uri) null);
 306                                 Assert.Fail ("#1");
 307                         } catch (ArgumentNullException ex) {
 308                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 309                                 Assert.IsNull (ex.InnerException, "#3");
 310                                 Assert.IsNotNull (ex.Message, "#4");
 311                                 Assert.IsNotNull (ex.ParamName, "#5");
 312                                 Assert.AreEqual ("address", ex.ParamName, "#6");
 313                         }
 314                 }
 315
 316                 [Test] // DownloadString (Uri)
 317                 public void DownloadString2_Address_SchemeNotSupported ()
 318                 {
 319                         WebClient wc = new WebClient ();
 320                         try {
 321                                 wc.DownloadString (new Uri ("tp://scheme.notsupported"));
 322                                 Assert.Fail ("#1");
 323                         } catch (WebException ex) {
 324                                 // An error occurred performing a WebClient request
 325                                 Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
 326                                 Assert.IsNotNull (ex.InnerException, "#3");
 327                                 Assert.IsNotNull (ex.Message, "#4");
 328                                 Assert.IsNull (ex.Response, "#5");
 329                                 Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
 330
 331                                 // The URI prefix is not recognized
 332                                 Exception inner = ex.InnerException;
 333                                 Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
 334                                 Assert.IsNull (inner.InnerException, "#8");
 335                                 Assert.IsNotNull (inner.Message, "#9");
 336                         }
 337                 }
 338
 339                 [Test]
 340                 public void EncodingTest ()
 341                 {
 342                         WebClient wc = new WebClient ();
 343                         Assert.AreSame (Encoding.Default, wc.Encoding, "#1");
 344                         wc.Encoding = Encoding.ASCII;
 345                         Assert.AreSame (Encoding.ASCII, wc.Encoding, "#2");
 346                 }
 347
 348                 [Test]
 349                 public void Encoding_Value_Null ()
 350                 {
 351                         WebClient wc = new WebClient ();
 352                         try {
 353                                 wc.Encoding = null;
 354                                 Assert.Fail ("#1");
 355                         } catch (ArgumentNullException ex) {
 356                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 357                                 Assert.IsNull (ex.InnerException, "#3");
 358                                 Assert.IsNotNull (ex.Message, "#4");
 359                                 Assert.AreEqual ("Encoding", ex.ParamName, "#6");
 360                         }
 361                 }
 362
 363                 [Test] // OpenRead (string)
 364                 public void OpenRead1_Address_Null ()
 365                 {
 366                         WebClient wc = new WebClient ();
 367                         try {
 368                                 wc.OpenRead ((string) null);
 369                                 Assert.Fail ("#1");
 370                         } catch (ArgumentNullException ex) {
 371                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 372                                 Assert.IsNull (ex.InnerException, "#3");
 373                                 Assert.IsNotNull (ex.Message, "#4");
 374                                 Assert.IsNotNull (ex.ParamName, "#5");
 375                                 Assert.AreEqual ("address", ex.ParamName, "#6");
 376                         }
 377                 }
 378
 379                 [Test] // OpenRead (string)
 380                 public void OpenRead1_Address_SchemeNotSupported ()
 381                 {
 382                         WebClient wc = new WebClient ();
 383                         try {
 384                                 wc.OpenRead ("tp://scheme.notsupported");
 385                                 Assert.Fail ("#1");
 386                         } catch (WebException ex) {
 387                                 // An error occurred performing a WebClient request
 388                                 Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
 389                                 Assert.IsNotNull (ex.InnerException, "#3");
 390                                 Assert.IsNotNull (ex.Message, "#4");
 391                                 Assert.IsNull (ex.Response, "#5");
 392                                 Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
 393
 394                                 // The URI prefix is not recognized
 395                                 Exception inner = ex.InnerException;
 396                                 Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
 397                                 Assert.IsNull (inner.InnerException, "#8");
 398                                 Assert.IsNotNull (inner.Message, "#9");
 399                         }
 400                 }
 401
 402                 [Test] // OpenRead (Uri)
 403                 public void OpenRead2_Address_Null ()
 404                 {
 405                         WebClient wc = new WebClient ();
 406                         try {
 407                                 wc.OpenRead ((Uri) null);
 408                                 Assert.Fail ("#1");
 409                         } catch (ArgumentNullException ex) {
 410                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 411                                 Assert.IsNull (ex.InnerException, "#3");
 412                                 Assert.IsNotNull (ex.Message, "#4");
 413                                 Assert.IsNotNull (ex.ParamName, "#5");
 414                                 Assert.AreEqual ("address", ex.ParamName, "#6");
 415                         }
 416                 }
 417
 418                 [Test] // OpenRead (Uri)
 419                 public void OpenRead2_Address_SchemeNotSupported ()
 420                 {
 421                         WebClient wc = new WebClient ();
 422                         try {
 423                                 wc.OpenRead (new Uri ("tp://scheme.notsupported"));
 424                                 Assert.Fail ("#1");
 425                         } catch (WebException ex) {
 426                                 // An error occurred performing a WebClient request
 427                                 Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
 428                                 Assert.IsNotNull (ex.InnerException, "#3");
 429                                 Assert.IsNotNull (ex.Message, "#4");
 430                                 Assert.IsNull (ex.Response, "#5");
 431                                 Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
 432
 433                                 // The URI prefix is not recognized
 434                                 Exception inner = ex.InnerException;
 435                                 Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
 436                                 Assert.IsNull (inner.InnerException, "#8");
 437                                 Assert.IsNotNull (inner.Message, "#9");
 438                         }
 439                 }
 440
 441                 [Test] // OpenWrite (string)
 442                 public void OpenWrite1_Address_Null ()
 443                 {
 444                         WebClient wc = new WebClient ();
 445                         try {
 446                                 wc.OpenWrite ((string) null);
 447                                 Assert.Fail ("#1");
 448                         } catch (ArgumentNullException ex) {
 449                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 450                                 Assert.IsNull (ex.InnerException, "#3");
 451                                 Assert.IsNotNull (ex.Message, "#4");
 452                                 Assert.IsNotNull (ex.ParamName, "#5");
 453                                 Assert.AreEqual ("address", ex.ParamName, "#6");
 454                         }
 455                 }
 456
 457                 [Test] // OpenWrite (string)
 458                 public void OpenWrite1_Address_SchemeNotSupported ()
 459                 {
 460                         WebClient wc = new WebClient ();
 461                         try {
 462                                 wc.OpenWrite ("tp://scheme.notsupported");
 463                                 Assert.Fail ("#1");
 464                         } catch (WebException ex) {
 465                                 // An error occurred performing a WebClient request
 466                                 Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
 467                                 Assert.IsNotNull (ex.InnerException, "#3");
 468                                 Assert.IsNotNull (ex.Message, "#4");
 469                                 Assert.IsNull (ex.Response, "#5");
 470                                 Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
 471
 472                                 // The URI prefix is not recognized
 473                                 Exception inner = ex.InnerException;
 474                                 Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
 475                                 Assert.IsNull (inner.InnerException, "#8");
 476                                 Assert.IsNotNull (inner.Message, "#9");
 477                         }
 478                 }
 479
 480                 [Test] // OpenWrite (string, string)
 481                 public void OpenWrite2_Address_Null ()
 482                 {
 483                         WebClient wc = new WebClient ();
 484                         try {
 485                                 wc.OpenWrite ((string) null, "PUT");
 486                                 Assert.Fail ("#1");
 487                         } catch (ArgumentNullException ex) {
 488                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 489                                 Assert.IsNull (ex.InnerException, "#3");
 490                                 Assert.IsNotNull (ex.Message, "#4");
 491                                 Assert.IsNotNull (ex.ParamName, "#5");
 492                                 Assert.AreEqual ("address", ex.ParamName, "#6");
 493                         }
 494                 }
 495
 496                 [Test] // OpenWrite (string, string)
 497                 public void OpenWrite2_Address_SchemeNotSupported ()
 498                 {
 499                         WebClient wc = new WebClient ();
 500                         try {
 501                                 wc.OpenWrite ("tp://scheme.notsupported", "PUT");
 502                                 Assert.Fail ("#1");
 503                         } catch (WebException ex) {
 504                                 // An error occurred performing a WebClient request
 505                                 Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
 506                                 Assert.IsNotNull (ex.InnerException, "#3");
 507                                 Assert.IsNotNull (ex.Message, "#4");
 508                                 Assert.IsNull (ex.Response, "#5");
 509                                 Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
 510
 511                                 // The URI prefix is not recognized
 512                                 Exception inner = ex.InnerException;
 513                                 Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
 514                                 Assert.IsNull (inner.InnerException, "#8");
 515                                 Assert.IsNotNull (inner.Message, "#9");
 516                         }
 517                 }
 518
 519                 [Test] // OpenWrite (Uri)
 520                 public void OpenWrite3_Address_Null ()
 521                 {
 522                         WebClient wc = new WebClient ();
 523                         try {
 524                                 wc.OpenWrite ((Uri) null);
 525                                 Assert.Fail ("#1");
 526                         } catch (ArgumentNullException ex) {
 527                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 528                                 Assert.IsNull (ex.InnerException, "#3");
 529                                 Assert.IsNotNull (ex.Message, "#4");
 530                                 Assert.IsNotNull (ex.ParamName, "#5");
 531                                 Assert.AreEqual ("address", ex.ParamName, "#6");
 532                         }
 533                 }
 534
 535                 [Test] // OpenWrite (Uri)
 536                 public void OpenWrite3_Address_SchemeNotSupported ()
 537                 {
 538                         WebClient wc = new WebClient ();
 539                         try {
 540                                 wc.OpenWrite (new Uri ("tp://scheme.notsupported"));
 541                                 Assert.Fail ("#1");
 542                         } catch (WebException ex) {
 543                                 // An error occurred performing a WebClient request
 544                                 Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
 545                                 Assert.IsNotNull (ex.InnerException, "#3");
 546                                 Assert.IsNotNull (ex.Message, "#4");
 547                                 Assert.IsNull (ex.Response, "#5");
 548                                 Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
 549
 550                                 // The URI prefix is not recognized
 551                                 Exception inner = ex.InnerException;
 552                                 Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
 553                                 Assert.IsNull (inner.InnerException, "#8");
 554                                 Assert.IsNotNull (inner.Message, "#9");
 555                         }
 556                 }
 557
 558                 [Test] // OpenWrite (Uri, string)
 559                 public void OpenWrite4_Address_Null ()
 560                 {
 561                         WebClient wc = new WebClient ();
 562                         try {
 563                                 wc.OpenWrite ((Uri) null, "POST");
 564                                 Assert.Fail ("#1");
 565                         } catch (ArgumentNullException ex) {
 566                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 567                                 Assert.IsNull (ex.InnerException, "#3");
 568                                 Assert.IsNotNull (ex.Message, "#4");
 569                                 Assert.IsNotNull (ex.ParamName, "#5");
 570                                 Assert.AreEqual ("address", ex.ParamName, "#6");
 571                         }
 572                 }
 573
 574                 [Test] // OpenWrite (Uri, string)
 575                 public void OpenWrite4_Address_SchemeNotSupported ()
 576                 {
 577                         WebClient wc = new WebClient ();
 578                         try {
 579                                 wc.OpenWrite (new Uri ("tp://scheme.notsupported"),
 580                                         "POST");
 581                                 Assert.Fail ("#1");
 582                         } catch (WebException ex) {
 583                                 // An error occurred performing a WebClient request
 584                                 Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
 585                                 Assert.IsNotNull (ex.InnerException, "#3");
 586                                 Assert.IsNotNull (ex.Message, "#4");
 587                                 Assert.IsNull (ex.Response, "#5");
 588                                 Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
 589
 590                                 // The URI prefix is not recognized
 591                                 Exception inner = ex.InnerException;
 592                                 Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
 593                                 Assert.IsNull (inner.InnerException, "#8");
 594                                 Assert.IsNotNull (inner.Message, "#9");
 595                         }
 596                 }
 597
 598                 [Test] // UploadData (string, byte [])
 599                 public void UploadData1_Address_Null ()
 600                 {
 601                         WebClient wc = new WebClient ();
 602                         try {
 603                                 wc.UploadData ((string) null, new byte [] { 0x1a });
 604                                 Assert.Fail ("#1");
 605                         } catch (ArgumentNullException ex) {
 606                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 607                                 Assert.IsNull (ex.InnerException, "#3");
 608                                 Assert.IsNotNull (ex.Message, "#4");
 609                                 Assert.IsNotNull (ex.ParamName, "#5");
 610                                 Assert.AreEqual ("address", ex.ParamName, "#6");
 611                         }
 612                 }
 613
 614                 [Test] // UploadData (string, byte [])
 615                 public void UploadData1_Address_SchemeNotSupported ()
 616                 {
 617                         WebClient wc = new WebClient ();
 618                         try {
 619                                 wc.UploadData ("tp://scheme.notsupported", new byte [] { 0x1a });
 620                                 Assert.Fail ("#1");
 621                         } catch (WebException ex) {
 622                                 // An error occurred performing a WebClient request
 623                                 Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
 624                                 Assert.IsNotNull (ex.InnerException, "#3");
 625                                 Assert.IsNotNull (ex.Message, "#4");
 626                                 Assert.IsNull (ex.Response, "#5");
 627                                 Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
 628
 629                                 // The URI prefix is not recognized
 630                                 Exception inner = ex.InnerException;
 631                                 Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
 632                                 Assert.IsNull (inner.InnerException, "#8");
 633                                 Assert.IsNotNull (inner.Message, "#9");
 634                         }
 635                 }
 636
 637                 [Test] // UploadData (string, byte [])
 638                 public void UploadData1_Data_Null ()
 639                 {
 640                         WebClient wc = new WebClient ();
 641                         try {
 642                                 wc.UploadData ("http://www.mono-project.com",
 643                                         (byte []) null);
 644                                 Assert.Fail ("#1");
 645                         } catch (ArgumentNullException ex) {
 646                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 647                                 Assert.IsNull (ex.InnerException, "#3");
 648                                 Assert.IsNotNull (ex.Message, "#4");
 649                                 Assert.IsNotNull (ex.ParamName, "#5");
 650                                 Assert.AreEqual ("data", ex.ParamName, "#6");
 651                         }
 652                 }
 653
 654                 [Test] // UploadData (Uri, byte [])
 655                 public void UploadData2_Address_Null ()
 656                 {
 657                         WebClient wc = new WebClient ();
 658                         try {
 659                                 wc.UploadData ((Uri) null, new byte [] { 0x1a });
 660                                 Assert.Fail ("#1");
 661                         } catch (ArgumentNullException ex) {
 662                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 663                                 Assert.IsNull (ex.InnerException, "#3");
 664                                 Assert.IsNotNull (ex.Message, "#4");
 665                                 Assert.IsNotNull (ex.ParamName, "#5");
 666                                 Assert.AreEqual ("address", ex.ParamName, "#6");
 667                         }
 668                 }
 669
 670                 [Test] // UploadData (Uri, byte [])
 671                 public void UploadData2_Address_SchemeNotSupported ()
 672                 {
 673                         WebClient wc = new WebClient ();
 674                         try {
 675                                 wc.UploadData (new Uri ("tp://scheme.notsupported"),
 676                                         new byte [] { 0x1a });
 677                                 Assert.Fail ("#1");
 678                         } catch (WebException ex) {
 679                                 // An error occurred performing a WebClient request
 680                                 Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
 681                                 Assert.IsNotNull (ex.InnerException, "#3");
 682                                 Assert.IsNotNull (ex.Message, "#4");
 683                                 Assert.IsNull (ex.Response, "#5");
 684                                 Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
 685
 686                                 // The URI prefix is not recognized
 687                                 Exception inner = ex.InnerException;
 688                                 Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
 689                                 Assert.IsNull (inner.InnerException, "#8");
 690                                 Assert.IsNotNull (inner.Message, "#9");
 691                         }
 692                 }
 693
 694                 [Test] // UploadData (Uri, byte [])
 695                 public void UploadData2_Data_Null ()
 696                 {
 697                         WebClient wc = new WebClient ();
 698                         try {
 699                                 wc.UploadData (new Uri ("http://www.mono-project.com"),
 700                                         (byte []) null);
 701                                 Assert.Fail ("#1");
 702                         } catch (ArgumentNullException ex) {
 703                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 704                                 Assert.IsNull (ex.InnerException, "#3");
 705                                 Assert.IsNotNull (ex.Message, "#4");
 706                                 Assert.IsNotNull (ex.ParamName, "#5");
 707                                 Assert.AreEqual ("data", ex.ParamName, "#6");
 708                         }
 709                 }
 710
 711                 [Test] // UploadData (string, string, byte [])
 712                 public void UploadData3_Address_Null ()
 713                 {
 714                         WebClient wc = new WebClient ();
 715                         try {
 716                                 wc.UploadData ((string) null, "POST",
 717                                         new byte [] { 0x1a });
 718                                 Assert.Fail ("#1");
 719                         } catch (ArgumentNullException ex) {
 720                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 721                                 Assert.IsNull (ex.InnerException, "#3");
 722                                 Assert.IsNotNull (ex.Message, "#4");
 723                                 Assert.IsNotNull (ex.ParamName, "#5");
 724                                 Assert.AreEqual ("address", ex.ParamName, "#6");
 725                         }
 726                 }
 727
 728                 [Test] // UploadData (string, string, byte [])
 729                 public void UploadData3_Address_SchemeNotSupported ()
 730                 {
 731                         WebClient wc = new WebClient ();
 732                         try {
 733                                 wc.UploadData ("tp://scheme.notsupported",
 734                                         "POST", new byte [] { 0x1a });
 735                                 Assert.Fail ("#1");
 736                         } catch (WebException ex) {
 737                                 // An error occurred performing a WebClient request
 738                                 Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
 739                                 Assert.IsNotNull (ex.InnerException, "#3");
 740                                 Assert.IsNotNull (ex.Message, "#4");
 741                                 Assert.IsNull (ex.Response, "#5");
 742                                 Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
 743
 744                                 // The URI prefix is not recognized
 745                                 Exception inner = ex.InnerException;
 746                                 Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
 747                                 Assert.IsNull (inner.InnerException, "#8");
 748                                 Assert.IsNotNull (inner.Message, "#9");
 749                         }
 750                 }
 751
 752                 [Test] // UploadData (string, string, byte [])
 753                 public void UploadData3_Data_Null ()
 754                 {
 755                         WebClient wc = new WebClient ();
 756                         try {
 757                                 wc.UploadData ("http://www.mono-project.com",
 758                                         "POST", (byte []) null);
 759                                 Assert.Fail ("#1");
 760                         } catch (ArgumentNullException ex) {
 761                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 762                                 Assert.IsNull (ex.InnerException, "#3");
 763                                 Assert.IsNotNull (ex.Message, "#4");
 764                                 Assert.IsNotNull (ex.ParamName, "#5");
 765                                 Assert.AreEqual ("data", ex.ParamName, "#6");
 766                         }
 767                 }
 768
 769                 [Test] // UploadData (Uri, string, byte [])
 770                 public void UploadData4_Address_Null ()
 771                 {
 772                         WebClient wc = new WebClient ();
 773                         try {
 774                                 wc.UploadData ((Uri) null, "POST", new byte [] { 0x1a });
 775                                 Assert.Fail ("#1");
 776                         } catch (ArgumentNullException ex) {
 777                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 778                                 Assert.IsNull (ex.InnerException, "#3");
 779                                 Assert.IsNotNull (ex.Message, "#4");
 780                                 Assert.IsNotNull (ex.ParamName, "#5");
 781                                 Assert.AreEqual ("address", ex.ParamName, "#6");
 782                         }
 783                 }
 784
 785                 [Test] // UploadData (Uri, string, byte [])
 786                 public void UploadData4_Address_SchemeNotSupported ()
 787                 {
 788                         WebClient wc = new WebClient ();
 789                         try {
 790                                 wc.UploadData (new Uri ("tp://scheme.notsupported"),
 791                                         "POST", new byte [] { 0x1a });
 792                                 Assert.Fail ("#1");
 793                         } catch (WebException ex) {
 794                                 // An error occurred performing a WebClient request
 795                                 Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
 796                                 Assert.IsNotNull (ex.InnerException, "#3");
 797                                 Assert.IsNotNull (ex.Message, "#4");
 798                                 Assert.IsNull (ex.Response, "#5");
 799                                 Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
 800
 801                                 // The URI prefix is not recognized
 802                                 Exception inner = ex.InnerException;
 803                                 Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
 804                                 Assert.IsNull (inner.InnerException, "#8");
 805                                 Assert.IsNotNull (inner.Message, "#9");
 806                         }
 807                 }
 808
 809                 [Test] // UploadData (Uri, string, byte [])
 810                 public void UploadData4_Data_Null ()
 811                 {
 812                         WebClient wc = new WebClient ();
 813                         try {
 814                                 wc.UploadData (new Uri ("http://www.mono-project.com"),
 815                                         "POST", (byte []) null);
 816                                 Assert.Fail ("#1");
 817                         } catch (ArgumentNullException ex) {
 818                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 819                                 Assert.IsNull (ex.InnerException, "#3");
 820                                 Assert.IsNotNull (ex.Message, "#4");
 821                                 Assert.IsNotNull (ex.ParamName, "#5");
 822                                 Assert.AreEqual ("data", ex.ParamName, "#6");
 823                         }
 824                 }
 825
 826                 [Test] // UploadFile (string, string)
 827                 public void UploadFile1_Address_Null ()
 828                 {
 829                         string tempFile = Path.Combine (_tempFolder, "upload.tmp");
 830                         File.Create (tempFile).Close ();
 831
 832                         WebClient wc = new WebClient ();
 833                         try {
 834                                 wc.UploadFile ((string) null, tempFile);
 835                                 Assert.Fail ("#1");
 836                         } catch (ArgumentNullException ex) {
 837                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 838                                 Assert.IsNull (ex.InnerException, "#3");
 839                                 Assert.IsNotNull (ex.Message, "#4");
 840                                 Assert.IsNotNull (ex.ParamName, "#5");
 841                                 Assert.AreEqual ("address", ex.ParamName, "#6");
 842                         }
 843                 }
 844
 845                 [Test] // UploadFile (string, string)
 846                 public void UploadFile1_Address_SchemeNotSupported ()
 847                 {
 848                         string tempFile = Path.Combine (_tempFolder, "upload.tmp");
 849                         File.Create (tempFile).Close ();
 850
 851                         WebClient wc = new WebClient ();
 852                         try {
 853                                 wc.UploadFile ("tp://scheme.notsupported",
 854                                         tempFile);
 855                                 Assert.Fail ("#1");
 856                         } catch (WebException ex) {
 857                                 // An error occurred performing a WebClient request
 858                                 Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
 859                                 Assert.IsNotNull (ex.InnerException, "#3");
 860                                 Assert.IsNotNull (ex.Message, "#4");
 861                                 Assert.IsNull (ex.Response, "#5");
 862                                 Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
 863
 864                                 // The URI prefix is not recognized
 865                                 Exception inner = ex.InnerException;
 866                                 Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
 867                                 Assert.IsNull (inner.InnerException, "#8");
 868                                 Assert.IsNotNull (inner.Message, "#9");
 869                         }
 870                 }
 871
 872                 [Test] // UploadFile (string, string)
 873                 public void UploadFile1_FileName_NotFound ()
 874                 {
 875                         string tempFile = Path.Combine (_tempFolder, "upload.tmp");
 876
 877                         WebClient wc = new WebClient ();
 878                         try {
 879                                 wc.UploadFile ("tp://scheme.notsupported",
 880                                         tempFile);
 881                                 Assert.Fail ("#1");
 882                         } catch (WebException ex) {
 883                                 // An error occurred performing a WebClient request
 884                                 Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
 885                                 Assert.IsNotNull (ex.Message, "#3");
 886                                 Assert.IsNull (ex.Response, "#4");
 887                                 Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#5");
 888
 889                                 // Could not find file "..."
 890                                 FileNotFoundException inner = ex.InnerException
 891                                         as FileNotFoundException;
 892                                 Assert.IsNotNull (inner, "#6");
 893                                 Assert.AreEqual (typeof (FileNotFoundException), inner.GetType (), "#7");
 894                                 Assert.IsNotNull (inner.FileName, "#8");
 895                                 Assert.AreEqual (tempFile, inner.FileName, "#9");
 896                                 Assert.IsNull (inner.InnerException, "#10");
 897                                 Assert.IsNotNull (inner.Message, "#11");
 898                         }
 899                 }
 900
 901                 [Test] // UploadFile (string, string)
 902                 public void UploadFile1_FileName_Null ()
 903                 {
 904                         WebClient wc = new WebClient ();
 905                         try {
 906                                 wc.UploadFile ("tp://scheme.notsupported",
 907                                         (string) null);
 908                                 Assert.Fail ("#1");
 909                         } catch (ArgumentNullException ex) {
 910                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 911                                 Assert.IsNull (ex.InnerException, "#3");
 912                                 Assert.IsNotNull (ex.Message, "#4");
 913                                 Assert.IsNotNull (ex.ParamName, "#5");
 914                                 Assert.AreEqual ("fileName", ex.ParamName, "#6");
 915                         }
 916                 }
 917
 918                 [Test] // UploadFile (Uri, string)
 919                 public void UploadFile2_Address_Null ()
 920                 {
 921                         string tempFile = Path.Combine (_tempFolder, "upload.tmp");
 922
 923                         WebClient wc = new WebClient ();
 924                         try {
 925                                 wc.UploadFile ((Uri) null, tempFile);
 926                                 Assert.Fail ("#1");
 927                         } catch (ArgumentNullException ex) {
 928                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 929                                 Assert.IsNull (ex.InnerException, "#3");
 930                                 Assert.IsNotNull (ex.Message, "#4");
 931                                 Assert.IsNotNull (ex.ParamName, "#5");
 932                                 Assert.AreEqual ("address", ex.ParamName, "#6");
 933                         }
 934                 }
 935
 936                 [Test] // UploadFile (Uri, string)
 937                 public void UploadFile2_Address_SchemeNotSupported ()
 938                 {
 939                         string tempFile = Path.Combine (_tempFolder, "upload.tmp");
 940                         File.Create (tempFile).Close ();
 941
 942                         WebClient wc = new WebClient ();
 943                         try {
 944                                 wc.UploadFile (new Uri ("tp://scheme.notsupported"),
 945                                         tempFile);
 946                                 Assert.Fail ("#1");
 947                         } catch (WebException ex) {
 948                                 // An error occurred performing a WebClient request
 949                                 Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
 950                                 Assert.IsNotNull (ex.InnerException, "#3");
 951                                 Assert.IsNotNull (ex.Message, "#4");
 952                                 Assert.IsNull (ex.Response, "#5");
 953                                 Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
 954
 955                                 // The URI prefix is not recognized
 956                                 Exception inner = ex.InnerException;
 957                                 Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
 958                                 Assert.IsNull (inner.InnerException, "#8");
 959                                 Assert.IsNotNull (inner.Message, "#9");
 960                         }
 961                 }
 962
 963                 [Test] // UploadFile (Uri, string)
 964                 public void UploadFile2_FileName_NotFound ()
 965                 {
 966                         string tempFile = Path.Combine (_tempFolder, "upload.tmp");
 967
 968                         WebClient wc = new WebClient ();
 969                         try {
 970                                 wc.UploadFile (new Uri ("tp://scheme.notsupported"),
 971                                         tempFile);
 972                                 Assert.Fail ("#1");
 973                         } catch (WebException ex) {
 974                                 // An error occurred performing a WebClient request
 975                                 Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
 976                                 Assert.IsNotNull (ex.Message, "#3");
 977                                 Assert.IsNull (ex.Response, "#4");
 978                                 Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#5");
 979
 980                                 // Could not find file "..."
 981                                 FileNotFoundException inner = ex.InnerException
 982                                         as FileNotFoundException;
 983                                 Assert.IsNotNull (inner, "#6");
 984                                 Assert.AreEqual (typeof (FileNotFoundException), inner.GetType (), "#7");
 985                                 Assert.IsNotNull (inner.FileName, "#8");
 986                                 Assert.AreEqual (tempFile, inner.FileName, "#9");
 987                                 Assert.IsNull (inner.InnerException, "#10");
 988                                 Assert.IsNotNull (inner.Message, "#11");
 989                         }
 990                 }
 991
 992                 [Test] // UploadFile (Uri, string)
 993                 public void UploadFile2_FileName_Null ()
 994                 {
 995                         WebClient wc = new WebClient ();
 996                         try {
 997                                 wc.UploadFile (new Uri ("tp://scheme.notsupported"),
 998                                         null);
 999                                 Assert.Fail ("#1");
1000                         } catch (ArgumentNullException ex) {
1001                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1002                                 Assert.IsNull (ex.InnerException, "#3");
1003                                 Assert.IsNotNull (ex.Message, "#4");
1004                                 Assert.IsNotNull (ex.ParamName, "#5");
1005                                 Assert.AreEqual ("fileName", ex.ParamName, "#6");
1006                         }
1007                 }
1008
1009                 [Test] // UploadFile (string, string, string)
1010                 public void UploadFile3_Address_Null ()
1011                 {
1012                         string tempFile = Path.Combine (_tempFolder, "upload.tmp");
1013                         File.Create (tempFile).Close ();
1014
1015                         WebClient wc = new WebClient ();
1016                         try {
1017                                 wc.UploadFile ((string) null, "POST", tempFile);
1018                                 Assert.Fail ("#1");
1019                         } catch (ArgumentNullException ex) {
1020                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1021                                 Assert.IsNull (ex.InnerException, "#3");
1022                                 Assert.IsNotNull (ex.Message, "#4");
1023                                 Assert.IsNotNull (ex.ParamName, "#5");
1024                                 Assert.AreEqual ("path", ex.ParamName, "#6");
1025                         }
1026                 }
1027
1028                 [Test] // UploadFile (string, string, string)
1029                 public void UploadFile3_Address_SchemeNotSupported ()
1030                 {
1031                         string tempFile = Path.Combine (_tempFolder, "upload.tmp");
1032                         File.Create (tempFile).Close ();
1033
1034                         WebClient wc = new WebClient ();
1035                         try {
1036                                 wc.UploadFile ("tp://scheme.notsupported",
1037                                         "POST", tempFile);
1038                                 Assert.Fail ("#1");
1039                         } catch (WebException ex) {
1040                                 // An error occurred performing a WebClient request
1041                                 Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
1042                                 Assert.IsNotNull (ex.InnerException, "#3");
1043                                 Assert.IsNotNull (ex.Message, "#4");
1044                                 Assert.IsNull (ex.Response, "#5");
1045                                 Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
1046
1047                                 // The URI prefix is not recognized
1048                                 Exception inner = ex.InnerException;
1049                                 Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
1050                                 Assert.IsNull (inner.InnerException, "#8");
1051                                 Assert.IsNotNull (inner.Message, "#9");
1052                         }
1053                 }
1054
1055                 [Test] // UploadFile (string, string, string)
1056                 public void UploadFile3_FileName_NotFound ()
1057                 {
1058                         string tempFile = Path.Combine (_tempFolder, "upload.tmp");
1059
1060                         WebClient wc = new WebClient ();
1061                         try {
1062                                 wc.UploadFile ("tp://scheme.notsupported",
1063                                         "POST", tempFile);
1064                                 Assert.Fail ("#1");
1065                         } catch (WebException ex) {
1066                                 // An error occurred performing a WebClient request
1067                                 Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
1068                                 Assert.IsNotNull (ex.Message, "#3");
1069                                 Assert.IsNull (ex.Response, "#4");
1070                                 Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#5");
1071
1072                                 // Could not find file "..."
1073                                 FileNotFoundException inner = ex.InnerException
1074                                         as FileNotFoundException;
1075                                 Assert.IsNotNull (inner, "#6");
1076                                 Assert.AreEqual (typeof (FileNotFoundException), inner.GetType (), "#7");
1077                                 Assert.IsNotNull (inner.FileName, "#8");
1078                                 Assert.AreEqual (tempFile, inner.FileName, "#9");
1079                                 Assert.IsNull (inner.InnerException, "#10");
1080                                 Assert.IsNotNull (inner.Message, "#11");
1081                         }
1082                 }
1083
1084                 [Test] // UploadFile (string, string, string)
1085                 public void UploadFile3_FileName_Null ()
1086                 {
1087                         WebClient wc = new WebClient ();
1088                         try {
1089                                 wc.UploadFile ("tp://scheme.notsupported",
1090                                         "POST", (string) null);
1091                                 Assert.Fail ("#1");
1092                         } catch (ArgumentNullException ex) {
1093                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1094                                 Assert.IsNull (ex.InnerException, "#3");
1095                                 Assert.IsNotNull (ex.Message, "#4");
1096                                 Assert.IsNotNull (ex.ParamName, "#5");
1097                                 Assert.AreEqual ("fileName", ex.ParamName, "#6");
1098                         }
1099                 }
1100
1101                 [Test] // UploadFile (Uri, string, string)
1102                 public void UploadFile4_Address_Null ()
1103                 {
1104                         string tempFile = Path.Combine (_tempFolder, "upload.tmp");
1105
1106                         WebClient wc = new WebClient ();
1107                         try {
1108                                 wc.UploadFile ((Uri) null, "POST", tempFile);
1109                                 Assert.Fail ("#1");
1110                         } catch (ArgumentNullException ex) {
1111                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1112                                 Assert.IsNull (ex.InnerException, "#3");
1113                                 Assert.IsNotNull (ex.Message, "#4");
1114                                 Assert.IsNotNull (ex.ParamName, "#5");
1115                                 Assert.AreEqual ("address", ex.ParamName, "#6");
1116                         }
1117                 }
1118
1119                 [Test] // UploadFile (Uri, string, string)
1120                 public void UploadFile4_Address_SchemeNotSupported ()
1121                 {
1122                         string tempFile = Path.Combine (_tempFolder, "upload.tmp");
1123                         File.Create (tempFile).Close ();
1124
1125                         WebClient wc = new WebClient ();
1126                         try {
1127                                 wc.UploadFile (new Uri ("tp://scheme.notsupported"),
1128                                         "POST", tempFile);
1129                                 Assert.Fail ("#1");
1130                         } catch (WebException ex) {
1131                                 // An error occurred performing a WebClient request
1132                                 Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
1133                                 Assert.IsNotNull (ex.InnerException, "#3");
1134                                 Assert.IsNotNull (ex.Message, "#4");
1135                                 Assert.IsNull (ex.Response, "#5");
1136                                 Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
1137
1138                                 // The URI prefix is not recognized
1139                                 Exception inner = ex.InnerException;
1140                                 Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
1141                                 Assert.IsNull (inner.InnerException, "#8");
1142                                 Assert.IsNotNull (inner.Message, "#9");
1143                         }
1144                 }
1145
1146                 [Test] // UploadFile (Uri, string, string)
1147                 public void UploadFile4_FileName_NotFound ()
1148                 {
1149                         string tempFile = Path.Combine (_tempFolder, "upload.tmp");
1150
1151                         WebClient wc = new WebClient ();
1152                         try {
1153                                 wc.UploadFile (new Uri ("tp://scheme.notsupported"),
1154                                         "POST", tempFile);
1155                                 Assert.Fail ("#1");
1156                         } catch (WebException ex) {
1157                                 // An error occurred performing a WebClient request
1158                                 Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
1159                                 Assert.IsNotNull (ex.Message, "#3");
1160                                 Assert.IsNull (ex.Response, "#4");
1161                                 Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#5");
1162
1163                                 // Could not find file "..."
1164                                 FileNotFoundException inner = ex.InnerException
1165                                         as FileNotFoundException;
1166                                 Assert.IsNotNull (inner, "#6");
1167                                 Assert.AreEqual (typeof (FileNotFoundException), inner.GetType (), "#7");
1168                                 Assert.IsNotNull (inner.FileName, "#8");
1169                                 Assert.AreEqual (tempFile, inner.FileName, "#9");
1170                                 Assert.IsNull (inner.InnerException, "#10");
1171                                 Assert.IsNotNull (inner.Message, "#11");
1172                         }
1173                 }
1174
1175                 [Test] // UploadFile (Uri, string, string)
1176                 public void UploadFile4_FileName_Null ()
1177                 {
1178                         WebClient wc = new WebClient ();
1179                         try {
1180                                 wc.UploadFile (new Uri ("tp://scheme.notsupported"),
1181                                         "POST", (string) null);
1182                                 Assert.Fail ("#1");
1183                         } catch (ArgumentNullException ex) {
1184                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1185                                 Assert.IsNull (ex.InnerException, "#3");
1186                                 Assert.IsNotNull (ex.Message, "#4");
1187                                 Assert.IsNotNull (ex.ParamName, "#5");
1188                                 Assert.AreEqual ("fileName", ex.ParamName, "#6");
1189                         }
1190                 }
1191
1192                 [Test] // UploadString (string, string)
1193                 public void UploadString1_Address_Null ()
1194                 {
1195                         WebClient wc = new WebClient ();
1196                         try {
1197                                 wc.UploadString ((string) null, (string) null);
1198                                 Assert.Fail ("#1");
1199                         } catch (ArgumentNullException ex) {
1200                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1201                                 Assert.IsNull (ex.InnerException, "#3");
1202                                 Assert.IsNotNull (ex.Message, "#4");
1203                                 Assert.IsNotNull (ex.ParamName, "#5");
1204                                 Assert.AreEqual ("address", ex.ParamName, "#6");
1205                         }
1206                 }
1207
1208                 [Test] // UploadString (string, string)
1209                 public void UploadString1_Address_SchemeNotSupported ()
1210                 {
1211                         WebClient wc = new WebClient ();
1212                         try {
1213                                 wc.UploadString ("tp://scheme.notsupported", "abc");
1214                                 Assert.Fail ("#1");
1215                         } catch (WebException ex) {
1216                                 // An error occurred performing a WebClient request
1217                                 Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
1218                                 Assert.IsNotNull (ex.InnerException, "#3");
1219                                 Assert.IsNotNull (ex.Message, "#4");
1220                                 Assert.IsNull (ex.Response, "#5");
1221                                 Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
1222
1223                                 // The URI prefix is not recognized
1224                                 Exception inner = ex.InnerException;
1225                                 Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
1226                                 Assert.IsNull (inner.InnerException, "#8");
1227                                 Assert.IsNotNull (inner.Message, "#9");
1228                         }
1229                 }
1230
1231                 [Test] // UploadString (string, string)
1232                 public void UploadString1_Data_Null ()
1233                 {
1234                         WebClient wc = new WebClient ();
1235                         try {
1236                                 wc.UploadString ("tp://scheme.notsupported", (string) null);
1237                                 Assert.Fail ("#1");
1238                         } catch (ArgumentNullException ex) {
1239                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1240                                 Assert.IsNull (ex.InnerException, "#3");
1241                                 Assert.IsNotNull (ex.Message, "#4");
1242                                 Assert.IsNotNull (ex.ParamName, "#5");
1243                                 Assert.AreEqual ("data", ex.ParamName, "#6");
1244                         }
1245                 }
1246
1247                 [Test] // UploadString (Uri, string)
1248                 public void UploadString2_Address_Null ()
1249                 {
1250                         WebClient wc = new WebClient ();
1251                         try {
1252                                 wc.UploadString ((Uri) null, (string) null);
1253                                 Assert.Fail ("#1");
1254                         } catch (ArgumentNullException ex) {
1255                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1256                                 Assert.IsNull (ex.InnerException, "#3");
1257                                 Assert.IsNotNull (ex.Message, "#4");
1258                                 Assert.IsNotNull (ex.ParamName, "#5");
1259                                 Assert.AreEqual ("address", ex.ParamName, "#6");
1260                         }
1261                 }
1262
1263                 [Test] // UploadString (Uri, string)
1264                 public void UploadString2_Address_SchemeNotSupported ()
1265                 {
1266                         WebClient wc = new WebClient ();
1267                         try {
1268                                 wc.UploadString (new Uri ("tp://scheme.notsupported"), "abc");
1269                                 Assert.Fail ("#1");
1270                         } catch (WebException ex) {
1271                                 // An error occurred performing a WebClient request
1272                                 Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
1273                                 Assert.IsNotNull (ex.InnerException, "#3");
1274                                 Assert.IsNotNull (ex.Message, "#4");
1275                                 Assert.IsNull (ex.Response, "#5");
1276                                 Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
1277
1278                                 // The URI prefix is not recognized
1279                                 Exception inner = ex.InnerException;
1280                                 Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
1281                                 Assert.IsNull (inner.InnerException, "#8");
1282                                 Assert.IsNotNull (inner.Message, "#9");
1283                         }
1284                 }
1285
1286                 [Test] // UploadString (Uri, string)
1287                 public void UploadString2_Data_Null ()
1288                 {
1289                         WebClient wc = new WebClient ();
1290                         try {
1291                                 wc.UploadString (new Uri ("tp://scheme.notsupported"),
1292                                         (string) null);
1293                                 Assert.Fail ("#1");
1294                         } catch (ArgumentNullException ex) {
1295                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1296                                 Assert.IsNull (ex.InnerException, "#3");
1297                                 Assert.IsNotNull (ex.Message, "#4");
1298                                 Assert.IsNotNull (ex.ParamName, "#5");
1299                                 Assert.AreEqual ("data", ex.ParamName, "#6");
1300                         }
1301                 }
1302
1303                 [Test] // UploadString (string, string, string)
1304                 public void UploadString3_Address_Null ()
1305                 {
1306                         WebClient wc = new WebClient ();
1307                         try {
1308                                 wc.UploadString ((string) null, (string) null,
1309                                         (string) null);
1310                                 Assert.Fail ("#1");
1311                         } catch (ArgumentNullException ex) {
1312                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1313                                 Assert.IsNull (ex.InnerException, "#3");
1314                                 Assert.IsNotNull (ex.Message, "#4");
1315                                 Assert.IsNotNull (ex.ParamName, "#5");
1316                                 Assert.AreEqual ("address", ex.ParamName, "#6");
1317                         }
1318                 }
1319
1320                 [Test] // UploadString (string, string, string)
1321                 public void UploadString3_Address_SchemeNotSupported ()
1322                 {
1323                         WebClient wc = new WebClient ();
1324                         try {
1325                                 wc.UploadString ("tp://scheme.notsupported",
1326                                         "POST", "abc");
1327                                 Assert.Fail ("#1");
1328                         } catch (WebException ex) {
1329                                 // An error occurred performing a WebClient request
1330                                 Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
1331                                 Assert.IsNotNull (ex.InnerException, "#3");
1332                                 Assert.IsNotNull (ex.Message, "#4");
1333                                 Assert.IsNull (ex.Response, "#5");
1334                                 Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
1335
1336                                 // The URI prefix is not recognized
1337                                 Exception inner = ex.InnerException;
1338                                 Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
1339                                 Assert.IsNull (inner.InnerException, "#8");
1340                                 Assert.IsNotNull (inner.Message, "#9");
1341                         }
1342                 }
1343
1344                 [Test] // UploadString (string, string, string)
1345                 public void UploadString3_Data_Null ()
1346                 {
1347                         WebClient wc = new WebClient ();
1348                         try {
1349                                 wc.UploadString ("tp://scheme.notsupported",
1350                                         "POST", (string) null);
1351                                 Assert.Fail ("#1");
1352                         } catch (ArgumentNullException ex) {
1353                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1354                                 Assert.IsNull (ex.InnerException, "#3");
1355                                 Assert.IsNotNull (ex.Message, "#4");
1356                                 Assert.IsNotNull (ex.ParamName, "#5");
1357                                 Assert.AreEqual ("data", ex.ParamName, "#6");
1358                         }
1359                 }
1360
1361                 [Test] // UploadString (Uri, string, string)
1362                 public void UploadString4_Address_Null ()
1363                 {
1364                         WebClient wc = new WebClient ();
1365                         try {
1366                                 wc.UploadString ((Uri) null, (string) null,
1367                                         (string) null);
1368                                 Assert.Fail ("#1");
1369                         } catch (ArgumentNullException ex) {
1370                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1371                                 Assert.IsNull (ex.InnerException, "#3");
1372                                 Assert.IsNotNull (ex.Message, "#4");
1373                                 Assert.IsNotNull (ex.ParamName, "#5");
1374                                 Assert.AreEqual ("address", ex.ParamName, "#6");
1375                         }
1376                 }
1377
1378                 [Test] // UploadString (Uri, string, string)
1379                 public void UploadString4_Address_SchemeNotSupported ()
1380                 {
1381                         WebClient wc = new WebClient ();
1382                         try {
1383                                 wc.UploadString (new Uri ("tp://scheme.notsupported"),
1384                                         "POST", "abc");
1385                                 Assert.Fail ("#1");
1386                         } catch (WebException ex) {
1387                                 // An error occurred performing a WebClient request
1388                                 Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
1389                                 Assert.IsNotNull (ex.InnerException, "#3");
1390                                 Assert.IsNotNull (ex.Message, "#4");
1391                                 Assert.IsNull (ex.Response, "#5");
1392                                 Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
1393
1394                                 // The URI prefix is not recognized
1395                                 Exception inner = ex.InnerException;
1396                                 Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
1397                                 Assert.IsNull (inner.InnerException, "#8");
1398                                 Assert.IsNotNull (inner.Message, "#9");
1399                         }
1400                 }
1401
1402                 [Test] // UploadString (Uri, string, string)
1403                 public void UploadString4_Data_Null ()
1404                 {
1405                         WebClient wc = new WebClient ();
1406                         try {
1407                                 wc.UploadString (new Uri ("tp://scheme.notsupported"),
1408                                         "POST", (string) null);
1409                                 Assert.Fail ("#1");
1410                         } catch (ArgumentNullException ex) {
1411                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1412                                 Assert.IsNull (ex.InnerException, "#3");
1413                                 Assert.IsNotNull (ex.Message, "#4");
1414                                 Assert.IsNotNull (ex.ParamName, "#5");
1415                                 Assert.AreEqual ("data", ex.ParamName, "#6");
1416                         }
1417                 }
1418
1419                 [Test]
1420                 public void UploadValues1 ()
1421                 {
1422                         IPEndPoint ep = NetworkHelpers.LocalEphemeralEndPoint ();
1423                         string url = "http://" + ep.ToString () + "/test/";
1424
1425                         using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (EchoRequestHandler))) {
1426                                 responder.Start ();
1427
1428                                 WebClient wc = new WebClient ();
1429                                 wc.Encoding = Encoding.ASCII;
1430
1431                                 NameValueCollection nvc = new NameValueCollection ();
1432                                 nvc.Add ("Name", "\u0041\u2262\u0391\u002E");
1433                                 nvc.Add ("Address", "\u002E\u2262\u0041\u0391");
1434
1435                                 byte [] buffer = wc.UploadValues (url, nvc);
1436                                 string response = Encoding.UTF8.GetString (buffer);
1437                                 Assert.AreEqual ("Name=A%e2%89%a2%ce%91.&Address=.%e2%89%a2A%ce%91\r\n", response);
1438                         }
1439                 }
1440
1441                 [Test] // UploadValues (string, NameValueCollection)
1442                 public void UploadValues1_Address_Null ()
1443                 {
1444                         WebClient wc = new WebClient ();
1445                         try {
1446                                 wc.UploadValues ((string) null, new NameValueCollection ());
1447                                 Assert.Fail ("#1");
1448                         } catch (ArgumentNullException ex) {
1449                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1450                                 Assert.IsNull (ex.InnerException, "#3");
1451                                 Assert.IsNotNull (ex.Message, "#4");
1452                                 Assert.IsNotNull (ex.ParamName, "#5");
1453                                 Assert.AreEqual ("address", ex.ParamName, "#6");
1454                         }
1455                 }
1456
1457                 [Test] // UploadValues (string, NameValueCollection)
1458                 public void UploadValues1_Address_SchemeNotSupported ()
1459                 {
1460                         WebClient wc = new WebClient ();
1461                         try {
1462                                 wc.UploadValues ("tp://scheme.notsupported",
1463                                         new NameValueCollection ());
1464                                 Assert.Fail ("#1");
1465                         } catch (WebException ex) {
1466                                 // An error occurred performing a WebClient request
1467                                 Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
1468                                 Assert.IsNotNull (ex.InnerException, "#3");
1469                                 Assert.IsNotNull (ex.Message, "#4");
1470                                 Assert.IsNull (ex.Response, "#5");
1471                                 Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
1472
1473                                 // The URI prefix is not recognized
1474                                 Exception inner = ex.InnerException;
1475                                 Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
1476                                 Assert.IsNull (inner.InnerException, "#8");
1477                                 Assert.IsNotNull (inner.Message, "#9");
1478                         }
1479                 }
1480
1481                 [Test] // UploadValues (string, NameValueCollection)
1482                 public void UploadValues1_Data_Null ()
1483                 {
1484                         WebClient wc = new WebClient ();
1485                         try {
1486                                 wc.UploadValues ("http://www.mono-project.com",
1487                                         (NameValueCollection) null);
1488                                 Assert.Fail ("#1");
1489                         } catch (ArgumentNullException ex) {
1490                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1491                                 Assert.IsNull (ex.InnerException, "#3");
1492                                 Assert.IsNotNull (ex.Message, "#4");
1493                                 Assert.IsNotNull (ex.ParamName, "#5");
1494                                 Assert.AreEqual ("data", ex.ParamName, "#6");
1495                         }
1496                 }
1497
1498                 [Test] // UploadValues (Uri, NameValueCollection)
1499                 public void UploadValues2_Address_Null ()
1500                 {
1501                         WebClient wc = new WebClient ();
1502                         try {
1503                                 wc.UploadValues ((Uri) null, new NameValueCollection ());
1504                                 Assert.Fail ("#1");
1505                         } catch (ArgumentNullException ex) {
1506                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1507                                 Assert.IsNull (ex.InnerException, "#3");
1508                                 Assert.IsNotNull (ex.Message, "#4");
1509                                 Assert.IsNotNull (ex.ParamName, "#5");
1510                                 Assert.AreEqual ("address", ex.ParamName, "#6");
1511                         }
1512                 }
1513
1514                 [Test] // UploadValues (Uri, NameValueCollection)
1515                 public void UploadValues2_Address_SchemeNotSupported ()
1516                 {
1517                         WebClient wc = new WebClient ();
1518                         try {
1519                                 wc.UploadValues (new Uri ("tp://scheme.notsupported"),
1520                                         new NameValueCollection ());
1521                                 Assert.Fail ("#1");
1522                         } catch (WebException ex) {
1523                                 // An error occurred performing a WebClient request
1524                                 Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
1525                                 Assert.IsNotNull (ex.InnerException, "#3");
1526                                 Assert.IsNotNull (ex.Message, "#4");
1527                                 Assert.IsNull (ex.Response, "#5");
1528                                 Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
1529
1530                                 // The URI prefix is not recognized
1531                                 Exception inner = ex.InnerException;
1532                                 Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
1533                                 Assert.IsNull (inner.InnerException, "#8");
1534                                 Assert.IsNotNull (inner.Message, "#9");
1535                         }
1536                 }
1537
1538                 [Test] // UploadValues (Uri, NameValueCollection)
1539                 public void UploadValues2_Data_Null ()
1540                 {
1541                         WebClient wc = new WebClient ();
1542                         try {
1543                                 wc.UploadValues (new Uri ("http://www.mono-project.com"),
1544                                         (NameValueCollection) null);
1545                                 Assert.Fail ("#1");
1546                         } catch (ArgumentNullException ex) {
1547                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1548                                 Assert.IsNull (ex.InnerException, "#3");
1549                                 Assert.IsNotNull (ex.Message, "#4");
1550                                 Assert.IsNotNull (ex.ParamName, "#5");
1551                                 Assert.AreEqual ("data", ex.ParamName, "#6");
1552                         }
1553                 }
1554
1555                 [Test] // UploadValues (string, string, NameValueCollection)
1556                 public void UploadValues3_Address_Null ()
1557                 {
1558                         WebClient wc = new WebClient ();
1559                         try {
1560                                 wc.UploadValues ((string) null, "POST",
1561                                         new NameValueCollection ());
1562                                 Assert.Fail ("#1");
1563                         } catch (ArgumentNullException ex) {
1564                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1565                                 Assert.IsNull (ex.InnerException, "#3");
1566                                 Assert.IsNotNull (ex.Message, "#4");
1567                                 Assert.IsNotNull (ex.ParamName, "#5");
1568                                 Assert.AreEqual ("address", ex.ParamName, "#6");
1569                         }
1570                 }
1571
1572                 [Test] // UploadValues (string, string, NameValueCollection)
1573                 public void UploadValues3_Address_SchemeNotSupported ()
1574                 {
1575                         WebClient wc = new WebClient ();
1576                         try {
1577                                 wc.UploadValues ("tp://scheme.notsupported",
1578                                         "POST", new NameValueCollection ());
1579                                 Assert.Fail ("#1");
1580                         } catch (WebException ex) {
1581                                 // An error occurred performing a WebClient request
1582                                 Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
1583                                 Assert.IsNotNull (ex.InnerException, "#3");
1584                                 Assert.IsNotNull (ex.Message, "#4");
1585                                 Assert.IsNull (ex.Response, "#5");
1586                                 Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
1587
1588                                 // The URI prefix is not recognized
1589                                 Exception inner = ex.InnerException;
1590                                 Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
1591                                 Assert.IsNull (inner.InnerException, "#8");
1592                                 Assert.IsNotNull (inner.Message, "#9");
1593                         }
1594                 }
1595
1596                 [Test] // UploadValues (string, string, NameValueCollection)
1597                 public void UploadValues3_Data_Null ()
1598                 {
1599                         WebClient wc = new WebClient ();
1600                         try {
1601                                 wc.UploadValues ("http://www.mono-project.com",
1602                                         "POST", (NameValueCollection) null);
1603                                 Assert.Fail ("#1");
1604                         } catch (ArgumentNullException ex) {
1605                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1606                                 Assert.IsNull (ex.InnerException, "#3");
1607                                 Assert.IsNotNull (ex.Message, "#4");
1608                                 Assert.IsNotNull (ex.ParamName, "#5");
1609                                 Assert.AreEqual ("data", ex.ParamName, "#6");
1610                         }
1611                 }
1612
1613                 [Test] // UploadValues (Uri, string, NameValueCollection)
1614                 public void UploadValues4_Address_Null ()
1615                 {
1616                         WebClient wc = new WebClient ();
1617                         try {
1618                                 wc.UploadValues ((Uri) null, "POST",
1619                                         new NameValueCollection ());
1620                                 Assert.Fail ("#1");
1621                         } catch (ArgumentNullException ex) {
1622                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1623                                 Assert.IsNull (ex.InnerException, "#3");
1624                                 Assert.IsNotNull (ex.Message, "#4");
1625                                 Assert.IsNotNull (ex.ParamName, "#5");
1626                                 Assert.AreEqual ("address", ex.ParamName, "#6");
1627                         }
1628                 }
1629
1630                 [Test] // UploadValues (Uri, string, NameValueCollection)
1631                 public void UploadValues4_Address_SchemeNotSupported ()
1632                 {
1633                         WebClient wc = new WebClient ();
1634                         try {
1635                                 wc.UploadValues (new Uri ("tp://scheme.notsupported"),
1636                                         "POST", new NameValueCollection ());
1637                                 Assert.Fail ("#1");
1638                         } catch (WebException ex) {
1639                                 // An error occurred performing a WebClient request
1640                                 Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
1641                                 Assert.IsNotNull (ex.InnerException, "#3");
1642                                 Assert.IsNotNull (ex.Message, "#4");
1643                                 Assert.IsNull (ex.Response, "#5");
1644                                 Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
1645
1646                                 // The URI prefix is not recognized
1647                                 Exception inner = ex.InnerException;
1648                                 Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
1649                                 Assert.IsNull (inner.InnerException, "#8");
1650                                 Assert.IsNotNull (inner.Message, "#9");
1651                         }
1652                 }
1653
1654                 [Test] // UploadValues (Uri, string, NameValueCollection)
1655                 public void UploadValues4_Data_Null ()
1656                 {
1657                         WebClient wc = new WebClient ();
1658                         try {
1659                                 wc.UploadValues (new Uri ("http://www.mono-project.com"),
1660                                         "POST", (NameValueCollection) null);
1661                                 Assert.Fail ("#1");
1662                         } catch (ArgumentNullException ex) {
1663                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1664                                 Assert.IsNull (ex.InnerException, "#3");
1665                                 Assert.IsNotNull (ex.Message, "#4");
1666                                 Assert.IsNotNull (ex.ParamName, "#5");
1667                                 Assert.AreEqual ("data", ex.ParamName, "#6");
1668                         }
1669                 }
1670
1671                 [Test]
1672                 public void GetWebRequestOverriding ()
1673                 {
1674                         GetWebRequestOverridingTestClass testObject = new GetWebRequestOverridingTestClass ();
1675                         testObject.DownloadData ("http://www.mono-project.com");
1676
1677                         Assert.IsTrue (testObject.overridedCodeRan, "Overrided code wasn't called");
1678                 }
1679
1680                 class GetWebRequestOverridingTestClass : WebClient
1681                 {
1682                         internal bool overridedCodeRan = false;
1683                         protected override WebRequest GetWebRequest(Uri address)
1684                         {
1685                                 overridedCodeRan = true;
1686                                 return base.GetWebRequest (address);
1687                         }
1688                 }
1689
1690                 static byte [] EchoRequestHandler (Socket socket)
1691                 {
1692                         MemoryStream ms = new MemoryStream ();
1693                         byte [] buffer = new byte [4096];
1694                         int bytesReceived = socket.Receive (buffer);
1695                         while (bytesReceived > 0) {
1696                                 ms.Write (buffer, 0, bytesReceived);
1697                                  // We don't check for Content-Length or anything else here, so we give the client a little time to write
1698                                  // after sending the headers
1699                                 Thread.Sleep (200);
1700                                 if (socket.Available > 0) {
1701                                         bytesReceived = socket.Receive (buffer);
1702                                 } else {
1703                                         bytesReceived = 0;
1704                                 }
1705                         }
1706                         ms.Flush ();
1707                         ms.Position = 0;
1708
1709                         StringBuilder sb = new StringBuilder ();
1710
1711                         string expect = null;
1712
1713                         StreamReader sr = new StreamReader (ms, Encoding.UTF8);
1714                         string line = null;
1715                         byte state = 0;
1716                         while ((line = sr.ReadLine ()) != null) {
1717                                 if (state > 0) {
1718                                         state = 2;
1719                                         sb.Append (line);
1720                                         sb.Append ("\r\n");
1721                                 } if (line.Length == 0) {
1722                                         state = 1;
1723                                 } else if (line.StartsWith ("Expect:")) {
1724                                         expect = line.Substring (8);
1725                                 }
1726                         }
1727
1728                         StringWriter sw = new StringWriter ();
1729
1730                         if (expect == "100-continue" && state != 2) {
1731                                 sw.WriteLine ("HTTP/1.1 100 Continue");
1732                                 sw.WriteLine ();
1733                                 sw.Flush ();
1734
1735                                 socket.Send (Encoding.UTF8.GetBytes (sw.ToString ()));
1736
1737                                 // receive body
1738                                 ms = new MemoryStream ();
1739                                 buffer = new byte [4096];
1740                                 bytesReceived = socket.Receive (buffer);
1741                                 while (bytesReceived > 0) {
1742                                         ms.Write (buffer, 0, bytesReceived);
1743                                         Thread.Sleep (200);
1744                                         if (socket.Available > 0) {
1745                                                 bytesReceived = socket.Receive (buffer);
1746                                         } else {
1747                                                 bytesReceived = 0;
1748                                         }
1749                                 }
1750                                 ms.Flush ();
1751                                 ms.Position = 0;
1752
1753                                 sb = new StringBuilder ();
1754                                 sr = new StreamReader (ms, Encoding.UTF8);
1755                                 line = sr.ReadLine ();
1756                                 while (line != null) {
1757                                         sb.Append (line);
1758                                         sb.Append ("\r\n");
1759                                         line = sr.ReadLine ();
1760                                 }
1761                         }
1762
1763                         sw = new StringWriter ();
1764                         sw.WriteLine ("HTTP/1.1 200 OK");
1765                         sw.WriteLine ("Content-Type: text/xml");
1766                         sw.WriteLine ("Content-Length: " + sb.Length.ToString (CultureInfo.InvariantCulture));
1767                         sw.WriteLine ();
1768                         sw.Write (sb.ToString ());
1769                         sw.Flush ();
1770
1771                         return Encoding.UTF8.GetBytes (sw.ToString ());
1772                 }
1773
1774                 [Test]
1775                 public void DefaultProxy ()
1776                 {
1777                         WebClient wc = new WebClient ();
1778                         // this is never null on .net
1779                         Assert.IsNotNull (wc.Proxy);
1780                         // and return the same instance as WebRequest.DefaultWebProxy
1781                         Assert.AreSame (wc.Proxy, WebRequest.DefaultWebProxy);
1782                 }
1783
1784 #if NET_4_5
1785                 [Test]
1786                 public void UploadStringAsyncCancelEvent ()
1787                 {
1788                         UploadAsyncCancelEventTest (9301, (webClient, uri, cancelEvent) =>
1789                         {
1790
1791                                 webClient.UploadStringCompleted += (sender, args) =>
1792                                 {
1793                                         if (args.Cancelled)
1794                                                 cancelEvent.Set ();
1795                                 };
1796
1797                                 webClient.UploadStringAsync (uri, "PUT", "text");
1798                         });
1799                 }
1800
1801                 [Test]
1802                 public void UploadDataAsyncCancelEvent ()
1803                 {
1804                         UploadAsyncCancelEventTest (9302, (webClient, uri, cancelEvent) =>
1805                         {
1806                                 webClient.UploadDataCompleted += (sender, args) =>
1807                                 {
1808                                         if (args.Cancelled)
1809                                                 cancelEvent.Set ();
1810                                 };
1811
1812                                 webClient.UploadDataAsync (uri, "PUT", new byte[] { });
1813                         });
1814                 }
1815
1816                 [Test]
1817                 public void UploadValuesAsyncCancelEvent ()
1818                 {
1819                         UploadAsyncCancelEventTest (9303, (webClient, uri, cancelEvent) =>
1820                         {
1821                                 webClient.UploadValuesCompleted += (sender, args) =>
1822                                 {
1823                                         if (args.Cancelled)
1824                                                 cancelEvent.Set ();
1825                                 };
1826
1827                                 webClient.UploadValuesAsync (uri, "PUT", new NameValueCollection ());
1828                         });
1829                 }
1830
1831                 [Test]
1832                 public void UploadFileAsyncCancelEvent ()
1833                 {
1834                         UploadAsyncCancelEventTest (9304,(webClient, uri, cancelEvent) =>
1835                         {
1836                                 string tempFile = Path.Combine (_tempFolder, "upload.tmp");
1837                                 File.Create (tempFile).Close ();
1838
1839                                 webClient.UploadFileCompleted += (sender, args) =>
1840                                 {
1841                                         if (args.Cancelled)
1842                                                 cancelEvent.Set ();
1843                                 };
1844
1845                                 webClient.UploadFileAsync (uri, "PUT", tempFile);
1846                         });
1847                 }
1848
1849                 [Test]
1850                 public void UploadFileAsyncContentType ()
1851                 {
1852                         var serverUri = "http://localhost:13370/";
1853                         var filename = Path.GetTempFileName ();
1854
1855                         HttpListener listener = new HttpListener ();
1856                         listener.Prefixes.Add (serverUri);
1857                         listener.Start ();
1858
1859                         using (var client = new WebClient ())
1860                         {
1861                                 client.UploadFileTaskAsync (new Uri (serverUri), filename);
1862                                 var request = listener.GetContext ().Request;
1863
1864                                 var expected = "multipart/form-data; boundary=---------------------";
1865                                 Assert.AreEqual (expected.Length + 15, request.ContentType.Length);
1866                                 Assert.AreEqual (expected, request.ContentType.Substring (0, expected.Length));
1867                         }
1868                         listener.Close ();
1869                 }
1870 #endif
1871
1872 #if NET_4_0
1873                 public void UploadAsyncCancelEventTest (int port, Action<WebClient, Uri, EventWaitHandle> uploadAction)
1874                 {
1875                         var ep = NetworkHelpers.LocalEphemeralEndPoint ();
1876                         string url = "http://" + ep.ToString() + "/test/";
1877
1878                         using (var responder = new SocketResponder (ep, EchoRequestHandler))
1879                         {
1880                                 responder.Start ();
1881
1882                                 var webClient = new WebClient ();
1883
1884                                 var cancellationTokenSource = new CancellationTokenSource ();
1885                                 cancellationTokenSource.Token.Register (webClient.CancelAsync);
1886
1887                                 var cancelEvent = new ManualResetEvent (false);
1888
1889                                 uploadAction.Invoke (webClient, new Uri (url), cancelEvent);
1890
1891                                 cancellationTokenSource.Cancel ();
1892
1893                                 Assert.IsTrue (cancelEvent.WaitOne (1000));
1894                         }
1895                 }
1896 #endif
1897         }
1898 }