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