1 // 2 // UnixEncodingTest.cs - NUnit Test Cases for Mono.Unix.UnixEncoding 3 // 4 // Authors: 5 // Patrick Kalkman kalkman@cistron.nl 6 // Sebastien Pouliot (spouliot@motus.com) 7 // Jonathan Pryor <jonpryor@vt.edu> 8 // 9 // (C) 2003 Patrick Kalkman 10 // (C) 2004 Novell (http://www.novell.com) 11 // (C) 2005 Jonathan Pryor 12 // 13 14 using NUnit.Framework; 15 using System; 16 using System.Text; 17 using Mono.Unix; 18 19 namespace MonoTests.Mono.Unix { 20 21 [TestFixture] 22 public class UnixEncodingTest { 23 24 private UnixEncoding unix; 25 26 [SetUp] Create()27 public void Create () 28 { 29 unix = new UnixEncoding (); 30 } 31 32 [Test] TestEncodingGetBytes1()33 public void TestEncodingGetBytes1() 34 { 35 UnixEncoding unixEnc = new UnixEncoding (); 36 string UniCode = "\u0041\u2262\u0391\u002E"; 37 38 // "A<NOT IDENTICAL TO><ALPHA>." may be encoded as 41 E2 89 A2 CE 91 2E 39 // see (RFC 2044) 40 byte[] unixBytes = unixEnc.GetBytes (UniCode); 41 42 Assert.AreEqual (0x41, unixBytes [0], "UTF #1"); 43 Assert.AreEqual (0xE2, unixBytes [1], "UTF #2"); 44 Assert.AreEqual (0x89, unixBytes [2], "UTF #3"); 45 Assert.AreEqual (0xA2, unixBytes [3], "UTF #4"); 46 Assert.AreEqual (0xCE, unixBytes [4], "UTF #5"); 47 Assert.AreEqual (0x91, unixBytes [5], "UTF #6"); 48 Assert.AreEqual (0x2E, unixBytes [6], "UTF #7"); 49 } 50 51 [Test] TestEncodingGetBytes2()52 public void TestEncodingGetBytes2() 53 { 54 UnixEncoding unixEnc = new UnixEncoding (); 55 string UniCode = "\u0048\u0069\u0020\u004D\u006F\u006D\u0020\u263A\u0021"; 56 57 // "Hi Mom <WHITE SMILING FACE>!" may be encoded as 48 69 20 4D 6F 6D 20 E2 98 BA 21 58 // see (RFC 2044) 59 byte[] unixBytes = new byte [11]; 60 61 int ByteCnt = unixEnc.GetBytes (UniCode.ToCharArray(), 0, UniCode.Length, unixBytes, 0); 62 63 Assert.AreEqual (11, ByteCnt, "UTF #1"); 64 Assert.AreEqual (0x48, unixBytes [0], "UTF #2"); 65 Assert.AreEqual (0x69, unixBytes [1], "UTF #3"); 66 Assert.AreEqual (0x20, unixBytes [2], "UTF #4"); 67 Assert.AreEqual (0x4D, unixBytes [3], "UTF #5"); 68 Assert.AreEqual (0x6F, unixBytes [4], "UTF #6"); 69 Assert.AreEqual (0x6D, unixBytes [5], "UTF #7"); 70 Assert.AreEqual (0x20, unixBytes [6], "UTF #8"); 71 Assert.AreEqual (0xE2, unixBytes [7], "UTF #9"); 72 Assert.AreEqual (0x98, unixBytes [8], "UTF #10"); 73 Assert.AreEqual (0xBA, unixBytes [9], "UTF #11"); 74 Assert.AreEqual (0x21, unixBytes [10], "UTF #12"); 75 } 76 77 [Test] TestDecodingGetChars1()78 public void TestDecodingGetChars1() 79 { 80 UnixEncoding unixEnc = new UnixEncoding (); 81 // 41 E2 89 A2 CE 91 2E may be decoded as "A<NOT IDENTICAL TO><ALPHA>." 82 // see (RFC 2044) 83 byte[] unixBytes = new byte [] {0x41, 0xE2, 0x89, 0xA2, 0xCE, 0x91, 0x2E}; 84 char[] UniCodeChars = unixEnc.GetChars(unixBytes); 85 86 Assert.AreEqual (0x0041, UniCodeChars [0], "UTF #1"); 87 Assert.AreEqual (0x2262, UniCodeChars [1], "UTF #2"); 88 Assert.AreEqual (0x0391, UniCodeChars [2], "UTF #3"); 89 Assert.AreEqual (0x002E, UniCodeChars [3], "UTF #4"); 90 } 91 92 [Test] TestMaxCharCount()93 public void TestMaxCharCount() 94 { 95 UnixEncoding unixenc = new UnixEncoding (); 96 Assert.AreEqual (50, unixenc.GetMaxCharCount(50), "UTF #1"); 97 } 98 99 [Test] TestMaxByteCount()100 public void TestMaxByteCount() 101 { 102 UnixEncoding unixenc = new UnixEncoding (); 103 Assert.AreEqual (200, unixenc.GetMaxByteCount(50), "UTF #1"); 104 } 105 106 // regression for bug #59648 107 [Test] TestThrowOnInvalid()108 public void TestThrowOnInvalid () 109 { 110 UnixEncoding u = new UnixEncoding (); 111 112 byte[] data = new byte [] { 0xC0, 0xAF }; 113 string s = u.GetString (data); 114 Assert.AreEqual (4, s.Length); 115 Assert.AreEqual (0x0000, (int) s [0]); 116 Assert.AreEqual (0xC0, (int) s [1]); 117 Assert.AreEqual (0x0000, (int) s [2]); 118 Assert.AreEqual (0xAF, (int) s [3]); 119 Assert.AreEqual ("\u0000\xC0\u0000\xAF", s, "Output-TestThrowOnInvalid"); 120 Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-TestThrowOnInvalid"); 121 122 data = new byte [] { 0x30, 0x31, 0xC0, 0xAF, 0x30, 0x32 }; 123 s = u.GetString (data); 124 Assert.AreEqual (8, s.Length); 125 Assert.AreEqual (0x30, (int) s [0]); 126 Assert.AreEqual (0x31, (int) s [1]); 127 Assert.AreEqual (0x0000, (int) s [2]); 128 Assert.AreEqual (0xC0, (int) s [3]); 129 Assert.AreEqual (0x0000, (int) s [4]); 130 Assert.AreEqual (0xAF, (int) s [5]); 131 Assert.AreEqual (0x30, (int) s [6]); 132 Assert.AreEqual (0x32, (int) s [7]); 133 134 Assert.AreEqual ("\x30\x31\u0000\xC0\u0000\xAF\x30\x32", s, "Output-TestThrowOnInvalid2"); 135 Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-TestThrowOnInvalid2"); 136 } 137 138 // unix decoding tests from http://www.cl.cam.ac.uk/~mgk25/ 139 140 [Test] T1_Correct_GreekWord_kosme()141 public void T1_Correct_GreekWord_kosme () 142 { 143 byte[] data = { 0xCE, 0xBA, 0xE1, 0xBD, 0xB9, 0xCF, 0x83, 0xCE, 0xBC, 0xCE, 0xB5 }; 144 string s = unix.GetString (data); 145 // cute but saving source code in unicode can be problematic 146 // so we just ensure we can re-encode this 147 Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted"); 148 } 149 150 [Test] T2_Boundary_1_FirstPossibleSequence_Pass()151 public void T2_Boundary_1_FirstPossibleSequence_Pass () 152 { 153 byte[] data211 = { 0x00 }; 154 string s = unix.GetString (data211); 155 Assert.AreEqual ("\0", s, "1 byte (U-00000000)"); 156 Assert.AreEqual (BitConverter.ToString (data211), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-1"); 157 158 byte[] data212 = { 0xC2, 0x80 }; 159 s = unix.GetString (data212); 160 Assert.AreEqual (128, s [0], "2 bytes (U-00000080)"); 161 Assert.AreEqual (BitConverter.ToString (data212), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-2"); 162 163 byte[] data213 = { 0xE0, 0xA0, 0x80 }; 164 s = unix.GetString (data213); 165 Assert.AreEqual (2048, s [0], "3 bytes (U-00000800)"); 166 Assert.AreEqual (BitConverter.ToString (data213), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-3"); 167 168 byte[] data214 = { 0xF0, 0x90, 0x80, 0x80 }; 169 s = unix.GetString (data214); 170 Assert.AreEqual (55296, s [0], "4 bytes (U-00010000)-0"); 171 Assert.AreEqual (56320, s [1], "4 bytes (U-00010000)-1"); 172 Assert.AreEqual (BitConverter.ToString (data214), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-4"); 173 } 174 175 [Test] T2_Boundary_1_FirstPossibleSequence_Fail_5()176 public void T2_Boundary_1_FirstPossibleSequence_Fail_5 () 177 { 178 byte[] data215 = { 0xF8, 0x88, 0x80, 0x80, 0x80 }; 179 string s = unix.GetString (data215); 180 Assert.AreEqual ("\u0000\xF8\u0000\x88\u0000\x80\u0000\x80\u0000\x80", s, "Output-5"); 181 Assert.AreEqual (BitConverter.ToString (data215), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-5"); 182 } 183 184 [Test] T2_Boundary_1_FirstPossibleSequence_Fail_6()185 public void T2_Boundary_1_FirstPossibleSequence_Fail_6 () 186 { 187 byte[] data216 = { 0xFC, 0x84, 0x80, 0x80, 0x80, 0x80 }; 188 string s = unix.GetString (data216); 189 Assert.AreEqual ("\u0000\xFC\u0000\x84\u0000\x80\u0000\x80\u0000\x80\u0000\x80", s, "Output-6"); 190 Assert.AreEqual (BitConverter.ToString (data216), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-6"); 191 } 192 193 [Test] T2_Boundary_2_LastPossibleSequence_Pass()194 public void T2_Boundary_2_LastPossibleSequence_Pass () 195 { 196 byte[] data221 = { 0x7F }; 197 string s = unix.GetString (data221); 198 Assert.AreEqual (127, s [0], "1 byte (U-0000007F)"); 199 Assert.AreEqual (BitConverter.ToString (data221), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-1"); 200 201 byte[] data222 = { 0xDF, 0xBF }; 202 s = unix.GetString (data222); 203 Assert.AreEqual (2047, s [0], "2 bytes (U-000007FF)"); 204 Assert.AreEqual (BitConverter.ToString (data222), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-2"); 205 206 byte[] data223 = { 0xEF, 0xBF, 0xBF }; 207 s = unix.GetString (data223); 208 Assert.AreEqual (65535, s [0], "3 bytes (U-0000FFFF)"); 209 Assert.AreEqual (BitConverter.ToString (data223), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-3"); 210 211 } 212 213 [Test] T2_Boundary_2_LastPossibleSequence_Fail_4()214 public void T2_Boundary_2_LastPossibleSequence_Fail_4 () 215 { 216 byte[] data224 = { 0x7F, 0xBF, 0xBF, 0xBF }; 217 string s = unix.GetString (data224); 218 Assert.AreEqual ("\x7F\u0000\xBF\u0000\xBF\u0000\xBF", s, "Output-4"); 219 Assert.AreEqual (BitConverter.ToString (data224), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-4"); 220 } 221 222 [Test] T2_Boundary_2_LastPossibleSequence_Fail_5()223 public void T2_Boundary_2_LastPossibleSequence_Fail_5 () 224 { 225 byte[] data225 = { 0xFB, 0xBF, 0xBF, 0xBF, 0xBF }; 226 string s = unix.GetString (data225); 227 Assert.AreEqual ("\u0000\xFB\u0000\xBF\u0000\xBF\u0000\xBF\u0000\xBF", s, "Output-5"); 228 Assert.AreEqual (BitConverter.ToString (data225), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-5"); 229 } 230 231 [Test] T2_Boundary_2_LastPossibleSequence_Fail_6()232 public void T2_Boundary_2_LastPossibleSequence_Fail_6 () 233 { 234 byte[] data226 = { 0xFD, 0xBF, 0xBF, 0xBF, 0xBF, 0xBF }; 235 string s = unix.GetString (data226); 236 Assert.AreEqual ("\u0000\xFD\u0000\xBF\u0000\xBF\u0000\xBF\u0000\xBF\u0000\xBF", s, "Output-6"); 237 Assert.AreEqual (BitConverter.ToString (data226), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-6"); 238 } 239 240 [Test] T2_Boundary_3_Other_Pass()241 public void T2_Boundary_3_Other_Pass () 242 { 243 byte[] data231 = { 0xED, 0x9F, 0xBF }; 244 string s = unix.GetString (data231); 245 Assert.AreEqual (55295, s [0], "U-0000D7FF"); 246 Assert.AreEqual (BitConverter.ToString (data231), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-1"); 247 248 byte[] data232 = { 0xEE, 0x80, 0x80 }; 249 s = unix.GetString (data232); 250 Assert.AreEqual (57344, s [0], "U-0000E000"); 251 Assert.AreEqual (BitConverter.ToString (data232), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-2"); 252 253 byte[] data233 = { 0xEF, 0xBF, 0xBD }; 254 s = unix.GetString (data233); 255 Assert.AreEqual (65533, s [0], "U-0000FFFD"); 256 Assert.AreEqual (BitConverter.ToString (data233), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-3"); 257 258 byte[] data234 = { 0xF4, 0x8F, 0xBF, 0xBF }; 259 s = unix.GetString (data234); 260 Assert.AreEqual (56319, s [0], "U-0010FFFF-0"); 261 Assert.AreEqual (57343, s [1], "U-0010FFFF-1"); 262 Assert.AreEqual (BitConverter.ToString (data234), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-4"); 263 } 264 265 [Test] T2_Boundary_3_Other_Fail_5()266 public void T2_Boundary_3_Other_Fail_5 () 267 { 268 byte[] data235 = { 0xF4, 0x90, 0x80, 0x80 }; 269 string s = unix.GetString (data235); 270 Assert.AreEqual ("\u0000\xF4\u0000\x90\u0000\x80\u0000\x80", s, "Output-5"); 271 Assert.AreEqual (BitConverter.ToString (data235), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-5"); 272 } 273 274 [Test] T3_Malformed_1_UnexpectedContinuation_311()275 public void T3_Malformed_1_UnexpectedContinuation_311 () 276 { 277 byte[] data = { 0x80 }; 278 string s = unix.GetString (data); 279 Assert.AreEqual ("\u0000\x80", s, "Output-311"); 280 Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-311"); 281 } 282 283 [Test] T3_Malformed_1_UnexpectedContinuation_312()284 public void T3_Malformed_1_UnexpectedContinuation_312 () 285 { 286 byte[] data = { 0xBF }; 287 string s = unix.GetString (data); 288 Assert.AreEqual ("\u0000\xBF", s, "Output-312"); 289 Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-313"); 290 } 291 292 [Test] T3_Malformed_1_UnexpectedContinuation_313()293 public void T3_Malformed_1_UnexpectedContinuation_313 () 294 { 295 byte[] data = { 0x80, 0xBF }; 296 string s = unix.GetString (data); 297 Assert.AreEqual ("\u0000\x80\u0000\xBF", s, "Output-313"); 298 Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-313"); 299 } 300 301 [Test] T3_Malformed_1_UnexpectedContinuation_314()302 public void T3_Malformed_1_UnexpectedContinuation_314 () 303 { 304 byte[] data = { 0x80, 0xBF, 0x80 }; 305 string s = unix.GetString (data); 306 Assert.AreEqual ("\u0000\x80\u0000\xBF\u0000\x80", s, "Output-314"); 307 Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-314"); 308 } 309 310 [Test] T3_Malformed_1_UnexpectedContinuation_315()311 public void T3_Malformed_1_UnexpectedContinuation_315 () 312 { 313 byte[] data = { 0x80, 0xBF, 0x80, 0xBF }; 314 string s = unix.GetString (data); 315 Assert.AreEqual ("\u0000\x80\u0000\xBF\u0000\x80\u0000\xBF", s, "Output-315"); 316 Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-315"); 317 } 318 319 [Test] T3_Malformed_1_UnexpectedContinuation_316()320 public void T3_Malformed_1_UnexpectedContinuation_316 () 321 { 322 byte[] data = { 0x80, 0xBF, 0x80, 0xBF, 0x80 }; 323 string s = unix.GetString (data); 324 Assert.AreEqual ("\u0000\x80\u0000\xBF\u0000\x80\u0000\xBF\u0000\x80", s, "Output-316"); 325 Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-316"); 326 } 327 328 [Test] T3_Malformed_1_UnexpectedContinuation_317()329 public void T3_Malformed_1_UnexpectedContinuation_317 () 330 { 331 byte[] data = { 0x80, 0xBF, 0x80, 0xBF, 0x80, 0xBF }; 332 string s = unix.GetString (data); 333 Assert.AreEqual ("\u0000\x80\u0000\xBF\u0000\x80\u0000\xBF\u0000\x80\u0000\xBF", s, "Output-317"); 334 Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-317"); 335 } 336 337 [Test] T3_Malformed_1_UnexpectedContinuation_318()338 public void T3_Malformed_1_UnexpectedContinuation_318 () 339 { 340 byte[] data = { 0x80, 0xBF, 0x80, 0xBF, 0x80, 0xBF, 0x80 }; 341 string s = unix.GetString (data); 342 Assert.AreEqual ("\u0000\x80\u0000\xBF\u0000\x80\u0000\xBF\u0000\x80\u0000\xBF\u0000\x80", s, "Output-318"); 343 Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-318"); 344 } 345 346 [Test] T3_Malformed_1_UnexpectedContinuation_319()347 public void T3_Malformed_1_UnexpectedContinuation_319 () 348 { 349 // 64 different continuation characters 350 byte[] data = { 351 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 352 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F, 353 0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF, 354 0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF }; 355 string s = unix.GetString (data); 356 Assert.AreEqual ("\u0000\x80\u0000\x81\u0000\x82\u0000\x83\u0000\x84\u0000\x85\u0000\x86\u0000\x87" + 357 "\u0000\x88\u0000\x89\u0000\x8A\u0000\x8B\u0000\x8C\u0000\x8D\u0000\x8E\u0000\x8F" + 358 "\u0000\x90\u0000\x91\u0000\x92\u0000\x93\u0000\x94\u0000\x95\u0000\x96\u0000\x97" + 359 "\u0000\x98\u0000\x99\u0000\x9A\u0000\x9B\u0000\x9C\u0000\x9D\u0000\x9E\u0000\x9F" + 360 "\u0000\xA0\u0000\xA1\u0000\xA2\u0000\xA3\u0000\xA4\u0000\xA5\u0000\xA6\u0000\xA7" + 361 "\u0000\xA8\u0000\xA9\u0000\xAA\u0000\xAB\u0000\xAC\u0000\xAD\u0000\xAE\u0000\xAF" + 362 "\u0000\xB0\u0000\xB1\u0000\xB2\u0000\xB3\u0000\xB4\u0000\xB5\u0000\xB6\u0000\xB7" + 363 "\u0000\xB8\u0000\xB9\u0000\xBA\u0000\xBB\u0000\xBC\u0000\xBD\u0000\xBE\u0000\xBF", 364 s, "Output-319"); 365 Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-319"); 366 } 367 368 [Test] T3_Malformed_2_LonelyStart_321()369 public void T3_Malformed_2_LonelyStart_321 () 370 { 371 byte[] data = { 372 0xC0, 0x20, 0xC1, 0x20, 0xC2, 0x20, 0xC3, 0x20, 0xC4, 0x20, 0xC5, 0x20, 0xC6, 0x20, 0xC7, 0x20, 373 0xC8, 0x20, 0xC9, 0x20, 0xCA, 0x20, 0xCB, 0x20, 0xCC, 0x20, 0xCD, 0x20, 0xCE, 0x20, 0xCF, 0x20, 374 0xD0, 0x20, 0xD1, 0x20, 0xD2, 0x20, 0xD3, 0x20, 0xD4, 0x20, 0xD5, 0x20, 0xD6, 0x20, 0xD7, 0x20, 375 0xD8, 0x20, 0xD9, 0x20, 0xDA, 0x20, 0xDB, 0x20, 0xDC, 0x20, 0xDD, 0x20, 0xDE, 0x20, 0xDF, 0x20 }; 376 string s = unix.GetString (data); 377 Assert.AreEqual ("\u0000\xC0 \u0000\xC1 \u0000\xC2 \u0000\xC3 \u0000\xC4 \u0000\xC5 \u0000\xC6 \u0000\xC7 " + 378 "\u0000\xC8 \u0000\xC9 \u0000\xCA \u0000\xCB \u0000\xCC \u0000\xCD \u0000\xCE \u0000\xCF " + 379 "\u0000\xD0 \u0000\xD1 \u0000\xD2 \u0000\xD3 \u0000\xD4 \u0000\xD5 \u0000\xD6 \u0000\xD7 " + 380 "\u0000\xD8 \u0000\xD9 \u0000\xDA \u0000\xDB \u0000\xDC \u0000\xDD \u0000\xDE \u0000\xDF ", 381 s, 382 "Output-T3_Malformed_2_LonelyStart_321"); 383 Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-T3_Malformed_2_LonelyStart_321"); 384 } 385 386 [Test] T3_Malformed_2_LonelyStart_322()387 public void T3_Malformed_2_LonelyStart_322 () 388 { 389 byte[] data = { 390 0xE0, 0x20, 0xE1, 0x20, 0xE2, 0x20, 0xE3, 0x20, 0xE4, 0x20, 0xE5, 0x20, 0xE6, 0x20, 0xE7, 0x20, 391 0xE8, 0x20, 0xE9, 0x20, 0xEA, 0x20, 0xEB, 0x20, 0xEC, 0x20, 0xED, 0x20, 0xEE, 0x20, 0xEF, 0x20 }; 392 string s = unix.GetString (data); 393 Assert.AreEqual ("\u0000\xE0 \u0000\xE1 \u0000\xE2 \u0000\xE3 \u0000\xE4 \u0000\xE5 \u0000\xE6 \u0000\xE7 " + 394 "\u0000\xE8 \u0000\xE9 \u0000\xEA \u0000\xEB \u0000\xEC \u0000\xED \u0000\xEE \u0000\xEF ", 395 s, 396 "Output-T3_Malformed_2_LonelyStart_322"); 397 Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-T3_Malformed_2_LonelyStart_322"); 398 } 399 400 [Test] T3_Malformed_2_LonelyStart_323()401 public void T3_Malformed_2_LonelyStart_323 () 402 { 403 byte[] data = { 0xF0, 0x20, 0xF1, 0x20, 0xF2, 0x20, 0xF3, 0x20, 0xF4, 0x20, 0xF5, 0x20, 0xF6, 0x20, 0xF7, 0x20 }; 404 string s = unix.GetString (data); 405 Assert.AreEqual ("\u0000\xF0 \u0000\xF1 \u0000\xF2 \u0000\xF3 \u0000\xF4 \u0000\xF5 \u0000\xF6 \u0000\xF7 ", 406 s, 407 "Output-T3_Malformed_2_LonelyStart_323"); 408 Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-T3_Malformed_2_LonelyStart_323"); 409 } 410 411 [Test] T3_Malformed_2_LonelyStart_324()412 public void T3_Malformed_2_LonelyStart_324 () 413 { 414 byte[] data = { 0xF0, 0x20, 0xF1, 0x20, 0xF2, 0x20, 0xF3, 0x20, 0xF4, 0x20, 0xF5, 0x20, 0xF6, 0x20, 0xF7, 0x20 }; 415 string s = unix.GetString (data); 416 Assert.AreEqual ("\u0000\xF0 \u0000\xF1 \u0000\xF2 \u0000\xF3 \u0000\xF4 \u0000\xF5 \u0000\xF6 \u0000\xF7 ", 417 s, 418 "Output-T3_Malformed_2_LonelyStart_324"); 419 Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-T3_Malformed_2_LonelyStart_324"); 420 } 421 422 [Test] T3_Malformed_2_LonelyStart_325()423 public void T3_Malformed_2_LonelyStart_325 () 424 { 425 byte[] data = { 0xFC, 0x20, 0xFD, 0x20 }; 426 string s = unix.GetString (data); 427 Assert.AreEqual ("\u0000\xFC \u0000\xFD ", s, "Output-T3_Malformed_2_LonelyStart_324"); 428 Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-T3_Malformed_2_LonelyStart_324"); 429 } 430 431 [Test] T3_Malformed_3_LastContinuationMissing_331()432 public void T3_Malformed_3_LastContinuationMissing_331 () 433 { 434 byte[] data = { 0xC0 }; 435 string s = unix.GetString (data); 436 Assert.AreEqual ("\u0000\xC0", s, "Output-T3_Malformed_3_LastContinuationMissing_331"); 437 Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-T3_Malformed_3_LastContinuationMissing_331"); 438 } 439 440 [Test] T3_Malformed_3_LastContinuationMissing_332()441 public void T3_Malformed_3_LastContinuationMissing_332 () 442 { 443 byte[] data = { 0xE0, 0x80 }; 444 string s = unix.GetString (data); 445 } 446 447 [Test] T3_Malformed_3_LastContinuationMissing_333()448 public void T3_Malformed_3_LastContinuationMissing_333 () 449 { 450 byte[] data = { 0xF0, 0x80, 0x80 }; 451 string s = unix.GetString (data); 452 Assert.AreEqual ("\u0000\xF0\u0000\x80\u0000\x80", s, "Output-T3_Malformed_3_LastContinuationMissing_333"); 453 Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-T3_Malformed_3_LastContinuationMissing_333"); 454 } 455 456 [Test] T3_Malformed_3_LastContinuationMissing_334()457 public void T3_Malformed_3_LastContinuationMissing_334 () 458 { 459 byte[] data = { 0xF8, 0x80, 0x80, 0x80 }; 460 string s = unix.GetString (data); 461 Assert.AreEqual ("\u0000\xF8\u0000\x80\u0000\x80\u0000\x80", s, "Output-T3_Malformed_3_LastContinuationMissing_334"); 462 Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-T3_Malformed_3_LastContinuationMissing_334"); 463 } 464 465 [Test] T3_Malformed_3_LastContinuationMissing_335()466 public void T3_Malformed_3_LastContinuationMissing_335 () 467 { 468 byte[] data = { 0xFC, 0x80, 0x80, 0x80, 0x80 }; 469 string s = unix.GetString (data); 470 Assert.AreEqual ("\u0000\xFC\u0000\x80\u0000\x80\u0000\x80\u0000\x80", s, "Output-T3_Malformed_3_LastContinuationMissing_335"); 471 Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-T3_Malformed_3_LastContinuationMissing_335"); 472 } 473 474 [Test] T3_Malformed_3_LastContinuationMissing_336()475 public void T3_Malformed_3_LastContinuationMissing_336 () 476 { 477 byte[] data = { 0xDF }; 478 string s = unix.GetString (data); 479 Assert.AreEqual ("\u0000\xDF", s, "Output-T3_Malformed_3_LastContinuationMissing_336"); 480 Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-T3_Malformed_3_LastContinuationMissing_336"); 481 } 482 483 [Test] T3_Malformed_3_LastContinuationMissing_337()484 public void T3_Malformed_3_LastContinuationMissing_337 () 485 { 486 byte[] data = { 0xEF, 0xBF }; 487 string s = unix.GetString (data); 488 Assert.AreEqual ("\u0000\xEF\u0000\xBF", s, "Output-T3_Malformed_3_LastContinuationMissing_337"); 489 Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-T3_Malformed_3_LastContinuationMissing_337"); 490 } 491 492 [Test] T3_Malformed_3_LastContinuationMissing_338()493 public void T3_Malformed_3_LastContinuationMissing_338 () 494 { 495 byte[] data = { 0xF7, 0xBF, 0xBF }; 496 string s = unix.GetString (data); 497 Assert.AreEqual ("\u0000\xF7\u0000\xBF\u0000\xBF", s, "Output-T3_Malformed_3_LastContinuationMissing_338"); 498 Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-T3_Malformed_3_LastContinuationMissing_338"); 499 } 500 501 [Test] T3_Malformed_3_LastContinuationMissing_339()502 public void T3_Malformed_3_LastContinuationMissing_339 () 503 { 504 byte[] data = { 0xF, 0xBF, 0xBF, 0xBF }; 505 string s = unix.GetString (data); 506 Assert.AreEqual ("\xF\u0000\xBF\u0000\xBF\u0000\xBF", s, "Output-339"); 507 Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-339"); 508 } 509 510 [Test] T3_Malformed_3_LastContinuationMissing_3310()511 public void T3_Malformed_3_LastContinuationMissing_3310 () 512 { 513 byte[] data = { 0xFD, 0xBF, 0xBF, 0xBF, 0xBF }; 514 string s = unix.GetString (data); 515 Assert.AreEqual ("\u0000\xFD\u0000\xBF\u0000\xBF\u0000\xBF\u0000\xBF", s, "Output-3310"); 516 Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-3310"); 517 } 518 519 [Test] T3_Malformed_4_ConcatenationImcomplete()520 public void T3_Malformed_4_ConcatenationImcomplete () 521 { 522 byte[] data = { 523 0xC0, 0xE0, 0x80, 0xF0, 0x80, 0x80, 0xF8, 0x80, 0x80, 0x80, 0xFC, 0x80, 0x80, 0x80, 0x80, 0xDF, 524 0xEF, 0xBF, 0xF7, 0xBF, 0xBF, 0xFB, 0xBF, 0xBF, 0xBF, 0xFD, 0xBF, 0xBF, 0xBF, 0xBF }; 525 string s = unix.GetString (data); 526 Assert.AreEqual ("\u0000\xC0\u0000\xE0\u0000\x80\u0000\xF0\u0000\x80\u0000\x80\u0000\xF8\u0000\x80" + 527 "\u0000\x80\u0000\x80\u0000\xFC\u0000\x80\u0000\x80\u0000\x80\u0000\x80\u0000\xDF" + 528 "\u0000\xEF\u0000\xBF\u0000\xF7\u0000\xBF\u0000\xBF\u0000\xFB\u0000\xBF\u0000\xBF" + 529 "\u0000\xBF\u0000\xFD\u0000\xBF\u0000\xBF\u0000\xBF\u0000\xBF", 530 s, "Output-T3_Malformed_4_ConcatenationImcomplete"); 531 Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-T3_Malformed_4_ConcatenationImcomplete"); 532 } 533 534 [Test] T3_Malformed_5_ImpossibleBytes_351()535 public void T3_Malformed_5_ImpossibleBytes_351 () 536 { 537 byte[] data = { 0xFE }; 538 string s = unix.GetString (data); 539 Assert.AreEqual ("\u0000\xFE", s, "Output-351"); 540 Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-351"); 541 } 542 543 [Test] T3_Malformed_5_ImpossibleBytes_352()544 public void T3_Malformed_5_ImpossibleBytes_352 () 545 { 546 byte[] data = { 0xFF }; 547 string s = unix.GetString (data); 548 Assert.AreEqual ("\u0000\xFF", s, "Output-352"); 549 Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-352"); 550 } 551 552 [Test] T3_Malformed_5_ImpossibleBytes_353()553 public void T3_Malformed_5_ImpossibleBytes_353 () 554 { 555 byte[] data = { 0xFE, 0xFE, 0xFF, 0xFF }; 556 string s = unix.GetString (data); 557 Assert.AreEqual ("\u0000\xFE\u0000\xFE\u0000\xFF\u0000\xFF", s, "Output-352"); 558 Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-352"); 559 } 560 561 // Overlong == dangereous -> "safe" decoder should reject them 562 563 [Test] T4_Overlong_1_ASCII_Slash_411()564 public void T4_Overlong_1_ASCII_Slash_411 () 565 { 566 byte[] data = { 0xC0, 0xAF }; 567 string s = unix.GetString (data); 568 Assert.AreEqual ("\u0000\xC0\u0000\xAF", s, "Output-T4_Overlong_1_ASCII_Slash_411"); 569 Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-T4_Overlong_1_ASCII_Slash_411"); 570 } 571 572 [Test] T4_Overlong_1_ASCII_Slash_412()573 public void T4_Overlong_1_ASCII_Slash_412 () 574 { 575 byte[] data = { 0xE0, 0x80, 0xAF }; 576 string s = unix.GetString (data); 577 Assert.AreEqual ("\u0000\xE0\u0000\x80\u0000\xAF", s, "Output-T4_Overlong_1_ASCII_Slash_413"); 578 Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-T4_Overlong_1_ASCII_Slash_413"); 579 } 580 581 [Test] T4_Overlong_1_ASCII_Slash_413()582 public void T4_Overlong_1_ASCII_Slash_413 () 583 { 584 byte[] data = { 0xF0, 0x80, 0x80, 0xAF }; 585 string s = unix.GetString (data); 586 Assert.AreEqual ("\u0000\xF0\u0000\x80\u0000\x80\u0000\xAF", s, "Output-T4_Overlong_1_ASCII_Slash_412"); 587 Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-T4_Overlong_1_ASCII_Slash_412"); 588 } 589 590 [Test] T4_Overlong_1_ASCII_Slash_414()591 public void T4_Overlong_1_ASCII_Slash_414 () 592 { 593 byte[] data = { 0xF8, 0x80, 0x80, 0x80, 0xAF }; 594 string s = unix.GetString (data); 595 Assert.AreEqual ("\u0000\xF8\u0000\x80\u0000\x80\u0000\x80\u0000\xAF", s, "Output-T4_Overlong_1_ASCII_Slash_414"); 596 Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-T4_Overlong_1_ASCII_Slash_414"); 597 } 598 599 [Test] T4_Overlong_1_ASCII_Slash_415()600 public void T4_Overlong_1_ASCII_Slash_415 () 601 { 602 byte[] data = { 0xFC, 0x80, 0x80, 0x80, 0x80, 0xAF }; 603 string s = unix.GetString (data); 604 Assert.AreEqual ("\u0000\xFC\u0000\x80\u0000\x80\u0000\x80\u0000\x80\u0000\xAF", s, "Output-T4_Overlong_1_ASCII_Slash_415"); 605 Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-T4_Overlong_1_ASCII_Slash_415"); 606 } 607 608 [Test] T4_Overlong_2_MaximumBoundary_421()609 public void T4_Overlong_2_MaximumBoundary_421 () 610 { 611 byte[] data = { 0xC1, 0xBF }; 612 string s = unix.GetString (data); 613 Assert.AreEqual ("\u0000\xC1\u0000\xBF", s, "Output-T4_Overlong_2_MaximumBoundary_421"); 614 Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-T4_Overlong_2_MaximumBoundary_421"); 615 } 616 617 [Test] T4_Overlong_2_MaximumBoundary_422()618 public void T4_Overlong_2_MaximumBoundary_422 () 619 { 620 byte[] data = { 0xE0, 0x9F, 0xBF }; 621 string s = unix.GetString (data); 622 Assert.AreEqual ("\u0000\xE0\u0000\x9F\u0000\xBF", s, "Output-T4_Overlong_2_MaximumBoundary_422"); 623 Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-T4_Overlong_2_MaximumBoundary_422"); 624 } 625 626 [Test] T4_Overlong_2_MaximumBoundary_423()627 public void T4_Overlong_2_MaximumBoundary_423 () 628 { 629 byte[] data = { 0xF0, 0x8F, 0xBF, 0xBF }; 630 string s = unix.GetString (data); 631 Assert.AreEqual ("\u0000\xF0\u0000\x8F\u0000\xBF\u0000\xBF", s, "Output-T4_Overlong_2_MaximumBoundary_423"); 632 Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-T4_Overlong_2_MaximumBoundary_423"); 633 } 634 635 [Test] T4_Overlong_2_MaximumBoundary_424()636 public void T4_Overlong_2_MaximumBoundary_424 () 637 { 638 byte[] data = { 0xF8, 0x87, 0xBF, 0xBF, 0xBF }; 639 string s = unix.GetString (data); 640 Assert.AreEqual ("\u0000\xF8\u0000\x87\u0000\xBF\u0000\xBF\u0000\xBF", s, "Output-T4_Overlong_2_MaximumBoundary_424"); 641 Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-T4_Overlong_2_MaximumBoundary_424"); 642 } 643 644 [Test] T4_Overlong_2_MaximumBoundary_425()645 public void T4_Overlong_2_MaximumBoundary_425 () 646 { 647 byte[] data = { 0xFC, 0x83, 0xBF, 0xBF, 0xBF, 0xBF }; 648 string s = unix.GetString (data); 649 Assert.AreEqual ("\u0000\xFC\u0000\x83\u0000\xBF\u0000\xBF\u0000\xBF\u0000\xBF", s, "Output-T4_Overlong_2_MaximumBoundary_425"); 650 Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-T4_Overlong_2_MaximumBoundary_425"); 651 } 652 653 [Test] T4_Overlong_3_NUL_431()654 public void T4_Overlong_3_NUL_431 () 655 { 656 byte[] data = { 0xC0, 0x80 }; 657 string s = unix.GetString (data); 658 Assert.AreEqual ("\u0000\xC0\u0000\x80", s, "Output-T4_Overlong_3_NUL_431"); 659 Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-T4_Overlong_3_NUL_431"); 660 } 661 662 [Test] T4_Overlong_3_NUL_432()663 public void T4_Overlong_3_NUL_432 () 664 { 665 byte[] data = { 0xE0, 0x80, 0x80 }; 666 string s = unix.GetString (data); 667 Assert.AreEqual ("\u0000\xE0\u0000\x80\u0000\x80", s, "Output-T4_Overlong_3_NUL_432"); 668 Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-T4_Overlong_3_NUL_432"); 669 } 670 671 [Test] T4_Overlong_3_NUL_433()672 public void T4_Overlong_3_NUL_433 () 673 { 674 byte[] data = { 0xF0, 0x80, 0x80, 0x80 }; 675 string s = unix.GetString (data); 676 Assert.AreEqual ("\u0000\xF0\u0000\x80\u0000\x80\u0000\x80", s, "Output-T4_Overlong_3_NUL_433"); 677 Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-T4_Overlong_3_NUL_433"); 678 } 679 680 [Test] T4_Overlong_3_NUL_434()681 public void T4_Overlong_3_NUL_434 () 682 { 683 byte[] data = { 0xF8, 0x80, 0x80, 0x80, 0x80 }; 684 string s = unix.GetString (data); 685 Assert.AreEqual ("\u0000\xF8\u0000\x80\u0000\x80\u0000\x80\u0000\x80", s, "Output-T4_Overlong_3_NUL_434"); 686 Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-T4_Overlong_3_NUL_434"); 687 } 688 689 [Test] T4_Overlong_3_NUL_435()690 public void T4_Overlong_3_NUL_435 () 691 { 692 byte[] data = { 0xFC, 0x80, 0x80, 0x80, 0x80, 0x80 }; 693 string s = unix.GetString (data); 694 Assert.AreEqual ("\u0000\xFC\u0000\x80\u0000\x80\u0000\x80\u0000\x80\u0000\x80", s, "Output-T4_Overlong_3_NUL_434"); 695 Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)), "Reconverted-T4_Overlong_3_NUL_434"); 696 } 697 698 [Test] 699 // MS Fx 1.1 accept this 700 // [ExpectedException (typeof (ArgumentException))] T5_IllegalCodePosition_1_UTF16Surrogates_511()701 public void T5_IllegalCodePosition_1_UTF16Surrogates_511 () 702 { 703 byte[] data = { 0xED, 0xA0, 0x80 }; 704 string s = unix.GetString (data); 705 // exception is "really" expected here 706 Assert.AreEqual (55296, s [0], "MS FX 1.1 behaviour"); 707 } 708 709 [Test] 710 // MS Fx 1.1 accept this 711 // [ExpectedException (typeof (ArgumentException))] T5_IllegalCodePosition_1_UTF16Surrogates_512()712 public void T5_IllegalCodePosition_1_UTF16Surrogates_512 () 713 { 714 byte[] data = { 0xED, 0xAD, 0xBF }; 715 string s = unix.GetString (data); 716 // exception is "really" expected here 717 Assert.AreEqual (56191, s [0], "MS FX 1.1 behaviour"); 718 } 719 720 [Test] 721 // MS Fx 1.1 accept this 722 // [ExpectedException (typeof (ArgumentException))] T5_IllegalCodePosition_1_UTF16Surrogates_513()723 public void T5_IllegalCodePosition_1_UTF16Surrogates_513 () 724 { 725 byte[] data = { 0xED, 0xAE, 0x80 }; 726 string s = unix.GetString (data); 727 // exception is "really" expected here 728 Assert.AreEqual (56192, s [0], "MS FX 1.1 behaviour"); 729 } 730 731 [Test] 732 // MS Fx 1.1 accept this 733 // [ExpectedException (typeof (ArgumentException))] T5_IllegalCodePosition_1_UTF16Surrogates_514()734 public void T5_IllegalCodePosition_1_UTF16Surrogates_514 () 735 { 736 byte[] data = { 0xED, 0xAF, 0xBF }; 737 string s = unix.GetString (data); 738 // exception is "really" expected here 739 Assert.AreEqual (56319, s [0], "MS FX 1.1 behaviour"); 740 } 741 742 [Test] 743 // MS Fx 1.1 accept this 744 // [ExpectedException (typeof (ArgumentException))] T5_IllegalCodePosition_1_UTF16Surrogates_515()745 public void T5_IllegalCodePosition_1_UTF16Surrogates_515 () 746 { 747 byte[] data = { 0xED, 0xB0, 0x80 }; 748 string s = unix.GetString (data); 749 // exception is "really" expected here 750 Assert.AreEqual (56320, s [0], "MS FX 1.1 behaviour"); 751 } 752 753 [Test] 754 // MS Fx 1.1 accept this 755 // [ExpectedException (typeof (ArgumentException))] T5_IllegalCodePosition_1_UTF16Surrogates_516()756 public void T5_IllegalCodePosition_1_UTF16Surrogates_516 () 757 { 758 byte[] data = { 0xED, 0xBE, 0x80 }; 759 string s = unix.GetString (data); 760 // exception is "really" expected here 761 Assert.AreEqual (57216, s [0], "MS FX 1.1 behaviour"); 762 } 763 764 [Test] 765 // MS Fx 1.1 accept this 766 // [ExpectedException (typeof (ArgumentException))] T5_IllegalCodePosition_1_UTF16Surrogates_517()767 public void T5_IllegalCodePosition_1_UTF16Surrogates_517 () 768 { 769 byte[] data = { 0xED, 0xBF, 0xBF }; 770 string s = unix.GetString (data); 771 // exception is "really" expected here 772 Assert.AreEqual (57343, s [0], "MS FX 1.1 behaviour"); 773 } 774 775 [Test] 776 // MS Fx 1.1 accept this 777 // [ExpectedException (typeof (ArgumentException))] T5_IllegalCodePosition_2_PairedUTF16Surrogates_521()778 public void T5_IllegalCodePosition_2_PairedUTF16Surrogates_521 () 779 { 780 byte[] data = { 0xED, 0xA0, 0x80, 0xED, 0xB0, 0x80 }; 781 string s = unix.GetString (data); 782 // exception is "really" expected here 783 Assert.AreEqual (55296, s [0], "MS FX 1.1 behaviour"); 784 Assert.AreEqual (56320, s [1], "MS FX 1.1 behaviour"); 785 } 786 787 [Test] 788 // MS Fx 1.1 accept this 789 // [ExpectedException (typeof (ArgumentException))] T5_IllegalCodePosition_2_PairedUTF16Surrogates_522()790 public void T5_IllegalCodePosition_2_PairedUTF16Surrogates_522 () 791 { 792 byte[] data = { 0xED, 0xA0, 0x80, 0xED, 0xBF, 0xBF }; 793 string s = unix.GetString (data); 794 // exception is "really" expected here 795 Assert.AreEqual (55296, s [0], "MS FX 1.1 behaviour"); 796 Assert.AreEqual (57343, s [1], "MS FX 1.1 behaviour"); 797 } 798 799 [Test] 800 // MS Fx 1.1 accept this 801 // [ExpectedException (typeof (ArgumentException))] T5_IllegalCodePosition_2_PairedUTF16Surrogates_523()802 public void T5_IllegalCodePosition_2_PairedUTF16Surrogates_523 () 803 { 804 byte[] data = { 0xED, 0xAD, 0xBF, 0xED, 0xB0, 0x80 }; 805 string s = unix.GetString (data); 806 // exception is "really" expected here 807 Assert.AreEqual (56191, s [0], "MS FX 1.1 behaviour"); 808 Assert.AreEqual (56320, s [1], "MS FX 1.1 behaviour"); 809 } 810 811 [Test] 812 // MS Fx 1.1 accept this 813 // [ExpectedException (typeof (ArgumentException))] T5_IllegalCodePosition_2_PairedUTF16Surrogates_524()814 public void T5_IllegalCodePosition_2_PairedUTF16Surrogates_524 () 815 { 816 byte[] data = { 0xED, 0xAD, 0xBF, 0xED, 0xBF, 0xBF }; 817 string s = unix.GetString (data); 818 // exception is "really" expected here 819 Assert.AreEqual (56191, s [0], "MS FX 1.1 behaviour"); 820 Assert.AreEqual (57343, s [1], "MS FX 1.1 behaviour"); 821 } 822 823 [Test] 824 // MS Fx 1.1 accept this 825 // [ExpectedException (typeof (ArgumentException))] T5_IllegalCodePosition_2_PairedUTF16Surrogates_525()826 public void T5_IllegalCodePosition_2_PairedUTF16Surrogates_525 () 827 { 828 byte[] data = { 0xED, 0xAE, 0x80, 0xED, 0xB0, 0x80 }; 829 string s = unix.GetString (data); 830 // exception is "really" expected here 831 Assert.AreEqual (56192, s [0], "MS FX 1.1 behaviour"); 832 Assert.AreEqual (56320, s [1], "MS FX 1.1 behaviour"); 833 } 834 835 [Test] 836 // MS Fx 1.1 accept this 837 // [ExpectedException (typeof (ArgumentException))] T5_IllegalCodePosition_2_PairedUTF16Surrogates_526()838 public void T5_IllegalCodePosition_2_PairedUTF16Surrogates_526 () 839 { 840 byte[] data = { 0xED, 0xAE, 0x80, 0xED, 0xBF, 0x8F }; 841 string s = unix.GetString (data); 842 // exception is "really" expected here 843 Assert.AreEqual (56192, s [0], "MS FX 1.1 behaviour"); 844 Assert.AreEqual (57295, s [1], "MS FX 1.1 behaviour"); 845 } 846 847 [Test] 848 // MS Fx 1.1 accept this 849 // [ExpectedException (typeof (ArgumentException))] T5_IllegalCodePosition_2_PairedUTF16Surrogates_527()850 public void T5_IllegalCodePosition_2_PairedUTF16Surrogates_527 () 851 { 852 byte[] data = { 0xED, 0xAF, 0xBF, 0xED, 0xB0, 0x80 }; 853 string s = unix.GetString (data); 854 // exception is "really" expected here 855 Assert.AreEqual (56319, s [0], "MS FX 1.1 behaviour"); 856 Assert.AreEqual (56320, s [1], "MS FX 1.1 behaviour"); 857 } 858 859 [Test] 860 // MS Fx 1.1 accept this 861 // [ExpectedException (typeof (ArgumentException))] T5_IllegalCodePosition_2_PairedUTF16Surrogates_528()862 public void T5_IllegalCodePosition_2_PairedUTF16Surrogates_528 () 863 { 864 byte[] data = { 0xED, 0xAF, 0xBF, 0xED, 0xBF, 0xBF }; 865 string s = unix.GetString (data); 866 // exception is "really" expected here 867 Assert.AreEqual (56319, s [0], "MS FX 1.1 behaviour"); 868 Assert.AreEqual (57343, s [1], "MS FX 1.1 behaviour"); 869 } 870 871 [Test] 872 // MS Fx 1.1 accept this 873 // [ExpectedException (typeof (ArgumentException))] T5_IllegalCodePosition_3_Other_531()874 public void T5_IllegalCodePosition_3_Other_531 () 875 { 876 byte[] data = { 0xEF, 0xBF, 0xBE }; 877 string s = unix.GetString (data); 878 // exception is "really" expected here 879 Assert.AreEqual (65534, s [0], "MS FX 1.1 behaviour"); 880 } 881 882 [Test] 883 // MS Fx 1.1 accept this 884 // [ExpectedException (typeof (ArgumentException))] T5_IllegalCodePosition_3_Other_532()885 public void T5_IllegalCodePosition_3_Other_532 () 886 { 887 byte[] data = { 0xEF, 0xBF, 0xBF }; 888 string s = unix.GetString (data); 889 // exception is "really" expected here 890 Assert.AreEqual (65535, s [0], "MS FX 1.1 behaviour"); 891 } 892 893 [Test] 894 // bug #75065 and #73086. GetCharsFEFF()895 public void GetCharsFEFF () 896 { 897 byte [] data = new byte [] {0xEF, 0xBB, 0xBF}; 898 Encoding enc = new UnixEncoding (); 899 string s = enc.GetString (data); 900 Assert.AreEqual (s, "\uFEFF"); 901 902 Encoding utf = enc; 903 char[] testChars = {'\uFEFF','A'}; 904 905 byte[] bytes = utf.GetBytes(testChars); 906 char[] chars = utf.GetChars(bytes); 907 Assert.AreEqual ('\uFEFF', chars [0], "#1"); 908 Assert.AreEqual ('A', chars [1], "#2"); 909 } 910 911 [Test] BinaryFilename()912 public void BinaryFilename () 913 { 914 Compare ("BinaryFilename", 915 "test\u0000\xffname", 916 new byte[]{ 917 (byte) 't', 918 (byte) 'e', 919 (byte) 's', 920 (byte) 't', 921 (byte) 0xff, 922 (byte) 'n', 923 (byte) 'a', 924 (byte) 'm', 925 (byte) 'e', 926 } 927 ); 928 } 929 930 [Test] SjisFilename()931 public void SjisFilename () 932 { 933 string fn = 934 "\u0000\x83\x4a\u0000\x83\u0000\x81\u0000\x83\x6e\u0000\x83\u0000\x81\u0000\x83\x6e.txt"; 935 Compare ("SjisFilename", 936 fn, 937 new byte[]{ 938 (byte) 0x83, 939 (byte) 0x4a, 940 (byte) 0x83, 941 (byte) 0x81, 942 (byte) 0x83, 943 (byte) 0x6e, 944 (byte) 0x83, 945 (byte) 0x81, 946 (byte) 0x83, 947 (byte) 0x6e, 948 (byte) 0x2e, 949 (byte) 0x74, 950 (byte) 0x78, 951 (byte) 0x74, 952 } 953 ); 954 } 955 956 [Test] SjisFilename2()957 public void SjisFilename2 () 958 { 959 string fn = 960 "\u0000\x83\x4a\u0000\x83\u0000\x81\u0000\x83\x6e\u0000\x83\u0000\x81\u0000\x83\x6e.txt"; 961 Compare ("SjisFilename2", 962 "/home/jon/" + fn + "/baz", 963 new byte[]{ 964 (byte) '/', 965 (byte) 'h', 966 (byte) 'o', 967 (byte) 'm', 968 (byte) 'e', 969 (byte) '/', 970 (byte) 'j', 971 (byte) 'o', 972 (byte) 'n', 973 (byte) '/', 974 975 (byte) 0x83, 976 (byte) 0x4a, 977 (byte) 0x83, 978 (byte) 0x81, 979 (byte) 0x83, 980 (byte) 0x6e, 981 (byte) 0x83, 982 (byte) 0x81, 983 (byte) 0x83, 984 (byte) 0x6e, 985 (byte) 0x2e, 986 (byte) 0x74, 987 (byte) 0x78, 988 (byte) 0x74, 989 990 (byte) '/', 991 (byte) 'b', 992 (byte) 'a', 993 (byte) 'z', 994 } 995 ); 996 } 997 Compare(string prefix, string start, byte[] end)998 private void Compare (string prefix, string start, byte[] end) 999 { 1000 byte[] bytes = unix.GetBytes (start); 1001 1002 Assert.AreEqual (end.Length, bytes.Length, prefix + ": byte length"); 1003 1004 for (int i = 0; i < global::System.Math.Min (bytes.Length, end.Length); ++i) 1005 Assert.AreEqual (end [i], bytes [i], prefix + ": byte " + i); 1006 1007 int cc = unix.GetCharCount (end, 0, end.Length); 1008 Assert.AreEqual (start.Length, cc, prefix + ": char count"); 1009 1010 char[] chars = new char [cc]; 1011 int r = unix.GetChars (end, 0, end.Length, chars, 0); 1012 1013 Assert.AreEqual (start.Length, r, prefix + ": chars length"); 1014 1015 for (int i = 0; i < global::System.Math.Min (r, start.Length); ++i) { 1016 Assert.AreEqual (start [i], chars [i], prefix + ": char " + i); 1017 } 1018 } 1019 } 1020 } 1021