URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libgo/] [go/] [unicode/] [letter_test.go] - Blame information for rev 747

Details | Compare with Previous | View Log


// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
 
package unicode_test
 
import (
        "testing"
        . "unicode"
)
 
var upperTest = []rune{
        0x41,
        0xc0,
        0xd8,
        0x100,
        0x139,
        0x14a,
        0x178,
        0x181,
        0x376,
        0x3cf,
        0x1f2a,
        0x2102,
        0x2c00,
        0x2c10,
        0x2c20,
        0xa650,
        0xa722,
        0xff3a,
        0x10400,
        0x1d400,
        0x1d7ca,
}
 
var notupperTest = []rune{
        0x40,
        0x5b,
        0x61,
        0x185,
        0x1b0,
        0x377,
        0x387,
        0x2150,
        0xffff,
        0x10000,
}
 
var letterTest = []rune{
        0x41,
        0x61,
        0xaa,
        0xba,
        0xc8,
        0xdb,
        0xf9,
        0x2ec,
        0x535,
        0x620,
        0x6e6,
        0x93d,
        0xa15,
        0xb99,
        0xdc0,
        0xedd,
        0x1000,
        0x1200,
        0x1312,
        0x1401,
        0x1885,
        0x2c00,
        0xa800,
        0xf900,
        0xfa30,
        0xffda,
        0xffdc,
        0x10000,
        0x10300,
        0x10400,
        0x20000,
        0x2f800,
        0x2fa1d,
}
 
var notletterTest = []rune{
        0x20,
        0x35,
        0x375,
        0x619,
        0x700,
        0xfffe,
        0x1ffff,
        0x10ffff,
}
 
// Contains all the special cased Latin-1 chars.
var spaceTest = []rune{
        0x09,
        0x0a,
        0x0b,
        0x0c,
        0x0d,
        0x20,
        0x85,
        0xA0,
        0x2000,
        0x3000,
}
 
type caseT struct {
        cas     int
        in, out rune
}
 
