mcs/class/corlib/Test/System.Text/UTF8EncodingTest.cs

   1 //
   2 // UTF8EncodingTest.cs - NUnit Test Cases for System.Text.UTF8Encoding
   3 //
   4 // Authors:
   5 //      Patrick Kalkman  kalkman@cistron.nl
   6 //      Sebastien Pouliot (spouliot@motus.com)
   7 //
   8 // (C) 2003 Patrick Kalkman
   9 // (C) 2004 Novell (http://www.novell.com)
  10 //
  11
  12 using NUnit.Framework;
  13 using System;
  14 using System.IO;
  15 using System.Text;
  16
  17 #if NET_2_0
  18 using DecoderException = System.Text.DecoderFallbackException;
  19 #else
  20 using DecoderException = System.ArgumentException;
  21 #endif
  22
  23 using AssertType = NUnit.Framework.Assert;
  24
  25 namespace MonoTests.System.Text
  26 {
  27         [TestFixture]
  28         public class UTF8EncodingTest
  29         {
  30                 private UTF8Encoding utf8;
  31
  32                 [SetUp]
  33                 public void Create ()
  34                 {
  35                         utf8 = new UTF8Encoding (true, true);
  36                 }
  37
  38                 [Test]
  39                 public void IsBrowserDisplay ()
  40                 {
  41                         Assert.IsTrue (utf8.IsBrowserDisplay);
  42                 }
  43
  44                 [Test]
  45                 public void IsBrowserSave ()
  46                 {
  47                         Assert.IsTrue (utf8.IsBrowserSave);
  48                 }
  49
  50                 [Test]
  51                 public void IsMailNewsDisplay ()
  52                 {
  53                         Assert.IsTrue (utf8.IsMailNewsDisplay);
  54                 }
  55
  56                 [Test]
  57                 public void IsMailNewsSave ()
  58                 {
  59                         Assert.IsTrue (utf8.IsMailNewsSave);
  60                 }
  61
  62                 [Test]
  63                 public void TestCompat ()
  64                 {
  65                         Assert.IsTrue (new UTF8Encoding ().Equals (new UTF8Encoding ()));
  66                 }
  67
  68                 [Test]
  69                 public void TestEncodingGetBytes1()
  70                 {
  71                         UTF8Encoding utf8Enc = new UTF8Encoding ();
  72                         string UniCode = "\u0041\u2262\u0391\u002E";
  73
  74                         // "A<NOT IDENTICAL TO><ALPHA>." may be encoded as 41 E2 89 A2 CE 91 2E
  75                         // see (RFC 2044)
  76                         byte[] utf8Bytes = utf8Enc.GetBytes (UniCode);
  77
  78                         Assert.AreEqual (0x41, utf8Bytes [0], "UTF #1");
  79                         Assert.AreEqual (0xE2, utf8Bytes [1], "UTF #2");
  80                         Assert.AreEqual (0x89, utf8Bytes [2], "UTF #3");
  81                         Assert.AreEqual (0xA2, utf8Bytes [3], "UTF #4");
  82                         Assert.AreEqual (0xCE, utf8Bytes [4], "UTF #5");
  83                         Assert.AreEqual (0x91, utf8Bytes [5], "UTF #6");
  84                         Assert.AreEqual (0x2E, utf8Bytes [6], "UTF #7");
  85                 }
  86
  87                 [Test]
  88                 public void TestEncodingGetBytes2()
  89                 {
  90                         UTF8Encoding utf8Enc = new UTF8Encoding ();
  91                         string UniCode = "\u0048\u0069\u0020\u004D\u006F\u006D\u0020\u263A\u0021";
  92
  93                         // "Hi Mom <WHITE SMILING FACE>!" may be encoded as 48 69 20 4D 6F 6D 20 E2 98 BA 21
  94                         // see (RFC 2044)
  95                         byte[] utf8Bytes = new byte [11];
  96
  97                         int ByteCnt = utf8Enc.GetBytes (UniCode.ToCharArray(), 0, UniCode.Length, utf8Bytes, 0);
  98                         Assert.AreEqual (11, ByteCnt, "UTF #1");
  99                         Assert.AreEqual (0x48, utf8Bytes [0], "UTF #2");
 100                         Assert.AreEqual (0x69, utf8Bytes [1], "UTF #3");
 101                         Assert.AreEqual (0x20, utf8Bytes [2], "UTF #4");
 102                         Assert.AreEqual (0x4D, utf8Bytes [3], "UTF #5");
 103                         Assert.AreEqual (0x6F, utf8Bytes [4], "UTF #6");
 104                         Assert.AreEqual (0x6D, utf8Bytes [5], "UTF #7");
 105                         Assert.AreEqual (0x20, utf8Bytes [6], "UTF #8");
 106                         Assert.AreEqual (0xE2, utf8Bytes [7], "UTF #9");
 107                         Assert.AreEqual (0x98, utf8Bytes [8], "UTF #10");
 108                         Assert.AreEqual (0xBA, utf8Bytes [9], "UTF #11");
 109                         Assert.AreEqual (0x21, utf8Bytes [10], "UTF #12");
 110                 }
 111
 112                 [Test]
 113                 public void TestDecodingGetChars1()
 114                 {
 115                         UTF8Encoding utf8Enc = new UTF8Encoding ();
 116                         // 41 E2 89 A2 CE 91 2E may be decoded as "A<NOT IDENTICAL TO><ALPHA>."
 117                         // see (RFC 2044)
 118                         byte[] utf8Bytes = new byte [] {0x41, 0xE2, 0x89, 0xA2, 0xCE, 0x91, 0x2E};
 119                         char[] UniCodeChars = utf8Enc.GetChars(utf8Bytes);
 120
 121                         Assert.AreEqual (0x0041, UniCodeChars [0], "UTF #1");
 122                         Assert.AreEqual (0x2262, UniCodeChars [1], "UTF #2");
 123                         Assert.AreEqual (0x0391, UniCodeChars [2], "UTF #3");
 124                         Assert.AreEqual (0x002E, UniCodeChars [3], "UTF #4");
 125                 }
 126
 127                 [Test]
 128 #if NET_2_0
 129                 [Category ("NotWorking")]
 130 #endif
 131                 public void TestMaxCharCount()
 132                 {
 133                         UTF8Encoding UTF8enc = new UTF8Encoding ();
 134 #if NET_2_0
 135                         // hmm, where is this extra 1 coming from?
 136                         Assert.AreEqual (51, UTF8enc.GetMaxCharCount(50), "UTF #1");
 137 #else
 138                         Assert.AreEqual (50, UTF8enc.GetMaxCharCount(50), "UTF #1");
 139 #endif
 140                 }
 141
 142                 [Test]
 143 #if NET_2_0
 144                 [Category ("NotWorking")]
 145 #endif
 146                 public void TestMaxByteCount()
 147                 {
 148                         UTF8Encoding UTF8enc = new UTF8Encoding ();
 149 #if NET_2_0
 150                         // maybe under .NET 2.0 insufficient surrogate pair is
 151                         // just not handled, and 3 is Preamble size.
 152                         Assert.AreEqual (153, UTF8enc.GetMaxByteCount(50), "UTF #1");
 153 #else
 154                         Assert.AreEqual (200, UTF8enc.GetMaxByteCount(50), "UTF #1");
 155 #endif
 156                 }
 157
 158                 // regression for bug #59648
 159                 [Test]
 160                 public void TestThrowOnInvalid ()
 161                 {
 162                         UTF8Encoding u = new UTF8Encoding (true, false);
 163
 164                         byte[] data = new byte [] { 0xC0, 0xAF };
 165 #if NET_2_0
 166                         Assert.AreEqual (2, u.GetCharCount (data), "#A0");
 167                         string s = u.GetString (data);
 168                         Assert.AreEqual ("\uFFFD\uFFFD", s, "#A1");
 169 #else
 170                         Assert.AreEqual (0, u.GetCharCount (data), "#A0");
 171                         string s = u.GetString (data);
 172                         Assert.AreEqual (String.Empty, s, "#A1");
 173 #endif
 174
 175                         data = new byte [] { 0x30, 0x31, 0xC0, 0xAF, 0x30, 0x32 };
 176                         s = u.GetString (data);
 177 #if NET_2_0
 178                         Assert.AreEqual (6, s.Length, "#B1");
 179                         Assert.AreEqual (0x30, (int) s [0], "#B2");
 180                         Assert.AreEqual (0x31, (int) s [1], "#B3");
 181                         Assert.AreEqual (0xFFFD, (int) s [2], "#B4");
 182                         Assert.AreEqual (0xFFFD, (int) s [3], "#B5");
 183                         Assert.AreEqual (0x30, (int) s [4], "#B6");
 184                         Assert.AreEqual (0x32, (int) s [5], "#B7");
 185 #else
 186                         Assert.AreEqual (4, s.Length, "#B1");
 187                         Assert.AreEqual (0x30, (int) s [0], "#B2");
 188                         Assert.AreEqual (0x31, (int) s [1], "#B3");
 189                         Assert.AreEqual (0x30, (int) s [2], "#B4");
 190                         Assert.AreEqual (0x32, (int) s [3], "#B5");
 191 #endif
 192                 }
 193
 194                 // UTF8 decoding tests from http://www.cl.cam.ac.uk/~mgk25/
 195
 196                 [Test]
 197                 public void T1_Correct_GreekWord_kosme ()
 198                 {
 199                         byte[] data = { 0xCE, 0xBA, 0xE1, 0xBD, 0xB9, 0xCF, 0x83, 0xCE, 0xBC, 0xCE, 0xB5 };
 200                         string s = utf8.GetString (data);
 201                         // cute but saving source code in unicode can be problematic
 202                         // so we just ensure we can re-encode this
 203                         Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (utf8.GetBytes (s)), "Reconverted");
 204                 }
 205
 206                 [Test]
 207                 public void T2_Boundary_1_FirstPossibleSequence_Pass ()
 208                 {
 209                         byte[] data211 = { 0x00 };
 210                         string s = utf8.GetString (data211);
 211                         Assert.AreEqual ("\0", s, "1 byte  (U-00000000)");
 212                         Assert.AreEqual (BitConverter.ToString (data211), BitConverter.ToString (utf8.GetBytes (s)), "Reconverted-1");
 213
 214                         byte[] data212 = { 0xC2, 0x80 };
 215                         s = utf8.GetString (data212);
 216                         Assert.AreEqual (128, s [0], "2 bytes (U-00000080)");
 217                         Assert.AreEqual (BitConverter.ToString (data212), BitConverter.ToString (utf8.GetBytes (s)), "Reconverted-2");
 218
 219                         byte[] data213 = { 0xE0, 0xA0, 0x80 };
 220                         s = utf8.GetString (data213);
 221                         Assert.AreEqual (2048, s [0], "3 bytes (U-00000800)");
 222                         Assert.AreEqual (BitConverter.ToString (data213), BitConverter.ToString (utf8.GetBytes (s)), "Reconverted-3");
 223
 224                         byte[] data214 = { 0xF0, 0x90, 0x80, 0x80 };
 225                         s = utf8.GetString (data214);
 226                         Assert.AreEqual (55296, s [0], "4 bytes (U-00010000)-0");
 227                         Assert.AreEqual (56320, s [1], "4 bytes (U-00010000)-1");
 228                         Assert.AreEqual (BitConverter.ToString (data214), BitConverter.ToString (utf8.GetBytes (s)), "Reconverted-4");
 229                 }
 230
 231                 [Test]
 232                 // Fail on MS Fx 1.1
 233                 [ExpectedException (typeof (DecoderException))]
 234                 public void T2_Boundary_1_FirstPossibleSequence_Fail_5 ()
 235                 {
 236                         byte[] data215 = { 0xF8, 0x88, 0x80, 0x80, 0x80 };
 237                         string s = utf8.GetString (data215);
 238                         Assert.IsNull (s, "5 bytes (U-00200000)");
 239                         Assert.AreEqual (BitConverter.ToString (data215), BitConverter.ToString (utf8.GetBytes (s)), "Reconverted-5");
 240                 }
 241
 242                 [Test]
 243                 // Fail on MS Fx 1.1
 244                 [ExpectedException (typeof (DecoderException))]
 245                 public void T2_Boundary_1_FirstPossibleSequence_Fail_6 ()
 246                 {
 247                         byte[] data216 = { 0xFC, 0x84, 0x80, 0x80, 0x80, 0x80 };
 248                         string s = utf8.GetString (data216);
 249                         Assert.IsNull (s, "6 bytes (U-04000000)");
 250                         Assert.AreEqual (BitConverter.ToString (data216), BitConverter.ToString (utf8.GetBytes (s)), "Reconverted-6");
 251                 }
 252
 253                 [Test]
 254                 public void T2_Boundary_2_LastPossibleSequence_Pass ()
 255                 {
 256                         byte[] data221 = { 0x7F };
 257                         string s = utf8.GetString (data221);
 258                         Assert.AreEqual (127, s [0], "1 byte  (U-0000007F)");
 259                         Assert.AreEqual (BitConverter.ToString (data221), BitConverter.ToString (utf8.GetBytes (s)), "Reconverted-1");
 260
 261                         byte[] data222 = { 0xDF, 0xBF };
 262                         s = utf8.GetString (data222);
 263                         Assert.AreEqual (2047, s [0], "2 bytes (U-000007FF)");
 264                         Assert.AreEqual (BitConverter.ToString (data222), BitConverter.ToString (utf8.GetBytes (s)), "Reconverted-2");
 265
 266                         byte[] data223 = { 0xEF, 0xBF, 0xBF };
 267                         s = utf8.GetString (data223);
 268                         Assert.AreEqual (65535, s [0], "3 bytes (U-0000FFFF)");
 269                         Assert.AreEqual (BitConverter.ToString (data223), BitConverter.ToString (utf8.GetBytes (s)), "Reconverted-3");
 270
 271                 }
 272
 273                 [Test]
 274                 // Fail on MS Fx 1.1
 275                 [ExpectedException (typeof (DecoderException))]
 276                 public void T2_Boundary_2_LastPossibleSequence_Fail_4 ()
 277                 {
 278                         byte[] data224 = { 0x7F, 0xBF, 0xBF, 0xBF };
 279                         string s = utf8.GetString (data224);
 280                         Assert.IsNull (s, "4 bytes (U-001FFFFF)");
 281                         Assert.AreEqual (BitConverter.ToString (data224), BitConverter.ToString (utf8.GetBytes (s)), "Reconverted-4");
 282                 }
 283
 284                 [Test]
 285                 // Fail on MS Fx 1.1
 286                 [ExpectedException (typeof (DecoderException))]
 287                 public void T2_Boundary_2_LastPossibleSequence_Fail_5 ()
 288                 {
 289                         byte[] data225 = { 0xFB, 0xBF, 0xBF, 0xBF, 0xBF };
 290                         string s = utf8.GetString (data225);
 291                         Assert.IsNull (s, "5 bytes (U-03FFFFFF)");
 292                         Assert.AreEqual (BitConverter.ToString (data225), BitConverter.ToString (utf8.GetBytes (s)), "Reconverted-5");
 293                 }
 294
 295                 [Test]
 296                 // Fail on MS Fx 1.1
 297                 [ExpectedException (typeof (DecoderException))]
 298                 public void T2_Boundary_2_LastPossibleSequence_Fail_6 ()
 299                 {
 300                         byte[] data226 = { 0xFD, 0xBF, 0xBF, 0xBF, 0xBF, 0xBF };
 301                         string s = utf8.GetString (data226);
 302                         Assert.IsNull (s, "6 bytes (U-7FFFFFFF)");
 303                         Assert.AreEqual (BitConverter.ToString (data226), BitConverter.ToString (utf8.GetBytes (s)), "Reconverted-6");
 304                 }
 305
 306                 [Test]
 307                 public void T2_Boundary_3_Other_Pass ()
 308                 {
 309                         byte[] data231 = { 0xED, 0x9F, 0xBF };
 310                         string s = utf8.GetString (data231);
 311                         Assert.AreEqual (55295, s [0], "U-0000D7FF");
 312                         Assert.AreEqual (BitConverter.ToString (data231), BitConverter.ToString (utf8.GetBytes (s)), "Reconverted-1");
 313
 314                         byte[] data232 = { 0xEE, 0x80, 0x80 };
 315                         s = utf8.GetString (data232);
 316                         Assert.AreEqual (57344, s [0], "U-0000E000");
 317                         Assert.AreEqual (BitConverter.ToString (data232), BitConverter.ToString (utf8.GetBytes (s)), "Reconverted-2");
 318
 319                         byte[] data233 = { 0xEF, 0xBF, 0xBD };
 320                         s = utf8.GetString (data233);
 321                         Assert.AreEqual (65533, s [0], "U-0000FFFD");
 322                         Assert.AreEqual (BitConverter.ToString (data233), BitConverter.ToString (utf8.GetBytes (s)), "Reconverted-3");
 323
 324                         byte[] data234 = { 0xF4, 0x8F, 0xBF, 0xBF };
 325                         s = utf8.GetString (data234);
 326                         Assert.AreEqual (56319, s [0], "U-0010FFFF-0");
 327                         Assert.AreEqual (57343, s [1], "U-0010FFFF-1");
 328                         Assert.AreEqual (BitConverter.ToString (data234), BitConverter.ToString (utf8.GetBytes (s)), "Reconverted-4");
 329                 }
 330
 331                 [Test]
 332                 // Fail on MS Fx 1.1
 333                 [ExpectedException (typeof (DecoderException))]
 334                 public void T2_Boundary_3_Other_Fail_5 ()
 335                 {
 336                         byte[] data235 = { 0xF4, 0x90, 0x80, 0x80 };
 337                         string s = utf8.GetString (data235);
 338                         Assert.IsNull (s, "U-00110000");
 339                         Assert.AreEqual (BitConverter.ToString (data235), BitConverter.ToString (utf8.GetBytes (s)), "Reconverted-5");
 340                 }
 341
 342                 [Test]
 343                 [ExpectedException (typeof (DecoderException))]
 344                 public void T3_Malformed_1_UnexpectedContinuation_311 ()
 345                 {
 346                         byte[] data = { 0x80 };
 347                         string s = utf8.GetString (data);
 348                         // exception is "really" expected here
 349                 }
 350
 351                 [Test]
 352                 [ExpectedException (typeof (DecoderException))]
 353                 public void T3_Malformed_1_UnexpectedContinuation_312 ()
 354                 {
 355                         byte[] data = { 0xBF };
 356                         string s = utf8.GetString (data);
 357                         // exception is "really" expected here
 358                 }
 359
 360                 [Test]
 361                 [ExpectedException (typeof (DecoderException))]
 362                 public void T3_Malformed_1_UnexpectedContinuation_313 ()
 363                 {
 364                         byte[] data = { 0x80, 0xBF };
 365                         string s = utf8.GetString (data);
 366                         // exception is "really" expected here
 367                 }
 368
 369                 [Test]
 370                 [ExpectedException (typeof (DecoderException))]
 371                 public void T3_Malformed_1_UnexpectedContinuation_314 ()
 372                 {
 373                         byte[] data = { 0x80, 0xBF, 0x80 };
 374                         string s = utf8.GetString (data);
 375                         // exception is "really" expected here
 376                 }
 377
 378                 [Test]
 379                 [ExpectedException (typeof (DecoderException))]
 380                 public void T3_Malformed_1_UnexpectedContinuation_315 ()
 381                 {
 382                         byte[] data = { 0x80, 0xBF, 0x80, 0xBF };
 383                         string s = utf8.GetString (data);
 384                         // exception is "really" expected here
 385                 }
 386
 387                 [Test]
 388                 [ExpectedException (typeof (DecoderException))]
 389                 public void T3_Malformed_1_UnexpectedContinuation_316 ()
 390                 {
 391                         byte[] data = { 0x80, 0xBF, 0x80, 0xBF, 0x80 };
 392                         string s = utf8.GetString (data);
 393                         // exception is "really" expected here
 394                 }
 395
 396                 [Test]
 397                 [ExpectedException (typeof (DecoderException))]
 398                 public void T3_Malformed_1_UnexpectedContinuation_317 ()
 399                 {
 400                         byte[] data = { 0x80, 0xBF, 0x80, 0xBF, 0x80, 0xBF };
 401                         string s = utf8.GetString (data);
 402                         // exception is "really" expected here
 403                 }
 404
 405                 [Test]
 406                 [ExpectedException (typeof (DecoderException))]
 407                 public void T3_Malformed_1_UnexpectedContinuation_318 ()
 408                 {
 409                         byte[] data = { 0x80, 0xBF, 0x80, 0xBF, 0x80, 0xBF, 0x80 };
 410                         string s = utf8.GetString (data);
 411                         // exception is "really" expected here
 412                 }
 413
 414                 [Test]
 415                 [ExpectedException (typeof (DecoderException))]
 416                 public void T3_Malformed_1_UnexpectedContinuation_319 ()
 417                 {
 418                         // 64 different continuation characters
 419                         byte[] data = {
 420                                 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F,
 421                                 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F,
 422                                 0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF,
 423                                 0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF };
 424                         string s = utf8.GetString (data);
 425                         // exception is "really" expected here
 426                 }
 427
 428                 [Test]
 429                 [ExpectedException (typeof (DecoderException))]
 430                 public void T3_Malformed_2_LonelyStart_321 ()
 431                 {
 432                         byte[] data = {
 433                                 0xC0, 0x20, 0xC1, 0x20, 0xC2, 0x20, 0xC3, 0x20, 0xC4, 0x20, 0xC5, 0x20, 0xC6, 0x20, 0xC7, 0x20,
 434                                 0xC8, 0x20, 0xC9, 0x20, 0xCA, 0x20, 0xCB, 0x20, 0xCC, 0x20, 0xCD, 0x20, 0xCE, 0x20, 0xCF, 0x20,
 435                                 0xD0, 0x20, 0xD1, 0x20, 0xD2, 0x20, 0xD3, 0x20, 0xD4, 0x20, 0xD5, 0x20, 0xD6, 0x20, 0xD7, 0x20,
 436                                 0xD8, 0x20, 0xD9, 0x20, 0xDA, 0x20, 0xDB, 0x20, 0xDC, 0x20, 0xDD, 0x20, 0xDE, 0x20, 0xDF, 0x20 };
 437                         string s = utf8.GetString (data);
 438                         // exception is "really" expected here
 439                 }
 440
 441                 [Test]
 442                 [ExpectedException (typeof (DecoderException))]
 443                 public void T3_Malformed_2_LonelyStart_322 ()
 444                 {
 445                         byte[] data = {
 446                                 0xE0, 0x20, 0xE1, 0x20, 0xE2, 0x20, 0xE3, 0x20, 0xE4, 0x20, 0xE5, 0x20, 0xE6, 0x20, 0xE7, 0x20,
 447                                 0xE8, 0x20, 0xE9, 0x20, 0xEA, 0x20, 0xEB, 0x20, 0xEC, 0x20, 0xED, 0x20, 0xEE, 0x20, 0xEF, 0x20 };
 448                         string s = utf8.GetString (data);
 449                         // exception is "really" expected here
 450                 }
 451
 452                 [Test]
 453                 [ExpectedException (typeof (DecoderException))]
 454                 public void T3_Malformed_2_LonelyStart_323 ()
 455                 {
 456                         byte[] data = { 0xF0, 0x20, 0xF1, 0x20, 0xF2, 0x20, 0xF3, 0x20, 0xF4, 0x20, 0xF5, 0x20, 0xF6, 0x20, 0xF7, 0x20 };
 457                         string s = utf8.GetString (data);
 458                         // exception is "really" expected here
 459                 }
 460
 461                 [Test]
 462                 [ExpectedException (typeof (DecoderException))]
 463                 public void T3_Malformed_2_LonelyStart_324 ()
 464                 {
 465                         byte[] data = { 0xF0, 0x20, 0xF1, 0x20, 0xF2, 0x20, 0xF3, 0x20, 0xF4, 0x20, 0xF5, 0x20, 0xF6, 0x20, 0xF7, 0x20 };
 466                         string s = utf8.GetString (data);
 467                         // exception is "really" expected here
 468                 }
 469
 470                 [Test]
 471                 [ExpectedException (typeof (DecoderException))]
 472                 public void T3_Malformed_2_LonelyStart_325 ()
 473                 {
 474                         byte[] data = { 0xFC, 0x20, 0xFD, 0x20 };
 475                         string s = utf8.GetString (data);
 476                         // exception is "really" expected here
 477                 }
 478
 479                 [Test]
 480                 [ExpectedException (typeof (DecoderException))]
 481                 public void T3_Malformed_3_LastContinuationMissing_331 ()
 482                 {
 483                         byte[] data = { 0xC0 };
 484                         string s = utf8.GetString (data);
 485                         // exception is "really" expected here
 486                 }
 487
 488                 [Test]
 489                 [ExpectedException (typeof (DecoderException))]
 490                 public void T3_Malformed_3_LastContinuationMissing_332 ()
 491                 {
 492                         byte[] data = { 0xE0, 0x80 };
 493                         string s = utf8.GetString (data);
 494                         // exception is "really" expected here
 495                 }
 496
 497                 [Test]
 498                 [ExpectedException (typeof (DecoderException))]
 499                 public void T3_Malformed_3_LastContinuationMissing_333 ()
 500                 {
 501                         byte[] data = { 0xF0, 0x80, 0x80 };
 502                         string s = utf8.GetString (data);
 503                         // exception is "really" expected here
 504                 }
 505
 506                 [Test]
 507                 [ExpectedException (typeof (DecoderException))]
 508                 public void T3_Malformed_3_LastContinuationMissing_334 ()
 509                 {
 510                         byte[] data = { 0xF8, 0x80, 0x80, 0x80 };
 511                         string s = utf8.GetString (data);
 512                         // exception is "really" expected here
 513                 }
 514
 515                 [Test]
 516                 [ExpectedException (typeof (DecoderException))]
 517                 public void T3_Malformed_3_LastContinuationMissing_335 ()
 518                 {
 519                         byte[] data = { 0xFC, 0x80, 0x80, 0x80, 0x80 };
 520                         string s = utf8.GetString (data);
 521                         // exception is "really" expected here
 522                 }
 523
 524                 [Test]
 525 // MS Fx 1.1 accept this
 526 //              [ExpectedException (typeof (DecoderException))]
 527                 public void T3_Malformed_3_LastContinuationMissing_336 ()
 528                 {
 529                         byte[] data = { 0xDF };
 530                         try {
 531                                 string s = utf8.GetString (data);
 532                                 // exception is "really" expected here
 533                                 Assert.AreEqual (String.Empty, s, "MS FX 1.1 behaviour");
 534                         }
 535                         catch (DecoderException) {
 536                                 // but Mono doesn't - better stick to the standard
 537                         }
 538                 }
 539
 540                 [Test]
 541                 // MS Fx 1.1 accept this
 542 //              [ExpectedException (typeof (DecoderException))]
 543                 public void T3_Malformed_3_LastContinuationMissing_337 ()
 544                 {
 545                         byte[] data = { 0xEF, 0xBF };
 546                         try {
 547                                 string s = utf8.GetString (data);
 548                                 // exception is "really" expected here
 549                                 Assert.AreEqual (String.Empty, s, "MS FX 1.1 behaviour");
 550                         }
 551                         catch (DecoderException) {
 552                                 // but Mono doesn't - better stick to the standard
 553                         }
 554                 }
 555
 556                 [Test]
 557                 [ExpectedException (typeof (DecoderException))]
 558                 public void T3_Malformed_3_LastContinuationMissing_338 ()
 559                 {
 560                         byte[] data = { 0xF7, 0xBF, 0xBF };
 561                         string s = utf8.GetString (data);
 562                         // exception is "really" expected here
 563                 }
 564
 565                 [Test]
 566                 [ExpectedException (typeof (DecoderException))]
 567                 public void T3_Malformed_3_LastContinuationMissing_339 ()
 568                 {
 569                         byte[] data = { 0xF, 0xBF, 0xBF, 0xBF };
 570                         string s = utf8.GetString (data);
 571                         // exception is "really" expected here
 572                 }
 573
 574                 [Test]
 575                 [ExpectedException (typeof (DecoderException))]
 576                 public void T3_Malformed_3_LastContinuationMissing_3310 ()
 577                 {
 578                         byte[] data = { 0xFD, 0xBF, 0xBF, 0xBF, 0xBF };
 579                         string s = utf8.GetString (data);
 580                         // exception is "really" expected here
 581                 }
 582
 583                 [Test]
 584                 [ExpectedException (typeof (DecoderException))]
 585                 public void T3_Malformed_4_ConcatenationImcomplete ()
 586                 {
 587                         byte[] data = {
 588                                 0xC0, 0xE0, 0x80, 0xF0, 0x80, 0x80, 0xF8, 0x80, 0x80, 0x80, 0xFC, 0x80, 0x80, 0x80, 0x80, 0xDF,
 589                                 0xEF, 0xBF, 0xF7, 0xBF, 0xBF, 0xFB, 0xBF, 0xBF, 0xBF, 0xFD, 0xBF, 0xBF, 0xBF, 0xBF };
 590                         string s = utf8.GetString (data);
 591                         // exception is "really" expected here
 592                 }
 593
 594                 [Test]
 595                 [ExpectedException (typeof (DecoderException))]
 596                 public void T3_Malformed_5_ImpossibleBytes_351 ()
 597                 {
 598                         byte[] data = { 0xFE };
 599                         string s = utf8.GetString (data);
 600                         // exception is "really" expected here
 601                 }
 602
 603                 [Test]
 604                 [ExpectedException (typeof (DecoderException))]
 605                 public void T3_Malformed_5_ImpossibleBytes_352 ()
 606                 {
 607                         byte[] data = { 0xFF };
 608                         string s = utf8.GetString (data);
 609                         // exception is "really" expected here
 610                 }
 611
 612                 [Test]
 613                 [ExpectedException (typeof (DecoderException))]
 614                 public void T3_Malformed_5_ImpossibleBytes_353 ()
 615                 {
 616                         byte[] data = { 0xFE, 0xFE, 0xFF, 0xFF };
 617                         string s = utf8.GetString (data);
 618                         // exception is "really" expected here
 619                 }
 620
 621                 // Overlong == dangereous -> "safe" decoder should reject them
 622
 623                 [Test]
 624                 [ExpectedException (typeof (DecoderException))]
 625                 public void T4_Overlong_1_ASCII_Slash_411 ()
 626                 {
 627                         byte[] data = { 0xC0, 0xAF };
 628                         string s = utf8.GetString (data);
 629                         // exception is "really" expected here
 630                 }
 631
 632                 [Test]
 633                 [ExpectedException (typeof (DecoderException))]
 634                 public void T4_Overlong_1_ASCII_Slash_412 ()
 635                 {
 636                         byte[] data = { 0xE0, 0x80, 0xAF };
 637                         string s = utf8.GetString (data);
 638                         // exception is "really" expected here
 639                 }
 640
 641                 [Test]
 642                 [ExpectedException (typeof (DecoderException))]
 643                 public void T4_Overlong_1_ASCII_Slash_413 ()
 644                 {
 645                         byte[] data = { 0xF0, 0x80, 0x80, 0xAF };
 646                         string s = utf8.GetString (data);
 647                         // exception is "really" expected here
 648                 }
 649
 650                 [Test]
 651                 [ExpectedException (typeof (DecoderException))]
 652                 public void T4_Overlong_1_ASCII_Slash_414 ()
 653                 {
 654                         byte[] data = { 0xF8, 0x80, 0x80, 0x80, 0xAF };
 655                         string s = utf8.GetString (data);
 656                         // exception is "really" expected here
 657                 }
 658
 659                 [Test]
 660                 [ExpectedException (typeof (DecoderException))]
 661                 public void T4_Overlong_1_ASCII_Slash_415 ()
 662                 {
 663                         byte[] data = { 0xFC, 0x80, 0x80, 0x80, 0x80, 0xAF };
 664                         string s = utf8.GetString (data);
 665                         // exception is "really" expected here
 666                 }
 667
 668                 [Test]
 669                 [ExpectedException (typeof (DecoderException))]
 670                 public void T4_Overlong_2_MaximumBoundary_421 ()
 671                 {
 672                         byte[] data = { 0xC1, 0xBF };
 673                         string s = utf8.GetString (data);
 674                         // exception is "really" expected here
 675                 }
 676
 677                 [Test]
 678                 [ExpectedException (typeof (DecoderException))]
 679                 public void T4_Overlong_2_MaximumBoundary_422 ()
 680                 {
 681                         byte[] data = { 0xE0, 0x9F, 0xBF };
 682                         string s = utf8.GetString (data);
 683                         // exception is "really" expected here
 684                 }
 685
 686                 [Test]
 687                 [ExpectedException (typeof (DecoderException))]
 688                 public void T4_Overlong_2_MaximumBoundary_423 ()
 689                 {
 690                         byte[] data = { 0xF0, 0x8F, 0xBF, 0xBF };
 691                         string s = utf8.GetString (data);
 692                         // exception is "really" expected here
 693                 }
 694
 695                 [Test]
 696                 [ExpectedException (typeof (DecoderException))]
 697                 public void T4_Overlong_2_MaximumBoundary_424 ()
 698                 {
 699                         byte[] data = { 0xF8, 0x87, 0xBF, 0xBF, 0xBF };
 700                         string s = utf8.GetString (data);
 701                         // exception is "really" expected here
 702                 }
 703
 704                 [Test]
 705                 [ExpectedException (typeof (DecoderException))]
 706                 public void T4_Overlong_2_MaximumBoundary_425 ()
 707                 {
 708                         byte[] data = { 0xFC, 0x83, 0xBF, 0xBF, 0xBF, 0xBF };
 709                         string s = utf8.GetString (data);
 710                         // exception is "really" expected here
 711                 }
 712
 713                 [Test]
 714                 [ExpectedException (typeof (DecoderException))]
 715                 public void T4_Overlong_3_NUL_431 ()
 716                 {
 717                         byte[] data = { 0xC0, 0x80 };
 718                         string s = utf8.GetString (data);
 719                         // exception is "really" expected here
 720                 }
 721
 722                 [Test]
 723                 [ExpectedException (typeof (DecoderException))]
 724                 public void T4_Overlong_3_NUL_432 ()
 725                 {
 726                         byte[] data = { 0xE0, 0x80, 0x80 };
 727                         string s = utf8.GetString (data);
 728                         // exception is "really" expected here
 729                 }
 730
 731                 [Test]
 732                 [ExpectedException (typeof (DecoderException))]
 733                 public void T4_Overlong_3_NUL_433 ()
 734                 {
 735                         byte[] data = { 0xF0, 0x80, 0x80, 0x80 };
 736                         string s = utf8.GetString (data);
 737                         // exception is "really" expected here
 738                 }
 739
 740                 [Test]
 741                 [ExpectedException (typeof (DecoderException))]
 742                 public void T4_Overlong_3_NUL_434 ()
 743                 {
 744                         byte[] data = { 0xF8, 0x80, 0x80, 0x80, 0x80 };
 745                         string s = utf8.GetString (data);
 746                         // exception is "really" expected here
 747                 }
 748
 749                 [Test]
 750                 [ExpectedException (typeof (DecoderException))]
 751                 public void T4_Overlong_3_NUL_435 ()
 752                 {
 753                         byte[] data = { 0xFC, 0x80, 0x80, 0x80, 0x80, 0x80 };
 754                         string s = utf8.GetString (data);
 755                         // exception is "really" expected here
 756                 }
 757
 758                 [Test]
 759 #if NET_2_0
 760                 [ExpectedException (typeof (DecoderFallbackException))]
 761 #else
 762 // MS Fx 1.1 accept this
 763                 [Category ("NotDotNet")]
 764                 [ExpectedException (typeof (DecoderException))]
 765 #endif
 766                         public void T5_IllegalCodePosition_1_UTF16Surrogates_511 ()
 767                 {
 768                         byte[] data = { 0xED, 0xA0, 0x80 };
 769                         string s = utf8.GetString (data);
 770                         // exception is "really" expected here
 771                         Assert.AreEqual (55296, s [0], "MS FX 1.1 behaviour");
 772                 }
 773
 774                 [Test]
 775 #if NET_2_0
 776                 [ExpectedException (typeof (DecoderFallbackException))]
 777 #else
 778 // MS Fx 1.1 accept this
 779                 [Category ("NotDotNet")]
 780                 [ExpectedException (typeof (DecoderException))]
 781 #endif
 782                 public void T5_IllegalCodePosition_1_UTF16Surrogates_512 ()
 783                 {
 784                         byte[] data = { 0xED, 0xAD, 0xBF };
 785                         string s = utf8.GetString (data);
 786                         // exception is "really" expected here
 787                         Assert.AreEqual (56191, s [0], "MS FX 1.1 behaviour");
 788                 }
 789
 790                 [Test]
 791 #if NET_2_0
 792                 [ExpectedException (typeof (DecoderFallbackException))]
 793 #else
 794 // MS Fx 1.1 accept this
 795                 [Category ("NotDotNet")]
 796                 [ExpectedException (typeof (DecoderException))]
 797 #endif
 798                 public void T5_IllegalCodePosition_1_UTF16Surrogates_513 ()
 799                 {
 800                         byte[] data = { 0xED, 0xAE, 0x80 };
 801                         string s = utf8.GetString (data);
 802                         // exception is "really" expected here
 803                         Assert.AreEqual (56192, s [0], "MS FX 1.1 behaviour");
 804                 }
 805
 806                 [Test]
 807 #if NET_2_0
 808                 [ExpectedException (typeof (DecoderFallbackException))]
 809 #else
 810 // MS Fx 1.1 accept this
 811                 [Category ("NotDotNet")]
 812                 [ExpectedException (typeof (DecoderException))]
 813 #endif
 814                 public void T5_IllegalCodePosition_1_UTF16Surrogates_514 ()
 815                 {
 816                         byte[] data = { 0xED, 0xAF, 0xBF };
 817                         string s = utf8.GetString (data);
 818                         // exception is "really" expected here
 819                         Assert.AreEqual (56319, s [0], "MS FX 1.1 behaviour");
 820                 }
 821
 822                 [Test]
 823 #if NET_2_0
 824                 [ExpectedException (typeof (DecoderFallbackException))]
 825 #else
 826 // MS Fx 1.1 accept this
 827                 [Category ("NotDotNet")]
 828                 [ExpectedException (typeof (DecoderException))]
 829 #endif
 830                 public void T5_IllegalCodePosition_1_UTF16Surrogates_515 ()
 831                 {
 832                         byte[] data = { 0xED, 0xB0, 0x80 };
 833                         string s = utf8.GetString (data);
 834                         // exception is "really" expected here
 835                         Assert.AreEqual (56320, s [0], "MS FX 1.1 behaviour");
 836                 }
 837
 838                 [Test]
 839 #if NET_2_0
 840                 [ExpectedException (typeof (DecoderFallbackException))]
 841 #else
 842 // MS Fx 1.1 accept this
 843                 [Category ("NotDotNet")]
 844                 [ExpectedException (typeof (DecoderException))]
 845 #endif
 846                 public void T5_IllegalCodePosition_1_UTF16Surrogates_516 ()
 847                 {
 848                         byte[] data = { 0xED, 0xBE, 0x80 };
 849                         string s = utf8.GetString (data);
 850                         // exception is "really" expected here
 851                         Assert.AreEqual (57216, s [0], "MS FX 1.1 behaviour");
 852                 }
 853
 854                 [Test]
 855 #if NET_2_0
 856                 [ExpectedException (typeof (DecoderFallbackException))]
 857 #else
 858 // MS Fx 1.1 accept this
 859                 [Category ("NotDotNet")]
 860                 [ExpectedException (typeof (DecoderException))]
 861 #endif
 862                 public void T5_IllegalCodePosition_1_UTF16Surrogates_517 ()
 863                 {
 864                         byte[] data = { 0xED, 0xBF, 0xBF };
 865                         string s = utf8.GetString (data);
 866                         // exception is "really" expected here
 867                         Assert.AreEqual (57343, s [0], "MS FX 1.1 behaviour");
 868                 }
 869
 870                 [Test]
 871 #if NET_2_0
 872                 [ExpectedException (typeof (DecoderFallbackException))]
 873 #else
 874 // MS Fx 1.1 accept this
 875                 [Category ("NotDotNet")]
 876                 [ExpectedException (typeof (DecoderException))]
 877 #endif
 878                 public void T5_IllegalCodePosition_2_PairedUTF16Surrogates_521 ()
 879                 {
 880                         byte[] data = { 0xED, 0xA0, 0x80, 0xED, 0xB0, 0x80 };
 881                         string s = utf8.GetString (data);
 882                         // exception is "really" expected here
 883                         Assert.AreEqual (55296, s [0], "MS FX 1.1 behaviour");
 884                         Assert.AreEqual (56320, s [1], "MS FX 1.1 behaviour");
 885                 }
 886
 887                 [Test]
 888 #if NET_2_0
 889                 [ExpectedException (typeof (DecoderFallbackException))]
 890 #else
 891 // MS Fx 1.1 accept this
 892                 [Category ("NotDotNet")]
 893                 [ExpectedException (typeof (DecoderException))]
 894 #endif
 895                 public void T5_IllegalCodePosition_2_PairedUTF16Surrogates_522 ()
 896                 {
 897                         byte[] data = { 0xED, 0xA0, 0x80, 0xED, 0xBF, 0xBF };
 898                         string s = utf8.GetString (data);
 899                         // exception is "really" expected here
 900                         Assert.AreEqual (55296, s [0], "MS FX 1.1 behaviour");
 901                         Assert.AreEqual (57343, s [1], "MS FX 1.1 behaviour");
 902                 }
 903
 904                 [Test]
 905 #if NET_2_0
 906                 [ExpectedException (typeof (DecoderFallbackException))]
 907 #else
 908 // MS Fx 1.1 accept this
 909                 [Category ("NotDotNet")]
 910                 [ExpectedException (typeof (DecoderException))]
 911 #endif
 912                 public void T5_IllegalCodePosition_2_PairedUTF16Surrogates_523 ()
 913                 {
 914                         byte[] data = { 0xED, 0xAD, 0xBF, 0xED, 0xB0, 0x80 };
 915                         string s = utf8.GetString (data);
 916                         // exception is "really" expected here
 917                         Assert.AreEqual (56191, s [0], "MS FX 1.1 behaviour");
 918                         Assert.AreEqual (56320, s [1], "MS FX 1.1 behaviour");
 919                 }
 920
 921                 [Test]
 922 #if NET_2_0
 923                 [ExpectedException (typeof (DecoderFallbackException))]
 924 #else
 925 // MS Fx 1.1 accept this
 926                 [Category ("NotDotNet")]
 927                 [ExpectedException (typeof (DecoderException))]
 928 #endif
 929                 public void T5_IllegalCodePosition_2_PairedUTF16Surrogates_524 ()
 930                 {
 931                         byte[] data = { 0xED, 0xAD, 0xBF, 0xED, 0xBF, 0xBF };
 932                         string s = utf8.GetString (data);
 933                         // exception is "really" expected here
 934                         Assert.AreEqual (56191, s [0], "MS FX 1.1 behaviour");
 935                         Assert.AreEqual (57343, s [1], "MS FX 1.1 behaviour");
 936                 }
 937
 938                 [Test]
 939 #if NET_2_0
 940                 [ExpectedException (typeof (DecoderFallbackException))]
 941 #else
 942 // MS Fx 1.1 accept this
 943                 [Category ("NotDotNet")]
 944                 [ExpectedException (typeof (DecoderException))]
 945 #endif
 946                 public void T5_IllegalCodePosition_2_PairedUTF16Surrogates_525 ()
 947                 {
 948                         byte[] data = { 0xED, 0xAE, 0x80, 0xED, 0xB0, 0x80 };
 949                         string s = utf8.GetString (data);
 950                         // exception is "really" expected here
 951                         Assert.AreEqual (56192, s [0], "MS FX 1.1 behaviour");
 952                         Assert.AreEqual (56320, s [1], "MS FX 1.1 behaviour");
 953                 }
 954
 955                 [Test]
 956 #if NET_2_0
 957                 [ExpectedException (typeof (DecoderFallbackException))]
 958 #else
 959 // MS Fx 1.1 accept this
 960                 [Category ("NotDotNet")]
 961                 [ExpectedException (typeof (DecoderException))]
 962 #endif
 963                 public void T5_IllegalCodePosition_2_PairedUTF16Surrogates_526 ()
 964                 {
 965                         byte[] data = { 0xED, 0xAE, 0x80, 0xED, 0xBF, 0x8F };
 966                         string s = utf8.GetString (data);
 967                         // exception is "really" expected here
 968                         Assert.AreEqual (56192, s [0], "MS FX 1.1 behaviour");
 969                         Assert.AreEqual (57295, s [1], "MS FX 1.1 behaviour");
 970                 }
 971
 972                 [Test]
 973 #if NET_2_0
 974                 [ExpectedException (typeof (DecoderFallbackException))]
 975 #else
 976 // MS Fx 1.1 accept this
 977                 [Category ("NotDotNet")]
 978                 [ExpectedException (typeof (DecoderException))]
 979 #endif
 980                 public void T5_IllegalCodePosition_2_PairedUTF16Surrogates_527 ()
 981                 {
 982                         byte[] data = { 0xED, 0xAF, 0xBF, 0xED, 0xB0, 0x80 };
 983                         string s = utf8.GetString (data);
 984                         // exception is "really" expected here
 985                         Assert.AreEqual (56319, s [0], "MS FX 1.1 behaviour");
 986                         Assert.AreEqual (56320, s [1], "MS FX 1.1 behaviour");
 987                 }
 988
 989                 [Test]
 990 #if NET_2_0
 991                 [ExpectedException (typeof (DecoderFallbackException))]
 992 #else
 993 // MS Fx 1.1 accept this
 994                 [Category ("NotDotNet")]
 995                 [ExpectedException (typeof (DecoderException))]
 996 #endif
 997                 public void T5_IllegalCodePosition_2_PairedUTF16Surrogates_528 ()
 998                 {
 999                         byte[] data = { 0xED, 0xAF, 0xBF, 0xED, 0xBF, 0xBF };
1000                         string s = utf8.GetString (data);
1001                         // exception is "really" expected here
1002                         Assert.AreEqual (56319, s [0], "MS FX 1.1 behaviour");
1003                         Assert.AreEqual (57343, s [1], "MS FX 1.1 behaviour");
1004                 }
1005
1006                 [Test]
1007 // MS Fx 1.1 accept this
1008 //              [ExpectedException (typeof (DecoderException))]
1009                 public void T5_IllegalCodePosition_3_Other_531 ()
1010                 {
1011                         byte[] data = { 0xEF, 0xBF, 0xBE };
1012                         string s = utf8.GetString (data);
1013                         // exception is "really" expected here
1014                         Assert.AreEqual (65534, s [0], "MS FX 1.1 behaviour");
1015                 }
1016
1017                 [Test]
1018 // MS Fx 1.1 accept this
1019 //              [ExpectedException (typeof (DecoderException))]
1020                 public void T5_IllegalCodePosition_3_Other_532 ()
1021                 {
1022                         byte[] data = { 0xEF, 0xBF, 0xBF };
1023                         string s = utf8.GetString (data);
1024                         // exception is "really" expected here
1025                         Assert.AreEqual (65535, s [0], "MS FX 1.1 behaviour");
1026                 }
1027
1028                 [Test]
1029                 // bug #75065 and #73086.
1030                 public void GetCharsFEFF ()
1031                 {
1032                         byte [] data = new byte [] {0xEF, 0xBB, 0xBF};
1033                         Encoding enc = new UTF8Encoding (false, true);
1034                         string s = enc.GetString (data);
1035                         Assert.AreEqual (s, "\uFEFF");
1036
1037                         Encoding utf = Encoding.UTF8;
1038                         char[] testChars = {'\uFEFF','A'};
1039
1040                         byte[] bytes = utf.GetBytes(testChars);
1041                         char[] chars = utf.GetChars(bytes);
1042                         Assert.AreEqual ('\uFEFF', chars [0], "#1");
1043                         Assert.AreEqual ('A', chars [1], "#2");
1044                 }
1045
1046 #if NET_2_0
1047                 [Test]
1048                 public void CloneNotReadOnly ()
1049                 {
1050                         Encoding e = Encoding.GetEncoding (65001).Clone ()
1051                                 as Encoding;
1052                         Assert.AreEqual (false, e.IsReadOnly);
1053                         e.EncoderFallback = new EncoderExceptionFallback ();
1054                 }
1055 #endif
1056
1057                 [Test]
1058 #if NET_2_0
1059                 [ExpectedException (typeof (DecoderFallbackException))]
1060 #else
1061                 [ExpectedException (typeof (ArgumentException))]
1062                 [Category ("NotDotNet")] // MS Bug
1063 #endif
1064                 public void Bug77315 ()
1065                 {
1066                         new UTF8Encoding (false, true).GetString (
1067                                 new byte [] {0xED, 0xA2, 0x8C});
1068                 }
1069
1070                 [Test]
1071                 public void SufficientByteArray ()
1072                 {
1073                         Encoder e = Encoding.UTF8.GetEncoder ();
1074                         byte [] bytes = new byte [0];
1075
1076                         char [] chars = new char [] {'\uD800'};
1077                         e.GetBytes (chars, 0, 1, bytes, 0, false);
1078                         try {
1079                                 int ret = e.GetBytes (chars, 1, 0, bytes, 0, true);
1080 #if NET_2_0
1081                                 Assert.AreEqual (0, ret, "drop insufficient char in 2.0: char[]");
1082 #else
1083                                 Assert.Fail ("ArgumentException is expected: char[]");
1084 #endif
1085                         } catch (ArgumentException ae) {
1086 #if NET_2_0
1087                                 throw ae;
1088 #endif
1089                         }
1090
1091                         string s = "\uD800";
1092                         try {
1093                                 int ret = Encoding.UTF8.GetBytes (s, 0, 1, bytes, 0);
1094 #if NET_2_0
1095                                 Assert.AreEqual (0, ret, "drop insufficient char in 2.0: string");
1096 #else
1097                                 Assert.Fail ("ArgumentException is expected: string");
1098 #endif
1099                         } catch (ArgumentException ae) {
1100 #if NET_2_0
1101                                 throw ae;
1102 #endif
1103                         }
1104                 }
1105
1106                 [Test] // bug #565129
1107                 public void SufficientByteArray2 ()
1108                 {
1109                         var u = Encoding.UTF8;
1110                         Assert.AreEqual (3, u.GetByteCount ("\uFFFD"), "#1-1");
1111                         Assert.AreEqual (3, u.GetByteCount ("\uD800"), "#1-2");
1112                         Assert.AreEqual (3, u.GetByteCount ("\uDC00"), "#1-3");
1113                         Assert.AreEqual (4, u.GetByteCount ("\uD800\uDC00"), "#1-4");
1114                         byte [] bytes = new byte [10];
1115                         Assert.AreEqual (3, u.GetBytes ("\uDC00", 0, 1, bytes, 0), "#1-5"); // was bogus
1116
1117                         Assert.AreEqual (3, u.GetBytes ("\uFFFD").Length, "#2-1");
1118                         Assert.AreEqual (3, u.GetBytes ("\uD800").Length, "#2-2");
1119                         Assert.AreEqual (3, u.GetBytes ("\uDC00").Length, "#2-3");
1120                         Assert.AreEqual (4, u.GetBytes ("\uD800\uDC00").Length, "#2-4");
1121
1122                         for (char c = char.MinValue; c < char.MaxValue; c++) {
1123                                 byte [] bIn;
1124                                 bIn = u.GetBytes (c.ToString ());
1125                         }
1126
1127                         try {
1128                                 new UTF8Encoding (false, true).GetBytes (new char [] {'\uDF45', '\uD808'}, 0, 2);
1129                                 Assert.Fail ("EncoderFallbackException is expected");
1130                         } catch (EncoderFallbackException) {
1131                         }
1132                 }
1133
1134 #if NET_2_0
1135                 [Test] // bug #77550
1136                 public void DecoderFallbackSimple ()
1137                 {
1138                         UTF8Encoding e = new UTF8Encoding (false, false);
1139                         AssertType.AreEqual (1, e.GetDecoder ().GetCharCount (
1140                                         new byte [] {(byte) 183}, 0, 1),
1141                                         "#1");
1142                         AssertType.AreEqual (1, e.GetDecoder().GetChars (
1143                                         new byte [] {(byte) 183}, 0, 1,
1144                                         new char [100], 0),
1145                                         "#2");
1146                         AssertType.AreEqual (1, e.GetString (new byte [] {(byte) 183}).Length,
1147                                         "#3");
1148                 }
1149
1150                 [Test]
1151                 public void FallbackDefaultEncodingUTF8 ()
1152                 {
1153                         DecoderReplacementFallbackBuffer b =
1154                                 Encoding.UTF8.DecoderFallback.CreateFallbackBuffer ()
1155                                 as DecoderReplacementFallbackBuffer;
1156                         AssertType.IsTrue (b.Fallback (new byte [] {}, 0), "#1");
1157                         AssertType.IsFalse (b.MovePrevious (), "#2");
1158                         AssertType.AreEqual (1, b.Remaining, "#3");
1159                         AssertType.AreEqual ('\uFFFD', b.GetNextChar (), "#4");
1160                 }
1161
1162                 [Test]
1163                 [Category ("MobileNotWorking")]
1164                 public void Bug415628 ()
1165                 {
1166                         using (var f = File.Open ("Test/resources/415628.bin", FileMode.Open)) {
1167                                 BinaryReader br = new BinaryReader (f);
1168                                 byte [] buf = br.ReadBytes (8000);
1169                                 Encoding.UTF8.GetString(buf);
1170                         }
1171                 }
1172 #endif
1173
1174                 [Test]
1175                 [ExpectedException (typeof (ArgumentException))]
1176                 public void Bug10788()
1177                 {
1178                         byte[] bytes = new byte[4096];
1179                         char[] chars = new char[10];
1180
1181                         Encoding.UTF8.GetDecoder ().GetChars (bytes, 0, 4096, chars, 9, false);
1182                 }
1183
1184                 [Test]
1185                 public void Bug10789()
1186                 {
1187                         byte[] bytes = new byte[4096];
1188                         char[] chars = new char[10];
1189
1190                         try {
1191                                 Encoding.UTF8.GetDecoder ().GetChars (bytes, 0, 1, chars, 10, false);
1192                                 Assert.Fail ("ArgumentException is expected #1");
1193                         } catch (ArgumentException) {
1194                         }
1195
1196                         try {
1197                                 Encoding.UTF8.GetDecoder ().GetChars (bytes, 0, 1, chars, 11, false);
1198                                 Assert.Fail ("ArgumentOutOfRangeException is expected #2");
1199                         } catch (ArgumentOutOfRangeException) {
1200                         }
1201
1202                         int charactersWritten = Encoding.UTF8.GetDecoder ().GetChars (bytes, 0, 0, chars, 10, false);
1203                         Assert.AreEqual (0, charactersWritten, "#3");
1204                 }
1205
1206                 // DecoderFallbackExceptionTest
1207                 //   This struct describes a DecoderFallbackExceptions' test. It
1208                 //   contains the expected indexes (eindex) and bad-bytes lengths
1209                 //   (elen) delivered by the first and subsequent
1210                 //   DecoderFallbackException throwed when the utf8 conversion routines
1211                 //   are exposed by the array of bytes (bytes) contained in this test.
1212                 //   It also has a nice description (description) for documentation and
1213                 //   debugging.
1214                 //
1215                 //   The hardcoded 'eindex' and 'elen' info is the output that you will
1216                 //   got if you run this strings on the MS.NET platform.
1217                 struct DecoderFallbackExceptionTest
1218                 {
1219                         public string description;
1220                         public byte [] bytes;
1221                         public int [] eindex;
1222                         public int [] elen;
1223                         public DecoderFallbackExceptionTest (
1224                                         string description,
1225                                         int [] eindex,
1226                                         int [] elen,
1227                                         byte [] bytes)
1228                         {
1229                                 this.description = description;
1230                                 this.bytes = bytes;
1231                                 if (eindex.Length != elen.Length)
1232                                         throw new ApplicationException ("eindex.Length != elen.Length in test '" + description + "'");
1233                                 this.eindex = eindex;
1234                                 this.elen = elen;
1235                         }
1236                 }
1237
1238                 // try to convert the all current test's bytes with Getchars()
1239                 // in only one step
1240                 private void DecoderFallbackExceptions_GetChars (
1241                         char [] chars,
1242                         int testno,
1243                         Decoder dec,
1244                         DecoderFallbackExceptionTest t)
1245                 {
1246                         try {
1247                                 dec.GetChars (t.bytes, 0, t.bytes.Length, chars, 0, true);
1248                                         Assert.IsTrue (
1249                                                 t.eindex.Length == 0,
1250                                                 String.Format (
1251                                                         "test#{0}-1: UNEXPECTED SUCCESS",
1252                                                         testno));
1253                         } catch(DecoderFallbackException ex) {
1254                                 Assert.IsTrue (
1255                                         t.eindex.Length > 0,
1256                                         String.Format (
1257                                                 "test#{0}-1: UNEXPECTED FAIL",
1258                                                 testno));
1259                                 Assert.IsTrue (
1260                                         ex.Index == t.eindex[0],
1261                                         String.Format (
1262                                                 "test#{0}-1: Expected exception at {1} not {2}.",
1263                                                 testno,
1264                                                 t.eindex[0],
1265                                                 ex.Index));
1266                                 Assert.IsTrue (
1267                                         ex.BytesUnknown.Length == t.elen[0],
1268                                         String.Format (
1269                                                 "test#{0}-1: Expected BytesUnknown.Length of {1} not {2}.",
1270                                                 testno,
1271                                                 t.elen[0],
1272                                                 ex.BytesUnknown.Length));
1273                                 for (int i = 0; i < ex.BytesUnknown.Length; i++)
1274                                         Assert.IsTrue (
1275                                                 ex.BytesUnknown[i] == t.bytes[ex.Index + i],
1276                                                 String.Format (
1277                                                         "test#{0}-1: expected byte {1:X} not {2:X} at {3}.",
1278                                                         testno,
1279                                                         t.bytes[ex.Index + i],
1280                                                         ex.BytesUnknown[i],
1281                                                         ex.Index + i));
1282                                 dec.Reset ();
1283                         }
1284                 }
1285
1286                 // convert bytes to string using a fixed blocksize.
1287                 // If something bad happens, try to recover using the
1288                 // DecoderFallbackException info.
1289                 private void DecoderFallbackExceptions_Convert (
1290                         char [] chars,
1291                         int testno,
1292                         Decoder dec,
1293                         DecoderFallbackExceptionTest t,
1294                         int block_size)
1295                 {
1296                         int charsUsed, bytesUsed;
1297                         bool completed;
1298
1299                         int ce = 0; // current exception
1300                         for (int c = 0; c < t.bytes.Length; ) {
1301                                 try {
1302                                         int bu = c + block_size > t.bytes.Length
1303                                                         ? t.bytes.Length - c
1304                                                         : block_size;
1305                                         dec.Convert (
1306                                                 t.bytes, c, bu,
1307                                                 chars, 0, chars.Length,
1308                                                 c + bu >= t.bytes.Length,
1309                                                 out bytesUsed, out charsUsed,
1310                                                 out completed);
1311                                         c += bytesUsed;
1312                                 } catch (DecoderFallbackException ex) {
1313                                         Assert.IsTrue (
1314                                                 t.eindex.Length > ce,
1315                                                 String.Format (
1316                                                         "test#{0}-2-{1}#{2}: UNEXPECTED FAIL (c={3}, eIndex={4}, eBytesUnknwon={5})",
1317                                                         testno, block_size, ce, c,
1318                                                         ex.Index,
1319                                                         ex.BytesUnknown.Length));
1320                                         Assert.IsTrue (
1321                                                 ex.Index + c == t.eindex[ce],
1322                                                 String.Format (
1323                                                         "test#{0}-2-{1}#{2}: Expected at {3} not {4}.",
1324                                                         testno, block_size, ce,
1325                                                         t.eindex[ce],
1326                                                         ex.Index + c));
1327                                         Assert.IsTrue (
1328                                                 ex.BytesUnknown.Length == t.elen[ce],
1329                                                 String.Format (
1330                                                         "test#{0}-2-{1}#{2}: Expected BytesUnknown.Length of {3} not {4} @{5}.",
1331                                                         testno, block_size, ce,
1332                                                         t.elen[0], ex.BytesUnknown.Length, c));
1333                                         for (int i = 0; i < ex.BytesUnknown.Length; i++)
1334                                                 Assert.IsTrue (
1335                                                         ex.BytesUnknown[i] == t.bytes[ex.Index + i + c],
1336                                                         String.Format (
1337                                                                 "test#{0}-2-{1}#{2}: Expected byte {3:X} not {4:X} at {5}.",
1338                                                                 testno, block_size, ce,
1339                                                                 t.bytes[ex.Index + i + c],
1340                                                                 ex.BytesUnknown[i],
1341                                                                 ex.Index + i));
1342                                         c += ex.BytesUnknown.Length + ex.Index;
1343                                         dec.Reset ();
1344                                         ce++;
1345                                 }
1346                         }
1347                         Assert.IsTrue (
1348                                 ce == t.eindex.Length,
1349                                 String.Format (
1350                                         "test#{0}-2-{1}: UNEXPECTED SUCCESS (expected {2} exceptions, but happened {3})",
1351                                         testno, block_size, t.eindex.Length, ce));
1352                 }
1353
1354                 [Test]
1355                 public void DecoderFallbackExceptions ()
1356                 {
1357
1358                         DecoderFallbackExceptionTest [] tests = new DecoderFallbackExceptionTest []
1359                         {
1360                                 /* #1  */
1361                                 new DecoderFallbackExceptionTest (
1362                                         "Greek word 'kosme'",
1363                                         new int [] { },
1364                                         new int [] { },
1365                                         new byte [] {
1366                                                 0xce, 0xba, 0xe1, 0xbd, 0xb9, 0xcf,
1367                                                 0x83, 0xce, 0xbc, 0xce, 0xb5 }),
1368                                 /* #2  */
1369                                 new DecoderFallbackExceptionTest (
1370                                         "First possible sequence of 1 byte",
1371                                         new int [] { },
1372                                         new int [] { },
1373                                         new byte [] { 0x00 }),
1374                                 /* #3  */
1375                                 new DecoderFallbackExceptionTest (
1376                                         "First possible sequence of 2 bytes",
1377                                         new int [] { },
1378                                         new int [] { },
1379                                         new byte [] { 0xc2, 0x80 }),
1380                                 /* #4  */
1381                                 new DecoderFallbackExceptionTest (
1382                                         "First possible sequence of 3 bytes",
1383                                         new int [] { },
1384                                         new int [] { },
1385                                         new byte [] { 0xe0, 0xa0, 0x80 }),
1386                                 /* #5  */
1387                                 new DecoderFallbackExceptionTest (
1388                                         "First possible sequence of 4 bytes",
1389                                         new int [] { },
1390                                         new int [] { },
1391                                         new byte [] { 0xf0, 0x90, 0x80, 0x80 }),
1392                                 /* #6  */
1393                                 new DecoderFallbackExceptionTest (
1394                                         "First possible sequence of 5 bytes",
1395                                         new int [] { 0, 1, 2, 3, 4 },
1396                                         new int [] { 1, 1, 1, 1, 1 },
1397                                         new byte [] { 0xf8, 0x88, 0x80, 0x80, 0x80 }),
1398                                 /* #7  */
1399                                 new DecoderFallbackExceptionTest (
1400                                         "First possible sequence of 6 bytes",
1401                                         new int [] { 0, 1, 2, 3, 4, 5 },
1402                                         new int [] { 1, 1, 1, 1, 1, 1 },
1403                                         new byte [] {
1404                                                 0xfc, 0x84, 0x80, 0x80, 0x80, 0x80 }),
1405                                 /* #8  */
1406                                 new DecoderFallbackExceptionTest (
1407                                         "Last possible sequence of 1 byte",
1408                                         new int [] { },
1409                                         new int [] { },
1410                                         new byte [] { 0x7f }),
1411                                 /* #9  */
1412                                 new DecoderFallbackExceptionTest (
1413                                         "Last possible sequence of 2 bytes",
1414                                         new int [] { },
1415                                         new int [] { },
1416                                         new byte [] { 0xdf, 0xbf }),
1417                                 /* #10 */
1418                                 new DecoderFallbackExceptionTest (
1419                                         "Last possible sequence of 3 bytes",
1420                                         new int [] { },
1421                                         new int [] { },
1422                                         new byte [] { 0xef, 0xbf, 0xbf }),
1423                                 /* #11 */
1424                                 new DecoderFallbackExceptionTest (
1425                                         "Last possible sequence of 4 bytes",
1426                                         new int [] { 0, 1, 2, 3 },
1427                                         new int [] { 1, 1, 1, 1 },
1428                                         new byte [] { 0xf7, 0xbf, 0xbf, 0xbf }),
1429                                 /* #12 */
1430                                 new DecoderFallbackExceptionTest (
1431                                         "Last possible sequence of 5 bytes",
1432                                         new int [] { 0, 1, 2, 3, 4 },
1433                                         new int [] { 1, 1, 1, 1, 1 },
1434                                         new byte [] { 0xfb, 0xbf, 0xbf, 0xbf, 0xbf }),
1435                                 /* #13 */
1436                                 new DecoderFallbackExceptionTest (
1437                                         "Last possible sequence of 6 bytes",
1438                                         new int [] { 0, 1, 2, 3, 4, 5 },
1439                                         new int [] { 1, 1, 1, 1, 1, 1 },
1440                                         new byte [] { 0xfd, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf }),
1441                                 /* #14 */
1442                                 new DecoderFallbackExceptionTest (
1443                                         "U-0000D7FF = ed 9f bf",
1444                                         new int [] { },
1445                                         new int [] { },
1446                                         new byte [] { 0xed, 0x9f, 0xbf }),
1447                                 /* #15 */
1448                                 new DecoderFallbackExceptionTest (
1449                                         "U-0000E000 = ee 80 80",
1450                                         new int [] { },
1451                                         new int [] { },
1452                                         new byte [] { 0xee, 0x80, 0x80 }),
1453                                 /* #16 */
1454                                 new DecoderFallbackExceptionTest (
1455                                         "U-0000FFFD = ef bf bd",
1456                                         new int [] { },
1457                                         new int [] { },
1458                                         new byte [] { 0xef, 0xbf, 0xbd }),
1459                                 /* #17 */
1460                                 new DecoderFallbackExceptionTest (
1461                                         "U-0010FFFF = f4 8f bf bf",
1462                                         new int [] { },
1463                                         new int [] { },
1464                                         new byte [] { 0xf4, 0x8f, 0xbf, 0xbf }),
1465                                 /* #18 */
1466                                 new DecoderFallbackExceptionTest (
1467                                         "U-00110000 = f4 90 80 80",
1468                                         new int [] { 0, 2, 3 },
1469                                         new int [] { 2, 1, 1 },
1470                                         new byte [] { 0xf4, 0x90, 0x80, 0x80 }),
1471                                 /* #19 */
1472                                 new DecoderFallbackExceptionTest (
1473                                         "First continuation byte 0x80",
1474                                         new int [] { 0 },
1475                                         new int [] { 1 },
1476                                         new byte [] { 0x80 }),
1477                                 /* #20 */
1478                                 new DecoderFallbackExceptionTest (
1479                                         "Last  continuation byte 0xbf",
1480                                         new int [] { 0 },
1481                                         new int [] { 1 },
1482                                         new byte [] { 0xbf }),
1483                                 /* #21 */
1484                                 new DecoderFallbackExceptionTest (
1485                                         "2 continuation bytes",
1486                                         new int [] { 0, 1 },
1487                                         new int [] { 1, 1 },
1488                                         new byte [] { 0x80, 0xbf }),
1489                                 /* #22 */
1490                                 new DecoderFallbackExceptionTest (
1491                                         "3 continuation bytes",
1492                                         new int [] { 0, 1, 2 },
1493                                         new int [] { 1, 1, 1 },
1494                                         new byte [] { 0x80, 0xbf, 0x80 }),
1495                                 /* #23 */
1496                                 new DecoderFallbackExceptionTest (
1497                                         "4 continuation bytes",
1498                                         new int [] { 0, 1, 2, 3 },
1499                                         new int [] { 1, 1, 1, 1 },
1500                                         new byte [] { 0x80, 0xbf, 0x80, 0xbf }),
1501                                 /* #24 */
1502                                 new DecoderFallbackExceptionTest (
1503                                         "5 continuation bytes",
1504                                         new int [] { 0, 1, 2, 3, 4 },
1505                                         new int [] { 1, 1, 1, 1, 1 },
1506                                         new byte [] { 0x80, 0xbf, 0x80, 0xbf, 0x80 }),
1507                                 /* #25 */
1508                                 new DecoderFallbackExceptionTest (
1509                                         "6 continuation bytes",
1510                                         new int [] { 0, 1, 2, 3, 4, 5 },
1511                                         new int [] { 1, 1, 1, 1, 1, 1 },
1512                                         new byte [] {
1513                                                 0x80, 0xbf, 0x80, 0xbf, 0x80, 0xbf }),
1514                                 /* #26 */
1515                                 new DecoderFallbackExceptionTest (
1516                                         "7 continuation bytes",
1517                                         new int [] { 0, 1, 2, 3, 4, 5, 6 },
1518                                         new int [] { 1, 1, 1, 1, 1, 1, 1 },
1519                                         new byte [] {
1520                                                 0x80, 0xbf, 0x80, 0xbf, 0x80, 0xbf,
1521                                                 0x80 }),
1522                                 /* #27 */
1523                                 new DecoderFallbackExceptionTest (
1524                                         "Sequence of all 64 continuation bytes",
1525                                         new int [] {
1526                                                  0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
1527                                                 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
1528                                                 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
1529                                                 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
1530                                                 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
1531                                                 50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
1532                                                 60, 61, 62, 63 },
1533                                         new int [] {
1534                                                 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1535                                                 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1536                                                 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1537                                                 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1538                                                 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1539                                                 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1540                                                 1, 1, 1, 1 },
1541                                         new byte [] {
1542                                                 0x80, 0x81, 0x82, 0x83, 0x84, 0x85,
1543                                                 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b,
1544                                                 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91,
1545                                                 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
1546                                                 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d,
1547                                                 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3,
1548                                                 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9,
1549                                                 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
1550                                                 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5,
1551                                                 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb,
1552                                                 0xbc, 0xbd, 0xbe, 0xbf }),
1553                                 /* #28 */
1554                                 new DecoderFallbackExceptionTest (
1555                                         "All 32 first bytes of 2-byte sequences (0xc0-0xdf), each followed by a space character",
1556                                         new int [] {
1557                                                  0,  2,  4,  6,  8,
1558                                                 10, 12, 14, 16, 18,
1559                                                 20, 22, 24, 26, 28,
1560                                                 30, 32, 34, 36, 38,
1561                                                 40, 42, 44, 46, 48,
1562                                                 50, 52, 54, 56, 58,
1563                                                 60, 62 },
1564                                         new int [] {
1565                                                 1, 1, 1, 1, 1,
1566                                                 1, 1, 1, 1, 1,
1567                                                 1, 1, 1, 1, 1,
1568                                                 1, 1, 1, 1, 1,
1569                                                 1, 1, 1, 1, 1,
1570                                                 1, 1, 1, 1, 1,
1571                                                 1, 1 },
1572                                         new byte [] {
1573                                                 0xc0, 0x20, 0xc1, 0x20, 0xc2, 0x20,
1574                                                 0xc3, 0x20, 0xc4, 0x20, 0xc5, 0x20,
1575                                                 0xc6, 0x20, 0xc7, 0x20, 0xc8, 0x20,
1576                                                 0xc9, 0x20, 0xca, 0x20, 0xcb, 0x20,
1577                                                 0xcc, 0x20, 0xcd, 0x20, 0xce, 0x20,
1578                                                 0xcf, 0x20, 0xd0, 0x20, 0xd1, 0x20,
1579                                                 0xd2, 0x20, 0xd3, 0x20, 0xd4, 0x20,
1580                                                 0xd5, 0x20, 0xd6, 0x20, 0xd7, 0x20,
1581                                                 0xd8, 0x20, 0xd9, 0x20, 0xda, 0x20,
1582                                                 0xdb, 0x20, 0xdc, 0x20, 0xdd, 0x20,
1583                                                 0xde, 0x20, 0xdf, 0x20 }),
1584                                 /* #29 */
1585                                 new DecoderFallbackExceptionTest (
1586                                         "All 16 first bytes of 3-byte sequences (0xe0-0xef), each followed by a space character",
1587                                         new int [] {
1588                                                  0,  2,  4,  6,  8,
1589                                                 10, 12, 14, 16, 18,
1590                                                 20, 22, 24, 26, 28,
1591                                                 30 },
1592                                         new int [] {
1593                                                 1, 1, 1, 1, 1,
1594                                                 1, 1, 1, 1, 1,
1595                                                 1, 1, 1, 1, 1,
1596                                                 1 },
1597                                         new byte [] {
1598                                                 0xe0, 0x20, 0xe1, 0x20, 0xe2, 0x20,
1599                                                 0xe3, 0x20, 0xe4, 0x20, 0xe5, 0x20,
1600                                                 0xe6, 0x20, 0xe7, 0x20, 0xe8, 0x20,
1601                                                 0xe9, 0x20, 0xea, 0x20, 0xeb, 0x20,
1602                                                 0xec, 0x20, 0xed, 0x20, 0xee, 0x20,
1603                                                 0xef, 0x20 }),
1604                                 /* #30 */
1605                                 new DecoderFallbackExceptionTest (
1606                                         "All 8 first bytes of 4-byte sequences (0xf0-0xf7), each followed by a space character",
1607                                         new int [] { 0,  2,  4,  6,  8, 10, 12, 14 },
1608                                         new int [] { 1, 1, 1, 1, 1, 1, 1, 1 },
1609                                         new byte [] {
1610                                                 0xf0, 0x20, 0xf1, 0x20, 0xf2, 0x20,
1611                                                 0xf3, 0x20, 0xf4, 0x20, 0xf5, 0x20,
1612                                                 0xf6, 0x20, 0xf7, 0x20 }),
1613                                 /* #31 */
1614                                 new DecoderFallbackExceptionTest (
1615                                         "All 4 first bytes of 5-byte sequences (0xf8-0xfb), each followed by a space character",
1616                                         new int [] { 0, 2, 4, 6 },
1617                                         new int [] { 1, 1, 1, 1 },
1618                                         new byte [] {
1619                                                 0xf8, 0x20, 0xf9, 0x20, 0xfa, 0x20,
1620                                                 0xfb, 0x20 }),
1621                                 /* #32 */
1622                                 new DecoderFallbackExceptionTest (
1623                                         "All 2 first bytes of 6-byte sequences (0xfc-0xfd), each followed by a space character",
1624                                         new int [] { 0, 2 },
1625                                         new int [] { 1, 1 },
1626                                         new byte [] { 0xfc, 0x20, 0xfd, 0x20 }),
1627                                 /* #33 */
1628                                 new DecoderFallbackExceptionTest (
1629                                         "2-byte sequence with last byte missing",
1630                                         new int [] { 0 },
1631                                         new int [] { 1 },
1632                                         new byte [] { 0xc0 }),
1633                                 /* #34 */
1634                                 new DecoderFallbackExceptionTest (
1635                                         "3-byte sequence with last byte missing",
1636                                         new int [] { 0 },
1637                                         new int [] { 2 },
1638                                         new byte [] { 0xe0, 0x80 }),
1639                                 /* #35 */
1640                                 new DecoderFallbackExceptionTest (
1641                                         "4-byte sequence with last byte missing",
1642                                         new int [] { 0, 2 },
1643                                         new int [] { 2, 1 },
1644                                         new byte [] { 0xf0, 0x80, 0x80 }),
1645                                 /* #36 */
1646                                 new DecoderFallbackExceptionTest (
1647                                         "5-byte sequence with last byte missing",
1648                                         new int [] { 0, 1, 2, 3 },
1649                                         new int [] { 1, 1, 1, 1 },
1650                                         new byte [] { 0xf8, 0x80, 0x80, 0x80 }),
1651                                 /* #37 */
1652                                 new DecoderFallbackExceptionTest (
1653                                         "6-byte sequence with last byte missing",
1654                                         new int [] { 0, 1, 2, 3, 4 },
1655                                         new int [] { 1, 1, 1, 1, 1 },
1656                                         new byte [] { 0xfc, 0x80, 0x80, 0x80, 0x80 }),
1657                                 /* #38 */
1658                                 new DecoderFallbackExceptionTest (
1659                                         "2-byte sequence with last byte missing",
1660                                         new int [] { 0 },
1661                                         new int [] { 1 },
1662                                         new byte [] { 0xdf }),
1663                                 /* #39 */
1664                                 new DecoderFallbackExceptionTest (
1665                                         "3-byte sequence with last byte missing",
1666                                         new int [] { 0 },
1667                                         new int [] { 2 },
1668                                         new byte [] { 0xef, 0xbf }),
1669                                 /* #40 */
1670                                 new DecoderFallbackExceptionTest (
1671                                         "4-byte sequence with last byte missing",
1672                                         new int [] { 0, 1, 2 },
1673                                         new int [] { 1, 1, 1 },
1674                                         new byte [] { 0xf7, 0xbf, 0xbf }),
1675                                 /* #41 */
1676                                 new DecoderFallbackExceptionTest (
1677                                         "5-byte sequence with last byte missing",
1678                                         new int [] { 0, 1, 2, 3 },
1679                                         new int [] { 1, 1, 1, 1 },
1680                                         new byte [] { 0xfb, 0xbf, 0xbf, 0xbf }),
1681                                 /* #42 */
1682                                 new DecoderFallbackExceptionTest (
1683                                         "6-byte sequence with last byte missing",
1684                                         new int [] { 0, 1, 2, 3, 4 },
1685                                         new int [] { 1, 1, 1, 1, 1 },
1686                                         new byte [] { 0xfd, 0xbf, 0xbf, 0xbf, 0xbf }),
1687                                 /* #43 */
1688                                 new DecoderFallbackExceptionTest (
1689                                         "All the 10 sequences of 3.3 concatenated",
1690                                         new int [] {
1691                                                  0,  1,      3,
1692                                                  5,  6,  7,  8,  9,
1693                                                 10, 11, 12, 13, 14,
1694                                                 15, 16,     18, 19,
1695                                                 20, 21, 22, 23, 24,
1696                                                 25, 26, 27, 28, 29 },
1697                                         new int [] {
1698                                                  1,  2,      2,
1699                                                  1,  1,  1,  1,  1,
1700                                                  1,  1,  1,  1,  1,
1701                                                  1,  2,      1,  1,
1702                                                  1,  1,  1,  1,  1,
1703                                                  1,  1,  1,  1,  1 },
1704                                         new byte [] {
1705                                                 0xc0, 0xe0, 0x80, 0xf0, 0x80, 0x80,
1706                                                 0xf8, 0x80, 0x80, 0x80, 0xfc, 0x80,
1707                                                 0x80, 0x80, 0x80, 0xdf, 0xef, 0xbf,
1708                                                 0xf7, 0xbf, 0xbf, 0xfb, 0xbf, 0xbf,
1709                                                 0xbf, 0xfd, 0xbf, 0xbf, 0xbf, 0xbf }),
1710                                 /* #44 */
1711                                 new DecoderFallbackExceptionTest (
1712                                         "Bad chars fe",
1713                                         new int [] { 0 },
1714                                         new int [] { 1 },
1715                                         new byte [] { 0xfe }),
1716                                 /* #45 */
1717                                 new DecoderFallbackExceptionTest (
1718                                         "Bad chars ff",
1719                                         new int [] { 0 },
1720                                         new int [] { 1 },
1721                                         new byte [] { 0xff }),
1722                                 /* #46 */
1723                                 new DecoderFallbackExceptionTest (
1724                                         "Bad chars fe fe ff ff",
1725                                         new int [] { 0, 1, 2, 3 },
1726                                         new int [] { 1, 1, 1, 1 },
1727                                         new byte [] { 0xfe, 0xfe, 0xff, 0xff }),
1728                                 /* #47 */
1729                                 new DecoderFallbackExceptionTest (
1730                                         "Overlong U+002F = c0 af",
1731                                         new int [] { 0, 1 },
1732                                         new int [] { 1, 1 },
1733                                         new byte [] { 0xc0, 0xaf }),
1734                                 /* #48 */
1735                                 new DecoderFallbackExceptionTest (
1736                                         "Overlong U+002F = e0 80 af",
1737                                         new int [] { 0, 2 },
1738                                         new int [] { 2, 1 },
1739                                         new byte [] { 0xe0, 0x80, 0xaf }),
1740                                 /* #49 */
1741                                 new DecoderFallbackExceptionTest (
1742                                         "Overlong U+002F = f0 80 80 af",
1743                                         new int [] { 0, 2, 3 },
1744                                         new int [] { 2, 1, 1 },
1745                                         new byte [] { 0xf0, 0x80, 0x80, 0xaf }),
1746                                 /* #50 */
1747                                 new DecoderFallbackExceptionTest (
1748                                         "Overlong U+002F = f8 80 80 80 af",
1749                                         new int [] { 0, 1, 2, 3, 4 },
1750                                         new int [] { 1, 1, 1, 1, 1 },
1751                                         new byte [] { 0xf8, 0x80, 0x80, 0x80, 0xaf }),
1752                                 /* #51 */
1753                                 new DecoderFallbackExceptionTest (
1754                                         "Overlong U+002F = fc 80 80 80 80 af",
1755                                         new int [] { 0, 1, 2, 3, 4, 5 },
1756                                         new int [] { 1, 1, 1, 1, 1, 1 },
1757                                         new byte [] {
1758                                                 0xfc, 0x80, 0x80, 0x80, 0x80, 0xaf }),
1759                                 /* #52 */
1760                                 new DecoderFallbackExceptionTest (
1761                                         "Maximum overlong U-0000007F",
1762                                         new int [] { 0, 1 },
1763                                         new int [] { 1, 1 },
1764                                         new byte [] { 0xc1, 0xbf }),
1765                                 /* #53 */
1766                                 new DecoderFallbackExceptionTest (
1767                                         "Maximum overlong U-000007FF",
1768                                         new int [] { 0, 2 },
1769                                         new int [] { 2, 1, },
1770                                         new byte [] { 0xe0, 0x9f, 0xbf }),
1771                                 /* #54 */
1772                                 new DecoderFallbackExceptionTest (
1773                                         "Maximum overlong U-0000FFFF",
1774                                         new int [] { 0, 2, 3 },
1775                                         new int [] { 2, 1, 1 },
1776                                         new byte [] { 0xf0, 0x8f, 0xbf, 0xbf }),
1777                                 /* #55 */
1778                                 new DecoderFallbackExceptionTest (
1779                                         "Maximum overlong U-001FFFFF",
1780                                         new int [] { 0, 1, 2, 3, 4 },
1781                                         new int [] { 1, 1, 1, 1, 1 },
1782                                         new byte [] { 0xf8, 0x87, 0xbf, 0xbf, 0xbf }),
1783                                 /* #56 */
1784                                 new DecoderFallbackExceptionTest (
1785                                         "Maximum overlong U-03FFFFFF",
1786                                         new int [] { 0, 1, 2, 3, 4, 5 },
1787                                         new int [] { 1, 1, 1, 1, 1, 1 },
1788                                         new byte [] {
1789                                                 0xfc, 0x83, 0xbf, 0xbf, 0xbf, 0xbf }),
1790                                 /* #57 */
1791                                 new DecoderFallbackExceptionTest (
1792                                         "Null overlong c0 80",
1793                                         new int [] { 0, 1 },
1794                                         new int [] { 1, 1 },
1795                                         new byte [] { 0xc0, 0x80, 0x22 }),
1796                                 /* #58 */
1797                                 new DecoderFallbackExceptionTest (
1798                                         "Null overlong e0 80 80",
1799                                         new int [] { 0, 2 },
1800                                         new int [] { 2, 1 },
1801                                         new byte [] { 0xe0, 0x80, 0x80 }),
1802                                 /* #59 */
1803                                 new DecoderFallbackExceptionTest (
1804                                         "Null overlong f0 80 80 80",
1805                                         new int [] { 0, 2, 3 },
1806                                         new int [] { 2, 1, 1 },
1807                                         new byte [] { 0xf0, 0x80, 0x80, 0x80 }),
1808                                 /* #60 */
1809                                 new DecoderFallbackExceptionTest (
1810                                         "Null overlong f8 80 80 80 80",
1811                                         new int [] { 0, 1, 2, 3, 4 },
1812                                         new int [] { 1, 1, 1, 1, 1 },
1813                                         new byte [] { 0xf8, 0x80, 0x80, 0x80, 0x80 }),
1814                                 /* #61 */
1815                                 new DecoderFallbackExceptionTest (
1816                                         "Null overlong fc 80 80 80 80 80",
1817                                         new int [] { 0, 1, 2, 3, 4, 5 },
1818                                         new int [] { 1, 1, 1, 1, 1, 1 },
1819                                         new byte [] {
1820                                                 0xfc, 0x80, 0x80, 0x80, 0x80, 0x80 }),
1821                                 /* #62 */
1822                                 new DecoderFallbackExceptionTest (
1823                                         "Single UTF-16 surrogate U+D800",
1824                                         new int [] { 0, 2 },
1825                                         new int [] { 2, 1 },
1826                                         new byte [] { 0xed, 0xa0, 0x80 }),
1827                                 /* #63 */
1828                                 new DecoderFallbackExceptionTest (
1829                                         "Single UTF-16 surrogate U+DB7F",
1830                                         new int [] { 0, 2 },
1831                                         new int [] { 2, 1 },
1832                                         new byte [] { 0xed, 0xad, 0xbf }),
1833                                 /* #64 */
1834                                 new DecoderFallbackExceptionTest (
1835                                         "Single UTF-16 surrogate U+DB80",
1836                                         new int [] { 0, 2 },
1837                                         new int [] { 2, 1 },
1838                                         new byte [] { 0xed, 0xae, 0x80 }),
1839                                 /* #65 */
1840                                 new DecoderFallbackExceptionTest (
1841                                         "Single UTF-16 surrogate U+DBFF",
1842                                         new int [] { 0, 2 },
1843                                         new int [] { 2, 1 },
1844                                         new byte [] { 0xed, 0xaf, 0xbf }),
1845                                 /* #66 */
1846                                 new DecoderFallbackExceptionTest (
1847                                         "Single UTF-16 surrogate U+DC00",
1848                                         new int [] { 0, 2 },
1849                                         new int [] { 2, 1 },
1850                                         new byte [] { 0xed, 0xb0, 0x80 }),
1851                                 /* #67 */
1852                                 new DecoderFallbackExceptionTest (
1853                                         "Single UTF-16 surrogate U+DF80",
1854                                         new int [] { 0, 2 },
1855                                         new int [] { 2, 1 },
1856                                         new byte [] { 0xed, 0xbe, 0x80 }),
1857                                 /* #68 */
1858                                 new DecoderFallbackExceptionTest (
1859                                         "Single UTF-16 surrogate U+DFFF",
1860                                         new int [] { 0, 2 },
1861                                         new int [] { 2, 1 },
1862                                         new byte [] { 0xed, 0xbf, 0xbf }),
1863                                 /* #69 */
1864                                 new DecoderFallbackExceptionTest (
1865                                         "Paired UTF-16 surrogate U+D800 U+DC00",
1866                                         new int [] { 0, 2, 3, 5 },
1867                                         new int [] { 2, 1, 2, 1 },
1868                                         new byte [] {
1869                                                 0xed, 0xa0, 0x80, 0xed, 0xb0, 0x80 }),
1870                                 /* #70 */
1871                                 new DecoderFallbackExceptionTest (
1872                                         "Paired UTF-16 surrogate U+D800 U+DFFF",
1873                                         new int [] { 0, 2, 3, 5 },
1874                                         new int [] { 2, 1, 2, 1 },
1875                                         new byte [] {
1876                                                 0xed, 0xa0, 0x80, 0xed, 0xbf, 0xbf }),
1877                                 /* #71 */
1878                                 new DecoderFallbackExceptionTest (
1879                                         "Paired UTF-16 surrogate U+DB7F U+DC00",
1880                                         new int [] { 0, 2, 3, 5 },
1881                                         new int [] { 2, 1, 2, 1 },
1882                                         new byte [] {
1883                                                 0xed, 0xad, 0xbf, 0xed, 0xb0, 0x80 }),
1884                                 /* #72 */
1885                                 new DecoderFallbackExceptionTest (
1886                                         "Paired UTF-16 surrogate U+DB7F U+DFFF",
1887                                         new int [] { 0, 2, 3, 5 },
1888                                         new int [] { 2, 1, 2, 1 },
1889                                         new byte [] {
1890                                                 0xed, 0xad, 0xbf, 0xed, 0xbf, 0xbf }),
1891                                 /* #73 */
1892                                 new DecoderFallbackExceptionTest (
1893                                         "Paired UTF-16 surrogate U+DB80 U+DC00",
1894                                         new int [] { 0, 2, 3, 5 },
1895                                         new int [] { 2, 1, 2, 1 },
1896                                         new byte [] {
1897                                                 0xed, 0xae, 0x80, 0xed, 0xb0, 0x80 }),
1898                                 /* #74 */
1899                                 new DecoderFallbackExceptionTest (
1900                                         "Paired UTF-16 surrogate U+DB80 U+DFFF",
1901                                         new int [] { 0, 2, 3, 5 },
1902                                         new int [] { 2, 1, 2, 1 },
1903                                         new byte [] {
1904                                                 0xed, 0xae, 0x80, 0xed, 0xbf, 0xbf }),
1905                                 /* #75 */
1906                                 new DecoderFallbackExceptionTest (
1907                                         "Paired UTF-16 surrogate U+DBFF U+DC00",
1908                                         new int [] { 0, 2, 3, 5 },
1909                                         new int [] { 2, 1, 2, 1 },
1910                                         new byte [] {
1911                                                 0xed, 0xaf, 0xbf, 0xed, 0xb0, 0x80 }),
1912                                 /* #76 */
1913                                 new DecoderFallbackExceptionTest (
1914                                         "Paired UTF-16 surrogate U+DBFF U+DFFF",
1915                                         new int [] { 0, 2, 3, 5 },
1916                                         new int [] { 2, 1, 2, 1 },
1917                                         new byte [] {
1918                                                 0xed, 0xaf, 0xbf, 0xed, 0xbf, 0xbf }),
1919                                 /* #77 */
1920                                 new DecoderFallbackExceptionTest (
1921                                         "Illegal code position U+FFFE",
1922                                         new int [] { },
1923                                         new int [] { },
1924                                         new byte [] { 0xef, 0xbf, 0xbe }),
1925                                 /* #78 */
1926                                 new DecoderFallbackExceptionTest (
1927                                         "Illegal code position U+FFFF",
1928                                         new int [] { },
1929                                         new int [] { },
1930                                         new byte [] { 0xef, 0xbf, 0xbf }),
1931                         };
1932                         Encoding utf8 = Encoding.GetEncoding (
1933                                                 "utf-8",
1934                                                 new EncoderExceptionFallback(),
1935                                                 new DecoderExceptionFallback());
1936                         Decoder dec = utf8.GetDecoder ();
1937                         char [] chars;
1938
1939                         for(int t = 0; t < tests.Length; t++) {
1940                                 chars = new char [utf8.GetMaxCharCount (tests[t].bytes.Length)];
1941
1942                                 // #1 complete conversion
1943                                 DecoderFallbackExceptions_GetChars (chars, t+1, dec, tests[t]);
1944
1945                                 // #2 convert with several block_sizes
1946                                 for (int bs = 1; bs <= tests[t].bytes.Length; bs++)
1947                                         DecoderFallbackExceptions_Convert (chars, t+1, dec, tests[t], bs);
1948                         }
1949                 }
1950
1951                 // EncoderFallbackExceptionTest
1952                 //   This struct describes a EncoderFallbackExceptions' test.
1953                 //   It contains an array (index_fail) which is void if it is a
1954                 //   valid UTF16 string.
1955                 //   If it is an invalid string this array contains indexes
1956                 //   (in 'index_fail') which point to the invalid chars in
1957                 //   'str'.
1958                 //   This array is hardcoded in each tests and it contains the
1959                 //   absolute positions found in a sequence of
1960                 //   EncoderFallbackException exceptions thrown if you convert
1961                 //   this strings on a MS.NET platform.
1962                 struct EncoderFallbackExceptionTest
1963                 {
1964                         public string str;
1965                         public int [] eindex;
1966                         public EncoderFallbackExceptionTest (
1967                                         string str,
1968                                         int [] eindex)
1969                         {
1970                                 this.str = str;
1971                                 this.eindex = eindex;
1972                         }
1973                 }
1974
1975                 // try to encode some bytes at once with GetBytes
1976                 private void EncoderFallbackExceptions_GetBytes (
1977                         byte [] bytes,
1978                         int testno,
1979                         Encoder enc,
1980                         EncoderFallbackExceptionTest t)
1981                 {
1982                         try {
1983                                 enc.GetBytes (
1984                                         t.str.ToCharArray (), 0, t.str.Length,
1985                                         bytes, 0, true);
1986                                 Assert.IsTrue (
1987                                         t.eindex.Length == 0,
1988                                         String.Format (
1989                                                 "test#{0}-1: UNEXPECTED SUCCESS",
1990                                                 testno));
1991                         } catch(EncoderFallbackException ex) {
1992                                 Assert.IsTrue (
1993                                         t.eindex.Length > 0,
1994                                         String.Format (
1995                                                 "test#{0}-1: UNEXPECTED FAIL",
1996                                                 testno));
1997                                 Assert.IsTrue (
1998                                         ex.Index == t.eindex[0],
1999                                         String.Format (
2000                                                 "test#{0}-1: Expected exception at {1} not {2}.",
2001                                                 testno, t.eindex[0], ex.Index));
2002                                 Assert.IsTrue (
2003                                         !ex.IsUnknownSurrogate (),
2004                                         String.Format (
2005                                                 "test#{0}-1: Expected false not {1} in IsUnknownSurrogate().",
2006                                                 testno,
2007                                                 ex.IsUnknownSurrogate ()));
2008                                 // NOTE: I know that in the previous check we
2009                                 // have asserted that ex.IsUnknownSurrogate()
2010                                 // is always false, but this does not mean that
2011                                 // we don't have to take in consideration its
2012                                 // real value for the next check.
2013                                 if (ex.IsUnknownSurrogate ())
2014                                         Assert.IsTrue (
2015                                                 ex.CharUnknownHigh == t.str[ex.Index]
2016                                                 && ex.CharUnknownLow == t.str[ex.Index + 1],
2017                                                 String.Format (
2018                                                         "test#{0}-1: expected ({1:X}, {2:X}) not ({3:X}, {4:X}).",
2019                                                         testno,
2020                                                         t.str[ex.Index],
2021                                                         t.str[ex.Index + 1],
2022                                                         ex.CharUnknownHigh,
2023                                                         ex.CharUnknownLow));
2024                                 else
2025                                         Assert.IsTrue (
2026                                                 ex.CharUnknown == t.str[ex.Index],
2027                                                 String.Format (
2028                                                         "test#{0}-1: expected ({1:X}) not ({2:X}).",
2029                                                         testno,
2030                                                         t.str[ex.Index],
2031                                                         ex.CharUnknown));
2032                                 enc.Reset ();
2033                         }
2034                 }
2035
2036                 private void EncoderFallbackExceptions_Convert (
2037                         byte [] bytes,
2038                         int testno,
2039                         Encoder enc,
2040                         EncoderFallbackExceptionTest t,
2041                         int block_size)
2042                 {
2043                         int charsUsed, bytesUsed;
2044                         bool completed;
2045
2046                         int ce = 0; // current exception
2047
2048                         for (int c = 0; c < t.str.Length; ) {
2049                                 //Console.WriteLine ("test#{0}-2-{1}: c={2}", testno, block_size, c);
2050                                 try {
2051                                         int bu = c + block_size > t.str.Length
2052                                                         ? t.str.Length - c
2053                                                         : block_size;
2054                                         enc.Convert (
2055                                                 t.str.ToCharArray (), c, bu,
2056                                                 bytes, 0, bytes.Length,
2057                                                 c + bu >= t.str.Length,
2058                                                 out charsUsed, out bytesUsed,
2059                                                 out completed);
2060                                         c += charsUsed;
2061                                 } catch (EncoderFallbackException ex) {
2062                                         //Console.WriteLine (
2063                                         //      "test#{0}-2-{1}#{2}: Exception (Index={3}, UnknownSurrogate={4})",
2064                                         //      testno, block_size, ce,
2065                                         //      ex.Index, ex.IsUnknownSurrogate ());
2066                                         Assert.IsTrue (
2067                                                 ce < t.eindex.Length,
2068                                                 String.Format (
2069                                                         "test#{0}-2-{1}#{2}: UNEXPECTED EXCEPTION (Index={3}, UnknownSurrogate={4})",
2070                                                         testno, block_size, ce,
2071                                                         ex.Index,
2072                                                         ex.IsUnknownSurrogate ()));
2073                                         Assert.IsTrue (
2074                                                 ex.Index + c == t.eindex[ce],
2075                                                 String.Format (
2076                                                         "test#{0}-2-{1}#{2}: Expected exception at {3} not {4}.",
2077                                                         testno, block_size, ce,
2078                                                         t.eindex[ce],
2079                                                         ex.Index + c));
2080                                         Assert.IsTrue (
2081                                                 !ex.IsUnknownSurrogate (),
2082                                                 String.Format (
2083                                                         "test#{0}-2-{1}#{2}: Expected false not {3} in IsUnknownSurrogate().",
2084                                                         testno, block_size, ce,
2085                                                         ex.IsUnknownSurrogate ()));
2086                                         if (ex.IsUnknownSurrogate ()) {
2087                                                 Assert.IsTrue (
2088                                                         ex.CharUnknownHigh == t.str[ex.Index + c]
2089                                                         && ex.CharUnknownLow == t.str[ex.Index + c + 1],
2090                                                         String.Format (
2091                                                                 "test#{0}-2-{1}#{2}: expected ({3:X}, {4:X}) not ({5:X}, {6:X}).",
2092                                                                 testno, block_size, ce,
2093                                                                 t.str[ex.Index + c], t.str[ex.Index + c + 1],
2094                                                                 ex.CharUnknownHigh, ex.CharUnknownLow));
2095                                                 c += ex.Index + 2;
2096                                         } else {
2097                                                 Assert.IsTrue (
2098                                                         ex.CharUnknown == t.str[ex.Index + c],
2099                                                         String.Format (
2100                                                                 "test#{0}-2-{1}#{2}: expected ({3:X}) not ({4:X}).",
2101                                                                 testno, block_size, ce,
2102                                                                 t.str[ex.Index + c],
2103                                                                 ex.CharUnknown));
2104                                                 c += ex.Index + 1;
2105                                         }
2106                                         enc.Reset ();
2107                                         ce++;
2108                                 }
2109                         }
2110                         Assert.IsTrue (
2111                                 ce == t.eindex.Length,
2112                                 String.Format (
2113                                         "test#{0}-2-{1}: UNEXPECTED SUCCESS (expected {2} exceptions, but happened {3})",
2114                                         testno, block_size, t.eindex.Length, ce));
2115                 }
2116
2117                 [Test]
2118                 public void EncoderFallbackExceptions ()
2119                 {
2120
2121                         EncoderFallbackExceptionTest [] tests = new EncoderFallbackExceptionTest []
2122                         {
2123                                 /* #1  */ new EncoderFallbackExceptionTest ( "Zero \u0000.",                                   new int [] { }),
2124                                 /* #2  */ new EncoderFallbackExceptionTest ( "Last before leads \uD7FF.",                      new int [] { }),
2125                                 /* #3  */ new EncoderFallbackExceptionTest ( "Using lead \uD800 without a surrogate.",         new int [] { 11 }),
2126                                 /* #4  */ new EncoderFallbackExceptionTest ( "Using lead \uD877 without a surrogate.",         new int [] { 11 }),
2127                                 /* #5  */ new EncoderFallbackExceptionTest ( "Using lead \uDBFF without a surrogate.",         new int [] { 11 }),
2128                                 /* #6  */ new EncoderFallbackExceptionTest ( "Using trail \uDC00 without a lead.",             new int [] { 12 }),
2129                                 /* #7  */ new EncoderFallbackExceptionTest ( "Using trail \uDBFF without a lead.",             new int [] { 12 }),
2130                                 /* #8  */ new EncoderFallbackExceptionTest ( "First-plane 2nd block \uE000.",                  new int [] { }),
2131                                 /* #9  */ new EncoderFallbackExceptionTest ( "First-plane 2nd block \uFFFF.",                  new int [] { }),
2132                                 /* #10 */ new EncoderFallbackExceptionTest ( "Playing with first surrogate \uD800\uDC00.",     new int [] { }),
2133                                 /* #11 */ new EncoderFallbackExceptionTest ( "Playing before first surrogate \uD800\uDBFF.",   new int [] { 31, 32 }),
2134                                 /* #12 */ new EncoderFallbackExceptionTest ( "Playing with last of first plane \uD800\uDFFF.", new int [] { }),
2135                                 /* #13 */ new EncoderFallbackExceptionTest ( "Playing with first of last plane \uDBFF\uDC00.", new int [] { }),
2136                                 /* #14 */ new EncoderFallbackExceptionTest ( "Playing with last surrogate \uDBFF\uDFFF.",      new int [] { }),
2137                                 /* #15 */ new EncoderFallbackExceptionTest ( "Playing after last surrogate \uDBFF\uE000.",     new int [] { 29 }),
2138                                 /* #16 */ new EncoderFallbackExceptionTest ( "Incomplete string \uD800",                       new int [] { 18 }),
2139                                 /* #17 */ new EncoderFallbackExceptionTest ( "Horrible thing \uD800\uD800.",                   new int [] { 15, 16 }),
2140                         };
2141                         Encoding utf8 = Encoding.GetEncoding (
2142                                                 "utf-8",
2143                                                 new EncoderExceptionFallback(),
2144                                                 new DecoderExceptionFallback());
2145                         Encoder enc = utf8.GetEncoder ();
2146                         byte [] bytes;
2147
2148                         for(int t = 0; t < tests.Length; t++) {
2149                                 bytes = new byte [utf8.GetMaxByteCount (tests[t].str.Length)];
2150
2151                                 // #1 complete conversion
2152                                 EncoderFallbackExceptions_GetBytes (bytes, t+1, enc, tests[t]);
2153
2154                                 // #2 convert in two rounds
2155                                 for (int bs = 1; bs <= tests[t].str.Length; bs++)
2156                                         EncoderFallbackExceptions_Convert (bytes, t+1, enc, tests[t], bs);
2157                         }
2158                 }
2159         }
2160 }