namespace MonoTests.System.IO {
[TestFixture]
-public class BinaryWriterTest : Assertion {
-
+public class BinaryWriterTest {
+ sealed class MyBinaryWriter : BinaryWriter
+ {
+ public MyBinaryWriter (Stream stream)
+ : base (stream)
+ { }
+
+ public void WriteLeb128 (int value)
+ {
+ base.Write7BitEncodedInt (value);
+ }
+ }
string TempFolder = Path.Combine (Path.GetTempPath (), "MonoTests.System.IO.Tests");
{
MemoryStream stream = new MemoryStream ();
BinaryWriter writer = new BinaryWriter (stream);
- AssertEquals ("test#01", true, writer.BaseStream.CanRead);
- AssertEquals ("test#02", true, writer.BaseStream.CanSeek);
- AssertEquals ("test#03", true, writer.BaseStream.CanWrite);
+ Assert.AreEqual (true, writer.BaseStream.CanRead, "test#01");
+ Assert.AreEqual (true, writer.BaseStream.CanSeek, "test#02");
+ Assert.AreEqual (true, writer.BaseStream.CanWrite, "test#03");
writer = new BinaryWriter (stream, new ASCIIEncoding ());
- AssertEquals ("test#04", true, writer.BaseStream.CanRead);
- AssertEquals ("test#05", true, writer.BaseStream.CanSeek);
- AssertEquals ("test#06", true, writer.BaseStream.CanWrite);
+ Assert.AreEqual (true, writer.BaseStream.CanRead, "test#04");
+ Assert.AreEqual (true, writer.BaseStream.CanSeek, "test#05");
+ Assert.AreEqual (true, writer.BaseStream.CanWrite, "test#06");
}
writer.Write ("t*st");
byte [] bytes = stream.GetBuffer ();
- AssertEquals ("test#01", 4, bytes [0]);
- AssertEquals ("test#02", 116, bytes [1]);
- AssertEquals ("test#03", 42, bytes [2]);
- AssertEquals ("test#04", 115, bytes [3]);
- AssertEquals ("test#05", 116, bytes [4]);
- AssertEquals ("test#06", 0, bytes [5]);
+ Assert.AreEqual (4, bytes [0], "test#01");
+ Assert.AreEqual (116, bytes [1], "test#02");
+ Assert.AreEqual (42, bytes [2], "test#03");
+ Assert.AreEqual (115, bytes [3], "test#04");
+ Assert.AreEqual (116, bytes [4], "test#05");
+ Assert.AreEqual (0, bytes [5], "test#06");
stream = new MemoryStream ();
writer = new BinaryWriter (stream, new UnicodeEncoding ());
writer.Write ("t*st");
bytes = stream.GetBuffer ();
- AssertEquals ("test#07", 8, bytes [0]);
- AssertEquals ("test#08", 116, bytes [1]);
- AssertEquals ("test#09", 0, bytes [2]);
- AssertEquals ("test#10", 42, bytes [3]);
- AssertEquals ("test#11", 0, bytes [4]);
- AssertEquals ("test#12", 115, bytes [5]);
- AssertEquals ("test#13", 0, bytes [6]);
- AssertEquals ("test#14", 116, bytes [7]);
- AssertEquals ("test#15", 0, bytes [8]);
+ Assert.AreEqual (8, bytes [0], "test#07");
+ Assert.AreEqual (116, bytes [1], "test#08");
+ Assert.AreEqual (0, bytes [2], "test#09");
+ Assert.AreEqual (42, bytes [3], "test#10");
+ Assert.AreEqual (0, bytes [4], "test#11");
+ Assert.AreEqual (115, bytes [5], "test#12");
+ Assert.AreEqual (0, bytes [6], "test#13");
+ Assert.AreEqual (116, bytes [7], "test#14");
+ Assert.AreEqual (0, bytes [8], "test#15");
stream = new MemoryStream ();
writer = new BinaryWriter (stream, new UTF7Encoding ());
writer.Write ("t*st");
bytes = stream.GetBuffer ();
- AssertEquals ("test#16", 8, bytes [0]);
- AssertEquals ("test#17", 116, bytes [1]);
- AssertEquals ("test#18", 43, bytes [2]);
- AssertEquals ("test#19", 65, bytes [3]);
- AssertEquals ("test#21", 67, bytes [4]);
- AssertEquals ("test#22", 111, bytes [5]);
- AssertEquals ("test#23", 45, bytes [6]);
- AssertEquals ("test#24", 115, bytes [7]);
- AssertEquals ("test#25", 116, bytes [8]);
- AssertEquals ("test#26", 0, bytes [9]);
- AssertEquals ("test#27", 0, bytes [10]);
+ Assert.AreEqual (8, bytes [0], "test#16");
+ Assert.AreEqual (116, bytes [1], "test#17");
+ Assert.AreEqual (43, bytes [2], "test#18");
+ Assert.AreEqual (65, bytes [3], "test#19");
+ Assert.AreEqual (67, bytes [4], "test#21");
+ Assert.AreEqual (111, bytes [5], "test#22");
+ Assert.AreEqual (45, bytes [6], "test#23");
+ Assert.AreEqual (115, bytes [7], "test#24");
+ Assert.AreEqual (116, bytes [8], "test#25");
+ Assert.AreEqual (0, bytes [9], "test#26");
+ Assert.AreEqual (0, bytes [10], "test#27");
stream = new MemoryStream ();
writer = new BinaryWriter (stream, new ASCIIEncoding ());
writer.Write ("t*st");
bytes = stream.GetBuffer ();
- AssertEquals ("test#28", 4, bytes [0]);
- AssertEquals ("test#29", 116, bytes [1]);
- AssertEquals ("test#30", 42, bytes [2]);
- AssertEquals ("test#31", 115, bytes [3]);
- AssertEquals ("test#32", 116, bytes [4]);
- AssertEquals ("test#33", 0, bytes [5]);
+ Assert.AreEqual (4, bytes [0], "test#28");
+ Assert.AreEqual (116, bytes [1], "test#29");
+ Assert.AreEqual (42, bytes [2], "test#30");
+ Assert.AreEqual (115, bytes [3], "test#31");
+ Assert.AreEqual (116, bytes [4], "test#32");
+ Assert.AreEqual (0, bytes [5], "test#33");
}
[Test]
MemoryStream stream = new MemoryStream ();
BinaryWriter writer = new BinaryWriter (stream, new ASCIIEncoding ());
writer.Close ();
- AssertEquals ("test#01", false, writer.BaseStream.CanRead);
- AssertEquals ("test#01", false, writer.BaseStream.CanWrite);
- AssertEquals ("test#01", false, writer.BaseStream.CanSeek);
+ Assert.AreEqual (false, writer.BaseStream.CanRead, "test#01");
+ Assert.AreEqual (false, writer.BaseStream.CanWrite, "test#01");
+ Assert.AreEqual (false, writer.BaseStream.CanSeek, "test#01");
}
[Test]
writer.Write ("-");
byte [] bytes = stream.GetBuffer ();
- AssertEquals ("test#01", 512, bytes.Length);
- AssertEquals ("test#02", 4, bytes [0]);
- AssertEquals ("test#03", 84, bytes [1]);
- AssertEquals ("test#04", 1, bytes [2]);
- AssertEquals ("test#05", 45, bytes [3]);
- AssertEquals ("test#06", 116, bytes [4]);
- AssertEquals ("test#07", 0, bytes [5]);
- AssertEquals ("test#08", 0, bytes [6]);
- AssertEquals ("test#09", 0, bytes [7]);
- AssertEquals ("test#10", 1, bytes [8]);
- AssertEquals ("test#11", 45, bytes [9]);
- AssertEquals ("test#12", 0, bytes [10]);
- AssertEquals ("test#13", 0, bytes [11]);
- AssertEquals ("test#14", 0, bytes [12]);
- AssertEquals ("test#15", 1, bytes [400]);
+ Assert.AreEqual (512, bytes.Length, "test#01");
+ Assert.AreEqual (4, bytes [0], "test#02");
+ Assert.AreEqual (84, bytes [1], "test#03");
+ Assert.AreEqual (1, bytes [2], "test#04");
+ Assert.AreEqual (45, bytes [3], "test#05");
+ Assert.AreEqual (116, bytes [4], "test#06");
+ Assert.AreEqual (0, bytes [5], "test#07");
+ Assert.AreEqual (0, bytes [6], "test#08");
+ Assert.AreEqual (0, bytes [7], "test#09");
+ Assert.AreEqual (1, bytes [8], "test#10");
+ Assert.AreEqual (45, bytes [9], "test#11");
+ Assert.AreEqual (0, bytes [10], "test#12");
+ Assert.AreEqual (0, bytes [11], "test#13");
+ Assert.AreEqual (0, bytes [12], "test#14");
+ Assert.AreEqual (1, bytes [400], "test#15");
}
[Test]
byte [] bytes = stream.GetBuffer ();
- AssertEquals ("test#01", 256, bytes.Length);
- AssertEquals ("test#02", 109, bytes [0]);
- AssertEquals ("test#03", 111, bytes [1]);
- AssertEquals ("test#04", 110, bytes [2]);
- AssertEquals ("test#05", 111, bytes [3]);
- AssertEquals ("test#06", 58, bytes [4]);
- AssertEquals ("test#07", 58, bytes [5]);
- AssertEquals ("test#08", 58, bytes [6]);
- AssertEquals ("test#09", 58, bytes [7]);
- AssertEquals ("test#10", 79, bytes [8]);
- AssertEquals ("test#11", 78, bytes [9]);
- AssertEquals ("test#12", 79, bytes [10]);
- AssertEquals ("test#13", 77, bytes [11]);
- AssertEquals ("test#14", 0, bytes [12]);
- AssertEquals ("test#15", 0, bytes [13]);
+ Assert.AreEqual (256, bytes.Length, "test#01");
+ Assert.AreEqual (109, bytes [0], "test#02");
+ Assert.AreEqual (111, bytes [1], "test#03");
+ Assert.AreEqual (110, bytes [2], "test#04");
+ Assert.AreEqual (111, bytes [3], "test#05");
+ Assert.AreEqual (58, bytes [4], "test#06");
+ Assert.AreEqual (58, bytes [5], "test#07");
+ Assert.AreEqual (58, bytes [6], "test#08");
+ Assert.AreEqual (58, bytes [7], "test#09");
+ Assert.AreEqual (79, bytes [8], "test#10");
+ Assert.AreEqual (78, bytes [9], "test#11");
+ Assert.AreEqual (79, bytes [10], "test#12");
+ Assert.AreEqual (77, bytes [11], "test#13");
+ Assert.AreEqual (0, bytes [12], "test#14");
+ Assert.AreEqual (0, bytes [13], "test#15");
}
[Test]
writer.Write (new byte [] {6, 5, 4, 3, 2, 1});
byte [] bytes = stream.GetBuffer ();
- AssertEquals ("test#01", 256, bytes.Length);
- AssertEquals ("test#02", 1, bytes [0]);
- AssertEquals ("test#03", 2, bytes [1]);
- AssertEquals ("test#04", 3, bytes [2]);
- AssertEquals ("test#05", 4, bytes [3]);
- AssertEquals ("test#06", 5, bytes [4]);
- AssertEquals ("test#07", 6, bytes [5]);
- AssertEquals ("test#08", 6, bytes [6]);
- AssertEquals ("test#09", 5, bytes [7]);
- AssertEquals ("test#10", 4, bytes [8]);
- AssertEquals ("test#11", 3, bytes [9]);
- AssertEquals ("test#12", 2, bytes [10]);
- AssertEquals ("test#13", 1, bytes [11]);
- AssertEquals ("test#14", 0, bytes [12]);
- AssertEquals ("test#15", 0, bytes [13]);
+ Assert.AreEqual (256, bytes.Length, "test#01");
+ Assert.AreEqual (1, bytes [0], "test#02");
+ Assert.AreEqual (2, bytes [1], "test#03");
+ Assert.AreEqual (3, bytes [2], "test#04");
+ Assert.AreEqual (4, bytes [3], "test#05");
+ Assert.AreEqual (5, bytes [4], "test#06");
+ Assert.AreEqual (6, bytes [5], "test#07");
+ Assert.AreEqual (6, bytes [6], "test#08");
+ Assert.AreEqual (5, bytes [7], "test#09");
+ Assert.AreEqual (4, bytes [8], "test#10");
+ Assert.AreEqual (3, bytes [9], "test#11");
+ Assert.AreEqual (2, bytes [10], "test#12");
+ Assert.AreEqual (1, bytes [11], "test#13");
+ Assert.AreEqual (0, bytes [12], "test#14");
+ Assert.AreEqual (0, bytes [13], "test#15");
}
writer.Write (s);
byte [] bytes;
bytes = stream.GetBuffer ();
- AssertEquals ("test#01", 256, bytes.Length);
- AssertEquals ("test#02", 64, bytes [0]);
- AssertEquals ("test#03", 0, bytes [1]);
+ Assert.AreEqual (256, bytes.Length, "test#01");
+ Assert.AreEqual (64, bytes [0], "test#02");
+ Assert.AreEqual (0, bytes [1], "test#03");
writer.Write (i);
bytes = stream.GetBuffer ();
- AssertEquals ("test#04", 256, bytes.Length);
- AssertEquals ("test#05", 64, bytes [0]);
- AssertEquals ("test#06", 0, bytes [1]);
- AssertEquals ("test#07", 64, bytes [2]);
- AssertEquals ("test#08", 109, bytes [3]);
- AssertEquals ("test#09", 218, bytes [4]);
- AssertEquals ("test#10", 3, bytes [5]);
- AssertEquals ("test#11", 0, bytes [6]);
+ Assert.AreEqual (256, bytes.Length, "test#04");
+ Assert.AreEqual (64, bytes [0], "test#05");
+ Assert.AreEqual (0, bytes [1], "test#06");
+ Assert.AreEqual (64, bytes [2], "test#07");
+ Assert.AreEqual (109, bytes [3], "test#08");
+ Assert.AreEqual (218, bytes [4], "test#09");
+ Assert.AreEqual (3, bytes [5], "test#10");
+ Assert.AreEqual (0, bytes [6], "test#11");
writer.Write (l);
bytes = stream.GetBuffer ();
- AssertEquals ("test#12", 256, bytes.Length);
- AssertEquals ("test#13", 255, bytes [6]);
- AssertEquals ("test#14", 159, bytes [7]);
- AssertEquals ("test#15", 114, bytes [8]);
- AssertEquals ("test#16", 78, bytes [9]);
- AssertEquals ("test#17", 24, bytes [10]);
- AssertEquals ("test#18", 9, bytes [11]);
- AssertEquals ("test#19", 0, bytes [12]);
+ Assert.AreEqual (256, bytes.Length, "test#12");
+ Assert.AreEqual (255, bytes [6], "test#13");
+ Assert.AreEqual (159, bytes [7], "test#14");
+ Assert.AreEqual (114, bytes [8], "test#15");
+ Assert.AreEqual (78, bytes [9], "test#16");
+ Assert.AreEqual (24, bytes [10], "test#17");
+ Assert.AreEqual (9, bytes [11], "test#18");
+ Assert.AreEqual (0, bytes [12], "test#19");
}
[Test]
writer.Write (d2);
byte [] bytes = stream.GetBuffer ();
- AssertEquals ("test#01", 256, bytes.Length);
- AssertEquals ("test#02", 192, bytes [0]);
- AssertEquals ("test#03", 18, bytes [1]);
- AssertEquals ("test#04", 151, bytes [2]);
- AssertEquals ("test#05", 95, bytes [3]);
- AssertEquals ("test#06", 209, bytes [4]);
- AssertEquals ("test#07", 20, bytes [5]);
- AssertEquals ("test#08", 7, bytes [6]);
- AssertEquals ("test#09", 0, bytes [7]);
- AssertEquals ("test#10", 0, bytes [8]);
- AssertEquals ("test#11", 0, bytes [9]);
- AssertEquals ("test#12", 0, bytes [10]);
- AssertEquals ("test#13", 0, bytes [11]);
- AssertEquals ("test#14", 0, bytes [12]);
- AssertEquals ("test#15", 0, bytes [13]);
- AssertEquals ("test#16", 2, bytes [14]);
- AssertEquals ("test#17", 0, bytes [15]);
- AssertEquals ("test#18", 125, bytes [16]);
- AssertEquals ("test#19", 149, bytes [17]);
- AssertEquals ("test#20", 217, bytes [18]);
- AssertEquals ("test#21", 172, bytes [19]);
- AssertEquals ("test#22", 239, bytes [20]);
- AssertEquals ("test#23", 244, bytes [21]);
- AssertEquals ("test#24", 31, bytes [22]);
- AssertEquals ("test#25", 0, bytes [23]);
- AssertEquals ("test#26", 0, bytes [24]);
- AssertEquals ("test#27", 0, bytes [25]);
- AssertEquals ("test#28", 0, bytes [26]);
- AssertEquals ("test#29", 0, bytes [27]);
- AssertEquals ("test#30", 0, bytes [28]);
- AssertEquals ("test#31", 0, bytes [29]);
- AssertEquals ("test#32", 0, bytes [30]);
- AssertEquals ("test#33", 128, bytes [31]);
- AssertEquals ("test#34", 0, bytes [32]);
- AssertEquals ("test#35", 0, bytes [33]);
- AssertEquals ("test#36", 0, bytes [34]);
- AssertEquals ("test#37", 0, bytes [35]);
- AssertEquals ("test#38", 0, bytes [36]);
- AssertEquals ("test#39", 0, bytes [37]);
- AssertEquals ("test#40", 0, bytes [38]);
- AssertEquals ("test#41", 0, bytes [39]);
- AssertEquals ("test#42", 0, bytes [40]);
- AssertEquals ("test#43", 0, bytes [41]);
- AssertEquals ("test#44", 0, bytes [42]);
- AssertEquals ("test#45", 0, bytes [43]);
- AssertEquals ("test#46", 0, bytes [44]);
- AssertEquals ("test#47", 0, bytes [45]);
- AssertEquals ("test#48", 0, bytes [46]);
+ Assert.AreEqual (256, bytes.Length, "test#01");
+ Assert.AreEqual (192, bytes [0], "test#02");
+ Assert.AreEqual (18, bytes [1], "test#03");
+ Assert.AreEqual (151, bytes [2], "test#04");
+ Assert.AreEqual (95, bytes [3], "test#05");
+ Assert.AreEqual (209, bytes [4], "test#06");
+ Assert.AreEqual (20, bytes [5], "test#07");
+ Assert.AreEqual (7, bytes [6], "test#08");
+ Assert.AreEqual (0, bytes [7], "test#09");
+ Assert.AreEqual (0, bytes [8], "test#10");
+ Assert.AreEqual (0, bytes [9], "test#11");
+ Assert.AreEqual (0, bytes [10], "test#12");
+ Assert.AreEqual (0, bytes [11], "test#13");
+ Assert.AreEqual (0, bytes [12], "test#14");
+ Assert.AreEqual (0, bytes [13], "test#15");
+ Assert.AreEqual (2, bytes [14], "test#16");
+ Assert.AreEqual (0, bytes [15], "test#17");
+ Assert.AreEqual (125, bytes [16], "test#18");
+ Assert.AreEqual (149, bytes [17], "test#19");
+ Assert.AreEqual (217, bytes [18], "test#20");
+ Assert.AreEqual (172, bytes [19], "test#21");
+ Assert.AreEqual (239, bytes [20], "test#22");
+ Assert.AreEqual (244, bytes [21], "test#23");
+ Assert.AreEqual (31, bytes [22], "test#24");
+ Assert.AreEqual (0, bytes [23], "test#25");
+ Assert.AreEqual (0, bytes [24], "test#26");
+ Assert.AreEqual (0, bytes [25], "test#27");
+ Assert.AreEqual (0, bytes [26], "test#28");
+ Assert.AreEqual (0, bytes [27], "test#29");
+ Assert.AreEqual (0, bytes [28], "test#30");
+ Assert.AreEqual (0, bytes [29], "test#31");
+ Assert.AreEqual (0, bytes [30], "test#32");
+ Assert.AreEqual (128, bytes [31], "test#33");
+ Assert.AreEqual (0, bytes [32], "test#34");
+ Assert.AreEqual (0, bytes [33], "test#35");
+ Assert.AreEqual (0, bytes [34], "test#36");
+ Assert.AreEqual (0, bytes [35], "test#37");
+ Assert.AreEqual (0, bytes [36], "test#38");
+ Assert.AreEqual (0, bytes [37], "test#39");
+ Assert.AreEqual (0, bytes [38], "test#40");
+ Assert.AreEqual (0, bytes [39], "test#41");
+ Assert.AreEqual (0, bytes [40], "test#42");
+ Assert.AreEqual (0, bytes [41], "test#43");
+ Assert.AreEqual (0, bytes [42], "test#44");
+ Assert.AreEqual (0, bytes [43], "test#45");
+ Assert.AreEqual (0, bytes [44], "test#46");
+ Assert.AreEqual (0, bytes [45], "test#47");
+ Assert.AreEqual (0, bytes [46], "test#48");
}
[Test]
-#if TARGET_JVM
- [Category("NotWorking")]
-#endif
public void WriteFloat ()
{
MemoryStream stream = new MemoryStream ();
writer.Write (f2);
byte [] bytes = stream.GetBuffer ();
- AssertEquals ("test#01", 256, bytes.Length);
- AssertEquals ("test#02", 199, bytes [0]);
- AssertEquals ("test#03", 236, bytes [1]);
- AssertEquals ("test#04", 101, bytes [2]);
- AssertEquals ("test#05", 80, bytes [3]);
- AssertEquals ("test#06", 10, bytes [4]);
- AssertEquals ("test#07", 245, bytes [5]);
- AssertEquals ("test#08", 33, bytes [6]);
- AssertEquals ("test#09", 183, bytes [7]);
- AssertEquals ("test#10", 0, bytes [8]);
- AssertEquals ("test#11", 0, bytes [9]);
+ Assert.AreEqual (256, bytes.Length, "test#01");
+ Assert.AreEqual (199, bytes [0], "test#02");
+ Assert.AreEqual (236, bytes [1], "test#03");
+ Assert.AreEqual (101, bytes [2], "test#04");
+ Assert.AreEqual (80, bytes [3], "test#05");
+ Assert.AreEqual (10, bytes [4], "test#06");
+ Assert.AreEqual (245, bytes [5], "test#07");
+ Assert.AreEqual (33, bytes [6], "test#08");
+ Assert.AreEqual (183, bytes [7], "test#09");
+ Assert.AreEqual (0, bytes [8], "test#10");
+ Assert.AreEqual (0, bytes [9], "test#11");
}
[Test]
writer.Write (d2);
byte [] bytes = stream.GetBuffer ();
- AssertEquals ("test#01", 256, bytes.Length);
- AssertEquals ("test#02", 49, bytes [0]);
- AssertEquals ("test#03", 69, bytes [1]);
- AssertEquals ("test#04", 15, bytes [2]);
- AssertEquals ("test#05", 157, bytes [3]);
- AssertEquals ("test#06", 211, bytes [4]);
- AssertEquals ("test#07", 55, bytes [5]);
- AssertEquals ("test#08", 188, bytes [6]);
- AssertEquals ("test#09", 84, bytes [7]);
- AssertEquals ("test#10", 76, bytes [8]);
- AssertEquals ("test#11", 59, bytes [9]);
- AssertEquals ("test#12", 59, bytes [10]);
- AssertEquals ("test#13", 60, bytes [11]);
- AssertEquals ("test#14", 4, bytes [12]);
- AssertEquals ("test#15", 196, bytes [13]);
- AssertEquals ("test#16", 90, bytes [14]);
- AssertEquals ("test#17", 165, bytes [15]);
- AssertEquals ("test#18", 0, bytes [16]);
+ Assert.AreEqual (256, bytes.Length, "test#01");
+ Assert.AreEqual (49, bytes [0], "test#02");
+ Assert.AreEqual (69, bytes [1], "test#03");
+ Assert.AreEqual (15, bytes [2], "test#04");
+ Assert.AreEqual (157, bytes [3], "test#05");
+ Assert.AreEqual (211, bytes [4], "test#06");
+ Assert.AreEqual (55, bytes [5], "test#07");
+ Assert.AreEqual (188, bytes [6], "test#08");
+ Assert.AreEqual (84, bytes [7], "test#09");
+ Assert.AreEqual (76, bytes [8], "test#10");
+ Assert.AreEqual (59, bytes [9], "test#11");
+ Assert.AreEqual (59, bytes [10], "test#12");
+ Assert.AreEqual (60, bytes [11], "test#13");
+ Assert.AreEqual (4, bytes [12], "test#14");
+ Assert.AreEqual (196, bytes [13], "test#15");
+ Assert.AreEqual (90, bytes [14], "test#16");
+ Assert.AreEqual (165, bytes [15], "test#17");
+ Assert.AreEqual (0, bytes [16], "test#18");
}
[Test]
writer.Write (c2);
byte [] bytes = stream.GetBuffer ();
- AssertEquals ("test#01", 256, bytes.Length);
- AssertEquals ("test#02", 12, bytes [0]);
- AssertEquals ("test#03", 45, bytes [1]);
- AssertEquals ("test#04", 64, bytes [2]);
- AssertEquals ("test#05", 77, bytes [3]);
- AssertEquals ("test#06", 0, bytes [4]);
+ Assert.AreEqual (256, bytes.Length, "test#01");
+ Assert.AreEqual (12, bytes [0], "test#02");
+ Assert.AreEqual (45, bytes [1], "test#03");
+ Assert.AreEqual (64, bytes [2], "test#04");
+ Assert.AreEqual (77, bytes [3], "test#05");
+ Assert.AreEqual (0, bytes [4], "test#06");
}
[Test]
writer.Write (s2);
byte [] bytes = stream.GetBuffer ();
- AssertEquals ("test#01", 256, bytes.Length);
- AssertEquals ("test#02", 3, bytes [0]);
- AssertEquals ("test#03", 97, bytes [1]);
- AssertEquals ("test#04", 98, bytes [2]);
- AssertEquals ("test#05", 99, bytes [3]);
- AssertEquals ("test#06", 4, bytes [4]);
- AssertEquals ("test#07", 68, bytes [5]);
- AssertEquals ("test#08", 101, bytes [6]);
- AssertEquals ("test#09", 70, bytes [7]);
- AssertEquals ("test#10", 10, bytes [8]);
- AssertEquals ("test#11", 0, bytes [9]);
+ Assert.AreEqual (256, bytes.Length, "test#01");
+ Assert.AreEqual (3, bytes [0], "test#02");
+ Assert.AreEqual (97, bytes [1], "test#03");
+ Assert.AreEqual (98, bytes [2], "test#04");
+ Assert.AreEqual (99, bytes [3], "test#05");
+ Assert.AreEqual (4, bytes [4], "test#06");
+ Assert.AreEqual (68, bytes [5], "test#07");
+ Assert.AreEqual (101, bytes [6], "test#08");
+ Assert.AreEqual (70, bytes [7], "test#09");
+ Assert.AreEqual (10, bytes [8], "test#10");
+ Assert.AreEqual (0, bytes [9], "test#11");
+ }
+
+ [Test]
+ public void Write7BitEncodedIntTest ()
+ {
+ MemoryStream stream = new MemoryStream ();
+ var writer = new MyBinaryWriter (stream);
+ writer.WriteLeb128 (5);
+
+ Assert.AreEqual (new byte[] { 5 }, stream.ToArray (), "#1");
+
+ stream = new MemoryStream ();
+ writer = new MyBinaryWriter (stream);
+ writer.WriteLeb128 (int.MaxValue);
+
+ Assert.AreEqual (new byte[] { 255, 255, 255, 255, 7 }, stream.ToArray (), "#2");
+
+ stream = new MemoryStream ();
+ writer = new MyBinaryWriter (stream);
+ writer.WriteLeb128 (128);
+
+ Assert.AreEqual (new byte[] { 128, 1 }, stream.ToArray (), "#3");
+
+ stream = new MemoryStream ();
+ writer = new MyBinaryWriter (stream);
+ writer.WriteLeb128 (-1025);
+
+ Assert.AreEqual (new byte[] { 255, 247, 255, 255, 15 }, stream.ToArray (), "#4");
+
+ stream = new MemoryStream ();
+ writer = new MyBinaryWriter (stream);
+ writer.WriteLeb128 (int.MinValue);
+
+ Assert.AreEqual (new byte[] { 128, 128, 128, 128, 8 }, stream.ToArray (), "#5");
+
+ stream = new MemoryStream ();
+ writer = new MyBinaryWriter (stream);
+ writer.WriteLeb128 (-1);
+
+ Assert.AreEqual (new byte[] { 255, 255, 255, 255, 15 }, stream.ToArray (), "#6");
+
+ stream = new MemoryStream ();
+ writer = new MyBinaryWriter (stream);
+ writer.WriteLeb128 (0);
+
+ Assert.AreEqual (new byte[] { 0 }, stream.ToArray (), "#7");
+ }
+
+ [Test]
+ public void BaseStreamCallsFlush ()
+ {
+ FlushStream stream = new FlushStream ();
+ BinaryWriter writer = new BinaryWriter (stream);
+ Stream s = writer.BaseStream;
+ Assert.IsTrue (stream.FlushCalled);
}
private void DeleteFile (string path)
if (File.Exists (path))
File.Delete (path);
}
+
+ class FlushStream : Stream
+ {
+ public bool FlushCalled;
+
+ public override bool CanRead {
+ get { return true; }
+ }
+
+ public override bool CanSeek {
+ get { return true; }
+ }
+
+ public override bool CanWrite {
+ get { return true; }
+ }
+
+ public override long Length {
+ get { return 0; }
+ }
+
+ public override long Position {
+ get { return 0; }
+ set { }
+ }
+
+ public override void Flush ()
+ {
+ FlushCalled = true;
+ }
+
+ public override int Read (byte[] buffer, int offset, int count)
+ {
+ return 0;
+ }
+
+ public override int ReadByte ()
+ {
+ return -1;
+ }
+
+ public override long Seek (long offset, SeekOrigin origin)
+ {
+ return 0;
+ }
+
+ public override void SetLength (long value)
+ {
+ }
+
+ public override void Write (byte[] buffer, int offset, int count)
+ {
+ }
+
+ public override void WriteByte (byte value)
+ {
+ }
+ }
+
+
}
}
projects / mono.git / blobdiff