namespace MonoTests.Mono.Unix {
[TestFixture]
- public class UnixEncodingTest : Assertion {
+ public class UnixEncodingTest {
private UnixEncoding unix;
// see (RFC 2044)
byte[] unixBytes = unixEnc.GetBytes (UniCode);
- Assertion.AssertEquals ("UTF #1", 0x41, unixBytes [0]);
- Assertion.AssertEquals ("UTF #2", 0xE2, unixBytes [1]);
- Assertion.AssertEquals ("UTF #3", 0x89, unixBytes [2]);
- Assertion.AssertEquals ("UTF #4", 0xA2, unixBytes [3]);
- Assertion.AssertEquals ("UTF #5", 0xCE, unixBytes [4]);
- Assertion.AssertEquals ("UTF #6", 0x91, unixBytes [5]);
- Assertion.AssertEquals ("UTF #7", 0x2E, unixBytes [6]);
+ Assert.AreEqual (0x41, unixBytes [0], "UTF #1");
+ Assert.AreEqual (0xE2, unixBytes [1], "UTF #2");
+ Assert.AreEqual (0x89, unixBytes [2], "UTF #3");
+ Assert.AreEqual (0xA2, unixBytes [3], "UTF #4");
+ Assert.AreEqual (0xCE, unixBytes [4], "UTF #5");
+ Assert.AreEqual (0x91, unixBytes [5], "UTF #6");
+ Assert.AreEqual (0x2E, unixBytes [6], "UTF #7");
}
[Test]
int ByteCnt = unixEnc.GetBytes (UniCode.ToCharArray(), 0, UniCode.Length, unixBytes, 0);
- Assertion.AssertEquals ("UTF #1", 11, ByteCnt);
- Assertion.AssertEquals ("UTF #2", 0x48, unixBytes [0]);
- Assertion.AssertEquals ("UTF #3", 0x69, unixBytes [1]);
- Assertion.AssertEquals ("UTF #4", 0x20, unixBytes [2]);
- Assertion.AssertEquals ("UTF #5", 0x4D, unixBytes [3]);
- Assertion.AssertEquals ("UTF #6", 0x6F, unixBytes [4]);
- Assertion.AssertEquals ("UTF #7", 0x6D, unixBytes [5]);
- Assertion.AssertEquals ("UTF #8", 0x20, unixBytes [6]);
- Assertion.AssertEquals ("UTF #9", 0xE2, unixBytes [7]);
- Assertion.AssertEquals ("UTF #10", 0x98, unixBytes [8]);
- Assertion.AssertEquals ("UTF #11", 0xBA, unixBytes [9]);
- Assertion.AssertEquals ("UTF #12", 0x21, unixBytes [10]);
+ Assert.AreEqual (11, ByteCnt, "UTF #1");
+ Assert.AreEqual (0x48, unixBytes [0], "UTF #2");
+ Assert.AreEqual (0x69, unixBytes [1], "UTF #3");
+ Assert.AreEqual (0x20, unixBytes [2], "UTF #4");
+ Assert.AreEqual (0x4D, unixBytes [3], "UTF #5");
+ Assert.AreEqual (0x6F, unixBytes [4], "UTF #6");
+ Assert.AreEqual (0x6D, unixBytes [5], "UTF #7");
+ Assert.AreEqual (0x20, unixBytes [6], "UTF #8");
+ Assert.AreEqual (0xE2, unixBytes [7], "UTF #9");
+ Assert.AreEqual (0x98, unixBytes [8], "UTF #10");
+ Assert.AreEqual (0xBA, unixBytes [9], "UTF #11");
+ Assert.AreEqual (0x21, unixBytes [10], "UTF #12");
}
[Test]
byte[] unixBytes = new byte [] {0x41, 0xE2, 0x89, 0xA2, 0xCE, 0x91, 0x2E};
char[] UniCodeChars = unixEnc.GetChars(unixBytes);
- Assertion.AssertEquals ("UTF #1", 0x0041, UniCodeChars [0]);
- Assertion.AssertEquals ("UTF #2", 0x2262, UniCodeChars [1]);
- Assertion.AssertEquals ("UTF #3", 0x0391, UniCodeChars [2]);
- Assertion.AssertEquals ("UTF #4", 0x002E, UniCodeChars [3]);
+ Assert.AreEqual (0x0041, UniCodeChars [0], "UTF #1");
+ Assert.AreEqual (0x2262, UniCodeChars [1], "UTF #2");
+ Assert.AreEqual (0x0391, UniCodeChars [2], "UTF #3");
+ Assert.AreEqual (0x002E, UniCodeChars [3], "UTF #4");
}
[Test]
public void TestMaxCharCount()
{
UnixEncoding unixenc = new UnixEncoding ();
- Assertion.AssertEquals ("UTF #1", 50, unixenc.GetMaxCharCount(50));
+ Assert.AreEqual (50, unixenc.GetMaxCharCount(50), "UTF #1");
}
[Test]
public void TestMaxByteCount()
{
UnixEncoding unixenc = new UnixEncoding ();
- Assertion.AssertEquals ("UTF #1", 200, unixenc.GetMaxByteCount(50));
+ Assert.AreEqual (200, unixenc.GetMaxByteCount(50), "UTF #1");
}
// regression for bug #59648
byte[] data = new byte [] { 0xC0, 0xAF };
string s = u.GetString (data);
- AssertEquals (4, s.Length);
- AssertEquals (0x0000, (int) s [0]);
- AssertEquals (0xC0, (int) s [1]);
- AssertEquals (0x0000, (int) s [2]);
- AssertEquals (0xAF, (int) s [3]);
- AssertEquals ("Output-TestThrowOnInvalid", "\u0000\xC0\u0000\xAF", s);
- AssertEquals ("Reconverted-TestThrowOnInvalid", BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
+ Assert.AreEqual (4, s.Length);
+ Assert.AreEqual (0x0000, (int) s [0]);
+ Assert.AreEqual (0xC0, (int) s [1]);
+ Assert.AreEqual (0x0000, (int) s [2]);
+ Assert.AreEqual (0xAF, (int) s [3]);
+ Assert.AreEqual ("\u0000\xC0\u0000\xAF", s, "Output-TestThrowOnInvalid");
+ Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-TestThrowOnInvalid");
data = new byte [] { 0x30, 0x31, 0xC0, 0xAF, 0x30, 0x32 };
s = u.GetString (data);
- AssertEquals (8, s.Length);
- AssertEquals (0x30, (int) s [0]);
- AssertEquals (0x31, (int) s [1]);
- AssertEquals (0x0000, (int) s [2]);
- AssertEquals (0xC0, (int) s [3]);
- AssertEquals (0x0000, (int) s [4]);
- AssertEquals (0xAF, (int) s [5]);
- AssertEquals (0x30, (int) s [6]);
- AssertEquals (0x32, (int) s [7]);
+ Assert.AreEqual (8, s.Length);
+ Assert.AreEqual (0x30, (int) s [0]);
+ Assert.AreEqual (0x31, (int) s [1]);
+ Assert.AreEqual (0x0000, (int) s [2]);
+ Assert.AreEqual (0xC0, (int) s [3]);
+ Assert.AreEqual (0x0000, (int) s [4]);
+ Assert.AreEqual (0xAF, (int) s [5]);
+ Assert.AreEqual (0x30, (int) s [6]);
+ Assert.AreEqual (0x32, (int) s [7]);
- AssertEquals ("Output-TestThrowOnInvalid2", "\x30\x31\u0000\xC0\u0000\xAF\x30\x32", s);
- AssertEquals ("Reconverted-TestThrowOnInvalid2", BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
+ Assert.AreEqual ("\x30\x31\u0000\xC0\u0000\xAF\x30\x32", s, "Output-TestThrowOnInvalid2");
+ Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-TestThrowOnInvalid2");
}
// unix decoding tests from http://www.cl.cam.ac.uk/~mgk25/
string s = unix.GetString (data);
// cute but saving source code in unicode can be problematic
// so we just ensure we can re-encode this
- AssertEquals ("Reconverted", BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
+ Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted");
}
[Test]
{
byte[] data211 = { 0x00 };
string s = unix.GetString (data211);
- AssertEquals ("1 byte (U-00000000)", "\0", s);
- AssertEquals ("Reconverted-1", BitConverter.ToString (data211), BitConverter.ToString (unix.GetBytes (s)));
+ Assert.AreEqual ("\0", s, "1 byte (U-00000000)");
+ Assert.AreEqual (BitConverter.ToString (data211), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-1");
byte[] data212 = { 0xC2, 0x80 };
s = unix.GetString (data212);
- AssertEquals ("2 bytes (U-00000080)", 128, s [0]);
- AssertEquals ("Reconverted-2", BitConverter.ToString (data212), BitConverter.ToString (unix.GetBytes (s)));
+ Assert.AreEqual (128, s [0], "2 bytes (U-00000080)");
+ Assert.AreEqual (BitConverter.ToString (data212), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-2");
byte[] data213 = { 0xE0, 0xA0, 0x80 };
s = unix.GetString (data213);
- AssertEquals ("3 bytes (U-00000800)", 2048, s [0]);
- AssertEquals ("Reconverted-3", BitConverter.ToString (data213), BitConverter.ToString (unix.GetBytes (s)));
+ Assert.AreEqual (2048, s [0], "3 bytes (U-00000800)");
+ Assert.AreEqual (BitConverter.ToString (data213), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-3");
byte[] data214 = { 0xF0, 0x90, 0x80, 0x80 };
s = unix.GetString (data214);
- AssertEquals ("4 bytes (U-00010000)-0", 55296, s [0]);
- AssertEquals ("4 bytes (U-00010000)-1", 56320, s [1]);
- AssertEquals ("Reconverted-4", BitConverter.ToString (data214), BitConverter.ToString (unix.GetBytes (s)));
+ Assert.AreEqual (55296, s [0], "4 bytes (U-00010000)-0");
+ Assert.AreEqual (56320, s [1], "4 bytes (U-00010000)-1");
+ Assert.AreEqual (BitConverter.ToString (data214), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-4");
}
[Test]
{
byte[] data215 = { 0xF8, 0x88, 0x80, 0x80, 0x80 };
string s = unix.GetString (data215);
- AssertEquals ("Output-5", "\u0000\xF8\u0000\x88\u0000\x80\u0000\x80\u0000\x80", s);
- AssertEquals ("Reconverted-5", BitConverter.ToString (data215), BitConverter.ToString (unix.GetBytes (s)));
+ Assert.AreEqual ("\u0000\xF8\u0000\x88\u0000\x80\u0000\x80\u0000\x80", s, "Output-5");
+ Assert.AreEqual (BitConverter.ToString (data215), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-5");
}
[Test]
{
byte[] data216 = { 0xFC, 0x84, 0x80, 0x80, 0x80, 0x80 };
string s = unix.GetString (data216);
- AssertEquals ("Output-6", "\u0000\xFC\u0000\x84\u0000\x80\u0000\x80\u0000\x80\u0000\x80", s);
- AssertEquals ("Reconverted-6", BitConverter.ToString (data216), BitConverter.ToString (unix.GetBytes (s)));
+ Assert.AreEqual ("\u0000\xFC\u0000\x84\u0000\x80\u0000\x80\u0000\x80\u0000\x80", s, "Output-6");
+ Assert.AreEqual (BitConverter.ToString (data216), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-6");
}
[Test]
{
byte[] data221 = { 0x7F };
string s = unix.GetString (data221);
- AssertEquals ("1 byte (U-0000007F)", 127, s [0]);
- AssertEquals ("Reconverted-1", BitConverter.ToString (data221), BitConverter.ToString (unix.GetBytes (s)));
+ Assert.AreEqual (127, s [0], "1 byte (U-0000007F)");
+ Assert.AreEqual (BitConverter.ToString (data221), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-1");
byte[] data222 = { 0xDF, 0xBF };
s = unix.GetString (data222);
- AssertEquals ("2 bytes (U-000007FF)", 2047, s [0]);
- AssertEquals ("Reconverted-2", BitConverter.ToString (data222), BitConverter.ToString (unix.GetBytes (s)));
+ Assert.AreEqual (2047, s [0], "2 bytes (U-000007FF)");
+ Assert.AreEqual (BitConverter.ToString (data222), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-2");
byte[] data223 = { 0xEF, 0xBF, 0xBF };
s = unix.GetString (data223);
- AssertEquals ("3 bytes (U-0000FFFF)", 65535, s [0]);
- AssertEquals ("Reconverted-3", BitConverter.ToString (data223), BitConverter.ToString (unix.GetBytes (s)));
+ Assert.AreEqual (65535, s [0], "3 bytes (U-0000FFFF)");
+ Assert.AreEqual (BitConverter.ToString (data223), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-3");
}
{
byte[] data224 = { 0x7F, 0xBF, 0xBF, 0xBF };
string s = unix.GetString (data224);
- AssertEquals ("Output-4",
- "\x7F\u0000\xBF\u0000\xBF\u0000\xBF", s);
- AssertEquals ("Reconverted-4", BitConverter.ToString (data224), BitConverter.ToString (unix.GetBytes (s)));
+ Assert.AreEqual ("\x7F\u0000\xBF\u0000\xBF\u0000\xBF", s, "Output-4");
+ Assert.AreEqual (BitConverter.ToString (data224), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-4");
}
[Test]
{
byte[] data225 = { 0xFB, 0xBF, 0xBF, 0xBF, 0xBF };
string s = unix.GetString (data225);
- AssertEquals ("Output-5", "\u0000\xFB\u0000\xBF\u0000\xBF\u0000\xBF\u0000\xBF", s);
- AssertEquals ("Reconverted-5", BitConverter.ToString (data225), BitConverter.ToString (unix.GetBytes (s)));
+ Assert.AreEqual ("\u0000\xFB\u0000\xBF\u0000\xBF\u0000\xBF\u0000\xBF", s, "Output-5");
+ Assert.AreEqual (BitConverter.ToString (data225), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-5");
}
[Test]
{
byte[] data226 = { 0xFD, 0xBF, 0xBF, 0xBF, 0xBF, 0xBF };
string s = unix.GetString (data226);
- AssertEquals ("Output-6", "\u0000\xFD\u0000\xBF\u0000\xBF\u0000\xBF\u0000\xBF\u0000\xBF", s);
- AssertEquals ("Reconverted-6", BitConverter.ToString (data226), BitConverter.ToString (unix.GetBytes (s)));
+ Assert.AreEqual ("\u0000\xFD\u0000\xBF\u0000\xBF\u0000\xBF\u0000\xBF\u0000\xBF", s, "Output-6");
+ Assert.AreEqual (BitConverter.ToString (data226), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-6");
}
[Test]
{
byte[] data231 = { 0xED, 0x9F, 0xBF };
string s = unix.GetString (data231);
- AssertEquals ("U-0000D7FF", 55295, s [0]);
- AssertEquals ("Reconverted-1", BitConverter.ToString (data231), BitConverter.ToString (unix.GetBytes (s)));
+ Assert.AreEqual (55295, s [0], "U-0000D7FF");
+ Assert.AreEqual (BitConverter.ToString (data231), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-1");
byte[] data232 = { 0xEE, 0x80, 0x80 };
s = unix.GetString (data232);
- AssertEquals ("U-0000E000", 57344, s [0]);
- AssertEquals ("Reconverted-2", BitConverter.ToString (data232), BitConverter.ToString (unix.GetBytes (s)));
+ Assert.AreEqual (57344, s [0], "U-0000E000");
+ Assert.AreEqual (BitConverter.ToString (data232), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-2");
byte[] data233 = { 0xEF, 0xBF, 0xBD };
s = unix.GetString (data233);
- AssertEquals ("U-0000FFFD", 65533, s [0]);
- AssertEquals ("Reconverted-3", BitConverter.ToString (data233), BitConverter.ToString (unix.GetBytes (s)));
+ Assert.AreEqual (65533, s [0], "U-0000FFFD");
+ Assert.AreEqual (BitConverter.ToString (data233), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-3");
byte[] data234 = { 0xF4, 0x8F, 0xBF, 0xBF };
s = unix.GetString (data234);
- AssertEquals ("U-0010FFFF-0", 56319, s [0]);
- AssertEquals ("U-0010FFFF-1", 57343, s [1]);
- AssertEquals ("Reconverted-4", BitConverter.ToString (data234), BitConverter.ToString (unix.GetBytes (s)));
+ Assert.AreEqual (56319, s [0], "U-0010FFFF-0");
+ Assert.AreEqual (57343, s [1], "U-0010FFFF-1");
+ Assert.AreEqual (BitConverter.ToString (data234), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-4");
}
[Test]
{
byte[] data235 = { 0xF4, 0x90, 0x80, 0x80 };
string s = unix.GetString (data235);
- AssertEquals ("Output-5", "\u0000\xF4\u0000\x90\u0000\x80\u0000\x80", s);
- AssertEquals ("Reconverted-5", BitConverter.ToString (data235), BitConverter.ToString (unix.GetBytes (s)));
+ Assert.AreEqual ("\u0000\xF4\u0000\x90\u0000\x80\u0000\x80", s, "Output-5");
+ Assert.AreEqual (BitConverter.ToString (data235), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-5");
}
[Test]
{
byte[] data = { 0x80 };
string s = unix.GetString (data);
- AssertEquals ("Output-311", "\u0000\x80", s);
- AssertEquals ("Reconverted-311", BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
+ Assert.AreEqual ("\u0000\x80", s, "Output-311");
+ Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-311");
}
[Test]
{
byte[] data = { 0xBF };
string s = unix.GetString (data);
- AssertEquals ("Output-312", "\u0000\xBF", s);
- AssertEquals ("Reconverted-313", BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
+ Assert.AreEqual ("\u0000\xBF", s, "Output-312");
+ Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-313");
}
[Test]
{
byte[] data = { 0x80, 0xBF };
string s = unix.GetString (data);
- AssertEquals ("Output-313", "\u0000\x80\u0000\xBF", s);
- AssertEquals ("Reconverted-313", BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
+ Assert.AreEqual ("\u0000\x80\u0000\xBF", s, "Output-313");
+ Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-313");
}
[Test]
{
byte[] data = { 0x80, 0xBF, 0x80 };
string s = unix.GetString (data);
- AssertEquals ("Output-314", "\u0000\x80\u0000\xBF\u0000\x80", s);
- AssertEquals ("Reconverted-314", BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
+ Assert.AreEqual ("\u0000\x80\u0000\xBF\u0000\x80", s, "Output-314");
+ Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-314");
}
[Test]
{
byte[] data = { 0x80, 0xBF, 0x80, 0xBF };
string s = unix.GetString (data);
- AssertEquals ("Output-315", "\u0000\x80\u0000\xBF\u0000\x80\u0000\xBF", s);
- AssertEquals ("Reconverted-315", BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
+ Assert.AreEqual ("\u0000\x80\u0000\xBF\u0000\x80\u0000\xBF", s, "Output-315");
+ Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-315");
}
[Test]
{
byte[] data = { 0x80, 0xBF, 0x80, 0xBF, 0x80 };
string s = unix.GetString (data);
- AssertEquals ("Output-316",
- "\u0000\x80\u0000\xBF\u0000\x80\u0000\xBF\u0000\x80", s);
- AssertEquals ("Reconverted-316", BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
+ Assert.AreEqual ("\u0000\x80\u0000\xBF\u0000\x80\u0000\xBF\u0000\x80", s, "Output-316");
+ Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-316");
}
[Test]
{
byte[] data = { 0x80, 0xBF, 0x80, 0xBF, 0x80, 0xBF };
string s = unix.GetString (data);
- AssertEquals ("Output-317",
- "\u0000\x80\u0000\xBF\u0000\x80\u0000\xBF\u0000\x80\u0000\xBF", s);
- AssertEquals ("Reconverted-317", BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
+ Assert.AreEqual ("\u0000\x80\u0000\xBF\u0000\x80\u0000\xBF\u0000\x80\u0000\xBF", s, "Output-317");
+ Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-317");
}
[Test]
{
byte[] data = { 0x80, 0xBF, 0x80, 0xBF, 0x80, 0xBF, 0x80 };
string s = unix.GetString (data);
- AssertEquals ("Output-318",
- "\u0000\x80\u0000\xBF\u0000\x80\u0000\xBF\u0000\x80\u0000\xBF\u0000\x80", s);
- AssertEquals ("Reconverted-318", BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
+ Assert.AreEqual ("\u0000\x80\u0000\xBF\u0000\x80\u0000\xBF\u0000\x80\u0000\xBF\u0000\x80", s, "Output-318");
+ Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-318");
}
[Test]
0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF,
0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF };
string s = unix.GetString (data);
- AssertEquals ("Output-319",
- "\u0000\x80\u0000\x81\u0000\x82\u0000\x83\u0000\x84\u0000\x85\u0000\x86\u0000\x87" +
+ Assert.AreEqual ("\u0000\x80\u0000\x81\u0000\x82\u0000\x83\u0000\x84\u0000\x85\u0000\x86\u0000\x87" +
"\u0000\x88\u0000\x89\u0000\x8A\u0000\x8B\u0000\x8C\u0000\x8D\u0000\x8E\u0000\x8F" +
"\u0000\x90\u0000\x91\u0000\x92\u0000\x93\u0000\x94\u0000\x95\u0000\x96\u0000\x97" +
"\u0000\x98\u0000\x99\u0000\x9A\u0000\x9B\u0000\x9C\u0000\x9D\u0000\x9E\u0000\x9F" +
"\u0000\xA8\u0000\xA9\u0000\xAA\u0000\xAB\u0000\xAC\u0000\xAD\u0000\xAE\u0000\xAF" +
"\u0000\xB0\u0000\xB1\u0000\xB2\u0000\xB3\u0000\xB4\u0000\xB5\u0000\xB6\u0000\xB7" +
"\u0000\xB8\u0000\xB9\u0000\xBA\u0000\xBB\u0000\xBC\u0000\xBD\u0000\xBE\u0000\xBF",
- s);
- AssertEquals ("Reconverted-319", BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
+ s, "Output-319");
+ Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-319");
}
[Test]
0xD0, 0x20, 0xD1, 0x20, 0xD2, 0x20, 0xD3, 0x20, 0xD4, 0x20, 0xD5, 0x20, 0xD6, 0x20, 0xD7, 0x20,
0xD8, 0x20, 0xD9, 0x20, 0xDA, 0x20, 0xDB, 0x20, 0xDC, 0x20, 0xDD, 0x20, 0xDE, 0x20, 0xDF, 0x20 };
string s = unix.GetString (data);
- AssertEquals ("Output-T3_Malformed_2_LonelyStart_321",
- "\u0000\xC0 \u0000\xC1 \u0000\xC2 \u0000\xC3 \u0000\xC4 \u0000\xC5 \u0000\xC6 \u0000\xC7 " +
+ Assert.AreEqual ("\u0000\xC0 \u0000\xC1 \u0000\xC2 \u0000\xC3 \u0000\xC4 \u0000\xC5 \u0000\xC6 \u0000\xC7 " +
"\u0000\xC8 \u0000\xC9 \u0000\xCA \u0000\xCB \u0000\xCC \u0000\xCD \u0000\xCE \u0000\xCF " +
"\u0000\xD0 \u0000\xD1 \u0000\xD2 \u0000\xD3 \u0000\xD4 \u0000\xD5 \u0000\xD6 \u0000\xD7 " +
"\u0000\xD8 \u0000\xD9 \u0000\xDA \u0000\xDB \u0000\xDC \u0000\xDD \u0000\xDE \u0000\xDF ",
- s
- );
- AssertEquals ("Reconverted-T3_Malformed_2_LonelyStart_321",
- BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
+ s,
+ "Output-T3_Malformed_2_LonelyStart_321");
+ Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-T3_Malformed_2_LonelyStart_321");
}
[Test]
0xE0, 0x20, 0xE1, 0x20, 0xE2, 0x20, 0xE3, 0x20, 0xE4, 0x20, 0xE5, 0x20, 0xE6, 0x20, 0xE7, 0x20,
0xE8, 0x20, 0xE9, 0x20, 0xEA, 0x20, 0xEB, 0x20, 0xEC, 0x20, 0xED, 0x20, 0xEE, 0x20, 0xEF, 0x20 };
string s = unix.GetString (data);
- AssertEquals ("Output-T3_Malformed_2_LonelyStart_322",
- "\u0000\xE0 \u0000\xE1 \u0000\xE2 \u0000\xE3 \u0000\xE4 \u0000\xE5 \u0000\xE6 \u0000\xE7 " +
+ Assert.AreEqual ("\u0000\xE0 \u0000\xE1 \u0000\xE2 \u0000\xE3 \u0000\xE4 \u0000\xE5 \u0000\xE6 \u0000\xE7 " +
"\u0000\xE8 \u0000\xE9 \u0000\xEA \u0000\xEB \u0000\xEC \u0000\xED \u0000\xEE \u0000\xEF ",
- s
- );
- AssertEquals ("Reconverted-T3_Malformed_2_LonelyStart_322",
- BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
+ s,
+ "Output-T3_Malformed_2_LonelyStart_322");
+ Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-T3_Malformed_2_LonelyStart_322");
}
[Test]
{
byte[] data = { 0xF0, 0x20, 0xF1, 0x20, 0xF2, 0x20, 0xF3, 0x20, 0xF4, 0x20, 0xF5, 0x20, 0xF6, 0x20, 0xF7, 0x20 };
string s = unix.GetString (data);
- AssertEquals ("Output-T3_Malformed_2_LonelyStart_323",
- "\u0000\xF0 \u0000\xF1 \u0000\xF2 \u0000\xF3 \u0000\xF4 \u0000\xF5 \u0000\xF6 \u0000\xF7 ",
- s
- );
- AssertEquals ("Reconverted-T3_Malformed_2_LonelyStart_323",
- BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
+ Assert.AreEqual ("\u0000\xF0 \u0000\xF1 \u0000\xF2 \u0000\xF3 \u0000\xF4 \u0000\xF5 \u0000\xF6 \u0000\xF7 ",
+ s,
+ "Output-T3_Malformed_2_LonelyStart_323");
+ Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-T3_Malformed_2_LonelyStart_323");
}
[Test]
{
byte[] data = { 0xF0, 0x20, 0xF1, 0x20, 0xF2, 0x20, 0xF3, 0x20, 0xF4, 0x20, 0xF5, 0x20, 0xF6, 0x20, 0xF7, 0x20 };
string s = unix.GetString (data);
- AssertEquals ("Output-T3_Malformed_2_LonelyStart_324",
- "\u0000\xF0 \u0000\xF1 \u0000\xF2 \u0000\xF3 \u0000\xF4 \u0000\xF5 \u0000\xF6 \u0000\xF7 ",
- s
- );
- AssertEquals ("Reconverted-T3_Malformed_2_LonelyStart_324",
- BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
+ Assert.AreEqual ("\u0000\xF0 \u0000\xF1 \u0000\xF2 \u0000\xF3 \u0000\xF4 \u0000\xF5 \u0000\xF6 \u0000\xF7 ",
+ s,
+ "Output-T3_Malformed_2_LonelyStart_324");
+ Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-T3_Malformed_2_LonelyStart_324");
}
[Test]
{
byte[] data = { 0xFC, 0x20, 0xFD, 0x20 };
string s = unix.GetString (data);
- AssertEquals ("Output-T3_Malformed_2_LonelyStart_324", "\u0000\xFC \u0000\xFD ", s);
- AssertEquals ("Reconverted-T3_Malformed_2_LonelyStart_324",
- BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
+ Assert.AreEqual ("\u0000\xFC \u0000\xFD ", s, "Output-T3_Malformed_2_LonelyStart_324");
+ Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-T3_Malformed_2_LonelyStart_324");
}
[Test]
{
byte[] data = { 0xC0 };
string s = unix.GetString (data);
- AssertEquals ("Output-T3_Malformed_3_LastContinuationMissing_331", "\u0000\xC0", s);
- AssertEquals ("Reconverted-T3_Malformed_3_LastContinuationMissing_331",
- BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
+ Assert.AreEqual ("\u0000\xC0", s, "Output-T3_Malformed_3_LastContinuationMissing_331");
+ Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-T3_Malformed_3_LastContinuationMissing_331");
}
[Test]
{
byte[] data = { 0xF0, 0x80, 0x80 };
string s = unix.GetString (data);
- AssertEquals ("Output-T3_Malformed_3_LastContinuationMissing_333",
- "\u0000\xF0\u0000\x80\u0000\x80", s);
- AssertEquals ("Reconverted-T3_Malformed_3_LastContinuationMissing_333",
- BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
+ Assert.AreEqual ("\u0000\xF0\u0000\x80\u0000\x80", s, "Output-T3_Malformed_3_LastContinuationMissing_333");
+ Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-T3_Malformed_3_LastContinuationMissing_333");
}
[Test]
{
byte[] data = { 0xF8, 0x80, 0x80, 0x80 };
string s = unix.GetString (data);
- AssertEquals ("Output-T3_Malformed_3_LastContinuationMissing_334",
- "\u0000\xF8\u0000\x80\u0000\x80\u0000\x80", s);
- AssertEquals ("Reconverted-T3_Malformed_3_LastContinuationMissing_334",
- BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
+ Assert.AreEqual ("\u0000\xF8\u0000\x80\u0000\x80\u0000\x80", s, "Output-T3_Malformed_3_LastContinuationMissing_334");
+ Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-T3_Malformed_3_LastContinuationMissing_334");
}
[Test]
{
byte[] data = { 0xFC, 0x80, 0x80, 0x80, 0x80 };
string s = unix.GetString (data);
- AssertEquals ("Output-T3_Malformed_3_LastContinuationMissing_335",
- "\u0000\xFC\u0000\x80\u0000\x80\u0000\x80\u0000\x80", s);
- AssertEquals ("Reconverted-T3_Malformed_3_LastContinuationMissing_335",
- BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
+ Assert.AreEqual ("\u0000\xFC\u0000\x80\u0000\x80\u0000\x80\u0000\x80", s, "Output-T3_Malformed_3_LastContinuationMissing_335");
+ Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-T3_Malformed_3_LastContinuationMissing_335");
}
[Test]
{
byte[] data = { 0xDF };
string s = unix.GetString (data);
- AssertEquals ("Output-T3_Malformed_3_LastContinuationMissing_336",
- "\u0000\xDF", s);
- AssertEquals ("Reconverted-T3_Malformed_3_LastContinuationMissing_336",
- BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
+ Assert.AreEqual ("\u0000\xDF", s, "Output-T3_Malformed_3_LastContinuationMissing_336");
+ Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-T3_Malformed_3_LastContinuationMissing_336");
}
[Test]
{
byte[] data = { 0xEF, 0xBF };
string s = unix.GetString (data);
- AssertEquals ("Output-T3_Malformed_3_LastContinuationMissing_337",
- "\u0000\xEF\u0000\xBF", s);
- AssertEquals ("Reconverted-T3_Malformed_3_LastContinuationMissing_337",
- BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
+ Assert.AreEqual ("\u0000\xEF\u0000\xBF", s, "Output-T3_Malformed_3_LastContinuationMissing_337");
+ Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-T3_Malformed_3_LastContinuationMissing_337");
}
[Test]
{
byte[] data = { 0xF7, 0xBF, 0xBF };
string s = unix.GetString (data);
- AssertEquals ("Output-T3_Malformed_3_LastContinuationMissing_338",
- "\u0000\xF7\u0000\xBF\u0000\xBF", s);
- AssertEquals ("Reconverted-T3_Malformed_3_LastContinuationMissing_338",
- BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
+ Assert.AreEqual ("\u0000\xF7\u0000\xBF\u0000\xBF", s, "Output-T3_Malformed_3_LastContinuationMissing_338");
+ Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-T3_Malformed_3_LastContinuationMissing_338");
}
[Test]
{
byte[] data = { 0xF, 0xBF, 0xBF, 0xBF };
string s = unix.GetString (data);
- AssertEquals ("Output-339",
- "\xF\u0000\xBF\u0000\xBF\u0000\xBF", s);
- AssertEquals ("Reconverted-339", BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
+ Assert.AreEqual ("\xF\u0000\xBF\u0000\xBF\u0000\xBF", s, "Output-339");
+ Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-339");
}
[Test]
{
byte[] data = { 0xFD, 0xBF, 0xBF, 0xBF, 0xBF };
string s = unix.GetString (data);
- AssertEquals ("Output-3310",
- "\u0000\xFD\u0000\xBF\u0000\xBF\u0000\xBF\u0000\xBF", s);
- AssertEquals ("Reconverted-3310", BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
+ Assert.AreEqual ("\u0000\xFD\u0000\xBF\u0000\xBF\u0000\xBF\u0000\xBF", s, "Output-3310");
+ Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-3310");
}
[Test]
0xC0, 0xE0, 0x80, 0xF0, 0x80, 0x80, 0xF8, 0x80, 0x80, 0x80, 0xFC, 0x80, 0x80, 0x80, 0x80, 0xDF,
0xEF, 0xBF, 0xF7, 0xBF, 0xBF, 0xFB, 0xBF, 0xBF, 0xBF, 0xFD, 0xBF, 0xBF, 0xBF, 0xBF };
string s = unix.GetString (data);
- AssertEquals ("Output-T3_Malformed_4_ConcatenationImcomplete",
- "\u0000\xC0\u0000\xE0\u0000\x80\u0000\xF0\u0000\x80\u0000\x80\u0000\xF8\u0000\x80" +
+ Assert.AreEqual ("\u0000\xC0\u0000\xE0\u0000\x80\u0000\xF0\u0000\x80\u0000\x80\u0000\xF8\u0000\x80" +
"\u0000\x80\u0000\x80\u0000\xFC\u0000\x80\u0000\x80\u0000\x80\u0000\x80\u0000\xDF" +
"\u0000\xEF\u0000\xBF\u0000\xF7\u0000\xBF\u0000\xBF\u0000\xFB\u0000\xBF\u0000\xBF" +
"\u0000\xBF\u0000\xFD\u0000\xBF\u0000\xBF\u0000\xBF\u0000\xBF",
- s);
- AssertEquals ("Reconverted-T3_Malformed_4_ConcatenationImcomplete", BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
+ s, "Output-T3_Malformed_4_ConcatenationImcomplete");
+ Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-T3_Malformed_4_ConcatenationImcomplete");
}
[Test]
{
byte[] data = { 0xFE };
string s = unix.GetString (data);
- AssertEquals ("Output-351", "\u0000\xFE", s);
- AssertEquals ("Reconverted-351", BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
+ Assert.AreEqual ("\u0000\xFE", s, "Output-351");
+ Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-351");
}
[Test]
{
byte[] data = { 0xFF };
string s = unix.GetString (data);
- AssertEquals ("Output-352", "\u0000\xFF", s);
- AssertEquals ("Reconverted-352", BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
+ Assert.AreEqual ("\u0000\xFF", s, "Output-352");
+ Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-352");
}
[Test]
{
byte[] data = { 0xFE, 0xFE, 0xFF, 0xFF };
string s = unix.GetString (data);
- AssertEquals ("Output-352", "\u0000\xFE\u0000\xFE\u0000\xFF\u0000\xFF", s);
- AssertEquals ("Reconverted-352", BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
+ Assert.AreEqual ("\u0000\xFE\u0000\xFE\u0000\xFF\u0000\xFF", s, "Output-352");
+ Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-352");
}
// Overlong == dangereous -> "safe" decoder should reject them
{
byte[] data = { 0xC0, 0xAF };
string s = unix.GetString (data);
- AssertEquals ("Output-T4_Overlong_1_ASCII_Slash_411",
- "\u0000\xC0\u0000\xAF", s);
- AssertEquals ("Reconverted-T4_Overlong_1_ASCII_Slash_411", BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
+ Assert.AreEqual ("\u0000\xC0\u0000\xAF", s, "Output-T4_Overlong_1_ASCII_Slash_411");
+ Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-T4_Overlong_1_ASCII_Slash_411");
}
[Test]
{
byte[] data = { 0xE0, 0x80, 0xAF };
string s = unix.GetString (data);
- AssertEquals ("Output-T4_Overlong_1_ASCII_Slash_413",
- "\u0000\xE0\u0000\x80\u0000\xAF", s);
- AssertEquals ("Reconverted-T4_Overlong_1_ASCII_Slash_413", BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
+ Assert.AreEqual ("\u0000\xE0\u0000\x80\u0000\xAF", s, "Output-T4_Overlong_1_ASCII_Slash_413");
+ Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-T4_Overlong_1_ASCII_Slash_413");
}
[Test]
{
byte[] data = { 0xF0, 0x80, 0x80, 0xAF };
string s = unix.GetString (data);
- AssertEquals ("Output-T4_Overlong_1_ASCII_Slash_412",
- "\u0000\xF0\u0000\x80\u0000\x80\u0000\xAF", s);
- AssertEquals ("Reconverted-T4_Overlong_1_ASCII_Slash_412", BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
+ Assert.AreEqual ("\u0000\xF0\u0000\x80\u0000\x80\u0000\xAF", s, "Output-T4_Overlong_1_ASCII_Slash_412");
+ Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-T4_Overlong_1_ASCII_Slash_412");
}
[Test]
{
byte[] data = { 0xF8, 0x80, 0x80, 0x80, 0xAF };
string s = unix.GetString (data);
- AssertEquals ("Output-T4_Overlong_1_ASCII_Slash_414",
- "\u0000\xF8\u0000\x80\u0000\x80\u0000\x80\u0000\xAF", s);
- AssertEquals ("Reconverted-T4_Overlong_1_ASCII_Slash_414", BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
+ Assert.AreEqual ("\u0000\xF8\u0000\x80\u0000\x80\u0000\x80\u0000\xAF", s, "Output-T4_Overlong_1_ASCII_Slash_414");
+ Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-T4_Overlong_1_ASCII_Slash_414");
}
[Test]
{
byte[] data = { 0xFC, 0x80, 0x80, 0x80, 0x80, 0xAF };
string s = unix.GetString (data);
- AssertEquals ("Output-T4_Overlong_1_ASCII_Slash_415",
- "\u0000\xFC\u0000\x80\u0000\x80\u0000\x80\u0000\x80\u0000\xAF", s);
- AssertEquals ("Reconverted-T4_Overlong_1_ASCII_Slash_415", BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
+ Assert.AreEqual ("\u0000\xFC\u0000\x80\u0000\x80\u0000\x80\u0000\x80\u0000\xAF", s, "Output-T4_Overlong_1_ASCII_Slash_415");
+ Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-T4_Overlong_1_ASCII_Slash_415");
}
[Test]
{
byte[] data = { 0xC1, 0xBF };
string s = unix.GetString (data);
- AssertEquals ("Output-T4_Overlong_2_MaximumBoundary_421",
- "\u0000\xC1\u0000\xBF", s);
- AssertEquals ("Reconverted-T4_Overlong_2_MaximumBoundary_421", BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
+ Assert.AreEqual ("\u0000\xC1\u0000\xBF", s, "Output-T4_Overlong_2_MaximumBoundary_421");
+ Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-T4_Overlong_2_MaximumBoundary_421");
}
[Test]
{
byte[] data = { 0xE0, 0x9F, 0xBF };
string s = unix.GetString (data);
- AssertEquals ("Output-T4_Overlong_2_MaximumBoundary_422",
- "\u0000\xE0\u0000\x9F\u0000\xBF", s);
- AssertEquals ("Reconverted-T4_Overlong_2_MaximumBoundary_422", BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
+ Assert.AreEqual ("\u0000\xE0\u0000\x9F\u0000\xBF", s, "Output-T4_Overlong_2_MaximumBoundary_422");
+ Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-T4_Overlong_2_MaximumBoundary_422");
}
[Test]
{
byte[] data = { 0xF0, 0x8F, 0xBF, 0xBF };
string s = unix.GetString (data);
- AssertEquals ("Output-T4_Overlong_2_MaximumBoundary_423",
- "\u0000\xF0\u0000\x8F\u0000\xBF\u0000\xBF", s);
- AssertEquals ("Reconverted-T4_Overlong_2_MaximumBoundary_423", BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
+ Assert.AreEqual ("\u0000\xF0\u0000\x8F\u0000\xBF\u0000\xBF", s, "Output-T4_Overlong_2_MaximumBoundary_423");
+ Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-T4_Overlong_2_MaximumBoundary_423");
}
[Test]
{
byte[] data = { 0xF8, 0x87, 0xBF, 0xBF, 0xBF };
string s = unix.GetString (data);
- AssertEquals ("Output-T4_Overlong_2_MaximumBoundary_424",
- "\u0000\xF8\u0000\x87\u0000\xBF\u0000\xBF\u0000\xBF", s);
- AssertEquals ("Reconverted-T4_Overlong_2_MaximumBoundary_424", BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
+ Assert.AreEqual ("\u0000\xF8\u0000\x87\u0000\xBF\u0000\xBF\u0000\xBF", s, "Output-T4_Overlong_2_MaximumBoundary_424");
+ Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-T4_Overlong_2_MaximumBoundary_424");
}
[Test]
{
byte[] data = { 0xFC, 0x83, 0xBF, 0xBF, 0xBF, 0xBF };
string s = unix.GetString (data);
- AssertEquals ("Output-T4_Overlong_2_MaximumBoundary_425",
- "\u0000\xFC\u0000\x83\u0000\xBF\u0000\xBF\u0000\xBF\u0000\xBF", s);
- AssertEquals ("Reconverted-T4_Overlong_2_MaximumBoundary_425", BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
+ Assert.AreEqual ("\u0000\xFC\u0000\x83\u0000\xBF\u0000\xBF\u0000\xBF\u0000\xBF", s, "Output-T4_Overlong_2_MaximumBoundary_425");
+ Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-T4_Overlong_2_MaximumBoundary_425");
}
[Test]
{
byte[] data = { 0xC0, 0x80 };
string s = unix.GetString (data);
- AssertEquals ("Output-T4_Overlong_3_NUL_431",
- "\u0000\xC0\u0000\x80", s);
- AssertEquals ("Reconverted-T4_Overlong_3_NUL_431", BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
+ Assert.AreEqual ("\u0000\xC0\u0000\x80", s, "Output-T4_Overlong_3_NUL_431");
+ Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-T4_Overlong_3_NUL_431");
}
[Test]
{
byte[] data = { 0xE0, 0x80, 0x80 };
string s = unix.GetString (data);
- AssertEquals ("Output-T4_Overlong_3_NUL_432",
- "\u0000\xE0\u0000\x80\u0000\x80", s);
- AssertEquals ("Reconverted-T4_Overlong_3_NUL_432", BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
+ Assert.AreEqual ("\u0000\xE0\u0000\x80\u0000\x80", s, "Output-T4_Overlong_3_NUL_432");
+ Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-T4_Overlong_3_NUL_432");
}
[Test]
{
byte[] data = { 0xF0, 0x80, 0x80, 0x80 };
string s = unix.GetString (data);
- AssertEquals ("Output-T4_Overlong_3_NUL_433",
- "\u0000\xF0\u0000\x80\u0000\x80\u0000\x80", s);
- AssertEquals ("Reconverted-T4_Overlong_3_NUL_433", BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
+ Assert.AreEqual ("\u0000\xF0\u0000\x80\u0000\x80\u0000\x80", s, "Output-T4_Overlong_3_NUL_433");
+ Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-T4_Overlong_3_NUL_433");
}
[Test]
{
byte[] data = { 0xF8, 0x80, 0x80, 0x80, 0x80 };
string s = unix.GetString (data);
- AssertEquals ("Output-T4_Overlong_3_NUL_434",
- "\u0000\xF8\u0000\x80\u0000\x80\u0000\x80\u0000\x80", s);
- AssertEquals ("Reconverted-T4_Overlong_3_NUL_434", BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
+ Assert.AreEqual ("\u0000\xF8\u0000\x80\u0000\x80\u0000\x80\u0000\x80", s, "Output-T4_Overlong_3_NUL_434");
+ Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-T4_Overlong_3_NUL_434");
}
[Test]
{
byte[] data = { 0xFC, 0x80, 0x80, 0x80, 0x80, 0x80 };
string s = unix.GetString (data);
- AssertEquals ("Output-T4_Overlong_3_NUL_434",
- "\u0000\xFC\u0000\x80\u0000\x80\u0000\x80\u0000\x80\u0000\x80", s);
- AssertEquals ("Reconverted-T4_Overlong_3_NUL_434", BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
+ Assert.AreEqual ("\u0000\xFC\u0000\x80\u0000\x80\u0000\x80\u0000\x80\u0000\x80", s, "Output-T4_Overlong_3_NUL_434");
+ Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-T4_Overlong_3_NUL_434");
}
[Test]
byte[] data = { 0xED, 0xA0, 0x80 };
string s = unix.GetString (data);
// exception is "really" expected here
- AssertEquals ("MS FX 1.1 behaviour", 55296, s [0]);
+ Assert.AreEqual (55296, s [0], "MS FX 1.1 behaviour");
}
[Test]
byte[] data = { 0xED, 0xAD, 0xBF };
string s = unix.GetString (data);
// exception is "really" expected here
- AssertEquals ("MS FX 1.1 behaviour", 56191, s [0]);
+ Assert.AreEqual (56191, s [0], "MS FX 1.1 behaviour");
}
[Test]
byte[] data = { 0xED, 0xAE, 0x80 };
string s = unix.GetString (data);
// exception is "really" expected here
- AssertEquals ("MS FX 1.1 behaviour", 56192, s [0]);
+ Assert.AreEqual (56192, s [0], "MS FX 1.1 behaviour");
}
[Test]
byte[] data = { 0xED, 0xAF, 0xBF };
string s = unix.GetString (data);
// exception is "really" expected here
- AssertEquals ("MS FX 1.1 behaviour", 56319, s [0]);
+ Assert.AreEqual (56319, s [0], "MS FX 1.1 behaviour");
}
[Test]
byte[] data = { 0xED, 0xB0, 0x80 };
string s = unix.GetString (data);
// exception is "really" expected here
- AssertEquals ("MS FX 1.1 behaviour", 56320, s [0]);
+ Assert.AreEqual (56320, s [0], "MS FX 1.1 behaviour");
}
[Test]
byte[] data = { 0xED, 0xBE, 0x80 };
string s = unix.GetString (data);
// exception is "really" expected here
- AssertEquals ("MS FX 1.1 behaviour", 57216, s [0]);
+ Assert.AreEqual (57216, s [0], "MS FX 1.1 behaviour");
}
[Test]
byte[] data = { 0xED, 0xBF, 0xBF };
string s = unix.GetString (data);
// exception is "really" expected here
- AssertEquals ("MS FX 1.1 behaviour", 57343, s [0]);
+ Assert.AreEqual (57343, s [0], "MS FX 1.1 behaviour");
}
[Test]
byte[] data = { 0xED, 0xA0, 0x80, 0xED, 0xB0, 0x80 };
string s = unix.GetString (data);
// exception is "really" expected here
- AssertEquals ("MS FX 1.1 behaviour", 55296, s [0]);
- AssertEquals ("MS FX 1.1 behaviour", 56320, s [1]);
+ Assert.AreEqual (55296, s [0], "MS FX 1.1 behaviour");
+ Assert.AreEqual (56320, s [1], "MS FX 1.1 behaviour");
}
[Test]
byte[] data = { 0xED, 0xA0, 0x80, 0xED, 0xBF, 0xBF };
string s = unix.GetString (data);
// exception is "really" expected here
- AssertEquals ("MS FX 1.1 behaviour", 55296, s [0]);
- AssertEquals ("MS FX 1.1 behaviour", 57343, s [1]);
+ Assert.AreEqual (55296, s [0], "MS FX 1.1 behaviour");
+ Assert.AreEqual (57343, s [1], "MS FX 1.1 behaviour");
}
[Test]
byte[] data = { 0xED, 0xAD, 0xBF, 0xED, 0xB0, 0x80 };
string s = unix.GetString (data);
// exception is "really" expected here
- AssertEquals ("MS FX 1.1 behaviour", 56191, s [0]);
- AssertEquals ("MS FX 1.1 behaviour", 56320, s [1]);
+ Assert.AreEqual (56191, s [0], "MS FX 1.1 behaviour");
+ Assert.AreEqual (56320, s [1], "MS FX 1.1 behaviour");
}
[Test]
byte[] data = { 0xED, 0xAD, 0xBF, 0xED, 0xBF, 0xBF };
string s = unix.GetString (data);
// exception is "really" expected here
- AssertEquals ("MS FX 1.1 behaviour", 56191, s [0]);
- AssertEquals ("MS FX 1.1 behaviour", 57343, s [1]);
+ Assert.AreEqual (56191, s [0], "MS FX 1.1 behaviour");
+ Assert.AreEqual (57343, s [1], "MS FX 1.1 behaviour");
}
[Test]
byte[] data = { 0xED, 0xAE, 0x80, 0xED, 0xB0, 0x80 };
string s = unix.GetString (data);
// exception is "really" expected here
- AssertEquals ("MS FX 1.1 behaviour", 56192, s [0]);
- AssertEquals ("MS FX 1.1 behaviour", 56320, s [1]);
+ Assert.AreEqual (56192, s [0], "MS FX 1.1 behaviour");
+ Assert.AreEqual (56320, s [1], "MS FX 1.1 behaviour");
}
[Test]
byte[] data = { 0xED, 0xAE, 0x80, 0xED, 0xBF, 0x8F };
string s = unix.GetString (data);
// exception is "really" expected here
- AssertEquals ("MS FX 1.1 behaviour", 56192, s [0]);
- AssertEquals ("MS FX 1.1 behaviour", 57295, s [1]);
+ Assert.AreEqual (56192, s [0], "MS FX 1.1 behaviour");
+ Assert.AreEqual (57295, s [1], "MS FX 1.1 behaviour");
}
[Test]
byte[] data = { 0xED, 0xAF, 0xBF, 0xED, 0xB0, 0x80 };
string s = unix.GetString (data);
// exception is "really" expected here
- AssertEquals ("MS FX 1.1 behaviour", 56319, s [0]);
- AssertEquals ("MS FX 1.1 behaviour", 56320, s [1]);
+ Assert.AreEqual (56319, s [0], "MS FX 1.1 behaviour");
+ Assert.AreEqual (56320, s [1], "MS FX 1.1 behaviour");
}
[Test]
byte[] data = { 0xED, 0xAF, 0xBF, 0xED, 0xBF, 0xBF };
string s = unix.GetString (data);
// exception is "really" expected here
- AssertEquals ("MS FX 1.1 behaviour", 56319, s [0]);
- AssertEquals ("MS FX 1.1 behaviour", 57343, s [1]);
+ Assert.AreEqual (56319, s [0], "MS FX 1.1 behaviour");
+ Assert.AreEqual (57343, s [1], "MS FX 1.1 behaviour");
}
[Test]
byte[] data = { 0xEF, 0xBF, 0xBE };
string s = unix.GetString (data);
// exception is "really" expected here
- AssertEquals ("MS FX 1.1 behaviour", 65534, s [0]);
+ Assert.AreEqual (65534, s [0], "MS FX 1.1 behaviour");
}
[Test]
byte[] data = { 0xEF, 0xBF, 0xBF };
string s = unix.GetString (data);
// exception is "really" expected here
- AssertEquals ("MS FX 1.1 behaviour", 65535, s [0]);
+ Assert.AreEqual (65535, s [0], "MS FX 1.1 behaviour");
}
[Test]
byte [] data = new byte [] {0xEF, 0xBB, 0xBF};
Encoding enc = new UnixEncoding ();
string s = enc.GetString (data);
- AssertEquals ("\uFEFF", s);
+ Assert.AreEqual (s, "\uFEFF");
Encoding utf = enc;
char[] testChars = {'\uFEFF','A'};
byte[] bytes = utf.GetBytes(testChars);
char[] chars = utf.GetChars(bytes);
- AssertEquals ("#1", '\uFEFF', chars [0]);
- AssertEquals ("#2", 'A', chars [1]);
+ Assert.AreEqual ('\uFEFF', chars [0], "#1");
+ Assert.AreEqual ('A', chars [1], "#2");
}
[Test]
{
byte[] bytes = unix.GetBytes (start);
- AssertEquals (prefix + ": byte length", end.Length, bytes.Length);
+ Assert.AreEqual (end.Length, bytes.Length, prefix + ": byte length");
- for (int i = 0; i < Math.Min (bytes.Length, end.Length); ++i)
- AssertEquals (prefix + ": byte " + i, end [i], bytes [i]);
+ for (int i = 0; i < global::System.Math.Min (bytes.Length, end.Length); ++i)
+ Assert.AreEqual (end [i], bytes [i], prefix + ": byte " + i);
int cc = unix.GetCharCount (end, 0, end.Length);
- AssertEquals (prefix + ": char count", start.Length, cc);
+ Assert.AreEqual (start.Length, cc, prefix + ": char count");
char[] chars = new char [cc];
int r = unix.GetChars (end, 0, end.Length, chars, 0);
- AssertEquals (prefix + ": chars length", start.Length, r);
+ Assert.AreEqual (start.Length, r, prefix + ": chars length");
- for (int i = 0; i < Math.Min (r, start.Length); ++i) {
- AssertEquals (prefix + ": char " + i, start [i], chars [i]);
+ for (int i = 0; i < global::System.Math.Min (r, start.Length); ++i) {
+ Assert.AreEqual (start [i], chars [i], prefix + ": char " + i);
}
}
}
projects / mono.git / blobdiff