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

   1 // BinaryReaderTest.cs - NUnit Test Cases for the SystemIO.BinaryReader class
   2 //
   3 // Eduardo Garcia Cebollero (kiwnix@yahoo.es)
   4 //
   5 // (C) Eduardo Garcia Cebollero.
   6 // (C) Ximian, Inc.  http://www.ximian.com
   7 // Copyright (C) 2004 Novell (http://www.novell.com)
   8 //
   9
  10 using NUnit.Framework;
  11 using System;
  12 using System.IO;
  13 using System.Text;
  14
  15 namespace MonoTests.System.IO
  16 {
  17         [TestFixture]
  18         public class BinaryReaderTest
  19         {
  20                 static string TempFolder = Path.Combine (Path.GetTempPath (), "MonoTests.System.IO.Tests");
  21                 static string _codeFileName = TempFolder + Path.DirectorySeparatorChar + "AFile.txt";
  22
  23                 [SetUp]
  24                 public void SetUp() {
  25                         if (!Directory.Exists (TempFolder))
  26                                 Directory.CreateDirectory (TempFolder);
  27
  28                         if (!File.Exists (_codeFileName))
  29                                 File.Create (_codeFileName).Close ();
  30                 }
  31
  32                 [TearDown]
  33                 public void TearDown ()
  34                 {
  35                                 if (Directory.Exists (TempFolder))
  36                                         Directory.Delete (TempFolder, true);
  37                 }
  38
  39                 [Test]
  40                 [ExpectedException(typeof(ArgumentNullException))]
  41                 public void CtorArgumentNullException1 ()
  42                 {
  43                         BinaryReader r = null;
  44                         try {
  45                                 r = new BinaryReader ((Stream) null);
  46                         } finally {
  47                                 if (r != null)
  48                                         r.Close ();
  49                         }
  50                 }
  51
  52                 [Test]
  53                 [ExpectedException(typeof(ArgumentNullException))]
  54                 public void CtorArgumentNullException2 ()
  55                 {
  56                         BinaryReader r = null;
  57                         try {
  58                                 r = new BinaryReader ((Stream) null, Encoding.ASCII);
  59                         } finally {
  60                                 if (r != null)
  61                                         r.Close ();
  62                         }
  63                 }
  64
  65                 [Test]
  66                 [ExpectedException(typeof(ArgumentNullException))]
  67                 public void CtorArgumentNullException3 ()
  68                 {
  69                         BinaryReader r = null;
  70                         try {
  71                                 r = new BinaryReader ((Stream) null, Encoding.Unicode);
  72                         } finally {
  73                                 if (r != null)
  74                                         r.Close ();
  75                         }
  76                 }
  77
  78                 [Test]
  79                 [ExpectedException(typeof(ArgumentNullException))]
  80                 public void CtorArgumentNullException4 ()
  81                 {
  82                         BinaryReader r = null;
  83                         try {
  84                                 r = new BinaryReader ((Stream) null, Encoding.UTF7);
  85                         } finally {
  86                                 if (r != null)
  87                                         r.Close ();
  88                         }
  89                 }
  90
  91                 [Test]
  92                 [ExpectedException(typeof(ArgumentNullException))]
  93                 public void CtorArgumentNullException5 ()
  94                 {
  95                         BinaryReader r = null;
  96                         try {
  97                                 r = new BinaryReader ((Stream) null, Encoding.UTF8);
  98                         } finally {
  99                                 if (r != null)
 100                                         r.Close ();
 101                         }
 102                 }
 103
 104                 [Test]
 105                 [ExpectedException(typeof(ArgumentNullException))]
 106                 public void CtorArgumentNullException6 ()
 107                 {
 108                         byte [] b = new byte [30];
 109                         MemoryStream m = new MemoryStream (b);
 110                         BinaryReader r = null;
 111                         try {
 112                                 r = new BinaryReader (m, (Encoding) null);
 113                         } finally {
 114                                 m.Close ();
 115                                 if (r != null)
 116                                         r.Close ();
 117                         }
 118                 }
 119
 120                 [Test]
 121                 [ExpectedException(typeof(ArgumentException))]
 122                 public void CtorArgumentException ()
 123                 {
 124                         FileStream f = null;
 125                         BinaryReader r = null;
 126                         try {
 127                                 f = new FileStream (_codeFileName, FileMode.Open, FileAccess.Write);
 128                                 r = new BinaryReader (f);
 129                         } finally {
 130                                 if (r != null)
 131                                         r.Close ();
 132                                 if (f != null)
 133                                         f.Close ();
 134                         }
 135                 }
 136
 137                 [Test]
 138                 public void Ctor1()
 139                 {
 140                         FileStream f = null;
 141                         BinaryReader r = null;
 142                         try {
 143                                 f = new FileStream (_codeFileName,
 144                                                         FileMode.Open,
 145                                                         FileAccess.Read);
 146                                 r = new BinaryReader (f);
 147                                 Assert.IsNotNull (r, "#03 no binary reader created");
 148                         } finally {
 149                                 if (r != null)
 150                                         r.Close ();
 151                                 if (f != null)
 152                                         f.Close ();
 153                         }
 154                 }
 155
 156                 //TODO: (TestCtor*) Verify the Use of a wrong Stream
 157                 //TODO: (TestClose*) Verify the Close Method
 158                 [Test]
 159                 public void Close1 ()
 160                 {
 161                         byte [] b = new byte [30];
 162                         MemoryStream m = new MemoryStream (b);
 163                         BinaryReader r = null;
 164                         try {
 165                                 r = new BinaryReader (m);
 166                         } finally {
 167                                 r.Close ();
 168                                 m.Close ();
 169                         }
 170                 }
 171
 172                 //TODO: (TestRead*) Verify Read Method
 173                 [Test]
 174                 public void TestReadBoolean ()
 175                 {
 176                         bool [] a = {true, true, false};
 177                         byte [] arr_a = new byte [3];
 178                         int i = 0;
 179                         foreach (bool a1 in a) {
 180                                   arr_a [i] = Convert.ToByte (a1);
 181                                   i++;
 182                         }
 183
 184                         bool b;
 185                         MemoryStream m = new MemoryStream (arr_a);
 186                         BinaryReader r = null;
 187                         try {
 188                                 r = new BinaryReader (m);
 189                                 b = r.ReadBoolean ();
 190                                 Assert.AreEqual (a [0], b, "#11 No well readed boolean: ");
 191                         } finally {
 192                                 if (r != null)
 193                                         r.Close ();
 194                                 m.Close ();
 195                         }
 196                 }
 197
 198                 [Test]
 199                 public void TestReadByte ()
 200                 {
 201                         byte [] a = {0, 2, 3, 1, 5, 2};
 202                         byte b;
 203                         MemoryStream m = new MemoryStream (a);
 204                         BinaryReader r = null;
 205                         try {
 206                                 r = new BinaryReader (m);
 207                                 b = r.ReadByte ();
 208                                 Assert.AreEqual (a [0], b, "#13 No well readed byte: ");
 209                         } finally {
 210                                 if (r != null)
 211                                         r.Close ();
 212                                 m.Close ();
 213                         }
 214                 }
 215
 216                 [Test]
 217                 public void TestReadChar()
 218                 {
 219                         char [] a = {'a','b','c','d','e'};
 220                         byte [] arr_a = new byte [5];
 221                         int i = 0;
 222                         char c;
 223
 224                         foreach (char a1 in a) {
 225                            arr_a [i] = Convert.ToByte (a1);
 226                            i++;
 227                         }
 228
 229                         MemoryStream m = null;
 230                         BinaryReader r = null;
 231                         try {
 232                                 m = new MemoryStream (arr_a);
 233                                 r = new BinaryReader (m);
 234                                 c = r.ReadChar ();
 235                                 Assert.AreEqual (a [0], c, "#15 No well readed Char");
 236                         } finally  {
 237                                 r.Close ();
 238                                 m.Close ();
 239                         }
 240                 }
 241
 242                 [Test]
 243                 public void TestReadInt32 () //Uses BinaryWriter!!
 244                 {
 245                         int [] arr_int = {1,10,200,3000,40000,500000,6000000};
 246                         byte [] arr_byte = new byte [28]; //Sizeof arr_int * 4
 247                         int [] arr_int2 = new int [7];
 248                         int i;
 249
 250                         MemoryStream mem_stream = null;
 251                         BinaryWriter bin_writer = null;
 252                         try {
 253                                 mem_stream = new MemoryStream (arr_byte);
 254                                 bin_writer = new BinaryWriter (mem_stream);
 255                                 foreach (int elem in arr_int)   {
 256                                         bin_writer.Write(elem);
 257                                 }
 258
 259                                 mem_stream.Seek(0,SeekOrigin.Begin);
 260                                 BinaryReader bin_reader = new BinaryReader (mem_stream);
 261                                 bin_reader.BaseStream.Seek(0,SeekOrigin.Begin);
 262
 263                                 for (i=0;i<7;i++) {
 264                                         try{
 265                                                 arr_int2 [i] = bin_reader.ReadInt32();
 266                                                 Assert.AreEqual (arr_int [i], arr_int2 [i], "#2E Wrong Readed Int32 in iteration "+ i);
 267                                         } catch (IOException e) {
 268                                                 Assert.Fail ("#2F Unexpected IO Exception" + e.ToString());
 269                                         }
 270                                 }
 271                         } finally {
 272                                 bin_writer.Close ();
 273                                 mem_stream.Close ();
 274                         }
 275                 }
 276
 277
 278                 //-TODO: (TestRead[Type]*) Verify the ReadBoolean, ReadByte ....
 279                 // ReadBoolean, ReadByte, ReadChar, ReadInt32 Done
 280
 281                 //TODO: (TestFillBuffer*) Verify the FillBuffer Method
 282                 [Test]
 283                 public void TestPeekChar ()
 284                 {
 285                         char char1, char2;
 286                         char [] b = {'A', 'B', 'C'};
 287                         byte [] arr_b = new byte [3];
 288                         int i = 0;
 289
 290                         foreach (char b1 in b) {
 291                                 arr_b [i] = Convert.ToByte (b1);
 292                                 i++;
 293                         }
 294
 295                         MemoryStream m = null;
 296                         BinaryReader r = null;
 297
 298                         try {
 299                                 m = new MemoryStream (arr_b);
 300                                 r = new BinaryReader (m);
 301                                 char1 = (char) r.PeekChar ();
 302                                 char2 = (char) r.PeekChar ();
 303                                 Assert.AreEqual (char1, char2, "#20 the stream pointer have been altered in peek");
 304                         } finally {
 305                                 r.Close ();
 306                                 m.Close ();
 307                         }
 308                 }
 309
 310                 [Test]
 311                 public void TestBaseSeek1 ()
 312                 {
 313                         char char1, char2;
 314                         char [] b = {'A','B','C','D','E','F'};
 315                         byte [] arr_b = new byte[6];
 316                         int i = 0;
 317                         foreach (char b1 in b) {
 318                                 arr_b [i] = Convert.ToByte (b1);
 319                                 i++;
 320                         }
 321
 322                         MemoryStream m = null;
 323                         BinaryReader r = null;
 324                         try {
 325                                 m = new MemoryStream (arr_b);
 326                                 r = new BinaryReader (m);
 327                                 char1 = (char) r.PeekChar ();
 328                                 r.BaseStream.Seek (0,SeekOrigin.Current);
 329                                 char2 = (char) r.PeekChar ();
 330                                 Assert.AreEqual (char1, char2, "#22 the stream Has been altered in Seek");
 331                         } finally {
 332                                 r.Close ();
 333                                 m.Close ();
 334                         }
 335                 }
 336
 337                 [Test]
 338                 public void TestBaseSeek2 ()
 339                 {
 340                         char char1, char2;
 341                         char [] b = {'A','B','C','D','E','F'};
 342                         byte [] arr_b = new byte[6];
 343                         int i = 0;
 344                         foreach (char b1 in b) {
 345                                 arr_b [i] = Convert.ToByte (b1);
 346                                 i++;
 347                         }
 348
 349                         MemoryStream m = null;
 350                         BinaryReader r = null;
 351                         try {
 352                                 m = new MemoryStream (arr_b);
 353                                 r = new BinaryReader (m);
 354                                 char1 = (char) r.PeekChar ();
 355                                 r.BaseStream.Seek (3,SeekOrigin.Current);
 356                                 r.BaseStream.Seek (-3,SeekOrigin.Current);
 357                                 char2 = (char) r.PeekChar ();
 358                                 Assert.AreEqual (char1, char2, "#24 the stream Has been altered in Seek");
 359                         } finally {
 360                                 r.Close ();
 361                                 m.Close ();
 362                         }
 363                 }
 364
 365                 [Test]
 366                 public void TestInterleavedSeek1 ()
 367                 {
 368                         byte int1;
 369                         byte [] arr_byte = {0,1,2,3,4,5,6,7,8,9};
 370
 371                         MemoryStream m = null;
 372                         BinaryReader r = null;
 373
 374                         try {
 375                                 m = new MemoryStream (arr_byte);
 376                                 r = new BinaryReader (m);
 377                                 {
 378                                 try {
 379                                         int1 = r.ReadByte();
 380                                         Assert.AreEqual (int1, arr_byte[0], "#26 Not well readed Byte");
 381                                 } catch (Exception e) {
 382                                 Assert.Fail ("#27 Unexpected exception thrown: " + e.ToString ());
 383                                 }
 384                                 }
 385                                 {
 386                                 try {
 387                                         r.BaseStream.Seek(-1,SeekOrigin.End);
 388                                         int1 = r.ReadByte();
 389                                         Assert.AreEqual (int1, arr_byte[9], "#28 Not well readed Byte");
 390                                 } catch (Exception e) {
 391                                 Assert.Fail ("#29 Unexpected exception thrown: " + e.ToString ());
 392                                 }
 393                                 }
 394                                 {
 395                                 try {
 396                                         r.BaseStream.Seek(3,SeekOrigin.Begin);
 397                                         int1 = r.ReadByte();
 398                                         Assert.AreEqual (int1, arr_byte[3], "#2A Not well readed Byte");
 399                                 } catch (Exception e) {
 400                                         Assert.Fail ("#2B Unexpected exception thrown: " + e.ToString ());
 401                                 }
 402                                 }
 403                                 {
 404                                 try {
 405                                         r.BaseStream.Seek(2,SeekOrigin.Current);
 406                                         int1 = r.ReadByte();
 407                                         Assert.AreEqual (int1, arr_byte [6], "#2C Not well readed Int32");
 408                                 } catch (Exception e) {
 409                                 Assert.Fail ("#2D Unexpected exception thrown: " + e.ToString ());
 410                                 }
 411                                 }
 412                         } finally {
 413                                 r.Close ();
 414                                 m.Close ();
 415                         }
 416
 417                 }
 418
 419         /// <summary>
 420         /// Throws an exception if stream is null
 421         /// </summary>
 422         [Test]
 423         [ExpectedException(typeof(ArgumentNullException))]
 424         public void CtorNullExceptionStream ()
 425         {
 426                 BinaryReader reader = null;
 427                 try {
 428                         reader = new BinaryReader (null);
 429                 } finally {
 430                         if (reader != null)
 431                                 reader.Close ();
 432                 }
 433         }
 434
 435         /// <summary>
 436         /// Throws an exception if encoding is null
 437         /// </summary>
 438         [Test]
 439         [ExpectedException(typeof(ArgumentNullException))]
 440         public void CtorNullExceptionEncoding ()
 441         {
 442                 MemoryStream stream = null;
 443                 BinaryReader reader = null;
 444
 445                 try {
 446                         stream = new MemoryStream (64);
 447                         reader = new BinaryReader (stream, null);
 448                 } finally {
 449                         if (reader != null)
 450                                 reader.Close ();
 451                         if (stream != null)
 452                                 stream.Close ();
 453                 }
 454         }
 455
 456         /// <summary>
 457         /// Throws an exception if stream does not support writing
 458         /// </summary>
 459         [Test]
 460         [ExpectedException(typeof(ArgumentException))]
 461         public void CtorArgumentExceptionCannotWrite ()
 462         {
 463                 string path = TempFolder + "/BinaryReaderTestFile.1";
 464                 DeleteFile (path);
 465                 FileStream file = null;
 466                 BinaryReader breader = null;
 467
 468                 try {
 469                         file = new FileStream (path, FileMode.CreateNew, FileAccess.Read);
 470                         breader = new BinaryReader (file);
 471                 } finally {
 472                         if (breader != null)
 473                                 breader.Close ();
 474                         if (file != null)
 475                                 file.Close ();
 476                         DeleteFile (path);
 477                 }
 478         }
 479
 480         /// <summary>
 481         /// Throws an exception if stream is already closed
 482         /// </summary>
 483         [Test]
 484         [ExpectedException(typeof(ArgumentException))]
 485         public void CtorArgumentExceptionClosedStream ()
 486         {
 487                 string path = TempFolder + "/BinaryReaderTestFile.2";
 488                 DeleteFile (path);
 489                 FileStream file = null;
 490                 BinaryReader breader = null;
 491                 try {
 492                         file = new FileStream (path, FileMode.CreateNew, FileAccess.Write);
 493                         file.Close ();
 494                         breader = new BinaryReader (file);
 495                 } finally {
 496
 497                         if (breader != null)
 498                                 breader.Close ();
 499
 500                         if (file != null)
 501                                 file.Close ();
 502                         DeleteFile (path);
 503                 }
 504         }
 505
 506         /// <summary>
 507         /// Throws an exception if stream is closed
 508         /// </summary>
 509         [Test]
 510         [ExpectedException(typeof(ArgumentException))]
 511         public void CtorArgumentExceptionEncoding ()
 512         {
 513                 MemoryStream stream = null;
 514                 BinaryReader reader = null;
 515
 516                 try {
 517                         stream = new MemoryStream (64);
 518                         stream.Close ();
 519
 520                         reader = new BinaryReader (stream, new ASCIIEncoding ());
 521                 } finally {
 522                         if (reader != null)
 523                                 reader.Close ();
 524                         if (stream != null)
 525                                 stream.Close ();
 526                 }
 527
 528         }
 529
 530         /// <summary>
 531         /// Tests read () method
 532         /// </summary>
 533         [Test]
 534         public void Read ()
 535         {
 536                 byte [] bytes = new byte [] {0, 1, 2, 3};
 537                 MemoryStream stream = null;
 538                 BinaryReader reader = null;
 539
 540                 try {
 541                         stream = new MemoryStream (bytes);
 542                         reader = new BinaryReader (stream);
 543
 544                         Assert.AreEqual (0, reader.Read (), "test#01");
 545                         Assert.AreEqual (1, reader.Read (), "test#02");
 546                         Assert.AreEqual (2, reader.Read (), "test#03");
 547                         Assert.AreEqual (3, reader.Read (), "test#04");
 548                         Assert.AreEqual (-1, reader.Read (), "test#05");
 549                 } finally {
 550                         reader.Close ();
 551                         stream.Close ();
 552                 }
 553         }
 554
 555         [Test]
 556         [ExpectedException (typeof (ArgumentNullException))]
 557         public void Read_Bytes_BufferNull ()
 558         {
 559                 byte[] b = null;
 560                 new BinaryReader (new MemoryStream ()).Read (b, 0, 1);
 561         }
 562
 563         [Test]
 564         [ExpectedException (typeof (ArgumentOutOfRangeException))]
 565         public void Read_Bytes_IndexNegative ()
 566         {
 567                 byte[] array = new byte [8];
 568                 new BinaryReader (new MemoryStream ()).Read (array, -1, array.Length);
 569         }
 570
 571         [Test]
 572         [ExpectedException (typeof (ArgumentException))]
 573         public void Read_Bytes_IndexOverflow ()
 574         {
 575                 byte[] array = new byte [8];
 576                 new BinaryReader (new MemoryStream ()).Read (array, Int32.MaxValue, array.Length);
 577         }
 578
 579         [Test]
 580         [ExpectedException (typeof (ArgumentOutOfRangeException))]
 581         public void Read_Bytes_CountNegative ()
 582         {
 583                 byte[] array = new byte [8];
 584                 new BinaryReader (new MemoryStream ()).Read (array, 0, -1);
 585         }
 586
 587         [Test]
 588         [ExpectedException (typeof (ArgumentException))]
 589         public void Read_Bytes_CountOverflow ()
 590         {
 591                 byte[] array = new byte [8];
 592                 new BinaryReader (new MemoryStream ()).Read (array, 0, Int32.MaxValue);
 593         }
 594
 595         [Test]
 596         [ExpectedException (typeof (ArgumentNullException))]
 597         public void Read_Chars_BufferNull ()
 598         {
 599                 char[] c = null;
 600                 new BinaryReader (new MemoryStream ()).Read (c, 0, 1);
 601         }
 602
 603         [Test]
 604         [ExpectedException (typeof (ArgumentOutOfRangeException))]
 605         public void Read_Chars_IndexNegative ()
 606         {
 607                 char[] array = new char [8];
 608                 new BinaryReader (new MemoryStream ()).Read (array, -1, array.Length);
 609         }
 610
 611         [Test]
 612         [ExpectedException (typeof (ArgumentException))]
 613         public void Read_Chars_IndexOverflow ()
 614         {
 615                 char[] array = new char [8];
 616                 new BinaryReader (new MemoryStream ()).Read (array, Int32.MaxValue, array.Length);
 617         }
 618
 619         [Test]
 620         [ExpectedException (typeof (ArgumentOutOfRangeException))]
 621         public void Read_Chars_CountNegative ()
 622         {
 623                 char[] array = new char [8];
 624                 new BinaryReader (new MemoryStream ()).Read (array, 0, -1);
 625         }
 626
 627         [Test]
 628         [ExpectedException (typeof (ArgumentException))]
 629         public void Read_Chars_CountOverflow ()
 630         {
 631                 char[] array = new char [8];
 632                 new BinaryReader (new MemoryStream ()).Read (array, 0, Int32.MaxValue);
 633         }
 634
 635         [Test]
 636         public void PeakChar ()
 637         {
 638                 byte [] bytes = new byte [] {0, 1, 2, 3};
 639                 MemoryStream stream = null;
 640                 BinaryReader reader = null;
 641
 642                 try {
 643                         stream = new MemoryStream (bytes);
 644                         reader = new BinaryReader (stream);
 645
 646                         Assert.AreEqual (0, reader.PeekChar (), "test#01");
 647                         Assert.AreEqual (0, reader.PeekChar (), "test#02");
 648                         Assert.AreEqual (0, reader.Read (), "test#03");
 649                         Assert.AreEqual (1, reader.Read (), "test#03");
 650                         Assert.AreEqual (2, reader.PeekChar (), "test#03");
 651                 } finally {
 652                         reader.Close ();
 653                         stream.Close ();
 654                 }
 655         }
 656
 657         [Test]
 658         [ExpectedException(typeof(ObjectDisposedException))]
 659         public void CloseRead ()
 660         {
 661                 byte [] bytes = new byte [] {0, 1, 2, 3};
 662                 MemoryStream stream = null;
 663                 BinaryReader reader = null;
 664
 665                 try {
 666                         stream = new MemoryStream (bytes);
 667                         reader = new BinaryReader (stream);
 668                         reader.Close ();
 669                         reader.Read ();
 670                 } finally {
 671                         reader.Close ();
 672                         stream.Close ();
 673                 }
 674         }
 675
 676         [Test]
 677         [ExpectedException(typeof(ObjectDisposedException))]
 678         public void ClosePeakChar ()
 679         {
 680                 byte [] bytes = new byte [] {0, 1, 2, 3};
 681                 MemoryStream stream = null;
 682                 BinaryReader reader = null;
 683
 684                 try {
 685                         stream = new MemoryStream (bytes);
 686                         reader = new BinaryReader (stream);
 687                         reader.Close ();
 688                         reader.PeekChar ();
 689                 } finally {
 690                         reader.Close ();
 691                         stream.Close ();
 692                 }
 693         }
 694
 695         [Test]
 696         [ExpectedException(typeof(ObjectDisposedException))]
 697         public void CloseReadBytes ()
 698         {
 699                 byte [] bytes = new byte [] {0, 1, 2, 3};
 700                 MemoryStream stream = null;
 701                 BinaryReader reader = null;
 702
 703                 try {
 704                         stream = new MemoryStream (bytes);
 705                         reader = new BinaryReader (stream);
 706                         reader.Close ();
 707                         reader.ReadBytes (1);
 708                 } finally {
 709                         reader.Close ();
 710                         stream.Close ();
 711                 }
 712         }
 713
 714         [Test]
 715         public void BaseStream ()
 716         {
 717                 byte [] bytes = new byte [] {0, 1, 2, 3};
 718                 MemoryStream stream = null;
 719                 BinaryReader reader = null;
 720
 721                 try {
 722                         stream = new MemoryStream (bytes);
 723                         reader = new BinaryReader (stream);
 724
 725                         Assert.AreEqual (4, reader.BaseStream.Length, "test#01");
 726                         Assert.AreEqual (true, reader.BaseStream.CanRead, "test#02");
 727                         reader.Close ();
 728                         Assert.AreEqual (null, reader.BaseStream, "test#03");
 729                 } finally {
 730                         reader.Close ();
 731                         stream.Close ();
 732                 }
 733         }
 734
 735
 736         /// <summary>
 737         /// Tests read (byte [], int, int) method
 738         /// </summary>
 739         [Test]
 740         public void ReadByteArray ()
 741         {
 742                 byte [] bytes = new byte [] {0, 1, 2, 3, 4, 5};
 743                 MemoryStream stream = null;
 744                 BinaryReader reader = null;
 745                 try {
 746
 747                         stream = new MemoryStream (bytes);
 748                         reader = new BinaryReader (stream);
 749
 750                         bytes = new byte [3];
 751                         reader.Read (bytes, 0, 3);
 752                         Assert.AreEqual (0, bytes [0], "test#01");
 753                         Assert.AreEqual (1, bytes [1], "test#02");
 754                         Assert.AreEqual (2, bytes [2], "test#03");
 755
 756                         bytes = new byte [6];
 757                         reader.Read (bytes, 3, 3);
 758                         Assert.AreEqual (0, bytes [0], "test#04");
 759                         Assert.AreEqual (0, bytes [1], "test#05");
 760                         Assert.AreEqual (0, bytes [2], "test#06");
 761                         Assert.AreEqual (3, bytes [3], "test#07");
 762                         Assert.AreEqual (4, bytes [4], "test#08");
 763                         Assert.AreEqual (5, bytes [5], "test#09");
 764
 765                         bytes = new byte [2];
 766                         reader.Read (bytes, 0, 2);
 767                         Assert.AreEqual (0, bytes [0], "test#10");
 768                         Assert.AreEqual (0, bytes [1], "test#11");
 769                 } finally {
 770                         reader.Close ();
 771                         stream.Close ();
 772                 }
 773         }
 774
 775         /// <summary>
 776         /// Test Read (char [], int, int)
 777         /// </summary>
 778         [Test]
 779         public void ReadCharArray ()
 780         {
 781
 782                 MemoryStream stream = null;
 783                 BinaryReader reader = null;
 784                 try {
 785                         stream = new MemoryStream (new byte [] {109, 111, 110, 111, 58, 58});
 786                         reader = new BinaryReader (stream);
 787                         char [] chars = new char [3];
 788                         reader.Read (chars, 0, 3);
 789                         Assert.AreEqual ('m', chars [0], "test#01");
 790                         Assert.AreEqual ('o', chars [1], "test#02");
 791                         Assert.AreEqual ('n', chars [2], "test#03");
 792
 793                         chars = new char [6];
 794                         reader.Read (chars, 3, 3);
 795                         Assert.AreEqual (0, chars [0], "test#04");
 796                         Assert.AreEqual (0, chars [1], "test#05");
 797                         Assert.AreEqual (0, chars [2], "test#06");
 798                         Assert.AreEqual ('o', chars [3], "test#07");
 799                         Assert.AreEqual (':', chars [4], "test#08");
 800                         Assert.AreEqual (':', chars [5], "test#09");
 801
 802                         chars = new char [2];
 803                         reader.Read (chars, 0, 2);
 804                         Assert.AreEqual (0, chars [0], "test#08");
 805                         Assert.AreEqual (0, chars [1], "test#09");
 806                 } finally {
 807                         reader.Close ();
 808                         stream.Close ();
 809                 }
 810
 811         }
 812
 813         /// <summary>
 814         /// Test ReadBoolean () method.
 815         /// </summary>
 816         [Test]
 817         public void ReadBoolean ()
 818         {
 819                 MemoryStream stream = null;
 820                 BinaryReader reader = null;
 821                 try {
 822                         stream = new MemoryStream (new byte [] {0, 1, 99, 0, 13});
 823                         reader = new BinaryReader (stream);
 824                         Assert.AreEqual (false, reader.ReadBoolean (), "test#01");
 825                         Assert.AreEqual (true, reader.ReadBoolean (), "test#02");
 826                         Assert.AreEqual (true, reader.ReadBoolean (), "test#03");
 827                         Assert.AreEqual (false, reader.ReadBoolean (), "test#04");
 828                         Assert.AreEqual (true, reader.ReadBoolean (), "test#05");
 829                 } finally {
 830                         reader.Close ();
 831                         stream.Close ();
 832                 }
 833         }
 834
 835         /// <summary>
 836         /// Test ReadBoolean () method exceptions.
 837         /// </summary>
 838         [Test]
 839         [ExpectedException(typeof(EndOfStreamException))]
 840         public void ReadBooleanException ()
 841         {
 842                 MemoryStream stream = null;
 843                 BinaryReader reader = null;
 844                 try {
 845                         stream = new MemoryStream (new byte [] {0, 1});
 846                         reader = new BinaryReader (stream);
 847                         reader.ReadBoolean ();
 848                         reader.ReadBoolean ();
 849                         reader.ReadBoolean ();
 850                 } finally {
 851                         reader.Close ();
 852                         stream.Close ();
 853                 }
 854         }
 855
 856         /// <summary>
 857         /// Test ReadByte () method.
 858         /// </summary>
 859         [Test]
 860         public void ReadByte ()
 861         {
 862                 MemoryStream stream = null;
 863                 BinaryReader reader = null;
 864
 865                 try {
 866                         stream = new MemoryStream (new byte [] {0, 1, 99, 0, 13});
 867                         reader = new BinaryReader (stream);
 868
 869                         Assert.AreEqual (0, reader.ReadByte (), "test#01");
 870                         Assert.AreEqual (1, reader.ReadByte (), "test#02");
 871                         Assert.AreEqual (99, reader.ReadByte (), "test#03");
 872                         Assert.AreEqual (0, reader.ReadByte (), "test#04");
 873                         Assert.AreEqual (13, reader.ReadByte (), "test#05");
 874                 } finally {
 875                         reader.Close ();
 876                         stream.Close ();
 877                 }
 878         }
 879
 880         /// <summary>
 881         /// Test ReadByte () method exceptions.
 882         /// </summary>
 883         [Test]
 884         [ExpectedException(typeof(EndOfStreamException))]
 885         public void ReadByteException ()
 886         {
 887                 MemoryStream stream = null;
 888                 BinaryReader reader = null;
 889
 890                 try {
 891                         stream = new MemoryStream (new byte [] {0, 1});
 892                         reader = new BinaryReader (stream);
 893                         reader.ReadByte ();
 894                         reader.ReadByte ();
 895                         reader.ReadByte ();
 896                 } finally {
 897                         reader.Close ();
 898                         stream.Close ();
 899                 }
 900         }
 901
 902         /// <summary>
 903         /// Test ReadBytes (int) method.
 904         /// </summary>
 905         [Test]
 906         public void ReadBytes ()
 907         {
 908                 MemoryStream stream = null;
 909                 BinaryReader reader = null;
 910
 911                 try {
 912                         stream = new MemoryStream (new byte [] {0, 1, 99, 0, 13});
 913                         reader = new BinaryReader (stream);
 914
 915                         byte [] bytes = reader.ReadBytes (2);
 916                         Assert.AreEqual (0, bytes [0], "test#01");
 917                         Assert.AreEqual (1, bytes [1], "test#02");
 918
 919                         bytes = reader.ReadBytes (2);
 920                         Assert.AreEqual (99, bytes [0], "test#03");
 921                         Assert.AreEqual (0, bytes [1], "test#04");
 922
 923                         bytes = reader.ReadBytes (2);
 924                         Assert.AreEqual (13, bytes [0], "test#05");
 925                         Assert.AreEqual (1, bytes.Length, "test#06");
 926
 927                 } finally {
 928                         reader.Close ();
 929                         stream.Close ();
 930                 }
 931         }
 932
 933         /// <summary>
 934         /// Test ReadBytes (int) method exception.
 935         /// </summary>
 936         [Test]
 937         [ExpectedException(typeof(ArgumentOutOfRangeException))]
 938         public void ReadBytesException ()
 939         {
 940                 MemoryStream stream = null;
 941                 BinaryReader reader = null;
 942
 943                 try {
 944                         stream = new MemoryStream (new byte [] {0, 1, 99, 0, 13});
 945                         reader = new BinaryReader (stream);
 946                         reader.ReadBytes (-1);
 947                 } finally {
 948                         reader.Close ();
 949                         stream.Close ();
 950                 }
 951         }
 952
 953         /// <summary>
 954         /// Test ReadChar () method.
 955         /// </summary>
 956         [Test]
 957         public void ReadChar ()
 958         {
 959                 MemoryStream stream = null;
 960                 BinaryReader reader = null;
 961                 try {
 962                         stream = new MemoryStream (new byte [] {0, 1, 99, 0, 13});
 963                         reader = new BinaryReader (stream);
 964
 965                         Assert.AreEqual (0, reader.ReadChar (), "test#01");
 966                         Assert.AreEqual (1, reader.ReadChar (), "test#02");
 967                         Assert.AreEqual (99, reader.ReadChar (), "test#03");
 968                         Assert.AreEqual (0, reader.ReadChar (), "test#04");
 969                         Assert.AreEqual (13, reader.ReadChar (), "test#05");
 970                 } finally {
 971                         reader.Close ();
 972                         stream.Close ();
 973                 }
 974         }
 975
 976         /// <summary>
 977         /// Test ReadChar () method exception.
 978         /// </summary>
 979         [Test]
 980         [ExpectedException(typeof(EndOfStreamException))]
 981         public void ReadCharException ()
 982         {
 983                 MemoryStream stream = null;
 984                 BinaryReader reader = null;
 985
 986                 try {
 987                         stream = new MemoryStream (new byte [] {0, 1});
 988                         reader = new BinaryReader (stream);
 989                         reader.ReadChar ();
 990                         reader.ReadChar ();
 991                         reader.ReadChar ();
 992                 } finally {
 993                         reader.Close ();
 994                         stream.Close ();
 995                 }
 996         }
 997
 998         /// <summary>
 999         /// Test ReadChars (int) method.
1000         /// </summary>
1001         [Test]
1002         public void ReadChars ()
1003         {
1004                 MemoryStream stream = null;
1005                 BinaryReader reader = null;
1006                 try {
1007                         stream = new MemoryStream (new byte [] {0, 1, 99, 0, 13});
1008                         reader = new BinaryReader (stream);
1009                         char [] chars = reader.ReadChars (2);
1010                         Assert.AreEqual (0, chars [0], "test#01");
1011                         Assert.AreEqual (1, chars [1], "test#02");
1012
1013                         chars = reader.ReadChars (2);
1014                         Assert.AreEqual (99, chars [0], "test#03");
1015                         Assert.AreEqual (0, chars [1], "test#04");
1016
1017                         chars = reader.ReadChars (2);
1018                         Assert.AreEqual (13, chars [0], "test#05");
1019                         Assert.AreEqual (1, chars.Length, "test#06");
1020                 } finally {
1021                         reader.Close ();
1022                         stream.Close ();
1023                 }
1024         }
1025
1026         /// <summary>
1027         /// Test ReadChars (int value) exceptions. If value is negative exception is thrown
1028         /// </summary>
1029         [Test]
1030         [ExpectedException(typeof(ArgumentOutOfRangeException))]
1031         public void ReadCharsException ()
1032         {
1033                 MemoryStream stream = null;
1034                 BinaryReader reader = null;
1035                 try {
1036                         stream = new MemoryStream (new byte [] {0, 1, 99, 0, 13});
1037                         reader = new BinaryReader (stream);
1038                         reader.ReadChars (-1);
1039                 } finally {
1040                         reader.Close ();
1041                         stream.Close ();
1042                 }
1043         }
1044
1045
1046         /// <summary>
1047         /// Test ReadDecimal () method.
1048         /// </summary>
1049         [Test]
1050         public void ReadDecimal ()
1051         {
1052                 MemoryStream stream = null;
1053                 BinaryReader reader = null;
1054                 try {
1055                         stream = new MemoryStream (new byte [] {0, 0, 0, 0, 0, 0, 65, 0, 0, 0, 0, 0, 0, 0, 0 ,128, 0, 0, 0, 0, 0});
1056                         reader = new BinaryReader (stream);
1057                         Assert.AreEqual (-18295873486192640, reader.ReadDecimal (), "test#01");
1058                 } finally {
1059                         reader.Close ();
1060                         stream.Close ();
1061                 }
1062         }
1063
1064         [Test]
1065         [ExpectedException(typeof(EndOfStreamException))]
1066         public void ReadDecimalException ()
1067         {
1068                 MemoryStream stream = new MemoryStream (new byte [] {0, 0, 0, 0, 0, 0, 65, 0, 0, 0, 0, 0, 0, 0, 0 ,87, 98, 0, 0, 0, 0, 0});
1069                 BinaryReader reader = new BinaryReader (stream);
1070                 try {
1071                         reader.ReadDecimal ();
1072                         reader.ReadDecimal ();
1073                 } finally {
1074                         reader.Close ();
1075                         stream.Close ();
1076                 }
1077         }
1078
1079         [Test]
1080         public void ReadDouble ()
1081         {
1082                 MemoryStream stream = new MemoryStream (new byte [] {0, 0, 0, 0, 0, 0, 65, 0, 0, 0, 0, 0, 0, 0, 0 ,87, 98, 0, 0, 0, 0});
1083                 BinaryReader reader = new BinaryReader (stream);
1084                 try {
1085                         Assert.AreEqual (1.8913127797311212E-307d, reader.ReadDouble (), "test#01");
1086                         Assert.AreEqual (1.2024538023802026E+111d, reader.ReadDouble (), "test#02");
1087                 } finally {
1088                         reader.Close ();
1089                         stream.Close ();
1090                 }
1091         }
1092
1093         [Test]
1094         [ExpectedException(typeof(EndOfStreamException))]
1095         public void ReadDoubleException ()
1096         {
1097                 MemoryStream stream = new MemoryStream (new byte [] {0, 0, 0, 0, 0, 0, 65, 0, 0, 0, 0, 0, 0, 0, 0 ,87, 98, 0, 0, 0, 0});
1098                 BinaryReader reader = new BinaryReader (stream);
1099                 try {
1100                         reader.ReadDouble ();
1101                         reader.ReadDouble ();
1102                         reader.ReadDouble ();
1103                 } finally {
1104                         reader.Close ();
1105                         stream.Close ();
1106                 }
1107         }
1108
1109         [Test]
1110         public void ReadInt16 ()
1111         {
1112                 MemoryStream stream = new MemoryStream (new byte [] {65, 1, 32, 43, 5, 3, 54, 0});
1113                 BinaryReader reader = new BinaryReader (stream);
1114                 try {
1115                         Assert.AreEqual (321, reader.ReadInt16 (), "test#01");
1116                         Assert.AreEqual (11040, reader.ReadInt16 (), "test#02");
1117                         Assert.AreEqual (773, reader.ReadInt16 (), "test#03");
1118                         Assert.AreEqual (54, reader.ReadInt16 (), "test#04");
1119                 } finally {
1120                         reader.Close ();
1121                         stream.Close ();
1122                 }
1123         }
1124
1125         [Test]
1126         [ExpectedException(typeof(EndOfStreamException))]
1127         public void ReadInt16Exception ()
1128         {
1129                 MemoryStream stream = new MemoryStream (new byte [] {65, 1});
1130                 BinaryReader reader = new BinaryReader (stream);
1131                 try {
1132                         reader.ReadInt16 ();
1133                         reader.ReadInt16 ();
1134                 } finally {
1135                         reader.Close ();
1136                         stream.Close ();
1137                 }
1138         }
1139
1140         [Test]
1141         public void ReadInt32 ()
1142         {
1143                 MemoryStream stream = new MemoryStream (new byte [] {65, 1, 32, 43, 5, 3, 54, 0});
1144                 BinaryReader reader = new BinaryReader (stream);
1145                 try {
1146                         Assert.AreEqual (723517761, reader.ReadInt32 (), "test#01");
1147                         Assert.AreEqual (3539717, reader.ReadInt32 (), "test#02");
1148                 } finally {
1149                         reader.Close ();
1150                         stream.Close ();
1151                 }
1152         }
1153
1154         [Test]
1155         [ExpectedException(typeof(EndOfStreamException))]
1156         public void ReadInt32Exception ()
1157         {
1158                 MemoryStream stream = new MemoryStream (new byte [] {65, 1, 32, 43});
1159                 BinaryReader reader = new BinaryReader (stream);
1160                 try {
1161                         reader.ReadInt32 ();
1162                         reader.ReadInt32 ();
1163                 } finally {
1164                         reader.Close ();
1165                         stream.Close ();
1166                 }
1167         }
1168
1169         [Test]
1170         public void ReadInt64 ()
1171         {
1172                 MemoryStream stream = new MemoryStream (new byte [] {65, 1, 32, 43, 5, 3, 54, 0, 34, 5, 7, 4, 23, 4, 76, 34, 76, 2, 6,45});
1173                 BinaryReader reader = new BinaryReader (stream);
1174                 try {
1175                         Assert.AreEqual (15202969475612993, reader.ReadInt64 (), "test#01");
1176                         Assert.AreEqual (2471354792417887522, reader.ReadInt64 (), "test#02");
1177                 } finally {
1178                         reader.Close ();
1179                         stream.Close ();
1180                 }
1181         }
1182
1183         [Test]
1184         [ExpectedException(typeof(EndOfStreamException))]
1185         public void ReadInt64Exception ()
1186         {
1187                 MemoryStream stream = new MemoryStream (new byte [] {65, 1, 32, 43, 5, 3, 54, 0, 34, 5, 7, 4, 23, 4, 76, 34, 76, 2, 6,45});
1188                 BinaryReader reader = new BinaryReader (stream);
1189
1190                 try {
1191                         reader.ReadInt64 ();
1192                         reader.ReadInt64 ();
1193                         reader.ReadInt64 ();
1194                 } finally {
1195                         reader.Close ();
1196                         stream.Close ();
1197                 }
1198         }
1199
1200         [Test]
1201         public void ReadSByte ()
1202         {
1203                 MemoryStream stream = new MemoryStream (new byte [] {65, 200, 32});
1204                 BinaryReader reader = new BinaryReader (stream);
1205
1206                 try {
1207                         Assert.AreEqual (65, reader.ReadSByte (), "test#01");
1208                         Assert.AreEqual (-56, reader.ReadSByte (), "test#02");
1209                         Assert.AreEqual (32, reader.ReadSByte (), "test#03");
1210                 } finally {
1211                         reader.Close ();
1212                         stream.Close ();
1213                 }
1214         }
1215
1216         [Test]
1217         [ExpectedException(typeof(EndOfStreamException))]
1218         public void ReadSByteException ()
1219         {
1220                 MemoryStream stream = new MemoryStream (new byte [] {65, 200});
1221                 BinaryReader reader = new BinaryReader (stream);
1222
1223                 try {
1224                         reader.ReadSByte ();
1225                         reader.ReadSByte ();
1226                         reader.ReadSByte ();
1227                 } finally {
1228                         reader.Close ();
1229                         stream.Close ();
1230                 }
1231         }
1232
1233         [Test]
1234         public void ReadSingle ()
1235         {
1236                 MemoryStream stream = new MemoryStream (new byte [] {65, 200, 0, 0, 0, 1, 2, 3, 4});
1237                 BinaryReader reader = new BinaryReader (stream);
1238                 try {
1239                         Assert.AreEqual (7.18375658E-41F, reader.ReadSingle (), "test#01");
1240                         Assert.AreEqual (3.82047143E-37F, reader.ReadSingle (), "test#02");
1241                 } finally {
1242                         reader.Close ();
1243                         stream.Close ();
1244                 }
1245         }
1246
1247         [Test]
1248         [ExpectedException(typeof(EndOfStreamException))]
1249         public void ReadSingleException ()
1250         {
1251                 MemoryStream stream = new MemoryStream (new byte [] {65, 200, 0, 0, 0, 1, 2, 3, 4});
1252                 BinaryReader reader = new BinaryReader (stream);
1253                 try {
1254                         reader.ReadSingle ();
1255                         reader.ReadSingle ();
1256                         reader.ReadSingle ();
1257                 } finally {
1258                         reader.Close ();
1259                         stream.Close ();
1260                 }
1261         }
1262
1263         [Test]
1264         public void ReadString ()
1265         {
1266                 MemoryStream stream = null;
1267                 BinaryReader reader = null;
1268                 try {
1269                         stream = new MemoryStream (new byte [] {6,109, 111, 110, 111, 58, 58});
1270                         reader = new BinaryReader (stream);
1271                         Assert.AreEqual ("mono::", reader.ReadString (), "test#01");
1272
1273                         stream = new MemoryStream (new byte [] {2,109, 111, 3, 111, 58, 58});
1274                         reader = new BinaryReader (stream);
1275                         Assert.AreEqual ("mo", reader.ReadString (), "test#02");
1276                         Assert.AreEqual ("o::", reader.ReadString (), "test#03");
1277                 } finally {
1278                         reader.Close ();
1279                         stream.Close ();
1280                 }
1281         }
1282
1283         [Test]
1284         public void ReadLongUTF8String ()
1285         {
1286                 // \u00A9 == (C)
1287                 string s = new String ('\u00A9', 100);
1288                 MemoryStream ms = new MemoryStream ();
1289                 BinaryWriter w = new BinaryWriter (ms);
1290                 w.Write (s);
1291                 w.Flush ();
1292                 ms.Position = 0;
1293                 BinaryReader r = new BinaryReader (ms);
1294                 Assert.AreEqual (s, r.ReadString ());
1295         }
1296
1297         [Test]
1298         [ExpectedException(typeof(EndOfStreamException))]
1299         public void ReadStringException ()
1300         {
1301                 MemoryStream stream = new MemoryStream (new byte [] {2,109, 111, 3, 111, 58, 58});
1302                 BinaryReader reader = new BinaryReader (stream);
1303
1304                 try {
1305                         reader.ReadString ();
1306                         reader.ReadString ();
1307                         reader.ReadString ();
1308                 } finally {
1309                         reader.Close ();
1310                         stream.Close ();
1311                 }
1312         }
1313
1314         [Test]
1315         [ExpectedException (typeof (FormatException))]
1316         public void ReadStringInvalidLength ()
1317         {
1318                 int count = 1000;
1319
1320                 byte[] x = new byte[count];
1321
1322                 for (int i = 0; i < count; i++)
1323                         x[i] = 0xFF;
1324
1325                 BinaryReader reader = new BinaryReader (new MemoryStream (x));
1326                 reader.ReadString ();
1327         }
1328
1329         [Test]
1330         public void ReadUInt16 ()
1331         {
1332                 MemoryStream stream = new MemoryStream (new byte [] {200, 200, 32, 43, 5, 3, 54, 0});
1333                 BinaryReader reader = new BinaryReader (stream);
1334
1335                 try {
1336                         Assert.AreEqual (51400, reader.ReadUInt16 (), "test#01");
1337                         Assert.AreEqual (11040, reader.ReadUInt16 (), "test#02");
1338                         Assert.AreEqual (773, reader.ReadUInt16 (), "test#03");
1339                         Assert.AreEqual (54, reader.ReadUInt16 (), "test#04");
1340                 } finally {
1341                         reader.Close ();
1342                         stream.Close ();
1343                 }
1344         }
1345
1346         [Test]
1347         [ExpectedException(typeof(EndOfStreamException))]
1348         public void ReadUInt16Exception ()
1349         {
1350                 MemoryStream stream = new MemoryStream (new byte [] {65, 1});
1351                 BinaryReader reader = new BinaryReader (stream);
1352                 try {
1353                         reader.ReadUInt16 ();
1354                         reader.ReadUInt16 ();
1355                 } finally {
1356                         reader.Close ();
1357                         stream.Close ();
1358                 }
1359         }
1360
1361         [Test]
1362         public void ReadUInt32 ()
1363         {
1364                 MemoryStream stream = new MemoryStream (new byte [] {65, 1, 32, 43, 5, 3, 54, 0});
1365                 BinaryReader reader = new BinaryReader (stream);
1366                 try {
1367                         Assert.AreEqual (723517761, reader.ReadUInt32 (), "test#01");
1368                         Assert.AreEqual (3539717, reader.ReadUInt32 (), "test#02");
1369                 } finally {
1370                         reader.Close ();
1371                         stream.Close ();
1372                 }
1373         }
1374
1375         [Test]
1376         [ExpectedException(typeof(EndOfStreamException))]
1377         public void ReadUInt32Exception ()
1378         {
1379                 MemoryStream stream = new MemoryStream (new byte [] {65, 1, 32, 43});
1380                 BinaryReader reader = new BinaryReader (stream);
1381
1382                 try {
1383                         reader.ReadUInt32 ();
1384                         reader.ReadUInt32 ();
1385                 } finally {
1386                         reader.Close ();
1387                         stream.Close ();
1388                 }
1389         }
1390
1391         [Test]
1392         public void ReadUInt64 ()
1393         {
1394                 MemoryStream stream = new MemoryStream (new byte [] {65, 1, 32, 43, 5, 3, 54, 0, 34, 5, 7, 4, 23, 4, 76, 34, 76, 2, 6,45});
1395                 BinaryReader reader = new BinaryReader (stream);
1396
1397                 try {
1398                         Assert.AreEqual (15202969475612993, reader.ReadUInt64 (), "test#01");
1399                         Assert.AreEqual (2471354792417887522, reader.ReadUInt64 (), "test#02");
1400                 } finally {
1401                         reader.Close ();
1402                         stream.Close ();
1403                 }
1404         }
1405
1406         [Test]
1407         public void Test_ReadZeroBytes ()
1408         {
1409                 MemoryStream stream = new MemoryStream (new byte [] {65, 1, 32, 43, 5, 3, 54, 0, 34, 5, 7, 4, 23, 4, 76, 34, 76, 2, 6,45});
1410                 BinaryReader reader = new BinaryReader (stream);
1411
1412                 char [] result = reader.ReadChars (0);
1413                 Assert.AreEqual (result.Length, 0, "ZERO_1");
1414         }
1415
1416         [Test]
1417         [ExpectedException(typeof(EndOfStreamException))]
1418         public void ReadUInt64Exception ()
1419         {
1420                 MemoryStream stream = new MemoryStream (new byte [] {65, 1, 32, 43, 5, 3, 54, 0, 34, 5, 7, 4, 23, 4, 76, 34, 76, 2, 6,45});
1421                 BinaryReader reader = new BinaryReader (stream);
1422
1423                 try {
1424                         reader.ReadUInt64 ();
1425                         reader.ReadUInt64 ();
1426                         reader.ReadUInt64 ();
1427                 } finally {
1428                         reader.Close ();
1429                         stream.Close ();
1430                 }
1431         }
1432
1433         private void DeleteFile (string path)
1434         {
1435                 if (File.Exists (path))
1436                         File.Delete (path);
1437         }
1438
1439         class MockBinaryReader : BinaryReader
1440         {
1441                 public int ReadCharsCounter;
1442                 public int ReadCounter;
1443
1444                 public MockBinaryReader (Stream input)
1445                         : base (input)
1446                 {
1447                 }
1448
1449                 public override char[] ReadChars (int count)
1450                 {
1451                         ++ReadCharsCounter;
1452                         return base.ReadChars (count);
1453                 }
1454
1455                 public override int Read (char[] buffer, int index, int count)
1456                 {
1457                         ++ReadCounter;
1458                         return base.Read (buffer, index, count);
1459                 }
1460         }
1461
1462         [Test]
1463         public void ReadOverrides ()
1464         {
1465                 var stream = new MemoryStream ();
1466
1467                 using (var writer = new BinaryWriter (stream)) {
1468                         writer.Write ("TEST");
1469                         stream.Seek (0, SeekOrigin.Begin);
1470
1471                         using (var reader = new MockBinaryReader (stream)) {
1472                                 var readChars = reader.ReadChars (4);
1473
1474                                 Assert.AreEqual (1, reader.ReadCharsCounter);
1475                                 Assert.AreEqual (0, reader.ReadCounter);
1476
1477                                 reader.Read (readChars, 0, 4);
1478                                 Assert.AreEqual (1, reader.ReadCharsCounter);
1479                                 Assert.AreEqual (1, reader.ReadCounter);
1480                         }
1481                 }
1482         }
1483 }
1484 }