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

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