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

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