* gcc.dg/guality/guality.exp: Skip on AIX.

[official-gcc.git] / libgo / go / unicode / letter_test.go

// 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 (
        "flag"
        "fmt"
        "runtime"
        "sort"
        "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;<compat> 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;<compat> 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.
        "KkK",
        "kKK",
        "KKk",
        "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
                }
        }
}

// Running 'go test -calibrate' runs the calibration to find a plausible
// cutoff point for linear search of a range list vs. binary search.
// We create a fake table and then time how long it takes to do a
// sequence of searches within that table, for all possible inputs
// relative to the ranges (something before all, in each, between each, after all).
// This assumes that all possible runes are equally likely.
// In practice most runes are ASCII so this is a conservative estimate
// of an effective cutoff value. In practice we could probably set it higher
// than what this function recommends.

var calibrate = flag.Bool("calibrate", false, "compute crossover for linear vs. binary search")

func TestCalibrate(t *testing.T) {
        if !*calibrate {
                return
        }

        if runtime.GOARCH == "amd64" {
                fmt.Printf("warning: running calibration on %s\n", runtime.GOARCH)
        }

        // Find the point where binary search wins by more than 10%.
        // The 10% bias gives linear search an edge when they're close,
        // because on predominantly ASCII inputs linear search is even
        // better than our benchmarks measure.
        n := sort.Search(64, func(n int) bool {
                tab := fakeTable(n)
                blinear := func(b *testing.B) {
                        tab := tab
                        max := n*5 + 20
                        for i := 0; i < b.N; i++ {
                                for j := 0; j <= max; j++ {
                                        linear(tab, uint16(j))
                                }
                        }
                }
                bbinary := func(b *testing.B) {
                        tab := tab
                        max := n*5 + 20
                        for i := 0; i < b.N; i++ {
                                for j := 0; j <= max; j++ {
                                        binary(tab, uint16(j))
                                }
                        }
                }
                bmlinear := testing.Benchmark(blinear)
                bmbinary := testing.Benchmark(bbinary)
                fmt.Printf("n=%d: linear=%d binary=%d\n", n, bmlinear.NsPerOp(), bmbinary.NsPerOp())
                return bmlinear.NsPerOp()*100 > bmbinary.NsPerOp()*110
        })
        fmt.Printf("calibration: linear cutoff = %d\n", n)
}

func fakeTable(n int) []Range16 {
        var r16 []Range16
        for i := 0; i < n; i++ {
                r16 = append(r16, Range16{uint16(i*5 + 10), uint16(i*5 + 12), 1})
        }
        return r16
}

func linear(ranges []Range16, r uint16) bool {
        for i := range ranges {
                range_ := &ranges[i]
                if r < range_.Lo {
                        return false
                }
                if r <= range_.Hi {
                        return (r-range_.Lo)%range_.Stride == 0
                }
        }
        return false
}

func binary(ranges []Range16, r uint16) bool {
        // binary search over ranges
        lo := 0
        hi := len(ranges)
        for lo < hi {
                m := lo + (hi-lo)/2
                range_ := &ranges[m]
                if range_.Lo <= r && r <= range_.Hi {
                        return (r-range_.Lo)%range_.Stride == 0
                }
                if r < range_.Lo {
                        hi = m
                } else {
                        lo = m + 1
                }
        }
        return false
}

func TestLatinOffset(t *testing.T) {
        var maps = []map[string]*RangeTable{
                Categories,
                FoldCategory,
                FoldScript,
                Properties,
                Scripts,
        }
        for _, m := range maps {
                for name, tab := range m {
                        i := 0
                        for i < len(tab.R16) && tab.R16[i].Hi <= MaxLatin1 {
                                i++
                        }
                        if tab.LatinOffset != i {
                                t.Errorf("%s: LatinOffset=%d, want %d", name, tab.LatinOffset, i)
                        }
                }
        }
}