var caseTest = []caseT{
        // errors
        {-1, '\n', 0xFFFD},
        {UpperCase, -1, -1},
        {UpperCase, 1 << 30, 1 << 30},
 
        // ASCII (special-cased so test carefully)
        {UpperCase, '\n', '\n'},
        {UpperCase, 'a', 'A'},
        {UpperCase, 'A', 'A'},
        {UpperCase, '7', '7'},
        {LowerCase, '\n', '\n'},
        {LowerCase, 'a', 'a'},
        {LowerCase, 'A', 'a'},
        {LowerCase, '7', '7'},
        {TitleCase, '\n', '\n'},
        {TitleCase, 'a', 'A'},
        {TitleCase, 'A', 'A'},
        {TitleCase, '7', '7'},
 
        // Latin-1: easy to read the tests!
        {UpperCase, 0x80, 0x80},
        {UpperCase, 'Å', 'Å'},
        {UpperCase, 'å', 'Å'},
        {LowerCase, 0x80, 0x80},
        {LowerCase, 'Å', 'å'},
        {LowerCase, 'å', 'å'},
        {TitleCase, 0x80, 0x80},
        {TitleCase, 'Å', 'Å'},
        {TitleCase, 'å', 'Å'},
 
        // 0131;LATIN SMALL LETTER DOTLESS I;Ll;0;L;;;;;N;;;0049;;0049
        {UpperCase, 0x0131, 'I'},
        {LowerCase, 0x0131, 0x0131},
        {TitleCase, 0x0131, 'I'},
 
        // 0133;LATIN SMALL LIGATURE IJ;Ll;0;L; 0069 006A;;;;N;LATIN SMALL LETTER I J;;0132;;0132
        {UpperCase, 0x0133, 0x0132},
        {LowerCase, 0x0133, 0x0133},
        {TitleCase, 0x0133, 0x0132},
 
        // 212A;KELVIN SIGN;Lu;0;L;004B;;;;N;DEGREES KELVIN;;;006B;
        {UpperCase, 0x212A, 0x212A},
        {LowerCase, 0x212A, 'k'},
        {TitleCase, 0x212A, 0x212A},
 
        // From an UpperLower sequence
        // A640;CYRILLIC CAPITAL LETTER ZEMLYA;Lu;0;L;;;;;N;;;;A641;
        {UpperCase, 0xA640, 0xA640},
        {LowerCase, 0xA640, 0xA641},
        {TitleCase, 0xA640, 0xA640},
        // A641;CYRILLIC SMALL LETTER ZEMLYA;Ll;0;L;;;;;N;;;A640;;A640
        {UpperCase, 0xA641, 0xA640},
        {LowerCase, 0xA641, 0xA641},
        {TitleCase, 0xA641, 0xA640},
        // A64E;CYRILLIC CAPITAL LETTER NEUTRAL YER;Lu;0;L;;;;;N;;;;A64F;
        {UpperCase, 0xA64E, 0xA64E},
        {LowerCase, 0xA64E, 0xA64F},
        {TitleCase, 0xA64E, 0xA64E},
        // A65F;CYRILLIC SMALL LETTER YN;Ll;0;L;;;;;N;;;A65E;;A65E
        {UpperCase, 0xA65F, 0xA65E},
        {LowerCase, 0xA65F, 0xA65F},
        {TitleCase, 0xA65F, 0xA65E},
 
        // From another UpperLower sequence
        // 0139;LATIN CAPITAL LETTER L WITH ACUTE;Lu;0;L;004C 0301;;;;N;LATIN CAPITAL LETTER L ACUTE;;;013A;
        {UpperCase, 0x0139, 0x0139},
        {LowerCase, 0x0139, 0x013A},
        {TitleCase, 0x0139, 0x0139},
        // 013F;LATIN CAPITAL LETTER L WITH MIDDLE DOT;Lu;0;L; 004C 00B7;;;;N;;;;0140;
        {UpperCase, 0x013f, 0x013f},
        {LowerCase, 0x013f, 0x0140},
        {TitleCase, 0x013f, 0x013f},
        // 0148;LATIN SMALL LETTER N WITH CARON;Ll;0;L;006E 030C;;;;N;LATIN SMALL LETTER N HACEK;;0147;;0147
        {UpperCase, 0x0148, 0x0147},
        {LowerCase, 0x0148, 0x0148},
        {TitleCase, 0x0148, 0x0147},
 
        // Last block in the 5.1.0 table
        // 10400;DESERET CAPITAL LETTER LONG I;Lu;0;L;;;;;N;;;;10428;
        {UpperCase, 0x10400, 0x10400},
        {LowerCase, 0x10400, 0x10428},
        {TitleCase, 0x10400, 0x10400},
        // 10427;DESERET CAPITAL LETTER EW;Lu;0;L;;;;;N;;;;1044F;
        {UpperCase, 0x10427, 0x10427},
        {LowerCase, 0x10427, 0x1044F},
        {TitleCase, 0x10427, 0x10427},
        // 10428;DESERET SMALL LETTER LONG I;Ll;0;L;;;;;N;;;10400;;10400
        {UpperCase, 0x10428, 0x10400},
        {LowerCase, 0x10428, 0x10428},
        {TitleCase, 0x10428, 0x10400},
        // 1044F;DESERET SMALL LETTER EW;Ll;0;L;;;;;N;;;10427;;10427
        {UpperCase, 0x1044F, 0x10427},
        {LowerCase, 0x1044F, 0x1044F},
        {TitleCase, 0x1044F, 0x10427},
 
        // First one not in the 5.1.0 table
        // 10450;SHAVIAN LETTER PEEP;Lo;0;L;;;;;N;;;;;
        {UpperCase, 0x10450, 0x10450},
        {LowerCase, 0x10450, 0x10450},
        {TitleCase, 0x10450, 0x10450},
 
        // Non-letters with case.
        {LowerCase, 0x2161, 0x2171},
        {UpperCase, 0x0345, 0x0399},
}
 
