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