+++ /dev/null
-// Copyright 2013 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 language
-
-import (
- "testing"
-
- "golang.org/x/text/internal/tag"
-)
-
-func b(s string) []byte {
- return []byte(s)
-}
-
-func TestLangID(t *testing.T) {
- tests := []struct {
- id, bcp47, iso3, norm string
- err error
- }{
- {id: "", bcp47: "und", iso3: "und", err: errSyntax},
- {id: " ", bcp47: "und", iso3: "und", err: errSyntax},
- {id: " ", bcp47: "und", iso3: "und", err: errSyntax},
- {id: " ", bcp47: "und", iso3: "und", err: errSyntax},
- {id: "xxx", bcp47: "und", iso3: "und", err: mkErrInvalid([]byte("xxx"))},
- {id: "und", bcp47: "und", iso3: "und"},
- {id: "aju", bcp47: "aju", iso3: "aju", norm: "jrb"},
- {id: "jrb", bcp47: "jrb", iso3: "jrb"},
- {id: "es", bcp47: "es", iso3: "spa"},
- {id: "spa", bcp47: "es", iso3: "spa"},
- {id: "ji", bcp47: "ji", iso3: "yid-", norm: "yi"},
- {id: "jw", bcp47: "jw", iso3: "jav-", norm: "jv"},
- {id: "ar", bcp47: "ar", iso3: "ara"},
- {id: "kw", bcp47: "kw", iso3: "cor"},
- {id: "arb", bcp47: "arb", iso3: "arb", norm: "ar"},
- {id: "ar", bcp47: "ar", iso3: "ara"},
- {id: "kur", bcp47: "ku", iso3: "kur"},
- {id: "nl", bcp47: "nl", iso3: "nld"},
- {id: "NL", bcp47: "nl", iso3: "nld"},
- {id: "gsw", bcp47: "gsw", iso3: "gsw"},
- {id: "gSW", bcp47: "gsw", iso3: "gsw"},
- {id: "und", bcp47: "und", iso3: "und"},
- {id: "sh", bcp47: "sh", iso3: "hbs", norm: "sr"},
- {id: "hbs", bcp47: "sh", iso3: "hbs", norm: "sr"},
- {id: "no", bcp47: "no", iso3: "nor", norm: "no"},
- {id: "nor", bcp47: "no", iso3: "nor", norm: "no"},
- {id: "cmn", bcp47: "cmn", iso3: "cmn", norm: "zh"},
- }
- for i, tt := range tests {
- want, err := getLangID(b(tt.id))
- if err != tt.err {
- t.Errorf("%d:err(%s): found %q; want %q", i, tt.id, err, tt.err)
- }
- if err != nil {
- continue
- }
- if id, _ := getLangISO2(b(tt.bcp47)); len(tt.bcp47) == 2 && want != id {
- t.Errorf("%d:getISO2(%s): found %v; want %v", i, tt.bcp47, id, want)
- }
- if len(tt.iso3) == 3 {
- if id, _ := getLangISO3(b(tt.iso3)); want != id {
- t.Errorf("%d:getISO3(%s): found %q; want %q", i, tt.iso3, id, want)
- }
- if id, _ := getLangID(b(tt.iso3)); want != id {
- t.Errorf("%d:getID3(%s): found %v; want %v", i, tt.iso3, id, want)
- }
- }
- norm := want
- if tt.norm != "" {
- norm, _ = getLangID(b(tt.norm))
- }
- id, _ := normLang(want)
- if id != norm {
- t.Errorf("%d:norm(%s): found %v; want %v", i, tt.id, id, norm)
- }
- if id := want.String(); tt.bcp47 != id {
- t.Errorf("%d:String(): found %s; want %s", i, id, tt.bcp47)
- }
- if id := want.ISO3(); tt.iso3[:3] != id {
- t.Errorf("%d:iso3(): found %s; want %s", i, id, tt.iso3[:3])
- }
- }
-}
-
-func TestGrandfathered(t *testing.T) {
- for _, tt := range []struct{ in, out string }{
- {"art-lojban", "jbo"},
- {"i-ami", "ami"},
- {"i-bnn", "bnn"},
- {"i-hak", "hak"},
- {"i-klingon", "tlh"},
- {"i-lux", "lb"},
- {"i-navajo", "nv"},
- {"i-pwn", "pwn"},
- {"i-tao", "tao"},
- {"i-tay", "tay"},
- {"i-tsu", "tsu"},
- {"no-bok", "nb"},
- {"no-nyn", "nn"},
- {"sgn-BE-FR", "sfb"},
- {"sgn-BE-NL", "vgt"},
- {"sgn-CH-DE", "sgg"},
- {"sgn-ch-de", "sgg"},
- {"zh-guoyu", "cmn"},
- {"zh-hakka", "hak"},
- {"zh-min-nan", "nan"},
- {"zh-xiang", "hsn"},
-
- // Grandfathered tags with no modern replacement will be converted as follows:
- {"cel-gaulish", "xtg-x-cel-gaulish"},
- {"en-GB-oed", "en-GB-oxendict"},
- {"en-gb-oed", "en-GB-oxendict"},
- {"i-default", "en-x-i-default"},
- {"i-enochian", "und-x-i-enochian"},
- {"i-mingo", "see-x-i-mingo"},
- {"zh-min", "nan-x-zh-min"},
-
- {"root", "und"},
- {"en_US_POSIX", "en-US-u-va-posix"},
- {"en_us_posix", "en-US-u-va-posix"},
- {"en-us-posix", "en-US-u-va-posix"},
- } {
- got := Raw.Make(tt.in)
- want := Raw.MustParse(tt.out)
- if got != want {
- t.Errorf("%s: got %q; want %q", tt.in, got, want)
- }
- }
-}
-
-func TestRegionID(t *testing.T) {
- tests := []struct {
- in, out string
- }{
- {"_ ", ""},
- {"_000", ""},
- {"419", "419"},
- {"AA", "AA"},
- {"ATF", "TF"},
- {"HV", "HV"},
- {"CT", "CT"},
- {"DY", "DY"},
- {"IC", "IC"},
- {"FQ", "FQ"},
- {"JT", "JT"},
- {"ZZ", "ZZ"},
- {"EU", "EU"},
- {"QO", "QO"},
- {"FX", "FX"},
- }
- for i, tt := range tests {
- if tt.in[0] == '_' {
- id := tt.in[1:]
- if _, err := getRegionID(b(id)); err == nil {
- t.Errorf("%d:err(%s): found nil; want error", i, id)
- }
- continue
- }
- want, _ := getRegionID(b(tt.in))
- if s := want.String(); s != tt.out {
- t.Errorf("%d:%s: found %q; want %q", i, tt.in, s, tt.out)
- }
- if len(tt.in) == 2 {
- want, _ := getRegionISO2(b(tt.in))
- if s := want.String(); s != tt.out {
- t.Errorf("%d:getISO2(%s): found %q; want %q", i, tt.in, s, tt.out)
- }
- }
- }
-}
-
-func TestRegionType(t *testing.T) {
- for _, tt := range []struct {
- r string
- t byte
- }{
- {"NL", bcp47Region | ccTLD},
- {"EU", bcp47Region | ccTLD}, // exceptionally reserved
- {"AN", bcp47Region | ccTLD}, // transitionally reserved
-
- {"DD", bcp47Region}, // deleted in ISO, deprecated in BCP 47
- {"NT", bcp47Region}, // transitionally reserved, deprecated in BCP 47
-
- {"XA", iso3166UserAssigned | bcp47Region},
- {"ZZ", iso3166UserAssigned | bcp47Region},
- {"AA", iso3166UserAssigned | bcp47Region},
- {"QO", iso3166UserAssigned | bcp47Region},
- {"QM", iso3166UserAssigned | bcp47Region},
- {"XK", iso3166UserAssigned | bcp47Region},
-
- {"CT", 0}, // deleted in ISO, not in BCP 47, canonicalized in CLDR
- } {
- r := MustParseRegion(tt.r)
- if tp := r.typ(); tp != tt.t {
- t.Errorf("Type(%s): got %x; want %x", tt.r, tp, tt.t)
- }
- }
-}
-
-func TestRegionISO3(t *testing.T) {
- tests := []struct {
- from, iso3, to string
- }{
- {" ", "ZZZ", "ZZ"},
- {"000", "ZZZ", "ZZ"},
- {"AA", "AAA", ""},
- {"CT", "CTE", ""},
- {"DY", "DHY", ""},
- {"EU", "QUU", ""},
- {"HV", "HVO", ""},
- {"IC", "ZZZ", "ZZ"},
- {"JT", "JTN", ""},
- {"PZ", "PCZ", ""},
- {"QU", "QUU", "EU"},
- {"QO", "QOO", ""},
- {"YD", "YMD", ""},
- {"FQ", "ATF", "TF"},
- {"TF", "ATF", ""},
- {"FX", "FXX", ""},
- {"ZZ", "ZZZ", ""},
- {"419", "ZZZ", "ZZ"},
- }
- for _, tt := range tests {
- r, _ := getRegionID(b(tt.from))
- if s := r.ISO3(); s != tt.iso3 {
- t.Errorf("iso3(%q): found %q; want %q", tt.from, s, tt.iso3)
- }
- if tt.iso3 == "" {
- continue
- }
- want := tt.to
- if tt.to == "" {
- want = tt.from
- }
- r, _ = getRegionID(b(want))
- if id, _ := getRegionISO3(b(tt.iso3)); id != r {
- t.Errorf("%s: found %q; want %q", tt.iso3, id, want)
- }
- }
-}
-
-func TestRegionM49(t *testing.T) {
- fromTests := []struct {
- m49 int
- id string
- }{
- {0, ""},
- {-1, ""},
- {1000, ""},
- {10000, ""},
-
- {001, "001"},
- {104, "MM"},
- {180, "CD"},
- {230, "ET"},
- {231, "ET"},
- {249, "FX"},
- {250, "FR"},
- {276, "DE"},
- {278, "DD"},
- {280, "DE"},
- {419, "419"},
- {626, "TL"},
- {736, "SD"},
- {840, "US"},
- {854, "BF"},
- {891, "CS"},
- {899, ""},
- {958, "AA"},
- {966, "QT"},
- {967, "EU"},
- {999, "ZZ"},
- }
- for _, tt := range fromTests {
- id, err := getRegionM49(tt.m49)
- if want, have := err != nil, tt.id == ""; want != have {
- t.Errorf("error(%d): have %v; want %v", tt.m49, have, want)
- continue
- }
- r, _ := getRegionID(b(tt.id))
- if r != id {
- t.Errorf("region(%d): have %s; want %s", tt.m49, id, r)
- }
- }
-
- toTests := []struct {
- m49 int
- id string
- }{
- {0, "000"},
- {0, "IC"}, // Some codes don't have an ID
-
- {001, "001"},
- {104, "MM"},
- {104, "BU"},
- {180, "CD"},
- {180, "ZR"},
- {231, "ET"},
- {250, "FR"},
- {249, "FX"},
- {276, "DE"},
- {278, "DD"},
- {419, "419"},
- {626, "TL"},
- {626, "TP"},
- {729, "SD"},
- {826, "GB"},
- {840, "US"},
- {854, "BF"},
- {891, "YU"},
- {891, "CS"},
- {958, "AA"},
- {966, "QT"},
- {967, "EU"},
- {967, "QU"},
- {999, "ZZ"},
- // For codes that don't have an M49 code use the replacement value,
- // if available.
- {854, "HV"}, // maps to Burkino Faso
- }
- for _, tt := range toTests {
- r, _ := getRegionID(b(tt.id))
- if r.M49() != tt.m49 {
- t.Errorf("m49(%q): have %d; want %d", tt.id, r.M49(), tt.m49)
- }
- }
-}
-
-func TestRegionDeprecation(t *testing.T) {
- tests := []struct{ in, out string }{
- {"BU", "MM"},
- {"BUR", "MM"},
- {"CT", "KI"},
- {"DD", "DE"},
- {"DDR", "DE"},
- {"DY", "BJ"},
- {"FX", "FR"},
- {"HV", "BF"},
- {"JT", "UM"},
- {"MI", "UM"},
- {"NH", "VU"},
- {"NQ", "AQ"},
- {"PU", "UM"},
- {"PZ", "PA"},
- {"QU", "EU"},
- {"RH", "ZW"},
- {"TP", "TL"},
- {"UK", "GB"},
- {"VD", "VN"},
- {"WK", "UM"},
- {"YD", "YE"},
- {"NL", "NL"},
- }
- for _, tt := range tests {
- rIn, _ := getRegionID([]byte(tt.in))
- rOut, _ := getRegionISO2([]byte(tt.out))
- r := normRegion(rIn)
- if rOut == rIn && r != 0 {
- t.Errorf("%s: was %q; want %q", tt.in, r, tt.in)
- }
- if rOut != rIn && r != rOut {
- t.Errorf("%s: was %q; want %q", tt.in, r, tt.out)
- }
-
- }
-}
-
-func TestGetScriptID(t *testing.T) {
- idx := tag.Index("0000BbbbDdddEeeeZzzz\xff\xff\xff\xff")
- tests := []struct {
- in string
- out scriptID
- }{
- {" ", 0},
- {" ", 0},
- {" ", 0},
- {"", 0},
- {"Aaaa", 0},
- {"Bbbb", 1},
- {"Dddd", 2},
- {"dddd", 2},
- {"dDDD", 2},
- {"Eeee", 3},
- {"Zzzz", 4},
- }
- for i, tt := range tests {
- if id, err := getScriptID(idx, b(tt.in)); id != tt.out {
- t.Errorf("%d:%s: found %d; want %d", i, tt.in, id, tt.out)
- } else if id == 0 && err == nil {
- t.Errorf("%d:%s: no error; expected one", i, tt.in)
- }
- }
-}
-
-func TestIsPrivateUse(t *testing.T) {
- type test struct {
- s string
- private bool
- }
- tests := []test{
- {"en", false},
- {"und", false},
- {"pzn", false},
- {"qaa", true},
- {"qtz", true},
- {"qua", false},
- }
- for i, tt := range tests {
- x, _ := getLangID([]byte(tt.s))
- if b := x.IsPrivateUse(); b != tt.private {
- t.Errorf("%d: langID.IsPrivateUse(%s) was %v; want %v", i, tt.s, b, tt.private)
- }
- }
- tests = []test{
- {"001", false},
- {"419", false},
- {"899", false},
- {"900", false},
- {"957", false},
- {"958", true},
- {"AA", true},
- {"AC", false},
- {"EU", false}, // CLDR grouping, exceptionally reserved in ISO.
- {"QU", true}, // Canonicalizes to EU, User-assigned in ISO.
- {"QO", true}, // CLDR grouping, User-assigned in ISO.
- {"QA", false},
- {"QM", true},
- {"QZ", true},
- {"XA", true},
- {"XK", true}, // Assigned to Kosovo in CLDR, User-assigned in ISO.
- {"XZ", true},
- {"ZW", false},
- {"ZZ", true},
- }
- for i, tt := range tests {
- x, _ := getRegionID([]byte(tt.s))
- if b := x.IsPrivateUse(); b != tt.private {
- t.Errorf("%d: regionID.IsPrivateUse(%s) was %v; want %v", i, tt.s, b, tt.private)
- }
- }
- tests = []test{
- {"Latn", false},
- {"Laaa", false}, // invalid
- {"Qaaa", true},
- {"Qabx", true},
- {"Qaby", false},
- {"Zyyy", false},
- {"Zzzz", false},
- }
- for i, tt := range tests {
- x, _ := getScriptID(script, []byte(tt.s))
- if b := x.IsPrivateUse(); b != tt.private {
- t.Errorf("%d: scriptID.IsPrivateUse(%s) was %v; want %v", i, tt.s, b, tt.private)
- }
- }
-}
OSDN Git Service