func TestIsLetter(t *testing.T) {
        for _, r := range upperTest {
                if !IsLetter(r) {
                        t.Errorf("IsLetter(U+%04X) = false, want true", r)
                }
        }
        for _, r := range letterTest {
                if !IsLetter(r) {
                        t.Errorf("IsLetter(U+%04X) = false, want true", r)
                }
        }
        for _, r := range notletterTest {
                if IsLetter(r) {
                        t.Errorf("IsLetter(U+%04X) = true, want false", r)
                }
        }
}
 
func TestIsUpper(t *testing.T) {
        for _, r := range upperTest {
                if !IsUpper(r) {
                        t.Errorf("IsUpper(U+%04X) = false, want true", r)
                }
        }
        for _, r := range notupperTest {
                if IsUpper(r) {
                        t.Errorf("IsUpper(U+%04X) = true, want false", r)
                }
        }
        for _, r := range notletterTest {
                if IsUpper(r) {
                        t.Errorf("IsUpper(U+%04X) = true, want false", r)
                }
        }
}
 
func caseString(c int) string {
        switch c {
        case UpperCase:
                return "UpperCase"
        case LowerCase:
                return "LowerCase"
        case TitleCase:
                return "TitleCase"
        }
        return "ErrorCase"
}
 
func TestTo(t *testing.T) {
        for _, c := range caseTest {
                r := To(c.cas, c.in)
                if c.out != r {
                        t.Errorf("To(U+%04X, %s) = U+%04X want U+%04X", c.in, caseString(c.cas), r, c.out)
                }
        }
}
 
func TestToUpperCase(t *testing.T) {
        for _, c := range caseTest {
                if c.cas != UpperCase {
                        continue
                }
                r := ToUpper(c.in)
                if c.out != r {
                        t.Errorf("ToUpper(U+%04X) = U+%04X want U+%04X", c.in, r, c.out)
                }
        }
}
 
func TestToLowerCase(t *testing.T) {
        for _, c := range caseTest {
                if c.cas != LowerCase {
                        continue
                }
                r := ToLower(c.in)
                if c.out != r {
                        t.Errorf("ToLower(U+%04X) = U+%04X want U+%04X", c.in, r, c.out)
                }
        }
}
 
func TestToTitleCase(t *testing.T) {
        for _, c := range caseTest {
                if c.cas != TitleCase {
                        continue
                }
                r := ToTitle(c.in)
                if c.out != r {
                        t.Errorf("ToTitle(U+%04X) = U+%04X want U+%04X", c.in, r, c.out)
                }
        }
}
 
func TestIsSpace(t *testing.T) {
        for _, c := range spaceTest {
                if !IsSpace(c) {
                        t.Errorf("IsSpace(U+%04X) = false; want true", c)
                }
        }
        for _, c := range letterTest {
                if IsSpace(c) {
                        t.Errorf("IsSpace(U+%04X) = true; want false", c)
                }
        }
}
 
// Check that the optimizations for IsLetter etc. agree with the tables.
// We only need to check the Latin-1 range.
func TestLetterOptimizations(t *testing.T) {
        for i := rune(0); i <= MaxLatin1; i++ {
                if Is(Letter, i) != IsLetter(i) {
                        t.Errorf("IsLetter(U+%04X) disagrees with Is(Letter)", i)
                }
                if Is(Upper, i) != IsUpper(i) {
                        t.Errorf("IsUpper(U+%04X) disagrees with Is(Upper)", i)
                }
                if Is(Lower, i) != IsLower(i) {
                        t.Errorf("IsLower(U+%04X) disagrees with Is(Lower)", i)
                }
                if Is(Title, i) != IsTitle(i) {
                        t.Errorf("IsTitle(U+%04X) disagrees with Is(Title)", i)
                }
                if Is(White_Space, i) != IsSpace(i) {
                        t.Errorf("IsSpace(U+%04X) disagrees with Is(White_Space)", i)
                }
                if To(UpperCase, i) != ToUpper(i) {
                        t.Errorf("ToUpper(U+%04X) disagrees with To(Upper)", i)
                }
                if To(LowerCase, i) != ToLower(i) {
                        t.Errorf("ToLower(U+%04X) disagrees with To(Lower)", i)
                }
                if To(TitleCase, i) != ToTitle(i) {
                        t.Errorf("ToTitle(U+%04X) disagrees with To(Title)", i)
                }
        }
}
 
