mcs/class/corlib/Test/System/CharTest.cs

   1 // CharTest.cs - NUnit Test Cases for the System.Char struct
   2 //
   3 // David Brandt (bucky@keystreams.com)
   4 //
   5 // (C) Ximian, Inc.  http://www.ximian.com
   6 // Copyright (C) 2005 Novell, Inc (http://www.novell.com)
   7 //
   8
   9 using NUnit.Framework;
  10 using System;
  11 using System.Globalization;
  12
  13 namespace MonoTests.System
  14 {
  15 [TestFixture]
  16 public class CharTest
  17 {
  18         [Test]
  19         public void TestCompareTo()
  20         {
  21                 Char c1 = 'a';
  22                 Char c2 = 'b';
  23                 Char c3 = 'b';
  24                 Assert.IsTrue(c1.CompareTo(c2) == -1, "Less than");
  25                 Assert.IsTrue(c2.CompareTo(c1) == 1, "Greater than");
  26                 Assert.IsTrue(c2.CompareTo(c3) == 0, "Equal 1");
  27                 Assert.IsTrue(c1.CompareTo(c1) == 0, "Equal 2");
  28         }
  29
  30         [Test]
  31         public void TestEquals()
  32         {
  33                 Char c1 = 'a';
  34                 Char c2 = 'b';
  35                 Char c3 = 'b';
  36                 Assert.IsTrue(c1.Equals(c1), "Same");
  37                 Assert.IsTrue(c2.Equals(c3), "Same value");
  38                 Assert.IsTrue(!c1.Equals(c2), "Not same");
  39         }
  40
  41         [Test]
  42         public void TestGetHashValue()
  43         {
  44                 Char c1 = ' ';
  45                 Assert.AreEqual(c1.GetHashCode(), c1.GetHashCode(), "deterministic hash code ");
  46                 // TODO - the spec doesn't say what algorithm is used to get hash codes.  So far, just a weak test for determinism and mostly-uniqueness.
  47         }
  48
  49         [Test]
  50         public void TestGetNumericValue()
  51         {
  52                 Char c1 = ' ';
  53                 Char c2 = '3';
  54                 Assert.AreEqual(-1.0, Char.GetNumericValue(c1), 0.1, "code 1");
  55                 Assert.AreEqual(3.0, Char.GetNumericValue(c2), 0.1, "code 2");
  56
  57                 string s1 = " 3 ";
  58                 Assert.AreEqual(-1.0, Char.GetNumericValue(s1, 0), 0.1, "space not number");
  59                 Assert.AreEqual(3.0, Char.GetNumericValue(s1, 1), 0.1, "space not number");
  60                 Assert.AreEqual(-1.0, Char.GetNumericValue(s1, 2), 0.1, "space not number");
  61         }
  62
  63         [Test]
  64         public void TestGetUnicodeCategory()
  65         {
  66                 {
  67                         char Pe1 = ']';
  68                         char Pe2 = '}';
  69                         char Pe3 = ')';
  70                         Assert.AreEqual(UnicodeCategory.ClosePunctuation,
  71                                                         Char.GetUnicodeCategory(Pe1),
  72                                                         "Close Punctuation");
  73                         Assert.AreEqual(UnicodeCategory.ClosePunctuation,
  74                                                         Char.GetUnicodeCategory(Pe2),
  75                                                         "Close Punctuation");
  76                         Assert.AreEqual(UnicodeCategory.ClosePunctuation,
  77                                                         Char.GetUnicodeCategory(Pe3),
  78                                                         "Close Punctuation");
  79                 }
  80                 // TODO - ConnectorPunctuation
  81                 {
  82                         char c1 = (char)0; // 0000-001F, 007F-009F
  83                         char c2 = (char)0x001F;
  84                         char c3 = (char)0x007F;
  85                         char c4 = (char)0x00F;
  86                         Assert.AreEqual(UnicodeCategory.Control,
  87                                                         Char.GetUnicodeCategory(c1),
  88                                                         "Control");
  89                         Assert.AreEqual(UnicodeCategory.Control,
  90                                                         Char.GetUnicodeCategory(c2),
  91                                                         "Control");
  92                         Assert.AreEqual(UnicodeCategory.Control,
  93                                                         Char.GetUnicodeCategory(c3),
  94                                                         "Control");
  95                         Assert.AreEqual(UnicodeCategory.Control,
  96                                                         Char.GetUnicodeCategory(c4),
  97                                                         "Control");
  98                 }
  99                 {
 100                         // TODO - more currencies?
 101                         char c1 = '$';
 102                         Assert.AreEqual(
 103                                      UnicodeCategory.CurrencySymbol,
 104                                      Char.GetUnicodeCategory(c1),
 105                                          "Currency");
 106                 }
 107                 {
 108                         char c1 = '-';
 109                         Assert.AreEqual(UnicodeCategory.DashPunctuation,
 110                                                         Char.GetUnicodeCategory(c1),
 111                                                         "Dash Punctuation");
 112                 }
 113                 {
 114                         char c1 = '2';
 115                         char c2 = '7';
 116                         Assert.AreEqual(UnicodeCategory.DecimalDigitNumber,
 117                                                         Char.GetUnicodeCategory(c1),
 118                                                         "Decimal Digit");
 119                         Assert.AreEqual(UnicodeCategory.DecimalDigitNumber,
 120                                                         Char.GetUnicodeCategory(c2),
 121                                                         "Decimal Digit");
 122                 }
 123                 // TODO - EnclosingMark
 124                 // TODO - FinalQuotePunctuation
 125                 // TODO - Format
 126                 // TODO - InitialQuotePunctuation
 127                 // TODO - LetterNumber
 128                 // TODO - LineSeparator (not '\n', that's a control char)
 129                 {
 130                         char c1 = 'a';
 131                         char c2 = 'z';
 132                         Assert.AreEqual(UnicodeCategory.LowercaseLetter,
 133                                                         Char.GetUnicodeCategory(c1),
 134                                                         "LowercaseLetter");
 135                         Assert.AreEqual(UnicodeCategory.LowercaseLetter,
 136                                                         Char.GetUnicodeCategory(c2),
 137                                                         "LowercaseLetter");
 138                 }
 139                 {
 140                         char c1 = '+';
 141                         char c2 = '=';
 142                         Assert.AreEqual(UnicodeCategory.MathSymbol,
 143                                                         Char.GetUnicodeCategory(c1),
 144                                                         "MathSymbol");
 145                         Assert.AreEqual(UnicodeCategory.MathSymbol,
 146                                                         Char.GetUnicodeCategory(c2),
 147                                                         "MathSymbol");
 148                 }
 149                 // TODO - ModifierSymbol
 150                 // TODO - NonSpacingMark
 151                 // TODO - OpenPunctuation
 152                 {
 153                         char c1 = '[';
 154                         char c2 = '{';
 155                         char c3 = '(';
 156                         Assert.AreEqual(UnicodeCategory.OpenPunctuation,
 157                                                         Char.GetUnicodeCategory(c1),
 158                                                         "OpenPunctuation");
 159                         Assert.AreEqual(UnicodeCategory.OpenPunctuation,
 160                                                         Char.GetUnicodeCategory(c2),
 161                                                         "OpenPunctuation");
 162                         Assert.AreEqual(UnicodeCategory.OpenPunctuation,
 163                                                         Char.GetUnicodeCategory(c3),
 164                                                         "OpenPunctuation");
 165                 }
 166                 // TODO - OtherLetter
 167                 // TODO - OtherNotAssigned
 168                 // TODO - OtherNumber
 169                 {
 170                         char c1 = '/';
 171                         Assert.AreEqual(UnicodeCategory.OtherPunctuation,
 172                                                         Char.GetUnicodeCategory(c1),
 173                                                         "OtherPunctuation");
 174                 }
 175                 // TODO - OtherSymbol
 176                 // TODO - ParagraphSeparator
 177                 // TODO - PrivateUse
 178                 {
 179                         char c1 = ' ';
 180                         Assert.AreEqual(UnicodeCategory.SpaceSeparator,
 181                                                         Char.GetUnicodeCategory(c1),
 182                                                         "SpaceSeparator");
 183                 }
 184                 // TODO - SpacingCombiningMark
 185                 {
 186                         char c1 = (char)0xD800; // D800-DBFF
 187                         char c2 = (char)0xDBFF; // D800-DBFF
 188                         char c3 = (char)0xDC01; // DC00-DEFF
 189                         char c4 = (char)0xDEFF; // DC00-DEFF
 190                         Assert.AreEqual(UnicodeCategory.Surrogate,
 191                                                         Char.GetUnicodeCategory(c1),
 192                                                         "High Surrogate");
 193                         Assert.AreEqual(UnicodeCategory.Surrogate,
 194                                                         Char.GetUnicodeCategory(c2),
 195                                                         "High Surrogate");
 196                         Assert.AreEqual(UnicodeCategory.Surrogate,
 197                                                         Char.GetUnicodeCategory(c3),
 198                                                         "Low Surrogate");
 199                         Assert.AreEqual(UnicodeCategory.Surrogate,
 200                                                         Char.GetUnicodeCategory(c4),
 201                                                         "Low Surrogate");
 202                 }
 203                 // TODO - TitlecaseLetter
 204                 // TODO - UppercaseLetter
 205                 {
 206                         char c1 = 'A';
 207                         char c2 = 'Z';
 208                         Assert.AreEqual(UnicodeCategory.UppercaseLetter,
 209                                                         Char.GetUnicodeCategory(c1),
 210                                                         "UppercaseLetter");
 211                         Assert.AreEqual(UnicodeCategory.UppercaseLetter,
 212                                                         Char.GetUnicodeCategory(c2),
 213                                                         "UppercaseLetter");
 214                 }
 215         }
 216
 217         [Test]
 218         public void TestGetUnicodeCategoryStringIndex ()
 219         {
 220                 Assert.AreEqual (Char.GetUnicodeCategory ("\uD800\uDF80", 0), UnicodeCategory.OtherLetter, "#C01");
 221                 Assert.AreEqual (Char.GetUnicodeCategory ("\uD800\uDF80", 1), UnicodeCategory.Surrogate, "#C02");
 222                 Assert.AreEqual (Char.GetUnicodeCategory ("\uD800", 0), UnicodeCategory.Surrogate, "#C03");
 223                 Assert.AreEqual (Char.GetUnicodeCategory ("\uD800!", 0), UnicodeCategory.Surrogate, "#C04");
 224                 Assert.AreEqual (Char.GetUnicodeCategory ("!", 0), UnicodeCategory.OtherPunctuation, "#C05");
 225                 Assert.AreEqual (Char.GetUnicodeCategory ("!\uD800", 1), UnicodeCategory.Surrogate, "#C06");
 226                 Assert.AreEqual (Char.GetUnicodeCategory ("!\uD800\uDF80", 1), UnicodeCategory.OtherLetter, "#C07");
 227         }
 228
 229         [Test]
 230         public void TestGetUnicodeCategoryAstralPlanes ()
 231         {
 232                 const int up_to = 0x10ffff;
 233                 // const int increment = 1;
 234                 const int increment = 0x1000 + 17;
 235
 236                 for (int codepoint = 0x10000; codepoint < up_to; codepoint += increment) {
 237                         string combined = Char.ConvertFromUtf32 (codepoint);
 238
 239                         Assert.AreEqual (combined.Length, 2, "#D01");
 240                         Assert.AreEqual (Char.GetUnicodeCategory (combined [0]), UnicodeCategory.Surrogate, "#D02");
 241                         Assert.AreEqual (Char.GetUnicodeCategory (combined [1]), UnicodeCategory.Surrogate, "#D03");
 242                         Assert.AreNotEqual (Char.GetUnicodeCategory (combined, 0), UnicodeCategory.Surrogate, "#D04");
 243                 }
 244         }
 245
 246         [Test]
 247         public void TestIsControl()
 248         {
 249                 // control is 0000-001F, 007F-009F
 250                 char c1 = (char)0;
 251                 char c2 = (char)0x001F;
 252                 char c3 = (char)0x007F;
 253                 char c4 = (char)0x009F;
 254                 Assert.IsTrue(!Char.IsControl(' '), "Not control");
 255                 Assert.IsTrue(Char.IsControl(c1), "control");
 256                 Assert.IsTrue(Char.IsControl(c2), "control");
 257                 Assert.IsTrue(Char.IsControl(c3), "control");
 258                 Assert.IsTrue(Char.IsControl(c4), "control");
 259
 260                 string s1 = " " + c1 + c2 + c3 + c4;
 261                 Assert.IsTrue(!Char.IsControl(s1, 0), "Not control");
 262                 Assert.IsTrue(Char.IsControl(s1, 1), "control");
 263                 Assert.IsTrue(Char.IsControl(s1, 2), "control");
 264                 Assert.IsTrue(Char.IsControl(s1, 3), "control");
 265                 Assert.IsTrue(Char.IsControl(s1, 4), "control");
 266         }
 267
 268         [Test]
 269         public void TestIsDigit()
 270         {
 271                 char c1 = '0';
 272                 char c2 = '9';
 273                 Assert.IsTrue(!Char.IsDigit(' '), "Not digit");
 274                 Assert.IsTrue(Char.IsDigit(c1), "digit");
 275                 Assert.IsTrue(Char.IsDigit(c2), "digit");
 276
 277                 string s1 = " " + c1 + c2;
 278                 Assert.IsTrue(!Char.IsDigit(s1, 0), "Not digit");
 279                 Assert.IsTrue(Char.IsDigit(s1, 1), "digit");
 280                 Assert.IsTrue(Char.IsDigit(s1, 2), "digit");
 281         }
 282
 283         [Test]
 284         public void TestIsLetter()
 285         {
 286                 char c1 = 'a';
 287                 char c2 = 'z';
 288                 char c3 = 'A';
 289                 char c4 = 'Z';
 290                 Assert.IsTrue(!Char.IsLetter(' '), "Not letter");
 291                 Assert.IsTrue(Char.IsLetter(c1), "letter");
 292                 Assert.IsTrue(Char.IsLetter(c2), "letter");
 293                 Assert.IsTrue(Char.IsLetter(c3), "letter");
 294                 Assert.IsTrue(Char.IsLetter(c4), "letter");
 295
 296                 string s1 = " " + c1 + c2 + c3 + c4;
 297                 Assert.IsTrue(!Char.IsLetter(s1, 0), "Not letter");
 298                 Assert.IsTrue(Char.IsLetter(s1, 1), "letter");
 299                 Assert.IsTrue(Char.IsLetter(s1, 2), "letter");
 300                 Assert.IsTrue(Char.IsLetter(s1, 3), "letter");
 301                 Assert.IsTrue(Char.IsLetter(s1, 4), "letter");
 302         }
 303
 304         [Test]
 305         public void TestIsLetterOrDigit()
 306         {
 307                 char c1 = 'a';
 308                 char c2 = 'z';
 309                 char c3 = 'A';
 310                 char c4 = 'Z';
 311                 char c5 = '0';
 312                 char c6 = '9';
 313                 Assert.IsTrue(!Char.IsLetterOrDigit(' '), "Not letterordigit");
 314                 Assert.IsTrue(Char.IsLetterOrDigit(c1), "letterordigit");
 315                 Assert.IsTrue(Char.IsLetterOrDigit(c2), "letterordigit");
 316                 Assert.IsTrue(Char.IsLetterOrDigit(c3), "letterordigit");
 317                 Assert.IsTrue(Char.IsLetterOrDigit(c4), "letterordigit");
 318                 Assert.IsTrue(Char.IsLetterOrDigit(c5), "letterordigit");
 319                 Assert.IsTrue(Char.IsLetterOrDigit(c6), "letterordigit");
 320
 321                 string s1 = " " + c1 + c2 + c3 + c4 + c5 + c6;
 322                 Assert.IsTrue(!Char.IsLetterOrDigit(s1, 0), "Not letterordigit");
 323                 Assert.IsTrue(Char.IsLetterOrDigit(s1, 1), "letterordigit");
 324                 Assert.IsTrue(Char.IsLetterOrDigit(s1, 2), "letterordigit");
 325                 Assert.IsTrue(Char.IsLetterOrDigit(s1, 3), "letterordigit");
 326                 Assert.IsTrue(Char.IsLetterOrDigit(s1, 4), "letterordigit");
 327                 Assert.IsTrue(Char.IsLetterOrDigit(s1, 5), "letterordigit");
 328                 Assert.IsTrue(Char.IsLetterOrDigit(s1, 6), "letterordigit");
 329         }
 330
 331         [Test]
 332         public void TestIsLower()
 333         {
 334                 char c1 = 'a';
 335                 char c2 = 'z';
 336                 Assert.IsTrue(!Char.IsLower(' '), "Not lower");
 337                 Assert.IsTrue(Char.IsLower(c1), "lower");
 338                 Assert.IsTrue(Char.IsLower(c2), "lower");
 339
 340                 string s1 = " " + c1 + c2;
 341                 Assert.IsTrue(!Char.IsLower(s1, 0), "Not lower");
 342                 Assert.IsTrue(Char.IsLower(s1, 1), "lower");
 343                 Assert.IsTrue(Char.IsLower(s1, 2), "lower");
 344         }
 345
 346         [Test]
 347         public void TestIsNumber()
 348         {
 349                 char c1 = '0';
 350                 char c2 = '9';
 351                 // TODO - IsNumber of less obvious characters
 352
 353                 Assert.IsTrue(!Char.IsNumber(' '), "Not number");
 354                 Assert.IsTrue(Char.IsNumber(c1), "number");
 355                 Assert.IsTrue(Char.IsNumber(c2), "number");
 356
 357                 string s1 = " " + c1 + c2;
 358                 Assert.IsTrue(!Char.IsNumber(s1, 0), "Not number");
 359                 Assert.IsTrue(Char.IsNumber(s1, 1), "number");
 360                 Assert.IsTrue(Char.IsNumber(s1, 2), "number");
 361         }
 362
 363         [Test]
 364         public void TestIsPunctuation()
 365         {
 366                 char c1 = '.';
 367                 char c2 = '?';
 368                 Assert.IsTrue(!Char.IsPunctuation(' '), "Not punctuation");
 369                 Assert.IsTrue(Char.IsPunctuation(c1), "punctuation");
 370                 Assert.IsTrue(Char.IsPunctuation(c2), "punctuation");
 371
 372                 string s1 = " " + c1 + c2;
 373                 Assert.IsTrue(!Char.IsPunctuation(s1, 0), "Not punctuation");
 374                 Assert.IsTrue(Char.IsPunctuation(s1, 1), "punctuation");
 375                 Assert.IsTrue(Char.IsPunctuation(s1, 2), "punctuation");
 376         }
 377
 378         [Test]
 379         public void TestIsSeparator()
 380         {
 381                 char c1 = ' ';
 382
 383                 Assert.IsTrue(!Char.IsSeparator('.'), "Not separator");
 384                 Assert.IsTrue(Char.IsSeparator(c1), "separator1");
 385
 386                 string s1 = "." + c1;
 387                 Assert.IsTrue(!Char.IsSeparator(s1, 0), "Not separator");
 388                 Assert.IsTrue(Char.IsSeparator(s1, 1), "separator1-2");
 389         }
 390
 391         [Test]
 392         public void TestIsSurrogate()
 393         {
 394                 // high surrogate - D800-DBFF
 395                 // low surrogate - DC00-DEFF
 396                 char c1 = (char)0xD800;
 397                 char c2 = (char)0xDBFF;
 398                 char c3 = (char)0xDC00;
 399                 char c4 = (char)0xDEFF;
 400                 Assert.IsTrue(!Char.IsSurrogate(' '), "Not surrogate");
 401                 Assert.IsTrue(Char.IsSurrogate(c1), "surrogate1");
 402                 Assert.IsTrue(Char.IsSurrogate(c2), "surrogate2");
 403                 Assert.IsTrue(Char.IsSurrogate(c3), "surrogate3");
 404                 Assert.IsTrue(Char.IsSurrogate(c4), "surrogate4");
 405
 406                 string s1 = " " + c1 + c2 + c3 + c4;
 407                 Assert.IsTrue(!Char.IsSurrogate(s1, 0), "Not surrogate");
 408                 Assert.IsTrue(Char.IsSurrogate(s1, 1), "surrogate1-2");
 409                 Assert.IsTrue(Char.IsSurrogate(s1, 2), "surrogate2-2");
 410                 Assert.IsTrue(Char.IsSurrogate(s1, 3), "surrogate3-2");
 411                 Assert.IsTrue(Char.IsSurrogate(s1, 4), "surrogate4-2");
 412         }
 413
 414         [Test]
 415         public void TestIsSymbol()
 416         {
 417                 char c1 = '+';
 418                 char c2 = '=';
 419                 Assert.IsTrue(!Char.IsSymbol(' '), "Not symbol");
 420                 Assert.IsTrue(Char.IsSymbol(c1), "symbol");
 421                 Assert.IsTrue(Char.IsSymbol(c2), "symbol");
 422
 423                 string s1 = " " + c1 + c2;
 424                 Assert.IsTrue(!Char.IsSymbol(s1, 0), "Not symbol");
 425                 Assert.IsTrue(Char.IsSymbol(s1, 1), "symbol");
 426                 Assert.IsTrue(Char.IsSymbol(s1, 2), "symbol");
 427         }
 428
 429         [Test]
 430         public void TestIsUpper()
 431         {
 432                 char c1 = 'A';
 433                 char c2 = 'Z';
 434                 Assert.IsTrue(!Char.IsUpper('a'), "Not upper");
 435                 Assert.IsTrue(Char.IsUpper(c1), "upper");
 436                 Assert.IsTrue(Char.IsUpper(c2), "upper");
 437
 438                 string s1 = "a" + c1 + c2;
 439                 Assert.IsTrue(!Char.IsUpper(s1, 0), "Not upper");
 440                 Assert.IsTrue(Char.IsUpper(s1, 1), "upper");
 441                 Assert.IsTrue(Char.IsUpper(s1, 2), "upper");
 442         }
 443
 444         [Test]
 445         public void TestIsWhiteSpace()
 446         {
 447                 char c1 = ' ';
 448                 char c2 = '\n';
 449                 char c3 = '\t';
 450
 451                 Assert.IsTrue(!Char.IsWhiteSpace('.'), "Not whitespace");
 452                 Assert.IsTrue(Char.IsWhiteSpace(c1), "whitespace1");
 453                 Assert.IsTrue(Char.IsWhiteSpace(c2), "whitespace2");
 454                 Assert.IsTrue(Char.IsWhiteSpace(c3), "whitespace3");
 455
 456                 string s1 = "." + c1 + c2 + c3;
 457                 Assert.IsTrue(!Char.IsWhiteSpace(s1, 0), "Not whitespace");
 458                 Assert.IsTrue(Char.IsWhiteSpace(s1, 1), "whitespace1-2");
 459                 Assert.IsTrue(Char.IsWhiteSpace(s1, 2), "whitespace2-2");
 460                 Assert.IsTrue(Char.IsWhiteSpace(s1, 3), "whitespace3-2");
 461
 462                 for (int i = 0; i < ushort.MaxValue; ++i ) {
 463                         switch (i) {
 464                         case '\x9':
 465                         case '\xa':
 466                         case '\xb':
 467                         case '\xc':
 468                         case '\xd':
 469                         case '\x20':
 470                         case '\x85':
 471                         case '\xa0':
 472                         case '\x1680':
 473                         case '\x2000':
 474                         case '\x2001':
 475                         case '\x2002':
 476                         case '\x2003':
 477                         case '\x2004':
 478                         case '\x2005':
 479                         case '\x2006':
 480                         case '\x2007':
 481                         case '\x2008':
 482                         case '\x2009':
 483                         case '\x200a':
 484                         case '\x2028':
 485                         case '\x2029':
 486                         case '\x202f':
 487                         case '\x205f':
 488                         case '\x3000':
 489                                 Assert.IsTrue (char.IsWhiteSpace ((char)i), "\\x" + i.ToString ("x"));
 490                                 break;
 491                         default:
 492                                 Assert.IsFalse (char.IsWhiteSpace ((char)i), "\\x" + i.ToString ("x"));
 493                                 break;
 494                         }
 495                 }
 496         }
 497
 498         [Test]
 499         public void TestParse()
 500         {
 501                 char c1 = 'a';
 502                 string s1 = "a";
 503                 Assert.IsTrue(c1.Equals(Char.Parse(s1)));
 504         }
 505
 506         [Test]
 507         public void TestTryParseValid ()
 508         {
 509                 char c1 = 'a';
 510                 string s1 = "a";
 511                 char c2;
 512
 513                 Assert.AreEqual (true, Char.TryParse (s1, out c2), "TryParse1");
 514                 Assert.AreEqual (c2, c1, "TryParse2");
 515         }
 516
 517         [Test]
 518         public void TestTryParseInvalid ()
 519         {
 520                 string s = "abc";
 521                 char c;
 522                 Assert.AreEqual (false, Char.TryParse (s, out c), "TryParse3");
 523                 Assert.AreEqual ('\0', c, "TryParse4");
 524         }
 525
 526         [Test]
 527         public void TestToLower()
 528         {
 529                 char a1 = 'a';
 530                 char a2 = 'A';
 531                 char a3 = 'z';
 532                 char a4 = 'Z';
 533                 char a5 = ' ';
 534                 char a6 = '+';
 535                 char b1 = 'a';
 536                 char b2 = 'a';
 537                 char b3 = 'z';
 538                 char b4 = 'z';
 539                 char b5 = ' ';
 540                 char b6 = '+';
 541                 Assert.AreEqual(b1, Char.ToLower(a1), "char lowered");
 542                 Assert.AreEqual(b2, Char.ToLower(a2), "char lowered");
 543                 Assert.AreEqual(b3, Char.ToLower(a3), "char lowered");
 544                 Assert.AreEqual(b4, Char.ToLower(a4), "char lowered");
 545                 Assert.AreEqual(b5, Char.ToLower(a5), "char lowered");
 546                 Assert.AreEqual(b6, Char.ToLower(a6), "char lowered");
 547         }
 548
 549         [Test]
 550         public void TestToUpper()
 551         {
 552                 char a1 = 'a';
 553                 char a2 = 'A';
 554                 char a3 = 'z';
 555                 char a4 = 'Z';
 556                 char a5 = ' ';
 557                 char a6 = '+';
 558                 char b1 = 'A';
 559                 char b2 = 'A';
 560                 char b3 = 'Z';
 561                 char b4 = 'Z';
 562                 char b5 = ' ';
 563                 char b6 = '+';
 564                 Assert.AreEqual(b1, Char.ToUpper(a1), "char uppered");
 565                 Assert.AreEqual(b2, Char.ToUpper(a2), "char uppered");
 566                 Assert.AreEqual(b3, Char.ToUpper(a3), "char uppered");
 567                 Assert.AreEqual(b4, Char.ToUpper(a4), "char uppered");
 568                 Assert.AreEqual(b5, Char.ToUpper(a5), "char uppered");
 569                 Assert.AreEqual(b6, Char.ToUpper(a6), "char uppered");
 570         }
 571
 572         [Test]
 573         public void TestToUpperInvariant ()
 574         {
 575                 Assert.AreEqual ('\u01c5', char.ToUpperInvariant ('\u01c5'));
 576         }
 577
 578         [Test]
 579         public void TestToString()
 580         {
 581                 char c1 = 'a';
 582                 string s1 = "a";
 583                 Assert.IsTrue(s1.Equals(c1.ToString()));
 584         }
 585
 586         [Test]
 587         public void TestGetTypeCode()
 588         {
 589                 char c1 = 'a';
 590                 Assert.IsTrue(c1.GetTypeCode().Equals(TypeCode.Char));
 591         }
 592
 593         [Test]
 594         public void TestConvertFromUtf32 ()
 595         {
 596                 Assert.AreEqual ("A", Char.ConvertFromUtf32 (0x41), "#1");
 597                 Assert.AreEqual ("\uD800\uDC00", Char.ConvertFromUtf32 (0x10000), "#2");
 598         }
 599
 600         [Test]
 601         [ExpectedException (typeof (ArgumentOutOfRangeException))]
 602         public void TestConvertFromUtf32Fail1 ()
 603         {
 604                 Char.ConvertFromUtf32 (-1);
 605         }
 606
 607         [Test]
 608         [ExpectedException (typeof (ArgumentOutOfRangeException))]
 609         public void TestConvertFromUtf32Fail2 ()
 610         {
 611                 Char.ConvertFromUtf32 (0x110001);
 612         }
 613
 614         [Test]
 615         [ExpectedException (typeof (ArgumentOutOfRangeException))]
 616         public void TestConvertFromUtf32Fail3 ()
 617         {
 618                 Char.ConvertFromUtf32 (0xD800);
 619         }
 620
 621         [Test]
 622         public void TestConvertToUtf32 ()
 623         {
 624                 Assert.AreEqual (0x10000, Char.ConvertToUtf32 ('\uD800', '\uDC00'), "#1");
 625                 Assert.AreEqual (0x10FFFF, Char.ConvertToUtf32 ('\uDBFF', '\uDFFF'), "#2");
 626         }
 627
 628         [Test]
 629         [ExpectedException (typeof (ArgumentOutOfRangeException))]
 630         public void TestConvertToUtf32Fail1 ()
 631         {
 632                 Char.ConvertToUtf32 ('A', '\uDC00');
 633         }
 634
 635         [Test]
 636         [ExpectedException (typeof (ArgumentOutOfRangeException))]
 637         public void TestConvertUtf32Fail2 ()
 638         {
 639                 Char.ConvertToUtf32 ('\uD800', '\uD800');
 640         }
 641 }
 642
 643 }