libgo/go/unicode/letter_test.go

   1 // Copyright 2009 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 package unicode_test
   6
   7 import (
   8         "testing"
   9         . "unicode"
  10 )
  11
  12 var upperTest = []int{
  13         0x41,
  14         0xc0,
  15         0xd8,
  16         0x100,
  17         0x139,
  18         0x14a,
  19         0x178,
  20         0x181,
  21         0x376,
  22         0x3cf,
  23         0x1f2a,
  24         0x2102,
  25         0x2c00,
  26         0x2c10,
  27         0x2c20,
  28         0xa650,
  29         0xa722,
  30         0xff3a,
  31         0x10400,
  32         0x1d400,
  33         0x1d7ca,
  34 }
  35
  36 var notupperTest = []int{
  37         0x40,
  38         0x5b,
  39         0x61,
  40         0x185,
  41         0x1b0,
  42         0x377,
  43         0x387,
  44         0x2150,
  45         0xffff,
  46         0x10000,
  47 }
  48
  49 var letterTest = []int{
  50         0x41,
  51         0x61,
  52         0xaa,
  53         0xba,
  54         0xc8,
  55         0xdb,
  56         0xf9,
  57         0x2ec,
  58         0x535,
  59         0x6e6,
  60         0x93d,
  61         0xa15,
  62         0xb99,
  63         0xdc0,
  64         0xedd,
  65         0x1000,
  66         0x1200,
  67         0x1312,
  68         0x1401,
  69         0x1885,
  70         0x2c00,
  71         0xa800,
  72         0xf900,
  73         0xfa30,
  74         0xffda,
  75         0xffdc,
  76         0x10000,
  77         0x10300,
  78         0x10400,
  79         0x20000,
  80         0x2f800,
  81         0x2fa1d,
  82 }
  83
  84 var notletterTest = []int{
  85         0x20,
  86         0x35,
  87         0x375,
  88         0x620,
  89         0x700,
  90         0xfffe,
  91         0x1ffff,
  92         0x10ffff,
  93 }
  94
  95 // Contains all the special cased Latin-1 chars.
  96 var spaceTest = []int{
  97         0x09,
  98         0x0a,
  99         0x0b,
 100         0x0c,
 101         0x0d,
 102         0x20,
 103         0x85,
 104         0xA0,
 105         0x2000,
 106         0x3000,
 107 }
 108
 109 type caseT struct {
 110         cas, in, out int
 111 }
 112
 113 var caseTest = []caseT{
 114         // errors
 115         {-1, '\n', 0xFFFD},
 116         {UpperCase, -1, -1},
 117         {UpperCase, 1 << 30, 1 << 30},
 118
 119         // ASCII (special-cased so test carefully)
 120         {UpperCase, '\n', '\n'},
 121         {UpperCase, 'a', 'A'},
 122         {UpperCase, 'A', 'A'},
 123         {UpperCase, '7', '7'},
 124         {LowerCase, '\n', '\n'},
 125         {LowerCase, 'a', 'a'},
 126         {LowerCase, 'A', 'a'},
 127         {LowerCase, '7', '7'},
 128         {TitleCase, '\n', '\n'},
 129         {TitleCase, 'a', 'A'},
 130         {TitleCase, 'A', 'A'},
 131         {TitleCase, '7', '7'},
 132
 133         // Latin-1: easy to read the tests!
 134         {UpperCase, 0x80, 0x80},
 135         {UpperCase, 'Å', 'Å'},
 136         {UpperCase, 'å', 'Å'},
 137         {LowerCase, 0x80, 0x80},
 138         {LowerCase, 'Å', 'å'},
 139         {LowerCase, 'å', 'å'},
 140         {TitleCase, 0x80, 0x80},
 141         {TitleCase, 'Å', 'Å'},
 142         {TitleCase, 'å', 'Å'},
 143
 144         // 0131;LATIN SMALL LETTER DOTLESS I;Ll;0;L;;;;;N;;;0049;;0049
 145         {UpperCase, 0x0131, 'I'},
 146         {LowerCase, 0x0131, 0x0131},
 147         {TitleCase, 0x0131, 'I'},
 148
 149         // 0133;LATIN SMALL LIGATURE IJ;Ll;0;L;<compat> 0069 006A;;;;N;LATIN SMALL LETTER I J;;0132;;0132
 150         {UpperCase, 0x0133, 0x0132},
 151         {LowerCase, 0x0133, 0x0133},
 152         {TitleCase, 0x0133, 0x0132},
 153
 154         // 212A;KELVIN SIGN;Lu;0;L;004B;;;;N;DEGREES KELVIN;;;006B;
 155         {UpperCase, 0x212A, 0x212A},
 156         {LowerCase, 0x212A, 'k'},
 157         {TitleCase, 0x212A, 0x212A},
 158
 159         // From an UpperLower sequence
 160         // A640;CYRILLIC CAPITAL LETTER ZEMLYA;Lu;0;L;;;;;N;;;;A641;
 161         {UpperCase, 0xA640, 0xA640},
 162         {LowerCase, 0xA640, 0xA641},
 163         {TitleCase, 0xA640, 0xA640},
 164         // A641;CYRILLIC SMALL LETTER ZEMLYA;Ll;0;L;;;;;N;;;A640;;A640
 165         {UpperCase, 0xA641, 0xA640},
 166         {LowerCase, 0xA641, 0xA641},
 167         {TitleCase, 0xA641, 0xA640},
 168         // A64E;CYRILLIC CAPITAL LETTER NEUTRAL YER;Lu;0;L;;;;;N;;;;A64F;
 169         {UpperCase, 0xA64E, 0xA64E},
 170         {LowerCase, 0xA64E, 0xA64F},
 171         {TitleCase, 0xA64E, 0xA64E},
 172         // A65F;CYRILLIC SMALL LETTER YN;Ll;0;L;;;;;N;;;A65E;;A65E
 173         {UpperCase, 0xA65F, 0xA65E},
 174         {LowerCase, 0xA65F, 0xA65F},
 175         {TitleCase, 0xA65F, 0xA65E},
 176
 177         // From another UpperLower sequence
 178         // 0139;LATIN CAPITAL LETTER L WITH ACUTE;Lu;0;L;004C 0301;;;;N;LATIN CAPITAL LETTER L ACUTE;;;013A;
 179         {UpperCase, 0x0139, 0x0139},
 180         {LowerCase, 0x0139, 0x013A},
 181         {TitleCase, 0x0139, 0x0139},
 182         // 013F;LATIN CAPITAL LETTER L WITH MIDDLE DOT;Lu;0;L;<compat> 004C 00B7;;;;N;;;;0140;
 183         {UpperCase, 0x013f, 0x013f},
 184         {LowerCase, 0x013f, 0x0140},
 185         {TitleCase, 0x013f, 0x013f},
 186         // 0148;LATIN SMALL LETTER N WITH CARON;Ll;0;L;006E 030C;;;;N;LATIN SMALL LETTER N HACEK;;0147;;0147
 187         {UpperCase, 0x0148, 0x0147},
 188         {LowerCase, 0x0148, 0x0148},
 189         {TitleCase, 0x0148, 0x0147},
 190
 191         // Last block in the 5.1.0 table
 192         // 10400;DESERET CAPITAL LETTER LONG I;Lu;0;L;;;;;N;;;;10428;
 193         {UpperCase, 0x10400, 0x10400},
 194         {LowerCase, 0x10400, 0x10428},
 195         {TitleCase, 0x10400, 0x10400},
 196         // 10427;DESERET CAPITAL LETTER EW;Lu;0;L;;;;;N;;;;1044F;
 197         {UpperCase, 0x10427, 0x10427},
 198         {LowerCase, 0x10427, 0x1044F},
 199         {TitleCase, 0x10427, 0x10427},
 200         // 10428;DESERET SMALL LETTER LONG I;Ll;0;L;;;;;N;;;10400;;10400
 201         {UpperCase, 0x10428, 0x10400},
 202         {LowerCase, 0x10428, 0x10428},
 203         {TitleCase, 0x10428, 0x10400},
 204         // 1044F;DESERET SMALL LETTER EW;Ll;0;L;;;;;N;;;10427;;10427
 205         {UpperCase, 0x1044F, 0x10427},
 206         {LowerCase, 0x1044F, 0x1044F},
 207         {TitleCase, 0x1044F, 0x10427},
 208
 209         // First one not in the 5.1.0 table
 210         // 10450;SHAVIAN LETTER PEEP;Lo;0;L;;;;;N;;;;;
 211         {UpperCase, 0x10450, 0x10450},
 212         {LowerCase, 0x10450, 0x10450},
 213         {TitleCase, 0x10450, 0x10450},
 214 }
 215
 216 func TestIsLetter(t *testing.T) {
 217         for _, r := range upperTest {
 218                 if !IsLetter(r) {
 219                         t.Errorf("IsLetter(U+%04X) = false, want true", r)
 220                 }
 221         }
 222         for _, r := range letterTest {
 223                 if !IsLetter(r) {
 224                         t.Errorf("IsLetter(U+%04X) = false, want true", r)
 225                 }
 226         }
 227         for _, r := range notletterTest {
 228                 if IsLetter(r) {
 229                         t.Errorf("IsLetter(U+%04X) = true, want false", r)
 230                 }
 231         }
 232 }
 233
 234 func TestIsUpper(t *testing.T) {
 235         for _, r := range upperTest {
 236                 if !IsUpper(r) {
 237                         t.Errorf("IsUpper(U+%04X) = false, want true", r)
 238                 }
 239         }
 240         for _, r := range notupperTest {
 241                 if IsUpper(r) {
 242                         t.Errorf("IsUpper(U+%04X) = true, want false", r)
 243                 }
 244         }
 245         for _, r := range notletterTest {
 246                 if IsUpper(r) {
 247                         t.Errorf("IsUpper(U+%04X) = true, want false", r)
 248                 }
 249         }
 250 }
 251
 252 func caseString(c int) string {
 253         switch c {
 254         case UpperCase:
 255                 return "UpperCase"
 256         case LowerCase:
 257                 return "LowerCase"
 258         case TitleCase:
 259                 return "TitleCase"
 260         }
 261         return "ErrorCase"
 262 }
 263
 264 func TestTo(t *testing.T) {
 265         for _, c := range caseTest {
 266                 r := To(c.cas, c.in)
 267                 if c.out != r {
 268                         t.Errorf("To(U+%04X, %s) = U+%04X want U+%04X", c.in, caseString(c.cas), r, c.out)
 269                 }
 270         }
 271 }
 272
 273 func TestToUpperCase(t *testing.T) {
 274         for _, c := range caseTest {
 275                 if c.cas != UpperCase {
 276                         continue
 277                 }
 278                 r := ToUpper(c.in)
 279                 if c.out != r {
 280                         t.Errorf("ToUpper(U+%04X) = U+%04X want U+%04X", c.in, r, c.out)
 281                 }
 282         }
 283 }
 284
 285 func TestToLowerCase(t *testing.T) {
 286         for _, c := range caseTest {
 287                 if c.cas != LowerCase {
 288                         continue
 289                 }
 290                 r := ToLower(c.in)
 291                 if c.out != r {
 292                         t.Errorf("ToLower(U+%04X) = U+%04X want U+%04X", c.in, r, c.out)
 293                 }
 294         }
 295 }
 296
 297 func TestToTitleCase(t *testing.T) {
 298         for _, c := range caseTest {
 299                 if c.cas != TitleCase {
 300                         continue
 301                 }
 302                 r := ToTitle(c.in)
 303                 if c.out != r {
 304                         t.Errorf("ToTitle(U+%04X) = U+%04X want U+%04X", c.in, r, c.out)
 305                 }
 306         }
 307 }
 308
 309 func TestIsSpace(t *testing.T) {
 310         for _, c := range spaceTest {
 311                 if !IsSpace(c) {
 312                         t.Errorf("IsSpace(U+%04X) = false; want true", c)
 313                 }
 314         }
 315         for _, c := range letterTest {
 316                 if IsSpace(c) {
 317                         t.Errorf("IsSpace(U+%04X) = true; want false", c)
 318                 }
 319         }
 320 }
 321
 322 // Check that the optimizations for IsLetter etc. agree with the tables.
 323 // We only need to check the Latin-1 range.
 324 func TestLetterOptimizations(t *testing.T) {
 325         for i := 0; i < 0x100; i++ {
 326                 if Is(Letter, i) != IsLetter(i) {
 327                         t.Errorf("IsLetter(U+%04X) disagrees with Is(Letter)", i)
 328                 }
 329                 if Is(Upper, i) != IsUpper(i) {
 330                         t.Errorf("IsUpper(U+%04X) disagrees with Is(Upper)", i)
 331                 }
 332                 if Is(Lower, i) != IsLower(i) {
 333                         t.Errorf("IsLower(U+%04X) disagrees with Is(Lower)", i)
 334                 }
 335                 if Is(Title, i) != IsTitle(i) {
 336                         t.Errorf("IsTitle(U+%04X) disagrees with Is(Title)", i)
 337                 }
 338                 if Is(White_Space, i) != IsSpace(i) {
 339                         t.Errorf("IsSpace(U+%04X) disagrees with Is(White_Space)", i)
 340                 }
 341                 if To(UpperCase, i) != ToUpper(i) {
 342                         t.Errorf("ToUpper(U+%04X) disagrees with To(Upper)", i)
 343                 }
 344                 if To(LowerCase, i) != ToLower(i) {
 345                         t.Errorf("ToLower(U+%04X) disagrees with To(Lower)", i)
 346                 }
 347                 if To(TitleCase, i) != ToTitle(i) {
 348                         t.Errorf("ToTitle(U+%04X) disagrees with To(Title)", i)
 349                 }
 350         }
 351 }
 352
 353 func TestTurkishCase(t *testing.T) {
 354         lower := []int("abcçdefgğhıijklmnoöprsştuüvyz")
 355         upper := []int("ABCÇDEFGĞHIİJKLMNOÖPRSŞTUÜVYZ")
 356         for i, l := range lower {
 357                 u := upper[i]
 358                 if TurkishCase.ToLower(l) != l {
 359                         t.Errorf("lower(U+%04X) is U+%04X not U+%04X", l, TurkishCase.ToLower(l), l)
 360                 }
 361                 if TurkishCase.ToUpper(u) != u {
 362                         t.Errorf("upper(U+%04X) is U+%04X not U+%04X", u, TurkishCase.ToUpper(u), u)
 363                 }
 364                 if TurkishCase.ToUpper(l) != u {
 365                         t.Errorf("upper(U+%04X) is U+%04X not U+%04X", l, TurkishCase.ToUpper(l), u)
 366                 }
 367                 if TurkishCase.ToLower(u) != l {
 368                         t.Errorf("lower(U+%04X) is U+%04X not U+%04X", u, TurkishCase.ToLower(l), l)
 369                 }
 370                 if TurkishCase.ToTitle(u) != u {
 371                         t.Errorf("title(U+%04X) is U+%04X not U+%04X", u, TurkishCase.ToTitle(u), u)
 372                 }
 373                 if TurkishCase.ToTitle(l) != u {
 374                         t.Errorf("title(U+%04X) is U+%04X not U+%04X", l, TurkishCase.ToTitle(l), u)
 375                 }
 376         }
 377 }