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                                         ce++;
1344                                         dec.Reset ();
1345                                         continue;
1346                                 }
1347                         }
1348                         Assert.IsTrue (
1349                                 t.eindex.Length <= ce,
1350                                 String.Format (
1351                                         "test#{0}-2-{1}: UNEXPECTED SUCCESS",
1352                                         testno, block_size));
1353                 }
1354
1355                 [Test]
1356                 public void DecoderFallbackExceptions ()
1357                 {
1358
1359                         DecoderFallbackExceptionTest [] tests = new DecoderFallbackExceptionTest []
1360                         {
1361                                 /* #1  */
1362                                 new DecoderFallbackExceptionTest (
1363                                         "Greek word 'kosme'",
1364                                         new int [] { },
1365                                         new int [] { },
1366                                         new byte [] {
1367                                                 0xce, 0xba, 0xe1, 0xbd, 0xb9, 0xcf,
1368                                                 0x83, 0xce, 0xbc, 0xce, 0xb5 }),
1369                                 /* #2  */
1370                                 new DecoderFallbackExceptionTest (
1371                                         "First possible sequence of 1 byte",
1372                                         new int [] { },
1373                                         new int [] { },
1374                                         new byte [] { 0x00 }),
1375                                 /* #3  */
1376                                 new DecoderFallbackExceptionTest (
1377                                         "First possible sequence of 2 bytes",
1378                                         new int [] { },
1379                                         new int [] { },
1380                                         new byte [] { 0xc2, 0x80 }),
1381                                 /* #4  */
1382                                 new DecoderFallbackExceptionTest (
1383                                         "First possible sequence of 3 bytes",
1384                                         new int [] { },
1385                                         new int [] { },
1386                                         new byte [] { 0xe0, 0xa0, 0x80 }),
1387                                 /* #5  */
1388                                 new DecoderFallbackExceptionTest (
1389                                         "First possible sequence of 4 bytes",
1390                                         new int [] { },
1391                                         new int [] { },
1392                                         new byte [] { 0xf0, 0x90, 0x80, 0x80 }),
1393                                 /* #6  */
1394                                 new DecoderFallbackExceptionTest (
1395                                         "First possible sequence of 5 bytes",
1396                                         new int [] { 0, 1, 2, 3, 4 },
1397                                         new int [] { 1, 1, 1, 1, 1 },
1398                                         new byte [] { 0xf8, 0x88, 0x80, 0x80, 0x80 }),
1399                                 /* #7  */
1400                                 new DecoderFallbackExceptionTest (
1401                                         "First possible sequence of 6 bytes",
1402                                         new int [] { 0, 1, 2, 3, 4, 5 },
1403                                         new int [] { 1, 1, 1, 1, 1, 1 },
1404                                         new byte [] {
1405                                                 0xfc, 0x84, 0x80, 0x80, 0x80, 0x80 }),
1406                                 /* #8  */
1407                                 new DecoderFallbackExceptionTest (
1408                                         "Last possible sequence of 1 byte",
1409                                         new int [] { },
1410                                         new int [] { },
1411                                         new byte [] { 0x7f }),
1412                                 /* #9  */
1413                                 new DecoderFallbackExceptionTest (
1414                                         "Last possible sequence of 2 bytes",
1415                                         new int [] { },
1416                                         new int [] { },
1417                                         new byte [] { 0xdf, 0xbf }),
1418                                 /* #10 */
1419                                 new DecoderFallbackExceptionTest (
1420                                         "Last possible sequence of 3 bytes",
1421                                         new int [] { },
1422                                         new int [] { },
1423                                         new byte [] { 0xef, 0xbf, 0xbf }),
1424                                 /* #11 */
1425                                 new DecoderFallbackExceptionTest (
1426                                         "Last possible sequence of 4 bytes",
1427                                         new int [] { 0, 1, 2, 3 },
1428                                         new int [] { 1, 1, 1, 1 },
1429                                         new byte [] { 0xf7, 0xbf, 0xbf, 0xbf }),
1430                                 /* #12 */
1431                                 new DecoderFallbackExceptionTest (
1432                                         "Last possible sequence of 5 bytes",
1433                                         new int [] { 0, 1, 2, 3, 4 },
1434                                         new int [] { 1, 1, 1, 1, 1 },
1435                                         new byte [] { 0xfb, 0xbf, 0xbf, 0xbf, 0xbf }),
1436                                 /* #13 */
1437                                 new DecoderFallbackExceptionTest (
1438                                         "Last possible sequence of 6 bytes",
1439                                         new int [] { 0, 1, 2, 3, 4, 5 },
1440                                         new int [] { 1, 1, 1, 1, 1, 1 },
1441                                         new byte [] { 0xfd, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf }),
1442                                 /* #14 */
1443                                 new DecoderFallbackExceptionTest (
1444                                         "U-0000D7FF = ed 9f bf",
1445                                         new int [] { },
1446                                         new int [] { },
1447                                         new byte [] { 0xed, 0x9f, 0xbf }),
1448                                 /* #15 */
1449                                 new DecoderFallbackExceptionTest (
1450                                         "U-0000E000 = ee 80 80",
1451                                         new int [] { },
1452                                         new int [] { },
1453                                         new byte [] { 0xee, 0x80, 0x80 }),
1454                                 /* #16 */
1455                                 new DecoderFallbackExceptionTest (
1456                                         "U-0000FFFD = ef bf bd",
1457                                         new int [] { },
1458                                         new int [] { },
1459                                         new byte [] { 0xef, 0xbf, 0xbd }),
1460                                 /* #17 */
1461                                 new DecoderFallbackExceptionTest (
1462                                         "U-0010FFFF = f4 8f bf bf",
1463                                         new int [] { },
1464                                         new int [] { },
1465                                         new byte [] { 0xf4, 0x8f, 0xbf, 0xbf }),
1466                                 /* #18 */
1467                                 new DecoderFallbackExceptionTest (
1468                                         "U-00110000 = f4 90 80 80",
1469                                         new int [] { 0, 2, 3 },
1470                                         new int [] { 2, 1, 1 },
1471                                         new byte [] { 0xf4, 0x90, 0x80, 0x80 }),
1472                                 /* #19 */
1473                                 new DecoderFallbackExceptionTest (
1474                                         "First continuation byte 0x80",
1475                                         new int [] { 0 },
1476                                         new int [] { 1 },
1477                                         new byte [] { 0x80 }),
1478                                 /* #20 */
1479                                 new DecoderFallbackExceptionTest (
1480                                         "Last  continuation byte 0xbf",
1481                                         new int [] { 0 },
1482                                         new int [] { 1 },
1483                                         new byte [] { 0xbf }),
1484                                 /* #21 */
1485                                 new DecoderFallbackExceptionTest (
1486                                         "2 continuation bytes",
1487                                         new int [] { 0, 1 },
1488                                         new int [] { 1, 1 },
1489                                         new byte [] { 0x80, 0xbf }),
1490                                 /* #22 */
1491                                 new DecoderFallbackExceptionTest (
1492                                         "3 continuation bytes",
1493                                         new int [] { 0, 1, 2 },
1494                                         new int [] { 1, 1, 1 },
1495                                         new byte [] { 0x80, 0xbf, 0x80 }),
1496                                 /* #23 */
1497                                 new DecoderFallbackExceptionTest (
1498                                         "4 continuation bytes",
1499                                         new int [] { 0, 1, 2, 3 },
1500                                         new int [] { 1, 1, 1, 1 },
1501                                         new byte [] { 0x80, 0xbf, 0x80, 0xbf }),
1502                                 /* #24 */
1503                                 new DecoderFallbackExceptionTest (
1504                                         "5 continuation bytes",
1505                                         new int [] { 0, 1, 2, 3, 4 },
1506                                         new int [] { 1, 1, 1, 1, 1 },
1507                                         new byte [] { 0x80, 0xbf, 0x80, 0xbf, 0x80 }),
1508                                 /* #25 */
1509                                 new DecoderFallbackExceptionTest (
1510                                         "6 continuation bytes",
1511                                         new int [] { 0, 1, 2, 3, 4, 5 },
1512                                         new int [] { 1, 1, 1, 1, 1, 1 },
1513                                         new byte [] {
1514                                                 0x80, 0xbf, 0x80, 0xbf, 0x80, 0xbf }),
1515                                 /* #26 */
1516                                 new DecoderFallbackExceptionTest (
1517                                         "7 continuation bytes",
1518                                         new int [] { 0, 1, 2, 3, 4, 5, 6 },
1519                                         new int [] { 1, 1, 1, 1, 1, 1, 1 },
1520                                         new byte [] {
1521                                                 0x80, 0xbf, 0x80, 0xbf, 0x80, 0xbf,
1522                                                 0x80 }),
1523                                 /* #27 */
1524                                 new DecoderFallbackExceptionTest (
1525                                         "Sequence of all 64 continuation bytes",
1526                                         new int [] {
1527                                                  0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
1528                                                 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
1529                                                 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
1530                                                 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
1531                                                 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
1532                                                 50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
1533                                                 60, 61, 62, 63 },
1534                                         new int [] {
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, 1, 1, 1, 1, 1, 1,
1541                                                 1, 1, 1, 1 },
1542                                         new byte [] {
1543                                                 0x80, 0x81, 0x82, 0x83, 0x84, 0x85,
1544                                                 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b,
1545                                                 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91,
1546                                                 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
1547                                                 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d,
1548                                                 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3,
1549                                                 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9,
1550                                                 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
1551                                                 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5,
1552                                                 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb,
1553                                                 0xbc, 0xbd, 0xbe, 0xbf }),
1554                                 /* #28 */
1555                                 new DecoderFallbackExceptionTest (
1556                                         "All 32 first bytes of 2-byte sequences (0xc0-0xdf), each followed by a space character",
1557                                         new int [] {
1558                                                  0,  2,  4,  6,  8,
1559                                                 10, 12, 14, 16, 18,
1560                                                 20, 22, 24, 26, 28,
1561                                                 30, 32, 34, 36, 38,
1562                                                 40, 42, 44, 46, 48,
1563                                                 50, 52, 54, 56, 58,
1564                                                 60, 62 },
1565                                         new int [] {
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, 1, 1, 1,
1572                                                 1, 1 },
1573                                         new byte [] {
1574                                                 0xc0, 0x20, 0xc1, 0x20, 0xc2, 0x20,
1575                                                 0xc3, 0x20, 0xc4, 0x20, 0xc5, 0x20,
1576                                                 0xc6, 0x20, 0xc7, 0x20, 0xc8, 0x20,
1577                                                 0xc9, 0x20, 0xca, 0x20, 0xcb, 0x20,
1578                                                 0xcc, 0x20, 0xcd, 0x20, 0xce, 0x20,
1579                                                 0xcf, 0x20, 0xd0, 0x20, 0xd1, 0x20,
1580                                                 0xd2, 0x20, 0xd3, 0x20, 0xd4, 0x20,
1581                                                 0xd5, 0x20, 0xd6, 0x20, 0xd7, 0x20,
1582                                                 0xd8, 0x20, 0xd9, 0x20, 0xda, 0x20,
1583                                                 0xdb, 0x20, 0xdc, 0x20, 0xdd, 0x20,
1584                                                 0xde, 0x20, 0xdf, 0x20 }),
1585                                 /* #29 */
1586                                 new DecoderFallbackExceptionTest (
1587                                         "All 16 first bytes of 3-byte sequences (0xe0-0xef), each followed by a space character",
1588                                         new int [] {
1589                                                  0,  2,  4,  6,  8,
1590                                                 10, 12, 14, 16, 18,
1591                                                 20, 22, 24, 26, 28,
1592                                                 30 },
1593                                         new int [] {
1594                                                 1, 1, 1, 1, 1,
1595                                                 1, 1, 1, 1, 1,
1596                                                 1, 1, 1, 1, 1,
1597                                                 1 },
1598                                         new byte [] {
1599                                                 0xe0, 0x20, 0xe1, 0x20, 0xe2, 0x20,
1600                                                 0xe3, 0x20, 0xe4, 0x20, 0xe5, 0x20,
1601                                                 0xe6, 0x20, 0xe7, 0x20, 0xe8, 0x20,
1602                                                 0xe9, 0x20, 0xea, 0x20, 0xeb, 0x20,
1603                                                 0xec, 0x20, 0xed, 0x20, 0xee, 0x20,
1604                                                 0xef, 0x20 }),
1605                                 /* #30 */
1606                                 new DecoderFallbackExceptionTest (
1607                                         "All 8 first bytes of 4-byte sequences (0xf0-0xf7), each followed by a space character",
1608                                         new int [] { 0,  2,  4,  6,  8, 10, 12, 14 },
1609                                         new int [] { 1, 1, 1, 1, 1, 1, 1, 1 },
1610                                         new byte [] {
1611                                                 0xf0, 0x20, 0xf1, 0x20, 0xf2, 0x20,
1612                                                 0xf3, 0x20, 0xf4, 0x20, 0xf5, 0x20,
1613                                                 0xf6, 0x20, 0xf7, 0x20 }),
1614                                 /* #31 */
1615                                 new DecoderFallbackExceptionTest (
1616                                         "All 4 first bytes of 5-byte sequences (0xf8-0xfb), each followed by a space character",
1617                                         new int [] { 0, 2, 4, 6 },
1618                                         new int [] { 1, 1, 1, 1 },
1619                                         new byte [] {
1620                                                 0xf8, 0x20, 0xf9, 0x20, 0xfa, 0x20,
1621                                                 0xfb, 0x20 }),
1622                                 /* #32 */
1623                                 new DecoderFallbackExceptionTest (
1624                                         "All 2 first bytes of 6-byte sequences (0xfc-0xfd), each followed by a space character",
1625                                         new int [] { 0, 2 },
1626                                         new int [] { 1, 1 },
1627                                         new byte [] { 0xfc, 0x20, 0xfd, 0x20 }),
1628                                 /* #33 */
1629                                 new DecoderFallbackExceptionTest (
1630                                         "2-byte sequence with last byte missing",
1631                                         new int [] { 0 },
1632                                         new int [] { 1 },
1633                                         new byte [] { 0xc0 }),
1634                                 /* #34 */
1635                                 new DecoderFallbackExceptionTest (
1636                                         "3-byte sequence with last byte missing",
1637                                         new int [] { 0 },
1638                                         new int [] { 2 },
1639                                         new byte [] { 0xe0, 0x80 }),
1640                                 /* #35 */
1641                                 new DecoderFallbackExceptionTest (
1642                                         "4-byte sequence with last byte missing",
1643                                         new int [] { 0, 2 },
1644                                         new int [] { 2, 1 },
1645                                         new byte [] { 0xf0, 0x80, 0x80 }),
1646                                 /* #36 */
1647                                 new DecoderFallbackExceptionTest (
1648                                         "5-byte sequence with last byte missing",
1649                                         new int [] { 0, 1, 2, 3 },
1650                                         new int [] { 1, 1, 1, 1 },
1651                                         new byte [] { 0xf8, 0x80, 0x80, 0x80 }),
1652                                 /* #37 */
1653                                 new DecoderFallbackExceptionTest (
1654                                         "6-byte sequence with last byte missing",
1655                                         new int [] { 0, 1, 2, 3, 4 },
1656                                         new int [] { 1, 1, 1, 1, 1 },
1657                                         new byte [] { 0xfc, 0x80, 0x80, 0x80, 0x80 }),
1658                                 /* #38 */
1659                                 new DecoderFallbackExceptionTest (
1660                                         "2-byte sequence with last byte missing",
1661                                         new int [] { 0 },
1662                                         new int [] { 1 },
1663                                         new byte [] { 0xdf }),
1664                                 /* #39 */
1665                                 new DecoderFallbackExceptionTest (
1666                                         "3-byte sequence with last byte missing",
1667                                         new int [] { 0 },
1668                                         new int [] { 2 },
1669                                         new byte [] { 0xef, 0xbf }),
1670                                 /* #40 */
1671                                 new DecoderFallbackExceptionTest (
1672                                         "4-byte sequence with last byte missing",
1673                                         new int [] { 0, 1, 2 },
1674                                         new int [] { 1, 1, 1 },
1675                                         new byte [] { 0xf7, 0xbf, 0xbf }),
1676                                 /* #41 */
1677                                 new DecoderFallbackExceptionTest (
1678                                         "5-byte sequence with last byte missing",
1679                                         new int [] { 0, 1, 2, 3 },
1680                                         new int [] { 1, 1, 1, 1 },
1681                                         new byte [] { 0xfb, 0xbf, 0xbf, 0xbf }),
1682                                 /* #42 */
1683                                 new DecoderFallbackExceptionTest (
1684                                         "6-byte sequence with last byte missing",
1685                                         new int [] { 0, 1, 2, 3, 4 },
1686                                         new int [] { 1, 1, 1, 1, 1 },
1687                                         new byte [] { 0xfd, 0xbf, 0xbf, 0xbf, 0xbf }),
1688                                 /* #43 */
1689                                 new DecoderFallbackExceptionTest (
1690                                         "All the 10 sequences of 3.3 concatenated",
1691                                         new int [] {
1692                                                  0,  1,      3,
1693                                                  5,  6,  7,  8,  9,
1694                                                 10, 11, 12, 13, 14,
1695                                                 15, 16,     18, 19,
1696                                                 20, 21, 22, 23, 24,
1697                                                 25, 26, 27, 28, 29 },
1698                                         new int [] {
1699                                                  1,  2,      2,
1700                                                  1,  1,  1,  1,  1,
1701                                                  1,  1,  1,  1,  1,
1702                                                  1,  2,      1,  1,
1703                                                  1,  1,  1,  1,  1,
1704                                                  1,  1,  1,  1,  1 },
1705                                         new byte [] {
1706                                                 0xc0, 0xe0, 0x80, 0xf0, 0x80, 0x80,
1707                                                 0xf8, 0x80, 0x80, 0x80, 0xfc, 0x80,
1708                                                 0x80, 0x80, 0x80, 0xdf, 0xef, 0xbf,
1709                                                 0xf7, 0xbf, 0xbf, 0xfb, 0xbf, 0xbf,
1710                                                 0xbf, 0xfd, 0xbf, 0xbf, 0xbf, 0xbf }),
1711                                 /* #44 */
1712                                 new DecoderFallbackExceptionTest (
1713                                         "Bad chars fe",
1714                                         new int [] { 0 },
1715                                         new int [] { 1 },
1716                                         new byte [] { 0xfe }),
1717                                 /* #45 */
1718                                 new DecoderFallbackExceptionTest (
1719                                         "Bad chars ff",
1720                                         new int [] { 0 },
1721                                         new int [] { 1 },
1722                                         new byte [] { 0xff }),
1723                                 /* #46 */
1724                                 new DecoderFallbackExceptionTest (
1725                                         "Bad chars fe fe ff ff",
1726                                         new int [] { 0, 1, 2, 3 },
1727                                         new int [] { 1, 1, 1, 1 },
1728                                         new byte [] { 0xfe, 0xfe, 0xff, 0xff }),
1729                                 /* #47 */
1730                                 new DecoderFallbackExceptionTest (
1731                                         "Overlong U+002F = c0 af",
1732                                         new int [] { 0, 1 },
1733                                         new int [] { 1, 1 },
1734                                         new byte [] { 0xc0, 0xaf }),
1735                                 /* #48 */
1736                                 new DecoderFallbackExceptionTest (
1737                                         "Overlong U+002F = e0 80 af",
1738                                         new int [] { 0, 2 },
1739                                         new int [] { 2, 1 },
1740                                         new byte [] { 0xe0, 0x80, 0xaf }),
1741                                 /* #49 */
1742                                 new DecoderFallbackExceptionTest (
1743                                         "Overlong U+002F = f0 80 80 af",
1744                                         new int [] { 0, 2, 3 },
1745                                         new int [] { 2, 1, 1 },
1746                                         new byte [] { 0xf0, 0x80, 0x80, 0xaf }),
1747                                 /* #50 */
1748                                 new DecoderFallbackExceptionTest (
1749                                         "Overlong U+002F = f8 80 80 80 af",
1750                                         new int [] { 0, 1, 2, 3, 4 },
1751                                         new int [] { 1, 1, 1, 1, 1 },
1752                                         new byte [] { 0xf8, 0x80, 0x80, 0x80, 0xaf }),
1753                                 /* #51 */
1754                                 new DecoderFallbackExceptionTest (
1755                                         "Overlong U+002F = fc 80 80 80 80 af",
1756                                         new int [] { 0, 1, 2, 3, 4, 5 },
1757                                         new int [] { 1, 1, 1, 1, 1, 1 },
1758                                         new byte [] {
1759                                                 0xfc, 0x80, 0x80, 0x80, 0x80, 0xaf }),
1760                                 /* #52 */
1761                                 new DecoderFallbackExceptionTest (
1762                                         "Maximum overlong U-0000007F",
1763                                         new int [] { 0, 1 },
1764                                         new int [] { 1, 1 },
1765                                         new byte [] { 0xc1, 0xbf }),
1766                                 /* #53 */
1767                                 new DecoderFallbackExceptionTest (
1768                                         "Maximum overlong U-000007FF",
1769                                         new int [] { 0, 2 },
1770                                         new int [] { 2, 1, },
1771                                         new byte [] { 0xe0, 0x9f, 0xbf }),
1772                                 /* #54 */
1773                                 new DecoderFallbackExceptionTest (
1774                                         "Maximum overlong U-0000FFFF",
1775                                         new int [] { 0, 2, 3 },
1776                                         new int [] { 2, 1, 1 },
1777                                         new byte [] { 0xf0, 0x8f, 0xbf, 0xbf }),
1778                                 /* #55 */
1779                                 new DecoderFallbackExceptionTest (
1780                                         "Maximum overlong U-001FFFFF",
1781                                         new int [] { 0, 1, 2, 3, 4 },
1782                                         new int [] { 1, 1, 1, 1, 1 },
1783                                         new byte [] { 0xf8, 0x87, 0xbf, 0xbf, 0xbf }),
1784                                 /* #56 */
1785                                 new DecoderFallbackExceptionTest (
1786                                         "Maximum overlong U-03FFFFFF",
1787                                         new int [] { 0, 1, 2, 3, 4, 5 },
1788                                         new int [] { 1, 1, 1, 1, 1, 1 },
1789                                         new byte [] {
1790                                                 0xfc, 0x83, 0xbf, 0xbf, 0xbf, 0xbf }),
1791                                 /* #57 */
1792                                 new DecoderFallbackExceptionTest (
1793                                         "Null overlong c0 80",
1794                                         new int [] { 0, 1 },
1795                                         new int [] { 1, 1 },
1796                                         new byte [] { 0xc0, 0x80, 0x22 }),
1797                                 /* #58 */
1798                                 new DecoderFallbackExceptionTest (
1799                                         "Null overlong e0 80 80",
1800                                         new int [] { 0, 2 },
1801                                         new int [] { 2, 1 },
1802                                         new byte [] { 0xe0, 0x80, 0x80 }),
1803                                 /* #59 */
1804                                 new DecoderFallbackExceptionTest (
1805                                         "Null overlong f0 80 80 80",
1806                                         new int [] { 0, 2, 3 },
1807                                         new int [] { 2, 1, 1 },
1808                                         new byte [] { 0xf0, 0x80, 0x80, 0x80 }),
1809                                 /* #60 */
1810                                 new DecoderFallbackExceptionTest (
1811                                         "Null overlong f8 80 80 80 80",
1812                                         new int [] { 0, 1, 2, 3, 4 },
1813                                         new int [] { 1, 1, 1, 1, 1 },
1814                                         new byte [] { 0xf8, 0x80, 0x80, 0x80, 0x80 }),
1815                                 /* #61 */
1816                                 new DecoderFallbackExceptionTest (
1817                                         "Null overlong fc 80 80 80 80 80",
1818                                         new int [] { 0, 1, 2, 3, 4, 5 },
1819                                         new int [] { 1, 1, 1, 1, 1, 1 },
1820                                         new byte [] {
1821                                                 0xfc, 0x80, 0x80, 0x80, 0x80, 0x80 }),
1822                                 /* #62 */
1823                                 new DecoderFallbackExceptionTest (
1824                                         "Single UTF-16 surrogate U+D800",
1825                                         new int [] { 0, 2 },
1826                                         new int [] { 2, 1 },
1827                                         new byte [] { 0xed, 0xa0, 0x80 }),
1828                                 /* #63 */
1829                                 new DecoderFallbackExceptionTest (
1830                                         "Single UTF-16 surrogate U+DB7F",
1831                                         new int [] { 0, 2 },
1832                                         new int [] { 2, 1 },
1833                                         new byte [] { 0xed, 0xad, 0xbf }),
1834                                 /* #64 */
1835                                 new DecoderFallbackExceptionTest (
1836                                         "Single UTF-16 surrogate U+DB80",
1837                                         new int [] { 0, 2 },
1838                                         new int [] { 2, 1 },
1839                                         new byte [] { 0xed, 0xae, 0x80 }),
1840                                 /* #65 */
1841                                 new DecoderFallbackExceptionTest (
1842                                         "Single UTF-16 surrogate U+DBFF",
1843                                         new int [] { 0, 2 },
1844                                         new int [] { 2, 1 },
1845                                         new byte [] { 0xed, 0xaf, 0xbf }),
1846                                 /* #66 */
1847                                 new DecoderFallbackExceptionTest (
1848                                         "Single UTF-16 surrogate U+DC00",
1849                                         new int [] { 0, 2 },
1850                                         new int [] { 2, 1 },
1851                                         new byte [] { 0xed, 0xb0, 0x80 }),
1852                                 /* #67 */
1853                                 new DecoderFallbackExceptionTest (
1854                                         "Single UTF-16 surrogate U+DF80",
1855                                         new int [] { 0, 2 },
1856                                         new int [] { 2, 1 },
1857                                         new byte [] { 0xed, 0xbe, 0x80 }),
1858                                 /* #68 */
1859                                 new DecoderFallbackExceptionTest (
1860                                         "Single UTF-16 surrogate U+DFFF",
1861                                         new int [] { 0, 2 },
1862                                         new int [] { 2, 1 },
1863                                         new byte [] { 0xed, 0xbf, 0xbf }),
1864                                 /* #69 */
1865                                 new DecoderFallbackExceptionTest (
1866                                         "Paired UTF-16 surrogate U+D800 U+DC00",
1867                                         new int [] { 0, 2, 3, 5 },
1868                                         new int [] { 2, 1, 2, 1 },
1869                                         new byte [] {
1870                                                 0xed, 0xa0, 0x80, 0xed, 0xb0, 0x80 }),
1871                                 /* #70 */
1872                                 new DecoderFallbackExceptionTest (
1873                                         "Paired UTF-16 surrogate U+D800 U+DFFF",
1874                                         new int [] { 0, 2, 3, 5 },
1875                                         new int [] { 2, 1, 2, 1 },
1876                                         new byte [] {
1877                                                 0xed, 0xa0, 0x80, 0xed, 0xbf, 0xbf }),
1878                                 /* #71 */
1879                                 new DecoderFallbackExceptionTest (
1880                                         "Paired UTF-16 surrogate U+DB7F U+DC00",
1881                                         new int [] { 0, 2, 3, 5 },
1882                                         new int [] { 2, 1, 2, 1 },
1883                                         new byte [] {
1884                                                 0xed, 0xad, 0xbf, 0xed, 0xb0, 0x80 }),
1885                                 /* #72 */
1886                                 new DecoderFallbackExceptionTest (
1887                                         "Paired UTF-16 surrogate U+DB7F U+DFFF",
1888                                         new int [] { 0, 2, 3, 5 },
1889                                         new int [] { 2, 1, 2, 1 },
1890                                         new byte [] {
1891                                                 0xed, 0xad, 0xbf, 0xed, 0xbf, 0xbf }),
1892                                 /* #73 */
1893                                 new DecoderFallbackExceptionTest (
1894                                         "Paired UTF-16 surrogate U+DB80 U+DC00",
1895                                         new int [] { 0, 2, 3, 5 },
1896                                         new int [] { 2, 1, 2, 1 },
1897                                         new byte [] {
1898                                                 0xed, 0xae, 0x80, 0xed, 0xb0, 0x80 }),
1899                                 /* #74 */
1900                                 new DecoderFallbackExceptionTest (
1901                                         "Paired UTF-16 surrogate U+DB80 U+DFFF",
1902                                         new int [] { 0, 2, 3, 5 },
1903                                         new int [] { 2, 1, 2, 1 },
1904                                         new byte [] {
1905                                                 0xed, 0xae, 0x80, 0xed, 0xbf, 0xbf }),
1906                                 /* #75 */
1907                                 new DecoderFallbackExceptionTest (
1908                                         "Paired UTF-16 surrogate U+DBFF U+DC00",
1909                                         new int [] { 0, 2, 3, 5 },
1910                                         new int [] { 2, 1, 2, 1 },
1911                                         new byte [] {
1912                                                 0xed, 0xaf, 0xbf, 0xed, 0xb0, 0x80 }),
1913                                 /* #76 */
1914                                 new DecoderFallbackExceptionTest (
1915                                         "Paired UTF-16 surrogate U+DBFF U+DFFF",
1916                                         new int [] { 0, 2, 3, 5 },
1917                                         new int [] { 2, 1, 2, 1 },
1918                                         new byte [] {
1919                                                 0xed, 0xaf, 0xbf, 0xed, 0xbf, 0xbf }),
1920                                 /* #77 */
1921                                 new DecoderFallbackExceptionTest (
1922                                         "Illegal code position U+FFFE",
1923                                         new int [] { },
1924                                         new int [] { },
1925                                         new byte [] { 0xef, 0xbf, 0xbe }),
1926                                 /* #78 */
1927                                 new DecoderFallbackExceptionTest (
1928                                         "Illegal code position U+FFFF",
1929                                         new int [] { },
1930                                         new int [] { },
1931                                         new byte [] { 0xef, 0xbf, 0xbf }),
1932                         };
1933                         Encoding utf8 = Encoding.GetEncoding (
1934                                                 "utf-8",
1935                                                 new EncoderExceptionFallback(),
1936                                                 new DecoderExceptionFallback());
1937                         Decoder dec = utf8.GetDecoder ();
1938                         char [] chars;
1939
1940                         for(int t = 0; t < tests.Length; t++) {
1941                                 chars = new char [utf8.GetMaxCharCount (tests[t].bytes.Length)];
1942
1943                                 // #1 complete conversion
1944                                 DecoderFallbackExceptions_GetChars (chars, t, dec, tests[t]);
1945
1946                                 // #2 convert with several block_sizes
1947                                 for (int bs = 1; bs < tests[t].bytes.Length; bs++)
1948                                         DecoderFallbackExceptions_Convert (chars, t, dec, tests[t], bs);
1949                         }
1950                 }
1951         }
1952 }