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         [Category ("RequiresBSDSockets")]
  25         public class WebClientTest
  26         {
  27                 private string _tempFolder;
  28
  29                 [SetUp]
  30                 public void SetUp ()
  31                 {
  32                         _tempFolder = Path.Combine (Path.GetTempPath (),
  33                                 GetType ().FullName);
  34                         if (Directory.Exists (_tempFolder))
  35                                 Directory.Delete (_tempFolder, true);
  36                         Directory.CreateDirectory (_tempFolder);
  37                 }
  38
  39                 [TearDown]
  40                 public void TearDown ()
  41                 {
  42                         if (Directory.Exists (_tempFolder))
  43                                 Directory.Delete (_tempFolder, true);
  44                 }
  45
  46                 [Test]
  47                 [Category ("InetAccess")]
  48                 public void DownloadTwice ()
  49                 {
  50                         WebClient wc = new WebClient();
  51                         string filename = Path.GetTempFileName();
  52
  53                         // A new, but empty file has been created. This is a test case
  54                         // for bug 81005
  55                         wc.DownloadFile("http://google.com/", filename);
  56
  57                         // Now, remove the file and attempt to download again.
  58                         File.Delete(filename);
  59                         wc.DownloadFile("http://google.com/", filename);
  60                 }
  61
  62                 [Test]
  63                 public void DownloadData1_Address_Null ()
  64                 {
  65                         WebClient wc = new WebClient ();
  66                         try {
  67                                 wc.DownloadData ((string) null);
  68                                 Assert.Fail ("#1");
  69                         } catch (ArgumentNullException ex) {
  70                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
  71                                 Assert.IsNull (ex.InnerException, "#3");
  72                                 Assert.IsNotNull (ex.Message, "#4");
  73                                 Assert.IsNotNull (ex.ParamName, "#5");
  74                                 Assert.AreEqual ("address", ex.ParamName, "#6");
  75                         }
  76                 }
  77
  78                 [Test] // DownloadData (string)
  79                 public void DownloadData1_Address_SchemeNotSupported ()
  80                 {
  81                         WebClient wc = new WebClient ();
  82                         try {
  83                                 wc.DownloadData ("tp://scheme.notsupported");
  84                                 Assert.Fail ("#1");
  85                         } catch (WebException ex) {
  86                                 // An error occurred performing a WebClient request
  87                                 Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
  88                                 Assert.IsNotNull (ex.InnerException, "#3");
  89                                 Assert.IsNotNull (ex.Message, "#4");
  90                                 Assert.IsNull (ex.Response, "#5");
  91                                 Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
  92
  93                                 // The URI prefix is not recognized
  94                                 Exception inner = ex.InnerException;
  95                                 Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
  96                                 Assert.IsNull (inner.InnerException, "#8");
  97                                 Assert.IsNotNull (inner.Message, "#9");
  98                         }
  99                 }
 100
 101                 [Test] // DownloadData (Uri)
 102                 public void DownloadData2_Address_Null ()
 103                 {
 104                         WebClient wc = new WebClient ();
 105                         try {
 106                                 wc.DownloadData ((Uri) null);
 107                                 Assert.Fail ("#1");
 108                         } catch (ArgumentNullException ex) {
 109                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 110                                 Assert.IsNull (ex.InnerException, "#3");
 111                                 Assert.IsNotNull (ex.Message, "#4");
 112                                 Assert.IsNotNull (ex.ParamName, "#5");
 113                                 Assert.AreEqual ("address", ex.ParamName, "#6");
 114                         }
 115                 }
 116
 117                 [Test] // DownloadData (Uri)
 118                 public void DownloadData2_Address_SchemeNotSupported ()
 119                 {
 120                         WebClient wc = new WebClient ();
 121                         try {
 122                                 wc.DownloadData (new Uri ("tp://scheme.notsupported"));
 123                                 Assert.Fail ("#1");
 124                         } catch (WebException ex) {
 125                                 // An error occurred performing a WebClient request
 126                                 Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
 127                                 Assert.IsNotNull (ex.InnerException, "#3");
 128                                 Assert.IsNotNull (ex.Message, "#4");
 129                                 Assert.IsNull (ex.Response, "#5");
 130                                 Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
 131
 132                                 // The URI prefix is not recognized
 133                                 Exception inner = ex.InnerException;
 134                                 Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
 135                                 Assert.IsNull (inner.InnerException, "#8");
 136                                 Assert.IsNotNull (inner.Message, "#9");
 137                         }
 138                 }
 139
 140                 [Test]
 141                 public void DownloadFile1_Address_Null ()
 142                 {
 143                         WebClient wc = new WebClient ();
 144                         try {
 145                                 wc.DownloadFile ((string) null, "tmp.out");
 146                                 Assert.Fail ("#1");
 147                         } catch (ArgumentNullException ex) {
 148                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 149                                 Assert.IsNull (ex.InnerException, "#3");
 150                                 Assert.IsNotNull (ex.Message, "#4");
 151                                 Assert.IsNotNull (ex.ParamName, "#5");
 152                                 Assert.AreEqual ("address", ex.ParamName, "#6");
 153                         }
 154                 }
 155
 156                 [Test] // DownloadFile (string, string)
 157                 public void DownloadFile1_Address_SchemeNotSupported ()
 158                 {
 159                         string file = Path.Combine (Path.GetTempPath (), "tmp.out");
 160                         WebClient wc = new WebClient ();
 161                         try {
 162                                 wc.DownloadFile ("tp://scheme.notsupported", file);
 163                                 Assert.Fail ("#1");
 164                         } catch (WebException ex) {
 165                                 // An error occurred performing a WebClient request
 166                                 Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
 167                                 Assert.IsNotNull (ex.InnerException, "#3");
 168                                 Assert.IsNotNull (ex.Message, "#4");
 169                                 Assert.IsNull (ex.Response, "#5");
 170                                 Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
 171
 172                                 // The URI prefix is not recognized
 173                                 Exception inner = ex.InnerException;
 174                                 Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
 175                                 Assert.IsNull (inner.InnerException, "#8");
 176                                 Assert.IsNotNull (inner.Message, "#9");
 177                         }
 178                         finally {
 179                                 if (File.Exists (file))
 180                                         File.Delete (file);
 181                         }
 182                 }
 183
 184                 [Test] // DownloadFile (string, string)
 185                 public void DownloadFile1_FileName_Null ()
 186                 {
 187                         WebClient wc = new WebClient ();
 188                         try {
 189                                 wc.DownloadFile ("tp://scheme.notsupported",
 190                                         (string) null);
 191                                 Assert.Fail ("#1");
 192                         } catch (ArgumentNullException ex) {
 193                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 194                                 Assert.IsNull (ex.InnerException, "#3");
 195                                 Assert.IsNotNull (ex.Message, "#4");
 196                                 Assert.IsNotNull (ex.ParamName, "#5");
 197                                 Assert.AreEqual ("fileName", ex.ParamName, "#6");
 198                         }
 199                 }
 200
 201                 [Test] // DownloadFile (Uri, string)
 202                 public void DownloadFile2_Address_Null ()
 203                 {
 204                         WebClient wc = new WebClient ();
 205                         try {
 206                                 wc.DownloadFile ((Uri) null, "tmp.out");
 207                                 Assert.Fail ("#1");
 208                         } catch (ArgumentNullException ex) {
 209                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 210                                 Assert.IsNull (ex.InnerException, "#3");
 211                                 Assert.IsNotNull (ex.Message, "#4");
 212                                 Assert.IsNotNull (ex.ParamName, "#5");
 213                                 Assert.AreEqual ("address", ex.ParamName, "#6");
 214                         }
 215                 }
 216
 217                 [Test] // DownloadFile (Uri, string)
 218                 public void DownloadFile2_Address_SchemeNotSupported ()
 219                 {
 220                         string file = Path.Combine (Path.GetTempPath (), "tmp.out");
 221                         WebClient wc = new WebClient ();
 222                         try {
 223                                 wc.DownloadFile (new Uri ("tp://scheme.notsupported"), file);
 224                                 Assert.Fail ("#1");
 225                         } catch (WebException ex) {
 226                                 // An error occurred performing a WebClient request
 227                                 Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
 228                                 Assert.IsNotNull (ex.InnerException, "#3");
 229                                 Assert.IsNotNull (ex.Message, "#4");
 230                                 Assert.IsNull (ex.Response, "#5");
 231                                 Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
 232
 233                                 // The URI prefix is not recognized
 234                                 Exception inner = ex.InnerException;
 235                                 Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
 236                                 Assert.IsNull (inner.InnerException, "#8");
 237                                 Assert.IsNotNull (inner.Message, "#9");
 238                         }
 239                         finally {
 240                                 if (File.Exists (file))
 241                                         File.Delete (file);
 242                         }
 243                 }
 244
 245                 [Test] // DownloadFile (Uri, string)
 246                 public void DownloadFile2_FileName_Null ()
 247                 {
 248                         WebClient wc = new WebClient ();
 249                         try {
 250                                 wc.DownloadFile (new Uri ("tp://scheme.notsupported"),
 251                                         (string) null);
 252                                 Assert.Fail ("#1");
 253                         } catch (ArgumentNullException ex) {
 254                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 255                                 Assert.IsNull (ex.InnerException, "#3");
 256                                 Assert.IsNotNull (ex.Message, "#4");
 257                                 Assert.IsNotNull (ex.ParamName, "#5");
 258                                 Assert.AreEqual ("fileName", ex.ParamName, "#6");
 259                         }
 260                 }
 261
 262                 [Test] // DownloadString (string)
 263                 public void DownloadString1_Address_Null ()
 264                 {
 265                         WebClient wc = new WebClient ();
 266                         try {
 267                                 wc.DownloadString ((string) null);
 268                                 Assert.Fail ("#1");
 269                         } catch (ArgumentNullException ex) {
 270                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 271                                 Assert.IsNull (ex.InnerException, "#3");
 272                                 Assert.IsNotNull (ex.Message, "#4");
 273                                 Assert.IsNotNull (ex.ParamName, "#5");
 274                                 Assert.AreEqual ("address", ex.ParamName, "#6");
 275                         }
 276                 }
 277
 278                 [Test] // DownloadString (string)
 279                 public void DownloadString1_Address_SchemeNotSupported ()
 280                 {
 281                         WebClient wc = new WebClient ();
 282                         try {
 283                                 wc.DownloadString ("tp://scheme.notsupported");
 284                                 Assert.Fail ("#1");
 285                         } catch (WebException ex) {
 286                                 // An error occurred performing a WebClient request
 287                                 Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
 288                                 Assert.IsNotNull (ex.InnerException, "#3");
 289                                 Assert.IsNotNull (ex.Message, "#4");
 290                                 Assert.IsNull (ex.Response, "#5");
 291                                 Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
 292
 293                                 // The URI prefix is not recognized
 294                                 Exception inner = ex.InnerException;
 295                                 Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
 296                                 Assert.IsNull (inner.InnerException, "#8");
 297                                 Assert.IsNotNull (inner.Message, "#9");
 298                         }
 299                 }
 300
 301                 [Test] // DownloadString (Uri)
 302                 public void DownloadString2_Address_Null ()
 303                 {
 304                         WebClient wc = new WebClient ();
 305                         try {
 306                                 wc.DownloadString ((Uri) null);
 307                                 Assert.Fail ("#1");
 308                         } catch (ArgumentNullException ex) {
 309                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 310                                 Assert.IsNull (ex.InnerException, "#3");
 311                                 Assert.IsNotNull (ex.Message, "#4");
 312                                 Assert.IsNotNull (ex.ParamName, "#5");
 313                                 Assert.AreEqual ("address", ex.ParamName, "#6");
 314                         }
 315                 }
 316
 317                 [Test] // DownloadString (Uri)
 318                 public void DownloadString2_Address_SchemeNotSupported ()
 319                 {
 320                         WebClient wc = new WebClient ();
 321                         try {
 322                                 wc.DownloadString (new Uri ("tp://scheme.notsupported"));
 323                                 Assert.Fail ("#1");
 324                         } catch (WebException ex) {
 325                                 // An error occurred performing a WebClient request
 326                                 Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
 327                                 Assert.IsNotNull (ex.InnerException, "#3");
 328                                 Assert.IsNotNull (ex.Message, "#4");
 329                                 Assert.IsNull (ex.Response, "#5");
 330                                 Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
 331
 332                                 // The URI prefix is not recognized
 333                                 Exception inner = ex.InnerException;
 334                                 Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
 335                                 Assert.IsNull (inner.InnerException, "#8");
 336                                 Assert.IsNotNull (inner.Message, "#9");
 337                         }
 338                 }
 339
 340                 [Test]
 341                 public void EncodingTest ()
 342                 {
 343                         WebClient wc = new WebClient ();
 344                         Assert.AreSame (Encoding.Default, wc.Encoding, "#1");
 345                         wc.Encoding = Encoding.ASCII;
 346                         Assert.AreSame (Encoding.ASCII, wc.Encoding, "#2");
 347                 }
 348
 349                 [Test]
 350                 public void Encoding_Value_Null ()
 351                 {
 352                         WebClient wc = new WebClient ();
 353                         try {
 354                                 wc.Encoding = null;
 355                                 Assert.Fail ("#1");
 356                         } catch (ArgumentNullException ex) {
 357                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 358                                 Assert.IsNull (ex.InnerException, "#3");
 359                                 Assert.IsNotNull (ex.Message, "#4");
 360                                 Assert.AreEqual ("Encoding", ex.ParamName, "#6");
 361                         }
 362                 }
 363
 364                 [Test] // OpenRead (string)
 365                 public void OpenRead1_Address_Null ()
 366                 {
 367                         WebClient wc = new WebClient ();
 368                         try {
 369                                 wc.OpenRead ((string) null);
 370                                 Assert.Fail ("#1");
 371                         } catch (ArgumentNullException ex) {
 372                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 373                                 Assert.IsNull (ex.InnerException, "#3");
 374                                 Assert.IsNotNull (ex.Message, "#4");
 375                                 Assert.IsNotNull (ex.ParamName, "#5");
 376                                 Assert.AreEqual ("address", ex.ParamName, "#6");
 377                         }
 378                 }
 379
 380                 [Test] // OpenRead (string)
 381                 public void OpenRead1_Address_SchemeNotSupported ()
 382                 {
 383                         WebClient wc = new WebClient ();
 384                         try {
 385                                 wc.OpenRead ("tp://scheme.notsupported");
 386                                 Assert.Fail ("#1");
 387                         } catch (WebException ex) {
 388                                 // An error occurred performing a WebClient request
 389                                 Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
 390                                 Assert.IsNotNull (ex.InnerException, "#3");
 391                                 Assert.IsNotNull (ex.Message, "#4");
 392                                 Assert.IsNull (ex.Response, "#5");
 393                                 Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
 394
 395                                 // The URI prefix is not recognized
 396                                 Exception inner = ex.InnerException;
 397                                 Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
 398                                 Assert.IsNull (inner.InnerException, "#8");
 399                                 Assert.IsNotNull (inner.Message, "#9");
 400                         }
 401                 }
 402
 403                 [Test] // OpenRead (Uri)
 404                 public void OpenRead2_Address_Null ()
 405                 {
 406                         WebClient wc = new WebClient ();
 407                         try {
 408                                 wc.OpenRead ((Uri) null);
 409                                 Assert.Fail ("#1");
 410                         } catch (ArgumentNullException ex) {
 411                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 412                                 Assert.IsNull (ex.InnerException, "#3");
 413                                 Assert.IsNotNull (ex.Message, "#4");
 414                                 Assert.IsNotNull (ex.ParamName, "#5");
 415                                 Assert.AreEqual ("address", ex.ParamName, "#6");
 416                         }
 417                 }
 418
 419                 [Test] // OpenRead (Uri)
 420                 public void OpenRead2_Address_SchemeNotSupported ()
 421                 {
 422                         WebClient wc = new WebClient ();
 423                         try {
 424                                 wc.OpenRead (new Uri ("tp://scheme.notsupported"));
 425                                 Assert.Fail ("#1");
 426                         } catch (WebException ex) {
 427                                 // An error occurred performing a WebClient request
 428                                 Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
 429                                 Assert.IsNotNull (ex.InnerException, "#3");
 430                                 Assert.IsNotNull (ex.Message, "#4");
 431                                 Assert.IsNull (ex.Response, "#5");
 432                                 Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
 433
 434                                 // The URI prefix is not recognized
 435                                 Exception inner = ex.InnerException;
 436                                 Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
 437                                 Assert.IsNull (inner.InnerException, "#8");
 438                                 Assert.IsNotNull (inner.Message, "#9");
 439                         }
 440                 }
 441
 442                 [Test] // OpenWrite (string)
 443                 public void OpenWrite1_Address_Null ()
 444                 {
 445                         WebClient wc = new WebClient ();
 446                         try {
 447                                 wc.OpenWrite ((string) null);
 448                                 Assert.Fail ("#1");
 449                         } catch (ArgumentNullException ex) {
 450                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 451                                 Assert.IsNull (ex.InnerException, "#3");
 452                                 Assert.IsNotNull (ex.Message, "#4");
 453                                 Assert.IsNotNull (ex.ParamName, "#5");
 454                                 Assert.AreEqual ("address", ex.ParamName, "#6");
 455                         }
 456                 }
 457
 458                 [Test] // OpenWrite (string)
 459                 public void OpenWrite1_Address_SchemeNotSupported ()
 460                 {
 461                         WebClient wc = new WebClient ();
 462                         try {
 463                                 wc.OpenWrite ("tp://scheme.notsupported");
 464                                 Assert.Fail ("#1");
 465                         } catch (WebException ex) {
 466                                 // An error occurred performing a WebClient request
 467                                 Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
 468                                 Assert.IsNotNull (ex.InnerException, "#3");
 469                                 Assert.IsNotNull (ex.Message, "#4");
 470                                 Assert.IsNull (ex.Response, "#5");
 471                                 Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
 472
 473                                 // The URI prefix is not recognized
 474                                 Exception inner = ex.InnerException;
 475                                 Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
 476                                 Assert.IsNull (inner.InnerException, "#8");
 477                                 Assert.IsNotNull (inner.Message, "#9");
 478                         }
 479                 }
 480
 481                 [Test] // OpenWrite (string, string)
 482                 public void OpenWrite2_Address_Null ()
 483                 {
 484                         WebClient wc = new WebClient ();
 485                         try {
 486                                 wc.OpenWrite ((string) null, "PUT");
 487                                 Assert.Fail ("#1");
 488                         } catch (ArgumentNullException ex) {
 489                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 490                                 Assert.IsNull (ex.InnerException, "#3");
 491                                 Assert.IsNotNull (ex.Message, "#4");
 492                                 Assert.IsNotNull (ex.ParamName, "#5");
 493                                 Assert.AreEqual ("address", ex.ParamName, "#6");
 494                         }
 495                 }
 496
 497                 [Test] // OpenWrite (string, string)
 498                 public void OpenWrite2_Address_SchemeNotSupported ()
 499                 {
 500                         WebClient wc = new WebClient ();
 501                         try {
 502                                 wc.OpenWrite ("tp://scheme.notsupported", "PUT");
 503                                 Assert.Fail ("#1");
 504                         } catch (WebException ex) {
 505                                 // An error occurred performing a WebClient request
 506                                 Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
 507                                 Assert.IsNotNull (ex.InnerException, "#3");
 508                                 Assert.IsNotNull (ex.Message, "#4");
 509                                 Assert.IsNull (ex.Response, "#5");
 510                                 Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
 511
 512                                 // The URI prefix is not recognized
 513                                 Exception inner = ex.InnerException;
 514                                 Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
 515                                 Assert.IsNull (inner.InnerException, "#8");
 516                                 Assert.IsNotNull (inner.Message, "#9");
 517                         }
 518                 }
 519
 520                 [Test] // OpenWrite (Uri)
 521                 public void OpenWrite3_Address_Null ()
 522                 {
 523                         WebClient wc = new WebClient ();
 524                         try {
 525                                 wc.OpenWrite ((Uri) null);
 526                                 Assert.Fail ("#1");
 527                         } catch (ArgumentNullException ex) {
 528                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 529                                 Assert.IsNull (ex.InnerException, "#3");
 530                                 Assert.IsNotNull (ex.Message, "#4");
 531                                 Assert.IsNotNull (ex.ParamName, "#5");
 532                                 Assert.AreEqual ("address", ex.ParamName, "#6");
 533                         }
 534                 }
 535
 536                 [Test] // OpenWrite (Uri)
 537                 public void OpenWrite3_Address_SchemeNotSupported ()
 538                 {
 539                         WebClient wc = new WebClient ();
 540                         try {
 541                                 wc.OpenWrite (new Uri ("tp://scheme.notsupported"));
 542                                 Assert.Fail ("#1");
 543                         } catch (WebException ex) {
 544                                 // An error occurred performing a WebClient request
 545                                 Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
 546                                 Assert.IsNotNull (ex.InnerException, "#3");
 547                                 Assert.IsNotNull (ex.Message, "#4");
 548                                 Assert.IsNull (ex.Response, "#5");
 549                                 Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
 550
 551                                 // The URI prefix is not recognized
 552                                 Exception inner = ex.InnerException;
 553                                 Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
 554                                 Assert.IsNull (inner.InnerException, "#8");
 555                                 Assert.IsNotNull (inner.Message, "#9");
 556                         }
 557                 }
 558
 559                 [Test] // OpenWrite (Uri, string)
 560                 public void OpenWrite4_Address_Null ()
 561                 {
 562                         WebClient wc = new WebClient ();
 563                         try {
 564                                 wc.OpenWrite ((Uri) null, "POST");
 565                                 Assert.Fail ("#1");
 566                         } catch (ArgumentNullException ex) {
 567                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 568                                 Assert.IsNull (ex.InnerException, "#3");
 569                                 Assert.IsNotNull (ex.Message, "#4");
 570                                 Assert.IsNotNull (ex.ParamName, "#5");
 571                                 Assert.AreEqual ("address", ex.ParamName, "#6");
 572                         }
 573                 }
 574
 575                 [Test] // OpenWrite (Uri, string)
 576                 public void OpenWrite4_Address_SchemeNotSupported ()
 577                 {
 578                         WebClient wc = new WebClient ();
 579                         try {
 580                                 wc.OpenWrite (new Uri ("tp://scheme.notsupported"),
 581                                         "POST");
 582                                 Assert.Fail ("#1");
 583                         } catch (WebException ex) {
 584                                 // An error occurred performing a WebClient request
 585                                 Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
 586                                 Assert.IsNotNull (ex.InnerException, "#3");
 587                                 Assert.IsNotNull (ex.Message, "#4");
 588                                 Assert.IsNull (ex.Response, "#5");
 589                                 Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
 590
 591                                 // The URI prefix is not recognized
 592                                 Exception inner = ex.InnerException;
 593                                 Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
 594                                 Assert.IsNull (inner.InnerException, "#8");
 595                                 Assert.IsNotNull (inner.Message, "#9");
 596                         }
 597                 }
 598
 599                 [Test] // UploadData (string, byte [])
 600                 public void UploadData1_Address_Null ()
 601                 {
 602                         WebClient wc = new WebClient ();
 603                         try {
 604                                 wc.UploadData ((string) null, new byte [] { 0x1a });
 605                                 Assert.Fail ("#1");
 606                         } catch (ArgumentNullException ex) {
 607                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 608                                 Assert.IsNull (ex.InnerException, "#3");
 609                                 Assert.IsNotNull (ex.Message, "#4");
 610                                 Assert.IsNotNull (ex.ParamName, "#5");
 611                                 Assert.AreEqual ("address", ex.ParamName, "#6");
 612                         }
 613                 }
 614
 615                 [Test] // UploadData (string, byte [])
 616                 public void UploadData1_Address_SchemeNotSupported ()
 617                 {
 618                         WebClient wc = new WebClient ();
 619                         try {
 620                                 wc.UploadData ("tp://scheme.notsupported", new byte [] { 0x1a });
 621                                 Assert.Fail ("#1");
 622                         } catch (WebException ex) {
 623                                 // An error occurred performing a WebClient request
 624                                 Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
 625                                 Assert.IsNotNull (ex.InnerException, "#3");
 626                                 Assert.IsNotNull (ex.Message, "#4");
 627                                 Assert.IsNull (ex.Response, "#5");
 628                                 Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
 629
 630                                 // The URI prefix is not recognized
 631                                 Exception inner = ex.InnerException;
 632                                 Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
 633                                 Assert.IsNull (inner.InnerException, "#8");
 634                                 Assert.IsNotNull (inner.Message, "#9");
 635                         }
 636                 }
 637
 638                 [Test] // UploadData (string, byte [])
 639                 public void UploadData1_Data_Null ()
 640                 {
 641                         WebClient wc = new WebClient ();
 642                         try {
 643                                 wc.UploadData ("http://www.mono-project.com",
 644                                         (byte []) null);
 645                                 Assert.Fail ("#1");
 646                         } catch (ArgumentNullException ex) {
 647                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 648                                 Assert.IsNull (ex.InnerException, "#3");
 649                                 Assert.IsNotNull (ex.Message, "#4");
 650                                 Assert.IsNotNull (ex.ParamName, "#5");
 651                                 Assert.AreEqual ("data", ex.ParamName, "#6");
 652                         }
 653                 }
 654
 655                 [Test] // UploadData (Uri, byte [])
 656                 public void UploadData2_Address_Null ()
 657                 {
 658                         WebClient wc = new WebClient ();
 659                         try {
 660                                 wc.UploadData ((Uri) null, new byte [] { 0x1a });
 661                                 Assert.Fail ("#1");
 662                         } catch (ArgumentNullException ex) {
 663                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 664                                 Assert.IsNull (ex.InnerException, "#3");
 665                                 Assert.IsNotNull (ex.Message, "#4");
 666                                 Assert.IsNotNull (ex.ParamName, "#5");
 667                                 Assert.AreEqual ("address", ex.ParamName, "#6");
 668                         }
 669                 }
 670
 671                 [Test] // UploadData (Uri, byte [])
 672                 public void UploadData2_Address_SchemeNotSupported ()
 673                 {
 674                         WebClient wc = new WebClient ();
 675                         try {
 676                                 wc.UploadData (new Uri ("tp://scheme.notsupported"),
 677                                         new byte [] { 0x1a });
 678                                 Assert.Fail ("#1");
 679                         } catch (WebException ex) {
 680                                 // An error occurred performing a WebClient request
 681                                 Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
 682                                 Assert.IsNotNull (ex.InnerException, "#3");
 683                                 Assert.IsNotNull (ex.Message, "#4");
 684                                 Assert.IsNull (ex.Response, "#5");
 685                                 Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
 686
 687                                 // The URI prefix is not recognized
 688                                 Exception inner = ex.InnerException;
 689                                 Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
 690                                 Assert.IsNull (inner.InnerException, "#8");
 691                                 Assert.IsNotNull (inner.Message, "#9");
 692                         }
 693                 }
 694
 695                 [Test] // UploadData (Uri, byte [])
 696                 public void UploadData2_Data_Null ()
 697                 {
 698                         WebClient wc = new WebClient ();
 699                         try {
 700                                 wc.UploadData (new Uri ("http://www.mono-project.com"),
 701                                         (byte []) null);
 702                                 Assert.Fail ("#1");
 703                         } catch (ArgumentNullException ex) {
 704                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 705                                 Assert.IsNull (ex.InnerException, "#3");
 706                                 Assert.IsNotNull (ex.Message, "#4");
 707                                 Assert.IsNotNull (ex.ParamName, "#5");
 708                                 Assert.AreEqual ("data", ex.ParamName, "#6");
 709                         }
 710                 }
 711
 712                 [Test] // UploadData (string, string, byte [])
 713                 public void UploadData3_Address_Null ()
 714                 {
 715                         WebClient wc = new WebClient ();
 716                         try {
 717                                 wc.UploadData ((string) null, "POST",
 718                                         new byte [] { 0x1a });
 719                                 Assert.Fail ("#1");
 720                         } catch (ArgumentNullException ex) {
 721                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 722                                 Assert.IsNull (ex.InnerException, "#3");
 723                                 Assert.IsNotNull (ex.Message, "#4");
 724                                 Assert.IsNotNull (ex.ParamName, "#5");
 725                                 Assert.AreEqual ("address", ex.ParamName, "#6");
 726                         }
 727                 }
 728
 729                 [Test] // UploadData (string, string, byte [])
 730                 public void UploadData3_Address_SchemeNotSupported ()
 731                 {
 732                         WebClient wc = new WebClient ();
 733                         try {
 734                                 wc.UploadData ("tp://scheme.notsupported",
 735                                         "POST", new byte [] { 0x1a });
 736                                 Assert.Fail ("#1");
 737                         } catch (WebException ex) {
 738                                 // An error occurred performing a WebClient request
 739                                 Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
 740                                 Assert.IsNotNull (ex.InnerException, "#3");
 741                                 Assert.IsNotNull (ex.Message, "#4");
 742                                 Assert.IsNull (ex.Response, "#5");
 743                                 Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
 744
 745                                 // The URI prefix is not recognized
 746                                 Exception inner = ex.InnerException;
 747                                 Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
 748                                 Assert.IsNull (inner.InnerException, "#8");
 749                                 Assert.IsNotNull (inner.Message, "#9");
 750                         }
 751                 }
 752
 753                 [Test] // UploadData (string, string, byte [])
 754                 public void UploadData3_Data_Null ()
 755                 {
 756                         WebClient wc = new WebClient ();
 757                         try {
 758                                 wc.UploadData ("http://www.mono-project.com",
 759                                         "POST", (byte []) null);
 760                                 Assert.Fail ("#1");
 761                         } catch (ArgumentNullException ex) {
 762                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 763                                 Assert.IsNull (ex.InnerException, "#3");
 764                                 Assert.IsNotNull (ex.Message, "#4");
 765                                 Assert.IsNotNull (ex.ParamName, "#5");
 766                                 Assert.AreEqual ("data", ex.ParamName, "#6");
 767                         }
 768                 }
 769
 770                 [Test] // UploadData (Uri, string, byte [])
 771                 public void UploadData4_Address_Null ()
 772                 {
 773                         WebClient wc = new WebClient ();
 774                         try {
 775                                 wc.UploadData ((Uri) null, "POST", new byte [] { 0x1a });
 776                                 Assert.Fail ("#1");
 777                         } catch (ArgumentNullException ex) {
 778                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 779                                 Assert.IsNull (ex.InnerException, "#3");
 780                                 Assert.IsNotNull (ex.Message, "#4");
 781                                 Assert.IsNotNull (ex.ParamName, "#5");
 782                                 Assert.AreEqual ("address", ex.ParamName, "#6");
 783                         }
 784                 }
 785
 786                 [Test] // UploadData (Uri, string, byte [])
 787                 public void UploadData4_Address_SchemeNotSupported ()
 788                 {
 789                         WebClient wc = new WebClient ();
 790                         try {
 791                                 wc.UploadData (new Uri ("tp://scheme.notsupported"),
 792                                         "POST", new byte [] { 0x1a });
 793                                 Assert.Fail ("#1");
 794                         } catch (WebException ex) {
 795                                 // An error occurred performing a WebClient request
 796                                 Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
 797                                 Assert.IsNotNull (ex.InnerException, "#3");
 798                                 Assert.IsNotNull (ex.Message, "#4");
 799                                 Assert.IsNull (ex.Response, "#5");
 800                                 Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
 801
 802                                 // The URI prefix is not recognized
 803                                 Exception inner = ex.InnerException;
 804                                 Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
 805                                 Assert.IsNull (inner.InnerException, "#8");
 806                                 Assert.IsNotNull (inner.Message, "#9");
 807                         }
 808                 }
 809
 810                 [Test] // UploadData (Uri, string, byte [])
 811                 public void UploadData4_Data_Null ()
 812                 {
 813                         WebClient wc = new WebClient ();
 814                         try {
 815                                 wc.UploadData (new Uri ("http://www.mono-project.com"),
 816                                         "POST", (byte []) null);
 817                                 Assert.Fail ("#1");
 818                         } catch (ArgumentNullException ex) {
 819                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 820                                 Assert.IsNull (ex.InnerException, "#3");
 821                                 Assert.IsNotNull (ex.Message, "#4");
 822                                 Assert.IsNotNull (ex.ParamName, "#5");
 823                                 Assert.AreEqual ("data", ex.ParamName, "#6");
 824                         }
 825                 }
 826
 827                 [Test] // UploadFile (string, string)
 828                 public void UploadFile1_Address_Null ()
 829                 {
 830                         string tempFile = Path.Combine (_tempFolder, "upload.tmp");
 831                         File.Create (tempFile).Close ();
 832
 833                         WebClient wc = new WebClient ();
 834                         try {
 835                                 wc.UploadFile ((string) null, tempFile);
 836                                 Assert.Fail ("#1");
 837                         } catch (ArgumentNullException ex) {
 838                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 839                                 Assert.IsNull (ex.InnerException, "#3");
 840                                 Assert.IsNotNull (ex.Message, "#4");
 841                                 Assert.IsNotNull (ex.ParamName, "#5");
 842                                 Assert.AreEqual ("address", ex.ParamName, "#6");
 843                         }
 844                 }
 845
 846                 [Test] // UploadFile (string, string)
 847                 public void UploadFile1_Address_SchemeNotSupported ()
 848                 {
 849                         string tempFile = Path.Combine (_tempFolder, "upload.tmp");
 850                         File.Create (tempFile).Close ();
 851
 852                         WebClient wc = new WebClient ();
 853                         try {
 854                                 wc.UploadFile ("tp://scheme.notsupported",
 855                                         tempFile);
 856                                 Assert.Fail ("#1");
 857                         } catch (WebException ex) {
 858                                 // An error occurred performing a WebClient request
 859                                 Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
 860                                 Assert.IsNotNull (ex.InnerException, "#3");
 861                                 Assert.IsNotNull (ex.Message, "#4");
 862                                 Assert.IsNull (ex.Response, "#5");
 863                                 Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
 864
 865                                 // The URI prefix is not recognized
 866                                 Exception inner = ex.InnerException;
 867                                 Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
 868                                 Assert.IsNull (inner.InnerException, "#8");
 869                                 Assert.IsNotNull (inner.Message, "#9");
 870                         }
 871                 }
 872
 873                 [Test] // UploadFile (string, string)
 874                 public void UploadFile1_FileName_NotFound ()
 875                 {
 876                         string tempFile = Path.Combine (_tempFolder, "upload.tmp");
 877
 878                         WebClient wc = new WebClient ();
 879                         try {
 880                                 wc.UploadFile ("tp://scheme.notsupported",
 881                                         tempFile);
 882                                 Assert.Fail ("#1");
 883                         } catch (WebException ex) {
 884                                 // An error occurred performing a WebClient request
 885                                 Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
 886                                 Assert.IsNotNull (ex.Message, "#3");
 887                                 Assert.IsNull (ex.Response, "#4");
 888                                 Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#5");
 889
 890                                 // Could not find file "..."
 891                                 FileNotFoundException inner = ex.InnerException
 892                                         as FileNotFoundException;
 893                                 Assert.IsNotNull (inner, "#6");
 894                                 Assert.AreEqual (typeof (FileNotFoundException), inner.GetType (), "#7");
 895                                 Assert.IsNotNull (inner.FileName, "#8");
 896                                 Assert.AreEqual (tempFile, inner.FileName, "#9");
 897                                 Assert.IsNull (inner.InnerException, "#10");
 898                                 Assert.IsNotNull (inner.Message, "#11");
 899                         }
 900                 }
 901
 902                 [Test] // UploadFile (string, string)
 903                 public void UploadFile1_FileName_Null ()
 904                 {
 905                         WebClient wc = new WebClient ();
 906                         try {
 907                                 wc.UploadFile ("tp://scheme.notsupported",
 908                                         (string) null);
 909                                 Assert.Fail ("#1");
 910                         } catch (ArgumentNullException ex) {
 911                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 912                                 Assert.IsNull (ex.InnerException, "#3");
 913                                 Assert.IsNotNull (ex.Message, "#4");
 914                                 Assert.IsNotNull (ex.ParamName, "#5");
 915                                 Assert.AreEqual ("fileName", ex.ParamName, "#6");
 916                         }
 917                 }
 918
 919                 [Test] // UploadFile (Uri, string)
 920                 public void UploadFile2_Address_Null ()
 921                 {
 922                         string tempFile = Path.Combine (_tempFolder, "upload.tmp");
 923
 924                         WebClient wc = new WebClient ();
 925                         try {
 926                                 wc.UploadFile ((Uri) null, tempFile);
 927                                 Assert.Fail ("#1");
 928                         } catch (ArgumentNullException ex) {
 929                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 930                                 Assert.IsNull (ex.InnerException, "#3");
 931                                 Assert.IsNotNull (ex.Message, "#4");
 932                                 Assert.IsNotNull (ex.ParamName, "#5");
 933                                 Assert.AreEqual ("address", ex.ParamName, "#6");
 934                         }
 935                 }
 936
 937                 [Test] // UploadFile (Uri, string)
 938                 public void UploadFile2_Address_SchemeNotSupported ()
 939                 {
 940                         string tempFile = Path.Combine (_tempFolder, "upload.tmp");
 941                         File.Create (tempFile).Close ();
 942
 943                         WebClient wc = new WebClient ();
 944                         try {
 945                                 wc.UploadFile (new Uri ("tp://scheme.notsupported"),
 946                                         tempFile);
 947                                 Assert.Fail ("#1");
 948                         } catch (WebException ex) {
 949                                 // An error occurred performing a WebClient request
 950                                 Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
 951                                 Assert.IsNotNull (ex.InnerException, "#3");
 952                                 Assert.IsNotNull (ex.Message, "#4");
 953                                 Assert.IsNull (ex.Response, "#5");
 954                                 Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
 955
 956                                 // The URI prefix is not recognized
 957                                 Exception inner = ex.InnerException;
 958                                 Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
 959                                 Assert.IsNull (inner.InnerException, "#8");
 960                                 Assert.IsNotNull (inner.Message, "#9");
 961                         }
 962                 }
 963
 964                 [Test] // UploadFile (Uri, string)
 965                 public void UploadFile2_FileName_NotFound ()
 966                 {
 967                         string tempFile = Path.Combine (_tempFolder, "upload.tmp");
 968
 969                         WebClient wc = new WebClient ();
 970                         try {
 971                                 wc.UploadFile (new Uri ("tp://scheme.notsupported"),
 972                                         tempFile);
 973                                 Assert.Fail ("#1");
 974                         } catch (WebException ex) {
 975                                 // An error occurred performing a WebClient request
 976                                 Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
 977                                 Assert.IsNotNull (ex.Message, "#3");
 978                                 Assert.IsNull (ex.Response, "#4");
 979                                 Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#5");
 980
 981                                 // Could not find file "..."
 982                                 FileNotFoundException inner = ex.InnerException
 983                                         as FileNotFoundException;
 984                                 Assert.IsNotNull (inner, "#6");
 985                                 Assert.AreEqual (typeof (FileNotFoundException), inner.GetType (), "#7");
 986                                 Assert.IsNotNull (inner.FileName, "#8");
 987                                 Assert.AreEqual (tempFile, inner.FileName, "#9");
 988                                 Assert.IsNull (inner.InnerException, "#10");
 989                                 Assert.IsNotNull (inner.Message, "#11");
 990                         }
 991                 }
 992
 993                 [Test] // UploadFile (Uri, string)
 994                 public void UploadFile2_FileName_Null ()
 995                 {
 996                         WebClient wc = new WebClient ();
 997                         try {
 998                                 wc.UploadFile (new Uri ("tp://scheme.notsupported"),
 999                                         null);
1000                                 Assert.Fail ("#1");
1001                         } catch (ArgumentNullException ex) {
1002                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1003                                 Assert.IsNull (ex.InnerException, "#3");
1004                                 Assert.IsNotNull (ex.Message, "#4");
1005                                 Assert.IsNotNull (ex.ParamName, "#5");
1006                                 Assert.AreEqual ("fileName", ex.ParamName, "#6");
1007                         }
1008                 }
1009
1010                 [Test] // UploadFile (string, string, string)
1011                 public void UploadFile3_Address_Null ()
1012                 {
1013                         string tempFile = Path.Combine (_tempFolder, "upload.tmp");
1014                         File.Create (tempFile).Close ();
1015
1016                         WebClient wc = new WebClient ();
1017                         try {
1018                                 wc.UploadFile ((string) null, "POST", tempFile);
1019                                 Assert.Fail ("#1");
1020                         } catch (ArgumentNullException ex) {
1021                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1022                                 Assert.IsNull (ex.InnerException, "#3");
1023                                 Assert.IsNotNull (ex.Message, "#4");
1024                                 Assert.IsNotNull (ex.ParamName, "#5");
1025                                 Assert.AreEqual ("path", ex.ParamName, "#6");
1026                         }
1027                 }
1028
1029                 [Test] // UploadFile (string, string, string)
1030                 public void UploadFile3_Address_SchemeNotSupported ()
1031                 {
1032                         string tempFile = Path.Combine (_tempFolder, "upload.tmp");
1033                         File.Create (tempFile).Close ();
1034
1035                         WebClient wc = new WebClient ();
1036                         try {
1037                                 wc.UploadFile ("tp://scheme.notsupported",
1038                                         "POST", tempFile);
1039                                 Assert.Fail ("#1");
1040                         } catch (WebException ex) {
1041                                 // An error occurred performing a WebClient request
1042                                 Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
1043                                 Assert.IsNotNull (ex.InnerException, "#3");
1044                                 Assert.IsNotNull (ex.Message, "#4");
1045                                 Assert.IsNull (ex.Response, "#5");
1046                                 Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
1047
1048                                 // The URI prefix is not recognized
1049                                 Exception inner = ex.InnerException;
1050                                 Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
1051                                 Assert.IsNull (inner.InnerException, "#8");
1052                                 Assert.IsNotNull (inner.Message, "#9");
1053                         }
1054                 }
1055
1056                 [Test] // UploadFile (string, string, string)
1057                 public void UploadFile3_FileName_NotFound ()
1058                 {
1059                         string tempFile = Path.Combine (_tempFolder, "upload.tmp");
1060
1061                         WebClient wc = new WebClient ();
1062                         try {
1063                                 wc.UploadFile ("tp://scheme.notsupported",
1064                                         "POST", tempFile);
1065                                 Assert.Fail ("#1");
1066                         } catch (WebException ex) {
1067                                 // An error occurred performing a WebClient request
1068                                 Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
1069                                 Assert.IsNotNull (ex.Message, "#3");
1070                                 Assert.IsNull (ex.Response, "#4");
1071                                 Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#5");
1072
1073                                 // Could not find file "..."
1074                                 FileNotFoundException inner = ex.InnerException
1075                                         as FileNotFoundException;
1076                                 Assert.IsNotNull (inner, "#6");
1077                                 Assert.AreEqual (typeof (FileNotFoundException), inner.GetType (), "#7");
1078                                 Assert.IsNotNull (inner.FileName, "#8");
1079                                 Assert.AreEqual (tempFile, inner.FileName, "#9");
1080                                 Assert.IsNull (inner.InnerException, "#10");
1081                                 Assert.IsNotNull (inner.Message, "#11");
1082                         }
1083                 }
1084
1085                 [Test] // UploadFile (string, string, string)
1086                 public void UploadFile3_FileName_Null ()
1087                 {
1088                         WebClient wc = new WebClient ();
1089                         try {
1090                                 wc.UploadFile ("tp://scheme.notsupported",
1091                                         "POST", (string) null);
1092                                 Assert.Fail ("#1");
1093                         } catch (ArgumentNullException ex) {
1094                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1095                                 Assert.IsNull (ex.InnerException, "#3");
1096                                 Assert.IsNotNull (ex.Message, "#4");
1097                                 Assert.IsNotNull (ex.ParamName, "#5");
1098                                 Assert.AreEqual ("fileName", ex.ParamName, "#6");
1099                         }
1100                 }
1101
1102                 [Test] // UploadFile (Uri, string, string)
1103                 public void UploadFile4_Address_Null ()
1104                 {
1105                         string tempFile = Path.Combine (_tempFolder, "upload.tmp");
1106
1107                         WebClient wc = new WebClient ();
1108                         try {
1109                                 wc.UploadFile ((Uri) null, "POST", tempFile);
1110                                 Assert.Fail ("#1");
1111                         } catch (ArgumentNullException ex) {
1112                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1113                                 Assert.IsNull (ex.InnerException, "#3");
1114                                 Assert.IsNotNull (ex.Message, "#4");
1115                                 Assert.IsNotNull (ex.ParamName, "#5");
1116                                 Assert.AreEqual ("address", ex.ParamName, "#6");
1117                         }
1118                 }
1119
1120                 [Test] // UploadFile (Uri, string, string)
1121                 public void UploadFile4_Address_SchemeNotSupported ()
1122                 {
1123                         string tempFile = Path.Combine (_tempFolder, "upload.tmp");
1124                         File.Create (tempFile).Close ();
1125
1126                         WebClient wc = new WebClient ();
1127                         try {
1128                                 wc.UploadFile (new Uri ("tp://scheme.notsupported"),
1129                                         "POST", tempFile);
1130                                 Assert.Fail ("#1");
1131                         } catch (WebException ex) {
1132                                 // An error occurred performing a WebClient request
1133                                 Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
1134                                 Assert.IsNotNull (ex.InnerException, "#3");
1135                                 Assert.IsNotNull (ex.Message, "#4");
1136                                 Assert.IsNull (ex.Response, "#5");
1137                                 Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
1138
1139                                 // The URI prefix is not recognized
1140                                 Exception inner = ex.InnerException;
1141                                 Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
1142                                 Assert.IsNull (inner.InnerException, "#8");
1143                                 Assert.IsNotNull (inner.Message, "#9");
1144                         }
1145                 }
1146
1147                 [Test] // UploadFile (Uri, string, string)
1148                 public void UploadFile4_FileName_NotFound ()
1149                 {
1150                         string tempFile = Path.Combine (_tempFolder, "upload.tmp");
1151
1152                         WebClient wc = new WebClient ();
1153                         try {
1154                                 wc.UploadFile (new Uri ("tp://scheme.notsupported"),
1155                                         "POST", tempFile);
1156                                 Assert.Fail ("#1");
1157                         } catch (WebException ex) {
1158                                 // An error occurred performing a WebClient request
1159                                 Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
1160                                 Assert.IsNotNull (ex.Message, "#3");
1161                                 Assert.IsNull (ex.Response, "#4");
1162                                 Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#5");
1163
1164                                 // Could not find file "..."
1165                                 FileNotFoundException inner = ex.InnerException
1166                                         as FileNotFoundException;
1167                                 Assert.IsNotNull (inner, "#6");
1168                                 Assert.AreEqual (typeof (FileNotFoundException), inner.GetType (), "#7");
1169                                 Assert.IsNotNull (inner.FileName, "#8");
1170                                 Assert.AreEqual (tempFile, inner.FileName, "#9");
1171                                 Assert.IsNull (inner.InnerException, "#10");
1172                                 Assert.IsNotNull (inner.Message, "#11");
1173                         }
1174                 }
1175
1176                 [Test] // UploadFile (Uri, string, string)
1177                 public void UploadFile4_FileName_Null ()
1178                 {
1179                         WebClient wc = new WebClient ();
1180                         try {
1181                                 wc.UploadFile (new Uri ("tp://scheme.notsupported"),
1182                                         "POST", (string) null);
1183                                 Assert.Fail ("#1");
1184                         } catch (ArgumentNullException ex) {
1185                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1186                                 Assert.IsNull (ex.InnerException, "#3");
1187                                 Assert.IsNotNull (ex.Message, "#4");
1188                                 Assert.IsNotNull (ex.ParamName, "#5");
1189                                 Assert.AreEqual ("fileName", ex.ParamName, "#6");
1190                         }
1191                 }
1192
1193                 [Test] // UploadString (string, string)
1194                 public void UploadString1_Address_Null ()
1195                 {
1196                         WebClient wc = new WebClient ();
1197                         try {
1198                                 wc.UploadString ((string) null, (string) null);
1199                                 Assert.Fail ("#1");
1200                         } catch (ArgumentNullException ex) {
1201                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1202                                 Assert.IsNull (ex.InnerException, "#3");
1203                                 Assert.IsNotNull (ex.Message, "#4");
1204                                 Assert.IsNotNull (ex.ParamName, "#5");
1205                                 Assert.AreEqual ("address", ex.ParamName, "#6");
1206                         }
1207                 }
1208
1209                 [Test] // UploadString (string, string)
1210                 public void UploadString1_Address_SchemeNotSupported ()
1211                 {
1212                         WebClient wc = new WebClient ();
1213                         try {
1214                                 wc.UploadString ("tp://scheme.notsupported", "abc");
1215                                 Assert.Fail ("#1");
1216                         } catch (WebException ex) {
1217                                 // An error occurred performing a WebClient request
1218                                 Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
1219                                 Assert.IsNotNull (ex.InnerException, "#3");
1220                                 Assert.IsNotNull (ex.Message, "#4");
1221                                 Assert.IsNull (ex.Response, "#5");
1222                                 Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
1223
1224                                 // The URI prefix is not recognized
1225                                 Exception inner = ex.InnerException;
1226                                 Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
1227                                 Assert.IsNull (inner.InnerException, "#8");
1228                                 Assert.IsNotNull (inner.Message, "#9");
1229                         }
1230                 }
1231
1232                 [Test] // UploadString (string, string)
1233                 public void UploadString1_Data_Null ()
1234                 {
1235                         WebClient wc = new WebClient ();
1236                         try {
1237                                 wc.UploadString ("tp://scheme.notsupported", (string) null);
1238                                 Assert.Fail ("#1");
1239                         } catch (ArgumentNullException ex) {
1240                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1241                                 Assert.IsNull (ex.InnerException, "#3");
1242                                 Assert.IsNotNull (ex.Message, "#4");
1243                                 Assert.IsNotNull (ex.ParamName, "#5");
1244                                 Assert.AreEqual ("data", ex.ParamName, "#6");
1245                         }
1246                 }
1247
1248                 [Test] // UploadString (Uri, string)
1249                 public void UploadString2_Address_Null ()
1250                 {
1251                         WebClient wc = new WebClient ();
1252                         try {
1253                                 wc.UploadString ((Uri) null, (string) null);
1254                                 Assert.Fail ("#1");
1255                         } catch (ArgumentNullException ex) {
1256                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1257                                 Assert.IsNull (ex.InnerException, "#3");
1258                                 Assert.IsNotNull (ex.Message, "#4");
1259                                 Assert.IsNotNull (ex.ParamName, "#5");
1260                                 Assert.AreEqual ("address", ex.ParamName, "#6");
1261                         }
1262                 }
1263
1264                 [Test] // UploadString (Uri, string)
1265                 public void UploadString2_Address_SchemeNotSupported ()
1266                 {
1267                         WebClient wc = new WebClient ();
1268                         try {
1269                                 wc.UploadString (new Uri ("tp://scheme.notsupported"), "abc");
1270                                 Assert.Fail ("#1");
1271                         } catch (WebException ex) {
1272                                 // An error occurred performing a WebClient request
1273                                 Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
1274                                 Assert.IsNotNull (ex.InnerException, "#3");
1275                                 Assert.IsNotNull (ex.Message, "#4");
1276                                 Assert.IsNull (ex.Response, "#5");
1277                                 Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
1278
1279                                 // The URI prefix is not recognized
1280                                 Exception inner = ex.InnerException;
1281                                 Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
1282                                 Assert.IsNull (inner.InnerException, "#8");
1283                                 Assert.IsNotNull (inner.Message, "#9");
1284                         }
1285                 }
1286
1287                 [Test] // UploadString (Uri, string)
1288                 public void UploadString2_Data_Null ()
1289                 {
1290                         WebClient wc = new WebClient ();
1291                         try {
1292                                 wc.UploadString (new Uri ("tp://scheme.notsupported"),
1293                                         (string) null);
1294                                 Assert.Fail ("#1");
1295                         } catch (ArgumentNullException ex) {
1296                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1297                                 Assert.IsNull (ex.InnerException, "#3");
1298                                 Assert.IsNotNull (ex.Message, "#4");
1299                                 Assert.IsNotNull (ex.ParamName, "#5");
1300                                 Assert.AreEqual ("data", ex.ParamName, "#6");
1301                         }
1302                 }
1303
1304                 [Test] // UploadString (string, string, string)
1305                 public void UploadString3_Address_Null ()
1306                 {
1307                         WebClient wc = new WebClient ();
1308                         try {
1309                                 wc.UploadString ((string) null, (string) null,
1310                                         (string) null);
1311                                 Assert.Fail ("#1");
1312                         } catch (ArgumentNullException ex) {
1313                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1314                                 Assert.IsNull (ex.InnerException, "#3");
1315                                 Assert.IsNotNull (ex.Message, "#4");
1316                                 Assert.IsNotNull (ex.ParamName, "#5");
1317                                 Assert.AreEqual ("address", ex.ParamName, "#6");
1318                         }
1319                 }
1320
1321                 [Test] // UploadString (string, string, string)
1322                 public void UploadString3_Address_SchemeNotSupported ()
1323                 {
1324                         WebClient wc = new WebClient ();
1325                         try {
1326                                 wc.UploadString ("tp://scheme.notsupported",
1327                                         "POST", "abc");
1328                                 Assert.Fail ("#1");
1329                         } catch (WebException ex) {
1330                                 // An error occurred performing a WebClient request
1331                                 Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
1332                                 Assert.IsNotNull (ex.InnerException, "#3");
1333                                 Assert.IsNotNull (ex.Message, "#4");
1334                                 Assert.IsNull (ex.Response, "#5");
1335                                 Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
1336
1337                                 // The URI prefix is not recognized
1338                                 Exception inner = ex.InnerException;
1339                                 Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
1340                                 Assert.IsNull (inner.InnerException, "#8");
1341                                 Assert.IsNotNull (inner.Message, "#9");
1342                         }
1343                 }
1344
1345                 [Test] // UploadString (string, string, string)
1346                 public void UploadString3_Data_Null ()
1347                 {
1348                         WebClient wc = new WebClient ();
1349                         try {
1350                                 wc.UploadString ("tp://scheme.notsupported",
1351                                         "POST", (string) null);
1352                                 Assert.Fail ("#1");
1353                         } catch (ArgumentNullException ex) {
1354                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1355                                 Assert.IsNull (ex.InnerException, "#3");
1356                                 Assert.IsNotNull (ex.Message, "#4");
1357                                 Assert.IsNotNull (ex.ParamName, "#5");
1358                                 Assert.AreEqual ("data", ex.ParamName, "#6");
1359                         }
1360                 }
1361
1362                 [Test] // UploadString (Uri, string, string)
1363                 public void UploadString4_Address_Null ()
1364                 {
1365                         WebClient wc = new WebClient ();
1366                         try {
1367                                 wc.UploadString ((Uri) null, (string) null,
1368                                         (string) null);
1369                                 Assert.Fail ("#1");
1370                         } catch (ArgumentNullException ex) {
1371                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1372                                 Assert.IsNull (ex.InnerException, "#3");
1373                                 Assert.IsNotNull (ex.Message, "#4");
1374                                 Assert.IsNotNull (ex.ParamName, "#5");
1375                                 Assert.AreEqual ("address", ex.ParamName, "#6");
1376                         }
1377                 }
1378
1379                 [Test] // UploadString (Uri, string, string)
1380                 public void UploadString4_Address_SchemeNotSupported ()
1381                 {
1382                         WebClient wc = new WebClient ();
1383                         try {
1384                                 wc.UploadString (new Uri ("tp://scheme.notsupported"),
1385                                         "POST", "abc");
1386                                 Assert.Fail ("#1");
1387                         } catch (WebException ex) {
1388                                 // An error occurred performing a WebClient request
1389                                 Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
1390                                 Assert.IsNotNull (ex.InnerException, "#3");
1391                                 Assert.IsNotNull (ex.Message, "#4");
1392                                 Assert.IsNull (ex.Response, "#5");
1393                                 Assert.AreEqual (WebExceptionStatus.UnknownError, ex.Status, "#6");
1394
1395                                 // The URI prefix is not recognized
1396                                 Exception inner = ex.InnerException;
1397                                 Assert.AreEqual (typeof (NotSupportedException), inner.GetType (), "#7");
1398                                 Assert.IsNull (inner.InnerException, "#8");
1399                                 Assert.IsNotNull (inner.Message, "#9");
1400                         }
1401                 }
1402
1403                 [Test] // UploadString (Uri, string, string)
1404                 public void UploadString4_Data_Null ()
1405                 {
1406                         WebClient wc = new WebClient ();
1407                         try {
1408                                 wc.UploadString (new Uri ("tp://scheme.notsupported"),
1409                                         "POST", (string) null);
1410                                 Assert.Fail ("#1");
1411                         } catch (ArgumentNullException ex) {
1412                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1413                                 Assert.IsNull (ex.InnerException, "#3");
1414                                 Assert.IsNotNull (ex.Message, "#4");
1415                                 Assert.IsNotNull (ex.ParamName, "#5");
1416                                 Assert.AreEqual ("data", ex.ParamName, "#6");
1417                         }
1418                 }
1419
1420                 [Test]
1421                 [Category ("AndroidNotWorking")] // Fails when ran as part of the entire BCL test suite. Works when only this fixture is ran
1422                 public void UploadValues1 ()
1423                 {
1424                         IPEndPoint ep = NetworkHelpers.LocalEphemeralEndPoint ();
1425                         string url = "http://" + ep.ToString () + "/test/";
1426
1427                         using (SocketResponder responder = new SocketResponder (ep, s => EchoRequestHandler (s))) {
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                 [Test]
1785                 [Category ("AndroidNotWorking")] // Fails when ran as part of the entire BCL test suite. Works when only this fixture is ran
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                 [Category ("AndroidNotWorking")] // Fails when ran as part of the entire BCL test suite. Works when only this fixture is ran
1803                 public void UploadDataAsyncCancelEvent ()
1804                 {
1805                         UploadAsyncCancelEventTest (9302, (webClient, uri, cancelEvent) =>
1806                         {
1807                                 webClient.UploadDataCompleted += (sender, args) =>
1808                                 {
1809                                         if (args.Cancelled)
1810                                                 cancelEvent.Set ();
1811                                 };
1812
1813                                 webClient.UploadDataAsync (uri, "PUT", new byte[] { });
1814                         });
1815                 }
1816
1817                 [Test]
1818                 [Category ("AndroidNotWorking")] // Fails when ran as part of the entire BCL test suite. Works when only this fixture is ran
1819                 public void UploadValuesAsyncCancelEvent ()
1820                 {
1821                         UploadAsyncCancelEventTest (9303, (webClient, uri, cancelEvent) =>
1822                         {
1823                                 webClient.UploadValuesCompleted += (sender, args) =>
1824                                 {
1825                                         if (args.Cancelled)
1826                                                 cancelEvent.Set ();
1827                                 };
1828
1829                                 webClient.UploadValuesAsync (uri, "PUT", new NameValueCollection ());
1830                         });
1831                 }
1832
1833                 [Test]
1834                 [Category ("AndroidNotWorking")] // Fails when ran as part of the entire BCL test suite. Works when only this fixture is ran
1835                 public void UploadFileAsyncCancelEvent ()
1836                 {
1837                         UploadAsyncCancelEventTest (9304,(webClient, uri, cancelEvent) =>
1838                         {
1839                                 string tempFile = Path.Combine (_tempFolder, "upload.tmp");
1840                                 File.Create (tempFile).Close ();
1841
1842                                 webClient.UploadFileCompleted += (sender, args) =>
1843                                 {
1844                                         if (args.Cancelled)
1845                                                 cancelEvent.Set ();
1846                                 };
1847
1848                                 webClient.UploadFileAsync (uri, "PUT", tempFile);
1849                         });
1850                 }
1851
1852                 [Test]
1853                 [Category ("AndroidNotWorking")] // Test suite hangs if the tests runs as part of the entire BCL suite. Works when only this fixture is ran
1854                 public void UploadFileAsyncContentType ()
1855                 {
1856                         var port = NetworkHelpers.FindFreePort ();
1857                         var serverUri = "http://localhost:" + port + "/";
1858                         var filename = Path.GetTempFileName ();
1859
1860                         HttpListener listener = new HttpListener ();
1861                         listener.Prefixes.Add (serverUri);
1862                         listener.Start ();
1863
1864                         using (var client = new WebClient ())
1865                         {
1866                                 client.UploadFileTaskAsync (new Uri (serverUri), filename);
1867                                 var request = listener.GetContext ().Request;
1868
1869                                 var expected = "multipart/form-data; boundary=---------------------";
1870                                 Assert.AreEqual (expected.Length + 15, request.ContentType.Length);
1871                                 Assert.AreEqual (expected, request.ContentType.Substring (0, expected.Length));
1872                         }
1873                         listener.Close ();
1874                 }
1875
1876                 public void UploadAsyncCancelEventTest (int port, Action<WebClient, Uri, EventWaitHandle> uploadAction)
1877                 {
1878                         var ep = NetworkHelpers.LocalEphemeralEndPoint ();
1879                         string url = "http://" + ep.ToString() + "/test/";
1880
1881                         using (var responder = new SocketResponder (ep, s => EchoRequestHandler (s)))
1882                         {
1883                                 var webClient = new WebClient ();
1884
1885                                 var cancellationTokenSource = new CancellationTokenSource ();
1886                                 cancellationTokenSource.Token.Register (webClient.CancelAsync);
1887
1888                                 var cancelEvent = new ManualResetEvent (false);
1889
1890                                 uploadAction.Invoke (webClient, new Uri (url), cancelEvent);
1891
1892                                 cancellationTokenSource.Cancel ();
1893
1894                                 Assert.IsTrue (cancelEvent.WaitOne (1000));
1895                         }
1896                 }
1897         }
1898 }