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

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