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

   1 //
   2 // System.IO.BufferedStream Unit Tests
   3 //
   4 // Authors:
   5 //      Ville Palo (vi64pa@kolumbus.fi)
   6 //      Sebastien Pouliot  <sebastien@ximian.com>
   7 //
   8 // (C) 2003 Ville Palo
   9 // Copyright (C) 2004 Novell (http://www.novell.com)
  10 //
  11
  12 using NUnit.Framework;
  13 using System.IO;
  14 using System.Text;
  15 using System;
  16
  17 namespace MonoTests.System.IO {
  18
  19 [TestFixture]
  20 public class BufferedStreamTest {
  21
  22         private MemoryStream mem;
  23
  24         [SetUp]
  25         protected void SetUp ()
  26         {
  27                 mem = new MemoryStream ();
  28         }
  29
  30         [TearDown]
  31         protected void TearDown ()
  32         {
  33                 //Some tests might mess with mem, so let's check it first
  34                 if (mem != null)
  35                         mem.Close ();
  36         }
  37
  38
  39         [Test]
  40         public void Ctor ()
  41         {
  42                 MemoryStream str = new MemoryStream ();
  43                 str.Write (new byte [] {1, 2, 3, 4, 5, 6}, 0, 6);
  44                 BufferedStream stream = new BufferedStream (str);
  45
  46                 Assert.AreEqual (true, stream.CanRead, "test#01");
  47                 Assert.AreEqual (true, stream.CanSeek, "test#02");
  48                 Assert.AreEqual (true, stream.CanWrite, "test#03");
  49                 Assert.AreEqual (6, stream.Length, "test#04");
  50                 Assert.AreEqual (6, stream.Position, "test#05");
  51
  52                 string path = Path.GetTempFileName ();
  53                 if (File.Exists (path))
  54                         File.Delete (path);
  55
  56                 FileStream file = new FileStream (path, FileMode.OpenOrCreate, FileAccess.Write);
  57                 stream = new BufferedStream (file);
  58                 Assert.AreEqual (false, stream.CanRead, "test#06");
  59                 Assert.AreEqual (true, stream.CanSeek, "test#07");
  60                 Assert.AreEqual (true, stream.CanWrite, "test#08");
  61                 Assert.AreEqual (0, stream.Length, "test#09");
  62                 Assert.AreEqual (0, stream.Position, "test#10");
  63                 file.Close ();
  64
  65                 if (File.Exists (path))
  66                         File.Delete (path);
  67
  68                 file = new FileStream (path, FileMode.OpenOrCreate, FileAccess.Write);
  69                 stream = new BufferedStream (file, 12);
  70                 Assert.AreEqual (false, stream.CanRead, "test#11");
  71                 Assert.AreEqual (true, stream.CanSeek, "test#12");
  72                 Assert.AreEqual (true, stream.CanWrite, "test#13");
  73                 Assert.AreEqual (0, stream.Length, "test#14");
  74                 Assert.AreEqual (0, stream.Position, "test#15");
  75
  76                 file.Close ();
  77                 if (File.Exists (path))
  78                         File.Delete (path);
  79         }
  80
  81         /// <summary>
  82         /// Throws an exception if stream is null
  83         /// </summary>
  84         [Test]
  85         [ExpectedException(typeof(ArgumentNullException))]
  86         public void CtorNullExceptionStream ()
  87         {
  88                 BufferedStream stream = new BufferedStream (null);
  89         }
  90
  91         /// <summary>
  92         /// Throws an exception if stream is null
  93         /// </summary>
  94         [Test]
  95         [ExpectedException(typeof(ArgumentNullException))]
  96         public void CtorNullExceptionStream1 ()
  97         {
  98                 BufferedStream stream = new BufferedStream (null, 12);
  99         }
 100
 101         /// <summary>
 102         /// Throws an exception if stream is null
 103         /// </summary>
 104         [Test]
 105         [ExpectedException(typeof(ArgumentOutOfRangeException))]
 106         public void CtorOutOfRangeExceptionStream1 ()
 107         {
 108                 MemoryStream str = new MemoryStream ();
 109                 BufferedStream stream = new BufferedStream (str, -12);
 110         }
 111
 112
 113         [Test]
 114         [ExpectedException(typeof(ObjectDisposedException))]
 115         public void CtorOutOfRangeException2 ()
 116         {
 117                 MemoryStream str = new MemoryStream ();
 118                 str.Close ();
 119                 BufferedStream stream = new BufferedStream (str);
 120         }
 121
 122         [Test]
 123         public void Close1 ()
 124         {
 125                 BufferedStream stream = new BufferedStream (mem);
 126                 stream.Close ();
 127                 stream.Close ();
 128         }
 129
 130         [Test]
 131         public void Close2 ()
 132         {
 133                 BufferedStream stream = new BufferedStream (mem);
 134                 stream.Close ();
 135                 Assert.AreEqual (false, stream.CanRead, "test#01");
 136                 Assert.AreEqual (false, stream.CanSeek, "test#02");
 137                 Assert.AreEqual (false, stream.CanWrite, "test#03");
 138         }
 139
 140         [Test]
 141         [ExpectedException(typeof(ObjectDisposedException))]
 142         public void Close3 ()
 143         {
 144                 BufferedStream stream = new BufferedStream (mem);
 145                 stream.Close ();
 146                 long l = stream.Position;
 147         }
 148
 149         [Test]
 150         [ExpectedException(typeof(ObjectDisposedException))]
 151         public void Close4 ()
 152         {
 153                 BufferedStream stream = new BufferedStream (mem);
 154                 stream.Close ();
 155                 long l = stream.Length;
 156         }
 157
 158         [Test]
 159         [ExpectedException(typeof(ObjectDisposedException))]
 160         public void Close5 ()
 161         {
 162                 BufferedStream stream = new BufferedStream (mem);
 163                 stream.Close ();
 164                 stream.WriteByte (1);
 165         }
 166
 167         [Test]
 168         [ExpectedException(typeof(ObjectDisposedException))]
 169         public void Close6 ()
 170         {
 171                 BufferedStream stream = new BufferedStream (mem);
 172                 stream.Close ();
 173                 stream.ReadByte ();
 174         }
 175
 176         [Test]
 177         [ExpectedException(typeof(NotSupportedException))]
 178         public void Close7 ()
 179         {
 180                 BufferedStream stream = new BufferedStream (mem);
 181                 mem.Close ();
 182                 stream.WriteByte (1);
 183         }
 184
 185         [Test]
 186         public void Read ()
 187         {
 188                 mem.Write (new byte [] {0, 1, 2, 3, 4, 5, 6, 7}, 0, 8);
 189                 BufferedStream stream = new BufferedStream (mem);
 190
 191                 byte [] bytes = new byte [10];
 192                 stream.Read (bytes, 0, 3);
 193                 Assert.AreEqual (0, bytes [0], "test#01");
 194                 Assert.AreEqual (0, bytes [1], "test#02");
 195                 Assert.AreEqual (0, bytes [2], "test#03");
 196
 197                 stream.Seek (0, SeekOrigin.Begin);
 198                 stream.Read (bytes, 0, 3);
 199                 Assert.AreEqual (0, bytes [0], "test#04");
 200                 Assert.AreEqual (1, bytes [1], "test#05");
 201                 Assert.AreEqual (2, bytes [2], "test#06");
 202                 Assert.AreEqual (0, bytes [0], "test#07");
 203
 204                 stream.Read (bytes, 5, 3);
 205                 Assert.AreEqual (3, bytes [5], "test#08");
 206                 Assert.AreEqual (4, bytes [6], "test#09");
 207                 Assert.AreEqual (5, bytes [7], "test#10");
 208                 Assert.AreEqual (0, bytes [8], "test#11");
 209
 210                 stream.Read (bytes, 0, 10);
 211                 Assert.AreEqual (3, bytes [5], "test#12");
 212                 Assert.AreEqual (4, bytes [6], "test#13");
 213                 Assert.AreEqual (5, bytes [7], "test#14");
 214                 Assert.AreEqual (0, bytes [9], "test#15");
 215         }
 216
 217         [Test]
 218         [ExpectedException(typeof(ArgumentException))]
 219         public void ReadException ()
 220         {
 221                 mem.Write (new byte [] {0, 1, 2, 3, 4, 5, 6, 7}, 0, 8);
 222                 BufferedStream stream = new BufferedStream (mem);
 223
 224                 byte [] bytes = new byte [10];
 225                 stream.Read (bytes, 0, 30);
 226         }
 227
 228         [Test]
 229         [ExpectedException(typeof(ArgumentNullException))]
 230         public void Read_Null ()
 231         {
 232                 BufferedStream stream = new BufferedStream (mem);
 233                 stream.Read (null, 0, 0);
 234         }
 235
 236         [Test]
 237         [ExpectedException(typeof(NotSupportedException))]
 238         public void Read_CantRead ()
 239         {
 240                 WriteOnlyStream wo = new WriteOnlyStream ();
 241                 BufferedStream stream = new BufferedStream (wo);
 242                 stream.Read (new byte [1], 0, 1);
 243         }
 244
 245         [Test]
 246         [ExpectedException(typeof(NotSupportedException))]
 247         public void ReadByte_CantRead ()
 248         {
 249                 WriteOnlyStream wo = new WriteOnlyStream ();
 250                 BufferedStream stream = new BufferedStream (wo);
 251                 stream.ReadByte ();
 252         }
 253
 254         [Test]
 255         [ExpectedException(typeof(ArgumentOutOfRangeException))]
 256         public void Read_OffsetNegative ()
 257         {
 258                 BufferedStream stream = new BufferedStream (mem);
 259                 stream.Read (new byte [1], -1, 1);
 260         }
 261
 262         [Test]
 263         [ExpectedException(typeof(ArgumentException))]
 264         public void Read_OffsetOverflow ()
 265         {
 266                 BufferedStream stream = new BufferedStream (mem);
 267                 stream.Read (new byte [1], Int32.MaxValue, 1);
 268         }
 269
 270         [Test]
 271         [ExpectedException(typeof(ArgumentOutOfRangeException))]
 272         public void Read_CountNegative ()
 273         {
 274                 BufferedStream stream = new BufferedStream (mem);
 275                 stream.Read (new byte [1], 1, -1);
 276         }
 277
 278         [Test]
 279         [ExpectedException(typeof(ArgumentException))]
 280         public void Read_CountOverflow ()
 281         {
 282                 BufferedStream stream = new BufferedStream (mem);
 283                 stream.Read (new byte [1], 1, Int32.MaxValue);
 284         }
 285
 286         [Test]
 287         public void ReadByte ()
 288         {
 289                 mem.Write (new byte [] {0, 1, 2, 3, 4, 5, 6, 7}, 0, 8);
 290                 BufferedStream stream = new BufferedStream (mem);
 291
 292                 Assert.AreEqual (-1, stream.ReadByte (), "test#01");
 293                 Assert.AreEqual (-1, stream.ReadByte (), "test#02");
 294                 Assert.AreEqual (-1, stream.ReadByte (), "test#03");
 295
 296                 stream.Seek (0, SeekOrigin.Begin);
 297                 Assert.AreEqual (0, stream.ReadByte (), "test#04");
 298                 Assert.AreEqual (1, stream.ReadByte (), "test#05");
 299                 Assert.AreEqual (2, stream.ReadByte (), "test#06");
 300                 Assert.AreEqual (3, stream.ReadByte (), "test#07");
 301         }
 302
 303         [Test]
 304         public void Write ()
 305         {
 306                 BufferedStream stream = new BufferedStream (mem);
 307
 308                 stream.Write (new byte [] {0, 1, 2, 3, 4}, 0, 4);
 309                 Assert.AreEqual (4, stream.Length, "test#01");
 310                 byte [] bytes = mem.GetBuffer ();
 311                 Assert.AreEqual (0, bytes [0], "test#02");
 312                 Assert.AreEqual (1, bytes [1], "test#03");
 313                 Assert.AreEqual (2, bytes [2], "test#04");
 314                 Assert.AreEqual (3, bytes [3], "test#05");
 315
 316                 bytes = new byte [] {1, 4, 3};
 317                 stream.Write (bytes, 0, 3);
 318                 stream.Flush ();
 319                 bytes = mem.GetBuffer ();
 320                 Assert.AreEqual (0, bytes [0], "test#06");
 321                 Assert.AreEqual (1, bytes [1], "test#07");
 322                 Assert.AreEqual (2, bytes [2], "test#08");
 323                 Assert.AreEqual (3, bytes [3], "test#09");
 324                 Assert.AreEqual (1, bytes [4], "test#10");
 325                 Assert.AreEqual (4, bytes [5], "test#11");
 326                 Assert.AreEqual (3, bytes [6], "test#10");
 327                 Assert.AreEqual (0, bytes [7], "test#11");
 328                 Assert.AreEqual (7, stream.Length, "test#12");
 329         }
 330
 331         [Test]
 332         [ExpectedException(typeof (ArgumentException))]
 333         public void WriteException ()
 334         {
 335                 BufferedStream stream = new BufferedStream (mem);
 336                 stream.Write (new byte [] {0,1,2,3}, 0, 10);
 337         }
 338
 339         [Test]
 340         [ExpectedException(typeof(ArgumentNullException))]
 341         public void Write_Null ()
 342         {
 343                 BufferedStream stream = new BufferedStream (mem);
 344                 stream.Write (null, 0, 0);
 345         }
 346
 347         [Test]
 348         [ExpectedException(typeof(NotSupportedException))]
 349         public void Write_CantWrite ()
 350         {
 351                 ReadOnlyStream ro = new ReadOnlyStream ();
 352                 BufferedStream stream = new BufferedStream (ro);
 353                 stream.Write (new byte [1], 0, 1);
 354         }
 355
 356         [Test]
 357         [ExpectedException(typeof(NotSupportedException))]
 358         public void WriteByte_CantWrite ()
 359         {
 360                 ReadOnlyStream ro = new ReadOnlyStream ();
 361                 BufferedStream stream = new BufferedStream (ro);
 362                 stream.WriteByte (0);
 363         }
 364
 365         [Test]
 366         [ExpectedException(typeof(ArgumentOutOfRangeException))]
 367         public void Write_OffsetNegative ()
 368         {
 369                 BufferedStream stream = new BufferedStream (mem);
 370                 stream.Write (new byte [1], -1, 1);
 371         }
 372
 373         [Test]
 374         [ExpectedException(typeof(ArgumentException))]
 375         public void Write_OffsetOverflow ()
 376         {
 377                 BufferedStream stream = new BufferedStream (mem);
 378                 stream.Write (new byte [1], Int32.MaxValue, 1);
 379         }
 380
 381         [Test]
 382         [ExpectedException(typeof(ArgumentOutOfRangeException))]
 383         public void Write_CountNegative ()
 384         {
 385                 BufferedStream stream = new BufferedStream (mem);
 386                 stream.Write (new byte [1], 1, -1);
 387         }
 388
 389         [Test]
 390         [ExpectedException(typeof(ArgumentException))]
 391         public void Write_CountOverflow ()
 392         {
 393                 BufferedStream stream = new BufferedStream (mem);
 394                 stream.Write (new byte [1], 1, Int32.MaxValue);
 395         }
 396
 397         [Test]
 398         public void WriteByte ()
 399         {
 400                 BufferedStream stream = new BufferedStream (mem);
 401                 stream.WriteByte (1);
 402                 stream.WriteByte (2);
 403                 stream.WriteByte (3);
 404                 stream.Flush ();
 405                 Assert.AreEqual (256, mem.GetBuffer ().Length, "test#01");
 406                 Assert.AreEqual (3, stream.Length, "test#02");
 407                 Assert.AreEqual (1, mem.GetBuffer () [0], "test#03");
 408                 Assert.AreEqual (2, mem.GetBuffer () [1], "test#04");
 409                 Assert.AreEqual (3, mem.GetBuffer () [2], "test#05");
 410         }
 411
 412         [Test]
 413         public void Flush ()
 414         {
 415                 BufferedStream stream = new BufferedStream (mem);
 416                 stream.WriteByte (1);
 417                 stream.WriteByte (2);
 418
 419                 byte [] bytes = mem.GetBuffer ();
 420                 Assert.AreEqual (0, bytes.Length, "test#01");
 421                 stream.Flush ();
 422
 423                 bytes = mem.GetBuffer ();
 424                 Assert.AreEqual (256, bytes.Length, "test#02");
 425                 Assert.AreEqual (1, bytes [0], "test#03");
 426                 Assert.AreEqual (2, bytes [1], "test#04");
 427                 mem.Close ();
 428                 mem = new MemoryStream ();
 429                 bytes = new byte [] {0, 1, 2, 3, 4, 5};
 430                 stream = new BufferedStream (mem);
 431                 stream.Write (bytes, 0, 2);
 432                 Assert.AreEqual (2, stream.Length, "test#05");
 433                 bytes = mem.GetBuffer ();
 434                 Assert.AreEqual (256, bytes.Length, "test#06");
 435
 436                 Assert.AreEqual (0, bytes [0], "test#07");
 437                 Assert.AreEqual (1, bytes [1], "test#08");
 438
 439                 stream.Write (bytes, 0, 2);
 440
 441                 bytes = mem.GetBuffer ();
 442                 Assert.AreEqual (0, bytes [0], "test#09");
 443                 Assert.AreEqual (1, bytes [1], "test#10");
 444                 Assert.AreEqual (0, bytes [2], "test#11");
 445                 Assert.AreEqual (0, bytes [3], "test#12");
 446                 stream.Flush ();
 447                 bytes = mem.GetBuffer ();
 448                 Assert.AreEqual (0, bytes [2], "test#13");
 449                 Assert.AreEqual (1, bytes [3], "test#14");
 450         }
 451
 452         [Test]
 453         public void Seek ()
 454         {
 455                 BufferedStream stream = new BufferedStream (mem);
 456                 stream.Write (new byte [] {0, 1, 2, 3, 4, 5}, 0, 6);
 457
 458                 Assert.AreEqual (6, stream.Position, "test#01");
 459
 460                 stream.Seek (-5, SeekOrigin.End);
 461                 Assert.AreEqual (1, stream.Position, "test#02");
 462
 463                 stream.Seek (3, SeekOrigin.Current);
 464                 Assert.AreEqual (4, stream.Position, "test#03");
 465
 466                 stream.Seek (300, SeekOrigin.Current);
 467                 Assert.AreEqual (304, stream.Position, "test#04");
 468         }
 469
 470         [Test]
 471         [ExpectedException(typeof (IOException))]
 472         public void SeekException ()
 473         {
 474                 BufferedStream stream = new BufferedStream (mem);
 475                 stream.Seek (-1, SeekOrigin.Begin);
 476         }
 477
 478         [Test]
 479         public void SetLength ()
 480         {
 481                 BufferedStream stream = new BufferedStream (mem);
 482                 stream.Write (new byte [] {0,1,2,3,4,5}, 0, 6);
 483
 484                 Assert.AreEqual (6, stream.Length, "test#01");
 485                 stream.SetLength (60);
 486                 Assert.AreEqual (60, stream.Length, "test#02");
 487
 488                 stream.SetLength (2);
 489                 Assert.AreEqual (2, stream.Length, "test#03");
 490         }
 491
 492          [Test]
 493          [ExpectedException(typeof(ArgumentOutOfRangeException))]
 494          public void SetLengthException ()
 495          {
 496                 BufferedStream stream = new BufferedStream (mem);
 497                 stream.SetLength (-1);
 498          }
 499
 500          [Test]
 501          [ExpectedException(typeof(NotSupportedException))]
 502          public void SetLengthException2 ()
 503          {
 504                 BufferedStream stream = new BufferedStream (mem);
 505                 mem.Close ();
 506                 stream.SetLength (1);
 507          }
 508
 509          [Test]
 510          public void SetLengthException3 ()
 511          {
 512                 BufferedStream stream = new BufferedStream (mem);
 513                 mem = null;
 514                 // Strangely, this does not throw an exception on .NET 1.1
 515                 stream.SetLength (1);
 516          }
 517
 518          [Test]
 519          public void Position ()
 520          {
 521                 mem = new MemoryStream ();
 522                 BufferedStream stream = new BufferedStream (mem,5);
 523                 stream.Write (new byte [] {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15}, 0, 16);
 524
 525                 stream.Position = 0;
 526                 Assert.AreEqual (0, stream.Position, "test#01");
 527                 Assert.AreEqual (0, stream.ReadByte (), "test#02");
 528
 529                 stream.Position = 5;
 530                 Assert.AreEqual (5, stream.Position, "test#01");
 531                 Assert.AreEqual (5, stream.ReadByte (), "test#02");
 532
 533                 // Should not need to read from the underlying stream:
 534                 stream.Position = 7;
 535                 Assert.AreEqual (7, stream.Position, "test#01");
 536                 Assert.AreEqual (7, stream.ReadByte (), "test#02");
 537
 538                 // Should not need to read from the underlying stream:
 539                 stream.Position = 5;
 540                 Assert.AreEqual (5, stream.Position, "test#01");
 541                 Assert.AreEqual (5, stream.ReadByte (), "test#02");
 542
 543                 // Should not need to read from the underlying stream:
 544                 stream.Position = 9;
 545                 Assert.AreEqual (9, stream.Position, "test#01");
 546                 Assert.AreEqual (9, stream.ReadByte (), "test#02");
 547
 548                 stream.Position = 10;
 549                 Assert.AreEqual (10, stream.Position, "test#01");
 550                 Assert.AreEqual (10, stream.ReadByte (), "test#02");
 551
 552                 stream.Position = 9;
 553                 Assert.AreEqual (9, stream.Position, "test#01");
 554                 Assert.AreEqual (9, stream.ReadByte (), "test#02");
 555          }
 556
 557         [Test]
 558         public void PositionAfterSetLength ()
 559         {
 560                 BufferedStream stream = new BufferedStream (new MemoryStream ());
 561                 stream.SetLength (32);
 562                 stream.Position = 32;
 563                 stream.SetLength (16);
 564                 Assert.AreEqual (16, stream.Position, "Position==16");
 565         }
 566
 567         [Test]
 568         [ExpectedException (typeof (ObjectDisposedException))]
 569         public void SetLength_Disposed ()
 570         {
 571                 BufferedStream stream = new BufferedStream (new MemoryStream ());
 572                 stream.Close ();
 573                 stream.SetLength (16);
 574         }
 575
 576         [Test]
 577         [ExpectedException (typeof (NotSupportedException))]
 578         public void Seek_ClosedMemoryStream ()
 579         {
 580                 MemoryStream ms = new MemoryStream ();
 581                 BufferedStream stream = new BufferedStream (ms);
 582                 ms.Close ();
 583                 stream.Seek (0, SeekOrigin.Begin);
 584         }
 585
 586         [Test]
 587         [ExpectedException (typeof (ObjectDisposedException))]
 588         public void Seek_ClosedBufferedStream ()
 589         {
 590                 BufferedStream stream = new BufferedStream (new MemoryStream ());
 591                 stream.Close ();
 592                 stream.Seek (0, SeekOrigin.Begin);
 593         }
 594 }
 595 }