mcs/class/corlib/Test/System.IO/FileStreamTest.cs

   1 // FileStreamTests.cs - NUnit2 Test Cases for System.IO.FileStream class
   2 //
   3 // Authors:
   4 //      Ville Palo (vi64pa@koti.soon.fi)
   5 //      Gert Driesen (gert.driesen@ardatis.com)
   6 //      Gonzalo Paniagua Javier (gonzalo@ximian.com)
   7 //
   8 // (C) Ville Palo
   9 // (c) 2003 Ximian, Inc. (http://www.ximian.com)
  10 //
  11
  12
  13 using NUnit.Framework;
  14 using System;
  15 using System.IO;
  16 using System.Text;
  17
  18 namespace MonoTests.System.IO
  19 {
  20         [TestFixture]
  21         public class FileStreamTest : Assertion
  22         {
  23                 string TempFolder = Path.Combine (Path.GetTempPath (), "MonoTests.System.IO.Tests");
  24                 static readonly char DSC = Path.DirectorySeparatorChar;
  25
  26                 [TearDown]
  27                 public void TearDown()
  28                 {
  29                         if (Directory.Exists (TempFolder))
  30                                 Directory.Delete (TempFolder, true);
  31                 }
  32
  33                 [SetUp]
  34                 public void SetUp ()
  35                 {
  36                         if (Directory.Exists (TempFolder))
  37                                 Directory.Delete (TempFolder, true);
  38
  39                         Directory.CreateDirectory (TempFolder);
  40                 }
  41
  42                 public void TestCtr ()
  43                 {
  44                         string path = TempFolder + DSC + "testfilestream.tmp.1";
  45                         DeleteFile (path);
  46                         FileStream stream = null;
  47                         try {
  48                                 stream = new FileStream (path, FileMode.Create);
  49                         } finally {
  50
  51                                 if (stream != null)
  52                                         stream.Close ();
  53                                 DeleteFile (path);
  54                         }
  55                 }
  56
  57                 [Test]
  58                 [ExpectedException (typeof (ArgumentException))]
  59                 public void CtorArgumentException1 ()
  60                 {
  61                         FileStream stream;
  62                         stream = new FileStream ("", FileMode.Create);
  63                         stream.Close ();
  64                 }
  65
  66                 [Test]
  67                 [ExpectedException (typeof (ArgumentNullException))]
  68                 public void CtorArgumentNullException ()
  69                 {
  70                         FileStream stream = new FileStream (null, FileMode.Create);
  71                         stream.Close ();
  72                 }
  73
  74                 [Test]
  75                 [ExpectedException (typeof (FileNotFoundException))]
  76                 public void CtorFileNotFoundException1 ()
  77                 {
  78                         string path = TempFolder + DSC + "thisfileshouldnotexists.test";
  79                         DeleteFile (path);
  80                         FileStream stream = null;
  81                         try {
  82                                 stream = new FileStream (TempFolder + DSC + "thisfileshouldnotexists.test", FileMode.Open);
  83                         } finally {
  84                                 if (stream != null)
  85                                         stream.Close ();
  86                                 DeleteFile (path);
  87                         }
  88                 }
  89
  90                 [Test]
  91                 [ExpectedException (typeof (FileNotFoundException))]
  92                 public void CtorFileNotFoundException2 ()
  93                 {
  94                         string path = TempFolder + DSC + "thisfileshouldNOTexists.test";
  95                         DeleteFile (path);
  96                         FileStream stream = null;
  97
  98                         try {
  99                                 stream = new FileStream (TempFolder + DSC + "thisfileshouldNOTexists.test", FileMode.Truncate);
 100                         } finally {
 101                                 if (stream != null)
 102                                         stream.Close ();
 103
 104                                 DeleteFile (path);
 105                         }
 106                 }
 107
 108                 [Test]
 109                 [ExpectedException (typeof (IOException))]
 110                 public void CtorIOException1 ()
 111                 {
 112                         string path = TempFolder + DSC + "thisfileshouldexists.test";
 113                         FileStream stream = null;
 114                         DeleteFile (path);
 115                         try {
 116                                 stream = new FileStream (path, FileMode.CreateNew);
 117                                 stream.Close ();
 118                                 stream = null;
 119                                 stream = new FileStream (path, FileMode.CreateNew);
 120                         } finally {
 121
 122                                 if (stream != null)
 123                                         stream.Close ();
 124                                 DeleteFile (path);
 125                         }
 126
 127                 }
 128
 129                 [Test]
 130                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
 131                 public void CtorArgumentOutOfRangeException1 ()
 132                 {
 133                         FileStream stream = null;
 134                         string path = TempFolder + Path.DirectorySeparatorChar + "temp";
 135                         DeleteFile (path);
 136                         try {
 137                                 stream = new FileStream (path, FileMode.Append | FileMode.CreateNew);
 138                         } finally {
 139                                 if (stream != null)
 140                                         stream.Close ();
 141                                 DeleteFile (path);
 142                         }
 143                 }
 144
 145                 [Test]
 146                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
 147                 public void CtorArgumentOutOfRangeException2 ()
 148                 {
 149                         FileStream stream = null;
 150                         string path = TempFolder + Path.DirectorySeparatorChar + "temp";
 151                         DeleteFile (path);
 152                         try {
 153                                 stream = new FileStream ("test.test.test", FileMode.Append | FileMode.Open);
 154                         } finally {
 155                                 if (stream != null)
 156                                         stream.Close ();
 157                                 DeleteFile (path);
 158                         }
 159                 }
 160
 161                 [Test]
 162                 [ExpectedException (typeof (DirectoryNotFoundException))]
 163                 public void CtorDirectoryNotFoundException ()
 164                 {
 165                         string path = TempFolder + DSC + "thisDirectoryShouldNotExists";
 166                         if (Directory.Exists (path))
 167                                 Directory.Delete (path, true);
 168
 169                         FileStream stream = null;
 170                         try {
 171                                 stream = new FileStream (path + DSC + "eitherthisfile.test", FileMode.CreateNew);
 172                         } finally {
 173
 174                                 if (stream != null)
 175                                         stream.Close ();
 176
 177                                 if (Directory.Exists (path))
 178                                         Directory.Delete (path, true);
 179                         }
 180                 }
 181
 182                 [Test]
 183                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
 184                 public void CtorArgumentOutOfRangeException3 ()
 185                 {
 186                         string path = TempFolder + DSC + "CtorArgumentOutOfRangeException1";
 187                         DeleteFile (path);
 188
 189                         FileStream stream = null;
 190                         try {
 191                                 stream = new FileStream (path, FileMode.CreateNew, FileAccess.Read, FileShare.None | FileShare.Inheritable);
 192                         } finally {
 193                                 if (stream != null)
 194                                         stream.Close ();
 195                                 DeleteFile (path);
 196                         }
 197                 }
 198
 199                 [Test]
 200                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
 201                 public void CtorArgumentOutOfRangeException4 ()
 202                 {
 203                         string path = TempFolder + DSC + "CtorArgumentOutOfRangeException4";
 204                         DeleteFile (path);
 205
 206                         FileStream stream = null;
 207                         try {
 208                                 stream = new FileStream (path, FileMode.OpenOrCreate, FileAccess.Read, FileShare.ReadWrite, -1);
 209                         } finally {
 210                                 if (stream != null)
 211                                         stream.Close ();
 212                                 DeleteFile (path);
 213                         }
 214                 }
 215
 216                 [Test]
 217                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
 218                 public void CtorBufferSizeZero ()
 219                 {
 220                         // Buffer size can't be zero
 221
 222                         string path = Path.Combine (TempFolder, "CtorBufferSizeZero");
 223                         DeleteFile (path);
 224
 225                         FileStream stream = null;
 226                         try {
 227                                 stream = new FileStream (path, FileMode.CreateNew, FileAccess.Write, FileShare.ReadWrite, 0);
 228                         } finally {
 229                                 if (stream != null)
 230                                         stream.Close ();
 231                                 DeleteFile (path);
 232                         }
 233                 }
 234
 235                 [Test]
 236                 [ExpectedException (typeof (ArgumentException))]
 237                 public void CtorArgumentException2 ()
 238                 {
 239                         // FileMode.CreateNew && FileAccess.Read
 240
 241                         string path = TempFolder + Path.DirectorySeparatorChar + "temp";
 242                         FileStream stream = null;
 243
 244                         DeleteFile (path);
 245
 246                         try {
 247                                 stream = new FileStream (".test.test.test.2", FileMode.CreateNew, FileAccess.Read, FileShare.None | FileShare.Write);
 248                         } finally {
 249
 250                                 if (stream != null)
 251                                         stream.Close ();
 252                                 DeleteFile (path);
 253                         }
 254                 }
 255
 256
 257                 [Test]
 258                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
 259                 public void CtorArgumentOutOfRangeException5 ()
 260                 {
 261                         string path = TempFolder + Path.DirectorySeparatorChar + "temp";
 262                         DeleteFile (path);
 263
 264                         FileStream stream = null;
 265                         try {
 266                                 stream = new FileStream (path, FileMode.CreateNew, FileAccess.Read, FileShare.Inheritable | FileShare.ReadWrite);
 267                         } finally {
 268                                 if (stream != null)
 269                                         stream.Close ();
 270                                 DeleteFile (path);
 271                         }
 272                 }
 273
 274
 275                 [Test]
 276                 [ExpectedException (typeof (ArgumentException))]
 277                 public void CtorArgumentException3 ()
 278                 {
 279                         string path = TempFolder + Path.DirectorySeparatorChar + "temp";
 280                         FileStream stream = null;
 281
 282                         DeleteFile (path);
 283
 284                         try {
 285                                 stream = new FileStream (".test.test.test.2", FileMode.Truncate, FileAccess.Read);
 286                         } finally {
 287                                 if (stream != null)
 288                                         stream.Close ();
 289
 290                                 DeleteFile (path);
 291                         }
 292                 }
 293
 294                 [Test, ExpectedException (typeof (IOException))]
 295                 public void CtorIOException2 ()
 296                 {
 297                         FileStream stream = null;
 298                         try {
 299                                 stream = new FileStream (new IntPtr (Int32.MaxValue), FileAccess.Read);
 300                         } finally {
 301                                 if (stream != null)
 302                                         stream.Close ();
 303                         }
 304                 }
 305
 306                 [Test, ExpectedException(typeof(IOException))]
 307                 public void CtorIOException ()
 308                 {
 309                         string path = TempFolder + DSC + "CTorIOException.Test";
 310                         FileStream stream = null;
 311                         FileStream stream2 = null;
 312                         DeleteFile (path);
 313
 314                         try {
 315                                 stream = new FileStream (path, FileMode.CreateNew);
 316
 317                                 // used by an another process
 318                                 stream2 = new FileStream (path, FileMode.OpenOrCreate);
 319                         } finally {
 320                                 if (stream != null)
 321                                         stream.Close ();
 322                                 if (stream2 != null)
 323                                         stream2.Close ();
 324                                 DeleteFile (path);
 325                         }
 326                 }
 327
 328                 [Test]
 329                 public void CtorAccess1Read2Read ()
 330                 {
 331                         FileStream fs = null;
 332                         FileStream fs2 = null;
 333                         string fn = Path.Combine (TempFolder, "temp");
 334                         try {
 335                                 if (!File.Exists (fn)) {
 336                                         TextWriter tw = File.CreateText (fn);
 337                                         tw.Write ("FOO");
 338                                         tw.Close ();
 339                                 }
 340                                 fs = new FileStream (fn, FileMode.Open, FileAccess.Read);
 341                                 fs2 = new FileStream (fn, FileMode.Open, FileAccess.Read);
 342                         } finally {
 343                                 if (fs != null)
 344                                         fs.Close ();
 345                                 if (fs2 != null)
 346                                         fs2.Close ();
 347                                 if (File.Exists (fn))
 348                                         File.Delete (fn);
 349                         }
 350                 }
 351
 352                 [Test]
 353                 [ExpectedException (typeof (IOException))]
 354                 public void CtorAccess1Read2Write ()
 355                 {
 356                         string fn = Path.Combine (TempFolder, "temp");
 357                         FileStream fs = null;
 358                         try {
 359                                 if (!File.Exists (fn)) {
 360                                         using (TextWriter tw = File.CreateText (fn)) {
 361                                                 tw.Write ("FOO");
 362                                         }
 363                                 }
 364                                 fs = new FileStream (fn, FileMode.Open, FileAccess.Read);
 365                                 fs = new FileStream (fn, FileMode.Create, FileAccess.Write);
 366                         } finally {
 367                                 if (fs != null)
 368                                         fs.Close ();
 369                                 if (File.Exists (fn))
 370                                         File.Delete (fn);
 371                         }
 372                 }
 373
 374                 [Test]
 375                 [ExpectedException (typeof (IOException))]
 376                 public void CtorAccess1Write2Write ()
 377                 {
 378                         string fn = Path.Combine (TempFolder, "temp");
 379                         FileStream fs = null;
 380                         try {
 381                                 if (File.Exists (fn))
 382                                         File.Delete (fn);
 383                                 fs = new FileStream (fn, FileMode.Create, FileAccess.Write);
 384                                 fs = new FileStream (fn, FileMode.Create, FileAccess.Write);
 385                         } finally {
 386                                 if (fs != null)
 387                                         fs.Close ();
 388                                 if (File.Exists (fn))
 389                                         File.Delete (fn);
 390                         }
 391                 }
 392
 393                 [Test]
 394                 public void Write ()
 395                 {
 396                         string path = TempFolder + DSC + "FileStreamTest.Write";
 397
 398                         DeleteFile (path);
 399
 400                         FileStream stream = new FileStream (path, FileMode.CreateNew, FileAccess.ReadWrite, FileShare.ReadWrite, 8);
 401
 402                         byte[] outbytes = new byte [] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
 403                         byte[] bytes = new byte [15];
 404
 405                         // Check that the data is flushed when we overflow the buffer
 406                         // with a large amount of data
 407                         stream.Write (outbytes, 0, 5);
 408                         stream.Write (outbytes, 5, 10);
 409                         stream.Seek (0, SeekOrigin.Begin);
 410
 411                         stream.Read (bytes, 0, 15);
 412                         for (int i = 0; i < 15; ++i)
 413                                 AssertEquals (i + 1, bytes [i]);
 414
 415                         // Check that the data is flushed when we overflow the buffer
 416                         // with a small amount of data
 417                         stream.Write (outbytes, 0, 7);
 418                         stream.Write (outbytes, 7, 7);
 419                         stream.Write (outbytes, 14, 1);
 420
 421                         stream.Read (bytes, 0, 15);
 422                         stream.Seek (15, SeekOrigin.Begin);
 423                         for (int i = 0; i < 15; ++i)
 424                                 AssertEquals (i + 1, bytes [i]);
 425                         stream.Close ();
 426                 }
 427
 428                 [Test]
 429                 public void Length ()
 430                 {
 431                         // Test that the Length property takes into account the data
 432                         // in the buffer
 433                         string path = TempFolder + DSC + "FileStreamTest.Length";
 434
 435                         DeleteFile (path);
 436
 437                         FileStream stream = new FileStream (path, FileMode.CreateNew);
 438
 439                         byte[] outbytes = new byte [] {1, 2, 3, 4};
 440
 441                         stream.Write (outbytes, 0, 4);
 442                         AssertEquals (stream.Length, 4);
 443                         stream.Close ();
 444                 }
 445
 446                 [Test]
 447                 public void Flush ()
 448                 {
 449                         string path = TempFolder + DSC + "FileStreamTest.Flush";
 450                         FileStream stream = null;
 451                         FileStream stream2 = null;
 452
 453                         DeleteFile (path);
 454
 455                         try {
 456                                 stream = new FileStream (path, FileMode.CreateNew, FileAccess.ReadWrite, FileShare.ReadWrite);
 457                                 stream2 = new FileStream (path, FileMode.Open, FileAccess.ReadWrite, FileShare.ReadWrite);
 458
 459                                 stream.Write (new byte [] {1, 2, 3, 4, 5}, 0, 5);
 460
 461                                 byte [] bytes = new byte [5];
 462                                 stream2.Read (bytes, 0, 5);
 463
 464                                 AssertEquals ("test#01", 0, bytes [0]);
 465                                 AssertEquals ("test#02", 0, bytes [1]);
 466                                 AssertEquals ("test#03", 0, bytes [2]);
 467                                 AssertEquals ("test#04", 0, bytes [3]);
 468
 469                                 stream.Flush ();
 470                                 stream2.Read (bytes, 0, 5);
 471                                 AssertEquals ("test#05", 1, bytes [0]);
 472                                 AssertEquals ("test#06", 2, bytes [1]);
 473                                 AssertEquals ("test#07", 3, bytes [2]);
 474                                 AssertEquals ("test#08", 4, bytes [3]);
 475                         } finally {
 476                                 if (stream != null)
 477                                         stream.Close ();
 478                                 if (stream2 != null)
 479                                         stream2.Close ();
 480
 481                                 DeleteFile (path);
 482                         }
 483                 }
 484
 485                 public void TestDefaultProperties ()
 486                 {
 487                         string path = TempFolder + Path.DirectorySeparatorChar + "testfilestream.tmp.2";
 488                         DeleteFile (path);
 489
 490                         FileStream stream = new FileStream (path, FileMode.Create);
 491
 492                         AssertEquals ("test#01", true, stream.CanRead);
 493                         AssertEquals ("test#02", true, stream.CanSeek);
 494                         AssertEquals ("test#03", true, stream.CanWrite);
 495                         AssertEquals ("test#04", false, stream.IsAsync);
 496                         AssertEquals ("test#05", true, stream.Name.EndsWith (path));
 497                         AssertEquals ("test#06", 0, stream.Position);
 498                         AssertEquals ("test#07", "System.IO.FileStream", stream.ToString());
 499                         stream.Close ();
 500                         DeleteFile (path);
 501
 502                         stream = new FileStream (path, FileMode.OpenOrCreate, FileAccess.Read);
 503                         AssertEquals ("test#08", true, stream.CanRead);
 504                         AssertEquals ("test#09", true, stream.CanSeek);
 505                         AssertEquals ("test#10", false, stream.CanWrite);
 506                         AssertEquals ("test#11", false, stream.IsAsync);
 507                         AssertEquals ("test#12", true, stream.Name.EndsWith (path));
 508                         AssertEquals ("test#13", 0, stream.Position);
 509                         AssertEquals ("test#14", "System.IO.FileStream", stream.ToString());
 510                         stream.Close ();
 511
 512                         stream = new FileStream (path, FileMode.Truncate, FileAccess.Write, FileShare.ReadWrite);
 513                         AssertEquals ("test#15", false, stream.CanRead);
 514                         AssertEquals ("test#16", true, stream.CanSeek);
 515                         AssertEquals ("test#17", true, stream.CanWrite);
 516                         AssertEquals ("test#18", false, stream.IsAsync);
 517                         AssertEquals ("test#19", true, stream.Name.EndsWith ("testfilestream.tmp.2"));
 518                         AssertEquals ("test#20", 0, stream.Position);
 519                         AssertEquals ("test#21", "System.IO.FileStream", stream.ToString());
 520                         stream.Close ();
 521                         DeleteFile (path);
 522                 }
 523
 524                 [Category("NotWorking")]
 525                 // Bug: 71371
 526                 public void TestLock_FailsOnMono ()
 527                 {
 528                         string path = TempFolder + Path.DirectorySeparatorChar + "TestLock";
 529                         DeleteFile (path);
 530
 531                         FileStream stream = new FileStream (path, FileMode.CreateNew, FileAccess.ReadWrite);
 532
 533                         stream.Write (new Byte [] {0,1,2,3,4,5,6,7,8,9,10}, 0, 10);
 534                         stream.Close ();
 535
 536                         stream = new FileStream (path, FileMode.Open, FileAccess.ReadWrite);
 537
 538                         stream.Lock (0, 5);
 539
 540                         FileStream stream2 = new FileStream (path , FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
 541
 542                         byte [] bytes = new byte [5];
 543                         try {
 544                                 stream2.Read (bytes, 0, 5);
 545                                 Fail ();
 546                         } catch (Exception e) {
 547
 548                                 // locked
 549                                 AssertEquals ("test#01", typeof (IOException), e.GetType ());
 550                         }
 551
 552                                         stream.Close ();
 553                         stream2.Close ();
 554
 555                         DeleteFile (path);
 556                 }
 557
 558                 public void TestLock()
 559                 {
 560                         string path = TempFolder + Path.DirectorySeparatorChar + "TestLock";
 561                         DeleteFile (path);
 562
 563                         FileStream stream = new FileStream (path, FileMode.CreateNew, FileAccess.ReadWrite);
 564
 565                         stream.Write (new Byte [] {0,1,2,3,4,5,6,7,8,9,10}, 0, 10);
 566                         stream.Close ();
 567
 568                         stream = new FileStream (path, FileMode.Open, FileAccess.ReadWrite);
 569
 570                         stream.Lock (0, 5);
 571
 572                         FileStream stream2 = new FileStream (path , FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
 573
 574                         byte [] bytes = new byte [5];
 575                         try {
 576                                 stream2.Read (bytes, 0, 5);
 577                                 Fail ();
 578                         } catch (Exception e) {
 579
 580                                 // locked
 581                                 // AssertEquals ("test#01", typeof (IOException), e.GetType ());
 582                                 //
 583                                 // Moved into the previous test case.
 584                         }
 585
 586                         stream2.Seek (5, SeekOrigin.Begin);
 587                         stream2.Read (bytes, 0, 5);
 588
 589                         AssertEquals ("test#02", 5, bytes [0]);
 590                         AssertEquals ("test#03", 6, bytes [1]);
 591                         AssertEquals ("test#04", 7, bytes [2]);
 592                         AssertEquals ("test#05", 8, bytes [3]);
 593                         AssertEquals ("test#06", 9, bytes [4]);
 594
 595                         stream.Unlock (0,5);
 596                         stream2.Seek (0, SeekOrigin.Begin);
 597                         stream2.Read (bytes, 0, 5);
 598
 599                         AssertEquals ("test#02", 0, bytes [0]);
 600                         AssertEquals ("test#03", 1, bytes [1]);
 601                         AssertEquals ("test#04", 2, bytes [2]);
 602                         AssertEquals ("test#05", 3, bytes [3]);
 603                         AssertEquals ("test#06", 4, bytes [4]);
 604
 605                         stream.Close ();
 606                         stream2.Close ();
 607
 608                         DeleteFile (path);
 609                 }
 610
 611                 [Test]
 612                 public void Seek ()
 613                 {
 614                         string path = TempFolder + DSC + "FST.Seek.Test";
 615                         DeleteFile (path);
 616
 617                         FileStream stream = new FileStream (path, FileMode.CreateNew, FileAccess.ReadWrite, FileShare.ReadWrite);
 618                         FileStream stream2 = new FileStream (path, FileMode.Open, FileAccess.ReadWrite, FileShare.ReadWrite);
 619
 620                         stream.Write (new byte [] {1, 2, 3, 4, 5, 6, 7, 8, 10}, 0, 9);
 621                         AssertEquals ("test#01", 5, stream2.Seek (5, SeekOrigin.Begin));
 622                         AssertEquals ("test#02", -1, stream2.ReadByte ());
 623
 624                         AssertEquals ("test#03", 2, stream2.Seek (-3, SeekOrigin.Current));
 625                         AssertEquals ("test#04", -1, stream2.ReadByte ());
 626
 627                         AssertEquals ("test#05", 12, stream.Seek (3, SeekOrigin.Current));
 628                         AssertEquals ("test#06", -1, stream.ReadByte ());
 629
 630                         AssertEquals ("test#07", 5, stream.Seek (-7, SeekOrigin.Current));
 631                         AssertEquals ("test#08", 6, stream.ReadByte ());
 632
 633                         AssertEquals ("test#09", 5, stream2.Seek (5, SeekOrigin.Begin));
 634                         AssertEquals ("test#10", 6, stream2.ReadByte ());
 635
 636                         stream.Close ();
 637                         stream2.Close ();
 638
 639                         DeleteFile (path);
 640                 }
 641
 642                 public void TestSeek ()
 643                 {
 644                                         string path = TempFolder + Path.DirectorySeparatorChar + "TestSeek";
 645                                         DeleteFile (path);
 646
 647                                         FileStream stream = new FileStream (path, FileMode.CreateNew, FileAccess.ReadWrite, FileShare.ReadWrite);
 648                         stream.Write (new byte[] {1, 2, 3, 4, 5, 6, 7, 8 , 9, 10}, 0, 10);
 649
 650                         stream.Seek (5, SeekOrigin.End);
 651                         AssertEquals ("test#01", -1, stream.ReadByte ());
 652
 653                         stream.Seek (-5, SeekOrigin.End);
 654                         AssertEquals ("test#02", 6, stream.ReadByte ());
 655
 656                         try {
 657                                 stream.Seek (-11, SeekOrigin.End);
 658                                 Fail ();
 659                         } catch (Exception e) {
 660                                 AssertEquals ("test#03", typeof (IOException), e.GetType ());
 661                         }
 662
 663                                         stream.Seek (19, SeekOrigin.Begin);
 664                                         AssertEquals ("test#04", -1, stream.ReadByte ());
 665
 666                                         stream.Seek (1, SeekOrigin.Begin);
 667                                         AssertEquals ("test#05", 2, stream.ReadByte ());
 668
 669                                         stream.Seek (3, SeekOrigin.Current);
 670                                         AssertEquals ("test#06", 6, stream.ReadByte ());
 671
 672                                         stream.Seek (-2, SeekOrigin.Current);
 673                                         AssertEquals ("test#07", 5, stream.ReadByte ());
 674
 675                                         stream.Flush ();
 676
 677                                         // Test that seeks work correctly when seeking inside the buffer
 678                                         stream.Seek (0, SeekOrigin.Begin);
 679                                         stream.WriteByte (0);
 680                                         stream.WriteByte (1);
 681                                         stream.Seek (0, SeekOrigin.Begin);
 682                                         byte[] buf = new byte [1];
 683                                         buf [0] = 2;
 684                                         stream.Write (buf, 0, 1);
 685                                         stream.Write (buf, 0, 1);
 686                                         stream.Flush ();
 687                                         stream.Seek (0, SeekOrigin.Begin);
 688                                         AssertEquals ("test#08", 2, stream.ReadByte ());
 689                                         AssertEquals ("test#09", 2, stream.ReadByte ());
 690
 691                                         stream.Close ();
 692
 693                                         DeleteFile (path);
 694                 }
 695
 696                 public void TestClose ()
 697                 {
 698                         string path = TempFolder + Path.DirectorySeparatorChar + "TestClose";
 699                         DeleteFile (path);
 700
 701                         FileStream stream = new FileStream (path, FileMode.CreateNew, FileAccess.ReadWrite);
 702
 703                         stream.Write (new byte [] {1, 2, 3, 4}, 0, 4);
 704                         stream.ReadByte ();
 705                         stream.Close ();
 706
 707                         try {
 708                                 stream.ReadByte ();
 709                                 Fail ();
 710                         } catch (Exception e) {
 711                                 AssertEquals ("test#01", typeof (ObjectDisposedException), e.GetType ());
 712                         }
 713
 714                         try {
 715                                 stream.WriteByte (64);
 716                                 Fail ();
 717                         } catch (Exception e) {
 718                                 AssertEquals ("test#02", typeof (ObjectDisposedException), e.GetType ());
 719                         }
 720
 721                         try {
 722                                 stream.Flush ();
 723                                 Fail ();
 724                         } catch (Exception e) {
 725                                 AssertEquals ("test#03", typeof (ObjectDisposedException), e.GetType ());
 726                         }
 727
 728                         try {
 729                                 long l = stream.Length;
 730                                 Fail ();
 731                         } catch (Exception e) {
 732                                 AssertEquals ("test#04", typeof (ObjectDisposedException), e.GetType ());
 733                         }
 734
 735                         try {
 736                                 long l = stream.Position;
 737                                 Fail ();
 738                         } catch (Exception e) {
 739                                 AssertEquals ("test#05", typeof (ObjectDisposedException), e.GetType ());
 740                         }
 741
 742                         AssertEquals ("test#06", false, stream.CanRead);
 743                         AssertEquals ("test#07", false, stream.CanSeek);
 744                         AssertEquals ("test#08", false, stream.CanWrite);
 745                         AssertEquals ("test#09", true, stream.Name.EndsWith (path));
 746
 747                         DeleteFile (path);
 748                 }
 749
 750
 751                 /// <summary>
 752                 /// Checks whether the <see cref="FileStream" /> throws a <see cref="NotSupportedException" />
 753                 /// when the stream is opened with access mode <see cref="FileAccess.Read" /> and the
 754                 /// <see cref="FileStream.Write(byte[], int, int)" /> method is called.
 755                 /// </summary>
 756                 [Test]
 757                 [ExpectedException (typeof(NotSupportedException))]
 758                 public void TestWriteVerifyAccessMode ()
 759                 {
 760                         string path = TempFolder + Path.DirectorySeparatorChar + "temp";
 761                         DeleteFile (path);
 762
 763                         FileStream stream = null;
 764                         byte[] buffer;
 765
 766                         try {
 767                                 buffer = Encoding.ASCII.GetBytes ("test");
 768                                 stream = new FileStream (path, FileMode.OpenOrCreate, FileAccess.Read);
 769                                 stream.Write (buffer, 0, buffer.Length);
 770                         } finally {
 771                                 if (stream != null)
 772                                         stream.Close();
 773                                 DeleteFile (path);
 774                         }
 775                 }
 776
 777                 /// <summary>
 778                 /// Checks whether the <see cref="FileStream" /> throws a <see cref="NotSupportedException" />
 779                 /// when the stream is opened with access mode <see cref="FileAccess.Read" /> and the
 780                 /// <see cref="FileStream.WriteByte(byte)" /> method is called.
 781                 /// </summary>
 782                 [Test]
 783                 [ExpectedException (typeof (NotSupportedException))]
 784                 public void TestWriteByteVerifyAccessMode ()
 785                 {
 786                         string path = TempFolder + Path.DirectorySeparatorChar + "temp";
 787                         DeleteFile (path);
 788
 789                         FileStream stream = null;
 790
 791                         try {
 792                                 stream = new FileStream (path, FileMode.OpenOrCreate, FileAccess.Read);
 793                                 stream.WriteByte (Byte.MinValue);
 794                         } finally {
 795                                 if (stream != null)
 796                                         stream.Close ();
 797                                 DeleteFile (path);
 798                         }
 799                 }
 800
 801                 /// <summary>
 802                 /// Checks whether the <see cref="FileStream" /> throws a <see cref="NotSupportedException" />
 803                 /// when the stream is opened with access mode <see cref="FileAccess.Write" /> and the
 804                 /// <see cref="FileStream.Read(byte[], int, int)" /> method is called.
 805                 /// </summary>
 806                 [Test]
 807                 [ExpectedException (typeof (NotSupportedException))]
 808                 public void TestReadVerifyAccessMode ()
 809                 {
 810                         string path = TempFolder + Path.DirectorySeparatorChar + "temp";
 811                         DeleteFile (path);
 812
 813                         FileStream stream = null;
 814                         byte[] buffer = new byte [100];
 815
 816                         try {
 817                                 stream = new FileStream (path, FileMode.OpenOrCreate, FileAccess.Write);
 818                                 stream.Read (buffer, 0, buffer.Length);
 819                         } finally {
 820                                 if (stream != null)
 821                                         stream.Close ();
 822                         }
 823                 }
 824
 825                 /// <summary>
 826                 /// Checks whether the <see cref="FileStream" /> throws a <see cref="NotSupportedException" />
 827                 /// when the stream is opened with access mode <see cref="FileAccess.Write" /> and the
 828                 /// <see cref="FileStream.ReadByte()" /> method is called.
 829                 /// </summary>
 830                 [Test]
 831                 [ExpectedException (typeof (NotSupportedException))]
 832                 public void TestReadByteVerifyAccessMode ()
 833                 {
 834                         string path = TempFolder + Path.DirectorySeparatorChar + "temp";
 835                         DeleteFile (path);
 836
 837                         FileStream stream = null;
 838
 839                         try {
 840                                 stream = new FileStream (path, FileMode.OpenOrCreate, FileAccess.Write);
 841                                 int readByte = stream.ReadByte ();
 842                         } finally {
 843                                 if (stream != null)
 844                                         stream.Close();
 845                                 DeleteFile (path);
 846                         }
 847                 }
 848
 849                 // Check that the stream is flushed even when it doesn't own the
 850                 // handle
 851                 [Test]
 852                 public void TestFlushNotOwningHandle ()
 853                 {
 854                         string path = Path.Combine (TempFolder, "TestFlushNotOwningHandle");
 855                         DeleteFile (path);
 856
 857                         FileStream s = new FileStream (path, FileMode.Create);
 858                         using (FileStream s2 = new FileStream (s.Handle, FileAccess.Write, false)) {
 859                                 byte[] buf = new byte [2];
 860                                 buf [0] = (int)'1';
 861                                 s2.Write (buf, 0, 1);
 862                         }
 863
 864                         s.Position = 0;
 865                         AssertEquals ((int)'1', s.ReadByte ());
 866                         s.Close ();
 867                 }
 868
 869                 private void DeleteFile (string path)
 870                 {
 871                         if (File.Exists (path))
 872                                 File.Delete (path);
 873                 }
 874
 875                 [Test]
 876                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
 877                 public void Read_OffsetNegative ()
 878                 {
 879                         string path = TempFolder + Path.DirectorySeparatorChar + "temp";
 880                         DeleteFile (path);
 881
 882                         using (FileStream stream = new FileStream (path, FileMode.OpenOrCreate, FileAccess.Read)) {
 883                                 stream.Read (new byte[0], -1, 1);
 884                         }
 885                 }
 886
 887                 [Test]
 888                 [ExpectedException (typeof (ArgumentException))]
 889                 public void Read_OffsetOverflow ()
 890                 {
 891                         string path = TempFolder + Path.DirectorySeparatorChar + "temp";
 892                         DeleteFile (path);
 893
 894                         using (FileStream stream = new FileStream (path, FileMode.OpenOrCreate, FileAccess.Read)) {
 895                                 stream.Read (new byte[0], Int32.MaxValue, 1);
 896                         }
 897                 }
 898
 899                 [Test]
 900                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
 901                 public void Read_CountNegative ()
 902                 {
 903                         string path = TempFolder + Path.DirectorySeparatorChar + "temp";
 904                         DeleteFile (path);
 905
 906                         using (FileStream stream = new FileStream (path, FileMode.OpenOrCreate, FileAccess.Read)) {
 907                                 stream.Read (new byte[0], 1, -1);
 908                         }
 909                 }
 910
 911                 [Test]
 912                 [ExpectedException (typeof (ArgumentException))]
 913                 public void Read_CountOverflow ()
 914                 {
 915                         string path = TempFolder + Path.DirectorySeparatorChar + "temp";
 916                         DeleteFile (path);
 917
 918                         using (FileStream stream = new FileStream (path, FileMode.OpenOrCreate, FileAccess.Read)) {
 919                                 stream.Read (new byte[0], 1, Int32.MaxValue);
 920                         }
 921                 }
 922
 923                 [Test]
 924                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
 925                 public void Write_OffsetNegative ()
 926                 {
 927                         string path = TempFolder + Path.DirectorySeparatorChar + "temp";
 928                         DeleteFile (path);
 929
 930                         using (FileStream stream = new FileStream (path, FileMode.OpenOrCreate, FileAccess.Write)) {
 931                                 stream.Write (new byte[0], -1, 1);
 932                         }
 933                 }
 934
 935                 [Test]
 936                 [ExpectedException (typeof (ArgumentException))]
 937                 public void Write_OffsetOverflow ()
 938                 {
 939                         string path = TempFolder + Path.DirectorySeparatorChar + "temp";
 940                         DeleteFile (path);
 941
 942                         using (FileStream stream = new FileStream (path, FileMode.OpenOrCreate, FileAccess.Write)) {
 943                                 stream.Write (new byte[0], Int32.MaxValue, 1);
 944                         }
 945                 }
 946
 947                 [Test]
 948                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
 949                 public void Write_CountNegative ()
 950                 {
 951                         string path = TempFolder + Path.DirectorySeparatorChar + "temp";
 952                         DeleteFile (path);
 953
 954                         using (FileStream stream = new FileStream (path, FileMode.OpenOrCreate, FileAccess.Write)) {
 955                                 stream.Write (new byte[0], 1, -1);
 956                         }
 957                 }
 958
 959                 [Test]
 960                 [ExpectedException (typeof (ArgumentException))]
 961                 public void Write_CountOverflow ()
 962                 {
 963                         string path = TempFolder + Path.DirectorySeparatorChar + "temp";
 964                         DeleteFile (path);
 965
 966                         using (FileStream stream = new FileStream (path, FileMode.OpenOrCreate, FileAccess.Write)) {
 967                                 stream.Write (new byte[0], 1, Int32.MaxValue);
 968                         }
 969                 }
 970
 971                 [Test]
 972                 [ExpectedException (typeof (ArgumentException))]
 973                 public void Seek_InvalidSeekOrigin ()
 974                 {
 975                         string path = TempFolder + Path.DirectorySeparatorChar + "temp";
 976                         DeleteFile (path);
 977
 978                         using (FileStream stream = new FileStream (path, FileMode.OpenOrCreate, FileAccess.Read)) {
 979                                 stream.Seek (0, (SeekOrigin) (-1));
 980                         }
 981                 }
 982
 983                 [Test]
 984                 [ExpectedException (typeof (ArgumentException))]
 985                 public void Constructor_InvalidFileHandle ()
 986                 {
 987                         new FileStream ((IntPtr)(-1), FileAccess.Read);
 988                 }
 989
 990                 [Test]
 991                 public void PositionAfterSetLength ()
 992                 {
 993                         string path = TempFolder + Path.DirectorySeparatorChar + "temp";
 994                         DeleteFile (path);
 995
 996                         using (FileStream stream = new FileStream (path, FileMode.OpenOrCreate, FileAccess.Write)) {
 997                                 stream.SetLength (32);
 998                                 stream.Position = 32;
 999                                 stream.SetLength (16);
1000                                 AssertEquals ("Position==16", 16, stream.Position);
1001                         }
1002                 }
1003
1004                 [Test]
1005                 [ExpectedException (typeof (ObjectDisposedException))]
1006                 public void SetLength_Disposed ()
1007                 {
1008                         string path = TempFolder + Path.DirectorySeparatorChar + "temp";
1009                         DeleteFile (path);
1010                         FileStream stream = new FileStream (path, FileMode.OpenOrCreate, FileAccess.Write);
1011                         stream.Close ();
1012                         stream.SetLength (16);
1013                 }
1014
1015                 [Test]
1016                 [ExpectedException (typeof (ObjectDisposedException))]
1017                 public void Position_Disposed ()
1018                 {
1019                         string path = TempFolder + Path.DirectorySeparatorChar + "temp";
1020                         DeleteFile (path);
1021                         FileStream stream = new FileStream (path, FileMode.OpenOrCreate, FileAccess.Read);
1022                         stream.Close ();
1023                         stream.Position = 0;
1024                 }
1025
1026                 [Test]
1027                 [ExpectedException (typeof (ObjectDisposedException))]
1028                 public void BeginRead_Disposed ()
1029                 {
1030                         string path = TempFolder + Path.DirectorySeparatorChar + "temp";
1031                         DeleteFile (path);
1032                         FileStream stream = new FileStream (path, FileMode.OpenOrCreate, FileAccess.Read);
1033                         stream.Close ();
1034                         stream.EndRead (stream.BeginRead (new byte[8], 0, 8, null, null));
1035                 }
1036
1037                 [Test]
1038                 [ExpectedException (typeof (ObjectDisposedException))]
1039                 public void BeginWrite_Disposed ()
1040                 {
1041                         string path = TempFolder + Path.DirectorySeparatorChar + "temp";
1042                         DeleteFile (path);
1043                         FileStream stream = new FileStream (path, FileMode.OpenOrCreate, FileAccess.Write);
1044                         stream.Close ();
1045                         stream.EndWrite (stream.BeginWrite (new byte[8], 0, 8, null, null));
1046                 }
1047
1048                 [Test]
1049                 [ExpectedException (typeof (ObjectDisposedException))]
1050                 public void Lock_Disposed ()
1051                 {
1052                         string path = TempFolder + Path.DirectorySeparatorChar + "temp";
1053                         DeleteFile (path);
1054                         FileStream stream = new FileStream (path, FileMode.OpenOrCreate, FileAccess.Write);
1055                         stream.Close ();
1056                         stream.Lock (0,1);
1057                 }
1058
1059                 [Test]
1060                 [ExpectedException (typeof (ObjectDisposedException))]
1061                 public void Unlock_Disposed ()
1062                 {
1063                         string path = TempFolder + Path.DirectorySeparatorChar + "temp";
1064                         DeleteFile (path);
1065                         FileStream stream = new FileStream (path, FileMode.OpenOrCreate, FileAccess.Write);
1066                         stream.Close ();
1067                         stream.Unlock (0,1);
1068                 }
1069
1070                 [Test]
1071                 public void ReadBytePastEndOfStream ()
1072                 {
1073                         string path = TempFolder + Path.DirectorySeparatorChar + "temp";
1074                         DeleteFile (path);
1075                         using (FileStream stream = new FileStream (path, FileMode.OpenOrCreate, FileAccess.Read)) {
1076                                 stream.Seek (0, SeekOrigin.End);
1077                                 AssertEquals ("ReadByte", -1, stream.ReadByte ());
1078                                 stream.Close ();
1079                         }
1080                 }
1081
1082                 [Test]
1083                 [ExpectedException (typeof (NotSupportedException))]
1084                 public void SetLengthWithClosedBaseStream ()
1085                 {
1086                         string fn = Path.Combine (TempFolder, "temp");
1087                         try {
1088                                 FileStream fs = new FileStream (fn, FileMode.Create);
1089                                 BufferedStream bs = new BufferedStream (fs);
1090                                 fs.Close ();
1091
1092                                 bs.SetLength (1000);
1093                         } finally {
1094                                 File.Delete (fn);
1095                         }
1096                 }
1097         }
1098 }
1099