mcs/class/Mono.Posix/Test/Mono.Unix/UnixEncodingTest.cs

   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]
  27                 public void Create ()
  28                 {
  29                         unix = new UnixEncoding ();
  30                 }
  31
  32                 [Test]
  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]
  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]
  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]
  93                 public void TestMaxCharCount()
  94                 {
  95                         UnixEncoding unixenc = new UnixEncoding ();
  96                         Assert.AreEqual (50, unixenc.GetMaxCharCount(50), "UTF #1");
  97                 }
  98
  99                 [Test]
 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]
 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]
 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]
 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]
 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]
 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]
 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]
 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]
 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]
 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]
 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]
 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]
 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]
 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]
 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]
 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]
 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]
 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]
 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]
 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]
 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]
 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]
 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]
 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]
 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]
 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]
 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]
 441                 public void T3_Malformed_3_LastContinuationMissing_332 ()
 442                 {
 443                         byte[] data = { 0xE0, 0x80 };
 444                         string s = unix.GetString (data);
 445                 }
 446
 447                 [Test]
 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]
 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]
 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]
 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]
 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]
 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]
 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]
 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]
 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]
 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]
 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]
 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]
 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]
 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]
 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]
 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]
 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]
 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]
 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]
 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]
 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]
 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]
 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]
 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]
 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]
 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]
 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))]
 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))]
 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))]
 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))]
 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))]
 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))]
 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))]
 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))]
 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))]
 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))]
 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))]
 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))]
 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))]
 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))]
 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))]
 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))]
 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))]
 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.
 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]
 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]
 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]
 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
 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 }