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

   1 //
   2 // FileWebRequestTest.cs - NUnit Test Cases for System.Net.FileWebRequest
   3 //
   4 // Authors:
   5 //   Lawrence Pit (loz@cable.a2000.nl)
   6 //   Martin Willemoes Hansen (mwh@sysrq.dk)
   7 //   Gert Driesen (drieseng@users.sourceforge.net)
   8 //
   9 // (C) 2003 Martin Willemoes Hansen
  10 //
  11
  12 using System;
  13 using System.Collections;
  14 using System.IO;
  15 using System.Net;
  16 using System.Runtime.Serialization;
  17 using System.Runtime.Serialization.Formatters;
  18 using System.Runtime.Serialization.Formatters.Binary;
  19 using System.Security;
  20 using System.Security.Permissions;
  21
  22 using NUnit.Framework;
  23
  24
  25 namespace MonoTests.System.Net
  26 {
  27         [TestFixture]
  28         public class FileWebRequestTest
  29         {
  30                 private string _tempDirectory;
  31                 private string _tempFile;
  32                 private Uri _tempFileUri;
  33
  34                 [SetUp]
  35                 public void SetUp ()
  36                 {
  37                         _tempDirectory = Path.Combine (Path.GetTempPath (), "MonoTests.System.Net.FileWebRequestTest");
  38                         _tempFile = Path.Combine (_tempDirectory, "FileWebRequestTest.tmp");
  39                         if (!Directory.Exists (_tempDirectory)) {
  40                                 Directory.CreateDirectory (_tempDirectory);
  41                         } else {
  42                                 // ensure no files are left over from previous runs
  43                                 string [] files = Directory.GetFiles (_tempDirectory, "*");
  44                                 foreach (string file in files)
  45                                         File.Delete (file);
  46                         }
  47                         _tempFileUri = GetTempFileUri ();
  48                 }
  49
  50                 [TearDown]
  51                 public void TearDown ()
  52                 {
  53                         if (Directory.Exists (_tempDirectory))
  54                                 Directory.Delete (_tempDirectory, true);
  55                 }
  56
  57                 [Test]
  58                 public void Async ()
  59                 {
  60                         WebResponse res = null;
  61
  62                         try {
  63                                 FileWebRequest req = (FileWebRequest) WebRequest.Create (_tempFileUri);
  64                                 req.Method = "PUT";
  65                                 req.ContentLength = 1;
  66                                 req.ContentType = "image/png";
  67
  68                                 req.Timeout = 2 * 1000;
  69                                 IAsyncResult async = req.BeginGetRequestStream (null, null);
  70                                 try {
  71                                         req.BeginGetRequestStream (null, null);
  72                                         Assert.Fail ("#1 should've failed");
  73                                 } catch (InvalidOperationException) {
  74                                         // Cannot re-call BeginGetRequestStream/BeginGetResponse while
  75                                         // a previous call is still in progress
  76                                 }
  77
  78                                 try {
  79                                         req.GetRequestStream ();
  80                                         Assert.Fail ("#3 should've failed");
  81                                 } catch (InvalidOperationException) {
  82                                         // Cannot re-call BeginGetRequestStream/BeginGetResponse while
  83                                         // a previous call is still in progress
  84                                 }
  85
  86                                 using (Stream wstream = req.EndGetRequestStream (async)) {
  87                                         Assert.IsFalse (wstream.CanRead, "#1r");
  88                                         Assert.IsTrue (wstream.CanWrite, "#1w");
  89                                         Assert.IsTrue (wstream.CanSeek, "#1s");
  90
  91                                         wstream.WriteByte (72);
  92                                         wstream.WriteByte (101);
  93                                         wstream.WriteByte (108);
  94                                         wstream.WriteByte (108);
  95                                         wstream.WriteByte (111);
  96                                         wstream.Close ();
  97                                 }
  98
  99                                 Assert.AreEqual (1, req.ContentLength, "#1cl");
 100                                 Assert.AreEqual ("image/png", req.ContentType, "#1ct");
 101
 102                                 // stream written
 103
 104                                 req = (FileWebRequest) WebRequest.Create (_tempFileUri);
 105                                 res = req.GetResponse ();
 106
 107                                 try {
 108                                         req.BeginGetRequestStream (null, null);
 109                                         Assert.Fail ("#20: should've failed");
 110                                 } catch (InvalidOperationException) {
 111                                         // Cannot send a content-body with this verb-type
 112                                 }
 113
 114                                 try {
 115                                         req.Method = "PUT";
 116                                         req.BeginGetRequestStream (null, null);
 117                                         Assert.Fail ("#21: should've failed");
 118                                 } catch (InvalidOperationException) {
 119                                         // This operation cannot be perfomed after the request has been submitted.
 120                                 }
 121
 122                                 req.GetResponse ();
 123
 124                                 IAsyncResult async2 = req.BeginGetResponse (null, null);
 125
 126                                 // this succeeds !!
 127                                 WebResponse res2 = req.EndGetResponse (async2);
 128                                 Assert.AreSame (res, res2, "#23");
 129
 130                                 Assert.AreEqual (5, res.ContentLength, "#2 len");
 131                                 Assert.AreEqual ("application/octet-stream", res.ContentType, "#2 type");
 132                                 Assert.AreEqual ("file", res.ResponseUri.Scheme, "#2 scheme");
 133
 134                                 Stream rstream = res.GetResponseStream ();
 135                                 Assert.IsTrue (rstream.CanRead, "#3r");
 136                                 Assert.IsFalse (rstream.CanWrite, "#3w");
 137                                 Assert.IsTrue (rstream.CanSeek, "#3s");
 138
 139                                 Assert.AreEqual (72, rstream.ReadByte (), "#4a");
 140                                 Assert.AreEqual (101, rstream.ReadByte (), "#4b");
 141                                 Assert.AreEqual (108, rstream.ReadByte (), "#4c");
 142                                 Assert.AreEqual (108, rstream.ReadByte (), "#4d");
 143                                 Assert.AreEqual (111, rstream.ReadByte (), "#4e");
 144
 145                                 rstream.Close ();
 146
 147                                 try {
 148                                         long len = res.ContentLength;
 149                                         Assert.AreEqual ((long) 5, len, "#5");
 150                                 } catch (ObjectDisposedException) {
 151                                         Assert.Fail ("#disposed contentlength");
 152                                 }
 153                                 try {
 154                                         WebHeaderCollection w = res.Headers;
 155                                 } catch (ObjectDisposedException) {
 156                                         Assert.Fail ("#disposed headers");
 157                                 }
 158                                 try {
 159                                         res.Close ();
 160                                 } catch (ObjectDisposedException) {
 161                                         Assert.Fail ("#disposed close");
 162                                 }
 163                         } finally {
 164                                 if (res != null)
 165                                         res.Close ();
 166                         }
 167                 }
 168
 169                 [Test]
 170                 [Category ("NotWorking")] // bug #323388
 171                 public void Async_GetResponse_Failure ()
 172                 {
 173                         FileWebRequest req = (FileWebRequest) WebRequest.Create (_tempFileUri);
 174                         req.Method = "PUT";
 175                         req.ContentLength = 1;
 176                         req.ContentType = "image/png";
 177                         req.Timeout = 500;
 178
 179                         IAsyncResult async = req.BeginGetRequestStream (null, null);
 180                         try {
 181                                 req.GetResponse ();
 182                                 Assert.Fail ("#1");
 183                         } catch (WebException) {
 184                                 // The operation has timed out
 185                         }
 186
 187                         try {
 188                                 req.BeginGetResponse (null, null);
 189                                 Assert.Fail ("#2");
 190                         } catch (InvalidOperationException) {
 191                                 // Cannot re-call BeginGetRequestStream/BeginGetResponse while
 192                                 // a previous call is still in progress
 193                         }
 194
 195                         using (Stream wstream = req.EndGetRequestStream (async)) {
 196                                 wstream.WriteByte (72);
 197                         }
 198
 199                         // the temp file should not be in use
 200                         Directory.Delete (_tempDirectory, true);
 201                 }
 202
 203                 [Test]
 204                 public void Sync ()
 205                 {
 206                         WebResponse res = null;
 207
 208                         try {
 209                                 FileWebRequest req = (FileWebRequest) WebRequest.Create (_tempFileUri);
 210                                 req.ContentLength = 1;
 211                                 req.ContentType = "image/png";
 212
 213                                 try {
 214                                         Stream stream = req.GetRequestStream ();
 215                                         Assert.Fail ("should throw exception");
 216                                 } catch (ProtocolViolationException) {
 217                                 }
 218
 219                                 req.Method = "PUT";
 220
 221                                 Stream wstream = req.GetRequestStream ();
 222                                 Assert.IsFalse (wstream.CanRead, "#1r");
 223                                 Assert.IsTrue (wstream.CanWrite, "#1w");
 224                                 Assert.IsTrue (wstream.CanSeek, "#1s");
 225
 226                                 wstream.WriteByte (72);
 227                                 wstream.WriteByte (101);
 228                                 wstream.WriteByte (108);
 229                                 wstream.WriteByte (108);
 230                                 wstream.WriteByte (111);
 231                                 wstream.Close ();
 232
 233                                 Assert.AreEqual (1, req.ContentLength, "#1cl");
 234                                 Assert.AreEqual ("image/png", req.ContentType, "#1ct");
 235
 236                                 // stream written
 237
 238                                 req = (FileWebRequest) WebRequest.Create (_tempFileUri);
 239                                 res = req.GetResponse ();
 240                                 Assert.AreEqual ((long) 5, res.ContentLength, "#2 len");
 241                                 Assert.AreEqual ("application/octet-stream", res.ContentType, "#2 type");
 242                                 Assert.AreEqual ("file", res.ResponseUri.Scheme, "#2 scheme");
 243
 244                                 Stream rstream = res.GetResponseStream ();
 245                                 Assert.IsTrue (rstream.CanRead, "#3r");
 246                                 Assert.IsFalse (rstream.CanWrite, "#3w");
 247                                 Assert.IsTrue (rstream.CanSeek, "#3s");
 248
 249                                 Assert.AreEqual (72, rstream.ReadByte (), "#4a");
 250                                 Assert.AreEqual (101, rstream.ReadByte (), "#4b");
 251                                 Assert.AreEqual (108, rstream.ReadByte (), "#4c");
 252                                 Assert.AreEqual (108, rstream.ReadByte (), "#4d");
 253                                 Assert.AreEqual (111, rstream.ReadByte (), "#4e");
 254
 255                                 rstream.Close ();
 256
 257                                 try {
 258                                         long len = res.ContentLength;
 259                                         Assert.AreEqual ((long) 5, len, "#5");
 260                                 } catch (ObjectDisposedException) {
 261                                         Assert.Fail ("#disposed contentlength");
 262                                 }
 263                                 try {
 264                                         WebHeaderCollection w = res.Headers;
 265                                 } catch (ObjectDisposedException) {
 266                                         Assert.Fail ("#disposed headers");
 267                                 }
 268                                 try {
 269                                         res.Close ();
 270                                 } catch (ObjectDisposedException) {
 271                                         Assert.Fail ("#disposed close");
 272                                 }
 273                         } finally {
 274                                 if (res != null)
 275                                         res.Close ();
 276                         }
 277                 }
 278
 279                 [Test]
 280                 [Category ("NotWorking")] // bug #323388
 281                 public void Sync_GetResponse_Failure ()
 282                 {
 283                         FileWebRequest req = (FileWebRequest) WebRequest.Create (_tempFileUri);
 284                         req.Method = "PUT";
 285                         req.ContentLength = 1;
 286                         req.ContentType = "image/png";
 287                         req.Timeout = 500;
 288
 289                         using (Stream rs = req.GetRequestStream ()) {
 290                                 try {
 291                                         req.GetResponse ();
 292                                         Assert.Fail ("#1");
 293                                 } catch (WebException) {
 294                                         // The operation has timed out
 295                                 }
 296
 297                                 try {
 298                                         req.BeginGetResponse (null, null);
 299                                         Assert.Fail ("#2");
 300                                 } catch (InvalidOperationException) {
 301                                         // Cannot re-call BeginGetRequestStream/BeginGetResponse while
 302                                         // a previous call is still in progress
 303                                 }
 304                         }
 305
 306                         // the temp file should not be in use
 307                         Directory.Delete (_tempDirectory, true);
 308                 }
 309
 310                 [Test]
 311                 public void ConnectionGroupName ()
 312                 {
 313                         FileWebRequest req = (FileWebRequest) WebRequest.Create (_tempFileUri);
 314                         Assert.IsNull (req.ConnectionGroupName, "#A");
 315                         req.ConnectionGroupName = "whatever";
 316                         Assert.IsNotNull (req.ConnectionGroupName, "#B1");
 317                         Assert.AreEqual ("whatever", req.ConnectionGroupName, "#B2");
 318                         req.ConnectionGroupName = string.Empty;
 319                         Assert.IsNotNull (req.ConnectionGroupName, "#C1");
 320                         Assert.AreEqual (string.Empty, req.ConnectionGroupName, "#C2");
 321                         req.ConnectionGroupName = null;
 322                         Assert.IsNull (req.ConnectionGroupName, "#D");
 323                 }
 324
 325                 [Test]
 326                 public void ContentLength ()
 327                 {
 328                         FileWebRequest req = (FileWebRequest) WebRequest.Create (_tempFileUri);
 329                         Assert.AreEqual (0, req.Headers.Count, "#A1");
 330                         Assert.AreEqual (0, req.ContentLength, "#A2");
 331                         req.ContentLength = 5;
 332                         Assert.AreEqual (5, req.ContentLength, "#A3");
 333                         Assert.AreEqual (0, req.Headers.Count, "#A4");
 334
 335                         req.Method = "PUT";
 336                         using (Stream s = req.GetRequestStream ()) {
 337                                 s.WriteByte (5);
 338                                 Assert.AreEqual (5, req.ContentLength, "#B1");
 339                                 s.WriteByte (4);
 340                                 Assert.AreEqual (5, req.ContentLength, "#B2");
 341                                 s.Flush ();
 342                                 Assert.AreEqual (5, req.ContentLength, "#B3");
 343                         }
 344                         Assert.AreEqual (5, req.ContentLength, "#B4");
 345                 }
 346
 347                 [Test]
 348                 public void ContentLength_Negative ()
 349                 {
 350                         FileWebRequest req = (FileWebRequest) WebRequest.Create (_tempFileUri);
 351                         try {
 352                                 req.ContentLength = -1;
 353                                 Assert.Fail ("#1");
 354                         } catch (ArgumentException ex) {
 355                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 356                                 Assert.IsNotNull (ex.Message, "#3");
 357                                 Assert.IsFalse (ex.Message == "value", "#4");
 358                                 Assert.IsNotNull (ex.ParamName, "#5");
 359                                 Assert.AreEqual ("value", ex.ParamName, "#6");
 360                                 Assert.IsNull (ex.InnerException, "#7");
 361                         }
 362                 }
 363
 364                 [Test]
 365                 public void ContentType ()
 366                 {
 367                         FileWebRequest req = (FileWebRequest) WebRequest.Create (_tempFileUri);
 368                         Assert.AreEqual (0, req.Headers.Count, "#A1");
 369                         Assert.IsNull (req.ContentType, "#A2");
 370
 371                         req.ContentType = "application/x-gzip";
 372                         Assert.AreEqual (1, req.Headers.Count, "#B1");
 373                         Assert.AreEqual ("Content-Type", req.Headers.GetKey (0), "#B2");
 374                         Assert.AreEqual ("application/x-gzip", req.Headers.Get (0), "#B3");
 375                         Assert.AreEqual ("application/x-gzip", req.ContentType, "#B4");
 376
 377                         req.Headers.Set ("Content-Type", "image/png");
 378                         Assert.AreEqual ("image/png", req.ContentType, "#C1");
 379
 380                         req.ContentType = null;
 381                         Assert.AreEqual (1, req.Headers.Count, "#D1");
 382                         Assert.AreEqual ("Content-Type", req.Headers.GetKey (0), "#D2");
 383                         Assert.AreEqual (string.Empty, req.Headers.Get (0), "#D3");
 384                         Assert.AreEqual (string.Empty, req.ContentType, "#D4");
 385
 386                         req.Headers.Remove ("Content-Type");
 387                         Assert.AreEqual (0, req.Headers.Count, "#E1");
 388                         Assert.IsNull (req.ContentType, "#E2");
 389                 }
 390
 391                 [Test]
 392                 public void Credentials ()
 393                 {
 394                         FileWebRequest req = (FileWebRequest) WebRequest.Create (_tempFileUri);
 395                         Assert.IsNull (req.Credentials, "#1");
 396                         req.Credentials = new NetworkCredential ();
 397                         Assert.IsNotNull (req.Credentials, "#2");
 398                         req.Credentials = null;
 399                         Assert.IsNull (req.Credentials, "#3");
 400                 }
 401
 402                 [Test]
 403                 [Category ("NotWorking")]
 404                 public void GetRequestStream ()
 405                 {
 406                         FileWebRequest req = (FileWebRequest) WebRequest.Create (
 407                                 _tempFileUri);
 408                         req.Timeout = 1000;
 409                         req.Method = "POST";
 410                         FileStream fsA = null;
 411                         FileStream fsB = null;
 412                         try {
 413                                 fsA = req.GetRequestStream () as FileStream;
 414                                 Assert.IsNotNull (fsA, "#A1");
 415                                 try {
 416                                         req.GetRequestStream ();
 417                                         Assert.Fail ("#A2");
 418                                 } catch (WebException) {
 419                                         // The operation has timed out
 420                                 }
 421                                 fsA.Close ();
 422                                 try {
 423                                         req.GetRequestStream ();
 424                                         Assert.Fail ("#A3");
 425                                 } catch (InvalidOperationException) {
 426                                         // Cannot re-call BeginGetRequestStream/BeginGetResponse
 427                                         // while a previous call is still in progress.
 428                                 }
 429                         } finally {
 430                                 if (fsA != null)
 431                                         fsA.Close ();
 432                                 if (fsB != null)
 433                                         fsB.Close ();
 434                         }
 435
 436                         req = (FileWebRequest) WebRequest.Create (_tempFileUri);
 437                         req.Timeout = 1000;
 438                         req.Method = "POST";
 439                         try {
 440                                 fsA = req.GetRequestStream () as FileStream;
 441                                 Assert.IsNotNull (fsA, "#B1");
 442                                 fsA.Close ();
 443                                 try {
 444                                         req.GetRequestStream ();
 445                                         Assert.Fail ("#B2");
 446                                 } catch (WebException) {
 447                                         // The operation has timed out
 448                                 }
 449                                 fsA.Close ();
 450                                 try {
 451                                         req.GetRequestStream ();
 452                                         Assert.Fail ("#B3");
 453                                 } catch (InvalidOperationException) {
 454                                         // Cannot re-call BeginGetRequestStream/BeginGetResponse
 455                                         // while a previous call is still in progress.
 456                                 }
 457                         } finally {
 458                                 if (fsA != null)
 459                                         fsA.Close ();
 460                                 if (fsB != null)
 461                                         fsB.Close ();
 462                         }
 463                 }
 464
 465                 [Test]
 466                 public void GetRequestStream_File_Exists ()
 467                 {
 468                         Stream s = File.Create (_tempFile);
 469                         s.Close ();
 470                         FileWebRequest req = (FileWebRequest) WebRequest.Create (
 471                                 _tempFileUri);
 472                         req.Method = "POST";
 473                         s = req.GetRequestStream ();
 474                         s.Close ();
 475                 }
 476
 477                 [Test]
 478                 public void GetRequestStream_Method_Valid ()
 479                 {
 480                         string [] methods = new string [] { "PUT", "POST", "CHECKOUT",
 481                                 "DELETE", "OPTIONS", "TRACE", "GET ", "DUNNO" };
 482
 483                         foreach (string method in methods) {
 484                                 FileWebRequest req = (FileWebRequest) WebRequest.Create (
 485                                         _tempFileUri);
 486                                 req.Method = method;
 487                                 using (Stream s = req.GetRequestStream ()) {
 488                                         Assert.IsNotNull (s, "#1:" + method);
 489                                         Assert.IsFalse (s.CanRead, "#2:" + method);
 490                                         Assert.IsTrue (s.CanSeek, "#3:" + method);
 491                                         Assert.IsFalse (s.CanTimeout, "#4:" + method);
 492                                         Assert.IsTrue (s.CanWrite, "#5:" + method);
 493                                         Assert.AreEqual (0, s.Length, "#6:" + method);
 494                                         Assert.AreEqual (0, s.Position, "#7:" + method);
 495                                         try {
 496                                                 int i = s.ReadTimeout;
 497                                                 Assert.Fail ("#8:" + method + "=>" + i);
 498                                         } catch (InvalidOperationException) {
 499                                         }
 500                                         try {
 501                                                 int i = s.WriteTimeout;
 502                                                 Assert.Fail ("#9:" + method + "=>" + i);
 503                                         } catch (InvalidOperationException) {
 504                                         }
 505                                 }
 506                         }
 507                 }
 508
 509                 [Test]
 510                 public void GetRequestStream_Method_Invalid ()
 511                 {
 512                         string [] methods = new string [] { "GET", "get", "HEAD", "head",
 513                                 "CONNECT", "connect"};
 514                         foreach (string method in methods) {
 515                                 FileWebRequest req = (FileWebRequest) WebRequest.Create (
 516                                         _tempFileUri);
 517                                 req.Method = method;
 518                                 try {
 519                                         req.GetRequestStream ();
 520                                         Assert.Fail ("#1:" + method);
 521                                 } catch (ProtocolViolationException ex) {
 522                                         Assert.AreEqual (typeof (ProtocolViolationException), ex.GetType (), "#2:" + method);
 523                                         Assert.IsNotNull (ex.Message, "#3:" + method);
 524                                         Assert.IsNull (ex.InnerException, "#4:" + method);
 525                                 }
 526                         }
 527                 }
 528
 529                 [Test]
 530                 public void GetResponse_File_Exists ()
 531                 {
 532                         Stream s = File.Create (_tempFile);
 533                         s.Close ();
 534                         FileWebRequest req = (FileWebRequest) WebRequest.Create (_tempFileUri);
 535                         FileWebResponse respA = null;
 536                         FileWebResponse respB = null;
 537                         try {
 538                                 respA = req.GetResponse () as FileWebResponse;
 539                                 Assert.IsNotNull (respA, "#1");
 540                                 respB = req.GetResponse () as FileWebResponse;
 541                                 Assert.IsNotNull (respB, "#2");
 542                                 Assert.AreSame (respA, respB, "#3");
 543                         } finally {
 544                                 if (respA != null)
 545                                         respA.Close ();
 546                                 if (respB != null)
 547                                         respB.Close ();
 548                         }
 549                 }
 550
 551                 [Test]
 552                 public void GetResponse_File_DoesNotExist ()
 553                 {
 554                         FileWebRequest req = (FileWebRequest) WebRequest.Create (_tempFileUri);
 555                         try {
 556                                 req.GetResponse ();
 557                                 Assert.Fail ("#1");
 558                         } catch (WebException ex) {
 559                                 Assert.AreEqual (typeof (WebException), ex.GetType (), "#1");
 560                                 Assert.IsNotNull (ex.Message, "#2");
 561                                 Assert.IsTrue (ex.Message.IndexOf ("FileWebRequestTest.tmp") != -1, "#3");
 562                                 Assert.IsNull (ex.Response, "#4");
 563                                 Assert.IsNotNull (ex.InnerException, "#5");
 564
 565                         }
 566                 }
 567
 568                 [Test]
 569                 public void Method ()
 570                 {
 571                         FileWebRequest req = (FileWebRequest) WebRequest.Create (_tempFileUri);
 572                         Assert.IsNotNull (req.Method, "#A1");
 573                         Assert.AreEqual ("GET", req.Method, "#A2");
 574                         req.Method = "whatever";
 575                         Assert.IsNotNull (req.Method, "#B1");
 576                         Assert.AreEqual ("whatever", req.Method, "#B2");
 577                         req.Method = "get ";
 578                         Assert.IsNotNull (req.Method, "#C1");
 579                         Assert.AreEqual ("get ", req.Method, "#C2");
 580                 }
 581
 582                 [Test]
 583                 public void Method_Empty ()
 584                 {
 585                         FileWebRequest req = (FileWebRequest) WebRequest.Create (_tempFileUri);
 586                         try {
 587                                 req.Method = string.Empty;
 588                                 Assert.Fail ("#1");
 589                         } catch (ArgumentException ex) {
 590                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 591                                 Assert.IsNotNull (ex.Message, "#3");
 592                                 Assert.AreEqual ("value", ex.ParamName, "#4");
 593                                 Assert.IsNull (ex.InnerException, "#5");
 594                         }
 595                 }
 596
 597                 [Test]
 598                 public void Method_Null ()
 599                 {
 600                         FileWebRequest req = (FileWebRequest) WebRequest.Create (_tempFileUri);
 601                         try {
 602                                 req.Method = null;
 603                                 Assert.Fail ("#1");
 604                         } catch (ArgumentException ex) {
 605                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 606                                 Assert.IsNotNull (ex.Message, "#3");
 607                                 Assert.AreEqual ("value", ex.ParamName, "#4");
 608                                 Assert.IsNull (ex.InnerException, "#5");
 609                         }
 610                 }
 611
 612                 [Test]
 613                 public void PreAuthenticate ()
 614                 {
 615                         FileWebRequest req = (FileWebRequest) WebRequest.Create (_tempFileUri);
 616                         Assert.IsFalse (req.PreAuthenticate, "#1");
 617                         req.PreAuthenticate = true;
 618                         Assert.IsTrue (req.PreAuthenticate, "#2");
 619                 }
 620
 621                 [Test]
 622                 public void Proxy ()
 623                 {
 624                         FileWebRequest req = (FileWebRequest) WebRequest.Create (_tempFileUri);
 625                         Assert.IsNull (req.Proxy, "#1");
 626                         req.Proxy = new WebProxy ();
 627                         Assert.IsNotNull (req.Proxy, "#2");
 628                         req.Proxy = null;
 629                         Assert.IsNull (req.Proxy, "#3");
 630                 }
 631
 632                 [Test]
 633                 public void RequestUri ()
 634                 {
 635                         FileWebRequest req = (FileWebRequest) WebRequest.Create (_tempFileUri);
 636                         Assert.AreSame (_tempFileUri, req.RequestUri);
 637                 }
 638
 639                 [Test]
 640                 public void Timeout ()
 641                 {
 642                         FileWebRequest req = (FileWebRequest) WebRequest.Create (_tempFileUri);
 643                         Assert.AreEqual (100000, req.Timeout, "#1");
 644                         req.Timeout = int.MaxValue;
 645                         Assert.AreEqual (int.MaxValue, req.Timeout, "#2");
 646                         req.Timeout = 0;
 647                         Assert.AreEqual (0, req.Timeout, "#3");
 648                 }
 649
 650                 [Test]
 651                 public void Timeout_Negative ()
 652                 {
 653                         FileWebRequest req = (FileWebRequest) WebRequest.Create (_tempFileUri);
 654                         req.Timeout = -1;
 655                         Assert.AreEqual (-1, req.Timeout, "#1");
 656                         try {
 657                                 req.Timeout = -2;
 658                                 Assert.Fail ("#2");
 659                         } catch (ArgumentOutOfRangeException ex) {
 660                                 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#3");
 661                                 Assert.IsNotNull (ex.Message, "#4");
 662                                 Assert.IsNotNull (ex.ParamName, "#5");
 663                                 Assert.IsFalse (ex.ParamName == "value", "#6");
 664                                 Assert.IsNull (ex.InnerException, "#7");
 665                         }
 666                 }
 667
 668                 [Test]
 669                 public void GetObjectData ()
 670                 {
 671                         FileWebRequest fwr = (FileWebRequest) WebRequest.Create ("file:///test.txt");
 672                         fwr.ConnectionGroupName = "CGN";
 673                         fwr.ContentLength = 10;
 674                         fwr.ContentType = "image/png";
 675                         fwr.Credentials = new NetworkCredential ("Miguel", "de Icaza", "Novell");
 676                         fwr.Headers.Add ("Disposition", "attach");
 677                         fwr.Method = "PUT";
 678                         fwr.PreAuthenticate = true;
 679                         fwr.Proxy = new WebProxy ("proxy.ximian.com");
 680                         fwr.Timeout = 20;
 681
 682                         SerializationInfo si = new SerializationInfo (typeof (FileWebRequest),
 683                                 new FormatterConverter ());
 684                         ((ISerializable) fwr).GetObjectData (si, new StreamingContext ());
 685                         Assert.AreEqual (9, si.MemberCount, "#A1");
 686                         int i = 0;
 687                         foreach (SerializationEntry entry in si) {
 688                                 Assert.IsNotNull (entry.Name, "#B1:" + i);
 689                                 Assert.IsNotNull (entry.ObjectType, "#B2:" + i);
 690                                 Assert.IsNotNull (entry.Value, "#B3:" + i);
 691
 692                                 switch (i) {
 693                                 case 0:
 694                                         Assert.AreEqual ("headers", entry.Name, "#B4:" + i);
 695                                         Assert.AreEqual (typeof (WebHeaderCollection), entry.ObjectType, "#B5:" + i);
 696                                         break;
 697                                 case 1:
 698                                         Assert.AreEqual ("proxy", entry.Name, "#B4:" + i);
 699                                         Assert.AreEqual (typeof (IWebProxy), entry.ObjectType, "#B5:" + i);
 700                                         break;
 701                                 case 2:
 702                                         Assert.AreEqual ("uri", entry.Name, "#B4:" + i);
 703                                         Assert.AreEqual (typeof (Uri), entry.ObjectType, "#B5:" + i);
 704                                         break;
 705                                 case 3:
 706                                         Assert.AreEqual ("connectionGroupName", entry.Name, "#B4:" + i);
 707                                         Assert.AreEqual (typeof (string), entry.ObjectType, "#B5:" + i);
 708                                         Assert.AreEqual ("CGN", entry.Value, "#B6:" + i);
 709                                         break;
 710                                 case 4:
 711                                         Assert.AreEqual ("method", entry.Name, "#B4:" + i);
 712                                         Assert.AreEqual (typeof (string), entry.ObjectType, "#B5:" + i);
 713                                         Assert.AreEqual ("PUT", entry.Value, "#B6:" + i);
 714                                         break;
 715                                 case 5:
 716                                         Assert.AreEqual ("contentLength", entry.Name, "#B4:" + i);
 717                                         Assert.AreEqual (typeof (long), entry.ObjectType, "#B5:" + i);
 718                                         Assert.AreEqual (10, entry.Value, "#B6:" + i);
 719                                         break;
 720                                 case 6:
 721                                         Assert.AreEqual ("timeout", entry.Name, "#B4:" + i);
 722                                         Assert.AreEqual (typeof (int), entry.ObjectType, "#B5:" + i);
 723                                         Assert.AreEqual (20, entry.Value, "#B6:" + i);
 724                                         break;
 725                                 case 7:
 726                                         Assert.AreEqual ("fileAccess", entry.Name, "#B4:" + i);
 727                                         Assert.AreEqual (typeof (FileAccess), entry.ObjectType, "#B5:" + i);
 728                                         Assert.AreEqual (FileAccess.Read, entry.Value, "#B6:" + i);
 729                                         break;
 730                                 case 8:
 731                                         Assert.AreEqual ("preauthenticate", entry.Name, "#B4:" + i);
 732                                         Assert.AreEqual (typeof (bool), entry.ObjectType, "#B5:" + i);
 733                                         Assert.AreEqual (false, entry.Value, "#B6:" + i);
 734                                         break;
 735                                 }
 736                                 i++;
 737                         }
 738                 }
 739
 740                 [Test]
 741                 [Category ("NotWorking")] // Difference at index 272: 20 instead of 19
 742                 public void Serialize ()
 743                 {
 744                         FileWebRequest fwr = (FileWebRequest) WebRequest.Create ("file://test.txt/");
 745                         fwr.ConnectionGroupName = "CGN";
 746                         fwr.ContentLength = 10;
 747                         fwr.ContentType = "image/png";
 748                         fwr.Credentials = new NetworkCredential ("Miguel", "de Icaza", "Novell");
 749                         fwr.Headers.Add ("Disposition", "attach");
 750                         fwr.Method = "PUT";
 751                         fwr.PreAuthenticate = true;
 752                         fwr.Proxy = new WebProxy ("proxy.ximian.com");
 753                         fwr.Timeout = 20;
 754
 755                         BinaryFormatter bf = new BinaryFormatter ();
 756                         bf.AssemblyFormat = FormatterAssemblyStyle.Full;
 757
 758                         MemoryStream ms = new MemoryStream ();
 759                         bf.Serialize (ms, fwr);
 760                         ms.Position = 0;
 761
 762                         byte [] buffer = new byte [ms.Length];
 763                         ms.Read (buffer, 0, buffer.Length);
 764                         Assert.AreEqual (_serialized, buffer);
 765                 }
 766
 767                 [Test]
 768                 public void Deserialize ()
 769                 {
 770                         MemoryStream ms = new MemoryStream ();
 771                         ms.Write (_serialized, 0, _serialized.Length);
 772                         ms.Position = 0;
 773
 774                         BinaryFormatter bf = new BinaryFormatter ();
 775                         FileWebRequest req = (FileWebRequest) bf.Deserialize (ms);
 776                         Assert.AreEqual ("CGN", req.ConnectionGroupName, "#A1");
 777                         Assert.AreEqual (10, req.ContentLength, "#A2");
 778                         Assert.AreEqual ("image/png", req.ContentType, "#A3");
 779                         Assert.IsNull (req.Credentials, "#A4");
 780                         Assert.AreEqual ("PUT", req.Method, "#A5");
 781                         Assert.IsFalse (req.PreAuthenticate, "#A6");
 782                         Assert.AreEqual ("file://test.txt/", req.RequestUri.AbsoluteUri, "#A7");
 783                         Assert.AreEqual (20, req.Timeout, "#A8");
 784
 785                         WebHeaderCollection headers = req.Headers;
 786                         Assert.IsNotNull (headers, "#C1");
 787                         Assert.AreEqual (2, headers.Count, "#C2");
 788                         Assert.AreEqual ("Content-Type", req.Headers.GetKey (0), "#C3");
 789                         Assert.AreEqual ("image/png", req.Headers.Get (0), "#C4");
 790                         Assert.AreEqual ("Disposition", req.Headers.GetKey (1), "#C5");
 791                         Assert.AreEqual ("attach", req.Headers.Get (1), "#C6");
 792
 793                         WebProxy proxy = req.Proxy as WebProxy;
 794                         Assert.IsNotNull (proxy, "#D1");
 795                         Assert.AreEqual ("http://proxy.ximian.com/", proxy.Address.AbsoluteUri, "#D2");
 796                         Assert.IsNotNull (proxy.BypassArrayList, "#D3");
 797                         Assert.AreEqual (0, proxy.BypassArrayList.Count, "#D4");
 798                         Assert.IsNotNull (proxy.BypassList, "#D5");
 799                         Assert.AreEqual (0, proxy.BypassList.Length, "#D6");
 800                         Assert.IsFalse (proxy.BypassProxyOnLocal, "#D7");
 801                         Assert.IsNull (proxy.Credentials, "#D8");
 802                 }
 803
 804                 private Uri GetTempFileUri ()
 805                 {
 806                         string tempFile = _tempFile;
 807                         if (RunningOnUnix) {
 808                                 // remove leading slash for absolute paths
 809                                 tempFile = tempFile.TrimStart ('/');
 810                         } else {
 811                                 tempFile = tempFile.Replace ('\\', '/');
 812                         }
 813                         return new Uri ("file:///" + tempFile);
 814                 }
 815
 816                 private bool RunningOnUnix {
 817                         get {
 818                                 // check for Unix platforms - see FAQ for more details
 819                                 // http://www.mono-project.com/FAQ:_Technical#How_to_detect_the_execution_platform_.3F
 820                                 int platform = (int) Environment.OSVersion.Platform;
 821                                 return ((platform == 4) || (platform == 128) || (platform == 6));
 822                         }
 823                 }
 824
 825                 private static readonly byte [] _serialized = new byte [] {
 826                         0x00, 0x01, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00,
 827                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x02, 0x00, 0x00, 0x00,
 828                         0x49, 0x53, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x2c, 0x20, 0x56, 0x65,
 829                         0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x32, 0x2e, 0x30, 0x2e, 0x30,
 830                         0x2e, 0x30, 0x2c, 0x20, 0x43, 0x75, 0x6c, 0x74, 0x75, 0x72, 0x65,
 831                         0x3d, 0x6e, 0x65, 0x75, 0x74, 0x72, 0x61, 0x6c, 0x2c, 0x20, 0x50,
 832                         0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79, 0x54, 0x6f, 0x6b,
 833                         0x65, 0x6e, 0x3d, 0x62, 0x37, 0x37, 0x61, 0x35, 0x63, 0x35, 0x36,
 834                         0x31, 0x39, 0x33, 0x34, 0x65, 0x30, 0x38, 0x39, 0x05, 0x01, 0x00,
 835                         0x00, 0x00, 0x19, 0x53, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x2e, 0x4e,
 836                         0x65, 0x74, 0x2e, 0x46, 0x69, 0x6c, 0x65, 0x57, 0x65, 0x62, 0x52,
 837                         0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x09, 0x00, 0x00, 0x00, 0x07,
 838                         0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x73, 0x05, 0x70, 0x72, 0x6f,
 839                         0x78, 0x79, 0x03, 0x75, 0x72, 0x69, 0x13, 0x63, 0x6f, 0x6e, 0x6e,
 840                         0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x47, 0x72, 0x6f, 0x75, 0x70,
 841                         0x4e, 0x61, 0x6d, 0x65, 0x06, 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64,
 842                         0x0d, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x4c, 0x65, 0x6e,
 843                         0x67, 0x74, 0x68, 0x07, 0x74, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74,
 844                         0x0a, 0x66, 0x69, 0x6c, 0x65, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73,
 845                         0x0f, 0x70, 0x72, 0x65, 0x61, 0x75, 0x74, 0x68, 0x65, 0x6e, 0x74,
 846                         0x69, 0x63, 0x61, 0x74, 0x65, 0x04, 0x04, 0x04, 0x01, 0x01, 0x00,
 847                         0x00, 0x03, 0x00, 0x1e, 0x53, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x2e,
 848                         0x4e, 0x65, 0x74, 0x2e, 0x57, 0x65, 0x62, 0x48, 0x65, 0x61, 0x64,
 849                         0x65, 0x72, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f,
 850                         0x6e, 0x02, 0x00, 0x00, 0x00, 0x13, 0x53, 0x79, 0x73, 0x74, 0x65,
 851                         0x6d, 0x2e, 0x4e, 0x65, 0x74, 0x2e, 0x57, 0x65, 0x62, 0x50, 0x72,
 852                         0x6f, 0x78, 0x79, 0x02, 0x00, 0x00, 0x00, 0x0a, 0x53, 0x79, 0x73,
 853                         0x74, 0x65, 0x6d, 0x2e, 0x55, 0x72, 0x69, 0x02, 0x00, 0x00, 0x00,
 854                         0x09, 0x08, 0x14, 0x53, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x2e, 0x49,
 855                         0x4f, 0x2e, 0x46, 0x69, 0x6c, 0x65, 0x41, 0x63, 0x63, 0x65, 0x73,
 856                         0x73, 0x01, 0x02, 0x00, 0x00, 0x00, 0x09, 0x03, 0x00, 0x00, 0x00,
 857                         0x09, 0x04, 0x00, 0x00, 0x00, 0x09, 0x05, 0x00, 0x00, 0x00, 0x06,
 858                         0x06, 0x00, 0x00, 0x00, 0x03, 0x43, 0x47, 0x4e, 0x06, 0x07, 0x00,
 859                         0x00, 0x00, 0x03, 0x50, 0x55, 0x54, 0x0a, 0x00, 0x00, 0x00, 0x00,
 860                         0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x04, 0xf8, 0xff, 0xff,
 861                         0xff, 0x14, 0x53, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x2e, 0x49, 0x4f,
 862                         0x2e, 0x46, 0x69, 0x6c, 0x65, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73,
 863                         0x01, 0x00, 0x00, 0x00, 0x07, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x5f,
 864                         0x5f, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0x00, 0x05, 0x03, 0x00,
 865                         0x00, 0x00, 0x1e, 0x53, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x2e, 0x4e,
 866                         0x65, 0x74, 0x2e, 0x57, 0x65, 0x62, 0x48, 0x65, 0x61, 0x64, 0x65,
 867                         0x72, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e,
 868                         0x05, 0x00, 0x00, 0x00, 0x05, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x01,
 869                         0x30, 0x01, 0x32, 0x01, 0x31, 0x01, 0x33, 0x00, 0x01, 0x01, 0x01,
 870                         0x01, 0x08, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x06,
 871                         0x09, 0x00, 0x00, 0x00, 0x0c, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e,
 872                         0x74, 0x2d, 0x54, 0x79, 0x70, 0x65, 0x06, 0x0a, 0x00, 0x00, 0x00,
 873                         0x09, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x2f, 0x70, 0x6e, 0x67, 0x06,
 874                         0x0b, 0x00, 0x00, 0x00, 0x0b, 0x44, 0x69, 0x73, 0x70, 0x6f, 0x73,
 875                         0x69, 0x74, 0x69, 0x6f, 0x6e, 0x06, 0x0c, 0x00, 0x00, 0x00, 0x06,
 876                         0x61, 0x74, 0x74, 0x61, 0x63, 0x68, 0x05, 0x04, 0x00, 0x00, 0x00,
 877                         0x13, 0x53, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x2e, 0x4e, 0x65, 0x74,
 878                         0x2e, 0x57, 0x65, 0x62, 0x50, 0x72, 0x6f, 0x78, 0x79, 0x04, 0x00,
 879                         0x00, 0x00, 0x0e, 0x5f, 0x42, 0x79, 0x70, 0x61, 0x73, 0x73, 0x4f,
 880                         0x6e, 0x4c, 0x6f, 0x63, 0x61, 0x6c, 0x0d, 0x5f, 0x50, 0x72, 0x6f,
 881                         0x78, 0x79, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x0b, 0x5f,
 882                         0x42, 0x79, 0x70, 0x61, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x16,
 883                         0x5f, 0x55, 0x73, 0x65, 0x44, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74,
 884                         0x43, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x73,
 885                         0x00, 0x04, 0x02, 0x00, 0x01, 0x0a, 0x53, 0x79, 0x73, 0x74, 0x65,
 886                         0x6d, 0x2e, 0x55, 0x72, 0x69, 0x02, 0x00, 0x00, 0x00, 0x01, 0x02,
 887                         0x00, 0x00, 0x00, 0x00, 0x09, 0x0d, 0x00, 0x00, 0x00, 0x0a, 0x00,
 888                         0x05, 0x05, 0x00, 0x00, 0x00, 0x0a, 0x53, 0x79, 0x73, 0x74, 0x65,
 889                         0x6d, 0x2e, 0x55, 0x72, 0x69, 0x01, 0x00, 0x00, 0x00, 0x0b, 0x41,
 890                         0x62, 0x73, 0x6f, 0x6c, 0x75, 0x74, 0x65, 0x55, 0x72, 0x69, 0x01,
 891                         0x02, 0x00, 0x00, 0x00, 0x06, 0x0e, 0x00, 0x00, 0x00, 0x10, 0x66,
 892                         0x69, 0x6c, 0x65, 0x3a, 0x2f, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2e,
 893                         0x74, 0x78, 0x74, 0x2f, 0x01, 0x0d, 0x00, 0x00, 0x00, 0x05, 0x00,
 894                         0x00, 0x00, 0x06, 0x0f, 0x00, 0x00, 0x00, 0x18, 0x68, 0x74, 0x74,
 895                         0x70, 0x3a, 0x2f, 0x2f, 0x70, 0x72, 0x6f, 0x78, 0x79, 0x2e, 0x78,
 896                         0x69, 0x6d, 0x69, 0x61, 0x6e, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x0b
 897                 };
 898         }
 899 }