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 // \r
   7 \r
   8 using NUnit.Framework;\r
   9 using System;\r
  10 using System.Globalization;\r
  11 \r
  12 namespace MonoTests.System\r
  13 {\r
  14 \r
  15 public class CharTest : TestCase\r
  16 {\r
  17         public CharTest() {}\r
  18 \r
  19         protected override void SetUp() \r
  20         {\r
  21         }\r
  22 \r
  23         protected override void TearDown() \r
  24         {\r
  25         }\r
  26 \r
  27         public void TestCompareTo()\r
  28         {\r
  29                 Char c1 = 'a';\r
  30                 Char c2 = 'b';\r
  31                 Char c3 = 'b';\r
  32                 Assert("Less than", c1.CompareTo(c2) == -1);\r
  33                 Assert("Greater than", c2.CompareTo(c1) == 1);\r
  34                 Assert("Equal 1", c2.CompareTo(c3) == 0);\r
  35                 Assert("Equal 2", c1.CompareTo(c1) == 0);\r
  36         }\r
  37         \r
  38         public void TestEquals()\r
  39         {\r
  40                 Char c1 = 'a';\r
  41                 Char c2 = 'b';\r
  42                 Char c3 = 'b';\r
  43                 Assert("Same", c1.Equals(c1));\r
  44                 Assert("Same value", c2.Equals(c3));\r
  45                 Assert("Not same", !c1.Equals(c2));\r
  46         }\r
  47 \r
  48         public void TestGetHashValue()\r
  49         {\r
  50                 Char c1 = ' ';\r
  51                 AssertEquals("deterministic hash code ", c1.GetHashCode(), c1.GetHashCode());\r
  52                 // 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
  53         }\r
  54 \r
  55         public void TestGetNumericValue()\r
  56         {\r
  57                 Char c1 = ' ';\r
  58                 Char c2 = '3';\r
  59                 AssertEquals("code 1", -1.0, Char.GetNumericValue(c1), 0.1);\r
  60                 AssertEquals("code 2", 3.0, Char.GetNumericValue(c2), 0.1);\r
  61 \r
  62                 string s1 = " 3 ";\r
  63                 AssertEquals("space not number", -1.0, Char.GetNumericValue(s1, 0), 0.1);\r
  64                 AssertEquals("space not number", 3.0, Char.GetNumericValue(s1, 1), 0.1);\r
  65                 AssertEquals("space not number", -1.0, Char.GetNumericValue(s1, 2), 0.1);\r
  66         }\r
  67 \r
  68         public void TestGetUnicodeCategory()\r
  69         {\r
  70                 {\r
  71                         char Pe1 = ']';\r
  72                         char Pe2 = '}';\r
  73                         char Pe3 = ')';\r
  74                         AssertEquals("Close Punctuation", \r
  75                                      UnicodeCategory.ClosePunctuation, \r
  76                                      Char.GetUnicodeCategory(Pe1));\r
  77                         AssertEquals("Close Punctuation", \r
  78                                      UnicodeCategory.ClosePunctuation, \r
  79                                      Char.GetUnicodeCategory(Pe2));\r
  80                         AssertEquals("Close Punctuation", \r
  81                                      UnicodeCategory.ClosePunctuation, \r
  82                                      Char.GetUnicodeCategory(Pe3));\r
  83                 }\r
  84                 // TODO - ConnectorPunctuation\r
  85                 {\r
  86                         char c1 = (char)0; // 0000-001F, 007F-009F\r
  87                         char c2 = (char)0x001F;\r
  88                         char c3 = (char)0x007F;\r
  89                         char c4 = (char)0x00F;\r
  90                         AssertEquals("Control", \r
  91                                      UnicodeCategory.Control, \r
  92                                      Char.GetUnicodeCategory(c1));\r
  93                         AssertEquals("Control", \r
  94                                      UnicodeCategory.Control, \r
  95                                      Char.GetUnicodeCategory(c2));\r
  96                         AssertEquals("Control", \r
  97                                      UnicodeCategory.Control, \r
  98                                      Char.GetUnicodeCategory(c3));\r
  99                         AssertEquals("Control", \r
 100                                      UnicodeCategory.Control, \r
 101                                      Char.GetUnicodeCategory(c4));\r
 102                 }\r
 103                 {\r
 104                         // TODO - more currencies?\r
 105                         char c1 = '$';\r
 106                         AssertEquals("Currency",\r
 107                                      UnicodeCategory.CurrencySymbol,\r
 108                                      Char.GetUnicodeCategory(c1));\r
 109                 }\r
 110                 {\r
 111                         char c1 = '-';\r
 112                         AssertEquals("Dash Punctuation", \r
 113                                      UnicodeCategory.DashPunctuation, \r
 114                                      Char.GetUnicodeCategory(c1));\r
 115                 }\r
 116                 {\r
 117                         char c1 = '2';\r
 118                         char c2 = '7';\r
 119                         AssertEquals("Decimal Digit", \r
 120                                      UnicodeCategory.DecimalDigitNumber, \r
 121                                      Char.GetUnicodeCategory(c1));\r
 122                         AssertEquals("Decimal Digit", \r
 123                                      UnicodeCategory.DecimalDigitNumber, \r
 124                                      Char.GetUnicodeCategory(c2));\r
 125                 }\r
 126                 // TODO - EnclosingMark\r
 127                 // TODO - FinalQuotePunctuation\r
 128                 // TODO - Format\r
 129                 // TODO - InitialQuotePunctuation\r
 130                 // TODO - LetterNumber\r
 131                 // TODO - LineSeparator (not '\n', that's a control char)\r
 132                 {\r
 133                         char c1 = 'a';\r
 134                         char c2 = 'z';\r
 135                         AssertEquals("LowercaseLetter", \r
 136                                      UnicodeCategory.LowercaseLetter, \r
 137                                      Char.GetUnicodeCategory(c1));\r
 138                         AssertEquals("LowercaseLetter", \r
 139                                      UnicodeCategory.LowercaseLetter, \r
 140                                      Char.GetUnicodeCategory(c2));\r
 141                 }\r
 142                 {\r
 143                         char c1 = '+';\r
 144                         char c2 = '=';\r
 145                         AssertEquals("MathSymbol", \r
 146                                      UnicodeCategory.MathSymbol, \r
 147                                      Char.GetUnicodeCategory(c1));\r
 148                         AssertEquals("MathSymbol", \r
 149                                      UnicodeCategory.MathSymbol, \r
 150                                      Char.GetUnicodeCategory(c2));\r
 151                 }\r
 152                 // TODO - ModifierSymbol\r
 153                 // TODO - NonSpacingMark\r
 154                 // TODO - OpenPunctuation\r
 155                 {\r
 156                         char c1 = '[';\r
 157                         char c2 = '{';\r
 158                         char c3 = '(';\r
 159                         AssertEquals("OpenPunctuation", \r
 160                                      UnicodeCategory.OpenPunctuation, \r
 161                                      Char.GetUnicodeCategory(c1));\r
 162                         AssertEquals("OpenPunctuation", \r
 163                                      UnicodeCategory.OpenPunctuation, \r
 164                                      Char.GetUnicodeCategory(c2));\r
 165                         AssertEquals("OpenPunctuation", \r
 166                                      UnicodeCategory.OpenPunctuation, \r
 167                                      Char.GetUnicodeCategory(c3));\r
 168                 }\r
 169                 // TODO - OtherLetter\r
 170                 // TODO - OtherNotAssigned\r
 171                 // TODO - OtherNumber\r
 172                 {\r
 173                         char c1 = '/';\r
 174                         AssertEquals("OtherPunctuation", \r
 175                                      UnicodeCategory.OtherPunctuation, \r
 176                                      Char.GetUnicodeCategory(c1));\r
 177                 }\r
 178                 // TODO - OtherSymbol\r
 179                 // TODO - ParagraphSeparator\r
 180                 // TODO - PrivateUse\r
 181                 {\r
 182                         char c1 = ' ';\r
 183                         AssertEquals("SpaceSeparator", \r
 184                                      UnicodeCategory.SpaceSeparator, \r
 185                                      Char.GetUnicodeCategory(c1));\r
 186                 }\r
 187                 // TODO - SpacingCombiningMark\r
 188                 {\r
 189                         char c1 = (char)0xD800; // D800-DBFF\r
 190                         char c2 = (char)0xDBFF; // D800-DBFF\r
 191                         char c3 = (char)0xDC01; // DC00-DEFF\r
 192                         char c4 = (char)0xDEFF; // DC00-DEFF\r
 193                         AssertEquals("High Surrogate", \r
 194                                      UnicodeCategory.Surrogate, \r
 195                                      Char.GetUnicodeCategory(c1));\r
 196                         AssertEquals("High Surrogate", \r
 197                                      UnicodeCategory.Surrogate, \r
 198                                      Char.GetUnicodeCategory(c2));\r
 199                         AssertEquals("Low Surrogate", \r
 200                                      UnicodeCategory.Surrogate, \r
 201                                      Char.GetUnicodeCategory(c3));\r
 202                         AssertEquals("Low Surrogate", \r
 203                                      UnicodeCategory.Surrogate, \r
 204                                      Char.GetUnicodeCategory(c4));\r
 205                 }\r
 206                 // TODO - TitlecaseLetter\r
 207                 // TODO - UppercaseLetter\r
 208                 {\r
 209                         char c1 = 'A';\r
 210                         char c2 = 'Z';\r
 211                         AssertEquals("UppercaseLetter", \r
 212                                      UnicodeCategory.UppercaseLetter, \r
 213                                      Char.GetUnicodeCategory(c1));\r
 214                         AssertEquals("UppercaseLetter", \r
 215                                      UnicodeCategory.UppercaseLetter, \r
 216                                      Char.GetUnicodeCategory(c2));\r
 217                 }\r
 218         }\r
 219 \r
 220         public void TestIsControl()\r
 221         {\r
 222                 // control is 0000-001F, 007F-009F\r
 223                 char c1 = (char)0;\r
 224                 char c2 = (char)0x001F;\r
 225                 char c3 = (char)0x007F;\r
 226                 char c4 = (char)0x009F;\r
 227                 Assert("Not control", !Char.IsControl(' '));\r
 228                 Assert("control", Char.IsControl(c1));\r
 229                 Assert("control", Char.IsControl(c2));\r
 230                 Assert("control", Char.IsControl(c3));\r
 231                 Assert("control", Char.IsControl(c4));\r
 232 \r
 233                 string s1 = " " + c1 + c2 + c3 + c4;\r
 234                 Assert("Not control", !Char.IsControl(s1, 0));\r
 235                 Assert("control", Char.IsControl(s1, 1));\r
 236                 Assert("control", Char.IsControl(s1, 2));\r
 237                 Assert("control", Char.IsControl(s1, 3));\r
 238                 Assert("control", Char.IsControl(s1, 4));\r
 239         }\r
 240 \r
 241         public void TestIsDigit()\r
 242         {\r
 243                 char c1 = '0';\r
 244                 char c2 = '9';\r
 245                 Assert("Not digit", !Char.IsDigit(' '));\r
 246                 Assert("digit", Char.IsDigit(c1));\r
 247                 Assert("digit", Char.IsDigit(c2));\r
 248 \r
 249                 string s1 = " " + c1 + c2;\r
 250                 Assert("Not digit", !Char.IsDigit(s1, 0));\r
 251                 Assert("digit", Char.IsDigit(s1, 1));\r
 252                 Assert("digit", Char.IsDigit(s1, 2));\r
 253         }\r
 254 \r
 255         public void TestIsLetter()\r
 256         {\r
 257                 char c1 = 'a';\r
 258                 char c2 = 'z';\r
 259                 char c3 = 'A';\r
 260                 char c4 = 'Z';\r
 261                 Assert("Not letter", !Char.IsLetter(' '));\r
 262                 Assert("letter", Char.IsLetter(c1));\r
 263                 Assert("letter", Char.IsLetter(c2));\r
 264                 Assert("letter", Char.IsLetter(c3));\r
 265                 Assert("letter", Char.IsLetter(c4));\r
 266 \r
 267                 string s1 = " " + c1 + c2 + c3 + c4;\r
 268                 Assert("Not letter", !Char.IsLetter(s1, 0));\r
 269                 Assert("letter", Char.IsLetter(s1, 1));\r
 270                 Assert("letter", Char.IsLetter(s1, 2));\r
 271                 Assert("letter", Char.IsLetter(s1, 3));\r
 272                 Assert("letter", Char.IsLetter(s1, 4));\r
 273         }\r
 274 \r
 275         public void TestIsLetterOrDigit()\r
 276         {\r
 277                 char c1 = 'a';\r
 278                 char c2 = 'z';\r
 279                 char c3 = 'A';\r
 280                 char c4 = 'Z';\r
 281                 char c5 = '0';\r
 282                 char c6 = '9';\r
 283                 Assert("Not letterordigit", !Char.IsLetterOrDigit(' '));\r
 284                 Assert("letterordigit", Char.IsLetterOrDigit(c1));\r
 285                 Assert("letterordigit", Char.IsLetterOrDigit(c2));\r
 286                 Assert("letterordigit", Char.IsLetterOrDigit(c3));\r
 287                 Assert("letterordigit", Char.IsLetterOrDigit(c4));\r
 288                 Assert("letterordigit", Char.IsLetterOrDigit(c5));\r
 289                 Assert("letterordigit", Char.IsLetterOrDigit(c6));\r
 290 \r
 291                 string s1 = " " + c1 + c2 + c3 + c4 + c5 + c6;\r
 292                 Assert("Not letterordigit", !Char.IsLetterOrDigit(s1, 0));\r
 293                 Assert("letterordigit", Char.IsLetterOrDigit(s1, 1));\r
 294                 Assert("letterordigit", Char.IsLetterOrDigit(s1, 2));\r
 295                 Assert("letterordigit", Char.IsLetterOrDigit(s1, 3));\r
 296                 Assert("letterordigit", Char.IsLetterOrDigit(s1, 4));\r
 297                 Assert("letterordigit", Char.IsLetterOrDigit(s1, 5));\r
 298                 Assert("letterordigit", Char.IsLetterOrDigit(s1, 6));\r
 299         }\r
 300 \r
 301         public void TestIsLower()\r
 302         {\r
 303                 char c1 = 'a';\r
 304                 char c2 = 'z';\r
 305                 Assert("Not lower", !Char.IsLower(' '));\r
 306                 Assert("lower", Char.IsLower(c1));\r
 307                 Assert("lower", Char.IsLower(c2));\r
 308 \r
 309                 string s1 = " " + c1 + c2;\r
 310                 Assert("Not lower", !Char.IsLower(s1, 0));\r
 311                 Assert("lower", Char.IsLower(s1, 1));\r
 312                 Assert("lower", Char.IsLower(s1, 2));\r
 313         }\r
 314 \r
 315         public void TestIsNumber()\r
 316         {\r
 317                 char c1 = '0';\r
 318                 char c2 = '9';\r
 319                 // TODO - IsNumber of less obvious characters\r
 320 \r
 321                 Assert("Not number", !Char.IsNumber(' '));\r
 322                 Assert("number", Char.IsNumber(c1));\r
 323                 Assert("number", Char.IsNumber(c2));\r
 324 \r
 325                 string s1 = " " + c1 + c2;\r
 326                 Assert("Not number", !Char.IsNumber(s1, 0));\r
 327                 Assert("number", Char.IsNumber(s1, 1));\r
 328                 Assert("number", Char.IsNumber(s1, 2));\r
 329         }\r
 330 \r
 331         public void TestIsPunctuation()\r
 332         {\r
 333                 char c1 = '.';\r
 334                 char c2 = '?';\r
 335                 Assert("Not punctuation", !Char.IsPunctuation(' '));\r
 336                 Assert("punctuation", Char.IsPunctuation(c1));\r
 337                 Assert("punctuation", Char.IsPunctuation(c2));\r
 338 \r
 339                 string s1 = " " + c1 + c2;\r
 340                 Assert("Not punctuation", !Char.IsPunctuation(s1, 0));\r
 341                 Assert("punctuation", Char.IsPunctuation(s1, 1));\r
 342                 Assert("punctuation", Char.IsPunctuation(s1, 2));\r
 343         }\r
 344 \r
 345         public void TestIsSeparator()\r
 346         {\r
 347                 char c1 = ' ';\r
 348 \r
 349                 Assert("Not separator", !Char.IsSeparator('.'));\r
 350                 Assert("separator1", Char.IsSeparator(c1));\r
 351 \r
 352                 string s1 = "." + c1;\r
 353                 Assert("Not separator", !Char.IsSeparator(s1, 0));\r
 354                 Assert("separator1-2", Char.IsSeparator(s1, 1));\r
 355         }\r
 356 \r
 357         public void TestIsSurrogate()\r
 358         {\r
 359                 // high surrogate - D800-DBFF\r
 360                 // low surrogate - DC00-DEFF\r
 361                 char c1 = (char)0xD800;\r
 362                 char c2 = (char)0xDBFF;\r
 363                 char c3 = (char)0xDC00;\r
 364                 char c4 = (char)0xDEFF;\r
 365                 Assert("Not surrogate", !Char.IsSurrogate(' '));\r
 366                 Assert("surrogate1", Char.IsSurrogate(c1));\r
 367                 Assert("surrogate2", Char.IsSurrogate(c2));\r
 368                 Assert("surrogate3", Char.IsSurrogate(c3));\r
 369                 Assert("surrogate4", Char.IsSurrogate(c4));\r
 370 \r
 371                 string s1 = " " + c1 + c2 + c3 + c4;\r
 372                 Assert("Not surrogate", !Char.IsSurrogate(s1, 0));\r
 373                 Assert("surrogate1-2", Char.IsSurrogate(s1, 1));\r
 374                 Assert("surrogate2-2", Char.IsSurrogate(s1, 2));\r
 375                 Assert("surrogate3-2", Char.IsSurrogate(s1, 3));\r
 376                 Assert("surrogate4-2", Char.IsSurrogate(s1, 4));\r
 377         }\r
 378 \r
 379         public void TestIsSymbol()\r
 380         {\r
 381                 char c1 = '+';\r
 382                 char c2 = '=';\r
 383                 Assert("Not symbol", !Char.IsSymbol(' '));\r
 384                 Assert("symbol", Char.IsSymbol(c1));\r
 385                 Assert("symbol", Char.IsSymbol(c2));\r
 386 \r
 387                 string s1 = " " + c1 + c2;\r
 388                 Assert("Not symbol", !Char.IsSymbol(s1, 0));\r
 389                 Assert("symbol", Char.IsSymbol(s1, 1));\r
 390                 Assert("symbol", Char.IsSymbol(s1, 2));\r
 391         }\r
 392 \r
 393         public void TestIsUpper()\r
 394         {\r
 395                 char c1 = 'A';\r
 396                 char c2 = 'Z';\r
 397                 Assert("Not upper", !Char.IsUpper('a'));\r
 398                 Assert("upper", Char.IsUpper(c1));\r
 399                 Assert("upper", Char.IsUpper(c2));\r
 400 \r
 401                 string s1 = "a" + c1 + c2;\r
 402                 Assert("Not upper", !Char.IsUpper(s1, 0));\r
 403                 Assert("upper", Char.IsUpper(s1, 1));\r
 404                 Assert("upper", Char.IsUpper(s1, 2));\r
 405         }\r
 406 \r
 407         public void TestIsWhiteSpace()\r
 408         {\r
 409                 char c1 = ' ';\r
 410                 char c2 = '\n';\r
 411                 char c3 = '\t';\r
 412 \r
 413                 Assert("Not whitespace", !Char.IsWhiteSpace('.'));\r
 414                 Assert("whitespace1", Char.IsWhiteSpace(c1));\r
 415                 Assert("whitespace2", Char.IsWhiteSpace(c2));\r
 416                 Assert("whitespace3", Char.IsWhiteSpace(c3));\r
 417 \r
 418                 string s1 = "." + c1 + c2 + c3;\r
 419                 Assert("Not whitespace", !Char.IsWhiteSpace(s1, 0));\r
 420                 Assert("whitespace1-2", Char.IsWhiteSpace(s1, 1));\r
 421                 Assert("whitespace2-2", Char.IsWhiteSpace(s1, 2));\r
 422                 Assert("whitespace3-2", Char.IsWhiteSpace(s1, 3));\r
 423         }\r
 424 \r
 425 \r
 426         public void TestParse()\r
 427         {\r
 428                 char c1 = 'a';\r
 429                 string s1 = "a";\r
 430                 Assert(c1.Equals(Char.Parse(s1)));\r
 431         }       \r
 432 \r
 433         public void TestToLower()\r
 434         {\r
 435                 char a1 = 'a';\r
 436                 char a2 = 'A';\r
 437                 char a3 = 'z';\r
 438                 char a4 = 'Z';\r
 439                 char a5 = ' ';\r
 440                 char a6 = '+';\r
 441                 char b1 = 'a';\r
 442                 char b2 = 'a';\r
 443                 char b3 = 'z';\r
 444                 char b4 = 'z';\r
 445                 char b5 = ' ';\r
 446                 char b6 = '+';\r
 447                 AssertEquals("char lowered", b1, Char.ToLower(a1));\r
 448                 AssertEquals("char lowered", b2, Char.ToLower(a2));\r
 449                 AssertEquals("char lowered", b3, Char.ToLower(a3));\r
 450                 AssertEquals("char lowered", b4, Char.ToLower(a4));\r
 451                 AssertEquals("char lowered", b5, Char.ToLower(a5));\r
 452                 AssertEquals("char lowered", b6, Char.ToLower(a6));\r
 453         }\r
 454 \r
 455         public void TestToUpper()\r
 456         {\r
 457                 char a1 = 'a';\r
 458                 char a2 = 'A';\r
 459                 char a3 = 'z';\r
 460                 char a4 = 'Z';\r
 461                 char a5 = ' ';\r
 462                 char a6 = '+';\r
 463                 char b1 = 'A';\r
 464                 char b2 = 'A';\r
 465                 char b3 = 'Z';\r
 466                 char b4 = 'Z';\r
 467                 char b5 = ' ';\r
 468                 char b6 = '+';\r
 469                 AssertEquals("char uppered", b1, Char.ToUpper(a1));\r
 470                 AssertEquals("char uppered", b2, Char.ToUpper(a2));\r
 471                 AssertEquals("char uppered", b3, Char.ToUpper(a3));\r
 472                 AssertEquals("char uppered", b4, Char.ToUpper(a4));\r
 473                 AssertEquals("char uppered", b5, Char.ToUpper(a5));\r
 474                 AssertEquals("char uppered", b6, Char.ToUpper(a6));\r
 475         }\r
 476 \r
 477 \r
 478         public void TestToString()\r
 479         {\r
 480                 char c1 = 'a';\r
 481                 string s1 = "a";\r
 482                 Assert(s1.Equals(c1.ToString()));\r
 483         }\r
 484 \r
 485         public void TestGetTypeCode()\r
 486         {\r
 487                 char c1 = 'a';\r
 488                 Assert(c1.GetTypeCode().Equals(TypeCode.Char));\r
 489         }\r
 490 \r
 491 }\r
 492 \r
 493 }\r