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