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 }