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
  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 TestIsControl()
 219         {
 220                 // control is 0000-001F, 007F-009F
 221                 char c1 = (char)0;
 222                 char c2 = (char)0x001F;
 223                 char c3 = (char)0x007F;
 224                 char c4 = (char)0x009F;
 225                 Assert.IsTrue(!Char.IsControl(' '), "Not control");
 226                 Assert.IsTrue(Char.IsControl(c1), "control");
 227                 Assert.IsTrue(Char.IsControl(c2), "control");
 228                 Assert.IsTrue(Char.IsControl(c3), "control");
 229                 Assert.IsTrue(Char.IsControl(c4), "control");
 230
 231                 string s1 = " " + c1 + c2 + c3 + c4;
 232                 Assert.IsTrue(!Char.IsControl(s1, 0), "Not control");
 233                 Assert.IsTrue(Char.IsControl(s1, 1), "control");
 234                 Assert.IsTrue(Char.IsControl(s1, 2), "control");
 235                 Assert.IsTrue(Char.IsControl(s1, 3), "control");
 236                 Assert.IsTrue(Char.IsControl(s1, 4), "control");
 237         }
 238
 239         [Test]
 240         public void TestIsDigit()
 241         {
 242                 char c1 = '0';
 243                 char c2 = '9';
 244                 Assert.IsTrue(!Char.IsDigit(' '), "Not digit");
 245                 Assert.IsTrue(Char.IsDigit(c1), "digit");
 246                 Assert.IsTrue(Char.IsDigit(c2), "digit");
 247
 248                 string s1 = " " + c1 + c2;
 249                 Assert.IsTrue(!Char.IsDigit(s1, 0), "Not digit");
 250                 Assert.IsTrue(Char.IsDigit(s1, 1), "digit");
 251                 Assert.IsTrue(Char.IsDigit(s1, 2), "digit");
 252         }
 253
 254         [Test]
 255         public void TestIsLetter()
 256         {
 257                 char c1 = 'a';
 258                 char c2 = 'z';
 259                 char c3 = 'A';
 260                 char c4 = 'Z';
 261                 Assert.IsTrue(!Char.IsLetter(' '), "Not letter");
 262                 Assert.IsTrue(Char.IsLetter(c1), "letter");
 263                 Assert.IsTrue(Char.IsLetter(c2), "letter");
 264                 Assert.IsTrue(Char.IsLetter(c3), "letter");
 265                 Assert.IsTrue(Char.IsLetter(c4), "letter");
 266
 267                 string s1 = " " + c1 + c2 + c3 + c4;
 268                 Assert.IsTrue(!Char.IsLetter(s1, 0), "Not letter");
 269                 Assert.IsTrue(Char.IsLetter(s1, 1), "letter");
 270                 Assert.IsTrue(Char.IsLetter(s1, 2), "letter");
 271                 Assert.IsTrue(Char.IsLetter(s1, 3), "letter");
 272                 Assert.IsTrue(Char.IsLetter(s1, 4), "letter");
 273         }
 274
 275         [Test]
 276         public void TestIsLetterOrDigit()
 277         {
 278                 char c1 = 'a';
 279                 char c2 = 'z';
 280                 char c3 = 'A';
 281                 char c4 = 'Z';
 282                 char c5 = '0';
 283                 char c6 = '9';
 284                 Assert.IsTrue(!Char.IsLetterOrDigit(' '), "Not letterordigit");
 285                 Assert.IsTrue(Char.IsLetterOrDigit(c1), "letterordigit");
 286                 Assert.IsTrue(Char.IsLetterOrDigit(c2), "letterordigit");
 287                 Assert.IsTrue(Char.IsLetterOrDigit(c3), "letterordigit");
 288                 Assert.IsTrue(Char.IsLetterOrDigit(c4), "letterordigit");
 289                 Assert.IsTrue(Char.IsLetterOrDigit(c5), "letterordigit");
 290                 Assert.IsTrue(Char.IsLetterOrDigit(c6), "letterordigit");
 291
 292                 string s1 = " " + c1 + c2 + c3 + c4 + c5 + c6;
 293                 Assert.IsTrue(!Char.IsLetterOrDigit(s1, 0), "Not letterordigit");
 294                 Assert.IsTrue(Char.IsLetterOrDigit(s1, 1), "letterordigit");
 295                 Assert.IsTrue(Char.IsLetterOrDigit(s1, 2), "letterordigit");
 296                 Assert.IsTrue(Char.IsLetterOrDigit(s1, 3), "letterordigit");
 297                 Assert.IsTrue(Char.IsLetterOrDigit(s1, 4), "letterordigit");
 298                 Assert.IsTrue(Char.IsLetterOrDigit(s1, 5), "letterordigit");
 299                 Assert.IsTrue(Char.IsLetterOrDigit(s1, 6), "letterordigit");
 300         }
 301
 302         [Test]
 303         public void TestIsLower()
 304         {
 305                 char c1 = 'a';
 306                 char c2 = 'z';
 307                 Assert.IsTrue(!Char.IsLower(' '), "Not lower");
 308                 Assert.IsTrue(Char.IsLower(c1), "lower");
 309                 Assert.IsTrue(Char.IsLower(c2), "lower");
 310
 311                 string s1 = " " + c1 + c2;
 312                 Assert.IsTrue(!Char.IsLower(s1, 0), "Not lower");
 313                 Assert.IsTrue(Char.IsLower(s1, 1), "lower");
 314                 Assert.IsTrue(Char.IsLower(s1, 2), "lower");
 315         }
 316
 317         [Test]
 318         public void TestIsNumber()
 319         {
 320                 char c1 = '0';
 321                 char c2 = '9';
 322                 // TODO - IsNumber of less obvious characters
 323
 324                 Assert.IsTrue(!Char.IsNumber(' '), "Not number");
 325                 Assert.IsTrue(Char.IsNumber(c1), "number");
 326                 Assert.IsTrue(Char.IsNumber(c2), "number");
 327
 328                 string s1 = " " + c1 + c2;
 329                 Assert.IsTrue(!Char.IsNumber(s1, 0), "Not number");
 330                 Assert.IsTrue(Char.IsNumber(s1, 1), "number");
 331                 Assert.IsTrue(Char.IsNumber(s1, 2), "number");
 332         }
 333
 334         [Test]
 335         public void TestIsPunctuation()
 336         {
 337                 char c1 = '.';
 338                 char c2 = '?';
 339                 Assert.IsTrue(!Char.IsPunctuation(' '), "Not punctuation");
 340                 Assert.IsTrue(Char.IsPunctuation(c1), "punctuation");
 341                 Assert.IsTrue(Char.IsPunctuation(c2), "punctuation");
 342
 343                 string s1 = " " + c1 + c2;
 344                 Assert.IsTrue(!Char.IsPunctuation(s1, 0), "Not punctuation");
 345                 Assert.IsTrue(Char.IsPunctuation(s1, 1), "punctuation");
 346                 Assert.IsTrue(Char.IsPunctuation(s1, 2), "punctuation");
 347         }
 348
 349         [Test]
 350         public void TestIsSeparator()
 351         {
 352                 char c1 = ' ';
 353
 354                 Assert.IsTrue(!Char.IsSeparator('.'), "Not separator");
 355                 Assert.IsTrue(Char.IsSeparator(c1), "separator1");
 356
 357                 string s1 = "." + c1;
 358                 Assert.IsTrue(!Char.IsSeparator(s1, 0), "Not separator");
 359                 Assert.IsTrue(Char.IsSeparator(s1, 1), "separator1-2");
 360         }
 361
 362         [Test]
 363         public void TestIsSurrogate()
 364         {
 365                 // high surrogate - D800-DBFF
 366                 // low surrogate - DC00-DEFF
 367                 char c1 = (char)0xD800;
 368                 char c2 = (char)0xDBFF;
 369                 char c3 = (char)0xDC00;
 370                 char c4 = (char)0xDEFF;
 371                 Assert.IsTrue(!Char.IsSurrogate(' '), "Not surrogate");
 372                 Assert.IsTrue(Char.IsSurrogate(c1), "surrogate1");
 373                 Assert.IsTrue(Char.IsSurrogate(c2), "surrogate2");
 374                 Assert.IsTrue(Char.IsSurrogate(c3), "surrogate3");
 375                 Assert.IsTrue(Char.IsSurrogate(c4), "surrogate4");
 376
 377                 string s1 = " " + c1 + c2 + c3 + c4;
 378                 Assert.IsTrue(!Char.IsSurrogate(s1, 0), "Not surrogate");
 379                 Assert.IsTrue(Char.IsSurrogate(s1, 1), "surrogate1-2");
 380                 Assert.IsTrue(Char.IsSurrogate(s1, 2), "surrogate2-2");
 381                 Assert.IsTrue(Char.IsSurrogate(s1, 3), "surrogate3-2");
 382                 Assert.IsTrue(Char.IsSurrogate(s1, 4), "surrogate4-2");
 383         }
 384
 385         [Test]
 386         public void TestIsSymbol()
 387         {
 388                 char c1 = '+';
 389                 char c2 = '=';
 390                 Assert.IsTrue(!Char.IsSymbol(' '), "Not symbol");
 391                 Assert.IsTrue(Char.IsSymbol(c1), "symbol");
 392                 Assert.IsTrue(Char.IsSymbol(c2), "symbol");
 393
 394                 string s1 = " " + c1 + c2;
 395                 Assert.IsTrue(!Char.IsSymbol(s1, 0), "Not symbol");
 396                 Assert.IsTrue(Char.IsSymbol(s1, 1), "symbol");
 397                 Assert.IsTrue(Char.IsSymbol(s1, 2), "symbol");
 398         }
 399
 400         [Test]
 401         public void TestIsUpper()
 402         {
 403                 char c1 = 'A';
 404                 char c2 = 'Z';
 405                 Assert.IsTrue(!Char.IsUpper('a'), "Not upper");
 406                 Assert.IsTrue(Char.IsUpper(c1), "upper");
 407                 Assert.IsTrue(Char.IsUpper(c2), "upper");
 408
 409                 string s1 = "a" + c1 + c2;
 410                 Assert.IsTrue(!Char.IsUpper(s1, 0), "Not upper");
 411                 Assert.IsTrue(Char.IsUpper(s1, 1), "upper");
 412                 Assert.IsTrue(Char.IsUpper(s1, 2), "upper");
 413         }
 414
 415         [Test]
 416         public void TestIsWhiteSpace()
 417         {
 418                 char c1 = ' ';
 419                 char c2 = '\n';
 420                 char c3 = '\t';
 421
 422                 Assert.IsTrue(!Char.IsWhiteSpace('.'), "Not whitespace");
 423                 Assert.IsTrue(Char.IsWhiteSpace(c1), "whitespace1");
 424                 Assert.IsTrue(Char.IsWhiteSpace(c2), "whitespace2");
 425                 Assert.IsTrue(Char.IsWhiteSpace(c3), "whitespace3");
 426
 427                 string s1 = "." + c1 + c2 + c3;
 428                 Assert.IsTrue(!Char.IsWhiteSpace(s1, 0), "Not whitespace");
 429                 Assert.IsTrue(Char.IsWhiteSpace(s1, 1), "whitespace1-2");
 430                 Assert.IsTrue(Char.IsWhiteSpace(s1, 2), "whitespace2-2");
 431                 Assert.IsTrue(Char.IsWhiteSpace(s1, 3), "whitespace3-2");
 432         }
 433
 434         [Test]
 435         public void IsWhiteSpace_Complete ()
 436         {
 437                 for (int i=0; i < UInt16.MaxValue; i++) {
 438                         Char c = Convert.ToChar (i);
 439                         switch (i) {
 440                         case 0x0009:
 441                         case 0x000A:
 442                         case 0x000B:
 443                         case 0x000C:
 444                         case 0x000D:
 445                         case 0x0020:
 446                         case 0x0085:
 447                         case 0x00A0:
 448                         case 0x1680:
 449                         case 0x2000:
 450                         case 0x2001:
 451                         case 0x2002:
 452                         case 0x2003:
 453                         case 0x2004:
 454                         case 0x2005:
 455                         case 0x2006:
 456                         case 0x2007:
 457                         case 0x2008:
 458                         case 0x2009:
 459                         case 0x200A:
 460                         case 0x200B:
 461                         case 0x2028:
 462                         case 0x2029:
 463                         case 0x202F:
 464 #if NET_2_0
 465                         case 0x205F:
 466 #endif
 467                         case 0x3000:
 468                                 Assert.IsTrue (Char.IsWhiteSpace (c), i.ToString ());
 469                                 break;
 470                         default:
 471                                 Assert.IsTrue (!Char.IsWhiteSpace (c), i.ToString ());
 472                                 break;
 473                         }
 474                 }
 475         }
 476
 477         [Test]
 478         public void TestParse()
 479         {
 480                 char c1 = 'a';
 481                 string s1 = "a";
 482                 Assert.IsTrue(c1.Equals(Char.Parse(s1)));
 483         }
 484
 485 #if NET_2_0
 486         [Test]
 487         public void TestTryParseValid ()
 488         {
 489                 char c1 = 'a';
 490                 string s1 = "a";
 491                 char c2;
 492
 493                 Assert.AreEqual (true, Char.TryParse (s1, out c2), "TryParse1");
 494                 Assert.AreEqual (c2, c1, "TryParse2");
 495         }
 496
 497         [Test]
 498         public void TestTryParseInvalid ()
 499         {
 500                 string s = "abc";
 501                 char c;
 502                 Assert.AreEqual (false, Char.TryParse (s, out c), "TryParse3");
 503                 Assert.AreEqual ('\0', c, "TryParse4");
 504         }
 505 #endif
 506
 507         [Test]
 508         public void TestToLower()
 509         {
 510                 char a1 = 'a';
 511                 char a2 = 'A';
 512                 char a3 = 'z';
 513                 char a4 = 'Z';
 514                 char a5 = ' ';
 515                 char a6 = '+';
 516                 char b1 = 'a';
 517                 char b2 = 'a';
 518                 char b3 = 'z';
 519                 char b4 = 'z';
 520                 char b5 = ' ';
 521                 char b6 = '+';
 522                 Assert.AreEqual(b1, Char.ToLower(a1), "char lowered");
 523                 Assert.AreEqual(b2, Char.ToLower(a2), "char lowered");
 524                 Assert.AreEqual(b3, Char.ToLower(a3), "char lowered");
 525                 Assert.AreEqual(b4, Char.ToLower(a4), "char lowered");
 526                 Assert.AreEqual(b5, Char.ToLower(a5), "char lowered");
 527                 Assert.AreEqual(b6, Char.ToLower(a6), "char lowered");
 528         }
 529
 530         [Test]
 531         public void TestToUpper()
 532         {
 533                 char a1 = 'a';
 534                 char a2 = 'A';
 535                 char a3 = 'z';
 536                 char a4 = 'Z';
 537                 char a5 = ' ';
 538                 char a6 = '+';
 539                 char b1 = 'A';
 540                 char b2 = 'A';
 541                 char b3 = 'Z';
 542                 char b4 = 'Z';
 543                 char b5 = ' ';
 544                 char b6 = '+';
 545                 Assert.AreEqual(b1, Char.ToUpper(a1), "char uppered");
 546                 Assert.AreEqual(b2, Char.ToUpper(a2), "char uppered");
 547                 Assert.AreEqual(b3, Char.ToUpper(a3), "char uppered");
 548                 Assert.AreEqual(b4, Char.ToUpper(a4), "char uppered");
 549                 Assert.AreEqual(b5, Char.ToUpper(a5), "char uppered");
 550                 Assert.AreEqual(b6, Char.ToUpper(a6), "char uppered");
 551         }
 552
 553         [Test]
 554         public void TestToString()
 555         {
 556                 char c1 = 'a';
 557                 string s1 = "a";
 558                 Assert.IsTrue(s1.Equals(c1.ToString()));
 559         }
 560
 561         [Test]
 562         public void TestGetTypeCode()
 563         {
 564                 char c1 = 'a';
 565                 Assert.IsTrue(c1.GetTypeCode().Equals(TypeCode.Char));
 566         }
 567
 568 #if NET_2_0
 569         [Test]
 570         public void TestConvertFromUtf32 ()
 571         {
 572                 Assert.AreEqual ("A", Char.ConvertFromUtf32 (0x41), "#1");
 573                 Assert.AreEqual ("\uD800\uDC00", Char.ConvertFromUtf32 (0x10000), "#2");
 574         }
 575
 576         [Test]
 577         [ExpectedException (typeof (ArgumentOutOfRangeException))]
 578         public void TestConvertFromUtf32Fail1 ()
 579         {
 580                 Char.ConvertFromUtf32 (-1);
 581         }
 582
 583         [Test]
 584         [ExpectedException (typeof (ArgumentOutOfRangeException))]
 585         public void TestConvertFromUtf32Fail2 ()
 586         {
 587                 Char.ConvertFromUtf32 (0x110001);
 588         }
 589
 590         [Test]
 591         [ExpectedException (typeof (ArgumentOutOfRangeException))]
 592         public void TestConvertFromUtf32Fail3 ()
 593         {
 594                 Char.ConvertFromUtf32 (0xD800);
 595         }
 596
 597         [Test]
 598         public void TestConvertToUtf32 ()
 599         {
 600                 Assert.AreEqual (0x10000, Char.ConvertToUtf32 ('\uD800', '\uDC00'), "#1");
 601                 Assert.AreEqual (0x10FFFF, Char.ConvertToUtf32 ('\uDBFF', '\uDFFF'), "#2");
 602         }
 603
 604         [Test]
 605         [ExpectedException (typeof (ArgumentOutOfRangeException))]
 606         public void TestConvertToUtf32Fail1 ()
 607         {
 608                 Char.ConvertToUtf32 ('A', '\uDC00');
 609         }
 610
 611         [Test]
 612         [ExpectedException (typeof (ArgumentOutOfRangeException))]
 613         public void TestConvertUtf32Fail2 ()
 614         {
 615                 Char.ConvertToUtf32 ('\uD800', '\uD800');
 616         }
 617 #endif
 618 }
 619
 620 }