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

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