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

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