func TestTurkishCase(t *testing.T) {
        lower := []rune("abcçdefgğhıijklmnoöprsştuüvyz")
        upper := []rune("ABCÇDEFGĞHIİJKLMNOÖPRSŞTUÜVYZ")
        for i, l := range lower {
                u := upper[i]
                if TurkishCase.ToLower(l) != l {
                        t.Errorf("lower(U+%04X) is U+%04X not U+%04X", l, TurkishCase.ToLower(l), l)
                }
                if TurkishCase.ToUpper(u) != u {
                        t.Errorf("upper(U+%04X) is U+%04X not U+%04X", u, TurkishCase.ToUpper(u), u)
                }
                if TurkishCase.ToUpper(l) != u {
                        t.Errorf("upper(U+%04X) is U+%04X not U+%04X", l, TurkishCase.ToUpper(l), u)
                }
                if TurkishCase.ToLower(u) != l {
                        t.Errorf("lower(U+%04X) is U+%04X not U+%04X", u, TurkishCase.ToLower(l), l)
                }
                if TurkishCase.ToTitle(u) != u {
                        t.Errorf("title(U+%04X) is U+%04X not U+%04X", u, TurkishCase.ToTitle(u), u)
                }
                if TurkishCase.ToTitle(l) != u {
                        t.Errorf("title(U+%04X) is U+%04X not U+%04X", l, TurkishCase.ToTitle(l), u)
                }
        }
}
 
var simpleFoldTests = []string{
        // SimpleFold could order its returned slices in any order it wants,
        // but we know it orders them in increasing order starting at in
        // and looping around from MaxRune to 0.
 
        // Easy cases.
        "Aa",
        "aA",
        "δΔ",
        "Δδ",
 
        // ASCII special cases.
        "KkK",
        "kKK",
        "KKk",
        "Ssſ",
        "sſS",
        "ſSs",
 
        // Non-ASCII special cases.
        "ρϱΡ",
        "ϱΡρ",
        "Ρρϱ",
        "ͅΙιι",
        "Ιιιͅ",
        "ιιͅΙ",
        "ιͅΙι",
 
        // Extra special cases: has lower/upper but no case fold.
        "İ",
        "ı",
}
 
func TestSimpleFold(t *testing.T) {
        for _, tt := range simpleFoldTests {
                cycle := []rune(tt)
                r := cycle[len(cycle)-1]
                for _, out := range cycle {
                        if r := SimpleFold(r); r != out {
                                t.Errorf("SimpleFold(%#U) = %#U, want %#U", r, r, out)
                        }
                        r = out
                }
        }
}

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libgo/] [go/] [unicode/] [letter_test.go] - Blame information for rev 747

