2 // UnixEncodingTest.cs - NUnit Test Cases for Mono.Unix.UnixEncoding
5 // Patrick Kalkman kalkman@cistron.nl
6 // Sebastien Pouliot (spouliot@motus.com)
7 // Jonathan Pryor <jonpryor@vt.edu>
9 // (C) 2003 Patrick Kalkman
10 // (C) 2004 Novell (http://www.novell.com)
11 // (C) 2005 Jonathan Pryor
14 using NUnit.Framework;
19 namespace MonoTests.Mono.Unix {
22 public class UnixEncodingTest : Assertion {
24 private UnixEncoding unix;
29 unix = new UnixEncoding ();
33 public void TestEncodingGetBytes1()
35 UnixEncoding unixEnc = new UnixEncoding ();
36 string UniCode = "\u0041\u2262\u0391\u002E";
38 // "A<NOT IDENTICAL TO><ALPHA>." may be encoded as 41 E2 89 A2 CE 91 2E
40 byte[] unixBytes = unixEnc.GetBytes (UniCode);
42 Assertion.AssertEquals ("UTF #1", 0x41, unixBytes [0]);
43 Assertion.AssertEquals ("UTF #2", 0xE2, unixBytes [1]);
44 Assertion.AssertEquals ("UTF #3", 0x89, unixBytes [2]);
45 Assertion.AssertEquals ("UTF #4", 0xA2, unixBytes [3]);
46 Assertion.AssertEquals ("UTF #5", 0xCE, unixBytes [4]);
47 Assertion.AssertEquals ("UTF #6", 0x91, unixBytes [5]);
48 Assertion.AssertEquals ("UTF #7", 0x2E, unixBytes [6]);
52 public void TestEncodingGetBytes2()
54 UnixEncoding unixEnc = new UnixEncoding ();
55 string UniCode = "\u0048\u0069\u0020\u004D\u006F\u006D\u0020\u263A\u0021";
57 // "Hi Mom <WHITE SMILING FACE>!" may be encoded as 48 69 20 4D 6F 6D 20 E2 98 BA 21
59 byte[] unixBytes = new byte [11];
61 int ByteCnt = unixEnc.GetBytes (UniCode.ToCharArray(), 0, UniCode.Length, unixBytes, 0);
63 Assertion.AssertEquals ("UTF #1", 11, ByteCnt);
64 Assertion.AssertEquals ("UTF #2", 0x48, unixBytes [0]);
65 Assertion.AssertEquals ("UTF #3", 0x69, unixBytes [1]);
66 Assertion.AssertEquals ("UTF #4", 0x20, unixBytes [2]);
67 Assertion.AssertEquals ("UTF #5", 0x4D, unixBytes [3]);
68 Assertion.AssertEquals ("UTF #6", 0x6F, unixBytes [4]);
69 Assertion.AssertEquals ("UTF #7", 0x6D, unixBytes [5]);
70 Assertion.AssertEquals ("UTF #8", 0x20, unixBytes [6]);
71 Assertion.AssertEquals ("UTF #9", 0xE2, unixBytes [7]);
72 Assertion.AssertEquals ("UTF #10", 0x98, unixBytes [8]);
73 Assertion.AssertEquals ("UTF #11", 0xBA, unixBytes [9]);
74 Assertion.AssertEquals ("UTF #12", 0x21, unixBytes [10]);
78 public void TestDecodingGetChars1()
80 UnixEncoding unixEnc = new UnixEncoding ();
81 // 41 E2 89 A2 CE 91 2E may be decoded as "A<NOT IDENTICAL TO><ALPHA>."
83 byte[] unixBytes = new byte [] {0x41, 0xE2, 0x89, 0xA2, 0xCE, 0x91, 0x2E};
84 char[] UniCodeChars = unixEnc.GetChars(unixBytes);
86 Assertion.AssertEquals ("UTF #1", 0x0041, UniCodeChars [0]);
87 Assertion.AssertEquals ("UTF #2", 0x2262, UniCodeChars [1]);
88 Assertion.AssertEquals ("UTF #3", 0x0391, UniCodeChars [2]);
89 Assertion.AssertEquals ("UTF #4", 0x002E, UniCodeChars [3]);
93 public void TestMaxCharCount()
95 UnixEncoding unixenc = new UnixEncoding ();
96 Assertion.AssertEquals ("UTF #1", 50, unixenc.GetMaxCharCount(50));
100 public void TestMaxByteCount()
102 UnixEncoding unixenc = new UnixEncoding ();
103 Assertion.AssertEquals ("UTF #1", 200, unixenc.GetMaxByteCount(50));
106 // regression for bug #59648
108 public void TestThrowOnInvalid ()
110 UnixEncoding u = new UnixEncoding ();
112 byte[] data = new byte [] { 0xC0, 0xAF };
113 string s = u.GetString (data);
114 AssertEquals (4, s.Length);
115 AssertEquals (0x0000, (int) s [0]);
116 AssertEquals (0xC0, (int) s [1]);
117 AssertEquals (0x0000, (int) s [2]);
118 AssertEquals (0xAF, (int) s [3]);
119 AssertEquals ("Output-TestThrowOnInvalid", "\u0000\xC0\u0000\xAF", s);
120 AssertEquals ("Reconverted-TestThrowOnInvalid", BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
122 data = new byte [] { 0x30, 0x31, 0xC0, 0xAF, 0x30, 0x32 };
123 s = u.GetString (data);
124 AssertEquals (8, s.Length);
125 AssertEquals (0x30, (int) s [0]);
126 AssertEquals (0x31, (int) s [1]);
127 AssertEquals (0x0000, (int) s [2]);
128 AssertEquals (0xC0, (int) s [3]);
129 AssertEquals (0x0000, (int) s [4]);
130 AssertEquals (0xAF, (int) s [5]);
131 AssertEquals (0x30, (int) s [6]);
132 AssertEquals (0x32, (int) s [7]);
134 AssertEquals ("Output-TestThrowOnInvalid2", "\x30\x31\u0000\xC0\u0000\xAF\x30\x32", s);
135 AssertEquals ("Reconverted-TestThrowOnInvalid2", BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
138 // unix decoding tests from http://www.cl.cam.ac.uk/~mgk25/
141 public void T1_Correct_GreekWord_kosme ()
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 AssertEquals ("Reconverted", BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
151 public void T2_Boundary_1_FirstPossibleSequence_Pass ()
153 byte[] data211 = { 0x00 };
154 string s = unix.GetString (data211);
155 AssertEquals ("1 byte (U-00000000)", "\0", s);
156 AssertEquals ("Reconverted-1", BitConverter.ToString (data211), BitConverter.ToString (unix.GetBytes (s)));
158 byte[] data212 = { 0xC2, 0x80 };
159 s = unix.GetString (data212);
160 AssertEquals ("2 bytes (U-00000080)", 128, s [0]);
161 AssertEquals ("Reconverted-2", BitConverter.ToString (data212), BitConverter.ToString (unix.GetBytes (s)));
163 byte[] data213 = { 0xE0, 0xA0, 0x80 };
164 s = unix.GetString (data213);
165 AssertEquals ("3 bytes (U-00000800)", 2048, s [0]);
166 AssertEquals ("Reconverted-3", BitConverter.ToString (data213), BitConverter.ToString (unix.GetBytes (s)));
168 byte[] data214 = { 0xF0, 0x90, 0x80, 0x80 };
169 s = unix.GetString (data214);
170 AssertEquals ("4 bytes (U-00010000)-0", 55296, s [0]);
171 AssertEquals ("4 bytes (U-00010000)-1", 56320, s [1]);
172 AssertEquals ("Reconverted-4", BitConverter.ToString (data214), BitConverter.ToString (unix.GetBytes (s)));
176 public void T2_Boundary_1_FirstPossibleSequence_Fail_5 ()
178 byte[] data215 = { 0xF8, 0x88, 0x80, 0x80, 0x80 };
179 string s = unix.GetString (data215);
180 AssertEquals ("Output-5", "\u0000\xF8\u0000\x88\u0000\x80\u0000\x80\u0000\x80", s);
181 AssertEquals ("Reconverted-5", BitConverter.ToString (data215), BitConverter.ToString (unix.GetBytes (s)));
185 public void T2_Boundary_1_FirstPossibleSequence_Fail_6 ()
187 byte[] data216 = { 0xFC, 0x84, 0x80, 0x80, 0x80, 0x80 };
188 string s = unix.GetString (data216);
189 AssertEquals ("Output-6", "\u0000\xFC\u0000\x84\u0000\x80\u0000\x80\u0000\x80\u0000\x80", s);
190 AssertEquals ("Reconverted-6", BitConverter.ToString (data216), BitConverter.ToString (unix.GetBytes (s)));
194 public void T2_Boundary_2_LastPossibleSequence_Pass ()
196 byte[] data221 = { 0x7F };
197 string s = unix.GetString (data221);
198 AssertEquals ("1 byte (U-0000007F)", 127, s [0]);
199 AssertEquals ("Reconverted-1", BitConverter.ToString (data221), BitConverter.ToString (unix.GetBytes (s)));
201 byte[] data222 = { 0xDF, 0xBF };
202 s = unix.GetString (data222);
203 AssertEquals ("2 bytes (U-000007FF)", 2047, s [0]);
204 AssertEquals ("Reconverted-2", BitConverter.ToString (data222), BitConverter.ToString (unix.GetBytes (s)));
206 byte[] data223 = { 0xEF, 0xBF, 0xBF };
207 s = unix.GetString (data223);
208 AssertEquals ("3 bytes (U-0000FFFF)", 65535, s [0]);
209 AssertEquals ("Reconverted-3", BitConverter.ToString (data223), BitConverter.ToString (unix.GetBytes (s)));
214 public void T2_Boundary_2_LastPossibleSequence_Fail_4 ()
216 byte[] data224 = { 0x7F, 0xBF, 0xBF, 0xBF };
217 string s = unix.GetString (data224);
218 AssertEquals ("Output-4",
219 "\x7F\u0000\xBF\u0000\xBF\u0000\xBF", s);
220 AssertEquals ("Reconverted-4", BitConverter.ToString (data224), BitConverter.ToString (unix.GetBytes (s)));
224 public void T2_Boundary_2_LastPossibleSequence_Fail_5 ()
226 byte[] data225 = { 0xFB, 0xBF, 0xBF, 0xBF, 0xBF };
227 string s = unix.GetString (data225);
228 AssertEquals ("Output-5", "\u0000\xFB\u0000\xBF\u0000\xBF\u0000\xBF\u0000\xBF", s);
229 AssertEquals ("Reconverted-5", BitConverter.ToString (data225), BitConverter.ToString (unix.GetBytes (s)));
233 public void T2_Boundary_2_LastPossibleSequence_Fail_6 ()
235 byte[] data226 = { 0xFD, 0xBF, 0xBF, 0xBF, 0xBF, 0xBF };
236 string s = unix.GetString (data226);
237 AssertEquals ("Output-6", "\u0000\xFD\u0000\xBF\u0000\xBF\u0000\xBF\u0000\xBF\u0000\xBF", s);
238 AssertEquals ("Reconverted-6", BitConverter.ToString (data226), BitConverter.ToString (unix.GetBytes (s)));
242 public void T2_Boundary_3_Other_Pass ()
244 byte[] data231 = { 0xED, 0x9F, 0xBF };
245 string s = unix.GetString (data231);
246 AssertEquals ("U-0000D7FF", 55295, s [0]);
247 AssertEquals ("Reconverted-1", BitConverter.ToString (data231), BitConverter.ToString (unix.GetBytes (s)));
249 byte[] data232 = { 0xEE, 0x80, 0x80 };
250 s = unix.GetString (data232);
251 AssertEquals ("U-0000E000", 57344, s [0]);
252 AssertEquals ("Reconverted-2", BitConverter.ToString (data232), BitConverter.ToString (unix.GetBytes (s)));
254 byte[] data233 = { 0xEF, 0xBF, 0xBD };
255 s = unix.GetString (data233);
256 AssertEquals ("U-0000FFFD", 65533, s [0]);
257 AssertEquals ("Reconverted-3", BitConverter.ToString (data233), BitConverter.ToString (unix.GetBytes (s)));
259 byte[] data234 = { 0xF4, 0x8F, 0xBF, 0xBF };
260 s = unix.GetString (data234);
261 AssertEquals ("U-0010FFFF-0", 56319, s [0]);
262 AssertEquals ("U-0010FFFF-1", 57343, s [1]);
263 AssertEquals ("Reconverted-4", BitConverter.ToString (data234), BitConverter.ToString (unix.GetBytes (s)));
267 public void T2_Boundary_3_Other_Fail_5 ()
269 byte[] data235 = { 0xF4, 0x90, 0x80, 0x80 };
270 string s = unix.GetString (data235);
271 AssertEquals ("Output-5", "\u0000\xF4\u0000\x90\u0000\x80\u0000\x80", s);
272 AssertEquals ("Reconverted-5", BitConverter.ToString (data235), BitConverter.ToString (unix.GetBytes (s)));
276 public void T3_Malformed_1_UnexpectedContinuation_311 ()
278 byte[] data = { 0x80 };
279 string s = unix.GetString (data);
280 AssertEquals ("Output-311", "\u0000\x80", s);
281 AssertEquals ("Reconverted-311", BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
285 public void T3_Malformed_1_UnexpectedContinuation_312 ()
287 byte[] data = { 0xBF };
288 string s = unix.GetString (data);
289 AssertEquals ("Output-312", "\u0000\xBF", s);
290 AssertEquals ("Reconverted-313", BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
294 public void T3_Malformed_1_UnexpectedContinuation_313 ()
296 byte[] data = { 0x80, 0xBF };
297 string s = unix.GetString (data);
298 AssertEquals ("Output-313", "\u0000\x80\u0000\xBF", s);
299 AssertEquals ("Reconverted-313", BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
303 public void T3_Malformed_1_UnexpectedContinuation_314 ()
305 byte[] data = { 0x80, 0xBF, 0x80 };
306 string s = unix.GetString (data);
307 AssertEquals ("Output-314", "\u0000\x80\u0000\xBF\u0000\x80", s);
308 AssertEquals ("Reconverted-314", BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
312 public void T3_Malformed_1_UnexpectedContinuation_315 ()
314 byte[] data = { 0x80, 0xBF, 0x80, 0xBF };
315 string s = unix.GetString (data);
316 AssertEquals ("Output-315", "\u0000\x80\u0000\xBF\u0000\x80\u0000\xBF", s);
317 AssertEquals ("Reconverted-315", BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
321 public void T3_Malformed_1_UnexpectedContinuation_316 ()
323 byte[] data = { 0x80, 0xBF, 0x80, 0xBF, 0x80 };
324 string s = unix.GetString (data);
325 AssertEquals ("Output-316",
326 "\u0000\x80\u0000\xBF\u0000\x80\u0000\xBF\u0000\x80", s);
327 AssertEquals ("Reconverted-316", BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
331 public void T3_Malformed_1_UnexpectedContinuation_317 ()
333 byte[] data = { 0x80, 0xBF, 0x80, 0xBF, 0x80, 0xBF };
334 string s = unix.GetString (data);
335 AssertEquals ("Output-317",
336 "\u0000\x80\u0000\xBF\u0000\x80\u0000\xBF\u0000\x80\u0000\xBF", s);
337 AssertEquals ("Reconverted-317", BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
341 public void T3_Malformed_1_UnexpectedContinuation_318 ()
343 byte[] data = { 0x80, 0xBF, 0x80, 0xBF, 0x80, 0xBF, 0x80 };
344 string s = unix.GetString (data);
345 AssertEquals ("Output-318",
346 "\u0000\x80\u0000\xBF\u0000\x80\u0000\xBF\u0000\x80\u0000\xBF\u0000\x80", s);
347 AssertEquals ("Reconverted-318", BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
351 public void T3_Malformed_1_UnexpectedContinuation_319 ()
353 // 64 different continuation characters
355 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F,
356 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F,
357 0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF,
358 0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF };
359 string s = unix.GetString (data);
360 AssertEquals ("Output-319",
361 "\u0000\x80\u0000\x81\u0000\x82\u0000\x83\u0000\x84\u0000\x85\u0000\x86\u0000\x87" +
362 "\u0000\x88\u0000\x89\u0000\x8A\u0000\x8B\u0000\x8C\u0000\x8D\u0000\x8E\u0000\x8F" +
363 "\u0000\x90\u0000\x91\u0000\x92\u0000\x93\u0000\x94\u0000\x95\u0000\x96\u0000\x97" +
364 "\u0000\x98\u0000\x99\u0000\x9A\u0000\x9B\u0000\x9C\u0000\x9D\u0000\x9E\u0000\x9F" +
365 "\u0000\xA0\u0000\xA1\u0000\xA2\u0000\xA3\u0000\xA4\u0000\xA5\u0000\xA6\u0000\xA7" +
366 "\u0000\xA8\u0000\xA9\u0000\xAA\u0000\xAB\u0000\xAC\u0000\xAD\u0000\xAE\u0000\xAF" +
367 "\u0000\xB0\u0000\xB1\u0000\xB2\u0000\xB3\u0000\xB4\u0000\xB5\u0000\xB6\u0000\xB7" +
368 "\u0000\xB8\u0000\xB9\u0000\xBA\u0000\xBB\u0000\xBC\u0000\xBD\u0000\xBE\u0000\xBF",
370 AssertEquals ("Reconverted-319", BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
374 public void T3_Malformed_2_LonelyStart_321 ()
377 0xC0, 0x20, 0xC1, 0x20, 0xC2, 0x20, 0xC3, 0x20, 0xC4, 0x20, 0xC5, 0x20, 0xC6, 0x20, 0xC7, 0x20,
378 0xC8, 0x20, 0xC9, 0x20, 0xCA, 0x20, 0xCB, 0x20, 0xCC, 0x20, 0xCD, 0x20, 0xCE, 0x20, 0xCF, 0x20,
379 0xD0, 0x20, 0xD1, 0x20, 0xD2, 0x20, 0xD3, 0x20, 0xD4, 0x20, 0xD5, 0x20, 0xD6, 0x20, 0xD7, 0x20,
380 0xD8, 0x20, 0xD9, 0x20, 0xDA, 0x20, 0xDB, 0x20, 0xDC, 0x20, 0xDD, 0x20, 0xDE, 0x20, 0xDF, 0x20 };
381 string s = unix.GetString (data);
382 AssertEquals ("Output-T3_Malformed_2_LonelyStart_321",
383 "\u0000\xC0 \u0000\xC1 \u0000\xC2 \u0000\xC3 \u0000\xC4 \u0000\xC5 \u0000\xC6 \u0000\xC7 " +
384 "\u0000\xC8 \u0000\xC9 \u0000\xCA \u0000\xCB \u0000\xCC \u0000\xCD \u0000\xCE \u0000\xCF " +
385 "\u0000\xD0 \u0000\xD1 \u0000\xD2 \u0000\xD3 \u0000\xD4 \u0000\xD5 \u0000\xD6 \u0000\xD7 " +
386 "\u0000\xD8 \u0000\xD9 \u0000\xDA \u0000\xDB \u0000\xDC \u0000\xDD \u0000\xDE \u0000\xDF ",
389 AssertEquals ("Reconverted-T3_Malformed_2_LonelyStart_321",
390 BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
394 public void T3_Malformed_2_LonelyStart_322 ()
397 0xE0, 0x20, 0xE1, 0x20, 0xE2, 0x20, 0xE3, 0x20, 0xE4, 0x20, 0xE5, 0x20, 0xE6, 0x20, 0xE7, 0x20,
398 0xE8, 0x20, 0xE9, 0x20, 0xEA, 0x20, 0xEB, 0x20, 0xEC, 0x20, 0xED, 0x20, 0xEE, 0x20, 0xEF, 0x20 };
399 string s = unix.GetString (data);
400 AssertEquals ("Output-T3_Malformed_2_LonelyStart_322",
401 "\u0000\xE0 \u0000\xE1 \u0000\xE2 \u0000\xE3 \u0000\xE4 \u0000\xE5 \u0000\xE6 \u0000\xE7 " +
402 "\u0000\xE8 \u0000\xE9 \u0000\xEA \u0000\xEB \u0000\xEC \u0000\xED \u0000\xEE \u0000\xEF ",
405 AssertEquals ("Reconverted-T3_Malformed_2_LonelyStart_322",
406 BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
410 public void T3_Malformed_2_LonelyStart_323 ()
412 byte[] data = { 0xF0, 0x20, 0xF1, 0x20, 0xF2, 0x20, 0xF3, 0x20, 0xF4, 0x20, 0xF5, 0x20, 0xF6, 0x20, 0xF7, 0x20 };
413 string s = unix.GetString (data);
414 AssertEquals ("Output-T3_Malformed_2_LonelyStart_323",
415 "\u0000\xF0 \u0000\xF1 \u0000\xF2 \u0000\xF3 \u0000\xF4 \u0000\xF5 \u0000\xF6 \u0000\xF7 ",
418 AssertEquals ("Reconverted-T3_Malformed_2_LonelyStart_323",
419 BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
423 public void T3_Malformed_2_LonelyStart_324 ()
425 byte[] data = { 0xF0, 0x20, 0xF1, 0x20, 0xF2, 0x20, 0xF3, 0x20, 0xF4, 0x20, 0xF5, 0x20, 0xF6, 0x20, 0xF7, 0x20 };
426 string s = unix.GetString (data);
427 AssertEquals ("Output-T3_Malformed_2_LonelyStart_324",
428 "\u0000\xF0 \u0000\xF1 \u0000\xF2 \u0000\xF3 \u0000\xF4 \u0000\xF5 \u0000\xF6 \u0000\xF7 ",
431 AssertEquals ("Reconverted-T3_Malformed_2_LonelyStart_324",
432 BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
436 public void T3_Malformed_2_LonelyStart_325 ()
438 byte[] data = { 0xFC, 0x20, 0xFD, 0x20 };
439 string s = unix.GetString (data);
440 AssertEquals ("Output-T3_Malformed_2_LonelyStart_324", "\u0000\xFC \u0000\xFD ", s);
441 AssertEquals ("Reconverted-T3_Malformed_2_LonelyStart_324",
442 BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
446 public void T3_Malformed_3_LastContinuationMissing_331 ()
448 byte[] data = { 0xC0 };
449 string s = unix.GetString (data);
450 AssertEquals ("Output-T3_Malformed_3_LastContinuationMissing_331", "\u0000\xC0", s);
451 AssertEquals ("Reconverted-T3_Malformed_3_LastContinuationMissing_331",
452 BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
456 public void T3_Malformed_3_LastContinuationMissing_332 ()
458 byte[] data = { 0xE0, 0x80 };
459 string s = unix.GetString (data);
463 public void T3_Malformed_3_LastContinuationMissing_333 ()
465 byte[] data = { 0xF0, 0x80, 0x80 };
466 string s = unix.GetString (data);
467 AssertEquals ("Output-T3_Malformed_3_LastContinuationMissing_333",
468 "\u0000\xF0\u0000\x80\u0000\x80", s);
469 AssertEquals ("Reconverted-T3_Malformed_3_LastContinuationMissing_333",
470 BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
474 public void T3_Malformed_3_LastContinuationMissing_334 ()
476 byte[] data = { 0xF8, 0x80, 0x80, 0x80 };
477 string s = unix.GetString (data);
478 AssertEquals ("Output-T3_Malformed_3_LastContinuationMissing_334",
479 "\u0000\xF8\u0000\x80\u0000\x80\u0000\x80", s);
480 AssertEquals ("Reconverted-T3_Malformed_3_LastContinuationMissing_334",
481 BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
485 public void T3_Malformed_3_LastContinuationMissing_335 ()
487 byte[] data = { 0xFC, 0x80, 0x80, 0x80, 0x80 };
488 string s = unix.GetString (data);
489 AssertEquals ("Output-T3_Malformed_3_LastContinuationMissing_335",
490 "\u0000\xFC\u0000\x80\u0000\x80\u0000\x80\u0000\x80", s);
491 AssertEquals ("Reconverted-T3_Malformed_3_LastContinuationMissing_335",
492 BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
496 public void T3_Malformed_3_LastContinuationMissing_336 ()
498 byte[] data = { 0xDF };
499 string s = unix.GetString (data);
500 AssertEquals ("Output-T3_Malformed_3_LastContinuationMissing_336",
502 AssertEquals ("Reconverted-T3_Malformed_3_LastContinuationMissing_336",
503 BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
507 public void T3_Malformed_3_LastContinuationMissing_337 ()
509 byte[] data = { 0xEF, 0xBF };
510 string s = unix.GetString (data);
511 AssertEquals ("Output-T3_Malformed_3_LastContinuationMissing_337",
512 "\u0000\xEF\u0000\xBF", s);
513 AssertEquals ("Reconverted-T3_Malformed_3_LastContinuationMissing_337",
514 BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
518 public void T3_Malformed_3_LastContinuationMissing_338 ()
520 byte[] data = { 0xF7, 0xBF, 0xBF };
521 string s = unix.GetString (data);
522 AssertEquals ("Output-T3_Malformed_3_LastContinuationMissing_338",
523 "\u0000\xF7\u0000\xBF\u0000\xBF", s);
524 AssertEquals ("Reconverted-T3_Malformed_3_LastContinuationMissing_338",
525 BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
529 public void T3_Malformed_3_LastContinuationMissing_339 ()
531 byte[] data = { 0xF, 0xBF, 0xBF, 0xBF };
532 string s = unix.GetString (data);
533 AssertEquals ("Output-339",
534 "\xF\u0000\xBF\u0000\xBF\u0000\xBF", s);
535 AssertEquals ("Reconverted-339", BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
539 public void T3_Malformed_3_LastContinuationMissing_3310 ()
541 byte[] data = { 0xFD, 0xBF, 0xBF, 0xBF, 0xBF };
542 string s = unix.GetString (data);
543 AssertEquals ("Output-3310",
544 "\u0000\xFD\u0000\xBF\u0000\xBF\u0000\xBF\u0000\xBF", s);
545 AssertEquals ("Reconverted-3310", BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
549 public void T3_Malformed_4_ConcatenationImcomplete ()
552 0xC0, 0xE0, 0x80, 0xF0, 0x80, 0x80, 0xF8, 0x80, 0x80, 0x80, 0xFC, 0x80, 0x80, 0x80, 0x80, 0xDF,
553 0xEF, 0xBF, 0xF7, 0xBF, 0xBF, 0xFB, 0xBF, 0xBF, 0xBF, 0xFD, 0xBF, 0xBF, 0xBF, 0xBF };
554 string s = unix.GetString (data);
555 AssertEquals ("Output-T3_Malformed_4_ConcatenationImcomplete",
556 "\u0000\xC0\u0000\xE0\u0000\x80\u0000\xF0\u0000\x80\u0000\x80\u0000\xF8\u0000\x80" +
557 "\u0000\x80\u0000\x80\u0000\xFC\u0000\x80\u0000\x80\u0000\x80\u0000\x80\u0000\xDF" +
558 "\u0000\xEF\u0000\xBF\u0000\xF7\u0000\xBF\u0000\xBF\u0000\xFB\u0000\xBF\u0000\xBF" +
559 "\u0000\xBF\u0000\xFD\u0000\xBF\u0000\xBF\u0000\xBF\u0000\xBF",
561 AssertEquals ("Reconverted-T3_Malformed_4_ConcatenationImcomplete", BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
565 public void T3_Malformed_5_ImpossibleBytes_351 ()
567 byte[] data = { 0xFE };
568 string s = unix.GetString (data);
569 AssertEquals ("Output-351", "\u0000\xFE", s);
570 AssertEquals ("Reconverted-351", BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
574 public void T3_Malformed_5_ImpossibleBytes_352 ()
576 byte[] data = { 0xFF };
577 string s = unix.GetString (data);
578 AssertEquals ("Output-352", "\u0000\xFF", s);
579 AssertEquals ("Reconverted-352", BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
583 public void T3_Malformed_5_ImpossibleBytes_353 ()
585 byte[] data = { 0xFE, 0xFE, 0xFF, 0xFF };
586 string s = unix.GetString (data);
587 AssertEquals ("Output-352", "\u0000\xFE\u0000\xFE\u0000\xFF\u0000\xFF", s);
588 AssertEquals ("Reconverted-352", BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
591 // Overlong == dangereous -> "safe" decoder should reject them
594 public void T4_Overlong_1_ASCII_Slash_411 ()
596 byte[] data = { 0xC0, 0xAF };
597 string s = unix.GetString (data);
598 AssertEquals ("Output-T4_Overlong_1_ASCII_Slash_411",
599 "\u0000\xC0\u0000\xAF", s);
600 AssertEquals ("Reconverted-T4_Overlong_1_ASCII_Slash_411", BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
604 public void T4_Overlong_1_ASCII_Slash_412 ()
606 byte[] data = { 0xE0, 0x80, 0xAF };
607 string s = unix.GetString (data);
608 AssertEquals ("Output-T4_Overlong_1_ASCII_Slash_413",
609 "\u0000\xE0\u0000\x80\u0000\xAF", s);
610 AssertEquals ("Reconverted-T4_Overlong_1_ASCII_Slash_413", BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
614 public void T4_Overlong_1_ASCII_Slash_413 ()
616 byte[] data = { 0xF0, 0x80, 0x80, 0xAF };
617 string s = unix.GetString (data);
618 AssertEquals ("Output-T4_Overlong_1_ASCII_Slash_412",
619 "\u0000\xF0\u0000\x80\u0000\x80\u0000\xAF", s);
620 AssertEquals ("Reconverted-T4_Overlong_1_ASCII_Slash_412", BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
624 public void T4_Overlong_1_ASCII_Slash_414 ()
626 byte[] data = { 0xF8, 0x80, 0x80, 0x80, 0xAF };
627 string s = unix.GetString (data);
628 AssertEquals ("Output-T4_Overlong_1_ASCII_Slash_414",
629 "\u0000\xF8\u0000\x80\u0000\x80\u0000\x80\u0000\xAF", s);
630 AssertEquals ("Reconverted-T4_Overlong_1_ASCII_Slash_414", BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
634 public void T4_Overlong_1_ASCII_Slash_415 ()
636 byte[] data = { 0xFC, 0x80, 0x80, 0x80, 0x80, 0xAF };
637 string s = unix.GetString (data);
638 AssertEquals ("Output-T4_Overlong_1_ASCII_Slash_415",
639 "\u0000\xFC\u0000\x80\u0000\x80\u0000\x80\u0000\x80\u0000\xAF", s);
640 AssertEquals ("Reconverted-T4_Overlong_1_ASCII_Slash_415", BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
644 public void T4_Overlong_2_MaximumBoundary_421 ()
646 byte[] data = { 0xC1, 0xBF };
647 string s = unix.GetString (data);
648 AssertEquals ("Output-T4_Overlong_2_MaximumBoundary_421",
649 "\u0000\xC1\u0000\xBF", s);
650 AssertEquals ("Reconverted-T4_Overlong_2_MaximumBoundary_421", BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
654 public void T4_Overlong_2_MaximumBoundary_422 ()
656 byte[] data = { 0xE0, 0x9F, 0xBF };
657 string s = unix.GetString (data);
658 AssertEquals ("Output-T4_Overlong_2_MaximumBoundary_422",
659 "\u0000\xE0\u0000\x9F\u0000\xBF", s);
660 AssertEquals ("Reconverted-T4_Overlong_2_MaximumBoundary_422", BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
664 public void T4_Overlong_2_MaximumBoundary_423 ()
666 byte[] data = { 0xF0, 0x8F, 0xBF, 0xBF };
667 string s = unix.GetString (data);
668 AssertEquals ("Output-T4_Overlong_2_MaximumBoundary_423",
669 "\u0000\xF0\u0000\x8F\u0000\xBF\u0000\xBF", s);
670 AssertEquals ("Reconverted-T4_Overlong_2_MaximumBoundary_423", BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
674 public void T4_Overlong_2_MaximumBoundary_424 ()
676 byte[] data = { 0xF8, 0x87, 0xBF, 0xBF, 0xBF };
677 string s = unix.GetString (data);
678 AssertEquals ("Output-T4_Overlong_2_MaximumBoundary_424",
679 "\u0000\xF8\u0000\x87\u0000\xBF\u0000\xBF\u0000\xBF", s);
680 AssertEquals ("Reconverted-T4_Overlong_2_MaximumBoundary_424", BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
684 public void T4_Overlong_2_MaximumBoundary_425 ()
686 byte[] data = { 0xFC, 0x83, 0xBF, 0xBF, 0xBF, 0xBF };
687 string s = unix.GetString (data);
688 AssertEquals ("Output-T4_Overlong_2_MaximumBoundary_425",
689 "\u0000\xFC\u0000\x83\u0000\xBF\u0000\xBF\u0000\xBF\u0000\xBF", s);
690 AssertEquals ("Reconverted-T4_Overlong_2_MaximumBoundary_425", BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
694 public void T4_Overlong_3_NUL_431 ()
696 byte[] data = { 0xC0, 0x80 };
697 string s = unix.GetString (data);
698 AssertEquals ("Output-T4_Overlong_3_NUL_431",
699 "\u0000\xC0\u0000\x80", s);
700 AssertEquals ("Reconverted-T4_Overlong_3_NUL_431", BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
704 public void T4_Overlong_3_NUL_432 ()
706 byte[] data = { 0xE0, 0x80, 0x80 };
707 string s = unix.GetString (data);
708 AssertEquals ("Output-T4_Overlong_3_NUL_432",
709 "\u0000\xE0\u0000\x80\u0000\x80", s);
710 AssertEquals ("Reconverted-T4_Overlong_3_NUL_432", BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
714 public void T4_Overlong_3_NUL_433 ()
716 byte[] data = { 0xF0, 0x80, 0x80, 0x80 };
717 string s = unix.GetString (data);
718 AssertEquals ("Output-T4_Overlong_3_NUL_433",
719 "\u0000\xF0\u0000\x80\u0000\x80\u0000\x80", s);
720 AssertEquals ("Reconverted-T4_Overlong_3_NUL_433", BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
724 public void T4_Overlong_3_NUL_434 ()
726 byte[] data = { 0xF8, 0x80, 0x80, 0x80, 0x80 };
727 string s = unix.GetString (data);
728 AssertEquals ("Output-T4_Overlong_3_NUL_434",
729 "\u0000\xF8\u0000\x80\u0000\x80\u0000\x80\u0000\x80", s);
730 AssertEquals ("Reconverted-T4_Overlong_3_NUL_434", BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
734 public void T4_Overlong_3_NUL_435 ()
736 byte[] data = { 0xFC, 0x80, 0x80, 0x80, 0x80, 0x80 };
737 string s = unix.GetString (data);
738 AssertEquals ("Output-T4_Overlong_3_NUL_434",
739 "\u0000\xFC\u0000\x80\u0000\x80\u0000\x80\u0000\x80\u0000\x80", s);
740 AssertEquals ("Reconverted-T4_Overlong_3_NUL_434", BitConverter.ToString (data), BitConverter.ToString (unix.GetBytes (s)));
744 // MS Fx 1.1 accept this
745 // [ExpectedException (typeof (ArgumentException))]
746 public void T5_IllegalCodePosition_1_UTF16Surrogates_511 ()
748 byte[] data = { 0xED, 0xA0, 0x80 };
749 string s = unix.GetString (data);
750 // exception is "really" expected here
751 AssertEquals ("MS FX 1.1 behaviour", 55296, s [0]);
755 // MS Fx 1.1 accept this
756 // [ExpectedException (typeof (ArgumentException))]
757 public void T5_IllegalCodePosition_1_UTF16Surrogates_512 ()
759 byte[] data = { 0xED, 0xAD, 0xBF };
760 string s = unix.GetString (data);
761 // exception is "really" expected here
762 AssertEquals ("MS FX 1.1 behaviour", 56191, s [0]);
766 // MS Fx 1.1 accept this
767 // [ExpectedException (typeof (ArgumentException))]
768 public void T5_IllegalCodePosition_1_UTF16Surrogates_513 ()
770 byte[] data = { 0xED, 0xAE, 0x80 };
771 string s = unix.GetString (data);
772 // exception is "really" expected here
773 AssertEquals ("MS FX 1.1 behaviour", 56192, s [0]);
777 // MS Fx 1.1 accept this
778 // [ExpectedException (typeof (ArgumentException))]
779 public void T5_IllegalCodePosition_1_UTF16Surrogates_514 ()
781 byte[] data = { 0xED, 0xAF, 0xBF };
782 string s = unix.GetString (data);
783 // exception is "really" expected here
784 AssertEquals ("MS FX 1.1 behaviour", 56319, s [0]);
788 // MS Fx 1.1 accept this
789 // [ExpectedException (typeof (ArgumentException))]
790 public void T5_IllegalCodePosition_1_UTF16Surrogates_515 ()
792 byte[] data = { 0xED, 0xB0, 0x80 };
793 string s = unix.GetString (data);
794 // exception is "really" expected here
795 AssertEquals ("MS FX 1.1 behaviour", 56320, s [0]);
799 // MS Fx 1.1 accept this
800 // [ExpectedException (typeof (ArgumentException))]
801 public void T5_IllegalCodePosition_1_UTF16Surrogates_516 ()
803 byte[] data = { 0xED, 0xBE, 0x80 };
804 string s = unix.GetString (data);
805 // exception is "really" expected here
806 AssertEquals ("MS FX 1.1 behaviour", 57216, s [0]);
810 // MS Fx 1.1 accept this
811 // [ExpectedException (typeof (ArgumentException))]
812 public void T5_IllegalCodePosition_1_UTF16Surrogates_517 ()
814 byte[] data = { 0xED, 0xBF, 0xBF };
815 string s = unix.GetString (data);
816 // exception is "really" expected here
817 AssertEquals ("MS FX 1.1 behaviour", 57343, s [0]);
821 // MS Fx 1.1 accept this
822 // [ExpectedException (typeof (ArgumentException))]
823 public void T5_IllegalCodePosition_2_PairedUTF16Surrogates_521 ()
825 byte[] data = { 0xED, 0xA0, 0x80, 0xED, 0xB0, 0x80 };
826 string s = unix.GetString (data);
827 // exception is "really" expected here
828 AssertEquals ("MS FX 1.1 behaviour", 55296, s [0]);
829 AssertEquals ("MS FX 1.1 behaviour", 56320, s [1]);
833 // MS Fx 1.1 accept this
834 // [ExpectedException (typeof (ArgumentException))]
835 public void T5_IllegalCodePosition_2_PairedUTF16Surrogates_522 ()
837 byte[] data = { 0xED, 0xA0, 0x80, 0xED, 0xBF, 0xBF };
838 string s = unix.GetString (data);
839 // exception is "really" expected here
840 AssertEquals ("MS FX 1.1 behaviour", 55296, s [0]);
841 AssertEquals ("MS FX 1.1 behaviour", 57343, s [1]);
845 // MS Fx 1.1 accept this
846 // [ExpectedException (typeof (ArgumentException))]
847 public void T5_IllegalCodePosition_2_PairedUTF16Surrogates_523 ()
849 byte[] data = { 0xED, 0xAD, 0xBF, 0xED, 0xB0, 0x80 };
850 string s = unix.GetString (data);
851 // exception is "really" expected here
852 AssertEquals ("MS FX 1.1 behaviour", 56191, s [0]);
853 AssertEquals ("MS FX 1.1 behaviour", 56320, s [1]);
857 // MS Fx 1.1 accept this
858 // [ExpectedException (typeof (ArgumentException))]
859 public void T5_IllegalCodePosition_2_PairedUTF16Surrogates_524 ()
861 byte[] data = { 0xED, 0xAD, 0xBF, 0xED, 0xBF, 0xBF };
862 string s = unix.GetString (data);
863 // exception is "really" expected here
864 AssertEquals ("MS FX 1.1 behaviour", 56191, s [0]);
865 AssertEquals ("MS FX 1.1 behaviour", 57343, s [1]);
869 // MS Fx 1.1 accept this
870 // [ExpectedException (typeof (ArgumentException))]
871 public void T5_IllegalCodePosition_2_PairedUTF16Surrogates_525 ()
873 byte[] data = { 0xED, 0xAE, 0x80, 0xED, 0xB0, 0x80 };
874 string s = unix.GetString (data);
875 // exception is "really" expected here
876 AssertEquals ("MS FX 1.1 behaviour", 56192, s [0]);
877 AssertEquals ("MS FX 1.1 behaviour", 56320, s [1]);
881 // MS Fx 1.1 accept this
882 // [ExpectedException (typeof (ArgumentException))]
883 public void T5_IllegalCodePosition_2_PairedUTF16Surrogates_526 ()
885 byte[] data = { 0xED, 0xAE, 0x80, 0xED, 0xBF, 0x8F };
886 string s = unix.GetString (data);
887 // exception is "really" expected here
888 AssertEquals ("MS FX 1.1 behaviour", 56192, s [0]);
889 AssertEquals ("MS FX 1.1 behaviour", 57295, s [1]);
893 // MS Fx 1.1 accept this
894 // [ExpectedException (typeof (ArgumentException))]
895 public void T5_IllegalCodePosition_2_PairedUTF16Surrogates_527 ()
897 byte[] data = { 0xED, 0xAF, 0xBF, 0xED, 0xB0, 0x80 };
898 string s = unix.GetString (data);
899 // exception is "really" expected here
900 AssertEquals ("MS FX 1.1 behaviour", 56319, s [0]);
901 AssertEquals ("MS FX 1.1 behaviour", 56320, s [1]);
905 // MS Fx 1.1 accept this
906 // [ExpectedException (typeof (ArgumentException))]
907 public void T5_IllegalCodePosition_2_PairedUTF16Surrogates_528 ()
909 byte[] data = { 0xED, 0xAF, 0xBF, 0xED, 0xBF, 0xBF };
910 string s = unix.GetString (data);
911 // exception is "really" expected here
912 AssertEquals ("MS FX 1.1 behaviour", 56319, s [0]);
913 AssertEquals ("MS FX 1.1 behaviour", 57343, s [1]);
917 // MS Fx 1.1 accept this
918 // [ExpectedException (typeof (ArgumentException))]
919 public void T5_IllegalCodePosition_3_Other_531 ()
921 byte[] data = { 0xEF, 0xBF, 0xBE };
922 string s = unix.GetString (data);
923 // exception is "really" expected here
924 AssertEquals ("MS FX 1.1 behaviour", 65534, s [0]);
928 // MS Fx 1.1 accept this
929 // [ExpectedException (typeof (ArgumentException))]
930 public void T5_IllegalCodePosition_3_Other_532 ()
932 byte[] data = { 0xEF, 0xBF, 0xBF };
933 string s = unix.GetString (data);
934 // exception is "really" expected here
935 AssertEquals ("MS FX 1.1 behaviour", 65535, s [0]);
939 // bug #75065 and #73086.
940 public void GetCharsFEFF ()
942 byte [] data = new byte [] {0xEF, 0xBB, 0xBF};
943 Encoding enc = new UnixEncoding ();
944 string s = enc.GetString (data);
945 AssertEquals ("\uFEFF", s);
948 char[] testChars = {'\uFEFF','A'};
950 byte[] bytes = utf.GetBytes(testChars);
951 char[] chars = utf.GetChars(bytes);
952 AssertEquals ("#1", '\uFEFF', chars [0]);
953 AssertEquals ("#2", 'A', chars [1]);
957 public void BinaryFilename ()
959 Compare ("BinaryFilename",
960 "test\u0000\xffname",
976 public void SjisFilename ()
979 "\u0000\x83\x4a\u0000\x83\u0000\x81\u0000\x83\x6e\u0000\x83\u0000\x81\u0000\x83\x6e.txt";
980 Compare ("SjisFilename",
1002 public void SjisFilename2 ()
1005 "\u0000\x83\x4a\u0000\x83\u0000\x81\u0000\x83\x6e\u0000\x83\u0000\x81\u0000\x83\x6e.txt";
1006 Compare ("SjisFilename2",
1007 "/home/jon/" + fn + "/baz",
1043 private void Compare (string prefix, string start, byte[] end)
1045 byte[] bytes = unix.GetBytes (start);
1047 AssertEquals (prefix + ": byte length", end.Length, bytes.Length);
1049 for (int i = 0; i < Math.Min (bytes.Length, end.Length); ++i)
1050 AssertEquals (prefix + ": byte " + i, end [i], bytes [i]);
1052 int cc = unix.GetCharCount (end, 0, end.Length);
1053 AssertEquals (prefix + ": char count", start.Length, cc);
1055 char[] chars = new char [cc];
1056 int r = unix.GetChars (end, 0, end.Length, chars, 0);
1058 AssertEquals (prefix + ": chars length", start.Length, r);
1060 for (int i = 0; i < Math.Min (r, start.Length); ++i) {
1061 AssertEquals (prefix + ": char " + i, start [i], chars [i]);