Line No.	Rev	Author	Line
1	747	jeremybenn	`// 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 = []rune{`
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 = []rune{`
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 = []rune{`
50			`0x41,`
51			`0x61,`
52			`0xaa,`
53			`0xba,`
54			`0xc8,`
55			`0xdb,`
56			`0xf9,`
57			`0x2ec,`
58			`0x535,`
59			`0x620,`
60			`0x6e6,`
61			`0x93d,`
62			`0xa15,`
63			`0xb99,`
64			`0xdc0,`
65			`0xedd,`
66			`0x1000,`
67			`0x1200,`
68			`0x1312,`
69			`0x1401,`
70			`0x1885,`
71			`0x2c00,`
72			`0xa800,`
73			`0xf900,`
74			`0xfa30,`
75			`0xffda,`
76			`0xffdc,`
77			`0x10000,`
78			`0x10300,`
79			`0x10400,`
80			`0x20000,`
81			`0x2f800,`
82			`0x2fa1d,`
83			`}`
84
85			`var notletterTest = []rune{`
86			`0x20,`
87			`0x35,`
88			`0x375,`
89			`0x619,`
90			`0x700,`
91			`0xfffe,`
92			`0x1ffff,`
93			`0x10ffff,`
94			`}`
95
96			`// Contains all the special cased Latin-1 chars.`
97			`var spaceTest = []rune{`
98			`0x09,`
99			`0x0a,`
100			`0x0b,`
101			`0x0c,`
102			`0x0d,`
103			`0x20,`
104			`0x85,`
105			`0xA0,`
106			`0x2000,`
107			`0x3000,`
108			`}`
109
110			`type caseT struct {`
111			`cas int`
112			`in, out rune`
113			`}`
114
115			`var caseTest = []caseT{`
116			`// errors`
117			`{-1, '\n', 0xFFFD},`
118			`{UpperCase, -1, -1},`
119			`{UpperCase, 1 << 30, 1 << 30},`
120
121			`// ASCII (special-cased so test carefully)`
122			`{UpperCase, '\n', '\n'},`
123			`{UpperCase, 'a', 'A'},`
124			`{UpperCase, 'A', 'A'},`
125			`{UpperCase, '7', '7'},`
126			`{LowerCase, '\n', '\n'},`
127			`{LowerCase, 'a', 'a'},`
128			`{LowerCase, 'A', 'a'},`
129			`{LowerCase, '7', '7'},`
130			`{TitleCase, '\n', '\n'},`
131			`{TitleCase, 'a', 'A'},`
132			`{TitleCase, 'A', 'A'},`
133			`{TitleCase, '7', '7'},`
134
135			`// Latin-1: easy to read the tests!`
136			`{UpperCase, 0x80, 0x80},`
137			`{UpperCase, 'Å', 'Å'},`
138			`{UpperCase, 'å', 'Å'},`
139			`{LowerCase, 0x80, 0x80},`
140			`{LowerCase, 'Å', 'å'},`
141			`{LowerCase, 'å', 'å'},`
142			`{TitleCase, 0x80, 0x80},`
143			`{TitleCase, 'Å', 'Å'},`
144			`{TitleCase, 'å', 'Å'},`
145
146			`// 0131;LATIN SMALL LETTER DOTLESS I;Ll;0;L;;;;;N;;;0049;;0049`
147			`{UpperCase, 0x0131, 'I'},`
148			`{LowerCase, 0x0131, 0x0131},`
149			`{TitleCase, 0x0131, 'I'},`
150
151			`// 0133;LATIN SMALL LIGATURE IJ;Ll;0;L; 0069 006A;;;;N;LATIN SMALL LETTER I J;;0132;;0132`
152			`{UpperCase, 0x0133, 0x0132},`
153			`{LowerCase, 0x0133, 0x0133},`
154			`{TitleCase, 0x0133, 0x0132},`
155
156			`// 212A;KELVIN SIGN;Lu;0;L;004B;;;;N;DEGREES KELVIN;;;006B;`
157			`{UpperCase, 0x212A, 0x212A},`
158			`{LowerCase, 0x212A, 'k'},`
159			`{TitleCase, 0x212A, 0x212A},`
160
161			`// From an UpperLower sequence`
162			`// A640;CYRILLIC CAPITAL LETTER ZEMLYA;Lu;0;L;;;;;N;;;;A641;`
163			`{UpperCase, 0xA640, 0xA640},`
164			`{LowerCase, 0xA640, 0xA641},`
165			`{TitleCase, 0xA640, 0xA640},`
166			`// A641;CYRILLIC SMALL LETTER ZEMLYA;Ll;0;L;;;;;N;;;A640;;A640`
167			`{UpperCase, 0xA641, 0xA640},`
168			`{LowerCase, 0xA641, 0xA641},`
169			`{TitleCase, 0xA641, 0xA640},`
170			`// A64E;CYRILLIC CAPITAL LETTER NEUTRAL YER;Lu;0;L;;;;;N;;;;A64F;`
171			`{UpperCase, 0xA64E, 0xA64E},`
172			`{LowerCase, 0xA64E, 0xA64F},`
173			`{TitleCase, 0xA64E, 0xA64E},`
174			`// A65F;CYRILLIC SMALL LETTER YN;Ll;0;L;;;;;N;;;A65E;;A65E`
175			`{UpperCase, 0xA65F, 0xA65E},`
176			`{LowerCase, 0xA65F, 0xA65F},`
177			`{TitleCase, 0xA65F, 0xA65E},`
178
179			`// From another UpperLower sequence`
180			`// 0139;LATIN CAPITAL LETTER L WITH ACUTE;Lu;0;L;004C 0301;;;;N;LATIN CAPITAL LETTER L ACUTE;;;013A;`
181			`{UpperCase, 0x0139, 0x0139},`
182			`{LowerCase, 0x0139, 0x013A},`
183			`{TitleCase, 0x0139, 0x0139},`
184			`// 013F;LATIN CAPITAL LETTER L WITH MIDDLE DOT;Lu;0;L; 004C 00B7;;;;N;;;;0140;`
185			`{UpperCase, 0x013f, 0x013f},`
186			`{LowerCase, 0x013f, 0x0140},`
187			`{TitleCase, 0x013f, 0x013f},`
188			`// 0148;LATIN SMALL LETTER N WITH CARON;Ll;0;L;006E 030C;;;;N;LATIN SMALL LETTER N HACEK;;0147;;0147`
189			`{UpperCase, 0x0148, 0x0147},`
190			`{LowerCase, 0x0148, 0x0148},`
191			`{TitleCase, 0x0148, 0x0147},`
192
193			`// Last block in the 5.1.0 table`
194			`// 10400;DESERET CAPITAL LETTER LONG I;Lu;0;L;;;;;N;;;;10428;`
195			`{UpperCase, 0x10400, 0x10400},`
196			`{LowerCase, 0x10400, 0x10428},`
197			`{TitleCase, 0x10400, 0x10400},`
198			`// 10427;DESERET CAPITAL LETTER EW;Lu;0;L;;;;;N;;;;1044F;`
199			`{UpperCase, 0x10427, 0x10427},`
200			`{LowerCase, 0x10427, 0x1044F},`
201			`{TitleCase, 0x10427, 0x10427},`
202			`// 10428;DESERET SMALL LETTER LONG I;Ll;0;L;;;;;N;;;10400;;10400`
203			`{UpperCase, 0x10428, 0x10400},`
204			`{LowerCase, 0x10428, 0x10428},`
205			`{TitleCase, 0x10428, 0x10400},`
206			`// 1044F;DESERET SMALL LETTER EW;Ll;0;L;;;;;N;;;10427;;10427`
207			`{UpperCase, 0x1044F, 0x10427},`
208			`{LowerCase, 0x1044F, 0x1044F},`
209			`{TitleCase, 0x1044F, 0x10427},`
210
211			`// First one not in the 5.1.0 table`
212			`// 10450;SHAVIAN LETTER PEEP;Lo;0;L;;;;;N;;;;;`
213			`{UpperCase, 0x10450, 0x10450},`
214			`{LowerCase, 0x10450, 0x10450},`
215			`{TitleCase, 0x10450, 0x10450},`
216
217			`// Non-letters with case.`
218			`{LowerCase, 0x2161, 0x2171},`
219			`{UpperCase, 0x0345, 0x0399},`
220			`}`
221
222			`func TestIsLetter(t *testing.T) {`
223			`for _, r := range upperTest {`
224			`if !IsLetter(r) {`
225			`t.Errorf("IsLetter(U+%04X) = false, want true", r)`
226			`}`
227			`}`
228			`for _, r := range letterTest {`
229			`if !IsLetter(r) {`
230			`t.Errorf("IsLetter(U+%04X) = false, want true", r)`
231			`}`
232			`}`
233			`for _, r := range notletterTest {`
234			`if IsLetter(r) {`
235			`t.Errorf("IsLetter(U+%04X) = true, want false", r)`
236			`}`
237			`}`
238			`}`
239
240			`func TestIsUpper(t *testing.T) {`
241			`for _, r := range upperTest {`
242			`if !IsUpper(r) {`
243			`t.Errorf("IsUpper(U+%04X) = false, want true", r)`
244			`}`
245			`}`
246			`for _, r := range notupperTest {`
247			`if IsUpper(r) {`
248			`t.Errorf("IsUpper(U+%04X) = true, want false", r)`
249			`}`
250			`}`
251			`for _, r := range notletterTest {`
252			`if IsUpper(r) {`
253			`t.Errorf("IsUpper(U+%04X) = true, want false", r)`
254			`}`
255			`}`
256			`}`
257
258			`func caseString(c int) string {`
259			`switch c {`
260			`case UpperCase:`
261			`return "UpperCase"`
262			`case LowerCase:`
263			`return "LowerCase"`
264			`case TitleCase:`
265			`return "TitleCase"`
266			`}`
267			`return "ErrorCase"`
268			`}`
269
270			`func TestTo(t *testing.T) {`
271			`for _, c := range caseTest {`
272			`r := To(c.cas, c.in)`
273			`if c.out != r {`
274			`t.Errorf("To(U+%04X, %s) = U+%04X want U+%04X", c.in, caseString(c.cas), r, c.out)`
275			`}`
276			`}`
277			`}`
278
279			`func TestToUpperCase(t *testing.T) {`
280			`for _, c := range caseTest {`
281			`if c.cas != UpperCase {`
282			`continue`
283			`}`
284			`r := ToUpper(c.in)`
285			`if c.out != r {`
286			`t.Errorf("ToUpper(U+%04X) = U+%04X want U+%04X", c.in, r, c.out)`
287			`}`
288			`}`
289			`}`
290
291			`func TestToLowerCase(t *testing.T) {`
292			`for _, c := range caseTest {`
293			`if c.cas != LowerCase {`
294			`continue`
295			`}`
296			`r := ToLower(c.in)`
297			`if c.out != r {`
298			`t.Errorf("ToLower(U+%04X) = U+%04X want U+%04X", c.in, r, c.out)`
299			`}`
300			`}`
301			`}`
302
303			`func TestToTitleCase(t *testing.T) {`
304			`for _, c := range caseTest {`
305			`if c.cas != TitleCase {`
306			`continue`
307			`}`
308			`r := ToTitle(c.in)`
309			`if c.out != r {`
310			`t.Errorf("ToTitle(U+%04X) = U+%04X want U+%04X", c.in, r, c.out)`
311			`}`
312			`}`
313			`}`
314
315			`func TestIsSpace(t *testing.T) {`
316			`for _, c := range spaceTest {`
317			`if !IsSpace(c) {`
318			`t.Errorf("IsSpace(U+%04X) = false; want true", c)`
319			`}`
320			`}`
321			`for _, c := range letterTest {`
322			`if IsSpace(c) {`
323			`t.Errorf("IsSpace(U+%04X) = true; want false", c)`
324			`}`
325			`}`
326			`}`
327
328			`// Check that the optimizations for IsLetter etc. agree with the tables.`
329			`// We only need to check the Latin-1 range.`
330			`func TestLetterOptimizations(t *testing.T) {`
331			`for i := rune(0); i <= MaxLatin1; i++ {`
332			`if Is(Letter, i) != IsLetter(i) {`
333			`t.Errorf("IsLetter(U+%04X) disagrees with Is(Letter)", i)`
334			`}`
335			`if Is(Upper, i) != IsUpper(i) {`
336			`t.Errorf("IsUpper(U+%04X) disagrees with Is(Upper)", i)`
337			`}`
338			`if Is(Lower, i) != IsLower(i) {`
339			`t.Errorf("IsLower(U+%04X) disagrees with Is(Lower)", i)`
340			`}`
341			`if Is(Title, i) != IsTitle(i) {`
342			`t.Errorf("IsTitle(U+%04X) disagrees with Is(Title)", i)`
343			`}`
344			`if Is(White_Space, i) != IsSpace(i) {`
345			`t.Errorf("IsSpace(U+%04X) disagrees with Is(White_Space)", i)`
346			`}`
347			`if To(UpperCase, i) != ToUpper(i) {`
348			`t.Errorf("ToUpper(U+%04X) disagrees with To(Upper)", i)`
349			`}`
350			`if To(LowerCase, i) != ToLower(i) {`
351			`t.Errorf("ToLower(U+%04X) disagrees with To(Lower)", i)`
352			`}`
353			`if To(TitleCase, i) != ToTitle(i) {`
354			`t.Errorf("ToTitle(U+%04X) disagrees with To(Title)", i)`
355			`}`
356			`}`
357			`}`
358
359			`func TestTurkishCase(t *testing.T) {`
360			`lower := []rune("abcçdefgğhıijklmnoöprsştuüvyz")`
361			`upper := []rune("ABCÇDEFGĞHIİJKLMNOÖPRSŞTUÜVYZ")`
362			`for i, l := range lower {`
363			`u := upper[i]`
364			`if TurkishCase.ToLower(l) != l {`
365			`t.Errorf("lower(U+%04X) is U+%04X not U+%04X", l, TurkishCase.ToLower(l), l)`
366			`}`
367			`if TurkishCase.ToUpper(u) != u {`
368			`t.Errorf("upper(U+%04X) is U+%04X not U+%04X", u, TurkishCase.ToUpper(u), u)`
369			`}`
370			`if TurkishCase.ToUpper(l) != u {`
371			`t.Errorf("upper(U+%04X) is U+%04X not U+%04X", l, TurkishCase.ToUpper(l), u)`
372			`}`
373			`if TurkishCase.ToLower(u) != l {`
374			`t.Errorf("lower(U+%04X) is U+%04X not U+%04X", u, TurkishCase.ToLower(l), l)`
375			`}`
376			`if TurkishCase.ToTitle(u) != u {`
377			`t.Errorf("title(U+%04X) is U+%04X not U+%04X", u, TurkishCase.ToTitle(u), u)`
378			`}`
379			`if TurkishCase.ToTitle(l) != u {`
380			`t.Errorf("title(U+%04X) is U+%04X not U+%04X", l, TurkishCase.ToTitle(l), u)`
381			`}`
382			`}`
383			`}`
384
385			`var simpleFoldTests = []string{`
386			`// SimpleFold could order its returned slices in any order it wants,`
387			`// but we know it orders them in increasing order starting at in`
388			`// and looping around from MaxRune to 0.`
389
390			`// Easy cases.`
391			`"Aa",`
392			`"aA",`
393			`"δΔ",`
394			`"Δδ",`
395
396			`// ASCII special cases.`
397			`"KkK",`
398			`"kKK",`
399			`"KKk",`
400			`"Ssſ",`
401			`"sſS",`
402			`"ſSs",`
403
404			`// Non-ASCII special cases.`
405			`"ρϱΡ",`
406			`"ϱΡρ",`
407			`"Ρρϱ",`
408			`"ͅΙιι",`
409			`"Ιιιͅ",`
410			`"ιιͅΙ",`
411			`"ιͅΙι",`
412
413			`// Extra special cases: has lower/upper but no case fold.`
414			`"İ",`
415			`"ı",`
416			`}`
417
418			`func TestSimpleFold(t *testing.T) {`
419			`for _, tt := range simpleFoldTests {`
420			`cycle := []rune(tt)`
421			`r := cycle[len(cycle)-1]`
422			`for _, out := range cycle {`
423			`if r := SimpleFold(r); r != out {`
424			`t.Errorf("SimpleFold(%#U) = %#U, want %#U", r, r, out)`
425			`}`
426			`r = out`
427			`}`
428			`}`
429			`}`